ZGlmZiAtLWdpdCBhL0NSRURJVFMgYi9DUkVESVRTCmluZGV4IDFkMzlhNmQuLmRjYTZhYmMgMTAwNjQ0Ci0tLSBhL0NSRURJVFMKKysrIGIvQ1JFRElUUwpAQCAtMTY3Nyw3ICsxNjc3LDcgQEAKIEQ6IEFzc29ydGVkIFZJQSB4ODYgc3VwcG9ydC4KIEQ6IDIuNSBBR1BHQVJUIG92ZXJoYXVsLgogRDogQ1BVRlJFUSBtYWludGVuYW5jZS4KLUQ6IEZlZG9yYSBrZXJuZWwgbWFpbnRhaW5lbmNlLgorRDogRmVkb3JhIGtlcm5lbCBtYWludGVuYW5jZS4KIEQ6IE1pc2MvT3RoZXIuCiBTOiAzMTQgTGl0dGxldG9uIFJkLCBXZXN0Zm9yZCwgTUEgMDE4ODYsIFVTQQogCkBAIC0zMjExLDcgKzMyMTEsNyBAQAogRToganNpbW1vbnNAaW5mcmFkZWFkLm9yZwogRToganNpbW1vbnNAdXNlcnMuc2YubmV0IAogRDogRnJhbWUgYnVmZmVyIGRldmljZSBtYWludGFpbmVyCi1EOiBpbnB1dCBsYXllciBkZXZlbG9wZW1lbnQgCitEOiBpbnB1dCBsYXllciBkZXZlbG9wbWVudAogRDogdHR5L2NvbnNvbGUgbGF5ZXIKIEQ6IHZhcmlvdXMgbWlwc2VsIGRldmljZXMgCiBTOiAxMTUgQ2FybWVsIEF2ZW51ZSAKQEAgLTMyOTAsNyArMzI5MCw3IEBACiBOOiBNYW5mcmVkIFNwcmF1bAogRTogbWFuZnJlZEBjb2xvcmZ1bGxpZmUuY29tCiBXOiBodHRwOi8vd3d3LmNvbG9yZnVsbGlmZS5jb20vfm1hbmZyZWQKLUQ6IExvdHMgb2YgdGlueSBoYWNrcy4gTGFyZ2VyIGltcHJvdm1lbnRzIHRvIFN5c1YgSVBDIG1zZywKK0Q6IExvdHMgb2YgdGlueSBoYWNrcy4gTGFyZ2VyIGltcHJvdmVtZW50cyB0byBTeXNWIElQQyBtc2csCiBEOiBzbGFiLCBwaXBlLCBzZWxlY3QuCiBTOiA3MTcwMSBTY2h3aWViZXJkaW5nZW4KIFM6IEdlcm1hbnkKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtYnVzLWNzcyBiL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtYnVzLWNzcwppbmRleCBiNTg1ZWMyLi4yOTc5YzQwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWJ1cy1jc3MKKysrIGIvRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1idXMtY3NzCkBAIC0yOSw3ICsyOSw3IEBACiAJCWxpbnV4LXMzOTBAdmdlci5rZXJuZWwub3JnCiBEZXNjcmlwdGlvbjoJQ29udGFpbnMgdGhlIFBJTS9QQU0vUE9NIHZhbHVlcywgYXMgcmVwb3J0ZWQgYnkgdGhlCiAJCWNoYW5uZWwgc3Vic3lzdGVtIHdoZW4gbGFzdCBxdWVyaWVkIGJ5IHRoZSBjb21tb24gSS9PCi0JCWxheWVyICh0aGlzIGltcGxpZXMgdGhhdCB0aGlzIGF0dHJpYnV0ZSBpcyBub3QgbmVjY2Vzc2FyaWx5CisJCWxheWVyICh0aGlzIGltcGxpZXMgdGhhdCB0aGlzIGF0dHJpYnV0ZSBpcyBub3QgbmVjZXNzYXJpbHkKIAkJaW4gc3luYyB3aXRoIHRoZSB2YWx1ZXMgY3VycmVudCBpbiB0aGUgY2hhbm5lbCBzdWJzeXN0ZW0pLgogCQlOb3RlOiBUaGlzIGlzIGFuIEkvTy1zdWJjaGFubmVsIHNwZWNpZmljIGF0dHJpYnV0ZS4KIFVzZXJzOgkJczM5MC10b29scywgSEFMCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWNsYXNzLWxlZCBiL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtY2xhc3MtbGVkCmluZGV4IGVkZmY2NjMuLjM2NDZlYzggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtY2xhc3MtbGVkCisrKyBiL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtY2xhc3MtbGVkCkBAIC0zMyw1ICszMyw1IEBACiBEZXNjcmlwdGlvbjoKIAkJSW52ZXJ0IHRoZSBMRUQgb24vb2ZmIHN0YXRlLiBUaGlzIHBhcmFtZXRlciBpcyBzcGVjaWZpYyB0bwogCQlncGlvIGFuZCBiYWNrbGlnaHQgdHJpZ2dlcnMuIEluIGNhc2Ugb2YgdGhlIGJhY2tsaWdodCB0cmlnZ2VyLAotCQlpdCBpcyB1c2VmdWxsIHdoZW4gZHJpdmluZyBhIExFRCB3aGljaCBpcyBpbnRlbmRlZCB0byBpbmRpY2F0ZQorCQlpdCBpcyB1c2VmdWwgd2hlbiBkcml2aW5nIGEgTEVEIHdoaWNoIGlzIGludGVuZGVkIHRvIGluZGljYXRlCiAJCWEgZGV2aWNlIGluIGEgc3RhbmRieSBsaWtlIHN0YXRlLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2R2Yi9kdmJwcm9wZXJ0eS54bWwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2R2YnByb3BlcnR5LnhtbAppbmRleCA1ZjU3YzdjLi45N2YzOTdlIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2R2YnByb3BlcnR5LnhtbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2R2YnByb3BlcnR5LnhtbApAQCAtNDAsNyArNDAsNyBAQAogCiAJCQk8cGFyYT5DZW50cmFsIGZyZXF1ZW5jeSBvZiB0aGUgY2hhbm5lbC48L3BhcmE+CiAKLQkJCTxwYXJhPkZvciBJU0RCLVQgdGhlIGNoYW5uZWxzIGFyZSB1c2FsbHkgdHJhbnNtaXR0ZWQgd2l0aCBhbiBvZmZzZXQgb2YgMTQza0h6LiBFLmcuIGEKKwkJCTxwYXJhPkZvciBJU0RCLVQgdGhlIGNoYW5uZWxzIGFyZSB1c3VhbGx5IHRyYW5zbWl0dGVkIHdpdGggYW4gb2Zmc2V0IG9mIDE0M2tIei4gRS5nLiBhCiAJCQkJdmFsaWQgZnJlcXVuY3kgY291bGQgYmUgNDc0MTQzIGtIei4gVGhlIHN0ZXBwaW5nIGlzIGJvdW5kIHRvIHRoZSBiYW5kd2lkdGggb2YKIAkJCQl0aGUgY2hhbm5lbCB3aGljaCBpcyA2TUh6LjwvcGFyYT4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2R2Yi9mcm9udGVuZC54bWwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2Zyb250ZW5kLnhtbAppbmRleCA3OGQ3NTZkLi42MGM2OTc2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2Zyb250ZW5kLnhtbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2Zyb250ZW5kLnhtbApAQCAtMTM5LDcgKzEzOSw3IEBACiA8c2VjdGlvbiBpZD0iZnJvbnRlbmRfc2VjX3RvbmUiPgogPHRpdGxlPlNFQyBjb250aW51b3VzIHRvbmU8L3RpdGxlPgogCi08cGFyYT5UaGUgY29udGlub3VzIDIyS0h6IHRvbmUgaXMgdXN1YWxseSB1c2VkIHdpdGggbm9uLURpU0VxQyBjYXBhYmxlIExOQnMgdG8gc3dpdGNoIHRoZQorPHBhcmE+VGhlIGNvbnRpbnVvdXMgMjJLSHogdG9uZSBpcyB1c3VhbGx5IHVzZWQgd2l0aCBub24tRGlTRXFDIGNhcGFibGUgTE5CcyB0byBzd2l0Y2ggdGhlCiBoaWdoL2xvdyBiYW5kIG9mIGEgZHVhbC1iYW5kIExOQi4gV2hlbiB1c2luZyBEaVNFcUMgZXB1aXBtZW50IHRoaXMgdm9sdGFnZSBoYXMgdG8KIGJlIHN3aXRjaGVkIGNvbnNpc3RlbnRseSB0byB0aGUgRGlTRXFDIGNvbW1hbmRzIGFzIGRlc2NyaWJlZCBpbiB0aGUgRGlTRXFDCiBzcGVjLjwvcGFyYT4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9rZXJuZWwtbG9ja2luZy50bXBsIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2tlcm5lbC1sb2NraW5nLnRtcGwKaW5kZXggZjY2ZjRkZi4uNjdlN2FiNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2tlcm5lbC1sb2NraW5nLnRtcGwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2tlcm5lbC1sb2NraW5nLnRtcGwKQEAgLTE3NjMsNyArMTc2Myw3IEBACiBUaGVyZSBpcyBhIGZ1cnRodXIgb3B0aW1pemF0aW9uIHBvc3NpYmxlIGhlcmU6IHJlbWVtYmVyIG91ciBvcmlnaW5hbAogY2FjaGUgY29kZSwgd2hlcmUgdGhlcmUgd2VyZSBubyByZWZlcmVuY2UgY291bnRzIGFuZCB0aGUgY2FsbGVyIHNpbXBseQogaGVsZCB0aGUgbG9jayB3aGVuZXZlciB1c2luZyB0aGUgb2JqZWN0PyAgVGhpcyBpcyBzdGlsbCBwb3NzaWJsZTogaWYKLXlvdSBob2xkIHRoZSBsb2NrLCBub29uZSBjYW4gZGVsZXRlIHRoZSBvYmplY3QsIHNvIHlvdSBkb24ndCBuZWVkIHRvCit5b3UgaG9sZCB0aGUgbG9jaywgbm8gb25lIGNhbiBkZWxldGUgdGhlIG9iamVjdCwgc28geW91IGRvbid0IG5lZWQgdG8KIGdldCBhbmQgcHV0IHRoZSByZWZlcmVuY2UgY291bnQuCiA8L3BhcmE+CiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9saWJhdGEudG1wbCBiL0RvY3VtZW50YXRpb24vRG9jQm9vay9saWJhdGEudG1wbAppbmRleCA4YzU0MTFjLi5jZGQxYmI5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svbGliYXRhLnRtcGwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2xpYmF0YS50bXBsCkBAIC0xMDMyLDcgKzEwMzIsNyBAQAogCSAgIDxsaXN0aXRlbT4KIAkgICA8cGFyYT4KIAkgICBUaGlzIGlzIGluZGljYXRlZCBieSBJQ1JDIGJpdCBpbiB0aGUgRVJST1IgcmVnaXN0ZXIgYW5kCi0JICAgbWVhbnMgdGhhdCBjb3JydXB0aW9uIG9jY3VycmVkIGR1cmluZyBkYXRhIHRyYW5zZmVyLiAgVXB0bworCSAgIG1lYW5zIHRoYXQgY29ycnVwdGlvbiBvY2N1cnJlZCBkdXJpbmcgZGF0YSB0cmFuc2Zlci4gIFVwIHRvCiAJICAgQVRBL0FUQVBJLTcsIHRoZSBzdGFuZGFyZCBzcGVjaWZpZXMgdGhhdCB0aGlzIGJpdCBpcyBvbmx5CiAJICAgYXBwbGljYWJsZSB0byBVRE1BIHRyYW5zZmVycyBidXQgQVRBL0FUQVBJLTggZHJhZnQgcmV2aXNpb24KIAkgICAxZiBzYXlzIHRoYXQgdGhlIGJpdCBtYXkgYmUgYXBwbGljYWJsZSB0byBtdWx0aXdvcmQgRE1BIGFuZApAQCAtMTA0NSwxMCArMTA0NSwxMCBAQAogCSAgIDx0ZXJtPkFCUlQgZXJyb3IgZHVyaW5nIGRhdGEgdHJhbnNmZXIgb3Igb24gY29tcGxldGlvbjwvdGVybT4KIAkgICA8bGlzdGl0ZW0+CiAJICAgPHBhcmE+Ci0JICAgVXB0byBBVEEvQVRBUEktNywgdGhlIHN0YW5kYXJkIHNwZWNpZmllcyB0aGF0IEFCUlQgY291bGQgYmUKKwkgICBVcCB0byBBVEEvQVRBUEktNywgdGhlIHN0YW5kYXJkIHNwZWNpZmllcyB0aGF0IEFCUlQgY291bGQgYmUKIAkgICBzZXQgb24gSUNSQyBlcnJvcnMgYW5kIG9uIGNhc2VzIHdoZXJlIGEgZGV2aWNlIGlzIG5vdCBhYmxlCiAJICAgdG8gY29tcGxldGUgYSBjb21tYW5kLiAgQ29tYmluZWQgd2l0aCB0aGUgZmFjdCB0aGF0IE1XRE1BCi0JICAgYW5kIFBJTyB0cmFuc2ZlciBlcnJvcnMgYXJlbid0IGFsbG93ZWQgdG8gdXNlIElDUkMgYml0IHVwdG8KKwkgICBhbmQgUElPIHRyYW5zZmVyIGVycm9ycyBhcmVuJ3QgYWxsb3dlZCB0byB1c2UgSUNSQyBiaXQgdXAgdG8KIAkgICBBVEEvQVRBUEktNywgaXQgc2VlbXMgdG8gaW1wbHkgdGhhdCBBQlJUIGJpdCBhbG9uZSBjb3VsZAogCSAgIGluZGljYXRlIHRyYW5mZXIgZXJyb3JzLgogCSAgIDwvcGFyYT4KQEAgLTExMjIsNyArMTEyMiw3IEBACiAJPHBhcmE+CiAJRGVwZW5kaW5nIG9uIGNvbW1hbmRzLCBub3QgYWxsIFNUQVRVUy9FUlJPUiBiaXRzIGFyZQogCWFwcGxpY2FibGUuICBUaGVzZSBub24tYXBwbGljYWJsZSBiaXRzIGFyZSBtYXJrZWQgd2l0aAotCSZxdW90O25hJnF1b3Q7IGluIHRoZSBvdXRwdXQgZGVzY3JpcHRpb25zIGJ1dCB1cHRvIEFUQS9BVEFQSS03CisJJnF1b3Q7bmEmcXVvdDsgaW4gdGhlIG91dHB1dCBkZXNjcmlwdGlvbnMgYnV0IHVwIHRvIEFUQS9BVEFQSS03CiAJbm8gZGVmaW5pdGlvbiBvZiAmcXVvdDtuYSZxdW90OyBjYW4gYmUgZm91bmQuICBIb3dldmVyLAogCUFUQS9BVEFQSS04IGRyYWZ0IHJldmlzaW9uIDFmIGRlc2NyaWJlcyAmcXVvdDtOL0EmcXVvdDsgYXMKIAlmb2xsb3dzLgpAQCAtMTUwNyw3ICsxNTA3LDcgQEAKIAogCTxsaXN0aXRlbT4KIAk8cGFyYT4KLQlDSFMgc2V0IHVwIHdpdGggSU5JVElBTElaRSBERVZJQ0UgUEFSQU1FVEVSUyAoc2VsZG9tbHkgdXNlZCkKKwlDSFMgc2V0IHVwIHdpdGggSU5JVElBTElaRSBERVZJQ0UgUEFSQU1FVEVSUyAoc2VsZG9tIHVzZWQpCiAJPC9wYXJhPgogCTwvbGlzdGl0ZW0+CiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9tdGRuYW5kLnRtcGwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svbXRkbmFuZC50bXBsCmluZGV4IDYyMGViM2YuLjZmMjQyZDUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9tdGRuYW5kLnRtcGwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL210ZG5hbmQudG1wbApAQCAtNDg1LDcgKzQ4NSw3IEBACiAJCQkJUmVlZC1Tb2xvbW9uIGxpYnJhcnkuCiAJCQk8L3BhcmE+CiAJCQk8cGFyYT4KLQkJCQlUaGUgRUNDIGJ5dGVzIG11c3QgYmUgcGxhY2VkIGltbWlkaWF0ZWx5IGFmdGVyIHRoZSBkYXRhCisJCQkJVGhlIEVDQyBieXRlcyBtdXN0IGJlIHBsYWNlZCBpbW1lZGlhdGVseSBhZnRlciB0aGUgZGF0YQogCQkJCWJ5dGVzIGluIG9yZGVyIHRvIG1ha2UgdGhlIHN5bmRyb21lIGdlbmVyYXRvciB3b3JrLiBUaGlzCiAJCQkJaXMgY29udHJhcnkgdG8gdGhlIHVzdWFsIGxheW91dCB1c2VkIGJ5IHNvZnR3YXJlIEVDQy4gVGhlCiAJCQkJc2VwYXJhdGlvbiBvZiBkYXRhIGFuZCBvdXQgb2YgYmFuZCBhcmVhIGlzIG5vdCBsb25nZXIKQEAgLTYyOSw3ICs2MjksNyBAQAogCQkJCWhvbGRzIHRoZSBiYWQgYmxvY2sgdGFibGUuIFN0b3JlIGEgcG9pbnRlciB0byB0aGUgcGF0dGVybiAgCiAJCQkJaW4gdGhlIHBhdHRlcm4gZmllbGQuIEZ1cnRoZXIgdGhlIGxlbmd0aCBvZiB0aGUgcGF0dGVybiBoYXMgdG8gYmUgCiAJCQkJc3RvcmVkIGluIGxlbiBhbmQgdGhlIG9mZnNldCBpbiB0aGUgc3BhcmUgYXJlYSBtdXN0IGJlIGdpdmVuCi0JCQkJaW4gdGhlIG9mZnMgbWVtYmVyIG9mIHRoZSBuYW5kX2JidF9kZXNjciBzdHVjdHVyZS4gRm9yIG1pcnJvcmVkCisJCQkJaW4gdGhlIG9mZnMgbWVtYmVyIG9mIHRoZSBuYW5kX2JidF9kZXNjciBzdHJ1Y3R1cmUuIEZvciBtaXJyb3JlZAogCQkJCWJhZCBibG9jayB0YWJsZXMgZGlmZmVyZW50IHBhdHRlcm5zIGFyZSBtYW5kYXRvcnkuPC9wYXJhPjwvbGlzdGl0ZW0+CiAJCQkJPGxpc3RpdGVtPjxwYXJhPlRhYmxlIGNyZWF0aW9uPC9wYXJhPgogCQkJCTxwYXJhPlNldCB0aGUgb3B0aW9uIE5BTkRfQkJUX0NSRUFURSB0byBlbmFibGUgdGhlIHRhYmxlIGNyZWF0aW9uCkBAIC02NDgsNyArNjQ4LDcgQEAKIAkJCQk8bGlzdGl0ZW0+PHBhcmE+VGFibGUgdmVyc2lvbiBjb250cm9sPC9wYXJhPgogCQkJCTxwYXJhPlNldCB0aGUgb3B0aW9uIE5BTkRfQkJUX1ZFUlNJT04gdG8gZW5hYmxlIHRoZSB0YWJsZSB2ZXJzaW9uIGNvbnRyb2wuCiAJCQkJSXQncyBoaWdobHkgcmVjb21tZW5kZWQgdG8gZW5hYmxlIHRoaXMgZm9yIG1pcnJvcmVkIHRhYmxlcyB3aXRoIHdyaXRlCi0JCQkJc3VwcG9ydC4gSXQgbWFrZXMgc3VyZSB0aGF0IHRoZSByaXNrIG9mIGxvb3NpbmcgdGhlIGJhZCBibG9jaworCQkJCXN1cHBvcnQuIEl0IG1ha2VzIHN1cmUgdGhhdCB0aGUgcmlzayBvZiBsb3NpbmcgdGhlIGJhZCBibG9jawogCQkJCXRhYmxlIGluZm9ybWF0aW9uIGlzIHJlZHVjZWQgdG8gdGhlIGxvc3Mgb2YgdGhlIGluZm9ybWF0aW9uIGFib3V0IHRoZQogCQkJCW9uZSB3b3JuIG91dCBibG9jayB3aGljaCBzaG91bGQgYmUgbWFya2VkIGJhZC4gVGhlIHZlcnNpb24gaXMgc3RvcmVkIGluCiAJCQkJNCBjb25zZWN1dGl2ZSBieXRlcyBpbiB0aGUgc3BhcmUgYXJlYSBvZiB0aGUgZGV2aWNlLiBUaGUgcG9zaXRpb24gb2YKQEAgLTEwNjAsMTkgKzEwNjAsMTkgQEAKIDxyb3c+CiA8ZW50cnk+MHgzRDwvZW50cnk+CiA8ZW50cnk+RUNDIGJ5dGUgMjE8L2VudHJ5PgotPGVudHJ5PkVycm9yIGNvcnJlY3Rpb24gY29kZSBieXRlIDAgb2YgdGhlIGVpZ3RoIDI1NiBCeXRlcyBvZiBkYXRhCis8ZW50cnk+RXJyb3IgY29ycmVjdGlvbiBjb2RlIGJ5dGUgMCBvZiB0aGUgZWlnaHRoIDI1NiBCeXRlcyBvZiBkYXRhCiBpbiB0aGlzIHBhZ2U8L2VudHJ5PgogPC9yb3c+CiA8cm93PgogPGVudHJ5PjB4M0U8L2VudHJ5PgogPGVudHJ5PkVDQyBieXRlIDIyPC9lbnRyeT4KLTxlbnRyeT5FcnJvciBjb3JyZWN0aW9uIGNvZGUgYnl0ZSAxIG9mIHRoZSBlaWd0aCAyNTYgQnl0ZXMgb2YgZGF0YQorPGVudHJ5PkVycm9yIGNvcnJlY3Rpb24gY29kZSBieXRlIDEgb2YgdGhlIGVpZ2h0aCAyNTYgQnl0ZXMgb2YgZGF0YQogaW4gdGhpcyBwYWdlPC9lbnRyeT4KIDwvcm93PgogPHJvdz4KIDxlbnRyeT4weDNGPC9lbnRyeT4KIDxlbnRyeT5FQ0MgYnl0ZSAyMzwvZW50cnk+Ci08ZW50cnk+RXJyb3IgY29ycmVjdGlvbiBjb2RlIGJ5dGUgMiBvZiB0aGUgZWlndGggMjU2IEJ5dGVzIG9mIGRhdGEKKzxlbnRyeT5FcnJvciBjb3JyZWN0aW9uIGNvZGUgYnl0ZSAyIG9mIHRoZSBlaWdodGggMjU2IEJ5dGVzIG9mIGRhdGEKIGluIHRoaXMgcGFnZTwvZW50cnk+CiA8L3Jvdz4KIDwvdGJvZHk+PC90Z3JvdXA+PC9pbmZvcm1hbHRhYmxlPgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3JlZ3VsYXRvci50bXBsIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3JlZ3VsYXRvci50bXBsCmluZGV4IDUzZjRmOGQuLjM0NmU1NTIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9yZWd1bGF0b3IudG1wbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svcmVndWxhdG9yLnRtcGwKQEAgLTI2Nyw4ICsyNjcsOCBAQAogICAgICA8c2VjdDEgaWQ9Im1hY2hpbmUtY29uc3RyYWludCI+CiAgICAgICAgPHRpdGxlPkNvbnN0cmFpbnRzPC90aXRsZT4KICAgICAgICA8cGFyYT4KLQkgQXMgd2VsbCBhcyBkZWZpbmluaW5nIHRoZSBjb25uZWN0aW9ucyB0aGUgbWFjaGluZSBpbnRlcmZhY2UKLQkgYWxzbyBwcm92aWRlcyBjb25zdHJhaW50cyBkZWZpbmluaW5nIHRoZSBvcGVyYXRpb25zIHRoYXQKKwkgQXMgd2VsbCBhcyBkZWZpbmluZyB0aGUgY29ubmVjdGlvbnMgdGhlIG1hY2hpbmUgaW50ZXJmYWNlCisJIGFsc28gcHJvdmlkZXMgY29uc3RyYWludHMgZGVmaW5pbmcgdGhlIG9wZXJhdGlvbnMgdGhhdAogCSBjbGllbnRzIGFyZSBhbGxvd2VkIHRvIHBlcmZvcm0gYW5kIHRoZSBwYXJhbWV0ZXJzIHRoYXQgbWF5IGJlCiAJIHNldC4gIFRoaXMgaXMgcmVxdWlyZWQgc2luY2UgZ2VuZXJhbGx5IHJlZ3VsYXRvciBkZXZpY2VzIHdpbGwKIAkgb2ZmZXIgbW9yZSBmbGV4aWJpbGl0eSB0aGFuIGl0IGlzIHNhZmUgdG8gdXNlIG9uIGEgZ2l2ZW4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay91aW8taG93dG8udG1wbCBiL0RvY3VtZW50YXRpb24vRG9jQm9vay91aW8taG93dG8udG1wbAppbmRleCBiNDY2NWI5Li43YzRiNTE0ZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Vpby1ob3d0by50bXBsCisrKyBiL0RvY3VtZW50YXRpb24vRG9jQm9vay91aW8taG93dG8udG1wbApAQCAtNzk3LDcgKzc5Nyw3IEBACiAJcGVyZm9ybSBzb21lIGluaXRpYWxpemF0aW9uLiBBZnRlciB0aGF0LCB5b3VyIGhhcmR3YXJlCiAJc3RhcnRzIHdvcmtpbmcgYW5kIHdpbGwgZ2VuZXJhdGUgYW4gaW50ZXJydXB0IGFzIHNvb24KIAlhcyBpdCdzIGZpbmlzaGVkLCBoYXMgc29tZSBkYXRhIGF2YWlsYWJsZSwgb3IgbmVlZHMgeW91cgotCWF0dGVudGlvbiBiZWNhdXNlIGFuIGVycm9yIG9jY3VyZWQuCisJYXR0ZW50aW9uIGJlY2F1c2UgYW4gZXJyb3Igb2NjdXJyZWQuCiAJPC9wYXJhPgogCTxwYXJhPgogCTxmaWxlbmFtZT4vZGV2L3Vpb1g8L2ZpbGVuYW1lPiBpcyBhIHJlYWQtb25seSBmaWxlLiBBCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdXNiLnRtcGwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdXNiLnRtcGwKaW5kZXggYWYyOTM2MC4uOGQ1N2MxOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3VzYi50bXBsCisrKyBiL0RvY3VtZW50YXRpb24vRG9jQm9vay91c2IudG1wbApAQCAtNjkwLDcgKzY5MCw3IEBACiAJCSAgICA8L3BhcmE+PHBhcmE+CiAJCSAgICBUaGlzIHJlcXVlc3QgbGV0cyBrZXJuZWwgZHJpdmVycyB0YWxrIHRvIHVzZXIgbW9kZSBjb2RlCiAJCSAgICB0aHJvdWdoIGZpbGVzeXN0ZW0gb3BlcmF0aW9ucyBldmVuIHdoZW4gdGhleSBkb24ndCBjcmVhdGUKLQkJICAgIGEgY2hhcmFjdG9yIG9yIGJsb2NrIHNwZWNpYWwgZGV2aWNlLgorCQkgICAgYSBjaGFyYWN0ZXIgb3IgYmxvY2sgc3BlY2lhbCBkZXZpY2UuCiAJCSAgICBJdCdzIGFsc28gYmVlbiB1c2VkIHRvIGRvIHRoaW5ncyBsaWtlIGFzayBkZXZpY2VzIHdoYXQKIAkJICAgIGRldmljZSBzcGVjaWFsIGZpbGUgc2hvdWxkIGJlIHVzZWQuCiAJCSAgICBUd28gcHJlLWRlZmluZWQgaW9jdGxzIGFyZSB1c2VkCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2NvbW1vbi54bWwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2NvbW1vbi54bWwKaW5kZXggZGJhYjc5Yy4uOTAyODcyMSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC9jb21tb24ueG1sCisrKyBiL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvY29tbW9uLnhtbApAQCAtMTAwLDcgKzEwMCw3IEBACiAKICAgICAgIDxwYXJhPkJ5IGNvbnZlbnRpb24gc3lzdGVtIGFkbWluaXN0cmF0b3JzIGNyZWF0ZSB2YXJpb3VzCiBjaGFyYWN0ZXIgZGV2aWNlIHNwZWNpYWwgZmlsZXMgd2l0aCB0aGVzZSBtYWpvciBhbmQgbWlub3IgbnVtYmVycyBpbgotdGhlIDxmaWxlbmFtZT4vZGV2PC9maWxlbmFtZT4gZGlyZWN0b3J5LiBUaGUgbmFtZXMgcmVjb21lbmRlZCBmb3IgdGhlCit0aGUgPGZpbGVuYW1lPi9kZXY8L2ZpbGVuYW1lPiBkaXJlY3RvcnkuIFRoZSBuYW1lcyByZWNvbW1lbmRlZCBmb3IgdGhlCiBkaWZmZXJlbnQgVjRMMiBkZXZpY2UgdHlwZXMgYXJlIGxpc3RlZCBpbiA8eHJlZiBsaW5rZW5kPSJkZXZpY2VzIiAvPi4KIDwvcGFyYT4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC9jb250cm9scy54bWwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2NvbnRyb2xzLnhtbAppbmRleCAyZmFlM2U4Li5hOTIwZWU4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2NvbnRyb2xzLnhtbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2NvbnRyb2xzLnhtbApAQCAtMTI0Myw3ICsxMjQzLDcgQEAKIAkgICAgICA8L3Jvdz48cm93PjxlbnRyeSBzcGFubmFtZT0iZGVzY3IiPk11dGVzIHRoZSBhdWRpbyB3aGVuCiBjYXB0dXJpbmcuIFRoaXMgaXMgbm90IGRvbmUgYnkgbXV0aW5nIGF1ZGlvIGhhcmR3YXJlLCB3aGljaCBjYW4gc3RpbGwKIHByb2R1Y2UgYSBzbGlnaHQgaGlzcywgYnV0IGluIHRoZSBlbmNvZGVyIGl0c2VsZiwgZ3VhcmFudGVlaW5nIGEgZml4ZWQKLWFuZCByZXByb2R1Y2FibGUgYXVkaW8gYml0c3RyZWFtLiAwID0gdW5tdXRlZCwgMSA9IG11dGVkLjwvZW50cnk+CithbmQgcmVwcm9kdWNpYmxlIGF1ZGlvIGJpdHN0cmVhbS4gMCA9IHVubXV0ZWQsIDEgPSBtdXRlZC48L2VudHJ5PgogCSAgICAgIDwvcm93PgogCSAgICAgIDxyb3c+PGVudHJ5PjwvZW50cnk+PC9yb3c+CiAJICAgICAgPHJvdyBpZD0idjRsMi1tcGVnLXZpZGVvLWVuY29kaW5nIj4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvZGV2LXN1YmRldi54bWwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2Rldi1zdWJkZXYueG1sCmluZGV4IDIxY2FmZjYuLjA1YzhmZWYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvZGV2LXN1YmRldi54bWwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC9kZXYtc3ViZGV2LnhtbApAQCAtOTAsNyArOTAsNyBAQAogICAgIHByb2Nlc3NpbmcgaGFyZHdhcmUuPC9wYXJhPgogCiAgICAgPGZpZ3VyZSBpZD0icGlwZWxpbmUtc2NhbGluZyI+Ci0gICAgICA8dGl0bGU+SW1hZ2UgRm9ybWF0IE5lZ290YXRpb24gb24gUGlwZWxpbmVzPC90aXRsZT4KKyAgICAgIDx0aXRsZT5JbWFnZSBGb3JtYXQgTmVnb3RpYXRpb24gb24gUGlwZWxpbmVzPC90aXRsZT4KICAgICAgIDxtZWRpYW9iamVjdD4KIAk8aW1hZ2VvYmplY3Q+CiAJICA8aW1hZ2VkYXRhIGZpbGVyZWY9InBpcGVsaW5lLnBkZiIgZm9ybWF0PSJQUyIgLz4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvbGlidjRsLnhtbCBiL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvbGlidjRsLnhtbAppbmRleCBjMTRmYzNkLi4zY2IxMGVjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2xpYnY0bC54bWwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC9saWJ2NGwueG1sCkBAIC0xNDAsNyArMTQwLDcgQEAKIAkJCTxwYXJhPmludCB2NGwyX2dldF9jb250cm9sKGludCBmZCwgaW50IGNpZCkgLQogVGhpcyBmdW5jdGlvbiByZXR1cm5zIGEgdmFsdWUgb2YgMCAtIDY1NTM1LCBzY2FsZWQgdG8gZnJvbSB0aGUgYWN0dWFsIHJhbmdlCiBvZiB0aGUgZ2l2ZW4gdjRsIGNvbnRyb2wgaWQuIHdoZW4gdGhlIGNpZCBkb2VzIG5vdCBleGlzdCwgY291bGQgbm90IGJlCi1hY2Nlc3NlZCBmb3Igc29tZSByZWFzb24sIG9yIHNvbWUgZXJyb3Igb2NjdXJlZCAwIGlzIHJldHVybmVkLgorYWNjZXNzZWQgZm9yIHNvbWUgcmVhc29uLCBvciBzb21lIGVycm9yIG9jY3VycmVkIDAgaXMgcmV0dXJuZWQuCiA8L3BhcmE+PC9saXN0aXRlbT4KIDwvaXRlbWl6ZWRsaXN0PgogCQk8L3NlY3Rpb24+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL3JlbW90ZV9jb250cm9sbGVycy54bWwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL3JlbW90ZV9jb250cm9sbGVycy54bWwKaW5kZXggM2MzYjY2Ny4uMTYwZTQ2NCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC9yZW1vdGVfY29udHJvbGxlcnMueG1sCisrKyBiL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvcmVtb3RlX2NvbnRyb2xsZXJzLnhtbApAQCAtMTMzLDcgKzEzMyw3IEBACiA8cm93PjxlbnRyeT48Y29uc3RhbnQ+S0VZX0xFRlQ8L2NvbnN0YW50PjwvZW50cnk+PGVudHJ5PkxlZnQga2V5PC9lbnRyeT48ZW50cnk+TEVGVDwvZW50cnk+PC9yb3c+CiA8cm93PjxlbnRyeT48Y29uc3RhbnQ+S0VZX1JJR0hUPC9jb25zdGFudD48L2VudHJ5PjxlbnRyeT5SaWdodCBrZXk8L2VudHJ5PjxlbnRyeT5SSUdIVDwvZW50cnk+PC9yb3c+CiAKLTxyb3c+PGVudHJ5PjxlbXBoYXNpcyByb2xlPSJib2xkIj5NaXNjZWxhbmVvdXMga2V5czwvZW1waGFzaXM+PC9lbnRyeT48L3Jvdz4KKzxyb3c+PGVudHJ5PjxlbXBoYXNpcyByb2xlPSJib2xkIj5NaXNjZWxsYW5lb3VzIGtleXM8L2VtcGhhc2lzPjwvZW50cnk+PC9yb3c+CiAKIDxyb3c+PGVudHJ5Pjxjb25zdGFudD5LRVlfRE9UPC9jb25zdGFudD48L2VudHJ5PjxlbnRyeT5SZXR1cm4gYSBkb3Q8L2VudHJ5PjxlbnRyeT4uPC9lbnRyeT48L3Jvdz4KIDxyb3c+PGVudHJ5Pjxjb25zdGFudD5LRVlfRk48L2NvbnN0YW50PjwvZW50cnk+PGVudHJ5PlNlbGVjdCBhIGZ1bmN0aW9uPC9lbnRyeT48ZW50cnk+RlVOQ1RJT048L2VudHJ5Pjwvcm93PgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3dyaXRpbmctYW4tYWxzYS1kcml2ZXIudG1wbCBiL0RvY3VtZW50YXRpb24vRG9jQm9vay93cml0aW5nLWFuLWFsc2EtZHJpdmVyLnRtcGwKaW5kZXggMGJhMTQ5ZC4uNThjZWQyMyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3dyaXRpbmctYW4tYWxzYS1kcml2ZXIudG1wbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svd3JpdGluZy1hbi1hbHNhLWRyaXZlci50bXBsCkBAIC00Nzg0LDcgKzQ3ODQsNyBAQAogICAgICAgICBGTSByZWdpc3RlcnMgY2FuIGJlIGRpcmVjdGx5IGFjY2Vzc2VkIHRocm91Z2ggdGhlIGRpcmVjdC1GTSBBUEksCiAgICAgICBkZWZpbmVkIGluIDxmaWxlbmFtZT4mbHQ7c291bmQvYXNvdW5kX2ZtLmgmZ3Q7PC9maWxlbmFtZT4uIEluCiAgICAgICBBTFNBIG5hdGl2ZSBtb2RlLCBGTSByZWdpc3RlcnMgYXJlIGFjY2Vzc2VkIHRocm91Z2gKLSAgICAgIHRoZSBIYXJkd2FyZS1EZXBlbmRhbnQgRGV2aWNlIGRpcmVjdC1GTSBleHRlbnNpb24gQVBJLCB3aGVyZWFzIGluCisgICAgICB0aGUgSGFyZHdhcmUtRGVwZW5kZW50IERldmljZSBkaXJlY3QtRk0gZXh0ZW5zaW9uIEFQSSwgd2hlcmVhcyBpbgogICAgICAgT1NTIGNvbXBhdGlibGUgbW9kZSwgRk0gcmVnaXN0ZXJzIGNhbiBiZSBhY2Nlc3NlZCB3aXRoIHRoZSBPU1MKICAgICAgIGRpcmVjdC1GTSBjb21wYXRpYmxlIEFQSSBpbiA8ZmlsZW5hbWU+L2Rldi9kbWZtWDwvZmlsZW5hbWU+IGRldmljZS4gCiAgICAgICA8L3BhcmE+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1BDSS9NU0ktSE9XVE8udHh0IGIvRG9jdW1lbnRhdGlvbi9QQ0kvTVNJLUhPV1RPLnR4dAppbmRleCBkY2Y3YWNjLi4zZjVlMGIwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1BDSS9NU0ktSE9XVE8udHh0CisrKyBiL0RvY3VtZW50YXRpb24vUENJL01TSS1IT1dUTy50eHQKQEAgLTI1Myw4ICsyNTMsOCBAQAogbXVzdCBiZSBhIHBvd2VyIG9mIHR3bykuICBJbiBhZGRpdGlvbiwgdGhlIE1TSSBpbnRlcnJ1cHQgdmVjdG9ycyBtdXN0CiBiZSBhbGxvY2F0ZWQgY29uc2VjdXRpdmVseSwgc28gdGhlIHN5c3RlbSBtYXkgbm90IGJlIGFibGUgdG8gYWxsb2NhdGUKIGFzIG1hbnkgdmVjdG9ycyBmb3IgTVNJIGFzIGl0IGNvdWxkIGZvciBNU0ktWC4gIE9uIHNvbWUgcGxhdGZvcm1zLCBNU0kKLWludGVycnVwdHMgbXVzdCBhbGwgYmUgdGFyZ2V0dGVkIGF0IHRoZSBzYW1lIHNldCBvZiBDUFVzIHdoZXJlYXMgTVNJLVgKLWludGVycnVwdHMgY2FuIGFsbCBiZSB0YXJnZXR0ZWQgYXQgZGlmZmVyZW50IENQVXMuCitpbnRlcnJ1cHRzIG11c3QgYWxsIGJlIHRhcmdldGVkIGF0IHRoZSBzYW1lIHNldCBvZiBDUFVzIHdoZXJlYXMgTVNJLVgKK2ludGVycnVwdHMgY2FuIGFsbCBiZSB0YXJnZXRlZCBhdCBkaWZmZXJlbnQgQ1BVcy4KIAogNC41LjIgU3BpbmxvY2tzCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vU2VjdXJpdHlCdWdzIGIvRG9jdW1lbnRhdGlvbi9TZWN1cml0eUJ1Z3MKaW5kZXggMjZjM2IzNi4uYTY2MGQ0OSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9TZWN1cml0eUJ1Z3MKKysrIGIvRG9jdW1lbnRhdGlvbi9TZWN1cml0eUJ1Z3MKQEAgLTI4LDcgKzI4LDcgQEAKIEEgZGlzY2xvc3VyZSBkYXRlIGlzIG5lZ290aWF0ZWQgYnkgdGhlIHNlY3VyaXR5IHRlYW0gd29ya2luZyB3aXRoIHRoZQogYnVnIHN1Ym1pdHRlciBhcyB3ZWxsIGFzIHZlbmRvcnMuICBIb3dldmVyLCB0aGUga2VybmVsIHNlY3VyaXR5IHRlYW0KIGhvbGRzIHRoZSBmaW5hbCBzYXkgd2hlbiBzZXR0aW5nIGEgZGlzY2xvc3VyZSBkYXRlLiAgVGhlIHRpbWVmcmFtZSBmb3IKLWRpc2Nsb3N1cmUgaXMgZnJvbSBpbW1lZGlhdGUgKGVzcC4gaWYgaXQncyBhbHJlYWR5IHB1YmxpY2FsbHkga25vd24pCitkaXNjbG9zdXJlIGlzIGZyb20gaW1tZWRpYXRlIChlc3AuIGlmIGl0J3MgYWxyZWFkeSBwdWJsaWNseSBrbm93bikKIHRvIGEgZmV3IHdlZWtzLiAgQXMgYSBiYXNpYyBkZWZhdWx0IHBvbGljeSwgd2UgZXhwZWN0IHJlcG9ydCBkYXRlIHRvCiBkaXNjbG9zdXJlIGRhdGUgdG8gYmUgb24gdGhlIG9yZGVyIG9mIDcgZGF5cy4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9TdWJtaXR0aW5nRHJpdmVycyBiL0RvY3VtZW50YXRpb24vU3VibWl0dGluZ0RyaXZlcnMKaW5kZXggMzhkMmFhYi4uMzE5YmFhOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9TdWJtaXR0aW5nRHJpdmVycworKysgYi9Eb2N1bWVudGF0aW9uL1N1Ym1pdHRpbmdEcml2ZXJzCkBAIC0xMDEsNyArMTAxLDcgQEAKIAkJY29tcGxldGUgb3ZlcnZpZXcgb2YgdGhlIHBvd2VyIG1hbmFnZW1lbnQgaXNzdWVzIHJlbGF0ZWQgdG8KIAkJZHJpdmVycyBzZWUgRG9jdW1lbnRhdGlvbi9wb3dlci9kZXZpY2VzLnR4dCAuCiAKLUNvbnRyb2w6CUluIGdlbmVyYWwgaWYgdGhlcmUgaXMgYWN0aXZlIG1haW50YWluYW5jZSBvZiBhIGRyaXZlciBieQorQ29udHJvbDoJSW4gZ2VuZXJhbCBpZiB0aGVyZSBpcyBhY3RpdmUgbWFpbnRlbmFuY2Ugb2YgYSBkcml2ZXIgYnkKIAkJdGhlIGF1dGhvciB0aGVuIHBhdGNoZXMgd2lsbCBiZSByZWRpcmVjdGVkIHRvIHRoZW0gdW5sZXNzCiAJCXRoZXkgYXJlIHRvdGFsbHkgb2J2aW91cyBhbmQgd2l0aG91dCBuZWVkIG9mIGNoZWNraW5nLgogCQlJZiB5b3Ugd2FudCB0byBiZSB0aGUgY29udGFjdCBhbmQgdXBkYXRlIHBvaW50IGZvciB0aGUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vU3VibWl0dGluZ1BhdGNoZXMgYi9Eb2N1bWVudGF0aW9uL1N1Ym1pdHRpbmdQYXRjaGVzCmluZGV4IDY4OWUyMzcuLmU0MzljZDAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vU3VibWl0dGluZ1BhdGNoZXMKKysrIGIvRG9jdW1lbnRhdGlvbi9TdWJtaXR0aW5nUGF0Y2hlcwpAQCAtNzI5LDcgKzcyOSw3IEBACiAgIDxodHRwOi8vbGttbC5vcmcvbGttbC8yMDA1LzQvNy8xODM+CiAKIEFuZGkgS2xlZW4sICJPbiBzdWJtaXR0aW5nIGtlcm5lbCBwYXRjaGVzIgotICBTb21lIHN0cmF0ZWdpZXMgdG8gZ2V0IGRpZmZpY3VsdCBvciBjb250cm92ZXJzYWwgY2hhbmdlcyBpbi4KKyAgU29tZSBzdHJhdGVnaWVzIHRvIGdldCBkaWZmaWN1bHQgb3IgY29udHJvdmVyc2lhbCBjaGFuZ2VzIGluLgogICBodHRwOi8vaGFsb2JhdGVzLmRlL29uLXN1Ym1pdHRpbmctcGF0Y2hlcy5wZGYKIAogLS0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYXJtL0lYUDR4eCBiL0RvY3VtZW50YXRpb24vYXJtL0lYUDR4eAppbmRleCAxMzNjNWZhLi43YjkzNTFmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2FybS9JWFA0eHgKKysrIGIvRG9jdW1lbnRhdGlvbi9hcm0vSVhQNHh4CkBAIC0zNiw3ICszNiw3IEBACiAtIFRpbWVycyAod2F0Y2hkb2csIE9TKQogCiBUaGUgZm9sbG93aW5nIGNvbXBvbmVudHMgb2YgdGhlIGNoaXBzIGFyZSBub3Qgc3VwcG9ydGVkIGJ5IExpbnV4IGFuZAotcmVxdWlyZSB0aGUgdXNlIG9mIEludGVsJ3MgcHJvcGlldGFyeSBDU1Igc29mdGFyZToKK3JlcXVpcmUgdGhlIHVzZSBvZiBJbnRlbCdzIHByb3ByaWV0YXJ5IENTUiBzb2Z0YXJlOgogCiAtIFVTQiBkZXZpY2UgaW50ZXJmYWNlCiAtIE5ldHdvcmsgaW50ZXJmYWNlcyAoSFNTLCBVdG9waWEsIE5QRXMsIGV0YykKQEAgLTQ3LDcgKzQ3LDcgQEAKIAogICAgaHR0cDovL2RldmVsb3Blci5pbnRlbC5jb20vZGVzaWduL25ldHdvcmsvcHJvZHVjdHMvbnBmYW1pbHkvaXhwNDI1Lmh0bSAgICAKIAotRE8gTk9UIFBPU1QgUVVFU1RJT05TIFRPIFRIRSBMSU5VWCBNQUlMSU5HIExJU1RTIFJFR0FSRElORyBUSEUgUFJPUElFVEFSWQorRE8gTk9UIFBPU1QgUVVFU1RJT05TIFRPIFRIRSBMSU5VWCBNQUlMSU5HIExJU1RTIFJFR0FSRElORyBUSEUgUFJPUFJJRVRBUlkKIFNPRlRXQVJFLgogCiBUaGVyZSBhcmUgc2V2ZXJhbCB3ZWJzaXRlcyB0aGF0IHByb3ZpZGUgZGlyZWN0aW9ucy9wb2ludGVycyBvbiB1c2luZwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hcm0vU2Ftc3VuZy1TM0MyNFhYL1N1c3BlbmQudHh0IGIvRG9jdW1lbnRhdGlvbi9hcm0vU2Ftc3VuZy1TM0MyNFhYL1N1c3BlbmQudHh0CmluZGV4IDdlZGQwZTIuLjFjYTYzYjMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vYXJtL1NhbXN1bmctUzNDMjRYWC9TdXNwZW5kLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2FybS9TYW1zdW5nLVMzQzI0WFgvU3VzcGVuZC50eHQKQEAgLTExNiw3ICsxMTYsNyBAQAogICAgIEFsbG93cyB0aGUgZW50aXJlIG1lbW9yeSB0byBiZSBjaGVja3N1bW1lZCBiZWZvcmUgYW5kIGFmdGVyIHRoZQogICAgIHN1c3BlbmQgdG8gc2VlIGlmIHRoZXJlIGhhcyBiZWVuIGFueSBjb3JydXB0aW9uIG9mIHRoZSBjb250ZW50cy4KIAotICAgIE5vdGUsIHRoZSB0aW1lIHRvIGNhbGN1bGF0ZSB0aGUgQ1JDIGlzIGRlcGVuZGFudCBvbiB0aGUgQ1BVIHNwZWVkCisgICAgTm90ZSwgdGhlIHRpbWUgdG8gY2FsY3VsYXRlIHRoZSBDUkMgaXMgZGVwZW5kZW50IG9uIHRoZSBDUFUgc3BlZWQKICAgICBhbmQgdGhlIHNpemUgb2YgbWVtb3J5LiBGb3IgYW4gNjRNYnl0ZSBSQU0gYXJlYSBvbiBhbiAyMDBNSHoKICAgICBTM0MyNDEwLCB0aGlzIGNhbiB0YWtlIGFwcHJveGltYXRlbHkgNCBzZWNvbmRzIHRvIGNvbXBsZXRlLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2FybS9TYW1zdW5nL0dQSU8udHh0IGIvRG9jdW1lbnRhdGlvbi9hcm0vU2Ftc3VuZy9HUElPLnR4dAppbmRleCAwNTg1MGM2Li41MTNmMjU2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2FybS9TYW1zdW5nL0dQSU8udHh0CisrKyBiL0RvY3VtZW50YXRpb24vYXJtL1NhbXN1bmcvR1BJTy50eHQKQEAgLTUsNyArNSw3IEBACiAtLS0tLS0tLS0tLS0KIAogVGhpcyBvdXRsaW5lcyB0aGUgU2Ftc3VuZyBHUElPIGltcGxlbWVudGF0aW9uIGFuZCB0aGUgYXJjaGl0ZWN0dXJlCi1zcGVjZmljIGNhbGxzIHByb3ZpZGVkIGFsb25naXNkZSB0aGUgZHJpdmVycy9ncGlvIGNvcmUuCitzcGVjaWZpYyBjYWxscyBwcm92aWRlZCBhbG9uZ2lzZGUgdGhlIGRyaXZlcnMvZ3BpbyBjb3JlLgogCiAKIFMzQzI0WFggKExlZ2FjeSkKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYmxvY2svYmlvZG9jLnR4dCBiL0RvY3VtZW50YXRpb24vYmxvY2svYmlvZG9jLnR4dAppbmRleCAyYTdiMzhjLi5jNmQ4NGNmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2Jsb2NrL2Jpb2RvYy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9ibG9jay9iaW9kb2MudHh0CkBAIC00OTcsNyArNDk3LDcgQEAKIGVudHJpZXMgd2l0aCB0aGVpciBjb3JyZXNwb25kaW5nIGRtYSBhZGRyZXNzIG1hcHBpbmdzIGZpbGxlZCBpbiBhdCB0aGUKIGFwcHJvcHJpYXRlIHRpbWUuIEFzIGFuIG9wdGltaXphdGlvbiwgY29udGlndW91cyBwaHlzaWNhbCBwYWdlcyBjYW4gYmUKIGNvdmVyZWQgYnkgYSBzaW5nbGUgZW50cnkgd2hlcmUgPHBhZ2U+IHJlZmVycyB0byB0aGUgZmlyc3QgcGFnZSBhbmQgPGxlbj4KLWNvdmVycyB0aGUgcmFuZ2Ugb2YgcGFnZXMgKHVwdG8gMTYgY29udGlndW91cyBwYWdlcyBjb3VsZCBiZSBjb3ZlcmVkIHRoaXMKK2NvdmVycyB0aGUgcmFuZ2Ugb2YgcGFnZXMgKHVwIHRvIDE2IGNvbnRpZ3VvdXMgcGFnZXMgY291bGQgYmUgY292ZXJlZCB0aGlzCiB3YXkpLiBUaGVyZSBpcyBhIGhlbHBlciByb3V0aW5lIChibGtfcnFfbWFwX3NnKSB3aGljaCBkcml2ZXJzIGNhbiB1c2UgdG8gYnVpbGQKIHRoZSBzZyBsaXN0LgogCkBAIC01NjUsNyArNTY1LDcgQEAKIAkuCiAJaW50IHRhZzsJLyogY29tbWFuZCB0YWcgYXNzb2NpYXRlZCB3aXRoIHJlcXVlc3QgKi8KIAl2b2lkICpzcGVjaWFsOyAgLyogc2FtZSBhcyBiZWZvcmUgKi8KLQljaGFyICpidWZmZXI7ICAgLyogdmFsaWQgb25seSBmb3IgbG93IG1lbW9yeSBidWZmZXJzIHVwdG8KKwljaGFyICpidWZmZXI7ICAgLyogdmFsaWQgb25seSBmb3IgbG93IG1lbW9yeSBidWZmZXJzIHVwIHRvCiAJCQkgY3VycmVudF9ucl9zZWN0b3JzICovCiAJLgogCS4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vY3B1LWhvdHBsdWcudHh0IGIvRG9jdW1lbnRhdGlvbi9jcHUtaG90cGx1Zy50eHQKaW5kZXggNDVkNWEyMS4uYTIwYmZkNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9jcHUtaG90cGx1Zy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9jcHUtaG90cGx1Zy50eHQKQEAgLTE5Niw3ICsxOTYsNyBAQAogCSNUbyBkaXNwbGF5IHRoZSBjdXJyZW50IGNwdSBzdGF0ZS4KIAkjY2F0IC9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdVgvb25saW5lCiAKLVE6IFdoeSBjYW50IGkgcmVtb3ZlIENQVTAgb24gc29tZSBzeXN0ZW1zPworUTogV2h5IGNhbid0IGkgcmVtb3ZlIENQVTAgb24gc29tZSBzeXN0ZW1zPwogQTogU29tZSBhcmNoaXRlY3R1cmVzIG1heSBoYXZlIHNvbWUgc3BlY2lhbCBkZXBlbmRlbmN5IG9uIGEgY2VydGFpbiBDUFUuCiAKIEZvciBlLmcgaW4gSUE2NCBwbGF0Zm9ybXMgd2UgaGF2ZSBhYmlsaXR5IHRvIHNlbnQgcGxhdGZvcm0gaW50ZXJydXB0cyB0byB0aGUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGVsbF9yYnUudHh0IGIvRG9jdW1lbnRhdGlvbi9kZWxsX3JidS50eHQKaW5kZXggMTUxNzQ5OC4uZDI2MmUyMiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZWxsX3JidS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZWxsX3JidS50eHQKQEAgLTYyLDcgKzYyLDcgQEAKIGZpbGUuCiBUaGlzIGZpbGUgaXMgdGhlbiBjb3BpZWQgdG8gL3N5cy9jbGFzcy9maXJtd2FyZS9kZWxsX3JidS9kYXRhLgogT25jZSB0aGlzIGZpbGUgZ2V0cyB0byB0aGUgZHJpdmVyLCB0aGUgZHJpdmVyIGV4dHJhY3RzIHBhY2tldF9zaXplIGRhdGEgZnJvbQotdGhlIGZpbGUgYW5kIHNwcmVhZHMgaXQgYWNjcm9zcyB0aGUgcGh5c2ljYWwgbWVtb3J5IGluIGNvbnRpZ3VvdXMgcGFja2V0X3NpemVkCit0aGUgZmlsZSBhbmQgc3ByZWFkcyBpdCBhY3Jvc3MgdGhlIHBoeXNpY2FsIG1lbW9yeSBpbiBjb250aWd1b3VzIHBhY2tldF9zaXplZAogc3BhY2UuCiBUaGlzIG1ldGhvZCBtYWtlcyBzdXJlIHRoYXQgYWxsIHRoZSBwYWNrZXRzIGdldCB0byB0aGUgZHJpdmVyIGluIGEgc2luZ2xlIG9wZXJhdGlvbi4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2UtbWFwcGVyL2RtLXNlcnZpY2UtdGltZS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZS1tYXBwZXIvZG0tc2VydmljZS10aW1lLnR4dAppbmRleCA3ZDAwNjY4Li5mYjFkNGEwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZS1tYXBwZXIvZG0tc2VydmljZS10aW1lLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZS1tYXBwZXIvZG0tc2VydmljZS10aW1lLnR4dApAQCAtMzcsNyArMzcsNyBAQAogPT09PT09PT09CiAKIGRtLXNlcnZpY2UtdGltZSBhZGRzIHRoZSBJL08gc2l6ZSB0byAnaW4tZmxpZ2h0LXNpemUnIHdoZW4gdGhlIEkvTyBpcwotZGlzcGF0Y2hlZCBhbmQgc3Vic3RyYWN0cyB3aGVuIGNvbXBsZXRlZC4KK2Rpc3BhdGNoZWQgYW5kIHN1YnRyYWN0cyB3aGVuIGNvbXBsZXRlZC4KIEJhc2ljYWxseSwgZG0tc2VydmljZS10aW1lIHNlbGVjdHMgYSBwYXRoIGhhdmluZyBtaW5pbXVtIHNlcnZpY2UgdGltZQogd2hpY2ggaXMgY2FsY3VsYXRlZCBieToKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2ZiL3NtNTAxZmIudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2ZiL3NtNTAxZmIudHh0CmluZGV4IDdkMzE5ZmIuLjlkOWYwMDkgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9mYi9zbTUwMWZiLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZmIvc201MDFmYi50eHQKQEAgLTE4LDkgKzE4LDkgQEAKIC0gZWRpZCA6IHZlcmJhdGltIEVESUQgZGF0YSBibG9jayBkZXNjcmliaW5nIGF0dGFjaGVkIGRpc3BsYXkuCiAgIERhdGEgZnJvbSB0aGUgZGV0YWlsZWQgdGltaW5nIGRlc2NyaXB0b3Igd2lsbCBiZSB1c2VkIHRvCiAgIHByb2dyYW0gdGhlIGRpc3BsYXkgY29udHJvbGxlci4KLS0gbGl0dGxlLWVuZGlhbjogYXZhaWxpYWJsZSBvbiBiaWcgZW5kaWFuIHN5c3RlbXMsIHRvCistIGxpdHRsZS1lbmRpYW46IGF2YWlsYWJsZSBvbiBiaWcgZW5kaWFuIHN5c3RlbXMsIHRvCiAgIHNldCBkaWZmZXJlbnQgZm9yZWlnbiBlbmRpYW4uCi0tIGJpZy1lbmRpYW46IGF2YWlsaWFibGUgb24gbGl0dGxlIGVuZGlhbiBzeXN0ZW1zLCB0bworLSBiaWctZW5kaWFuOiBhdmFpbGFibGUgb24gbGl0dGxlIGVuZGlhbiBzeXN0ZW1zLCB0bwogICBzZXQgZGlmZmVyZW50IGZvcmVpZ24gZW5kaWFuLgogCiBFeGFtcGxlIGZvciBNUEM1MjAwOgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL210ZC9mc2wtdXBtLW5hbmQudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL210ZC9mc2wtdXBtLW5hbmQudHh0CmluZGV4IGE0OGIyY2EuLjAwZjFmNTQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvZnNsLXVwbS1uYW5kLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbXRkL2ZzbC11cG0tbmFuZC50eHQKQEAgLTE1LDcgKzE1LDcgQEAKIC0gZ3Bpb3MgOiBtYXkgc3BlY2lmeSBvcHRpb25hbCBHUElPcyBjb25uZWN0ZWQgdG8gdGhlIFJlYWR5LU5vdC1CdXN5IHBpbnMKIAkoUi9CIykuIEZvciBtdWx0aS1jaGlwIGRldmljZXMsICJuIiBHUElPIGRlZmluaXRpb25zIGFyZSByZXF1aXJlZAogCWFjY29yZGluZyB0byB0aGUgbnVtYmVyIG9mIGNoaXBzLgotLSBjaGlwLWRlbGF5IDogY2hpcCBkZXBlbmRlbnQgZGVsYXkgZm9yIHRyYW5zZmVyaW5nIGRhdGEgZnJvbSBhcnJheSB0bworLSBjaGlwLWRlbGF5IDogY2hpcCBkZXBlbmRlbnQgZGVsYXkgZm9yIHRyYW5zZmVycmluZyBkYXRhIGZyb20gYXJyYXkgdG8KIAlyZWFkIHJlZ2lzdGVycyAodFIpLiBSZXF1aXJlZCBpZiBwcm9wZXJ0eSAiZ3Bpb3MiIGlzIG5vdCB1c2VkCiAJKFIvQiMgcGlucyBub3QgY29ubmVjdGVkKS4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9jYW4vc2phMTAwMC50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbmV0L2Nhbi9zamExMDAwLnR4dAppbmRleCBkNmQyMDlkLi5jMmRiY2VjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbmV0L2Nhbi9zamExMDAwLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbmV0L2Nhbi9zamExMDAwLnR4dApAQCAtMzksNyArMzksNyBAQAogCiAtIG54cCxuby1jb21wYXJhdG9yLWJ5cGFzcyA6IEFsbG93cyB0byBkaXNhYmxlIHRoZSBDQU4gaW5wdXQgY29tcGVyYXRvci4KIAotRm9yIGZ1dGhlciBpbmZvcm1hdGlvbiwgcGxlYXNlIGhhdmUgYSBsb29rIHRvIHRoZSBTSkExMDAwIGRhdGEgc2hlZXQuCitGb3IgZnVydGhlciBpbmZvcm1hdGlvbiwgcGxlYXNlIGhhdmUgYSBsb29rIHRvIHRoZSBTSkExMDAwIGRhdGEgc2hlZXQuCiAKIEV4YW1wbGVzOgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbXBpYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbXBpYy50eHQKaW5kZXggOGFhMTBmNC4uNGY2MTQ1OCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL21waWMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9tcGljLnR4dApAQCAtMTk5LDcgKzE5OSw3IEBACiAKIEVYQU1QTEUgNQogCS8qCi0JICogRGVmaW5pdGlvbiBvZiBhbiBlcnJvciBpbnRlcnJ1cHQgKGludGVydXB0IHR5cGUgMSkuCisJICogRGVmaW5pdGlvbiBvZiBhbiBlcnJvciBpbnRlcnJ1cHQgKGludGVycnVwdCB0eXBlIDEpLgogCSAqIFNvQyBpbnRlcnJ1cHQgbnVtYmVyIGlzIDE2IGFuZCB0aGUgc3BlY2lmaWMgZXJyb3IKICAgICAgICAgICogaW50ZXJydXB0IGJpdCBpbiB0aGUgZXJyb3IgaW50ZXJydXB0IHN1bW1hcnkgcmVnaXN0ZXIKIAkgKiBpcyAyMy4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHZiL1JFQURNRS5kdmItdXNiIGIvRG9jdW1lbnRhdGlvbi9kdmIvUkVBRE1FLmR2Yi11c2IKaW5kZXggYzgyMzhlNC4uYzRkOTYzYSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kdmIvUkVBRE1FLmR2Yi11c2IKKysrIGIvRG9jdW1lbnRhdGlvbi9kdmIvUkVBRE1FLmR2Yi11c2IKQEAgLTEzOCw3ICsxMzgsNyBAQAogaW4gdGhlIGRldmljZSkuCiAKIElmIHlvdSB3YW50IHRvIGVuYWJsZSBkZWJ1ZyBvdXRwdXQsIHlvdSBoYXZlIHRvIGxvYWQgdGhlIGRyaXZlciBtYW51YWxseSBhbmQKLWZyb20gd2l0aGluZyB0aGUgZHZiLWtlcm5lbCBjdnMgcmVwb3NpdG9yeS4KK2Zyb20gd2l0aGluIHRoZSBkdmIta2VybmVsIGN2cyByZXBvc2l0b3J5LgogCiBmaXJzdCBoYXZlIGEgbG9vaywgd2hpY2ggZGVidWcgbGV2ZWwgYXJlIGF2YWlsYWJsZToKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kdmIvY2kudHh0IGIvRG9jdW1lbnRhdGlvbi9kdmIvY2kudHh0CmluZGV4IDRhMGMyYjUuLjZjM2JkYTUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZHZiL2NpLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2R2Yi9jaS50eHQKQEAgLTQ3LDcgKzQ3LDcgQEAKIAogKiBDSSBtb2R1bGVzIHRoYXQgYXJlIHN1cHBvcnRlZAogfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KLVRoZSBDSSBtb2R1bGUgc3VwcG9ydCBpcyBsYXJnZWx5IGRlcGVuZGFudCB1cG9uIHRoZSBmaXJtd2FyZSBvbiB0aGUgY2FyZHMKK1RoZSBDSSBtb2R1bGUgc3VwcG9ydCBpcyBsYXJnZWx5IGRlcGVuZGVudCB1cG9uIHRoZSBmaXJtd2FyZSBvbiB0aGUgY2FyZHMKIFNvbWUgY2FyZHMgZG8gc3VwcG9ydCBhbG1vc3QgYWxsIG9mIHRoZSBhdmFpbGFibGUgQ0kgbW9kdWxlcy4gVGhlcmUgaXMKIG5vdGhpbmcgbXVjaCB0aGF0IGNhbiBiZSBkb25lIGluIG9yZGVyIHRvIG1ha2UgYWRkaXRpb25hbCBDSSBtb2R1bGVzCiB3b3JraW5nIHdpdGggdGhlc2UgY2FyZHMuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2R2Yi9mYXEudHh0IGIvRG9jdW1lbnRhdGlvbi9kdmIvZmFxLnR4dAppbmRleCAxMjE4MzJlLi45N2IxMzczIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2R2Yi9mYXEudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZHZiL2ZhcS50eHQKQEAgLTEwNiw3ICsxMDYsNyBAQAogNS4gVGhlIGR2Yl9uZXQgZGV2aWNlIGRvZXNuJ3QgZ2l2ZSBtZSBhbnkgcGFja2V0cyBhdCBhbGwKIAogCVJ1biB0Y3BkdW1wIG9uIHRoZSBkdmIwXzAgaW50ZXJmYWNlLiBUaGlzIHNldHMgdGhlIGludGVyZmFjZQotCWludG8gcHJvbWlzY291cyBtb2RlIHNvIGl0IGFjY2VwdHMgYW55IHBhY2tldHMgZnJvbSB0aGUgUElECisJaW50byBwcm9taXNjdW91cyBtb2RlIHNvIGl0IGFjY2VwdHMgYW55IHBhY2tldHMgZnJvbSB0aGUgUElECiAJeW91IGhhdmUgY29uZmlndXJlZCB3aXRoIHRoZSBkdmJuZXQgdXRpbGl0eS4gQ2hlY2sgaWYgdGhlcmUKIAlhcmUgYW55IHBhY2tldHMgd2l0aCB0aGUgSVAgYWRkciBhbmQgTUFDIGFkZHIgeW91IGhhdmUKIAljb25maWd1cmVkIHdpdGggaWZjb25maWcuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2VkYWMudHh0IGIvRG9jdW1lbnRhdGlvbi9lZGFjLnR4dAppbmRleCBjY2MwN2MyLi4yNDk4MjJjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2VkYWMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZWRhYy50eHQKQEAgLTc0MSw3ICs3NDEsNyBAQAogICAgQXMgRURBQyBBUEkgbWFwcyB0aGUgbWluaW11bSB1bml0eSBpcyBjc3Jvd3MsIHRoZSBkcml2ZXIgc2VxdWVuY2lhbGx5CiAgICBtYXBzIGNoYW5uZWwvZGltbSBpbnRvIGRpZmZlcmVudCBjc3Jvd3MuCiAKLSAgIEZvciBleGFtcGxlLCBzdXBvc2luZyB0aGUgZm9sbG93aW5nIGxheW91dDoKKyAgIEZvciBleGFtcGxlLCBzdXBwb3NpbmcgdGhlIGZvbGxvd2luZyBsYXlvdXQ6CiAJQ2gwIHBoeSByZDAsIHdyMCAoMHgwNjNmNDAzMSk6IDIgcmFua3MsIFVESU1NcwogCSAgZGltbSAwIDEwMjQgTWIgb2Zmc2V0OiAwLCBiYW5rOiA4LCByYW5rOiAxLCByb3c6IDB4NDAwMCwgY29sOiAweDQwMAogCSAgZGltbSAxIDEwMjQgTWIgb2Zmc2V0OiA0LCBiYW5rOiA4LCByYW5rOiAxLCByb3c6IDB4NDAwMCwgY29sOiAweDQwMApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9laXNhLnR4dCBiL0RvY3VtZW50YXRpb24vZWlzYS50eHQKaW5kZXggZjI5N2ZjMS4uMzhjZjBjNyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9laXNhLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2Vpc2EudHh0CkBAIC04NCw3ICs4NCw3IEBACiAKIGlkX3RhYmxlCTogYW4gYXJyYXkgb2YgTlVMTCB0ZXJtaW5hdGVkIEVJU0EgaWQgc3RyaW5ncywKIAkJICBmb2xsb3dlZCBieSBhbiBlbXB0eSBzdHJpbmcuIEVhY2ggc3RyaW5nIGNhbgotCQkgIG9wdGlvbmFsbHkgYmUgcGFpcmVkIHdpdGggYSBkcml2ZXItZGVwZW5kYW50IHZhbHVlCisJCSAgb3B0aW9uYWxseSBiZSBwYWlyZWQgd2l0aCBhIGRyaXZlci1kZXBlbmRlbnQgdmFsdWUKIAkJICAoZHJpdmVyX2RhdGEpLgogCiBkcml2ZXIJCTogYSBnZW5lcmljIGRyaXZlciwgc3VjaCBhcyBkZXNjcmliZWQgaW4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmIvdmlhZmIudHh0IGIvRG9jdW1lbnRhdGlvbi9mYi92aWFmYi50eHQKaW5kZXggMWEyZThhYS4uNDQ0ZTM0YiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9mYi92aWFmYi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9mYi92aWFmYi50eHQKQEAgLTIwNCw3ICsyMDQsNyBAQAogCiAgICAgc3VwcG9ydGVkX291dHB1dF9kZXZpY2VzCiAKLSAgICAgICAgVGhpcyByZWFkLW9ubHkgZmlsZSBjb250YWlucyBhIGZ1bGwgJywnIHNlcGVyYXRlZCBsaXN0IGNvbnRhaW5pbmcgYWxsCisgICAgICAgIFRoaXMgcmVhZC1vbmx5IGZpbGUgY29udGFpbnMgYSBmdWxsICcsJyBzZXBhcmF0ZWQgbGlzdCBjb250YWluaW5nIGFsbAogICAgICAgICBvdXRwdXQgZGV2aWNlcyB0aGF0IGNvdWxkIGJlIGF2YWlsYWJsZSBvbiB5b3VyIHBsYXRmb3JtLiBJdCBpcyBsaWtlbHkKICAgICAgICAgdGhhdCBub3QgYWxsIG9mIHRob3NlIGhhdmUgYSBjb25uZWN0b3Igb24geW91ciBoYXJkd2FyZSBidXQgaXQgc2hvdWxkCiAgICAgICAgIHByb3ZpZGUgYSBnb29kIHN0YXJ0aW5nIHBvaW50IHRvIGZpZ3VyZSBvdXQgd2hpY2ggb2YgdGhvc2UgbmFtZXMgbWF0Y2gKQEAgLTIyNSw3ICsyMjUsNyBAQAogICAgICAgICBUaGlzIGNhbiBoYXBwZW4gZm9yIGV4YW1wbGUgaWYgb25seSBvbmUgKHRoZSBvdGhlcikgaWdhIGlzIHVzZWQuCiAgICAgICAgIFdyaXRpbmcgdG8gdGhlc2UgZmlsZXMgYWxsb3dzIGFkanVzdGluZyB0aGUgb3V0cHV0IGRldmljZXMgZHVyaW5nCiAgICAgICAgIHJ1bnRpbWUuIE9uZSBjYW4gYWRkIG5ldyBkZXZpY2VzLCByZW1vdmUgZXhpc3Rpbmcgb25lcyBvciBzd2l0Y2gKLSAgICAgICAgYmV0d2VlbiBpZ2FzLiBFc3NlbnRpYWxseSB5b3UgY2FuIHdyaXRlIGEgJywnIHNlcGVyYXRlZCBsaXN0IG9mIGRldmljZQorICAgICAgICBiZXR3ZWVuIGlnYXMuIEVzc2VudGlhbGx5IHlvdSBjYW4gd3JpdGUgYSAnLCcgc2VwYXJhdGVkIGxpc3Qgb2YgZGV2aWNlCiAgICAgICAgIG5hbWVzIChvciBhIHNpbmdsZSBvbmUpIGluIHRoZSBzYW1lIGZvcm1hdCBhcyB0aGUgb3V0cHV0IHRvIHRob3NlCiAgICAgICAgIGZpbGVzLiBZb3UgY2FuIGFkZCBhICcrJyBvciAnLScgYXMgYSBwcmVmaXggYWxsb3dpbmcgc2ltcGxlIGFkZGl0aW9uCiAgICAgICAgIGFuZCByZW1vdmFsIG9mIGRldmljZXMuIFNvIGEgcHJlZml4ICcrJyBhZGRzIHRoZSBkZXZpY2VzIGZyb20geW91ciBsaXN0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2F1dG9mczQtbW91bnQtY29udHJvbC50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2F1dG9mczQtbW91bnQtY29udHJvbC50eHQKaW5kZXggNTE5ODZiZi4uNGM5NTkzNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9hdXRvZnM0LW1vdW50LWNvbnRyb2wudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvYXV0b2ZzNC1tb3VudC1jb250cm9sLnR4dApAQCAtMzA5LDcgKzMwOSw3IEBACiBBVVRPRlNfREVWX0lPQ1RMX1RJTUVPVVRfQ01ECiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKLVNldCB0aGUgZXhwaXJlIHRpbWVvdXQgZm9yIG1vdW50cyB3aXRoaW5nIGFuIGF1dG9mcyBtb3VudCBwb2ludC4KK1NldCB0aGUgZXhwaXJlIHRpbWVvdXQgZm9yIG1vdW50cyB3aXRoaW4gYW4gYXV0b2ZzIG1vdW50IHBvaW50LgogCiBUaGUgY2FsbCByZXF1aXJlcyBhbiBpbml0aWFsaXplZCBzdHJ1Y3QgYXV0b2ZzX2Rldl9pb2N0bCB3aXRoIHRoZQogaW9jdGxmZCBmaWVsZCBzZXQgdG8gdGhlIGRlc2NyaXB0b3Igb2J0YWluZWQgZnJvbSB0aGUgb3BlbiBjYWxsLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9jYWNoaW5nL25ldGZzLWFwaS50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NhY2hpbmcvbmV0ZnMtYXBpLnR4dAppbmRleCAxOTAyYzU3Li5hMTY3YWI4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NhY2hpbmcvbmV0ZnMtYXBpLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NhY2hpbmcvbmV0ZnMtYXBpLnR4dApAQCAtOTUsNyArOTUsNyBAQAogdGhlIHRyZWUuICBUaGUgbmV0ZnMgY2FuIGV2ZW4gbWl4IGluZGljZXMgYW5kIGRhdGEgZmlsZXMgYXQgdGhlIHNhbWUgbGV2ZWwsIGJ1dAogaXQncyBub3QgcmVjb21tZW5kZWQuCiAKLUVhY2ggaW5kZXggZW50cnkgY29uc2lzdHMgb2YgYSBrZXkgb2YgaW5kZXRlcm1pbmF0ZSBsZW5ndGggcGx1cyBzb21lIGF1eGlsbGlhcnkKK0VhY2ggaW5kZXggZW50cnkgY29uc2lzdHMgb2YgYSBrZXkgb2YgaW5kZXRlcm1pbmF0ZSBsZW5ndGggcGx1cyBzb21lIGF1eGlsaWFyeQogZGF0YSwgYWxzbyBvZiBpbmRldGVybWluYXRlIGxlbmd0aC4KIAogVGhlcmUgYXJlIHNvbWUgbGltaXRzIG9uIGluZGljZXM6CkBAIC0yMDMsMjMgKzIwMywyMyBAQAogCiAgICAgIElmIHRoZSBmdW5jdGlvbiBpcyBhYnNlbnQsIGEgZmlsZSBzaXplIG9mIDAgaXMgYXNzdW1lZC4KIAotICg2KSBBIGZ1bmN0aW9uIHRvIHJldHJpZXZlIGF1eGlsbGlhcnkgZGF0YSBmcm9tIHRoZSBuZXRmcyBbb3B0aW9uYWxdLgorICg2KSBBIGZ1bmN0aW9uIHRvIHJldHJpZXZlIGF1eGlsaWFyeSBkYXRhIGZyb20gdGhlIG5ldGZzIFtvcHRpb25hbF0uCiAKICAgICAgVGhpcyBmdW5jdGlvbiB3aWxsIGJlIGNhbGxlZCB3aXRoIHRoZSBuZXRmcyBkYXRhIHRoYXQgd2FzIHBhc3NlZCB0byB0aGUKLSAgICAgY29va2llIGFjcXVpc2l0aW9uIGZ1bmN0aW9uIGFuZCB0aGUgbWF4aW11bSBsZW5ndGggb2YgYXV4aWxsaWFyeSBkYXRhIHRoYXQKLSAgICAgaXQgbWF5IHByb3ZpZGUuICBJdCBzaG91bGQgd3JpdGUgdGhlIGF1eGlsbGlhcnkgZGF0YSBpbnRvIHRoZSBnaXZlbiBidWZmZXIKKyAgICAgY29va2llIGFjcXVpc2l0aW9uIGZ1bmN0aW9uIGFuZCB0aGUgbWF4aW11bSBsZW5ndGggb2YgYXV4aWxpYXJ5IGRhdGEgdGhhdAorICAgICBpdCBtYXkgcHJvdmlkZS4gIEl0IHNob3VsZCB3cml0ZSB0aGUgYXV4aWxpYXJ5IGRhdGEgaW50byB0aGUgZ2l2ZW4gYnVmZmVyCiAgICAgIGFuZCByZXR1cm4gdGhlIHF1YW50aXR5IGl0IHdyb3RlLgogCi0gICAgIElmIHRoaXMgZnVuY3Rpb24gaXMgYWJzZW50LCB0aGUgYXV4aWxsaWFyeSBkYXRhIGxlbmd0aCB3aWxsIGJlIHNldCB0byAwLgorICAgICBJZiB0aGlzIGZ1bmN0aW9uIGlzIGFic2VudCwgdGhlIGF1eGlsaWFyeSBkYXRhIGxlbmd0aCB3aWxsIGJlIHNldCB0byAwLgogCi0gICAgIFRoZSBsZW5ndGggb2YgdGhlIGF1eGlsbGlhcnkgZGF0YSBidWZmZXIgbWF5IGJlIGRlcGVuZGVudCBvbiB0aGUga2V5CisgICAgIFRoZSBsZW5ndGggb2YgdGhlIGF1eGlsaWFyeSBkYXRhIGJ1ZmZlciBtYXkgYmUgZGVwZW5kZW50IG9uIHRoZSBrZXkKICAgICAgbGVuZ3RoLiAgQSBuZXRmcyBtdXN0bid0IHJlbHkgb24gYmVpbmcgYWJsZSB0byBwcm92aWRlIG1vcmUgdGhhbiA0MDAgYnl0ZXMKICAgICAgZm9yIGJvdGguCiAKLSAoNykgQSBmdW5jdGlvbiB0byBjaGVjayB0aGUgYXV4aWxsaWFyeSBkYXRhIFtvcHRpb25hbF0uCisgKDcpIEEgZnVuY3Rpb24gdG8gY2hlY2sgdGhlIGF1eGlsaWFyeSBkYXRhIFtvcHRpb25hbF0uCiAKICAgICAgVGhpcyBmdW5jdGlvbiB3aWxsIGJlIGNhbGxlZCB0byBjaGVjayB0aGF0IGEgbWF0Y2ggZm91bmQgaW4gdGhlIGNhY2hlIGZvcgotICAgICB0aGlzIG9iamVjdCBpcyB2YWxpZC4gIEZvciBpbnN0YW5jZSB3aXRoIEFGUyBpdCBjb3VsZCBjaGVjayB0aGUgYXV4aWxsaWFyeQorICAgICB0aGlzIG9iamVjdCBpcyB2YWxpZC4gIEZvciBpbnN0YW5jZSB3aXRoIEFGUyBpdCBjb3VsZCBjaGVjayB0aGUgYXV4aWxpYXJ5CiAgICAgIGRhdGEgYWdhaW5zdCB0aGUgZGF0YSB2ZXJzaW9uIG51bWJlciByZXR1cm5lZCBieSB0aGUgc2VydmVyIHRvIGRldGVybWluZQogICAgICB3aGV0aGVyIHRoZSBpbmRleCBlbnRyeSBpbiBhIGNhY2hlIGlzIHN0aWxsIHZhbGlkLgogCkBAIC0yMzIsNyArMjMyLDcgQEAKIAkoKikgRlNDQUNIRV9DSEVDS0FVWF9ORUVEU19VUERBVEUJLSB0aGUgZW50cnkgcmVxdWlyZXMgdXBkYXRlCiAJKCopIEZTQ0FDSEVfQ0hFQ0tBVVhfT0JTT0xFVEUJCS0gdGhlIGVudHJ5IHNob3VsZCBiZSBkZWxldGVkCiAKLSAgICAgVGhpcyBmdW5jdGlvbiBjYW4gYWxzbyBiZSB1c2VkIHRvIGV4dHJhY3QgZGF0YSBmcm9tIHRoZSBhdXhpbGxpYXJ5IGRhdGEgaW4KKyAgICAgVGhpcyBmdW5jdGlvbiBjYW4gYWxzbyBiZSB1c2VkIHRvIGV4dHJhY3QgZGF0YSBmcm9tIHRoZSBhdXhpbGlhcnkgZGF0YSBpbgogICAgICB0aGUgY2FjaGUgYW5kIGNvcHkgaXQgaW50byB0aGUgbmV0ZnMncyBzdHJ1Y3R1cmVzLgogCiAgKDgpIEEgcGFpciBvZiBmdW5jdGlvbnMgdG8gbWFuYWdlIGNvbnRleHRzIGZvciB0aGUgY29tcGxldGlvbiBjYWxsYmFjawpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9jb25maWdmcy9jb25maWdmcy50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NvbmZpZ2ZzL2NvbmZpZ2ZzLnR4dAppbmRleCBmYWJjYjBlLi5kZDU3YmI2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NvbmZpZ2ZzL2NvbmZpZ2ZzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NvbmZpZ2ZzL2NvbmZpZ2ZzLnR4dApAQCAtNDA5LDcgKzQwOSw3IEBACiBybWRpcigyKS4gIFRoZXkgYWxzbyBhcmUgbm90IGNvbnNpZGVyZWQgd2hlbiBybWRpcigyKSBvbiB0aGUgcGFyZW50CiBncm91cCBpcyBjaGVja2luZyBmb3IgY2hpbGRyZW4uCiAKLVtEZXBlbmRhbnQgU3Vic3lzdGVtc10KK1tEZXBlbmRlbnQgU3Vic3lzdGVtc10KIAogU29tZXRpbWVzIG90aGVyIGRyaXZlcnMgZGVwZW5kIG9uIHBhcnRpY3VsYXIgY29uZmlnZnMgaXRlbXMuICBGb3IKIGV4YW1wbGUsIG9jZnMyIG1vdW50cyBkZXBlbmQgb24gYSBoZWFydGJlYXQgcmVnaW9uIGl0ZW0uICBJZiB0aGF0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2V4dDQudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9leHQ0LnR4dAppbmRleCA2YjA1MDQ2Li5jNzllYzU4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2V4dDQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZXh0NC50eHQKQEAgLTk3LDcgKzk3LDcgQEAKICogSW5vZGUgYWxsb2NhdGlvbiB1c2luZyBsYXJnZSB2aXJ0dWFsIGJsb2NrIGdyb3VwcyB2aWEgZmxleF9iZwogKiBkZWxheWVkIGFsbG9jYXRpb24KICogbGFyZ2UgYmxvY2sgKHVwIHRvIHBhZ2VzaXplKSBzdXBwb3J0Ci0qIGVmZmljZW50IG5ldyBvcmRlcmVkIG1vZGUgaW4gSkJEMiBhbmQgZXh0NChhdm9pZCB1c2luZyBidWZmZXIgaGVhZCB0byBmb3JjZQorKiBlZmZpY2llbnQgbmV3IG9yZGVyZWQgbW9kZSBpbiBKQkQyIGFuZCBleHQ0KGF2b2lkIHVzaW5nIGJ1ZmZlciBoZWFkIHRvIGZvcmNlCiAgIHRoZSBvcmRlcmluZykKIAogWzFdIEZpbGVzeXN0ZW1zIHdpdGggYSBibG9jayBzaXplIG9mIDFrIG1heSBzZWUgYSBsaW1pdCBpbXBvc2VkIGJ5IHRoZQpAQCAtMTA2LDcgKzEwNiw3IEBACiAyLjIgQ2FuZGlkYXRlIGZlYXR1cmVzIGZvciBmdXR1cmUgaW5jbHVzaW9uCiAKICogT25saW5lIGRlZnJhZyAocGF0Y2hlcyBhdmFpbGFibGUgYnV0IG5vdCB3ZWxsIHRlc3RlZCkKLSogcmVkdWNlZCBta2UyZnMgdGltZSB2aWEgbGF6eSBpdGFibGUgaW5pdGlhbGl6YXRpb24gaW4gY29uanVjdGlvbiB3aXRoCisqIHJlZHVjZWQgbWtlMmZzIHRpbWUgdmlhIGxhenkgaXRhYmxlIGluaXRpYWxpemF0aW9uIGluIGNvbmp1bmN0aW9uIHdpdGgKICAgdGhlIHVuaW5pdF9iZyBmZWF0dXJlIChjYXBhYmlsaXR5IHRvIGRvIHRoaXMgaXMgYXZhaWxhYmxlIGluIGUyZnNwcm9ncwogICBidXQgYSBrZXJuZWwgdGhyZWFkIHRvIGRvIGxhenkgemVyb2luZyBvZiB1bnVzZWQgaW5vZGUgdGFibGUgYmxvY2tzCiAgIGFmdGVyIGZpbGVzeXN0ZW0gaXMgZmlyc3QgbW91bnRlZCBpcyByZXF1aXJlZCBmb3Igc2FmZXR5KQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9nZnMyLXVldmVudHMudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9nZnMyLXVldmVudHMudHh0CmluZGV4IGZkOTY2ZGMuLmQ4MTg4OTYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZ2ZzMi11ZXZlbnRzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2dmczItdWV2ZW50cy50eHQKQEAgLTYyLDcgKzYyLDcgQEAKIAogVGhlIFJFTU9WRSB1ZXZlbnQgaXMgZ2VuZXJhdGVkIGF0IHRoZSBlbmQgb2YgYW4gdW5zdWNjZXNzZnVsIG1vdW50CiBvciBhdCB0aGUgZW5kIG9mIGEgdW1vdW50IG9mIHRoZSBmaWxlc3lzdGVtLiBBbGwgUkVNT1ZFIHVldmVudHMgd2lsbAotaGF2ZSBiZWVuIHByZWNlZWRlZCBieSBhdCBsZWFzdCBhbiBBREQgdWV2ZW50IGZvciB0aGUgc2FtZSBmaWxleXN0ZW0sCitoYXZlIGJlZW4gcHJlY2VkZWQgYnkgYXQgbGVhc3QgYW4gQUREIHVldmVudCBmb3IgdGhlIHNhbWUgZmlsZXlzdGVtLAogYW5kIHVubGlrZSB0aGUgb3RoZXIgdWV2ZW50cyBpcyBnZW5lcmF0ZWQgYXV0b21hdGljYWxseSBieSB0aGUga2VybmVsJ3MKIGtvYmplY3Qgc3Vic3lzdGVtLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2dmczIudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9nZnMyLnR4dAppbmRleCAwYjU5YzAyLi40Y2RhOTI2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2dmczIudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZ2ZzMi50eHQKQEAgLTExLDcgKzExLDcgQEAKIGZlYXR1cmVzIG9mIEdGUyBpcyBwZXJmZWN0IGNvbnNpc3RlbmN5IC0tIGNoYW5nZXMgbWFkZSB0byB0aGUgZmlsZSBzeXN0ZW0KIG9uIG9uZSBtYWNoaW5lIHNob3cgdXAgaW1tZWRpYXRlbHkgb24gYWxsIG90aGVyIG1hY2hpbmVzIGluIHRoZSBjbHVzdGVyLgogCi1HRlMgdXNlcyBpbnRlcmNoYW5nYWJsZSBpbnRlci1ub2RlIGxvY2tpbmcgbWVjaGFuaXNtcywgdGhlIGN1cnJlbnRseQorR0ZTIHVzZXMgaW50ZXJjaGFuZ2VhYmxlIGludGVyLW5vZGUgbG9ja2luZyBtZWNoYW5pc21zLCB0aGUgY3VycmVudGx5CiBzdXBwb3J0ZWQgbWVjaGFuaXNtcyBhcmU6CiAKICAgbG9ja19ub2xvY2sgLS0gYWxsb3dzIGdmcyB0byBiZSB1c2VkIGFzIGEgbG9jYWwgZmlsZSBzeXN0ZW0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvbnRmcy50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL250ZnMudHh0CmluZGV4IDkzM2JjNjYuLjc5MWFmOGQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvbnRmcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9udGZzLnR4dApAQCAtMzUwLDcgKzM1MCw3IEBACiBhbHJlYWR5IGluIHN5bmMgd2hpY2ggd2lsbCBiZSB0aGUgY2FzZSBvbiBhIGNsZWFuIHNodXRkb3duIG9mIFdpbmRvd3MuICBJZiB0aGUKIG1pcnJvcnMgYXJlIG5vdCBjbGVhbiwgeW91IGNhbiBzcGVjaWZ5IHRoZSAic3luYyIgb3B0aW9uIGluc3RlYWQgb2YgIm5vc3luYyIKIGFuZCB0aGUgRGV2aWNlLU1hcHBlciBkcml2ZXIgd2lsbCB0aGVuIGNvcHkgdGhlIGVudGlyZXR5IG9mIHRoZSAiU291cmNlIERldmljZSIKLXRvIHRoZSAiVGFyZ2V0IERldmljZSIgb3IgaWYgeW91IHNwZWNpZmllZCBtdWx0aXBsZWQgdGFyZ2V0IGRldmljZXMgdG8gYWxsIG9mCit0byB0aGUgIlRhcmdldCBEZXZpY2UiIG9yIGlmIHlvdSBzcGVjaWZpZWQgbXVsdGlwbGUgdGFyZ2V0IGRldmljZXMgdG8gYWxsIG9mCiB0aGVtLgogCiBPbmNlIHlvdSBoYXZlIHlvdXIgdGFibGUsIHNhdmUgaXQgaW4gYSBmaWxlIHNvbWV3aGVyZSAoZS5nLiAvZXRjL250ZnN2b2x1bWUxKSwKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvb2NmczIudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9vY2ZzMi50eHQKaW5kZXggNTM5M2U2Ni4uOWVkOTIwYSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9vY2ZzMi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9vY2ZzMi50eHQKQEAgLTgwLDcgKzgwLDcgQEAKIG5vdXNlcl94YXR0cgkJRGlzYWJsZXMgRXh0ZW5kZWQgVXNlciBBdHRyaWJ1dGVzLgogYWNsCQkJRW5hYmxlcyBQT1NJWCBBY2Nlc3MgQ29udHJvbCBMaXN0cyBzdXBwb3J0Lgogbm9hY2wJCSgqKQlEaXNhYmxlcyBQT1NJWCBBY2Nlc3MgQ29udHJvbCBMaXN0cyBzdXBwb3J0LgotcmVzdl9sZXZlbD0yCSgqKQlTZXQgaG93IGFncmVzc2l2ZSBhbGxvY2F0aW9uIHJlc2VydmF0aW9ucyB3aWxsIGJlLgorcmVzdl9sZXZlbD0yCSgqKQlTZXQgaG93IGFnZ3Jlc3NpdmUgYWxsb2NhdGlvbiByZXNlcnZhdGlvbnMgd2lsbCBiZS4KIAkJCVZhbGlkIHZhbHVlcyBhcmUgYmV0d2VlbiAwIChyZXNlcnZhdGlvbnMgb2ZmKSB0byA4CiAJCQkobWF4aW11bSBzcGFjZSBmb3IgcmVzZXJ2YXRpb25zKS4KIGRpcl9yZXN2X2xldmVsPQkoKikJQnkgZGVmYXVsdCwgZGlyZWN0b3J5IHJlc2VydmF0aW9ucyB3aWxsIHNjYWxlIHdpdGggZmlsZQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9wYXRoLWxvb2t1cC50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3BhdGgtbG9va3VwLnR4dAppbmRleCBlYjU5YzhiLi4zNTcxNjY3IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3BhdGgtbG9va3VwLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3BhdGgtbG9va3VwLnR4dApAQCAtNDIsNyArNDIsNyBAQAogQSBuYW1lIHN0cmluZyBzcGVjaWZpZXMgYSBzdGFydCAocm9vdCBkaXJlY3RvcnksIGN3ZCwgZmQtcmVsYXRpdmUpIGFuZCBhCiBzZXF1ZW5jZSBvZiBlbGVtZW50cyAoZGlyZWN0b3J5IGVudHJ5IG5hbWVzKSwgd2hpY2ggdG9nZXRoZXIgcmVmZXIgdG8gYSBwYXRoIGluCiB0aGUgbmFtZXNwYWNlLiBBIHBhdGggaXMgcmVwcmVzZW50ZWQgYXMgYSAoZGVudHJ5LCB2ZnNtb3VudCkgdHVwbGUuIFRoZSBuYW1lCi1lbGVtZW50cyBhcmUgc3ViLXN0cmluZ3MsIHNlcGVyYXRlZCBieSAnLycuCitlbGVtZW50cyBhcmUgc3ViLXN0cmluZ3MsIHNlcGFyYXRlZCBieSAnLycuCiAKIE5hbWUgbG9va3VwcyB3aWxsIHdhbnQgdG8gZmluZCBhIHBhcnRpY3VsYXIgcGF0aCB0aGF0IGEgbmFtZSBzdHJpbmcgcmVmZXJzIHRvCiAodXN1YWxseSB0aGUgZmluYWwgZWxlbWVudCwgb3IgcGFyZW50IG9mIGZpbmFsIGVsZW1lbnQpLiBUaGlzIGlzIGRvbmUgYnkgdGFraW5nCkBAIC0zNTQsNyArMzU0LDcgQEAKIAogV2hhdCB0aGlzIHNob3dzIGlzIHRoYXQgZmFpbGVkIHJjdS13YWxrIGxvb2t1cHMsIGllLiBvbmVzIHRoYXQgYXJlIHJlc3RhcnRlZAogZW50aXJlbHkgd2l0aCByZWYtd2FsaywgYXJlIHF1aXRlIHJhcmUuIEV2ZW4gdGhlICJ2ZnN0ZXN0IiBjYXNlIHdoaWNoCi1zcGVjaWZpY2FsbHkgaGFzIGNvbmN1cnJlbnQgcmVuYW1lcy9ta2Rpci9ybWRpci8gY3JlYXQvdW5saW5rL2V0YyB0byBleGNlcmNpc2UKK3NwZWNpZmljYWxseSBoYXMgY29uY3VycmVudCByZW5hbWVzL21rZGlyL3JtZGlyLyBjcmVhdC91bmxpbmsvZXRjIHRvIGV4ZXJjaXNlCiBzdWNoIHJhY2VzIGlzIG5vdCBzaG93aW5nIGEgaHVnZSBhbW91bnQgb2YgcmVzdGFydHMuCiAKIERyb3BwaW5nIGZyb20gcmN1LXdhbGsgdG8gcmVmLXdhbGsgbWVhbiB0aGF0IHdlIGhhdmUgZW5jb3VudGVyZWQgYSBkZW50cnkgd2hlcmUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcG9obWVsZnMvbmV0d29ya19wcm90b2NvbC50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3BvaG1lbGZzL25ldHdvcmtfcHJvdG9jb2wudHh0CmluZGV4IDQwZWE2YzIuLjY1ZTAzZGQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcG9obWVsZnMvbmV0d29ya19wcm90b2NvbC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9wb2htZWxmcy9uZXR3b3JrX3Byb3RvY29sLnR4dApAQCAtMjAsNyArMjAsNyBAQAogc28gb25lIGNhbiBleHRlbmQgcHJvdG9jb2wgYXMgbmVlZGVkIHdpdGhvdXQgYnJlYWtpbmcgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBhcyBsb25nCiBhcyBvbGQgY29tbWFuZHMgYXJlIHN1cHBvcnRlZC4gQWxsIHN0cmluZyBsZW5ndGhzIGluY2x1ZGUgdGFpbCAwIGJ5dGUuCiAKLUFsbCBjb21tYW5zIGFyZSB0cmFuc2ZlcmVkIG92ZXIgdGhlIG5ldHdvcmsgaW4gYmlnLWVuZGlhbi4gQ1BVIGVuZGlhbmVzcyBpcyB1c2VkIGF0IHRoZSBlbmQgcGVlcnMuCitBbGwgY29tbWFuZHMgYXJlIHRyYW5zZmVycmVkIG92ZXIgdGhlIG5ldHdvcmsgaW4gYmlnLWVuZGlhbi4gQ1BVIGVuZGlhbmVzcyBpcyB1c2VkIGF0IHRoZSBlbmQgcGVlcnMuCiAKIEBjbWQgLSBjb21tYW5kIG51bWJlciwgd2hpY2ggc3BlY2lmaWVzIGNvbW1hbmQgdG8gYmUgcHJvY2Vzc2VkLiBGb2xsb3dpbmcKIAljb21tYW5kcyBhcmUgdXNlZCBjdXJyZW50bHk6CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Byb2MudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9wcm9jLnR4dAppbmRleCAyM2NhZTY1Li5iMGI4MTRkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Byb2MudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcHJvYy50eHQKQEAgLTU0Myw3ICs1NDMsNyBAQAogICB0aGVpciBzdGF0aXN0aWNzIGFyZSB1c2VkIGJ5IGtlcm5lbCBkZXZlbG9wZXJzIGFuZCBpbnRlcmVzdGVkIHVzZXJzIHRvCiAgIGRldGVybWluZSB0aGUgb2NjdXJyZW5jZSBvZiBpbnRlcnJ1cHRzIG9mIHRoZSBnaXZlbiB0eXBlLgogCi1UaGUgYWJvdmUgSVJRIHZlY3RvcnMgYXJlIGRpc3BsYXllZCBvbmx5IHdoZW4gcmVsZXZlbnQuICBGb3IgZXhhbXBsZSwKK1RoZSBhYm92ZSBJUlEgdmVjdG9ycyBhcmUgZGlzcGxheWVkIG9ubHkgd2hlbiByZWxldmFudC4gIEZvciBleGFtcGxlLAogdGhlIHRocmVzaG9sZCB2ZWN0b3IgZG9lcyBub3QgZXhpc3Qgb24geDg2XzY0IHBsYXRmb3Jtcy4gIE90aGVycyBhcmUKIHN1cHByZXNzZWQgd2hlbiB0aGUgc3lzdGVtIGlzIGEgdW5pcHJvY2Vzc29yLiAgQXMgb2YgdGhpcyB3cml0aW5nLCBvbmx5CiBpMzg2IGFuZCB4ODZfNjQgcGxhdGZvcm1zIHN1cHBvcnQgdGhlIG5ldyBJUlEgdmVjdG9yIGRpc3BsYXlzLgpAQCAtMTIwMiw3ICsxMjAyLDcgQEAKICAgICAgICAgICAgICAgICAgICAgICAgVyA9IGNhbiBkbyB3cml0ZSBvcGVyYXRpb25zCiAgICAgICAgICAgICAgICAgICAgICAgIFUgPSBjYW4gZG8gdW5ibGFuawogICBmbGFncyAgICAgICAgICAgICAgICBFID0gaXQgaXMgZW5hYmxlZAotICAgICAgICAgICAgICAgICAgICAgICBDID0gaXQgaXMgcHJlZmVyZWQgY29uc29sZQorICAgICAgICAgICAgICAgICAgICAgICBDID0gaXQgaXMgcHJlZmVycmVkIGNvbnNvbGUKICAgICAgICAgICAgICAgICAgICAgICAgQiA9IGl0IGlzIHByaW1hcnkgYm9vdCBjb25zb2xlCiAgICAgICAgICAgICAgICAgICAgICAgIHAgPSBpdCBpcyB1c2VkIGZvciBwcmludGsgYnVmZmVyCiAgICAgICAgICAgICAgICAgICAgICAgIGIgPSBpdCBpcyBub3QgYSBUVFkgYnV0IGEgQnJhaWxsZSBkZXZpY2UKQEAgLTEzMzEsNyArMTMzMSw3IEBACiBEb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQuCiAKIENhdmVhdDogd2hlbiBhIHBhcmVudCB0YXNrIGlzIHNlbGVjdGVkLCB0aGUgb29tIGtpbGxlciB3aWxsIHNhY3JpZmljZSBhbnkgZmlyc3QKLWdlbmVyYXRpb24gY2hpbGRyZW4gd2l0aCBzZXBlcmF0ZSBhZGRyZXNzIHNwYWNlcyBpbnN0ZWFkLCBpZiBwb3NzaWJsZS4gIFRoaXMKK2dlbmVyYXRpb24gY2hpbGRyZW4gd2l0aCBzZXBhcmF0ZSBhZGRyZXNzIHNwYWNlcyBpbnN0ZWFkLCBpZiBwb3NzaWJsZS4gIFRoaXMKIGF2b2lkcyBzZXJ2ZXJzIGFuZCBpbXBvcnRhbnQgc3lzdGVtIGRhZW1vbnMgZnJvbSBiZWluZyBraWxsZWQgYW5kIGxvc2VzIHRoZQogbWluaW1hbCBhbW91bnQgb2Ygd29yay4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9zcXVhc2hmcy50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3NxdWFzaGZzLnR4dAppbmRleCAyZDc4ZjE5Li5kNGQ0MTQ2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3NxdWFzaGZzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3NxdWFzaGZzLnR4dApAQCAtMjE5LDcgKzIxOSw3IEBACiByZWZlcmVuY2UgdG8gd2hlcmUgdGhlIGFjdHVhbCB2YWx1ZSBpcyBzdG9yZWQpLiAgVGhpcyBhbGxvd3MgbGFyZ2UgdmFsdWVzCiB0byBiZSBzdG9yZWQgb3V0IG9mIGxpbmUgaW1wcm92aW5nIHNjYW5uaW5nIGFuZCBsb29rdXAgcGVyZm9ybWFuY2UgYW5kIGl0CiBhbHNvIGFsbG93cyB2YWx1ZXMgdG8gYmUgZGUtZHVwbGljYXRlZCwgdGhlIHZhbHVlIGJlaW5nIHN0b3JlZCBvbmNlLCBhbmQKLWFsbCBvdGhlciBvY2N1cmVuY2VzIGhvbGRpbmcgYW4gb3V0IG9mIGxpbmUgcmVmZXJlbmNlIHRvIHRoYXQgdmFsdWUuCithbGwgb3RoZXIgb2NjdXJyZW5jZXMgaG9sZGluZyBhbiBvdXQgb2YgbGluZSByZWZlcmVuY2UgdG8gdGhhdCB2YWx1ZS4KIAogVGhlIHhhdHRyIGxpc3RzIGFyZSBwYWNrZWQgaW50byBjb21wcmVzc2VkIDhLIG1ldGFkYXRhIGJsb2Nrcy4KIFRvIHJlZHVjZSBvdmVyaGVhZCBpbiBpbm9kZXMsIHJhdGhlciB0aGFuIHN0b3JpbmcgdGhlIG9uLWRpc2sKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvc3lzZnMudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9zeXNmcy50eHQKaW5kZXggZjgwNmU1MC4uNTk3ZjcyOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9zeXNmcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9zeXNmcy50eHQKQEAgLTYyLDcgKzYyLDcgQEAKIAogTWl4aW5nIHR5cGVzLCBleHByZXNzaW5nIG11bHRpcGxlIGxpbmVzIG9mIGRhdGEsIGFuZCBkb2luZyBmYW5jeQogZm9ybWF0dGluZyBvZiBkYXRhIGlzIGhlYXZpbHkgZnJvd25lZCB1cG9uLiBEb2luZyB0aGVzZSB0aGluZ3MgbWF5IGdldAoteW91IHB1YmxpY2FsbHkgaHVtaWxpYXRlZCBhbmQgeW91ciBjb2RlIHJld3JpdHRlbiB3aXRob3V0IG5vdGljZS4gCit5b3UgcHVibGljbHkgaHVtaWxpYXRlZCBhbmQgeW91ciBjb2RlIHJld3JpdHRlbiB3aXRob3V0IG5vdGljZS4gCiAKIAogQW4gYXR0cmlidXRlIGRlZmluaXRpb24gaXMgc2ltcGx5OgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy92ZnMudHh0IGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy92ZnMudHh0CmluZGV4IDgwODE1ZWQuLjIxYTdkYzQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvdmZzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQKQEAgLTk3LDcgKzk3LDcgQEAKIFRoZSBwYXNzZWQgc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgZGVzY3JpYmVzIHlvdXIgZmlsZXN5c3RlbS4gV2hlbiBhCiByZXF1ZXN0IGlzIG1hZGUgdG8gbW91bnQgYSBmaWxlc3lzdGVtIG9udG8gYSBkaXJlY3RvcnkgaW4geW91ciBuYW1lc3BhY2UsCiB0aGUgVkZTIHdpbGwgY2FsbCB0aGUgYXBwcm9wcmlhdGUgbW91bnQoKSBtZXRob2QgZm9yIHRoZSBzcGVjaWZpYwotZmlsZXN5c3RlbS4gIE5ldyB2ZnNtb3VudCByZWZlcmluZyB0byB0aGUgdHJlZSByZXR1cm5lZCBieSAtPm1vdW50KCkKK2ZpbGVzeXN0ZW0uICBOZXcgdmZzbW91bnQgcmVmZXJyaW5nIHRvIHRoZSB0cmVlIHJldHVybmVkIGJ5IC0+bW91bnQoKQogd2lsbCBiZSBhdHRhY2hlZCB0byB0aGUgbW91bnRwb2ludCwgc28gdGhhdCB3aGVuIHBhdGhuYW1lIHJlc29sdXRpb24KIHJlYWNoZXMgdGhlIG1vdW50cG9pbnQgaXQgd2lsbCBqdW1wIGludG8gdGhlIHJvb3Qgb2YgdGhhdCB2ZnNtb3VudC4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy94ZnMtZGVsYXllZC1sb2dnaW5nLWRlc2lnbi50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3hmcy1kZWxheWVkLWxvZ2dpbmctZGVzaWduLnR4dAppbmRleCA1MjgyZTNlLi4yY2UzNjQzIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3hmcy1kZWxheWVkLWxvZ2dpbmctZGVzaWduLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3hmcy1kZWxheWVkLWxvZ2dpbmctZGVzaWduLnR4dApAQCAtNDIsNyArNDIsNyBAQAogVGhpcyByZWxvZ2dpbmcgdGVjaG5pcXVlIGFsc28gYWxsb3dzIG9iamVjdHMgdG8gYmUgbW92ZWQgZm9yd2FyZCBpbiB0aGUgbG9nIHNvCiB0aGF0IGFuIG9iamVjdCBiZWluZyByZWxvZ2dlZCBkb2VzIG5vdCBwcmV2ZW50IHRoZSB0YWlsIG9mIHRoZSBsb2cgZnJvbSBldmVyCiBtb3ZpbmcgZm9yd2FyZC4gIFRoaXMgY2FuIGJlIHNlZW4gaW4gdGhlIHRhYmxlIGFib3ZlIGJ5IHRoZSBjaGFuZ2luZwotKGluY3JlYXNpbmcpIExTTiBvZiBlYWNoIHN1YnNxdWVudCB0cmFuc2FjdGlvbiAtIHRoZSBMU04gaXMgZWZmZWN0aXZlbHkgYQorKGluY3JlYXNpbmcpIExTTiBvZiBlYWNoIHN1YnNlcXVlbnQgdHJhbnNhY3Rpb24gLSB0aGUgTFNOIGlzIGVmZmVjdGl2ZWx5IGEKIGRpcmVjdCBlbmNvZGluZyBvZiB0aGUgbG9jYXRpb24gaW4gdGhlIGxvZyBvZiB0aGUgdHJhbnNhY3Rpb24uCiAKIFRoaXMgcmVsb2dnaW5nIGlzIGFsc28gdXNlZCB0byBpbXBsZW1lbnQgbG9uZy1ydW5uaW5nLCBtdWx0aXBsZS1jb21taXQKQEAgLTMzOCw3ICszMzgsNyBAQAogaW50byB0aGUgbmV3IENJTCwgdGhlbiBjaGVja3BvaW50IHRyYW5zYWN0aW9uIGNvbW1pdCBjb2RlIGNhbm5vdCB1c2UgbG9nIGl0ZW1zCiB0byBzdG9yZSB0aGUgbGlzdCBvZiBsb2cgdmVjdG9ycyB0aGF0IG5lZWQgdG8gYmUgd3JpdHRlbiBpbnRvIHRoZSB0cmFuc2FjdGlvbi4KIEhlbmNlIGxvZyB2ZWN0b3JzIG5lZWQgdG8gYmUgYWJsZSB0byBiZSBjaGFpbmVkIHRvZ2V0aGVyIHRvIGFsbG93IHRoZW0gdG8gYmUKLWRldGF0Y2hlZCBmcm9tIHRoZSBsb2cgaXRlbXMuIFRoYXQgaXMsIHdoZW4gdGhlIENJTCBpcyBmbHVzaGVkIHRoZSBtZW1vcnkKK2RldGFjaGVkIGZyb20gdGhlIGxvZyBpdGVtcy4gVGhhdCBpcywgd2hlbiB0aGUgQ0lMIGlzIGZsdXNoZWQgdGhlIG1lbW9yeQogYnVmZmVyIGFuZCBsb2cgdmVjdG9yIGF0dGFjaGVkIHRvIGVhY2ggbG9nIGl0ZW0gbmVlZHMgdG8gYmUgYXR0YWNoZWQgdG8gdGhlCiBjaGVja3BvaW50IGNvbnRleHQgc28gdGhhdCB0aGUgbG9nIGl0ZW0gY2FuIGJlIHJlbGVhc2VkLiBJbiBkaWFncmFtbWF0aWMgZm9ybSwKIHRoZSBDSUwgd291bGQgbG9vayBsaWtlIHRoaXMgYmVmb3JlIHRoZSBmbHVzaDoKQEAgLTU3Nyw3ICs1NzcsNyBAQAogcGVuZGluZyB0cmFuc2FjdGlvbnMuIFRodXMgdGhlIHBpbm5pbmcgYW5kIHVucGlubmluZyBvZiBhIGxvZyBpdGVtIGlzIHN5bW1ldHJpYwogYXMgdGhlcmUgaXMgYSAxOjEgcmVsYXRpb25zaGlwIHdpdGggdHJhbnNhY3Rpb24gY29tbWl0IGFuZCBsb2cgaXRlbSBjb21wbGV0aW9uLgogCi1Gb3IgZGVsYXllZCBsb2dnaW5nLCBob3dldmVyLCB3ZSBoYXZlIGFuIGFzc3ltZXRyaWMgdHJhbnNhY3Rpb24gY29tbWl0IHRvCitGb3IgZGVsYXllZCBsb2dnaW5nLCBob3dldmVyLCB3ZSBoYXZlIGFuIGFzeW1tZXRyaWMgdHJhbnNhY3Rpb24gY29tbWl0IHRvCiBjb21wbGV0aW9uIHJlbGF0aW9uc2hpcC4gRXZlcnkgdGltZSBhbiBvYmplY3QgaXMgcmVsb2dnZWQgaW4gdGhlIENJTCBpdCBnb2VzCiB0aHJvdWdoIHRoZSBjb21taXQgcHJvY2VzcyB3aXRob3V0IGEgY29ycmVzcG9uZGluZyBjb21wbGV0aW9uIGJlaW5nIHJlZ2lzdGVyZWQuCiBUaGF0IGlzLCB3ZSBub3cgaGF2ZSBhIG1hbnktdG8tb25lIHJlbGF0aW9uc2hpcCBiZXR3ZWVuIHRyYW5zYWN0aW9uIGNvbW1pdCBhbmQKQEAgLTc4MCw3ICs3ODAsNyBAQAogRnJvbSB0aGlzLCBpdCBjYW4gYmUgc2VlbiB0aGF0IHRoZSBvbmx5IGxpZmUgY3ljbGUgZGlmZmVyZW5jZXMgYmV0d2VlbiB0aGUgdHdvCiBsb2dnaW5nIG1ldGhvZHMgYXJlIGluIHRoZSBtaWRkbGUgb2YgdGhlIGxpZmUgY3ljbGUgLSB0aGV5IHN0aWxsIGhhdmUgdGhlIHNhbWUKIGJlZ2lubmluZyBhbmQgZW5kIGFuZCBleGVjdXRpb24gY29uc3RyYWludHMuIFRoZSBvbmx5IGRpZmZlcmVuY2VzIGFyZSBpbiB0aGUKLWNvbW1pdGluZyBvZiB0aGUgbG9nIGl0ZW1zIHRvIHRoZSBsb2cgaXRzZWxmIGFuZCB0aGUgY29tcGxldGlvbiBwcm9jZXNzaW5nLgorY29tbWl0dGluZyBvZiB0aGUgbG9nIGl0ZW1zIHRvIHRoZSBsb2cgaXRzZWxmIGFuZCB0aGUgY29tcGxldGlvbiBwcm9jZXNzaW5nLgogSGVuY2UgZGVsYXllZCBsb2dnaW5nIHNob3VsZCBub3QgaW50cm9kdWNlIGFueSBjb25zdHJhaW50cyBvbiBsb2cgaXRlbQogYmVoYXZpb3VyLCBhbGxvY2F0aW9uIG9yIGZyZWVpbmcgdGhhdCBkb24ndCBhbHJlYWR5IGV4aXN0LgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2h3bW9uL2FiaXR1Z3VydSBiL0RvY3VtZW50YXRpb24vaHdtb24vYWJpdHVndXJ1CmluZGV4IDVlYjNiOWQuLjkxNWYzMjAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaHdtb24vYWJpdHVndXJ1CisrKyBiL0RvY3VtZW50YXRpb24vaHdtb24vYWJpdHVndXJ1CkBAIC03OCw3ICs3OCw3IEBACiAKIFRoZSBmaXJzdCBhbmQgc2Vjb25kIHJldmlzaW9uIG9mIHRoZSB1R3VydSBjaGlwIGluIHJlYWxpdHkgaXMgYSBXaW5ib25kCiBXODNMOTUwRCBpbiBkaXNndWlzZSAoZGVzcGl0ZSBBYml0IGNsYWltaW5nIGl0IGlzICJhIG5ldyBtaWNyb3Byb2Nlc3NvcgotZGVzaWduZWQgYnkgdGhlIEFCSVQgRW5naW5lZXJzIikuIFVuZm9ydHVuYXRseSB0aGlzIGRvZXNuJ3QgaGVscCBzaW5jZSB0aGUKK2Rlc2lnbmVkIGJ5IHRoZSBBQklUIEVuZ2luZWVycyIpLiBVbmZvcnR1bmF0ZWx5IHRoaXMgZG9lc24ndCBoZWxwIHNpbmNlIHRoZQogVzgzTDk1MEQgaXMgYSBnZW5lcmljIG1pY3JvY29udHJvbGxlciB3aXRoIGEgY3VzdG9tIEFiaXQgYXBwbGljYXRpb24gcnVubmluZwogb24gaXQuCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vYWJpdHVndXJ1LWRhdGFzaGVldCBiL0RvY3VtZW50YXRpb24vaHdtb24vYWJpdHVndXJ1LWRhdGFzaGVldAppbmRleCBkOTI1MWVmLi44ZDJiZThhIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2h3bW9uL2FiaXR1Z3VydS1kYXRhc2hlZXQKKysrIGIvRG9jdW1lbnRhdGlvbi9od21vbi9hYml0dWd1cnUtZGF0YXNoZWV0CkBAIC01LDkgKzUsOSBAQAogZGF0YXNoZWV0IGZyb20gQWJpdC4gVGhlIGRhdGEgSSBoYXZlIGdvdCBvbiB1R3VydSBoYXZlIEkgYXNzZW1ibGVkIHRocm91Z2gKIG15IHdlYWsga25vd2xlZGdlIGluICJiYWNrd2FyZHMgZW5naW5lZXJpbmciLgogQW5kIGp1c3QgZm9yIHRoZSByZWNvcmQsIHlvdSBtYXkgaGF2ZSBub3RpY2VkIHVHdXJ1IGlzbid0IGEgY2hpcCBkZXZlbG9wZWQgYnkKLUFiaXQsIGFzIHRoZXkgY2xhaW0gaXQgdG8gYmUuIEl0J3MgcmVhbHkganVzdCBhbiBtaWNyb3Byb2Nlc3NvciAodUMpIGNyZWF0ZWQgYnkKK0FiaXQsIGFzIHRoZXkgY2xhaW0gaXQgdG8gYmUuIEl0J3MgcmVhbGx5IGp1c3QgYW4gbWljcm9wcm9jZXNzb3IgKHVDKSBjcmVhdGVkIGJ5CiBXaW5ib25kIChXODNMOTUwRCkuIEFuZCBubywgcmVhZGluZyB0aGUgbWFudWFsIGZvciB0aGlzIHNwZWNpZmljIHVDIG9yCi1tYWlsaW5nICBXaW5kYm9uZCBmb3IgaGVscCB3b24ndCBnaXZlIGFueSB1c2VmdWxsIGRhdGEgYWJvdXQgdUd1cnUsIGFzIGl0IGlzCittYWlsaW5nICBXaW5kYm9uZCBmb3IgaGVscCB3b24ndCBnaXZlIGFueSB1c2VmdWwgZGF0YSBhYm91dCB1R3VydSwgYXMgaXQgaXMKIHRoZSBwcm9ncmFtIGluc2lkZSB0aGUgdUMgdGhhdCBpcyByZXNwb25kaW5nIHRvIGNhbGxzLgogCiBPbGxlIFNhbmRiZXJnIDxvbGxlYnVsbEBnbWFpbC5jb20+LCAyMDA1LTA1LTI1CkBAIC00MSw3ICs0MSw3IEBACiAKIEFmdGVyIHdpZGVyIHRlc3Rpbmcgb2YgdGhlIExpbnV4IGtlcm5lbCBkcml2ZXIgc29tZSB2YXJpYW50cyBvZiB0aGUgdUd1cnUgaGF2ZQogdHVybmVkIHVwIHdoaWNoIHdpbGwgaG9sZCAweDAwIGluc3RlYWQgb2YgMHhBQyBhdCB0aGUgQ01EIHBvcnQsIHRodXMgd2UgYWxzbwotaGF2ZSB0byB0ZXN0IENNRCBmb3IgdHdvIGRpZmZlcmVudCB2YWx1ZXMuIE9uIHRoZXNlIHVHdXJ1J3MgREFUQSB3aWxsIGluaXRhbGx5CitoYXZlIHRvIHRlc3QgQ01EIGZvciB0d28gZGlmZmVyZW50IHZhbHVlcy4gT24gdGhlc2UgdUd1cnUncyBEQVRBIHdpbGwgaW5pdGlhbGx5CiBob2xkIDB4MDkgYW5kIHdpbGwgb25seSBob2xkIDB4MDggYWZ0ZXIgcmVhZGluZyBDTUQgZmlyc3QsIHNvIENNRCBtdXN0IGJlIHJlYWQKIGZpcnN0IQogCkBAIC0zMDgsNSArMzA4LDUgQEAKIHJlc3VsdGVkIGluIGEgX3Blcm1hbmVudF8gcmVwcm9ncmFtbWluZyBvZiB0aGUgdm9sdGFnZXMsIGx1Y2tpbHkgSSBoYWQgdGhlCiBzZW5zb3JzIHBhcnQgY29uZmlndXJlZCBzbyB0aGF0IGl0IHdvdWxkIHNodXRkb3duIG15IHN5c3RlbSBvbiBhbnkgb3V0IG9mIHNwZWMKIHZvbHRhZ2VzIHdoaWNoIHByb3ByYWJseSBzYWZlZCBteSBjb21wdXRlciAoYWZ0ZXIgYSByZWJvb3QgSSBtYW5hZ2VkIHRvCi1pbW1lZGlhdGx5IGVudGVyIHRoZSBiaW9zIGFuZCByZWxvYWQgdGhlIGRlZmF1bHRzKS4gVGhpcyBwcm9iYWJseSBtZWFucyB0aGF0CitpbW1lZGlhdGVseSBlbnRlciB0aGUgYmlvcyBhbmQgcmVsb2FkIHRoZSBkZWZhdWx0cykuIFRoaXMgcHJvYmFibHkgbWVhbnMgdGhhdAogdGhlIHJlYWQvd3JpdGUgY3ljbGUgZm9yIHRoZSBub24gc2Vuc29yIHBhcnQgaXMgZGlmZmVyZW50IGZyb20gdGhlIHNlbnNvciBwYXJ0LgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi9hYml0dWd1cnUzIGIvRG9jdW1lbnRhdGlvbi9od21vbi9hYml0dWd1cnUzCmluZGV4IGZhNTk4YWEuLmE2Y2NmZTQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaHdtb24vYWJpdHVndXJ1MworKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL2FiaXR1Z3VydTMKQEAgLTQ3LDcgKzQ3LDcgQEAKIHRoZSBBYml0IHVHdXJ1IGNoaXAsIGZvdW5kIG9uIHJlY2VudCBBYml0IHVHdXJ1IGZlYXR1cmluZyBtb3RoZXJib2FyZHMuCiAKIFRoZSAzcmQgcmV2aXNpb24gb2YgdGhlIHVHdXJ1IGNoaXAgaW4gcmVhbGl0eSBpcyBhIFdpbmJvbmQgVzgzTDk1MUcuCi1VbmZvcnR1bmF0bHkgdGhpcyBkb2Vzbid0IGhlbHAgc2luY2UgdGhlIFc4M0w5NTFHIGlzIGEgZ2VuZXJpYyBtaWNyb2NvbnRyb2xsZXIKK1VuZm9ydHVuYXRlbHkgdGhpcyBkb2Vzbid0IGhlbHAgc2luY2UgdGhlIFc4M0w5NTFHIGlzIGEgZ2VuZXJpYyBtaWNyb2NvbnRyb2xsZXIKIHdpdGggYSBjdXN0b20gQWJpdCBhcHBsaWNhdGlvbiBydW5uaW5nIG9uIGl0LgogCiBEZXNwaXRlIEFiaXQgbm90IHJlbGVhc2luZyBhbnkgaW5mb3JtYXRpb24gcmVnYXJkaW5nIHRoZSB1R3VydSByZXZpc2lvbiAzLApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi9wbWJ1cyBiL0RvY3VtZW50YXRpb24vaHdtb24vcG1idXMKaW5kZXggZjJkNDJlOC4uZGM0OTMzZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9od21vbi9wbWJ1cworKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3BtYnVzCkBAIC0xNTAsMTEgKzE1MCwxMSBAQAogYXR0cmlidXRlcyBhcmUgcmVhZC1vbmx5LgogCiBpblhfaW5wdXQJCU1lYXN1cmVkIHZvbHRhZ2UuIEZyb20gUkVBRF9WSU4gb3IgUkVBRF9WT1VUIHJlZ2lzdGVyLgotaW5YX21pbgkJCU1pbnVtdW0gVm9sdGFnZS4KK2luWF9taW4JCQlNaW5pbXVtIFZvbHRhZ2UuCiAJCQlGcm9tIFZJTl9VVl9XQVJOX0xJTUlUIG9yIFZPVVRfVVZfV0FSTl9MSU1JVCByZWdpc3Rlci4KIGluWF9tYXgJCQlNYXhpbXVtIHZvbHRhZ2UuCiAJCQlGcm9tIFZJTl9PVl9XQVJOX0xJTUlUIG9yIFZPVVRfT1ZfV0FSTl9MSU1JVCByZWdpc3Rlci4KLWluWF9sY3JpdAkJQ3JpdGljYWwgbWludW11bSBWb2x0YWdlLgoraW5YX2xjcml0CQlDcml0aWNhbCBtaW5pbXVtIFZvbHRhZ2UuCiAJCQlGcm9tIFZJTl9VVl9GQVVMVF9MSU1JVCBvciBWT1VUX1VWX0ZBVUxUX0xJTUlUIHJlZ2lzdGVyLgogaW5YX2NyaXQJCUNyaXRpY2FsIG1heGltdW0gdm9sdGFnZS4KIAkJCUZyb20gVklOX09WX0ZBVUxUX0xJTUlUIG9yIFZPVVRfT1ZfRkFVTFRfTElNSVQgcmVnaXN0ZXIuCkBAIC0xNjksNyArMTY5LDcgQEAKIGN1cnJYX2lucHV0CQlNZWFzdXJlZCBjdXJyZW50LiBGcm9tIFJFQURfSUlOIG9yIFJFQURfSU9VVCByZWdpc3Rlci4KIGN1cnJYX21heAkJTWF4aW11bSBjdXJyZW50LgogCQkJRnJvbSBJSU5fT0NfV0FSTl9MSU1JVCBvciBJT1VUX09DX1dBUk5fTElNSVQgcmVnaXN0ZXIuCi1jdXJyWF9sY3JpdAkJQ3JpdGljYWwgbWludW11bSBvdXRwdXQgY3VycmVudC4KK2N1cnJYX2xjcml0CQlDcml0aWNhbCBtaW5pbXVtIG91dHB1dCBjdXJyZW50LgogCQkJRnJvbSBJT1VUX1VDX0ZBVUxUX0xJTUlUIHJlZ2lzdGVyLgogY3VyclhfY3JpdAkJQ3JpdGljYWwgbWF4aW11bSBjdXJyZW50LgogCQkJRnJvbSBJSU5fT0NfRkFVTFRfTElNSVQgb3IgSU9VVF9PQ19GQVVMVF9MSU1JVCByZWdpc3Rlci4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vc3lzZnMtaW50ZXJmYWNlIGIvRG9jdW1lbnRhdGlvbi9od21vbi9zeXNmcy1pbnRlcmZhY2UKaW5kZXggODNhNjk4Ny4uOGY2M2MyNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9od21vbi9zeXNmcy1pbnRlcmZhY2UKKysrIGIvRG9jdW1lbnRhdGlvbi9od21vbi9zeXNmcy1pbnRlcmZhY2UKQEAgLTU3OSw3ICs1NzksNyBAQAogZmFuWzEtKl1fZmF1bHQKIHRlbXBbMS0qXV9mYXVsdAogCQlJbnB1dCBmYXVsdCBjb25kaXRpb24KLQkJMDogbm8gZmF1bHQgb2NjdXJlZAorCQkwOiBubyBmYXVsdCBvY2N1cnJlZAogCQkxOiBmYXVsdCBjb25kaXRpb24KIAkJUk8KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi93ODM3ODFkIGIvRG9jdW1lbnRhdGlvbi9od21vbi93ODM3ODFkCmluZGV4IGVjYmMxZTQuLjEyOWIwYTMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaHdtb24vdzgzNzgxZAorKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3c4Mzc4MWQKQEAgLTQwMyw3ICs0MDMsNyBAQAogCiAweDgwIC0gc2VlbXMgdG8gdHVybiBmYW5zIG9mZiBhZnRlciBzb21lIHRpbWUoMS0yIG1pbnV0ZXMpLi4uIG1pZ2h0IGJlCiBzb21lIGZvcm0gb2YgYXV0by1mYW4tY29udHJvbCBiYXNlZCBvbiB0ZW1wPyBobW0gKFFmYW4/IHRoaXMgbW9ibyBpcyBhbgotb2xkIEFTVVMsIGl0IGlzbid0IG1hcmtldGVkIGFzIFFmYW4uIE1heWJlIHNvbWUgYmV0YSBwcmUtYXR0ZW1wIGF0IFFmYW4KK29sZCBBU1VTLCBpdCBpc24ndCBtYXJrZXRlZCBhcyBRZmFuLiBNYXliZSBzb21lIGJldGEgcHJlLWF0dGVtcHQgYXQgUWZhbgogdGhhdCB3YXMgZHJvcHBlZCBhdCB0aGUgQklPUykKIDB4ODEgLSBvZmYKIDB4ODIgLSBzbGlnaHRseSAib24tbmVyIiB0aGFuIG9mZiwgYnV0IG15IGZhbnMgZG8gbm90IGdldCB0byBtb3ZlLiBJIGNhbgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi93ODM3OTFkIGIvRG9jdW1lbnRhdGlvbi9od21vbi93ODM3OTFkCmluZGV4IDU2NjNlNDkuLjkwMzg3YzMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaHdtb24vdzgzNzkxZAorKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3c4Mzc5MWQKQEAgLTkzLDcgKzkzLDcgQEAKIG1ldGhvZCBvZiBhIHNpbmdsZSBzeXNmcyBiZWVwX21hc2sgZmlsZSB0byBhIG5ld2VyIG1ldGhvZCB1c2luZyBtdWx0aXBsZQogKl9iZWVwIGZpbGVzIGFzIGRlc2NyaWJlZCBpbiAuLi4vRG9jdW1lbnRhdGlvbi9od21vbi9zeXNmcy1pbnRlcmZhY2UuCiAKLUEgc2ltaWxhciBjaGFuZ2UgaGFzIG9jY3VyZWQgZm9yIHRoZSBiaXRtYXAgY29ycmVzcG9uZGluZyB0byB0aGUgYWxhcm1zLiBUaGUKK0Egc2ltaWxhciBjaGFuZ2UgaGFzIG9jY3VycmVkIGZvciB0aGUgYml0bWFwIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGFsYXJtcy4gVGhlCiBvcmlnaW5hbCBsZWdhY3kgbWV0aG9kIHVzZWQgYSBzaW5nbGUgc3lzZnMgYWxhcm1zIGZpbGUgY29udGFpbmluZyBhIGJpdG1hcAogb2YgdHJpZ2dlcmVkIGFsYXJtcy4gVGhlIG5ld2VyIG1ldGhvZCB1c2VzIG11bHRpcGxlIHN5c2ZzICpfYWxhcm0gZmlsZXMKIChhZ2FpbiBmb2xsb3dpbmcgdGhlIHBhdHRlcm4gZGVzY3JpYmVkIGluIHN5c2ZzLWludGVyZmFjZSkuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2kyYy9idXNzZXMvaTJjLXBhcnBvcnQtbGlnaHQgYi9Eb2N1bWVudGF0aW9uL2kyYy9idXNzZXMvaTJjLXBhcnBvcnQtbGlnaHQKaW5kZXggYmRjOWNiYi4uYzIyZWUwNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9pMmMvYnVzc2VzL2kyYy1wYXJwb3J0LWxpZ2h0CisrKyBiL0RvY3VtZW50YXRpb24vaTJjL2J1c3Nlcy9pMmMtcGFycG9ydC1saWdodApAQCAtNCw3ICs0LDcgQEAKIAogVGhpcyBkcml2ZXIgaXMgYSBsaWdodCB2ZXJzaW9uIG9mIGkyYy1wYXJwb3J0LiBJdCBkb2Vzbid0IGRlcGVuZCAgICAgICAgCiBvbiB0aGUgcGFycG9ydCBkcml2ZXIsIGFuZCB1c2VzIGRpcmVjdCBJL08gYWNjZXNzIGluc3RlYWQuIFRoaXMgbWlnaHQgYmUKLXByZWZlcmVkIG9uIGVtYmVkZGVkIHN5c3RlbXMgd2hlcmUgd2FzdGluZyBtZW1vcnkgZm9yIHRoZSBjbGVhbiBidXQgaGVhdnkKK3ByZWZlcnJlZCBvbiBlbWJlZGRlZCBzeXN0ZW1zIHdoZXJlIHdhc3RpbmcgbWVtb3J5IGZvciB0aGUgY2xlYW4gYnV0IGhlYXZ5CiBwYXJwb3J0IGhhbmRsaW5nIGlzIG5vdCBhbiBvcHRpb24uIFRoZSBkcmF3YmFjayBpcyBhIHJlZHVjZWQgcG9ydGFiaWxpdHkKIGFuZCB0aGUgaW1wb3NzaWJpbGl0eSB0byBkYWlzeS1jaGFpbiBvdGhlciBwYXJhbGxlbCBwb3J0IGRldmljZXMuICAgICAgICAgICAgICAgICAKICAgCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2kyYy9idXNzZXMvaTJjLXNpczk2eCBiL0RvY3VtZW50YXRpb24vaTJjL2J1c3Nlcy9pMmMtc2lzOTZ4CmluZGV4IDcwZTZhMGMuLjBiOTc5ZjMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaTJjL2J1c3Nlcy9pMmMtc2lzOTZ4CisrKyBiL0RvY3VtZW50YXRpb24vaTJjL2J1c3Nlcy9pMmMtc2lzOTZ4CkBAIC0zNSw3ICszNSw3IEBACiAKIChrZXJuZWwgdmVyc2lvbnMgbGF0ZXIgdGhhbiAyLjQuMTggbWF5IGZpbGwgaW4gdGhlICJVbmtub3duInMpCiAKLUlmIHlvdSBjYW50IHNlZSBpdCBwbGVhc2UgbG9vayBvbiBxdWlya19zaXNfOTZ4X3NtYnVzCitJZiB5b3UgY2FuJ3Qgc2VlIGl0IHBsZWFzZSBsb29rIG9uIHF1aXJrX3Npc185Nnhfc21idXMKIChkcml2ZXJzL3BjaS9xdWlya3MuYykgKGFsc28gaWYgc291dGhicmlkZ2UgZGV0ZWN0aW9uIGZhaWxzKQogCiBJIHN1c3BlY3QgdGhhdCB0aGlzIGRyaXZlciBjb3VsZCBiZSBtYWRlIHRvIHdvcmsgZm9yIHRoZSBmb2xsb3dpbmcgU2lTCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2kyYy9idXNzZXMvaTJjLXRhb3MtZXZtIGIvRG9jdW1lbnRhdGlvbi9pMmMvYnVzc2VzL2kyYy10YW9zLWV2bQppbmRleCA5MTQ2ZTMzLi42M2Y2MmJjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2kyYy9idXNzZXMvaTJjLXRhb3MtZXZtCisrKyBiL0RvY3VtZW50YXRpb24vaTJjL2J1c3Nlcy9pMmMtdGFvcy1ldm0KQEAgLTEzLDcgKzEzLDcgQEAKIAogKiBUQU9TIFRTTDI1NTAgRVZNCiAKLUZvciBhZGR0aW9uYWwgaW5mb3JtYXRpb24gb24gVEFPUyBwcm9kdWN0cywgcGxlYXNlIHNlZQorRm9yIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gb24gVEFPUyBwcm9kdWN0cywgcGxlYXNlIHNlZQogICBodHRwOi8vd3d3LnRhb3NpbmMuY29tLwogCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaTJvL1JFQURNRSBiL0RvY3VtZW50YXRpb24vaTJvL1JFQURNRQppbmRleCAwZWJmNThjLi5lZTkxZTI2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2kyby9SRUFETUUKKysrIGIvRG9jdW1lbnRhdGlvbi9pMm8vUkVBRE1FCkBAIC01Myw3ICs1Myw3IEBACiBCb3hIaWxsIENvcnBvcmF0aW9uCiAJTG9hbiBvZiBpbml0aWFsIEZpYnJlQ2hhbm5lbCBkaXNrIGFycmF5IHVzZWQgZm9yIGRldmVsb3BtZW50IHdvcmsuCiAKLUV1cm9wZWFuIENvbWlzc2lvbgorRXVyb3BlYW4gQ29tbWlzc2lvbgogCUZ1bmRpbmcgdGhlIHdvcmsgZG9uZSBieSB0aGUgVW5pdmVyc2l0eSBvZiBIZWxzaW5raQogCiBTeXNLb25uZWN0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2lhNjQvYWxpYXNpbmctdGVzdC5jIGIvRG9jdW1lbnRhdGlvbi9pYTY0L2FsaWFzaW5nLXRlc3QuYwppbmRleCAzZGZiNzZjLi41Y2FhMmFmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2lhNjQvYWxpYXNpbmctdGVzdC5jCisrKyBiL0RvY3VtZW50YXRpb24vaWE2NC9hbGlhc2luZy10ZXN0LmMKQEAgLTE3Nyw3ICsxNzcsNyBAQAogCiAJCQkvKgogCQkJICogSXQncyBPSyBpZiB0aGUgUk9NIGlzIHVucmVhZGFibGUuICBNYXliZSB0aGVyZQotCQkJICogaXMgbm8gUk9NLCBvciBzb21lIG90aGVyIGVycm9yIG9jdXJyZWQuICBUaGUKKwkJCSAqIGlzIG5vIFJPTSwgb3Igc29tZSBvdGhlciBlcnJvciBvY2N1cnJlZC4gIFRoZQogCQkJICogaW1wb3J0YW50IHRoaW5nIGlzIHRoYXQgbm8gTUNBIGhhcHBlbmVkLgogCQkJICovCiAJCQlpZiAocmMgPiAwKQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9pbnB1dC9qb3lzdGljay1wYXJwb3J0LnR4dCBiL0RvY3VtZW50YXRpb24vaW5wdXQvam95c3RpY2stcGFycG9ydC50eHQKaW5kZXggMWM4NTZmMy4uNTY4NzBjNyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9pbnB1dC9qb3lzdGljay1wYXJwb3J0LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2lucHV0L2pveXN0aWNrLXBhcnBvcnQudHh0CkBAIC0yNzIsNyArMjcyLDcgQEAKIAogICBBbHNvLCB0aGUgY29ubmVjdGlvbiBpcyBhIGJpdCBtb3JlIGNvbXBsZXguIFlvdSdsbCBuZWVkIGEgYnVuY2ggb2YgZGlvZGVzLAogYW5kIG9uZSBwdWxsdXAgcmVzaXN0b3IuIEZpcnN0LCB5b3UgY29ubmVjdCB0aGUgRGlyZWN0aW9ucyBhbmQgdGhlIGJ1dHRvbgotdGhlIHNhbWUgYXMgZm9yIGRiOSwgaG93ZXZlciB3aXRoIHRoZSBkaW9kZXMgaW5iZXR3ZWVuLgordGhlIHNhbWUgYXMgZm9yIGRiOSwgaG93ZXZlciB3aXRoIHRoZSBkaW9kZXMgYmV0d2Vlbi4KIAogCSAgICBEaW9kZXMKIChwaW4gMikgLS0tLS18PHwtLS0tPiBVcApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9pbnB1dC9yb3RhcnktZW5jb2Rlci50eHQgYi9Eb2N1bWVudGF0aW9uL2lucHV0L3JvdGFyeS1lbmNvZGVyLnR4dAppbmRleCA4YjQxMjlkLi45NDNlOGY2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2lucHV0L3JvdGFyeS1lbmNvZGVyLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2lucHV0L3JvdGFyeS1lbmNvZGVyLnR4dApAQCAtNDYsNyArNDYsNyBAQAogCiBkKSBGYWxsaW5nIGVkZ2Ugb24gY2hhbm5lbCBCLCBjaGFubmVsIEEgaW4gbG93IHN0YXRlCiAJUGFya2luZyBwb3NpdGlvbi4gSWYgdGhlIGVuY29kZXIgZW50ZXJzIHRoaXMgc3RhdGUsIGEgZnVsbCB0cmFuc2l0aW9uCi0Jc2hvdWxkIGhhdmUgaGFwcGVuZCwgdW5sZXNzIGl0IGZsaXBwZWQgYmFjayBvbiBoYWxmIHRoZSB3YXkuIFRoZQorCXNob3VsZCBoYXZlIGhhcHBlbmVkLCB1bmxlc3MgaXQgZmxpcHBlZCBiYWNrIG9uIGhhbGYgdGhlIHdheS4gVGhlCiAJJ2FybWVkJyBzdGF0ZSB0ZWxscyB1cyBhYm91dCB0aGF0LgogCiAyLiBQbGF0Zm9ybSByZXF1aXJlbWVudHMKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaW5wdXQvd2Fsa2VyYTA3MDEudHh0IGIvRG9jdW1lbnRhdGlvbi9pbnB1dC93YWxrZXJhMDcwMS50eHQKaW5kZXggOGY0Mjg5ZS4uNTYxMzg1ZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9pbnB1dC93YWxrZXJhMDcwMS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9pbnB1dC93YWxrZXJhMDcwMS50eHQKQEAgLTc3LDcgKzc3LDcgQEAKIAogMjQgYmluK29jdCB2YWx1ZXMgKyAxIGJpbiB2YWx1ZSA9IDI0KjQrMSBiaXRzICA9IDk3IGJpdHMKIAotKFdhcm5pbmcsIHB1bHNlcyBvbiBBQ0sgYXIgaW52ZXJ0ZWQgYnkgdHJhbnNpc3RvciwgaXJxIGlzIHJpc2VkIHVwIG9uIHN5bmMKKyhXYXJuaW5nLCBwdWxzZXMgb24gQUNLIGFyZSBpbnZlcnRlZCBieSB0cmFuc2lzdG9yLCBpcnEgaXMgcmFpc2VkIHVwIG9uIHN5bmMKIHRvIGJpbiBjaGFuZ2Ugb3Igb2N0YWwgdmFsdWUgdG8gYmluIGNoYW5nZSkuCiAKIEJpbmFyeSBkYXRhIHJlcHJlc2VudGF0aW9uczoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaXJxZmxhZ3MtdHJhY2luZy50eHQgYi9Eb2N1bWVudGF0aW9uL2lycWZsYWdzLXRyYWNpbmcudHh0CmluZGV4IDZhNDQ0ODcuLjY3YWE3MWUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaXJxZmxhZ3MtdHJhY2luZy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9pcnFmbGFncy10cmFjaW5nLnR4dApAQCAtNTMsNSArNTMsNSBAQAogdHVybiBpdHNlbGYgb2ZmLiBJLmUuIHRoZSBsb2NrIHZhbGlkYXRvciB3aWxsIHN0aWxsIGJlIHJlbGlhYmxlLiBUaGVyZQogc2hvdWxkIGJlIG5vIGNyYXNoZXMgZHVlIHRvIGlycS10cmFjaW5nIGJ1Z3MuIChleGNlcHQgaWYgdGhlIGFzc2VtYmx5CiBjaGFuZ2VzIGJyZWFrIG90aGVyIGNvZGUgYnkgbW9kaWZ5aW5nIGNvbmRpdGlvbnMgb3IgcmVnaXN0ZXJzIHRoYXQKLXNob3VsZG50IGJlKQorc2hvdWxkbid0IGJlKQogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2lzZG4vSU5URVJGQUNFLkNBUEkgYi9Eb2N1bWVudGF0aW9uL2lzZG4vSU5URVJGQUNFLkNBUEkKaW5kZXggMzA5ZWI1ZS4uMTY4OGI1YSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9pc2RuL0lOVEVSRkFDRS5DQVBJCisrKyBiL0RvY3VtZW50YXRpb24vaXNkbi9JTlRFUkZBQ0UuQ0FQSQpAQCAtMjQwLDcgKzI0MCw3IEBACiBtZXNzYWdlcyBiZXR3ZWVuIHRoZWlyIHRyYW5zcG9ydCBlbmNvZGluZyBkZXNjcmliZWQgaW4gdGhlIENBUEkgMi4wIHN0YW5kYXJkCiBhbmQgdGhlaXIgX2Ntc2cgc3RydWN0dXJlIHJlcHJlc2VudGF0aW9uLiBOb3RlIHRoYXQgY2FwaV9jbXNnMm1lc3NhZ2UoKSBkb2VzCiBub3Qga25vdyBvciBjaGVjayB0aGUgc2l6ZSBvZiBpdHMgZGVzdGluYXRpb24gYnVmZmVyLiBUaGUgY2FsbGVyIG11c3QgbWFrZQotc3VyZSBpdCBpcyBiaWcgZW5vdWdoIHRvIGFjY29tb2RhdGUgdGhlIHJlc3VsdGluZyBDQVBJIG1lc3NhZ2UuCitzdXJlIGl0IGlzIGJpZyBlbm91Z2ggdG8gYWNjb21tb2RhdGUgdGhlIHJlc3VsdGluZyBDQVBJIG1lc3NhZ2UuCiAKIAogNS4gTG93ZXIgTGF5ZXIgSW50ZXJmYWNlIEZ1bmN0aW9ucwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9rYnVpbGQva2J1aWxkLnR4dCBiL0RvY3VtZW50YXRpb24va2J1aWxkL2tidWlsZC50eHQKaW5kZXggZjE0MzFkMC4uN2MyYTg5YiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9rYnVpbGQva2J1aWxkLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2tidWlsZC9rYnVpbGQudHh0CkBAIC0yNiwxMSArMjYsMTEgQEAKIAogQUZMQUdTX01PRFVMRQogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLUFkZHRpb25hbCBtb2R1bGUgc3BlY2lmaWMgb3B0aW9ucyB0byB1c2UgZm9yICQoQVMpLgorQWRkaXRpb25hbCBtb2R1bGUgc3BlY2lmaWMgb3B0aW9ucyB0byB1c2UgZm9yICQoQVMpLgogCiBBRkxBR1NfS0VSTkVMCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotQWRkdGlvbmFsIG9wdGlvbnMgZm9yICQoQVMpIHdoZW4gdXNlZCBmb3IgYXNzZW1ibGVyCitBZGRpdGlvbmFsIG9wdGlvbnMgZm9yICQoQVMpIHdoZW4gdXNlZCBmb3IgYXNzZW1ibGVyCiBjb2RlIGZvciBjb2RlIHRoYXQgaXMgY29tcGlsZWQgYXMgYnVpbHQtaW4uCiAKIEtDRkxBR1MKQEAgLTM5LDEyICszOSwxMiBAQAogCiBDRkxBR1NfS0VSTkVMCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotQWRkdGlvbmFsIG9wdGlvbnMgZm9yICQoQ0MpIHdoZW4gdXNlZCB0byBjb21waWxlCitBZGRpdGlvbmFsIG9wdGlvbnMgZm9yICQoQ0MpIHdoZW4gdXNlZCB0byBjb21waWxlCiBjb2RlIHRoYXQgaXMgY29tcGlsZWQgYXMgYnVpbHQtaW4uCiAKIENGTEFHU19NT0RVTEUKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi1BZGR0aW9uYWwgbW9kdWxlIHNwZWNpZmljIG9wdGlvbnMgdG8gdXNlIGZvciAkKENDKS4KK0FkZGl0aW9uYWwgbW9kdWxlIHNwZWNpZmljIG9wdGlvbnMgdG8gdXNlIGZvciAkKENDKS4KIAogTERGTEFHU19NT0RVTEUKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dCBiL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0CmluZGV4IGQyYjUxNTAuLmNjODVhOTIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0CkBAIC02OTksNyArNjk5LDcgQEAKIAlla2dkYm9jPQlbWDg2LEtHREJdIEFsbG93IGVhcmx5IGtlcm5lbCBjb25zb2xlIGRlYnVnZ2luZwogCQkJZWtnZGJvYz1rYmQKIAotCQkJVGhpcyBpcyBkZXNnaW5lZCB0byBiZSB1c2VkIGluIGNvbmp1bmN0aW9uIHdpdGgKKwkJCVRoaXMgaXMgZGVzaWduZWQgdG8gYmUgdXNlZCBpbiBjb25qdW5jdGlvbiB3aXRoCiAJCQl0aGUgYm9vdCBhcmd1bWVudDogZWFybHlwcmludGs9dmdhCiAKIAllZGQ9CQlbRUREXQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9rdm0vbW11LnR4dCBiL0RvY3VtZW50YXRpb24va3ZtL21tdS50eHQKaW5kZXggMTQyY2M1MS4uZjQ2YWE1OCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9rdm0vbW11LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2t2bS9tbXUudHh0CkBAIC0yMyw3ICsyMyw3IEBACiAgICAgICAgICAgICAgICBhbmQgZnJhbWVidWZmZXItYmFzZWQgZGlzcGxheXMKIC0gZm9vdHByaW50OiAgIGtlZXAgdGhlIGFtb3VudCBvZiBwaW5uZWQga2VybmVsIG1lbW9yeSBsb3cgKG1vc3QgbWVtb3J5CiAgICAgICAgICAgICAgICBzaG91bGQgYmUgc2hyaW5rYWJsZSkKLS0gcmVsaWFibGl0eTogIGF2b2lkIG11bHRpcGFnZSBvciBHRlBfQVRPTUlDIGFsbG9jYXRpb25zCistIHJlbGlhYmlsaXR5OiAgYXZvaWQgbXVsdGlwYWdlIG9yIEdGUF9BVE9NSUMgYWxsb2NhdGlvbnMKIAogQWNyb255bXMKID09PT09PT09CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2t2bS9wcGMtcHYudHh0IGIvRG9jdW1lbnRhdGlvbi9rdm0vcHBjLXB2LnR4dAppbmRleCBhN2YyMjQ0Li4zYWI5NjljIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2t2bS9wcGMtcHYudHh0CisrKyBiL0RvY3VtZW50YXRpb24va3ZtL3BwYy1wdi50eHQKQEAgLTEzNiw3ICsxMzYsNyBAQAogPT09PT09PT09PT09PT09PT09PT0KIAogVGhlICJsZCIgYW5kICJzdGQiIGluc3RydWN0aW9ucyBhcmUgdHJhbnNvcm1lZCB0byAibHd6IiBhbmQgInN0dyIgaW5zdHJ1Y3Rpb25zCi1yZXNwZWN0aXZlbHkgb24gMzIgYml0IHN5c3RlbXMgd2l0aCBhbiBhZGRlZCBvZmZzZXQgb2YgNCB0byBhY2NvbW9kYXRlIGZvciBiaWcKK3Jlc3BlY3RpdmVseSBvbiAzMiBiaXQgc3lzdGVtcyB3aXRoIGFuIGFkZGVkIG9mZnNldCBvZiA0IHRvIGFjY29tbW9kYXRlIGZvciBiaWcKIGVuZGlhbm5lc3MuCiAKIFRoZSBmb2xsb3dpbmcgaXMgYSBsaXN0IG9mIG1hcHBpbmcgdGhlIExpbnV4IGtlcm5lbCBwZXJmb3JtcyB3aGVuIHJ1bm5pbmcgYXMKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24va3ZtL3RpbWVrZWVwaW5nLnR4dCBiL0RvY3VtZW50YXRpb24va3ZtL3RpbWVrZWVwaW5nLnR4dAppbmRleCAwYzUwMzNhLi5kZjg5NDYzIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2t2bS90aW1la2VlcGluZy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9rdm0vdGltZWtlZXBpbmcudHh0CkBAIC04MSw3ICs4MSw3IEBACiAgd2hlbiB0aGUgZ2F0ZSBpcyBoaWdoIChhbHdheXMgdHJ1ZSBmb3IgdGltZXJzIDAgYW5kIDEpLiAgV2hlbiB0aGUgY291bnQKICByZWFjaGVzIHplcm8sIHRoZSBvdXRwdXQgZ29lcyBoaWdoLgogCi1Nb2RlIDE6IFRyaWdnZXJlZCBPbmUtc2hvdC4gIFRoZSBvdXRwdXQgaXMgaW50aWFsbHkgc2V0IGhpZ2guICBXaGVuIHRoZSBnYXRlCitNb2RlIDE6IFRyaWdnZXJlZCBPbmUtc2hvdC4gIFRoZSBvdXRwdXQgaXMgaW5pdGlhbGx5IHNldCBoaWdoLiAgV2hlbiB0aGUgZ2F0ZQogIGxpbmUgaXMgc2V0IGhpZ2gsIGEgY291bnRkb3duIGlzIGluaXRpYXRlZCAod2hpY2ggZG9lcyBub3Qgc3RvcCBpZiB0aGUgZ2F0ZSBpcwogIGxvd2VyZWQpLCBkdXJpbmcgd2hpY2ggdGhlIG91dHB1dCBpcyBzZXQgbG93LiAgV2hlbiB0aGUgY291bnQgcmVhY2hlcyB6ZXJvLAogIHRoZSBvdXRwdXQgZ29lcyBoaWdoLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS1mcmFtZXdvcmsudHh0IGIvRG9jdW1lbnRhdGlvbi9tZWRpYS1mcmFtZXdvcmsudHh0CmluZGV4IGZkNDhhZGQuLjc2YTIwODcgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbWVkaWEtZnJhbWV3b3JrLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL21lZGlhLWZyYW1ld29yay50eHQKQEAgLTE5NCw3ICsxOTQsNyBAQAogCiBMaW5rcyBhcmUgcmVwcmVzZW50ZWQgYnkgYSBzdHJ1Y3QgbWVkaWFfbGluayBpbnN0YW5jZSwgZGVmaW5lZCBpbgogaW5jbHVkZS9tZWRpYS9tZWRpYS1lbnRpdHkuaC4gRWFjaCBlbnRpdHkgc3RvcmVzIGFsbCBsaW5rcyBvcmlnaW5hdGluZyBhdCBvcgotdGFyZ2V0dGluZyBhbnkgb2YgaXRzIHBhZHMgaW4gYSBsaW5rcyBhcnJheS4gQSBnaXZlbiBsaW5rIGlzIHRodXMgc3RvcmVkCit0YXJnZXRpbmcgYW55IG9mIGl0cyBwYWRzIGluIGEgbGlua3MgYXJyYXkuIEEgZ2l2ZW4gbGluayBpcyB0aHVzIHN0b3JlZAogdHdpY2UsIG9uY2UgaW4gdGhlIHNvdXJjZSBlbnRpdHkgYW5kIG9uY2UgaW4gdGhlIHRhcmdldCBlbnRpdHkuIFRoZSBhcnJheSBpcwogcHJlLWFsbG9jYXRlZCBhbmQgZ3Jvd3MgZHluYW1pY2FsbHkgYXMgbmVlZGVkLgogCkBAIC0zNDgsNiArMzQ4LDYgQEAKIHdpdGggdGhlIE1FRElBX0xOS19GTF9EWU5BTUlDIGZsYWcuCiAKIElmIG90aGVyIG9wZXJhdGlvbnMgbmVlZCB0byBiZSBkaXNhbGxvd2VkIG9uIHN0cmVhbWluZyBlbnRpdGllcyAoc3VjaCBhcwotY2hhbmdpbmcgZW50aXRpZXMgY29uZmlndXJhdGlvbiBwYXJhbWV0ZXJzKSBkcml2ZXJzIGNhbiBleHBsaWN0bHkgY2hlY2sgdGhlCitjaGFuZ2luZyBlbnRpdGllcyBjb25maWd1cmF0aW9uIHBhcmFtZXRlcnMpIGRyaXZlcnMgY2FuIGV4cGxpY2l0bHkgY2hlY2sgdGhlCiBtZWRpYV9lbnRpdHkgc3RyZWFtX2NvdW50IGZpZWxkIHRvIGZpbmQgb3V0IGlmIGFuIGVudGl0eSBpcyBzdHJlYW1pbmcuIFRoaXMKIG9wZXJhdGlvbiBtdXN0IGJlIGRvbmUgd2l0aCB0aGUgbWVkaWFfZGV2aWNlIGdyYXBoX211dGV4IGhlbGQuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL21pcHMvQVUxeHh4X0lERS5SRUFETUUgYi9Eb2N1bWVudGF0aW9uL21pcHMvQVUxeHh4X0lERS5SRUFETUUKaW5kZXggOGFjZTM1ZS4uY2M4ODdlYyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9taXBzL0FVMXh4eF9JREUuUkVBRE1FCisrKyBiL0RvY3VtZW50YXRpb24vbWlwcy9BVTF4eHhfSURFLlJFQURNRQpAQCAtMzksMTMgKzM5LDEzIEBACiAgICAgICBJbnRlcmZhY2UgYW5kIExpbnV4IERldmljZSBEcml2ZXIiIEFwcGxpY2F0aW9uIE5vdGUuCiAKIAotRklMRVMsIENPTkZJR1MgQU5EIENPTVBBVEFCSUxJVFkKK0ZJTEVTLCBDT05GSUdTIEFORCBDT01QQVRJQklMSVRZCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiBUd28gZmlsZXMgYXJlIGludHJvZHVjZWQ6CiAKICAgYSkgJ2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWF1MXgwMC9hdTF4eHhfaWRlLmgnCi0gICAgIGNvbnRhaW5lcyA6IHN0cnVjdCBfYXVpZGVfaHdpZgorICAgICBjb250YWlucyA6IHN0cnVjdCBfYXVpZGVfaHdpZgogICAgICAgICAgICAgICAgICB0aW1pbmcgcGFyYW1ldGVycyBmb3IgUElPIG1vZGUgMC8xLzIvMy80CiAgICAgICAgICAgICAgICAgIHRpbWluZyBwYXJhbWV0ZXJzIGZvciBNV0RNQSAwLzEvMgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL21pc2MtZGV2aWNlcy9pY3M5MzJzNDAxIGIvRG9jdW1lbnRhdGlvbi9taXNjLWRldmljZXMvaWNzOTMyczQwMQppbmRleCAwN2E3MzlmLi5iZGFjNjdmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL21pc2MtZGV2aWNlcy9pY3M5MzJzNDAxCisrKyBiL0RvY3VtZW50YXRpb24vbWlzYy1kZXZpY2VzL2ljczkzMnM0MDEKQEAgLTUsNyArNSw3IEBACiAgICogSURUIElDUzkzMlM0MDEKICAgICBQcmVmaXg6ICdpY3M5MzJzNDAxJwogICAgIEFkZHJlc3NlcyBzY2FubmVkOiBJMkMgMHg2OQotICAgIERhdGFzaGVldDogUHVibGljYWxseSBhdmFpbGFibGUgYXQgdGhlIElEVCB3ZWJzaXRlCisgICAgRGF0YXNoZWV0OiBQdWJsaWNseSBhdmFpbGFibGUgYXQgdGhlIElEVCB3ZWJzaXRlCiAKIEF1dGhvcjogRGFycmljayBKLiBXb25nCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy8zYzM1OS50eHQgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvM2MzNTkudHh0CmluZGV4IDRhZjgwNzEuLmRhZGZlODEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy8zYzM1OS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nLzNjMzU5LnR4dApAQCAtNDUsNyArNDUsNyBAQAogCiBWYXJpYWJsZSBNVFUgc2l6ZToKIAotVGhlIGRyaXZlciBjYW4gaGFuZGxlIGEgTVRVIHNpemUgdXB0byBlaXRoZXIgNDUwMCBvciAxODAwMCBkZXBlbmRpbmcgdXBvbiAKK1RoZSBkcml2ZXIgY2FuIGhhbmRsZSBhIE1UVSBzaXplIHVwIHRvIGVpdGhlciA0NTAwIG9yIDE4MDAwIGRlcGVuZGluZyB1cG9uIAogcmluZyBzcGVlZC4gIFRoZSBkcml2ZXIgYWxzbyBjaGFuZ2VzIHRoZSBzaXplIG9mIHRoZSByZWNlaXZlIGJ1ZmZlcnMgYXMgcGFydAogb2YgdGhlIG10dSByZS1zaXppbmcsIHNvIGlmIHlvdSBzZXQgbXR1ID0gMTgwMDAsIHlvdSB3aWxsIG5lZWQgdG8gYmUgYWJsZQogdG8gYWxsb2NhdGUgMTYgKiAoc2tfYnVmZiB3aXRoIDE4MDAwIGJ1ZmZlciBzaXplKSBjYWxsIGl0IDE4NTAwIGJ5dGVzIHBlciByaW5nIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL1JFQURNRS5pcHcyMjAwIGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL1JFQURNRS5pcHcyMjAwCmluZGV4IDYxNmE4ZTUuLmI3NjU4YmUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9SRUFETUUuaXB3MjIwMAorKysgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvUkVBRE1FLmlwdzIyMDAKQEAgLTI1Niw3ICsyNTYsNyBAQAogCiBXaGVyZSAkVkFMVUUgd291bGQgYmUgYSBudW1iZXIgaW4gdGhlIGNhc2Ugb2YgdGhpcyBzeXNmcyBlbnRyeS4gIFRoZSAKIGlucHV0IHRvIHN5c2ZzIGZpbGVzIGRvZXMgbm90IGhhdmUgdG8gYmUgYSBudW1iZXIuICBGb3IgZXhhbXBsZSwgdGhlIAotZmlybXdhcmUgbG9hZGVyIHVzZWQgYnkgaG90cGx1ZyB1dGlsaXplcyBzeXNmcyBlbnRyaWVzIGZvciB0cmFuc2ZlcmluZyAKK2Zpcm13YXJlIGxvYWRlciB1c2VkIGJ5IGhvdHBsdWcgdXRpbGl6ZXMgc3lzZnMgZW50cmllcyBmb3IgdHJhbnNmZXJyaW5nIAogdGhlIGZpcm13YXJlIGltYWdlIGZyb20gdXNlciBzcGFjZSBpbnRvIHRoZSBkcml2ZXIuCiAKIFRoZSBJbnRlbChSKSBQUk8vV2lyZWxlc3MgMjkxNUFCRyBEcml2ZXIgZm9yIExpbnV4IGV4cG9zZXMgc3lzZnMgZW50cmllcyAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9ib25kaW5nLnR4dCBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9ib25kaW5nLnR4dAppbmRleCBiMzZlNzQxLi5lMjcyMDJiYiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2JvbmRpbmcudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9ib25kaW5nLnR4dApAQCAtMzY4LDcgKzM2OCw3IEBACiAJCWdyYXR1aXRvdXMgQVJQIGlzIGxvc3QsIGNvbW11bmljYXRpb24gbWF5IGJlCiAJCWRpc3J1cHRlZC4KIAotCQlXaGVuIHRoaXMgcG9saWN5IGlzIHVzZWQgaW4gY29uanVjdGlvbiB3aXRoIHRoZSBtaWkKKwkJV2hlbiB0aGlzIHBvbGljeSBpcyB1c2VkIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIG1paQogCQltb25pdG9yLCBkZXZpY2VzIHdoaWNoIGFzc2VydCBsaW5rIHVwIHByaW9yIHRvIGJlaW5nCiAJCWFibGUgdG8gYWN0dWFsbHkgdHJhbnNtaXQgYW5kIHJlY2VpdmUgYXJlIHBhcnRpY3VsYXJseQogCQlzdXNjZXB0aWJsZSB0byBsb3NzIG9mIHRoZSBncmF0dWl0b3VzIEFSUCwgYW5kIGFuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvY2FpZi9MaW51eC1DQUlGLnR4dCBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9jYWlmL0xpbnV4LUNBSUYudHh0CmluZGV4IDdmZTdhOWEuLmU1MmZkNjIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9jYWlmL0xpbnV4LUNBSUYudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9jYWlmL0xpbnV4LUNBSUYudHh0CkBAIC0xMzYsNyArMTM2LDcgQEAKICAgICAgIC0gQ0ZNVVggQ0FJRiBNdXggbGF5ZXIuIEhhbmRsZXMgbXVsdGlwbGV4aW5nIGJldHdlZW4gbXVsdGlwbGUKIAlwaHlzaWNhbCBiZWFyZXJzIGFuZCBtdWx0aXBsZSBjaGFubmVscyBzdWNoIGFzIFZFSSwgRGF0YWdyYW0sIGV0Yy4KIAlUaGUgTVVYIGtlZXBzIHRyYWNrIG9mIHRoZSBleGlzdGluZyBDQUlGIENoYW5uZWxzIGFuZAotCVBoeXNpY2FsIEluc3RhbmNlcyBhbmQgc2VsZWN0cyB0aGUgYXByb3ByaWF0ZSBpbnN0YW5jZSBiYXNlZAorCVBoeXNpY2FsIEluc3RhbmNlcyBhbmQgc2VsZWN0cyB0aGUgYXBwcm9wcmlhdGUgaW5zdGFuY2UgYmFzZWQKIAlvbiBDaGFubmVsLUlkIGFuZCBQaHlzaWNhbC1JRC4KIAogICAgICAgLSBDRkZSTUwgQ0FJRiBGcmFtaW5nIGxheWVyLiBIYW5kbGVzIEZyYW1pbmcgaS5lLiBGcmFtZSBsZW5ndGgKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9jYWlmL3NwaV9wb3J0aW5nLnR4dCBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9jYWlmL3NwaV9wb3J0aW5nLnR4dAppbmRleCAwY2I4Y2I5Li45ZWZkMDY4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvY2FpZi9zcGlfcG9ydGluZy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2NhaWYvc3BpX3BvcnRpbmcudHh0CkBAIC0xNTAsNyArMTUwLDcgQEAKIHZvaWQgc3NwaV9zaWdfeGZlcihib29sIHhmZXIsIHN0cnVjdCBjZnNwaV9kZXYgKmRldikKIHsKIAkvKiBJZiB4ZmVyIGlzIHRydWUgdGhlbiB5b3Ugc2hvdWxkIGFzc2VydCB0aGUgU1BJX0lOVCB0byBpbmRpY2F0ZSB0bwotCSAqIHRoZSBtYXN0ZXIgdGhhdCB5b3UgYXJlIHJlYWR5IHRvIHJlY2lldmUgdGhlIGRhdGEgZnJvbSB0aGUgbWFzdGVyCisJICogdGhlIG1hc3RlciB0aGF0IHlvdSBhcmUgcmVhZHkgdG8gcmVjZWl2ZSB0aGUgZGF0YSBmcm9tIHRoZSBtYXN0ZXIKIAkgKiBTUEkuIElmIHhmZXIgaXMgZmFsc2UgdGhlbiB5b3Ugc2hvdWxkIGRlLWFzc2VydCBTUElfSU5UIHRvIGluZGljYXRlCiAJICogdGhhdCB0aGUgdHJhbnNmZXIgaXMgZG9uZS4KIAkgKi8KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9jYW4udHh0IGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2Nhbi50eHQKaW5kZXggNWIwNGI2Ny4uNTZjYTNiNyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2Nhbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2Nhbi50eHQKQEAgLTI0MCw3ICsyNDAsNyBAQAogICB0aGUgdXNlciBhcHBsaWNhdGlvbiB1c2luZyB0aGUgY29tbW9uIENBTiBmaWx0ZXIgbWVjaGFuaXNtcy4gSW5zaWRlCiAgIHRoaXMgZmlsdGVyIGRlZmluaXRpb24gdGhlIChpbnRlcmVzdGVkKSB0eXBlIG9mIGVycm9ycyBtYXkgYmUKICAgc2VsZWN0ZWQuIFRoZSByZWNlcHRpb24gb2YgZXJyb3IgZnJhbWVzIGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQuCi0gIFRoZSBmb3JtYXQgb2YgdGhlIENBTiBlcnJvciBmcmFtZSBpcyBicmllZmx5IGRlY3JpYmVkIGluIHRoZSBMaW51eAorICBUaGUgZm9ybWF0IG9mIHRoZSBDQU4gZXJyb3IgZnJhbWUgaXMgYnJpZWZseSBkZXNjcmliZWQgaW4gdGhlIExpbnV4CiAgIGhlYWRlciBmaWxlICJpbmNsdWRlL2xpbnV4L2Nhbi9lcnJvci5oIi4KIAogNC4gSG93IHRvIHVzZSBTb2NrZXQgQ0FOCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvaWVlZTgwMjE1NC50eHQgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvaWVlZTgwMjE1NC50eHQKaW5kZXggMjNjOTk1ZS4uZjQxZWEyNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2llZWU4MDIxNTQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9pZWVlODAyMTU0LnR4dApAQCAtOSw3ICs5LDcgQEAKIG9mIElFRUUgODAyLjE1LjQgLyBaaWdCZWUgLyA2TG9XUEFOIHByb3RvY29scy4gSUVFRSA4MDIuMTUuNCBpcyBhIHN0YWNrCiBvZiBwcm90b2NvbHMgZm9yIG9yZ2FuaXppbmcgTG93LVJhdGUgV2lyZWxlc3MgUGVyc29uYWwgQXJlYSBOZXR3b3Jrcy4KIAotQ3VycmVudGx5IG9ubHkgSUVFRSA4MDIuMTUuNCBsYXllciBpcyBpbXBsZW1lbnRlZC4gV2UgaGF2ZSBjaG9vc2VuCitDdXJyZW50bHkgb25seSBJRUVFIDgwMi4xNS40IGxheWVyIGlzIGltcGxlbWVudGVkLiBXZSBoYXZlIGNob3NlbgogdG8gdXNlIHBsYWluIEJlcmtlbGV5IHNvY2tldCBBUEksIHRoZSBnZW5lcmljIExpbnV4IG5ldHdvcmtpbmcgc3RhY2sKIHRvIHRyYW5zZmVyIElFRUUgODAyLjE1LjQgbWVzc2FnZXMgYW5kIGEgc3BlY2lhbCBwcm90b2NvbCBvdmVyIGdlbmV0bGluawogZm9yIGNvbmZpZ3VyYXRpb24vbWFuYWdlbWVudApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL29seW1waWMudHh0IGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL29seW1waWMudHh0CmluZGV4IGM2NWE5NDAuLmI5NWI1YmYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9vbHltcGljLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvb2x5bXBpYy50eHQKQEAgLTY1LDcgKzY1LDcgQEAKIAogVmFyaWFibGUgTVRVIHNpemU6CiAKLVRoZSBkcml2ZXIgY2FuIGhhbmRsZSBhIE1UVSBzaXplIHVwdG8gZWl0aGVyIDQ1MDAgb3IgMTgwMDAgZGVwZW5kaW5nIHVwb24gCitUaGUgZHJpdmVyIGNhbiBoYW5kbGUgYSBNVFUgc2l6ZSB1cCB0byBlaXRoZXIgNDUwMCBvciAxODAwMCBkZXBlbmRpbmcgdXBvbiAKIHJpbmcgc3BlZWQuICBUaGUgZHJpdmVyIGFsc28gY2hhbmdlcyB0aGUgc2l6ZSBvZiB0aGUgcmVjZWl2ZSBidWZmZXJzIGFzIHBhcnQKIG9mIHRoZSBtdHUgcmUtc2l6aW5nLCBzbyBpZiB5b3Ugc2V0IG10dSA9IDE4MDAwLCB5b3Ugd2lsbCBuZWVkIHRvIGJlIGFibGUKIHRvIGFsbG9jYXRlIDE2ICogKHNrX2J1ZmYgd2l0aCAxODAwMCBidWZmZXIgc2l6ZSkgY2FsbCBpdCAxODUwMCBieXRlcyBwZXIgcmluZyAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9wYWNrZXRfbW1hcC50eHQgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvcGFja2V0X21tYXAudHh0CmluZGV4IDA3Mzg5NGQuLjRhY2VhNjYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9wYWNrZXRfbW1hcC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL3BhY2tldF9tbWFwLnR4dApAQCAtMjIzLDcgKzIyMyw3IEBACiAKIEEgZnJhbWUgY2FuIGJlIG9mIGFueSBzaXplIHdpdGggdGhlIG9ubHkgY29uZGl0aW9uIGl0IGNhbiBmaXQgaW4gYSBibG9jay4gQSBibG9jawogY2FuIG9ubHkgaG9sZCBhbiBpbnRlZ2VyIG51bWJlciBvZiBmcmFtZXMsIG9yIGluIG90aGVyIHdvcmRzLCBhIGZyYW1lIGNhbm5vdCAKLWJlIHNwYXduZWQgYWNjcm9zcyB0d28gYmxvY2tzLCBzbyB0aGVyZSBhcmUgc29tZSBkZXRhaWxzIHlvdSBoYXZlIHRvIHRha2UgaW50byAKK2JlIHNwYXduZWQgYWNyb3NzIHR3byBibG9ja3MsIHNvIHRoZXJlIGFyZSBzb21lIGRldGFpbHMgeW91IGhhdmUgdG8gdGFrZSBpbnRvIAogYWNjb3VudCB3aGVuIGNob29zaW5nIHRoZSBmcmFtZV9zaXplLiBTZWUgIk1hcHBpbmcgYW5kIHVzZSBvZiB0aGUgY2lyY3VsYXIgCiBidWZmZXIgKHJpbmcpIi4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL3MyaW8udHh0IGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL3MyaW8udHh0CmluZGV4IDlkNGUwZjQuLjRiZTBjMDMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9zMmlvLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvczJpby50eHQKQEAgLTM3LDcgKzM3LDcgQEAKIFRoZSBjb3JyZXNwb25kaW5nIGFkYXB0ZXIncyBMRUQgd2lsbCBibGluayBtdWx0aXBsZSB0aW1lcy4KIAogMy4JRmVhdHVyZXMgc3VwcG9ydGVkOgotYS4gSnVtYm8gZnJhbWVzLiBYZnJhbWUgSS9JSSBzdXBwb3J0cyBNVFUgdXB0byA5NjAwIGJ5dGVzLAorYS4gSnVtYm8gZnJhbWVzLiBYZnJhbWUgSS9JSSBzdXBwb3J0cyBNVFUgdXAgdG8gOTYwMCBieXRlcywKIG1vZGlmaWFibGUgdXNpbmcgaWZjb25maWcgY29tbWFuZC4KIAogYi4gT2ZmbG9hZHMuIFN1cHBvcnRzIGNoZWNrc3VtIG9mZmxvYWQoVENQL1VEUC9JUCkgb24gdHJhbnNtaXQKQEAgLTQ5LDcgKzQ5LDcgQEAKIElCTSB4U2VyaWVzKS4KIAogZC4gTVNJL01TSS1YLiBDYW4gYmUgZW5hYmxlZCBvbiBwbGF0Zm9ybXMgd2hpY2ggc3VwcG9ydCB0aGlzIGZlYXR1cmUKLShJQTY0LCBYZW9uKSByZXN1bHRpbmcgaW4gbm90aWNlYWJsZSBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudCh1cHRvIDclCisoSUE2NCwgWGVvbikgcmVzdWx0aW5nIGluIG5vdGljZWFibGUgcGVyZm9ybWFuY2UgaW1wcm92ZW1lbnQodXAgdG8gNyUKIG9uIGNlcnRhaW4gcGxhdGZvcm1zKS4KIAogZS4gU3RhdGlzdGljcy4gQ29tcHJlaGVuc2l2ZSBNQUMtbGV2ZWwgYW5kIHNvZnR3YXJlIHN0YXRpc3RpY3MgZGlzcGxheWVkCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvdGMtYWN0aW9ucy1lbnYtcnVsZXMudHh0IGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL3RjLWFjdGlvbnMtZW52LXJ1bGVzLnR4dAppbmRleCBkY2FkZjZmLi43MGQ2Y2Y2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvdGMtYWN0aW9ucy1lbnYtcnVsZXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy90Yy1hY3Rpb25zLWVudi1ydWxlcy50eHQKQEAgLTEsNSArMSw1IEBACiAKLVRoZSAiZW52aXJvbWVudGFsIiBydWxlcyBmb3IgYXV0aG9ycyBvZiBhbnkgbmV3IHRjIGFjdGlvbnMgYXJlOgorVGhlICJlbnZpcm9ubWVudGFsIiBydWxlcyBmb3IgYXV0aG9ycyBvZiBhbnkgbmV3IHRjIGFjdGlvbnMgYXJlOgogCiAxKSBJZiB5b3Ugc3RlYWxldGggb3IgYm9ycm93ZXRoIGFueSBwYWNrZXQgdGhvdSBzaGFsdCBiZSBicmFuY2hpbmcKIGZyb20gdGhlIHJpZ2h0ZW91cyBwYXRoIGFuZCB0aG91IHNoYWx0IGNsb25ldGguCkBAIC0yMCw3ICsyMCw3IEBACiAzKSBEcm9wcGluZyBwYWNrZXRzIHlvdSBkb24ndCBvd24gaXMgYSBuby1uby4gWW91IHNpbXBseSByZXR1cm4KIFRDX0FDVF9TSE9UIHRvIHRoZSBjYWxsZXIgYW5kIHRoZXkgd2lsbCBkcm9wIGl0LgogCi1UaGUgImVudmlyb21lbnRhbCIgcnVsZXMgZm9yIGNhbGxlcnMgb2YgYWN0aW9ucyAocWRpc2NzIGV0YykgYXJlOgorVGhlICJlbnZpcm9ubWVudGFsIiBydWxlcyBmb3IgY2FsbGVycyBvZiBhY3Rpb25zIChxZGlzY3MgZXRjKSBhcmU6CiAKICopIFRob3UgYXJ0IHJlc3BvbnNpYmxlIGZvciBmcmVlaW5nIGFueXRoaW5nIHJldHVybmVkIGFzIGJlaW5nCiBUQ19BQ1RfU0hPVC9TVE9MRU4vUVVFVUVELiBJZiBub25lIG9mIFRDX0FDVF9TSE9UL1NUT0xFTi9RVUVVRUQgaXMKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXIvZGV2aWNlcy50eHQgYi9Eb2N1bWVudGF0aW9uL3Bvd2VyL2RldmljZXMudHh0CmluZGV4IGYwMjNiYTYuLjE5NzFiY2YgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcG93ZXIvZGV2aWNlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9wb3dlci9kZXZpY2VzLnR4dApAQCAtMzY3LDcgKzM2Nyw3IEBACiBzdXNwZW5kIG1ldGhvZHMgd2VyZSBjYWxsZWQsIGZvciBleGFtcGxlIGJ5IGNvbXBsZXRlIHJlaW5pdGlhbGl6YXRpb24uCiBUaGlzIG1heSBiZSB0aGUgaGFyZGVzdCBwYXJ0LCBhbmQgdGhlIG9uZSBtb3N0IHByb3RlY3RlZCBieSBOREEnZCBkb2N1bWVudHMKIGFuZCBjaGlwIGVycmF0YS4gIEl0J3Mgc2ltcGxlc3QgaWYgdGhlIGhhcmR3YXJlIHN0YXRlIGhhc24ndCBjaGFuZ2VkIHNpbmNlCi10aGUgc3VzcGVuZCB3YXMgY2FycmllZCBvdXQsIGJ1dCB0aGF0IGNhbid0IGJlIGd1YXJhbnRlZWQgKGluIGZhY3QsIGl0IHVzdXNhbGx5Cit0aGUgc3VzcGVuZCB3YXMgY2FycmllZCBvdXQsIGJ1dCB0aGF0IGNhbid0IGJlIGd1YXJhbnRlZWQgKGluIGZhY3QsIGl0IHVzdWFsbHkKIGlzIG5vdCB0aGUgY2FzZSkuCiAKIERyaXZlcnMgbXVzdCBhbHNvIGJlIHByZXBhcmVkIHRvIG5vdGljZSB0aGF0IHRoZSBkZXZpY2UgaGFzIGJlZW4gcmVtb3ZlZApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlci9ub3RpZmllcnMudHh0IGIvRG9jdW1lbnRhdGlvbi9wb3dlci9ub3RpZmllcnMudHh0CmluZGV4IGFlMWI3ZWMuLmNmOTgwNzAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcG93ZXIvbm90aWZpZXJzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Bvd2VyL25vdGlmaWVycy50eHQKQEAgLTI0LDcgKzI0LDcgQEAKIAkJCWJlIGZyb3plbiBpbW1lZGlhdGVseS4KIAogUE1fUE9TVF9ISUJFUk5BVElPTglUaGUgc3lzdGVtIG1lbW9yeSBzdGF0ZSBoYXMgYmVlbiByZXN0b3JlZCBmcm9tIGEKLQkJCWhpYmVybmF0aW9uIGltYWdlIG9yIGFuIGVycm9yIG9jY3VyZWQgZHVyaW5nIHRoZQorCQkJaGliZXJuYXRpb24gaW1hZ2Ugb3IgYW4gZXJyb3Igb2NjdXJyZWQgZHVyaW5nIHRoZQogCQkJaGliZXJuYXRpb24uICBEZXZpY2UgZHJpdmVycycgLnJlc3VtZSgpIGNhbGxiYWNrcyBoYXZlCiAJCQliZWVuIGV4ZWN1dGVkIGFuZCB0YXNrcyBoYXZlIGJlZW4gdGhhd2VkLgogCkBAIC0zOCw3ICszOCw3IEBACiAKIFBNX1NVU1BFTkRfUFJFUEFSRQlUaGUgc3lzdGVtIGlzIHByZXBhcmluZyBmb3IgYSBzdXNwZW5kLgogCi1QTV9QT1NUX1NVU1BFTkQJCVRoZSBzeXN0ZW0gaGFzIGp1c3QgcmVzdW1lZCBvciBhbiBlcnJvciBvY2N1cmVkIGR1cmluZworUE1fUE9TVF9TVVNQRU5ECQlUaGUgc3lzdGVtIGhhcyBqdXN0IHJlc3VtZWQgb3IgYW4gZXJyb3Igb2NjdXJyZWQgZHVyaW5nCiAJCQl0aGUgc3VzcGVuZC4JRGV2aWNlIGRyaXZlcnMnIC5yZXN1bWUoKSBjYWxsYmFja3MgaGF2ZQogCQkJYmVlbiBleGVjdXRlZCBhbmQgdGFza3MgaGF2ZSBiZWVuIHRoYXdlZC4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlci9vcHAudHh0IGIvRG9jdW1lbnRhdGlvbi9wb3dlci9vcHAudHh0CmluZGV4IGNkNDQ1NTguLjVhZTcwYTEyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3Bvd2VyL29wcC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9wb3dlci9vcHAudHh0CkBAIC0xNzgsNyArMTc4LDcgQEAKIAkJaWYgKCFJU19FUlIob3BwKSkKIAkJCXNvY19zd2l0Y2hfdG9fZnJlcV92b2x0YWdlKGZyZXEpOwogCQllbHNlCi0JCQkvKiBkbyBzb21ldGhpbmcgd2hlbiB3ZSBjYW50IHNhdGlzZnkgdGhlIHJlcSAqLworCQkJLyogZG8gc29tZXRoaW5nIHdoZW4gd2UgY2FuJ3Qgc2F0aXNmeSB0aGUgcmVxICovCiAJCS8qIGRvIG90aGVyIHN0dWZmICovCiAJIH0KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlci9zd3N1c3AudHh0IGIvRG9jdW1lbnRhdGlvbi9wb3dlci9zd3N1c3AudHh0CmluZGV4IGVhNzE4ODkuLmFjMTkwY2YgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcG93ZXIvc3dzdXNwLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Bvd2VyL3N3c3VzcC50eHQKQEAgLTE5Miw3ICsxOTIsNyBAQAogZGlzdGluY3Rpb25zIGJldHdlZW4gU1VTUEVORCBhbmQgRlJFRVpFLgogCiBBOiBEb2luZyBTVVNQRU5EIHdoZW4geW91IGFyZSBhc2tlZCB0byBkbyBGUkVFWkUgaXMgYWx3YXlzIGNvcnJlY3QsCi1idXQgaXQgbWF5IGJlIHVubmVjY2Vzc2FyaWx5IHNsb3cuIElmIHlvdSB3YW50IHlvdXIgZHJpdmVyIHRvIHN0YXkgc2ltcGxlLAorYnV0IGl0IG1heSBiZSB1bm5lY2Vzc2FyaWx5IHNsb3cuIElmIHlvdSB3YW50IHlvdXIgZHJpdmVyIHRvIHN0YXkgc2ltcGxlLAogc2xvd25lc3MgbWF5IG5vdCBtYXR0ZXIgdG8geW91LiBJdCBjYW4gYWx3YXlzIGJlIGZpeGVkIGxhdGVyLgogCiBGb3IgZGV2aWNlcyBsaWtlIGRpc2sgaXQgZG9lcyBtYXR0ZXIsIHlvdSBkbyBub3Qgd2FudCB0byBzcGluZG93biBmb3IKQEAgLTIzNyw3ICsyMzcsNyBAQAogCiAgICAgICBydW5uaW5nIHN5c3RlbSwgdXNlciBhc2tzIGZvciBzdXNwZW5kLXRvLWRpc2sKIAotICAgICAgdXNlciBwcm9jZXNzZXMgYXJlIHN0b3BwZWQgKGluIGNvbW1vbiBjYXNlIHRoZXJlIGFyZSBub25lLCBidXQgd2l0aCByZXN1bWUtZnJvbS1pbml0cmQsIG5vb25lIGtub3dzKQorICAgICAgdXNlciBwcm9jZXNzZXMgYXJlIHN0b3BwZWQgKGluIGNvbW1vbiBjYXNlIHRoZXJlIGFyZSBub25lLCBidXQgd2l0aCByZXN1bWUtZnJvbS1pbml0cmQsIG5vIG9uZSBrbm93cykKIAogICAgICAgcmVhZCBpbWFnZSBmcm9tIGRpc2sKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlci91c2VybGFuZC1zd3N1c3AudHh0IGIvRG9jdW1lbnRhdGlvbi9wb3dlci91c2VybGFuZC1zd3N1c3AudHh0CmluZGV4IDgxNjgwZjkuLjExMDFiZWUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcG93ZXIvdXNlcmxhbmQtc3dzdXNwLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Bvd2VyL3VzZXJsYW5kLXN3c3VzcC50eHQKQEAgLTk4LDcgKzk4LDcgQEAKIFRoZSBkZXZpY2UncyByZWFkKCkgb3BlcmF0aW9uIGNhbiBiZSB1c2VkIHRvIHRyYW5zZmVyIHRoZSBzbmFwc2hvdCBpbWFnZSBmcm9tCiB0aGUga2VybmVsLiAgSXQgaGFzIHRoZSBmb2xsb3dpbmcgbGltaXRhdGlvbnM6CiAtIHlvdSBjYW5ub3QgcmVhZCgpIG1vcmUgdGhhbiBvbmUgdmlydHVhbCBtZW1vcnkgcGFnZSBhdCBhIHRpbWUKLS0gcmVhZCgpcyBhY2Nyb3NzIHBhZ2UgYm91bmRhcmllcyBhcmUgaW1wb3NzaWJsZSAoaWUuIGlmIHlwdSByZWFkKCkgMS8yIG9mCistIHJlYWQoKXMgYWNyb3NzIHBhZ2UgYm91bmRhcmllcyBhcmUgaW1wb3NzaWJsZSAoaWUuIGlmIHlwdSByZWFkKCkgMS8yIG9mCiAJYSBwYWdlIGluIHRoZSBwcmV2aW91cyBjYWxsLCB5b3Ugd2lsbCBvbmx5IGJlIGFibGUgdG8gcmVhZCgpCiAJX2F0XyBfbW9zdF8gMS8yIG9mIHRoZSBwYWdlIGluIHRoZSBuZXh0IGNhbGwpCiAKQEAgLTEzNyw3ICsxMzcsNyBAQAogbWVhbnMsIHN1Y2ggYXMgY2hlY2tzdW1zLCB0byBlbnN1cmUgdGhlIGludGVncml0eSBvZiB0aGUgc25hcHNob3QgaW1hZ2UuCiAKIFRoZSBzdXNwZW5kaW5nIGFuZCByZXN1bWluZyB1dGlsaXRpZXMgTVVTVCBsb2NrIHRoZW1zZWx2ZXMgaW4gbWVtb3J5LAotcHJlZmVycmFibHkgdXNpbmcgbWxvY2thbGwoKSwgYmVmb3JlIGNhbGxpbmcgU05BUFNIT1RfRlJFRVpFLgorcHJlZmVyYWJseSB1c2luZyBtbG9ja2FsbCgpLCBiZWZvcmUgY2FsbGluZyBTTkFQU0hPVF9GUkVFWkUuCiAKIFRoZSBzdXNwZW5kaW5nIHV0aWxpdHkgTVVTVCBjaGVjayB0aGUgdmFsdWUgc3RvcmVkIGJ5IFNOQVBTSE9UX0NSRUFURV9JTUFHRQogaW4gdGhlIG1lbW9yeSBsb2NhdGlvbiBwb2ludGVkIHRvIGJ5IHRoZSBsYXN0IGFyZ3VtZW50IG9mIGlvY3RsKCkgYW5kIHByb2NlZWQKQEAgLTE0Nyw3ICsxNDcsNyBAQAogCShhKQlUaGUgc3VzcGVuZGluZyB1dGlsaXR5IE1VU1QgTk9UIGNsb3NlIHRoZSBzbmFwc2hvdCBkZXZpY2UKIAkJX3VubGVzc18gdGhlIHdob2xlIHN1c3BlbmQgcHJvY2VkdXJlIGlzIHRvIGJlIGNhbmNlbGxlZCwgaW4KIAkJd2hpY2ggY2FzZSwgaWYgdGhlIHNuYXBzaG90IGltYWdlIGhhcyBhbHJlYWR5IGJlZW4gc2F2ZWQsIHRoZQotCQlzdXNwZW5kaW5nIHV0aWxpdHkgU0hPVUxEIGRlc3Ryb3kgaXQsIHByZWZlcnJhYmx5IGJ5IHphcHBpbmcKKwkJc3VzcGVuZGluZyB1dGlsaXR5IFNIT1VMRCBkZXN0cm95IGl0LCBwcmVmZXJhYmx5IGJ5IHphcHBpbmcKIAkJaXRzIGhlYWRlci4gIElmIHRoZSBzdXNwZW5kIGlzIG5vdCB0byBiZSBjYW5jZWxsZWQsIHRoZQogCQlzeXN0ZW0gTVVTVCBiZSBwb3dlcmVkIG9mZiBvciByZWJvb3RlZCBhZnRlciB0aGUgc25hcHNob3QKIAkJaW1hZ2UgaGFzIGJlZW4gc2F2ZWQuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvaHZjcy50eHQgYi9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvaHZjcy50eHQKaW5kZXggNmQ4YmUzNC4uYTczMGNhNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2h2Y3MudHh0CisrKyBiL0RvY3VtZW50YXRpb24vcG93ZXJwYy9odmNzLnR4dApAQCAtNTI4LDcgKzUyOCw3IEBACiBvcmRlciB0aGFuIGhvdyB0aGV5IHdvdWxkIGJlIGV4cG9zZWQgb24gbW9kdWxlIGxvYWQuICBSZWJvb3Rpbmcgb3IKIHJlbG9hZGluZyB0aGUgbW9kdWxlIGFmdGVyIGR5bmFtaWMgYWRkaXRpb24gbWF5IHJlc3VsdCBpbiB0aGUgL2Rldi9odmNzKgogYW5kIHZ0eS1zZXJ2ZXIgY291cGxpbmcgY2hhbmdpbmcgaWYgYSB2dHktc2VydmVyIGFkYXB0ZXIgd2FzIGFkZGVkIGluIGEKLXNsb3QgaW5iZXR3ZWVuIHR3byBvdGhlciB2dHktc2VydmVyIGFkYXB0ZXJzLiAgUmVmZXIgdG8gdGhlIHNlY3Rpb24gYWJvdmUKK3Nsb3QgYmV0d2VlbiB0d28gb3RoZXIgdnR5LXNlcnZlciBhZGFwdGVycy4gIFJlZmVyIHRvIHRoZSBzZWN0aW9uIGFib3ZlCiBvbiBob3cgdG8gZGV0ZXJtaW5lIHdoaWNoIHZ0eS1zZXJ2ZXIgZ29lcyB3aXRoIHdoaWNoIC9kZXYvaHZjcyogbm9kZS4KIEhpbnQ7IGxvb2sgYXQgdGhlIHN5c2ZzICJpbmRleCIgYXR0cmlidXRlIGZvciB0aGUgdnR5LXNlcnZlci4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zY3NpL0NoYW5nZUxvZy5scGZjIGIvRG9jdW1lbnRhdGlvbi9zY3NpL0NoYW5nZUxvZy5scGZjCmluZGV4IDVlODM3NjkuLmM1NmVjOTkgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cubHBmYworKysgYi9Eb2N1bWVudGF0aW9uL3Njc2kvQ2hhbmdlTG9nLmxwZmMKQEAgLTM1Miw3ICszNTIsNyBAQAogCSAgbHBmY19zY3NpcG9ydC5jCiAJKiBJbiByZW1vdGUgcG9ydCBjaGFuZ2VzOiBubyBsb25nZXIgbnVsbGluZyB0YXJnZXQtPnBub2RlIHdoZW4KIAkgIHJlbW92aW5nIGZyb20gbWFwcGVkIGxpc3QuIFBub2RlIGdldCBudWxsZWQgd2hlbiB0aGUgbm9kZSBpcwotCSAgZnJlZWQgKGFmdGVyIG5vZGV2IHRtbykuIFRoaXMgYnVnIHdhcyBjYXVzaW5nIGkvbyByZWNpZXZlZCBpbgorCSAgZnJlZWQgKGFmdGVyIG5vZGV2IHRtbykuIFRoaXMgYnVnIHdhcyBjYXVzaW5nIGkvbyByZWNlaXZlZCBpbgogCSAgdGhlIHNtYWxsIHdpbmRvdyB3aGlsZSB0aGUgZGV2aWNlIHdhcyBibG9ja2VkIHRvIGJlIGVycm9yZWQgdy8KIAkgIGRpZF9ub19jb25uZWN0LiBXaXRoIHRoZSBmaXgsIGl0IHJldHVybnMgaG9zdF9idXN5CiAJICAocGVyIHRoZSBwcmUtcmVtb3RlIHBvcnQgY2hhbmdlcykuCkBAIC01MzAsNyArNTMwLDcgQEAKIAkgIGNvaGVyZW50IG1hcHBpbmdzLiAgTm90ZTogVGhlcmUgYXJlIG1vcmUgY29uc2lzdGVudCBtYXBwaW5ncwogCSAgdGhhdCBhcmUgdXNpbmcgcGNpX2RtYV9zeW5jIGNhbGxzLiBQcm9iYWJseSB0aGVzZSBzaG91bGQgYmUKIAkgIHJlbW92ZWQgYXMgd2VsbC4KLQkqIE1vZGlmaWVkIGxwZmNfZnJlZV9zY3NpX2J1ZiB0byBhY2NvbW9kYXRlIGFsbCB0aHJlZSBzY3NpX2J1ZgorCSogTW9kaWZpZWQgbHBmY19mcmVlX3Njc2lfYnVmIHRvIGFjY29tbW9kYXRlIGFsbCB0aHJlZSBzY3NpX2J1ZgogCSAgZnJlZSB0eXBlcyB0byBhbGxldmlhdGUgbWlzY2VsbGFuZW91cyBwYW5pY3Mgd2l0aCBjYWJsZSBwdWxsCiAJICB0ZXN0aW5nLgogCSogU2V0IGhvdHBsdWcgdG8gZGVmYXVsdCAwIGFuZCBscGZjX3RhcmdldF9yZW1vdmUgdG8gbm90IHJlbW92ZQpAQCAtNTgzLDcgKzU4Myw3IEBACiAJICBpbmNsdWRlZCBtb3JlIHRoYW4gb25jZS4KIAkqIFJlcGxhY2VkICJzZXRfY3VycmVudF9zdGF0ZShUQVNLX1VOSU5URVJSVVBUSUJMRSk7CiAJICBzY2hlZHVsZV90aW1lb3V0KHRpbWVvdXQpIiB3aXRoICJtc2xlZXAodGltZW91dCkiLgotCSogRml4bm9kZSB3YXMgbG9vc2luZyBzdGFyZ2V0IHdoZW4gcmVkaXNjb3ZlcmVkLiBXZSBzYXcgbWVzc2FnZXMKKwkqIEZpeG5vZGUgd2FzIGxvc2luZyBzdGFyZ2V0IHdoZW4gcmVkaXNjb3ZlcmVkLiBXZSBzYXcgbWVzc2FnZXMKIAkgIGxpa2U6IGxwZmMgMDAwMDowNDowMi4wOiAwOjAyNjMgQ2Fubm90IGJsb2NrIHNjc2kgdGFyZ2V0IGFzIGEKIAkgIHJlc3VsdC4gIE1vdmVkIHN0YXJnZXQgZmllbGQgaW50byBzdHJ1Y3QgbHBmY190YXJnZXQgd2hpY2ggaXMKIAkgIHJlZmVyZW5jZWQgZnJvbSB0aGUgbm9kZS4KQEAgLTYwNCw3ICs2MDQsNyBAQAogCSogTWFrZSAzIGZ1bmN0aW9ucyBzdGF0aWM6IGxwZmNfZ2V0X2hiYV9zeW1fbm9kZV9uYW1lLAogCSAgbHBmY19pbnRyX3ByZXAgYW5kIGxwZmNfc2V0dXBfc2xpbV9hY2Nlc3MuICBNb3ZlIGxwZmNfaW50cl9wcmVwCiAJICBhbmQgbHBmY19zZXR1cF9zbGltX2FjY2VzcyBzbyB0aGV5J3JlIGRlZmluZWQgYmVmb3JlIGJlaW5nIHVzZWQuCi0JKiBSZW1vdmUgYW4gdW5lY2Vzc2FyeSBsaXN0X2RlbCgpIGluIGxwZmNfaGJhZGlzYy5jLgorCSogUmVtb3ZlIGFuIHVubmVjZXNzYXJ5IGxpc3RfZGVsKCkgaW4gbHBmY19oYmFkaXNjLmMuCiAJKiBTZXQgbmxwX3N0YXRlIGJlZm9yZSBjYWxsaW5nIGxwZmNfbmxwX2xpc3QoKSBzaW5jZSB0aGlzIHdpbGwKIAkgIHBvdGVudGlhbGx5IGNhbGwgZmNfdGFyZ2V0X3VuYmxvY2sgd2hpY2ggbWF5IGNhdXNlIGEgcmFjZSBpbgogCSAgcXVldWVjb21tYW5kIGJ5IHJlbGVhc2luZyBob3N0X2xvY2suCkBAIC03NTMsNyArNzUzLDcgQEAKIAkqIENoYW5nZWQgdmVyc2lvbiBudW1iZXIgdG8gOC4wLjEyCiAJKiBSZW1vdmVkIHVzZWQgI2RlZmluZXM6IERFRkFVTFRfUENJX0xBVEVOQ1lfQ0xPQ0tTIGFuZAogCSAgUENJX0xBVEVOQ1lfVkFMVUUgZnJvbSBscGZjX2h3LmguCi0JKiBDaGFuZ2VzIHRvIGFjY29tb2RhdGUgcm5pZC4KKwkqIENoYW5nZXMgdG8gYWNjb21tb2RhdGUgcm5pZC4KIAkqIEZpeCBSU0NOIGhhbmRsaW5nIHNvIFJTQ04gTlMgcXVlcmllcyBvbmx5IGVmZmVjdCBOUG9ydHMgZm91bmQgaW4KIAkgIFJTQ04gZGF0YS4KIAkqIElmIHdlIHJjdiBhIHBsb2dpIG9uIGEgTlBvcnQgcXVldWVkIHVwIGZvciBkaXNjb3ZlcnksIGNsZWFyIHRoZQpAQCAtODEzLDcgKzgxMyw3IEBACiAJICBjb3VudGVyIGluc3RlYWQsIGJyZF9ubyBpc24ndCByZXVzZWQgYW55bW9yZS4gIEFsc28gc29tZSB0aW55CiAJICB3aGl0ZXNwYWNlIGNsZWFudXBzIGluIHN1cnJvdW5kaW5nIGNvZGUuCiAJKiBSZW9yZGVyIGZ1bmN0aW9ucyBpbiBscGZjX2Vscy5jIHRvIHJlbW92ZSBuZWVkIGZvciBwcm90b3R5cGVzLgotCSogUmVtb3ZlZCB1bnNlZCBwcm90b3R5cGVzIGZyb20gbHBmY19jcnRuLmggLQorCSogUmVtb3ZlZCB1bnVzZWQgcHJvdG90eXBlcyBmcm9tIGxwZmNfY3J0bi5oIC0KIAkgIGxwZmNfaXBfdGltZW91dF9oYW5kbGVyLCBscGZjX3JlYWRfcGNpIGFuZCBscGZjX3Jldm9rZS4KIAkqIFJlbW92ZWQgc29tZSB1bnVzZWQgcHJvdG90eXBlcyBmcm9tIGxwZmNfY3J0bi5oIC0KIAkgIGxwZmNfc2NzaV9oYmFfcmVzZXQsIGxwZmNfc2NzaV9pc3N1ZV9pbnFzbiwKQEAgLTg2Myw3ICs4NjMsNyBAQAogCSogTWluaW1hbCBzdXBwb3J0IGZvciBTQ1NJIGZsYXQgc3BhY2UgYWRkcmVzc2luZy92b2x1bWUgc2V0CiAJICBhZGRyZXNzaW5nLiAgVXNlIDE2IGJpdHMgb2YgTFVOIGFkZHJlc3Mgc28gdGhhdCBmbGF0CiAJICBhZGRyZXNzaW5nL1ZTQSB3aWxsIHdvcmsuCi0JKiBDaGFuZ2VkIDIgb2NjdXJlbmNlcyBvZiBpZiggMSAhPSBmKHgpKSB0byBpZihmKHgpICE9IDEpCisJKiBDaGFuZ2VkIDIgb2NjdXJyZW5jZXMgb2YgaWYoIDEgIT0gZih4KSkgdG8gaWYoZih4KSAhPSAxKQogCSogRHJvcCBpbmNsdWRlIG9mIGxwZmNfY2ZncGFybS5oLgogCSogUmVkdWNlIHN0YWNrIHVzYWdlIG9mIGxwZmNfZmRtaV9jbWQgaW4gbHBmY19jdC5jLgogCSogQWRkIG1pbmltdW0gcmFuZ2UgY2hlY2tpbmcgcHJvcGVydHkgdG8gL3N5cyB3cml0ZS9zdG9yZQpAQCAtMTQ0OSw3ICsxNDQ5LDcgQEAKIAkqIFJlbW92ZWQgbHBmY19lbHNfY2hrX2xhdHQgZnJvbSB0aGUgbHBmY19jb25maWdfcG9zdCBmdW5jdGlvbi4KIAkgIGxwZmNfZWxzX2Noa19sYXR0IHdpbGwgZW5hYmxlIHRoZSBsaW5rIGV2ZW50IGludGVycnVwdHMgd2hlbgogCSAgZmxvZ2kgaXMgcGVuZGluZyB3aGljaCBjYXVzZXMgdHdvIGRpc2NvdmVyeSBzdGF0ZSBtYWNoaW5lcwotCSAgcnVubmluZyBwYXJhbGxlbHkuCisJICBydW5uaW5nIHBhcmFsbGVsbHkuCiAJKiBBZGQgcGNpX2Rpc2FibGVfZGV2aWNlIHRvIHVubG9hZCBwYXRoLgogCSogTW92ZSBscGZjX3NsZWVwX2V2ZW50IGZyb20gbHBmY19mY3AuYyB0byBscGZjX3V0aWxfaW9jdGwuYwogCSogQ2FsbCBkbWFfbWFwX3NpbmdsZSgpICYgcGNpX21hcF9zaW5nbGUoKSBkaXJlY3RseSBpbnN0ZWFkIG9mIHZpYQpAQCAtMTU5MCw3ICsxNTkwLDcgQEAKIAkgIEVMWF9XUklURV9IUyBFTFhfV1JJVEVfSEEgRUxYX1dSSVRFX0NBIEVMWF9SRUFEX0hDCiAJICBFTFhfUkVBRF9IUyBFTFhfUkVBRF9IQSBFTFhfUkVBRF9DQSBFTFhfUkVBRF9NQiBFTFhfUkVTRVQKIAkgIEVMWF9SRUFEX0hCQSBFTFhfSU5TVEFOQ0UgRUxYX0xJUC4gIEFsc28gaW50cm9kdWNlZAotCSAgYXR0cmlidXRlICJzZXQiIHRvIGJlIHVzZWQgaW4gY29uanVjdGlvbiB3aXRoIHRoZSBhYm92ZQorCSAgYXR0cmlidXRlICJzZXQiIHRvIGJlIHVzZWQgaW4gY29uanVuY3Rpb24gd2l0aCB0aGUgYWJvdmUKIAkgIGF0dHJpYnV0ZXMuCiAJKiBSZW1vdmVkIERMSU5LLCBlbnF1ZSBhbmQgZGVxdWUgZGVjbGFyYXRpb25zIG5vdyB0aGF0IGNsb2NrCiAJICBkb2Vzbid0IHVzZSB0aGVtIGFueW1vcmUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cubWVnYXJhaWQgYi9Eb2N1bWVudGF0aW9uL3Njc2kvQ2hhbmdlTG9nLm1lZ2FyYWlkCmluZGV4IDVlMDdkMzIuLmQyMDUyZmQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cubWVnYXJhaWQKKysrIGIvRG9jdW1lbnRhdGlvbi9zY3NpL0NoYW5nZUxvZy5tZWdhcmFpZApAQCAtMTY4LDcgKzE2OCw3IEBACiAKIDEuCVNvcnRlZCBvdXQgUENJIElEcyB0byByZW1vdmUgbWVnYXJhaWQgc3VwcG9ydCBvdmVybGFwcy4KIAlCYXNlZCBvbiB0aGUgcGF0Y2ggZnJvbSBEYW5pZWwsIHNvcnRlZCBvdXQgUENJIElEcyBhbG9uZyB3aXRoCi0JY2hhcmFjdG9yIG5vZGUgbmFtZSBjaGFuZ2UgZnJvbSAnbWVnYWRldicgdG8gJ21lZ2FkZXZfbGVnYWN5JyB0byBhdm9pZAorCWNoYXJhY3RlciBub2RlIG5hbWUgY2hhbmdlIGZyb20gJ21lZ2FkZXYnIHRvICdtZWdhZGV2X2xlZ2FjeScgdG8gYXZvaWQKIAljb25mbGljdC4KIAktLS0KIAlIb3BlZnVsbHkgd2UnbGwgYmUgZ2V0dGluZyB0aGUgYnVpbGQgcmVzdHJpY3Rpb24gemFwcGVkIG11Y2ggc29vbmVyLCAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cubmNyNTNjOHh4IGIvRG9jdW1lbnRhdGlvbi9zY3NpL0NoYW5nZUxvZy5uY3I1M2M4eHgKaW5kZXggOGIyNzhjMS4uOTI4OGUzZDggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cubmNyNTNjOHh4CisrKyBiL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cubmNyNTNjOHh4CkBAIC0yMDAsNyArMjAwLDcgQEAKIAkgIEJ5IGRlZmF1bHQgdGhlIGRyaXZlciB1c2VzIGJvdGggSVJRRl9TSEFSRUQgYW5kIElSUUZfRElTQUJMRUQuCiAJICBPcHRpb24gJ25jcjUzYzh4eD1pcnFtOjB4MjAnIG1heSBiZSB1c2VkIHdoZW4gYW4gSVJRIGlzIHNoYXJlZCBieSAKIAkgIGEgNTNDOFhYIGFkYXB0ZXIgYW5kIGEgbmV0d29yayBib2FyZC4KLQktIFRpbnkgbWlzcGVsbGluZyBmaXhlZCAoQUJPUlQgaW5zdGVhZCBvZiBBQlJUKS4gV2FzIGZvcnR1bmF0ZWx5IAorCS0gVGlueSBtaXNzcGVsbGluZyBmaXhlZCAoQUJPUlQgaW5zdGVhZCBvZiBBQlJUKS4gV2FzIGZvcnR1bmF0ZWx5IAogCSAgaGFybWxlc3MuCiAJLSBOZWdvdGlhdGUgU1lOQyBkYXRhIHRyYW5zZmVycyB3aXRoIENDUyBkZXZpY2VzLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Njc2kvQ2hhbmdlTG9nLnN5bTUzYzh4eCBiL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cuc3ltNTNjOHh4CmluZGV4IDAyZmZiYzEuLmMxOTMzNzAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cuc3ltNTNjOHh4CisrKyBiL0RvY3VtZW50YXRpb24vc2NzaS9DaGFuZ2VMb2cuc3ltNTNjOHh4CkBAIC00NTcsNyArNDU3LDcgQEAKIFNhdCBEZWMgMTkgIDIxOjAwIDE5OTggR2VyYXJkIFJvdWRpZXIgKGdyb3VkaWVyQGNsdWItaW50ZXJuZXQuZnIpCiAJKiB2ZXJzaW9uIHN5bTUzYzh4eC0xLjAKIAktIERlZmluZSBzb21lIG5ldyBJTyByZWdpc3RlcnMgZm9yIHRoZSA4OTYgKGlzdGF0MSwgbWJveDAsIG1ib3gxKQotCS0gUmV2YW1wIHNsaWdobHkgdGhlIFN5bWJpb3MgTlZSQU0gbGF5LW91dCBiYXNlZCBvbiB0aGUgZXhjZXJwdCBvZiAKKwktIFJldmFtcCBzbGlnaHRseSB0aGUgU3ltYmlvcyBOVlJBTSBsYXktb3V0IGJhc2VkIG9uIHRoZSBleGNlcnB0IG9mIAogCSAgdGhlIGhlYWRlciBmaWxlIEkgcmVjZWl2ZWQgZnJvbSBTeW1iaW9zLgogCS0gQ2hlY2sgdGhlIFBDSSBidXMgbnVtYmVyIGZvciB0aGUgYm9vdCBvcmRlciAoVXNpbmcgYSBmYXN0IAogCSAgUENJIGNvbnRyb2xsZXIgYmVoaW5nIGEgUENJLVBDSSBicmlkZ2Ugc2VlbXMgc3ViLW9wdGltYWwpLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zY3NpL2FoYTE1MngudHh0IGIvRG9jdW1lbnRhdGlvbi9zY3NpL2FoYTE1MngudHh0CmluZGV4IDI5Y2U2ZDguLjk0ODQ4NzMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2NzaS9haGExNTJ4LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Njc2kvYWhhMTUyeC50eHQKQEAgLTEyNCw3ICsxMjQsNyBAQAogdGhlIHJpZ2h0IGdlb21ldHJ5IHRvIGJlIGFibGUgdG8gaW50ZXJwcmV0IGl0LgogCiBNb3Jlb3ZlciB0aGVyZSBhcmUgY2VydGFpbiBsaW1pdGF0aW9ucyB0byB0aGUgQy9IL1MgYWRkcmVzc2luZyBzY2hlbWUsCi1uYW1lbHkgdGhlIGFkZHJlc3Mgc3BhY2UgaXMgbGltaXRlZCB0byB1cHRvIDI1NSBoZWFkcywgdXB0byA2MyBzZWN0b3JzCituYW1lbHkgdGhlIGFkZHJlc3Mgc3BhY2UgaXMgbGltaXRlZCB0byB1cCB0byAyNTUgaGVhZHMsIHVwIHRvIDYzIHNlY3RvcnMKIGFuZCBhIG1heGltdW0gb2YgMTAyMyBjeWxpbmRlcnMuCiAKIFRoZSBBSEEtMTUyMiBCSU9TIGNhbGN1bGF0ZXMgdGhlIGdlb21ldHJ5IGJ5IGZpeGluZyB0aGUgbnVtYmVyIG9mIGhlYWRzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Njc2kvYWljNzl4eC50eHQgYi9Eb2N1bWVudGF0aW9uL3Njc2kvYWljNzl4eC50eHQKaW5kZXggMTZlMDU0Yy4uNjRhYzcwOSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zY3NpL2FpYzc5eHgudHh0CisrKyBiL0RvY3VtZW50YXRpb24vc2NzaS9haWM3OXh4LnR4dApAQCAtMjY3LDcgKzI2Nyw3IEBACiAgICAgICAgICAgICAgIE9wdGlvbjogdGFnX2luZm86e3t2YWx1ZVssdmFsdWUuLi5dfVsse3ZhbHVlWyx2YWx1ZS4uLl19Li4uXX0KICAgICAgICAgICBEZWZpbml0aW9uOiBTZXQgdGhlIHBlci10YXJnZXQgdGFnZ2VkIHF1ZXVlIGRlcHRoIG9uIGEKICAgICAgICAgICAgICAgICAgICAgICBwZXIgY29udHJvbGxlciBiYXNpcy4gIEJvdGggY29udHJvbGxlcnMgYW5kIHRhcmdldHMKLSAgICAgICAgICAgICAgICAgICAgICBtYXkgYmUgb21taXR0ZWQgaW5kaWNhdGluZyB0aGF0IHRoZXkgc2hvdWxkIHJldGFpbgorICAgICAgICAgICAgICAgICAgICAgIG1heSBiZSBvbWl0dGVkIGluZGljYXRpbmcgdGhhdCB0aGV5IHNob3VsZCByZXRhaW4KICAgICAgICAgICAgICAgICAgICAgICB0aGUgZGVmYXVsdCB0YWcgZGVwdGguCiAgICAgICAgICAgICBFeGFtcGxlczogdGFnX2luZm86e3sxNiwzMiwzMiw2NCw4LDgsLDMyLDMyLDMyLDMyLDMyLDMyLDMyLDMyLDMyfQogICAgICAgICAgICAgICAgICAgICAgICAgT24gQ29udHJvbGxlciAwCkBAIC0yOTEsNyArMjkxLDcgQEAKICAgICAgICAgICAgICAgICAgICAgICBUaGUgcmRfc3RybV9iaXRtYXNrIGlzIGEgMTYgYml0IGhleCB2YWx1ZSBpbiB3aGljaAogICAgICAgICAgICAgICAgICAgICAgIGVhY2ggYml0IHJlcHJlc2VudHMgYSB0YXJnZXQuICBTZXR0aW5nIHRoZSB0YXJnZXQncwogICAgICAgICAgICAgICAgICAgICAgIGJpdCB0byAnMScgZW5hYmxlcyByZWFkIHN0cmVhbWluZyBmb3IgdGhhdAotICAgICAgICAgICAgICAgICAgICAgIHRhcmdldC4gIENvbnRyb2xsZXJzIG1heSBiZSBvbW1pdHRlZCBpbmRpY2F0aW5nIHRoYXQKKyAgICAgICAgICAgICAgICAgICAgICB0YXJnZXQuICBDb250cm9sbGVycyBtYXkgYmUgb21pdHRlZCBpbmRpY2F0aW5nIHRoYXQKICAgICAgICAgICAgICAgICAgICAgICB0aGV5IHNob3VsZCByZXRhaW4gdGhlIGRlZmF1bHQgcmVhZCBzdHJlYW1pbmcgc2V0dGluZy4KICAgICAgICAgICAgICBFeGFtcGxlOiByZF9zdHJtOnsweDAwNDF9CiAgICAgICAgICAgICAgICAgICAgICAgICBPbiBDb250cm9sbGVyIDAKQEAgLTMxMyw3ICszMTMsNyBAQAogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICAgICAgICAgICAgT3B0aW9uOiBkdjoge3ZhbHVlWyx2YWx1ZS4uLl19CiAgICAgICAgICAgRGVmaW5pdGlvbjogU2V0IERvbWFpbiBWYWxpZGF0aW9uIFBvbGljeSBvbiBhIHBlci1jb250cm9sbGVyIGJhc2lzLgotICAgICAgICAgICAgICAgICAgICAgIENvbnRyb2xsZXJzIG1heSBiZSBvbW1pdHRlZCBpbmRpY2F0aW5nIHRoYXQKKyAgICAgICAgICAgICAgICAgICAgICBDb250cm9sbGVycyBtYXkgYmUgb21pdHRlZCBpbmRpY2F0aW5nIHRoYXQKICAgICAgICAgICAgICAgICAgICAgICB0aGV5IHNob3VsZCByZXRhaW4gdGhlIGRlZmF1bHQgcmVhZCBzdHJlYW1pbmcgc2V0dGluZy4KICAgICAgICAgICAgICBFeGFtcGxlOiBkdjp7LTEsMCwsMSwxLDB9CiAgICAgICAgICAgICAgICAgICAgICAgICBPbiBDb250cm9sbGVyIDAgbGVhdmUgRFYgYXQgaXRzIGRlZmF1bHQgc2V0dGluZy4KQEAgLTM0MCw3ICszNDAsNyBAQAogICAgICAgICAgICAgICBPcHRpb246IHByZWNvbXA6IHt2YWx1ZVssdmFsdWUuLi5dfQogICAgICAgICAgIERlZmluaXRpb246IFNldCBJTyBDZWxsIHByZWNvbXBlbnNhdGlvbiB2YWx1ZSBvbiBhIHBlci1jb250cm9sbGVyCiAgICAgICAgICAgICAgICAgICAgICAgYmFzaXMuCi0gICAgICAgICAgICAgICAgICAgICAgQ29udHJvbGxlcnMgbWF5IGJlIG9tbWl0dGVkIGluZGljYXRpbmcgdGhhdAorICAgICAgICAgICAgICAgICAgICAgIENvbnRyb2xsZXJzIG1heSBiZSBvbWl0dGVkIGluZGljYXRpbmcgdGhhdAogICAgICAgICAgICAgICAgICAgICAgIHRoZXkgc2hvdWxkIHJldGFpbiB0aGUgZGVmYXVsdCBwcmVjb21wZW5zYXRpb24gc2V0dGluZy4KICAgICAgICAgICAgICBFeGFtcGxlOiBwcmVjb21wOnsweDF9CiAgICAgICAgICAgICAgICAgICAgICAgICBPbiBDb250cm9sbGVyIDAgc2V0IHByZWNvbXBlbnNhdGlvbiB0byAxLgpAQCAtMzUzLDcgKzM1Myw3IEBACiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgICAgICAgICAgICBPcHRpb246IHNsZXdyYXRlOiB7dmFsdWVbLHZhbHVlLi4uXX0KICAgICAgICAgICBEZWZpbml0aW9uOiBTZXQgSU8gQ2VsbCBzbGV3IHJhdGUgb24gYSBwZXItY29udHJvbGxlciBiYXNpcy4KLSAgICAgICAgICAgICAgICAgICAgICBDb250cm9sbGVycyBtYXkgYmUgb21taXR0ZWQgaW5kaWNhdGluZyB0aGF0CisgICAgICAgICAgICAgICAgICAgICAgQ29udHJvbGxlcnMgbWF5IGJlIG9taXR0ZWQgaW5kaWNhdGluZyB0aGF0CiAgICAgICAgICAgICAgICAgICAgICAgdGhleSBzaG91bGQgcmV0YWluIHRoZSBkZWZhdWx0IHNsZXcgcmF0ZSBzZXR0aW5nLgogICAgICAgICAgICAgIEV4YW1wbGU6IHNsZXdyYXRlOnsweDF9CiAgICAgICAgICAgICAgICAgICAgICAgICBPbiBDb250cm9sbGVyIDAgc2V0IHNsZXcgcmF0ZSB0byAxLgpAQCAtMzY2LDcgKzM2Niw3IEBACiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgICAgICAgICAgICBPcHRpb246IGFtcGxpdHVkZToge3ZhbHVlWyx2YWx1ZS4uLl19CiAgICAgICAgICAgRGVmaW5pdGlvbjogU2V0IElPIENlbGwgc2lnbmFsIGFtcGxpdHVkZSBvbiBhIHBlci1jb250cm9sbGVyIGJhc2lzLgotICAgICAgICAgICAgICAgICAgICAgIENvbnRyb2xsZXJzIG1heSBiZSBvbW1pdHRlZCBpbmRpY2F0aW5nIHRoYXQKKyAgICAgICAgICAgICAgICAgICAgICBDb250cm9sbGVycyBtYXkgYmUgb21pdHRlZCBpbmRpY2F0aW5nIHRoYXQKICAgICAgICAgICAgICAgICAgICAgICB0aGV5IHNob3VsZCByZXRhaW4gdGhlIGRlZmF1bHQgcmVhZCBzdHJlYW1pbmcgc2V0dGluZy4KICAgICAgICAgICAgICBFeGFtcGxlOiBhbXBsaXR1ZGU6ezB4MX0KICAgICAgICAgICAgICAgICAgICAgICAgIE9uIENvbnRyb2xsZXIgMCBzZXQgYW1wbGl0dWRlIHRvIDEuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Njc2kvaWJtbWNhLnR4dCBiL0RvY3VtZW50YXRpb24vc2NzaS9pYm1tY2EudHh0CmluZGV4IDQ1ZDYxYWQuLmFjNDFhOWYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2NzaS9pYm1tY2EudHh0CisrKyBiL0RvY3VtZW50YXRpb24vc2NzaS9pYm1tY2EudHh0CkBAIC0zMDMsNyArMzAzLDcgQEAKICAgIChzY2IpIGFuZCBjYWxscyBhIGxvY2FsIGZ1bmN0aW9uIGlzc3VlX2NtZCgpLCB3aGljaCB3cml0ZXMgYSBzY2IgCiAgICBjb21tYW5kIGludG8gc3Vic3lzdGVtIEkvTyBwb3J0cy4gT25jZSB0aGUgc2NiIGNvbW1hbmQgaXMgY2FycmllZCBvdXQsIAogICAgdGhlIGludGVycnVwdF9oYW5kbGVyKCkgaXMgaW52b2tlZC4gSWYgYSBkZXZpY2UgaXMgZGV0ZXJtaW5lZCB0byBiZSAKLSAgIGV4aXN0YW50IGFuZCBpdCBoYXMgbm90IGFzc2lnbmVkIGFueSBsZG4sIGl0IGdldHMgb25lIGR5bmFtaWNhbGx5LgorICAgZXhpc3RlbnQgYW5kIGl0IGhhcyBub3QgYXNzaWduZWQgYW55IGxkbiwgaXQgZ2V0cyBvbmUgZHluYW1pY2FsbHkuCiAgICBGb3IgdGhpcywgdGhlIHdob2xlIHN0dWZmIGlzIGRvbmUgaW4gaWJtbWNhX3F1ZXVlY29tbWFuZCgpLgogCiAgICAyLjYgQWJvcnQgJiBSZXNldCBDb21tYW5kcwpAQCAtNzQxLDcgKzc0MSw3IEBACiAgICAgICBzb21lIGVycm9yIGFwcGVhcmVkLCBlbHNlIGl0IGlzIHVuZGVmaW5lZC4gTm93LCB0aGlzIGlzIGZpeGVkLiBCZWZvcmUKICAgICAgIGFueSBTQ0IgY29tbWFuZCBnZXRzIHF1ZXVlZCwgdGhlIHRzYi5kZXZfc3RhdHVzIGlzIHNldCB0byAwLCBzbyB0aGUgCiAgICAgICBjbWQtPnJlc3VsdCB3b24ndCBzY3JldyB1cCBMaW51eCBoaWdoZXIgbGV2ZWwgZHJpdmVycy4KLSAgIDIpIFRoZSByZXNldC1mdW5jdGlvbiBoYXMgc2xpZ2h0bHkgaW1wcm92ZWQuIFRoaXMgaXMgc3RpbGwgcGxhbmVkIGZvciAKKyAgIDIpIFRoZSByZXNldC1mdW5jdGlvbiBoYXMgc2xpZ2h0bHkgaW1wcm92ZWQuIFRoaXMgaXMgc3RpbGwgcGxhbm5lZCBmb3IgCiAgICAgICBhYm9ydC4gRHVyaW5nIHRoZSBhYm9ydCBhbmQgdGhlIHJlc2V0IGZ1bmN0aW9uLCBubyBpbnRlcnJ1cHRzIGFyZSAKICAgICAgIGFsbG93ZWQuIFRoaXMgaXMgaG93ZXZlciBxdWl0ZSBoYXJkIHRvIGNvcGUgd2l0aCwgc28gdGhlIElOVC1zdGF0dXMKICAgICAgIHJlZ2lzdGVyIGlzIHJlYWQuIFdoZW4gdGhlIGludGVycnVwdCBnZXRzIHF1ZXVlZCwgb25lIGNhbiBmaW5kIGl0cwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zY3NpL3Njc2ktY2hhbmdlci50eHQgYi9Eb2N1bWVudGF0aW9uL3Njc2kvc2NzaS1jaGFuZ2VyLnR4dAppbmRleCAwMzIzOTliLi5hZGUwNDZlIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3Njc2kvc2NzaS1jaGFuZ2VyLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Njc2kvc2NzaS1jaGFuZ2VyLnR4dApAQCAtMTAyLDcgKzEwMiw3IEBACiAKIElmIHlvdSBpbnNtb2QgdGhlIGRyaXZlciB3aXRoICJpbnNtb2QgZGVidWc9MSIsIGl0IHdpbGwgYmUgdmVyYm9zZSBhbmQKIHByaW50cyBhIGxvdCBvZiBzdHVmZiB0byB0aGUgc3lzbG9nLiAgQ29tcGlsaW5nIHRoZSBrZXJuZWwgd2l0aAotQ09ORklHX1NDU0lfQ09OU1RBTlRTPXkgaW1wcm92ZXMgdGhlIHF1YWxpdHkgb2YgdGhlIGVycm9yIG1lc3NhZ2VzIGFsb3QKK0NPTkZJR19TQ1NJX0NPTlNUQU5UUz15IGltcHJvdmVzIHRoZSBxdWFsaXR5IG9mIHRoZSBlcnJvciBtZXNzYWdlcyBhIGxvdAogYmVjYXVzZSB0aGUga2VybmVsIHdpbGwgdHJhbnNsYXRlIHRoZSBlcnJvciBjb2RlcyBpbnRvIGh1bWFuLXJlYWRhYmxlCiBzdHJpbmdzIHRoZW4uCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2NzaS9zY3NpX2VoLnR4dCBiL0RvY3VtZW50YXRpb24vc2NzaS9zY3NpX2VoLnR4dAppbmRleCA3YWNiZWJiLi42ZmYxNmI2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3Njc2kvc2NzaV9laC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9zY3NpL3Njc2lfZWgudHh0CkBAIC0yOTAsNyArMjkwLDcgQEAKIAlTQ1NJIHRyYW5zcG9ydHMvTExERHMgYXV0b21hdGljYWxseSBhY3F1aXJlIHNlbnNlIGRhdGEgb24KIAljb21tYW5kIGZhaWx1cmVzIChhdXRvc2Vuc2UpLiAgQXV0b3NlbnNlIGlzIHJlY29tbWVuZGVkIGZvcgogCXBlcmZvcm1hbmNlIHJlYXNvbnMgYW5kIGFzIHNlbnNlIGluZm9ybWF0aW9uIGNvdWxkIGdldCBvdXQgb2YKLQlzeW5jIGluYmV0d2VlbiBvY2N1cnJlbmNlIG9mIENIRUNLIENPTkRJVElPTiBhbmQgdGhpcyBhY3Rpb24uCisJc3luYyBiZXR3ZWVuIG9jY3VycmVuY2Ugb2YgQ0hFQ0sgQ09ORElUSU9OIGFuZCB0aGlzIGFjdGlvbi4KIAogCU5vdGUgdGhhdCBpZiBhdXRvc2Vuc2UgaXMgbm90IHN1cHBvcnRlZCwgc2NtZC0+c2Vuc2VfYnVmZmVyCiAJY29udGFpbnMgaW52YWxpZCBzZW5zZSBkYXRhIHdoZW4gZXJyb3ItY29tcGxldGluZyB0aGUgc2NtZApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zY3NpL3Njc2lfZmNfdHJhbnNwb3J0LnR4dCBiL0RvY3VtZW50YXRpb24vc2NzaS9zY3NpX2ZjX3RyYW5zcG9ydC50eHQKaW5kZXggZTAwMTkyZC4uZjc5MjgyZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zY3NpL3Njc2lfZmNfdHJhbnNwb3J0LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Njc2kvc2NzaV9mY190cmFuc3BvcnQudHh0CkBAIC0yOTEsNyArMjkxLDcgQEAKIFZwb3J0IHN1cHBvcnQgYnkgTExERDoKIAogICBUaGUgTExERCBpbmRpY2F0ZXMgc3VwcG9ydCBmb3IgdnBvcnRzIGJ5IHN1cHBseWluZyBhIHZwb3J0X2NyZWF0ZSgpCi0gIGZ1bmN0aW9uIGluIHRoZSB0cmFuc3BvcnQgdGVtcGxhdGUuICBUaGUgcHJlc2Vuc2Ugb2YgdGhpcyBmdW5jdGlvbiB3aWxsCisgIGZ1bmN0aW9uIGluIHRoZSB0cmFuc3BvcnQgdGVtcGxhdGUuICBUaGUgcHJlc2VuY2Ugb2YgdGhpcyBmdW5jdGlvbiB3aWxsCiAgIGNhdXNlIHRoZSBjcmVhdGlvbiBvZiB0aGUgbmV3IGF0dHJpYnV0ZXMgb24gdGhlIGZjX2hvc3QuICBBcyBwYXJ0IG9mCiAgIHRoZSBwaHlzaWNhbCBwb3J0IGNvbXBsZXRpbmcgaXRzIGluaXRpYWxpemF0aW9uIHJlbGF0aXZlIHRvIHRoZQogICB0cmFuc3BvcnQsIGl0IHNob3VsZCBzZXQgdGhlIG1heF9ucGl2X3Zwb3J0cyBhdHRyaWJ1dGUgdG8gaW5kaWNhdGUgdGhlCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NlcmlhbC9tb3hhLXNtYXJ0aW8gYi9Eb2N1bWVudGF0aW9uL3NlcmlhbC9tb3hhLXNtYXJ0aW8KaW5kZXggZDEwNDQzOS4uNWQyYTMzYiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zZXJpYWwvbW94YS1zbWFydGlvCisrKyBiL0RvY3VtZW50YXRpb24vc2VyaWFsL21veGEtc21hcnRpbwpAQCAtNDczLDcgKzQ3Myw3IEBACiAgICBzcGRfbm9ybWFsCSAgVXNlICAzOC40a2IgIHdoZW4gIHRoZSBhcHBsaWNhdGlvbiByZXF1ZXN0cyAzOC40a2IuCiAgICBzcGRfY3VzdAkgIFVzZSAgdGhlIGN1c3RvbSBkaXZpc29yIHRvIHNldCB0aGUgc3BlZWQgd2hlbiAgdGhlCiAJCSAgYXBwbGljYXRpb24gcmVxdWVzdHMgMzguNGtiLgotICAgZGl2aXNvcgkgIFRoaXMgb3B0aW9uIHNldCB0aGUgY3VzdG9tIGRpdmlzb24uCisgICBkaXZpc29yCSAgVGhpcyBvcHRpb24gc2V0IHRoZSBjdXN0b20gZGl2aXNpb24uCiAgICBiYXVkX2Jhc2UJICBUaGlzIG9wdGlvbiBzZXQgdGhlIGJhc2UgYmF1ZCByYXRlLgogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zZXJpYWwvbl9nc20udHh0IGIvRG9jdW1lbnRhdGlvbi9zZXJpYWwvbl9nc20udHh0CmluZGV4IDM5N2Y0MWEuLmE1ZDkxMTIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2VyaWFsL25fZ3NtLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3NlcmlhbC9uX2dzbS50eHQKQEAgLTM0LDcgKzM0LDcgQEAKIAkvKiBjb25maWd1cmUgdGhlIHNlcmlhbCBwb3J0IDogc3BlZWQsIGZsb3cgY29udHJvbCAuLi4gKi8KIAogCS8qIHNlbmQgdGhlIEFUIGNvbW1hbmRzIHRvIHN3aXRjaCB0aGUgbW9kZW0gdG8gQ01VWCBtb2RlCi0JICAgYW5kIGNoZWNrIHRoYXQgaXQncyBzdWNjZXNmdWwgKHNob3VsZCByZXR1cm4gT0spICovCisJICAgYW5kIGNoZWNrIHRoYXQgaXQncyBzdWNjZXNzZnVsIChzaG91bGQgcmV0dXJuIE9LKSAqLwogCXdyaXRlKGZkLCAiQVQrQ01VWD0wXHIiLCAxMCk7CiAKIAkvKiBleHBlcmllbmNlIHNob3dlZCB0aGF0IHNvbWUgbW9kZW1zIG5lZWQgc29tZSB0aW1lIGJlZm9yZQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL0FMU0EtQ29uZmlndXJhdGlvbi50eHQgYi9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2EvQUxTQS1Db25maWd1cmF0aW9uLnR4dAppbmRleCAxODFiYTViLi45ODIyYWZiIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2EvQUxTQS1Db25maWd1cmF0aW9uLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2EvQUxTQS1Db25maWd1cmF0aW9uLnR4dApAQCAtMzIyLDcgKzMyMiw3IEBACiAgICAgInBvcnQiIG5lZWRzIHRvIG1hdGNoIHRoZSBCQVNFIEFERFJFU1MganVtcGVyIG9uIHRoZSBjYXJkICgweDIyMCBvciAweDI0MCkKICAgICBvciB0aGUgdmFsdWUgc3RvcmVkIGluIHRoZSBjYXJkJ3MgRUVQUk9NIGZvciBjYXJkcyB0aGF0IGhhdmUgYW4gRUVQUk9NIGFuZAogICAgIHRoZWlyICJDT05GSUcgTU9ERSIganVtcGVyIHNldCB0byAiRUVQUk9NIFNFVFRJTkciLiBUaGUgb3RoZXIgdmFsdWVzIGNhbgotICAgIGJlIGNob29zZW4gZnJlZWx5IGZyb20gdGhlIG9wdGlvbnMgZW51bWVyYXRlZCBhYm92ZS4KKyAgICBiZSBjaG9zZW4gZnJlZWx5IGZyb20gdGhlIG9wdGlvbnMgZW51bWVyYXRlZCBhYm92ZS4KIAogICAgIElmIGRtYTIgaXMgc3BlY2lmaWVkIGFuZCBkaWZmZXJlbnQgZnJvbSBkbWExLCB0aGUgY2FyZCB3aWxsIG9wZXJhdGUgaW4KICAgICBmdWxsLWR1cGxleCBtb2RlLiBXaGVuIGRtYTE9Mywgb25seSBkbWEyPTAgaXMgdmFsaWQgYW5kIHRoZSBvbmx5IHdheSB0bwpAQCAtMzU2LDcgKzM1Niw3IEBACiAgICAgInBvcnQiIG5lZWRzIHRvIG1hdGNoIHRoZSBCQVNFIEFERFJFU1MganVtcGVyIG9uIHRoZSBjYXJkICgweDIyMCBvciAweDI0MCkKICAgICBvciB0aGUgdmFsdWUgc3RvcmVkIGluIHRoZSBjYXJkJ3MgRUVQUk9NIGZvciBjYXJkcyB0aGF0IGhhdmUgYW4gRUVQUk9NIGFuZAogICAgIHRoZWlyICJDT05GSUcgTU9ERSIganVtcGVyIHNldCB0byAiRUVQUk9NIFNFVFRJTkciLiBUaGUgb3RoZXIgdmFsdWVzIGNhbgotICAgIGJlIGNob29zZW4gZnJlZWx5IGZyb20gdGhlIG9wdGlvbnMgZW51bWVyYXRlZCBhYm92ZS4KKyAgICBiZSBjaG9zZW4gZnJlZWx5IGZyb20gdGhlIG9wdGlvbnMgZW51bWVyYXRlZCBhYm92ZS4KIAogICAgIElmIGRtYTIgaXMgc3BlY2lmaWVkIGFuZCBkaWZmZXJlbnQgZnJvbSBkbWExLCB0aGUgY2FyZCB3aWxsIG9wZXJhdGUgaW4KICAgICBmdWxsLWR1cGxleCBtb2RlLiBXaGVuIGRtYTE9Mywgb25seSBkbWEyPTAgaXMgdmFsaWQgYW5kIHRoZSBvbmx5IHdheSB0bwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9vc3MvUkVBRE1FLk9TUyBiL0RvY3VtZW50YXRpb24vc291bmQvb3NzL1JFQURNRS5PU1MKaW5kZXggYzYxNWRlYi4uNGJlMjU5NCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9vc3MvUkVBRE1FLk9TUworKysgYi9Eb2N1bWVudGF0aW9uL3NvdW5kL29zcy9SRUFETUUuT1NTCkBAIC0xMzUyLDcgKzEzNTIsNyBAQAogVGhlIFBDTTIwIGNvbnRhaW5zIGEgcmFkaW8gdHVuZXIsIHdoaWNoIGlzIGFsc28gY29udHJvbGxlZCBieQogQUNJLiBUaGlzIHJhZGlvIHR1bmVyIGlzIHN1cHBvcnRlZCBieSB0aGUgQUNJIGRyaXZlciB0b2dldGhlciB3aXRoIHRoZQogbWlyb3BjbTIwLm8gbW9kdWxlLiBBbHNvIHRoZSA3LWJhbmQgZXF1YWxpemVyIGlzIGludGVncmF0ZWQKLShsaW1pdGVkIGJ5IHRoZSBPU1MtZGVzaWduKS4gRGV2ZWxvcGVtZW50IGhhcyBzdGFydGVkIGFuZCBtYXliZQorKGxpbWl0ZWQgYnkgdGhlIE9TUy1kZXNpZ24pLiBEZXZlbG9wbWVudCBoYXMgc3RhcnRlZCBhbmQgbWF5YmUKIGZpbmlzaGVkIGZvciB0aGUgUkRTIGRlY29kZXIgb24gdGhpcyBjYXJkLCB0b28uIFlvdSB3aWxsIGJlIGFibGUgdG8KIHJlYWQgUmFkaW9UZXh0LCB0aGUgUHJvZ3JhbW1lIFNlcnZpY2UgbmFtZSwgUHJvZ3JhbW1lIFRZcGUgYW5kCiBvdGhlcnMuIEV2ZW4gdGhlIHY0bCByYWRpbyBtb2R1bGUgYmVuZWZpdHMgZnJvbSBpdCB3aXRoIGEgcmVmaW5lZApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zcGkvcHhhMnh4IGIvRG9jdW1lbnRhdGlvbi9zcGkvcHhhMnh4CmluZGV4IDY4YTRmZTMuLjQ5M2RhZGEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc3BpL3B4YTJ4eAorKysgYi9Eb2N1bWVudGF0aW9uL3NwaS9weGEyeHgKQEAgLTE0Myw3ICsxNDMsNyBAQAogTk9URTogdGhlIFNQSSBkcml2ZXIgY2Fubm90IGNvbnRyb2wgdGhlIGNoaXAgc2VsZWN0IGlmIFNTUEZSTSBpcyB1c2VkLCBzbyB0aGUKIGNoaXBzZWxlY3QgaXMgZHJvcHBlZCBhZnRlciBlYWNoIHNwaV90cmFuc2Zlci4gIE1vc3QgZGV2aWNlcyBuZWVkIGNoaXAgc2VsZWN0CiBhc3NlcnRlZCBhcm91bmQgdGhlIGNvbXBsZXRlIG1lc3NhZ2UuICBVc2UgU1NQRlJNIGFzIGEgR1BJTyAodGhyb3VnaCBjc19jb250cm9sKQotdG8gYWNjb21vZGF0ZSB0aGVzZSBjaGlwcy4KK3RvIGFjY29tbW9kYXRlIHRoZXNlIGNoaXBzLgogCiAKIE5TU1AgU0xBVkUgU0FNUExFCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NwaS9zcGktbG03MGxscCBiL0RvY3VtZW50YXRpb24vc3BpL3NwaS1sbTcwbGxwCmluZGV4IDM0YTljZmQuLjQ2M2Y2ZDAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc3BpL3NwaS1sbTcwbGxwCisrKyBiL0RvY3VtZW50YXRpb24vc3BpL3NwaS1sbTcwbGxwCkBAIC00Niw3ICs0Niw3IEBACiAKIE5vdGUgdGhhdCBzaW5jZSB0aGUgTE03MCB1c2VzIGEgIjMtd2lyZSIgdmFyaWFudCBvZiBTUEksIHRoZSBTSS9TTyBwaW4KIGlzIGNvbm5lY3RlZCB0byBib3RoIHBpbiBENyAoYXMgTWFzdGVyIE91dCkgYW5kIFNlbGVjdCAoYXMgTWFzdGVyIEluKQotdXNpbmcgYW4gYXJyYW5nbWVudCB0aGF0IGxldHMgZWl0aGVyIHRoZSBwYXJwb3J0IG9yIHRoZSBMTTcwIHB1bGwgdGhlCit1c2luZyBhbiBhcnJhbmdlbWVudCB0aGF0IGxldHMgZWl0aGVyIHRoZSBwYXJwb3J0IG9yIHRoZSBMTTcwIHB1bGwgdGhlCiBwaW4gbG93LiAgVGhpcyBjYW4ndCBiZSBzaGFyZWQgd2l0aCB0cnVlIFNQSSBkZXZpY2VzLCBidXQgb3RoZXIgMy13aXJlCiBkZXZpY2VzIG1pZ2h0IHNoYXJlIHRoZSBzYW1lIFNJL1NPIHBpbi4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi90ZWxlcGhvbnkvaXhqLnR4dCBiL0RvY3VtZW50YXRpb24vdGVsZXBob255L2l4ai50eHQKaW5kZXggNGZiMzE0ZC4uZGI5NGZiNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi90ZWxlcGhvbnkvaXhqLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3RlbGVwaG9ueS9peGoudHh0CkBAIC01MSw3ICs1MSw3IEBACiBTcGVjaWZpY2FsbHksIHZlcnkgb2xkIEludGVybmV0IFBob25lSkFDSyBjYXJkcyBoYXZlIG5vbi1zdGFuZGFyZAogRy43MjMuMSBjb2RlY3MgKGR1ZSB0byB0aGUgZWFybHkgbmF0dXJlIG9mIHRoZSBEU1BzIGluIHRob3NlIGRheXMpLgogVGhlIGF1dG8tY29udmVyc2lvbiBjb2RlIHRvIGJyaW5nIHRob3NlIGNhcmRzIGludG8gY29tcGxpYW5jZSB3aXRoCi10b2RheXMgc3RhbmRhcmRzIGlzIGF2YWlsYWJsZSBhcyBhIGJpbmFyeSBvbmx5IG1vZHVsZSB0byB0aG9zZSBwZW9wbGUKK3RvZGF5J3Mgc3RhbmRhcmRzIGlzIGF2YWlsYWJsZSBhcyBhIGJpbmFyeSBvbmx5IG1vZHVsZSB0byB0aG9zZSBwZW9wbGUKIG5lZWRpbmcgaXQuICBJZiB5b3UgYm91Z2h0IHlvdXIgY2FyZCBhZnRlciAxOTk3IG9yIHNvLCB5b3UgYXJlIE9LIC0KIGl0J3Mgb25seSB0aGUgdmVyeSBvbGQgY2FyZHMgdGhhdCBhcmUgYWZmZWN0ZWQuCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdHJhY2UvcmluZy1idWZmZXItZGVzaWduLnR4dCBiL0RvY3VtZW50YXRpb24vdHJhY2UvcmluZy1idWZmZXItZGVzaWduLnR4dAppbmRleCBkMjk5ZmYzLi43ZDM1MGI0IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3RyYWNlL3JpbmctYnVmZmVyLWRlc2lnbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90cmFjZS9yaW5nLWJ1ZmZlci1kZXNpZ24udHh0CkBAIC0yMzcsNyArMjM3LDcgQEAKICAgICAgIHx3cml0dGVuICB8CiAgICAgICArLS0tLS0tLS0tKwogICAgICAgfHdyaXR0ZW4gIHwKLSAgICAgICstLS0tLS0tLS0rICA8LS0tIG5leHQgcG9zaXRvbiBmb3Igd3JpdGUgKGN1cnJlbnQgY29tbWl0KQorICAgICAgKy0tLS0tLS0tLSsgIDwtLS0gbmV4dCBwb3NpdGlvbiBmb3Igd3JpdGUgKGN1cnJlbnQgY29tbWl0KQogICAgICAgfCBlbXB0eSAgIHwKICAgICAgICstLS0tLS0tLS0rCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvUkVBRE1FLnB2cnVzYjIgYi9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L1JFQURNRS5wdnJ1c2IyCmluZGV4IGE3NDcyMDAuLjIxMzdiNTggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvUkVBRE1FLnB2cnVzYjIKKysrIGIvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9SRUFETUUucHZydXNiMgpAQCAtMTcyLDcgKzE3Miw3IEBACiAgICAgdG8gcHJvdmlkZSBhIHN0cmVhbWluZyBBUEkgdXNhYmxlIGJ5IGEgcmVhZCgpIHN5c3RlbSBjYWxsIHN0eWxlIG9mCiAgICAgSS9PLiAgUmlnaHQgbm93IHRoaXMgaXMgdGhlIG9ubHkgbGF5ZXIgb24gdG9wIG9mIHB2cnVzYjItaW8uW2NoXSwKICAgICBob3dldmVyIHRoZSB1bmRlcmx5aW5nIGFyY2hpdGVjdHVyZSBoZXJlIHdhcyBpbnRlbmRlZCB0byBhbGxvdyBmb3IKLSAgICBvdGhlciBzdHlsZXMgb2YgSS9PIHRvIGJlIGltcGxlbWVudGVkIHdpdGggYWRkaXRvbmFsIG1vZHVsZXMsIGxpa2UKKyAgICBvdGhlciBzdHlsZXMgb2YgSS9PIHRvIGJlIGltcGxlbWVudGVkIHdpdGggYWRkaXRpb25hbCBtb2R1bGVzLCBsaWtlCiAgICAgbW1hcCgpJ2VkIGJ1ZmZlcnMgb3Igc29tZXRoaW5nIGV2ZW4gbW9yZSBleG90aWMuCiAKICAgcHZydXNiMi1tYWluLmMgLSBUaGlzIGlzIHRoZSB0b3AgbGV2ZWwgb2YgdGhlIGRyaXZlci4gIE1vZHVsZSBsZXZlbApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9idHR2L1JFQURNRSBiL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvYnR0di9SRUFETUUKaW5kZXggM2EzNjdjZC4uN2NiZjRmYiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9idHR2L1JFQURNRQorKysgYi9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L2J0dHYvUkVBRE1FCkBAIC03MCw3ICs3MCw3IEBACiBpbnN0ZWFkIG9mIG1haWxpbmcgbWUgZGlyZWN0bHkuICBUaGUgY2hhbmNlIHRoYXQgc29tZW9uZSB3aXRoIHRoZQogc2FtZSBjYXJkIGxpc3RlbnMgdGhlcmUgaXMgbXVjaCBoaWdoZXIuLi4KIAotRm9yIHByb2JsZW1zIHdpdGggc291bmQ6ICBUaGVyZSBhcmUgYWxvdCBvZiBkaWZmZXJlbnQgc3lzdGVtcyB1c2VkCitGb3IgcHJvYmxlbXMgd2l0aCBzb3VuZDogIFRoZXJlIGFyZSBhIGxvdCBvZiBkaWZmZXJlbnQgc3lzdGVtcyB1c2VkCiBmb3IgVFYgc291bmQgYWxsIG92ZXIgdGhlIHdvcmxkLiAgQW5kIHRoZXJlIGFyZSBhbHNvIGRpZmZlcmVudCBjaGlwcwogd2hpY2ggZGVjb2RlIHRoZSBhdWRpbyBzaWduYWwuICBSZXBvcnRzIGFib3V0IHNvdW5kIHByb2JsZW1zICgic3RlcmVvCiBkb2VzJ250IHdvcmsiKSBhcmUgcHJldHR5IHVzZWxlc3MgdW5sZXNzIHlvdSBpbmNsdWRlIHNvbWUgZGV0YWlscwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9idHR2L1JFQURNRS5mcmVlemUgYi9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L2J0dHYvUkVBRE1FLmZyZWV6ZQppbmRleCA0MjU5ZGNjLi41ZWRkZmEwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L2J0dHYvUkVBRE1FLmZyZWV6ZQorKysgYi9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L2J0dHYvUkVBRE1FLmZyZWV6ZQpAQCAtMzMsNyArMzMsNyBAQAogCiBJJ3ZlIHNlZW4gcmVwb3J0cyB0aGF0IGJ0dHYgMC43LnggY3Jhc2hlcyB3aGVyZWFzIDAuOC54IHdvcmtzIHJvY2sgc29saWQKIGZvciBzb21lIHBlb3BsZS4gIFRodXMgcHJvYmFibHkgYSBzbWFsbCBidWdsZXQgbGVmdCBzb21ld2hlcmUgaW4gYnR0dgotMC43LnguICBJIGhhdmUgbm8gaWRlYSB3aGVyZSBleGFjdGx5LCBpdCB3b3JrcyBzdGFibGUgZm9yIG1lIGFuZCBhbG90IG9mCiswLjcueC4gIEkgaGF2ZSBubyBpZGVhIHdoZXJlIGV4YWN0bHksIGl0IHdvcmtzIHN0YWJsZSBmb3IgbWUgYW5kIGEgbG90IG9mCiBvdGhlciBwZW9wbGUuICBCdXQgaW4gY2FzZSB5b3UgaGF2ZSBwcm9ibGVtcyB3aXRoIHRoZSAwLjcueCB2ZXJzaW9ucyB5b3UKIGNhbiBnaXZlIDAuOC54IGEgdHJ5IC4uLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L2J0dHYvU291bmQtRkFRIGIvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9idHR2L1NvdW5kLUZBUQppbmRleCBiYzVlNDFkLi4zOTVmNmM2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L2J0dHYvU291bmQtRkFRCisrKyBiL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvYnR0di9Tb3VuZC1GQVEKQEAgLTIsNyArMiw3IEBACiBidHR2IGFuZCBzb3VuZCBtaW5pIGhvd3RvCiA9PT09PT09PT09PT09PT09PT09PT09PT09CiAKLVRoZXJlIGFyZSBhbG90IG9mIGRpZmZlcmVudCBidDg0OC84NDkvODc4Lzg3OSBiYXNlZCBib2FyZHMgYXZhaWxhYmxlLgorVGhlcmUgYXJlIGEgbG90IG9mIGRpZmZlcmVudCBidDg0OC84NDkvODc4Lzg3OSBiYXNlZCBib2FyZHMgYXZhaWxhYmxlLgogTWFraW5nIHZpZGVvIHdvcmsgb2Z0ZW4gaXMgbm90IGEgYmlnIGRlYWwsIGJlY2F1c2UgdGhpcyBpcyBoYW5kbGVkCiBjb21wbGV0ZWx5IGJ5IHRoZSBidDh4eCBjaGlwLCB3aGljaCBpcyBjb21tb24gb24gYWxsIGJvYXJkcy4gIEJ1dAogc291bmQgaXMgaGFuZGxlZCBpbiBzbGlnaHRseSBkaWZmZXJlbnQgd2F5cyBvbiBlYWNoIGJvYXJkLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9weGFfY2FtZXJhLnR4dCBiL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvcHhhX2NhbWVyYS50eHQKaW5kZXggNGY2ZDBjYS4uNTFlZDE1NyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC9weGFfY2FtZXJhLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L3B4YV9jYW1lcmEudHh0CkBAIC04NCwxMiArODQsMTIgQEAKICAgICAgICB0cmFuc2ZlciBpcyBub3Qgc3RhcnRlZC4gT24gIkVuZCBPZiBGcmFtZSIgaW50ZXJydXB0LCB0aGUgaXJxIGhhbmRsZXIKICAgICAgICBzdGFydHMgdGhlIERNQSBjaGFpbi4KICAgICAgLSBjYXB0dXJlIG9mIG9uZSB2aWRlb2J1ZmZlcgotICAgICAgIFRoZSBETUEgY2hhaW4gc3RhcnRzIHRyYW5zZmVyaW5nIGRhdGEgaW50byB2aWRlb2J1ZmZlciBSQU0gcGFnZXMuCi0gICAgICAgV2hlbiBhbGwgcGFnZXMgYXJlIHRyYW5zZmVyZWQsIHRoZSBETUEgaXJxIGlzIHJhaXNlZCBvbiAiRU5ESU5UUiIgc3RhdHVzCisgICAgICAgVGhlIERNQSBjaGFpbiBzdGFydHMgdHJhbnNmZXJyaW5nIGRhdGEgaW50byB2aWRlb2J1ZmZlciBSQU0gcGFnZXMuCisgICAgICAgV2hlbiBhbGwgcGFnZXMgYXJlIHRyYW5zZmVycmVkLCB0aGUgRE1BIGlycSBpcyByYWlzZWQgb24gIkVORElOVFIiIHN0YXR1cwogICAgICAtIGZpbmlzaGluZyBvbmUgdmlkZW9idWZmZXIKICAgICAgICBUaGUgRE1BIGlycSBoYW5kbGVyIG1hcmtzIHRoZSB2aWRlb2J1ZmZlciBhcyAiZG9uZSIsIGFuZCByZW1vdmVzIGl0IGZyb20KICAgICAgICB0aGUgYWN0aXZlIHJ1bm5pbmcgcXVldWUKLSAgICAgICBNZWFud2hpbGUsIHRoZSBuZXh0IHZpZGVvYnVmZmVyIChpZiB0aGVyZSBpcyBvbmUpLCBpcyB0cmFuc2ZlcmVkIGJ5IERNQQorICAgICAgIE1lYW53aGlsZSwgdGhlIG5leHQgdmlkZW9idWZmZXIgKGlmIHRoZXJlIGlzIG9uZSksIGlzIHRyYW5zZmVycmVkIGJ5IERNQQogICAgICAtIGZpbmlzaGluZyB0aGUgbGFzdCB2aWRlb2J1ZmZlcgogICAgICAgIE9uIHRoZSBETUEgaXJxIG9mIHRoZSBsYXN0IHZpZGVvYnVmZmVyLCB0aGUgUUNJIGlzIHN0b3BwZWQuCiAKQEAgLTEwMSw3ICsxMDEsNyBAQAogCiAgICAgIFRoaXMgc3RydWN0dXJlIGlzIHBvaW50ZWQgYnkgZG1hLT5zZ19jcHUuCiAgICAgIFRoZSBkZXNjcmlwdG9ycyBhcmUgdXNlZCBhcyBmb2xsb3dzIDoKLSAgICAgIC0gZGVzYy1zZ1tpXTogaS10aCBkZXNjcmlwdG9yLCB0cmFuc2ZlcmluZyB0aGUgaS10aCBzZworICAgICAgLSBkZXNjLXNnW2ldOiBpLXRoIGRlc2NyaXB0b3IsIHRyYW5zZmVycmluZyB0aGUgaS10aCBzZwogICAgICAgICBlbGVtZW50IHRvIHRoZSB2aWRlbyBidWZmZXIgc2NhdHRlciBnYXRoZXIKICAgICAgIC0gZmluaXNoZXI6IGhhcyBkZGFkcj1EQUREUl9TVE9QLCBkY21kPUVORElSUUVOCiAgICAgICAtIGxpbmtlcjogaGFzIGRkYWRyPSBkZXNjLXNnWzBdIG9mIG5leHQgdmlkZW8gYnVmZmVyLCBkY21kPTAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvdjRsMi1mcmFtZXdvcmsudHh0IGIvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC92NGwyLWZyYW1ld29yay50eHQKaW5kZXggM2IxNTYwOC4uY2YyMWY3YSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC92NGwyLWZyYW1ld29yay50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC92NGwyLWZyYW1ld29yay50eHQKQEAgLTM0Myw3ICszNDMsNyBAQAogCWVyciA9IHY0bDJfZGV2aWNlX2NhbGxfdW50aWxfZXJyKHY0bDJfZGV2LCAwLCBjb3JlLCBnX2NoaXBfaWRlbnQsICZjaGlwKTsKIAogQW55IGVycm9yIGV4Y2VwdCAtRU5PSU9DVExDTUQgd2lsbCBleGl0IHRoZSBsb29wIHdpdGggdGhhdCBlcnJvci4gSWYgbm8KLWVycm9ycyAoZXhjZXB0IC1FTk9JT0NUTENNRCkgb2NjdXJlZCwgdGhlbiAwIGlzIHJldHVybmVkLgorZXJyb3JzIChleGNlcHQgLUVOT0lPQ1RMQ01EKSBvY2N1cnJlZCwgdGhlbiAwIGlzIHJldHVybmVkLgogCiBUaGUgc2Vjb25kIGFyZ3VtZW50IHRvIGJvdGggY2FsbHMgaXMgYSBncm91cCBJRC4gSWYgMCwgdGhlbiBhbGwgc3ViZGV2cyBhcmUKIGNhbGxlZC4gSWYgbm9uLXplcm8sIHRoZW4gb25seSB0aG9zZSB3aG9zZSBncm91cCBJRCBtYXRjaCB0aGF0IHZhbHVlIHdpbGwKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdm0vYWN0aXZlX21tLnR4dCBiL0RvY3VtZW50YXRpb24vdm0vYWN0aXZlX21tLnR4dAppbmRleCA0ZWUxZjY0Li5kYmY0NTgxIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZtL2FjdGl2ZV9tbS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi92bS9hY3RpdmVfbW0udHh0CkBAIC03NCw3ICs3NCw3IEBACiBhbmQgdGhpbmdzIGxpa2UgdGhhdCkuCiAKIEFueXdheSwgSSBwdXQgYSBwcmUtcGF0Y2gtMi4zLjEzLTEgb24gZnRwLmtlcm5lbC5vcmcganVzdCBhIG1vbWVudCBhZ28sCi1iZWNhdXNlIGl0IHNsaWdodGx5IGNoYW5nZXMgdGhlIGludGVyZmFjZXMgdG8gYWNjb21vZGF0ZSB0aGUgYWxwaGEgKHdobworYmVjYXVzZSBpdCBzbGlnaHRseSBjaGFuZ2VzIHRoZSBpbnRlcmZhY2VzIHRvIGFjY29tbW9kYXRlIHRoZSBhbHBoYSAod2hvCiB3b3VsZCBoYXZlIHRob3VnaHQgaXQsIGJ1dCB0aGUgYWxwaGEgYWN0dWFsbHkgZW5kcyB1cCBoYXZpbmcgb25lIG9mIHRoZQogdWdsaWVzdCBjb250ZXh0IHN3aXRjaCBjb2RlcyAtIHVubGlrZSB0aGUgb3RoZXIgYXJjaGl0ZWN0dXJlcyB3aGVyZSB0aGUgTU0KIGFuZCByZWdpc3RlciBzdGF0ZSBpcyBzZXBhcmF0ZSwgdGhlIGFscGhhIFBBTGNvZGUgam9pbnMgdGhlIHR3bywgYW5kIHlvdQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92bS9odWdldGxicGFnZS50eHQgYi9Eb2N1bWVudGF0aW9uL3ZtL2h1Z2V0bGJwYWdlLnR4dAppbmRleCA0NTc2MzRjLi5mODU1MWIzIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZtL2h1Z2V0bGJwYWdlLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3ZtL2h1Z2V0bGJwYWdlLnR4dApAQCAtNzIsNyArNzIsNyBAQAogYWxsb2NhdGluZyBodWdlIHBhZ2VzIGFzIG1lbW9yeSBoYXMgbm90IHlldCBiZWNvbWUgZnJhZ21lbnRlZC4KIAogU29tZSBwbGF0Zm9ybXMgc3VwcG9ydCBtdWx0aXBsZSBodWdlIHBhZ2Ugc2l6ZXMuICBUbyBhbGxvY2F0ZSBodWdlIHBhZ2VzCi1vZiBhIHNwZWNpZmljIHNpemUsIG9uZSBtdXN0IHByZWNlZWQgdGhlIGh1Z2UgcGFnZXMgYm9vdCBjb21tYW5kIHBhcmFtZXRlcnMKK29mIGEgc3BlY2lmaWMgc2l6ZSwgb25lIG11c3QgcHJlY2VkZSB0aGUgaHVnZSBwYWdlcyBib290IGNvbW1hbmQgcGFyYW1ldGVycwogd2l0aCBhIGh1Z2UgcGFnZSBzaXplIHNlbGVjdGlvbiBwYXJhbWV0ZXIgImh1Z2VwYWdlc3o9PHNpemU+Ii4gIDxzaXplPiBtdXN0CiBiZSBzcGVjaWZpZWQgaW4gYnl0ZXMgd2l0aCBvcHRpb25hbCBzY2FsZSBzdWZmaXggW2tLbU1nR10uICBUaGUgZGVmYXVsdCBodWdlCiBwYWdlIHNpemUgbWF5IGJlIHNlbGVjdGVkIHdpdGggdGhlICJkZWZhdWx0X2h1Z2VwYWdlc3o9PHNpemU+IiBib290IHBhcmFtZXRlci4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdm0vb3ZlcmNvbW1pdC1hY2NvdW50aW5nIGIvRG9jdW1lbnRhdGlvbi92bS9vdmVyY29tbWl0LWFjY291bnRpbmcKaW5kZXggMjFjN2IxZi4uNzA2ZDdlZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi92bS9vdmVyY29tbWl0LWFjY291bnRpbmcKKysrIGIvRG9jdW1lbnRhdGlvbi92bS9vdmVyY29tbWl0LWFjY291bnRpbmcKQEAgLTQsNyArNCw3IEBACiAJCWFkZHJlc3Mgc3BhY2UgYXJlIHJlZnVzZWQuIFVzZWQgZm9yIGEgdHlwaWNhbCBzeXN0ZW0uIEl0CiAJCWVuc3VyZXMgYSBzZXJpb3VzbHkgd2lsZCBhbGxvY2F0aW9uIGZhaWxzIHdoaWxlIGFsbG93aW5nCiAJCW92ZXJjb21taXQgdG8gcmVkdWNlIHN3YXAgdXNhZ2UuICByb290IGlzIGFsbG93ZWQgdG8gCi0JCWFsbG9jYXRlIHNsaWdobHkgbW9yZSBtZW1vcnkgaW4gdGhpcyBtb2RlLiBUaGlzIGlzIHRoZSAKKwkJYWxsb2NhdGUgc2xpZ2h0bHkgbW9yZSBtZW1vcnkgaW4gdGhpcyBtb2RlLiBUaGlzIGlzIHRoZSAKIAkJZGVmYXVsdC4KIAogMQktCUFsd2F5cyBvdmVyY29tbWl0LiBBcHByb3ByaWF0ZSBmb3Igc29tZSBzY2llbnRpZmljCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3cxL3NsYXZlcy93MV9kczI0MjMgYi9Eb2N1bWVudGF0aW9uL3cxL3NsYXZlcy93MV9kczI0MjMKaW5kZXggOTBhNjVkMi4uM2Y5OGI1MCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi93MS9zbGF2ZXMvdzFfZHMyNDIzCisrKyBiL0RvY3VtZW50YXRpb24vdzEvc2xhdmVzL3cxX2RzMjQyMwpAQCAtMjEsOCArMjEsOCBAQAogCiBFYWNoIGxpbmVzIHdpbGwgY29udGFpbiB0aGUgdmFsdWVzIG9mIDQyIGJ5dGVzIHJlYWQgZnJvbSB0aGUgY291bnRlciBhbmQKIG1lbW9yeSBwYWdlIGFsb25nIHRoZSBjcmM9WUVTIG9yIE5PIGZvciBpbmRpY2F0aW5nIHdoZXRoZXIgdGhlIHJlYWQgb3BlcmF0aW9uCi13YXMgc3VjY2Vzc2Z1bGwgYW5kIENSQyBtYXRjaGVkLgotSWYgdGhlIG9wZXJhdGlvbiB3YXMgc3VjY2Vzc2Z1bGwsIHRoZXJlIGlzIGFsc28gaW4gdGhlIGVuZCBvZiBlYWNoIGxpbmUKK3dhcyBzdWNjZXNzZnVsIGFuZCBDUkMgbWF0Y2hlZC4KK0lmIHRoZSBvcGVyYXRpb24gd2FzIHN1Y2Nlc3NmdWwsIHRoZXJlIGlzIGFsc28gaW4gdGhlIGVuZCBvZiBlYWNoIGxpbmUKIGEgY291bnRlciB2YWx1ZSBleHByZXNzZWQgYXMgYW4gaW50ZWdlciBhZnRlciBjPQogCiBNZWFuaW5nIG9mIDQyIGJ5dGVzIHJlcHJlc2VudGVkIGlzIGZvbGxvd2luZzoKQEAgLTM0LDcgKzM0LDcgQEAKICAtIGNyYz1ZRVMvTk8gaW5kaWNhdGluZyB3aGV0aGVyIHJlYWQgd2FzIG9rIGFuZCBjcmMgbWF0Y2hlZAogIC0gYz08aW50PiBjdXJyZW50IGNvdW50ZXIgdmFsdWUKIAotZXhhbXBsZSBmcm9tIHRoZSBzdWNjZXNzZnVsbCByZWFkOgorZXhhbXBsZSBmcm9tIHRoZSBzdWNjZXNzZnVsIHJlYWQ6CiAwMCAwMiAwMCAwMCAwMCAwMCAwMCAwMCAwMCA2ZCAzOCAwMCBmZiBmZiAwMCAwMCBmZSBmZiAwMCAwMCBmZiBmZiAwMCAwMCBmZiBmZiAwMCAwMCBmZiBmZiAwMCAwMCBmZiBmZiAwMCAwMCBmZiBmZiAwMCAwMCBmZiBmZiBjcmM9WUVTIGM9MgogMDAgMDIgMDAgMDAgMDAgMDAgMDAgMDAgMDAgZTAgMWYgMDAgZmYgZmYgMDAgMDAgZmYgZmYgMDAgMDAgZmYgZmYgMDAgMDAgZmYgZmYgMDAgMDAgZmYgZmYgMDAgMDAgZmYgZmYgMDAgMDAgZmYgZmYgMDAgMDAgZmYgZmYgY3JjPVlFUyBjPTIKIDAwIDI5IGM2IDVkIDE4IDAwIDAwIDAwIDAwIDA0IDM3IDAwIGZmIGZmIDAwIDAwIGZmIGZmIDAwIDAwIGZmIGZmIDAwIDAwIGZmIGZmIDAwIDAwIGZmIGZmIDAwIDAwIGZmIGZmIDAwIDAwIGZmIGZmIDAwIDAwIGZmIGZmIGNyYz1ZRVMgYz00MDg3OTg3NjEKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdzEvdzEubmV0bGluayBiL0RvY3VtZW50YXRpb24vdzEvdzEubmV0bGluawppbmRleCA4MDQ0NDVmLi5mNTlhMzE5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3cxL3cxLm5ldGxpbmsKKysrIGIvRG9jdW1lbnRhdGlvbi93MS93MS5uZXRsaW5rCkBAIC04MSw3ICs4MSw3IEBACiBmb3JtYXQ6CiAKIAljbl9tc2cgKENOX1cxX0lEWC5DTl9XMV9WQUwgYXMgaWQsIGxlbiBpcyBlcXVhbCB0byBzaXplb2Yoc3RydWN0Ci0JdzFfbmV0bGlua19tc2cpIHBsdXMgbnVtYmVyIG9mIG1hc3RlcnMgbXVsdGlwbGVkIGJ5IDQpCisJdzFfbmV0bGlua19tc2cpIHBsdXMgbnVtYmVyIG9mIG1hc3RlcnMgbXVsdGlwbGllZCBieSA0KQogCXcxX25ldGxpbmtfbXNnICh0eXBlOiBXMV9MSVNUX01BU1RFUlMsIGxlbiBpcyBlcXVhbCB0bwogCQludW1iZXIgb2YgbWFzdGVycyBtdWx0aXBsaWVkIGJ5IDQgKHUzMiBzaXplKSkKIAlpZDAgLi4uIGlkTgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi93YXRjaGRvZy9ocHdkdC50eHQgYi9Eb2N1bWVudGF0aW9uL3dhdGNoZG9nL2hwd2R0LnR4dAppbmRleCA5YzI0ZDVmLi45NDg4MDc4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3dhdGNoZG9nL2hwd2R0LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3dhdGNoZG9nL2hwd2R0LnR4dApAQCAtOCw3ICs4LDcgQEAKICBUaGUgSFAgaUxPMiBOTUkgV2F0Y2hkb2cgZHJpdmVyIGlzIGEga2VybmVsIG1vZHVsZSB0aGF0IHByb3ZpZGVzIGJhc2ljCiAgd2F0Y2hkb2cgZnVuY3Rpb25hbGl0eSBhbmQgdGhlIGFkZGVkIGJlbmVmaXQgb2YgTk1JIHNvdXJjaW5nLiBCb3RoIHRoZQogIHdhdGNoZG9nIGZ1bmN0aW9uYWxpdHkgYW5kIHRoZSBOTUkgc291cmNpbmcgY2FwYWJpbGl0eSBuZWVkIHRvIGJlIGVuYWJsZWQKLSBieSB0aGUgdXNlci4gUmVtZW1iZXIgdGhhdCB0aGUgdHdvIG1vZGVzIGFyZSBub3QgZGVwZW5kYW50IG9uIG9uZSBhbm90aGVyLgorIGJ5IHRoZSB1c2VyLiBSZW1lbWJlciB0aGF0IHRoZSB0d28gbW9kZXMgYXJlIG5vdCBkZXBlbmRlbnQgb24gb25lIGFub3RoZXIuCiAgQSB1c2VyIGNhbiBoYXZlIHRoZSBOTUkgc291cmNpbmcgd2l0aG91dCB0aGUgd2F0Y2hkb2cgdGltZXIgYW5kIHZpY2UtdmVyc2EuCiAKICBXYXRjaGRvZyBmdW5jdGlvbmFsaXR5IGlzIGVuYWJsZWQgbGlrZSBhbnkgb3RoZXIgY29tbW9uIHdhdGNoZG9nIGRyaXZlci4gVGhhdApkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCA2YjRiOWNkLi42NDk2MDBjIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtNjkxNiw2ICs2OTE2LDEzIEBACiBTOglNYWludGFpbmVkCiBGOglkcml2ZXJzL3BsYXRmb3JtL3g4NgogCitYRU4gTkVUV09SSyBCQUNLRU5EIERSSVZFUgorTToJSWFuIENhbXBiZWxsIDxpYW4uY2FtcGJlbGxAY2l0cml4LmNvbT4KK0w6CXhlbi1kZXZlbEBsaXN0cy54ZW5zb3VyY2UuY29tIChtb2RlcmF0ZWQgZm9yIG5vbi1zdWJzY3JpYmVycykKK0w6CW5ldGRldkB2Z2VyLmtlcm5lbC5vcmcKK1M6CVN1cHBvcnRlZAorRjoJZHJpdmVycy9uZXQveGVuLW5ldGJhY2svKgorCiBYRU4gUENJIFNVQlNZU1RFTQogTToJS29ucmFkIFJ6ZXN6dXRlayBXaWxrIDxrb25yYWQud2lsa0BvcmFjbGUuY29tPgogTDoJeGVuLWRldmVsQGxpc3RzLnhlbnNvdXJjZS5jb20gKG1vZGVyYXRlZCBmb3Igbm9uLXN1YnNjcmliZXJzKQpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9lbGYuaCBiL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vZWxmLmgKaW5kZXggOWJhYWU4YS4uZGE1NDQ5ZSAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9lbGYuaAorKysgYi9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL2VsZi5oCkBAIC0xMDEsNyArMTAxLDcgQEAKIAogI2RlZmluZSBFTEZfUExBVF9JTklUKF9yLCBsb2FkX2FkZHIpCV9yLT5yMCA9IDAKIAotLyogVGhlIHJlZ2lzdGVycyBhcmUgbGF5ZWQgb3V0IGluIHB0X3JlZ3MgZm9yIFBBTCBhbmQgc3lzY2FsbAorLyogVGhlIHJlZ2lzdGVycyBhcmUgbGFpZCBvdXQgaW4gcHRfcmVncyBmb3IgUEFMIGFuZCBzeXNjYWxsCiAgICBjb252ZW5pZW5jZS4gIFJlLW9yZGVyIHRoZW0gZm9yIHRoZSBsaW5lYXIgZWxmX2dyZWdzZXRfdC4gICovCiAKIHN0cnVjdCBwdF9yZWdzOwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvY29yZV9sY2EuYyBiL2FyY2gvYWxwaGEva2VybmVsL2NvcmVfbGNhLmMKaW5kZXggNDg0M2Y2ZS4uY2IyODAxYyAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvY29yZV9sY2EuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9jb3JlX2xjYS5jCkBAIC0xMzMsNyArMTMzLDcgQEAKIAogCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAotCS8qIFJlc2V0IHN0YXR1cyByZWdpc3RlciB0byBhdm9pZCBsb29zaW5nIGVycm9ycy4gICovCisJLyogUmVzZXQgc3RhdHVzIHJlZ2lzdGVyIHRvIGF2b2lkIGxvc2luZyBlcnJvcnMuICAqLwogCXN0YXQwID0gKih2dWxwKUxDQV9JT0NfU1RBVDA7CiAJKih2dWxwKUxDQV9JT0NfU1RBVDAgPSBzdGF0MDsKIAltYigpOwpAQCAtMTcwLDcgKzE3MCw3IEBACiAKIAlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CS8qIGF2b2lkIGdldHRpbmcgaGl0IGJ5IG1hY2hpbmUgY2hlY2sgKi8KIAotCS8qIFJlc2V0IHN0YXR1cyByZWdpc3RlciB0byBhdm9pZCBsb29zaW5nIGVycm9ycy4gICovCisJLyogUmVzZXQgc3RhdHVzIHJlZ2lzdGVyIHRvIGF2b2lkIGxvc2luZyBlcnJvcnMuICAqLwogCXN0YXQwID0gKih2dWxwKUxDQV9JT0NfU1RBVDA7CiAJKih2dWxwKUxDQV9JT0NfU1RBVDAgPSBzdGF0MDsKIAltYigpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvZXJyX21hcnZlbC5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvZXJyX21hcnZlbC5jCmluZGV4IDY0OGFlODguLmFlNTRhZDkgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL2Vycl9tYXJ2ZWwuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9lcnJfbWFydmVsLmMKQEAgLTEwMjcsNyArMTAyNyw3IEBACiAJICogbm9ybWFsIG9wZXJhdGlvbiwgZGlzbWlzcyB0aGVtLgogCSAqCiAJICogRGlzbWlzcyBpZjoKLQkgKglDX1NUQVQJCT0gMHgxNCAJCShFcnJvciBSZXBvbnNlKQorCSAqCUNfU1RBVAkJPSAweDE0IAkJKEVycm9yIFJlc3BvbnNlKQogCSAqCUNfU1RTPDM+CT0gMCAgICAJCShDX0FERFIgdmFsaWQpCiAJICoJQ19BRERSPDQyPgk9IDEgICAgCQkoSS9PKQogCSAqCUNfQUREUjwzMToyMj4JPSAxMTExMTB4eGIJKFBDSSBDb25maWcgc3BhY2UpCmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2xpYi9ldjY3LXN0cnJjaHIuUyBiL2FyY2gvYWxwaGEvbGliL2V2Njctc3RycmNoci5TCmluZGV4IDNmZDhiZjQuLmRkMGQ4YzYgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEvbGliL2V2Njctc3RycmNoci5TCisrKyBiL2FyY2gvYWxwaGEvbGliL2V2Njctc3RycmNoci5TCkBAIC04Miw3ICs4Miw3IEBACiAkZW9zOgogCW5lZ3EJdDEsIHQ0CQkjIEUgOiBpc29sYXRlIGZpcnN0IG51bGwgYnl0ZSBtYXRjaAogCWFuZAl0MSwgdDQsIHQ0CSMgRSA6Ci0Jc3VicQl0NCwgMSwgdDUJIyBFIDogYnVpbGQgYSBtYXNrIG9mIHRoZSBieXRlcyB1cHRvLi4uCisJc3VicQl0NCwgMSwgdDUJIyBFIDogYnVpbGQgYSBtYXNrIG9mIHRoZSBieXRlcyB1cCB0by4uLgogCW9yCXQ0LCB0NSwgdDQJIyBFIDogLi4uIGFuZCBpbmNsdWRpbmcgdGhlIG51bGwKIAogCWFuZAl0MywgdDQsIHQzCSMgRSA6IG1hc2sgb3V0IGNoYXIgbWF0Y2hlcyBhZnRlciBudWxsCmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2xpYi9mbHMuYyBiL2FyY2gvYWxwaGEvbGliL2Zscy5jCmluZGV4IDMyYWZhYTMuLmRkZDA0OGMgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEvbGliL2Zscy5jCisrKyBiL2FyY2gvYWxwaGEvbGliL2Zscy5jCkBAIC02LDcgKzYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgogCiAvKiBUaGlzIGlzIGZscyh4KS0xLCBleGNlcHQgemVybyBpcyBoZWxkIHRvIHplcm8uICBUaGlzIGFsbG93cyBtb3N0Ci0gICBlZmZpY2VudCBpbnB1dCBpbnRvIGV4dGJsLCBwbHVzIGl0IGFsbG93cyBlYXN5IGhhbmRsaW5nIG9mIGZscygwKT0wLiAgKi8KKyAgIGVmZmljaWVudCBpbnB1dCBpbnRvIGV4dGJsLCBwbHVzIGl0IGFsbG93cyBlYXN5IGhhbmRsaW5nIG9mIGZscygwKT0wLiAgKi8KIAogY29uc3QgdW5zaWduZWQgY2hhciBfX2Zsc20xX3RhYlsyNTZdID0gCiB7CmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2xpYi9zdHJyY2hyLlMgYi9hcmNoL2FscGhhL2xpYi9zdHJyY2hyLlMKaW5kZXggODJjZmQwYS4uMTk3MGRjMCAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9saWIvc3RycmNoci5TCisrKyBiL2FyY2gvYWxwaGEvbGliL3N0cnJjaHIuUwpAQCAtNTQsNyArNTQsNyBAQAogJGVvczoKIAluZWdxCXQxLCB0NAkJIyBlMCAgICA6IGlzb2xhdGUgZmlyc3QgbnVsbCBieXRlIG1hdGNoCiAJYW5kCXQxLCB0NCwgdDQJIyBlMSAgICA6Ci0Jc3VicQl0NCwgMSwgdDUJIyBlMCAgICA6IGJ1aWxkIGEgbWFzayBvZiB0aGUgYnl0ZXMgdXB0by4uLgorCXN1YnEJdDQsIDEsIHQ1CSMgZTAgICAgOiBidWlsZCBhIG1hc2sgb2YgdGhlIGJ5dGVzIHVwIHRvLi4uCiAJb3IJdDQsIHQ1LCB0NAkjIGUxICAgIDogLi4uIGFuZCBpbmNsdWRpbmcgdGhlIG51bGwKIAogCWFuZAl0MywgdDQsIHQzCSMgZTAgICAgOiBtYXNrIG91dCBjaGFyIG1hdGNoZXMgYWZ0ZXIgbnVsbApkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9vcHJvZmlsZS9vcF9tb2RlbF9ldjY3LmMgYi9hcmNoL2FscGhhL29wcm9maWxlL29wX21vZGVsX2V2NjcuYwppbmRleCA3MDMwMjA4Li41YjlkMTc4IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL29wcm9maWxlL29wX21vZGVsX2V2NjcuYworKysgYi9hcmNoL2FscGhhL29wcm9maWxlL29wX21vZGVsX2V2NjcuYwpAQCAtMTkyLDcgKzE5Miw3IEBACiAJCWNhc2UgVFJBUF9JTlZBTElEMToKIAkJY2FzZSBUUkFQX0lOVkFMSUQyOgogCQljYXNlIFRSQVBfSU5WQUxJRDM6Ci0JCQkvKiBQaXBlbGluZSByZWRpcmVjdGlvbiBvY3VycmVkLiBQTVBDIHBvaW50cworCQkJLyogUGlwZWxpbmUgcmVkaXJlY3Rpb24gb2NjdXJyZWQuIFBNUEMgcG9pbnRzCiAJCQkgICB0byBQQUxjb2RlLiBSZWNvZ25pemUgSVRCIG1pc3MgYnkgUEFMY29kZQogCQkJICAgb2Zmc2V0IGFkZHJlc3MsIGFuZCBnZXQgYWN0dWFsIFBDIGZyb20KIAkJCSAgIEVYQ19BRERSLiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL0tjb25maWcgYi9hcmNoL2FybS9LY29uZmlnCmluZGV4IDViOWY3OGIuLmZkYzlkNGQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL0tjb25maWcKKysrIGIvYXJjaC9hcm0vS2NvbmZpZwpAQCAtNjk0LDcgKzY5NCw3IEBACiAJICB0aGUgU2Ftc3VuZyBTTURLMjQxMCBkZXZlbG9wbWVudCBib2FyZCAoYW5kIGRlcml2YXRpdmVzKS4KIAogCSAgTm90ZSwgdGhlIFMzQzI0MTYgYW5kIHRoZSBTM0MyNDUwIGFyZSBzbyBjbG9zZSB0aGF0IHRoZXkgZXZlbiBzaGFyZQotCSAgdGhlIHNhbWUgU29DIElEIGNvZGUuIFRoaXMgbWVhbnMgdGhhdCB0aGVyZSBpcyBubyBzZXBlcmF0ZSBtYWNoaW5lCisJICB0aGUgc2FtZSBTb0MgSUQgY29kZS4gVGhpcyBtZWFucyB0aGF0IHRoZXJlIGlzIG5vIHNlcGFyYXRlIG1hY2hpbmUKIAkgIGRpcmVjdG9yeSAobm8gYXJjaC9hcm0vbWFjaC1zM2MyNDUwKSBhcyB0aGUgUzNDMjQxNiB3YXMgZmlyc3QuCiAKIGNvbmZpZyBBUkNIX1MzQzY0WFgKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL0tjb25maWctbm9tbXUgYi9hcmNoL2FybS9LY29uZmlnLW5vbW11CmluZGV4IDkwMWU2ZGYuLjJjZWY4ZTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL0tjb25maWctbm9tbXUKKysrIGIvYXJjaC9hcm0vS2NvbmZpZy1ub21tdQpAQCAtMzQsNyArMzQsNyBAQAogCSAgdXNlZCBpbnN0ZWFkIG9mIHRoZSBhdXRvLXByb2Jpbmcgd2hpY2ggdXRpbGl6ZXMgdGhlIHJlZ2lzdGVyLgogCiBjb25maWcgUkVNQVBfVkVDVE9SU19UT19SQU0KLQlib29sICdJbnN0YWxsIHZlY3RvcnMgdG8gdGhlIGJlZ2luaW5nIG9mIFJBTScgaWYgRFJBTV9CQVNFCisJYm9vbCAnSW5zdGFsbCB2ZWN0b3JzIHRvIHRoZSBiZWdpbm5pbmcgb2YgUkFNJyBpZiBEUkFNX0JBU0UKIAlkZXBlbmRzIG9uIERSQU1fQkFTRQogCWhlbHAKIAkgIFRoZSBrZXJuZWwgbmVlZHMgdG8gY2hhbmdlIHRoZSBoYXJkd2FyZSBleGNlcHRpb24gdmVjdG9ycy4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbW1vbi9wbDMzMC5jIGIvYXJjaC9hcm0vY29tbW9uL3BsMzMwLmMKaW5kZXggOGYwZjg2ZC4uOTc5MTJmYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29tbW9uL3BsMzMwLmMKKysrIGIvYXJjaC9hcm0vY29tbW9uL3BsMzMwLmMKQEAgLTEwNDUsNyArMTA0NSw3IEBACiAJdW5zaWduZWQgbGNudDAsIGxjbnQxLCBsam1wMCwgbGptcDE7CiAJc3RydWN0IF9hcmdfTFBFTkQgbHBlbmQ7CiAKLQkvKiBNYXggaXRlcmF0aW9ucyBwb3NzaWJpbGUgaW4gRE1BTFAgaXMgMjU2ICovCisJLyogTWF4IGl0ZXJhdGlvbnMgcG9zc2libGUgaW4gRE1BTFAgaXMgMjU2ICovCiAJaWYgKCpidXJzdHMgPj0gMjU2KjI1NikgewogCQlsY250MSA9IDI1NjsKIAkJbGNudDAgPSAyNTY7CkBAIC0xNDQ2LDcgKzE0NDYsNyBAQAogCX0KIAogCWZvciAoZXYgPSAwOyBldiA8IHBpLT5wY2ZnLm51bV9ldmVudHM7IGV2KyspIHsKLQkJaWYgKHZhbCAmICgxIDw8IGV2KSkgeyAvKiBFdmVudCBvY2N1cmVkICovCisJCWlmICh2YWwgJiAoMSA8PCBldikpIHsgLyogRXZlbnQgb2NjdXJyZWQgKi8KIAkJCXN0cnVjdCBwbDMzMF90aHJlYWQgKnRocmQ7CiAJCQl1MzIgaW50ZW4gPSByZWFkbChyZWdzICsgSU5URU4pOwogCQkJaW50IGFjdGl2ZTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2Zwc3RhdGUuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2Zwc3RhdGUuaAppbmRleCBlZTVlMDNlLi4zYWQ0YzEwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9mcHN0YXRlLmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vZnBzdGF0ZS5oCkBAIC0xOCw3ICsxOCw3IEBACiAgKiBWRlAgc3RvcmFnZSBhcmVhIGhhczoKICAqICAtIEZQRVhDLCBGUFNDUiwgRlBJTlNUIGFuZCBGUElOU1QyLgogICogIC0gMTYgb3IgMzIgZG91YmxlIHByZWNpc2lvbiBkYXRhIHJlZ2lzdGVycwotICogIC0gYW4gaW1wbGVtZW50YXRpb24tZGVwZW5kYW50IHdvcmQgb2Ygc3RhdGUgZm9yIEZMRE1YL0ZTVE1YIChwcmUtQVJNdjYpCisgKiAgLSBhbiBpbXBsZW1lbnRhdGlvbi1kZXBlbmRlbnQgd29yZCBvZiBzdGF0ZSBmb3IgRkxETVgvRlNUTVggKHByZS1BUk12NikKICAqIAogICogIEZQRVhDIHdpbGwgYWx3YXlzIGJlIG5vbi16ZXJvIG9uY2UgdGhlIFZGUCBoYXMgYmVlbiB1c2VkIGluIHRoaXMgcHJvY2Vzcy4KICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vZ2x1ZS1jYWNoZS5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vZ2x1ZS1jYWNoZS5oCmluZGV4IGM3YWZiYzUuLjdlMzA4NzQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2dsdWUtY2FjaGUuaAorKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9nbHVlLWNhY2hlLmgKQEAgLTEyNiw3ICsxMjYsNyBAQAogI2VuZGlmCiAKICNpZiAhZGVmaW5lZChfQ0FDSEUpICYmICFkZWZpbmVkKE1VTFRJX0NBQ0hFKQotI2Vycm9yIFVua25vd24gY2FjaGUgbWFpbnRhaW5lbmNlIG1vZGVsCisjZXJyb3IgVW5rbm93biBjYWNoZSBtYWludGVuYW5jZSBtb2RlbAogI2VuZGlmCiAKICNpZm5kZWYgTVVMVElfQ0FDSEUKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2dsdWUuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2dsdWUuaAppbmRleCAwZWMzNWQxLi5mYmY3MWQ3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9nbHVlLmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vZ2x1ZS5oCkBAIC0xMCw4ICsxMCw4IEBACiAgKgogICogIFRoaXMgZmlsZSBwcm92aWRlcyB0aGUgZ2x1ZSB0byBzdGljayB0aGUgcHJvY2Vzc29yLXNwZWNpZmljIGJpdHMKICAqICBpbnRvIHRoZSBrZXJuZWwgaW4gYW4gZWZmaWNpZW50IG1hbm5lci4gIFRoZSBpZGVhIGlzIHRvIHVzZSBicmFuY2hlcwotICogIHdoZW4gd2UncmUgb25seSB0YXJnZXR0aW5nIG9uZSBjbGFzcyBvZiBUTEIsIG9yIGluZGlyZWN0IGNhbGxzCi0gKiAgd2hlbiB3ZSdyZSB0YXJnZXR0aW5nIG11bHRpcGxlIGNsYXNzZXMgb2YgVExCcy4KKyAqICB3aGVuIHdlJ3JlIG9ubHkgdGFyZ2V0aW5nIG9uZSBjbGFzcyBvZiBUTEIsIG9yIGluZGlyZWN0IGNhbGxzCisgKiAgd2hlbiB3ZSdyZSB0YXJnZXRpbmcgbXVsdGlwbGUgY2xhc3NlcyBvZiBUTEJzLgogICovCiAjaWZkZWYgX19LRVJORUxfXwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9oYXJkd2FyZS9wbDA4MC5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vaGFyZHdhcmUvcGwwODAuaAppbmRleCBmMzViODZlLi5lNGEwNGU0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9oYXJkd2FyZS9wbDA4MC5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2hhcmR3YXJlL3BsMDgwLmgKQEAgLTE2LDcgKzE2LDcgQEAKICAqIG1ha2UgaXQgbm90IGVudGllcmx5IGNvbXBhdGlibGUgd2l0aCB0aGUgUEwwODAgc3BlY2lmaWNhdGlvbiBmcm9tCiAgKiBBUk0uIFdoZW4gaW4gZG91YnQsIGNoZWNrIHRoZSBTYW1zdW5nIGRvY3VtZW50YXRpb24gZmlyc3QuCiAgKgotICogVGhlIFNhbXN1bmcgZGVmaW5lcyBhcmUgUEwwODBTLCBhbmQgYWRkIGFuIGV4dHJhIGNvbnRyb2xsIHJlZ2lzdGVyLAorICogVGhlIFNhbXN1bmcgZGVmaW5lcyBhcmUgUEwwODBTLCBhbmQgYWRkIGFuIGV4dHJhIGNvbnRyb2wgcmVnaXN0ZXIsCiAgKiB0aGUgYWJpbGl0eSB0byBtb3ZlIG1vcmUgdGhhbiAyXjExIGNvdW50cyBvZiBkYXRhIGFuZCBzb21lIGV4dHJhCiAgKiBPbmVOQU5EIGZlYXR1cmVzLgogKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3N5c3RlbS5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vc3lzdGVtLmgKaW5kZXggOWE4NzgyMy4uODg1YmUwOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vc3lzdGVtLmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vc3lzdGVtLmgKQEAgLTI0OSw3ICsyNDksNyBAQAogICogY2FjaGUgdG90YWxseS4gIFRoaXMgbWVhbnMgdGhhdCB0aGUgY2FjaGUgYmVjb21lcyBpbmNvbnNpc3RlbnQsIGFuZCwKICAqIHNpbmNlIHdlIHVzZSBub3JtYWwgbG9hZHMvc3RvcmVzIGFzIHdlbGwsIHRoaXMgaXMgcmVhbGx5IGJhZC4KICAqIFR5cGljYWxseSwgdGhpcyBjYXVzZXMgb29wc2VuIGluIGZpbHBfY2xvc2UsIGJ1dCBjb3VsZCBoYXZlIG90aGVyLAotICogbW9yZSBkaXNhc3Rlcm91cyBlZmZlY3RzLiAgVGhlcmUgYXJlIHR3byB3b3JrLWFyb3VuZHM6CisgKiBtb3JlIGRpc2FzdHJvdXMgZWZmZWN0cy4gIFRoZXJlIGFyZSB0d28gd29yay1hcm91bmRzOgogICogIDEuIERpc2FibGUgaW50ZXJydXB0cyBhbmQgZW11bGF0ZSB0aGUgYXRvbWljIHN3YXAKICAqICAyLiBDbGVhbiB0aGUgY2FjaGUsIHBlcmZvcm0gYXRvbWljIHN3YXAsIGZsdXNoIHRoZSBjYWNoZQogICoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3Vjb250ZXh0LmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS91Y29udGV4dC5oCmluZGV4IDQ3ZjAyM2EuLjE0NzQ5YWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3Vjb250ZXh0LmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vdWNvbnRleHQuaApAQCAtNDcsNyArNDcsNyBAQAogI2VuZGlmCiAKICNpZmRlZiBDT05GSUdfSVdNTVhUCi0vKiBpd21teHRfYXJlYSBpcyAweDk4IGJ5dGVzIGxvbmcsIHByZWNlZWRlZCBieSA4IGJ5dGVzIG9mIHNpZ25hdHVyZSAqLworLyogaXdtbXh0X2FyZWEgaXMgMHg5OCBieXRlcyBsb25nLCBwcmVjZWRlZCBieSA4IGJ5dGVzIG9mIHNpZ25hdHVyZSAqLwogI2RlZmluZSBJV01NWFRfTUFHSUMJCTB4MTJlZjg0MmEKICNkZWZpbmUgSVdNTVhUX1NUT1JBR0VfU0laRQkoSVdNTVhUX1NJWkUgKyA4KQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvc3dwX2VtdWxhdGUuYyBiL2FyY2gvYXJtL2tlcm5lbC9zd3BfZW11bGF0ZS5jCmluZGV4IDdhNTc2MDkuLjQwZWU3ZTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9zd3BfZW11bGF0ZS5jCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9zd3BfZW11bGF0ZS5jCkBAIC0xNTgsNyArMTU4LDcgQEAKIAogCWlmIChyZXMgPT0gMCkgewogCQkvKgotCQkgKiBCYXJyaWVyIGFsc28gcmVxdWlyZWQgYmV0d2VlbiBhcXVpcmluZyBhIGxvY2sgZm9yIGEKKwkJICogQmFycmllciBhbHNvIHJlcXVpcmVkIGJldHdlZW4gYWNxdWlyaW5nIGEgbG9jayBmb3IgYQogCQkgKiBwcm90ZWN0ZWQgcmVzb3VyY2UgYW5kIGFjY2Vzc2luZyB0aGUgcmVzb3VyY2UuIEluc2VydGVkIGZvcgogCQkgKiBzYW1lIHJlYXNvbiBhcyBhYm92ZS4KIAkJICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWF0OTEvYm9hcmQtY2FybWV2YS5jIGIvYXJjaC9hcm0vbWFjaC1hdDkxL2JvYXJkLWNhcm1ldmEuYwppbmRleCAyZTc0YTE5Li4yOTVlMWU3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWF0OTEvYm9hcmQtY2FybWV2YS5jCisrKyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9ib2FyZC1jYXJtZXZhLmMKQEAgLTc2LDcgKzc2LDcgQEAKIAkucHVsbHVwX3Bpbgk9IEFUOTFfUElOX1BEOSwKIH07CiAKLS8qIEZJWE1FOiB1c2VyIGRlcGVuZGFudCAqLworLyogRklYTUU6IHVzZXIgZGVwZW5kZW50ICovCiAvLyBzdGF0aWMgc3RydWN0IGF0OTFfY2ZfZGF0YSBfX2luaXRkYXRhIGNhcm1ldmFfY2ZfZGF0YSA9IHsKIC8vCS5kZXRfcGluCT0gQVQ5MV9QSU5fUEIwLAogLy8JLnJzdF9waW4JPSBBVDkxX1BJTl9QQzUsCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWF0OTEvaW5jbHVkZS9tYWNoL2F0OTFfbWNpLmggYi9hcmNoL2FybS9tYWNoLWF0OTEvaW5jbHVkZS9tYWNoL2F0OTFfbWNpLmgKaW5kZXggMjdhYzZmNS4uMDIxODJjMSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1hdDkxL2luY2x1ZGUvbWFjaC9hdDkxX21jaS5oCisrKyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9pbmNsdWRlL21hY2gvYXQ5MV9tY2kuaApAQCAtMTAyLDcgKzEwMiw3IEBACiAjZGVmaW5lCQlBVDkxX01DSV9SRElSRQkJKDEgPDwgMTcpCS8qIFJlc3BvbnNlIERpcmVjdGlvbiBFcnJvciAqLwogI2RlZmluZQkJQVQ5MV9NQ0lfUkNSQ0UJCSgxIDw8IDE4KQkvKiBSZXNwb25zZSBDUkMgRXJyb3IgKi8KICNkZWZpbmUJCUFUOTFfTUNJX1JFTkRFCQkoMSA8PCAxOSkJLyogUmVzcG9uc2UgRW5kIEJpdCBFcnJvciAqLwotI2RlZmluZQkJQVQ5MV9NQ0lfUlRPRQkJKDEgPDwgMjApCS8qIFJlcG9uc2UgVGltZS1vdXQgRXJyb3IgKi8KKyNkZWZpbmUJCUFUOTFfTUNJX1JUT0UJCSgxIDw8IDIwKQkvKiBSZXNwb25zZSBUaW1lLW91dCBFcnJvciAqLwogI2RlZmluZQkJQVQ5MV9NQ0lfRENSQ0UJCSgxIDw8IDIxKQkvKiBEYXRhIENSQyBFcnJvciAqLwogI2RlZmluZQkJQVQ5MV9NQ0lfRFRPRQkJKDEgPDwgMjIpCS8qIERhdGEgVGltZS1vdXQgRXJyb3IgKi8KICNkZWZpbmUJCUFUOTFfTUNJX09WUkUJCSgxIDw8IDMwKQkvKiBPdmVycnVuICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWF0OTEvaW5jbHVkZS9tYWNoL2dwaW8uaCBiL2FyY2gvYXJtL21hY2gtYXQ5MS9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IGRkZWI2NDUuLjA1NmRjNjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtYXQ5MS9pbmNsdWRlL21hY2gvZ3Bpby5oCisrKyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9pbmNsdWRlL21hY2gvZ3Bpby5oCkBAIC0yMDgsNyArMjA4LDcgQEAKIAogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KIAotLyogd3JhcHBlcnMgZm9yICJuZXcgc3R5bGUiIEdQSU8gY2FsbHMuIHRoZSBvbGQgQVQ5MS1zcGVjZmljIG9uZXMgc2hvdWxkCisvKiB3cmFwcGVycyBmb3IgIm5ldyBzdHlsZSIgR1BJTyBjYWxscy4gdGhlIG9sZCBBVDkxLXNwZWNpZmljIG9uZXMgc2hvdWxkCiAgKiBldmVudHVhbGx5IGJlIHJlbW92ZWQgKGFsb25nIHdpdGggdGhpcyBlcnJuby5oIGluY2x1c2lvbiksIGFuZCB0aGUKICAqIGdwaW8gcmVxdWVzdC9mcmVlIGNhbGxzIHNob3VsZCBwcm9iYWJseSBiZSBpbXBsZW1lbnRlZC4KICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2NzcC9kbWFjL2RtYWNId19leHRyYS5jIGIvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2NzcC9kbWFjL2RtYWNId19leHRyYS5jCmluZGV4IDc3Zjg0YjQuLmExZjMyODMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9jc3AvZG1hYy9kbWFjSHdfZXh0cmEuYworKysgYi9hcmNoL2FybS9tYWNoLWJjbXJpbmcvY3NwL2RtYWMvZG1hY0h3X2V4dHJhLmMKQEAgLTU1MSw3ICs1NTEsNyBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qKgotKiAgQGJyaWVmICAgQ2hlY2sgdGhlIGV4aXN0YW5jZSBvZiBwZW5kaW5nIGRlc2NyaXB0b3IKKyogIEBicmllZiAgIENoZWNrIHRoZSBleGlzdGVuY2Ugb2YgcGVuZGluZyBkZXNjcmlwdG9yCiAqCiAqICBUaGlzIGZ1bmN0aW9uIGNvbmZpcm1lcyBpZiB0aGVyZSBpcyBhbnkgcGVuZGluZyBkZXNjcmlwdG9yIGluIHRoZSBjaGFpbgogKiAgdG8gcHJvZ3JhbSB0aGUgY2hhbm5lbApAQCAtNzc1LDcgKzc3NSw3IEBACiAvKioKICogIEBicmllZiAgIFJlYWQgZGF0YSBETUFlZCB0byBtZW1vcnkKICoKLSogIFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIGRhdGEgdGhhdCBoYXMgYmVlbiBETUFlZCB0byBtZW1vcnkgd2hpbGUgdHJhbnNmZXJpbmcgZnJvbToKKyogIFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIGRhdGEgdGhhdCBoYXMgYmVlbiBETUFlZCB0byBtZW1vcnkgd2hpbGUgdHJhbnNmZXJyaW5nIGZyb206CiAqICAgICAgICAgIC0gTWVtb3J5IHRvIG1lbW9yeQogKiAgICAgICAgICAtIFBlcmlwaGVyYWwgdG8gbWVtb3J5CiAqCkBAIC05NDEsNyArOTQxLDcgQEAKIC8qKgogKiAgQGJyaWVmICAgU2V0cyBjaGFubmVsIHNwZWNpZmljIHVzZXIgZGF0YQogKgotKiAgVGhpcyBmdW5jdGlvbiBhc3NvY2lhdGVzIHVzZXIgZGF0YSB0byBhIHNwZWNpZiBETUEgY2hhbm5lbAorKiAgVGhpcyBmdW5jdGlvbiBhc3NvY2lhdGVzIHVzZXIgZGF0YSB0byBhIHNwZWNpZmljIERNQSBjaGFubmVsCiAqCiAqLwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvZG1hLmMgYi9hcmNoL2FybS9tYWNoLWJjbXJpbmcvZG1hLmMKaW5kZXggOGQxYmFmMy4uZDg3YWQzMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2RtYS5jCisrKyBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9kbWEuYwpAQCAtNjI5LDcgKzYyOSw3IEBACiAqICAgQ29uZmlndXJlcyBhIERNQSBjaGFubmVsLgogKgogKiAgIEByZXR1cm4KLSogICAgICAgPj0gMCAgICAtIEluaXRpYWxpemF0aW9uIHdhcyBzdWNjZXNzZnVsbC4KKyogICAgICAgPj0gMCAgICAtIEluaXRpYWxpemF0aW9uIHdhcyBzdWNjZXNzZnVsLgogKgogKiAgICAgICAtRUJVU1kgIC0gRGV2aWNlIGlzIGN1cnJlbnRseSBiZWluZyB1c2VkLgogKiAgICAgICAtRU5PREVWIC0gRGV2aWNlIGhhbmRlZCBpbiBpcyBpbnZhbGlkLgpAQCAtNjczLDcgKzY3Myw3IEBACiAvKioKICogICBJbml0aWFsaXplcyBhbGwgb2YgdGhlIGRhdGEgc3RydWN0dXJlcyBhc3NvY2lhdGVkIHdpdGggdGhlIERNQS4KICogICBAcmV0dXJuCi0qICAgICAgID49IDAgICAgLSBJbml0aWFsaXphdGlvbiB3YXMgc3VjY2Vzc2Z1bGwuCisqICAgICAgID49IDAgICAgLSBJbml0aWFsaXphdGlvbiB3YXMgc3VjY2Vzc2Z1bC4KICoKICogICAgICAgLUVCVVNZICAtIERldmljZSBpcyBjdXJyZW50bHkgYmVpbmcgdXNlZC4KICogICAgICAgLUVOT0RFViAtIERldmljZSBoYW5kZWQgaW4gaXMgaW52YWxpZC4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL2NzcC9kbWFjSHcuaCBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL2NzcC9kbWFjSHcuaAppbmRleCA2YzhkYTJiLi5lNmExZGM0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaW5jbHVkZS9jc3AvZG1hY0h3LmgKKysrIGIvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2luY2x1ZGUvY3NwL2RtYWNIdy5oCkBAIC0zNjIsNyArMzYyLDcgQEAKIC8qKgogKiAgQGJyaWVmICAgUmVhZCBkYXRhIERNQSB0cmFuc2ZlcnJlZCB0byBtZW1vcnkKICoKLSogIFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIGRhdGEgdGhhdCBoYXMgYmVlbiBETUFlZCB0byBtZW1vcnkgd2hpbGUgdHJhbnNmZXJpbmcgZnJvbToKKyogIFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIGRhdGEgdGhhdCBoYXMgYmVlbiBETUFlZCB0byBtZW1vcnkgd2hpbGUgdHJhbnNmZXJyaW5nIGZyb206CiAqICAgICAgICAgIC0gTWVtb3J5IHRvIG1lbW9yeQogKiAgICAgICAgICAtIFBlcmlwaGVyYWwgdG8gbWVtb3J5CiAqCkBAIC00NDYsNyArNDQ2LDcgQEAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKioKLSogIEBicmllZiAgIENoZWNrIHRoZSBleGlzdGFuY2Ugb2YgcGVuZGluZyBkZXNjcmlwdG9yCisqICBAYnJpZWYgICBDaGVjayB0aGUgZXhpc3RlbmNlIG9mIHBlbmRpbmcgZGVzY3JpcHRvcgogKgogKiAgVGhpcyBmdW5jdGlvbiBjb25maXJtZXMgaWYgdGhlcmUgaXMgYW55IHBlbmRpbmcgZGVzY3JpcHRvciBpbiB0aGUgY2hhaW4KICogIHRvIHByb2dyYW0gdGhlIGNoYW5uZWwKQEAgLTU0Miw3ICs1NDIsNyBAQAogLyoqCiAqICBAYnJpZWYgICBTZXRzIGNoYW5uZWwgc3BlY2lmaWMgdXNlciBkYXRhCiAqCi0qICBUaGlzIGZ1bmN0aW9uIGFzc29jaWF0ZXMgdXNlciBkYXRhIHRvIGEgc3BlY2lmIERNQSBjaGFubmVsCisqICBUaGlzIGZ1bmN0aW9uIGFzc29jaWF0ZXMgdXNlciBkYXRhIHRvIGEgc3BlY2lmaWMgRE1BIGNoYW5uZWwKICoKICovCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvY3NwL2NoaXBjSHdfZGVmLmggYi9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaW5jbHVkZS9tYWNoL2NzcC9jaGlwY0h3X2RlZi5oCmluZGV4IDcwZWFlYTguLjE2MTk3MzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvY3NwL2NoaXBjSHdfZGVmLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2luY2x1ZGUvbWFjaC9jc3AvY2hpcGNId19kZWYuaApAQCAtMTgwLDcgKzE4MCw3IEBACiAKICNkZWZpbmUgY2hpcGNId19YVEFMX0ZSRVFfSHogICAgICAgICAgICAgICAgICAgIDI1MDAwMDAwCS8qIFJlZmVyZW5jZSBjbG9jayBmcmVxdWVuY3kgaW4gSHogKi8KIAotLyogUHJvZ3JhbWFibGUgcGluIGRlZmluZXMgKi8KKy8qIFByb2dyYW1tYWJsZSBwaW4gZGVmaW5lcyAqLwogI2RlZmluZSBjaGlwY0h3X1BJTl9HUElPKG4pICAgICAgICAgICAgICAgICAgICAgKCgoKG4pID49IDApICYmICgobikgPCAoY2hpcGNId19HUElPX0NPVU5UKSkpID8gKG4pIDogMHhGRkZGRkZGRikKIAkJCQkJCQkJCSAgICAgLyogR1BJTyBwaW4gMCAtIDYwICovCiAjZGVmaW5lIGNoaXBjSHdfUElOX1VBUlRUWEQgICAgICAgICAgICAgICAgICAgICAoY2hpcGNId19HUElPX0NPVU5UICsgMCkJLyogVUFSVCBUcmFuc21pdCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2luY2x1ZGUvbWFjaC9jc3AvY2hpcGNId19pbmxpbmUuaCBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvY3NwL2NoaXBjSHdfaW5saW5lLmgKaW5kZXggYzc4ODMzYS4uMDMyMzhjMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2luY2x1ZGUvbWFjaC9jc3AvY2hpcGNId19pbmxpbmUuaAorKysgYi9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaW5jbHVkZS9tYWNoL2NzcC9jaGlwY0h3X2lubGluZS5oCkBAIC04MzIsNyArODMyLDcgQEAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKioKLSogIEBicmllZiAgIExvd2VyIGxheWVyIGZ1bnRpb24gdG8gZW5hYmxlL2Rpc2FibGUgYSBjbG9jayBvZiBhIGNlcnRhaW4gZGV2aWNlCisqICBAYnJpZWYgICBMb3dlciBsYXllciBmdW5jdGlvbiB0byBlbmFibGUvZGlzYWJsZSBhIGNsb2NrIG9mIGEgY2VydGFpbiBkZXZpY2UKICoKICogIFRoaXMgZnVuY3Rpb24gZW5hYmxlcy9kaXNhYmxlcyBhIGNvcmUgY2xvY2sKICoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvY3NwL2ludGNId19yZWcuaCBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvY3NwL2ludGNId19yZWcuaAppbmRleCBlMDFmYzQ2Li4wYWViNmE2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaW5jbHVkZS9tYWNoL2NzcC9pbnRjSHdfcmVnLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2luY2x1ZGUvbWFjaC9jc3AvaW50Y0h3X3JlZy5oCkBAIC0xMDksOSArMTA5LDkgQEAKICNkZWZpbmUgSU5UQ0hXX0lOVEMwX0RNQTBDMCAgICAgICAgICAgICAgICgxPDxJTlRDSFdfSU5UQzBfRE1BMEMwX0JJVE5VTSkKIAogLyogSU5UQzEgLSBpbnRlcnJ1cHQgY29udHJvbGxlciAxICovCi0jZGVmaW5lIElOVENIV19JTlRDMV9ERFJWUE1QX0JJVE5VTSAgICAgICAyNwkvKiBERFIgYW5kIFZQTSBQTEwgY2xvY2sgcGhhc2UgcmVsYXRpb25zaGlwIGludGVydXB0IChOb3QgZm9yIEEwKSAqLworI2RlZmluZSBJTlRDSFdfSU5UQzFfRERSVlBNUF9CSVROVU0gICAgICAgMjcJLyogRERSIGFuZCBWUE0gUExMIGNsb2NrIHBoYXNlIHJlbGF0aW9uc2hpcCBpbnRlcnJ1cHQgKE5vdCBmb3IgQTApICovCiAjZGVmaW5lIElOVENIV19JTlRDMV9ERFJWUE1UX0JJVE5VTSAgICAgICAyNgkvKiBERFIgYW5kIFZQTSBIVyBwaGFzZSBhbGlnbiB0aW1lb3V0IGludGVycnVwdCAoTm90IGZvciBBMCkgKi8KLSNkZWZpbmUgSU5UQ0hXX0lOVEMxX0REUlBfQklUTlVNICAgICAgICAgIDI2CS8qIEREUiBhbmQgUExMIGNsb2NrIHBoYXNlIHJlbGF0aW9uc2hpcCBpbnRlcnVwdCAoRm9yIEEwIG9ubHkpKSAqLworI2RlZmluZSBJTlRDSFdfSU5UQzFfRERSUF9CSVROVU0gICAgICAgICAgMjYJLyogRERSIGFuZCBQTEwgY2xvY2sgcGhhc2UgcmVsYXRpb25zaGlwIGludGVycnVwdCAoRm9yIEEwIG9ubHkpKSAqLwogI2RlZmluZSBJTlRDSFdfSU5UQzFfUlRDMl9CSVROVU0gICAgICAgICAgMjUJLyogUmVhbCB0aW1lIGNsb2NrIHRhbXBlciBpbnRlcnJ1cHQgKi8KICNkZWZpbmUgSU5UQ0hXX0lOVEMxX1ZERUNfQklUTlVNICAgICAgICAgIDI0CS8qIEhhbnRybyBWaWRlbyBEZWNvZGVyIGludGVycnVwdCAqLwogLyogQml0cyAxMy0yMyBhcmUgbm9uLXNlY3VyZSB2ZXJzaW9ucyBvZiB0aGUgY29ycmVzcG9uZGluZyBzZWN1cmUgYml0cyBpbiBTSU5UQyBiaXRzIDAtMTAuICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaW5jbHVkZS9tYWNoL3JlZ191bWkuaCBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvcmVnX3VtaS5oCmluZGV4IDA2YTM1NTQuLjA5OTI4NDIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvcmVnX3VtaS5oCisrKyBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvcmVnX3VtaS5oCkBAIC04OCw3ICs4OCw3IEBACiAvKiBSRUdfVU1JX0ZMQVNIMC8xLzJfVENSLCBSRUdfVU1JX1NSQU0wLzFfVENSIGJpdHMgKi8KIC8qIEVuYWJsZSB3YWl0IHBpbiBkdXJpbmcgYnVyc3Qgd3JpdGUgb3IgcmVhZCAqLwogI2RlZmluZSBSRUdfVU1JX1RDUl9XQUlURU4gICAgICAgICAgICAgIDB4ODAwMDAwMDAKLS8qIEVuYWJsZSBtZW0gY3RybHIgdG8gd29yayBpd3RoIGV4dCBtZW0gb2YgbG93ZXIgZnJlcSB0aGFuIEFIQiBjbGsgKi8KKy8qIEVuYWJsZSBtZW0gY3RybHIgdG8gd29yayB3aXRoIGV4dCBtZW0gb2YgbG93ZXIgZnJlcSB0aGFuIEFIQiBjbGsgKi8KICNkZWZpbmUgUkVHX1VNSV9UQ1JfTE9XRlJFUSAgICAgICAgICAgICAweDQwMDAwMDAwCiAvKiAxPXN5bmNoIHdyaXRlLCAwPWFzeW5jIHdyaXRlICovCiAjZGVmaW5lIFJFR19VTUlfVENSX01FTVRZUEVfU1lOQ1dSSVRFICAgMHgyMDAwMDAwMApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2JvYXJkLW5ldXJvcy1vc2QyLmMgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvYm9hcmQtbmV1cm9zLW9zZDIuYwppbmRleCA2YzM4OWZmLi4zZTdiZTJkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvYm9hcmQtbmV1cm9zLW9zZDIuYworKysgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvYm9hcmQtbmV1cm9zLW9zZDIuYwpAQCAtMTEsNyArMTEsNyBAQAogICogRE02NDRYLUVWTSBib2FyZC4gSXQgaGFzOgogICogCURNNjQ0Nk0wMiBtb2R1bGUgd2l0aCAyNTZNQiBOQU5ELCAyNTZNQiBSQU0sIFRMVjMyMEFJQzMyIEFJQywKICAqIAlVU0IsIEV0aGVybmV0LCBTRC9NTUMsIFVBUlQsIFRIUzgyMDAsIFRWUDcwMDAgZm9yIHZpZGVvLgotICogCUFkZGl0aW9uYWx5IHJlYWx0aW1lIGNsb2NrLCBJUiByZW1vdGUgY29udHJvbCByZWNlaXZlciwKKyAqIAlBZGRpdGlvbmFsbHkgcmVhbHRpbWUgY2xvY2ssIElSIHJlbW90ZSBjb250cm9sIHJlY2VpdmVyLAogICogCUlSIEJsYXN0ZXIgYmFzZWQgb24gTVNQNDMwIChmaXJtd2FyZSBhbHRob3VnaCBpcyBkaWZmZXJlbnQKICAqIAlmcm9tIHVzZWQgaW4gRE02NDRYLUVWTSksIGludGVybmFsIEFUQS02IDMuNeKAnSBIREQgZHJpdmUKICAqIAl3aXRoIFBBVEEgaW50ZXJmYWNlLCB0d28gbXV4ZWQgcmVkLWdyZWVuIGxlZHMuCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvY3B1ZnJlcS5jIGIvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2NwdWZyZXEuYwppbmRleCA0YTY4YzJiLi4wYTk1YmUxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvY3B1ZnJlcS5jCisrKyBiL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9jcHVmcmVxLmMKQEAgLTE2Nyw3ICsxNjcsNyBAQAogCS8qCiAJICogVGltZSBtZWFzdXJlbWVudCBhY3Jvc3MgdGhlIHRhcmdldCgpIGZ1bmN0aW9uIHlpZWxkcyB+MTUwMC0xODAwdXMKIAkgKiB0aW1lIHRha2VuIHdpdGggbm8gZHJpdmVycyBvbiBub3RpZmljYXRpb24gbGlzdC4KLQkgKiBTZXR0aW5nIHRoZSBsYXRlbmN5IHRvIDIwMDAgdXMgdG8gYWNjb21vZGF0ZSBhZGRpdGlvbiBvZiBkcml2ZXJzCisJICogU2V0dGluZyB0aGUgbGF0ZW5jeSB0byAyMDAwIHVzIHRvIGFjY29tbW9kYXRlIGFkZGl0aW9uIG9mIGRyaXZlcnMKIAkgKiB0byBwcmUvcG9zdCBjaGFuZ2Ugbm90aWZpY2F0aW9uIGxpc3QuCiAJICovCiAJcG9saWN5LT5jcHVpbmZvLnRyYW5zaXRpb25fbGF0ZW5jeSA9IDIwMDAgKiAxMDAwOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2RhODUwLmMgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvZGE4NTAuYwppbmRleCA2OGZlNGMyLi5iOTViOTE5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvZGE4NTAuYworKysgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvZGE4NTAuYwpAQCAtMTEyMyw3ICsxMTIzLDcgQEAKIAkgKiBUaGlzIGhlbHBzIGtlZXBpbmcgdGhlIHBlcmlwaGVyYWxzIG9uIHRoaXMgZG9tYWluIGluc3VsYXRlZAogCSAqIGZyb20gQ1BVIGZyZXF1ZW5jeSBjaGFuZ2VzIGNhdXNlZCBieSBEVkZTLiBUaGUgZmlybXdhcmUgc2V0cwogCSAqIGJvdGggUExMMCBhbmQgUExMMSB0byB0aGUgc2FtZSBmcmVxdWVuY3kgc28sIHRoZXJlIHNob3VsZCBub3QKLQkgKiBiZSBhbnkgbm90aWNpYmxlIGNoYW5nZSBldmVuIGluIG5vbi1EVkZTIHVzZSBjYXNlcy4KKwkgKiBiZSBhbnkgbm90aWNlYWJsZSBjaGFuZ2UgZXZlbiBpbiBub24tRFZGUyB1c2UgY2FzZXMuCiAJICovCiAJZGE4NTBfc2V0X2FzeW5jM19zcmMoMSk7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9kbTM1NS5jIGIvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2RtMzU1LmMKaW5kZXggNzYzNjRkMS4uZjY4MDEyMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2RtMzU1LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2RtMzU1LmMKQEAgLTMxNCw3ICszMTQsNyBAQAogCS5uYW1lID0gInRpbWVyMiIsCiAJLnBhcmVudCA9ICZwbGwxX2F1eF9jbGssCiAJLmxwc2MgPSBEQVZJTkNJX0xQU0NfVElNRVIyLAotCS51c2Vjb3VudCA9IDEsICAgICAgICAgICAgICAvKiBSRVZJU0lUOiB3aHkgY2FudCcgdGhpcyBiZSBkaXNhYmxlZD8gKi8KKwkudXNlY291bnQgPSAxLCAgICAgICAgICAgICAgLyogUkVWSVNJVDogd2h5IGNhbid0JyB0aGlzIGJlIGRpc2FibGVkPyAqLwogfTsKIAogc3RhdGljIHN0cnVjdCBjbGsgdGltZXIzX2NsayA9IHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9kbTY0NHguYyBiL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9kbTY0NHguYwppbmRleCA5YTIzNzZiLi41ZjhhNjU0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvZG02NDR4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2RtNjQ0eC5jCkBAIC0yNzQsNyArMjc0LDcgQEAKIAkubmFtZSA9ICJ0aW1lcjIiLAogCS5wYXJlbnQgPSAmcGxsMV9hdXhfY2xrLAogCS5scHNjID0gREFWSU5DSV9MUFNDX1RJTUVSMiwKLQkudXNlY291bnQgPSAxLCAgICAgICAgICAgICAgLyogUkVWSVNJVDogd2h5IGNhbnQnIHRoaXMgYmUgZGlzYWJsZWQ/ICovCisJLnVzZWNvdW50ID0gMSwgICAgICAgICAgICAgIC8qIFJFVklTSVQ6IHdoeSBjYW4ndCcgdGhpcyBiZSBkaXNhYmxlZD8gKi8KIH07CiAKIHN0YXRpYyBzdHJ1Y3QgY2xrX2xvb2t1cCBkbTY0NHhfY2xrc1tdID0gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2luY2x1ZGUvbWFjaC9jcHV0eXBlLmggYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvaW5jbHVkZS9tYWNoL2NwdXR5cGUuaAppbmRleCBjZWE2Yjg5Li45NTdmYjg3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvaW5jbHVkZS9tYWNoL2NwdXR5cGUuaAorKysgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvaW5jbHVkZS9tYWNoL2NwdXR5cGUuaApAQCAtNCw3ICs0LDcgQEAKICAqIEF1dGhvcjogS2V2aW4gSGlsbWFuLCBEZWVwIFJvb3QgU3lzdGVtcywgTExDCiAgKgogICogRGVmaW5lcyB0aGUgY3B1X2lzXyooKSBtYWNyb3MgZm9yIHJ1bnRpbWUgZGV0ZWN0aW9uIG9mIERhVmluY2kKLSAqIGRldmljZSB0eXBlLiAgSW4gYWRkdGlvbiwgaWYgc3VwcG9ydCBmb3IgYSBnaXZlbiBkZXZpY2UgaXMgbm90CisgKiBkZXZpY2UgdHlwZS4gIEluIGFkZGl0aW9uLCBpZiBzdXBwb3J0IGZvciBhIGdpdmVuIGRldmljZSBpcyBub3QKICAqIGNvbXBpbGVkIGluIHRvIHRoZSBrZXJuZWwsIHRoZSBtYWNyb3MgcmV0dXJuIDAgc28gdGhhdAogICogcmVzdWx0aW5nIGNvZGUgY2FuIGJlIG9wdGltaXplZCBvdXQuCiAgKgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvZ3Bpby5jIGIvYXJjaC9hcm0vbWFjaC1lcDkzeHgvZ3Bpby5jCmluZGV4IDE4MGI4YTkuLmE1YTlmZjcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2dwaW8uYworKysgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9ncGlvLmMKQEAgLTEwMSw3ICsxMDEsNyBAQAogc3RhdGljIHZvaWQgZXA5M3h4X2dwaW9fZl9pcnFfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCiB7CiAJLyoKLQkgKiBtYXAgZGlzY29udGlndW91cyBodyBpcnEgcmFuZ2UgdG8gY29udGlub3VzIHN3IGlycSByYW5nZToKKwkgKiBtYXAgZGlzY29udGlndW91cyBodyBpcnEgcmFuZ2UgdG8gY29udGludW91cyBzdyBpcnEgcmFuZ2U6CiAJICoKIAkgKiAgSVJRX0VQOTNYWF9HUElPezAuLjd9TVVYIC0+IGdwaW9fdG9faXJxKEVQOTNYWF9HUElPX0xJTkVfRih7MC4uN30pCiAJICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWV4eW5vczQvaW5jbHVkZS9tYWNoL2dwaW8uaCBiL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IDkzOTcyOGIuLmJlOTI2NmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9pbmNsdWRlL21hY2gvZ3Bpby5oCisrKyBiL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9pbmNsdWRlL21hY2gvZ3Bpby5oCkBAIC0xOCw3ICsxOCw3IEBACiAjZGVmaW5lIGdwaW9fY2Fuc2xlZXAJX19ncGlvX2NhbnNsZWVwCiAjZGVmaW5lIGdwaW9fdG9faXJxCV9fZ3Bpb190b19pcnEKIAotLyogUHJhY3RpY2FsbHksIEdQSU8gYmFua3MgdXB0byBHUFogYXJlIHRoZSBjb25maWd1cmFibGUgZ3BpbyBiYW5rcyAqLworLyogUHJhY3RpY2FsbHksIEdQSU8gYmFua3MgdXAgdG8gR1BaIGFyZSB0aGUgY29uZmlndXJhYmxlIGdwaW8gYmFua3MgKi8KIAogLyogR1BJTyBiYW5rIHNpemVzICovCiAjZGVmaW5lIEVYWU5PUzRfR1BJT19BMF9OUgkoOCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9tY3QuYyBiL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9tY3QuYwppbmRleCBhZjgyYThmLi4xNGFjMTBiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWV4eW5vczQvbWN0LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1leHlub3M0L21jdC5jCkBAIC0yNzYsNyArMjc2LDcgQEAKIAkvKiB1cGRhdGUgaW50ZXJydXB0IGNvdW50IGJ1ZmZlciAqLwogCWV4eW5vczRfbWN0X3dyaXRlKHRtcCwgbWV2dC0+YmFzZSArIE1DVF9MX0lDTlRCX09GRlNFVCk7CiAKLQkvKiBlbmFibGUgTUNUIHRpY2sgaW50ZXJ1cHQgKi8KKwkvKiBlbmFibGUgTUNUIHRpY2sgaW50ZXJydXB0ICovCiAJZXh5bm9zNF9tY3Rfd3JpdGUoMHgxLCBtZXZ0LT5iYXNlICsgTUNUX0xfSU5UX0VOQl9PRkZTRVQpOwogCiAJdG1wID0gX19yYXdfcmVhZGwobWV2dC0+YmFzZSArIE1DVF9MX1RDT05fT0ZGU0VUKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9zZXR1cC1zZGhjaS1ncGlvLmMgYi9hcmNoL2FybS9tYWNoLWV4eW5vczQvc2V0dXAtc2RoY2ktZ3Bpby5jCmluZGV4IDFiM2QzYTJkLi5lOGQwOGJmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWV4eW5vczQvc2V0dXAtc2RoY2ktZ3Bpby5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9zZXR1cC1zZGhjaS1ncGlvLmMKQEAgLTM4LDE0ICszOCwxNCBAQAogCXN3aXRjaCAod2lkdGgpIHsKIAljYXNlIDg6CiAJCWZvciAoZ3BpbyA9IEVYWU5PUzRfR1BLMSgzKTsgZ3BpbyA8PSBFWFlOT1M0X0dQSzEoNik7IGdwaW8rKykgewotCQkJLyogRGF0YSBwaW4gR1BLMVszOjZdIHRvIHNwZWNpYWwtZnVudGlvbiAzICovCisJCQkvKiBEYXRhIHBpbiBHUEsxWzM6Nl0gdG8gc3BlY2lhbC1mdW5jdGlvbiAzICovCiAJCQlzM2NfZ3Bpb19jZmdwaW4oZ3BpbywgUzNDX0dQSU9fU0ZOKDMpKTsKIAkJCXMzY19ncGlvX3NldHB1bGwoZ3BpbywgUzNDX0dQSU9fUFVMTF9VUCk7CiAJCQlzNXBfZ3Bpb19zZXRfZHJ2c3RyKGdwaW8sIFM1UF9HUElPX0RSVlNUUl9MVjQpOwogCQl9CiAJY2FzZSA0OgogCQlmb3IgKGdwaW8gPSBFWFlOT1M0X0dQSzAoMyk7IGdwaW8gPD0gRVhZTk9TNF9HUEswKDYpOyBncGlvKyspIHsKLQkJCS8qIERhdGEgcGluIEdQSzBbMzo2XSB0byBzcGVjaWFsLWZ1bnRpb24gMiAqLworCQkJLyogRGF0YSBwaW4gR1BLMFszOjZdIHRvIHNwZWNpYWwtZnVuY3Rpb24gMiAqLwogCQkJczNjX2dwaW9fY2ZncGluKGdwaW8sIFMzQ19HUElPX1NGTigyKSk7CiAJCQlzM2NfZ3Bpb19zZXRwdWxsKGdwaW8sIFMzQ19HUElPX1BVTExfVVApOwogCQkJczVwX2dwaW9fc2V0X2RydnN0cihncGlvLCBTNVBfR1BJT19EUlZTVFJfTFY0KTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZXh5bm9zNC9zZXR1cC1zZGhjaS5jIGIvYXJjaC9hcm0vbWFjaC1leHlub3M0L3NldHVwLXNkaGNpLmMKaW5kZXggODVmOTQzMy4uMWU4M2Y4YyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1leHlub3M0L3NldHVwLXNkaGNpLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1leHlub3M0L3NldHVwLXNkaGNpLmMKQEAgLTM1LDcgKzM1LDcgQEAKIHsKIAl1MzIgY3RybDIsIGN0cmwzOwogCi0JLyogZG9uJ3QgbmVlZCB0byBhbHRlciBhbnl0aGluZyBhY29yZGluZyB0byBjYXJkLXR5cGUgKi8KKwkvKiBkb24ndCBuZWVkIHRvIGFsdGVyIGFueXRoaW5nIGFjY29yZGluZyB0byBjYXJkLXR5cGUgKi8KIAogCWN0cmwyID0gcmVhZGwociArIFMzQ19TREhDSV9DT05UUk9MMik7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW9wMTN4eC9wY2kuYyBiL2FyY2gvYXJtL21hY2gtaW9wMTN4eC9wY2kuYwppbmRleCA3NzNlYTBjLi5iYTNkYWUzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWlvcDEzeHgvcGNpLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pb3AxM3h4L3BjaS5jCkBAIC0yMjUsNyArMjI1LDcgQEAKIC8qIFRoaXMgcm91dGluZSBjaGVja3MgdGhlIHN0YXR1cyBvZiB0aGUgbGFzdCBjb25maWd1cmF0aW9uIGN5Y2xlLiAgSWYgYW4gZXJyb3IKICAqIHdhcyBkZXRlY3RlZCBpdCByZXR1cm5zID4wLCBlbHNlIGl0IHJldHVybnMgYSAwLiAgVGhlIGVycm9ycyBiZWluZyBjaGVja2VkCiAgKiBhcmUgcGFyaXR5LCBtYXN0ZXIgYWJvcnQsIHRhcmdldCBhYm9ydCAobWFzdGVyIGFuZCB0YXJnZXQpLiAgVGhlc2UgdHlwZXMgb2YKLSAqIGVycm9ycyBvY2N1cmUgZHVyaW5nIGEgY29uZmlnIGN5Y2xlIHdoZXJlIHRoZXJlIGlzIG5vIGRldmljZSwgbGlrZSBkdXJpbmcKKyAqIGVycm9ycyBvY2N1ciBkdXJpbmcgYSBjb25maWcgY3ljbGUgd2hlcmUgdGhlcmUgaXMgbm8gZGV2aWNlLCBsaWtlIGR1cmluZwogICogdGhlIGRpc2NvdmVyeSBzdGFnZS4KICAqLwogc3RhdGljIGludCBpb3AxM3h4X2F0dXhfcGNpX3N0YXR1cyhpbnQgY2xlYXIpCkBAIC0zMzIsNyArMzMyLDcgQEAKIC8qIFRoaXMgcm91dGluZSBjaGVja3MgdGhlIHN0YXR1cyBvZiB0aGUgbGFzdCBjb25maWd1cmF0aW9uIGN5Y2xlLiAgSWYgYW4gZXJyb3IKICAqIHdhcyBkZXRlY3RlZCBpdCByZXR1cm5zID4wLCBlbHNlIGl0IHJldHVybnMgYSAwLiAgVGhlIGVycm9ycyBiZWluZyBjaGVja2VkCiAgKiBhcmUgcGFyaXR5LCBtYXN0ZXIgYWJvcnQsIHRhcmdldCBhYm9ydCAobWFzdGVyIGFuZCB0YXJnZXQpLiAgVGhlc2UgdHlwZXMgb2YKLSAqIGVycm9ycyBvY2N1cmUgZHVyaW5nIGEgY29uZmlnIGN5Y2xlIHdoZXJlIHRoZXJlIGlzIG5vIGRldmljZSwgbGlrZSBkdXJpbmcKKyAqIGVycm9ycyBvY2N1ciBkdXJpbmcgYSBjb25maWcgY3ljbGUgd2hlcmUgdGhlcmUgaXMgbm8gZGV2aWNlLCBsaWtlIGR1cmluZwogICogdGhlIGRpc2NvdmVyeSBzdGFnZS4KICAqLwogc3RhdGljIGludCBpb3AxM3h4X2F0dWVfcGNpX3N0YXR1cyhpbnQgY2xlYXIpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWtpcmt3b29kL3RzeDF4LWNvbW1vbi5jIGIvYXJjaC9hcm0vbWFjaC1raXJrd29vZC90c3gxeC1jb21tb24uYwppbmRleCBmNzgxMTY0Li4yNDI5NGIyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWtpcmt3b29kL3RzeDF4LWNvbW1vbi5jCisrKyBiL2FyY2gvYXJtL21hY2gta2lya3dvb2QvdHN4MXgtY29tbW9uLmMKQEAgLTE1LDcgKzE1LDcgQEAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqIDE2IE1pQiBOT1IgZmxhc2guIFRoZSBzdHJ1Y3QgbXRkX3BhcnRpdGlvbiBpcyBub3QgaW4gdGhlIHNhbWUgb3JkZXIgYXMgdGhlCi0gKiAgICAgcGFydGl0aW9ucyBvbiB0aGUgZGV2aWNlIGJlY2F1c2Ugd2Ugd2FudCB0byBrZWVwIGNvbXBhdGFiaWxpdHkgd2l0aAorICogICAgIHBhcnRpdGlvbnMgb24gdGhlIGRldmljZSBiZWNhdXNlIHdlIHdhbnQgdG8ga2VlcCBjb21wYXRpYmlsaXR5IHdpdGgKICAqICAgICB0aGUgUU5BUCBmaXJtd2FyZS4KICAqIExheW91dCBhcyB1c2VkIGJ5IFFOQVA6CiAgKiAgMHgwMDAwMDAwMC0weDAwMDgwMDAwIDogIlUtQm9vdCIKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbHBjMzJ4eC9wbS5jIGIvYXJjaC9hcm0vbWFjaC1scGMzMnh4L3BtLmMKaW5kZXggZTc2ZDQxYi4uYjljODA1OSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1scGMzMnh4L3BtLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1scGMzMnh4L3BtLmMKQEAgLTQxLDcgKzQxLDcgQEAKICAqIERSQU0gY2xvY2tpbmcgYW5kIHJlZnJlc2ggYXJlIHNsaWdodGx5IGRpZmZlcmVudCBmb3Igc3lzdGVtcyB3aXRoIEREUgogICogRFJBTSBvciByZWd1bGFyIFNEUkFNIGRldmljZXMuIElmIFNEUkFNIGlzIHVzZWQgaW4gdGhlIHN5c3RlbSwgdGhlCiAgKiBTRFJBTSB3aWxsIHN0aWxsIGJlIGFjY2Vzc2libGUgaW4gZGlyZWN0LXJ1biBtb2RlLiBJbiBERFIgYmFzZWQgc3lzdGVtcywKLSAqIGEgdHJhbnNpc3Rpb24gdG8gZGlyZWN0LXJ1biBtb2RlIHdpbGwgc3RvcCBhbGwgRERSIGFjY2Vzc2VzIChubyBjbG9ja3MpLgorICogYSB0cmFuc2l0aW9uIHRvIGRpcmVjdC1ydW4gbW9kZSB3aWxsIHN0b3AgYWxsIEREUiBhY2Nlc3NlcyAobm8gY2xvY2tzKS4KICAqIEJlY2F1c2Ugb2YgdGhpcywgdGhlIGNvZGUgdG8gc3dpdGNoIHBvd2VyIG1vZGVzIGFuZCB0aGUgY29kZSB0byBlbnRlcgogICogYW5kIGV4aXQgRFJBTSBzZWxmLXJlZnJlc2ggbW9kZXMgbXVzdCBub3QgYmUgZXhlY3V0ZWQgaW4gRFJBTS4gQSBzbWFsbAogICogc2VjdGlvbiBvZiBJUkFNIGlzIHVzZWQgaW5zdGVhZCBmb3IgdGhpcy4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbW1wL3RpbWUuYyBiL2FyY2gvYXJtL21hY2gtbW1wL3RpbWUuYwppbmRleCBhZWI5YWUyLi45OTgzM2I5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW1tcC90aW1lLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1tbXAvdGltZS5jCkBAIC05LDcgKzksNyBAQAogICogICAyMDA4LTA0LTExOiBKYXNvbiBDaGFnYXMgPEphc29uLmNoYWdhc0BtYXJ2ZWxsLmNvbT4KICAqICAgMjAwOC0xMC0wODogQmluIFlhbmcgPGJpbi55YW5nQG1hcnZlbGwuY29tPgogICoKLSAqIFRoZSB0aW1lcnMgbW9kdWxlIGFjdHVhbGx5IGluY2x1ZGVzIHRocmVlIHRpbWVycywgZWFjaCB0aW1lciB3aXRoIHVwdG8KKyAqIFRoZSB0aW1lcnMgbW9kdWxlIGFjdHVhbGx5IGluY2x1ZGVzIHRocmVlIHRpbWVycywgZWFjaCB0aW1lciB3aXRoIHVwIHRvCiAgKiB0aHJlZSBtYXRjaCBjb21wYXJhdG9ycy4gVGltZXIgIzAgaXMgdXNlZCBoZXJlIGluIGZyZWUtcnVubmluZyBtb2RlIGFzCiAgKiB0aGUgY2xvY2sgc291cmNlLCBhbmQgbWF0Y2ggY29tcGFyYXRvciAjMSB1c2VkIGFzIGNsb2NrIGV2ZW50IGRldmljZS4KICAqCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1zbS9hY3B1Y2xvY2stYXJtMTEuYyBiL2FyY2gvYXJtL21hY2gtbXNtL2FjcHVjbG9jay1hcm0xMS5jCmluZGV4IDdmZmJkOTguLjgwNWQ0ZWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXNtL2FjcHVjbG9jay1hcm0xMS5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXNtL2FjcHVjbG9jay1hcm0xMS5jCkBAIC0zNDMsNyArMzQzLDcgQEAKIAkJfQogCX0KIAotCS8qIFNldCB3YWl0IHN0YXRlcyBmb3IgQ1BVIGluYmV0d2VlbiBmcmVxdWVuY3kgY2hhbmdlcyAqLworCS8qIFNldCB3YWl0IHN0YXRlcyBmb3IgQ1BVIGJldHdlZW4gZnJlcXVlbmN5IGNoYW5nZXMgKi8KIAlyZWdfY2xrY3RsID0gcmVhZGwoQTExU19DTEtfQ05UTF9BRERSKTsKIAlyZWdfY2xrY3RsIHw9ICgxMDAgPDwgMTYpOyAvKiBzZXQgV1RfU1RfQ05UICovCiAJd3JpdGVsKHJlZ19jbGtjdGwsIEExMVNfQ0xLX0NOVExfQUREUik7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1zbS9zY20uYyBiL2FyY2gvYXJtL21hY2gtbXNtL3NjbS5jCmluZGV4IGNmYTgwOGQuLjIzMmY5N2EgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXNtL3NjbS5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXNtL3NjbS5jCkBAIC00Niw3ICs0Niw3IEBACiAgKiBAaWQ6IGNvbW1hbmQgdG8gYmUgZXhlY3V0ZWQKICAqIEBidWY6IGJ1ZmZlciByZXR1cm5lZCBmcm9tIHNjbV9nZXRfY29tbWFuZF9idWZmZXIoKQogICoKLSAqIEFuIFNDTSBjb21tYW5kIGlzIGxheWVkIG91dCBpbiBtZW1vcnkgYXMgZm9sbG93czoKKyAqIEFuIFNDTSBjb21tYW5kIGlzIGxhaWQgb3V0IGluIG1lbW9yeSBhcyBmb2xsb3dzOgogICoKICAqCS0tLS0tLS0tLS0tLS0tLS0tLS0gPC0tLSBzdHJ1Y3Qgc2NtX2NvbW1hbmQKICAqCXwgY29tbWFuZCBoZWFkZXIgIHwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDEvYW1zLWRlbHRhLWZpcS1oYW5kbGVyLlMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2Ftcy1kZWx0YS1maXEtaGFuZGxlci5TCmluZGV4IDkyN2Q1YTEuLmMxYzVmYjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDEvYW1zLWRlbHRhLWZpcS1oYW5kbGVyLlMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9hbXMtZGVsdGEtZmlxLWhhbmRsZXIuUwpAQCAtNzksNyArNzksNyBAQAogCiAKIC8qCi0gKiBSZWdpc3RlciB1c2VhZ2UKKyAqIFJlZ2lzdGVyIHVzYWdlCiAgKiByOCAgLSB0ZW1wb3JhcnkKICAqIHI5ICAtIHRoZSBkcml2ZXIgYnVmZmVyCiAgKiByMTAgLSB0ZW1wb3JhcnkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDEvYm9hcmQtc3gxLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2JvYXJkLXN4MS5jCmluZGV4IGQ0MWZlMmQuLjBhZDc4MWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDEvYm9hcmQtc3gxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9ib2FyZC1zeDEuYwpAQCAtMzk5LDcgKzM5OSw3IEBACiAJc3gxX21tY19pbml0KCk7CiAKIAkvKiB0dXJuIG9uIFVTQiBwb3dlciAqLwotCS8qIHN4MV9zZXR1c2Jwb3dlcigxKTsgY2FudCBkbyBpdCBoZXJlIGJlY2F1c2UgaTJjIGlzIG5vdCByZWFkeSAqLworCS8qIHN4MV9zZXR1c2Jwb3dlcigxKTsgY2FuJ3QgZG8gaXQgaGVyZSBiZWNhdXNlIGkyYyBpcyBub3QgcmVhZHkgKi8KIAlncGlvX3JlcXVlc3QoMSwgIkFfSVJEQV9PRkYiKTsKIAlncGlvX3JlcXVlc3QoMTEsICJBX1NXSVRDSCIpOwogCWdwaW9fcmVxdWVzdCgxNSwgIkFfVVNCX09OIik7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAxL2RldmljZXMuYyBiL2FyY2gvYXJtL21hY2gtb21hcDEvZGV2aWNlcy5jCmluZGV4IGIwZjRjMjMuLjM2ZjI2YzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDEvZGV2aWNlcy5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDEvZGV2aWNlcy5jCkBAIC0yODEsNyArMjgxLDcgQEAKICAqIENsYWltaW5nIEdQSU9zLCBhbmQgc2V0dGluZyB0aGVpciBkaXJlY3Rpb24gYW5kIGluaXRpYWwgdmFsdWVzLCBpcyB0aGUKICAqIHJlc3BvbnNpYmlsaXR5IG9mIHRoZSBkZXZpY2UgZHJpdmVycy4gIFNvIGlzIHJlc3BvbmRpbmcgdG8gcHJvYmUoKS4KICAqCi0gKiBCb2FyZC1zcGVjaWZpYyBrbm93bGVnZSBsaWtlIGNyZWF0aW5nIGRldmljZXMgb3IgcGluIHNldHVwIGlzIHRvIGJlCisgKiBCb2FyZC1zcGVjaWZpYyBrbm93bGVkZ2UgbGlrZSBjcmVhdGluZyBkZXZpY2VzIG9yIHBpbiBzZXR1cCBpcyB0byBiZQogICoga2VwdCBvdXQgb2YgZHJpdmVycyBhcyBtdWNoIGFzIHBvc3NpYmxlLiAgSW4gcGFydGljdWxhciwgcGluIHNldHVwCiAgKiBtYXkgYmUgaGFuZGxlZCBieSB0aGUgYm9vdCBsb2FkZXIsIGFuZCBkcml2ZXJzIHNob3VsZCBleHBlY3QgaXQgd2lsbAogICogbm9ybWFsbHkgaGF2ZSBiZWVuIGRvbmUgYnkgdGhlIHRpbWUgdGhleSdyZSBwcm9iZWQuCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAxL2luY2x1ZGUvbWFjaC9hbXMtZGVsdGEtZmlxLmggYi9hcmNoL2FybS9tYWNoLW9tYXAxL2luY2x1ZGUvbWFjaC9hbXMtZGVsdGEtZmlxLmgKaW5kZXggN2EyZGYyOS4uMjNlZWQwMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMS9pbmNsdWRlL21hY2gvYW1zLWRlbHRhLWZpcS5oCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDEvaW5jbHVkZS9tYWNoL2Ftcy1kZWx0YS1maXEuaApAQCAtMzEsNyArMzEsNyBAQAogI2VuZGlmCiAKIC8qCi0gKiBUaGVzZSBhcmUgdGhlIG9mZnNldHMgZnJvbSB0aGUgYmVnaW5pbmcgb2YgdGhlIGZpcV9idWZmZXIuIFRoZXkgYXJlIHB1dCBoZXJlCisgKiBUaGVzZSBhcmUgdGhlIG9mZnNldHMgZnJvbSB0aGUgYmVnaW5uaW5nIG9mIHRoZSBmaXFfYnVmZmVyLiBUaGV5IGFyZSBwdXQgaGVyZQogICogc2luY2UgdGhlIGJ1ZmZlciBhbmQgaGVhZGVyIG5lZWQgdG8gYmUgYWNjZXNzZWQgYnkgZHJpdmVycyBzZXJ2aWNpbmcgZGV2aWNlcwogICogd2hpY2ggZ2VuZXJhdGUgR1BJTyBpbnRlcnJ1cHRzIC0gZS5nLiBrZXlib2FyZCwgbW9kZW0sIGhvb2sgc3dpdGNoLgogICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWlnZXAwMDIwLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWlnZXAwMDIwLmMKaW5kZXggNWY4YTJmZC4uMzRjZjk4MiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1pZ2VwMDAyMC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtaWdlcDAwMjAuYwpAQCAtNjk2LDcgKzY5Niw3IEBACiAJaWdlcDJfaW5pdF9zbXNjOTExeCgpOwogCiAJLyoKLQkgKiBXTEFOLUJUIGNvbWJvIG1vZHVsZSBmcm9tIE11UmF0YSB3aWNoIGhhcyBhIE1hcnZlbGwgV0xBTgorCSAqIFdMQU4tQlQgY29tYm8gbW9kdWxlIGZyb20gTXVSYXRhIHdoaWNoIGhhcyBhIE1hcnZlbGwgV0xBTgogCSAqICg4OFc4Njg2KSArIENTUiBCbHVldG9vdGggY2hpcHNldC4gVXNlcyBTRElPIGludGVyZmFjZS4KIAkgKi8KIAlpZ2VwMl93bGFuX2J0X2luaXQoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtaWdlcDAwMzAuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtaWdlcDAwMzAuYwppbmRleCBiMTBkYjBlLi4yY2Y4NmMzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWlnZXAwMDMwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1pZ2VwMDAzMC5jCkBAIC00NDAsNyArNDQwLDcgQEAKIAlpZ2VwM19sZWRzX2luaXQoKTsKIAogCS8qCi0JICogV0xBTi1CVCBjb21ibyBtb2R1bGUgZnJvbSBNdVJhdGEgd2ljaCBoYXMgYSBNYXJ2ZWxsIFdMQU4KKwkgKiBXTEFOLUJUIGNvbWJvIG1vZHVsZSBmcm9tIE11UmF0YSB3aGljaCBoYXMgYSBNYXJ2ZWxsIFdMQU4KIAkgKiAoODhXODY4NikgKyBDU1IgQmx1ZXRvb3RoIGNoaXBzZXQuIFVzZXMgU0RJTyBpbnRlcmZhY2UuCiAJICovCiAJaWdlcDNfd2lmaV9idF9pbml0KCk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmMKaW5kZXggYWI4Nzg1NC4uNmNiNmMwMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbi5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW4uYwpAQCAtMjU4LDcgKzI1OCw3IEBACiAgKiBjbGtkbV9pbml0IC0gc2V0IHVwIHRoZSBjbG9ja2RvbWFpbiBsYXllcgogICogQGNsa2Rtczogb3B0aW9uYWwgcG9pbnRlciB0byBhbiBhcnJheSBvZiBjbG9ja2RvbWFpbnMgdG8gcmVnaXN0ZXIKICAqIEBpbml0X2F1dG9kZXBzOiBvcHRpb25hbCBwb2ludGVyIHRvIGFuIGFycmF5IG9mIGF1dG9kZXBzIHRvIHJlZ2lzdGVyCi0gKiBAY3VzdG9tX2Z1bmNzOiBmdW5jIHBvaW50ZXJzIGZvciBhcmNoIHNwZWNmaWMgaW1wbGVtZW50YXRpb25zCisgKiBAY3VzdG9tX2Z1bmNzOiBmdW5jIHBvaW50ZXJzIGZvciBhcmNoIHNwZWNpZmljIGltcGxlbWVudGF0aW9ucwogICoKICAqIFNldCB1cCBpbnRlcm5hbCBzdGF0ZS4gIElmIGEgcG9pbnRlciB0byBhbiBhcnJheSBvZiBjbG9ja2RvbWFpbnMKICAqIEBjbGtkbXMgd2FzIHN1cHBsaWVkLCBsb29wIHRocm91Z2ggdGhlIGxpc3Qgb2YgY2xvY2tkb21haW5zLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbi5oIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbi5oCmluZGV4IDg1YjNkY2UuLjU4MjM1ODQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW4uaAorKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmgKQEAgLTEyNSw3ICsxMjUsNyBAQAogfTsKIAogLyoqCi0gKiBzdHJ1Y3QgY2xrZG1fb3BzIC0gQXJjaCBzcGVjZmljIGZ1bmN0aW9uIGltcGxlbWVudGF0aW9ucworICogc3RydWN0IGNsa2RtX29wcyAtIEFyY2ggc3BlY2lmaWMgZnVuY3Rpb24gaW1wbGVtZW50YXRpb25zCiAgKiBAY2xrZG1fYWRkX3drZGVwOiBBZGQgYSB3YWtldXAgZGVwZW5kZW5jeSBiZXR3ZWVuIGNsayBkb21haW5zCiAgKiBAY2xrZG1fZGVsX3drZGVwOiBEZWxldGUgYSB3YWtldXAgZGVwZW5kZW5jeSBiZXR3ZWVuIGNsayBkb21haW5zCiAgKiBAY2xrZG1fcmVhZF93a2RlcDogUmVhZCB3YWtldXAgZGVwZW5kZW5jeSBzdGF0ZSBiZXR3ZWVuIGNsayBkb21haW5zCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2NwdWlkbGUzNHh4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2NwdWlkbGUzNHh4LmMKaW5kZXggYTQ0YzUyMy4uMWMyNDBlZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jcHVpZGxlMzR4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY3B1aWRsZTM0eHguYwpAQCAtMjk3LDggKzI5Nyw4IEBACiAKIC8qKgogICogb21hcDNfY3B1aWRsZV91cGRhdGVfc3RhdGVzKCkgLSBVcGRhdGUgdGhlIGNwdWlkbGUgc3RhdGVzCi0gKiBAbXB1X2RlZXBlc3Rfc3RhdGU6CUVuYWJsZSBzdGF0ZXMgdXB0byBhbmQgaW5jbHVkaW5nIHRoaXMgZm9yIG1wdSBkb21haW4KLSAqIEBjb3JlX2RlZXBlc3Rfc3RhdGU6CUVuYWJsZSBzdGF0ZXMgdXB0byBhbmQgaW5jbHVkaW5nIHRoaXMgZm9yIGNvcmUgZG9tYWluCisgKiBAbXB1X2RlZXBlc3Rfc3RhdGU6CUVuYWJsZSBzdGF0ZXMgdXAgdG8gYW5kIGluY2x1ZGluZyB0aGlzIGZvciBtcHUgZG9tYWluCisgKiBAY29yZV9kZWVwZXN0X3N0YXRlOglFbmFibGUgc3RhdGVzIHVwIHRvIGFuZCBpbmNsdWRpbmcgdGhpcyBmb3IgY29yZSBkb21haW4KICAqCiAgKiBUaGlzIGdvZXMgdGhyb3VnaCB0aGUgbGlzdCBvZiBzdGF0ZXMgYXZhaWxhYmxlIGFuZCBlbmFibGVzIGFuZCBkaXNhYmxlcyB0aGUKICAqIHZhbGlkaXR5IG9mIEMgc3RhdGVzIGJhc2VkIG9uIGRlZXBlc3Qgc3RhdGUgdGhhdCBjYW4gYmUgYWNoaWV2ZWQgZm9yIHRoZQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9kZXZpY2VzLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2RldmljZXMuYwppbmRleCA4NGQxYjczLi43Yjg1NTg1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2RldmljZXMuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2RldmljZXMuYwpAQCAtMjUzLDcgKzI1Myw3IEBACiAJCQlBUlJBWV9TSVpFKG9tYXBfa2V5Ym9hcmRfbGF0ZW5jeSksIDApOwogCiAJaWYgKElTX0VSUihvZCkpIHsKLQkJV0FSTigxLCAiQ2FudCBidWlsZCBvbWFwX2RldmljZSBmb3IgJXM6JXMuXG4iLAorCQlXQVJOKDEsICJDYW4ndCBidWlsZCBvbWFwX2RldmljZSBmb3IgJXM6JXMuXG4iLAogCQkJCQkJbmFtZSwgb2gtPm5hbWUpOwogCQlyZXR1cm4gUFRSX0VSUihvZCk7CiAJfQpAQCAtMzczLDcgKzM3Myw3IEBACiAJb2QgPSBvbWFwX2RldmljZV9idWlsZChuYW1lLCBzcGlfbnVtLCBvaCwgcGRhdGEsCiAJCQkJc2l6ZW9mKCpwZGF0YSksCW9tYXBfbWNzcGlfbGF0ZW5jeSwKIAkJCQlBUlJBWV9TSVpFKG9tYXBfbWNzcGlfbGF0ZW5jeSksIDApOwotCVdBUk4oSVNfRVJSKG9kKSwgIkNhbnQgYnVpbGQgb21hcF9kZXZpY2UgZm9yICVzOiVzXG4iLAorCVdBUk4oSVNfRVJSKG9kKSwgIkNhbid0IGJ1aWxkIG9tYXBfZGV2aWNlIGZvciAlczolc1xuIiwKIAkJCQluYW1lLCBvaC0+bmFtZSk7CiAJa2ZyZWUocGRhdGEpOwogCXJldHVybiAwOwpAQCAtNzI1LDcgKzcyNSw3IEBACiAJb2QgPSBvbWFwX2RldmljZV9idWlsZChkZXZfbmFtZSwgaWQsIG9oLCBOVUxMLCAwLAogCQkJCW9tYXBfd2R0X2xhdGVuY3ksCiAJCQkJQVJSQVlfU0laRShvbWFwX3dkdF9sYXRlbmN5KSwgMCk7Ci0JV0FSTihJU19FUlIob2QpLCAiQ2FudCBidWlsZCBvbWFwX2RldmljZSBmb3IgJXM6JXMuXG4iLAorCVdBUk4oSVNfRVJSKG9kKSwgIkNhbid0IGJ1aWxkIG9tYXBfZGV2aWNlIGZvciAlczolcy5cbiIsCiAJCQkJZGV2X25hbWUsIG9oLT5uYW1lKTsKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvZG1hLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2RtYS5jCmluZGV4IDM0OTIyYjIuLmM5ZmYwZTcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvZG1hLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9kbWEuYwpAQCAtMjYyLDcgKzI2Miw3IEBACiAJCQlvbWFwMl9kbWFfbGF0ZW5jeSwgQVJSQVlfU0laRShvbWFwMl9kbWFfbGF0ZW5jeSksIDApOwogCWtmcmVlKHApOwogCWlmIChJU19FUlIob2QpKSB7Ci0JCXByX2VycigiJXM6IENhbnQgYnVpbGQgb21hcF9kZXZpY2UgZm9yICVzOiVzLlxuIiwKKwkJcHJfZXJyKCIlczogQ2FuJ3QgYnVpbGQgb21hcF9kZXZpY2UgZm9yICVzOiVzLlxuIiwKIAkJCV9fZnVuY19fLCBuYW1lLCBvaC0+bmFtZSk7CiAJCXJldHVybiBQVFJfRVJSKG9kKTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2dwaW8uYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvZ3Bpby5jCmluZGV4IDQxM2RlMTguLjk1Mjk4NDIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvZ3Bpby5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvZ3Bpby5jCkBAIC04Miw3ICs4Miw3IEBACiAJa2ZyZWUocGRhdGEpOwogCiAJaWYgKElTX0VSUihvZCkpIHsKLQkJV0FSTigxLCAiQ2FudCBidWlsZCBvbWFwX2RldmljZSBmb3IgJXM6JXMuXG4iLAorCQlXQVJOKDEsICJDYW4ndCBidWlsZCBvbWFwX2RldmljZSBmb3IgJXM6JXMuXG4iLAogCQkJCQluYW1lLCBvaC0+bmFtZSk7CiAJCXJldHVybiBQVFJfRVJSKG9kKTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2hzbW1jLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2hzbW1jLmMKaW5kZXggMTM3ZTFhNS4uYjJmMzBiZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9oc21tYy5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvaHNtbWMuYwpAQCAtNDY1LDcgKzQ2NSw3IEBACiAJb2QgPSBvbWFwX2RldmljZV9idWlsZChuYW1lLCBjdHJsX25yIC0gMSwgb2gsIG1tY19kYXRhLAogCQlzaXplb2Yoc3RydWN0IG9tYXBfbW1jX3BsYXRmb3JtX2RhdGEpLCBvaGwsIG9obF9jbnQsIGZhbHNlKTsKIAlpZiAoSVNfRVJSKG9kKSkgewotCQlXQVJOKDEsICJDYW50IGJ1aWxkIG9tYXBfZGV2aWNlIGZvciAlczolcy5cbiIsIG5hbWUsIG9oLT5uYW1lKTsKKwkJV0FSTigxLCAiQ2FuJ3QgYnVpbGQgb21hcF9kZXZpY2UgZm9yICVzOiVzLlxuIiwgbmFtZSwgb2gtPm5hbWUpOwogCQlrZnJlZShtbWNfZGF0YS0+c2xvdHNbMF0ubmFtZSk7CiAJCWdvdG8gZG9uZTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL21jYnNwLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL21jYnNwLmMKaW5kZXggNTY1YjkwNi4uNGE2ZWY2YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9tY2JzcC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvbWNic3AuYwpAQCAtMTQ5LDcgKzE0OSw3IEBACiAJCQkJQVJSQVlfU0laRShvbWFwMl9tY2JzcF9sYXRlbmN5KSwgZmFsc2UpOwogCWtmcmVlKHBkYXRhKTsKIAlpZiAoSVNfRVJSKG9kKSkgIHsKLQkJcHJfZXJyKCIlczogQ2FudCBidWlsZCBvbWFwX2RldmljZSBmb3IgJXM6JXMuXG4iLCBfX2Z1bmNfXywKKwkJcHJfZXJyKCIlczogQ2FuJ3QgYnVpbGQgb21hcF9kZXZpY2UgZm9yICVzOiVzLlxuIiwgX19mdW5jX18sCiAJCQkJCW5hbWUsIG9oLT5uYW1lKTsKIAkJcmV0dXJuIFBUUl9FUlIob2QpOwogCX0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvbXV4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL211eC5jCmluZGV4IGJiMDQzY2IuLmE0YWIxZTMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvbXV4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXguYwpAQCAtNTE4LDcgKzUxOCw3IEBACiAJCQlzZXFfcHJpbnRmKHMsICIvKiAlcyAqL1xuIiwgbS0+bXV4bmFtZXNbbW9kZV0pOwogCiAJCS8qCi0JCSAqIFhYWDogTWlnaHQgYmUgcmV2aXNpdGVkIHRvIHN1cHBvcnQgZGlmZmVyZW5jZXMgYWNjcm9zcworCQkgKiBYWFg6IE1pZ2h0IGJlIHJldmlzaXRlZCB0byBzdXBwb3J0IGRpZmZlcmVuY2VzIGFjcm9zcwogCQkgKiBzYW1lIE9NQVAgZ2VuZXJhdGlvbi4KIAkJICovCiAJCXNlcV9wcmludGYocywgIk9NQVAlZF9NVVgoJXMsICIsIG9tYXBfZ2VuLCBtMF9kZWYpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXgyNDMwLmggYi9hcmNoL2FybS9tYWNoLW9tYXAyL211eDI0MzAuaAppbmRleCBhZGJlYTBkLi45ZmQ5MzE0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL211eDI0MzAuaAorKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL211eDI0MzAuaApAQCAtMjIsNyArMjIsNyBAQAogICogYWJzb2x1dGUgYWRkcmVzc2VzLiAgVGhlIG5hbWUgaW4gdGhlIG1hY3JvIGlzIHRoZSBtb2RlLTAgbmFtZSBvZgogICogdGhlIHBpbi4gIE5PVEU6IFRoZXNlIHJlZ2lzdGVycyBhcmUgOC1iaXRzIHdpZGUuCiAgKgotICogTm90ZSB0aGF0IHRoZXNlIGRlZmluZXMgdXNlIFNETU1DIGluc3RlYWQgb2YgTU1DIGZvciBjb21wYWJpbGl0eQorICogTm90ZSB0aGF0IHRoZXNlIGRlZmluZXMgdXNlIFNETU1DIGluc3RlYWQgb2YgTU1DIGZvciBjb21wYXRpYmlsaXR5CiAgKiB3aXRoIHNpZ25hbCBuYW1lcyB1c2VkIGluIDM2MzAuCiAgKi8KICNkZWZpbmUgT01BUDI0MzBfQ09OVFJPTF9QQURDT05GX0dQTUNfQ0xLX09GRlNFVAkJMHgwMDAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZF8yNDMwX2RhdGEuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZF8yNDMwX2RhdGEuYwppbmRleCBhODYwZmI1Li5lNmUzODEwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2RfMjQzMF9kYXRhLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX2h3bW9kXzI0MzBfZGF0YS5jCkBAIC0xNTU5LDcgKzE1NTksNyBAQAogCQkJICogSTJDSFMgSVAncyBkbyBub3QgZm9sbG93IHRoZSB1c3VhbCBwYXR0ZXJuLgogCQkJICogcHJjbV9yZWdfaWQgYWxvbmUgY2Fubm90IGJlIHVzZWQgdG8gcHJvZ3JhbQogCQkJICogdGhlIGljbGsgYW5kIGZjbGsuIE5lZWRzIHRvIGJlIGhhbmRsZWQgdXNpbmcKLQkJCSAqIGFkZGl0b25hbCBmbGFncyB3aGVuIGNsayBoYW5kbGluZyBpcyBtb3ZlZAorCQkJICogYWRkaXRpb25hbCBmbGFncyB3aGVuIGNsayBoYW5kbGluZyBpcyBtb3ZlZAogCQkJICogdG8gaHdtb2QgZnJhbWV3b3JrLgogCQkJICovCiAJCQkubW9kdWxlX29mZnMgPSBDT1JFX01PRCwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9waHlfaW50ZXJuYWwuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9waHlfaW50ZXJuYWwuYwppbmRleCBlMmU2MDVmLi4wNWY2YWJjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfcGh5X2ludGVybmFsLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX3BoeV9pbnRlcm5hbC5jCkBAIC0xMTIsMTIgKzExMiwxMiBAQAogCQllbHNlCiAJCQkvKgogCQkJICogRW5hYmxlIFZCVVMgVmFsaWQsIEFWYWxpZCBhbmQgSURESUcKLQkJCSAqIGhpZ2ggaW1wZWRlbmNlCisJCQkgKiBoaWdoIGltcGVkYW5jZQogCQkJICovCiAJCQlfX3Jhd193cml0ZWwoSURESUcgfCBBVkFMSUQgfCBWQlVTVkFMSUQsCiAJCQkJCQljdHJsX2Jhc2UgKyBVU0JPVEdIU19DT05UUk9MKTsKIAl9IGVsc2UgewotCQkvKiBFbmFibGUgc2Vzc2lvbiBFTkQgYW5kIElESUcgdG8gaGlnaCBpbXBlZGVuY2UuICovCisJCS8qIEVuYWJsZSBzZXNzaW9uIEVORCBhbmQgSURJRyB0byBoaWdoIGltcGVkYW5jZS4gKi8KIAkJX19yYXdfd3JpdGVsKFNFU1NFTkQgfCBJRERJRywgY3RybF9iYXNlICsKIAkJCQkJVVNCT1RHSFNfQ09OVFJPTCk7CiAJfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX3R3bC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX3R3bC5jCmluZGV4IDBhOGU3NGUuLjA3ZDYxNDAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF90d2wuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfdHdsLmMKQEAgLTMwOCw3ICszMDgsNyBAQAogICogU3RyYXRlZ3kgU29mdHdhcmUgU2NhbGluZyBNb2RlIChFTkFCTEVfVk1PREU9MCksIGZvciBzZXR0aW5nIHRoZSB2b2x0YWdlcywKICAqIGluIHRob3NlIHNjZW5hcmlvcyB0aGlzIGJpdCBpcyB0byBiZSBjbGVhcmVkIChlbmFibGUgPSBmYWxzZSkuCiAgKgotICogUmV0dXJucyAwIG9uIHN1Y2VzcywgZXJyb3IgaXMgcmV0dXJuZWQgaWYgSTJDIHJlYWQvd3JpdGUgZmFpbHMuCisgKiBSZXR1cm5zIDAgb24gc3VjY2VzcywgZXJyb3IgaXMgcmV0dXJuZWQgaWYgSTJDIHJlYWQvd3JpdGUgZmFpbHMuCiAgKi8KIGludCBfX2luaXQgb21hcDNfdHdsX3NldF9zcl9iaXQoYm9vbCBlbmFibGUpCiB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL3Bvd2VyZG9tYWluLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3Bvd2VyZG9tYWluLmMKaW5kZXggNDljNjUxMy4uOWFmMDg0NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wb3dlcmRvbWFpbi5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvcG93ZXJkb21haW4uYwpAQCAtMTk2LDcgKzE5Niw3IEBACiAvKioKICAqIHB3cmRtX2luaXQgLSBzZXQgdXAgdGhlIHBvd2VyZG9tYWluIGxheWVyCiAgKiBAcHdyZG1fbGlzdDogYXJyYXkgb2Ygc3RydWN0IHBvd2VyZG9tYWluIHBvaW50ZXJzIHRvIHJlZ2lzdGVyCi0gKiBAY3VzdG9tX2Z1bmNzOiBmdW5jIHBvaW50ZXJzIGZvciBhcmNoIHNwZWNmaWMgaW1wbGVtZW50YXRpb25zCisgKiBAY3VzdG9tX2Z1bmNzOiBmdW5jIHBvaW50ZXJzIGZvciBhcmNoIHNwZWNpZmljIGltcGxlbWVudGF0aW9ucwogICoKICAqIExvb3AgdGhyb3VnaCB0aGUgYXJyYXkgb2YgcG93ZXJkb21haW5zIEBwd3JkbV9saXN0LCByZWdpc3RlcmluZyBhbGwKICAqIHRoYXQgYXJlIGF2YWlsYWJsZSBvbiB0aGUgY3VycmVudCBDUFUuIElmIHB3cmRtX2xpc3QgaXMgc3VwcGxpZWQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvcG93ZXJkb21haW4uaCBiL2FyY2gvYXJtL21hY2gtb21hcDIvcG93ZXJkb21haW4uaAppbmRleCAwMjdmNDBiLi5kMjNkOTc5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3Bvd2VyZG9tYWluLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wb3dlcmRvbWFpbi5oCkBAIC0xMjEsNyArMTIxLDcgQEAKIH07CiAKIC8qKgotICogc3RydWN0IHB3cmRtX29wcyAtIEFyY2ggc3BlY2ZpYyBmdW5jdGlvbiBpbXBsZW1lbnRhdGlvbnMKKyAqIHN0cnVjdCBwd3JkbV9vcHMgLSBBcmNoIHNwZWNpZmljIGZ1bmN0aW9uIGltcGxlbWVudGF0aW9ucwogICogQHB3cmRtX3NldF9uZXh0X3B3cnN0OiBTZXQgdGhlIHRhcmdldCBwb3dlciBzdGF0ZSBmb3IgYSBwZAogICogQHB3cmRtX3JlYWRfbmV4dF9wd3JzdDogUmVhZCB0aGUgdGFyZ2V0IHBvd2VyIHN0YXRlIHNldCBmb3IgYSBwZAogICogQHB3cmRtX3JlYWRfcHdyc3Q6IFJlYWQgdGhlIGN1cnJlbnQgcG93ZXIgc3RhdGUgb2YgYSBwZApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wb3dlcmRvbWFpbnMzeHh4X2RhdGEuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvcG93ZXJkb21haW5zM3h4eF9kYXRhLmMKaW5kZXggOWM5YzExMy4uNDY5YTkyMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wb3dlcmRvbWFpbnMzeHh4X2RhdGEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3Bvd2VyZG9tYWluczN4eHhfZGF0YS5jCkBAIC03Miw3ICs3Miw3IEBACiAKIC8qCiAgKiBUaGUgVVNCVExMIFNhdmUtYW5kLVJlc3RvcmUgbWVjaGFuaXNtIGlzIGJyb2tlbiBvbgotICogMzQzMHMgdXB0byBFUzMuMCBhbmQgMzYzMEVTMS4wLiBIZW5jZSB0aGlzIGZlYXR1cmUKKyAqIDM0MzBzIHVwIHRvIEVTMy4wIGFuZCAzNjMwRVMxLjAuIEhlbmNlIHRoaXMgZmVhdHVyZQogICogbmVlZHMgdG8gYmUgZGlzYWJsZWQgb24gdGhlc2UgY2hpcHMuCiAgKiBSZWZlcjogMzQzMCBlcnJhdGEgSUQgaTQ1OSBhbmQgMzYzMCBlcnJhdGEgSUQgaTU3OQogICoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvc21hcnRyZWZsZXguYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvc21hcnRyZWZsZXguYwppbmRleCA4ZjY3NGM5Li4xM2UyNGY5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3NtYXJ0cmVmbGV4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9zbWFydHJlZmxleC5jCkBAIC0yNDcsNyArMjQ3LDcgQEAKICAqIGRyaXZlciByZWdpc3RlciBhbmQgc3IgZGV2aWNlIGludGlhbGl6dGlvbiBBUEkncy4gT25seSBvbmUgY2FsbAogICogd2lsbCB1bHRpbWF0ZWx5IHN1Y2NlZWQuCiAgKgotICogQ3VycmVubHkgdGhpcyBmdW5jdGlvbiByZWdpc3RlcnMgaW50ZXJycnVwdCBoYW5kbGVyIGZvciBhIHBhcnRpY3VsYXIgU1IKKyAqIEN1cnJlbnRseSB0aGlzIGZ1bmN0aW9uIHJlZ2lzdGVycyBpbnRlcnJydXB0IGhhbmRsZXIgZm9yIGEgcGFydGljdWxhciBTUgogICogaWYgc21hcnRyZWZsZXggY2xhc3MgZHJpdmVyIGlzIGFscmVhZHkgcmVnaXN0ZXJlZCBhbmQgaGFzCiAgKiByZXF1ZXN0ZWQgZm9yIGludGVycnVwdHMgYW5kIHRoZSBTUiBpbnRlcnJ1cHQgbGluZSBpbiBwcmVzZW50LgogICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL3ZvbHRhZ2UuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvdm9sdGFnZS5jCmluZGV4IGM2ZmFjZjcuLjZmYjUyMDkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvdm9sdGFnZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvdm9sdGFnZS5jCkBAIC04NTEsNyArODUxLDcgQEAKICAqIEB2b2x0ZG06CXBvaW50ZXIgdG8gdGhlIFZERCB3aG9zZSB2b2x0YWdlIGlzIHRvIGJlIHJlc2V0LgogICoKICAqIFRoaXMgQVBJIGZpbmRzIG91dCB0aGUgY29ycmVjdCB2b2x0YWdlIHRoZSB2b2x0YWdlIGRvbWFpbiBpcyBzdXBwb3NlZAotICogdG8gYmUgYXQgYW5kIHJlc2V0cyB0aGUgdm9sdGFnZSB0byB0aGF0IGxldmVsLiBTaG91bGQgYmUgdXNlZCBleHBlY2lhbGx5CisgKiB0byBiZSBhdCBhbmQgcmVzZXRzIHRoZSB2b2x0YWdlIHRvIHRoYXQgbGV2ZWwuIFNob3VsZCBiZSB1c2VkIGVzcGVjaWFsbHkKICAqIHdoaWxlIGRpc2FibGluZyBhbnkgdm9sdGFnZSBjb21wZW5zYXRpb24gbW9kdWxlcy4KICAqLwogdm9pZCBvbWFwX3ZvbHRhZ2VfcmVzZXQoc3RydWN0IHZvbHRhZ2Vkb21haW4gKnZvbHRkbSkKQEAgLTkxMiw3ICs5MTIsNyBAQAogICogVGhpcyBBUEkgc2VhcmNoZXMgb25seSB0aHJvdWdoIHRoZSBub24tY29tcGVuc2F0ZWQgdm9sdGFnZXMgaW50IHRoZQogICogdm9sdGFnZSB0YWJsZS4KICAqIFJldHVybnMgcG9pbnRlciB0byB0aGUgdm9sdGFnZSB0YWJsZSBlbnRyeSBjb3JyZXNwb25kaW5nIHRvIHZvbHQgb24KLSAqIHN1Y2Vzcy4gUmV0dXJucyAtRU5PREFUQSBpZiBubyB2b2x0YWdlIHRhYmxlIGV4aXNpdHMgZm9yIHRoZSBwYXNzZWQgdm9sdGFnZQorICogc3VjY2Vzcy4gUmV0dXJucyAtRU5PREFUQSBpZiBubyB2b2x0YWdlIHRhYmxlIGV4aXNpdHMgZm9yIHRoZSBwYXNzZWQgdm9sdGFnZQogICogZG9tYWluIG9yIGlmIHRoZXJlIGlzIG5vIG1hdGNoaW5nIGVudHJ5LgogICovCiBzdHJ1Y3Qgb21hcF92b2x0X2RhdGEgKm9tYXBfdm9sdGFnZV9nZXRfdm9sdGRhdGEoc3RydWN0IHZvbHRhZ2Vkb21haW4gKnZvbHRkbSwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb3Jpb241eC9hZGRyLW1hcC5jIGIvYXJjaC9hcm0vbWFjaC1vcmlvbjV4L2FkZHItbWFwLmMKaW5kZXggMWE1ZDZhMC4uNWNlYWZkYyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vcmlvbjV4L2FkZHItbWFwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vcmlvbjV4L2FkZHItbWFwLmMKQEAgLTE5LDcgKzE5LDcgQEAKICNpbmNsdWRlICJjb21tb24uaCIKIAogLyoKLSAqIFRoZSBPcmlvbiBoYXMgZnVsbHkgcHJvZ3JhbWFibGUgYWRkcmVzcyBtYXAuIFRoZXJlJ3MgYSBzZXBhcmF0ZSBhZGRyZXNzCisgKiBUaGUgT3Jpb24gaGFzIGZ1bGx5IHByb2dyYW1tYWJsZSBhZGRyZXNzIG1hcC4gVGhlcmUncyBhIHNlcGFyYXRlIGFkZHJlc3MKICAqIG1hcCBmb3IgZWFjaCBvZiB0aGUgZGV2aWNlIF9tYXN0ZXJfIGludGVyZmFjZXMsIGUuZy4gQ1BVLCBQQ0ksIFBDSWUsIFVTQiwKICAqIEdpZ2FiaXQgRXRoZXJuZXQsIERNQS9YT1IgZW5naW5lcywgZXRjLiBFYWNoIGludGVyZmFjZSBoYXMgaXRzIG93bgogICogYWRkcmVzcyBkZWNvZGUgd2luZG93cyB0aGF0IGFsbG93IGl0IHRvIGFjY2VzcyBhbnkgb2YgdGhlIE9yaW9uIHJlc291cmNlcy4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb3Jpb241eC9uZXQyYmlnLXNldHVwLmMgYi9hcmNoL2FybS9tYWNoLW9yaW9uNXgvbmV0MmJpZy1zZXR1cC5jCmluZGV4IDQyOWVjYWYuLmE1OTMwZjggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb3Jpb241eC9uZXQyYmlnLXNldHVwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vcmlvbjV4L25ldDJiaWctc2V0dXAuYwpAQCAtMTkwLDcgKzE5MCw3IEBACiAgKiBUaGUgcG93ZXIgZnJvbnQgTEVEcyAoYmx1ZSBhbmQgcmVkKSBhbmQgU0FUQSByZWQgTEVEcyBhcmUgY29udHJvbGxlZCB2aWEgYQogICogc2luZ2xlIEdQSU8gbGluZSBhbmQgYXJlIGNvbXBhdGlibGUgd2l0aCB0aGUgbGVkcy1ncGlvIGRyaXZlci4KICAqCi0gKiBUaGUgU0FUQSBibHVlIExFRHMgaGF2ZSBzb21lIGhhcmR3YXJlIGJsaW5rIGNhcGFiaWxpdGllcyB3aGljaCBhcmUgZGV0YWlsbGVkCisgKiBUaGUgU0FUQSBibHVlIExFRHMgaGF2ZSBzb21lIGhhcmR3YXJlIGJsaW5rIGNhcGFiaWxpdGllcyB3aGljaCBhcmUgZGV0YWlsZWQKICAqIGluIHRoZSBmb2xsb3dpbmcgYXJyYXk6CiAgKgogICogU0FUQXggYmx1ZSBMRUQgfCBTQVRBeCBhY3Rpdml0eSB8IExFRCBzdGF0ZQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vcmlvbjV4L3RzMjA5LXNldHVwLmMgYi9hcmNoL2FybS9tYWNoLW9yaW9uNXgvdHMyMDktc2V0dXAuYwppbmRleCBmMGY0M2UxLi5lNmQ2NDQ5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9yaW9uNXgvdHMyMDktc2V0dXAuYworKysgYi9hcmNoL2FybS9tYWNoLW9yaW9uNXgvdHMyMDktc2V0dXAuYwpAQCAtMzYsNyArMzYsNyBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogOE1pQiBOT1IgZmxhc2guIFRoZSBzdHJ1Y3QgbXRkX3BhcnRpdGlvbiBpcyBub3QgaW4gdGhlIHNhbWUgb3JkZXIgYXMgdGhlCi0gKiAgICAgcGFydGl0aW9ucyBvbiB0aGUgZGV2aWNlIGJlY2F1c2Ugd2Ugd2FudCB0byBrZWVwIGNvbXBhdGFiaWxpdHkgd2l0aAorICogICAgIHBhcnRpdGlvbnMgb24gdGhlIGRldmljZSBiZWNhdXNlIHdlIHdhbnQgdG8ga2VlcCBjb21wYXRpYmlsaXR5IHdpdGgKICAqICAgICBleGlzdGluZyBRTkFQIGZpcm13YXJlLgogICoKICAqIExheW91dCBhcyB1c2VkIGJ5IFFOQVA6CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9yaW9uNXgvdHM0MDktc2V0dXAuYyBiL2FyY2gvYXJtL21hY2gtb3Jpb241eC90czQwOS1zZXR1cC5jCmluZGV4IDkyZjM5M2YuLjllYWM4MTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb3Jpb241eC90czQwOS1zZXR1cC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb3Jpb241eC90czQwOS1zZXR1cC5jCkBAIC01Niw3ICs1Niw3IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiA4TWlCIE5PUiBmbGFzaC4gVGhlIHN0cnVjdCBtdGRfcGFydGl0aW9uIGlzIG5vdCBpbiB0aGUgc2FtZSBvcmRlciBhcyB0aGUKLSAqICAgICBwYXJ0aXRpb25zIG9uIHRoZSBkZXZpY2UgYmVjYXVzZSB3ZSB3YW50IHRvIGtlZXAgY29tcGF0YWJpbGl0eSB3aXRoCisgKiAgICAgcGFydGl0aW9ucyBvbiB0aGUgZGV2aWNlIGJlY2F1c2Ugd2Ugd2FudCB0byBrZWVwIGNvbXBhdGliaWxpdHkgd2l0aAogICogICAgIGV4aXN0aW5nIFFOQVAgZmlybXdhcmUuCiAgKgogICogTGF5b3V0IGFzIHVzZWQgYnkgUU5BUDoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL2luY2x1ZGUvbWFjaC9weGEzeHgtcmVncy5oIGIvYXJjaC9hcm0vbWFjaC1weGEvaW5jbHVkZS9tYWNoL3B4YTN4eC1yZWdzLmgKaW5kZXggZTRmYjQ2Ni4uMjA3ZWNiNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1weGEvaW5jbHVkZS9tYWNoL3B4YTN4eC1yZWdzLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvaW5jbHVkZS9tYWNoL3B4YTN4eC1yZWdzLmgKQEAgLTM4LDcgKzM4LDcgQEAKICNkZWZpbmUgUENNRCh4KQkJX19SRUcoMHg0MEY1MDExMCArICgoeCkgPDwgMikpCiAKIC8qCi0gKiBTbGF2ZSBQb3dlciBNYW5hZ21lbnQgVW5pdAorICogU2xhdmUgUG93ZXIgTWFuYWdlbWVudCBVbml0CiAgKi8KICNkZWZpbmUgQVNDUgkJX19SRUcoMHg0MGY0MDAwMCkJLyogQXBwbGljYXRpb24gU3Vic3lzdGVtIFBvd2VyIFN0YXR1cy9Db25maWd1cmF0aW9uICovCiAjZGVmaW5lIEFSU1IJCV9fUkVHKDB4NDBmNDAwMDQpCS8qIEFwcGxpY2F0aW9uIFN1YnN5c3RlbSBSZXNldCBTdGF0dXMgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL2luY2x1ZGUvbWFjaC96ZXVzLmggYi9hcmNoL2FybS9tYWNoLXB4YS9pbmNsdWRlL21hY2gvemV1cy5oCmluZGV4IGZhYTQwOGEuLjA2NDFmMzEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2luY2x1ZGUvbWFjaC96ZXVzLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvaW5jbHVkZS9tYWNoL3pldXMuaApAQCAtNjQsNyArNjQsNyBAQAogCiAvKgogICogQ1BMRCByZWdpc3RlcnM6Ci0gKiBPbmx5IDQgcmVnaXN0ZXJzLCBidXQgc3ByZWFkZWQgb3ZlciBhIDMyTUIgYWRkcmVzcyBzcGFjZS4KKyAqIE9ubHkgNCByZWdpc3RlcnMsIGJ1dCBzcHJlYWQgb3ZlciBhIDMyTUIgYWRkcmVzcyBzcGFjZS4KICAqIEJlIGdlbnRsZSwgYW5kIHJlbWFwIHRoYXQgb3ZlciAzMmtCLi4uCiAgKi8KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1weGEvbWlvYTcwMS5jIGIvYXJjaC9hcm0vbWFjaC1weGEvbWlvYTcwMS5jCmluZGV4IGRkMTNiYjYuLjIzOTI1ZGIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL21pb2E3MDEuYworKysgYi9hcmNoL2FybS9tYWNoLXB4YS9taW9hNzAxLmMKQEAgLTQ1OCw3ICs0NTgsNyBAQAogLyoKICAqIFN1c3BlbmQvUmVzdW1lIGJvb3RzdHJhcCBtYW5hZ2VtZW50CiAgKgotICogTUlPIEE3MDEgcmVib290IHNlcXVlbmNlIGlzIGhpZ2hseSBST00gZGVwZW5kYW50LiBGcm9tIHRoZSBvbmUgZGlzc2Fzc2VtYmxlZCwKKyAqIE1JTyBBNzAxIHJlYm9vdCBzZXF1ZW5jZSBpcyBoaWdobHkgUk9NIGRlcGVuZGVudC4gRnJvbSB0aGUgb25lIGRpc3Nhc3NlbWJsZWQsCiAgKiB0aGlzIHNlcXVlbmNlIGlzIGFzIGZvbGxvd3MgOgogICogICAtIGRpc2FibGVzIGludGVycnVwdHMKICAqICAgLSBpbml0aWFsaXplIFNEUkFNIChzZWxmIHJlZnJlc2ggUkFNIGludG8gYWN0aXZlIFJBTSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvZG1hLmggYi9hcmNoL2FybS9tYWNoLXMzYzI0MTAvaW5jbHVkZS9tYWNoL2RtYS5oCmluZGV4IGNmNjgxMzYuLmIyYjJhNWIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvZG1hLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9kbWEuaApAQCAtMTksNyArMTksNyBAQAogI2RlZmluZSBNQVhfRE1BX1RSQU5TRkVSX1NJWkUgICAweDEwMDAwMCAvKiBEYXRhIFVuaXQgaXMgaGFsZiB3b3JkICAqLwogCiAvKiBXZSB1c2UgYHZpcnR1YWxgIGRtYSBjaGFubmVscyB0byBoaWRlIHRoZSBmYWN0IHdlIGhhdmUgb25seSBhIGxpbWl0ZWQKLSAqIG51bWJlciBvZiBETUEgY2hhbm5lbHMsIGFuZCBub3Qgb2YgYWxsIG9mIHRoZW0gKGRlcGVuZGFudCBvbiB0aGUgZGV2aWNlKQorICogbnVtYmVyIG9mIERNQSBjaGFubmVscywgYW5kIG5vdCBvZiBhbGwgb2YgdGhlbSAoZGVwZW5kZW50IG9uIHRoZSBkZXZpY2UpCiAgKiBjYW4gYmUgYXR0YWNoZWQgdG8gYW55IERNQSBzb3VyY2UuIFdlIHRoZXJlZm9yZSBsZXQgdGhlIERNQSBjb3JlIGhhbmRsZQogICogdGhlIGFsbG9jYXRpb24gb2YgaGFyZHdhcmUgY2hhbm5lbHMgdG8gY2xpZW50cy4KICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzI0MTAvaW5jbHVkZS9tYWNoL3JlZ3MtbWVtLmggYi9hcmNoL2FybS9tYWNoLXMzYzI0MTAvaW5jbHVkZS9tYWNoL3JlZ3MtbWVtLmgKaW5kZXggN2Y3YzUyOS4uOTg4YTY4NiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9yZWdzLW1lbS5oCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvcmVncy1tZW0uaApAQCAtMTAxLDcgKzEwMSw3IEBACiAjZGVmaW5lIFMzQzI0MTBfQkFOS0NPTl9QTUMxNgkJKDB4MDMpCiAKIC8qIGJhbmsgY29uZmlndXJhdGlvbnMgZm9yIGJhbmtzIDAuLjcsIG5vdGUgYmFua3MKLSAqIDYgYW5kIDcgaGF2ZSBkaWZmZXJudCBjb25maWd1cmF0aW9ucyBkZXBlbmRpbmcgb24KKyAqIDYgYW5kIDcgaGF2ZSBkaWZmZXJlbnQgY29uZmlndXJhdGlvbnMgZGVwZW5kaW5nIG9uCiAgKiB0aGUgbWVtb3J5IHR5cGUgYml0cyAqLwogCiAjZGVmaW5lIFMzQzI0MTBfQkFOS0NPTl9UYWNwMgkJKDB4MCA8PCAyKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL21hY2gtbjMwLmMgYi9hcmNoL2FybS9tYWNoLXMzYzI0MTAvbWFjaC1uMzAuYwppbmRleCA2NmY0NDQ0Li4wNzlkY2FhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzI0MTAvbWFjaC1uMzAuYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzI0MTAvbWFjaC1uMzAuYwpAQCAtMjUyLDcgKzI1Miw3IEBACiAJLmRlZl90cmlnZ2VyCT0gIiIsCiB9OwogCi0vKiBUaGlzIGlzIHRoZSBibHVlIExFRCBvbiB0aGUgZGV2aWNlLiBPcmlnaW5hbHkgdXNlZCB0byBpbmRpY2F0ZSBHUFMgYWN0aXZpdHkKKy8qIFRoaXMgaXMgdGhlIGJsdWUgTEVEIG9uIHRoZSBkZXZpY2UuIE9yaWdpbmFsbHkgdXNlZCB0byBpbmRpY2F0ZSBHUFMgYWN0aXZpdHkKICAqIGJ5IGZsYXNoaW5nLiAqLwogc3RhdGljIHN0cnVjdCBzM2MyNHh4X2xlZF9wbGF0ZGF0YSBuMzVfYmx1ZV9sZWRfcGRhdGEgPSB7CiAJLm5hbWUJCT0gImJsdWVfbGVkIiwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQ0MC9tYWNoLW1pbmkyNDQwLmMgYi9hcmNoL2FybS9tYWNoLXMzYzI0NDAvbWFjaC1taW5pMjQ0MC5jCmluZGV4IGRmZWRjOWMuLmRkMzEyMGQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQ0MC9tYWNoLW1pbmkyNDQwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQwL21hY2gtbWluaTI0NDAuYwpAQCAtMTU1LDcgKzE1NSw3IEBACiAJICogdGhlIHNhbWUgdGltaW5ncywgaG93ZXZlciwgYW55dGhpbmcgc21hbGxlciB0aGFuIDEwMjR4NzY4CiAJICogd2lsbCBvbmx5IGJlIGRpc3BsYXllZCBpbiB0aGUgdG9wIGxlZnQgY29ybmVyIG9mIGEgMTAyNHg3NjgKIAkgKiBYR0Egb3V0cHV0IHVubGVzcyB5b3UgYWRkIG9wdGlvbmFsIGRpcCBzd2l0Y2hlcyB0byB0aGUgc2hpZWxkLgotCSAqIFRoZXJlZm9yZSB0aW1pbmdzIGZvciBvdGhlciByZXNvbHV0aW9ucyBoYXZlIGJlZW4gb21taXRlZCBoZXJlLgorCSAqIFRoZXJlZm9yZSB0aW1pbmdzIGZvciBvdGhlciByZXNvbHV0aW9ucyBoYXZlIGJlZW4gb21pdHRlZCBoZXJlLgogCSAqLwogCVsyXSA9IHsKIAkJX0xDRF9ERUNMQVJFKApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2RtYS5jIGIvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2RtYS5jCmluZGV4IGMzNTU4NWMuLmIxOTcxNzEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjNjR4eC9kbWEuYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzY0eHgvZG1hLmMKQEAgLTMxNSw3ICszMTUsNyBAQAogCWNhc2UgUzNDMjQxMF9ETUFPUF9GTFVTSDoKIAkJcmV0dXJuIHMzYzY0eHhfZG1hX2ZsdXNoKGNoYW4pOwogCi0JLyogYmVsaXZlIFBBVVNFL1JFU1VNRSBhcmUgbm8tb3BzICovCisJLyogYmVsaWV2ZSBQQVVTRS9SRVNVTUUgYXJlIG5vLW9wcyAqLwogCWNhc2UgUzNDMjQxMF9ETUFPUF9QQVVTRToKIAljYXNlIFMzQzI0MTBfRE1BT1BfUkVTVU1FOgogCWNhc2UgUzNDMjQxMF9ETUFPUF9TVEFSVEVEOgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL2luY2x1ZGUvbWFjaC9yZWdzLWZiLmggYi9hcmNoL2FybS9tYWNoLXM1cGMxMDAvaW5jbHVkZS9tYWNoL3JlZ3MtZmIuaAppbmRleCA0YmU0Y2M5Li4wN2FhNGQ2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cGMxMDAvaW5jbHVkZS9tYWNoL3JlZ3MtZmIuaAorKysgYi9hcmNoL2FybS9tYWNoLXM1cGMxMDAvaW5jbHVkZS9tYWNoL3JlZ3MtZmIuaApAQCAtMjksNyArMjksNyBAQAogI2RlZmluZSBXUEFMQ09OX0gJCQkJCSgweDE5YykKICNkZWZpbmUgV1BBTENPTl9MCQkJCQkoMHgxYTApCiAKLS8qIFBhbGxldGUgY29udHJvIGZvciBXUEFMMCBhbmQgV1BBTDEgaXMgdGhlIHNhbWUgYXMgaW4gUzNDNjR4eCwgYnV0CisvKiBQYWxldHRlIGNvbnRyb2wgZm9yIFdQQUwwIGFuZCBXUEFMMSBpcyB0aGUgc2FtZSBhcyBpbiBTM0M2NHh4LCBidXQKICAqIGRpZmZlcmVudCBmb3IgV1BBTDItNAogICovCiAvKiBJbiBXUEFMQ09OX0wgKGFrYSBXUEFMQ09OKSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL3NldHVwLXNkaGNpLmMgYi9hcmNoL2FybS9tYWNoLXM1cGMxMDAvc2V0dXAtc2RoY2kuYwppbmRleCBmMTY5NDZlLi5iZTI1ODc5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cGMxMDAvc2V0dXAtc2RoY2kuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cGMxMDAvc2V0dXAtc2RoY2kuYwpAQCAtNDAsNyArNDAsNyBAQAogewogCXUzMiBjdHJsMiwgY3RybDM7CiAKLQkvKiBkb24ndCBuZWVkIHRvIGFsdGVyIGFueXRoaW5nIGFjb3JkaW5nIHRvIGNhcmQtdHlwZSAqLworCS8qIGRvbid0IG5lZWQgdG8gYWx0ZXIgYW55dGhpbmcgYWNjb3JkaW5nIHRvIGNhcmQtdHlwZSAqLwogCiAJd3JpdGVsKFMzQzY0WFhfU0RIQ0lfQ09OVFJPTDRfRFJJVkVfOW1BLCByICsgUzNDNjRYWF9TREhDSV9DT05UUk9MNCk7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjIxMC9pbmNsdWRlL21hY2gvZ3Bpby5oIGIvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2luY2x1ZGUvbWFjaC9ncGlvLmgKaW5kZXggMWY0YjU5NS4uYTVhMWUzMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2luY2x1ZGUvbWFjaC9ncGlvLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2luY2x1ZGUvbWFjaC9ncGlvLmgKQEAgLTE4LDcgKzE4LDcgQEAKICNkZWZpbmUgZ3Bpb19jYW5zbGVlcAlfX2dwaW9fY2Fuc2xlZXAKICNkZWZpbmUgZ3Bpb190b19pcnEJX19ncGlvX3RvX2lycQogCi0vKiBQcmFjdGljYWxseSwgR1BJTyBiYW5rcyB1cHRvIE1QMDMgYXJlIHRoZSBjb25maWd1cmFibGUgZ3BpbyBiYW5rcyAqLworLyogUHJhY3RpY2FsbHksIEdQSU8gYmFua3MgdXAgdG8gTVAwMyBhcmUgdGhlIGNvbmZpZ3VyYWJsZSBncGlvIGJhbmtzICovCiAKIC8qIEdQSU8gYmFuayBzaXplcyAqLwogI2RlZmluZSBTNVBWMjEwX0dQSU9fQTBfTlIJKDgpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvc2V0dXAtc2RoY2ktZ3Bpby5jIGIvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL3NldHVwLXNkaGNpLWdwaW8uYwppbmRleCA3NDY3NzdkLi4zZTNhYzA1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvc2V0dXAtc2RoY2ktZ3Bpby5jCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9zZXR1cC1zZGhjaS1ncGlvLmMKQEAgLTMyLDEwICszMiwxMCBAQAogCiAJc3dpdGNoICh3aWR0aCkgewogCWNhc2UgODoKLQkJLyogR1BHMVszOjZdIHNwZWNpYWwtZnVudGlvbiAzICovCisJCS8qIEdQRzFbMzo2XSBzcGVjaWFsLWZ1bmN0aW9uIDMgKi8KIAkJczNjX2dwaW9fY2ZncmFuZ2Vfbm9wdWxsKFM1UFYyMTBfR1BHMSgzKSwgNCwgUzNDX0dQSU9fU0ZOKDMpKTsKIAljYXNlIDQ6Ci0JCS8qIEdQRzBbMzo2XSBzcGVjaWFsLWZ1bnRpb24gMiAqLworCQkvKiBHUEcwWzM6Nl0gc3BlY2lhbC1mdW5jdGlvbiAyICovCiAJCXMzY19ncGlvX2NmZ3JhbmdlX25vcHVsbChTNVBWMjEwX0dQRzAoMyksIDQsIFMzQ19HUElPX1NGTigyKSk7CiAJZGVmYXVsdDoKIAkJYnJlYWs7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvc2V0dXAtc2RoY2kuYyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9zZXR1cC1zZGhjaS5jCmluZGV4IGMzMmUyMDIuLmE4M2I2YzkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjIxMC9zZXR1cC1zZGhjaS5jCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9zZXR1cC1zZGhjaS5jCkBAIC0zOCw3ICszOCw3IEBACiB7CiAJdTMyIGN0cmwyLCBjdHJsMzsKIAotCS8qIGRvbid0IG5lZWQgdG8gYWx0ZXIgYW55dGhpbmcgYWNvcmRpbmcgdG8gY2FyZC10eXBlICovCisJLyogZG9uJ3QgbmVlZCB0byBhbHRlciBhbnl0aGluZyBhY2NvcmRpbmcgdG8gY2FyZC10eXBlICovCiAKIAl3cml0ZWwoUzNDNjRYWF9TREhDSV9DT05UUk9MNF9EUklWRV85bUEsIHIgKyBTM0M2NFhYX1NESENJX0NPTlRST0w0KTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zYTExMDAvTWFrZWZpbGUgYi9hcmNoL2FybS9tYWNoLXNhMTEwMC9NYWtlZmlsZQppbmRleCBlNjk3NjkxLi40MTI1MmQyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNhMTEwMC9NYWtlZmlsZQorKysgYi9hcmNoL2FybS9tYWNoLXNhMTEwMC9NYWtlZmlsZQpAQCAtNTAsNyArNTAsNyBAQAogIyBMRURzIHN1cHBvcnQKIG9iai0kKENPTkZJR19MRURTKSArPSAkKGxlZC15KQogCi0jIE1pc2NlbGFuZW91cyBmdW5jdGlvbnMKKyMgTWlzY2VsbGFuZW91cyBmdW5jdGlvbnMKIG9iai0kKENPTkZJR19QTSkJCQkrPSBwbS5vIHNsZWVwLm8KIG9iai0kKENPTkZJR19TQTExMDBfU1NQKQkJKz0gc3NwLm8KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zYTExMDAvY3B1LXNhMTEwMC5jIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvY3B1LXNhMTEwMC5jCmluZGV4IDA3ZDRlOGIuLmFhYThhY2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL2NwdS1zYTExMDAuYworKysgYi9hcmNoL2FybS9tYWNoLXNhMTEwMC9jcHUtc2ExMTAwLmMKQEAgLTY4LDcgKzY4LDcgQEAKICAqIGNsb2NrIGNoYW5nZSBpbiBST00gYW5kIGp1bXAgdG8gdGhhdCBjb2RlIGZyb20gdGhlIGtlcm5lbC4gVGhlIG1haW4KICAqIGRpc2FkdmFudGFnZSBpcyB0aGF0IHRoZSBST00gaGFzIHRvIGJlIG1vZGlmaWVkLCB3aGljaCBpcyBub3QKICAqIHBvc3NpYmxlIG9uIGFsbCBTQS0xMTAwIHBsYXRmb3Jtcy4gQW5vdGhlciBkaXNhZHZhbnRhZ2UgaXMgdGhhdAotICoganVtcGluZyB0byBST00gbWFrZXMgY2xvY2sgc3dpdGNoaW5nIHVuZWNlc3NhcnkgY29tcGxpY2F0ZWQuCisgKiBqdW1waW5nIHRvIFJPTSBtYWtlcyBjbG9jayBzd2l0Y2hpbmcgdW5uZWNlc3NhcnkgY29tcGxpY2F0ZWQuCiAgKgogICogVGhlIGlkZWEgYmVoaW5kIHRoaXMgZHJpdmVyIGlzIHRoYXQgdGhlIG1lbW9yeSBjb25maWd1cmF0aW9uIGNhbiBiZQogICogY2hhbmdlZCB3aGlsZSBydW5uaW5nIGZyb20gRFJBTSAoZXZlbiB3aXRoIGludGVycnVwdHMgdHVybmVkIG9uISkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL2luY2x1ZGUvbWFjaC9TQS0xMTAwLmggYi9hcmNoL2FybS9tYWNoLXNhMTEwMC9pbmNsdWRlL21hY2gvU0EtMTEwMC5oCmluZGV4IDRmN2VhMDEuLmJhZTgyOTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL2luY2x1ZGUvbWFjaC9TQS0xMTAwLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvaW5jbHVkZS9tYWNoL1NBLTExMDAuaApAQCAtMTc5NCw3ICsxNzk0LDcgQEAKICAgICAgICAgICAgICAgICAJKEREQVJfRGV2UmQgKyBEREFSX0Jyc3Q0ICsgRERBUl8xNkJpdERldiArIFwKICAgICAgICAgICAgICAgICAJIEREQVJfU2VyNFNTUFJjICsgRERBUl9EZXZBZGQgKF9fUFJFRyhTZXI0U1NEUikpKQogCi0jZGVmaW5lIERDU1JfUlVOCTB4MDAwMDAwMDEJLyogRE1BIFJVTmluZyAgICAgICAgICAgICAgICAgICAgICAqLworI2RlZmluZSBEQ1NSX1JVTgkweDAwMDAwMDAxCS8qIERNQSBydW5uaW5nICAgICAgICAgICAgICAgICAgICAgKi8KICNkZWZpbmUgRENTUl9JRSAJMHgwMDAwMDAwMgkvKiBETUEgSW50ZXJydXB0IEVuYWJsZSAgICAgICAgICAgICovCiAjZGVmaW5lIERDU1JfRVJST1IJMHgwMDAwMDAwNAkvKiBETUEgRVJST1IgICAgICAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIERDU1JfRE9ORUEJMHgwMDAwMDAwOAkvKiBET05FIERNQSB0cmFuc2ZlciBidWZmZXIgQSAgICAgICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNhMTEwMC9qb3JuYWRhNzIwX3NzcC5jIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvam9ybmFkYTcyMF9zc3AuYwppbmRleCA5ZDQ5MGM2Li5mNTBiMDBiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNhMTEwMC9qb3JuYWRhNzIwX3NzcC5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2ExMTAwL2pvcm5hZGE3MjBfc3NwLmMKQEAgLTI5LDcgKzI5LDcgQEAKIC8qKgogICogam9ybmFkYV9zc3BfcmV2ZXJzZSAtIHJldmVyc2VzIGlucHV0IGJ5dGUKICAqCi0gKiB3ZSBuZWVkIHRvIHJldmVyc2UgYWxsIGRhdGEgd2UgcmVjaWV2ZSBmcm9tIHRoZSBtY3UgZHVlIHRvIGl0cyBwaHlzaWNhbCBsb2NhdGlvbgorICogd2UgbmVlZCB0byByZXZlcnNlIGFsbCBkYXRhIHdlIHJlY2VpdmUgZnJvbSB0aGUgbWN1IGR1ZSB0byBpdHMgcGh5c2ljYWwgbG9jYXRpb24KICAqIHJldHVybnMgOiAwMTExMDExMSAtPiAxMTEwMTExMAogICovCiB1OCBpbmxpbmUgam9ybmFkYV9zc3BfcmV2ZXJzZSh1OCBieXRlKQpAQCAtMTc5LDcgKzE3OSw3IEBACiAKIHN0YXRpYyBpbnQgam9ybmFkYV9zc3BfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldikKIHsKLQkvKiBOb3RlIHRoYXQgdGhpcyBkb2VzbnQgYWN0dWFsbHkgcmVtb3ZlIHRoZSBkcml2ZXIsIHNpbmNlIHRoZXJlcyBub3RoaW5nIHRvIHJlbW92ZQorCS8qIE5vdGUgdGhhdCB0aGlzIGRvZXNuJ3QgYWN0dWFsbHkgcmVtb3ZlIHRoZSBkcml2ZXIsIHNpbmNlIHRoZXJlcyBub3RoaW5nIHRvIHJlbW92ZQogCSAqIEl0IGp1c3QgbWFrZXMgc3VyZSBldmVyeXRoaW5nIGlzIHR1cm5lZCBvZmYgKi8KIAlHUFNSID0gR1BJT19HUElPMjU7CiAJc3NwX2V4aXQoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtYXA0ZXZiLmMgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLWFwNGV2Yi5jCmluZGV4IDc4M2I2NmYuLjFlMzVmYTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtYXA0ZXZiLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1hcDRldmIuYwpAQCAtOTQ3LDcgKzk0Nyw3IEBACiAJJmFwNGV2Yl9jYW1lcmEsCiB9OwogCi1zdGF0aWMgaW50IF9faW5pdCBoZG1pX2luaXRfcG1fY2xvY2sodm9pZCkKK3N0YXRpYyB2b2lkIF9faW5pdCBoZG1pX2luaXRfcG1fY2xvY2sodm9pZCkKIHsKIAlzdHJ1Y3QgY2xrICpoZG1pX2ljayA9IGNsa19nZXQoJmhkbWlfZGV2aWNlLmRldiwgImljayIpOwogCWludCByZXQ7CkBAIC05ODgsMjAgKzk4OCwxNSBAQAogCXByX2RlYnVnKCJQTExDMiBzZXQgZnJlcXVlbmN5ICVsdVxuIiwgcmF0ZSk7CiAKIAlyZXQgPSBjbGtfc2V0X3BhcmVudChoZG1pX2ljaywgJnNoNzM3Ml9wbGxjMl9jbGspOwotCWlmIChyZXQgPCAwKSB7CisJaWYgKHJldCA8IDApCiAJCXByX2VycigiQ2Fubm90IHNldCBIRE1JIHBhcmVudDogJWRcbiIsIHJldCk7Ci0JCWdvdG8gb3V0OwotCX0KIAogb3V0OgogCWlmICghSVNfRVJSKGhkbWlfaWNrKSkKIAkJY2xrX3B1dChoZG1pX2ljayk7Ci0JcmV0dXJuIHJldDsKIH0KIAotZGV2aWNlX2luaXRjYWxsKGhkbWlfaW5pdF9wbV9jbG9jayk7Ci0KLXN0YXRpYyBpbnQgX19pbml0IGZzaV9pbml0X3BtX2Nsb2NrKHZvaWQpCitzdGF0aWMgdm9pZCBfX2luaXQgZnNpX2luaXRfcG1fY2xvY2sodm9pZCkKIHsKIAlzdHJ1Y3QgY2xrICpmc2lhX2ljazsKIAlpbnQgcmV0OwpAQCAtMTAxMCw3ICsxMDA1LDcgQEAKIAlpZiAoSVNfRVJSKGZzaWFfaWNrKSkgewogCQlyZXQgPSBQVFJfRVJSKGZzaWFfaWNrKTsKIAkJcHJfZXJyKCJDYW5ub3QgZ2V0IEZTSSBJQ0s6ICVkXG4iLCByZXQpOwotCQlyZXR1cm4gcmV0OworCQlyZXR1cm47CiAJfQogCiAJcmV0ID0gY2xrX3NldF9wYXJlbnQoZnNpYV9pY2ssICZzaDczNzJfZnNpYWNrX2Nsayk7CkBAIC0xMDE4LDEwICsxMDEzLDcgQEAKIAkJcHJfZXJyKCJDYW5ub3Qgc2V0IEZTSS1BIHBhcmVudDogJWRcbiIsIHJldCk7CiAKIAljbGtfcHV0KGZzaWFfaWNrKTsKLQotCXJldHVybiByZXQ7CiB9Ci1kZXZpY2VfaW5pdGNhbGwoZnNpX2luaXRfcG1fY2xvY2spOwogCiAvKgogICogRklYTUUgISEKQEAgLTEzNDgsNiArMTM0MCw5IEBACiAJX19yYXdfd3JpdGVsKHNyY3I0ICYgfigxIDw8IDEzKSwgU1JDUjQpOwogCiAJcGxhdGZvcm1fYWRkX2RldmljZXMoYXA0ZXZiX2RldmljZXMsIEFSUkFZX1NJWkUoYXA0ZXZiX2RldmljZXMpKTsKKworCWhkbWlfaW5pdF9wbV9jbG9jaygpOworCWZzaV9pbml0X3BtX2Nsb2NrKCk7CiB9CiAKIHN0YXRpYyB2b2lkIF9faW5pdCBhcDRldmJfdGltZXJfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1tYWNrZXJlbC5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1tYWNrZXJlbC5jCmluZGV4IDgxODRkNGQuLjdkYTJjYTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtbWFja2VyZWwuYworKysgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLW1hY2tlcmVsLmMKQEAgLTQyMyw3ICs0MjMsNyBAQAogCS5uYW1lCQk9ICJzaF9mc2kyX2JfaGRtaSIsCiB9OwogCi1zdGF0aWMgaW50IF9faW5pdCBoZG1pX2luaXRfcG1fY2xvY2sodm9pZCkKK3N0YXRpYyB2b2lkIF9faW5pdCBoZG1pX2luaXRfcG1fY2xvY2sodm9pZCkKIHsKIAlzdHJ1Y3QgY2xrICpoZG1pX2ljayA9IGNsa19nZXQoJmhkbWlfZGV2aWNlLmRldiwgImljayIpOwogCWludCByZXQ7CkBAIC00NjcsMTcgKzQ2NywxMyBAQAogCXByX2RlYnVnKCJQTExDMiBzZXQgZnJlcXVlbmN5ICVsdVxuIiwgcmF0ZSk7CiAKIAlyZXQgPSBjbGtfc2V0X3BhcmVudChoZG1pX2ljaywgJnNoNzM3Ml9wbGxjMl9jbGspOwotCWlmIChyZXQgPCAwKSB7CisJaWYgKHJldCA8IDApCiAJCXByX2VycigiQ2Fubm90IHNldCBIRE1JIHBhcmVudDogJWRcbiIsIHJldCk7Ci0JCWdvdG8gb3V0OwotCX0KIAogb3V0OgogCWlmICghSVNfRVJSKGhkbWlfaWNrKSkKIAkJY2xrX3B1dChoZG1pX2ljayk7Ci0JcmV0dXJuIHJldDsKIH0KLWRldmljZV9pbml0Y2FsbChoZG1pX2luaXRfcG1fY2xvY2spOwogCiAvKiBVU0IxIChIb3N0KSAqLwogc3RhdGljIHZvaWQgdXNiMV9ob3N0X3BvcnRfcG93ZXIoaW50IHBvcnQsIGludCBwb3dlcikKQEAgLTEyMTgsNiArMTIxNCw4IEBACiAJc2g3MzcyX2FkZF9zdGFuZGFyZF9kZXZpY2VzKCk7CiAKIAlwbGF0Zm9ybV9hZGRfZGV2aWNlcyhtYWNrZXJlbF9kZXZpY2VzLCBBUlJBWV9TSVpFKG1hY2tlcmVsX2RldmljZXMpKTsKKworCWhkbWlfaW5pdF9wbV9jbG9jaygpOwogfQogCiBzdGF0aWMgdm9pZCBfX2luaXQgbWFja2VyZWxfdGltZXJfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9pbmNsdWRlL21hY2gvbW1jLmggYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2luY2x1ZGUvbWFjaC9tbWMuaAppbmRleCBlMTE1NjBhLi4yMWE1OWRiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2luY2x1ZGUvbWFjaC9tbWMuaAorKysgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2luY2x1ZGUvbWFjaC9tbWMuaApAQCAtOSw3ICs5LDcgQEAKIAogI2lmZGVmIENPTkZJR19NQUNIX0FQNEVWQgogI2luY2x1ZGUgIm1hY2gvbW1jLWFwNGViLmgiCi0jZWxpZiBDT05GSUdfTUFDSF9NQUNLRVJFTAorI2VsaWYgZGVmaW5lZChDT05GSUdfTUFDSF9NQUNLRVJFTCkKICNpbmNsdWRlICJtYWNoL21tYy1tYWNrZXJlbC5oIgogI2Vsc2UKICNlcnJvciAidW5zdXBwb3J0ZWQgYm9hcmQuIgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9pbmNsdWRlL21hY2gvemJvb3QuaCBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvaW5jbHVkZS9tYWNoL3pib290LmgKaW5kZXggNmQ2YTIwNS4uOTMyMGFmZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9pbmNsdWRlL21hY2gvemJvb3QuaAorKysgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2luY2x1ZGUvbWFjaC96Ym9vdC5oCkBAIC0xMyw3ICsxMyw3IEBACiAjaWZkZWYgQ09ORklHX01BQ0hfQVA0RVZCCiAjZGVmaW5lIE1BQ0hfVFlQRQlNQUNIX1RZUEVfQVA0RVZCCiAjaW5jbHVkZSAibWFjaC9oZWFkLWFwNGV2Yi50eHQiCi0jZWxpZiBDT05GSUdfTUFDSF9NQUNLRVJFTAorI2VsaWYgZGVmaW5lZChDT05GSUdfTUFDSF9NQUNLRVJFTCkKICNkZWZpbmUgTUFDSF9UWVBFCU1BQ0hfVFlQRV9NQUNLRVJFTAogI2luY2x1ZGUgIm1hY2gvaGVhZC1tYWNrZXJlbC50eHQiCiAjZWxzZQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC10ZWdyYS9kbWEuYyBiL2FyY2gvYXJtL21hY2gtdGVncmEvZG1hLmMKaW5kZXggZTk0NWFlMi4uZjRlZjVlYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC10ZWdyYS9kbWEuYworKysgYi9hcmNoL2FybS9tYWNoLXRlZ3JhL2RtYS5jCkBAIC0yMjMsNyArMjIzLDcgQEAKIAkgKiAgLSBDaGFuZ2UgdGhlIHNvdXJjZSBzZWxlY3RvciB0byBpbnZhbGlkIHRvIHN0b3AgdGhlIERNQSBmcm9tCiAJICogICAgRklGTyB0byBtZW1vcnkuCiAJICogIC0gUmVhZCB0aGUgc3RhdHVzIHJlZ2lzdGVyIHRvIGtub3cgdGhlIG51bWJlciBvZiBwZW5kaW5nCi0JICogICAgYnl0ZXMgdG8gYmUgdHJhbnNmZXJlZC4KKwkgKiAgICBieXRlcyB0byBiZSB0cmFuc2ZlcnJlZC4KIAkgKiAgLSBGaW5hbGx5IHN0b3Agb3IgcHJvZ3JhbSB0aGUgRE1BIHRvIHRoZSBuZXh0IGJ1ZmZlciBpbiB0aGUKIAkgKiAgICBsaXN0LgogCSAqLwpAQCAtMjQ0LDcgKzI0NCw3IEBACiAJaWYgKHN0YXR1cyAmIFNUQV9CVVNZKQogCQlyZXEtPmJ5dGVzX3RyYW5zZmVycmVkIC09IHRvX3RyYW5zZmVyOwogCi0JLyogSW4gY29udGlub3VzIHRyYW5zZmVyIG1vZGUsIERNQSBvbmx5IHRyYWNrcyB0aGUgY291bnQgb2YgdGhlCisJLyogSW4gY29udGludW91cyB0cmFuc2ZlciBtb2RlLCBETUEgb25seSB0cmFja3MgdGhlIGNvdW50IG9mIHRoZQogCSAqIGhhbGYgRE1BIGJ1ZmZlci4gU28sIGlmIHRoZSBETUEgYWxyZWFkeSBmaW5pc2hlZCBoYWxmIHRoZSBETUEKIAkgKiB0aGVuIGFkZCB0aGUgaGFsZiBidWZmZXIgdG8gdGhlIGNvbXBsZXRlZCBjb3VudC4KIAkgKgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC10ZWdyYS9pbmNsdWRlL21hY2gvZG1hLmggYi9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9kbWEuaAppbmRleCAzOTAxMWJkLi5kMDEzMmU4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9kbWEuaAorKysgYi9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9kbWEuaApAQCAtOTIsMTEgKzkyLDExIEBACiAJLyogIFRoaXMgaXMgYSBjYWxsZWQgZnJvbSB0aGUgRE1BIElTUiBjb250ZXh0IHdoZW4gdGhlIERNQSBpcyBzdGlsbCBpbgogCSAqICBwcm9ncmVzcyBhbmQgaXMgYWN0aXZlbHkgZmlsbGluZyBzYW1lIGJ1ZmZlci4KIAkgKgotCSAqICBJbiBjYXNlIG9mIGNvbnRpbm91cyBtb2RlIHJlY2VpdmUsIHRoaXMgdGhyZXNob2xkIGlzIDEvMiB0aGUgYnVmZmVyCisJICogIEluIGNhc2Ugb2YgY29udGludW91cyBtb2RlIHJlY2VpdmUsIHRoaXMgdGhyZXNob2xkIGlzIDEvMiB0aGUgYnVmZmVyCiAJICogIHNpemUuIEluIG90aGVyIGNhc2VzLCB0aGlzIHdpbGwgbm90IGV2ZW4gYmUgY2FsbGVkIGFzIHRoZXJlIGlzIG5vCiAJICogIGhhcmR3YXJlIHN1cHBvcnQgZm9yIGl0LgogCSAqCi0JICogSW4gdGhlIGNhc2Ugb2YgY29udGlub3VzIG1vZGUgcmVjZWl2ZSwgaWYgdGhlcmUgaXMgbmV4dCByZXEgYWxyZWFkeQorCSAqIEluIHRoZSBjYXNlIG9mIGNvbnRpbnVvdXMgbW9kZSByZWNlaXZlLCBpZiB0aGVyZSBpcyBuZXh0IHJlcSBhbHJlYWR5CiAJICogcXVldWVkLCBETUEgcHJvZ3JhbXMgdGhlIEhXIHRvIHVzZSB0aGF0IHJlcSB3aGVuIHRoaXMgcmVxIGlzCiAJICogY29tcGxldGVkLiBJZiB0aGVyZSBpcyBubyAibmV4dCByZXEiIHF1ZXVlZCwgdGhlbiBETUEgSVNSIGRvZXNuJ3QgZG8KIAkgKiBhbnl0aGluZyBiZWZvcmUgY2FsbGluZyB0aGlzIGNhbGxiYWNrLgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC11MzAwL2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLXUzMDAvY2xvY2suYwppbmRleCBmYWJjYzQ5Li41NTM1ZGQwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXUzMDAvY2xvY2suYworKysgYi9hcmNoL2FybS9tYWNoLXUzMDAvY2xvY2suYwpAQCAtMjYzLDcgKzI2Myw3IEBACiAJdmFsID0gcmVhZHcoVTMwMF9TWVNDT05fVkJBU0UgKyBVMzAwX1NZU0NPTl9DQ1IpOwogCXZhbCAmPSB+VTMwMF9TWVNDT05fQ0NSX0kyUzBfVVNFX1ZDWE87CiAJd3JpdGV3KHZhbCwgVTMwMF9TWVNDT05fVkJBU0UgKyBVMzAwX1NZU0NPTl9DQ1IpOwotCS8qIERlYWN0aXZhdGUgVkNYTyBpZiBub29uZSBlbHNlIGlzIHVzaW5nIFZDWE8gKi8KKwkvKiBEZWFjdGl2YXRlIFZDWE8gaWYgbm8gb25lIGVsc2UgaXMgdXNpbmcgVkNYTyAqLwogCWlmICghKHZhbCAmIFUzMDBfU1lTQ09OX0NDUl9JMlMxX1VTRV9WQ1hPKSkKIAkJdmFsICY9IH5VMzAwX1NZU0NPTl9DQ1JfVFVSTl9WQ1hPX09OOwogCXdyaXRldyh2YWwsIFUzMDBfU1lTQ09OX1ZCQVNFICsgVTMwMF9TWVNDT05fQ0NSKTsKQEAgLTI4Myw3ICsyODMsNyBAQAogCXZhbCA9IHJlYWR3KFUzMDBfU1lTQ09OX1ZCQVNFICsgVTMwMF9TWVNDT05fQ0NSKTsKIAl2YWwgJj0gflUzMDBfU1lTQ09OX0NDUl9JMlMxX1VTRV9WQ1hPOwogCXdyaXRldyh2YWwsIFUzMDBfU1lTQ09OX1ZCQVNFICsgVTMwMF9TWVNDT05fQ0NSKTsKLQkvKiBEZWFjdGl2YXRlIFZDWE8gaWYgbm9vbmUgZWxzZSBpcyB1c2luZyBWQ1hPICovCisJLyogRGVhY3RpdmF0ZSBWQ1hPIGlmIG5vIG9uZSBlbHNlIGlzIHVzaW5nIFZDWE8gKi8KIAlpZiAoISh2YWwgJiBVMzAwX1NZU0NPTl9DQ1JfSTJTMF9VU0VfVkNYTykpCiAJCXZhbCAmPSB+VTMwMF9TWVNDT05fQ0NSX1RVUk5fVkNYT19PTjsKIAl3cml0ZXcodmFsLCBVMzAwX1NZU0NPTl9WQkFTRSArIFUzMDBfU1lTQ09OX0NDUik7CkBAIC02NDksNyArNjQ5LDcgQEAKICAqLwogbG9uZyBjbGtfcm91bmRfcmF0ZShzdHJ1Y3QgY2xrICpjbGssIHVuc2lnbmVkIGxvbmcgcmF0ZSkKIHsKLQkvKiBUT0RPOiBnZXQgYXByb3ByaWF0ZSBzd2l0Y2hlcyBmb3IgRU1JRkNMSywgQUhCQ0xLIGFuZCBNQ0xLICovCisJLyogVE9ETzogZ2V0IGFwcHJvcHJpYXRlIHN3aXRjaGVzIGZvciBFTUlGQ0xLLCBBSEJDTEsgYW5kIE1DTEsgKi8KIAkvKiBFbHNlIGRlZmF1bHQgdG8gZml4ZWQgdmFsdWUgKi8KIAogCWlmIChjbGstPnJvdW5kX3JhdGUpIHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtdXg1MDAvYm9hcmQtbW9wNTAwLmMgYi9hcmNoL2FybS9tYWNoLXV4NTAwL2JvYXJkLW1vcDUwMC5jCmluZGV4IGRjODc0NmQuLmFmOTEzNzQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdXg1MDAvYm9hcmQtbW9wNTAwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC11eDUwMC9ib2FyZC1tb3A1MDAuYwpAQCAtNTIsNyArNTIsNyBAQAogCSAqIG9uIHZhbHVlIHByZXNlbnQgaW4gR3Bpb1NlbDEgdG8gR3Bpb1NlbDYgYW5kIEFsdGVybmF0RnVuY3Rpb24KIAkgKiByZWdpc3Rlci4gVGhpcyBpcyB0aGUgYXJyYXkgb2YgNyBjb25maWd1cmF0aW9uIHNldHRpbmdzLgogCSAqIE9uZSBoYXMgdG8gY29tcGlsZSB0aW1lIGRlY2lkZSB0aGVzZSBzZXR0aW5ncy4gQmVsb3cgaXMgdGhlCi0JICogZXhwbGFpbmF0aW9uIG9mIHRoZXNlIHNldHRpbmcKKwkgKiBleHBsYW5hdGlvbiBvZiB0aGVzZSBzZXR0aW5nCiAJICogR3Bpb1NlbDEgPSAweDAwID0+IFBpbnMgR1BJTzEgdG8gR1BJTzggYXJlIG5vdCB1c2VkIGFzIEdQSU8KIAkgKiBHcGlvU2VsMiA9IDB4MUUgPT4gUGlucyBHUElPMTAgdG8gR1BJTzEzIGFyZSBjb25maWd1cmVkIGFzIEdQSU8KIAkgKiBHcGlvU2VsMyA9IDB4ODAgPT4gUGluIEdQSU8yNCBpcyBjb25maWd1cmVkIGFzIEdQSU8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtdXg1MDAvaW5jbHVkZS9tYWNoL2RiODUwMC1yZWdzLmggYi9hcmNoL2FybS9tYWNoLXV4NTAwL2luY2x1ZGUvbWFjaC9kYjg1MDAtcmVncy5oCmluZGV4IDBmZWZiMzQuLjE2NjQ3YjIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdXg1MDAvaW5jbHVkZS9tYWNoL2RiODUwMC1yZWdzLmgKKysrIGIvYXJjaC9hcm0vbWFjaC11eDUwMC9pbmNsdWRlL21hY2gvZGI4NTAwLXJlZ3MuaApAQCAtNTgsNyArNTgsNyBAQAogI2RlZmluZSBVODUwMF9HUElPMl9CQVNFCShVODUwMF9QRVIyX0JBU0UgKyAweEUwMDApCiAjZGVmaW5lIFU4NTAwX0dQSU8zX0JBU0UJKFU4NTAwX1BFUjVfQkFTRSArIDB4MUUwMDApCiAKLS8qIHBlcjcgYmFzZSBhZGRyZXNzZXNzICovCisvKiBwZXI3IGJhc2UgYWRkcmVzc2VzICovCiAjZGVmaW5lIFU4NTAwX0NSX0JBU0VfRUQJKFU4NTAwX1BFUjdfQkFTRV9FRCArIDB4ODAwMCkKICNkZWZpbmUgVTg1MDBfTVRVMF9CQVNFX0VECShVODUwMF9QRVI3X0JBU0VfRUQgKyAweGEwMDApCiAjZGVmaW5lIFU4NTAwX01UVTFfQkFTRV9FRAkoVTg1MDBfUEVSN19CQVNFX0VEICsgMHhiMDAwKQpAQCAtNjgsNyArNjgsNyBAQAogI2RlZmluZSBVODUwMF9VQVJUMF9CQVNFCShVODUwMF9QRVIxX0JBU0UgKyAweDAwMDApCiAjZGVmaW5lIFU4NTAwX1VBUlQxX0JBU0UJKFU4NTAwX1BFUjFfQkFTRSArIDB4MTAwMCkKIAotLyogcGVyNiBiYXNlIGFkZHJlc3Nlc3MgKi8KKy8qIHBlcjYgYmFzZSBhZGRyZXNzZXMgKi8KICNkZWZpbmUgVTg1MDBfUk5HX0JBU0UJCShVODUwMF9QRVI2X0JBU0UgKyAweDAwMDApCiAjZGVmaW5lIFU4NTAwX1BLQV9CQVNFCQkoVTg1MDBfUEVSNl9CQVNFICsgMHgxMDAwKQogI2RlZmluZSBVODUwMF9QS0FNX0JBU0UJCShVODUwMF9QRVI2X0JBU0UgKyAweDIwMDApCkBAIC03OSwxMSArNzksMTEgQEAKICNkZWZpbmUgVTg1MDBfQ1JZUFRPMV9CQVNFCShVODUwMF9QRVI2X0JBU0UgKyAweGIwMDApCiAjZGVmaW5lIFU4NTAwX0NMS1JTVDZfQkFTRQkoVTg1MDBfUEVSNl9CQVNFICsgMHhmMDAwKQogCi0vKiBwZXI1IGJhc2UgYWRkcmVzc2VzcyAqLworLyogcGVyNSBiYXNlIGFkZHJlc3NlcyAqLwogI2RlZmluZSBVODUwMF9VU0JPVEdfQkFTRQkoVTg1MDBfUEVSNV9CQVNFICsgMHgwMDAwMCkKICNkZWZpbmUgVTg1MDBfQ0xLUlNUNV9CQVNFCShVODUwMF9QRVI1X0JBU0UgKyAweDFmMDAwKQogCi0vKiBwZXI0IGJhc2UgYWRkcmVzc2VzcyAqLworLyogcGVyNCBiYXNlIGFkZHJlc3NlcyAqLwogI2RlZmluZSBVODUwMF9CQUNLVVBSQU0wX0JBU0UJKFU4NTAwX1BFUjRfQkFTRSArIDB4MDAwMDApCiAjZGVmaW5lIFU4NTAwX0JBQ0tVUFJBTTFfQkFTRQkoVTg1MDBfUEVSNF9CQVNFICsgMHgwMTAwMCkKICNkZWZpbmUgVTg1MDBfUlRUMF9CQVNFCQkoVTg1MDBfUEVSNF9CQVNFICsgMHgwMjAwMCkKQEAgLTEwNiw3ICsxMDYsNyBAQAogI2RlZmluZSBVODUwMF9TREk1X0JBU0UJCShVODUwMF9QRVIzX0JBU0UgKyAweDgwMDApCiAjZGVmaW5lIFU4NTAwX0NMS1JTVDNfQkFTRQkoVTg1MDBfUEVSM19CQVNFICsgMHhmMDAwKQogCi0vKiBwZXIyIGJhc2UgYWRkcmVzc2VzcyAqLworLyogcGVyMiBiYXNlIGFkZHJlc3NlcyAqLwogI2RlZmluZSBVODUwMF9JMkMzX0JBU0UJCShVODUwMF9QRVIyX0JBU0UgKyAweDAwMDApCiAjZGVmaW5lIFU4NTAwX1NQSTJfQkFTRQkJKFU4NTAwX1BFUjJfQkFTRSArIDB4MTAwMCkKICNkZWZpbmUgVTg1MDBfU1BJMV9CQVNFCQkoVTg1MDBfUEVSMl9CQVNFICsgMHgyMDAwKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vY2FjaGUtdjR3Yi5TIGIvYXJjaC9hcm0vbW0vY2FjaGUtdjR3Yi5TCmluZGV4IGQzNjQ0ZGIuLmY0MGM2OTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL2NhY2hlLXY0d2IuUworKysgYi9hcmNoL2FybS9tbS9jYWNoZS12NHdiLlMKQEAgLTMyLDcgKzMyLDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBzaXplIGF0IHdoaWNoIGl0IGJlY29tZXMgbW9yZSBlZmZpY2llbnQgdG8KICAqIGNsZWFuIHRoZSB3aG9sZSBjYWNoZSwgcmF0aGVyIHRoYW4gdXNpbmcgdGhlIGluZGl2aWR1YWwKLSAqIGNhY2hlIGxpbmUgbWFpbnRhaW5lbmNlIGluc3RydWN0aW9ucy4KKyAqIGNhY2hlIGxpbmUgbWFpbnRlbmFuY2UgaW5zdHJ1Y3Rpb25zLgogICoKICAqICBTaXplICBDbGVhbiAodGlja3MpIERpcnR5ICh0aWNrcykKICAqICAgNDA5NiAgIDIxICAyMCAgMjEgICAgNTMgIDU1ICA1NApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vY2FjaGUtdjR3dC5TIGIvYXJjaC9hcm0vbW0vY2FjaGUtdjR3dC5TCmluZGV4IDQ5YzJiNjYuLmE3YjI3NmQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL2NhY2hlLXY0d3QuUworKysgYi9hcmNoL2FybS9tbS9jYWNoZS12NHd0LlMKQEAgLTM0LDcgKzM0LDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBzaXplIGF0IHdoaWNoIGl0IGJlY29tZXMgbW9yZSBlZmZpY2llbnQgdG8KICAqIGNsZWFuIHRoZSB3aG9sZSBjYWNoZSwgcmF0aGVyIHRoYW4gdXNpbmcgdGhlIGluZGl2aWR1YWwKLSAqIGNhY2hlIGxpbmUgbWFpbnRhaW5lbmNlIGluc3RydWN0aW9ucy4KKyAqIGNhY2hlIGxpbmUgbWFpbnRlbmFuY2UgaW5zdHJ1Y3Rpb25zLgogICoKICAqICoqKiBUaGlzIG5lZWRzIGJlbmNobWFya2luZwogICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9jYWNoZS12Ny5TIGIvYXJjaC9hcm0vbW0vY2FjaGUtdjcuUwppbmRleCA2MTM2ZTY4Li5kYzE4ZDgxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9jYWNoZS12Ny5TCisrKyBiL2FyY2gvYXJtL21tL2NhY2hlLXY3LlMKQEAgLTk2LDcgKzk2LDcgQEAKICAqCUZsdXNoIHRoZSBlbnRpcmUgY2FjaGUgc3lzdGVtLgogICogIFRoZSBkYXRhIGNhY2hlIGZsdXNoIGlzIG5vdyBhY2hpZXZlZCB1c2luZyBhdG9taWMgY2xlYW4gLyBpbnZhbGlkYXRlcwogICogIHdvcmtpbmcgb3V0d2FyZHMgZnJvbSBMMSBjYWNoZS4gVGhpcyBpcyBkb25lIHVzaW5nIFNldC9XYXkgYmFzZWQgY2FjaGUKLSAqICBtYWludGFpbmFuY2UgaW5zdHJ1Y3Rpb25zLgorICogIG1haW50ZW5hbmNlIGluc3RydWN0aW9ucy4KICAqICBUaGUgaW5zdHJ1Y3Rpb24gY2FjaGUgY2FuIHN0aWxsIGJlIGludmFsaWRhdGVkIGJhY2sgdG8gdGhlIHBvaW50IG9mCiAgKiAgdW5pZmljYXRpb24gaW4gYSBzaW5nbGUgaW5zdHJ1Y3Rpb24uCiAgKgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vcHJvYy1hcm0xMDIwLlMgYi9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjAuUwppbmRleCAyMjZlM2Q4Li42YzRlN2ZkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjAuUworKysgYi9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjAuUwpAQCAtNjQsNyArNjQsNyBAQAogLyoKICAqIFRoaXMgaXMgdGhlIHNpemUgYXQgd2hpY2ggaXQgYmVjb21lcyBtb3JlIGVmZmljaWVudCB0bwogICogY2xlYW4gdGhlIHdob2xlIGNhY2hlLCByYXRoZXIgdGhhbiB1c2luZyB0aGUgaW5kaXZpZHVhbAotICogY2FjaGUgbGluZSBtYWludGFpbmVuY2UgaW5zdHJ1Y3Rpb25zLgorICogY2FjaGUgbGluZSBtYWludGVuYW5jZSBpbnN0cnVjdGlvbnMuCiAgKi8KICNkZWZpbmUgQ0FDSEVfRExJTUlUCTMyNzY4CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL3Byb2MtYXJtMTAyMGUuUyBiL2FyY2gvYXJtL21tL3Byb2MtYXJtMTAyMGUuUwppbmRleCA4NmQ5YzJjLi40Y2U5NDdjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjBlLlMKKysrIGIvYXJjaC9hcm0vbW0vcHJvYy1hcm0xMDIwZS5TCkBAIC02NCw3ICs2NCw3IEBACiAvKgogICogVGhpcyBpcyB0aGUgc2l6ZSBhdCB3aGljaCBpdCBiZWNvbWVzIG1vcmUgZWZmaWNpZW50IHRvCiAgKiBjbGVhbiB0aGUgd2hvbGUgY2FjaGUsIHJhdGhlciB0aGFuIHVzaW5nIHRoZSBpbmRpdmlkdWFsCi0gKiBjYWNoZSBsaW5lIG1haW50YWluZW5jZSBpbnN0cnVjdGlvbnMuCisgKiBjYWNoZSBsaW5lIG1haW50ZW5hbmNlIGluc3RydWN0aW9ucy4KICAqLwogI2RlZmluZSBDQUNIRV9ETElNSVQJMzI3NjgKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vcHJvYy1hcm0xMDIyLlMgYi9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjIuUwppbmRleCA4M2QzZGQzLi5jODg4NGM1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjIuUworKysgYi9hcmNoL2FybS9tbS9wcm9jLWFybTEwMjIuUwpAQCAtNTMsNyArNTMsNyBAQAogLyoKICAqIFRoaXMgaXMgdGhlIHNpemUgYXQgd2hpY2ggaXQgYmVjb21lcyBtb3JlIGVmZmljaWVudCB0bwogICogY2xlYW4gdGhlIHdob2xlIGNhY2hlLCByYXRoZXIgdGhhbiB1c2luZyB0aGUgaW5kaXZpZHVhbAotICogY2FjaGUgbGluZSBtYWludGFpbmVuY2UgaW5zdHJ1Y3Rpb25zLgorICogY2FjaGUgbGluZSBtYWludGVuYW5jZSBpbnN0cnVjdGlvbnMuCiAgKi8KICNkZWZpbmUgQ0FDSEVfRExJTUlUCTMyNzY4CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL3Byb2MtYXJtMTAyNi5TIGIvYXJjaC9hcm0vbW0vcHJvYy1hcm0xMDI2LlMKaW5kZXggNjg2MDQzZS4uNDEzNjg0NiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbW0vcHJvYy1hcm0xMDI2LlMKKysrIGIvYXJjaC9hcm0vbW0vcHJvYy1hcm0xMDI2LlMKQEAgLTUzLDcgKzUzLDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBzaXplIGF0IHdoaWNoIGl0IGJlY29tZXMgbW9yZSBlZmZpY2llbnQgdG8KICAqIGNsZWFuIHRoZSB3aG9sZSBjYWNoZSwgcmF0aGVyIHRoYW4gdXNpbmcgdGhlIGluZGl2aWR1YWwKLSAqIGNhY2hlIGxpbmUgbWFpbnRhaW5lbmNlIGluc3RydWN0aW9ucy4KKyAqIGNhY2hlIGxpbmUgbWFpbnRlbmFuY2UgaW5zdHJ1Y3Rpb25zLgogICovCiAjZGVmaW5lIENBQ0hFX0RMSU1JVAkzMjc2OAogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9wcm9jLWFybTcyMC5TIGIvYXJjaC9hcm0vbW0vcHJvYy1hcm03MjAuUwppbmRleCA2NjUyNjZkLi43YTA2ZTU5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTcyMC5TCisrKyBiL2FyY2gvYXJtL21tL3Byb2MtYXJtNzIwLlMKQEAgLTYzLDcgKzYzLDcgQEAKIC8qCiAgKiBGdW5jdGlvbjogYXJtNzIwX3Byb2NfZG9faWRsZSh2b2lkKQogICogUGFyYW1zICA6IHIwID0gdW51c2VkCi0gKiBQdXJwb3NlIDogcHV0IHRoZSBwcm9jZXNzZXIgaW4gcHJvcGVyIGlkbGUgbW9kZQorICogUHVycG9zZSA6IHB1dCB0aGUgcHJvY2Vzc29yIGluIHByb3BlciBpZGxlIG1vZGUKICAqLwogRU5UUlkoY3B1X2FybTcyMF9kb19pZGxlKQogCQltb3YJcGMsIGxyCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9wcm9jLWFybTkyMC5TIGIvYXJjaC9hcm0vbW0vcHJvYy1hcm05MjAuUwppbmRleCAyMTk5ODBlLi5iNDZlYjIxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTkyMC5TCisrKyBiL2FyY2gvYXJtL21tL3Byb2MtYXJtOTIwLlMKQEAgLTUzLDcgKzUzLDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBzaXplIGF0IHdoaWNoIGl0IGJlY29tZXMgbW9yZSBlZmZpY2llbnQgdG8KICAqIGNsZWFuIHRoZSB3aG9sZSBjYWNoZSwgcmF0aGVyIHRoYW4gdXNpbmcgdGhlIGluZGl2aWR1YWwKLSAqIGNhY2hlIGxpbmUgbWFpbnRhaW5lbmNlIGluc3RydWN0aW9ucy4KKyAqIGNhY2hlIGxpbmUgbWFpbnRlbmFuY2UgaW5zdHJ1Y3Rpb25zLgogICovCiAjZGVmaW5lIENBQ0hFX0RMSU1JVAk2NTUzNgogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9wcm9jLWFybTkyMi5TIGIvYXJjaC9hcm0vbW0vcHJvYy1hcm05MjIuUwppbmRleCAzNjE1NGIxLi45NWJhMWZjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTkyMi5TCisrKyBiL2FyY2gvYXJtL21tL3Byb2MtYXJtOTIyLlMKQEAgLTU0LDcgKzU0LDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBzaXplIGF0IHdoaWNoIGl0IGJlY29tZXMgbW9yZSBlZmZpY2llbnQgdG8KICAqIGNsZWFuIHRoZSB3aG9sZSBjYWNoZSwgcmF0aGVyIHRoYW4gdXNpbmcgdGhlIGluZGl2aWR1YWwKLSAqIGNhY2hlIGxpbmUgbWFpbnRhaW5lbmNlIGluc3RydWN0aW9ucy4gIChJIHRoaW5rIHRoaXMgc2hvdWxkCisgKiBjYWNoZSBsaW5lIG1haW50ZW5hbmNlIGluc3RydWN0aW9ucy4gIChJIHRoaW5rIHRoaXMgc2hvdWxkCiAgKiBiZSAzMjc2OCkuCiAgKi8KICNkZWZpbmUgQ0FDSEVfRExJTUlUCTgxOTIKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL3Byb2MtYXJtOTI1LlMgYi9hcmNoL2FybS9tbS9wcm9jLWFybTkyNS5TCmluZGV4IDg5YzVlMDAwLi41NDFlNDc3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLWFybTkyNS5TCisrKyBiL2FyY2gvYXJtL21tL3Byb2MtYXJtOTI1LlMKQEAgLTc3LDcgKzc3LDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBzaXplIGF0IHdoaWNoIGl0IGJlY29tZXMgbW9yZSBlZmZpY2llbnQgdG8KICAqIGNsZWFuIHRoZSB3aG9sZSBjYWNoZSwgcmF0aGVyIHRoYW4gdXNpbmcgdGhlIGluZGl2aWR1YWwKLSAqIGNhY2hlIGxpbmUgbWFpbnRhaW5lbmNlIGluc3RydWN0aW9ucy4KKyAqIGNhY2hlIGxpbmUgbWFpbnRlbmFuY2UgaW5zdHJ1Y3Rpb25zLgogICovCiAjZGVmaW5lIENBQ0hFX0RMSU1JVAk4MTkyCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL3Byb2MtbWFjcm9zLlMgYi9hcmNoL2FybS9tbS9wcm9jLW1hY3Jvcy5TCmluZGV4IGUzMmZhNDkuLjM0MjYxZjkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL3Byb2MtbWFjcm9zLlMKKysrIGIvYXJjaC9hcm0vbW0vcHJvYy1tYWNyb3MuUwpAQCAtODUsNyArODUsNyBAQAogCiAvKgogICogU2FuaXR5IGNoZWNrIHRoZSBQVEUgY29uZmlndXJhdGlvbiBmb3IgdGhlIGNvZGUgYmVsb3cgLSB3aGljaCBtYWtlcwotICogY2VydGFpbiBhc3N1bXB0aW9ucyBhYm91dCBob3cgdGhlc2UgYml0cyBhcmUgbGF5ZWQgb3V0LgorICogY2VydGFpbiBhc3N1bXB0aW9ucyBhYm91dCBob3cgdGhlc2UgYml0cyBhcmUgbGFpZCBvdXQuCiAgKi8KICNpZmRlZiBDT05GSUdfTU1VCiAjaWYgTF9QVEVfU0hBUkVEICE9IFBURV9FWFRfU0hBUkVECmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9wcm9jLXY2LlMgYi9hcmNoL2FybS9tbS9wcm9jLXY2LlMKaW5kZXggODMyYjZiZC4uYmZhMGM5ZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbW0vcHJvYy12Ni5TCisrKyBiL2FyY2gvYXJtL21tL3Byb2MtdjYuUwpAQCAtMTMyLDcgKzEzMiw3IEBACiAJbXJjCXAxNSwgMCwgcjYsIGMzLCBjMCwgMAlAIERvbWFpbiBJRAogCW1yYwlwMTUsIDAsIHI3LCBjMiwgYzAsIDAJQCBUcmFuc2xhdGlvbiB0YWJsZSBiYXNlIDAKIAltcmMJcDE1LCAwLCByOCwgYzIsIGMwLCAxCUAgVHJhbnNsYXRpb24gdGFibGUgYmFzZSAxCi0JbXJjCXAxNSwgMCwgcjksIGMxLCBjMCwgMQlAIGF1eGlsbGFyeSBjb250cm9sIHJlZ2lzdGVyCisJbXJjCXAxNSwgMCwgcjksIGMxLCBjMCwgMQlAIGF1eGlsaWFyeSBjb250cm9sIHJlZ2lzdGVyCiAJbXJjCXAxNSwgMCwgcjEwLCBjMSwgYzAsIDIJQCBjby1wcm9jZXNzb3IgYWNjZXNzIGNvbnRyb2wKIAltcmMJcDE1LCAwLCByMTEsIGMxLCBjMCwgMAlAIGNvbnRyb2wgcmVnaXN0ZXIKIAlzdG1pYQlyMCwge3I0IC0gcjExfQpAQCAtMTUxLDcgKzE1MSw3IEBACiAJbWNyCXAxNSwgMCwgcjYsIGMzLCBjMCwgMAlAIERvbWFpbiBJRAogCW1jcglwMTUsIDAsIHI3LCBjMiwgYzAsIDAJQCBUcmFuc2xhdGlvbiB0YWJsZSBiYXNlIDAKIAltY3IJcDE1LCAwLCByOCwgYzIsIGMwLCAxCUAgVHJhbnNsYXRpb24gdGFibGUgYmFzZSAxCi0JbWNyCXAxNSwgMCwgcjksIGMxLCBjMCwgMQlAIGF1eGlsbGFyeSBjb250cm9sIHJlZ2lzdGVyCisJbWNyCXAxNSwgMCwgcjksIGMxLCBjMCwgMQlAIGF1eGlsaWFyeSBjb250cm9sIHJlZ2lzdGVyCiAJbWNyCXAxNSwgMCwgcjEwLCBjMSwgYzAsIDIJQCBjby1wcm9jZXNzb3IgYWNjZXNzIGNvbnRyb2wKIAltY3IJcDE1LCAwLCBpcCwgYzIsIGMwLCAyCUAgVFRCIGNvbnRyb2wgcmVnaXN0ZXIKIAltY3IJcDE1LCAwLCBpcCwgYzcsIGM1LCA0CUAgSVNCCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9wcm9jLXY3LlMgYi9hcmNoL2FybS9tbS9wcm9jLXY3LlMKaW5kZXggMjYyZmE4OC4uYzM1NjE4ZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbW0vcHJvYy12Ny5TCisrKyBiL2FyY2gvYXJtL21tL3Byb2MtdjcuUwpAQCAtMjM3LDcgKzIzNyw3IEBACiAJbWNyCXAxNSwgMCwgcjcsIGMyLCBjMCwgMAlAIFRUQiAwCiAJbWNyCXAxNSwgMCwgcjgsIGMyLCBjMCwgMQlAIFRUQiAxCiAJbWNyCXAxNSwgMCwgaXAsIGMyLCBjMCwgMglAIFRUQiBjb250cm9sIHJlZ2lzdGVyCi0JbWNyCXAxNSwgMCwgcjEwLCBjMSwgYzAsIDEJQCBBdXhpbGxhcnkgY29udHJvbCByZWdpc3RlcgorCW1jcglwMTUsIDAsIHIxMCwgYzEsIGMwLCAxCUAgQXV4aWxpYXJ5IGNvbnRyb2wgcmVnaXN0ZXIKIAltY3IJcDE1LCAwLCByMTEsIGMxLCBjMCwgMglAIENvLXByb2Nlc3NvciBhY2Nlc3MgY29udHJvbAogCWxkcglyNCwgPVBSUlIJCUAgUFJSUgogCWxkcglyNSwgPU5NUlIJCUAgTk1SUgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvY3B1ZnJlcS5jIGIvYXJjaC9hcm0vcGxhdC1teGMvY3B1ZnJlcS5jCmluZGV4IGNlODE0ODEuLjQyNjhhMmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2NwdWZyZXEuYworKysgYi9hcmNoL2FybS9wbGF0LW14Yy9jcHVmcmVxLmMKQEAgLTEzLDcgKzEzLDcgQEAKIAogLyoKICAqIEEgZHJpdmVyIGZvciB0aGUgRnJlZXNjYWxlIFNlbWljb25kdWN0b3IgaS5NWEMgQ1BVZnJlcSBtb2R1bGUuCi0gKiBUaGUgQ1BVRlJFUSBkcml2ZXIgaXMgZm9yIGNvbnRyb2xpbmcgQ1BVIGZyZXF1ZW5jeS4gSXQgYWxsb3dzIHlvdSB0byBjaGFuZ2UKKyAqIFRoZSBDUFVGUkVRIGRyaXZlciBpcyBmb3IgY29udHJvbGxpbmcgQ1BVIGZyZXF1ZW5jeS4gSXQgYWxsb3dzIHlvdSB0byBjaGFuZ2UKICAqIHRoZSBDUFUgY2xvY2sgc3BlZWQgb24gdGhlIGZseS4KICAqLwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvZW50cnktbWFjcm8uUyBiL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9lbnRyeS1tYWNyby5TCmluZGV4IGJkOWJiOTcuLjJlNDllNzEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9lbnRyeS1tYWNyby5TCisrKyBiL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9lbnRyeS1tYWNyby5TCkBAIC0zMyw5ICszMyw5IEBACiAJLm1hY3JvICBhcmNoX3JldF90b191c2VyLCB0bXAxLCB0bXAyCiAJLmVuZG0KIAotCUAgdGhpcyBtYWNybyBjaGVja3Mgd2hpY2ggaW50ZXJydXB0IG9jY3VyZWQKKwlAIHRoaXMgbWFjcm8gY2hlY2tzIHdoaWNoIGludGVycnVwdCBvY2N1cnJlZAogCUAgYW5kIHJldHVybnMgaXRzIG51bWJlciBpbiBpcnFucgotCUAgYW5kIHJldHVybnMgaWYgYW4gaW50ZXJydXB0IG9jY3VyZWQgaW4gaXJxc3RhdAorCUAgYW5kIHJldHVybnMgaWYgYW4gaW50ZXJydXB0IG9jY3VycmVkIGluIGlycXN0YXQKIAkubWFjcm8JZ2V0X2lycW5yX2FuZF9iYXNlLCBpcnFuciwgaXJxc3RhdCwgYmFzZSwgdG1wCiAjaWZuZGVmIENPTkZJR19NWENfVFpJQwogCUAgTG9hZCBvZmZzZXQgJiBwcmlvcml0eSBvZiB0aGUgaGlnaGVzdCBwcmlvcml0eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvaW5jbHVkZS9tYWNoL214Y19uYW5kLmggYi9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvbXhjX25hbmQuaAppbmRleCAwNGMwZDA2Li42YmI5NmVmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvbXhjX25hbmQuaAorKysgYi9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvbXhjX25hbmQuaApAQCAtMjQsNyArMjQsNyBAQAogCiBzdHJ1Y3QgbXhjX25hbmRfcGxhdGZvcm1fZGF0YSB7CiAJdW5zaWduZWQgaW50IHdpZHRoOwkvKiBkYXRhIGJ1cyB3aWR0aCBpbiBieXRlcyAqLwotCXVuc2lnbmVkIGludCBod19lY2M6MTsJLyogMCBpZiBzdXByZXNzIGhhcmR3YXJlIEVDQyAqLworCXVuc2lnbmVkIGludCBod19lY2M6MTsJLyogMCBpZiBzdXBwcmVzcyBoYXJkd2FyZSBFQ0MgKi8KIAl1bnNpZ25lZCBpbnQgZmxhc2hfYmJ0OjE7IC8qIHNldCB0byAxIHRvIHVzZSBhIGZsYXNoIGJhc2VkIGJidCAqLwogCXN0cnVjdCBtdGRfcGFydGl0aW9uICpwYXJ0czsJLyogcGFydGl0aW9uIHRhYmxlICovCiAJaW50IG5yX3BhcnRzOwkJCS8qIHNpemUgb2YgcGFydHMgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9kZXZpY2VzLmMgYi9hcmNoL2FybS9wbGF0LW9tYXAvZGV2aWNlcy5jCmluZGV4IDdkOWY4MTUuLmVhMjhmOThkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvZGV2aWNlcy5jCisrKyBiL2FyY2gvYXJtL3BsYXQtb21hcC9kZXZpY2VzLmMKQEAgLTI4MCw3ICsyODAsNyBAQAogICogQ2xhaW1pbmcgR1BJT3MsIGFuZCBzZXR0aW5nIHRoZWlyIGRpcmVjdGlvbiBhbmQgaW5pdGlhbCB2YWx1ZXMsIGlzIHRoZQogICogcmVzcG9uc2liaWxpdHkgb2YgdGhlIGRldmljZSBkcml2ZXJzLiAgU28gaXMgcmVzcG9uZGluZyB0byBwcm9iZSgpLgogICoKLSAqIEJvYXJkLXNwZWNpZmljIGtub3dsZWdlIGxpa2UgY3JlYXRpbmcgZGV2aWNlcyBvciBwaW4gc2V0dXAgaXMgdG8gYmUKKyAqIEJvYXJkLXNwZWNpZmljIGtub3dsZWRnZSBsaWtlIGNyZWF0aW5nIGRldmljZXMgb3IgcGluIHNldHVwIGlzIHRvIGJlCiAgKiBrZXB0IG91dCBvZiBkcml2ZXJzIGFzIG11Y2ggYXMgcG9zc2libGUuICBJbiBwYXJ0aWN1bGFyLCBwaW4gc2V0dXAKICAqIG1heSBiZSBoYW5kbGVkIGJ5IHRoZSBib290IGxvYWRlciwgYW5kIGRyaXZlcnMgc2hvdWxkIGV4cGVjdCBpdCB3aWxsCiAgKiBub3JtYWxseSBoYXZlIGJlZW4gZG9uZSBieSB0aGUgdGltZSB0aGV5J3JlIHByb2JlZC4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9kbWEuYyBiL2FyY2gvYXJtL3BsYXQtb21hcC9kbWEuYwppbmRleCAyZWMzYjVkLi5jMjIyMTdjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvZG1hLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1vbWFwL2RtYS5jCkBAIC0xMDE5LDcgKzEwMTksNyBAQAogICogSWYgdGhlIGNoYW5uZWwgaXMgcnVubmluZyB0aGUgY2FsbGVyIG11c3QgZGlzYWJsZSBpbnRlcnJ1cHRzIHByaW9yIGNhbGxpbmcKICAqIHRoaXMgZnVuY3Rpb24gYW5kIHByb2Nlc3MgdGhlIHJldHVybmVkIHZhbHVlIGJlZm9yZSByZS1lbmFibGluZyBpbnRlcnJ1cHQgdG8KICAqIHByZXZlbnQgcmFjZXMgd2l0aCB0aGUgaW50ZXJydXB0IGhhbmRsZXIuIE5vdGUgdGhhdCBpbiBjb250aW51b3VzIG1vZGUgdGhlcmUKLSAqIGlzIGEgY2hhbmNlIGZvciBDU1NBX0wgcmVnaXN0ZXIgb3ZlcmZsb3cgaW5iZXR3ZWVuIHRoZSB0d28gcmVhZHMgcmVzdWx0aW5nCisgKiBpcyBhIGNoYW5jZSBmb3IgQ1NTQV9MIHJlZ2lzdGVyIG92ZXJmbG93IGJldHdlZW4gdGhlIHR3byByZWFkcyByZXN1bHRpbmcKICAqIGluIGluY29ycmVjdCByZXR1cm4gdmFsdWUuCiAgKi8KIGRtYV9hZGRyX3Qgb21hcF9nZXRfZG1hX3NyY19wb3MoaW50IGxjaCkKQEAgLTEwNDYsNyArMTA0Niw3IEBACiAgKiBJZiB0aGUgY2hhbm5lbCBpcyBydW5uaW5nIHRoZSBjYWxsZXIgbXVzdCBkaXNhYmxlIGludGVycnVwdHMgcHJpb3IgY2FsbGluZwogICogdGhpcyBmdW5jdGlvbiBhbmQgcHJvY2VzcyB0aGUgcmV0dXJuZWQgdmFsdWUgYmVmb3JlIHJlLWVuYWJsaW5nIGludGVycnVwdCB0bwogICogcHJldmVudCByYWNlcyB3aXRoIHRoZSBpbnRlcnJ1cHQgaGFuZGxlci4gTm90ZSB0aGF0IGluIGNvbnRpbnVvdXMgbW9kZSB0aGVyZQotICogaXMgYSBjaGFuY2UgZm9yIENEU0FfTCByZWdpc3RlciBvdmVyZmxvdyBpbmJldHdlZW4gdGhlIHR3byByZWFkcyByZXN1bHRpbmcKKyAqIGlzIGEgY2hhbmNlIGZvciBDRFNBX0wgcmVnaXN0ZXIgb3ZlcmZsb3cgYmV0d2VlbiB0aGUgdHdvIHJlYWRzIHJlc3VsdGluZwogICogaW4gaW5jb3JyZWN0IHJldHVybiB2YWx1ZS4KICAqLwogZG1hX2FkZHJfdCBvbWFwX2dldF9kbWFfZHN0X3BvcyhpbnQgbGNoKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC9ncGlvLmggYi9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2dwaW8uaAppbmRleCBkNmY5ZmEwLi5jYWMyZThhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2dwaW8uaAorKysgYi9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2dwaW8uaApAQCAtOTMsNyArOTMsNyBAQAogLyogV3JhcHBlcnMgZm9yICJuZXcgc3R5bGUiIEdQSU8gY2FsbHMsIHVzaW5nIHRoZSBuZXcgaW5mcmFzdHJ1Y3R1cmUKICAqIHdoaWNoIGxldHMgdXMgcGx1ZyBpbiBGUEdBLCBJMkMsIGFuZCBvdGhlciBpbXBsZW1lbnRhdGlvbnMuCiAgKiAqCi0gKiBUaGUgb3JpZ2luYWwgT01BUC1zcGVjZmljIGNhbGxzIHNob3VsZCBldmVudHVhbGx5IGJlIHJlbW92ZWQuCisgKiBUaGUgb3JpZ2luYWwgT01BUC1zcGVjaWZpYyBjYWxscyBzaG91bGQgZXZlbnR1YWxseSBiZSByZW1vdmVkLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC9ncG1jLmggYi9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2dwbWMuaAppbmRleCAxMmIzMTYxLi4xNTI3OTI5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2dwbWMuaAorKysgYi9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2dwbWMuaApAQCAtOTAsNyArOTAsNyBAQAogCQkvKiAxLWJpdCBlY2M6IHN0b3JlZCBhdCBlbmQgb2Ygc3BhcmUgYXJlYSAqLwogCU9NQVBfRUNDX0hBTU1JTkdfQ09ERV9ERUZBVUxUID0gMCwgLyogRGVmYXVsdCwgcy93IG1ldGhvZCAqLwogCU9NQVBfRUNDX0hBTU1JTkdfQ09ERV9IVywgLyogZ3BtYyB0byBkZXRlY3QgdGhlIGVycm9yICovCi0JCS8qIDEtYml0IGVjYzogc3RvcmVkIGF0IGJlZ2luaW5nIG9mIHNwYXJlIGFyZWEgYXMgcm9tY29kZSAqLworCQkvKiAxLWJpdCBlY2M6IHN0b3JlZCBhdCBiZWdpbm5pbmcgb2Ygc3BhcmUgYXJlYSBhcyByb21jb2RlICovCiAJT01BUF9FQ0NfSEFNTUlOR19DT0RFX0hXX1JPTUNPREUsIC8qIGdwbWMgbWV0aG9kICYgcm9tY29kZSBsYXlvdXQgKi8KIH07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9tY2JzcC5jIGIvYXJjaC9hcm0vcGxhdC1vbWFwL21jYnNwLmMKaW5kZXggZDU5OGQ5Zi4uNTU4N2FjZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1vbWFwL21jYnNwLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1vbWFwL21jYnNwLmMKQEAgLTExMDMsNyArMTEwMyw3IEBACiAJCS8qIHJlc2VuZCAqLwogCQlyZXR1cm4gLTE7CiAJfSBlbHNlIHsKLQkJLyogd2FpdCBmb3IgcmVjaWV2ZSBjb25maXJtYXRpb24gKi8KKwkJLyogd2FpdCBmb3IgcmVjZWl2ZSBjb25maXJtYXRpb24gKi8KIAkJaW50IGF0dGVtcHMgPSAwOwogCQl3aGlsZSAoIShNQ0JTUF9SRUFEKG1jYnNwLCBTUENSMSkgJiBSUkRZKSkgewogCQkJaWYgKGF0dGVtcHMrKyA+IDEwMDApIHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtcHhhL2luY2x1ZGUvcGxhdC9tZnAuaCBiL2FyY2gvYXJtL3BsYXQtcHhhL2luY2x1ZGUvcGxhdC9tZnAuaAppbmRleCA3NWY2NTY0Li44OWU2OGUwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXB4YS9pbmNsdWRlL3BsYXQvbWZwLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1weGEvaW5jbHVkZS9wbGF0L21mcC5oCkBAIC00MzQsNyArNDM0LDcgQEAKICAqCiAgKiBtZnBfaW5pdF9hZGRyKCkgLSBhY2NlcHRzIGEgdGFibGUgb2YgIm1mcF9hZGRyX21hcCIgc3RydWN0dXJlLCB3aGljaAogICogcmVwcmVzZW50cyBhIHJhbmdlIG9mIE1GUCBwaW5zIGZyb20gInN0YXJ0IiB0byAiZW5kIiwgd2l0aCB0aGUgb2Zmc2V0Ci0gKiBiZWdpbmluZyBhdCAib2Zmc2V0IiwgdG8gZGVmaW5lIGEgc2luZ2xlIHBpbiwgbGV0ICJlbmQiID0gLTEuCisgKiBiZWdpbm5pbmcgYXQgIm9mZnNldCIsIHRvIGRlZmluZSBhIHNpbmdsZSBwaW4sIGxldCAiZW5kIiA9IC0xLgogICoKICAqIHVzZQogICoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9NYWtlZmlsZSBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9NYWtlZmlsZQppbmRleCBjMjA2NGMzLi4wMjkxYmQ2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXMzYzI0eHgvTWFrZWZpbGUKKysrIGIvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L01ha2VmaWxlCkBAIC0yMyw3ICsyMyw3IEBACiBvYmotJChDT05GSUdfQ1BVX0ZSRVFfUzNDMjRYWCkJKz0gY3B1LWZyZXEubwogb2JqLSQoQ09ORklHX0NQVV9GUkVRX1MzQzI0WFhfREVCVUdGUykgKz0gY3B1LWZyZXEtZGVidWdmcy5vCiAKLSMgQXJjaGl0ZWN0dXJlIGRlcGVuZGFudCBidWlsZHMKKyMgQXJjaGl0ZWN0dXJlIGRlcGVuZGVudCBidWlsZHMKIAogb2JqLSQoQ09ORklHX1BNX1NJTVRFQykJCSs9IHBtLXNpbXRlYy5vCiBvYmotJChDT05GSUdfUE0pCQkrPSBwbS5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXMzYzI0eHgvY3B1LWZyZXEuYyBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9jcHUtZnJlcS5jCmluZGV4IGVlYTc1ZmYuLmIzZDNkMDIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9jcHUtZnJlcS5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9jcHUtZnJlcS5jCkBAIC00NTUsNyArNDU1LDcgQEAKIAogCS8qIHdoaWxzdCB3ZSB3aWxsIGJlIGNhbGxlZCBsYXRlciBvbiwgd2UgdHJ5IGFuZCByZS1zZXQgdGhlCiAJICogY3B1IGZyZXF1ZW5jaWVzIGFzIHNvb24gYXMgcG9zc2libGUgc28gdGhhdCB3ZSBkbyBub3QgZW5kCi0JICogdXAgcmVzdW1pbmcgZGV2aWNlcyBhbmQgdGhlbiBpbW1lZGlhdGxleSBoYXZpbmcgdG8gcmUtc2V0CisJICogdXAgcmVzdW1pbmcgZGV2aWNlcyBhbmQgdGhlbiBpbW1lZGlhdGVseSBoYXZpbmcgdG8gcmUtc2V0CiAJICogYSBudW1iZXIgb2Ygc2V0dGluZ3Mgb25jZSB0aGVzZSBkZXZpY2VzIGhhdmUgcmVzdGFydGVkLgogCSAqCiAJICogYXMgYSBub3RlLCBpdCBpcyBleHBlY3RlZCBkZXZpY2VzIGFyZSBub3QgdXNlZCB1bnRpbCB0aGV5CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXMzYzI0eHgvZG1hLmMgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvZG1hLmMKaW5kZXggNmFkMjc0ZS4uMjdlYTg1MmUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9kbWEuYworKysgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvZG1hLmMKQEAgLTU1Nyw3ICs1NTcsNyBAQAogCQlicmVhazsKIAogCWNhc2UgUzNDMjQxMF9ETUFMT0FEXzFMT0FERURfMVJVTk5JTkc6Ci0JCS8qIEkgYmVsaXZlIGluIHRoaXMgY2FzZSB3ZSBkbyBub3QgaGF2ZSBhbnl0aGluZyB0byBkbworCQkvKiBJIGJlbGlldmUgaW4gdGhpcyBjYXNlIHdlIGRvIG5vdCBoYXZlIGFueXRoaW5nIHRvIGRvCiAJCSAqIHVudGlsIHRoZSBuZXh0IGJ1ZmZlciBjb21lcyBhbG9uZywgYW5kIHdlIHR1cm4gb2ZmIHRoZQogCQkgKiByZWxvYWQgKi8KIAkJcmV0dXJuOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zNXAvaXJxLWdwaW9pbnQuYyBiL2FyY2gvYXJtL3BsYXQtczVwL2lycS1ncGlvaW50LmMKaW5kZXggNDZkZDA3OC4uY2Q2ZDY3YyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zNXAvaXJxLWdwaW9pbnQuYworKysgYi9hcmNoL2FybS9wbGF0LXM1cC9pcnEtZ3Bpb2ludC5jCkBAIC0yMDgsNyArMjA4LDcgQEAKIAl9CiAKIAkvKgotCSAqIGNoYWluZWQgR1BJTyBpcnEgaGFzIGJlZW4gc3VjZXNzZnVsbHkgcmVnaXN0ZXJlZCwgYWxsb2NhdGUgbmV3IGdwaW8KKwkgKiBjaGFpbmVkIEdQSU8gaXJxIGhhcyBiZWVuIHN1Y2Nlc3NmdWxseSByZWdpc3RlcmVkLCBhbGxvY2F0ZSBuZXcgZ3BpbwogCSAqIGludCBncm91cCBhbmQgYXNzaWduIGlycSBudWJtZXJzCiAJICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvY2xvY2suaCBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvY2xvY2suaAppbmRleCA5YTgyYjg4Li45ODNjNTc4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2Nsb2NrLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9jbG9jay5oCkBAIC0yMSw3ICsyMSw3IEBACiAgKiBAc2V0X3BhcmVudDogc2V0IHRoZSBjbG9jaydzIHBhcmVudCwgc2VlIGNsa19zZXRfcGFyZW50KCkuCiAgKgogICogR3JvdXAgdGhlIGNvbW1vbiBjbG9jayBpbXBsZW1lbnRhdGlvbnMgdG9nZXRoZXIgc28gdGhhdCB3ZQotICogZG9uJ3QgaGF2ZSB0byBrZWVwIHNldHRpbmcgdGhlIHNhbWUgZmllbHMgYWdhaW4uIFdlIGxlYXZlCisgKiBkb24ndCBoYXZlIHRvIGtlZXAgc2V0dGluZyB0aGUgc2FtZSBmaWVsZHMgYWdhaW4uIFdlIGxlYXZlCiAgKiBlbmFibGUgaW4gc3RydWN0IGNsay4KICAqCiAgKiBBZGRpbmcgYW4gZXh0cmEgbGF5ZXIgb2YgaW5kaXJlY3Rpb24gaW50byB0aGUgcHJvY2VzcyBzaG91bGQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZ3Bpby1jZmctaGVscGVycy5oIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNmZy1oZWxwZXJzLmgKaW5kZXggNTYwM2RiMC4uM2FkODM4NiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNmZy1oZWxwZXJzLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNmZy1oZWxwZXJzLmgKQEAgLTExNCw3ICsxMTQsNyBAQAogICogb2YgY29udHJvbCBwZXIgR1BJTywgZ2VuZXJhbGx5IGluIHRoZSBmb3JtIG9mOgogICoJMDAwMCA9IElucHV0CiAgKgkwMDAxID0gT3V0cHV0Ci0gKglvdGhlcnMgPSBTcGVjaWFsIGZ1bmN0aW9ucyAoZGVwZW5kYW50IG9uIGJhbmspCisgKglvdGhlcnMgPSBTcGVjaWFsIGZ1bmN0aW9ucyAoZGVwZW5kZW50IG9uIGJhbmspCiAgKgogICogTm90ZSwgc2luY2UgdGhlIGNvZGUgdG8gZGVhbCB3aXRoIHRoZSBjYXNlIHdoZXJlIHRoZXJlIGFyZSB0d28gY29udHJvbAogICogcmVnaXN0ZXJzIGluc3RlYWQgb2Ygb25lLCB3ZSBkbyBub3QgaGF2ZSBhIHNlcGFyYXRlIHNldCBvZiBmdW5jdGlvbnMgZm9yCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY2ZnLmggYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY2ZnLmgKaW5kZXggNWUwNGZhNi4uMTc2MmRjYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNmZy5oCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZ3Bpby1jZmcuaApAQCAtMTI1LDcgKzEyNSw3IEBACiAgKgogICogVGhlc2UgdmFsdWVzIGNvbnRyb2wgdGhlIHN0YXRlIG9mIHRoZSB3ZWFrIHB1bGwte3VwLGRvd259IHJlc2lzdG9ycwogICogYXZhaWxhYmxlIG9uIG1vc3QgcGlucyBvbiB0aGUgUzNDIHNlcmllcy4gTm90IGFsbCBjaGlwcyBzdXBwb3J0IGJvdGgKLSAqIHVwIG9yIGRvd24gc2V0dGluZ3MsIGFuZCBpdCBtYXkgYmUgZGVwZW5kYW50IG9uIHRoZSBjaGlwIHRoYXQgaXMgYmVpbmcKKyAqIHVwIG9yIGRvd24gc2V0dGluZ3MsIGFuZCBpdCBtYXkgYmUgZGVwZW5kZW50IG9uIHRoZSBjaGlwIHRoYXQgaXMgYmVpbmcKICAqIHVzZWQgdG8gd2hldGhlciB0aGUgcGFydGljdWxhciBtb2RlIGlzIGF2YWlsYWJsZS4KICAqLwogI2RlZmluZSBTM0NfR1BJT19QVUxMX05PTkUJKChfX2ZvcmNlIHMzY19ncGlvX3B1bGxfdCkweDAwKQpAQCAtMTM4LDcgKzEzOCw3IEBACiAgKiBAcHVsbDogVGhlIGNvbmZpZ3VyYXRpb24gZm9yIHRoZSBwdWxsIHJlc2lzdG9yLgogICoKICAqIFRoaXMgZnVuY3Rpb24gc2V0cyB0aGUgc3RhdGUgb2YgdGhlIHB1bGwte3VwLGRvd259IHJlc2lzdG9yIGZvciB0aGUKLSAqIHNwZWNpZmllZCBwaW4uIEl0IHdpbGwgcmV0dXJuIDAgaWYgc3VjY2Vzc2Z1bGwsIG9yIGEgbmVnYXRpdmUgZXJyb3IKKyAqIHNwZWNpZmllZCBwaW4uIEl0IHdpbGwgcmV0dXJuIDAgaWYgc3VjY2Vzc2Z1bCwgb3IgYSBuZWdhdGl2ZSBlcnJvcgogICogY29kZSBpZiB0aGUgcGluIGNhbm5vdCBzdXBwb3J0IHRoZSByZXF1ZXN0ZWQgcHVsbCBzZXR0aW5nLgogICoKICAqIEBwdWxsIGlzIG9uZSBvZiBTM0NfR1BJT19QVUxMX05PTkUsIFMzQ19HUElPX1BVTExfRE9XTiBvciBTM0NfR1BJT19QVUxMX1VQLgpAQCAtMjAyLDcgKzIwMiw3IEBACiAgKiBAZHJ2c3RyOiBUaGUgbmV3IHZhbHVlIG9mIHRoZSBkcml2ZXIgc3RyZW5ndGgKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIHNldHMgdGhlIGRyaXZlciBzdHJlbmd0aCB2YWx1ZSBmb3IgdGhlIHNwZWNpZmllZCBwaW4uCi0gKiBJdCB3aWxsIHJldHVybiAwIGlmIHN1Y2Nlc3NmdWxsLCBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgaWYgdGhlIHBpbgorICogSXQgd2lsbCByZXR1cm4gMCBpZiBzdWNjZXNzZnVsLCBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgaWYgdGhlIHBpbgogICogY2Fubm90IHN1cHBvcnQgdGhlIHJlcXVlc3RlZCBzZXR0aW5nLgogKi8KIGV4dGVybiBpbnQgczVwX2dwaW9fc2V0X2RydnN0cih1bnNpZ25lZCBpbnQgcGluLCBzNXBfZ3Bpb19kcnZzdHJfdCBkcnZzdHIpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNvcmUuaCBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZ3Bpby1jb3JlLmgKaW5kZXggZGFjMzVkMC4uOGNhZDRjZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNvcmUuaAorKysgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY29yZS5oCkBAIC0xMDgsNyArMTA4LDcgQEAKICAqIG9mIGNvbnRyb2wgcGVyIEdQSU8sIGdlbmVyYWxseSBpbiB0aGUgZm9ybSBvZjoKICAqIDAwMDAgPSBJbnB1dAogICogMDAwMSA9IE91dHB1dAotICogb3RoZXJzID0gU3BlY2lhbCBmdW5jdGlvbnMgKGRlcGVuZGFudCBvbiBiYW5rKQorICogb3RoZXJzID0gU3BlY2lhbCBmdW5jdGlvbnMgKGRlcGVuZGVudCBvbiBiYW5rKQogICoKICAqIE5vdGUsIHNpbmNlIHRoZSBjb2RlIHRvIGRlYWwgd2l0aCB0aGUgY2FzZSB3aGVyZSB0aGVyZSBhcmUgdHdvIGNvbnRyb2wKICAqIHJlZ2lzdGVycyBpbnN0ZWFkIG9mIG9uZSwgd2UgZG8gbm90IGhhdmUgYSBzZXBhcmF0ZSBzZXQgb2YgZnVuY3Rpb24KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvc2RoY2kuaCBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvc2RoY2kuaAppbmRleCBiMGJkZjE2Li4wNThlMDk2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L3NkaGNpLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9zZGhjaS5oCkBAIC01Nyw3ICs1Nyw3IEBACiAgKiBAY2ZnX2dwaW86IENvbmZpZ3VyZSB0aGUgR1BJTyBmb3IgYSBzcGVjaWZpYyBjYXJkIGJpdC13aWR0aAogICogQGNmZ19jYXJkOiBDb25maWd1cmUgdGhlIGludGVyZmFjZSBmb3IgYSBzcGVjaWZpYyBjYXJkIGFuZCBzcGVlZC4gVGhpcwogICogICAgICAgICAgICBpcyBuZWNlc3NhcnkgdGhlIGNvbnRyb2xsZXJzIGFuZC9vciBHUElPIGJsb2NrcyByZXF1aXJlIHRoZQotICoJICAgICAgY2hhbmdpbmcgb2YgZHJpdmVyLXN0cmVuZ3RoIGFuZCBvdGhlciBjb250cm9scyBkZXBlbmRhbnQgb24KKyAqCSAgICAgIGNoYW5naW5nIG9mIGRyaXZlci1zdHJlbmd0aCBhbmQgb3RoZXIgY29udHJvbHMgZGVwZW5kZW50IG9uCiAgKgkgICAgICB0aGUgY2FyZCBhbmQgc3BlZWQgb2Ygb3BlcmF0aW9uLgogICoKICAqIEluaXRpYWxpc2F0aW9uIGRhdGEgc3BlY2lmaWMgdG8gZWl0aGVyIHRoZSBtYWNoaW5lIG9yIHRoZSBwbGF0Zm9ybQpAQCAtMTA4LDcgKzEwOCw3IEBACiBleHRlcm4gc3RydWN0IHMzY19zZGhjaV9wbGF0ZGF0YSBzM2NfaHNtbWMyX2RlZl9wbGF0ZGF0YTsKIGV4dGVybiBzdHJ1Y3QgczNjX3NkaGNpX3BsYXRkYXRhIHMzY19oc21tYzNfZGVmX3BsYXRkYXRhOwogCi0vKiBIZWxwZXIgZnVuY3Rpb24gYXZhaWxhYmxpdHkgKi8KKy8qIEhlbHBlciBmdW5jdGlvbiBhdmFpbGFiaWxpdHkgKi8KIAogZXh0ZXJuIHZvaWQgczNjMjQxNl9zZXR1cF9zZGhjaTBfY2ZnX2dwaW8oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqLCBpbnQgdyk7CiBleHRlcm4gdm9pZCBzM2MyNDE2X3NldHVwX3NkaGNpMV9jZmdfZ3BpbyhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICosIGludCB3KTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9zM2MtcGwzMzAuYyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9zM2MtcGwzMzAuYwppbmRleCBiNGZmOGQ3Li5mODU2MzhjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvczNjLXBsMzMwLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL3MzYy1wbDMzMC5jCkBAIC02OCw3ICs2OCw3IEBACiAgKiBAcmVxOiBUd28gcmVxdWVzdHMgdG8gY29tbXVuaWNhdGUgd2l0aCB0aGUgUEwzMzAgZW5naW5lLgogICogQGNhbGxiYWNrX2ZuOiBDYWxsYmFjayBmdW5jdGlvbiB0byB0aGUgY2xpZW50LgogICogQHJxY2ZnOiBDaGFubmVsIGNvbmZpZ3VyYXRpb24gZm9yIHRoZSB4ZmVycy4KLSAqIEB4ZmVyX2hlYWQ6IFBvaW50ZXIgdG8gdGhlIHhmZXIgdG8gYmUgbmV4dCBleGNlY3V0ZWQuCisgKiBAeGZlcl9oZWFkOiBQb2ludGVyIHRvIHRoZSB4ZmVyIHRvIGJlIG5leHQgZXhlY3V0ZWQuCiAgKiBAZG1hYzogUG9pbnRlciB0byB0aGUgRE1BQyB0aGF0IG1hbmFnZXMgdGhpcyBjaGFubmVsLCBOVUxMIGlmIHRoZQogICogCWNoYW5uZWwgaXMgYXZhaWxhYmxlIHRvIGJlIGFjcXVpcmVkLgogICogQGNsaWVudDogQ2xpZW50IG9mIHRoaXMgY2hhbm5lbC4gTlVMTCBpZiB0aGUKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc3BlYXIvaW5jbHVkZS9wbGF0L2Nsb2NrLmggYi9hcmNoL2FybS9wbGF0LXNwZWFyL2luY2x1ZGUvcGxhdC9jbG9jay5oCmluZGV4IDJhZTY2MDYuLmZjYzBkMGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc3BlYXIvaW5jbHVkZS9wbGF0L2Nsb2NrLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zcGVhci9pbmNsdWRlL3BsYXQvY2xvY2suaApAQCAtODksNyArODksNyBAQAogICogQHNpYmxpbmc6IG5vZGUgZm9yIGxpc3Qgb2YgY2xvY2tzIGhhdmluZyBzYW1lIHBhcmVudHMKICAqIEBwcml2YXRlX2RhdGE6IGNsb2NrIHNwZWNpZmljIHByaXZhdGUgZGF0YQogICogQG5vZGU6IGxpc3QgdG8gbWFpbnRhaW4gY2xvY2tzIGxpbmVhcmx5Ci0gKiBAY2w6IGNsb2NrbG9vayB1cCBhc3NvaWNhdGVkIHdpdGggdGhpcyBjbG9jaworICogQGNsOiBjbG9ja2xvb2sgdXAgYXNzb2NpYXRlZCB3aXRoIHRoaXMgY2xvY2sKICAqIEBkZW50OiBvYmplY3QgZm9yIGRlYnVnZnMKICAqLwogc3RydWN0IGNsayB7CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL0tjb25maWcuZGVidWcgYi9hcmNoL2JsYWNrZmluL0tjb25maWcuZGVidWcKaW5kZXggYWNiODM3OS4uMjY0MTczMSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9LY29uZmlnLmRlYnVnCisrKyBiL2FyY2gvYmxhY2tmaW4vS2NvbmZpZy5kZWJ1ZwpAQCAtNTksNyArNTksNyBAQAogICAgICAgICAgIGJlIHJlcG9ydGVkIG11bHRpcGxlIGN5Y2xlcyBhZnRlciB0aGUgZXJyb3IgaGFwcGVucy4gVGhpcyBkZWxheQogCSAgY2FuIGNhdXNlIHRoZSB3cm9uZyBhcHBsaWNhdGlvbiwgb3IgZXZlbiB0aGUga2VybmVsIHRvIHJlY2VpdmUgYQogCSAgc2lnbmFsIHRvIGJlIGtpbGxlZC4gSWYgeW91IGFyZSBnZXR0aW5nIEhXIGVycm9ycyBpbiB5b3VyIHN5c3RlbSwKLQkgIHRyeSB0dXJuaW5nIHRoaXMgb24gdG8gZW5zdXJlIHRoZXkgYXJlIGF0IGxlYXN0IGNvbW1pbmcgZnJvbSB0aGUKKwkgIHRyeSB0dXJuaW5nIHRoaXMgb24gdG8gZW5zdXJlIHRoZXkgYXJlIGF0IGxlYXN0IGNvbWluZyBmcm9tIHRoZQogCSAgcHJvcGVyIHRocmVhZC4KIAogCSAgT24gcHJvZHVjdGlvbiBzeXN0ZW1zLCBpdCBpcyBzYWZlIChhbmQgYSBzbWFsbCBvcHRpbWl6YXRpb24pIHRvIHNheSBOLgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90cmFwcy5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90cmFwcy5oCmluZGV4IDlmZTBkYTYuLjcwYzRlNTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdHJhcHMuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3RyYXBzLmgKQEAgLTU3LDcgKzU3LDcgQEAKICNkZWZpbmUgSFdDX3gzKGxldmVsKSBcCiAJIkV4dGVybmFsIE1lbW9yeSBBZGRyZXNzaW5nIEVycm9yXG4iCiAjZGVmaW5lIEVYQ18weDA0KGxldmVsKSBcCi0JIlVuaW1wbG1lbnRlZCBleGNlcHRpb24gb2NjdXJlZFxuIiBcCisJIlVuaW1wbG1lbnRlZCBleGNlcHRpb24gb2NjdXJyZWRcbiIgXAogCWxldmVsICIgLSBNYXliZSB5b3UgZm9yZ290IHRvIGluc3RhbGwgYSBjdXN0b20gZXhjZXB0aW9uIGhhbmRsZXI/XG4iCiAjZGVmaW5lIEhXQ194MTIobGV2ZWwpIFwKIAkiUGVyZm9ybWFuY2UgTW9uaXRvciBPdmVyZmxvd1xuIgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwva2dkYi5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwva2dkYi5jCmluZGV4IGI4Y2ZlMzQuLjliODBiMTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2tnZGIuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9rZ2RiLmMKQEAgLTE4MSw3ICsxODEsNyBAQAogCQlyZXR1cm4gLUVOT1NQQzsKIAl9CiAKLQkvKiBCZWNhc3VlIGhhcmR3YXJlIGRhdGEgd2F0Y2hwb2ludCBpbXBlbGVtZW50ZWQgaW4gY3VycmVudAorCS8qIEJlY2F1c2UgaGFyZHdhcmUgZGF0YSB3YXRjaHBvaW50IGltcGVsZW1lbnRlZCBpbiBjdXJyZW50CiAJICogQmxhY2tmaW4gY2FuIG5vdCB0cmlnZ2VyIGFuIGV4Y2VwdGlvbiBldmVudCBhcyB0aGUgaGFyZHdhcmUKIAkgKiBpbnN0cmN0aW9uIHdhdGNocG9pbnQgZG9lcywgd2UgaWduYW9yZSBhbGwgZGF0YSB3YXRjaCBwb2ludCBoZXJlLgogCSAqIFRoZXkgY2FuIGJlIHR1cm5lZCBvbiBlYXNpbHkgYWZ0ZXIgZnV0dXJlIGJsYWNrZmluIGRlc2lnbgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdHJhcHMuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3RyYXBzLmMKaW5kZXggNTljMWRmNy4uNjU1ZjI1ZCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdHJhcHMuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC90cmFwcy5jCkBAIC05OCw3ICs5OCw3IEBACiAJLyogc2VuZCB0aGUgYXBwcm9wcmlhdGUgc2lnbmFsIHRvIHRoZSB1c2VyIHByb2dyYW0gKi8KIAlzd2l0Y2ggKHRyYXBucikgewogCi0JLyogVGhpcyB0YWJsZSB3b3JrcyBpbiBjb25qdWN0aW9uIHdpdGggdGhlIG9uZSBpbiAuL21hY2gtY29tbW9uL2VudHJ5LlMKKwkvKiBUaGlzIHRhYmxlIHdvcmtzIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIG9uZSBpbiAuL21hY2gtY29tbW9uL2VudHJ5LlMKIAkgKiBTb21lIGV4Y2VwdGlvbnMgYXJlIGhhbmRsZWQgdGhlcmUgKGluIGFzc2VtYmx5LCBpbiBleGNlcHRpb24gc3BhY2UpCiAJICogU29tZSBhcmUgaGFuZGxlZCBoZXJlLCAoaW4gQywgaW4gaW50ZXJydXB0IHNwYWNlKQogCSAqIFNvbWUsIGxpa2UgQ1BMQiwgYXJlIGhhbmRsZWQgaW4gYm90aCwgd2hlcmUgdGhlIG5vcm1hbCBwYXRoIGlzCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2xpYi9pbnMuUyBiL2FyY2gvYmxhY2tmaW4vbGliL2lucy5TCmluZGV4IDNlZGJkOGQuLjc5Y2FjY2UgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL2lucy5TCisrKyBiL2FyY2gvYmxhY2tmaW4vbGliL2lucy5TCkBAIC02Nyw3ICs2Nyw3IEBACiAgKiAgLSBETUEgdmVyc2lvbiwgd2hpY2ggZG8gbm90IHN1ZmZlciBmcm9tIHRoaXMgaXNzdWUuIERNQSB2ZXJzaW9ucyBoYXZlCiAgKiAgICAgIGRpZmZlcmVudCBuYW1lIChwcmVmaXhlZCBieSBkbWFfICksIGFuZCBhcmUgbG9jYXRlZCBpbgogICogICAgICAuLi9rZXJuZWwvYmZpbl9kbWFfNXh4LmMKLSAqIFVzaW5nIHRoZSBkbWEgcmVsYXRlZCBmdW5jdGlvbnMgYXJlIHJlY29tbWVuZGVkIGZvciB0cmFuc2ZlcmluZyBsYXJnZQorICogVXNpbmcgdGhlIGRtYSByZWxhdGVkIGZ1bmN0aW9ucyBhcmUgcmVjb21tZW5kZWQgZm9yIHRyYW5zZmVycmluZyBsYXJnZQogICogYnVmZmVycyBpbi9vdXQgb2YgRklGT3MuCiAgKi8KIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvbWVtbW92ZS5TIGIvYXJjaC9ibGFja2Zpbi9saWIvbWVtbW92ZS5TCmluZGV4IDgwYzI0MGEuLjRlY2E1NjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL21lbW1vdmUuUworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9tZW1tb3ZlLlMKQEAgLTYwLDcgKzYwLDcgQEAKIAlbUDArK10gPSBSMTsKIAogCUNDID0gUDIgPT0gMDsgICAgICAgICAgICAgLyogYW55IHJlbWFpbmluZyBieXRlcz8gKi8KLQlQMyA9IEkwOyAgICAgICAgICAgICAgICAgIC8qIEFtbWVuZCBQMyB0byB1cGRhdGVkIHB0ci4gKi8KKwlQMyA9IEkwOyAgICAgICAgICAgICAgICAgIC8qIEFtZW5kIFAzIHRvIHVwZGF0ZWQgcHRyLiAqLwogCUlGICFDQyBKVU1QIC5MYnl0ZXM7CiAJUDMgPSBJMTsKIAlSVFM7CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3N0YW1wLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3N0YW1wLmMKaW5kZXggMmM2OTc4NS4uM2ZhMzM1NCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9zdGFtcC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvc3RhbXAuYwpAQCAtMjUzMCw3ICsyNTMwLDcgQEAKIHN0YXRpYyBzdHJ1Y3QgcGF0YV9wbGF0Zm9ybV9pbmZvIGJmaW5fcGF0YV9wbGF0Zm9ybV9kYXRhID0gewogCS5pb3BvcnRfc2hpZnQgPSAwLAogfTsKLS8qIENvbXBhY3RGbGFzaCBTdG9yYWdlIENhcmQgTWVtb3J5IE1hcHBlZCBBZHJlc3NpbmcKKy8qIENvbXBhY3RGbGFzaCBTdG9yYWdlIENhcmQgTWVtb3J5IE1hcHBlZCBBZGRyZXNzaW5nCiAgKiAvUkVHID0gQTExID0gMQogICovCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fcGF0YV9yZXNvdXJjZXNbXSA9IHsKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vZW50cnkuUyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vZW50cnkuUwppbmRleCA0NmFiNDU3Li5mOTY5MzNmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2VudHJ5LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9lbnRyeS5TCkBAIC0yNjgsNyArMjY4LDcgQEAKIAkvKiBUbyBnZXQgaGVyZSwgd2UganVzdCB0cmllZCBhbmQgZmFpbGVkIHRvIGNoYW5nZSBhIENQTEIKIAkgKiBzbywgaGFuZGxlIHRoaW5ncyBpbiB0cmFwX2MgKEMgY29kZSksIGJ5IGxvd2VyaW5nIHRvCiAJICogSVJRNSwganVzdCBsaWtlIHdlIG5vcm1hbGx5IGRvLiBTaW5jZSB0aGlzIGlzIG5vdCBhCi0JICogIm5vcm1hbCIgcmV0dXJuIHBhdGgsIHdlIGhhdmUgYSBkbyBhbG90IG9mIHN0dWZmIHRvCisJICogIm5vcm1hbCIgcmV0dXJuIHBhdGgsIHdlIGhhdmUgYSBkbyBhIGxvdCBvZiBzdHVmZiB0bwogCSAqIHRoZSBzdGFjayB0byBnZXQgcmVhZHkgc28sIHdlIGNhbiBmYWxsIHRocm91Z2ggLSB3ZQogCSAqIG5lZWQgdG8gbWFrZSBhIENQTEIgZXhjZXB0aW9uIGxvb2sgbGlrZSBhIG5vcm1hbCBleGNlcHRpb24KIAkgKi8KQEAgLTgxNyw3ICs4MTcsNyBAQAogCXJldHMgPSBbc3ArK107CiAKIAkvKgotCSAqIFdoZW4gd2UgY29tZSBvdXQgb2YgcmVzdW1lLCByMCBjYXJyaWVzICJvbGQiIHRhc2ssIGJlY3Vhc2Ugd2UgYXJlCisJICogV2hlbiB3ZSBjb21lIG91dCBvZiByZXN1bWUsIHIwIGNhcnJpZXMgIm9sZCIgdGFzaywgYmVjYXVzZSB3ZSBhcmUKIAkgKiBpbiAibmV3IiB0YXNrLgogCSAqLwogCXJ0czsKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaGVhZC5TIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9oZWFkLlMKaW5kZXggNTgxZTJiMC4uNzZkZTU3MiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9oZWFkLlMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9oZWFkLlMKQEAgLTE3NCw3ICsxNzQsNyBAQAogCXNwLmwgPSBsbyhLRVJORUxfQ0xPQ0tfU1RBQ0spOwogCXNwLmggPSBoaShLRVJORUxfQ0xPQ0tfU1RBQ0spOwogCWNhbGwgX2luaXRfY2xvY2tzOwotCXNwID0gdXNwOwkvKiB1c3AgaGFzbnQgYmVlbiB0b3VjaGVkLCBzbyByZXN0b3JlIGZyb20gdGhlcmUgKi8KKwlzcCA9IHVzcDsJLyogdXNwIGhhc24ndCBiZWVuIHRvdWNoZWQsIHNvIHJlc3RvcmUgZnJvbSB0aGVyZSAqLwogI2VuZGlmCiAKIAkvKiBUaGlzIHNlY3Rpb24ga2VlcHMgdGhlIHByb2Nlc3NvciBpbiBzdXBlcnZpc29yIG1vZGUKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYxMC9SRUFETUUubW0gYi9hcmNoL2NyaXMvYXJjaC12MTAvUkVBRE1FLm1tCmluZGV4IDUxN2QxZjAuLjY3NzMxZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYxMC9SRUFETUUubW0KKysrIGIvYXJjaC9jcmlzL2FyY2gtdjEwL1JFQURNRS5tbQpAQCAtMzgsNyArMzgsNyBAQAogbWFwIGR1cmluZyBrZXJuZWwtbW9kZSwgc28gdGhhdCB0aGUga2VybmVsIGVhc2lseSBjYW4gYWNjZXNzIHRoZSBjb3JyZXNwb25kaW5nCiB1c2VyLW1vZGUgcHJvY2VzcycgZGF0YS4KIAotQXMgYSBjb21wYXJpc2lvbiwgdGhlIExpbnV4L2kzODYgMi4wIHB1dHMgdGhlIGtlcm5lbCBhbmQgcGh5c2ljYWwgUkFNIGF0CitBcyBhIGNvbXBhcmlzb24sIHRoZSBMaW51eC9pMzg2IDIuMCBwdXRzIHRoZSBrZXJuZWwgYW5kIHBoeXNpY2FsIFJBTSBhdAogYWRkcmVzcyAwLCBvdmVybGFwcGluZyB3aXRoIHRoZSB1c2VyLW1vZGUgdmlydHVhbCBzcGFjZSwgc28gdGhhdCBkZXNjcmlwdG9yCiByZWdpc3RlcnMgYXJlIG5lZWRlZCBmb3IgZWFjaCBtZW1vcnkgYWNjZXNzIHRvIHNwZWNpZnkgd2hpY2ggTU1VIHNwYWNlIHRvCiBtYXAgdGhyb3VnaC4gVGhhdCBjaGFuZ2VkIGluIDIuMiwgcHV0dGluZyB0aGUga2VybmVsL3BoeXNpY2FsIFJBTSBhdCAKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYxMC9kcml2ZXJzL3N5bmNfc2VyaWFsLmMgYi9hcmNoL2NyaXMvYXJjaC12MTAvZHJpdmVycy9zeW5jX3NlcmlhbC5jCmluZGV4IDM5OWRjMWUuLjg1MDI2NTM3IDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvYXJjaC12MTAvZHJpdmVycy9zeW5jX3NlcmlhbC5jCisrKyBiL2FyY2gvY3Jpcy9hcmNoLXYxMC9kcml2ZXJzL3N5bmNfc2VyaWFsLmMKQEAgLTMxLDcgKzMxLDcgQEAKICNpbmNsdWRlIDxhc20vc3luY19zZXJpYWwuaD4KICNpbmNsdWRlIDxhcmNoL2lvX2ludGVyZmFjZV9tdXguaD4KIAotLyogVGhlIHJlY2VpdmVyIGlzIGEgYml0IHRyaWNreSBiZWFjdXNlIG9mIHRoZSBjb250aW51b3VzIHN0cmVhbSBvZiBkYXRhLiovCisvKiBUaGUgcmVjZWl2ZXIgaXMgYSBiaXQgdHJpY2t5IGJlY2F1c2Ugb2YgdGhlIGNvbnRpbnVvdXMgc3RyZWFtIG9mIGRhdGEuKi8KIC8qICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwogLyogVGhyZWUgRE1BIGRlc2NyaXB0b3JzIGFyZSBsaW5rZWQgdG9nZXRoZXIuIEVhY2ggRE1BIGRlc2NyaXB0b3IgaXMgICAgICovCiAvKiByZXNwb25zaWJsZSBmb3IgcG9ydC0+YnVmY2h1bmsgb2YgYSBjb21tb24gYnVmZmVyLiAgICAgICAgICAgICAgICAgICAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9kcml2ZXJzL2F4aXNmbGFzaG1hcC5jIGIvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvYXhpc2ZsYXNobWFwLmMKaW5kZXggM2Q3NTEyNS4uN2IxNTVmOCAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvYXhpc2ZsYXNobWFwLmMKKysrIGIvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvYXhpc2ZsYXNobWFwLmMKQEAgLTIxNSw3ICsyMTUsNyBAQAogfTsKICNlbmRpZgogCi0vKiBBdXhpbGxpYXJ5IHBhcnRpdGlvbiBpZiB3ZSBmaW5kIGFub3RoZXIgZmxhc2ggKi8KKy8qIEF1eGlsaWFyeSBwYXJ0aXRpb24gaWYgd2UgZmluZCBhbm90aGVyIGZsYXNoICovCiBzdGF0aWMgc3RydWN0IG10ZF9wYXJ0aXRpb24gYXV4X3BhcnRpdGlvbiA9IHsKIAkubmFtZSA9ICJhdXgiLAogCS5zaXplID0gMCwKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9kcml2ZXJzL21hY2gtYTMvbmFuZGZsYXNoLmMgYi9hcmNoL2NyaXMvYXJjaC12MzIvZHJpdmVycy9tYWNoLWEzL25hbmRmbGFzaC5jCmluZGV4IDI1ZDZmMmIuLmY1OGYyYzEgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9kcml2ZXJzL21hY2gtYTMvbmFuZGZsYXNoLmMKKysrIGIvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvbWFjaC1hMy9uYW5kZmxhc2guYwpAQCAtMTY1LDcgKzE2NSw3IEBACiAJLyogRW5hYmxlIHRoZSBmb2xsb3dpbmcgZm9yIGEgZmxhc2ggYmFzZWQgYmFkIGJsb2NrIHRhYmxlICovCiAJLyogdGhpcy0+b3B0aW9ucyA9IE5BTkRfVVNFX0ZMQVNIX0JCVDsgKi8KIAotCS8qIFNjYW4gdG8gZmluZCBleGlzdGFuY2Ugb2YgdGhlIGRldmljZSAqLworCS8qIFNjYW4gdG8gZmluZCBleGlzdGVuY2Ugb2YgdGhlIGRldmljZSAqLwogCWlmIChuYW5kX3NjYW4oY3Jpc3YzMl9tdGQsIDEpKSB7CiAJCWVyciA9IC1FTlhJTzsKIAkJZ290byBvdXRfbXRkOwpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvbWFjaC1mcy9uYW5kZmxhc2guYyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9kcml2ZXJzL21hY2gtZnMvbmFuZGZsYXNoLmMKaW5kZXggYzVhMGY1NC4uZDViMGNjOSAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvbWFjaC1mcy9uYW5kZmxhc2guYworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIvZHJpdmVycy9tYWNoLWZzL25hbmRmbGFzaC5jCkBAIC0xNTYsNyArMTU2LDcgQEAKIAkvKiBFbmFibGUgdGhlIGZvbGxvd2luZyBmb3IgYSBmbGFzaCBiYXNlZCBiYWQgYmxvY2sgdGFibGUgKi8KIAkvKiB0aGlzLT5vcHRpb25zID0gTkFORF9VU0VfRkxBU0hfQkJUOyAqLwogCi0JLyogU2NhbiB0byBmaW5kIGV4aXN0YW5jZSBvZiB0aGUgZGV2aWNlICovCisJLyogU2NhbiB0byBmaW5kIGV4aXN0ZW5jZSBvZiB0aGUgZGV2aWNlICovCiAJaWYgKG5hbmRfc2NhbihjcmlzdjMyX210ZCwgMSkpIHsKIAkJZXJyID0gLUVOWElPOwogCQlnb3RvIG91dF9pb3I7CmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvYXJjaC12MzIvZHJpdmVycy9zeW5jX3NlcmlhbC5jIGIvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvc3luY19zZXJpYWwuYwppbmRleCBjODYzN2E5Li5hNmExODBiIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvYXJjaC12MzIvZHJpdmVycy9zeW5jX3NlcmlhbC5jCisrKyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9kcml2ZXJzL3N5bmNfc2VyaWFsLmMKQEAgLTMzLDcgKzMzLDcgQEAKICNpbmNsdWRlIDxhc20vc3luY19zZXJpYWwuaD4KIAogCi0vKiBUaGUgcmVjZWl2ZXIgaXMgYSBiaXQgdHJpY2t5IGJlYWN1c2Ugb2YgdGhlIGNvbnRpbnVvdXMgc3RyZWFtIG9mIGRhdGEuKi8KKy8qIFRoZSByZWNlaXZlciBpcyBhIGJpdCB0cmlja3kgYmVjYXVzZSBvZiB0aGUgY29udGludW91cyBzdHJlYW0gb2YgZGF0YS4qLwogLyogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCiAvKiBUaHJlZSBETUEgZGVzY3JpcHRvcnMgYXJlIGxpbmtlZCB0b2dldGhlci4gRWFjaCBETUEgZGVzY3JpcHRvciBpcyAgICAgKi8KIC8qIHJlc3BvbnNpYmxlIGZvciBwb3J0LT5idWZjaHVuayBvZiBhIGNvbW1vbiBidWZmZXIuICAgICAgICAgICAgICAgICAgICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9lbnRyeS5TIGIvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9lbnRyeS5TCmluZGV4IDBlY2I1MGIuLjNhYmYxMmMgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvZW50cnkuUworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2VudHJ5LlMKQEAgLTE4Miw3ICsxODIsNyBAQAogCW1vdmUuZAkkcjAsIFskc3BdCiAKIAk7OyBUaGUgcmVnaXN0ZXJzIGNhcnJ5aW5nIHBhcmFtZXRlcnMgKFIxMC1SMTMpIGFyZSBpbnRhY3QuIFRoZSBvcHRpb25hbAotCTs7IGZpZnRoIGFuZCBzaXh0aCBwYXJhbWV0ZXJzIGlzIGluIE1PRiBhbmQgU1JQIHJlc3BlY3Rpdmx5LiBQdXQgdGhlbQorCTs7IGZpZnRoIGFuZCBzaXh0aCBwYXJhbWV0ZXJzIGlzIGluIE1PRiBhbmQgU1JQIHJlc3BlY3RpdmVseS4gUHV0IHRoZW0KIAk7OyBiYWNrIG9uIHRoZSBzdGFjay4KIAlzdWJxCTQsICRzcAogCW1vdmUJJHNycCwgWyRzcF0KZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvaXJxLmMgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2lycS5jCmluZGV4IDgwMjMxNzYuLjY4YTFhNTkgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvaXJxLmMKKysrIGIvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9pcnEuYwpAQCAtMzc0LDcgKzM3NCw3IEBACiAJaXJxX2VudGVyKCk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgTkJSX1JFR1M7IGkrKykgewotCQkvKiBHZXQgd2hpY2ggSVJRcyB0aGF0IGhhcHBlbmQuICovCisJCS8qIEdldCB3aGljaCBJUlFzIHRoYXQgaGFwcGVuZWQuICovCiAJCW1hc2tlZFtpXSA9IFJFR19SRF9JTlRfVkVDVChpbnRyX3ZlY3QsIGlycV9yZWdzW2NwdV0sCiAJCQlyX21hc2tlZF92ZWN0LCBpKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9rZ2RiLmMgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2tnZGIuYwppbmRleCA2YjY1MzMyLi5jMDM0M2MzIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2tnZGIuYworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2tnZGIuYwpAQCAtOTI1LDcgKzkyNSw3IEBACiAKIAkJCQkJaWYgKHJlZy5lZGEgPj0gYnBfZF9yZWdzW2JwICogMl0gJiYKIAkJCQkJICAgIHJlZy5lZGEgPD0gYnBfZF9yZWdzW2JwICogMiArIDFdKSB7Ci0JCQkJCQkvKiBFREEgd2l0aGluZyByYW5nZSBmb3IgdGhpcyBCUDsgaXQgbXVzdCBiZSB0aGUgb25lCisJCQkJCQkvKiBFREEgd2l0aGluIHJhbmdlIGZvciB0aGlzIEJQOyBpdCBtdXN0IGJlIHRoZSBvbmUKIAkJCQkJCSAgIHdlJ3JlIGxvb2tpbmcgZm9yLiAqLwogCQkJCQkJc3RvcHBlZF9kYXRhX2FkZHJlc3MgPSByZWcuZWRhOwogCQkJCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL3Byb2Nlc3MuYyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvcHJvY2Vzcy5jCmluZGV4IDU2MmY4NDcuLjA1NzBlOGMgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvcHJvY2Vzcy5jCisrKyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvcHJvY2Vzcy5jCkBAIC0xNDksNyArMTQ5LDcgQEAKICAgICAgICAgY2hpbGRyZWdzLT5yMTAgPSAwOwkvKiBDaGlsZCByZXR1cm5zIDAgYWZ0ZXIgYSBmb3JrL2Nsb25lLiAqLwogCiAJLyogU2V0IGEgbmV3IFRMUyA/Ci0JICogVGhlIFRMUyBpcyBpbiAkbW9mIGJlYWN1c2UgaXQgaXMgdGhlIDV0aCBhcmd1bWVudCB0byBzeXNfY2xvbmUuCisJICogVGhlIFRMUyBpcyBpbiAkbW9mIGJlY2F1c2UgaXQgaXMgdGhlIDV0aCBhcmd1bWVudCB0byBzeXNfY2xvbmUuCiAJICovCiAJaWYgKHAtPm1tICYmIChjbG9uZV9mbGFncyAmIENMT05FX1NFVFRMUykpIHsKIAkJdGFza190aHJlYWRfaW5mbyhwKS0+dGxzID0gcmVncy0+bW9mOwpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9zaWduYWwuYyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvc2lnbmFsLmMKaW5kZXggYjNhMDVhZS4uY2U0YWIxYSAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9zaWduYWwuYworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL3NpZ25hbC5jCkBAIC02MTAsNyArNjEwLDcgQEAKIAkJdXNlcl9yZWdzKHRpKS0+c3BjID0gMDsKIAl9CiAJLyogRklYTUU6IEZpbHRlciBvdXQgZmFsc2UgaC93IGJyZWFrcG9pbnQgaGl0cyAoaS5lLiBFREEKLQkgICBub3Qgd2l0aGluZyBhbnkgY29uZmlndXJlZCBoL3cgYnJlYWtwb2ludCByYW5nZSkuIFN5bmNocm9uaXplIHdpdGgKKwkgICBub3Qgd2l0aGluIGFueSBjb25maWd1cmVkIGgvdyBicmVha3BvaW50IHJhbmdlKS4gU3luY2hyb25pemUgd2l0aAogCSAgIHdoYXQgYWxyZWFkeSBleGlzdHMgZm9yIGtlcm5lbCBkZWJ1Z2dpbmcuICAqLwogCWlmICgoKHVzZXJfcmVncyh0aSktPmV4cyAmIDB4ZmYwMCkgPj4gOCkgPT0gQlJFQUtfOF9JTlRSX1ZFQ1QpIHsKIAkJLyogQnJlYWsgODogc3VidHJhY3QgMiBmcm9tIEVSUCB1bmxlc3MgaW4gYSBkZWxheSBzbG90LiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2FyY2gtdjMyL21hY2gtYTMvYXJiaXRlci5jIGIvYXJjaC9jcmlzL2FyY2gtdjMyL21hY2gtYTMvYXJiaXRlci5jCmluZGV4IDhiOTI0ZGIuLjE1ZjVjOWQgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9tYWNoLWEzL2FyYml0ZXIuYworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIvbWFjaC1hMy9hcmJpdGVyLmMKQEAgLTU2OCw3ICs1NjgsNyBAQAogCVJFR19XUihtYXJiX2Zvb19icCwgd2F0Y2gtPmluc3RhbmNlLCByd19hY2ssIGFjayk7CiAJUkVHX1dSKG1hcmJfZm9vLCByZWdpX21hcmJfZm9vLCByd19hY2tfaW50ciwgYWNrX2ludHIpOwogCi0JcHJpbnRrKEtFUk5fREVCVUcgIklSUSBvY2N1cmVkIGF0ICVYXG4iLCAodW5zaWduZWQpZ2V0X2lycV9yZWdzKCkpOworCXByaW50ayhLRVJOX0RFQlVHICJJUlEgb2NjdXJyZWQgYXQgJVhcbiIsICh1bnNpZ25lZClnZXRfaXJxX3JlZ3MoKSk7CiAKIAlpZiAod2F0Y2gtPmNiKQogCQl3YXRjaC0+Y2IoKTsKQEAgLTYyNCw3ICs2MjQsNyBAQAogCVJFR19XUihtYXJiX2Jhcl9icCwgd2F0Y2gtPmluc3RhbmNlLCByd19hY2ssIGFjayk7CiAJUkVHX1dSKG1hcmJfYmFyLCByZWdpX21hcmJfYmFyLCByd19hY2tfaW50ciwgYWNrX2ludHIpOwogCi0JcHJpbnRrKEtFUk5fREVCVUcgIklSUSBvY2N1cmVkIGF0ICVYXG4iLCAodW5zaWduZWQpZ2V0X2lycV9yZWdzKCktPmVycCk7CisJcHJpbnRrKEtFUk5fREVCVUcgIklSUSBvY2N1cnJlZCBhdCAlWFxuIiwgKHVuc2lnbmVkKWdldF9pcnFfcmVncygpLT5lcnApOwogCiAJaWYgKHdhdGNoLT5jYikKIAkJd2F0Y2gtPmNiKCk7CmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvYXJjaC12MzIvbWFjaC1mcy9hcmJpdGVyLmMgYi9hcmNoL2NyaXMvYXJjaC12MzIvbWFjaC1mcy9hcmJpdGVyLmMKaW5kZXggODJlZjI5My4uM2Y4ZWJiNSAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2FyY2gtdjMyL21hY2gtZnMvYXJiaXRlci5jCisrKyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9tYWNoLWZzL2FyYml0ZXIuYwpAQCAtMzk1LDcgKzM5NSw3IEBACiAJUkVHX1dSKG1hcmJfYnAsIHdhdGNoLT5pbnN0YW5jZSwgcndfYWNrLCBhY2spOwogCVJFR19XUihtYXJiLCByZWdpX21hcmIsIHJ3X2Fja19pbnRyLCBhY2tfaW50cik7CiAKLQlwcmludGsoS0VSTl9JTkZPICJJUlEgb2NjdXJlZCBhdCAlbFhcbiIsIGdldF9pcnFfcmVncygpLT5lcnApOworCXByaW50ayhLRVJOX0lORk8gIklSUSBvY2N1cnJlZCBhdCAlbFhcbiIsIGdldF9pcnFfcmVncygpLT5lcnApOwogCiAJaWYgKHdhdGNoLT5jYikKIAkJd2F0Y2gtPmNiKCk7CmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvYm9vdC9yZXNjdWUvaGVhZF92MTAuUyBiL2FyY2gvY3Jpcy9ib290L3Jlc2N1ZS9oZWFkX3YxMC5TCmluZGV4IDJmYWZlMjQuLmFmNTVkZjAgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9ib290L3Jlc2N1ZS9oZWFkX3YxMC5TCisrKyBiL2FyY2gvY3Jpcy9ib290L3Jlc2N1ZS9oZWFkX3YxMC5TCkBAIC03LDcgKzcsNyBAQAogICogZm9yIGVhY2ggcGFydGl0aW9uIHRoYXQgdGhpcyBjb2RlIHNob3VsZCBjaGVjay4KICAqCiAgKiBJZiBhbnkgb2YgdGhlIGNoZWNrc3VtcyBmYWlsLCB3ZSBhc3N1bWUgdGhlIGZsYXNoIGlzIHNvCi0gKiBjb3JydXB0IHRoYXQgd2UgY2FudCB1c2UgaXQgdG8gYm9vdCBpbnRvIHRoZSBmdHAgZmxhc2gKKyAqIGNvcnJ1cHQgdGhhdCB3ZSBjYW4ndCB1c2UgaXQgdG8gYm9vdCBpbnRvIHRoZSBmdHAgZmxhc2gKICAqIGxvYWRlciwgYW5kIGluc3RlYWQgd2UgaW5pdGlhbGl6ZSB0aGUgc2VyaWFsIHBvcnQgdG8KICAqIHJlY2VpdmUgYSBmbGFzaC1sb2FkZXIgYW5kIG5ldyBmbGFzaCBpbWFnZS4gd2UgZG9udCBpbmNsdWRlCiAgKiBhbnkgZmxhc2ggY29kZSBoZXJlLCBidXQganVzdCBhY2NlcHQgYSBjZXJ0YWluIGFtb3VudCBvZgpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2luY2x1ZGUvYXJjaC12MzIvYXJjaC9od3JlZ3MvTWFrZWZpbGUgYi9hcmNoL2NyaXMvaW5jbHVkZS9hcmNoLXYzMi9hcmNoL2h3cmVncy9NYWtlZmlsZQppbmRleCBmOWEwNWQyLi5iOGIzZjhkIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvaW5jbHVkZS9hcmNoLXYzMi9hcmNoL2h3cmVncy9NYWtlZmlsZQorKysgYi9hcmNoL2NyaXMvaW5jbHVkZS9hcmNoLXYzMi9hcmNoL2h3cmVncy9NYWtlZmlsZQpAQCAtMSw2ICsxLDYgQEAKICMgTWFrZWZpbGUgdG8gZ2VuZXJhdGUgb3IgY29weSB0aGUgbGF0ZXN0IHJlZ2lzdGVyIGRlZmluaXRpb25zCiAjIGFuZCByZWxhdGVkIGRhdGFzdHJ1Y3R1cmVzIGFuZCBoZWxwZXJtYWNyb3MuCi0jIFRoZSBvZmZpY2FsIHBsYWNlIGZvciB0aGVzZSBmaWxlcyBpcyBhdDoKKyMgVGhlIG9mZmljaWFsIHBsYWNlIGZvciB0aGVzZSBmaWxlcyBpcyBhdDoKIFJFTEVBU0UgPz0gcjFfYWxmYTUKIE9GRklDSUFMX0lOQ0RJUiA9IC9uL2FzaWMvcHJvamVjdHMvZ3Vpbm5lc3MvcmVsZWFzZXMvJChSRUxFQVNFKS9kZXNpZ24vdG9wL3N3L2luY2x1ZGUvCiAKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9pbmNsdWRlL2FyY2gtdjMyL2FyY2gvaHdyZWdzL2lvcC9NYWtlZmlsZSBiL2FyY2gvY3Jpcy9pbmNsdWRlL2FyY2gtdjMyL2FyY2gvaHdyZWdzL2lvcC9NYWtlZmlsZQppbmRleCBhOTAwNTZhLi4wNzQ3YTIyIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvaW5jbHVkZS9hcmNoLXYzMi9hcmNoL2h3cmVncy9pb3AvTWFrZWZpbGUKKysrIGIvYXJjaC9jcmlzL2luY2x1ZGUvYXJjaC12MzIvYXJjaC9od3JlZ3MvaW9wL01ha2VmaWxlCkBAIC0xLDcgKzEsNyBAQAogIyAkSWQ6IE1ha2VmaWxlLHYgMS4zIDIwMDQvMDEvMDcgMjA6MzQ6NTUgam9oYW5hIEV4cCAkCiAjIE1ha2VmaWxlIHRvIGdlbmVyYXRlIG9yIGNvcHkgdGhlIGxhdGVzdCByZWdpc3RlciBkZWZpbml0aW9ucwogIyBhbmQgcmVsYXRlZCBkYXRhc3RydWN0dXJlcyBhbmQgaGVscGVybWFjcm9zLgotIyBUaGUgb2ZmaWNhbCBwbGFjZSBmb3IgdGhlc2UgZmlsZXMgaXMgcHJvYmFibHkgYXQ6CisjIFRoZSBvZmZpY2lhbCBwbGFjZSBmb3IgdGhlc2UgZmlsZXMgaXMgcHJvYmFibHkgYXQ6CiBSRUxFQVNFID89IHIxX2FsZmE1CiBJT1BPRkZJQ0lBTF9JTkNESVIgPSAvbi9hc2ljL3Byb2plY3RzL2d1aW5uZXNzL3JlbGVhc2VzLyQoUkVMRUFTRSkvZGVzaWduL3RvcC9zdy9pbmNsdWRlLwogCmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvaW5jbHVkZS9hc20vcGd0YWJsZS5oIGIvYXJjaC9jcmlzL2luY2x1ZGUvYXNtL3BndGFibGUuaAppbmRleCA5ZWFhZTIxLi43ZGY0MzAxIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvaW5jbHVkZS9hc20vcGd0YWJsZS5oCisrKyBiL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9wZ3RhYmxlLmgKQEAgLTk3LDcgKzk3LDcgQEAKICNkZWZpbmUgcHRlX2NsZWFyKG1tLGFkZHIseHApCWRvIHsgcHRlX3ZhbCgqKHhwKSkgPSAwOyB9IHdoaWxlICgwKQogCiAjZGVmaW5lIHBtZF9ub25lKHgpICAgICAoIXBtZF92YWwoeCkpCi0vKiBieSByZW1vdmluZyB0aGUgX1BBR0VfS0VSTkVMIGJpdCBmcm9tIHRoZSBjb21wYXJpc2lvbiwgdGhlIHNhbWUgcG1kX2JhZAorLyogYnkgcmVtb3ZpbmcgdGhlIF9QQUdFX0tFUk5FTCBiaXQgZnJvbSB0aGUgY29tcGFyaXNvbiwgdGhlIHNhbWUgcG1kX2JhZAogICogd29ya3MgZm9yIGJvdGggX1BBR0VfVEFCTEUgYW5kIF9LRVJOUEdfVEFCTEUgcG1kIGVudHJpZXMuCiAgKi8KICNkZWZpbmUJcG1kX2JhZCh4KQkoKHBtZF92YWwoeCkgJiAoflBBR0VfTUFTSyAmIH5fUEFHRV9LRVJORUwpKSAhPSBfUEFHRV9UQUJMRSkKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9rZXJuZWwvdHJhcHMuYyBiL2FyY2gvY3Jpcy9rZXJuZWwvdHJhcHMuYwppbmRleCA1NDFlZmJmMC4uOGRhNTNmMyAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2tlcm5lbC90cmFwcy5jCisrKyBiL2FyY2gvY3Jpcy9rZXJuZWwvdHJhcHMuYwpAQCAtMTgzLDcgKzE4Myw3IEBACiAKIC8qCiAgKiBUaGlzIGdldHMgY2FsbGVkIGZyb20gZW50cnkuUyB3aGVuIHRoZSB3YXRjaGRvZyBoYXMgYml0dGVuLiBTaG93IHNvbWV0aGluZwotICogc2ltaWxpYXIgdG8gYW4gT29wcyBkdW1wLCBhbmQgaWYgdGhlIGtlcm5lbCBpcyBjb25maWd1cmVkIHRvIGJlIGEgbmljZQorICogc2ltaWxhciB0byBhbiBPb3BzIGR1bXAsIGFuZCBpZiB0aGUga2VybmVsIGlzIGNvbmZpZ3VyZWQgdG8gYmUgYSBuaWNlCiAgKiBkb2dneSwgdGhlbiBoYWx0IGluc3RlYWQgb2YgcmVib290LgogICovCiB2b2lkCmRpZmYgLS1naXQgYS9hcmNoL2Zydi9pbmNsdWRlL2FzbS9wY2kuaCBiL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3BjaS5oCmluZGV4IDBkNTk5NzkuLmVmMDNiYWYgMTAwNjQ0Ci0tLSBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3BjaS5oCisrKyBiL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3BjaS5oCkBAIC01NCw3ICs1NCw3IEBACiAjZW5kaWYKIAogLyoKLSAqCVRoZXNlIGFyZSBwcmV0dHkgbXVjaCBhcmJpdGFyeSB3aXRoIHRoZSBDb01FTSBpbXBsZW1lbnRhdGlvbi4KKyAqCVRoZXNlIGFyZSBwcmV0dHkgbXVjaCBhcmJpdHJhcnkgd2l0aCB0aGUgQ29NRU0gaW1wbGVtZW50YXRpb24uCiAgKglXZSBoYXZlIHRoZSB3aG9sZSBhZGRyZXNzIHNwYWNlIHRvIG91cnNlbHZlcy4KICAqLwogI2RlZmluZSBQQ0lCSU9TX01JTl9JTwkJMHgxMDAKZGlmZiAtLWdpdCBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3Nwci1yZWdzLmggYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS9zcHItcmVncy5oCmluZGV4IDAxZTZhZjUuLmQzODgzMDIgMTAwNjQ0Ci0tLSBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3Nwci1yZWdzLmgKKysrIGIvYXJjaC9mcnYvaW5jbHVkZS9hc20vc3ByLXJlZ3MuaApAQCAtMjc0LDcgKzI3NCw3IEBACiAjZGVmaW5lIE1TUjBfUkQJCQkweGMwMDAwMDAwCS8qIHJvdW5kaW5nIG1vZGUgKi8KICNkZWZpbmUgTVNSMF9SRF9ORUFSRVNUCQkweDAwMDAwMDAwCS8qIC0gbmVhcmVzdCAqLwogI2RlZmluZSBNU1IwX1JEX1pFUk8JCTB4NDAwMDAwMDAJLyogLSB6ZXJvICovCi0jZGVmaW5lIE1TUjBfUkRfUE9TX0lORgkJMHg4MDAwMDAwMAkvKiAtIHBvc3RpdmUgaW5maW5pdHkgKi8KKyNkZWZpbmUgTVNSMF9SRF9QT1NfSU5GCQkweDgwMDAwMDAwCS8qIC0gcG9zaXRpdmUgaW5maW5pdHkgKi8KICNkZWZpbmUgTVNSMF9SRF9ORUdfSU5GCQkweGMwMDAwMDAwCS8qIC0gbmVnYXRpdmUgaW5maW5pdHkgKi8KIAogLyoKZGlmZiAtLWdpdCBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3ZpcnRjb252ZXJ0LmggYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS92aXJ0Y29udmVydC5oCmluZGV4IDU5Nzg4ZmEuLmIyNmQ3MGEgMTAwNjQ0Ci0tLSBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL3ZpcnRjb252ZXJ0LmgKKysrIGIvYXJjaC9mcnYvaW5jbHVkZS9hc20vdmlydGNvbnZlcnQuaApAQCAtMSw0ICsxLDQgQEAKLS8qIHZpcnRjb252ZXJ0Lmg6IHZpcnR1YWwvcGh5c2ljYWwvcGFnZSBhZGRyZXNzIGNvbnZlcnRpb24KKy8qIHZpcnRjb252ZXJ0Lmg6IHZpcnR1YWwvcGh5c2ljYWwvcGFnZSBhZGRyZXNzIGNvbnZlcnNpb24KICAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQgUmVkIEhhdCwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgogICogV3JpdHRlbiBieSBEYXZpZCBIb3dlbGxzIChkaG93ZWxsc0ByZWRoYXQuY29tKQpkaWZmIC0tZ2l0IGEvYXJjaC9mcnYva2VybmVsL2VudHJ5LXRhYmxlLlMgYi9hcmNoL2Zydi9rZXJuZWwvZW50cnktdGFibGUuUwppbmRleCBiZjM1ZjMzLi4wNmM1YWUxIDEwMDY0NAotLS0gYS9hcmNoL2Zydi9rZXJuZWwvZW50cnktdGFibGUuUworKysgYi9hcmNoL2Zydi9rZXJuZWwvZW50cnktdGFibGUuUwpAQCAtODYsNyArODYsNyBAQAogCS5nbG9ibAkJX19icmVha19rZXJuZWx0cmFwX2ZpeHVwX3RhYmxlCiBfX2JyZWFrX2tlcm5lbHRyYXBfZml4dXBfdGFibGU6CiAKLQkjIGhhbmRsZXIgZGVjbGFyYXRpb24gZm9yIGEgc29md2FyZSBvciBwcm9ncmFtIGludGVycnVwdAorCSMgaGFuZGxlciBkZWNsYXJhdGlvbiBmb3IgYSBzb2Z0d2FyZSBvciBwcm9ncmFtIGludGVycnVwdAogLm1hY3JvIFZFQ1RPUl9TT0ZUUFJPRyB0YnJfdHQsIHZlYwogCS5zZWN0aW9uIC50cmFwLnVzZXIKIAkub3JnCQlcdGJyX3R0CkBAIC0xNDUsNyArMTQ1LDcgQEAKIAkubG9uZwkJXHZlYwogLmVuZG0KIAotCSMgaGFuZGxlciBkZWNsYXJhdGlvbiBmb3IgYW4gTU1VIG9ubHkgc29md2FyZSBvciBwcm9ncmFtIGludGVycnVwdAorCSMgaGFuZGxlciBkZWNsYXJhdGlvbiBmb3IgYW4gTU1VIG9ubHkgc29mdHdhcmUgb3IgcHJvZ3JhbSBpbnRlcnJ1cHQKIC5tYWNybyBWRUNUT1JfU1BfTU1VIHRicl90dCwgdmVjCiAjaWZkZWYgQ09ORklHX01NVQogIAlWRUNUT1JfU09GVFBST0cJXHRicl90dCwgXHZlYwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L0tjb25maWcgYi9hcmNoL2lhNjQvS2NvbmZpZwppbmRleCBjNGVhMDkyLi5lNWNjNTZhIDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvS2NvbmZpZworKysgYi9hcmNoL2lhNjQvS2NvbmZpZwpAQCAtNDE0LDExICs0MTQsMTEgQEAKIAlzdXBwb3J0LiAKIAogY29uZmlnIEZPUkNFX0NQRUlfUkVUQVJHRVQKLQlib29sICJGb3JjZSBhc3N1bXB0aW9uIHRoYXQgQ1BFSSBjYW4gYmUgcmUtdGFyZ2V0dGVkIgorCWJvb2wgIkZvcmNlIGFzc3VtcHRpb24gdGhhdCBDUEVJIGNhbiBiZSByZS10YXJnZXRlZCIKIAlkZXBlbmRzIG9uIFBFUk1JVF9CU1BfUkVNT1ZFCiAJZGVmYXVsdCBuCiAJLS0taGVscC0tLQotCVNheSBZIGlmIHlvdSBuZWVkIHRvIGZvcmNlIHRoZSBhc3N1bXB0aW9uIHRoYXQgQ1BFSSBjYW4gYmUgcmUtdGFyZ2V0dGVkIHRvCisJU2F5IFkgaWYgeW91IG5lZWQgdG8gZm9yY2UgdGhlIGFzc3VtcHRpb24gdGhhdCBDUEVJIGNhbiBiZSByZS10YXJnZXRlZCB0bwogCWFueSBjcHUgaW4gdGhlIHN5c3RlbS4gVGhpcyBoaW50IGlzIGF2YWlsYWJsZSB2aWEgQUNQSSAzLjAgc3BlY2lmaWNhdGlvbnMuCiAJVGlnZXI0IHN5c3RlbXMgYXJlIGNhcGFibGUgb2YgcmUtZGlyZWN0aW5nIENQRUkgdG8gYW55IENQVSBvdGhlciB0aGFuIEJTUC4KIAlUaGlzIG9wdGlvbiBpdCB1c2VmdWwgdG8gZW5hYmxlIHRoaXMgZmVhdHVyZSBvbiBvbGRlciBCSU9TJ3MgYXMgd2VsbC4KZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9wYWwuaCBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9wYWwuaAppbmRleCA2YTI5MjUwLi4yZTY5Mjg0IDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vcGFsLmgKKysrIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3BhbC5oCkBAIC0xNjY5LDcgKzE2NjksNyBAQAogfSBwYWxfdnBfaW5mb191X3Q7CiAKIC8qCi0gKiBSZXR1cm5zIGluZm9tYXRpb24gYWJvdXQgdmlydHVhbCBwcm9jZXNzb3IgZmVhdHVyZXMKKyAqIFJldHVybnMgaW5mb3JtYXRpb24gYWJvdXQgdmlydHVhbCBwcm9jZXNzb3IgZmVhdHVyZXMKICAqLwogc3RhdGljIGlubGluZSBzNjQKIGlhNjRfcGFsX3ZwX2luZm8gKHU2NCBmZWF0dXJlX3NldCwgdTY0IHZwX2J1ZmZlciwgdTY0ICp2cF9pbmZvLCB1NjQgKnZtbV9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9wZXJmbW9uX2RlZmF1bHRfc21wbC5oIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3BlcmZtb25fZGVmYXVsdF9zbXBsLmgKaW5kZXggNzQ3MjRiMi4uYTJkNTYwYyAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3BlcmZtb25fZGVmYXVsdF9zbXBsLmgKKysrIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3BlcmZtb25fZGVmYXVsdF9zbXBsLmgKQEAgLTY3LDggKzY3LDggQEAKICAgICAgICAgdW5zaWduZWQgbG9uZyAgIGlwOyAgICAgICAgICAgICAgICAgICAgIC8qIHdoZXJlIGRpZCB0aGUgb3ZlcmZsb3cgaW50ZXJydXB0IGhhcHBlbmVkICAqLwogICAgICAgICB1bnNpZ25lZCBsb25nICAgdHN0YW1wOyAgICAgICAgICAgICAgICAgLyogYXIuaXRjIHdoZW4gZW50ZXJpbmcgcGVyZm1vbiBpbnRyLiBoYW5kbGVyICovCiAKLSAgICAgICAgdW5zaWduZWQgc2hvcnQgIGNwdTsgICAgICAgICAgICAgICAgICAgIC8qIGNwdSBvbiB3aGljaCB0aGUgb3ZlcmZsb3cgb2NjdXJlZCAqLwotICAgICAgICB1bnNpZ25lZCBzaG9ydCAgc2V0OyAgICAgICAgICAgICAgICAgICAgLyogZXZlbnQgc2V0IGFjdGl2ZSB3aGVuIG92ZXJmbG93IG9jdXJyZWQgICAqLworICAgICAgICB1bnNpZ25lZCBzaG9ydCAgY3B1OyAgICAgICAgICAgICAgICAgICAgLyogY3B1IG9uIHdoaWNoIHRoZSBvdmVyZmxvdyBvY2N1cnJlZCAqLworICAgICAgICB1bnNpZ25lZCBzaG9ydCAgc2V0OyAgICAgICAgICAgICAgICAgICAgLyogZXZlbnQgc2V0IGFjdGl2ZSB3aGVuIG92ZXJmbG93IG9jY3VycmVkICAgKi8KICAgICAgICAgaW50ICAgIAkJdGdpZDsgICAgICAgICAgICAgIAkvKiB0aHJlYWQgZ3JvdXAgaWQgKGZvciBOUFRMLCB0aGlzIGlzIGdldHBpZCgpKSAqLwogfSBwZm1fZGVmYXVsdF9zbXBsX2VudHJ5X3Q7CiAKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9zbi9idGUuaCBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9zbi9idGUuaAppbmRleCA5Njc5OGQyLi5jYzZjNGRiIDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vc24vYnRlLmgKKysrIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3NuL2J0ZS5oCkBAIC0yMTYsNyArMjE2LDcgQEAKIAlidGVfY29weSgwLCBkZXN0LCBsZW4sICgobW9kZSkgfCBCVEVfWkVST19GSUxMKSwgbm90aWZpY2F0aW9uKQogCiAvKgotICogVGhlIGZvbGxvd2luZyBpcyB0aGUgcHJlZmVyZWQgd2F5IG9mIGNhbGxpbmcgYnRlX3VuYWxpZ25lZF9jb3B5CisgKiBUaGUgZm9sbG93aW5nIGlzIHRoZSBwcmVmZXJyZWQgd2F5IG9mIGNhbGxpbmcgYnRlX3VuYWxpZ25lZF9jb3B5CiAgKiBJZiB0aGUgY29weSBpcyBmdWxseSBjYWNoZSBsaW5lIGFsaWduZWQsIHRoZW4gYnRlX2NvcHkgaXMKICAqIHVzZWQgaW5zdGVhZC4gIFNpbmNlIGJ0ZV9jb3B5IGlzIGlubGluZWQsIHRoaXMgc2F2ZXMgYSBjYWxsCiAgKiBzdGFjay4gIE5PVEU6IGJ0ZV9jb3B5IGlzIGNhbGxlZCBzeW5jaHJvbm91c2x5IGFuZCBkb2VzIGJsb2NrCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vc24vc2h1Yl9tbXIuaCBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9zbi9zaHViX21tci5oCmluZGV4IDdkZTFkMWQuLmE4NGQ4NzAgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9zbi9zaHViX21tci5oCisrKyBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9zbi9zaHViX21tci5oCkBAIC00NTksNyArNDU5LDcgQEAKIC8qID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ICovCiAvKiBTb21lIE1NUnMgYXJlIGZ1bmN0aW9uYWxseSBpZGVudGljYWwgKG9yIGNsb3NlIGVub3VnaCkgb24gYm90aCBTSFVCMSAqLwogLyogYW5kIFNIVUIyIHRoYXQgaXQgbWFrZXMgc2Vuc2UgdG8gZGVmaW5lIGEgZ2ViZXJpYyBuYW1lIGZvciB0aGUgTU1SLiAgKi8KLS8qIEl0IGlzIGFjY2VwdGlibGUgdG8gdXNlIChmb3IgZXhhbXBsZSkgU0hfSVBJX0lOVCB0byByZWZlcmVuY2UgdGhlICAgICovCisvKiBJdCBpcyBhY2NlcHRhYmxlIHRvIHVzZSAoZm9yIGV4YW1wbGUpIFNIX0lQSV9JTlQgdG8gcmVmZXJlbmNlIHRoZSAgICAqLwogLyogdGhlIElQSSBNTVIuIFRoZSB2YWx1ZSBvZiBTSF9JUElfSU5UIGlzIGRldGVybWluZWQgYXQgcnVudGltZSBiYXNlZCAgKi8KIC8qIG9uIHRoZSB0eXBlIG9mIHRoZSBTSFVCLiBEbyBub3QgdXNlIHRoZXNlICNkZWZpbmVzIGluIHBlcmZvcm1hbmNlICAgICovCiAvKiBjcml0aWNhbCBjb2RlICBvciBsb29wcyAtIHRoZXJlIGlzIGEgc21hbGwgcGVyZm9ybWFuY2UgcGVuYWx0eS4gICAgICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3NuL3NodWJpby5oIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3NuL3NodWJpby5oCmluZGV4IDYwNTI0MjIuLmVjYjhhNDkgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9zbi9zaHViaW8uaAorKysgYi9hcmNoL2lhNjQvaW5jbHVkZS9hc20vc24vc2h1YmlvLmgKQEAgLTEzODMsNyArMTM4Myw3IEBACiAgKiByZXNwb25zZSBpcyBjYXB0dXJlIGluIElYU00gYW5kIElYU1MsIGFuZCBJWFNTW1ZBTElEXSBpcyBzZXQuIFRoZSAgICAqCiAgKiBlcnJhbnQgaGVhZGVyIGlzIHRoZXJlYnkgY2FwdHVyZWQsIGFuZCBubyBmdXJ0aGVyIHNwdXJpb3VzIHJlYWQgICAgICAqCiAgKiByZXNwb25lcyBhcmUgY2FwdHVyZWQgdW50aWwgSVhTU1tWQUxJRF0gaXMgY2xlYXJlZCBieSBzZXR0aW5nIHRoZSAgICAqCi0gKiBhcHByb3ByaWF0ZSBiaXQgaW4gSUVDTFIuRXZlcnl0aW1lIGEgc3B1cmlvdXMgcmVhZCByZXNwb25zZSBpcyAgICAgICAqCisgKiBhcHByb3ByaWF0ZSBiaXQgaW4gSUVDTFIuIEV2ZXJ5IHRpbWUgYSBzcHVyaW91cyByZWFkIHJlc3BvbnNlIGlzICAgICAqCiAgKiBkZXRlY3RlZCwgdGhlIFNQVVJfUkQgYml0IG9mIHRoZSBQUkIgY29ycmVzcG9uZGluZyB0byB0aGUgaW5jb21pbmcgICAqCiAgKiBtZXNzYWdlJ3MgU0lETiBmaWVsZCBpcyBzZXQuIFRoaXMgYWx3YXlzIGhhcHBlbnMsIHJlZ2FybGVzcyBvZiAgICAgICAqCiAgKiB3aGV0aGVyIGEgaGVhZGVyIGlzIGNhcHR1cmVkLiBUaGUgcHJvZ3JhbW1lciBzaG91bGQgY2hlY2sgICAgICAgICAgICAqCkBAIC0yNzM4LDcgKzI3MzgsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoJCQkJCQkJCQkqCiAgKiBUaGUgZm9sbG93aW5nIGRlZmluZXMgd2hpY2ggd2VyZSBub3QgZm9ybWVkIGludG8gc3RydWN0dXJlcyBhcmUJKgotICogcHJvYmFibHkgaW5kZW50aWNhbCB0byBhbm90aGVyIHJlZ2lzdGVyLCBhbmQgdGhlIG5hbWUgb2YgdGhlCQkqCisgKiBwcm9iYWJseSBpZGVudGljYWwgdG8gYW5vdGhlciByZWdpc3RlciwgYW5kIHRoZSBuYW1lIG9mIHRoZQkJKgogICogcmVnaXN0ZXIgaXMgcHJvdmlkZWQgYWdhaW5zdCBlYWNoIG9mIHRoZXNlIHJlZ2lzdGVycy4gVGhpcwkJKgogICogaW5mb3JtYXRpb24gbmVlZHMgdG8gYmUgY2hlY2tlZCBjYXJlZnVsbHkJCQkJKgogICoJCQkJCQkJCQkqCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQva2VybmVsL2N5Y2xvbmUuYyBiL2FyY2gvaWE2NC9rZXJuZWwvY3ljbG9uZS5jCmluZGV4IGQ1MmYxZjcuLjFiODExYzYgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9rZXJuZWwvY3ljbG9uZS5jCisrKyBiL2FyY2gvaWE2NC9rZXJuZWwvY3ljbG9uZS5jCkBAIC0zMSw3ICszMSw3IEBACiAgICAgICAgIC5yYXRpbmcgICAgICAgICA9IDMwMCwKICAgICAgICAgLnJlYWQgICAgICAgICAgID0gcmVhZF9jeWNsb25lLAogICAgICAgICAubWFzayAgICAgICAgICAgPSAoMUxMIDw8IDQwKSAtIDEsCi0gICAgICAgIC5tdWx0ICAgICAgICAgICA9IDAsIC8qdG8gYmUgY2FsdWNsYXRlZCovCisgICAgICAgIC5tdWx0ICAgICAgICAgICA9IDAsIC8qdG8gYmUgY2FsY3VsYXRlZCovCiAgICAgICAgIC5zaGlmdCAgICAgICAgICA9IDE2LAogICAgICAgICAuZmxhZ3MgICAgICAgICAgPSBDTE9DS19TT1VSQ0VfSVNfQ09OVElOVU9VUywKIH07CmRpZmYgLS1naXQgYS9hcmNoL2lhNjQva2VybmVsL3BlcmZtb25fZGVmYXVsdF9zbXBsLmMgYi9hcmNoL2lhNjQva2VybmVsL3BlcmZtb25fZGVmYXVsdF9zbXBsLmMKaW5kZXggNWY2MzdiYi4uMzBjNjQ0ZSAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2tlcm5lbC9wZXJmbW9uX2RlZmF1bHRfc21wbC5jCisrKyBiL2FyY2gvaWE2NC9rZXJuZWwvcGVyZm1vbl9kZWZhdWx0X3NtcGwuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAJICogY3VycmVudCA9IHRhc2sgcnVubmluZyBhdCB0aGUgdGltZSBvZiB0aGUgb3ZlcmZsb3cuCiAJICoKIAkgKiBwZXItdGFzayBtb2RlOgotCSAqIAktIHRoaXMgaXMgdXN1c2FsbHkgdGhlIHRhc2sgYmVpbmcgbW9uaXRvcmVkLgorCSAqIAktIHRoaXMgaXMgdXN1YWxseSB0aGUgdGFzayBiZWluZyBtb25pdG9yZWQuCiAJICogCSAgVW5kZXIgY2VydGFpbiBjb25kaXRpb25zLCBpdCBtaWdodCBiZSBhIGRpZmZlcmVudCB0YXNrCiAJICoKIAkgKiBzeXN0ZW0td2lkZToKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9rZXJuZWwvc21wYm9vdC5jIGIvYXJjaC9pYTY0L2tlcm5lbC9zbXBib290LmMKaW5kZXggNDRmMTFlZS4uMTRlYzY0MSAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2tlcm5lbC9zbXBib290LmMKKysrIGIvYXJjaC9pYTY0L2tlcm5lbC9zbXBib290LmMKQEAgLTcwMyw3ICs3MDMsNyBAQAogCQkJCWRhdGEtPmNoaXAtPmlycV9kaXNhYmxlKGRhdGEpOwogCQkJCWRhdGEtPmNoaXAtPmlycV9zZXRfYWZmaW5pdHkoZGF0YSwgbWFzaywgZmFsc2UpOwogCQkJCWRhdGEtPmNoaXAtPmlycV9lbmFibGUoZGF0YSk7Ci0JCQkJcHJpbnRrICgiUmUtdGFyZ2V0dGluZyBDUEVJIHRvIGNwdSAlZFxuIiwgbmV3X2NwZWlfY3B1KTsKKwkJCQlwcmludGsgKCJSZS10YXJnZXRpbmcgQ1BFSSB0byBjcHUgJWRcbiIsIG5ld19jcGVpX2NwdSk7CiAJCQl9CiAJCX0KIAkJaWYgKCFkYXRhKSB7CmRpZmYgLS1naXQgYS9hcmNoL2lhNjQva2VybmVsL3RvcG9sb2d5LmMgYi9hcmNoL2lhNjQva2VybmVsL3RvcG9sb2d5LmMKaW5kZXggMGJhYTFiYi4uMGUwZTBjYyAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2tlcm5lbC90b3BvbG9neS5jCisrKyBiL2FyY2gvaWE2NC9rZXJuZWwvdG9wb2xvZ3kuYwpAQCAtNDMsNyArNDMsNyBAQAogewogI2lmZGVmIENPTkZJR19BQ1BJCiAJLyoKLQkgKiBJZiBDUEVJIGNhbiBiZSByZS10YXJnZXR0ZWQgb3IgaWYgdGhpcyBpcyBub3QKKwkgKiBJZiBDUEVJIGNhbiBiZSByZS10YXJnZXRlZCBvciBpZiB0aGlzIGlzIG5vdAogCSAqIENQRUkgdGFyZ2V0LCB0aGVuIGl0IGlzIGhvdHBsdWdnYWJsZQogCSAqLwogCWlmIChjYW5fY3BlaV9yZXRhcmdldCgpIHx8ICFpc19jcHVfY3BlaV90YXJnZXQobnVtKSkKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9rdm0vcHJvY2Vzcy5jIGIvYXJjaC9pYTY0L2t2bS9wcm9jZXNzLmMKaW5kZXggYmI4NjJmYi4uYjAzOTg3NCAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2t2bS9wcm9jZXNzLmMKKysrIGIvYXJjaC9pYTY0L2t2bS9wcm9jZXNzLmMKQEAgLTk4Nyw3ICs5ODcsNyBAQAogCiBzdGF0aWMgdm9pZCBrdm1fZG9fcmVzdW1lX29wKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKIHsKLQl2bW1fc2FuaXR5X2NoZWNrKHZjcHUpOyAvKkd1YXJhbnRlZSB2Y3B1IHJ1bmluZyBvbiBoZWFsdGh5IHZtbSEqLworCXZtbV9zYW5pdHlfY2hlY2sodmNwdSk7IC8qR3VhcmFudGVlIHZjcHUgcnVubmluZyBvbiBoZWFsdGh5IHZtbSEqLwogCiAJaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChLVk1fUkVRX1JFU1VNRSwgJnZjcHUtPnJlcXVlc3RzKSkgewogCQl2Y3B1X2RvX3Jlc3VtZSh2Y3B1KTsKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9saWIvZG9fY3N1bS5TIGIvYXJjaC9pYTY0L2xpYi9kb19jc3VtLlMKaW5kZXggNmJlYzJmYy4uMWE0MzFhNSAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2xpYi9kb19jc3VtLlMKKysrIGIvYXJjaC9pYTY0L2xpYi9kb19jc3VtLlMKQEAgLTIwMSw3ICsyMDEsNyBAQAogCTs7CiAocDYpCWFkZHMgcmVzdWx0MVswXT0xLHJlc3VsdDFbMF0KIChwOSkJYnIuY29uZC5zcHRrIC5kb19jc3VtX2V4aXQJLy8gaWYgKGNvdW50ID09IDEpIGV4aXQKLQkvLyBGYWxsIHRocm91Z2ggdG8gY2FsdWN1bGF0ZSB0aGUgY2hlY2tzdW0sIGZlZWRpbmcgcmVzdWx0MVswXSBhcworCS8vIEZhbGwgdGhyb3VnaCB0byBjYWxjdWxhdGUgdGhlIGNoZWNrc3VtLCBmZWVkaW5nIHJlc3VsdDFbMF0gYXMKIAkvLyB0aGUgaW5pdGlhbCB2YWx1ZSBpbiByZXN1bHQxWzBdLgogCS8vCiAJLy8gQ2FsY3VsYXRlIHRoZSBjaGVja3N1bSBsb2FkaW5nIHR3byA4LWJ5dGUgd29yZHMgcGVyIGxvb3AuCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQvc24va2VybmVsL2lycS5jIGIvYXJjaC9pYTY0L3NuL2tlcm5lbC9pcnEuYwppbmRleCAxMzljMDE4Li44MWExZjRlIDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvc24va2VybmVsL2lycS5jCisrKyBiL2FyY2gvaWE2NC9zbi9rZXJuZWwvaXJxLmMKQEAgLTIyNyw3ICsyMjcsNyBAQAogewogICAgICAgICAvKgogICAgICAgICAgKiBPbiBzeXN0ZW1zIHdoaWNoIHN1cHBvcnQgQ1BVIGRpc2FibGluZyAoU0h1YjIpLCBhbGwgZXJyb3IgaW50ZXJydXB0cwotICAgICAgICAgKiBhcmUgdGFyZ2V0dGVkIGF0IHRoZSBib290IENQVS4KKyAgICAgICAgICogYXJlIHRhcmdldGVkIGF0IHRoZSBib290IENQVS4KICAgICAgICAgICovCiAgICAgICAgIGlmIChpc19zaHViMigpICYmIHNuX3Byb21fZmVhdHVyZV9hdmFpbGFibGUoUFJGX0NQVV9ESVNBQkxFX1NVUFBPUlQpKQogICAgICAgICAgICAgICAgIHNldF9pcnFfYWZmaW5pdHlfaW5mbyhpcnEsIGNwdV9waHlzaWNhbF9pZCgwKSwgMCk7CkBAIC00MzUsNyArNDM1LDcgQEAKIAkvKgogCSAqIEJyaWRnZSB0eXBlcyBhdHRhY2hlZCB0byBUSU8gKGFueXRoaW5nIGJ1dCBQSUMpIGRvIG5vdCBuZWVkIHRoaXMgV0FSCiAJICogc2luY2UgdGhleSBkbyBub3QgdGFyZ2V0IFNodWIgSUkgaW50ZXJydXB0IHJlZ2lzdGVycy4gIElmIHRoYXQKLQkgKiBldmVyIGNoYW5nZXMsIHRoaXMgY2hlY2sgbmVlZHMgdG8gYWNjb21vZGF0ZS4KKwkgKiBldmVyIGNoYW5nZXMsIHRoaXMgY2hlY2sgbmVlZHMgdG8gYWNjb21tb2RhdGUuCiAJICovCiAJaWYgKHNuX2lycV9pbmZvLT5pcnFfYnJpZGdlX3R5cGUgIT0gUENJSU9fQVNJQ19UWVBFX1BJQykKIAkJcmV0dXJuOwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L3NuL3BjaS9wY2lici9wY2licl9kbWEuYyBiL2FyY2gvaWE2NC9zbi9wY2kvcGNpYnIvcGNpYnJfZG1hLmMKaW5kZXggYzY1OWFkNS4uMzNkZWY2NiAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L3NuL3BjaS9wY2lici9wY2licl9kbWEuYworKysgYi9hcmNoL2lhNjQvc24vcGNpL3BjaWJyL3BjaWJyX2RtYS5jCkBAIC0yMjcsNyArMjI3LDcgQEAKICAqIGFmdGVyIGRvaW5nIHRoZSByZWFkLiAgRm9yIFBJQyB0aGlzIHJvdXRpbmUgdGhlbiBmb3JjZXMgYSBmYWtlIGludGVycnVwdAogICogb24gYW5vdGhlciBsaW5lLCB3aGljaCBpcyBsb2dpY2FsbHkgYXNzb2NpYXRlZCB3aXRoIHRoZSBzbG90IHRoYXQgdGhlIFBJTwogICogaXMgYWRkcmVzc2VkIHRvLiAgSXQgdGhlbiBzcGlucyB3aGlsZSB3YXRjaGluZyB0aGUgbWVtb3J5IGxvY2F0aW9uIHRoYXQKLSAqIHRoZSBpbnRlcnJ1cHQgaXMgdGFyZ2V0dGVkIHRvLiAgV2hlbiB0aGUgaW50ZXJydXB0IHJlc3BvbnNlIGFycml2ZXMsIHdlIAorICogdGhlIGludGVycnVwdCBpcyB0YXJnZXRlZCB0by4gIFdoZW4gdGhlIGludGVycnVwdCByZXNwb25zZSBhcnJpdmVzLCB3ZSAKICAqIGFyZSBzdXJlIHRoYXQgdGhlIERNQSBoYXMgbGFuZGVkIGluIG1lbW9yeSBhbmQgaXQgaXMgc2FmZSBmb3IgdGhlIGRyaXZlcgogICogdG8gcHJvY2VlZC4JRm9yIFRJT0NQIHVzZSB0aGUgRGV2aWNlKHgpIFdyaXRlIFJlcXVlc3QgQnVmZmVyIEZsdXNoIAogICogQnJpZGdlIHJlZ2lzdGVyIHNpbmNlIGl0IGVuc3VyZXMgdGhlIGRhdGEgaGFzIGVudGVyZWQgdGhlIGNvaGVyZW5jZSBkb21haW4sCmRpZmYgLS1naXQgYS9hcmNoL20zMnIvaW5jbHVkZS9hc20vbTMyMTA0dXQvbTMyMTA0dXRfcGxkLmggYi9hcmNoL20zMnIvaW5jbHVkZS9hc20vbTMyMTA0dXQvbTMyMTA0dXRfcGxkLmgKaW5kZXggMmRjODlkNi4uMWZlYWU5NyAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL20zMjEwNHV0L20zMjEwNHV0X3BsZC5oCisrKyBiL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9tMzIxMDR1dC9tMzIxMDR1dF9wbGQuaApAQCAtNCw3ICs0LDcgQEAKIC8qCiAgKiBpbmNsdWRlL2FzbS1tMzJyL20zMjEwNHV0L20zMjEwNHV0X3BsZC5oCiAgKgotICogRGVmaW5pdGlvbnMgZm9yIFByb2dyYW1hYmxlIExvZ2ljIERldmljZShQTEQpIG9uIE0zMjEwNFVUIGJvYXJkLgorICogRGVmaW5pdGlvbnMgZm9yIFByb2dyYW1tYWJsZSBMb2dpYyBEZXZpY2UoUExEKSBvbiBNMzIxMDRVVCBib2FyZC4KICAqIEJhc2VkIG9uIG0zMjcwMHV0X3BsZC5oCiAgKgogICogQ29weXJpZ2h0IChjKSAyMDAyCVRha2VvIFRha2FoYXNoaQpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL20zMjcwMHV0L20zMjcwMHV0X3BsZC5oIGIvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL20zMjcwMHV0L20zMjcwMHV0X3BsZC5oCmluZGV4IDU3NjIzYmUuLjM1Mjk0NjcgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9tMzI3MDB1dC9tMzI3MDB1dF9wbGQuaAorKysgYi9hcmNoL20zMnIvaW5jbHVkZS9hc20vbTMyNzAwdXQvbTMyNzAwdXRfcGxkLmgKQEAgLTQsNyArNCw3IEBACiAvKgogICogaW5jbHVkZS9hc20tbTMyci9tMzI3MDB1dC9tMzI3MDB1dF9wbGQuaAogICoKLSAqIERlZmluaXRpb25zIGZvciBQcm9ncmFtYWJsZSBMb2dpYyBEZXZpY2UoUExEKSBvbiBNMzI3MDBVVCBib2FyZC4KKyAqIERlZmluaXRpb25zIGZvciBQcm9ncmFtbWFibGUgTG9naWMgRGV2aWNlKFBMRCkgb24gTTMyNzAwVVQgYm9hcmQuCiAgKgogICogQ29weXJpZ2h0IChjKSAyMDAyCVRha2VvIFRha2FoYXNoaQogICoKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9vcHNwdXQvb3BzcHV0X3BsZC5oIGIvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL29wc3B1dC9vcHNwdXRfcGxkLmgKaW5kZXggM2YxMWVhMS4uNjkwMTQwMSAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL29wc3B1dC9vcHNwdXRfcGxkLmgKKysrIGIvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL29wc3B1dC9vcHNwdXRfcGxkLmgKQEAgLTQsNyArNCw3IEBACiAvKgogICogaW5jbHVkZS9hc20tbTMyci9vcHNwdXQvb3BzcHV0X3BsZC5oCiAgKgotICogRGVmaW5pdGlvbnMgZm9yIFByb2dyYW1hYmxlIExvZ2ljIERldmljZShQTEQpIG9uIE9QU1BVVCBib2FyZC4KKyAqIERlZmluaXRpb25zIGZvciBQcm9ncmFtbWFibGUgTG9naWMgRGV2aWNlKFBMRCkgb24gT1BTUFVUIGJvYXJkLgogICoKICAqIENvcHlyaWdodCAoYykgMjAwMglUYWtlbyBUYWthaGFzaGkKICAqCmRpZmYgLS1naXQgYS9hcmNoL20zMnIvaW5jbHVkZS9hc20vcGd0YWJsZS0ybGV2ZWwuaCBiL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9wZ3RhYmxlLTJsZXZlbC5oCmluZGV4IGJjYTM0NzUuLjljZGFmNzMgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9wZ3RhYmxlLTJsZXZlbC5oCisrKyBiL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9wZ3RhYmxlLTJsZXZlbC5oCkBAIC00NCw3ICs0NCw3IEBACiAjZGVmaW5lIHNldF9wdGVfYXQobW0sYWRkcixwdGVwLHB0ZXZhbCkgc2V0X3B0ZShwdGVwLHB0ZXZhbCkKIAogLyoKLSAqIChwbWRzIGFyZSBmb2xkZWQgaW50byBwZ2RzIHNvIHRoaXMgZG9lc250IGdldCBhY3R1YWxseSBjYWxsZWQsCisgKiAocG1kcyBhcmUgZm9sZGVkIGludG8gcGdkcyBzbyB0aGlzIGRvZXNuJ3QgZ2V0IGFjdHVhbGx5IGNhbGxlZCwKICAqIGJ1dCB0aGUgZGVmaW5lIGlzIG5lZWRlZCBmb3IgYSBnZW5lcmljIGlubGluZSBmdW5jdGlvbi4pCiAgKi8KICNkZWZpbmUgc2V0X3BtZChwbWRwdHIsIHBtZHZhbCkgKCoocG1kcHRyKSA9IHBtZHZhbCkKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9tbS9mYXVsdC5jIGIvYXJjaC9tMzJyL21tL2ZhdWx0LmMKaW5kZXggYjhlYzAwMi4uMmM5YWViNCAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9tMzJyL21tL2ZhdWx0LmMKQEAgLTEyMCw3ICsxMjAsNyBAQAogCiAJLyogV2hlbiBydW5uaW5nIGluIHRoZSBrZXJuZWwgd2UgZXhwZWN0IGZhdWx0cyB0byBvY2N1ciBvbmx5IHRvCiAJICogYWRkcmVzc2VzIGluIHVzZXIgc3BhY2UuICBBbGwgb3RoZXIgZmF1bHRzIHJlcHJlc2VudCBlcnJvcnMgaW4gdGhlCi0JICoga2VybmVsIGFuZCBzaG91bGQgZ2VuZXJhdGUgYW4gT09QUy4gIFVuZm9ydHVuYXRseSwgaW4gdGhlIGNhc2Ugb2YgYW4KKwkgKiBrZXJuZWwgYW5kIHNob3VsZCBnZW5lcmF0ZSBhbiBPT1BTLiAgVW5mb3J0dW5hdGVseSwgaW4gdGhlIGNhc2Ugb2YgYW4KIAkgKiBlcnJvbmVvdXMgZmF1bHQgb2NjdXJyaW5nIGluIGEgY29kZSBwYXRoIHdoaWNoIGFscmVhZHkgaG9sZHMgbW1hcF9zZW0KIAkgKiB3ZSB3aWxsIGRlYWRsb2NrIGF0dGVtcHRpbmcgdG8gdmFsaWRhdGUgdGhlIGZhdWx0IGFnYWluc3QgdGhlCiAJICogYWRkcmVzcyBzcGFjZS4gIEx1Y2tpbHkgdGhlIGtlcm5lbCBvbmx5IHZhbGlkbHkgcmVmZXJlbmNlcyB1c2VyCkBAIC0xMjgsNyArMTI4LDcgQEAKIAkgKiBleGNlcHRpb25zIHRhYmxlLgogCSAqCiAJICogQXMgdGhlIHZhc3QgbWFqb3JpdHkgb2YgZmF1bHRzIHdpbGwgYmUgdmFsaWQgd2Ugd2lsbCBvbmx5IHBlcmZvcm0KLQkgKiB0aGUgc291cmNlIHJlZmVyZW5jZSBjaGVjayB3aGVuIHRoZXJlIGlzIGEgcG9zc2liaWx0eSBvZiBhIGRlYWRsb2NrLgorCSAqIHRoZSBzb3VyY2UgcmVmZXJlbmNlIGNoZWNrIHdoZW4gdGhlcmUgaXMgYSBwb3NzaWJpbGl0eSBvZiBhIGRlYWRsb2NrLgogCSAqIEF0dGVtcHQgdG8gbG9jayB0aGUgYWRkcmVzcyBzcGFjZSwgaWYgd2UgY2Fubm90IHdlIHRoZW4gdmFsaWRhdGUgdGhlCiAJICogc291cmNlLiAgSWYgdGhpcyBpcyBpbnZhbGlkIHdlIGNhbiBza2lwIHRoZSBhZGRyZXNzIHNwYWNlIGNoZWNrLAogCSAqIHRodXMgYXZvaWRpbmcgdGhlIGRlYWRsb2NrLgpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2F0YXJpL2F0YWtleWIuYyBiL2FyY2gvbTY4ay9hdGFyaS9hdGFrZXliLmMKaW5kZXggNTg5MDg5Ny4uYjk5NTUxMyAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2F0YXJpL2F0YWtleWIuYworKysgYi9hcmNoL202OGsvYXRhcmkvYXRha2V5Yi5jCkBAIC0xMzAsNyArMTMwLDcgQEAKICAqIGl0J3MgcmVhbGx5IGhhcmQgdG8gZGVjaWRlIHdoZXRoZXIgdGhleSdyZSBtb3VzZSBvciBrZXlib2FyZCBieXRlcy4gU2luY2UKICAqIG92ZXJydW5zIHVzdWFsbHkgb2NjdXIgd2hlbiBtb3ZpbmcgdGhlIEF0YXJpIG1vdXNlIHJhcGlkbHksIHRoZXkncmUgc2VlbiBhcwogICogbW91c2UgYnl0ZXMgaGVyZS4gSWYgdGhpcyBpcyB3cm9uZywgb25seSBhIG1ha2UgY29kZSBvZiB0aGUga2V5Ym9hcmQgZ2V0cwotICogbG9zdCwgd2hpY2ggaXNuJ3QgdG9vIGJhZC4gTG9vc2luZyBhIGJyZWFrIGNvZGUgd291bGQgYmUgZGlzYXN0cm91cywKKyAqIGxvc3QsIHdoaWNoIGlzbid0IHRvbyBiYWQuIExvc2luZyBhIGJyZWFrIGNvZGUgd291bGQgYmUgZGlzYXN0cm91cywKICAqIGJlY2F1c2UgdGhlbiB0aGUga2V5Ym9hcmQgcmVwZWF0IHN0cmlrZXMuLi4KICAqLwogCmRpZmYgLS1naXQgYS9hcmNoL202OGsvZnBzcDA0MC9iaW5kZWMuUyBiL2FyY2gvbTY4ay9mcHNwMDQwL2JpbmRlYy5TCmluZGV4IDcyZjExNTkuLmYyZTc5NTIgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9mcHNwMDQwL2JpbmRlYy5TCisrKyBiL2FyY2gvbTY4ay9mcHNwMDQwL2JpbmRlYy5TCkBAIC02MDksNyArNjA5LDcgQEAKIHwgICAgICBBNi4gIFRoaXMgdGVzdCBvY2N1cnMgb25seSBvbiB0aGUgZmlyc3QgcGFzcy4gIElmIHRoZQogfCAgICAgIHJlc3VsdCBpcyBleGFjdGx5IDEwXkxFTiwgZGVjcmVtZW50IElMT0cgYW5kIGRpdmlkZQogfCAgICAgIHRoZSBtYW50aXNzYSBieSAxMC4gIFRoZSBjYWxjdWxhdGlvbiBvZiAxMF5MRU4gY2Fubm90Ci18ICAgICAgYmUgaW5leGFjdCwgc2luY2UgYWxsIHBvd2VycyBvZiB0ZW4gdXB0byAxMF4yNyBhcmUgZXhhY3QKK3wgICAgICBiZSBpbmV4YWN0LCBzaW5jZSBhbGwgcG93ZXJzIG9mIHRlbiB1cCB0byAxMF4yNyBhcmUgZXhhY3QKIHwgICAgICBpbiBleHRlbmRlZCBwcmVjaXNpb24sIHNvIHRoZSB1c2Ugb2YgYSBwcmV2aW91cyBwb3dlci1vZi10ZW4KIHwgICAgICB0YWJsZSB3aWxsIGludHJvZHVjZSBubyBlcnJvci4KIHwKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pZnBzcDA2MC9zcmMvZnBzcC5TIGIvYXJjaC9tNjhrL2lmcHNwMDYwL3NyYy9mcHNwLlMKaW5kZXggMjZlODVlMi4uNzhjYjYwZiAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2lmcHNwMDYwL3NyYy9mcHNwLlMKKysrIGIvYXJjaC9tNjhrL2lmcHNwMDYwL3NyYy9mcHNwLlMKQEAgLTExODEzLDcgKzExODEzLDcgQEAKIAlibmUuYgkJZm11bF91bmZsX2VuYV9zZAkjIG5vLCBzZ2wgb3IgZGJsCiAKICMgaWYgdGhlIHJuZCBtb2RlIGlzIGFueXRoaW5nIGJ1dCBSWiwgdGhlbiB3ZSBoYXZlIHRvIHJlLWRvIHRoZSBhYm92ZQotIyBtdWx0aXBsaWNhdGlvbiBiZWN1YXNlIHdlIHVzZWQgUlogZm9yIGFsbC4KKyMgbXVsdGlwbGljYXRpb24gYmVjYXVzZSB3ZSB1c2VkIFJaIGZvciBhbGwuCiAJZm1vdi5sCQlMX1NDUjMoJWE2KSwlZnBjcgkjIHNldCBGUENSCiAKIGZtdWxfdW5mbF9lbmFfY29udDoKQEAgLTE4MDk1LDcgKzE4MDk1LDcgQEAKIAogCXJ0cwogCi0jIGFkZHJlc2luZyBtb2RlIGlzIHBvc3QtaW5jcmVtZW50LiB3cml0ZSB0aGUgcmVzdWx0IGJ5dGUuIGlmIHRoZSB3cml0ZQorIyBhZGRyZXNzaW5nIG1vZGUgaXMgcG9zdC1pbmNyZW1lbnQuIHdyaXRlIHRoZSByZXN1bHQgYnl0ZS4gaWYgdGhlIHdyaXRlCiAjIGZhaWxzIHRoZW4gZG9uJ3QgdXBkYXRlIHRoZSBhZGRyZXNzIHJlZ2lzdGVyLiBpZiB3cml0ZSBwYXNzZXMgdGhlbgogIyBjYWxsIGluY19hcmVnKCkgdG8gdXBkYXRlIHRoZSBhZGRyZXNzIHJlZ2lzdGVyLgogZnNjY19tZW1faW5jOgpAQCAtMjA4NzYsNyArMjA4NzYsNyBAQAogCXN3YXAJCSVkMAkJCSMgZDAgbm93IGluIHVwcGVyIHdvcmQKIAlsc2wubAkJJjB4NCwlZDAJCSMgZDAgaW4gcHJvcGVyIHBsYWNlIGZvciBkYmwgcHJlYyBleHAKIAl0c3QuYgkJRlRFTVBfRVgoJWEwKQkJIyB0ZXN0IHNpZ24KLQlicGwuYgkJZHN0X2dldF9kbWFuCQkjIGlmIHBvc3RpdmUsIGdvIHByb2Nlc3MgbWFudGlzc2EKKwlicGwuYgkJZHN0X2dldF9kbWFuCQkjIGlmIHBvc2l0aXZlLCBnbyBwcm9jZXNzIG1hbnRpc3NhCiAJYnNldAkJJjB4MWYsJWQwCQkjIGlmIG5lZ2F0aXZlLCBzZXQgc2lnbgogZHN0X2dldF9kbWFuOgogCW1vdi5sCQlGVEVNUF9ISSglYTApLCVkMQkjIGdldCBtcyBtYW50aXNzYQpAQCAtMjI5NDMsNyArMjI5NDMsNyBAQAogIwlGUF9TUkMoYTYpID0gcGFja2VkIG9wZXJhbmQgbm93IGFzIGEgYmluYXJ5IEZQIG51bWJlcgkJIwogIwkJCQkJCQkJCSMKICMgQUxHT1JJVEhNICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCSMKLSMJR2V0IHRoZSBjb3JyZWN0IDxlYT4gd2hpaGMgaXMgdGhlIHZhbHVlIG9uIHRoZSBleGNlcHRpb24gc3RhY2sJIworIwlHZXQgdGhlIGNvcnJlY3QgPGVhPiB3aGljaCBpcyB0aGUgdmFsdWUgb24gdGhlIGV4Y2VwdGlvbiBzdGFjawkjCiAjIGZyYW1lIHcvIG1heWJlIGEgY29ycmVjdGlvbiBmYWN0b3IgaWYgdGhlIDxlYT4gaXMgLShhbikgb3IgKGFuKSsuCSMKICMgVGhlbiwgZmV0Y2ggdGhlIG9wZXJhbmQgZnJvbSBtZW1vcnkuIElmIHRoZSBmZXRjaCBmYWlscywgZXhpdAkJIwogIyB0aHJvdWdoIGZhY2NfaW5feCgpLgkJCQkJCQkjCkBAIC0yNDA5Niw3ICsyNDA5Niw3IEBACiAjICAgICAgQTYuICBUaGlzIHRlc3Qgb2NjdXJzIG9ubHkgb24gdGhlIGZpcnN0IHBhc3MuICBJZiB0aGUKICMgICAgICByZXN1bHQgaXMgZXhhY3RseSAxMF5MRU4sIGRlY3JlbWVudCBJTE9HIGFuZCBkaXZpZGUKICMgICAgICB0aGUgbWFudGlzc2EgYnkgMTAuICBUaGUgY2FsY3VsYXRpb24gb2YgMTBeTEVOIGNhbm5vdAotIyAgICAgIGJlIGluZXhhY3QsIHNpbmNlIGFsbCBwb3dlcnMgb2YgdGVuIHVwdG8gMTBeMjcgYXJlIGV4YWN0CisjICAgICAgYmUgaW5leGFjdCwgc2luY2UgYWxsIHBvd2VycyBvZiB0ZW4gdXAgdG8gMTBeMjcgYXJlIGV4YWN0CiAjICAgICAgaW4gZXh0ZW5kZWQgcHJlY2lzaW9uLCBzbyB0aGUgdXNlIG9mIGEgcHJldmlvdXMgcG93ZXItb2YtdGVuCiAjICAgICAgdGFibGUgd2lsbCBpbnRyb2R1Y2Ugbm8gZXJyb3IuCiAjCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaWZwc3AwNjAvc3JjL3BmcHNwLlMgYi9hcmNoL202OGsvaWZwc3AwNjAvc3JjL3BmcHNwLlMKaW5kZXggZTcxYmEwYS4uNGFlZGVmOSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2lmcHNwMDYwL3NyYy9wZnBzcC5TCisrKyBiL2FyY2gvbTY4ay9pZnBzcDA2MC9zcmMvcGZwc3AuUwpAQCAtNzc3Nyw3ICs3Nzc3LDcgQEAKIAlzd2FwCQklZDAJCQkjIGQwIG5vdyBpbiB1cHBlciB3b3JkCiAJbHNsLmwJCSYweDQsJWQwCQkjIGQwIGluIHByb3BlciBwbGFjZSBmb3IgZGJsIHByZWMgZXhwCiAJdHN0LmIJCUZURU1QX0VYKCVhMCkJCSMgdGVzdCBzaWduCi0JYnBsLmIJCWRzdF9nZXRfZG1hbgkJIyBpZiBwb3N0aXZlLCBnbyBwcm9jZXNzIG1hbnRpc3NhCisJYnBsLmIJCWRzdF9nZXRfZG1hbgkJIyBpZiBwb3NpdGl2ZSwgZ28gcHJvY2VzcyBtYW50aXNzYQogCWJzZXQJCSYweDFmLCVkMAkJIyBpZiBuZWdhdGl2ZSwgc2V0IHNpZ24KIGRzdF9nZXRfZG1hbjoKIAltb3YubAkJRlRFTVBfSEkoJWEwKSwlZDEJIyBnZXQgbXMgbWFudGlzc2EKQEAgLTgyNDQsNyArODI0NCw3IEBACiAJYm5lLmIJCWZtdWxfdW5mbF9lbmFfc2QJIyBubywgc2dsIG9yIGRibAogCiAjIGlmIHRoZSBybmQgbW9kZSBpcyBhbnl0aGluZyBidXQgUlosIHRoZW4gd2UgaGF2ZSB0byByZS1kbyB0aGUgYWJvdmUKLSMgbXVsdGlwbGljYXRpb24gYmVjdWFzZSB3ZSB1c2VkIFJaIGZvciBhbGwuCisjIG11bHRpcGxpY2F0aW9uIGJlY2F1c2Ugd2UgdXNlZCBSWiBmb3IgYWxsLgogCWZtb3YubAkJTF9TQ1IzKCVhNiksJWZwY3IJIyBzZXQgRlBDUgogCiBmbXVsX3VuZmxfZW5hX2NvbnQ6CkBAIC0xMjkwMyw3ICsxMjkwMyw3IEBACiAjCUZQX1NSQyhhNikgPSBwYWNrZWQgb3BlcmFuZCBub3cgYXMgYSBiaW5hcnkgRlAgbnVtYmVyCQkjCiAjCQkJCQkJCQkJIwogIyBBTEdPUklUSE0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioJIwotIwlHZXQgdGhlIGNvcnJlY3QgPGVhPiB3aGloYyBpcyB0aGUgdmFsdWUgb24gdGhlIGV4Y2VwdGlvbiBzdGFjawkjCisjCUdldCB0aGUgY29ycmVjdCA8ZWE+IHdoaWNoIGlzIHRoZSB2YWx1ZSBvbiB0aGUgZXhjZXB0aW9uIHN0YWNrCSMKICMgZnJhbWUgdy8gbWF5YmUgYSBjb3JyZWN0aW9uIGZhY3RvciBpZiB0aGUgPGVhPiBpcyAtKGFuKSBvciAoYW4pKy4JIwogIyBUaGVuLCBmZXRjaCB0aGUgb3BlcmFuZCBmcm9tIG1lbW9yeS4gSWYgdGhlIGZldGNoIGZhaWxzLCBleGl0CQkjCiAjIHRocm91Z2ggZmFjY19pbl94KCkuCQkJCQkJCSMKQEAgLTE0MDU2LDcgKzE0MDU2LDcgQEAKICMgICAgICBBNi4gIFRoaXMgdGVzdCBvY2N1cnMgb25seSBvbiB0aGUgZmlyc3QgcGFzcy4gIElmIHRoZQogIyAgICAgIHJlc3VsdCBpcyBleGFjdGx5IDEwXkxFTiwgZGVjcmVtZW50IElMT0cgYW5kIGRpdmlkZQogIyAgICAgIHRoZSBtYW50aXNzYSBieSAxMC4gIFRoZSBjYWxjdWxhdGlvbiBvZiAxMF5MRU4gY2Fubm90Ci0jICAgICAgYmUgaW5leGFjdCwgc2luY2UgYWxsIHBvd2VycyBvZiB0ZW4gdXB0byAxMF4yNyBhcmUgZXhhY3QKKyMgICAgICBiZSBpbmV4YWN0LCBzaW5jZSBhbGwgcG93ZXJzIG9mIHRlbiB1cCB0byAxMF4yNyBhcmUgZXhhY3QKICMgICAgICBpbiBleHRlbmRlZCBwcmVjaXNpb24sIHNvIHRoZSB1c2Ugb2YgYSBwcmV2aW91cyBwb3dlci1vZi10ZW4KICMgICAgICB0YWJsZSB3aWxsIGludHJvZHVjZSBubyBlcnJvci4KICMKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9hdGFyaWludHMuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9hdGFyaWludHMuaAppbmRleCBmNTk3ODkyLi42NTZiYmJmIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vYXRhcmlpbnRzLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2F0YXJpaW50cy5oCkBAIC0xNDYsNyArMTQ2LDcgQEAKIAogLyoKICAqIHtlbixkaXN9YWJsZV9pcnEgaGF2ZSB0aGUgdXN1YWwgc2VtYW50aWNzIG9mIHRlbXBvcmFyeSBibG9ja2luZyB0aGUKLSAqIGludGVycnVwdCwgYnV0IG5vdCBsb29zaW5nIHJlcXVlc3RzIHRoYXQgaGFwcGVuIGJldHdlZW4gZGlzYWJsaW5nIGFuZAorICogaW50ZXJydXB0LCBidXQgbm90IGxvc2luZyByZXF1ZXN0cyB0aGF0IGhhcHBlbiBiZXR3ZWVuIGRpc2FibGluZyBhbmQKICAqIGVuYWJsaW5nLiBUaGlzIGlzIGRvbmUgd2l0aCB0aGUgTUZQIG1hc2sgcmVnaXN0ZXJzLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9ib290c3RkLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vYm9vdHN0ZC5oCmluZGV4IGJkYzFhNGEuLmU1MThmNWEgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9ib290c3RkLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2Jvb3RzdGQuaApAQCAtMzEsNyArMzEsNyBAQAogI2RlZmluZSBfX0JOX2ZsYXNoX3dyaXRlX3JhbmdlCQkyMAogCiAvKiBDYWxsaW5nIGNvbnZlbnRpb25zIGNvbXBhdGlibGUgdG8gKHVDKWxpbnV4LzY4awotICogV2UgdXNlIHNpbW1pbGFyIG1hY3JvcyB0byBjYWxsIGludG8gdGhlIGJvb3Rsb2FkZXIgYXMgZm9yIHVDbGludXgKKyAqIFdlIHVzZSBzaW1pbGFyIG1hY3JvcyB0byBjYWxsIGludG8gdGhlIGJvb3Rsb2FkZXIgYXMgZm9yIHVDbGludXgKICAqLwogCiAjZGVmaW5lIF9fYnNjX3JldHVybih0eXBlLCByZXMpIFwKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9jb21tcHJvYy5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2NvbW1wcm9jLmgKaW5kZXggZWRmNWViNi4uYTczOTk4NSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2NvbW1wcm9jLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2NvbW1wcm9jLmgKQEAgLTg4LDcgKzg4LDcgQEAKIAogCiAvKiByeCBiZCBzdGF0dXMvY29udHJvbCBiaXRzICovCi0jZGVmaW5lIEJEX1NDX0VNUFRZCSgodXNob3J0KTB4ODAwMCkJLyogUmVjaWV2ZSBpcyBlbXB0eSAqLworI2RlZmluZSBCRF9TQ19FTVBUWQkoKHVzaG9ydCkweDgwMDApCS8qIFJlY2VpdmUgaXMgZW1wdHkgKi8KICNkZWZpbmUgQkRfU0NfV1JBUAkoKHVzaG9ydCkweDIwMDApCS8qIExhc3QgYnVmZmVyIGRlc2NyaXB0b3IgaW4gdGFibGUgKi8KICNkZWZpbmUgQkRfU0NfSU5UUlBUCSgodXNob3J0KTB4MTAwMCkJLyogSW50ZXJydXB0IG9uIGNoYW5nZSAqLwogI2RlZmluZSBCRF9TQ19MQVNUCSgodXNob3J0KTB4MDgwMCkJLyogTGFzdCBidWZmZXIgaW4gZnJhbWUgT1IgY29udHJvbCBjaGFyICovCkBAIC05Niw3ICs5Niw3IEBACiAjZGVmaW5lIEJEX1NDX0ZJUlNUCSgodXNob3J0KTB4MDQwMCkJLyogMXN0IGJ1ZmZlciBpbiBhbiBIRExDIGZyYW1lICovCiAjZGVmaW5lIEJEX1NDX0FERFIJKCh1c2hvcnQpMHgwNDAwKQkvKiAxc3QgYnl0ZSBpcyBhIG11bHRpZHJvcCBhZGRyZXNzICovCiAKLSNkZWZpbmUgQkRfU0NfQ00JKCh1c2hvcnQpMHgwMjAwKQkvKiBDb250aW5vdXMgbW9kZSAqLworI2RlZmluZSBCRF9TQ19DTQkoKHVzaG9ydCkweDAyMDApCS8qIENvbnRpbnVvdXMgbW9kZSAqLwogI2RlZmluZSBCRF9TQ19JRAkoKHVzaG9ydCkweDAxMDApCS8qIFJlY2VpdmVkIHRvbyBtYW55IGlkbGVzICovCiAKICNkZWZpbmUgQkRfU0NfQU0JKCh1c2hvcnQpMHgwMDgwKQkvKiBNdWx0aWRyb3AgYWRkcmVzcyBtYXRjaCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2RlbGF5X25vLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vZGVsYXlfbm8uaAppbmRleCA1NWNiZDYyLi5jM2EwZWRjIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vZGVsYXlfbm8uaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vZGVsYXlfbm8uaApAQCAtMTYsNyArMTYsNyBAQAogCSAqIGxvbmcgd29yZCBhbGlnbm1lbnQgd2hpY2ggaXMgdGhlIGZhc3RlciB2ZXJzaW9uLgogCSAqIFRoZSAweDRhOGUgaXMgb2YgY291cnNlIGEgJ3RzdGwgJWZwJyBpbnN0cnVjdGlvbi4gIFRoaXMgaXMgYmV0dGVyCiAJICogdGhhbiB1c2luZyBhIE5PUCAoMHg0ZTcxKSBpbnN0cnVjdGlvbiBiZWNhdXNlIGl0IGV4ZWN1dGVzIGluIG9uZQotCSAqIGN5Y2xlIG5vdCB0aHJlZSBhbmQgZG9lc24ndCBhbGxvdyBmb3IgYW4gYXJiaXRhcnkgZGVsYXkgd2FpdGluZworCSAqIGN5Y2xlIG5vdCB0aHJlZSBhbmQgZG9lc24ndCBhbGxvdyBmb3IgYW4gYXJiaXRyYXJ5IGRlbGF5IHdhaXRpbmcKIAkgKiBmb3IgYnVzIGN5Y2xlcyB0byBmaW5pc2guICBBbHNvIGZwL2E2IGlzbid0IGxpa2VseSB0byBjYXVzZSBhCiAJICogc3RhbGwgd2FpdGluZyBmb3IgdGhlIHJlZ2lzdGVyIHRvIGJlY29tZSB2YWxpZCBpZiBzdWNoIGlzIGFkZGVkCiAJICogdG8gdGhlIGNvbGRmaXJlIGF0IHNvbWUgc3RhZ2UuCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vZ3Bpby5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2dwaW8uaAppbmRleCBjNjRjN2I3Li5iMjA0NjgzIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vZ3Bpby5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9ncGlvLmgKQEAgLTMxLDcgKzMxLDcgQEAKICAqIEdQSU9zIGluIGEgc2luZ2xlIGNvbnRyb2wgYXJlYSwgb3RoZXJzIGhhdmUgc29tZSBHUElPcyBpbXBsZW1lbnRlZCBpbgogICogZGlmZmVyZW50IG1vZHVsZXMuCiAgKgotICogVGhpcyBpbXBsZW1lbnRhdGlvbiBhdHRlbXB0cyBhY2NvbW9kYXRlIHRoZSBkaWZmZXJlbmNlcyB3aGlsZSBwcmVzZW50aW5nCisgKiBUaGlzIGltcGxlbWVudGF0aW9uIGF0dGVtcHRzIGFjY29tbW9kYXRlIHRoZSBkaWZmZXJlbmNlcyB3aGlsZSBwcmVzZW50aW5nCiAgKiBhIGdlbmVyaWMgaW50ZXJmYWNlIHRoYXQgd2lsbCBvcHRpbWl6ZSB0byBhcyBmZXcgaW5zdHJ1Y3Rpb25zIGFzIHBvc3NpYmxlLgogICovCiAjaWYgZGVmaW5lZChDT05GSUdfTTUyMDYpIHx8IGRlZmluZWQoQ09ORklHX001MjA2ZSkgfHwgXApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjB4c2ltLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyMHhzaW0uaAppbmRleCA1NWQ1YTRjNS4uYjZiZjJjNSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjB4c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjB4c2ltLmgKQEAgLTE1Nyw3ICsxNTcsNyBAQAogI2RlZmluZQlNQ0ZGRUNfU0laRQkJMHg4MDAJCS8qIFJlZ2lzdGVyIHNldCBzaXplICovCiAKIC8qCi0gKiAgUmVzZXQgQ29udHJvbGwgVW5pdC4KKyAqICBSZXNldCBDb250cm9sIFVuaXQuCiAgKi8KICNkZWZpbmUJTUNGX1JDUgkJCTB4RkMwQTAwMDAKICNkZWZpbmUJTUNGX1JTUgkJCTB4RkMwQTAwMDEKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTIzeHNpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjN4c2ltLmgKaW5kZXggODk5NmRmNi4uNjIzNTkyMSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjN4c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjN4c2ltLmgKQEAgLTQ4LDcgKzQ4LDcgQEAKICNkZWZpbmUJTUNGU0lNX0RNUjEJCShNQ0ZfSVBTQkFSICsgMHg1NCkJLyogQWRkcmVzcyBtYXNrIDEgKi8KIAogLyoKLSAqICBSZXNldCBDb250cm9sbCBVbml0IChyZWxhdGl2ZSB0byBJUFNCQVIpLgorICogIFJlc2V0IENvbnRyb2wgVW5pdCAocmVsYXRpdmUgdG8gSVBTQkFSKS4KICAqLwogI2RlZmluZQlNQ0ZfUkNSCQkJMHgxMTAwMDAKICNkZWZpbmUJTUNGX1JTUgkJCTB4MTEwMDAxCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyN3hzaW0uaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI3eHNpbS5oCmluZGV4IDc0ODU1YTYuLjc1ODgxMGUgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI3eHNpbS5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI3eHNpbS5oCkBAIC0yODMsNyArMjgzLDcgQEAKICNlbmRpZgogCiAvKgotICogIFJlc2V0IENvbnRyb2xsIFVuaXQgKHJlbGF0aXZlIHRvIElQU0JBUikuCisgKiAgUmVzZXQgQ29udHJvbCBVbml0IChyZWxhdGl2ZSB0byBJUFNCQVIpLgogICovCiAjZGVmaW5lCU1DRl9SQ1IJCQkweDExMDAwMAogI2RlZmluZQlNQ0ZfUlNSCQkJMHgxMTAwMDEKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTMwN3NpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzA3c2ltLmgKaW5kZXggNGM5NGMwMS4uOGY4NjA5ZiAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzA3c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzA3c2ltLmgKQEAgLTI5LDcgKzI5LDcgQEAKICNkZWZpbmUJTUNGU0lNX1NXU1IJCTB4MDMJCS8qIFNXIFdhdGNoZG9nIHNlcnZpY2UgKHIvdykgKi8KICNkZWZpbmUJTUNGU0lNX1BBUgkJMHgwNAkJLyogUGluIEFzc2lnbm1lbnQgcmVnIChyL3cpICovCiAjZGVmaW5lCU1DRlNJTV9JUlFQQVIJCTB4MDYJCS8qIEludGVycnVwdCBBc3NpZ25tZW50IHJlZyAoci93KSAqLwotI2RlZmluZQlNQ0ZTSU1fUExMQ1IJCTB4MDgJCS8qIFBMTCBDb250cm9sbCBSZWcqLworI2RlZmluZQlNQ0ZTSU1fUExMQ1IJCTB4MDgJCS8qIFBMTCBDb250cm9sIFJlZyovCiAjZGVmaW5lCU1DRlNJTV9NUEFSSwkJMHgwQwkJLyogQlVTIE1hc3RlciBDb250cm9sIFJlZyovCiAjZGVmaW5lCU1DRlNJTV9JUFIJCTB4NDAJCS8qIEludGVycnVwdCBQZW5kIHJlZyAoci93KSAqLwogI2RlZmluZQlNQ0ZTSU1fSU1SCQkweDQ0CQkvKiBJbnRlcnJ1cHQgTWFzayByZWcgKHIvdykgKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTQwN3NpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDA3c2ltLmgKaW5kZXggNzYyYzU4Yy4uNTFlMDBiMCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDA3c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDA3c2ltLmgKQEAgLTI5LDcgKzI5LDcgQEAKICNkZWZpbmUJTUNGU0lNX1NXU1IJCTB4MDMJCS8qIFNXIFdhdGNoZG9nIHNlcnZpY2UgKHIvdykgKi8KICNkZWZpbmUJTUNGU0lNX1BBUgkJMHgwNAkJLyogUGluIEFzc2lnbm1lbnQgcmVnIChyL3cpICovCiAjZGVmaW5lCU1DRlNJTV9JUlFQQVIJCTB4MDYJCS8qIEludGVycnVwdCBBc3NpZ25tZW50IHJlZyAoci93KSAqLwotI2RlZmluZQlNQ0ZTSU1fUExMQ1IJCTB4MDgJCS8qIFBMTCBDb250cm9sbCBSZWcqLworI2RlZmluZQlNQ0ZTSU1fUExMQ1IJCTB4MDgJCS8qIFBMTCBDb250cm9sIFJlZyovCiAjZGVmaW5lCU1DRlNJTV9NUEFSSwkJMHgwQwkJLyogQlVTIE1hc3RlciBDb250cm9sIFJlZyovCiAjZGVmaW5lCU1DRlNJTV9JUFIJCTB4NDAJCS8qIEludGVycnVwdCBQZW5kIHJlZyAoci93KSAqLwogI2RlZmluZQlNQ0ZTSU1fSU1SCQkweDQ0CQkvKiBJbnRlcnJ1cHQgTWFzayByZWcgKHIvdykgKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNjgzNjBfcXVpY2MuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNjgzNjBfcXVpY2MuaAppbmRleCA2ZDQwZjRkLi41OTQxNGNjIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTY4MzYwX3F1aWNjLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL202ODM2MF9xdWljYy5oCkBAIC0zMiw3ICszMiw3IEBACiAgICAgLyogQkFTRSArIDB4MDAwOiB1c2VyIGRhdGEgbWVtb3J5ICovCiAgICAgdm9sYXRpbGUgdW5zaWduZWQgY2hhciAgICAgIHVkYXRhX2JkX3Vjb2RlWzB4NDAwXTsgLyp1c2VyIGRhdGEgYmQncyBVY29kZSovCiAgICAgdm9sYXRpbGUgdW5zaWduZWQgY2hhciAgICAgIHVkYXRhX2JkWzB4MjAwXTsgICAgICAgLyp1c2VyIGRhdGEgVWNvZGUgICAgICovCi0gICAgdm9sYXRpbGUgdW5zaWduZWQgY2hhciAgICAgIHVjb2RlX2V4dFsweDEwMF07ICAgICAgLypVY29kZSBFeHRlbnRpb24gcmFtICovCisgICAgdm9sYXRpbGUgdW5zaWduZWQgY2hhciAgICAgIHVjb2RlX2V4dFsweDEwMF07ICAgICAgLypVY29kZSBFeHRlbnNpb24gcmFtICovCiAgICAgdm9sYXRpbGUgdW5zaWduZWQgY2hhciAgICAgIFJFU0VSVkVEMVsweDUwMF07ICAgICAgLyogUmVzZXJ2ZWQgYXJlYSAgICAgICovCiB9OwogI2Vsc2UKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tYWNfb3NzLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbWFjX29zcy5oCmluZGV4IDcyMjFmNzIuLjNjZjJiNmUgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tYWNfb3NzLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21hY19vc3MuaApAQCAtNjEsNyArNjEsNyBAQAogLyoKICAqIE9TUyBJbnRlcnJ1cHQgbGV2ZWxzIGZvciB2YXJpb3VzIHN1Yi1zeXN0ZW1zCiAgKgotICogVGhpcyBtYXBwaW5nIGlzIGxheWVkIG91dCB3aXRoIHR3byB0aGluZ3MgaW4gbWluZDogZmlyc3QsIHdlIHRyeSB0byBrZWVwCisgKiBUaGlzIG1hcHBpbmcgaXMgbGFpZCBvdXQgd2l0aCB0d28gdGhpbmdzIGluIG1pbmQ6IGZpcnN0LCB3ZSB0cnkgdG8ga2VlcAogICogdGhpbmdzIG9uIHRoZWlyIG93biBsZXZlbHMgdG8gYXZvaWQgaGF2aW5nIHRvIGRvIGRvdWJsZS1kaXNwYXRjaGVzLiBTZWNvbmQsCiAgKiB0aGUgbGV2ZWxzIG1hdGNoIGFzIGNsb3NlbHkgYXMgcG9zc2libGUgdGhlIGFsdGVybmF0ZSBJUlEgbWFwcGluZyBtb2RlIChha2EKICAqICJBL1VYIG1vZGUiKSBhdmFpbGFibGUgb24gc29tZSBWSUEgbWFjaGluZXMuCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbWFjX3ZpYS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21hY192aWEuaAppbmRleCAzOWFmYjQzLi5hNTk2NjVlIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbWFjX3ZpYS5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tYWNfdmlhLmgKQEAgLTIwNCw3ICsyMDQsNyBAQAogI2RlZmluZSB2VDJDTAkweDEwMDAgIC8qIFtWSUEgb25seV0gVGltZXIgdHdvIGNvdW50ZXIgbG93LiAqLwogI2RlZmluZSB2VDJDSAkweDEyMDAgIC8qIFtWSUEgb25seV0gVGltZXIgdHdvIGNvdW50ZXIgaGlnaC4gKi8KICNkZWZpbmUgdlNSCTB4MTQwMCAgLyogW1ZJQSBvbmx5XSBTaGlmdCByZWdpc3Rlci4gKi8KLSNkZWZpbmUgdkFDUgkweDE2MDAgIC8qIFtWSUEgb25seV0gQXV4aWxhcnkgY29udHJvbCByZWdpc3Rlci4gKi8KKyNkZWZpbmUgdkFDUgkweDE2MDAgIC8qIFtWSUEgb25seV0gQXV4aWxpYXJ5IGNvbnRyb2wgcmVnaXN0ZXIuICovCiAjZGVmaW5lIHZQQ1IJMHgxODAwICAvKiBbVklBIG9ubHldIFBlcmlwaGVyYWwgY29udHJvbCByZWdpc3Rlci4gKi8KICAgICAgICAgICAgICAgICAgICAgICAgIC8qICAgICAgICAgICAgQ0hSUCBzZXogbmV2ZXIgZXZlciB0byAqd3JpdGUqIHRoaXMuCiAJCQkgKiAgICAgICAgICAgIE1hYyBmYW1pbHkgc2F5cyBuZXZlciB0byAqY2hhbmdlKiB0aGlzLgpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21hY2ludG9zaC5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21hY2ludG9zaC5oCmluZGV4IDUwZGIzNTkuLmMyYTFjNWUgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tYWNpbnRvc2guaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbWFjaW50b3NoLmgKQEAgLTE0LDcgKzE0LDcgQEAKIGV4dGVybiBpbnQgbWFjX2lycV9wZW5kaW5nKHVuc2lnbmVkIGludCk7CiAKIC8qCi0gKglGbG9wcHkgZHJpdmVyIG1hZ2ljIGhvb2sgLSBwcm9iYWJseSBzaG91bGRudCBiZSBoZXJlCisgKglGbG9wcHkgZHJpdmVyIG1hZ2ljIGhvb2sgLSBwcm9iYWJseSBzaG91bGRuJ3QgYmUgaGVyZQogICovCiAKIGV4dGVybiB2b2lkIHZpYTFfc2V0X2hlYWQoaW50KTsKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2Z0aW1lci5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21jZnRpbWVyLmgKaW5kZXggOTJiMjc2Zi4uMzUxYzI3MiAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21jZnRpbWVyLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21jZnRpbWVyLmgKQEAgLTI3LDcgKzI3LDcgQEAKIAogLyoKICAqCUJpdCBkZWZpbml0aW9ucyBmb3IgdGhlIFRpbWVyIE1vZGUgUmVnaXN0ZXIgKFRNUikuCi0gKglSZWdpc3RlciBiaXQgZmxhZ3MgYXJlIGNvbW1vbiBhY2Nyb3NzIENvbGRGaXJlcy4KKyAqCVJlZ2lzdGVyIGJpdCBmbGFncyBhcmUgY29tbW9uIGFjcm9zcyBDb2xkRmlyZXMuCiAgKi8KICNkZWZpbmUJTUNGVElNRVJfVE1SX1BSRU1BU0sJMHhmZjAwCQkvKiBQcmVzY2FsYXIgbWFzayAqLwogI2RlZmluZQlNQ0ZUSU1FUl9UTVJfRElTQ0UJMHgwMDAwCQkvKiBEaXNhYmxlIGNhcHR1cmUgKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9rZXJuZWwvaGVhZC5TIGIvYXJjaC9tNjhrL2tlcm5lbC9oZWFkLlMKaW5kZXggZWY1NDEyOC4uMjc2MjJiMyAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2tlcm5lbC9oZWFkLlMKKysrIGIvYXJjaC9tNjhrL2tlcm5lbC9oZWFkLlMKQEAgLTEzNCw3ICsxMzQsNyBAQAogICoJVGhhbmtzIHRvIGEgc21hbGwgaGVscGluZyByb3V0aW5lIGVuYWJsaW5nIHRoZSBtbXUgZ290IHF1aXRlIHNpbXBsZQogICogYW5kIHRoZXJlIGlzIG9ubHkgb25lIHdheSBsZWZ0LiBtbXVfZW5nYWdlIG1ha2VzIGEgY29tcGxldGUgYSBuZXcgbWFwcGluZwogICogdGhhdCBvbmx5IGluY2x1ZGVzIHRoZSBhYnNvbHV0ZSBuZWNlc3NhcnkgdG8gYmUgYWJsZSB0byBqdW1wIHRvIHRoZSBmaW5hbAotICogcG9zdGlvbiBhbmQgdG8gcmVzdG9yZSB0aGUgb3JpZ2luYWwgbWFwcGluZy4KKyAqIHBvc2l0aW9uIGFuZCB0byByZXN0b3JlIHRoZSBvcmlnaW5hbCBtYXBwaW5nLgogICogQXMgdGhpcyBjb2RlIGRvZXNuJ3QgbmVlZCBhIHRyYW5zcGFyZW50IHRyYW5zbGF0aW9uIHJlZ2lzdGVyIGFueW1vcmUgdGhpcwogICogbWVhbnMgYWxsIHJlZ2lzdGVycyBhcmUgZnJlZSB0byBiZSB1c2VkIGJ5IG1hY2hpbmVzIHRoYXQgbmVlZHMgdGhlbSBmb3IKICAqIG90aGVyIHB1cnBvc2VzLgpAQCAtOTY5LDcgKzk2OSw3IEBACiAJaXNfbm90XzA0MF9vcl8wNjAoMWYpCiAKIAkvKgotCSAqIDA0MDogTWFwIHRoZSAxNk1lZyByYW5nZSBwaHlzaWNhbCAweDAgdXB0byBsb2dpY2FsIDB4ODAwMC4wMDAwCisJICogMDQwOiBNYXAgdGhlIDE2TWVnIHJhbmdlIHBoeXNpY2FsIDB4MCB1cCB0byBsb2dpY2FsIDB4ODAwMC4wMDAwCiAJICovCiAJbW11X21hcAkJIzB4ODAwMDAwMDAsIzAsIzB4MDEwMDAwMDAsI19QQUdFX05PQ0FDSEVfUwogCS8qCkBAIC05ODIsNyArOTgyLDcgQEAKIAogMToKIAkvKgotCSAqIDAzMDoJTWFwIHRoZSAzMk1lZyByYW5nZSBwaHlzaWNhbCAweDAgdXB0byBsb2dpY2FsIDB4ODAwMC4wMDAwCisJICogMDMwOglNYXAgdGhlIDMyTWVnIHJhbmdlIHBoeXNpY2FsIDB4MCB1cCB0byBsb2dpY2FsIDB4ODAwMC4wMDAwCiAJICovCiAJbW11X21hcAkJIzB4ODAwMDAwMDAsIzAsIzB4MDIwMDAwMDAsI19QQUdFX05PQ0FDSEUwMzAKIAltbXVfbWFwX3R0CSMxLCMweDQwMDAwMDAwLCMweDIwMDAwMDAwLCNfUEFHRV9OT0NBQ0hFMDMwCkBAIC0xMDc0LDcgKzEwNzQsNyBAQAogCWlzXzA0MCgxZikKIAogCS8qCi0JICogMDMwOiBNYXAgdGhlIDMyTWVnIHJhbmdlIHBoeXNpY2FsIDB4MCB1cHRvIGxvZ2ljYWwgMHhmMDAwLjAwMDAKKwkgKiAwMzA6IE1hcCB0aGUgMzJNZWcgcmFuZ2UgcGh5c2ljYWwgMHgwIHVwIHRvIGxvZ2ljYWwgMHhmMDAwLjAwMDAKIAkgKi8KIAltbXVfbWFwCSMweGYwMDAwMDAwLCMwLCMweDAyMDAwMDAwLCNfUEFHRV9OT0NBQ0hFMDMwCiAKQEAgLTEwODIsNyArMTA4Miw3IEBACiAKIDE6CiAJLyoKLQkgKiAwNDA6IE1hcCB0aGUgMTZNZWcgcmFuZ2UgcGh5c2ljYWwgMHgwIHVwdG8gbG9naWNhbCAweGYwMDAuMDAwMAorCSAqIDA0MDogTWFwIHRoZSAxNk1lZyByYW5nZSBwaHlzaWNhbCAweDAgdXAgdG8gbG9naWNhbCAweGYwMDAuMDAwMAogCSAqLwogCW1tdV9tYXAgIzB4ZjAwMDAwMDAsIzAsIzB4MDEwMDAwMDAsI19QQUdFX05PQ0FDSEVfUwogCkBAIC0zMDc4LDcgKzMwNzgsNyBAQAogCS8qCiAJICogSWYgdGhlIGxvYWRlciBnYXZlIHVzIGEgYm9hcmQgdHlwZSB0aGVuIHdlIGNhbiB1c2UgdGhhdCB0bwogCSAqIHNlbGVjdCBhbiBhcHByb3ByaWF0ZSBvdXRwdXQgcm91dGluZTsgb3RoZXJ3aXNlIHdlIGp1c3QgdXNlCi0JICogdGhlIEJ1ZyBjb2RlLiAgSWYgd2UgaGFldiB0byB1c2UgdGhlIEJ1ZyB0aGF0IG1lYW5zIHRoZSBCdWcKKwkgKiB0aGUgQnVnIGNvZGUuICBJZiB3ZSBoYXZlIHRvIHVzZSB0aGUgQnVnIHRoYXQgbWVhbnMgdGhlIEJ1ZwogCSAqIHdvcmtzcGFjZSBoYXMgdG8gYmUgdmFsaWQsIHdoaWNoIG1lYW5zIHRoZSBCdWcgaGFzIHRvIHVzZQogCSAqIHRoZSBTUkFNLCB3aGljaCBpcyBub24tc3RhbmRhcmQuCiAJICovCmRpZmYgLS1naXQgYS9hcmNoL202OGsva2VybmVsL3ZtbGludXgubGRzX25vLlMgYi9hcmNoL202OGsva2VybmVsL3ZtbGludXgubGRzX25vLlMKaW5kZXggNDdlMTVlYi4uZjRkNzE1YyAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2tlcm5lbC92bWxpbnV4Lmxkc19uby5TCisrKyBiL2FyY2gvbTY4ay9rZXJuZWwvdm1saW51eC5sZHNfbm8uUwpAQCAtMyw3ICszLDcgQEAKICAqCiAgKgkoQykgQ29weXJpZ2h0IDIwMDItMjAwNiwgR3JlZyBVbmdlcmVyIDxnZXJnQHNuYXBnZWFyLmNvbT4KICAqCi0gKglUaGlzIGxpbmtlciBzY3JpcHQgaXMgZXF1aXBlZCB0byBidWlsZCBlaXRoZXIgUk9NIGxvYWRlZCBvciBSQU0KKyAqCVRoaXMgbGlua2VyIHNjcmlwdCBpcyBlcXVpcHBlZCB0byBidWlsZCBlaXRoZXIgUk9NIGxvYWRlZCBvciBSQU0KICAqCXJ1biBrZXJuZWxzLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9wbGF0Zm9ybS81MjN4L2NvbmZpZy5jIGIvYXJjaC9tNjhrL3BsYXRmb3JtLzUyM3gvY29uZmlnLmMKaW5kZXggNDE4YTc2Zi4uNzFmNDQzNiAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL3BsYXRmb3JtLzUyM3gvY29uZmlnLmMKKysrIGIvYXJjaC9tNjhrL3BsYXRmb3JtLzUyM3gvY29uZmlnLmMKQEAgLTMsNyArMyw3IEBACiAvKgogICoJbGludXgvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vNTIzeC9jb25maWcuYwogICoKLSAqCVN1Yi1hcmNoaXRjdHVyZSBkZXBlbmRhbnQgaW5pdGlhbGl6YXRpb24gY29kZSBmb3IgdGhlIEZyZWVzY2FsZQorICoJU3ViLWFyY2hpdGN0dXJlIGRlcGVuZGVudCBpbml0aWFsaXphdGlvbiBjb2RlIGZvciB0aGUgRnJlZXNjYWxlCiAgKgk1MjN4IENQVXMuCiAgKgogICoJQ29weXJpZ2h0IChDKSAxOTk5LTIwMDUsIEdyZWcgVW5nZXJlciAoZ2VyZ0BzbmFwZ2Vhci5jb20pCmRpZmYgLS1naXQgYS9hcmNoL202OGsvcGxhdGZvcm0vNTI3Mi9pbnRjLmMgYi9hcmNoL202OGsvcGxhdGZvcm0vNTI3Mi9pbnRjLmMKaW5kZXggNDNlNmU5Ni4uN2U3MTVkZiAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL3BsYXRmb3JtLzUyNzIvaW50Yy5jCisrKyBiL2FyY2gvbTY4ay9wbGF0Zm9ybS81MjcyL2ludGMuYwpAQCAtMzMsNyArMzMsNyBAQAogICoKICAqIE5vdGUgdGhhdCB0aGUgZXh0ZXJuYWwgaW50ZXJydXB0cyBhcmUgZWRnZSB0cmlnZ2VyZWQgKHVubGlrZSB0aGUKICAqIGludGVybmFsIGludGVycnVwdCBzb3VyY2VzIHdoaWNoIGFyZSBsZXZlbCB0cmlnZ2VyZWQpLiBXaGljaCBtZWFucwotICogdGhleSBhbHNvIG5lZWQgYWNrbm93bGVkZ2VpbmcgdmlhIGFja25vd2xlZGdlIGJpdHMuCisgKiB0aGV5IGFsc28gbmVlZCBhY2tub3dsZWRnaW5nIHZpYSBhY2tub3dsZWRnZSBiaXRzLgogICovCiBzdHJ1Y3QgaXJxbWFwIHsKIAl1bnNpZ25lZCBjaGFyCWljcjsKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9wbGF0Zm9ybS81Mjd4L2NvbmZpZy5jIGIvYXJjaC9tNjhrL3BsYXRmb3JtLzUyN3gvY29uZmlnLmMKaW5kZXggZmEzNTk1OS4uM2ViYzc2OSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL3BsYXRmb3JtLzUyN3gvY29uZmlnLmMKKysrIGIvYXJjaC9tNjhrL3BsYXRmb3JtLzUyN3gvY29uZmlnLmMKQEAgLTMsNyArMyw3IEBACiAvKgogICoJbGludXgvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vNTI3eC9jb25maWcuYwogICoKLSAqCVN1Yi1hcmNoaXRjdHVyZSBkZXBlbmRhbnQgaW5pdGlhbGl6YXRpb24gY29kZSBmb3IgdGhlIEZyZWVzY2FsZQorICoJU3ViLWFyY2hpdGN0dXJlIGRlcGVuZGVudCBpbml0aWFsaXphdGlvbiBjb2RlIGZvciB0aGUgRnJlZXNjYWxlCiAgKgk1MjcwLzUyNzEgQ1BVcy4KICAqCiAgKglDb3B5cmlnaHQgKEMpIDE5OTktMjAwNCwgR3JlZyBVbmdlcmVyIChnZXJnQHNuYXBnZWFyLmNvbSkKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9wbGF0Zm9ybS81Mjh4L2NvbmZpZy5jIGIvYXJjaC9tNjhrL3BsYXRmb3JtLzUyOHgvY29uZmlnLmMKaW5kZXggYWMzOWZjNi4uN2FiZTc3YSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL3BsYXRmb3JtLzUyOHgvY29uZmlnLmMKKysrIGIvYXJjaC9tNjhrL3BsYXRmb3JtLzUyOHgvY29uZmlnLmMKQEAgLTMsNyArMyw3IEBACiAvKgogICoJbGludXgvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vNTI4eC9jb25maWcuYwogICoKLSAqCVN1Yi1hcmNoaXRjdHVyZSBkZXBlbmRhbnQgaW5pdGlhbGl6YXRpb24gY29kZSBmb3IgdGhlIEZyZWVzY2FsZQorICoJU3ViLWFyY2hpdGN0dXJlIGRlcGVuZGVudCBpbml0aWFsaXphdGlvbiBjb2RlIGZvciB0aGUgRnJlZXNjYWxlCiAgKgk1MjgwLCA1MjgxIGFuZCA1MjgyIENQVXMuCiAgKgogICoJQ29weXJpZ2h0IChDKSAxOTk5LTIwMDMsIEdyZWcgVW5nZXJlciAoZ2VyZ0BzbmFwZ2Vhci5jb20pCmRpZmYgLS1naXQgYS9hcmNoL202OGsvcGxhdGZvcm0vY29sZGZpcmUvY2FjaGUuYyBiL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9jYWNoZS5jCmluZGV4IDIzNWQzYzQuLjcxYmVlYWYgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9jYWNoZS5jCisrKyBiL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9jYWNoZS5jCkBAIC0xLDcgKzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqCWNhY2hlLmMgLS0gZ2VuZXJhbCBDb2xkRmlyZSBDYWNoZSBtYWludGFpbmVuY2UgY29kZQorICoJY2FjaGUuYyAtLSBnZW5lcmFsIENvbGRGaXJlIENhY2hlIG1haW50ZW5hbmNlIGNvZGUKICAqCiAgKglDb3B5cmlnaHQgKEMpIDIwMTAsIEdyZWcgVW5nZXJlciAoZ2VyZ0BzbmFwZ2Vhci5jb20pCiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9lbnRyeS5TIGIvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL2VudHJ5LlMKaW5kZXggNTgzN2NmMC4uZWFiNjNmMCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL2VudHJ5LlMKKysrIGIvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL2VudHJ5LlMKQEAgLTE2Myw3ICsxNjMsNyBAQAogCiAvKgogICogVGhpcyBpcyB0aGUgZ2VuZXJpYyBpbnRlcnJ1cHQgaGFuZGxlciAoZm9yIGFsbCBoYXJkd2FyZSBpbnRlcnJ1cHQKLSAqIHNvdXJjZXMpLiBDYWxscyB1cHRvIGhpZ2ggbGV2ZWwgY29kZSB0byBkbyBhbGwgdGhlIHdvcmsuCisgKiBzb3VyY2VzKS4gQ2FsbHMgdXAgdG8gaGlnaCBsZXZlbCBjb2RlIHRvIGRvIGFsbCB0aGUgd29yay4KICAqLwogRU5UUlkoaW50aGFuZGxlcikKIAlTQVZFX0FMTApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL2hlYWQuUyBiL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9oZWFkLlMKaW5kZXggMTI5YmZmNDkuLjZhZTkxYTQgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9oZWFkLlMKKysrIGIvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL2hlYWQuUwpAQCAtMjAsNyArMjAsNyBAQAogCiAvKgogICoJSWYgd2UgZG9uJ3QgaGF2ZSBhIGZpeGVkIG1lbW9yeSBzaXplLCB0aGVuIGxldHMgYnVpbGQgaW4gY29kZQotICoJdG8gYXV0byBkZXRlY3QgdGhlIERSQU0gc2l6ZS4gT2J2aW91c2x5IHRoaXMgaXMgdGhlIHByZWZlcmVkCisgKgl0byBhdXRvIGRldGVjdCB0aGUgRFJBTSBzaXplLiBPYnZpb3VzbHkgdGhpcyBpcyB0aGUgcHJlZmVycmVkCiAgKgltZXRob2QsIGFuZCBzaG91bGQgd29yayBmb3IgbW9zdCBib2FyZHMuIEl0IHdvbid0IHdvcmsgZm9yIHRob3NlCiAgKgl0aGF0IGRvIG5vdCBoYXZlIHRoZWlyIFJBTSBzdGFydGluZyBhdCBhZGRyZXNzIDAsIGFuZCBpdCBvbmx5CiAgKgl3b3JrcyBvbiBTRFJBTSAobm90IGJvYXJkcyBmaXR0ZWQgd2l0aCBTUkFNKS4KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9pbnRjLmMgYi9hcmNoL202OGsvcGxhdGZvcm0vY29sZGZpcmUvaW50Yy5jCmluZGV4IGMyOGE2ZWQuLjBiYmI0MTQgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9wbGF0Zm9ybS9jb2xkZmlyZS9pbnRjLmMKKysrIGIvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL2ludGMuYwpAQCAtMzcsNyArMzcsNyBAQAogLyoKICAqIEluIHRoZSBlYXJseSB2ZXJzaW9uIDIgY29yZSBDb2xkRmlyZSBwYXJ0cyB0aGUgSU1SIHJlZ2lzdGVyIHdhcyAxNiBiaXRzCiAgKiBpbiBzaXplLiBWZXJzaW9uIDMgKGFuZCBsYXRlciB2ZXJzaW9uIDIpIGNvcmUgcGFydHMgaGF2ZSBhIDMyIGJpdAotICogc2l6ZWQgSU1SIHJlZ2lzdGVyLiBQcm92aWRlIHNvbWUgc2l6ZSBpbmRlcGVuZGFudCBtZXRob2RzIHRvIGFjY2VzcyB0aGUKKyAqIHNpemVkIElNUiByZWdpc3Rlci4gUHJvdmlkZSBzb21lIHNpemUgaW5kZXBlbmRlbnQgbWV0aG9kcyB0byBhY2Nlc3MgdGhlCiAgKiBJTVIgcmVnaXN0ZXIuCiAgKi8KICNpZmRlZiBNQ0ZTSU1fSU1SX0lTXzE2QklUUwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL3BsYXRmb3JtL2NvbGRmaXJlL3NsdGltZXJzLmMgYi9hcmNoL202OGsvcGxhdGZvcm0vY29sZGZpcmUvc2x0aW1lcnMuYwppbmRleCAwYTFiOTM3Li42YTg1ZGFmIDEwMDY0NAotLS0gYS9hcmNoL202OGsvcGxhdGZvcm0vY29sZGZpcmUvc2x0aW1lcnMuYworKysgYi9hcmNoL202OGsvcGxhdGZvcm0vY29sZGZpcmUvc2x0aW1lcnMuYwpAQCAtMTA2LDcgKzEwNiw3IEBACiAJY3ljbGVzID0gbWNmc2x0X2NudDsKIAlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAKLQkvKiBzdWJzdHJhY3QgYmVjYXVzZSBzbGljZSB0aW1lcnMgY291bnQgZG93biAqLworCS8qIHN1YnRyYWN0IGJlY2F1c2Ugc2xpY2UgdGltZXJzIGNvdW50IGRvd24gKi8KIAlyZXR1cm4gY3ljbGVzIC0gc2NudDsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL3E0MC9SRUFETUUgYi9hcmNoL202OGsvcTQwL1JFQURNRQppbmRleCBmODc3YjcyLi5iMjZkNWY1IDEwMDY0NAotLS0gYS9hcmNoL202OGsvcTQwL1JFQURNRQorKysgYi9hcmNoL202OGsvcTQwL1JFQURNRQpAQCAtODksNyArODksNyBAQAogb3IgZnJvbSBzb21lIElTQSBkZXZpY2VzLCBFSVJRX1JFRyBjYW4gZGlzdGluZ3Vpc2ggdXAgdG8gOCBJU0EgSVJRcy4KIAogVGhlIFE0MCBjdXN0b20gY2hpcCBpcyBwcm9ncmFtbWFibGUgdG8gcHJvdmlkZSAyIHBlcmlvZGljIHRpbWVyczoKLQktIDUwIG9yIDIwMCBIeiAtIGxldmVsIDIsICEhVEhJUyBDQU5UIEJFIERJU0FCTEVEISEKKwktIDUwIG9yIDIwMCBIeiAtIGxldmVsIDIsICEhVEhJUyBDQU4nVCBCRSBESVNBQkxFRCEhCiAJLSAxMCBvciAyMCBLSHogLSBsZXZlbCA0LCB1c2VkIGZvciBkbWEtc291bmQKIAogTGludXggdXNlcyB0aGUgMjAwIEh6IGludGVycnVwdCBmb3IgdGltZXIgYW5kIGJlZXAgYnkgZGVmYXVsdC4KZGlmZiAtLWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9NYWtlZmlsZSBiL2FyY2gvbWljcm9ibGF6ZS9NYWtlZmlsZQppbmRleCA2ZjQzMmU2Li5iMjNjNDBlIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvTWFrZWZpbGUKKysrIGIvYXJjaC9taWNyb2JsYXplL01ha2VmaWxlCkBAIC0xOCw3ICsxOCw3IEBACiAjIHJhdGhlciB0aGFuIGJvb2xzIHkvbgogCiAjIFdvcmsgb3V0IEhXIG11bHRpcGxlciBzdXBwb3J0LiBUaGlzIGlzIHRyaWNreS4KLSMgMS4gU3BhcnRhbjIgaGFzIG5vIEhXIG11bHRpcGxlcnMuCisjIDEuIFNwYXJ0YW4yIGhhcyBubyBIVyBtdWx0aXBsaWVycy4KICMgMi4gTWljcm9CbGF6ZSB2My54IGFsd2F5cyB1c2VzIHRoZW0sIGV4Y2VwdCBpbiBTcGFydGFuIDIKICMgMy4gQWxsIG90aGVyIEZQR2EvQ1BVIHZlciBjb21ib3MsIHdlIGNhbiB0cnVzdCB0aGUgQ09ORklHXyBzZXR0aW5ncwogaWZlcSAoLCQoZmluZHN0cmluZyBzcGFydGFuMiwkKENPTkZJR19YSUxJTlhfTUlDUk9CTEFaRTBfRkFNSUxZKSkpCmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vaW8uaCBiL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9pby5oCmluZGV4IGVhZTMyMjIuLjhjZGFjMTQgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9pby5oCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9pby5oCkBAIC03MCw3ICs3MCw3IEBACiAKIC8qCiAgKiByZWFkIChyZWFkYiwgcmVhZHcsIHJlYWRsLCByZWFkcSkgYW5kIHdyaXRlICh3cml0ZWIsIHdyaXRldywKLSAqIHdyaXRlbCwgd3JpdGVxKSBhY2Nlc3NvcnMgYXJlIGZvciBQQ0kgYW5kIHRodXMgbGl0dGVsIGVuZGlhbi4KKyAqIHdyaXRlbCwgd3JpdGVxKSBhY2Nlc3NvcnMgYXJlIGZvciBQQ0kgYW5kIHRodXMgbGl0dGxlIGVuZGlhbi4KICAqIExpbnV4IDIuNCBmb3IgTWljcm9ibGF6ZSBoYWQgdGhpcyB3cm9uZy4KICAqLwogc3RhdGljIGlubGluZSB1bnNpZ25lZCBjaGFyIHJlYWRiKGNvbnN0IHZvbGF0aWxlIHZvaWQgX19pb21lbSAqYWRkcikKZGlmZiAtLWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9wY2ktYnJpZGdlLmggYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vcGNpLWJyaWRnZS5oCmluZGV4IDEwNzE3NjYuLjc0NmRmOTEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9wY2ktYnJpZGdlLmgKKysrIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3BjaS1icmlkZ2UuaApAQCAtNzYsNyArNzYsNyBAQAogCSAqIFVzZWQgZm9yIHZhcmlhbnRzIG9mIFBDSSBpbmRpcmVjdCBoYW5kbGluZyBhbmQgcG9zc2libGUgcXVpcmtzOgogCSAqICBTRVRfQ0ZHX1RZUEUgLSB1c2VkIG9uIDR4eCBvciBhbnkgUEhCIHRoYXQgZG9lcyBleHBsaWNpdCB0eXBlMC8xCiAJICogIEVYVF9SRUcgLSBwcm92aWRlcyBhY2Nlc3MgdG8gUENJLWUgZXh0ZW5kZWQgcmVnaXN0ZXJzCi0JICogIFNVUlBSRVNTX1BSSU1BUllfQlVTIC0gd2Ugc3VycHJlc3MgdGhlIHNldHRpbmcgb2YgUENJX1BSSU1BUllfQlVTCisJICogIFNVUlBSRVNTX1BSSU1BUllfQlVTIC0gd2Ugc3VwcHJlc3MgdGhlIHNldHRpbmcgb2YgUENJX1BSSU1BUllfQlVTCiAJICogICBvbiBGcmVlc2NhbGUgUENJLWUgY29udHJvbGxlcnMgc2luY2UgdGhleSB1c2VkIHRoZSBQQ0lfUFJJTUFSWV9CVVMKIAkgKiAgIHRvIGRldGVybWluZSB3aGljaCBidXMgbnVtYmVyIHRvIG1hdGNoIG9uIHdoZW4gZ2VuZXJhdGluZyB0eXBlMAogCSAqICAgY29uZmlnIGN5Y2xlcwpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3BjaS5oIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3BjaS5oCmluZGV4IDIyMzJmZjk0Li5iYTY1Y2Y0IDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vcGNpLmgKKysrIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3BjaS5oCkBAIC0xNTgsNyArMTU4LDcgQEAKIGV4dGVybiB2b2lkIHBjaWJpb3Nfc2V0dXBfYnVzX2RldmljZXMoc3RydWN0IHBjaV9idXMgKmJ1cyk7CiBleHRlcm4gdm9pZCBwY2liaW9zX3NldHVwX2J1c19zZWxmKHN0cnVjdCBwY2lfYnVzICpidXMpOwogCi0vKiBUaGlzIHBhcnQgb2YgY29kZSB3YXMgb3JpZ2luYWx5IGluIHhpbGlueC1wY2kuaCAqLworLyogVGhpcyBwYXJ0IG9mIGNvZGUgd2FzIG9yaWdpbmFsbHkgaW4geGlsaW54LXBjaS5oICovCiAjaWZkZWYgQ09ORklHX1BDSV9YSUxJTlgKIGV4dGVybiB2b2lkIF9faW5pdCB4aWxpbnhfcGNpX2luaXQodm9pZCk7CiAjZWxzZQpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2tlcm5lbC9jcHUvY2FjaGUuYyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvY3B1L2NhY2hlLmMKaW5kZXggY2YwYWZkOS4uNGI3ZDhhMyAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2tlcm5lbC9jcHUvY2FjaGUuYworKysgYi9hcmNoL21pY3JvYmxhemUva2VybmVsL2NwdS9jYWNoZS5jCkBAIC0xMjksNyArMTI5LDcgQEAKICAqIHRvIHVzZSBmb3Igc2ltcGxlIHdkYyBvciB3aWMuCiAgKgogICogc3RhcnQgYWRkcmVzcyBpcyBjYWNoZSBhbGlnbmVkCi0gKiBlbmQgYWRkcmVzcyBpcyBub3QgYWxpZ25lZCwgaWYgZW5kIGlzIGFsaWduZWQgdGhlbiBJIGhhdmUgdG8gc3Vic3RyYWN0CisgKiBlbmQgYWRkcmVzcyBpcyBub3QgYWxpZ25lZCwgaWYgZW5kIGlzIGFsaWduZWQgdGhlbiBJIGhhdmUgdG8gc3VidHJhY3QKICAqIGNhY2hlbGluZSBsZW5ndGggYmVjYXVzZSBJIGNhbid0IGZsdXNoL2ludmFsaWRhdGUgdGhlIG5leHQgY2FjaGVsaW5lLgogICogSWYgaXMgbm90LCBJIGFsaWduIGl0IGJlY2F1c2UgSSB3aWxsIGZsdXNoL2ludmFsaWRhdGUgd2hvbGUgbGluZS4KICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2xpYi9tZW1jcHkuYyBiL2FyY2gvbWljcm9ibGF6ZS9saWIvbWVtY3B5LmMKaW5kZXggY2M0OTVkNy4uNTI3NDZlNyAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2xpYi9tZW1jcHkuYworKysgYi9hcmNoL21pY3JvYmxhemUvbGliL21lbWNweS5jCkBAIC02Myw4ICs2Myw4IEBACiAJaWYgKGxpa2VseShjID49IDQpKSB7CiAJCXVuc2lnbmVkICB2YWx1ZSwgYnVmX2hvbGQ7CiAKLQkJLyogQWxpZ24gdGhlIGRzdGluYXRpb24gdG8gYSB3b3JkIGJvdW5kcnkuICovCi0JCS8qIFRoaXMgaXMgZG9uZSBpbiBhbiBlbmRpYW4gaW5kZXBlbmRhbnQgbWFubmVyLiAqLworCQkvKiBBbGlnbiB0aGUgZGVzdGluYXRpb24gdG8gYSB3b3JkIGJvdW5kYXJ5LiAqLworCQkvKiBUaGlzIGlzIGRvbmUgaW4gYW4gZW5kaWFuIGluZGVwZW5kZW50IG1hbm5lci4gKi8KIAkJc3dpdGNoICgodW5zaWduZWQgbG9uZylkc3QgJiAzKSB7CiAJCWNhc2UgMToKIAkJCSpkc3QrKyA9ICpzcmMrKzsKQEAgLTgwLDcgKzgwLDcgQEAKIAkJaV9kc3QgPSAodm9pZCAqKWRzdDsKIAogCQkvKiBDaG9vc2UgYSBjb3B5IHNjaGVtZSBiYXNlZCBvbiB0aGUgc291cmNlICovCi0JCS8qIGFsaWdubWVudCByZWxhdGl2ZSB0byBkc3RpbmF0aW9uLiAqLworCQkvKiBhbGlnbm1lbnQgcmVsYXRpdmUgdG8gZGVzdGluYXRpb24uICovCiAJCXN3aXRjaCAoKHVuc2lnbmVkIGxvbmcpc3JjICYgMykgewogCQljYXNlIDB4MDoJLyogQm90aCBieXRlIG9mZnNldHMgYXJlIGFsaWduZWQgKi8KIAkJCWlfc3JjICA9IChjb25zdCB2b2lkICopc3JjOwpAQCAtMTczLDcgKzE3Myw3IEBACiAJfQogCiAJLyogRmluaXNoIG9mZiBhbnkgcmVtYWluaW5nIGJ5dGVzICovCi0JLyogc2ltcGxlIGZhc3QgY29weSwgLi4uIHVubGVzcyBhIGNhY2hlIGJvdW5kcnkgaXMgY3Jvc3NlZCAqLworCS8qIHNpbXBsZSBmYXN0IGNvcHksIC4uLiB1bmxlc3MgYSBjYWNoZSBib3VuZGFyeSBpcyBjcm9zc2VkICovCiAJc3dpdGNoIChjKSB7CiAJY2FzZSAzOgogCQkqZHN0KysgPSAqc3JjKys7CmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvbGliL21lbW1vdmUuYyBiL2FyY2gvbWljcm9ibGF6ZS9saWIvbWVtbW92ZS5jCmluZGV4IDgxMGZkNjguLjIxNDZjMzcgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9saWIvbWVtbW92ZS5jCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9saWIvbWVtbW92ZS5jCkBAIC04Myw4ICs4Myw4IEBACiAJaWYgKGMgPj0gNCkgewogCQl1bnNpZ25lZCAgdmFsdWUsIGJ1Zl9ob2xkOwogCi0JCS8qIEFsaWduIHRoZSBkZXN0aW5hdGlvbiB0byBhIHdvcmQgYm91bmRyeS4gKi8KLQkJLyogVGhpcyBpcyBkb25lIGluIGFuIGVuZGlhbiBpbmRlcGVuZGFudCBtYW5uZXIuICovCisJCS8qIEFsaWduIHRoZSBkZXN0aW5hdGlvbiB0byBhIHdvcmQgYm91bmRhcnkuICovCisJCS8qIFRoaXMgaXMgZG9uZSBpbiBhbiBlbmRpYW4gaW5kZXBlbmRlbnQgbWFubmVyLiAqLwogCiAJCXN3aXRjaCAoKHVuc2lnbmVkIGxvbmcpZHN0ICYgMykgewogCQljYXNlIDM6CkBAIC0xOTMsNyArMTkzLDcgQEAKIAkJZHN0ID0gKHZvaWQgKilpX2RzdDsKIAl9CiAKLQkvKiBzaW1wbGUgZmFzdCBjb3B5LCAuLi4gdW5sZXNzIGEgY2FjaGUgYm91bmRyeSBpcyBjcm9zc2VkICovCisJLyogc2ltcGxlIGZhc3QgY29weSwgLi4uIHVubGVzcyBhIGNhY2hlIGJvdW5kYXJ5IGlzIGNyb3NzZWQgKi8KIAkvKiBGaW5pc2ggb2ZmIGFueSByZW1haW5pbmcgYnl0ZXMgKi8KIAlzd2l0Y2ggKGMpIHsKIAljYXNlIDQ6CmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvbGliL21lbXNldC5jIGIvYXJjaC9taWNyb2JsYXplL2xpYi9tZW1zZXQuYwppbmRleCA4MzQ1NjVkLi5kZGY2NzkzIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvbGliL21lbXNldC5jCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9saWIvbWVtc2V0LmMKQEAgLTY0LDcgKzY0LDcgQEAKIAogCWlmIChsaWtlbHkobiA+PSA0KSkgewogCQkvKiBBbGlnbiB0aGUgZGVzdGluYXRpb24gdG8gYSB3b3JkIGJvdW5kYXJ5ICovCi0JCS8qIFRoaXMgaXMgZG9uZSBpbiBhbiBlbmRpYW4gaW5kZXBlbmRhbnQgbWFubmVyICovCisJCS8qIFRoaXMgaXMgZG9uZSBpbiBhbiBlbmRpYW4gaW5kZXBlbmRlbnQgbWFubmVyICovCiAJCXN3aXRjaCAoKHVuc2lnbmVkKSBzcmMgJiAzKSB7CiAJCWNhc2UgMToKIAkJCSpzcmMrKyA9IGM7CmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvcGNpL2luZGlyZWN0X3BjaS5jIGIvYXJjaC9taWNyb2JsYXplL3BjaS9pbmRpcmVjdF9wY2kuYwppbmRleCAyNWYxOGYwLi40MTk2ZWI2YiAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL3BjaS9pbmRpcmVjdF9wY2kuYworKysgYi9hcmNoL21pY3JvYmxhemUvcGNpL2luZGlyZWN0X3BjaS5jCkBAIC0xMDgsNyArMTA4LDcgQEAKIAkJb3V0X2xlMzIoaG9zZS0+Y2ZnX2FkZHIsICgweDgwMDAwMDAwIHwgKGJ1c19ubyA8PCAxNikgfAogCQkJIChkZXZmbiA8PCA4KSB8IHJlZyB8IGNmZ190eXBlKSk7CiAKLQkvKiBzdXJwcmVzcyBzZXR0aW5nIG9mIFBDSV9QUklNQVJZX0JVUyAqLworCS8qIHN1cHByZXNzIHNldHRpbmcgb2YgUENJX1BSSU1BUllfQlVTICovCiAJaWYgKGhvc2UtPmluZGlyZWN0X3R5cGUgJiBJTkRJUkVDVF9UWVBFX1NVUlBSRVNTX1BSSU1BUllfQlVTKQogCQlpZiAoKG9mZnNldCA9PSBQQ0lfUFJJTUFSWV9CVVMpICYmCiAJCQkoYnVzLT5udW1iZXIgPT0gaG9zZS0+Zmlyc3RfYnVzbm8pKQpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL3BsYXRmb3JtL2dlbmVyaWMvS2NvbmZpZy5hdXRvIGIvYXJjaC9taWNyb2JsYXplL3BsYXRmb3JtL2dlbmVyaWMvS2NvbmZpZy5hdXRvCmluZGV4IDVkODZmYzEuLjI1YTZmMDEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9wbGF0Zm9ybS9nZW5lcmljL0tjb25maWcuYXV0bworKysgYi9hcmNoL21pY3JvYmxhemUvcGxhdGZvcm0vZ2VuZXJpYy9LY29uZmlnLmF1dG8KQEAgLTI5LDcgKzI5LDcgQEAKIAkgIEJBU0UgQWRkcmVzcyBmb3Iga2VybmVsCiAKIGNvbmZpZyBYSUxJTlhfTUlDUk9CTEFaRTBfRkFNSUxZCi0Jc3RyaW5nICJUYXJnZXR0ZWQgRlBHQSBmYW1pbHkiCisJc3RyaW5nICJUYXJnZXRlZCBGUEdBIGZhbWlseSIKIAlkZWZhdWx0ICJ2aXJ0ZXg1IgogCiBjb25maWcgWElMSU5YX01JQ1JPQkxBWkUwX1VTRV9NU1JfSU5TVFIKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9LY29uZmlnIGIvYXJjaC9taXBzL0tjb25maWcKaW5kZXggODNhYTVmYi4uOGUyNTZjYyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL0tjb25maWcKKysrIGIvYXJjaC9taXBzL0tjb25maWcKQEAgLTExMzUsNyArMTEzNSw3IEBACiAJICBUaGUgTG9vbmdzb24gMkUgcHJvY2Vzc29yIGltcGxlbWVudHMgdGhlIE1JUFMgSUlJIGluc3RydWN0aW9uIHNldAogCSAgd2l0aCBtYW55IGV4dGVuc2lvbnMuCiAKLQkgIEl0IGhhcyBhbiBpbnRlcm5hbCBGUEdBIG5vcnRoYnJpZGdlLCB3aGljaCBpcyBjb21wYXRpYWJsZSB0bworCSAgSXQgaGFzIGFuIGludGVybmFsIEZQR0Egbm9ydGhicmlkZ2UsIHdoaWNoIGlzIGNvbXBhdGlibGUgdG8KIAkgIGJvbml0bzY0LgogCiBjb25maWcgQ1BVX0xPT05HU09OMkYKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9NYWtlZmlsZSBiL2FyY2gvbWlwcy9NYWtlZmlsZQppbmRleCBhYzFkNWI2Li41M2UzNTE0IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvTWFrZWZpbGUKKysrIGIvYXJjaC9taXBzL01ha2VmaWxlCkBAIC0xMDEsNyArMTAxLDcgQEAKICMgY2FyZWZ1bGx5IGF2b2lkIHRvIGFkZCBpdCByZWR1bmRhbnRseSBiZWNhdXNlIGdjYyAzLjMvMy40IGNvbXBsYWlucwogIyB3aGVuIGZlZCB0aGUgdG9vbGNoYWluIGRlZmF1bHQhCiAjCi0jIENlcnRhaW4gZ2NjIHZlcnNpb25zIHVwdG8gZ2NjIDQuMS4xIChwcm9iYWJseSA0LjItc3VidmVyc2lvbiBhcyBvZgorIyBDZXJ0YWluIGdjYyB2ZXJzaW9ucyB1cCB0byBnY2MgNC4xLjEgKHByb2JhYmx5IDQuMi1zdWJ2ZXJzaW9uIGFzIG9mCiAjIDIwMDYtMTAtMTAgZG9uJ3QgcHJvcGVybHkgY2hhbmdlIHRoZSBwcmVkZWZpbmVkIHN5bWJvbHMgaWYgLUVCIC8gLUVMCiAjIGFyZSB1c2VkLCBzbyB3ZSBrbHVkZ2UgdGhhdCBoZXJlLiAgQSBidWcgaGFzIGJlZW4gZmlsZWQgYXQKICMgaHR0cDovL2djYy5nbnUub3JnL2J1Z3ppbGxhL3Nob3dfYnVnLmNnaT9pZD0yOTQxMy4KQEAgLTMxNCw1ICszMTQsNSBAQAogCWVjaG8gJyAgdm1saW51ei5iaW4gICAgICAgICAgLSBSYXcgYmluYXJ5IHpib290IGltYWdlJwogCWVjaG8gJyAgdm1saW51ei5zcmVjICAgICAgICAgLSBTUkVDIHpib290IGltYWdlJwogCWVjaG8KLQllY2hvICcgIFRoZXNlIHdpbGwgYmUgZGVmYXVsdCBhcyBhcHJvcHJpYXRlIGZvciBhIGNvbmZpZ3VyZWQgcGxhdGZvcm0uJworCWVjaG8gJyAgVGhlc2Ugd2lsbCBiZSBkZWZhdWx0IGFzIGFwcHJvcHJpYXRlIGZvciBhIGNvbmZpZ3VyZWQgcGxhdGZvcm0uJwogZW5kZWYKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hbGNoZW15L2NvbW1vbi9jbG9ja3MuYyBiL2FyY2gvbWlwcy9hbGNoZW15L2NvbW1vbi9jbG9ja3MuYwppbmRleCBhZjBmZTQxLi5mMzgyOThhIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvYWxjaGVteS9jb21tb24vY2xvY2tzLmMKKysrIGIvYXJjaC9taXBzL2FsY2hlbXkvY29tbW9uL2Nsb2Nrcy5jCkBAIC03NSw3ICs3NSw3IEBACiAgKiBjb3VudGVyLCBpZiBpdCBleGlzdHMuICBJZiB3ZSBkb24ndCBoYXZlIGFuIGFjY3VyYXRlIHByb2Nlc3NvcgogICogc3BlZWQsIGFsbCBvZiB0aGUgcGVyaXBoZXJhbHMgdGhhdCBkZXJpdmUgdGhlaXIgY2xvY2tzIGJhc2VkIG9uCiAgKiB0aGlzIGFkdmVydGlzZWQgc3BlZWQgd2lsbCBpbnRyb2R1Y2UgZXJyb3IgYW5kIHNvbWV0aW1lcyBub3Qgd29yawotICogcHJvcGVybHkuICBUaGlzIGZ1bmN0aW9uIGlzIGZ1dGhlciBjb252b2x1dGVkIHRvIHN0aWxsIGFsbG93IGNvbmZpZ3VyYXRpb25zCisgKiBwcm9wZXJseS4gIFRoaXMgZnVuY3Rpb24gaXMgZnVydGhlciBjb252b2x1dGVkIHRvIHN0aWxsIGFsbG93IGNvbmZpZ3VyYXRpb25zCiAgKiB0byBkbyB0aGF0IGluIGNhc2UgdGhleSBoYXZlIHJlYWxseSwgcmVhbGx5IG9sZCBzaWxpY29uIHdpdGggYQogICogd3JpdGUtb25seSBQTEwgcmVnaXN0ZXIuCQkJLS0gRGFuCiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL2V4ZWN1dGl2ZS9vY3Rlb24tbW9kZWwuYyBiL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL2V4ZWN1dGl2ZS9vY3Rlb24tbW9kZWwuYwppbmRleCA5YWZjMzc5Li5jOGQzNTY4IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY2F2aXVtLW9jdGVvbi9leGVjdXRpdmUvb2N0ZW9uLW1vZGVsLmMKKysrIGIvYXJjaC9taXBzL2Nhdml1bS1vY3Rlb24vZXhlY3V0aXZlL29jdGVvbi1tb2RlbC5jCkBAIC03NSw3ICs3NSw3IEBACiAKIAludW1fY29yZXMgPSBjdm14X29jdGVvbl9udW1fY29yZXMoKTsKIAotCS8qIE1ha2Ugc3VyZSB0aGUgbm9uIGV4aXN0YW50IGRldmljZXMgbG9vayBkaXNhYmxlZCAqLworCS8qIE1ha2Ugc3VyZSB0aGUgbm9uIGV4aXN0ZW50IGRldmljZXMgbG9vayBkaXNhYmxlZCAqLwogCXN3aXRjaCAoKGNoaXBfaWQgPj4gOCkgJiAweGZmKSB7CiAJY2FzZSA2OgkJLyogQ041MFhYICovCiAJY2FzZSAyOgkJLyogQ04zMFhYICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY2F2aXVtLW9jdGVvbi9vY3Rlb24tcGxhdGZvcm0uYyBiL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL29jdGVvbi1wbGF0Zm9ybS5jCmluZGV4IGNlY2FmNjIuLmNkNjFkNzIgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL29jdGVvbi1wbGF0Zm9ybS5jCisrKyBiL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL29jdGVvbi1wbGF0Zm9ybS5jCkBAIC03NSw3ICs3NSw3IEBACiAJCSAqIHplcm8uCiAJCSAqLwogCi0JCS8qIEFzdW1lIHRoYXQgQ1MxIGltbWVkaWF0ZWx5IGZvbGxvd3MuICovCisJCS8qIEFzc3VtZSB0aGF0IENTMSBpbW1lZGlhdGVseSBmb2xsb3dzLiAqLwogCQltaW9fYm9vdF9yZWdfY2ZnLnU2NCA9CiAJCQljdm14X3JlYWRfY3NyKENWTVhfTUlPX0JPT1RfUkVHX0NGR1goaSArIDEpKTsKIAkJcmVnaW9uX2Jhc2UgPSBtaW9fYm9vdF9yZWdfY2ZnLnMuYmFzZSA8PCAxNjsKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL3NldHVwLmMgYi9hcmNoL21pcHMvY2F2aXVtLW9jdGVvbi9zZXR1cC5jCmluZGV4IDhiMTM5YmYuLjA3MDdmYWUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jYXZpdW0tb2N0ZW9uL3NldHVwLmMKKysrIGIvYXJjaC9taXBzL2Nhdml1bS1vY3Rlb24vc2V0dXAuYwpAQCAtNjYyLDcgKzY2Miw3IEBACiAJICogc29tZSBtZW1vcnkgdmVjdG9ycy4gV2hlbiBTUEFSU0VNRU0gaXMgaW4gdXNlLCBpdCBkb2Vzbid0CiAJICogdmVyaWZ5IHRoYXQgdGhlIHNpemUgaXMgYmlnIGVub3VnaCBmb3IgdGhlIGZpbmFsCiAJICogdmVjdG9ycy4gTWFraW5nIHRoZSBzbWFsbGVzdCBjaHVjayA0TUIgc2VlbXMgdG8gYmUgZW5vdWdoCi0JICogdG8gY29uc2lzdGFudGx5IHdvcmsuCisJICogdG8gY29uc2lzdGVudGx5IHdvcmsuCiAJICovCiAJbWVtX2FsbG9jX3NpemUgPSA0IDw8IDIwOwogCWlmIChtZW1fYWxsb2Nfc2l6ZSA+IE1BWF9NRU1PUlkpCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvZncvYXJjL3Byb21saWIuYyBiL2FyY2gvbWlwcy9mdy9hcmMvcHJvbWxpYi5jCmluZGV4IGM1MDhjMDAuLmI3ZjlkZDMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9mdy9hcmMvcHJvbWxpYi5jCisrKyBiL2FyY2gvbWlwcy9mdy9hcmMvcHJvbWxpYi5jCkBAIC00LDcgKzQsNyBAQAogICogZm9yIG1vcmUgZGV0YWlscy4KICAqCiAgKiBDb3B5cmlnaHQgKEMpIDE5OTYgRGF2aWQgUy4gTWlsbGVyIChkbUBzZ2kuY29tKQotICogQ29tcGFiaWxpdHkgd2l0aCBib2FyZCBjYWNoZXMsIFVsZiBDYXJsc3NvbgorICogQ29tcGF0aWJpbGl0eSB3aXRoIGJvYXJkIGNhY2hlcywgVWxmIENhcmxzc29uCiAgKi8KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxhc20vc2dpYWxpYi5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2RlYy9wcm9tLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vZGVjL3Byb20uaAppbmRleCBiOWM4MjAzLi5jMGVhZDYzIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vZGVjL3Byb20uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vZGVjL3Byb20uaApAQCAtMTA4LDcgKzEwOCw3IEBACiAKIC8qCiAgKiBPbiBNSVBTNjQgd2UgaGF2ZSB0byBjYWxsIFBST00gZnVuY3Rpb25zIHZpYSBhIGhlbHBlcgotICogZGlzcGF0Y2hlciB0byBhY2NvbW9kYXRlIEFCSSBpbmNvbXBhdGliaWxpdGllcy4KKyAqIGRpc3BhdGNoZXIgdG8gYWNjb21tb2RhdGUgQUJJIGluY29tcGF0aWJpbGl0aWVzLgogICovCiAjZGVmaW5lIF9fREVDX1BST01fTzMyKGZ1biwgYXJnKSBmdW4gYXJnIF9fYXNtX18oI2Z1bik7IFwKIAkJCQkgX19hc21fXygjZnVuICIgPSBjYWxsX28zMiIpCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vZmxvcHB5LmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vZmxvcHB5LmgKaW5kZXggOTkyZDIzMi4uYzVjN2MwZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2Zsb3BweS5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9mbG9wcHkuaApAQCAtMjQsNyArMjQsNyBAQAogICogQW5kIG9uIE1pcHMncyB0aGUgQ01PUyBpbmZvIGZhaWxzIGFsc28gLi4uCiAgKgogICogRklYTUU6IFRoaXMgaW5mb3JtYXRpb24gc2hvdWxkIGNvbWUgZnJvbSB0aGUgQVJDIGNvbmZpZ3VyYXRpb24gdHJlZQotICogICAgICAgIG9yIHdoZXJlZXZlciBhIHBhcnRpY3VsYXIgbWFjaGluZSBoYXMgc3RvcmVkIHRoaXMgLi4uCisgKiAgICAgICAgb3Igd2hlcmV2ZXIgYSBwYXJ0aWN1bGFyIG1hY2hpbmUgaGFzIHN0b3JlZCB0aGlzIC4uLgogICovCiAjZGVmaW5lIEZMT1BQWTBfVFlQRSAJCWZkX2RyaXZlX3R5cGUoMCkKICNkZWZpbmUgRkxPUFBZMV9UWVBFCQlmZF9kcml2ZV90eXBlKDEpCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vaHdfaXJxLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vaHdfaXJxLmgKaW5kZXggYWNhMDVhNC4uNzdhZGRhMiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2h3X2lycS5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9od19pcnEuaApAQCAtMTMsNyArMTMsNyBAQAogZXh0ZXJuIGF0b21pY190IGlycV9lcnJfY291bnQ7CiAKIC8qCi0gKiBpbnRlcnJ1cHQtcmV0cmlnZ2VyOiBOT1AgZm9yIG5vdy4gVGhpcyBtYXkgbm90IGJlIGFwcm9wcmlhdGUgZm9yIGFsbAorICogaW50ZXJydXB0LXJldHJpZ2dlcjogTk9QIGZvciBub3cuIFRoaXMgbWF5IG5vdCBiZSBhcHByb3ByaWF0ZSBmb3IgYWxsCiAgKiBtYWNoaW5lcywgd2UnbGwgc2VlIC4uLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9pby5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2lvLmgKaW5kZXggNWIwMTdmMi4uYjA0ZTRkZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2lvLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2lvLmgKQEAgLTI0Miw3ICsyNDIsNyBAQAogICogVGhpcyB2ZXJzaW9uIG9mIGlvcmVtYXAgZW5zdXJlcyB0aGF0IHRoZSBtZW1vcnkgaXMgbWFya2VkIHVuY2FjaGFibGUKICAqIG9uIHRoZSBDUFUgYXMgd2VsbCBhcyBob25vdXJpbmcgZXhpc3RpbmcgY2FjaGluZyBydWxlcyBmcm9tIHRoaW5ncyBsaWtlCiAgKiB0aGUgUENJIGJ1cy4gTm90ZSB0aGF0IHRoZXJlIGFyZSBvdGhlciBjYWNoZXMgYW5kIGJ1ZmZlcnMgb24gbWFueQotICogYnVzc2VzLiBJbiBwYXRpY3VsYXIgZHJpdmVyIGF1dGhvcnMgc2hvdWxkIHJlYWQgdXAgb24gUENJIHdyaXRlcworICogYnVzc2VzLiBJbiBwYXJ0aWN1bGFyIGRyaXZlciBhdXRob3JzIHNob3VsZCByZWFkIHVwIG9uIFBDSSB3cml0ZXMKICAqCiAgKiBJdCdzIHVzZWZ1bCBpZiBzb21lIGNvbnRyb2wgcmVnaXN0ZXJzIGFyZSBpbiBzdWNoIGFuIGFyZWEgYW5kCiAgKiB3cml0ZSBjb21iaW5pbmcgb3IgcmVhZCBjYWNoaW5nIGlzIG5vdCBkZXNpcmFibGU6CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vaXJxZmxhZ3MuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9pcnFmbGFncy5oCmluZGV4IDllZjNiMGQuLjMwOWNiY2QgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9pcnFmbGFncy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9pcnFmbGFncy5oCkBAIC0xNzQsNyArMTc0LDcgQEAKIAkibXRjMAlcXGZsYWdzLCAkMiwgMQkJCQkJCVxuIgogI2VsaWYgZGVmaW5lZChDT05GSUdfQ1BVX01JUFNSMikgJiYgZGVmaW5lZChDT05GSUdfSVJRX0NQVSkKIAkvKgotCSAqIFNsb3csIGJ1dCBkb2Vzbid0IHN1ZmZlciBmcm9tIGEgcmVsYXRpdmx5IHVubGlrZWx5IHJhY2UKKwkgKiBTbG93LCBidXQgZG9lc24ndCBzdWZmZXIgZnJvbSBhIHJlbGF0aXZlbHkgdW5saWtlbHkgcmFjZQogCSAqIGNvbmRpdGlvbiB3ZSdyZSBoYXZpbmcgc2luY2UgZGF5cyAxLgogCSAqLwogCSIJYmVxeglcXGZsYWdzLCAxZgkJCQkJXG4iCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1iY202M3h4L2JjbTk2M3h4X3RhZy5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYmNtNjN4eC9iY205NjN4eF90YWcuaAppbmRleCA1MzI1MDg0Li4zMjk3OGQzIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1iY202M3h4L2JjbTk2M3h4X3RhZy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWJjbTYzeHgvYmNtOTYzeHhfdGFnLmgKQEAgLTQsNyArNCw3IEBACiAjZGVmaW5lIFRBR1ZFUl9MRU4JCTQJLyogTGVuZ3RoIG9mIFRhZyBWZXJzaW9uICovCiAjZGVmaW5lIFRBR0xBWU9VVF9MRU4JCTQJLyogTGVuZ3RoIG9mIEZsYXNoTGF5b3V0VmVyICovCiAjZGVmaW5lIFNJRzFfTEVOCQkyMAkvKiBDb21wYW55IFNpZ25hdHVyZSAxIExlbmd0aCAqLwotI2RlZmluZSBTSUcyX0xFTgkJMTQJLyogQ29tcGFueSBTaWduYXR1cmUgMiBMZW5naHQgKi8KKyNkZWZpbmUgU0lHMl9MRU4JCTE0CS8qIENvbXBhbnkgU2lnbmF0dXJlIDIgTGVuZ3RoICovCiAjZGVmaW5lIEJPQVJESURfTEVOCQkxNgkvKiBMZW5ndGggb2YgQm9hcmRJZCAqLwogI2RlZmluZSBFTkRJQU5GTEFHX0xFTgkJMgkvKiBFbmRpYW4gRmxhZyBMZW5ndGggKi8KICNkZWZpbmUgQ0hJUElEX0xFTgkJNgkvKiBDaGlwIElkIExlbmd0aCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtaXAzMi9tYzE0NjgxOHJ0Yy5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtaXAzMi9tYzE0NjgxOHJ0Yy5oCmluZGV4IGMyOGJhOGQuLjZiNmJhYjQgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWlwMzIvbWMxNDY4MThydGMuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1pcDMyL21jMTQ2ODE4cnRjLmgKQEAgLTI2LDcgKzI2LDcgQEAKIH0KIAogLyoKLSAqIEZJWE1FOiBEbyBpdCByaWdodC4gRm9yIG5vdyBqdXN0IGFzc3VtZSB0aGF0IG5vb25lIGxpdmVzIGluIDIwdGggY2VudHVyeQorICogRklYTUU6IERvIGl0IHJpZ2h0LiBGb3Igbm93IGp1c3QgYXNzdW1lIHRoYXQgbm8gb25lIGxpdmVzIGluIDIwdGggY2VudHVyeQogICogYW5kIG5vIE8yIHVzZXIgaW4gMjJ0aCBjZW50dXJ5IDstKQogICovCiAjZGVmaW5lIG1jMTQ2ODE4X2RlY29kZV95ZWFyKHllYXIpICgoeWVhcikgKyAyMDAwKQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtbG9vbmdzb24vY3M1NTM2L2NzNTUzNi5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtbG9vbmdzb24vY3M1NTM2L2NzNTUzNi5oCmluZGV4IDAyMWY3N2MuLjJhOGUyYmIgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWxvb25nc29uL2NzNTUzNi9jczU1MzYuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1sb29uZ3Nvbi9jczU1MzYvY3M1NTM2LmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogVGhlIGhlYWRlciBmaWxlIG9mIGNzNTUzNiBzb3VydGggYnJpZGdlLgorICogVGhlIGhlYWRlciBmaWxlIG9mIGNzNTUzNiBzb3V0aCBicmlkZ2UuCiAgKgogICogQ29weXJpZ2h0IChDKSAyMDA3IExlbW90ZSwgSW5jLgogICogQXV0aG9yIDogamxsaXUgPGxpdWpsQGxlbW90ZS5jb20+CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1wYjF4MDAvcGIxMDAwLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1wYjF4MDAvcGIxMDAwLmgKaW5kZXggNmQxZmY5MC4uNjUwNTkyNSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcGIxeDAwL3BiMTAwMC5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLXBiMXgwMC9wYjEwMDAuaApAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBBbGNoZW15IFNlbWkgUGIxMDAwIFJlZmVycmVuY2UgQm9hcmQKKyAqIEFsY2hlbXkgU2VtaSBQYjEwMDAgUmVmZXJlbmNlIEJvYXJkCiAgKgogICogQ29weXJpZ2h0IDIwMDEsIDIwMDggTW9udGFWaXN0YSBTb2Z0d2FyZSBJbmMuCiAgKiBBdXRob3I6IE1vbnRhVmlzdGEgU29mdHdhcmUsIEluYy4gPHNvdXJjZUBtdmlzdGEuY29tPgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcGIxeDAwL3BiMTIwMC5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcGIxeDAwL3BiMTIwMC5oCmluZGV4IDk2MmViNTUuLmZjZTQzMzIgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLXBiMXgwMC9wYjEyMDAuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1wYjF4MDAvcGIxMjAwLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogQU1EIEFsY2hlbXkgUGIxMjAwIFJlZmVycmVuY2UgQm9hcmQKKyAqIEFNRCBBbGNoZW15IFBiMTIwMCBSZWZlcmVuY2UgQm9hcmQKICAqIEJvYXJkIFJlZ2lzdGVycyBkZWZpbmVzLgogICoKICAqICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcGIxeDAwL3BiMTU1MC5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcGIxeDAwL3BiMTU1MC5oCmluZGV4IGZjNGQ3NjYuLmY4MzVjODggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLXBiMXgwMC9wYjE1NTAuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1wYjF4MDAvcGIxNTUwLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogQU1EIEFsY2hlbXkgU2VtaSBQQjE1NTAgUmVmZXJyZW5jZSBCb2FyZAorICogQU1EIEFsY2hlbXkgU2VtaSBQQjE1NTAgUmVmZXJlbmNlIEJvYXJkCiAgKiBCb2FyZCBSZWdpc3RlcnMgZGVmaW5lcy4KICAqCiAgKiBDb3B5cmlnaHQgMjAwNCBFbWJlZGRlZCBFZGdlIExMQy4KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLXBvd2VydHYvZG1hLWNvaGVyZW5jZS5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcG93ZXJ0di9kbWEtY29oZXJlbmNlLmgKaW5kZXggZjc2MDI5Yy4uYThlNzJjZiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcG93ZXJ0di9kbWEtY29oZXJlbmNlLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtcG93ZXJ0di9kbWEtY29oZXJlbmNlLmgKQEAgLTQ4LDcgKzQ4LDcgQEAKIAkJCQkvKiBjaGVjayBmb3IgYSB2YWxpZCBwYWdlICovCiAJCQkJaWYgKHB0ZV9wcmVzZW50KHB0ZSkpIHsKIAkJCQkJLyogZ2V0IHRoZSBwaHlzaWNhbCBhZGRyZXNzIHRoZSBwYWdlIGlzCi0JCQkJCSAqIHJlZmVyaW5nIHRvICovCisJCQkJCSAqIHJlZmVycmluZyB0byAqLwogCQkJCQlwaHlzX2FkZHIgPSAodW5zaWduZWQgbG9uZykKIAkJCQkJCXBhZ2VfdG9fcGh5cyhwdGVfcGFnZShwdGUpKTsKIAkJCQkJLyogYWRkIHRoZSBvZmZzZXQgd2l0aGluIHRoZSBwYWdlICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWlwc3JlZ3MuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzcmVncy5oCmluZGV4IDRkOTg3MDkuLjZhNmY4YTggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzcmVncy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzcmVncy5oCkBAIC05MjIsNyArOTIyLDcgQEAKICNkZWZpbmUgd3JpdGVfYzBfY29uZmlnNyh2YWwpCV9fd3JpdGVfMzJiaXRfYzBfcmVnaXN0ZXIoJDE2LCA3LCB2YWwpCiAKIC8qCi0gKiBUaGUgV2F0Y2hMbyByZWdpc3Rlci4gIFRoZXJlIG1heSBiZSB1cHRvIDggb2YgdGhlbS4KKyAqIFRoZSBXYXRjaExvIHJlZ2lzdGVyLiAgVGhlcmUgbWF5IGJlIHVwIHRvIDggb2YgdGhlbS4KICAqLwogI2RlZmluZSByZWFkX2MwX3dhdGNobG8wKCkJX19yZWFkX3Vsb25nX2MwX3JlZ2lzdGVyKCQxOCwgMCkKICNkZWZpbmUgcmVhZF9jMF93YXRjaGxvMSgpCV9fcmVhZF91bG9uZ19jMF9yZWdpc3RlcigkMTgsIDEpCkBAIC05NDIsNyArOTQyLDcgQEAKICNkZWZpbmUgd3JpdGVfYzBfd2F0Y2hsbzcodmFsKQlfX3dyaXRlX3Vsb25nX2MwX3JlZ2lzdGVyKCQxOCwgNywgdmFsKQogCiAvKgotICogVGhlIFdhdGNoSGkgcmVnaXN0ZXIuICBUaGVyZSBtYXkgYmUgdXB0byA4IG9mIHRoZW0uCisgKiBUaGUgV2F0Y2hIaSByZWdpc3Rlci4gIFRoZXJlIG1heSBiZSB1cCB0byA4IG9mIHRoZW0uCiAgKi8KICNkZWZpbmUgcmVhZF9jMF93YXRjaGhpMCgpCV9fcmVhZF8zMmJpdF9jMF9yZWdpc3RlcigkMTksIDApCiAjZGVmaW5lIHJlYWRfYzBfd2F0Y2hoaTEoKQlfX3JlYWRfMzJiaXRfYzBfcmVnaXN0ZXIoJDE5LCAxKQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LWJvb3RpbmZvLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vb2N0ZW9uL2N2bXgtYm9vdGluZm8uaAppbmRleCBmM2MyM2E0Li40ZTRjM2E4IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vb2N0ZW9uL2N2bXgtYm9vdGluZm8uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vb2N0ZW9uL2N2bXgtYm9vdGluZm8uaApAQCAtMjAwLDcgKzIwMCw3IEBACiAJQ1ZNWF9DSElQX1RZUEVfTUFYLAogfTsKIAotLyogQ29tcGF0YWJpbGl0eSBhbGlhcyBmb3IgTkFDMzggbmFtZSBjaGFuZ2UsIHBsYW5uZWQgdG8gYmUgcmVtb3ZlZAorLyogQ29tcGF0aWJpbGl0eSBhbGlhcyBmb3IgTkFDMzggbmFtZSBjaGFuZ2UsIHBsYW5uZWQgdG8gYmUgcmVtb3ZlZAogICogZnJvbSBTREsgMS43ICovCiAjZGVmaW5lIENWTVhfQk9BUkRfVFlQRV9OQU8zOAlDVk1YX0JPQVJEX1RZUEVfTkFDMzgKIApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LWJvb3RtZW0uaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9vY3Rlb24vY3ZteC1ib290bWVtLmgKaW5kZXggOGU3MDhiZC4uODc3ODQ1YiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LWJvb3RtZW0uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vb2N0ZW9uL2N2bXgtYm9vdG1lbS5oCkBAIC02Nyw3ICs2Nyw3IEBACiAKIC8qCiAgKiBTdHJ1Y3R1cmUgZm9yIG5hbWVkIG1lbW9yeSBibG9ja3MuICBOdW1iZXIgb2YgZGVzY3JpcHRvcnMgYXZhaWxhYmxlCi0gKiBjYW4gYmUgY2hhbmdlZCB3aXRob3V0IGFmZmVjdGluZyBjb21wYXRpYmxpdHksIGJ1dCBuYW1lIGxlbmd0aAorICogY2FuIGJlIGNoYW5nZWQgd2l0aG91dCBhZmZlY3RpbmcgY29tcGF0aWJpbGl0eSwgYnV0IG5hbWUgbGVuZ3RoCiAgKiBjaGFuZ2VzIHJlcXVpcmUgYSBidW1wIGluIHRoZSBib290bWVtIGRlc2NyaXB0b3IgdmVyc2lvbiBOb3RlOiBUaGlzCiAgKiBzdHJ1Y3R1cmUgbXVzdCBiZSBuYXR1cmFsbHkgNjQgYml0IGFsaWduZWQsIGFzIGEgc2luZ2xlIG1lbW9yeQogICogaW1hZ2Ugd2lsbCBiZSB1c2VkIGJ5IGJvdGggMzIgYW5kIDY0IGJpdCBwcm9ncmFtcy4KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9vY3Rlb24vY3ZteC1sMmMuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9vY3Rlb24vY3ZteC1sMmMuaAppbmRleCAwYjMyYzViLi4yYzhmZjllIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vb2N0ZW9uL2N2bXgtbDJjLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LWwyYy5oCkBAIC0xNTcsNyArMTU3LDcgQEAKIAogLyoqCiAgKiBDb25maWd1cmUgb25lIG9mIHRoZSBmb3VyIEwyIENhY2hlIHBlcmZvcm1hbmNlIGNvdW50ZXJzIHRvIGNhcHR1cmUgZXZlbnQKLSAqIG9jY3VyZW5jZXMuCisgKiBvY2N1cnJlbmNlcy4KICAqCiAgKiBAY291bnRlcjogICAgICAgIFRoZSBjb3VudGVyIHRvIGNvbmZpZ3VyZS4gUmFuZ2UgMC4uMy4KICAqIEBldmVudDogICAgICAgICAgVGhlIHR5cGUgb2YgTDIgQ2FjaGUgZXZlbnQgb2NjdXJyZW5jZSB0byBjb3VudC4KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9vY3Rlb24vY3ZteC5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LmgKaW5kZXggOWQ5MzgxZS4uN2UxMjg2NyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL29jdGVvbi9jdm14LmgKQEAgLTE1MSw3ICsxNTEsNyBAQAogI2VuZGlmCiAKIC8qKgotICogQ29udmVydCBhIG1lbW9yeSBwb2ludGVyICh2b2lkKikgaW50byBhIGhhcmR3YXJlIGNvbXBhdGFibGUKKyAqIENvbnZlcnQgYSBtZW1vcnkgcG9pbnRlciAodm9pZCopIGludG8gYSBoYXJkd2FyZSBjb21wYXRpYmxlCiAgKiBtZW1vcnkgYWRkcmVzcyAodWludDY0X3QpLiBPY3Rlb24gaGFyZHdhcmUgd2lkZ2V0cyBkb24ndAogICogdW5kZXJzdGFuZCBsb2dpY2FsIGFkZHJlc3Nlcy4KICAqCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vcGFjY2Vzcy5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3BhY2Nlc3MuaAppbmRleCBjMjM5NGY4Li45Y2U1YTFlIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vcGFjY2Vzcy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9wYWNjZXNzLmgKQEAgLTcsNyArNyw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTksIDIwMDAgU2lsaWNvbiBHcmFwaGljcywgSW5jLgogICoKICAqIFByb3RlY3RlZCBtZW1vcnkgYWNjZXNzLiAgVXNlZCBmb3IgZXZlcnl0aGluZyB0aGF0IG1pZ2h0IHRha2UgcmV2ZW5nZQotICogYnkgc2VuZGluZyBhIERCRSBlcnJvciBsaWtlIGFjY2Vzc2luZyBwb3NzaWJseSBub24tZXhpc3RhbnQgbWVtb3J5IG9yCisgKiBieSBzZW5kaW5nIGEgREJFIGVycm9yIGxpa2UgYWNjZXNzaW5nIHBvc3NpYmx5IG5vbi1leGlzdGVudCBtZW1vcnkgb3IKICAqIGRldmljZXMuCiAgKi8KICNpZm5kZWYgX0FTTV9QQUNDRVNTX0gKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9wY2kvYnJpZGdlLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vcGNpL2JyaWRnZS5oCmluZGV4IGYxZjUwOGUuLmJlNDRmYjAgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9wY2kvYnJpZGdlLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3BjaS9icmlkZ2UuaApAQCAtMjYyLDcgKzI2Miw3IEBACiB9IGJyaWRnZV90OwogCiAvKgotICogRmllbGQgZm9ybWF0cyBmb3IgRXJyb3IgQ29tbWFuZCBXb3JkIGFuZCBBdXhpbGxhcnkgRXJyb3IgQ29tbWFuZCBXb3JkCisgKiBGaWVsZCBmb3JtYXRzIGZvciBFcnJvciBDb21tYW5kIFdvcmQgYW5kIEF1eGlsaWFyeSBFcnJvciBDb21tYW5kIFdvcmQKICAqIG9mIGJyaWRnZS4KICAqLwogdHlwZWRlZiBzdHJ1Y3QgYnJpZGdlX2Vycl9jbWR3b3JkX3MgewpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3BtYy1zaWVycmEvbXNwNzF4eC9tc3BfcmVnb3BzLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vcG1jLXNpZXJyYS9tc3A3MXh4L21zcF9yZWdvcHMuaAppbmRleCA2MGE1YTM4Li43ZDQxNDc0IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vcG1jLXNpZXJyYS9tc3A3MXh4L21zcF9yZWdvcHMuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vcG1jLXNpZXJyYS9tc3A3MXh4L21zcF9yZWdvcHMuaApAQCAtMjA1LDcgKzIwNSw3IEBACiAgKiAgIGN1c3RvbV9yZWFkX3JlZzMyKGFkZHJlc3MsIHRtcCk7CTwtLSBSZWFkcyB0aGUgYWRkcmVzcyBhbmQgcHV0IHRoZSB2YWx1ZQogICoJCQkJCQlpbiB0aGUgJ3RtcCcgdmFyaWFibGUgZ2l2ZW4KICAqCi0gKglGcm9tIGhlcmUgb24gb3V0LCB5b3UgYXJlIChiYXNpY2x5KSBhdG9taWMsIHNvIGRvbid0IGRvIGFueXRoaW5nIHRvbworICoJRnJvbSBoZXJlIG9uIG91dCwgeW91IGFyZSAoYmFzaWNhbGx5KSBhdG9taWMsIHNvIGRvbid0IGRvIGFueXRoaW5nIHRvbwogICoJZmFuY3khCiAgKglBbHNvLCB0aGlzIGNvZGUgbWF5IGxvb3AgaWYgdGhlIGVuZCBvZiB0aGlzIGJsb2NrIGZhaWxzIHRvIHdyaXRlCiAgKglldmVyeXRoaW5nIGJhY2sgc2FmZWx5IGR1ZSBkbyB0aGUgb3RoZXIgQ1BVLCBzbyBkbyBOT1QgZG8gYW55dGhpbmcKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaAppbmRleCBlYWQ2OTI4Li5jMTA0ZjEwIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3Byb2Nlc3Nvci5oCkBAIC0zMzcsNyArMzM3LDcgQEAKIC8qCiAgKiBSZXR1cm5fYWRkcmVzcyBpcyBhIHJlcGxhY2VtZW50IGZvciBfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoY291bnQpCiAgKiB3aGljaCBvbiBjZXJ0YWluIGFyY2hpdGVjdHVyZXMgY2Fubm90IHJlYXNvbmFibHkgYmUgaW1wbGVtZW50ZWQgaW4gR0NDCi0gKiAoTUlQUywgQWxwaGEpIG9yIGlzIHVudXNlYWJsZSB3aXRoIC1mb21pdC1mcmFtZS1wb2ludGVyIChpMzg2KS4KKyAqIChNSVBTLCBBbHBoYSkgb3IgaXMgdW51c2FibGUgd2l0aCAtZm9taXQtZnJhbWUtcG9pbnRlciAoaTM4NikuCiAgKiBOb3RlIHRoYXQgX19idWlsdGluX3JldHVybl9hZGRyZXNzKHg+PTEpIGlzIGZvcmJpZGRlbiBiZWNhdXNlIEdDQwogICogYWJvcnRzIGNvbXBpbGF0aW9uIG9uIHNvbWUgQ1BVcy4gIEl0J3Mgc2ltcGx5IG5vdCBwb3NzaWJsZSB0byB1bndpbmQKICAqIHNvbWUgQ1BVJ3Mgc3RhY2tmcmFtZXMuCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc2dpL2lvYy5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NnaS9pb2MuaAppbmRleCA1N2E5NzE5Li4zODAzNDdiIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc2dpL2lvYy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9zZ2kvaW9jLmgKQEAgLTE3LDcgKzE3LDcgQEAKICNpbmNsdWRlIDxhc20vc2dpL3BpMS5oPgogCiAvKgotICogQWxsIHJlZ2lzdGVycyBhcmUgOC1iaXQgd2lkZSBhbGxpZ25lZCBvbiAzMi1iaXQgYm91bmRhcnkuIEJhZCB0aGluZ3MKKyAqIEFsbCByZWdpc3RlcnMgYXJlIDgtYml0IHdpZGUgYWxpZ25lZCBvbiAzMi1iaXQgYm91bmRhcnkuIEJhZCB0aGluZ3MKICAqIGhhcHBlbiBpZiB5b3UgdHJ5IHdvcmQgYWNjZXNzIHRoZW0uIFlvdSBoYXZlIGJlZW4gd2FybmVkLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9zaWJ5dGUvc2IxMjUwX21hYy5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NpYnl0ZS9zYjEyNTBfbWFjLmgKaW5kZXggNTkxYjkwNi4uNzdmNzg3MiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NpYnl0ZS9zYjEyNTBfbWFjLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NpYnl0ZS9zYjEyNTBfbWFjLmgKQEAgLTUyMCw3ICs1MjAsNyBAQAogI2RlZmluZSBHX01BQ19SWF9FT1BfQ09VTlRFUih4KSAgICAgX1NCX0dFVFZBTFVFKHgsIFNfTUFDX1JYX0VPUF9DT1VOVEVSLCBNX01BQ19SWF9FT1BfQ09VTlRFUikKIAogLyoKLSAqIE1BQyBSZWNpZXZlIEFkZHJlc3MgRmlsdGVyIEV4YWN0IE1hdGNoIFJlZ2lzdGVycyAoVGFibGUgOS0yMSkKKyAqIE1BQyBSZWNlaXZlIEFkZHJlc3MgRmlsdGVyIEV4YWN0IE1hdGNoIFJlZ2lzdGVycyAoVGFibGUgOS0yMSkKICAqIFJlZ2lzdGVyczogTUFDX0FERFIwXzAgdGhyb3VnaCBNQUNfQUREUjdfMAogICogUmVnaXN0ZXJzOiBNQUNfQUREUjBfMSB0aHJvdWdoIE1BQ19BRERSN18xCiAgKiBSZWdpc3RlcnM6IE1BQ19BRERSMF8yIHRocm91Z2ggTUFDX0FERFI3XzIKQEAgLTUzOCw3ICs1MzgsNyBAQAogLyogTm8gYml0ZmllbGRzICovCiAKIC8qCi0gKiBNQUMgUmVjaWV2ZSBBZGRyZXNzIEZpbHRlciBIYXNoIE1hdGNoIFJlZ2lzdGVycyAoVGFibGUgOS0yMikKKyAqIE1BQyBSZWNlaXZlIEFkZHJlc3MgRmlsdGVyIEhhc2ggTWF0Y2ggUmVnaXN0ZXJzIChUYWJsZSA5LTIyKQogICogUmVnaXN0ZXJzOiBNQUNfSEFTSDBfMCB0aHJvdWdoIE1BQ19IQVNIN18wCiAgKiBSZWdpc3RlcnM6IE1BQ19IQVNIMF8xIHRocm91Z2ggTUFDX0hBU0g3XzEKICAqIFJlZ2lzdGVyczogTUFDX0hBU0gwXzIgdGhyb3VnaCBNQUNfSEFTSDdfMgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NpZ2luZm8uaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9zaWdpbmZvLmgKaW5kZXggMWNhNjRiNC4uMjBlYmViOCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NpZ2luZm8uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vc2lnaW5mby5oCkBAIC0xMDEsNyArMTAxLDcgQEAKIAogLyoKICAqIHNpX2NvZGUgdmFsdWVzCi0gKiBBZ2FpbiB0aGVzZSBoYXZlIGJlZW4gY2hvb3NlbiB0byBiZSBJUklYIGNvbXBhdGlibGUuCisgKiBBZ2FpbiB0aGVzZSBoYXZlIGJlZW4gY2hvc2VuIHRvIGJlIElSSVggY29tcGF0aWJsZS4KICAqLwogI3VuZGVmIFNJX0FTWU5DSU8KICN1bmRlZiBTSV9USU1FUgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NuL2tsY29uZmlnLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vc24va2xjb25maWcuaAppbmRleCAwOWU1OTBkLi5mZTAyOTAwIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc24va2xjb25maWcuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vc24va2xjb25maWcuaApAQCAtNzgsNyArNzgsNyBAQAogICovCiAjZGVmaW5lIE1BWF9TTE9UU19QRVJfTk9ERQkoMSArIDIgKyA2ICsgMikKIAotLyogWFhYIGlmIGVhY2ggbm9kZSBpcyBndXJhbnRlZWQgdG8gaGF2ZSBzb21lIG1lbW9yeSAqLworLyogWFhYIGlmIGVhY2ggbm9kZSBpcyBndWFyYW50ZWVkIHRvIGhhdmUgc29tZSBtZW1vcnkgKi8KIAogI2RlZmluZSBNQVhfUENJX0RFVlMJCTgKIApAQCAtNTM5LDcgKzUzOSw3IEBACiAjZGVmaW5lIEtMU1RSVUNUX0lPQzNfVFRZIAkyNAogCiAvKiBFYXJseSBBY2Nlc3MgSU8gcHJvbXMgYXJlIGNvbXBhdGlibGUKLSAgIG9ubHkgd2l0aCBLTFNUUlVDVCB2YWx1ZXMgdXB0byAyNC4gKi8KKyAgIG9ubHkgd2l0aCBLTFNUUlVDVCB2YWx1ZXMgdXAgdG8gMjQuICovCiAKICNkZWZpbmUgS0xTVFJVQ1RfRklCRVJDSEFOTkVMIAkyNQogI2RlZmluZSBLTFNUUlVDVF9NT0RfU0VSSUFMX05VTSAyNgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NuL3NuMC9odWJpby5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3NuL3NuMC9odWJpby5oCmluZGV4IDMxYzc2YzAuLjQ2Mjg2ZDggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9zbi9zbjAvaHViaW8uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vc24vc24wL2h1YmlvLmgKQEAgLTYyMiw3ICs2MjIsNyBAQAogICovCiAjZGVmaW5lCUlJT19JQ1JCX1BST0MwCQkwCS8qIFNvdXJjZSBvZiByZXF1ZXN0IGlzIFByb2MgMCAqLwogI2RlZmluZQlJSU9fSUNSQl9QUk9DMQkJMQkvKiBTb3VyY2Ugb2YgcmVxdWVzdCBpcyBQcm9jIDEgKi8KLSNkZWZpbmUJSUlPX0lDUkJfR0JfUkVRCQkyCS8qIFNvdXJjZSBpcyBHdXJhbnRlZWQgQlcgcmVxdWVzdCAqLworI2RlZmluZQlJSU9fSUNSQl9HQl9SRVEJCTIJLyogU291cmNlIGlzIEd1YXJhbnRlZWQgQlcgcmVxdWVzdCAqLwogI2RlZmluZQlJSU9fSUNSQl9JT19SRVEJCTMJLyogU291cmNlIGlzIE5vcm1hbCBJTyByZXF1ZXN0CSovCiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc3RhY2tmcmFtZS5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3N0YWNrZnJhbWUuaAppbmRleCA1ODczMGM1Li5iNGJhMjQ0IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc3RhY2tmcmFtZS5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9zdGFja2ZyYW1lLmgKQEAgLTM0Niw3ICszNDYsNyBAQAogCQkgKiB3ZSBjYW4ndCBkaXNwYXRjaCBpdCBkaXJlY3RseSB3aXRob3V0IHRyYXNoaW5nCiAJCSAqIHNvbWUgcmVnaXN0ZXJzLCBzbyB3ZSdsbCB0cnkgdG8gZGV0ZWN0IHRoaXMgdW5saWtlbHkKIAkJICogY2FzZSBhbmQgcHJvZ3JhbSBhIHNvZnR3YXJlIGludGVycnVwdCBpbiB0aGUgVlBFLAotCQkgKiBhcyB3b3VsZCBiZSBkb25lIGZvciBhIGNyb3NzLVZQRSBJUEkuICBUbyBhY2NvbW9kYXRlCisJCSAqIGFzIHdvdWxkIGJlIGRvbmUgZm9yIGEgY3Jvc3MtVlBFIElQSS4gIFRvIGFjY29tbW9kYXRlCiAJCSAqIHRoZSBoYW5kbGluZyBvZiB0aGF0IGNhc2UsIHdlJ3JlIGRvaW5nIGEgRFZQRSBpbnN0ZWFkCiAJCSAqIG9mIGp1c3QgYSBETVQgaGVyZSB0byBwcm90ZWN0IGFnYWluc3Qgb3RoZXIgdGhyZWFkcy4KIAkJICogVGhpcyBpcyBhIGxvdCBvZiBjcnVmdCB0byBjb3ZlciBhIHRpbnkgd2luZG93LgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3dhci5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3dhci5oCmluZGV4IDIyMzYxZDUuLmZhMTMzYzEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS93YXIuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vd2FyLmgKQEAgLTIyNyw3ICsyMjcsNyBAQAogI2VuZGlmCiAKIC8qCi0gKiBPbiB0aGUgUjEwMDAwIHVwdG8gdmVyc2lvbiAyLjYgKG5vdCBzdXJlIGFib3V0IDIuNykgdGhlcmUgaXMgYSBidWcgdGhhdAorICogT24gdGhlIFIxMDAwMCB1cCB0byB2ZXJzaW9uIDIuNiAobm90IHN1cmUgYWJvdXQgMi43KSB0aGVyZSBpcyBhIGJ1ZyB0aGF0CiAgKiBtYXkgY2F1c2UgbGwgLyBzYyBhbmQgbGxkIC8gc2NkIHNlcXVlbmNlcyB0byBleGVjdXRlIG5vbi1hdG9taWNhbGx5LgogICovCiAjaWZuZGVmIFIxMDAwMF9MTFNDX1dBUgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2p6NDc0MC9ib2FyZC1xaV9sYjYwLmMgYi9hcmNoL21pcHMvano0NzQwL2JvYXJkLXFpX2xiNjAuYwppbmRleCBiYzE4ZGFhLi5jM2IwNGJlIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvano0NzQwL2JvYXJkLXFpX2xiNjAuYworKysgYi9hcmNoL21pcHMvano0NzQwL2JvYXJkLXFpX2xiNjAuYwpAQCAtNjUsNyArNjUsNyBAQAogfTsKIAogLyogRWFybHkgcHJvdG90eXBlcyBvZiB0aGUgUUkgTEI2MCBoYWQgb25seSAxR0Igb2YgTkFORC4KLSAqIEluIG9yZGVyIHRvIHN1cHBvcnQgdGhlc2UgZGV2aWNlcyBhc3dlbGwgdGhlIHBhcnRpdGlvbiBhbmQgZWNjIGxheW91dCBpcworICogSW4gb3JkZXIgdG8gc3VwcG9ydCB0aGVzZSBkZXZpY2VzIGFzIHdlbGwgdGhlIHBhcnRpdGlvbiBhbmQgZWNjIGxheW91dCBpcwogICogaW5pdGlhbGl6ZWQgZGVwZW5kaW5nIG9uIHRoZSBOQU5EIHNpemUgKi8KIHN0YXRpYyBzdHJ1Y3QgbXRkX3BhcnRpdGlvbiBxaV9sYjYwX3BhcnRpdGlvbnNfMWdiW10gPSB7CiAJewpAQCAtNDM5LDcgKzQzOSw3IEBACiBzdGF0aWMgdm9pZCBfX2luaXQgYm9hcmRfZ3Bpb19zZXR1cCh2b2lkKQogewogCS8qIFdlIG9ubHkgbmVlZCB0byBlbmFibGUvZGlzYWJsZSBwdWxsdXAgaGVyZSBmb3IgcGlucyB1c2VkIGluIGdlbmVyaWMKLQkgKiBkcml2ZXJzLiBFdmVyeXRoaW5nIGVsc2UgaXMgZG9uZSBieSB0aGUgZHJpdmVycyB0aGVtc2VsZnMuICovCisJICogZHJpdmVycy4gRXZlcnl0aGluZyBlbHNlIGlzIGRvbmUgYnkgdGhlIGRyaXZlcnMgdGhlbXNlbHZlcy4gKi8KIAlqel9ncGlvX2Rpc2FibGVfcHVsbHVwKFFJX0xCNjBfR1BJT19TRF9WQ0NfRU5fTik7CiAJanpfZ3Bpb19kaXNhYmxlX3B1bGx1cChRSV9MQjYwX0dQSU9fU0RfQ0QpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC9jcHUtYnVnczY0LmMgYi9hcmNoL21pcHMva2VybmVsL2NwdS1idWdzNjQuYwppbmRleCBiOGJiOGJhLi5mMzA1Y2ExIDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL2NwdS1idWdzNjQuYworKysgYi9hcmNoL21pcHMva2VybmVsL2NwdS1idWdzNjQuYwpAQCAtNzMsNyArNzMsNyBAQAogCQk6ICIwIiAoNSksICIxIiAoOCksICIyIiAoNSkpOwogCWFsaWduX21vZChhbGlnbiwgbW9kKTsKIAkvKgotCSAqIFRoZSB0cmFpbGluZyBub3AgaXMgbmVlZGVkIHRvIGZ1bGxmaWxsIHRoZSB0d28taW5zdHJ1Y3Rpb24KKwkgKiBUaGUgdHJhaWxpbmcgbm9wIGlzIG5lZWRlZCB0byBmdWxmaWxsIHRoZSB0d28taW5zdHJ1Y3Rpb24KIAkgKiByZXF1aXJlbWVudCBiZXR3ZWVuIHJlYWRpbmcgaGkvbG8gYW5kIHN0YXJpbmcgYSBtdWx0L2Rpdi4KIAkgKiBMZWF2aW5nIGl0IG91dCBtYXkgY2F1c2UgZ2FzIGluc2VydCBhIG5vcCBpdHNlbGYgYnJlYWtpbmcKIAkgKiB0aGUgZGVzaXJlZCBhbGlnbm1lbnQgb2YgdGhlIG5leHQgY2h1bmsuCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3BlcmZfZXZlbnRfbWlwc3h4LmMgYi9hcmNoL21pcHMva2VybmVsL3BlcmZfZXZlbnRfbWlwc3h4LmMKaW5kZXggZDlhN2RiNy4uNzUyNjZmZiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2tlcm5lbC9wZXJmX2V2ZW50X21pcHN4eC5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvcGVyZl9ldmVudF9taXBzeHguYwpAQCAtNzIxLDcgKzcyMSw3IEBACiAKIC8qCiAgKiBNSVBTIHBlcmZvcm1hbmNlIGNvdW50ZXJzIGNhbiBiZSBwZXItVEMuIFRoZSBjb250cm9sIHJlZ2lzdGVycyBjYW4KLSAqIG5vdCBiZSBkaXJlY3RseSBhY2Nlc3NlZCBhY2Nyb3NzIENQVXMuIEhlbmNlIGlmIHdlIHdhbnQgdG8gZG8gZ2xvYmFsCisgKiBub3QgYmUgZGlyZWN0bHkgYWNjZXNzZWQgYWNyb3NzIENQVXMuIEhlbmNlIGlmIHdlIHdhbnQgdG8gZG8gZ2xvYmFsCiAgKiBjb250cm9sLCB3ZSBuZWVkIGNyb3NzIENQVSBjYWxscy4gb25fZWFjaF9jcHUoKSBjYW4gaGVscCB1cywgYnV0IHdlCiAgKiBjYW4gbm90IG1ha2Ugc3VyZSB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3aXRoIGludGVycnVwdHMgZW5hYmxlZC4gU28KICAqIGhlcmUgd2UgcGF1c2UgbG9jYWwgY291bnRlcnMgYW5kIHRoZW4gZ3JhYiBhIHJ3bG9jayBhbmQgbGVhdmUgdGhlCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3Byb2Nlc3MuYyBiL2FyY2gvbWlwcy9rZXJuZWwvcHJvY2Vzcy5jCmluZGV4IGFlMTY3ZGYuLmQyMTEyZDMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvcHJvY2Vzcy5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvcHJvY2Vzcy5jCkBAIC00MTAsNyArNDEwLDcgQEAKIAlpZiAoIWthbGxzeW1zX2xvb2t1cF9zaXplX29mZnNldChwYywgJnNpemUsICZvZnMpKQogCQlyZXR1cm4gMDsKIAkvKgotCSAqIFJldHVybiByYSBpZiBhbiBleGNlcHRpb24gb2NjdXJlZCBhdCB0aGUgZmlyc3QgaW5zdHJ1Y3Rpb24KKwkgKiBSZXR1cm4gcmEgaWYgYW4gZXhjZXB0aW9uIG9jY3VycmVkIGF0IHRoZSBmaXJzdCBpbnN0cnVjdGlvbgogCSAqLwogCWlmICh1bmxpa2VseShvZnMgPT0gMCkpIHsKIAkJcGMgPSAqcmE7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3NtcC1tdC5jIGIvYXJjaC9taXBzL2tlcm5lbC9zbXAtbXQuYwppbmRleCBjMGU4MTQxLi4xZWM1NmU2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3NtcC1tdC5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvc21wLW10LmMKQEAgLTEyMCw3ICsxMjAsNyBAQAogCiAJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogCi0JdnBmbGFncyA9IGR2cGUoKTsJLyogY2FudCBhY2Nlc3MgdGhlIG90aGVyIENQVSdzIHJlZ2lzdGVycyB3aGlsc3QgTVZQRSBlbmFibGVkICovCisJdnBmbGFncyA9IGR2cGUoKTsJLyogY2FuJ3QgYWNjZXNzIHRoZSBvdGhlciBDUFUncyByZWdpc3RlcnMgd2hpbHN0IE1WUEUgZW5hYmxlZCAqLwogCiAJc3dpdGNoIChhY3Rpb24pIHsKIAljYXNlIFNNUF9DQUxMX0ZVTkNUSU9OOgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC90aW1lLmMgYi9hcmNoL21pcHMva2VybmVsL3RpbWUuYwppbmRleCBmYjc0OTc0Li4xMDgzYWQ0IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3RpbWUuYworKysgYi9hcmNoL21pcHMva2VybmVsL3RpbWUuYwpAQCAtMTAyLDcgKzEwMiw3IEBACiAJY2FzZSBDUFVfUjQ0MDBTQzoKIAljYXNlIENQVV9SNDQwME1DOgogCQkvKgotCQkgKiBUaGUgcHVibGlzaGVkIGVycmF0YSBmb3IgdGhlIFI0NDAwIHVwdG8gMy4wIHNheSB0aGUgQ1BVCisJCSAqIFRoZSBwdWJsaXNoZWQgZXJyYXRhIGZvciB0aGUgUjQ0MDAgdXAgdG8gMy4wIHNheSB0aGUgQ1BVCiAJCSAqIGhhcyB0aGUgbWZjMCBmcm9tIGNvdW50IGJ1Zy4KIAkJICovCiAJCWlmICgoY3VycmVudF9jcHVfZGF0YS5wcm9jZXNzb3JfaWQgJiAweGZmKSA8PSAweDMwKQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC92cGUuYyBiL2FyY2gvbWlwcy9rZXJuZWwvdnBlLmMKaW5kZXggYWI1MmI3Yy4uZGJiNmI0MCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2tlcm5lbC92cGUuYworKysgYi9hcmNoL21pcHMva2VybmVsL3ZwZS5jCkBAIC0xOSw3ICsxOSw3IEBACiAgKiBWUEUgc3VwcG9ydCBtb2R1bGUKICAqCiAgKiBQcm92aWRlcyBzdXBwb3J0IGZvciBsb2FkaW5nIGEgTUlQUyBTUCBwcm9ncmFtIG9uIFZQRTEuCi0gKiBUaGUgU1AgZW52aXJvbWVudCBpcyByYXRoZXIgc2ltcGxlLCBubyB0bGIncy4gIEl0IG5lZWRzIHRvIGJlIHJlbG9jYXRhYmxlCisgKiBUaGUgU1AgZW52aXJvbm1lbnQgaXMgcmF0aGVyIHNpbXBsZSwgbm8gdGxiJ3MuICBJdCBuZWVkcyB0byBiZSByZWxvY2F0YWJsZQogICogKG9yIHBhcnRpYWxseSBsaW5rZWQpLiBZb3Ugc2hvdWxkIGluaXRpYWxpc2UgeW91ciBzdGFjayBpbiB0aGUgc3RhcnR1cAogICogY29kZS4gVGhpcyBsb2FkZXIgbG9va3MgZm9yIHRoZSBzeW1ib2wgX19zdGFydCBhbmQgc2V0cyB1cAogICogZXhlY3V0aW9uIHRvIHJlc3VtZSBmcm9tIHRoZXJlLiBUaGUgTUlQUyBTREUga2l0IGNvbnRhaW5zIHN1aXRhYmxlIGV4YW1wbGVzLgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2xpYi9zdHJubGVuX3VzZXIuUyBiL2FyY2gvbWlwcy9saWIvc3Rybmxlbl91c2VyLlMKaW5kZXggYzc2OGUzMDAuLjY0NDU3MTYgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9saWIvc3Rybmxlbl91c2VyLlMKKysrIGIvYXJjaC9taXBzL2xpYi9zdHJubGVuX3VzZXIuUwpAQCAtMTcsNyArMTcsNyBAQAogCS5wcmV2aW91cwogCiAvKgotICogUmV0dXJuIHRoZSBzaXplIG9mIGEgc3RyaW5nIGluY2x1ZGluZyB0aGUgZW5kaW5nIE5VTCBjaGFyYWN0ZXIgdXB0byBhCisgKiBSZXR1cm4gdGhlIHNpemUgb2YgYSBzdHJpbmcgaW5jbHVkaW5nIHRoZSBlbmRpbmcgTlVMIGNoYXJhY3RlciB1cCB0byBhCiAgKiBtYXhpbXVtIG9mIGExIG9yIDAgaW4gY2FzZSBvZiBlcnJvci4KICAqCiAgKiBOb3RlOiBmb3IgcGVyZm9ybWFuY2UgcmVhc29ucyB3ZSBkZWxpYmVyYXRlbHkgYWNjZXB0IHRoYXQgYSB1c2VyIG1heQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21hdGgtZW11L2RwX2ZzcC5jIGIvYXJjaC9taXBzL21hdGgtZW11L2RwX2ZzcC5jCmluZGV4IDFkZmJkOTIuLmRhZWQ2ODMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9tYXRoLWVtdS9kcF9mc3AuYworKysgYi9hcmNoL21pcHMvbWF0aC1lbXUvZHBfZnNwLmMKQEAgLTYyLDcgKzYyLDcgQEAKIAkJYnJlYWs7CiAJfQogCi0JLyogQ0FOVCBwb3NzaWJseSBvdmVyZmxvdyx1bmRlcmZsb3csIG9yIG5lZWQgcm91bmRpbmcKKwkvKiBDQU4nVCBwb3NzaWJseSBvdmVyZmxvdyx1bmRlcmZsb3csIG9yIG5lZWQgcm91bmRpbmcKIAkgKi8KIAogCS8qIGRyb3AgdGhlIGhpZGRlbiBiaXQgKi8KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9tYXRoLWVtdS9kcF9tdWwuYyBiL2FyY2gvbWlwcy9tYXRoLWVtdS9kcF9tdWwuYwppbmRleCBhYTU2NmU3Li4wOTE3NWY0IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvbWF0aC1lbXUvZHBfbXVsLmMKKysrIGIvYXJjaC9taXBzL21hdGgtZW11L2RwX211bC5jCkBAIC0xMDQsNyArMTA0LDcgQEAKIAljYXNlIENMUEFJUihJRUVFNzU0X0NMQVNTX05PUk0sIElFRUU3NTRfQ0xBU1NfTk9STSk6CiAJCWJyZWFrOwogCX0KLQkvKiBybSA9IHhtICogeW0sIHJlID0geGUreWUgYmFzaWNseSAqLworCS8qIHJtID0geG0gKiB5bSwgcmUgPSB4ZSt5ZSBiYXNpY2FsbHkgKi8KIAlhc3NlcnQoeG0gJiBEUF9ISURERU5fQklUKTsKIAlhc3NlcnQoeW0gJiBEUF9ISURERU5fQklUKTsKIAl7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbWF0aC1lbXUvZHNlbXVsLmMgYi9hcmNoL21pcHMvbWF0aC1lbXUvZHNlbXVsLmMKaW5kZXggMzZkOTc1YS4uM2M0YThjNSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL21hdGgtZW11L2RzZW11bC5jCisrKyBiL2FyY2gvbWlwcy9tYXRoLWVtdS9kc2VtdWwuYwpAQCAtMzIsNyArMzIsNyBAQAogICogbm90IGNoYW5nZSBjcDBfZXBjIGR1ZSB0byB0aGUgaW5zdHJ1Y3Rpb24KICAqCiAgKiBBY2NvcmRpbmcgdG8gdGhlIHNwZWM6Ci0gKiAxKSBpdCBzaG91bGRudCBiZSBhIGJyYW5jaCA6LSkKKyAqIDEpIGl0IHNob3VsZG4ndCBiZSBhIGJyYW5jaCA6LSkKICAqIDIpIGl0IGNhbiBiZSBhIENPUCBpbnN0cnVjdGlvbiA6LSgKICAqIDMpIGlmIHdlIGFyZSB0cmluZyB0byBydW4gYSBwcm90ZWN0ZWQgbWVtb3J5IHNwYWNlIHdlIG11c3QgdGFrZQogICogICAgc3BlY2lhbCBjYXJlIG9uIG1lbW9yeSBhY2Nlc3MgaW5zdHJ1Y3Rpb25zIDotKApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21hdGgtZW11L3NwX211bC5jIGIvYXJjaC9taXBzL21hdGgtZW11L3NwX211bC5jCmluZGV4IGMwNmJiNDAyLi4yNzIyYTI1IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvbWF0aC1lbXUvc3BfbXVsLmMKKysrIGIvYXJjaC9taXBzL21hdGgtZW11L3NwX211bC5jCkBAIC0xMDQsNyArMTA0LDcgQEAKIAljYXNlIENMUEFJUihJRUVFNzU0X0NMQVNTX05PUk0sIElFRUU3NTRfQ0xBU1NfTk9STSk6CiAJCWJyZWFrOwogCX0KLQkvKiBybSA9IHhtICogeW0sIHJlID0geGUreWUgYmFzaWNseSAqLworCS8qIHJtID0geG0gKiB5bSwgcmUgPSB4ZSt5ZSBiYXNpY2FsbHkgKi8KIAlhc3NlcnQoeG0gJiBTUF9ISURERU5fQklUKTsKIAlhc3NlcnQoeW0gJiBTUF9ISURERU5fQklUKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21tL2NleC1zYjEuUyBiL2FyY2gvbWlwcy9tbS9jZXgtc2IxLlMKaW5kZXggMmQwODI2OC4uODljNDEyYiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL21tL2NleC1zYjEuUworKysgYi9hcmNoL21pcHMvbW0vY2V4LXNiMS5TCkBAIC03OSw3ICs3OSw3IEBACiByZWNvdmVyZWRfZGNhY2hlOgogCS8qCiAJICogVW5sb2NrIENhY2hlRXJyLUQgKHdoaWNoIGluIHR1cm4gdW5sb2NrcyBDYWNoZUVyci1EUEEpLgotCSAqIE91Z2h0IHRvIGxvZyB0aGUgb2NjdXJlbmNlIG9mIHRoaXMgcmVjb3ZlcmVkIGRjYWNoZSBlcnJvci4KKwkgKiBPdWdodCB0byBsb2cgdGhlIG9jY3VycmVuY2Ugb2YgdGhpcyByZWNvdmVyZWQgZGNhY2hlIGVycm9yLgogCSAqLwogCWIJcmVjb3ZlcmVkCiAJIG10YzAJJDAsQzBfQ0VSUl9ECmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbW0vdGxiZXguYyBiL2FyY2gvbWlwcy9tbS90bGJleC5jCmluZGV4IDA0ZjllMTcuLjVlZjI5NGYgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9tbS90bGJleC5jCisrKyBiL2FyY2gvbWlwcy9tbS90bGJleC5jCkBAIC0zNTIsNyArMzUyLDcgQEAKIAogLyoKICAqIFdyaXRlIHJhbmRvbSBvciBpbmRleGVkIFRMQiBlbnRyeSwgYW5kIGNhcmUgYWJvdXQgdGhlIGhhemFyZHMgZnJvbQotICogdGhlIHByZWNlZWRpbmcgbXRjMCBhbmQgZm9yIHRoZSBmb2xsb3dpbmcgZXJldC4KKyAqIHRoZSBwcmVjZWRpbmcgbXRjMCBhbmQgZm9yIHRoZSBmb2xsb3dpbmcgZXJldC4KICAqLwogZW51bSB0bGJfd3JpdGVfZW50cnkgeyB0bGJfcmFuZG9tLCB0bGJfaW5kZXhlZCB9OwogCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbXRpLW1hbHRhL21hbHRhLXNtdGMuYyBiL2FyY2gvbWlwcy9tdGktbWFsdGEvbWFsdGEtc210Yy5jCmluZGV4IGU2Nzg5MTUuLjQ5YTM4YjAgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9tdGktbWFsdGEvbWFsdGEtc210Yy5jCisrKyBiL2FyY2gvbWlwcy9tdGktbWFsdGEvbWFsdGEtc210Yy5jCkBAIC0xMzAsNyArMTMwLDcgQEAKIAkgKiBjbGVhcmVkIGluIHRoZSBhZmZpbml0eSBtYXNrLCB0aGVyZSB3aWxsIG5ldmVyIGJlIGFueQogCSAqIGludGVycnVwdCBmb3J3YXJkaW5nLiAgQnV0IGFzIHNvb24gYXMgYSBwcm9ncmFtIG9yIG9wZXJhdG9yCiAJICogc2V0cyBhZmZpbml0eSBmb3Igb25lIG9mIHRoZSByZWxhdGVkIElSUXMsIHdlIG5lZWQgdG8gbWFrZQotCSAqIHN1cmUgdGhhdCB3ZSBkb24ndCBldmVyIHRyeSB0byBmb3J3YXJkIGFjcm9zcyB0aGUgVlBFIGJvdW5kcnksCisJICogc3VyZSB0aGF0IHdlIGRvbid0IGV2ZXIgdHJ5IHRvIGZvcndhcmQgYWNyb3NzIHRoZSBWUEUgYm91bmRhcnksCiAJICogYXQgbGVhc3Qgbm90IHVudGlsIHdlIGVuZ2luZWVyIGEgc3lzdGVtIHdoZXJlIHRoZSBpbnRlcnJ1cHQKIAkgKiBfYWNrKCkgb3IgX2VuZCgpIGZ1bmN0aW9uIGNhbiBzb21laG93IGtub3cgdGhhdCBpdCBjb3JyZXNwb25kcwogCSAqIHRvIGFuIGludGVycnVwdCB0YWtlbiBvbiBhbm90aGVyIFZQRSwgYW5kIHBlcmZvcm0gdGhlIGFwcHJvcHJpYXRlCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvcGNpL29wcy1wbWNtc3AuYyBiL2FyY2gvbWlwcy9wY2kvb3BzLXBtY21zcC5jCmluZGV4IDY4Nzk4ZjguLjhmYmZiZjIgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9wY2kvb3BzLXBtY21zcC5jCisrKyBiL2FyY2gvbWlwcy9wY2kvb3BzLXBtY21zcC5jCkBAIC0zNDQsNyArMzQ0LDcgQEAKICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUENJX0FDQ0VTU19XUklURSBhbmQgUENJX0FDQ0VTU19SRUFELgogICoKICAqICAgICAgICAgICAgICAgYnVzICAgICAgICAgIC0gcG9pbnRlciB0byB0aGUgYnVzIG51bWJlciBvZiB0aGUgZGV2aWNlIHRvCi0gKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJlIHRhcmdldHRlZCBmb3IgdGhlIGNvbmZpZ3VyYXRpb24gY3ljbGUuCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJlIHRhcmdldGVkIGZvciB0aGUgY29uZmlndXJhdGlvbiBjeWNsZS4KICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVGhlIG9ubHkgZWxlbWVudCBvZiB0aGUgcGNpX2J1cyBzdHJ1Y3R1cmUKICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdXNlZCBpcyBidXMtPm51bWJlci4gVGhpcyBhcmd1bWVudCBkZXRlcm1pbmVzCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIHRoZSBjb25maWd1cmF0aW9uIGFjY2VzcyB3aWxsIGJlIFR5cGUgMCBvcgpAQCAtMzU0LDcgKzM1NCw3IEBACiAgKgogICogICAgICAgICAgICAgICBkZXZmbiAgICAgICAgLSB0aGlzIGlzIGFuIDgtYml0IGZpZWxkLiBUaGUgbG93ZXIgdGhyZWUgYml0cwogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzcGVjaWZ5IHRoZSBmdW5jdGlvbiBudW1iZXIgb2YgdGhlIGRldmljZSB0bwotICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiZSB0YXJnZXR0ZWQgZm9yIHRoZSBjb25maWd1cmF0aW9uIGN5Y2xlLCB3aXRoCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJlIHRhcmdldGVkIGZvciB0aGUgY29uZmlndXJhdGlvbiBjeWNsZSwgd2l0aAogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbGwgdGhyZWUtYml0IGNvbWJpbmF0aW9ucyBiZWluZyBsZWdhbC4gVGhlCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVwcGVyIGZpdmUgYml0cyBzcGVjaWZ5IHRoZSBkZXZpY2UgbnVtYmVyLAogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICB3aXRoIGxlZ2FsIHZhbHVlcyBiZWluZyAxMCB0byAzMS4KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9wY2kvcGNpLWJjbTE0ODAuYyBiL2FyY2gvbWlwcy9wY2kvcGNpLWJjbTE0ODAuYwppbmRleCA2ZjVlMjRjLi5hZjhjMzE5IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvcGNpL3BjaS1iY20xNDgwLmMKKysrIGIvYXJjaC9taXBzL3BjaS9wY2ktYmNtMTQ4MC5jCkBAIC0yMTAsNyArMjEwLDcgQEAKIAlQQ0lCSU9TX01JTl9JTyA9IDB4MDAwMDgwMDBVTDsKIAlQQ0lCSU9TX01JTl9NRU0gPSAweDAxMDAwMDAwVUw7CiAKLQkvKiBTZXQgSS9PIHJlc291cmNlIGxpbWl0cy4gLSB1bmxpbWl0ZWQgZm9yIG5vdyB0byBhY2NvbW9kYXRlIEhUICovCisJLyogU2V0IEkvTyByZXNvdXJjZSBsaW1pdHMuIC0gdW5saW1pdGVkIGZvciBub3cgdG8gYWNjb21tb2RhdGUgSFQgKi8KIAlpb3BvcnRfcmVzb3VyY2UuZW5kID0gMHhmZmZmZmZmZlVMOwogCWlvbWVtX3Jlc291cmNlLmVuZCA9IDB4ZmZmZmZmZmZVTDsKIApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL3BjaS9wY2ktb2N0ZW9uLmMgYi9hcmNoL21pcHMvcGNpL3BjaS1vY3Rlb24uYwppbmRleCAyZDc0ZmM5Li5lZDFjNTQyIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvcGNpL3BjaS1vY3Rlb24uYworKysgYi9hcmNoL21pcHMvcGNpL3BjaS1vY3Rlb24uYwpAQCAtNDQxLDcgKzQ0MSw3IEBACiAKIAkvKgogCSAqIFRET01DIG11c3QgYmUgc2V0IHRvIG9uZSBpbiBQQ0kgbW9kZS4gVERPTUMgc2hvdWxkIGJlIHNldCB0byA0Ci0JICogaW4gUENJLVggbW9kZSB0byBhbGxvdyBmb3VyIG91c3RhbmRpbmcgc3BsaXRzLiBPdGhlcndpc2UsCisJICogaW4gUENJLVggbW9kZSB0byBhbGxvdyBmb3VyIG91dHN0YW5kaW5nIHNwbGl0cy4gT3RoZXJ3aXNlLAogCSAqIHNob3VsZCBub3QgY2hhbmdlIGZyb20gaXRzIHJlc2V0IHZhbHVlLiBEb24ndCB3cml0ZSBQQ0lfQ0ZHMTkKIAkgKiBpbiBQQ0kgbW9kZSAoMHg4MjAwMDAwMSByZXNldCB2YWx1ZSksIHdyaXRlIGl0IHRvIDB4ODIwMDAwMDQKIAkgKiBhZnRlciBQQ0ktWCBtb2RlIGlzIGtub3duLiBNUkJDSSxNRFdFLE1EUkUgLT4gbXVzdCBiZSB6ZXJvLgpAQCAtNTE1LDcgKzUxNSw3IEBACiAjZW5kaWYJLyogVVNFX09DVEVPTl9JTlRFUk5BTF9BUkJJVEVSICovCiAKIAkvKgotCSAqIFByZWZlcnJhYmx5IHdyaXR0ZW4gdG8gMSB0byBzZXQgTUxURC4gW1JEU0FUSSxUUlRBRSwKKwkgKiBQcmVmZXJhYmx5IHdyaXR0ZW4gdG8gMSB0byBzZXQgTUxURC4gW1JEU0FUSSxUUlRBRSwKIAkgKiBUV1RBRSxUTUFFLERQUE1SIC0+IG11c3QgYmUgemVyby4gVElMVCAtPiBtdXN0IG5vdCBiZSBzZXQgdG8KIAkgKiAxLi43LgogCSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL3BjaS9wY2kuYyBiL2FyY2gvbWlwcy9wY2kvcGNpLmMKaW5kZXggMzhiYzI4MC4uMzNiYmE3YiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL3BjaS9wY2kuYworKysgYi9hcmNoL21pcHMvcGNpL3BjaS5jCkBAIC0xMjUsNyArMTI1LDcgQEAKIAlob3NlX3RhaWwgPSAmaG9zZS0+bmV4dDsKIAogCS8qCi0JICogRG8gbm90IHBhbmljIGhlcmUgYnV0IGxhdGVyIC0gdGhpcyBtaWdodCBoYXBlbiBiZWZvcmUgY29uc29sZSBpbml0LgorCSAqIERvIG5vdCBwYW5pYyBoZXJlIGJ1dCBsYXRlciAtIHRoaXMgbWlnaHQgaGFwcGVuIGJlZm9yZSBjb25zb2xlIGluaXQuCiAJICovCiAJaWYgKCFob3NlLT5pb19tYXBfYmFzZSkgewogCQlwcmludGsoS0VSTl9XQVJOSU5HCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvcG1jLXNpZXJyYS9tc3A3MXh4L21zcF9zZXR1cC5jIGIvYXJjaC9taXBzL3BtYy1zaWVycmEvbXNwNzF4eC9tc3Bfc2V0dXAuYwppbmRleCBmYjM3YTEwLi4yNDEzZWE2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvcG1jLXNpZXJyYS9tc3A3MXh4L21zcF9zZXR1cC5jCisrKyBiL2FyY2gvbWlwcy9wbWMtc2llcnJhL21zcDcxeHgvbXNwX3NldHVwLmMKQEAgLTIzOSw3ICsyMzksNyBAQAogI2lmZGVmIENPTkZJR19QTUNUV0lMRUQKIAkvKgogCSAqIFNldHVwIExFRCBzdGF0ZXMgYmVmb3JlIHRoZSBzdWJzeXNfaW5pdGNhbGwgbG9hZHMgb3RoZXIKLQkgKiBkZXBlbmRhbnQgZHJpdmVycy9tb2R1bGVzLgorCSAqIGRlcGVuZGVudCBkcml2ZXJzL21vZHVsZXMuCiAJICovCiAJcG1jdHdpbGVkX3NldHVwKCk7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9wbng4MzN4L2NvbW1vbi9wbGF0Zm9ybS5jIGIvYXJjaC9taXBzL3BueDgzM3gvY29tbW9uL3BsYXRmb3JtLmMKaW5kZXggY2U0NWRmMS4uODcxNjdkYyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL3BueDgzM3gvY29tbW9uL3BsYXRmb3JtLmMKKysrIGIvYXJjaC9taXBzL3BueDgzM3gvY29tbW9uL3BsYXRmb3JtLmMKQEAgLTE2NSw3ICsxNjUsNyBAQAogCXsKIAkJLmJhc2UgPSBQTlg4MzNYX0kyQzBfUE9SVFNfU1RBUlQsCiAJCS5pcnEgPSAtMSwgLyogc2hvdWxkIGJlIFBOWDgzM1hfUElDX0kyQzBfSU5UIGJ1dCBwb2xsaW5nIGlzIGZhc3RlciAqLwotCQkuY2xvY2sgPSA2LAkvKiAwID09IDQwMCBrSHosIDQgPT0gMTAwIGtIeihNYXhpbXVtIEhETUkpLCA2ID0gNTBrSHooUHJlZmVyZWQgSERDUCkgKi8KKwkJLmNsb2NrID0gNiwJLyogMCA9PSA0MDAga0h6LCA0ID09IDEwMCBrSHooTWF4aW11bSBIRE1JKSwgNiA9IDUwa0h6KFByZWZlcnJlZCBIRENQKSAqLwogCQkuYnVzX2FkZHIgPSAwLAkvKiBubyBzbGF2ZSBzdXBwb3J0ICovCiAJfSwKIAl7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvc2dpLWlwMjcvS2NvbmZpZyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9LY29uZmlnCmluZGV4IDVlOTYwYWUuLmJjNWU5NzYgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9zZ2ktaXAyNy9LY29uZmlnCisrKyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9LY29uZmlnCkBAIC0xLDcgKzEsNyBAQAogI2NvbmZpZyBTR0lfU04wX1hYTAogIwlib29sICJJUDI3IFhYTCIKICMJZGVwZW5kcyBvbiBTR0lfSVAyNwotIwkgIFRoaXMgb3B0aW9ucyBhZGRzIHN1cHBvcnQgZm9yIHVzZXJzcGFjZSBwcm9jZXNzZXMgdXB0byAxNlRCIHNpemUuCisjCSAgVGhpcyBvcHRpb25zIGFkZHMgc3VwcG9ydCBmb3IgdXNlcnNwYWNlIHByb2Nlc3NlcyB1cCB0byAxNlRCIHNpemUuCiAjCSAgTm9ybWFsbHkgdGhlIGxpbWl0IGlzIGp1c3QgLjVUQi4KIAogY2hvaWNlCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvc2dpLWlwMjcvVE9ETyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9UT0RPCmluZGV4IDE5ZjE1MTIuLjE2MDg1N2YgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9zZ2ktaXAyNy9UT0RPCisrKyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9UT0RPCkBAIC0xMyw3ICsxMyw3IEBACiA5LiBzdGFydF90aHJlYWQgbXVzdCB0dXJuIG9mZiBVWDY0IC4uLiBhbmQgZGVmaW5lIHRsYl9yZWZpbGxfZGVidWcuCiAxMC4gTmVlZCBhIGJhZCBwbWQgdGFibGUsIGJhZCBwdGUgdGFibGUuIF9fYmFkX3BtZF90YWJsZS9fX2JhZF9wYWdldGFibGUKIGRvZXMgbm90IGFncmVlIHdpdGggcGdkX2JhZC9wbWRfYmFkLgotMTEuIEFsbCBpbnRycyAoaXAyN19kb19pcnEgaGFuZGxlcnMpIGFyZSB0YXJnZXR0ZWQgYXQgY3B1IEEgb24gdGhlIG5vZGUuCisxMS4gQWxsIGludHJzIChpcDI3X2RvX2lycSBoYW5kbGVycykgYXJlIHRhcmdldGVkIGF0IGNwdSBBIG9uIHRoZSBub2RlLgogVGhpcyBtaWdodCBuZWVkIHRvIGNoYW5nZSBsYXRlci4gT25seSB0aGUgdGltZXIgaW50ciBpcyBzZXQgdXAgdG8gYmUKIHJlY2VpdmVkIG9uIGJvdGggQ3B1IEEgYW5kIEIuIChpcDI3X2RvX2lycSgpL2JyaWRnZV9zdGFydHVwKCkpCiAxMy4gQ2FjaGUgZmx1c2hpbmcgKHNwZWNpYWxseSB0aGUgU01QIHZlcnNpb24pIGhhcyB0byBiZSBpbnZlc3RpZ2F0ZWQuCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvc2dpLWlwMjcvaXAyNy1pbml0LmMgYi9hcmNoL21pcHMvc2dpLWlwMjcvaXAyNy1pbml0LmMKaW5kZXggNTFkM2E0Zi4uOTIzYzA4MCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL3NnaS1pcDI3L2lwMjctaW5pdC5jCisrKyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9pcDI3LWluaXQuYwpAQCAtOTMsNyArOTMsNyBAQAogCiAJLyoKIAkgKiBTb21lIGludGVycnVwdHMgYXJlIHJlc2VydmVkIGJ5IGhhcmR3YXJlIG9yIGJ5IHNvZnR3YXJlIGNvbnZlbnRpb24uCi0JICogTWFyayB0aGVzZSBhcyByZXNlcnZlZCByaWdodCBhd2F5IHNvIHRoZXkgd29uJ3QgYmUgdXNlZCBhY2NpZGVudGx5CisJICogTWFyayB0aGVzZSBhcyByZXNlcnZlZCByaWdodCBhd2F5IHNvIHRoZXkgd29uJ3QgYmUgdXNlZCBhY2NpZGVudGFsbHkKIAkgKiBsYXRlci4KIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDw9IEJBU0VfUENJX0lSUTsgaSsrKSB7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvc2dpLWlwMjcvaXAyNy1pcnEuYyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9pcDI3LWlycS5jCmluZGV4IDExNDg4NzEuLjBhMDQ2MDMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9zZ2ktaXAyNy9pcDI3LWlycS5jCisrKyBiL2FyY2gvbWlwcy9zZ2ktaXAyNy9pcDI3LWlycS5jCkBAIC00MSw3ICs0MSw3IEBACiAgKiBMaW51eCBoYXMgYSBjb250cm9sbGVyLWluZGVwZW5kZW50IHg4NiBpbnRlcnJ1cHQgYXJjaGl0ZWN0dXJlLgogICogZXZlcnkgY29udHJvbGxlciBoYXMgYSAnY29udHJvbGxlci10ZW1wbGF0ZScsIHRoYXQgaXMgdXNlZAogICogYnkgdGhlIG1haW4gY29kZSB0byBkbyB0aGUgcmlnaHQgdGhpbmcuIEVhY2ggZHJpdmVyLXZpc2libGUKLSAqIGludGVycnVwdCBzb3VyY2UgaXMgdHJhbnNwYXJlbnRseSB3aXJlZCB0byB0aGUgYXByb3ByaWF0ZQorICogaW50ZXJydXB0IHNvdXJjZSBpcyB0cmFuc3BhcmVudGx5IHdpcmVkIHRvIHRoZSBhcHByb3ByaWF0ZQogICogY29udHJvbGxlci4gVGh1cyBkcml2ZXJzIG5lZWQgbm90IGJlIGF3YXJlIG9mIHRoZQogICogaW50ZXJydXB0LWNvbnRyb2xsZXIuCiAgKgpkaWZmIC0tZ2l0IGEvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL2NwdS1yZWdzLmggYi9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vY3B1LXJlZ3MuaAppbmRleCA5MGVkNGEzLi5jNTRlZmZhIDEwMDY0NAotLS0gYS9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vY3B1LXJlZ3MuaAorKysgYi9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vY3B1LXJlZ3MuaApAQCAtNDksNyArNDksNyBAQAogI2RlZmluZSBFUFNXX0lNXzYJCTB4MDAwMDA2MDAJLyogaW50ZXJydXB0IG1vZGUgNiAqLwogI2RlZmluZSBFUFNXX0lNXzcJCTB4MDAwMDA3MDAJLyogaW50ZXJydXB0IG1vZGUgNyAqLwogI2RlZmluZSBFUFNXX0lFCQkJMHgwMDAwMDgwMAkvKiBpbnRlcnJ1cHQgZW5hYmxlICovCi0jZGVmaW5lIEVQU1dfUwkJCTB4MDAwMDMwMDAJLyogc29mdHdhcmUgYXV4aWxsaWFyeSBiaXRzICovCisjZGVmaW5lIEVQU1dfUwkJCTB4MDAwMDMwMDAJLyogc29mdHdhcmUgYXV4aWxpYXJ5IGJpdHMgKi8KICNkZWZpbmUgRVBTV19UCQkJMHgwMDAwODAwMAkvKiB0cmFjZSBlbmFibGUgKi8KICNkZWZpbmUgRVBTV19uU0wJCTB4MDAwMTAwMDAJLyogbm90IHN1cGVydmlzb3IgbGV2ZWwgKi8KICNkZWZpbmUgRVBTV19OTUlECQkweDAwMDIwMDAwCS8qIG5vbm1hc2thYmxlIGludGVycnVwdCBkaXNhYmxlICovCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9laXNhX2VlcHJvbS5oIGIvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vZWlzYV9lZXByb20uaAppbmRleCA5YzlkYTk4Li44Y2U4Yjg1IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9laXNhX2VlcHJvbS5oCisrKyBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL2Vpc2FfZWVwcm9tLmgKQEAgLTI3LDcgKzI3LDcgQEAKIAl1X2ludDhfdCAgdmVyX21hajsKIAl1X2ludDhfdCAgdmVyX21pbjsKIAl1X2ludDhfdCAgbnVtX3Nsb3RzOyAgICAgICAgLyogbnVtYmVyIG9mIEVJU0Egc2xvdHMgaW4gc3lzdGVtICovCi0JdV9pbnQxNl90IGNzdW07ICAgICAgICAgICAgIC8qIGNoZWNrc3VtLCBJIGRvbid0IGtub3cgaG93IHRvIGNhbHVsYXRlIHRoaXMgKi8KKwl1X2ludDE2X3QgY3N1bTsgICAgICAgICAgICAgLyogY2hlY2tzdW0sIEkgZG9uJ3Qga25vdyBob3cgdG8gY2FsY3VsYXRlIHRoaXMgKi8KIAl1X2ludDhfdCAgcGFkWzEwXTsKIH0gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOwogCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9rZXJuZWwvZW50cnkuUyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9lbnRyeS5TCmluZGV4IGU1NDc3MDkuLmVhZDhkMmEgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9lbnRyeS5TCisrKyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9lbnRyeS5TCkBAIC0xODcsOCArMTg3LDggQEAKIAogCS8qIFJlZ2lzdGVyIGRlZmluaXRpb25zIGZvciB0bGIgbWlzcyBoYW5kbGVyIG1hY3JvcyAqLwogCi0JdmEgID0gcjgJLyogdmlydHVhbCBhZGRyZXNzIGZvciB3aGljaCB0aGUgdHJhcCBvY2N1cmVkICovCi0Jc3BjID0gcjI0CS8qIHNwYWNlIGZvciB3aGljaCB0aGUgdHJhcCBvY2N1cmVkICovCisJdmEgID0gcjgJLyogdmlydHVhbCBhZGRyZXNzIGZvciB3aGljaCB0aGUgdHJhcCBvY2N1cnJlZCAqLworCXNwYyA9IHIyNAkvKiBzcGFjZSBmb3Igd2hpY2ggdGhlIHRyYXAgb2NjdXJyZWQgKi8KIAogI2lmbmRlZiBDT05GSUdfNjRCSVQKIApAQCAtODgyLDcgKzg4Miw3IEBACiAJICogKHdlIGRvbid0IHN0b3JlIHRoZW0gaW4gdGhlIHNpZ2NvbnRleHQpLCBzbyBzZXQgdGhlbQogCSAqIHRvICJwcm9wZXIiIHZhbHVlcyBub3cgKG90aGVyd2lzZSB3ZSdsbCB3aW5kIHVwIHJlc3RvcmluZwogCSAqIHdoYXRldmVyIHdhcyBsYXN0IHN0b3JlZCBpbiB0aGUgdGFzayBzdHJ1Y3R1cmUsIHdoaWNoIG1pZ2h0Ci0JICogYmUgaW5jb25zaXN0ZW50IGlmIGFuIGludGVycnVwdCBvY2N1cmVkIHdoaWxlIG9uIHRoZSBnYXRld2F5CisJICogYmUgaW5jb25zaXN0ZW50IGlmIGFuIGludGVycnVwdCBvY2N1cnJlZCB3aGlsZSBvbiB0aGUgZ2F0ZXdheQogCSAqIHBhZ2UpLiBOb3RlIHRoYXQgd2UgbWF5IGJlICJ0cmFzaGluZyIgdmFsdWVzIHRoZSB1c2VyIHB1dCBpbgogCSAqIHRoZW0sIGJ1dCB3ZSBkb24ndCBzdXBwb3J0IHRoZSB1c2VyIGNoYW5naW5nIHRoZW0uCiAJICovCkBAIC0xMTU2LDExICsxMTU2LDExIEBACiAJICovCiAKIAl0MCA9IHIxCQkvKiB0ZW1wb3JhcnkgcmVnaXN0ZXIgMCAqLwotCXZhID0gcjgJCS8qIHZpcnR1YWwgYWRkcmVzcyBmb3Igd2hpY2ggdGhlIHRyYXAgb2NjdXJlZCAqLworCXZhID0gcjgJCS8qIHZpcnR1YWwgYWRkcmVzcyBmb3Igd2hpY2ggdGhlIHRyYXAgb2NjdXJyZWQgKi8KIAl0MSA9IHI5CQkvKiB0ZW1wb3JhcnkgcmVnaXN0ZXIgMSAqLwogCXB0ZSAgPSByMTYJLyogcHRlL3BoeXMgcGFnZSAjICovCiAJcHJvdCA9IHIxNwkvKiBwcm90IGJpdHMgKi8KLQlzcGMgID0gcjI0CS8qIHNwYWNlIGZvciB3aGljaCB0aGUgdHJhcCBvY2N1cmVkICovCisJc3BjICA9IHIyNAkvKiBzcGFjZSBmb3Igd2hpY2ggdGhlIHRyYXAgb2NjdXJyZWQgKi8KIAlwdHAgPSByMjUJLyogcGFnZSBkaXJlY3RvcnkvcGFnZSB0YWJsZSBwb2ludGVyICovCiAKICNpZmRlZiBDT05GSUdfNjRCSVQKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL2tlcm5lbC9oZWFkLlMgYi9hcmNoL3BhcmlzYy9rZXJuZWwvaGVhZC5TCmluZGV4IDRkYmRmMGUuLjE0NWM1ZTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9oZWFkLlMKKysrIGIvYXJjaC9wYXJpc2Mva2VybmVsL2hlYWQuUwpAQCAtMTMxLDcgKzEzMSw3IEBACiAJbGRvICAgICAgICAgICAgIFRIUkVBRF9TWl9BTEdOKCVyNiksJXNwCiAKICNpZmRlZiBDT05GSUdfU01QCi0JLyogU2V0IHRoZSBzbXAgcmVuZGV2b3VzIGFkZHJlc3MgaW50byBwYWdlIHplcm8uCisJLyogU2V0IHRoZSBzbXAgcmVuZGV6dm91cyBhZGRyZXNzIGludG8gcGFnZSB6ZXJvLgogCSoqIEl0IHdvdWxkIGJlIHNhZmVyIHRvIGRvIHRoaXMgaW4gaW5pdF9zbXBfY29uZmlnKCkgYnV0CiAJKiogaXQncyBqdXN0IHdheSBlYXNpZXIgdG8gZGVhbCB3aXRoIGhlcmUgYmVjYXVzZQogCSoqIG9mIDY0LWJpdCBmdW5jdGlvbiBwdHJzIGFuZCB0aGUgYWRkcmVzcyBpcyBsb2NhbCB0byB0aGlzIGZpbGUuCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9rZXJuZWwvaW52ZW50b3J5LmMgYi9hcmNoL3BhcmlzYy9rZXJuZWwvaW52ZW50b3J5LmMKaW5kZXggZDIyOGQ4Mi4uMDgzMjRhYSAxMDA2NDQKLS0tIGEvYXJjaC9wYXJpc2Mva2VybmVsL2ludmVudG9yeS5jCisrKyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9pbnZlbnRvcnkuYwpAQCAtOTMsNyArOTMsNyBAQAogCWNhc2UgMHg2OgkJLyogNzA1LCA3MTAgKi8KIAljYXNlIDB4NzoJCS8qIDcxNSwgNzI1ICovCiAJY2FzZSAweDg6CQkvKiA3NDUsIDc0NywgNzQyICovCi0JY2FzZSAweEE6CQkvKiA3MTIgYW5kIHNpbWlsaWFyICovCisJY2FzZSAweEE6CQkvKiA3MTIgYW5kIHNpbWlsYXIgKi8KIAljYXNlIDB4QzoJCS8qIDcxNS82NCwgYXQgbGVhc3QgKi8KIAogCQlwZGNfdHlwZSA9IFBEQ19UWVBFX1NOQUtFOwpkaWZmIC0tZ2l0IGEvYXJjaC9wYXJpc2Mva2VybmVsL3NpZ25hbC5jIGIvYXJjaC9wYXJpc2Mva2VybmVsL3NpZ25hbC5jCmluZGV4IDYwOWEzMzEuLjEyYzFlZDMgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9zaWduYWwuYworKysgYi9hcmNoL3BhcmlzYy9rZXJuZWwvc2lnbmFsLmMKQEAgLTI5MSw3ICsyOTEsNyBAQAogCQlEQkcoMSwic2V0dXBfcnRfZnJhbWU6IGZyYW1lLT51YyA9IDB4JXBcbiIsICZmcmFtZS0+dWMpOwogCQlEQkcoMSwic2V0dXBfcnRfZnJhbWU6IGZyYW1lLT51Yy51Y19tY29udGV4dCA9IDB4JXBcbiIsICZmcmFtZS0+dWMudWNfbWNvbnRleHQpOwogCQllcnIgfD0gc2V0dXBfc2lnY29udGV4dCgmZnJhbWUtPnVjLnVjX21jb250ZXh0LCByZWdzLCBpbl9zeXNjYWxsKTsKLQkJLyogRklYTUU6IFNob3VsZCBwcm9iYWJseSBiZSBjb252ZXJ0ZWQgYXN3ZWxsIGZvciB0aGUgY29tcGF0IGNhc2UgKi8KKwkJLyogRklYTUU6IFNob3VsZCBwcm9iYWJseSBiZSBjb252ZXJ0ZWQgYXMgd2VsbCBmb3IgdGhlIGNvbXBhdCBjYXNlICovCiAJCWVyciB8PSBfX2NvcHlfdG9fdXNlcigmZnJhbWUtPnVjLnVjX3NpZ21hc2ssIHNldCwgc2l6ZW9mKCpzZXQpKTsKIAl9CiAJCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9rZXJuZWwvc3lzY2FsbC5TIGIvYXJjaC9wYXJpc2Mva2VybmVsL3N5c2NhbGwuUwppbmRleCA2OGU3NWNlLi44MmE1MmIyIDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9rZXJuZWwvc3lzY2FsbC5TCisrKyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9zeXNjYWxsLlMKQEAgLTYwNSw3ICs2MDUsNyBAQAogCWNvcHkJJXIwLCAlcjIxCiAKIDM6CQkKLQkvKiBFcnJvciBvY2N1cmVkIG9uIGxvYWQgb3Igc3RvcmUgKi8KKwkvKiBFcnJvciBvY2N1cnJlZCBvbiBsb2FkIG9yIHN0b3JlICovCiAJLyogRnJlZSBsb2NrICovCiAJc3R3CSVyMjAsIDAoJXNyMiwlcjIwKQogI2lmIEVOQUJMRV9MV1NfREVCVUcKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL2tlcm5lbC9zeXNjYWxsX3RhYmxlLlMgYi9hcmNoL3BhcmlzYy9rZXJuZWwvc3lzY2FsbF90YWJsZS5TCmluZGV4IDc0ODY3ZGYuLjRiZTg1ZWUgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9zeXNjYWxsX3RhYmxlLlMKKysrIGIvYXJjaC9wYXJpc2Mva2VybmVsL3N5c2NhbGxfdGFibGUuUwpAQCAtMzQsNyArMzQsNyBAQAogLyogVXNlIEVOVFJZX1NBTUUgZm9yIDMyLWJpdCBzeXNjYWxscyB3aGljaCBhcmUgdGhlIHNhbWUgb24gd2lkZSBhbmQKICAqIG5hcnJvdyBwYWxpbnV4LiAgVXNlIEVOVFJZX0RJRkYgZm9yIHRob3NlIHdoZXJlIGEgMzItYml0IHNwZWNpZmljCiAgKiBpbXBsZW1lbnRhdGlvbiBpcyByZXF1aXJlZCBvbiB3aWRlIHBhbGludXguICBVc2UgRU5UUllfQ09NUCB3aGVyZQotICogdGhlIGNvbXBhdGFiaWxpdHkgbGF5ZXIgaGFzIGEgdXNlZnVsIDMyLWJpdCBpbXBsZW1lbnRhdGlvbi4KKyAqIHRoZSBjb21wYXRpYmlsaXR5IGxheWVyIGhhcyBhIHVzZWZ1bCAzMi1iaXQgaW1wbGVtZW50YXRpb24uCiAgKi8KICNkZWZpbmUgRU5UUllfU0FNRShfbmFtZV8pIC5kd29yZCBzeXNfIyNfbmFtZV8KICNkZWZpbmUgRU5UUllfRElGRihfbmFtZV8pIC5kd29yZCBzeXMzMl8jI19uYW1lXwpkaWZmIC0tZ2l0IGEvYXJjaC9wYXJpc2MvbWF0aC1lbXUvZGZhZGQuYyBiL2FyY2gvcGFyaXNjL21hdGgtZW11L2RmYWRkLmMKaW5kZXggZTE0N2Q3ZC4uZDM3ZTJkMiAxMDA2NDQKLS0tIGEvYXJjaC9wYXJpc2MvbWF0aC1lbXUvZGZhZGQuYworKysgYi9hcmNoL3BhcmlzYy9tYXRoLWVtdS9kZmFkZC5jCkBAIC0zMDMsNyArMzAzLDcgQEAKIAlpZihEYmxfaXN6ZXJvX2hpZGRlbihyZXN1bHRwMSkpCiAJICAgIHsKIAkgICAgLyogSGFuZGxlIG5vcm1hbGl6YXRpb24gKi8KLQkgICAgLyogQSBzdHJhaWdodCBmb3dhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUgcmVzdWx0CisJICAgIC8qIEEgc3RyYWlnaHQgZm9yd2FyZCBhbGdvcml0aG0gd291bGQgbm93IHNoaWZ0IHRoZSByZXN1bHQKIAkgICAgICogYW5kIGV4dGVuc2lvbiBsZWZ0IHVudGlsIHRoZSBoaWRkZW4gYml0IGJlY29tZXMgb25lLiAgTm90CiAJICAgICAqIGFsbCBvZiB0aGUgZXh0ZW5zaW9uIGJpdHMgbmVlZCBwYXJ0aWNpcGF0ZSBpbiB0aGUgc2hpZnQuCiAJICAgICAqIE9ubHkgdGhlIHR3byBtb3N0IHNpZ25pZmljYW50IGJpdHMgKHJvdW5kIGFuZCBndWFyZCkgYXJlCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9tYXRoLWVtdS9kZnN1Yi5jIGIvYXJjaC9wYXJpc2MvbWF0aC1lbXUvZGZzdWIuYwppbmRleCA4N2ViYzYwLi4yZThiNWE3IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9tYXRoLWVtdS9kZnN1Yi5jCisrKyBiL2FyY2gvcGFyaXNjL21hdGgtZW11L2Rmc3ViLmMKQEAgLTMwNiw3ICszMDYsNyBAQAogCWlmKERibF9pc3plcm9faGlkZGVuKHJlc3VsdHAxKSkKIAkgICAgewogCSAgICAvKiBIYW5kbGUgbm9ybWFsaXphdGlvbiAqLwotCSAgICAvKiBBIHN0cmFpZ2h0IGZvd2FyZCBhbGdvcml0aG0gd291bGQgbm93IHNoaWZ0IHRoZSByZXN1bHQKKwkgICAgLyogQSBzdHJhaWdodCBmb3J3YXJkIGFsZ29yaXRobSB3b3VsZCBub3cgc2hpZnQgdGhlIHJlc3VsdAogCSAgICAgKiBhbmQgZXh0ZW5zaW9uIGxlZnQgdW50aWwgdGhlIGhpZGRlbiBiaXQgYmVjb21lcyBvbmUuICBOb3QKIAkgICAgICogYWxsIG9mIHRoZSBleHRlbnNpb24gYml0cyBuZWVkIHBhcnRpY2lwYXRlIGluIHRoZSBzaGlmdC4KIAkgICAgICogT25seSB0aGUgdHdvIG1vc3Qgc2lnbmlmaWNhbnQgYml0cyAocm91bmQgYW5kIGd1YXJkKSBhcmUKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL21hdGgtZW11L2ZtcHlmYWRkLmMgYi9hcmNoL3BhcmlzYy9tYXRoLWVtdS9mbXB5ZmFkZC5jCmluZGV4IDVkZDdmOTMuLmIwNjdjNDUgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL21hdGgtZW11L2ZtcHlmYWRkLmMKKysrIGIvYXJjaC9wYXJpc2MvbWF0aC1lbXUvZm1weWZhZGQuYwpAQCAtNTMxLDcgKzUzMSw3IEBACiAJCXNpZ25fc2F2ZSA9IERibF9zaWduZXh0ZW5kZWRzaWduKHJlc3VsdHAxKTsKIAkJaWYgKERibF9pc3plcm9faGlkZGVuKHJlc3VsdHAxKSkgewogCQkJLyogSGFuZGxlIG5vcm1hbGl6YXRpb24gKi8KLQkJLyogQSBzdHJhaWdodCBmb3dhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUKKwkJLyogQSBzdHJhaWdodGZvcndhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUKIAkJICogcmVzdWx0IGFuZCBleHRlbnNpb24gbGVmdCB1bnRpbCB0aGUgaGlkZGVuIGJpdAogCQkgKiBiZWNvbWVzIG9uZS4gIE5vdCBhbGwgb2YgdGhlIGV4dGVuc2lvbiBiaXRzIG5lZWQKIAkJICogcGFydGljaXBhdGUgaW4gdGhlIHNoaWZ0LiAgT25seSB0aGUgdHdvIG1vc3QgCkBAIC0xMTkxLDcgKzExOTEsNyBAQAogCQlzaWduX3NhdmUgPSBEYmxfc2lnbmV4dGVuZGVkc2lnbihyZXN1bHRwMSk7CiAJCWlmIChEYmxfaXN6ZXJvX2hpZGRlbihyZXN1bHRwMSkpIHsKIAkJCS8qIEhhbmRsZSBub3JtYWxpemF0aW9uICovCi0JCS8qIEEgc3RyYWlnaHQgZm93YXJkIGFsZ29yaXRobSB3b3VsZCBub3cgc2hpZnQgdGhlCisJCS8qIEEgc3RyYWlnaHRmb3J3YXJkIGFsZ29yaXRobSB3b3VsZCBub3cgc2hpZnQgdGhlCiAJCSAqIHJlc3VsdCBhbmQgZXh0ZW5zaW9uIGxlZnQgdW50aWwgdGhlIGhpZGRlbiBiaXQKIAkJICogYmVjb21lcyBvbmUuICBOb3QgYWxsIG9mIHRoZSBleHRlbnNpb24gYml0cyBuZWVkCiAJCSAqIHBhcnRpY2lwYXRlIGluIHRoZSBzaGlmdC4gIE9ubHkgdGhlIHR3byBtb3N0IApAQCAtMTg0MSw3ICsxODQxLDcgQEAKIAkJc2lnbl9zYXZlID0gU2dsX3NpZ25leHRlbmRlZHNpZ24ocmVzdWx0cDEpOwogCQlpZiAoU2dsX2lzemVyb19oaWRkZW4ocmVzdWx0cDEpKSB7CiAJCQkvKiBIYW5kbGUgbm9ybWFsaXphdGlvbiAqLwotCQkvKiBBIHN0cmFpZ2h0IGZvd2FyZCBhbGdvcml0aG0gd291bGQgbm93IHNoaWZ0IHRoZQorCQkvKiBBIHN0cmFpZ2h0Zm9yd2FyZCBhbGdvcml0aG0gd291bGQgbm93IHNoaWZ0IHRoZQogCQkgKiByZXN1bHQgYW5kIGV4dGVuc2lvbiBsZWZ0IHVudGlsIHRoZSBoaWRkZW4gYml0CiAJCSAqIGJlY29tZXMgb25lLiAgTm90IGFsbCBvZiB0aGUgZXh0ZW5zaW9uIGJpdHMgbmVlZAogCQkgKiBwYXJ0aWNpcGF0ZSBpbiB0aGUgc2hpZnQuICBPbmx5IHRoZSB0d28gbW9zdCAKQEAgLTI0ODMsNyArMjQ4Myw3IEBACiAJCXNpZ25fc2F2ZSA9IFNnbF9zaWduZXh0ZW5kZWRzaWduKHJlc3VsdHAxKTsKIAkJaWYgKFNnbF9pc3plcm9faGlkZGVuKHJlc3VsdHAxKSkgewogCQkJLyogSGFuZGxlIG5vcm1hbGl6YXRpb24gKi8KLQkJLyogQSBzdHJhaWdodCBmb3dhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUKKwkJLyogQSBzdHJhaWdodGZvcndhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUKIAkJICogcmVzdWx0IGFuZCBleHRlbnNpb24gbGVmdCB1bnRpbCB0aGUgaGlkZGVuIGJpdAogCQkgKiBiZWNvbWVzIG9uZS4gIE5vdCBhbGwgb2YgdGhlIGV4dGVuc2lvbiBiaXRzIG5lZWQKIAkJICogcGFydGljaXBhdGUgaW4gdGhlIHNoaWZ0LiAgT25seSB0aGUgdHdvIG1vc3QgCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9tYXRoLWVtdS9zZmFkZC5jIGIvYXJjaC9wYXJpc2MvbWF0aC1lbXUvc2ZhZGQuYwppbmRleCAwMDhkNzIxLi5mODAyY2Q2IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9tYXRoLWVtdS9zZmFkZC5jCisrKyBiL2FyY2gvcGFyaXNjL21hdGgtZW11L3NmYWRkLmMKQEAgLTI5OCw3ICsyOTgsNyBAQAogCWlmKFNnbF9pc3plcm9faGlkZGVuKHJlc3VsdCkpCiAJICAgIHsKIAkgICAgLyogSGFuZGxlIG5vcm1hbGl6YXRpb24gKi8KLQkgICAgLyogQSBzdHJhaWdodCBmb3dhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUgcmVzdWx0CisJICAgIC8qIEEgc3RyYWlnaHRmb3J3YXJkIGFsZ29yaXRobSB3b3VsZCBub3cgc2hpZnQgdGhlIHJlc3VsdAogCSAgICAgKiBhbmQgZXh0ZW5zaW9uIGxlZnQgdW50aWwgdGhlIGhpZGRlbiBiaXQgYmVjb21lcyBvbmUuICBOb3QKIAkgICAgICogYWxsIG9mIHRoZSBleHRlbnNpb24gYml0cyBuZWVkIHBhcnRpY2lwYXRlIGluIHRoZSBzaGlmdC4KIAkgICAgICogT25seSB0aGUgdHdvIG1vc3Qgc2lnbmlmaWNhbnQgYml0cyAocm91bmQgYW5kIGd1YXJkKSBhcmUKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL21hdGgtZW11L3Nmc3ViLmMgYi9hcmNoL3BhcmlzYy9tYXRoLWVtdS9zZnN1Yi5jCmluZGV4IDI0ZWVmNjEuLjVmOTBkMGYgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL21hdGgtZW11L3Nmc3ViLmMKKysrIGIvYXJjaC9wYXJpc2MvbWF0aC1lbXUvc2ZzdWIuYwpAQCAtMzAxLDcgKzMwMSw3IEBACiAJaWYoU2dsX2lzemVyb19oaWRkZW4ocmVzdWx0KSkKIAkgICAgewogCSAgICAvKiBIYW5kbGUgbm9ybWFsaXphdGlvbiAqLwotCSAgICAvKiBBIHN0cmFpZ2h0IGZvd2FyZCBhbGdvcml0aG0gd291bGQgbm93IHNoaWZ0IHRoZSByZXN1bHQKKwkgICAgLyogQSBzdHJhaWdodGZvcndhcmQgYWxnb3JpdGhtIHdvdWxkIG5vdyBzaGlmdCB0aGUgcmVzdWx0CiAJICAgICAqIGFuZCBleHRlbnNpb24gbGVmdCB1bnRpbCB0aGUgaGlkZGVuIGJpdCBiZWNvbWVzIG9uZS4gIE5vdAogCSAgICAgKiBhbGwgb2YgdGhlIGV4dGVuc2lvbiBiaXRzIG5lZWQgcGFydGljaXBhdGUgaW4gdGhlIHNoaWZ0LgogCSAgICAgKiBPbmx5IHRoZSB0d28gbW9zdCBzaWduaWZpY2FudCBiaXRzIChyb3VuZCBhbmQgZ3VhcmQpIGFyZQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2JpdG9wcy5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2JpdG9wcy5oCmluZGV4IDJlNTYxODcuLmYxOGM2ZDkgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9iaXRvcHMuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vYml0b3BzLmgKQEAgLTIwOSw4ICsyMDksOCBAQAogCQlyZXR1cm4gQklUU19QRVJfTE9ORzsKIAogCS8qCi0JICogQ2FsY3VsYXRlIHRoZSBiaXQgcG9zaXRpb24gb2YgdGhlIGxlYXN0IHNpZ25maWNhbnQgJzEnIGJpdCBpbiB4Ci0JICogKHNpbmNlIHggaGFzIGJlZW4gY2hhbmdlZCB0aGlzIHdpbGwgYWN0dWFsbHkgYmUgdGhlIGxlYXN0IHNpZ25maWNhbnQKKwkgKiBDYWxjdWxhdGUgdGhlIGJpdCBwb3NpdGlvbiBvZiB0aGUgbGVhc3Qgc2lnbmlmaWNhbnQgJzEnIGJpdCBpbiB4CisJICogKHNpbmNlIHggaGFzIGJlZW4gY2hhbmdlZCB0aGlzIHdpbGwgYWN0dWFsbHkgYmUgdGhlIGxlYXN0IHNpZ25pZmljYW50CiAJICogJzAnIGJpdCBpbiAqIHRoZSBvcmlnaW5hbCB4KS4gIE5vdGU6ICh4ICYgLXgpIGdpdmVzIHVzIGEgbWFzayB0aGF0CiAJICogaXMgdGhlIGxlYXN0IHNpZ25pZmljYW50ICogKFJJR0hULW1vc3QpIDEtYml0IG9mIHRoZSB2YWx1ZSBpbiB4LgogCSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2NvbXBhdC5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2NvbXBhdC5oCmluZGV4IDIyOTYxMTIuLjkxMDEwZTggMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9jb21wYXQuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vY29tcGF0LmgKQEAgLTE0MCw3ICsxNDAsNyBAQAogCXVuc2lnbmVkIGxvbmcgdXNwID0gcmVncy0+Z3ByWzFdOwogCiAJLyoKLQkgKiBXZSBjYW50IGFjY2VzcyBiZWxvdyB0aGUgc3RhY2sgcG9pbnRlciBpbiB0aGUgMzJiaXQgQUJJIGFuZAorCSAqIFdlIGNhbid0IGFjY2VzcyBiZWxvdyB0aGUgc3RhY2sgcG9pbnRlciBpbiB0aGUgMzJiaXQgQUJJIGFuZAogCSAqIGNhbiBhY2Nlc3MgMjg4IGJ5dGVzIGluIHRoZSA2NGJpdCBBQkkKIAkgKi8KIAlpZiAoIWlzXzMyYml0X3Rhc2soKSkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9jcG0uaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9jcG0uaAppbmRleCBlNTAzMjNmLi40Mzk4YTZjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vY3BtLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2NwbS5oCkBAIC05OCw3ICs5OCw3IEBACiAjZGVmaW5lIEJEX1NDX0lOVFJQVAkoMHgxMDAwKQkvKiBJbnRlcnJ1cHQgb24gY2hhbmdlICovCiAjZGVmaW5lIEJEX1NDX0xBU1QJKDB4MDgwMCkJLyogTGFzdCBidWZmZXIgaW4gZnJhbWUgKi8KICNkZWZpbmUgQkRfU0NfVEMJKDB4MDQwMCkJLyogVHJhbnNtaXQgQ1JDICovCi0jZGVmaW5lIEJEX1NDX0NNCSgweDAyMDApCS8qIENvbnRpbm91cyBtb2RlICovCisjZGVmaW5lIEJEX1NDX0NNCSgweDAyMDApCS8qIENvbnRpbnVvdXMgbW9kZSAqLwogI2RlZmluZSBCRF9TQ19JRAkoMHgwMTAwKQkvKiBSZWMnZCB0b28gbWFueSBpZGxlcyAqLwogI2RlZmluZSBCRF9TQ19QCQkoMHgwMTAwKQkvKiB4bXQgcHJlYW1ibGUgKi8KICNkZWZpbmUgQkRfU0NfQlIJKDB4MDAyMCkJLyogQnJlYWsgcmVjZWl2ZWQgKi8KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9jcG0xLmggYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vY3BtMS5oCmluZGV4IGJkMDc2NTBkLi44ZWU0MjExIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vY3BtMS5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9jcG0xLmgKQEAgLTQsNyArNCw3IEBACiAgKgogICogVGhpcyBmaWxlIGNvbnRhaW5zIHN0cnVjdHVyZXMgYW5kIGluZm9ybWF0aW9uIGZvciB0aGUgY29tbXVuaWNhdGlvbgogICogcHJvY2Vzc29yIGNoYW5uZWxzLiAgU29tZSBDUE0gY29udHJvbCBhbmQgc3RhdHVzIGlzIGF2YWlsYWJsZQotICogdGhyb3VnaHQgdGhlIE1QQzh4eCBpbnRlcm5hbCBtZW1vcnkgbWFwLiAgU2VlIGltbWFwLmggZm9yIGRldGFpbHMuCisgKiB0aHJvdWdoIHRoZSBNUEM4eHggaW50ZXJuYWwgbWVtb3J5IG1hcC4gIFNlZSBpbW1hcC5oIGZvciBkZXRhaWxzLgogICogVGhpcyBmaWxlIG9ubHkgY29udGFpbnMgd2hhdCBJIG5lZWQgZm9yIHRoZSBtb21lbnQsIG5vdCB0aGUgdG90YWwKICAqIENQTSBjYXBhYmlsaXRpZXMuICBJIChvciBzb21lb25lIGVsc2UpIHdpbGwgYWRkIGRlZmluaXRpb25zIGFzIHRoZXkKICAqIGFyZSBuZWVkZWQuICAtLSBEYW4KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9odmNhbGwuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9odmNhbGwuaAppbmRleCBlYzA4OWFjLi44ZWRlYzcxIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vaHZjYWxsLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2h2Y2FsbC5oCkBAIC0xMjIsNyArMTIyLDcgQEAKICNkZWZpbmUgSF9EQUJSWF9LRVJORUwJCSgxVUw8PCg2My02MikpCiAjZGVmaW5lIEhfREFCUlhfVVNFUgkJKDFVTDw8KDYzLTYzKSkKIAotLyogRWFjaCBjb250cm9sIGJsb2NrIGhhcyB0byBiZSBvbiBhIDRLIGJvbmRhcnkgKi8KKy8qIEVhY2ggY29udHJvbCBibG9jayBoYXMgdG8gYmUgb24gYSA0SyBib3VuZGFyeSAqLwogI2RlZmluZSBIX0NCX0FMSUdOTUVOVCAgICAgICAgICA0MDk2CiAKIC8qIHBTZXJpZXMgaHlwZXJ2aXNvciBvcGNvZGVzICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20va3Byb2Jlcy5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2twcm9iZXMuaAppbmRleCBkMGU3NzAxLi5iZTAxNzFhIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20va3Byb2Jlcy5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKQEAgLTUwLDcgKzUwLDcgQEAKICAqIEhhbmRsZSBjYXNlcyB3aGVyZToKICAqIAkJLSBVc2VyIHBhc3NlcyBhIDwuc3ltYm9sPiBvciA8bW9kdWxlOi5zeW1ib2w+CiAgKiAJCS0gVXNlciBwYXNzZXMgYSA8c3ltYm9sPiBvciA8bW9kdWxlOnN5bWJvbD4KLSAqIAkJLSBVc2VyIHBhc3NlcyBhIG5vbi1leGlzdGFudCBzeW1ib2wsIGthbGxzeW1zX2xvb2t1cF9uYW1lCisgKiAJCS0gVXNlciBwYXNzZXMgYSBub24tZXhpc3RlbnQgc3ltYm9sLCBrYWxsc3ltc19sb29rdXBfbmFtZQogICogCQkgIHJldHVybnMgMC4gRG9uJ3QgZGVyZWYgdGhlIE5VTEwgcG9pbnRlciBpbiB0aGF0IGNhc2UKICAqLwogI2RlZmluZSBrcHJvYmVfbG9va3VwX25hbWUobmFtZSwgYWRkcikJCQkJCVwKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9scHBhY2EuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9scHBhY2EuaAppbmRleCAyNmI4YzgwLi5hMDc3YWRjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vbHBwYWNhLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2xwcGFjYS5oCkBAIC0xMDUsNyArMTA1LDcgQEAKIAkvLyBwcm9jZXNzaW5nIG9mIGV4dGVybmFsIGludGVycnVwdHMuICBOb3RlIHRoYXQgUExJQyB3aWxsIHN0b3JlIHRoZQogCS8vIFhJUlIgZGlyZWN0bHkgaW50byB0aGUgeFhpcnJWYWx1ZSBmaWVsZCBzbyB0aGF0IGFub3RoZXIgWElSUiB3aWxsCiAJLy8gbm90IGJlIHByZXNlbnRlZCB1bnRpbCB0aGlzIG9uZSBjbGVhcnMuICBUaGUgbGF5b3V0IG9mIHRoZSBsb3cKLQkvLyA0LWJ5dGVzIG9mIHRoaXMgRHdvcmQgaXMgdXB0byBTTElDIC0gUExJQyBqdXN0IGNoZWNrcyB3aGV0aGVyIHRoZQorCS8vIDQtYnl0ZXMgb2YgdGhpcyBEd29yZCBpcyB1cCB0byBTTElDIC0gUExJQyBqdXN0IGNoZWNrcyB3aGV0aGVyIHRoZQogCS8vIGVudGlyZSBEd29yZCBpcyB6ZXJvIG9yIG5vdC4gIEEgbm9uLXplcm8gdmFsdWUgaW4gdGhlIGxvdyBvcmRlcgogCS8vIDItYnl0ZXMgd2lsbCByZXN1bHQgaW4gU0xJQyBiZWluZyBncmFudGVkIHRoZSBoaWdoZXN0IHRocmVhZAogCS8vIHByaW9yaXR5IHVwb24gcmV0dXJuLiAgQSAwIHdpbGwgcmV0dXJuIHRvIFNMSUMgYXMgbWVkaXVtIHByaW9yaXR5LgpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BhZ2VfNjQuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wYWdlXzY0LmgKaW5kZXggOTMyZjg4ZC4uODEyYjJjZCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BhZ2VfNjQuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGFnZV82NC5oCkBAIC0xNjksNyArMTY5LDcgQEAKIC8qCiAgKiBUaGlzIGlzIHRoZSBkZWZhdWx0IGlmIGEgcHJvZ3JhbSBkb2Vzbid0IGhhdmUgYSBQVF9HTlVfU1RBQ0sKICAqIHByb2dyYW0gaGVhZGVyIGVudHJ5LiBUaGUgUFBDNjQgRUxGIEFCSSBoYXMgYSBub24gZXhlY3V0YWJsZSBzdGFjawotICogc3RhY2sgYnkgZGVmYXVsdCwgc28gaW4gdGhlIGFic2Vuc2Ugb2YgYSBQVF9HTlVfU1RBQ0sgcHJvZ3JhbSBoZWFkZXIKKyAqIHN0YWNrIGJ5IGRlZmF1bHQsIHNvIGluIHRoZSBhYnNlbmNlIG9mIGEgUFRfR05VX1NUQUNLIHByb2dyYW0gaGVhZGVyCiAgKiB3ZSB0dXJuIGV4ZWN1dGUgcGVybWlzc2lvbiBvZmYuCiAgKi8KICNkZWZpbmUgVk1fU1RBQ0tfREVGQVVMVF9GTEFHUzMyCShWTV9SRUFEIHwgVk1fV1JJVEUgfCBWTV9FWEVDIHwgXApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3Bhc2VtaV9kbWEuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wYXNlbWlfZG1hLmgKaW5kZXggMTlmZDc5My4uZWFmYTVhNSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3Bhc2VtaV9kbWEuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGFzZW1pX2RtYS5oCkBAIC01MjIsNyArNTIyLDcgQEAKIGV4dGVybiB2b2lkIHBhc2VtaV9kbWFfZnJlZV9idWYoc3RydWN0IHBhc2VtaV9kbWFjaGFuICpjaGFuLCBpbnQgc2l6ZSwKIAkJCQlkbWFfYWRkcl90ICpoYW5kbGUpOwogCi0vKiBSb3V0aW5lcyB0byBhbGxvY2F0ZSBmbGFncyAoZXZlbnRzKSBmb3IgY2hhbm5lbCBzeW5jcm9uaXphdGlvbiAqLworLyogUm91dGluZXMgdG8gYWxsb2NhdGUgZmxhZ3MgKGV2ZW50cykgZm9yIGNoYW5uZWwgc3luY2hyb25pemF0aW9uICovCiBleHRlcm4gaW50ICBwYXNlbWlfZG1hX2FsbG9jX2ZsYWcodm9pZCk7CiBleHRlcm4gdm9pZCBwYXNlbWlfZG1hX2ZyZWVfZmxhZyhpbnQgZmxhZyk7CiBleHRlcm4gdm9pZCBwYXNlbWlfZG1hX3NldF9mbGFnKGludCBmbGFnKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wY2ktYnJpZGdlLmggYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGNpLWJyaWRnZS5oCmluZGV4IDVlMTU2ZTAuLmI5MGRiZjggMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wY2ktYnJpZGdlLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BjaS1icmlkZ2UuaApAQCAtMTA2LDcgKzEwNiw3IEBACiAJICogVXNlZCBmb3IgdmFyaWFudHMgb2YgUENJIGluZGlyZWN0IGhhbmRsaW5nIGFuZCBwb3NzaWJsZSBxdWlya3M6CiAJICogIFNFVF9DRkdfVFlQRSAtIHVzZWQgb24gNHh4IG9yIGFueSBQSEIgdGhhdCBkb2VzIGV4cGxpY2l0IHR5cGUwLzEKIAkgKiAgRVhUX1JFRyAtIHByb3ZpZGVzIGFjY2VzcyB0byBQQ0ktZSBleHRlbmRlZCByZWdpc3RlcnMKLQkgKiAgU1VSUFJFU1NfUFJJTUFSWV9CVVMgLSB3ZSBzdXJwcmVzcyB0aGUgc2V0dGluZyBvZiBQQ0lfUFJJTUFSWV9CVVMKKwkgKiAgU1VSUFJFU1NfUFJJTUFSWV9CVVMgLSB3ZSBzdXBwcmVzcyB0aGUgc2V0dGluZyBvZiBQQ0lfUFJJTUFSWV9CVVMKIAkgKiAgIG9uIEZyZWVzY2FsZSBQQ0ktZSBjb250cm9sbGVycyBzaW5jZSB0aGV5IHVzZWQgdGhlIFBDSV9QUklNQVJZX0JVUwogCSAqICAgdG8gZGV0ZXJtaW5lIHdoaWNoIGJ1cyBudW1iZXIgdG8gbWF0Y2ggb24gd2hlbiBnZW5lcmF0aW5nIHR5cGUwCiAJICogICBjb25maWcgY3ljbGVzCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcG1hY19mZWF0dXJlLmggYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcG1hY19mZWF0dXJlLmgKaW5kZXggMDBlZWRjNS4uMTA5MDJjOSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BtYWNfZmVhdHVyZS5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wbWFjX2ZlYXR1cmUuaApAQCAtNTMsOCArNTMsOCBAQAogCiAvKiBIZXJlIGlzIHRoZSBpbmZhbW91cyBzZXJpZSBvZiBPSGFyZSBiYXNlZCBtYWNoaW5lcwogICovCi0jZGVmaW5lIFBNQUNfVFlQRV9DT01FVAkJCTB4MjAJLyogQmVsZWl2ZWQgdG8gYmUgUG93ZXJCb29rIDI0MDAgKi8KLSNkZWZpbmUgUE1BQ19UWVBFX0hPT1BFUgkJMHgyMQkvKiBCZWxlaXZlZCB0byBiZSBQb3dlckJvb2sgMzQwMCAqLworI2RlZmluZSBQTUFDX1RZUEVfQ09NRVQJCQkweDIwCS8qIEJlbGlldmVkIHRvIGJlIFBvd2VyQm9vayAyNDAwICovCisjZGVmaW5lIFBNQUNfVFlQRV9IT09QRVIJCTB4MjEJLyogQmVsaWV2ZWQgdG8gYmUgUG93ZXJCb29rIDM0MDAgKi8KICNkZWZpbmUgUE1BQ19UWVBFX0tBTkdBCQkJMHgyMgkvKiBQb3dlckJvb2sgMzUwMCAoZmlyc3QgRzMpICovCiAjZGVmaW5lIFBNQUNfVFlQRV9BTENIRU1ZCQkweDIzCS8qIEFsY2hlbXkgbW90aGVyYm9hcmQgYmFzZSAqLwogI2RlZmluZSBQTUFDX1RZUEVfR0FaRUxMRQkJMHgyNAkvKiBTcGFydGFjdXMsIHNvbWUgNXh4eC82eHh4ICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcHRlLWNvbW1vbi5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3B0ZS1jb21tb24uaAppbmRleCA3NmJiMTk1Li44MTFmMDRhIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcHRlLWNvbW1vbi5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wdGUtY29tbW9uLmgKQEAgLTg2LDcgKzg2LDcgQEAKICNkZWZpbmUgUFRFX1JQTl9NQVNLCSh+KCgxVUw8PFBURV9SUE5fU0hJRlQpLTEpKQogI2VuZGlmCiAKLS8qIF9QQUdFX0NIR19NQVNLIG1hc2tzIG9mIGJpdHMgdGhhdCBhcmUgdG8gYmUgcHJlc2VydmVkIGFjY3Jvc3MKKy8qIF9QQUdFX0NIR19NQVNLIG1hc2tzIG9mIGJpdHMgdGhhdCBhcmUgdG8gYmUgcHJlc2VydmVkIGFjcm9zcwogICogcGdwcm90IGNoYW5nZXMKICAqLwogI2RlZmluZSBfUEFHRV9DSEdfTUFTSwkoUFRFX1JQTl9NQVNLIHwgX1BBR0VfSFBURUZMQUdTIHwgX1BBR0VfRElSVFkgfCBcCkBAIC0xNzQsNyArMTc0LDcgQEAKIC8qCiAgKiBEb24ndCBqdXN0IGNoZWNrIGZvciBhbnkgbm9uIHplcm8gYml0cyBpbiBfX1BBR0VfVVNFUiwgc2luY2UgZm9yIGJvb2szZQogICogYW5kIFBURV82NEJJVCwgUEFHRV9LRVJORUxfWCBjb250YWlucyBfUEFHRV9CQVBfU1Igd2hpY2ggaXMgYWxzbyBpbgotICogX1BBR0VfVVNFUi4gIE5lZWQgdG8gZXhwbGljdGx5IG1hdGNoIF9QQUdFX0JBUF9VUiBiaXQgaW4gdGhhdCBjYXNlIHRvby4KKyAqIF9QQUdFX1VTRVIuICBOZWVkIHRvIGV4cGxpY2l0bHkgbWF0Y2ggX1BBR0VfQkFQX1VSIGJpdCBpbiB0aGF0IGNhc2UgdG9vLgogICovCiAjZGVmaW5lIHB0ZV91c2VyKHZhbCkJCSgodmFsICYgX1BBR0VfVVNFUikgPT0gX1BBR0VfVVNFUikKIApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZ19ib29rZS5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZ19ib29rZS5oCmluZGV4IDNiMWE5YjcuLmIzMTY3OTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9yZWdfYm9va2UuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcmVnX2Jvb2tlLmgKQEAgLTIsNyArMiw3IEBACiAgKiBDb250YWlucyByZWdpc3RlciBkZWZpbml0aW9ucyBjb21tb24gdG8gdGhlIEJvb2sgRSBQb3dlclBDCiAgKiBzcGVjaWZpY2F0aW9uLiAgTm90aWNlIHRoYXQgd2hpbGUgdGhlIElCTS00MHggc2VyaWVzIG9mIENQVXMKICAqIGFyZSBub3QgdHJ1ZSBCb29rIEUgUG93ZXJQQ3MsIHRoZXkgYm9ycm93ZWQgYSBudW1iZXIgb2YgZmVhdHVyZXMKLSAqIGJlZm9yZSBCb29rIEUgd2FzIGZpbmFsaXplZCwgYW5kIGFyZSBpbmNsdWRlZCBoZXJlIGFzIHdlbGwuICBVbmZvcnR1bmF0bHksCisgKiBiZWZvcmUgQm9vayBFIHdhcyBmaW5hbGl6ZWQsIGFuZCBhcmUgaW5jbHVkZWQgaGVyZSBhcyB3ZWxsLiAgVW5mb3J0dW5hdGVseSwKICAqIHRoZXkgc29tZXRpbWVzIHVzZWQgZGlmZmVyZW50IGxvY2F0aW9ucyB0aGFuIHRydWUgQm9vayBFIENQVXMgZGlkLgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9zcHVfcHJpdjEuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9zcHVfcHJpdjEuaAppbmRleCAyNTAyMGEzLi5kOGY1YzYwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vc3B1X3ByaXYxLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3NwdV9wcml2MS5oCkBAIC0yMjMsNyArMjIzLDcgQEAKIH0KIAogLyoKLSAqIFRoZSBkZWNsYXJhdGlvbnMgZm9sb3dpbmcgYXJlIHB1dCBoZXJlIGZvciBjb252ZW5pZW5jZQorICogVGhlIGRlY2xhcmF0aW9ucyBmb2xsb3dpbmcgYXJlIHB1dCBoZXJlIGZvciBjb252ZW5pZW5jZQogICogYW5kIG9ubHkgaW50ZW5kZWQgdG8gYmUgdXNlZCBieSB0aGUgcGxhdGZvcm0gc2V0dXAgY29kZS4KICAqLwogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vdW5pbm9ydGguaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS91bmlub3J0aC5oCmluZGV4IGY3Mzc3MzIuLmFlOWM4OTkgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS91bmlub3J0aC5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS91bmlub3J0aC5oCkBAIC02MCw3ICs2MCw3IEBACiAgKgogICogT2J2aW91c2x5LCB0aGUgR0FSVCBpcyBub3QgY2FjaGUgY29oZXJlbnQgYW5kIHNvIGFueSBjaGFuZ2UgdG8gaXQKICAqIG11c3QgYmUgZmx1c2hlZCB0byBtZW1vcnkgKG9yIG1heWJlIGp1c3QgbWFrZSB0aGUgR0FSVCBzcGFjZSBub24KLSAqIGNhY2hhYmxlKS4gQUdQIG1lbW9yeSBpdHNlbGYgZG9lbnMndCBzZWVtIHRvIGJlIGNhY2hlIGNvaGVyZW50IG5laXRoZXIuCisgKiBjYWNoYWJsZSkuIEFHUCBtZW1vcnkgaXRzZWxmIGRvZXMndCBzZWVtIHRvIGJlIGNhY2hlIGNvaGVyZW50IG5laXRoZXIuCiAgKgogICogSW4gb3JkZXIgdG8gaW52YWxpZGF0ZSB0aGUgR0FSVCAod2hpY2ggaXMgcHJvYmFibHkgbmVjZXNzYXJ5IHRvIGludmFsCiAgKiB0aGUgYnJpZGdlIGludGVybmFsIFRMQnMpLCB0aGUgZm9sbG93aW5nIHNlcXVlbmNlIGhhcyB0byBiZSB3cml0dGVuLApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3Zkc29fZGF0YXBhZ2UuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS92ZHNvX2RhdGFwYWdlLmgKaW5kZXggMjVlMzkyMi4uYjczYTgxOSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3Zkc29fZGF0YXBhZ2UuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vdmRzb19kYXRhcGFnZS5oCkBAIC01Nyw3ICs1Nyw3IEBACiAJfSB2ZXJzaW9uOwogCiAJLyogTm90ZSBhYm91dCB0aGUgcGxhdGZvcm0gZmxhZ3M6IGl0IG5vdyBvbmx5IGNvbnRhaW5zIHRoZSBscGFyCi0JICogYml0LiBUaGUgYWN0dWFsIHBsYXRmb3JtIG51bWJlciBpcyBkZWFkIGFuZCBidXJyaWVkCisJICogYml0LiBUaGUgYWN0dWFsIHBsYXRmb3JtIG51bWJlciBpcyBkZWFkIGFuZCBidXJpZWQKIAkgKi8KIAlfX3UzMiBwbGF0Zm9ybTsJCQkvKiBQbGF0Zm9ybSBmbGFncwkJMHgxOCAqLwogCV9fdTMyIHByb2Nlc3NvcjsJCS8qIFByb2Nlc3NvciB0eXBlCQkweDFDICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL2J0ZXh0LmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL2J0ZXh0LmMKaW5kZXggNjI1OTQyYS4uNjBiM2UzNyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9idGV4dC5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvYnRleHQuYwpAQCAtOTksNyArOTksNyBAQAogCiAvKiBUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIHRvIGVuYWJsZSB0aGUgZWFybHkgYm9vdCB0ZXh0IHdoZW4gZG9pbmcKICAqIE9GIGJvb3Rpbmcgb3Igd2l0aGluIGJvb3R4IGluaXQuIEl0IG11c3QgYmUgZm9sbG93ZWQgYnkgYSBidGV4dF91bm1hcCgpCi0gKiBjYWxsIGJlZm9yZSB0aGUgbG9naWNhbCBhZGRyZXNzIGJlY29tZXMgdW51c2VhYmxlCisgKiBjYWxsIGJlZm9yZSB0aGUgbG9naWNhbCBhZGRyZXNzIGJlY29tZXMgdW51c2FibGUKICAqLwogdm9pZCBfX2luaXQgYnRleHRfc2V0dXBfZGlzcGxheShpbnQgd2lkdGgsIGludCBoZWlnaHQsIGludCBkZXB0aCwgaW50IHBpdGNoLAogCQkJCXVuc2lnbmVkIGxvbmcgYWRkcmVzcykKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvZXhjZXB0aW9ucy02NGUuUyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvZXhjZXB0aW9ucy02NGUuUwppbmRleCA1YzQzMDYzLi45NjUxYWNjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL2V4Y2VwdGlvbnMtNjRlLlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9leGNlcHRpb25zLTY0ZS5TCkBAIC0zNzksNyArMzc5LDcgQEAKIAltZnNwcglyMTMsU1BSTl9TUFJHX1BBQ0EJLyogZ2V0IG91ciBQQUNBICovCiAJYglzeXN0ZW1fY2FsbF9jb21tb24KIAotLyogQXV4aWxsYXJ5IFByb2Nlc3NvciBVbmF2YWlsYWJsZSBJbnRlcnJ1cHQgKi8KKy8qIEF1eGlsaWFyeSBQcm9jZXNzb3IgVW5hdmFpbGFibGUgSW50ZXJydXB0ICovCiAJU1RBUlRfRVhDRVBUSU9OKGFwX3VuYXZhaWxhYmxlKTsKIAlOT1JNQUxfRVhDRVBUSU9OX1BST0xPRygweGYyMCwgUFJPTE9HX0FERElUSU9OX05PTkUpCiAJRVhDRVBUSU9OX0NPTU1PTigweGYyMCwgUEFDQV9FWEdFTiwgSU5UU19LRUVQKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9leGNlcHRpb25zLTY0cy5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9leGNlcHRpb25zLTY0cy5TCmluZGV4IGM1MzJjYjIuLmFlYjczOWUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvZXhjZXB0aW9ucy02NHMuUworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2V4Y2VwdGlvbnMtNjRzLlMKQEAgLTUsNyArNSw3IEBACiAgKiBoYW5kbGluZyBhbmQgb3RoZXIgZml4ZWQgb2Zmc2V0IHNwZWNpZmljIHRoaW5ncy4KICAqCiAgKiBUaGlzIGZpbGUgaXMgbWVhbnQgdG8gYmUgI2luY2x1ZGVkIGZyb20gaGVhZF82NC5TIGR1ZSB0bwotICogcG9zaXRpb24gZGVwZW5kYW50IGFzc2VtYmx5LgorICogcG9zaXRpb24gZGVwZW5kZW50IGFzc2VtYmx5LgogICoKICAqIE1vc3Qgb2YgdGhpcyBvcmlnaW5hdGVzIGZyb20gaGVhZF82NC5TIGFuZCB0aHVzIGhhcyB0aGUgc2FtZQogICogY29weXJpZ2h0IGhpc3RvcnkuCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL2hlYWRfNDB4LlMgYi9hcmNoL3Bvd2VycGMva2VybmVsL2hlYWRfNDB4LlMKaW5kZXggOWRkMjFhOC4uYTkxNjI2ZCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkXzQweC5TCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvaGVhZF80MHguUwpAQCAtNzY2LDcgKzc2Niw3IEBACiAJICogbWlzcyBnZXQgdG8gdGhpcyBwb2ludCB0byBsb2FkIHRoZSBUTEIuCiAJICogCXIxMCAtIFRMQl9UQUcgdmFsdWUKIAkgKiAJcjExIC0gTGludXggUFRFCi0JICoJcjEyLCByOSAtIGF2aWxhYmxlIHRvIHVzZQorCSAqCXIxMiwgcjkgLSBhdmFpbGFibGUgdG8gdXNlCiAJICoJUElEIC0gbG9hZGVkIHdpdGggcHJvcGVyIHZhbHVlIHdoZW4gd2UgZ2V0IGhlcmUKIAkgKglVcG9uIGV4aXQsIHdlIHJlbG9hZCBldmVyeXRoaW5nIGFuZCBSRkkuCiAJICogQWN0dWFsbHksIGl0IHdpbGwgZml0IG5vdywgYnV0IG9oIHdlbGwuLi4uLmEgY29tbW9uIHBsYWNlCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL2hlYWRfNDR4LlMgYi9hcmNoL3Bvd2VycGMva2VybmVsL2hlYWRfNDR4LlMKaW5kZXggY2JiMzQzNi4uNWUxMmI3NCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkXzQ0eC5TCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvaGVhZF80NHguUwpAQCAtMTc4LDcgKzE3OCw3IEBACiAJTk9STUFMX0VYQ0VQVElPTl9QUk9MT0cKIAlFWENfWEZFUl9FRV9MSVRFKDB4MGMwMCwgRG9TeXNjYWxsKQogCi0JLyogQXV4aWxsYXJ5IFByb2Nlc3NvciBVbmF2YWlsYWJsZSBJbnRlcnJ1cHQgKi8KKwkvKiBBdXhpbGlhcnkgUHJvY2Vzc29yIFVuYXZhaWxhYmxlIEludGVycnVwdCAqLwogCUVYQ0VQVElPTigweDIwMjAsIEF1eGlsbGFyeVByb2Nlc3NvclVuYXZhaWxhYmxlLCB1bmtub3duX2V4Y2VwdGlvbiwgRVhDX1hGRVJfRUUpCiAKIAkvKiBEZWNyZW1lbnRlciBJbnRlcnJ1cHQgKi8KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvaGVhZF82NC5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkXzY0LlMKaW5kZXggMjcxMTQwYi4uM2EzMTlmOSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkXzY0LlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkXzY0LlMKQEAgLTQwLDcgKzQwLDcgQEAKICNpbmNsdWRlIDxhc20va3ZtX2Jvb2szc19hc20uaD4KICNpbmNsdWRlIDxhc20vcHRyYWNlLmg+CiAKLS8qIFRoZSBwaHlzaWNhbCBtZW1vcnkgaXMgbGF5ZWQgb3V0IHN1Y2ggdGhhdCB0aGUgc2Vjb25kYXJ5IHByb2Nlc3NvcgorLyogVGhlIHBoeXNpY2FsIG1lbW9yeSBpcyBsYWlkIG91dCBzdWNoIHRoYXQgdGhlIHNlY29uZGFyeSBwcm9jZXNzb3IKICAqIHNwaW4gY29kZSBzaXRzIGF0IDB4MDAwMC4uLjB4MDBmZi4gT24gc2VydmVyLCB0aGUgdmVjdG9ycyBmb2xsb3cKICAqIHVzaW5nIHRoZSBsYXlvdXQgZGVzY3JpYmVkIGluIGV4Y2VwdGlvbnMtNjRzLlMKICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkX2ZzbF9ib29rZS5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9oZWFkX2ZzbF9ib29rZS5TCmluZGV4IDNlMDI3MTAuLjVlY2Y1NGMgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvaGVhZF9mc2xfYm9va2UuUworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2hlYWRfZnNsX2Jvb2tlLlMKQEAgLTMyNiw3ICszMjYsNyBAQAogCU5PUk1BTF9FWENFUFRJT05fUFJPTE9HCiAJRVhDX1hGRVJfRUVfTElURSgweDBjMDAsIERvU3lzY2FsbCkKIAotCS8qIEF1eGlsbGFyeSBQcm9jZXNzb3IgVW5hdmFpbGFibGUgSW50ZXJydXB0ICovCisJLyogQXV4aWxpYXJ5IFByb2Nlc3NvciBVbmF2YWlsYWJsZSBJbnRlcnJ1cHQgKi8KIAlFWENFUFRJT04oMHgyOTAwLCBBdXhpbGxhcnlQcm9jZXNzb3JVbmF2YWlsYWJsZSwgdW5rbm93bl9leGNlcHRpb24sIEVYQ19YRkVSX0VFKQogCiAJLyogRGVjcmVtZW50ZXIgSW50ZXJydXB0ICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL2wyY3JfNnh4LlMgYi9hcmNoL3Bvd2VycGMva2VybmVsL2wyY3JfNnh4LlMKaW5kZXggMmEyZjNjMy4uOTdlYzg1NSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9sMmNyXzZ4eC5TCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvbDJjcl82eHguUwpAQCAtMTUxLDcgKzE1MSw3IEBACiAJIC8qKioqIE1pZ2h0IGJlIGEgZ29vZCBpZGVhIHRvIHNldCBMMkRPIGhlcmUgLSB0byBwcmV2ZW50IGluc3RydWN0aW9ucwogCSAgICAgICBmcm9tIGdldHRpbmcgaW50byB0aGUgY2FjaGUuICBCdXQgc2luY2Ugd2UgaW52YWxpZGF0ZQogCSAgICAgICB0aGUgbmV4dCB0aW1lIHdlIGVuYWJsZSB0aGUgY2FjaGUgaXQgZG9lc24ndCByZWFsbHkgbWF0dGVyLgotCSAgICAgICBEb24ndCBkbyB0aGlzIHVubGVzcyB5b3UgYWNjb21vZGF0ZSBhbGwgcHJvY2Vzc29yIHZhcmlhdGlvbnMuCisJICAgICAgIERvbid0IGRvIHRoaXMgdW5sZXNzIHlvdSBhY2NvbW1vZGF0ZSBhbGwgcHJvY2Vzc29yIHZhcmlhdGlvbnMuCiAJICAgICAgIFRoZSBiaXQgbW92ZWQgb24gdGhlIDc0NTAuLi4uLgogCSAgKioqKi8KIApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9scGFyY2ZnLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL2xwYXJjZmcuYwppbmRleCAxNjQ2ODM2Li4zMDFkYjY1IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL2xwYXJjZmcuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2xwYXJjZmcuYwpAQCAtMjYyLDcgKzI2Miw3IEBACiAJc2VxX3ByaW50ZihtLCAic3lzdGVtX2FjdGl2ZV9wcm9jZXNzb3JzPSVkXG4iLAogCSAgICAgICAgICAgcHBwX2RhdGEuYWN0aXZlX3N5c3RlbV9wcm9jcyk7CiAKLQkvKiBwb29sIHJlbGF0ZWQgZW50cmllcyBhcmUgYXByb3ByaWF0ZSBmb3Igc2hhcmVkIGNvbmZpZ3MgKi8KKwkvKiBwb29sIHJlbGF0ZWQgZW50cmllcyBhcmUgYXBwcm9wcmlhdGUgZm9yIHNoYXJlZCBjb25maWdzICovCiAJaWYgKGxwcGFjYV9vZigwKS5zaGFyZWRfcHJvYykgewogCQl1bnNpZ25lZCBsb25nIHBvb2xfaWRsZV90aW1lLCBwb29sX3Byb2NzOwogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3BlcmZfZXZlbnQuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudC5jCmluZGV4IDk3ZTBhZTQuLmM0MDYzYjcgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudC5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudC5jCkBAIC03NTksNyArNzU5LDcgQEAKIAogCS8qCiAJICogSWYgZ3JvdXAgZXZlbnRzIHNjaGVkdWxpbmcgdHJhbnNhY3Rpb24gd2FzIHN0YXJ0ZWQsCi0JICogc2tpcCB0aGUgc2NoZWR1bGFiaWxpdHkgdGVzdCBoZXJlLCBpdCB3aWxsIGJlIHBlZm9ybWVkCisJICogc2tpcCB0aGUgc2NoZWR1bGFiaWxpdHkgdGVzdCBoZXJlLCBpdCB3aWxsIGJlIHBlcmZvcm1lZAogCSAqIGF0IGNvbW1pdCB0aW1lKC0+Y29tbWl0X3R4bikgYXMgYSB3aG9sZQogCSAqLwogCWlmIChjcHVody0+Z3JvdXBfZmxhZyAmIFBFUkZfRVZFTlRfVFhOKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcGNfc2F2ZV9yZWdzLlMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3BwY19zYXZlX3JlZ3MuUwppbmRleCBlODNiYTNmLi4xYjE3ODdkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3BwY19zYXZlX3JlZ3MuUworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3BwY19zYXZlX3JlZ3MuUwpAQCAtMTUsNyArMTUsNyBAQAogCiAvKgogICogR3JhYiB0aGUgcmVnaXN0ZXIgdmFsdWVzIGFzIHRoZXkgYXJlIG5vdy4KLSAqIFRoaXMgd29uJ3QgZG8gYSBwYXJ0aWN1bGFyaWx5IGdvb2Qgam9iIGJlY2F1c2Ugd2UgcmVhbGx5CisgKiBUaGlzIHdvbid0IGRvIGEgcGFydGljdWxhcmx5IGdvb2Qgam9iIGJlY2F1c2Ugd2UgcmVhbGx5CiAgKiB3YW50IG91ciBjYWxsZXIncyBjYWxsZXIncyByZWdpc3RlcnMsIGFuZCBvdXIgY2FsbGVyIGhhcwogICogYWxyZWFkeSBleGVjdXRlZCBpdHMgcHJvbG9ndWUuCiAgKiBUb0RvOiBXZSBjb3VsZCByZWFjaCBiYWNrIGludG8gdGhlIGNhbGxlcidzIHNhdmUgYXJlYSB0byBkbwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcm9tLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Byb20uYwppbmRleCAwNWI3MTM5Li5lNzRmYTEyIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3Byb20uYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Byb20uYwpAQCAtNjgzLDcgKzY4Myw3IEBACiAjZW5kaWYKIAogI2lmZGVmIENPTkZJR19QSFlQX0RVTVAKLQkvKiBzY2FuIHRyZWUgdG8gc2VlIGlmIGR1bXAgb2NjdXJlZCBkdXJpbmcgbGFzdCBib290ICovCisJLyogc2NhbiB0cmVlIHRvIHNlZSBpZiBkdW1wIG9jY3VycmVkIGR1cmluZyBsYXN0IGJvb3QgKi8KIAlvZl9zY2FuX2ZsYXRfZHQoZWFybHlfaW5pdF9kdF9zY2FuX3BoeXBfZHVtcCwgTlVMTCk7CiAjZW5kaWYKIApAQCAtNzM5LDcgKzczOSw3IEBACiAKIAlEQkcoIlNjYW5uaW5nIENQVXMgLi4uXG4iKTsKIAotCS8qIFJldHJlaXZlIENQVSByZWxhdGVkIGluZm9ybWF0aW9ucyBmcm9tIHRoZSBmbGF0IHRyZWUKKwkvKiBSZXRyaWV2ZSBDUFUgcmVsYXRlZCBpbmZvcm1hdGlvbnMgZnJvbSB0aGUgZmxhdCB0cmVlCiAJICogKGFsdGl2ZWMgc3VwcG9ydCwgYm9vdCBDUFUgSUQsIC4uLikKIAkgKi8KIAlvZl9zY2FuX2ZsYXRfZHQoZWFybHlfaW5pdF9kdF9zY2FuX2NwdXMsIE5VTEwpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wdHJhY2UuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcHRyYWNlLmMKaW5kZXggODk1YjA4Mi4uNTU2MTNlMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wdHJhY2UuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3B0cmFjZS5jCkBAIC00NjMsNyArNDYzLDcgQEAKICNpZmRlZiBDT05GSUdfVlNYCiAvKgogICogQ3VycmVudGx5IHRvIHNldCBhbmQgYW5kIGdldCBhbGwgdGhlIHZzeCBzdGF0ZSwgeW91IG5lZWQgdG8gY2FsbAotICogdGhlIGZwIGFuZCBWTVggY2FsbHMgYXN3ZWxsLiAgVGhpcyBvbmx5IGdldC9zZXRzIHRoZSBsb3dlciAzMgorICogdGhlIGZwIGFuZCBWTVggY2FsbHMgYXMgd2VsbC4gIFRoaXMgb25seSBnZXQvc2V0cyB0aGUgbG93ZXIgMzIKICAqIDEyOGJpdCBWU1ggcmVnaXN0ZXJzLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcnRhc2QuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcnRhc2QuYwppbmRleCA3OTgwZWMwLi42N2Y2YzNiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3J0YXNkLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9ydGFzZC5jCkBAIC00NjUsNyArNDY1LDcgQEAKIAlwcl9kZWJ1ZygicnRhc2Q6IHdpbGwgc2xlZXAgZm9yICVkIG1pbGxpc2Vjb25kc1xuIiwKIAkJICgzMDAwMCAvIHJ0YXNfZXZlbnRfc2Nhbl9yYXRlKSk7CiAKLQkvKiBSZXRyZWl2ZSBlcnJvcnMgZnJvbSBudnJhbSBpZiBhbnkgKi8KKwkvKiBSZXRyaWV2ZSBlcnJvcnMgZnJvbSBudnJhbSBpZiBhbnkgKi8KIAlyZXRyZWl2ZV9udnJhbV9lcnJvcl9sb2coKTsKIAogCXNjaGVkdWxlX2RlbGF5ZWRfd29ya19vbihjcHVtYXNrX2ZpcnN0KGNwdV9vbmxpbmVfbWFzayksCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3N3c3VzcF8zMi5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9zd3N1c3BfMzIuUwppbmRleCBiMDc1NGUyLi5iYTRkZWUzIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3N3c3VzcF8zMi5TCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvc3dzdXNwXzMyLlMKQEAgLTE0Myw3ICsxNDMsNyBAQAogCiAJLyogRGlzYWJsZSBNU1I6RFIgdG8gbWFrZSBzdXJlIHdlIGRvbid0IHRha2UgYSBUTEIgb3IKIAkgKiBoYXNoIG1pc3MgZHVyaW5nIHRoZSBjb3B5LCBhcyBvdXIgaGFzaCB0YWJsZSB3aWxsCi0JICogZm9yIGEgd2hpbGUgYmUgdW51c2VhYmxlLiBGb3IgLnRleHQsIHdlIGFzc3VtZSB3ZSBhcmUKKwkgKiBmb3IgYSB3aGlsZSBiZSB1bnVzYWJsZS4gRm9yIC50ZXh0LCB3ZSBhc3N1bWUgd2UgYXJlCiAJICogY292ZXJlZCBieSBhIEJBVC4gVGhpcyB3b3JrcyBvbmx5IGZvciBub24tRzUgYXQgdGhpcwogCSAqIHBvaW50LiBHNSB3aWxsIG5lZWQgYSBiZXR0ZXIgYXBwcm9hY2gsIHBvc3NpYmx5IHVzaW5nCiAJICogYSBzbWFsbCB0ZW1wb3JhcnkgaGFzaCB0YWJsZSBmaWxsZWQgd2l0aCBsYXJnZSBtYXBwaW5ncywKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvdHJhcHMuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvdHJhcHMuYwppbmRleCBiZDc0ZmFjLi41ZGRiODAxIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3RyYXBzLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC90cmFwcy5jCkBAIC05NTksNyArOTU5LDcgQEAKIAkgKiBFU1JfRFNUICghPykgb3IgMC4gIEluIHRoZSBwcm9jZXNzIG9mIGNoYXNpbmcgdGhpcyB3aXRoIHRoZQogCSAqIGhhcmR3YXJlIHBlb3BsZSAtIG5vdCBzdXJlIGlmIGl0IGNhbiBoYXBwZW4gb24gYW55IGlsbGVnYWwKIAkgKiBpbnN0cnVjdGlvbiBvciBvbmx5IG9uIEZQIGluc3RydWN0aW9ucywgd2hldGhlciB0aGVyZSBpcyBhCi0JICogcGF0dGVybiB0byBvY2N1cmVuY2VzIGV0Yy4gLWRnaWJzb24gMzEvTWFyLzIwMDMgKi8KKwkgKiBwYXR0ZXJuIHRvIG9jY3VycmVuY2VzIGV0Yy4gLWRnaWJzb24gMzEvTWFyLzIwMDMgKi8KIAlzd2l0Y2ggKGRvX21hdGhlbXUocmVncykpIHsKIAljYXNlIDA6CiAJCWVtdWxhdGVfc2luZ2xlX3N0ZXAocmVncyk7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3VkYmdfMTY1NTAuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvdWRiZ18xNjU1MC5jCmluZGV4IGI0YjE2N2IuLmJhYTMzYTcgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvdWRiZ18xNjU1MC5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvdWRiZ18xNjU1MC5jCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIHVkYmcgZm9yIE5TMTY1NTAgY29tcGF0YWJsZSBzZXJpYWwgcG9ydHMKKyAqIHVkYmcgZm9yIE5TMTY1NTAgY29tcGF0aWJsZSBzZXJpYWwgcG9ydHMKICAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDEtMjAwNSBQUEMgNjQgVGVhbSwgSUJNIENvcnAKICAqCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3Zkc28zMi9zaWd0cmFtcC5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC92ZHNvMzIvc2lndHJhbXAuUwppbmRleCA2OGQ0OWRkLi5jZjBjOWM5IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3Zkc28zMi9zaWd0cmFtcC5TCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvdmRzbzMyL3NpZ3RyYW1wLlMKQEAgLTE5LDcgKzE5LDcgQEAKIAogLyogVGhlIG5vcCBoZXJlIGlzIGEgaGFjay4gIFRoZSBkd2FyZjIgdW53aW5kIHJvdXRpbmVzIHN1YnRyYWN0IDEgZnJvbQogICAgdGhlIHJldHVybiBhZGRyZXNzIHRvIGdldCBhbiBhZGRyZXNzIGluIHRoZSBtaWRkbGUgb2YgdGhlIHByZXN1bWVkCi0gICBjYWxsIGluc3RydWN0aW9uLiAgU2luY2Ugd2UgZG9uJ3QgaGF2ZSBhIGNhbGwgaGVyZSwgd2UgYXJ0aWZpY2FsbHkKKyAgIGNhbGwgaW5zdHJ1Y3Rpb24uICBTaW5jZSB3ZSBkb24ndCBoYXZlIGEgY2FsbCBoZXJlLCB3ZSBhcnRpZmljaWFsbHkKICAgIGV4dGVuZCB0aGUgcmFuZ2UgY292ZXJlZCBieSB0aGUgdW53aW5kIGluZm8gYnkgYWRkaW5nIGEgbm9wIGJlZm9yZQogICAgdGhlIHJlYWwgc3RhcnQuICAqLwogCW5vcApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC92ZHNvNjQvc2lndHJhbXAuUyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvdmRzbzY0L3NpZ3RyYW1wLlMKaW5kZXggNTllYjU5Yi4uNDVlYTI4MSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC92ZHNvNjQvc2lndHJhbXAuUworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Zkc282NC9zaWd0cmFtcC5TCkBAIC0yMCw3ICsyMCw3IEBACiAKIC8qIFRoZSBub3AgaGVyZSBpcyBhIGhhY2suICBUaGUgZHdhcmYyIHVud2luZCByb3V0aW5lcyBzdWJ0cmFjdCAxIGZyb20KICAgIHRoZSByZXR1cm4gYWRkcmVzcyB0byBnZXQgYW4gYWRkcmVzcyBpbiB0aGUgbWlkZGxlIG9mIHRoZSBwcmVzdW1lZAotICAgY2FsbCBpbnN0cnVjdGlvbi4gIFNpbmNlIHdlIGRvbid0IGhhdmUgYSBjYWxsIGhlcmUsIHdlIGFydGlmaWNhbGx5CisgICBjYWxsIGluc3RydWN0aW9uLiAgU2luY2Ugd2UgZG9uJ3QgaGF2ZSBhIGNhbGwgaGVyZSwgd2UgYXJ0aWZpY2lhbGx5CiAgICBleHRlbmQgdGhlIHJhbmdlIGNvdmVyZWQgYnkgdGhlIHVud2luZCBpbmZvIGJ5IHBhZGRpbmcgYmVmb3JlIHRoZQogICAgcmVhbCBzdGFydC4gICovCiAJbm9wCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvbW0vaGFzaF9sb3dfNjQuUyBiL2FyY2gvcG93ZXJwYy9tbS9oYXNoX2xvd182NC5TCmluZGV4IDMwNzlmNmIuLjViN2RkNGUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9tbS9oYXNoX2xvd182NC5TCisrKyBiL2FyY2gvcG93ZXJwYy9tbS9oYXNoX2xvd182NC5TCkBAIC0xOTIsOCArMTkyLDggQEAKIAlybGRpY3IJcjMscjAsMyw2My0zCQkvKiByMyA9IChoYXNoICYgbWFzaykgPDwgMyAqLwogCiAJLyogQ2FsbCBwcGNfbWQuaHB0ZV9pbnNlcnQgKi8KLQlsZAlyNixTVEtfUEFSTShyNCkocjEpCS8qIFJldHJlaXZlIG5ldyBwcCBiaXRzICovCi0JbXIJcjQscjI5CQkJLyogUmV0cmVpdmUgdmEgKi8KKwlsZAlyNixTVEtfUEFSTShyNCkocjEpCS8qIFJldHJpZXZlIG5ldyBwcCBiaXRzICovCisJbXIJcjQscjI5CQkJLyogUmV0cmlldmUgdmEgKi8KIAlsaQlyNywwCQkJLyogIWJvbHRlZCwgIXNlY29uZGFyeSAqLwogCWxpCXI4LE1NVV9QQUdFXzRLCQkvKiBwYWdlIHNpemUgKi8KIAlsZAlyOSxTVEtfUEFSTShyOSkocjEpCS8qIHNlZ21lbnQgc2l6ZSAqLwpAQCAtMjE1LDggKzIxNSw4IEBACiAJcmxkaWNyCXIzLHIwLDMsNjMtMwkvKiByMCA9ICh+aGFzaCAmIG1hc2spIDw8IDMgKi8KIAkKIAkvKiBDYWxsIHBwY19tZC5ocHRlX2luc2VydCAqLwotCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmVpdmUgbmV3IHBwIGJpdHMgKi8KLQltcglyNCxyMjkJCQkvKiBSZXRyZWl2ZSB2YSAqLworCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmlldmUgbmV3IHBwIGJpdHMgKi8KKwltcglyNCxyMjkJCQkvKiBSZXRyaWV2ZSB2YSAqLwogCWxpCXI3LEhQVEVfVl9TRUNPTkRBUlkJLyogIWJvbHRlZCwgc2Vjb25kYXJ5ICovCiAJbGkJcjgsTU1VX1BBR0VfNEsJCS8qIHBhZ2Ugc2l6ZSAqLwogCWxkCXI5LFNUS19QQVJNKHI5KShyMSkJLyogc2VnbWVudCBzaXplICovCkBAIC00OTUsOCArNDk1LDggQEAKIAlybGRpY3IJcjMscjAsMyw2My0zCQkvKiByMCA9IChoYXNoICYgbWFzaykgPDwgMyAqLwogCiAJLyogQ2FsbCBwcGNfbWQuaHB0ZV9pbnNlcnQgKi8KLQlsZAlyNixTVEtfUEFSTShyNCkocjEpCS8qIFJldHJlaXZlIG5ldyBwcCBiaXRzICovCi0JbXIJcjQscjI5CQkJLyogUmV0cmVpdmUgdmEgKi8KKwlsZAlyNixTVEtfUEFSTShyNCkocjEpCS8qIFJldHJpZXZlIG5ldyBwcCBiaXRzICovCisJbXIJcjQscjI5CQkJLyogUmV0cmlldmUgdmEgKi8KIAlsaQlyNywwCQkJLyogIWJvbHRlZCwgIXNlY29uZGFyeSAqLwogCWxpCXI4LE1NVV9QQUdFXzRLCQkvKiBwYWdlIHNpemUgKi8KIAlsZAlyOSxTVEtfUEFSTShyOSkocjEpCS8qIHNlZ21lbnQgc2l6ZSAqLwpAQCAtNTIyLDggKzUyMiw4IEBACiAJcmxkaWNyCXIzLHIwLDMsNjMtMwkJLyogcjAgPSAofmhhc2ggJiBtYXNrKSA8PCAzICovCiAKIAkvKiBDYWxsIHBwY19tZC5ocHRlX2luc2VydCAqLwotCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmVpdmUgbmV3IHBwIGJpdHMgKi8KLQltcglyNCxyMjkJCQkvKiBSZXRyZWl2ZSB2YSAqLworCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmlldmUgbmV3IHBwIGJpdHMgKi8KKwltcglyNCxyMjkJCQkvKiBSZXRyaWV2ZSB2YSAqLwogCWxpCXI3LEhQVEVfVl9TRUNPTkRBUlkJLyogIWJvbHRlZCwgc2Vjb25kYXJ5ICovCiAJbGkJcjgsTU1VX1BBR0VfNEsJCS8qIHBhZ2Ugc2l6ZSAqLwogCWxkCXI5LFNUS19QQVJNKHI5KShyMSkJLyogc2VnbWVudCBzaXplICovCkBAIC04MTMsOCArODEzLDggQEAKIAlybGRpY3IJcjMscjAsMyw2My0zCS8qIHIwID0gKGhhc2ggJiBtYXNrKSA8PCAzICovCiAKIAkvKiBDYWxsIHBwY19tZC5ocHRlX2luc2VydCAqLwotCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmVpdmUgbmV3IHBwIGJpdHMgKi8KLQltcglyNCxyMjkJCQkvKiBSZXRyZWl2ZSB2YSAqLworCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmlldmUgbmV3IHBwIGJpdHMgKi8KKwltcglyNCxyMjkJCQkvKiBSZXRyaWV2ZSB2YSAqLwogCWxpCXI3LDAJCQkvKiAhYm9sdGVkLCAhc2Vjb25kYXJ5ICovCiAJbGkJcjgsTU1VX1BBR0VfNjRLCiAJbGQJcjksU1RLX1BBUk0ocjkpKHIxKQkvKiBzZWdtZW50IHNpemUgKi8KQEAgLTgzNiw4ICs4MzYsOCBAQAogCXJsZGljcglyMyxyMCwzLDYzLTMJLyogcjAgPSAofmhhc2ggJiBtYXNrKSA8PCAzICovCiAKIAkvKiBDYWxsIHBwY19tZC5ocHRlX2luc2VydCAqLwotCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmVpdmUgbmV3IHBwIGJpdHMgKi8KLQltcglyNCxyMjkJCQkvKiBSZXRyZWl2ZSB2YSAqLworCWxkCXI2LFNUS19QQVJNKHI0KShyMSkJLyogUmV0cmlldmUgbmV3IHBwIGJpdHMgKi8KKwltcglyNCxyMjkJCQkvKiBSZXRyaWV2ZSB2YSAqLwogCWxpCXI3LEhQVEVfVl9TRUNPTkRBUlkJLyogIWJvbHRlZCwgc2Vjb25kYXJ5ICovCiAJbGkJcjgsTU1VX1BBR0VfNjRLCiAJbGQJcjksU1RLX1BBUk0ocjkpKHIxKQkvKiBzZWdtZW50IHNpemUgKi8KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9tbS9oYXNoX3V0aWxzXzY0LmMgYi9hcmNoL3Bvd2VycGMvbW0vaGFzaF91dGlsc182NC5jCmluZGV4IGE1OTkxZmEuLjU4YTAyMmQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9tbS9oYXNoX3V0aWxzXzY0LmMKKysrIGIvYXJjaC9wb3dlcnBjL21tL2hhc2hfdXRpbHNfNjQuYwpAQCAtNzUzLDcgKzc1Myw3IEBACiAJCW10c3ByKFNQUk5fU0RSMSwgX1NEUjEpOwogCiAJLyogSW5pdGlhbGl6ZSBTVEFCL1NMQi4gV2UgdXNlIGEgdmlydHVhbCBhZGRyZXNzIGFzIGl0IHdvcmtzCi0JICogaW4gcmVhbCBtb2RlIG9uIHBTZXJpZXMgYW5kIHdlIHdhbnQgYSB2aXJ1dGFsIGFkZHJlc3Mgb24KKwkgKiBpbiByZWFsIG1vZGUgb24gcFNlcmllcyBhbmQgd2Ugd2FudCBhIHZpcnR1YWwgYWRkcmVzcyBvbgogCSAqIGlTZXJpZXMgYW55d2F5CiAJICovCiAJaWYgKGNwdV9oYXNfZmVhdHVyZShDUFVfRlRSX1NMQikpCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvbW0vbWVtLmMgYi9hcmNoL3Bvd2VycGMvbW0vbWVtLmMKaW5kZXggYTY2NDk5Ni4uNTdlNTQ1YiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL21tL21lbS5jCisrKyBiL2FyY2gvcG93ZXJwYy9tbS9tZW0uYwpAQCAtNDI0LDcgKzQyNCw3IEBACiAJY2xlYXJfcGFnZShwYWdlKTsKIAogCS8qCi0JICogV2Ugc2hvdWxkbnQgaGF2ZSB0byBkbyB0aGlzLCBidXQgc29tZSB2ZXJzaW9ucyBvZiBnbGliYworCSAqIFdlIHNob3VsZG4ndCBoYXZlIHRvIGRvIHRoaXMsIGJ1dCBzb21lIHZlcnNpb25zIG9mIGdsaWJjCiAJICogcmVxdWlyZSBpdCAobGQuc28gYXNzdW1lcyB6ZXJvIGZpbGxlZCBwYWdlcyBhcmUgaWNhY2hlIGNsZWFuKQogCSAqIC0gQW50b24KIAkgKi8KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9tbS9udW1hLmMgYi9hcmNoL3Bvd2VycGMvbW0vbnVtYS5jCmluZGV4IDBkYzk1YzAuLjVlYzFkYWQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9tbS9udW1hLmMKKysrIGIvYXJjaC9wb3dlcnBjL21tL251bWEuYwpAQCAtNDQwLDExICs0NDAsMTEgQEAKIH0KIAogLyoKLSAqIFJldHJlaXZlIGFuZCB2YWxpZGF0ZSB0aGUgaWJtLGR5bmFtaWMtbWVtb3J5IHByb3BlcnR5IG9mIHRoZSBkZXZpY2UgdHJlZS4KKyAqIFJldHJpZXZlIGFuZCB2YWxpZGF0ZSB0aGUgaWJtLGR5bmFtaWMtbWVtb3J5IHByb3BlcnR5IG9mIHRoZSBkZXZpY2UgdHJlZS4KICAqCiAgKiBUaGUgbGF5b3V0IG9mIHRoZSBpYm0sZHluYW1pYy1tZW1vcnkgcHJvcGVydHkgaXMgYSBudW1iZXIgTiBvZiBtZW1ibG9jawogICogbGlzdCBlbnRyaWVzIGZvbGxvd2VkIGJ5IE4gbWVtYmxvY2sgbGlzdCBlbnRyaWVzLiAgRWFjaCBtZW1ibG9jayBsaXN0IGVudHJ5Ci0gKiBjb250YWlucyBpbmZvcm1hdGlvbiBhcyBsYXllZCBvdXQgaW4gdGhlIG9mX2RyY29uZl9jZWxsIHN0cnVjdCBhYm92ZS4KKyAqIGNvbnRhaW5zIGluZm9ybWF0aW9uIGFzIGxhaWQgb3V0IGluIHRoZSBvZl9kcmNvbmZfY2VsbCBzdHJ1Y3QgYWJvdmUuCiAgKi8KIHN0YXRpYyBpbnQgb2ZfZ2V0X2RyY29uZl9tZW1vcnkoc3RydWN0IGRldmljZV9ub2RlICptZW1vcnksIGNvbnN0IHUzMiAqKmRtKQogewpAQCAtNDY4LDcgKzQ2OCw3IEBACiB9CiAKIC8qCi0gKiBSZXRyZWl2ZSBhbmQgdmFsaWRhdGUgdGhlIGlibSxsbWItc2l6ZSBwcm9wZXJ0eSBmb3IgZHJjb25mIG1lbW9yeQorICogUmV0cmlldmUgYW5kIHZhbGlkYXRlIHRoZSBpYm0sbG1iLXNpemUgcHJvcGVydHkgZm9yIGRyY29uZiBtZW1vcnkKICAqIGZyb20gdGhlIGRldmljZSB0cmVlLgogICovCiBzdGF0aWMgdTY0IG9mX2dldF9sbWJfc2l6ZShzdHJ1Y3QgZGV2aWNlX25vZGUgKm1lbW9yeSkKQEAgLTQ5MCw3ICs0OTAsNyBAQAogfTsKIAogLyoKLSAqIFJldHJlaXZlIGFuZCB2YWxpZGF0ZSB0aGUgbGlzdCBvZiBhc3NvY2lhdGl2aXR5IGFycmF5cyBmb3IgZHJjb25mCisgKiBSZXRyaWV2ZSBhbmQgdmFsaWRhdGUgdGhlIGxpc3Qgb2YgYXNzb2NpYXRpdml0eSBhcnJheXMgZm9yIGRyY29uZgogICogbWVtb3J5IGZyb20gdGhlIGlibSxhc3NvY2lhdGl2aXR5LWxvb2t1cC1hcnJheXMgcHJvcGVydHkgb2YgdGhlCiAgKiBkZXZpY2UgdHJlZS4uCiAgKgpAQCAtNjA0LDcgKzYwNCw3IEBACiAgKiBSZXR1cm5zIHRoZSBzaXplIHRoZSByZWdpb24gc2hvdWxkIGhhdmUgdG8gZW5mb3JjZSB0aGUgbWVtb3J5IGxpbWl0LgogICogVGhpcyB3aWxsIGVpdGhlciBiZSB0aGUgb3JpZ2luYWwgdmFsdWUgb2Ygc2l6ZSwgYSB0cnVuY2F0ZWQgdmFsdWUsCiAgKiBvciB6ZXJvLiBJZiB0aGUgcmV0dXJuZWQgdmFsdWUgb2Ygc2l6ZSBpcyAwIHRoZSByZWdpb24gc2hvdWxkIGJlCi0gKiBkaXNjYXJkZWQgYXMgaXQgbGllcyB3aG9seSBhYm92ZSB0aGUgbWVtb3J5IGxpbWl0LgorICogZGlzY2FyZGVkIGFzIGl0IGxpZXMgd2hvbGx5IGFib3ZlIHRoZSBtZW1vcnkgbGltaXQuCiAgKi8KIHN0YXRpYyB1bnNpZ25lZCBsb25nIF9faW5pdCBudW1hX2VuZm9yY2VfbWVtb3J5X2xpbWl0KHVuc2lnbmVkIGxvbmcgc3RhcnQsCiAJCQkJCQkgICAgICB1bnNpZ25lZCBsb25nIHNpemUpCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvbW0vdGxiX2xvd182NGUuUyBiL2FyY2gvcG93ZXJwYy9tbS90bGJfbG93XzY0ZS5TCmluZGV4IDIyMjgxNTEuLmFmMDg5MjIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9tbS90bGJfbG93XzY0ZS5TCisrKyBiL2FyY2gvcG93ZXJwYy9tbS90bGJfbG93XzY0ZS5TCkBAIC0xOTIsNyArMTkyLDcgQEAKIAlvcglyMTAscjE1LHIxNAogCiBCRUdJTl9NTVVfRlRSX1NFQ1RJT04KLQkvKiBTZXQgdGhlIFRMQiByZXNlcnZhdGlvbiBhbmQgc2VhY2ggZm9yIGV4aXN0aW5nIGVudHJ5LiBUaGVuIGxvYWQKKwkvKiBTZXQgdGhlIFRMQiByZXNlcnZhdGlvbiBhbmQgc2VhcmNoIGZvciBleGlzdGluZyBlbnRyeS4gVGhlbiBsb2FkCiAJICogdGhlIGVudHJ5LgogCSAqLwogCVBQQ19UTEJTUlhfRE9UKDAscjE2KQpAQCAtNDI1LDcgKzQyNSw3IEBACiAKIHZpcnRfcGFnZV90YWJsZV90bGJfbWlzc19mYXVsdDoKIAkvKiBJZiB3ZSBmYXVsdCBoZXJlLCB0aGluZ3MgYXJlIGEgbGl0dGxlIGJpdCB0cmlja3kuIFdlIG5lZWQgdG8gY2FsbAotCSAqIGVpdGhlciBkYXRhIG9yIGluc3RydWN0aW9uIHN0b3JlIGZhdWx0LCBhbmQgd2UgbmVlZCB0byByZXRyZWl2ZQorCSAqIGVpdGhlciBkYXRhIG9yIGluc3RydWN0aW9uIHN0b3JlIGZhdWx0LCBhbmQgd2UgbmVlZCB0byByZXRyaWV2ZQogCSAqIHRoZSBvcmlnaW5hbCBmYXVsdCBhZGRyZXNzIGFuZCBFU1IgKGZvciBkYXRhKS4KIAkgKgogCSAqIFRoZSB0aGluZyBpcywgd2Uga25vdyB0aGF0IGluIG5vcm1hbCBjaXJjdW1zdGFuY2VzLCB0aGlzIGlzCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvb3Byb2ZpbGUvb3BfbW9kZWxfY2VsbC5jIGIvYXJjaC9wb3dlcnBjL29wcm9maWxlL29wX21vZGVsX2NlbGwuYwppbmRleCBjNGQyYjcxLi5jYjUxNWNmIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvb3Byb2ZpbGUvb3BfbW9kZWxfY2VsbC5jCisrKyBiL2FyY2gvcG93ZXJwYy9vcHJvZmlsZS9vcF9tb2RlbF9jZWxsLmMKQEAgLTY3LDcgKzY3LDcgQEAKIAogI2RlZmluZSBNQVhfU1BVX0NPVU5UIDB4RkZGRkZGCS8qIG1heGltdW0gMjQgYml0IExGU1IgdmFsdWUgKi8KIAotLyogTWludW11bSBIVyBpbnRlcnZhbCB0aW1lciBzZXR0aW5nIHRvIHNlbmQgdmFsdWUgdG8gdHJhY2UgYnVmZmVyIGlzIDEwIGN5Y2xlLgorLyogTWluaW11bSBIVyBpbnRlcnZhbCB0aW1lciBzZXR0aW5nIHRvIHNlbmQgdmFsdWUgdG8gdHJhY2UgYnVmZmVyIGlzIDEwIGN5Y2xlLgogICogVG8gY29uZmlndXJlIGNvdW50ZXIgdG8gc2VuZCB2YWx1ZSBldmVyeSBOIGN5Y2xlcyBzZXQgY291bnRlciB0bwogICogMl4zMiAtIDEgLSBOLgogICovCkBAIC0xNDcwLDcgKzE0NzAsNyBAQAogICogdHJhY2UgYnVmZmVyIGF0IHRoZSBtYXhpbXVtIHJhdGUgcG9zc2libGUuICBUaGUgdHJhY2UgYnVmZmVyIGlzIGNvbmZpZ3VyZWQKICAqIHRvIHN0b3JlIHRoZSBQQ3MsIHdyYXBwaW5nIHdoZW4gaXQgaXMgZnVsbC4gIFRoZSBwZXJmb3JtYW5jZSBjb3VudGVyIGlzCiAgKiBpbml0aWFsaXplZCB0byB0aGUgbWF4IGhhcmR3YXJlIGNvdW50IG1pbnVzIHRoZSBudW1iZXIgb2YgZXZlbnRzLCBOLCBiZXR3ZWVuCi0gKiBzYW1wbGVzLiAgT25jZSB0aGUgTiBldmVudHMgaGF2ZSBvY2N1cmVkLCBhIEhXIGNvdW50ZXIgb3ZlcmZsb3cgb2NjdXJzCisgKiBzYW1wbGVzLiAgT25jZSB0aGUgTiBldmVudHMgaGF2ZSBvY2N1cnJlZCwgYSBIVyBjb3VudGVyIG92ZXJmbG93IG9jY3VycwogICogY2F1c2luZyB0aGUgZ2VuZXJhdGlvbiBvZiBhIEhXIGNvdW50ZXIgaW50ZXJydXB0IHdoaWNoIGFsc28gc3RvcHMgdGhlCiAgKiB3cml0aW5nIG9mIHRoZSBTUFUgUEMgdmFsdWVzIHRvIHRoZSB0cmFjZSBidWZmZXIuICBIZW5jZSB0aGUgbGFzdCBQQwogICogd3JpdHRlbiB0byB0aGUgdHJhY2UgYnVmZmVyIGlzIHRoZSBTUFUgUEMgdGhhdCB3ZSB3YW50LiAgVW5mb3J0dW5hdGVseSwKQEAgLTE2NTYsNyArMTY1Niw3IEBACiAJCSAqIFRoZSBjb3VudGVycyB3ZXJlIGZyb3plbiBieSB0aGUgaW50ZXJydXB0LgogCQkgKiBSZWVuYWJsZSB0aGUgaW50ZXJydXB0IGFuZCByZXN0YXJ0IHRoZSBjb3VudGVycy4KIAkJICogSWYgdGhlcmUgd2FzIGEgcmFjZSBiZXR3ZWVuIHRoZSBpbnRlcnJ1cHQgaGFuZGxlciBhbmQKLQkJICogdGhlIHZpcnR1YWwgY291bnRlciByb3V0aW5lLgkgVGhlIHZpcnV0YWwgY291bnRlcgorCQkgKiB0aGUgdmlydHVhbCBjb3VudGVyIHJvdXRpbmUuCSBUaGUgdmlydHVhbCBjb3VudGVyCiAJCSAqIHJvdXRpbmUgbWF5IGhhdmUgY2xlYXJlZCB0aGUgaW50ZXJydXB0cy4gIEhlbmNlIG11c3QKIAkJICogdXNlIHRoZSB2aXJ0X2NudHJfaW50ZXJfbWFzayB0byByZS1lbmFibGUgdGhlIGludGVycnVwdHMuCiAJCSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL29wcm9maWxlL29wX21vZGVsX3Bvd2VyNC5jIGIvYXJjaC9wb3dlcnBjL29wcm9maWxlL29wX21vZGVsX3Bvd2VyNC5jCmluZGV4IDgwNzc0MDkuLjhlZTUxYTIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9vcHJvZmlsZS9vcF9tb2RlbF9wb3dlcjQuYworKysgYi9hcmNoL3Bvd2VycGMvb3Byb2ZpbGUvb3BfbW9kZWxfcG93ZXI0LmMKQEAgLTIwNyw3ICsyMDcsNyBAQAogCXVuc2lnbmVkIGxvbmcgbW1jcmE7CiAJdW5zaWduZWQgbG9uZyBzbG90OwogCi0JLyogQ2FudCBkbyBtdWNoIGFib3V0IGl0ICovCisJLyogQ2FuJ3QgZG8gbXVjaCBhYm91dCBpdCAqLwogCWlmICghY3VyX2NwdV9zcGVjLT5vcHJvZmlsZV9tbWNyYV9zaWh2KQogCQlyZXR1cm4gcGM7CiAKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvNTJ4eC9tcGM1Mnh4X2xwYmZpZm8uYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvNTJ4eC9tcGM1Mnh4X2xwYmZpZm8uYwppbmRleCA2Mzg1ZDg4Li45OTQwY2U4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzUyeHgvbXBjNTJ4eF9scGJmaWZvLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy81Mnh4L21wYzUyeHhfbHBiZmlmby5jCkBAIC01Nyw3ICs1Nyw3IEBACiBzdGF0aWMgc3RydWN0IG1wYzUyeHhfbHBiZmlmbyBscGJmaWZvOwogCiAvKioKLSAqIG1wYzUyeHhfbHBiZmlmb19raWNrIC0gVHJpZ2dlciB0aGUgbmV4dCBibG9jayBvZiBkYXRhIHRvIGJlIHRyYW5zZmVyZWQKKyAqIG1wYzUyeHhfbHBiZmlmb19raWNrIC0gVHJpZ2dlciB0aGUgbmV4dCBibG9jayBvZiBkYXRhIHRvIGJlIHRyYW5zZmVycmVkCiAgKi8KIHN0YXRpYyB2b2lkIG1wYzUyeHhfbHBiZmlmb19raWNrKHN0cnVjdCBtcGM1Mnh4X2xwYmZpZm9fcmVxdWVzdCAqcmVxKQogewpAQCAtMTc5LDcgKzE3OSw3IEBACiAgKgogICogT24gdHJhbnNtaXQsIHRoZSBkbWEgY29tcGxldGlvbiBpcnEgdHJpZ2dlcnMgYmVmb3JlIHRoZSBmaWZvIGNvbXBsZXRpb24KICAqIHRyaWdnZXJzLiAgSGFuZGxlIHRoZSBkbWEgY29tcGxldGlvbiBoZXJlIGluc3RlYWQgb2YgdGhlIExQQiBGSUZPIEJlc3Rjb21tCi0gKiB0YXNrIGNvbXBsZXRpb24gaXJxIGJlY3Vhc2UgZXZlcnl0aW5nIGlzIG5vdCByZWFsbHkgZG9uZSB1bnRpbCB0aGUgTFBCIEZJRk8KKyAqIHRhc2sgY29tcGxldGlvbiBpcnEgYmVjYXVzZSBldmVyeXRoaW5nIGlzIG5vdCByZWFsbHkgZG9uZSB1bnRpbCB0aGUgTFBCIEZJRk8KICAqIGNvbXBsZXRpb24gaXJxIHRyaWdnZXJzLgogICoKICAqIEluIG90aGVyIHdvcmRzOgpAQCAtMTk1LDcgKzE5NSw3IEBACiAgKiBFeGl0IGNvbmRpdGlvbnM6CiAgKiAxKSBUcmFuc2ZlciBhYm9ydGVkCiAgKiAyKSBGSUZPIGNvbXBsZXRlIHdpdGhvdXQgRE1BOyBtb3JlIGRhdGEgdG8gZG8KLSAqIDMpIEZJRk8gY29tcGxldGUgd2l0aG91dCBETUE7IGFsbCBkYXRhIHRyYW5zZmVyZWQKKyAqIDMpIEZJRk8gY29tcGxldGUgd2l0aG91dCBETUE7IGFsbCBkYXRhIHRyYW5zZmVycmVkCiAgKiA0KSBGSUZPIGNvbXBsZXRlIHVzaW5nIERNQQogICoKICAqIENvbmRpdGlvbiAxIGNhbiBvY2N1ciByZWdhcmRsZXNzIG9mIHdoZXRoZXIgb3Igbm90IERNQSBpcyB1c2VkLgpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy81Mnh4L21wYzUyeHhfcGljLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzUyeHgvbXBjNTJ4eF9waWMuYwppbmRleCAzZGRlYTk2Li4xZGQxNTQwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzUyeHgvbXBjNTJ4eF9waWMuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzUyeHgvbXBjNTJ4eF9waWMuYwpAQCAtNTEyLDcgKzUxMiw3IEBACiAvKioKICAqIG1wYzUyeHhfZ2V0X2lycSAtIEdldCBwZW5kaW5nIGludGVycnVwdCBudW1iZXIgaG9vayBmdW5jdGlvbgogICoKLSAqIENhbGxlZCBieSB0aGUgaW50ZXJ1cHQgaGFuZGxlciB0byBkZXRlcm1pbmUgd2hhdCBJUlEgaGFuZGxlciBuZWVkcyB0byBiZQorICogQ2FsbGVkIGJ5IHRoZSBpbnRlcnJ1cHQgaGFuZGxlciB0byBkZXRlcm1pbmUgd2hhdCBJUlEgaGFuZGxlciBuZWVkcyB0byBiZQogICogZXhlY3V0ZWQuCiAgKgogICogU3RhdHVzIG9mIHBlbmRpbmcgaW50ZXJydXB0cyBpcyBkZXRlcm1pbmVkIGJ5IHJlYWRpbmcgdGhlIGVuY29kZWQgc3RhdHVzCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvc3B1ZnMvbHNjc2FfYWxsb2MuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9sc2NzYV9hbGxvYy5jCmluZGV4IDNiODk0ZjUuLjE0NzA2OTkgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9sc2NzYV9hbGxvYy5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9sc2NzYV9hbGxvYy5jCkBAIC05MCw3ICs5MCw3IEBACiAJICovCiAJZm9yIChpID0gMDsgaSA8IFNQVV9MU0NTQV9OVU1fQklHX1BBR0VTOyBpKyspIHsKIAkJLyogWFhYIFRoaXMgaXMgbGlrZWx5IHRvIGZhaWwsIHdlIHNob3VsZCB1c2UgYSBzcGVjaWFsIHBvb2wKLQkJICogICAgIHNpbWlsaWFyIHRvIHdoYXQgaHVnZXRsYmZzIGRvZXMuCisJCSAqICAgICBzaW1pbGFyIHRvIHdoYXQgaHVnZXRsYmZzIGRvZXMuCiAJCSAqLwogCQljc2EtPmxzY3NhX3BhZ2VzW2ldID0gYWxsb2NfcGFnZXMoR0ZQX0tFUk5FTCwKIAkJCQkJCSAgU1BVXzY0S19QQUdFX09SREVSKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9zY2hlZC5jIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL3NwdWZzL3NjaGVkLmMKaW5kZXggMGIwNDY2Mi4uNjUyMDM4NSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL3NwdWZzL3NjaGVkLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL3NwdWZzL3NjaGVkLmMKQEAgLTg0Niw3ICs4NDYsNyBAQAogCQlzdHJ1Y3QgbGlzdF9oZWFkICpycSA9ICZzcHVfcHJpby0+cnVucVtiZXN0XTsKIAogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGN0eCwgcnEsIHJxKSB7Ci0JCQkvKiBYWFgoaGNoKTogY2hlY2sgZm9yIGFmZmluaXR5IGhlcmUgYXN3ZWxsICovCisJCQkvKiBYWFgoaGNoKTogY2hlY2sgZm9yIGFmZmluaXR5IGhlcmUgYXMgd2VsbCAqLwogCQkJaWYgKF9fbm9kZV9hbGxvd2VkKGN0eCwgbm9kZSkpIHsKIAkJCQlfX3NwdV9kZWxfZnJvbV9ycShjdHgpOwogCQkJCWdvdG8gZm91bmQ7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvc3B1ZnMvc3B1X3Jlc3RvcmUuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9zcHVfcmVzdG9yZS5jCmluZGV4IDIxYTljOTUuLjcyYzkwNWYgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9zcHVfcmVzdG9yZS5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9zcHVfcmVzdG9yZS5jCkBAIC0yODQsNyArMjg0LDcgQEAKIAkJZXhpdF9pbnN0cnNbM10gPSBCUl9JTlNUUjsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJLyogU1BVX1N0YXR1c1tSXT0xLiBObyBhZGRpdG9uYWwgaW5zdHJ1Y3Rpb25zLiAqLworCQkvKiBTUFVfU3RhdHVzW1JdPTEuIE5vIGFkZGl0aW9uYWwgaW5zdHJ1Y3Rpb25zLiAqLwogCQlicmVhazsKIAl9CiAJc3B1X3N5bmMoKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvaXNlcmllcy9tZi5jIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL21mLmMKaW5kZXggYjVlMDI2Yi4uNjJkYWJlMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL21mLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL21mLmMKQEAgLTUxLDcgKzUxLDcgQEAKIHN0YXRpYyBpbnQgbWZfaW5pdGlhbGl6ZWQ7CiAKIC8qCi0gKiBUaGlzIGlzIHRoZSBzdHJ1Y3R1cmUgbGF5b3V0IGZvciB0aGUgTWFjaGluZSBGYWNpbGl0ZXMgTFBBUiBldmVudAorICogVGhpcyBpcyB0aGUgc3RydWN0dXJlIGxheW91dCBmb3IgdGhlIE1hY2hpbmUgRmFjaWxpdGllcyBMUEFSIGV2ZW50CiAgKiBmbG93cy4KICAqLwogc3RydWN0IHZzcF9jbWRfZGF0YSB7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2lzZXJpZXMvdmlvcGF0aC5jIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL3Zpb3BhdGguYwppbmRleCBiNWYwNWQ5Li4yMzc2MDY5IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2lzZXJpZXMvdmlvcGF0aC5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvaXNlcmllcy92aW9wYXRoLmMKQEAgLTM5Niw3ICszOTYsNyBAQAogCQkJdmlvcGF0aFN0YXR1c1tyZW1vdGVMcF0ubVRhcmdldEluc3QpKSB7CiAJCQlwcmludGsoVklPUEFUSF9LRVJOX1dBUk4KIAkJCSAgICAgICAibWVzc2FnZSBmcm9tIGludmFsaWQgcGFydGl0aW9uLiAiCi0JCQkgICAgICAgImludCBtc2cgcmN2ZCwgc291cmNlIGluc3QgKCVkKSBkb2VzbnQgbWF0Y2ggKCVkKVxuIiwKKwkJCSAgICAgICAiaW50IG1zZyByY3ZkLCBzb3VyY2UgaW5zdCAoJWQpIGRvZXNuJ3QgbWF0Y2ggKCVkKVxuIiwKIAkJCSAgICAgICB2aW9wYXRoU3RhdHVzW3JlbW90ZUxwXS5tVGFyZ2V0SW5zdCwKIAkJCSAgICAgICBldmVudC0+eFNvdXJjZUluc3RhbmNlSWQpOwogCQkJcmV0dXJuOwpAQCAtNDA3LDcgKzQwNyw3IEBACiAJCQl2aW9wYXRoU3RhdHVzW3JlbW90ZUxwXS5tU291cmNlSW5zdCkpIHsKIAkJCXByaW50ayhWSU9QQVRIX0tFUk5fV0FSTgogCQkJICAgICAgICJtZXNzYWdlIGZyb20gaW52YWxpZCBwYXJ0aXRpb24uICIKLQkJCSAgICAgICAiaW50IG1zZyByY3ZkLCB0YXJnZXQgaW5zdCAoJWQpIGRvZXNudCBtYXRjaCAoJWQpXG4iLAorCQkJICAgICAgICJpbnQgbXNnIHJjdmQsIHRhcmdldCBpbnN0ICglZCkgZG9lc24ndCBtYXRjaCAoJWQpXG4iLAogCQkJICAgICAgIHZpb3BhdGhTdGF0dXNbcmVtb3RlTHBdLm1Tb3VyY2VJbnN0LAogCQkJICAgICAgIGV2ZW50LT54VGFyZ2V0SW5zdGFuY2VJZCk7CiAJCQlyZXR1cm47CkBAIC00MTgsNyArNDE4LDcgQEAKIAkJICAgIHZpb3BhdGhTdGF0dXNbcmVtb3RlTHBdLm1Tb3VyY2VJbnN0KSB7CiAJCQlwcmludGsoVklPUEFUSF9LRVJOX1dBUk4KIAkJCSAgICAgICAibWVzc2FnZSBmcm9tIGludmFsaWQgcGFydGl0aW9uLiAiCi0JCQkgICAgICAgImFjayBtc2cgcmN2ZCwgc291cmNlIGluc3QgKCVkKSBkb2VzbnQgbWF0Y2ggKCVkKVxuIiwKKwkJCSAgICAgICAiYWNrIG1zZyByY3ZkLCBzb3VyY2UgaW5zdCAoJWQpIGRvZXNuJ3QgbWF0Y2ggKCVkKVxuIiwKIAkJCSAgICAgICB2aW9wYXRoU3RhdHVzW3JlbW90ZUxwXS5tU291cmNlSW5zdCwKIAkJCSAgICAgICBldmVudC0+eFNvdXJjZUluc3RhbmNlSWQpOwogCQkJcmV0dXJuOwpAQCAtNDI4LDcgKzQyOCw3IEBACiAJCSAgICB2aW9wYXRoU3RhdHVzW3JlbW90ZUxwXS5tVGFyZ2V0SW5zdCkgewogCQkJcHJpbnRrKFZJT1BBVEhfS0VSTl9XQVJOCiAJCQkgICAgICAgIm1lc3NhZ2UgZnJvbSBpbnZhbGlkIHBhcnRpdGlvbi4gIgotCQkJICAgICAgICJ2aW9wYXRoOiBhY2sgbXNnIHJjdmQsIHRhcmdldCBpbnN0ICglZCkgZG9lc250IG1hdGNoICglZClcbiIsCisJCQkgICAgICAgInZpb3BhdGg6IGFjayBtc2cgcmN2ZCwgdGFyZ2V0IGluc3QgKCVkKSBkb2Vzbid0IG1hdGNoICglZClcbiIsCiAJCQkgICAgICAgdmlvcGF0aFN0YXR1c1tyZW1vdGVMcF0ubVRhcmdldEluc3QsCiAJCQkgICAgICAgZXZlbnQtPnhUYXJnZXRJbnN0YW5jZUlkKTsKIAkJCXJldHVybjsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcGFzZW1pL2RtYV9saWIuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcGFzZW1pL2RtYV9saWIuYwppbmRleCAwOTY5NWFlLi4zMjFhOWIzIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bhc2VtaS9kbWFfbGliLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wYXNlbWkvZG1hX2xpYi5jCkBAIC0zNzksOSArMzc5LDkgQEAKIH0KIEVYUE9SVF9TWU1CT0wocGFzZW1pX2RtYV9mcmVlX2J1Zik7CiAKLS8qIHBhc2VtaV9kbWFfYWxsb2NfZmxhZyAtIEFsbG9jYXRlIGEgZmxhZyAoZXZlbnQpIGZvciBjaGFubmVsIHN5bmNyb25pemF0aW9uCisvKiBwYXNlbWlfZG1hX2FsbG9jX2ZsYWcgLSBBbGxvY2F0ZSBhIGZsYWcgKGV2ZW50KSBmb3IgY2hhbm5lbCBzeW5jaHJvbml6YXRpb24KICAqCi0gKiBBbGxvY2F0ZXMgYSBmbGFnIGZvciB1c2Ugd2l0aCBjaGFubmVsIHN5bmNyb25pemF0aW9uIChldmVudCBkZXNjcmlwdG9ycykuCisgKiBBbGxvY2F0ZXMgYSBmbGFnIGZvciB1c2Ugd2l0aCBjaGFubmVsIHN5bmNocm9uaXphdGlvbiAoZXZlbnQgZGVzY3JpcHRvcnMpLgogICogUmV0dXJucyBhbGxvY2F0ZWQgZmxhZyAoMC02MyksIDwgMCBvbiBlcnJvci4KICAqLwogaW50IHBhc2VtaV9kbWFfYWxsb2NfZmxhZyh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm1hYy9NYWtlZmlsZSBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJtYWMvTWFrZWZpbGUKaW5kZXggNTBmMTY5My4uZWE0N2RmNiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm1hYy9NYWtlZmlsZQorKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL01ha2VmaWxlCkBAIC0xMSw3ICsxMSw3IEBACiBvYmotJChDT05GSUdfUE1BQ19CQUNLTElHSFQpCSs9IGJhY2tsaWdodC5vCiBvYmotJChDT05GSUdfQ1BVX0ZSRVFfUE1BQykJKz0gY3B1ZnJlcV8zMi5vCiBvYmotJChDT05GSUdfQ1BVX0ZSRVFfUE1BQzY0KQkrPSBjcHVmcmVxXzY0Lm8KLSMgQ09ORklHX05WUkFNIGlzIGFuIGFyY2guIGluZGVwZW5kYW50IHRyaXN0YXRlIHN5bWJvbCwgZm9yIHBtYWMzMiB3ZSByZWFsbHkKKyMgQ09ORklHX05WUkFNIGlzIGFuIGFyY2guIGluZGVwZW5kZW50IHRyaXN0YXRlIHN5bWJvbCwgZm9yIHBtYWMzMiB3ZSByZWFsbHkKICMgbmVlZCB0aGlzIHRvIGJlIGEgYm9vbC4gIENoZWF0IGhlcmUgYW5kIHByZXRlbmQgQ09ORklHX05WUkFNPW0gaXMgcmVhbGx5CiAjIENPTkZJR19OVlJBTT15CiBvYmotJChDT05GSUdfTlZSQU06bT15KQkJKz0gbnZyYW0ubwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm1hYy9sb3dfaTJjLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL2xvd19pMmMuYwppbmRleCA0ODA1NjdlLi5lOWM4YTYwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL2xvd19pMmMuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL2xvd19pMmMuYwpAQCAtOTA0LDcgKzkwNCw3IEBACiAJcHJpbnRrKEtFUk5fSU5GTyAiU01VIGkyYyAlc1xuIiwgY29udHJvbGxlci0+ZnVsbF9uYW1lKTsKIAogCS8qIExvb2sgZm9yIGNoaWxkcywgbm90ZSB0aGF0IHRoZXkgbWlnaHQgbm90IGJlIG9mIHRoZSByaWdodAotCSAqIHR5cGUgYXMgb2xkZXIgZGV2aWNlIHRyZWVzIG1peCBpMmMgYnVzc2VzIGFuZCBvdGhlciB0aGlnbnMKKwkgKiB0eXBlIGFzIG9sZGVyIGRldmljZSB0cmVlcyBtaXggaTJjIGJ1c3NlcyBhbmQgb3RoZXIgdGhpbmdzCiAJICogYXQgdGhlIHNhbWUgbGV2ZWwKIAkgKi8KIAlmb3IgKGJ1c25vZGUgPSBOVUxMOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm1hYy9wY2kuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJtYWMvcGNpLmMKaW5kZXggYWI2ODk4OS4uZjMzZTA4ZCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm1hYy9wY2kuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL3BjaS5jCkBAIC0yOTksNyArMjk5LDcgQEAKICAqIFRoaXMgZnVuY3Rpb24gZGVhbHMgd2l0aCBzb21lICJzcGVjaWFsIGNhc2VzIiBkZXZpY2VzLgogICoKICAqICAwIC0+IE5vIHNwZWNpYWwgY2FzZQotICogIDEgLT4gU2tpcCB0aGUgZGV2aWNlIGJ1dCBhY3QgYXMgaWYgdGhlIGFjY2VzcyB3YXMgc3VjY2Vzc2Z1bGwKKyAqICAxIC0+IFNraXAgdGhlIGRldmljZSBidXQgYWN0IGFzIGlmIHRoZSBhY2Nlc3Mgd2FzIHN1Y2Nlc3NmdWwKICAqICAgICAgIChyZXR1cm4gMHhmZidzIG9uIHJlYWRzLCBldmVudHVhbGx5LCBjYWNoZSBjb25maWcgc3BhY2UKICAqICAgICAgIGFjY2Vzc2VzIGluIGEgbGF0ZXIgdmVyc2lvbikKICAqIC0xIC0+IEhpZGUgdGhlIGRldmljZSAodW5zdWNjZXNzZnVsIGFjY2VzcykKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9kbHBhci5jIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL2RscGFyLmMKaW5kZXggYjc0YTkyMy4uNTdjZWI5MiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL2RscGFyLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL2RscGFyLmMKQEAgLTc0LDcgKzc0LDcgQEAKIAkJcmV0dXJuIE5VTEw7CiAKIAkvKiBUaGUgY29uZmlndXJlIGNvbm5lY3RvciByZXBvcnRlZCBuYW1lIGRvZXMgbm90IGNvbnRhaW4gYQotCSAqIHByZWNlZWRpbmcgJy8nLCBzbyB3ZSBhbGxvY2F0ZSBhIGJ1ZmZlciBsYXJnZSBlbm91Z2ggdG8KKwkgKiBwcmVjZWRpbmcgJy8nLCBzbyB3ZSBhbGxvY2F0ZSBhIGJ1ZmZlciBsYXJnZSBlbm91Z2ggdG8KIAkgKiBwcmVwZW5kIHRoaXMgdG8gdGhlIGZ1bGxfbmFtZS4KIAkgKi8KIAluYW1lID0gKGNoYXIgKiljY3dhICsgY2N3YS0+bmFtZV9vZmZzZXQ7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvZWVoLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvZWVoLmMKaW5kZXggM2NjNGQxMC4uODk2NDkxNyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL2VlaC5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9lZWguYwpAQCAtNjUsNyArNjUsNyBAQAogICogIHdpdGggRUVILgogICoKICAqICBJZGVhbGx5LCBhIFBDSSBkZXZpY2UgZHJpdmVyLCB3aGVuIHN1c3BlY3RpbmcgdGhhdCBhbiBpc29sYXRpb24KLSAqICBldmVudCBoYXMgb2NjdXJlZCAoZS5nLiBieSByZWFkaW5nIDB4ZmYncyksIHdpbGwgdGhlbiBhc2sgRUVICisgKiAgZXZlbnQgaGFzIG9jY3VycmVkIChlLmcuIGJ5IHJlYWRpbmcgMHhmZidzKSwgd2lsbCB0aGVuIGFzayBFRUgKICAqICB3aGV0aGVyIHRoaXMgaXMgdGhlIGNhc2UsIGFuZCB0aGVuIHRha2UgYXBwcm9wcmlhdGUgc3RlcHMgdG8KICAqICByZXNldCB0aGUgUENJIHNsb3QsIHRoZSBQQ0kgZGV2aWNlLCBhbmQgdGhlbiByZXN1bWUgb3BlcmF0aW9ucy4KICAqICBIb3dldmVyLCB1bnRpbCB0aGF0IGRheSwgIHRoZSBjaGVja2luZyBpcyBkb25lIGhlcmUsIHdpdGggdGhlCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvaG90cGx1Zy1jcHUuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9ob3RwbHVnLWNwdS5jCmluZGV4IGZkNTBjY2QuLmVmOGM0NTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9ob3RwbHVnLWNwdS5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9ob3RwbHVnLWNwdS5jCkBAIC0yMTYsNyArMjE2LDcgQEAKIAkJICAgICAgIGNwdSwgcGNwdSwgY3B1X3N0YXR1cyk7CiAJfQogCi0JLyogSXNvbGF0aW9uIGFuZCBkZWFsbG9jYXRpb24gYXJlIGRlZmluYXRseSBkb25lIGJ5CisJLyogSXNvbGF0aW9uIGFuZCBkZWFsbG9jYXRpb24gYXJlIGRlZmluaXRlbHkgZG9uZSBieQogCSAqIGRyc2xvdF9jaHJwX2NwdS4gIElmIHRoZXkgd2VyZSBub3QgdGhleSB3b3VsZCBiZQogCSAqIGRvbmUgaGVyZS4gIENoYW5nZSBpc29sYXRlIHN0YXRlIHRvIElzb2xhdGUgYW5kCiAJICogY2hhbmdlIGFsbG9jYXRpb24tc3RhdGUgdG8gVW51c2FibGUuCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvaW9tbXUuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9pb21tdS5jCmluZGV4IDE1NGM0NjQuLjZkNTQxMmEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9pb21tdS5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9pb21tdS5jCkBAIC0yNzIsNyArMjcyLDcgQEAKIAlyZXR1cm4gdGNlX3JldDsKIH0KIAotLyogdGhpcyBpcyBjb21wYXRhYmxlIHdpdGggY2VsbHMgZm9yIHRoZSBkZXZpY2UgdHJlZSBwcm9wZXJ0eSAqLworLyogdGhpcyBpcyBjb21wYXRpYmxlIHdpdGggY2VsbHMgZm9yIHRoZSBkZXZpY2UgdHJlZSBwcm9wZXJ0eSAqLwogc3RydWN0IGR5bmFtaWNfZG1hX3dpbmRvd19wcm9wIHsKIAlfX2JlMzIJbGlvYm47CQkvKiB0Y2UgdGFibGUgbnVtYmVyICovCiAJX19iZTY0CWRtYV9iYXNlOwkvKiBhZGRyZXNzIGhpLGxvICovCkBAIC05NzYsNyArOTc2LDcgQEAKIAlwcl9kZWJ1ZygicGNpX2RtYV9kZXZfc2V0dXBfcFNlcmllc0xQOiAlc1xuIiwgcGNpX25hbWUoZGV2KSk7CiAKIAkvKiBkZXYgc2V0dXAgZm9yIExQQVIgaXMgYSBsaXR0bGUgdHJpY2t5LCBzaW5jZSB0aGUgZGV2aWNlIHRyZWUgbWlnaHQKLQkgKiBjb250YWluIHRoZSBkbWEtd2luZG93IHByb3BlcnRpZXMgcGVyLWRldmljZSBhbmQgbm90IG5lY2Nlc2FyaWx5CisJICogY29udGFpbiB0aGUgZG1hLXdpbmRvdyBwcm9wZXJ0aWVzIHBlci1kZXZpY2UgYW5kIG5vdCBuZWNlc3NhcmlseQogCSAqIGZvciB0aGUgYnVzLiBTbyB3ZSBuZWVkIHRvIHNlYXJjaCB1cHdhcmRzIGluIHRoZSB0cmVlIHVudGlsIHdlCiAJICogZWl0aGVyIGhpdCBhIGRtYS13aW5kb3cgcHJvcGVydHksIE9SIGZpbmQgYSBwYXJlbnQgd2l0aCBhIHRhYmxlCiAJICogYWxyZWFkeSBhbGxvY2F0ZWQuCkBAIC0xMDMzLDcgKzEwMzMsNyBAQAogCiAJCS8qCiAJCSAqIHRoZSBkZXZpY2UgdHJlZSBtaWdodCBjb250YWluIHRoZSBkbWEtd2luZG93IHByb3BlcnRpZXMKLQkJICogcGVyLWRldmljZSBhbmQgbm90IG5lY2Nlc2FyaWx5IGZvciB0aGUgYnVzLiBTbyB3ZSBuZWVkIHRvCisJCSAqIHBlci1kZXZpY2UgYW5kIG5vdCBuZWNlc3NhcmlseSBmb3IgdGhlIGJ1cy4gU28gd2UgbmVlZCB0bwogCQkgKiBzZWFyY2ggdXB3YXJkcyBpbiB0aGUgdHJlZSB1bnRpbCB3ZSBlaXRoZXIgaGl0IGEgZG1hLXdpbmRvdwogCQkgKiBwcm9wZXJ0eSwgT1IgZmluZCBhIHBhcmVudCB3aXRoIGEgdGFibGUgYWxyZWFkeSBhbGxvY2F0ZWQuCiAJCSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL3hpY3MuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy94aWNzLmMKaW5kZXggZWM4ZmUyMi4uZDY5MDEzMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL3hpY3MuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMveGljcy5jCkBAIC04OTcsNyArODk3LDcgQEAKIAkJaW50IHN0YXR1czsKIAkJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCQkvKiBXZSBjYW50IHNldCBhZmZpbml0eSBvbiBJU0EgaW50ZXJydXB0cyAqLworCQkvKiBXZSBjYW4ndCBzZXQgYWZmaW5pdHkgb24gSVNBIGludGVycnVwdHMgKi8KIAkJaWYgKHZpcnEgPCBOVU1fSVNBX0lOVEVSUlVQVFMpCiAJCQljb250aW51ZTsKIAkJaWYgKGlycV9tYXBbdmlycV0uaG9zdCAhPSB4aWNzX2hvc3QpCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2F4b25yYW0uYyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvYXhvbnJhbS5jCmluZGV4IDI3NDAyYzdkLi4xNjM2ZGQ4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2F4b25yYW0uYworKysgYi9hcmNoL3Bvd2VycGMvc3lzZGV2L2F4b25yYW0uYwpAQCAtOTUsNyArOTUsNyBAQAogCiAJQlVHX09OKCFiYW5rKTsKIAotCWRldl9lcnIoJmRldmljZS0+ZGV2LCAiQ29ycmVjdGFibGUgbWVtb3J5IGVycm9yIG9jY3VyZWRcbiIpOworCWRldl9lcnIoJmRldmljZS0+ZGV2LCAiQ29ycmVjdGFibGUgbWVtb3J5IGVycm9yIG9jY3VycmVkXG4iKTsKIAliYW5rLT5lY2NfY291bnRlcisrOwogCXJldHVybiBJUlFfSEFORExFRDsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9zeXNkZXYvYmVzdGNvbW0vYmVzdGNvbW0uaCBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvYmVzdGNvbW0vYmVzdGNvbW0uaAppbmRleCAyM2E5NWY4Li5hMGUyZTZiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2Jlc3Rjb21tL2Jlc3Rjb21tLmgKKysrIGIvYXJjaC9wb3dlcnBjL3N5c2Rldi9iZXN0Y29tbS9iZXN0Y29tbS5oCkBAIC0yMCw3ICsyMCw3IEBACiAgKiBzdHJ1Y3QgYmNvbV9iZCAtIFN0cnVjdHVyZSBkZXNjcmliaW5nIGEgZ2VuZXJpYyBCZXN0Q29tbSBidWZmZXIgZGVzY3JpcHRvcgogICogQHN0YXR1czogVGhlIGN1cnJlbnQgc3RhdHVzIG9mIHRoaXMgYnVmZmVyLiBFeGFjdCBtZWFuaW5nIGRlcGVuZHMgb24gdGhlCiAgKiAgICAgICAgICB0YXNrIHR5cGUKLSAqIEBkYXRhOiBBbiBhcnJheSBvZiB1MzIgZXh0cmEgZGF0YS4gIFNpemUgb2YgYXJyYXkgaXMgdGFzayBkZXBlbmRhbnQuCisgKiBAZGF0YTogQW4gYXJyYXkgb2YgdTMyIGV4dHJhIGRhdGEuICBTaXplIG9mIGFycmF5IGlzIHRhc2sgZGVwZW5kZW50LgogICoKICAqIE5vdGU6IERvbid0IGRlcmVmZXJlbmNlIGEgYmNvbV9iZCBwb2ludGVyIGFzIGFuIGFycmF5LiAgVGhlIHNpemUgb2YgdGhlCiAgKiAgICAgICBiY29tX2JkIGlzIHZhcmlhYmxlLiAgVXNlIGJjb21fZ2V0X2JkKCkgaW5zdGVhZC4KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9zeXNkZXYvYmVzdGNvbW0vYmVzdGNvbW1fcHJpdi5oIGIvYXJjaC9wb3dlcnBjL3N5c2Rldi9iZXN0Y29tbS9iZXN0Y29tbV9wcml2LmgKaW5kZXggZWIwZDFjOC4uM2I1MmYzZiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3N5c2Rldi9iZXN0Y29tbS9iZXN0Y29tbV9wcml2LmgKKysrIGIvYXJjaC9wb3dlcnBjL3N5c2Rldi9iZXN0Y29tbS9iZXN0Y29tbV9wcml2LmgKQEAgLTk3LDcgKzk3LDcgQEAKIAl1OAlyZXNlcnZlZFs4XTsKIH07CiAKLS8qIERlc2NyaXB0b3JzIHN0dWN0dXJlICYgY28gKi8KKy8qIERlc2NyaXB0b3JzIHN0cnVjdHVyZSAmIGNvICovCiAjZGVmaW5lIEJDT01fREVTQ19OT1AJCTB4MDAwMDAxZjgKICNkZWZpbmUgQkNPTV9MQ0RfTUFTSwkJMHg4MDAwMDAwMAogI2RlZmluZSBCQ09NX0RSRF9FWFRFTkRFRAkweDQwMDAwMDAwCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2NwbTEuYyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvY3BtMS5jCmluZGV4IDhiNWFiYTIuLmUwYmM5NDQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9zeXNkZXYvY3BtMS5jCisrKyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvY3BtMS5jCkBAIC0yMjMsNyArMjIzLDcgQEAKIAogCS8qIFNldCBTRE1BIEJ1cyBSZXF1ZXN0IHByaW9yaXR5IDUuCiAJICogT24gODYwVCwgdGhpcyBhbHNvIGVuYWJsZXMgRkVDIHByaW9yaXR5IDYuICBJIGFtIG5vdCBzdXJlCi0JICogdGhpcyBpcyB3aGF0IHdlIHJlYWx5IHdhbnQgZm9yIHNvbWUgYXBwbGljYXRpb25zLCBidXQgdGhlCisJICogdGhpcyBpcyB3aGF0IHdlIHJlYWxseSB3YW50IGZvciBzb21lIGFwcGxpY2F0aW9ucywgYnV0IHRoZQogCSAqIG1hbnVhbCByZWNvbW1lbmRzIGl0LgogCSAqIEJpdCAyNSwgRkFNIGNhbiBhbHNvIGJlIHNldCB0byB1c2UgRkVDIGFnZ3Jlc3NpdmUgbW9kZSAoODYwVCkuCiAJICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2luZGlyZWN0X3BjaS5jIGIvYXJjaC9wb3dlcnBjL3N5c2Rldi9pbmRpcmVjdF9wY2kuYwppbmRleCA3ZWQ4MDk2Li44MmZkYWQ4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2luZGlyZWN0X3BjaS5jCisrKyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvaW5kaXJlY3RfcGNpLmMKQEAgLTExNyw3ICsxMTcsNyBAQAogCQlvdXRfbGUzMihob3NlLT5jZmdfYWRkciwgKDB4ODAwMDAwMDAgfCAoYnVzX25vIDw8IDE2KSB8CiAJCQkgKGRldmZuIDw8IDgpIHwgcmVnIHwgY2ZnX3R5cGUpKTsKIAotCS8qIHN1cnByZXNzIHNldHRpbmcgb2YgUENJX1BSSU1BUllfQlVTICovCisJLyogc3VwcHJlc3Mgc2V0dGluZyBvZiBQQ0lfUFJJTUFSWV9CVVMgKi8KIAlpZiAoaG9zZS0+aW5kaXJlY3RfdHlwZSAmIFBQQ19JTkRJUkVDVF9UWVBFX1NVUlBSRVNTX1BSSU1BUllfQlVTKQogCQlpZiAoKG9mZnNldCA9PSBQQ0lfUFJJTUFSWV9CVVMpICYmCiAJCQkoYnVzLT5udW1iZXIgPT0gaG9zZS0+Zmlyc3RfYnVzbm8pKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3N5c2Rldi9wcGM0eHhfcGNpLmggYi9hcmNoL3Bvd2VycGMvc3lzZGV2L3BwYzR4eF9wY2kuaAppbmRleCA1NmQ5ZTVkLi5jMzlhMTM0IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvc3lzZGV2L3BwYzR4eF9wY2kuaAorKysgYi9hcmNoL3Bvd2VycGMvc3lzZGV2L3BwYzR4eF9wY2kuaApAQCAtMzI0LDcgKzMyNCw3IEBACiAjZGVmaW5lIFBFU0RSMF80NjBFWF9JSFMyCQkweDAzNkQKIAogLyoKLSAqIDQ2MFNYIGFkZHRpb25hbCBEQ1JzCisgKiA0NjBTWCBhZGRpdGlvbmFsIERDUnMKICAqLwogI2RlZmluZSBQRVNEUm5fNDYwU1hfUkNFSQkJMHgwMgogCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vYXRvbWljLmggYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vYXRvbWljLmgKaW5kZXggNWM1YmExMC4uZDlkYjEzOCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2F0b21pYy5oCisrKyBiL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9hdG9taWMuaApAQCAtOSw3ICs5LDcgQEAKICAqCiAgKiBBdG9taWMgb3BlcmF0aW9ucyB0aGF0IEMgY2FuJ3QgZ3VhcmFudGVlIHVzLgogICogVXNlZnVsIGZvciByZXNvdXJjZSBjb3VudGluZyBldGMuCi0gKiBzMzkwIHVzZXMgJ0NvbXBhcmUgQW5kIFN3YXAnIGZvciBhdG9taWNpdHkgaW4gU01QIGVudmlyb21lbnQuCisgKiBzMzkwIHVzZXMgJ0NvbXBhcmUgQW5kIFN3YXAnIGZvciBhdG9taWNpdHkgaW4gU01QIGVudmlyb25tZW50LgogICoKICAqLwogCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY2lvLmggYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY2lvLmgKaW5kZXggZTM0MzQ3ZC4uZmM1MGEzMzQgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9jaW8uaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY2lvLmgKQEAgLTE4Myw3ICsxODMsNyBAQAogICogVGhlIGlyYiB0aGF0IGlzIGhhbmRlZCB0byB0aGUgZGV2aWNlIGRyaXZlciB3aGVuIGFuIGludGVycnVwdCBvY2N1cnMuIEZvcgogICogc29saWNpdGVkIGludGVycnVwdHMsIHRoZSBjb21tb24gSS9PIGxheWVyIGFscmVhZHkgcGVyZm9ybXMgY2hlY2tzIHdoZXRoZXIKICAqIGEgZmllbGQgaXMgdmFsaWQ7IGEgZmllbGQgbm90IGJlaW5nIHZhbGlkIGlzIGFsd2F5cyBwYXNzZWQgYXMgJTAuCi0gKiBJZiBhIHVuaXQgY2hlY2sgb2NjdXJlZCwgQGVjdyBtYXkgY29udGFpbiBzZW5zZSBkYXRhOyB0aGlzIGlzIHJldHJpZXZlZAorICogSWYgYSB1bml0IGNoZWNrIG9jY3VycmVkLCBAZWN3IG1heSBjb250YWluIHNlbnNlIGRhdGE7IHRoaXMgaXMgcmV0cmlldmVkCiAgKiBieSB0aGUgY29tbW9uIEkvTyBsYXllciBpdHNlbGYgaWYgdGhlIGRldmljZSBkb2Vzbid0IHN1cHBvcnQgY29uY3VycmVudAogICogc2Vuc2UgKHNvIHRoYXQgdGhlIGRldmljZSBkcml2ZXIgbmV2ZXIgbmVlZHMgdG8gcGVyZm9ybSBiYXNpYyBzZW5lIGl0c2VsZikuCiAgKiBGb3IgdW5zb2xpY2l0ZWQgaW50ZXJydXB0cywgdGhlIGlyYiBpcyBwYXNzZWQgYXMtaXMgKGV4cGVjdCBmb3Igc2Vuc2UgZGF0YSwKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvaGVhZC5TIGIvYXJjaC9zMzkwL2tlcm5lbC9oZWFkLlMKaW5kZXggNzA2MTM5OC4uZmIzMTdiZiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2tlcm5lbC9oZWFkLlMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9oZWFkLlMKQEAgLTQ2MCw3ICs0NjAsNyBAQAogI2lmbmRlZiBDT05GSUdfTUFSQ0hfRzUKIAkjIGNoZWNrIGNhcGFiaWxpdGllcyBhZ2FpbnN0IE1BUkNIX3tHNSxaOTAwLFo5OTAsWjlfMTA5LFoxMH0KIAl4YwlfX0xDX1NURkxfRkFDX0xJU1QoOCksX19MQ19TVEZMX0ZBQ19MSVNUCi0Jc3RmbAlfX0xDX1NURkxfRkFDX0xJU1QJIyBzdG9yZSBmYWNpbGl0eSBsaXN0CisJLmluc24JcywweGIyYjEwMDAwLF9fTENfU1RGTF9GQUNfTElTVAkjIHN0b3JlIGZhY2lsaXR5IGxpc3QKIAl0bQlfX0xDX1NURkxfRkFDX0xJU1QsMHgwMQkjIHN0ZmxlIGF2YWlsYWJsZSA/CiAJanoJMGYKIAlsYQklcjAsMApkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2tlcm5lbC9yZWlwbDY0LlMgYi9hcmNoL3MzOTAva2VybmVsL3JlaXBsNjQuUwppbmRleCA1ZTczZGVlLi45ZWFiYmM5IDEwMDY0NAotLS0gYS9hcmNoL3MzOTAva2VybmVsL3JlaXBsNjQuUworKysgYi9hcmNoL3MzOTAva2VybmVsL3JlaXBsNjQuUwpAQCAtNzgsNyArNzgsNyBAQAogICogaW4gdGhlIEVTQSBwc3cuCiAgKiBCaXQgMzEgb2YgdGhlIGFkZHJlc3NlcyBoYXMgdG8gYmUgMCBmb3IgdGhlCiAgKiAzMWJpdCBscHN3ZSBpbnN0cnVjdGlvbiBhIGZhY3QgdGhleSBhcHBlYXIgdG8gaGF2ZQotICogb21taXRlZCBmcm9tIHRoZSBwb3AuCisgKiBvbWl0dGVkIGZyb20gdGhlIHBvcC4KICAqLwogLkxuZXdwc3c6CS5xdWFkCTB4MDAwMDAwMDA4MDAwMDAwMAogCQkucXVhZAkuTHBnMQpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2tlcm5lbC9zZXR1cC5jIGIvYXJjaC9zMzkwL2tlcm5lbC9zZXR1cC5jCmluZGV4IGVkMTgzYzIuLmY1NDM0ZDEgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvc2V0dXAuYworKysgYi9hcmNoL3MzOTAva2VybmVsL3NldHVwLmMKQEAgLTcwOCw3ICs3MDgsNyBAQAogCSAqIGFuZCAxVUxMPDwwIGFzIGJpdCA2My4gQml0cyAwLTMxIGNvbnRhaW4gdGhlIHNhbWUgaW5mb3JtYXRpb24KIAkgKiBhcyBzdG9yZWQgYnkgc3RmbCwgYml0cyAzMi14eHggY29udGFpbiBhZGRpdGlvbmFsIGZhY2lsaXRpZXMuCiAJICogSG93IG1hbnkgZmFjaWxpdHkgd29yZHMgYXJlIHN0b3JlZCBkZXBlbmRzIG9uIHRoZSBudW1iZXIgb2YKLQkgKiBkb3VibGV3b3JkcyBwYXNzZWQgdG8gdGhlIGluc3RydWN0aW9uLiBUaGUgYWRkaXRpb25hbCBmYWNpbGl0ZXMKKwkgKiBkb3VibGV3b3JkcyBwYXNzZWQgdG8gdGhlIGluc3RydWN0aW9uLiBUaGUgYWRkaXRpb25hbCBmYWNpbGl0aWVzCiAJICogYXJlOgogCSAqICAgQml0IDQyOiBkZWNpbWFsIGZsb2F0aW5nIHBvaW50IGZhY2lsaXR5IGlzIGluc3RhbGxlZAogCSAqICAgQml0IDQ0OiBwZXJmb3JtIGZsb2F0aW5nIHBvaW50IG9wZXJhdGlvbiBmYWNpbGl0eSBpcyBpbnN0YWxsZWQKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvc3dpdGNoX2NwdS5TIGIvYXJjaC9zMzkwL2tlcm5lbC9zd2l0Y2hfY3B1LlMKaW5kZXggNDY5ZjExYi4uMjA1MzBkZCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2tlcm5lbC9zd2l0Y2hfY3B1LlMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9zd2l0Y2hfY3B1LlMKQEAgLTQ2LDcgKzQ2LDkgQEAKIAlsdHIJJXI0LCVyNAkJCS8qIE5ldyBzdGFjayA/ICovCiAJanoJMWYKIAlscgklcjE1LCVyNAotMToJYmFzcgklcjE0LCVyMgorMToJbHIJJXIxNCwlcjIJCS8qIHIxNDogRnVuY3Rpb24gdG8gY2FsbCAqLworCWxyCSVyMiwlcjMJCQkvKiByMiA6IFBhcmFtZXRlciBmb3IgZnVuY3Rpb24qLworCWJhc3IJJXIxNCwlcjE0CQkvKiBDYWxsIGZ1bmN0aW9uICovCiAKIC5ncHJyZWdzX2FkZHI6CiAJLmxvbmcJLmdwcnJlZ3MKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvc3dpdGNoX2NwdTY0LlMgYi9hcmNoL3MzOTAva2VybmVsL3N3aXRjaF9jcHU2NC5TCmluZGV4IGQ5NGFhY2MuLjViZTNmNDMgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvc3dpdGNoX2NwdTY0LlMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9zd2l0Y2hfY3B1NjQuUwpAQCAtNDIsNyArNDIsOSBAQAogCWx0Z3IJJXI0LCVyNAkJCS8qIE5ldyBzdGFjayA/ICovCiAJanoJMWYKIAlsZ3IJJXIxNSwlcjQKLTE6CWJhc3IJJXIxNCwlcjIKKzE6CWxncgklcjE0LCVyMgkJLyogcjE0OiBGdW5jdGlvbiB0byBjYWxsICovCisJbGdyCSVyMiwlcjMJCQkvKiByMiA6IFBhcmFtZXRlciBmb3IgZnVuY3Rpb24qLworCWJhc3IJJXIxNCwlcjE0CQkvKiBDYWxsIGZ1bmN0aW9uICovCiAKIAkuc2VjdGlvbiAuZGF0YSwiYXciLEBwcm9nYml0cwogLmdwcnJlZ3M6CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva2VybmVsL3RpbWUuYyBiL2FyY2gvczM5MC9rZXJuZWwvdGltZS5jCmluZGV4IDllN2IwMzkuLjg3YmU2NTUgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvdGltZS5jCisrKyBiL2FyY2gvczM5MC9rZXJuZWwvdGltZS5jCkBAIC03MjQsNyArNzI0LDcgQEAKIH0KIAogLyoKLSAqIFN5bmMgdGhlIFRPRCBjbG9jayB1c2luZyB0aGUgcG9ydCByZWZlcmVkIHRvIGJ5IGFpYnAuIFRoaXMgcG9ydAorICogU3luYyB0aGUgVE9EIGNsb2NrIHVzaW5nIHRoZSBwb3J0IHJlZmVycmVkIHRvIGJ5IGFpYnAuIFRoaXMgcG9ydAogICogaGFzIHRvIGJlIGVuYWJsZWQgYW5kIHRoZSBvdGhlciBwb3J0IGhhcyB0byBiZSBkaXNhYmxlZC4gVGhlCiAgKiBsYXN0IGVhY3IgdXBkYXRlIGhhcyB0byBiZSBtb3JlIHRoYW4gMS42IHNlY29uZHMgaW4gdGhlIHBhc3QuCiAgKi8KQEAgLTEwMTIsNyArMTAxMiw3IEBACiAJCWVhY3IgPSBldHJfaGFuZGxlX3VwZGF0ZSgmYWliLCBlYWNyKTsKIAogCS8qCi0JICogU2VsZWN0IHBvcnRzIHRvIGVuYWJsZS4gVGhlIHByZWZlcmVkIHN5bmNocm9uaXphdGlvbiBtb2RlIGlzIFBQUy4KKwkgKiBTZWxlY3QgcG9ydHMgdG8gZW5hYmxlLiBUaGUgcHJlZmVycmVkIHN5bmNocm9uaXphdGlvbiBtb2RlIGlzIFBQUy4KIAkgKiBJZiBhIHBvcnQgY2FuIGJlIGVuYWJsZWQgZGVwZW5kcyBvbiBhIG51bWJlciBvZiB0aGluZ3M6CiAJICogMSkgVGhlIHBvcnQgbmVlZHMgdG8gYmUgb25saW5lIGFuZCB1cHRvZGF0ZS4gQSBwb3J0IGlzIG5vdAogCSAqICAgIGRpc2FibGVkIGp1c3QgYmVjYXVzZSBpdCBpcyBub3QgdXB0b2RhdGUsIGJ1dCBpdCBpcyBvbmx5CkBAIC0xMDkxLDcgKzEwOTEsNyBAQAogCS8qCiAJICogVXBkYXRlIGVhY3IgYW5kIHRyeSB0byBzeW5jaHJvbml6ZSB0aGUgY2xvY2suIElmIHRoZSB1cGRhdGUKIAkgKiBvZiBlYWNyIGNhdXNlZCBhIHN0ZXBwaW5nIHBvcnQgc3dpdGNoIChvciBpZiB3ZSBoYXZlIHRvCi0JICogYXNzdW1lIHRoYXQgYSBzdGVwcGluZyBwb3J0IHN3aXRjaCBoYXMgb2NjdXJlZCkgb3IgdGhlCisJICogYXNzdW1lIHRoYXQgYSBzdGVwcGluZyBwb3J0IHN3aXRjaCBoYXMgb2NjdXJyZWQpIG9yIHRoZQogCSAqIGNsb2NrIHN5bmNpbmcgZmFpbGVkLCByZXNldCB0aGUgc3luYyBjaGVjayBjb250cm9sIGJpdAogCSAqIGFuZCBzZXQgdXAgYSB0aW1lciB0byB0cnkgYWdhaW4gYWZ0ZXIgMC41IHNlY29uZHMKIAkgKi8KZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvdnRpbWUuYyBiL2FyY2gvczM5MC9rZXJuZWwvdnRpbWUuYwppbmRleCAxY2NkZjRkLi41ZThlYWQ0IDEwMDY0NAotLS0gYS9hcmNoL3MzOTAva2VybmVsL3Z0aW1lLmMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC92dGltZS5jCkBAIC00NCw3ICs0NCw3IEBACiAJX191NjQgdGltZXI7CiAKIAlhc20gdm9sYXRpbGUgKCIgIFNUUFQgJTBcbiIgIC8qIFN0b3JlIGN1cnJlbnQgY3B1IHRpbWVyIHZhbHVlICovCi0JCSAgICAgICIgIFNQVCAlMSIgICAgIC8qIFNldCBuZXcgdmFsdWUgaW1tZWRpYXRseSBhZnRlcndhcmRzICovCisJCSAgICAgICIgIFNQVCAlMSIgICAgIC8qIFNldCBuZXcgdmFsdWUgaW1tZWRpYXRlbHkgYWZ0ZXJ3YXJkcyAqLwogCQkgICAgICA6ICI9bSIgKHRpbWVyKSA6ICJtIiAoZXhwaXJlcykgKTsKIAlTMzkwX2xvd2NvcmUuc3lzdGVtX3RpbWVyICs9IFMzOTBfbG93Y29yZS5sYXN0X3VwZGF0ZV90aW1lciAtIHRpbWVyOwogCVMzOTBfbG93Y29yZS5sYXN0X3VwZGF0ZV90aW1lciA9IGV4cGlyZXM7CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva3ZtL2t2bS1zMzkwLmMgYi9hcmNoL3MzOTAva3ZtL2t2bS1zMzkwLmMKaW5kZXggYmFkZTUzMy4uMzBjYTg1YyAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2t2bS9rdm0tczM5MC5jCisrKyBiL2FyY2gvczM5MC9rdm0va3ZtLXMzOTAuYwpAQCAtNzIxLDcgKzcyMSw3IEBACiAKIAkvKgogCSAqIGd1ZXN0cyBjYW4gYXNrIGZvciB1cCB0byAyNTUrMSBkb3VibGUgd29yZHMsIHdlIG5lZWQgYSBmdWxsIHBhZ2UKLQkgKiB0byBob2xkIHRoZSBtYXhpbXVtIGFtb3VudCBvZiBmYWNpbGl0ZXMuIE9uIHRoZSBvdGhlciBoYW5kLCB3ZQorCSAqIHRvIGhvbGQgdGhlIG1heGltdW0gYW1vdW50IG9mIGZhY2lsaXRpZXMuIE9uIHRoZSBvdGhlciBoYW5kLCB3ZQogCSAqIG9ubHkgc2V0IGZhY2lsaXRpZXMgdGhhdCBhcmUga25vd24gdG8gd29yayBpbiBLVk0uCiAJICovCiAJZmFjaWxpdGllcyA9ICh1bnNpZ25lZCBsb25nIGxvbmcgKikgZ2V0X3plcm9lZF9wYWdlKEdGUF9LRVJORUx8R0ZQX0RNQSk7CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva3ZtL3ByaXYuYyBiL2FyY2gvczM5MC9rdm0vcHJpdi5jCmluZGV4IDkxOTRhNGIuLjczYzQ3YmQgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rdm0vcHJpdi5jCisrKyBiL2FyY2gvczM5MC9rdm0vcHJpdi5jCkBAIC0zMTEsNyArMzExLDcgQEAKIAogCS8qCiAJICogYSBsb3Qgb2YgQjIgaW5zdHJ1Y3Rpb25zIGFyZSBwcml2aWxlZGdlZC4gV2UgZmlyc3QgY2hlY2sgZm9yCi0JICogdGhlIHByaXZpbGVkZ2VzIG9uZXMsIHRoYXQgd2UgY2FuIGhhbmRsZSBpbiB0aGUga2VybmVsLiBJZiB0aGUKKwkgKiB0aGUgcHJpdmlsZWdlZCBvbmVzLCB0aGF0IHdlIGNhbiBoYW5kbGUgaW4gdGhlIGtlcm5lbC4gSWYgdGhlCiAJICoga2VybmVsIGNhbiBoYW5kbGUgdGhpcyBpbnN0cnVjdGlvbiwgd2UgY2hlY2sgZm9yIHRoZSBwcm9ibGVtCiAJICogc3RhdGUgYml0IGFuZCAoYSkgaGFuZGxlIHRoZSBpbnN0cnVjdGlvbiBvciAoYikgc2VuZCBhIGNvZGUgMgogCSAqIHByb2dyYW0gY2hlY2suCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvbW0vZmF1bHQuYyBiL2FyY2gvczM5MC9tbS9mYXVsdC5jCmluZGV4IDJjNTc4MDYuLjkyMTdlMzMgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9tbS9mYXVsdC5jCisrKyBiL2FyY2gvczM5MC9tbS9mYXVsdC5jCkBAIC0zOTIsNyArMzkyLDcgQEAKIHsKIAlpbnQgZmF1bHQ7CiAKLQkvKiBQcm90ZWN0aW9uIGV4Y2VwdGlvbiBpcyBzdXByZXNzaW5nLCBkZWNyZW1lbnQgcHN3IGFkZHJlc3MuICovCisJLyogUHJvdGVjdGlvbiBleGNlcHRpb24gaXMgc3VwcHJlc3NpbmcsIGRlY3JlbWVudCBwc3cgYWRkcmVzcy4gKi8KIAlyZWdzLT5wc3cuYWRkciAtPSAocGdtX2ludF9jb2RlID4+IDE2KTsKIAkvKgogCSAqIENoZWNrIGZvciBsb3ctYWRkcmVzcyBwcm90ZWN0aW9uLiAgVGhpcyBuZWVkcyB0byBiZSB0cmVhdGVkCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvb3Byb2ZpbGUvaHdzYW1wbGVyLmMgYi9hcmNoL3MzOTAvb3Byb2ZpbGUvaHdzYW1wbGVyLmMKaW5kZXggM2Q0OGY0ZC4uNDk1Mjg3MiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL29wcm9maWxlL2h3c2FtcGxlci5jCisrKyBiL2FyY2gvczM5MC9vcHJvZmlsZS9od3NhbXBsZXIuYwpAQCAtNTE3LDEyICs1MTcsOCBAQAogCiBzdGF0aWMgaW50IGNoZWNrX2hhcmR3YXJlX3ByZXJlcXVpc2l0ZXModm9pZCkKIHsKLQl1bnNpZ25lZCBsb25nIGxvbmcgZmFjaWxpdHlfYml0c1syXTsKLQotCW1lbWNweShmYWNpbGl0eV9iaXRzLCBTMzkwX2xvd2NvcmUuc3RmbGVfZmFjX2xpc3QsIDMyKTsKLQlpZiAoIShmYWNpbGl0eV9iaXRzWzFdICYgKDFVTEwgPDwgNTkpKSkKKwlpZiAoIXRlc3RfZmFjaWxpdHkoNjgpKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7Ci0KIAlyZXR1cm4gMDsKIH0KIC8qCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL01ha2VmaWxlIGIvYXJjaC9zY29yZS9NYWtlZmlsZQppbmRleCBkNzdkYzYzLi45NzRhZWZlIDEwMDY0NAotLS0gYS9hcmNoL3Njb3JlL01ha2VmaWxlCisrKyBiL2FyY2gvc2NvcmUvTWFrZWZpbGUKQEAgLTQwLDUgKzQwLDUgQEAKIGRlZmluZSBhcmNoaGVscAogCWVjaG8gJyAgdm1saW51eC5iaW4gICAgICAgICAgLSBSYXcgYmluYXJ5IGJvb3QgaW1hZ2UnCiAJZWNobwotCWVjaG8gJyAgVGhlc2Ugd2lsbCBiZSBkZWZhdWx0IGFzIGFwcm9wcmlhdGUgZm9yIGEgY29uZmlndXJlZCBwbGF0Zm9ybS4nCisJZWNobyAnICBUaGVzZSB3aWxsIGJlIGRlZmF1bHQgYXMgYXBwcm9wcmlhdGUgZm9yIGEgY29uZmlndXJlZCBwbGF0Zm9ybS4nCiBlbmRlZgpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9LY29uZmlnIGIvYXJjaC9zaC9LY29uZmlnCmluZGV4IGJjNDM5ZGUuLjRiODlkYTIgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvS2NvbmZpZworKysgYi9hcmNoL3NoL0tjb25maWcKQEAgLTI0LDYgKzI0LDcgQEAKIAlzZWxlY3QgUlRDX0xJQgogCXNlbGVjdCBHRU5FUklDX0FUT01JQzY0CiAJc2VsZWN0IEdFTkVSSUNfSVJRX1NIT1cKKwlzZWxlY3QgQVJDSF9OT19TWVNERVZfT1BTCiAJaGVscAogCSAgVGhlIFN1cGVySCBpcyBhIFJJU0MgcHJvY2Vzc29yIHRhcmdldGVkIGZvciB1c2UgaW4gZW1iZWRkZWQgc3lzdGVtcwogCSAgYW5kIGNvbnN1bWVyIGVsZWN0cm9uaWNzOyBpdCB3YXMgYWxzbyB1c2VkIGluIHRoZSBTZWdhIERyZWFtY2FzdApkaWZmIC0tZ2l0IGEvYXJjaC9zaC9LY29uZmlnLmRlYnVnIGIvYXJjaC9zaC9LY29uZmlnLmRlYnVnCmluZGV4IDEyZmVjNzIuLjE1NTNkNTYgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvS2NvbmZpZy5kZWJ1ZworKysgYi9hcmNoL3NoL0tjb25maWcuZGVidWcKQEAgLTgyLDcgKzgyLDcgQEAKIAloZWxwCiAJICBJZiBydW5uaW5nIGluIHBhaW5mdWxseSBzbG93IGVudmlyb25tZW50cywgc3VjaCBhcyBhbiBSVEwKIAkgIHNpbXVsYXRpb24gb3IgZnJvbSByZW1vdGUgbWVtb3J5IHZpYSBTSGRlYnVnLCB3aGVyZSB0aGUgbWVtb3J5Ci0JICBjYW4gYWxyZWFkeSBiZSBnYXVyYW50ZWVkIHRvIGJlciB6ZXJvZWQgb24gYm9vdCwgc2F5IFkuCisJICBjYW4gYWxyZWFkeSBiZSBndWFyYW50ZWVkIHRvIGJlciB6ZXJvZWQgb24gYm9vdCwgc2F5IFkuCiAKIAkgIEZvciBhbGwgb3RoZXIgY2FzZXMsIHNheSBOLiBJZiB0aGlzIG9wdGlvbiBzZWVtcyBwZXJwbGV4aW5nLCBvcgogCSAgeW91IGFyZW4ndCBzdXJlLCBzYXkgTi4KZGlmZiAtLWdpdCBhL2FyY2gvc2gvYm9hcmRzL2JvYXJkLXNoNzc1N2xjci5jIGIvYXJjaC9zaC9ib2FyZHMvYm9hcmQtc2g3NzU3bGNyLmMKaW5kZXggYTllMzM1Ni4uZmEyYTIwOCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib2FyZHMvYm9hcmQtc2g3NzU3bGNyLmMKKysrIGIvYXJjaC9zaC9ib2FyZHMvYm9hcmQtc2g3NzU3bGNyLmMKQEAgLTE3LDcgKzE3LDcgQEAKICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGxpbnV4L21tYy9ob3N0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW1jL3NoX21tY2lmLmg+Ci0jaW5jbHVkZSA8bGludXgvbWZkL3NoX21vYmlsZV9zZGhpLmg+CisjaW5jbHVkZSA8bGludXgvbW1jL3NoX21vYmlsZV9zZGhpLmg+CiAjaW5jbHVkZSA8Y3B1L3NoNzc1Ny5oPgogI2luY2x1ZGUgPGFzbS9zaF9ldGguaD4KICNpbmNsdWRlIDxhc20vaGVhcnRiZWF0Lmg+CmRpZmYgLS1naXQgYS9hcmNoL3NoL2JvYXJkcy9tYWNoLWFwMzI1cnhhL3NldHVwLmMgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWFwMzI1cnhhL3NldHVwLmMKaW5kZXggNjM2ZDgzMS4uNjE4YmQ1NiAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib2FyZHMvbWFjaC1hcDMyNXJ4YS9zZXR1cC5jCisrKyBiL2FyY2gvc2gvYm9hcmRzL21hY2gtYXAzMjVyeGEvc2V0dXAuYwpAQCAtMTU2LDI0ICsxNTYsMzQgQEAKICNkZWZpbmUgUE9SVF9EUlZDUkEJMHhBNDA1MDE4QQogI2RlZmluZSBQT1JUX0RSVkNSQgkweEE0MDUwMThDCiAKK3N0YXRpYyBpbnQgYXAzMjBfd3ZnYV9zZXRfYnJpZ2h0bmVzcyh2b2lkICpib2FyZF9kYXRhLCBpbnQgYnJpZ2h0bmVzcykKK3sKKwlpZiAoYnJpZ2h0bmVzcykgeworCQlncGlvX3NldF92YWx1ZShHUElPX1BUUzMsIDApOworCQlfX3Jhd193cml0ZXcoMHgxMDAsIEZQR0FfQktMUkVHKTsKKwl9IGVsc2UgeworCQlfX3Jhd193cml0ZXcoMCwgRlBHQV9CS0xSRUcpOworCQlncGlvX3NldF92YWx1ZShHUElPX1BUUzMsIDEpOworCX0KKwkKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBhcDMyMF93dmdhX2dldF9icmlnaHRuZXNzKHZvaWQgKmJvYXJkX2RhdGEpCit7CisJcmV0dXJuIGdwaW9fZ2V0X3ZhbHVlKEdQSU9fUFRTMyk7Cit9CisKIHN0YXRpYyB2b2lkIGFwMzIwX3d2Z2FfcG93ZXJfb24odm9pZCAqYm9hcmRfZGF0YSwgc3RydWN0IGZiX2luZm8gKmluZm8pCiB7CiAJbXNsZWVwKDEwMCk7CiAKIAkvKiBBU0QgQVAtMzIwLzMyNSBMQ0QgT04gKi8KIAlfX3Jhd193cml0ZXcoRlBHQV9MQ0RSRUdfVkFMLCBGUEdBX0xDRFJFRyk7Ci0KLQkvKiBiYWNrbGlnaHQgKi8KLQlncGlvX3NldF92YWx1ZShHUElPX1BUUzMsIDApOwotCV9fcmF3X3dyaXRldygweDEwMCwgRlBHQV9CS0xSRUcpOwogfQogCiBzdGF0aWMgdm9pZCBhcDMyMF93dmdhX3Bvd2VyX29mZih2b2lkICpib2FyZF9kYXRhKQogewotCS8qIGJhY2tsaWdodCAqLwotCV9fcmF3X3dyaXRldygwLCBGUEdBX0JLTFJFRyk7Ci0JZ3Bpb19zZXRfdmFsdWUoR1BJT19QVFMzLCAxKTsKLQogCS8qIEFTRCBBUC0zMjAvMzI1IExDRCBPRkYgKi8KIAlfX3Jhd193cml0ZXcoMCwgRlBHQV9MQ0RSRUcpOwogfQpAQCAtMjA5LDYgKzIxOSwxMiBAQAogCQkuYm9hcmRfY2ZnID0gewogCQkJLmRpc3BsYXlfb24gPSBhcDMyMF93dmdhX3Bvd2VyX29uLAogCQkJLmRpc3BsYXlfb2ZmID0gYXAzMjBfd3ZnYV9wb3dlcl9vZmYsCisJCQkuc2V0X2JyaWdodG5lc3MgPSBhcDMyMF93dmdhX3NldF9icmlnaHRuZXNzLAorCQkJLmdldF9icmlnaHRuZXNzID0gYXAzMjBfd3ZnYV9nZXRfYnJpZ2h0bmVzcywKKwkJfSwKKwkJLmJsX2luZm8gPSB7CisJCQkubmFtZSA9ICJzaF9tb2JpbGVfbGNkY19ibCIsCisJCQkubWF4X2JyaWdodG5lc3MgPSAxLAogCQl9LAogCX0KIH07CmRpZmYgLS1naXQgYS9hcmNoL3NoL2JvYXJkcy9tYWNoLWRyZWFtY2FzdC9pcnEuYyBiL2FyY2gvc2gvYm9hcmRzL21hY2gtZHJlYW1jYXN0L2lycS5jCmluZGV4IDc4Y2YyYWIuLmY2M2QzMjMgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvYm9hcmRzL21hY2gtZHJlYW1jYXN0L2lycS5jCisrKyBiL2FyY2gvc2gvYm9hcmRzL21hY2gtZHJlYW1jYXN0L2lycS5jCkBAIC01MSw3ICs1MSw3IEBACiAgKi8KICNkZWZpbmUgTEVWRUwoZXZlbnQpICgoKGV2ZW50KSAtIEhXX0VWRU5UX0lSUV9CQVNFKSAvIDMyKQogCi0vKiBSZXR1cm4gdGhlIGhhcmR3YXJlIGV2ZW50J3MgYml0IHBvc2l0b24gd2l0aGluIHRoZSBFTVIvRVNSICovCisvKiBSZXR1cm4gdGhlIGhhcmR3YXJlIGV2ZW50J3MgYml0IHBvc2l0aW9uIHdpdGhpbiB0aGUgRU1SL0VTUiAqLwogI2RlZmluZSBFVkVOVF9CSVQoZXZlbnQpICgoKGV2ZW50KSAtIEhXX0VWRU5UX0lSUV9CQVNFKSAmIDMxKQogCiAvKgpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9ib2FyZHMvbWFjaC1lY292ZWMyNC9zZXR1cC5jIGIvYXJjaC9zaC9ib2FyZHMvbWFjaC1lY292ZWMyNC9zZXR1cC5jCmluZGV4IGZkNGZmMjUuLjg2YTBkNTYgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvYm9hcmRzL21hY2gtZWNvdmVjMjQvc2V0dXAuYworKysgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWVjb3ZlYzI0L3NldHVwLmMKQEAgLTI2Myw2ICsyNjMsMTggQEAKIAl9LAogfTsKIAorc3RhdGljIGludCBlY292ZWMyNF9zZXRfYnJpZ2h0bmVzcyh2b2lkICpib2FyZF9kYXRhLCBpbnQgYnJpZ2h0bmVzcykKK3sKKwlncGlvX3NldF92YWx1ZShHUElPX1BUUjEsIGJyaWdodG5lc3MpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZWNvdmVjMjRfZ2V0X2JyaWdodG5lc3Modm9pZCAqYm9hcmRfZGF0YSkKK3sKKwlyZXR1cm4gZ3Bpb19nZXRfdmFsdWUoR1BJT19QVFIxKTsKK30KKwogc3RhdGljIHN0cnVjdCBzaF9tb2JpbGVfbGNkY19pbmZvIGxjZGNfaW5mbyA9IHsKIAkuY2hbMF0gPSB7CiAJCS5pbnRlcmZhY2VfdHlwZSA9IFJHQjE4LApAQCAtMjczLDYgKzI4NSwxMiBAQAogCQkJLmhlaWdodCA9IDkxLAogCQl9LAogCQkuYm9hcmRfY2ZnID0geworCQkJLnNldF9icmlnaHRuZXNzID0gZWNvdmVjMjRfc2V0X2JyaWdodG5lc3MsCisJCQkuZ2V0X2JyaWdodG5lc3MgPSBlY292ZWMyNF9nZXRfYnJpZ2h0bmVzcywKKwkJfSwKKwkJLmJsX2luZm8gPSB7CisJCQkubmFtZSA9ICJzaF9tb2JpbGVfbGNkY19ibCIsCisJCQkubWF4X2JyaWdodG5lc3MgPSAxLAogCQl9LAogCX0KIH07CkBAIC05MzYsNyArOTU0LDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCS8qIHJlYWQgTUFDIGFkZHJlc3MgZnJvbWUgRUVQUk9NICovCisJLyogcmVhZCBNQUMgYWRkcmVzcyBmcm9tIEVFUFJPTSAqLwogCWZvciAoaSA9IDA7IGkgPCBzaXplb2YocGQtPm1hY19hZGRyKTsgaSsrKSB7CiAJCXBkLT5tYWNfYWRkcltpXSA9IG1hY19yZWFkKGEsIDB4MTAgKyBpKTsKIAkJbXNsZWVwKDEwKTsKZGlmZiAtLWdpdCBhL2FyY2gvc2gvYm9hcmRzL21hY2gtbGFuZGlzay9zZXR1cC5jIGIvYXJjaC9zaC9ib2FyZHMvbWFjaC1sYW5kaXNrL3NldHVwLmMKaW5kZXggOTQxODZjZi4uZjExNDdjYSAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib2FyZHMvbWFjaC1sYW5kaXNrL3NldHVwLmMKKysrIGIvYXJjaC9zaC9ib2FyZHMvbWFjaC1sYW5kaXNrL3NldHVwLmMKQEAgLTIzLDcgKzIzLDcgQEAKIAogc3RhdGljIHZvaWQgbGFuZGlza19wb3dlcl9vZmYodm9pZCkKIHsKLSAgICAgICAgX19yYXdfd3JpdGViKDB4MDEsIFBBX1NIVVRET1dOKTsKKwlfX3Jhd193cml0ZWIoMHgwMSwgUEFfU0hVVERPV04pOwogfQogCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGNmX2lkZV9yZXNvdXJjZXNbM107CkBAIC04NSw3ICs4NSw3IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCBsYW5kaXNrX3NldHVwKGNoYXIgKipjbWRsaW5lX3ApCiB7Ci0gICAgICAgIC8qIExFRCBPTiAqLworCS8qIExFRCBPTiAqLwogCV9fcmF3X3dyaXRlYihfX3Jhd19yZWFkYihQQV9MRUQpIHwgMHgwMywgUEFfTEVEKTsKIAogCXByaW50ayhLRVJOX0lORk8gIkktTyBEQVRBIERFVklDRSwgSU5DLiBcIkxBTkRJU0sgU2VyaWVzXCIgc3VwcG9ydC5cbiIpOwpAQCAtOTcsNyArOTcsNiBAQAogICovCiBzdGF0aWMgc3RydWN0IHNoX21hY2hpbmVfdmVjdG9yIG12X2xhbmRpc2sgX19pbml0bXYgPSB7CiAJLm12X25hbWUgPSAiTEFORElTSyIsCi0JLm12X25yX2lycXMgPSA3MiwKIAkubXZfc2V0dXAgPSBsYW5kaXNrX3NldHVwLAogCS5tdl9pbml0X2lycSA9IGluaXRfbGFuZGlza19JUlEsCiB9OwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9kcml2ZXJzL3BjaS9wY2ktc2g3NzUxLmggYi9hcmNoL3NoL2RyaXZlcnMvcGNpL3BjaS1zaDc3NTEuaAppbmRleCA0OTgzYTRkLi41ZWRlMzhjIDEwMDY0NAotLS0gYS9hcmNoL3NoL2RyaXZlcnMvcGNpL3BjaS1zaDc3NTEuaAorKysgYi9hcmNoL3NoL2RyaXZlcnMvcGNpL3BjaS1zaDc3NTEuaApAQCAtNjEsNyArNjEsNyBAQAogICAjZGVmaW5lIFNINzc1MV9QQ0lDT05GM19CSVNUNyAgICAgIDB4ODAwMDAwMDAgIC8qIEJpc3QgU3VwcG9ydGVkICovCiAgICNkZWZpbmUgU0g3NzUxX1BDSUNPTkYzX0JJU1Q2ICAgICAgMHg0MDAwMDAwMCAgLyogQmlzdCBFeGVjdXRpbmcgKi8KICAgI2RlZmluZSBTSDc3NTFfUENJQ09ORjNfQklTVDNfMCAgICAweDBGMDAwMDAwICAvKiBCaXN0IFBhc3NlZCAqLwotICAjZGVmaW5lIFNINzc1MV9QQ0lDT05GM19IRDcgICAgICAgIDB4MDA4MDAwMDAgIC8qIFNpbmdsZSBGdW50aW9uIGRldmljZSAqLworICAjZGVmaW5lIFNINzc1MV9QQ0lDT05GM19IRDcgICAgICAgIDB4MDA4MDAwMDAgIC8qIFNpbmdsZSBGdW5jdGlvbiBkZXZpY2UgKi8KICAgI2RlZmluZSBTSDc3NTFfUENJQ09ORjNfSEQ2XzAgICAgICAweDAwN0YwMDAwICAvKiBDb25maWd1cmF0aW9uIExheW91dCAqLwogICAjZGVmaW5lIFNINzc1MV9QQ0lDT05GM19MQVQgICAgICAgIDB4MDAwMEZGMDAgIC8qIExhdGVuY3kgVGltZXIgKi8KICAgI2RlZmluZSBTSDc3NTFfUENJQ09ORjNfQ0xTICAgICAgICAweDAwMDAwMEZGICAvKiBDYWNoZSBMaW5lIFNpemUgKi8KZGlmZiAtLWdpdCBhL2FyY2gvc2gvZHJpdmVycy9wY2kvcGNpLmMgYi9hcmNoL3NoL2RyaXZlcnMvcGNpL3BjaS5jCmluZGV4IGEwOWM3N2QuLjE5NDIzMWMgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvZHJpdmVycy9wY2kvcGNpLmMKKysrIGIvYXJjaC9zaC9kcml2ZXJzL3BjaS9wY2kuYwpAQCAtODQsNyArODQsNyBAQAogCWhvc2VfdGFpbCA9ICZob3NlLT5uZXh0OwogCiAJLyoKLQkgKiBEbyBub3QgcGFuaWMgaGVyZSBidXQgbGF0ZXIgLSB0aGlzIG1pZ2h0IGhhcGVuIGJlZm9yZSBjb25zb2xlIGluaXQuCisJICogRG8gbm90IHBhbmljIGhlcmUgYnV0IGxhdGVyIC0gdGhpcyBtaWdodCBoYXBwZW4gYmVmb3JlIGNvbnNvbGUgaW5pdC4KIAkgKi8KIAlpZiAoIWhvc2UtPmlvX21hcF9iYXNlKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcKZGlmZiAtLWdpdCBhL2FyY2gvc2gvaW5jbHVkZS9hc20vcGFnZS5oIGIvYXJjaC9zaC9pbmNsdWRlL2FzbS9wYWdlLmgKaW5kZXggYzRlMGIzZC4uODIyZDYwOCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9pbmNsdWRlL2FzbS9wYWdlLmgKKysrIGIvYXJjaC9zaC9pbmNsdWRlL2FzbS9wYWdlLmgKQEAgLTE4Niw3ICsxODYsNyBAQAogLyoKICAqIFdoaWxlIEJZVEVTX1BFUl9XT1JEID09IDQgb24gdGhlIGN1cnJlbnQgc2g2NCBBQkksIEdDQyB3aWxsIHN0aWxsCiAgKiBoYXBwaWx5IGdlbmVyYXRlIHtsZC9zdH0ucSBwYWlycywgcmVxdWlyaW5nIHVzIHRvIGhhdmUgOC1ieXRlCi0gKiBhbGlnbm1lbnQgdG8gYXZvaWQgdHJhcHMuIFRoZSBrbWFsbG9jIGFsaWdubWVudCBpcyBnYXVyYW50ZWVkIGJ5CisgKiBhbGlnbm1lbnQgdG8gYXZvaWQgdHJhcHMuIFRoZSBrbWFsbG9jIGFsaWdubWVudCBpcyBndWFyYW50ZWVkIGJ5CiAgKiB2aXJ0dWUgb2YgTDFfQ0FDSEVfQllURVMsIHJlcXVpcmluZyB0aGlzIHRvIG9ubHkgYmUgc3BlY2lhbCBjYXNlZAogICogZm9yIHNsYWIgY2FjaGVzLgogICovCmRpZmYgLS1naXQgYS9hcmNoL3NoL2luY2x1ZGUvYXNtL3BndGFibGVfMzIuaCBiL2FyY2gvc2gvaW5jbHVkZS9hc20vcGd0YWJsZV8zMi5oCmluZGV4IGI3OTlmZTcuLjBiY2UzZDggMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvaW5jbHVkZS9hc20vcGd0YWJsZV8zMi5oCisrKyBiL2FyY2gvc2gvaW5jbHVkZS9hc20vcGd0YWJsZV8zMi5oCkBAIC0xNjcsNyArMTY3LDcgQEAKICNlbmRpZgogCiAvKgotICogTWFzayBvZiBiaXRzIHRoYXQgYXJlIHRvIGJlIHByZXNlcnZlZCBhY2Nyb3NzIHBncHJvdCBjaGFuZ2VzLgorICogTWFzayBvZiBiaXRzIHRoYXQgYXJlIHRvIGJlIHByZXNlcnZlZCBhY3Jvc3MgcGdwcm90IGNoYW5nZXMuCiAgKi8KICNkZWZpbmUgX1BBR0VfQ0hHX01BU0sgXAogCShQVEVfTUFTSyB8IF9QQUdFX0FDQ0VTU0VEIHwgX1BBR0VfQ0FDSEFCTEUgfCBcCmRpZmYgLS1naXQgYS9hcmNoL3NoL2luY2x1ZGUvYXNtL3VuYWxpZ25lZC1zaDRhLmggYi9hcmNoL3NoL2luY2x1ZGUvYXNtL3VuYWxpZ25lZC1zaDRhLmgKaW5kZXggYzQ4YTljMy4uOTVhZGM1MCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9pbmNsdWRlL2FzbS91bmFsaWduZWQtc2g0YS5oCisrKyBiL2FyY2gvc2gvaW5jbHVkZS9hc20vdW5hbGlnbmVkLXNoNGEuaApAQCAtOSw3ICs5LDcgQEAKICAqIHN0cnVjdC4KICAqCiAgKiBUaGUgc2FtZSBub3RlIGFzIHdpdGggdGhlIG1vdmxpLmwvbW92Y28ubCBwYWlyIGFwcGxpZXMgaGVyZSwgYXMgbG9uZwotICogYXMgdGhlIGxvYWQgaXMgZ2F1cmFudGVlZCB0byBiZSBpbmxpbmVkLCBub3RoaW5nIGVsc2Ugd2lsbCBob29rIGluIHRvCisgKiBhcyB0aGUgbG9hZCBpcyBndWFyYW50ZWVkIHRvIGJlIGlubGluZWQsIG5vdGhpbmcgZWxzZSB3aWxsIGhvb2sgaW4gdG8KICAqIHIwIGFuZCB3ZSBnZXQgdGhlIHJldHVybiB2YWx1ZSBmb3IgZnJlZS4KICAqCiAgKiBOT1RFOiBEdWUgdG8gdGhlIGZhY3Qgd2UgcmVxdWlyZSByMCBlbmNvZGluZywgY2FyZSBzaG91bGQgYmUgdGFrZW4gdG8KZGlmZiAtLWdpdCBhL2FyY2gvc2gvaW5jbHVkZS9tYWNoLWNvbW1vbi9tYWNoL2hpZ2hsYW5kZXIuaCBiL2FyY2gvc2gvaW5jbHVkZS9tYWNoLWNvbW1vbi9tYWNoL2hpZ2hsYW5kZXIuaAppbmRleCA1ZDlkNGQ1Li42Y2U5NDRlIDEwMDY0NAotLS0gYS9hcmNoL3NoL2luY2x1ZGUvbWFjaC1jb21tb24vbWFjaC9oaWdobGFuZGVyLmgKKysrIGIvYXJjaC9zaC9pbmNsdWRlL21hY2gtY29tbW9uL21hY2gvaGlnaGxhbmRlci5oCkBAIC0yNCw3ICsyNCw3IEBACiAjZGVmaW5lIFBBX09CTEVEICAgICAgICAoUEFfQkNSKzB4MDAxYykgLyogT24gQm9hcmQgTEVEIGNvbnRyb2wgKi8KICNkZWZpbmUgUEFfT0JTVyAgICAgICAgIChQQV9CQ1IrMHgwMDFlKSAvKiBPbiBCb2FyZCBTd2l0Y2ggY29udHJvbCAqLwogI2RlZmluZSBQQV9BVURJT1NFTCAgICAgKFBBX0JDUisweDAwMjApIC8qIFNvdW5kIEludGVyZmFjZSBTZWxlY3QgY29udHJvbCAqLwotI2RlZmluZSBQQV9FWFRQTFIgICAgICAgKFBBX0JDUisweDAwMWUpIC8qIEV4dGVudGlvbiBQaW4gUG9sYXJpdHkgY29udHJvbCAqLworI2RlZmluZSBQQV9FWFRQTFIgICAgICAgKFBBX0JDUisweDAwMWUpIC8qIEV4dGVuc2lvbiBQaW4gUG9sYXJpdHkgY29udHJvbCAqLwogI2RlZmluZSBQQV9UUENUTCAgICAgICAgKFBBX0JDUisweDAxMDApIC8qIFRvdWNoIFBhbmVsIEFjY2VzcyBjb250cm9sICovCiAjZGVmaW5lIFBBX1RQRENLQ1RMICAgICAoUEFfQkNSKzB4MDEwMikgLyogVG91Y2ggUGFuZWwgQWNjZXNzIGRhdGEgY29udHJvbCAqLwogI2RlZmluZSBQQV9UUENUTENMUiAgICAgKFBBX0JDUisweDAxMDQpIC8qIFRvdWNoIFBhbmVsIEFjY2VzcyBjb250cm9sICovCkBAIC04OSw3ICs4OSw3IEBACiAjZGVmaW5lIFBBX09CTEVECShQQV9CQ1IrMHgwMDE4KQkvKiBPbiBCb2FyZCBMRUQgY29udHJvbCAqLwogI2RlZmluZSBQQV9PQlNXCQkoUEFfQkNSKzB4MDAxYSkJLyogT24gQm9hcmQgU3dpdGNoIGNvbnRyb2wgKi8KICNkZWZpbmUgUEFfQVVESU9TRUwJKFBBX0JDUisweDAwMWMpCS8qIFNvdW5kIEludGVyZmFjZSBTZWxlY3QgY29udHJvbCAqLwotI2RlZmluZSBQQV9FWFRQTFIJKFBBX0JDUisweDAwMWUpCS8qIEV4dGVudGlvbiBQaW4gUG9sYXJpdHkgY29udHJvbCAqLworI2RlZmluZSBQQV9FWFRQTFIJKFBBX0JDUisweDAwMWUpCS8qIEV4dGVuc2lvbiBQaW4gUG9sYXJpdHkgY29udHJvbCAqLwogI2RlZmluZSBQQV9UUENUTAkoUEFfQkNSKzB4MDEwMCkJLyogVG91Y2ggUGFuZWwgQWNjZXNzIGNvbnRyb2wgKi8KICNkZWZpbmUgUEFfVFBEQ0tDVEwJKFBBX0JDUisweDAxMDIpCS8qIFRvdWNoIFBhbmVsIEFjY2VzcyBkYXRhIGNvbnRyb2wgKi8KICNkZWZpbmUgUEFfVFBDVExDTFIJKFBBX0JDUisweDAxMDQpCS8qIFRvdWNoIFBhbmVsIEFjY2VzcyBjb250cm9sICovCmRpZmYgLS1naXQgYS9hcmNoL3NoL2luY2x1ZGUvbWFjaC1jb21tb24vbWFjaC9yMmQuaCBiL2FyY2gvc2gvaW5jbHVkZS9tYWNoLWNvbW1vbi9tYWNoL3IyZC5oCmluZGV4IDBhODAwMTUuLmUwNGY3NWUgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvaW5jbHVkZS9tYWNoLWNvbW1vbi9tYWNoL3IyZC5oCisrKyBiL2FyY2gvc2gvaW5jbHVkZS9tYWNoLWNvbW1vbi9tYWNoL3IyZC5oCkBAIC0xOCwxOCArMTgsMTggQEAKICNkZWZpbmUgUEFfRElTUENUTAkweGE0MDAwMDA4CS8qIERpc3BsYXkgVGltaW5nIGNvbnRyb2wgKi8KICNkZWZpbmUgUEFfU0RNUE9XCTB4YTQwMDAwMGEJLyogU0QgUG93ZXIgY29udHJvbCAqLwogI2RlZmluZSBQQV9SVENDRQkweGE0MDAwMDBjCS8qIFJUQyg5NzAxKSBFbmFibGUgY29udHJvbCAqLwotI2RlZmluZSBQQV9QQ0lDRAkweGE0MDAwMDBlCS8qIFBDSSBFeHRlbnRpb24gZGV0ZWN0IGNvbnRyb2wgKi8KKyNkZWZpbmUgUEFfUENJQ0QJMHhhNDAwMDAwZQkvKiBQQ0kgRXh0ZW5zaW9uIGRldGVjdCBjb250cm9sICovCiAjZGVmaW5lIFBBX1ZPWUFHRVJSVFMJMHhhNDAwMDAyMAkvKiBWT1lBR0VSIFJlc2V0IGNvbnRyb2wgKi8KIAogI2RlZmluZSBQQV9SMkQxX0FYUlNUCQkweGE0MDAwMDIyCS8qIEFYX0xBTiBSZXNldCBjb250cm9sICovCiAjZGVmaW5lIFBBX1IyRDFfQ0ZSU1QJCTB4YTQwMDAwMjQJLyogQ0YgUmVzZXQgY29udHJvbCAqLwogI2RlZmluZSBQQV9SMkQxX0FETVJUUwkJMHhhNDAwMDAyNgkvKiBTRCBSZXNldCBjb250cm9sICovCi0jZGVmaW5lIFBBX1IyRDFfRVhUUlNUCQkweGE0MDAwMDI4CS8qIEV4dGVudGlvbiBSZXNldCBjb250cm9sICovCisjZGVmaW5lIFBBX1IyRDFfRVhUUlNUCQkweGE0MDAwMDI4CS8qIEV4dGVuc2lvbiBSZXNldCBjb250cm9sICovCiAjZGVmaW5lIFBBX1IyRDFfQ0ZDRElOVENMUgkweGE0MDAwMDJhCS8qIENGIEluc2VydCBJbnRlcnJ1cHQgY2xlYXIgKi8KIAogI2RlZmluZSBQQV9SMkRQTFVTX0NGUlNUCTB4YTQwMDAwMjIJLyogQ0YgUmVzZXQgY29udHJvbCAqLwogI2RlZmluZSBQQV9SMkRQTFVTX0FETVJUUwkweGE0MDAwMDI0CS8qIFNEIFJlc2V0IGNvbnRyb2wgKi8KLSNkZWZpbmUgUEFfUjJEUExVU19FWFRSU1QJMHhhNDAwMDAyNgkvKiBFeHRlbnRpb24gUmVzZXQgY29udHJvbCAqLworI2RlZmluZSBQQV9SMkRQTFVTX0VYVFJTVAkweGE0MDAwMDI2CS8qIEV4dGVuc2lvbiBSZXNldCBjb250cm9sICovCiAjZGVmaW5lIFBBX1IyRFBMVVNfQ0ZDRElOVENMUgkweGE0MDAwMDI4CS8qIENGIEluc2VydCBJbnRlcnJ1cHQgY2xlYXIgKi8KICNkZWZpbmUgUEFfUjJEUExVU19LRVlDVExDTFIJMHhhNDAwMDAyYQkvKiBLZXkgSW50ZXJydXB0IGNsZWFyICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL2NwdS9jbG9jay1jcGcuYyBiL2FyY2gvc2gva2VybmVsL2NwdS9jbG9jay1jcGcuYwppbmRleCBkZDBlMGYyLi44ZjYzYTI2IDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9jcHUvY2xvY2stY3BnLmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvY3B1L2Nsb2NrLWNwZy5jCkBAIC02Nyw3ICs2Nyw3IEBACiB9CiAKIC8qCi0gKiBQbGFjZWhvbGRlciBmb3IgY29tcGF0YWJpbGl0eSwgdW50aWwgdGhlIGxhenkgQ1BVcyBkbyB0aGlzCisgKiBQbGFjZWhvbGRlciBmb3IgY29tcGF0aWJpbGl0eSwgdW50aWwgdGhlIGxhenkgQ1BVcyBkbyB0aGlzCiAgKiBvbiB0aGVpciBvd24uCiAgKi8KIGludCBfX2luaXQgX193ZWFrIGFyY2hfY2xrX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL2NwdS9zaDRhL3NldHVwLXNoNzc4Ni5jIGIvYXJjaC9zaC9rZXJuZWwvY3B1L3NoNGEvc2V0dXAtc2g3Nzg2LmMKaW5kZXggMTY1NmI4Yy4uYmViYTMyYiAxMDA2NDQKLS0tIGEvYXJjaC9zaC9rZXJuZWwvY3B1L3NoNGEvc2V0dXAtc2g3Nzg2LmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvY3B1L3NoNGEvc2V0dXAtc2g3Nzg2LmMKQEAgLTY0OCw3ICs2NDgsNyBAQAogCSAqIFRoZSBmb2xsb3dpbmcgc2V0dGluZ3MgYXJlIG5lY2Vzc2FyeQogCSAqIGZvciB1c2luZyB0aGUgVVNCIG1vZHVsZXMuCiAJICoKLQkgKiBzZWUgIlVTQiBJbml0YWwgU2V0dGluZ3MiIGZvciBkZXRhaWwKKwkgKiBzZWUgIlVTQiBJbml0aWFsIFNldHRpbmdzIiBmb3IgZGV0YWlsCiAJICovCiAJX19yYXdfd3JpdGVsKFVTQklOSVRWQUwxLCBVU0JJTklUUkVHMSk7CiAJX19yYXdfd3JpdGVsKFVTQklOSVRWQUwyLCBVU0JJTklUUkVHMik7CmRpZmYgLS1naXQgYS9hcmNoL3NoL2tlcm5lbC9pcnEuYyBiL2FyY2gvc2gva2VybmVsL2lycS5jCmluZGV4IDY0ZWEwYjEuLjkxOTcxMTAgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gva2VybmVsL2lycS5jCisrKyBiL2FyY2gvc2gva2VybmVsL2lycS5jCkBAIC0xODMsNyArMTgzLDcgQEAKIAkJKTsKIAogCQkvKgotCQkgKiBTaG91bGRudCBoYXBwZW4sIHdlIHJldHVybmVkIGFib3ZlIGlmIGluX2ludGVycnVwdCgpOgorCQkgKiBTaG91bGRuJ3QgaGFwcGVuLCB3ZSByZXR1cm5lZCBhYm92ZSBpZiBpbl9pbnRlcnJ1cHQoKToKIAkJICovCiAJCVdBUk5fT05fT05DRShzb2Z0aXJxX2NvdW50KCkpOwogCX0KZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL3NldHVwLmMgYi9hcmNoL3NoL2tlcm5lbC9zZXR1cC5jCmluZGV4IDRmMjY3MTYuLjU4YmZmNDUgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gva2VybmVsL3NldHVwLmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvc2V0dXAuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAJfQogCiAJLyoKLQkgKiBJZiB3ZSBnb3QgdGhpcyBmYXIgaW5zcGl0ZSBvZiB0aGUgYm9vdCBsb2FkZXIncyBiZXN0IGVmZm9ydHMKKwkgKiBJZiB3ZSBnb3QgdGhpcyBmYXIgaW4gc3BpdGUgb2YgdGhlIGJvb3QgbG9hZGVyJ3MgYmVzdCBlZmZvcnRzCiAJICogdG8gdGhlIGNvbnRyYXJ5LCBhc3N1bWUgd2UgYWN0dWFsbHkgaGF2ZSBhIHZhbGlkIGluaXRyZCBhbmQKIAkgKiBmaXggdXAgdGhlIHJvb3QgZGV2LgogCSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9saWI2NC9jb3B5X3VzZXJfbWVtY3B5LlMgYi9hcmNoL3NoL2xpYjY0L2NvcHlfdXNlcl9tZW1jcHkuUwppbmRleCAyYTYyODE2Li40OWFlYWJlIDEwMDY0NAotLS0gYS9hcmNoL3NoL2xpYjY0L2NvcHlfdXNlcl9tZW1jcHkuUworKysgYi9hcmNoL3NoL2xpYjY0L2NvcHlfdXNlcl9tZW1jcHkuUwpAQCAtMjcsNyArMjcsNyBAQAogISAyLjogV2hlbiB0aGVyZSBhcmUgdHdvIG9yIHRocmVlIGJ5dGVzIGluIHRoZSBsYXN0IHdvcmQgb2YgYW4gMTEtb3ItbW9yZQogISAgICAgYnl0ZXMgbWVtb3J5IGNodW5rIHRvIGIgY29waWVkLCB0aGUgcmVzdCBvZiB0aGUgd29yZCBjYW4gYmUgcmVhZAogISAgICAgd2l0aG91dCBzaWRlIGVmZmVjdHMuCi0hICAgICBUaGlzIGNvdWxkIGJlIGVhc2lseSBjaGFuZ2VkIGJ5IGluY3JlYXNpbmcgdGhlIG1pbnVtdW0gc2l6ZSBvZgorISAgICAgVGhpcyBjb3VsZCBiZSBlYXNpbHkgY2hhbmdlZCBieSBpbmNyZWFzaW5nIHRoZSBtaW5pbXVtIHNpemUgb2YKICEgICAgIGEgZmFzdCBtZW1jcHkgYW5kIHRoZSBhbW91bnQgc3VidHJhY3RlZCBmcm9tIHI3IGJlZm9yZSBMXzJsX2xvb3AgYmUgMiwKICEgICAgIGhvd2V2ZXIsIHRoaXMgd291bGQgY29zdCBhIGZldyBleHRyYSBjeWxlcyBvbiBhdmVyYWdlLgogISAgICAgRm9yIFNIbWVkaWEsIHRoZSBhc3N1bXB0aW9uIGlzIHRoYXQgYW55IHF1YWR3b3JkIGNhbiBiZSByZWFkIGluIGl0cwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9saWI2NC9tZW1jcHkuUyBiL2FyY2gvc2gvbGliNjQvbWVtY3B5LlMKaW5kZXggZGQzMDBjMy4uNWQ2ODJlMCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9saWI2NC9tZW1jcHkuUworKysgYi9hcmNoL3NoL2xpYjY0L21lbWNweS5TCkBAIC0yOSw3ICsyOSw3IEBACiAhIDIuOiBXaGVuIHRoZXJlIGFyZSB0d28gb3IgdGhyZWUgYnl0ZXMgaW4gdGhlIGxhc3Qgd29yZCBvZiBhbiAxMS1vci1tb3JlCiAhICAgICBieXRlcyBtZW1vcnkgY2h1bmsgdG8gYiBjb3BpZWQsIHRoZSByZXN0IG9mIHRoZSB3b3JkIGNhbiBiZSByZWFkCiAhICAgICB3aXRob3V0IHNpZGUgZWZmZWN0cy4KLSEgICAgIFRoaXMgY291bGQgYmUgZWFzaWx5IGNoYW5nZWQgYnkgaW5jcmVhc2luZyB0aGUgbWludW11bSBzaXplIG9mCishICAgICBUaGlzIGNvdWxkIGJlIGVhc2lseSBjaGFuZ2VkIGJ5IGluY3JlYXNpbmcgdGhlIG1pbmltdW0gc2l6ZSBvZgogISAgICAgYSBmYXN0IG1lbWNweSBhbmQgdGhlIGFtb3VudCBzdWJ0cmFjdGVkIGZyb20gcjcgYmVmb3JlIExfMmxfbG9vcCBiZSAyLAogISAgICAgaG93ZXZlciwgdGhpcyB3b3VsZCBjb3N0IGEgZmV3IGV4dHJhIGN5bGVzIG9uIGF2ZXJhZ2UuCiAhICAgICBGb3IgU0htZWRpYSwgdGhlIGFzc3VtcHRpb24gaXMgdGhhdCBhbnkgcXVhZHdvcmQgY2FuIGJlIHJlYWQgaW4gaXRzCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL2h5cGVydmlzb3IuaCBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vaHlwZXJ2aXNvci5oCmluZGV4IGJhZmU1YTYuLjc1Njg2NDAgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vaHlwZXJ2aXNvci5oCisrKyBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vaHlwZXJ2aXNvci5oCkBAIC02NTQsNyArNjU0LDcgQEAKICAqIEFSRzM6CW1tdSBjb250ZXh0CiAgKiBBUkc0OglmbGFncyAoSFZfTU1VX3tJTU1VLERNTVV9KQogICogUkVUMDoJc3RhdHVzCi0gKiBFUlJPUlM6CUVJTlZBTAkJCUludmFsaWQgdmlydXRhbCBhZGRyZXNzLCBjb250ZXh0LCBvcgorICogRVJST1JTOglFSU5WQUwJCQlJbnZhbGlkIHZpcnR1YWwgYWRkcmVzcywgY29udGV4dCwgb3IKICAqCQkJCQlmbGFncyB2YWx1ZQogICoJCUVOT1RTVVBQT1JURUQJCUFSRzAgb3IgQVJHMSBpcyBub24temVybwogICoKQEAgLTcyMSw3ICs3MjEsNyBAQAogICogQVJHMjoJVFRFCiAgKiBBUkczOglmbGFncyAoSFZfTU1VX3tJTU1VLERNTVV9KQogICogUkVUMDoJc3RhdHVzCi0gKiBFUlJPUlM6CUVJTlZBTAkJCUludmFsaWQgdmlydXRhbCBhZGRyZXNzIG9yIGZsYWdzIHZhbHVlCisgKiBFUlJPUlM6CUVJTlZBTAkJCUludmFsaWQgdmlydHVhbCBhZGRyZXNzIG9yIGZsYWdzIHZhbHVlCiAgKgkJRUJBRFBHU1oJCUludmFsaWQgcGFnZSBzaXplIHZhbHVlCiAgKgkJRU5PUkFERFIJCUludmFsaWQgcmVhbCBhZGRyZXNzIGluIFRURQogICoJCUVUT09NQU5ZCQlUb28gbWFueSBtYXBwaW5ncyAobWF4IG9mIDggcmVhY2hlZCkKQEAgLTgwMCw3ICs4MDAsNyBAQAogICogQVJHMToJcmVzZXJ2ZWQsIG11c3QgYmUgemVybwogICogQVJHMjoJZmxhZ3MgKEhWX01NVV97SU1NVSxETU1VfSkKICAqIFJFVDA6CXN0YXR1cwotICogRVJST1JTOglFSU5WQUwJCQlJbnZhbGlkIHZpcnV0YWwgYWRkcmVzcyBvciBmbGFncyB2YWx1ZQorICogRVJST1JTOglFSU5WQUwJCQlJbnZhbGlkIHZpcnR1YWwgYWRkcmVzcyBvciBmbGFncyB2YWx1ZQogICoJCUVOT01BUAkJCVNwZWNpZmllZCBtYXBwaW5nIHdhcyBub3QgZm91bmQKICAqCiAgKiBEZW1hcHMgYW55IHBlcm1hbmVudCBwYWdlIG1hcHBpbmcgKGVzdGFibGlzaGVkIHZpYQpAQCAtMTIwNSw3ICsxMjA1LDcgQEAKICAqIHN0cnVjdHVyZSBjb250ZW50cy4gIEF0dGVtcHRzIHRvIGRvIHNvIHdpbGwgcmVzdWx0IGluIHVuZGVmaW5lZAogICogYmVoYXZpb3IgZm9yIHRoZSBndWVzdC4KICAqCi0gKiBFYWNoIHRyYXAgdHJhY2UgYnVmZmVyIGVudHJ5IGlzIGxheWVkIG91dCBhcyBmb2xsb3dzOgorICogRWFjaCB0cmFwIHRyYWNlIGJ1ZmZlciBlbnRyeSBpcyBsYWlkIG91dCBhcyBmb2xsb3dzOgogICovCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogc3RydWN0IGh2X3RyYXBfdHJhY2VfZW50cnkgewpAQCAtMTMwMCw3ICsxMzAwLDcgQEAKICAqIHN0YXRlIGluIFJFVDEuICBGdXR1cmUgc3lzdGVtcyBtYXkgZGVmaW5lIHZhcmlvdXMgZmxhZ3MgZm9yIHRoZQogICogZW5hYmxlIGFyZ3VtZW50IChBUkcwKSwgZm9yIHRoZSBtb21lbnQgYSBndWVzdCBzaG91bGQgcGFzcwogICogIih1aW50NjRfdCkgLTEiIHRvIGVuYWJsZSwgYW5kICIodWludDY0X3QpIDAiIHRvIGRpc2FibGUgYWxsCi0gKiB0cmFjaW5nIC0gd2hpY2ggd2lsbCBlbnN1cmUgZnV0dXJlIGNvbXBhdGFiaWxpdHkuCisgKiB0cmFjaW5nIC0gd2hpY2ggd2lsbCBlbnN1cmUgZnV0dXJlIGNvbXBhdGliaWxpdHkuCiAgKi8KICNkZWZpbmUgSFZfRkFTVF9UVFJBQ0VfRU5BQkxFCQkweDkyCiAKQEAgLTE4ODAsNyArMTg4MCw3IEBACiAgKiBwY2lfZGV2aWNlLCBhdCBwY2lfY29uZmlnX29mZnNldCBmcm9tIHRoZSBiZWdpbm5pbmcgb2YgdGhlIGRldmljZSdzCiAgKiBjb25maWd1cmF0aW9uIHNwYWNlLiAgSWYgdGhlcmUgd2FzIG5vIGVycm9yLCBSRVQxIGlzIHNldCB0byB6ZXJvIGFuZAogICogUkVUMiBpcyBzZXQgdG8gdGhlIGRhdGEgcmVhZC4gIEluc2lnbmlmaWNhbnQgYml0cyBpbiBSRVQyIGFyZSBub3QKLSAqIGd1YXJlbnRlZWQgdG8gaGF2ZSBhbnkgc3BlY2lmaWMgdmFsdWUgYW5kIHRoZXJlZm9yZSBtdXN0IGJlIGlnbm9yZWQuCisgKiBndWFyYW50ZWVkIHRvIGhhdmUgYW55IHNwZWNpZmljIHZhbHVlIGFuZCB0aGVyZWZvcmUgbXVzdCBiZSBpZ25vcmVkLgogICoKICAqIFRoZSBkYXRhIHJldHVybmVkIGluIFJFVDIgaXMgc2l6ZSBiYXNlZCBieXRlIHN3YXBwZWQuCiAgKgpAQCAtMTk0MSw5ICsxOTQxLDkgQEAKICAqIGFuZCByZXR1cm4gdGhlIGFjdHVhbCBkYXRhIHJlYWQgaW4gUkVUMi4gIFRoZSBkYXRhIHJldHVybmVkIGlzIHNpemUgYmFzZWQKICAqIGJ5dGUgc3dhcHBlZC4KICAqCi0gKiBOb24tc2lnbmlmaWNhbnQgYml0cyBpbiBSRVQyIGFyZSBub3QgZ3VhcmVudGVlZCB0byBoYXZlIGFueSBzcGVjaWZpYyB2YWx1ZQorICogTm9uLXNpZ25pZmljYW50IGJpdHMgaW4gUkVUMiBhcmUgbm90IGd1YXJhbnRlZWQgdG8gaGF2ZSBhbnkgc3BlY2lmaWMgdmFsdWUKICAqIGFuZCB0aGVyZWZvcmUgbXVzdCBiZSBpZ25vcmVkLiAgSWYgUkVUMSBpcyByZXR1cm5lZCBhcyBub24temVybywgdGhlIGRhdGEKLSAqIHZhbHVlIGlzIG5vdCBndWFyZW50ZWVkIHRvIGhhdmUgYW55IHNwZWNpZmljIHZhbHVlIGFuZCBzaG91bGQgYmUgaWdub3JlZC4KKyAqIHZhbHVlIGlzIG5vdCBndWFyYW50ZWVkIHRvIGhhdmUgYW55IHNwZWNpZmljIHZhbHVlIGFuZCBzaG91bGQgYmUgaWdub3JlZC4KICAqCiAgKiBUaGUgY2FsbGVyIG11c3QgaGF2ZSBwZXJtaXNzaW9uIHRvIHJlYWQgZnJvbSB0aGUgZ2l2ZW4gZGV2aGFuZGxlLCByZWFsCiAgKiBhZGRyZXNzLCB3aGljaCBtdXN0IGJlIGFuIElPIGFkZHJlc3MuICBUaGUgYXJndW1lbnQgcmVhbCBhZGRyZXNzIG11c3QgYmUgYQpAQCAtMjQ1Niw5ICsyNDU2LDkgQEAKICAqCiAgKiBBcyByZWNlaXZlIHF1ZXVlIGNvbmZpZ3VyYXRpb24gY2F1c2VzIGEgcmVzZXQgb2YgdGhlIHF1ZXVlJ3MgaGVhZCBhbmQKICAqIHRhaWwgcG9pbnRlcnMgdGhlcmUgaXMgbm8gd2F5IGZvciBhIGd1ZXMgdG8gZGV0ZXJtaW5lIGhvdyBtYW55IGVudHJpZXMKLSAqIGhhdmUgYmVlbiByZWNlaXZlZCBiZXR3ZWVuIGEgcHJlY2VlZGluZyBsZGNfZ2V0X3J4X3N0YXRlKCkgQVBJIGNhbGwKKyAqIGhhdmUgYmVlbiByZWNlaXZlZCBiZXR3ZWVuIGEgcHJlY2VkaW5nIGxkY19nZXRfcnhfc3RhdGUoKSBBUEkgY2FsbAogICogYW5kIHRoZSBjb21wbGV0aW9uIG9mIHRoZSBjb25maWd1cmF0aW9uIG9wZXJhdGlvbi4gIEl0IHNob3VsZCBiZSBub3RlZAotICogdGhhdCBkYXRhZ3JhbSBkZWxpdmVyeSBpcyBub3QgZ3VhcmVudGVlZCB2aWEgZG9tYWluIGNoYW5uZWxzIGFueXdheSwKKyAqIHRoYXQgZGF0YWdyYW0gZGVsaXZlcnkgaXMgbm90IGd1YXJhbnRlZWQgdmlhIGRvbWFpbiBjaGFubmVscyBhbnl3YXksCiAgKiBhbmQgdGhlcmVmb3JlIGFueSBoaWdoZXIgcHJvdG9jb2wgc2hvdWxkIGJlIHJlc2lsaWVudCB0byBkYXRhZ3JhbQogICogbG9zcyBpZiBuZWNlc3NhcnkuICBIb3dldmVyLCB0byBvdmVyY29tZSB0aGlzIHNwZWNpZmljIHJhY2UgcG90ZW50aWFsCiAgKiBpdCBpcyByZWNvbW1lbmRlZCwgZm9yIGV4YW1wbGUsIHRoYXQgYSBoaWdoZXIgbGV2ZWwgcHJvdG9jb2wgYmUgZW1wbG95ZWQKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vbnM4NzMwMy5oIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9uczg3MzAzLmgKaW5kZXggNjg2ZGVmZS4uYWY3NTU0OCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9uczg3MzAzLmgKKysrIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9uczg3MzAzLmgKQEAgLTM3LDcgKzM3LDcgQEAKIC8qIFBvd2VyIGFuZCBUZXN0IFJlZ2lzdGVyIChQVFIpIGJpdHMgKi8KICNkZWZpbmUgUFRSX0xQVEJfSVJRNwkweDA4CiAjZGVmaW5lIFBUUl9MRVZFTF9JUlEJMHg4MAkvKiBXaGVuIG5vdCBFQ1AvRVBQOiBVc2UgbGV2ZWwgSVJRICAgICAgICAgICAqLwotI2RlZmluZSBQVFJfTFBUX1JFR19ESVIJMHg4MAkvKiBXaGVuIEVDUC9FUFA6IExQVCBDVFIgY29udHJvbGxzIGRpcmVjdGlvbiAqLworI2RlZmluZSBQVFJfTFBUX1JFR19ESVIJMHg4MAkvKiBXaGVuIEVDUC9FUFA6IExQVCBDVFIgY29udHJvbHMgZGlyZWN0aW9uICovCiAJCQkJLyogICAgICAgICAgICAgICBvZiB0aGUgcGFyYWxsZWwgcG9ydAkgICAgICovCiAKIC8qIEZ1bmN0aW9uIENvbnRyb2wgUmVnaXN0ZXIgKEZDUikgYml0cyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9wY3IuaCBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vcGNyLmgKaW5kZXggODQzZTRmYS4uMjg4ZDdiZSAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9wY3IuaAorKysgYi9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL3Bjci5oCkBAIC0zMSw3ICszMSw3IEBACiAKIC8qIEluIG9yZGVyIHRvIGNvbW1vbml6ZSBhcyBtdWNoIG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBhcwogICogcG9zc2libGUsIHdlIHVzZSBQSUNIIGFzIG91ciBjb3VudGVyLiAgTW9zdGx5IHRoaXMgaXMKLSAqIHRvIGFjY29tb2RhdGUgTmlhZ2FyYS0xIHdoaWNoIGNhbiBvbmx5IGNvdW50IGluc24gY3ljbGVzCisgKiB0byBhY2NvbW1vZGF0ZSBOaWFnYXJhLTEgd2hpY2ggY2FuIG9ubHkgY291bnQgaW5zbiBjeWNsZXMKICAqIGluIFBJQ0guCiAgKi8KIHN0YXRpYyBpbmxpbmUgdTY0IHBpY2xfdmFsdWUodW5zaWduZWQgaW50IG5taV9oeikKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vcHRyYWNlLmggYi9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL3B0cmFjZS5oCmluZGV4IDMwYjBiNzkuLmM3YWQzZmUgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vcHRyYWNlLmgKKysrIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9wdHJhY2UuaApAQCAtMzMsNyArMzMsNyBAQAogCSAqIHRoaW5ncyBsaWtlICJpbiBhIHN5c3RlbSBjYWxsIiBldGMuIGZvciBhbiBhcmJpdHJheQogCSAqIHByb2Nlc3MuCiAJICoKLQkgKiBUaGUgUFRfUkVHU19NQUdJQyBpcyBjaG9vc2VuIHN1Y2ggdGhhdCBpdCBjYW4gYmUKKwkgKiBUaGUgUFRfUkVHU19NQUdJQyBpcyBjaG9zZW4gc3VjaCB0aGF0IGl0IGNhbiBiZQogCSAqIGxvYWRlZCBjb21wbGV0ZWx5IHVzaW5nIGp1c3QgYSBzZXRoaSBpbnN0cnVjdGlvbi4KIAkgKi8KIAl1bnNpZ25lZCBpbnQgbWFnaWM7CmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9lbnRyeS5TIGIvYXJjaC9zcGFyYy9rZXJuZWwvZW50cnkuUwppbmRleCA5MDZlZTNlLi42ZGE3ODRhIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2tlcm5lbC9lbnRyeS5TCisrKyBiL2FyY2gvc3BhcmMva2VybmVsL2VudHJ5LlMKQEAgLTgwMSw3ICs4MDEsNyBAQAogCS5nbG9ibAl2YWNfaHdmbHVzaF9wYXRjaDFfb24sIHZhY19od2ZsdXNoX3BhdGNoMl9vbgogCiAvKgotICogVWdseSwgYnV0IHdlIGNhbnQgdXNlIGhhcmR3YXJlIGZsdXNoaW5nIG9uIHRoZSBzdW40IGFuZCB3ZSdkIHJlcXVpcmUKKyAqIFVnbHksIGJ1dCB3ZSBjYW4ndCB1c2UgaGFyZHdhcmUgZmx1c2hpbmcgb24gdGhlIHN1bjQgYW5kIHdlJ2QgcmVxdWlyZQogICogdHdvIGluc3RydWN0aW9ucyAoQW50b24pCiAgKi8KIHZhY19od2ZsdXNoX3BhdGNoMV9vbjoJCWFkZGNjCSVsNywgLVBBR0VfU0laRSwgJWw3CkBAIC04NTEsNyArODUxLDcgQEAKIAkgc2V0aGkJJWhpKH4oKDEgPDwgU1VONENfUkVBTF9QR0RJUl9TSElGVCkgLSAxKSksICVsNAogCiAJLyogSWYgdGhlIGtlcm5lbCByZWZlcmVuY2VzIGEgYnVtIGtlcm5lbCBwb2ludGVyLCBvciBhIHB0ZSB3aGljaAotCSAqIHBvaW50cyB0byBhIG5vbiBleGlzdGFudCBwYWdlIGluIHJhbSwgd2Ugd2lsbCBydW4gdGhpcyBjb2RlCisJICogcG9pbnRzIHRvIGEgbm9uIGV4aXN0ZW50IHBhZ2UgaW4gcmFtLCB3ZSB3aWxsIHJ1biB0aGlzIGNvZGUKIAkgKiBfZm9yZXZlcl8gYW5kIGxvY2sgdXAgdGhlIG1hY2hpbmUhISEhISBTbyB3ZSBtdXN0IGNoZWNrIGZvcgogCSAqIHRoaXMgY29uZGl0aW9uLCB0aGUgQUNfU1lOQ19FUlIgYml0cyBhcmUgd2hhdCB3ZSBtdXN0IGV4YW1pbmUuCiAJICogQWxzbyBhIHBhcml0eSBlcnJvciB3b3VsZCBtYWtlIHRoaXMgaGFwcGVuIGFzIHdlbGwuICBTbyB3ZSBqdXN0CmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9oZWFkXzY0LlMgYi9hcmNoL3NwYXJjL2tlcm5lbC9oZWFkXzY0LlMKaW5kZXggZjhmMjEwNS4uYWE1OTRjNyAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwvaGVhZF82NC5TCisrKyBiL2FyY2gvc3BhcmMva2VybmVsL2hlYWRfNjQuUwpAQCAtODUsNyArODUsNyBAQAogc3BhcmM2NF9ib290OgogCW1vdgklbzQsICVsNwogCi0JLyogV2UgbmVlZCB0byByZW1hcCB0aGUga2VybmVsLiAgVXNlIHBvc2l0aW9uIGluZGVwZW5kYW50CisJLyogV2UgbmVlZCB0byByZW1hcCB0aGUga2VybmVsLiAgVXNlIHBvc2l0aW9uIGluZGVwZW5kZW50CiAJICogY29kZSB0byByZW1hcCB1cyB0byBLRVJOQkFTRS4KIAkgKgogCSAqIFNJTE8gY2FuIGludm9rZSB1cyB3aXRoIDMyLWJpdCBhZGRyZXNzIG1hc2tpbmcgZW5hYmxlZCwKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMva2VybmVsL2luaXRfdGFzay5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvaW5pdF90YXNrLmMKaW5kZXggNWZlM2Q2NS4uMzVmMTQxYSAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwvaW5pdF90YXNrLmMKKysrIGIvYXJjaC9zcGFyYy9rZXJuZWwvaW5pdF90YXNrLmMKQEAgLTE1LDcgKzE1LDcgQEAKIAogLyogLnRleHQgc2VjdGlvbiBpbiBoZWFkLlMgaXMgYWxpZ25lZCBhdCA4ayBib3VuZGFyeSBhbmQgdGhpcyBnZXRzIGxpbmtlZAogICogcmlnaHQgYWZ0ZXIgdGhhdCBzbyB0aGF0IHRoZSBpbml0X3RocmVhZF91bmlvbiBpcyBhbGlnbmVkIHByb3Blcmx5IGFzIHdlbGwuCi0gKiBJZiB0aGlzIGlzIG5vdCBhbGlnbmVkIG9uIGEgOGsgYm91bmRyeSwgdGhlbiB5b3Ugc2hvdWxkIGNoYW5nZSBjb2RlCisgKiBJZiB0aGlzIGlzIG5vdCBhbGlnbmVkIG9uIGEgOGsgYm91bmRhcnksIHRoZW4geW91IHNob3VsZCBjaGFuZ2UgY29kZQogICogaW4gZXRyYXAuUyB3aGljaCBhc3N1bWVzIGl0LgogICovCiB1bmlvbiB0aHJlYWRfdW5pb24gaW5pdF90aHJlYWRfdW5pb24gX19pbml0X3Rhc2tfZGF0YSA9CmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9vZl9kZXZpY2VfNjQuYyBiL2FyY2gvc3BhcmMva2VybmVsL29mX2RldmljZV82NC5jCmluZGV4IDYzY2Q0ZTUuLjVjMTQ5NjggMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMva2VybmVsL29mX2RldmljZV82NC5jCisrKyBiL2FyY2gvc3BhcmMva2VybmVsL29mX2RldmljZV82NC5jCkBAIC00NTksNyArNDU5LDcgQEAKIAkJICoKIAkJICogSGFuZGxlIHRoaXMgYnkgZGVjaWRpbmcgdGhhdCwgaWYgd2UgZGlkbid0IGdldCBhCiAJCSAqIG1hdGNoIGluIHRoZSBwYXJlbnQncyAnaW50ZXJydXB0LW1hcCcsIGFuZCB0aGUKLQkJICogcGFyZW50IGlzIGFuIElSUSB0cmFuc2xhdGVyLCB0aGVuIHVzZSB0aGUgcGFyZW50IGFzCisJCSAqIHBhcmVudCBpcyBhbiBJUlEgdHJhbnNsYXRvciwgdGhlbiB1c2UgdGhlIHBhcmVudCBhcwogCQkgKiBvdXIgSVJRIGNvbnRyb2xsZXIuCiAJCSAqLwogCQlpZiAocHAtPmlycV90cmFucykKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMva2VybmVsL3BlcmZfZXZlbnQuYyBiL2FyY2gvc3BhcmMva2VybmVsL3BlcmZfZXZlbnQuYwppbmRleCA3NjA1Nzg2Li5lZTg0MjZlIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2tlcm5lbC9wZXJmX2V2ZW50LmMKKysrIGIvYXJjaC9zcGFyYy9rZXJuZWwvcGVyZl9ldmVudC5jCkBAIC0xMDI3LDcgKzEwMjcsNyBAQAogCiAJLyoKIAkgKiBJZiBncm91cCBldmVudHMgc2NoZWR1bGluZyB0cmFuc2FjdGlvbiB3YXMgc3RhcnRlZCwKLQkgKiBza2lwIHRoZSBzY2hlZHVsYWJpbGl0eSB0ZXN0IGhlcmUsIGl0IHdpbGwgYmUgcGVmb3JtZWQKKwkgKiBza2lwIHRoZSBzY2hlZHVsYWJpbGl0eSB0ZXN0IGhlcmUsIGl0IHdpbGwgYmUgcGVyZm9ybWVkCiAJICogYXQgY29tbWl0IHRpbWUoLT5jb21taXRfdHhuKSBhcyBhIHdob2xlCiAJICovCiAJaWYgKGNwdWMtPmdyb3VwX2ZsYWcgJiBQRVJGX0VWRU5UX1RYTikKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvbWF0aC1lbXUvTWFrZWZpbGUgYi9hcmNoL3NwYXJjL21hdGgtZW11L01ha2VmaWxlCmluZGV4IGI5MDg1ZWMuLjgyNWRiZWUgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvbWF0aC1lbXUvTWFrZWZpbGUKKysrIGIvYXJjaC9zcGFyYy9tYXRoLWVtdS9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKICMgTWFrZWZpbGUgZm9yIHRoZSBGUFUgaW5zdHJ1Y3Rpb24gZW11bGF0aW9uLgogIwogCi0jIHN1cHJlc3MgYWxsIHdhcm5pbmdzIC0gYXMgbWF0aC5jIHByb2R1Y2VzIGEgbG90IQorIyBzdXBwcmVzcyBhbGwgd2FybmluZ3MgLSBhcyBtYXRoLmMgcHJvZHVjZXMgYSBsb3QhCiBjY2ZsYWdzLXkgOj0gLXcKIAogb2JqLXkgICAgOj0gbWF0aF8kKEJJVFMpLm8KZGlmZiAtLWdpdCBhL2FyY2gvdGlsZS9LY29uZmlnIGIvYXJjaC90aWxlL0tjb25maWcKaW5kZXggNmUyY2RkNS4uZTMyYjBjMiAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL0tjb25maWcKKysrIGIvYXJjaC90aWxlL0tjb25maWcKQEAgLTUxLDcgKzUxLDcgQEAKIGNvbmZpZyBHRU5FUklDX0NMT0NLRVZFTlRTCiAJZGVmX2Jvb2wgeQogCi0jIEZJWE1FOiB0aWxlZ3ggY2FuIGltcGxlbWVudCBhIG1vcmUgZWZmaWNlbnQgcndzZW0uCisjIEZJWE1FOiB0aWxlZ3ggY2FuIGltcGxlbWVudCBhIG1vcmUgZWZmaWNpZW50IHJ3c2VtLgogY29uZmlnIFJXU0VNX0dFTkVSSUNfU1BJTkxPQ0sKIAlkZWZfYm9vbCB5CiAKZGlmZiAtLWdpdCBhL2FyY2gvdGlsZS9pbmNsdWRlL2h2L2Rydl94Z2JlX2ludGYuaCBiL2FyY2gvdGlsZS9pbmNsdWRlL2h2L2Rydl94Z2JlX2ludGYuaAppbmRleCAxNDZlNDdkLi5mMTMxODhhIDEwMDY0NAotLS0gYS9hcmNoL3RpbGUvaW5jbHVkZS9odi9kcnZfeGdiZV9pbnRmLmgKKysrIGIvYXJjaC90aWxlL2luY2x1ZGUvaHYvZHJ2X3hnYmVfaW50Zi5oCkBAIC0zMTksNyArMzE5LDcgQEAKICAqICAgICAgICAgaXMgYW4gZXJyb3IgY29kZSwgb3IgemVybyBpZiBubyBlcnJvci4gIFRoZSB2YWwwIG1lbWJlciBpcyB0aGUKICAqICAgICAgICAgdXBkYXRlZCB2YWx1ZSBvZiBzZXFubzsgaXQgaGFzIGJlZW4gaW5jcmVtZW50ZWQgYnkgMSBmb3IgZWFjaAogICogICAgICAgICBwYWNrZXQgc2VudC4gIFRoYXQgaW5jcmVtZW50IG1heSBiZSBsZXNzIHRoYW4gbmVudHJpZXMgaWYgYW4KLSAqICAgICAgICAgZXJyb3Igb2NjdXJlZCwgb3IgaWYgc29tZSBvZiB0aGUgZW50cmllcyBpbiB0aGUgdmVjdG9yIGNvbnRhaW4KKyAqICAgICAgICAgZXJyb3Igb2NjdXJyZWQsIG9yIGlmIHNvbWUgb2YgdGhlIGVudHJpZXMgaW4gdGhlIHZlY3RvciBjb250YWluCiAgKiAgICAgICAgIGhhbmRsZXMgZXF1YWwgdG8gTkVUSU9fUEtUX0hBTkRMRV9OT05FLiAgVGhlIHZhbDEgbWVtYmVyIGlzIHRoZQogICogICAgICAgICB1cGRhdGVkIHZhbHVlIG9mIG5lbnRyaWVzOyBpdCBoYXMgYmVlbiBkZWNyZW1lbnRlZCBieSAxIGZvciBlYWNoCiAgKiAgICAgICAgIHZlY3RvciBlbnRyeSBwcm9jZXNzZWQuICBBZ2FpbiwgdGhhdCBkZWNyZW1lbnQgbWF5IGJlIGxlc3MgdGhhbgpkaWZmIC0tZ2l0IGEvYXJjaC90aWxlL2luY2x1ZGUvaHYvaHlwZXJ2aXNvci5oIGIvYXJjaC90aWxlL2luY2x1ZGUvaHYvaHlwZXJ2aXNvci5oCmluZGV4IDFiOGJmMDMuLmVlNDFiY2EgMTAwNjQ0Ci0tLSBhL2FyY2gvdGlsZS9pbmNsdWRlL2h2L2h5cGVydmlzb3IuaAorKysgYi9hcmNoL3RpbGUvaW5jbHVkZS9odi9oeXBlcnZpc29yLmgKQEAgLTEzNDAsNyArMTM0MCw3IEBACiAgKiAgdGhpcyBvcGVyYXRpb24uICBJZiBhbnkgcGVybWFuZW50IGRlbGl2ZXJ5IGVycm9ycyB3ZXJlIGVuY291bnRlcmVkLAogICogIHRoZSByb3V0aW5lIHJldHVybnMgSFZfRVJFQ0lQLiAgSW4gdGhlIGV2ZW50IG9mIHBlcm1hbmVudCBkZWxpdmVyeQogICogIGVycm9ycywgaXQgbWF5IGJlIHRoZSBjYXNlIHRoYXQgZGVsaXZlcnkgd2FzIG5vdCBhdHRlbXB0ZWQgdG8gYWxsCi0gKiAgcmVjaXBpZW50czsgaWYgYW55IG1lc3NhZ2VzIHdlcmUgc3VjY2VzZnVsbHkgZGVsaXZlcmVkLCBob3dldmVyLAorICogIHJlY2lwaWVudHM7IGlmIGFueSBtZXNzYWdlcyB3ZXJlIHN1Y2Nlc3NmdWxseSBkZWxpdmVyZWQsIGhvd2V2ZXIsCiAgKiAgcmVjaXBpZW50cycgc3RhdGUgdmFsdWVzIHdpbGwgYmUgdXBkYXRlZCBhcHByb3ByaWF0ZWx5LgogICoKICAqICBJdCBpcyBleHBsaWNpdGx5IGxlZ2FsIHRvIHNwZWNpZnkgYSByZWNpcGllbnQgc3RydWN0dXJlIHdob3NlIHN0YXRlCkBAIC0xMzU5LDcgKzEzNTksNyBAQAogICogIG5ldmVyIGNhbGwgaHZfcmVjZWl2ZV9tZXNzYWdlLCBvciBjb3VsZCByZWdpc3RlciBhIGRpZmZlcmVudCBzdGF0ZQogICogIGJ1ZmZlciwgbG9zaW5nIHRoZSBtZXNzYWdlLgogICoKLSAqICBTcGVjaWZpeWluZyB0aGUgc2FtZSByZWNpcGllbnQgbW9yZSB0aGFuIG9uY2UgaW4gdGhlIHJlY2lwaWVudCBsaXN0CisgKiAgU3BlY2lmeWluZyB0aGUgc2FtZSByZWNpcGllbnQgbW9yZSB0aGFuIG9uY2UgaW4gdGhlIHJlY2lwaWVudCBsaXN0CiAgKiAgaXMgYW4gZXJyb3IsIHdoaWNoIHdpbGwgbm90IHJlc3VsdCBpbiBhbiBlcnJvciByZXR1cm4gYnV0IHdoaWNoIG1heQogICogIG9yIG1heSBub3QgcmVzdWx0IGluIG1vcmUgdGhhbiBvbmUgbWVzc2FnZSBiZWluZyBkZWxpdmVyZWQgdG8gdGhlCiAgKiAgcmVjaXBpZW50IHRpbGUuCmRpZmYgLS1naXQgYS9hcmNoL3RpbGUva2VybmVsL3BjaS5jIGIvYXJjaC90aWxlL2tlcm5lbC9wY2kuYwppbmRleCBhMWVlMjViLi5lYTM4ZjBjIDEwMDY0NAotLS0gYS9hcmNoL3RpbGUva2VybmVsL3BjaS5jCisrKyBiL2FyY2gvdGlsZS9rZXJuZWwvcGNpLmMKQEAgLTM2LDcgKzM2LDcgQEAKICAqIEluaXRpYWxpemF0aW9uIGZsb3cgYW5kIHByb2Nlc3MKICAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqCi0gKiBUaGlzIGZpbGVzIGNvbnRhaW5lcyB0aGUgcm91dGluZXMgdG8gc2VhcmNoIGZvciBQQ0kgYnVzZXMsCisgKiBUaGlzIGZpbGVzIGNvbnRhaW5zIHRoZSByb3V0aW5lcyB0byBzZWFyY2ggZm9yIFBDSSBidXNlcywKICAqIGVudW1lcmF0ZSB0aGUgYnVzZXMsIGFuZCBjb25maWd1cmUgYW55IGF0dGFjaGVkIGRldmljZXMuCiAgKgogICogVGhlcmUgYXJlIHR3byBlbnRyeSBwb2ludHMgaGVyZToKQEAgLTUxOSw3ICs1MTksNyBAQAogCiAKIC8qCi0gKiBTZWUgdGlsZV9jZmdfcmVhZCgpIGZvciByZWxldmVudCBjb21tZW50cy4KKyAqIFNlZSB0aWxlX2NmZ19yZWFkKCkgZm9yIHJlbGV2YW50IGNvbW1lbnRzLgogICogTm90ZSB0aGF0ICJ2YWwiIGlzIHRoZSB2YWx1ZSB0byB3cml0ZSwgbm90IGEgcG9pbnRlciB0byB0aGF0IHZhbHVlLgogICovCiBzdGF0aWMgaW50IF9fZGV2aW5pdCB0aWxlX2NmZ193cml0ZShzdHJ1Y3QgcGNpX2J1cyAqYnVzLApkaWZmIC0tZ2l0IGEvYXJjaC90aWxlL21tL2ZhdWx0LmMgYi9hcmNoL3RpbGUvbW0vZmF1bHQuYwppbmRleCA3NThmNTk3Li41MWY4NjYzIDEwMDY0NAotLS0gYS9hcmNoL3RpbGUvbW0vZmF1bHQuYworKysgYi9hcmNoL3RpbGUvbW0vZmF1bHQuYwpAQCAtMjkwLDcgKzI5MCw3IEBACiAJLyoKIAkgKiBFYXJseSBvbiwgd2UgbmVlZCB0byBjaGVjayBmb3IgbWlncmF0aW5nIFBURSBlbnRyaWVzOwogCSAqIHNlZSBob21lY2FjaGUuYy4gIElmIHdlIGZpbmQgYSBtaWdyYXRpbmcgUFRFLCB3ZSB3YWl0IHVudGlsCi0JICogdGhlIGJhY2tpbmcgcGFnZSBjbGFpbXMgdG8gYmUgZG9uZSBtaWdyYXRpbmcsIHRoZW4gd2UgcHJvY2VkZS4KKwkgKiB0aGUgYmFja2luZyBwYWdlIGNsYWltcyB0byBiZSBkb25lIG1pZ3JhdGluZywgdGhlbiB3ZSBwcm9jZWVkLgogCSAqIEZvciBrZXJuZWwgUFRFcywgd2UgcmV3cml0ZSB0aGUgUFRFIGFuZCByZXR1cm4gYW5kIHJldHJ5LgogCSAqIE90aGVyd2lzZSwgd2UgdHJlYXQgdGhlIGZhdWx0IGxpa2UgYSBub3JtYWwgIm5vIFBURSIgZmF1bHQsCiAJICogcmF0aGVyIHRoYW4gdHJ5aW5nIHRvIHBhdGNoIHVwIHRoZSBleGlzdGluZyBQVEUuCmRpZmYgLS1naXQgYS9hcmNoL3RpbGUvbW0vaHVnZXRsYnBhZ2UuYyBiL2FyY2gvdGlsZS9tbS9odWdldGxicGFnZS5jCmluZGV4IDIwMWE1ODIuLjQyY2ZjYmEgMTAwNjQ0Ci0tLSBhL2FyY2gvdGlsZS9tbS9odWdldGxicGFnZS5jCisrKyBiL2FyY2gvdGlsZS9tbS9odWdldGxicGFnZS5jCkBAIC0yMTksNyArMjE5LDcgQEAKIAlpZiAobW0tPmZyZWVfYXJlYV9jYWNoZSA8IGxlbikKIAkJZ290byBmYWlsOwogCi0JLyogZWl0aGVyIG5vIGFkZHJlc3MgcmVxdWVzdGVkIG9yIGNhbnQgZml0IGluIHJlcXVlc3RlZCBhZGRyZXNzIGhvbGUgKi8KKwkvKiBlaXRoZXIgbm8gYWRkcmVzcyByZXF1ZXN0ZWQgb3IgY2FuJ3QgZml0IGluIHJlcXVlc3RlZCBhZGRyZXNzIGhvbGUgKi8KIAlhZGRyID0gKG1tLT5mcmVlX2FyZWFfY2FjaGUgLSBsZW4pICYgaHVnZV9wYWdlX21hc2soaCk7CiAJZG8gewogCQkvKgpkaWZmIC0tZ2l0IGEvYXJjaC91bS9LY29uZmlnLm5ldCBiL2FyY2gvdW0vS2NvbmZpZy5uZXQKaW5kZXggOWU5YTRhYS4uMzE2MGIxYSAxMDA2NDQKLS0tIGEvYXJjaC91bS9LY29uZmlnLm5ldAorKysgYi9hcmNoL3VtL0tjb25maWcubmV0CkBAIC0xODYsNyArMTg2LDcgQEAKICAgICAgICAgb3RoZXIgdHJhbnNwb3J0cywgU0xpUlAgd29ya3Mgd2l0aG91dCB0aGUgbmVlZCBvZiByb290IGxldmVsCiAgICAgICAgIHByaXZsZWdlcywgc2V0dWlkIGJpbmFyaWVzLCBvciBTTElQIGRldmljZXMgb24gdGhlIGhvc3QuICBUaGlzCiAgICAgICAgIGFsc28gbWVhbnMgbm90IGV2ZXJ5IHR5cGUgb2YgY29ubmVjdGlvbiBpcyBwb3NzaWJsZSwgYnV0IG1vc3QKLSAgICAgICAgc2l0dWF0aW9ucyBjYW4gYmUgYWNjb21vZGF0ZWQgd2l0aCBjYXJlZnVsbHkgY3JhZnRlZCBzbGlycAorICAgICAgICBzaXR1YXRpb25zIGNhbiBiZSBhY2NvbW1vZGF0ZWQgd2l0aCBjYXJlZnVsbHkgY3JhZnRlZCBzbGlycAogICAgICAgICBjb21tYW5kcyB0aGF0IGNhbiBiZSBwYXNzZWQgYWxvbmcgYXMgcGFydCBvZiB0aGUgbmV0d29yayBkZXZpY2UncwogICAgICAgICBzZXR1cCBzdHJpbmcuICBUaGUgZWZmZWN0IG9mIHRoaXMgdHJhbnNwb3J0IG9uIHRoZSBVTUwgaXMgc2ltaWxhcgogICAgICAgICB0aGF0IG9mIGEgaG9zdCBiZWhpbmQgYSBmaXJld2FsbCB0aGF0IG1hc3F1ZXJhZGVzIGFsbCBuZXR3b3JrCmRpZmYgLS1naXQgYS9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL21hY2gvcmVncy11bWFsLmggYi9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL21hY2gvcmVncy11bWFsLmgKaW5kZXggODg1YmI2Mi4uYWEyMmRmNyAxMDA2NDQKLS0tIGEvYXJjaC91bmljb3JlMzIvaW5jbHVkZS9tYWNoL3JlZ3MtdW1hbC5oCisrKyBiL2FyY2gvdW5pY29yZTMyL2luY2x1ZGUvbWFjaC9yZWdzLXVtYWwuaApAQCAtNTIsNyArNTIsNyBAQAogICovCiAjZGVmaW5lIFVNQUxfTUlJU1RBVFVTCQkoUEtVTklUWV9VTUFMX0JBU0UgKyAweDAwMzApCiAvKgotICogTUlJIE1hbmFnbWVudCBJbmRpY2F0b3IgVU1BTF9NSUlJRENUCisgKiBNSUkgTWFuYWdlbWVudCBJbmRpY2F0b3IgVU1BTF9NSUlJRENUCiAgKi8KICNkZWZpbmUgVU1BTF9NSUlJRENUCQkoUEtVTklUWV9VTUFMX0JBU0UgKyAweDAwMzQpCiAvKgpAQCAtOTEsNyArOTEsNyBAQAogI2RlZmluZSBVTUFMX0ZJRk9SQU02CQkoUEtVTklUWV9VTUFMX0JBU0UgKyAweDAwNzgpCiAjZGVmaW5lIFVNQUxfRklGT1JBTTcJCShQS1VOSVRZX1VNQUxfQkFTRSArIDB4MDA3YykKIAotLyogTUFIQkUgTU9EVUVMIE9GIFVNQUwgKi8KKy8qIE1BSEJFIE1PRFVMRSBPRiBVTUFMICovCiAvKiBVTUFMJ3MgTUFIQkUgbW9kdWxlIGludGVyZmFjZXMgdG8gdGhlIGhvc3Qgc3lzdGVtIHRocm91Z2ggMzItYml0IEFIQiBNYXN0ZXIKICAqIGFuZCBTbGF2ZSBwb3J0cy5SZWdpc3RlcnMgd2l0aGluIHRoZSBNLUFIQkUgcHJvdmlkZSBDb250cm9sIGFuZCBTdGF0dXMKICAqIGluZm9ybWF0aW9uIGNvbmNlcm5pbmcgdGhlc2UgdHJhbnNmZXJzLgpkaWZmIC0tZ2l0IGEvYXJjaC91bmljb3JlMzIva2VybmVsL2hlYWQuUyBiL2FyY2gvdW5pY29yZTMyL2tlcm5lbC9oZWFkLlMKaW5kZXggOTIyNTVmMy4uOGNhZjMyMiAxMDA2NDQKLS0tIGEvYXJjaC91bmljb3JlMzIva2VybmVsL2hlYWQuUworKysgYi9hcmNoL3VuaWNvcmUzMi9rZXJuZWwvaGVhZC5TCkBAIC0xNjQsNyArMTY0LDcgQEAKIEVORFBST0Moc3RleHQpCiAKIC8qCi0gKiBFbmFibGUgdGhlIE1NVS4gIFRoaXMgY29tcGxldGVseSBjaGFuZ2VzIHRoZSBzdHVjdHVyZSBvZiB0aGUgdmlzaWJsZQorICogRW5hYmxlIHRoZSBNTVUuICBUaGlzIGNvbXBsZXRlbHkgY2hhbmdlcyB0aGUgc3RydWN0dXJlIG9mIHRoZSB2aXNpYmxlCiAgKiBtZW1vcnkgc3BhY2UuICBZb3Ugd2lsbCBub3QgYmUgYWJsZSB0byB0cmFjZSBleGVjdXRpb24gdGhyb3VnaCB0aGlzLgogICoKICAqICByMCAgPSBjcCMwIGNvbnRyb2wgcmVnaXN0ZXIKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2kzODcuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2kzODcuaAppbmRleCBlZjMyODkwLi5jOWUwOWVhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pMzg3LmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vaTM4Ny5oCkBAIC0yMzcsNyArMjM3LDcgQEAKIAl9IGVsc2UgaWYgKHVzZV9meHNyKCkpIHsKIAkJZnB1X2Z4c2F2ZShmcHUpOwogCX0gZWxzZSB7Ci0JCWFzbSB2b2xhdGlsZSgiZnNhdmUgJVtmeF07IGZ3YWl0IgorCQlhc20gdm9sYXRpbGUoImZuc2F2ZSAlW2Z4XTsgZndhaXQiCiAJCQkgICAgIDogW2Z4XSAiPW0iIChmcHUtPnN0YXRlLT5mc2F2ZSkpOwogCQlyZXR1cm47CiAJfQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3NldHVwLmMgYi9hcmNoL3g4Ni9rZXJuZWwvc2V0dXAuYwppbmRleCA1YTA0ODRhLi40YmU5YjM5IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvc2V0dXAuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvc2V0dXAuYwpAQCAtOTc2LDYgKzk3NiwxMSBAQAogCXBhZ2luZ19pbml0KCk7CiAJeDg2X2luaXQucGFnaW5nLnBhZ2V0YWJsZV9zZXR1cF9kb25lKHN3YXBwZXJfcGdfZGlyKTsKIAorCWlmIChib290X2NwdV9kYXRhLmNwdWlkX2xldmVsID49IDApIHsKKwkJLyogQSBDUFUgaGFzICVjcjQgaWYgYW5kIG9ubHkgaWYgaXQgaGFzIENQVUlEICovCisJCW1tdV9jcjRfZmVhdHVyZXMgPSByZWFkX2NyNCgpOworCX0KKwogI2lmZGVmIENPTkZJR19YODZfMzIKIAkvKiBzeW5jIGJhY2sga2VybmVsIGFkZHJlc3MgcmFuZ2UgKi8KIAljbG9uZV9wZ2RfcmFuZ2UoaW5pdGlhbF9wYWdlX3RhYmxlICsgS0VSTkVMX1BHRF9CT1VOREFSWSwKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2bS94ODYuYyBiL2FyY2gveDg2L2t2bS94ODYuYwppbmRleCA1OGY1MTdiLi45MzRiNGM2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rdm0veDg2LmMKKysrIGIvYXJjaC94ODYva3ZtL3g4Ni5jCkBAIC0yMzk1LDkgKzIzOTUsOSBAQAogCQlpbnQgaTsKIAogCQllbnRyeS0+ZmxhZ3MgfD0gS1ZNX0NQVUlEX0ZMQUdfU0lHTklGQ0FOVF9JTkRFWDsKLQkJZm9yIChpID0gMTsgKm5lbnQgPCBtYXhuZW50OyArK2kpIHsKLQkJCWlmIChlbnRyeVtpIC0gMV0uZWF4ID09IDAgJiYgaSAhPSAyKQotCQkJCWJyZWFrOworCQlmb3IgKGkgPSAxOyAqbmVudCA8IG1heG5lbnQgJiYgaSA8IDY0OyArK2kpIHsKKwkJCWlmIChlbnRyeVtpXS5lYXggPT0gMCkKKwkJCQljb250aW51ZTsKIAkJCWRvX2NwdWlkXzFfZW50KCZlbnRyeVtpXSwgZnVuY3Rpb24sIGkpOwogCQkJZW50cnlbaV0uZmxhZ3MgfD0KIAkJCSAgICAgICBLVk1fQ1BVSURfRkxBR19TSUdOSUZDQU5UX0lOREVYOwpAQCAtNDk1OCwxMiArNDk1OCw2IEBACiAJCQliZXN0ID0gZTsKIAkJCWJyZWFrOwogCQl9Ci0JCS8qCi0JCSAqIEJvdGggYmFzaWMgb3IgYm90aCBleHRlbmRlZD8KLQkJICovCi0JCWlmICgoKGUtPmZ1bmN0aW9uIF4gZnVuY3Rpb24pICYgMHg4MDAwMDAwMCkgPT0gMCkKLQkJCWlmICghYmVzdCB8fCBlLT5mdW5jdGlvbiA+IGJlc3QtPmZ1bmN0aW9uKQotCQkJCWJlc3QgPSBlOwogCX0KIAlyZXR1cm4gYmVzdDsKIH0KQEAgLTQ5ODMsNiArNDk3NywyNyBAQAogCXJldHVybiAzNjsKIH0KIAorLyoKKyAqIElmIG5vIG1hdGNoIGlzIGZvdW5kLCBjaGVjayB3aGV0aGVyIHdlIGV4Y2VlZCB0aGUgdkNQVSdzIGxpbWl0CisgKiBhbmQgcmV0dXJuIHRoZSBjb250ZW50IG9mIHRoZSBoaWdoZXN0IHZhbGlkIF9zdGFuZGFyZF8gbGVhZiBpbnN0ZWFkLgorICogVGhpcyBpcyB0byBzYXRpc2Z5IHRoZSBDUFVJRCBzcGVjaWZpY2F0aW9uLgorICovCitzdGF0aWMgc3RydWN0IGt2bV9jcHVpZF9lbnRyeTIqIGNoZWNrX2NwdWlkX2xpbWl0KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdTMyIGZ1bmN0aW9uLCB1MzIgaW5kZXgpCit7CisJc3RydWN0IGt2bV9jcHVpZF9lbnRyeTIgKm1heGxldmVsOworCisJbWF4bGV2ZWwgPSBrdm1fZmluZF9jcHVpZF9lbnRyeSh2Y3B1LCBmdW5jdGlvbiAmIDB4ODAwMDAwMDAsIDApOworCWlmICghbWF4bGV2ZWwgfHwgbWF4bGV2ZWwtPmVheCA+PSBmdW5jdGlvbikKKwkJcmV0dXJuIE5VTEw7CisJaWYgKGZ1bmN0aW9uICYgMHg4MDAwMDAwMCkgeworCQltYXhsZXZlbCA9IGt2bV9maW5kX2NwdWlkX2VudHJ5KHZjcHUsIDAsIDApOworCQlpZiAoIW1heGxldmVsKQorCQkJcmV0dXJuIE5VTEw7CisJfQorCXJldHVybiBrdm1fZmluZF9jcHVpZF9lbnRyeSh2Y3B1LCBtYXhsZXZlbC0+ZWF4LCBpbmRleCk7Cit9CisKIHZvaWQga3ZtX2VtdWxhdGVfY3B1aWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogewogCXUzMiBmdW5jdGlvbiwgaW5kZXg7CkBAIC00OTk1LDYgKzUwMTAsMTAgQEAKIAlrdm1fcmVnaXN0ZXJfd3JpdGUodmNwdSwgVkNQVV9SRUdTX1JDWCwgMCk7CiAJa3ZtX3JlZ2lzdGVyX3dyaXRlKHZjcHUsIFZDUFVfUkVHU19SRFgsIDApOwogCWJlc3QgPSBrdm1fZmluZF9jcHVpZF9lbnRyeSh2Y3B1LCBmdW5jdGlvbiwgaW5kZXgpOworCisJaWYgKCFiZXN0KQorCQliZXN0ID0gY2hlY2tfY3B1aWRfbGltaXQodmNwdSwgZnVuY3Rpb24sIGluZGV4KTsKKwogCWlmIChiZXN0KSB7CiAJCWt2bV9yZWdpc3Rlcl93cml0ZSh2Y3B1LCBWQ1BVX1JFR1NfUkFYLCBiZXN0LT5lYXgpOwogCQlrdm1fcmVnaXN0ZXJfd3JpdGUodmNwdSwgVkNQVV9SRUdTX1JCWCwgYmVzdC0+ZWJ4KTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL3NyYXRfMzIuYyBiL2FyY2gveDg2L21tL3NyYXRfMzIuYwppbmRleCA0ODY1MWM2Li4zNjRmMzZiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9tbS9zcmF0XzMyLmMKKysrIGIvYXJjaC94ODYvbW0vc3JhdF8zMi5jCkBAIC0yMTEsMTAgKzIxMSwxMiBAQAogewogCWludCBpLCBqLCBuaWQ7CiAKLQogCWlmIChzcmF0X2Rpc2FibGVkKCkpCiAJCWdvdG8gb3V0X2ZhaWw7CiAKKwlpZiAoYWNwaV9udW1hX2luaXQoKSA8IDApCisJCWdvdG8gb3V0X2ZhaWw7CisKIAlpZiAobnVtX21lbW9yeV9jaHVua3MgPT0gMCkgewogCQlwcmludGsoS0VSTl9ERUJVRwogCQkJICJjb3VsZCBub3QgZmluZCBhbnkgQUNQSSBTUkFUIG1lbW9yeSBhcmVhcy5cbiIpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGxhdGZvcm0vbXJzdC92cnRjLmMgYi9hcmNoL3g4Ni9wbGF0Zm9ybS9tcnN0L3ZydGMuYwppbmRleCAwNGNmNjQ1Li43M2Q3MGQ2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wbGF0Zm9ybS9tcnN0L3ZydGMuYworKysgYi9hcmNoL3g4Ni9wbGF0Zm9ybS9tcnN0L3ZydGMuYwpAQCAtMTAwLDkgKzEwMCwxMSBAQAogCiB2b2lkIF9faW5pdCBtcnN0X3J0Y19pbml0KHZvaWQpCiB7Ci0JdW5zaWduZWQgbG9uZyB2cnRjX3BhZGRyID0gc2ZpX21ydGNfYXJyYXlbMF0ucGh5c19hZGRyOworCXVuc2lnbmVkIGxvbmcgdnJ0Y19wYWRkcjsKIAogCXNmaV90YWJsZV9wYXJzZShTRklfU0lHX01SVEMsIE5VTEwsIE5VTEwsIHNmaV9wYXJzZV9tcnRjKTsKKworCXZydGNfcGFkZHIgPSBzZmlfbXJ0Y19hcnJheVswXS5waHlzX2FkZHI7CiAJaWYgKCFzZmlfbXJ0Y19udW0gfHwgIXZydGNfcGFkZHIpCiAJCXJldHVybjsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGxhdGZvcm0vdmlzd3Mvdmlzd3NfcXVpcmtzLmMgYi9hcmNoL3g4Ni9wbGF0Zm9ybS92aXN3cy92aXN3c19xdWlya3MuYwppbmRleCBmZTRjZjgyLi5jN2FiZjEzIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wbGF0Zm9ybS92aXN3cy92aXN3c19xdWlya3MuYworKysgYi9hcmNoL3g4Ni9wbGF0Zm9ybS92aXN3cy92aXN3c19xdWlya3MuYwpAQCAtNDcxLDE1ICs0NzEsNyBAQAogewogCWxlZ2FjeV9waWMtPmluaXQoMCk7CiAJZW5hYmxlX2NvYmFsdF9pcnEoZGF0YSk7Ci19Ci0KLXN0YXRpYyB2b2lkIGVuZF9waWl4NF9tYXN0ZXJfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKLXsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmNvYmFsdF9sb2NrLCBmbGFncyk7Ci0JZW5hYmxlX2NvYmFsdF9pcnEoZGF0YSk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY29iYWx0X2xvY2ssIGZsYWdzKTsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBwaWl4NF9tYXN0ZXJfaXJxX3R5cGUgPSB7CkBAIC00OTIsNyArNDg0LDcgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBwaWl4NF92aXJ0dWFsX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJQSUlYNC12aXJ0dWFsIiwKLQkubWFzawkJPSBwaWk0X21hc2ssCisJLmlycV9tYXNrCT0gcGlpNF9tYXNrLAogfTsKIAogLyoKQEAgLTU4MCw5ICs1NzIsOSBAQAogCiBzdGF0aWMgaW5saW5lIHZvaWQgc2V0X3BpaXg0X3ZpcnR1YWxfaXJxX3R5cGUodm9pZCkKIHsKLQlwaWl4NF92aXJ0dWFsX2lycV90eXBlLmVuYWJsZSA9CWk4MjU5QV9jaGlwLnVubWFzazsKLQlwaWl4NF92aXJ0dWFsX2lycV90eXBlLmRpc2FibGUgPSBpODI1OUFfY2hpcC5tYXNrOwotCXBpaXg0X3ZpcnR1YWxfaXJxX3R5cGUudW5tYXNrID0JaTgyNTlBX2NoaXAudW5tYXNrOworCXBpaXg0X3ZpcnR1YWxfaXJxX3R5cGUuaXJxX2VuYWJsZSA9IGk4MjU5QV9jaGlwLmlycV91bm1hc2s7CisJcGlpeDRfdmlydHVhbF9pcnFfdHlwZS5pcnFfZGlzYWJsZSA9IGk4MjU5QV9jaGlwLmlycV9tYXNrOworCXBpaXg0X3ZpcnR1YWxfaXJxX3R5cGUuaXJxX3VubWFzayA9IGk4MjU5QV9jaGlwLmlycV91bm1hc2s7CiB9CiAKIHN0YXRpYyB2b2lkIF9faW5pdCB2aXN3c19wcmVfaW50cl9pbml0KHZvaWQpCkBAIC01OTksNyArNTkxLDcgQEAKIAkJZWxzZSBpZiAoaSA9PSBDT19JUlFfSURFMCkKIAkJCWNoaXAgPSAmY29iYWx0X2lycV90eXBlOwogCQllbHNlIGlmIChpID09IENPX0lSUV9JREUxKQotCQkJPmNoaXAgPSAmY29iYWx0X2lycV90eXBlOworCQkJY2hpcCA9ICZjb2JhbHRfaXJxX3R5cGU7CiAJCWVsc2UgaWYgKGkgPT0gQ09fSVJRXzgyNTkpCiAJCQljaGlwID0gJnBpaXg0X21hc3Rlcl9pcnFfdHlwZTsKIAkJZWxzZSBpZiAoaSA8IENPX0lSUV9BUElDMCkKZGlmZiAtLWdpdCBhL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNtL2RtYS5oIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vZG1hLmgKaW5kZXggMTM3Y2EzOS4uYmIwOTlhMyAxMDA2NDQKLS0tIGEvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vZG1hLmgKKysrIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vZG1hLmgKQEAgLTM3LDcgKzM3LDcgQEAKICAqCXRoZSBzaXplIG9mIHRoZSBzdGF0aWNhbGx5IG1hcHBlZCBrZXJuZWwgc2VnbWVudAogICoJKFhDSEFMX0tTRUdfe0NBQ0hFRCxCWVBBU1N9X1NJWkUpLCBpZS4gMTI4IE1CLgogICoKLSAqIE5PVEU6IFdoZW4gdGhlIGVudGlyZSBLU0VHIGFyZWEgaXMgRE1BIGNhcGFibGUsIHdlIHN1YnN0cmFjdAorICogTk9URTogV2hlbiB0aGUgZW50aXJlIEtTRUcgYXJlYSBpcyBETUEgY2FwYWJsZSwgd2Ugc3VidHJhY3QKICAqCW9uZSBmcm9tIHRoZSBtYXggYWRkcmVzcyBzbyB0aGF0IHRoZSB2aXJ0X3RvX3BoeXMoKSBtYWNybwogICoJd29ya3MgY29ycmVjdGx5IG9uIHRoZSBhZGRyZXNzIChvdGhlcndpc2UgdGhlIGFkZHJlc3MKICAqCWVudGVycyBhbm90aGVyIGFyZWEsIGFuZCB2aXJ0X3RvX3BoeXMoKSBtYXkgbm90IHJldHVybgpkaWZmIC0tZ2l0IGEvYXJjaC94dGVuc2Eva2VybmVsL2VudHJ5LlMgYi9hcmNoL3h0ZW5zYS9rZXJuZWwvZW50cnkuUwppbmRleCA1ZmQwMWY2Li42MjIzZjMzIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9rZXJuZWwvZW50cnkuUworKysgYi9hcmNoL3h0ZW5zYS9rZXJuZWwvZW50cnkuUwpAQCAtMTAyNiw3ICsxMDI2LDcgQEAKICAqIFRSWQkgYWRkcyBhbiBlbnRyeSB0byB0aGUgX19leF90YWJsZSBmaXh1cCB0YWJsZSBmb3IgdGhlIGltbWVkaWF0ZWx5CiAgKgkgZm9sbG93aW5nIGluc3RydWN0aW9uLgogICoKLSAqIENBVENIIGNhdGNoZXMgYW55IGV4Y2VwdGlvbiB0aGF0IG9jY3VycmVkIGF0IG9uZSBvZiB0aGUgcHJlY2VlZGluZyBUUlkKKyAqIENBVENIIGNhdGNoZXMgYW55IGV4Y2VwdGlvbiB0aGF0IG9jY3VycmVkIGF0IG9uZSBvZiB0aGUgcHJlY2VkaW5nIFRSWQogICogICAgICAgc3RhdGVtZW50cyBhbmQgY29udGludWVzIGZyb20gdGhlcmUKICAqCiAgKiBVc2FnZSBUUlkJbDMyaQlhMCwgYTEsIDAKZGlmZiAtLWdpdCBhL2Jsb2NrL2Jsay1jZ3JvdXAuYyBiL2Jsb2NrL2Jsay1jZ3JvdXAuYwppbmRleCAyYmVmNTcwLi5mMDYwNWFiIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY2dyb3VwLmMKKysrIGIvYmxvY2svYmxrLWNncm91cC5jCkBAIC04NjgsNyArODY4LDcgQEAKIH0KIAogLyoKLSAqIFNvbWUgcnVsZXMvdmFsdWVzIGluIGJsa2cgaGF2ZSBjaGFuZ2VkLiBQcm9wb2dhdGUgdGhvc2UgdG8gcmVzcGVjdGl2ZQorICogU29tZSBydWxlcy92YWx1ZXMgaW4gYmxrZyBoYXZlIGNoYW5nZWQuIFByb3BhZ2F0ZSB0aG9zZSB0byByZXNwZWN0aXZlCiAgKiBwb2xpY2llcy4KICAqLwogc3RhdGljIHZvaWQgYmxraW9fdXBkYXRlX2Jsa2dfcG9saWN5KHN0cnVjdCBibGtpb19jZ3JvdXAgKmJsa2NnLApAQCAtOTAzLDcgKzkwMyw3IEBACiB9CiAKIC8qCi0gKiBBIHBvbGljeSBub2RlIHJ1bGUgaGFzIGJlZW4gdXBkYXRlZC4gUHJvcG9nYXRlIHRoaXMgdXBkYXRlIHRvIGFsbCB0aGUKKyAqIEEgcG9saWN5IG5vZGUgcnVsZSBoYXMgYmVlbiB1cGRhdGVkLiBQcm9wYWdhdGUgdGhpcyB1cGRhdGUgdG8gYWxsIHRoZQogICogYmxvY2sgZ3JvdXBzIHdoaWNoIG1pZ2h0IGJlIGFmZmVjdGVkIGJ5IHRoaXMgdXBkYXRlLgogICovCiBzdGF0aWMgdm9pZCBibGtpb191cGRhdGVfcG9saWN5X25vZGVfYmxrZyhzdHJ1Y3QgYmxraW9fY2dyb3VwICpibGtjZywKZGlmZiAtLWdpdCBhL2Jsb2NrL2Jsay1jb3JlLmMgYi9ibG9jay9ibGstY29yZS5jCmluZGV4IDcyNTA5MWQuLjkwZjIyY2MgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1jb3JlLmMKKysrIGIvYmxvY2svYmxrLWNvcmUuYwpAQCAtMTE4NCw3ICsxMTg0LDcgQEAKIAogLyoKICAqIEF0dGVtcHRzIHRvIG1lcmdlIHdpdGggdGhlIHBsdWdnZWQgbGlzdCBpbiB0aGUgY3VycmVudCBwcm9jZXNzLiBSZXR1cm5zCi0gKiB0cnVlIGlmIG1lcmdlIHdhcyBzdWNjZXNmdWwsIG90aGVyd2lzZSBmYWxzZS4KKyAqIHRydWUgaWYgbWVyZ2Ugd2FzIHN1Y2Nlc3NmdWwsIG90aGVyd2lzZSBmYWxzZS4KICAqLwogc3RhdGljIGJvb2wgYXR0ZW1wdF9wbHVnX21lcmdlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwKIAkJCSAgICAgICBzdHJ1Y3QgYmlvICpiaW8pCmRpZmYgLS1naXQgYS9ibG9jay9ibGstdGhyb3R0bGUuYyBiL2Jsb2NrL2Jsay10aHJvdHRsZS5jCmluZGV4IDZjOThjZmUuLjA0NzVhMjIgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay10aHJvdHRsZS5jCisrKyBiL2Jsb2NrL2Jsay10aHJvdHRsZS5jCkBAIC05MTYsNyArOTE2LDcgQEAKIC8qCiAgKiBGb3IgYWxsIHVwZGF0ZSBmdW5jdGlvbnMsIGtleSBzaG91bGQgYmUgYSB2YWxpZCBwb2ludGVyIGJlY2F1c2UgdGhlc2UKICAqIHVwZGF0ZSBmdW5jdGlvbnMgYXJlIGNhbGxlZCB1bmRlciBibGtjZ19sb2NrLCB0aGF0IG1lYW5zLCBibGtnIGlzCi0gKiB2YWxpZCBhbmQgaW4gdHVybiBrZXkgaXMgdmFsaWQuIHF1ZXVlIGV4aXQgcGF0aCBjYW4gbm90IHJhY2UgYmVjdWFzZQorICogdmFsaWQgYW5kIGluIHR1cm4ga2V5IGlzIHZhbGlkLiBxdWV1ZSBleGl0IHBhdGggY2FuIG5vdCByYWNlIGJlY2F1c2UKICAqIG9mIGJsa2NnX2xvY2sKICAqCiAgKiBDYW4gbm90IHRha2UgcXVldWUgbG9jayBpbiB1cGRhdGUgZnVuY3Rpb25zIGFzIHF1ZXVlIGxvY2sgdW5kZXIgYmxrY2dfbG9jawpkaWZmIC0tZ2l0IGEvYmxvY2svYmxrLmggYi9ibG9jay9ibGsuaAppbmRleCBjOGRiMzcxLi42MTI2MzQ2IDEwMDY0NAotLS0gYS9ibG9jay9ibGsuaAorKysgYi9ibG9jay9ibGsuaApAQCAtMzIsNyArMzIsNyBAQAogCiAvKgogICogRUggdGltZXIgYW5kIElPIGNvbXBsZXRpb24gd2lsbCBib3RoIGF0dGVtcHQgdG8gJ2dyYWInIHRoZSByZXF1ZXN0LCBtYWtlCi0gKiBzdXJlIHRoYXQgb25seSBvbmUgb2YgdGhlbSBzdWNlZWRzCisgKiBzdXJlIHRoYXQgb25seSBvbmUgb2YgdGhlbSBzdWNjZWVkcwogICovCiBzdGF0aWMgaW5saW5lIGludCBibGtfbWFya19ycV9jb21wbGV0ZShzdHJ1Y3QgcmVxdWVzdCAqcnEpCiB7CmRpZmYgLS1naXQgYS9ibG9jay9jZnEtaW9zY2hlZC5jIGIvYmxvY2svY2ZxLWlvc2NoZWQuYwppbmRleCA3Nzg1MTY5Li4zYmU4ODFlIDEwMDY0NAotLS0gYS9ibG9jay9jZnEtaW9zY2hlZC5jCisrKyBiL2Jsb2NrL2NmcS1pb3NjaGVkLmMKQEAgLTg4OCw3ICs4ODgsNyBAQAogCS8qCiAJICogQ3VycmVudGx5IHB1dCB0aGUgZ3JvdXAgYXQgdGhlIGVuZC4gTGF0ZXIgaW1wbGVtZW50IHNvbWV0aGluZwogCSAqIHNvIHRoYXQgZ3JvdXBzIGdldCBsZXNzZXIgdnRpbWUgYmFzZWQgb24gdGhlaXIgd2VpZ2h0cywgc28gdGhhdAotCSAqIGlmIGdyb3VwIGRvZXMgbm90IGxvb3NlIGFsbCBpZiBpdCB3YXMgbm90IGNvbnRpbm91c2x5IGJhY2tsb2dnZWQuCisJICogaWYgZ3JvdXAgZG9lcyBub3QgbG9vc2UgYWxsIGlmIGl0IHdhcyBub3QgY29udGludW91c2x5IGJhY2tsb2dnZWQuCiAJICovCiAJbiA9IHJiX2xhc3QoJnN0LT5yYik7CiAJaWYgKG4pIHsKZGlmZiAtLWdpdCBhL2Jsb2NrL2dlbmhkLmMgYi9ibG9jay9nZW5oZC5jCmluZGV4IGM5MWEyZGEuLmIzNjRiZDAgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2dlbmhkLmMKKysrIGIvYmxvY2svZ2VuaGQuYwpAQCAtNzM5LDcgKzczOSw3IEBACiAKIAkJLyoKIAkJICogRG9uJ3Qgc2hvdyBlbXB0eSBkZXZpY2VzIG9yIHRoaW5ncyB0aGF0IGhhdmUgYmVlbgotCQkgKiBzdXJwcmVzc2VkCisJCSAqIHN1cHByZXNzZWQKIAkJICovCiAJCWlmIChnZXRfY2FwYWNpdHkoZGlzaykgPT0gMCB8fAogCQkgICAgKGRpc2stPmZsYWdzICYgR0VOSERfRkxfU1VQUFJFU1NfUEFSVElUSU9OX0lORk8pKQpkaWZmIC0tZ2l0IGEvY3J5cHRvL2Fuc2lfY3BybmcuYyBiL2NyeXB0by9hbnNpX2Nwcm5nLmMKaW5kZXggMmJjMzMyMS4uZmZhMDI0NSAxMDA2NDQKLS0tIGEvY3J5cHRvL2Fuc2lfY3BybmcuYworKysgYi9jcnlwdG8vYW5zaV9jcHJuZy5jCkBAIC04Myw3ICs4Myw3IEBACiB9CiAvKgogICogUmV0dXJucyBERUZBVUxUX0JMS19TWiBieXRlcyBvZiByYW5kb20gZGF0YSBwZXIgY2FsbAotICogcmV0dXJucyAwIGlmIGdlbmVyYXRpb24gc3VjY2VkZWQsIDwwIGlmIHNvbWV0aGluZyB3ZW50IHdyb25nCisgKiByZXR1cm5zIDAgaWYgZ2VuZXJhdGlvbiBzdWNjZWVkZWQsIDwwIGlmIHNvbWV0aGluZyB3ZW50IHdyb25nCiAgKi8KIHN0YXRpYyBpbnQgX2dldF9tb3JlX3BybmdfYnl0ZXMoc3RydWN0IHBybmdfY29udGV4dCAqY3R4LCBpbnQgY29udF90ZXN0KQogewpkaWZmIC0tZ2l0IGEvY3J5cHRvL2FzeW5jX3R4L2FzeW5jX3hvci5jIGIvY3J5cHRvL2FzeW5jX3R4L2FzeW5jX3hvci5jCmluZGV4IDA3OWFlOGMuLmJjMjgzMzcgMTAwNjQ0Ci0tLSBhL2NyeXB0by9hc3luY190eC9hc3luY194b3IuYworKysgYi9jcnlwdG8vYXN5bmNfdHgvYXN5bmNfeG9yLmMKQEAgLTk0LDcgKzk0LDcgQEAKIAkJaWYgKHVubGlrZWx5KCF0eCkpCiAJCQlhc3luY190eF9xdWllc2NlKCZzdWJtaXQtPmRlcGVuZF90eCk7CiAKLQkJLyogc3BpbiB3YWl0IGZvciB0aGUgcHJlY2VlZGluZyB0cmFuc2FjdGlvbnMgdG8gY29tcGxldGUgKi8KKwkJLyogc3BpbiB3YWl0IGZvciB0aGUgcHJlY2VkaW5nIHRyYW5zYWN0aW9ucyB0byBjb21wbGV0ZSAqLwogCQl3aGlsZSAodW5saWtlbHkoIXR4KSkgewogCQkJZG1hX2FzeW5jX2lzc3VlX3BlbmRpbmcoY2hhbik7CiAJCQl0eCA9IGRtYS0+ZGV2aWNlX3ByZXBfZG1hX3hvcihjaGFuLCBkbWFfZGVzdCwKZGlmZiAtLWdpdCBhL2NyeXB0by9nZjEyOG11bC5jIGIvY3J5cHRvL2dmMTI4bXVsLmMKaW5kZXggYTkwZDI2MC4uZGYzNWU0YyAxMDA2NDQKLS0tIGEvY3J5cHRvL2dmMTI4bXVsLmMKKysrIGIvY3J5cHRvL2dmMTI4bXVsLmMKQEAgLTg5LDcgKzg5LDcgQEAKIH0KIAogLyoJR2l2ZW4gdGhlIHZhbHVlIGkgaW4gMC4uMjU1IGFzIHRoZSBieXRlIG92ZXJmbG93IHdoZW4gYSBmaWVsZCBlbGVtZW50Ci0gICAgaW4gR0hBU0ggaXMgbXVsdGlwbGVkIGJ5IHheOCwgdGhpcyBmdW5jdGlvbiB3aWxsIHJldHVybiB0aGUgdmFsdWVzIHRoYXQKKyAgICBpbiBHSEFTSCBpcyBtdWx0aXBsaWVkIGJ5IHheOCwgdGhpcyBmdW5jdGlvbiB3aWxsIHJldHVybiB0aGUgdmFsdWVzIHRoYXQKICAgICBhcmUgZ2VuZXJhdGVkIGluIHRoZSBsbyAxNi1iaXQgd29yZCBvZiB0aGUgZmllbGQgdmFsdWUgYnkgYXBwbHlpbmcgdGhlCiAgICAgbW9kdWxhciBwb2x5bm9taWFsLiBUaGUgdmFsdWVzIGxvX2J5dGUgYW5kIGhpX2J5dGUgYXJlIHJldHVybmVkIHZpYSB0aGUKICAgICBtYWNybyB4cF9mdW4obG9fYnl0ZSwgaGlfYnl0ZSkgc28gdGhhdCB0aGUgdmFsdWVzIGNhbiBiZSBhc3NlbWJsZWQgaW50bwpkaWZmIC0tZ2l0IGEvY3J5cHRvL3ZtYWMuYyBiL2NyeXB0by92bWFjLmMKaW5kZXggMDk5OTI3NC4uZjM1ZmY4YSAxMDA2NDQKLS0tIGEvY3J5cHRvL3ZtYWMuYworKysgYi9jcnlwdG8vdm1hYy5jCkBAIC05NSw3ICs5NSw3IEBACiAKIC8qCiAgKiBGb3IgaGlnaGVzdCBwZXJmb3JtYW5jZSB0aGUgTDEgTkggYW5kIEwyIHBvbHlub21pYWwgaGFzaGVzIHNob3VsZCBiZQotICogY2FyZWZ1bGx5IGltcGxlbWVudGVkIHRvIHRha2UgYWR2YW50YWdlIG9mIG9uZSdzIHRhcmdldCBhcmNoaXRlY2h0dXJlLgorICogY2FyZWZ1bGx5IGltcGxlbWVudGVkIHRvIHRha2UgYWR2YW50YWdlIG9mIG9uZSdzIHRhcmdldCBhcmNoaXRlY3R1cmUuCiAgKiBIZXJlIHRoZXNlIHR3byBoYXNoIGZ1bmN0aW9ucyBhcmUgZGVmaW5lZCBtdWx0aXBsZSB0aW1lOyBvbmNlIGZvcgogICogNjQtYml0IGFyY2hpdGVjdHVyZXMsIG9uY2UgZm9yIDMyLWJpdCBTU0UyIGFyY2hpdGVjdHVyZXMsIGFuZCBvbmNlCiAgKiBmb3IgdGhlIHJlc3QgKDMyLWJpdCkgYXJjaGl0ZWN0dXJlcy4KZGlmZiAtLWdpdCBhL2NyeXB0by94dHMuYyBiL2NyeXB0by94dHMuYwppbmRleCA1NTVlY2FhLi44NTE3MDU0IDEwMDY0NAotLS0gYS9jcnlwdG8veHRzLmMKKysrIGIvY3J5cHRvL3h0cy5jCkBAIC00NSw3ICs0NSw3IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCS8qIHdlIG5lZWQgdHdvIGNpcGhlciBpbnN0YW5jZXM6IG9uZSB0byBjb21wdXRlIHRoZSBpbml0YWwgJ3R3ZWFrJworCS8qIHdlIG5lZWQgdHdvIGNpcGhlciBpbnN0YW5jZXM6IG9uZSB0byBjb21wdXRlIHRoZSBpbml0aWFsICd0d2VhaycKIAkgKiBieSBlbmNyeXB0aW5nIHRoZSBJViAodXN1YWxseSB0aGUgJ3BsYWluJyBpdikgYW5kIHRoZSBvdGhlcgogCSAqIG9uZSB0byBlbmNyeXB0IGFuZCBkZWNyeXB0IHRoZSBkYXRhICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hcGVpL2doZXMuYyBiL2RyaXZlcnMvYWNwaS9hcGVpL2doZXMuYwppbmRleCBkMWQ0ODRkLi5mNzAzYjI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYXBlaS9naGVzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FwZWkvZ2hlcy5jCkBAIC0yNDEsNyArMjQxLDcgQEAKIAljYXNlIENQRVJfU0VWX0ZBVEFMOgogCQlyZXR1cm4gR0hFU19TRVZfUEFOSUM7CiAJZGVmYXVsdDoKLQkJLyogVW5rb3duLCBnbyBwYW5pYyAqLworCQkvKiBVbmtub3duLCBnbyBwYW5pYyAqLwogCQlyZXR1cm4gR0hFU19TRVZfUEFOSUM7CiAJfQogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl90aHJvdHRsaW5nLmMgYi9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX3Rocm90dGxpbmcuYwppbmRleCBmYTg0ZTk3Li5hZDM1MDE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX3Rocm90dGxpbmcuYworKysgYi9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX3Rocm90dGxpbmcuYwpAQCAtMTE2NCw3ICsxMTY0LDcgQEAKIAkJCSAqLwogCQkJaWYgKCFtYXRjaF9wci0+ZmxhZ3MudGhyb3R0bGluZykgewogCQkJCUFDUElfREVCVUdfUFJJTlQoKEFDUElfREJfSU5GTywKLQkJCQkJIlRocm90dGxpbmcgQ29udHJvbGwgaXMgdW5zdXBwb3J0ZWQgIgorCQkJCQkiVGhyb3R0bGluZyBDb250cm9sIGlzIHVuc3VwcG9ydGVkICIKIAkJCQkJIm9uIENQVSAlZFxuIiwgaSkpOwogCQkJCWNvbnRpbnVlOwogCQkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3ZpZGVvLmMgYi9kcml2ZXJzL2FjcGkvdmlkZW8uYwppbmRleCAzMWU5ZTEwLi5lYzU3NGZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvdmlkZW8uYworKysgYi9kcml2ZXJzL2FjcGkvdmlkZW8uYwpAQCAtMTM1NCw3ICsxMzU0LDcgQEAKIAkJc3RhdHVzID0gYWNwaV92aWRlb19idXNfZ2V0X29uZV9kZXZpY2UoZGV2LCB2aWRlbyk7CiAJCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewogCQkJcHJpbnRrKEtFUk5fV0FSTklORyBQUkVGSVgKLQkJCQkJIkNhbnQgYXR0YWNoIGRldmljZVxuIik7CisJCQkJCSJDYW4ndCBhdHRhY2ggZGV2aWNlXG4iKTsKIAkJCWNvbnRpbnVlOwogCQl9CiAJfQpAQCAtMTM3Myw3ICsxMzczLDcgQEAKIAkJCQkJICAgIGFjcGlfdmlkZW9fZGV2aWNlX25vdGlmeSk7CiAJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgUFJFRklYCi0JCSAgICAgICAiQ2FudCByZW1vdmUgdmlkZW8gbm90aWZ5IGhhbmRsZXJcbiIpOworCQkgICAgICAgIkNhbid0IHJlbW92ZSB2aWRlbyBub3RpZnkgaGFuZGxlclxuIik7CiAJfQogCWlmIChkZXZpY2UtPmJhY2tsaWdodCkgewogCQliYWNrbGlnaHRfZGV2aWNlX3VucmVnaXN0ZXIoZGV2aWNlLT5iYWNrbGlnaHQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hbWJhL2J1cy5jIGIvZHJpdmVycy9hbWJhL2J1cy5jCmluZGV4IDZkMmJiMjUuLjgyMTA0MDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYW1iYS9idXMuYworKysgYi9kcml2ZXJzL2FtYmEvYnVzLmMKQEAgLTc2MCw3ICs3NjAsNyBAQAogfQogCiAvKioKLSAqCWFtYmFfcmVsZWFzZV9yZWdpb25zIC0gcmVsZWFzZSBtZW0gcmVnaW9ucyBhc3NvaWNhdGVkIHdpdGggZGV2aWNlCisgKglhbWJhX3JlbGVhc2VfcmVnaW9ucyAtIHJlbGVhc2UgbWVtIHJlZ2lvbnMgYXNzb2NpYXRlZCB3aXRoIGRldmljZQogICoJQGRldjogYW1iYV9kZXZpY2Ugc3RydWN0dXJlIGZvciBkZXZpY2UKICAqCiAgKglSZWxlYXNlIHJlZ2lvbnMgY2xhaW1lZCBieSBhIHN1Y2Nlc3NmdWwgY2FsbCB0byBhbWJhX3JlcXVlc3RfcmVnaW9ucy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2FoY2kuYyBiL2RyaXZlcnMvYXRhL2FoY2kuYwppbmRleCBlNjJmNjkzLi4zOWQ4MjljIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9haGNpLmMKKysrIGIvZHJpdmVycy9hdGEvYWhjaS5jCkBAIC05MjYsNyArOTI2LDcgQEAKIAkJLyoKIAkJICogQWNlciBlTWFjaGluZXMgRzcyNSBoYXMgdGhlIHNhbWUgcHJvYmxlbS4gIEJJT1MKIAkJICogVjEuMDMgaXMga25vd24gdG8gYmUgYnJva2VuLiAgVjMuMDQgaXMga25vd24gdG8KLQkJICogd29yay4gIEluYmV0d2VlbiwgdGhlcmUgYXJlIFYxLjA2LCBWMi4wNiBhbmQgVjMuMDMKKwkJICogd29yay4gIEJldHdlZW4sIHRoZXJlIGFyZSBWMS4wNiwgVjIuMDYgYW5kIFYzLjAzCiAJCSAqIHRoYXQgd2UgZG9uJ3QgaGF2ZSBtdWNoIGlkZWEgYWJvdXQuICBGb3Igbm93LAogCQkgKiBibGFja2xpc3QgYW55dGhpbmcgb2xkZXIgdGhhbiBWMy4wNC4KIAkJICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2FoY2kuaCBiL2RyaXZlcnMvYXRhL2FoY2kuaAppbmRleCBjY2FmMDgxLi4zOTg2NTAwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9haGNpLmgKKysrIGIvZHJpdmVycy9hdGEvYWhjaS5oCkBAIC0yMjUsNyArMjI1LDcgQEAKIAkvKiBlbV9jdGwgYml0cyAqLwogCUVNX0NUTF9SU1QJCT0gKDEgPDwgOSksIC8qIFJlc2V0ICovCiAJRU1fQ1RMX1RNCQk9ICgxIDw8IDgpLCAvKiBUcmFuc21pdCBNZXNzYWdlICovCi0JRU1fQ1RMX01SCQk9ICgxIDw8IDApLCAvKiBNZXNzYWdlIFJlY2lldmVkICovCisJRU1fQ1RMX01SCQk9ICgxIDw8IDApLCAvKiBNZXNzYWdlIFJlY2VpdmVkICovCiAJRU1fQ1RMX0FMSEQJCT0gKDEgPDwgMjYpLCAvKiBBY3Rpdml0eSBMRUQgKi8KIAlFTV9DVExfWE1UCQk9ICgxIDw8IDI1KSwgLyogVHJhbnNtaXQgT25seSAqLwogCUVNX0NUTF9TTUIJCT0gKDEgPDwgMjQpLCAvKiBTaW5nbGUgTWVzc2FnZSBCdWZmZXIgKi8KQEAgLTI4MSw3ICsyODEsNyBAQAogfTsKIAogc3RydWN0IGFoY2lfaG9zdF9wcml2IHsKLQl2b2lkIF9faW9tZW0gKgkJbW1pbzsJCS8qIGJ1cy1pbmRlcGVuZGFudCBtZW0gbWFwICovCisJdm9pZCBfX2lvbWVtICoJCW1taW87CQkvKiBidXMtaW5kZXBlbmRlbnQgbWVtIG1hcCAqLwogCXVuc2lnbmVkIGludAkJZmxhZ3M7CQkvKiBBSENJX0hGTEFHXyogKi8KIAl1MzIJCQljYXA7CQkvKiBjYXAgdG8gdXNlICovCiAJdTMyCQkJY2FwMjsJCS8qIGNhcDIgdG8gdXNlICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9hdGFfcGlpeC5jIGIvZHJpdmVycy9hdGEvYXRhX3BpaXguYwppbmRleCBjZGVjNGFiLi4wYmMzZmQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9hdGFfcGlpeC5jCisrKyBiL2RyaXZlcnMvYXRhL2F0YV9waWl4LmMKQEAgLTM4LDE2ICszOCwxNiBAQAogICogIEhhcmR3YXJlIGRvY3VtZW50YXRpb24gYXZhaWxhYmxlIGF0IGh0dHA6Ly9kZXZlbG9wZXIuaW50ZWwuY29tLwogICoKICAqIERvY3VtZW50YXRpb24KLSAqCVB1YmxpY2FsbHkgYXZhaWxhYmxlIGZyb20gSW50ZWwgd2ViIHNpdGUuIEVycmF0YSBkb2N1bWVudGF0aW9uCi0gKiBpcyBhbHNvIHB1YmxpY2FsbHkgYXZhaWxhYmxlLiBBcyBhbiBhaWRlIHRvIGFueW9uZSBoYWNraW5nIG9uIHRoaXMKKyAqCVB1YmxpY2x5IGF2YWlsYWJsZSBmcm9tIEludGVsIHdlYiBzaXRlLiBFcnJhdGEgZG9jdW1lbnRhdGlvbgorICogaXMgYWxzbyBwdWJsaWNseSBhdmFpbGFibGUuIEFzIGFuIGFpZGUgdG8gYW55b25lIGhhY2tpbmcgb24gdGhpcwogICogZHJpdmVyIHRoZSBsaXN0IG9mIGVycmF0YSB0aGF0IGFyZSByZWxldmFudCBpcyBiZWxvdywgZ29pbmcgYmFjayB0bwogICogUElJWDQuIE9sZGVyIGRldmljZSBkb2N1bWVudGF0aW9uIGlzIG5vdyBhIGJpdCB0cmlja3kgdG8gZmluZC4KICAqCiAgKiBUaGUgY2hpcHNldHMgYWxsIGZvbGxvdyB2ZXJ5IG11Y2ggdGhlIHNhbWUgZGVzaWduLiBUaGUgb3JpZ2luYWwgVHJpdG9uCi0gKiBzZXJpZXMgY2hpcHNldHMgZG8gX25vdF8gc3VwcG9ydCBpbmRlcGVuZGFudCBkZXZpY2UgdGltaW5ncywgYnV0IHRoaXMKKyAqIHNlcmllcyBjaGlwc2V0cyBkbyBfbm90XyBzdXBwb3J0IGluZGVwZW5kZW50IGRldmljZSB0aW1pbmdzLCBidXQgdGhpcwogICogaXMgZml4ZWQgaW4gVHJpdG9uIElJLiBXaXRoIHRoZSBvZGQgbW9iaWxlIGV4Y2VwdGlvbiB0aGUgY2hpcHMgdGhlbgogICogY2hhbmdlIGxpdHRsZSBleGNlcHQgaW4gZ2FpbmluZyBtb3JlIG1vZGVzIHVudGlsIFNBVEEgYXJyaXZlcy4gVGhpcwotICogZHJpdmVyIHN1cHBvcnRzIG9ubHkgdGhlIGNoaXBzIHdpdGggaW5kZXBlbmRhbnQgdGltaW5nICh0aGF0IGlzIHRob3NlCisgKiBkcml2ZXIgc3VwcG9ydHMgb25seSB0aGUgY2hpcHMgd2l0aCBpbmRlcGVuZGVudCB0aW1pbmcgKHRoYXQgaXMgdGhvc2UKICAqIHdpdGggU0lUUkUgYW5kIHRoZSAweDQ0IHRpbWluZyByZWdpc3RlcikuIFNlZSBwYXRhX29sZHBpaXggYW5kIHBhdGFfbXBpaXgKICAqIGZvciB0aGUgZWFybHkgY2hpcCBkcml2ZXJzLgogICoKQEAgLTEyMiw3ICsxMjIsNyBAQAogCVAyCQkJPSAyLCAgLyogcG9ydCAyICovCiAJUDMJCQk9IDMsICAvKiBwb3J0IDMgKi8KIAlJREUJCQk9IC0xLCAvKiBJREUgKi8KLQlOQQkJCT0gLTIsIC8qIG5vdCBhdmFsaWFibGUgKi8KKwlOQQkJCT0gLTIsIC8qIG5vdCBhdmFpbGFibGUgKi8KIAlSVgkJCT0gLTMsIC8qIHJlc2VydmVkICovCiAKIAlQSUlYX0FIQ0lfREVWSUNFCT0gNiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMgYi9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jCmluZGV4IGI5MWUxOWMuLjQyM2MwYTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMKKysrIGIvZHJpdmVycy9hdGEvbGliYXRhLWNvcmUuYwpAQCAtNTM0MCw3ICs1MzQwLDcgQEAKICAqCiAgKglSZXN1bWUgQGhvc3QuICBBY3R1YWwgb3BlcmF0aW9uIGlzIHBlcmZvcm1lZCBieSBFSC4gIFRoaXMKICAqCWZ1bmN0aW9uIHJlcXVlc3RzIEVIIHRvIHBlcmZvcm0gUE0gb3BlcmF0aW9ucyBhbmQgcmV0dXJucy4KLSAqCU5vdGUgdGhhdCBhbGwgcmVzdW1lIG9wZXJhdGlvbnMgYXJlIHBlcmZvcm1lZCBwYXJhbGxlbHkuCisgKglOb3RlIHRoYXQgYWxsIHJlc3VtZSBvcGVyYXRpb25zIGFyZSBwZXJmb3JtZWQgcGFyYWxsZWxseS4KICAqCiAgKglMT0NLSU5HOgogICoJS2VybmVsIHRocmVhZCBjb250ZXh0IChtYXkgc2xlZXApLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvbGliYXRhLWVoLmMgYi9kcml2ZXJzL2F0YS9saWJhdGEtZWguYwppbmRleCBkZjNmMzE0Li44OGNkMjJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtZWguYworKysgYi9kcml2ZXJzL2F0YS9saWJhdGEtZWguYwpAQCAtNzcxLDcgKzc3MSw3IEBACiAJCS8qIHByb2Nlc3MgcG9ydCBzdXNwZW5kIHJlcXVlc3QgKi8KIAkJYXRhX2VoX2hhbmRsZV9wb3J0X3N1c3BlbmQoYXApOwogCi0JCS8qIEV4Y2VwdGlvbiBtaWdodCBoYXZlIGhhcHBlbmQgYWZ0ZXIgLT5lcnJvcl9oYW5kbGVyCisJCS8qIEV4Y2VwdGlvbiBtaWdodCBoYXZlIGhhcHBlbmVkIGFmdGVyIC0+ZXJyb3JfaGFuZGxlcgogCQkgKiByZWNvdmVyZWQgdGhlIHBvcnQgYnV0IGJlZm9yZSB0aGlzIHBvaW50LiAgUmVwZWF0CiAJCSAqIEVIIGluIHN1Y2ggY2FzZS4KIAkJICovCkBAIC0xNzQyLDcgKzE3NDIsNyBAQAogICoKICAqCUFuYWx5emUgdGFza2ZpbGUgb2YgQHFjIGFuZCBmdXJ0aGVyIGRldGVybWluZSBjYXVzZSBvZgogICoJZmFpbHVyZS4gIFRoaXMgZnVuY3Rpb24gYWxzbyByZXF1ZXN0cyBBVEFQSSBzZW5zZSBkYXRhIGlmCi0gKglhdmFsaWFibGUuCisgKglhdmFpbGFibGUuCiAgKgogICoJTE9DS0lORzoKICAqCUtlcm5lbCB0aHJlYWQgY29udGV4dCAobWF5IHNsZWVwKS4KQEAgLTE4OTMsNyArMTg5Myw3IEBACiAgKgkgICBvY2N1cnJlZCBkdXJpbmcgbGFzdCA1IG1pbnMsIE5DUV9PRkYuCiAgKgogICoJMy4gSWYgbW9yZSB0aGFuIDggQVRBX0JVUywgVE9VVF9IU00gb3IgVU5LX0RFViBlcnJvcnMKLSAqCSAgIG9jdXJyZWQgZHVyaW5nIGxhc3QgNSBtaW5zLCBGQUxMQkFDS19UT19QSU8KKyAqCSAgIG9jY3VycmVkIGR1cmluZyBsYXN0IDUgbWlucywgRkFMTEJBQ0tfVE9fUElPCiAgKgogICoJNC4gSWYgbW9yZSB0aGFuIDMgVE9VVF9IU00gb3IgVU5LX0RFViBlcnJvcnMgb2NjdXJyZWQKICAqCSAgIGR1cmluZyBsYXN0IDEwIG1pbnMsIE5DUV9PRkYuCkBAIC0yNTc3LDcgKzI1NzcsNyBAQAogCWlmIChsaW5rLT5mbGFncyAmIEFUQV9MRkxBR19OT19TUlNUKQogCQlzb2Z0cmVzZXQgPSBOVUxMOwogCi0JLyogbWFrZSBzdXJlIGVhY2ggcmVzZXQgYXR0ZW1wIGlzIGF0IGxlYXN0IENPT0xfRE9XTiBhcGFydCAqLworCS8qIG1ha2Ugc3VyZSBlYWNoIHJlc2V0IGF0dGVtcHQgaXMgYXQgbGVhc3QgQ09PTF9ET1dOIGFwYXJ0ICovCiAJaWYgKGVoYy0+aS5mbGFncyAmIEFUQV9FSElfRElEX1JFU0VUKSB7CiAJCW5vdyA9IGppZmZpZXM7CiAJCVdBUk5fT04odGltZV9hZnRlcihlaGMtPmxhc3RfcmVzZXQsIG5vdykpOwpAQCAtMjczNiw3ICsyNzM2LDcgQEAKIAkJCWlmICghcmVzZXQpIHsKIAkJCQlhdGFfbGlua19wcmludGsobGluaywgS0VSTl9FUlIsCiAJCQkJCQkiZm9sbG93LXVwIHNvZnRyZXNldCByZXF1aXJlZCAiCi0JCQkJCQkiYnV0IG5vIHNvZnRyZXNldCBhdmFsaWFibGVcbiIpOworCQkJCQkJImJ1dCBubyBzb2Z0cmVzZXQgYXZhaWxhYmxlXG4iKTsKIAkJCQlmYWlsZWRfbGluayA9IGxpbms7CiAJCQkJcmMgPSAtRUlOVkFMOwogCQkJCWdvdG8gZmFpbDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2xpYmF0YS1zY3NpLmMgYi9kcml2ZXJzL2F0YS9saWJhdGEtc2NzaS5jCmluZGV4IGE4MzQxOTkuLmUyZjU3ZTllIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtc2NzaS5jCisrKyBiL2RyaXZlcnMvYXRhL2xpYmF0YS1zY3NpLmMKQEAgLTk5OSw3ICs5OTksNyBAQAogICoJQHFjOiBDb21tYW5kIHRoYXQgd2UgYXJlIGVycm9yaW5nIG91dAogICoKICAqCUdlbmVyYXRlIHNlbnNlIGJsb2NrIGZvciBhIGZhaWxlZCBBVEEgY29tbWFuZCBAcWMuICBEZXNjcmlwdG9yCi0gKglmb3JtYXQgaXMgdXNlZCB0byBhY2NvbW9kYXRlIExCQTQ4IGJsb2NrIGFkZHJlc3MuCisgKglmb3JtYXQgaXMgdXNlZCB0byBhY2NvbW1vZGF0ZSBMQkE0OCBibG9jayBhZGRyZXNzLgogICoKICAqCUxPQ0tJTkc6CiAgKglOb25lLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvbGliYXRhLXNmZi5jIGIvZHJpdmVycy9hdGEvbGliYXRhLXNmZi5jCmluZGV4IGNmN2FjYmMuLmY4MzgwY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2xpYmF0YS1zZmYuYworKysgYi9kcml2ZXJzL2F0YS9saWJhdGEtc2ZmLmMKQEAgLTI4MzksNyArMjgzOSw3IEBACiAJCWJtZG1hX3N0b3BwZWQgPSB0cnVlOwogCiAJCWlmICh1bmxpa2VseShob3N0X3N0YXQgJiBBVEFfRE1BX0VSUikpIHsKLQkJCS8qIGVycm9yIHdoZW4gdHJhbnNmZXJpbmcgZGF0YSB0by9mcm9tIG1lbW9yeSAqLworCQkJLyogZXJyb3Igd2hlbiB0cmFuc2ZlcnJpbmcgZGF0YSB0by9mcm9tIG1lbW9yeSAqLwogCQkJcWMtPmVycl9tYXNrIHw9IEFDX0VSUl9IT1NUX0JVUzsKIAkJCWFwLT5oc21fdGFza19zdGF0ZSA9IEhTTV9TVF9FUlI7CiAJCX0KQEAgLTMwMzIsNyArMzAzMiw3IEBACiAJICogT3IgbWF5YmUgSSdtIGp1c3QgYmVpbmcgcGFyYW5vaWQuCiAJICoKIAkgKiBGSVhNRTogVGhlIHBvc3Rpbmcgb2YgdGhpcyB3cml0ZSBtZWFucyBJL08gc3RhcnRzIGFyZQotCSAqIHVubmVjY2Vzc2FyaWx5IGRlbGF5ZWQgZm9yIE1NSU8KKwkgKiB1bm5lY2Vzc2FyaWx5IGRlbGF5ZWQgZm9yIE1NSU8KIAkgKi8KIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGF0YV9ibWRtYV9zdGFydCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX2FtZC5jIGIvZHJpdmVycy9hdGEvcGF0YV9hbWQuYwppbmRleCA2MjBhMDdjLi5iMDk3NWE1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9wYXRhX2FtZC5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfYW1kLmMKQEAgLTExLDcgKzExLDcgQEAKICAqCVBvd2VyIG1hbmFnZW1lbnQgb24gcG9ydHMKICAqCiAgKgotICogIERvY3VtZW50YXRpb24gcHVibGljYWxseSBhdmFpbGFibGUuCisgKiAgRG9jdW1lbnRhdGlvbiBwdWJsaWNseSBhdmFpbGFibGUuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvcGF0YV9hcmFzYW5fY2YuYyBiL2RyaXZlcnMvYXRhL3BhdGFfYXJhc2FuX2NmLmMKaW5kZXggNjVjZWU3NC4uNzE5YmI3MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvcGF0YV9hcmFzYW5fY2YuYworKysgYi9kcml2ZXJzL2F0YS9wYXRhX2FyYXNhbl9jZi5jCkBAIC0zODUsNyArMzg1LDcgQEAKIAkJcmV0dXJuIC1FVElNRURPVVQ7CiAJfQogCi0JLyogQ2hlY2sgaWYgUElPIEVycm9yIGludGVycnVwdCBoYXMgb2NjdXJlZCAqLworCS8qIENoZWNrIGlmIFBJTyBFcnJvciBpbnRlcnJ1cHQgaGFzIG9jY3VycmVkICovCiAJaWYgKGFjZGV2LT5kbWFfc3RhdHVzICYgQVRBX0RNQV9FUlIpCiAJCXJldHVybiAtRUFHQUlOOwogCkBAIC00NTAsNyArNDUwLDcgQEAKIAkvKgogCSAqIEZvciBlYWNoIHNnOgogCSAqIE1BWF9YRkVSX0NPVU5UIGRhdGEgd2lsbCBiZSB0cmFuc2ZlcnJlZCBiZWZvcmUgd2UgZ2V0IHRyYW5zZmVyCi0JICogY29tcGxldGUgaW50ZXJydXB0LiBJbmJldHdlZW4gYWZ0ZXIgRklGT19TSVpFIGRhdGEKKwkgKiBjb21wbGV0ZSBpbnRlcnJ1cHQuIEJldHdlZW4gYWZ0ZXIgRklGT19TSVpFIGRhdGEKIAkgKiBidWZmZXIgYXZhaWxhYmxlIGludGVycnVwdCB3aWxsIGJlIGdlbmVyYXRlZC4gQXQgdGhpcyB0aW1lIHdlIHdpbGwKIAkgKiBmaWxsIEZJRk8gYWdhaW46IG1heCBGSUZPX1NJWkUgZGF0YS4KIAkgKi8KQEAgLTQ2Myw3ICs0NjMsNyBAQAogCQkJCWFjZGV2LT52YmFzZSArIFhGRVJfQ1RSKTsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYWNkZXYtPmhvc3QtPmxvY2ssIGZsYWdzKTsKIAotCQkvKiBjb250aW51ZSBkbWEgeGZlcnMgdW50aWxsIGN1cnJlbnQgc2cgaXMgY29tcGxldGVkICovCisJCS8qIGNvbnRpbnVlIGRtYSB4ZmVycyB1bnRpbCBjdXJyZW50IHNnIGlzIGNvbXBsZXRlZCAqLwogCQl3aGlsZSAoeGZlcl9jbnQpIHsKIAkJCS8qIHdhaXQgZm9yIHJlYWQgdG8gY29tcGxldGUgKi8KIAkJCWlmICghd3JpdGUpIHsKQEAgLTU2Myw3ICs1NjMsNyBAQAogCiBjaGFuX3JlcXVlc3RfZmFpbDoKIAlzcGluX2xvY2tfaXJxc2F2ZSgmYWNkZXYtPmhvc3QtPmxvY2ssIGZsYWdzKTsKLQkvKiBlcnJvciB3aGVuIHRyYW5zZmVyaW5nIGRhdGEgdG8vZnJvbSBtZW1vcnkgKi8KKwkvKiBlcnJvciB3aGVuIHRyYW5zZmVycmluZyBkYXRhIHRvL2Zyb20gbWVtb3J5ICovCiAJcWMtPmVycl9tYXNrIHw9IEFDX0VSUl9IT1NUX0JVUzsKIAlxYy0+YXAtPmhzbV90YXNrX3N0YXRlID0gSFNNX1NUX0VSUjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvcGF0YV9iZjU0eC5jIGIvZHJpdmVycy9hdGEvcGF0YV9iZjU0eC5jCmluZGV4IGUwYjU4YjguLmVhNjQ5NjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfYmY1NHguYworKysgYi9kcml2ZXJzL2F0YS9wYXRhX2JmNTR4LmMKQEAgLTEzNDIsNyArMTM0Miw3IEBACiAJCQlhcC0+b3BzLT5ibWRtYV9zdG9wKHFjKTsKIAogCQkJaWYgKHVubGlrZWx5KGhvc3Rfc3RhdCAmIEFUQV9ETUFfRVJSKSkgewotCQkJCS8qIGVycm9yIHdoZW4gdHJhbnNmZXJpbmcgZGF0YSB0by9mcm9tIG1lbW9yeSAqLworCQkJCS8qIGVycm9yIHdoZW4gdHJhbnNmZXJyaW5nIGRhdGEgdG8vZnJvbSBtZW1vcnkgKi8KIAkJCQlxYy0+ZXJyX21hc2sgfD0gQUNfRVJSX0hPU1RfQlVTOwogCQkJCWFwLT5oc21fdGFza19zdGF0ZSA9IEhTTV9TVF9FUlI7CiAJCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX2NzNTUyMC5jIGIvZHJpdmVycy9hdGEvcGF0YV9jczU1MjAuYwppbmRleCAwMzA5NTJmLi5lMzI1NGZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9wYXRhX2NzNTUyMC5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfY3M1NTIwLmMKQEAgLTI5LDcgKzI5LDcgQEAKICAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICAqCiAgKiBEb2N1bWVudGF0aW9uOgotICoJTm90IHB1YmxpY2FsbHkgYXZhaWxhYmxlLgorICoJTm90IHB1YmxpY2x5IGF2YWlsYWJsZS4KICAqLwogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvcGF0YV9tcGlpeC5jIGIvZHJpdmVycy9hdGEvcGF0YV9tcGlpeC5jCmluZGV4IGIyMWYwMDIuLmQ4ZDljNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfbXBpaXguYworKysgYi9kcml2ZXJzL2F0YS9wYXRhX21waWl4LmMKQEAgLTE1LDcgKzE1LDcgQEAKICAqIHdpdGggUENJIElERSBhbmQgYWxzbyB0aGF0IHdlIGRvIG5vdCBkaXNhYmxlIHRoZSBkZXZpY2Ugd2hlbiBvdXIgZHJpdmVyIGlzCiAgKiB1bmxvYWRlZCAoYXMgaXQgaGFzIG1hbnkgb3RoZXIgZnVuY3Rpb25zKS4KICAqCi0gKiBUaGUgZHJpdmVyIGNvbmNpb3VzbHkga2VlcHMgdGhpcyBsb2dpYyBpbnRlcm5hbGx5IHRvIGF2b2lkIHB1c2hpbmcgcXVpcmt5CisgKiBUaGUgZHJpdmVyIGNvbnNjaW91c2x5IGtlZXBzIHRoaXMgbG9naWMgaW50ZXJuYWxseSB0byBhdm9pZCBwdXNoaW5nIHF1aXJreQogICogUEFUQSBoaXN0b3J5IGludG8gdGhlIGNsZWFuIGxpYmF0YSBsYXllci4KICAqCiAgKiBUaGlua3BhZCBzcGVjaWZpYyBub3RlOiBJZiB5b3UgYm9vdCBhbiBNUElJWCB1c2luZyBhIHRoaW5rcGFkIHdpdGggYSBQQ01DSUEKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL3BhdGFfcnoxMDAwLmMgYi9kcml2ZXJzL2F0YS9wYXRhX3J6MTAwMC5jCmluZGV4IDRhNDU0YTguLjRkMDQ0NzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfcnoxMDAwLmMKKysrIGIvZHJpdmVycy9hdGEvcGF0YV9yejEwMDAuYwpAQCAtMTEyLDcgKzExMiw3IEBACiAJaWYgKHJjKQogCQlyZXR1cm4gcmM7CiAKLQkvKiBJZiB0aGlzIGZhaWxzIG9uIHJlc3VtZSAod2hpY2ggaXMgYSAiY2FudCBoYXBwZW4iIGNhc2UpLCB3ZQorCS8qIElmIHRoaXMgZmFpbHMgb24gcmVzdW1lICh3aGljaCBpcyBhICJjYW4ndCBoYXBwZW4iIGNhc2UpLCB3ZQogCSAgIG11c3Qgc3RvcCBhcyBhbnkgcHJvZ3Jlc3Mgcmlza3MgZGF0YSBsb3NzICovCiAJaWYgKHJ6MTAwMF9maWZvX2Rpc2FibGUocGRldikpCiAJCXBhbmljKCJyejEwMDAgZmlmbyIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvcGF0YV9zaWw2ODAuYyBiL2RyaXZlcnMvYXRhL3BhdGFfc2lsNjgwLmMKaW5kZXggMDBlZWZiZC4uMTE4Nzg3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvcGF0YV9zaWw2ODAuYworKysgYi9kcml2ZXJzL2F0YS9wYXRhX3NpbDY4MC5jCkBAIC0xMSw3ICsxMSw3IEBACiAgKgogICogIE1heSBiZSBjb3BpZWQgb3IgbW9kaWZpZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQogICoKLSAqICBEb2N1bWVudGF0aW9uIHB1YmxpY2FsbHkgYXZhaWxhYmxlLgorICogIERvY3VtZW50YXRpb24gcHVibGljbHkgYXZhaWxhYmxlLgogICoKICAqCUlmIHlvdSBoYXZlIHN0cmFuZ2UgcHJvYmxlbXMgd2l0aCBuVmlkaWEgY2hpcHNldCBzeXN0ZW1zIHBsZWFzZQogICoJc2VlIHRoZSBTSSBzdXBwb3J0IGRvY3VtZW50YXRpb24gYW5kIHVwZGF0ZSB5b3VyIHN5c3RlbSBCSU9TCkBAIC00Myw3ICs0Myw3IEBACiAgKgogICoJVHVybiBhIGNvbmZpZyByZWdpc3RlciBvZmZzZXQgaW50byB0aGUgcmlnaHQgYWRkcmVzcyBpbiBlaXRoZXIKICAqCVBDSSBzcGFjZSBvciBNTUlPIHNwYWNlIHRvIGFjY2VzcyB0aGUgY29udHJvbCByZWdpc3RlciBpbiBxdWVzdGlvbgotICoJVGhhbmtmdWxseSB0aGlzIGlzIGEgY29uZmlndXJhdGlvbiBvcGVyYXRpb24gc28gaXNudCBwZXJmb3JtYW5jZQorICoJVGhhbmtmdWxseSB0aGlzIGlzIGEgY29uZmlndXJhdGlvbiBvcGVyYXRpb24gc28gaXNuJ3QgcGVyZm9ybWFuY2UKICAqCWNyaXRpY2lhbC4KICAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX3Npcy5jIGIvZHJpdmVycy9hdGEvcGF0YV9zaXMuYwppbmRleCBjMDRhYmMzLi5iZTA4ZmY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9wYXRhX3Npcy5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfc2lzLmMKQEAgLTMzMSw3ICszMzEsNyBAQAogCiAJaWYgKGFkZXYtPmRtYV9tb2RlIDwgWEZFUl9VRE1BXzApIHsKIAkJLyogYml0cyAzLTAgaG9sZCByZWNvdmVyeSB0aW1pbmcgYml0cyA4LTEwIGFjdGl2ZSB0aW1pbmcgYW5kCi0JCSAgIHRoZSBoaWdoZXIgYml0cyBhcmUgZGVwZW5kYW50IG9uIHRoZSBkZXZpY2UgKi8KKwkJICAgdGhlIGhpZ2hlciBiaXRzIGFyZSBkZXBlbmRlbnQgb24gdGhlIGRldmljZSAqLwogCQl0aW1pbmcgJj0gfjB4ODcwRjsKIAkJdGltaW5nIHw9IG13ZG1hX2JpdHNbc3BlZWRdOwogCX0gZWxzZSB7CkBAIC0zNzEsNyArMzcxLDcgQEAKIAogCWlmIChhZGV2LT5kbWFfbW9kZSA8IFhGRVJfVURNQV8wKSB7CiAJCS8qIGJpdHMgMy0wIGhvbGQgcmVjb3ZlcnkgdGltaW5nIGJpdHMgOC0xMCBhY3RpdmUgdGltaW5nIGFuZAotCQkgICB0aGUgaGlnaGVyIGJpdHMgYXJlIGRlcGVuZGFudCBvbiB0aGUgZGV2aWNlLCBiaXQgMTUgdWRtYSAqLworCQkgICB0aGUgaGlnaGVyIGJpdHMgYXJlIGRlcGVuZGVudCBvbiB0aGUgZGV2aWNlLCBiaXQgMTUgdWRtYSAqLwogCQl0aW1pbmcgJj0gfjB4ODcwRjsKIAkJdGltaW5nIHw9IG13ZG1hX2JpdHNbc3BlZWRdOwogCX0gZWxzZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX3RyaWZsZXguYyBiL2RyaXZlcnMvYXRhL3BhdGFfdHJpZmxleC5jCmluZGV4IDBkMWY4OWUuLjAzYjZkNjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfdHJpZmxleC5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfdHJpZmxleC5jCkBAIC0zMCw3ICszMCw3IEBACiAgKiBMb29zZWx5IGJhc2VkIG9uIHRoZSBwaWl4ICYgc3Z3a3MgZHJpdmVycy4KICAqCiAgKiBEb2N1bWVudGF0aW9uOgotICoJTm90IHB1YmxpY2FsbHkgYXZhaWxhYmxlLgorICoJTm90IHB1YmxpY2x5IGF2YWlsYWJsZS4KICAqLwogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9zYXRhX2ZzbC5jIGIvZHJpdmVycy9hdGEvc2F0YV9mc2wuYwppbmRleCAwZjkxZTU4Li4zNWE3MWQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9zYXRhX2ZzbC5jCisrKyBiL2RyaXZlcnMvYXRhL3NhdGFfZnNsLmMKQEAgLTQyLDcgKzQyLDcgQEAKIAogCS8qCiAJICogU0FUQS1GU0wgaG9zdCBjb250cm9sbGVyIHN1cHBvcnRzIGEgbWF4LiBvZiAoMTUrMSkgZGlyZWN0IFBSREVzLCBhbmQKLQkgKiBjaGFpbmVkIGluZGlyZWN0IFBSREVzIHVwdG8gYSBtYXggY291bnQgb2YgNjMuCisJICogY2hhaW5lZCBpbmRpcmVjdCBQUkRFcyB1cCB0byBhIG1heCBjb3VudCBvZiA2My4KIAkgKiBXZSBhcmUgYWxsb2NhdGluZyBhbiBhcnJheSBvZiA2MyBQUkRFcyBjb250aWd1b3VzbHksIGJ1dCBQUkRFIzE1IHdpbGwKIAkgKiBiZSBzZXR1cCBhcyBhbiBpbmRpcmVjdCBkZXNjcmlwdG9yLCBwb2ludGluZyB0byBpdCdzIG5leHQKIAkgKiAoY29udGlndW91cykgUFJERS4gVGhvdWdoIGNoYWluZWQgaW5kaXJlY3QgUFJERSBhcnJheXMgYXJlCkBAIC05MDcsNyArOTA3LDcgQEAKIAlhdGFfbXNsZWVwKGFwLCAxKTsKIAogCS8qCi0JICogU0FUQSBkZXZpY2UgZW50ZXJzIHJlc2V0IHN0YXRlIGFmdGVyIHJlY2V2aW5nIGEgQ29udHJvbCByZWdpc3RlcgorCSAqIFNBVEEgZGV2aWNlIGVudGVycyByZXNldCBzdGF0ZSBhZnRlciByZWNlaXZpbmcgYSBDb250cm9sIHJlZ2lzdGVyCiAJICogRklTIHdpdGggU1JTVCBiaXQgYXNzZXJ0ZWQgYW5kIGl0IGF3YWl0cyBhbm90aGVyIEgyRCBDb250cm9sIHJlZy4KIAkgKiBGSVMgd2l0aCBTUlNUIGJpdCBjbGVhcmVkLCB0aGVuIHRoZSBkZXZpY2UgZG9lcyBpbnRlcm5hbCBkaWFncyAmCiAJICogaW5pdGlhbGl6YXRpb24sIGZvbGxvd2VkIGJ5IGluZGljYXRpbmcgaXQncyBpbml0aWFsaXphdGlvbiBzdGF0dXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL3NhdGFfbXYuYyBiL2RyaXZlcnMvYXRhL3NhdGFfbXYuYwppbmRleCBjZDQwNjUxLi5iNTJjMDUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9zYXRhX212LmMKKysrIGIvZHJpdmVycy9hdGEvc2F0YV9tdi5jCkBAIC0xMzUyLDcgKzEzNTIsNyBAQAogCQkJLyoKIAkJCSAqIFdvcmthcm91bmQgZm9yIDg4U1g2MHgxIEZFciBTQVRBIzI2OgogCQkJICoKLQkJCSAqIENPTVJFU0VUcyBoYXZlIHRvIHRha2UgY2FyZSBub3QgdG8gYWNjaWRlbnRseQorCQkJICogQ09NUkVTRVRzIGhhdmUgdG8gdGFrZSBjYXJlIG5vdCB0byBhY2NpZGVudGFsbHkKIAkJCSAqIHB1dCB0aGUgZHJpdmUgdG8gc2xlZXAgd2hlbiB3cml0aW5nIFNDUl9DT05UUk9MLgogCQkJICogU2V0dGluZyBiaXRzIDEyLi4xNSBwcmV2ZW50cyB0aGlzIHByb2JsZW0uCiAJCQkgKgpAQCAtMjA0NCw3ICsyMDQ0LDcgQEAKIAogCWN3ID0gJnBwLT5jcnFiW2luX2luZGV4XS5hdGFfY21kWzBdOwogCi0JLyogU2FkbHksIHRoZSBDUlFCIGNhbm5vdCBhY2NvbW9kYXRlIGFsbCByZWdpc3RlcnMtLXRoZXJlIGFyZQorCS8qIFNhZGx5LCB0aGUgQ1JRQiBjYW5ub3QgYWNjb21tb2RhdGUgYWxsIHJlZ2lzdGVycy0tdGhlcmUgYXJlCiAJICogb25seSAxMSBieXRlcy4uLnNvIHdlIG11c3QgcGljayBhbmQgY2hvb3NlIHJlcXVpcmVkCiAJICogcmVnaXN0ZXJzIGJhc2VkIG9uIHRoZSBjb21tYW5kLiAgU28sIHdlIGRyb3AgZmVhdHVyZSBhbmQKIAkgKiBob2JfZmVhdHVyZSBmb3IgW1JXXSBETUEgY29tbWFuZHMsIGJ1dCB0aGV5IGFyZSBuZWVkZWQgZm9yCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9zYXRhX252LmMgYi9kcml2ZXJzL2F0YS9zYXRhX252LmMKaW5kZXggNDIzNDRlMy4uZjE3M2VmMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvc2F0YV9udi5jCisrKyBiL2RyaXZlcnMvYXRhL3NhdGFfbnYuYwpAQCAtMjEyMSw3ICsyMTIxLDcgQEAKIAogCWhvc3Rfc3RhdCA9IGFwLT5vcHMtPmJtZG1hX3N0YXR1cyhhcCk7CiAJaWYgKHVubGlrZWx5KGhvc3Rfc3RhdCAmIEFUQV9ETUFfRVJSKSkgewotCQkvKiBlcnJvciB3aGVuIHRyYW5zZmVyaW5nIGRhdGEgdG8vZnJvbSBtZW1vcnkgKi8KKwkJLyogZXJyb3Igd2hlbiB0cmFuc2ZlcnJpbmcgZGF0YSB0by9mcm9tIG1lbW9yeSAqLwogCQlhdGFfZWhpX2NsZWFyX2Rlc2MoZWhpKTsKIAkJYXRhX2VoaV9wdXNoX2Rlc2MoZWhpLCAiQk1ETUEgc3RhdCAweCV4IiwgaG9zdF9zdGF0KTsKIAkJZWhpLT5lcnJfbWFzayB8PSBBQ19FUlJfSE9TVF9CVVM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9zYXRhX3ZpYS5jIGIvZHJpdmVycy9hdGEvc2F0YV92aWEuYwppbmRleCAyMTI0MmM1Li41NDQzNGRiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9zYXRhX3ZpYS5jCisrKyBiL2RyaXZlcnMvYXRhL3NhdGFfdmlhLmMKQEAgLTU4Miw3ICs1ODIsNyBAQAogCSAqIFdoZW4gaG9zdCBpc3N1ZXMgSE9MRCwgZGV2aWNlIG1heSBzZW5kIHVwIHRvIDIwRFcgb2YgZGF0YQogCSAqIGJlZm9yZSBhY2tub3dsZWRnaW5nIGl0IHdpdGggSE9MREEgYW5kIHRoZSBob3N0IHNob3VsZCBiZQogCSAqIGFibGUgdG8gYnVmZmVyIHRoZW0gaW4gRklGTy4gIFVuZm9ydHVuYXRlbHksIHNvbWUgV0QgZHJpdmVzCi0JICogc2VuZCB1cHRvIDQwRFcgYmVmb3JlIGFja25vd2xlZGdpbmcgSE9MRCBhbmQsIGluIHRoZQorCSAqIHNlbmQgdXAgdG8gNDBEVyBiZWZvcmUgYWNrbm93bGVkZ2luZyBIT0xEIGFuZCwgaW4gdGhlCiAJICogZGVmYXVsdCBjb25maWd1cmF0aW9uLCB0aGlzIGVuZHMgdXAgb3ZlcmZsb3dpbmcgdnQ2NDIxJ3MKIAkgKiBGSUZPLCBtYWtpbmcgdGhlIGNvbnRyb2xsZXIgYWJvcnQgdGhlIHRyYW5zYWN0aW9uIHdpdGgKIAkgKiBSX0VSUi4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRtL2FtYmFzc2Fkb3IuYyBiL2RyaXZlcnMvYXRtL2FtYmFzc2Fkb3IuYwppbmRleCA5ZjQ3ZTg2Li5hNWZjYjFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0bS9hbWJhc3NhZG9yLmMKKysrIGIvZHJpdmVycy9hdG0vYW1iYXNzYWRvci5jCkBAIC00OTcsNyArNDk3LDcgQEAKIAkgIC8vIFZDIGxheWVyIHN0YXRzCiAJICBhdG9taWNfaW5jKCZhdG1fdmNjLT5zdGF0cy0+cngpOwogCSAgX19uZXRfdGltZXN0YW1wKHNrYik7Ci0JICAvLyBlbmQgb2Ygb3VyIHJlc3BvbnNhYmlsaXR5CisJICAvLyBlbmQgb2Ygb3VyIHJlc3BvbnNpYmlsaXR5CiAJICBhdG1fdmNjLT5wdXNoIChhdG1fdmNjLCBza2IpOwogCSAgcmV0dXJuOwogCSAgCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0bS9maXJlc3RyZWFtLmMgYi9kcml2ZXJzL2F0bS9maXJlc3RyZWFtLmMKaW5kZXggMDQ5NjUwZC4uZWY3YTY1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdG0vZmlyZXN0cmVhbS5jCisrKyBiL2RyaXZlcnMvYXRtL2ZpcmVzdHJlYW0uYwpAQCAtMTc4Miw3ICsxNzgyLDcgQEAKIAkJd3JpdGVfZnMgKGRldiwgUkFTMCwgUkFTMF9EQ0RfWEhMVCAKIAkJCSAgfCAoKCgxIDw8IEZTMTU1X1ZQSV9CSVRTKSAtIDEpICogUkFTMF9WUFNFTCkKIAkJCSAgfCAoKCgxIDw8IEZTMTU1X1ZDSV9CSVRTKSAtIDEpICogUkFTMF9WQ1NFTCkpOwotCQkvKiBXZSBjYW4gY2hvc2UgdGhlIHNwbGl0IGFyYml0YXJpbHkuIFdlIG1pZ2h0IGJlIGFibGUgdG8gCisJCS8qIFdlIGNhbiBjaG9zZSB0aGUgc3BsaXQgYXJiaXRyYXJpbHkuIFdlIG1pZ2h0IGJlIGFibGUgdG8gCiAJCSAgIHN1cHBvcnQgbW9yZS4gV2hhdGV2ZXIuIFRoaXMgc2hvdWxkIGRvIGZvciBub3cuICovCiAJCWRldi0+YXRtX2Rldi0+Y2lfcmFuZ2UudnBpX2JpdHMgPSBGUzE1NV9WUElfQklUUzsKIAkJZGV2LT5hdG1fZGV2LT5jaV9yYW5nZS52Y2lfYml0cyA9IEZTMTU1X1ZDSV9CSVRTOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdG0vZm9yZTIwMGUuaCBiL2RyaXZlcnMvYXRtL2ZvcmUyMDBlLmgKaW5kZXggN2Y5N2MwOS4uYmEzNGEwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdG0vZm9yZTIwMGUuaAorKysgYi9kcml2ZXJzL2F0bS9mb3JlMjAwZS5oCkBAIC0yNjMsNyArMjYzLDcgQEAKIH0gb3Bjb2RlX3Q7CiAKIAotLyogdmlydHVhbCBwYXRoIC8gdmlydHVhbCBjaGFubmVsIGlkZW50aWZlcnMgKi8KKy8qIHZpcnR1YWwgcGF0aCAvIHZpcnR1YWwgY2hhbm5lbCBpZGVudGlmaWVycyAqLwogCiB0eXBlZGVmIHN0cnVjdCB2cHZjIHsKICAgICBCSVRGSUVMRDMoCkBAIC05MjYsNyArOTI2LDcgQEAKIAogI2RlZmluZSBQQ0EyMDBFX1BDSV9MQVRFTkNZICAgICAgMHg0MCAgICAvKiBtYXhpbXVtIHNsYXZlIGxhdGVudHkgICAgICAgICAgICAqLwogI2RlZmluZSBQQ0EyMDBFX1BDSV9NQVNURVJfQ1RSTCAgMHg0MSAgICAvKiBtYXN0ZXIgY29udHJvbCAgICAgICAgICAgICAgICAgICAqLwotI2RlZmluZSBQQ0EyMDBFX1BDSV9USFJFU0hPTEQgICAgMHg0MiAgICAvKiBidXJzdCAvIGNvbnRpbm91cyByZXEgdGhyZXNob2xkICAqLworI2RlZmluZSBQQ0EyMDBFX1BDSV9USFJFU0hPTEQgICAgMHg0MiAgICAvKiBidXJzdCAvIGNvbnRpbnVvdXMgcmVxIHRocmVzaG9sZCAgKi8KIAogLyogUEJJIG1hc3RlciBjb250cm9sIHJlZ2lzdGVyICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRtL2hvcml6b24uYyBiL2RyaXZlcnMvYXRtL2hvcml6b24uYwppbmRleCAyNDc2MWUxLi5kNThlM2ZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0bS9ob3Jpem9uLmMKKysrIGIvZHJpdmVycy9hdG0vaG9yaXpvbi5jCkBAIC0xNjksMTMgKzE2OSwxMyBAQAogICBSZWFsIFRpbWUgKGNkdiBhbmQgbWF4IENEVCBnaXZlbikKICAgCiAgIENCUihwY3IpICAgICAgICAgICAgIHBjciBiYW5kd2lkdGggYWx3YXlzIGF2YWlsYWJsZQotICBydFZCUihwY3Isc2NyLG1icykgICBzY3IgYmFuZHdpZHRoIGFsd2F5cyBhdmFpbGFibGUsIHVwdG8gcGNyIGF0IG1icyB0b28KKyAgcnRWQlIocGNyLHNjcixtYnMpICAgc2NyIGJhbmR3aWR0aCBhbHdheXMgYXZhaWxhYmxlLCB1cCB0byBwY3IgYXQgbWJzIHRvbwogICAKICAgTm9uIFJlYWwgVGltZQogICAKLSAgbnJ0VkJSKHBjcixzY3IsbWJzKSAgc2NyIGJhbmR3aWR0aCBhbHdheXMgYXZhaWxhYmxlLCB1cHRvIHBjciBhdCBtYnMgdG9vCisgIG5ydFZCUihwY3Isc2NyLG1icykgIHNjciBiYW5kd2lkdGggYWx3YXlzIGF2YWlsYWJsZSwgdXAgdG8gcGNyIGF0IG1icyB0b28KICAgVUJSKCkKLSAgQUJSKG1jcixwY3IpICAgICAgICAgbWNyIGJhbmR3aWR0aCBhbHdheXMgYXZhaWxhYmxlLCB1cHRvIHBjciAoZGVwZW5kaW5nKSB0b28KKyAgQUJSKG1jcixwY3IpICAgICAgICAgbWNyIGJhbmR3aWR0aCBhbHdheXMgYXZhaWxhYmxlLCB1cCB0byBwY3IgKGRlcGVuZGluZykgdG9vCiAgIAogICBtYnMgaXMgbWF4IGJ1cnN0IHNpemUgKGJ1Y2tldCkKICAgcGNyIGFuZCBzY3IgaGF2ZSBhc3NvY2lhdGVkIGNkdnQgdmFsdWVzCkBAIC05NDQsNyArOTQ0LDcgQEAKIC8vIHRvIGJlIGZpeGVkIHNvb24sIHNvIGRvIG5vdCBkZWZpbmUgVEFJTFJFQ1VTUklPTldPUktTIHVubGVzcyB5b3UKIC8vIGFyZSBzdXJlIGl0IGRvZXMgYXMgeW91IG1heSBvdGhlcndpc2Ugb3ZlcmZsb3cgdGhlIGtlcm5lbCBzdGFjay4KIAotLy8gZ2l2aW5nIHRoaXMgZm4gYSByZXR1cm4gdmFsdWUgd291bGQgaGVscCBHQ0MsIGFsbGVkZ2VkbHkKKy8vIGdpdmluZyB0aGlzIGZuIGEgcmV0dXJuIHZhbHVlIHdvdWxkIGhlbHAgR0NDLCBhbGxlZ2VkbHkKIAogc3RhdGljIHZvaWQgcnhfc2NoZWR1bGUgKGhyel9kZXYgKiBkZXYsIGludCBpcnEpIHsKICAgdW5zaWduZWQgaW50IHJ4X2J5dGVzOwpAQCAtMTAzNiw3ICsxMDM2LDcgQEAKIAkgIC8vIFZDIGxheWVyIHN0YXRzCiAJICBhdG9taWNfaW5jKCZ2Y2MtPnN0YXRzLT5yeCk7CiAJICBfX25ldF90aW1lc3RhbXAoc2tiKTsKLQkgIC8vIGVuZCBvZiBvdXIgcmVzcG9uc2FiaWxpdHkKKwkgIC8vIGVuZCBvZiBvdXIgcmVzcG9uc2liaWxpdHkKIAkgIHZjYy0+cHVzaCAodmNjLCBza2IpOwogCX0KICAgICAgIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRtL2lkdDc3MjUyLmMgYi9kcml2ZXJzL2F0bS9pZHQ3NzI1Mi5jCmluZGV4IGJmYjdmZWUuLjA0OGY5OWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRtL2lkdDc3MjUyLmMKKysrIGIvZHJpdmVycy9hdG0vaWR0NzcyNTIuYwpAQCAtMzQ5NSw3ICszNDk1LDcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAlpZiAoZGV2LT5waHktPmlvY3RsID09IE5VTEwpIHsKLQkJcHJpbnRrKCIlczogTFQgaGFkIG5vIElPQ1RMIGZ1bnRpb24gZGVmaW5lZC5cbiIsIGNhcmQtPm5hbWUpOworCQlwcmludGsoIiVzOiBMVCBoYWQgbm8gSU9DVEwgZnVuY3Rpb24gZGVmaW5lZC5cbiIsIGNhcmQtPm5hbWUpOwogCQlkZWluaXRfY2FyZChjYXJkKTsKIAkJcmV0dXJuIC0xOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRtL2lkdDc3MjUyLmggYi9kcml2ZXJzL2F0bS9pZHQ3NzI1Mi5oCmluZGV4IGY1M2E0M2EuLjNhODJjYzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRtL2lkdDc3MjUyLmgKKysrIGIvZHJpdmVycy9hdG0vaWR0NzcyNTIuaApAQCAtNzY2LDcgKzc2Niw3IEBACiAjZGVmaW5lIFNBUl9SQ1RFX0JVRkZTVEFUX01BU0sgMHgwMDAwMzAwMCAgLyogYnVmZmVyIHN0YXR1cyAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIFNBUl9SQ1RFX0VGQ0kgICAgICAgICAgMHgwMDAwMDgwMCAgLyogRUZDSSBDb25nZXN0aW9uIGZsYWcgICAgICAgICAgICovCiAjZGVmaW5lIFNBUl9SQ1RFX0NMUCAgICAgICAgICAgMHgwMDAwMDQwMCAgLyogQ2VsbCBMb3NzIFByaW9yaXR5IGZsYWcgICAgICAgICovCi0jZGVmaW5lIFNBUl9SQ1RFX0NSQyAgICAgICAgICAgMHgwMDAwMDIwMCAgLyogUmVjaWV2ZWQgQ1JDIEVycm9yICAgICAgICAgICAgICovCisjZGVmaW5lIFNBUl9SQ1RFX0NSQyAgICAgICAgICAgMHgwMDAwMDIwMCAgLyogUmVjZWl2ZWQgQ1JDIEVycm9yICAgICAgICAgICAgICovCiAjZGVmaW5lIFNBUl9SQ1RFX0NFTExDTlRfTUFTSyAgMHgwMDAwMDFGRiAgLyogY2VsbCBDb3VudCAgICAgICAgICAgICAgICAgICAgICovCiAKICNkZWZpbmUgU0FSX1JDVEVfQUFMMCAgICAgICAgICAweDAwMDAwMDAwICAvKiBBQUwgdHlwZXMgZm9yIEFMTCBmaWVsZCAgICAgICAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRtL2lwaGFzZS5jIGIvZHJpdmVycy9hdG0vaXBoYXNlLmMKaW5kZXggZDgwZDUxYi4uMWM2NzRhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdG0vaXBoYXNlLmMKKysrIGIvZHJpdmVycy9hdG0vaXBoYXNlLmMKQEAgLTEwMjUsNyArMTAyNSw3IEBACiB9IAogICAKICAgCi0vKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIFJlY2lldmluZyBzaWRlIHN0dWZmIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8gIAorLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSBSZWNlaXZpbmcgc2lkZSBzdHVmZiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovICAKICAKIHN0YXRpYyB2b2lkIHJ4X2V4Y3BfcmN2ZChzdHJ1Y3QgYXRtX2RldiAqZGV2KSAgCiB7ICAKQEAgLTExOTUsNyArMTE5NSw3IEBACiAgIGlmIChzdGF0dXMgJiBSWF9QS1RfUkNWRCkgIAogICB7ICAKIAkvKiBkbyBzb21ldGhpbmcgKi8gIAotCS8qIEJhc2ljYWxseSByZWN2ZCBhbiBpbnRlcnJ1cHQgZm9yIHJlY2V2aW5nIGEgcGFja2V0LiAgCisJLyogQmFzaWNhbGx5IHJlY3ZkIGFuIGludGVycnVwdCBmb3IgcmVjZWl2aW5nIGEgcGFja2V0LiAgCiAJQSBkZXNjcmlwdG9yIHdvdWxkIGhhdmUgYmVlbiB3cml0dGVuIHRvIHRoZSBwYWNrZXQgY29tcGxldGUgICAKIAlxdWV1ZS4gR2V0IGFsbCB0aGUgZGVzY3JpcHRvcnMgYW5kIHNldCB1cCBkbWEgdG8gbW92ZSB0aGUgICAKIAlwYWNrZXRzIHRpbGwgdGhlIHBhY2tldCBjb21wbGV0ZSBxdWV1ZSBpcyBlbXB0eS4uICAKQEAgLTE4NTUsNyArMTg1NSw3IEBACiAgICAgICAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOyAKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgaWYgKHZjYy0+cW9zLnR4dHAubWF4X3BjciA+IGlhZGV2LT5MaW5lUmF0ZSkgewotICAgICAgICAgICAgICAgICAgIElGX0NCUihwcmludGsoIlBDUiBpcyBub3QgYXZhaWxibGVcbiIpOykKKyAgICAgICAgICAgICAgICAgICBJRl9DQlIocHJpbnRrKCJQQ1IgaXMgbm90IGF2YWlsYWJsZVxuIik7KQogICAgICAgICAgICAgICAgICAgIHJldHVybiAtMTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgdmMtPnR5cGUgPSBDQlI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0bS9sYW5haS5jIGIvZHJpdmVycy9hdG0vbGFuYWkuYwppbmRleCA1Mjg4MGM4Li40ZThiYTU2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0bS9sYW5haS5jCisrKyBiL2RyaXZlcnMvYXRtL2xhbmFpLmMKQEAgLTEyNTUsNyArMTI1NSw3IEBACiAJLyoKIAkgKiBTaW5jZSB0aGUgImJ1dHQgcmVnaXN0ZXIiIGlzIGEgc2hhcmVkIHJlc291bmNlIG9uIHRoZSBjYXJkIHdlCiAJICogc2VyaWFsaXplIGFsbCBhY2Nlc3NlcyB0byBpdCB0aHJvdWdoIHRoaXMgc3BpbmxvY2suICBUaGlzIGlzCi0JICogbW9zdGx5IGp1c3QgcGFyYW5vaWEgc2ljbmUgdGhlIHJlZ2lzdGVyIGlzIHJhcmVseSAiYnVzeSIgYW55d2F5CisJICogbW9zdGx5IGp1c3QgcGFyYW5vaWEgc2luY2UgdGhlIHJlZ2lzdGVyIGlzIHJhcmVseSAiYnVzeSIgYW55d2F5CiAJICogYnV0IGlzIG5lZWRlZCBmb3IgY29ycmVjdG5lc3MuCiAJICovCiAJc3Bpbl9sb2NrKCZsYW5haS0+ZW5kdHhsb2NrKTsKQEAgLTE5OTAsNyArMTk5MCw3IEBACiAKIC8qCiAgKiBXZSBfY2FuXyB1c2UgVkNJPT0wIGZvciBub3JtYWwgdHJhZmZpYywgYnV0IG9ubHkgZm9yIFVCUiAob3Igd2UnbGwKLSAqIGdldCBhIENCUlpFUk8gaW50ZXJydXB0KSwgYW5kIHdlIGNhbiB1c2UgaXQgb25seSBpZiBub29uZSBpcyByZWNlaXZpbmcKKyAqIGdldCBhIENCUlpFUk8gaW50ZXJydXB0KSwgYW5kIHdlIGNhbiB1c2UgaXQgb25seSBpZiBubyBvbmUgaXMgcmVjZWl2aW5nCiAgKiBBQUwwIHRyYWZmaWMgKHNpbmNlIHRoZXkgd2lsbCB1c2UgdGhlIHNhbWUgcXVldWUpIC0gYWNjb3JkaW5nIHRvIHRoZQogICogZG9jcyB3ZSBzaG91bGRuJ3QgZXZlbiB1c2UgaXQgZm9yIEFBTDAgdHJhZmZpYwogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F1eGRpc3BsYXkvY2ZhZzEyODY0Yi5jIGIvZHJpdmVycy9hdXhkaXNwbGF5L2NmYWcxMjg2NGIuYwppbmRleCA0OTc1ODU5Li40MWNlNGJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F1eGRpc3BsYXkvY2ZhZzEyODY0Yi5jCisrKyBiL2RyaXZlcnMvYXV4ZGlzcGxheS9jZmFnMTI4NjRiLmMKQEAgLTQ5LDcgKzQ5LDcgQEAKIHN0YXRpYyB1bnNpZ25lZCBpbnQgY2ZhZzEyODY0Yl9yYXRlID0gQ09ORklHX0NGQUcxMjg2NEJfUkFURTsKIG1vZHVsZV9wYXJhbShjZmFnMTI4NjRiX3JhdGUsIHVpbnQsIFNfSVJVR08pOwogTU9EVUxFX1BBUk1fREVTQyhjZmFnMTI4NjRiX3JhdGUsCi0JIlJlZnJlc2ggcmF0ZSAoaGVydHpzKSIpOworCSJSZWZyZXNoIHJhdGUgKGhlcnR6KSIpOwogCiB1bnNpZ25lZCBpbnQgY2ZhZzEyODY0Yl9nZXRyYXRlKHZvaWQpCiB7CkBAIC02MCw3ICs2MCw3IEBACiAgKiBjZmFnMTI4NjRiIENvbW1hbmRzCiAgKgogICoJRSA9IEVuYWJsZSBzaWduYWwKLSAqCQlFdmVyeXRpbWUgRSBzd2l0Y2ggZnJvbSBsb3cgdG8gaGlnaCwKKyAqCQlFdmVyeSB0aW1lIEUgc3dpdGNoIGZyb20gbG93IHRvIGhpZ2gsCiAgKgkJY2ZhZzEyODY0Yi9rczAxMDggcmVhZHMgdGhlIGNvbW1hbmQvZGF0YS4KICAqCiAgKglDUzEgPSBGaXJzdCBrczAxMDhjb250cm9sbGVyLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL3Bvd2VyL3J1bnRpbWUuYyBiL2RyaXZlcnMvYmFzZS9wb3dlci9ydW50aW1lLmMKaW5kZXggNTQ1OTdjOC4uMzE3MmM2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL3Bvd2VyL3J1bnRpbWUuYworKysgYi9kcml2ZXJzL2Jhc2UvcG93ZXIvcnVudGltZS5jCkBAIC00NDMsNyArNDQzLDcgQEAKICAqCiAgKiBDaGVjayBpZiB0aGUgZGV2aWNlJ3MgcnVuLXRpbWUgUE0gc3RhdHVzIGFsbG93cyBpdCB0byBiZSByZXN1bWVkLiAgQ2FuY2VsCiAgKiBhbnkgc2NoZWR1bGVkIG9yIHBlbmRpbmcgcmVxdWVzdHMuICBJZiBhbm90aGVyIHJlc3VtZSBoYXMgYmVlbiBzdGFydGVkCi0gKiBlYXJsaWVyLCBlaXRoZXIgcmV0dXJuIGltZWRpYXRlbHkgb3Igd2FpdCBmb3IgaXQgdG8gZmluaXNoLCBkZXBlbmRpbmcgb24gdGhlCisgKiBlYXJsaWVyLCBlaXRoZXIgcmV0dXJuIGltbWVkaWF0ZWx5IG9yIHdhaXQgZm9yIGl0IHRvIGZpbmlzaCwgZGVwZW5kaW5nIG9uIHRoZQogICogUlBNX05PV0FJVCBhbmQgUlBNX0FTWU5DIGZsYWdzLiAgU2ltaWxhcmx5LCBpZiB0aGVyZSdzIGEgc3VzcGVuZCBydW5uaW5nIGluCiAgKiBwYXJhbGxlbCB3aXRoIHRoaXMgZnVuY3Rpb24sIGVpdGhlciB0ZWxsIHRoZSBvdGhlciBwcm9jZXNzIHRvIHJlc3VtZSBhZnRlcgogICogc3VzcGVuZGluZyAoZGVmZXJyZWRfcmVzdW1lKSBvciB3YWl0IGZvciBpdCB0byBmaW5pc2guICBJZiB0aGUgUlBNX0FTWU5DCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2Uvc3lzLmMgYi9kcml2ZXJzL2Jhc2Uvc3lzLmMKaW5kZXggZmJlNzJkYS4uYWNkZTliNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL3N5cy5jCisrKyBiL2RyaXZlcnMvYmFzZS9zeXMuYwpAQCAtMTk3LDcgKzE5Nyw3IEBACiB9CiAKIC8qKgotICoJc3lzZGV2X2RyaXZlcl9yZWdpc3RlciAtIFJlZ2lzdGVyIGF1eGlsbGFyeSBkcml2ZXIKKyAqCXN5c2Rldl9kcml2ZXJfcmVnaXN0ZXIgLSBSZWdpc3RlciBhdXhpbGlhcnkgZHJpdmVyCiAgKglAY2xzOglEZXZpY2UgY2xhc3MgZHJpdmVyIGJlbG9uZ3MgdG8uCiAgKglAZHJ2OglEcml2ZXIuCiAgKgpAQCAtMjUwLDcgKzI1MCw3IEBACiB9CiAKIC8qKgotICoJc3lzZGV2X2RyaXZlcl91bnJlZ2lzdGVyIC0gUmVtb3ZlIGFuIGF1eGlsbGFyeSBkcml2ZXIuCisgKglzeXNkZXZfZHJpdmVyX3VucmVnaXN0ZXIgLSBSZW1vdmUgYW4gYXV4aWxpYXJ5IGRyaXZlci4KICAqCUBjbHM6CUNsYXNzIGRyaXZlciBiZWxvbmdzIHRvLgogICoJQGRydjoJRHJpdmVyLgogICovCkBAIC0zMDIsNyArMzAyLDcgQEAKIAkJICogY29kZSB0aGF0IHNob3VsZCBoYXZlIGNhbGxlZCB1cy4KIAkJICovCiAKLQkJLyogTm90aWZ5IGNsYXNzIGF1eGlsbGFyeSBkcml2ZXJzICovCisJCS8qIE5vdGlmeSBjbGFzcyBhdXhpbGlhcnkgZHJpdmVycyAqLwogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGRydiwgJmNscy0+ZHJpdmVycywgZW50cnkpIHsKIAkJCWlmIChkcnYtPmFkZCkKIAkJCQlkcnYtPmFkZChzeXNkZXYpOwpAQCAtMzM1LDcgKzMzNSw3IEBACiAgKgogICoJTG9vcCBvdmVyIGVhY2ggY2xhc3Mgb2Ygc3lzdGVtIGRldmljZXMsIGFuZCB0aGUgZGV2aWNlcyBpbiBlYWNoCiAgKglvZiB0aG9zZSBjbGFzc2VzLiBGb3IgZWFjaCBkZXZpY2UsIHdlIGNhbGwgdGhlIHNodXRkb3duIG1ldGhvZCBmb3IKLSAqCWVhY2ggZHJpdmVyIHJlZ2lzdGVyZWQgZm9yIHRoZSBkZXZpY2UgLSB0aGUgYXV4aWxsYXJpZXMsCisgKgllYWNoIGRyaXZlciByZWdpc3RlcmVkIGZvciB0aGUgZGV2aWNlIC0gdGhlIGF1eGlsaWFyaWVzLAogICoJYW5kIHRoZSBjbGFzcyBkcml2ZXIuCiAgKgogICoJTm90ZTogVGhlIGxpc3QgaXMgaXRlcmF0ZWQgaW4gcmV2ZXJzZSBvcmRlciwgc28gdGhhdCB3ZSBzaHV0IGRvd24KQEAgLTM2MCw3ICszNjAsNyBAQAogCQkJc3RydWN0IHN5c2Rldl9kcml2ZXIgKmRydjsKIAkJCXByX2RlYnVnKCIgJXNcbiIsIGtvYmplY3RfbmFtZSgmc3lzZGV2LT5rb2JqKSk7CiAKLQkJCS8qIENhbGwgYXV4aWxsYXJ5IGRyaXZlcnMgZmlyc3QgKi8KKwkJCS8qIENhbGwgYXV4aWxpYXJ5IGRyaXZlcnMgZmlyc3QgKi8KIAkJCWxpc3RfZm9yX2VhY2hfZW50cnkoZHJ2LCAmY2xzLT5kcml2ZXJzLCBlbnRyeSkgewogCQkJCWlmIChkcnYtPnNodXRkb3duKQogCQkJCQlkcnYtPnNodXRkb3duKHN5c2Rldik7CkBAIC0zODUsNyArMzg1LDcgQEAKIAlXQVJOX09OQ0UoIWlycXNfZGlzYWJsZWQoKSwKIAkJIkludGVycnVwdHMgZW5hYmxlZCBhZnRlciAlcEZcbiIsIGNscy0+cmVzdW1lKTsKIAotCS8qIENhbGwgYXV4aWxsYXJ5IGRyaXZlcnMgbmV4dC4gKi8KKwkvKiBDYWxsIGF1eGlsaWFyeSBkcml2ZXJzIG5leHQuICovCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShkcnYsICZjbHMtPmRyaXZlcnMsIGVudHJ5KSB7CiAJCWlmIChkcnYtPnJlc3VtZSkKIAkJCWRydi0+cmVzdW1lKGRldik7CkBAIC00MzIsNyArNDMyLDcgQEAKIAkJbGlzdF9mb3JfZWFjaF9lbnRyeShzeXNkZXYsICZjbHMtPmtzZXQubGlzdCwga29iai5lbnRyeSkgewogCQkJcHJfZGVidWcoIiAlc1xuIiwga29iamVjdF9uYW1lKCZzeXNkZXYtPmtvYmopKTsKIAotCQkJLyogQ2FsbCBhdXhpbGxhcnkgZHJpdmVycyBmaXJzdCAqLworCQkJLyogQ2FsbCBhdXhpbGlhcnkgZHJpdmVycyBmaXJzdCAqLwogCQkJbGlzdF9mb3JfZWFjaF9lbnRyeShkcnYsICZjbHMtPmRyaXZlcnMsIGVudHJ5KSB7CiAJCQkJaWYgKGRydi0+c3VzcGVuZCkgewogCQkJCQlyZXQgPSBkcnYtPnN1c3BlbmQoc3lzZGV2LCBzdGF0ZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL0RBQzk2MC5jIGIvZHJpdmVycy9ibG9jay9EQUM5NjAuYwppbmRleCA3OTg4MjEwLi44MDY2ZDA4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL0RBQzk2MC5jCisrKyBiL2RyaXZlcnMvYmxvY2svREFDOTYwLmMKQEAgLTE3OTAsNyArMTc5MCw3IEBACiAgIHVuc2lnbmVkIHNob3J0IExvZ2ljYWxEZXZpY2VOdW1iZXIgPSAwOwogICBpbnQgTW9kZWxOYW1lTGVuZ3RoOwogCi0gIC8qIEdldCBkYXRhIGludG8gZG1hLWFibGUgYXJlYSwgdGhlbiBjb3B5IGludG8gcGVybWFuYW50IGxvY2F0aW9uICovCisgIC8qIEdldCBkYXRhIGludG8gZG1hLWFibGUgYXJlYSwgdGhlbiBjb3B5IGludG8gcGVybWFuZW50IGxvY2F0aW9uICovCiAgIGlmICghREFDOTYwX1YyX05ld0NvbnRyb2xsZXJJbmZvKENvbnRyb2xsZXIpKQogICAgIHJldHVybiBEQUM5NjBfRmFpbHVyZShDb250cm9sbGVyLCAiR0VUIENPTlRST0xMRVIgSU5GTyIpOwogICBtZW1jcHkoQ29udHJvbGxlckluZm8sIENvbnRyb2xsZXItPlYyLk5ld0NvbnRyb2xsZXJJbmZvcm1hdGlvbiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX2FjdGxvZy5jIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfYWN0bG9nLmMKaW5kZXggMmExNjQyYi4uYzY4MjhiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfYWN0bG9nLmMKKysrIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfYWN0bG9nLmMKQEAgLTMwLDcgKzMwLDcgQEAKIAogLyogV2UgbWFpbnRhaW4gYSB0cml2aWFsIGNoZWNrIHN1bSBpbiBvdXIgb24gZGlzayBhY3Rpdml0eSBsb2cuCiAgKiBXaXRoIHRoYXQgd2UgY2FuIGVuc3VyZSBjb3JyZWN0IG9wZXJhdGlvbiBldmVuIHdoZW4gdGhlIHN0b3JhZ2UKLSAqIGRldmljZSBtaWdodCBkbyBhIHBhcnRpYWwgKGxhc3QpIHNlY3RvciB3cml0ZSB3aGlsZSBsb29zaW5nIHBvd2VyLgorICogZGV2aWNlIG1pZ2h0IGRvIGEgcGFydGlhbCAobGFzdCkgc2VjdG9yIHdyaXRlIHdoaWxlIGxvc2luZyBwb3dlci4KICAqLwogc3RydWN0IF9fcGFja2VkIGFsX3RyYW5zYWN0aW9uIHsKIAl1MzIgICAgICAgbWFnaWM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9pbnQuaCBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX2ludC5oCmluZGV4IDgxMDMwZDguLmIyNjk5YmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX2ludC5oCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX2ludC5oCkBAIC02MjIsNyArNjIyLDcgQEAKIC8qIG9uZSBiaXRtYXAgcGFja2V0LCBpbmNsdWRpbmcgdGhlIHBfaGVhZGVyLAogICogc2hvdWxkIGZpdCB3aXRoaW4gb25lIF9hcmNoaXRlY3R1cmUgaW5kZXBlbmRlbmRfIHBhZ2UuCiAgKiBzbyB3ZSBuZWVkIHRvIHVzZSB0aGUgZml4ZWQgc2l6ZSA0S2lCIHBhZ2Ugc2l6ZQotICogbW9zdCBhcmNoaXRlY2h0dXJlcyBoYXZlIHVzZWQgZm9yIGEgbG9uZyB0aW1lLgorICogbW9zdCBhcmNoaXRlY3R1cmVzIGhhdmUgdXNlZCBmb3IgYSBsb25nIHRpbWUuCiAgKi8KICNkZWZpbmUgQk1fUEFDS0VUX1BBWUxPQURfQllURVMgKDQwOTYgLSBzaXplb2Yoc3RydWN0IHBfaGVhZGVyODApKQogI2RlZmluZSBCTV9QQUNLRVRfV09SRFMgKEJNX1BBQ0tFVF9QQVlMT0FEX0JZVEVTL3NpemVvZihsb25nKSkKQEAgLTgxMCw3ICs4MTAsNyBAQAogCiAvKiBnbG9iYWwgZmxhZyBiaXRzICovCiBlbnVtIHsKLQlDUkVBVEVfQkFSUklFUiwJCS8qIG5leHQgUF9EQVRBIGlzIHByZWNlZWRlZCBieSBhIFBfQkFSUklFUiAqLworCUNSRUFURV9CQVJSSUVSLAkJLyogbmV4dCBQX0RBVEEgaXMgcHJlY2VkZWQgYnkgYSBQX0JBUlJJRVIgKi8KIAlTSUdOQUxfQVNFTkRFUiwJCS8qIHdoZXRoZXIgYXNlbmRlciB3YW50cyB0byBiZSBpbnRlcnJ1cHRlZCAqLwogCVNFTkRfUElORywJCS8qIHdoZXRoZXIgYXNlbmRlciBzaG91bGQgc2VuZCBhIHBpbmcgYXNhcCAqLwogCkBAIC0xMTI2LDcgKzExMjYsNyBAQAogCWludCBjX3N5bmNfcmF0ZTsgLyogY3VycmVudCByZXN5bmMgcmF0ZSBhZnRlciBzeW5jZXIgdGhyb3R0bGUgbWFnaWMgKi8KIAlzdHJ1Y3QgZmlmb19idWZmZXIgcnNfcGxhbl9zOyAvKiBjb3JyZWN0aW9uIHZhbHVlcyBvZiByZXN5bmMgcGxhbmVyICovCiAJaW50IHJzX2luX2ZsaWdodDsgLyogcmVzeW5jIHNlY3RvcnMgaW4gZmxpZ2h0ICh0byBwcm94eSwgaW4gcHJveHkgYW5kIGZyb20gcHJveHkpICovCi0JaW50IHJzX3BsYW5lZDsgICAgLyogcmVzeW5jIHNlY3RvcnMgYWxyZWFkeSBwbGFuZWQgKi8KKwlpbnQgcnNfcGxhbmVkOyAgICAvKiByZXN5bmMgc2VjdG9ycyBhbHJlYWR5IHBsYW5uZWQgKi8KIAlhdG9taWNfdCBhcF9pbl9mbGlnaHQ7IC8qIEFwcCBzZWN0b3JzIGluIGZsaWdodCAod2FpdGluZyBmb3IgYWNrKSAqLwogfTsKIApAQCAtMTE0NCw3ICsxMTQ0LDcgQEAKIAlyZXR1cm4gbWRldi0+bWlub3I7CiB9CiAKLS8qIHJldHVybnMgMSBpZiBpdCB3YXMgc3VjY2Vzc2Z1bGwsCisvKiByZXR1cm5zIDEgaWYgaXQgd2FzIHN1Y2Nlc3NmdWwsCiAgKiByZXR1cm5zIDAgaWYgdGhlcmUgd2FzIG5vIGRhdGEgc29ja2V0LgogICogc28gd2hlcmV2ZXIgeW91IGFyZSBnb2luZyB0byB1c2UgdGhlIGRhdGEuc29ja2V0LCBlLmcuIGRvCiAgKiBpZiAoIWRyYmRfZ2V0X2RhdGFfc29jayhtZGV2KSkKQEAgLTIwNzksNyArMjA3OSw3IEBACiAvKiBjb3VudHMgaG93IG1hbnkgcmVzeW5jLXJlbGF0ZWQgYW5zd2VycyB3ZSBzdGlsbCBleHBlY3QgZnJvbSB0aGUgcGVlcgogICoJCSAgICAgaW5jcmVhc2UJCQlkZWNyZWFzZQogICogQ19TWU5DX1RBUkdFVCBzZW5kcyBQX1JTX0RBVEFfUkVRVUVTVCAoYW5kIGV4cGVjdHMgUF9SU19EQVRBX1JFUExZKQotICogQ19TWU5DX1NPVVJDRSBzZW5kcyBQX1JTX0RBVEFfUkVQTFkgICAoYW5kIGV4cGVjdHMgUF9XUklURV9BQ0sgd2hpdGggSURfU1lOQ0VSKQorICogQ19TWU5DX1NPVVJDRSBzZW5kcyBQX1JTX0RBVEFfUkVQTFkgICAoYW5kIGV4cGVjdHMgUF9XUklURV9BQ0sgd2l0aCBJRF9TWU5DRVIpCiAgKgkJCQkJICAgKG9yIFBfTkVHX0FDSyB3aXRoIElEX1NZTkNFUikKICAqLwogc3RhdGljIGlubGluZSB2b2lkIGluY19yc19wZW5kaW5nKHN0cnVjdCBkcmJkX2NvbmYgKm1kZXYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMKaW5kZXggZGZjODVmMy4uNWI1MjVjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX21haW4uYwpAQCAtMTU2MSw3ICsxNTYxLDcgQEAKIAkJaWYgKGRyYmRfc2VuZF9zdGF0ZShtZGV2KSkKIAkJCWRldl93YXJuKERFViwgIk5vdGlmaWVkIHBlZXIgdGhhdCBJJ20gbm93IGRpc2tsZXNzLlxuIik7CiAJCS8qIGNvcnJlc3BvbmRpbmcgZ2V0X2xkZXYgaW4gX19kcmJkX3NldF9zdGF0ZQotCQkgKiB0aGlzIG1heSBmaW5hbHkgdHJpZ2dlciBkcmJkX2xkZXZfZGVzdHJveS4gKi8KKwkJICogdGhpcyBtYXkgZmluYWxseSB0cmlnZ2VyIGRyYmRfbGRldl9kZXN0cm95LiAqLwogCQlwdXRfbGRldihtZGV2KTsKIAl9CiAKQEAgLTM3MDYsNyArMzcwNiw3IEBACiAJYnVmZmVyID0gKHN0cnVjdCBtZXRhX2RhdGFfb25fZGlzayAqKXBhZ2VfYWRkcmVzcyhtZGV2LT5tZF9pb19wYWdlKTsKIAogCWlmICghZHJiZF9tZF9zeW5jX3BhZ2VfaW8obWRldiwgYmRldiwgYmRldi0+bWQubWRfb2Zmc2V0LCBSRUFEKSkgewotCQkvKiBOT1RFOiBjYW50IGRvIG5vcm1hbCBlcnJvciBwcm9jZXNzaW5nIGhlcmUgYXMgdGhpcyBpcworCQkvKiBOT1RFOiBjYW4ndCBkbyBub3JtYWwgZXJyb3IgcHJvY2Vzc2luZyBoZXJlIGFzIHRoaXMgaXMKIAkJICAgY2FsbGVkIEJFRk9SRSBkaXNrIGlzIGF0dGFjaGVkICovCiAJCWRldl9lcnIoREVWLCAiRXJyb3Igd2hpbGUgcmVhZGluZyBtZXRhZGF0YS5cbiIpOwogCQlydiA9IEVSUl9JT19NRF9ESVNLOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2ZXIuYyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX3JlY2VpdmVyLmMKaW5kZXggZmUxNTY0Yy4uZmQyNjY2NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC04NjIsNyArODYyLDcgQEAKIAltc29jay0+c2stPnNrX3JjdnRpbWVvID0gbWRldi0+bmV0X2NvbmYtPnBpbmdfaW50KkhaOwogCiAJLyogd2UgZG9uJ3Qgd2FudCBkZWxheXMuCi0JICogd2UgdXNlIFRDUF9DT1JLIHdoZXJlIGFwcm9wcmlhdGUsIHRob3VnaCAqLworCSAqIHdlIHVzZSBUQ1BfQ09SSyB3aGVyZSBhcHByb3ByaWF0ZSwgdGhvdWdoICovCiAJZHJiZF90Y3Bfbm9kZWxheShzb2NrKTsKIAlkcmJkX3RjcF9ub2RlbGF5KG1zb2NrKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfdmxpLmggYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF92bGkuaAppbmRleCBmYzgyNDAwLi44Y2IxNTMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF92bGkuaAorKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF92bGkuaApAQCAtMzIsNyArMzIsNyBAQAogICogdGhlIGJpdG1hcCB0cmFuc2ZlciB0aW1lIGNhbiB0YWtlIG11Y2ggdG9vIGxvbmcsCiAgKiBpZiB0cmFuc21pdHRlZCBpbiBwbGFpbiB0ZXh0LgogICoKLSAqIFdlIHRyeSB0byByZWR1Y2UgdGhlIHRyYW5zZmVyZWQgYml0bWFwIGluZm9ybWF0aW9uCisgKiBXZSB0cnkgdG8gcmVkdWNlIHRoZSB0cmFuc2ZlcnJlZCBiaXRtYXAgaW5mb3JtYXRpb24KICAqIGJ5IGVuY29kaW5nIHJ1bmxlbmd0aHMgb2YgYml0IHBvbGFyaXR5LgogICoKICAqIFdlIG5ldmVyIGFjdHVhbGx5IG5lZWQgdG8gZW5jb2RlIGEgInplcm8iIChydW5sZW5ndGhzIGFyZSBwb3NpdGl2ZSkuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2hkLmMgYi9kcml2ZXJzL2Jsb2NrL2hkLmMKaW5kZXggMzBlYzZiMy4uMDA3YzYzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9oZC5jCisrKyBiL2RyaXZlcnMvYmxvY2svaGQuYwpAQCAtNzMzLDcgKzczMyw3IEBACiAJCSAqIHRoZSBCSU9TIG9yIENNT1MuICBUaGlzIGRvZXNuJ3Qgd29yayBhbGwgdGhhdCB3ZWxsLAogCQkgKiBzaW5jZSB0aGlzIGFzc3VtZXMgdGhhdCB0aGlzIGlzIGEgcHJpbWFyeSBvciBzZWNvbmRhcnkKIAkJICogZHJpdmUsIGFuZCBpZiB3ZSdyZSB1c2luZyB0aGlzIGxlZ2FjeSBkcml2ZXIsIGl0J3MKLQkJICogcHJvYmFibHkgYW4gYXV4aWxsaWFyeSBjb250cm9sbGVyIGFkZGVkIHRvIHJlY292ZXIKKwkJICogcHJvYmFibHkgYW4gYXV4aWxpYXJ5IGNvbnRyb2xsZXIgYWRkZWQgdG8gcmVjb3ZlcgogCQkgKiBsZWdhY3kgZGF0YSBvZmYgYW4gU1QtNTA2IGRyaXZlLiAgRWl0aGVyIHdheSwgaXQncwogCQkgKiBkZWZpbml0ZWx5IHNhZmVzdCB0byBoYXZlIHRoZSB1c2VyIGV4cGxpY2l0bHkgc3BlY2lmeQogCQkgKiB0aGUgaW5mb3JtYXRpb24uCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3Zpb2Rhc2QuYyBiL2RyaXZlcnMvYmxvY2svdmlvZGFzZC5jCmluZGV4IGUyZmY2OTcuLjlhNWIyYTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svdmlvZGFzZC5jCisrKyBiL2RyaXZlcnMvYmxvY2svdmlvZGFzZC5jCkBAIC05NCw3ICs5NCw3IEBACiAJeyAweDAyMDQsIEVJTywgIlVzZSBFcnJvciIgfSwKIAl7IDB4MDIwNSwgRUlPLCAiUmVsZWFzZSBFcnJvciIgfSwKIAl7IDB4MDIwNiwgRUlOVkFMLCAiSW52YWxpZCBEaXNrIiB9LAotCXsgMHgwMjA3LCBFQlVTWSwgIkNhbnQgTG9jayIgfSwKKwl7IDB4MDIwNywgRUJVU1ksICJDYW4ndCBMb2NrIiB9LAogCXsgMHgwMjA4LCBFSU8sICJBbHJlYWR5IExvY2tlZCIgfSwKIAl7IDB4MDIwOSwgRUlPLCAiQWxyZWFkeSBVbmxvY2tlZCIgfSwKIAl7IDB4MDIwQSwgRUlPLCAiSW52YWxpZCBBcmciIH0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3hzeXNhY2UuYyBiL2RyaXZlcnMvYmxvY2sveHN5c2FjZS5jCmluZGV4IDczMzU0YjAuLjY0NWZmNzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sveHN5c2FjZS5jCisrKyBiL2RyaXZlcnMvYmxvY2sveHN5c2FjZS5jCkBAIC02MjEsNyArNjIxLDcgQEAKIAkJYWNlX2R1bXBfbWVtKGFjZS0+Y2ZfaWQsIDUxMik7CS8qIERlYnVnOiBEdW1wIG91dCBkaXNrIElEICovCiAKIAkJaWYgKGFjZS0+ZGF0YV9yZXN1bHQpIHsKLQkJCS8qIEVycm9yIG9jY3VyZWQsIGRpc2FibGUgdGhlIGRpc2sgKi8KKwkJCS8qIEVycm9yIG9jY3VycmVkLCBkaXNhYmxlIHRoZSBkaXNrICovCiAJCQlhY2UtPm1lZGlhX2NoYW5nZSA9IDE7CiAJCQlzZXRfY2FwYWNpdHkoYWNlLT5nZCwgMCk7CiAJCQlkZXZfZXJyKGFjZS0+ZGV2LCAiZXJyb3IgZmV0Y2hpbmcgQ0YgaWQgKCVpKVxuIiwKQEAgLTgwMSw3ICs4MDEsNyBAQAogCXUzMiBzcmVnID0gYWNlX2luMzIoYWNlLCBBQ0VfU1RBVFVTKTsKIAl1MTYgY3JlZyA9IGFjZV9pbihhY2UsIEFDRV9DVFJMKTsKIAotCS8qIENoZWNrIGZvciBlcnJvciBvY2N1cmFuY2UgKi8KKwkvKiBDaGVjayBmb3IgZXJyb3Igb2NjdXJyZW5jZSAqLwogCWlmICgoc3JlZyAmIChBQ0VfU1RBVFVTX0NGR0VSUk9SIHwgQUNFX1NUQVRVU19DRkNFUlJPUikpICYmCiAJICAgIChjcmVnICYgQUNFX0NUUkxfRVJST1JJUlEpKSB7CiAJCWRldl9lcnIoYWNlLT5kZXYsICJ0cmFuc2ZlciBmYWlsdXJlXG4iKTsKQEAgLTExNjksNyArMTE2OSw3IEBACiAJCQlpcnEgPSBkZXYtPnJlc291cmNlW2ldLnN0YXJ0OwogCX0KIAotCS8qIENhbGwgdGhlIGJ1cy1pbmRlcGVuZGFudCBzZXR1cCBjb2RlICovCisJLyogQ2FsbCB0aGUgYnVzLWluZGVwZW5kZW50IHNldHVwIGNvZGUgKi8KIAlyZXR1cm4gYWNlX2FsbG9jKCZkZXYtPmRldiwgaWQsIHBoeXNhZGRyLCBpcnEsIGJ1c193aWR0aCk7CiB9CiAKQEAgLTEyMjIsNyArMTIyMiw3IEBACiAJaWYgKG9mX2ZpbmRfcHJvcGVydHkob3AtPmRldi5vZl9ub2RlLCAiOC1iaXQiLCBOVUxMKSkKIAkJYnVzX3dpZHRoID0gQUNFX0JVU19XSURUSF84OwogCi0JLyogQ2FsbCB0aGUgYnVzLWluZGVwZW5kYW50IHNldHVwIGNvZGUgKi8KKwkvKiBDYWxsIHRoZSBidXMtaW5kZXBlbmRlbnQgc2V0dXAgY29kZSAqLwogCXJldHVybiBhY2VfYWxsb2MoJm9wLT5kZXYsIGlkID8gYmUzMl90b19jcHVwKGlkKSA6IDAsCiAJCQkJCQlwaHlzYWRkciwgaXJxLCBidXNfd2lkdGgpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibHVldG9vdGgvaGNpX2xsLmMgYi9kcml2ZXJzL2JsdWV0b290aC9oY2lfbGwuYwppbmRleCAzODU5NWU3Li43ZTRiNDM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2JsdWV0b290aC9oY2lfbGwuYworKysgYi9kcml2ZXJzL2JsdWV0b290aC9oY2lfbGwuYwpAQCAtMjA3LDcgKzIwNyw3IEBACiAJCS8qCiAJCSAqIFRoaXMgc3RhdGUgbWVhbnMgdGhhdCBib3RoIHRoZSBob3N0IGFuZCB0aGUgQlJGIGNoaXAKIAkJICogaGF2ZSBzaW11bHRhbmVvdXNseSBzZW50IGEgd2FrZS11cC1pbmRpY2F0aW9uIHBhY2tldC4KLQkJICogVHJhZGl0aW9uYWx5LCBpbiB0aGlzIGNhc2UsIHJlY2VpdmluZyBhIHdha2UtdXAtaW5kaWNhdGlvbgorCQkgKiBUcmFkaXRpb25hbGx5LCBpbiB0aGlzIGNhc2UsIHJlY2VpdmluZyBhIHdha2UtdXAtaW5kaWNhdGlvbgogCQkgKiB3YXMgZW5vdWdoIGFuZCBhbiBhZGRpdGlvbmFsIHdha2UtdXAtYWNrIHdhc24ndCBuZWVkZWQuCiAJCSAqIFRoaXMgaGFzIGNoYW5nZWQgd2l0aCB0aGUgQlJGNjM1MCwgd2hpY2ggZG9lcyByZXF1aXJlIGFuCiAJCSAqIGV4cGxpY2l0IHdha2UtdXAtYWNrLiBPdGhlciBCUkYgdmVyc2lvbnMsIHdoaWNoIGRvIG5vdApkaWZmIC0tZ2l0IGEvZHJpdmVycy9jZHJvbS9jZHJvbS5jIGIvZHJpdmVycy9jZHJvbS9jZHJvbS5jCmluZGV4IGUyYzQ4YTcuLjUxNGRkOGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2Ryb20vY2Ryb20uYworKysgYi9kcml2ZXJzL2Nkcm9tL2Nkcm9tLmMKQEAgLTMwLDcgKzMwLDcgQEAKICAgY2hhbmdlbG9nIGZvciB0aGUgMS54IHNlcmllcywgRGF2aWQ/CiAKIDIuMDAgIERlYyAgMiwgMTk5NyAtLSBFcmlrIEFuZGVyc2VuIDxhbmRlcnNlZUBkZWJpYW4ub3JnPgotICAtLSBOZXcgbWFpbnRhaW5lciEgQXMgRGF2aWQgQS4gdmFuIExlZXV3ZW4gaGFzIGJlZW4gdG9vIGJ1c3kgdG8gYWN0aXZseQorICAtLSBOZXcgbWFpbnRhaW5lciEgQXMgRGF2aWQgQS4gdmFuIExlZXV3ZW4gaGFzIGJlZW4gdG9vIGJ1c3kgdG8gYWN0aXZlbHkKICAgbWFpbnRhaW4gYW5kIGltcHJvdmUgdGhpcyBkcml2ZXIsIEkgYW0gbm93IGNhcnJ5aW5nIG9uIHRoZSB0b3JjaC4gSWYKICAgeW91IGhhdmUgYSBwcm9ibGVtIHdpdGggdGhpcyBkcml2ZXIsIHBsZWFzZSBmZWVsIGZyZWUgdG8gY29udGFjdCBtZS4KIApAQCAtMjUyMCw3ICsyNTIwLDcgQEAKIC8qCiAgKiBPaywgdGhpcyBpcyB3aGVyZSBwcm9ibGVtcyBzdGFydC4gIFRoZSBjdXJyZW50IGludGVyZmFjZSBmb3IgdGhlCiAgKiBDRFJPTV9ESVNDX1NUQVRVUyBpb2N0bCBpcyBmbGF3ZWQuICBJdCBtYWtlcyB0aGUgZmFsc2UgYXNzdW1wdGlvbiB0aGF0Ci0gKiBDRHMgYXJlIGFsbCBDRFNfREFUQV8xIG9yIGFsbCBDRFNfQVVESU8sIGV0Yy4gIFVuZm9ydHVuYXRseSwgd2hpbGUgdGhpcworICogQ0RzIGFyZSBhbGwgQ0RTX0RBVEFfMSBvciBhbGwgQ0RTX0FVRElPLCBldGMuICBVbmZvcnR1bmF0ZWx5LCB3aGlsZSB0aGlzCiAgKiBpcyBvZnRlbiB0aGUgY2FzZSwgaXQgaXMgYWxzbyB2ZXJ5IGNvbW1vbiBmb3IgQ0RzIHRvIGhhdmUgc29tZSB0cmFja3MKICAqIHdpdGggZGF0YSwgYW5kIHNvbWUgdHJhY2tzIHdpdGggYXVkaW8uICBKdXN0IGJlY2F1c2UgSSBmZWVsIGxpa2UgaXQsCiAgKiBJIGRlY2xhcmUgdGhlIGZvbGxvd2luZyB0byBiZSB0aGUgYmVzdCB3YXkgdG8gY29wZS4gIElmIHRoZSBDRCBoYXMgQU5ZCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvYWdwL2FncC5oIGIvZHJpdmVycy9jaGFyL2FncC9hZ3AuaAppbmRleCAzZTY3ZGRkLi45MjNmOTlkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvYWdwL2FncC5oCisrKyBiL2RyaXZlcnMvY2hhci9hZ3AvYWdwLmgKQEAgLTIzNyw3ICsyMzcsNyBAQAogCiBsb25nIGNvbXBhdF9hZ3BfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKTsKIAotLyogQ2hpcHNldCBpbmRlcGVuZGFudCByZWdpc3RlcnMgKGZyb20gQUdQIFNwZWMpICovCisvKiBDaGlwc2V0IGluZGVwZW5kZW50IHJlZ2lzdGVycyAoZnJvbSBBR1AgU3BlYykgKi8KICNkZWZpbmUgQUdQX0FQQkFTRQkweDEwCiAKICNkZWZpbmUgQUdQU1RBVAkJMHg0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvYWdwL2FtZC1rNy1hZ3AuYyBiL2RyaXZlcnMvY2hhci9hZ3AvYW1kLWs3LWFncC5jCmluZGV4IDQ1NjgxYzAuLmY3ZTg4NzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9hZ3AvYW1kLWs3LWFncC5jCisrKyBiL2RyaXZlcnMvY2hhci9hZ3AvYW1kLWs3LWFncC5jCkBAIC0yNzIsNyArMjcyLDcgQEAKICAqIFRoaXMgcm91dGluZSBjb3VsZCBiZSBpbXBsZW1lbnRlZCBieSB0YWtpbmcgdGhlIGFkZHJlc3NlcwogICogd3JpdHRlbiB0byB0aGUgR0FUVCwgYW5kIGZsdXNoaW5nIHRoZW0gaW5kaXZpZHVhbGx5LiAgSG93ZXZlcgogICogY3VycmVudGx5IGl0IGp1c3QgZmx1c2hlcyB0aGUgd2hvbGUgdGFibGUuICBXaGljaCBpcyBwcm9iYWJseQotICogbW9yZSBlZmZpY2VudCwgc2luY2UgYWdwX21lbW9yeSBibG9ja3MgY2FuIGJlIGEgbGFyZ2UgbnVtYmVyIG9mCisgKiBtb3JlIGVmZmljaWVudCwgc2luY2UgYWdwX21lbW9yeSBibG9ja3MgY2FuIGJlIGEgbGFyZ2UgbnVtYmVyIG9mCiAgKiBlbnRyaWVzLgogICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9hZ3Avc3dvcmtzLWFncC5jIGIvZHJpdmVycy9jaGFyL2FncC9zd29ya3MtYWdwLmMKaW5kZXggMTNhY2FhZi4uZjAyZjliMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2FncC9zd29ya3MtYWdwLmMKKysrIGIvZHJpdmVycy9jaGFyL2FncC9zd29ya3MtYWdwLmMKQEAgLTIyOSw3ICsyMjksNyBAQAogICogVGhpcyByb3V0aW5lIGNvdWxkIGJlIGltcGxlbWVudGVkIGJ5IHRha2luZyB0aGUgYWRkcmVzc2VzCiAgKiB3cml0dGVuIHRvIHRoZSBHQVRULCBhbmQgZmx1c2hpbmcgdGhlbSBpbmRpdmlkdWFsbHkuICBIb3dldmVyCiAgKiBjdXJyZW50bHkgaXQganVzdCBmbHVzaGVzIHRoZSB3aG9sZSB0YWJsZS4gIFdoaWNoIGlzIHByb2JhYmx5Ci0gKiBtb3JlIGVmZmljZW50LCBzaW5jZSBhZ3BfbWVtb3J5IGJsb2NrcyBjYW4gYmUgYSBsYXJnZSBudW1iZXIgb2YKKyAqIG1vcmUgZWZmaWNpZW50LCBzaW5jZSBhZ3BfbWVtb3J5IGJsb2NrcyBjYW4gYmUgYSBsYXJnZSBudW1iZXIgb2YKICAqIGVudHJpZXMuCiAgKi8KIHN0YXRpYyB2b2lkIHNlcnZlcndvcmtzX3RsYmZsdXNoKHN0cnVjdCBhZ3BfbWVtb3J5ICp0ZW1wKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2FncC92aWEtYWdwLmMgYi9kcml2ZXJzL2NoYXIvYWdwL3ZpYS1hZ3AuYwppbmRleCBkZjY3ZTgwLi44YmMzODQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvYWdwL3ZpYS1hZ3AuYworKysgYi9kcml2ZXJzL2NoYXIvYWdwL3ZpYS1hZ3AuYwpAQCAtNDAwLDcgKzQwMCw3IEBACiAJICogdGhlIHRyYWRpdGlvbmFsIEFHUCB3aGljaCByZXNpZGVzIG9ubHkgaW4gY2hpcHNldC4gQUdQIGlzIHVzZWQKIAkgKiBieSAzRCBkcml2ZXIgd2hpY2ggd2Fzbid0IGF2YWlsYWJsZSBmb3IgdGhlIFZUMzMzNiBhbmQgVlQzMzY0CiAJICogZ2VuZXJhdGlvbiB1bnRpbCBub3cuICBVbmZvcnR1bmF0ZWx5LCBieSB0ZXN0aW5nLCBWVDMzNjQgd29ya3MKLQkgKiBidXQgVlQzMzM2IGRvZXNuJ3QuIC0gZXhwbGFpbmF0aW9uIGZyb20gdmlhLCBqdXN0IGxlYXZlIHRoaXMgYXMKKwkgKiBidXQgVlQzMzM2IGRvZXNuJ3QuIC0gZXhwbGFuYXRpb24gZnJvbSB2aWEsIGp1c3QgbGVhdmUgdGhpcyBhcwogCSAqIGFzIGEgcGxhY2Vob2xkZXIgdG8gYXZvaWQgZnV0dXJlIHBhdGNoZXMgYWRkaW5nIGl0IGJhY2sgaW4uCiAJICovCiAjaWYgMApkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2lwbWkvaXBtaV9wb3dlcm9mZi5jIGIvZHJpdmVycy9jaGFyL2lwbWkvaXBtaV9wb3dlcm9mZi5jCmluZGV4IDBkZWM1ZGEuLjJlZmExNzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9pcG1pL2lwbWlfcG93ZXJvZmYuYworKysgYi9kcml2ZXJzL2NoYXIvaXBtaS9pcG1pX3Bvd2Vyb2ZmLmMKQEAgLTEyMiw3ICsxMjIsNyBAQAogCiAKIC8qCi0gKiBDb2RlIHRvIHNlbmQgYSBtZXNzYWdlIGFuZCB3YWl0IGZvciB0aGUgcmVwb25zZS4KKyAqIENvZGUgdG8gc2VuZCBhIG1lc3NhZ2UgYW5kIHdhaXQgZm9yIHRoZSByZXNwb25zZS4KICAqLwogCiBzdGF0aWMgdm9pZCByZWNlaXZlX2hhbmRsZXIoc3RydWN0IGlwbWlfcmVjdl9tc2cgKnJlY3ZfbXNnLCB2b2lkICpoYW5kbGVyX2RhdGEpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaXBtaS9pcG1pX3NpX2ludGYuYyBiL2RyaXZlcnMvY2hhci9pcG1pL2lwbWlfc2lfaW50Zi5jCmluZGV4IGQyOGI0ODQuLmNjNmM5YjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9pcG1pL2lwbWlfc2lfaW50Zi5jCisrKyBiL2RyaXZlcnMvY2hhci9pcG1pL2lwbWlfc2lfaW50Zi5jCkBAIC0zMzksNyArMzM5LDcgQEAKIAkJY0NvZGUgPSBJUE1JX0VSUl9VTlNQRUNJRklFRDsKIAkvKiBlbHNlIHVzZSBpdCBhcyBpcyAqLwogCi0JLyogTWFrZSBpdCBhIHJlcG9uc2UgKi8KKwkvKiBNYWtlIGl0IGEgcmVzcG9uc2UgKi8KIAltc2ctPnJzcFswXSA9IG1zZy0+ZGF0YVswXSB8IDQ7CiAJbXNnLT5yc3BbMV0gPSBtc2ctPmRhdGFbMV07CiAJbXNnLT5yc3BbMl0gPSBjQ29kZTsKQEAgLTI5MjcsNyArMjkyNyw3IEBACiB7CiAJc3RydWN0IGlwbWlfc21pX21zZyAqbXNnID0gc21pX2luZm8tPmN1cnJfbXNnOwogCi0JLyogTWFrZSBpdCBhIHJlcG9uc2UgKi8KKwkvKiBNYWtlIGl0IGEgcmVzcG9uc2UgKi8KIAltc2ctPnJzcFswXSA9IG1zZy0+ZGF0YVswXSB8IDQ7CiAJbXNnLT5yc3BbMV0gPSBtc2ctPmRhdGFbMV07CiAJbXNnLT5yc3BbMl0gPSBDQU5OT1RfUkVUVVJOX1JFUVVFU1RFRF9MRU5HVEg7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvbWJjcy5oIGIvZHJpdmVycy9jaGFyL21iY3MuaAppbmRleCBiYTY3MTU4Li4xYTM2ODg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvbWJjcy5oCisrKyBiL2RyaXZlcnMvY2hhci9tYmNzLmgKQEAgLTM2LDEzICszNiwxMyBAQAogI2RlZmluZSBNQkNTX1JEX0RNQV9DVFJMCTB4MDExMAkvKiBSZWFkIERNQSBDb250cm9sICovCiAjZGVmaW5lIE1CQ1NfUkRfRE1BX0FNT19ERVNUCTB4MDExOAkvKiBSZWFkIERNQSBBTU8gRGVzdGluYXRpb24gKi8KICNkZWZpbmUgTUJDU19SRF9ETUFfSU5UX0RFU1QJMHgwMTIwCS8qIFJlYWQgRE1BIEludGVycnVwdCBEZXN0aW5hdGlvbiAqLwotI2RlZmluZSBNQkNTX1JEX0RNQV9BVVhfU1RBVAkweDAxMzAJLyogUmVhZCBETUEgQXV4aWxsYXJ5IFN0YXR1cyAqLworI2RlZmluZSBNQkNTX1JEX0RNQV9BVVhfU1RBVAkweDAxMzAJLyogUmVhZCBETUEgQXV4aWxpYXJ5IFN0YXR1cyAqLwogI2RlZmluZSBNQkNTX1dSX0RNQV9TWVNfQUREUgkweDAyMDAJLyogV3JpdGUgRE1BIFN5c3RlbSBBZGRyZXNzICovCiAjZGVmaW5lIE1CQ1NfV1JfRE1BX0xPQ19BRERSCTB4MDIwOAkvKiBXcml0ZSBETUEgTG9jYWwgQWRkcmVzcyAqLwogI2RlZmluZSBNQkNTX1dSX0RNQV9DVFJMCTB4MDIxMAkvKiBXcml0ZSBETUEgQ29udHJvbCAqLwogI2RlZmluZSBNQkNTX1dSX0RNQV9BTU9fREVTVAkweDAyMTgJLyogV3JpdGUgRE1BIEFNTyBEZXN0aW5hdGlvbiAqLwogI2RlZmluZSBNQkNTX1dSX0RNQV9JTlRfREVTVAkweDAyMjAJLyogV3JpdGUgRE1BIEludGVycnVwdCBEZXN0aW5hdGlvbiAqLwotI2RlZmluZSBNQkNTX1dSX0RNQV9BVVhfU1RBVAkweDAyMzAJLyogV3JpdGUgRE1BIEF1eGlsbGFyeSBTdGF0dXMgKi8KKyNkZWZpbmUgTUJDU19XUl9ETUFfQVVYX1NUQVQJMHgwMjMwCS8qIFdyaXRlIERNQSBBdXhpbGlhcnkgU3RhdHVzICovCiAjZGVmaW5lIE1CQ1NfQUxHX0FNT19ERVNUCTB4MDMwMAkvKiBBbGdvcml0aG0gQU1PIERlc3RpbmF0aW9uICovCiAjZGVmaW5lIE1CQ1NfQUxHX0lOVF9ERVNUCTB4MDMwOAkvKiBBbGdvcml0aG0gSW50ZXJydXB0IERlc3RpbmF0aW9uICovCiAjZGVmaW5lIE1CQ1NfQUxHX09GRlNFVFMJMHgwMzEwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvbXdhdmUvMzc4MGkuaCBiL2RyaXZlcnMvY2hhci9td2F2ZS8zNzgwaS5oCmluZGV4IDI3MDQzMWMuLmZiYTZhYjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9td2F2ZS8zNzgwaS5oCisrKyBiL2RyaXZlcnMvY2hhci9td2F2ZS8zNzgwaS5oCkBAIC0xMjIsNyArMTIyLDcgQEAKIHR5cGVkZWYgc3RydWN0IHsKIAl1bnNpZ25lZCBjaGFyIERtYTozOwkvKiBSVzogRE1BIGNoYW5uZWwgc2VsZWN0aW9uICovCiAJdW5zaWduZWQgY2hhciBOdW1UcmFuc2ZlcnM6MjsJLyogUlc6IE1heGltdW0gIyBvZiB0cmFuc2ZlcnMgb25jZSBiZWluZyBncmFudGVkIHRoZSBJU0EgYnVzICovCi0JdW5zaWduZWQgY2hhciBSZVJlcXVlc3Q6MjsJLyogUlc6IE1pbnVtdW0gZGVsYXkgYmV0d2VlbiByZWxlYXNpbmcgdGhlIElTQSBidXMgYW5kIHJlcXVlc3RpbmcgaXQgYWdhaW4gKi8KKwl1bnNpZ25lZCBjaGFyIFJlUmVxdWVzdDoyOwkvKiBSVzogTWluaW11bSBkZWxheSBiZXR3ZWVuIHJlbGVhc2luZyB0aGUgSVNBIGJ1cyBhbmQgcmVxdWVzdGluZyBpdCBhZ2FpbiAqLwogCXVuc2lnbmVkIGNoYXIgTUVNQ1MxNjoxOwkvKiBSVzogSVNBIHNpZ25hbCBNRU1DUzE2OiAwPWRpc2FibGVkLCAxPWVuYWJsZWQgKi8KIH0gRFNQX0JVU01BU1RFUl9DRkdfMTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL253YnV0dG9uLmMgYi9kcml2ZXJzL2NoYXIvbndidXR0b24uYwppbmRleCA4OTk0Y2UzLi4wNGE0ODBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvbndidXR0b24uYworKysgYi9kcml2ZXJzL2NoYXIvbndidXR0b24uYwpAQCAtNzUsNyArNzUsNyBAQAogICogd2l0aCAtRUlOVkFMLiBJZiB0aGVyZSBpcyBtb3JlIHRoYW4gb25lIGVudHJ5IHdpdGggdGhlIHNhbWUgYWRkcmVzcywKICAqIGJlY2F1c2UgaXQgc2VhcmNoZXMgdGhlIGxpc3QgZnJvbSBlbmQgdG8gYmVnaW5uaW5nLCBpdCB3aWxsIHVucmVnaXN0ZXIgdGhlCiAgKiBsYXN0IG9uZSB0byBiZSByZWdpc3RlcmVkIGZpcnN0IChGSUxPLSBGaXJzdCBJbiBMYXN0IE91dCkuCi0gKiBOb3RlIHRoYXQgdGhpcyBpcyBub3QgbmVjY2Vzc2FyaWx5IHRydWUgaWYgdGhlIGVudHJpZXMgYXJlIG5vdCBzdWJtaXR0ZWQKKyAqIE5vdGUgdGhhdCB0aGlzIGlzIG5vdCBuZWNlc3NhcmlseSB0cnVlIGlmIHRoZSBlbnRyaWVzIGFyZSBub3Qgc3VibWl0dGVkCiAgKiBhdCB0aGUgc2FtZSB0aW1lLCBiZWNhdXNlIGFub3RoZXIgZHJpdmVyIGNvdWxkIGhhdmUgdW5yZWdpc3RlcmVkIGEgY2FsbGJhY2sKICAqIGJldHdlZW4gdGhlIHN1Ym1pc3Npb25zIGNyZWF0aW5nIGEgZ2FwIGVhcmxpZXIgaW4gdGhlIGxpc3QsIHdoaWNoIHdvdWxkCiAgKiBiZSBmaWxsZWQgZmlyc3QgYXQgc3VibWlzc2lvbiB0aW1lLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3BjbWNpYS9jbTQwMDBfY3MuYyBiL2RyaXZlcnMvY2hhci9wY21jaWEvY200MDAwX2NzLmMKaW5kZXggYmNiYmM3MS4uOTBiZDAxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3BjbWNpYS9jbTQwMDBfY3MuYworKysgYi9kcml2ZXJzL2NoYXIvcGNtY2lhL2NtNDAwMF9jcy5jCkBAIC04MDYsNyArODA2LDcgQEAKIAkJZGV2LT5mbGFnczEgPSAweDAxOwogCQl4b3V0YihkZXYtPmZsYWdzMSwgUkVHX0ZMQUdTMShpb2Jhc2UpKTsKIAotCQkvKiBhdHIgaXMgcHJlc2VudCAod2hpY2ggZG9lc250IG1lYW4gaXQncyB2YWxpZCkgKi8KKwkJLyogYXRyIGlzIHByZXNlbnQgKHdoaWNoIGRvZXNuJ3QgbWVhbiBpdCdzIHZhbGlkKSAqLwogCQlzZXRfYml0KElTX0FUUl9QUkVTRU5ULCAmZGV2LT5mbGFncyk7CiAJCWlmIChkZXYtPmF0clswXSA9PSAweDAzKQogCQkJc3RyX2ludmVydF9yZXZlcnQoZGV2LT5hdHIsIGRldi0+YXRyX2xlbik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvcGNtY2lhL3N5bmNsaW5rX2NzLmMgYi9kcml2ZXJzL2NoYXIvcGNtY2lhL3N5bmNsaW5rX2NzLmMKaW5kZXggYmVjYTgwYi4uYjU3NTQxMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3BjbWNpYS9zeW5jbGlua19jcy5jCisrKyBiL2RyaXZlcnMvY2hhci9wY21jaWEvc3luY2xpbmtfY3MuYwpAQCAtMTI5MCw3ICsxMjkwLDcgQEAKIAkvKiBBbGxvY2F0ZSBhbmQgY2xhaW0gYWRhcHRlciByZXNvdXJjZXMgKi8KIAlyZXR2YWwgPSBjbGFpbV9yZXNvdXJjZXMoaW5mbyk7CiAKLQkvKiBwZXJmb3JtIGV4aXN0YW5jZSBjaGVjayBhbmQgZGlhZ25vc3RpY3MgKi8KKwkvKiBwZXJmb3JtIGV4aXN0ZW5jZSBjaGVjayBhbmQgZGlhZ25vc3RpY3MgKi8KIAlpZiAoICFyZXR2YWwgKQogCQlyZXR2YWwgPSBhZGFwdGVyX3Rlc3QoaW5mbyk7CiAKQEAgLTI2ODAsNyArMjY4MCw3IEBACiBzdGF0aWMgaW50IGNsYWltX3Jlc291cmNlcyhNR1NMUENfSU5GTyAqaW5mbykKIHsKIAlpZiAocnhfYWxsb2NfYnVmZmVycyhpbmZvKSA8IDAgKSB7Ci0JCXByaW50ayggIkNhbnQgYWxsb2NhdGUgcnggYnVmZmVyICVzXG4iLCBpbmZvLT5kZXZpY2VfbmFtZSk7CisJCXByaW50ayggIkNhbid0IGFsbG9jYXRlIHJ4IGJ1ZmZlciAlc1xuIiwgaW5mby0+ZGV2aWNlX25hbWUpOwogCQlyZWxlYXNlX3Jlc291cmNlcyhpbmZvKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3JhbmRvbS5jIGIvZHJpdmVycy9jaGFyL3JhbmRvbS5jCmluZGV4IDVlMjllODAuLmQ0ZGRlYmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9yYW5kb20uYworKysgYi9kcml2ZXJzL2NoYXIvcmFuZG9tLmMKQEAgLTczMiw3ICs3MzIsNyBAQAogCQkJICAgICAgIHNpemVfdCBuYnl0ZXMsIGludCBtaW4sIGludCByc3ZkKTsKIAogLyoKLSAqIFRoaXMgdXRpbGl0eSBpbmxpbmUgZnVuY3Rpb24gaXMgcmVzcG9uc2libGUgZm9yIHRyYW5zZmVyaW5nIGVudHJvcHkKKyAqIFRoaXMgdXRpbGl0eSBpbmxpbmUgZnVuY3Rpb24gaXMgcmVzcG9uc2libGUgZm9yIHRyYW5zZmVycmluZyBlbnRyb3B5CiAgKiBmcm9tIHRoZSBwcmltYXJ5IHBvb2wgdG8gdGhlIHNlY29uZGFyeSBleHRyYWN0aW9uIHBvb2wuIFdlIG1ha2UKICAqIHN1cmUgd2UgcHVsbCBlbm91Z2ggZm9yIGEgJ2NhdGFzdHJvcGhpYyByZXNlZWQnLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvc29ueXBpLmMgYi9kcml2ZXJzL2NoYXIvc29ueXBpLmMKaW5kZXggNzllMzZjOC4uMWVlOGNlNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3NvbnlwaS5jCisrKyBiL2RyaXZlcnMvY2hhci9zb255cGkuYwpAQCAtMTI0MSw3ICsxMjQxLDcgQEAKIAl3aGlsZSAoY2hlY2tfaW9wb3J0ICYmIGNoZWNrLT5wb3J0MSkgewogCQlpZiAoIXJlcXVlc3RfcmVnaW9uKGNoZWNrLT5wb3J0MSwKIAkJCQkgICBzb255cGlfZGV2aWNlLnJlZ2lvbl9zaXplLAotCQkJCSAgICJTb255IFByb2dyYW1hYmxlIEkvTyBEZXZpY2UgQ2hlY2siKSkgeworCQkJCSAgICJTb255IFByb2dyYW1tYWJsZSBJL08gRGV2aWNlIENoZWNrIikpIHsKIAkJCXByaW50ayhLRVJOX0VSUiAic29ueXBpOiBpb3BvcnQgMHglLjR4IGJ1c3ksIHVzaW5nIHNvbnktbGFwdG9wPyAiCiAJCQkJCSJpZiBub3QgdXNlIGNoZWNrX2lvcG9ydD0wXG4iLAogCQkJCQljaGVjay0+cG9ydDEpOwpAQCAtMTI1NSw3ICsxMjU1LDcgQEAKIAogCQlpZiAocmVxdWVzdF9yZWdpb24oaW9wb3J0X2xpc3QtPnBvcnQxLAogCQkJCSAgIHNvbnlwaV9kZXZpY2UucmVnaW9uX3NpemUsCi0JCQkJICAgIlNvbnkgUHJvZ3JhbWFibGUgSS9PIERldmljZSIpKSB7CisJCQkJICAgIlNvbnkgUHJvZ3JhbW1hYmxlIEkvTyBEZXZpY2UiKSkgewogCQkJZGV2LT5pb3BvcnQxID0gaW9wb3J0X2xpc3QtPnBvcnQxOwogCQkJZGV2LT5pb3BvcnQyID0gaW9wb3J0X2xpc3QtPnBvcnQyOwogCQkJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIveGlsaW54X2h3aWNhcC94aWxpbnhfaHdpY2FwLmMgYi9kcml2ZXJzL2NoYXIveGlsaW54X2h3aWNhcC94aWxpbnhfaHdpY2FwLmMKaW5kZXggZDNjOWQ3NS4uZDY0MTJjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3hpbGlueF9od2ljYXAveGlsaW54X2h3aWNhcC5jCisrKyBiL2RyaXZlcnMvY2hhci94aWxpbnhfaHdpY2FwL3hpbGlueF9od2ljYXAuYwpAQCAtNjcsNyArNjcsNyBAQAogICogY3AgZm9vLmJpdCAvZGV2L2ljYXAwCiAgKgogICogTm90ZSB0aGF0IHVubGVzcyBmb28uYml0IGlzIGFuIGFwcHJvcHJpYXRlbHkgY29uc3RydWN0ZWQgcGFydGlhbAotICogYml0c3RyZWFtLCB0aGlzIGhhcyBhIGhpZ2ggbGlrZWx5aG9vZCBvZiBvdmVyd3JpdGluZyB0aGUgZGVzaWduCisgKiBiaXRzdHJlYW0sIHRoaXMgaGFzIGEgaGlnaCBsaWtlbGlob29kIG9mIG92ZXJ3cml0aW5nIHRoZSBkZXNpZ24KICAqIGN1cnJlbnRseSBwcm9ncmFtbWVkIGluIHRoZSBGUEdBLgogICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3B1ZnJlcS9jcHVmcmVxLmMgYi9kcml2ZXJzL2NwdWZyZXEvY3B1ZnJlcS5jCmluZGV4IGIwMzc3MWQuLjJkYWZjNWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3B1ZnJlcS9jcHVmcmVxLmMKKysrIGIvZHJpdmVycy9jcHVmcmVxL2NwdWZyZXEuYwpAQCAtMTc4Miw3ICsxNzgyLDcgQEAKICAqCWNwdWZyZXFfdXBkYXRlX3BvbGljeSAtIHJlLWV2YWx1YXRlIGFuIGV4aXN0aW5nIGNwdWZyZXEgcG9saWN5CiAgKglAY3B1OiBDUFUgd2hpY2ggc2hhbGwgYmUgcmUtZXZhbHVhdGVkCiAgKgotICoJVXNlZnVsbCBmb3IgcG9saWN5IG5vdGlmaWVycyB3aGljaCBoYXZlIGRpZmZlcmVudCBuZWNlc3NpdGllcworICoJVXNlZnVsIGZvciBwb2xpY3kgbm90aWZpZXJzIHdoaWNoIGhhdmUgZGlmZmVyZW50IG5lY2Vzc2l0aWVzCiAgKglhdCBkaWZmZXJlbnQgdGltZXMuCiAgKi8KIGludCBjcHVmcmVxX3VwZGF0ZV9wb2xpY3kodW5zaWduZWQgaW50IGNwdSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL2FtY2MvY3J5cHRvNHh4X3NhLmMgYi9kcml2ZXJzL2NyeXB0by9hbWNjL2NyeXB0bzR4eF9zYS5jCmluZGV4IDQ2NmZkOTQuLmRlOGE3YTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3J5cHRvL2FtY2MvY3J5cHRvNHh4X3NhLmMKKysrIGIvZHJpdmVycy9jcnlwdG8vYW1jYy9jcnlwdG80eHhfc2EuYwpAQCAtMTcsNyArMTcsNyBAQAogICogQGZpbGUgY3J5cHRvNHh4X3NhLmMKICAqCiAgKiBUaGlzIGZpbGUgaW1wbGVtZW50cyB0aGUgc2VjdXJpdHkgY29udGV4dAotICogYXNzb2ljYXRlIGZvcm1hdC4KKyAqIGFzc29jaWF0ZSBmb3JtYXQuCiAgKi8KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL2FtY2MvY3J5cHRvNHh4X3NhLmggYi9kcml2ZXJzL2NyeXB0by9hbWNjL2NyeXB0bzR4eF9zYS5oCmluZGV4IDRiODNlZDcuLjEzNTJkNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3J5cHRvL2FtY2MvY3J5cHRvNHh4X3NhLmgKKysrIGIvZHJpdmVycy9jcnlwdG8vYW1jYy9jcnlwdG80eHhfc2EuaApAQCAtMTUsNyArMTUsNyBAQAogICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICAqCiAgKiBUaGlzIGZpbGUgZGVmaW5lcyB0aGUgc2VjdXJpdHkgY29udGV4dAotICogYXNzb2ljYXRlIGZvcm1hdC4KKyAqIGFzc29jaWF0ZSBmb3JtYXQuCiAgKi8KIAogI2lmbmRlZiBfX0NSWVBUTzRYWF9TQV9IX18KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL2l4cDR4eF9jcnlwdG8uYyBiL2RyaXZlcnMvY3J5cHRvL2l4cDR4eF9jcnlwdG8uYwppbmRleCAwZDY2MjIxLi40YzIwYzViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NyeXB0by9peHA0eHhfY3J5cHRvLmMKKysrIGIvZHJpdmVycy9jcnlwdG8vaXhwNHh4X2NyeXB0by5jCkBAIC0xMDQ0LDcgKzEwNDQsNyBAQAogCW1lbWNweShjcnlwdC0+aXYsIHJlcS0+aXYsIGl2c2l6ZSk7CiAKIAlpZiAocmVxLT5zcmMgIT0gcmVxLT5kc3QpIHsKLQkJQlVHKCk7IC8qIC1FTk9UU1VQIGJlY2F1c2Ugb2YgbXkgbGF6eW5lc3MgKi8KKwkJQlVHKCk7IC8qIC1FTk9UU1VQIGJlY2F1c2Ugb2YgbXkgbGF6aW5lc3MgKi8KIAl9CiAKIAkvKiBBU1NPQyBkYXRhICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9hdF9oZG1hYy5jIGIvZHJpdmVycy9kbWEvYXRfaGRtYWMuYwppbmRleCAzZDdkNzA1Li4yMzVmNTNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2RtYS9hdF9oZG1hYy5jCisrKyBiL2RyaXZlcnMvZG1hL2F0X2hkbWFjLmMKQEAgLTE2Nyw3ICsxNjcsNyBAQAogLyoqCiAgKiBhdGNfYXNzaWduX2Nvb2tpZSAtIGNvbXB1dGUgYW5kIGFzc2lnbiBuZXcgY29va2llCiAgKiBAYXRjaGFuOiBjaGFubmVsIHdlIHdvcmsgb24KLSAqIEBkZXNjOiBkZXNjcmlwdG9yIHRvIGFzaWduIGNvb2tpZSBmb3IKKyAqIEBkZXNjOiBkZXNjcmlwdG9yIHRvIGFzc2lnbiBjb29raWUgZm9yCiAgKgogICogQ2FsbGVkIHdpdGggYXRjaGFuLT5sb2NrIGhlbGQgYW5kIGJoIGRpc2FibGVkCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL2NvaDkwMTMxOC5jIGIvZHJpdmVycy9kbWEvY29oOTAxMzE4LmMKaW5kZXggMDBkZWFiZC4uZjQ4ZTU0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvY29oOTAxMzE4LmMKKysrIGIvZHJpdmVycy9kbWEvY29oOTAxMzE4LmMKQEAgLTUyOSw3ICs1MjksNyBAQAogCXZhbCA9IHJlYWRsKHZpcnRiYXNlICsgQ09IOTAxMzE4X0NYX0NGRyArCiAJCSAgICBDT0g5MDEzMThfQ1hfQ0ZHX1NQQUNJTkcgKiBjaGFubmVsKTsKIAotCS8qIFN0b3BwaW5nIGluZmluaXQgdHJhbnNmZXIgKi8KKwkvKiBTdG9wcGluZyBpbmZpbml0ZSB0cmFuc2ZlciAqLwogCWlmICgodmFsICYgQ09IOTAxMzE4X0NYX0NUUkxfVENfRU5BQkxFKSA9PSAwICYmCiAJICAgICh2YWwgJiBDT0g5MDEzMThfQ1hfQ0ZHX0NIX0VOQUJMRSkpCiAJCWNvaGMtPnN0b3BwZWQgPSAxOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvaW50ZWxfbWlkX2RtYS5jIGIvZHJpdmVycy9kbWEvaW50ZWxfbWlkX2RtYS5jCmluZGV4IDc5OGY0NmEuLjNkNGVjMzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL2ludGVsX21pZF9kbWEuYworKysgYi9kcml2ZXJzL2RtYS9pbnRlbF9taWRfZG1hLmMKQEAgLTkxMSw4ICs5MTEsOCBAQAogCiAvKioKICAqIG1pZGNfaGFuZGxlX2Vycm9yIC0JSGFuZGxlIERNQSB0eG4gZXJyb3IKLSAqIEBtaWQ6IGNvbnRyb2xsZXIgd2hlcmUgZXJyb3Igb2NjdXJlZAotICogQG1pZGM6IGNoYW4gd2hlcmUgZXJyb3Igb2NjdXJlZAorICogQG1pZDogY29udHJvbGxlciB3aGVyZSBlcnJvciBvY2N1cnJlZAorICogQG1pZGM6IGNoYW4gd2hlcmUgZXJyb3Igb2NjdXJyZWQKICAqCiAgKiBTY2FuIHRoZSBkZXNjcmlwdG9yIGZvciBlcnJvcgogICovCkBAIC0xMDk5LDcgKzEwOTksNyBAQAogCQlkbWEtPm1hc2tfcmVnID0gaW9yZW1hcChMTldfUEVSSVBIUkFMX01BU0tfQkFTRSwKIAkJCQkJTE5XX1BFUklQSFJBTF9NQVNLX1NJWkUpOwogCQlpZiAoZG1hLT5tYXNrX3JlZyA9PSBOVUxMKSB7Ci0JCQlwcl9lcnIoIkVSUl9NRE1BOkNhbnQgbWFwIHBlcmlwaHJhbCBpbnRyIHNwYWNlICEhXG4iKTsKKwkJCXByX2VycigiRVJSX01ETUE6Q2FuJ3QgbWFwIHBlcmlwaHJhbCBpbnRyIHNwYWNlICEhXG4iKTsKIAkJCXJldHVybiAtRU5PTUVNOwogCQl9CiAJfSBlbHNlCkBAIC0xMzczLDcgKzEzNzMsNyBAQAogCXBjaV9yZXN0b3JlX3N0YXRlKHBjaSk7CiAJcmV0ID0gcGNpX2VuYWJsZV9kZXZpY2UocGNpKTsKIAlpZiAocmV0KSB7Ci0JCXByX2VycigiTURNQTogZGV2aWNlIGNhbnQgYmUgZW5hYmxlZCBmb3IgJXhcbiIsIHBjaS0+ZGV2aWNlKTsKKwkJcHJfZXJyKCJNRE1BOiBkZXZpY2UgY2FuJ3QgYmUgZW5hYmxlZCBmb3IgJXhcbiIsIHBjaS0+ZGV2aWNlKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAJZGV2aWNlLT5zdGF0ZSA9IFJVTk5JTkc7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9pbnRlbF9taWRfZG1hX3JlZ3MuaCBiL2RyaXZlcnMvZG1hL2ludGVsX21pZF9kbWFfcmVncy5oCmluZGV4IDcwOWZlY2IuLmFlYTVlZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL2ludGVsX21pZF9kbWFfcmVncy5oCisrKyBiL2RyaXZlcnMvZG1hL2ludGVsX21pZF9kbWFfcmVncy5oCkBAIC0xNzQsOCArMTc0LDggQEAKICAqIEBkbWE6IGRtYSBkZXZpY2Ugc3RydXR1cmUgcG9pbnRlcgogICogQGJ1c3k6IGJvb2wgcmVwcmVzZW50aW5nIGlmIGNoIGlzIGJ1c3kgKGFjdGl2ZSB0eG4pIG9yIG5vdAogICogQGluX3VzZTogYm9vbCByZXByZXNlbnRpbmcgaWYgY2ggaXMgaW4gdXNlIG9yIG5vdAotICogQHJhd190ZnI6IHJhdyB0cmYgaW50ZXJydXB0IHJlY2lldmVkCi0gKiBAcmF3X2Jsb2NrOiByYXcgYmxvY2sgaW50ZXJydXB0IHJlY2lldmVkCisgKiBAcmF3X3RmcjogcmF3IHRyZiBpbnRlcnJ1cHQgcmVjZWl2ZWQKKyAqIEByYXdfYmxvY2s6IHJhdyBibG9jayBpbnRlcnJ1cHQgcmVjZWl2ZWQKICAqLwogc3RydWN0IGludGVsX21pZF9kbWFfY2hhbiB7CiAJc3RydWN0IGRtYV9jaGFuCQljaGFuOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvbXBjNTEyeF9kbWEuYyBiL2RyaXZlcnMvZG1hL21wYzUxMnhfZG1hLmMKaW5kZXggNGY5NWQzMS4uYjliYWU5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvbXBjNTEyeF9kbWEuYworKysgYi9kcml2ZXJzL2RtYS9tcGM1MTJ4X2RtYS5jCkBAIC0zMjgsNyArMzI4LDcgQEAKIAlyZXR1cm4gSVJRX0hBTkRMRUQ7CiB9CiAKLS8qIHByb2NjZXNzIGNvbXBsZXRlZCBkZXNjcmlwdG9ycyAqLworLyogcHJvY2VzcyBjb21wbGV0ZWQgZGVzY3JpcHRvcnMgKi8KIHN0YXRpYyB2b2lkIG1wY19kbWFfcHJvY2Vzc19jb21wbGV0ZWQoc3RydWN0IG1wY19kbWEgKm1kbWEpCiB7CiAJZG1hX2Nvb2tpZV90IGxhc3RfY29va2llID0gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL3NoZG1hLmMgYi9kcml2ZXJzL2RtYS9zaGRtYS5jCmluZGV4IDY0NTFiNTguLmQ1MGRhNDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL3NoZG1hLmMKKysrIGIvZHJpdmVycy9kbWEvc2hkbWEuYwpAQCAtODY1LDcgKzg2NSwxMiBAQAogCiBzdGF0aWMgaXJxcmV0dXJuX3Qgc2hfZG1hZV9lcnIoaW50IGlycSwgdm9pZCAqZGF0YSkKIHsKLQlyZXR1cm4gSVJRX1JFVFZBTChzaF9kbWFlX3Jlc2V0KGRhdGEpKTsKKwlzdHJ1Y3Qgc2hfZG1hZV9kZXZpY2UgKnNoZGV2ID0gZGF0YTsKKworCWlmIChkbWFvcl9yZWFkKHNoZGV2KSAmIERNQU9SX0FFKQorCQlyZXR1cm4gSVJRX1JFVFZBTChzaF9kbWFlX3Jlc2V0KGRhdGEpKTsKKwllbHNlCisJCXJldHVybiBJUlFfTk9ORTsKIH0KIAogc3RhdGljIHZvaWQgZG1hZV9kb190YXNrbGV0KHVuc2lnbmVkIGxvbmcgZGF0YSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL3N0ZV9kbWE0MC5jIGIvZHJpdmVycy9kbWEvc3RlX2RtYTQwLmMKaW5kZXggYWY5NTVkZS4uOTRlZTE1ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvc3RlX2RtYTQwLmMKKysrIGIvZHJpdmVycy9kbWEvc3RlX2RtYTQwLmMKQEAgLTkwLDcgKzkwLDcgQEAKICAqIEBsbGlfbG9nOiBTYW1lIGFzIGFib3ZlIGJ1dCBmb3IgbG9naWNhbCBjaGFubmVscy4KICAqIEBsbGlfcG9vbDogVGhlIHBvb2wgd2l0aCB0d28gZW50cmllcyBwcmUtYWxsb2NhdGVkLgogICogQGxsaV9sZW46IE51bWJlciBvZiBsbGlzIG9mIGN1cnJlbnQgZGVzY3JpcHRvci4KLSAqIEBsbGlfY3VycmVudDogTnVtYmVyIG9mIHRyYW5zZmVyZWQgbGxpcy4KKyAqIEBsbGlfY3VycmVudDogTnVtYmVyIG9mIHRyYW5zZmVycmVkIGxsaXMuCiAgKiBAbGNsYV9hbGxvYzogTnVtYmVyIG9mIExDTEEgZW50cmllcyBhbGxvY2F0ZWQuCiAgKiBAdHhkOiBETUEgZW5naW5lIHN0cnVjdC4gVXNlZCBmb3IgYW1vbmcgb3RoZXIgdGhpbmdzIGZvciBjb21tdW5pY2F0aW9uCiAgKiBkdXJpbmcgYSB0cmFuc2Zlci4KQEAgLTEyMTQsNyArMTIxNCw3IEBACiAJcmV0dXJuOwogCiAgZXJyOgotCS8qIFJlc2N1ZSBtYW5vdXZlciBpZiByZWNlaXZpbmcgZG91YmxlIGludGVycnVwdHMgKi8KKwkvKiBSZXNjdWUgbWFub2V1dnJlIGlmIHJlY2VpdmluZyBkb3VibGUgaW50ZXJydXB0cyAqLwogCWlmIChkNDBjLT5wZW5kaW5nX3R4ID4gMCkKIAkJZDQwYy0+cGVuZGluZ190eC0tOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmQ0MGMtPmxvY2ssIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9LY29uZmlnIGIvZHJpdmVycy9lZGFjL0tjb25maWcKaW5kZXggZmFjMWEyMC4uYWYxYTE3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL0tjb25maWcKKysrIGIvZHJpdmVycy9lZGFjL0tjb25maWcKQEAgLTQ1LDcgKzQ1LDcgQEAKIAlkZWZhdWx0IHkKIAktLS1oZWxwLS0tCiAJICBFbmFibGUgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZGVjb2RlIE1hY2hpbmUgQ2hlY2sgRXhjZXB0aW9ucwotCSAgb2NjdXJpbmcgb24geW91ciBtYWNoaW5lIGluIGh1bWFuLXJlYWRhYmxlIGZvcm0uCisJICBvY2N1cnJpbmcgb24geW91ciBtYWNoaW5lIGluIGh1bWFuLXJlYWRhYmxlIGZvcm0uCiAKIAkgIFlvdSBzaG91bGQgZGVmaW5pdGVseSBzYXkgWSBoZXJlIGluIGNhc2UgeW91IHdhbnQgdG8gZGVjb2RlIE1DRXMKIAkgIHdoaWNoIG9jY3VyIHJlYWxseSBlYXJseSB1cG9uIGJvb3QsIGJlZm9yZSB0aGUgbW9kdWxlIGluZnJhc3RydWN0dXJlCmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvY3BjOTI1X2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9jcGM5MjVfZWRhYy5jCmluZGV4IGI5YTc4MWMuLjgzN2FkOGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9jcGM5MjVfZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9jcGM5MjVfZWRhYy5jCkBAIC04MTcsNyArODE3LDcgQEAKIAl9CiB9CiAKLS8qIENvbnZlcnQgY3VycmVudCBiYWNrLWdyb3VuZCBzY3J1YiByYXRlIGludG8gYnl0ZS9zZWMgYmFuZHdpdGggKi8KKy8qIENvbnZlcnQgY3VycmVudCBiYWNrLWdyb3VuZCBzY3J1YiByYXRlIGludG8gYnl0ZS9zZWMgYmFuZHdpZHRoICovCiBzdGF0aWMgaW50IGNwYzkyNV9nZXRfc2RyYW1fc2NydWJfcmF0ZShzdHJ1Y3QgbWVtX2N0bF9pbmZvICptY2kpCiB7CiAJc3RydWN0IGNwYzkyNV9tY19wZGF0YSAqcGRhdGEgPSBtY2ktPnB2dF9pbmZvOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2VkYWNfY29yZS5oIGIvZHJpdmVycy9lZGFjL2VkYWNfY29yZS5oCmluZGV4IDNkOTY1MzQuLmVlZmEzNTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9lZGFjX2NvcmUuaAorKysgYi9kcml2ZXJzL2VkYWMvZWRhY19jb3JlLmgKQEAgLTE2NCw3ICsxNjQsNyBAQAogLyogY2hpcHNldCBFcnJvciBEZXRlY3Rpb24gYW5kIENvcnJlY3Rpb24gY2FwYWJpbGl0aWVzIGFuZCBtb2RlICovCiBlbnVtIGVkYWNfdHlwZSB7CiAJRURBQ19VTktOT1dOID0gMCwJLyogVW5rbm93biBpZiBFQ0MgaXMgYXZhaWxhYmxlICovCi0JRURBQ19OT05FLAkJLyogRG9lc250IHN1cHBvcnQgRUNDICovCisJRURBQ19OT05FLAkJLyogRG9lc24ndCBzdXBwb3J0IEVDQyAqLwogCUVEQUNfUkVTRVJWRUQsCQkvKiBSZXNlcnZlZCBFQ0MgdHlwZSAqLwogCUVEQUNfUEFSSVRZLAkJLyogRGV0ZWN0cyBwYXJpdHkgZXJyb3JzICovCiAJRURBQ19FQywJCS8qIEVycm9yIENoZWNraW5nIC0gbm8gY29ycmVjdGlvbiAqLwpAQCAtMjMzLDcgKzIzMyw3IEBACiAgKgkJCW9mIHRoZXNlIGluIHBhcmFsbGVsIHByb3ZpZGVzIDY0IGJpdHMgd2hpY2ggaXMgY29tbW9uCiAgKgkJCWZvciBhIG1lbW9yeSBzdGljay4KICAqCi0gKiBNZW1vcnkgU3RpY2s6CUEgcHJpbnRlZCBjaXJjdWl0IGJvYXJkIHRoYXQgYWdyZWdhdGVzIG11bHRpcGxlCisgKiBNZW1vcnkgU3RpY2s6CUEgcHJpbnRlZCBjaXJjdWl0IGJvYXJkIHRoYXQgYWdncmVnYXRlcyBtdWx0aXBsZQogICoJCQltZW1vcnkgZGV2aWNlcyBpbiBwYXJhbGxlbC4gIFRoaXMgaXMgdGhlIGF0b21pYwogICoJCQltZW1vcnkgY29tcG9uZW50IHRoYXQgaXMgcHVyY2hhc2VhYmxlIGJ5IEpvZSBjb25zdW1lcgogICoJCQlhbmQgbG9hZGVkIGludG8gYSBtZW1vcnkgc29ja2V0LgpAQCAtMzg1LDcgKzM4NSw3IEBACiAKIAkvKiBHZXQgdGhlIGN1cnJlbnQgc2RyYW0gbWVtb3J5IHNjcnViIHJhdGUgZnJvbSB0aGUgaW50ZXJuYWwKIAkgICByZXByZXNlbnRhdGlvbiBhbmQgY29udmVydHMgaXQgdG8gdGhlIGNsb3Nlc3QgbWF0Y2hpbmcKLQkgICBiYW5kd2l0aCBpbiBieXRlcy9zZWMuCisJICAgYmFuZHdpZHRoIGluIGJ5dGVzL3NlYy4KIAkgKi8KIAlpbnQgKCpnZXRfc2RyYW1fc2NydWJfcmF0ZSkgKHN0cnVjdCBtZW1fY3RsX2luZm8gKiBtY2kpOwogCkBAIC04MjMsNyArODIzLDcgQEAKICAqIFRoZXJlIGFyZSBhIGxpbWl0ZWQgbnVtYmVyIG9mIGVycm9yIGxvZ2dpbmcgcmVnaXN0ZXJzIHRoYXQgY2FuCiAgKiBiZSBleGF1c3RlZC4gIFdoZW4gYWxsIHJlZ2lzdGVycyBhcmUgZXhoYXVzdGVkIGFuZCBhbiBhZGRpdGlvbmFsCiAgKiBlcnJvciBvY2N1cnMgdGhlbiBhbiBlcnJvciBvdmVyZmxvdyByZWdpc3RlciByZWNvcmRzIHRoYXQgYW4KLSAqIGVycm9yIG9jY3VyZWQgYW5kIHRoZSB0eXBlIG9mIGVycm9yLCBidXQgZG9lc24ndCBoYXZlIGFueQorICogZXJyb3Igb2NjdXJyZWQgYW5kIHRoZSB0eXBlIG9mIGVycm9yLCBidXQgZG9lc24ndCBoYXZlIGFueQogICogZnVydGhlciBpbmZvcm1hdGlvbi4gIFRoZSBjZS91ZSB2ZXJzaW9ucyBtYWtlIGZvciBjbGVhbmVyCiAgKiByZXBvcnRpbmcgbG9naWMgYW5kIGZ1bmN0aW9uIGludGVyZmFjZSAtIHJlZHVjZXMgY29uZGl0aW9uYWwKICAqIHN0YXRlbWVudCBjbHV0dGVyIGFuZCBleHRyYSBmdW5jdGlvbiBhcmd1bWVudHMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvZWRhY19kZXZpY2UuYyBiL2RyaXZlcnMvZWRhYy9lZGFjX2RldmljZS5jCmluZGV4IGQ1ZTEzYzkuLmE3NDA4Y2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9lZGFjX2RldmljZS5jCisrKyBiL2RyaXZlcnMvZWRhYy9lZGFjX2RldmljZS5jCkBAIC02NzIsNyArNjcyLDcgQEAKIAkJYmxvY2stPmNvdW50ZXJzLmNlX2NvdW50Kys7CiAJfQogCi0JLyogUHJvcG9nYXRlIHRoZSBjb3VudCB1cCB0aGUgJ3RvdGFscycgdHJlZSAqLworCS8qIFByb3BhZ2F0ZSB0aGUgY291bnQgdXAgdGhlICd0b3RhbHMnIHRyZWUgKi8KIAlpbnN0YW5jZS0+Y291bnRlcnMuY2VfY291bnQrKzsKIAllZGFjX2Rldi0+Y291bnRlcnMuY2VfY291bnQrKzsKIApAQCAtNzE4LDcgKzcxOCw3IEBACiAJCWJsb2NrLT5jb3VudGVycy51ZV9jb3VudCsrOwogCX0KIAotCS8qIFByb3BvZ2F0ZSB0aGUgY291bnQgdXAgdGhlICd0b3RhbHMnIHRyZWUgKi8KKwkvKiBQcm9wYWdhdGUgdGhlIGNvdW50IHVwIHRoZSAndG90YWxzJyB0cmVlICovCiAJaW5zdGFuY2UtPmNvdW50ZXJzLnVlX2NvdW50Kys7CiAJZWRhY19kZXYtPmNvdW50ZXJzLnVlX2NvdW50Kys7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9lZGFjX2RldmljZV9zeXNmcy5jIGIvZHJpdmVycy9lZGFjL2VkYWNfZGV2aWNlX3N5c2ZzLmMKaW5kZXggNDAwZGUwNy4uODY2NDlkZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL2VkYWNfZGV2aWNlX3N5c2ZzLmMKKysrIGIvZHJpdmVycy9lZGFjL2VkYWNfZGV2aWNlX3N5c2ZzLmMKQEAgLTUzMyw3ICs1MzMsNyBAQAogCW1lbXNldCgmYmxvY2stPmtvYmosIDAsIHNpemVvZihzdHJ1Y3Qga29iamVjdCkpOwogCiAJLyogYnVtcCB0aGUgbWFpbiBrb2JqZWN0J3MgcmVmZXJlbmNlIGNvdW50IGZvciB0aGlzIGNvbnRyb2xsZXIKLQkgKiBhbmQgdGhpcyBpbnN0YW5jZSBpcyBkZXBlbmRhbnQgb24gdGhlIG1haW4KKwkgKiBhbmQgdGhpcyBpbnN0YW5jZSBpcyBkZXBlbmRlbnQgb24gdGhlIG1haW4KIAkgKi8KIAltYWluX2tvYmogPSBrb2JqZWN0X2dldCgmZWRhY19kZXYtPmtvYmopOwogCWlmICghbWFpbl9rb2JqKSB7CkBAIC02MzUsNyArNjM1LDcgQEAKIAlpbnN0YW5jZS0+Y3RsID0gZWRhY19kZXY7CiAKIAkvKiBidW1wIHRoZSBtYWluIGtvYmplY3QncyByZWZlcmVuY2UgY291bnQgZm9yIHRoaXMgY29udHJvbGxlcgotCSAqIGFuZCB0aGlzIGluc3RhbmNlIGlzIGRlcGVuZGFudCBvbiB0aGUgbWFpbgorCSAqIGFuZCB0aGlzIGluc3RhbmNlIGlzIGRlcGVuZGVudCBvbiB0aGUgbWFpbgogCSAqLwogCW1haW5fa29iaiA9IGtvYmplY3RfZ2V0KCZlZGFjX2Rldi0+a29iaik7CiAJaWYgKCFtYWluX2tvYmopIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9lZGFjX21jLmMgYi9kcml2ZXJzL2VkYWMvZWRhY19tYy5jCmluZGV4IGE0ZTlkYjIuLjFkODA1NjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9lZGFjX21jLmMKKysrIGIvZHJpdmVycy9lZGFjL2VkYWNfbWMuYwpAQCAtNzI0LDcgKzcyNCw3IEBACiAJCSAqIFNvbWUgTUMncyBjYW4gcmVtYXAgbWVtb3J5IHNvIHRoYXQgaXQgaXMgc3RpbGwgYXZhaWxhYmxlCiAJCSAqIGF0IGEgZGlmZmVyZW50IGFkZHJlc3Mgd2hlbiBQQ0kgZGV2aWNlcyBtYXAgaW50byBtZW1vcnkuCiAJCSAqIE1DJ3MgdGhhdCBjYW4ndCBkbyB0aGlzIGxvc2UgdGhlIG1lbW9yeSB3aGVyZSBQQ0kgZGV2aWNlcwotCQkgKiBhcmUgbWFwcGVkLiAgVGhpcyBtYXBwaW5nIGlzIE1DIGRlcGVuZGFudCBhbmQgc28gd2UgY2FsbAorCQkgKiBhcmUgbWFwcGVkLiAgVGhpcyBtYXBwaW5nIGlzIE1DIGRlcGVuZGVudCBhbmQgc28gd2UgY2FsbAogCQkgKiBiYWNrIGludG8gdGhlIE1DIGRyaXZlciBmb3IgaXQgdG8gbWFwIHRoZSBNQyBwYWdlIHRvCiAJCSAqIGEgcGh5c2ljYWwgKENQVSkgcGFnZSB3aGljaCBjYW4gdGhlbiBiZSBtYXBwZWQgdG8gYSB2aXJ0dWFsCiAJCSAqIHBhZ2UgLSB3aGljaCBjYW4gdGhlbiBiZSBzY3J1YmJlZC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9lZGFjX21jX3N5c2ZzLmMgYi9kcml2ZXJzL2VkYWMvZWRhY19tY19zeXNmcy5jCmluZGV4IDczMTk2ZjcuLjI2MzQzZmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9lZGFjX21jX3N5c2ZzLmMKKysrIGIvZHJpdmVycy9lZGFjL2VkYWNfbWNfc3lzZnMuYwpAQCAtODUwLDcgKzg1MCw3IEBACiAKIAkvKgogCSAqIGxvb3AgaWYgdGhlcmUgYXJlIGF0dHJpYnV0ZXMgYW5kIHVudGlsIHdlIGhpdCBhIE5VTEwgZW50cnkKLQkgKiBSZW1vdmUgZmlyc3QgYWxsIHRoZSBhdHJpYnV0ZXMKKwkgKiBSZW1vdmUgZmlyc3QgYWxsIHRoZSBhdHRyaWJ1dGVzCiAJICovCiAJd2hpbGUgKHN5c2ZzX2F0dHJpYikgewogCQlkZWJ1Z2Y0KCIlcygpIHN5c2ZzX2F0dHJpYiA9ICVwXG4iLF9fZnVuY19fLCBzeXNmc19hdHRyaWIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2VkYWNfcGNpX3N5c2ZzLmMgYi9kcml2ZXJzL2VkYWMvZWRhY19wY2lfc3lzZnMuYwppbmRleCAwMjNiMDFjLi40OTUxOThhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2VkYWMvZWRhY19wY2lfc3lzZnMuYworKysgYi9kcml2ZXJzL2VkYWMvZWRhY19wY2lfc3lzZnMuYwpAQCAtMzUyLDcgKzM1Miw3IEBACiAJCXJldHVybiAwOwogCiAJLyogRmlyc3QgdGltZSwgc28gY3JlYXRlIHRoZSBtYWluIGtvYmplY3QgYW5kIGl0cwotCSAqIGNvbnRyb2xzIGFuZCBhdHJpYnV0ZXMKKwkgKiBjb250cm9scyBhbmQgYXR0cmlidXRlcwogCSAqLwogCWVkYWNfY2xhc3MgPSBlZGFjX2dldF9zeXNmc19jbGFzcygpOwogCWlmIChlZGFjX2NsYXNzID09IE5VTEwpIHsKQEAgLTU1MSw3ICs1NTEsNyBAQAogLyoKICAqICBQQ0kgUGFyaXR5IHBvbGxpbmcKICAqCi0gKglGdWNudGlvbiB0byByZXRyaWV2ZSB0aGUgY3VycmVudCBwYXJpdHkgc3RhdHVzCisgKglGdW5jdGlvbiB0byByZXRyaWV2ZSB0aGUgY3VycmVudCBwYXJpdHkgc3RhdHVzCiAgKglhbmQgZGVjb2RlIGl0CiAgKgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvaTUwMDBfZWRhYy5jIGIvZHJpdmVycy9lZGFjL2k1MDAwX2VkYWMuYwppbmRleCBhNWNlZmFiLi44N2Y0MjdjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2VkYWMvaTUwMDBfZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9pNTAwMF9lZGFjLmMKQEAgLTEzNzIsNyArMTM3Miw3IEBACiAJICogYWN0dWFsIG51bWJlciBvZiBzbG90cy9kaW1tcyBwZXIgY2hhbm5lbCwgd2UgdGh1cyB1dGlsaXplIHRoZQogCSAqIHJlc291cmNlIGFzIHNwZWNpZmllZCBieSB0aGUgY2hpcHNldC4gVGh1cywgd2UgbWlnaHQgaGF2ZQogCSAqIGhhdmUgbW9yZSBESU1NcyBwZXIgY2hhbm5lbCB0aGFuIGFjdHVhbGx5IG9uIHRoZSBtb2JvLCBidXQgdGhpcwotCSAqIGFsbG93cyB0aGUgZHJpdmVyIHRvIHN1cHBvcnQgdXB0byB0aGUgY2hpcHNldCBtYXgsIHdpdGhvdXQKKwkgKiBhbGxvd3MgdGhlIGRyaXZlciB0byBzdXBwb3J0IHVwIHRvIHRoZSBjaGlwc2V0IG1heCwgd2l0aG91dAogCSAqIHNvbWUgZmFuY3kgbW9ibyBkZXRlcm1pbmF0aW9uLgogCSAqLwogCWk1MDAwX2dldF9kaW1tX2FuZF9jaGFubmVsX2NvdW50cyhwZGV2LCAmbnVtX2RpbW1zX3Blcl9jaGFubmVsLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2k1MTAwX2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9pNTEwMF9lZGFjLmMKaW5kZXggMDQ0OGRhMC4uYmNiZGVlYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL2k1MTAwX2VkYWMuYworKysgYi9kcml2ZXJzL2VkYWMvaTUxMDBfZWRhYy5jCkBAIC0xMSw3ICsxMSw3IEBACiAgKgogICogVGhlIGludGVsIDUxMDAgaGFzIHR3byBpbmRlcGVuZGVudCBjaGFubmVscy4gRURBQyBjb3JlIGN1cnJlbnRseQogICogY2FuIG5vdCByZWZsZWN0IHRoaXMgY29uZmlndXJhdGlvbiBzbyBpbnN0ZWFkIHRoZSBjaGlwLXNlbGVjdAotICogcm93cyBmb3IgZWFjaCByZXNwZWN0aXZlIGNoYW5uZWwgYXJlIGxheWVkIG91dCBvbmUgYWZ0ZXIgYW5vdGhlciwKKyAqIHJvd3MgZm9yIGVhY2ggcmVzcGVjdGl2ZSBjaGFubmVsIGFyZSBsYWlkIG91dCBvbmUgYWZ0ZXIgYW5vdGhlciwKICAqIHRoZSBmaXJzdCBoYWxmIGJlbG9uZ2luZyB0byBjaGFubmVsIDAsIHRoZSBzZWNvbmQgaGFsZiBiZWxvbmdpbmcKICAqIHRvIGNoYW5uZWwgMS4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2k1NDAwX2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9pNTQwMF9lZGFjLmMKaW5kZXggMzhhOWJlOS4uODBhNDY1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL2k1NDAwX2VkYWMuYworKysgYi9kcml2ZXJzL2VkYWMvaTU0MDBfZWRhYy5jCkBAIC02NDgsNyArNjQ4LDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCS8qIE1pc2NlbGFuZW91cyBlcnJvcnMgKi8KKwkvKiBNaXNjZWxsYW5lb3VzIGVycm9ycyAqLwogCWVycm51bSA9IGZpbmRfZmlyc3RfYml0KCZhbGxFcnJvcnMsIEFSUkFZX1NJWkUoZXJyb3JfbmFtZSkpOwogCiAJYnJhbmNoID0gZXh0cmFjdF9mYmRjaGFuX2luZHgoaW5mby0+ZmVycl9uZl9mYmQpOwpAQCAtMTI0MCw3ICsxMjQwLDcgQEAKIAkgKiBhY3R1YWwgbnVtYmVyIG9mIHNsb3RzL2RpbW1zIHBlciBjaGFubmVsLCB3ZSB0aHVzIHV0aWxpemUgdGhlCiAJICogcmVzb3VyY2UgYXMgc3BlY2lmaWVkIGJ5IHRoZSBjaGlwc2V0LiBUaHVzLCB3ZSBtaWdodCBoYXZlCiAJICogaGF2ZSBtb3JlIERJTU1zIHBlciBjaGFubmVsIHRoYW4gYWN0dWFsbHkgb24gdGhlIG1vYm8sIGJ1dCB0aGlzCi0JICogYWxsb3dzIHRoZSBkcml2ZXIgdG8gc3VwcG9ydCB1cHRvIHRoZSBjaGlwc2V0IG1heCwgd2l0aG91dAorCSAqIGFsbG93cyB0aGUgZHJpdmVyIHRvIHN1cHBvcnQgdXAgdG8gdGhlIGNoaXBzZXQgbWF4LCB3aXRob3V0CiAJICogc29tZSBmYW5jeSBtb2JvIGRldGVybWluYXRpb24uCiAJICovCiAJbnVtX2RpbW1zX3Blcl9jaGFubmVsID0gTUFYX0RJTU1TX1BFUl9DSEFOTkVMOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2k3MzAwX2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9pNzMwMF9lZGFjLmMKaW5kZXggNzZkMWY1Ny4uMzYzY2MxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL2k3MzAwX2VkYWMuYworKysgYi9kcml2ZXJzL2VkYWMvaTczMDBfZWRhYy5jCkBAIC0xMDY1LDcgKzEwNjUsNyBAQAogCSAqIGFjdHVhbCBudW1iZXIgb2Ygc2xvdHMvZGltbXMgcGVyIGNoYW5uZWwsIHdlIHRodXMgdXRpbGl6ZSB0aGUKIAkgKiByZXNvdXJjZSBhcyBzcGVjaWZpZWQgYnkgdGhlIGNoaXBzZXQuIFRodXMsIHdlIG1pZ2h0IGhhdmUKIAkgKiBoYXZlIG1vcmUgRElNTXMgcGVyIGNoYW5uZWwgdGhhbiBhY3R1YWxseSBvbiB0aGUgbW9ibywgYnV0IHRoaXMKLQkgKiBhbGxvd3MgdGhlIGRyaXZlciB0byBzdXBwb3J0IHVwdG8gdGhlIGNoaXBzZXQgbWF4LCB3aXRob3V0CisJICogYWxsb3dzIHRoZSBkcml2ZXIgdG8gc3VwcG9ydCB1cCB0byB0aGUgY2hpcHNldCBtYXgsIHdpdGhvdXQKIAkgKiBzb21lIGZhbmN5IG1vYm8gZGV0ZXJtaW5hdGlvbi4KIAkgKi8KIAludW1fZGltbXNfcGVyX2NoYW5uZWwgPSBNQVhfU0xPVFM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvaTdjb3JlX2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9pN2NvcmVfZWRhYy5jCmluZGV4IDgxMTU0YWIuLjQ2NWNiYzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9pN2NvcmVfZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9pN2NvcmVfZWRhYy5jCkBAIC0xNzcyLDcgKzE3NzIsNyBAQAogCS8qCiAJICogTUNFIGZpcnN0IHN0ZXA6IENvcHkgYWxsIG1jZSBlcnJvcnMgaW50byBhIHRlbXBvcmFyeSBidWZmZXIKIAkgKiBXZSB1c2UgYSBkb3VibGUgYnVmZmVyaW5nIGhlcmUsIHRvIHJlZHVjZSB0aGUgcmlzayBvZgotCSAqIGxvb3NpbmcgYW4gZXJyb3IuCisJICogbG9zaW5nIGFuIGVycm9yLgogCSAqLwogCXNtcF9ybWIoKTsKIAljb3VudCA9IChwdnQtPm1jZV9vdXQgKyBNQ0VfTE9HX0xFTiAtIHB2dC0+bWNlX2luKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2k4MjQ0M2J4Z3hfZWRhYy5jIGIvZHJpdmVycy9lZGFjL2k4MjQ0M2J4Z3hfZWRhYy5jCmluZGV4IDY3ODQwNWEuLjQzMjlkMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9pODI0NDNieGd4X2VkYWMuYworKysgYi9kcml2ZXJzL2VkYWMvaTgyNDQzYnhneF9lZGFjLmMKQEAgLTIwMyw3ICsyMDMsNyBAQAogCQlyb3dfaGlnaF9saW1pdCA9ICgodTMyKSBkcmJhciA8PCAyMyk7CiAJCS8qIGZpbmQgdGhlIERSQU0gQ2hpcCBTZWxlY3QgQmFzZSBhZGRyZXNzIGFuZCBtYXNrICovCiAJCWRlYnVnZjEoIk1DJWQ6ICVzOiAlcygpIFJvdz0lZCwgIgotCQkJIkJvdW5kcnkgQWRkcmVzcz0lIzB4LCBMYXN0ID0gJSMweFxuIiwKKwkJCSJCb3VuZGFyeSBBZGRyZXNzPSUjMHgsIExhc3QgPSAlIzB4XG4iLAogCQkJbWNpLT5tY19pZHgsIF9fRklMRV9fLCBfX2Z1bmNfXywgaW5kZXgsIHJvd19oaWdoX2xpbWl0LAogCQkJcm93X2hpZ2hfbGltaXRfbGFzdCk7CiAKQEAgLTMwNSw3ICszMDUsNyBAQAogCWk4MjQ0M2J4Z3hfaW5pdF9jc3Jvd3MobWNpLCBwZGV2LCBlZGFjX21vZGUsIG10eXBlKTsKIAogCS8qIE1hbnkgQklPU2VzIGRvbid0IGNsZWFyIGVycm9yIGZsYWdzIG9uIGJvb3QsIHNvIGRvIHRoaXMKLQkgKiBoZXJlLCBvciB3ZSBnZXQgInBoYW50b20iIGVycm9ycyBvY2N1cmluZyBhdCBtb2R1bGUtbG9hZAorCSAqIGhlcmUsIG9yIHdlIGdldCAicGhhbnRvbSIgZXJyb3JzIG9jY3VycmluZyBhdCBtb2R1bGUtbG9hZAogCSAqIHRpbWUuICovCiAJcGNpX3dyaXRlX2JpdHMzMihwZGV2LCBJODI0NDNCWEdYX0VBUCwKIAkJCShJODI0NDNCWEdYX0VBUF9PRkZTRVRfU0JFIHwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9tY2VfYW1kX2luai5jIGIvZHJpdmVycy9lZGFjL21jZV9hbWRfaW5qLmMKaW5kZXggNzMzYTdlN2EuLmE0OTg3ZTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9tY2VfYW1kX2luai5jCisrKyBiL2RyaXZlcnMvZWRhYy9tY2VfYW1kX2luai5jCkBAIC05MCw3ICs5MCw3IEBACiAKIAlpZiAodmFsdWUgPiA1KQogCQlpZiAoYm9vdF9jcHVfZGF0YS54ODYgIT0gMHgxNSB8fCB2YWx1ZSA+IDYpIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiTm9uLWV4aXN0YW50IE1DRSBiYW5rOiAlbHVcbiIsIHZhbHVlKTsKKwkJCXByaW50ayhLRVJOX0VSUiAiTm9uLWV4aXN0ZW50IE1DRSBiYW5rOiAlbHVcbiIsIHZhbHVlKTsKIAkJCXJldHVybiAtRUlOVkFMOwogCQl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9yODI2MDBfZWRhYy5jIGIvZHJpdmVycy9lZGFjL3I4MjYwMF9lZGFjLmMKaW5kZXggNmE4MjJjNi4uNjc4NTEzNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL3I4MjYwMF9lZGFjLmMKKysrIGIvZHJpdmVycy9lZGFjL3I4MjYwMF9lZGFjLmMKQEAgLTEyMCw3ICsxMjAsNyBAQAogCQkJCSAqICAgICAgICB3cml0ZSAwPU5PUAogCQkJCSAqLwogCi0jZGVmaW5lIFI4MjYwMF9EUkJBCTB4NjAJLyogKyAweDYwLi4weDYzIFNEUkFNIFJvdyBCb3VuZHJ5IEFkZHJlc3MKKyNkZWZpbmUgUjgyNjAwX0RSQkEJMHg2MAkvKiArIDB4NjAuLjB4NjMgU0RSQU0gUm93IEJvdW5kYXJ5IEFkZHJlc3MKIAkJCQkgKiAgUmVnaXN0ZXJzCiAJCQkJICoKIAkJCQkgKiA3OjAgIEFkZHJlc3MgbGluZXMgMzA6MjQgLSB1cHBlciBsaW1pdCBvZgpAQCAtMjE3LDcgKzIxNyw3IEBACiB7CiAJc3RydWN0IGNzcm93X2luZm8gKmNzcm93OwogCWludCBpbmRleDsKLQl1OCBkcmJhcjsJCS8qIFNEUkFNIFJvdyBCb3VuZHJ5IEFkZHJlc3MgUmVnaXN0ZXIgKi8KKwl1OCBkcmJhcjsJCS8qIFNEUkFNIFJvdyBCb3VuZGFyeSBBZGRyZXNzIFJlZ2lzdGVyICovCiAJdTMyIHJvd19oaWdoX2xpbWl0LCByb3dfaGlnaF9saW1pdF9sYXN0OwogCXUzMiByZWdfc2RyYW0sIGVjY19vbiwgcm93X2Jhc2U7CiAKQEAgLTIzNiw3ICsyMzYsNyBAQAogCQlyb3dfaGlnaF9saW1pdCA9ICgodTMyKSBkcmJhciA8PCAyNCk7CiAvKgkJcm93X2hpZ2hfbGltaXQgPSAoKHUzMilkcmJhciA8PCAyNCkgfCAweGZmZmZmZlVMOyAqLwogCi0JCWRlYnVnZjEoIiVzKCkgUm93PSVkLCBCb3VuZHJ5IEFkZHJlc3M9JSMweCwgTGFzdCA9ICUjMHhcbiIsCisJCWRlYnVnZjEoIiVzKCkgUm93PSVkLCBCb3VuZGFyeSBBZGRyZXNzPSUjMHgsIExhc3QgPSAlIzB4XG4iLAogCQkJX19mdW5jX18sIGluZGV4LCByb3dfaGlnaF9saW1pdCwgcm93X2hpZ2hfbGltaXRfbGFzdCk7CiAKIAkJLyogRW1wdHkgcm93IFtwLjU3XSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJld2lyZS9uZXQuYyBiL2RyaXZlcnMvZmlyZXdpcmUvbmV0LmMKaW5kZXggN2VkMDhmZC4uM2YwNGRkMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9maXJld2lyZS9uZXQuYworKysgYi9kcml2ZXJzL2ZpcmV3aXJlL25ldC5jCkBAIC00NTMsNyArNDUzLDcgQEAKIAltZW1jcHkocGQtPnBidWYgKyBmcmFnX29mZiwgZnJhZ19idWYsIGZyYWdfbGVuKTsKIAogCS8qCi0JICogTW92ZSBsaXN0IGVudHJ5IHRvIGJlZ2lubmlnIG9mIGxpc3Qgc28gdGhhdCBvbGRlc3QgcGFydGlhbAorCSAqIE1vdmUgbGlzdCBlbnRyeSB0byBiZWdpbm5pbmcgb2YgbGlzdCBzbyB0aGF0IG9sZGVzdCBwYXJ0aWFsCiAJICogZGF0YWdyYW1zIHBlcmNvbGF0ZSB0byB0aGUgZW5kIG9mIHRoZSBsaXN0CiAJICovCiAJbGlzdF9tb3ZlX3RhaWwoJnBkLT5wZF9saW5rLCAmcGVlci0+cGRfbGlzdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vbWMzMzg4MC5jIGIvZHJpdmVycy9ncGlvL21jMzM4ODAuYwppbmRleCAwMGY2ZDI0Li40ZWM3OTc1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vbWMzMzg4MC5jCisrKyBiL2RyaXZlcnMvZ3Bpby9tYzMzODgwLmMKQEAgLTQ1LDcgKzQ1LDcgQEAKICAqIFRvIHNhdmUgdGltZSB3ZSBjYWNoZSB0aGVtIGhlcmUgaW4gbWVtb3J5CiAgKi8KIHN0cnVjdCBtYzMzODgwIHsKLQlzdHJ1Y3QgbXV0ZXgJbG9jazsJLyogcHJvdGVjdCBmcm9tIHNpbXVsdGFub3VzIGFjY2Vzc2VzICovCisJc3RydWN0IG11dGV4CWxvY2s7CS8qIHByb3RlY3QgZnJvbSBzaW11bHRhbmVvdXMgYWNjZXNzZXMgKi8KIAl1OAkJcG9ydF9jb25maWc7CiAJc3RydWN0IGdwaW9fY2hpcCBjaGlwOwogCXN0cnVjdCBzcGlfZGV2aWNlICpzcGk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2NydGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jCmluZGV4IDc5OWUxNDkuLjg3Mjc0N2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jCkBAIC0xNjk5LDcgKzE2OTksNyBAQAogCiAJbXV0ZXhfbG9jaygmZGV2LT5tb2RlX2NvbmZpZy5tdXRleCk7CiAKLQkvKiBUT0RPIGNoZWNrIGJ1ZmZlciBpcyBzdWZmaWNlbnRseSBsYXJnZSAqLworCS8qIFRPRE8gY2hlY2sgYnVmZmVyIGlzIHN1ZmZpY2llbnRseSBsYXJnZSAqLwogCS8qIFRPRE8gc2V0dXAgZGVzdHJ1Y3RvciBjYWxsYmFjayAqLwogCiAJZmIgPSBkZXYtPm1vZGVfY29uZmlnLmZ1bmNzLT5mYl9jcmVhdGUoZGV2LCBmaWxlX3ByaXYsIHIpOwpAQCAtMTc1MCw3ICsxNzUwLDcgQEAKIAogCW11dGV4X2xvY2soJmRldi0+bW9kZV9jb25maWcubXV0ZXgpOwogCW9iaiA9IGRybV9tb2RlX29iamVjdF9maW5kKGRldiwgKmlkLCBEUk1fTU9ERV9PQkpFQ1RfRkIpOwotCS8qIFRPRE8gY2hlY2sgdGhhdCB3ZSByZWFseSBnZXQgYSBmcmFtZWJ1ZmZlciBiYWNrLiAqLworCS8qIFRPRE8gY2hlY2sgdGhhdCB3ZSByZWFsbHkgZ2V0IGEgZnJhbWVidWZmZXIgYmFjay4gKi8KIAlpZiAoIW9iaikgewogCQlEUk1fRVJST1IoIm1vZGUgaW52YWxpZCBmcmFtZWJ1ZmZlciBpZFxuIik7CiAJCXJldCA9IC1FSU5WQUw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX21tLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX21tLmMKaW5kZXggYWRkMTczNy4uNWQwMGIwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9tbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fbW0uYwpAQCAtNTUxLDcgKzU1MSw3IEBACiAgKiBjb3JydXB0ZWQuCiAgKgogICogV2hlbiB0aGUgc2NhbiBsaXN0IGlzIGVtcHR5LCB0aGUgc2VsZWN0ZWQgbWVtb3J5IG5vZGVzIGNhbiBiZSBmcmVlZC4gQW4KLSAqIGltbWVkaWF0bHkgZm9sbG93aW5nIGRybV9tbV9zZWFyY2hfZnJlZSB3aXRoIGJlc3RfbWF0Y2ggPSAwIHdpbGwgdGhlbiByZXR1cm4KKyAqIGltbWVkaWF0ZWx5IGZvbGxvd2luZyBkcm1fbW1fc2VhcmNoX2ZyZWUgd2l0aCBiZXN0X21hdGNoID0gMCB3aWxsIHRoZW4gcmV0dXJuCiAgKiB0aGUganVzdCBmcmVlZCBibG9jayAoYmVjYXVzZSBpdHMgYXQgdGhlIHRvcCBvZiB0aGUgZnJlZV9zdGFjayBsaXN0KS4KICAqCiAgKiBSZXR1cm5zIG9uZSBpZiB0aGlzIGJsb2NrIHNob3VsZCBiZSBldmljdGVkLCB6ZXJvIG90aGVyd2lzZS4gV2lsbCBhbHdheXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCmluZGV4IDUwMDQ3MjQuLjFjMWIyN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaApAQCAtNjMwLDcgKzYzMCw3IEBACiAJCSAqIEZsYWcgaWYgdGhlIGhhcmR3YXJlIGFwcGVhcnMgdG8gYmUgd2VkZ2VkLgogCQkgKgogCQkgKiBUaGlzIGlzIHNldCB3aGVuIGF0dGVtcHRzIHRvIGlkbGUgdGhlIGRldmljZSB0aW1lb3V0LgotCQkgKiBJdCBwcmV2ZW50cyBjb21tYW5kIHN1Ym1pc3Npb24gZnJvbSBvY2N1cmluZyBhbmQgbWFrZXMKKwkJICogSXQgcHJldmVudHMgY29tbWFuZCBzdWJtaXNzaW9uIGZyb20gb2NjdXJyaW5nIGFuZCBtYWtlcwogCQkgKiBldmVyeSBwZW5kaW5nIHJlcXVlc3QgZmFpbAogCQkgKi8KIAkJYXRvbWljX3Qgd2VkZ2VkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMKaW5kZXggMGRhZWZjYS4uY2I4NTc4YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jCkBAIC0yMTMsNyArMjEzLDcgQEAKIAkJCXJldHVybiBNT0RFX1BBTkVMOwogCX0KIAotCS8qIG9ubHkgcmVmdXNlIHRoZSBtb2RlIG9uIG5vbiBlRFAgc2luY2Ugd2UgaGF2ZSBzZWVuIHNvbWUgd2llcmQgZURQIHBhbmVscworCS8qIG9ubHkgcmVmdXNlIHRoZSBtb2RlIG9uIG5vbiBlRFAgc2luY2Ugd2UgaGF2ZSBzZWVuIHNvbWUgd2VpcmQgZURQIHBhbmVscwogCSAgIHdoaWNoIGFyZSBvdXRzaWRlIHNwZWMgdG9sZXJhbmNlcyBidXQgc29tZWhvdyB3b3JrIGJ5IG1hZ2ljICovCiAJaWYgKCFpc19lZHAoaW50ZWxfZHApICYmCiAJICAgIChpbnRlbF9kcF9saW5rX3JlcXVpcmVkKGNvbm5lY3Rvci0+ZGV2LCBpbnRlbF9kcCwgbW9kZS0+Y2xvY2spCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zZHZvX3JlZ3MuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm9fcmVncy5oCmluZGV4IGEzODZiMDIuLjRmNGUyM2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm9fcmVncy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm9fcmVncy5oCkBAIC0yMzAsNyArMjMwLDcgQEAKIH0gX19hdHRyaWJ1dGVfXygocGFja2VkKSk7CiAKIC8qKgotICogVGFrZXMgYSBzdHJ1Y3QgaW50ZWxfc2R2b19vdXRwdXRfZmxhZ3Mgb2Ygd2hpY2ggb3V0cHV0cyBhcmUgdGFyZ2V0dGVkIGJ5CisgKiBUYWtlcyBhIHN0cnVjdCBpbnRlbF9zZHZvX291dHB1dF9mbGFncyBvZiB3aGljaCBvdXRwdXRzIGFyZSB0YXJnZXRlZCBieQogICogZnV0dXJlIG91dHB1dCBjb21tYW5kcy4KICAqCiAgKiBBZmZlY3RlZCBjb21tYW5kcyBpbmNsdWUgU0VUX09VVFBVVF9USU1JTkdTX1BBUlRbMTJdLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21nYS9tZ2FfZG1hLmMgYi9kcml2ZXJzL2dwdS9kcm0vbWdhL21nYV9kbWEuYwppbmRleCAxZTFlYjFkLi41Y2NiNjVkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21nYS9tZ2FfZG1hLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21nYS9tZ2FfZG1hLmMKQEAgLTQyNiw3ICs0MjYsNyBAQAogICogQm9vdHN0cmFwIHRoZSBkcml2ZXIgZm9yIEFHUCBETUEuCiAgKgogICogXHRvZG8KLSAqIEludmVzdGlnYXRlIHdoZXRoZXIgdGhlcmUgaXMgYW55IGJlbmlmaXQgdG8gc3RvcmluZyB0aGUgV0FSUCBtaWNyb2NvZGUgaW4KKyAqIEludmVzdGlnYXRlIHdoZXRoZXIgdGhlcmUgaXMgYW55IGJlbmVmaXQgdG8gc3RvcmluZyB0aGUgV0FSUCBtaWNyb2NvZGUgaW4KICAqIEFHUCBtZW1vcnkuICBJZiBub3QsIHRoZSBtaWNyb2NvZGUgbWF5IGFzIHdlbGwgYWx3YXlzIGJlIHB1dCBpbiBQQ0kKICAqIG1lbW9yeS4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2NoYW5uZWwuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfY2hhbm5lbC5jCmluZGV4IDM4MzcwOTAuLjRjZWEzNWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfY2hhbm5lbC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfY2hhbm5lbC5jCkBAIC0yMDAsNyArMjAwLDcgQEAKIAkvKiBkaXNhYmxlIHRoZSBmaWZvIGNhY2hlcyAqLwogCXBmaWZvLT5yZWFzc2lnbihkZXYsIGZhbHNlKTsKIAotCS8qIENvbnN0cnVjdCBpbml0YWwgUkFNRkMgZm9yIG5ldyBjaGFubmVsICovCisJLyogQ29uc3RydWN0IGluaXRpYWwgUkFNRkMgZm9yIG5ldyBjaGFubmVsICovCiAJcmV0ID0gcGZpZm8tPmNyZWF0ZV9jb250ZXh0KGNoYW4pOwogCWlmIChyZXQpIHsKIAkJbm91dmVhdV9jaGFubmVsX3B1dCgmY2hhbik7CkBAIC0yNzgsNyArMjc4LDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCS8qIG5vb25lIHdhbnRzIHRoZSBjaGFubmVsIGFueW1vcmUgKi8KKwkvKiBubyBvbmUgd2FudHMgdGhlIGNoYW5uZWwgYW55bW9yZSAqLwogCU5WX0RFQlVHKGRldiwgImZyZWVpbmcgY2hhbm5lbCAlZFxuIiwgY2hhbi0+aWQpOwogCW5vdXZlYXVfZGVidWdmc19jaGFubmVsX2ZpbmkoY2hhbik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Rydi5oCmluZGV4IGZmZjE4MGEuLjU3ZTUzMDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9kcnYuaApAQCAtMjE2LDcgKzIxNiw3IEBACiAJLyogbWFwcGluZyBvZiB0aGUgZmlmbyBpdHNlbGYgKi8KIAlzdHJ1Y3QgZHJtX2xvY2FsX21hcCAqbWFwOwogCi0JLyogbWFwcGluZyBvZiB0aGUgcmVncyBjb250cm9saW5nIHRoZSBmaWZvICovCisJLyogbWFwcGluZyBvZiB0aGUgcmVncyBjb250cm9sbGluZyB0aGUgZmlmbyAqLwogCXZvaWQgX19pb21lbSAqdXNlcjsKIAl1aW50MzJfdCB1c2VyX2dldDsKIAl1aW50MzJfdCB1c2VyX3B1dDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfc3RhdGUuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfc3RhdGUuYwppbmRleCA0ZmNiZDA5Li41YmIyODU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X3N0YXRlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9zdGF0ZS5jCkBAIC05NjMsNyArOTYzLDcgQEAKIAlpZiAocmV0KQogCQlnb3RvIGVycl9tbWlvOwogCi0JLyogTWFwIFBSQU1JTiBCQVIsIG9yIG9uIG9sZGVyIGNhcmRzLCB0aGUgYXBlcnR1cmUgd2l0aGluZyBCQVIwICovCisJLyogTWFwIFBSQU1JTiBCQVIsIG9yIG9uIG9sZGVyIGNhcmRzLCB0aGUgYXBlcnR1cmUgd2l0aGluIEJBUjAgKi8KIAlpZiAoZGV2X3ByaXYtPmNhcmRfdHlwZSA+PSBOVl80MCkgewogCQlpbnQgcmFtaW5fYmFyID0gMjsKIAkJaWYgKHBjaV9yZXNvdXJjZV9sZW4oZGV2LT5wZGV2LCByYW1pbl9iYXIpID09IDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjA0X2NydGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252MDRfY3J0Yy5jCmluZGV4IGEyNjBmYmIuLjc0OGI5ZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252MDRfY3J0Yy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252MDRfY3J0Yy5jCkBAIC0xNjQsNyArMTY0LDcgQEAKIAlOVl9ERUJVR19LTVMoZGV2LCAiU2V0dGluZyBkcG1zIG1vZGUgJWQgb24gQ1JUQyAlZFxuIiwgbW9kZSwKIAkJCQkJCQludl9jcnRjLT5pbmRleCk7CiAKLQlpZiAobnZfY3J0Yy0+bGFzdF9kcG1zID09IG1vZGUpIC8qIERvbid0IGRvIHVubmVjZXNhcnkgbW9kZSBjaGFuZ2VzLiAqLworCWlmIChudl9jcnRjLT5sYXN0X2RwbXMgPT0gbW9kZSkgLyogRG9uJ3QgZG8gdW5uZWNlc3NhcnkgbW9kZSBjaGFuZ2VzLiAqLwogCQlyZXR1cm47CiAKIAludl9jcnRjLT5sYXN0X2RwbXMgPSBtb2RlOwpAQCAtNjc3LDcgKzY3Nyw3IEBACiAKIAlOVkJsYW5rU2NyZWVuKGRldiwgbnZfY3J0Yy0+aW5kZXgsIHRydWUpOwogCi0JLyogU29tZSBtb3JlIHByZXBlcmF0aW9uLiAqLworCS8qIFNvbWUgbW9yZSBwcmVwYXJhdGlvbi4gKi8KIAlOVldyaXRlQ1JUQyhkZXYsIG52X2NydGMtPmluZGV4LCBOVl9QQ1JUQ19DT05GSUcsIE5WX1BDUlRDX0NPTkZJR19TVEFSVF9BRERSRVNTX05PTl9WR0EpOwogCWlmIChkZXZfcHJpdi0+Y2FyZF90eXBlID09IE5WXzQwKSB7CiAJCXVpbnQzMl90IHJlZzkwMCA9IE5WUmVhZFJBTURBQyhkZXYsIG52X2NydGMtPmluZGV4LCBOVl9QUkFNREFDXzkwMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX2dyYXBoLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX2dyYXBoLmMKaW5kZXggMThkMzBjMi4uZmNlYjQ0YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY0MF9ncmFwaC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NDBfZ3JhcGguYwpAQCAtMTgxLDcgKzE4MSw3IEBACiAJCSAgTlY0MF9QR1JBUEhfQ1RYQ1RMX0NVUl9MT0FERUQpOwogCS8qIDB4MzJFMCByZWNvcmRzIHRoZSBpbnN0YW5jZSBhZGRyZXNzIG9mIHRoZSBhY3RpdmUgRklGTydzIFBHUkFQSAogCSAqIGNvbnRleHQuICBJZiBhdCBhbnkgdGltZSB0aGlzIGRvZXNuJ3QgbWF0Y2ggMHg0MDAzMkMsIHlvdSB3aWxsCi0JICogcmVjaWV2ZSBQR1JBUEhfSU5UUl9DT05URVhUX1NXSVRDSAorCSAqIHJlY2VpdmUgUEdSQVBIX0lOVFJfQ09OVEVYVF9TV0lUQ0gKIAkgKi8KIAludl93cjMyKGRldiwgTlY0MF9QRklGT19HUkNUWF9JTlNUQU5DRSwgaW5zdCk7CiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2F0b21iaW9zLmggYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2F0b21iaW9zLmgKaW5kZXggMDRiMjY5ZC4uN2ZkODg0OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9hdG9tYmlvcy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vYXRvbWJpb3MuaApAQCAtNzM4LDEzICs3MzgsMTMgQEAKIHsKICNpZiBBVE9NX0JJR19FTkRJQU4KICAgICBVQ0hBUiB1Y1Jlc2VydmVkMToxOwotICAgIFVDSEFSIHVjRGlnU2VsOjM7ICAgICAgICAgICAgIC8vID0wLzEvMi8zLzQvNTogRElHMC8xLzIvMy80LzUgKEluIHJlZ2lzdGVyIHNwZWMgYWxzbyByZWZlcmVkIGFzIERJR0EvQi9DL0QvRS9GKQorICAgIFVDSEFSIHVjRGlnU2VsOjM7ICAgICAgICAgICAgIC8vID0wLzEvMi8zLzQvNTogRElHMC8xLzIvMy80LzUgKEluIHJlZ2lzdGVyIHNwZWMgYWxzbyByZWZlcnJlZCBhcyBESUdBL0IvQy9EL0UvRikKICAgICBVQ0hBUiB1Y1Jlc2VydmVkOjM7CiAgICAgVUNIQVIgdWNEUExpbmtSYXRlOjE7ICAgICAgICAgLy8gPTA6IDEuNjJHaHosID0xOiAyLjdHaHoKICNlbHNlCiAgICAgVUNIQVIgdWNEUExpbmtSYXRlOjE7ICAgICAgICAgLy8gPTA6IDEuNjJHaHosID0xOiAyLjdHaHoKICAgICBVQ0hBUiB1Y1Jlc2VydmVkOjM7Ci0gICAgVUNIQVIgdWNEaWdTZWw6MzsgICAgICAgICAgICAgLy8gPTAvMS8yLzMvNC81OiBESUcwLzEvMi8zLzQvNSAoSW4gcmVnaXN0ZXIgc3BlYyBhbHNvIHJlZmVyZWQgYXMgRElHQS9CL0MvRC9FL0YpCisgICAgVUNIQVIgdWNEaWdTZWw6MzsgICAgICAgICAgICAgLy8gPTAvMS8yLzMvNC81OiBESUcwLzEvMi8zLzQvNSAoSW4gcmVnaXN0ZXIgc3BlYyBhbHNvIHJlZmVycmVkIGFzIERJR0EvQi9DL0QvRS9GKQogICAgIFVDSEFSIHVjUmVzZXJ2ZWQxOjE7CiAjZW5kaWYKIH1BVE9NX0RJR19FTkNPREVSX0NPTkZJR19WMzsKQEAgLTc4NSwxMyArNzg1LDEzIEBACiB7CiAjaWYgQVRPTV9CSUdfRU5ESUFOCiAgICAgVUNIQVIgdWNSZXNlcnZlZDE6MTsKLSAgICBVQ0hBUiB1Y0RpZ1NlbDozOyAgICAgICAgICAgICAvLyA9MC8xLzIvMy80LzU6IERJRzAvMS8yLzMvNC81IChJbiByZWdpc3RlciBzcGVjIGFsc28gcmVmZXJlZCBhcyBESUdBL0IvQy9EL0UvRikKKyAgICBVQ0hBUiB1Y0RpZ1NlbDozOyAgICAgICAgICAgICAvLyA9MC8xLzIvMy80LzU6IERJRzAvMS8yLzMvNC81IChJbiByZWdpc3RlciBzcGVjIGFsc28gcmVmZXJyZWQgYXMgRElHQS9CL0MvRC9FL0YpCiAgICAgVUNIQVIgdWNSZXNlcnZlZDoyOwogICAgIFVDSEFSIHVjRFBMaW5rUmF0ZToyOyAgICAgICAgIC8vID0wOiAxLjYyR2h6LCA9MTogMi43R2h6LCAyPTUuNEdoeiAgICA8PSBDaGFuZ2VkIGNvbXBhcmluZyB0byBwcmV2aW91cyB2ZXJzaW9uCiAjZWxzZQogICAgIFVDSEFSIHVjRFBMaW5rUmF0ZToyOyAgICAgICAgIC8vID0wOiAxLjYyR2h6LCA9MTogMi43R2h6LCAyPTUuNEdoeiAgICA8PSBDaGFuZ2VkIGNvbXBhcmluZyB0byBwcmV2aW91cyB2ZXJzaW9uCiAgICAgVUNIQVIgdWNSZXNlcnZlZDoyOwotICAgIFVDSEFSIHVjRGlnU2VsOjM7ICAgICAgICAgICAgIC8vID0wLzEvMi8zLzQvNTogRElHMC8xLzIvMy80LzUgKEluIHJlZ2lzdGVyIHNwZWMgYWxzbyByZWZlcmVkIGFzIERJR0EvQi9DL0QvRS9GKQorICAgIFVDSEFSIHVjRGlnU2VsOjM7ICAgICAgICAgICAgIC8vID0wLzEvMi8zLzQvNTogRElHMC8xLzIvMy80LzUgKEluIHJlZ2lzdGVyIHNwZWMgYWxzbyByZWZlcnJlZCBhcyBESUdBL0IvQy9EL0UvRikKICAgICBVQ0hBUiB1Y1Jlc2VydmVkMToxOwogI2VuZGlmCiB9QVRPTV9ESUdfRU5DT0RFUl9DT05GSUdfVjQ7CkBAIC0yMTI2LDcgKzIxMjYsNyBAQAogLy8gU3RydWN0dXJlcyB1c2VkIGluIEZpcm13YXJlSW5mb1RhYmxlCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8JCiAKLS8vIHVzQklPU0NhcGFiaWxpdHkgRGVmaW50aW9uOgorLy8gdXNCSU9TQ2FwYWJpbGl0eSBEZWZpbml0aW9uOgogLy8gQml0IDAgPSAwOiBCaW9zIGltYWdlIGlzIG5vdCBQb3N0ZWQsID0xOkJpb3MgaW1hZ2UgaXMgUG9zdGVkOyAKIC8vIEJpdCAxID0gMDogRHVhbCBDUlRDIGlzIG5vdCBzdXBwb3J0ZWQsID0xOiBEdWFsIENSVEMgaXMgc3VwcG9ydGVkOyAKIC8vIEJpdCAyID0gMDogRXh0ZW5kZWQgRGVza3RvcCBpcyBub3Qgc3VwcG9ydGVkLCA9MTogRXh0ZW5kZWQgRGVza3RvcCBpcyBzdXBwb3J0ZWQ7IApAQCAtMzM0MSw3ICszMzQxLDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwkKIC8vIFN0cnVjdHVyZSB1c2VkIGluIEFuYWxvZ1RWX0luZm9UYWJsZSAoVG9wIGxldmVsKQogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCQotLy91Y1RWQm9vdFVwRGVmYXVsdFN0ZCBkZWZpbml0b246CisvL3VjVFZCb290VXBEZWZhdWx0U3RkIGRlZmluaXRpb246CiAKIC8vQVRPTV9UVl9OVFNDICAgICAgICAgICAgICAgIDEKIC8vQVRPTV9UVl9OVFNDSiAgICAgICAgICAgICAgIDIKQEAgLTM4MTYsNyArMzgxNiw3IEBACiAgIFVDSEFSICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZCBbNl07ICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBmb3IgcG90ZW50aWFsIGV4cGFuc2lvbgogfUFUT01fRVhURVJOQUxfRElTUExBWV9DT05ORUNUSU9OX0lORk87CiAKLS8vUmVsYXRlZCBkZWZpbml0aW9ucywgYWxsIHJlY29yZHMgYXJlIGRpZmZlcm50IGJ1dCB0aGV5IGhhdmUgYSBjb21tb25kIGhlYWRlcgorLy9SZWxhdGVkIGRlZmluaXRpb25zLCBhbGwgcmVjb3JkcyBhcmUgZGlmZmVyZW50IGJ1dCB0aGV5IGhhdmUgYSBjb21tb25kIGhlYWRlcgogdHlwZWRlZiBzdHJ1Y3QgX0FUT01fQ09NTU9OX1JFQ09SRF9IRUFERVIKIHsKICAgVUNIQVIgICAgICAgICAgICAgICB1Y1JlY29yZFR5cGU7ICAgICAgICAgICAgICAgICAgICAgIC8vQW4gZW11biB0byBpbmRpY2F0ZSB0aGUgcmVjb3JkIHR5cGUKQEAgLTQzNjUsMTQgKzQzNjUsMTQgQEAKIHVsQ1NSX00zX0FSQl9DTlRMX0RFRkFVTFRbMTBdOiAgICBBcnJheXMgd2l0aCB2YWx1ZXMgZm9yIENTUiBNMyBhcmJpdGVyIGZvciBkZWZhdWx0CiB1bENTUl9NM19BUkJfQ05UTF9VVkRbMTBdOiAgICAgICAgQXJyYXlzIHdpdGggdmFsdWVzIGZvciBDU1IgTTMgYXJiaXRlciBmb3IgVVZEIHBsYXliYWNrLgogdWxDU1JfTTNfQVJCX0NOVExfRlMzRFsxMF06ICAgICAgIEFycmF5cyB3aXRoIHZhbHVlcyBmb3IgQ1NSIE0zIGFyYml0ZXIgZm9yIEZ1bGwgU2NyZWVuIDNEIGFwcGxpY2F0aW9ucy4KLXNBdmFpbF9TQ0xLWzVdOiAgICAgICAgICAgICAgICAgICBBcnJheXMgdG8gcHJvdmlkZSBhdmFpbGFiZSBsaXN0IG9mIFNMQ0sgYW5kIGNvcnJlc3BvbmRpbmcgdm9sdGFnZSwgb3JkZXIgZnJvbSBsb3cgdG8gaGlnaCAgCitzQXZhaWxfU0NMS1s1XTogICAgICAgICAgICAgICAgICAgQXJyYXlzIHRvIHByb3ZpZGUgYXZhaWxhYmxlIGxpc3Qgb2YgU0xDSyBhbmQgY29ycmVzcG9uZGluZyB2b2x0YWdlLCBvcmRlciBmcm9tIGxvdyB0byBoaWdoICAKIHVsR01DUmVzdG9yZVJlc2V0VGltZTogICAgICAgICAgICBHTUMgcG93ZXIgcmVzdG9yZSBhbmQgR01DIHJlc2V0IHRpbWUgdG8gY2FsY3VsYXRlIGRhdGEgcmVjb25uZWN0aW9uIGxhdGVuY3kuIFVuaXQgaW4gbnMuIAogdWxNaW5pbXVtTkNsazogICAgICAgICAgICAgICAgICAgIE1pbmltdW0gTkNMSyBzcGVlZCBhbW9uZyBhbGwgTkItUHN0YXRlcyB0byBjYWxjdWFsdGUgZGF0YSByZWNvbm5lY3Rpb24gbGF0ZW5jeS4gVW5pdCBpbiAxMGtIei4gCiB1bElkbGVOQ2xrOiAgICAgICAgICAgICAgICAgICAgICAgTkNMSyBzcGVlZCB3aGlsZSBtZW1vcnkgcnVucyBpbiBzZWxmLXJlZnJlc2ggc3RhdGUuIFVuaXQgaW4gMTBrSHouCiB1bEREUl9ETExfUG93ZXJVcFRpbWU6ICAgICAgICAgICAgRERSIFBIWSBETEwgcG93ZXIgdXAgdGltZS4gVW5pdCBpbiBucy4KIHVsRERSX1BMTF9Qb3dlclVwVGltZTogICAgICAgICAgICBERFIgUEhZIFBMTCBwb3dlciB1cCB0aW1lLiBVbml0IGluIG5zLgotdXNQQ0lFQ2xrU1NQZXJjZW50YWdlOiAgICAgICAgICAgIFBDSUUgQ2xvY2sgU3ByZWQgU3BlY3RydW0gUGVyY2VudGFnZSBpbiB1bml0IDAuMDElOyAxMDAgbWVhbiAxJS4KLXVzUENJRUNsa1NTVHlwZTogICAgICAgICAgICAgICAgICBQQ0lFIENsb2NrIFNwcmVkIFNwZWN0cnVtIFR5cGUuIDAgZm9yIERvd24gc3ByZWFkKGRlZmF1bHQpOyAxIGZvciBDZW50ZXIgc3ByZWFkLgordXNQQ0lFQ2xrU1NQZXJjZW50YWdlOiAgICAgICAgICAgIFBDSUUgQ2xvY2sgU3ByZWFkIFNwZWN0cnVtIFBlcmNlbnRhZ2UgaW4gdW5pdCAwLjAxJTsgMTAwIG1lYW4gMSUuCit1c1BDSUVDbGtTU1R5cGU6ICAgICAgICAgICAgICAgICAgUENJRSBDbG9jayBTcHJlYWQgU3BlY3RydW0gVHlwZS4gMCBmb3IgRG93biBzcHJlYWQoZGVmYXVsdCk7IDEgZm9yIENlbnRlciBzcHJlYWQuCiB1c0x2ZHNTU1BlcmNlbnRhZ2U6ICAgICAgICAgICAgICAgTFZEUyBwYW5lbCAoIG5vdCBpbmNsdWRlIGVEUCApIFNwcmVhZCBTcGVjdHJ1bSBQZXJjZW50YWdlIGluIHVuaXQgb2YgMC4wMSUsID0wLCB1c2UgVkJJT1MgZGVmYXVsdCBzZXR0aW5nLiAKIHVzTHZkc1NTcHJlYWRSYXRlSW4xMEh6OiAgICAgICAgICBMVkRTIHBhbmVsICggbm90IGluY2x1ZGUgZURQICkgU3ByZWFkIFNwZWN0cnVtIGZyZXF1ZW5jeSBpbiB1bml0IG9mIDEwSHosID0wLCB1c2UgVkJJT1MgZGVmYXVsdCBzZXR0aW5nLiAKIHVzSERNSVNTUGVyY2VudGFnZTogICAgICAgICAgICAgICBIRE1JIFNwcmVhZCBTcGVjdHJ1bSBQZXJjZW50YWdlIGluIHVuaXQgMC4wMSU7IDEwMCBtZWFuIDElLCAgPTAsIHVzZSBWQklPUyBkZWZhdWx0IHNldHRpbmcuIApAQCAtNDU1NSw3ICs0NTU1LDcgQEAKICNkZWZpbmUgQVRPTV9TMF9TWVNURU1fUE9XRVJfU1RBVEVfVkFMVUVfTElURUFDIDMKICNkZWZpbmUgQVRPTV9TMF9TWVNURU1fUE9XRVJfU1RBVEVfVkFMVUVfTElUMkFDIDQKIAotLy9CeXRlIGFsaWduZWQgZGVmaW50aW9uIGZvciBCSU9TIHVzYWdlCisvL0J5dGUgYWxpZ25lZCBkZWZpbml0aW9uIGZvciBCSU9TIHVzYWdlCiAjZGVmaW5lIEFUT01fUzBfQ1JUMV9NT05PYjAgICAgICAgICAgICAgMHgwMQogI2RlZmluZSBBVE9NX1MwX0NSVDFfQ09MT1JiMCAgICAgICAgICAgIDB4MDIKICNkZWZpbmUgQVRPTV9TMF9DUlQxX01BU0tiMCAgICAgICAgICAgICAoQVRPTV9TMF9DUlQxX01PTk9iMCtBVE9NX1MwX0NSVDFfQ09MT1JiMCkKQEAgLTQ2MjEsNyArNDYyMSw3IEBACiAjZGVmaW5lIEFUT01fUzJfRElTUExBWV9ST1RBVElPTl9BTkdMRV9NQVNLICAgMHhDMDAwMDAwMEwKIAogCi0vL0J5dGUgYWxpZ25lZCBkZWZpbnRpb24gZm9yIEJJT1MgdXNhZ2UKKy8vQnl0ZSBhbGlnbmVkIGRlZmluaXRpb24gZm9yIEJJT1MgdXNhZ2UKICNkZWZpbmUgQVRPTV9TMl9UVjFfU1RBTkRBUkRfTUFTS2IwICAgICAweDBGCiAjZGVmaW5lIEFUT01fUzJfQ1VSUkVOVF9CTF9MRVZFTF9NQVNLYjEgMHhGRgogI2RlZmluZSBBVE9NX1MyX0RFVklDRV9EUE1TX1NUQVRFYjIgICAgIDB4MDEKQEAgLTQ2NzEsNyArNDY3MSw3IEBACiAjZGVmaW5lIEFUT01fUzNfQUxMT1dfRkFTVF9QV1JfU1dJVENIICAgMHg0MDAwMDAwMEwKICNkZWZpbmUgQVRPTV9TM19SUVNUX0dQVV9VU0VfTUlOX1BXUiAgICAweDgwMDAwMDAwTAogCi0vL0J5dGUgYWxpZ25lZCBkZWZpbnRpb24gZm9yIEJJT1MgdXNhZ2UKKy8vQnl0ZSBhbGlnbmVkIGRlZmluaXRpb24gZm9yIEJJT1MgdXNhZ2UKICNkZWZpbmUgQVRPTV9TM19DUlQxX0FDVElWRWIwICAgICAgICAgICAweDAxCiAjZGVmaW5lIEFUT01fUzNfTENEMV9BQ1RJVkViMCAgICAgICAgICAgMHgwMgogI2RlZmluZSBBVE9NX1MzX1RWMV9BQ1RJVkViMCAgICAgICAgICAgIDB4MDQKQEAgLTQ3MDcsNyArNDcwNyw3IEBACiAjZGVmaW5lIEFUT01fUzRfTENEMV9SRUZSRVNIX01BU0sgICAgICAgMHgwMDAwRkYwMEwKICNkZWZpbmUgQVRPTV9TNF9MQ0QxX1JFRlJFU0hfU0hJRlQgICAgICA4CiAKLS8vQnl0ZSBhbGlnbmVkIGRlZmludGlvbiBmb3IgQklPUyB1c2FnZQorLy9CeXRlIGFsaWduZWQgZGVmaW5pdGlvbiBmb3IgQklPUyB1c2FnZQogI2RlZmluZSBBVE9NX1M0X0xDRDFfUEFORUxfSURfTUFTS2IwCSAgMHgwRkYKICNkZWZpbmUgQVRPTV9TNF9MQ0QxX1JFRlJFU0hfTUFTS2IxCQkgIEFUT01fUzRfTENEMV9QQU5FTF9JRF9NQVNLYjAKICNkZWZpbmUgQVRPTV9TNF9WUkFNX0lORk9fTUFTS2IyICAgICAgICBBVE9NX1M0X0xDRDFfUEFORUxfSURfTUFTS2IwCkBAIC00Nzg2LDcgKzQ3ODYsNyBAQAogI2RlZmluZSBBVE9NX1M2X1ZSSV9CUklHSFRORVNTX0NIQU5HRSAgICAgICAweDQwMDAwMDAwTAogI2RlZmluZSBBVE9NX1M2X0NPTkZJR19ESVNQTEFZX0NIQU5HRV9NQVNLICAweDgwMDAwMDAwTAogCi0vL0J5dGUgYWxpZ25lZCBkZWZpbnRpb24gZm9yIEJJT1MgdXNhZ2UKKy8vQnl0ZSBhbGlnbmVkIGRlZmluaXRpb24gZm9yIEJJT1MgdXNhZ2UKICNkZWZpbmUgQVRPTV9TNl9ERVZJQ0VfQ0hBTkdFYjAgICAgICAgICAweDAxCiAjZGVmaW5lIEFUT01fUzZfU0NBTEVSX0NIQU5HRWIwICAgICAgICAgMHgwMgogI2RlZmluZSBBVE9NX1M2X0xJRF9DSEFOR0ViMCAgICAgICAgICAgIDB4MDQKQEAgLTUwMjcsNyArNTAyNyw3IEBACiAKIHR5cGVkZWYgc3RydWN0IF9NRU1PUllfQ0xFQU5fVVBfUEFSQU1FVEVSUwogewotICBVU0hPUlQgIHVzTWVtb3J5U3RhcnQ7ICAgICAgICAgICAgICAgIC8vaW4gOEtiIGJvdW5kcnksIG9mZnNldCBmcm9tIG1lbW9yeSBiYXNlIGFkZHJlc3MKKyAgVVNIT1JUICB1c01lbW9yeVN0YXJ0OyAgICAgICAgICAgICAgICAvL2luIDhLYiBib3VuZGFyeSwgb2Zmc2V0IGZyb20gbWVtb3J5IGJhc2UgYWRkcmVzcwogICBVU0hPUlQgIHVzTWVtb3J5U2l6ZTsgICAgICAgICAgICAgICAgIC8vOEtiIGJsb2NrcyBhbGlnbmVkCiB9TUVNT1JZX0NMRUFOX1VQX1BBUkFNRVRFUlM7CiAjZGVmaW5lIE1FTU9SWV9DTEVBTl9VUF9QU19BTExPQ0FUSU9OIE1FTU9SWV9DTEVBTl9VUF9QQVJBTUVURVJTCkBAIC02ODU1LDcgKzY4NTUsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAKLS8vIEZvbGxvd2luZyBkZWZpbml0aW9ucyBhcmUgZm9yIGNvbXBhdGlibGl0eSBpc3N1ZSBpbiBkaWZmZXJlbnQgU1cgY29tcG9uZW50cy4gCisvLyBGb2xsb3dpbmcgZGVmaW5pdGlvbnMgYXJlIGZvciBjb21wYXRpYmlsaXR5IGlzc3VlIGluIGRpZmZlcmVudCBTVyBjb21wb25lbnRzLiAKICNkZWZpbmUgQVRPTV9NQVNURVJfREFUQV9UQUJMRV9SRVZJU0lPTiAgIDB4MDEKICNkZWZpbmUgT2JqZWN0X0luZm8JCQkJCQkJCQkJCQlPYmplY3RfSGVhZGVyCQkJCiAjZGVmaW5lCUFkanVzdEFSQl9TRVEJCQkJCQkJCQkJCU1DX0luaXRQYXJhbWV0ZXIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdyZWVuX2NzLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbl9jcy5jCmluZGV4IGVkZGU5MGIuLjIzZDM2NDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdyZWVuX2NzLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW5fY3MuYwpAQCAtNDQyLDcgKzQ0Miw3IEBACiAJfQogCWliID0gcC0+aWItPnB0cjsKIAlzd2l0Y2ggKHJlZykgewotCS8qIGZvcmNlIGZvbGxvd2luZyByZWcgdG8gMCBpbiBhbiBhdHRlbXAgdG8gZGlzYWJsZSBvdXQgYnVmZmVyCisJLyogZm9yY2UgZm9sbG93aW5nIHJlZyB0byAwIGluIGFuIGF0dGVtcHQgdG8gZGlzYWJsZSBvdXQgYnVmZmVyCiAJICogd2hpY2ggd2lsbCBuZWVkIHVzIHRvIGJldHRlciB1bmRlcnN0YW5kIGhvdyBpdCB3b3JrcyB0byBwZXJmb3JtCiAJICogc2VjdXJpdHkgY2hlY2sgb24gaXQgKEplcm9tZSkKIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjMwMC5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMzAwLmMKaW5kZXggODcxMzczMS4uNTVhN2YxOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMzAwLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMzAwLmMKQEAgLTQzNyw3ICs0MzcsNyBAQAogCXN0YXR1cyA9IFJSRUczMihSXzAwMEU0MF9SQkJNX1NUQVRVUyk7CiAJZGV2X2luZm8ocmRldi0+ZGV2LCAiKCVzOiVkKSBSQkJNX1NUQVRVUz0weCUwOFhcbiIsIF9fZnVuY19fLCBfX0xJTkVfXywgc3RhdHVzKTsKIAkvKiByZXNldHRpbmcgdGhlIENQIHNlZW1zIHRvIGJlIHByb2JsZW1hdGljIHNvbWV0aW1lcyBpdCBlbmQgdXAKLQkgKiBoYXJkIGxvY2tpbmcgdGhlIGNvbXB1dGVyLCBidXQgaXQncyBuZWNlc3NhcnkgZm9yIHN1Y2Nlc3NmdWxsCisJICogaGFyZCBsb2NraW5nIHRoZSBjb21wdXRlciwgYnV0IGl0J3MgbmVjZXNzYXJ5IGZvciBzdWNjZXNzZnVsCiAJICogcmVzZXQgbW9yZSB0ZXN0ICYgcGxheWluZyBpcyBuZWVkZWQgb24gUjNYWC9SNFhYIHRvIGZpbmQgYQogCSAqIHJlbGlhYmxlIChpZiBhbnkgc29sdXRpb24pCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IzMDBfcmVnLmggYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IzMDBfcmVnLmgKaW5kZXggZjBiY2UzOS4uMDBjMGQyYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMzAwX3JlZy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjMwMF9yZWcuaApAQCAtNjA4LDcgKzYwOCw3IEBACiAgKiBNeSBndWVzcyBpcyB0aGF0IHRoZXJlIGFyZSB0d28gYml0cyBmb3IgZWFjaCB6YmlhcyBwcmltaXRpdmUKICAqIChGSUxMLCBMSU5FLCBQT0lOVCkuCiAgKiAgT25lIHRvIGVuYWJsZSBkZXB0aCB0ZXN0IGFuZCBvbmUgZm9yIGRlcHRoIHdyaXRlLgotICogWWV0IHRoaXMgZG9lc250IGV4cGxhaW4gd2h5IGRlcHRoIHdyaXRlcyB3b3JrIC4uLgorICogWWV0IHRoaXMgZG9lc24ndCBleHBsYWluIHdoeSBkZXB0aCB3cml0ZXMgd29yayAuLi4KICAqLwogI2RlZmluZSBSMzAwX1JFX09DQ0xVU0lPTl9DTlRMCQkgICAgMHg0MkI0CiAjCWRlZmluZSBSMzAwX09DQ0xVU0lPTl9PTgkJKDE8PDEpCkBAIC04MTcsNyArODE3LDcgQEAKICMJZGVmaW5lIFIzMDBfVFhfTUlOX0ZJTFRFUl9MSU5FQVJfTUlQX05FQVJFU1QgICAgICAgICg2ICA8PCAgMTEpCiAjCWRlZmluZSBSMzAwX1RYX01JTl9GSUxURVJfTElORUFSX01JUF9MSU5FQVIgICAgICAgICAoMTAgPDwgIDExKQogCi0vKiBOT1RFOiBORUFSRVNUIGRvZXNudCBzZWVtIHRvIGV4aXN0LgorLyogTk9URTogTkVBUkVTVCBkb2Vzbid0IHNlZW0gdG8gZXhpc3QuCiAgKiBJbSBub3Qgc2V0aW5nIE1BR19GSUxURVJfTUFTSyBhbmQgKDMgPDwgMTEpIG9uIGZvciBhbGwKICAqIGFuaXNvdHJvcHkgbW9kZXMgYmVjYXVzZSB0aGF0IHdvdWxkIHZvaWQgc2VsZWN0ZWQgbWFnIGZpbHRlcgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I2MDBfY3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjYwMF9jcy5jCmluZGV4IDMzMjQ2MjAuLmZkMThiZTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjYwMF9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjYwMF9jcy5jCkBAIC05MjEsNyArOTIxLDcgQEAKIAkJcmV0dXJuIDA7CiAJaWIgPSBwLT5pYi0+cHRyOwogCXN3aXRjaCAocmVnKSB7Ci0JLyogZm9yY2UgZm9sbG93aW5nIHJlZyB0byAwIGluIGFuIGF0dGVtcCB0byBkaXNhYmxlIG91dCBidWZmZXIKKwkvKiBmb3JjZSBmb2xsb3dpbmcgcmVnIHRvIDAgaW4gYW4gYXR0ZW1wdCB0byBkaXNhYmxlIG91dCBidWZmZXIKIAkgKiB3aGljaCB3aWxsIG5lZWQgdXMgdG8gYmV0dGVyIHVuZGVyc3RhbmQgaG93IGl0IHdvcmtzIHRvIHBlcmZvcm0KIAkgKiBzZWN1cml0eSBjaGVjayBvbiBpdCAoSmVyb21lKQogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yNjAwX2hkbWkuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjYwMF9oZG1pLmMKaW5kZXggNTBkYjZkNi4uZjVhYzdlNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yNjAwX2hkbWkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I2MDBfaGRtaS5jCkBAIC0zMzQsNyArMzM0LDcgQEAKIAlyNjAwX2hkbWlfdmlkZW9pbmZvZnJhbWUoZW5jb2RlciwgUkdCLCAwLCAwLCAwLCAwLAogCQkwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwKTsKIAotCS8qIGl0J3MgdW5rbm93biB3aGF0IHRoZXNlIGJpdHMgZG8gZXhjYXRseSwgYnV0IGl0J3MgaW5kZWVkIHF1aXRlIHVzZWZ1bGwgZm9yIGRlYnVnZ2luZyAqLworCS8qIGl0J3MgdW5rbm93biB3aGF0IHRoZXNlIGJpdHMgZG8gZXhjYXRseSwgYnV0IGl0J3MgaW5kZWVkIHF1aXRlIHVzZWZ1bCBmb3IgZGVidWdnaW5nICovCiAJV1JFRzMyKG9mZnNldCtSNjAwX0hETUlfQVVESU9fREVCVUdfMCwgMHgwMEZGRkZGRik7CiAJV1JFRzMyKG9mZnNldCtSNjAwX0hETUlfQVVESU9fREVCVUdfMSwgMHgwMDdGRkZGRik7CiAJV1JFRzMyKG9mZnNldCtSNjAwX0hETUlfQVVESU9fREVCVUdfMiwgMHgwMDAwMDAwMSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaAppbmRleCBjZmUzYWYxLi45M2Y1MzY1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKQEAgLTY3OSwxMSArNjc5LDExIEBACiAgKiBAc2lkZXBvcnRfYmFuZHdpZHRoOiBzaWRlcG9ydCBiYW5kd2lkdGggdGhlIGdwdSBoYXMgKE1CeXRlL3MpIChJR1ApCiAgKiBAaHRfYmFuZHdpZHRoOiAgICAgICBodCBiYW5kd2lkdGggdGhlIGdwdSBoYXMgKE1CeXRlL3MpIChJR1ApCiAgKiBAY29yZV9iYW5kd2lkdGg6ICAgICBjb3JlIEdQVSBiYW5kd2lkdGggdGhlIGdwdSBoYXMgKE1CeXRlL3MpIChJR1ApCi0gKiBAc2NsazogICAgICAgICAgCUdQVSBjbG9jayBNaHogKGNvcmUgYmFuZHdpdGggZGVwZW5kcyBvZiB0aGlzIGNsb2NrKQorICogQHNjbGs6ICAgICAgICAgIAlHUFUgY2xvY2sgTWh6IChjb3JlIGJhbmR3aWR0aCBkZXBlbmRzIG9mIHRoaXMgY2xvY2spCiAgKiBAbmVlZGVkX2JhbmR3aWR0aDogICBjdXJyZW50IGJhbmR3aWR0aCBuZWVkcwogICoKICAqIEl0IGtlZXBzIHRyYWNrIG9mIHZhcmlvdXMgZGF0YSBuZWVkZWQgdG8gdGFrZSBwb3dlcm1hbmFnZW1lbnQgZGVjaXNpb24uCi0gKiBCYW5kd2l0aCBuZWVkIGlzIHVzZWQgdG8gZGV0ZXJtaW5lIG1pbmltdW4gY2xvY2sgb2YgdGhlIEdQVSBhbmQgbWVtb3J5LgorICogQmFuZHdpZHRoIG5lZWQgaXMgdXNlZCB0byBkZXRlcm1pbmUgbWluaW11biBjbG9jayBvZiB0aGUgR1BVIGFuZCBtZW1vcnkuCiAgKiBFcXVhdGlvbiBiZXR3ZWVuIGdwdS9tZW1vcnkgY2xvY2sgYW5kIGF2YWlsYWJsZSBiYW5kd2lkdGggaXMgaHcgZGVwZW5kZW50CiAgKiAodHlwZSBvZiBtZW1vcnksIGJ1cyBzaXplLCBlZmZpY2llbmN5LCAuLi4pCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2NwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9jcC5jCmluZGV4IDNkNTk5ZTMuLjc1ODY3NzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2NwLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fY3AuYwpAQCAtMjQ0LDcgKzI0NCw3IEBACiAJdTMyIGFncF9iYXNlX2xvID0gYWdwX2Jhc2UgJiAweGZmZmZmZmZmOwogCXUzMiByNnh4X2FncF9iYXNlID0gKGFncF9iYXNlID4+IDIyKSAmIDB4M2ZmZmY7CiAKLQkvKiBSNnh4L1I3eHggbXVzdCBiZSBhbGlnbmVkIHRvIGEgNE1CIGJvdW5kcnkgKi8KKwkvKiBSNnh4L1I3eHggbXVzdCBiZSBhbGlnbmVkIHRvIGEgNE1CIGJvdW5kYXJ5ICovCiAJaWYgKChkZXZfcHJpdi0+ZmxhZ3MgJiBSQURFT05fRkFNSUxZX01BU0spID49IENISVBfUlY3NzApCiAJCVJBREVPTl9XUklURShSNzAwX01DX1ZNX0FHUF9CQVNFLCByNnh4X2FncF9iYXNlKTsKIAllbHNlIGlmICgoZGV2X3ByaXYtPmZsYWdzICYgUkFERU9OX0ZBTUlMWV9NQVNLKSA+PSBDSElQX1I2MDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9jdXJzb3IuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2N1cnNvci5jCmluZGV4IDAxN2FjNTQuLmJkZjJmYTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2N1cnNvci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2N1cnNvci5jCkBAIC0yMjYsNyArMjI2LDcgQEAKIAkJeSArPSBjcnRjLT55OwogCQlEUk1fREVCVUcoInggJWQgeSAlZCBjLT54ICVkIGMtPnkgJWRcbiIsIHgsIHksIGNydGMtPngsIGNydGMtPnkpOwogCi0JCS8qIGF2aXZvIGN1cnNvciBpbWFnZSBjYW4ndCBlbmQgb24gMTI4IHBpeGVsIGJvdW5kcnkgb3IKKwkJLyogYXZpdm8gY3Vyc29yIGltYWdlIGNhbid0IGVuZCBvbiAxMjggcGl4ZWwgYm91bmRhcnkgb3IKIAkJICogZ28gcGFzdCB0aGUgZW5kIG9mIHRoZSBmcmFtZSBpZiBib3RoIGNydGNzIGFyZSBlbmFibGVkCiAJCSAqLwogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNydGNfcCwgJmNydGMtPmRldi0+bW9kZV9jb25maWcuY3J0Y19saXN0LCBoZWFkKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kZXZpY2UuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2RldmljZS5jCmluZGV4IGYwMjA5YmUuLjg5MDIxN2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2RldmljZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2RldmljZS5jCkBAIC0yNjIsNyArMjYyLDcgQEAKICAqIE5vdGU6IEdUVCBzdGFydCwgZW5kLCBzaXplIHNob3VsZCBiZSBpbml0aWFsaXplZCBiZWZvcmUgY2FsbGluZyB0aGlzCiAgKiBmdW5jdGlvbiBvbiBBR1AgcGxhdGZvcm0uCiAgKgotICogTm90ZTogV2UgZG9uJ3QgZXhwbGljdGx5IGVuZm9yY2UgVlJBTSBzdGFydCB0byBiZSBhbGlnbmVkIG9uIFZSQU0gc2l6ZSwKKyAqIE5vdGU6IFdlIGRvbid0IGV4cGxpY2l0bHkgZW5mb3JjZSBWUkFNIHN0YXJ0IHRvIGJlIGFsaWduZWQgb24gVlJBTSBzaXplLAogICogdGhpcyBzaG91bGRuJ3QgYmUgYSBwcm9ibGVtIGFzIHdlIGFyZSB1c2luZyB0aGUgUENJIGFwZXJ0dXJlIGFzIGEgcmVmZXJlbmNlLgogICogT3RoZXJ3aXNlIHRoaXMgd291bGQgYmUgbmVlZGVkIGZvciBydjI4MCwgYWxsIHIzeHgsIGFuZCBhbGwgcjR4eCwgYnV0CiAgKiBub3QgSUdQLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGlzcGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGlzcGxheS5jCmluZGV4IDRiZTU4NzkuLmJkYmFiNWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rpc3BsYXkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kaXNwbGF5LmMKQEAgLTE0OTIsNyArMTQ5Miw3IEBACiAgKgogICogXHJldHVybiBGbGFncywgb3InZWQgdG9nZXRoZXIgYXMgZm9sbG93czoKICAqCi0gKiBEUk1fU0NBTk9VVFBPU19WQUxJRCA9IFF1ZXJ5IHN1Y2Nlc3NmdWxsLgorICogRFJNX1NDQU5PVVRQT1NfVkFMSUQgPSBRdWVyeSBzdWNjZXNzZnVsLgogICogRFJNX1NDQU5PVVRQT1NfSU5WQkwgPSBJbnNpZGUgdmJsYW5rLgogICogRFJNX1NDQU5PVVRQT1NfQUNDVVJBVEUgPSBSZXR1cm5lZCBwb3NpdGlvbiBpcyBhY2N1cmF0ZS4gQSBsYWNrIG9mCiAgKiB0aGlzIGZsYWcgbWVhbnMgdGhhdCByZXR1cm5lZCBwb3NpdGlvbiBtYXkgYmUgb2Zmc2V0IGJ5IGEgY29uc3RhbnQgYnV0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rydi5oCmluZGV4IDVjYmE0NmIuLmExYjU5Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rydi5oCkBAIC0yNzEsNyArMjcxLDcgQEAKIAogCWludCBoYXZlX3pfb2Zmc2V0OwogCi0JLyogc3RhcnRpbmcgZnJvbSBoZXJlIG9uLCBkYXRhIGlzIHByZXNlcnZlZCBhY2Nyb3NzIGFuIG9wZW4gKi8KKwkvKiBzdGFydGluZyBmcm9tIGhlcmUgb24sIGRhdGEgaXMgcHJlc2VydmVkIGFjcm9zcyBhbiBvcGVuICovCiAJdWludDMyX3QgZmxhZ3M7CQkvKiBzZWUgcmFkZW9uX2NoaXBfZmxhZ3MgKi8KIAlyZXNvdXJjZV9zaXplX3QgZmJfYXBlcl9vZmZzZXQ7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX29iamVjdC5oIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fb2JqZWN0LmgKaW5kZXggN2Y4ZTc3OC4uZWRlNmMxMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fb2JqZWN0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fb2JqZWN0LmgKQEAgLTg3LDcgKzg3LDcgQEAKICAqIFJldHVybnMgY3VycmVudCBHUFUgb2Zmc2V0IG9mIHRoZSBvYmplY3QuCiAgKgogICogTm90ZTogb2JqZWN0IHNob3VsZCBlaXRoZXIgYmUgcGlubmVkIG9yIHJlc2VydmVkIHdoZW4gY2FsbGluZyB0aGlzCi0gKiBmdW5jdGlvbiwgaXQgbWlnaHQgYmUgdXNlZnVsbCB0byBhZGQgY2hlY2sgZm9yIHRoaXMgZm9yIGRlYnVnZ2luZy4KKyAqIGZ1bmN0aW9uLCBpdCBtaWdodCBiZSB1c2VmdWwgdG8gYWRkIGNoZWNrIGZvciB0aGlzIGZvciBkZWJ1Z2dpbmcuCiAgKi8KIHN0YXRpYyBpbmxpbmUgdTY0IHJhZGVvbl9ib19ncHVfb2Zmc2V0KHN0cnVjdCByYWRlb25fYm8gKmJvKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fc3RhdGUuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3N0YXRlLmMKaW5kZXggNGFlNWEzZC4uOTJlN2VhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fc3RhdGUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9zdGF0ZS5jCkBAIC05ODAsNyArOTgwLDcgQEAKIAl9CiAKIAkvKiBoeXBlciB6IGNsZWFyICovCi0JLyogbm8gZG9jcyBhdmFpbGFibGUsIGJhc2VkIG9uIHJldmVyc2UgZW5nZW5lZXJpbmcgYnkgU3RlcGhhbmUgTWFyY2hlc2luICovCisJLyogbm8gZG9jcyBhdmFpbGFibGUsIGJhc2VkIG9uIHJldmVyc2UgZW5naW5lZXJpbmcgYnkgU3RlcGhhbmUgTWFyY2hlc2luICovCiAJaWYgKChmbGFncyAmIChSQURFT05fREVQVEggfCBSQURFT05fU1RFTkNJTCkpCiAJICAgICYmIChmbGFncyAmIFJBREVPTl9DTEVBUl9GQVNUWikpIHsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9rbXMuYwppbmRleCBjY2VlYjQyLi5kZmUzMmU2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9rbXMuYwpAQCAtMjQ1LDcgKzI0NSw3IEBACiAJCS8qIFRPRE8gaGFuZGxlIG5vbmUgcGFnZSBhbGlnbmVkIG9mZnNldHMgKi8KIAkJLyogVE9ETyBoYW5kbGUgcGFydGlhbCB1cGxvYWRzIGFuZCBwaXRjaCAhPSAyNTYgKi8KIAkJLyogVE9ETyBoYW5kbGUgbW9yZSB0aGVuIG9uZSBjb3B5IChzaXplICE9IDY0KSAqLwotCQlEUk1fRVJST1IoImxhenkgcHJvZ3JhbWVyLCBjYW50IGhhbmRsZSB3aWVyZCBzdHVmZlxuIik7CisJCURSTV9FUlJPUigibGF6eSBwcm9ncmFtbWVyLCBjYW4ndCBoYW5kbGUgd2VpcmQgc3R1ZmZcbiIpOwogCQlyZXR1cm47CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS92Z2EvdmdhYXJiLmMgYi9kcml2ZXJzL2dwdS92Z2EvdmdhYXJiLmMKaW5kZXggYWNlMmIxNi4uYmU4ZDRjYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvdmdhL3ZnYWFyYi5jCisrKyBiL2RyaXZlcnMvZ3B1L3ZnYS92Z2FhcmIuYwpAQCAtMTUxLDcgKzE1MSw3IEBACiBzdGF0aWMgdm9pZCB2Z2FfY2hlY2tfZmlyc3RfdXNlKHZvaWQpCiB7CiAJLyogd2Ugc2hvdWxkIGluZm9ybSBhbGwgR1BVcyBpbiB0aGUgc3lzdGVtIHRoYXQKLQkgKiBWR0EgYXJiIGhhcyBvY2N1cmVkIGFuZCB0byB0cnkgYW5kIGRpc2FibGUgcmVzb3VyY2VzCisJICogVkdBIGFyYiBoYXMgb2NjdXJyZWQgYW5kIHRvIHRyeSBhbmQgZGlzYWJsZSByZXNvdXJjZXMKIAkgKiBpZiB0aGV5IGNhbiAqLwogCWlmICghdmdhX2FyYml0ZXJfdXNlZCkgewogCQl2Z2FfYXJiaXRlcl91c2VkID0gdHJ1ZTsKQEAgLTc3NCw3ICs3NzQsNyBAQAogCSAqLwogCXNwaW5fbG9ja19pcnFzYXZlKCZ2Z2FfbG9jaywgZmxhZ3MpOwogCi0JLyogSWYgd2UgYXJlIHRhcmdldHRpbmcgdGhlIGRlZmF1bHQsIHVzZSBpdCAqLworCS8qIElmIHdlIGFyZSB0YXJnZXRpbmcgdGhlIGRlZmF1bHQsIHVzZSBpdCAqLwogCXBkZXYgPSBwcml2LT50YXJnZXQ7CiAJaWYgKHBkZXYgPT0gTlVMTCB8fCBwZGV2ID09IFBDSV9JTlZBTElEX0NBUkQpIHsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdmdhX2xvY2ssIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL0tjb25maWcgYi9kcml2ZXJzL2hpZC9LY29uZmlnCmluZGV4IGI3ZWM0MDUuLjlkZTllOTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL0tjb25maWcKKysrIGIvZHJpdmVycy9oaWQvS2NvbmZpZwpAQCAtMTg1LDcgKzE4NSw3IEBACiAJU3VwcG9ydCBmb3IgRXprZXkgQlRDIDgxOTMga2V5Ym9hcmQuCiAKIGNvbmZpZyBISURfS0VZVE9VQ0gKLQl0cmlzdGF0ZSAiS2V5b3V0Y2ggSElEIGRldmljZXMiCisJdHJpc3RhdGUgIktleXRvdWNoIEhJRCBkZXZpY2VzIgogCWRlcGVuZHMgb24gVVNCX0hJRAogCS0tLWhlbHAtLS0KIAlTdXBwb3J0IGZvciBLZXl0b3VjaCBISUQgZGV2aWNlcyBub3QgZnVsbHkgY29tcGxpYW50IHdpdGgKQEAgLTM0MCwxMCArMzQwLDE3IEBACiAJU3VwcG9ydCBmb3IgTi1UcmlnIHRvdWNoIHNjcmVlbi4KIAogY29uZmlnIEhJRF9PUlRFSwotCXRyaXN0YXRlICJPcnRlayBQS0ItMTcwMC9XS0ItMjAwMCB3aXJlbGVzcyBrZXlib2FyZCBhbmQgbW91c2UgdHJhY2twYWQiCisJdHJpc3RhdGUgIk9ydGVrIFBLQi0xNzAwL1dLQi0yMDAwL1NreWNhYmxlIHdpcmVsZXNzIGtleWJvYXJkIGFuZCBtb3VzZSB0cmFja3BhZCIKIAlkZXBlbmRzIG9uIFVTQl9ISUQKIAktLS1oZWxwLS0tCi0JU3VwcG9ydCBmb3IgT3J0ZWsgUEtCLTE3MDAvV0tCLTIwMDAgd2lyZWxlc3Mga2V5Ym9hcmQgKyBtb3VzZSB0cmFja3BhZC4KKwlUaGVyZSBhcmUgY2VydGFpbiBkZXZpY2VzIHdoaWNoIGhhdmUgTG9naWNhbE1heGltdW0gd3JvbmcgaW4gdGhlIGtleWJvYXJkCisJdXNhZ2UgcGFnZSBvZiB0aGVpciByZXBvcnQgZGVzY3JpcHRvci4gVGhlIG1vc3QgcHJldmFpbGluZyBvbmVzIHNvIGZhcgorCWFyZSBtYW51ZmFjdHVyZWQgYnkgT3J0ZWssIHRodXMgdGhlIG5hbWUgb2YgdGhlIGRyaXZlci4gQ3VycmVudGx5CisJc3VwcG9ydGVkIGRldmljZXMgYnkgdGhpcyBkcml2ZXIgYXJlCisKKwkgICAtIE9ydGVrIFBLQi0xNzAwCisJICAgLSBPcnRlayBXS0ItMjAwMAorCSAgIC0gU2t5Y2FibGUgd2lyZWxlc3MgcHJlc2VudGVyCiAKIGNvbmZpZyBISURfUEFOVEhFUkxPUkQKIAl0cmlzdGF0ZSAiUGFudGhlcmxvcmQvR3JlZW5Bc2lhIGdhbWUgY29udHJvbGxlciIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL2hpZC1jb3JlLmMgYi9kcml2ZXJzL2hpZC9oaWQtY29yZS5jCmluZGV4IGU5Njg3NzYuLjQwOGM0YmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL2hpZC1jb3JlLmMKKysrIGIvZHJpdmVycy9oaWQvaGlkLWNvcmUuYwpAQCAtMzA2LDcgKzMwNiw3IEBACiAJY2FzZSBISURfR0xPQkFMX0lURU1fVEFHX1BVU0g6CiAKIAkJaWYgKHBhcnNlci0+Z2xvYmFsX3N0YWNrX3B0ciA9PSBISURfR0xPQkFMX1NUQUNLX1NJWkUpIHsKLQkJCWRiZ19oaWQoImdsb2JhbCBlbnZpcm9tZW50IHN0YWNrIG92ZXJmbG93XG4iKTsKKwkJCWRiZ19oaWQoImdsb2JhbCBlbnZpcm9ubWVudCBzdGFjayBvdmVyZmxvd1xuIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIApAQCAtMzE3LDcgKzMxNyw3IEBACiAJY2FzZSBISURfR0xPQkFMX0lURU1fVEFHX1BPUDoKIAogCQlpZiAoIXBhcnNlci0+Z2xvYmFsX3N0YWNrX3B0cikgewotCQkJZGJnX2hpZCgiZ2xvYmFsIGVudmlyb21lbnQgc3RhY2sgdW5kZXJmbG93XG4iKTsKKwkJCWRiZ19oaWQoImdsb2JhbCBlbnZpcm9ubWVudCBzdGFjayB1bmRlcmZsb3dcbiIpOwogCQkJcmV0dXJuIC0xOwogCQl9CiAKQEAgLTE0NDksOCArMTQ0OSwxMCBAQAogCXsgSElEX1VTQl9ERVZJQ0UoVVNCX1ZFTkRPUl9JRF9ST0NDQVQsIFVTQl9ERVZJQ0VfSURfUk9DQ0FUX0tPTkVQTFVTKSB9LAogCXsgSElEX1VTQl9ERVZJQ0UoVVNCX1ZFTkRPUl9JRF9ST0NDQVQsIFVTQl9ERVZJQ0VfSURfUk9DQ0FUX0tPVkFQTFVTKSB9LAogCXsgSElEX1VTQl9ERVZJQ0UoVVNCX1ZFTkRPUl9JRF9ST0NDQVQsIFVTQl9ERVZJQ0VfSURfUk9DQ0FUX1BZUkFfV0lSRUQpIH0sCisJeyBISURfVVNCX0RFVklDRShVU0JfVkVORE9SX0lEX1JPQ0NBVCwgVVNCX0RFVklDRV9JRF9ST0NDQVRfUFlSQV9XSVJFTEVTUykgfSwKIAl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfU0FNU1VORywgVVNCX0RFVklDRV9JRF9TQU1TVU5HX0lSX1JFTU9URSkgfSwKIAl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfU0FNU1VORywgVVNCX0RFVklDRV9JRF9TQU1TVU5HX1dJUkVMRVNTX0tCRF9NT1VTRSkgfSwKKwl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfU0tZQ0FCTEUsIFVTQl9ERVZJQ0VfSURfU0tZQ0FCTEVfV0lSRUxFU1NfUFJFU0VOVEVSKSB9LAogCXsgSElEX1VTQl9ERVZJQ0UoVVNCX1ZFTkRPUl9JRF9TT05ZLCBVU0JfREVWSUNFX0lEX1NPTllfUFMzX0NPTlRST0xMRVIpIH0sCiAJeyBISURfQkxVRVRPT1RIX0RFVklDRShVU0JfVkVORE9SX0lEX1NPTlksIFVTQl9ERVZJQ0VfSURfU09OWV9QUzNfQ09OVFJPTExFUikgfSwKIAl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfU09OWSwgVVNCX0RFVklDRV9JRF9TT05ZX1ZBSU9fVkdYX01PVVNFKSB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9oaWQvaGlkLWRlYnVnLmMgYi9kcml2ZXJzL2hpZC9oaWQtZGVidWcuYwppbmRleCA1NTUzODJmLi5iYWU0ODc0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2hpZC9oaWQtZGVidWcuYworKysgYi9kcml2ZXJzL2hpZC9oaWQtZGVidWcuYwpAQCAtMzQxLDcgKzM0MSw3IEBACiAgICAgeyAweDg1LCAweDgzLCAiRGVzaWduQ2FwYWNpdHkiIH0sCiAgICAgeyAweDg1LCAweDg1LCAiTWFudWZhY3R1cmVyRGF0ZSIgfSwKICAgICB7IDB4ODUsIDB4ODksICJpRGV2aWNlQ2hlbWlzdHJ5IiB9LAotICAgIHsgMHg4NSwgMHg4YiwgIlJlY2hhcmdhYmxlIiB9LAorICAgIHsgMHg4NSwgMHg4YiwgIlJlY2hhcmdlYWJsZSIgfSwKICAgICB7IDB4ODUsIDB4OGYsICJpT0VNSW5mb3JtYXRpb24iIH0sCiAgICAgeyAweDg1LCAweDhkLCAiQ2FwYWNpdHlHcmFudWxhcml0eTEiIH0sCiAgICAgeyAweDg1LCAweGQwLCAiQUNQcmVzZW50IiB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9oaWQvaGlkLWlkcy5oIGIvZHJpdmVycy9oaWQvaGlkLWlkcy5oCmluZGV4IDY1YWM1M2QuLjAwYTk0YjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL2hpZC1pZHMuaAorKysgYi9kcml2ZXJzL2hpZC9oaWQtaWRzLmgKQEAgLTE1MCw2ICsxNTAsNyBAQAogI2RlZmluZSBVU0JfREVWSUNFX0lEX0NBTkRPX01VTFRJX1RPVUNIXzE1XzYgMHgwZjAxCiAKICNkZWZpbmUgVVNCX1ZFTkRPUl9JRF9DSAkJMHgwNjhlCisjZGVmaW5lIFVTQl9ERVZJQ0VfSURfQ0hfUFJPX1RIUk9UVExFCTB4MDBmMQogI2RlZmluZSBVU0JfREVWSUNFX0lEX0NIX1BST19QRURBTFMJMHgwMGYyCiAjZGVmaW5lIFVTQl9ERVZJQ0VfSURfQ0hfQ09NQkFUU1RJQ0sJMHgwMGY0CiAjZGVmaW5lIFVTQl9ERVZJQ0VfSURfQ0hfRkxJR0hUX1NJTV9FQ0xJUFNFX1lPS0UgICAgICAgMHgwMDUxCkBAIC01MjQsNiArNTI1LDkgQEAKICNkZWZpbmUgVVNCX0RFVklDRV9JRF9TQU1TVU5HX0lSX1JFTU9URQkweDAwMDEKICNkZWZpbmUgVVNCX0RFVklDRV9JRF9TQU1TVU5HX1dJUkVMRVNTX0tCRF9NT1VTRQkweDA2MDAKIAorI2RlZmluZSBVU0JfVkVORE9SX0lEX1NLWUNBQkxFCQkJMHgxMjIzCisjZGVmaW5lCVVTQl9ERVZJQ0VfSURfU0tZQ0FCTEVfV0lSRUxFU1NfUFJFU0VOVEVSCTB4M0YwNworCiAjZGVmaW5lIFVTQl9WRU5ET1JfSURfU09OWQkJCTB4MDU0YwogI2RlZmluZSBVU0JfREVWSUNFX0lEX1NPTllfVkFJT19WR1hfTU9VU0UJMHgwMjRiCiAjZGVmaW5lIFVTQl9ERVZJQ0VfSURfU09OWV9QUzNfQ09OVFJPTExFUgkweDAyNjgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL2hpZC1sZ2ZmLmMgYi9kcml2ZXJzL2hpZC9oaWQtbGdmZi5jCmluZGV4IDkwZDBlZjIuLmYwOTkwNzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL2hpZC1sZ2ZmLmMKKysrIGIvZHJpdmVycy9oaWQvaGlkLWxnZmYuYwpAQCAtNzMsNiArNzMsOCBAQAogCXsgMHgwNDZkLCAweGMyOTMsIGZmX2pveXN0aWNrIH0sCiAJeyAweDA0NmQsIDB4YzI5NCwgZmZfd2hlZWwgfSwKIAl7IDB4MDQ2ZCwgMHhjMjk1LCBmZl9qb3lzdGljayB9LAorCXsgMHgwNDZkLCAweGMyOTgsIGZmX3doZWVsIH0sCisJeyAweDA0NmQsIDB4YzI5OSwgZmZfd2hlZWwgfSwKIAl7IDB4MDQ2ZCwgMHhjYTAzLCBmZl93aGVlbCB9LAogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9oaWQvaGlkLW1hZ2ljbW91c2UuYyBiL2RyaXZlcnMvaGlkL2hpZC1tYWdpY21vdXNlLmMKaW5kZXggMzE4Y2M0MC4uMGVjOTFjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9oaWQvaGlkLW1hZ2ljbW91c2UuYworKysgYi9kcml2ZXJzL2hpZC9oaWQtbWFnaWNtb3VzZS5jCkBAIC03Niw3ICs3Niw3IEBACiAgKiBUaGlzIGlzIHRydWUgd2hlbiBzaW5nbGVfdG91Y2hfaWQgaXMgZXF1YWwgdG8gTk9fVE9VQ0hFUy4gSWYgbXVsdGlwbGUgdG91Y2hlcwogICogYXJlIGRvd24gYW5kIHRoZSB0b3VjaCBwcm92aWRpbmcgZm9yIHNpbmdsZSB0b3VjaCBlbXVsYXRpb24gaXMgbGlmdGVkLAogICogc2luZ2xlX3RvdWNoX2lkIGlzIGVxdWFsIHRvIFNJTkdMRV9UT1VDSF9VUC4gV2hpbGUgc2luZ2xlIHRvdWNoIGVtdWxhdGlvbiBpcwotICogb2NjdXJpbmcsIHNpbmdsZV90b3VjaF9pZCBjb3JyZXNwb25kcyB3aXRoIHRoZSB0cmFja2luZyBpZCBvZiB0aGUgdG91Y2ggdXNlZC4KKyAqIG9jY3VycmluZywgc2luZ2xlX3RvdWNoX2lkIGNvcnJlc3BvbmRzIHdpdGggdGhlIHRyYWNraW5nIGlkIG9mIHRoZSB0b3VjaCB1c2VkLgogICovCiAjZGVmaW5lIE5PX1RPVUNIRVMgLTEKICNkZWZpbmUgU0lOR0xFX1RPVUNIX1VQIC0yCkBAIC00MTgsNiArNDE4LDggQEAKIAkJCWlucHV0X3NldF9hYnNfcGFyYW1zKGlucHV0LCBBQlNfTVRfUE9TSVRJT05fWSwgLTI0NTYsCiAJCQkJMjU2NSwgNCwgMCk7CiAJCX0KKworCQlpbnB1dF9zZXRfZXZlbnRzX3Blcl9wYWNrZXQoaW5wdXQsIDYwKTsKIAl9CiAKIAlpZiAocmVwb3J0X3VuZGVjaXBoZXJlZCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9oaWQvaGlkLW9ydGVrLmMgYi9kcml2ZXJzL2hpZC9oaWQtb3J0ZWsuYwppbmRleCBmOWI3ZGQ0Li4wZmZhMWQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2hpZC9oaWQtb3J0ZWsuYworKysgYi9kcml2ZXJzL2hpZC9oaWQtb3J0ZWsuYwpAQCAtMSw4ICsxLDE0IEBACiAvKgotICogIEhJRCBkcml2ZXIgZm9yIE9ydGVrIFBLQi0xNzAwL1dLQi0yMDAwICh3aXJlbGVzcyBrZXlib2FyZCArIG1vdXNlIHRyYWNrcGFkKS4KLSAqICBGaXhlcyBMb2dpY2FsTWF4aW11bSBlcnJvciBpbiBISUQgcmVwb3J0IGRlc2NyaXB0aW9uLgorICogIEhJRCBkcml2ZXIgZm9yIHZhcmlvdXMgZGV2aWNlcyB3aGljaCBhcmUgYXBwYXJlbnRseSBiYXNlZCBvbiB0aGUgc2FtZSBjaGlwc2V0CisgKiAgZnJvbSBjZXJ0YWluIHZlbmRvciB3aGljaCBwcm9kdWNlcyBjaGlwcyB0aGF0IGNvbnRhaW4gd3JvbmcgTG9naWNhbE1heGltdW0KKyAqICB2YWx1ZSBpbiB0aGVpciBISUQgcmVwb3J0IGRlc2NyaXB0b3IuIEN1cnJlbnRseSBzdXBwb3J0ZWQgZGV2aWNlcyBhcmU6CisgKgorICogICAgT3J0ZWsgUEtCLTE3MDAKKyAqICAgIE9ydGVrIFdLQi0yMDAwCisgKiAgICBTa3ljYWJsZSB3aXJlbGVzcyBwcmVzZW50ZXIKICAqCiAgKiAgQ29weXJpZ2h0IChjKSAyMDEwIEpvaG5hdGhvbiBIYXJyaXMgPGptaGFycmlzQGdtYWlsLmNvbT4KKyAqICBDb3B5cmlnaHQgKGMpIDIwMTEgSmlyaSBLb3NpbmEKICAqLwogCiAvKgpAQCAtMjIsOCArMjgsMTEgQEAKIAkJdW5zaWduZWQgaW50ICpyc2l6ZSkKIHsKIAlpZiAoKnJzaXplID49IDU2ICYmIHJkZXNjWzU0XSA9PSAweDI1ICYmIHJkZXNjWzU1XSA9PSAweDAxKSB7Ci0JCWhpZF9pbmZvKGhkZXYsICJGaXhpbmcgdXAgT3J0ZWsgV0tCLTIwMDAgcmVwb3J0IGRlc2NyaXB0b3JcbiIpOworCQloaWRfaW5mbyhoZGV2LCAiRml4aW5nIHVwIGxvZ2ljYWwgbWluaW11bSBpbiByZXBvcnQgZGVzY3JpcHRvciAoT3J0ZWspXG4iKTsKIAkJcmRlc2NbNTVdID0gMHg5MjsKKwl9IGVsc2UgaWYgKCpyc2l6ZSA+PSA1NCAmJiByZGVzY1s1Ml0gPT0gMHgyNSAmJiByZGVzY1s1M10gPT0gMHgwMSkgeworCQloaWRfaW5mbyhoZGV2LCAiRml4aW5nIHVwIGxvZ2ljYWwgbWluaW11bSBpbiByZXBvcnQgZGVzY3JpcHRvciAoU2t5Y2FibGUpXG4iKTsKKwkJcmRlc2NbNTNdID0gMHg2NTsKIAl9CiAJcmV0dXJuIHJkZXNjOwogfQpAQCAtMzEsNiArNDAsNyBAQAogc3RhdGljIGNvbnN0IHN0cnVjdCBoaWRfZGV2aWNlX2lkIG9ydGVrX2RldmljZXNbXSA9IHsKIAl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfT1JURUssIFVTQl9ERVZJQ0VfSURfT1JURUtfUEtCMTcwMCkgfSwKIAl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfT1JURUssIFVTQl9ERVZJQ0VfSURfT1JURUtfV0tCMjAwMCkgfSwKKwl7IEhJRF9VU0JfREVWSUNFKFVTQl9WRU5ET1JfSURfU0tZQ0FCTEUsIFVTQl9ERVZJQ0VfSURfU0tZQ0FCTEVfV0lSRUxFU1NfUFJFU0VOVEVSKSB9LAogCXsgfQogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUoaGlkLCBvcnRla19kZXZpY2VzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL2hpZC1waWNvbGNkLmMgYi9kcml2ZXJzL2hpZC9oaWQtcGljb2xjZC5jCmluZGV4IDY1N2RhNWEuLmIyZjU2YTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL2hpZC1waWNvbGNkLmMKKysrIGIvZHJpdmVycy9oaWQvaGlkLXBpY29sY2QuYwpAQCAtMTgwNiwxMyArMTgwNiwxMyBAQAogLyoKICAqIE5vdGVzOgogICogLSBjb25jdXJyZW50IHdyaXRpbmcgaXMgcHJldmVudGVkIGJ5IG11dGV4IGFuZCBhbGwgd3JpdGVzIG11c3QgYmUKLSAqICAgbio2NCBieXRlcyBhbmQgNjQtYnl0ZSBhbGlnbmVkLCBlYWNoIHdyaXRlIGJlaW5nIHByZWNlZWRlZCBieSBhbgorICogICBuKjY0IGJ5dGVzIGFuZCA2NC1ieXRlIGFsaWduZWQsIGVhY2ggd3JpdGUgYmVpbmcgcHJlY2VkZWQgYnkgYW4KICAqICAgRVJBU0Ugd2hpY2ggZXJhc2VzIGEgNjRieXRlIGJsb2NrLgogICogICBJZiBsZXNzIHRoYW4gcmVxdWVzdGVkIHdhcyB3cml0dGVuIG9yIGFuIGVycm9yIGlzIHJldHVybmVkIGZvciBhbgogICogICBvdGhlcndpc2UgY29ycmVjdCB3cml0ZSByZXF1ZXN0IHRoZSBuZXh0IDY0LWJ5dGUgYmxvY2sgd2hpY2ggc2hvdWxkCiAgKiAgIGhhdmUgYmVlbiB3cml0dGVuIGlzIGluIHVuZGVmaW5lZCBzdGF0ZSAobW9zdGx5OiBvcmlnaW5hbCwgZXJhc2VkLAogICogICAoaGFsZi0pd3JpdHRlbiB3aXRoIHdyaXRlIGVycm9yKQotICogLSByZWFkaW5nIGNhbiBoYXBwZW5kIHdpdGhvdXQgc3BlY2lhbCByZXN0cmljdGlvbgorICogLSByZWFkaW5nIGNhbiBoYXBwZW4gd2l0aG91dCBzcGVjaWFsIHJlc3RyaWN0aW9uCiAgKi8KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHBpY29sY2RfZGVidWdfZmxhc2hfZm9wcyA9IHsKIAkub3duZXIgICAgPSBUSElTX01PRFVMRSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL2hpZC1yb2NjYXQta29uZS5oIGIvZHJpdmVycy9oaWQvaGlkLXJvY2NhdC1rb25lLmgKaW5kZXggNjRhYmI1Yi4uNDEwOWEwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9oaWQvaGlkLXJvY2NhdC1rb25lLmgKKysrIGIvZHJpdmVycy9oaWQvaGlkLXJvY2NhdC1rb25lLmgKQEAgLTE2Niw3ICsxNjYsNyBAQAogCS8qIG9zZCBldmVudHMgYXJlIHRob3VnaHQgdG8gYmUgZGlzcGxheSBvbiBzY3JlZW4gKi8KIAlrb25lX21vdXNlX2V2ZW50X29zZF9kcGkgPSAweGEwLAogCWtvbmVfbW91c2VfZXZlbnRfb3NkX3Byb2ZpbGUgPSAweGIwLAotCS8qIFRPRE8gY2xhcmlmeSBtZWFuaW5nIGFuZCBvY2N1cmVuY2Ugb2Yga29uZV9tb3VzZV9ldmVudF9jYWxpYnJhdGlvbiAqLworCS8qIFRPRE8gY2xhcmlmeSBtZWFuaW5nIGFuZCBvY2N1cnJlbmNlIG9mIGtvbmVfbW91c2VfZXZlbnRfY2FsaWJyYXRpb24gKi8KIAlrb25lX21vdXNlX2V2ZW50X2NhbGlicmF0aW9uID0gMHhjMCwKIAlrb25lX21vdXNlX2V2ZW50X2NhbGxfb3ZlcmxvbmdfbWFjcm8gPSAweGUwLAogCS8qIHN3aXRjaCBldmVudHMgbm90aWZ5IGlmIHVzZXIgY2hhbmdlZCB2YWx1ZXMgd2l0aCBtb3VzZWJ1dHRvbiBjbGljayAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9oaWQvaGlkLXJvY2NhdC1weXJhLmMgYi9kcml2ZXJzL2hpZC9oaWQtcm9jY2F0LXB5cmEuYwppbmRleCAxNjBmNDgxLi4zODI4MGMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2hpZC9oaWQtcm9jY2F0LXB5cmEuYworKysgYi9kcml2ZXJzL2hpZC9oaWQtcm9jY2F0LXB5cmEuYwpAQCAtNjUyLDcgKzY1Miw4IEBACiBzdGF0aWMgY29uc3Qgc3RydWN0IGhpZF9kZXZpY2VfaWQgcHlyYV9kZXZpY2VzW10gPSB7CiAJeyBISURfVVNCX0RFVklDRShVU0JfVkVORE9SX0lEX1JPQ0NBVCwKIAkJCVVTQl9ERVZJQ0VfSURfUk9DQ0FUX1BZUkFfV0lSRUQpIH0sCi0JLyogVE9ETyBhZGQgVVNCX0RFVklDRV9JRF9ST0NDQVRfUFlSQV9XSVJFTEVTUyBhZnRlciB0ZXN0aW5nICovCisJeyBISURfVVNCX0RFVklDRShVU0JfVkVORE9SX0lEX1JPQ0NBVCwKKwkJCVVTQl9ERVZJQ0VfSURfUk9DQ0FUX1BZUkFfV0lSRUxFU1MpIH0sCiAJeyB9CiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5jIGIvZHJpdmVycy9oaWQvdXNiaGlkL2hpZC1xdWlya3MuYwppbmRleCA5YTk0YjY0Li5hODQyNmYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5jCisrKyBiL2RyaXZlcnMvaGlkL3VzYmhpZC9oaWQtcXVpcmtzLmMKQEAgLTU5LDYgKzU5LDcgQEAKIAl7IFVTQl9WRU5ET1JfSURfQ0gsIFVTQl9ERVZJQ0VfSURfQ0hfQ09NQkFUU1RJQ0ssIEhJRF9RVUlSS19OT0dFVCB9LAogCXsgVVNCX1ZFTkRPUl9JRF9DSCwgVVNCX0RFVklDRV9JRF9DSF9GTElHSFRfU0lNX0VDTElQU0VfWU9LRSwgSElEX1FVSVJLX05PR0VUIH0sCiAJeyBVU0JfVkVORE9SX0lEX0NILCBVU0JfREVWSUNFX0lEX0NIX0ZMSUdIVF9TSU1fWU9LRSwgSElEX1FVSVJLX05PR0VUIH0sCisJeyBVU0JfVkVORE9SX0lEX0NILCBVU0JfREVWSUNFX0lEX0NIX1BST19USFJPVFRMRSwgSElEX1FVSVJLX05PR0VUIH0sCiAJeyBVU0JfVkVORE9SX0lEX0NILCBVU0JfREVWSUNFX0lEX0NIX1BST19QRURBTFMsIEhJRF9RVUlSS19OT0dFVCB9LAogCXsgVVNCX1ZFTkRPUl9JRF9DSCwgVVNCX0RFVklDRV9JRF9DSF8zQVhJU181QlVUVE9OX1NUSUNLLCBISURfUVVJUktfTk9HRVQgfSwKIAl7IFVTQl9WRU5ET1JfSURfQ0gsIFVTQl9ERVZJQ0VfSURfQ0hfQVhJU18yOTUsIEhJRF9RVUlSS19OT0dFVCB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9hYml0dWd1cnUuYyBiL2RyaXZlcnMvaHdtb24vYWJpdHVndXJ1LmMKaW5kZXggMGUwNWFhMS4uZTdkNGM0NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9hYml0dWd1cnUuYworKysgYi9kcml2ZXJzL2h3bW9uL2FiaXR1Z3VydS5jCkBAIC0xNDIyLDcgKzE0MjIsNyBAQAogCSAgIGF0IERBVEEgYW5kIDB4QUMsIHdoZW4gdGhpcyBkcml2ZXIgaGFzIGFscmVhZHkgYmVlbiBsb2FkZWQgb25jZQogCSAgIERBVEEgd2lsbCBob2xkIDB4MDguIEZvciBtb3N0IHVHdXJ1J3MgQ01EIHdpbGwgaG9sZCAweEFDIGluIGVpdGhlcgogCSAgIHNjZW5hcmlvIGJ1dCBzb21lIHdpbGwgaG9sZCAweDAwLgotCSAgIFNvbWUgdUd1cnUncyBpbml0YWxseSBob2xkIDB4MDkgYXQgREFUQSBhbmQgd2lsbCBvbmx5IGhvbGQgMHgwOAorCSAgIFNvbWUgdUd1cnUncyBpbml0aWFsbHkgaG9sZCAweDA5IGF0IERBVEEgYW5kIHdpbGwgb25seSBob2xkIDB4MDgKIAkgICBhZnRlciByZWFkaW5nIENNRCBmaXJzdCwgc28gQ01EIG11c3QgYmUgcmVhZCBmaXJzdCEgKi8KIAl1OCBjbWRfdmFsID0gaW5iX3AoQUJJVF9VR1VSVV9CQVNFICsgQUJJVF9VR1VSVV9DTUQpOwogCXU4IGRhdGFfdmFsID0gaW5iX3AoQUJJVF9VR1VSVV9CQVNFICsgQUJJVF9VR1VSVV9EQVRBKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vYWJpdHVndXJ1My5jIGIvZHJpdmVycy9od21vbi9hYml0dWd1cnUzLmMKaW5kZXggMDM0Y2ViZi4uZTg5ZDU3MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9hYml0dWd1cnUzLmMKKysrIGIvZHJpdmVycy9od21vbi9hYml0dWd1cnUzLmMKQEAgLTE1MSw3ICsxNTEsNyBAQAogCS8qIFBvaW50ZXIgdG8gdGhlIHNlbnNvcnMgaW5mbyBmb3IgdGhlIGRldGVjdGVkIG1vdGhlcmJvYXJkICovCiAJY29uc3Qgc3RydWN0IGFiaXR1Z3VydTNfc2Vuc29yX2luZm8gKnNlbnNvcnM7CiAKLQkvKiBUaGUgYWJpdHVndXJ1MyBzdXBwb3J0cyB1cHRvIDQ4IHNlbnNvcnMsIGFuZCB0aHVzIGhhcyByZWdpc3RlcnMKKwkvKiBUaGUgYWJpdHVndXJ1MyBzdXBwb3J0cyB1cCB0byA0OCBzZW5zb3JzLCBhbmQgdGh1cyBoYXMgcmVnaXN0ZXJzCiAJICAgc2V0cyBmb3IgNDggc2Vuc29ycywgZm9yIGNvbnZpZW5lbmNlIHJlYXNvbnMgLyBzaW1wbGljaXR5IG9mIHRoZQogCSAgIGNvZGUgd2UgYWx3YXlzIHJlYWQgYW5kIHN0b3JlIGFsbCByZWdpc3RlcnMgZm9yIGFsbCA0OCBzZW5zb3JzICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vYWRtMTAyNi5jIGIvZHJpdmVycy9od21vbi9hZG0xMDI2LmMKaW5kZXggYmUwZmRkNS4uMDUzMTg2NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9hZG0xMDI2LmMKKysrIGIvZHJpdmVycy9od21vbi9hZG0xMDI2LmMKQEAgLTE3NSw3ICsxNzUsNyBAQAogICogdGhlc2UgbWFjcm9zIGFyZSBjYWxsZWQ6IGFyZ3VtZW50cyBtYXkgYmUgZXZhbHVhdGVkIG1vcmUgdGhhbiBvbmNlLgogICovCiAKLS8qIElOIGFyZSBzY2FsZWQgYWNvcmRpbmcgdG8gYnVpbHQtaW4gcmVzaXN0b3JzLiAgVGhlc2UgYXJlIHRoZQorLyogSU4gYXJlIHNjYWxlZCBhY2NvcmRpbmcgdG8gYnVpbHQtaW4gcmVzaXN0b3JzLiAgVGhlc2UgYXJlIHRoZQogICogICB2b2x0YWdlcyBjb3JyZXNwb25kaW5nIHRvIDMvNCBvZiBmdWxsIHNjYWxlICgxOTIgb3IgMHhjMCkKICAqICAgTk9URTogVGhlIC0xMlYgaW5wdXQgbmVlZHMgYW4gYWRkaXRpb25hbCBmYWN0b3IgdG8gYWNjb3VudAogICogICAgICBmb3IgdGhlIFZyZWYgcHVsbHVwIHJlc2lzdG9yLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9sbTg1LmMgYi9kcml2ZXJzL2h3bW9uL2xtODUuYwppbmRleCBjZjQ3ZTZlLi4yNTBkMDk5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL2xtODUuYworKysgYi9kcml2ZXJzL2h3bW9uL2xtODUuYwpAQCAtMTMwLDcgKzEzMCw3IEBACiAgICB0aGVzZSBtYWNyb3MgYXJlIGNhbGxlZDogYXJndW1lbnRzIG1heSBiZSBldmFsdWF0ZWQgbW9yZSB0aGFuIG9uY2UuCiAgKi8KIAotLyogSU4gYXJlIHNjYWxlZCBhY29yZGluZyB0byBidWlsdC1pbiByZXNpc3RvcnMgKi8KKy8qIElOIGFyZSBzY2FsZWQgYWNjb3JkaW5nIHRvIGJ1aWx0LWluIHJlc2lzdG9ycyAqLwogc3RhdGljIGNvbnN0IGludCBsbTg1X3NjYWxpbmdbXSA9IHsgIC8qIC4wMDEgVm9sdHMgKi8KIAkyNTAwLCAyMjUwLCAzMzAwLCA1MDAwLCAxMjAwMCwKIAkzMzAwLCAxNTAwLCAxODAwIC8qRU1DNkQxMDAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9sbTkwLmMgYi9kcml2ZXJzL2h3bW9uL2xtOTAuYwppbmRleCA4MTI3ODFjLi5jNDNiNGU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL2xtOTAuYworKysgYi9kcml2ZXJzL2h3bW9uL2xtOTAuYwpAQCAtMzU2LDcgKzM1Niw3IEBACiAJLyoKIAkgKiBUaGVyZSBpcyBhIHRyaWNrIGhlcmUuIFdlIGhhdmUgdG8gcmVhZCB0d28gcmVnaXN0ZXJzIHRvIGhhdmUgdGhlCiAJICogc2Vuc29yIHRlbXBlcmF0dXJlLCBidXQgd2UgaGF2ZSB0byBiZXdhcmUgYSBjb252ZXJzaW9uIGNvdWxkIG9jY3VyCi0JICogaW5iZXR3ZWVuIHRoZSByZWFkaW5ncy4gVGhlIGRhdGFzaGVldCBzYXlzIHdlIHNob3VsZCBlaXRoZXIgdXNlCisJICogYmV0d2VlbiB0aGUgcmVhZGluZ3MuIFRoZSBkYXRhc2hlZXQgc2F5cyB3ZSBzaG91bGQgZWl0aGVyIHVzZQogCSAqIHRoZSBvbmUtc2hvdCBjb252ZXJzaW9uIHJlZ2lzdGVyLCB3aGljaCB3ZSBkb24ndCB3YW50IHRvIGRvCiAJICogKGRpc2FibGVzIGhhcmR3YXJlIG1vbml0b3JpbmcpIG9yIG1vbml0b3IgdGhlIGJ1c3kgYml0LCB3aGljaCBpcwogCSAqIGltcG9zc2libGUgKHdlIGNhbid0IHJlYWQgdGhlIHZhbHVlcyBhbmQgbW9uaXRvciB0aGF0IGJpdCBhdCB0aGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vc2h0MTUuYyBiL2RyaXZlcnMvaHdtb24vc2h0MTUuYwppbmRleCAxYTljMzJkLi5mNGU2MTdhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL3NodDE1LmMKKysrIGIvZHJpdmVycy9od21vbi9zaHQxNS5jCkBAIC01Miw3ICs1Miw3IEBACiAjZGVmaW5lIFNIVDE1X1RTVQkJMTUwCS8qIGRhdGEgc2V0dXAgdGltZSAqLwogCiAvKioKLSAqIHN0cnVjdCBzaHQxNV90ZW1wcGFpciAtIGVsZW1lbnRzIG9mIHZvbHRhZ2UgZGVwZW5kYW50IHRlbXAgY2FsYworICogc3RydWN0IHNodDE1X3RlbXBwYWlyIC0gZWxlbWVudHMgb2Ygdm9sdGFnZSBkZXBlbmRlbnQgdGVtcCBjYWxjCiAgKiBAdmRkOglzdXBwbHkgdm9sdGFnZSBpbiBtaWNyb3ZvbHRzCiAgKiBAZDE6CQlzZWUgZGF0YSBzaGVldAogICovCkBAIC0yNTEsNyArMjUxLDcgQEAKIAllbmFibGVfaXJxKGdwaW9fdG9faXJxKGRhdGEtPnBkYXRhLT5ncGlvX2RhdGEpKTsKIAlpZiAoZ3Bpb19nZXRfdmFsdWUoZGF0YS0+cGRhdGEtPmdwaW9fZGF0YSkgPT0gMCkgewogCQlkaXNhYmxlX2lycV9ub3N5bmMoZ3Bpb190b19pcnEoZGF0YS0+cGRhdGEtPmdwaW9fZGF0YSkpOwotCQkvKiBPbmx5IHJlbGV2YW50IGlmIHRoZSBpbnRlcnJ1cHQgaGFzbid0IG9jY3VyZWQuICovCisJCS8qIE9ubHkgcmVsZXZhbnQgaWYgdGhlIGludGVycnVwdCBoYXNuJ3Qgb2NjdXJyZWQuICovCiAJCWlmICghYXRvbWljX3JlYWQoJmRhdGEtPmludGVycnVwdF9oYW5kbGVkKSkKIAkJCXNjaGVkdWxlX3dvcmsoJmRhdGEtPnJlYWRfd29yayk7CiAJfQpAQCAtNDUyLDcgKzQ1Miw3IEBACiAJCSovCiAJCWF0b21pY19zZXQoJmRhdGEtPmludGVycnVwdF9oYW5kbGVkLCAwKTsKIAkJZW5hYmxlX2lycShncGlvX3RvX2lycShkYXRhLT5wZGF0YS0+Z3Bpb19kYXRhKSk7Ci0JCS8qIElmIHN0aWxsIG5vdCBvY2N1cmVkIG9yIGFub3RoZXIgaGFuZGxlciBoYXMgYmVlbiBzY2hlZHVsZWQgKi8KKwkJLyogSWYgc3RpbGwgbm90IG9jY3VycmVkIG9yIGFub3RoZXIgaGFuZGxlciBoYXMgYmVlbiBzY2hlZHVsZWQgKi8KIAkJaWYgKGdwaW9fZ2V0X3ZhbHVlKGRhdGEtPnBkYXRhLT5ncGlvX2RhdGEpCiAJCSAgICB8fCBhdG9taWNfcmVhZCgmZGF0YS0+aW50ZXJydXB0X2hhbmRsZWQpKQogCQkJcmV0dXJuOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi90bXAxMDIuYyBiL2RyaXZlcnMvaHdtb24vdG1wMTAyLmMKaW5kZXggOTMxODdjMy4uNWJkMTk0OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi90bXAxMDIuYworKysgYi9kcml2ZXJzL2h3bW9uL3RtcDEwMi5jCkBAIC0xNjYsNyArMTY2LDcgQEAKIAogCWlmICghaTJjX2NoZWNrX2Z1bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAogCQkJCSAgICAgSTJDX0ZVTkNfU01CVVNfV09SRF9EQVRBKSkgewotCQlkZXZfZXJyKCZjbGllbnQtPmRldiwgImFkYXB0ZXIgZG9lc250IHN1cHBvcnQgU01CdXMgd29yZCAiCisJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiYWRhcHRlciBkb2Vzbid0IHN1cHBvcnQgU01CdXMgd29yZCAiCiAJCQkidHJhbnNhY3Rpb25zXG4iKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi93ODM3OTFkLmMgYi9kcml2ZXJzL2h3bW9uL3c4Mzc5MWQuYwppbmRleCA0MDBhODhiLi4xN2NmMWFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL3c4Mzc5MWQuYworKysgYi9kcml2ZXJzL2h3bW9uL3c4Mzc5MWQuYwpAQCAtNTU2LDcgKzU1Niw3IEBACiAKIC8qIE5vdGU6IHdlIHNhdmUgYW5kIHJlc3RvcmUgdGhlIGZhbiBtaW5pbXVtIGhlcmUsIGJlY2F1c2UgaXRzIHZhbHVlIGlzCiAgICBkZXRlcm1pbmVkIGluIHBhcnQgYnkgdGhlIGZhbiBkaXZpc29yLiAgVGhpcyBmb2xsb3dzIHRoZSBwcmluY2lwbGUgb2YKLSAgIGxlYXN0IHN1cHJpc2U7IHRoZSB1c2VyIGRvZXNuJ3QgZXhwZWN0IHRoZSBmYW4gbWluaW11bSB0byBjaGFuZ2UganVzdAorICAgbGVhc3Qgc3VycHJpc2U7IHRoZSB1c2VyIGRvZXNuJ3QgZXhwZWN0IHRoZSBmYW4gbWluaW11bSB0byBjaGFuZ2UganVzdAogICAgYmVjYXVzZSB0aGUgZGl2aXNvciBjaGFuZ2VkLiAqLwogc3RhdGljIHNzaXplX3Qgc3RvcmVfZmFuX2RpdihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAogCQkJCWNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi93ODM3OTJkLmMgYi9kcml2ZXJzL2h3bW9uL3c4Mzc5MmQuYwppbmRleCA2Mzg0MWY4Li5mM2U3MTMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL3c4Mzc5MmQuYworKysgYi9kcml2ZXJzL2h3bW9uL3c4Mzc5MmQuYwpAQCAtMjQ0LDcgKzI0NCw3IEBACiAjZGVmaW5lIFRFTVAxX1RPX1JFRyh2YWwpCShTRU5TT1JTX0xJTUlUKCgodmFsKSA8IDAgPyAodmFsKSsweDEwMCoxMDAwIFwKIAkJCQkJOiAodmFsKSkgLyAxMDAwLCAwLCAweGZmKSkKICNkZWZpbmUgVEVNUDFfRlJPTV9SRUcodmFsKQkoKCh2YWwpICYgMHg4MCA/ICh2YWwpLTB4MTAwIDogKHZhbCkpICogMTAwMCkKLS8qIGZvciB0ZW1wMiBhbmQgdGVtcDMsIGJlY2F1c2UgdGhleSBuZWVkIGFkZHRpb25hbCByZXNvbHV0aW9uICovCisvKiBmb3IgdGVtcDIgYW5kIHRlbXAzLCBiZWNhdXNlIHRoZXkgbmVlZCBhZGRpdGlvbmFsIHJlc29sdXRpb24gKi8KICNkZWZpbmUgVEVNUF9BRERfRlJPTV9SRUcodmFsMSwgdmFsMikgXAogCSgoKCh2YWwxKSAmIDB4ODAgPyAodmFsMSktMHgxMDAgXAogCQk6ICh2YWwxKSkgKiAxMDAwKSArICgodmFsMiAmIDB4ODApID8gNTAwIDogMCkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL3c4Mzc5My5jIGIvZHJpdmVycy9od21vbi93ODM3OTMuYwppbmRleCBlM2JkZWRmLi44NTRmOTExIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL3c4Mzc5My5jCisrKyBiL2RyaXZlcnMvaHdtb24vdzgzNzkzLmMKQEAgLTE5MjEsNyArMTkyMSw3IEBACiAJc3RydWN0IHc4Mzc5M19kYXRhICpkYXRhID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7CiAJaW50IGksIGo7CiAJLyoKLQkgICBUaGV5IGFyZSBzb21ld2hhdCAic3RhYmxlIiByZWdpc3RlcnMsIGFuZCB0byB1cGRhdGUgdGhlbSBldmVyeXRpbWUKKwkgICBUaGV5IGFyZSBzb21ld2hhdCAic3RhYmxlIiByZWdpc3RlcnMsIGFuZCB0byB1cGRhdGUgdGhlbSBldmVyeSB0aW1lCiAJICAgdGFrZXMgc28gbXVjaCB0aW1lLCBpdCdzIGp1c3Qgbm90IHdvcnRoeS4gVXBkYXRlIHRoZW0gaW4gYSBsb25nCiAJICAgaW50ZXJ2YWwgdG8gYXZvaWQgZXhjZXB0aW9uLgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvYWxnb3MvaTJjLWFsZ28tcGNhLmMgYi9kcml2ZXJzL2kyYy9hbGdvcy9pMmMtYWxnby1wY2EuYwppbmRleCAyYjlhOGY1Li40Y2E5Y2Y5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2kyYy9hbGdvcy9pMmMtYWxnby1wY2EuYworKysgYi9kcml2ZXJzL2kyYy9hbGdvcy9pMmMtYWxnby1wY2EuYwpAQCAtMzQzLDcgKzM0Myw3IEBACiAKIAlyZXQgPSBjdXJtc2c7CiAgb3V0OgotCURFQjEoIn19fSB0cmFuc2ZlcmVkICVkLyVkIG1lc3NhZ2VzLiAiCisJREVCMSgifX19IHRyYW5zZmVycmVkICVkLyVkIG1lc3NhZ2VzLiAiCiAJICAgICAic3RhdHVzIGlzICUjMDR4LiBjb250cm9sIGlzICUjMDR4XG4iLAogCSAgICAgY3VybXNnLCBudW0sIHBjYV9zdGF0dXMoYWRhcCksCiAJICAgICBwY2FfZ2V0X2NvbihhZGFwKSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFsaTE1MzUuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtYWxpMTUzNS5jCmluZGV4IDkwNmEzY2E1Li5kZDM2NDE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFsaTE1MzUuYworKysgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFsaTE1MzUuYwpAQCAtMjk1LDcgKzI5NSw3IEBACiAJfQogCiAJLyogVW5mb3J0dW5hdGVseSB0aGUgQUxJIFNNQiBjb250cm9sbGVyIG1hcHMgIm5vIHJlc3BvbnNlIiBhbmQgImJ1cwotCSAqIGNvbGxpc2lvbiIgaW50byBhIHNpbmdsZSBiaXQuIE5vIHJlcG9uc2UgaXMgdGhlIHVzdWFsIGNhc2Ugc28gZG9uJ3QKKwkgKiBjb2xsaXNpb24iIGludG8gYSBzaW5nbGUgYml0LiBObyByZXNwb25zZSBpcyB0aGUgdXN1YWwgY2FzZSBzbyBkb24ndAogCSAqIGRvIGEgcHJpbnRrLiAgVGhpcyBtZWFucyB0aGF0IGJ1cyBjb2xsaXNpb25zIGdvIHVucmVwb3J0ZWQuCiAJICovCiAJaWYgKHRlbXAgJiBBTEkxNTM1X1NUU19CVVNFUlIpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtYWxpMTV4My5jIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1hbGkxNXgzLmMKaW5kZXggYjE0ZjZkNi4uODNlOGE2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1hbGkxNXgzLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1hbGkxNXgzLmMKQEAgLTMxOCw3ICszMTgsNyBAQAogCiAJLyoKIAkgIFVuZm9ydHVuYXRlbHkgdGhlIEFMSSBTTUIgY29udHJvbGxlciBtYXBzICJubyByZXNwb25zZSIgYW5kICJidXMKLQkgIGNvbGxpc2lvbiIgaW50byBhIHNpbmdsZSBiaXQuIE5vIHJlcG9uc2UgaXMgdGhlIHVzdWFsIGNhc2Ugc28gZG9uJ3QKKwkgIGNvbGxpc2lvbiIgaW50byBhIHNpbmdsZSBiaXQuIE5vIHJlc3BvbnNlIGlzIHRoZSB1c3VhbCBjYXNlIHNvIGRvbid0CiAJICBkbyBhIHByaW50ay4KIAkgIFRoaXMgbWVhbnMgdGhhdCBidXMgY29sbGlzaW9ucyBnbyB1bnJlcG9ydGVkLgogCSovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWRhdmluY2kuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtZGF2aW5jaS5jCmluZGV4IDU3OTVjODMuLmE3NmQ4NWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtZGF2aW5jaS5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtZGF2aW5jaS5jCkBAIC0zNTUsNyArMzU1LDcgQEAKIAkvKgogCSAqIFdyaXRlIG1vZGUgcmVnaXN0ZXIgZmlyc3QgYXMgbmVlZGVkIGZvciBjb3JyZWN0IGJlaGF2aW91cgogCSAqIG9uIE9NQVAtTDEzOCwgYnV0IGRvbid0IHNldCBTVFQgeWV0IHRvIGF2b2lkIGEgcmFjZSB3aXRoIFhSRFkKLQkgKiBvY2N1cmluZyBiZWZvcmUgd2UgaGF2ZSBsb2FkZWQgRFhSCisJICogb2NjdXJyaW5nIGJlZm9yZSB3ZSBoYXZlIGxvYWRlZCBEWFIKIAkgKi8KIAlkYXZpbmNpX2kyY193cml0ZV9yZWcoZGV2LCBEQVZJTkNJX0kyQ19NRFJfUkVHLCBmbGFnKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1kZXNpZ253YXJlLmMgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWRlc2lnbndhcmUuYwppbmRleCBiNjY0ZWQ4Li5iN2E1MWM0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWRlc2lnbndhcmUuYworKysgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWRlc2lnbndhcmUuYwpAQCAtMTc4LDcgKzE3OCw3IEBACiAgKiBAbG9jazogcHJvdGVjdCB0aGlzIHN0cnVjdCBhbmQgSU8gcmVnaXN0ZXJzCiAgKiBAY2xrOiBpbnB1dCByZWZlcmVuY2UgY2xvY2sKICAqIEBjbWRfZXJyOiBydW4gdGltZSBoYWR3YXJlIGVycm9yIGNvZGUKLSAqIEBtc2dzOiBwb2ludHMgdG8gYW4gYXJyYXkgb2YgbWVzc2FnZXMgY3VycmVudGx5IGJlaW5nIHRyYW5zZmVyZWQKKyAqIEBtc2dzOiBwb2ludHMgdG8gYW4gYXJyYXkgb2YgbWVzc2FnZXMgY3VycmVudGx5IGJlaW5nIHRyYW5zZmVycmVkCiAgKiBAbXNnc19udW06IHRoZSBudW1iZXIgb2YgZWxlbWVudHMgaW4gbXNncwogICogQG1zZ193cml0ZV9pZHg6IHRoZSBlbGVtZW50IGluZGV4IG9mIHRoZSBjdXJyZW50IHR4IG1lc3NhZ2UgaW4gdGhlIG1zZ3MKICAqCWFycmF5CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWVsZWt0b3IuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtZWxla3Rvci5jCmluZGV4IGU1YjFhM2IuLjM3ZTJlODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtZWxla3Rvci5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtZWxla3Rvci5jCkBAIC0yMiw3ICsyMiw3IEBACiAvKiBXaXRoIHNvbWUgY2hhbmdlcyBmcm9tIEt5w7ZzdGkgTcOkbGtraSA8a21hbGtraUBjYy5odXQuZmk+IGFuZCBldmVuCiAgICBGcm9kbyBMb29pamFhcmQgPGZyb2RvbEBkZHMubmw+ICovCiAKLS8qIFBhcnRpYWx5IHJld3JpdGVuIGJ5IE9sZWcgSS4gVmRvdmlraW4gZm9yIG1tYXBwZWQgc3VwcG9ydCBvZgorLyogUGFydGlhbGx5IHJld3JpdGVuIGJ5IE9sZWcgSS4gVmRvdmlraW4gZm9yIG1tYXBwZWQgc3VwcG9ydCBvZgogICAgZm9yIEFscGhhIFByb2Nlc3NvciBJbmMuIFVQLTIwMDAoKykgYm9hcmRzICovCiAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtaTgwMS5jIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pODAxLmMKaW5kZXggZWQyZTBjNS4uNzJjMDQxNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pODAxLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pODAxLmMKQEAgLTk2LDcgKzk2LDcgQEAKICNkZWZpbmUgU01CSFNUQ0ZHX1NNQl9TTUlfRU4JMgogI2RlZmluZSBTTUJIU1RDRkdfSTJDX0VOCTQKIAotLyogQXV4aWxsYXJ5IGNvbnRyb2wgcmVnaXN0ZXIgYml0cywgSUNINCsgb25seSAqLworLyogQXV4aWxpYXJ5IGNvbnRyb2wgcmVnaXN0ZXIgYml0cywgSUNINCsgb25seSAqLwogI2RlZmluZSBTTUJBVVhDVExfQ1JDCQkxCiAjZGVmaW5lIFNNQkFVWENUTF9FMzJCCQkyCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtaWJtX2lpYy5jIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pYm1faWljLmMKaW5kZXggZTRmODhkYy4uM2MxMTBmYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pYm1faWljLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pYm1faWljLmMKQEAgLTQ5NCw3ICs0OTQsNyBAQAogCQlpZiAodW5saWtlbHkocmV0IDwgMCkpCiAJCQlicmVhazsKIAkJZWxzZSBpZiAodW5saWtlbHkocmV0ICE9IGNvdW50KSl7Ci0JCQlEQkcoIiVkOiB4ZmVyX2J5dGVzLCByZXF1ZXN0ZWQgJWQsIHRyYW5zZmVyZWQgJWRcbiIsCisJCQlEQkcoIiVkOiB4ZmVyX2J5dGVzLCByZXF1ZXN0ZWQgJWQsIHRyYW5zZmVycmVkICVkXG4iLAogCQkJCWRldi0+aWR4LCBjb3VudCwgcmV0KTsKIAogCQkJLyogSWYgaXQncyBub3QgYSBsYXN0IHBhcnQgb2YgeGZlciwgYWJvcnQgaXQgKi8KQEAgLTU5Myw3ICs1OTMsNyBAQAogCWlmICh1bmxpa2VseSgoaW5fOCgmaWljLT5leHRzdHMpICYgRVhUU1RTX0JDU19NQVNLKSAhPSBFWFRTVFNfQkNTX0ZSRUUpKXsKIAkJREJHKCIlZDogaWljX3hmZXIsIGJ1cyBpcyBub3QgZnJlZVxuIiwgZGV2LT5pZHgpOwogCi0JCS8qIFVzdWFsbHkgaXQgbWVhbnMgc29tZXRoaW5nIHNlcmlvdXMgaGFzIGhhcHBlbmQuCisJCS8qIFVzdWFsbHkgaXQgbWVhbnMgc29tZXRoaW5nIHNlcmlvdXMgaGFzIGhhcHBlbmVkLgogCQkgKiBXZSAqY2Fubm90KiBoYXZlIHVuZmluaXNoZWQgcHJldmlvdXMgdHJhbnNmZXIKIAkJICogc28gaXQgZG9lc24ndCBtYWtlIGFueSBzZW5zZSB0byB0cnkgdG8gc3RvcCBpdC4KIAkJICogUHJvYmFibHkgd2Ugd2VyZSBub3QgYWJsZSB0byByZWNvdmVyIGZyb20gdGhlCmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWludGVsLW1pZC5jIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1pbnRlbC1taWQuYwppbmRleCBjNzE0OTI3Li5lODI4YWM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWludGVsLW1pZC5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtaW50ZWwtbWlkLmMKQEAgLTE3MCw4ICsxNzAsOCBAQAogLyogUmF3IEludGVycnVwdCBTdGF0dXMgUmVnaXN0ZXIgKi8KICNkZWZpbmUgSUNfUkFXX0lOVFJfU1RBVAkweDM0CQkvKiBSZWFkIE9ubHkgKi8KICNkZWZpbmUgR0VOX0NBTEwJCSgxIDw8IDExKQkvKiBHZW5lcmFsIGNhbGwgKi8KLSNkZWZpbmUgU1RBUlRfREVUCQkoMSA8PCAxMCkJLyogKFJFKVNUQVJUIG9jY3VyZWQgKi8KLSNkZWZpbmUgU1RPUF9ERVQJCSgxIDw8IDkpCS8qIFNUT1Agb2NjdXJlZCAqLworI2RlZmluZSBTVEFSVF9ERVQJCSgxIDw8IDEwKQkvKiAoUkUpU1RBUlQgb2NjdXJyZWQgKi8KKyNkZWZpbmUgU1RPUF9ERVQJCSgxIDw8IDkpCS8qIFNUT1Agb2NjdXJyZWQgKi8KICNkZWZpbmUgQUNUSVZJVFkJCSgxIDw8IDgpCS8qIEJ1cyBidXN5ICovCiAjZGVmaW5lIFJYX0RPTkUJCQkoMSA8PCA3KQkvKiBOb3QgdXNlZCBpbiBNYXN0ZXIgbW9kZSAqLwogI2RlZmluZQlUWF9BQlJUCQkJKDEgPDwgNikJLyogVHJhbnNtaXQgQWJvcnQgKi8KQEAgLTM3NSw3ICszNzUsNyBAQAogICogSTJDIHNob3VsZCBiZSBkaXNhYmxlZCBwcmlvciB0byBvdGhlciByZWdpc3RlciBvcGVyYXRpb24uIElmIGZhaWxlZCwgYW4KICAqIGVycm5vIGlzIHJldHVybmVkLiBNYXNrIGFuZCBDbGVhciBhbGwgaW50ZXJycHRzLCB0aGlzIHNob3VsZCBiZSBkb25lIGF0CiAgKiBmaXJzdC4gIFNldCBjb21tb24gcmVnaXN0ZXJzIHdoaWNoIHdpbGwgbm90IGJlIG1vZGlmaWVkIGR1cmluZyBub3JtYWwKLSAqIHRyYW5zZmVycywgaW5jbHVkaW5nOiBjb250cm9sbCByZWdpc3RlciwgRklGTyB0aHJlc2hvbGQgYW5kIGNsb2NrIGZyZXEuCisgKiB0cmFuc2ZlcnMsIGluY2x1ZGluZzogY29udHJvbCByZWdpc3RlciwgRklGTyB0aHJlc2hvbGQgYW5kIGNsb2NrIGZyZXEuCiAgKiBDaGVjayBBUEIgZGF0YSB3aWR0aCBhdCBsYXN0LgogICovCiBzdGF0aWMgaW50IGludGVsX21pZF9pMmNfaHdpbml0KHN0cnVjdCBpbnRlbF9taWRfaTJjX3ByaXZhdGUgKmkyYykKQEAgLTQ1NSw3ICs0NTUsNyBAQAogICoKICAqIEJ5IHJlYWRpbmcgcmVnaXN0ZXIgSUNfVFhfQUJSVF9TT1VSQ0UsIHZhcmlvdXMgdHJhbnNmZXIgZXJyb3JzIGNhbiBiZQogICogZGlzdGluZ3VzaGVkLiBBdCBwcmVzZW50LCBubyBjaXJjdW1zdGFuY2VzIGhhdmUgYmVlbiBmb3VuZCBvdXQgdGhhdAotICogbXVsdGlwbGUgZXJyb3JzIHdvdWxkIGJlIG9jY3VyZWQgc2ltdXRhbmVvdXNseSwgc28gd2Ugc2ltcGx5IHVzZSB0aGUKKyAqIG11bHRpcGxlIGVycm9ycyB3b3VsZCBiZSBvY2N1cnJlZCBzaW11dGFuZW91c2x5LCBzbyB3ZSBzaW1wbHkgdXNlIHRoZQogICogcmVnaXN0ZXIgdmFsdWUgZGlyZWN0bHkuCiAgKgogICogQXQgbGFzdCB0aGUgZXJyb3IgYml0cyBhcmUgY2xlYXJlZC4gKE5vdGUgY2xlYXIgQUJSVF9TQllURV9OT1JTVFJUIGJpdCBuZWVkCkBAIC00NjksNyArNDY5LDcgQEAKIAogCS8qIFNpbmdsZSB0cmFuc2ZlciBlcnJvciBjaGVjazoKIAkgKiBBY2NvcmRpbmcgdG8gZGF0YWJvb2ssIFRYL1JYIEZJRk9zIHdvdWxkIGJlIGZsdXNoZWQgd2hlbgotCSAqIHRoZSBhYm9ydCBpbnRlcnJ1cHQgb2NjdXJlZC4KKwkgKiB0aGUgYWJvcnQgaW50ZXJydXB0IG9jY3VycmVkLgogCSAqLwogCWlmIChhYm9ydCAmIEFCUlRfTUFTVEVSX0RJUykKIAkJZGV2X2VycigmYWRhcC0+ZGV2LApAQCAtNTY5LDcgKzU2OSw3IEBACiAgKiBSZXR1cm4gVmFsdWVzOgogICogMAlpZiB0aGUgcmVhZCB0cmFuc2ZlciBzdWNjZWVkcwogICogLUVUSU1FRE9VVAlpZiB3ZSBjYW5ub3QgcmVhZCB0aGUgInJhdyIgaW50ZXJydXB0IHJlZ2lzdGVyCi0gKiAtRUlOVkFMCWlmIGEgdHJhbnNmZXIgYWJvcnQgb2NjdXJlZAorICogLUVJTlZBTAlpZiBhIHRyYW5zZmVyIGFib3J0IG9jY3VycmVkCiAgKgogICogRm9yIGV2ZXJ5IGJ5dGUsIGEgIldSSVRFIiBjb21tYW5kIHdpbGwgYmUgbG9hZGVkIGludG8gSUNfREFUQV9DTUQgcHJpb3IgdG8KICAqIGRhdGEgdHJhbnNmZXIuIFRoZSBhY3R1YWwgIndyaXRlIiBvcGVyYXRpb24gd2lsbCBiZSBwZXJmb3JtZWQgd2hlbiB0aGUKQEAgLTY5Nyw3ICs2OTcsNyBAQAogICogQG51bTogbnVtYmVyIG9mIGkyY19tc2cKICAqCiAgKiBSZXR1cm4gVmFsdWVzOgotICogKwkJbnVtYmVyIG9mIG1lc3NhZ2VzIHRyYW5zZmVyZWQKKyAqICsJCW51bWJlciBvZiBtZXNzYWdlcyB0cmFuc2ZlcnJlZAogICogLUVUSU1FRE9VVAlJZiBjYW5ub3QgZGlzYWJsZSBJMkMgY29udHJvbGxlciBvciByZWFkIElDX1NUQVRVUwogICogLUVJTlZBTAlJZiB0aGUgYWRkcmVzcyBpbiBpMmNfbXNnIGlzIGludmFsaWQKICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWlzY2guYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtaXNjaC5jCmluZGV4IGRkYzI1OGUuLjA2ODJmOGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtaXNjaC5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtaXNjaC5jCkBAIC0xNDEsNyArMTQxLDcgQEAKICAqIFRoaXMgaXMgdGhlIG1haW4gYWNjZXNzIGVudHJ5IGZvciBpMmMtc2NoIGFjY2VzcwogICogYWRhcCBpcyBpMmNfYWRhcHRlciBwb2ludGVyLCBhZGRyIGlzIHRoZSBpMmMgZGV2aWNlIGJ1cyBhZGRyZXNzLCByZWFkX3dyaXRlCiAgKiAoMCBmb3IgcmVhZCBhbmQgMSBmb3Igd3JpdGUpLCBzaXplIGlzIGkyYyB0cmFuc2FjdGlvbiB0eXBlIGFuZCBkYXRhIGlzIHRoZQotICogdW5pb24gb2YgdHJhbnNhY3Rpb24gZm9yIGRhdGEgdG8gYmUgdHJhbnNmZXJlZCBvciBkYXRhIHJlYWQgZnJvbSBidXMuCisgKiB1bmlvbiBvZiB0cmFuc2FjdGlvbiBmb3IgZGF0YSB0byBiZSB0cmFuc2ZlcnJlZCBvciBkYXRhIHJlYWQgZnJvbSBidXMuCiAgKiByZXR1cm4gMCBmb3Igc3VjY2VzcyBhbmQgb3RoZXJzIGZvciBmYWlsdXJlLgogICovCiBzdGF0aWMgczMyIHNjaF9hY2Nlc3Moc3RydWN0IGkyY19hZGFwdGVyICphZGFwLCB1MTYgYWRkciwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtbXhzLmMgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLW14cy5jCmluZGV4IGNhZjk2ZGMuLjdlNzhmN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtbXhzLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1teHMuYwpAQCAtMTQ5LDcgKzE0OSw3IEBACiAJICogV2UgaGF2ZSB0byBjb3B5IHRoZSBzbGF2ZSBhZGRyZXNzICh1OCkgYW5kIGJ1ZmZlciAoYXJiaXRyYXJ5IG51bWJlcgogCSAqIG9mIHU4KSBpbnRvIHRoZSBkYXRhIHJlZ2lzdGVyICh1MzIpLiBUbyBhY2hpZXZlIHRoYXQsIHRoZSB1OCBhcmUgcHV0CiAJICogaW50byB0aGUgTVNCcyBvZiAnZGF0YScgd2hpY2ggaXMgdGhlbiBzaGlmdGVkIGZvciB0aGUgbmV4dCB1OC4gV2hlbgotCSAqIGFwcm9wcmlhdGUsICdkYXRhJyBpcyB3cml0dGVuIHRvIE1YU19JMkNfREFUQS4gU28sIHRoZSBmaXJzdCB1MzIKKwkgKiBhcHByb3ByaWF0ZSwgJ2RhdGEnIGlzIHdyaXR0ZW4gdG8gTVhTX0kyQ19EQVRBLiBTbywgdGhlIGZpcnN0IHUzMgogCSAqIGxvb2tzIGxpa2UgdGhpczoKIAkgKgogCSAqICAzICAgICAgICAgIDIgICAgICAgICAgMSAgICAgICAgICAwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLW5vbWFkaWsuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtbm9tYWRpay5jCmluZGV4IDU5NGVkNTAuLmUxMGU1Y2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtbm9tYWRpay5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtbm9tYWRpay5jCkBAIC0xMjYsOSArMTI2LDkgQEAKIC8qKgogICogc3RydWN0IGkyY19ubWtfY2xpZW50IC0gY2xpZW50IHNwZWNpZmljIGRhdGEKICAqIEBzbGF2ZV9hZHI6IDctYml0IHNsYXZlIGFkZHJlc3MKLSAqIEBjb3VudDogbm8uIGJ5dGVzIHRvIGJlIHRyYW5zZmVyZWQKKyAqIEBjb3VudDogbm8uIGJ5dGVzIHRvIGJlIHRyYW5zZmVycmVkCiAgKiBAYnVmZmVyOiBjbGllbnQgZGF0YSBidWZmZXIKLSAqIEB4ZmVyX2J5dGVzOiBieXRlcyB0cmFuc2ZlcmVkIHRpbGwgbm93CisgKiBAeGZlcl9ieXRlczogYnl0ZXMgdHJhbnNmZXJyZWQgdGlsbCBub3cKICAqIEBvcGVyYXRpb246IGN1cnJlbnQgSTJDIG9wZXJhdGlvbgogICovCiBzdHJ1Y3QgaTJjX25ta19jbGllbnQgewpAQCAtMzMwLDcgKzMzMCw3IEBACiAJICogc2xzdSBkZWZpbmVzIHRoZSBkYXRhIHNldHVwIHRpbWUgYWZ0ZXIgU0NMIGNsb2NrCiAJICogc3RyZXRjaGluZyBpbiB0ZXJtcyBvZiBpMmMgY2xrIGN5Y2xlcy4gVGhlCiAJICogbmVlZGVkIHNldHVwIHRpbWUgZm9yIHRoZSB0aHJlZSBtb2RlcyBhcmUgMjUwbnMsCi0JICogMTAwbnMsIDEwbnMgcmVwZWN0aXZlbHkgdGh1cyBsZWFkaW5nIHRvIHRoZSB2YWx1ZXMKKwkgKiAxMDBucywgMTBucyByZXNwZWN0aXZlbHkgdGh1cyBsZWFkaW5nIHRvIHRoZSB2YWx1ZXMKIAkgKiBvZiAxNCwgNiwgMiBmb3IgYSA0OCBNSHogaTJjIGNsay4KIAkgKi8KIAl3cml0ZWwoZGV2LT5jZmcuc2xzdSA8PCAxNiwgZGV2LT52aXJ0YmFzZSArIEkyQ19TQ1IpOwpAQCAtMzY0LDcgKzM2NCw3IEBACiAJLyoKIAkgKiBzZXQgdGhlIHNwZWVkIG1vZGUuIEN1cnJlbnRseSB3ZSBzdXBwb3J0CiAJICogb25seSBzdGFuZGFyZCBhbmQgZmFzdCBtb2RlIG9mIG9wZXJhdGlvbgotCSAqIFRPRE8gLSBzdXBwb3J0IGZvciBmYXN0IG1vZGUgcGx1cyAodXB0byAxTWIvcykKKwkgKiBUT0RPIC0gc3VwcG9ydCBmb3IgZmFzdCBtb2RlIHBsdXMgKHVwIHRvIDFNYi9zKQogCSAqIGFuZCBoaWdoIHNwZWVkICh1cCB0byAzLjQgTWIvcykKIAkgKi8KIAlpZiAoZGV2LT5jZmcuc20gPiBJMkNfRlJFUV9NT0RFX0ZBU1QpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtczYwMDAuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtczYwMDAuYwppbmRleCBjYWRjMDIxLi5jYjVkMDFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLXM2MDAwLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zNjAwMC5jCkBAIC0zMTgsNyArMzE4LDcgQEAKIAlyYyA9IHJlcXVlc3RfaXJxKGlmYWNlLT5pcnEsIHM2aTJjX2ludGVycnVwdF9lbnRyeSwKIAkJCSBJUlFGX1NIQVJFRCwgZGV2LT5uYW1lLCBpZmFjZSk7CiAJaWYgKHJjKSB7Ci0JCWRldl9lcnIoJnBfYWRhcC0+ZGV2LCAiczZpMmM6IGNhbnQgZ2V0IElSUSAlZFxuIiwgaWZhY2UtPmlycSk7CisJCWRldl9lcnIoJnBfYWRhcC0+ZGV2LCAiczZpMmM6IGNhbid0IGdldCBJUlEgJWRcbiIsIGlmYWNlLT5pcnEpOwogCQlnb3RvIGVycl9jbGtfZGlzOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zdHUzMDAuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtc3R1MzAwLmMKaW5kZXggMjY2MTM1ZC4uOTk4Nzk2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zdHUzMDAuYworKysgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLXN0dTMwMC5jCkBAIC00OTcsNyArNDk3LDcgQEAKIAl1MzIgdmFsOwogCWludCBpID0gMDsKIAotCS8qIExvY2F0ZSB0aGUgYXByb3ByaWF0ZSBjbG9jayBzZXR0aW5nICovCisJLyogTG9jYXRlIHRoZSBhcHByb3ByaWF0ZSBjbG9jayBzZXR0aW5nICovCiAJd2hpbGUgKGkgPCBBUlJBWV9TSVpFKHN0dTMwMF9jbGt0YWJsZSkgLSAxICYmCiAJICAgICAgIHN0dTMwMF9jbGt0YWJsZVtpXS5yYXRlIDwgY2xrcmF0ZSkKIAkJaSsrOwpAQCAtNjQ0LDcgKzY0NCw3IEBACiAJcmV0ID0gc3R1MzAwX2F3YWl0X2V2ZW50KGRldiwgU1RVMzAwX0VWRU5UXzYpOwogCiAJLyoKLQkgKiBDbGVhciBhbnkgcGVuZGluZyBFVkVOVCA2IG5vIG1hdHRlciB3aGF0IGhhcHBlbmQgZHVyaW5nCisJICogQ2xlYXIgYW55IHBlbmRpbmcgRVZFTlQgNiBubyBtYXR0ZXIgd2hhdCBoYXBwZW5lZCBkdXJpbmcKIAkgKiBhd2FpdF9ldmVudC4KIAkgKi8KIAl2YWwgPSBzdHUzMDBfcjgoZGV2LT52aXJ0YmFzZSArIEkyQ19DUik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLXRlZ3JhLmMgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLXRlZ3JhLmMKaW5kZXggMzkyMWY2Ni4uYjRhYjM5YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy10ZWdyYS5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtdGVncmEuYwpAQCAtMzg2LDcgKzM4Niw3IEBACiAJCWR2Y193cml0ZWwoaTJjX2RldiwgRFZDX1NUQVRVU19JMkNfRE9ORV9JTlRSLCBEVkNfU1RBVFVTKTsKIAlyZXR1cm4gSVJRX0hBTkRMRUQ7CiBlcnI6Ci0JLyogQW4gZXJyb3Igb2NjdXJlZCwgbWFzayBhbGwgaW50ZXJydXB0cyAqLworCS8qIEFuIGVycm9yIG9jY3VycmVkLCBtYXNrIGFsbCBpbnRlcnJ1cHRzICovCiAJdGVncmFfaTJjX21hc2tfaXJxKGkyY19kZXYsIEkyQ19JTlRfTk9fQUNLIHwgSTJDX0lOVF9BUkJJVFJBVElPTl9MT1NUIHwKIAkJSTJDX0lOVF9QQUNLRVRfWEZFUl9DT01QTEVURSB8IEkyQ19JTlRfVFhfRklGT19EQVRBX1JFUSB8CiAJCUkyQ19JTlRfUlhfRklGT19EQVRBX1JFUSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLXhpaWMuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMteGlpYy5jCmluZGV4IDlmYmQ3ZTYuLmU5ZDVmZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMteGlpYy5jCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMteGlpYy5jCkBAIC0yMSw3ICsyMSw3IEBACiAgKiB0byB0aGUgYXV0b21vdGl2ZSBkZXZlbG9wbWVudCBib2FyZCBSdXNzZWxsdmlsbGUuIFRoZSBjb3B5cmlnaHQgaG9sZGVyCiAgKiBhcyBzZWVuIGluIHRoZSBoZWFkZXIgaXMgSW50ZWwgY29ycG9yYXRpb24uCiAgKiBNb2NlYW4gTGFib3JhdG9yaWVzIGZvcmtlZCBvZmYgdGhlIEdOVS9MaW51eCBwbGF0Zm9ybSB3b3JrIGludG8gYQotICogc2VwYXJhdGUgY29tcGFueSBjYWxsZWQgUGVsYWdpY29yZSBBQiwgd2hpY2ggY29tbWl0ZWQgdGhlIGNvZGUgdG8gdGhlCisgKiBzZXBhcmF0ZSBjb21wYW55IGNhbGxlZCBQZWxhZ2ljb3JlIEFCLCB3aGljaCBjb21taXR0ZWQgdGhlIGNvZGUgdG8gdGhlCiAgKiBrZXJuZWwuCiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvaTJjLWNvcmUuYyBiL2RyaXZlcnMvaTJjL2kyYy1jb3JlLmMKaW5kZXggZTVmNzZhMC4uNzBjMzBlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvaTJjLWNvcmUuYworKysgYi9kcml2ZXJzL2kyYy9pMmMtY29yZS5jCkBAIC0zNDgsNyArMzQ4LDcgQEAKIAogCiAvKiBUaGlzIGlzIGEgcGVybWlzc2l2ZSBhZGRyZXNzIHZhbGlkaXR5IGNoZWNrLCBJMkMgYWRkcmVzcyBtYXAgY29uc3RyYWludHMKLSAqIGFyZSBwdXJwb3NlZGx5IG5vdCBlbmZvcmNlZCwgZXhjZXB0IGZvciB0aGUgZ2VuZXJhbCBjYWxsIGFkZHJlc3MuICovCisgKiBhcmUgcHVycG9zZWx5IG5vdCBlbmZvcmNlZCwgZXhjZXB0IGZvciB0aGUgZ2VuZXJhbCBjYWxsIGFkZHJlc3MuICovCiBzdGF0aWMgaW50IGkyY19jaGVja19jbGllbnRfYWRkcl92YWxpZGl0eShjb25zdCBzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQogewogCWlmIChjbGllbnQtPmZsYWdzICYgSTJDX0NMSUVOVF9URU4pIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWRlL2N5ODJjNjkzLmMgYi9kcml2ZXJzL2lkZS9jeTgyYzY5My5jCmluZGV4IDkzODNmNjcuLjNiZTYwZGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL2N5ODJjNjkzLmMKKysrIGIvZHJpdmVycy9pZGUvY3k4MmM2OTMuYwpAQCAtNjcsNyArNjcsNyBAQAogCiAJLyoKIAkgKiBub3RlOiBiZWxvdyB3ZSBzZXQgdGhlIHZhbHVlIGZvciBCdXMgTWFzdGVyIElERSBUaW1lT3V0IFJlZ2lzdGVyCi0JICogSSdtIG5vdCBhYnNvbHV0bHkgc3VyZSB3aGF0IHRoaXMgZG9lcywgYnV0IGl0IHNvbHZlZCBteSBwcm9ibGVtCisJICogSSdtIG5vdCBhYnNvbHV0ZWx5IHN1cmUgd2hhdCB0aGlzIGRvZXMsIGJ1dCBpdCBzb2x2ZWQgbXkgcHJvYmxlbQogCSAqIHdpdGggSURFIERNQSBhbmQgc291bmQsIHNvIEkgbm93IGNhbiBwbGF5IHNvdW5kIGFuZCB3b3JrIHdpdGgKIAkgKiBteSBJREUgZHJpdmVyIGF0IHRoZSBzYW1lIHRpbWUgOi0pCiAJICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWRlL2lkZS1mbG9wcHkuYyBiL2RyaXZlcnMvaWRlL2lkZS1mbG9wcHkuYwppbmRleCA1NDA2YjZlLi41YTcwMmQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lkZS9pZGUtZmxvcHB5LmMKKysrIGIvZHJpdmVycy9pZGUvaWRlLWZsb3BweS5jCkBAIC0xMDcsNyArMTA3LDcgQEAKIHN0YXRpYyB2b2lkIGlkZV9mbG9wcHlfcmVwb3J0X2Vycm9yKHN0cnVjdCBpZGVfZGlza19vYmogKmZsb3BweSwKIAkJCQkgICAgc3RydWN0IGlkZV9hdGFwaV9wYyAqcGMpCiB7Ci0JLyogc3VwcmVzcyBlcnJvciBtZXNzYWdlcyByZXN1bHRpbmcgZnJvbSBNZWRpdW0gbm90IHByZXNlbnQgKi8KKwkvKiBzdXBwcmVzcyBlcnJvciBtZXNzYWdlcyByZXN1bHRpbmcgZnJvbSBNZWRpdW0gbm90IHByZXNlbnQgKi8KIAlpZiAoZmxvcHB5LT5zZW5zZV9rZXkgPT0gMHgwMiAmJgogCSAgICBmbG9wcHktPmFzYyAgICAgICA9PSAweDNhICYmCiAJICAgIGZsb3BweS0+YXNjcSAgICAgID09IDB4MDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9pZGUtdGFza2ZpbGUuYyBiL2RyaXZlcnMvaWRlL2lkZS10YXNrZmlsZS5jCmluZGV4IDM0Yjk4NzIuLjYwMGM4OWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL2lkZS10YXNrZmlsZS5jCisrKyBiL2RyaXZlcnMvaWRlL2lkZS10YXNrZmlsZS5jCkBAIC0yMDEsNyArMjAxLDcgQEAKIAl1OCBzdGF0OwogCiAJLyoKLQkgKiBMYXN0IHNlY3RvciB3YXMgdHJhbnNmZXJlZCwgd2FpdCB1bnRpbCBkZXZpY2UgaXMgcmVhZHkuICBUaGlzIGNhbgorCSAqIExhc3Qgc2VjdG9yIHdhcyB0cmFuc2ZlcnJlZCwgd2FpdCB1bnRpbCBkZXZpY2UgaXMgcmVhZHkuICBUaGlzIGNhbgogCSAqIHRha2UgdXAgdG8gNiBtcyBvbiBzb21lIEFUQVBJIGRldmljZXMsIHNvIHdlIHdpbGwgd2FpdCBtYXggMTAgbXMuCiAJICovCiAJZm9yIChyZXRyaWVzID0gMDsgcmV0cmllcyA8IDEwMDA7IHJldHJpZXMrKykgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZGUvcGlpeC5jIGIvZHJpdmVycy9pZGUvcGlpeC5jCmluZGV4IDFiZGNhNDkuLmI1OWQwNGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL3BpaXguYworKysgYi9kcml2ZXJzL2lkZS9waWl4LmMKQEAgLTgsOCArOCw4IEBACiAgKgogICogRG9jdW1lbnRhdGlvbjoKICAqCi0gKglQdWJsaWNhbGx5IGF2YWlsYWJsZSBmcm9tIEludGVsIHdlYiBzaXRlLiBFcnJhdGEgZG9jdW1lbnRhdGlvbgotICogaXMgYWxzbyBwdWJsaWNhbGx5IGF2YWlsYWJsZS4gQXMgYW4gYWlkZSB0byBhbnlvbmUgaGFja2luZyBvbiB0aGlzCisgKglQdWJsaWNseSBhdmFpbGFibGUgZnJvbSBJbnRlbCB3ZWIgc2l0ZS4gRXJyYXRhIGRvY3VtZW50YXRpb24KKyAqIGlzIGFsc28gcHVibGljbHkgYXZhaWxhYmxlLiBBcyBhbiBhaWRlIHRvIGFueW9uZSBoYWNraW5nIG9uIHRoaXMKICAqIGRyaXZlciB0aGUgbGlzdCBvZiBlcnJhdGEgdGhhdCBhcmUgcmVsZXZhbnQgaXMgYmVsb3cuZ29pbmcgYmFjayB0bwogICogUElJWDQuIE9sZGVyIGRldmljZSBkb2N1bWVudGF0aW9uIGlzIG5vdyBhIGJpdCB0cmlja3kgdG8gZmluZC4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9zaXM1NTEzLmMgYi9kcml2ZXJzL2lkZS9zaXM1NTEzLmMKaW5kZXggZGI3ZjRlNy4uNGEwMDIyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZGUvc2lzNTUxMy5jCisrKyBiL2RyaXZlcnMvaWRlL3NpczU1MTMuYwpAQCAtNTMsNyArNTMsNyBAQAogCiAjZGVmaW5lIERSVl9OQU1FICJzaXM1NTEzIgogCi0vKiByZWdpc3RlcnMgbGF5b3V0IGFuZCBpbml0IHZhbHVlcyBhcmUgY2hpcHNldCBmYW1pbHkgZGVwZW5kYW50ICovCisvKiByZWdpc3RlcnMgbGF5b3V0IGFuZCBpbml0IHZhbHVlcyBhcmUgY2hpcHNldCBmYW1pbHkgZGVwZW5kZW50ICovCiAKICNkZWZpbmUgQVRBXzE2CQkweDAxCiAjZGVmaW5lIEFUQV8zMwkJMHgwMgpAQCAtNDA2LDcgKzQwNiw3IEBACiAJCQkJCXBjaV9uYW1lKGRldikpOwogCQkJCWNoaXBzZXRfZmFtaWx5ID0gQVRBXzEzMzsKIAotCQkJCS8qIENoZWNrIGZvciA1NTEzIGNvbXBhYmlsaXR5IG1hcHBpbmcKKwkJCQkvKiBDaGVjayBmb3IgNTUxMyBjb21wYXRpYmlsaXR5IG1hcHBpbmcKIAkJCQkgKiBXZSBtdXN0IHVzZSB0aGlzLCBlbHNlIHRoZSBwb3J0IGVuYWJsZWQgY29kZSB3aWxsIGZhaWwsCiAJCQkJICogYXMgaXQgZXhwZWN0cyB0aGUgZW5hYmxlYml0cyBhdCAweDRhLgogCQkJCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZGUvdHJpZmxleC5jIGIvZHJpdmVycy9pZGUvdHJpZmxleC5jCmluZGV4IDc5NTM0NDcuLmU1M2ExYjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL3RyaWZsZXguYworKysgYi9kcml2ZXJzL2lkZS90cmlmbGV4LmMKQEAgLTIyLDcgKzIyLDcgQEAKICAqIExvb3NlbHkgYmFzZWQgb24gdGhlIHBpaXggJiBzdndrcyBkcml2ZXJzLgogICoKICAqIERvY3VtZW50YXRpb246Ci0gKglOb3QgcHVibGljYWxseSBhdmFpbGFibGUuCisgKglOb3QgcHVibGljbHkgYXZhaWxhYmxlLgogICovCiAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZGUvdmlhODJjeHh4LmMgYi9kcml2ZXJzL2lkZS92aWE4MmN4eHguYwppbmRleCBkMmEwOTk3Li5mNDZmNDljIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lkZS92aWE4MmN4eHguYworKysgYi9kcml2ZXJzL2lkZS92aWE4MmN4eHguYwpAQCAtMTQsNyArMTQsNyBAQAogICoJQW5kcmUgSGVkcmljawogICoKICAqIERvY3VtZW50YXRpb246Ci0gKglPYnNvbGV0ZSBkZXZpY2UgZG9jdW1lbnRhdGlvbiBwdWJsaWNhbGx5IGF2YWlsYWJsZSBmcm9tIHZpYS5jb20udHcKKyAqCU9ic29sZXRlIGRldmljZSBkb2N1bWVudGF0aW9uIHB1YmxpY2x5IGF2YWlsYWJsZSBmcm9tIHZpYS5jb20udHcKICAqCUN1cnJlbnQgZGV2aWNlIGRvY3VtZW50YXRpb24gYXZhaWxhYmxlIHVuZGVyIE5EQSBvbmx5CiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX2FlLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfYWUuYwppbmRleCA2MmFmNzQyLi4yNGY5ZTNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfYWUuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfYWUuYwpAQCAtMTU3LDcgKzE1Nyw3IEBACiAJaW50IHN0YXR1czsKIAogCS8qCi0JICogcmV0cmVpdmUgdGhlIG1lc3NhZ2UKKwkgKiByZXRyaWV2ZSB0aGUgbWVzc2FnZQogCSAqLwogCXdyID0gYzJfbXFfY29uc3VtZShtcSk7CiAJaWYgKCF3cikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9hbXNvMTEwMC9jMl9xcC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX3FwLmMKaW5kZXggZDhmNGJiOC4uMGQ3YjZmMjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9hbXNvMTEwMC9jMl9xcC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9hbXNvMTEwMC9jMl9xcC5jCkBAIC02MTIsNyArNjEyLDcgQEAKIAljMl91bmxvY2tfY3FzKHNlbmRfY3EsIHJlY3ZfY3EpOwogCiAJLyoKLQkgKiBEZXN0b3J5IHFwIGluIHRoZSBybmljLi4uCisJICogRGVzdHJveSBxcCBpbiB0aGUgcm5pYy4uLgogCSAqLwogCWRlc3Ryb3lfcXAoYzJkZXYsIHFwKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX3dyLmggYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfd3IuaAppbmRleCBjNjVmYmRkLi44ZDRiNGNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfd3IuaAorKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfd3IuaApAQCAtMTMxLDcgKzEzMSw3IEBACiAJICogICAgICAgICAgQWxsIHRoZSBwcmVjZWRpbmcgSURzIGFyZSBmaXhlZCwgYW5kIG11c3Qgbm90IGNoYW5nZS4KIAkgKiAgICAgICAgICBZb3UgY2FuIGFkZCBuZXcgSURzLCBidXQgbXVzdCBub3QgcmVtb3ZlIG9yIHJlb3JkZXIKIAkgKiAgICAgICAgICBhbnkgSURzLiBJZiB5b3UgZG8sIFlPVSB3aWxsIHJ1aW4gYW55IGhvcGUgb2YKLQkgKiAgICAgICAgICBjb21wYXRhYmlsaXR5IGJldHdlZW4gdmVyc2lvbnMuCisJICogICAgICAgICAgY29tcGF0aWJpbGl0eSBiZXR3ZWVuIHZlcnNpb25zLgogCSAqLwogCUNDV1JfTEFTVCwKIApAQCAtMjQyLDcgKzI0Miw3IEBACiAvKgogICogIHRvIGZpeCBidWcgMTgxNSB3ZSBkZWZpbmUgdGhlIG1heCBzaXplIGFsbG93YWJsZSBvZiB0aGUKICAqICB0ZXJtaW5hdGUgbWVzc2FnZSAocGVyIHRoZSBJRVRGIHNwZWMpLlJlZmVyIHRvIHRoZSBJRVRGCi0gKiAgcHJvdG9jYWwgc3BlY2lmaWNhdGlvbiwgc2VjdGlvbiAxMi4xLjYsIHBhZ2UgNjQpCisgKiAgcHJvdG9jb2wgc3BlY2lmaWNhdGlvbiwgc2VjdGlvbiAxMi4xLjYsIHBhZ2UgNjQpCiAgKiAgVGhlIG1lc3NhZ2UgaXMgcHJlZml4ZWQgYnkgMjAgdHlwZXMgb2YgRERQIGluZm8uCiAgKgogICogIFRoZW4gdGhlIG1lc3NhZ2UgaGFzIDYgYnl0ZXMgZm9yIHRoZSB0ZXJtaW5hdGUgY29udHJvbApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2RyaXZlci5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2RyaXZlci5jCmluZGV4IDQ3ZGI0YmYuLjU4YzBlNDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9kcml2ZXIuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZHJpdmVyLmMKQEAgLTIzOTIsNyArMjM5Miw3IEBACiAJLyoKIAkgKiBjbGVhciBTZXJkZXNFbmFibGUgYW5kIHR1cm4gdGhlIGxlZHMgb2ZmOyBkbyB0aGlzIGhlcmUgYmVjYXVzZQogCSAqIHdlIGFyZSB1bmxvYWRpbmcsIHNvIGRvbid0IGNvdW50IG9uIGludGVycnVwdHMgdG8gbW92ZSBhbG9uZwotCSAqIFR1cm4gdGhlIExFRHMgb2ZmIGV4cGxpY3RseSBmb3IgdGhlIHNhbWUgcmVhc29uLgorCSAqIFR1cm4gdGhlIExFRHMgb2ZmIGV4cGxpY2l0bHkgZm9yIHRoZSBzYW1lIHJlYXNvbi4KIAkgKi8KIAlkZC0+aXBhdGhfZl9xdWlldF9zZXJkZXMoZGQpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZmlsZV9vcHMuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9maWxlX29wcy5jCmluZGV4IDZkNGIyOWMuLmVlNzlhMmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9maWxlX29wcy5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9maWxlX29wcy5jCkBAIC0xOTcyLDcgKzE5NzIsNyBAQAogCSAqIDAgdG8gMS4gIFNvIGZvciB0aG9zZSBjaGlwcywgd2UgdHVybiBpdCBvZmYgYW5kIHRoZW4gYmFjayBvbi4KIAkgKiBUaGlzIHdpbGwgKHZlcnkgYnJpZWZseSkgYWZmZWN0IGFueSBvdGhlciBvcGVuIHBvcnRzLCBidXQgdGhlCiAJICogZHVyYXRpb24gaXMgdmVyeSBzaG9ydCwgYW5kIHRoZXJlZm9yZSBpc24ndCBhbiBpc3N1ZS4gIFdlCi0JICogZXhwbGljdGx5IHNldCB0aGUgaW4tbWVtb3J5IHRhaWwgY29weSB0byAwIGJlZm9yZWhhbmQsIHNvIHdlCisJICogZXhwbGljaXRseSBzZXQgdGhlIGluLW1lbW9yeSB0YWlsIGNvcHkgdG8gMCBiZWZvcmVoYW5kLCBzbyB3ZQogCSAqIGRvbid0IGhhdmUgdG8gd2FpdCB0byBiZSBzdXJlIHRoZSBETUEgdXBkYXRlIGhhcyBoYXBwZW5lZAogCSAqIChjaGlwIHJlc2V0cyBoZWFkL3RhaWwgdG8gMCBvbiB0cmFuc2l0aW9uIHRvIGVuYWJsZSkuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfaW5pdF9jaGlwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfaW5pdF9jaGlwLmMKaW5kZXggZmVmMGY0Mi4uN2MxZWViZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2luaXRfY2hpcC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9pbml0X2NoaXAuYwpAQCAtMzM1LDcgKzMzNSw3IEBACiAgKiBAZGQ6IHRoZSBpbmZpbmlwYXRoIGRldmljZQogICoKICAqIHNhbml0eSBjaGVjayBhdCBsZWFzdCBzb21lIG9mIHRoZSB2YWx1ZXMgYWZ0ZXIgcmVzZXQsIGFuZAotICogZW5zdXJlIG5vIHJlY2VpdmUgb3IgdHJhbnNtaXQgKGV4cGxpY3RseSwgaW4gY2FzZSByZXNldAorICogZW5zdXJlIG5vIHJlY2VpdmUgb3IgdHJhbnNtaXQgKGV4cGxpY2l0bHksIGluIGNhc2UgcmVzZXQKICAqIGZhaWxlZAogICovCiBzdGF0aWMgaW50IGluaXRfY2hpcF9yZXNldChzdHJ1Y3QgaXBhdGhfZGV2ZGF0YSAqZGQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdWQuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91ZC5jCmluZGV4IDc0MjA3MTUuLmU4YTJhOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91ZC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91ZC5jCkBAIC04Niw3ICs4Niw3IEBACiAJfQogCiAJLyoKLQkgKiBBIEdSSCBpcyBleHBlY3RlZCB0byBwcmVjZWVkIHRoZSBkYXRhIGV2ZW4gaWYgbm90CisJICogQSBHUkggaXMgZXhwZWN0ZWQgdG8gcHJlY2VkZSB0aGUgZGF0YSBldmVuIGlmIG5vdAogCSAqIHByZXNlbnQgb24gdGhlIHdpcmUuCiAJICovCiAJbGVuZ3RoID0gc3dxZS0+bGVuZ3RoOwpAQCAtNTE1LDcgKzUxNSw3IEBACiAJfQogCiAJLyoKLQkgKiBBIEdSSCBpcyBleHBlY3RlZCB0byBwcmVjZWVkIHRoZSBkYXRhIGV2ZW4gaWYgbm90CisJICogQSBHUkggaXMgZXhwZWN0ZWQgdG8gcHJlY2VkZSB0aGUgZGF0YSBldmVuIGlmIG5vdAogCSAqIHByZXNlbnQgb24gdGhlIHdpcmUuCiAJICovCiAJd2MuYnl0ZV9sZW4gPSB0bGVuICsgc2l6ZW9mKHN0cnVjdCBpYl9ncmgpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3VzZXJfc2RtYS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3VzZXJfc2RtYS5jCmluZGV4IGJlNzhmNjYuLmY1Y2IxM2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91c2VyX3NkbWEuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdXNlcl9zZG1hLmMKQEAgLTIzNiw3ICsyMzYsNyBAQAogCXJldHVybiAxICsgKChlcGFnZSAtIHNwYWdlKSA+PiBQQUdFX1NISUZUKTsKIH0KIAotLyogdHJ1bmNhdGUgbGVuZ3RoIHRvIHBhZ2UgYm91bmRyeSAqLworLyogdHJ1bmNhdGUgbGVuZ3RoIHRvIHBhZ2UgYm91bmRhcnkgKi8KIHN0YXRpYyBpbnQgaXBhdGhfdXNlcl9zZG1hX3BhZ2VfbGVuZ3RoKHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBsZW4pCiB7CiAJY29uc3QgdW5zaWduZWQgbG9uZyBvZmZzZXQgPSBhZGRyICYgflBBR0VfTUFTSzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2NtLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19jbS5jCmluZGV4IGNmYTNhMmIuLjMzYzdlZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2NtLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfY20uYwpAQCAtMTM5Nyw3ICsxMzk3LDcgQEAKIAkJY2xlYW51cF9yZXRyYW5zX2VudHJ5KGNtX25vZGUpOwogCQljbV9ub2RlLT5zdGF0ZSA9IE5FU19DTV9TVEFURV9DTE9TSU5HOwogCQlzZW5kX2FjayhjbV9ub2RlLCBOVUxMKTsKLQkJLyogV2FpdCBmb3IgQUNLIGFzIHRoaXMgaXMgc2ltdWx0YW5vdXMgY2xvc2UuLgorCQkvKiBXYWl0IGZvciBBQ0sgYXMgdGhpcyBpcyBzaW11bHRhbmVvdXMgY2xvc2UuLgogCQkqIEFmdGVyIHdlIHJlY2VpdmUgQUNLLCBkbyBub3Qgc2VuZCBhbnl0aGluZy4uCiAJCSogSnVzdCBybSB0aGUgbm9kZS4uIERvbmUuLiAqLwogCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2h3LmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19ody5jCmluZGV4IDA4YzE5NDguLjEwZDBhNWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2h3LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfaHcuYwpAQCAtODAsNyArODAsNyBAQAogCiAjaWZkZWYgQ09ORklHX0lORklOSUJBTkRfTkVTX0RFQlVHCiBzdGF0aWMgdW5zaWduZWQgY2hhciAqbmVzX2l3YXJwX3N0YXRlX3N0cltdID0gewotCSJOb24tRXhpc3RhbnQiLAorCSJOb24tRXhpc3RlbnQiLAogCSJJZGxlIiwKIAkiUlRTIiwKIAkiQ2xvc2luZyIsCkBAIC05MSw3ICs5MSw3IEBACiB9OwogCiBzdGF0aWMgdW5zaWduZWQgY2hhciAqbmVzX3RjcF9zdGF0ZV9zdHJbXSA9IHsKLQkiTm9uLUV4aXN0YW50IiwKKwkiTm9uLUV4aXN0ZW50IiwKIAkiQ2xvc2VkIiwKIAkiTGlzdGVuIiwKIAkiU1lOIFNlbnQiLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfbmljLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19uaWMuYwppbmRleCAyYzljMTkzLi5lOTZiOGZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19uaWMuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19uaWMuYwpAQCAtOTAyLDcgKzkwMiw3IEBACiAJCW5lc193cml0ZV9pbmRleGVkKG5lc2RldiwgTkVTX0lEWF9OSUNfVU5JQ0FTVF9BTEwsIG5pY19hY3RpdmUpOwogCX0KIAotCW5lc19kZWJ1ZyhORVNfREJHX05JQ19SWCwgIk51bWJlciBvZiBNQyBlbnRyaWVzID0gJWQsIFByb21pc2NvdXMgPSAlZCwgQWxsIE11bHRpY2FzdCA9ICVkLlxuIiwKKwluZXNfZGVidWcoTkVTX0RCR19OSUNfUlgsICJOdW1iZXIgb2YgTUMgZW50cmllcyA9ICVkLCBQcm9taXNjdW91cyA9ICVkLCBBbGwgTXVsdGljYXN0ID0gJWQuXG4iLAogCQkgIG1jX2NvdW50LCAhIShuZXRkZXYtPmZsYWdzICYgSUZGX1BST01JU0MpLAogCQkgICEhKG5ldGRldi0+ZmxhZ3MgJiBJRkZfQUxMTVVMVEkpKTsKIAlpZiAoIW1jX2FsbF9vbikgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWIuaCBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliLmgKaW5kZXggNzMyMjVlZS4uNzY5YTFkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWIuaAorKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYi5oCkBAIC02NTMsNyArNjUzLDcgQEAKIAogLyogZGV2aWNlIGRhdGEgc3RydWN0IG5vdyBjb250YWlucyBvbmx5ICJnZW5lcmFsIHBlci1kZXZpY2UiIGluZm8uCiAgKiBmaWVsZHMgcmVsYXRlZCB0byBhIHBoeXNpY2FsIElCIHBvcnQgYXJlIGluIGEgcWliX3Bwb3J0ZGF0YSBzdHJ1Y3QsCi0gKiBkZXNjcmliZWQgYWJvdmUpIHdoaWxlIGZpZWxkcyBvbmx5IHVzZWQgYnkgYSBwYXJ0aWN1YWxyIGNoaXAtdHlwZSBhcmUgaW4KKyAqIGRlc2NyaWJlZCBhYm92ZSkgd2hpbGUgZmllbGRzIG9ubHkgdXNlZCBieSBhIHBhcnRpY3VsYXIgY2hpcC10eXBlIGFyZSBpbgogICogYSBxaWJfY2hpcGRhdGEgc3RydWN0LCB3aG9zZSBjb250ZW50cyBhcmUgb3BhcXVlIHRvIHRoaXMgZmlsZS4KICAqLwogc3RydWN0IHFpYl9kZXZkYXRhIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2ZpbGVfb3BzLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9maWxlX29wcy5jCmluZGV4IDc1YmZhZDEuLjQwNmZjYTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2ZpbGVfb3BzLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfZmlsZV9vcHMuYwpAQCAtMTUzOSw3ICsxNTM5LDcgQEAKIAogCQkvKgogCQkgKiBJZiBwcm9jZXNzIGhhcyBOT1QgYWxyZWFkeSBzZXQgaXQncyBhZmZpbml0eSwgc2VsZWN0IGFuZAotCQkgKiByZXNlcnZlIGEgcHJvY2Vzc29yIGZvciBpdCwgYXMgYSByZW5kZXZvdXMgZm9yIGFsbAorCQkgKiByZXNlcnZlIGEgcHJvY2Vzc29yIGZvciBpdCwgYXMgYSByZW5kZXp2b3VzIGZvciBhbGwKIAkJICogdXNlcnMgb2YgdGhlIGRyaXZlci4gIElmIHRoZXkgZG9uJ3QgYWN0dWFsbHkgbGF0ZXIKIAkJICogc2V0IGFmZmluaXR5IHRvIHRoaXMgY3B1LCBvciBzZXQgaXQgdG8gc29tZSBvdGhlciBjcHUsCiAJCSAqIGl0IGp1c3QgbWVhbnMgdGhhdCBzb29uZXIgb3IgbGF0ZXIgd2UgZG9uJ3QgcmVjb21tZW5kCkBAIC0xNjU3LDcgKzE2NTcsNyBAQAogCSAqIDAgdG8gMS4gIFNvIGZvciB0aG9zZSBjaGlwcywgd2UgdHVybiBpdCBvZmYgYW5kIHRoZW4gYmFjayBvbi4KIAkgKiBUaGlzIHdpbGwgKHZlcnkgYnJpZWZseSkgYWZmZWN0IGFueSBvdGhlciBvcGVuIGN0eHRzLCBidXQgdGhlCiAJICogZHVyYXRpb24gaXMgdmVyeSBzaG9ydCwgYW5kIHRoZXJlZm9yZSBpc24ndCBhbiBpc3N1ZS4gIFdlCi0JICogZXhwbGljdGx5IHNldCB0aGUgaW4tbWVtb3J5IHRhaWwgY29weSB0byAwIGJlZm9yZWhhbmQsIHNvIHdlCisJICogZXhwbGljaXRseSBzZXQgdGhlIGluLW1lbW9yeSB0YWlsIGNvcHkgdG8gMCBiZWZvcmVoYW5kLCBzbyB3ZQogCSAqIGRvbid0IGhhdmUgdG8gd2FpdCB0byBiZSBzdXJlIHRoZSBETUEgdXBkYXRlIGhhcyBoYXBwZW5lZAogCSAqIChjaGlwIHJlc2V0cyBoZWFkL3RhaWwgdG8gMCBvbiB0cmFuc2l0aW9uIHRvIGVuYWJsZSkuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE2MTIwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE2MTIwLmMKaW5kZXggNzc0ZGVhOC4uN2RlNGI3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaWJhNjEyMC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2liYTYxMjAuYwpAQCAtMTc5OSw3ICsxNzk5LDcgQEAKIAkvKgogCSAqIEtlZXAgY2hpcCBmcm9tIGJlaW5nIGFjY2Vzc2VkIHVudGlsIHdlIGFyZSByZWFkeS4gIFVzZQogCSAqIHdyaXRlcSgpIGRpcmVjdGx5LCB0byBhbGxvdyB0aGUgd3JpdGUgZXZlbiB0aG91Z2ggUUlCX1BSRVNFTlQKLQkgKiBpc250JyBzZXQuCisJICogaXNuJ3QnIHNldC4KIAkgKi8KIAlkZC0+ZmxhZ3MgJj0gfihRSUJfSU5JVFRFRCB8IFFJQl9QUkVTRU5UKTsKIAlkZC0+aW50X2NvdW50ZXIgPSAwOyAvKiBzbyB3ZSBjaGVjayBpbnRlcnJ1cHRzIHdvcmsgYWdhaW4gKi8KQEAgLTIxNzEsNyArMjE3MSw3IEBACiAJCSAqIEluaXQgdGhlIGNvbnRleHQgcmVnaXN0ZXJzIGFsc287IGlmIHdlIHdlcmUKIAkJICogZGlzYWJsZWQsIHRhaWwgYW5kIGhlYWQgc2hvdWxkIGJvdGggYmUgemVybwogCQkgKiBhbHJlYWR5IGZyb20gdGhlIGVuYWJsZSwgYnV0IHNpbmNlIHdlIGRvbid0Ci0JCSAqIGtub3csIHdlIGhhdmUgdG8gZG8gaXQgZXhwbGljdGx5LgorCQkgKiBrbm93LCB3ZSBoYXZlIHRvIGRvIGl0IGV4cGxpY2l0bHkuCiAJCSAqLwogCQl2YWwgPSBxaWJfcmVhZF91cmVnMzIoZGQsIHVyX3JjdmVncmluZGV4dGFpbCwgY3R4dCk7CiAJCXFpYl93cml0ZV91cmVnKGRkLCB1cl9yY3ZlZ3JpbmRleGhlYWQsIHZhbCwgY3R4dCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE3MjIwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE3MjIwLmMKaW5kZXggZGU3OTlmMS4uNzRmZTAzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaWJhNzIyMC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2liYTcyMjAuYwpAQCAtMjExMSw3ICsyMTExLDcgQEAKIAkvKgogCSAqIEtlZXAgY2hpcCBmcm9tIGJlaW5nIGFjY2Vzc2VkIHVudGlsIHdlIGFyZSByZWFkeS4gIFVzZQogCSAqIHdyaXRlcSgpIGRpcmVjdGx5LCB0byBhbGxvdyB0aGUgd3JpdGUgZXZlbiB0aG91Z2ggUUlCX1BSRVNFTlQKLQkgKiBpc250JyBzZXQuCisJICogaXNuJ3QnIHNldC4KIAkgKi8KIAlkZC0+ZmxhZ3MgJj0gfihRSUJfSU5JVFRFRCB8IFFJQl9QUkVTRU5UKTsKIAlkZC0+aW50X2NvdW50ZXIgPSAwOyAvKiBzbyB3ZSBjaGVjayBpbnRlcnJ1cHRzIHdvcmsgYWdhaW4gKi8KQEAgLTI0NzksNyArMjQ3OSw3IEBACiAJCSAqIHdlIGNvbW1hbmQgdGhlIGxpbmsgZG93bi4gIEFzIHdpdGggd2lkdGgsIG9ubHkgd3JpdGUgdGhlCiAJCSAqIGFjdHVhbCByZWdpc3RlciBpZiB0aGUgbGluayBpcyBjdXJyZW50bHkgZG93biwgb3RoZXJ3aXNlCiAJCSAqIHRha2VzIGVmZmVjdCBvbiBuZXh0IGxpbmsgY2hhbmdlLiAgU2luY2Ugc2V0dGluZyBpcyBiZWluZwotCQkgKiBleHBsaWN0bHkgcmVxdWVzdGVkICh2aWEgTUFEIG9yIHN5c2ZzKSwgY2xlYXIgYXV0b25lZworCQkgKiBleHBsaWNpdGx5IHJlcXVlc3RlZCAodmlhIE1BRCBvciBzeXNmcyksIGNsZWFyIGF1dG9uZWcKIAkJICogZmFpbHVyZSBzdGF0dXMgaWYgc3BlZWQgYXV0b25lZyBpcyBlbmFibGVkLgogCQkgKi8KIAkJcHBkLT5saW5rX3NwZWVkX2VuYWJsZWQgPSB2YWw7CkBAIC0yNzc4LDcgKzI3NzgsNyBAQAogCQkgKiBJbml0IHRoZSBjb250ZXh0IHJlZ2lzdGVycyBhbHNvOyBpZiB3ZSB3ZXJlCiAJCSAqIGRpc2FibGVkLCB0YWlsIGFuZCBoZWFkIHNob3VsZCBib3RoIGJlIHplcm8KIAkJICogYWxyZWFkeSBmcm9tIHRoZSBlbmFibGUsIGJ1dCBzaW5jZSB3ZSBkb24ndAotCQkgKiBrbm93LCB3ZSBoYXZlIHRvIGRvIGl0IGV4cGxpY3RseS4KKwkJICoga25vdywgd2UgaGF2ZSB0byBkbyBpdCBleHBsaWNpdGx5LgogCQkgKi8KIAkJdmFsID0gcWliX3JlYWRfdXJlZzMyKGRkLCB1cl9yY3ZlZ3JpbmRleHRhaWwsIGN0eHQpOwogCQlxaWJfd3JpdGVfdXJlZyhkZCwgdXJfcmN2ZWdyaW5kZXhoZWFkLCB2YWwsIGN0eHQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaWJhNzMyMi5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaWJhNzMyMi5jCmluZGV4IDRhMmQyMWUuLjU1ZGUzY2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2liYTczMjIuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE3MzIyLmMKQEAgLTMyOTksNyArMzI5OSw3IEBACiAJLyoKIAkgKiBLZWVwIGNoaXAgZnJvbSBiZWluZyBhY2Nlc3NlZCB1bnRpbCB3ZSBhcmUgcmVhZHkuICBVc2UKIAkgKiB3cml0ZXEoKSBkaXJlY3RseSwgdG8gYWxsb3cgdGhlIHdyaXRlIGV2ZW4gdGhvdWdoIFFJQl9QUkVTRU5UCi0JICogaXNudCcgc2V0LgorCSAqIGlzbid0JyBzZXQuCiAJICovCiAJZGQtPmZsYWdzICY9IH4oUUlCX0lOSVRURUQgfCBRSUJfUFJFU0VOVCB8IFFJQl9CQURJTlRSKTsKIAlkZC0+ZmxhZ3MgfD0gUUlCX0RPSU5HX1JFU0VUOwpAQCAtMzcyNyw3ICszNzI3LDcgQEAKIAkJLyoKIAkJICogQXMgd2l0aCB3aWR0aCwgb25seSB3cml0ZSB0aGUgYWN0dWFsIHJlZ2lzdGVyIGlmIHRoZQogCQkgKiBsaW5rIGlzIGN1cnJlbnRseSBkb3duLCBvdGhlcndpc2UgdGFrZXMgZWZmZWN0IG9uIG5leHQKLQkJICogbGluayBjaGFuZ2UuICBTaW5jZSBzZXR0aW5nIGlzIGJlaW5nIGV4cGxpY3RseSByZXF1ZXN0ZWQKKwkJICogbGluayBjaGFuZ2UuICBTaW5jZSBzZXR0aW5nIGlzIGJlaW5nIGV4cGxpY2l0bHkgcmVxdWVzdGVkCiAJCSAqICh2aWEgTUFEIG9yIHN5c2ZzKSwgY2xlYXIgYXV0b25lZyBmYWlsdXJlIHN0YXR1cyBpZiBzcGVlZAogCQkgKiBhdXRvbmVnIGlzIGVuYWJsZWQuCiAJCSAqLwpAQCAtNDE2Myw3ICs0MTYzLDcgQEAKIAkJICogSW5pdCB0aGUgY29udGV4dCByZWdpc3RlcnMgYWxzbzsgaWYgd2Ugd2VyZQogCQkgKiBkaXNhYmxlZCwgdGFpbCBhbmQgaGVhZCBzaG91bGQgYm90aCBiZSB6ZXJvCiAJCSAqIGFscmVhZHkgZnJvbSB0aGUgZW5hYmxlLCBidXQgc2luY2Ugd2UgZG9uJ3QKLQkJICoga25vdywgd2UgaGF2ZSB0byBkbyBpdCBleHBsaWN0bHkuCisJCSAqIGtub3csIHdlIGhhdmUgdG8gZG8gaXQgZXhwbGljaXRseS4KIAkJICovCiAJCXZhbCA9IHFpYl9yZWFkX3VyZWczMihkZCwgdXJfcmN2ZWdyaW5kZXh0YWlsLCBjdHh0KTsKIAkJcWliX3dyaXRlX3VyZWcoZGQsIHVyX3JjdmVncmluZGV4aGVhZCwgdmFsLCBjdHh0KTsKQEAgLTc0ODMsNyArNzQ4Myw3IEBACiAJLyogICAgICAgQmFzZWxpbmUgV2FuZGVyIENvcnJlY3Rpb24gR2FpbiBbMTM6NC0wXSAobGVhdmUgYXMgZGVmYXVsdCkgKi8KIAkvKiAgICAgICBCYXNlbGluZSBXYW5kZXIgQ29ycmVjdGlvbiBHYWluIFszOjctNV0gKGxlYXZlIGFzIGRlZmF1bHQpICovCiAJLyogICAgICAgRGF0YSBSYXRlIFNlbGVjdCBbNTo3LTZdIChsZWF2ZSBhcyBkZWZhdWx0KSAqLwotCS8qICAgICAgIFJYIFBhcnJhbGVsIFdvcmQgV2lkdGggWzM6MTAtOF0gKGxlYXZlIGFzIGRlZmF1bHQpICovCisJLyogICAgICAgUlggUGFyYWxsZWwgV29yZCBXaWR0aCBbMzoxMC04XSAobGVhdmUgYXMgZGVmYXVsdCkgKi8KIAogCS8qIFJYIFJFU1QgKi8KIAkvKiAgICAgICBTaW5nbGUtIG9yIE11bHRpLWNoYW5uZWwgcmVzZXQgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2luaXQuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2luaXQuYwppbmRleCBmZmVmYjc4Li5hMDFmM2ZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pbml0LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaW5pdC5jCkBAIC0zNDYsNyArMzQ2LDcgQEAKICAqIEBkZDogdGhlIHFsb2dpY19pYiBkZXZpY2UKICAqCiAgKiBzYW5pdHkgY2hlY2sgYXQgbGVhc3Qgc29tZSBvZiB0aGUgdmFsdWVzIGFmdGVyIHJlc2V0LCBhbmQKLSAqIGVuc3VyZSBubyByZWNlaXZlIG9yIHRyYW5zbWl0IChleHBsaWN0bHksIGluIGNhc2UgcmVzZXQKKyAqIGVuc3VyZSBubyByZWNlaXZlIG9yIHRyYW5zbWl0IChleHBsaWNpdGx5LCBpbiBjYXNlIHJlc2V0CiAgKiBmYWlsZWQKICAqLwogc3RhdGljIGludCBpbml0X2FmdGVyX3Jlc2V0KHN0cnVjdCBxaWJfZGV2ZGF0YSAqZGQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9tYWQuaCBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX21hZC5oCmluZGV4IDE0N2FmZjkuLjc4NDBhYjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX21hZC5oCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX21hZC5oCkBAIC03Myw3ICs3Myw3IEBACiAKIAkJc3RydWN0IHsKIAkJCV9fYmUxNglyZXNlcnZlZDsKLQkJCV9fYmUxNglsaWQ7CQkvKiBMSUQgd2hlcmUgY2hhbmdlIG9jY3VyZWQgKi8KKwkJCV9fYmUxNglsaWQ7CQkvKiBMSUQgd2hlcmUgY2hhbmdlIG9jY3VycmVkICovCiAJCQl1OAlyZXNlcnZlZDI7CiAJCQl1OAlsb2NhbF9jaGFuZ2VzOwkvKiBsb3cgYml0IC0gbG9jYWwgY2hhbmdlcyAqLwogCQkJX19iZTMyCW5ld19jYXBfbWFzazsJLyogbmV3IGNhcGFiaWxpdHkgbWFzayAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfdHdzaS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfdHdzaS5jCmluZGV4IDZmMzFjYTUuLmRkZGU3MmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3R3c2kuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl90d3NpLmMKQEAgLTQxLDcgKzQxLDcgQEAKICAqIFFMb2dpY19JQiAiVHdvIFdpcmUgU2VyaWFsIEludGVyZmFjZSIgZHJpdmVyLgogICogT3JpZ2luYWxseSB3cml0dGVuIGZvciBhIG5vdC1xdWl0ZS1pMmMgc2VyaWFsIGVlcHJvbSwgd2hpY2ggaXMKICAqIHN0aWxsIHVzZWQgb24gc29tZSBzdXBwb3J0ZWQgYm9hcmRzLiBMYXRlciBib2FyZHMgaGF2ZSBhZGRlZCBhCi0gKiB2YXJpZXR5IG9mIG90aGVyIHVzZXMsIG1vc3QgYm9hcmQtc3BlY2lmaWMsIHNvIHRlaCBiaXQtYm9mZmluZworICogdmFyaWV0eSBvZiBvdGhlciB1c2VzLCBtb3N0IGJvYXJkLXNwZWNpZmljLCBzbyB0aGUgYml0LWJvZmZpbmcKICAqIHBhcnQgaGFzIGJlZW4gc3BsaXQgb2ZmIHRvIHRoaXMgZmlsZSwgd2hpbGUgdGhlIG90aGVyIHBhcnRzCiAgKiBoYXZlIGJlZW4gbW92ZWQgdG8gY2hpcC1zcGVjaWZpYyBmaWxlcy4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl91ZC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfdWQuYwppbmRleCA0YTUxZmQxLi44Mjg2MDlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl91ZC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3VkLmMKQEAgLTExNiw3ICsxMTYsNyBAQAogCX0KIAogCS8qCi0JICogQSBHUkggaXMgZXhwZWN0ZWQgdG8gcHJlY2VlZCB0aGUgZGF0YSBldmVuIGlmIG5vdAorCSAqIEEgR1JIIGlzIGV4cGVjdGVkIHRvIHByZWNlZGUgdGhlIGRhdGEgZXZlbiBpZiBub3QKIAkgKiBwcmVzZW50IG9uIHRoZSB3aXJlLgogCSAqLwogCWxlbmd0aCA9IHN3cWUtPmxlbmd0aDsKQEAgLTUyMCw3ICs1MjAsNyBAQAogCQlnb3RvIGRyb3A7CiAKIAkvKgotCSAqIEEgR1JIIGlzIGV4cGVjdGVkIHRvIHByZWNlZWQgdGhlIGRhdGEgZXZlbiBpZiBub3QKKwkgKiBBIEdSSCBpcyBleHBlY3RlZCB0byBwcmVjZWRlIHRoZSBkYXRhIGV2ZW4gaWYgbm90CiAJICogcHJlc2VudCBvbiB0aGUgd2lyZS4KIAkgKi8KIAl3Yy5ieXRlX2xlbiA9IHRsZW4gKyBzaXplb2Yoc3RydWN0IGliX2dyaCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl91c2VyX3NkbWEuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3VzZXJfc2RtYS5jCmluZGV4IDY2MjA4YmMuLjgyNDQyMDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3VzZXJfc2RtYS5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3VzZXJfc2RtYS5jCkBAIC0yMzksNyArMjM5LDcgQEAKIH0KIAogLyoKLSAqIFRydW5jYXRlIGxlbmd0aCB0byBwYWdlIGJvdW5kcnkuCisgKiBUcnVuY2F0ZSBsZW5ndGggdG8gcGFnZSBib3VuZGFyeS4KICAqLwogc3RhdGljIGludCBxaWJfdXNlcl9zZG1hX3BhZ2VfbGVuZ3RoKHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBsZW4pCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lzZXIvaXNjc2lfaXNlci5oIGIvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pc2VyL2lzY3NpX2lzZXIuaAppbmRleCBmMWRmMDE1Li4yZjAyYWIwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lzZXIvaXNjc2lfaXNlci5oCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXNlci9pc2NzaV9pc2VyLmgKQEAgLTkxLDcgKzkxLDcgQEAKICNkZWZpbmUgU0laRV80SwkoMVVMIDw8IFNISUZUXzRLKQogI2RlZmluZSBNQVNLXzRLCSh+KFNJWkVfNEstMSkpCiAKLQkJCQkJLyogc3VwcG9ydCB1cHRvIDUxMktCIGluIG9uZSBSRE1BICovCisJCQkJCS8qIHN1cHBvcnQgdXAgdG8gNTEyS0IgaW4gb25lIFJETUEgKi8KICNkZWZpbmUgSVNDU0lfSVNFUl9TR19UQUJMRVNJWkUgICAgICAgICAoMHg4MDAwMCA+PiBTSElGVF80SykKICNkZWZpbmUgSVNFUl9ERUZfQ01EX1BFUl9MVU4JCTEyOAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2pveWRldi5jIGIvZHJpdmVycy9pbnB1dC9qb3lkZXYuYwppbmRleCAzMTgyYzljLi41Njg4YjVjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2pveWRldi5jCisrKyBiL2RyaXZlcnMvaW5wdXQvam95ZGV2LmMKQEAgLTc1OCw3ICs3NTgsNyBAQAogfQogCiAvKgotICogTWFyayBkZXZpY2Ugbm9uLWV4aXN0YW50LiBUaGlzIGRpc2FibGVzIHdyaXRlcywgaW9jdGxzIGFuZAorICogTWFyayBkZXZpY2Ugbm9uLWV4aXN0ZW50LiBUaGlzIGRpc2FibGVzIHdyaXRlcywgaW9jdGxzIGFuZAogICogcHJldmVudHMgbmV3IHVzZXJzIGZyb20gb3BlbmluZyB0aGUgZGV2aWNlLiBBbHJlYWR5IHBvc3RlZAogICogYmxvY2tpbmcgcmVhZHMgd2lsbCBzdGF5LCBob3dldmVyIG5ldyBvbmVzIHdpbGwgZmFpbC4KICAqLwpAQCAtNzc3LDcgKzc3Nyw3IEBACiAJam95ZGV2X2hhbmd1cChqb3lkZXYpOwogCWpveWRldl9yZW1vdmVfY2hyZGV2KGpveWRldik7CiAKLQkvKiBqb3lkZXYgaXMgbWFya2VkIGRlYWQgc28gbm9vbmUgZWxzZSBhY2Nlc3NlcyBqb3lkZXYtPm9wZW4gKi8KKwkvKiBqb3lkZXYgaXMgbWFya2VkIGRlYWQgc28gbm8gb25lIGVsc2UgYWNjZXNzZXMgam95ZGV2LT5vcGVuICovCiAJaWYgKGpveWRldi0+b3BlbikKIAkJaW5wdXRfY2xvc2VfZGV2aWNlKGhhbmRsZSk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2pveXN0aWNrL2EzZC5jIGIvZHJpdmVycy9pbnB1dC9qb3lzdGljay9hM2QuYwppbmRleCBkMjU5YjQxLi4xNjM5YWIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2pveXN0aWNrL2EzZC5jCisrKyBiL2RyaXZlcnMvaW5wdXQvam95c3RpY2svYTNkLmMKQEAgLTMsNyArMyw3IEBACiAgKi8KIAogLyoKLSAqIEZQLUdhbWluZyBBc3Nhc2luIDNEIGpveXN0aWNrIGRyaXZlciBmb3IgTGludXgKKyAqIEZQLUdhbWluZyBBc3Nhc3NpbiAzRCBqb3lzdGljayBkcml2ZXIgZm9yIExpbnV4CiAgKi8KIAogLyoKQEAgLTM0LDcgKzM0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgogI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4KIAotI2RlZmluZSBEUklWRVJfREVTQwkiRlAtR2FtaW5nIEFzc2FzaW4gM0Qgam95c3RpY2sgZHJpdmVyIgorI2RlZmluZSBEUklWRVJfREVTQwkiRlAtR2FtaW5nIEFzc2Fzc2luIDNEIGpveXN0aWNrIGRyaXZlciIKIAogTU9EVUxFX0FVVEhPUigiVm9qdGVjaCBQYXZsaWsgPHZvanRlY2hAdWN3LmN6PiIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKERSSVZFUl9ERVNDKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvZGF2aW5jaV9rZXlzY2FuLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2RhdmluY2lfa2V5c2Nhbi5jCmluZGV4IGE5MWVlOTQuLmNkODlkMTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvZGF2aW5jaV9rZXlzY2FuLmMKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9kYXZpbmNpX2tleXNjYW4uYwpAQCAtNSw3ICs1LDcgQEAKICAqCiAgKiBBdXRob3I6IE1pZ3VlbCBBZ3VpbGFyIDxtaWd1ZWwuYWd1aWxhckByaWRnZXJ1bi5jb20+CiAgKgotICogSW50aWFsIENvZGU6IFNhbmRlZXAgUGF1bHJhaiA8cy1wYXVscmFqQHRpLmNvbT4KKyAqIEluaXRpYWwgQ29kZTogU2FuZGVlcCBQYXVscmFqIDxzLXBhdWxyYWpAdGkuY29tPgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9taXNjL2FkeGwzNHguYyBiL2RyaXZlcnMvaW5wdXQvbWlzYy9hZHhsMzR4LmMKaW5kZXggZGU1OTAwZC4uMTQ0ZGRiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9taXNjL2FkeGwzNHguYworKysgYi9kcml2ZXJzL2lucHV0L21pc2MvYWR4bDM0eC5jCkBAIC03MTYsNyArNzE2LDcgQEAKIAlwZGF0YSA9IGRldi0+cGxhdGZvcm1fZGF0YTsKIAlpZiAoIXBkYXRhKSB7CiAJCWRldl9kYmcoZGV2LAotCQkJIk5vIHBsYXRmcm9tIGRhdGE6IFVzaW5nIGRlZmF1bHQgaW5pdGlhbGl6YXRpb25cbiIpOworCQkJIk5vIHBsYXRmb3JtIGRhdGE6IFVzaW5nIGRlZmF1bHQgaW5pdGlhbGl6YXRpb25cbiIpOwogCQlwZGF0YSA9ICZhZHhsMzR4X2RlZmF1bHRfaW5pdDsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbWlzYy9rZXlzcGFuX3JlbW90ZS5jIGIvZHJpdmVycy9pbnB1dC9taXNjL2tleXNwYW5fcmVtb3RlLmMKaW5kZXggYTkzYzUyNS4uZmM2MjI1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9taXNjL2tleXNwYW5fcmVtb3RlLmMKKysrIGIvZHJpdmVycy9pbnB1dC9taXNjL2tleXNwYW5fcmVtb3RlLmMKQEAgLTMxMiw3ICszMTIsNyBAQAogCQkJcmVtb3RlLT5kYXRhLnRlc3RlciA9IHJlbW90ZS0+ZGF0YS50ZXN0ZXIgPj4gNTsKIAkJCXJlbW90ZS0+ZGF0YS5iaXRzX2xlZnQgLT0gNTsKIAkJfSBlbHNlIHsKLQkJCWVycigiQmFkIG1lc3NhZ2UgcmVjaWV2ZWQsIG5vIHN0b3AgYml0IGZvdW5kLlxuIik7CisJCQllcnIoIkJhZCBtZXNzYWdlIHJlY2VpdmVkLCBubyBzdG9wIGJpdCBmb3VuZC5cbiIpOwogCQl9CiAKIAkJZGV2X2RiZygmcmVtb3RlLT51ZGV2LT5kZXYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L21pc2Mvd2lzdHJvbl9idG5zLmMgYi9kcml2ZXJzL2lucHV0L21pc2Mvd2lzdHJvbl9idG5zLmMKaW5kZXggMTI1MDFkZS4uNTJiNDE5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9taXNjL3dpc3Ryb25fYnRucy5jCisrKyBiL2RyaXZlcnMvaW5wdXQvbWlzYy93aXN0cm9uX2J0bnMuYwpAQCAtMjc0LDcgKzI3NCw3IEBACiAJeyBLRV9CTFVFVE9PVEgsIDB4MzAgfSwgICAgICAgICAgICAgICAgICAgICAgLyogRm4rRjEwICovCiAJeyBLRV9LRVksICAgICAgIDB4MzEsIHtLRVlfTUFJTH0gfSwgICAgICAgICAgLyogbWFpbCBidXR0b24gKi8KIAl7IEtFX0tFWSwgICAgICAgMHgzNiwge0tFWV9XV1d9IH0sICAgICAgICAgICAvKiB3d3cgYnV0dG9uICovCi0JeyBLRV9XSUZJLCAgICAgIDB4NzggfSwgICAgICAgICAgICAgICAgICAgICAgLyogc2F0ZWxpdGUgZGlzaCBidXR0b24gKi8KKwl7IEtFX1dJRkksICAgICAgMHg3OCB9LCAgICAgICAgICAgICAgICAgICAgICAvKiBzYXRlbGxpdGUgZGlzaCBidXR0b24gKi8KIAl7IEtFX0VORCwgICAgICAgMCB9CiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L21vdXNlL2JjbTU5NzQuYyBiL2RyaXZlcnMvaW5wdXQvbW91c2UvYmNtNTk3NC5jCmluZGV4IDNhZWFkOTEuLjMxMjY5ODMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbW91c2UvYmNtNTk3NC5jCisrKyBiL2RyaXZlcnMvaW5wdXQvbW91c2UvYmNtNTk3NC5jCkBAIC02MzksNyArNjM5LDcgQEAKICAqIGRldmljZSwgcmVzdWx0aW5nIGluIHRyYWNrcGFkIG1hbGZ1bmN0aW9uIHVuZGVyIGNlcnRhaW4KICAqIGNpcmN1bXN0YW5jZXMuIFRvIGdldCBhcm91bmQgdGhpcyBwcm9ibGVtLCB0aGVyZSBpcyBhdCBsZWFzdCBvbmUKICAqIGV4YW1wbGUgdGhhdCB1dGlsaXplcyB0aGUgVVNCX1FVSVJLX1JFU0VUX1JFU1VNRSBxdWlyayBpbiBvcmRlciB0bwotICogcmVjaWV2ZSBhIHJlc2V0X3Jlc3VtZSByZXF1ZXN0IHJhdGhlciB0aGFuIHRoZSBub3JtYWwgcmVzdW1lLgorICogcmVjZWl2ZSBhIHJlc2V0X3Jlc3VtZSByZXF1ZXN0IHJhdGhlciB0aGFuIHRoZSBub3JtYWwgcmVzdW1lLgogICogU2luY2UgdGhlIGltcGxlbWVudGF0aW9uIG9mIHJlc2V0X3Jlc3VtZSBpcyBlcXVhbCB0byBtb2RlIHN3aXRjaAogICogcGx1cyBzdGFydF90cmFmZmljLCBpdCBzZWVtcyBlYXNpZXIgdG8gYWx3YXlzIGRvIHRoZSBzd2l0Y2ggd2hlbgogICogc3RhcnRpbmcgdHJhZmZpYyBvbiB0aGUgZGV2aWNlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9tb3VzZS9zeW5hcHRpY3NfaTJjLmMgYi9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljc19pMmMuYwppbmRleCBmNmFhMjZkLi5jYmEzYzg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljc19pMmMuYworKysgYi9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljc19pMmMuYwpAQCAtNDYyLDcgKzQ2Miw3IEBACiAJICogV2hpbGUgaW50ZXJydXB0IGRyaXZlbiwgdGhlcmUgaXMgbm8gcmVhbCBuZWVkIHRvIHBvbGwgdGhlIGRldmljZS4KIAkgKiBCdXQgdG91Y2hwYWRzIGFyZSB2ZXJ5IHNlbnNpdGl2ZSwgc28gdGhlcmUgY291bGQgYmUgZXJyb3JzCiAJICogcmVsYXRlZCB0byBwaHlzaWNhbCBlbnZpcm9ubWVudCBhbmQgdGhlIGF0dGVudGlvbiBsaW5lIGlzbid0Ci0JICogbmVjY2VzYXJpbHkgYXNzZXJ0ZWQuIEluIHN1Y2ggY2FzZSB3ZSBjYW4gbG9zZSB0aGUgdG91Y2hwYWQuCisJICogbmVjZXNzYXJpbHkgYXNzZXJ0ZWQuIEluIHN1Y2ggY2FzZSB3ZSBjYW4gbG9zZSB0aGUgdG91Y2hwYWQuCiAJICogV2UgcG9sbCB0aGUgZGV2aWNlIG9uY2UgaW4gVEhSRUFEX0lSUV9TTEVFUF9TRUNTIGFuZAogCSAqIGlmIGVycm9yIGlzIGRldGVjdGVkLCB3ZSB0cnkgdG8gcmVzZXQgYW5kIHJlY29uZmlndXJlIHRoZSB0b3VjaHBhZC4KIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbW91c2UvdnN4eHhhYS5jIGIvZHJpdmVycy9pbnB1dC9tb3VzZS92c3h4eGFhLmMKaW5kZXggYmYyYzBjOC4uZWI5YTNjZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9tb3VzZS92c3h4eGFhLmMKKysrIGIvZHJpdmVycy9pbnB1dC9tb3VzZS92c3h4eGFhLmMKQEAgLTMzNCw3ICszMzQsNyBAQAogCSAqIE06IG1hbnVmYWN0dXJlciBsb2NhdGlvbiBjb2RlCiAJICogUjogcmV2aXNpb24gY29kZQogCSAqIEU6IEVycm9yIGNvZGUuIElmIGl0J3MgaW4gdGhlIHJhbmdlIG9mIDB4MDAuLjB4MWYsIG9ubHkgc29tZQotCSAqICAgIG1pbm9yIHByb2JsZW0gb2NjdXJlZC4gRXJyb3JzID49IDB4MjAgYXJlIGNvbnNpZGVyZWQgYmFkCisJICogICAgbWlub3IgcHJvYmxlbSBvY2N1cnJlZC4gRXJyb3JzID49IDB4MjAgYXJlIGNvbnNpZGVyZWQgYmFkCiAJICogICAgYW5kIHRoZSBkZXZpY2UgbWF5IG5vdCB3b3JrIHByb3Blcmx5Li4uCiAJICogRDogPDAwMTA+ID09IG1vdXNlLCA8MDEwMD4gPT0gdGFibGV0CiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L3NlcmlvL2hwX3NkYy5jIGIvZHJpdmVycy9pbnB1dC9zZXJpby9ocF9zZGMuYwppbmRleCA4YzBiNTFjLi40MjIwNjIwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3NlcmlvL2hwX3NkYy5jCisrKyBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vaHBfc2RjLmMKQEAgLTk1NSw3ICs5NTUsNyBAQAogCUlOSVRfREVMQVlFRF9XT1JLKCZtb2R1bGVsb2FkZXJfd29yaywgcmVxdWVzdF9tb2R1bGVfZGVsYXllZCk7CiAKIAlyZXQgPSBocF9zZGNfaW5pdCgpOwotCS8qIGFmdGVyIHN1Y2Nlc3NmdWxsIGluaXRpYWxpemF0aW9uIGdpdmUgU0RDIHNvbWUgdGltZSB0byBzZXR0bGUKKwkvKiBhZnRlciBzdWNjZXNzZnVsIGluaXRpYWxpemF0aW9uIGdpdmUgU0RDIHNvbWUgdGltZSB0byBzZXR0bGUKIAkgKiBhbmQgdGhlbiBsb2FkIHRoZSBocF9zZGNfbWxjIHVwcGVyIGxheWVyIGRyaXZlciAqLwogCWlmICghcmV0KQogCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJm1vZHVsZWxvYWRlcl93b3JrLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9zZXJpby94aWxpbnhfcHMyLmMgYi9kcml2ZXJzL2lucHV0L3NlcmlvL3hpbGlueF9wczIuYwppbmRleCA3NTQwYmFmLi44MGJhYTUzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3NlcmlvL3hpbGlueF9wczIuYworKysgYi9kcml2ZXJzL2lucHV0L3NlcmlvL3hpbGlueF9wczIuYwpAQCAtMjI1LDcgKzIyNSw3IEBACiAvKioKICAqIHhwczJfb2ZfcHJvYmUgLSBwcm9iZSBtZXRob2QgZm9yIHRoZSBQUy8yIGRldmljZS4KICAqIEBvZl9kZXY6CXBvaW50ZXIgdG8gT0YgZGV2aWNlIHN0cnVjdHVyZQotICogQG1hdGNoOglwb2ludGVyIHRvIHRoZSBzdHVjdHVyZSB1c2VkIGZvciBtYXRjaGluZyBhIGRldmljZQorICogQG1hdGNoOglwb2ludGVyIHRvIHRoZSBzdHJ1Y3R1cmUgdXNlZCBmb3IgbWF0Y2hpbmcgYSBkZXZpY2UKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIHByb2JlcyB0aGUgUFMvMiBkZXZpY2UgaW4gdGhlIGRldmljZSB0cmVlLgogICogSXQgaW5pdGlhbGl6ZXMgdGhlIGRyaXZlciBkYXRhIHN0cnVjdHVyZSBhbmQgdGhlIGhhcmR3YXJlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9pbnRlbC1taWQtdG91Y2guYyBiL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vaW50ZWwtbWlkLXRvdWNoLmMKaW5kZXggYzAzMDdiMi4uNjZjOTZiZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9pbnRlbC1taWQtdG91Y2guYworKysgYi9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL2ludGVsLW1pZC10b3VjaC5jCkBAIC01NDIsNyArNTQyLDcgQEAKIAkgKiBBREMgcG93ZXIgb24sIHN0YXJ0LCBlbmFibGUgUEVOREVUIGFuZCBzZXQgbG9vcCBkZWxheQogCSAqIEFEQyBsb29wIGRlbGF5IGlzIHNldCB0byA0LjUgbXMgYXBwcm94aW1hdGVseQogCSAqIExvb3AgZGVsYXkgbW9yZSB0aGFuIHRoaXMgcmVzdWx0cyBpbiBqaXR0ZXIgaW4gYWRjIHJlYWRpbmdzCi0JICogU2V0dGluZyBsb29wIGRlbGF5IHRvIDAgKGNvbnRpbm91cyBsb29wKSBpbiBNQVhJTSBzdG9wcyBQRU5ERVQKKwkgKiBTZXR0aW5nIGxvb3AgZGVsYXkgdG8gMCAoY29udGludW91cyBsb29wKSBpbiBNQVhJTSBzdG9wcyBQRU5ERVQKIAkgKiBpbnRlcnJ1cHQgZ2VuZXJhdGlvbiBzb21ldGltZXMuCiAJICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vdWNiMTQwMF90cy5jIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi91Y2IxNDAwX3RzLmMKaW5kZXggMDI4YTUzNi4uM2I1YjVkZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi91Y2IxNDAwX3RzLmMKKysrIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi91Y2IxNDAwX3RzLmMKQEAgLTYsNyArNiw3IEBACiAgKiAgQ29weXJpZ2h0OglNb250YVZpc3RhIFNvZnR3YXJlLCBJbmMuCiAgKgogICogU3BsaXRpbmcgZG9uZSBieTogTWFyZWsgVmFzdXQgPG1hcmVrLnZhc3V0QGdtYWlsLmNvbT4KLSAqIElmIHNvbWV0aGluZyBkb2VzbnQgd29yayBhbmQgaXQgd29ya2VkIGJlZm9yZSBzcGxpdGluZywgZS1tYWlsIG1lLAorICogSWYgc29tZXRoaW5nIGRvZXNuJ3Qgd29yayBhbmQgaXQgd29ya2VkIGJlZm9yZSBzcGxpdGluZywgZS1tYWlsIG1lLAogICogZG9udCBib3RoZXIgTmljb2xhcyBwbGVhc2UgOy0pCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vd205NzA1LmMgYi9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3dtOTcwNS5jCmluZGV4IDZiNWJlNzQuLjk4ZTYxMTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vd205NzA1LmMKKysrIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi93bTk3MDUuYwpAQCAtMzA2LDcgKzMwNiw3IEBACiAJZGlnMiA9IHdtLT5kaWdbMl07CiAKIAlpZiAoZW5hYmxlKSB7Ci0JCS8qIGNvbnRpbm91cyBtb2RlICovCisJCS8qIGNvbnRpbnVvdXMgbW9kZSAqLwogCQlpZiAod20tPm1hY2hfb3BzLT5hY2Nfc3RhcnR1cCAmJgogCQkgICAgKHJldCA9IHdtLT5tYWNoX29wcy0+YWNjX3N0YXJ0dXAod20pKSA8IDApCiAJCQlyZXR1cm4gcmV0OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi93bTk3MTIuYyBiL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vd205NzEyLmMKaW5kZXggNzQ5MGIwNS4uMmJjMmZiOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi93bTk3MTIuYworKysgYi9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3dtOTcxMi5jCkBAIC00MTksNyArNDE5LDcgQEAKIAlkaWcyID0gd20tPmRpZ1syXTsKIAogCWlmIChlbmFibGUpIHsKLQkJLyogY29udGlub3VzIG1vZGUgKi8KKwkJLyogY29udGludW91cyBtb2RlICovCiAJCWlmICh3bS0+bWFjaF9vcHMtPmFjY19zdGFydHVwKSB7CiAJCQlyZXQgPSB3bS0+bWFjaF9vcHMtPmFjY19zdGFydHVwKHdtKTsKIAkJCWlmIChyZXQgPCAwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi93bTk3MTMuYyBiL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vd205NzEzLmMKaW5kZXggMjM4YjUxMy4uNzNlYzk5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi93bTk3MTMuYworKysgYi9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3dtOTcxMy5jCkBAIC00MzEsNyArNDMxLDcgQEAKIAlkaWczID0gd20tPmRpZ1syXTsKIAogCWlmIChlbmFibGUpIHsKLQkJLyogY29udGlub3VzIG1vZGUgKi8KKwkJLyogY29udGludW91cyBtb2RlICovCiAJCWlmICh3bS0+bWFjaF9vcHMtPmFjY19zdGFydHVwICYmCiAJCQkocmV0ID0gd20tPm1hY2hfb3BzLT5hY2Nfc3RhcnR1cCh3bSkpIDwgMCkKIAkJCXJldHVybiByZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3dtOTd4eC1jb3JlLmMgYi9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3dtOTd4eC1jb3JlLmMKaW5kZXggNmI3NWM5Zi4uNWRiZTczYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi93bTk3eHgtY29yZS5jCisrKyBiL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vd205N3h4LWNvcmUuYwpAQCAtMzM1LDcgKzMzNSw3IEBACiAJICovCiAJaWYgKCF3bS0+bWFjaF9vcHMtPmFjY19lbmFibGVkIHx8IHdtLT5tYWNoX29wcy0+YWNjX3Blbl9kb3duKSB7CiAJCWlmICh3bS0+cGVuX2lzX2Rvd24gJiYgIXBlbl93YXNfZG93bikgewotCQkJLyogRGF0YSBpcyBub3QgYXZhaWxpYWJsZSBpbW1lZGlhdGVseSBvbiBwZW4gZG93biAqLworCQkJLyogRGF0YSBpcyBub3QgYXZhaWxhYmxlIGltbWVkaWF0ZWx5IG9uIHBlbiBkb3duICovCiAJCQlxdWV1ZV9kZWxheWVkX3dvcmsod20tPnRzX3dvcmtxLCAmd20tPnRzX3JlYWRlciwgMSk7CiAJCX0KIApAQCAtMzU0LDcgKzM1NCw3IEBACiAgKiBDb2RlYyBQRU5ET1dOIGlycSBoYW5kbGVyCiAgKgogICogV2UgaGF2ZSB0byBkaXNhYmxlIHRoZSBjb2RlYyBpbnRlcnJ1cHQgaW4gdGhlIGhhbmRsZXIgYmVjYXVzZSBpdAotICogY2FuIHRha2UgdXB0byAxbXMgdG8gY2xlYXIgdGhlIGludGVycnVwdCBzb3VyY2UuIFdlIHNjaGVkdWxlIGEgdGFzaworICogY2FuIHRha2UgdXAgdG8gMW1zIHRvIGNsZWFyIHRoZSBpbnRlcnJ1cHQgc291cmNlLiBXZSBzY2hlZHVsZSBhIHRhc2sKICAqIGluIGEgd29yayBxdWV1ZSB0byBkbyB0aGUgYWN0dWFsIGludGVyYWN0aW9uIHdpdGggdGhlIGNoaXAuICBUaGUKICAqIGludGVycnVwdCBpcyB0aGVuIGVuYWJsZWQgYWdhaW4gaW4gdGhlIHNsb3cgaGFuZGxlciB3aGVuIHRoZSBzb3VyY2UKICAqIGhhcyBiZWVuIGNsZWFyZWQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vZGl2YWNhcGkuaCBiL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9kaXZhY2FwaS5oCmluZGV4IDlmNWI2ODAuLmUzMzBkYTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9kaXZhY2FwaS5oCisrKyBiL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9kaXZhY2FwaS5oCkBAIC02NzMsNyArNjczLDcgQEAKIAogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi0vKiBhdXhpbGxpYXJ5IHN0YXRlcyBmb3Igc3VwcGxlbWVudGFyeSBzZXJ2aWNlcyAgICAgICAgICAgICAgICAgICAgICovCisvKiBhdXhpbGlhcnkgc3RhdGVzIGZvciBzdXBwbGVtZW50YXJ5IHNlcnZpY2VzICAgICAgICAgICAgICAgICAgICAgKi8KIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KIAogI2RlZmluZSBJRExFICAgICAgICAgICAgICAgIDAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9pby5oIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL2lvLmgKaW5kZXggMGM2YzY1MC4uYTZmMTc1NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL2lvLmgKKysrIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL2lvLmgKQEAgLTYwLDcgKzYwLDcgQEAKICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KIHN0cnVjdCBfSVNETl9BREFQVEVSIHsKICB2b2lkICAgICAgICAgICAgICgqIERJUmVxdWVzdCkoUElTRE5fQURBUFRFUiwgRU5USVRZICopIDsKLSBpbnQgICAgICAgICAgICAgICAgIFN0YXRlIDsgLyogZnJvbSBOVDQgMS5zcnYsIGEgZ29vZCBpZGVhLCBidXQgIGEgcG9vciBhY2hpZXZtZW50ICovCisgaW50ICAgICAgICAgICAgICAgICBTdGF0ZSA7IC8qIGZyb20gTlQ0IDEuc3J2LCBhIGdvb2QgaWRlYSwgYnV0ICBhIHBvb3IgYWNoaWV2ZW1lbnQgKi8KICBpbnQgICAgICAgICAgICAgICAgIEluaXRpYWxpemVkIDsKICBpbnQgICAgICAgICBSZWdpc3RlcmVkV2l0aERpZGQgOwogIGludCAgICAgICAgICAgICAgICAgVW5hdmFpbGFibGUgOyAgLyogY2FsbGJhY2sgZnVuY3Rpb24gcG9zc2libGU/ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vbWVzc2FnZS5jIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL21lc3NhZ2UuYwppbmRleCAzNDFlZjE3Li44YzVjNTYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vbWVzc2FnZS5jCisrKyBiL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9tZXNzYWdlLmMKQEAgLTI2MzksNyArMjYzOSw3IEBACiAgICAgfQogICAgIGVsc2UKICAgICB7Ci0gICAgICAvKiBsb2NhbCByZXBseSBpZiBhc3NpZ24gdW5zdWNjZXNzZnVsbAorICAgICAgLyogbG9jYWwgcmVwbHkgaWYgYXNzaWduIHVuc3VjY2Vzc2Z1bAogICAgICAgICAgb3IgQjMgcHJvdG9jb2wgYWxsb3dzIG9ubHkgb25lIGxheWVyIDMgY29ubmVjdGlvbgogICAgICAgICAgICBhbmQgYWxyZWFkeSBjb25uZWN0ZWQKICAgICAgICAgICAgICBvciBCMiBwcm90b2NvbCBub3QgYW55IExBUEQKQEAgLTgxODksNyArODE4OSw3IEBACiAgICAgICBkbGNbIDBdID0gMTU7CiAgICAgICBpZihiMl9jb25maWctPmxlbmd0aCA+PSA4KSB7IC8qIFBJQUZTIGNvbnRyb2wgYWJpbGl0aWVzICovCiAgICAgICAgIGRsY1sgN10gPSAxMDsgCi0gICAgICAgIGRsY1sxNl0gPSAyOyAvKiBMZW5ndGggb2YgUElBRlMgZXh0ZW50aW9uICovCisgICAgICAgIGRsY1sxNl0gPSAyOyAvKiBMZW5ndGggb2YgUElBRlMgZXh0ZW5zaW9uICovCiAgICAgICAgIGRsY1sxN10gPSBQSUFGU19VREFUQV9BQklMSVRJRVM7IC8qIGNvbnRyb2wgKFVEQVRBKSBhYmlsaXR5ICovCiAgICAgICAgIGRsY1sxOF0gPSBiMl9jb25maWdfcGFybXNbNF0uaW5mb1swXTsgLyogdmFsdWUgKi8KICAgICAgICAgZGxjWyAwXSA9IDE4OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL3BjLmggYi9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vcGMuaAppbmRleCAxYzY5NDU3Li5iZjZiMDE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vcGMuaAorKysgYi9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vcGMuaApAQCAtNzAxLDcgKzcwMSw3IEBACiAjZGVmaW5lIFBST1RDQVBfRlJFRTEyICAgIDB4MTAwMCAgLyogbm90IHVzZWQgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KICNkZWZpbmUgUFJPVENBUF9GUkVFMTMgICAgMHgyMDAwICAvKiBub3QgdXNlZCAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwogI2RlZmluZSBQUk9UQ0FQX0ZSRUUxNCAgICAweDQwMDAgIC8qIG5vdCB1c2VkICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi0jZGVmaW5lIFBST1RDQVBfRVhURU5TSU9OIDB4ODAwMCAgLyogdXNlZCBmb3IgZnV0dXJlIGV4dGVudGlvbnMgICAgICAgICAgKi8KKyNkZWZpbmUgUFJPVENBUF9FWFRFTlNJT04gMHg4MDAwICAvKiB1c2VkIGZvciBmdXR1cmUgZXh0ZW5zaW9ucyAgICAgICAgICAqLwogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qICovCiAvKiBPbmhvb2sgZGF0YSB0cmFuc21pc3Npb24gRVRTMzAwNjU5MDEgKi8KIC8qIE1lc3NhZ2UgVHlwZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL3VtX2lkaS5jIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL3VtX2lkaS5jCmluZGV4IDY1NjNkYjkuLmFjMGJkZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi91bV9pZGkuYworKysgYi9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vdW1faWRpLmMKQEAgLTM2Myw3ICszNjMsNyBAQAogCiAJCWlmICgocmV0ID0gKCpjcF9mbikgKG9zX2hhbmRsZSwgZHN0LCBkYXRhLCBsZW5ndGgpKSA+PSAwKSB7CiAJCQkvKgotCQkJICAgQWNrbm93bGVkZ2Ugb25seSBpZiByZWFkIHdhcyBzdWNjZXNzZnVsbAorCQkJICAgQWNrbm93bGVkZ2Ugb25seSBpZiByZWFkIHdhcyBzdWNjZXNzZnVsCiAJCQkgKi8KIAkJCWRpdmFfZGF0YV9xX2Fja19zZWdtZW50NHJlYWQocSk7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9tSVNETi9oZmNtdWx0aS5jIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL21JU0ROL2hmY211bHRpLmMKaW5kZXggNGUzNzgwZC4uZjZmM2M4NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2hhcmR3YXJlL21JU0ROL2hmY211bHRpLmMKKysrIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL21JU0ROL2hmY211bHRpLmMKQEAgLTExOCw3ICsxMTgsNyBAQAogICoJLT4gU2VlIGhmY19tdWx0aS5oIGZvciBIRkNfSU9fTU9ERV8qIHZhbHVlcwogICoJQnkgZGVmYXVsdCwgdGhlIElPIG1vZGUgaXMgcGNpIG1lbW9yeSBJTyAoTUVNSU8pLgogICoJU29tZSBjYXJkcyByZXF1aXJlIHNwZWNpZmljIElPIG1vZGUsIHNvIGl0IGNhbm5vdCBiZSBjaGFuZ2VkLgotICoJSXQgbWF5IGJlIHVzZWZ1bGwgdG8gc2V0IElPIG1vZGUgdG8gcmVnaXN0ZXIgaW8gKFJFR0lPKSB0byBzb2x2ZQorICoJSXQgbWF5IGJlIHVzZWZ1bCB0byBzZXQgSU8gbW9kZSB0byByZWdpc3RlciBpbyAoUkVHSU8pIHRvIHNvbHZlCiAgKglQQ0kgYnJpZGdlIHByb2JsZW1zLgogICoJSWYgdW5zdXJlLCBkb24ndCBnaXZlIHRoaXMgcGFyYW1ldGVyLgogICoKQEAgLTkwMyw3ICs5MDMsNyBAQAogLyoKICAqIFNwZWVjaCBEZXNpZ24gcmVzeW5jIGZlYXR1cmUKICAqIE5PVEU6IFRoaXMgaXMgY2FsbGVkIHNvbWV0aW1lcyBvdXRzaWRlIGludGVycnVwdCBoYW5kbGVyLgotICogV2UgbXVzdCBsb2NrIGlycXNhdmUsIHNvIG5vIG90aGVyIGludGVycnVwdCAob3RoZXIgY2FyZCkgd2lsbCBvY2N1cnIhCisgKiBXZSBtdXN0IGxvY2sgaXJxc2F2ZSwgc28gbm8gb3RoZXIgaW50ZXJydXB0IChvdGhlciBjYXJkKSB3aWxsIG9jY3VyIQogICogQWxzbyBtdWx0aXBsZSBpbnRlcnJ1cHRzIG1heSBuZXN0LCBzbyBtdXN0IGxvY2sgZWFjaCBhY2Nlc3MgKGxpc3RzLCBjYXJkKSEKICAqLwogc3RhdGljIGlubGluZSB2b2lkCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvbUlTRE4vaGZjcGNpLmMgYi9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvbUlTRE4vaGZjcGNpLmMKaW5kZXggMTVkMzIzYi4uNDM0M2FiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2hhcmR3YXJlL21JU0ROL2hmY3BjaS5jCisrKyBiL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9tSVNETi9oZmNwY2kuYwpAQCAtMjcyLDcgKzI3Miw3IEBACiAJICogRC0gYW5kIG1vbml0b3IvQ0kgY2hhbm5lbCBhcmUgbm90IGVuYWJsZWQKIAkgKiBTVElPMSBpcyB1c2VkIGFzIG91dHB1dCBmb3IgZGF0YSwgQjErQjIgZnJvbSBTVC0+SU9NK0hGQwogCSAqIFNUSU8yIGlzIHVzZWQgYXMgZGF0YSBpbnB1dCwgQjErQjIgZnJvbSBJT00tPlNUCi0JICogU1QgQi1jaGFubmVsIHNlbmQgZGlzYWJsZWQgLT4gY29udGlub3VzIDFzCisJICogU1QgQi1jaGFubmVsIHNlbmQgZGlzYWJsZWQgLT4gY29udGludW91cyAxcwogCSAqIFRoZSBJT00gc2xvdHMgYXJlIGFsd2F5cyBlbmFibGVkCiAJICovCiAJaWYgKHRlc3RfYml0KEhGQ19DRkdfUENNLCAmaGMtPmNmZykpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfcGNpLmMgYi9kcml2ZXJzL2lzZG4vaGlzYXgvaGZjX3BjaS5jCmluZGV4IDMxNDcwMjAuLjBjYjA1NDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfcGNpLmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L2hmY19wY2kuYwpAQCAtMTQ2LDcgKzE0Niw3IEBACiAJLyogRC0gYW5kIG1vbml0b3IvQ0kgY2hhbm5lbCBhcmUgbm90IGVuYWJsZWQgKi8KIAkvKiBTVElPMSBpcyB1c2VkIGFzIG91dHB1dCBmb3IgZGF0YSwgQjErQjIgZnJvbSBTVC0+SU9NK0hGQyAqLwogCS8qIFNUSU8yIGlzIHVzZWQgYXMgZGF0YSBpbnB1dCwgQjErQjIgZnJvbSBJT00tPlNUICovCi0JLyogU1QgQi1jaGFubmVsIHNlbmQgZGlzYWJsZWQgLT4gY29udGlub3VzIDFzICovCisJLyogU1QgQi1jaGFubmVsIHNlbmQgZGlzYWJsZWQgLT4gY29udGludW91cyAxcyAqLwogCS8qIFRoZSBJT00gc2xvdHMgYXJlIGFsd2F5cyBlbmFibGVkICovCiAJY3MtPmh3LmhmY3BjaS5jb25uID0gMHgzNjsJLyogc2V0IGRhdGEgZmxvdyBkaXJlY3Rpb25zICovCiAJV3JpdGVfaGZjKGNzLCBIRkNQQ0lfQ09OTkVDVCwgY3MtPmh3LmhmY3BjaS5jb25uKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfc3guYyBiL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfc3guYwppbmRleCAxMjM1YjcxLi4xNTZkN2M2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGlzYXgvaGZjX3N4LmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L2hmY19zeC5jCkBAIC0zOTksNyArMzk5LDcgQEAKIAkvKiBELSBhbmQgbW9uaXRvci9DSSBjaGFubmVsIGFyZSBub3QgZW5hYmxlZCAqLwogCS8qIFNUSU8xIGlzIHVzZWQgYXMgb3V0cHV0IGZvciBkYXRhLCBCMStCMiBmcm9tIFNULT5JT00rSEZDICovCiAJLyogU1RJTzIgaXMgdXNlZCBhcyBkYXRhIGlucHV0LCBCMStCMiBmcm9tIElPTS0+U1QgKi8KLQkvKiBTVCBCLWNoYW5uZWwgc2VuZCBkaXNhYmxlZCAtPiBjb250aW5vdXMgMXMgKi8KKwkvKiBTVCBCLWNoYW5uZWwgc2VuZCBkaXNhYmxlZCAtPiBjb250aW51b3VzIDFzICovCiAJLyogVGhlIElPTSBzbG90cyBhcmUgYWx3YXlzIGVuYWJsZWQgKi8KIAljcy0+aHcuaGZjc3guY29ubiA9IDB4MzY7CS8qIHNldCBkYXRhIGZsb3cgZGlyZWN0aW9ucyAqLwogCVdyaXRlX2hmYyhjcywgSEZDU1hfQ09OTkVDVCwgY3MtPmh3LmhmY3N4LmNvbm4pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2hpc2F4L2hmY191c2IuaCBiL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfdXNiLmgKaW5kZXggZTc5ZjU2NS4uMmY1ODFjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2hpc2F4L2hmY191c2IuaAorKysgYi9kcml2ZXJzL2lzZG4vaGlzYXgvaGZjX3VzYi5oCkBAIC0xMjYsNyArMTI2LDcgQEAKIAogCiAvKgotICogZGV2aWNlIGRlcGVuZGFudCBpbmZvcm1hdGlvbiB0byBzdXBwb3J0IGRpZmZlcmVudAorICogZGV2aWNlIGRlcGVuZGVudCBpbmZvcm1hdGlvbiB0byBzdXBwb3J0IGRpZmZlcmVudAogICogSVNETiBUYSdzIHVzaW5nIHRoZSBIRkMtUyBVU0IgY2hpcAogICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9sM2RzczEuYyBiL2RyaXZlcnMvaXNkbi9oaXNheC9sM2RzczEuYwppbmRleCBjYzZlZTJkLi44ZTJmZDAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGlzYXgvbDNkc3MxLmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L2wzZHNzMS5jCkBAIC0xNTk1LDcgKzE1OTUsNyBAQAogCSAqIEJlYXJlciBDYXBhYmlsaXRpZXMKIAkgKi8KIAlwID0gc2tiLT5kYXRhOwotCS8qIG9ubHkgdGhlIGZpcnN0IG9jY3VyZW5jZSAnbGwgYmUgZGV0ZWN0ZWQgISAqLworCS8qIG9ubHkgdGhlIGZpcnN0IG9jY3VycmVuY2UgJ2xsIGJlIGRldGVjdGVkICEgKi8KIAlpZiAoKHAgPSBmaW5kaWUocCwgc2tiLT5sZW4sIDB4MDQsIDApKSkgewogCQlpZiAoKHBbMV0gPCAyKSB8fCAocFsxXSA+IDExKSkKIAkJCWVyciA9IDE7CkBAIC0yMTYxLDcgKzIxNjEsNyBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKiBoYW5kbGUgc3BlY2lhbCBjb21tYW5kcyBmb3IgdGhpcyBwcm90b2NvbC4gICovCi0vKiBFeGFtcGxlcyBhcmUgY2FsbCBpbmRlcGVuZGFudCBzZXJ2aWNlcyBsaWtlICovCisvKiBFeGFtcGxlcyBhcmUgY2FsbCBpbmRlcGVuZGVudCBzZXJ2aWNlcyBsaWtlICovCiAvKiByZW1vdGUgb3BlcmF0aW9ucyB3aXRoIGR1bW15ICBjYWxscmVmLiAgICAgICovCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiBzdGF0aWMgaW50IGwzZHNzMV9jbWRfZ2xvYmFsKHN0cnVjdCBQU3RhY2sgKnN0LCBpc2RuX2N0cmwgKmljKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2hpc2F4L2wzbmkxLmMgYi9kcml2ZXJzL2lzZG4vaGlzYXgvbDNuaTEuYwppbmRleCBmOTU4NDQ5Li43YjIyOWMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGlzYXgvbDNuaTEuYworKysgYi9kcml2ZXJzL2lzZG4vaGlzYXgvbDNuaTEuYwpAQCAtMTQ0OSw3ICsxNDQ5LDcgQEAKIAkgKiBCZWFyZXIgQ2FwYWJpbGl0aWVzCiAJICovCiAJcCA9IHNrYi0+ZGF0YTsKLQkvKiBvbmx5IHRoZSBmaXJzdCBvY2N1cmVuY2UgJ2xsIGJlIGRldGVjdGVkICEgKi8KKwkvKiBvbmx5IHRoZSBmaXJzdCBvY2N1cnJlbmNlICdsbCBiZSBkZXRlY3RlZCAhICovCiAJaWYgKChwID0gZmluZGllKHAsIHNrYi0+bGVuLCAweDA0LCAwKSkpIHsKIAkJaWYgKChwWzFdIDwgMikgfHwgKHBbMV0gPiAxMSkpCiAJCQllcnIgPSAxOwpAQCAtMjAxNyw3ICsyMDE3LDcgQEAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyogaGFuZGxlIHNwZWNpYWwgY29tbWFuZHMgZm9yIHRoaXMgcHJvdG9jb2wuICAqLwotLyogRXhhbXBsZXMgYXJlIGNhbGwgaW5kZXBlbmRhbnQgc2VydmljZXMgbGlrZSAqLworLyogRXhhbXBsZXMgYXJlIGNhbGwgaW5kZXBlbmRlbnQgc2VydmljZXMgbGlrZSAqLwogLyogcmVtb3RlIG9wZXJhdGlvbnMgd2l0aCBkdW1teSAgY2FsbHJlZi4gICAgICAqLwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogc3RhdGljIGludCBsM25pMV9jbWRfZ2xvYmFsKHN0cnVjdCBQU3RhY2sgKnN0LCBpc2RuX2N0cmwgKmljKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2hpc2F4L25qX3MuYyBiL2RyaXZlcnMvaXNkbi9oaXNheC9ual9zLmMKaW5kZXggMjM0NGU3Yi4uYTFiODk1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2hpc2F4L25qX3MuYworKysgYi9kcml2ZXJzL2lzZG4vaGlzYXgvbmpfcy5jCkBAIC0xNjcsNyArMTY3LDcgQEAKIAkJcmV0dXJuKDApOwogCX0KIAkvKiB0aGUgVEozMDAgYW5kIFRKMzIwIG11c3QgYmUgZGV0ZWN0ZWQsIHRoZSBJUlEgaGFuZGxpbmcgaXMgZGlmZmVyZW50Ci0JICogdW5mb3J0dW5hdGx5IHRoZSBjaGlwcyB1c2UgdGhlIHNhbWUgZGV2aWNlIElELCBidXQgdGhlIFRKMzIwIGhhcworCSAqIHVuZm9ydHVuYXRlbHkgdGhlIGNoaXBzIHVzZSB0aGUgc2FtZSBkZXZpY2UgSUQsIGJ1dCB0aGUgVEozMjAgaGFzCiAJICogdGhlIGJpdDIwIGluIHN0YXR1cyBQQ0kgY2ZnIHJlZ2lzdGVyIHNldAogCSAqLwogCXBjaV9yZWFkX2NvbmZpZ19kd29yZChkZXZfbmV0amV0LCAweDA0LCAmY2ZnKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9zdDU0ODFfYi5jIGIvZHJpdmVycy9pc2RuL2hpc2F4L3N0NTQ4MV9iLmMKaW5kZXggZTU2ZTVhZi4uZWQ0YmM1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2hpc2F4L3N0NTQ4MV9iLmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L3N0NTQ4MV9iLmMKQEAgLTEyNCw3ICsxMjQsNyBAQAogfQogCiAvKgotICogU3RhcnQgdHJhbnNmZXJpbmcgKGZsYWdzIG9yIGRhdGEpIG9uIHRoZSBCIGNoYW5uZWwsIHNpbmNlCisgKiBTdGFydCB0cmFuc2ZlcnJpbmcgKGZsYWdzIG9yIGRhdGEpIG9uIHRoZSBCIGNoYW5uZWwsIHNpbmNlCiAgKiBGSUZPIGNvdW50ZXJzIGhhcyBiZWVuIHNldCB0byBhIG5vbi16ZXJvIHZhbHVlLgogICovCiBzdGF0aWMgdm9pZCBzdDU0ODFCX3N0YXJ0X3hmZXIodm9pZCAqY29udGV4dCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9zdDU0ODFfdXNiLmMgYi9kcml2ZXJzL2lzZG4vaGlzYXgvc3Q1NDgxX3VzYi5jCmluZGV4IDEwZDQxYzUuLjE1OWU4ZmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oaXNheC9zdDU0ODFfdXNiLmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L3N0NTQ4MV91c2IuYwpAQCAtNDcwLDcgKzQ3MCw3IEBACiAKIC8qCiAgKiBEZWNvZGUgZnJhbWVzIHJlY2VpdmVkIG9uIHRoZSBCL0QgY2hhbm5lbC4KLSAqIE5vdGUgdGhhdCB0aGlzIGZ1bmN0aW9uIHdpbGwgYmUgY2FsbGVkIGNvbnRpbm91c2x5CisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiB3aWxsIGJlIGNhbGxlZCBjb250aW51b3VzbHkKICAqIHdpdGggNjRLYml0L3MgLyAxNktiaXQvcyBvZiBkYXRhIGFuZCBoZW5jZSBpdCB3aWxsIGJlIAogICogY2FsbGVkIDUwIHRpbWVzIHBlciBzZWNvbmQgd2l0aCAyMCBJU09DIGRlc2NyaXB0b3JzLiAKICAqIENhbGxlZCBhdCBpbnRlcnJ1cHQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaGlzYXgvdGVsZXNfY3MuYyBiL2RyaXZlcnMvaXNkbi9oaXNheC90ZWxlc19jcy5jCmluZGV4IDI4MmE0NDYuLmFhMjVlMTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oaXNheC90ZWxlc19jcy5jCisrKyBiL2RyaXZlcnMvaXNkbi9oaXNheC90ZWxlc19jcy5jCkBAIC05LDcgKzksNyBAQAogICAgIEFsc28gaW5zcGlyZWQgYnkgRUxTQSBQQ01DSUEgZHJpdmVyIAogICAgIGJ5IEtsYXVzIExpY2h0ZW53YWxkZXIgPExpY2h0ZW53YWxkZXJAQUNNLm9yZz4KICAgICAKLSAgICBFeHRlbnRpb25zIHRvIG5ldyBoaXNheF9wY21jaWEgYnkgS2Fyc3RlbiBLZWlsCisgICAgRXh0ZW5zaW9ucyB0byBuZXcgaGlzYXhfcGNtY2lhIGJ5IEthcnN0ZW4gS2VpbAogCiAgICAgbWlub3IgY2hhbmdlcyB0byBiZSBjb21wYXRpYmxlIHdpdGgga2VybmVsIDIuNC54CiAgICAgYnkgSmFuLlNjaHViZXJ0QEdNWC5saQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX3NjaGVkLmMgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fc2NoZWQuYwppbmRleCA4MWRiNGExLi4zNjc0ZDMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fc2NoZWQuYworKysgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fc2NoZWQuYwpAQCAtMTQzLDcgKzE0Myw3IEBACiAvKiBzZW5kIG9uZSBjb25maWcgbGluZSB0byB0aGUgY2FyZCBhbmQgcmV0dXJuIDAgaWYgc3VjY2Vzc2Z1bCwgb3RoZXJ3aXNlIGEgKi8KIC8qIG5lZ2F0aXZlIGVycm9yIGNvZGUuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KIC8qIFRoZSBmdW5jdGlvbiB3b3JrcyB3aXRoIHRpbWVvdXRzIHBlcmhhcHMgbm90IGdpdmluZyB0aGUgZ3JlYXRlc3Qgc3BlZWQgICAgKi8KLS8qIHNlbmRpbmcgdGhlIGxpbmUsIGJ1dCB0aGlzIHNob3VsZCBiZSBtZWFuaW5nbGVzcyBiZWFjdXNlIG9ubHkgc29tZSBsaW5lcyAgKi8KKy8qIHNlbmRpbmcgdGhlIGxpbmUsIGJ1dCB0aGlzIHNob3VsZCBiZSBtZWFuaW5nbGVzcyBiZWNhdXNlIG9ubHkgc29tZSBsaW5lcyAgKi8KIC8qIGFyZSB0byBiZSBzZW50IGFuZCB0aGlzIGhhcHBlbnMgdmVyeSBzZWxkb20uICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIGludApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2k0bC9pc2RuX25ldC5jIGIvZHJpdmVycy9pc2RuL2k0bC9pc2RuX25ldC5jCmluZGV4IGFmZWVkZTcuLjJhN2QxN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9pNGwvaXNkbl9uZXQuYworKysgYi9kcml2ZXJzL2lzZG4vaTRsL2lzZG5fbmV0LmMKQEAgLTE1MzAsNyArMTUzMCw3IEBACiAJCXByaW50ayAoS0VSTl9XQVJOSU5HCiAJCQkJIlVQRE9XTjogTGluZSBwcm90b2NvbCBvbiBJbnRlcmZhY2UgJXMsIgogCQkJCSIgY2hhbmdlZCBzdGF0ZSB0byBkb3duXG4iLCBscC0+bmV0ZGV2LT5kZXYtPm5hbWUpOwotCQkvKiBzaG91bGQgc3RvcCByb3V0aW5nIGhpZ2hlci1sZXZlbCBkYXRhIGFjY3Jvc3MgKi8KKwkJLyogc2hvdWxkIHN0b3Agcm91dGluZyBoaWdoZXItbGV2ZWwgZGF0YSBhY3Jvc3MgKi8KIAl9IGVsc2UgaWYgKCghbHAtPmNpc2NvX2xpbmVfc3RhdGUpICYmCiAJCShteXNlcV9kaWZmID49IDApICYmIChteXNlcV9kaWZmIDw9IDIpKSB7CiAJCS8qIGxpbmUgZG93biAtPiB1cCAqLwpAQCAtMTUzOCw3ICsxNTM4LDcgQEAKIAkJcHJpbnRrIChLRVJOX1dBUk5JTkcKIAkJCQkiVVBET1dOOiBMaW5lIHByb3RvY29sIG9uIEludGVyZmFjZSAlcywiCiAJCQkJIiBjaGFuZ2VkIHN0YXRlIHRvIHVwXG4iLCBscC0+bmV0ZGV2LT5kZXYtPm5hbWUpOwotCQkvKiByZXN0YXJ0IHJvdXRpbmcgaGlnaGVyLWxldmVsIGRhdGEgYWNjcm9zcyAqLworCQkvKiByZXN0YXJ0IHJvdXRpbmcgaGlnaGVyLWxldmVsIGRhdGEgYWNyb3NzICovCiAJfQogCiAJaWYgKGxwLT5jaXNjb19kZWJzZXJpbnQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaTRsL2lzZG5fcHBwLmMgYi9kcml2ZXJzL2lzZG4vaTRsL2lzZG5fcHBwLmMKaW5kZXggOWU4MTYyYy4uMWIwMDJiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2k0bC9pc2RuX3BwcC5jCisrKyBiL2RyaXZlcnMvaXNkbi9pNGwvaXNkbl9wcHAuYwpAQCAtMTUxNCw3ICsxNTE0LDcgQEAKICNkZWZpbmUgTVBfTE9OR1NFUV9NQVhCSVQJKChNUF9MT05HU0VRX01BU0srMSk+PjEpCiAjZGVmaW5lIE1QX1NIT1JUU0VRX01BWEJJVAkoKE1QX1NIT1JUU0VRX01BU0srMSk+PjEpCiAKLS8qIHNlcXVlbmNlLXdyYXAgc2FmZSBjb21wYXJpc2lvbnMgKGZvciBsb25nIHNlcXVlbmNlKSovIAorLyogc2VxdWVuY2Utd3JhcCBzYWZlIGNvbXBhcmlzb25zIChmb3IgbG9uZyBzZXF1ZW5jZSkqLwogI2RlZmluZSBNUF9MVChhLGIpCSgoYS1iKSZNUF9MT05HU0VRX01BWEJJVCkKICNkZWZpbmUgTVBfTEUoYSxiKSAJISgoYi1hKSZNUF9MT05HU0VRX01BWEJJVCkKICNkZWZpbmUgTVBfR1QoYSxiKSAJKChiLWEpJk1QX0xPTkdTRVFfTUFYQklUKQpAQCAtMTc0Niw3ICsxNzQ2LDcgQEAKIAkJICogdGhlbiBuZXh0IGZyYWdtZW50IHNob3VsZCBiZSB0aGUgc3RhcnQgb2YgbmV3IHJlYXNzZW1ibHkKIAkJICogaWYgc2VxdWVuY2UgaXMgY29udGlndW91cywgYnV0IHdlIGhhdmVuJ3QgcmVhc3NlbWJsZWQgeWV0LAogCQkgKiBrZWVwIGdvaW5nLgotCQkgKiBpZiBzZXF1ZW5jZSBpcyBub3QgY29udGlndW91cywgZWl0aGVyIGNsZWFyIGV2ZXJ5dGluZworCQkgKiBpZiBzZXF1ZW5jZSBpcyBub3QgY29udGlndW91cywgZWl0aGVyIGNsZWFyIGV2ZXJ5dGhpbmcKIAkJICogYmVsb3cgbG93IHdhdGVybWFyayBhbmQgc2V0IHN0YXJ0IHRvIHRoZSBuZXh0IGZyYWcgb3IKIAkJICogY2xlYXIgc3RhcnQgcHRyLgogCQkgKi8gCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaTRsL2lzZG5fdHR5LmMgYi9kcml2ZXJzL2lzZG4vaTRsL2lzZG5fdHR5LmMKaW5kZXggM2Q4OGYxNS4uNjA3ZDg0NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2k0bC9pc2RuX3R0eS5jCisrKyBiL2RyaXZlcnMvaXNkbi9pNGwvaXNkbl90dHkuYwpAQCAtNzkyLDcgKzc5Miw3IEBACiB9CiAKIC8qIGlzZG5fdHR5X3Jlc3VtZSgpIHRyaWVzIHRvIHJlc3VtZSBhIHN1c3BlbmRlZCBjYWxsCi0gKiBzZXR1cCBvZiB0aGUgbG93ZXIgbGV2ZWxzIGJlZm9yZSB0aGF0LiB1bmZvcnR1bmF0bHkgaGVyZSBpcyBubworICogc2V0dXAgb2YgdGhlIGxvd2VyIGxldmVscyBiZWZvcmUgdGhhdC4gdW5mb3J0dW5hdGVseSBoZXJlIGlzIG5vCiAgKiBjaGVja2luZyBmb3IgY29tcGF0aWJpbGl0eSBvZiB1c2VkIHByb3RvY29scyBpbXBsZW1lbnRlZCBieSBROTMxCiAgKiBJdCBkb2VzIHRoZSBzYW1lIHRoaW5ncyBsaWtlIGlzZG5fdHR5X2RpYWwsIHRoZSBsYXN0IGNvbW1hbmQKICAqIGlzIGRpZmZlcmVudCwgbWF5IGJlIHdlIGNhbiBtZXJnZSBpdC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9pc2RubG9vcC9pc2RubG9vcC5jIGIvZHJpdmVycy9pc2RuL2lzZG5sb29wL2lzZG5sb29wLmMKaW5kZXggYjhhMTA5OC4uZDQ5N2RiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2lzZG5sb29wL2lzZG5sb29wLmMKKysrIGIvZHJpdmVycy9pc2RuL2lzZG5sb29wL2lzZG5sb29wLmMKQEAgLTk1NCw3ICs5NTQsNyBAQAogLyoKICAqIFB1dCBjb21tYW5kLXN0cmluZ3MgaW50byB0aGUgb2YgdGhlICdjYXJkJy4gSW4gcmVhbGl0eSwgZXhlY3V0ZSB0aGVtCiAgKiByaWdodCBpbiBwbGFjZSBieSBjYWxsaW5nIGlzZG5sb29wX3BhcnNlX2NtZCgpLiBBbHNvIGNvcHkgZXZlcnkKLSAqIGNvbW1hbmQgdG8gdGhlIHJlYWQgbWVzc2FnZSByaW5nYnVmZmVyLCBwcmVjZWVkaW5nIGl0IHdpdGggYSAnPicuCisgKiBjb21tYW5kIHRvIHRoZSByZWFkIG1lc3NhZ2UgcmluZ2J1ZmZlciwgcHJlY2VkaW5nIGl0IHdpdGggYSAnPicuCiAgKiBUaGVzZSBtZXNhZ2dlcyBjYW4gYmUgcmVhZCBhdCAvZGV2L2lzZG5jdHJsLgogICoKICAqIFBhcmFtZXRlcjoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9tSVNETi9kc3AuaCBiL2RyaXZlcnMvaXNkbi9tSVNETi9kc3AuaAppbmRleCAxOGFmODY4Li44NTQ5NDMxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vbUlTRE4vZHNwLmgKKysrIGIvZHJpdmVycy9pc2RuL21JU0ROL2RzcC5oCkBAIC0yMSw3ICsyMSw3IEBACiAvKiBvcHRpb25zIG1heSBiZToKICAqCiAgKiBiaXQgMCA9IHVzZSB1bGF3IGluc3RlYWQgb2YgYWxhdwotICogYml0IDEgPSBlbmFibGUgaGZjIGhhcmR3YXJlIGFjY2VsbGVyYXRpb24gZm9yIGFsbCBjaGFubmVscworICogYml0IDEgPSBlbmFibGUgaGZjIGhhcmR3YXJlIGFjY2VsZXJhdGlvbiBmb3IgYWxsIGNoYW5uZWxzCiAgKgogICovCiAjZGVmaW5lIERTUF9PUFRfVUxBVwkJKDE8PDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vbUlTRE4vZHNwX2NteC5jIGIvZHJpdmVycy9pc2RuL21JU0ROL2RzcF9jbXguYwppbmRleCAzMDliYWNmLi40ZDM5NWRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vbUlTRE4vZHNwX2NteC5jCisrKyBiL2RyaXZlcnMvaXNkbi9tSVNETi9kc3BfY214LmMKQEAgLTE1MTMsNyArMTUxMyw3IEBACiAJLyogLT4gaWYgZWNobyBpcyBOT1QgZW5hYmxlZCAqLwogCWlmICghZHNwLT5lY2hvLnNvZnR3YXJlKSB7CiAJCS8qCi0JCSAqIC0+IHN1YnN0cmFjdCByeC1kYXRhIGZyb20gY29uZi1kYXRhLAorCQkgKiAtPiBzdWJ0cmFjdCByeC1kYXRhIGZyb20gY29uZi1kYXRhLAogCQkgKiBpZiB0eC1kYXRhIGlzIGF2YWlsYWJsZSwgbWl4CiAJCSAqLwogCQl3aGlsZSAociAhPSByciAmJiB0ICE9IHR0KSB7CkBAIC0xNTcyLDcgKzE1NzIsNyBAQAogc2VuZF9wYWNrZXQ6CiAJLyoKIAkgKiBzZW5kIHR4LWRhdGEgaWYgZW5hYmxlZCAtIGRvbid0IGZpbHRlciwKLQkgKiBiZWN1YXNlIHdlIHdhbnQgd2hhdCB3ZSBzZW5kLCBub3Qgd2hhdCB3ZSBmaWx0ZXJlZAorCSAqIGJlY2F1c2Ugd2Ugd2FudCB3aGF0IHdlIHNlbmQsIG5vdCB3aGF0IHdlIGZpbHRlcmVkCiAJICovCiAJaWYgKGRzcC0+dHhfZGF0YSkgewogCQlpZiAodHhfZGF0YV9vbmx5KSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vbUlTRE4vZHNwX2NvcmUuYyBiL2RyaXZlcnMvaXNkbi9tSVNETi9kc3BfY29yZS5jCmluZGV4IDZmNWI1NDguLjI4NzcyOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9tSVNETi9kc3BfY29yZS5jCisrKyBiL2RyaXZlcnMvaXNkbi9tSVNETi9kc3BfY29yZS5jCkBAIC0xMTUsNyArMTE1LDcgQEAKICAqCiAgKiBUaGUgQ01YIGhhcyBzcGVjaWFsIGZ1bmN0aW9ucyBmb3IgY29uZmVyZW5jZXMgd2l0aCBvbmUsIHR3byBhbmQgbW9yZQogICogbWVtYmVycy4gSXQgd2lsbCBhbGxvdyBkaWZmZXJlbnQgdHlwZXMgb2YgZGF0YSBmbG93LiBSZWNlaXZlIGFuZCB0cmFuc21pdAotICogZGF0YSB0by9mb3JtIHVwcGVyIGxheWVyIG1heSBiZSBzd2l0aGVkIG9uL29mZiBpbmRpdmlkdWFsbHkgd2l0aG91dCBsb29zaW5nCisgKiBkYXRhIHRvL2Zvcm0gdXBwZXIgbGF5ZXIgbWF5IGJlIHN3aXRoZWQgb24vb2ZmIGluZGl2aWR1YWxseSB3aXRob3V0IGxvc2luZwogICogZmVhdHVyZXMgb2YgQ01YLCBUb25lcyBhbmQgRFRNRi4KICAqCiAgKiBFY2hvIENhbmNlbGxhdGlvbjogU29tZXRpbWVzIHdlIGxpa2UgdG8gY2FuY2VsIGVjaG8gZnJvbSB0aGUgaW50ZXJmYWNlLgpAQCAtMTI3LDkgKzEyNyw5IEBACiAgKgogICogSWYgYWxsIHVzZWQgZmVhdHVyZXMgY2FuIGJlIHJlYWxpemVkIGluIGhhcmR3YXJlLCBhbmQgaWYgdHJhbnNtaXQgYW5kL29yCiAgKiByZWNlaXZlIGRhdGEgaXN0IGRpc2FibGVkLCB0aGUgY2FyZCBtYXkgbm90IHNlbmQvcmVjZWl2ZSBhbnkgZGF0YSBhdCBhbGwuCi0gKiBOb3QgcmVjZWl2aW5nIGlzIHVzZWZ1bGwgaWYgb25seSBhbm5vdW5jZW1lbnRzIGFyZSBwbGF5ZWQuIE5vdCBzZW5kaW5nIGlzCi0gKiB1c2VmdWxsIGlmIGFuIGFuc3dlcmluZyBtYWNoaW5lIHJlY29yZHMgYXVkaW8uIE5vdCBzZW5kaW5nIGFuZCByZWNlaXZpbmcgaXMKLSAqIHVzZWZ1bGwgZHVyaW5nIG1vc3Qgc3RhdGVzIG9mIHRoZSBjYWxsLiBJZiBzdXBwb3J0ZWQgYnkgaGFyZHdhcmUsIHRvbmVzCisgKiBOb3QgcmVjZWl2aW5nIGlzIHVzZWZ1bCBpZiBvbmx5IGFubm91bmNlbWVudHMgYXJlIHBsYXllZC4gTm90IHNlbmRpbmcgaXMKKyAqIHVzZWZ1bCBpZiBhbiBhbnN3ZXJpbmcgbWFjaGluZSByZWNvcmRzIGF1ZGlvLiBOb3Qgc2VuZGluZyBhbmQgcmVjZWl2aW5nIGlzCisgKiB1c2VmdWwgZHVyaW5nIG1vc3Qgc3RhdGVzIG9mIHRoZSBjYWxsLiBJZiBzdXBwb3J0ZWQgYnkgaGFyZHdhcmUsIHRvbmVzCiAgKiB3aWxsIGJlIHBsYXllZCB3aXRob3V0IGNwdSBsb2FkLiBTbWFsbCBQQlhzIGFuZCBOVC1Nb2RlIGFwcGxpY2F0aW9ucyB3aWxsCiAgKiBub3QgbmVlZCBleHBlbnNpdmUgaGFyZHdhcmUgd2hlbiBwcm9jZXNzaW5nIGNhbGxzLgogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9tSVNETi9kc3BfZHRtZi5jIGIvZHJpdmVycy9pc2RuL21JU0ROL2RzcF9kdG1mLmMKaW5kZXggOWFlMmQzMy4uNWI0ODRjMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL21JU0ROL2RzcF9kdG1mLmMKKysrIGIvZHJpdmVycy9pc2RuL21JU0ROL2RzcF9kdG1mLmMKQEAgLTEwNiw3ICsxMDYsNyBAQAogICogdGVzdGVkIGl0IGFsbG90LiBpdCBldmVuIHdvcmtzIHdpdGggdmVyeSBzaG9ydCB0b25lcyAoNDBtcykuIHRoZSBvbmx5CiAgKiBkaXNhZHZhbnRhZ2UgaXMsIHRoYXQgaXQgZG9lc24ndCB3b3JrIGdvb2Qgd2l0aCBkaWZmZXJlbnQgdm9sdW1lcyBvZiBib3RoCiAgKiB0b25lcy4gdGhpcyB3aWxsIGhhcHBlbiwgaWYgYWNjb3VzdGljYWxseSBjb3VwbGVkIGRpYWxlcnMgYXJlIHVzZWQuCi0gKiBpdCBzb21ldGltZXMgZGV0ZWN0cyB0b25lcyBkdXJpbmcgc3BlYWNoLCB3aGljaCBpcyBub3JtYWwgZm9yIGRlY29kZXJzLgorICogaXQgc29tZXRpbWVzIGRldGVjdHMgdG9uZXMgZHVyaW5nIHNwZWVjaCwgd2hpY2ggaXMgbm9ybWFsIGZvciBkZWNvZGVycy4KICAqIHVzZSBzZXF1ZW5jZXMgdG8gZ2l2ZW4gY29tbWFuZHMgZHVyaW5nIGNhbGxzLgogICoKICAqIGR0bWYgLSBwb2ludHMgdG8gYSBzdHJ1Y3R1cmUgb2YgdGhlIGN1cnJlbnQgZHRtZiBzdGF0ZQpAQCAtMjQ0LDcgKzI0NCw3IEBACiAJCWlmIChyZXN1bHRbaV0gPCB0cmVzaCkgewogCQkJbG93Z3JvdXAgPSAtMTsKIAkJCWhpZ2hncm91cCA9IC0xOwotCQkJYnJlYWs7ICAvKiBub2lzZSBpbmJldHdlZW4gKi8KKwkJCWJyZWFrOyAgLyogbm9pc2UgaW4gYmV0d2VlbiAqLwogCQl9CiAJCS8qIGdvb2QgbGV2ZWwgZm91bmQuIFRoaXMgaXMgYWxsb3dlZCBvbmx5IG9uZSB0aW1lIHBlciBncm91cCAqLwogCQlpZiAoaSA8IE5DT0VGRi8yKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vbUlTRE4vZHNwX3RvbmVzLmMgYi9kcml2ZXJzL2lzZG4vbUlTRE4vZHNwX3RvbmVzLmMKaW5kZXggN2RiZTU0ZS4uNGU0NDQwZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL21JU0ROL2RzcF90b25lcy5jCisrKyBiL2RyaXZlcnMvaXNkbi9tSVNETi9kc3BfdG9uZXMuYwpAQCAtMzk0LDcgKzM5NCw3IEBACiAJd2hpbGUgKGxlbikgewogCQkvKiBmaW5kIHNhbXBsZSB0byBzdGFydCB3aXRoICovCiAJCXdoaWxlICg0MikgewotCQkJLyogd2FycCBhcnJvdW5kICovCisJCQkvKiB3cmFwIGFyb3VuZCAqLwogCQkJaWYgKCFwYXQtPnNlcVtpbmRleF0pIHsKIAkJCQljb3VudCA9IDA7CiAJCQkJaW5kZXggPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL21JU0ROL2wxb2lwX2NvcmUuYyBiL2RyaXZlcnMvaXNkbi9tSVNETi9sMW9pcF9jb3JlLmMKaW5kZXggYmQ1MjZmNi4uMjJmOGVjOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL21JU0ROL2wxb2lwX2NvcmUuYworKysgYi9kcml2ZXJzL2lzZG4vbUlTRE4vbDFvaXBfY29yZS5jCkBAIC0xNzksNyArMTc5LDcgQEAKIC0gVGltZSBCYXNlID0gVGltZXN0YW1wIG9mIGZpcnN0IHNhbXBsZSBpbiBmcmFtZQogVGhlICJUaW1lIEJhc2UiIGlzIHVzZWQgdG8gcmVhcmFuZ2UgcGFja2V0cyBhbmQgdG8gZGV0ZWN0IHBhY2tldCBsb3NzLgogVGhlIDE2IGJpdHMgYXJlIHNlbnQgaW4gbmV0d29yayBvcmRlciAoTVNCIGZpcnN0KSBhbmQgY291bnQgMS84MDAwIHRoIG9mIGEKLXNlY29uZC4gVGhpcyBjYXVzZXMgYSB3cmFwIGFycm91bmQgZWFjaCA4LDE5MiBzZWNvbmRzLiBUaGVyZSBpcyBubyByZXF1aXJlbWVudAorc2Vjb25kLiBUaGlzIGNhdXNlcyBhIHdyYXAgYXJvdW5kIGVhY2ggOCwxOTIgc2Vjb25kcy4gVGhlcmUgaXMgbm8gcmVxdWlyZW1lbnQKIGZvciB0aGUgaW5pdGlhbCAiVGltZSBCYXNlIiwgYnV0IDAgc2hvdWxkIGJlIHVzZWQgZm9yIHRoZSBmaXJzdCBwYWNrZXQuCiBJbiBjYXNlIG9mIEhETEMgZGF0YSwgdGhpcyB0aW1lc3RhbXAgY291bnRzIHRoZSBwYWNrZXQgb3IgYnl0ZSBudW1iZXIuCiAKQEAgLTIwNSw3ICsyMDUsNyBAQAogCiBJZiB0aGUgb25kZW1hbmQgcGFyYW1ldGVyIGlzIGdpdmVuLCB0aGUgcmVtb3RlIElQIGlzIHNldCB0byAwIG9uIHRpbWVvdXQuCiBUaGlzIHdpbGwgc3RvcCBrZWVwYWxpdmUgdHJhZmZpYyB0byByZW1vdGUuIElmIHRoZSByZW1vdGUgaXMgb25saW5lIGFnYWluLAotdHJhZmZpYyB3aWxsIGNvbnRpbnVlIHRvIHRoZSByZW1vdGUgYWRkcmVzcy4gVGhpcyBpcyB1c2VmdWxsIGZvciByb2FkIHdhcnJpb3JzLgordHJhZmZpYyB3aWxsIGNvbnRpbnVlIHRvIHRoZSByZW1vdGUgYWRkcmVzcy4gVGhpcyBpcyB1c2VmdWwgZm9yIHJvYWQgd2FycmlvcnMuCiBUaGlzIGZlYXR1cmUgb25seSB3b3JrcyB3aXRoIElEIHNldCwgb3RoZXJ3aGlzZSBpdCBpcyBoaWdobHkgdW5zZWN1cmUuCiAKIApAQCAtNTkwLDcgKzU5MCw3IEBACiAJCQlyZXR1cm47CiAJCX0KIAl9IGVsc2UKLQkJbWxlbiA9IGxlbi0yOyAvKiBzaW5nbGUgZnJhbWUsIHN1YnN0cmFjdCB0aW1lYmFzZSAqLworCQltbGVuID0gbGVuLTI7IC8qIHNpbmdsZSBmcmFtZSwgc3VidHJhY3QgdGltZWJhc2UgKi8KIAogCWlmIChsZW4gPCAyKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBwYWNrZXQgZXJyb3IgLSBwYWNrZXQgdG9vIHNob3J0LCB0aW1lICIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9tSVNETi9sYXllcjIuYyBiL2RyaXZlcnMvaXNkbi9tSVNETi9sYXllcjIuYwppbmRleCA0YWU3NTA1Li5kMGFlYjQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vbUlTRE4vbGF5ZXIyLmMKKysrIGIvZHJpdmVycy9pc2RuL21JU0ROL2xheWVyMi5jCkBAIC0xODY0LDcgKzE4NjQsNyBAQAogCQlwc2FwaSA+Pj0gMjsKIAkJcHRlaSA+Pj0gMTsKIAkJaWYgKHBzYXBpICE9IGwyLT5zYXBpKSB7Ci0JCQkvKiBub3Qgb3VyIGJ1c3NpbmVzcyAqLworCQkJLyogbm90IG91ciBidXNpbmVzcyAqLwogCQkJaWYgKCpkZWJ1ZyAmIERFQlVHX0wyKQogCQkJCXByaW50ayhLRVJOX0RFQlVHICIlczogc2FwaSAlZC8lZCBtaXNtYXRjaFxuIiwKIAkJCQkJX19mdW5jX18sIHBzYXBpLCBsMi0+c2FwaSk7CkBAIC0xODcyLDcgKzE4NzIsNyBAQAogCQkJcmV0dXJuIDA7CiAJCX0KIAkJaWYgKChwdGVpICE9IGwyLT50ZWkpICYmIChwdGVpICE9IEdST1VQX1RFSSkpIHsKLQkJCS8qIG5vdCBvdXIgYnVzc2luZXNzICovCisJCQkvKiBub3Qgb3VyIGJ1c2luZXNzICovCiAJCQlpZiAoKmRlYnVnICYgREVCVUdfTDIpCiAJCQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiB0ZWkgJWQvJWQgbWlzbWF0Y2hcbiIsCiAJCQkJCV9fZnVuY19fLCBwdGVpLCBsMi0+dGVpKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbGVkcy9sZWRzLXBjYTk1MzIuYyBiL2RyaXZlcnMvbGVkcy9sZWRzLXBjYTk1MzIuYwppbmRleCBhZmFjMzM4Li41YmY2M2FmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2xlZHMvbGVkcy1wY2E5NTMyLmMKKysrIGIvZHJpdmVycy9sZWRzL2xlZHMtcGNhOTUzMi5jCkBAIC01OCw3ICs1OCw3IEBACiAJLmlkX3RhYmxlID0gcGNhOTUzMl9pZCwKIH07CiAKLS8qIFdlIGhhdmUgdHdvIHB3bS9ibGlua2VycywgYnV0IDE2IHBvc3NpYmxlIGxlZHMgdG8gZHJpdmUuIEFkZGl0aW9uYWx5LAorLyogV2UgaGF2ZSB0d28gcHdtL2JsaW5rZXJzLCBidXQgMTYgcG9zc2libGUgbGVkcyB0byBkcml2ZS4gQWRkaXRpb25hbGx5LAogICogdGhlIGNsZXZlciBUaGVjdXMgcGVvcGxlIGFyZSB1c2luZyBvbmUgcHdtIHRvIGRyaXZlIHRoZSBiZWVwZXIuIFNvLAogICogYXMgYSBjb21wcm9taXNlIHdlIGF2ZXJhZ2Ugb25lIHB3bSB0byB0aGUgdmFsdWVzIHJlcXVlc3RlZCBieSBhbGwKICAqIGxlZHMgdGhhdCBhcmUgbm90IE9OL09GRi4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbGVkcy9sZWRzLXdtODM1MC5jIGIvZHJpdmVycy9sZWRzL2xlZHMtd204MzUwLmMKaW5kZXggYTA0NTIzMi4uZjE0ZWRkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9sZWRzL2xlZHMtd204MzUwLmMKKysrIGIvZHJpdmVycy9sZWRzL2xlZHMtd204MzUwLmMKQEAgLTIxNSwxMyArMjE1LDEzIEBACiAKIAlpc2luayA9IHJlZ3VsYXRvcl9nZXQoJnBkZXYtPmRldiwgImxlZF9pc2luayIpOwogCWlmIChJU19FUlIoaXNpbmspKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiJXM6IGNhbnQgZ2V0IElTSU5LXG4iLCBfX2Z1bmNfXyk7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IGNhbid0IGdldCBJU0lOS1xuIiwgX19mdW5jX18pOwogCQlyZXR1cm4gUFRSX0VSUihpc2luayk7CiAJfQogCiAJZGNkYyA9IHJlZ3VsYXRvcl9nZXQoJnBkZXYtPmRldiwgImxlZF92Y2MiKTsKIAlpZiAoSVNfRVJSKGRjZGMpKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiJXM6IGNhbnQgZ2V0IERDRENcbiIsIF9fZnVuY19fKTsKKwkJcHJpbnRrKEtFUk5fRVJSICIlczogY2FuJ3QgZ2V0IERDRENcbiIsIF9fZnVuY19fKTsKIAkJcmV0ID0gUFRSX0VSUihkY2RjKTsKIAkJZ290byBlcnJfaXNpbms7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9sZ3Vlc3QvbGd1ZXN0X3VzZXIuYyBiL2RyaXZlcnMvbGd1ZXN0L2xndWVzdF91c2VyLmMKaW5kZXggM2M3ODFjZC4uOTQ4YzU0NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9sZ3Vlc3QvbGd1ZXN0X3VzZXIuYworKysgYi9kcml2ZXJzL2xndWVzdC9sZ3Vlc3RfdXNlci5jCkBAIC0xMzAsNyArMTMwLDcgQEAKIAlyY3VfYXNzaWduX3BvaW50ZXIobGctPmV2ZW50ZmRzLCBuZXcpOwogCiAJLyoKLQkgKiBXZSdyZSBub3QgaW4gYSBiaWcgaHVycnkuICBXYWl0IHVudGlsIG5vb25lJ3MgbG9va2luZyBhdCBvbGQKKwkgKiBXZSdyZSBub3QgaW4gYSBiaWcgaHVycnkuICBXYWl0IHVudGlsIG5vIG9uZSdzIGxvb2tpbmcgYXQgb2xkCiAJICogdmVyc2lvbiwgdGhlbiBmcmVlIGl0LgogCSAqLwogCXN5bmNocm9uaXplX3JjdSgpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tYWNpbnRvc2gvYWRiaGlkLmMgYi9kcml2ZXJzL21hY2ludG9zaC9hZGJoaWQuYwppbmRleCA1Mzk2YzY3Li4wOWQ3MmJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21hY2ludG9zaC9hZGJoaWQuYworKysgYi9kcml2ZXJzL21hY2ludG9zaC9hZGJoaWQuYwpAQCAtMzI4LDcgKzMyOCw3IEBACiAJc3dpdGNoIChrZXljb2RlKSB7CiAJY2FzZSBBREJfS0VZX0NBUFNMT0NLOgogCQlpZiAoIXJlc3RvcmVfY2Fwc2xvY2tfZXZlbnRzKSB7Ci0JCQkvKiBHZW5lcmF0ZSBkb3duL3VwIGV2ZW50cyBmb3IgQ2Fwc0xvY2sgZXZlcnl0aW1lLiAqLworCQkJLyogR2VuZXJhdGUgZG93bi91cCBldmVudHMgZm9yIENhcHNMb2NrIGV2ZXJ5IHRpbWUuICovCiAJCQlpbnB1dF9yZXBvcnRfa2V5KGFoaWQtPmlucHV0LCBLRVlfQ0FQU0xPQ0ssIDEpOwogCQkJaW5wdXRfc3luYyhhaGlkLT5pbnB1dCk7CiAJCQlpbnB1dF9yZXBvcnRfa2V5KGFoaWQtPmlucHV0LCBLRVlfQ0FQU0xPQ0ssIDApOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tYWNpbnRvc2gvbWFjaW8tYWRiLmMgYi9kcml2ZXJzL21hY2ludG9zaC9tYWNpby1hZGIuYwppbmRleCBiZDZkYTdhLi5iNmVmOGY1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21hY2ludG9zaC9tYWNpby1hZGIuYworKysgYi9kcml2ZXJzL21hY2ludG9zaC9tYWNpby1hZGIuYwpAQCAtMTQ3LDcgKzE0Nyw3IEBACiAKIAkvKiBIcm0uLi4gd2UgbWF5IHdhbnQgdG8gbm90IGxvY2sgaW50ZXJydXB0cyBmb3Igc28KIAkgKiBsb25nIC4uLiBvaCB3ZWxsLCB3aG8gdXNlcyB0aGF0IGNoaXAgYW55d2F5ID8gOikKLQkgKiBUaGF0IGZ1bmN0aW9uIHdpbGwgYmUgc2VsZG9tbHkgdXNlZCBkdXJpbmcgYm9vdAorCSAqIFRoYXQgZnVuY3Rpb24gd2lsbCBiZSBzZWxkb20gdXNlZCBkdXJpbmcgYm9vdAogCSAqIG9uIHJhcmUgbWFjaGluZXMsIHNvLi4uCiAJICovCiAJc3Bpbl9sb2NrX2lycXNhdmUoJm1hY2lvX2xvY2ssIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX2FkdDc0NnguYyBiL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX2FkdDc0NnguYwppbmRleCA5ZTNlMmM1Li4wMjM2NzMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21hY2ludG9zaC90aGVybV9hZHQ3NDZ4LmMKKysrIGIvZHJpdmVycy9tYWNpbnRvc2gvdGhlcm1fYWR0NzQ2eC5jCkBAIC02NjIsNyArNjYyLDcgQEAKIAkJZXJyIHw9IGRldmljZV9jcmVhdGVfZmlsZSgmb2ZfZGV2LT5kZXYsICZkZXZfYXR0cl9zZW5zb3IyX2Zhbl9zcGVlZCk7CiAJaWYgKGVycikKIAkJcHJpbnRrKEtFUk5fV0FSTklORwotCQkJIkZhaWxlZCB0byBjcmVhdGUgdGVtcGVydGF1cmUgYXR0cmlidXRlIGZpbGUocykuXG4iKTsKKwkJCSJGYWlsZWQgdG8gY3JlYXRlIHRlbXBlcmF0dXJlIGF0dHJpYnV0ZSBmaWxlKHMpLlxuIik7CiB9CiAKIHN0YXRpYyB2b2lkIHRoZXJtb3N0YXRfcmVtb3ZlX2ZpbGVzKHZvaWQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21hY2ludG9zaC90aGVybV9wbTcyLmMgYi9kcml2ZXJzL21hY2ludG9zaC90aGVybV9wbTcyLmMKaW5kZXggYzk4NzAzMy4uYmI4YjcyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tYWNpbnRvc2gvdGhlcm1fcG03Mi5jCisrKyBiL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX3BtNzIuYwpAQCAtOTEsNyArOTEsNyBAQAogICoKICAqICBNYXIuIDEwLCAyMDA1IDogMS4yCiAgKgktIEFkZCBiYXNpYyBzdXBwb3J0IGZvciBYc2VydmUgRzUKLSAqCS0gUmV0cmVpdmUgcHVtcHMgbWluL21heCBmcm9tIEVFUFJPTSBpbWFnZSBpbiBkZXZpY2UtdHJlZSAoYnJva2VuKQorICoJLSBSZXRyaWV2ZSBwdW1wcyBtaW4vbWF4IGZyb20gRUVQUk9NIGltYWdlIGluIGRldmljZS10cmVlIChicm9rZW4pCiAgKgktIFVzZSBtaW4vbWF4IG1hY3JvcyBoZXJlIG9yIHRoZXJlCiAgKgktIExhdGVzdCBkYXJ3aW4gdXBkYXRlZCBVM0ggbWluIGZhbiBzcGVlZCB0byAyMCUgUFdNCiAgKgpAQCAtMzc1LDcgKzM3NSw3IEBACiAJCXJjID0gaTJjX21hc3Rlcl9zZW5kKHN0YXRlLT5tb25pdG9yLCBidWYsIDIpOwogCQlpZiAocmMgPD0gMCkKIAkJCWdvdG8gZXJyb3I7Ci0JCS8qIFdhaXQgZm9yIGNvbnZlcnRpb24gKi8KKwkJLyogV2FpdCBmb3IgY29udmVyc2lvbiAqLwogCQltc2xlZXAoMSk7CiAJCS8qIFN3aXRjaCB0byBkYXRhIHJlZ2lzdGVyICovCiAJCWJ1ZlswXSA9IDQ7CkBAIC0xMTkyLDcgKzExOTIsNyBAQAogCQllcnIgfD0gZGV2aWNlX2NyZWF0ZV9maWxlKCZvZl9kZXYtPmRldiwgJmRldl9hdHRyX2NwdTFfaW50YWtlX2Zhbl9ycG0pOwogCX0KIAlpZiAoZXJyKQotCQlwcmludGsoS0VSTl9XQVJOSU5HICJGYWlsZWQgdG8gY3JlYXRlIHNvbWUgb2YgdGhlIGF0cmlidXRlIgorCQlwcmludGsoS0VSTl9XQVJOSU5HICJGYWlsZWQgdG8gY3JlYXRlIHNvbWUgb2YgdGhlIGF0dHJpYnV0ZSIKIAkJCSJmaWxlcyBmb3IgQ1BVICVkXG4iLCBpbmRleCk7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX3dpbmR0dW5uZWwuYyBiL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX3dpbmR0dW5uZWwuYwppbmRleCBkMzc4MTlmLi40NmM0ZTk1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21hY2ludG9zaC90aGVybV93aW5kdHVubmVsLmMKKysrIGIvZHJpdmVycy9tYWNpbnRvc2gvdGhlcm1fd2luZHR1bm5lbC5jCkBAIC00NSw3ICs0NSw3IEBACiAjaW5jbHVkZSA8YXNtL3NlY3Rpb25zLmg+CiAjaW5jbHVkZSA8YXNtL21hY2lvLmg+CiAKLSNkZWZpbmUgTE9HX1RFTVAJCTAJCQkvKiBjb250aW5vdXNseSBsb2cgdGVtcGVyYXR1cmUgKi8KKyNkZWZpbmUgTE9HX1RFTVAJCTAJCQkvKiBjb250aW51b3VzbHkgbG9nIHRlbXBlcmF0dXJlICovCiAKIHN0YXRpYyBzdHJ1Y3QgewogCXZvbGF0aWxlIGludAkJcnVubmluZzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvYml0bWFwLmggYi9kcml2ZXJzL21kL2JpdG1hcC5oCmluZGV4IDkzMWE3YTcuLmQwYWVhZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYml0bWFwLmgKKysrIGIvZHJpdmVycy9tZC9iaXRtYXAuaApAQCAtNDUsNyArNDUsNyBAQAogICoKICAqIFRoZSBjb3VudGVyIGNvdW50cyBwZW5kaW5nIHdyaXRlIHJlcXVlc3RzLCBwbHVzIHRoZSBvbi1kaXNrIGJpdC4KICAqIFdoZW4gdGhlIGNvdW50ZXIgaXMgJzEnIGFuZCB0aGUgcmVzeW5jIGJpdHMgYXJlIGNsZWFyLCB0aGUgb24tZGlzawotICogYml0IGNhbiBiZSBjbGVhcmVkIGFzd2VsbCwgdGh1cyBzZXR0aW5nIHRoZSBjb3VudGVyIHRvIDAuCisgKiBiaXQgY2FuIGJlIGNsZWFyZWQgYXMgd2VsbCwgdGh1cyBzZXR0aW5nIHRoZSBjb3VudGVyIHRvIDAuCiAgKiBXaGVuIHdlIHNldCBhIGJpdCwgb3IgaW4gdGhlIGNvdW50ZXIgKHRvIHN0YXJ0IGEgd3JpdGUpLCBpZiB0aGUgZmllbGRzIGlzCiAgKiAwLCB3ZSBmaXJzdCBzZXQgdGhlIGRpc2sgYml0IGFuZCBzZXQgdGhlIGNvdW50ZXIgdG8gMS4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXJlZ2lvbi1oYXNoLmMgYi9kcml2ZXJzL21kL2RtLXJlZ2lvbi1oYXNoLmMKaW5kZXggZGFkMDExYS4uNzc3MWVkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1yZWdpb24taGFzaC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tcmVnaW9uLWhhc2guYwpAQCAtNDE5LDcgKzQxOSw3IEBACiAJLyoKIAkgKiBQb3NzaWJsZSBjYXNlczoKIAkgKiAgIDEpIERNX1JIX0RJUlRZCi0JICogICAyKSBETV9SSF9OT1NZTkM6IHdhcyBkaXJ0eSwgb3RoZXIgcHJlY2VlZGluZyB3cml0ZXMgZmFpbGVkCisJICogICAyKSBETV9SSF9OT1NZTkM6IHdhcyBkaXJ0eSwgb3RoZXIgcHJlY2VkaW5nIHdyaXRlcyBmYWlsZWQKIAkgKiAgIDMpIERNX1JIX1JFQ09WRVJJTkc6IGZsdXNoaW5nIHBlbmRpbmcgd3JpdGVzCiAJICogRWl0aGVyIGNhc2UsIHRoZSByZWdpb24gc2hvdWxkIGhhdmUgbm90IGJlZW4gY29ubmVjdGVkIHRvIGxpc3QuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2ZhdWx0eS5jIGIvZHJpdmVycy9tZC9mYXVsdHkuYwppbmRleCAzMzlmZGM2Li4yMzA3OGRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2ZhdWx0eS5jCisrKyBiL2RyaXZlcnMvbWQvZmF1bHR5LmMKQEAgLTMwLDcgKzMwLDcgQEAKICAqCiAgKiBEaWZmZXJlbnQgbW9kZXMgY2FuIGJlIGFjdGl2ZSBhdCBhIHRpbWUsIGJ1dCBvbmx5CiAgKiBvbmUgY2FuIGJlIHNldCBhdCBhcnJheSBjcmVhdGlvbi4gIE90aGVycyBjYW4gYmUgYWRkZWQgbGF0ZXIuCi0gKiBBIG1vZGUgY2FuIGJlIG9uZS1zaG90IG9yIHJlY3VycmVudCB3aXRoIHRoZSByZWN1cnJhbmNlIGJlaW5nCisgKiBBIG1vZGUgY2FuIGJlIG9uZS1zaG90IG9yIHJlY3VycmVudCB3aXRoIHRoZSByZWN1cnJlbmNlIGJlaW5nCiAgKiBvbmNlIGluIGV2ZXJ5IE4gcmVxdWVzdHMuCiAgKiBUaGUgYm90dG9tIDUgYml0cyBvZiB0aGUgImxheW91dCIgaW5kaWNhdGUgdGhlIG1vZGUuICBUaGUKICAqIHJlbWFpbmRlciBpbmRpY2F0ZSBhIHBlcmlvZCwgb3IgMCBmb3Igb25lLXNob3QuCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLmMgYi9kcml2ZXJzL21kL21kLmMKaW5kZXggOGI2NmUwNC4uYjEyYjM3NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9tZC5jCisrKyBiL2RyaXZlcnMvbWQvbWQuYwpAQCAtNjI2Niw3ICs2MjY2LDcgQEAKIAkgKiBydCBpcyBhIHNlY3Rvcl90LCBzbyBjb3VsZCBiZSAzMmJpdCBvciA2NGJpdC4KIAkgKiBTbyB3ZSBkaXZpZGUgYmVmb3JlIG11bHRpcGx5IGluIGNhc2UgaXQgaXMgMzJiaXQgYW5kIGNsb3NlCiAJICogdG8gdGhlIGxpbWl0LgotCSAqIFdlIHNjYWxlIHRoZSBkaXZpc29yIChkYikgYnkgMzIgdG8gYXZvaWQgbG9vc2luZyBwcmVjaXNpb24KKwkgKiBXZSBzY2FsZSB0aGUgZGl2aXNvciAoZGIpIGJ5IDMyIHRvIGF2b2lkIGxvc2luZyBwcmVjaXNpb24KIAkgKiBuZWFyIHRoZSBlbmQgb2YgcmVzeW5jIHdoZW4gdGhlIG51bWJlciBvZiByZW1haW5pbmcgc2VjdG9ycwogCSAqIGlzIGNsb3NlIHRvICdkYicuCiAJICogV2UgdGhlbiBkaXZpZGUgcnQgYnkgMzIgYWZ0ZXIgbXVsdGlwbHlpbmcgYnkgZGIgdG8gY29tcGVuc2F0ZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvbWQuaCBiL2RyaXZlcnMvbWQvbWQuaAppbmRleCAxMjIxNWQ0Li41MmI0MDczIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL21kLmgKKysrIGIvZHJpdmVycy9tZC9tZC5oCkBAIC05NCw3ICs5NCw3IEBACiAjZGVmaW5lCUluX3N5bmMJCTIJCS8qIGRldmljZSBpcyBpbl9zeW5jIHdpdGggcmVzdCBvZiBhcnJheSAqLwogI2RlZmluZQlXcml0ZU1vc3RseQk0CQkvKiBBdm9pZCByZWFkaW5nIGlmIGF0IGFsbCBwb3NzaWJsZSAqLwogI2RlZmluZQlBdXRvRGV0ZWN0ZWQJNwkJLyogYWRkZWQgYnkgYXV0by1kZXRlY3QgKi8KLSNkZWZpbmUgQmxvY2tlZAkJOAkJLyogQW4gZXJyb3Igb2NjdXJlZCBvbiBhbiBleHRlcm5hbGx5CisjZGVmaW5lIEJsb2NrZWQJCTgJCS8qIEFuIGVycm9yIG9jY3VycmVkIG9uIGFuIGV4dGVybmFsbHkKIAkJCQkJICogbWFuYWdlZCBhcnJheSwgZG9uJ3QgYWxsb3cgd3JpdGVzCiAJCQkJCSAqIHVudGlsIGl0IGlzIGNsZWFyZWQgKi8KIAl3YWl0X3F1ZXVlX2hlYWRfdCBibG9ja2VkX3dhaXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQxMC5jIGIvZHJpdmVycy9tZC9yYWlkMTAuYwppbmRleCBmN2I2MjM3Li4yZGE4M2Q1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxMC5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDEwLmMKQEAgLTUsNyArNSw3IEBACiAgKgogICogUkFJRC0xMCBzdXBwb3J0IGZvciBtZC4KICAqCi0gKiBCYXNlIG9uIGNvZGUgaW4gcmFpZDEuYy4gIFNlZSByYWlkMS5jIGZvciBmdXRoZXIgY29weXJpZ2h0IGluZm9ybWF0aW9uLgorICogQmFzZSBvbiBjb2RlIGluIHJhaWQxLmMuICBTZWUgcmFpZDEuYyBmb3IgZnVydGhlciBjb3B5cmlnaHQgaW5mb3JtYXRpb24uCiAgKgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CkBAIC0zNDAsMTQgKzM0MCwxNCBAQAogCiAvKgogICogUkFJRDEwIGxheW91dCBtYW5hZ2VyCi0gKiBBc3dlbGwgYXMgdGhlIGNodW5rc2l6ZSBhbmQgcmFpZF9kaXNrcyBjb3VudCwgdGhlcmUgYXJlIHR3bworICogQXMgd2VsbCBhcyB0aGUgY2h1bmtzaXplIGFuZCByYWlkX2Rpc2tzIGNvdW50LCB0aGVyZSBhcmUgdHdvCiAgKiBwYXJhbWV0ZXJzOiBuZWFyX2NvcGllcyBhbmQgZmFyX2NvcGllcy4KICAqIG5lYXJfY29waWVzICogZmFyX2NvcGllcyBtdXN0IGJlIDw9IHJhaWRfZGlza3MuCiAgKiBOb3JtYWxseSBvbmUgb2YgdGhlc2Ugd2lsbCBiZSAxLgogICogSWYgYm90aCBhcmUgMSwgd2UgZ2V0IHJhaWQwLgogICogSWYgbmVhcl9jb3BpZXMgPT0gcmFpZF9kaXNrcywgd2UgZ2V0IHJhaWQxLgogICoKLSAqIENodW5rcyBhcmUgbGF5ZWQgb3V0IGluIHJhaWQwIHN0eWxlIHdpdGggbmVhcl9jb3BpZXMgY29waWVzIG9mIHRoZQorICogQ2h1bmtzIGFyZSBsYWlkIG91dCBpbiByYWlkMCBzdHlsZSB3aXRoIG5lYXJfY29waWVzIGNvcGllcyBvZiB0aGUKICAqIGZpcnN0IGNodW5rLCBmb2xsb3dlZCBieSBuZWFyX2NvcGllcyBjb3BpZXMgb2YgdGhlIG5leHQgY2h1bmsgYW5kCiAgKiBzbyBvbi4KICAqIElmIGZhcl9jb3BpZXMgPiAxLCB0aGVuIGFmdGVyIDEvZmFyX2NvcGllcyBvZiB0aGUgYXJyYXkgaGFzIGJlZW4gYXNzaWduZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDEwLmggYi9kcml2ZXJzL21kL3JhaWQxMC5oCmluZGV4IDIzMTZhYzIuLjk0NGIxMTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDEwLmgKKysrIGIvZHJpdmVycy9tZC9yYWlkMTAuaApAQCAtMTcsOCArMTcsOCBAQAogCXNwaW5sb2NrX3QJCWRldmljZV9sb2NrOwogCiAJLyogZ2VvbWV0cnkgKi8KLQlpbnQJCQluZWFyX2NvcGllczsgIC8qIG51bWJlciBvZiBjb3BpZXMgbGF5ZWQgb3V0IHJhaWQwIHN0eWxlICovCi0JaW50IAkJCWZhcl9jb3BpZXM7ICAgLyogbnVtYmVyIG9mIGNvcGllcyBsYXllZCBvdXQKKwlpbnQJCQluZWFyX2NvcGllczsgIC8qIG51bWJlciBvZiBjb3BpZXMgbGFpZCBvdXQgcmFpZDAgc3R5bGUgKi8KKwlpbnQgCQkJZmFyX2NvcGllczsgICAvKiBudW1iZXIgb2YgY29waWVzIGxhaWQgb3V0CiAJCQkJCSAgICAgICAqIGF0IGxhcmdlIHN0cmlkZXMgYWNyb3NzIGRyaXZlcwogCQkJCQkgICAgICAgKi8KIAlpbnQJCQlmYXJfb2Zmc2V0OyAgIC8qIGZhcl9jb3BpZXMgYXJlIG9mZnNldCBieSAxIHN0cmlwZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl9pMmMuYyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3NhYTcxNDZfaTJjLmMKaW5kZXggNzRlZTE3Mi4uYjJiYTlkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl9pMmMuYworKysgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X2kyYy5jCkBAIC0xNjEsNyArMTYxLDcgQEAKIAkJbXNsZWVwKFNBQTcxNDZfSTJDX0RFTEFZKTsKIAl9CiAKLQkvKiBpZiBhbnkgZXJyb3IgaXMgc3RpbGwgcHJlc2VudCwgYSBmYXRhbCBlcnJvciBoYXMgb2NjdXJlZCAuLi4gKi8KKwkvKiBpZiBhbnkgZXJyb3IgaXMgc3RpbGwgcHJlc2VudCwgYSBmYXRhbCBlcnJvciBoYXMgb2NjdXJyZWQgLi4uICovCiAJc3RhdHVzID0gc2FhNzE0Nl9pMmNfc3RhdHVzKGRldik7CiAJaWYgKCBkZXYtPmkyY19iaXRyYXRlICE9IHN0YXR1cyApIHsKIAkJREVCX0kyQygoImZhdGFsIGVycm9yLiBzdGF0dXM6MHglMDh4XG4iLHN0YXR1cykpOwpAQCAtMzI2LDkgKzMyNiw5IEBACiAJCQlpZiAoIDAgIT0gZXJyKSB7CiAJCQkJLyogdGhpcyBvbmUgaXMgdW5zYXRpc2Z5aW5nOiBzb21lIGkyYyBzbGF2ZXMgb24gc29tZQogCQkJCSAgIGR2YiBjYXJkcyBkb24ndCBhY2tub3dsZWRnZSBjb3JyZWN0bHksIHNvIHRoZSBzYWE3MTQ2Ci0JCQkJICAgdGhpbmtzIHRoYXQgYW4gYWRkcmVzcyBlcnJvciBvY2N1cmVkLiBpbiB0aGF0IGNhc2UsIHRoZQorCQkJCSAgIHRoaW5rcyB0aGF0IGFuIGFkZHJlc3MgZXJyb3Igb2NjdXJyZWQuIGluIHRoYXQgY2FzZSwgdGhlCiAJCQkJICAgdHJhbnNhY3Rpb24gc2hvdWxkIGJlIHJldHJ5aW5nLCBldmVuIGlmIGFuIGFkZHJlc3MgZXJyb3IKLQkJCQkgICBvY2N1cmVkLiBhbmFsb2cgc2FhNzE0NiBiYXNlZCBjYXJkcyBleHRlbnNpdmVseSByZWx5IG9uCisJCQkJICAgb2NjdXJyZWQuIGFuYWxvZyBzYWE3MTQ2IGJhc2VkIGNhcmRzIGV4dGVuc2l2ZWx5IHJlbHkgb24KIAkJCQkgICBpMmMgYWRkcmVzcyBwcm9iaW5nLCBob3dldmVyLCBhbmQgYWRkcmVzcyBlcnJvcnMgaW5kaWNhdGUgdGhhdCBhCiAJCQkJICAgZGV2aWNlIGlzIHJlYWxseSAqbm90KiB0aGVyZS4gcmV0cnlpbmcgaW4gdGhhdCBjYXNlCiAJCQkJICAgaW5jcmVhc2VzIHRoZSB0aW1lIHRoZSBkZXZpY2UgbmVlZHMgdG8gcHJvYmUgZ3JlYXRseSwgc28KQEAgLTM2NSw3ICszNjUsNyBAQAogCURFQl9JMkMoKCJ0cmFuc21pc3Npb24gc3VjY2Vzc2Z1bC4gKG1zZzolZCkuXG4iLGVycikpOwogb3V0OgogCS8qIGFub3RoZXIgYnVnIGluIHJldmlzaW9uIDA6IHRoZSBpMmMtcmVnaXN0ZXJzIGdldCB1cGxvYWRlZCByYW5kb21seSBieSBvdGhlcgotCSAgIHVwbG9hZHMsIHNvIHdlIGJldHRlciBjbGVhciB0aGVtIG91dCBiZWZvcmUgY29udGludWVpbmcgKi8KKwkgICB1cGxvYWRzLCBzbyB3ZSBiZXR0ZXIgY2xlYXIgdGhlbSBvdXQgYmVmb3JlIGNvbnRpbnVpbmcgKi8KIAlpZiggMCA9PSBkZXYtPnJldmlzaW9uICkgewogCQlfX2xlMzIgemVybyA9IDA7CiAJCXNhYTcxNDZfaTJjX3Jlc2V0KGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2NvbW1vbi90dW5lcnMvbXhsNTAwNXMuYyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3R1bmVycy9teGw1MDA1cy5jCmluZGV4IDYwNWUyOGIuLjBkNmUwOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3R1bmVycy9teGw1MDA1cy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3R1bmVycy9teGw1MDA1cy5jCkBAIC0xMDYsNyArMTA2LDcgQEAKIC8qIE1YTDUwMDUgVHVuZXIgUmVnaXN0ZXIgU3RydWN0ICovCiBzdHJ1Y3QgVHVuZXJSZWcgewogCXUxNiBSZWdfTnVtOwkvKiBUdW5lciBSZWdpc3RlciBBZGRyZXNzICovCi0JdTE2IFJlZ19WYWw7CS8qIEN1cnJlbnQgc3cgcHJvZ3JhbW1lZCB2YWx1ZSB3YWl0aW5nIHRvIGJlIHdyaXRlbiAqLworCXUxNiBSZWdfVmFsOwkvKiBDdXJyZW50IHN3IHByb2dyYW1tZWQgdmFsdWUgd2FpdGluZyB0byBiZSB3cml0dGVuICovCiB9OwogCiBlbnVtIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3R1bmVycy90ZGExODI3MS5oIGIvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL3RkYTE4MjcxLmgKaW5kZXggM2FiYjIyMS4uNTBjZmE4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL3RkYTE4MjcxLmgKKysrIGIvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL3RkYTE4MjcxLmgKQEAgLTk4LDcgKzk4LDcgQEAKIAkvKiBvdXRwdXQgb3B0aW9ucyB0aGF0IGNhbiBiZSBkaXNhYmxlZCAqLwogCWVudW0gdGRhMTgyNzFfb3V0cHV0X29wdGlvbnMgb3V0cHV0X29wdDsKIAotCS8qIHNvbWUgaTJjIHByb3ZpZGVycyBjYW50IHdyaXRlIGFsbCAzOSByZWdpc3RlcnMgYXQgb25jZSAqLworCS8qIHNvbWUgaTJjIHByb3ZpZGVycyBjYW4ndCB3cml0ZSBhbGwgMzkgcmVnaXN0ZXJzIGF0IG9uY2UgKi8KIAllbnVtIHRkYTE4MjcxX3NtYWxsX2kyYyBzbWFsbF9pMmM7CiAKIAkvKiBmb3JjZSByZiB0cmFja2luZyBmaWx0ZXIgY2FsaWJyYXRpb24gb24gc3RhcnR1cCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvYjJjMi9mbGV4Y29wLXBjaS5jIGIvZHJpdmVycy9tZWRpYS9kdmIvYjJjMi9mbGV4Y29wLXBjaS5jCmluZGV4IDIyN2MwMjAuLjk1NTI1NDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2IyYzIvZmxleGNvcC1wY2kuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9iMmMyL2ZsZXhjb3AtcGNpLmMKQEAgLTU4LDcgKzU4LDcgQEAKIAogCWludCBhY3RpdmVfZG1hMV9hZGRyOyAvKiAwID0gYWRkcjAgb2YgZG1hMTsgMSA9IGFkZHIxIG9mIGRtYTEgKi8KIAl1MzIgbGFzdF9kbWExX2N1cl9wb3M7Ci0JLyogcG9zaXRpb24gb2YgdGhlIHBvaW50ZXIgbGFzdCB0aW1lIHRoZSB0aW1lci9wYWNrZXQgaXJxIG9jY3VyZWQgKi8KKwkvKiBwb3NpdGlvbiBvZiB0aGUgcG9pbnRlciBsYXN0IHRpbWUgdGhlIHRpbWVyL3BhY2tldCBpcnEgb2NjdXJyZWQgKi8KIAlpbnQgY291bnQ7CiAJaW50IGNvdW50X3ByZXY7CiAJaW50IHN0cmVhbV9wcm9ibGVtOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvYnQ4eHgvZHZiLWJ0OHh4LmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9idDh4eC9kdmItYnQ4eHguYwppbmRleCA3OGZjNDY5Li4xZTExMDZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9idDh4eC9kdmItYnQ4eHguYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9idDh4eC9kdmItYnQ4eHguYwpAQCAtNDI3LDEwICs0MjcsMTAgQEAKIAlzdHJ1Y3QgZHZiX2J0OHh4X2NhcmQgKmJ0ID0gZmUtPmR2Yi0+cHJpdjsKIAogCS8qIFJFU0VUIERFVklDRQotCSAqIHJlc2V0IGlzIGNvbnRyb2xlZCBieSBHUElPLTAKKwkgKiByZXNldCBpcyBjb250cm9sbGVkIGJ5IEdQSU8tMAogCSAqIHdoZW4gc2V0IHRvIDAgY2F1c2VzIHJlc2V0IGFuZCB3aGVuIHRvIDEgZm9yIG5vcm1hbCBvcAogCSAqIG11c3QgcmVtYWluIHJlc2V0IGZvciAxMjggY2xvY2sgY3ljbGVzIG9uIGEgNTBNaHogY2xvY2sKLQkgKiBhbHNvIFBSTTEgUFJNMiAmIFBSTTQgYXJlIGNvbnRyb2xlZCBieSBHUElPLTEsR1BJTy0yICYgR1BJTy00CisJICogYWxzbyBQUk0xIFBSTTIgJiBQUk00IGFyZSBjb250cm9sbGVkIGJ5IEdQSU8tMSxHUElPLTIgJiBHUElPLTQKIAkgKiBXZSBhc3N1bWUgdGhhdCB0aGUgcmVzZXQgaGFzIGJlIGhlbGQgbG93IGxvbmcgZW5vdWdoIG9yIHdlCiAJICogaGF2ZSBiZWVuIHJlc2V0IGJ5IGEgcG93ZXIgb24uICBXaGVuIHRoZSBkcml2ZXIgaXMgdW5sb2FkZWQKIAkgKiByZXNldCBzZXQgdG8gMCBzbyBpZiByZWxvYWRlZCB3ZSBoYXZlIGJlZW4gcmVzZXQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9kdmItY29yZS9kdmJfZnJvbnRlbmQuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi1jb3JlL2R2Yl9mcm9udGVuZC5jCmluZGV4IGNhZDY2MzQuLjMxZTJjMGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi1jb3JlL2R2Yl9mcm9udGVuZC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi1jb3JlL2R2Yl9mcm9udGVuZC5jCkBAIC0xNjM4LDcgKzE2MzgsNyBAQAogCWNhc2UgRkVfUkVBRF9TVEFUVVM6IHsKIAkJZmVfc3RhdHVzX3QqIHN0YXR1cyA9IHBhcmc7CiAKLQkJLyogaWYgcmV0dW5lIHdhcyByZXF1ZXN0ZWQgYnV0IGhhc24ndCBvY2N1cmVkIHlldCwgcHJldmVudAorCQkvKiBpZiByZXR1bmUgd2FzIHJlcXVlc3RlZCBidXQgaGFzbid0IG9jY3VycmVkIHlldCwgcHJldmVudAogCQkgKiB0aGF0IHVzZXIgZ2V0IHNpZ25hbCBzdGF0ZSBmcm9tIHByZXZpb3VzIHR1bmluZyAqLwogCQlpZiAoZmVwcml2LT5zdGF0ZSA9PSBGRVNUQVRFX1JFVFVORSB8fAogCQkgICAgZmVwcml2LT5zdGF0ZSA9PSBGRVNUQVRFX0VSUk9SKSB7CkBAIC0xNzI5LDcgKzE3MjksNyBAQAogCQkJICogRGlzaCBuZXR3b3JrIGxlZ2FjeSBzd2l0Y2hlcyAoYXMgdXNlZCBieSBEaXNoNTAwKQogCQkJICogYXJlIGNvbnRyb2xsZWQgYnkgc2VuZGluZyA5LWJpdCBjb21tYW5kIHdvcmRzCiAJCQkgKiBzcGFjZWQgOG1zZWMgYXBhcnQuCi0JCQkgKiB0aGUgYWN0dWFsIGNvbW1hbmQgd29yZCBpcyBzd2l0Y2gvcG9ydCBkZXBlbmRhbnQKKwkJCSAqIHRoZSBhY3R1YWwgY29tbWFuZCB3b3JkIGlzIHN3aXRjaC9wb3J0IGRlcGVuZGVudAogCQkJICogc28gaXQgaXMgdXAgdG8gdGhlIHVzZXJzcGFjZSBhcHBsaWNhdGlvbiB0byBzZW5kCiAJCQkgKiB0aGUgcmlnaHQgY29tbWFuZC4KIAkJCSAqIFRoZSBjb21tYW5kIG11c3QgYWx3YXlzIHN0YXJ0IHdpdGggYSAnMCcgYWZ0ZXIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi11c2IvYWY5MDA1LWZlLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9kdmItdXNiL2FmOTAwNS1mZS5jCmluZGV4IDE5OWVjZTAuLjZhZDk0NzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi11c2IvYWY5MDA1LWZlLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZHZiLXVzYi9hZjkwMDUtZmUuYwpAQCAtNTgwLDcgKzU4MCw3IEBACiAJCU5TX2NvZWZmMl84ayA9IDB4NzI0OTI1OwogCQlicmVhazsKIAlkZWZhdWx0OgotCQllcnIoIkludmFsaWQgYmFuZHdpdGggJWQuIiwgYncpOworCQllcnIoIkludmFsaWQgYmFuZHdpZHRoICVkLiIsIGJ3KTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCkBAIC03ODksNyArNzg5LDcgQEAKIAkJdGVtcCA9IDI7CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCWVycigiSW52YWxpZCBiYW5kd2l0aCAlZC4iLCBidyk7CisJCWVycigiSW52YWxpZCBiYW5kd2lkdGggJWQuIiwgYncpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAJcmV0dXJuIGFmOTAwNV93cml0ZV9yZWdpc3Rlcl9iaXRzKGQsIHhkX2dfcmVnX2J3LCByZWdfYndfcG9zLApAQCAtOTMwLDcgKzkzMCw3IEBACiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAotCS8qIGluaXQgb3RoZXIgcGFyYW1ldGVyczogcHJvZ3JhbSBjZm9lIGFuZCBzZWxlY3QgYmFuZHdpdGggKi8KKwkvKiBpbml0IG90aGVyIHBhcmFtZXRlcnM6IHByb2dyYW0gY2ZvZSBhbmQgc2VsZWN0IGJhbmR3aWR0aCAqLwogCWRlYl9pbmZvKCJwcm9ncmFtIGNmb2VcbiIpOwogCWlmICgocmV0ID0gYWY5MDA1X2ZlX3Byb2dyYW1fY2ZvZShzdGF0ZS0+ZCwgQkFORFdJRFRIXzZfTUhaKSkpCiAJCXJldHVybiByZXQ7CkBAIC0xMTY3LDcgKzExNjcsNyBAQAogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKLQkvKiBzZWxlY3QgYmFuZHdpdGggKi8KKwkvKiBzZWxlY3QgYmFuZHdpZHRoICovCiAJZGViX2luZm8oInNlbGVjdCBiYW5kd2lkdGgiKTsKIAlyZXQgPSBhZjkwMDVfZmVfc2VsZWN0X2J3KHN0YXRlLT5kLCBmZXAtPnUub2ZkbS5iYW5kd2lkdGgpOwogCWlmIChyZXQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9kdmItdXNiL2ZyaWlvLmggYi9kcml2ZXJzL21lZGlhL2R2Yi9kdmItdXNiL2ZyaWlvLmgKaW5kZXggYWY4ZDU1ZS4uMGY0NjFjYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZHZiLXVzYi9mcmlpby5oCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi11c2IvZnJpaW8uaApAQCAtMjAsNyArMjAsNyBAQAogICogICAgICAgICBGcm9udGVuZDogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbXRlY2ggSkRWQlQtOTA1MDIKICAqICAgICAgICAgICAgICh0dW5lciBQTEw6ICAgICAgICAgICAgICAgICAgICAgICB0dWE2MDM0LCBJMkMgYWRkcjooMHhDMCA+PiAxKSkKICAqICAgICAgICAgICAgIChPRkRNIGRlbW9kdWxhdG9yOiAgICAgICAgICAgICAgICBUQzkwNTAyLCBJMkMgYWRkcjooMHgzMCA+PiAxKSkKLSAqICAgICAgICAgTEVEIHgzICgrTE5CKSBjb250cm9sbDogICAgICAgICAgICAgICBQSUMgMTZGNjc2CisgKiAgICAgICAgIExFRCB4MyAoK0xOQikgY29udHJvbDogICAgICAgICAgICAgICAgUElDIDE2RjY3NgogICogICAgICAgICBFRVBST006ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDI0QzA4CiAgKgogICogICAgICAgIChVU0Igc21hcnQgY2FyZCByZWFkZXI6ICAgICAgICAgICAgICAgIEFVOTUyMikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi11c2IvbG1lZG0wNC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZHZiLXVzYi9sbWVkbTA0LmMKaW5kZXggY2QyNmU3Yy4uZjJkYjAxMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZHZiLXVzYi9sbWVkbTA0LmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZHZiLXVzYi9sbWVkbTA0LmMKQEAgLTMyMSw3ICszMjEsNyBAQAogCWxtZV9pbnQtPmxtZV91cmItPnRyYW5zZmVyX2ZsYWdzIHw9IFVSQl9OT19UUkFOU0ZFUl9ETUFfTUFQOwogCiAJdXNiX3N1Ym1pdF91cmIobG1lX2ludC0+bG1lX3VyYiwgR0ZQX0FUT01JQyk7Ci0JaW5mbygiSU5UIEludGVydXB0IFNlcnZpY2UgU3RhcnRlZCIpOworCWluZm8oIklOVCBJbnRlcnJ1cHQgU2VydmljZSBTdGFydGVkIik7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTQ4Miw3ICs0ODIsNyBAQAogCQkJYnJlYWs7CiAJCX0KIAotCQlkZWJfaW5mbyg0LCAiSTJDIEZyb20gSW50ZXJ1cHQgTWVzc2FnZSBvdXQoJTAyeCkgaW4oJTAyeCkiLAorCQlkZWJfaW5mbyg0LCAiSTJDIEZyb20gSW50ZXJydXB0IE1lc3NhZ2Ugb3V0KCUwMngpIGluKCUwMngpIiwKIAkJCQl3YnVmWzNdLCByYnVmWzFdKTsKIAogCX0KQEAgLTYzMiwxMSArNjMyLDExIEBACiAJfQogCWQtPnJjX2RldiA9IHJjOwogCi0JLyogU3RhcnQgdGhlIEludGVydXB0ICovCisJLyogU3RhcnQgdGhlIEludGVycnVwdCAqLwogCXJldCA9IGxtZTI1MTBfaW50X3JlYWQoYWRhcCk7CiAJaWYgKHJldCA8IDApIHsKIAkJcmNfdW5yZWdpc3Rlcl9kZXZpY2UocmMpOwotCQlpbmZvKCJJTlQgVW5hYmxlIHRvIHN0YXJ0IEludGVydXB0IFNlcnZpY2UiKTsKKwkJaW5mbygiSU5UIFVuYWJsZSB0byBzdGFydCBJbnRlcnJ1cHQgU2VydmljZSIpOwogCQlyZXR1cm4gLUVOT0RFVjsKIAl9CiAKQEAgLTEwMDMsNyArMTAwMyw3IEBACiAJCXJldHVybiAtRU5PREVWOwogCX0KIAotCS8qIFN0YXJ0IHRoZSBJbnRlcnVwdCAmIFJlbW90ZSovCisJLyogU3RhcnQgdGhlIEludGVycnVwdCAmIFJlbW90ZSovCiAJcmV0ID0gbG1lMjUxMF9pbnRfc2VydmljZShhZGFwKTsKIAogCXJldHVybiByZXQ7CkBAIC0xMTcxLDcgKzExNzEsNyBAQAogCQl1c2Jfa2lsbF91cmIoc3QtPmxtZV91cmIpOwogCQl1c2JfZnJlZV9jb2hlcmVudChkLT51ZGV2LCA1MDAwLCBzdC0+YnVmZmVyLAogCQkJCSAgc3QtPmxtZV91cmItPnRyYW5zZmVyX2RtYSk7Ci0JCWluZm8oIkludGVydXB0IFNlcnZpY2UgU3RvcHBlZCIpOworCQlpbmZvKCJJbnRlcnJ1cHQgU2VydmljZSBTdG9wcGVkIik7CiAJCXJjX3VucmVnaXN0ZXJfZGV2aWNlKGQtPnJjX2Rldik7CiAJCWluZm8oIlJlbW90ZSBTdG9wcGVkIik7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2F0Ym04ODMwLmggYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYXRibTg4MzAuaAppbmRleCBlODE0OWYzLi4wMjQyNzMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYXRibTg4MzAuaAorKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYXRibTg4MzAuaApAQCAtMzksNyArMzksNyBAQAogCS8qIHBhcmFsbGVsIG9yIHNlcmlhbCB0cmFuc3BvcnQgc3RyZWFtICovCiAJdTggc2VyaWFsX3RzOwogCi0JLyogdHJhbnNwb3J0IHN0cmVhbSBjbG9jayBvdXRwdXQgb25seSB3aGVuIHJlY2V2aW5nIHZhbGlkIHN0cmVhbSAqLworCS8qIHRyYW5zcG9ydCBzdHJlYW0gY2xvY2sgb3V0cHV0IG9ubHkgd2hlbiByZWNlaXZpbmcgdmFsaWQgc3RyZWFtICovCiAJdTggdHNfY2xrX2dhdGVkOwogCiAJLyogRGVjb2RlciBzYW1wbGUgVFMgZGF0YSBhdCByaXNpbmcgZWRnZSBvZiBjbG9jayAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2F1ODUyMl9kaWcuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9hdTg1MjJfZGlnLmMKaW5kZXggNjVmNmEzNi4uMWQ1NzI5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2F1ODUyMl9kaWcuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYXU4NTIyX2RpZy5jCkBAIC02MzUsNyArNjM1LDcgQEAKIAlzdHJ1Y3QgYXU4NTIyX2xlZF9jb25maWcgKmxlZF9jb25maWcgPSBzdGF0ZS0+Y29uZmlnLT5sZWRfY2ZnOwogCXU4IHZhbDsKIAotCS8qIGJhaWwgb3V0IGlmIHdlIGNhbnQgY29udHJvbCBhbiBMRUQgKi8KKwkvKiBiYWlsIG91dCBpZiB3ZSBjYW4ndCBjb250cm9sIGFuIExFRCAqLwogCWlmICghbGVkX2NvbmZpZyB8fCAhbGVkX2NvbmZpZy0+Z3Bpb19vdXRwdXQgfHwKIAkgICAgIWxlZF9jb25maWctPmdwaW9fb3V0cHV0X2VuYWJsZSB8fCAhbGVkX2NvbmZpZy0+Z3Bpb19vdXRwdXRfZGlzYWJsZSkKIAkJcmV0dXJuIDA7CkBAIC02NjUsNyArNjY1LDcgQEAKIAlzdHJ1Y3QgYXU4NTIyX2xlZF9jb25maWcgKmxlZF9jb25maWcgPSBzdGF0ZS0+Y29uZmlnLT5sZWRfY2ZnOwogCWludCBpLCByZXQgPSAwOwogCi0JLyogYmFpbCBvdXQgaWYgd2UgY2FudCBjb250cm9sIGFuIExFRCAqLworCS8qIGJhaWwgb3V0IGlmIHdlIGNhbid0IGNvbnRyb2wgYW4gTEVEICovCiAJaWYgKCFsZWRfY29uZmlnIHx8ICFsZWRfY29uZmlnLT5ncGlvX2xlZHMgfHwKIAkgICAgIWxlZF9jb25maWctPm51bV9sZWRfc3RhdGVzIHx8ICFsZWRfY29uZmlnLT5sZWRfc3RhdGVzKQogCQlyZXR1cm4gMDsKQEAgLTgwMyw3ICs4MDMsNyBAQAogCWludCBsZWQ7CiAJdTE2IHN0cm9uZzsKIAotCS8qIGJhaWwgb3V0IGlmIHdlIGNhbnQgY29udHJvbCBhbiBMRUQgKi8KKwkvKiBiYWlsIG91dCBpZiB3ZSBjYW4ndCBjb250cm9sIGFuIExFRCAqLwogCWlmICghbGVkX2NvbmZpZykKIAkJcmV0dXJuIDA7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9iY20zNTEwLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYmNtMzUxMC5jCmluZGV4IGNmNWU1NzYuLjhhZmY1ODYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9iY20zNTEwLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2JjbTM1MTAuYwpAQCAtMTU1LDcgKzE1NSw3IEBACiAJdW5zaWduZWQgbG9uZyB0OwogCiAvKiBDaGVjayBpZiBhbnkgcHJldmlvdXMgSEFCIHJlcXVlc3Qgc3RpbGwgbmVlZHMgdG8gYmUgc2VydmljZWQgYnkgdGhlCi0gKiBBcXVpc2l0aW9uIFByb2Nlc3NvciBiZWZvcmUgc2VuZGluZyBuZXcgcmVxdWVzdCAqLworICogQWNxdWlzaXRpb24gUHJvY2Vzc29yIGJlZm9yZSBzZW5kaW5nIG5ldyByZXF1ZXN0ICovCiAJaWYgKChyZXQgPSBiY20zNTEwX3JlYWRCKHN0LDB4YTgsJnYpKSA8IDApCiAJCXJldHVybiByZXQ7CiAJaWYgKHYuSEFCU1RBVF9hOC5IQUJSKSB7CkBAIC0zNjEsNyArMzYxLDcgQEAKIC8qIFNldCBkdXJhdGlvbiBvZiB0aGUgaW5pdGlhbCBzdGF0ZSBvZiBUVU5DVEwgPSAzLjM0IG1pY3JvIFNlYyAqLwogCWMuVFVOQ1RMX3N0YXRlID0gMHg0MDsKIAotLyogUFJFU0NBTEVSIERFVklERSBSQVRJTyB8IEJDMV8yXzNfNDsgKGJhbmQgc3dpdGNoKSwgMXN0b3NjIFJFRkVSRU5DRSBDT1VOVEVSIFJFRl9TMTIgYW5kIFJFRl9TMTEgKi8KKy8qIFBSRVNDQUxFUiBESVZJREUgUkFUSU8gfCBCQzFfMl8zXzQ7IChiYW5kIHN3aXRjaCksIDFzdG9zYyBSRUZFUkVOQ0UgQ09VTlRFUiBSRUZfUzEyIGFuZCBSRUZfUzExICovCiAJYy5jdGxfZGF0WzBdLmN0cmwuc2l6ZSA9IEJJVFNfODsKIAljLmN0bF9kYXRbMF0uZGF0YSAgICAgID0gMHg4MCB8IGJjOwogCkBAIC0zOTcsNyArMzk3LDcgQEAKIAljLmN0bF9kYXRbN10uY3RybC5jczAgID0gMTsKIAljLmN0bF9kYXRbN10uZGF0YSAgICAgID0gMHg0MDsKIAotLyogUFJFU0NBTEVSIERFVklERSBSQVRJTywgMm5kb3NjIFJFRkVSRU5DRSBDT1VOVEVSIFJFRl9TMTIgYW5kIFJFRl9TMTEgKi8KKy8qIFBSRVNDQUxFUiBESVZJREUgUkFUSU8sIDJuZG9zYyBSRUZFUkVOQ0UgQ09VTlRFUiBSRUZfUzEyIGFuZCBSRUZfUzExICovCiAJYy5jdGxfZGF0WzhdLmN0cmwuc2l6ZSA9IEJJVFNfODsKIAljLmN0bF9kYXRbOF0uZGF0YSAgICAgID0gMHg4MDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2N4MjI3MDAuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDIyNzAwLmMKaW5kZXggNWZiYzBmYy4uMDE0MjIxNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2N4MjI3MDAuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyMjcwMC5jCkBAIC0xNzksNyArMTc5LDcgQEAKIAljeDIyNzAwX3dyaXRlcmVnIChzdGF0ZSwgMHgwNiwgdmFsKTsKIAogCWN4MjI3MDBfd3JpdGVyZWcgKHN0YXRlLCAweDA4LCAweDA0IHwgMHgwMik7ICAvKiB1c2UgdXNlciB0cHMgcGFyYW1ldGVycyAqLwotCWN4MjI3MDBfd3JpdGVyZWcgKHN0YXRlLCAweDA4LCAweDA0KTsgICAgICAgICAvKiByZXN0YXJ0IGFxdWlzaXRpb24gKi8KKwljeDIyNzAwX3dyaXRlcmVnIChzdGF0ZSwgMHgwOCwgMHgwNCk7ICAgICAgICAgLyogcmVzdGFydCBhY3F1aXNpdGlvbiAqLwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyMjcwMi5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2N4MjI3MDIuYwppbmRleCBmZjZjNDk4Li4zMTM5NTU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyMjcwMi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDIyNzAyLmMKQEAgLTU1LDcgKzU1LDcgQEAKIAogLyogUmVnaXN0ZXIgdmFsdWVzIHRvIGluaXRpYWxpc2UgdGhlIGRlbW9kICovCiBzdGF0aWMgY29uc3QgdTggaW5pdF90YWJbXSA9IHsKLQkweDAwLCAweDAwLCAvKiBTdG9wIGFxdWlzaXRpb24gKi8KKwkweDAwLCAweDAwLCAvKiBTdG9wIGFjcXVpc2l0aW9uICovCiAJMHgwQiwgMHgwNiwKIAkweDA5LCAweDAxLAogCTB4MEQsIDB4NDEsCkBAIC0zMTAsNyArMzEwLDcgQEAKIAkJCSYgMHhmYyk7CiAJCWN4MjI3MDJfd3JpdGVyZWcoc3RhdGUsIDB4MEMsCiAJCQkoY3gyMjcwMl9yZWFkcmVnKHN0YXRlLCAweDBDKSAmIDB4QkYpIHwgMHg0MCk7Ci0JCWN4MjI3MDJfd3JpdGVyZWcoc3RhdGUsIDB4MDAsIDB4MDEpOyAvKiBCZWdpbiBhcXVpc2l0aW9uICovCisJCWN4MjI3MDJfd3JpdGVyZWcoc3RhdGUsIDB4MDAsIDB4MDEpOyAvKiBCZWdpbiBhY3F1aXNpdGlvbiAqLwogCQlkcHJpbnRrKCIlczogQXV0b2RldGVjdGluZ1xuIiwgX19mdW5jX18pOwogCQlyZXR1cm4gMDsKIAl9CkBAIC00MjQsNyArNDI0LDcgQEAKIAljeDIyNzAyX3dyaXRlcmVnKHN0YXRlLCAweDBDLAogCQkoY3gyMjcwMl9yZWFkcmVnKHN0YXRlLCAweDBDKSAmIDB4QkYpIHwgMHg0MCk7CiAKLQkvKiBCZWdpbiBjaGFubmVsIGFxdWlzaXRpb24gKi8KKwkvKiBCZWdpbiBjaGFubmVsIGFjcXVpc2l0aW9uICovCiAJY3gyMjcwMl93cml0ZXJlZyhzdGF0ZSwgMHgwMCwgMHgwMSk7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDI0MTEwLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyNDExMC5jCmluZGV4IDdhMWE1YmMuLmJmOWM5OTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDI0MTEwLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2N4MjQxMTAuYwpAQCAtNTQ0LDcgKzU0NCw3IEBACiAJY3gyNDExMF9zZXRfaW52ZXJzaW9uIChzdGF0ZSwgcC0+aW52ZXJzaW9uKTsKIAljeDI0MTEwX3NldF9mZWMgKHN0YXRlLCBwLT51LnFwc2suZmVjX2lubmVyKTsKIAljeDI0MTEwX3NldF9zeW1ib2xyYXRlIChzdGF0ZSwgcC0+dS5xcHNrLnN5bWJvbF9yYXRlKTsKLQljeDI0MTEwX3dyaXRlcmVnKHN0YXRlLDB4MDQsMHgwNSk7IC8qIHN0YXJ0IGFxdWlzaXRpb24gKi8KKwljeDI0MTEwX3dyaXRlcmVnKHN0YXRlLDB4MDQsMHgwNSk7IC8qIHN0YXJ0IGFjcXVpc2l0aW9uICovCiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDI0MTEzLmggYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyNDExMy5oCmluZGV4IDVkZTBmN2YuLjAxZWI3YjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDI0MTEzLmgKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2N4MjQxMTMuaApAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiAgRHJpdmVyIGZvciBDb25leGFudCBDWDI0MTEzL0NYMjQxMjggVHVuZXIgKFNhdGVsaXRlKQorICogIERyaXZlciBmb3IgQ29uZXhhbnQgQ1gyNDExMy9DWDI0MTI4IFR1bmVyIChTYXRlbGxpdGUpCiAgKgogICogIENvcHlyaWdodCAoQykgMjAwNy04IFBhdHJpY2sgQm9ldHRjaGVyIDxwYkBsaW51eHR2Lm9yZz4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyNDEyMy5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2N4MjQxMjMuYwppbmRleCBmYWQ2YTk5Li5iMWRkOGFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvY3gyNDEyMy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9jeDI0MTIzLmMKQEAgLTk0OSw3ICs5NDksNyBAQAogCWVsc2UKIAkJZXJyKCJpdCBzZWVtcyBJIGRvbid0IGhhdmUgYSB0dW5lci4uLiIpOwogCi0JLyogRW5hYmxlIGF1dG9tYXRpYyBhcXVpc2l0aW9uIGFuZCByZXNldCBjeWNsZSAqLworCS8qIEVuYWJsZSBhdXRvbWF0aWMgYWNxdWlzaXRpb24gYW5kIHJlc2V0IGN5Y2xlICovCiAJY3gyNDEyM193cml0ZXJlZyhzdGF0ZSwgMHgwMywgKGN4MjQxMjNfcmVhZHJlZyhzdGF0ZSwgMHgwMykgfCAweDA3KSk7CiAJY3gyNDEyM193cml0ZXJlZyhzdGF0ZSwgMHgwMCwgMHgxMCk7CiAJY3gyNDEyM193cml0ZXJlZyhzdGF0ZSwgMHgwMCwgMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvZHJ4Mzk3eEQuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9kcngzOTd4RC5jCmluZGV4IGEwNTAwN2MuLjUzNmYwMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9kcngzOTd4RC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9kcngzOTd4RC5jCkBAIC0xMDk3LDcgKzEwOTcsNyBAQAogCXMtPmNvbmZpZy5pZmFnYy53MEEgPSAweDNmZjsKIAlzLT5jb25maWcuaWZhZ2MudzBDID0gMHgzODg7CiAKLQkvKiBmb3Igc2lnbmFsIHN0cmVuZ2h0IGNhbGN1bGF0aW9ucyAqLworCS8qIGZvciBzaWduYWwgc3RyZW5ndGggY2FsY3VsYXRpb25zICovCiAJcy0+Y29uZmlnLnNzNzYgPSA4MjA7CiAJcy0+Y29uZmlnLnNzNzggPSAyMjAwOwogCXMtPmNvbmZpZy5zczdBID0gMTUwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL21iODZhMTYuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9tYjg2YTE2LmMKaW5kZXggMzNiNjMyMy4uYzI4MzExMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL21iODZhMTYuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvbWI4NmExNi5jCkBAIC0xNjMwLDcgKzE2MzAsNyBAQAogCXN0YXRlLT5zcmF0ZSA9IHAtPnUucXBzay5zeW1ib2xfcmF0ZSAvIDEwMDA7CiAKIAlpZiAoIW1iODZhMTZfc2V0X2ZlKHN0YXRlKSkgewotCQlkcHJpbnRrKHZlcmJvc2UsIE1CODZBMTZfRVJST1IsIDEsICJTdWNjZXNmdWxseSBhY3F1aXJlZCBMT0NLIik7CisJCWRwcmludGsodmVyYm9zZSwgTUI4NkExNl9FUlJPUiwgMSwgIlN1Y2Nlc3NmdWxseSBhY3F1aXJlZCBMT0NLIik7CiAJCXJldHVybiBEVkJGRV9BTEdPX1NFQVJDSF9TVUNDRVNTOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL21iODZhMjBzLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvbWI4NmEyMHMuYwppbmRleCBjYzRhY2QyLi4wZjg2N2E1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvbWI4NmEyMHMuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvbWI4NmEyMHMuYwpAQCAtNDA2LDcgKzQwNiw3IEBACiAJCXByaW50ayhLRVJOX0lORk8gIm1iODZhMjBzOiBJbml0IGZhaWxlZC4gV2lsbCB0cnkgYWdhaW4gbGF0ZXJcbiIpOwogCX0gZWxzZSB7CiAJCXN0YXRlLT5uZWVkX2luaXQgPSBmYWxzZTsKLQkJZHByaW50aygiSW5pdGlhbGl6YXRpb24gc3VjY2VkZWQuXG4iKTsKKwkJZHByaW50aygiSW5pdGlhbGl6YXRpb24gc3VjY2VlZGVkLlxuIik7CiAJfQogCXJldHVybiByYzsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9tdDMxMi5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL210MzEyLmMKaW5kZXggNDcyOTA3ZC4uODNlNmYxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL210MzEyLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL210MzEyLmMKQEAgLTY3MCw3ICs2NzAsNyBAQAogCQlpZiAocmV0IDwgMCkKIAkJCWdvdG8gZXJyb3I7CiAKLQkJLyogcHJlc2VydmUgdGhpcyBiaXQgdG8gbm90IGFjY2lkZW50bHkgc2h1dGRvd24gQURDICovCisJCS8qIHByZXNlcnZlIHRoaXMgYml0IHRvIG5vdCBhY2NpZGVudGFsbHkgc2h1dGRvd24gQURDICovCiAJCXZhbCAmPSAweDgwOwogCQlicmVhazsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvczVoMTQyMC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3M1aDE0MjAuYwppbmRleCBlODdiNzQ3Li4xN2Y4Y2RmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvczVoMTQyMC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zNWgxNDIwLmMKQEAgLTIyNSw3ICsyMjUsNyBAQAogCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKIAlpbnQgcmVzdWx0ID0gMDsKIAotCS8qIHNldHVwIGZvciBESVNFUUMgcmVjaWV2ZSAqLworCS8qIHNldHVwIGZvciBESVNFUUMgcmVjZWl2ZSAqLwogCXZhbCA9IHM1aDE0MjBfcmVhZHJlZyhzdGF0ZSwgMHgzYik7CiAJczVoMTQyMF93cml0ZXJlZyhzdGF0ZSwgMHgzYiwgMHg4Mik7IC8qIEZJWE1FOiBndWVzcyAtIGRvIHdlIG5lZWQgdG8gc2V0IERJU19SRFkoMHgwOCkgaW4gcmVjZWl2ZSBtb2RlPyAqLwogCW1zbGVlcCgxNSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3RiNjEwMC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3N0YjYxMDAuYwppbmRleCA2NDY3M2I4Li5iYzFhOGFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3RiNjEwMC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zdGI2MTAwLmMKQEAgLTM2MCw3ICszNjAsNyBAQAogCWVsc2UKIAkJb2RpdiA9IDA7CiAKLQkvKiBWQ08gZW5hYmxlZCwgc2VhY2ggY2xvY2sgb2ZmIGFzIHBlciBMTDMuNywgMy40LjEgKi8KKwkvKiBWQ08gZW5hYmxlZCwgc2VhcmNoIGNsb2NrIG9mZiBhcyBwZXIgTEwzLjcsIDMuNC4xICovCiAJcmVnc1tTVEI2MTAwX1ZDT10gPSAweGUwIHwgKG9kaXYgPDwgU1RCNjEwMF9WQ09fT0RJVl9TSElGVCk7CiAKIAkvKiBPU00JKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zdHYwMjk3LmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3R2MDI5Ny5jCmluZGV4IDRmZDc0NzkuLjg0ZDg4ZjMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3R2MDI5Ny5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zdHYwMjk3LmMKQEAgLTQzNSw3ICs0MzUsNyBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQkvLyBkZXRlcm1pbmUgaW52ZXJzaW9uIGRlcGVuZGFudCBwYXJhbWV0ZXJzCisJLy8gZGV0ZXJtaW5lIGludmVyc2lvbiBkZXBlbmRlbnQgcGFyYW1ldGVycwogCWludmVyc2lvbiA9IHAtPmludmVyc2lvbjsKIAlpZiAoc3RhdGUtPmNvbmZpZy0+aW52ZXJ0KQogCQlpbnZlcnNpb24gPSAoaW52ZXJzaW9uID09IElOVkVSU0lPTl9PTikgPyBJTlZFUlNJT05fT0ZGIDogSU5WRVJTSU9OX09OOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3N0djAzNjcuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zdHYwMzY3LmMKaW5kZXggNGUwZTZhOC4uZTU3YWI1MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3N0djAzNjcuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3R2MDM2Ny5jCkBAIC0xMzI4LDcgKzEzMjgsNyBAQAogCiAJLypndWFyZD1zdHYwMzY3X3JlYWRiaXRzKHN0YXRlLEYzNjdURVJfU1lSX0dVQVJEKTsgKi8KIAotCS8qc3VwcmVzcyBFUFEgYXV0byBmb3IgU1lSX0dBUkQgMS8xNiBvciAxLzMyCisJLypzdXBwcmVzcyBFUFEgYXV0byBmb3IgU1lSX0dBUkQgMS8xNiBvciAxLzMyCiAJYW5kIHNldCBjaGFubmVsIHByZWRpY3RvciBpbiBhdXRvbWF0aWMgKi8KICNpZiAwCiAJc3dpdGNoIChndWFyZCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3N0djA5MDBfcHJpdi5oIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3N0djA5MDBfcHJpdi5oCmluZGV4IGI2MmIwZjAuLmUwZWE3NGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zdHYwOTAwX3ByaXYuaAorKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3R2MDkwMF9wcml2LmgKQEAgLTIzOCw3ICsyMzgsNyBAQAogfTsKIAogc3RydWN0IHN0djA5MDBfaW5pdF9wYXJhbXN7Ci0JdTMyCWRtZF9yZWZfY2xrOy8qIFJlZnJlbmNlLElucHV0IGNsb2NrIGZvciB0aGUgZGVtb2QgaW4gSHogKi8KKwl1MzIJZG1kX3JlZl9jbGs7LyogUmVmZXJlbmNlLElucHV0IGNsb2NrIGZvciB0aGUgZGVtb2QgaW4gSHogKi8KIAogCS8qIERlbW9kdWxhdG9yIFR5cGUgKHNpbmdsZSBkZW1vZCBvciBkdWFsIGRlbW9kKSAqLwogCWVudW0gZmVfc3R2MDkwMF9kZW1vZF9tb2RlCWRlbW9kX21vZGU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3R2MDkweC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL3N0djA5MHguYwppbmRleCA0MWQwZjBhLi41MmQ4NzEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvc3R2MDkweC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9zdHYwOTB4LmMKQEAgLTE0MjQsNyArMTQyNCw3IEBACiAJCQlpZiAoU1RWMDkweF9XUklURV9ERU1PRChzdGF0ZSwgQ0ZSTE9XMCwgMHgwMCkgPCAwKQogCQkJCWdvdG8gZXJyOwogCi0JCQkvKmVubGFyZ2UgdGhlIHRpbWluZyBiYW5kd2l0aCBmb3IgTG93IFNSKi8KKwkJCS8qZW5sYXJnZSB0aGUgdGltaW5nIGJhbmR3aWR0aCBmb3IgTG93IFNSKi8KIAkJCWlmIChTVFYwOTB4X1dSSVRFX0RFTU9EKHN0YXRlLCBSVENTMiwgMHg2OCkgPCAwKQogCQkJCWdvdG8gZXJyOwogCQl9IGVsc2UgewpAQCAtMTQzMiwxNyArMTQzMiwxNyBAQAogCQkJU2V0IFRoZSBjYXJyaWVyIHNlYXJjaCB1cCBhbmQgbG93IHRvIGF1dG8gbW9kZSAqLwogCQkJaWYgKFNUVjA5MHhfV1JJVEVfREVNT0Qoc3RhdGUsIENBUkNGRywgMHhjNCkgPCAwKQogCQkJCWdvdG8gZXJyOwotCQkJLypyZWR1Y2UgdGhlIHRpbWluZyBiYW5kd2l0aCBmb3IgaGlnaCBTUiovCisJCQkvKnJlZHVjZSB0aGUgdGltaW5nIGJhbmR3aWR0aCBmb3IgaGlnaCBTUiovCiAJCQlpZiAoU1RWMDkweF9XUklURV9ERU1PRChzdGF0ZSwgUlRDUzIsIDB4NDQpIDwgMCkKIAkJCQlnb3RvIGVycjsKIAkJfQogCX0gZWxzZSB7CiAJCS8qID49IEN1dCAzICovCiAJCWlmIChzdGF0ZS0+c3JhdGUgPD0gNTAwMDAwMCkgewotCQkJLyogZW5sYXJnZSB0aGUgdGltaW5nIGJhbmR3aXRoIGZvciBMb3cgU1IgKi8KKwkJCS8qIGVubGFyZ2UgdGhlIHRpbWluZyBiYW5kd2lkdGggZm9yIExvdyBTUiAqLwogCQkJU1RWMDkweF9XUklURV9ERU1PRChzdGF0ZSwgUlRDUzIsIDB4NjgpOwogCQl9IGVsc2UgewotCQkJLyogcmVkdWNlIHRpbWluZyBiYW5kd2l0aCBmb3IgaGlnaCBTUiAqLworCQkJLyogcmVkdWNlIHRpbWluZyBiYW5kd2lkdGggZm9yIGhpZ2ggU1IgKi8KIAkJCVNUVjA5MHhfV1JJVEVfREVNT0Qoc3RhdGUsIFJUQ1MyLCAweDQ0KTsKIAkJfQogCkBAIC0yNDgyLDcgKzI0ODIsNyBAQAogCQkJCQlkdmJzMl9mbHlfd2hlZWwgPSBTVFYwOTB4X0dFVEZJRUxEX1B4KHJlZywgRkxZV0hFRUxfQ1BUX0ZJRUxEKTsKIAkJCQl9CiAJCQkJaWYgKGR2YnMyX2ZseV93aGVlbCA8IDB4ZCkgewotCQkJCQkvKkZBTFNFIGxvY2ssIFRoZSBkZW1vZCBpcyBsb29zaW5nIGxvY2sgKi8KKwkJCQkJLypGQUxTRSBsb2NrLCBUaGUgZGVtb2QgaXMgbG9zaW5nIGxvY2sgKi8KIAkJCQkJbG9jayA9IDA7CiAJCQkJCWlmICh0cmlhbHMgPCAyKSB7CiAJCQkJCQlpZiAoc3RhdGUtPmludGVybmFsLT5kZXZfdmVyID49IDB4MjApIHsKQEAgLTMyMDIsNyArMzIwMiw3IEBACiAJCQlnb3RvIGVycjsKIAkJaWYgKFNUVjA5MHhfV1JJVEVfREVNT0Qoc3RhdGUsIENPUlJFTE1BTlQsIDB4NzApIDwgMCkKIAkJCWdvdG8gZXJyOwotCQlpZiAoc3R2MDkweF9zZXRfc3JhdGUoc3RhdGUsIDEwMDAwMDApIDwgMCkgLyogaW5pdGFsIHNyYXRlID0gMU1zcHMgKi8KKwkJaWYgKHN0djA5MHhfc2V0X3NyYXRlKHN0YXRlLCAxMDAwMDAwKSA8IDApIC8qIGluaXRpYWwgc3JhdGUgPSAxTXNwcyAqLwogCQkJZ290byBlcnI7CiAJfSBlbHNlIHsKIAkJLyoga25vd24gc3JhdGUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL21hbnRpcy9tYW50aXNfdWFydC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvbWFudGlzL21hbnRpc191YXJ0LmMKaW5kZXggOTdiODg5ZS4uZjgwN2M4YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvbWFudGlzL21hbnRpc191YXJ0LmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvbWFudGlzL21hbnRpc191YXJ0LmMKQEAgLTE3Miw3ICsxNzIsNyBAQAogCW1td3JpdGUobW1yZWFkKE1BTlRJU19VQVJUX0NUTCkgfCBNQU5USVNfVUFSVF9SWElOVCwgTUFOVElTX1VBUlRfQ1RMKTsKIAogCXNjaGVkdWxlX3dvcmsoJm1hbnRpcy0+dWFydF93b3JrKTsKLQlkcHJpbnRrKE1BTlRJU19ERUJVRywgMSwgIlVBUlQgc3VjY2VzZnVsbHkgaW5pdGlhbGl6ZWQiKTsKKwlkcHJpbnRrKE1BTlRJU19ERUJVRywgMSwgIlVBUlQgc3VjY2Vzc2Z1bGx5IGluaXRpYWxpemVkIik7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL25nZW5lL25nZW5lLWNvcmUuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL25nZW5lL25nZW5lLWNvcmUuYwppbmRleCAxNzVhMGY2Li5jY2MyZDFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9uZ2VuZS9uZ2VuZS1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvbmdlbmUvbmdlbmUtY29yZS5jCkBAIC0xMjIsNyArMTIyLDcgQEAKIAkJCQkJCUN1ci0+bmdlbmVCdWZmZXIuU1IuRmxhZ3MgJj0KIAkJCQkJCQl+MHg0MDsKIAkJCQkJCWJyZWFrOwotCQkJCQkJLyogU3RvcCBwcm9jY2Vzc2luZyBzdHJlYW0gKi8KKwkJCQkJCS8qIFN0b3AgcHJvY2Vzc2luZyBzdHJlYW0gKi8KIAkJCQkJfQogCQkJCX0gZWxzZSB7CiAJCQkJCS8qIFdlIGdvdCBhIHZhbGlkIGJ1ZmZlciwKQEAgLTEzMyw3ICsxMzMsNyBAQAogCQkJCXByaW50ayhLRVJOX0VSUiBERVZJQ0VfTkFNRSAiOiBPT1BTXG4iKTsKIAkJCQlpZiAoY2hhbi0+SFdTdGF0ZSA9PSBIV1NUQVRFX1JVTikgewogCQkJCQlDdXItPm5nZW5lQnVmZmVyLlNSLkZsYWdzICY9IH4weDQwOwotCQkJCQlicmVhazsJLyogU3RvcCBwcm9jY2Vzc2luZyBzdHJlYW0gKi8KKwkJCQkJYnJlYWs7CS8qIFN0b3AgcHJvY2Vzc2luZyBzdHJlYW0gKi8KIAkJCQl9CiAJCQl9CiAJCQlpZiAoY2hhbi0+QXVkaW9EVE9VcGRhdGVkKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9wbHV0bzIvcGx1dG8yLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9wbHV0bzIvcGx1dG8yLmMKaW5kZXggNmNhNjcxMy4uN2NiNzllYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvcGx1dG8yL3BsdXRvMi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL3BsdXRvMi9wbHV0bzIuYwpAQCAtMjk0LDEzICsyOTQsMTMgQEAKIAogCS8qIFdvcmthcm91bmQgZm9yIGJyb2tlbiBoYXJkd2FyZToKIAkgKiBbMV0gT24gc3RhcnR1cCBOQlBBQ0tFVFMgc2VlbXMgdG8gY29udGFpbiBhbiB1bmluaXRpYWxpemVkIHZhbHVlLAotCSAqICAgICBidXQgbm8gcGFja2V0cyBoYXZlIGJlZW4gdHJhbnNmZXJlZC4KKwkgKiAgICAgYnV0IG5vIHBhY2tldHMgaGF2ZSBiZWVuIHRyYW5zZmVycmVkLgogCSAqIFsyXSBTb21ldGltZXMgKGFjdHVhbGx5IHZlcnkgb2Z0ZW4pIE5CUEFDS0VUUyBzdGF5cyBhdCB6ZXJvCi0JICogICAgIGFsdGhvdWdoIG9uZSBwYWNrZXQgaGFzIGJlZW4gdHJhbnNmZXJlZC4KKwkgKiAgICAgYWx0aG91Z2ggb25lIHBhY2tldCBoYXMgYmVlbiB0cmFuc2ZlcnJlZC4KIAkgKiBbM10gU29tZXRpbWVzIChhY3R1YWxseSByYXJlbHkpLCB0aGUgY2FyZCBnZXRzIGludG8gYW4gZXJyb25lb3VzCiAJICogICAgIG1vZGUgd2hlcmUgaXQgY29udGludW91c2x5IGdlbmVyYXRlcyBpbnRlcnJ1cHRzLCBjbGFpbWluZyBpdAotCSAqICAgICBoYXMgcmVjaWV2ZWQgbmJwYWNrZXRzPlRTX0RNQV9QQUNLRVRTIHBhY2tldHMsIGJ1dCBubyBwYWNrZXQKLQkgKiAgICAgaGFzIGJlZW4gdHJhbnNmZXJlZC4gT25seSBhIHJlc2V0IHNlZW1zIHRvIHNvbHZlIHRoaXMKKwkgKiAgICAgaGFzIHJlY2VpdmVkIG5icGFja2V0cz5UU19ETUFfUEFDS0VUUyBwYWNrZXRzLCBidXQgbm8gcGFja2V0CisJICogICAgIGhhcyBiZWVuIHRyYW5zZmVycmVkLiBPbmx5IGEgcmVzZXQgc2VlbXMgdG8gc29sdmUgdGhpcwogCSAqLwogCWlmICgobmJwYWNrZXRzID09IDApIHx8IChuYnBhY2tldHMgPiBUU19ETUFfUEFDS0VUUykpIHsKIAkJdW5zaWduZWQgaW50IGkgPSAwOwpAQCAtMzMyLDcgKzMzMiw3IEBACiAJc3RydWN0IHBsdXRvICpwbHV0byA9IGRldl9pZDsKIAl1MzIgdHNjcjsKIAotCS8qIGNoZWNrIHdoZXRoZXIgYW4gaW50ZXJydXB0IG9jY3VyZWQgb24gdGhpcyBkZXZpY2UgKi8KKwkvKiBjaGVjayB3aGV0aGVyIGFuIGludGVycnVwdCBvY2N1cnJlZCBvbiB0aGlzIGRldmljZSAqLwogCXRzY3IgPSBwbHV0b19yZWFkcmVnKHBsdXRvLCBSRUdfVFNDUik7CiAJaWYgKCEodHNjciAmIChUU0NSX0RFIHwgVFNDUl9PVlIpKSkKIAkJcmV0dXJuIElSUV9OT05FOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvc2lhbm8vc21zZHZiLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9zaWFuby9zbXNkdmIuYwppbmRleCBiODBkMDliLi4zN2M1OTRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9zaWFuby9zbXNkdmIuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9zaWFuby9zbXNkdmIuYwpAQCAtNjUwLDcgKzY1MCw3IEBACiAJCWlmIChzdGF0dXMgJiBGRV9IQVNfTE9DSykKIAkJCXJldHVybiByZXQ7CiAKLQkJLyogcHJldmlvdXMgdHVuZSBkaWRudCBsb2NrIC0gZW5hYmxlIExOQSBhbmQgdHVuZSBhZ2FpbiAqLworCQkvKiBwcmV2aW91cyB0dW5lIGRpZG4ndCBsb2NrIC0gZW5hYmxlIExOQSBhbmQgdHVuZSBhZ2FpbiAqLwogCQlzbXNfYm9hcmRfbG5hX2NvbnRyb2woY2xpZW50LT5jb3JlZGV2LCAxKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL3R0cGNpL2F2NzExMC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvdHRwY2kvYXY3MTEwLmMKaW5kZXggZmMwYTYwZi4uM2QyMDcxOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvdHRwY2kvYXY3MTEwLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvdHRwY2kvYXY3MTEwLmMKQEAgLTIzMzIsNyArMjMzMiw3IEBACiAgKiBpbmNyZW1lbnQuIFRoYXQncyBob3cgdGhlIDcxNDYgaXMgcHJvZ3JhbW1lZCB0byBkbyBldmVudAogICogY291bnRpbmcgaW4gdGhpcyBidWRnZXQtcGF0Y2guYwogICogSSAqdGhpbmsqIEhQUyBzZXR0aW5nIGhhcyBzb21ldGhpbmcgdG8gZG8gd2l0aCB0aGUgcGhhc2UKLSAqIG9mIEhTIGJ1dCBJIGNhbnQgYmUgMTAwJSBzdXJlIGluIHRoYXQuCisgKiBvZiBIUyBidXQgSSBjYW4ndCBiZSAxMDAlIHN1cmUgaW4gdGhhdC4KICAqCiAgKiBoYXJkd2FyZSBkZWJ1ZyBub3RlOiBhIHdvcmtpbmcgYnVkZ2V0IGNhcmQgKGluY2x1ZGluZyBidWRnZXQgcGF0Y2gpCiAgKiB3aXRoIHZwZWlycSgpIGludGVycnVwdCBzZXR1cCBpbiBtb2RlICIweDkwIiAoZXZlcnkgNjRLKSB3aWxsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi90dHBjaS9idWRnZXQtcGF0Y2guYyBiL2RyaXZlcnMvbWVkaWEvZHZiL3R0cGNpL2J1ZGdldC1wYXRjaC5jCmluZGV4IDU3OTgzNTUuLjMzOTVkMWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL3R0cGNpL2J1ZGdldC1wYXRjaC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL3R0cGNpL2J1ZGdldC1wYXRjaC5jCkBAIC01MzksNyArNTM5LDcgQEAKICoqICAgICAgaW5jcmVtZW50LiBUaGF0J3MgaG93IHRoZSA3MTQ2IGlzIHByb2dyYW1tZWQgdG8gZG8gZXZlbnQKICoqICAgICAgY291bnRpbmcgaW4gdGhpcyBidWRnZXQtcGF0Y2guYwogKiogICAgICBJICp0aGluayogSFBTIHNldHRpbmcgaGFzIHNvbWV0aGluZyB0byBkbyB3aXRoIHRoZSBwaGFzZQotKiogICAgICBvZiBIUyBidXQgSSBjYW50IGJlIDEwMCUgc3VyZSBpbiB0aGF0LgorKiogICAgICBvZiBIUyBidXQgSSBjYW4ndCBiZSAxMDAlIHN1cmUgaW4gdGhhdC4KIAogKiogICAgICBoYXJkd2FyZSBkZWJ1ZyBub3RlOiBhIHdvcmtpbmcgYnVkZ2V0IGNhcmQgKGluY2x1ZGluZyBidWRnZXQgcGF0Y2gpCiAqKiAgICAgIHdpdGggdnBlaXJxKCkgaW50ZXJydXB0IHNldHVwIGluIG1vZGUgIjB4OTAiIChldmVyeSA2NEspIHdpbGwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL3R0dXNiLWRlYy90dHVzYl9kZWMuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL3R0dXNiLWRlYy90dHVzYl9kZWMuYwppbmRleCBmZTFiODAzLi5mODkzYmZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi90dHVzYi1kZWMvdHR1c2JfZGVjLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvdHR1c2ItZGVjL3R0dXNiX2RlYy5jCkBAIC0yMzQsNyArMjM0LDcgQEAKIAkJICogKHdpdGggYnVmZmVyWzNdID09IDB4NDApIGluIGFuIGludGVydmFsbCBvZiB+MTAwbXMuCiAJCSAqIEJ1dCB0byBoYW5kbGUgdGhpcyBjb3JyZWN0bHkgd2UgaGFkIHRvIGltbGVtZW5lbnQgc29tZQogCQkgKiBraW5kIG9mIHRpbWVyIHdoaWNoIHNpZ25hbHMgYSAna2V5IHVwJyBldmVudCBpZiBubwotCQkgKiBrZXlyZXBlYXQgc2lnbmFsIGlzIHJlY2lldmVkIGZvciBsZXRzIHNheSAyMDBtcy4KKwkJICoga2V5cmVwZWF0IHNpZ25hbCBpcyByZWNlaXZlZCBmb3IgbGV0cyBzYXkgMjAwbXMuCiAJCSAqIHRoaXMgc2hvdWxkL2NvdWxkIGJlIGFkZGVkIGxhdGVyIC4uLgogCQkgKiBmb3Igbm93IGxldHMgcmVwb3J0IGVhY2ggc2lnbmFsIGFzIGEga2V5IGRvd24gYW5kIHVwKi8KIAkJZHByaW50aygiJXM6cmMgc2lnbmFsOiVkXG4iLCBfX2Z1bmNfXywgYnVmZmVyWzRdKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tbXI4MDAuYyBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tbXI4MDAuYwppbmRleCBlNmIyZDA4Li5iM2E2MzViIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JhZGlvL3JhZGlvLW1yODAwLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYWRpby9yYWRpby1tcjgwMC5jCkBAIC05OSw3ICs5OSw3IEBACiAKIC8qCiAgKiBDb21tYW5kcyB0aGF0IGRldmljZSBzaG91bGQgdW5kZXJzdGFuZAotICogTGlzdCBpc250IGZ1bGwgYW5kIHdpbGwgYmUgdXBkYXRlZCB3aXRoIGltcGxlbWVudGF0aW9uIG9mIG5ldyBmdW5jdGlvbnMKKyAqIExpc3QgaXNuJ3QgZnVsbCBhbmQgd2lsbCBiZSB1cGRhdGVkIHdpdGggaW1wbGVtZW50YXRpb24gb2YgbmV3IGZ1bmN0aW9ucwogICovCiAjZGVmaW5lIEFNUkFESU9fU0VUX0ZSRVEJMHhhNAogI2RlZmluZSBBTVJBRElPX1NFVF9NVVRFCTB4YWIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vc2k0NzEzLWkyYy5jIGIvZHJpdmVycy9tZWRpYS9yYWRpby9zaTQ3MTMtaTJjLmMKaW5kZXggMGZhYjZmOC4uZGVjYTJlMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYWRpby9zaTQ3MTMtaTJjLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYWRpby9zaTQ3MTMtaTJjLmMKQEAgLTQ4MSw3ICs0ODEsNyBAQAogfQogCiAvKgotICogc2k0NzEzX3dhaXRfc3RjIC0gV2FpdHMgU1RDIGludGVycnVwdCBhbmQgY2xlYXJzIHN0YXR1cyBiaXRzLiBVc2VmdWxsCisgKiBzaTQ3MTNfd2FpdF9zdGMgLSBXYWl0cyBTVEMgaW50ZXJydXB0IGFuZCBjbGVhcnMgc3RhdHVzIGJpdHMuIFVzZWZ1bAogICoJCSAgICAgZm9yIFRYX1RVTkVfUE9XRVIsIFRYX1RVTkVfRlJFUSBhbmQgVFhfVFVORV9NRUFTCiAgKiBAc2Rldjogc2k0NzEzX2RldmljZSBzdHJ1Y3R1cmUgZm9yIHRoZSBkZXZpY2Ugd2UgYXJlIGNvbW11bmljYXRpbmcKICAqIEB1c2VjczogdGltZW91dCB0byB3YWl0IGZvciBTVEMgaW50ZXJydXB0IHNpZ25hbApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYWRpby93bDEyOHgvZm1kcnZfY29tbW9uLmMgYi9kcml2ZXJzL21lZGlhL3JhZGlvL3dsMTI4eC9mbWRydl9jb21tb24uYwppbmRleCBlY2ZkOWZiLi41OTkxYWI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JhZGlvL3dsMTI4eC9mbWRydl9jb21tb24uYworKysgYi9kcml2ZXJzL21lZGlhL3JhZGlvL3dsMTI4eC9mbWRydl9jb21tb24uYwpAQCAtMzUyLDcgKzM1Miw3IEBACiAJaWYgKCFhdG9taWNfcmVhZCgmZm1kZXYtPnR4X2NudCkpCiAJCXJldHVybjsKIAotCS8qIENoZWNrLCBpcyB0aGVyZSBhbnkgdGltZW91dCBoYXBwZW5uZWQgdG8gbGFzdCB0cmFuc21pdHRlZCBwYWNrZXQgKi8KKwkvKiBDaGVjaywgaXMgdGhlcmUgYW55IHRpbWVvdXQgaGFwcGVuZWQgdG8gbGFzdCB0cmFuc21pdHRlZCBwYWNrZXQgKi8KIAlpZiAoKGppZmZpZXMgLSBmbWRldi0+bGFzdF90eF9qaWZmaWVzKSA+IEZNX0RSVl9UWF9USU1FT1VUKSB7CiAJCWZtZXJyKCJUWCB0aW1lb3V0IG9jY3VycmVkXG4iKTsKIAkJYXRvbWljX3NldCgmZm1kZXYtPnR4X2NudCwgMSk7CkBAIC00NzgsNyArNDc4LDcgQEAKIAkJcmV0dXJuIC1FVElNRURPVVQ7CiAJfQogCWlmICghZm1kZXYtPnJlc3Bfc2tiKSB7Ci0JCWZtZXJyKCJSZXBvbnNlIFNLQiBpcyBtaXNzaW5nXG4iKTsKKwkJZm1lcnIoIlJlc3BvbnNlIFNLQiBpcyBtaXNzaW5nXG4iKTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCXNwaW5fbG9ja19pcnFzYXZlKCZmbWRldi0+cmVzcF9za2JfbG9jaywgZmxhZ3MpOwpAQCAtMTU5OCw3ICsxNTk4LDcgQEAKIAkJZm1kYmcoIkZNIENvcmUgaXMgYWxyZWFkeSBkb3duXG4iKTsKIAkJcmV0dXJuIDA7CiAJfQotCS8qIFNldmljZSBwZW5kaW5nIHJlYWQgKi8KKwkvKiBTZXJ2aWNlIHBlbmRpbmcgcmVhZCAqLwogCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmZm1kZXYtPnJ4LnJkcy5yZWFkX3F1ZXVlKTsKIAogCXRhc2tsZXRfa2lsbCgmZm1kZXYtPnR4X3Rhc2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYWRpby93bDEyOHgvZm1kcnZfY29tbW9uLmggYi9kcml2ZXJzL21lZGlhL3JhZGlvL3dsMTI4eC9mbWRydl9jb21tb24uaAppbmRleCA0MjdjNDE2Li5hZWUyNDNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JhZGlvL3dsMTI4eC9mbWRydl9jb21tb24uaAorKysgYi9kcml2ZXJzL21lZGlhL3JhZGlvL3dsMTI4eC9mbWRydl9jb21tb24uaApAQCAtMzYyLDcgKzM2Miw3IEBACiAjZGVmaW5lIEZNX1RYX1BSRUVNUEhfNTBVUwkJMAogI2RlZmluZSBGTV9UWF9QUkVFTVBIXzc1VVMJCTIKIAotLyogRk0gVFggYW50ZW5uYSBpbXBlZGVuY2UgdmFsdWVzICovCisvKiBGTSBUWCBhbnRlbm5hIGltcGVkYW5jZSB2YWx1ZXMgKi8KICNkZWZpbmUgRk1fVFhfQU5UX0lNUF81MAkJMAogI2RlZmluZSBGTV9UWF9BTlRfSU1QXzIwMAkJMQogI2RlZmluZSBGTV9UWF9BTlRfSU1QXzUwMAkJMgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYy9lbmVfaXIuYyBiL2RyaXZlcnMvbWVkaWEvcmMvZW5lX2lyLmMKaW5kZXggMWFjNDkxMy4uYTQzZWQ2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYy9lbmVfaXIuYworKysgYi9kcml2ZXJzL21lZGlhL3JjL2VuZV9pci5jCkBAIC01MjAsNyArNTIwLDcgQEAKIAlkZXYtPnJ4X2VuYWJsZWQgPSBmYWxzZTsKIH0KIAotLyogVGhpcyByZXNldHMgdGhlIHJlY2VpdmVyLiBVc2VmdWxsIHRvIHN0b3Agc3RyZWFtIG9mIHNwYWNlcyBhdCBlbmQgb2YKKy8qIFRoaXMgcmVzZXRzIHRoZSByZWNlaXZlci4gVXNlZnVsIHRvIHN0b3Agc3RyZWFtIG9mIHNwYWNlcyBhdCBlbmQgb2YKICAqIHRyYW5zbWlzc2lvbgogICovCiBzdGF0aWMgdm9pZCBlbmVfcnhfcmVzZXQoc3RydWN0IGVuZV9kZXZpY2UgKmRldikKQEAgLTEwODksNyArMTA4OSw3IEBACiAJaWYgKGVycm9yIDwgMCkKIAkJZ290byBlcnJvcjsKIAotCWVuZV9ub3RpY2UoImRyaXZlciBoYXMgYmVlbiBzdWNjZXNmdWxseSBsb2FkZWQiKTsKKwllbmVfbm90aWNlKCJkcml2ZXIgaGFzIGJlZW4gc3VjY2Vzc2Z1bGx5IGxvYWRlZCIpOwogCXJldHVybiAwOwogZXJyb3I6CiAJaWYgKGRldiAmJiBkZXYtPmlycSA+PSAwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYy9pbW9uLmMgYi9kcml2ZXJzL21lZGlhL3JjL2ltb24uYwppbmRleCBmNzE0ZTFhLi5lYmQ2OGVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL2ltb24uYworKysgYi9kcml2ZXJzL21lZGlhL3JjL2ltb24uYwpAQCAtMTI5Myw3ICsxMjkzLDcgQEAKIAkgKiBjb250YWluIGEgcG9zaXRpb24gY29vcmRpbmF0ZSAoeCx5KSwgd2l0aCBlYWNoIGNvbXBvbmVudCByYW5naW5nCiAJICogZnJvbSAtMTQgdG8gMTQuIFdlIHdhbnQgdG8gZG93bi1zYW1wbGUgdGhpcyB0byBvbmx5IDQgZGlzY3JldGUgdmFsdWVzCiAJICogZm9yIHVwL2Rvd24vbGVmdC9yaWdodCBhcnJvdyBrZXlzLiBBbHNvLCB3aGVuIHlvdSBnZXQgdG9vIGNsb3NlIHRvCi0JICogZGlhZ29uYWxzLCBpdCBoYXMgYSB0ZW5kYW5jeSB0byBqdW1wIGJhY2sgYW5kIGZvcnRoLCBzbyBsZXRzIHRyeSB0bworCSAqIGRpYWdvbmFscywgaXQgaGFzIGEgdGVuZGVuY3kgdG8ganVtcCBiYWNrIGFuZCBmb3J0aCwgc28gbGV0cyB0cnkgdG8KIAkgKiBpZ25vcmUgd2hlbiB0aGV5IGdldCB0b28gY2xvc2UuCiAJICovCiAJaWYgKGljdHgtPnByb2R1Y3QgIT0gMHhmZmRjKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2lyLXJhdy5jIGIvZHJpdmVycy9tZWRpYS9yYy9pci1yYXcuYwppbmRleCAwMWYyNThhLi4xMWMxOWQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL2lyLXJhdy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvaXItcmF3LmMKQEAgLTE1Myw3ICsxNTMsNyBAQAogICogQHR5cGU6CXRoZSB0eXBlIG9mIHRoZSBldmVudCB0aGF0IGhhcyBvY2N1cnJlZAogICoKICAqIFRoaXMgcm91dGluZSAod2hpY2ggbWF5IGJlIGNhbGxlZCBmcm9tIGFuIGludGVycnVwdCBjb250ZXh0KSB3b3JrcwotICogaW4gc2ltaWxpYXIgbWFubmVyIHRvIGlyX3Jhd19ldmVudF9zdG9yZV9lZGdlLgorICogaW4gc2ltaWxhciBtYW5uZXIgdG8gaXJfcmF3X2V2ZW50X3N0b3JlX2VkZ2UuCiAgKiBUaGlzIHJvdXRpbmUgaXMgaW50ZW5kZWQgZm9yIGRldmljZXMgd2l0aCBsaW1pdGVkIGludGVybmFsIGJ1ZmZlcgogICogSXQgYXV0b21lcmdlcyBzYW1wbGVzIG9mIHNhbWUgdHlwZSwgYW5kIGhhbmRsZXMgdGltZW91dHMKICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLWxtZTI1MTAuYyBiL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1sbWUyNTEwLmMKaW5kZXggM2MxOTEzOS4uYWZhZTE0ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLWxtZTI1MTAuYworKysgYi9kcml2ZXJzL21lZGlhL3JjL2tleW1hcHMvcmMtbG1lMjUxMC5jCkBAIC01NSw3ICs1NSw3IEBACiAJeyAweGZmNDBmYjA0LCBLRVlfTUVESUFfUkVQRUFUfSwgLyogUmVjYWxsICovCiAJeyAweGZmNDBlNTFhLCBLRVlfUEFVU0UgfSwgLyogVGltZXNoaWZ0ICovCiAJeyAweGZmNDBmZDAyLCBLRVlfVk9MVU1FVVAgfSwgLyogMiB4IC0vKyBLZXlzIG5vdCBtYXJrZWQgKi8KLQl7IDB4ZmY0MGY5MDYsIEtFWV9WT0xVTUVET1dOIH0sIC8qIFZvbHVtbmUgZGVmaW5lZCBhcyByaWdodCBoYW5kKi8KKwl7IDB4ZmY0MGY5MDYsIEtFWV9WT0xVTUVET1dOIH0sIC8qIFZvbHVtZSBkZWZpbmVkIGFzIHJpZ2h0IGhhbmQqLwogCXsgMHhmZjQwZmUwMSwgS0VZX0NIQU5ORUxVUCB9LAogCXsgMHhmZjQwZmEwNSwgS0VZX0NIQU5ORUxET1dOIH0sCiAJeyAweGZmNDBlYjE0LCBLRVlfWk9PTSB9LApAQCAtNzYsNyArNzYsNyBAQAogCXsgMHhmZjAwYmI0NCwgS0VZX01FRElBX1JFUEVBVH0sIC8qIFJlY2FsbCAqLwogCXsgMHhmZjAwYjU0YSwgS0VZX1BBVVNFIH0sIC8qIFRpbWVzaGlmdCAqLwogCXsgMHhmZjAwYjg0NywgS0VZX1ZPTFVNRVVQIH0sIC8qIDIgeCAtLysgS2V5cyBub3QgbWFya2VkICovCi0JeyAweGZmMDBiYzQzLCBLRVlfVk9MVU1FRE9XTiB9LCAvKiBWb2x1bW5lIGRlZmluZWQgYXMgcmlnaHQgaGFuZCovCisJeyAweGZmMDBiYzQzLCBLRVlfVk9MVU1FRE9XTiB9LCAvKiBWb2x1bWUgZGVmaW5lZCBhcyByaWdodCBoYW5kKi8KIAl7IDB4ZmYwMGI5NDYsIEtFWV9DSEFOTkVMVVAgfSwKIAl7IDB4ZmYwMGJmNDAsIEtFWV9DSEFOTkVMRE9XTiB9LAogCXsgMHhmZjAwZjcwOCwgS0VZX1pPT00gfSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1tc2ktdHZhbnl3aGVyZS5jIGIvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLW1zaS10dmFueXdoZXJlLmMKaW5kZXggMThiMzdmYS4uZmRkMjEzZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLW1zaS10dmFueXdoZXJlLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLW1zaS10dmFueXdoZXJlLmMKQEAgLTI5LDcgKzI5LDcgQEAKIAogCXsgMHgwYywgS0VZX01VVEUgfSwKIAl7IDB4MGYsIEtFWV9TQ1JFRU4gfSwJCS8qIEZ1bGwgU2NyZWVuICovCi0JeyAweDEwLCBLRVlfRk4gfSwJCS8qIEZ1bnRpb24gKi8KKwl7IDB4MTAsIEtFWV9GTiB9LAkJLyogRnVuY3Rpb24gKi8KIAl7IDB4MTEsIEtFWV9USU1FIH0sCQkvKiBUaW1lIHNoaWZ0ICovCiAJeyAweDEyLCBLRVlfUE9XRVIgfSwKIAl7IDB4MTMsIEtFWV9NRURJQSB9LAkJLyogTVRTICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2tleW1hcHMvcmMtbm9yd29vZC5jIGIvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLW5vcndvb2QuYwppbmRleCBmMWMxMjgxLi5mOWYyZmEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL2tleW1hcHMvcmMtbm9yd29vZC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1ub3J3b29kLmMKQEAgLTQ5LDcgKzQ5LDcgQEAKIAl7IDB4MzcsIEtFWV9QTEFZIH0sCQkvKiBQbGF5ICAgICAgICAgICAgICAgICovCiAJeyAweDM2LCBLRVlfUEFVU0UgfSwJCS8qIFBhdXNlICAgICAgICAgICAgICAgKi8KIAl7IDB4MmIsIEtFWV9TVE9QIH0sCQkvKiBTdG9wICAgICAgICAgICAgICAgICovCi0JeyAweDY3LCBLRVlfRkFTVEZPUldBUkQgfSwJLyogRm93YXJkICAgICAgICAgICAgICAqLworCXsgMHg2NywgS0VZX0ZBU1RGT1JXQVJEIH0sCS8qIEZvcndhcmQgICAgICAgICAgICAgICovCiAJeyAweDY2LCBLRVlfUkVXSU5EIH0sCQkvKiBSZXdpbmQgICAgICAgICAgICAgICovCiAJeyAweDNlLCBLRVlfU0VBUkNIIH0sCQkvKiBBdXRvIFNjYW4gICAgICAgICAgICovCiAJeyAweDJlLCBLRVlfQ0FNRVJBIH0sCQkvKiBDYXB0dXJlIFZpZGVvICAgICAgICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL3JjLW1haW4uYyBiL2RyaXZlcnMvbWVkaWEvcmMvcmMtbWFpbi5jCmluZGV4IDVhYzFiYWYuLmY1M2Y5YzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmMvcmMtbWFpbi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvcmMtbWFpbi5jCkBAIC0yNTUsNyArMjU1LDcgQEAKICAqIEByY19tYXA6CXNjYW5jb2RlIHRhYmxlIHRvIGJlIHNlYXJjaGVkCiAgKiBAc2NhbmNvZGU6CXRoZSBkZXNpcmVkIHNjYW5jb2RlCiAgKiBAcmVzaXplOgljb250cm9scyB3aGV0aGVyIHdlIGFsbG93ZWQgdG8gcmVzaXplIHRoZSB0YWJsZSB0bwotICoJCWFjY29tb2RhdGUgbm90IHlldCBwcmVzZW50IHNjYW5jb2RlcworICoJCWFjY29tbW9kYXRlIG5vdCB5ZXQgcHJlc2VudCBzY2FuY29kZXMKICAqIEByZXR1cm46CWluZGV4IG9mIHRoZSBtYXBwaW5nIGNvbnRhaW5pbmcgc2NhbmNvZGUgaW4gcXVlc3Rpb24KICAqCQlvciAtMVUgaW4gY2FzZSBvZiBmYWlsdXJlLgogICoKQEAgLTEwMzcsNyArMTAzNyw3IEBACiAJCWdvdG8gb3V0X3RhYmxlOwogCiAJLyoKLQkgKiBEZWZhdWx0IGRlbGF5IG9mIDI1MG1zIGlzIHRvbyBzaG9ydCBmb3Igc29tZSBwcm90b2NvbHMsIGV4cGVjaWFsbHkKKwkgKiBEZWZhdWx0IGRlbGF5IG9mIDI1MG1zIGlzIHRvbyBzaG9ydCBmb3Igc29tZSBwcm90b2NvbHMsIGVzcGVjaWFsbHkKIAkgKiBzaW5jZSB0aGUgdGltZW91dCBpcyBjdXJyZW50bHkgc2V0IHRvIDI1MG1zLiBJbmNyZWFzZSBpdCB0byA1MDBtcywKIAkgKiB0byBhdm9pZCB3cm9uZyByZXBldGl0aW9uIG9mIHRoZSBrZXljb2Rlcy4gTm90ZSB0aGF0IHRoaXMgbXVzdCBiZQogCSAqIHNldCBhZnRlciB0aGUgY2FsbCB0byBpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoKS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vYXUwODI4L2F1MDgyOC12aWRlby5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9hdTA4MjgvYXUwODI4LXZpZGVvLmMKaW5kZXggNmFkODNhMS4uYzAzZWIyOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9hdTA4MjgvYXUwODI4LXZpZGVvLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9hdTA4MjgvYXUwODI4LXZpZGVvLmMKQEAgLTUwMiw3ICs1MDIsNyBAQAogCiAJLyogR2V0IHRoZSBuZXh0IGJ1ZmZlciAqLwogCSpidWYgPSBsaXN0X2VudHJ5KGRtYV9xLT5hY3RpdmUubmV4dCwgc3RydWN0IGF1MDgyOF9idWZmZXIsIHZiLnF1ZXVlKTsKLQkvKiBDbGVhbnMgdXAgYnVmZmVyIC0gVXNlZnVsbCBmb3IgdGVzdGluZyBmb3IgZnJhbWUvVVJCIGxvc3MgKi8KKwkvKiBDbGVhbnMgdXAgYnVmZmVyIC0gVXNlZnVsIGZvciB0ZXN0aW5nIGZvciBmcmFtZS9VUkIgbG9zcyAqLwogCW91dHAgPSB2aWRlb2J1Zl90b192bWFsbG9jKCYoKmJ1ZiktPnZiKTsKIAltZW1zZXQob3V0cCwgMHgwMCwgKCpidWYpLT52Yi5zaXplKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9idDh4eC9idHR2LWNhcmRzLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2J0OHh4L2J0dHYtY2FyZHMuYwppbmRleCAyNDJmMGQ1Li4zYzllNmM3IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2J0OHh4L2J0dHYtY2FyZHMuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2J0OHh4L2J0dHYtY2FyZHMuYwpAQCAtMjI0NCw4ICsyMjQ0LDggQEAKIAl9LAogCVtCVFRWX0JPQVJEX1BJQ09MT19URVRSQV9DSElQXSA9IHsKIAkJLypFcmljIERFQklFRiA8ZGViaWVmQHRlbGVtc2EuY29tPiovCi0JCS8qRVVSRVNZUyBQaWNvbG8gVGV0cmEgOiA0IENvbmV4YW50IEZ1c2lvbiA4NzhBLCBubyBhdWRpbywgdmlkZW8gaW5wdXQgc2V0IHdpdGggYW5hbG9nIG11bHRpcGxleGVycyBHUElPIGNvbnRyb2xlZCovCi0JCS8qIGFkZHMgcGljb2xvX3RldHJhX211eHNlbCgpLCBwaWNvbG9fdGV0cmFfaW5pdCgpLCB0aGUgZm9sb3dpbmcgZGVjbGFyYXRpb24gc3RydWN1cmUsIGFuZCAjZGVmaW5lIEJUVFZfQk9BUkRfUElDT0xPX1RFVFJBX0NISVAqLworCQkvKkVVUkVTWVMgUGljb2xvIFRldHJhIDogNCBDb25leGFudCBGdXNpb24gODc4QSwgbm8gYXVkaW8sIHZpZGVvIGlucHV0IHNldCB3aXRoIGFuYWxvZyBtdWx0aXBsZXhlcnMgR1BJTyBjb250cm9sbGVkKi8KKwkJLyogYWRkcyBwaWNvbG9fdGV0cmFfbXV4c2VsKCksIHBpY29sb190ZXRyYV9pbml0KCksIHRoZSBmb2xsb3dpbmcgZGVjbGFyYXRpb24gc3RydWN1cmUsIGFuZCAjZGVmaW5lIEJUVFZfQk9BUkRfUElDT0xPX1RFVFJBX0NISVAqLwogCQkvKjB4NzkgaW4gYnR0di5oKi8KIAkJLm5hbWUgICAgICAgICAgID0gIkV1cmVzeXMgUGljb2xvIFRldHJhIiwKIAkJLnZpZGVvX2lucHV0cyAgID0gNCwKQEAgLTQ1NjcsNyArNDU2Nyw3IEBACiAgKiBhdCBvbmUgaW5wdXQgd2hpbGUgdGhlIG1vbml0b3IgaXMgbG9va2luZyBhdCBhbm90aGVyLgogICoKICAqIFNpbmNlIEkndmUgY291bGRuJ3QgYmUgYm90aGVyZWQgZmlndXJpbmcgb3V0IGhvdyB0byBhZGQgYW4KLSAqIGluZGVwZW5kYW50IG11eHNlbCBmb3IgdGhlIG1vbml0b3IgYnVzLCBJJ3ZlIGp1c3Qgc2V0IGl0IHRvCisgKiBpbmRlcGVuZGVudCBtdXhzZWwgZm9yIHRoZSBtb25pdG9yIGJ1cywgSSd2ZSBqdXN0IHNldCBpdCB0bwogICogd2hhdGV2ZXIgdGhlIGNhcmQgaXMgbG9va2luZyBhdC4KICAqCiAgKiAgT1VUMCBvZiB0aGUgVERBODU0MCdzIGlzIGNvbm5lY3RlZCB0byBNVVgwICAgICAgICAgKDB4MDMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2J0OHh4L2J0dHYtZ3Bpby5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9idDh4eC9idHR2LWdwaW8uYwppbmRleCBmZDYwNGQzLi4xM2NlNzJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2J0OHh4L2J0dHYtZ3Bpby5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vYnQ4eHgvYnR0di1ncGlvLmMKQEAgLTMsNyArMyw3IEBACiAgICAgYnR0di1ncGlvLmMgIC0tICBncGlvIHN1YiBkcml2ZXJzCiAKICAgICBzeXNmcy1iYXNlZCBzdWIgZHJpdmVyIGludGVyZmFjZSBmb3IgYnR0dgotICAgIG1haW5seSBpbnRlbnRlZCBmb3IgZ3BpbyBhY2Nlc3MKKyAgICBtYWlubHkgaW50ZW5kZWQgZm9yIGdwaW8gYWNjZXNzCiAKIAogICAgIENvcHlyaWdodCAoQykgMTk5Niw5Nyw5OCBSYWxwaCAgTWV0emxlciAocmprbUB0aHAudW5pLWtvZWxuLmRlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9jYWZlX2NjaWMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY2FmZV9jY2ljLmMKaW5kZXggNTVmZmQ2MC4uNjY0NzAzMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jYWZlX2NjaWMuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2NhZmVfY2NpYy5jCkBAIC0zODMsNyArMzgzLDcgQEAKIAkgKiBjYXVzZXMgdGhlIGRldmljZSB0byBkaWUuCiAJICogVXNlIGEgYnVzeS13YWl0IGJlY2F1c2Ugd2Ugb2Z0ZW4gc2VuZCBhIGxhcmdlIHF1YW50aXR5IG9mIHNtYWxsCiAJICogY29tbWFuZHMgYXQtb25jZTsgdXNpbmcgbXNsZWVwKCkgd291bGQgY2F1c2UgYSBsb3Qgb2YgY29udGV4dAotCSAqIHN3aXRjaGVzIHdoaWNoIHRha2UgbG9uZ2VyIHRoYW4gMm1zLCByZXN1bHRpbmcgaW4gYSBub3RpY2FibGUKKwkgKiBzd2l0Y2hlcyB3aGljaCB0YWtlIGxvbmdlciB0aGFuIDJtcywgcmVzdWx0aW5nIGluIGEgbm90aWNlYWJsZQogCSAqIGJvb3QtdGltZSBhbmQgY2FwdHVyZS1zdGFydCBkZWxheXMuCiAJICovCiAJbWRlbGF5KDIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtYXYtY29yZS5oIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtYXYtY29yZS5oCmluZGV4IDE4OGM5YzMuLmU5YzY5ZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gxOC9jeDE4LWF2LWNvcmUuaAorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1hdi1jb3JlLmgKQEAgLTEwOSw3ICsxMDksNyBAQAogCWludCBpc19pbml0aWFsaXplZDsKIAogCS8qCi0JICogVGhlIFZCSSBzbGljZXIgc3RhcnRzIG9wZXJhdGluZyBhbmQgY291bnRpbmcgbGluZXMsIGJlZ2luaW5nIGF0CisJICogVGhlIFZCSSBzbGljZXIgc3RhcnRzIG9wZXJhdGluZyBhbmQgY291bnRpbmcgbGluZXMsIGJlZ2lubmluZyBhdAogCSAqIHNsaWNlciBsaW5lIGNvdW50IG9mIDEsIGF0IEQgbGluZXMgYWZ0ZXIgdGhlIGRlYXNzZXJ0aW9uIG9mIFZSRVNFVC4KIAkgKiBUaGlzIHN0YXJpbmcgZmllbGQgbGluZSwgUywgaXMgNiAoJiAzMTkpIG9yIDEwICgmIDI3MykgZm9yIDYyNSBvciA1MjUKIAkgKiBsaW5lIHN5c3RlbXMgcmVzcGVjdGl2ZWx5LiAgU2xpY2VkIGFuY2lsbGFyeSBkYXRhIGNhcHR1cmVkIG9uIFZCSQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtaW9jdGwuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gxOC9jeDE4LWlvY3RsLmMKaW5kZXggODZjMzBiOS4uNGYwNDFjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtaW9jdGwuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1pb2N0bC5jCkBAIC0zMTIsNyArMzEyLDcgQEAKIAogCS8qCiAJICogU2V0IHRoZSBkaWdpdGl6ZXIgcmVnaXN0ZXJzIGZvciByYXcgYWN0aXZlIFZCSS4KLQkgKiBOb3RlIGN4MThfYXZfdmJpX3dpcGVzIG91dCBhbG90IG9mIHRoZSBwYXNzZWQgaW4gZm10IHVuZGVyIHZhbGlkCisJICogTm90ZSBjeDE4X2F2X3ZiaV93aXBlcyBvdXQgYSBsb3Qgb2YgdGhlIHBhc3NlZCBpbiBmbXQgdW5kZXIgdmFsaWQKIAkgKiBjYWxsaW5nIGNvbmRpdGlvbnMKIAkgKi8KIAlyZXQgPSB2NGwyX3N1YmRldl9jYWxsKGN4LT5zZF9hdiwgdmJpLCBzX3Jhd19mbXQsICZmbXQtPmZtdC52YmkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtdmJpLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC12YmkuYwppbmRleCA1ODIyMjc1Li42ZDMxMjFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC12YmkuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC12YmkuYwpAQCAtMjksNyArMjksNyBAQAogLyoKICAqIFJhc3RlciBSZWZlcmVuY2UvUHJvdGVjdGlvbiAoUlApIGJ5dGVzLCB1c2VkIGluIFN0YXJ0L0VuZCBBY3RpdmUKICAqIFZpZGVvIGNvZGVzIGVtaXR0ZWQgZnJvbSB0aGUgZGlnaXR6ZXIgaW4gVklQIDEueCBtb2RlLCB0aGF0IGZsYWcgdGhlIHN0YXJ0Ci0gKiBvZiBWQkkgc2FtcGxlIG9yIFZCSSBhbmNpbGxpYXJ5IGRhdGEgcmVnaW9ucyBpbiB0aGUgZGlnaXRpYWwgcmF0c2VyIGxpbmUuCisgKiBvZiBWQkkgc2FtcGxlIG9yIFZCSSBhbmNpbGxhcnkgZGF0YSByZWdpb25zIGluIHRoZSBkaWdpdGlhbCByYXRzZXIgbGluZS4KICAqCiAgKiBUYXNrIEZpZWxkRXZlbiBWZXJ0aWNhbEJsYW5rIEhvcml6b250YWxCbGFuayAwIDAgMCAwCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzF4eC9jeDIzMXh4LWF2Y29yZS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtYXZjb3JlLmMKaW5kZXggNjI4NDNkMy4uMjgwZGY0MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtYXZjb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtYXZjb3JlLmMKQEAgLTI1NzcsNyArMjU3Nyw3IEBACiAJCQlicmVhazsKIAogCQljYXNlIDY6CS8qIHRzMSBwYXJhbGxlbCBtb2RlICovCi0JCQljeDIzMXh4X2luZm8oIiVzOiBzZXQgdHMxIHBhcnJhbGxlbCBtb2RlIHJlZ2lzdGVyc1xuIiwKKwkJCWN4MjMxeHhfaW5mbygiJXM6IHNldCB0czEgcGFyYWxsZWwgbW9kZSByZWdpc3RlcnNcbiIsCiAJCQkJICAgICBfX2Z1bmNfXyk7CiAJCQlzdGF0dXMgPSBjeDIzMXh4X21vZGVfcmVnaXN0ZXIoZGV2LCBUU19NT0RFX1JFRywgMHgxMDApOwogCQkJc3RhdHVzID0gY3gyMzF4eF9tb2RlX3JlZ2lzdGVyKGRldiwgVFMxX0NGR19SRUcsIDB4NDAwKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzF4eC9jeDIzMXh4LXZiaS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtdmJpLmMKaW5kZXggMWQ5MTQ0OC4uMWM3YTRkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtdmJpLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtdmJpLmMKQEAgLTYzMSw3ICs2MzEsNyBAQAogCS8qIEdldCB0aGUgbmV4dCBidWZmZXIgKi8KIAkqYnVmID0gbGlzdF9lbnRyeShkbWFfcS0+YWN0aXZlLm5leHQsIHN0cnVjdCBjeDIzMXh4X2J1ZmZlciwgdmIucXVldWUpOwogCi0JLyogQ2xlYW5zIHVwIGJ1ZmZlciAtIFVzZWZ1bGwgZm9yIHRlc3RpbmcgZm9yIGZyYW1lL1VSQiBsb3NzICovCisJLyogQ2xlYW5zIHVwIGJ1ZmZlciAtIFVzZWZ1bCBmb3IgdGVzdGluZyBmb3IgZnJhbWUvVVJCIGxvc3MgKi8KIAlvdXRwID0gdmlkZW9idWZfdG9fdm1hbGxvYygmKCpidWYpLT52Yik7CiAJbWVtc2V0KG91dHAsIDAsICgqYnVmKS0+dmIuc2l6ZSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzF4eC9jeDIzMXh4LXZpZGVvLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MjMxeHgvY3gyMzF4eC12aWRlby5jCmluZGV4IGZmZDVhZjkuLmE2OWMyNGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzF4eC9jeDIzMXh4LXZpZGVvLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtdmlkZW8uYwpAQCAtMzA5LDcgKzMwOSw3IEBACiAJLyogR2V0IHRoZSBuZXh0IGJ1ZmZlciAqLwogCSpidWYgPSBsaXN0X2VudHJ5KGRtYV9xLT5hY3RpdmUubmV4dCwgc3RydWN0IGN4MjMxeHhfYnVmZmVyLCB2Yi5xdWV1ZSk7CiAKLQkvKiBDbGVhbnMgdXAgYnVmZmVyIC0gVXNlZnVsbCBmb3IgdGVzdGluZyBmb3IgZnJhbWUvVVJCIGxvc3MgKi8KKwkvKiBDbGVhbnMgdXAgYnVmZmVyIC0gVXNlZnVsIGZvciB0ZXN0aW5nIGZvciBmcmFtZS9VUkIgbG9zcyAqLwogCW91dHAgPSB2aWRlb2J1Zl90b192bWFsbG9jKCYoKmJ1ZiktPnZiKTsKIAltZW1zZXQob3V0cCwgMCwgKCpidWYpLT52Yi5zaXplKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzODg1L2NpbWF4Mi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzODg1L2NpbWF4Mi5jCmluZGV4IDIwOWI5NzEuLmM5ZjE1ZDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzg4NS9jaW1heDIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MjM4ODUvY2ltYXgyLmMKQEAgLTQ0OSw3ICs0NDksNyBAQAogCQkweDA0LCAvKiBhY2sgYWN0aXZlIGxvdyAqLwogCQkweDAwLCAvKiBMT0NLID0gMCAqLwogCQkweDMzLCAvKiBzZXJpYWwgbW9kZSwgcmlzaW5nIGluLCByaXNpbmcgb3V0LCBNU0IgZmlyc3QqLwotCQkweDMxLCAvKiBzeW5jcm9uaXphdGlvbiAqLworCQkweDMxLCAvKiBzeW5jaHJvbml6YXRpb24gKi8KIAl9OwogCWludCByZXQ7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzg4NS9jeDIzODg1LmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MjM4ODUvY3gyMzg4NS5oCmluZGV4IDhkYjI3OTcuLmMxODY0NzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzg4NS9jeDIzODg1LmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzODg1L2N4MjM4ODUuaApAQCAtMjE0LDcgKzIxNCw3IEBACiAKIAkvKiBWZW5kb3JzIGNhbiBhbmQgZG8gcnVuIHRoZSBQQ0llIGJyaWRnZSBhdCBkaWZmZXJlbnQKIAkgKiBjbG9jayByYXRlcywgZHJpdmVuIHBoeXNpY2FsbHkgYnkgY3J5c3RhbHMgb24gdGhlIFBDQnMuCi0JICogVGhlIGNvcmUgaGFzIHRvIGFjY29tb2RhdGUgdGhpcy4gVGhpcyBhbGxvd3MgdGhlIHVzZXIKKwkgKiBUaGUgY29yZSBoYXMgdG8gYWNjb21tb2RhdGUgdGhpcy4gVGhpcyBhbGxvd3MgdGhlIHVzZXIKIAkgKiB0byBhZGQgbmV3IGJvYXJkcyB3aXRoIG5ldyBmcmVxdWVuY3lzLiBUaGUgdmFsdWUgaXMKIAkgKiBleHByZXNzZWQgaW4gSHouCiAJICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyNTg0MC9jeDI1ODQwLWNvcmUuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyNTg0MC9jeDI1ODQwLWNvcmUuYwppbmRleCAzNTc5NmUwLi5iN2VlMmFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MjU4NDAvY3gyNTg0MC1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDI1ODQwL2N4MjU4NDAtY29yZS5jCkBAIC0yLDcgKzIsNyBAQAogICoKICAqIENvcHlyaWdodCAoQykgMjAwNCBVbGYgRWtsdW5kCiAgKgotICogQmFzZWQgb24gdGhlIHNhYTcxMTUgZHJpdmVyIGFuZCBvbiB0aGUgZmlyc3QgdmVyaXNvbiBvZiBDaHJpcyBLZW5uZWR5J3MKKyAqIEJhc2VkIG9uIHRoZSBzYWE3MTE1IGRyaXZlciBhbmQgb24gdGhlIGZpcnN0IHZlcnNpb24gb2YgQ2hyaXMgS2VubmVkeSdzCiAgKiBjeDI1ODQwIGRyaXZlci4KICAqCiAgKiBDaGFuZ2VzIGJ5IFR5bGVyIFRyYWZmb3JkIDx0YXRyYWZmb3JkQGNvbWNhc3QubmV0PgpAQCAtNDQ1LDcgKzQ0NSw3IEBACiAJY3gyNTg0MF93cml0ZShjbGllbnQsIDB4OTE4LCAweGEwKTsKIAljeDI1ODQwX3dyaXRlKGNsaWVudCwgMHg5MTksIDB4MDEpOwogCi0JLyogc3RlcmVvIHByZWZlcmVkICovCisJLyogc3RlcmVvIHByZWZlcnJlZCAqLwogCWN4MjU4NDBfd3JpdGUoY2xpZW50LCAweDgwOSwgMHgwNCk7CiAJLyogQUM5NyBzaGlmdCAqLwogCWN4MjU4NDBfd3JpdGUoY2xpZW50LCAweDhjZiwgMHgwZik7CkBAIC01NDYsNyArNTQ2LDcgQEAKIAkgKiBBdXggUExMCiAJICogSW5pdGlhbCBzZXR1cCBmb3IgYXVkaW8gc2FtcGxlIGNsb2NrOgogCSAqIDQ4IGtzcHMsIDE2IGJpdHMvc2FtcGxlLCB4MTYwIG11bHRpcGxpZXIgPSAxMjIuODggTUh6Ci0JICogSW50aWFsIEkyUyBvdXRwdXQvbWFzdGVyIGNsb2NrKD8pOgorCSAqIEluaXRpYWwgSTJTIG91dHB1dC9tYXN0ZXIgY2xvY2soPyk6CiAJICogNDgga3NwcywgMTYgYml0cy9zYW1wbGUsIHgxNiBtdWx0aXBsaWVyID0gMTIuMjg4IE1IegogCSAqLwogCXN3aXRjaCAoc3RhdGUtPmlkKSB7CkBAIC05MDMsNyArOTAzLDcgQEAKIAl9IGVsc2UgaWYgKHN0ZCAmIFY0TDJfU1REX1BBTCkgewogCQkvKiBBdXRvZGV0ZWN0IGF1ZGlvIHN0YW5kYXJkIGFuZCBhdWRpbyBzeXN0ZW0gKi8KIAkJY3gyNTg0MF93cml0ZShjbGllbnQsIDB4ODA4LCAweGZmKTsKLQkJLyogU2luY2Ugc3lzdGVtIFBBTC1MIGlzIHByZXR0eSBtdWNoIG5vbi1leGlzdGFudCBhbmQKKwkJLyogU2luY2Ugc3lzdGVtIFBBTC1MIGlzIHByZXR0eSBtdWNoIG5vbi1leGlzdGVudCBhbmQKIAkJICAgbm90IHVzZWQgYnkgYW55IHB1YmxpYyBicm9hZGNhc3QgbmV0d29yaywgZm9yY2UKIAkJICAgNi41IE1IeiBjYXJyaWVyIHRvIGJlIGludGVycHJldGVkIGFzIFN5c3RlbSBESywKIAkJICAgdGhpcyBhdm9pZHMgREsgYXVkaW8gZGV0ZWN0aW9uIGluc3RhYmlsaXR5ICovCkBAIC0xODUxLDcgKzE4NTEsNyBAQAogCQkJcmV0ID0gVjRMMl9JREVOVF9DWDIzODg1X0FWOwogCQl9IGVsc2UgewogCQkJLyogQ1gyMzg4NyBoYXMgYSBicm9rZW4gRElGLCBidXQgdGhlIHJlZ2lzdGVycwotCQkJICogYXBwZWFyIHZhbGlkIChidXQgdW5zZWQpLCBnb29kIGVub3VnaCB0byBkZXRlY3QuICovCisJCQkgKiBhcHBlYXIgdmFsaWQgKGJ1dCB1bnVzZWQpLCBnb29kIGVub3VnaCB0byBkZXRlY3QuICovCiAJCQlyZXQgPSBWNEwyX0lERU5UX0NYMjM4ODdfQVY7CiAJCX0KIAl9IGVsc2UgaWYgKGN4MjU4NDBfcmVhZDQoY2xpZW50LCAweDMwMCkgJiAweDBmZmZmZmZmKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvZG02NDR4X2NjZGMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS9kbTY0NHhfY2NkYy5jCmluZGV4IDQ5MGFhZmIuLmM4YjMyYzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS9kbTY0NHhfY2NkYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS9kbTY0NHhfY2NkYy5jCkBAIC0yNTgsNyArMjU4LDcgQEAKIAkvKgogCSAqIEFsbG9jYXRlIG1lbW9yeSBmb3IgRlBDIHRhYmxlIGlmIGN1cnJlbnQKIAkgKiBGUEMgdGFibGUgYnVmZmVyIGlzIG5vdCBiaWcgZW5vdWdoIHRvCi0JICogYWNjb21vZGF0ZSBGUEMgTnVtYmVyIHJlcXVlc3RlZAorCSAqIGFjY29tbW9kYXRlIEZQQyBOdW1iZXIgcmVxdWVzdGVkCiAJICovCiAJaWYgKHJhd19wYXJhbXMtPmZhdWx0X3B4bC5mcF9udW0gIT0gY29uZmlnX3BhcmFtcy0+ZmF1bHRfcHhsLmZwX251bSkgewogCQlpZiAoZnBjX3BoeXNhZGRyICE9IE5VTEwpIHsKQEAgLTQzNiw3ICs0MzYsNyBAQAogCiAJLyoKIAkgKiBjb25maWd1cmUgdGhlIGhvcml6b250YWwgbGluZSBvZmZzZXQuIFRoaXMgc2hvdWxkIGJlIGEKLQkgKiBvbiAzMiBieXRlIGJvbmRhcnkuIFNvIGNsZWFyIExTQiA1IGJpdHMKKwkgKiBvbiAzMiBieXRlIGJvdW5kYXJ5LiBTbyBjbGVhciBMU0IgNSBiaXRzCiAJICovCiAJcmVndygoKHBhcmFtcy0+d2luLndpZHRoICogMiAgKyAzMSkgJiB+MHgxZiksIENDRENfSFNJWkVfT0ZGKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwZmVfY2FwdHVyZS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwZmVfY2FwdHVyZS5jCmluZGV4IDcxZTk2MWUuLjViMzhmYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGZlX2NhcHR1cmUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBmZV9jYXB0dXJlLmMKQEAgLTE2OTEsNyArMTY5MSw3IEBACiAJCWdvdG8gdW5sb2NrX291dDsKIAl9CiAKLQkvKiBhZGp1c3QgdGhlIHdpZHRoIHRvIDE2IHBpeGVsIGJvdW5kcnkgKi8KKwkvKiBhZGp1c3QgdGhlIHdpZHRoIHRvIDE2IHBpeGVsIGJvdW5kYXJ5ICovCiAJY3JvcC0+Yy53aWR0aCA9ICgoY3JvcC0+Yy53aWR0aCArIDE1KSAmIH4weGYpOwogCiAJLyogbWFrZSBzdXJlIHBhcmFtZXRlcnMgYXJlIHZhbGlkICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2VtMjh4eC9lbTI4eHgtdmlkZW8uYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZW0yOHh4L2VtMjh4eC12aWRlby5jCmluZGV4IGE4MzEzMWIuLjdiNjQ2MWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZW0yOHh4L2VtMjh4eC12aWRlby5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZW0yOHh4L2VtMjh4eC12aWRlby5jCkBAIC0zNzcsNyArMzc3LDcgQEAKIAkvKiBHZXQgdGhlIG5leHQgYnVmZmVyICovCiAJKmJ1ZiA9IGxpc3RfZW50cnkoZG1hX3EtPmFjdGl2ZS5uZXh0LCBzdHJ1Y3QgZW0yOHh4X2J1ZmZlciwgdmIucXVldWUpOwogCi0JLyogQ2xlYW5zIHVwIGJ1ZmZlciAtIFVzZWZ1bGwgZm9yIHRlc3RpbmcgZm9yIGZyYW1lL1VSQiBsb3NzICovCisJLyogQ2xlYW5zIHVwIGJ1ZmZlciAtIFVzZWZ1bCBmb3IgdGVzdGluZyBmb3IgZnJhbWUvVVJCIGxvc3MgKi8KIAlvdXRwID0gdmlkZW9idWZfdG9fdm1hbGxvYygmKCpidWYpLT52Yik7CiAJbWVtc2V0KG91dHAsIDAsICgqYnVmKS0+dmIuc2l6ZSk7CiAKQEAgLTQwNCw3ICs0MDQsNyBAQAogCiAJLyogR2V0IHRoZSBuZXh0IGJ1ZmZlciAqLwogCSpidWYgPSBsaXN0X2VudHJ5KGRtYV9xLT5hY3RpdmUubmV4dCwgc3RydWN0IGVtMjh4eF9idWZmZXIsIHZiLnF1ZXVlKTsKLQkvKiBDbGVhbnMgdXAgYnVmZmVyIC0gVXNlZnVsbCBmb3IgdGVzdGluZyBmb3IgZnJhbWUvVVJCIGxvc3MgKi8KKwkvKiBDbGVhbnMgdXAgYnVmZmVyIC0gVXNlZnVsIGZvciB0ZXN0aW5nIGZvciBmcmFtZS9VUkIgbG9zcyAqLwogCW91dHAgPSB2aWRlb2J1Zl90b192bWFsbG9jKCYoKmJ1ZiktPnZiKTsKIAltZW1zZXQob3V0cCwgMHgwMCwgKCpidWYpLT52Yi5zaXplKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nbDg2MC9nbDg2MC1taTEzMjAuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ2w4NjAvZ2w4NjAtbWkxMzIwLmMKaW5kZXggYzI3NmE3ZC4uYjU3MTYwZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nbDg2MC9nbDg2MC1taTEzMjAuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2dsODYwL2dsODYwLW1pMTMyMC5jCkBAIC0yMDEsNyArMjAxLDcgQEAKIAlzZC0+dm1heC5iYWNrbGlnaHQgID0gIDI7CiAJc2QtPnZtYXguYnJpZ2h0bmVzcyA9ICA4OwogCXNkLT52bWF4LnNoYXJwbmVzcyAgPSAgNzsKLQlzZC0+dm1heC5jb250cmFzdCAgID0gIDA7IC8qIDEwIGJ1dCBub3Qgd29ya2luZyB3aXRoIHRpaHMgZHJpdmVyICovCisJc2QtPnZtYXguY29udHJhc3QgICA9ICAwOyAvKiAxMCBidXQgbm90IHdvcmtpbmcgd2l0aCB0aGlzIGRyaXZlciAqLwogCXNkLT52bWF4LmdhbW1hICAgICAgPSA0MDsKIAlzZC0+dm1heC5odWUgICAgICAgID0gIDUgKyAxOwogCXNkLT52bWF4LnNhdHVyYXRpb24gPSAgODsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ3NwY2EuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ3NwY2EuYwppbmRleCA5YzZhNjQzLi5lNTI2YWEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2dzcGNhLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nc3BjYS5jCkBAIC04NTcsNyArODU3LDcgQEAKIAkJfQogCiAJCS8qIHRoZSBiYW5kd2lkdGggaXMgbm90IHdpZGUgZW5vdWdoCi0JCSAqIG5lZ29jaWF0ZSBvciB0cnkgYSBsb3dlciBhbHRlcm5hdGUgc2V0dGluZyAqLworCQkgKiBuZWdvdGlhdGUgb3IgdHJ5IGEgbG93ZXIgYWx0ZXJuYXRlIHNldHRpbmcgKi8KIAkJUERFQlVHKERfRVJSfERfU1RSRUFNLAogCQkJImJhbmR3aWR0aCBub3Qgd2lkZSBlbm91Z2ggLSB0cnlpbmcgYWdhaW4iKTsKIAkJbXNsZWVwKDIwKTsJLyogd2FpdCBmb3Iga2lsbCBjb21wbGV0ZSAqLwpAQCAtMjM0Niw3ICsyMzQ2LDcgQEAKIAl1c2Jfc2V0X2ludGZkYXRhKGludGYsIE5VTEwpOwogCiAJLyogcmVsZWFzZSB0aGUgZGV2aWNlICovCi0JLyogKHRoaXMgd2lsbCBjYWxsIGdzcGNhX3JlbGVhc2UoKSBpbW1lZGlhdGx5IG9yIG9uIGxhc3QgY2xvc2UpICovCisJLyogKHRoaXMgd2lsbCBjYWxsIGdzcGNhX3JlbGVhc2UoKSBpbW1lZGlhdGVseSBvciBvbiBsYXN0IGNsb3NlKSAqLwogCXZpZGVvX3VucmVnaXN0ZXJfZGV2aWNlKCZnc3BjYV9kZXYtPnZkZXYpOwogCiAvKglQREVCVUcoRF9QUk9CRSwgImRpc2Nvbm5lY3QgY29tcGxldGUiKTsgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbWFycy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9tYXJzLmMKaW5kZXggY2I0ZDBiZi4uMDE5NjIwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9tYXJzLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9tYXJzLmMKQEAgLTM2MSw3ICszNjEsNyBAQAogCQltaV93KGdzcGNhX2RldiwgaSArIDEsIG1pX2RhdGFbaV0pOwogCiAJZGF0YVswXSA9IDB4MDA7Ci0JZGF0YVsxXSA9IDB4NGQ7CQkvKiBJU09DIHRyYW5zZmVyaW5nIGVuYWJsZS4uLiAqLworCWRhdGFbMV0gPSAweDRkOwkJLyogSVNPQyB0cmFuc2ZlcnJpbmcgZW5hYmxlLi4uICovCiAJcmVnX3coZ3NwY2FfZGV2LCAyKTsKIAogCWdzcGNhX2Rldi0+Y3RybF9pbmFjID0gMDsgLyogYWN0aXZhdGUgdGhlIGlsbHVtaW5hdG9yIGNvbnRyb2xzICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL21yOTczMTBhLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL21yOTczMTBhLmMKaW5kZXggMzg4NGM5ZC4uOTdlNTA3OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9tcjk3MzEwYS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbXI5NzMxMGEuYwpAQCAtNDY5LDcgKzQ2OSw3IEBACiBzdGF0aWMgaW50IGlzb2NfZW5hYmxlKHN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2RldikKIHsKIAlnc3BjYV9kZXYtPnVzYl9idWZbMF0gPSAweDAwOwotCWdzcGNhX2Rldi0+dXNiX2J1ZlsxXSA9IDB4NGQ7ICAvKiBJU09DIHRyYW5zZmVyaW5nIGVuYWJsZS4uLiAqLworCWdzcGNhX2Rldi0+dXNiX2J1ZlsxXSA9IDB4NGQ7ICAvKiBJU09DIHRyYW5zZmVycmluZyBlbmFibGUuLi4gKi8KIAlyZXR1cm4gbXJfd3JpdGUoZ3NwY2FfZGV2LCAyKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUxOS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUxOS5jCmluZGV4IGZkMWI2MDguLjM2YTQ2ZmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evb3Y1MTkuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL292NTE5LmMKQEAgLTM4MSw3ICszODEsNyBAQAogICAgbGFyZ2VyIHRoZW4gbmVjZXNzYXJ5LCBob3dldmVyIHRoZXkgbmVlZCB0byBiZSB0aGlzIGJpZyBhcyB0aGUgb3Y1MTEgLwogICAgb3Y1MTggYWx3YXlzIGZpbGxzIHRoZSBlbnRpcmUgaXNvYyBmcmFtZSwgdXNpbmcgMCBwYWRkaW5nIGJ5dGVzIHdoZW4KICAgIGl0IGRvZXNuJ3QgaGF2ZSBhbnkgZGF0YS4gU28gd2l0aCBsb3cgZnJhbWVyYXRlcyB0aGUgYW1vdW50IG9mIGRhdGEKLSAgIHRyYW5zZmVyZWQgY2FuIGJlY29tZSBxdWl0ZSBsYXJnZSAobGlidjRsIHdpbGwgcmVtb3ZlIGFsbCB0aGUgMCBwYWRkaW5nCisgICB0cmFuc2ZlcnJlZCBjYW4gYmVjb21lIHF1aXRlIGxhcmdlIChsaWJ2NGwgd2lsbCByZW1vdmUgYWxsIHRoZSAwIHBhZGRpbmcKICAgIGluIHVzZXJzcGFjZSkuICovCiBzdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfcGl4X2Zvcm1hdCBvdjUxOF92Z2FfbW9kZVtdID0gewogCXszMjAsIDI0MCwgVjRMMl9QSVhfRk1UX09WNTE4LCBWNEwyX0ZJRUxEX05PTkUsCkBAIC00MzY4LDcgKzQzNjgsNyBAQAogCQkJCWdzcGNhX2Rldi0+bGFzdF9wYWNrZXRfdHlwZSA9IERJU0NBUkRfUEFDS0VUOwogCQkJCXJldHVybjsKIAkJCX0KLQkJCS8qIEFkZCAxMSBieXRlIGZvb3RlciB0byBmcmFtZSwgbWlnaHQgYmUgdXNlZnVsbCAqLworCQkJLyogQWRkIDExIGJ5dGUgZm9vdGVyIHRvIGZyYW1lLCBtaWdodCBiZSB1c2VmdWwgKi8KIAkJCWdzcGNhX2ZyYW1lX2FkZChnc3BjYV9kZXYsIExBU1RfUEFDS0VULCBpbiwgMTEpOwogCQkJcmV0dXJuOwogCQl9IGVsc2UgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zb25peGIuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc29uaXhiLmMKaW5kZXggNWEwODczOC4uMTQ2YjQ1OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zb25peGIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3Nvbml4Yi5jCkBAIC04MjcsNyArODI3LDcgQEAKIAkJICAgcG9zc2libGUgdG8gdXNlIGxlc3MgZXhwb3N1cmUgdGhlbiB3aGF0IHRoZSBmcHMgbWF4aW11bQogCQkgICBhbGxvd3MgYnkgc2V0dGluZyByZWdpc3RlciAxMC4gcmVnaXN0ZXIgMTAgY29uZmlndXJlcyB0aGUKIAkJICAgYWN0dWFsIGV4cG9zdXJlIGFzIHF1b3RpZW50IG9mIHRoZSBmdWxsIGV4cG9zdXJlLCB3aXRoIDAKLQkJICAgYmVpbmcgbm8gZXhwb3N1cmUgYXQgYWxsIChub3QgdmVyeSB1c2VmdWxsKSBhbmQgcmVnMTBfbWF4CisJCSAgIGJlaW5nIG5vIGV4cG9zdXJlIGF0IGFsbCAobm90IHZlcnkgdXNlZnVsKSBhbmQgcmVnMTBfbWF4CiAJCSAgIGJlaW5nIG1heCBleHBvc3VyZSBwb3NzaWJsZSBhdCB0aGF0IGZyYW1lcmF0ZS4KIAogCQkgICBUaGUgY29kZSBtYXBzIG91ciAwIC0gNTEwIG1zIGV4cG9zdXJlIGN0cmwgdG8gdGhlc2UgMgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTAwLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDAuYwppbmRleCA0NTU1MmMzLi4zZTc2OTUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDAuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDAuYwpAQCAtNjA3LDcgKzYwNyw3IEBACiAJcmVnX3coZ3NwY2FfZGV2LCAweDAwLCAweDg4ODAsIDIpOwogCS8qIGZhbWlseSBjYW0gUXVpY2tzbWFydCBzdHVmZiAqLwogCXJlZ193KGdzcGNhX2RldiwgMHgwMCwgMHg4MDBhLCAweDAwKTsKLQkvKiBTZXQgYWdjIHRyYW5zZmVyOiBzeW5jZWQgaW5iZXR3ZWVuIGZyYW1lcyAqLworCS8qIFNldCBhZ2MgdHJhbnNmZXI6IHN5bmNlZCBiZXR3ZWVuIGZyYW1lcyAqLwogCXJlZ193KGdzcGNhX2RldiwgMHgwMCwgMHg4MjBmLCAweDAxKTsKIAkvKiBJbml0IFNEUkFNIC0gbmVlZGVkIGZvciBTRFJBTSBhY2Nlc3MgKi8KIAlyZWdfdyhnc3BjYV9kZXYsIDB4MDAsIDB4ODcwYSwgMHgwNCk7CkBAIC04MzEsNyArODMxLDcgQEAKIAogCQkvKiBmYW1pbHljYW0gUXVpY2tzbWFydCBwb2NrZXREViBzdHVmZiAqLwogCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDAsIDB4ODAwYSwgMHgwMCk7Ci0JCS8qIFNldCBhZ2MgdHJhbnNmZXI6IHN5bmNlZCBpbmJldHdlZW4gZnJhbWVzICovCisJCS8qIFNldCBhZ2MgdHJhbnNmZXI6IHN5bmNlZCBiZXR3ZWVuIGZyYW1lcyAqLwogCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDAsIDB4ODIwZiwgMHgwMSk7CiAJCS8qIEluaXQgU0RSQU0gLSBuZWVkZWQgZm9yIFNEUkFNIGFjY2VzcyAqLwogCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDAsIDB4ODcwYSwgMHgwNCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDguYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTUwOC5jCmluZGV4IDM0ODMxOTMuLjQxZGNlNDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTUwOC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTUwOC5jCkBAIC01OTIsNyArNTkyLDcgQEAKIC8qIFRoaXMgbGluZSBzZWVtcyB0byBzZXR1cCB0aGUgZnJhbWUvY2FudmFzICovCiAJezB4MDAwZiwgMHg4NDAyfSwKIAotLyogVGhlZXNlIDYgbGluZXMgYXJlIG5lZWRlZCB0byBzdGFydHVwIHRoZSB3ZWJjYW0gKi8KKy8qIFRoZXNlIDYgbGluZXMgYXJlIG5lZWRlZCB0byBzdGFydHVwIHRoZSB3ZWJjYW0gKi8KIAl7MHgwMDkwLCAweDgxMTB9LAogCXsweDAwMDEsIDB4ODExNH0sCiAJezB4MDAwMSwgMHg4MTE0fSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3E5MDUuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3E5MDUuYwppbmRleCAyZTljMDYxLi41YmE5NmFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NxOTA1LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcTkwNS5jCkBAIC0yMiw3ICsyMiw3IEBACiAgKiBIaXN0b3J5IGFuZCBBY2tub3dsZWRnbWVudHMKICAqCiAgKiBUaGUgb3JpZ2luYWwgTGludXggZHJpdmVyIGZvciBTUTkwNSBiYXNlZCBjYW1lcmFzIHdhcyB3cml0dGVuIGJ5Ci0gKiBNYXJjZWxsIExlbmd5ZWwgYW5kIGZ1cnRlciBkZXZlbG9wZWQgYnkgbWFueSBvdGhlciBjb250cmlidXRlcnMKKyAqIE1hcmNlbGwgTGVuZ3llbCBhbmQgZnVydGVyIGRldmVsb3BlZCBieSBtYW55IG90aGVyIGNvbnRyaWJ1dG9ycwogICogYW5kIGlzIGF2YWlsYWJsZSBmcm9tIGh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvcHJvamVjdHMvc3FjYW0vCiAgKgogICogVGhpcyBkcml2ZXIgdGFrZXMgYWR2YW50YWdlIG9mIHRoZSByZXZlcnNlIGVuZ2luZWVyaW5nIHdvcmsgZG9uZSBmb3IKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3R2MDZ4eC9zdHYwNnh4X2hkY3MuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3R2MDZ4eC9zdHYwNnh4X2hkY3MuYwppbmRleCAxNzUzMWI0Li5iODE1Njg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0djA2eHgvc3R2MDZ4eF9oZGNzLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zdHYwNnh4L3N0djA2eHhfaGRjcy5jCkBAIC01NjksNyArNTY5LDcgQEAKIAlpZiAoZXJyIDwgMCkKIAkJcmV0dXJuIGVycjsKIAotCS8qIEVuYWJsZSBjb250aW5vdXMgZnJhbWUgY2FwdHVyZSwgYml0IDI6IHN0b3Agd2hlbiBmcmFtZSBjb21wbGV0ZSAqLworCS8qIEVuYWJsZSBjb250aW51b3VzIGZyYW1lIGNhcHR1cmUsIGJpdCAyOiBzdG9wIHdoZW4gZnJhbWUgY29tcGxldGUgKi8KIAllcnIgPSBzdHYwNnh4X3dyaXRlX3NlbnNvcihzZCwgSERDU19SRUdfQ09ORklHKHNkKSwgQklUKDMpKTsKIAlpZiAoZXJyIDwgMCkKIAkJcmV0dXJuIGVycjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaGV4aXVtX2dlbWluaS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZXhpdW1fZ2VtaW5pLmMKaW5kZXggY2RmOGIxOS4uY2JjNTA1YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9oZXhpdW1fZ2VtaW5pLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZXhpdW1fZ2VtaW5pLmMKQEAgLTI2MSw3ICsyNjEsNyBAQAogCiAvKiB0aGUgc2FhNzE0NiBwcm92aWRlcyBzb21lIGNvbnRyb2xzIChicmlnaHRuZXNzLCBjb250cmFzdCwgc2F0dXJhdGlvbikKICAgIHdoaWNoIGdldHMgcmVnaXN0ZXJlZCAqYWZ0ZXIqIHRoaXMgZnVuY3Rpb24uIGJlY2F1c2Ugb2YgdGhpcyB3ZSBoYXZlCi0gICB0byByZXR1cm4gd2l0aCBhIHZhbHVlICE9IDAgZXZlbiBpZiB0aGUgZnVuY3Rpb24gc3VjY2VkZWQuLiAqLworICAgdG8gcmV0dXJuIHdpdGggYSB2YWx1ZSAhPSAwIGV2ZW4gaWYgdGhlIGZ1bmN0aW9uIHN1Y2NlZWRlZC4uICovCiBzdGF0aWMgaW50IHZpZGlvY19xdWVyeWN0cmwoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKmZoLCBzdHJ1Y3QgdjRsMl9xdWVyeWN0cmwgKnFjKQogewogCXN0cnVjdCBzYWE3MTQ2X2RldiAqZGV2ID0gKChzdHJ1Y3Qgc2FhNzE0Nl9maCAqKWZoKS0+ZGV2OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHYtZmlybXdhcmUuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vaXZ0di9pdnR2LWZpcm13YXJlLmMKaW5kZXggNGRmMDE5NC4uMTRhMWNlYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHYtZmlybXdhcmUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2l2dHYvaXZ0di1maXJtd2FyZS5jCkBAIC0xNzksNyArMTc5LDcgQEAKIHsKIAlpbnQgaTsKIAotCS8qIG1haWxib3ggaXMgcHJlY2VlZGVkIGJ5IGEgMTYgYnl0ZSAnbWFnaWMgY29va2llJyBzdGFydGluZyBhdCBhIDI1Ni1ieXRlCisJLyogbWFpbGJveCBpcyBwcmVjZWRlZCBieSBhIDE2IGJ5dGUgJ21hZ2ljIGNvb2tpZScgc3RhcnRpbmcgYXQgYSAyNTYtYnl0ZQogCSAgIGFkZHJlc3MgYm91bmRhcnkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgc2l6ZTsgaSArPSAweDEwMCkgewogCQlpZiAocmVhZGwobWVtICsgaSkgICAgICA9PSAweDEyMzQ1Njc4ICYmCkBAIC0zNzcsNyArMzc3LDcgQEAKIAkJCSAgIlJlbG9hZGluZ1xuIiwgd2hlcmUpOwogCQlyZXMgPSBpdnR2X2Zpcm13YXJlX3Jlc3RhcnQoaXR2KTsKIAkJLyoKLQkJICogRXZlbiBpZiByZXN0YXJ0ZWQgb2ssIHN0aWxsIHNpZ25hbCBhIHByb2JsZW0gaGFkIG9jY3VyZWQuCisJCSAqIEV2ZW4gaWYgcmVzdGFydGVkIG9rLCBzdGlsbCBzaWduYWwgYSBwcm9ibGVtIGhhZCBvY2N1cnJlZC4KIAkJICogVGhlIGNhbGxlciBjYW4gY29tZSB0aHJvdWdoIHRoaXMgZnVuY3Rpb24gYWdhaW4gdG8gY2hlY2sKIAkJICogaWYgdGhpbmdzIGFyZSByZWFsbHkgb2sgYWZ0ZXIgdGhlIHJlc3RhcnQuCiAJCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHZmYi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHZmYi5jCmluZGV4IGYwMzE2ZDAuLjE3MjQ3NDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaXZ0di9pdnR2ZmIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2l2dHYvaXZ0dmZiLmMKQEAgLTEwODAsNyArMTA4MCw3IEBACiAJCWttYWxsb2Moc2l6ZW9mKHUzMikgKiAxNiwgR0ZQX0tFUk5FTHxfX0dGUF9OT1dBUk4pOwogCiAJaWYgKCFvaS0+aXZ0dmZiX2luZm8ucHNldWRvX3BhbGV0dGUpIHsKLQkJSVZUVkZCX0VSUigiYWJvcnQsIHVuYWJsZSB0byBhbGxvYyBwc2V1ZG8gcGFsbGV0ZVxuIik7CisJCUlWVFZGQl9FUlIoImFib3J0LCB1bmFibGUgdG8gYWxsb2MgcHNldWRvIHBhbGV0dGVcbiIpOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vbXNwMzQwMC1kcml2ZXIuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vbXNwMzQwMC1kcml2ZXIuYwppbmRleCBiMTc2M2FjLi44MTI2NjIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL21zcDM0MDAtZHJpdmVyLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9tc3AzNDAwLWRyaXZlci5jCkBAIC02OSw3ICs2OSw3IEBACiAvKiBtb2R1bGUgcGFyYW1ldGVycyAqLwogc3RhdGljIGludCBvcG1vZGUgICA9IE9QTU9ERV9BVVRPOwogaW50IG1zcF9kZWJ1ZzsJCSAvKiBtc3BfZGVidWcgb3V0cHV0ICovCi1pbnQgbXNwX29uY2U7CQkgLyogbm8gY29udGlub3VzIHN0ZXJlbyBtb25pdG9yaW5nICovCitpbnQgbXNwX29uY2U7CQkgLyogbm8gY29udGludW91cyBzdGVyZW8gbW9uaXRvcmluZyAqLwogaW50IG1zcF9hbXNvdW5kOwkgLyogaGFyZC13aXJlIEFNIHNvdW5kIGF0IDYuNSBIeiAoZnJhbmNlKSwKIAkJCSAgICB0aGUgYXV0b3NjYW4gc2VlbXMgd29yayB3ZWxsIG9ubHkgd2l0aCBGTS4uLiAqLwogaW50IG1zcF9zdGFuZGFyZCA9IDE7ICAgIC8qIE92ZXJyaWRlIGF1dG8gZGV0ZWN0IG9mIGF1ZGlvIG1zcF9zdGFuZGFyZCwKQEAgLTU1MSw3ICs1NTEsNyBAQAogCXN3aXRjaCAoc3RhdGUtPm1vZGUpIHsKIAkJY2FzZSBNU1BfTU9ERV9BTV9ERVRFQ1Q6IHAgPSAiQU0gKGZvciBjYXJyaWVyIGRldGVjdCkiOyBicmVhazsKIAkJY2FzZSBNU1BfTU9ERV9GTV9SQURJTzogcCA9ICJGTSBSYWRpbyI7IGJyZWFrOwotCQljYXNlIE1TUF9NT0RFX0ZNX1RFUlJBOiBwID0gIlRlcnJlc3RpYWwgRk0tbW9uby9zdGVyZW8iOyBicmVhazsKKwkJY2FzZSBNU1BfTU9ERV9GTV9URVJSQTogcCA9ICJUZXJyZXN0cmlhbCBGTS1tb25vL3N0ZXJlbyI7IGJyZWFrOwogCQljYXNlIE1TUF9NT0RFX0ZNX1NBVDogcCA9ICJTYXRlbGxpdGUgRk0tbW9ubyI7IGJyZWFrOwogCQljYXNlIE1TUF9NT0RFX0ZNX05JQ0FNMTogcCA9ICJOSUNBTS9GTSAoQi9HLCBEL0spIjsgYnJlYWs7CiAJCWNhc2UgTVNQX01PREVfRk1fTklDQU0yOiBwID0gIk5JQ0FNL0ZNIChJKSI7IGJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9tc3AzNDAwLWt0aHJlYWRzLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL21zcDM0MDAta3RocmVhZHMuYwppbmRleCBiMzc2ZmNkLi44MDM4N2UyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL21zcDM0MDAta3RocmVhZHMuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL21zcDM0MDAta3RocmVhZHMuYwpAQCAtODcsNyArODcsNyBAQAogCQl7LTgsIC04LCA0LCA2LCA3OCwgMTA3fSwKIAkJTVNQX0NBUlJJRVIoMTAuNyksIE1TUF9DQVJSSUVSKDEwLjcpLAogCQkweDAwZDAsIDB4MDQ4MCwgMHgwMDIwLCAweDMwMDAKLQl9LCB7CS8qIFRlcnJlc3RpYWwgRk0tbW9ubyArIEZNLXN0ZXJlbyAqLworCX0sIHsJLyogVGVycmVzdHJpYWwgRk0tbW9ubyArIEZNLXN0ZXJlbyAqLwogCQl7MywgMTgsIDI3LCA0OCwgNjYsIDcyfSwKIAkJezMsIDE4LCAyNywgNDgsIDY2LCA3Mn0sCiAJCU1TUF9DQVJSSUVSKDUuNSksIE1TUF9DQVJSSUVSKDUuNSksCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAvb21hcF92b3V0LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAvb21hcF92b3V0LmMKaW5kZXggMDI5YTRiYS4uZDRmZTdiYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwL29tYXBfdm91dC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcC9vbWFwX3ZvdXQuYwpAQCAtNDczLDcgKzQ3Myw3IEBACiAvKgogICogQ29udmVydCBWNEwyIHJvdGF0aW9uIHRvIERTUyByb3RhdGlvbgogICoJVjRMMiB1bmRlcnN0YW5kIDAsIDkwLCAxODAsIDI3MC4KLSAqCUNvbnZlcnQgdG8gMCwgMSwgMiBhbmQgMyByZXBzZWN0aXZlbHkgZm9yIERTUworICoJQ29udmVydCB0byAwLCAxLCAyIGFuZCAzIHJlc3BlY3RpdmVseSBmb3IgRFNTCiAgKi8KIHN0YXRpYyBpbnQgdjRsMl9yb3RfdG9fZHNzX3JvdChpbnQgdjRsMl9yb3RhdGlvbiwKIAkJCWVudW0gZHNzX3JvdGF0aW9uICpyb3RhdGlvbiwgYm9vbCBtaXJyb3IpCkBAIC0xMTQyLDcgKzExNDIsNyBAQAogfQogCiAvKgotICogQnVmZmVyIHF1ZXVlIGZ1bnRpb24gd2lsbCBiZSBjYWxsZWQgZnJvbSB0aGUgdmlkZW9idWYgbGF5ZXIgd2hlbiBfUUJVRgorICogQnVmZmVyIHF1ZXVlIGZ1bmN0aW9uIHdpbGwgYmUgY2FsbGVkIGZyb20gdGhlIHZpZGVvYnVmIGxheWVyIHdoZW4gX1FCVUYKICAqIGlvY3RsIGlzIGNhbGxlZC4gSXQgaXMgdXNlZCB0byBlbnF1ZXVlIGJ1ZmZlciwgd2hpY2ggaXMgcmVhZHkgdG8gYmUKICAqIGRpc3BsYXllZC4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwL29tYXBfdm91dGxpYi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwL29tYXBfdm91dGxpYi5jCmluZGV4IGI5NDFjNzYuLjJhYTZhNzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcC9vbWFwX3ZvdXRsaWIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAvb21hcF92b3V0bGliLmMKQEAgLTUzLDcgKzUzLDcgQEAKIC8qIEdpdmVuIGEgbmV3IHJlbmRlciB3aW5kb3cgaW4gbmV3X3dpbiwgYWRqdXN0IHRoZSB3aW5kb3cgdG8gdGhlCiAgKiBuZWFyZXN0IHN1cHBvcnRlZCBjb25maWd1cmF0aW9uLiAgVGhlIGFkanVzdGVkIHdpbmRvdyBwYXJhbWV0ZXJzIGFyZQogICogcmV0dXJuZWQgaW4gbmV3X3dpbi4KLSAqIFJldHVybnMgemVybyBpZiBzdWNjZXNmdWwsIG9yIC1FSU5WQUwgaWYgdGhlIHJlcXVlc3RlZCB3aW5kb3cgaXMKKyAqIFJldHVybnMgemVybyBpZiBzdWNjZXNzZnVsLCBvciAtRUlOVkFMIGlmIHRoZSByZXF1ZXN0ZWQgd2luZG93IGlzCiAgKiBpbXBvc3NpYmxlIGFuZCBjYW5ub3QgcmVhc29uYWJseSBiZSBhZGp1c3RlZC4KICAqLwogaW50IG9tYXBfdm91dF90cnlfd2luZG93KHN0cnVjdCB2NGwyX2ZyYW1lYnVmZmVyICpmYnVmLApAQCAtMTAxLDcgKzEwMSw3IEBACiAgKiB3aWxsIGFsc28gYmUgYWRqdXN0ZWQgaWYgbmVjZXNzYXJ5LiAgUHJlZmVyZW5jZSBpcyBnaXZlbiB0byBrZWVwaW5nIHRoZQogICogdGhlIHdpbmRvdyBhcyBjbG9zZSB0byB0aGUgcmVxdWVzdGVkIGNvbmZpZ3VyYXRpb24gYXMgcG9zc2libGUuICBJZgogICogc3VjY2Vzc2Z1bCwgbmV3X3dpbiwgdm91dC0+d2luLCBhbmQgY3JvcCBhcmUgdXBkYXRlZC4KLSAqIFJldHVybnMgemVybyBpZiBzdWNjZXNmdWwsIG9yIC1FSU5WQUwgaWYgdGhlIHJlcXVlc3RlZCBwcmV2aWV3IHdpbmRvdyBpcworICogUmV0dXJucyB6ZXJvIGlmIHN1Y2Nlc3NmdWwsIG9yIC1FSU5WQUwgaWYgdGhlIHJlcXVlc3RlZCBwcmV2aWV3IHdpbmRvdyBpcwogICogaW1wb3NzaWJsZSBhbmQgY2Fubm90IHJlYXNvbmFibHkgYmUgYWRqdXN0ZWQuCiAgKi8KIGludCBvbWFwX3ZvdXRfbmV3X3dpbmRvdyhzdHJ1Y3QgdjRsMl9yZWN0ICpjcm9wLApAQCAtMTU1LDcgKzE1NSw3IEBACiAgKiB3aW5kb3cgd291bGQgZmFsbCBvdXRzaWRlIHRoZSBkaXNwbGF5IGJvdW5kYXJpZXMsIHRoZSBjcm9wcGluZyByZWN0YW5nbGUKICAqIHdpbGwgYWxzbyBiZSBhZGp1c3RlZCB0byBtYWludGFpbiB0aGUgcmVzY2FsaW5nIHJhdGlvcy4gIElmIHN1Y2Nlc3NmdWwsIGNyb3AKICAqIGFuZCB3aW4gYXJlIHVwZGF0ZWQuCi0gKiBSZXR1cm5zIHplcm8gaWYgc3VjY2VzZnVsLCBvciAtRUlOVkFMIGlmIHRoZSByZXF1ZXN0ZWQgY3JvcHBpbmcgcmVjdGFuZ2xlIGlzCisgKiBSZXR1cm5zIHplcm8gaWYgc3VjY2Vzc2Z1bCwgb3IgLUVJTlZBTCBpZiB0aGUgcmVxdWVzdGVkIGNyb3BwaW5nIHJlY3RhbmdsZSBpcwogICogaW1wb3NzaWJsZSBhbmQgY2Fubm90IHJlYXNvbmFibHkgYmUgYWRqdXN0ZWQuCiAgKi8KIGludCBvbWFwX3ZvdXRfbmV3X2Nyb3Aoc3RydWN0IHY0bDJfcGl4X2Zvcm1hdCAqcGl4LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwMV9jYW1lcmEuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDFfY2FtZXJhLmMKaW5kZXggZWFiMzFjYi4uNTk1NGI5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwMV9jYW1lcmEuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAxX2NhbWVyYS5jCkBAIC02ODcsNyArNjg3LDcgQEAKIAkJICogSW4gQ09OVElHIG1vZGUsIHRoZSBjdXJyZW50IGJ1ZmZlciBwYXJhbWV0ZXJzIGhhZCBhbHJlYWR5CiAJCSAqIGJlZW4gZW50ZXJlZCBpbnRvIHRoZSBETUEgcHJvZ3JhbW1pbmcgcmVnaXN0ZXIgc2V0IHdoaWxlIHRoZQogCQkgKiBidWZmZXIgd2FzIGZldGNoZWQgd2l0aCBwcmVwYXJlX25leHRfdmIoKSwgdGhleSBtYXkgaGF2ZSBhbHNvCi0JCSAqIGJlZW4gdHJhbnNmZXJlZCBpbnRvIHRoZSBydW50aW1lIHNldCBhbmQgYWxyZWFkeSBhY3RpdmUgaWYKKwkJICogYmVlbiB0cmFuc2ZlcnJlZCBpbnRvIHRoZSBydW50aW1lIHNldCBhbmQgYWxyZWFkeSBhY3RpdmUgaWYKIAkJICogdGhlIERNQSBzdGlsbCBydW5uaW5nLgogCQkgKi8KIAl9IGVsc2UgewpAQCAtODM1LDcgKzgzNSw3IEBACiAJCQkJLyoKIAkJCQkgKiBJZiBleGFjdGx5IDIgc2didWZzIGZyb20gdGhlIG5leHQgc2dsaXN0IGhhdmUKIAkJCQkgKiBiZWVuIHByb2dyYW1tZWQgaW50byB0aGUgRE1BIGVuZ2luZSAodGhlCi0JCQkJICogZnJpc3Qgb25lIGFscmVhZHkgdHJhbnNmZXJlZCBpbnRvIHRoZSBETUEKKwkJCQkgKiBmaXJzdCBvbmUgYWxyZWFkeSB0cmFuc2ZlcnJlZCBpbnRvIHRoZSBETUEKIAkJCQkgKiBydW50aW1lIHJlZ2lzdGVyIHNldCwgdGhlIHNlY29uZCBvbmUgc3RpbGwKIAkJCQkgKiBpbiB0aGUgcHJvZ3JhbW1pbmcgc2V0KSwgdGhlbiB3ZSBhcmUgaW4gc3luYy4KIAkJCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcC5jCmluZGV4IDFhOTk2M2JkLi41MDNiZDc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwLmMKQEAgLTcxNSw3ICs3MTUsNyBAQAogICogV2FsayB0aGUgZW50aXRpZXMgY2hhaW4gc3RhcnRpbmcgYXQgdGhlIHBpcGVsaW5lIG91dHB1dCB2aWRlbyBub2RlIGFuZCBzdGFydAogICogYWxsIG1vZHVsZXMgaW4gdGhlIGNoYWluIGluIHRoZSBnaXZlbiBtb2RlLgogICoKLSAqIFJldHVybiAwIGlmIHN1Y2Nlc3NmdWxsLCBvciB0aGUgcmV0dXJuIHZhbHVlIG9mIHRoZSBmYWlsZWQgdmlkZW86OnNfc3RyZWFtCisgKiBSZXR1cm4gMCBpZiBzdWNjZXNzZnVsLCBvciB0aGUgcmV0dXJuIHZhbHVlIG9mIHRoZSBmYWlsZWQgdmlkZW86OnNfc3RyZWFtCiAgKiBvcGVyYXRpb24gb3RoZXJ3aXNlLgogICovCiBzdGF0aWMgaW50IGlzcF9waXBlbGluZV9lbmFibGUoc3RydWN0IGlzcF9waXBlbGluZSAqcGlwZSwKQEAgLTg4Myw3ICs4ODMsNyBAQAogICogU2V0IHRoZSBwaXBlbGluZSB0byB0aGUgZ2l2ZW4gc3RyZWFtIHN0YXRlLiBQaXBlbGluZXMgY2FuIGJlIHN0YXJ0ZWQgaW4KICAqIHNpbmdsZS1zaG90IG9yIGNvbnRpbnVvdXMgbW9kZS4KICAqCi0gKiBSZXR1cm4gMCBpZiBzdWNjZXNzZnVsbCwgb3IgdGhlIHJldHVybiB2YWx1ZSBvZiB0aGUgZmFpbGVkIHZpZGVvOjpzX3N0cmVhbQorICogUmV0dXJuIDAgaWYgc3VjY2Vzc2Z1bCwgb3IgdGhlIHJldHVybiB2YWx1ZSBvZiB0aGUgZmFpbGVkIHZpZGVvOjpzX3N0cmVhbQogICogb3BlcmF0aW9uIG90aGVyd2lzZS4KICAqLwogaW50IG9tYXAzaXNwX3BpcGVsaW5lX3NldF9zdHJlYW0oc3RydWN0IGlzcF9waXBlbGluZSAqcGlwZSwKQEAgLTEyODMsNyArMTI4Myw3IEBACiAJCWNsayB8PSBJU1BDVFJMX1JTWl9DTEtfRU47CiAKIAkvKiBOT1RFOiBGb3IgQ0NEQyAmIFByZXZpZXcgc3VibW9kdWxlcywgd2UgbmVlZCB0byBhZmZlY3QgaW50ZXJuYWwKLQkgKiAgICAgICBSQU0gYXN3ZWxsLgorCSAqICAgICAgIFJBTSBhcyB3ZWxsLgogCSAqLwogCWlmIChpc3AtPnN1YmNsa19yZXNvdXJjZXMgJiBPTUFQM19JU1BfU1VCQ0xLX0NDREMpCiAJCWNsayB8PSBJU1BDVFJMX0NDRENfQ0xLX0VOIHwgSVNQQ1RSTF9DQ0RDX1JBTV9FTjsKQEAgLTE0MzEsNyArMTQzMSw3IEBACiAgKiBJbmNyZW1lbnQgdGhlIHJlZmVyZW5jZSBjb3VudCBvbiB0aGUgSVNQLiBJZiB0aGUgZmlyc3QgcmVmZXJlbmNlIGlzIHRha2VuLAogICogZW5hYmxlIGNsb2NrcyBhbmQgcG93ZXItdXAgYWxsIHN1Ym1vZHVsZXMuCiAgKgotICogUmV0dXJuIGEgcG9pbnRlciB0byB0aGUgSVNQIGRldmljZSBzdHJ1Y3R1cmUsIG9yIE5VTEwgaWYgYW4gZXJyb3Igb2NjdXJlZC4KKyAqIFJldHVybiBhIHBvaW50ZXIgdG8gdGhlIElTUCBkZXZpY2Ugc3RydWN0dXJlLCBvciBOVUxMIGlmIGFuIGVycm9yIG9jY3VycmVkLgogICovCiBzdHJ1Y3QgaXNwX2RldmljZSAqb21hcDNpc3BfZ2V0KHN0cnVjdCBpc3BfZGV2aWNlICppc3ApCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNjZGMuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwY2NkYy5oCmluZGV4IGQ0MDNhZjUuLjQ4M2ExOWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwY2NkYy5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwY2NkYy5oCkBAIC0xNTAsNyArMTUwLDcgQEAKICAqIEBpbnB1dDogQWN0aXZlIGlucHV0CiAgKiBAb3V0cHV0OiBBY3RpdmUgb3V0cHV0cwogICogQHZpZGVvX291dDogT3V0cHV0IHZpZGVvIG5vZGUKLSAqIEBlcnJvcjogQSBoYXJkd2FyZSBlcnJvciBvY2N1cmVkIGR1cmluZyBjYXB0dXJlCisgKiBAZXJyb3I6IEEgaGFyZHdhcmUgZXJyb3Igb2NjdXJyZWQgZHVyaW5nIGNhcHR1cmUKICAqIEBhbGF3OiBBLWxhdyBjb21wcmVzc2lvbiBlbmFibGVkICgxKSBvciBkaXNhYmxlZCAoMCkKICAqIEBscGY6IExvdyBwYXNzIGZpbHRlciBlbmFibGVkICgxKSBvciBkaXNhYmxlZCAoMCkKICAqIEBvYmNsYW1wOiBPcHRpY2FsLWJsYWNrIGNsYW1wIGVuYWJsZWQgKDEpIG9yIGRpc2FibGVkICgwKQpAQCAtMTYzLDcgKzE2Myw3IEBACiAgKiBAc2hhZG93X3VwZGF0ZTogQ29udHJvbHMgdXBkYXRlIGluIHByb2dyZXNzIGJ5IHVzZXJzcGFjZQogICogQHN5bmNpZjogSW50ZXJmYWNlIHN5bmNocm9uaXphdGlvbiBjb25maWd1cmF0aW9uCiAgKiBAdnBjZmc6IFZpZGVvIHBvcnQgY29uZmlndXJhdGlvbgotICogQHVuZGVycnVuOiBBIGJ1ZmZlciB1bmRlcnJ1biBvY2N1cmVkIGFuZCBhIG5ldyBidWZmZXIgaGFzIGJlZW4gcXVldWVkCisgKiBAdW5kZXJydW46IEEgYnVmZmVyIHVuZGVycnVuIG9jY3VycmVkIGFuZCBhIG5ldyBidWZmZXIgaGFzIGJlZW4gcXVldWVkCiAgKiBAc3RhdGU6IFN0cmVhbWluZyBzdGF0ZQogICogQGxvY2s6IFNlcmlhbGl6ZXMgc2hhZG93X3VwZGF0ZSB3aXRoIGludGVycnVwdCBoYW5kbGVyCiAgKiBAd2FpdDogV2FpdCBxdWV1ZSB1c2VkIHRvIHN0b3AgdGhlIG1vZHVsZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3BjY3AyLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNjcDIuYwppbmRleCAwZWZlZjJlLi4wZTE2Y2FiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNjcDIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNjcDIuYwpAQCAtNzcyLDcgKzc3Miw3IEBACiAgKiBAc2QgICAgOiBwb2ludGVyIHRvIHY0bDIgc3ViZGV2IHN0cnVjdHVyZQogICogQGZoICAgIDogVjRMMiBzdWJkZXYgZmlsZSBoYW5kbGUKICAqIEBmbXQgICA6IHBvaW50ZXIgdG8gdjRsMiBzdWJkZXYgZm9ybWF0IHN0cnVjdHVyZQotICogcmV0dXJuIC1FSU5WQUwgb3IgemVybyBvbiBzdWNlc3MKKyAqIHJldHVybiAtRUlOVkFMIG9yIHplcm8gb24gc3VjY2VzcwogICovCiBzdGF0aWMgaW50IGNjcDJfZ2V0X2Zvcm1hdChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBzdHJ1Y3QgdjRsMl9zdWJkZXZfZmggKmZoLAogCQkJICAgICAgc3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm10KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3Bjc2kyLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNzaTIuYwppbmRleCBmYjUwM2YzLi42OTE2MWE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNzaTIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcGNzaTIuYwpAQCAtOTY5LDcgKzk2OSw3IEBACiAgKiBAc2QgOiBwb2ludGVyIHRvIHY0bDIgc3ViZGV2IHN0cnVjdHVyZQogICogQGZoIDogVjRMMiBzdWJkZXYgZmlsZSBoYW5kbGUKICAqIEBmbXQ6IHBvaW50ZXIgdG8gdjRsMiBzdWJkZXYgZm9ybWF0IHN0cnVjdHVyZQotICogcmV0dXJuIC1FSU5WQUwgb3IgemVybyBvbiBzdWNlc3MKKyAqIHJldHVybiAtRUlOVkFMIG9yIHplcm8gb24gc3VjY2VzcwogICovCiBzdGF0aWMgaW50IGNzaTJfZ2V0X2Zvcm1hdChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBzdHJ1Y3QgdjRsMl9zdWJkZXZfZmggKmZoLAogCQkJICAgc3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm10KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3BwcmV2aWV3LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcHByZXZpZXcuYwppbmRleCBiYWY5Mzc0Li4yYjE2OTg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcHByZXZpZXcuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcHByZXZpZXcuYwpAQCAtMzQsNyArMzQsNyBAQAogI2luY2x1ZGUgImlzcHJlZy5oIgogI2luY2x1ZGUgImlzcHByZXZpZXcuaCIKIAotLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsb3VyZXNjZW50IExpZ2h0IGZvciBSR0J0b1JHQiBCbGVuZGluZyAqLworLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsdW9yZXNjZW50IExpZ2h0IGZvciBSR0J0b1JHQiBCbGVuZGluZyAqLwogc3RhdGljIHN0cnVjdCBvbWFwM2lzcF9wcmV2X3JnYnRvcmdiIGZscl9yZ2IycmdiID0gewogCXsJLyogUkdCLVJHQiBNYXRyaXggKi8KIAkJezB4MDFFMiwgMHgwRjMwLCAweDBGRUV9LApAQCAtNDQsNyArNDQsNyBAQAogCXsweDAwMDAsIDB4MDAwMCwgMHgwMDAwfQogfTsKIAotLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsb3VyZXNjZW50IExpZ2h0IGZvciBSR0IgdG8gWVVWIENvbnZlcnNpb24qLworLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsdW9yZXNjZW50IExpZ2h0IGZvciBSR0IgdG8gWVVWIENvbnZlcnNpb24qLwogc3RhdGljIHN0cnVjdCBvbWFwM2lzcF9wcmV2X2NzYyBmbHJfcHJldl9jc2MgPSB7CiAJewkvKiBDU0MgQ29lZiBNYXRyaXggKi8KIAkJezY2LCAxMjksIDI1fSwKQEAgLTU0LDIyICs1NCwyMiBAQAogCXsweDAsIDB4MCwgMHgwfQogfTsKIAotLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsb3VyZXNjZW50IExpZ2h0IGZvciBDRkEgR3JhZGllbnQqLworLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsdW9yZXNjZW50IExpZ2h0IGZvciBDRkEgR3JhZGllbnQqLwogI2RlZmluZSBGTFJfQ0ZBX0dSQURUSFJTX0hPUloJMHgyOAogI2RlZmluZSBGTFJfQ0ZBX0dSQURUSFJTX1ZFUlQJMHgyOAogCi0vKiBEZWZhdWx0IHZhbHVlcyBpbiBPZmZpY2UgRmxvdXJlc2NlbnQgTGlnaHQgZm9yIENocm9tYSBTdXBwcmVzc2lvbiovCisvKiBEZWZhdWx0IHZhbHVlcyBpbiBPZmZpY2UgRmx1b3Jlc2NlbnQgTGlnaHQgZm9yIENocm9tYSBTdXBwcmVzc2lvbiovCiAjZGVmaW5lIEZMUl9DU1VQX0dBSU4JCTB4MEQKICNkZWZpbmUgRkxSX0NTVVBfVEhSRVMJCTB4RUIKIAotLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsb3VyZXNjZW50IExpZ2h0IGZvciBOb2lzZSBGaWx0ZXIqLworLyogRGVmYXVsdCB2YWx1ZXMgaW4gT2ZmaWNlIEZsdW9yZXNjZW50IExpZ2h0IGZvciBOb2lzZSBGaWx0ZXIqLwogI2RlZmluZSBGTFJfTkZfU1RSR1RICQkweDAzCiAKIC8qIERlZmF1bHQgdmFsdWVzIGZvciBXaGl0ZSBCYWxhbmNlICovCiAjZGVmaW5lIEZMUl9XQkFMX0RHQUlOCQkweDEwMAogI2RlZmluZSBGTFJfV0JBTF9DT0VGCQkweDIwCiAKLS8qIERlZmF1bHQgdmFsdWVzIGluIE9mZmljZSBGbG91cmVzY2VudCBMaWdodCBmb3IgQmxhY2sgQWRqdXN0bWVudCovCisvKiBEZWZhdWx0IHZhbHVlcyBpbiBPZmZpY2UgRmx1b3Jlc2NlbnQgTGlnaHQgZm9yIEJsYWNrIEFkanVzdG1lbnQqLwogI2RlZmluZSBGTFJfQkxLQURKX0JMVUUJCTB4MAogI2RlZmluZSBGTFJfQkxLQURKX0dSRUVOCTB4MAogI2RlZmluZSBGTFJfQkxLQURKX1JFRAkJMHgwCkBAIC0xMzcsNyArMTM3LDcgQEAKICAqIEBlbmFibGU6IDEgLSBFbmFibGUsIDAgLSBEaXNhYmxlCiAgKgogICogTk9URTogUFJWX1dTRFJfQUREUiBhbmQgUFJWX1dBRERfT0ZGU0VUIG11c3QgYmUgc2V0IGFsc28KLSAqIFRoZSBwcm9jY2VzcyBpcyBhcHBsaWVkIGZvciBlYWNoIGNhcHR1cmVkIGZyYW1lLgorICogVGhlIHByb2Nlc3MgaXMgYXBwbGllZCBmb3IgZWFjaCBjYXB0dXJlZCBmcmFtZS4KICAqLwogc3RhdGljIHZvaWQKIHByZXZpZXdfZW5hYmxlX2Rya2ZyYW1lX2NhcHR1cmUoc3RydWN0IGlzcF9wcmV2X2RldmljZSAqcHJldiwgdTggZW5hYmxlKQpAQCAtMTU3LDcgKzE1Nyw3IEBACiAgKiBAZW5hYmxlOiAxIC0gQWNxdWlyZXMgbWVtb3J5IGJhbmR3aWR0aCBzaW5jZSB0aGUgcGl4ZWxzIGluIGVhY2ggZnJhbWUgaXMKICAqICAgICAgICAgIHN1YnRyYWN0ZWQgd2l0aCB0aGUgcGl4ZWxzIGluIHRoZSBjdXJyZW50IGZyYW1lLgogICoKLSAqIFRoZSBwcm9jY2VzcyBpcyBhcHBsaWVkIGZvciBlYWNoIGNhcHR1cmVkIGZyYW1lLgorICogVGhlIHByb2Nlc3MgaXMgYXBwbGllZCBmb3IgZWFjaCBjYXB0dXJlZCBmcmFtZS4KICAqLwogc3RhdGljIHZvaWQKIHByZXZpZXdfZW5hYmxlX2Rya2ZyYW1lKHN0cnVjdCBpc3BfcHJldl9kZXZpY2UgKnByZXYsIHU4IGVuYWJsZSkKQEAgLTE1MjgsNyArMTUyOCw3IEBACiAgKiBwcmV2aWV3X3NldF9zdHJlYW0gLSBFbmFibGUvRGlzYWJsZSBzdHJlYW1pbmcgb24gcHJldmlldyBzdWJkZXYKICAqIEBzZCAgICA6IHBvaW50ZXIgdG8gdjRsMiBzdWJkZXYgc3RydWN0dXJlCiAgKiBAZW5hYmxlOiAxID09IEVuYWJsZSwgMCA9PSBEaXNhYmxlCi0gKiByZXR1cm4gLUVJTlZBTCBvciB6ZXJvIG9uIHN1Y2VzcworICogcmV0dXJuIC1FSU5WQUwgb3IgemVybyBvbiBzdWNjZXNzCiAgKi8KIHN0YXRpYyBpbnQgcHJldmlld19zZXRfc3RyZWFtKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsIGludCBlbmFibGUpCiB7CkBAIC0xNzgwLDcgKzE3ODAsNyBAQAogICogQHNkIDogcG9pbnRlciB0byB2NGwyIHN1YmRldiBzdHJ1Y3R1cmUKICAqIEBmaCA6IFY0TDIgc3ViZGV2IGZpbGUgaGFuZGxlCiAgKiBAZm10OiBwb2ludGVyIHRvIHY0bDIgc3ViZGV2IGZvcm1hdCBzdHJ1Y3R1cmUKLSAqIHJldHVybiAtRUlOVkFMIG9yIHplcm8gb24gc3VjZXNzCisgKiByZXR1cm4gLUVJTlZBTCBvciB6ZXJvIG9uIHN1Y2Nlc3MKICAqLwogc3RhdGljIGludCBwcmV2aWV3X2dldF9mb3JtYXQoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgc3RydWN0IHY0bDJfc3ViZGV2X2ZoICpmaCwKIAkJCSAgICAgIHN0cnVjdCB2NGwyX3N1YmRldl9mb3JtYXQgKmZtdCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwcHJldmlldy5oIGIvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3BwcmV2aWV3LmgKaW5kZXggZjJkNjNjYS4uZmE5NDNiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3BwcmV2aWV3LmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3BwcmV2aWV3LmgKQEAgLTE2Myw3ICsxNjMsNyBAQAogICogQG91dHB1dDogQml0bWFzayBvZiB0aGUgYWN0aXZlIG91dHB1dAogICogQHZpZGVvX2luOiBJbnB1dCB2aWRlbyBlbnRpdHkKICAqIEB2aWRlb19vdXQ6IE91dHB1dCB2aWRlbyBlbnRpdHkKLSAqIEBlcnJvcjogQSBoYXJkd2FyZSBlcnJvciBvY2N1cmVkIGR1cmluZyBjYXB0dXJlCisgKiBAZXJyb3I6IEEgaGFyZHdhcmUgZXJyb3Igb2NjdXJyZWQgZHVyaW5nIGNhcHR1cmUKICAqIEBwYXJhbXM6IE1vZHVsZSBjb25maWd1cmF0aW9uIGRhdGEKICAqIEBzaGFkb3dfdXBkYXRlOiBJZiBzZXQsIHVwZGF0ZSB0aGUgaGFyZHdhcmUgY29uZmlndXJlZCBpbiB0aGUgbmV4dCBpbnRlcnJ1cHQKICAqIEB1bmRlcnJ1bjogV2hldGhlciB0aGUgcHJldmlldyBlbnRpdHkgaGFzIHF1ZXVlZCBidWZmZXJzIG9uIHRoZSBvdXRwdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwcXVldWUuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwcXVldWUuaAppbmRleCAyNTFkZTNlLi45MmM1YTEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcHF1ZXVlLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3BxdWV1ZS5oCkBAIC00Niw5ICs0Niw5IEBACiAgKglkZXZpY2UgeWV0LgogICogQElTUF9CVUZfU1RBVEVfQUNUSVZFOiBUaGUgYnVmZmVyIGlzIGluIHVzZSBmb3IgYW4gYWN0aXZlIHZpZGVvIHRyYW5zZmVyLgogICogQElTUF9CVUZfU1RBVEVfRVJST1I6IFRoZSBkZXZpY2UgaXMgZG9uZSB3aXRoIHRoZSBidWZmZXIgYW5kIGFuIGVycm9yCi0gKglvY2N1cmVkLiBGb3IgY2FwdHVyZSBkZXZpY2UgdGhlIGJ1ZmZlciBsaWtlbHkgY29udGFpbnMgY29ycnVwdGVkIGRhdGEgb3IKKyAqCW9jY3VycmVkLiBGb3IgY2FwdHVyZSBkZXZpY2UgdGhlIGJ1ZmZlciBsaWtlbHkgY29udGFpbnMgY29ycnVwdGVkIGRhdGEgb3IKICAqCW5vIGRhdGEgYXQgYWxsLgotICogQElTUF9CVUZfU1RBVEVfRE9ORTogVGhlIGRldmljZSBpcyBkb25lIHdpdGggdGhlIGJ1ZmZlciBhbmQgbm8gZXJyb3Igb2NjdXJlZC4KKyAqIEBJU1BfQlVGX1NUQVRFX0RPTkU6IFRoZSBkZXZpY2UgaXMgZG9uZSB3aXRoIHRoZSBidWZmZXIgYW5kIG5vIGVycm9yIG9jY3VycmVkLgogICoJRm9yIGNhcHR1cmUgZGV2aWNlcyB0aGUgYnVmZmVyIGNvbnRhaW5zIHZhbGlkIGRhdGEuCiAgKi8KIGVudW0gaXNwX3ZpZGVvX2J1ZmZlcl9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcHJlc2l6ZXIuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwcmVzaXplci5jCmluZGV4IDc1ZDM5YjEuLjY1M2Y4OGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwcmVzaXplci5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwcmVzaXplci5jCkBAIC03NTEsNyArNzUxLDcgQEAKICAqIHJhdGlvIHdpbGwgdGh1cyByZXN1bHQgaW4gYSByZXNpemluZyBmYWN0b3Igc2xpZ2h0bHkgbGFyZ2VyIHRoYW4gdGhlCiAgKiByZXF1ZXN0ZWQgdmFsdWUuCiAgKgotICogVG8gYWNjb21vZGF0ZSB0aGF0LCBhbmQgbWFrZSBzdXJlIHRoZSBUUk0gZXF1YXRpb25zIGFyZSBzYXRpc2ZpZWQgZXhhY3RseSwgd2UKKyAqIFRvIGFjY29tbW9kYXRlIHRoYXQsIGFuZCBtYWtlIHN1cmUgdGhlIFRSTSBlcXVhdGlvbnMgYXJlIHNhdGlzZmllZCBleGFjdGx5LCB3ZQogICogY29tcHV0ZSB0aGUgaW5wdXQgY3JvcCByZWN0YW5nbGUgYXMgdGhlIGxhc3Qgc3RlcC4KICAqCiAgKiBBcyBpZiB0aGUgc2l0dWF0aW9uIHdhc24ndCBjb21wbGV4IGVub3VnaCwgdGhlIG1heGltdW0gb3V0cHV0IHdpZHRoIGRlcGVuZHMKQEAgLTEzODYsNyArMTM4Niw3IEBACiAgKiBAc2QgICAgOiBwb2ludGVyIHRvIHY0bDIgc3ViZGV2IHN0cnVjdHVyZQogICogQGZoICAgIDogVjRMMiBzdWJkZXYgZmlsZSBoYW5kbGUKICAqIEBmbXQgICA6IHBvaW50ZXIgdG8gdjRsMiBzdWJkZXYgZm9ybWF0IHN0cnVjdHVyZQotICogcmV0dXJuIC1FSU5WQUwgb3IgemVybyBvbiBzdWNlc3MKKyAqIHJldHVybiAtRUlOVkFMIG9yIHplcm8gb24gc3VjY2VzcwogICovCiBzdGF0aWMgaW50IHJlc2l6ZXJfZ2V0X2Zvcm1hdChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBzdHJ1Y3QgdjRsMl9zdWJkZXZfZmggKmZoLAogCQkJICAgICAgc3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm10KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3B2aWRlby5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9vbWFwM2lzcC9pc3B2aWRlby5jCmluZGV4IGEwYmI1ZGIuLjIwOGE3ZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb21hcDNpc3AvaXNwdmlkZW8uYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL29tYXAzaXNwL2lzcHZpZGVvLmMKQEAgLTQ5NCwxMiArNDk0LDEyIEBACiAvKgogICogb21hcDNpc3BfdmlkZW9fYnVmZmVyX25leHQgLSBDb21wbGV0ZSB0aGUgY3VycmVudCBidWZmZXIgYW5kIHJldHVybiB0aGUgbmV4dAogICogQHZpZGVvOiBJU1AgdmlkZW8gb2JqZWN0Ci0gKiBAZXJyb3I6IFdoZXRoZXIgYW4gZXJyb3Igb2NjdXJlZCBkdXJpbmcgY2FwdHVyZQorICogQGVycm9yOiBXaGV0aGVyIGFuIGVycm9yIG9jY3VycmVkIGR1cmluZyBjYXB0dXJlCiAgKgogICogUmVtb3ZlIHRoZSBjdXJyZW50IHZpZGVvIGJ1ZmZlciBmcm9tIHRoZSBETUEgcXVldWUgYW5kIGZpbGwgaXRzIHRpbWVzdGFtcCwKICAqIGZpZWxkIGNvdW50IGFuZCBzdGF0ZSBmaWVsZHMgYmVmb3JlIHdha2luZyB1cCBpdHMgY29tcGxldGlvbiBoYW5kbGVyLgogICoKLSAqIFRoZSBidWZmZXIgc3RhdGUgaXMgc2V0IHRvIFZJREVPQlVGX0RPTkUgaWYgbm8gZXJyb3Igb2NjdXJlZCAoQGVycm9yIGlzIDApCisgKiBUaGUgYnVmZmVyIHN0YXRlIGlzIHNldCB0byBWSURFT0JVRl9ET05FIGlmIG5vIGVycm9yIG9jY3VycmVkIChAZXJyb3IgaXMgMCkKICAqIG9yIFZJREVPQlVGX0VSUk9SIG90aGVyd2lzZSAoQGVycm9yIGlzIG5vbi16ZXJvKS4KICAqCiAgKiBUaGUgRE1BIHF1ZXVlIGlzIGV4cGVjdGVkIHRvIGNvbnRhaW4gYXQgbGVhc3Qgb25lIGJ1ZmZlci4KQEAgLTU3OCw3ICs1NzgsNyBAQAogLyoKICAqIG9tYXAzaXNwX3ZpZGVvX3Jlc3VtZSAtIFBlcmZvcm0gcmVzdW1lIG9wZXJhdGlvbiBvbiB0aGUgYnVmZmVycwogICogQHZpZGVvOiBJU1AgdmlkZW8gb2JqZWN0Ci0gKiBAY29udGludW91czogUGlwZWxpbmUgaXMgaW4gc2luZ2xlIHNob3QgbW9kZSBpZiAwIG9yIGNvbnRpbm91cyBtb2RlIG90aGVyd2lzZQorICogQGNvbnRpbnVvdXM6IFBpcGVsaW5lIGlzIGluIHNpbmdsZSBzaG90IG1vZGUgaWYgMCBvciBjb250aW51b3VzIG1vZGUgb3RoZXJ3aXNlCiAgKgogICogVGhpcyBmdW5jdGlvbiBpcyBpbnRlbmRlZCB0byBiZSB1c2VkIG9uIHN1c3BlbmQvcmVzdW1lIHNjZW5hcmlvLiBJdAogICogcmVxdWVzdHMgdmlkZW8gcXVldWUgbGF5ZXIgdG8gZGlzY2FyZCBidWZmZXJzIG1hcmtlZCBhcyBET05FIGlmIGl0J3MgaW4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb3Y2NjUwLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL292NjY1MC5jCmluZGV4IGZlOGUzZWIuLjQ1NmQ5YWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vb3Y2NjUwLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9vdjY2NTAuYwpAQCAtMTAzOCw3ICsxMDM4LDcgQEAKIAlyZXQgPSBvdjY2NTBfcmVnX3JtdyhjbGllbnQsIFJFR19DT01BLCBDT01BX1JFU0VULCAwKTsKIAlpZiAocmV0KQogCQlkZXZfZXJyKCZjbGllbnQtPmRldiwKLQkJCSJBbiBlcnJvciBvY2N1cmVkIHdoaWxlIGVudGVyaW5nIHNvZnQgcmVzZXQhXG4iKTsKKwkJCSJBbiBlcnJvciBvY2N1cnJlZCB3aGlsZSBlbnRlcmluZyBzb2Z0IHJlc2V0IVxuIik7CiAKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9vdjk2NDAuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb3Y5NjQwLmMKaW5kZXggNTNkODhhMi4uNTE3M2FjNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9vdjk2NDAuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL292OTY0MC5jCkBAIC0yNzMsNyArMjczLDcgQEAKIAlyZXQgPSBvdjk2NDBfcmVnX3dyaXRlKGNsaWVudCwgT1Y5NjQwX0NPTTcsIE9WOTY0MF9DT003X1NDQ0JfUkVTRVQpOwogCWlmIChyZXQpCiAJCWRldl9lcnIoJmNsaWVudC0+ZGV2LAotCQkJIkFuIGVycm9yIG9jY3VyZWQgd2hpbGUgZW50ZXJpbmcgc29mdCByZXNldCFcbiIpOworCQkJIkFuIGVycm9yIG9jY3VycmVkIHdoaWxlIGVudGVyaW5nIHNvZnQgcmVzZXQhXG4iKTsKIAogCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3B2cnVzYjIvcHZydXNiMi1lZXByb20uYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWVlcHJvbS5jCmluZGV4IGFlZWQxYzIuLjk1MTVmM2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWVlcHJvbS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWVlcHJvbS5jCkBAIC0zMiw3ICszMiw3IEBACiAKICAgIFJlYWQgYW5kIGFuYWx5emUgZGF0YSBpbiB0aGUgZWVwcm9tLiAgVXNlIHR2ZWVwcm9tIHRvIGZpZ3VyZSBvdXQKICAgIHRoZSBwYWNrZXQgc3RydWN0dXJlLCBzaW5jZSB0aGlzIGlzIGFub3RoZXIgSGF1cHBhdWdlIGRldmljZSBhbmQKLSAgIGludGVybmFsbHkgaXQgaGFzIGEgZmFtaWx5IHJlc2VtYmxlbmNlIHRvIGl2dHYtdHlwZSBkZXZpY2VzCisgICBpbnRlcm5hbGx5IGl0IGhhcyBhIGZhbWlseSByZXNlbWJsYW5jZSB0byBpdnR2LXR5cGUgZGV2aWNlcwogCiAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3B2cnVzYjIvcHZydXNiMi1oZHcuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWhkdy5oCmluZGV4IDUxZDMwMDkuLmQ3NzUzYWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWhkdy5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWhkdy5oCkBAIC03NSw3ICs3NSw3IEBACiAgKiAgKGJ1dCBpdCBtaWdodCBzdGlsbCBvbiB0aGUgYnVzKS4gIEluIHRoaXMgc3RhdGUgdGhlcmUncyBub3RoaW5nIHdlIGNhbgogICogIGRvOyBpdCBtdXN0IGJlIHJlcGx1Z2dlZCBpbiBvcmRlciB0byByZWNvdmVyLgogICoKLSAqICBDT0xEIC0gRGV2aWNlIGlzIGluIGFuIHVudXN1YWJsZSBzdGF0ZSwgbmVlZHMgbWljcm9jb250cm9sbGVyIGZpcm13YXJlLgorICogIENPTEQgLSBEZXZpY2UgaXMgaW4gYW4gdW51c2FibGUgc3RhdGUsIG5lZWRzIG1pY3JvY29udHJvbGxlciBmaXJtd2FyZS4KICAqCiAgKiAgV0FSTSAtIFdlIGNhbiBjb21tdW5pY2F0ZSB3aXRoIHRoZSBkZXZpY2UgYW5kIHRoZSBwcm9wZXIKICAqICBtaWNyb2NvbnRyb2xsZXIgZmlybXdhcmUgaXMgcnVubmluZywgYnV0IG90aGVyIGRldmljZSBpbml0aWFsaXphdGlvbiBpcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9weGFfY2FtZXJhLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3B4YV9jYW1lcmEuYwppbmRleCAwMjY4Njc3Li5jMWVlMDlhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3B4YV9jYW1lcmEuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3B4YV9jYW1lcmEuYwpAQCAtNzE0LDcgKzcxNCw3IEBACiAgKgogICogVGhlIERNQSBjaGFpbmluZyBpcyBkb25lIHdpdGggRE1BIHJ1bm5pbmcuIFRoaXMgbWVhbnMgYSB0aW55IHRlbXBvcmFsIHdpbmRvdwogICogcmVtYWlucywgd2hlcmUgYSBidWZmZXIgaXMgcXVldWVkIG9uIHRoZSBjaGFpbiwgd2hpbGUgdGhlIGNoYWluIGlzIGFscmVhZHkKLSAqIHN0b3BwZWQuIFRoaXMgbWVhbnMgdGhlIHRhaWxlZCBidWZmZXIgd291bGQgbmV2ZXIgYmUgdHJhbnNmZXJlZCBieSBETUEuCisgKiBzdG9wcGVkLiBUaGlzIG1lYW5zIHRoZSB0YWlsZWQgYnVmZmVyIHdvdWxkIG5ldmVyIGJlIHRyYW5zZmVycmVkIGJ5IERNQS4KICAqIFRoaXMgZnVuY3Rpb24gcmVzdGFydHMgdGhlIGNhcHR1cmUgZm9yIHRoaXMgY29ybmVyIGNhc2UsIHdoZXJlIDoKICAqICAtIERBRFIoKSA9PSBEQUREUl9TVE9QCiAgKiAgLSBhIHZpZGVvYnVmZmVyIGlzIHF1ZXVlZCBvbiB0aGUgcGNkZXYtPmNhcHR1cmUgbGlzdApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9zNXAtZmltYy9maW1jLXJlZy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9zNXAtZmltYy9maW1jLXJlZy5jCmluZGV4IDRkOTI5YTMuLjQ4OTNiMmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vczVwLWZpbWMvZmltYy1yZWcuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3M1cC1maW1jL2ZpbWMtcmVnLmMKQEAgLTM1Niw3ICszNTYsNyBAQAogCQkvKiBvbmUgc2hvdCBtb2RlICovCiAJCWNmZyB8PSBTNVBfQ0lJTUdDUFRfQ1BUX0ZSRU5fRU5BQkxFIHwgUzVQX0NJSU1HQ1BUX0lNR0NQVEVOOwogCX0gZWxzZSB7Ci0JCS8qIENvbnRpbm91cyBmcmFtZSBjYXB0dXJlIG1vZGUgKGZyZWVydW4pLiAqLworCQkvKiBDb250aW51b3VzIGZyYW1lIGNhcHR1cmUgbW9kZSAoZnJlZXJ1bikuICovCiAJCWNmZyAmPSB+KFM1UF9DSUlNR0NQVF9DUFRfRlJFTl9FTkFCTEUgfAogCQkJIFM1UF9DSUlNR0NQVF9DUFRfRlJNT0RfQ05UKTsKIAkJY2ZnIHw9IFM1UF9DSUlNR0NQVF9JTUdDUFRFTjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzEzNC9zYWE3MTM0LWNhcmRzLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMzQvc2FhNzEzNC1jYXJkcy5jCmluZGV4IDYxYzYwMDcuLjUwZjFiZTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzEzNC9zYWE3MTM0LWNhcmRzLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTM0L3NhYTcxMzQtY2FyZHMuYwpAQCAtNzQ2MCw3ICs3NDYwLDcgQEAKIAkJCQlkZXYtPnR1bmVyX3R5cGUgPSBUVU5FUl9QSElMSVBTX0ZNMTIxNk1FX01LMzsKIAkJCQlicmVhazsKIAkJCWRlZmF1bHQ6Ci0JCQkJcHJpbnRrKEtFUk5fRVJSICIlcyBDYW50IGRldGVybWluZSB0dW5lciB0eXBlICV4IGZyb20gRUVQUk9NXG4iLCBkZXYtPm5hbWUsIHR1bmVyX3QpOworCQkJCXByaW50ayhLRVJOX0VSUiAiJXMgQ2FuJ3QgZGV0ZXJtaW5lIHR1bmVyIHR5cGUgJXggZnJvbSBFRVBST01cbiIsIGRldi0+bmFtZSwgdHVuZXJfdCk7CiAJCQl9CiAJCX0gZWxzZSBpZiAoKGRhdGFbMV0gIT0gMCkgJiYgKGRhdGFbMV0gIT0gMHhmZikpIHsKIAkJCS8qIG5ldyBjb25maWcgc3RydWN0dXJlICovCkBAIC03NDgwLDcgKzc0ODAsNyBAQAogCQkJCQlwcmludGsoS0VSTl9JTkZPICIlcyBCb2FyZCBoYXMgRFZCLVRcbiIsIGRldi0+bmFtZSk7CiAJCQkJYnJlYWs7CiAJCQlkZWZhdWx0OgotCQkJCXByaW50ayhLRVJOX0VSUiAiJXMgQ2FudCBkZXRlcm1pbmUgdHVuZXIgdHlwZSAleCBmcm9tIEVFUFJPTVxuIiwgZGV2LT5uYW1lLCB0dW5lcl90KTsKKwkJCQlwcmludGsoS0VSTl9FUlIgIiVzIENhbid0IGRldGVybWluZSB0dW5lciB0eXBlICV4IGZyb20gRUVQUk9NXG4iLCBkZXYtPm5hbWUsIHR1bmVyX3QpOwogCQkJfQogCQl9IGVsc2UgewogCQkJcHJpbnRrKEtFUk5fRVJSICIlcyB1bmV4cGVjdGVkIGNvbmZpZyBzdHJ1Y3R1cmVcbiIsIGRldi0+bmFtZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxNjQvc2FhNzE2NC1jbWQuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LWNtZC5jCmluZGV4IDZhNGMyMTcuLjYyZmFjN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LWNtZC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LWNtZC5jCkBAIC0yNTcsNyArMjU3LDcgQEAKIH0KIAogLyogV2FpdCBmb3IgYSBzaWduYWwgZXZlbnQsIHdpdGhvdXQgaG9sZGluZyBhIG11dGV4LiBFaXRoZXIgcmV0dXJuIFRJTUVPVVQgaWYKLSAqIHRoZSBldmVudCBuZXZlciBvY2N1cmVkLCBvciBTQUFfT0sgaWYgaXQgd2FzIHNpZ25hbGVkIGR1cmluZyB0aGUgd2FpdC4KKyAqIHRoZSBldmVudCBuZXZlciBvY2N1cnJlZCwgb3IgU0FBX09LIGlmIGl0IHdhcyBzaWduYWxlZCBkdXJpbmcgdGhlIHdhaXQuCiAgKi8KIGludCBzYWE3MTY0X2NtZF93YWl0KHN0cnVjdCBzYWE3MTY0X2RldiAqZGV2LCB1OCBzZXFubykKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LWZ3LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxNjQvc2FhNzE2NC1mdy5jCmluZGV4IGIzNjkzMDAuLmEyNjZiZjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LWZ3LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTY0L3NhYTcxNjQtZncuYwpAQCAtNDQ0LDcgKzQ0NCw3IEBACiAJCXByaW50ayhLRVJOX0lORk8gIiAuUmVzZXJ2ZWQgPSAweCV4XG4iLCBoZHItPnJlc2VydmVkKTsKIAkJcHJpbnRrKEtFUk5fSU5GTyAiIC5WZXJzaW9uID0gMHgleFxuIiwgaGRyLT52ZXJzaW9uKTsKIAotCQkvKiBSZXRyZWl2ZSBib290bG9hZGVyIGlmIHJlcWQgKi8KKwkJLyogUmV0cmlldmUgYm9vdGxvYWRlciBpZiByZXFkICovCiAJCWlmICgoaGRyLT5maXJtd2FyZXNpemUgPT0gMCkgJiYgKGhkci0+YnNsc2l6ZSA9PSAwKSkKIAkJCS8qIFNlY29uZCBib290bG9hZGVyIGluIHRoZSBmaXJtd2FyZSBmaWxlICovCiAJCQlmaWxlc2l6ZSA9IGhkci0+cmVzZXJ2ZWQgKiAxNjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LXR5cGVzLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxNjQvc2FhNzE2NC10eXBlcy5oCmluZGV4IGRmMWQyOTkuLjFkMjE0MGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzE2NC9zYWE3MTY0LXR5cGVzLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTY0L3NhYTcxNjQtdHlwZXMuaApAQCAtNDEyLDcgKzQxMiw3IEBACiAJdTgJU3RhcnRMaW5lOyAvKiBOVFNDIFN0YXJ0ID0gMTAgKi8KIAl1OAlFbmRMaW5lOyAvKiBOVFNDID0gMjEgKi8KIAl1OAlGaWVsZFJhdGU7IC8qIDYwIGZvciBOVFNDICovCi0JdTgJYk51bUxpbmVzOyAvKiBVbnNlZCAtIHNjaGVkdWxlZCBmb3IgcmVtb3ZhbCAqLworCXU4CWJOdW1MaW5lczsgLyogVW51c2VkIC0gc2NoZWR1bGVkIGZvciByZW1vdmFsICovCiB9IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpOwogCiBzdHJ1Y3QgdG1Db21SZXNQcm9iZUNvbW1pdCB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3NuOWMxMDIvc245YzEwMl9jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NuOWMxMDIvc245YzEwMl9jb3JlLmMKaW5kZXggY2U1NmExYy4uMGUwN2M0OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9zbjljMTAyL3NuOWMxMDJfY29yZS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vc245YzEwMi9zbjljMTAyX2NvcmUuYwpAQCAtMTgxMCw3ICsxODEwLDcgQEAKIAkJLyoKIAkJICAgV2Ugd2lsbCBub3QgcmVsZWFzZSB0aGUgIm9wZW5fbXV0ZXgiIGxvY2ssIHNvIHRoYXQgb25seSBvbmUKIAkJICAgcHJvY2VzcyBjYW4gYmUgaW4gdGhlIHdhaXQgcXVldWUgYmVsb3cuIFRoaXMgd2F5IHRoZSBwcm9jZXNzCi0JCSAgIHdpbGwgYmUgc2xlZXBpbmcgd2hpbGUgaG9sZGluZyB0aGUgbG9jaywgd2l0aG91dCBsb29zaW5nIGl0cworCQkgICB3aWxsIGJlIHNsZWVwaW5nIHdoaWxlIGhvbGRpbmcgdGhlIGxvY2ssIHdpdGhvdXQgbG9zaW5nIGl0cwogCQkgICBwcmlvcml0eSBhZnRlciBhbnkgd2FrZV91cCgpLgogCQkqLwogCQllcnIgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGVfZXhjbHVzaXZlKGNhbS0+d2FpdF9vcGVuLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9zbjljMTAyL3NuOWMxMDJfc2Vuc29yLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NuOWMxMDIvc245YzEwMl9zZW5zb3IuaAppbmRleCA3ZjM4NTQ5Li4zNjc5OTcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3NuOWMxMDIvc245YzEwMl9zZW5zb3IuaAorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NuOWMxMDIvc245YzEwMl9zZW5zb3IuaApAQCAtMTgwLDcgKzE4MCw3IEBACiAJICAgSXQgc2hvdWxkIGJlIHVzZWQgdG8gaW5pdGlhbGl6ZSB0aGUgc2Vuc29yIG9ubHksIGJ1dCBtYXkgYWxzbwogCSAgIGNvbmZpZ3VyZSBwYXJ0IG9mIHRoZSBTTjlDMVhYIGNoaXAgaWYgbmVjZXNzYXJ5LiBZb3UgZG9uJ3QgbmVlZCB0bwogCSAgIHNldHVwIHBpY3R1cmUgc2V0dGluZ3MgbGlrZSBicmlnaHRuZXNzLCBjb250cmFzdCwgZXRjLi4gaGVyZSwgaWYKLQkgICB0aGUgY29ycmlzcG9uZGluZyBjb250cm9scyBhcmUgaW1wbGVtZW50ZWQgKHNlZSBiZWxvdyksIHNpbmNlCisJICAgdGhlIGNvcnJlc3BvbmRpbmcgY29udHJvbHMgYXJlIGltcGxlbWVudGVkIChzZWUgYmVsb3cpLCBzaW5jZQogCSAgIHRoZXkgYXJlIGFkanVzdGVkIGluIHRoZSBjb3JlIGRyaXZlciBieSBjYWxsaW5nIHRoZSBzZXRfY3RybCgpCiAJICAgbWV0aG9kIGFmdGVyIGluaXQoKSwgd2hlcmUgdGhlIGFyZ3VtZW50cyBhcmUgdGhlIGRlZmF1bHQgdmFsdWVzCiAJICAgc3BlY2lmaWVkIGluIHRoZSB2NGwyX3F1ZXJ5Y3RybCBsaXN0IG9mIHN1cHBvcnRlZCBjb250cm9sczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdGNtODI1eC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby90Y204MjV4LmMKaW5kZXggNTQ2ODFhNS4uYjZlZTFiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby90Y204MjV4LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby90Y204MjV4LmMKQEAgLTQ5Myw3ICs0OTMsNyBAQAogCWludCB2YWwsIHI7CiAJc3RydWN0IHZjb250cm9sICpsdmM7CiAKLQkvKiBleHBvc3VyZSB0aW1lIGlzIHNwZWNpYWwsIHNwcmVhZCBhY2Nyb3NzIDIgcmVnaXN0ZXJzICovCisJLyogZXhwb3N1cmUgdGltZSBpcyBzcGVjaWFsLCBzcHJlYWQgYWNyb3NzIDIgcmVnaXN0ZXJzICovCiAJaWYgKHZjLT5pZCA9PSBWNEwyX0NJRF9FWFBPU1VSRSkgewogCQlpbnQgdmFsX2xvd2VyLCB2YWxfdXBwZXI7CiAKQEAgLTUzOCw3ICs1MzgsNyBAQAogCXN0cnVjdCB2Y29udHJvbCAqbHZjOwogCWludCB2YWwgPSB2Yy0+dmFsdWU7CiAKLQkvKiBleHBvc3VyZSB0aW1lIGlzIHNwZWNpYWwsIHNwcmVhZCBhY2Nyb3NzIDIgcmVnaXN0ZXJzICovCisJLyogZXhwb3N1cmUgdGltZSBpcyBzcGVjaWFsLCBzcHJlYWQgYWNyb3NzIDIgcmVnaXN0ZXJzICovCiAJaWYgKHZjLT5pZCA9PSBWNEwyX0NJRF9FWFBPU1VSRSkgewogCQlpbnQgdmFsX2xvd2VyLCB2YWxfdXBwZXI7CiAJCXZhbF9sb3dlciA9IHZhbCAmIFRDTTgyNVhfTUFTSyhUQ004MjVYX0VTUlNQRF9MKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdHZhdWRpby5jIGIvZHJpdmVycy9tZWRpYS92aWRlby90dmF1ZGlvLmMKaW5kZXggYTI1ZTJiNS4uYzQ2YTNiYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby90dmF1ZGlvLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby90dmF1ZGlvLmMKQEAgLTEwNTgsMTEgKzEwNTgsMTEgQEAKICNkZWZpbmUgVERBOTg3NV9NVlIgICAgICAgICAweDFiICAvKiBNYWluIHZvbHVtZSBkcm9pdGUgKi8KICNkZWZpbmUgVERBOTg3NV9NQkEgICAgICAgICAweDFkICAvKiBNYWluIEJhc3NlICovCiAjZGVmaW5lIFREQTk4NzVfTVRSICAgICAgICAgMHgxZSAgLyogTWFpbiB0cmVibGUgKi8KLSNkZWZpbmUgVERBOTg3NV9BQ1MgICAgICAgICAweDFmICAvKiBBdXhpbGFyeSBjaGFubmVsIHNlbGVjdCAoRk0pIDBiMDAwMDAwMCovCi0jZGVmaW5lIFREQTk4NzVfQVZMICAgICAgICAgMHgyMCAgLyogQXV4aWxhcnkgdm9sdW1lIGdhdWNoZSAqLwotI2RlZmluZSBUREE5ODc1X0FWUiAgICAgICAgIDB4MjEgIC8qIEF1eGlsYXJ5IHZvbHVtZSBkcm9pdGUgKi8KLSNkZWZpbmUgVERBOTg3NV9BQkEgICAgICAgICAweDIyICAvKiBBdXhpbGFyeSBCYXNzZSAqLwotI2RlZmluZSBUREE5ODc1X0FUUiAgICAgICAgIDB4MjMgIC8qIEF1eGlsYXJ5IHRyZWJsZSAqLworI2RlZmluZSBUREE5ODc1X0FDUyAgICAgICAgIDB4MWYgIC8qIEF1eGlsaWFyeSBjaGFubmVsIHNlbGVjdCAoRk0pIDBiMDAwMDAwMCovCisjZGVmaW5lIFREQTk4NzVfQVZMICAgICAgICAgMHgyMCAgLyogQXV4aWxpYXJ5IHZvbHVtZSBnYXVjaGUgKi8KKyNkZWZpbmUgVERBOTg3NV9BVlIgICAgICAgICAweDIxICAvKiBBdXhpbGlhcnkgdm9sdW1lIGRyb2l0ZSAqLworI2RlZmluZSBUREE5ODc1X0FCQSAgICAgICAgIDB4MjIgIC8qIEF1eGlsaWFyeSBCYXNzZSAqLworI2RlZmluZSBUREE5ODc1X0FUUiAgICAgICAgIDB4MjMgIC8qIEF1eGlsaWFyeSB0cmVibGUgKi8KIAogI2RlZmluZSBUREE5ODc1X01TUiAgICAgICAgIDB4MDIgIC8qIE1vbml0b3Igc2VsZWN0IHJlZ2lzdGVyICovCiAjZGVmaW5lIFREQTk4NzVfQzFNU0IgICAgICAgMHgwMyAgLyogQ2FycmllciAxIChGTSkgZnJlcXVlbmN5IHJlZ2lzdGVyIE1TQiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby91dmMvdXZjX3ZpZGVvLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3V2Yy91dmNfdmlkZW8uYwppbmRleCA1NDVjMDI5Li5mYzc2NmI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3V2Yy91dmNfdmlkZW8uYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3V2Yy91dmNfdmlkZW8uYwpAQCAtMzk0LDExICszOTQsMTEgQEAKICAqCiAgKiB1dmNfdmlkZW9fZGVjb2RlX2VuZCBpcyBjYWxsZWQgd2l0aCBoZWFkZXIgZGF0YSBhdCB0aGUgZW5kIG9mIGEgYnVsayBvcgogICogaXNvY2hyb25vdXMgcGF5bG9hZC4gSXQgcGVyZm9ybXMgYW55IGFkZGl0aW9uYWwgaGVhZGVyIGRhdGEgcHJvY2Vzc2luZyBhbmQKLSAqIHJldHVybnMgMCBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgaWYgYW4gZXJyb3Igb2NjdXJlZC4gQXMgaGVhZGVyIGRhdGEgaGF2ZQorICogcmV0dXJucyAwIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBpZiBhbiBlcnJvciBvY2N1cnJlZC4gQXMgaGVhZGVyIGRhdGEgaGF2ZQogICogYWxyZWFkeSBiZWVuIHByb2Nlc3NlZCBieSB1dmNfdmlkZW9fZGVjb2RlX3N0YXJ0LCB0aGlzIGZ1bmN0aW9ucyBpc24ndAogICogcmVxdWlyZWQgdG8gcGVyZm9ybSBzYW5pdHkgY2hlY2tzIGEgc2Vjb25kIHRpbWUuCiAgKgotICogRm9yIGlzb2Nocm9ub3VzIHRyYW5zZmVycyB3aGVyZSBhIHBheWxvYWQgaXMgYWx3YXlzIHRyYW5zZmVyZWQgaW4gYSBzaW5nbGUKKyAqIEZvciBpc29jaHJvbm91cyB0cmFuc2ZlcnMgd2hlcmUgYSBwYXlsb2FkIGlzIGFsd2F5cyB0cmFuc2ZlcnJlZCBpbiBhIHNpbmdsZQogICogVVJCLCB0aGUgdGhyZWUgZnVuY3Rpb25zIHdpbGwgYmUgY2FsbGVkIGluIGEgcm93LgogICoKICAqIFRvIGxldCB0aGUgZGVjb2RlciBwcm9jZXNzIGhlYWRlciBkYXRhIGFuZCB1cGRhdGUgaXRzIGludGVybmFsIHN0YXRlIGV2ZW4KQEAgLTY1OCw3ICs2NTgsNyBAQAogCQkJCQkJCSAgICBidWYpOwogCQl9IHdoaWxlIChyZXQgPT0gLUVBR0FJTik7CiAKLQkJLyogSWYgYW4gZXJyb3Igb2NjdXJlZCBza2lwIHRoZSByZXN0IG9mIHRoZSBwYXlsb2FkLiAqLworCQkvKiBJZiBhbiBlcnJvciBvY2N1cnJlZCBza2lwIHRoZSByZXN0IG9mIHRoZSBwYXlsb2FkLiAqLwogCQlpZiAocmV0IDwgMCB8fCBidWYgPT0gTlVMTCkgewogCQkJc3RyZWFtLT5idWxrLnNraXBfcGF5bG9hZCA9IDE7CiAJCX0gZWxzZSB7CkBAIC04MjEsNyArODIxLDcgQEAKIAkJcmV0dXJuIHN0cmVhbS0+dXJiX3NpemUgLyBwc2l6ZTsKIAogCS8qIENvbXB1dGUgdGhlIG51bWJlciBvZiBwYWNrZXRzLiBCdWxrIGVuZHBvaW50cyBtaWdodCB0cmFuc2ZlciBVVkMKLQkgKiBwYXlsb2FkcyBhY2Nyb3NzIG11bHRpcGxlIFVSQnMuCisJICogcGF5bG9hZHMgYWNyb3NzIG11bHRpcGxlIFVSQnMuCiAJICovCiAJbnBhY2tldHMgPSBESVZfUk9VTkRfVVAoc2l6ZSwgcHNpemUpOwogCWlmIChucGFja2V0cyA+IFVWQ19NQVhfUEFDS0VUUykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdjRsMi1pb2N0bC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWlvY3RsLmMKaW5kZXggYTAxZWQzOS4uNTA2ZWRjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWlvY3RsLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWlvY3RsLmMKQEAgLTQ4LDcgKzQ4LDcgQEAKIAkJCXByaW50ayhLRVJOX0NPTlQgIiVzOiAiIGZtdCwgdmZkLT5uYW1lLCAjIyBhcmcpO1wKIAkJfSB3aGlsZSAoMCkKIAotLyogWmVybyBvdXQgdGhlIGVuZCBvZiB0aGUgc3RydWN0IHBvaW50ZWQgdG8gYnkgcC4gIEV2ZXJ0aGluZyBhZnRlciwgYnV0CisvKiBaZXJvIG91dCB0aGUgZW5kIG9mIHRoZSBzdHJ1Y3QgcG9pbnRlZCB0byBieSBwLiAgRXZlcnl0aGluZyBhZnRlciwgYnV0CiAgKiBub3QgaW5jbHVkaW5nLCB0aGUgc3BlY2lmaWVkIGZpZWxkIGlzIGNsZWFyZWQuICovCiAjZGVmaW5lIENMRUFSX0FGVEVSX0ZJRUxEKHAsIGZpZWxkKSBcCiAJbWVtc2V0KCh1OCAqKShwKSArIG9mZnNldG9mKHR5cGVvZigqKHApKSwgZmllbGQpICsgc2l6ZW9mKChwKS0+ZmllbGQpLCBcCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3ZweDMyMjAuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vdnB4MzIyMC5jCmluZGV4IDc1MzAxZDEuLmNhMzcyZWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdnB4MzIyMC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vdnB4MzIyMC5jCkBAIC0zNTQsNyArMzU0LDcgQEAKIAogCS8qIEhlcmUgd2UgYmFjayB1cCB0aGUgaW5wdXQgc2VsZWN0aW9uIGJlY2F1c2UgaXQgZ2V0cwogCSAgIG92ZXJ3cml0dGVuIHdoZW4gd2UgZmlsbCB0aGUgcmVnaXN0ZXJzIHdpdGggdGhlCi0JICAgY2hvb3NlbiB2aWRlbyBub3JtICovCisJICAgY2hvc2VuIHZpZGVvIG5vcm0gKi8KIAl0ZW1wX2lucHV0ID0gdnB4MzIyMF9mcF9yZWFkKHNkLCAweGYyKTsKIAogCXY0bDJfZGJnKDEsIGRlYnVnLCBzZCwgInNfc3RkICVsbHhcbiIsICh1bnNpZ25lZCBsb25nIGxvbmcpc3RkKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vdmlkZW9jb2RlYy5oIGIvZHJpdmVycy9tZWRpYS92aWRlby96b3Jhbi92aWRlb2NvZGVjLmgKaW5kZXggYjY1NGJmZi4uZGVmNTU1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby96b3Jhbi92aWRlb2NvZGVjLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby96b3Jhbi92aWRlb2NvZGVjLmgKQEAgLTU3LDcgKzU3LDcgQEAKICAgIHRoZXJmb3IgdGhleSBtYXkgbm90IGJlIGluaXRpYWxpemVkLgogCiAgICBUaGUgb3RoZXIgZnVuY3Rpb25zIGFyZSBqdXN0IGZvciBjb252ZW5pZW5jZSwgYXMgdGhleSBhcmUgZm9yIHN1cmUgdXNlZCBieQotICAgbW9zdC9hbGwgb2YgdGhlIGNvZGVjcy4gVGhlIGxhc3Qgb25lcyBtYXkgYmUgb21taXRlZCwgdG9vLgorICAgbW9zdC9hbGwgb2YgdGhlIGNvZGVjcy4gVGhlIGxhc3Qgb25lcyBtYXkgYmUgb21pdHRlZCwgdG9vLgogCiAgICBTZWUgdGhlIHN0cnVjdHVyZSBkZWNsYXJhdGlvbiBiZWxvdyBmb3IgbW9yZSBpbmZvcm1hdGlvbiBhbmQgd2hpY2ggZGF0YSBoYXMKICAgIHRvIGJlIHNldCB1cCBmb3IgdGhlIG1hc3RlciBhbmQgdGhlIHNsYXZlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby96b3Jhbi96b3Jhbi5oIGIvZHJpdmVycy9tZWRpYS92aWRlby96b3Jhbi96b3Jhbi5oCmluZGV4IDRiYjM2OGUuLmYzZjY0MDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vem9yYW4uaAorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3pvcmFuL3pvcmFuLmgKQEAgLTI1OSw3ICsyNTksNyBAQAogCXN0cnVjdCB2ZmVfcG9sYXJpdHkgdmZlX3BvbDsKIAl1OCBncGlvX3BvbFtaUl9HUElPX01BWF07CiAKLQkvKiBpcyB0aGUgL0dXUyBsaW5lIGNvbmVjdGVkPyAqLworCS8qIGlzIHRoZSAvR1dTIGxpbmUgY29ubmVjdGVkPyAqLwogCXU4IGd3c19ub3RfY29ubmVjdGVkOwogCiAJLyogYXZzNmV5ZXMgbXV4IHNldHRpbmcgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vem9yYW5fZHJpdmVyLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3pvcmFuL3pvcmFuX2RyaXZlci5jCmluZGV4IDdjMzkyMWQuLjI3NzFkODEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vem9yYW5fZHJpdmVyLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby96b3Jhbi96b3Jhbl9kcml2ZXIuYwpAQCAtMTI1NCw3ICsxMjU0LDcgQEAKIHsKIAlzdHJ1Y3Qgem9yYW4gKnpyID0gZmgtPnpyOwogCi0JLyogSWYgdGhlcmUgaXMgbm90aGluZyB0byBkbywgcmV0dXJuIGltbWVkaWF0bHkgKi8KKwkvKiBJZiB0aGVyZSBpcyBub3RoaW5nIHRvIGRvLCByZXR1cm4gaW1tZWRpYXRlbHkgKi8KIAlpZiAoKG9uICYmIGZoLT5vdmVybGF5X2FjdGl2ZSAhPSBaT1JBTl9GUkVFKSB8fAogCSAgICAoIW9uICYmIGZoLT5vdmVybGF5X2FjdGl2ZSA9PSBaT1JBTl9GUkVFKSkKIAkJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lbXN0aWNrL2NvcmUvbXNwcm9fYmxvY2suYyBiL2RyaXZlcnMvbWVtc3RpY2svY29yZS9tc3Byb19ibG9jay5jCmluZGV4IDU3YjQyYmYuLjRhMTkwOWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVtc3RpY2svY29yZS9tc3Byb19ibG9jay5jCisrKyBiL2RyaXZlcnMvbWVtc3RpY2svY29yZS9tc3Byb19ibG9jay5jCkBAIC05NzMsNyArOTczLDcgQEAKIH0KIAogLyogTWVtb3J5IGFsbG9jYXRlZCBmb3IgYXR0cmlidXRlcyBieSB0aGlzIGZ1bmN0aW9uIHNob3VsZCBiZSBmcmVlZCBieQotICogbXNwcm9fYmxvY2tfZGF0YV9jbGVhciwgbm8gbWF0dGVyIGlmIHRoZSBpbml0aWFsaXphdGlvbiBwcm9jZXNzIHN1Y2NlZGVkCisgKiBtc3Byb19ibG9ja19kYXRhX2NsZWFyLCBubyBtYXR0ZXIgaWYgdGhlIGluaXRpYWxpemF0aW9uIHByb2Nlc3Mgc3VjY2VlZGVkCiAgKiBvciBmYWlsZWQuCiAgKi8KIHN0YXRpYyBpbnQgbXNwcm9fYmxvY2tfcmVhZF9hdHRyaWJ1dGVzKHN0cnVjdCBtZW1zdGlja19kZXYgKmNhcmQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lbXN0aWNrL2hvc3QvcjU5Mi5jIGIvZHJpdmVycy9tZW1zdGljay9ob3N0L3I1OTIuYwppbmRleCA3MDBkNDIwLi42NjhmNWM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lbXN0aWNrL2hvc3QvcjU5Mi5jCisrKyBiL2RyaXZlcnMvbWVtc3RpY2svaG9zdC9yNTkyLmMKQEAgLTc5Niw3ICs3OTYsNyBAQAogCWlmIChtZW1zdGlja19hZGRfaG9zdChob3N0KSkKIAkJZ290byBlcnJvcjc7CiAKLQltZXNzYWdlKCJkcml2ZXIgc3VjY2VzZnVsbHkgbG9hZGVkIik7CisJbWVzc2FnZSgiZHJpdmVyIHN1Y2Nlc3NmdWxseSBsb2FkZWQiKTsKIAlyZXR1cm4gMDsKIGVycm9yNzoKIAlmcmVlX2lycShkZXYtPmlycSwgZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVtc3RpY2svaG9zdC9yNTkyLmggYi9kcml2ZXJzL21lbXN0aWNrL2hvc3QvcjU5Mi5oCmluZGV4IGVlZTI2NGUuLmM1NzI2YzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVtc3RpY2svaG9zdC9yNTkyLmgKKysrIGIvZHJpdmVycy9tZW1zdGljay9ob3N0L3I1OTIuaApAQCAtNDMsMTIgKzQzLDEyIEBACiAKIAkJCQkJCQkvKiBFcnJvciBkZXRlY3Rpb24gdmlhIENSQyAqLwogI2RlZmluZSBSNTkyX1NUQVRVU19TRU5EX0VSUgkJKDEgPDwgMjQpCS8qIFNlbmQgZmFpbGVkICovCi0jZGVmaW5lIFI1OTJfU1RBVFVTX1JFQ1ZfRVJSCQkoMSA8PCAyNSkJLyogUmVjaWV2ZSBmYWlsZWQgKi8KKyNkZWZpbmUgUjU5Ml9TVEFUVVNfUkVDVl9FUlIJCSgxIDw8IDI1KQkvKiBSZWNlaXZlIGZhaWxlZCAqLwogCiAJCQkJCQkJLyogQ2FyZCBzdGF0ZSAqLwotI2RlZmluZSBSNTkyX1NUQVRVU19SRFkJCQkoMSA8PCAyOCkJLyogUkRZIHNpZ25hbCByZWNpZXZlZCAqLworI2RlZmluZSBSNTkyX1NUQVRVU19SRFkJCQkoMSA8PCAyOCkJLyogUkRZIHNpZ25hbCByZWNlaXZlZCAqLwogI2RlZmluZSBSNTkyX1NUQVRVU19DRUQJCQkoMSA8PCAyOSkJLyogSU5UOiBDb21tYW5kIGRvbmUgKHNlcmlhbCBtb2RlKSovCi0jZGVmaW5lIFI1OTJfU1RBVFVTX1NGSUZPX0lOUFVUCQkoMSA8PCAzMCkJLyogU21hbGwgZmlmbyByZWNpZXZlZCBkYXRhKi8KKyNkZWZpbmUgUjU5Ml9TVEFUVVNfU0ZJRk9fSU5QVVQJCSgxIDw8IDMwKQkvKiBTbWFsbCBmaWZvIHJlY2VpdmVkIGRhdGEqLwogCiAjZGVmaW5lIFI1OTJfU0ZJRk9fU0laRQkJCTMyCQkvKiB0b3RhbCBzaXplIG9mIHNtYWxsIGZpZm8gaXMgMzIgYnl0ZXMgKi8KICNkZWZpbmUgUjU5Ml9TRklGT19QQUNLRVQJCTgJCS8qIHBhY2tldCBzaXplIG9mIHNtYWxsIGZpZm8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbHNpL21waV9sb2dfZmMuaCBiL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbHNpL21waV9sb2dfZmMuaAppbmRleCBmYWNlNmU3Li4wM2JlOGIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL2xzaS9tcGlfbG9nX2ZjLmgKKysrIGIvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9sc2kvbXBpX2xvZ19mYy5oCkBAIC0zOCw4ICszOCw4IEBACiB7CiAgICAgTVBJX0lPQ0xPR0lORk9fRkNfSU5JVF9CQVNFICAgICAgICAgICAgICAgICAgICAgPSAweDIwMDAwMDAwLAogICAgIE1QSV9JT0NMT0dJTkZPX0ZDX0lOSVRfRVJST1JfT1VUX09GX09SREVSX0ZSQU1FID0gMHgyMDAwMDAwMSwgLyogcmVjZWl2ZWQgYW4gb3V0IG9mIG9yZGVyIGZyYW1lIC0gdW5zdXBwb3J0ZWQgKi8KLSAgICBNUElfSU9DTE9HSU5GT19GQ19JTklUX0VSUk9SX0JBRF9TVEFSVF9PRl9GUkFNRSA9IDB4MjAwMDAwMDIsIC8qIEJhZCBSeCBGcmFtZSwgYmFkIHN0YXJ0IG9mIGZyYW1lIHByaW1hdGl2ZSAqLwotICAgIE1QSV9JT0NMT0dJTkZPX0ZDX0lOSVRfRVJST1JfQkFEX0VORF9PRl9GUkFNRSAgID0gMHgyMDAwMDAwMywgLyogQmFkIFJ4IEZyYW1lLCBiYWQgZW5kIG9mIGZyYW1lIHByaW1hdGl2ZSAqLworICAgIE1QSV9JT0NMT0dJTkZPX0ZDX0lOSVRfRVJST1JfQkFEX1NUQVJUX09GX0ZSQU1FID0gMHgyMDAwMDAwMiwgLyogQmFkIFJ4IEZyYW1lLCBiYWQgc3RhcnQgb2YgZnJhbWUgcHJpbWl0aXZlICovCisgICAgTVBJX0lPQ0xPR0lORk9fRkNfSU5JVF9FUlJPUl9CQURfRU5EX09GX0ZSQU1FICAgPSAweDIwMDAwMDAzLCAvKiBCYWQgUnggRnJhbWUsIGJhZCBlbmQgb2YgZnJhbWUgcHJpbWl0aXZlICovCiAgICAgTVBJX0lPQ0xPR0lORk9fRkNfSU5JVF9FUlJPUl9PVkVSX1JVTiAgICAgICAgICAgPSAweDIwMDAwMDA0LCAvKiBCYWQgUnggRnJhbWUsIG92ZXJydW4gKi8KICAgICBNUElfSU9DTE9HSU5GT19GQ19JTklUX0VSUk9SX1JYX09USEVSICAgICAgICAgICA9IDB4MjAwMDAwMDUsIC8qIE90aGVyIGVycm9ycyBjYXVnaHQgYnkgSU9DIHdoaWNoIHJlcXVpcmUgcmV0cmllcyAqLwogICAgIE1QSV9JT0NMT0dJTkZPX0ZDX0lOSVRfRVJST1JfU1VCUFJPQ19ERUFEICAgICAgID0gMHgyMDAwMDAwNiwgLyogTWFpbiBwcm9jZXNzb3IgY291bGQgbm90IGluaXRpYWxpemUgc3ViLXByb2Nlc3NvciAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9sc2kvbXBpX2xvZ19zYXMuaCBiL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbHNpL21waV9sb2dfc2FzLmgKaW5kZXggOGIwNDgxMC4uZjYyOTYwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9sc2kvbXBpX2xvZ19zYXMuaAorKysgYi9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL2xzaS9tcGlfbG9nX3Nhcy5oCkBAIC01Niw5ICs1Niw5IEBACiAjZGVmaW5lIElPUF9MT0dJTkZPX0NPREVfRldVUExPQURfTk9fRkxBU0hfQVZBSUxBQkxFICAgICAgICAgKDB4MDAwM0UwMDApIC8qIFRyaWVkIHRvIHVwbG9hZCBmcm9tIGZsYXNoLCBidXQgdGhlcmUgaXMgbm9uZSAqLwogI2RlZmluZSBJT1BfTE9HSU5GT19DT0RFX0ZXVVBMT0FEX1VOS05PV05fSU1BR0VfVFlQRSAgICAgICAgICgweDAwMDNFMDAxKSAvKiBJbWFnZVR5cGUgZmllbGQgY29udGVudHMgd2VyZSBpbnZhbGlkICovCiAjZGVmaW5lIElPUF9MT0dJTkZPX0NPREVfRldVUExPQURfV1JPTkdfSU1BR0VfU0laRSAgICAgICAgICAgKDB4MDAwM0UwMDIpIC8qIEltYWdlU2l6ZSBmaWVsZCBpbiBUQ1NHRSB3YXMgYmFkL29mZnNldCBpbiBNZmdQZyA0IHdhcyB3cm9uZyAqLwotI2RlZmluZSBJT1BfTE9HSU5GT19DT0RFX0ZXVVBMT0FEX0VOVElSRV9GTEFTSF9VUExPQURfRkFJTEVEICgweDAwMDNFMDAzKSAvKiBFcnJvciBvY2N1cmVkIHdoaWxlIGF0dGVtcHRpbmcgdG8gdXBsb2FkIHRoZSBlbnRpcmUgZmxhc2ggKi8KLSNkZWZpbmUgSU9QX0xPR0lORk9fQ09ERV9GV1VQTE9BRF9SRUdJT05fVVBMT0FEX0ZBSUxFRCAgICAgICAoMHgwMDAzRTAwNCkgLyogRXJyb3Igb2NjdXJlZCB3aGlsZSBhdHRlbXB0aW5nIHRvIHVwbG9hZCBzaW5nbGUgZmxhc2ggcmVnaW9uICovCi0jZGVmaW5lIElPUF9MT0dJTkZPX0NPREVfRldVUExPQURfRE1BX0ZBSUxVUkUgICAgICAgICAgICAgICAgKDB4MDAwM0UwMDUpIC8qIFByb2JsZW0gb2NjdXJlZCB3aGlsZSBETUFpbmcgRlcgdG8gaG9zdCBtZW1vcnkgKi8KKyNkZWZpbmUgSU9QX0xPR0lORk9fQ09ERV9GV1VQTE9BRF9FTlRJUkVfRkxBU0hfVVBMT0FEX0ZBSUxFRCAoMHgwMDAzRTAwMykgLyogRXJyb3Igb2NjdXJyZWQgd2hpbGUgYXR0ZW1wdGluZyB0byB1cGxvYWQgdGhlIGVudGlyZSBmbGFzaCAqLworI2RlZmluZSBJT1BfTE9HSU5GT19DT0RFX0ZXVVBMT0FEX1JFR0lPTl9VUExPQURfRkFJTEVEICAgICAgICgweDAwMDNFMDA0KSAvKiBFcnJvciBvY2N1cnJlZCB3aGlsZSBhdHRlbXB0aW5nIHRvIHVwbG9hZCBzaW5nbGUgZmxhc2ggcmVnaW9uICovCisjZGVmaW5lIElPUF9MT0dJTkZPX0NPREVfRldVUExPQURfRE1BX0ZBSUxVUkUgICAgICAgICAgICAgICAgKDB4MDAwM0UwMDUpIC8qIFByb2JsZW0gb2NjdXJyZWQgd2hpbGUgRE1BaW5nIEZXIHRvIGhvc3QgbWVtb3J5ICovCiAKICNkZWZpbmUgSU9QX0xPR0lORk9fQ09ERV9ESUFHX01TR19FUlJPUiAgICAgICAgICAgICAgICAgICAgICAoMHgwMDA0MDAwMCkgLyogRXJyb3IgaGFuZGxpbmcgZGlhZyBtc2cgLSBvcidkIHdpdGggZGlhZyBzdGF0dXMgKi8KIApAQCAtMTg3LDggKzE4Nyw4IEBACiAjZGVmaW5lIFBMX0xPR0lORk9fU1VCX0NPREVfQlJFQUtfT05fSU5DT01QTEVURV9CUkVBS19SQ1ZEICAgKDB4MDAwMDUwMDApCiAKICNkZWZpbmUgUExfTE9HSU5GT19DT0RFX0VOQ0xfTUdNVF9TTVBfRlJBTUVfRkFJTFVSRSAgICAgICAgICAoMHgwMDIwMDAwMCkgLyogQ2FuJ3QgZ2V0IFNNUCBGcmFtZSAqLwotI2RlZmluZSBQTF9MT0dJTkZPX0NPREVfRU5DTF9NR01UX1NNUF9SRUFEX0VSUk9SICAgICAgICAgICAgICgweDAwMjAwMDEwKSAvKiBFcnJvciBvY2N1cmVkIG9uIFNNUCBSZWFkICovCi0jZGVmaW5lIFBMX0xPR0lORk9fQ09ERV9FTkNMX01HTVRfU01QX1dSSVRFX0VSUk9SICAgICAgICAgICAgKDB4MDAyMDAwMjApIC8qIEVycm9yIG9jY3VyZWQgb24gU01QIFdyaXRlICovCisjZGVmaW5lIFBMX0xPR0lORk9fQ09ERV9FTkNMX01HTVRfU01QX1JFQURfRVJST1IgICAgICAgICAgICAgKDB4MDAyMDAwMTApIC8qIEVycm9yIG9jY3VycmVkIG9uIFNNUCBSZWFkICovCisjZGVmaW5lIFBMX0xPR0lORk9fQ09ERV9FTkNMX01HTVRfU01QX1dSSVRFX0VSUk9SICAgICAgICAgICAgKDB4MDAyMDAwMjApIC8qIEVycm9yIG9jY3VycmVkIG9uIFNNUCBXcml0ZSAqLwogI2RlZmluZSBQTF9MT0dJTkZPX0NPREVfRU5DTF9NR01UX05PVF9TVVBQT1JURURfT05fRU5DTCAgICAgICgweDAwMjAwMDQwKSAvKiBFbmNsIE1nbXQgc2VydmljZXMgbm90IGF2YWlsYWJsZSBmb3IgdGhpcyBXV0lEICovCiAjZGVmaW5lIFBMX0xPR0lORk9fQ09ERV9FTkNMX01HTVRfQUREUl9NT0RFX05PVF9TVVBQT1JURUQgICAgKDB4MDAyMDAwNTApIC8qIEFkZHJlc3MgTW9kZSBub3Qgc3VwcG9yZWQgKi8KICNkZWZpbmUgUExfTE9HSU5GT19DT0RFX0VOQ0xfTUdNVF9CQURfU0xPVF9OVU0gICAgICAgICAgICAgICAoMHgwMDIwMDA2MCkgLyogSW52YWxpZCBTbG90IE51bWJlciBpbiBTRVAgTXNnICovCkBAIC0yMDcsOCArMjA3LDggQEAKICNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfUkVDRUlWRURfTkFDS19GUk9NX1NMQVZFICAgICAgICAgICAoMHgwMDIwMDEwMykgLyogU0VQIE5BQ0snZCwgaXQgaXMgYnVzeSAqLwogI2RlZmluZSBQTF9MT0dJTkZPX0RBX1NFUF9ESURfTk9UX1JFQ0VJVkVfQUNLICAgICAgICAgICAgICAgICgweDAwMjAwMTA0KSAvKiBTRVAgZGlkbid0IHJjdi4gQUNLIChMYXN0IFJjdmQgQml0ID0gMSkgKi8KICNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfQkFEX1NUQVRVU19IRFJfQ0hLU1VNICAgICAgICAgICAgICAoMHgwMDIwMDEwNSkgLyogU0VQIHN0b3BwZWQgb3Igc2VudCBiYWQgY2hrc3VtIGluIEhkciAqLwotI2RlZmluZSBQTF9MT0dJTkZPX0RBX1NFUF9TVE9QX09OX0RBVEEgICAgICAgICAgICAgICAgICAgICAgICgweDAwMjAwMTA2KSAvKiBTRVAgc3RvcHBlZCB3aGlsZSB0cmFuc2ZlcmluZyBkYXRhICovCi0jZGVmaW5lIFBMX0xPR0lORk9fREFfU0VQX1NUT1BfT05fU0VOU0VfREFUQSAgICAgICAgICAgICAgICAgKDB4MDAyMDAxMDcpIC8qIFNFUCBzdG9wcGVkIHdoaWxlIHRyYW5zZmVyaW5nIHNlbnNlIGRhdGEgKi8KKyNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfU1RPUF9PTl9EQVRBICAgICAgICAgICAgICAgICAgICAgICAoMHgwMDIwMDEwNikgLyogU0VQIHN0b3BwZWQgd2hpbGUgdHJhbnNmZXJyaW5nIGRhdGEgKi8KKyNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfU1RPUF9PTl9TRU5TRV9EQVRBICAgICAgICAgICAgICAgICAoMHgwMDIwMDEwNykgLyogU0VQIHN0b3BwZWQgd2hpbGUgdHJhbnNmZXJyaW5nIHNlbnNlIGRhdGEgKi8KICNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfVU5TVVBQT1JURURfU0NTSV9TVEFUVVNfMSAgICAgICAgICAoMHgwMDIwMDEwOCkgLyogU0VQIHJldHVybmVkIHVua25vd24gc2NzaSBzdGF0dXMgKi8KICNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfVU5TVVBQT1JURURfU0NTSV9TVEFUVVNfMiAgICAgICAgICAoMHgwMDIwMDEwOSkgLyogU0VQIHJldHVybmVkIHVua25vd24gc2NzaSBzdGF0dXMgKi8KICNkZWZpbmUgUExfTE9HSU5GT19EQV9TRVBfQ0hLU1VNX0VSUk9SX0FGVEVSX1NUT1AgICAgICAgICAgICAoMHgwMDIwMDEwQSkgLyogU0VQIHJldHVybmVkIGJhZCBjaGtzdW0gYWZ0ZXIgU1RPUCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9tcHRiYXNlLmMgYi9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL21wdGJhc2UuYwppbmRleCBlYzgwODBjLi5mYTE1ZTg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL21wdGJhc2UuYworKysgYi9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL21wdGJhc2UuYwpAQCAtMzQzNSw3ICszNDM1LDcgQEAKICAqCUlmIG1lbW9yeSBoYXMgYWxyZWFkeSBiZWVuIGFsbG9jYXRlZCwgdGhlIHNhbWUgKGNhY2hlZCkgdmFsdWUKICAqCWlzIHJldHVybmVkLgogICoKLSAqCVJldHVybiAwIGlmIHN1Y2Nlc3NmdWxsLCBvciBub24temVybyBmb3IgZmFpbHVyZQorICoJUmV0dXJuIDAgaWYgc3VjY2Vzc2Z1bCwgb3Igbm9uLXplcm8gZm9yIGZhaWx1cmUKICAqKi8KIGludAogbXB0X2FsbG9jX2Z3X21lbW9yeShNUFRfQURBUFRFUiAqaW9jLCBpbnQgc2l6ZSkKQEAgLTY5MzIsNyArNjkzMiw3IEBACiAgKglNZXNzYWdlIFVuaXQgUmVzZXQgLSBpbnN0cnVjdHMgdGhlIElPQyB0byByZXNldCB0aGUgUmVwbHkgUG9zdCBhbmQKICAqCUZyZWUgRklGTydzLiBBbGwgdGhlIE1lc3NhZ2UgRnJhbWVzIG9uIFJlcGx5IEZyZWUgRklGTyBhcmUgZGlzY2FyZGVkLgogICoJQWxsIHBvc3RlZCBidWZmZXJzIGFyZSBmcmVlZCwgYW5kIGV2ZW50IG5vdGlmaWNhdGlvbiBpcyB0dXJuZWQgb2ZmLgotICoJSU9DIGRvZXNudCByZXBseSB0byBhbnkgb3V0c3RhbmRpbmcgcmVxdWVzdC4gVGhpcyB3aWxsIHRyYW5zZmVyIElPQworICoJSU9DIGRvZXNuJ3QgcmVwbHkgdG8gYW55IG91dHN0YW5kaW5nIHJlcXVlc3QuIFRoaXMgd2lsbCB0cmFuc2ZlciBJT0MKICAqCXRvIFJFQURZIHN0YXRlLgogICoqLwogaW50CkBAIC03OTA1LDcgKzc5MDUsNyBAQAogCQkgICAgIk93bmVyIiwgCQkJCQkvKiAxNWggKi8KIAkJIk9wZW4gVHJhbnNtaXQgRE1BIEFib3J0IiwJCQkvKiAxNmggKi8KIAkJIklPIERldmljZSBNaXNzaW5nIERlbGF5IFJldHJ5IiwJCS8qIDE3aCAqLwotCQkiSU8gQ2FuY2VsbGVkIER1ZSB0byBSZWNpZXZlIEVycm9yIiwJCS8qIDE4aCAqLworCQkiSU8gQ2FuY2VsbGVkIER1ZSB0byBSZWNlaXZlIEVycm9yIiwJCS8qIDE4aCAqLwogCQlOVUxMLAkJCQkJCS8qIDE5aCAqLwogCQlOVUxMLAkJCQkJCS8qIDFBaCAqLwogCQlOVUxMLAkJCQkJCS8qIDFCaCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9tcHRjdGwuYyBiL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbXB0Y3RsLmMKaW5kZXggODc4YmRhMC4uNmU2ZTE2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9tcHRjdGwuYworKysgYi9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL21wdGN0bC5jCkBAIC05ODUsNyArOTg1LDcgQEAKIAlSZXBseU1zZyA9IChwRldEb3dubG9hZFJlcGx5X3QpaW9jcC0+aW9jdGxfY21kcy5yZXBseTsKIAlpb2NzdGF0ID0gbGUxNl90b19jcHUoUmVwbHlNc2ctPklPQ1N0YXR1cykgJiBNUElfSU9DU1RBVFVTX01BU0s7CiAJaWYgKGlvY3N0YXQgPT0gTVBJX0lPQ1NUQVRVU19TVUNDRVNTKSB7Ci0JCXByaW50ayhNWUlPQ19zX0lORk9fRk1UICJGL1cgdXBkYXRlIHN1Y2Nlc3NmdWxsIVxuIiwgaW9jcC0+bmFtZSk7CisJCXByaW50ayhNWUlPQ19zX0lORk9fRk1UICJGL1cgdXBkYXRlIHN1Y2Nlc3NmdWwhXG4iLCBpb2NwLT5uYW1lKTsKIAkJcmV0dXJuIDA7CiAJfSBlbHNlIGlmIChpb2NzdGF0ID09IE1QSV9JT0NTVEFUVVNfSU5WQUxJRF9GVU5DVElPTikgewogCQlwcmludGsoTVlJT0Nfc19XQVJOX0ZNVCAiSG1tbS4uLiAgRi9XIGRvd25sb2FkIG5vdCBzdXBwb3J0ZWQhPyFcbiIsCkBAIC0yNDA3LDcgKzI0MDcsNyBAQAogCX0KIAogCS8qIG1mIGlzIG51bGwgaWYgY29tbWFuZCBpc3N1ZWQgc3VjY2Vzc2Z1bGx5Ci0JICogb3RoZXJ3aXNlLCBmYWlsdXJlIG9jY3VyZWQgYWZ0ZXIgbWYgYWNxdWlyZWQuCisJICogb3RoZXJ3aXNlLCBmYWlsdXJlIG9jY3VycmVkIGFmdGVyIG1mIGFjcXVpcmVkLgogCSAqLwogCWlmIChtZikKIAkJbXB0X2ZyZWVfbXNnX2ZyYW1lKGlvYywgbWYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9tcHRzYXMuYyBiL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbXB0c2FzLmMKaW5kZXggZjVhMTRhZi4uNjZmOTQxMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9tcHRzYXMuYworKysgYi9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL21wdHNhcy5jCkBAIC0zMDcsNyArMzA3LDcgQEAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPmZ3X2V2ZW50X2xvY2ssIGZsYWdzKTsKIH0KIAotLyogZnJlZSBtZW1vcnkgYXNzb2ljYXRlZCB0byBhIHNhcyBmaXJtd2FyZSBldmVudCAqLworLyogZnJlZSBtZW1vcnkgYXNzb2NpYXRlZCB0byBhIHNhcyBmaXJtd2FyZSBldmVudCAqLwogc3RhdGljIHZvaWQKIG1wdHNhc19mcmVlX2Z3X2V2ZW50KE1QVF9BREFQVEVSICppb2MsIHN0cnVjdCBmd19ldmVudF93b3JrICpmd19ldmVudCkKIHsKQEAgLTEwOTQsNyArMTA5NCw3IEBACiAvKioKICAqIG1wdHNhc190YXJnZXRfcmVzZXRfcXVldWUKICAqCi0gKiBSZWNlaXZlIHJlcXVlc3QgZm9yIFRBUkdFVF9SRVNFVCBhZnRlciByZWNpZXZpbmcgYW4gZmlybXdhcmUKKyAqIFJlY2VpdmUgcmVxdWVzdCBmb3IgVEFSR0VUX1JFU0VUIGFmdGVyIHJlY2VpdmluZyBhbiBmaXJtd2FyZQogICogZXZlbnQgTk9UX1JFU1BPTkRJTkdfRVZFTlQsIHRoZW4gcHV0IGNvbW1hbmQgaW4gbGluayBsaXN0CiAgKiBhbmQgcXVldWUgaWYgdGFza19xdWV1ZSBhbHJlYWR5IGluIHVzZS4KICAqCkBAIC0xNDAzLDcgKzE0MDMsNyBAQAogLyoqCiAgKgltcHRzYXNfYWRkX2VuZF9kZXZpY2UgLSByZXBvcnQgYSBuZXcgZW5kIGRldmljZSB0byBzYXMgdHJhbnNwb3J0IGxheWVyCiAgKglAaW9jOiBQb2ludGVyIHRvIE1QVF9BREFQVEVSIHN0cnVjdHVyZQotICoJQHBoeV9pbmZvOiBkZWNyaWJlcyBhdHRhY2hlZCBkZXZpY2UKKyAqCUBwaHlfaW5mbzogZGVzY3JpYmVzIGF0dGFjaGVkIGRldmljZQogICoKICAqCXJldHVybiAoMCkgc3VjY2VzcyAoMSkgZmFpbHVyZQogICoKQEAgLTE0ODEsNyArMTQ4MSw3IEBACiAvKioKICAqCW1wdHNhc19kZWxfZW5kX2RldmljZSAtIHJlcG9ydCBhIGRlbGV0ZWQgZW5kIGRldmljZSB0byBzYXMgdHJhbnNwb3J0IGxheWVyCiAgKglAaW9jOiBQb2ludGVyIHRvIE1QVF9BREFQVEVSIHN0cnVjdHVyZQotICoJQHBoeV9pbmZvOiBkZWNyaWJlcyBhdHRhY2hlZCBkZXZpY2UKKyAqCUBwaHlfaW5mbzogZGVzY3JpYmVzIGF0dGFjaGVkIGRldmljZQogICoKICAqKi8KIHN0YXRpYyB2b2lkCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lc3NhZ2UvaTJvL1JFQURNRSBiL2RyaXZlcnMvbWVzc2FnZS9pMm8vUkVBRE1FCmluZGV4IDkxMWZjMzAuLmYwNzJhOGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVzc2FnZS9pMm8vUkVBRE1FCisrKyBiL2RyaXZlcnMvbWVzc2FnZS9pMm8vUkVBRE1FCkBAIC01Myw3ICs1Myw3IEBACiBCb3hIaWxsIENvcnBvcmF0aW9uCiAJTG9hbiBvZiBpbml0aWFsIEZpYnJlQ2hhbm5lbCBkaXNrIGFycmF5IHVzZWQgZm9yIGRldmVsb3BtZW50IHdvcmsuCiAKLUV1cm9wZWFuIENvbWlzc2lvbgorRXVyb3BlYW4gQ29tbWlzc2lvbgogCUZ1bmRpbmcgdGhlIHdvcmsgZG9uZSBieSB0aGUgVW5pdmVyc2l0eSBvZiBIZWxzaW5raQogCiBTeXNLb25uZWN0CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lc3NhZ2UvaTJvL2RldmljZS5jIGIvZHJpdmVycy9tZXNzYWdlL2kyby9kZXZpY2UuYwppbmRleCAwZWU0MjY0Li40NTQ3ZGI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lc3NhZ2UvaTJvL2RldmljZS5jCisrKyBiL2RyaXZlcnMvbWVzc2FnZS9pMm8vZGV2aWNlLmMKQEAgLTY1LDcgKzY1LDcgQEAKIAogCXJjID0gaTJvX2RldmljZV9pc3N1ZV9jbGFpbShkZXYsIEkyT19DTURfVVRJTF9DTEFJTSwgSTJPX0NMQUlNX1BSSU1BUlkpOwogCWlmICghcmMpCi0JCXByX2RlYnVnKCJpMm86IGNsYWltIG9mIGRldmljZSAlZCBzdWNjZWRlZFxuIiwKKwkJcHJfZGVidWcoImkybzogY2xhaW0gb2YgZGV2aWNlICVkIHN1Y2NlZWRlZFxuIiwKIAkJCSBkZXYtPmxjdF9kYXRhLnRpZCk7CiAJZWxzZQogCQlwcl9kZWJ1ZygiaTJvOiBjbGFpbSBvZiBkZXZpY2UgJWQgZmFpbGVkICVkXG4iLApAQCAtMTEwLDcgKzExMCw3IEBACiAJfQogCiAJaWYgKCFyYykKLQkJcHJfZGVidWcoImkybzogY2xhaW0gcmVsZWFzZSBvZiBkZXZpY2UgJWQgc3VjY2VkZWRcbiIsCisJCXByX2RlYnVnKCJpMm86IGNsYWltIHJlbGVhc2Ugb2YgZGV2aWNlICVkIHN1Y2NlZWRlZFxuIiwKIAkJCSBkZXYtPmxjdF9kYXRhLnRpZCk7CiAJZWxzZQogCQlwcl9kZWJ1ZygiaTJvOiBjbGFpbSByZWxlYXNlIG9mIGRldmljZSAlZCBmYWlsZWQgJWRcbiIsCkBAIC0yNDgsNyArMjQ4LDcgQEAKIAkJCWdvdG8gdW5yZWdfZGV2OwogCX0KIAotCS8qIGNyZWF0ZSB1c2VyIGVudHJpZXMgcmVmZXJpbmcgdG8gdGhpcyBkZXZpY2UgKi8KKwkvKiBjcmVhdGUgdXNlciBlbnRyaWVzIHJlZmVycmluZyB0byB0aGlzIGRldmljZSAqLwogCWxpc3RfZm9yX2VhY2hfZW50cnkodG1wLCAmYy0+ZGV2aWNlcywgbGlzdCkKIAkgICAgaWYgKCh0bXAtPmxjdF9kYXRhLnVzZXJfdGlkID09IGkyb19kZXYtPmxjdF9kYXRhLnRpZCkKIAkJJiYgKHRtcCAhPSBpMm9fZGV2KSkgewpAQCAtMjY3LDcgKzI2Nyw3IEBACiAJCQlnb3RvIHJtbGluazE7CiAJfQogCi0JLyogY3JlYXRlIHBhcmVudCBlbnRyaWVzIHJlZmVyaW5nIHRvIHRoaXMgZGV2aWNlICovCisJLyogY3JlYXRlIHBhcmVudCBlbnRyaWVzIHJlZmVycmluZyB0byB0aGlzIGRldmljZSAqLwogCWxpc3RfZm9yX2VhY2hfZW50cnkodG1wLCAmYy0+ZGV2aWNlcywgbGlzdCkKIAkgICAgaWYgKCh0bXAtPmxjdF9kYXRhLnBhcmVudF90aWQgPT0gaTJvX2Rldi0+bGN0X2RhdGEudGlkKQogCQkmJiAodG1wICE9IGkyb19kZXYpKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lc3NhZ2UvaTJvL2kyb19ibG9jay5jIGIvZHJpdmVycy9tZXNzYWdlL2kyby9pMm9fYmxvY2suYwppbmRleCA0N2VjNWJjLi42NDNhZDUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lc3NhZ2UvaTJvL2kyb19ibG9jay5jCisrKyBiL2RyaXZlcnMvbWVzc2FnZS9pMm8vaTJvX2Jsb2NrLmMKQEAgLTYxMCw3ICs2MTAsNyBAQAogCiAJLyoKIAkgKiBUaGlzIGlzIHRvIGRlYWlsIHdpdGggdGhlIGNhc2Ugb2YgYW4gYXBwbGljYXRpb24KLQkgKiBvcGVuaW5nIGEgZGV2aWNlIGFuZCB0aGVuIHRoZSBkZXZpY2UgZGlzc2FwZWFycyB3aGlsZQorCSAqIG9wZW5pbmcgYSBkZXZpY2UgYW5kIHRoZW4gdGhlIGRldmljZSBkaXNhcHBlYXJzIHdoaWxlCiAJICogaXQncyBpbiB1c2UsIGFuZCB0aGVuIHRoZSBhcHBsaWNhdGlvbiB0cmllcyB0byByZWxlYXNlCiAJICogaXQuICBleDogVW5tb3VudGluZyBhIGRlbGV0ZWQgUkFJRCB2b2x1bWUgYXQgcmVib290LgogCSAqIElmIHdlIHNlbmQgbWVzc2FnZXMsIGl0IHdpbGwganVzdCBjYXVzZSBGQUlMcyBzaW5jZQpAQCAtNzE3LDcgKzcxNyw3IEBACiAKIC8qKgogICoJaTJvX2Jsb2NrX3RyYW5zZmVyIC0gVHJhbnNmZXIgYSByZXF1ZXN0IHRvL2Zyb20gdGhlIEkyTyBjb250cm9sbGVyCi0gKglAcmVxOiB0aGUgcmVxdWVzdCB3aGljaCBzaG91bGQgYmUgdHJhbnNmZXJlZAorICoJQHJlcTogdGhlIHJlcXVlc3Qgd2hpY2ggc2hvdWxkIGJlIHRyYW5zZmVycmVkCiAgKgogICoJVGhpcyBmdW5jdGlvbiBjb252ZXJ0cyB0aGUgcmVxdWVzdCBpbnRvIGEgSTJPIG1lc3NhZ2UuIFRoZSBuZWNlc3NhcnkKICAqCURNQSBidWZmZXJzIGFyZSBhbGxvY2F0ZWQgYW5kIGFmdGVyIGV2ZXJ5dGhpbmcgaXMgc2V0dXAgcG9zdCB0aGUgbWVzc2FnZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZXNzYWdlL2kyby9pMm9fYmxvY2suaCBiL2RyaXZlcnMvbWVzc2FnZS9pMm8vaTJvX2Jsb2NrLmgKaW5kZXggNjdmOTIxYi4uY2Y4ODczYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZXNzYWdlL2kyby9pMm9fYmxvY2suaAorKysgYi9kcml2ZXJzL21lc3NhZ2UvaTJvL2kyb19ibG9jay5oCkBAIC03Myw3ICs3Myw3IEBACiAJc3RydWN0IGkyb19kZXZpY2UgKmkyb19kZXY7CS8qIHBvaW50ZXIgdG8gSTJPIGRldmljZSAqLwogCXN0cnVjdCBnZW5kaXNrICpnZDsKIAlzcGlubG9ja190IGxvY2s7CS8qIHF1ZXVlIGxvY2sgKi8KLQlzdHJ1Y3QgbGlzdF9oZWFkIG9wZW5fcXVldWU7CS8qIGxpc3Qgb2YgdHJhbnNmZXJlZCwgYnV0IHVuZmluaXNoZWQKKwlzdHJ1Y3QgbGlzdF9oZWFkIG9wZW5fcXVldWU7CS8qIGxpc3Qgb2YgdHJhbnNmZXJyZWQsIGJ1dCB1bmZpbmlzaGVkCiAJCQkJCSAgIHJlcXVlc3RzICovCiAJdW5zaWduZWQgaW50IG9wZW5fcXVldWVfZGVwdGg7CS8qIG51bWJlciBvZiByZXF1ZXN0cyBpbiB0aGUgcXVldWUgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZXNzYWdlL2kyby9pMm9fc2NzaS5jIGIvZHJpdmVycy9tZXNzYWdlL2kyby9pMm9fc2NzaS5jCmluZGV4IDk3YmRmODIuLmYwMDM5NTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVzc2FnZS9pMm8vaTJvX3Njc2kuYworKysgYi9kcml2ZXJzL21lc3NhZ2UvaTJvL2kyb19zY3NpLmMKQEAgLTIwNCw3ICsyMDQsNyBAQAogICoJaTJvX3Njc2lfcHJvYmUgLSB2ZXJpZnkgaWYgZGV2IGlzIGEgSTJPIFNDU0kgZGV2aWNlIGFuZCBpbnN0YWxsIGl0CiAgKglAZGV2OiBkZXZpY2UgdG8gdmVyaWZ5IGlmIGl0IGlzIGEgSTJPIFNDU0kgZGV2aWNlCiAgKgotICoJUmV0cmlldmUgY2hhbm5lbCwgaWQgYW5kIGx1biBmb3IgSTJPIGRldmljZS4gSWYgZXZlcnRoaW5nIGdvZXMgd2VsbAorICoJUmV0cmlldmUgY2hhbm5lbCwgaWQgYW5kIGx1biBmb3IgSTJPIGRldmljZS4gSWYgZXZlcnl0aGluZyBnb2VzIHdlbGwKICAqCXJlZ2lzdGVyIHRoZSBJMk8gZGV2aWNlIGFzIFNDU0kgZGV2aWNlIG9uIHRoZSBJMk8gU0NTSSBjb250cm9sbGVyLgogICoKICAqCVJldHVybnMgMCBvbiBzdWNjZXNzIG9yIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL0tjb25maWcgYi9kcml2ZXJzL21mZC9LY29uZmlnCmluZGV4IGUyZmVhNTguLjNlZDNmZjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL0tjb25maWcKKysrIGIvZHJpdmVycy9tZmQvS2NvbmZpZwpAQCAtMjAxLDcgKzIwMSw3IEBACiAJICBhcyBjbG9jayByZXF1ZXN0IGhhbmRzaGFraW5nLgogCiAJICBUaGlzIGRyaXZlciB1c2VzIGJvYXJkLXNwZWNpZmljIGRhdGEgdG8gaW5pdGlhbGl6ZSB0aGUgcmVzb3VyY2VzCi0JICBhbmQgbG9hZCBzY3JpcHRzIGNvbnRyb2xpbmcgd2hpY2ggcmVzb3VyY2VzIGFyZSBzd2l0Y2hlZCBvZmYvb24KKwkgIGFuZCBsb2FkIHNjcmlwdHMgY29udHJvbGxpbmcgd2hpY2ggcmVzb3VyY2VzIGFyZSBzd2l0Y2hlZCBvZmYvb24KIAkgIG9yIHJlc2V0IHdoZW4gYSBzbGVlcCwgd2FrZXVwIG9yIHdhcm0gcmVzZXQgZXZlbnQgb2NjdXJzLgogCiBjb25maWcgVFdMNDAzMF9DT0RFQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvYWI4NTAwLWdwYWRjLmMgYi9kcml2ZXJzL21mZC9hYjg1MDAtZ3BhZGMuYwppbmRleCBiYzkzYjJlLi42NDIxYWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9hYjg1MDAtZ3BhZGMuYworKysgYi9kcml2ZXJzL21mZC9hYjg1MDAtZ3BhZGMuYwpAQCAtMzE0LDcgKzMxNCw3IEBACiAJLyogd2FpdCBmb3IgY29tcGxldGlvbiBvZiBjb252ZXJzaW9uICovCiAJaWYgKCF3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmdwYWRjLT5hYjg1MDBfZ3BhZGNfY29tcGxldGUsIDIqSFopKSB7CiAJCWRldl9lcnIoZ3BhZGMtPmRldiwKLQkJCSJ0aW1lb3V0OiBkaWRudCByZWNpZXZlIEdQQURDIGNvbnZlcnNpb24gaW50ZXJydXB0XG4iKTsKKwkJCSJ0aW1lb3V0OiBkaWRuJ3QgcmVjZWl2ZSBHUEFEQyBjb252ZXJzaW9uIGludGVycnVwdFxuIik7CiAJCXJldCA9IC1FSU5WQUw7CiAJCWdvdG8gb3V0OwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL2V6eC1wY2FwLmMgYi9kcml2ZXJzL21mZC9lengtcGNhcC5jCmluZGV4IGYyZjQwMjkuLjQzYTc2YzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL2V6eC1wY2FwLmMKKysrIGIvZHJpdmVycy9tZmQvZXp4LXBjYXAuYwpAQCAtMTg1LDcgKzE4NSw3IEBACiAJCWV6eF9wY2FwX3JlYWQocGNhcCwgUENBUF9SRUdfTVNSLCAmbXNyKTsKIAkJZXp4X3BjYXBfcmVhZChwY2FwLCBQQ0FQX1JFR19JU1IsICZpc3IpOwogCi0JCS8qIFdlIGNhbnQgc2VydmljZS9hY2sgaXJxcyB0aGF0IGFyZSBhc3NpZ25lZCB0byBwb3J0IDIgKi8KKwkJLyogV2UgY2FuJ3Qgc2VydmljZS9hY2sgaXJxcyB0aGF0IGFyZSBhc3NpZ25lZCB0byBwb3J0IDIgKi8KIAkJaWYgKCEocGRhdGEtPmNvbmZpZyAmIFBDQVBfU0VDT05EX1BPUlQpKSB7CiAJCQllenhfcGNhcF9yZWFkKHBjYXAsIFBDQVBfUkVHX0lOVF9TRUwsICZpbnRfc2VsKTsKIAkJCWlzciAmPSB+aW50X3NlbDsKQEAgLTQ1Nyw3ICs0NTcsNyBAQAogCXBjYXAtPndvcmtxdWV1ZSA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJwY2FwZCIpOwogCWlmICghcGNhcC0+d29ya3F1ZXVlKSB7CiAJCXJldCA9IC1FTk9NRU07Ci0JCWRldl9lcnIoJnNwaS0+ZGV2LCAiY2FudCBjcmVhdGUgcGNhcCB0aHJlYWRcbiIpOworCQlkZXZfZXJyKCZzcGktPmRldiwgImNhbid0IGNyZWF0ZSBwY2FwIHRocmVhZFxuIik7CiAJCWdvdG8gZnJlZV9wY2FwOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvb21hcC11c2ItaG9zdC5jIGIvZHJpdmVycy9tZmQvb21hcC11c2ItaG9zdC5jCmluZGV4IGNiMDEyMDkuLjUzNDUwZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL29tYXAtdXNiLWhvc3QuYworKysgYi9kcml2ZXJzL21mZC9vbWFwLXVzYi1ob3N0LmMKQEAgLTMzMiw3ICszMzIsNyBAQAogCWludAkJCQlpOwogCiAJaWYgKCFwZGF0YSkgewotCQlkZXZfZXJyKGRldiwgIk1pc3NpbmcgcGxhdGZyb20gZGF0YVxuIik7CisJCWRldl9lcnIoZGV2LCAiTWlzc2luZyBwbGF0Zm9ybSBkYXRhXG4iKTsKIAkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBlbmRfcHJvYmU7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvcGNmNTA2MzMtY29yZS5jIGIvZHJpdmVycy9tZmQvcGNmNTA2MzMtY29yZS5jCmluZGV4IGM3Njg3ZjYuLjU3ODY4NDE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9wY2Y1MDYzMy1jb3JlLmMKKysrIGIvZHJpdmVycy9tZmQvcGNmNTA2MzMtY29yZS5jCkBAIC01MSw3ICs1MSw3IEBACiAKIH0KIAotLyogUmVhZCBhIGJsb2NrIG9mIHVwdG8gMzIgcmVncyAgKi8KKy8qIFJlYWQgYSBibG9jayBvZiB1cCB0byAzMiByZWdzICAqLwogaW50IHBjZjUwNjMzX3JlYWRfYmxvY2soc3RydWN0IHBjZjUwNjMzICpwY2YsIHU4IHJlZywKIAkJCQkJaW50IG5yX3JlZ3MsIHU4ICpkYXRhKQogewpAQCAtNjUsNyArNjUsNyBAQAogfQogRVhQT1JUX1NZTUJPTF9HUEwocGNmNTA2MzNfcmVhZF9ibG9jayk7CiAKLS8qIFdyaXRlIGEgYmxvY2sgb2YgdXB0byAzMiByZWdzICAqLworLyogV3JpdGUgYSBibG9jayBvZiB1cCB0byAzMiByZWdzICAqLwogaW50IHBjZjUwNjMzX3dyaXRlX2Jsb2NrKHN0cnVjdCBwY2Y1MDYzMyAqcGNmICwgdTggcmVnLAogCQkJCQlpbnQgbnJfcmVncywgdTggKmRhdGEpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC90d2w2MDMwLWlycS5jIGIvZHJpdmVycy9tZmQvdHdsNjAzMC1pcnEuYwppbmRleCBmYTkzNzA1Li5kZmJhZTM0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC90d2w2MDMwLWlycS5jCisrKyBiL2RyaXZlcnMvbWZkL3R3bDYwMzAtaXJxLmMKQEAgLTIyOSw3ICsyMjksNyBAQAogCXR3bDYwMzBfaW50ZXJydXB0X3VubWFzayhUV0w2MDMwX01NQ0RFVEVDVF9JTlRfTUFTSywKIAkJCQkJCVJFR19JTlRfTVNLX1NUU19CKTsKIAkvKgotCSAqIEludGlhbGx5IENvbmZpZ3VyaW5nIE1NQ19DVFJMIGZvciByZWNldmluZyBpbnRlcnJ1cHRzICYKKwkgKiBJbml0aWFsbHkgQ29uZmlndXJpbmcgTU1DX0NUUkwgZm9yIHJlY2VpdmluZyBpbnRlcnJ1cHRzICYKIAkgKiBDYXJkIHN0YXR1cyBvbiBUV0w2MDMwIGZvciBNTUMxCiAJICovCiAJcmV0ID0gdHdsX2kyY19yZWFkX3U4KFRXTDYwMzBfTU9EVUxFX0lEMCwgJnJlZ192YWwsIFRXTDYwMzBfTU1DQ1RSTCk7CkBAIC0yNzUsNyArMjc1LDcgQEAKIAkJLyogVFdMNjAzMCBwcm92aWRlJ3MgQ2FyZCBkZXRlY3Qgc3VwcG9ydCBmb3IKIAkJICogb25seSBNTUMxIGNvbnRyb2xsZXIuCiAJCSAqLwotCQlwcl9lcnIoIlVua293biBNTUMgY29udHJvbGxlciAlZCBpbiAlc1xuIiwgcGRldi0+aWQsIF9fZnVuY19fKTsKKwkJcHJfZXJyKCJVbmtub3duIE1NQyBjb250cm9sbGVyICVkIGluICVzXG4iLCBwZGV2LT5pZCwgX19mdW5jX18pOwogCQlyZXR1cm4gcmV0OwogCX0KIAkvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvdWNiMTQwMF9jb3JlLmMgYi9kcml2ZXJzL21mZC91Y2IxNDAwX2NvcmUuYwppbmRleCBkNzNmODRiLi5kYWY2OTUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC91Y2IxNDAwX2NvcmUuYworKysgYi9kcml2ZXJzL21mZC91Y2IxNDAwX2NvcmUuYwpAQCAtOCw3ICs4LDcgQEAKICAqICBDb3B5cmlnaHQ6CU1vbnRhVmlzdGEgU29mdHdhcmUsIEluYy4KICAqCiAgKiBTcGxpdGluZyBkb25lIGJ5OiBNYXJlayBWYXN1dCA8bWFyZWsudmFzdXRAZ21haWwuY29tPgotICogSWYgc29tZXRoaW5nIGRvZXNudCB3b3JrIGFuZCBpdCB3b3JrZWQgYmVmb3JlIHNwbGl0aW5nLCBlLW1haWwgbWUsCisgKiBJZiBzb21ldGhpbmcgZG9lc24ndCB3b3JrIGFuZCBpdCB3b3JrZWQgYmVmb3JlIHNwbGl0aW5nLCBlLW1haWwgbWUsCiAgKiBkb250IGJvdGhlciBOaWNvbGFzIHBsZWFzZSA7LSkKICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL2JtcDA4NS5jIGIvZHJpdmVycy9taXNjL2JtcDA4NS5jCmluZGV4IGVjZDI3NmEuLjVmODk4Y2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9ibXAwODUuYworKysgYi9kcml2ZXJzL21pc2MvYm1wMDg1LmMKQEAgLTIsNyArMiw3IEBACiAKICAgICBUaGlzIGRyaXZlciBzdXBwb3J0cyB0aGUgYm1wMDg1IGRpZ2l0YWwgYmFyb21ldHJpYyBwcmVzc3VyZQogICAgIGFuZCB0ZW1wZXJhdHVyZSBzZW5zb3IgZnJvbSBCb3NjaCBTZW5zb3J0ZWMuIFRoZSBkYXRhc2hlZXQKLSAgICBpcyBhdmFsaWFibGUgZnJvbSB0aGVpciB3ZWJzaXRlOgorICAgIGlzIGF2YWlsYWJsZSBmcm9tIHRoZWlyIHdlYnNpdGU6CiAgICAgaHR0cDovL3d3dy5ib3NjaC1zZW5zb3J0ZWMuY29tL2NvbnRlbnQvbGFuZ3VhZ2UxL2Rvd25sb2Fkcy9CU1QtQk1QMDg1LURTMDAwLTA1LnBkZgogCiAgICAgQSBwcmVzc3VyZSBtZWFzdXJlbWVudCBpcyBpc3N1ZWQgYnkgcmVhZGluZyBmcm9tIHByZXNzdXJlMF9pbnB1dC4KQEAgLTQyOSw3ICs0MjksNyBAQAogCWlmIChlcnIpCiAJCWdvdG8gZXhpdF9mcmVlOwogCi0JZGV2X2luZm8oJmRhdGEtPmNsaWVudC0+ZGV2LCAiU3VjY2VzZnVsbHkgaW5pdGlhbGl6ZWQgYm1wMDg1IVxuIik7CisJZGV2X2luZm8oJmRhdGEtPmNsaWVudC0+ZGV2LCAiU3VjY2Vzc2Z1bGx5IGluaXRpYWxpemVkIGJtcDA4NSFcbiIpOwogCWdvdG8gZXhpdDsKIAogZXhpdF9mcmVlOgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL2MycG9ydC9jMnBvcnQtZHVyYW1hcjIxNTAuYyBiL2RyaXZlcnMvbWlzYy9jMnBvcnQvYzJwb3J0LWR1cmFtYXIyMTUwLmMKaW5kZXggMzM4ZGNjMS4uNzc4ZmMzZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9taXNjL2MycG9ydC9jMnBvcnQtZHVyYW1hcjIxNTAuYworKysgYi9kcml2ZXJzL21pc2MvYzJwb3J0L2MycG9ydC1kdXJhbWFyMjE1MC5jCkBAIC00MSw3ICs0MSw3IEBACiAJCW91dGIodiB8IChDMkQgfCBDMkNLKSwgRElSX1BPUlQpOwogCWVsc2UKIAkJLyogV2hlbiBhY2Nlc3MgaXMgIm9mZiIgaXMgaW1wb3J0YW50IHRoYXQgYm90aCBsaW5lcyBhcmUgc2V0Ci0JCSAqIGFzIGlucHV0cyBvciBoaS1pbXBlZGVuY2UgKi8KKwkJICogYXMgaW5wdXRzIG9yIGhpLWltcGVkYW5jZSAqLwogCQlvdXRiKHYgJiB+KEMyRCB8IEMyQ0spLCBESVJfUE9SVCk7CiAKIAltdXRleF91bmxvY2soJnVwZGF0ZV9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9pYm1hc20vcmVtb3RlLmggYi9kcml2ZXJzL21pc2MvaWJtYXNtL3JlbW90ZS5oCmluZGV4IDcyYWNmNWEuLjAwZGJmMWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9pYm1hc20vcmVtb3RlLmgKKysrIGIvZHJpdmVycy9taXNjL2libWFzbS9yZW1vdGUuaApAQCAtMjAsNyArMjAsNyBAQAogICoKICAqIEF1dGhvcjogTWF4IEFzYvZjayA8YW1heEB1cy5pYm0uY29tPgogICoKLSAqIE9yaWduYWxseSB3cml0dGVuIGJ5IFBldGUgUmV5bm9sZHMKKyAqIE9yaWdpbmFsbHkgd3JpdHRlbiBieSBQZXRlIFJleW5vbGRzCiAgKi8KIAogI2lmbmRlZiBfSUJNQVNNX1JFTU9URV9IXwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL2l3bWMzMjAwdG9wL21haW4uYyBiL2RyaXZlcnMvbWlzYy9pd21jMzIwMHRvcC9tYWluLmMKaW5kZXggNzI3YWYwNy4uYjFmNDU2MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9taXNjL2l3bWMzMjAwdG9wL21haW4uYworKysgYi9kcml2ZXJzL21pc2MvaXdtYzMyMDB0b3AvbWFpbi5jCkBAIC0yNjgsNyArMjY4LDcgQEAKIAkJTE9HX0lORk8ocHJpdiwgSVJRLCAiQUNLIGJhcmtlciBhcnJpdmVkICIKIAkJCQkiLSBzdGFydGluZyBGVyBkb3dubG9hZFxuIik7CiAJfSBlbHNlIHsgLyogUkVCT09UIGJhcmtlciAqLwotCQlMT0dfSU5GTyhwcml2LCBJUlEsICJSZWNpZXZlZCByZWJvb3QgYmFya2VyOiAleFxuIiwgYmFya2VyKTsKKwkJTE9HX0lORk8ocHJpdiwgSVJRLCAiUmVjZWl2ZWQgcmVib290IGJhcmtlcjogJXhcbiIsIGJhcmtlcik7CiAJCXByaXYtPmJhcmtlciA9IGJhcmtlcjsKIAogCQlpZiAoYmFya2VyICYgQkFSS0VSX0ROTE9BRF9TWU5DX01TSykgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL2tnZGJ0cy5jIGIvZHJpdmVycy9taXNjL2tnZGJ0cy5jCmluZGV4IDI3ZGM0NjMuLjc0ZjE2ZjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9rZ2RidHMuYworKysgYi9kcml2ZXJzL21pc2Mva2dkYnRzLmMKQEAgLTY0NSw3ICs2NDUsNyBAQAogCiAJd2hpbGUgKCpjaGtfc3RyICE9ICdcMCcgJiYgKnB1dF9zdHIgIT0gJ1wwJykgewogCQkvKiBJZiBzb21lb25lIGRvZXMgYSAqIHRvIG1hdGNoIHRoZSByZXN0IG9mIHRoZSBzdHJpbmcsIGFsbG93Ci0JCSAqIGl0LCBvciBzdG9wIGlmIHRoZSByZWNpZXZlZCBzdHJpbmcgaXMgY29tcGxldGUuCisJCSAqIGl0LCBvciBzdG9wIGlmIHRoZSByZWNlaXZlZCBzdHJpbmcgaXMgY29tcGxldGUuCiAJCSAqLwogCQlpZiAoKnB1dF9zdHIgPT0gJyMnIHx8ICpjaGtfc3RyID09ICcqJykKIAkJCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL3NnaS1ncnUvZ3J1a3NlcnZpY2VzLmMgYi9kcml2ZXJzL21pc2Mvc2dpLWdydS9ncnVrc2VydmljZXMuYwppbmRleCAzNDc0OWVlLi45ZTliZGRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21pc2Mvc2dpLWdydS9ncnVrc2VydmljZXMuYworKysgYi9kcml2ZXJzL21pc2Mvc2dpLWdydS9ncnVrc2VydmljZXMuYwpAQCAtMjI5LDcgKzIyOSw3IEBACiAJYmlkID0gYmxhZGVfaWQgPCAwID8gdXZfbnVtYV9ibGFkZV9pZCgpIDogYmxhZGVfaWQ7CiAJYnMgPSBncnVfYmFzZVtiaWRdOwogCi0JLyogSGFuZGxlIHRoZSBjYXNlIHdoZXJlIG1pZ3JhdGlvbiBvY2N1cmVkIHdoaWxlIHdhaXRpbmcgZm9yIHRoZSBzZW1hICovCisJLyogSGFuZGxlIHRoZSBjYXNlIHdoZXJlIG1pZ3JhdGlvbiBvY2N1cnJlZCB3aGlsZSB3YWl0aW5nIGZvciB0aGUgc2VtYSAqLwogCWRvd25fcmVhZCgmYnMtPmJzX2tndHNfc2VtYSk7CiAJaWYgKGJsYWRlX2lkIDwgMCAmJiBiaWQgIT0gdXZfbnVtYV9ibGFkZV9pZCgpKSB7CiAJCXVwX3JlYWQoJmJzLT5ic19rZ3RzX3NlbWEpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL3NnaS1ncnUvZ3J1dGFibGVzLmggYi9kcml2ZXJzL21pc2Mvc2dpLWdydS9ncnV0YWJsZXMuaAppbmRleCA3YThiOTA2Li41YzNjZTI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21pc2Mvc2dpLWdydS9ncnV0YWJsZXMuaAorKysgYi9kcml2ZXJzL21pc2Mvc2dpLWdydS9ncnV0YWJsZXMuaApAQCAtMzc5LDcgKzM3OSw3IEBACiAJCQkJCQkgICByZXF1aXJlZCBmb3IgY29udGVzdCAqLwogCWNoYXIJCQl0c19jY2hfcmVxX3NsaWNlOy8qIENDSCBwYWNrZXQgc2xpY2UgKi8KIAljaGFyCQkJdHNfYmxhZGU7CS8qIElmID49IDAsIG1pZ3JhdGUgY29udGV4dCBpZgotCQkJCQkJICAgcmVmIGZyb20gZGlmZXJlbnQgYmxhZGUgKi8KKwkJCQkJCSAgIHJlZiBmcm9tIGRpZmZlcmVudCBibGFkZSAqLwogCWNoYXIJCQl0c19mb3JjZV9jY2hfcmVsb2FkOwogCWNoYXIJCQl0c19jYnJfaWR4W0dSVV9DQlJfQVVdOy8qIENCUiBudW1iZXJzIG9mIGVhY2gKIAkJCQkJCQkgIGFsbG9jYXRlZCBDQiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL3RpLXN0L3N0X2tpbS5jIGIvZHJpdmVycy9taXNjL3RpLXN0L3N0X2tpbS5jCmluZGV4IDllZTRjNzguLmI0NDg4YzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy90aS1zdC9zdF9raW0uYworKysgYi9kcml2ZXJzL21pc2MvdGktc3Qvc3Rfa2ltLmMKQEAgLTY0OSw3ICs2NDksNyBAQAogCQkvKiBtdWx0aXBsZSBkZXZpY2VzIGNvdWxkIGV4aXN0ICovCiAJCXN0X2tpbV9kZXZpY2VzW3BkZXYtPmlkXSA9IHBkZXY7CiAJfSBlbHNlIHsKLQkJLyogcGxhdGZvcm0ncyBzdXJlIGFib3V0IGV4aXN0YW5jZSBvZiAxIGRldmljZSAqLworCQkvKiBwbGF0Zm9ybSdzIHN1cmUgYWJvdXQgZXhpc3RlbmNlIG9mIDEgZGV2aWNlICovCiAJCXN0X2tpbV9kZXZpY2VzWzBdID0gcGRldjsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1jL2NhcmQvbW1jX3Rlc3QuYyBiL2RyaXZlcnMvbW1jL2NhcmQvbW1jX3Rlc3QuYwppbmRleCBmNWNlZGVjLi5hYmMxYTYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9jYXJkL21tY190ZXN0LmMKKysrIGIvZHJpdmVycy9tbWMvY2FyZC9tbWNfdGVzdC5jCkBAIC0yOTIsNyArMjkyLDcgQEAKIH0KIAogLyoKLSAqIEFsbG9jYXRlIGEgbG90IG9mIG1lbW9yeSwgcHJlZmVycmFibHkgbWF4X3N6IGJ1dCBhdCBsZWFzdCBtaW5fc3ouICBJbiBjYXNlCisgKiBBbGxvY2F0ZSBhIGxvdCBvZiBtZW1vcnksIHByZWZlcmFibHkgbWF4X3N6IGJ1dCBhdCBsZWFzdCBtaW5fc3ouICBJbiBjYXNlCiAgKiB0aGVyZSBpc24ndCBtdWNoIG1lbW9yeSBkbyBub3QgZXhjZWVkIDEvMTZ0aCB0b3RhbCBsb3dtZW0gcGFnZXMuICBBbHNvIGRvCiAgKiBub3QgZXhjZWVkIGEgbWF4aW11bSBudW1iZXIgb2Ygc2VnbWVudHMgYW5kIHRyeSBub3QgdG8gbWFrZSBzZWdtZW50cyBtdWNoCiAgKiBiaWdnZXIgdGhhbiBtYXhpbXVtIHNlZ21lbnQgc2l6ZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1jL2NvcmUvbW1jLmMgYi9kcml2ZXJzL21tYy9jb3JlL21tYy5jCmluZGV4IDE0ZTk1ZjMuLjc3MmQwZDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2NvcmUvbW1jLmMKKysrIGIvZHJpdmVycy9tbWMvY29yZS9tbWMuYwpAQCAtNTM4LDcgKzUzOCw3IEBACiAKIAkvKgogCSAqIElmIGVuaGFuY2VkX2FyZWFfZW4gaXMgVFJVRSwgaG9zdCBuZWVkcyB0byBlbmFibGUgRVJBU0VfR1JQX0RFRgotCSAqIGJpdC4gIFRoaXMgYml0IHdpbGwgYmUgbG9zdCBldmVyeXRpbWUgYWZ0ZXIgYSByZXNldCBvciBwb3dlciBvZmYuCisJICogYml0LiAgVGhpcyBiaXQgd2lsbCBiZSBsb3N0IGV2ZXJ5IHRpbWUgYWZ0ZXIgYSByZXNldCBvciBwb3dlciBvZmYuCiAJICovCiAJaWYgKGNhcmQtPmV4dF9jc2QuZW5oYW5jZWRfYXJlYV9lbikgewogCQllcnIgPSBtbWNfc3dpdGNoKGNhcmQsIEVYVF9DU0RfQ01EX1NFVF9OT1JNQUwsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL21tY19vcHMuYyBiL2RyaXZlcnMvbW1jL2NvcmUvbW1jX29wcy5jCmluZGV4IDYwODQyZjguLmYzYjIyYmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2NvcmUvbW1jX29wcy5jCisrKyBiL2RyaXZlcnMvbW1jL2NvcmUvbW1jX29wcy5jCkBAIC0xMDUsNyArMTA1LDcgQEAKIAkgKiB0aGF0IGluIGNhc2Ugb2YgaGFyZHdhcmUgdGhhdCB3b24ndCBwdWxsIHVwIERBVDMvbkNTIG90aGVyd2lzZS4KIAkgKgogCSAqIFNQSSBob3N0cyBpZ25vcmUgaW9zLmNoaXBfc2VsZWN0OyBpdCdzIG1hbmFnZWQgYWNjb3JkaW5nIHRvCi0JICogcnVsZXMgdGhhdCBtdXN0IGFjY29tb2RhdGUgbm9uLU1NQyBzbGF2ZXMgd2hpY2ggdGhpcyBsYXllcgorCSAqIHJ1bGVzIHRoYXQgbXVzdCBhY2NvbW1vZGF0ZSBub24tTU1DIHNsYXZlcyB3aGljaCB0aGlzIGxheWVyCiAJICogd29uJ3QgZXZlbiBrbm93IGFib3V0LgogCSAqLwogCWlmICghbW1jX2hvc3RfaXNfc3BpKGhvc3QpKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL3NkaW9faXJxLmMgYi9kcml2ZXJzL21tYy9jb3JlL3NkaW9faXJxLmMKaW5kZXggYmIxOTJmOS4uYjMwMDE2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9zZGlvX2lycS5jCisrKyBiL2RyaXZlcnMvbW1jL2NvcmUvc2Rpb19pcnEuYwpAQCAtNDUsNyArNDUsNyBAQAogCQkJc3RydWN0IHNkaW9fZnVuYyAqZnVuYyA9IGNhcmQtPnNkaW9fZnVuY1tpIC0gMV07CiAJCQlpZiAoIWZ1bmMpIHsKIAkJCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogcGVuZGluZyBJUlEgZm9yICIKLQkJCQkJIm5vbi1leGlzdGFudCBmdW5jdGlvblxuIiwKKwkJCQkJIm5vbi1leGlzdGVudCBmdW5jdGlvblxuIiwKIAkJCQkJbW1jX2NhcmRfaWQoY2FyZCkpOwogCQkJCXJldCA9IC1FSU5WQUw7CiAJCQl9IGVsc2UgaWYgKGZ1bmMtPmlycV9oYW5kbGVyKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9ob3N0L2F0bWVsLW1jaS5jIGIvZHJpdmVycy9tbWMvaG9zdC9hdG1lbC1tY2kuYwppbmRleCA4MGJjOWE1Li5lYTM4ODhiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L2F0bWVsLW1jaS5jCisrKyBiL2RyaXZlcnMvbW1jL2hvc3QvYXRtZWwtbWNpLmMKQEAgLTEyNyw3ICsxMjcsNyBAQAogICogRVZFTlRfREFUQV9DT01QTEVURSBpcyBzZXQgaW4gQHBlbmRpbmdfZXZlbnRzLCBhbGwgZGF0YS1yZWxhdGVkCiAgKiBpbnRlcnJ1cHRzIG11c3QgYmUgZGlzYWJsZWQgYW5kIEBkYXRhX3N0YXR1cyB1cGRhdGVkIHdpdGggYQogICogc25hcHNob3Qgb2YgU1IuIFNpbWlsYXJseSwgYmVmb3JlIEVWRU5UX0NNRF9DT01QTEVURSBpcyBzZXQsIHRoZQotICogQ01EUkRZIGludGVydXB0IG11c3QgYmUgZGlzYWJsZWQgYW5kIEBjbWRfc3RhdHVzIHVwZGF0ZWQgd2l0aCBhCisgKiBDTURSRFkgaW50ZXJydXB0IG11c3QgYmUgZGlzYWJsZWQgYW5kIEBjbWRfc3RhdHVzIHVwZGF0ZWQgd2l0aCBhCiAgKiBzbmFwc2hvdCBvZiBTUiwgYW5kIGJlZm9yZSBFVkVOVF9YRkVSX0NPTVBMRVRFIGNhbiBiZSBzZXQsIHRoZQogICogYnl0ZXNfeGZlcmVkIGZpZWxkIG9mIEBkYXRhIG11c3QgYmUgd3JpdHRlbi4gVGhpcyBpcyBlbnN1cmVkIGJ5CiAgKiB1c2luZyBiYXJyaWVycy4KQEAgLTEwODIsNyArMTA4Miw3IEBACiAJLyoKIAkgKiBVcGRhdGUgdGhlIE1NQyBjbG9jayByYXRlIGlmIG5lY2Vzc2FyeS4gVGhpcyBtYXkgYmUKIAkgKiBuZWNlc3NhcnkgaWYgc2V0X2lvcygpIGlzIGNhbGxlZCB3aGVuIGEgZGlmZmVyZW50IHNsb3QgaXMKLQkgKiBidXN5IHRyYW5zZmVyaW5nIGRhdGEuCisJICogYnVzeSB0cmFuc2ZlcnJpbmcgZGF0YS4KIAkgKi8KIAlpZiAoaG9zdC0+bmVlZF9jbG9ja191cGRhdGUpIHsKIAkJbWNpX3dyaXRlbChob3N0LCBNUiwgaG9zdC0+bW9kZV9yZWcpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC9tbWNfc3BpLmMgYi9kcml2ZXJzL21tYy9ob3N0L21tY19zcGkuYwppbmRleCAyZjdmYzBjLi43YzFlMTZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L21tY19zcGkuYworKysgYi9kcml2ZXJzL21tYy9ob3N0L21tY19zcGkuYwpAQCAtOTksNyArOTksNyBAQAogI2RlZmluZSByMWJfdGltZW91dAkJKEhaICogMykKIAogLyogT25lIG9mIHRoZSBjcml0aWNhbCBzcGVlZCBwYXJhbWV0ZXJzIGlzIHRoZSBhbW91bnQgb2YgZGF0YSB3aGljaCBtYXkKLSAqIGJlIHRyYW5zZmVyZWQgaW4gb25lIGNvbW1hbmQuIElmIHRoaXMgdmFsdWUgaXMgdG9vIGxvdywgdGhlIFNEIGNhcmQKKyAqIGJlIHRyYW5zZmVycmVkIGluIG9uZSBjb21tYW5kLiBJZiB0aGlzIHZhbHVlIGlzIHRvbyBsb3csIHRoZSBTRCBjYXJkCiAgKiBjb250cm9sbGVyIGhhcyB0byBkbyBtdWx0aXBsZSBwYXJ0aWFsIGJsb2NrIHdyaXRlcyAoYXJnZ2doISkuIFdpdGgKICAqIHRvZGF5ICgyMDA4KSBTRCBjYXJkcyB0aGVyZSBpcyBsaXR0bGUgc3BlZWQgZ2FpbiBpZiB3ZSB0cmFuc2ZlciBtb3JlCiAgKiB0aGFuIDY0IEtCeXRlcyBhdCBhIHRpbWUuIFNvIHVzZSB0aGlzIHZhbHVlIHVudGlsIHRoZXJlIGlzIGFueSBpbmRpY2F0aW9uCmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9ob3N0L3MzY21jaS5jIGIvZHJpdmVycy9tbWMvaG9zdC9zM2NtY2kuYwppbmRleCAxY2NkNGIyLi5hMDRmODdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L3MzY21jaS5jCisrKyBiL2RyaXZlcnMvbW1jL2hvc3QvczNjbWNpLmMKQEAgLTg3NCw3ICs4NzQsNyBAQAogCWlmICghbXJxLT5kYXRhKQogCQlnb3RvIHJlcXVlc3RfZG9uZTsKIAotCS8qIENhbHVsYXRlIHRoZSBhbW91dCBvZiBieXRlcyB0cmFuc2ZlciBpZiB0aGVyZSB3YXMgbm8gZXJyb3IgKi8KKwkvKiBDYWxjdWxhdGUgdGhlIGFtb3V0IG9mIGJ5dGVzIHRyYW5zZmVyIGlmIHRoZXJlIHdhcyBubyBlcnJvciAqLwogCWlmIChtcnEtPmRhdGEtPmVycm9yID09IDApIHsKIAkJbXJxLT5kYXRhLT5ieXRlc194ZmVyZWQgPQogCQkJKG1ycS0+ZGF0YS0+YmxvY2tzICogbXJxLT5kYXRhLT5ibGtzeik7CkBAIC04ODIsNyArODgyLDcgQEAKIAkJbXJxLT5kYXRhLT5ieXRlc194ZmVyZWQgPSAwOwogCX0KIAotCS8qIElmIHdlIGhhZCBhbiBlcnJvciB3aGlsZSB0cmFuc2ZlcmluZyBkYXRhIHdlIGZsdXNoIHRoZQorCS8qIElmIHdlIGhhZCBhbiBlcnJvciB3aGlsZSB0cmFuc2ZlcnJpbmcgZGF0YSB3ZSBmbHVzaCB0aGUKIAkgKiBETUEgY2hhbm5lbCBhbmQgdGhlIGZpZm8gdG8gY2xlYXIgb3V0IGFueSBnYXJiYWdlLiAqLwogCWlmIChtcnEtPmRhdGEtPmVycm9yICE9IDApIHsKIAkJaWYgKHMzY21jaV9ob3N0X3VzZWRtYShob3N0KSkKQEAgLTk4MCw3ICs5ODAsNyBAQAogCiAJaWYgKChkYXRhLT5ibGtzeiAmIDMpICE9IDApIHsKIAkJLyogV2UgY2Fubm90IGRlYWwgd2l0aCB1bmFsaWduZWQgYmxvY2tzIHdpdGggbW9yZSB0aGFuCi0JCSAqIG9uZSBibG9jayBiZWluZyB0cmFuc2ZlcmVkLiAqLworCQkgKiBvbmUgYmxvY2sgYmVpbmcgdHJhbnNmZXJyZWQuICovCiAKIAkJaWYgKGRhdGEtPmJsb2NrcyA+IDEpIHsKIAkJCXByX3dhcm5pbmcoIiVzOiBjYW4ndCBkbyBub24td29yZCBzaXplZCBibG9jayB0cmFuc2ZlcnMgKGJsa3N6ICVkKVxuIiwgX19mdW5jX18sIGRhdGEtPmJsa3N6KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1jL2hvc3QvdG1pb19tbWNfcGlvLmMgYi9kcml2ZXJzL21tYy9ob3N0L3RtaW9fbW1jX3Bpby5jCmluZGV4IDZhZThkMmYuLjYyZDM3ZGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2hvc3QvdG1pb19tbWNfcGlvLmMKKysrIGIvZHJpdmVycy9tbWMvaG9zdC90bWlvX21tY19waW8uYwpAQCAtMzU1LDcgKzM1NSw3IEBACiAvKgogICogVGhpcyBjaGlwIGFsd2F5cyByZXR1cm5zIChhdCBsZWFzdD8pIGFzIG11Y2ggZGF0YSBhcyB5b3UgYXNrIGZvci4KICAqIEknbSB1bnN1cmUgd2hhdCBoYXBwZW5zIGlmIHlvdSBhc2sgZm9yIGxlc3MgdGhhbiBhIGJsb2NrLiBUaGlzIHNob3VsZCBiZQotICogbG9va2VkIGludG8gdG8gZW5zdXJlIHRoYXQgYSBmdW5ueSBsZW5ndGggcmVhZCBkb2VzbnQgaG9zZSB0aGUgY29udHJvbGxlci4KKyAqIGxvb2tlZCBpbnRvIHRvIGVuc3VyZSB0aGF0IGEgZnVubnkgbGVuZ3RoIHJlYWQgZG9lc24ndCBob3NlIHRoZSBjb250cm9sbGVyLgogICovCiBzdGF0aWMgdm9pZCB0bWlvX21tY19waW9faXJxKHN0cnVjdCB0bWlvX21tY19ob3N0ICpob3N0KQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC93YnNkLmMgYi9kcml2ZXJzL21tYy9ob3N0L3dic2QuYwppbmRleCA3ZmNhMGEzLi42MmU1YTRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L3dic2QuYworKysgYi9kcml2ZXJzL21tYy9ob3N0L3dic2QuYwpAQCAtNDg0LDcgKzQ4NCw3IEBACiAKIAkvKgogCSAqIENoZWNrIHRoYXQgd2UgYXJlbid0IGJlaW5nIGNhbGxlZCBhZnRlciB0aGUKLQkgKiBlbnRpcmUgYnVmZmVyIGhhcyBiZWVuIHRyYW5zZmVyZWQuCisJICogZW50aXJlIGJ1ZmZlciBoYXMgYmVlbiB0cmFuc2ZlcnJlZC4KIAkgKi8KIAlpZiAoaG9zdC0+bnVtX3NnID09IDApCiAJCXJldHVybjsKQEAgLTgyOCw3ICs4MjgsNyBAQAogCS8qCiAJICogSWYgdGhpcyBpcyBhIGRhdGEgdHJhbnNmZXIgdGhlIHJlcXVlc3QKIAkgKiB3aWxsIGJlIGZpbmlzaGVkIGFmdGVyIHRoZSBkYXRhIGhhcwotCSAqIHRyYW5zZmVyZWQuCisJICogdHJhbnNmZXJyZWQuCiAJICovCiAJaWYgKGNtZC0+ZGF0YSAmJiAhY21kLT5lcnJvcikgewogCQkvKgpAQCAtOTA0LDcgKzkwNCw3IEBACiAJCQlzZXR1cCAmPSB+V0JTRF9EQVQzX0g7CiAKIAkJCS8qCi0JCQkgKiBXZSBjYW5ub3QgcmVzdW1lIGNhcmQgZGV0ZWN0aW9uIGltbWVkaWF0bHkKKwkJCSAqIFdlIGNhbm5vdCByZXN1bWUgY2FyZCBkZXRlY3Rpb24gaW1tZWRpYXRlbHkKIAkJCSAqIGJlY2F1c2Ugb2YgY2FwYWNpdGFuY2UgYW5kIGRlbGF5cyBpbiB0aGUgY2hpcC4KIAkJCSAqLwogCQkJbW9kX3RpbWVyKCZob3N0LT5pZ25vcmVfdGltZXIsIGppZmZpZXMgKyBIWiAvIDEwMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9jaGlwcy9LY29uZmlnIGIvZHJpdmVycy9tdGQvY2hpcHMvS2NvbmZpZwppbmRleCAzNWM2YTIzLi5iMWUzYzI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9jaGlwcy9LY29uZmlnCisrKyBiL2RyaXZlcnMvbXRkL2NoaXBzL0tjb25maWcKQEAgLTE5LDcgKzE5LDcgQEAKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBlbmFibGVzIEpFREVDLXN0eWxlIHByb2Jpbmcgb2YgZmxhc2ggY2hpcHMgd2hpY2ggYXJlIG5vdAogCSAgY29tcGF0aWJsZSB3aXRoIHRoZSBDb21tb24gRmxhc2ggSW50ZXJmYWNlLCBidXQgd2lsbCB1c2UgdGhlIGNvbW1vbgotCSAgQ0ZJLXRhcmdldHRlZCBmbGFzaCBkcml2ZXJzIGZvciBhbnkgY2hpcHMgd2hpY2ggYXJlIGlkZW50aWZpZWQgd2hpY2gKKwkgIENGSS10YXJnZXRlZCBmbGFzaCBkcml2ZXJzIGZvciBhbnkgY2hpcHMgd2hpY2ggYXJlIGlkZW50aWZpZWQgd2hpY2gKIAkgIGFyZSBpbiBmYWN0IGNvbXBhdGlibGUgaW4gYWxsIGJ1dCB0aGUgcHJvYmUgbWV0aG9kLiBUaGlzIGFjdHVhbGx5CiAJICBjb3ZlcnMgbW9zdCBBTUQvRnVqaXRzdS1jb21wYXRpYmxlIGNoaXBzIGFuZCBhbHNvIG5vbi1DRkkKIAkgIEludGVsIGNoaXBzLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvY2hpcHMvY2ZpX2NtZHNldF8wMDAxLmMgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDEuYwppbmRleCAwOTJhZWYxLi4wOWNiN2M4IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDEuYworKysgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDEuYwpAQCAtMTI0NywxMiArMTI0NywxMiBAQAogCQkJYnJlYWs7CiAKIAkJaWYgKGNoaXAtPmVyYXNlX3N1c3BlbmRlZCAmJiBjaGlwX3N0YXRlID09IEZMX0VSQVNJTkcpICB7Ci0JCQkvKiBFcmFzZSBzdXNwZW5kIG9jY3VyZWQgd2hpbGUgc2xlZXA6IHJlc2V0IHRpbWVvdXQgKi8KKwkJCS8qIEVyYXNlIHN1c3BlbmQgb2NjdXJyZWQgd2hpbGUgc2xlZXA6IHJlc2V0IHRpbWVvdXQgKi8KIAkJCXRpbWVvID0gcmVzZXRfdGltZW87CiAJCQljaGlwLT5lcmFzZV9zdXNwZW5kZWQgPSAwOwogCQl9CiAJCWlmIChjaGlwLT53cml0ZV9zdXNwZW5kZWQgJiYgY2hpcF9zdGF0ZSA9PSBGTF9XUklUSU5HKSAgewotCQkJLyogV3JpdGUgc3VzcGVuZCBvY2N1cmVkIHdoaWxlIHNsZWVwOiByZXNldCB0aW1lb3V0ICovCisJCQkvKiBXcml0ZSBzdXNwZW5kIG9jY3VycmVkIHdoaWxlIHNsZWVwOiByZXNldCB0aW1lb3V0ICovCiAJCQl0aW1lbyA9IHJlc2V0X3RpbWVvOwogCQkJY2hpcC0+d3JpdGVfc3VzcGVuZGVkID0gMDsKIAkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvY2hpcHMvY2ZpX2NtZHNldF8wMDAyLmMgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDIuYwppbmRleCBmOWE1MzMxLi4wYjQ5MjY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDIuYworKysgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDIuYwpAQCAtMjYzLDcgKzI2Myw3IEBACiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CiAKIAkvKgotCSAqIFRoZXNlIGZsYXNoZXMgcmVwb3J0IHR3byBzZXBlcmF0ZSBlcmFzZWJsb2NrIHJlZ2lvbnMgYmFzZWQgb24gdGhlCisJICogVGhlc2UgZmxhc2hlcyByZXBvcnQgdHdvIHNlcGFyYXRlIGVyYXNlYmxvY2sgcmVnaW9ucyBiYXNlZCBvbiB0aGUKIAkgKiBzZWN0b3JfZXJhc2Utc2l6ZSBhbmQgYmxvY2tfZXJhc2Utc2l6ZSwgYWx0aG91Z2ggdGhleSBib3RoIG9wZXJhdGUgb24gdGhlCiAJICogc2FtZSBtZW1vcnkuIFRoaXMgaXMgbm90IGFsbG93ZWQgYWNjb3JkaW5nIHRvIENGSSwgc28gd2UganVzdCBwaWNrIHRoZQogCSAqIHNlY3Rvcl9lcmFzZS1zaXplLgpAQCAtNjExLDggKzYxMSw4IEBACiAgKgogICogTm90ZSB0aGF0IGFueXRoaW5nIG1vcmUgY29tcGxpY2F0ZWQgdGhhbiBjaGVja2luZyBpZiBubyBiaXRzIGFyZSB0b2dnbGluZwogICogKGluY2x1ZGluZyBjaGVja2luZyBEUTUgZm9yIGFuIGVycm9yIHN0YXR1cykgaXMgdHJpY2t5IHRvIGdldCB3b3JraW5nCi0gKiBjb3JyZWN0bHkgYW5kIGlzIHRoZXJlZm9yZSBub3QgZG9uZQkocGFydGljdWxhcnkgd2l0aCBpbnRlcmxlYXZlZCBjaGlwcwotICogYXMgZWFjaCBjaGlwIG11c3QgYmUgY2hlY2tlZCBpbmRlcGVuZGFudGx5IG9mIHRoZSBvdGhlcnMpLgorICogY29ycmVjdGx5IGFuZCBpcyB0aGVyZWZvcmUgbm90IGRvbmUJKHBhcnRpY3VsYXJseSB3aXRoIGludGVybGVhdmVkIGNoaXBzCisgKiBhcyBlYWNoIGNoaXAgbXVzdCBiZSBjaGVja2VkIGluZGVwZW5kZW50bHkgb2YgdGhlIG90aGVycykuCiAgKi8KIHN0YXRpYyBpbnQgX194aXByYW0gY2hpcF9yZWFkeShzdHJ1Y3QgbWFwX2luZm8gKm1hcCwgdW5zaWduZWQgbG9uZyBhZGRyKQogewpAQCAtNjM1LDggKzYzNSw4IEBACiAgKgogICogTm90ZSB0aGF0IGFueXRoaW5nIG1vcmUgY29tcGxpY2F0ZWQgdGhhbiBjaGVja2luZyBpZiBubyBiaXRzIGFyZSB0b2dnbGluZwogICogKGluY2x1ZGluZyBjaGVja2luZyBEUTUgZm9yIGFuIGVycm9yIHN0YXR1cykgaXMgdHJpY2t5IHRvIGdldCB3b3JraW5nCi0gKiBjb3JyZWN0bHkgYW5kIGlzIHRoZXJlZm9yZSBub3QgZG9uZQkocGFydGljdWxhcnkgd2l0aCBpbnRlcmxlYXZlZCBjaGlwcwotICogYXMgZWFjaCBjaGlwIG11c3QgYmUgY2hlY2tlZCBpbmRlcGVuZGFudGx5IG9mIHRoZSBvdGhlcnMpLgorICogY29ycmVjdGx5IGFuZCBpcyB0aGVyZWZvcmUgbm90IGRvbmUJKHBhcnRpY3VsYXJseSB3aXRoIGludGVybGVhdmVkIGNoaXBzCisgKiBhcyBlYWNoIGNoaXAgbXVzdCBiZSBjaGVja2VkIGluZGVwZW5kZW50bHkgb2YgdGhlIG90aGVycykuCiAgKgogICovCiBzdGF0aWMgaW50IF9feGlwcmFtIGNoaXBfZ29vZChzdHJ1Y3QgbWFwX2luZm8gKm1hcCwgdW5zaWduZWQgbG9uZyBhZGRyLCBtYXBfd29yZCBleHBlY3RlZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV91dGlsLmMgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfdXRpbC5jCmluZGV4IDZhZTNkMTEuLjhlNDY0MDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV91dGlsLmMKKysrIGIvZHJpdmVycy9tdGQvY2hpcHMvY2ZpX3V0aWwuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBDb21tb24gRmxhc2ggSW50ZXJmYWNlIHN1cHBvcnQ6Ci0gKiAgIEdlbmVyaWMgdXRpbGl0eSBmdW5jdGlvbnMgbm90IGRlcGVuZGFudCBvbiBjb21tYW5kIHNldAorICogICBHZW5lcmljIHV0aWxpdHkgZnVuY3Rpb25zIG5vdCBkZXBlbmRlbnQgb24gY29tbWFuZCBzZXQKICAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDIgUmVkIEhhdAogICogQ29weXJpZ2h0IChDKSAyMDAzIFNUTWljcm9lbGVjdHJvbmljcyBMaW1pdGVkCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9jaGlwcy9qZWRlY19wcm9iZS5jIGIvZHJpdmVycy9tdGQvY2hpcHMvamVkZWNfcHJvYmUuYwppbmRleCA0ZTFiZTUxLi5lYTgzMmVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9jaGlwcy9qZWRlY19wcm9iZS5jCisrKyBiL2RyaXZlcnMvbXRkL2NoaXBzL2plZGVjX3Byb2JlLmMKQEAgLTIwNzUsNyArMjA3NSw3IEBACiAJfQogCiAJLyoKLQkgKiBNYWtlIHN1cmUgdGhlIElEJ3MgZGlzc2FwcGVhciB3aGVuIHRoZSBkZXZpY2UgaXMgdGFrZW4gb3V0IG9mCisJICogTWFrZSBzdXJlIHRoZSBJRCdzIGRpc2FwcGVhciB3aGVuIHRoZSBkZXZpY2UgaXMgdGFrZW4gb3V0IG9mCiAJICogSUQgbW9kZS4gIFRoZSBvbmx5IHRpbWUgdGhpcyBzaG91bGQgZmFpbCB3aGVuIGl0IHNob3VsZCBzdWNjZWVkCiAJICogaXMgd2hlbiB0aGUgSUQncyBhcmUgd3JpdHRlbiBhcyBkYXRhIHRvIHRoZSBzYW1lCiAJICogYWRkcmVzc2VzLiAgRm9yIHRoaXMgcmFyZSBhbmQgdW5mb3J0dW5hdGUgY2FzZSB0aGUgY2hpcApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvZGV2aWNlcy9ibG9jazJtdGQuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvYmxvY2sybXRkLmMKaW5kZXggZjI5YTZmOS4uOTcxODNjOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvZGV2aWNlcy9ibG9jazJtdGQuYworKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2Jsb2NrMm10ZC5jCkBAIC0yOTUsNyArMjk1LDcgQEAKIAlkZXYtPm10ZC5vd25lciA9IFRISVNfTU9EVUxFOwogCiAJaWYgKGFkZF9tdGRfZGV2aWNlKCZkZXYtPm10ZCkpIHsKLQkJLyogRGV2aWNlIGRpZG50IGdldCBhZGRlZCwgc28gZnJlZSB0aGUgZW50cnkgKi8KKwkJLyogRGV2aWNlIGRpZG4ndCBnZXQgYWRkZWQsIHNvIGZyZWUgdGhlIGVudHJ5ICovCiAJCWdvdG8gZGV2aW5pdF9lcnI7CiAJfQogCWxpc3RfYWRkKCZkZXYtPmxpc3QsICZibGttdGRfZGV2aWNlX2xpc3QpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2MyMDAxcGx1cy5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2MyMDAxcGx1cy5jCmluZGV4IDcxOWIyOTEuLjhiMzZmYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jMjAwMXBsdXMuYworKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2RvYzIwMDFwbHVzLmMKQEAgLTkwLDcgKzkwLDcgQEAKIAlyZXR1cm4gcmV0OwogfQogCi0vKiBGb3Igc29tZSByZWFzb24gdGhlIE1pbGxlbm5pdW0gUGx1cyBzZWVtcyB0byBvY2Nhc3Npb25hbGx5IHB1dCBpdHNlbGYKKy8qIEZvciBzb21lIHJlYXNvbiB0aGUgTWlsbGVubml1bSBQbHVzIHNlZW1zIHRvIG9jY2FzaW9uYWxseSBwdXQgaXRzZWxmCiAgKiBpbnRvIHJlc2V0IG1vZGUuIEZvciBtZSB0aGlzIGhhcHBlbnMgcmFuZG9tbHksIHdpdGggbm8gcGF0dGVybiB0aGF0IEkKICAqIGNhbiBkZXRlY3QuIE0tc3lzdGVtcyBzdWdnZXN0IGFsd2F5cyBjaGVjayB0aGlzIG9uIGFueSBibG9jayBsZXZlbAogICogb3BlcmF0aW9uIGFuZCBzZXR0aW5nIHRvIG5vcm1hbCBtb2RlIGlmIGluIHJlc2V0IG1vZGUuCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL2RvY2VjYy5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2NlY2MuYwppbmRleCBhOTk4MzhiLi4zN2VmMjlhIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9kZXZpY2VzL2RvY2VjYy5jCisrKyBiL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jZWNjLmMKQEAgLTEwOSw3ICsxMDksNyBAQAogICAgb2YgdGhlIGludGVnZXIgImFscGhhX3RvW2ldIiB3aXRoIGEoMCkgYmVpbmcgdGhlIExTQiBhbmQgYShtLTEpIHRoZSBNU0IuIFRodXMgZm9yCiAgICBleGFtcGxlIHRoZSBwb2x5bm9taWFsIHJlcHJlc2VudGF0aW9uIG9mIEBeNSB3b3VsZCBiZSBnaXZlbiBieSB0aGUgYmluYXJ5CiAgICByZXByZXNlbnRhdGlvbiBvZiB0aGUgaW50ZWdlciAiYWxwaGFfdG9bNV0iLgotICAgICAgICAgICAgICAgICAgIFNpbWlsYXJpbHksIGluZGV4X29mW10gY2FuIGJlIHVzZWQgYXMgZm9sbG93czoKKyAgICAgICAgICAgICAgICAgICBTaW1pbGFybHksIGluZGV4X29mW10gY2FuIGJlIHVzZWQgYXMgZm9sbG93czoKICAgICAgICAgQXMgYWJvdmUsIGxldCBAIHJlcHJlc2VudCB0aGUgcHJpbWl0aXZlIGVsZW1lbnQgb2YgR0YoMl5tKSB0aGF0IGlzCiAgICB0aGUgcm9vdCBvZiB0aGUgcHJpbWl0aXZlIHBvbHlub21pYWwgcCh4KS4gSW4gb3JkZXIgdG8gZmluZCB0aGUgcG93ZXIKICAgIG9mIEAgKGFscGhhKSB0aGF0IGhhcyB0aGUgcG9seW5vbWlhbCByZXByZXNlbnRhdGlvbgpAQCAtMTIxLDcgKzEyMSw3IEBACiAgICBOT1RFOgogICAgICAgICBUaGUgZWxlbWVudCBhbHBoYV90b1syXm0tMV0gPSAwIGFsd2F5cyBzaWduaWZ5aW5nIHRoYXQgdGhlCiAgICByZXByZXNlbnRhdGlvbiBvZiAiQF5pbmZpbml0eSIgPSAwIGlzICgwLDAsMCwuLi4sMCkuCi0gICAgICAgIFNpbWlsYXJpbHksIHRoZSBlbGVtZW50IGluZGV4X29mWzBdID0gQTAgYWx3YXlzIHNpZ25pZnlpbmcKKyAgICAgICAgU2ltaWxhcmx5LCB0aGUgZWxlbWVudCBpbmRleF9vZlswXSA9IEEwIGFsd2F5cyBzaWduaWZ5aW5nCiAgICB0aGF0IHRoZSBwb3dlciBvZiBhbHBoYSB3aGljaCBoYXMgdGhlIHBvbHlub21pYWwgcmVwcmVzZW50YXRpb24KICAgICgwLDAsLi4uLDApIGlzICJpbmZpbml0eSIuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvbGFydC5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9sYXJ0LmMKaW5kZXggY2FmNjA0MS4uNGI4MjlmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvZGV2aWNlcy9sYXJ0LmMKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9sYXJ0LmMKQEAgLTM1Myw3ICszNTMsNyBAQAogICAgLyogcHV0IHRoZSBmbGFzaCBiYWNrIGludG8gY29tbWFuZCBtb2RlICovCiAgICB3cml0ZTMyIChEQVRBX1RPX0ZMQVNIIChSRUFEX0FSUkFZKSxvZmZzZXQpOwogCi0gICAvKiB3YXMgdGhlIGVyYXNlIHN1Y2Nlc3NmdWxsPyAqLworICAgLyogd2FzIHRoZSBlcmFzZSBzdWNjZXNzZnVsPyAqLwogICAgaWYgKChzdGF0dXMgJiBTVEFUVVNfRVJBU0VfRVJSKSkKIAkgewogCQlwcmludGsgKEtFUk5fV0FSTklORyAiJXM6IGVyYXNlIGVycm9yIGF0IGFkZHJlc3MgMHglLjh4LlxuIixtb2R1bGVfbmFtZSxvZmZzZXQpOwpAQCAtNTA4LDcgKzUwOCw3IEBACiAgICAvKiBwdXQgdGhlIGZsYXNoIGJhY2sgaW50byBjb21tYW5kIG1vZGUgKi8KICAgIHdyaXRlMzIgKERBVEFfVE9fRkxBU0ggKFJFQURfQVJSQVkpLG9mZnNldCk7CiAKLSAgIC8qIHdhcyB0aGUgd3JpdGUgc3VjY2Vzc2Z1bGw/ICovCisgICAvKiB3YXMgdGhlIHdyaXRlIHN1Y2Nlc3NmdWw/ICovCiAgICBpZiAoKHN0YXR1cyAmIFNUQVRVU19QR01fRVJSKSB8fCByZWFkMzIgKG9mZnNldCkgIT0geCkKIAkgewogCQlwcmludGsgKEtFUk5fV0FSTklORyAiJXM6IHdyaXRlIGVycm9yIGF0IGFkZHJlc3MgMHglLjh4LlxuIixtb2R1bGVfbmFtZSxvZmZzZXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvZGV2aWNlcy9wbWM1NTEuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvcG1jNTUxLmMKaW5kZXggZWYwYWJhMC4uNDFiOGNkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvZGV2aWNlcy9wbWM1NTEuYworKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL3BtYzU1MS5jCkBAIC0zNTEsNyArMzUxLDcgQEAKICAqIEZpeHVwIHJvdXRpbmVzIGZvciB0aGUgVjM3MFBEQwogICogUENJIGRldmljZSBJRCAweDAyMDAxMWIwCiAgKgotICogVGhpcyBmdW5jdGlvbiBiYXNpY2x5IGtpY2sgc3RhcnRzIHRoZSBEUkFNIG9ib2FyZCB0aGUgY2FyZCBhbmQgZ2V0cyBpdAorICogVGhpcyBmdW5jdGlvbiBiYXNpY2FsbHkga2ljayBzdGFydHMgdGhlIERSQU0gb2JvYXJkIHRoZSBjYXJkIGFuZCBnZXRzIGl0CiAgKiByZWFkeSB0byBiZSB1c2VkLiAgQmVmb3JlIHRoaXMgaXMgZG9uZSB0aGUgZGV2aWNlIHJlYWRzIFZFUlkgZXJyYXRpYywgc28KICAqIG11Y2ggdGhhdCBpdCBjYW4gY3Jhc2ggdGhlIExpbnV4IDIuMi54IHNlcmllcyBrZXJuZWxzIHdoZW4gYSB1c2VyIGNhdCdzCiAgKiAvcHJvYy9wY2kgLi4gdGhvdWdoIHRoYXQgaXMgbWFpbmx5IGEga2VybmVsIGJ1ZyBpbiBoYW5kbGluZyB0aGUgUENJIERFVlNFTApAQCAtNTQwLDcgKzU0MCw3IEBACiAKIAkvKgogCSAqIENoZWNrIHRvIG1ha2UgY2VydGFpbiB0aGUgREVWU0VMIGlzIHNldCBjb3JyZWN0bHksIHRoaXMgZGV2aWNlCi0JICogaGFzIGEgdGVuZGFuY3kgdG8gYXNzZXJ0IERFVlNFTCBhbmQgVFJEWSB3aGVuIGEgd3JpdGUgaXMgcGVyZm9ybWVkCisJICogaGFzIGEgdGVuZGVuY3kgdG8gYXNzZXJ0IERFVlNFTCBhbmQgVFJEWSB3aGVuIGEgd3JpdGUgaXMgcGVyZm9ybWVkCiAJICogdG8gdGhlIG1lbW9yeSB3aGVuIG1lbW9yeSBpcyByZWFkLW9ubHkKIAkgKi8KIAlpZiAoKGNtZCAmIFBDSV9TVEFUVVNfREVWU0VMX01BU0spICE9IDB4MCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbHBkZHIvbHBkZHJfY21kcy5jIGIvZHJpdmVycy9tdGQvbHBkZHIvbHBkZHJfY21kcy5jCmluZGV4IDA0ZmRmY2MuLjEyNjc5OTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL2xwZGRyL2xwZGRyX2NtZHMuYworKysgYi9kcml2ZXJzL210ZC9scGRkci9scGRkcl9jbWRzLmMKQEAgLTMsNyArMyw3IEBACiAgKiBlcmFzZSwgbG9jay91bmxvY2sgc3VwcG9ydCBmb3IgTFBERFIgZmxhc2ggbWVtb3JpZXMKICAqIChDKSAyMDA4IEtvcm9sZXYgQWxleGV5IDxha29yb2xldkBpbmZyYWRlYWQub3JnPgogICogKEMpIDIwMDggVmFzaWxpeSBMZW9uZW5rbyA8dmFzaWxpeS5sZW9uZW5rb0BnbWFpbC5jb20+Ci0gKiBNYW55IHRoYW5rcyB0byBSb21hbiBCb3Jpc292IGZvciBpbnRpYWwgZW5hYmxpbmcKKyAqIE1hbnkgdGhhbmtzIHRvIFJvbWFuIEJvcmlzb3YgZm9yIGluaXRpYWwgZW5hYmxpbmcKICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQpAQCAtMTcxLDcgKzE3MSw3IEBACiAJCQltdXRleF9sb2NrKCZjaGlwLT5tdXRleCk7CiAJCX0KIAkJaWYgKGNoaXAtPmVyYXNlX3N1c3BlbmRlZCB8fCBjaGlwLT53cml0ZV9zdXNwZW5kZWQpICB7Ci0JCQkvKiBTdXNwZW5kIGhhcyBvY2N1cmVkIHdoaWxlIHNsZWVwOiByZXNldCB0aW1lb3V0ICovCisJCQkvKiBTdXNwZW5kIGhhcyBvY2N1cnJlZCB3aGlsZSBzbGVlcDogcmVzZXQgdGltZW91dCAqLwogCQkJdGltZW8gPSByZXNldF90aW1lbzsKIAkJCWNoaXAtPmVyYXNlX3N1c3BlbmRlZCA9IGNoaXAtPndyaXRlX3N1c3BlbmRlZCA9IDA7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvY2VpdmEuYyBiL2RyaXZlcnMvbXRkL21hcHMvY2VpdmEuYwppbmRleCBlNWY2NDViLi4yM2Y1NTFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tYXBzL2NlaXZhLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9jZWl2YS5jCkBAIC00Miw3ICs0Miw3IEBACiAgKgogICogUGxlYXNlIG5vdGU6CiAgKiAgMS4gVGhlIGZsYXNoIHNpemUgZ2l2ZW4gc2hvdWxkIGJlIHRoZSBsYXJnZXN0IGZsYXNoIHNpemUgdGhhdCBjYW4KLSAqICAgICBiZSBhY2NvbW9kYXRlZC4KKyAqICAgICBiZSBhY2NvbW1vZGF0ZWQuCiAgKgogICogIDIuIFRoZSBidXMgd2lkdGggbXVzdCBkZWZpbmVkIGluIGNscHNfc2V0dXBfZmxhc2guCiAgKgpAQCAtNTgsNyArNTgsNyBAQAogI2RlZmluZSBCT09UX1BBUlRJVElPTl9TSVpFX0tpQiAgICAgICAoMTYpCiAjZGVmaW5lIFBBUkFNU19QQVJUSVRJT05fU0laRV9LaUIgICAgICg4KQogI2RlZmluZSBLRVJORUxfUEFSVElUSU9OX1NJWkVfS2lCICAgICAoNCoxMjgpCi0vKiBVc2UgYm90aCByZW1haW5nIHBvcnRpb24gb2YgZmlyc3QgZmxhc2gsIGFuZCBhbGwgb2Ygc2Vjb25kIGZsYXNoICovCisvKiBVc2UgYm90aCByZW1haW5pbmcgcG9ydGlvbiBvZiBmaXJzdCBmbGFzaCwgYW5kIGFsbCBvZiBzZWNvbmQgZmxhc2ggKi8KICNkZWZpbmUgUk9PVF9QQVJUSVRJT05fU0laRV9LaUIgICAgICAgKDMqMTI4KSArICg4KjEyOCkKIAogc3RhdGljIHN0cnVjdCBtdGRfcGFydGl0aW9uIGNlaXZhX3BhcnRpdGlvbnNbXSA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvY2ZpX2ZsYWdhZG0uYyBiL2RyaXZlcnMvbXRkL21hcHMvY2ZpX2ZsYWdhZG0uYwppbmRleCBiNGVkODE2Li5mNzEzNDNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tYXBzL2NmaV9mbGFnYWRtLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9jZmlfZmxhZ2FkbS5jCkBAIC0zMyw3ICszMyw3IEBACiAKIAogLyogV2Ugc3BsaXQgdGhlIGZsYXNoIGNoaXAgdXAgaW50byBmb3VyIHBhcnRzLgotICogMTogYm9vdGxvYWRlciBmaXJ0cyAxMjhrCQkJKDB4MDAwMDAwMDAgLSAweDAwMDFGRkZGKSBzaXplIDB4MDIwMDAwCisgKiAxOiBib290bG9hZGVyIGZpcnN0IDEyOGsJCQkoMHgwMDAwMDAwMCAtIDB4MDAwMUZGRkYpIHNpemUgMHgwMjAwMDAKICAqIDI6IGtlcm5lbCA2NDBrCQkJCQkoMHgwMDAyMDAwMCAtIDB4MDAwQkZGRkYpIHNpemUgMHgwQTAwMDAKICAqIDM6IGNvbXByZXNzZWQgMTUzNmsgcm9vdCByYW1kaXNrCSgweDAwMEMwMDAwIC0gMHgwMDIzRkZGRikgc2l6ZSAweDE4MDAwMAogICogNDogd3JpdGVhYmxlIGRpc2twYXJ0aXRpb24gKGpmZnMpKDB4MDAyNDAwMDAgLSAweDAwM0ZGRkZGKSBzaXplIDB4MUMwMDAwCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tYXBzL3BjbWNpYW10ZC5jIGIvZHJpdmVycy9tdGQvbWFwcy9wY21jaWFtdGQuYwppbmRleCA5MTcwMjI5Li42Nzk5ZTc1IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tYXBzL3BjbWNpYW10ZC5jCisrKyBiL2RyaXZlcnMvbXRkL21hcHMvcGNtY2lhbXRkLmMKQEAgLTQ5Nyw3ICs0OTcsNyBAQAogCQlkZXYtPnBjbWNpYV9tYXAuc2V0X3ZwcCA9IHBjbWNpYW10ZF9zZXRfdnBwOwogCiAJLyogUmVxdWVzdCBhIG1lbW9yeSB3aW5kb3cgZm9yIFBDTUNJQS4gU29tZSBhcmNoaXRldXJlcyBjYW4gbWFwIHdpbmRvd3MKLQkgKiB1cHRvIHRoZSBtYXhpbXVtIHRoYXQgUENNQ0lBIGNhbiBzdXBwb3J0ICg2NE1pQikgLSB0aGlzIGlzIGlkZWFsIGFuZAorCSAqIHVwIHRvIHRoZSBtYXhpbXVtIHRoYXQgUENNQ0lBIGNhbiBzdXBwb3J0ICg2NE1pQikgLSB0aGlzIGlzIGlkZWFsIGFuZAogCSAqIHdlIGFpbSBmb3IgYSB3aW5kb3cgdGhlIHNpemUgb2YgdGhlIHdob2xlIGNhcmQgLSBvdGhlcndpc2Ugd2UgdHJ5CiAJICogc21hbGxlciB3aW5kb3dzIHVudGlsIHdlIHN1Y2NlZWQKIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvcG1jbXNwLWZsYXNoLmMgYi9kcml2ZXJzL210ZC9tYXBzL3BtY21zcC1mbGFzaC5jCmluZGV4IGFjYjEzZmEuLjY0YWVhNmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL21hcHMvcG1jbXNwLWZsYXNoLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9wbWNtc3AtZmxhc2guYwpAQCAtMyw3ICszLDcgQEAKICAqIENvbmZpZyB3aXRoIGJvdGggQ0ZJIGFuZCBKRURFQyBkZXZpY2Ugc3VwcG9ydC4KICAqCiAgKiBCYXNpY2FsbHkgcGh5c21hcC5jIHdpdGggdGhlIGFkZGl0aW9uIG9mIHBhcnRpdGlvbnMgYW5kCi0gKiBhbiBhcnJheSBvZiBtYXBwaW5nIGluZm8gdG8gYWNjb21vZGF0ZSBtb3JlIHRoYW4gb25lIGZsYXNoIHR5cGUgcGVyIGJvYXJkLgorICogYW4gYXJyYXkgb2YgbWFwcGluZyBpbmZvIHRvIGFjY29tbW9kYXRlIG1vcmUgdGhhbiBvbmUgZmxhc2ggdHlwZSBwZXIgYm9hcmQuCiAgKgogICogQ29weXJpZ2h0IDIwMDUtMjAwNyBQTUMtU2llcnJhLCBJbmMuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbWFwcy9zYzUyMGNkcC5jIGIvZHJpdmVycy9tdGQvbWFwcy9zYzUyMGNkcC5jCmluZGV4IDg1YzFlNTYuLjRkOGFhYWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL21hcHMvc2M1MjBjZHAuYworKysgYi9kcml2ZXJzL210ZC9tYXBzL3NjNTIwY2RwLmMKQEAgLTE5Nyw3ICsxOTcsNyBAQAogCX0KIAogCS8qCi0JKiogRmluZCB0aGUgUEFSeHggcmVnaXN0ZXJzIHRoYXQgYXJlIHJlcG9uc2libGUgZm9yIGFjdGl2YXRpbmcKKwkqKiBGaW5kIHRoZSBQQVJ4eCByZWdpc3RlcnMgdGhhdCBhcmUgcmVzcG9uc2libGUgZm9yIGFjdGl2YXRpbmcKIAkqKiBST01DUzAsIFJPTUNTMSBhbmQgQk9PVENTLiBSZXByb2dyYW0gZWFjaCBvZiB0aGVzZSB3aXRoIGEKIAkqKiBuZXcgdmFsdWUgZnJvbSB0aGUgdGFibGUuCiAJKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvdHFtOHh4bC5jIGIvZHJpdmVycy9tdGQvbWFwcy90cW04eHhsLmMKaW5kZXggYzA4ZTE0MC4uMDcxOGRmYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbWFwcy90cW04eHhsLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy90cW04eHhsLmMKQEAgLTYzLDcgKzYzLDcgQEAKICAqLwogCiAjaWZkZWYgQ09ORklHX01URF9QQVJUSVRJT05TCi0vKiBDdXJyZW50bHksIFRRTTh4eEwgaGFzIHVwdG8gOE1pQiBmbGFzaCAqLworLyogQ3VycmVudGx5LCBUUU04eHhMIGhhcyB1cCB0byA4TWlCIGZsYXNoICovCiBzdGF0aWMgdW5zaWduZWQgbG9uZyB0cW04eHhsX21heF9mbGFzaF9zaXplID0gMHgwMDgwMDAwMDsKIAogLyogcGFydGl0aW9uIGRlZmluaXRpb24gZm9yIGZpcnN0IGZsYXNoIGJhbmsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL210ZGJsb2NrLmMgYi9kcml2ZXJzL210ZC9tdGRibG9jay5jCmluZGV4IDFlNzRhZDkuLjMzMjY2MTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL210ZGJsb2NrLmMKKysrIGIvZHJpdmVycy9tdGQvbXRkYmxvY2suYwpAQCAtMTI5LDcgKzEyOSw3IEBACiAJCXJldHVybiByZXQ7CiAKIAkvKgotCSAqIEhlcmUgd2UgY291bGQgYXJndWJseSBzZXQgdGhlIGNhY2hlIHN0YXRlIHRvIFNUQVRFX0NMRUFOLgorCSAqIEhlcmUgd2UgY291bGQgYXJndWFibHkgc2V0IHRoZSBjYWNoZSBzdGF0ZSB0byBTVEFURV9DTEVBTi4KIAkgKiBIb3dldmVyIHRoaXMgY291bGQgbGVhZCB0byBpbmNvbnNpc3RlbmN5IHNpbmNlIHdlIHdpbGwgbm90CiAJICogYmUgbm90aWZpZWQgaWYgdGhpcyBjb250ZW50IGlzIGFsdGVyZWQgb24gdGhlIGZsYXNoIGJ5IG90aGVyCiAJICogbWVhbnMuICBMZXQncyBkZWNsYXJlIGl0IGVtcHR5IGFuZCBsZWF2ZSBidWZmZXJpbmcgdGFza3MgdG8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL210ZGNoYXIuYyBiL2RyaXZlcnMvbXRkL210ZGNoYXIuYwppbmRleCAxNDViM2QwZC4uNGMzNmVmNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbXRkY2hhci5jCisrKyBiL2RyaXZlcnMvbXRkL210ZGNoYXIuYwpAQCAtMjM0LDcgKzIzNCw3IEBACiAJCSAqIHRoZSBkYXRhLiBGb3Igb3VyIHVzZXJzcGFjZSB0b29scyBpdCBpcyBpbXBvcnRhbnQKIAkJICogdG8gZHVtcCBhcmVhcyB3aXRoIGVjYyBlcnJvcnMgIQogCQkgKiBGb3Iga2VybmVsIGludGVybmFsIHVzYWdlIGl0IGFsc28gbWlnaHQgcmV0dXJuIC1FVUNMRUFOCi0JCSAqIHRvIHNpZ25hbCB0aGUgY2FsbGVyIHRoYXQgYSBiaXRmbGlwIGhhcyBvY2N1cmVkIGFuZCBoYXMKKwkJICogdG8gc2lnbmFsIHRoZSBjYWxsZXIgdGhhdCBhIGJpdGZsaXAgaGFzIG9jY3VycmVkIGFuZCBoYXMKIAkJICogYmVlbiBjb3JyZWN0ZWQgYnkgdGhlIEVDQyBhbGdvcml0aG0uCiAJCSAqIFVzZXJzcGFjZSBzb2Z0d2FyZSB3aGljaCBhY2Nlc3NlcyBOQU5EIHRoaXMgd2F5CiAJCSAqIG11c3QgYmUgYXdhcmUgb2YgdGhlIGZhY3QgdGhhdCBpdCBkZWFscyB3aXRoIE5BTkQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL210ZHN3YXAuYyBiL2RyaXZlcnMvbXRkL210ZHN3YXAuYwppbmRleCAyMzc5MTNjLi5mZWQyMTVjIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tdGRzd2FwLmMKKysrIGIvZHJpdmVycy9tdGQvbXRkc3dhcC5jCkBAIC0xNDUyLDcgKzE0NTIsNyBAQAogCW9pbmZvID0gbXRkLT5lY2NsYXlvdXQ7CiAJaWYgKCFtdGQtPm9vYnNpemUgfHwgIW9pbmZvIHx8IG9pbmZvLT5vb2JhdmFpbCA8IE1URFNXQVBfT09CU0laRSkgewogCQlwcmludGsoS0VSTl9FUlIgIiVzOiBOb3QgZW5vdWdoIGZyZWUgYnl0ZXMgaW4gT09CLCAiCi0JCQkiJWQgYXZhaWxhYmxlLCAlbHUgbmVlZGVkLlxuIiwKKwkJCSIlZCBhdmFpbGFibGUsICV6dSBuZWVkZWQuXG4iLAogCQkJTVREU1dBUF9QUkVGSVgsIG9pbmZvLT5vb2JhdmFpbCwgTVREU1dBUF9PT0JTSVpFKTsKIAkJcmV0dXJuOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvS2NvbmZpZyBiL2RyaXZlcnMvbXRkL25hbmQvS2NvbmZpZwppbmRleCBhOTIwNTRlLi5lZGVjNDU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL0tjb25maWcKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9LY29uZmlnCkBAIC0yMzksNyArMjM5LDcgQEAKIAloZWxwCiAJICBUaGlzIGVuYWJsZXMgdGhlIE5BTkQgZmxhc2ggY29udHJvbGxlciBvbiB0aGUgQkNNIFVNSSBibG9jay4KIAotCSAgTm8gYm9hcmQgc3BlY2ZpYyBzdXBwb3J0IGlzIGRvbmUgYnkgdGhpcyBkcml2ZXIsIGVhY2ggYm9hcmQKKwkgIE5vIGJvYXJkIHNwZWNpZmljIHN1cHBvcnQgaXMgZG9uZSBieSB0aGlzIGRyaXZlciwgZWFjaCBib2FyZAogCSAgbXVzdCBhZHZlcnRpc2UgYSBwbGF0Zm9ybV9kZXZpY2UgZm9yIHRoZSBkcml2ZXIgdG8gYXR0YWNoLgogCiBjb25maWcgTVREX05BTkRfQkNNX1VNSV9IV0NTCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2Ftcy1kZWx0YS5jIGIvZHJpdmVycy9tdGQvbmFuZC9hbXMtZGVsdGEuYwppbmRleCBhMDY3ZDA5Li5iYzY1YmY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2Ftcy1kZWx0YS5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvYW1zLWRlbHRhLmMKQEAgLTIyOCw3ICsyMjgsNyBAQAogCQkJCQkgIEFNU19ERUxUQV9MQVRDSDJfTkFORF9OQ0UgfAogCQkJCQkgIEFNU19ERUxUQV9MQVRDSDJfTkFORF9OV1ApOwogCi0JLyogU2NhbiB0byBmaW5kIGV4aXN0YW5jZSBvZiB0aGUgZGV2aWNlICovCisJLyogU2NhbiB0byBmaW5kIGV4aXN0ZW5jZSBvZiB0aGUgZGV2aWNlICovCiAJaWYgKG5hbmRfc2NhbihhbXNfZGVsdGFfbXRkLCAxKSkgewogCQllcnIgPSAtRU5YSU87CiAJCWdvdG8gb3V0X210ZDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvYXRtZWxfbmFuZC5jIGIvZHJpdmVycy9tdGQvbmFuZC9hdG1lbF9uYW5kLmMKaW5kZXggNmZhZTA0Yi4uOTUwNjQ2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9hdG1lbF9uYW5kLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9hdG1lbF9uYW5kLmMKQEAgLTIwOSwyMiArMjA5LDggQEAKIAlpbnQgZXJyID0gLUVJTzsKIAllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIgPSBpc19yZWFkID8gRE1BX0ZST01fREVWSUNFIDogRE1BX1RPX0RFVklDRTsKIAotCWlmIChidWYgPj0gaGlnaF9tZW1vcnkpIHsKLQkJc3RydWN0IHBhZ2UgKnBnOwotCi0JCWlmICgoKHNpemVfdClidWYgJiBQQUdFX01BU0spICE9Ci0JCSAgICAoKHNpemVfdCkoYnVmICsgbGVuIC0gMSkgJiBQQUdFX01BU0spKSB7Ci0JCQlkZXZfd2Fybihob3N0LT5kZXYsICJCdWZmZXIgbm90IGZpdCBpbiBvbmUgcGFnZVxuIik7Ci0JCQlnb3RvIGVycl9idWY7Ci0JCX0KLQotCQlwZyA9IHZtYWxsb2NfdG9fcGFnZShidWYpOwotCQlpZiAocGcgPT0gMCkgewotCQkJZGV2X2Vycihob3N0LT5kZXYsICJGYWlsZWQgdG8gdm1hbGxvY190b19wYWdlXG4iKTsKLQkJCWdvdG8gZXJyX2J1ZjsKLQkJfQotCQlwID0gcGFnZV9hZGRyZXNzKHBnKSArICgoc2l6ZV90KWJ1ZiAmIH5QQUdFX01BU0spOwotCX0KKwlpZiAoYnVmID49IGhpZ2hfbWVtb3J5KQorCQlnb3RvIGVycl9idWY7CiAKIAlkbWFfZGV2ID0gaG9zdC0+ZG1hX2NoYW4tPmRldmljZTsKIApAQCAtMjgwLDcgKzI2Niw4IEBACiAJc3RydWN0IG5hbmRfY2hpcCAqY2hpcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgYXRtZWxfbmFuZF9ob3N0ICpob3N0ID0gY2hpcC0+cHJpdjsKIAotCWlmICh1c2VfZG1hICYmIGxlbiA+PSBtdGQtPm9vYnNpemUpCisJaWYgKHVzZV9kbWEgJiYgbGVuID4gbXRkLT5vb2JzaXplKQorCQkvKiBvbmx5IHVzZSBETUEgZm9yIGJpZ2dlciB0aGFuIG9vYiBzaXplOiBiZXR0ZXIgcGVyZm9ybWFuY2VzICovCiAJCWlmIChhdG1lbF9uYW5kX2RtYV9vcChtdGQsIGJ1ZiwgbGVuLCAxKSA9PSAwKQogCQkJcmV0dXJuOwogCkBAIC0yOTUsNyArMjgyLDggQEAKIAlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gbXRkLT5wcml2OwogCXN0cnVjdCBhdG1lbF9uYW5kX2hvc3QgKmhvc3QgPSBjaGlwLT5wcml2OwogCi0JaWYgKHVzZV9kbWEgJiYgbGVuID49IG10ZC0+b29ic2l6ZSkKKwlpZiAodXNlX2RtYSAmJiBsZW4gPiBtdGQtPm9vYnNpemUpCisJCS8qIG9ubHkgdXNlIERNQSBmb3IgYmlnZ2VyIHRoYW4gb29iIHNpemU6IGJldHRlciBwZXJmb3JtYW5jZXMgKi8KIAkJaWYgKGF0bWVsX25hbmRfZG1hX29wKG10ZCwgKHZvaWQgKilidWYsIGxlbiwgMCkgPT0gMCkKIAkJCXJldHVybjsKIApAQCAtNTk5LDcgKzU4NywxMCBAQAogCQluYW5kX2NoaXAtPm9wdGlvbnMgfD0gTkFORF9VU0VfRkxBU0hfQkJUOwogCX0KIAotCWlmIChjcHVfaGFzX2RtYSgpICYmIHVzZV9kbWEpIHsKKwlpZiAoIWNwdV9oYXNfZG1hKCkpCisJCXVzZV9kbWEgPSAwOworCisJaWYgKHVzZV9kbWEpIHsKIAkJZG1hX2NhcF9tYXNrX3QgbWFzazsKIAogCQlkbWFfY2FwX3plcm8obWFzayk7CkBAIC02MTEsNyArNjAyLDggQEAKIAkJfQogCX0KIAlpZiAodXNlX2RtYSkKLQkJZGV2X2luZm8oaG9zdC0+ZGV2LCAiVXNpbmcgRE1BIGZvciBOQU5EIGFjY2Vzcy5cbiIpOworCQlkZXZfaW5mbyhob3N0LT5kZXYsICJVc2luZyAlcyBmb3IgRE1BIHRyYW5zZmVycy5cbiIsCisJCQkJCWRtYV9jaGFuX25hbWUoaG9zdC0+ZG1hX2NoYW4pKTsKIAllbHNlCiAJCWRldl9pbmZvKGhvc3QtPmRldiwgIk5vIERNQSBzdXBwb3J0IGZvciBOQU5EIGFjY2Vzcy5cbiIpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2F1dGNwdTEyLmMgYi9kcml2ZXJzL210ZC9uYW5kL2F1dGNwdTEyLmMKaW5kZXggN2M5NWRhMS4uMDkxMWNmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9hdXRjcHUxMi5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvYXV0Y3B1MTIuYwpAQCAtMTc2LDcgKzE3Niw3IEBACiAJICovCiAJdGhpcy0+b3B0aW9ucyA9IE5BTkRfVVNFX0ZMQVNIX0JCVDsKIAotCS8qIFNjYW4gdG8gZmluZCBleGlzdGFuY2Ugb2YgdGhlIGRldmljZSAqLworCS8qIFNjYW4gdG8gZmluZCBleGlzdGVuY2Ugb2YgdGhlIGRldmljZSAqLwogCWlmIChuYW5kX3NjYW4oYXV0Y3B1MTJfbXRkLCAxKSkgewogCQllcnIgPSAtRU5YSU87CiAJCWdvdG8gb3V0X2lvcjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvY3M1NTN4X25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvY3M1NTN4X25hbmQuYwppbmRleCA5ZjFiNDUxLi43MWMzNWEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2NzNTUzeF9uYW5kLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9jczU1M3hfbmFuZC5jCkBAIC0yNDEsNyArMjQxLDcgQEAKIAkvKiBFbmFibGUgdGhlIGZvbGxvd2luZyBmb3IgYSBmbGFzaCBiYXNlZCBiYWQgYmxvY2sgdGFibGUgKi8KIAl0aGlzLT5vcHRpb25zID0gTkFORF9VU0VfRkxBU0hfQkJUIHwgTkFORF9OT19BVVRPSU5DUjsKIAotCS8qIFNjYW4gdG8gZmluZCBleGlzdGFuY2Ugb2YgdGhlIGRldmljZSAqLworCS8qIFNjYW4gdG8gZmluZCBleGlzdGVuY2Ugb2YgdGhlIGRldmljZSAqLwogCWlmIChuYW5kX3NjYW4obmV3X210ZCwgMSkpIHsKIAkJZXJyID0gLUVOWElPOwogCQlnb3RvIG91dF9pb3I7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2RlbmFsaS5jIGIvZHJpdmVycy9tdGQvbmFuZC9kZW5hbGkuYwppbmRleCA4YzhkM2M4Li40NjMzZjA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2RlbmFsaS5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvZGVuYWxpLmMKQEAgLTcyNCw3ICs3MjQsNyBAQAogfQogCiAvKiBUaGlzIGhlbHBlciBmdW5jdGlvbiBzZXR1cHMgdGhlIHJlZ2lzdGVycyBmb3IgRUNDIGFuZCB3aGV0aGVyIG9yIG5vdAotICogdGhlIHNwYXJlIGFyZWEgd2lsbCBiZSB0cmFuc2ZlcmVkLiAqLworICogdGhlIHNwYXJlIGFyZWEgd2lsbCBiZSB0cmFuc2ZlcnJlZC4gKi8KIHN0YXRpYyB2b2lkIHNldHVwX2VjY19mb3JfeGZlcihzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCBib29sIGVjY19lbiwKIAkJCQlib29sIHRyYW5zZmVyX3NwYXJlKQogewpAQCAtOTY1LDcgKzk2NSw3IEBACiAKIAkJCWlmIChFQ0NfRVJST1JfQ09SUkVDVEFCTEUoZXJyX2NvcnJlY3Rpb25faW5mbykpIHsKIAkJCQkvKiBJZiBlcnJfYnl0ZSBpcyBsYXJnZXIgdGhhbiBFQ0NfU0VDVE9SX1NJWkUsCi0JCQkJICogbWVhbnMgZXJyb3IgaGFwcGVuZCBpbiBPT0IsIHNvIHdlIGlnbm9yZQorCQkJCSAqIG1lYW5zIGVycm9yIGhhcHBlbmVkIGluIE9PQiwgc28gd2UgaWdub3JlCiAJCQkJICogaXQuIEl0J3Mgbm8gbmVlZCBmb3IgdXMgdG8gY29ycmVjdCBpdAogCQkJCSAqIGVycl9kZXZpY2UgaXMgcmVwcmVzZW50ZWQgdGhlIE5BTkQgZXJyb3IKIAkJCQkgKiBiaXRzIGFyZSBoYXBwZW5lZCBpbiBpZiB0aGVyZSBhcmUgbW9yZQpAQCAtMTEwOSw3ICsxMTA5LDcgQEAKIH0KIAogLyogVGhpcyBpcyB0aGUgY2FsbGJhY2sgdGhhdCB0aGUgTkFORCBjb3JlIGNhbGxzIHRvIHdyaXRlIGEgcGFnZSB3aXRob3V0IEVDQy4KLSAqIHJhdyBhY2Nlc3MgaXMgc2ltaWxpYXIgdG8gRUNDIHBhZ2Ugd3JpdGVzLCBzbyBhbGwgdGhlIHdvcmsgaXMgZG9uZSBpbiB0aGUKKyAqIHJhdyBhY2Nlc3MgaXMgc2ltaWxhciB0byBFQ0MgcGFnZSB3cml0ZXMsIHNvIGFsbCB0aGUgd29yayBpcyBkb25lIGluIHRoZQogICogd3JpdGVfcGFnZSgpIGZ1bmN0aW9uIGFib3ZlLgogICovCiBzdGF0aWMgdm9pZCBkZW5hbGlfd3JpdGVfcGFnZV9yYXcoc3RydWN0IG10ZF9pbmZvICptdGQsIHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2Rpc2tvbmNoaXAuYyBiL2RyaXZlcnMvbXRkL25hbmQvZGlza29uY2hpcC5jCmluZGV4IGI3ZjhkZTcuLjk2YzBiMzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvZGlza29uY2hpcC5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvZGlza29uY2hpcC5jCkBAIC0xMzcsNyArMTM3LDcgQEAKICAqCiAgKiBGYWJyaWNlIEJlbGxhcmQgZmlndXJlZCB0aGlzIG91dCBpbiB0aGUgb2xkIGRvY2VjYyBjb2RlLiBJIGFkZGVkCiAgKiBzb21lIGNvbW1lbnRzLCBpbXByb3ZlZCBhIG1pbm9yIGJpdCBhbmQgY29udmVydGVkIGl0IHRvIG1ha2UgdXNlCi0gKiBvZiB0aGUgZ2VuZXJpYyBSZWVkLVNvbG9tb24gbGliYXJ5LiB0Z2x4CisgKiBvZiB0aGUgZ2VuZXJpYyBSZWVkLVNvbG9tb24gbGlicmFyeS4gdGdseAogICovCiBzdGF0aWMgaW50IGRvY19lY2NfZGVjb2RlKHN0cnVjdCByc19jb250cm9sICpycywgdWludDhfdCAqZGF0YSwgdWludDhfdCAqZWNjKQogewpAQCAtNDAwLDcgKzQwMCw3IEBACiAJZG9jMjAweF9od2NvbnRyb2wobXRkLCAwLCBOQU5EX0NUUkxfQUxFIHwgTkFORF9DVFJMX0NIQU5HRSk7CiAJZG9jMjAweF9od2NvbnRyb2wobXRkLCBOQU5EX0NNRF9OT05FLCBOQU5EX05DRSB8IE5BTkRfQ1RSTF9DSEFOR0UpOwogCi0JLyogV2UgY2FudCcgdXNlIGRldl9yZWFkeSBoZXJlLCBidXQgYXQgbGVhc3Qgd2Ugd2FpdCBmb3IgdGhlCisJLyogV2UgY2FuJ3QnIHVzZSBkZXZfcmVhZHkgaGVyZSwgYnV0IGF0IGxlYXN0IHdlIHdhaXQgZm9yIHRoZQogCSAqIGNvbW1hbmQgdG8gY29tcGxldGUKIAkgKi8KIAl1ZGVsYXkoNTApOwpAQCAtOTg2LDcgKzk4Niw3IEBACiAJCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIEVDQ0NvbmYpOwogCX0KIAotCS8qIEVycm9yIG9jY3VyZWQgPyAqLworCS8qIEVycm9yIG9jY3VycmVkID8gKi8KIAlpZiAoZHVtbXkgJiAweDgwKSB7CiAJCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspIHsKIAkJCWlmIChEb0NfaXNfTWlsbGVubml1bVBsdXMoZG9jKSkKQEAgLTExNjAsNyArMTE2MCw3IEBACiAJLyogTk9URTogVGhlIGxpbmVzIGJlbG93IG1vZGlmeSBpbnRlcm5hbCB2YXJpYWJsZXMgb2YgdGhlIE5BTkQgYW5kIE1URAogCSAgIGxheWVyczsgdmFyaWFibGVzIHdpdGggaGF2ZSBhbHJlYWR5IGJlZW4gY29uZmlndXJlZCBieSBuYW5kX3NjYW4uCiAJICAgVW5mb3J0dW5hdGVseSwgd2UgZGlkbid0IGtub3cgYmVmb3JlIHRoaXMgcG9pbnQgd2hhdCB0aGVzZSB2YWx1ZXMKLQkgICBzaG91bGQgYmUuICBUaHVzLCB0aGlzIGNvZGUgaXMgc29tZXdoYXQgZGVwZW5kYW50IG9uIHRoZSBleGFjdAorCSAgIHNob3VsZCBiZS4gIFRodXMsIHRoaXMgY29kZSBpcyBzb21ld2hhdCBkZXBlbmRlbnQgb24gdGhlIGV4YWN0CiAJICAgaW1wbGVtZW50YXRpb24gb2YgdGhlIE5BTkQgbGF5ZXIuICAqLwogCWlmIChtaC0+VW5pdFNpemVGYWN0b3IgIT0gMHhmZikgewogCQl0aGlzLT5iYnRfZXJhc2Vfc2hpZnQgKz0gKDB4ZmYgLSBtaC0+VW5pdFNpemVGYWN0b3IpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9mc2xfZWxiY19uYW5kLmMgYi9kcml2ZXJzL210ZC9uYW5kL2ZzbF9lbGJjX25hbmQuYwppbmRleCA3YTEzZDQyLi41MzdlMzgwIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2ZzbF9lbGJjX25hbmQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL2ZzbF9lbGJjX25hbmQuYwpAQCAtNTksNyArNTksNyBAQAogCXVuc2lnbmVkIGludCBmbXI7ICAgICAgIC8qIEZDTSBGbGFzaCBNb2RlIFJlZ2lzdGVyIHZhbHVlICAgICAqLwogfTsKIAotLyogRnJlZXNjYWxlIGVMQkMgRkNNIGNvbnRyb2xsZXIgaW5mb21hdGlvbiAqLworLyogRnJlZXNjYWxlIGVMQkMgRkNNIGNvbnRyb2xsZXIgaW5mb3JtYXRpb24gKi8KIAogc3RydWN0IGZzbF9lbGJjX2ZjbV9jdHJsIHsKIAlzdHJ1Y3QgbmFuZF9od19jb250cm9sIGNvbnRyb2xsZXI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2ZzbWNfbmFuZC5jIGIvZHJpdmVycy9tdGQvbmFuZC9mc21jX25hbmQuYwppbmRleCAyMDViMTBiLi4wZDQ1ZWYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2ZzbWNfbmFuZC5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvZnNtY19uYW5kLmMKQEAgLTMzNSw3ICszMzUsNyBAQAogCiAvKgogICogZnNtY19yZWFkX2h3ZWNjX2VjYzQgLSBIYXJkd2FyZSBFQ0MgY2FsY3VsYXRvciBmb3IgZWNjNCBvcHRpb24gc3VwcG9ydGVkIGJ5Ci0gKiBGU01DLiBFQ0MgaXMgMTMgYnl0ZXMgZm9yIDUxMiBieXRlcyBvZiBkYXRhIChzdXBwb3J0cyBlcnJvciBjb3JyZWN0aW9uIHVwdG8KKyAqIEZTTUMuIEVDQyBpcyAxMyBieXRlcyBmb3IgNTEyIGJ5dGVzIG9mIGRhdGEgKHN1cHBvcnRzIGVycm9yIGNvcnJlY3Rpb24gdXAgdG8KICAqIG1heCBvZiA4LWJpdHMpCiAgKi8KIHN0YXRpYyBpbnQgZnNtY19yZWFkX2h3ZWNjX2VjYzQoc3RydWN0IG10ZF9pbmZvICptdGQsIGNvbnN0IHVpbnQ4X3QgKmRhdGEsCkBAIC0zODEsNyArMzgxLDcgQEAKIAogLyoKICAqIGZzbWNfcmVhZF9od2VjY19lY2MxIC0gSGFyZHdhcmUgRUNDIGNhbGN1bGF0b3IgZm9yIGVjYzEgb3B0aW9uIHN1cHBvcnRlZCBieQotICogRlNNQy4gRUNDIGlzIDMgYnl0ZXMgZm9yIDUxMiBieXRlcyBvZiBkYXRhIChzdXBwb3J0cyBlcnJvciBjb3JyZWN0aW9uIHVwdG8KKyAqIEZTTUMuIEVDQyBpcyAzIGJ5dGVzIGZvciA1MTIgYnl0ZXMgb2YgZGF0YSAoc3VwcG9ydHMgZXJyb3IgY29ycmVjdGlvbiB1cCB0bwogICogbWF4IG9mIDEtYml0KQogICovCiBzdGF0aWMgaW50IGZzbWNfcmVhZF9od2VjY19lY2MxKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBjb25zdCB1aW50OF90ICpkYXRhLApAQCAtNDA4LDEwICs0MDgsMTAgQEAKICAqIEBidWY6CWJ1ZmZlciB0byBzdG9yZSByZWFkIGRhdGEKICAqIEBwYWdlOglwYWdlIG51bWJlciB0byByZWFkCiAgKgotICogVGhpcyByb3V0aW5lIGlzIG5lZWRlZCBmb3IgZnNtYyB2ZXJpc29uIDggYXMgcmVhZGluZyBmcm9tIE5BTkQgY2hpcCBoYXMgdG8gYmUKKyAqIFRoaXMgcm91dGluZSBpcyBuZWVkZWQgZm9yIGZzbWMgdmVyc2lvbiA4IGFzIHJlYWRpbmcgZnJvbSBOQU5EIGNoaXAgaGFzIHRvIGJlCiAgKiBwZXJmb3JtZWQgaW4gYSBzdHJpY3Qgc2VxdWVuY2UgYXMgZm9sbG93czoKICAqIGRhdGEoNTEyIGJ5dGUpIC0+IGVjYygxMyBieXRlKQotICogQWZ0ZXIgdGhpcyByZWFkLCBmc21jIGhhcmR3YXJlIGdlbmVyYXRlcyBhbmQgcmVwb3J0cyBlcnJvciBkYXRhIGJpdHModXB0byBhCisgKiBBZnRlciB0aGlzIHJlYWQsIGZzbWMgaGFyZHdhcmUgZ2VuZXJhdGVzIGFuZCByZXBvcnRzIGVycm9yIGRhdGEgYml0cyh1cCB0byBhCiAgKiBtYXggb2YgOCBiaXRzKQogICovCiBzdGF0aWMgaW50IGZzbWNfcmVhZF9wYWdlX2h3ZWNjKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLApAQCAtNjg2LDcgKzY4Niw3IEBACiAJfQogCiAJLyoKLQkgKiBTY2FuIHRvIGZpbmQgZXhpc3RhbmNlIG9mIHRoZSBkZXZpY2UKKwkgKiBTY2FuIHRvIGZpbmQgZXhpc3RlbmNlIG9mIHRoZSBkZXZpY2UKIAkgKi8KIAlpZiAobmFuZF9zY2FuX2lkZW50KCZob3N0LT5tdGQsIDEsIE5VTEwpKSB7CiAJCXJldCA9IC1FTlhJTzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYXNlLmMgYi9kcml2ZXJzL210ZC9uYW5kL25hbmRfYmFzZS5jCmluZGV4IDg1Y2ZjMDYuLmM1NGE0Y2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYXNlLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9uYW5kX2Jhc2UuYwpAQCAtMTU4Miw3ICsxNTgyLDcgQEAKIH0KIAogLyoqCi0gKiBuYW5kX3JlYWQgLSBbTVREIEludGVyZmFjZV0gTVREIGNvbXBhYmlsaXR5IGZ1bmN0aW9uIGZvciBuYW5kX2RvX3JlYWRfZWNjCisgKiBuYW5kX3JlYWQgLSBbTVREIEludGVyZmFjZV0gTVREIGNvbXBhdGliaWxpdHkgZnVuY3Rpb24gZm9yIG5hbmRfZG9fcmVhZF9lY2MKICAqIEBtdGQ6CU1URCBkZXZpY2Ugc3RydWN0dXJlCiAgKiBAZnJvbToJb2Zmc2V0IHRvIHJlYWQgZnJvbQogICogQGxlbjoJbnVtYmVyIG9mIGJ5dGVzIHRvIHJlYWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYnQuYyBiL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYnQuYwppbmRleCBhMWU4YjMwLi5hZjQ2NDI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL25hbmRfYmJ0LmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9uYW5kX2JidC5jCkBAIC05NDUsNyArOTQ1LDcgQEAKIAkJcmQyID0gTlVMTDsKIAkJLyogUGVyIGNoaXAgb3IgcGVyIGRldmljZSA/ICovCiAJCWNoaXBzZWwgPSAodGQtPm9wdGlvbnMgJiBOQU5EX0JCVF9QRVJDSElQKSA/IGkgOiAtMTsKLQkJLyogTWlycm9yZWQgdGFibGUgYXZpbGFibGUgPyAqLworCQkvKiBNaXJyb3JlZCB0YWJsZSBhdmFpbGFibGUgPyAqLwogCQlpZiAobWQpIHsKIAkJCWlmICh0ZC0+cGFnZXNbaV0gPT0gLTEgJiYgbWQtPnBhZ2VzW2ldID09IC0xKSB7CiAJCQkJd3JpdGVvcHMgPSAweDAzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9uYW5kc2ltLmMgYi9kcml2ZXJzL210ZC9uYW5kL25hbmRzaW0uYwppbmRleCAyMTMxODFiLi44OTNkOTViIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL25hbmRzaW0uYworKysgYi9kcml2ZXJzL210ZC9uYW5kL25hbmRzaW0uYwpAQCAtMTYyLDcgKzE2Miw3IEBACiBNT0RVTEVfUEFSTV9ERVNDKGdyYXZlcGFnZXMsICAgICAiUGFnZXMgdGhhdCBsb3NlIGRhdGEgWzogbWF4aW11bSByZWFkcyAoZGVmYXVsdHMgdG8gMyldIgogCQkJCSAiIHNlcGFyYXRlZCBieSBjb21tYXMgZS5nLiAxNDAxOjIgbWVhbnMgcGFnZSAxNDAxIgogCQkJCSAiIGNhbiBiZSByZWFkIG9ubHkgdHdpY2UgYmVmb3JlIGZhaWxpbmciKTsKLU1PRFVMRV9QQVJNX0RFU0MocnB0d2VhciwgICAgICAgICJOdW1iZXIgb2YgZXJhc2VzIGluYmV0d2VlbiByZXBvcnRpbmcgd2VhciwgaWYgbm90IHplcm8iKTsKK01PRFVMRV9QQVJNX0RFU0MocnB0d2VhciwgICAgICAgICJOdW1iZXIgb2YgZXJhc2VzIGJldHdlZW4gcmVwb3J0aW5nIHdlYXIsIGlmIG5vdCB6ZXJvIik7CiBNT0RVTEVfUEFSTV9ERVNDKG92ZXJyaWRlc2l6ZSwgICAiU3BlY2lmaWVzIHRoZSBOQU5EIEZsYXNoIHNpemUgb3ZlcnJpZGluZyB0aGUgSUQgYnl0ZXMuICIKIAkJCQkgIlRoZSBzaXplIGlzIHNwZWNpZmllZCBpbiBlcmFzZSBibG9ja3MgYW5kIGFzIHRoZSBleHBvbmVudCBvZiBhIHBvd2VyIG9mIHR3byIKIAkJCQkgIiBlLmcuIDUgbWVhbnMgYSBzaXplIG9mIDMyIGVyYXNlIGJsb2NrcyIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9ub21hZGlrX25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvbm9tYWRpa19uYW5kLmMKaW5kZXggOGMwYjY5My4uYTA0NWE0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9ub21hZGlrX25hbmQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL25vbWFkaWtfbmFuZC5jCkBAIC0xNTEsNyArMTUxLDcgQEAKIAluYW5kLT5vcHRpb25zID0gcGRhdGEtPm9wdGlvbnM7CiAKIAkvKgotCSAqIFNjYW4gdG8gZmluZCBleGlzdGFuY2Ugb2YgdGhlIGRldmljZQorCSAqIFNjYW4gdG8gZmluZCBleGlzdGVuY2Ugb2YgdGhlIGRldmljZQogCSAqLwogCWlmIChuYW5kX3NjYW4oJmhvc3QtPm10ZCwgMSkpIHsKIAkJcmV0ID0gLUVOWElPOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9wYXNlbWlfbmFuZC5jIGIvZHJpdmVycy9tdGQvbmFuZC9wYXNlbWlfbmFuZC5jCmluZGV4IDU5ZWZhODIuLjIwYmZlNWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvcGFzZW1pX25hbmQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3Bhc2VtaV9uYW5kLmMKQEAgLTE1Nyw3ICsxNTcsNyBAQAogCS8qIEVuYWJsZSB0aGUgZm9sbG93aW5nIGZvciBhIGZsYXNoIGJhc2VkIGJhZCBibG9jayB0YWJsZSAqLwogCWNoaXAtPm9wdGlvbnMgPSBOQU5EX1VTRV9GTEFTSF9CQlQgfCBOQU5EX05PX0FVVE9JTkNSOwogCi0JLyogU2NhbiB0byBmaW5kIGV4aXN0YW5jZSBvZiB0aGUgZGV2aWNlICovCisJLyogU2NhbiB0byBmaW5kIGV4aXN0ZW5jZSBvZiB0aGUgZGV2aWNlICovCiAJaWYgKG5hbmRfc2NhbihwYXNlbWlfbmFuZF9tdGQsIDEpKSB7CiAJCWVyciA9IC1FTlhJTzsKIAkJZ290byBvdXRfbHBjOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9wbGF0X25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvcGxhdF9uYW5kLmMKaW5kZXggMzE3YWZmNC4uY2FmNWE3MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9wbGF0X25hbmQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3BsYXRfbmFuZC5jCkBAIC05NSw3ICs5NSw3IEBACiAJCQlnb3RvIG91dDsKIAl9CiAKLQkvKiBTY2FuIHRvIGZpbmQgZXhpc3RhbmNlIG9mIHRoZSBkZXZpY2UgKi8KKwkvKiBTY2FuIHRvIGZpbmQgZXhpc3RlbmNlIG9mIHRoZSBkZXZpY2UgKi8KIAlpZiAobmFuZF9zY2FuKCZkYXRhLT5tdGQsIHBkYXRhLT5jaGlwLm5yX2NoaXBzKSkgewogCQllcnIgPSAtRU5YSU87CiAJCWdvdG8gb3V0OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9weGEzeHhfbmFuZC5jIGIvZHJpdmVycy9tdGQvbmFuZC9weGEzeHhfbmFuZC5jCmluZGV4IGFiN2Y0YzMuLmZmMDcwMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvcHhhM3h4X25hbmQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3B4YTN4eF9uYW5kLmMKQEAgLTE4NCw3ICsxODQsNyBAQAogCiBzdGF0aWMgaW50IHVzZV9kbWEgPSAxOwogbW9kdWxlX3BhcmFtKHVzZV9kbWEsIGJvb2wsIDA0NDQpOwotTU9EVUxFX1BBUk1fREVTQyh1c2VfZG1hLCAiZW5hYmxlIERNQSBmb3IgZGF0YSB0cmFuc2ZlcmluZyB0by9mcm9tIE5BTkQgSFciKTsKK01PRFVMRV9QQVJNX0RFU0ModXNlX2RtYSwgImVuYWJsZSBETUEgZm9yIGRhdGEgdHJhbnNmZXJyaW5nIHRvL2Zyb20gTkFORCBIVyIpOwogCiAvKgogICogRGVmYXVsdCBOQU5EIGZsYXNoIGNvbnRyb2xsZXIgY29uZmlndXJhdGlvbiBzZXR1cCBieSB0aGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvcjg1Mi5jIGIvZHJpdmVycy9tdGQvbmFuZC9yODUyLmMKaW5kZXggNjMyMmQxZi4uY2FlMmUwMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9yODUyLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9yODUyLmMKQEAgLTE4NSw3ICsxODUsNyBAQAogCiAJZGJnX3ZlcmJvc2UoImRvaW5nIGRtYSAlcyAiLCBkb19yZWFkID8gInJlYWQiIDogIndyaXRlIik7CiAKLQkvKiBTZXQgaW50aWFsIGRtYSBzdGF0ZTogZm9yIHJlYWRpbmcgZmlyc3QgZmlsbCBvbiBib2FyZCBidWZmZXIsCisJLyogU2V0IGluaXRpYWwgZG1hIHN0YXRlOiBmb3IgcmVhZGluZyBmaXJzdCBmaWxsIG9uIGJvYXJkIGJ1ZmZlciwKIAkgIGZyb20gZGV2aWNlLCBmb3Igd3JpdGVzIGZpcnN0IGZpbGwgdGhlIGJ1ZmZlciAgZnJvbSBtZW1vcnkqLwogCWRldi0+ZG1hX3N0YXRlID0gZG9fcmVhZCA/IERNQV9JTlRFUk5BTCA6IERNQV9NRU1PUlk7CiAKQEAgLTc2Niw3ICs3NjYsNyBAQAogCQlyZXQgPSBJUlFfSEFORExFRDsKIAkJZGV2LT5jYXJkX2RldGVjdGVkID0gISEoY2FyZF9zdGF0dXMgJiBSODUyX0NBUkRfSVJRX0lOU0VSVCk7CiAKLQkJLyogd2Ugc2hvdWxkbid0IHJlY2lldmUgYW55IGludGVycnVwdHMgaWYgd2Ugd2FpdCBmb3IgY2FyZAorCQkvKiB3ZSBzaG91bGRuJ3QgcmVjZWl2ZSBhbnkgaW50ZXJydXB0cyBpZiB3ZSB3YWl0IGZvciBjYXJkCiAJCQl0byBzZXR0bGUgKi8KIAkJV0FSTl9PTihkZXYtPmNhcmRfdW5zdGFibGUpOwogCkBAIC03OTQsMTMgKzc5NCwxMyBAQAogCQlyZXQgPSBJUlFfSEFORExFRDsKIAogCQlpZiAoZG1hX3N0YXR1cyAmIFI4NTJfRE1BX0lSUV9FUlJPUikgewotCQkJZGJnKCJyZWNpZXZlZCBkbWEgZXJyb3IgSVJRIik7CisJCQlkYmcoInJlY2VpdmVkIGRtYSBlcnJvciBJUlEiKTsKIAkJCXI4NTJfZG1hX2RvbmUoZGV2LCAtRUlPKTsKIAkJCWNvbXBsZXRlKCZkZXYtPmRtYV9kb25lKTsKIAkJCWdvdG8gb3V0OwogCQl9CiAKLQkJLyogcmVjaWV2ZWQgRE1BIGludGVycnVwdCBvdXQgb2Ygbm93aGVyZT8gKi8KKwkJLyogcmVjZWl2ZWQgRE1BIGludGVycnVwdCBvdXQgb2Ygbm93aGVyZT8gKi8KIAkJV0FSTl9PTl9PTkNFKGRldi0+ZG1hX3N0YWdlID09IDApOwogCiAJCWlmIChkZXYtPmRtYV9zdGFnZSA9PSAwKQpAQCAtOTYwLDcgKzk2MCw3IEBACiAJCSZkZXYtPmNhcmRfZGV0ZWN0X3dvcmssIDApOwogCiAKLQlwcmludGsoS0VSTl9OT1RJQ0UgRFJWX05BTUUgIjogZHJpdmVyIGxvYWRlZCBzdWNjZXNmdWxseVxuIik7CisJcHJpbnRrKEtFUk5fTk9USUNFIERSVl9OQU1FICI6IGRyaXZlciBsb2FkZWQgc3VjY2Vzc2Z1bGx5XG4iKTsKIAlyZXR1cm4gMDsKIAogZXJyb3IxMDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvc2hfZmxjdGwuYyBiL2RyaXZlcnMvbXRkL25hbmQvc2hfZmxjdGwuYwppbmRleCA1NDZjMmYwLi44MWJiYjVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL3NoX2ZsY3RsLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9zaF9mbGN0bC5jCkBAIC03OCw3ICs3OCw3IEBACiAKIHN0YXRpYyB2b2lkIHRpbWVvdXRfZXJyb3Ioc3RydWN0IHNoX2ZsY3RsICpmbGN0bCwgY29uc3QgY2hhciAqc3RyKQogewotCWRldl9lcnIoJmZsY3RsLT5wZGV2LT5kZXYsICJUaW1lb3V0IG9jY3VyZWQgaW4gJXNcbiIsIHN0cik7CisJZGV2X2VycigmZmxjdGwtPnBkZXYtPmRldiwgIlRpbWVvdXQgb2NjdXJyZWQgaW4gJXNcbiIsIHN0cik7CiB9CiAKIHN0YXRpYyB2b2lkIHdhaXRfY29tcGxldGlvbihzdHJ1Y3Qgc2hfZmxjdGwgKmZsY3RsKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9zbV9jb21tb24uYyBiL2RyaXZlcnMvbXRkL25hbmQvc21fY29tbW9uLmMKaW5kZXggNGE4ZjM2Ny4uNTdjYzgwYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9zbV9jb21tb24uYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3NtX2NvbW1vbi5jCkBAIC0xMjEsNyArMTIxLDcgQEAKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwogCi0JLyogQmFkIGJsb2NrIG1hcmtlciBwb3N0aW9uICovCisJLyogQmFkIGJsb2NrIG1hcmtlciBwb3NpdGlvbiAqLwogCWNoaXAtPmJhZGJsb2NrcG9zID0gMHgwNTsKIAljaGlwLT5iYWRibG9ja2JpdHMgPSA3OwogCWNoaXAtPmJsb2NrX21hcmtiYWQgPSBzbV9ibG9ja19tYXJrYmFkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC90bWlvX25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvdG1pb19uYW5kLmMKaW5kZXggMzhmYjE2Ny4uMTRjNTc4NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC90bWlvX25hbmQuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3RtaW9fbmFuZC5jCkBAIC00LDcgKzQsNyBAQAogICogU2xpZ2h0bHkgbXVya3kgcHJlLWdpdCBoaXN0b3J5IG9mIHRoZSBkcml2ZXI6CiAgKgogICogQ29weXJpZ2h0IChjKSBJYW4gTW9sdG9uIDIwMDQsIDIwMDUsIDIwMDgKLSAqICAgIE9yaWdpbmFsIHdvcmssIGluZGVwZW5kYW50IG9mIHNoYXJwcyBjb2RlLiBJbmNsdWRlZCBoYXJkd2FyZSBFQ0Mgc3VwcG9ydC4KKyAqICAgIE9yaWdpbmFsIHdvcmssIGluZGVwZW5kZW50IG9mIHNoYXJwcyBjb2RlLiBJbmNsdWRlZCBoYXJkd2FyZSBFQ0Mgc3VwcG9ydC4KICAqICAgIEhhcmQgRUNDIGRpZCBub3Qgd29yayBmb3Igd3JpdGVzIGluIHRoZSBlYXJseSByZXZpc2lvbnMuCiAgKiBDb3B5cmlnaHQgKGMpIERpcmsgT3BmZXIgMjAwNS4KICAqICAgIE1vZGlmaWNhdGlvbnMgZGV2ZWxvcGVkIGZyb20gc2hhcnBzIGNvZGUgYnV0CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9vbmVuYW5kL29tYXAyLmMgYi9kcml2ZXJzL210ZC9vbmVuYW5kL29tYXAyLmMKaW5kZXggZjU5MWY2MS4uMWZjYjQxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvb25lbmFuZC9vbWFwMi5jCisrKyBiL2RyaXZlcnMvbXRkL29uZW5hbmQvb21hcDIuYwpAQCAtNjA4LDcgKzYwOCw3IEBACiAKIAlyZXQgPSByZWd1bGF0b3JfZW5hYmxlKGMtPnJlZ3VsYXRvcik7CiAJaWYgKHJldCAhPSAwKQotCQlkZXZfZXJyKCZjLT5wZGV2LT5kZXYsICJjYW50IGVuYWJsZSByZWd1bGF0b3JcbiIpOworCQlkZXZfZXJyKCZjLT5wZGV2LT5kZXYsICJjYW4ndCBlbmFibGUgcmVndWxhdG9yXG4iKTsKIAogCXJldHVybiByZXQ7CiB9CkBAIC02MjAsNyArNjIwLDcgQEAKIAogCXJldCA9IHJlZ3VsYXRvcl9kaXNhYmxlKGMtPnJlZ3VsYXRvcik7CiAJaWYgKHJldCAhPSAwKQotCQlkZXZfZXJyKCZjLT5wZGV2LT5kZXYsICJjYW50IGRpc2FibGUgcmVndWxhdG9yXG4iKTsKKwkJZGV2X2VycigmYy0+cGRldi0+ZGV2LCAiY2FuJ3QgZGlzYWJsZSByZWd1bGF0b3JcbiIpOwogCiAJcmV0dXJuIHJldDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL29uZW5hbmQvb25lbmFuZF9zaW0uYyBiL2RyaXZlcnMvbXRkL29uZW5hbmQvb25lbmFuZF9zaW0uYwppbmRleCA4YjI0NjA2Li41ZWYzYmQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9vbmVuYW5kL29uZW5hbmRfc2ltLmMKKysrIGIvZHJpdmVycy9tdGQvb25lbmFuZC9vbmVuYW5kX3NpbS5jCkBAIC0zMjEsNyArMzIxLDcgQEAKIAkJCQljb250aW51ZTsKIAkJCWlmIChtZW1jbXAoZGVzdCArIG9mZiwgZmZjaGFycywgdGhpcy0+c3VicGFnZXNpemUpICYmCiAJCQkgICAgb25lbmFuZF9jaGVja19vdmVyd3JpdGUoZGVzdCArIG9mZiwgc3JjICsgb2ZmLCB0aGlzLT5zdWJwYWdlc2l6ZSkpCi0JCQkJcHJpbnRrKEtFUk5fRVJSICJvdmVyLXdyaXRlIGhhcHBlbmQgYXQgMHglMDh4XG4iLCBvZmZzZXQpOworCQkJCXByaW50ayhLRVJOX0VSUiAib3Zlci13cml0ZSBoYXBwZW5lZCBhdCAweCUwOHhcbiIsIG9mZnNldCk7CiAJCQltZW1jcHkoZGVzdCArIG9mZiwgc3JjICsgb2ZmLCB0aGlzLT5zdWJwYWdlc2l6ZSk7CiAJCX0KIAkJLyogRmFsbCB0aHJvdWdoICovCkBAIC0zMzUsNyArMzM1LDcgQEAKIAkJZGVzdCA9IE9ORU5BTkRfQ09SRV9TUEFSRShmbGFzaCwgdGhpcywgb2Zmc2V0KTsKIAkJaWYgKG1lbWNtcChkZXN0LCBmZmNoYXJzLCBtdGQtPm9vYnNpemUpICYmCiAJCSAgICBvbmVuYW5kX2NoZWNrX292ZXJ3cml0ZShkZXN0LCBzcmMsIG10ZC0+b29ic2l6ZSkpCi0JCQlwcmludGsoS0VSTl9FUlIgIk9PQjogb3Zlci13cml0ZSBoYXBwZW5kIGF0IDB4JTA4eFxuIiwKKwkJCXByaW50ayhLRVJOX0VSUiAiT09COiBvdmVyLXdyaXRlIGhhcHBlbmVkIGF0IDB4JTA4eFxuIiwKIAkJCSAgICAgICBvZmZzZXQpOwogCQltZW1jcHkoZGVzdCwgc3JjLCBtdGQtPm9vYnNpemUpOwogCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL3NtX2Z0bC5jIGIvZHJpdmVycy9tdGQvc21fZnRsLmMKaW5kZXggMmIwZGFhZS4uZWQzZDZjZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvc21fZnRsLmMKKysrIGIvZHJpdmVycy9tdGQvc21fZnRsLmMKQEAgLTU0MCw3ICs1NDAsNyBAQAogCQkJcmV0dXJuIC1FSU87CiAJfQogCi0JLyogSWYgdGhlIGJsb2NrIGlzIHNsaWNlZCAocGFydGlhbHkgZXJhc2VkIHVzdWFsbHkpIGVyYXNlIGl0ICovCisJLyogSWYgdGhlIGJsb2NrIGlzIHNsaWNlZCAocGFydGlhbGx5IGVyYXNlZCB1c3VhbGx5KSBlcmFzZSBpdCAqLwogCWlmIChpID09IDIpIHsKIAkJc21fZXJhc2VfYmxvY2soZnRsLCB6b25lLCBibG9jaywgMSk7CiAJCXJldHVybiAxOwpAQCAtODc4LDcgKzg3OCw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLS8qIEdldCBhbmQgYXV0b21hdGljbHkgaW5pdGlhbGl6ZSBhbiBGVEwgbWFwcGluZyBmb3Igb25lIHpvbmUgKi8KKy8qIEdldCBhbmQgYXV0b21hdGljYWxseSBpbml0aWFsaXplIGFuIEZUTCBtYXBwaW5nIGZvciBvbmUgem9uZSAqLwogc3RydWN0IGZ0bF96b25lICpzbV9nZXRfem9uZShzdHJ1Y3Qgc21fZnRsICpmdGwsIGludCB6b25lX251bSkKIHsKIAlzdHJ1Y3QgZnRsX3pvbmUgKnpvbmU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC91YmkvS2NvbmZpZyBiL2RyaXZlcnMvbXRkL3ViaS9LY29uZmlnCmluZGV4IDZhYmViNGYuLjRkY2M3NTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL3ViaS9LY29uZmlnCisrKyBiL2RyaXZlcnMvbXRkL3ViaS9LY29uZmlnCkBAIC01Niw3ICs1Niw3IEBACiAJYm9vbCAiVUJJIGRlYnVnZ2luZyIKIAlkZXBlbmRzIG9uIFNZU0ZTCiAJc2VsZWN0IERFQlVHX0ZTCi0Jc2VsZWN0IEtBTExTWU1TX0FMTCBpZiBLQUxMU1lNUyAmJiBERUJVR19LRVJORUwKKwlzZWxlY3QgS0FMTFNZTVMKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBlbmFibGVzIFVCSSBkZWJ1Z2dpbmcuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL3ViaS9pby5jIGIvZHJpdmVycy9tdGQvdWJpL2lvLmMKaW5kZXggZWVkZWRmOS4uZTM0N2NjNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvdWJpL2lvLmMKKysrIGIvZHJpdmVycy9tdGQvdWJpL2lvLmMKQEAgLTM0NCw2ICszNDQsMTIgQEAKIAl3YWl0X3F1ZXVlX2hlYWRfdCB3cTsKIAogCWRiZ19pbygiZXJhc2UgUEVCICVkIiwgcG51bSk7CisJdWJpX2Fzc2VydChwbnVtID49IDAgJiYgcG51bSA8IHViaS0+cGViX2NvdW50KTsKKworCWlmICh1YmktPnJvX21vZGUpIHsKKwkJdWJpX2VycigicmVhZC1vbmx5IG1vZGUiKTsKKwkJcmV0dXJuIC1FUk9GUzsKKwl9CiAKIHJldHJ5OgogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJndxKTsKQEAgLTM5MCw3ICszOTYsNyBAQAogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQlpZiAodWJpX2RiZ19pc19lcmFzZV9mYWlsdXJlKCkgJiYgIWVycikgeworCWlmICh1YmlfZGJnX2lzX2VyYXNlX2ZhaWx1cmUoKSkgewogCQlkYmdfZXJyKCJjYW5ub3QgZXJhc2UgUEVCICVkIChlbXVsYXRlZCkiLCBwbnVtKTsKIAkJcmV0dXJuIC1FSU87CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvdWJpL3NjYW4uYyBiL2RyaXZlcnMvbXRkL3ViaS9zY2FuLmMKaW5kZXggMTFlYjhlZi4uZDJkMTJhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvdWJpL3NjYW4uYworKysgYi9kcml2ZXJzL210ZC91Ymkvc2Nhbi5jCkBAIC05NjgsNyArOTY4LDcgQEAKIAkJCSAqIGNvbnRhaW5zIGdhcmJhZ2UgYmVjYXVzZSBvZiBhIHBvd2VyIGN1dCBkdXJpbmcgZXJhc2UKIAkJCSAqIG9wZXJhdGlvbi4gU28gd2UganVzdCBzY2hlZHVsZSB0aGlzIFBFQiBmb3IgZXJhc3VyZS4KIAkJCSAqCi0JCQkgKiBCZXNpZGVzLCBpbiBjYXNlIG9mIE5PUiBmbGFzaCwgd2UgZGVsaWJlcmF0bHkKKwkJCSAqIEJlc2lkZXMsIGluIGNhc2Ugb2YgTk9SIGZsYXNoLCB3ZSBkZWxpYmVyYXRlbHkKIAkJCSAqIGNvcnJ1cHQgYm90aCBoZWFkZXJzIGJlY2F1c2UgTk9SIGZsYXNoIGVyYXN1cmUgaXMKIAkJCSAqIHNsb3cgYW5kIGNhbiBzdGFydCBmcm9tIHRoZSBlbmQuCiAJCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL3ViaS92bXQuYyBiL2RyaXZlcnMvbXRkL3ViaS92bXQuYwppbmRleCBiNzllMGRlLi4zNjZlYjcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC91Ymkvdm10LmMKKysrIGIvZHJpdmVycy9tdGQvdWJpL3ZtdC5jCkBAIC03OTAsMTEgKzc5MCw2IEBACiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoIXZvbC0+bmFtZSkgewotCQl1YmlfZXJyKCJOVUxMIHZvbHVtZSBuYW1lIik7Ci0JCWdvdG8gZmFpbDsKLQl9Ci0KIAluID0gc3Rybmxlbih2b2wtPm5hbWUsIHZvbC0+bmFtZV9sZW4gKyAxKTsKIAlpZiAobiAhPSB2b2wtPm5hbWVfbGVuKSB7CiAJCXViaV9lcnIoImJhZCBuYW1lX2xlbiAlbGxkIiwgbik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC8zYzUwMS5jIGIvZHJpdmVycy9uZXQvM2M1MDEuYwppbmRleCA5ZTFjMDNlLi41NDIwZjZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC8zYzUwMS5jCisrKyBiL2RyaXZlcnMvbmV0LzNjNTAxLmMKQEAgLTM5OSw3ICszOTksNyBAQAogICogYXMgd2UgbWF5IHN0aWxsIGJlIGF0dGVtcHRpbmcgdG8gcmV0cmlldmUgdGhlIGxhc3QgUlggcGFja2V0IGJ1ZmZlci4KICAqCiAgKiBXaGVuIGEgdHJhbnNtaXQgdGltZXMgb3V0IHdlIGR1bXAgdGhlIGNhcmQgaW50byBjb250cm9sIG1vZGUgYW5kIGp1c3QKLSAqIHN0YXJ0IGFnYWluLiBJdCBoYXBwZW5zIGVub3VnaCB0aGF0IGl0IGlzbnQgd29ydGggbG9nZ2luZy4KKyAqIHN0YXJ0IGFnYWluLiBJdCBoYXBwZW5zIGVub3VnaCB0aGF0IGl0IGlzbid0IHdvcnRoIGxvZ2dpbmcuCiAgKgogICogV2UgYXZvaWQgaG9sZGluZyB0aGUgc3BpbiBsb2NrcyB3aGVuIGRvaW5nIHRoZSBwYWNrZXQgbG9hZCB0byB0aGUgYm9hcmQuCiAgKiBUaGUgZGV2aWNlIGlzIHZlcnkgc2xvdywgYW5kIGl0cyBETUEgbW9kZSBpcyBldmVuIHNsb3dlci4gSWYgd2UgaGVsZCB0aGUKQEAgLTQ5OSw3ICs0OTksNyBAQAogICoKICAqIEhhbmRsZSB0aGUgZXRoZXIgaW50ZXJmYWNlIGludGVycnVwdHMuIFRoZSAzYzUwMSBuZWVkcyBhIGxvdCBtb3JlCiAgKiBoYW5kIGhvbGRpbmcgdGhhbiBtb3N0IGNhcmRzLiBJbiBwYXJ0aWN1bGFyIHdlIGdldCBhIHRyYW5zbWl0IGludGVycnVwdAotICogd2l0aCBhIGNvbGxpc2lvbiBlcnJvciBiZWNhdXNlIHRoZSBib2FyZCBmaXJtd2FyZSBpc250IGNhcGFibGUgb2YgcmV3aW5kaW5nCisgKiB3aXRoIGEgY29sbGlzaW9uIGVycm9yIGJlY2F1c2UgdGhlIGJvYXJkIGZpcm13YXJlIGlzbid0IGNhcGFibGUgb2YgcmV3aW5kaW5nCiAgKiBpdHMgb3duIHRyYW5zbWl0IGJ1ZmZlciBwb2ludGVycy4gSXQgY2FuIGhvd2V2ZXIgY291bnQgdG8gMTYgZm9yIHVzLgogICoKICAqIE9uIHRoZSByZWNlaXZlIHNpZGUgdGhlIGNhcmQgaXMgYWxzbyB2ZXJ5IGR1bWIuIEl0IGhhcyBubyBidWZmZXJpbmcgdG8KQEAgLTczMiw3ICs3MzIsNyBAQAogICogZWxfcmVzZXQ6IFJlc2V0IGEgM2M1MDEgY2FyZAogICogQGRldjogVGhlIDNjNTAxIGNhcmQgYWJvdXQgdG8gZ2V0IHphcHBlZAogICoKLSAqIEV2ZW4gcmVzZXR0aW5nIGEgM2M1MDEgaXNudCBzaW1wbGUuIFdoZW4geW91IGFjdGl2YXRlIHJlc2V0IGl0IGxvc2VzIGFsbAorICogRXZlbiByZXNldHRpbmcgYSAzYzUwMSBpc24ndCBzaW1wbGUuIFdoZW4geW91IGFjdGl2YXRlIHJlc2V0IGl0IGxvc2VzIGFsbAogICogaXRzIGNvbmZpZ3VyYXRpb24uIFlvdSBtdXN0IGhvbGQgdGhlIGxvY2sgd2hlbiBkb2luZyB0aGlzLiBUaGUgZnVuY3Rpb24KICAqIGNhbm5vdCB0YWtlIHRoZSBsb2NrIGl0c2VsZiBhcyBpdCBpcyBjYWxsYWJsZSBmcm9tIHRoZSBpcnEgaGFuZGxlci4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvM2M1MjMuYyBiL2RyaXZlcnMvbmV0LzNjNTIzLmMKaW5kZXggZGU1NzlkMC4uYmMwZDFhMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvM2M1MjMuYworKysgYi9kcml2ZXJzL25ldC8zYzUyMy5jCkBAIC00NCw3ICs0NCw3IEBACiAgICB0aGlzIGZvciB0aGUgNjRLIHZlcnNpb24gd291bGQgcmVxdWlyZSBhIGxvdCBvZiBoZWlub3VzIGJhbmsKICAgIHN3aXRjaGluZywgd2hpY2ggSSdtIHN1cmUgbm90IGludGVyZXN0ZWQgaW4gZG9pbmcuICBJZiB5b3UgdHJ5IHRvCiAgICBpbXBsZW1lbnQgYSBiYW5rIHN3aXRjaGluZyB2ZXJzaW9uLCB5b3UnbGwgYmFzaWNhbGx5IGhhdmUgdG8gcmVtZW1iZXIKLSAgIHdoYXQgYmFuayBpcyBlbmFibGVkIGFuZCBkbyBhIHN3aXRjaCBldmVyeXRpbWUgeW91IGFjY2VzcyBhIG1lbW9yeQorICAgd2hhdCBiYW5rIGlzIGVuYWJsZWQgYW5kIGRvIGEgc3dpdGNoIGV2ZXJ5IHRpbWUgeW91IGFjY2VzcyBhIG1lbW9yeQogICAgbG9jYXRpb24gdGhhdCdzIG5vdCBjdXJyZW50LiAgWW91J2xsIGFsc28gaGF2ZSB0byByZW1hcCBwb2ludGVycyBvbgogICAgdGhlIGRyaXZlciBzaWRlLCBiZWNhdXNlIGl0IG9ubHkga25vd3MgYWJvdXQgMTZLIG9mIHRoZSBtZW1vcnkuCiAgICBBbnlvbmUgZGVzcGVyYXRlIG9yIG1hc29jaGlzdGljIGVub3VnaCB0byB0cnk/CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC8zYzUyNy5jIGIvZHJpdmVycy9uZXQvM2M1MjcuYwppbmRleCA4YzA5NGJhLi5kOWQwNTZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC8zYzUyNy5jCisrKyBiL2RyaXZlcnMvbmV0LzNjNTI3LmMKQEAgLTUxLDcgKzUxLDcgQEAKICAqCWNpcmN1bGFyIGJ1ZmZlciBxdWV1ZXMuCiAgKgogICoJVGhlIG1haWxib3hlcyBjYW4gYmUgdXNlZCBmb3IgY29udHJvbGxpbmcgaG93IHRoZSBjYXJkIHRyYXZlcnNlcwotICoJaXRzIGJ1ZmZlciByaW5ncywgYnV0IGFyZSB1c2VkIG9ubHkgZm9yIGluaXRhbCBzZXR1cCBpbiB0aGlzCisgKglpdHMgYnVmZmVyIHJpbmdzLCBidXQgYXJlIHVzZWQgb25seSBmb3IgaW5pdGlhbCBzZXR1cCBpbiB0aGlzCiAgKglpbXBsZW1lbnRhdGlvbi4gIFRoZSBleGVjIG1haWxib3ggYWxsb3dzIGEgdmFyaWV0eSBvZiBjb21tYW5kcyB0bwogICoJYmUgZXhlY3V0ZWQuIEVhY2ggY29tbWFuZCBtdXN0IGNvbXBsZXRlIGJlZm9yZSB0aGUgbmV4dCBpcwogICoJZXhlY3V0ZWQuIFByaW1hcmlseSB3ZSB1c2UgdGhlIGV4ZWMgbWFpbGJveCBmb3IgY29udHJvbGxpbmcgdGhlCkBAIC04MTMsNyArODEzLDcgQEAKICAqCiAgKglUaGlzIHNldHMgdXAgdGhlIGhvc3QgdHJhbnNtaXQgZGF0YS1zdHJ1Y3R1cmVzLgogICoKLSAqCUZpcnN0LCB3ZSBvYnRhaW4gZnJvbSB0aGUgY2FyZCBpdCdzIGN1cnJlbnQgcG9zdGlvbiBpbiB0aGUgdHgKKyAqCUZpcnN0LCB3ZSBvYnRhaW4gZnJvbSB0aGUgY2FyZCBpdCdzIGN1cnJlbnQgcG9zaXRpb24gaW4gdGhlIHR4CiAgKglyaW5nLCBzbyB0aGF0IHdlIHdpbGwga25vdyB3aGVyZSB0byBiZWdpbiB0cmFuc21pdHRpbmcKICAqCXBhY2tldHMuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvM2M1OXguYyBiL2RyaXZlcnMvbmV0LzNjNTl4LmMKaW5kZXggMGE5MjQzNmYuLjhjYzIyNTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0LzNjNTl4LmMKKysrIGIvZHJpdmVycy9uZXQvM2M1OXguYwpAQCAtOTg0LDcgKzk4NCw3IEBACiAJCSAqIGFueSBkZXZpY2UgaGF2ZSBiZWVuIGZvdW5kIHdoZW4gd2UgZXhpdCBmcm9tCiAJCSAqIGVpc2FfZHJpdmVyX3JlZ2lzdGVyICh0aGUgYnVzIHJvb3QgZHJpdmVyIG1heSBub3QgYmUKIAkJICogaW5pdGlhbGl6ZWQgeWV0KS4gU28gd2UgYmxpbmRseSBhc3N1bWUgc29tZXRoaW5nIHdhcwotCQkgKiBmb3VuZCwgYW5kIGxldCB0aGUgc3lzZnMgbWFnaWMgaGFwcGVuZC4uLgorCQkgKiBmb3VuZCwgYW5kIGxldCB0aGUgc3lzZnMgbWFnaWMgaGFwcGVuZWQuLi4KIAkJICovCiAJCWVpc2FfZm91bmQgPSAxOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2FjZW5pYy5jIGIvZHJpdmVycy9uZXQvYWNlbmljLmMKaW5kZXggNDFkOTkxMS4uZWU2NDhmZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYWNlbmljLmMKKysrIGIvZHJpdmVycy9uZXQvYWNlbmljLmMKQEAgLTE1ODQsNyArMTU4NCw3IEBACiAJLyoKIAkgKiBXZSBoYXZlbid0IHJlY2VpdmVkIGEgc3RhdHMgdXBkYXRlIGV2ZW50IGZvciBtb3JlIHRoYW4gMi41CiAJICogc2Vjb25kcyBhbmQgdGhlcmUgaXMgZGF0YSBpbiB0aGUgdHJhbnNtaXQgcXVldWUsIHRodXMgd2UKLQkgKiBhc3VtZSB0aGUgY2FyZCBpcyBzdHVjay4KKwkgKiBhc3N1bWUgdGhlIGNhcmQgaXMgc3R1Y2suCiAJICovCiAJaWYgKCphcC0+dHhfY3NtICE9IGFwLT50eF9yZXRfY3NtKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBUcmFuc21pdHRlciBpcyBzdHVjaywgJTA4eFxuIiwKQEAgLTI1NjQsNyArMjU2NCw3IEBACiAKIAkJLyoKIAkJICogQSBUWC1kZXNjcmlwdG9yIHByb2R1Y2VyIChhbiBJUlEpIG1pZ2h0IGhhdmUgZ290dGVuCi0JCSAqIGluYmV0d2VlbiwgbWFraW5nIHRoZSByaW5nIGZyZWUgYWdhaW4uIFNpbmNlIHhtaXQgaXMKKwkJICogYmV0d2VlbiwgbWFraW5nIHRoZSByaW5nIGZyZWUgYWdhaW4uIFNpbmNlIHhtaXQgaXMKIAkJICogc2VyaWFsaXplZCwgdGhpcyBpcyB0aGUgb25seSBzaXR1YXRpb24gd2UgaGF2ZSB0bwogCQkgKiByZS10ZXN0LgogCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2FtZDgxMTFlLmMgYi9kcml2ZXJzL25ldC9hbWQ4MTExZS5jCmluZGV4IDJjYTg4MGIuLjg4NDk1YzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2FtZDgxMTFlLmMKKysrIGIvZHJpdmVycy9uZXQvYW1kODExMWUuYwpAQCAtMTM5OCw3ICsxMzk4LDcgQEAKIAkJbWNfZmlsdGVyWzFdID0gbWNfZmlsdGVyWzBdID0gMDsKIAkJbHAtPm9wdGlvbnMgJj0gfk9QVElPTl9NVUxUSUNBU1RfRU5BQkxFOwogCQlhbWQ4MTExZV93cml0ZXEoKih1NjQqKW1jX2ZpbHRlcixscC0+bW1pbyArIExBRFJGKTsKLQkJLyogZGlzYWJsZSBwcm9taXNjb3VzIG1vZGUgKi8KKwkJLyogZGlzYWJsZSBwcm9taXNjdW91cyBtb2RlICovCiAJCXdyaXRlbChQUk9NLCBscC0+bW1pbyArIENNRDIpOwogCQlyZXR1cm47CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYXQxNzAwLmMgYi9kcml2ZXJzL25ldC9hdDE3MDAuYwppbmRleCBmNDc0NGZjLi42NWE3OGY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9hdDE3MDAuYworKysgYi9kcml2ZXJzL25ldC9hdDE3MDAuYwpAQCAtMTMzLDcgKzEzMyw3IEBACiAvKiBSdW4tdGltZSByZWdpc3RlciBiYW5rIDIgZGVmaW5pdGlvbnMuICovCiAjZGVmaW5lIERBVEFQT1JUCQk4CQkvKiBXb3JkLXdpZGUgRE1BIG9yIHByb2dyYW1tZWQtSS9PIGRhdGFwb3J0LiAqLwogI2RlZmluZSBUWF9TVEFSVAkJMTAKLSNkZWZpbmUgQ09MMTZDTlRMCQkxMQkJLyogQ29udHJvbGwgUmVnIGZvciAxNiBjb2xsaXNpb25zICovCisjZGVmaW5lIENPTDE2Q05UTAkJMTEJCS8qIENvbnRyb2wgUmVnIGZvciAxNiBjb2xsaXNpb25zICovCiAjZGVmaW5lIE1PREUxMwkJCTEzCiAjZGVmaW5lIFJYX0NUUkwJCQkxNAogLyogQ29uZmlndXJhdGlvbiByZWdpc3RlcnMgb25seSBvbiB0aGUgJzg2NUEvQiBjaGlwcy4gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2F0bDFlL2F0bDFlX21haW4uYyBiL2RyaXZlcnMvbmV0L2F0bDFlL2F0bDFlX21haW4uYwppbmRleCAxZmYwMDFhLi5iMGE3MWUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9hdGwxZS9hdGwxZV9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvYXRsMWUvYXRsMWVfbWFpbi5jCkBAIC0yNTA5LDcgKzI1MDksNyBAQAogCS5pZF90YWJsZSA9IGF0bDFlX3BjaV90YmwsCiAJLnByb2JlICAgID0gYXRsMWVfcHJvYmUsCiAJLnJlbW92ZSAgID0gX19kZXZleGl0X3AoYXRsMWVfcmVtb3ZlKSwKLQkvKiBQb3dlciBNYW5hZ21lbnQgSG9va3MgKi8KKwkvKiBQb3dlciBNYW5hZ2VtZW50IEhvb2tzICovCiAjaWZkZWYgQ09ORklHX1BNCiAJLnN1c3BlbmQgID0gYXRsMWVfc3VzcGVuZCwKIAkucmVzdW1lICAgPSBhdGwxZV9yZXN1bWUsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9hdGx4L2F0bDIuYyBiL2RyaXZlcnMvbmV0L2F0bHgvYXRsMi5jCmluZGV4IDkzN2VmMWEuLmUzY2JmNDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2F0bHgvYXRsMi5jCisrKyBiL2RyaXZlcnMvbmV0L2F0bHgvYXRsMi5jCkBAIC0xNzAxLDcgKzE3MDEsNyBAQAogCS5pZF90YWJsZSA9IGF0bDJfcGNpX3RibCwKIAkucHJvYmUgICAgPSBhdGwyX3Byb2JlLAogCS5yZW1vdmUgICA9IF9fZGV2ZXhpdF9wKGF0bDJfcmVtb3ZlKSwKLQkvKiBQb3dlciBNYW5hZ21lbnQgSG9va3MgKi8KKwkvKiBQb3dlciBNYW5hZ2VtZW50IEhvb2tzICovCiAJLnN1c3BlbmQgID0gYXRsMl9zdXNwZW5kLAogI2lmZGVmIENPTkZJR19QTQogCS5yZXN1bWUgICA9IGF0bDJfcmVzdW1lLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYmNtNjN4eF9lbmV0LmMgYi9kcml2ZXJzL25ldC9iY202M3h4X2VuZXQuYwppbmRleCBlOTRhOTY2YS4uYzQ4MTA0YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYmNtNjN4eF9lbmV0LmMKKysrIGIvZHJpdmVycy9uZXQvYmNtNjN4eF9lbmV0LmMKQEAgLTU5Nyw3ICs1OTcsNyBAQAogfQogCiAvKgotICogQ2hhbmdlIHJ4IG1vZGUgKHByb21pc2NvdXMvYWxsbXVsdGkpIGFuZCB1cGRhdGUgbXVsdGljYXN0IGxpc3QKKyAqIENoYW5nZSByeCBtb2RlIChwcm9taXNjdW91cy9hbGxtdWx0aSkgYW5kIHVwZGF0ZSBtdWx0aWNhc3QgbGlzdAogICovCiBzdGF0aWMgdm9pZCBiY21fZW5ldF9zZXRfbXVsdGljYXN0X2xpc3Qoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlLmggYi9kcml2ZXJzL25ldC9iZW5ldC9iZS5oCmluZGV4IGY4MDNjNTguLjY2ODIzZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlLmgKKysrIGIvZHJpdmVycy9uZXQvYmVuZXQvYmUuaApAQCAtMTU0LDcgKzE1NCw3IEBACiAJdTE2IG1pbl9lcWQ7CQkvKiBpbiB1c2VjcyAqLwogCXUxNiBtYXhfZXFkOwkJLyogaW4gdXNlY3MgKi8KIAl1MTYgY3VyX2VxZDsJCS8qIGluIHVzZWNzICovCi0JdTggIG1zaXhfdmVjX2lkeDsKKwl1OCAgZXFfaWR4OwogCiAJc3RydWN0IG5hcGlfc3RydWN0IG5hcGk7CiB9OwpAQCAtMjkxLDcgKzI5MSw3IEBACiAJdTMyIG51bV9yeF9xczsKIAl1MzIgYmlnX3BhZ2Vfc2l6ZTsJLyogQ29tcG91bmRlZCBwYWdlIHNpemUgc2hhcmVkIGJ5IHJ4IHdyYnMgKi8KIAotCXU4IG1zaXhfdmVjX25leHRfaWR4OworCXU4IGVxX25leHRfaWR4OwogCXN0cnVjdCBiZV9kcnZfc3RhdHMgZHJ2X3N0YXRzOwogCiAJc3RydWN0IHZsYW5fZ3JvdXAgKnZsYW5fZ3JwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jCmluZGV4IDVhNGE4N2U3Li4xZTJkODI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9iZW5ldC9iZV9jbWRzLmMKKysrIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jCkBAIC0xMzMxLDcgKzEzMzEsNyBAQAogCiAvKgogICogVXNlcyBNQ0MgZm9yIHRoaXMgY29tbWFuZCBhcyBpdCBtYXkgYmUgY2FsbGVkIGluIEJIIGNvbnRleHQKLSAqIChtYyA9PSBOVUxMKSA9PiBtdWx0aWNhc3QgcHJvbWlzY291cworICogKG1jID09IE5VTEwpID0+IG11bHRpY2FzdCBwcm9taXNjdW91cwogICovCiBpbnQgYmVfY21kX211bHRpY2FzdF9zZXQoc3RydWN0IGJlX2FkYXB0ZXIgKmFkYXB0ZXIsIHUzMiBpZl9pZCwKIAkJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgc3RydWN0IGJlX2RtYV9tZW0gKm1lbSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlX21haW4uYyBiL2RyaXZlcnMvbmV0L2JlbmV0L2JlX21haW4uYwppbmRleCBhNzExNjNmLi43Y2I1YTExIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9iZW5ldC9iZV9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfbWFpbi5jCkBAIC03MDgsNyArNzA4LDcgQEAKIAkJZ290byBkb25lOwogCX0KIAotCS8qIEJFIHdhcyBwcmV2aW91c2x5IGluIHByb21pc2NvdXMgbW9kZTsgZGlzYWJsZSBpdCAqLworCS8qIEJFIHdhcyBwcmV2aW91c2x5IGluIHByb21pc2N1b3VzIG1vZGU7IGRpc2FibGUgaXQgKi8KIAlpZiAoYWRhcHRlci0+cHJvbWlzY3VvdXMpIHsKIAkJYWRhcHRlci0+cHJvbWlzY3VvdXMgPSBmYWxzZTsKIAkJYmVfY21kX3Byb21pc2N1b3VzX2NvbmZpZyhhZGFwdGVyLCBhZGFwdGVyLT5wb3J0X251bSwgMCk7CkBAIC0xNDk3LDcgKzE0OTcsNyBAQAogCWlmIChiZV9jbWRfZXFfY3JlYXRlKGFkYXB0ZXIsIGVxLCBhZGFwdGVyLT50eF9lcS5jdXJfZXFkKSkKIAkJZ290byB0eF9lcV9mcmVlOwogCi0JYWRhcHRlci0+dHhfZXEubXNpeF92ZWNfaWR4ID0gYWRhcHRlci0+bXNpeF92ZWNfbmV4dF9pZHgrKzsKKwlhZGFwdGVyLT50eF9lcS5lcV9pZHggPSBhZGFwdGVyLT5lcV9uZXh0X2lkeCsrOwogCiAKIAkvKiBBbGxvYyBUWCBldGggY29tcGwgcXVldWUgKi8KQEAgLTE1OTAsNyArMTU5MCw3IEBACiAJCWlmIChyYykKIAkJCWdvdG8gZXJyOwogCi0JCXJ4by0+cnhfZXEubXNpeF92ZWNfaWR4ID0gYWRhcHRlci0+bXNpeF92ZWNfbmV4dF9pZHgrKzsKKwkJcnhvLT5yeF9lcS5lcV9pZHggPSBhZGFwdGVyLT5lcV9uZXh0X2lkeCsrOwogCiAJCS8qIENRICovCiAJCWNxID0gJnJ4by0+Y3E7CkBAIC0xNjY2LDExICsxNjY2LDExIEBACiAJCWlmICghaXNyKQogCQkJcmV0dXJuIElSUV9OT05FOwogCi0JCWlmICgoMSA8PCBhZGFwdGVyLT50eF9lcS5tc2l4X3ZlY19pZHggJiBpc3IpKQorCQlpZiAoKDEgPDwgYWRhcHRlci0+dHhfZXEuZXFfaWR4ICYgaXNyKSkKIAkJCWV2ZW50X2hhbmRsZShhZGFwdGVyLCAmYWRhcHRlci0+dHhfZXEpOwogCiAJCWZvcl9hbGxfcnhfcXVldWVzKGFkYXB0ZXIsIHJ4bywgaSkgewotCQkJaWYgKCgxIDw8IHJ4by0+cnhfZXEubXNpeF92ZWNfaWR4ICYgaXNyKSkKKwkJCWlmICgoMSA8PCByeG8tPnJ4X2VxLmVxX2lkeCAmIGlzcikpCiAJCQkJZXZlbnRfaGFuZGxlKGFkYXB0ZXIsICZyeG8tPnJ4X2VxKTsKIAkJfQogCX0KQEAgLTE5NTEsNyArMTk1MSw3IEBACiBzdGF0aWMgaW5saW5lIGludCBiZV9tc2l4X3ZlY19nZXQoc3RydWN0IGJlX2FkYXB0ZXIgKmFkYXB0ZXIsCiAJCQkJCXN0cnVjdCBiZV9lcV9vYmogKmVxX29iaikKIHsKLQlyZXR1cm4gYWRhcHRlci0+bXNpeF9lbnRyaWVzW2VxX29iai0+bXNpeF92ZWNfaWR4XS52ZWN0b3I7CisJcmV0dXJuIGFkYXB0ZXItPm1zaXhfZW50cmllc1tlcV9vYmotPmVxX2lkeF0udmVjdG9yOwogfQogCiBzdGF0aWMgaW50IGJlX3JlcXVlc3RfaXJxKHN0cnVjdCBiZV9hZGFwdGVyICphZGFwdGVyLApAQCAtMjM0NSw2ICsyMzQ1LDcgQEAKIAliZV9tY2NfcXVldWVzX2Rlc3Ryb3koYWRhcHRlcik7CiAJYmVfcnhfcXVldWVzX2Rlc3Ryb3koYWRhcHRlcik7CiAJYmVfdHhfcXVldWVzX2Rlc3Ryb3koYWRhcHRlcik7CisJYWRhcHRlci0+ZXFfbmV4dF9pZHggPSAwOwogCiAJaWYgKGJlX3BoeXNmbihhZGFwdGVyKSAmJiBhZGFwdGVyLT5zcmlvdl9lbmFibGVkKQogCQlmb3IgKHZmID0gMDsgdmYgPCBudW1fdmZzOyB2ZisrKQpAQCAtMzE0MSwxMiArMzE0MiwxNCBAQAogc3RhdGljIHZvaWQgYmVfc2h1dGRvd24oc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7CiAJc3RydWN0IGJlX2FkYXB0ZXIgKmFkYXB0ZXIgPSBwY2lfZ2V0X2RydmRhdGEocGRldik7Ci0Jc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiA9ICBhZGFwdGVyLT5uZXRkZXY7CiAKLQlpZiAobmV0aWZfcnVubmluZyhuZXRkZXYpKQorCWlmICghYWRhcHRlcikKKwkJcmV0dXJuOworCisJaWYgKG5ldGlmX3J1bm5pbmcoYWRhcHRlci0+bmV0ZGV2KSkKIAkJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZhZGFwdGVyLT53b3JrKTsKIAotCW5ldGlmX2RldmljZV9kZXRhY2gobmV0ZGV2KTsKKwluZXRpZl9kZXZpY2VfZGV0YWNoKGFkYXB0ZXItPm5ldGRldik7CiAKIAliZV9jbWRfcmVzZXRfZnVuY3Rpb24oYWRhcHRlcik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JuYS9iZmFfaW9jLmMgYi9kcml2ZXJzL25ldC9ibmEvYmZhX2lvYy5jCmluZGV4IDM0OTMzY2IuLmUzZGUwYjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JuYS9iZmFfaW9jLmMKKysrIGIvZHJpdmVycy9uZXQvYm5hL2JmYV9pb2MuYwpAQCAtMjIxOSwxMyArMjIxOSw5IEBACiBzdGF0aWMgdm9pZAogYmZhX2lvY19yZWNvdmVyKHN0cnVjdCBiZmFfaW9jICppb2MpCiB7Ci0JdTE2IGJkZjsKLQotCWJkZiA9IChpb2MtPnBjaWRldi5wY2lfc2xvdCA8PCA4IHwgaW9jLT5wY2lkZXYucGNpX2Z1bmMgPDwgMyB8Ci0JCQkJCWlvYy0+cGNpZGV2LmRldmljZV9pZCk7Ci0KLQlwcl9jcml0KCJGaXJtd2FyZSBoZWFydGJlYXQgZmFpbHVyZSBhdCAlZCIsIGJkZik7Ci0JQlVHX09OKDEpOworCXByX2NyaXQoIkhlYXJ0IEJlYXQgb2YgSU9DIGhhcyBmYWlsZWRcbiIpOworCWJmYV9pb2Nfc3RhdHMoaW9jLCBpb2NfaGJmYWlscyk7CisJYmZhX2ZzbV9zZW5kX2V2ZW50KGlvYywgSU9DX0VfSEJGQUlMKTsKIH0KIAogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JuYS9ibmFfaHcuaCBiL2RyaXZlcnMvbmV0L2JuYS9ibmFfaHcuaAppbmRleCA4MDZiMjI0Li42Y2I4OTY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ibmEvYm5hX2h3LmgKKysrIGIvZHJpdmVycy9uZXQvYm5hL2JuYV9ody5oCkBAIC04OTcsNyArODk3LDcgQEAKICAqIENhdGFwdWx0IFJTUyBUYWJsZSBCYXNlIE9mZnNldCBBZGRyZXNzCiAgKgogICogRXhpc3RzIGluIFJBRCBtZW1vcnkgc3BhY2UuCi0gKiBFYWNoIGVudHJ5IGlzIDM1MiBiaXRzLCBidXQgYWxsaWduZWQgb24KKyAqIEVhY2ggZW50cnkgaXMgMzUyIGJpdHMsIGJ1dCBhbGlnbmVkIG9uCiAgKiA2NCBieXRlICg1MTIgYml0KSBib3VuZGFyeS4gQWNjZXNzZWQKICAqIDQgYnl0ZSB3b3JkcywgdGhlIHdob2xlIGVudHJ5IGNhbiBiZQogICogYnJva2VuIGludG8gMTEgd29yZCBhY2Nlc3Nlcy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4LmggYi9kcml2ZXJzL25ldC9ibngyeC9ibngyeC5oCmluZGV4IGI3ZmY4N2IuLmUwZmNhNzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4LmgKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnguaApAQCAtMTIyMCw3ICsxMjIwLDcgQEAKIAlzdHJ1Y3QgYm54MnhfZGNieF9wb3J0X3BhcmFtcwkJZGNieF9wb3J0X3BhcmFtczsKIAlpbnQJCQkJCWRjYl92ZXJzaW9uOwogCi0JLyogRENCWCBOZWdvdGF0aW9uIHJlc3VsdHMgKi8KKwkvKiBEQ0JYIE5lZ290aWF0aW9uIHJlc3VsdHMgKi8KIAlzdHJ1Y3QgZGNieF9mZWF0dXJlcwkJCWRjYnhfbG9jYWxfZmVhdDsKIAl1MzIJCQkJCWRjYnhfZXJyb3I7CiAJdTMyCQkJCQlwZW5kaW5nX21heDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X2hzaS5oIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfaHNpLmgKaW5kZXggYmU1MDNjYy4uZGFjMWJmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfaHNpLmgKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfaHNpLmgKQEAgLTMwMTksNyArMzAxOSw3IEBACiAKIAogLyoKLSAqIGNvbW1vbiBmbGFnIHRvIGluZGljYXRlIGV4aXN0YW5jZSBvZiBUUEEuCisgKiBjb21tb24gZmxhZyB0byBpbmRpY2F0ZSBleGlzdGVuY2Ugb2YgVFBBLgogICovCiBzdHJ1Y3QgdHN0b3JtX2V0aF90cGFfZXhpc3QgewogI2lmIGRlZmluZWQoX19CSUdfRU5ESUFOKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbGluay5jIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbGluay5jCmluZGV4IGYyZjM2N2QuLjk3NGVmMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X2xpbmsuYworKysgYi9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9saW5rLmMKQEAgLTI4MjMsNyArMjgyMyw3IEBACiAJCQkJICAgICBzdHJ1Y3QgbGlua19wYXJhbXMgKnBhcmFtcykKIHsKIAl1MTYgY250LCBjdHJsOwotCS8qIFdhaXQgZm9yIHNvZnQgcmVzZXQgdG8gZ2V0IGNsZWFyZWQgdXB0byAxIHNlYyAqLworCS8qIFdhaXQgZm9yIHNvZnQgcmVzZXQgdG8gZ2V0IGNsZWFyZWQgdXAgdG8gMSBzZWMgKi8KIAlmb3IgKGNudCA9IDA7IGNudCA8IDEwMDA7IGNudCsrKSB7CiAJCWJueDJ4X2NsNDVfcmVhZChicCwgcGh5LAogCQkJCU1ESU9fUE1BX0RFVkFELCBNRElPX1BNQV9SRUdfQ1RSTCwgJmN0cmwpOwpAQCAtNDE0MSw3ICs0MTQxLDcgQEAKIAkJCXZhbCA9ICgxPDw1KTsKIAkJCS8qCiAJCQkgKiBOb3RlIHRoYXQgMi41RyB3b3JrcyBvbmx5IHdoZW4gdXNlZCB3aXRoIDFHCi0JCQkgKiBhZHZlcnRpc21lbnQKKwkJCSAqIGFkdmVydGlzZW1lbnQKIAkJCSAqLwogCQl9IGVsc2UKIAkJCXZhbCA9ICgxPDw1KTsKQEAgLTQxNTEsNyArNDE1MSw3IEBACiAJCQlQT1JUX0hXX0NGR19TUEVFRF9DQVBBQklMSVRZX0QwXzEwRykKIAkJCXZhbCB8PSAoMTw8Nyk7CiAKLQkJLyogTm90ZSB0aGF0IDIuNUcgd29ya3Mgb25seSB3aGVuIHVzZWQgd2l0aCAxRyBhZHZlcnRpc21lbnQgKi8KKwkJLyogTm90ZSB0aGF0IDIuNUcgd29ya3Mgb25seSB3aGVuIHVzZWQgd2l0aCAxRyBhZHZlcnRpc2VtZW50ICovCiAJCWlmIChwaHktPnNwZWVkX2NhcF9tYXNrICYKIAkJCShQT1JUX0hXX0NGR19TUEVFRF9DQVBBQklMSVRZX0QwXzFHIHwKIAkJCSBQT1JUX0hXX0NGR19TUEVFRF9DQVBBQklMSVRZX0QwXzJfNUcpKQpAQCAtNTIzMiwxNCArNTIzMiwxNCBAQAogCQlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksCiAJCQkJIE1ESU9fUE1BX0RFVkFELCBNRElPX1BNQV9SRUdfTEFTSV9DVFJMLCAxKTsKIAl9IGVsc2UgewotCQkvKiBGb3JjZSAxR2JwcyB1c2luZyBhdXRvbmVnIHdpdGggMUcgYWR2ZXJ0aXNtZW50ICovCisJCS8qIEZvcmNlIDFHYnBzIHVzaW5nIGF1dG9uZWcgd2l0aCAxRyBhZHZlcnRpc2VtZW50ICovCiAKIAkJLyogQWxsb3cgQ0wzNyB0aHJvdWdoIENMNzMgKi8KIAkJRFAoTkVUSUZfTVNHX0xJTkssICJYR1hTIDg3MDYgQXV0b05lZ1xuIik7CiAJCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKIAkJCQkgTURJT19BTl9ERVZBRCwgTURJT19BTl9SRUdfQ0wzN19DTDczLCAweDA0MGMpOwogCi0JCS8qIEVuYWJsZSBGdWxsLUR1cGxleCBhZHZlcnRpc21lbnQgb24gQ0wzNyAqLworCQkvKiBFbmFibGUgRnVsbC1EdXBsZXggYWR2ZXJ0aXNlbWVudCBvbiBDTDM3ICovCiAJCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKIAkJCQkgTURJT19BTl9ERVZBRCwgTURJT19BTl9SRUdfQ0wzN19GQ19MUCwgMHgwMDIwKTsKIAkJLyogRW5hYmxlIENMMzcgQU4gKi8KQEAgLTYyNjksNyArNjI2OSw3IEBACiAKIAlzd2l0Y2ggKGFjdHVhbF9waHlfc2VsZWN0aW9uKSB7CiAJY2FzZSBQT1JUX0hXX0NGR19QSFlfU0VMRUNUSU9OX0hBUkRXQVJFX0RFRkFVTFQ6Ci0JCS8qIERvIG5vdGhpbmcuIEVzc2VudGlhbHkgdGhpcyBpcyBsaWtlIHRoZSBwcmlvcml0eSBjb3BwZXIgKi8KKwkJLyogRG8gbm90aGluZy4gRXNzZW50aWFsbHkgdGhpcyBpcyBsaWtlIHRoZSBwcmlvcml0eSBjb3BwZXIgKi8KIAkJYnJlYWs7CiAJY2FzZSBQT1JUX0hXX0NGR19QSFlfU0VMRUNUSU9OX0ZJUlNUX1BIWV9QUklPUklUWToKIAkJdmFsIHw9IE1ESU9fQ1RMX1JFR184NDgyM19NRURJQV9QUklPUklUWV9DT1BQRVI7CkBAIC03NzY1LDcgKzc3NjUsNyBAQAogCVJFR19XUihicCwgTklHX1JFR19OSUdfRU1BQzBfRU4gKyBwb3J0KjQsIDApOwogCiAJbXNsZWVwKDEwKTsKLQkvKiBUaGUgUEhZIHJlc2V0IGlzIGNvbnRyb2xlZCBieSBHUElPIDEKKwkvKiBUaGUgUEhZIHJlc2V0IGlzIGNvbnRyb2xsZWQgYnkgR1BJTyAxCiAJICogSG9sZCBpdCBhcyB2YXJzIGxvdwogCSAqLwogCSAvKiBjbGVhciBsaW5rIGxlZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbWFpbi5jIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbWFpbi5jCmluZGV4IDMyZTY0Y2M4Li5hOTdhNGExIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbWFpbi5jCkBAIC0zNzAyLDcgKzM3MDIsNyBAQAogCWlmICgoaHdfY29ucyAmIEVRX0RFU0NfTUFYX1BBR0UpID09IEVRX0RFU0NfTUFYX1BBR0UpCiAJCWh3X2NvbnMrKzsKIAotCS8qIFRoaXMgZnVuY3Rpb24gbWF5IG5ldmVyIHJ1biBpbiBwYXJyYWxlbCB3aXRoIGl0c2VsZiBmb3IgYQorCS8qIFRoaXMgZnVuY3Rpb24gbWF5IG5ldmVyIHJ1biBpbiBwYXJhbGxlbCB3aXRoIGl0c2VsZiBmb3IgYQogCSAqIHNwZWNpZmljIGJwLCB0aHVzIHRoZXJlIGlzIG5vIG5lZWQgaW4gInBhaXJlZCIgcmVhZCBtZW1vcnkKIAkgKiBiYXJyaWVyIGhlcmUuCiAJICovCkBAIC01MDg5LDcgKzUwODksNyBAQAogCQkvKiBTdGVwIDE6IHNldCB6ZXJvZXMgdG8gYWxsIGlsdCBwYWdlIGVudHJpZXMgd2l0aCB2YWxpZCBiaXQgb24KIAkJICogU3RlcCAyOiBzZXQgdGhlIHRpbWVycyBmaXJzdC9sYXN0IGlsdCBlbnRyeSB0byBwb2ludAogCQkgKiB0byB0aGUgZW50aXJlIHJhbmdlIHRvIHByZXZlbnQgSUxUIHJhbmdlIGVycm9yIGZvciAzcmQvNHRoCi0JCSAqIHZuaWMJKHRoaXMgY29kZSBhc3N1bWVzIGV4aXN0YW5jZSBvZiB0aGUgdm5pYykKKwkJICogdm5pYwkodGhpcyBjb2RlIGFzc3VtZXMgZXhpc3RlbmNlIG9mIHRoZSB2bmljKQogCQkgKgogCQkgKiBib3RoIHN0ZXBzIHBlcmZvcm1lZCBieSBjYWxsIHRvIGJueDJ4X2lsdF9jbGllbnRfaW5pdF9vcCgpCiAJCSAqIHdpdGggZHVtbXkgVE0gY2xpZW50CkBAIC04Njg1LDcgKzg2ODUsNyBAQAogCQkJCUUxSF9GVU5DX01BWCAqIHNpemVvZihzdHJ1Y3QgZHJ2X2Z1bmNfbWIpOwogCQkvKgogCQkgKiBnZXQgbWYgY29uZmlndXJhdGlvbjoKLQkJICogMS4gZXhpc3RhbmNlIG9mIE1GIGNvbmZpZ3VyYXRpb24KKwkJICogMS4gZXhpc3RlbmNlIG9mIE1GIGNvbmZpZ3VyYXRpb24KIAkJICogMi4gTUFDIGFkZHJlc3MgbXVzdCBiZSBsZWdhbCAoY2hlY2sgb25seSB1cHBlciBieXRlcykKIAkJICogICAgZm9yICBTd2l0Y2gtSW5kZXBlbmRlbnQgbW9kZTsKIAkJICogICAgT1ZMQU4gbXVzdCBiZSBsZWdhbCBmb3IgU3dpdGNoLURlcGVuZGVudCBtb2RlCkBAIC04NzI3LDcgKzg3MjcsNyBAQAogCQkJZGVmYXVsdDoKIAkJCQkvKiBVbmtub3duIGNvbmZpZ3VyYXRpb246IHJlc2V0IG1mX2NvbmZpZyAqLwogCQkJCWJwLT5tZl9jb25maWdbdm5dID0gMDsKLQkJCQlEUChORVRJRl9NU0dfUFJPQkUsICJVbmtvd24gTUYgbW9kZSAweCV4XG4iLAorCQkJCURQKE5FVElGX01TR19QUk9CRSwgIlVua25vd24gTUYgbW9kZSAweCV4XG4iLAogCQkJCSAgIHZhbCk7CiAJCQl9CiAJCX0KQEAgLTk3NzcsNyArOTc3Nyw3IEBACiAKICNlbmRpZgogCi0JLyogQ29uZmlndXJlIGludGVydXB0IG1vZGU6IHRyeSB0byBlbmFibGUgTVNJLVgvTVNJIGlmCisJLyogQ29uZmlndXJlIGludGVycnVwdCBtb2RlOiB0cnkgdG8gZW5hYmxlIE1TSS1YL01TSSBpZgogCSAqIG5lZWRlZCwgc2V0IGJwLT5udW1fcXVldWVzIGFwcHJvcHJpYXRlbHkuCiAJICovCiAJYm54Mnhfc2V0X2ludF9tb2RlKGJwKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X3JlZy5oIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfcmVnLmgKaW5kZXggMWM4OWYxOS4uMTUwOWEyMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfcmVnLmgKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfcmVnLmgKQEAgLTE3NSw5ICsxNzUsOSBAQAogICAgdGhlIGluaXRpYWwgY3JlZGl0IHZhbHVlOyByZWFkIHJldHVybnMgdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIGNyZWRpdAogICAgY291bnRlci4gTXVzdCBiZSBpbml0aWFsaXplZCB0byAxIGF0IHN0YXJ0LXVwLiAqLwogI2RlZmluZSBDQ01fUkVHX0NGQ19JTklUX0NSRAkJCQkJIDB4ZDAyMDQKLS8qIFtSVyAyXSBBdXhpbGxhcnkgY291bnRlciBmbGFnIFEgbnVtYmVyIDEuICovCisvKiBbUlcgMl0gQXV4aWxpYXJ5IGNvdW50ZXIgZmxhZyBRIG51bWJlciAxLiAqLwogI2RlZmluZSBDQ01fUkVHX0NOVF9BVVgxX1EJCQkJCSAweGQwMGM4Ci0vKiBbUlcgMl0gQXV4aWxsYXJ5IGNvdW50ZXIgZmxhZyBRIG51bWJlciAyLiAqLworLyogW1JXIDJdIEF1eGlsaWFyeSBjb3VudGVyIGZsYWcgUSBudW1iZXIgMi4gKi8KICNkZWZpbmUgQ0NNX1JFR19DTlRfQVVYMl9RCQkJCQkgMHhkMDBjYwogLyogW1JXIDI4XSBUaGUgQ00gaGVhZGVyIHZhbHVlIGZvciBRTSByZXF1ZXN0IChwcmltYXJ5KS4gKi8KICNkZWZpbmUgQ0NNX1JFR19DUU1fQ0NNX0hEUl9QCQkJCQkgMHhkMDA4YwpAQCAtNDU3LDEzICs0NTcsMTMgQEAKICNkZWZpbmUgQ1NETV9SRUdfQUdHX0lOVF9NT0RFXzkgCQkJCSAweGMyMWRjCiAvKiBbUlcgMTNdIFRoZSBzdGFydCBhZGRyZXNzIGluIHRoZSBpbnRlcm5hbCBSQU0gZm9yIHRoZSBjZmNfcnNwIGxjaWQgKi8KICNkZWZpbmUgQ1NETV9SRUdfQ0ZDX1JTUF9TVEFSVF9BRERSCQkJCSAweGMyMDA4Ci0vKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wZXRpb24gY291bnRlciAjMCAqLworLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGxldGlvbiBjb3VudGVyICMwICovCiAjZGVmaW5lIENTRE1fUkVHX0NNUF9DT1VOVEVSX01BWDAJCQkJIDB4YzIwMWMKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMxICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzEgKi8KICNkZWZpbmUgQ1NETV9SRUdfQ01QX0NPVU5URVJfTUFYMQkJCQkgMHhjMjAyMAotLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGV0aW9uIGNvdW50ZXIgIzIgKi8KKy8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBsZXRpb24gY291bnRlciAjMiAqLwogI2RlZmluZSBDU0RNX1JFR19DTVBfQ09VTlRFUl9NQVgyCQkJCSAweGMyMDI0Ci0vKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wZXRpb24gY291bnRlciAjMyAqLworLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGxldGlvbiBjb3VudGVyICMzICovCiAjZGVmaW5lIENTRE1fUkVHX0NNUF9DT1VOVEVSX01BWDMJCQkJIDB4YzIwMjgKIC8qIFtSVyAxM10gVGhlIHN0YXJ0IGFkZHJlc3MgaW4gdGhlIGludGVybmFsIFJBTSBmb3IgdGhlIGNvbXBsZXRpb24KICAgIGNvdW50ZXJzLiAqLwpAQCAtODUxLDcgKzg1MSw3IEBACiAjZGVmaW5lIElHVV9SRUdfQVRUTl9NU0dfQUREUl9MCQkJCSAweDEzMDEyMAogLyogW1IgNF0gRGVidWc6IFszXSAtIGF0dGVudGlvbiB3cml0ZSBkb25lIG1lc3NhZ2UgaXMgcGVuZGluZyAoMC1ubyBwZW5kaW5nOwogICogMS1wZW5kaW5nKS4gWzI6MF0gPSBQRklELiBQZW5kaW5nIG1lYW5zIGF0dGVudGlvbiBtZXNzYWdlIHdhcyBzZW50OyBidXQKLSAqIHdyaXRlIGRvbmUgZGlkbnQgcmVjZWl2ZS4gKi8KKyAqIHdyaXRlIGRvbmUgZGlkbid0IHJlY2VpdmUuICovCiAjZGVmaW5lIElHVV9SRUdfQVRUTl9XUklURV9ET05FX1BFTkRJTkcJCQkgMHgxMzAwMzAKICNkZWZpbmUgSUdVX1JFR19CTE9DS19DT05GSUdVUkFUSU9OCQkJCSAweDEzMDAwMAogI2RlZmluZSBJR1VfUkVHX0NPTU1BTkRfUkVHXzMyTFNCX0RBVEEJCQkJIDB4MTMwMTI0CkBAIC04NjIsNyArODYyLDcgQEAKICNkZWZpbmUgSUdVX1JFR19DU1RPUk1fVFlQRV8wX1NCX0NMRUFOVVAJCQkgMHgxMzAyMDAKIC8qIFtSIDVdIERlYnVnOiBjdHJsX2ZzbSAqLwogI2RlZmluZSBJR1VfUkVHX0NUUkxfRlNNCQkJCQkgMHgxMzAwNjQKLS8qIFtSIDFdIGRhdGEgYXZhaWxibGUgZm9yIGVycm9yIG1lbW9yeS4gSWYgdGhpcyBiaXQgaXMgY2xlYXIgZG8gbm90IHJlZAorLyogW1IgMV0gZGF0YSBhdmFpbGFibGUgZm9yIGVycm9yIG1lbW9yeS4gSWYgdGhpcyBiaXQgaXMgY2xlYXIgZG8gbm90IHJlZAogICogZnJvbSBlcnJvcl9oYW5kbGluZ19tZW1vcnkuICovCiAjZGVmaW5lIElHVV9SRUdfRVJST1JfSEFORExJTkdfREFUQV9WQUxJRAkJCSAweDEzMDEzMAogLyogW1JXIDExXSBQYXJpdHkgbWFzayByZWdpc3RlciAjMCByZWFkL3dyaXRlICovCkBAIC0zMDE1LDcgKzMwMTUsNyBAQAogICAgYmxvY2suIFNob3VsZCBiZSB1c2VkIGZvciBjbG9zZSB0aGUgZ2F0ZXMuICovCiAjZGVmaW5lIFBYUF9SRUdfSFNUX0RJU0NBUkRfRE9PUkJFTExTCQkJCSAweDEwMzBhNAogLyogW1IgMV0gZGVidWcgb25seTogJzEnIG1lYW5zIHRoaXMgUFNXSFNUIGlzIGRpc2NhcmRpbmcgZG9vcmJlbGxzLiBUaGlzIGJpdAotICAgc2hvdWxkIHVwZGF0ZSBhY2NvcmluZyB0byAnaHN0X2Rpc2NhcmRfZG9vcmJlbGxzJyByZWdpc3RlciB3aGVuIHRoZSBzdGF0ZQorICAgc2hvdWxkIHVwZGF0ZSBhY2NvcmRpbmcgdG8gJ2hzdF9kaXNjYXJkX2Rvb3JiZWxscycgcmVnaXN0ZXIgd2hlbiB0aGUgc3RhdGUKICAgIG1hY2hpbmUgaXMgaWRsZSAqLwogI2RlZmluZSBQWFBfUkVHX0hTVF9ESVNDQVJEX0RPT1JCRUxMU19TVEFUVVMJCQkgMHgxMDMwYTAKIC8qIFtSVyAxXSBXaGVuIDE7IG5ldyBpbnRlcm5hbCB3cml0ZXMgYXJyaXZpbmcgdG8gdGhlIGJsb2NrIGFyZSBkaXNjYXJkZWQuCkBAIC0zMDIzLDcgKzMwMjMsNyBAQAogI2RlZmluZSBQWFBfUkVHX0hTVF9ESVNDQVJEX0lOVEVSTkFMX1dSSVRFUwkJCSAweDEwMzBhOAogLyogW1IgNl0gZGVidWcgb25seTogQSBiaXQgbWFzayBmb3IgYWxsIFBTV0hTVCBpbnRlcm5hbCB3cml0ZSBjbGllbnRzLiAnMScKICAgIG1lYW5zIHRoaXMgUFNXSFNUIGlzIGRpc2NhcmRpbmcgaW5wdXRzIGZyb20gdGhpcyBjbGllbnQuIEVhY2ggYml0IHNob3VsZAotICAgdXBkYXRlIGFjY29yaW5nIHRvICdoc3RfZGlzY2FyZF9pbnRlcm5hbF93cml0ZXMnIHJlZ2lzdGVyIHdoZW4gdGhlIHN0YXRlCisgICB1cGRhdGUgYWNjb3JkaW5nIHRvICdoc3RfZGlzY2FyZF9pbnRlcm5hbF93cml0ZXMnIHJlZ2lzdGVyIHdoZW4gdGhlIHN0YXRlCiAgICBtYWNoaW5lIGlzIGlkbGUuICovCiAjZGVmaW5lIFBYUF9SRUdfSFNUX0RJU0NBUkRfSU5URVJOQUxfV1JJVEVTX1NUQVRVUwkJIDB4MTAzMDljCiAvKiBbV0IgMTYwXSBVc2VkIGZvciBpbml0aWFsaXphdGlvbiBvZiB0aGUgaW5ib3VuZCBpbnRlcnJ1cHRzIG1lbW9yeSAqLwpAQCAtMzgyMiwxMyArMzgyMiwxMyBAQAogI2RlZmluZSBUU0RNX1JFR19BR0dfSU5UX1RfMQkJCQkJIDB4NDIwYmMKIC8qIFtSVyAxM10gVGhlIHN0YXJ0IGFkZHJlc3MgaW4gdGhlIGludGVybmFsIFJBTSBmb3IgdGhlIGNmY19yc3AgbGNpZCAqLwogI2RlZmluZSBUU0RNX1JFR19DRkNfUlNQX1NUQVJUX0FERFIJCQkJIDB4NDIwMDgKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMwICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzAgKi8KICNkZWZpbmUgVFNETV9SRUdfQ01QX0NPVU5URVJfTUFYMAkJCQkgMHg0MjAxYwotLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGV0aW9uIGNvdW50ZXIgIzEgKi8KKy8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBsZXRpb24gY291bnRlciAjMSAqLwogI2RlZmluZSBUU0RNX1JFR19DTVBfQ09VTlRFUl9NQVgxCQkJCSAweDQyMDIwCi0vKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wZXRpb24gY291bnRlciAjMiAqLworLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGxldGlvbiBjb3VudGVyICMyICovCiAjZGVmaW5lIFRTRE1fUkVHX0NNUF9DT1VOVEVSX01BWDIJCQkJIDB4NDIwMjQKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMzICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzMgKi8KICNkZWZpbmUgVFNETV9SRUdfQ01QX0NPVU5URVJfTUFYMwkJCQkgMHg0MjAyOAogLyogW1JXIDEzXSBUaGUgc3RhcnQgYWRkcmVzcyBpbiB0aGUgaW50ZXJuYWwgUkFNIGZvciB0aGUgY29tcGxldGlvbgogICAgY291bnRlcnMuICovCkBAIC00Mjg0LDEzICs0Mjg0LDEzIEBACiAjZGVmaW5lIFVTRE1fUkVHX0FHR19JTlRfVF82CQkJCQkgMHhjNDBkMAogLyogW1JXIDEzXSBUaGUgc3RhcnQgYWRkcmVzcyBpbiB0aGUgaW50ZXJuYWwgUkFNIGZvciB0aGUgY2ZjX3JzcCBsY2lkICovCiAjZGVmaW5lIFVTRE1fUkVHX0NGQ19SU1BfU1RBUlRfQUREUgkJCQkgMHhjNDAwOAotLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGV0aW9uIGNvdW50ZXIgIzAgKi8KKy8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBsZXRpb24gY291bnRlciAjMCAqLwogI2RlZmluZSBVU0RNX1JFR19DTVBfQ09VTlRFUl9NQVgwCQkJCSAweGM0MDFjCi0vKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wZXRpb24gY291bnRlciAjMSAqLworLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGxldGlvbiBjb3VudGVyICMxICovCiAjZGVmaW5lIFVTRE1fUkVHX0NNUF9DT1VOVEVSX01BWDEJCQkJIDB4YzQwMjAKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMyICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzIgKi8KICNkZWZpbmUgVVNETV9SRUdfQ01QX0NPVU5URVJfTUFYMgkJCQkgMHhjNDAyNAotLyogW1JXIDE2XSBUaGUgbWF4aW11bSB2YWx1ZSBvZiB0aGUgY29tcGV0aW9uIGNvdW50ZXIgIzMgKi8KKy8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBsZXRpb24gY291bnRlciAjMyAqLwogI2RlZmluZSBVU0RNX1JFR19DTVBfQ09VTlRFUl9NQVgzCQkJCSAweGM0MDI4CiAvKiBbUlcgMTNdIFRoZSBzdGFydCBhZGRyZXNzIGluIHRoZSBpbnRlcm5hbCBSQU0gZm9yIHRoZSBjb21wbGV0aW9uCiAgICBjb3VudGVycy4gKi8KQEAgLTQ3OTgsMTMgKzQ3OTgsMTMgQEAKICNkZWZpbmUgWFNETV9SRUdfQUdHX0lOVF9NT0RFXzEgCQkJCSAweDE2NjFiYwogLyogW1JXIDEzXSBUaGUgc3RhcnQgYWRkcmVzcyBpbiB0aGUgaW50ZXJuYWwgUkFNIGZvciB0aGUgY2ZjX3JzcCBsY2lkICovCiAjZGVmaW5lIFhTRE1fUkVHX0NGQ19SU1BfU1RBUlRfQUREUgkJCQkgMHgxNjYwMDgKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMwICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzAgKi8KICNkZWZpbmUgWFNETV9SRUdfQ01QX0NPVU5URVJfTUFYMAkJCQkgMHgxNjYwMWMKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMxICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzEgKi8KICNkZWZpbmUgWFNETV9SRUdfQ01QX0NPVU5URVJfTUFYMQkJCQkgMHgxNjYwMjAKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMyICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzIgKi8KICNkZWZpbmUgWFNETV9SRUdfQ01QX0NPVU5URVJfTUFYMgkJCQkgMHgxNjYwMjQKLS8qIFtSVyAxNl0gVGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIGNvbXBldGlvbiBjb3VudGVyICMzICovCisvKiBbUlcgMTZdIFRoZSBtYXhpbXVtIHZhbHVlIG9mIHRoZSBjb21wbGV0aW9uIGNvdW50ZXIgIzMgKi8KICNkZWZpbmUgWFNETV9SRUdfQ01QX0NPVU5URVJfTUFYMwkJCQkgMHgxNjYwMjgKIC8qIFtSVyAxM10gVGhlIHN0YXJ0IGFkZHJlc3MgaW4gdGhlIGludGVybmFsIFJBTSBmb3IgdGhlIGNvbXBsZXRpb24KICAgIGNvdW50ZXJzLiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX2FsYi5oIGIvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX2FsYi5oCmluZGV4IDRiM2UzNTguLjg2ODYxZjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JvbmRpbmcvYm9uZF9hbGIuaAorKysgYi9kcml2ZXJzL25ldC9ib25kaW5nL2JvbmRfYWxiLmgKQEAgLTc2LDcgKzc2LDcgQEAKIAkJCQkgKi8KIAl1MzIgdHhfYnl0ZXM7CQkvKiBFYWNoIENsaWVudCBhY2N1bXVsYXRlcyB0aGUgQnl0ZXNUeCB0aGF0CiAJCQkJICogd2VyZSB0cmFubWl0dGVkIHRvIGl0LCBhbmQgYWZ0ZXIgZWFjaAotCQkJCSAqIENhbGxCYWNrIHRoZSBMb2FkSGlzdG9yeSBpcyBkZXZpZGVkCisJCQkJICogQ2FsbEJhY2sgdGhlIExvYWRIaXN0b3J5IGlzIGRpdmlkZWQKIAkJCQkgKiBieSB0aGUgYmFsYW5jZSBpbnRlcnZhbAogCQkJCSAqLwogCXUzMiBsb2FkX2hpc3Rvcnk7CS8qIFRoaXMgZmllbGQgY29udGFpbnMgdGhlIGFtb3VudCBvZiBCeXRlcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FpZi9jYWlmX3NobWNvcmUuYyBiL2RyaXZlcnMvbmV0L2NhaWYvY2FpZl9zaG1jb3JlLmMKaW5kZXggODA1MTExNi4uNzMxYWExMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FpZi9jYWlmX3NobWNvcmUuYworKysgYi9kcml2ZXJzL25ldC9jYWlmL2NhaWZfc2htY29yZS5jCkBAIC01OTEsNyArNTkxLDcgQEAKIAkJCShOUl9UWF9CVUYgKiBUWF9CVUZfU1ogKyBOUl9SWF9CVUYgKiBSWF9CVUZfU1opKSB7CiAKIAkJcHJfd2FybigiRVJST1IsIEFtb3VudCBvZiBhdmFpbGFibGUiCi0JCQkJIiBQaHlzLiBTSE0gY2Fubm90IGFjY29tb2RhdGUgY3VycmVudCBTSE0gIgorCQkJCSIgUGh5cy4gU0hNIGNhbm5vdCBhY2NvbW1vZGF0ZSBjdXJyZW50IFNITSAiCiAJCQkJImRyaXZlciBjb25maWd1cmF0aW9uLCBCYWlsaW5nIG91dCAuLi5cbiIpOwogCQlmcmVlX25ldGRldihwc2htX2Rldi0+cHNobV9uZXRkZXYpOwogCQlyZXR1cm4gLUVOT01FTTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2NhaWYvY2FpZl9zcGkuYyBiL2RyaXZlcnMvbmV0L2NhaWYvY2FpZl9zcGkuYwppbmRleCAyMGRhMTk5Li41N2U2MzkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYWlmL2NhaWZfc3BpLmMKKysrIGIvZHJpdmVycy9uZXQvY2FpZi9jYWlmX3NwaS5jCkBAIC0zOTcsNyArMzk3LDcgQEAKIAlpbnQgcGt0cyA9IDA7CiAKIAkvKgotCSAqIERlY29tbWl0IHByZXZpb3VzbHkgY29tbWl0ZWQgZnJhbWVzLgorCSAqIERlY29tbWl0IHByZXZpb3VzbHkgY29tbWl0dGVkIGZyYW1lcy4KIAkgKiBza2JfcXVldWVfc3BsaWNlX3RhaWwoJmNmc3BpLT5jaGVhZCwmY2ZzcGktPnFoZWFkKQogCSAqLwogCXdoaWxlIChza2JfcGVlaygmY2ZzcGktPmNoZWFkKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FpZi9jYWlmX3NwaV9zbGF2ZS5jIGIvZHJpdmVycy9uZXQvY2FpZi9jYWlmX3NwaV9zbGF2ZS5jCmluZGV4IDFiOTk0M2EuLmIwMDllMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2NhaWYvY2FpZl9zcGlfc2xhdmUuYworKysgYi9kcml2ZXJzL25ldC9jYWlmL2NhaWZfc3BpX3NsYXZlLmMKQEAgLTk4LDcgKzk4LDcgQEAKIAogCQkJY2ZzcGlfZGJnX3N0YXRlKGNmc3BpLCBDRlNQSV9TVEFURV9GRVRDSF9QS1QpOwogCi0JCQkvKiBDb3B5IGNvbW1pdGVkIFNQSSBmcmFtZXMgYWZ0ZXIgdGhlIFNQSSBpbmRpY2F0aW9uLiAqLworCQkJLyogQ29weSBjb21taXR0ZWQgU1BJIGZyYW1lcyBhZnRlciB0aGUgU1BJIGluZGljYXRpb24uICovCiAJCQlwdHIgPSAodTggKikgY2ZzcGktPnhmZXIudmFfdHg7CiAJCQlwdHIgKz0gU1BJX0lORF9TWjsKIAkJCWxlbiA9IGNmc3BpX3htaXRmcm0oY2ZzcGksIHB0ciwgY2ZzcGktPnR4X2NwY2tfbGVuKTsKQEAgLTE1OCw3ICsxNTgsNyBAQAogCiAJCWNmc3BpX2RiZ19zdGF0ZShjZnNwaSwgQ0ZTUElfU1RBVEVfU0lHX0FDVElWRSk7CiAKLQkJLyogU2lnbmFsIHRoYXQgd2UgYXJlIHJlYWR5IHRvIHJlY2lldmUgZGF0YS4gKi8KKwkJLyogU2lnbmFsIHRoYXQgd2UgYXJlIHJlYWR5IHRvIHJlY2VpdmUgZGF0YS4gKi8KIAkJY2ZzcGktPmRldi0+c2lnX3hmZXIodHJ1ZSwgY2ZzcGktPmRldik7CiAKIAkJY2ZzcGlfZGJnX3N0YXRlKGNmc3BpLCBDRlNQSV9TVEFURV9XQUlUX1hGRVJfRE9ORSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4uYyBiL2RyaXZlcnMvbmV0L2Nhbi9hdDkxX2Nhbi5jCmluZGV4IDU3ZDJmZmIuLjc0ZWZiNWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9hdDkxX2Nhbi5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9hdDkxX2Nhbi5jCkBAIC00MTYsNyArNDE2LDcgQEAKIAogCXN0YXRzLT50eF9ieXRlcyArPSBjZi0+Y2FuX2RsYzsKIAotCS8qIF9OT1RFXzogc3Vic3RyYWN0IEFUOTFfTUJfVFhfRklSU1Qgb2Zmc2V0IGZyb20gbWIhICovCisJLyogX05PVEVfOiBzdWJ0cmFjdCBBVDkxX01CX1RYX0ZJUlNUIG9mZnNldCBmcm9tIG1iISAqLwogCWNhbl9wdXRfZWNob19za2Ioc2tiLCBkZXYsIG1iIC0gQVQ5MV9NQl9UWF9GSVJTVCk7CiAKIAkvKgpAQCAtNzgyLDcgKzc4Miw3IEBACiAJCXJlZ19tc3IgPSBhdDkxX3JlYWQocHJpdiwgQVQ5MV9NU1IobWIpKTsKIAkJaWYgKGxpa2VseShyZWdfbXNyICYgQVQ5MV9NU1JfTVJEWSAmJgogCQkJICAgfnJlZ19tc3IgJiBBVDkxX01TUl9NQUJUKSkgewotCQkJLyogX05PVEVfOiBzdWJzdHJhY3QgQVQ5MV9NQl9UWF9GSVJTVCBvZmZzZXQgZnJvbSBtYiEgKi8KKwkJCS8qIF9OT1RFXzogc3VidHJhY3QgQVQ5MV9NQl9UWF9GSVJTVCBvZmZzZXQgZnJvbSBtYiEgKi8KIAkJCWNhbl9nZXRfZWNob19za2IoZGV2LCBtYiAtIEFUOTFfTUJfVFhfRklSU1QpOwogCQkJZGV2LT5zdGF0cy50eF9wYWNrZXRzKys7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9jX2Nhbi9jX2Nhbi5jIGIvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuLmMKaW5kZXggMzE1NTI5NS4uN2U1Y2MwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuLmMKQEAgLTgxMyw3ICs4MTMsNyBAQAogCXN0cnVjdCBza19idWZmICpza2I7CiAJc3RydWN0IGNhbl9iZXJyX2NvdW50ZXIgYmVjOwogCi0JLyogcHJvcG9nYXRlIHRoZSBlcnJvciBjb25kaXRpb24gdG8gdGhlIENBTiBzdGFjayAqLworCS8qIHByb3BhZ2F0ZSB0aGUgZXJyb3IgY29uZGl0aW9uIHRvIHRoZSBDQU4gc3RhY2sgKi8KIAlza2IgPSBhbGxvY19jYW5fZXJyX3NrYihkZXYsICZjZik7CiAJaWYgKHVubGlrZWx5KCFza2IpKQogCQlyZXR1cm4gMDsKQEAgLTg4Nyw3ICs4ODcsNyBAQAogCWlmIChsZWNfdHlwZSA9PSBMRUNfVU5VU0VEIHx8IGxlY190eXBlID09IExFQ19OT19FUlJPUikKIAkJcmV0dXJuIDA7CiAKLQkvKiBwcm9wb2dhdGUgdGhlIGVycm9yIGNvbmRpdGlvbiB0byB0aGUgQ0FOIHN0YWNrICovCisJLyogcHJvcGFnYXRlIHRoZSBlcnJvciBjb25kaXRpb24gdG8gdGhlIENBTiBzdGFjayAqLwogCXNrYiA9IGFsbG9jX2Nhbl9lcnJfc2tiKGRldiwgJmNmKTsKIAlpZiAodW5saWtlbHkoIXNrYikpCiAJCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL2phbnotaWNhbjMuYyBiL2RyaXZlcnMvbmV0L2Nhbi9qYW56LWljYW4zLmMKaW5kZXggMTAyYjE2Yy4uNTg3ZmJhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL2phbnotaWNhbjMuYworKysgYi9kcml2ZXJzL25ldC9jYW4vamFuei1pY2FuMy5jCkBAIC0yNzQsNyArMjc0LDcgQEAKICAqLwogCiAvKgotICogUmVjaWV2ZSBhIG1lc3NhZ2UgZnJvbSB0aGUgSUNBTjMgIm9sZC1zdHlsZSIgZmlybXdhcmUgaW50ZXJmYWNlCisgKiBSZWNlaXZlIGEgbWVzc2FnZSBmcm9tIHRoZSBJQ0FOMyAib2xkLXN0eWxlIiBmaXJtd2FyZSBpbnRlcmZhY2UKICAqCiAgKiBMT0NLSU5HOiBtdXN0IGhvbGQgbW9kLT5sb2NrCiAgKgpAQCAtMTA1MCw3ICsxMDUwLDcgQEAKIAkJY29tcGxldGUoJm1vZC0+dGVybWluYXRpb25fY29tcCk7CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCWRldl9lcnIobW9kLT5kZXYsICJyZWNpZXZlZCBhbiB1bmtub3duIGlucXVpcnkgcmVzcG9uc2VcbiIpOworCQlkZXZfZXJyKG1vZC0+ZGV2LCAicmVjZWl2ZWQgYW4gdW5rbm93biBpbnF1aXJ5IHJlc3BvbnNlXG4iKTsKIAkJYnJlYWs7CiAJfQogfQpAQCAtMTA1OCw3ICsxMDU4LDcgQEAKIHN0YXRpYyB2b2lkIGljYW4zX2hhbmRsZV91bmtub3duX21lc3NhZ2Uoc3RydWN0IGljYW4zX2RldiAqbW9kLAogCQkJCQlzdHJ1Y3QgaWNhbjNfbXNnICptc2cpCiB7Ci0JZGV2X3dhcm4obW9kLT5kZXYsICJyZWNpZXZlZCB1bmtub3duIG1lc3NhZ2U6IHNwZWMgMHglLjJ4IGxlbmd0aCAlZFxuIiwKKwlkZXZfd2Fybihtb2QtPmRldiwgInJlY2VpdmVkIHVua25vd24gbWVzc2FnZTogc3BlYyAweCUuMnggbGVuZ3RoICVkXG4iLAogCQkJICAgbXNnLT5zcGVjLCBsZTE2X3RvX2NwdShtc2ctPmxlbikpOwogfQogCkBAIC0xMTEzLDcgKzExMTMsNyBAQAogfQogCiAvKgotICogUmVjaWV2ZSBvbmUgQ0FOIGZyYW1lIGZyb20gdGhlIGhhcmR3YXJlCisgKiBSZWNlaXZlIG9uZSBDQU4gZnJhbWUgZnJvbSB0aGUgaGFyZHdhcmUKICAqCiAgKiBDT05URVhUOiBtdXN0IGJlIGNhbGxlZCBmcm9tIHVzZXIgY29udGV4dAogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vbWNwMjUxeC5jIGIvZHJpdmVycy9uZXQvY2FuL21jcDI1MXguYwppbmRleCA3NTEzYzQ1Li4zMzAxNDBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vbWNwMjUxeC5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9tY3AyNTF4LmMKQEAgLTkzMSw3ICs5MzEsOCBAQAogCXByaXYtPnR4X2xlbiA9IDA7CiAKIAlyZXQgPSByZXF1ZXN0X3RocmVhZGVkX2lycShzcGktPmlycSwgTlVMTCwgbWNwMjUxeF9jYW5faXN0LAotCQkJICBJUlFGX1RSSUdHRVJfRkFMTElORywgREVWSUNFX05BTUUsIHByaXYpOworCQkgIHBkYXRhLT5pcnFfZmxhZ3MgPyBwZGF0YS0+aXJxX2ZsYWdzIDogSVJRRl9UUklHR0VSX0ZBTExJTkcsCisJCSAgREVWSUNFX05BTUUsIHByaXYpOwogCWlmIChyZXQpIHsKIAkJZGV2X2Vycigmc3BpLT5kZXYsICJmYWlsZWQgdG8gYWNxdWlyZSBpcnEgJWRcbiIsIHNwaS0+aXJxKTsKIAkJaWYgKHBkYXRhLT50cmFuc2NlaXZlcl9lbmFibGUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vbXNjYW4vbXNjYW4uYyBiL2RyaXZlcnMvbmV0L2Nhbi9tc2Nhbi9tc2Nhbi5jCmluZGV4IDc0Y2Q4ODAuLjkyZmVhYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9tc2Nhbi9tc2Nhbi5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9tc2Nhbi9tc2Nhbi5jCkBAIC0yNDYsNyArMjQ2LDcgQEAKIAkJb3V0X2JlMTYoJnJlZ3MtPnR4LmlkcjNfMiwgY2FuX2lkKTsKIAogCQljYW5faWQgPj49IDE2OwotCQkvKiBFRkZfRkxBR1MgYXJlIGluYmV0d2VlbiB0aGUgSURzIDooICovCisJCS8qIEVGRl9GTEFHUyBhcmUgYmV0d2VlbiB0aGUgSURzIDooICovCiAJCWNhbl9pZCA9IChjYW5faWQgJiAweDcpIHwgKChjYW5faWQgPDwgMikgJiAweGZmZTApCiAJCQkgfCBNU0NBTl9FRkZfRkxBR1M7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9zamExMDAwL3NqYTEwMDAuYyBiL2RyaXZlcnMvbmV0L2Nhbi9zamExMDAwL3NqYTEwMDAuYwppbmRleCAwYThkZTAxLi5hMzU4ZWE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vc2phMTAwMC9zamExMDAwLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3NqYTEwMDAvc2phMTAwMC5jCkBAIC00MjUsNyArNDI1LDcgQEAKIAkJCWNmLT5kYXRhWzNdID0gZWNjICYgRUNDX1NFRzsKIAkJCWJyZWFrOwogCQl9Ci0JCS8qIEVycm9yIG9jY3VyZWQgZHVyaW5nIHRyYW5zbWlzc2lvbj8gKi8KKwkJLyogRXJyb3Igb2NjdXJyZWQgZHVyaW5nIHRyYW5zbWlzc2lvbj8gKi8KIAkJaWYgKChlY2MgJiBFQ0NfRElSKSA9PSAwKQogCQkJY2YtPmRhdGFbMl0gfD0gQ0FOX0VSUl9QUk9UX1RYOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmcuaCBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmcuaAppbmRleCA3ZWM5ZjRkLi5hZmQ3ZDg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nLmgKKysrIGIvZHJpdmVycy9uZXQvY2FuL3NvZnRpbmcvc29mdGluZy5oCkBAIC0yMiw3ICsyMiw3IEBACiAJc3RydWN0IHNvZnRpbmcgKmNhcmQ7CiAJc3RydWN0IHsKIAkJaW50IHBlbmRpbmc7Ci0JCS8qIHZhcmlhYmxlcyB3aWNoIGhvbGQgdGhlIGNpcmN1bGFyIGJ1ZmZlciAqLworCQkvKiB2YXJpYWJsZXMgd2hpY2ggaG9sZCB0aGUgY2lyY3VsYXIgYnVmZmVyICovCiAJCWludCBlY2hvX3B1dDsKIAkJaW50IGVjaG9fZ2V0OwogCX0gdHg7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nX21haW4uYyBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfbWFpbi5jCmluZGV4IGFlZWE5ZjkuLjdhNzA3MDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfbWFpbi5jCkBAIC0yMTgsNyArMjE4LDcgQEAKIAlwdHIgPSBidWY7CiAJY21kID0gKnB0cisrOwogCWlmIChjbWQgPT0gMHhmZikKLQkJLyogbm90IHF1aXRlIHVzZWZ1bGwsIHByb2JhYmx5IHRoZSBjYXJkIGhhcyBnb3Qgb3V0ICovCisJCS8qIG5vdCBxdWl0ZSB1c2VmdWwsIHByb2JhYmx5IHRoZSBjYXJkIGhhcyBnb3Qgb3V0ICovCiAJCXJldHVybiAwOwogCW5ldGRldiA9IGNhcmQtPm5ldFswXTsKIAlpZiAoY21kICYgQ01EX0JVUzIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vdGlfaGVjYy5jIGIvZHJpdmVycy9uZXQvY2FuL3RpX2hlY2MuYwppbmRleCA0ZDA3ZjFlLi5mN2JiZGU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vdGlfaGVjYy5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi90aV9oZWNjLmMKQEAgLTY2Myw3ICs2NjMsNyBAQAogCXN0cnVjdCBjYW5fZnJhbWUgKmNmOwogCXN0cnVjdCBza19idWZmICpza2I7CiAKLQkvKiBwcm9wb2dhdGUgdGhlIGVycm9yIGNvbmRpdGlvbiB0byB0aGUgY2FuIHN0YWNrICovCisJLyogcHJvcGFnYXRlIHRoZSBlcnJvciBjb25kaXRpb24gdG8gdGhlIGNhbiBzdGFjayAqLwogCXNrYiA9IGFsbG9jX2Nhbl9lcnJfc2tiKG5kZXYsICZjZik7CiAJaWYgKCFza2IpIHsKIAkJaWYgKHByaW50a19yYXRlbGltaXQoKSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi91c2IvZW1zX3VzYi5jIGIvZHJpdmVycy9uZXQvY2FuL3VzYi9lbXNfdXNiLmMKaW5kZXggZTc1ZjFhOC4uYTcyYzdiZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL3VzYi9lbXNfdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3VzYi9lbXNfdXNiLmMKQEAgLTM4Niw3ICszODYsNyBAQAogCQkJYnJlYWs7CiAJCX0KIAotCQkvKiBFcnJvciBvY2N1cmVkIGR1cmluZyB0cmFuc21pc3Npb24/ICovCisJCS8qIEVycm9yIG9jY3VycmVkIGR1cmluZyB0cmFuc21pc3Npb24/ICovCiAJCWlmICgoZWNjICYgU0pBMTAwMF9FQ0NfRElSKSA9PSAwKQogCQkJY2YtPmRhdGFbMl0gfD0gQ0FOX0VSUl9QUk9UX1RYOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vdXNiL2VzZF91c2IyLmMgYi9kcml2ZXJzL25ldC9jYW4vdXNiL2VzZF91c2IyLmMKaW5kZXggZGM1M2M4My4uZWI4YjBlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL3VzYi9lc2RfdXNiMi5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi91c2IvZXNkX3VzYjIuYwpAQCAtMjg0LDcgKzI4NCw3IEBACiAJCQkJYnJlYWs7CiAJCQl9CiAKLQkJCS8qIEVycm9yIG9jY3VyZWQgZHVyaW5nIHRyYW5zbWlzc2lvbj8gKi8KKwkJCS8qIEVycm9yIG9jY3VycmVkIGR1cmluZyB0cmFuc21pc3Npb24/ICovCiAJCQlpZiAoIShlY2MgJiBTSkExMDAwX0VDQ19ESVIpKQogCQkJCWNmLT5kYXRhWzJdIHw9IENBTl9FUlJfUFJPVF9UWDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2Fzc2luaS5jIGIvZHJpdmVycy9uZXQvY2Fzc2luaS5jCmluZGV4IDM0Mzc2MTMuLjE0M2EyOGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhc3NpbmkuYworKysgYi9kcml2ZXJzL25ldC9jYXNzaW5pLmMKQEAgLTUxLDcgKzUxLDcgQEAKICAqIFRYIGhhcyA0IHF1ZXVlcy4gY3VycmVudGx5IHRoZXNlIHF1ZXVlcyBhcmUgdXNlZCBpbiBhIHJvdW5kLXJvYmluCiAgKiBmYXNoaW9uIGZvciBsb2FkIGJhbGFuY2luZy4gVGhleSBjYW4gYWxzbyBiZSB1c2VkIGZvciBRb1MuIGZvciB0aGF0CiAgKiB0byB3b3JrLCBob3dldmVyLCBRb1MgaW5mb3JtYXRpb24gbmVlZHMgdG8gYmUgZXhwb3NlZCBkb3duIHRvIHRoZSBkcml2ZXIKLSAqIGxldmVsIHNvIHRoYXQgc3VicXVldWVzIGdldCB0YXJnZXR0ZWQgdG8gcGFydGljdWxhciB0cmFuc21pdCByaW5ncy4KKyAqIGxldmVsIHNvIHRoYXQgc3VicXVldWVzIGdldCB0YXJnZXRlZCB0byBwYXJ0aWN1bGFyIHRyYW5zbWl0IHJpbmdzLgogICogYWx0ZXJuYXRpdmVseSwgdGhlIHF1ZXVlcyBjYW4gYmUgY29uZmlndXJlZCB2aWEgdXNlIG9mIHRoZSBhbGwtcHVycG9zZQogICogaW9jdGwuCiAgKgpAQCAtNTE2NSw3ICs1MTY1LDcgQEAKIAlwY2lfcmVsZWFzZV9yZWdpb25zKHBkZXYpOwogCiBlcnJfd3JpdGVfY2FjaGVsaW5lOgotCS8qIFRyeSB0byByZXN0b3JlIGl0IGluIGNhc2UgdGhlIGVycm9yIG9jY3VyZWQgYWZ0ZXIgd2UKKwkvKiBUcnkgdG8gcmVzdG9yZSBpdCBpbiBjYXNlIHRoZSBlcnJvciBvY2N1cnJlZCBhZnRlciB3ZQogCSAqIHNldCBpdC4KIAkgKi8KIAlwY2lfd3JpdGVfY29uZmlnX2J5dGUocGRldiwgUENJX0NBQ0hFX0xJTkVfU0laRSwgb3JpZ19jYWNoZWxpbmVfc2l6ZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYXNzaW5pLmggYi9kcml2ZXJzL25ldC9jYXNzaW5pLmgKaW5kZXggZmFmNDc0Ni4uYjM2MTQyNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2Fzc2luaS5oCisrKyBiL2RyaXZlcnMvbmV0L2Nhc3NpbmkuaApAQCAtNzcyLDcgKzc3Miw3IEBACiAjZGVmaW5lICAgIFJYX0RFQlVHX0lOVFJfV1JJVEVfUFRSX01BU0sgICAgMHhDMDAwMDAwMCAvKiBpbnRlcnJ1cHQgd3JpdGUgcG9pbnRlcgogCQkJCQkJCSBvZiB0aGUgaW50ZXJydXB0IHF1ZXVlICovCiAKLS8qIGZsb3cgY29udHJvbCBmcmFtZXMgYXJlIGVtbWl0dGVkIHVzaW5nIHR3byBQQVVTRSB0aHJlc2hvbGRzOgorLyogZmxvdyBjb250cm9sIGZyYW1lcyBhcmUgZW1pdHRlZCB1c2luZyB0d28gUEFVU0UgdGhyZXNob2xkczoKICAqIFhPRkYgUEFVU0UgdXNlcyBwYXVzZSB0aW1lIHZhbHVlIHByZS1wcm9ncmFtbWVkIGluIHRoZSBTZW5kIFBBVVNFIE1BQyByZWcKICAqIFhPTiBQQVVTRSB1c2VzIGEgcGF1c2UgdGltZSBvZiAwLiBncmFudWxhcml0eSBvZiB0aHJlc2hvbGQgaXMgNjRieXRlcy4KICAqIFBBVVNFIHRocmVzaG9sZHMgZGVmaW5lZCBpbiB0ZXJtcyBvZiBGSUZPIG9jY3VwYW5jeSBhbmQgbWF5IGJlIHRyYW5zbGF0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2NoZWxzaW8vbXY4OGUxeHh4LmMgYi9kcml2ZXJzL25ldC9jaGVsc2lvL212ODhlMXh4eC5jCmluZGV4IDgwOTA0N2EuLjcxMDE4YTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2NoZWxzaW8vbXY4OGUxeHh4LmMKKysrIGIvZHJpdmVycy9uZXQvY2hlbHNpby9tdjg4ZTF4eHguYwpAQCAtNDEsNyArNDEsNyBAQAogICoKICAqIFBBUkFNUzogY3BoeSAgICAgLSBQb2ludGVyIHRvIFBIWSBpbnN0YW5jZSBkYXRhLgogICoKLSAqIFJFVFVSTjogIDAgLSBTdWNjZXNzZnVsbCByZXNldC4KKyAqIFJFVFVSTjogIDAgLSBTdWNjZXNzZnVsIHJlc2V0LgogICogICAgICAgICAtMSAtIFRpbWVvdXQuCiAgKi8KIHN0YXRpYyBpbnQgbXY4OGUxeHh4X3Jlc2V0KHN0cnVjdCBjcGh5ICpjcGh5LCBpbnQgd2FpdCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2NoZWxzaW8vcG0zMzkzLmMgYi9kcml2ZXJzL25ldC9jaGVsc2lvL3BtMzM5My5jCmluZGV4IDdkYmIxNmQuLjQwYzdiOTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2NoZWxzaW8vcG0zMzkzLmMKKysrIGIvZHJpdmVycy9uZXQvY2hlbHNpby9wbTMzOTMuYwpAQCAtMjkzLDcgKzI5Myw3IEBACiAJcG0zMzkzX2VuYWJsZShjbWFjLCB3aGljaCk7CiAKIAkvKgotCSAqIFhYWCBUaGlzIHNob3VsZCBiZSBkb25lIGJ5IHRoZSBQSFkgYW5kIHByZWZlcnJhYmx5IG5vdCBhdCBhbGwuCisJICogWFhYIFRoaXMgc2hvdWxkIGJlIGRvbmUgYnkgdGhlIFBIWSBhbmQgcHJlZmVyYWJseSBub3QgYXQgYWxsLgogCSAqIFRoZSBQSFkgZG9lc24ndCBnaXZlIHVzIGxpbmsgc3RhdHVzIGluZGljYXRpb24gb24gaXRzIG93biBzbyBoYXZlCiAJICogdGhlIGxpbmsgbWFuYWdlbWVudCBjb2RlIHF1ZXJ5IGl0IGluc3RlYWQuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jaGVsc2lvL3NnZS5jIGIvZHJpdmVycy9uZXQvY2hlbHNpby9zZ2UuYwppbmRleCBmNzc4YjE1Li44NzU0ZDQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jaGVsc2lvL3NnZS5jCisrKyBiL2RyaXZlcnMvbmV0L2NoZWxzaW8vc2dlLmMKQEAgLTE2NjIsNyArMTY2Miw3IEBACiAgKiBUaGUgY29kZSBmaWd1cmVzIG91dCBob3cgbWFueSBlbnRyaWVzIHRoZSBza19idWZmIHdpbGwgcmVxdWlyZSBpbiB0aGUKICAqIGNtZFEgYW5kIHVwZGF0ZXMgdGhlIGNtZFEgZGF0YSBzdHJ1Y3R1cmUgd2l0aCB0aGUgc3RhdGUgb25jZSB0aGUgZW5xdWV1ZQogICogaGFzIGNvbXBsZXRlLiBUaGVuLCBpdCBkb2Vzbid0IGFjY2VzcyB0aGUgZ2xvYmFsIHN0cnVjdHVyZSBhbnltb3JlLCBidXQKLSAqIHVzZXMgdGhlIGNvcnJlc3BvbmRpbmcgZmllbGRzIG9uIHRoZSBzdGFjay4gSW4gY29uanVjdGlvbiB3aXRoIGEgc3BpbmxvY2sKKyAqIHVzZXMgdGhlIGNvcnJlc3BvbmRpbmcgZmllbGRzIG9uIHRoZSBzdGFjay4gSW4gY29uanVuY3Rpb24gd2l0aCBhIHNwaW5sb2NrCiAgKiBhcm91bmQgdGhhdCBjb2RlLCB3ZSBjYW4gbWFrZSB0aGUgZnVuY3Rpb24gcmVlbnRyYW50IHdpdGhvdXQgaG9sZGluZyB0aGUKICAqIGxvY2sgd2hlbiB3ZSBhY3R1YWxseSBlbnF1ZXVlICh3aGljaCBtaWdodCBiZSBleHBlbnNpdmUsIGVzcGVjaWFsbHkgb24KICAqIGFyY2hpdGVjdHVyZXMgd2l0aCBJTyBNTVVzKS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2NoZWxzaW8vdnNjNzMyNi5jIGIvZHJpdmVycy9uZXQvY2hlbHNpby92c2M3MzI2LmMKaW5kZXggMTA2YTU5MC4uYjBjYjM4OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2hlbHNpby92c2M3MzI2LmMKKysrIGIvZHJpdmVycy9uZXQvY2hlbHNpby92c2M3MzI2LmMKQEAgLTU2Niw3ICs1NjYsNyBAQAogCWZvciAoaSA9IDA7IGkgPD0gMHgzYTsgKytpKQogCQl2c2Nfd3JpdGUobWFjLT5hZGFwdGVyLCBDUkEoNCwgcG9ydCwgaSksIDApOwogCi0JLyogQ2xlYXIgc29md2FyZSBjb3VudGVycyAqLworCS8qIENsZWFyIHNvZnR3YXJlIGNvdW50ZXJzICovCiAJbWVtc2V0KCZtYWMtPnN0YXRzLCAwLCBzaXplb2Yoc3RydWN0IGNtYWNfc3RhdGlzdGljcykpOwogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jcmlzL2V0aF92MTAuYyBiL2RyaXZlcnMvbmV0L2NyaXMvZXRoX3YxMC5jCmluZGV4IDgwYzJmZWUuLjlkMjY3ZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2NyaXMvZXRoX3YxMC5jCisrKyBiL2RyaXZlcnMvbmV0L2NyaXMvZXRoX3YxMC5jCkBAIC0xMzgzLDcgKzEzODMsNyBAQAogCXNwaW5fbG9jaygmbnAtPmxvY2spOyAvKiBQcmVlbXB0IHByb3RlY3Rpb24gKi8KIAlzd2l0Y2ggKGNtZCkgewogCQkvKiBUaGUgaW9jdGxzIGJlbG93IHNob3VsZCBiZSBjb25zaWRlcmVkIG9ic29sZXRlIGJ1dCBhcmUgKi8KLQkJLyogc3RpbGwgcHJlc2VudCBmb3IgY29tcGF0YWJpbGl0eSB3aXRoIG9sZCBzY3JpcHRzL2FwcHMgICovCisJCS8qIHN0aWxsIHByZXNlbnQgZm9yIGNvbXBhdGliaWxpdHkgd2l0aCBvbGQgc2NyaXB0cy9hcHBzICAqLwogCQljYXNlIFNFVF9FVEhfU1BFRURfMTA6ICAgICAgICAgICAgICAgICAgLyogMTAgTWJwcyAqLwogCQkJZTEwMF9zZXRfc3BlZWQoZGV2LCAxMCk7CiAJCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2N4Z2IzL3NnZS5jIGIvZHJpdmVycy9uZXQvY3hnYjMvc2dlLmMKaW5kZXggZjlmNjY0NS4uYmZhMmQ1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY3hnYjMvc2dlLmMKKysrIGIvZHJpdmVycy9uZXQvY3hnYjMvc2dlLmMKQEAgLTE5OSw3ICsxOTksNyBAQAogICoJbmVlZF9za2JfdW5tYXAgLSBkb2VzIHRoZSBwbGF0Zm9ybSBuZWVkIHVubWFwcGluZyBvZiBza19idWZmcz8KICAqCiAgKglSZXR1cm5zIHRydWUgaWYgdGhlIHBsYXRmb3JtIG5lZWRzIHNrX2J1ZmYgdW5tYXBwaW5nLiAgVGhlIGNvbXBpbGVyCi0gKglvcHRpbWl6ZXMgYXdheSB1bmVjZXNzYXJ5IGNvZGUgaWYgdGhpcyByZXR1cm5zIHRydWUuCisgKglvcHRpbWl6ZXMgYXdheSB1bm5lY2Vzc2FyeSBjb2RlIGlmIHRoaXMgcmV0dXJucyB0cnVlLgogICovCiBzdGF0aWMgaW5saW5lIGludCBuZWVkX3NrYl91bm1hcCh2b2lkKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY3hnYjMvdDNfaHcuYyBiL2RyaXZlcnMvbmV0L2N4Z2IzL3QzX2h3LmMKaW5kZXggZDU1ZGI2Yi4uYzY4ODQyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY3hnYjMvdDNfaHcuYworKysgYi9kcml2ZXJzL25ldC9jeGdiMy90M19ody5jCkBAIC0xMzg2LDExICsxMzg2LDExIEBACiAgKglAcmVnOiB0aGUgaW50ZXJydXB0IHN0YXR1cyByZWdpc3RlciB0byBwcm9jZXNzCiAgKglAbWFzazogYSBtYXNrIHRvIGFwcGx5IHRvIHRoZSBpbnRlcnJ1cHQgc3RhdHVzCiAgKglAYWN0czogdGFibGUgb2YgaW50ZXJydXB0IGFjdGlvbnMKLSAqCUBzdGF0czogc3RhdGlzdGljcyBjb3VudGVycyB0cmFja2luZyBpbnRlcnJ1cHQgb2NjdXJlbmNlcworICoJQHN0YXRzOiBzdGF0aXN0aWNzIGNvdW50ZXJzIHRyYWNraW5nIGludGVycnVwdCBvY2N1cnJlbmNlcwogICoKICAqCUEgdGFibGUgZHJpdmVuIGludGVycnVwdCBoYW5kbGVyIHRoYXQgYXBwbGllcyBhIHNldCBvZiBtYXNrcyB0byBhbgogICoJaW50ZXJydXB0IHN0YXR1cyB3b3JkIGFuZCBwZXJmb3JtcyB0aGUgY29ycmVzcG9uZGluZyBhY3Rpb25zIGlmIHRoZQotICoJaW50ZXJydXB0cyBkZXNjcmliZWQgYnkgdGhlIG1hc2sgaGF2ZSBvY2N1cmVkLiAgVGhlIGFjdGlvbnMgaW5jbHVkZQorICoJaW50ZXJydXB0cyBkZXNjcmliZWQgYnkgdGhlIG1hc2sgaGF2ZSBvY2N1cnJlZC4gIFRoZSBhY3Rpb25zIGluY2x1ZGUKICAqCW9wdGlvbmFsbHkgcHJpbnRpbmcgYSB3YXJuaW5nIG9yIGFsZXJ0IG1lc3NhZ2UsIGFuZCBvcHRpb25hbGx5CiAgKglpbmNyZW1lbnRpbmcgYSBzdGF0IGNvdW50ZXIuICBUaGUgdGFibGUgaXMgdGVybWluYXRlZCBieSBhbiBlbnRyeQogICoJc3BlY2lmeWluZyBtYXNrIDAuICBSZXR1cm5zIHRoZSBudW1iZXIgb2YgZmF0YWwgaW50ZXJydXB0IGNvbmRpdGlvbnMuCkBAIC0yNzgzLDcgKzI3ODMsNyBAQAogewogCS8qCiAJICogU2VlIGRyYWZ0LW1hdGhpcy1wbHBtdHVkLTAwLnR4dCBmb3IgdGhlIHZhbHVlcy4gIFRoZSBtaW4gaXMgODggc28KLQkgKiBpdCBjYW4gYWNjb21vZGF0ZSBtYXggc2l6ZSBUQ1AvSVAgaGVhZGVycyB3aGVuIFNBQ0sgYW5kIHRpbWVzdGFtcHMKKwkgKiBpdCBjYW4gYWNjb21tb2RhdGUgbWF4IHNpemUgVENQL0lQIGhlYWRlcnMgd2hlbiBTQUNLIGFuZCB0aW1lc3RhbXBzCiAJICogYXJlIGVuYWJsZWQgYW5kIHN0aWxsIGhhdmUgYXQgbGVhc3QgOCBieXRlcyBvZiBwYXlsb2FkLgogCSAqLwogCW10dXNbMF0gPSA4ODsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2N4Z2I0L3Q0X2h3LmMgYi9kcml2ZXJzL25ldC9jeGdiNC90NF9ody5jCmluZGV4IGI5ZmQ4YTYuLmQxZWMxMTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2N4Z2I0L3Q0X2h3LmMKKysrIGIvZHJpdmVycy9uZXQvY3hnYjQvdDRfaHcuYwpAQCAtODgzLDcgKzg4Myw3IEBACiAgKgogICoJQSB0YWJsZSBkcml2ZW4gaW50ZXJydXB0IGhhbmRsZXIgdGhhdCBhcHBsaWVzIGEgc2V0IG9mIG1hc2tzIHRvIGFuCiAgKglpbnRlcnJ1cHQgc3RhdHVzIHdvcmQgYW5kIHBlcmZvcm1zIHRoZSBjb3JyZXNwb25kaW5nIGFjdGlvbnMgaWYgdGhlCi0gKglpbnRlcnJ1cHRzIGRlc2NyaWJlZCBieSB0aGUgbWFzayBoYXZlIG9jY3VyZWQuICBUaGUgYWN0aW9ucyBpbmNsdWRlCisgKglpbnRlcnJ1cHRzIGRlc2NyaWJlZCBieSB0aGUgbWFzayBoYXZlIG9jY3VycmVkLiAgVGhlIGFjdGlvbnMgaW5jbHVkZQogICoJb3B0aW9uYWxseSBlbWl0dGluZyBhIHdhcm5pbmcgb3IgYWxlcnQgbWVzc2FnZS4gIFRoZSB0YWJsZSBpcyB0ZXJtaW5hdGVkCiAgKglieSBhbiBlbnRyeSBzcGVjaWZ5aW5nIG1hc2sgMC4gIFJldHVybnMgdGhlIG51bWJlciBvZiBmYXRhbCBpbnRlcnJ1cHQKICAqCWNvbmRpdGlvbnMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jeGdiNHZmL2N4Z2I0dmZfbWFpbi5jIGIvZHJpdmVycy9uZXQvY3hnYjR2Zi9jeGdiNHZmX21haW4uYwppbmRleCA2YWFkNjRkLi40NjYxY2JiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jeGdiNHZmL2N4Z2I0dmZfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2N4Z2I0dmYvY3hnYjR2Zl9tYWluLmMKQEAgLTI3MzgsNyArMjczOCw3IEBACiAJY2ZnX3F1ZXVlcyhhZGFwdGVyKTsKIAogCS8qCi0JICogUHJpbnQgYSBzaG9ydCBub3RpY2Ugb24gdGhlIGV4aXN0YW5jZSBhbmQgY29uZmlndXJhdGlvbiBvZiB0aGUgbmV3CisJICogUHJpbnQgYSBzaG9ydCBub3RpY2Ugb24gdGhlIGV4aXN0ZW5jZSBhbmQgY29uZmlndXJhdGlvbiBvZiB0aGUgbmV3CiAJICogVkYgbmV0d29yayBkZXZpY2UgLi4uCiAJICovCiAJZm9yX2VhY2hfcG9ydChhZGFwdGVyLCBwaWR4KSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jeGdiNHZmL3NnZS5jIGIvZHJpdmVycy9uZXQvY3hnYjR2Zi9zZ2UuYwppbmRleCBlMGIzZDFiLi5iYjY1MTIxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jeGdiNHZmL3NnZS5jCisrKyBiL2RyaXZlcnMvbmV0L2N4Z2I0dmYvc2dlLmMKQEAgLTIyNCw4ICsyMjQsOCBAQAogLyoqCiAgKgluZWVkX3NrYl91bm1hcCAtIGRvZXMgdGhlIHBsYXRmb3JtIG5lZWQgdW5tYXBwaW5nIG9mIHNrX2J1ZmZzPwogICoKLSAqCVJldHVybnMgdHJ1ZSBpZiB0aGUgcGxhdGZyb20gbmVlZHMgc2tfYnVmZiB1bm1hcHBpbmcuICBUaGUgY29tcGlsZXIKLSAqCW9wdGltaXplcyBhd2F5IHVuZWNlc3NhcnkgY29kZSBpZiB0aGlzIHJldHVybnMgdHJ1ZS4KKyAqCVJldHVybnMgdHJ1ZSBpZiB0aGUgcGxhdGZvcm0gbmVlZHMgc2tfYnVmZiB1bm1hcHBpbmcuICBUaGUgY29tcGlsZXIKKyAqCW9wdGltaXplcyBhd2F5IHVubmVjZXNzYXJ5IGNvZGUgaWYgdGhpcyByZXR1cm5zIHRydWUuCiAgKi8KIHN0YXRpYyBpbmxpbmUgaW50IG5lZWRfc2tiX3VubWFwKHZvaWQpCiB7CkBAIC0yNjcsNyArMjY3LDcgQEAKICAqCiAgKglUZXN0cyBzcGVjaWZpZWQgRnJlZSBMaXN0IHRvIHNlZSB3aGV0aGVyIHRoZSBudW1iZXIgb2YgYnVmZmVycwogICoJYXZhaWxhYmxlIHRvIHRoZSBoYXJkd2FyZSBoYXMgZmFsbGVkIGJlbG93IG91ciAic3RhcnZhdGlvbiIKLSAqCXRocmVzaGhvbGQuCisgKgl0aHJlc2hvbGQuCiAgKi8KIHN0YXRpYyBpbmxpbmUgYm9vbCBmbF9zdGFydmluZyhjb25zdCBzdHJ1Y3Qgc2dlX2ZsICpmbCkKIHsKQEAgLTExNDksNyArMTE0OSw3IEBACiAJaWYgKHVubGlrZWx5KGNyZWRpdHMgPCBFVEhUWFFfU1RPUF9USFJFUykpIHsKIAkJLyoKIAkJICogQWZ0ZXIgd2UncmUgZG9uZSBpbmplY3RpbmcgdGhlIFdvcmsgUmVxdWVzdCBmb3IgdGhpcwotCQkgKiBwYWNrZXQsIHdlJ2xsIGJlIGJlbG93IG91ciAic3RvcCB0aHJlc2hob2xkIiBzbyBzdG9wIHRoZSBUWAorCQkgKiBwYWNrZXQsIHdlJ2xsIGJlIGJlbG93IG91ciAic3RvcCB0aHJlc2hvbGQiIHNvIHN0b3AgdGhlIFRYCiAJCSAqIFF1ZXVlIG5vdyBhbmQgc2NoZWR1bGUgYSByZXF1ZXN0IGZvciBhbiBTR0UgRWdyZXNzIFF1ZXVlCiAJCSAqIFVwZGF0ZSBtZXNzYWdlLiAgVGhlIHF1ZXVlIHdpbGwgZ2V0IHN0YXJ0ZWQgbGF0ZXIgb24gd2hlbgogCQkgKiB0aGUgZmlybXdhcmUgcHJvY2Vzc2VzIHRoaXMgV29yayBSZXF1ZXN0IGFuZCBzZW5kcyB1cyBhbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZGF2aW5jaV9lbWFjLmMgYi9kcml2ZXJzL25ldC9kYXZpbmNpX2VtYWMuYwppbmRleCBiYWNhNmJmLi44MDdiNmJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9kYXZpbmNpX2VtYWMuYworKysgYi9kcml2ZXJzL25ldC9kYXZpbmNpX2VtYWMuYwpAQCAtOTQsMTQgKzk0LDE0IEBACiBzdGF0aWMgY29uc3QgY2hhciBlbWFjX3ZlcnNpb25fc3RyaW5nW10gPSAiVEkgRGFWaW5jaSBFTUFDIExpbnV4IHY2LjEiOwogCiAvKiBDb25maWd1cmF0aW9uIGl0ZW1zICovCi0jZGVmaW5lIEVNQUNfREVGX1BBU1NfQ1JDCQkoMCkgLyogRG8gbm90IHBhc3MgQ1JDIHVwdG8gZnJhbWVzICovCisjZGVmaW5lIEVNQUNfREVGX1BBU1NfQ1JDCQkoMCkgLyogRG8gbm90IHBhc3MgQ1JDIHVwIHRvIGZyYW1lcyAqLwogI2RlZmluZSBFTUFDX0RFRl9RT1NfRU4JCQkoMCkgLyogRU1BQyBwcm9wcmlldGFyeSBRb1MgZGlzYWJsZWQgKi8KICNkZWZpbmUgRU1BQ19ERUZfTk9fQlVGRl9DSEFJTgkJKDApIC8qIE5vIGJ1ZmZlciBjaGFpbiAqLwogI2RlZmluZSBFTUFDX0RFRl9NQUNDVFJMX0ZSQU1FX0VOCSgwKSAvKiBEaXNjYXJkIE1hY2NvbnRyb2wgZnJhbWVzICovCiAjZGVmaW5lIEVNQUNfREVGX1NIT1JUX0ZSQU1FX0VOCQkoMCkgLyogRGlzY2FyZCBzaG9ydCBmcmFtZXMgKi8KICNkZWZpbmUgRU1BQ19ERUZfRVJST1JfRlJBTUVfRU4JCSgwKSAvKiBEaXNjYXJkIGVycm9yIGZyYW1lcyAqLwotI2RlZmluZSBFTUFDX0RFRl9QUk9NX0VOCQkoMCkgLyogUHJvbWlzY291cyBkaXNhYmxlZCAqLwotI2RlZmluZSBFTUFDX0RFRl9QUk9NX0NICQkoMCkgLyogUHJvbWlzY291cyBjaGFubmVsIGlzIDAgKi8KKyNkZWZpbmUgRU1BQ19ERUZfUFJPTV9FTgkJKDApIC8qIFByb21pc2N1b3VzIGRpc2FibGVkICovCisjZGVmaW5lIEVNQUNfREVGX1BST01fQ0gJCSgwKSAvKiBQcm9taXNjdW91cyBjaGFubmVsIGlzIDAgKi8KICNkZWZpbmUgRU1BQ19ERUZfQkNBU1RfRU4JCSgxKSAvKiBCcm9hZGNhc3QgZW5hYmxlZCAqLwogI2RlZmluZSBFTUFDX0RFRl9CQ0FTVF9DSAkJKDApIC8qIEJyb2FkY2FzdCBjaGFubmVsIGlzIDAgKi8KICNkZWZpbmUgRU1BQ19ERUZfTUNBU1RfRU4JCSgxKSAvKiBNdWx0aWNhc3QgZW5hYmxlZCAqLwpAQCAtMTAxMyw3ICsxMDEzLDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCS8qIHJlY3ljbGUgb24gcmVjaWV2ZSBlcnJvciAqLworCS8qIHJlY3ljbGUgb24gcmVjZWl2ZSBlcnJvciAqLwogCWlmIChzdGF0dXMgPCAwKSB7CiAJCW5kZXYtPnN0YXRzLnJ4X2Vycm9ycysrOwogCQlnb3RvIHJlY3ljbGU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9ldGh0b29sLmMgYi9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9ldGh0b29sLmMKaW5kZXggZjRkMDkyMi4uZGQ3MDczOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfZXRodG9vbC5jCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX2V0aHRvb2wuYwpAQCAtMTYwLDcgKzE2MCw3IEBACiAJCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmFkYXB0ZXItPmxpbmtfZHVwbGV4KTsKIAkJZWNtZC0+c3BlZWQgPSBhZGFwdGVyLT5saW5rX3NwZWVkOwogCi0JCS8qIHVuZm9ydHVuYXRseSBGVUxMX0RVUExFWCAhPSBEVVBMRVhfRlVMTAorCQkvKiB1bmZvcnR1bmF0ZWx5IEZVTExfRFVQTEVYICE9IERVUExFWF9GVUxMCiAJCSAqICAgICAgICAgIGFuZCBIQUxGX0RVUExFWCAhPSBEVVBMRVhfSEFMRiAqLwogCiAJCWlmIChhZGFwdGVyLT5saW5rX2R1cGxleCA9PSBGVUxMX0RVUExFWCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX2h3LmggYi9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9ody5oCmluZGV4IGM3MGIyM2QuLjVjOWE4NDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX2h3LmgKKysrIGIvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfaHcuaApAQCAtMTAyNiw3ICsxMDI2LDcgQEAKIAogI2RlZmluZSBFMTAwMF9LVU1DVFJMU1RBIDB4MDAwMzQJLyogTUFDLVBIWSBpbnRlcmZhY2UgLSBSVyAqLwogI2RlZmluZSBFMTAwMF9NRFBIWUEgICAgIDB4MDAwM0MJLyogUEhZIGFkZHJlc3MgLSBSVyAqLwotI2RlZmluZSBFMTAwMF9NQU5DMkggICAgIDB4MDU4NjAJLyogTWFuYWdtZW50IENvbnRyb2wgVG8gSG9zdCAtIFJXICovCisjZGVmaW5lIEUxMDAwX01BTkMySCAgICAgMHgwNTg2MAkvKiBNYW5hZ2VtZW50IENvbnRyb2wgVG8gSG9zdCAtIFJXICovCiAjZGVmaW5lIEUxMDAwX1NXX0ZXX1NZTkMgMHgwNUI1QwkvKiBTb2Z0d2FyZS1GaXJtd2FyZSBTeW5jaHJvbml6YXRpb24gLSBSVyAqLwogCiAjZGVmaW5lIEUxMDAwX0dDUiAgICAgICAweDA1QjAwCS8qIFBDSS1FeCBDb250cm9sICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9tYWluLmMgYi9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9tYWluLmMKaW5kZXggYmZhYjE0MC4uNDc3ZTA2NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX21haW4uYwpAQCAtMjA1LDcgKzIwNSw3IEBACiAJLnByb2JlICAgID0gZTEwMDBfcHJvYmUsCiAJLnJlbW92ZSAgID0gX19kZXZleGl0X3AoZTEwMDBfcmVtb3ZlKSwKICNpZmRlZiBDT05GSUdfUE0KLQkvKiBQb3dlciBNYW5hZ21lbnQgSG9va3MgKi8KKwkvKiBQb3dlciBNYW5hZ2VtZW50IEhvb2tzICovCiAJLnN1c3BlbmQgID0gZTEwMDBfc3VzcGVuZCwKIAkucmVzdW1lICAgPSBlMTAwMF9yZXN1bWUsCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9uZXRkZXYuYyBiL2RyaXZlcnMvbmV0L2UxMDAwZS9uZXRkZXYuYwppbmRleCBhMzlkNGE0Li41MDZhMGEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMGUvbmV0ZGV2LmMKKysrIGIvZHJpdmVycy9uZXQvZTEwMDBlL25ldGRldi5jCkBAIC00ODg2LDcgKzQ4ODYsNyBAQAogCWlmIChza2ItPnByb3RvY29sID09IGh0b25zKEVUSF9QX0lQKSkKIAkJdHhfZmxhZ3MgfD0gRTEwMDBfVFhfRkxBR1NfSVBWNDsKIAotCS8qIGlmIGNvdW50IGlzIDAgdGhlbiBtYXBwaW5nIGVycm9yIGhhcyBvY2N1cmVkICovCisJLyogaWYgY291bnQgaXMgMCB0aGVuIG1hcHBpbmcgZXJyb3IgaGFzIG9jY3VycmVkICovCiAJY291bnQgPSBlMTAwMF90eF9tYXAoYWRhcHRlciwgc2tiLCBmaXJzdCwgbWF4X3Blcl90eGQsIG5yX2ZyYWdzLCBtc3MpOwogCWlmIChjb3VudCkgewogCQllMTAwMF90eF9xdWV1ZShhZGFwdGVyLCB0eF9mbGFncywgY291bnQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZW5jMjhqNjBfaHcuaCBiL2RyaXZlcnMvbmV0L2VuYzI4ajYwX2h3LmgKaW5kZXggMWEwYjIwOS4uMjViNDFkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZW5jMjhqNjBfaHcuaAorKysgYi9kcml2ZXJzL25ldC9lbmMyOGo2MF9ody5oCkBAIC0zMDMsNyArMzAzLDcgQEAKIC8qIG1heGltdW0gZXRoZXJuZXQgZnJhbWUgbGVuZ3RoICovCiAjZGVmaW5lIE1BWF9GUkFNRUxFTgkJMTUxOAogCi0vKiBQcmVmZXJlZCBoYWxmIGR1cGxleDogTEVEQTogTGluayBzdGF0dXMgTEVEQjogUngvVHggYWN0aXZpdHkgKi8KKy8qIFByZWZlcnJlZCBoYWxmIGR1cGxleDogTEVEQTogTGluayBzdGF0dXMgTEVEQjogUngvVHggYWN0aXZpdHkgKi8KICNkZWZpbmUgRU5DMjhKNjBfTEFNUFNfTU9ERQkweDM0NzYKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGgxNmkuYyBiL2RyaXZlcnMvbmV0L2V0aDE2aS5jCmluZGV4IGZiNzE3YmUuLjEyZDI4ZTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aDE2aS5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aDE2aS5jCkBAIC0xMyw3ICsxMyw3IEBACiAgICBUaGlzIGRyaXZlciBzdXBwb3J0cyBmb2xsb3dpbmcgY2FyZHMgOgogCS0gSUNMIEV0aGVyVGVhbSAxNmkKIAktIElDTCBFdGhlclRlYW0gMzIgRUlTQQotCSAgKFVzZXMgdHJ1ZSAzMiBiaXQgdHJhbnNmZXJzIHJhdGhlciB0aGFuIDE2aSBjb21wYWJpbGl0eSBtb2RlKQorCSAgKFVzZXMgdHJ1ZSAzMiBiaXQgdHJhbnNmZXJzIHJhdGhlciB0aGFuIDE2aSBjb21wYXRpYmlsaXR5IG1vZGUpCiAKICAgIEV4YW1wbGUgTW9kdWxlIHVzYWdlOgogICAgICAgICBpbnNtb2QgZXRoMTZpLm8gaW89MHgyYTAgbWVkaWF0eXBlPWJuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRob2MuYyBiL2RyaXZlcnMvbmV0L2V0aG9jLmMKaW5kZXggZGIwMjkwZi4uYTgzZGQzMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRob2MuYworKysgYi9kcml2ZXJzL25ldC9ldGhvYy5jCkBAIC01NDIsNyArNTQyLDcgQEAKIAogCS8qIEZpZ3VyZSBvdXQgd2hhdCB0cmlnZ2VyZWQgdGhlIGludGVycnVwdC4uLgogCSAqIFRoZSB0cmlja3kgYml0IGhlcmUgaXMgdGhhdCB0aGUgaW50ZXJydXB0IHNvdXJjZSBiaXRzIGdldAotCSAqIHNldCBpbiBJTlRfU09VUkNFIGZvciBhbiBldmVudCBpcnJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0aGF0CisJICogc2V0IGluIElOVF9TT1VSQ0UgZm9yIGFuIGV2ZW50IHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0aGF0CiAJICogZXZlbnQgaXMgbWFza2VkIG9yIG5vdC4gIFRodXMsIGluIG9yZGVyIHRvIGZpZ3VyZSBvdXQgd2hhdAogCSAqIHRyaWdnZXJlZCB0aGUgaW50ZXJydXB0LCB3ZSBuZWVkIHRvIHJlbW92ZSB0aGUgc291cmNlcwogCSAqIGZvciBhbGwgZXZlbnRzIHRoYXQgYXJlIGN1cnJlbnRseSBtYXNrZWQuICBUaGlzIGJlaGF2aW91cgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZmVjLmggYi9kcml2ZXJzL25ldC9mZWMuaAppbmRleCBhY2UzMThkLi44YjJjNmQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9mZWMuaAorKysgYi9kcml2ZXJzL25ldC9mZWMuaApAQCAtOTcsMTEgKzk3LDExIEBACiAgKglUaGUgZm9sbG93aW5nIGRlZmluaXRpb25zIGNvdXJ0ZXN5IG9mIGNvbW1wcm9jLmgsIHdoaWNoIHdoZXJlCiAgKglDb3B5cmlnaHQgKGMpIDE5OTcgRGFuIE1hbGVrIChkbWFsZWtAamxjLm5ldCkuCiAgKi8KLSNkZWZpbmUgQkRfU0NfRU1QVFkgICAgICgodXNob3J0KTB4ODAwMCkgICAgICAgIC8qIFJlY2lldmUgaXMgZW1wdHkgKi8KKyNkZWZpbmUgQkRfU0NfRU1QVFkgICAgICgodXNob3J0KTB4ODAwMCkgICAgICAgIC8qIFJlY2VpdmUgaXMgZW1wdHkgKi8KICNkZWZpbmUgQkRfU0NfUkVBRFkgICAgICgodXNob3J0KTB4ODAwMCkgICAgICAgIC8qIFRyYW5zbWl0IGlzIHJlYWR5ICovCiAjZGVmaW5lIEJEX1NDX1dSQVAgICAgICAoKHVzaG9ydCkweDIwMDApICAgICAgICAvKiBMYXN0IGJ1ZmZlciBkZXNjcmlwdG9yICovCiAjZGVmaW5lIEJEX1NDX0lOVFJQVCAgICAoKHVzaG9ydCkweDEwMDApICAgICAgICAvKiBJbnRlcnJ1cHQgb24gY2hhbmdlICovCi0jZGVmaW5lIEJEX1NDX0NNICAgICAgICAoKHVzaG9ydCkweDAyMDApICAgICAgICAvKiBDb250aW5vdXMgbW9kZSAqLworI2RlZmluZSBCRF9TQ19DTSAgICAgICAgKCh1c2hvcnQpMHgwMjAwKSAgICAgICAgLyogQ29udGludW91cyBtb2RlICovCiAjZGVmaW5lIEJEX1NDX0lEICAgICAgICAoKHVzaG9ydCkweDAxMDApICAgICAgICAvKiBSZWMnZCB0b28gbWFueSBpZGxlcyAqLwogI2RlZmluZSBCRF9TQ19QICAgICAgICAgKCh1c2hvcnQpMHgwMTAwKSAgICAgICAgLyogeG10IHByZWFtYmxlICovCiAjZGVmaW5lIEJEX1NDX0JSICAgICAgICAoKHVzaG9ydCkweDAwMjApICAgICAgICAvKiBCcmVhayByZWNlaXZlZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZm9yY2VkZXRoLmMgYi9kcml2ZXJzL25ldC9mb3JjZWRldGguYwppbmRleCA3YjkyODk3Li5kNWFiNGRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9mb3JjZWRldGguYworKysgYi9kcml2ZXJzL25ldC9mb3JjZWRldGguYwpAQCAtNDQwLDcgKzQ0MCw3IEBACiAjZGVmaW5lIE5WX1JYM19WTEFOX1RBR19QUkVTRU5UICgxPDwxNikKICNkZWZpbmUgTlZfUlgzX1ZMQU5fVEFHX01BU0sJKDB4MDAwMEZGRkYpCiAKLS8qIE1pc2NlbGFuZW91cyBoYXJkd2FyZSByZWxhdGVkIGRlZmluZXM6ICovCisvKiBNaXNjZWxsYW5lb3VzIGhhcmR3YXJlIHJlbGF0ZWQgZGVmaW5lczogKi8KICNkZWZpbmUgTlZfUENJX1JFR1NaX1ZFUjEJMHgyNzAKICNkZWZpbmUgTlZfUENJX1JFR1NaX1ZFUjIJMHgyZDQKICNkZWZpbmUgTlZfUENJX1JFR1NaX1ZFUjMJMHg2MDQKQEAgLTE0ODgsNyArMTQ4OCw3IEBACiAJCX0KIAl9CiAKLQkvKiBzb21lIHBoeXMgY2xlYXIgb3V0IHBhdXNlIGFkdmVydGlzbWVudCBvbiByZXNldCwgc2V0IGl0IGJhY2sgKi8KKwkvKiBzb21lIHBoeXMgY2xlYXIgb3V0IHBhdXNlIGFkdmVydGlzZW1lbnQgb24gcmVzZXQsIHNldCBpdCBiYWNrICovCiAJbWlpX3J3KGRldiwgbnAtPnBoeWFkZHIsIE1JSV9BRFZFUlRJU0UsIHJlZyk7CiAKIAkvKiByZXN0YXJ0IGF1dG8gbmVnb3RpYXRpb24sIHBvd2VyIGRvd24gcGh5ICovCkBAIC0yNTM1LDcgKzI1MzUsNyBAQAogCWVsc2UKIAkJbnZfdHhfZG9uZV9vcHRpbWl6ZWQoZGV2LCBucC0+dHhfcmluZ19zaXplKTsKIAotCS8qIHNhdmUgY3VycmVudCBIVyBwb3N0aW9uICovCisJLyogc2F2ZSBjdXJyZW50IEhXIHBvc2l0aW9uICovCiAJaWYgKG5wLT50eF9jaGFuZ2Vfb3duZXIpCiAJCXB1dF90eC5leCA9IG5wLT50eF9jaGFuZ2Vfb3duZXItPmZpcnN0X3R4X2Rlc2M7CiAJZWxzZQpAQCAtNDA1Myw3ICs0MDUzLDcgQEAKIAogCX0gZWxzZSBpZiAoZWNtZC0+YXV0b25lZyA9PSBBVVRPTkVHX0RJU0FCTEUpIHsKIAkJLyogTm90ZTogYXV0b25lZ290aWF0aW9uIGRpc2FibGUsIHNwZWVkIDEwMDAgaW50ZW50aW9uYWxseQotCQkgKiBmb3JiaWRkZW4gLSBub29uZSBzaG91bGQgbmVlZCB0aGF0LiAqLworCQkgKiBmb3JiaWRkZW4gLSBubyBvbmUgc2hvdWxkIG5lZWQgdGhhdC4gKi8KIAogCQlpZiAoZWNtZC0+c3BlZWQgIT0gU1BFRURfMTAgJiYgZWNtZC0+c3BlZWQgIT0gU1BFRURfMTAwKQogCQkJcmV0dXJuIC1FSU5WQUw7CkBAIC00MTAzLDcgKzQxMDMsNyBAQAogCQkJYWR2IHw9IEFEVkVSVElTRV8xMDBIQUxGOwogCQlpZiAoZWNtZC0+YWR2ZXJ0aXNpbmcgJiBBRFZFUlRJU0VEXzEwMGJhc2VUX0Z1bGwpCiAJCQlhZHYgfD0gQURWRVJUSVNFXzEwMEZVTEw7Ci0JCWlmIChucC0+cGF1c2VfZmxhZ3MgJiBOVl9QQVVTRUZSQU1FX1JYX1JFUSkgIC8qIGZvciByeCB3ZSBzZXQgYm90aCBhZHZlcnRpc21lbnRzIGJ1dCBkaXNhYmxlIHR4IHBhdXNlICovCisJCWlmIChucC0+cGF1c2VfZmxhZ3MgJiBOVl9QQVVTRUZSQU1FX1JYX1JFUSkgIC8qIGZvciByeCB3ZSBzZXQgYm90aCBhZHZlcnRpc2VtZW50cyBidXQgZGlzYWJsZSB0eCBwYXVzZSAqLwogCQkJYWR2IHw9ICBBRFZFUlRJU0VfUEFVU0VfQ0FQIHwgQURWRVJUSVNFX1BBVVNFX0FTWU07CiAJCWlmIChucC0+cGF1c2VfZmxhZ3MgJiBOVl9QQVVTRUZSQU1FX1RYX1JFUSkKIAkJCWFkdiB8PSAgQURWRVJUSVNFX1BBVVNFX0FTWU07CkBAIC00MTQ4LDcgKzQxNDgsNyBAQAogCQlpZiAoZWNtZC0+c3BlZWQgPT0gU1BFRURfMTAwICYmIGVjbWQtPmR1cGxleCA9PSBEVVBMRVhfRlVMTCkKIAkJCWFkdiB8PSBBRFZFUlRJU0VfMTAwRlVMTDsKIAkJbnAtPnBhdXNlX2ZsYWdzICY9IH4oTlZfUEFVU0VGUkFNRV9BVVRPTkVHfE5WX1BBVVNFRlJBTUVfUlhfRU5BQkxFfE5WX1BBVVNFRlJBTUVfVFhfRU5BQkxFKTsKLQkJaWYgKG5wLT5wYXVzZV9mbGFncyAmIE5WX1BBVVNFRlJBTUVfUlhfUkVRKSB7LyogZm9yIHJ4IHdlIHNldCBib3RoIGFkdmVydGlzbWVudHMgYnV0IGRpc2FibGUgdHggcGF1c2UgKi8KKwkJaWYgKG5wLT5wYXVzZV9mbGFncyAmIE5WX1BBVVNFRlJBTUVfUlhfUkVRKSB7LyogZm9yIHJ4IHdlIHNldCBib3RoIGFkdmVydGlzZW1lbnRzIGJ1dCBkaXNhYmxlIHR4IHBhdXNlICovCiAJCQlhZHYgfD0gIEFEVkVSVElTRV9QQVVTRV9DQVAgfCBBRFZFUlRJU0VfUEFVU0VfQVNZTTsKIAkJCW5wLT5wYXVzZV9mbGFncyB8PSBOVl9QQVVTRUZSQU1FX1JYX0VOQUJMRTsKIAkJfQpAQCAtNDQ0OSw3ICs0NDQ5LDcgQEAKIAogCQlhZHYgPSBtaWlfcncoZGV2LCBucC0+cGh5YWRkciwgTUlJX0FEVkVSVElTRSwgTUlJX1JFQUQpOwogCQlhZHYgJj0gfihBRFZFUlRJU0VfUEFVU0VfQ0FQIHwgQURWRVJUSVNFX1BBVVNFX0FTWU0pOwotCQlpZiAobnAtPnBhdXNlX2ZsYWdzICYgTlZfUEFVU0VGUkFNRV9SWF9SRVEpIC8qIGZvciByeCB3ZSBzZXQgYm90aCBhZHZlcnRpc21lbnRzIGJ1dCBkaXNhYmxlIHR4IHBhdXNlICovCisJCWlmIChucC0+cGF1c2VfZmxhZ3MgJiBOVl9QQVVTRUZSQU1FX1JYX1JFUSkgLyogZm9yIHJ4IHdlIHNldCBib3RoIGFkdmVydGlzZW1lbnRzIGJ1dCBkaXNhYmxlIHR4IHBhdXNlICovCiAJCQlhZHYgfD0gIEFEVkVSVElTRV9QQVVTRV9DQVAgfCBBRFZFUlRJU0VfUEFVU0VfQVNZTTsKIAkJaWYgKG5wLT5wYXVzZV9mbGFncyAmIE5WX1BBVVNFRlJBTUVfVFhfUkVRKQogCQkJYWR2IHw9ICBBRFZFUlRJU0VfUEFVU0VfQVNZTTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2dpYW5mYXIuaCBiL2RyaXZlcnMvbmV0L2dpYW5mYXIuaAppbmRleCBlYzVkNTk1Li5iMmZlN2VkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9naWFuZmFyLmgKKysrIGIvZHJpdmVycy9uZXQvZ2lhbmZhci5oCkBAIC0xMDQzLDcgKzEwNDMsNyBAQAogfTsKIAogLyogU3RydWN0IHN0b2xlbiBhbG1vc3QgY29tcGxldGVseSAoYW5kIHNoYW1lbGVzc2x5KSBmcm9tIHRoZSBGQ0MgZW5ldCBzb3VyY2UKLSAqIChPaywgdGhhdCdzIG5vdCBzbyB0cnVlIGFueW1vcmUsIGJ1dCB0aGVyZSBpcyBhIGZhbWlseSByZXNlbWJsZW5jZSkKKyAqIChPaywgdGhhdCdzIG5vdCBzbyB0cnVlIGFueW1vcmUsIGJ1dCB0aGVyZSBpcyBhIGZhbWlseSByZXNlbWJsYW5jZSkKICAqIFRoZSBHRkFSIGJ1ZmZlciBkZXNjcmlwdG9ycyB0cmFjayB0aGUgcmluZyBidWZmZXJzLiAgVGhlIHJ4X2JkX2Jhc2UKICAqIGFuZCB0eF9iZF9iYXNlIGFsd2F5cyBwb2ludCB0byB0aGUgY3VycmVudGx5IGF2YWlsYWJsZSBidWZmZXIuCiAgKiBUaGUgZGlydHlfdHggdHJhY2tzIHRoZSBjdXJyZW50IGJ1ZmZlciB0aGF0IGlzIGJlaW5nIHNlbnQgYnkgdGhlCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9oYW1yYWRpby9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L2hhbXJhZGlvL01ha2VmaWxlCmluZGV4IDlkZWY4NjcuLjEwNDA5NjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2hhbXJhZGlvL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvbmV0L2hhbXJhZGlvL01ha2VmaWxlCkBAIC0zLDcgKzMsNyBAQAogIwogIwogIyAxOTk3MTEzMCAJTW92ZWQgdGhlIGFtYXRldXIgcmFkaW8gcmVsYXRlZCBuZXR3b3JrIGRyaXZlcnMgZnJvbSAKLSMJCWRyaXZlcnMvbmV0LyB0byBkcml2ZXJzL2hhbXJhZGlvIGZvciBlYXNpZXIgbWFpbnRhaW5hbmNlLgorIwkJZHJpdmVycy9uZXQvIHRvIGRyaXZlcnMvaGFtcmFkaW8gZm9yIGVhc2llciBtYWludGVuYW5jZS4KICMgICAgICAgICAgICAgICBKb2VyZyBSZXV0ZXIgREwxQktFIDxqcmV1dGVyQHlhaW5hLmRlPgogIwogIyAyMDAwMDgwNglSZXdyaXR0ZW4gdG8gdXNlIGxpc3RzIGluc3RlYWQgb2YgaWYtc3RhdGVtZW50cy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2hhbXJhZGlvL3lhbS5jIGIvZHJpdmVycy9uZXQvaGFtcmFkaW8veWFtLmMKaW5kZXggN2Q5Y2VkMC4uOTZhOThkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaGFtcmFkaW8veWFtLmMKKysrIGIvZHJpdmVycy9uZXQvaGFtcmFkaW8veWFtLmMKQEAgLTMwLDcgKzMwLDcgQEAKICAqICAgMC4xIEYxT0FUIDA3LjA2Ljk4ICBBZGQgdGltZXIgcG9sbGluZyByb3V0aW5lIGZvciBjaGFubmVsIGFyYml0cmF0aW9uCiAgKiAgIDAuMiBGNkZCQiAwOC4wNi45OCAgQWRkZWQgZGVsYXkgYWZ0ZXIgRlBHQSBwcm9ncmFtbWluZwogICogICAwLjMgRjZGQkIgMjkuMDcuOTggIERlbGF5ZWQgUFRUIGltcGxlbWVudGF0aW9uIGZvciBkdXBtb2RlPTIKLSAqICAgMC40IEY2RkJCIDMwLjA3Ljk4ICBBZGRlZCBUeFRhaWwsIFNsb3R0aW1lIGFuZCBQZXJzaXN0YW5jZQorICogICAwLjQgRjZGQkIgMzAuMDcuOTggIEFkZGVkIFR4VGFpbCwgU2xvdHRpbWUgYW5kIFBlcnNpc3RlbmNlCiAgKiAgIDAuNSBGNkZCQiAwMS4wOC45OCAgU2hhcmVkIElSUXMsIC9wcm9jL25ldCBhbmQgbmV0d29yayBzdGF0aXN0aWNzCiAgKiAgIDAuNiBGNkZCQiAyNS4wOC45OCAgQWRkZWQgMTIwMEJkcyBmb3JtYXQKICAqICAgMC43IEY2RkJCIDEyLjA5Ljk4ICBBZGRlZCB0byB0aGUga2VybmVsIGNvbmZpZ3VyYXRpb24KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2hwMTAwLmMgYi9kcml2ZXJzL25ldC9ocDEwMC5jCmluZGV4IDhlMmM0NjAuLjhlMTBkMmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2hwMTAwLmMKKysrIGIvZHJpdmVycy9uZXQvaHAxMDAuYwpAQCAtMTgwLDggKzE4MCw4IEBACiAKIAl1X2ludCAqcGFnZV92YWRkcl9hbGduOwkvKiBBbGlnbmVkIHZpcnR1YWwgYWRkcmVzcyBvZiBhbGxvY2F0ZWQgcGFnZSAqLwogCXVfbG9uZyB3aGF0ZXZlcl9vZmZzZXQ7CS8qIE9mZnNldCB0byBidXMvcGh5cy9kbWEgYWRkcmVzcyAqLwotCWludCByeHJjb21taXQ7CQkvKiAjIFJ4IFBETHMgY29tbWl0ZWQgdG8gYWRhcHRlciAqLwotCWludCB0eHJjb21taXQ7CQkvKiAjIFR4IFBETHMgY29tbWl0ZWQgdG8gYWRhcHRlciAqLworCWludCByeHJjb21taXQ7CQkvKiAjIFJ4IFBETHMgY29tbWl0dGVkIHRvIGFkYXB0ZXIgKi8KKwlpbnQgdHhyY29tbWl0OwkJLyogIyBUeCBQRExzIGNvbW1pdHRlZCB0byBhZGFwdGVyICovCiB9OwogCiAvKgpAQCAtNzE2LDcgKzcxNiw3IEBACiAJICogaW1wbGVtZW50ZWQvdGVzdGVkIG9ubHkgd2l0aCB0aGUgbGFzc2VuIGNoaXAgYW55d2F5Li4uICovCiAJaWYgKGxwLT5tb2RlID09IDEpIHsJLyogYnVzbWFzdGVyICovCiAJCWRtYV9hZGRyX3QgcGFnZV9iYWRkcjsKLQkJLyogR2V0IHBoeXNpY2FsbHkgY29udGlub3VzIG1lbW9yeSBmb3IgVFggJiBSWCBQRExzICAgICovCisJCS8qIEdldCBwaHlzaWNhbGx5IGNvbnRpbnVvdXMgbWVtb3J5IGZvciBUWCAmIFJYIFBETHMgICAgKi8KIAkJLyogQ29udmVyc2lvbiB0byBuZXcgUENJIEFQSSA6CiAJCSAqIFBhZ2VzIGFyZSBhbHdheXMgYWxpZ25lZCBhbmQgemVyb2VkLCBubyBuZWVkIHRvIGl0IG91cnNlbGYuCiAJCSAqIERvYyBzYXlzIHNob3VsZCBiZSBPSyBmb3IgRUlTQSBidXMgYXMgd2VsbCAtIEplYW4gSUkgKi8KQEAgLTE1OTYsNyArMTU5Niw3IEBACiAKIC8qIGNsZWFuX3R4cmluZyBjaGVja3MgaWYgcGFja2V0cyBoYXZlIGJlZW4gc2VudCBieSB0aGUgY2FyZCBieSByZWFkaW5nCiAgKiB0aGUgVFhfUERMIHJlZ2lzdGVyIGZyb20gdGhlIHBlcmZvcm1hbmNlIHBhZ2UgYW5kIGNvbXBhcmluZyBpdCB0byB0aGUKLSAqIG51bWJlciBvZiBjb21taXRlZCBwYWNrZXRzLiBJdCB0aGVuIGZyZWVzIHRoZSBza2IncyBvZiB0aGUgcGFja2V0cyB0aGF0CisgKiBudW1iZXIgb2YgY29tbWl0dGVkIHBhY2tldHMuIEl0IHRoZW4gZnJlZXMgdGhlIHNrYidzIG9mIHRoZSBwYWNrZXRzIHRoYXQKICAqIG9idmlvdXNseSBoYXZlIGJlZW4gc2VudCB0byB0aGUgbmV0d29yay4KICAqCiAgKiBOZWVkcyB0aGUgUEVSRk9STUFOQ0UgcGFnZSBzZWxlY3RlZC4KQEAgLTE2MTcsNyArMTYxNyw3IEBACiAKICNpZmRlZiBIUDEwMF9ERUJVRwogCWlmIChkb25lY291bnQgPiBNQVhfVFhfUERMKQotCQlwcmludGsoImhwMTAwOiAlczogV2FybmluZzogTW9yZSBQRExzIHRyYW5zbWl0dGVkIHRoYW4gY29tbWl0ZWQgdG8gY2FyZD8/P1xuIiwgZGV2LT5uYW1lKTsKKwkJcHJpbnRrKCJocDEwMDogJXM6IFdhcm5pbmc6IE1vcmUgUERMcyB0cmFuc21pdHRlZCB0aGFuIGNvbW1pdHRlZCB0byBjYXJkPz8/XG4iLCBkZXYtPm5hbWUpOwogI2VuZGlmCiAKIAlmb3IgKDsgMCAhPSBkb25lY291bnQ7IGRvbmVjb3VudC0tKSB7CkBAIC0xNzY1LDcgKzE3NjUsNyBAQAogICogUmVjZWl2ZSBGdW5jdGlvbiAoTm9uLUJ1c21hc3RlciBtb2RlKQogICogQ2FsbGVkIHdoZW4gYW4gIlJlY2VpdmUgUGFja2V0IiBpbnRlcnJ1cHQgb2NjdXJzLCBpLmUuIHRoZSByZWNlaXZlCiAgKiBwYWNrZXQgY291bnRlciBpcyBub24temVyby4KLSAqIEZvciBub24tYnVzbWFzdGVyLCB0aGlzIGZ1bmN0aW9uIGRvZXMgdGhlIHdob2xlIHdvcmsgb2YgdHJhbnNmZXJpbmcKKyAqIEZvciBub24tYnVzbWFzdGVyLCB0aGlzIGZ1bmN0aW9uIGRvZXMgdGhlIHdob2xlIHdvcmsgb2YgdHJhbnNmZXJyaW5nCiAgKiB0aGUgcGFja2V0IHRvIHRoZSBob3N0IG1lbW9yeSBhbmQgdGhlbiB1cCB0byBoaWdoZXIgbGF5ZXJzIHZpYSBza2IKICAqIGFuZCBuZXRpZl9yeC4KICAqLwpAQCAtMTg5Miw3ICsxODkyLDcgQEAKIAkJLyogUlhfUEtUX0NOVCBzdGF0ZXMgaG93IG1hbnkgUERMcyBhcmUgY3VycmVudGx5IGZvcm1hdHRlZCBhbmQgYXZhaWxhYmxlIHRvCiAJCSAqIHRoZSBjYXJkcyBCTSBlbmdpbmUgKi8KIAlpZiAoKGhwMTAwX2ludyhSWF9QS1RfQ05UKSAmIDB4MDBmZikgPj0gbHAtPnJ4cmNvbW1pdCkgewotCQlwcmludGsoImhwMTAwOiAlczogTW9yZSBwYWNrZXRzIHJlY2VpdmVkIHRoYW4gY29tbWl0ZWQ/IFJYX1BLVF9DTlQ9MHgleCwgY29tbWl0PTB4JXhcbiIsCisJCXByaW50aygiaHAxMDA6ICVzOiBNb3JlIHBhY2tldHMgcmVjZWl2ZWQgdGhhbiBjb21taXR0ZWQ/IFJYX1BLVF9DTlQ9MHgleCwgY29tbWl0PTB4JXhcbiIsCiAJCQkJICAgICBkZXYtPm5hbWUsIGhwMTAwX2ludyhSWF9QS1RfQ05UKSAmIDB4MDBmZiwKIAkJCQkgICAgIGxwLT5yeHJjb21taXQpOwogCQlyZXR1cm47CkBAIC0yMjU2LDcgKzIyNTYsNyBAQAogCQlpZiAobHAtPm1vZGUgIT0gMSkJLyogbm9uIGJ1c21hc3RlciAqLwogCQkJaHAxMDBfcngoZGV2KTsKIAkJZWxzZSBpZiAoISh2YWwgJiBIUDEwMF9SWF9QRExfRklMTF9DT01QTCkpIHsKLQkJCS8qIFNob3VsZG50IGhhcHBlbiAtIG1heWJlIHdlIG1pc3NlZCBhIFJYX1BETF9GSUxMIEludGVycnVwdD8gICovCisJCQkvKiBTaG91bGRuJ3QgaGFwcGVuIC0gbWF5YmUgd2UgbWlzc2VkIGEgUlhfUERMX0ZJTEwgSW50ZXJydXB0PyAgKi8KIAkJCWhwMTAwX3J4X2JtKGRldik7CiAJCX0KIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ocDEwMC5oIGIvZHJpdmVycy9uZXQvaHAxMDAuaAppbmRleCBlNmNhMTI4Li5iNjBlOTZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ocDEwMC5oCisrKyBiL2RyaXZlcnMvbmV0L2hwMTAwLmgKQEAgLTEwOSw3ICsxMDksNyBAQAogI2RlZmluZSBIUDEwMF9SRUdfTUFDX0NGR18yCTB4MGQJLyogUlc6ICg4KSBNaXNjIE1BQyBmdW5jdGlvbnMgICAgICAgICovCiAjZGVmaW5lIEhQMTAwX1JFR19NQUNfQ0ZHXzMgICAgIDB4MGUJLyogUlc6ICg4KSBNaXNjIE1BQyBmdW5jdGlvbnMgKi8KICNkZWZpbmUgSFAxMDBfUkVHX01BQ19DRkdfNCAgICAgMHgwZgkvKiBSOiAgKDgpIE1pc2MgTUFDIHN0YXRlcyAqLwotI2RlZmluZSBIUDEwMF9SRUdfRFJPUFBFRAkweDEwCS8qIFI6ICAoMTYpLDExOjAgUGt0cyBjYW50IGZpdCBpbiBtZW0gKi8KKyNkZWZpbmUgSFAxMDBfUkVHX0RST1BQRUQJMHgxMAkvKiBSOiAgKDE2KSwxMTowIFBrdHMgY2FuJ3QgZml0IGluIG1lbSAqLwogI2RlZmluZSBIUDEwMF9SRUdfQ1JDCQkweDEyCS8qIFI6ICAoOCkgUGt0cyB3aXRoIENSQyAgICAgICAgICAgICAqLwogI2RlZmluZSBIUDEwMF9SRUdfQUJPUlQJCTB4MTMJLyogUjogICg4KSBBYm9ydGVkIFR4IHBrdHMgICAgICAgICAgICovCiAjZGVmaW5lIEhQMTAwX1JFR19UUkFJTl9SRVFVRVNUIDB4MTQJLyogUlc6ICgxNikgRW5kbm9kZSBNQUMgcmVnaXN0ZXIuICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pYm1fbmV3ZW1hYy90YWguYyBiL2RyaXZlcnMvbmV0L2libV9uZXdlbWFjL3RhaC5jCmluZGV4IDhlYWQ2YTkuLjVmNTFiZjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2libV9uZXdlbWFjL3RhaC5jCisrKyBiL2RyaXZlcnMvbmV0L2libV9uZXdlbWFjL3RhaC5jCkBAIC02MCw3ICs2MCw3IEBACiAJCXByaW50ayhLRVJOX0VSUiAiJXM6IHJlc2V0IHRpbWVvdXRcbiIsCiAJCQlvZmRldi0+ZGV2Lm9mX25vZGUtPmZ1bGxfbmFtZSk7CiAKLQkvKiAxMEtCIFRBSCBUWCBGSUZPIGFjY29tb2RhdGVzIHRoZSBtYXggTVRVIG9mIDkwMDAgKi8KKwkvKiAxMEtCIFRBSCBUWCBGSUZPIGFjY29tbW9kYXRlcyB0aGUgbWF4IE1UVSBvZiA5MDAwICovCiAJb3V0X2JlMzIoJnAtPm1yLAogCQkgVEFIX01SX0NWUiB8IFRBSF9NUl9TVF83NjggfCBUQUhfTVJfVEZTXzEwS0IgfCBUQUhfTVJfRFRGUCB8CiAJCSBUQUhfTVJfRElHKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2libWxhbmEuYyBiL2RyaXZlcnMvbmV0L2libWxhbmEuYwppbmRleCA5NGQ5OTY5Li44ZmY2OGFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pYm1sYW5hLmMKKysrIGIvZHJpdmVycy9uZXQvaWJtbGFuYS5jCkBAIC01Myw3ICs1Myw3IEBACiAJc3RpbGwgd29yayB3aXRoIDIuMC54Li4uLgogICBKYW4gMjh0aCwgMjAwMAogCWluIExpbnV4IDIuMi4xMywgdGhlIHZlcnNpb24uaCBmaWxlIG15c3RlcmlvdXNseSBkaWRuJ3QgZ2V0Ci0JaW5jbHVkZWQuICBBZGRlZCBhIHdvcmthcm91bmQgZm9yIHRoaXMuICBGdXRoZXJtb3JlLCBpdCBub3cKKwlpbmNsdWRlZC4gIEFkZGVkIGEgd29ya2Fyb3VuZCBmb3IgdGhpcy4gIEZ1cnRoZXJtb3JlLCBpdCBub3cKIAlub3Qgb25seSBjb21waWxlcyBhcyBhIG1vZHVsZXMgOy0pCiAgIEphbiAzMHRoLCAyMDAwCiAJbmV3ZXIga2VybmVscyBhdXRvbWF0aWNhbGx5IHByb2JlIG1vcmUgdGhhbiBvbmUgYm9hcmQsIHNvIHRoZQpAQCAtNDgxLDcgKzQ4MSw3IEBACiAJaWYgKChkZXYtPmZsYWdzICYgSUZGX0FMTE1VTFRJKSB8fCBuZXRkZXZfbWNfY291bnQoZGV2KSA+IGNhbWNudCkKIAkJcmNydmFsIHw9IFJDUkVHX0FNQzsKIAotCS8qIHByb21pc2NvdXMgbW9kZSA/ICovCisJLyogcHJvbWlzY3VvdXMgbW9kZSA/ICovCiAKIAlpZiAoZGV2LT5mbGFncyAmIElGRl9QUk9NSVNDKQogCQlyY3J2YWwgfD0gUkNSRUdfUFJPOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaWJtbGFuYS5oIGIvZHJpdmVycy9uZXQvaWJtbGFuYS5oCmluZGV4IGFhM2RkYmQuLmFjY2Q1ZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2libWxhbmEuaAorKysgYi9kcml2ZXJzL25ldC9pYm1sYW5hLmgKQEAgLTkwLDcgKzkwLDcgQEAKICNkZWZpbmUgUkNSRUdfRVJSICAgICAgICAweDgwMDAJLyogYWNjZXB0IGRhbWFnZWQgYW5kIGNvbGxpZGVkIHBrdHMgKi8KICNkZWZpbmUgUkNSRUdfUk5UICAgICAgICAweDQwMDAJLyogYWNjZXB0IHBhY2tldHMgdGhhdCBhcmUgPCA2NCAgICAgKi8KICNkZWZpbmUgUkNSRUdfQlJEICAgICAgICAweDIwMDAJLyogYWNjZXB0IGJyb2FkY2FzdHMgICAgICAgICAgICAgICAgKi8KLSNkZWZpbmUgUkNSRUdfUFJPICAgICAgICAweDEwMDAJLyogcHJvbWlzY291cyBtb2RlICAgICAgICAgICAgICAgICAgKi8KKyNkZWZpbmUgUkNSRUdfUFJPICAgICAgICAweDEwMDAJLyogcHJvbWlzY3VvdXMgbW9kZSAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIFJDUkVHX0FNQyAgICAgICAgMHgwODAwCS8qIGFjY2VwdCBhbGwgbXVsdGljYXN0cyAgICAgICAgICAgICovCiAjZGVmaW5lIFJDUkVHX0xCX05PTkUgICAgMHgwMDAwCS8qIG5vIGxvb3BiYWNrICAgICAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIFJDUkVHX0xCX01BQyAgICAgMHgwMjAwCS8qIE1BQyBsb29wYmFjayAgICAgICAgICAgICAgICAgICAgICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pZ2IvZTEwMDBfbWFjLmMgYi9kcml2ZXJzL25ldC9pZ2IvZTEwMDBfbWFjLmMKaW5kZXggOTBjNWUwMS4uY2U4MjU1ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaWdiL2UxMDAwX21hYy5jCisrKyBiL2RyaXZlcnMvbmV0L2lnYi9lMTAwMF9tYWMuYwpAQCAtMTgxLDcgKzE4MSw3IEBACiAgKiAgYWRkcmVzcyBhbmQgbXVzdCBvdmVycmlkZSB0aGUgYWN0dWFsIHBlcm1hbmVudCBNQUMgYWRkcmVzcy4gIElmIGFuCiAgKiAgYWx0ZXJuYXRlIE1BQyBhZGRyZXNzIGlzIGZvcHVuZCBpdCBpcyBzYXZlZCBpbiB0aGUgaHcgc3RydWN0IGFuZAogICogIHByZ3JhbW1lZCBpbnRvIFJBUjAgYW5kIHRoZSBjdW50aW9uIHJldHVybnMgc3VjY2Vzcywgb3RoZXJ3aXNlIHRoZQotICogIGZ1Y250aW9uIHJldHVybnMgYW4gZXJyb3IuCisgKiAgZnVuY3Rpb24gcmV0dXJucyBhbiBlcnJvci4KICAqKi8KIHMzMiBpZ2JfY2hlY2tfYWx0X21hY19hZGRyKHN0cnVjdCBlMTAwMF9odyAqaHcpCiB7CkBAIC05ODIsNyArOTgyLDcgQEAKIH0KIAogLyoqCi0gKiAgaWdiX2dldF9zcGVlZF9hbmRfZHVwbGV4X2NvcHBlciAtIFJldHJlaXZlIGN1cnJlbnQgc3BlZWQvZHVwbGV4CisgKiAgaWdiX2dldF9zcGVlZF9hbmRfZHVwbGV4X2NvcHBlciAtIFJldHJpZXZlIGN1cnJlbnQgc3BlZWQvZHVwbGV4CiAgKiAgQGh3OiBwb2ludGVyIHRvIHRoZSBIVyBzdHJ1Y3R1cmUKICAqICBAc3BlZWQ6IHN0b3JlcyB0aGUgY3VycmVudCBzcGVlZAogICogIEBkdXBsZXg6IHN0b3JlcyB0aGUgY3VycmVudCBkdXBsZXgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lnYi9lMTAwMF9waHkuYyBiL2RyaXZlcnMvbmV0L2lnYi9lMTAwMF9waHkuYwppbmRleCA2Njk0YmYzLi5kNjM5NzA2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pZ2IvZTEwMDBfcGh5LmMKKysrIGIvZHJpdmVycy9uZXQvaWdiL2UxMDAwX3BoeS5jCkBAIC0xNDIxLDcgKzE0MjEsNyBAQAogfQogCiAvKioKLSAqICBpZ2JfY2hlY2tfZG93bnNoaWZ0IC0gQ2hlY2tzIHdoZXRoZXIgYSBkb3duc2hpZnQgaW4gc3BlZWQgb2NjdXJlZAorICogIGlnYl9jaGVja19kb3duc2hpZnQgLSBDaGVja3Mgd2hldGhlciBhIGRvd25zaGlmdCBpbiBzcGVlZCBvY2N1cnJlZAogICogIEBodzogcG9pbnRlciB0byB0aGUgSFcgc3RydWN0dXJlCiAgKgogICogIFN1Y2Nlc3MgcmV0dXJucyAwLCBGYWlsdXJlIHJldHVybnMgMQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaWdiL2lnYl9tYWluLmMgYi9kcml2ZXJzL25ldC9pZ2IvaWdiX21haW4uYwppbmRleCAzZDg1MGFmLi4wZGZkMWI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pZ2IvaWdiX21haW4uYworKysgYi9kcml2ZXJzL25ldC9pZ2IvaWdiX21haW4uYwpAQCAtMjAwLDcgKzIwMCw3IEBACiAJLnByb2JlICAgID0gaWdiX3Byb2JlLAogCS5yZW1vdmUgICA9IF9fZGV2ZXhpdF9wKGlnYl9yZW1vdmUpLAogI2lmZGVmIENPTkZJR19QTQotCS8qIFBvd2VyIE1hbmFnbWVudCBIb29rcyAqLworCS8qIFBvd2VyIE1hbmFnZW1lbnQgSG9va3MgKi8KIAkuc3VzcGVuZCAgPSBpZ2Jfc3VzcGVuZCwKIAkucmVzdW1lICAgPSBpZ2JfcmVzdW1lLAogI2VuZGlmCkBAIC0yMjkyLDcgKzIyOTIsNyBAQAogCQkvKioKIAkJICogU2NhbGUgdGhlIE5JQyBjbG9jayBjeWNsZSBieSBhIGxhcmdlIGZhY3RvciBzbyB0aGF0CiAJCSAqIHJlbGF0aXZlbHkgc21hbGwgY2xvY2sgY29ycmVjdGlvbnMgY2FuIGJlIGFkZGVkIG9yCi0JCSAqIHN1YnN0cmFjdGVkIGF0IGVhY2ggY2xvY2sgdGljay4gVGhlIGRyYXdiYWNrcyBvZiBhIGxhcmdlCisJCSAqIHN1YnRyYWN0ZWQgYXQgZWFjaCBjbG9jayB0aWNrLiBUaGUgZHJhd2JhY2tzIG9mIGEgbGFyZ2UKIAkJICogZmFjdG9yIGFyZSBhKSB0aGF0IHRoZSBjbG9jayByZWdpc3RlciBvdmVyZmxvd3MgbW9yZSBxdWlja2x5CiAJCSAqIChub3Qgc3VjaCBhIGJpZyBkZWFsKSBhbmQgYikgdGhhdCB0aGUgaW5jcmVtZW50IHBlciB0aWNrIGhhcwogCQkgKiB0byBmaXQgaW50byAyNCBiaXRzLiAgQXMgYSByZXN1bHQgd2UgbmVlZCB0byB1c2UgYSBzaGlmdCBvZgpAQCAtMzQwOSw3ICszNDA5LDcgQEAKIAkJfSBlbHNlIHsKIAkJCS8qCiAJCQkgKiBXcml0ZSBhZGRyZXNzZXMgdG8gdGhlIE1UQSwgaWYgdGhlIGF0dGVtcHQgZmFpbHMKLQkJCSAqIHRoZW4gd2Ugc2hvdWxkIGp1c3QgdHVybiBvbiBwcm9taXNjb3VzIG1vZGUgc28KKwkJCSAqIHRoZW4gd2Ugc2hvdWxkIGp1c3QgdHVybiBvbiBwcm9taXNjdW91cyBtb2RlIHNvCiAJCQkgKiB0aGF0IHdlIGNhbiBhdCBsZWFzdCByZWNlaXZlIG11bHRpY2FzdCB0cmFmZmljCiAJCQkgKi8KIAkJCWNvdW50ID0gaWdiX3dyaXRlX21jX2FkZHJfbGlzdChuZXRkZXYpOwpAQCAtMzQyMyw3ICszNDIzLDcgQEAKIAkJLyoKIAkJICogV3JpdGUgYWRkcmVzc2VzIHRvIGF2YWlsYWJsZSBSQVIgcmVnaXN0ZXJzLCBpZiB0aGVyZSBpcyBub3QKIAkJICogc3VmZmljaWVudCBzcGFjZSB0byBzdG9yZSBhbGwgdGhlIGFkZHJlc3NlcyB0aGVuIGVuYWJsZQotCQkgKiB1bmljYXN0IHByb21pc2NvdXMgbW9kZQorCQkgKiB1bmljYXN0IHByb21pc2N1b3VzIG1vZGUKIAkJICovCiAJCWNvdW50ID0gaWdiX3dyaXRlX3VjX2FkZHJfbGlzdChuZXRkZXYpOwogCQlpZiAoY291bnQgPCAwKSB7CkBAIC00MzE3LDcgKzQzMTcsNyBAQAogCiAJLyoKIAkgKiBjb3VudCByZWZsZWN0cyBkZXNjcmlwdG9ycyBtYXBwZWQsIGlmIDAgb3IgbGVzcyB0aGVuIG1hcHBpbmcgZXJyb3IKLQkgKiBoYXMgb2NjdXJlZCBhbmQgd2UgbmVlZCB0byByZXdpbmQgdGhlIGRlc2NyaXB0b3IgcXVldWUKKwkgKiBoYXMgb2NjdXJyZWQgYW5kIHdlIG5lZWQgdG8gcmV3aW5kIHRoZSBkZXNjcmlwdG9yIHF1ZXVlCiAJICovCiAJY291bnQgPSBpZ2JfdHhfbWFwX2Fkdih0eF9yaW5nLCBza2IsIGZpcnN0KTsKIAlpZiAoIWNvdW50KSB7CkBAIC01MzUyLDggKzUzNTIsOCBAQAogICogIFRoZSB1bmljYXN0IHRhYmxlIGFkZHJlc3MgaXMgYSByZWdpc3RlciBhcnJheSBvZiAzMi1iaXQgcmVnaXN0ZXJzLgogICogIFRoZSB0YWJsZSBpcyBtZWFudCB0byBiZSB1c2VkIGluIGEgd2F5IHNpbWlsYXIgdG8gaG93IHRoZSBNVEEgaXMgdXNlZAogICogIGhvd2V2ZXIgZHVlIHRvIGNlcnRhaW4gbGltaXRhdGlvbnMgaW4gdGhlIGhhcmR3YXJlIGl0IGlzIG5lY2Vzc2FyeSB0bwotICogIHNldCBhbGwgdGhlIGhhc2ggYml0cyB0byAxIGFuZCB1c2UgdGhlIFZNT0xSIFJPUEUgYml0IGFzIGEgcHJvbWlzY291cwotICogIGVuYWJsZSBiaXQgdG8gYWxsb3cgdmxhbiB0YWcgc3RyaXBwaW5nIHdoZW4gcHJvbWlzY291cyBtb2RlIGlzIGVuYWJsZWQKKyAqICBzZXQgYWxsIHRoZSBoYXNoIGJpdHMgdG8gMSBhbmQgdXNlIHRoZSBWTU9MUiBST1BFIGJpdCBhcyBhIHByb21pc2N1b3VzCisgKiAgZW5hYmxlIGJpdCB0byBhbGxvdyB2bGFuIHRhZyBzdHJpcHBpbmcgd2hlbiBwcm9taXNjdW91cyBtb2RlIGlzIGVuYWJsZWQKICAqKi8KIHN0YXRpYyB2b2lkIGlnYl9zZXRfdXRhKHN0cnVjdCBpZ2JfYWRhcHRlciAqYWRhcHRlcikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lnYnZmL25ldGRldi5jIGIvZHJpdmVycy9uZXQvaWdidmYvbmV0ZGV2LmMKaW5kZXggNmNjYzMyZi4uMWQwNGNhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaWdidmYvbmV0ZGV2LmMKKysrIGIvZHJpdmVycy9uZXQvaWdidmYvbmV0ZGV2LmMKQEAgLTIyMjcsNyArMjIyNyw3IEBACiAKIAkvKgogCSAqIGNvdW50IHJlZmxlY3RzIGRlc2NyaXB0b3JzIG1hcHBlZCwgaWYgMCB0aGVuIG1hcHBpbmcgZXJyb3IKLQkgKiBoYXMgb2NjdXJlZCBhbmQgd2UgbmVlZCB0byByZXdpbmQgdGhlIGRlc2NyaXB0b3IgcXVldWUKKwkgKiBoYXMgb2NjdXJyZWQgYW5kIHdlIG5lZWQgdG8gcmV3aW5kIHRoZSBkZXNjcmlwdG9yIHF1ZXVlCiAJICovCiAJY291bnQgPSBpZ2J2Zl90eF9tYXBfYWR2KGFkYXB0ZXIsIHR4X3JpbmcsIHNrYiwgZmlyc3QpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pcGcuYyBiL2RyaXZlcnMvbmV0L2lwZy5jCmluZGV4IGE1YjBmMGUuLjU4Y2QzMjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2lwZy5jCisrKyBiL2RyaXZlcnMvbmV0L2lwZy5jCkBAIC00ODYsMTQgKzQ4NiwxNCBAQAogCXBoeWN0cmwgPSBpcGdfcjgoUEhZX0NUUkwpOwogCW1hY19jdHJsX3ZhbCA9IGlwZ19yMzIoTUFDX0NUUkwpOwogCi0JLyogU2V0IGZsYWdzIGZvciB1c2UgaW4gcmVzb2x2aW5nIGF1dG8tbmVnb3RhdGlvbiwgYXNzdW1pbmcKKwkvKiBTZXQgZmxhZ3MgZm9yIHVzZSBpbiByZXNvbHZpbmcgYXV0by1uZWdvdGlhdGlvbiwgYXNzdW1pbmcKIAkgKiBub24tMTAwME1icHMsIGhhbGYgZHVwbGV4LCBubyBmbG93IGNvbnRyb2wuCiAJICovCiAJZnVsbGR1cGxleCA9IDA7CiAJdHhmbG93Y29udHJvbCA9IDA7CiAJcnhmbG93Y29udHJvbCA9IDA7CiAKLQkvKiBUbyBhY2NvbW9kYXRlIGEgcHJvYmxlbSBpbiAxME1icHMgb3BlcmF0aW9uLAorCS8qIFRvIGFjY29tbW9kYXRlIGEgcHJvYmxlbSBpbiAxME1icHMgb3BlcmF0aW9uLAogCSAqIHNldCBhIGdsb2JhbCBmbGFnIGlmIFBIWSBydW5uaW5nIGluIDEwTWJwcyBtb2RlLgogCSAqLwogCXNwLT50ZW5tYnBzbW9kZSA9IDA7CkBAIC04NDYsNyArODQ2LDcgQEAKIH0KIAogLyoKLSAqIEZyZWUgYWxsIHRyYW5zbWl0IGJ1ZmZlcnMgd2hpY2ggaGF2ZSBhbHJlYWR5IGJlZW4gdHJhbnNmZXJlZAorICogRnJlZSBhbGwgdHJhbnNtaXQgYnVmZmVycyB3aGljaCBoYXZlIGFscmVhZHkgYmVlbiB0cmFuc2ZlcnJlZAogICogdmlhIERNQSB0byB0aGUgSVBHLgogICovCiBzdGF0aWMgdm9pZCBpcGdfbmljX3R4ZnJlZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQpAQCAtOTIwLDcgKzkyMCw3IEBACiAKIC8qCiAgKiBGb3IgVHhDb21wbGV0ZSBpbnRlcnJ1cHRzLCBmcmVlIGFsbCB0cmFuc21pdAotICogYnVmZmVycyB3aGljaCBoYXZlIGFscmVhZHkgYmVlbiB0cmFuc2ZlcmVkIHZpYSBETUEKKyAqIGJ1ZmZlcnMgd2hpY2ggaGF2ZSBhbHJlYWR5IGJlZW4gdHJhbnNmZXJyZWQgdmlhIERNQQogICogdG8gdGhlIElQRy4KICAqLwogc3RhdGljIHZvaWQgaXBnX25pY190eGNsZWFudXAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKQEAgLTExNDEsMTMgKzExNDEsMTMgQEAKIAogCQkvKiBJbmNyZW1lbnQgZGV0YWlsZWQgcmVjZWl2ZSBlcnJvciBzdGF0aXN0aWNzLiAqLwogCQlpZiAobGU2NF90b19jcHUocnhmZC0+cmZzKSAmIElQR19SRlNfUlhGSUZPT1ZFUlJVTikgewotCQkJSVBHX0RFQlVHX01TRygiUlggRklGTyBvdmVycnVuIG9jY3VyZWQuXG4iKTsKKwkJCUlQR19ERUJVR19NU0coIlJYIEZJRk8gb3ZlcnJ1biBvY2N1cnJlZC5cbiIpOwogCiAJCQlzcC0+c3RhdHMucnhfZmlmb19lcnJvcnMrKzsKIAkJfQogCiAJCWlmIChsZTY0X3RvX2NwdShyeGZkLT5yZnMpICYgSVBHX1JGU19SWFJVTlRGUkFNRSkgewotCQkJSVBHX0RFQlVHX01TRygiUlggcnVudCBvY2N1cmVkLlxuIik7CisJCQlJUEdfREVCVUdfTVNHKCJSWCBydW50IG9jY3VycmVkLlxuIik7CiAJCQlzcC0+c3RhdHMucnhfbGVuZ3RoX2Vycm9ycysrOwogCQl9CiAKQEAgLTExNTYsNyArMTE1Niw3IEBACiAJCSAqLwogCiAJCWlmIChsZTY0X3RvX2NwdShyeGZkLT5yZnMpICYgSVBHX1JGU19SWEFMSUdOTUVOVEVSUk9SKSB7Ci0JCQlJUEdfREVCVUdfTVNHKCJSWCBhbGlnbm1lbnQgZXJyb3Igb2NjdXJlZC5cbiIpOworCQkJSVBHX0RFQlVHX01TRygiUlggYWxpZ25tZW50IGVycm9yIG9jY3VycmVkLlxuIik7CiAJCQlzcC0+c3RhdHMucnhfZnJhbWVfZXJyb3JzKys7CiAJCX0KIApAQCAtMTQyMSwxMiArMTQyMSwxMiBAQAogCiAJCQkvKiBJbmNyZW1lbnQgZGV0YWlsZWQgcmVjZWl2ZSBlcnJvciBzdGF0aXN0aWNzLiAqLwogCQkJaWYgKGxlNjRfdG9fY3B1KHJ4ZmQtPnJmcykgJiBJUEdfUkZTX1JYRklGT09WRVJSVU4pIHsKLQkJCQlJUEdfREVCVUdfTVNHKCJSWCBGSUZPIG92ZXJydW4gb2NjdXJlZC5cbiIpOworCQkJCUlQR19ERUJVR19NU0coIlJYIEZJRk8gb3ZlcnJ1biBvY2N1cnJlZC5cbiIpOwogCQkJCXNwLT5zdGF0cy5yeF9maWZvX2Vycm9ycysrOwogCQkJfQogCiAJCQlpZiAobGU2NF90b19jcHUocnhmZC0+cmZzKSAmIElQR19SRlNfUlhSVU5URlJBTUUpIHsKLQkJCQlJUEdfREVCVUdfTVNHKCJSWCBydW50IG9jY3VyZWQuXG4iKTsKKwkJCQlJUEdfREVCVUdfTVNHKCJSWCBydW50IG9jY3VycmVkLlxuIik7CiAJCQkJc3AtPnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKIAkJCX0KIApAQCAtMTQzNiw3ICsxNDM2LDcgQEAKIAkJCSAqLwogCiAJCQlpZiAobGU2NF90b19jcHUocnhmZC0+cmZzKSAmIElQR19SRlNfUlhBTElHTk1FTlRFUlJPUikgewotCQkJCUlQR19ERUJVR19NU0coIlJYIGFsaWdubWVudCBlcnJvciBvY2N1cmVkLlxuIik7CisJCQkJSVBHX0RFQlVHX01TRygiUlggYWxpZ25tZW50IGVycm9yIG9jY3VycmVkLlxuIik7CiAJCQkJc3AtPnN0YXRzLnJ4X2ZyYW1lX2Vycm9ycysrOwogCQkJfQogCkBAIC0xNDYwLDcgKzE0NjAsNyBAQAogCQkJfQogCQl9IGVsc2UgewogCi0JCQkvKiBBZGp1c3QgdGhlIG5ldyBidWZmZXIgbGVuZ3RoIHRvIGFjY29tb2RhdGUgdGhlIHNpemUKKwkJCS8qIEFkanVzdCB0aGUgbmV3IGJ1ZmZlciBsZW5ndGggdG8gYWNjb21tb2RhdGUgdGhlIHNpemUKIAkJCSAqIG9mIHRoZSByZWNlaXZlZCBmcmFtZS4KIAkJCSAqLwogCQkJc2tiX3B1dChza2IsIGZyYW1lbGVuKTsKQEAgLTE0ODgsNyArMTQ4OCw3IEBACiAJfQogCiAJLyoKLQkgKiBJZiB0aGVyZSBhcmUgbW9yZSBSRkRzIHRvIHByb2NlcyBhbmQgdGhlIGFsbG9jYXRlZCBhbW91bnQgb2YgUkZECisJICogSWYgdGhlcmUgYXJlIG1vcmUgUkZEcyB0byBwcm9jZXNzIGFuZCB0aGUgYWxsb2NhdGVkIGFtb3VudCBvZiBSRkQKIAkgKiBwcm9jZXNzaW5nIHRpbWUgaGFzIGV4cGlyZWQsIGFzc2VydCBJbnRlcnJ1cHQgUmVxdWVzdGVkIHRvIG1ha2UKIAkgKiBzdXJlIHdlIGNvbWUgYmFjayB0byBwcm9jZXNzIHRoZSByZW1haW5pbmcgUkZEcy4KIAkgKi8KQEAgLTE4ODYsNyArMTg4Niw3IEBACiAJLyogUmVxdWVzdCBUeENvbXBsZXRlIGludGVycnVwdHMgYXQgYW4gaW50ZXJ2YWwgZGVmaW5lZAogCSAqIGJ5IHRoZSBjb25zdGFudCBJUEdfRlJBTUVTQkVUV0VFTlRYQ09NUExFVEVTLgogCSAqIFJlcXVlc3QgVHhDb21wbGV0ZSBpbnRlcnJ1cHQgZm9yIGV2ZXJ5IGZyYW1lCi0JICogaWYgaW4gMTBNYnBzIG1vZGUgdG8gYWNjb21vZGF0ZSBwcm9ibGVtIHdpdGggMTBNYnBzCisJICogaWYgaW4gMTBNYnBzIG1vZGUgdG8gYWNjb21tb2RhdGUgcHJvYmxlbSB3aXRoIDEwTWJwcwogCSAqIHByb2Nlc3NpbmcuCiAJICovCiAJaWYgKHNwLT50ZW5tYnBzbW9kZSkKQEAgLTIwOTgsNyArMjA5OCw3IEBACiAJc3RydWN0IGlwZ19uaWNfcHJpdmF0ZSAqc3AgPSBuZXRkZXZfcHJpdihkZXYpOwogCWludCBlcnI7CiAKLQkvKiBGdW5jdGlvbiB0byBhY2NvbW9kYXRlIGNoYW5nZXMgdG8gTWF4aW11bSBUcmFuc2ZlciBVbml0CisJLyogRnVuY3Rpb24gdG8gYWNjb21tb2RhdGUgY2hhbmdlcyB0byBNYXhpbXVtIFRyYW5zZmVyIFVuaXQKIAkgKiAob3IgTVRVKSBvZiBJUEcgTklDLiBDYW5ub3QgdXNlIGRlZmF1bHQgZnVuY3Rpb24gc2luY2UKIAkgKiB0aGUgZGVmYXVsdCB3aWxsIG5vdCBhbGxvdyBmb3IgTVRVID4gMTUwMCBieXRlcy4KIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lyZGEvYWxpLWlyY2MuYyBiL2RyaXZlcnMvbmV0L2lyZGEvYWxpLWlyY2MuYwppbmRleCA5MjYzMWViLi44NzIxODNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL2FsaS1pcmNjLmMKKysrIGIvZHJpdmVycy9uZXQvaXJkYS9hbGktaXJjYy5jCkBAIC03Niw3ICs3Niw3IEBACiBzdGF0aWMgaW50ICBhbGlfaXJjY19pbml0XzQzKGFsaV9jaGlwX3QgKmNoaXAsIGNoaXBpb190ICppbmZvKTsKIHN0YXRpYyBpbnQgIGFsaV9pcmNjX2luaXRfNTMoYWxpX2NoaXBfdCAqY2hpcCwgY2hpcGlvX3QgKmluZm8pOwogCi0vKiBUaGVzZSBhcmUgdGhlIGN1cnJlbnRseSBrbm93biBBTGkgc291cnRoLWJyaWRnZSBjaGlwc2V0cywgdGhlIG9ubHkgb25lIGRpZmZlcmVuY2UKKy8qIFRoZXNlIGFyZSB0aGUgY3VycmVudGx5IGtub3duIEFMaSBzb3V0aC1icmlkZ2UgY2hpcHNldHMsIHRoZSBvbmx5IG9uZSBkaWZmZXJlbmNlCiAgKiBpcyB0aGF0IE0xNTQzQyBkb2Vzbid0IHN1cHBvcnQgSFAgSERTTC0zNjAwCiAgKi8KIHN0YXRpYyBhbGlfY2hpcF90IGNoaXBzW10gPQpAQCAtMTEwOCw3ICsxMTA4LDcgQEAKIAlvdXRiKGxjciwJCSAgaW9iYXNlK1VBUlRfTENSKTsgLyogU2V0IDhOMQkqLwogCW91dGIoZmNyLAkJICBpb2Jhc2UrVUFSVF9GQ1IpOyAvKiBFbmFibGUgRklGTydzICovCiAKLQkvKiB3aXRob3V0IHRoaXMsIHRoZSBjb25lY3Rpb24gd2lsbCBiZSBicm9rZW4gYWZ0ZXIgY29tZSBiYWNrIGZyb20gRklSIHNwZWVkLAorCS8qIHdpdGhvdXQgdGhpcywgdGhlIGNvbm5lY3Rpb24gd2lsbCBiZSBicm9rZW4gYWZ0ZXIgY29tZSBiYWNrIGZyb20gRklSIHNwZWVkLAogCSAgIGJ1dCB3aXRoIHRoaXMsIHRoZSBTSVIgY29ubmVjdGlvbiBpcyBoYXJkZXIgdG8gZXN0YWJsaXNoZWQgKi8KIAlvdXRiKChVQVJUX01DUl9EVFIgfCBVQVJUX01DUl9SVFMgfCBVQVJUX01DUl9PVVQyKSwgaW9iYXNlK1VBUlRfTUNSKTsKIAkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lyZGEvZG9uYXVib2UuYyBiL2RyaXZlcnMvbmV0L2lyZGEvZG9uYXVib2UuYwppbmRleCBmODFkOTQ0Li4xNzRjYWZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL2RvbmF1Ym9lLmMKKysrIGIvZHJpdmVycy9uZXQvaXJkYS9kb25hdWJvZS5jCkBAIC01Niw3ICs1Niw3IEBACiAvKiBkb19wcm9iZSBtb2R1bGUgcGFyYW1ldGVyIEVuYWJsZSB0aGlzIGNvZGUgKi8KIC8qIFByb2JlIGNvZGUgaXMgdmVyeSB1c2VmdWwgZm9yIHVuZGVyc3RhbmRpbmcgaG93IHRoZSBoYXJkd2FyZSB3b3JrcyAqLwogLyogVXNlIGl0IHdpdGggdmFyaW91cyBjb21iaW5hdGlvbnMgb2YgVFRfTEVOLCBSWF9MRU4gKi8KLS8qIFN0cm9uZ2x5IHJlY29tZW5kZWQsIGRpc2FibGUgaWYgdGhlIHByb2JlIGZhaWxzIG9uIHlvdXIgbWFjaGluZSAqLworLyogU3Ryb25nbHkgcmVjb21tZW5kZWQsIGRpc2FibGUgaWYgdGhlIHByb2JlIGZhaWxzIG9uIHlvdXIgbWFjaGluZSAqLwogLyogYW5kIHNlbmQgbWUgPGphbWVzQGZpc2hzb3VwLmRocy5vcmc+IHRoZSBvdXRwdXQgb2YgZG1lc2cgKi8KICNkZWZpbmUgVVNFX1BST0JFIDEKICN1bmRlZiAgVVNFX1BST0JFCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pcmRhL2RvbmF1Ym9lLmggYi9kcml2ZXJzL25ldC9pcmRhL2RvbmF1Ym9lLmgKaW5kZXggNzdmY2Y0NC4uZDkyZDU0ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXJkYS9kb25hdWJvZS5oCisrKyBiL2RyaXZlcnMvbmV0L2lyZGEvZG9uYXVib2UuaApAQCAtNTEsNyArNTEsNyBAQAogCiAvKiBUaGUgZG9jdW1lbnRhdGlvbiBmb3IgdGhpcyBjaGlwIGlzIGFsbGVnZWRseSByZWxlYXNlZCAgICAgICAgICovCiAvKiBIb3dldmVyIEkgaGF2ZSBub3Qgc2VlbiBpdCwgbm90IGhhdmUgSSBtYW5hZ2VkIHRvIGNvbnRhY3QgICAgICovCi0vKiBhbnlvbmUgd2hvIGhhcy4gSE9XRVZFUiB0aGUgY2hpcCBiZWFycyBhIHN0cmlraW5nIHJlc2VtYmxlbmNlICovCisvKiBhbnlvbmUgd2hvIGhhcy4gSE9XRVZFUiB0aGUgY2hpcCBiZWFycyBhIHN0cmlraW5nIHJlc2VtYmxhbmNlICovCiAvKiB0byB0aGUgSXJEQSBjb250cm9sbGVyIGluIHRoZSBUb3NoaWJhIFJJU0MgVE1QUjM5MjIgY2hpcCAgICAgICovCiAvKiB0aGUgZG9jdW1lbnRhdGlvbiBmb3IgdGhpcyBpcyBmcmVlbHkgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICovCiAvKiBodHRwOi8vd3d3Lm1hZGluZ2xleS5vcmcvamFtZXMvcmVzb3VyY2VzL3Rvc2hvYm9lL1RNUFIzOTIyLnBkZiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXJkYS9naXJiaWwtc2lyLmMgYi9kcml2ZXJzL25ldC9pcmRhL2dpcmJpbC1zaXIuYwppbmRleCBhMzFiOGZhLi45NmNkZWNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL2dpcmJpbC1zaXIuYworKysgYi9kcml2ZXJzL25ldC9pcmRhL2dpcmJpbC1zaXIuYwpAQCAtMzgsNyArMzgsNyBAQAogLyogQ29udHJvbCByZWdpc3RlciAxICovCiAjZGVmaW5lIEdJUkJJTF9UWEVOICAgIDB4MDEgLyogRW5hYmxlIHRyYW5zbWl0dGVyICovCiAjZGVmaW5lIEdJUkJJTF9SWEVOICAgIDB4MDIgLyogRW5hYmxlIHJlY2VpdmVyICovCi0jZGVmaW5lIEdJUkJJTF9FQ0FOICAgIDB4MDQgLyogQ2FuY2VsIHNlbGYgZW1taXRlZCBkYXRhICovCisjZGVmaW5lIEdJUkJJTF9FQ0FOICAgIDB4MDQgLyogQ2FuY2VsIHNlbGYgZW1pdHRlZCBkYXRhICovCiAjZGVmaW5lIEdJUkJJTF9FQ0hPICAgIDB4MDggLyogRWNobyBjb250cm9sIGNoYXJhY3RlcnMgKi8KIAogLyogTEVEIEN1cnJlbnQgUmVnaXN0ZXIgKDB4MikgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lyZGEvaXJkYS11c2IuYyBiL2RyaXZlcnMvbmV0L2lyZGEvaXJkYS11c2IuYwppbmRleCBlNGVhNjE5Li5kOTI2N2NiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL2lyZGEtdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvaXJkYS9pcmRhLXVzYi5jCkBAIC0zNzAsNyArMzcwLDcgQEAKIAkvKiB1cmIgaXMgbm93IGF2YWlsYWJsZSAqLwogCS8vdXJiLT5zdGF0dXMgPSAwOyAtPiB0ZXN0ZWQgYWJvdmUKIAotCS8qIE5ldyBzcGVlZCBhbmQgeGJvZiBpcyBub3cgY29tbWl0ZWQgaW4gaGFyZHdhcmUgKi8KKwkvKiBOZXcgc3BlZWQgYW5kIHhib2YgaXMgbm93IGNvbW1pdHRlZCBpbiBoYXJkd2FyZSAqLwogCXNlbGYtPm5ld19zcGVlZCA9IC0xOwogCXNlbGYtPm5ld194Ym9mcyA9IC0xOwogCkBAIC02MDIsNyArNjAyLDcgQEAKIAkJCUlSREFfREVCVUcoMSwgIiVzKCksIENoYW5naW5nIHNwZWVkIG5vdy4uLlxuIiwgX19mdW5jX18pOwogCQkJaXJkYV91c2JfY2hhbmdlX3NwZWVkX3hib2ZzKHNlbGYpOwogCQl9IGVsc2UgewotCQkJLyogTmV3IHNwZWVkIGFuZCB4Ym9mIGlzIG5vdyBjb21taXRlZCBpbiBoYXJkd2FyZSAqLworCQkJLyogTmV3IHNwZWVkIGFuZCB4Ym9mIGlzIG5vdyBjb21taXR0ZWQgaW4gaGFyZHdhcmUgKi8KIAkJCXNlbGYtPm5ld19zcGVlZCA9IC0xOwogCQkJc2VsZi0+bmV3X3hib2ZzID0gLTE7CiAJCQkvKiBEb25lLCB3YWl0aW5nIGZvciBuZXh0IHBhY2tldCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXJkYS9tY3M3NzgwLmMgYi9kcml2ZXJzL25ldC9pcmRhL21jczc3ODAuYwppbmRleCBjYzgyMWRlLi5iZTUyYmZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL21jczc3ODAuYworKysgYi9kcml2ZXJzL25ldC9pcmRhL21jczc3ODAuYwpAQCAtNTg4LDcgKzU4OCw3IEBACiAKIAltY3NfZ2V0X3JlZyhtY3MsIE1DU19NT0RFX1JFRywgJnJ2YWwpOwogCi0JLyogTUlOUlhQVyB2YWx1ZXMgcmVjb21lbmRlZCBieSBNb3NDaGlwICovCisJLyogTUlOUlhQVyB2YWx1ZXMgcmVjb21tZW5kZWQgYnkgTW9zQ2hpcCAqLwogCWlmIChtY3MtPm5ld19zcGVlZCA8PSAxMTUyMDApIHsKIAkJcnZhbCAmPSB+TUNTX0ZJUjsKIApAQCAtNzk5LDcgKzc5OSw3IEBACiAJcmV0ID0gdXNiX3N1Ym1pdF91cmIodXJiLCBHRlBfQVRPTUlDKTsKIH0KIAotLyogVHJhbnNtaXQgY2FsbGJhY2sgZnVudGlvbi4gICovCisvKiBUcmFuc21pdCBjYWxsYmFjayBmdW5jdGlvbi4gICovCiBzdGF0aWMgdm9pZCBtY3Nfc2VuZF9pcnEoc3RydWN0IHVyYiAqdXJiKQogewogCXN0cnVjdCBtY3NfY2IgKm1jcyA9IHVyYi0+Y29udGV4dDsKQEAgLTgxMSw3ICs4MTEsNyBAQAogCQluZXRpZl93YWtlX3F1ZXVlKG5kZXYpOwogfQogCi0vKiBUcmFuc21pdCBjYWxsYmFjayBmdW50aW9uLiAgKi8KKy8qIFRyYW5zbWl0IGNhbGxiYWNrIGZ1bmN0aW9uLiAgKi8KIHN0YXRpYyBuZXRkZXZfdHhfdCBtY3NfaGFyZF94bWl0KHN0cnVjdCBza19idWZmICpza2IsCiAJCQkJICAgICAgIHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXJkYS9uc2MtaXJjYy5jIGIvZHJpdmVycy9uZXQvaXJkYS9uc2MtaXJjYy5jCmluZGV4IDU1OWZlODUuLjdhOTYzZDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2lyZGEvbnNjLWlyY2MuYworKysgYi9kcml2ZXJzL25ldC9pcmRhL25zYy1pcmNjLmMKQEAgLTcxNiw3ICs3MTYsNyBAQAogCWludCByZWcsIGNvbSA9IDA7CiAJaW50IHBucDsKIAotCS8qIFJlYWQgZnVudGlvbiBlbmFibGUgcmVnaXN0ZXIgKEZFUikgKi8KKwkvKiBSZWFkIGZ1bmN0aW9uIGVuYWJsZSByZWdpc3RlciAoRkVSKSAqLwogCW91dGIoQ0ZHXzMzOF9GRVIsIGNmZ19iYXNlKTsKIAlyZWcgPSBpbmIoY2ZnX2Jhc2UrMSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lyZGEvbnNjLWlyY2MuaCBiL2RyaXZlcnMvbmV0L2lyZGEvbnNjLWlyY2MuaAppbmRleCA3YmE3NzM4Li4zMmZhNTgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL25zYy1pcmNjLmgKKysrIGIvZHJpdmVycy9uZXQvaXJkYS9uc2MtaXJjYy5oCkBAIC0xMzUsNyArMTM1LDcgQEAKICNkZWZpbmUgTFNSX1RYUkRZICAgICAgIDB4MjAgLyogVHJhbnNtaXR0ZXIgcmVhZHkgKi8KICNkZWZpbmUgTFNSX1RYRU1QICAgICAgIDB4NDAgLyogVHJhbnNtaXR0ZXIgZW1wdHkgKi8KIAotI2RlZmluZSBBU0NSICAgICAgICAgICAgMHgwNyAvKiBBdXhpbGxhcnkgU3RhdHVzIGFuZCBDb250cm9sIFJlZ2lzdGVyICovCisjZGVmaW5lIEFTQ1IgICAgICAgICAgICAweDA3IC8qIEF1eGlsaWFyeSBTdGF0dXMgYW5kIENvbnRyb2wgUmVnaXN0ZXIgKi8KICNkZWZpbmUgQVNDUl9SWEZfVE9VVCAgIDB4MDEgLyogUnggRklGTyB0aW1lb3V0ICovCiAjZGVmaW5lIEFTQ1JfRkVORF9JTkYgICAweDAyIC8qIEZyYW1lIGVuZCBieXRlcyBpbiByeCBGSUZPICovCiAjZGVmaW5lIEFTQ1JfU19FT1QgICAgICAweDA0IC8qIFNldCBlbmQgb2YgdHJhbnNtaXNzaW9uICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pcmRhL3B4YWZpY3BfaXIuYyBiL2RyaXZlcnMvbmV0L2lyZGEvcHhhZmljcF9pci5jCmluZGV4IGMxOTJjMzEuLjAwMWVkMGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2lyZGEvcHhhZmljcF9pci5jCisrKyBiL2RyaXZlcnMvbmV0L2lyZGEvcHhhZmljcF9pci5jCkBAIC00MCw3ICs0MCw3IEBACiAKICNkZWZpbmUgSUNDUjBfQU1FCSgxIDw8IDcpCS8qIEFkZHJlc3MgbWF0Y2ggZW5hYmxlICovCiAjZGVmaW5lIElDQ1IwX1RJRQkoMSA8PCA2KQkvKiBUcmFuc21pdCBGSUZPIGludGVycnVwdCBlbmFibGUgKi8KLSNkZWZpbmUgSUNDUjBfUklFCSgxIDw8IDUpCS8qIFJlY2lldmUgRklGTyBpbnRlcnJ1cHQgZW5hYmxlICovCisjZGVmaW5lIElDQ1IwX1JJRQkoMSA8PCA1KQkvKiBSZWNlaXZlIEZJRk8gaW50ZXJydXB0IGVuYWJsZSAqLwogI2RlZmluZSBJQ0NSMF9SWEUJKDEgPDwgNCkJLyogUmVjZWl2ZSBlbmFibGUgKi8KICNkZWZpbmUgSUNDUjBfVFhFCSgxIDw8IDMpCS8qIFRyYW5zbWl0IGVuYWJsZSAqLwogI2RlZmluZSBJQ0NSMF9UVVMJKDEgPDwgMikJLyogVHJhbnNtaXQgRklGTyB1bmRlcnJ1biBzZWxlY3QgKi8KQEAgLTQ4Myw3ICs0ODMsNyBAQAogCX0KIAogCWlmIChpY3NyMCAmIElDU1IwX0VJRikgewotCQkvKiBBbiBlcnJvciBpbiBGSUZPIG9jY3VyZWQsIG9yIHRoZXJlIGlzIGEgZW5kIG9mIGZyYW1lICovCisJCS8qIEFuIGVycm9yIGluIEZJRk8gb2NjdXJyZWQsIG9yIHRoZXJlIGlzIGEgZW5kIG9mIGZyYW1lICovCiAJCXB4YV9pcmRhX2Zpcl9pcnFfZWlmKHNpLCBkZXYsIGljc3IwKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lyZGEvc21zYy1pcmNjMi5jIGIvZHJpdmVycy9uZXQvaXJkYS9zbXNjLWlyY2MyLmMKaW5kZXggMWMxNjc3Yy4uODgwMGUxZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXJkYS9zbXNjLWlyY2MyLmMKKysrIGIvZHJpdmVycy9uZXQvaXJkYS9zbXNjLWlyY2MyLmMKQEAgLTE1ODIsNyArMTU4Miw3IEBACiAJaW50IGlvYmFzZTsKIAlpbnQgaWlyLCBsc3I7CiAKLQkvKiBBbHJlYWR5IGxvY2tlZCBjb21taW5nIGhlcmUgaW4gc21zY19pcmNjX2ludGVycnVwdCgpICovCisJLyogQWxyZWFkeSBsb2NrZWQgY29taW5nIGhlcmUgaW4gc21zY19pcmNjX2ludGVycnVwdCgpICovCiAJLypzcGluX2xvY2soJnNlbGYtPmxvY2spOyovCiAKIAlpb2Jhc2UgPSBzZWxmLT5pby5zaXJfYmFzZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2lyZGEvdmlhLWlyY2MuYyBiL2RyaXZlcnMvbmV0L2lyZGEvdmlhLWlyY2MuYwppbmRleCAxODZjZDI4Li5mNTA0YjI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pcmRhL3ZpYS1pcmNjLmMKKysrIGIvZHJpdmVycy9uZXQvaXJkYS92aWEtaXJjYy5jCkBAIC0yOSw3ICsyOSw3IEBACiAKIDIwMDQtMDItMTY6IDxzZGFAYmRpdC5kZT4KIC0gUmVtb3ZlZCB1bm5lZWRlZCAnbGVnYWN5JyBwY2kgc3R1ZmYuCi0tIE1ha2Ugc3VyZSBTSVIgbW9kZSBpcyBzZXQgKGh3X2luaXQoKSkgYmVmb3JlIGNhbGxpbmcgbW9kZS1kZXBlbmRhbnQgc3R1ZmYuCistIE1ha2Ugc3VyZSBTSVIgbW9kZSBpcyBzZXQgKGh3X2luaXQoKSkgYmVmb3JlIGNhbGxpbmcgbW9kZS1kZXBlbmRlbnQgc3R1ZmYuCiAtIE9uIHNwZWVkIGNoYW5nZSBmcm9tIGNvcmUsIGRvbid0IHNlbmQgU0lSIGZyYW1lIHdpdGggbmV3IHNwZWVkLiAKICAgVXNlIGN1cnJlbnQgc3BlZWQgYW5kIGNoYW5nZSBzcGVlZHMgbGF0ZXIuCiAtIE1ha2UgbW9kdWxlLXBhcmFtIGRvbmdsZV9pZCBhY3R1YWxseSB3b3JrLgpAQCAtMzM0LDcgKzMzNCw3IEBACiAJc2VsZi0+aW8uZG9uZ2xlX2lkID0gZG9uZ2xlX2lkOwogCiAJLyogVGhlIG9ubHkgdmFsdWUgd2UgbXVzdCBvdmVycmlkZSBpdCB0aGUgYmF1ZHJhdGUgKi8KLQkvKiBNYXhpbXVtIHNwZWVkcyBhbmQgY2FwYWJpbGl0aWVzIGFyZSBkb25nbGUtZGVwZW5kYW50LiAqLworCS8qIE1heGltdW0gc3BlZWRzIGFuZCBjYXBhYmlsaXRpZXMgYXJlIGRvbmdsZS1kZXBlbmRlbnQuICovCiAJc3dpdGNoKCBzZWxmLT5pby5kb25nbGVfaWQgKXsKIAljYXNlIDB4MGQ6CiAJCXNlbGYtPnFvcy5iYXVkX3JhdGUuYml0cyA9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pcmRhL3Zsc2lfaXIuaCBiL2RyaXZlcnMvbmV0L2lyZGEvdmxzaV9pci5oCmluZGV4IGQ2NmZhYjguLmEwNzZlYjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2lyZGEvdmxzaV9pci5oCisrKyBiL2RyaXZlcnMvbmV0L2lyZGEvdmxzaV9pci5oCkBAIC0yMDksNyArMjA5LDcgQEAKIAlJUklOVFJfQUNURU4JPSAweDgwLAkvKiBhY3Rpdml0eSBpbnRlcnJ1cHQgZW5hYmxlICovCiAJSVJJTlRSX0FDVElWSVRZCT0gMHg0MCwJLyogYWN0aXZpdHkgbW9uaXRvciAodHJhZmZpYyBkZXRlY3RlZCkgKi8KIAlJUklOVFJfUlBLVEVOCT0gMHgyMCwJLyogcmVjZWl2ZSBwYWNrZXQgaW50ZXJydXB0IGVuYWJsZSovCi0JSVJJTlRSX1JQS1RJTlQJPSAweDEwLAkvKiByeC1wYWNrZXQgdHJhbnNmZXJlZCBmcm9tIGZpZm8gdG8gbWVtb3J5IGZpbmlzaGVkICovCisJSVJJTlRSX1JQS1RJTlQJPSAweDEwLAkvKiByeC1wYWNrZXQgdHJhbnNmZXJyZWQgZnJvbSBmaWZvIHRvIG1lbW9yeSBmaW5pc2hlZCAqLwogCUlSSU5UUl9UUEtURU4JPSAweDA4LAkvKiB0cmFuc21pdCBwYWNrZXQgaW50ZXJydXB0IGVuYWJsZSAqLwogCUlSSU5UUl9UUEtUSU5UCT0gMHgwNCwJLyogbGFzdCBiaXQgb2YgdHgtcGFja2V0K2NyYyBzaGlmdGVkIHRvIGlyLXB1bHNlciAqLwogCUlSSU5UUl9PRV9FTgk9IDB4MDIsCS8qIFVBUlQgcnggZmlmbyBvdmVycnVuIGVycm9yIGludGVycnVwdCBlbmFibGUgKi8KQEAgLTczOSw3ICs3MzksNyBAQAogLyogdGhlIHJlbWFwcGVkIGVycm9yIGZsYWdzIHdlIHVzZSBmb3IgcmV0dXJuaW5nIGZyb20gZnJhbWUKICAqIHBvc3QtcHJvY2Vzc2luZyBpbiB2bHNpX3Byb2Nlc3NfdHgvcngoKSBhZnRlciBpdCB3YXMgY29tcGxldGVkCiAgKiBieSB0aGUgaGFyZHdhcmUuIFRoZXNlIGZ1bmN0aW9ucyBlaXRoZXIgcmV0dXJuIHRoZSA+PTAgbnVtYmVyCi0gKiBvZiB0cmFuc2ZlcmVkIGJ5dGVzIGluIGNhc2Ugb2Ygc3VjY2VzcyBvciB0aGUgbmVnYXRpdmUgKC0pCisgKiBvZiB0cmFuc2ZlcnJlZCBieXRlcyBpbiBjYXNlIG9mIHN1Y2Nlc3Mgb3IgdGhlIG5lZ2F0aXZlICgtKQogICogb2YgdGhlIG9yJ2VkIGVycm9yIGZsYWdzLgogICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2RjYi5jIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZGNiLmMKaW5kZXggNDFjNTI5Zi4uNjg2YTE3YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZGNiLmMKKysrIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZGNiLmMKQEAgLTM2LDcgKzM2LDcgQEAKIC8qKgogICogaXhnYmVfaWVlZV9jcmVkaXRzIC0gVGhpcyBjYWxjdWxhdGVzIHRoZSBpZWVlIHRyYWZmaWMgY2xhc3MKICAqIGNyZWRpdHMgZnJvbSB0aGUgY29uZmlndXJlZCBiYW5kd2lkdGggcGVyY2VudGFnZXMuIENyZWRpdHMKLSAqIGFyZSB0aGUgc21hbGxlc3QgdW5pdCBwcm9ncmFtYWJsZSBpbnRvIHRoZSB1bmRlcmx5aW5nCisgKiBhcmUgdGhlIHNtYWxsZXN0IHVuaXQgcHJvZ3JhbW1hYmxlIGludG8gdGhlIHVuZGVybHlpbmcKICAqIGhhcmR3YXJlLiBUaGUgSUVFRSA4MDIuMVFheiBzcGVjaWZpY2F0aW9uIGRvIG5vdCB1c2UgYmFuZHdpZHRoCiAgKiBncm91cHMgc28gdGhpcyBpcyBtdWNoIHNpbXBsaWZpZWQgZnJvbSB0aGUgQ0VFIGNhc2UuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2RjYl9ubC5jIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZGNiX25sLmMKaW5kZXggZmVjNGM3Mi4uMzI3Yzg2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZGNiX25sLmMKKysrIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZGNiX25sLmMKQEAgLTM2MCw3ICszNjAsNyBAQAogCQlyZXR1cm4gRENCX05PX0hXX0NIRzsKIAogCS8qCi0JICogT25seSB0YWtlIGRvd24gdGhlIGFkYXB0ZXIgaWYgYW4gYXBwIGNoYW5nZSBvY2N1cmVkLiBGQ29FCisJICogT25seSB0YWtlIGRvd24gdGhlIGFkYXB0ZXIgaWYgYW4gYXBwIGNoYW5nZSBvY2N1cnJlZC4gRkNvRQogCSAqIG1heSBzaHVmZmxlIHR4IHJpbmdzIGluIHRoaXMgY2FzZSBhbmQgdGhpcyBjYW4gbm90IGJlIGRvbmUKIAkgKiB3aXRob3V0IGEgcmVzZXQgY3VycmVudGx5LgogCSAqLwpAQCAtNTk5LDcgKzU5OSw3IEBACiAJCQkJYnJlYWs7CiAKIAkJCS8qIFRoZSBGQ29FIGFwcGxpY2F0aW9uIHByaW9yaXR5IG1heSBiZSBjaGFuZ2VkIG11bHRpcGxlCi0JCQkgKiB0aW1lcyBpbiBxdWljayBzdWNlc3Npb24gd2l0aCBzd2l0Y2hlcyB0aGF0IGJ1aWxkIHVwCisJCQkgKiB0aW1lcyBpbiBxdWljayBzdWNjZXNzaW9uIHdpdGggc3dpdGNoZXMgdGhhdCBidWlsZCB1cAogCQkJICogVExWcy4gVG8gYXZvaWQgY3JlYXRpbmcgdW5lZWRlZCBkZXZpY2UgcmVzZXRzIHRoaXMKIAkJCSAqIGNoZWNrcyB0aGUgYWN0dWFsIEhXIGNvbmZpZ3VyYXRpb24gYW5kIGNsZWFycwogCQkJICogQklUX0FQUF9VUENIRyBpZiBhIEhXIGNvbmZpZ3VyYXRpb24gY2hhbmdlIGlzIG5vdApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfbWFpbi5jIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfbWFpbi5jCmluZGV4IGYxN2U0YTcuLjZmOGFkYzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX21haW4uYworKysgYi9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9tYWluLmMKQEAgLTY0NCw3ICs2NDQsNyBAQAogICogQGFkYXB0ZXI6IGRyaXZlciBwcml2YXRlIHN0cnVjdAogICogQGluZGV4OiByZWcgaWR4IG9mIHF1ZXVlIHRvIHF1ZXJ5ICgwLTEyNykKICAqCi0gKiBIZWxwZXIgZnVuY3Rpb24gdG8gZGV0ZXJtaW5lIHRoZSB0cmFmZmljIGluZGV4IGZvciBhIHBhdGljdWxhcgorICogSGVscGVyIGZ1bmN0aW9uIHRvIGRldGVybWluZSB0aGUgdHJhZmZpYyBpbmRleCBmb3IgYSBwYXJ0aWN1bGFyCiAgKiByZWdpc3RlciBpbmRleC4KICAqCiAgKiBSZXR1cm5zIDogYSB0YyBpbmRleCBmb3IgdXNlIGluIHJhbmdlIDAtNywgb3IgMC0zCkBAIC0zNTU2LDcgKzM1NTYsNyBAQAogCQl9IGVsc2UgewogCQkJLyoKIAkJCSAqIFdyaXRlIGFkZHJlc3NlcyB0byB0aGUgTVRBLCBpZiB0aGUgYXR0ZW1wdCBmYWlscwotCQkJICogdGhlbiB3ZSBzaG91bGQganVzdCB0dXJuIG9uIHByb21pc2NvdXMgbW9kZSBzbworCQkJICogdGhlbiB3ZSBzaG91bGQganVzdCB0dXJuIG9uIHByb21pc2N1b3VzIG1vZGUgc28KIAkJCSAqIHRoYXQgd2UgY2FuIGF0IGxlYXN0IHJlY2VpdmUgbXVsdGljYXN0IHRyYWZmaWMKIAkJCSAqLwogCQkJaHctPm1hYy5vcHMudXBkYXRlX21jX2FkZHJfbGlzdChodywgbmV0ZGV2KTsKQEAgLTM1NjcsNyArMzU2Nyw3IEBACiAJCS8qCiAJCSAqIFdyaXRlIGFkZHJlc3NlcyB0byBhdmFpbGFibGUgUkFSIHJlZ2lzdGVycywgaWYgdGhlcmUgaXMgbm90CiAJCSAqIHN1ZmZpY2llbnQgc3BhY2UgdG8gc3RvcmUgYWxsIHRoZSBhZGRyZXNzZXMgdGhlbiBlbmFibGUKLQkJICogdW5pY2FzdCBwcm9taXNjb3VzIG1vZGUKKwkJICogdW5pY2FzdCBwcm9taXNjdW91cyBtb2RlCiAJCSAqLwogCQljb3VudCA9IGl4Z2JlX3dyaXRlX3VjX2FkZHJfbGlzdChuZXRkZXYpOwogCQlpZiAoY291bnQgPCAwKSB7CkBAIC00NDQzLDcgKzQ0NDMsNyBAQAogfQogCiAvKgotICogaXhnYmVfc2V0X251bV9xdWV1ZXM6IEFsbG9jYXRlIHF1ZXVlcyBmb3IgZGV2aWNlLCBmZWF0dXJlIGRlcGVuZGFudAorICogaXhnYmVfc2V0X251bV9xdWV1ZXM6IEFsbG9jYXRlIHF1ZXVlcyBmb3IgZGV2aWNlLCBmZWF0dXJlIGRlcGVuZGVudAogICogQGFkYXB0ZXI6IGJvYXJkIHByaXZhdGUgc3RydWN0dXJlIHRvIGluaXRpYWxpemUKICAqCiAgKiBUaGlzIGlzIHRoZSB0b3AgbGV2ZWwgcXVldWUgYWxsb2NhdGlvbiByb3V0aW5lLiAgVGhlIG9yZGVyIGhlcmUgaXMgdmVyeQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfcGh5LmMgYi9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9waHkuYwppbmRleCBmNzJmNzA1Li5kZjViOGFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9waHkuYworKysgYi9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9waHkuYwpAQCAtMTY5NCw3ICsxNjk0LDcgQEAKIH0KIAogLyoqCi0gKiAgaXhnYmVfdG5fY2hlY2tfb3ZlcnRlbXAgLSBDaGVja3MgaWYgYW4gb3ZlcnRlbXAgb2NjdXJlZC4KKyAqICBpeGdiZV90bl9jaGVja19vdmVydGVtcCAtIENoZWNrcyBpZiBhbiBvdmVydGVtcCBvY2N1cnJlZC4KICAqICBAaHc6IHBvaW50ZXIgdG8gaGFyZHdhcmUgc3RydWN0dXJlCiAgKgogICogIENoZWNrcyBpZiB0aGUgTEFTSSB0ZW1wIGFsYXJtIHN0YXR1cyB3YXMgdHJpZ2dlcmVkIGR1ZSB0byBvdmVydGVtcApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfeDU0MC5jIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfeDU0MC5jCmluZGV4IGY0N2U5M2YuLmQ5MzIzYzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX3g1NDAuYworKysgYi9kcml2ZXJzL25ldC9peGdiZS9peGdiZV94NTQwLmMKQEAgLTU3Myw3ICs1NzMsNyBAQAogICogQGh3OiBwb2ludGVyIHRvIGhhcmR3YXJlIHN0cnVjdHVyZQogICogQG1hc2s6IE1hc2sgdG8gc3BlY2lmeSB3aGljaCBzZW1hcGhvcmUgdG8gcmVsZWFzZQogICoKLSAqIFJlbGVhc2VzIHRoZSBTV0ZXIHNlbWFwaG9yZSB0aHJvdWdodCB0aGUgU1dfRldfU1lOQyByZWdpc3RlcgorICogUmVsZWFzZXMgdGhlIFNXRlcgc2VtYXBob3JlIHRocm91Z2ggdGhlIFNXX0ZXX1NZTkMgcmVnaXN0ZXIKICAqIGZvciB0aGUgc3BlY2lmaWVkIGZ1bmN0aW9uIChDU1IsIFBIWTAsIFBIWTEsIEVWTSwgRmxhc2gpCiAgKiovCiBzdGF0aWMgdm9pZCBpeGdiZV9yZWxlYXNlX3N3Zndfc3luY19YNTQwKHN0cnVjdCBpeGdiZV9odyAqaHcsIHUxNiBtYXNrKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXhnYmV2Zi9peGdiZXZmX21haW4uYyBiL2RyaXZlcnMvbmV0L2l4Z2JldmYvaXhnYmV2Zl9tYWluLmMKaW5kZXggMDU0YWIwNS4uMDVmYTdjOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXhnYmV2Zi9peGdiZXZmX21haW4uYworKysgYi9kcml2ZXJzL25ldC9peGdiZXZmL2l4Z2JldmZfbWFpbi5jCkBAIC0xOTI1LDcgKzE5MjUsNyBAQAogfQogCiAvKgotICogaXhnYmV2Zl9zZXRfbnVtX3F1ZXVlczogQWxsb2NhdGUgcXVldWVzIGZvciBkZXZpY2UsIGZlYXR1cmUgZGVwZW5kYW50CisgKiBpeGdiZXZmX3NldF9udW1fcXVldWVzOiBBbGxvY2F0ZSBxdWV1ZXMgZm9yIGRldmljZSwgZmVhdHVyZSBkZXBlbmRlbnQKICAqIEBhZGFwdGVyOiBib2FyZCBwcml2YXRlIHN0cnVjdHVyZSB0byBpbml0aWFsaXplCiAgKgogICogVGhpcyBpcyB0aGUgdG9wIGxldmVsIHF1ZXVlIGFsbG9jYXRpb24gcm91dGluZS4gIFRoZSBvcmRlciBoZXJlIGlzIHZlcnkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2tzODg0Mi5jIGIvZHJpdmVycy9uZXQva3M4ODQyLmMKaW5kZXggZWZkNDRhZi4uZjBkODM0NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQva3M4ODQyLmMKKysrIGIvZHJpdmVycy9uZXQva3M4ODQyLmMKQEAgLTMyMSw3ICszMjEsNyBAQAogCS8qIFJYIDIga2IgaGlnaCB3YXRlcm1hcmsgKi8KIAlrczg4NDJfd3JpdGUxNihhZGFwdGVyLCAwLCAweDEwMDAsIFJFR19RUkZDUik7CiAKLQkvKiBhZ2dyZXNpdmUgYmFjayBvZmYgaW4gaGFsZiBkdXBsZXggKi8KKwkvKiBhZ2dyZXNzaXZlIGJhY2sgb2ZmIGluIGhhbGYgZHVwbGV4ICovCiAJa3M4ODQyX2VuYWJsZV9iaXRzKGFkYXB0ZXIsIDMyLCAxIDw8IDgsIFJFR19TR0NSMSk7CiAKIAkvKiBlbmFibGUgbm8gZXhjZXNzaXZlIGNvbGxpc29uIGRyb3AgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2tzODg1MS5jIGIvZHJpdmVycy9uZXQva3M4ODUxLmMKaW5kZXggMGZhNGE5OC4uYmNkOWJhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQva3M4ODUxLmMKKysrIGIvZHJpdmVycy9uZXQva3M4ODUxLmMKQEAgLTE0MSw3ICsxNDEsNyBAQAogICoKICAqIEFsbCB0aGVzZSBjYWxscyBpc3N1ZSBTUEkgdHJhbnNhY3Rpb25zIHRvIGFjY2VzcyB0aGUgY2hpcCdzIHJlZ2lzdGVycy4gVGhleQogICogYWxsIHJlcXVpcmUgdGhhdCB0aGUgbmVjZXNzYXJ5IGxvY2sgaXMgaGVsZCB0byBwcmV2ZW50IGFjY2Vzc2VzIHdoZW4gdGhlCi0gKiBjaGlwIGlzIGJ1c3kgdHJhbnNmZXJpbmcgcGFja2V0IGRhdGEgKFJYL1RYIEZJRk8gYWNjZXNzZXMpLgorICogY2hpcCBpcyBidXN5IHRyYW5zZmVycmluZyBwYWNrZXQgZGF0YSAoUlgvVFggRklGTyBhY2Nlc3NlcykuCiAgKi8KIAogLyoqCkBAIC00ODMsNyArNDgzLDcgQEAKIAkgKgogCSAqIFRoaXMgZm9ybSBvZiBvcGVyYXRpb24gd291bGQgcmVxdWlyZSB1cyB0byBob2xkIHRoZSBTUEkgYnVzJwogCSAqIGNoaXBzZWxlY3QgbG93IGR1cmluZyB0aGUgZW50aWUgdHJhbnNhY3Rpb24gdG8gYXZvaWQgYW55Ci0JICogcmVzZXQgdG8gdGhlIGRhdGEgc3RyZWFtIGNvbW1pbmcgZnJvbSB0aGUgY2hpcC4KKwkgKiByZXNldCB0byB0aGUgZGF0YSBzdHJlYW0gY29taW5nIGZyb20gdGhlIGNoaXAuCiAJICovCiAKIAlmb3IgKDsgcnhmYyAhPSAwOyByeGZjLS0pIHsKQEAgLTYzNCw3ICs2MzQsNyBAQAogCiAvKioKICAqIGNhbGNfdHhsZW4gLSBjYWxjdWxhdGUgc2l6ZSBvZiBtZXNzYWdlIHRvIHNlbmQgcGFja2V0Ci0gKiBAbGVuOiBMZW5naHQgb2YgZGF0YQorICogQGxlbjogTGVuZ3RoIG9mIGRhdGEKICAqCiAgKiBSZXR1cm5zIHRoZSBzaXplIG9mIHRoZSBUWEZJRk8gbWVzc2FnZSBuZWVkZWQgdG8gc2VuZAogICogdGhpcyBwYWNrZXQuCkBAIC0xNDcyLDcgKzE0NzIsNyBAQAogICogQHJlZzogVGhlIHJlZ2lzdGVyIHRvIHJlYWQuCiAgKgogICogVGhpcyBjYWxsIHJlYWRzIGRhdGEgZnJvbSB0aGUgUEhZIHJlZ2lzdGVyIHNwZWNpZmllZCBpbiBAcmVnLiBTaW5jZSB0aGUKLSAqIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGFsbCB0aGUgTUlJIHJlZ2lzdGVycywgdGhlIG5vbi1leGlzdGFudCB2YWx1ZXMKKyAqIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGFsbCB0aGUgTUlJIHJlZ2lzdGVycywgdGhlIG5vbi1leGlzdGVudCB2YWx1ZXMKICAqIGFyZSBhbHdheXMgcmV0dXJuZWQgYXMgemVyby4KICAqCiAgKiBXZSByZXR1cm4gemVybyBmb3IgdW5zdXBwb3J0ZWQgcmVnaXN0ZXJzIGFzIHRoZSBNSUkgY29kZSBkb2VzIG5vdCBjaGVjawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQva3M4ODUxX21sbC5jIGIvZHJpdmVycy9uZXQva3M4ODUxX21sbC5jCmluZGV4IDJlMmM2OWIuLjYxNjMxY2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2tzODg1MV9tbGwuYworKysgYi9kcml2ZXJzL25ldC9rczg4NTFfbWxsLmMKQEAgLTQ3MCw3ICs0NzAsNyBAQAogICoKICAqIEFsbCB0aGVzZSBjYWxscyBpc3N1ZSB0cmFuc2FjdGlvbnMgdG8gYWNjZXNzIHRoZSBjaGlwJ3MgcmVnaXN0ZXJzLiBUaGV5CiAgKiBhbGwgcmVxdWlyZSB0aGF0IHRoZSBuZWNlc3NhcnkgbG9jayBpcyBoZWxkIHRvIHByZXZlbnQgYWNjZXNzZXMgd2hlbiB0aGUKLSAqIGNoaXAgaXMgYnVzeSB0cmFuc2ZlcmluZyBwYWNrZXQgZGF0YSAoUlgvVFggRklGTyBhY2Nlc3NlcykuCisgKiBjaGlwIGlzIGJ1c3kgdHJhbnNmZXJyaW5nIHBhY2tldCBkYXRhIChSWC9UWCBGSUZPIGFjY2Vzc2VzKS4KICAqLwogCiAvKioKQEAgLTEzNjQsNyArMTM2NCw3IEBACiAgKiBAcmVnOiBUaGUgcmVnaXN0ZXIgdG8gcmVhZC4KICAqCiAgKiBUaGlzIGNhbGwgcmVhZHMgZGF0YSBmcm9tIHRoZSBQSFkgcmVnaXN0ZXIgc3BlY2lmaWVkIGluIEByZWcuIFNpbmNlIHRoZQotICogZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgYWxsIHRoZSBNSUkgcmVnaXN0ZXJzLCB0aGUgbm9uLWV4aXN0YW50IHZhbHVlcworICogZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgYWxsIHRoZSBNSUkgcmVnaXN0ZXJzLCB0aGUgbm9uLWV4aXN0ZW50IHZhbHVlcwogICogYXJlIGFsd2F5cyByZXR1cm5lZCBhcyB6ZXJvLgogICoKICAqIFdlIHJldHVybiB6ZXJvIGZvciB1bnN1cHBvcnRlZCByZWdpc3RlcnMgYXMgdGhlIE1JSSBjb2RlIGRvZXMgbm90IGNoZWNrCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9saWI4MzkwLmMgYi9kcml2ZXJzL25ldC9saWI4MzkwLmMKaW5kZXggZGE3NGRiNC4uMTdiNzVlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbGliODM5MC5jCisrKyBiL2RyaXZlcnMvbmV0L2xpYjgzOTAuYwpAQCAtMzUsNyArMzUsNyBAQAogICBBbGV4ZXkgS3V6bmV0c292CTogdXNlIHRoZSA4MzkwJ3Mgc2l4IGJpdCBoYXNoIG11bHRpY2FzdCBmaWx0ZXIuCiAgIFBhdWwgR29ydG1ha2VyCTogdHdlYWsgQU5LJ3MgYWJvdmUgbXVsdGljYXN0IGNoYW5nZXMgYSBiaXQuCiAgIFBhdWwgR29ydG1ha2VyCTogdXBkYXRlIHBhY2tldCBzdGF0aXN0aWNzIGZvciB2Mi4xLngKLSAgQWxhbiBDb3gJCTogc3VwcG9ydCBhcmJpdGFyeSBzdHVwaWQgcG9ydCBtYXBwaW5ncyBvbiB0aGUKKyAgQWxhbiBDb3gJCTogc3VwcG9ydCBhcmJpdHJhcnkgc3R1cGlkIHBvcnQgbWFwcGluZ3Mgb24gdGhlCiAgIAkJCSAgNjhLIE1hY2ludG9zaC4gU3VwcG9ydCA+MTZiaXQgSS9PIHNwYWNlcwogICBQYXVsIEdvcnRtYWtlcgk6IGFkZCBrbW9kIHN1cHBvcnQgZm9yIGF1dG8tbG9hZGluZyBvZiB0aGUgODM5MAogCQkJICBtb2R1bGUgYnkgYWxsIGRyaXZlcnMgdGhhdCByZXF1aXJlIGl0LgpAQCAtMTIxLDcgKzEyMSw3IEBACiAvKgogICoJU01QIGFuZCB0aGUgODM5MCBzZXR1cC4KICAqCi0gKglUaGUgODM5MCBpc250IGV4YWN0bHkgZGVzaWduZWQgdG8gYmUgbXVsdGl0aHJlYWRlZCBvbiBSWC9UWC4gVGhlcmUgaXMKKyAqCVRoZSA4MzkwIGlzbid0IGV4YWN0bHkgZGVzaWduZWQgdG8gYmUgbXVsdGl0aHJlYWRlZCBvbiBSWC9UWC4gVGhlcmUgaXMKICAqCWEgcGFnZSByZWdpc3RlciB0aGF0IGNvbnRyb2xzIGJhbmsgYW5kIHBhY2tldCBidWZmZXIgYWNjZXNzLiBXZSBndWFyZAogICoJdGhpcyB3aXRoIGVpX2xvY2FsLT5wYWdlX2xvY2suIE5vYm9keSBzaG91bGQgYXNzdW1lIG9yIHNldCB0aGUgcGFnZSBvdGhlcgogICoJdGhhbiB6ZXJvIHdoZW4gdGhlIGxvY2sgaXMgbm90IGhlbGQuIExvY2sgaG9sZGVycyBtdXN0IHJlc3RvcmUgcGFnZSAwCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9scDQ4NmUuYyBiL2RyaXZlcnMvbmV0L2xwNDg2ZS5jCmluZGV4IDM2OTg4MjQuLjM4NWE5NTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2xwNDg2ZS5jCisrKyBiL2RyaXZlcnMvbmV0L2xwNDg2ZS5jCkBAIC0yNyw3ICsyNyw3IEBACiAKIAlDcmVkaXRzOgogCVRoYW5rcyB0byBNdXJwaHkgU29mdHdhcmUgQlYgZm9yIGxldHRpbmcgbWUgd3JpdGUgdGhpcyBpbiB0aGVpciB0aW1lLgotCVdlbGwsIGFjdHVhbGx5LCBJIGdldCBwYXllZCBkb2luZyB0aGlzLi4uCisJV2VsbCwgYWN0dWFsbHksIEkgZ2V0IHBhaWQgZG9pbmcgdGhpcy4uLgogCShBbHNvOiBzZWUgaHR0cDovL3d3dy5tdXJwaHkubmwgZm9yIG11cnBoeSwgYW5kIG15IGhvbWVwYWdlIH5hcmQgZm9yCiAJbW9yZSBpbmZvcm1hdGlvbiBvbiB0aGUgUHJvZmVzc2lvbmFsIFdvcmtzdGF0aW9uKQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tZXRoLmggYi9kcml2ZXJzL25ldC9tZXRoLmgKaW5kZXggYTc4ZGMxYy4uNWIxNDVjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWV0aC5oCisrKyBiL2RyaXZlcnMvbmV0L21ldGguaApAQCAtMTQ0LDcgKzE0NCw3IEBACiAJCQkJICAgICAgIC8qIEJpdHMgMjIgdGhyb3VnaCAyOCBhcmUgdXNlZCB0byBkZXRlcm1pbmUgSVBHUjIgKi8KIAogI2RlZmluZSBNRVRIX1JFVl9TSElGVCAyOSAgICAgICAvKiBCaXRzIDI5IHRocm91Z2ggMzEgYXJlIHVzZWQgdG8gZGV0ZXJtaW5lIHRoZSByZXZpc2lvbiAqLwotCQkJCSAgICAgICAvKiAwMDA6IEluaXRhbCByZXZpc2lvbiAqLworCQkJCSAgICAgICAvKiAwMDA6IEluaXRpYWwgcmV2aXNpb24gKi8KIAkJCQkgICAgICAgLyogMDAxOiBGaXJzdCByZXZpc2lvbiwgSW1wcm92ZWQgVFggY29uY2F0ZW5hdGlvbiAqLwogCiAKQEAgLTE5Myw3ICsxOTMsNyBAQAogCQkJCQkgICAgICAJLyogMTogQSBUWCBtZXNzYWdlIGhhZCB0aGUgSU5UIHJlcXVlc3QgYml0IHNldCwgdGhlIHBhY2tldCBoYXMgYmVlbiBzZW50LiAqLwogI2RlZmluZSBNRVRIX0lOVF9UWF9MSU5LX0ZBSUwJQklUKDIpCS8qIDA6IE5vIGludGVycnVwdCBwZW5kaW5nLCAxOiBQSFkgaGFzIHJlcG9ydGVkIGEgbGluayBmYWlsdXJlICovCiAjZGVmaW5lIE1FVEhfSU5UX01FTV9FUlJPUglCSVQoMykJLyogMDogTm8gaW50ZXJydXB0IHBlbmRpbmcgKi8KLQkJCQkJCS8qIDE6IEEgbWVtb3J5IGVycm9yIG9jY3VycmVkIGR1cnJpbmcgRE1BLCBETUEgc3RvcHBlZCwgRmF0YWwgKi8KKwkJCQkJCS8qIDE6IEEgbWVtb3J5IGVycm9yIG9jY3VycmVkIGR1cmluZyBETUEsIERNQSBzdG9wcGVkLCBGYXRhbCAqLwogI2RlZmluZSBNRVRIX0lOVF9UWF9BQk9SVAkJQklUKDQpCS8qIDA6IE5vIGludGVycnVwdCBwZW5kaW5nLCAxOiBUaGUgVFggYWJvcnRlZCBvcGVyYXRpb24sIERNQSBzdG9wcGVkLCBGQVRBTCAqLwogI2RlZmluZSBNRVRIX0lOVF9SWF9USFJFU0hPTEQJQklUKDUpCS8qIDA6IE5vIGludGVycnVwdCBwZW5kaW5nLCAxOiBTZWxlY3RlZCByZWNlaXZlIHRocmVzaG9sZCBjb25kaXRpb24gVmFsaWQgKi8KICNkZWZpbmUgTUVUSF9JTlRfUlhfVU5ERVJGTE9XCUJJVCg2KQkvKiAwOiBObyBpbnRlcnJ1cHQgcGVuZGluZywgMTogRklGTyB3YXMgZW1wdHksIHBhY2tldCBjb3VsZCBub3QgYmUgcXVldWVkICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L2VuX21haW4uYyBiL2RyaXZlcnMvbmV0L21seDQvZW5fbWFpbi5jCmluZGV4IDkzMTdiNjEuLjkyNzZiMWIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tbHg0L2VuX21haW4uYworKysgYi9kcml2ZXJzL25ldC9tbHg0L2VuX21haW4uYwpAQCAtMjM2LDcgKzIzNiw3IEBACiAJCWdvdG8gZXJyX21yOwogCX0KIAotCS8qIENvbmZpZ3VyZSB3aWNoIHBvcnRzIHRvIHN0YXJ0IGFjY29yZGluZyB0byBtb2R1bGUgcGFyYW1ldGVycyAqLworCS8qIENvbmZpZ3VyZSB3aGljaCBwb3J0cyB0byBzdGFydCBhY2NvcmRpbmcgdG8gbW9kdWxlIHBhcmFtZXRlcnMgKi8KIAltZGV2LT5wb3J0X2NudCA9IDA7CiAJbWx4NF9mb3JlYWNoX3BvcnQoaSwgZGV2LCBNTFg0X1BPUlRfVFlQRV9FVEgpCiAJCW1kZXYtPnBvcnRfY250Kys7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L2VuX25ldGRldi5jIGIvZHJpdmVycy9uZXQvbWx4NC9lbl9uZXRkZXYuYwppbmRleCA0ZjE1OGJhLi43NzA2M2Y5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tbHg0L2VuX25ldGRldi5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvZW5fbmV0ZGV2LmMKQEAgLTI0Nyw3ICsyNDcsNyBAQAogCQkJCQkJCSAgICAgICBwcml2LT5wb3J0KTsKIAkJCWlmIChlcnIpCiAJCQkJZW5fZXJyKHByaXYsICJGYWlsZWQgZW5hYmxpbmcgIgotCQkJCQkgICAgICJwcm9taXNjb3VzIG1vZGVcbiIpOworCQkJCQkgICAgICJwcm9taXNjdW91cyBtb2RlXG4iKTsKIAogCQkJLyogRGlzYWJsZSBwb3J0IG11bHRpY2FzdCBmaWx0ZXIgKHVuY29uZGl0aW9uYWxseSkgKi8KIAkJCWVyciA9IG1seDRfU0VUX01DQVNUX0ZMVFIobWRldi0+ZGV2LCBwcml2LT5wb3J0LCAwLApAQCAtMjc2LDcgKzI3Niw3IEBACiAJfQogCiAJLyoKLQkgKiBOb3QgaW4gcHJvbWlzY291cyBtb2RlCisJICogTm90IGluIHByb21pc2N1b3VzIG1vZGUKIAkgKi8KIAogCWlmIChwcml2LT5mbGFncyAmIE1MWDRfRU5fRkxBR19QUk9NSVNDKSB7CkBAIC0yOTIsMTQgKzI5MiwxNCBAQAogCQkJZXJyID0gbWx4NF91bmljYXN0X3Byb21pc2NfcmVtb3ZlKG1kZXYtPmRldiwgcHJpdi0+YmFzZV9xcG4sCiAJCQkJCQkJICBwcml2LT5wb3J0KTsKIAkJaWYgKGVycikKLQkJCWVuX2Vycihwcml2LCAiRmFpbGVkIGRpc2FibGluZyBwcm9taXNjb3VzIG1vZGVcbiIpOworCQkJZW5fZXJyKHByaXYsICJGYWlsZWQgZGlzYWJsaW5nIHByb21pc2N1b3VzIG1vZGVcbiIpOwogCiAJCS8qIERpc2FibGUgTXVsdGljYXN0IHByb21pc2MgKi8KIAkJaWYgKHByaXYtPmZsYWdzICYgTUxYNF9FTl9GTEFHX01DX1BST01JU0MpIHsKIAkJCWVyciA9IG1seDRfbXVsdGljYXN0X3Byb21pc2NfcmVtb3ZlKG1kZXYtPmRldiwgcHJpdi0+YmFzZV9xcG4sCiAJCQkJCQkJICAgIHByaXYtPnBvcnQpOwogCQkJaWYgKGVycikKLQkJCQllbl9lcnIocHJpdiwgIkZhaWxlZCBkaXNhYmxpbmcgbXVsdGljYXN0IHByb21pc2NvdXMgbW9kZVxuIik7CisJCQkJZW5fZXJyKHByaXYsICJGYWlsZWQgZGlzYWJsaW5nIG11bHRpY2FzdCBwcm9taXNjdW91cyBtb2RlXG4iKTsKIAkJCXByaXYtPmZsYWdzICY9IH5NTFg0X0VOX0ZMQUdfTUNfUFJPTUlTQzsKIAkJfQogCkBAIC0zMzEsNyArMzMxLDcgQEAKIAkJCWVyciA9IG1seDRfbXVsdGljYXN0X3Byb21pc2NfcmVtb3ZlKG1kZXYtPmRldiwgcHJpdi0+YmFzZV9xcG4sCiAJCQkJCQkJICAgIHByaXYtPnBvcnQpOwogCQkJaWYgKGVycikKLQkJCQllbl9lcnIocHJpdiwgIkZhaWxlZCBkaXNhYmxpbmcgbXVsdGljYXN0IHByb21pc2NvdXMgbW9kZVxuIik7CisJCQkJZW5fZXJyKHByaXYsICJGYWlsZWQgZGlzYWJsaW5nIG11bHRpY2FzdCBwcm9taXNjdW91cyBtb2RlXG4iKTsKIAkJCXByaXYtPmZsYWdzICY9IH5NTFg0X0VOX0ZMQUdfTUNfUFJPTUlTQzsKIAkJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L2VuX3J4LmMgYi9kcml2ZXJzL25ldC9tbHg0L2VuX3J4LmMKaW5kZXggMDU5OThlZS4uNjJkZDIxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9lbl9yeC5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvZW5fcnguYwpAQCAtMzQ1LDYgKzM0NSw4IEBACiAJCWVyciA9IG1seDRfZW5faW5pdF9hbGxvY2F0b3IocHJpdiwgcmluZyk7CiAJCWlmIChlcnIpIHsKIAkJCWVuX2Vycihwcml2LCAiRmFpbGVkIGluaXRpYWxpemluZyByaW5nIGFsbG9jYXRvclxuIik7CisJCQlpZiAocmluZy0+c3RyaWRlIDw9IFRYQkJfU0laRSkKKwkJCQlyaW5nLT5idWYgLT0gVFhCQl9TSVpFOwogCQkJcmluZ19pbmQtLTsKIAkJCWdvdG8gZXJyX2FsbG9jYXRvcjsKIAkJfQpAQCAtMzY5LDYgKzM3MSw4IEBACiAJcmluZ19pbmQgPSBwcml2LT5yeF9yaW5nX251bSAtIDE7CiBlcnJfYWxsb2NhdG9yOgogCXdoaWxlIChyaW5nX2luZCA+PSAwKSB7CisJCWlmIChwcml2LT5yeF9yaW5nW3JpbmdfaW5kXS5zdHJpZGUgPD0gVFhCQl9TSVpFKQorCQkJcHJpdi0+cnhfcmluZ1tyaW5nX2luZF0uYnVmIC09IFRYQkJfU0laRTsKIAkJbWx4NF9lbl9kZXN0cm95X2FsbG9jYXRvcihwcml2LCAmcHJpdi0+cnhfcmluZ1tyaW5nX2luZF0pOwogCQlyaW5nX2luZC0tOwogCX0KQEAgLTcwNiw3ICs3MTAsNyBAQAogfQogCiAKLS8qIENhbGN1bGF0ZSB0aGUgbGFzdCBvZmZzZXQgcG9zaXRpb24gdGhhdCBhY2NvbW9kYXRlcyBhIGZ1bGwgZnJhZ21lbnQKKy8qIENhbGN1bGF0ZSB0aGUgbGFzdCBvZmZzZXQgcG9zaXRpb24gdGhhdCBhY2NvbW1vZGF0ZXMgYSBmdWxsIGZyYWdtZW50CiAgKiAoYXNzdW1pbmcgZmFnbWVudCBzaXplID0gc3RyaWRlLWFsaWduKSAqLwogc3RhdGljIGludCBtbHg0X2VuX2xhc3RfYWxsb2Nfb2Zmc2V0KHN0cnVjdCBtbHg0X2VuX3ByaXYgKnByaXYsIHUxNiBzdHJpZGUsIHUxNiBhbGlnbikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L21seDQvZW5fc2VsZnRlc3QuYyBiL2RyaXZlcnMvbmV0L21seDQvZW5fc2VsZnRlc3QuYwppbmRleCA5YzkxYTkyLi4xOTFhOGRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tbHg0L2VuX3NlbGZ0ZXN0LmMKKysrIGIvZHJpdmVycy9uZXQvbWx4NC9lbl9zZWxmdGVzdC5jCkBAIC0xNDksNyArMTQ5LDcgQEAKIAogCQluZXRpZl9jYXJyaWVyX29mZihkZXYpOwogcmV0cnlfdHg6Ci0JCS8qIFdhaXQgdW50aWxsIGFsbCB0eCBxdWV1ZXMgYXJlIGVtcHR5LgorCQkvKiBXYWl0IHVudGlsIGFsbCB0eCBxdWV1ZXMgYXJlIGVtcHR5LgogCQkgKiB0aGVyZSBzaG91bGQgbm90IGJlIGFueSBhZGRpdGlvbmFsIGluY29taW5nIHRyYWZmaWMKIAkJICogc2luY2Ugd2UgdHVybmVkIHRoZSBjYXJyaWVyIG9mZiAqLwogCQltc2xlZXAoMjAwKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L21seDQvZW5fdHguYyBiL2RyaXZlcnMvbmV0L21seDQvZW5fdHguYwppbmRleCAwMWZlYjhmLi5iMjI5YWNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tbHg0L2VuX3R4LmMKKysrIGIvZHJpdmVycy9uZXQvbWx4NC9lbl90eC5jCkBAIC02MzYsNyArNjM2LDcgQEAKIAlpZiAodW5saWtlbHkoIXJlYWxfc2l6ZSkpCiAJCWdvdG8gdHhfZHJvcDsKIAotCS8qIEFsbGlnbiBkZXNjcmlwdG9yIHRvIFRYQkIgc2l6ZSAqLworCS8qIEFsaWduIGRlc2NyaXB0b3IgdG8gVFhCQiBzaXplICovCiAJZGVzY19zaXplID0gQUxJR04ocmVhbF9zaXplLCBUWEJCX1NJWkUpOwogCW5yX3R4YmIgPSBkZXNjX3NpemUgLyBUWEJCX1NJWkU7CiAJaWYgKHVubGlrZWx5KG5yX3R4YmIgPiBNQVhfREVTQ19UWEJCUykpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L21seDQvbWFpbi5jIGIvZHJpdmVycy9uZXQvbWx4NC9tYWluLmMKaW5kZXggNjJmYTdlZS4uMzgxNGZjOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvbWx4NC9tYWluLmMKQEAgLTk0NCw2ICs5NDQsMTAgQEAKIAl9CiAKIAlmb3IgKHBvcnQgPSAxOyBwb3J0IDw9IGRldi0+Y2Fwcy5udW1fcG9ydHM7IHBvcnQrKykgeworCQllbnVtIG1seDRfcG9ydF90eXBlIHBvcnRfdHlwZSA9IDA7CisJCW1seDRfU0VOU0VfUE9SVChkZXYsIHBvcnQsICZwb3J0X3R5cGUpOworCQlpZiAocG9ydF90eXBlKQorCQkJZGV2LT5jYXBzLnBvcnRfdHlwZVtwb3J0XSA9IHBvcnRfdHlwZTsKIAkJaWJfcG9ydF9kZWZhdWx0X2NhcHMgPSAwOwogCQllcnIgPSBtbHg0X2dldF9wb3J0X2liX2NhcHMoZGV2LCBwb3J0LCAmaWJfcG9ydF9kZWZhdWx0X2NhcHMpOwogCQlpZiAoZXJyKQpAQCAtOTU4LDYgKzk2Miw3IEBACiAJCQlnb3RvIGVycl9tY2dfdGFibGVfZnJlZTsKIAkJfQogCX0KKwltbHg0X3NldF9wb3J0X21hc2soZGV2KTsKIAogCXJldHVybiAwOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L21jZy5jIGIvZHJpdmVycy9uZXQvbWx4NC9tY2cuYwppbmRleCBjNmQzMzZhLi5lNjNjMzdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tbHg0L21jZy5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvbWNnLmMKQEAgLTIyMiw3ICsyMjIsNyBAQAogCiAJLyogdGhlIGdpdmVuIHFwbiBpcyBsaXN0ZWQgYXMgYSBwcm9taXNjIHFwbgogCSAqIHdlIG5lZWQgdG8gYWRkIGl0IGFzIGEgZHVwbGljYXRlIHRvIHRoaXMgZW50cnkKLQkgKiBmb3IgZnV0dXJlIHJlZmVybmNlICovCisJICogZm9yIGZ1dHVyZSByZWZlcmVuY2VzICovCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShkcXAsICZlbnRyeS0+ZHVwbGljYXRlcywgbGlzdCkgewogCQlpZiAocXBuID09IGRxcC0+cXBuKQogCQkJcmV0dXJuIDA7IC8qIHFwIGlzIGFscmVhZHkgZHVwbGljYXRlZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbWx4NC9tbHg0LmggYi9kcml2ZXJzL25ldC9tbHg0L21seDQuaAppbmRleCBjMWUwZTVmLi5kZDdkNzQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tbHg0L21seDQuaAorKysgYi9kcml2ZXJzL25ldC9tbHg0L21seDQuaApAQCAtNDMxLDYgKzQzMSw4IEBACiAKIHZvaWQgbWx4NF9oYW5kbGVfY2F0YXNfZXJyKHN0cnVjdCBtbHg0X2RldiAqZGV2KTsKIAoraW50IG1seDRfU0VOU0VfUE9SVChzdHJ1Y3QgbWx4NF9kZXYgKmRldiwgaW50IHBvcnQsCisJCSAgICBlbnVtIG1seDRfcG9ydF90eXBlICp0eXBlKTsKIHZvaWQgbWx4NF9kb19zZW5zZV9wb3J0cyhzdHJ1Y3QgbWx4NF9kZXYgKmRldiwKIAkJCSBlbnVtIG1seDRfcG9ydF90eXBlICpzdHlwZSwKIAkJCSBlbnVtIG1seDRfcG9ydF90eXBlICpkZWZhdWx0cyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L3BvcnQuYyBiL2RyaXZlcnMvbmV0L21seDQvcG9ydC5jCmluZGV4IGVjYTdkODUuLjg4NTY2NTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L21seDQvcG9ydC5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvcG9ydC5jCkBAIC0xNzIsNyArMTcyLDcgQEAKIAkJfQogCiAJCWlmIChtYWMgPT0gKE1MWDRfTUFDX01BU0sgJiBiZTY0X3RvX2NwdSh0YWJsZS0+ZW50cmllc1tpXSkpKSB7Ci0JCQkvKiBNQUMgYWxyZWFkeSByZWdpc3RlcmVkLCBpbmNyZWFzZSByZWZlcm5jZSBjb3VudCAqLworCQkJLyogTUFDIGFscmVhZHkgcmVnaXN0ZXJlZCwgaW5jcmVhc2UgcmVmZXJlbmNlcyBjb3VudCAqLwogCQkJKyt0YWJsZS0+cmVmc1tpXTsKIAkJCWdvdG8gb3V0OwogCQl9CkBAIC0zNjAsNyArMzYwLDcgQEAKIAkJaWYgKHRhYmxlLT5yZWZzW2ldICYmCiAJCSAgICAodmxhbiA9PSAoTUxYNF9WTEFOX01BU0sgJgogCQkJICAgICAgYmUzMl90b19jcHUodGFibGUtPmVudHJpZXNbaV0pKSkpIHsKLQkJCS8qIFZsYW4gYWxyZWFkeSByZWdpc3RlcmVkLCBpbmNyZWFzZSByZWZlcm5jZSBjb3VudCAqLworCQkJLyogVmxhbiBhbHJlYWR5IHJlZ2lzdGVyZWQsIGluY3JlYXNlIHJlZmVyZW5jZXMgY291bnQgKi8KIAkJCSppbmRleCA9IGk7CiAJCQkrK3RhYmxlLT5yZWZzW2ldOwogCQkJZ290byBvdXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L3NlbnNlLmMgYi9kcml2ZXJzL25ldC9tbHg0L3NlbnNlLmMKaW5kZXggMDE1ZmJlNy4uZTIzMzdhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9zZW5zZS5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvc2Vuc2UuYwpAQCAtMzgsOCArMzgsOCBAQAogCiAjaW5jbHVkZSAibWx4NC5oIgogCi1zdGF0aWMgaW50IG1seDRfU0VOU0VfUE9SVChzdHJ1Y3QgbWx4NF9kZXYgKmRldiwgaW50IHBvcnQsCi0JCQkgICBlbnVtIG1seDRfcG9ydF90eXBlICp0eXBlKQoraW50IG1seDRfU0VOU0VfUE9SVChzdHJ1Y3QgbWx4NF9kZXYgKmRldiwgaW50IHBvcnQsCisJCSAgICBlbnVtIG1seDRfcG9ydF90eXBlICp0eXBlKQogewogCXU2NCBvdXRfcGFyYW07CiAJaW50IGVyciA9IDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9teXJpMTBnZS9teXJpMTBnZS5jIGIvZHJpdmVycy9uZXQvbXlyaTEwZ2UvbXlyaTEwZ2UuYwppbmRleCA2NzNkYzYwLi4xNDQ2ZGU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9teXJpMTBnZS9teXJpMTBnZS5jCisrKyBiL2RyaXZlcnMvbmV0L215cmkxMGdlL215cmkxMGdlLmMKQEAgLTM3MDIsNyArMzcwMiw3IEBACiAKIC8qCiAgKiBUaGlzIGZ1bmN0aW9uIGRldGVybWluZXMgdGhlIG51bWJlciBvZiBzbGljZXMgc3VwcG9ydGVkLgotICogVGhlIG51bWJlciBzbGljZXMgaXMgdGhlIG1pbnVtdW0gb2YgdGhlIG51bWJlciBvZiBDUFVTLAorICogVGhlIG51bWJlciBzbGljZXMgaXMgdGhlIG1pbmltdW0gb2YgdGhlIG51bWJlciBvZiBDUFVTLAogICogdGhlIG51bWJlciBvZiBNU0ktWCBpcnFzIHN1cHBvcnRlZCwgdGhlIG51bWJlciBvZiBzbGljZXMKICAqIHN1cHBvcnRlZCBieSB0aGUgZmlybXdhcmUKICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbXlyaV9zYnVzLmMgYi9kcml2ZXJzL25ldC9teXJpX3NidXMuYwppbmRleCBhNzYxMDc2Li41M2FlZWE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9teXJpX3NidXMuYworKysgYi9kcml2ZXJzL25ldC9teXJpX3NidXMuYwpAQCAtMTAwOSw3ICsxMDA5LDcgQEAKIAogCS8qIE1hcCBpbiB0aGUgTXlyaUNPTSByZWdpc3Rlci9sb2NhbHJhbSBzZXQuICovCiAJaWYgKG1wLT5lZXByb20uY3B1dmVycyA8IENQVVZFUlNfNF8wKSB7Ci0JCS8qIFhYWCBNYWtlcyBubyBzZW5zZSwgaWYgY29udHJvbCByZWcgaXMgbm9uLWV4aXN0YW50IHRoaXMKKwkJLyogWFhYIE1ha2VzIG5vIHNlbnNlLCBpZiBjb250cm9sIHJlZyBpcyBub24tZXhpc3RlbnQgdGhpcwogCQkgKiBYWFggZHJpdmVyIGNhbm5vdCBmdW5jdGlvbiBhdCBhbGwuLi4gbWF5YmUgcHJlLTQuMCBpcwogCQkgKiBYWFggb25seSBhIHZhbGlkIHZlcnNpb24gZm9yIFBDSSBjYXJkcz8gIEFzayBmZWxkeS4uLgogCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L25hdHNlbWkuYyBiL2RyaXZlcnMvbmV0L25hdHNlbWkuYwppbmRleCAyZmQzOTYzLi5hYTI4MTNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9uYXRzZW1pLmMKKysrIGIvZHJpdmVycy9uZXQvbmF0c2VtaS5jCkBAIC0yMDMsNyArMjAzLDcgQEAKIElJSWQuIFN5bmNocm9uaXphdGlvbgogCiBNb3N0IG9wZXJhdGlvbnMgYXJlIHN5bmNocm9uaXplZCBvbiB0aGUgbnAtPmxvY2sgaXJxIHNwaW5sb2NrLCBleGNlcHQgdGhlCi1yZWNpZXZlIGFuZCB0cmFuc21pdCBwYXRocyB3aGljaCBhcmUgc3luY2hyb25pc2VkIHVzaW5nIGEgY29tYmluYXRpb24gb2YKK3JlY2VpdmUgYW5kIHRyYW5zbWl0IHBhdGhzIHdoaWNoIGFyZSBzeW5jaHJvbmlzZWQgdXNpbmcgYSBjb21iaW5hdGlvbiBvZgogaGFyZHdhcmUgZGVzY3JpcHRvciBvd25lcnNoaXAsIGRpc2FibGluZyBpbnRlcnJ1cHRzIGFuZCBOQVBJIHBvbGwgc2NoZWR1bGluZy4KIAogSVZiLiBSZWZlcmVuY2VzCkBAIC03MjYsNyArNzI2LDcgQEAKIAkgKiBUaGVyZSBhcmUgdHdvIGFkZHJlc3NlcyB3ZSBtdXN0IGF2b2lkOgogCSAqIC0gdGhlIGFkZHJlc3Mgb24gdGhlIGV4dGVybmFsIHBoeSB0aGF0IGlzIHVzZWQgZm9yIHRyYW5zbWlzc2lvbi4KIAkgKiAtIHRoZSBhZGRyZXNzIHRoYXQgd2Ugd2FudCB0byBhY2Nlc3MuIFVzZXIgc3BhY2UgY2FuIGFjY2VzcyBwaHlzCi0JICogICBvbiB0aGUgbWlpIGJ1cyB3aXRoIFNJT0NHTUlJUkVHL1NJT0NTTUlJUkVHLCBpbmRlcGVuZGFudCBmcm9tIHRoZQorCSAqICAgb24gdGhlIG1paSBidXMgd2l0aCBTSU9DR01JSVJFRy9TSU9DU01JSVJFRywgaW5kZXBlbmRlbnQgZnJvbSB0aGUKIAkgKiAgIHBoeSB0aGF0IGlzIHVzZWQgZm9yIHRyYW5zbWlzc2lvbi4KIAkgKi8KIApAQCAtMTk4Miw3ICsxOTgyLDcgQEAKIAogCW5wLT5yeF9oZWFkX2Rlc2MgPSAmbnAtPnJ4X3JpbmdbMF07CiAKLQkvKiBQbGVhc2UgYmUgY2FyZWZ1bGwgYmVmb3JlIGNoYW5naW5nIHRoaXMgbG9vcCAtIGF0IGxlYXN0IGdjYy0yLjk1LjEKKwkvKiBQbGVhc2UgYmUgY2FyZWZ1bCBiZWZvcmUgY2hhbmdpbmcgdGhpcyBsb29wIC0gYXQgbGVhc3QgZ2NjLTIuOTUuMQogCSAqIG1pc2NvbXBpbGVzIGl0IG90aGVyd2lzZS4KIAkgKi8KIAkvKiBJbml0aWFsaXplIGFsbCBSeCBkZXNjcmlwdG9ycy4gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L25ldHhlbi9uZXR4ZW5fbmljX2hkci5oIGIvZHJpdmVycy9uZXQvbmV0eGVuL25ldHhlbl9uaWNfaGRyLmgKaW5kZXggZDhiZDczZC4uZGMxOTY3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbmV0eGVuL25ldHhlbl9uaWNfaGRyLmgKKysrIGIvZHJpdmVycy9uZXQvbmV0eGVuL25ldHhlbl9uaWNfaGRyLmgKQEAgLTc4MCw3ICs3ODAsNyBAQAogCiAvKgogICogY2FwYWJpbGl0aWVzIHJlZ2lzdGVyLCBjYW4gYmUgdXNlZCB0byBzZWxlY3RpdmVseSBlbmFibGUvZGlzYWJsZSBmZWF0dXJlcwotICogZm9yIGJhY2t3YXJkIGNvbXBhYmlsaXR5CisgKiBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eQogICovCiAjZGVmaW5lIENSQl9OSUNfQ0FQQUJJTElUSUVTX0hPU1QJTkVUWEVOX05JQ19SRUcoMHgxYTgpCiAjZGVmaW5lIENSQl9OSUNfTVNJX01PREVfSE9TVAkJTkVUWEVOX05JQ19SRUcoMHgyNzApCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9uczgzODIwLmMgYi9kcml2ZXJzL25ldC9uczgzODIwLmMKaW5kZXggYTQxYjJjZi4uNjY2N2UwNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbnM4MzgyMC5jCisrKyBiL2RyaXZlcnMvbmV0L25zODM4MjAuYwpAQCAtNTEyLDcgKzUxMiw3IEBACiAvKiBQYWNrZXQgUmVjZWl2ZXIKICAqCiAgKiBUaGUgaGFyZHdhcmUgc3VwcG9ydHMgbGlua2VkIGxpc3RzIG9mIHJlY2VpdmUgZGVzY3JpcHRvcnMgZm9yCi0gKiB3aGljaCBvd25lcnNoaXAgaXMgdHJhbnNmZXJlZCBiYWNrIGFuZCBmb3J0aCBieSBtZWFucyBvZiBhbgorICogd2hpY2ggb3duZXJzaGlwIGlzIHRyYW5zZmVycmVkIGJhY2sgYW5kIGZvcnRoIGJ5IG1lYW5zIG9mIGFuCiAgKiBvd25lcnNoaXAgYml0LiAgV2hpbGUgdGhlIGhhcmR3YXJlIGRvZXMgc3VwcG9ydCB0aGUgdXNlIG9mIGEKICAqIHJpbmcgZm9yIHJlY2VpdmUgZGVzY3JpcHRvcnMsIHdlIG9ubHkgbWFrZSB1c2Ugb2YgYSBjaGFpbiBpbgogICogYW4gYXR0ZW1wdCB0byByZWR1Y2UgYnVzIHRyYWZmaWMgdW5kZXIgaGVhdnkgbG9hZCBzY2VuYXJpb3MuCkBAIC0xMTQ3LDcgKzExNDcsNyBAQAogI2lmZGVmIE5TODM4MjBfVkxBTl9BQ0NFTF9TVVBQT1JUCiAJaWYodmxhbl90eF90YWdfcHJlc2VudChza2IpKSB7CiAJCS8qIGZldGNoIHRoZSB2bGFuIHRhZyBpbmZvIG91dCBvZiB0aGUKLQkJICogYW5jaWxsaWFyeSBkYXRhIGlmIHRoZSB2bGFuIGNvZGUKKwkJICogYW5jaWxsYXJ5IGRhdGEgaWYgdGhlIHZsYW4gY29kZQogCQkgKiBpcyB1c2luZyBodyB2bGFuIGFjY2VsZXJhdGlvbgogCQkgKi8KIAkJc2hvcnQgdGFnID0gdmxhbl90eF90YWdfZ2V0KHNrYik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wY2hfZ2JlL3BjaF9nYmUuaCBiL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZS5oCmluZGV4IGUxZTMzYzguLmJmMTI2ZTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZS5oCisrKyBiL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZS5oCkBAIC0zNTEsNyArMzUxLDcgQEAKIH07CiAKIC8qKgotICogc3RydWN0IHBjaF9nYmVfbWFjX2luZm8gLSBNQUMgaW5mb21hdGlvbgorICogc3RydWN0IHBjaF9nYmVfbWFjX2luZm8gLSBNQUMgaW5mb3JtYXRpb24KICAqIEBhZGRyWzZdOgkJU3RvcmUgdGhlIE1BQyBhZGRyZXNzCiAgKiBAZmM6CQkJTW9kZSBvZiBmbG93IGNvbnRyb2wKICAqIEBmY19hdXRvbmVnOgkJQXV0byBuZWdvdGlhdGlvbiBlbmFibGUgZm9yIGZsb3cgY29udHJvbCBzZXR0aW5nCkBAIC0zNzUsNyArMzc1LDcgQEAKIH07CiAKIC8qKgotICogc3RydWN0IHBjaF9nYmVfcGh5X2luZm8gLSBQSFkgaW5mb21hdGlvbgorICogc3RydWN0IHBjaF9nYmVfcGh5X2luZm8gLSBQSFkgaW5mb3JtYXRpb24KICAqIEBhZGRyOgkJUEhZIGFkZHJlc3MKICAqIEBpZDoJCQlQSFkncyBpZGVudGlmaWVyCiAgKiBAcmV2aXNpb246CQlQSFkncyByZXZpc2lvbgpAQCAtMzkzLDcgKzM5Myw3IEBACiAvKiEKICAqIEBpbmdyb3VwIEdpZ2FiaXQgRXRoZXIgZHJpdmVyIExheWVyCiAgKiBAc3RydWN0ICBwY2hfZ2JlX2J1c19pbmZvCi0gKiBAYnJpZWYgICBCdXMgaW5mb21hdGlvbgorICogQGJyaWVmICAgQnVzIGluZm9ybWF0aW9uCiAgKi8KIHN0cnVjdCBwY2hfZ2JlX2J1c19pbmZvIHsKIAl1OCB0eXBlOwpAQCAtNDA0LDcgKzQwNCw3IEBACiAvKiEKICAqIEBpbmdyb3VwIEdpZ2FiaXQgRXRoZXIgZHJpdmVyIExheWVyCiAgKiBAc3RydWN0ICBwY2hfZ2JlX2h3Ci0gKiBAYnJpZWYgICBIYXJkd2FyZSBpbmZvbWF0aW9uCisgKiBAYnJpZWYgICBIYXJkd2FyZSBpbmZvcm1hdGlvbgogICovCiBzdHJ1Y3QgcGNoX2diZV9odyB7CiAJdm9pZCAqYmFjazsKQEAgLTQ2Miw3ICs0NjIsNyBAQAogCiAKIC8qKgotICogc3RydWN0IHBjaF9nYmVfYnVmZmVyIC0gQnVmZmVyIGluZm9tYXRpb24KKyAqIHN0cnVjdCBwY2hfZ2JlX2J1ZmZlciAtIEJ1ZmZlciBpbmZvcm1hdGlvbgogICogQHNrYjoJcG9pbnRlciB0byBhIHNvY2tldCBidWZmZXIKICAqIEBkbWE6CURNQSBhZGRyZXNzCiAgKiBAdGltZV9zdGFtcDoJdGltZSBzdGFtcApAQCAtNDc3LDcgKzQ3Nyw3IEBACiB9OwogCiAvKioKLSAqIHN0cnVjdCBwY2hfZ2JlX3R4X3JpbmcgLSB0eCByaW5nIGluZm9tYXRpb24KKyAqIHN0cnVjdCBwY2hfZ2JlX3R4X3JpbmcgLSB0eCByaW5nIGluZm9ybWF0aW9uCiAgKiBAdHhfbG9jazoJc3BpbmxvY2sgc3RydWN0cwogICogQGRlc2M6CXBvaW50ZXIgdG8gdGhlIGRlc2NyaXB0b3IgcmluZyBtZW1vcnkKICAqIEBkbWE6CXBoeXNpY2FsIGFkZHJlc3Mgb2YgdGhlIGRlc2NyaXB0b3IgcmluZwpAQCAtNDk5LDcgKzQ5OSw3IEBACiB9OwogCiAvKioKLSAqIHN0cnVjdCBwY2hfZ2JlX3J4X3JpbmcgLSByeCByaW5nIGluZm9tYXRpb24KKyAqIHN0cnVjdCBwY2hfZ2JlX3J4X3JpbmcgLSByeCByaW5nIGluZm9ybWF0aW9uCiAgKiBAZGVzYzoJcG9pbnRlciB0byB0aGUgZGVzY3JpcHRvciByaW5nIG1lbW9yeQogICogQGRtYToJcGh5c2ljYWwgYWRkcmVzcyBvZiB0aGUgZGVzY3JpcHRvciByaW5nCiAgKiBAc2l6ZToJbGVuZ3RoIG9mIGRlc2NyaXB0b3IgcmluZyBpbiBieXRlcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGNoX2diZS9wY2hfZ2JlX2V0aHRvb2wuYyBiL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZV9ldGh0b29sLmMKaW5kZXggYzhjODczYi4uZDIxNzRhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGNoX2diZS9wY2hfZ2JlX2V0aHRvb2wuYworKysgYi9kcml2ZXJzL25ldC9wY2hfZ2JlL3BjaF9nYmVfZXRodG9vbC5jCkBAIC0yMSw3ICsyMSw3IEBACiAjaW5jbHVkZSAicGNoX2diZV9hcGkuaCIKIAogLyoqCi0gKiBwY2hfZ2JlX3N0YXRzIC0gU3RhdHMgaXRlbSBpbmZvbWF0aW9uCisgKiBwY2hfZ2JlX3N0YXRzIC0gU3RhdHMgaXRlbSBpbmZvcm1hdGlvbgogICovCiBzdHJ1Y3QgcGNoX2diZV9zdGF0cyB7CiAJY2hhciBzdHJpbmdbRVRIX0dTVFJJTkdfTEVOXTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZV9tYWluLmMgYi9kcml2ZXJzL25ldC9wY2hfZ2JlL3BjaF9nYmVfbWFpbi5jCmluZGV4IDUwOTg2ODQuLjJlZjJmOWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZV9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvcGNoX2diZS9wY2hfZ2JlX21haW4uYwpAQCAtMTAxMSw3ICsxMDExLDcgQEAKIAl0bXBfc2tiLT5sZW4gPSBza2ItPmxlbjsKIAltZW1jcHkoJnRtcF9za2ItPmRhdGFbRVRIX0hMRU4gKyAyXSwgJnNrYi0+ZGF0YVtFVEhfSExFTl0sCiAJICAgICAgIChza2ItPmxlbiAtIEVUSF9ITEVOKSk7Ci0JLyotLSBTZXQgQnVmZmVyIGluZm9tYXRpb24gLS0qLworCS8qLS0gU2V0IEJ1ZmZlciBpbmZvcm1hdGlvbiAtLSovCiAJYnVmZmVyX2luZm8tPmxlbmd0aCA9IHRtcF9za2ItPmxlbjsKIAlidWZmZXJfaW5mby0+ZG1hID0gZG1hX21hcF9zaW5nbGUoJmFkYXB0ZXItPnBkZXYtPmRldiwgdG1wX3NrYi0+ZGF0YSwKIAkJCQkJICBidWZmZXJfaW5mby0+bGVuZ3RoLApAQCAtMTU0MCw3ICsxNTQwLDcgQEAKIAlzaXplID0gKGludClzaXplb2Yoc3RydWN0IHBjaF9nYmVfYnVmZmVyKSAqIHR4X3JpbmctPmNvdW50OwogCXR4X3JpbmctPmJ1ZmZlcl9pbmZvID0gdnphbGxvYyhzaXplKTsKIAlpZiAoIXR4X3JpbmctPmJ1ZmZlcl9pbmZvKSB7Ci0JCXByX2VycigiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgdGhlIGJ1ZmZlciBpbmZvbWF0aW9uXG4iKTsKKwkJcHJfZXJyKCJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciB0aGUgYnVmZmVyIGluZm9ybWF0aW9uXG4iKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wY2ktc2tlbGV0b24uYyBiL2RyaXZlcnMvbmV0L3BjaS1za2VsZXRvbi5jCmluZGV4IDE3NjZkYzQuLmMwZjIzMzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BjaS1za2VsZXRvbi5jCisrKyBiL2RyaXZlcnMvbmV0L3BjaS1za2VsZXRvbi5jCkBAIC0yMTQsNyArMjE0LDcgQEAKIAl7ICJTTUMxMjExVFggRVpDYXJkIDEwLzEwMCAoUmVhbFRlayBSVEw4MTM5KSIgfSwKIC8qCXsgTVBYNTAzMCwgIkFjY3RvbiBNUFg1MDMwIChSZWFsVGVrIFJUTDgxMzkpIiB9LCovCiAJeyAiRGVsdGEgRWxlY3Ryb25pY3MgODEzOSAxMC8xMDBCYXNlVFgiIH0sCi0JeyAiQWRkdHJvbiBUZWNobm9sZ3kgODEzOSAxMC8xMDBCYXNlVFgiIH0sCisJeyAiQWRkdHJvbiBUZWNobm9sb2d5IDgxMzkgMTAvMTAwQmFzZVRYIiB9LAogfTsKIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wY21jaWEvM2M1NzRfY3MuYyBiL2RyaXZlcnMvbmV0L3BjbWNpYS8zYzU3NF9jcy5jCmluZGV4IDMyMWIxMmYuLjgxYWMzMzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BjbWNpYS8zYzU3NF9jcy5jCisrKyBiL2RyaXZlcnMvbmV0L3BjbWNpYS8zYzU3NF9jcy5jCkBAIC05NTAsNyArOTUwLDcgQEAKIH0KIAogLyogIFVwZGF0ZSBzdGF0aXN0aWNzLgotCVN1cHJpc2luZ2x5IHRoaXMgbmVlZCBub3QgYmUgcnVuIHNpbmdsZS10aHJlYWRlZCwgYnV0IGl0IGVmZmVjdGl2ZWx5IGlzLgorCVN1cnByaXNpbmdseSB0aGlzIG5lZWQgbm90IGJlIHJ1biBzaW5nbGUtdGhyZWFkZWQsIGJ1dCBpdCBlZmZlY3RpdmVseSBpcy4KIAlUaGUgY291bnRlcnMgY2xlYXIgd2hlbiByZWFkLCBzbyB0aGUgYWRkcyBtdXN0IG1lcmVseSBiZSBhdG9taWMuCiAgKi8KIHN0YXRpYyB2b2lkIHVwZGF0ZV9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGNtY2lhL2F4bmV0X2NzLmMgYi9kcml2ZXJzL25ldC9wY21jaWEvYXhuZXRfY3MuYwppbmRleCBkM2NiNzcyLi4zMDc3ZDcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9wY21jaWEvYXhuZXRfY3MuYworKysgYi9kcml2ZXJzL25ldC9wY21jaWEvYXhuZXRfY3MuYwpAQCAtNzgwLDcgKzc4MCw3IEBACiAgIEFsZXhleSBLdXpuZXRzb3YJOiB1c2UgdGhlIDgzOTAncyBzaXggYml0IGhhc2ggbXVsdGljYXN0IGZpbHRlci4KICAgUGF1bCBHb3J0bWFrZXIJOiB0d2VhayBBTksncyBhYm92ZSBtdWx0aWNhc3QgY2hhbmdlcyBhIGJpdC4KICAgUGF1bCBHb3J0bWFrZXIJOiB1cGRhdGUgcGFja2V0IHN0YXRpc3RpY3MgZm9yIHYyLjEueAotICBBbGFuIENveAkJOiBzdXBwb3J0IGFyYml0YXJ5IHN0dXBpZCBwb3J0IG1hcHBpbmdzIG9uIHRoZQorICBBbGFuIENveAkJOiBzdXBwb3J0IGFyYml0cmFyeSBzdHVwaWQgcG9ydCBtYXBwaW5ncyBvbiB0aGUKICAgCQkJICA2OEsgTWFjaW50b3NoLiBTdXBwb3J0ID4xNmJpdCBJL08gc3BhY2VzCiAgIFBhdWwgR29ydG1ha2VyCTogYWRkIGttb2Qgc3VwcG9ydCBmb3IgYXV0by1sb2FkaW5nIG9mIHRoZSA4MzkwCiAJCQkgIG1vZHVsZSBieSBhbGwgZHJpdmVycyB0aGF0IHJlcXVpcmUgaXQuCkBAIC04NDIsNyArODQyLDcgQEAKIC8qCiAgKglTTVAgYW5kIHRoZSA4MzkwIHNldHVwLgogICoKLSAqCVRoZSA4MzkwIGlzbnQgZXhhY3RseSBkZXNpZ25lZCB0byBiZSBtdWx0aXRocmVhZGVkIG9uIFJYL1RYLiBUaGVyZSBpcworICoJVGhlIDgzOTAgaXNuJ3QgZXhhY3RseSBkZXNpZ25lZCB0byBiZSBtdWx0aXRocmVhZGVkIG9uIFJYL1RYLiBUaGVyZSBpcwogICoJYSBwYWdlIHJlZ2lzdGVyIHRoYXQgY29udHJvbHMgYmFuayBhbmQgcGFja2V0IGJ1ZmZlciBhY2Nlc3MuIFdlIGd1YXJkCiAgKgl0aGlzIHdpdGggZWlfbG9jYWwtPnBhZ2VfbG9jay4gTm9ib2R5IHNob3VsZCBhc3N1bWUgb3Igc2V0IHRoZSBwYWdlIG90aGVyCiAgKgl0aGFuIHplcm8gd2hlbiB0aGUgbG9jayBpcyBub3QgaGVsZC4gTG9jayBob2xkZXJzIG11c3QgcmVzdG9yZSBwYWdlIDAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3BjbWNpYS9zbWM5MWM5Ml9jcy5jIGIvZHJpdmVycy9uZXQvcGNtY2lhL3NtYzkxYzkyX2NzLmMKaW5kZXggOGE5ZmY1My4uMTA4NTkxNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGNtY2lhL3NtYzkxYzkyX2NzLmMKKysrIGIvZHJpdmVycy9uZXQvcGNtY2lhL3NtYzkxYzkyX2NzLmMKQEAgLTEyNjQsNyArMTI2NCw3IEBACiAKIC8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogCi0gICAgSGFuZGxlIGEgVHggYW5vbW9sb3VzIGV2ZW50LiAgRW50ZXJlZCB3aGlsZSBpbiBXaW5kb3cgMi4KKyAgICBIYW5kbGUgYSBUeCBhbm9tYWxvdXMgZXZlbnQuICBFbnRlcmVkIHdoaWxlIGluIFdpbmRvdyAyLgogCiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGNuZXQzMi5jIGIvZHJpdmVycy9uZXQvcGNuZXQzMi5jCmluZGV4IGFlZTNiYjAuLjc2ODAzNzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BjbmV0MzIuYworKysgYi9kcml2ZXJzL25ldC9wY25ldDMyLmMKQEAgLTE2NTEsNyArMTY1MSw3IEBACiAJLyoKIAkgKiAgT24gc2VsZWN0ZWQgY2hpcHMgdHVybiBvbiB0aGUgQkNSMTg6Tk9VRkxPIGJpdC4gVGhpcyBzdG9wcyB0cmFuc21pdAogCSAqICBzdGFydGluZyB1bnRpbCB0aGUgcGFja2V0IGlzIGxvYWRlZC4gU3RyaWtlIG9uZSBmb3IgcmVsaWFiaWxpdHksIGxvc2UKLQkgKiAgb25lIGZvciBsYXRlbmN5IC0gYWx0aG91Z2ggb24gUENJIHRoaXMgaXNudCBhIGJpZyBsb3NzLiBPbGRlciBjaGlwcworCSAqICBvbmUgZm9yIGxhdGVuY3kgLSBhbHRob3VnaCBvbiBQQ0kgdGhpcyBpc24ndCBhIGJpZyBsb3NzLiBPbGRlciBjaGlwcwogCSAqICBoYXZlIEZJRk8ncyBzbWFsbGVyIHRoYW4gYSBwYWNrZXQsIHNvIHlvdSBjYW4ndCBkbyB0aGlzLgogCSAqICBUdXJuIG9uIEJDUjE4OkJ1cnN0UmRFbiBhbmQgQkNSMTg6QnVyc3RXckVuLgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGh5L3BoeV9kZXZpY2UuYyBiL2RyaXZlcnMvbmV0L3BoeS9waHlfZGV2aWNlLmMKaW5kZXggZTg3MGMwNi4uZmYxMDlmZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGh5L3BoeV9kZXZpY2UuYworKysgYi9kcml2ZXJzL25ldC9waHkvcGh5X2RldmljZS5jCkBAIC01MzgsNyArNTM4LDcgQEAKIC8qIEdlbmVyaWMgUEhZIHN1cHBvcnQgYW5kIGhlbHBlciBmdW5jdGlvbnMgKi8KIAogLyoqCi0gKiBnZW5waHlfY29uZmlnX2FkdmVydCAtIHNhbml0aXplIGFuZCBhZHZlcnRpc2UgYXV0by1uZWdvdGF0aW9uIHBhcmFtZXRlcnMKKyAqIGdlbnBoeV9jb25maWdfYWR2ZXJ0IC0gc2FuaXRpemUgYW5kIGFkdmVydGlzZSBhdXRvLW5lZ290aWF0aW9uIHBhcmFtZXRlcnMKICAqIEBwaHlkZXY6IHRhcmdldCBwaHlfZGV2aWNlIHN0cnVjdAogICoKICAqIERlc2NyaXB0aW9uOiBXcml0ZXMgTUlJX0FEVkVSVElTRSB3aXRoIHRoZSBhcHByb3ByaWF0ZSB2YWx1ZXMsCkBAIC02ODcsNyArNjg3LDcgQEAKIAkJcmV0dXJuIHJlc3VsdDsKIAogCWlmIChyZXN1bHQgPT0gMCkgewotCQkvKiBBZHZlcnRpc21lbnQgaGFzbid0IGNoYW5nZWQsIGJ1dCBtYXliZSBhbmVnIHdhcyBuZXZlciBvbiB0bworCQkvKiBBZHZlcnRpc2VtZW50IGhhc24ndCBjaGFuZ2VkLCBidXQgbWF5YmUgYW5lZyB3YXMgbmV2ZXIgb24gdG8KIAkJICogYmVnaW4gd2l0aD8gIE9yIG1heWJlIHBoeSB3YXMgaXNvbGF0ZWQ/ICovCiAJCWludCBjdGwgPSBwaHlfcmVhZChwaHlkZXYsIE1JSV9CTUNSKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcHBwX2dlbmVyaWMuYyBiL2RyaXZlcnMvbmV0L3BwcF9nZW5lcmljLmMKaW5kZXggOWY2ZDY3MC4uNDYwOWJjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcHBwX2dlbmVyaWMuYworKysgYi9kcml2ZXJzL25ldC9wcHBfZ2VuZXJpYy5jCkBAIC0xNDQ4LDcgKzE0NDgsNyBAQAogCiAJCS8qCiAJCSAqY2hlY2sgaWYgd2UgYXJlIG9uIHRoZSBsYXN0IGNoYW5uZWwgb3IKLQkJICp3ZSBleGNlZGVkIHRoZSBsZW5naHQgb2YgdGhlIGRhdGEgdG8KKwkJICp3ZSBleGNlZGVkIHRoZSBsZW5ndGggb2YgdGhlIGRhdGEgdG8KIAkJICpmcmFnbWVudAogCQkgKi8KIAkJaWYgKChuZnJlZSA8PSAwKSB8fCAoZmxlbiA+IGxlbikpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wcHBfc3luY3R0eS5jIGIvZHJpdmVycy9uZXQvcHBwX3N5bmN0dHkuYwppbmRleCA0ZTZiNzJmLi4yNTczZjUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9wcHBfc3luY3R0eS5jCisrKyBiL2RyaXZlcnMvbmV0L3BwcF9zeW5jdHR5LmMKQEAgLTE3OCw3ICsxNzgsNyBAQAogICogd2F5IHRvIGZpeCB0aGlzIGlzIHRvIHVzZSBhIHJ3bG9jayBpbiB0aGUgdHR5IHN0cnVjdCwgYnV0IGZvciBub3cKICAqIHdlIHVzZSBhIHNpbmdsZSBnbG9iYWwgcndsb2NrIGZvciBhbGwgdHR5cyBpbiBwcHAgbGluZSBkaXNjaXBsaW5lLgogICoKLSAqIEZJWE1FOiBGaXhlZCBpbiB0dHlfaW8gbm93ZGF5cy4KKyAqIEZJWE1FOiBGaXhlZCBpbiB0dHlfaW8gbm93YWRheXMuCiAgKi8KIHN0YXRpYyBERUZJTkVfUldMT0NLKGRpc2NfZGF0YV9sb2NrKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcHBwb2UuYyBiL2RyaXZlcnMvbmV0L3BwcG9lLmMKaW5kZXggNzhjMGUzYy4uNzE4ODc5YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcHBwb2UuYworKysgYi9kcml2ZXJzL25ldC9wcHBvZS5jCkBAIC0xMTUsNyArMTE1LDcgQEAKICAqIDIpIFNlc3Npb24gc3RhZ2UgKE1BQyBhbmQgU0lEIGFyZSBrbm93bikKICAqCiAgKiBFdGhlcm5ldCBmcmFtZXMgaGF2ZSBhIHNwZWNpYWwgdGFnIGZvciB0aGlzIGJ1dAotICogd2UgdXNlIHNpbXBsaWVyIGFwcHJvYWNoIGJhc2VkIG9uIHNlc3Npb24gaWQKKyAqIHdlIHVzZSBzaW1wbGVyIGFwcHJvYWNoIGJhc2VkIG9uIHNlc3Npb24gaWQKICAqLwogc3RhdGljIGlubGluZSBib29sIHN0YWdlX3Nlc3Npb24oX19iZTE2IHNpZCkKIHsKQEAgLTMxNyw3ICszMTcsNyBAQAogCQkJbG9ja19zb2NrKHNrKTsKIAogCQkJaWYgKHBvLT5wcHBvZV9kZXYgPT0gZGV2ICYmCi0JCQkgICAgc2stPnNrX3N0YXRlICYgKFBQUE9YX0NPTk5FQ1RFRCB8IFBQUE9YX0JPVU5EKSkgeworCQkJICAgIHNrLT5za19zdGF0ZSAmIChQUFBPWF9DT05ORUNURUQgfCBQUFBPWF9CT1VORCB8IFBQUE9YX1pPTUJJRSkpIHsKIAkJCQlwcHBveF91bmJpbmRfc29jayhzayk7CiAJCQkJc2stPnNrX3N0YXRlID0gUFBQT1hfWk9NQklFOwogCQkJCXNrLT5za19zdGF0ZV9jaGFuZ2Uoc2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcHMzX2dlbGljX25ldC5jIGIvZHJpdmVycy9uZXQvcHMzX2dlbGljX25ldC5jCmluZGV4IDVlY2ZhNGIuLmZmZGY3MzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BzM19nZWxpY19uZXQuYworKysgYi9kcml2ZXJzL25ldC9wczNfZ2VsaWNfbmV0LmMKQEAgLTYzMiw3ICs2MzIsNyBAQAogICogQGNhcmQ6IGNhcmQgc3RydWN0dXJlCiAgKgogICogZ2VsaWNfY2FyZF9kaXNhYmxlX3J4ZG1hYyB0ZXJtaW5hdGVzIHByb2Nlc3Npbmcgb24gdGhlIERNQSBjb250cm9sbGVyIGJ5Ci0gKiB0dXJpbmcgb2ZmIERNQSBhbmQgaXNzdWVpbmcgYSBmb3JjZSBlbmQKKyAqIHR1cmluZyBvZmYgRE1BIGFuZCBpc3N1aW5nIGEgZm9yY2UgZW5kCiAgKi8KIHN0YXRpYyBpbmxpbmUgdm9pZCBnZWxpY19jYXJkX2Rpc2FibGVfcnhkbWFjKHN0cnVjdCBnZWxpY19jYXJkICpjYXJkKQogewpAQCAtNjUwLDcgKzY1MCw3IEBACiAgKiBAY2FyZDogY2FyZCBzdHJ1Y3R1cmUKICAqCiAgKiBnZWxpY19jYXJkX2Rpc2FibGVfdHhkbWFjIHRlcm1pbmF0ZXMgcHJvY2Vzc2luZyBvbiB0aGUgRE1BIGNvbnRyb2xsZXIgYnkKLSAqIHR1cmluZyBvZmYgRE1BIGFuZCBpc3N1ZWluZyBhIGZvcmNlIGVuZAorICogdHVyaW5nIG9mZiBETUEgYW5kIGlzc3VpbmcgYSBmb3JjZSBlbmQKICAqLwogc3RhdGljIGlubGluZSB2b2lkIGdlbGljX2NhcmRfZGlzYWJsZV90eGRtYWMoc3RydWN0IGdlbGljX2NhcmQgKmNhcmQpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wczNfZ2VsaWNfbmV0LmggYi9kcml2ZXJzL25ldC9wczNfZ2VsaWNfbmV0LmgKaW5kZXggMzI1MjFhZS4uZmFkYWRmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcHMzX2dlbGljX25ldC5oCisrKyBiL2RyaXZlcnMvbmV0L3BzM19nZWxpY19uZXQuaApAQCAtMTE3LDcgKzExNyw3IEBACiAJR0VMSUNfREVTQ1JfUlhEQVRBRVJSCT0gMHgwMDAyMDAwMCwgLyogSVAgcGFja2V0IGZvcm1hdCBlcnJvciAqLwogCUdFTElDX0RFU0NSX1JYQ0FMRVJSCT0gMHgwMDAxMDAwMCwgLyogY2FyaWllciBleHRlbnNpb24gbGVuZ3RoCiAJCQkJCSAgICAgICogZXJyb3IgKi8KLQlHRUxJQ19ERVNDUl9SWENSRVhFUlIJPSAweDAwMDA4MDAwLCAvKiBjYXJyaWVyIGV4dGVudGlvbiBlcnJvciAqLworCUdFTElDX0RFU0NSX1JYQ1JFWEVSUgk9IDB4MDAwMDgwMDAsIC8qIGNhcnJpZXIgZXh0ZW5zaW9uIGVycm9yICovCiAJR0VMSUNfREVTQ1JfUlhNTFRDU1QJPSAweDAwMDA0MDAwLCAvKiBtdWx0aWNhc3QgYWRkcmVzcyBmcmFtZSAqLwogCS8qIGJpdCAxMy4uMCByZXNlcnZlZCAqLwogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3BzM19nZWxpY193aXJlbGVzcy5jIGIvZHJpdmVycy9uZXQvcHMzX2dlbGljX3dpcmVsZXNzLmMKaW5kZXggNGE2MjRhMi4uYjVhZTI5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcHMzX2dlbGljX3dpcmVsZXNzLmMKKysrIGIvZHJpdmVycy9uZXQvcHMzX2dlbGljX3dpcmVsZXNzLmMKQEAgLTgxNCw3ICs4MTQsNyBAQAogCQkJICogeW91IHdpbGwgbm90IGRlY2lkZSBzdWl0YWJsZSBjaXBoZXIgZnJvbQogCQkJICogaXRzIGJlYWNvbi4KIAkJCSAqIFlvdSBzaG91bGQgaGF2ZSBrbm93bGVkZ2UgYWJvdXQgdGhlIEFQJ3MKLQkJCSAqIGNpcGhlciBpbmZvbWF0aW9uIGluIG90aGVyIG1ldGhvZCBwcmlvciB0bworCQkJICogY2lwaGVyIGluZm9ybWF0aW9uIGluIG90aGVyIG1ldGhvZCBwcmlvciB0bwogCQkJICogdGhlIGFzc29jaWF0aW9uLgogCQkJICovCiAJCQlpZiAoIXByZWNpc2VfaWUoKSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3B4YTE2OF9ldGguYyBiL2RyaXZlcnMvbmV0L3B4YTE2OF9ldGguYwppbmRleCAxYjYzYzhhLi44OWY3NTQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9weGExNjhfZXRoLmMKKysrIGIvZHJpdmVycy9uZXQvcHhhMTY4X2V0aC5jCkBAIC00NjIsNyArNDYyLDcgQEAKICAqIHBlcCAtIEVUSEVSTkVUIC4KICAqIG1hY19hZGRyIC0gTUFDIGFkZHJlc3MuCiAgKiBza2lwIC0gaWYgMSwgc2tpcCB0aGlzIGFkZHJlc3MuVXNlZCBpbiBjYXNlIG9mIGRlbGV0aW5nIGFuIGVudHJ5IHdoaWNoIGlzIGEKLSAqCSAgcGFydCBvZiBjaGFpbiBpbiB0aGUgaGFzaCB0YWJsZS5XZSBjYW50IGp1c3QgZGVsZXRlIHRoZSBlbnRyeSBzaW5jZQorICoJICBwYXJ0IG9mIGNoYWluIGluIHRoZSBoYXNoIHRhYmxlLldlIGNhbid0IGp1c3QgZGVsZXRlIHRoZSBlbnRyeSBzaW5jZQogICoJICB0aGF0IHdpbGwgYnJlYWsgdGhlIGNoYWluLldlIG5lZWQgdG8gZGVmcmFnbWVudCB0aGUgdGFibGVzIHRpbWUgdG8KICAqCSAgdGltZS4KICAqIHJkICAgLSAwIERpc2NhcmQgcGFja2V0IHVwb24gbWF0Y2guCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9xbGEzeHh4LmggYi9kcml2ZXJzL25ldC9xbGEzeHh4LmgKaW5kZXggMzM2MmE2Ni4uNzNlMjM0MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcWxhM3h4eC5oCisrKyBiL2RyaXZlcnMvbmV0L3FsYTN4eHguaApAQCAtNzcwLDcgKzc3MCw3IEBACiAJRk05M0M1NkFfV0RTID0gMHgwLAogCUZNOTNDNTZBX0VSQVNFID0gMHgzLAogCUZNOTNDNTZBX0VSQVNFX0FMTCA9IDB4MCwKLS8qIENvbW1hbmQgRXh0ZW50aW9ucyAqLworLyogQ29tbWFuZCBFeHRlbnNpb25zICovCiAJRk05M0M1NkFfV0VOX0VYVCA9IDB4MywKIAlGTTkzQzU2QV9XUklURV9BTExfRVhUID0gMHgxLAogCUZNOTNDNTZBX1dEU19FWFQgPSAweDAsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9xbGdlL3FsZ2VfbWFpbi5jIGIvZHJpdmVycy9uZXQvcWxnZS9xbGdlX21haW4uYwppbmRleCA0OWJmYTU4Li41YmIzMTE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9xbGdlL3FsZ2VfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3FsZ2UvcWxnZV9tYWluLmMKQEAgLTY2MCw3ICs2NjAsNyBAQAogLyogSWYgd2UncmUgcnVubmluZyB3aXRoIG11bHRpcGxlIE1TSS1YIHZlY3RvcnMgdGhlbiB3ZSBlbmFibGUgb24gdGhlIGZseS4KICAqIE90aGVyd2lzZSwgd2UgbWF5IGhhdmUgbXVsdGlwbGUgb3V0c3RhbmRpbmcgd29ya2VycyBhbmQgZG9uJ3Qgd2FudCB0bwogICogZW5hYmxlIHVudGlsIHRoZSBsYXN0IG9uZSBmaW5pc2hlcy4gSW4gdGhpcyBjYXNlLCB0aGUgaXJxX2NudCBnZXRzCi0gKiBpbmNyZW1lbnRlZCBldmVyeXRpbWUgd2UgcXVldWUgYSB3b3JrZXIgYW5kIGRlY3JlbWVudGVkIGV2ZXJ5dGltZQorICogaW5jcmVtZW50ZWQgZXZlcnkgdGltZSB3ZSBxdWV1ZSBhIHdvcmtlciBhbmQgZGVjcmVtZW50ZWQgZXZlcnkgdGltZQogICogYSB3b3JrZXIgZmluaXNoZXMuICBPbmNlIGl0IGhpdHMgemVybyB3ZSBlbmFibGUgdGhlIGludGVycnVwdC4KICAqLwogdTMyIHFsX2VuYWJsZV9jb21wbGV0aW9uX2ludGVycnVwdChzdHJ1Y3QgcWxfYWRhcHRlciAqcWRldiwgdTMyIGludHIpCkBAIC0zMjk5LDcgKzMyOTksNyBAQAogICogd2lsbCBzZXJ2aWNlIGl0LiAgQW4gZXhhbXBsZSB3b3VsZCBiZSBpZiB0aGVyZSBhcmUKICAqIDIgdmVjdG9ycyAoc28gMiBSU1MgcmluZ3MpIGFuZCA4IFRYIGNvbXBsZXRpb24gcmluZ3MuCiAgKiBUaGlzIHdvdWxkIG1lYW4gdGhhdCB2ZWN0b3IgMCB3b3VsZCBzZXJ2aWNlIFJTUyByaW5nIDAKLSAqIGFuZCBUWCBjb21wZXRpb24gcmluZ3MgMCwxLDIgYW5kIDMuICBWZWN0b3IgMSB3b3VsZAorICogYW5kIFRYIGNvbXBsZXRpb24gcmluZ3MgMCwxLDIgYW5kIDMuICBWZWN0b3IgMSB3b3VsZAogICogc2VydmljZSBSU1MgcmluZyAxIGFuZCBUWCBjb21wbGV0aW9uIHJpbmdzIDQsNSw2IGFuZCA3LgogICovCiBzdGF0aWMgdm9pZCBxbF9zZXRfdHhfdmVjdChzdHJ1Y3QgcWxfYWRhcHRlciAqcWRldikKQEAgLTQxNTIsNyArNDE1Miw3IEBACiAJaW50IGksIHN0YXR1czsKIAl1MzIgbGJxX2J1Zl9sZW47CiAKLQkvKiBXYWl0IGZvciBhbiBvdXN0YW5kaW5nIHJlc2V0IHRvIGNvbXBsZXRlLiAqLworCS8qIFdhaXQgZm9yIGFuIG91dHN0YW5kaW5nIHJlc2V0IHRvIGNvbXBsZXRlLiAqLwogCWlmICghdGVzdF9iaXQoUUxfQURBUFRFUl9VUCwgJnFkZXYtPmZsYWdzKSkgewogCQlpbnQgaSA9IDM7CiAJCXdoaWxlIChpLS0gJiYgIXRlc3RfYml0KFFMX0FEQVBURVJfVVAsICZxZGV2LT5mbGFncykpIHsKQEAgLTQyODEsNyArNDI4MSw3IEBACiAJCQlpZiAocWxfc2V0X3JvdXRpbmdfcmVnCiAJCQkgICAgKHFkZXYsIFJUX0lEWF9QUk9NSVNDVU9VU19TTE9ULCBSVF9JRFhfVkFMSUQsIDEpKSB7CiAJCQkJbmV0aWZfZXJyKHFkZXYsIGh3LCBxZGV2LT5uZGV2LAotCQkJCQkgICJGYWlsZWQgdG8gc2V0IHByb21pc2NvdXMgbW9kZS5cbiIpOworCQkJCQkgICJGYWlsZWQgdG8gc2V0IHByb21pc2N1b3VzIG1vZGUuXG4iKTsKIAkJCX0gZWxzZSB7CiAJCQkJc2V0X2JpdChRTF9QUk9NSVNDVU9VUywgJnFkZXYtPmZsYWdzKTsKIAkJCX0KQEAgLTQyOTEsNyArNDI5MSw3IEBACiAJCQlpZiAocWxfc2V0X3JvdXRpbmdfcmVnCiAJCQkgICAgKHFkZXYsIFJUX0lEWF9QUk9NSVNDVU9VU19TTE9ULCBSVF9JRFhfVkFMSUQsIDApKSB7CiAJCQkJbmV0aWZfZXJyKHFkZXYsIGh3LCBxZGV2LT5uZGV2LAotCQkJCQkgICJGYWlsZWQgdG8gY2xlYXIgcHJvbWlzY291cyBtb2RlLlxuIik7CisJCQkJCSAgIkZhaWxlZCB0byBjbGVhciBwcm9taXNjdW91cyBtb2RlLlxuIik7CiAJCQl9IGVsc2UgewogCQkJCWNsZWFyX2JpdChRTF9QUk9NSVNDVU9VUywgJnFkZXYtPmZsYWdzKTsKIAkJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3I2MDQwLmMgYi9kcml2ZXJzL25ldC9yNjA0MC5jCmluZGV4IGUzZWJkOTAuLjIwMGEzNjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3I2MDQwLmMKKysrIGIvZHJpdmVycy9uZXQvcjYwNDAuYwpAQCAtNTM1LDcgKzUzNSw3IEBACiAJCQkvKiBSWCBkcmliYmxlICovCiAJCQlpZiAoZXJyICYgRFNDX1JYX0VSUl9EUkkpCiAJCQkJZGV2LT5zdGF0cy5yeF9mcmFtZV9lcnJvcnMrKzsKLQkJCS8qIEJ1ZmZlciBsZW5naHQgZXhjZWVkZWQgKi8KKwkJCS8qIEJ1ZmZlciBsZW5ndGggZXhjZWVkZWQgKi8KIAkJCWlmIChlcnIgJiBEU0NfUlhfRVJSX0JVRikKIAkJCQlkZXYtPnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKIAkJCS8qIFBhY2tldCB0b28gbG9uZyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvczJpby5jIGIvZHJpdmVycy9uZXQvczJpby5jCmluZGV4IDM1NmU3NGQuLjMzN2JkY2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3MyaW8uYworKysgYi9kcml2ZXJzL25ldC9zMmlvLmMKQEAgLTIzNTMsNyArMjM1Myw3IEBACiAKIAlpZiAoczJpb19saW5rX2ZhdWx0X2luZGljYXRpb24obmljKSA9PSBNQUNfUk1BQ19FUlJfVElNRVIpIHsKIAkJLyoKLQkJICogRG9udCBzZWUgbGluayBzdGF0ZSBpbnRlcnJ1cHRzIGluaXRhbGx5IG9uIHNvbWUgc3dpdGNoZXMsCisJCSAqIERvbnQgc2VlIGxpbmsgc3RhdGUgaW50ZXJydXB0cyBpbml0aWFsbHkgb24gc29tZSBzd2l0Y2hlcywKIAkJICogc28gZGlyZWN0bHkgc2NoZWR1bGluZyB0aGUgbGluayBzdGF0ZSB0YXNrIGhlcmUuCiAJCSAqLwogCQlzY2hlZHVsZV93b3JrKCZuaWMtPnNldF9saW5rX3Rhc2spOwpAQCAtMzU2Myw3ICszNTYzLDcgQEAKIAl9CiAKIAkvKgotCSAqIENsZWFyIHNwdXJpb3VzIEVDQyBpbnRlcnJ1cHRzIHRoYXQgd291bGQgaGF2ZSBvY2N1cmVkIG9uCisJICogQ2xlYXIgc3B1cmlvdXMgRUNDIGludGVycnVwdHMgdGhhdCB3b3VsZCBoYXZlIG9jY3VycmVkIG9uCiAJICogWEZSQU1FIElJIGNhcmRzIGFmdGVyIHJlc2V0LgogCSAqLwogCWlmIChzcC0+ZGV2aWNlX3R5cGUgPT0gWEZSQU1FX0lJX0RFVklDRSkgewpAQCAtNDA2NSw3ICs0MDY1LDcgQEAKICAqICBEZXNjcmlwdGlvbiA6CiAgKiAgVGhpcyBmdW5jdGlvbiBpcyB0aGUgVHggZW50cnkgcG9pbnQgb2YgdGhlIGRyaXZlci4gUzJJTyBOSUMgc3VwcG9ydHMKICAqICBjZXJ0YWluIHByb3RvY29sIGFzc2lzdCBmZWF0dXJlcyBvbiBUeCBzaWRlLCBuYW1lbHkgIENTTywgUy9HLCBMU08uCi0gKiAgTk9URTogd2hlbiBkZXZpY2UgY2FudCBxdWV1ZSB0aGUgcGt0LGp1c3QgdGhlIHRyYW5zX3N0YXJ0IHZhcmlhYmxlIHdpbGwKKyAqICBOT1RFOiB3aGVuIGRldmljZSBjYW4ndCBxdWV1ZSB0aGUgcGt0LGp1c3QgdGhlIHRyYW5zX3N0YXJ0IHZhcmlhYmxlIHdpbGwKICAqICBub3QgYmUgdXBhZHRlZC4KICAqICBSZXR1cm4gdmFsdWU6CiAgKiAgMCBvbiBzdWNjZXNzICYgMSBvbiBmYWlsdXJlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvczJpby5oIGIvZHJpdmVycy9uZXQvczJpby5oCmluZGV4IDdkMTYwMzAuLjJkMTQ0OTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3MyaW8uaAorKysgYi9kcml2ZXJzL25ldC9zMmlvLmgKQEAgLTM3Niw3ICszNzYsNyBAQAogLyogTWFpbnRhaW5zIFBlciBGSUZPIHJlbGF0ZWQgaW5mb3JtYXRpb24uICovCiBzdHJ1Y3QgdHhfZmlmb19jb25maWcgewogI2RlZmluZQlNQVhfQVZBSUxBQkxFX1RYRFMJODE5MgotCXUzMiBmaWZvX2xlbjsJCS8qIHNwZWNpZmllcyBsZW4gb2YgRklGTyB1cHRvIDgxOTIsIGllIG5vIG9mIFR4RExzICovCisJdTMyIGZpZm9fbGVuOwkJLyogc3BlY2lmaWVzIGxlbiBvZiBGSUZPIHVwIHRvIDgxOTIsIGllIG5vIG9mIFR4RExzICovCiAvKiBQcmlvcml0eSBkZWZpbml0aW9uICovCiAjZGVmaW5lIFRYX0ZJRk9fUFJJXzAgICAgICAgICAgICAgICAwCS8qSGlnaGVzdCAqLwogI2RlZmluZSBUWF9GSUZPX1BSSV8xICAgICAgICAgICAgICAgMQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2ZjL2ZhbGNvbi5jIGIvZHJpdmVycy9uZXQvc2ZjL2ZhbGNvbi5jCmluZGV4IDczNGZjZmIuLmQ5NmIyMzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NmYy9mYWxjb24uYworKysgYi9kcml2ZXJzL25ldC9zZmMvZmFsY29uLmMKQEAgLTY5Miw3ICs2OTIsNyBAQAogCWVmeF9vd29yZF90IG1kX3N0YXQ7CiAJaW50IGNvdW50OwogCi0JLyogd2FpdCB1cHRvIDUwbXMgLSB0YWtlbiBtYXggZnJvbSBkYXRhc2hlZXQgKi8KKwkvKiB3YWl0IHVwIHRvIDUwbXMgLSB0YWtlbiBtYXggZnJvbSBkYXRhc2hlZXQgKi8KIAlmb3IgKGNvdW50ID0gMDsgY291bnQgPCA1MDAwOyBjb3VudCsrKSB7CiAJCWVmeF9yZWFkbyhlZngsICZtZF9zdGF0LCBGUl9BQl9NRF9TVEFUKTsKIAkJaWYgKEVGWF9PV09SRF9GSUVMRChtZF9zdGF0LCBGUkZfQUJfTURfQlNZKSA9PSAwKSB7CkBAIC0xMjIxLDcgKzEyMjEsNyBAQAogCiAJCQlyZXR1cm4gMDsKIAkJfQotCX0gd2hpbGUgKCsrY291bnQgPCAyMCk7CS8qIHdhaXQgdXB0byAwLjQgc2VjICovCisJfSB3aGlsZSAoKytjb3VudCA8IDIwKTsJLyogd2FpdCB1cCB0byAwLjQgc2VjICovCiAKIAluZXRpZl9lcnIoZWZ4LCBodywgZWZ4LT5uZXRfZGV2LCAidGltZWQgb3V0IHdhaXRpbmcgZm9yIFNSQU0gcmVzZXRcbiIpOwogCXJldHVybiAtRVRJTUVET1VUOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2ZjL21jZGkuYyBiL2RyaXZlcnMvbmV0L3NmYy9tY2RpLmMKaW5kZXggNWUxMThmMC4uZDk4NDc5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2ZjL21jZGkuYworKysgYi9kcml2ZXJzL25ldC9zZmMvbWNkaS5jCkBAIC00NTMsNyArNDUzLDcgQEAKIAkgKgogCSAqIFRoZXJlJ3MgYSByYWNlIGhlcmUgd2l0aCBlZnhfbWNkaV9ycGMoKSwgYmVjYXVzZSB3ZSBtaWdodCByZWNlaXZlCiAJICogYSBSRUJPT1QgZXZlbnQgKmJlZm9yZSogdGhlIHJlcXVlc3QgaGFzIGJlZW4gY29waWVkIG91dC4gSW4gcG9sbGVkCi0JICogbW9kZSAoZHVyaW5nIHN0YXJ0dXApIHRoaXMgaXMgaXJyZWxldmVudCwgYmVjYXVzZSBlZnhfbWNkaV9jb21wbGV0ZSgpCisJICogbW9kZSAoZHVyaW5nIHN0YXJ0dXApIHRoaXMgaXMgaXJyZWxldmFudCwgYmVjYXVzZSBlZnhfbWNkaV9jb21wbGV0ZSgpCiAJICogaXMgaWdub3JlZC4gSW4gZXZlbnQgbW9kZSwgdGhpcyBjb25kaXRpb24gaXMganVzdCBhbiBlZGdlLWNhc2Ugb2YKIAkgKiByZWNlaXZpbmcgYSBSRUJPT1QgZXZlbnQgYWZ0ZXIgcG9zdGluZyB0aGUgTUNESSByZXF1ZXN0LiBEaWQgdGhlIG1jCiAJICogcmVib290IGJlZm9yZSBvciBhZnRlciB0aGUgY29weW91dD8gVGhlIGJlc3Qgd2UgY2FuIGRvIGFsd2F5cyBpcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2ZjL21jZGlfcGNvbC5oIGIvZHJpdmVycy9uZXQvc2ZjL21jZGlfcGNvbC5oCmluZGV4IGI4NmExNWYuLjQxZmUwNmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NmYy9tY2RpX3Bjb2wuaAorKysgYi9kcml2ZXJzL25ldC9zZmMvbWNkaV9wY29sLmgKQEAgLTEwMyw3ICsxMDMsNyBAQAogICoKICAqIElmIENvZGU9PUNNRERPTkUsIHRoZW4gdGhlIGZpZWxkcyBhcmUgZnVydGhlciBpbnRlcnByZXRlZCBhczoKICAqCi0gKiAgIC0gTEVWRUw9PUlORk8gICAgQ29tbWFuZCBzdWNjZWRlZAorICogICAtIExFVkVMPT1JTkZPICAgIENvbW1hbmQgc3VjY2VlZGVkCiAgKiAgIC0gTEVWRUw9PUVSUiAgICAgQ29tbWFuZCBmYWlsZWQKICAqCiAgKiAgICAwICAgICA4ICAgICAgICAgMTYgICAgICAyNCAgICAgMzIKQEAgLTU3Miw3ICs1NzIsNyBAQAogICAoNCooX251bXdvcmRzKSkKIAogLyogTUNfQ01EX1NFVF9SQU5EX1NFRUQ6Ci0gKiBTZXQgdGhlIDE2Ynl0ZSBzZWVkIGZvciB0aGUgTUMgcHN1ZWRvLXJhbmRvbSBnZW5lcmF0b3IKKyAqIFNldCB0aGUgMTZieXRlIHNlZWQgZm9yIHRoZSBNQyBwc2V1ZG8tcmFuZG9tIGdlbmVyYXRvcgogICovCiAjZGVmaW5lIE1DX0NNRF9TRVRfUkFORF9TRUVEIDB4MWEKICNkZWZpbmUgTUNfQ01EX1NFVF9SQU5EX1NFRURfSU5fTEVOIDE2CkBAIC0xMTYyLDcgKzExNjIsNyBAQAogI2RlZmluZSBNQ19DTURfTUFDX1NUQVRTX0NNRF9DTEVBUl9XSURUSCAxCiAjZGVmaW5lIE1DX0NNRF9NQUNfU1RBVFNfQ01EX1BFUklPRElDX0NIQU5HRV9MQk4gMgogI2RlZmluZSBNQ19DTURfTUFDX1NUQVRTX0NNRF9QRVJJT0RJQ19DSEFOR0VfV0lEVEggMQotLyogUmVtYWluaW5nIFBFUklPRCogZmllbGRzIG9ubHkgcmVsZXZlbnQgd2hlbiBQRVJJT0RJQ19DSEFOR0UgaXMgc2V0ICovCisvKiBSZW1haW5pbmcgUEVSSU9EKiBmaWVsZHMgb25seSByZWxldmFudCB3aGVuIFBFUklPRElDX0NIQU5HRSBpcyBzZXQgKi8KICNkZWZpbmUgTUNfQ01EX01BQ19TVEFUU19DTURfUEVSSU9ESUNfRU5BQkxFX0xCTiAzCiAjZGVmaW5lIE1DX0NNRF9NQUNfU1RBVFNfQ01EX1BFUklPRElDX0VOQUJMRV9XSURUSCAxCiAjZGVmaW5lIE1DX0NNRF9NQUNfU1RBVFNfQ01EX1BFUklPRElDX0NMRUFSX0xCTiA0CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zZmMvbWNkaV9waHkuYyBiL2RyaXZlcnMvbmV0L3NmYy9tY2RpX3BoeS5jCmluZGV4IGVjM2Y3NDAuLjdlM2M2NWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NmYy9tY2RpX3BoeS5jCisrKyBiL2RyaXZlcnMvbmV0L3NmYy9tY2RpX3BoeS5jCkBAIC00NDksNyArNDQ5LDcgQEAKIAlzdHJ1Y3QgZWZ4X21jZGlfcGh5X2RhdGEgKnBoeV9jZmcgPSBlZngtPnBoeV9kYXRhOwogCXUzMiBybXRhZHY7CiAKLQkvKiBUaGUgbGluayBwYXJ0bmVyIGNhcGFiaWxpdGllcyBhcmUgb25seSByZWxldmVudCBpZiB0aGUKKwkvKiBUaGUgbGluayBwYXJ0bmVyIGNhcGFiaWxpdGllcyBhcmUgb25seSByZWxldmFudCBpZiB0aGUKIAkgKiBsaW5rIHN1cHBvcnRzIGZsb3cgY29udHJvbCBhdXRvbmVnb3RpYXRpb24gKi8KIAlpZiAofnBoeV9jZmctPnN1cHBvcnRlZF9jYXAgJiAoMSA8PCBNQ19DTURfUEhZX0NBUF9BTl9MQk4pKQogCQlyZXR1cm47CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zZmMvbmV0X2RyaXZlci5oIGIvZHJpdmVycy9uZXQvc2ZjL25ldF9kcml2ZXIuaAppbmRleCAyMTVkNWM1Li45ZmZhOWE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zZmMvbmV0X2RyaXZlci5oCisrKyBiL2RyaXZlcnMvbmV0L3NmYy9uZXRfZHJpdmVyLmgKQEAgLTY3MCw3ICs2NzAsNyBAQAogICogQGlycV96ZXJvX2NvdW50OiBOdW1iZXIgb2YgbGVnYWN5IElSUXMgc2VlbiB3aXRoIHF1ZXVlIGZsYWdzID09IDAKICAqIEBmYXRhbF9pcnFfbGV2ZWw6IElSUSBsZXZlbCAoYml0IG51bWJlcikgdXNlZCBmb3Igc2VyaW91cyBlcnJvcnMKICAqIEBtdGRfbGlzdDogTGlzdCBvZiBNVERzIGF0dGFjaGVkIHRvIHRoZSBOSUMKLSAqIEBuaWNfZGF0YTogSGFyZHdhcmUgZGVwZW5kYW50IHN0YXRlCisgKiBAbmljX2RhdGE6IEhhcmR3YXJlIGRlcGVuZGVudCBzdGF0ZQogICogQG1hY19sb2NrOiBNQUMgYWNjZXNzIGxvY2suIFByb3RlY3RzIEBwb3J0X2VuYWJsZWQsIEBwaHlfbW9kZSwKICAqCUBwb3J0X2luaGliaXRlZCwgZWZ4X21vbml0b3IoKSBhbmQgZWZ4X3JlY29uZmlndXJlX3BvcnQoKQogICogQHBvcnRfZW5hYmxlZDogUG9ydCBlbmFibGVkIGluZGljYXRvci4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NnaXNlZXEuYyBiL2RyaXZlcnMvbmV0L3NnaXNlZXEuYwppbmRleCAzYTBjYzYzLi5kZDAzYmY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zZ2lzZWVxLmMKKysrIGIvZHJpdmVycy9uZXQvc2dpc2VlcS5jCkBAIC0zMyw3ICszMyw3IEBACiAgKiB3aXRoIHRoYXQgaW4gbWluZCwgSSd2ZSBkZWNpZGVkIHRvIG1ha2UgdGhpcyBkcml2ZXIgbG9vayBjb21wbGV0ZWx5IGxpa2UgYQogICogc3R1cGlkIExhbmNlIGZyb20gYSBkcml2ZXIgYXJjaGl0ZWN0dXJlIHBlcnNwZWN0aXZlLiAgT25seSBkaWZmZXJlbmNlIGlzIHRoYXQKICAqIGhlcmUgb3VyICJyaW5nIGJ1ZmZlciIgbG9va3MgYW5kIGFjdHMgbGlrZSBhIHJlYWwgTGFuY2Ugb25lIGRvZXMgYnV0IGlzCi0gKiBsYXllZCBvdXQgbGlrZSBob3cgdGhlIEhQQyBETUEgYW5kIHRoZSBTZWVxIHdhbnQgaXQgdG8uICBZb3UnZCBiZSBzdXJwcmlzZWQKKyAqIGxhaWQgb3V0IGxpa2UgaG93IHRoZSBIUEMgRE1BIGFuZCB0aGUgU2VlcSB3YW50IGl0IHRvLiAgWW91J2QgYmUgc3VycHJpc2VkCiAgKiBob3cgYSBzdHVwaWQgaWRlYSBsaWtlIHRoaXMgY2FuIHBheSBvZmYgaW4gcGVyZm9ybWFuY2UsIG5vdCB0byBtZW50aW9uCiAgKiBtYWtpbmcgdGhpcyBkcml2ZXIgMiwwMDAgdGltZXMgZWFzaWVyIHRvIHdyaXRlLiA7LSkKICAqLwpAQCAtNzcsNyArNzcsNyBAQAogfTsKIAogLyoKLSAqIFdhcm5pbmc6IFRoaXMgc3RydWN0dXJlIGlzIGxheWVkIG91dCBpbiBhIGNlcnRhaW4gd2F5IGJlY2F1c2UgSFBDIGRtYQorICogV2FybmluZzogVGhpcyBzdHJ1Y3R1cmUgaXMgbGFpZCBvdXQgaW4gYSBjZXJ0YWluIHdheSBiZWNhdXNlIEhQQyBkbWEKICAqICAgICAgICAgIGRlc2NyaXB0b3JzIG11c3QgYmUgOC1ieXRlIGFsaWduZWQuICBTbyBkb24ndCB0b3VjaCB0aGlzIHdpdGhvdXQKICAqICAgICAgICAgIHNvbWUgY2FyZS4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2hfZXRoLmMgYi9kcml2ZXJzL25ldC9zaF9ldGguYwppbmRleCBlOWU3YTUzLi44YTcyYTk3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zaF9ldGguYworKysgYi9kcml2ZXJzL25ldC9zaF9ldGguYwpAQCAtMTg3NSw3ICsxODc1LDcgQEAKIAlpZiAocmV0KQogCQlnb3RvIG91dF91bnJlZ2lzdGVyOwogCi0JLyogcHJpbnQgZGV2aWNlIGluZm9tYXRpb24gKi8KKwkvKiBwcmludCBkZXZpY2UgaW5mb3JtYXRpb24gKi8KIAlwcl9pbmZvKCJCYXNlIGFkZHJlc3MgYXQgMHgleCwgJXBNLCBJUlEgJWQuXG4iLAogCSAgICAgICAodTMyKW5kZXYtPmJhc2VfYWRkciwgbmRldi0+ZGV2X2FkZHIsIG5kZXYtPmlycSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NpczE5MC5jIGIvZHJpdmVycy9uZXQvc2lzMTkwLmMKaW5kZXggMzQwNmVkOC4uYjQzNmUwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2lzMTkwLmMKKysrIGIvZHJpdmVycy9uZXQvc2lzMTkwLmMKQEAgLTkzLDcgKzkzLDcgQEAKIAlJbnRyU3RhdHVzCQk9IDB4MjAsCiAJSW50ck1hc2sJCT0gMHgyNCwKIAlJbnRyQ29udHJvbAkJPSAweDI4LAotCUludHJUaW1lcgkJPSAweDJjLAkvLyB1bnVzZWQgKEludGVydXB0IFRpbWVyKQorCUludHJUaW1lcgkJPSAweDJjLAkvLyB1bnVzZWQgKEludGVycnVwdCBUaW1lcikKIAlQTUNvbnRyb2wJCT0gMHgzMCwJLy8gdW51c2VkIChQb3dlciBNZ210IENvbnRyb2wvU3RhdHVzKQogCXJzdjIJCQk9IDB4MzQsCS8vIHJlc2VydmVkCiAJUk9NQ29udHJvbAkJPSAweDM4LApAQCAtMjM0LDcgKzIzNCw3IEBACiAJUnhTaXplTWFzawk9IDB4MDAwMGZmZmYKIAkvKgogCSAqIFRoZSBhc2ljIGNvdWxkIGFwcGFyZW50bHkgZG8gdmxhbiwgVFNPLCBqdW1ibyAoc2lzMTkxIG9ubHkpIGFuZAotCSAqIHByb3ZpZGUgdHdvICh1bnVzZWQgd2l0aCBMaW51eCkgVHggcXVldWVzLiBObyBwdWJsaWNhbGx5CisJICogcHJvdmlkZSB0d28gKHVudXNlZCB3aXRoIExpbnV4KSBUeCBxdWV1ZXMuIE5vIHB1YmxpY2x5CiAJICogYXZhaWxhYmxlIGRvY3VtZW50YXRpb24gYWxhcy4KIAkgKi8KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zaXM5MDAuYyBiL2RyaXZlcnMvbmV0L3NpczkwMC5jCmluZGV4IDg0ZDQxNjcuLmNiMzE3Y2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NpczkwMC5jCisrKyBiL2RyaXZlcnMvbmV0L3NpczkwMC5jCkBAIC0xMTgwLDcgKzExODAsNyBAQAogICoKICAqCTYzMEUgZXF1YWxpemVyIHdvcmthcm91bmQgcnVsZShDeXJ1cyBIdWFuZyAwOC8xNSkKICAqCVBIWSByZWdpc3RlciAxNGgoVGVzdCkKLSAqCUJpdCAxNDogMCAtLSBBdXRvbWF0aWNhbGx5IGRlY3RlY3QgKGRlZmF1bHQpCisgKglCaXQgMTQ6IDAgLS0gQXV0b21hdGljYWxseSBkZXRlY3QgKGRlZmF1bHQpCiAgKgkJMSAtLSBNYW51YWxseSBzZXQgRXF1YWxpemVyIGZpbHRlcgogICoJQml0IDEzOiAwIC0tIChEZWZhdWx0KQogICoJCTEgLS0gU3BlZWQgdXAgY29udmVyZ2VuY2Ugb2YgZXF1YWxpemVyIHNldHRpbmcKQEAgLTExOTIsNyArMTE5Miw3IEBACiAgKglUaGVuIHNldCBlcXVhbGl6ZXIgdmFsdWUsIGFuZCBzZXQgQml0IDE0IHRvIDEsIEJpdCA5IHRvIDAKICAqCUxpbmsgT2ZmOlNldCBCaXQgMTMgdG8gMSwgQml0IDE0IHRvIDAKICAqCUNhbGN1bGF0ZSBFcXVhbGl6ZXIgdmFsdWU6Ci0gKglXaGVuIExpbmsgaXMgT04gYW5kIEJpdCAxNCBpcyAwLCBTSVM5MDBQSFkgd2lsbCBhdXRvLWRlY3RlY3QgcHJvcGVyIGVxdWFsaXplciB2YWx1ZS4KKyAqCVdoZW4gTGluayBpcyBPTiBhbmQgQml0IDE0IGlzIDAsIFNJUzkwMFBIWSB3aWxsIGF1dG8tZGV0ZWN0IHByb3BlciBlcXVhbGl6ZXIgdmFsdWUuCiAgKglXaGVuIHRoZSBlcXVhbGl6ZXIgaXMgc3RhYmxlLCB0aGlzIHZhbHVlIGlzIG5vdCBhIGZpeGVkIHZhbHVlLiBJdCB3aWxsIGJlIHdpdGhpbgogICoJYSBzbWFsbCByYW5nZShlZy4gN345KS4gVGhlbiB3ZSBnZXQgYSBtaW5pbXVtIGFuZCBhIG1heGltdW0gdmFsdWUoZWcuIG1pbj03LCBtYXg9OSkKICAqCTAgPD0gbWF4IDw9IDQgIC0tPiBzZXQgZXF1YWxpemVyIHRvIG1heApAQCAtMTcyMyw3ICsxNzIzLDcgQEAKIAkJcnhfc2l6ZSA9IGRhdGFfc2l6ZSAtIENSQ19TSVpFOwogCiAjaWYgZGVmaW5lZChDT05GSUdfVkxBTl84MDIxUSkgfHwgZGVmaW5lZChDT05GSUdfVkxBTl84MDIxUV9NT0RVTEUpCi0JCS8qIGBgVE9PTE9ORycnIGZsYWcgbWVhbnMganVtYm8gcGFja2V0IHJlY2l2ZWQuICovCisJCS8qIGBgVE9PTE9ORycnIGZsYWcgbWVhbnMganVtYm8gcGFja2V0IHJlY2VpdmVkLiAqLwogCQlpZiAoKHJ4X3N0YXR1cyAmIFRPT0xPTkcpICYmIGRhdGFfc2l6ZSA8PSBNQVhfRlJBTUVfU0laRSkKIAkJCXJ4X3N0YXR1cyAmPSAofiAoKHVuc2lnbmVkIGludClUT09MT05HKSk7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NrZnAvZXNzLmMgYi9kcml2ZXJzL25ldC9za2ZwL2Vzcy5jCmluZGV4IDg2MzlhMDguLjJmYzU5ODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NrZnAvZXNzLmMKKysrIGIvZHJpdmVycy9uZXQvc2tmcC9lc3MuYwpAQCAtMjQxLDcgKzI0MSw3IEBACiAJCQkhPSBTTVRfUkRGX1NVQ0NFU1MpIHx8CiAJCQkoc20tPnNtdF90aWQgIT0gc21jLT5lc3MuYWxsb2NfdHJhbnNfaWQpKSB7CiAKLQkJCURCX0VTUygiRVNTOiBBbGxvY2F0aW9uIFJlc3BvbmNlIG5vdCBhY2NlcHRlZFxuIiwwLDApIDsKKwkJCURCX0VTUygiRVNTOiBBbGxvY2F0aW9uIFJlc3BvbnNlIG5vdCBhY2NlcHRlZFxuIiwwLDApIDsKIAkJCXJldHVybiBmczsKIAkJfQogCkBAIC0zOTMsNyArMzkzLDcgQEAKIAkgKgkJICAgICAgfAkgVC1ORUcJfAogCSAqCQkgICAgICAgLSAgICAgICAtCiAgCSAqCi0JICogVC1ORUcgaXMgZGlzY3JpYmVkIGJ5IHRoZSBlcXVhdGlvbjoKKwkgKiBULU5FRyBpcyBkZXNjcmliZWQgYnkgdGhlIGVxdWF0aW9uOgogCSAqCiAJICoJCSAgICAgKC0pIGZkZGlNQUNULU5FRwogCSAqCVQtTkVHID0JICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTQ3OSw3ICs0NzksNyBAQAogCXZvaWQJCQkqcCA7CiAKIAkvKgotCSAqIGdldCBhbmQgaW5pdGlhbGl6ZSB0aGUgcmVzcG9uY2UgZnJhbWUKKwkgKiBnZXQgYW5kIGluaXRpYWxpemUgdGhlIHJlc3BvbnNlIGZyYW1lCiAJICovCiAJaWYgKHNiYV9jbWQgPT0gQ0hBTkdFX0FMTE9DQVRJT04pIHsKIAkJaWYgKCEobWI9c210X2J1aWxkX2ZyYW1lKHNtYyxTTVRfUkFGLFNNVF9SRVBMWSwKQEAgLTU3OCw3ICs1NzgsNyBAQAogCX0KIAkKIAkvKgotCSAqIGdldCBhbmQgaW5pdGlhbGl6ZSB0aGUgcmVzcG9uY2UgZnJhbWUKKwkgKiBnZXQgYW5kIGluaXRpYWxpemUgdGhlIHJlc3BvbnNlIGZyYW1lCiAJICovCiAJaWYgKCEobWI9c210X2J1aWxkX2ZyYW1lKHNtYyxTTVRfUkFGLFNNVF9SRVFVRVNULAogCQkJc2l6ZW9mKHN0cnVjdCBzbXRfc2JhX2FsY19yZXEpKSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2ZwL2ZwbHVzdG0uYyBiL2RyaXZlcnMvbmV0L3NrZnAvZnBsdXN0bS5jCmluZGV4IGNhNGU3YmIuLmEyMGVkMWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NrZnAvZnBsdXN0bS5jCisrKyBiL2RyaXZlcnMvbmV0L3NrZnAvZnBsdXN0bS5jCkBAIC0zNDAsNyArMzQwLDcgQEAKIAlvdXRwdyhGTV9BKEZNX0xDTlRSKSwwKSA7CiAJb3V0cHcoRk1fQShGTV9FQ05UUiksMCkgOwogCS8qCi0JICogY2xlYXIgaW50ZXJuYWwgZXJyb3IgY291bnRlciBzdHVjdHVyZQorCSAqIGNsZWFyIGludGVybmFsIGVycm9yIGNvdW50ZXIgc3RydWN0dXJlCiAJICovCiAJZWMgPSAodV9sb25nICopJnNtYy0+aHcuZnAuZXJyX3N0YXRzIDsKIAlmb3IgKGkgPSAoc2l6ZW9mKHN0cnVjdCBlcnJfc3QpL3NpemVvZihsb25nKSkgOyBpIDsgaS0tKQpAQCAtMTI2Miw4ICsxMjYyLDggQEAKIAogUGFyYQltb2RlID0JMQlSWF9FTkFCTEVfQUxMTVVMVEkJZW5hYmxlIGFsbCBtdWx0aWNhc3RzCiAJCTIJUlhfRElTQUJMRV9BTExNVUxUSQlkaXNhYmxlICJlbmFibGUgYWxsIG11bHRpY2FzdHMiCi0JCTMJUlhfRU5BQkxFX1BST01JU0MJZW5hYmxlIHByb21pc2NvdXMKLQkJNAlSWF9ESVNBQkxFX1BST01JU0MJZGlzYWJsZSBwcm9taXNjb3VzCisJCTMJUlhfRU5BQkxFX1BST01JU0MJZW5hYmxlIHByb21pc2N1b3VzCisJCTQJUlhfRElTQUJMRV9QUk9NSVNDCWRpc2FibGUgcHJvbWlzY3VvdXMKIAkJNQlSWF9FTkFCTEVfTlNBCQllbmFibGUgcmVjZXB0aW9uIG9mIE5TQSBmcmFtZXMKIAkJNglSWF9ESVNBQkxFX05TQQkJZGlzYWJsZSByZWNlcHRpb24gb2YgTlNBIGZyYW1lcwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2ZwL2gvY210ZGVmLmggYi9kcml2ZXJzL25ldC9za2ZwL2gvY210ZGVmLmgKaW5kZXggZjJmNzcxZC4uNWE2YzYxMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2tmcC9oL2NtdGRlZi5oCisrKyBiL2RyaXZlcnMvbmV0L3NrZnAvaC9jbXRkZWYuaApAQCAtMTksNyArMTksNyBAQAogCiAvKgogICogaW1wbGVtZW50YXRpb24gc3BlY2lmaWMgY29uc3RhbnRzCi0gKiBNT0RJSUZZIFRIRSBGT0xMV09JTkcgVEhSRUUgREVGSU5FUworICogTU9ESUlGWSBUSEUgRk9MTE9XSU5HIFRIUkVFIERFRklORVMKICAqLwogI2RlZmluZSBBTURQTEMJCQkvKiBpZiBBbWQgUExDIGNoaXAgdXNlZCAqLwogI2lmZGVmCUNPTkMKQEAgLTQ1Niw3ICs0NTYsNyBAQAogCXVfbG9uZyBzb2Z0X2VyciA7CQkvKiBlcnJvciBjb3VudGVyICovCiAJdV9sb25nIHBhcml0eV9lcnIgOwkJLyogZXJyb3IgY291bnRlciAqLwogCXVfbG9uZyBlYnVmX2VyciA7CQkvKiBlcnJvciBjb3VudGVyICovCi0JdV9sb25nIGVidWZfY29udCA7CQkvKiBjb250aW5vdXMgZXJyb3IgY291bnRlciAqLworCXVfbG9uZyBlYnVmX2NvbnQgOwkJLyogY29udGludW91cyBlcnJvciBjb3VudGVyICovCiAJdV9sb25nIHBoeWludiA7CQkJLyogZXJyb3IgY291bnRlciAqLwogCXVfbG9uZyB2c3ltX2N0ciA7CQkvKiBlcnJvciBjb3VudGVyICovCiAJdV9sb25nIG1pbmlfY3RyIDsJCS8qIGVycm9yIGNvdW50ZXIgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NrZnAvaC9mcGx1c3RtLmggYi9kcml2ZXJzL25ldC9za2ZwL2gvZnBsdXN0bS5oCmluZGV4IDZkNzM4ZTEuLmQ0MzE5MWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NrZnAvaC9mcGx1c3RtLmgKKysrIGIvZHJpdmVycy9uZXQvc2tmcC9oL2ZwbHVzdG0uaApAQCAtMjM3LDggKzIzNyw4IEBACiAgKi8KICNkZWZpbmUgUlhfRU5BQkxFX0FMTE1VTFRJCTEJLyogZW5hYmxlIGFsbCBtdWx0aWNhc3RzICovCiAjZGVmaW5lIFJYX0RJU0FCTEVfQUxMTVVMVEkJMgkvKiBkaXNhYmxlICJlbmFibGUgYWxsIG11bHRpY2FzdHMiICovCi0jZGVmaW5lIFJYX0VOQUJMRV9QUk9NSVNDCTMJLyogZW5hYmxlIHByb21pc2NvdXMgKi8KLSNkZWZpbmUgUlhfRElTQUJMRV9QUk9NSVNDCTQJLyogZGlzYWJsZSBwcm9taXNjb3VzICovCisjZGVmaW5lIFJYX0VOQUJMRV9QUk9NSVNDCTMJLyogZW5hYmxlIHByb21pc2N1b3VzICovCisjZGVmaW5lIFJYX0RJU0FCTEVfUFJPTUlTQwk0CS8qIGRpc2FibGUgcHJvbWlzY3VvdXMgKi8KICNkZWZpbmUgUlhfRU5BQkxFX05TQQkJNQkvKiBlbmFibGUgcmVjZXB0aW9uIG9mIE5TQSBmcmFtZXMgKi8KICNkZWZpbmUgUlhfRElTQUJMRV9OU0EJCTYJLyogZGlzYWJsZSByZWNlcHRpb24gb2YgTlNBIGZyYW1lcyAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2ZwL2gvc21jLmggYi9kcml2ZXJzL25ldC9za2ZwL2gvc21jLmgKaW5kZXggMDI2YTgzYi4uYzc3NGE5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2tmcC9oL3NtYy5oCisrKyBiL2RyaXZlcnMvbmV0L3NrZnAvaC9zbWMuaApAQCAtMzg4LDcgKzM4OCw3IEBACiAJdV9sb25nCXJtdF90X3BvbGwgOwkJLyogUk1UIDogY2xhaW0vYmVhY29uIHBvbGxlciAqLwogCXVfbG9uZyAgcm10X2R1cF9tYWNfYmVoYXZpb3IgOyAgLyogRmxhZyBmb3IgdGhlIGJlYXZpb3Igb2YgU01UIGlmCiAJCQkJCSAqIGEgRHVwbGljYXRlIE1BQyBBZGRyZXNzIHdhcyBkZXRlY3RlZC4KLQkJCQkJICogRkFMU0U6IFNNVCB3aWxsIGxlYXZlIGZpbmFseSB0aGUgcmluZworCQkJCQkgKiBGQUxTRTogU01UIHdpbGwgbGVhdmUgZmluYWxseSB0aGUgcmluZwogCQkJCQkgKiBUUlVFOiAgU01UIHdpbGwgcmVpbnN0ZXJ0IGludG8gdGhlIHJpbmcKIAkJCQkJICovCiAJdV9sb25nCW1hY19kX21heCA7CQkvKiBNQUMgOiBEX01heCB0aW1lciB2YWx1ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2tmcC9oL3NtdC5oIGIvZHJpdmVycy9uZXQvc2tmcC9oL3NtdC5oCmluZGV4IDI5NzY3NTcuLjIwMzBmOWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3NrZnAvaC9zbXQuaAorKysgYi9kcml2ZXJzL25ldC9za2ZwL2gvc210LmgKQEAgLTc5Myw3ICs3OTMsNyBAQAogfSA7CiAKIC8qCi0gKiBTQkEgUmVxdWVzdCBBbGxvY2F0aW9uIFJlc3BvbmNlIEZyYW1lCisgKiBTQkEgUmVxdWVzdCBBbGxvY2F0aW9uIFJlc3BvbnNlIEZyYW1lCiAgKi8KIHN0cnVjdCBzbXRfc2JhX2FsY19yZXMgewogCXN0cnVjdCBzbXRfaGVhZGVyCXNtdCA7CQkvKiBnZW5lcmljIGhlYWRlciAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2tmcC9oL3N1cGVybl8yLmggYi9kcml2ZXJzL25ldC9za2ZwL2gvc3VwZXJuXzIuaAppbmRleCA1YmEwYjgzLi4wYjczNjkwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9za2ZwL2gvc3VwZXJuXzIuaAorKysgYi9kcml2ZXJzL25ldC9za2ZwL2gvc3VwZXJuXzIuaApAQCAtMTQsNyArMTQsNyBAQAogCiAvKgogCWRlZmluZXMgZm9yIEFNRCBTdXBlcm5ldCBJSSBjaGlwIHNldAotCXRoZSBjaGlwcyBhcmUgcmVmZXJlZCB0byBhcworCXRoZSBjaGlwcyBhcmUgcmVmZXJyZWQgdG8gYXMKIAkJRlBMVVMJRm9ybWFjIFBsdXMKIAkJUExDCVBoeXNpY2FsIExheWVyCiAKQEAgLTM4Niw3ICszODYsNyBAQAogI2RlZmluZQlGTV9NRElTUkNWCSg0PDw4KQkJLyogZGlzYWJsZSByZWNlaXZlIGZ1bmN0aW9uICovCiAjZGVmaW5lCUZNX01SRVMwCSg1PDw4KQkJLyogcmVzZXJ2ZSAqLwogI2RlZmluZQlGTV9NTElNUFJPTQkoNjw8OCkJCS8qIGxpbWl0ZWQtcHJvbWlzY3VvdXMgbW9kZSAqLwotI2RlZmluZSBGTV9NUFJPTUlTQ09VUwkoNzw8OCkJCS8qIGFkZHJlc3MgZGV0ZWN0aW9uIDogcHJvbWlzY291cyAqLworI2RlZmluZSBGTV9NUFJPTUlTQ09VUwkoNzw8OCkJCS8qIGFkZHJlc3MgZGV0ZWN0aW9uIDogcHJvbWlzY3VvdXMgKi8KIAogI2RlZmluZSBGTV9TRUxTQQkweDA4MDAJCS8qIHNlbGVjdC1zaG9ydC1hZGRyZXNzIGJpdCAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2ZwL2h3bXRtLmMgYi9kcml2ZXJzL25ldC9za2ZwL2h3bXRtLmMKaW5kZXggYWY1YTc1NS4uZTI2Mzk4YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2tmcC9od210bS5jCisrKyBiL2RyaXZlcnMvbmV0L3NrZnAvaHdtdG0uYwpAQCAtNjkxLDcgKzY5MSw3IEBACiAgKgkJaW50ZXJydXB0IHNlcnZpY2Ugcm91dGluZSwgaGFuZGxlcyB0aGUgaW50ZXJydXB0IHJlcXVlc3RzCiAgKgkJZ2VuZXJhdGVkIGJ5IHRoZSBGRERJIGFkYXB0ZXIuCiAgKgotICogTk9URToJVGhlIG9wZXJhdGluZyBzeXN0ZW0gZGVwZW5kZW50IG1vZHVsZSBtdXN0IGdhcmFudGVlIHRoYXQgdGhlCisgKiBOT1RFOglUaGUgb3BlcmF0aW5nIHN5c3RlbSBkZXBlbmRlbnQgbW9kdWxlIG11c3QgZ3VhcmFudGVlIHRoYXQgdGhlCiAgKgkJaW50ZXJydXB0cyBvZiB0aGUgYWRhcHRlciBhcmUgZGlzYWJsZWQgd2hlbiBpdCBjYWxscyBmZGRpX2lzci4KICAqCiAgKglBYm91dCB0aGUgVVNFX0JSRUFLX0lTUiBtZWNoYW5pc21uOgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2tmcC9wY21wbGMuYyBiL2RyaXZlcnMvbmV0L3NrZnAvcGNtcGxjLmMKaW5kZXggMTEyZDM1Yi4uODhkMDJkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2tmcC9wY21wbGMuYworKysgYi9kcml2ZXJzL25ldC9za2ZwL3BjbXBsYy5jCkBAIC0xNjgwLDcgKzE2ODAsNyBAQAogCQkJICogUHJldmVudCBjb3VudGVyIGZyb20gYmVpbmcgd3JhcHBlZCBhZnRlcgogCQkJICogaGFuZ2luZyB5ZWFycyBpbiB0aGF0IGludGVycnVwdC4KIAkJCSAqLwotCQkJcGxjLT5lYnVmX2NvbnQrKyA7CS8qIEVidWYgY29udGlub3VzIGVycm9yICovCisJCQlwbGMtPmVidWZfY29udCsrIDsJLyogRWJ1ZiBjb250aW51b3VzIGVycm9yICovCiAJCX0KIAogI2lmZGVmCVNVUEVSTkVUXzMKQEAgLTE3MTcsOCArMTcxNyw4IEBACiAJCX0KICNlbmRpZgkvKiBTVVBFUk5FVF8zICovCiAJfSBlbHNlIHsKLQkJLyogUmVzZXQgdGhlIGNvbnRpbm91cyBlcnJvciB2YXJpYWJsZSAqLwotCQlwbGMtPmVidWZfY29udCA9IDAgOwkvKiByZXNldCBFYnVmIGNvbnRpbm91cyBlcnJvciAqLworCQkvKiBSZXNldCB0aGUgY29udGludW91cyBlcnJvciB2YXJpYWJsZSAqLworCQlwbGMtPmVidWZfY29udCA9IDAgOwkvKiByZXNldCBFYnVmIGNvbnRpbnVvdXMgZXJyb3IgKi8KIAl9CiAJaWYgKGNtZCAmIFBMX1BIWUlOVikgewkJLyogcGh5c2ljYWwgbGF5ZXIgaW52YWxpZCBzaWduYWwgKi8KIAkJcGxjLT5waHlpbnYrKyA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2ZwL3NtdC5jIGIvZHJpdmVycy9uZXQvc2tmcC9zbXQuYwppbmRleCAxZTFiZDBjLi4wOGQ5NDMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9za2ZwL3NtdC5jCisrKyBiL2RyaXZlcnMvbmV0L3NrZnAvc210LmMKQEAgLTIxOSw3ICsyMTksNyBAQAogCiAJLyoKIAkgKiBPbmx5IHdoZW4gcmluZyBpcyB1cCB3ZSB3aWxsIGhhdmUgYSB0b2tlbiBjb3VudC4gVGhlCi0JICogZmxhZyBpcyB1bmZvcnR1bmF0bHkgYSBzaW5nbGUgaW5zdGFuY2UgdmFsdWUuIFRoaXMKKwkgKiBmbGFnIGlzIHVuZm9ydHVuYXRlbHkgYSBzaW5nbGUgaW5zdGFuY2UgdmFsdWUuIFRoaXMKIAkgKiBkb2Vzbid0IG1hdHRlciBub3csIGJlY2F1c2Ugd2UgY3VycmVudGx5IGhhdmUgb25seQogCSAqIG9uZSBNQUMgaW5zdGFuY2UuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2dlLmggYi9kcml2ZXJzL25ldC9za2dlLmgKaW5kZXggNTA3YWRkYy4uNTFjMDIxNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2tnZS5oCisrKyBiL2RyaXZlcnMvbmV0L3NrZ2UuaApAQCAtMTAzOCw3ICsxMDM4LDcgQEAKIAogCVBIWV9TVF9QUkVfU1VQCT0gMTw8NiwgLyogQml0ICA2OglQcmVhbWJsZSBTdXBwcmVzc2lvbiAqLwogCVBIWV9TVF9BTl9PVkVSCT0gMTw8NSwgLyogQml0ICA1OglBdXRvLU5lZ290aWF0aW9uIE92ZXIgKi8KLQlQSFlfU1RfUkVNX0ZMVAk9IDE8PDQsIC8qIEJpdCAgNDoJUmVtb3RlIEZhdWx0IENvbmRpdGlvbiBPY2N1cmVkICovCisJUEhZX1NUX1JFTV9GTFQJPSAxPDw0LCAvKiBCaXQgIDQ6CVJlbW90ZSBGYXVsdCBDb25kaXRpb24gT2NjdXJyZWQgKi8KIAlQSFlfU1RfQU5fQ0FQCT0gMTw8MywgLyogQml0ICAzOglBdXRvLU5lZ290aWF0aW9uIENhcGFiaWxpdHkgKi8KIAlQSFlfU1RfTFNZTkMJPSAxPDwyLCAvKiBCaXQgIDI6CUxpbmsgU3luY2hyb25pemVkICovCiAJUEhZX1NUX0pBQl9ERVQJPSAxPDwxLCAvKiBCaXQgIDE6CUphYmJlciBEZXRlY3RlZCAqLwpAQCAtMTcyMSw4ICsxNzIxLDggQEAKIAlHTV9HUFNSX0xJTktfVVAJCT0gMTw8MTIsIC8qIEJpdCAxMjoJTGluayBVcCBTdGF0dXMgKi8KIAlHTV9HUFNSX1BBVVNFCQk9IDE8PDExLCAvKiBCaXQgMTE6CVBhdXNlIFN0YXRlICovCiAJR01fR1BTUl9UWF9BQ1RJVkUJPSAxPDwxMCwgLyogQml0IDEwOglUeCBpbiBQcm9ncmVzcyAqLwotCUdNX0dQU1JfRVhDX0NPTAkJPSAxPDw5LAkvKiBCaXQgIDk6CUV4Y2Vzc2l2ZSBDb2xsaXNpb25zIE9jY3VyZWQgKi8KLQlHTV9HUFNSX0xBVF9DT0wJCT0gMTw8OCwJLyogQml0ICA4OglMYXRlIENvbGxpc2lvbnMgT2NjdXJlZCAqLworCUdNX0dQU1JfRVhDX0NPTAkJPSAxPDw5LAkvKiBCaXQgIDk6CUV4Y2Vzc2l2ZSBDb2xsaXNpb25zIE9jY3VycmVkICovCisJR01fR1BTUl9MQVRfQ09MCQk9IDE8PDgsCS8qIEJpdCAgODoJTGF0ZSBDb2xsaXNpb25zIE9jY3VycmVkICovCiAKIAlHTV9HUFNSX1BIWV9TVF9DSAk9IDE8PDUsCS8qIEJpdCAgNToJUEhZIFN0YXR1cyBDaGFuZ2UgKi8KIAlHTV9HUFNSX0dJR19TUEVFRAk9IDE8PDQsCS8qIEJpdCAgNDoJR2lnYWJpdCBTcGVlZCAoMSA9IDEwMDAgTWJwcykgKi8KQEAgLTIyMjcsNyArMjIyNyw3IEBACiAJWE1fU1RfQkMJPSAxPDw3LAkJLyogQml0ICA3OglCcm9hZGNhc3QgcGFja2V0ICovCiAJWE1fU1RfTUMJPSAxPDw2LAkJLyogQml0ICA2OglNdWx0aWNhc3QgcGFja2V0ICovCiAJWE1fU1RfVUMJPSAxPDw1LAkJLyogQml0ICA1OglVbmljYXN0IHBhY2tldCAqLwotCVhNX1NUX1RYX1VSCT0gMTw8NCwJCS8qIEJpdCAgNDoJRklGTyBVbmRlcnJ1biBvY2N1cmVkICovCisJWE1fU1RfVFhfVVIJPSAxPDw0LAkJLyogQml0ICA0OglGSUZPIFVuZGVycnVuIG9jY3VycmVkICovCiAJWE1fU1RfQ1NfRVJSCT0gMTw8MywJCS8qIEJpdCAgMzoJQ2FycmllciBTZW5zZSBFcnJvciAqLwogCVhNX1NUX0xBVF9DT0wJPSAxPDwyLAkJLyogQml0ICAyOglMYXRlIENvbGxpc2lvbiBFcnJvciAqLwogCVhNX1NUX01VTF9DT0wJPSAxPDwxLAkJLyogQml0ICAxOglNdWx0aXBsZSBDb2xsaXNpb25zICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za3kyLmMgYi9kcml2ZXJzL25ldC9za3kyLmMKaW5kZXggMmE5MTg2OC4uZmY4ZDI2MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2t5Mi5jCisrKyBiL2RyaXZlcnMvbmV0L3NreTIuYwpAQCAtOTMyLDcgKzkzMiw3IEBACiAJc2t5Ml93cml0ZTgoaHcsIFNLX1JFRyhwb3J0LCBUWF9HTUZfQ1RSTF9UKSwgR01GX1JTVF9DTFIpOwogCXNreTJfd3JpdGUxNihodywgU0tfUkVHKHBvcnQsIFRYX0dNRl9DVFJMX1QpLCBHTUZfT1BFUl9PTik7CiAKLQkvKiBPbiBjaGlwcyB3aXRob3V0IHJhbSBidWZmZXIsIHBhdXNlIGlzIGNvbnRyb2xlZCBieSBNQUMgbGV2ZWwgKi8KKwkvKiBPbiBjaGlwcyB3aXRob3V0IHJhbSBidWZmZXIsIHBhdXNlIGlzIGNvbnRyb2xsZWQgYnkgTUFDIGxldmVsICovCiAJaWYgKCEoaHctPmZsYWdzICYgU0tZMl9IV19SQU1fQlVGRkVSKSkgewogCQkvKiBQYXVzZSB0aHJlc2hvbGQgaXMgc2NhbGVkIGJ5IDggaW4gYnl0ZXMgKi8KIAkJaWYgKGh3LT5jaGlwX2lkID09IENISVBfSURfWVVLT05fRkVfUCAmJgpAQCAtMzI1NSw3ICszMjU1LDcgQEAKIAogLyogVGFrZSBkZXZpY2UgZG93biAob2ZmbGluZSkuCiAgKiBFcXVpdmFsZW50IHRvIGRvaW5nIGRldl9zdG9wKCkgYnV0IHRoaXMgZG9lcyBub3QKLSAqIGluZm9ybSB1cHBlciBsYXllcnMgb2YgdGhlIHRyYW5zaXN0aW9uLgorICogaW5mb3JtIHVwcGVyIGxheWVycyBvZiB0aGUgdHJhbnNpdGlvbi4KICAqLwogc3RhdGljIHZvaWQgc2t5Ml9kZXRhY2goc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NreTIuaCBiL2RyaXZlcnMvbmV0L3NreTIuaAppbmRleCA2ODYxYjBlLi4wYzZkMTBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9za3kyLmgKKysrIGIvZHJpdmVycy9uZXQvc2t5Mi5oCkBAIC0xMTk0LDcgKzExOTQsNyBAQAogCiAJUEhZX1NUX1BSRV9TVVAJPSAxPDw2LCAvKiBCaXQgIDY6CVByZWFtYmxlIFN1cHByZXNzaW9uICovCiAJUEhZX1NUX0FOX09WRVIJPSAxPDw1LCAvKiBCaXQgIDU6CUF1dG8tTmVnb3RpYXRpb24gT3ZlciAqLwotCVBIWV9TVF9SRU1fRkxUCT0gMTw8NCwgLyogQml0ICA0OglSZW1vdGUgRmF1bHQgQ29uZGl0aW9uIE9jY3VyZWQgKi8KKwlQSFlfU1RfUkVNX0ZMVAk9IDE8PDQsIC8qIEJpdCAgNDoJUmVtb3RlIEZhdWx0IENvbmRpdGlvbiBPY2N1cnJlZCAqLwogCVBIWV9TVF9BTl9DQVAJPSAxPDwzLCAvKiBCaXQgIDM6CUF1dG8tTmVnb3RpYXRpb24gQ2FwYWJpbGl0eSAqLwogCVBIWV9TVF9MU1lOQwk9IDE8PDIsIC8qIEJpdCAgMjoJTGluayBTeW5jaHJvbml6ZWQgKi8KIAlQSFlfU1RfSkFCX0RFVAk9IDE8PDEsIC8qIEJpdCAgMToJSmFiYmVyIERldGVjdGVkICovCkBAIC0xNzI1LDggKzE3MjUsOCBAQAogCUdNX0dQU1JfTElOS19VUAkJPSAxPDwxMiwgLyogQml0IDEyOglMaW5rIFVwIFN0YXR1cyAqLwogCUdNX0dQU1JfUEFVU0UJCT0gMTw8MTEsIC8qIEJpdCAxMToJUGF1c2UgU3RhdGUgKi8KIAlHTV9HUFNSX1RYX0FDVElWRQk9IDE8PDEwLCAvKiBCaXQgMTA6CVR4IGluIFByb2dyZXNzICovCi0JR01fR1BTUl9FWENfQ09MCQk9IDE8PDksCS8qIEJpdCAgOToJRXhjZXNzaXZlIENvbGxpc2lvbnMgT2NjdXJlZCAqLwotCUdNX0dQU1JfTEFUX0NPTAkJPSAxPDw4LAkvKiBCaXQgIDg6CUxhdGUgQ29sbGlzaW9ucyBPY2N1cmVkICovCisJR01fR1BTUl9FWENfQ09MCQk9IDE8PDksCS8qIEJpdCAgOToJRXhjZXNzaXZlIENvbGxpc2lvbnMgT2NjdXJyZWQgKi8KKwlHTV9HUFNSX0xBVF9DT0wJCT0gMTw8OCwJLyogQml0ICA4OglMYXRlIENvbGxpc2lvbnMgT2NjdXJyZWQgKi8KIAogCUdNX0dQU1JfUEhZX1NUX0NICT0gMTw8NSwJLyogQml0ICA1OglQSFkgU3RhdHVzIENoYW5nZSAqLwogCUdNX0dQU1JfR0lHX1NQRUVECT0gMTw8NCwJLyogQml0ICA0OglHaWdhYml0IFNwZWVkICgxID0gMTAwMCBNYnBzKSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc21jOTF4LmggYi9kcml2ZXJzL25ldC9zbWM5MXguaAppbmRleCA2OGQ0OGFiLi41ZjUzZmJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zbWM5MXguaAorKysgYi9kcml2ZXJzL25ldC9zbWM5MXguaApAQCAtOTIxLDcgKzkyMSw3IEBACiAgKiBIYWNrIEFsZXJ0OiBTb21lIHNldHVwcyBqdXN0IGNhbid0IHdyaXRlIDggb3IgMTYgYml0cyByZWxpYWJseSB3aGVuIG5vdAogICogYWxpZ25lZCB0byBhIDMyIGJpdCBib3VuZGFyeS4gIEkgdGVsbCB5b3UgdGhhdCBkb2VzIGV4aXN0IQogICogRm9ydHVuYXRlbHkgdGhlIGFmZmVjdGVkIHJlZ2lzdGVyIGFjY2Vzc2VzIGNhbiBiZSBlYXNpbHkgd29ya2VkIGFyb3VuZAotICogc2luY2Ugd2UgY2FuIHdyaXRlIHplcm9lcyB0byB0aGUgcHJlY2VlZGluZyAxNiBiaXRzIHdpdGhvdXQgYWR2ZXJzZQorICogc2luY2Ugd2UgY2FuIHdyaXRlIHplcm9lcyB0byB0aGUgcHJlY2VkaW5nIDE2IGJpdHMgd2l0aG91dCBhZHZlcnNlCiAgKiBlZmZlY3RzIGFuZCB1c2UgYSAzMi1iaXQgYWNjZXNzLgogICoKICAqIEVuZm9yY2UgaXQgb24gYW55IDMyLWJpdCBjYXBhYmxlIHNldHVwIGZvciBub3cuCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zbXNjOTExeC5jIGIvZHJpdmVycy9uZXQvc21zYzkxMXguYwppbmRleCAxNTY2MjU5Li40YjQyZWNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zbXNjOTExeC5jCisrKyBiL2RyaXZlcnMvbmV0L3Ntc2M5MTF4LmMKQEAgLTE2NjksNyArMTY2OSw3IEBACiAJfQogCiAJaWYgKGUyY21kICYgRTJQX0NNRF9FUENfVElNRU9VVF8pIHsKLQkJU01TQ19UUkFDRShEUlYsICJFcnJvciBvY2N1cmVkIGR1cmluZyBlZXByb20gb3BlcmF0aW9uIik7CisJCVNNU0NfVFJBQ0UoRFJWLCAiRXJyb3Igb2NjdXJyZWQgZHVyaW5nIGVlcHJvbSBvcGVyYXRpb24iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCkBAIC0xODE4LDYgKzE4MTgsNyBAQAogCVNNU0NfVFJBQ0UoUFJPQkUsICJQSFkgd2lsbCBiZSBhdXRvZGV0ZWN0ZWQuIik7CiAKIAlzcGluX2xvY2tfaW5pdCgmcGRhdGEtPmRldl9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmcGRhdGEtPm1hY19sb2NrKTsKIAogCWlmIChwZGF0YS0+aW9hZGRyID09IDApIHsKIAkJU01TQ19XQVJOSU5HKFBST0JFLCAicGRhdGEtPmlvYWRkcjogMHgwMDAwMDAwMCIpOwpAQCAtMTg5NSw4ICsxODk2LDExIEBACiAJLyogd29ya2Fyb3VuZCBmb3IgcGxhdGZvcm1zIHdpdGhvdXQgYW4gZWVwcm9tLCB3aGVyZSB0aGUgbWFjIGFkZHJlc3MKIAkgKiBpcyBzdG9yZWQgZWxzZXdoZXJlIGFuZCBzZXQgYnkgdGhlIGJvb3Rsb2FkZXIuICBUaGlzIHNhdmVzIHRoZQogCSAqIG1hYyBhZGRyZXNzIGJlZm9yZSByZXNldHRpbmcgdGhlIGRldmljZSAqLwotCWlmIChwZGF0YS0+Y29uZmlnLmZsYWdzICYgU01TQzkxMVhfU0FWRV9NQUNfQUREUkVTUykKKwlpZiAocGRhdGEtPmNvbmZpZy5mbGFncyAmIFNNU0M5MTFYX1NBVkVfTUFDX0FERFJFU1MpIHsKKwkJc3Bpbl9sb2NrX2lycSgmcGRhdGEtPm1hY19sb2NrKTsKIAkJc21zYzkxMXhfcmVhZF9tYWNfYWRkcmVzcyhkZXYpOworCQlzcGluX3VubG9ja19pcnEoJnBkYXRhLT5tYWNfbG9jayk7CisJfQogCiAJLyogUmVzZXQgdGhlIExBTjkxMXggKi8KIAlpZiAoc21zYzkxMXhfc29mdF9yZXNldChwZGF0YSkpCkBAIC0yMDU5LDggKzIwNjMsNiBAQAogCQlTTVNDX1RSQUNFKFBST0JFLCAiTmV0d29yayBpbnRlcmZhY2U6IFwiJXNcIiIsIGRldi0+bmFtZSk7CiAJfQogCi0Jc3Bpbl9sb2NrX2luaXQoJnBkYXRhLT5tYWNfbG9jayk7Ci0KIAlyZXR2YWwgPSBzbXNjOTExeF9taWlfaW5pdChwZGV2LCBkZXYpOwogCWlmIChyZXR2YWwpIHsKIAkJU01TQ19XQVJOSU5HKFBST0JFLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc21zYzk0MjAuYyBiL2RyaXZlcnMvbmV0L3Ntc2M5NDIwLmMKaW5kZXggYjA5ZWUxYy4uNGM5MmFkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc21zYzk0MjAuYworKysgYi9kcml2ZXJzL25ldC9zbXNjOTQyMC5jCkBAIC0zNjQsNyArMzY0LDcgQEAKIAl9CiAKIAlpZiAoZTJjbWQgJiBFMlBfQ01EX0VQQ19USU1FT1VUXykgewotCQlzbXNjX2luZm8oSFcsICJFcnJvciBvY2N1cmVkIGR1cmluZyBlZXByb20gb3BlcmF0aW9uIik7CisJCXNtc2NfaW5mbyhIVywgIkVycm9yIG9jY3VycmVkIGR1cmluZyBlZXByb20gb3BlcmF0aW9uIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL25vcm1fZGVzYy5jIGIvZHJpdmVycy9uZXQvc3RtbWFjL25vcm1fZGVzYy5jCmluZGV4IGNkMGNjNzYuLjAyOWMyYTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3N0bW1hYy9ub3JtX2Rlc2MuYworKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvbm9ybV9kZXNjLmMKQEAgLTY3LDcgKzY3LDcgQEAKIAogLyogVGhpcyBmdW5jdGlvbiB2ZXJpZmllcyBpZiBlYWNoIGluY29taW5nIGZyYW1lIGhhcyBzb21lIGVycm9ycwogICogYW5kLCBpZiByZXF1aXJlZCwgdXBkYXRlcyB0aGUgbXVsdGljYXN0IHN0YXRpc3RpY3MuCi0gKiBJbiBjYXNlIG9mIHN1Y2Nlc3MsIGl0IHJldHVybnMgY3N1bV9ub25lIGJlY2FzdWUgdGhlIGRldmljZQorICogSW4gY2FzZSBvZiBzdWNjZXNzLCBpdCByZXR1cm5zIGNzdW1fbm9uZSBiZWNhdXNlIHRoZSBkZXZpY2UKICAqIGlzIG5vdCBhYmxlIHRvIGNvbXB1dGUgdGhlIGNzdW0gaW4gSFcuICovCiBzdGF0aWMgaW50IG5kZXNjX2dldF9yeF9zdGF0dXModm9pZCAqZGF0YSwgc3RydWN0IHN0bW1hY19leHRyYV9zdGF0cyAqeCwKIAkJCSAgICAgICBzdHJ1Y3QgZG1hX2Rlc2MgKnApCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zdW5ibWFjLmggYi9kcml2ZXJzL25ldC9zdW5ibWFjLmgKaW5kZXggOGRiODg5NC4uNDk0M2U5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc3VuYm1hYy5oCisrKyBiL2RyaXZlcnMvbmV0L3N1bmJtYWMuaApAQCAtMTg1LDcgKzE4NSw3IEBACiAjZGVmaW5lIEJJR01BQ19SWENGR19FTkFCTEUgICAgMHgwMDAwMDAwMSAvKiBFbmFibGUgdGhlIHJlY2VpdmVyICAgICAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIEJJR01BQ19SWENGR19GSUZPICAgICAgMHgwMDAwMDAwZSAvKiBEZWZhdWx0IHJ4IGZ0aHJlc2guLi4gICAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIEJJR01BQ19SWENGR19QU1RSSVAgICAgMHgwMDAwMDAyMCAvKiBQYWQgYnl0ZSBzdHJpcCBlbmFibGUgICAgICAgICAgICAgICAgICAgICovCi0jZGVmaW5lIEJJR01BQ19SWENGR19QTUlTQyAgICAgMHgwMDAwMDA0MCAvKiBFbmFibGUgcHJvbWlzY291cyBtb2RlICAgICAgICAgICAgICAgICAgICovCisjZGVmaW5lIEJJR01BQ19SWENGR19QTUlTQyAgICAgMHgwMDAwMDA0MCAvKiBFbmFibGUgcHJvbWlzY3VvdXMgbW9kZSAgICAgICAgICAgICAgICAgICAqLwogI2RlZmluZSBCSUdNQUNfUlhDRkdfREVSUiAgICAgIDB4MDAwMDAwODAgLyogRGlzYWJsZSBlcnJvciBjaGVja2luZyAgICAgICAgICAgICAgICAgICAqLwogI2RlZmluZSBCSUdNQUNfUlhDRkdfRENSQ1MgICAgIDB4MDAwMDAxMDAgLyogRGlzYWJsZSBDUkMgc3RyaXBwaW5nICAgICAgICAgICAgICAgICAgICAqLwogI2RlZmluZSBCSUdNQUNfUlhDRkdfTUUgICAgICAgIDB4MDAwMDAyMDAgLyogUmVjZWl2ZSBwYWNrZXRzIGFkZHJlc3NlZCB0byBtZSAgICAgICAgICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3VuZ2VtLmMgYi9kcml2ZXJzL25ldC9zdW5nZW0uYwppbmRleCBjMWEzNDQ4Li5kM2JlNzM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zdW5nZW0uYworKysgYi9kcml2ZXJzL25ldC9zdW5nZW0uYwpAQCAtMTE1MCw3ICsxMTUwLDcgQEAKIAl2YWwgJj0gfihQQ1NfQ0ZHX0VOQUJMRSB8IFBDU19DRkdfVE8pOwogCXdyaXRlbCh2YWwsIGdwLT5yZWdzICsgUENTX0NGRyk7CiAKLQkvKiBBZHZlcnRpc2UgYWxsIGNhcGFiaWxpdGllcyBleGNlcHQgYXNzeW1ldHJpYworCS8qIEFkdmVydGlzZSBhbGwgY2FwYWJpbGl0aWVzIGV4Y2VwdCBhc3ltbWV0cmljCiAJICogcGF1c2UuCiAJICovCiAJdmFsID0gcmVhZGwoZ3AtPnJlZ3MgKyBQQ1NfTUlJQURWKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3N1bmhtZS5oIGIvZHJpdmVycy9uZXQvc3VuaG1lLmgKaW5kZXggNzU2YjViZi4uNjRmMjc4MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc3VuaG1lLmgKKysrIGIvZHJpdmVycy9uZXQvc3VuaG1lLmgKQEAgLTIyMyw3ICsyMjMsNyBAQAogLyogQmlnTWFjIHJlY2VpdmUgY29uZmlnIHJlZ2lzdGVyLiAqLwogI2RlZmluZSBCSUdNQUNfUlhDRkdfRU5BQkxFICAgMHgwMDAwMDAwMSAvKiBFbmFibGUgdGhlIHJlY2VpdmVyICAgICAgICAgICAgICovCiAjZGVmaW5lIEJJR01BQ19SWENGR19QU1RSSVAgICAweDAwMDAwMDIwIC8qIFBhZCBieXRlIHN0cmlwIGVuYWJsZSAgICAgICAgICAgKi8KLSNkZWZpbmUgQklHTUFDX1JYQ0ZHX1BNSVNDICAgIDB4MDAwMDAwNDAgLyogRW5hYmxlIHByb21pc2NvdXMgbW9kZSAgICAgICAgICAqLworI2RlZmluZSBCSUdNQUNfUlhDRkdfUE1JU0MgICAgMHgwMDAwMDA0MCAvKiBFbmFibGUgcHJvbWlzY3VvdXMgbW9kZSAgICAgICAgICAqLwogI2RlZmluZSBCSUdNQUNfUlhDRkdfREVSUiAgICAgMHgwMDAwMDA4MCAvKiBEaXNhYmxlIGVycm9yIGNoZWNraW5nICAgICAgICAgICovCiAjZGVmaW5lIEJJR01BQ19SWENGR19EQ1JDUyAgICAweDAwMDAwMTAwIC8qIERpc2FibGUgQ1JDIHN0cmlwcGluZyAgICAgICAgICAgKi8KICNkZWZpbmUgQklHTUFDX1JYQ0ZHX1JFSk1FICAgIDB4MDAwMDAyMDAgLyogUmVqZWN0IHBhY2tldHMgYWRkcmVzc2VkIHRvIG1lICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdGMzNTgxNS5jIGIvZHJpdmVycy9uZXQvdGMzNTgxNS5jCmluZGV4IGI2ZWVjOGMuLjdjYTUxY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3RjMzU4MTUuYworKysgYi9kcml2ZXJzL25ldC90YzM1ODE1LmMKQEAgLTExOSwxMyArMTE5LDEzIEBACiAvKgogICogQml0IGFzc2lnbm1lbnRzCiAgKi8KLS8qIERNQV9DdGwgYml0IGFzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKy8qIERNQV9DdGwgYml0IGFzc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAjZGVmaW5lIERNQV9SeEFsaWduCSAgICAgICAweDAwYzAwMDAwIC8qIDE6UmVjZXB0aW9uIEFsaWdubWVudAkgICAgICovCiAjZGVmaW5lIERNQV9SeEFsaWduXzEJICAgICAgIDB4MDA0MDAwMDAKICNkZWZpbmUgRE1BX1J4QWxpZ25fMgkgICAgICAgMHgwMDgwMDAwMAogI2RlZmluZSBETUFfUnhBbGlnbl8zCSAgICAgICAweDAwYzAwMDAwCiAjZGVmaW5lIERNQV9NNjZFblN0YXQJICAgICAgIDB4MDAwODAwMDAgLyogMTo2Nk1IeiBFbmFibGUgU3RhdGUJICAgICAqLwotI2RlZmluZSBETUFfSW50TWFzawkgICAgICAgMHgwMDA0MDAwMCAvKiAxOkludGVydXB0IG1hc2sJCSAgICAgKi8KKyNkZWZpbmUgRE1BX0ludE1hc2sJICAgICAgIDB4MDAwNDAwMDAgLyogMTpJbnRlcnJ1cHQgbWFzawkJICAgICAqLwogI2RlZmluZSBETUFfU1dJbnRSZXEJICAgICAgIDB4MDAwMjAwMDAgLyogMTpTb2Z0d2FyZSBJbnRlcnJ1cHQgcmVxdWVzdCAgICAqLwogI2RlZmluZSBETUFfVHhXYWtlVXAJICAgICAgIDB4MDAwMTAwMDAgLyogMTpUcmFuc21pdCBXYWtlIFVwCQkgICAgICovCiAjZGVmaW5lIERNQV9SeEJpZ0UJICAgICAgIDB4MDAwMDgwMDAgLyogMTpSZWNlaXZlIEJpZyBFbmRpYW4JICAgICAqLwpAQCAtMTM0LDExICsxMzQsMTEgQEAKICNkZWZpbmUgRE1BX1Bvd3JNZ21udAkgICAgICAgMHgwMDAwMTAwMCAvKiAxOlBvd2VyIE1hbmFnZW1lbnQJCSAgICAgKi8KICNkZWZpbmUgRE1BX0RtQnVyc3RfTWFzayAgICAgICAweDAwMDAwMWZjIC8qIERNQSBCdXJzdCBzaXplCQkgICAgICovCiAKLS8qIFJ4RnJhZ1NpemUgYml0IGFzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKy8qIFJ4RnJhZ1NpemUgYml0IGFzc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAjZGVmaW5lIFJ4RnJhZ19FblBhY2sJICAgICAgIDB4MDAwMDgwMDAgLyogMTpFbmFibGUgUGFja2luZwkJICAgICAqLwogI2RlZmluZSBSeEZyYWdfTWluRnJhZ01hc2sgICAgIDB4MDAwMDBmZmMgLyogTWluaW11bSBGcmFnbWVudAkJICAgICAqLwogCi0vKiBNQUNfQ3RsIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBNQUNfQ3RsIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogI2RlZmluZSBNQUNfTGluazEwCSAgICAgICAweDAwMDA4MDAwIC8qIDE6TGluayBTdGF0dXMgMTBNYml0cwkgICAgICovCiAjZGVmaW5lIE1BQ19Fbk1pc3NSb2xsCSAgICAgICAweDAwMDAyMDAwIC8qIDE6RW5hYmxlIE1pc3NlZCBSb2xsCSAgICAgKi8KICNkZWZpbmUgTUFDX01pc3NSb2xsCSAgICAgICAweDAwMDAwNDAwIC8qIDE6TWlzc2VkIFJvbGwJCSAgICAgKi8KQEAgLTE1Miw3ICsxNTIsNyBAQAogI2RlZmluZSBNQUNfSGFsdEltbQkgICAgICAgMHgwMDAwMDAwMiAvKiAxOkhhbHQgSW1tZWRpYXRlCQkgICAgICovCiAjZGVmaW5lIE1BQ19IYWx0UmVxCSAgICAgICAweDAwMDAwMDAxIC8qIDE6SGFsdCByZXF1ZXN0CQkgICAgICovCiAKLS8qIFBST01fQ3RsIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKy8qIFBST01fQ3RsIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAjZGVmaW5lIFBST01fQnVzeQkgICAgICAgMHgwMDAwODAwMCAvKiAxOkJ1c3kgKFN0YXJ0IE9wZXJhdGlvbikJICAgICAqLwogI2RlZmluZSBQUk9NX1JlYWQJICAgICAgIDB4MDAwMDQwMDAgLyoxMDpSZWFkIG9wZXJhdGlvbgkJICAgICAqLwogI2RlZmluZSBQUk9NX1dyaXRlCSAgICAgICAweDAwMDAyMDAwIC8qMDE6V3JpdGUgb3BlcmF0aW9uCQkgICAgICovCkBAIC0xNjIsNyArMTYyLDcgQEAKICNkZWZpbmUgUFJPTV9BZGRyX0VuYQkgICAgICAgMHgwMDAwMDAzMCAvKjExeHh4eDpQUk9NIFdyaXRlIGVuYWJsZQkgICAgICovCiAJCQkJCSAgLyowMHh4eHg6CSAgICAgIGRpc2FibGUJICAgICAqLwogCi0vKiBDQU1fQ3RsIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBDQU1fQ3RsIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogI2RlZmluZSBDQU1fQ29tcEVuCSAgICAgICAweDAwMDAwMDEwIC8qIDE6Q0FNIENvbXBhcmUgRW5hYmxlCSAgICAgKi8KICNkZWZpbmUgQ0FNX05lZ0NBTQkgICAgICAgMHgwMDAwMDAwOCAvKiAxOlJlamVjdCBwYWNrZXRzIENBTSByZWNvZ25pemVzLCovCiAJCQkJCSAgLyoJCQlhY2NlcHQgb3RoZXIgKi8KQEAgLTE3MCw3ICsxNzAsNyBAQAogI2RlZmluZSBDQU1fR3JvdXBBY2MJICAgICAgIDB4MDAwMDAwMDIgLyogMTpNdWx0aWNhc3QgYXNzZXB0CQkgICAgICovCiAjZGVmaW5lIENBTV9TdGF0aW9uQWNjCSAgICAgICAweDAwMDAwMDAxIC8qIDE6dW5pY2FzdCBhY2NlcHQJCSAgICAgKi8KIAotLyogQ0FNX0VuYSBiaXQgYXNpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworLyogQ0FNX0VuYSBiaXQgYXNzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICNkZWZpbmUgQ0FNX0VOVFJZX01BWAkJICAgICAgIDIxICAgLyogQ0FNIERhdGEgZW50cnkgbWF4IGNvdW50CSAgICAgKi8KICNkZWZpbmUgQ0FNX0VuYV9NYXNrICgoMTw8Q0FNX0VOVFJZX01BWCktMSkgLyogQ0FNIEVuYWJsZSBiaXRzIChNYXggMjFiaXRzKSAgKi8KICNkZWZpbmUgQ0FNX0VuYV9CaXQoaW5kZXgpCSgxIDw8IChpbmRleCkpCkBAIC0xNzgsNyArMTc4LDcgQEAKICNkZWZpbmUgQ0FNX0VOVFJZX1NPVVJDRQkxCiAjZGVmaW5lIENBTV9FTlRSWV9NQUNDVEwJMjAKIAotLyogVHhfQ3RsIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworLyogVHhfQ3RsIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICNkZWZpbmUgVHhfRW4JCSAgICAgICAweDAwMDAwMDAxIC8qIDE6VHJhbnNtaXQgZW5hYmxlCQkgICAgICovCiAjZGVmaW5lIFR4X1R4SGFsdAkgICAgICAgMHgwMDAwMDAwMiAvKiAxOlRyYW5zbWl0IEhhbHQgUmVxdWVzdAkgICAgICovCiAjZGVmaW5lIFR4X05vUGFkCSAgICAgICAweDAwMDAwMDA0IC8qIDE6U3VwcHJlc3MgUGFkZGluZwkJICAgICAqLwpAQCAtMTkyLDcgKzE5Miw3IEBACiAjZGVmaW5lIFR4X0VuVHhQYXIJICAgICAgIDB4MDAwMDIwMDAgLyogMTpFbmFibGUgVHJhbnNtaXQgUGFyaXR5CSAgICAgKi8KICNkZWZpbmUgVHhfRW5Db21wCSAgICAgICAweDAwMDA0MDAwIC8qIDE6RW5hYmxlIENvbXBsZXRpb24JICAgICAqLwogCi0vKiBUeF9TdGF0IGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBUeF9TdGF0IGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogI2RlZmluZSBUeF9UeENvbGxfTUFTSwkgICAgICAgMHgwMDAwMDAwRiAvKiBUeCBDb2xsaXNpb24gQ291bnQJCSAgICAgKi8KICNkZWZpbmUgVHhfRXhDb2xsCSAgICAgICAweDAwMDAwMDEwIC8qIEV4Y2Vzc2l2ZSBDb2xsaXNpb24JICAgICAqLwogI2RlZmluZSBUeF9UWERlZmVyCSAgICAgICAweDAwMDAwMDIwIC8qIFRyYW5zbWl0IERlZmVyZWQJCSAgICAgKi8KQEAgLTIwOCw3ICsyMDgsNyBAQAogI2RlZmluZSBUeF9IYWx0ZWQJICAgICAgIDB4MDAwMDgwMDAgLyogVHggSGFsdGVkCQkJICAgICAqLwogI2RlZmluZSBUeF9TUUVycgkgICAgICAgMHgwMDAxMDAwMCAvKiBTaWduYWwgUXVhbGl0eSBFcnJvcihTUUUpCSAgICAgKi8KIAotLyogUnhfQ3RsIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworLyogUnhfQ3RsIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICNkZWZpbmUgUnhfRW5Hb29kCSAgICAgICAweDAwMDA0MDAwIC8qIDE6RW5hYmxlIEdvb2QJCSAgICAgKi8KICNkZWZpbmUgUnhfRW5SeFBhcgkgICAgICAgMHgwMDAwMjAwMCAvKiAxOkVuYWJsZSBSZWNlaXZlIFBhcml0eQkgICAgICovCiAjZGVmaW5lIFJ4X0VuTG9uZ0VycgkgICAgICAgMHgwMDAwMDgwMCAvKiAxOkVuYWJsZSBMb25nIEVycm9yCSAgICAgKi8KQEAgLTIyMiw3ICsyMjIsNyBAQAogI2RlZmluZSBSeF9SeEhhbHQJICAgICAgIDB4MDAwMDAwMDIgLyogMTpSZWNlaXZlIEhhbHQgUmVxdWVzdAkgICAgICovCiAjZGVmaW5lIFJ4X1J4RW4JCSAgICAgICAweDAwMDAwMDAxIC8qIDE6UmVjZWl2ZSBJbnRycnVwdCBFbmFibGUJICAgICAqLwogCi0vKiBSeF9TdGF0IGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBSeF9TdGF0IGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogI2RlZmluZSBSeF9IYWx0ZWQJICAgICAgIDB4MDAwMDgwMDAgLyogUnggSGFsdGVkCQkJICAgICAqLwogI2RlZmluZSBSeF9Hb29kCQkgICAgICAgMHgwMDAwNDAwMCAvKiBSeCBHb29kCQkJICAgICAqLwogI2RlZmluZSBSeF9SeFBhcgkgICAgICAgMHgwMDAwMjAwMCAvKiBSeCBQYXJpdHkgRXJyb3IJCSAgICAgKi8KQEAgLTIzOCw3ICsyMzgsNyBAQAogCiAjZGVmaW5lIFJ4X1N0YXRfTWFzawkgICAgICAgMHgwMDAwRkZGMCAvKiBSeCBBbGwgU3RhdHVzIE1hc2sJCSAgICAgKi8KIAotLyogSW50X0VuIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworLyogSW50X0VuIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICNkZWZpbmUgSW50X05SQWJ0RW4JICAgICAgIDB4MDAwMDA4MDAgLyogMTpOb24tcmVjb3ZlcmFibGUgQWJvcnQgRW5hYmxlICAqLwogI2RlZmluZSBJbnRfVHhDdGxDbXBFbgkgICAgICAgMHgwMDAwMDQwMCAvKiAxOlRyYW5zbWl0IEN0bCBDb21wbGV0ZSBFbmFibGUgICovCiAjZGVmaW5lIEludF9EbVBhckVyckVuCSAgICAgICAweDAwMDAwMjAwIC8qIDE6RE1BIFBhcml0eSBFcnJvciBFbmFibGUJICAgICAqLwpAQCAtMjUzLDcgKzI1Myw3IEBACiAjZGVmaW5lIEludF9GREFFeEVuCSAgICAgICAweDAwMDAwMDAxIC8qIDE6RnJlZSBEZXNjcmlwdG9yIEFyZWEJICAgICAqLwogCQkJCQkgIC8qCQkgICBFeGhhdXN0ZWQgRW5hYmxlICAqLwogCi0vKiBJbnRfU3JjIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBJbnRfU3JjIGJpdCBhc3NpZ24gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogI2RlZmluZSBJbnRfTlJhYnQJICAgICAgIDB4MDAwMDQwMDAgLyogMTpOb24gUmVjb3ZlcmFibGUgZXJyb3IJICAgICAqLwogI2RlZmluZSBJbnRfRG1QYXJFcnJTdGF0ICAgICAgIDB4MDAwMDIwMDAgLyogMTpETUEgUGFyaXR5IEVycm9yICYgQ2xlYXIJICAgICAqLwogI2RlZmluZSBJbnRfQkxFeAkgICAgICAgMHgwMDAwMTAwMCAvKiAxOkJ1ZmZlciBMaXN0IEVtcHR5ICYgQ2xlYXIgICAgICovCkBAIC0yNzAsOCArMjcwLDggQEAKICNkZWZpbmUgSW50X0ludE1hY1J4CSAgICAgICAweDAwMDAwMDAyIC8qIDE6UnggY29udHJvbGxlciAmIENsZWFyCSAgICAgKi8KICNkZWZpbmUgSW50X0ludE1hY1R4CSAgICAgICAweDAwMDAwMDAxIC8qIDE6VHggY29udHJvbGxlciAmIENsZWFyCSAgICAgKi8KIAotLyogTURfQ0EgYml0IGFzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotI2RlZmluZSBNRF9DQV9QcmVTdXAJICAgICAgIDB4MDAwMDEwMDAgLyogMTpQcmVhbWJsZSBTdXByZXNzCQkgICAgICovCisvKiBNRF9DQSBiaXQgYXNzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworI2RlZmluZSBNRF9DQV9QcmVTdXAJICAgICAgIDB4MDAwMDEwMDAgLyogMTpQcmVhbWJsZSBTdXBwcmVzcwkJICAgICAqLwogI2RlZmluZSBNRF9DQV9CdXN5CSAgICAgICAweDAwMDAwODAwIC8qIDE6QnVzeSAoU3RhcnQgT3BlcmF0aW9uKQkgICAgICovCiAjZGVmaW5lIE1EX0NBX1dyCSAgICAgICAweDAwMDAwNDAwIC8qIDE6V3JpdGUgMDpSZWFkCQkgICAgICovCiAKQEAgLTI5Niw3ICsyOTYsNyBAQAogCiAjZGVmaW5lIEZEX0FMSUdOCTE2CiAKLS8qIEZyYW1lIERlc2NyaXB0ZXIgYml0IGFzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKy8qIEZyYW1lIERlc2NyaXB0ZXIgYml0IGFzc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAjZGVmaW5lIEZEX0ZETGVuZ3RoX01BU0sgICAgICAgMHgwMDAwRkZGRiAvKiBMZW5ndGggTUFTSwkJICAgICAqLwogI2RlZmluZSBGRF9CRENudF9NQVNLCSAgICAgICAweDAwMUYwMDAwIC8qIEJEIGNvdW50IE1BU0sgaW4gRkQJICAgICAqLwogI2RlZmluZSBGRF9Gcm1PcHRfTUFTSwkgICAgICAgMHg3QzAwMDAwMCAvKiBGcmFtZSBvcHRpb24gTUFTSwkJICAgICAqLwpAQCAtMzA5LDggKzMwOSw4IEBACiAjZGVmaW5lIEZEX05leHRfRU9MCSAgICAgICAweDAwMDAwMDAxIC8qIEZEIEVPTCBpbmRpY2F0b3IJCSAgICAgKi8KICNkZWZpbmUgRkRfQkRDbnRfU0hJRlQJICAgICAgIDE2CiAKLS8qIEJ1ZmZlciBEZXNjcmlwdGVyIGJpdCBhc2lnbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLSNkZWZpbmUgQkRfQnVmZkxlbmd0aF9NQVNLICAgICAweDAwMDBGRkZGIC8qIFJlY2lldmUgRGF0YSBTaXplCQkgICAgICovCisvKiBCdWZmZXIgRGVzY3JpcHRlciBiaXQgYXNzaWduIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworI2RlZmluZSBCRF9CdWZmTGVuZ3RoX01BU0sgICAgIDB4MDAwMEZGRkYgLyogUmVjZWl2ZSBEYXRhIFNpemUJCSAgICAgKi8KICNkZWZpbmUgQkRfUnhCRElEX01BU0sJICAgICAgIDB4MDBGRjAwMDAgLyogQkQgSUQgTnVtYmVyIE1BU0sJCSAgICAgKi8KICNkZWZpbmUgQkRfUnhCRFNlcU5fTUFTSyAgICAgICAweDdGMDAwMDAwIC8qIFJ4IEJEIFNlcXVlbmNlIE51bWJlcgkgICAgICovCiAjZGVmaW5lIEJEX0Nvd25zQkQJICAgICAgIDB4ODAwMDAwMDAgLyogQkQgQ29udHJvbGxlciBvd25lciBiaXQJICAgICAqLwpAQCAtMzM5LDcgKzMzOSw3IEBACiAjZGVmaW5lIFRYX1RIUkVTSE9MRAkxMDI0CiAvKiB1c2VkIHRocmVzaG9sZCB3aXRoIHBhY2tldCBtYXggYnl0ZSBmb3IgbG93IHBjaSB0cmFuc2ZlciBhYmlsaXR5LiovCiAjZGVmaW5lIFRYX1RIUkVTSE9MRF9NQVggMTUzNgotLyogc2V0dGluZyB0aHJlc2hvbGQgbWF4IHZhbHVlIHdoZW4gb3ZlcnJ1biBlcnJvciBvY2N1cmVkIHRoaXMgY291bnQuICovCisvKiBzZXR0aW5nIHRocmVzaG9sZCBtYXggdmFsdWUgd2hlbiBvdmVycnVuIGVycm9yIG9jY3VycmVkIHRoaXMgY291bnQuICovCiAjZGVmaW5lIFRYX1RIUkVTSE9MRF9LRUVQX0xJTUlUIDEwCiAKIC8qIDE2ICsgUlhfQlVGX05VTSAqIDggKyBSWF9GRF9OVU0gKiAxNiArIFRYX0ZEX05VTSAqIDMyIDw9IFBBR0VfU0laRSpGRF9QQUdFX05VTSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdGVodXRpLmMgYi9kcml2ZXJzL25ldC90ZWh1dGkuYwppbmRleCAzMzk3NjE4Li44NTY0ZWM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90ZWh1dGkuYworKysgYi9kcml2ZXJzL25ldC90ZWh1dGkuYwpAQCAtNjQ1LDcgKzY0NSw3IEBACiAJaWYgKGNtZCAhPSBTSU9DREVWUFJJVkFURSkgewogCQllcnJvciA9IGNvcHlfZnJvbV91c2VyKGRhdGEsIGlmci0+aWZyX2RhdGEsIHNpemVvZihkYXRhKSk7CiAJCWlmIChlcnJvcikgewotCQkJcHJfZXJyKCJjYW50IGNvcHkgZnJvbSB1c2VyXG4iKTsKKwkJCXByX2VycigiY2FuJ3QgY29weSBmcm9tIHVzZXJcbiIpOwogCQkJUkVUKC1FRkFVTFQpOwogCQl9CiAJCURCRygiJWQgMHgleCAweCV4XG4iLCBkYXRhWzBdLCBkYXRhWzFdLCBkYXRhWzJdKTsKQEAgLTk5OSw3ICs5OTksNyBAQAogICoKICAqIFJ4RCBmaWZvIGlzIHNtYWxsZXIgdGhhbiBSeEYgZmlmbyBieSBkZXNpZ24uIFVwb24gaGlnaCBsb2FkLCBSeEQgd2lsbCBiZQogICogZmlsbGVkIGFuZCBwYWNrZXRzIHdpbGwgYmUgZHJvcHBlZCBieSBuaWMgd2l0aG91dCBnZXR0aW5nIGludG8gaG9zdCBvcgotICogY291c2luZyBpbnRlcnJ1cHQuIEFueXdheSwgaW4gdGhhdCBjb25kaXRpb24sIGhvc3QgaGFzIG5vIGNoYW5jZSB0byBwcm9jY2VzcworICogY291c2luZyBpbnRlcnJ1cHQuIEFueXdheSwgaW4gdGhhdCBjb25kaXRpb24sIGhvc3QgaGFzIG5vIGNoYW5jZSB0byBwcm9jZXNzCiAgKiBhbGwgcGFja2V0cywgYnV0IGRyb3BwaW5nIGluIG5pYyBpcyBjaGVhcGVyLCBzaW5jZSBpdCB0YWtlcyAwIGNwdSBjeWNsZXMKICAqLwogCkBAIC0xMjAwLDggKzEyMDAsOCBAQAogCVJFVCgpOwogfQogCi0vKiBiZHhfcnhfcmVjZWl2ZSAtIHJlY2lldmVzIGZ1bGwgcGFja2V0cyBmcm9tIFJYRCBmaWZvIGFuZCBwYXNzIHRoZW0gdG8gT1MKLSAqIE5PVEU6IGEgc3BlY2lhbCB0cmVhdG1lbnQgaXMgZ2l2ZW4gdG8gbm9uLWNvbnRpbm91cyBkZXNjcmlwdG9ycworLyogYmR4X3J4X3JlY2VpdmUgLSByZWNlaXZlcyBmdWxsIHBhY2tldHMgZnJvbSBSWEQgZmlmbyBhbmQgcGFzcyB0aGVtIHRvIE9TCisgKiBOT1RFOiBhIHNwZWNpYWwgdHJlYXRtZW50IGlzIGdpdmVuIHRvIG5vbi1jb250aW51b3VzIGRlc2NyaXB0b3JzCiAgKiB0aGF0IHN0YXJ0IG5lYXIgdGhlIGVuZCwgd3JhcHMgYXJvdW5kIGFuZCBjb250aW51ZSBhdCB0aGUgYmVnaW5uaW5nLiBhIHNlY29uZAogICogcGFydCBpcyBjb3BpZWQgcmlnaHQgYWZ0ZXIgdGhlIGZpcnN0LCBhbmQgdGhlbiBkZXNjcmlwdG9yIGlzIGludGVycHJldGVkIGFzCiAgKiBub3JtYWwuIGZpZm8gaGFzIGFuIGV4dHJhIHNwYWNlIHRvIGFsbG93IHN1Y2ggb3BlcmF0aW9ucwpAQCAtMTU4NCw5ICsxNTg0LDkgQEAKIH0KIAogLyoKLSAqIGJkeF90eF9zcGFjZSAtIGNhbGN1bGF0ZXMgYXZhbGFibGUgc3BhY2UgaW4gVFggZmlmbworICogYmR4X3R4X3NwYWNlIC0gY2FsY3VsYXRlcyBhdmFpbGFibGUgc3BhY2UgaW4gVFggZmlmbwogICogQHByaXYgLSBOSUMgcHJpdmF0ZSBzdHJ1Y3R1cmUKLSAqIFJldHVybnMgYXZhbGlhYmxlIHNwYWNlIGluIFRYIGZpZm8gaW4gYnl0ZXMKKyAqIFJldHVybnMgYXZhaWxhYmxlIHNwYWNlIGluIFRYIGZpZm8gaW4gYnl0ZXMKICAqLwogc3RhdGljIGlubGluZSBpbnQgYmR4X3R4X3NwYWNlKHN0cnVjdCBiZHhfcHJpdiAqcHJpdikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3RlaHV0aS5oIGIvZHJpdmVycy9uZXQvdGVodXRpLmgKaW5kZXggYjZiYTg2MC4uYzU2NDJmZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdGVodXRpLmgKKysrIGIvZHJpdmVycy9uZXQvdGVodXRpLmgKQEAgLTUwMiw3ICs1MDIsNyBAQAogI2RlZmluZSAgR01BQ19SWF9GSUxURVJfQUNSQyAgMHgwMDEwCS8qIGFjY2VwdCBjcmMgZXJyb3IgKi8KICNkZWZpbmUgIEdNQUNfUlhfRklMVEVSX0FNICAgIDB4MDAwOAkvKiBhY2NlcHQgbXVsdGljYXN0ICovCiAjZGVmaW5lICBHTUFDX1JYX0ZJTFRFUl9BQiAgICAweDAwMDQJLyogYWNjZXB0IGJyb2FkY2FzdCAqLwotI2RlZmluZSAgR01BQ19SWF9GSUxURVJfUFJNICAgMHgwMDAxCS8qIFswOjFdIHByb21pc2NvdXMgbW9kZSAqLworI2RlZmluZSAgR01BQ19SWF9GSUxURVJfUFJNICAgMHgwMDAxCS8qIFswOjFdIHByb21pc2N1b3VzIG1vZGUgKi8KIAogI2RlZmluZSAgTUFYX0ZSQU1FX0FCX1ZBTCAgICAgICAweDNmZmYJLyogMTM6MCAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC90ZzMuYyBiL2RyaXZlcnMvbmV0L3RnMy5jCmluZGV4IDczYzk0MmQuLmI4YzVmMzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3RnMy5jCisrKyBiL2RyaXZlcnMvbmV0L3RnMy5jCkBAIC05NzEyLDcgKzk3MTIsNyBAQAogCQllZXByb20tPmxlbiArPSBiX2NvdW50OwogCX0KIAotCS8qIHJlYWQgYnl0ZXMgdXB0byB0aGUgbGFzdCA0IGJ5dGUgYm91bmRhcnkgKi8KKwkvKiByZWFkIGJ5dGVzIHVwIHRvIHRoZSBsYXN0IDQgYnl0ZSBib3VuZGFyeSAqLwogCXBkID0gJmRhdGFbZWVwcm9tLT5sZW5dOwogCWZvciAoaSA9IDA7IGkgPCAobGVuIC0gKGxlbiAmIDMpKTsgaSArPSA0KSB7CiAJCXJldCA9IHRnM19udnJhbV9yZWFkX2JlMzIodHAsIG9mZnNldCArIGksICZ2YWwpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdGczLmggYi9kcml2ZXJzL25ldC90ZzMuaAppbmRleCA3Mzg4NGI2Li41ZTk2NzA2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90ZzMuaAorKysgYi9kcml2ZXJzL25ldC90ZzMuaApAQCAtMjEzMCw3ICsyMTMwLDcgQEAKICNkZWZpbmUgTUlJX1RHM19EU1BfRVhQOTYJCTB4MGY5NgogI2RlZmluZSBNSUlfVEczX0RTUF9FWFA5NwkJMHgwZjk3CiAKLSNkZWZpbmUgTUlJX1RHM19BVVhfQ1RSTAkJMHgxOCAvKiBhdXhpbGxpYXJ5IGNvbnRyb2wgcmVnaXN0ZXIgKi8KKyNkZWZpbmUgTUlJX1RHM19BVVhfQ1RSTAkJMHgxOCAvKiBhdXhpbGlhcnkgY29udHJvbCByZWdpc3RlciAqLwogCiAjZGVmaW5lIE1JSV9URzNfQVVYQ1RMX1BDVExfMTAwVFhfTFBXUgkweDAwMTAKICNkZWZpbmUgTUlJX1RHM19BVVhDVExfUENUTF9TUFJfSVNPTEFURQkweDAwMjAKQEAgLTIxNDYsNyArMjE0Niw3IEBACiAjZGVmaW5lIE1JSV9URzNfQVVYQ1RMX0FDVExfVFhfNkRCCTB4MDQwMAogI2RlZmluZSBNSUlfVEczX0FVWENUTF9TSERXU0VMX0FVWENUTAkweDAwMDAKIAotI2RlZmluZSBNSUlfVEczX0FVWF9TVEFUCQkweDE5IC8qIGF1eGlsbGlhcnkgc3RhdHVzIHJlZ2lzdGVyICovCisjZGVmaW5lIE1JSV9URzNfQVVYX1NUQVQJCTB4MTkgLyogYXV4aWxpYXJ5IHN0YXR1cyByZWdpc3RlciAqLwogI2RlZmluZSBNSUlfVEczX0FVWF9TVEFUX0xQQVNTCQkweDAwMDQKICNkZWZpbmUgTUlJX1RHM19BVVhfU1RBVF9TUERNQVNLCTB4MDcwMAogI2RlZmluZSBNSUlfVEczX0FVWF9TVEFUXzEwSEFMRgkJMHgwMTAwCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC90b2tlbnJpbmcvM2MzNTkuYyBiL2RyaXZlcnMvbmV0L3Rva2VucmluZy8zYzM1OS5jCmluZGV4IDEwODAwZjEuLjhhM2IxOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3Rva2VucmluZy8zYzM1OS5jCisrKyBiL2RyaXZlcnMvbmV0L3Rva2VucmluZy8zYzM1OS5jCkBAIC0yMDgsNyArMjA4LDcgQEAKICAqCXBhc3NpbmcvZ2V0dGluZyB0aGUgbmV4dCB2YWx1ZSBmcm9tIHRoZSBuaWMuIEFzIHdpdGggYWxsIHJlcXVlc3RzCiAgKglvbiB0aGlzIG5pYyBpdCBoYXMgdG8gYmUgZG9uZSBpbiB0d28gc3RhZ2VzLCBhKSB0ZWxsIHRoZSBuaWMgd2hpY2gKICAqCW1lbW9yeSBhZGRyZXNzIHlvdSB3YW50IHRvIGFjY2VzcyBhbmQgYikgcGFzcy9nZXQgdGhlIHZhbHVlIGZyb20gdGhlIG5pYy4KLSAqCVdpdGggdGhlIEVFUHJvbSwgeW91IGhhdmUgdG8gd2FpdCBiZWZvcmUgYW5kIGluYmV0d2VlbiBhY2Nlc3MgYSkgYW5kIGIpLgorICoJV2l0aCB0aGUgRUVQcm9tLCB5b3UgaGF2ZSB0byB3YWl0IGJlZm9yZSBhbmQgYmV0d2VlbiBhY2Nlc3MgYSkgYW5kIGIpLgogICoJQXMgdGhpcyBpcyBvbmx5IHJlYWQgYXQgaW5pdGlhbGl6YXRpb24gdGltZSBhbmQgdGhlIHdhaXQgcGVyaW9kIGlzIHZlcnkgCiAgKglzbWFsbCB3ZSBzaG91bGRuJ3QgaGF2ZSB0byB3b3JyeSBhYm91dCBzY2hlZHVsaW5nIGlzc3Vlcy4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdG9rZW5yaW5nL21hZGdlbWMuYyBiL2RyaXZlcnMvbmV0L3Rva2VucmluZy9tYWRnZW1jLmMKaW5kZXggNzg1YWQxYS4uMmJlZGMwYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdG9rZW5yaW5nL21hZGdlbWMuYworKysgYi9kcml2ZXJzL25ldC90b2tlbnJpbmcvbWFkZ2VtYy5jCkBAIC03Myw3ICs3Myw3IEBACiBzdGF0aWMgaXJxcmV0dXJuX3QgbWFkZ2VtY19pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkKTsKIAogLyoKLSAqIFRoZXNlIHdvcmsgYXJvdW5kIHBhZ2luZywgaG93ZXZlciB0aGV5IGRvbid0IGd1YXJlbnRlZSB5b3UncmUgb24gdGhlCisgKiBUaGVzZSB3b3JrIGFyb3VuZCBwYWdpbmcsIGhvd2V2ZXIgdGhleSBkb24ndCBndWFyYW50ZWUgeW91J3JlIG9uIHRoZQogICogcmlnaHQgcGFnZS4KICAqLwogI2RlZmluZSBTSUZSRUFEQihyZWcpIChpbmIoZGV2LT5iYXNlX2FkZHIgKyAoKHJlZzwweDgpP3JlZzpyZWctMHg4KSkpCkBAIC0zODcsNyArMzg3LDcgQEAKICAqIGJvdGggd2l0aCB0aGVpciBvd24gZGlzYWR2YW50YWdlcy4uLgogICoKICAqIDEpICAJUmVhZCBpbiB0aGUgU0lGU1RTIHJlZ2lzdGVyIGZyb20gdGhlIFRNUyBjb250cm9sbGVyLiAgVGhpcwotICoJaXMgZ3VhcmVudGVlZCB0byBiZSBhY2N1cmF0ZSwgaG93ZXZlciwgdGhlcmUncyBhIGZhaXJseQorICoJaXMgZ3VhcmFudGVlZCB0byBiZSBhY2N1cmF0ZSwgaG93ZXZlciwgdGhlcmUncyBhIGZhaXJseQogICoJbGFyZ2UgcGVyZm9ybWFuY2UgcGVuYWx0eSBmb3IgZG9pbmcgc286IHRoZSBNYWRnZSBjaGlwcwogICoJbXVzdCByZXF1ZXN0IHRoZSByZWdpc3RlciBmcm9tIHRoZSBFYWdsZSwgdGhlIEVhZ2xlIG11c3QKICAqCXJlYWQgdGhlbSBmcm9tIGl0cyBpbnRlcm5hbCBidXMsIGFuZCB0aGVuIHRha2UgdGhlIHJvdXRlCkBAIC00NTQsNyArNDU0LDcgQEAKIH0KIAogLyoKLSAqIFNldCB0aGUgY2FyZCB0byB0aGUgcHJlZmVyZWQgcmluZyBzcGVlZC4KKyAqIFNldCB0aGUgY2FyZCB0byB0aGUgcHJlZmVycmVkIHJpbmcgc3BlZWQuCiAgKgogICogVW5saWtlIG5ld2VyIGNhcmRzLCB0aGUgTUMxNi8zMiBoYXZlIHRoZWlyIHNwZWVkIHNlbGVjdGlvbgogICogY2lyY3VpdCBjb25uZWN0ZWQgdG8gdGhlIE1hZGdlIEFTSUNzIGFuZCBub3QgdG8gdGhlIFRNUzM4MApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdG9rZW5yaW5nL3NtY3RyLmMgYi9kcml2ZXJzL25ldC90b2tlbnJpbmcvc21jdHIuYwppbmRleCA2M2RiNWE2Li5kOTA0NGFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90b2tlbnJpbmcvc21jdHIuYworKysgYi9kcml2ZXJzL25ldC90b2tlbnJpbmcvc21jdHIuYwpAQCAtMzkzLDcgKzM5Myw3IEBACiAgICAgICAgIHRwLT5yeF9iZGJfZW5kW05PTl9NQUNfUVVFVUVdID0gKEJEQmxvY2sgKilzbWN0cl9tYWxsb2MoZGV2LCAwKTsKIAogICAgICAgICAvKiBBbGxvY2F0ZSBNQUMgdHJhbnNtaXQgYnVmZmVycy4KLSAgICAgICAgICogTUFDIFR4IEJ1ZmZlcnMgZG9lbid0IGhhdmUgdG8gYmUgb24gYW4gT0REIEJvdW5kcnkuCisgICAgICAgICAqIE1BQyBUeCBCdWZmZXJzIGRvZW4ndCBoYXZlIHRvIGJlIG9uIGFuIE9ERCBCb3VuZGFyeS4KICAgICAgICAgICovCiAgICAgICAgIHRwLT50eF9idWZmX2hlYWRbTUFDX1FVRVVFXQogICAgICAgICAgICAgICAgID0gKF9fdTE2ICopc21jdHJfbWFsbG9jKGRldiwgdHAtPnR4X2J1ZmZfc2l6ZVtNQUNfUVVFVUVdKTsKQEAgLTQxNSw3ICs0MTUsNyBAQAogCiAgICAgICAgIC8qIEFsbG9jYXRlIE5vbi1NQUMgdHJhbnNtaXQgYnVmZmVycy4KICAgICAgICAgICogPz8gRm9yIG1heGltdW0gTmV0d2FyZSBwZXJmb3JtYW5jZSwgcHV0IFR4IEJ1ZmZlcnMgb24KLSAgICAgICAgICogT0REIEJvdW5kcnkgYW5kIHRoZW4gcmVzdG9yZSBtYWxsb2MgdG8gRXZlbiBCb3VuZHJ5cy4KKyAgICAgICAgICogT0REIEJvdW5kYXJ5IGFuZCB0aGVuIHJlc3RvcmUgbWFsbG9jIHRvIEV2ZW4gQm91bmRyeXMuCiAgICAgICAgICAqLwogICAgICAgICBzbWN0cl9tYWxsb2MoZGV2LCAxTCk7CiAgICAgICAgIHRwLT50eF9idWZmX2hlYWRbTk9OX01BQ19RVUVVRV0KQEAgLTEzMTEsNyArMTMxMSw3IEBACiAgICAgICAgIG1lbV91c2VkICs9IHNpemVvZihCREJsb2NrKSAqIHRwLT5udW1fcnhfYmRic1tNQUNfUVVFVUVdOwogCiAgICAgICAgIC8qIEFsbG9jYXRlIE1BQyB0cmFuc21pdCBidWZmZXJzLgotICAgICAgICAgKiBNQUMgdHJhbnNtaXQgYnVmZmVycyBkb24ndCBoYXZlIHRvIGJlIG9uIGFuIE9ERCBCb3VuZHJ5LgorICAgICAgICAgKiBNQUMgdHJhbnNtaXQgYnVmZmVycyBkb24ndCBoYXZlIHRvIGJlIG9uIGFuIE9ERCBCb3VuZGFyeS4KICAgICAgICAgICovCiAgICAgICAgIG1lbV91c2VkICs9IHRwLT50eF9idWZmX3NpemVbTUFDX1FVRVVFXTsKIApAQCAtMTMyNSw3ICsxMzI1LDcgQEAKIAogICAgICAgICAvKiBBbGxvY2F0ZSBOb24tTUFDIHRyYW5zbWl0IGJ1ZmZlcnMuCiAgICAgICAgICAqIEZvciBtYXhpbXVtIE5ldHdhcmUgcGVyZm9ybWFuY2UsIHB1dCBUeCBCdWZmZXJzIG9uCi0gICAgICAgICAqIE9ERCBCb3VuZHJ5LGFuZCB0aGVuIHJlc3RvcmUgbWFsbG9jIHRvIEV2ZW4gQm91bmRyeXMuCisgICAgICAgICAqIE9ERCBCb3VuZGFyeSxhbmQgdGhlbiByZXN0b3JlIG1hbGxvYyB0byBFdmVuIEJvdW5kcnlzLgogICAgICAgICAgKi8KICAgICAgICAgbWVtX3VzZWQgKz0gMUw7CiAgICAgICAgIG1lbV91c2VkICs9IHRwLT50eF9idWZmX3NpemVbTk9OX01BQ19RVUVVRV07CkBAIC0zMDY5LDggKzMwNjksOCBAQAogICogZGlzYWJsZWQuIT8KICAqCiAgKiBOT1RFIDI6IElmIHRoZSBtb25pdG9yX3N0YXRlIGlzIE1TX0JFQUNPTl9URVNUX1NUQVRFIGFuZCB0aGUgcmVjZWl2ZV9tYXNrCi0gKiBoYXMgYW55IG11bHRpLWNhc3Qgb3IgcHJvbWlzY291cyBiaXRzIHNldCwgdGhlIHJlY2VpdmVfbWFzayBuZWVkcyB0bwotICogYmUgY2hhbmdlZCB0byBjbGVhciB0aGUgbXVsdGktY2FzdCBvciBwcm9taXNjb3VzIG1vZGUgYml0cywgdGhlIGxvYmVfdGVzdAorICogaGFzIGFueSBtdWx0aS1jYXN0IG9yIHByb21pc2N1b3VzIGJpdHMgc2V0LCB0aGUgcmVjZWl2ZV9tYXNrIG5lZWRzIHRvCisgKiBiZSBjaGFuZ2VkIHRvIGNsZWFyIHRoZSBtdWx0aS1jYXN0IG9yIHByb21pc2N1b3VzIG1vZGUgYml0cywgdGhlIGxvYmVfdGVzdAogICogcnVuLCBhbmQgdGhlbiB0aGUgcmVjZWl2ZSBtYXNrIHNldCBiYWNrIHRvIGl0cyBvcmlnaW5hbCB2YWx1ZSBpZiB0aGUgdGVzdAogICogaXMgc3VjY2Vzc2Z1bC4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdG9rZW5yaW5nL3RtczM4MHRyLmggYi9kcml2ZXJzL25ldC90b2tlbnJpbmcvdG1zMzgwdHIuaAppbmRleCA2MGIzMGVlLi5lNWE2MTdjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90b2tlbnJpbmcvdG1zMzgwdHIuaAorKysgYi9kcml2ZXJzL25ldC90b2tlbnJpbmcvdG1zMzgwdHIuaApAQCAtNDQyLDcgKzQ0Miw3IEBACiAjZGVmaW5lIFBBU1NfRklSU1RfQlVGX09OTFkJMHgwMTAwCS8qIFBhc3NlcyBvbmx5IGZpcnN0IGludGVybmFsIGJ1ZmZlcgogCQkJCQkgKiBvZiBlYWNoIHJlY2VpdmVkIGZyYW1lOyBGcmFtZVNpemUKIAkJCQkJICogb2YgUlBMcyBtdXN0IGNvbnRhaW4gaW50ZXJuYWwKLQkJCQkJICogQlVGRkVSX1NJWkUgYml0cyBmb3IgcHJvbWlzY291cyBtb2RlLgorCQkJCQkgKiBCVUZGRVJfU0laRSBiaXRzIGZvciBwcm9taXNjdW91cyBtb2RlLgogCQkJCQkgKi8KICNkZWZpbmUgRU5BQkxFX0ZVTExfRFVQTEVYX1NFTEVDVElPTgkweDIwMDAgCiAgCQkJCQkvKiBFbmFibGUgdGhlIHVzZSBvZiBmdWxsLWR1cGxleApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdHNpMTA4X2V0aC5oIGIvZHJpdmVycy9uZXQvdHNpMTA4X2V0aC5oCmluZGV4IDVhNzdhZTYuLjVmZWU3ZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3RzaTEwOF9ldGguaAorKysgYi9kcml2ZXJzL25ldC90c2kxMDhfZXRoLmgKQEAgLTMwNSw5ICszMDUsOSBAQAogI2RlZmluZSBUU0kxMDhfVFhfQ1JDCSgxIDw8IDUpCS8qIEdlbmVyYXRlIENSQyBmb3IgdGhpcyBwYWNrZXQgKi8KICNkZWZpbmUgVFNJMTA4X1RYX0lOVAkoMSA8PCAxNCkJLyogR2VuZXJhdGUgYW4gSVJRIGFmdGVyIGZyYWcuIHByb2Nlc3NlZCAqLwogI2RlZmluZSBUU0kxMDhfVFhfUkVUUlkJKDB4ZiA8PCAxNikJLyogNCBiaXQgZmllbGQgaW5kaWNhdGluZyBudW0uIG9mIHJldHJpZXMgKi8KLSNkZWZpbmUgVFNJMTA4X1RYX0NPTAkoMSA8PCAyMCkJLyogU2V0IGlmIGEgY29sbGlzaW9uIG9jY3VyZWQgKi8KLSNkZWZpbmUgVFNJMTA4X1RYX0xDT0wJKDEgPDwgMjQpCS8qIFNldCBpZiBhIGxhdGUgY29sbGlzaW9uIG9jY3VyZWQgKi8KLSNkZWZpbmUgVFNJMTA4X1RYX1VOREVSCSgxIDw8IDI1KQkvKiBTZXQgaWYgYSBGSUZPIHVuZGVycnVuIG9jY3VyZWQgKi8KKyNkZWZpbmUgVFNJMTA4X1RYX0NPTAkoMSA8PCAyMCkJLyogU2V0IGlmIGEgY29sbGlzaW9uIG9jY3VycmVkICovCisjZGVmaW5lIFRTSTEwOF9UWF9MQ09MCSgxIDw8IDI0KQkvKiBTZXQgaWYgYSBsYXRlIGNvbGxpc2lvbiBvY2N1cnJlZCAqLworI2RlZmluZSBUU0kxMDhfVFhfVU5ERVIJKDEgPDwgMjUpCS8qIFNldCBpZiBhIEZJRk8gdW5kZXJydW4gb2NjdXJyZWQgKi8KICNkZWZpbmUgVFNJMTA4X1RYX1JMSU0JKDEgPDwgMjYpCS8qIFNldCBpZiB0aGUgcmV0cnkgbGltaXQgd2FzIHJlYWNoZWQgKi8KICNkZWZpbmUgVFNJMTA4X1RYX09LCSgxIDw8IDMwKQkvKiBTZXQgaWYgdGhlIGZyYW1lIFRYIHdhcyBzdWNjZXNzZnVsICovCiAjZGVmaW5lIFRTSTEwOF9UWF9PV04JKDEgPDwgMzEpCS8qIFNldCBpZiB0aGUgZGV2aWNlIG93bnMgdGhlIGRlc2NyaXB0b3IgKi8KQEAgLTMzMiw3ICszMzIsNyBAQAogI2RlZmluZSBUU0kxMDhfUlhfUlVOVAkoMSA8PCA0KS8qIFBhY2tldCBpcyBsZXNzIHRoYW4gbWluaW11bSBzaXplICovCiAjZGVmaW5lIFRTSTEwOF9SWF9IQVNICSgxIDw8IDcpLyogSGFzaCB0YWJsZSBtYXRjaCAqLwogI2RlZmluZSBUU0kxMDhfUlhfQkFECSgxIDw8IDgpCS8qIEJhZCBmcmFtZSAqLwotI2RlZmluZSBUU0kxMDhfUlhfT1ZFUgkoMSA8PCA5KQkvKiBGSUZPIG92ZXJydW4gb2NjdXJlZCAqLworI2RlZmluZSBUU0kxMDhfUlhfT1ZFUgkoMSA8PCA5KQkvKiBGSUZPIG92ZXJydW4gb2NjdXJyZWQgKi8KICNkZWZpbmUgVFNJMTA4X1JYX1RSVU5DCSgxIDw8IDExKQkvKiBQYWNrZXQgdHJ1bmNhdGVkIGR1ZSB0byBleGNlc3MgbGVuZ3RoICovCiAjZGVmaW5lIFRTSTEwOF9SWF9DUkMJKDEgPDwgMTIpCS8qIFBhY2tldCBoYWQgYSBDUkMgZXJyb3IgKi8KICNkZWZpbmUgVFNJMTA4X1JYX0lOVAkoMSA8PCAxMykJLyogR2VuZXJhdGUgYW4gSVJRIGFmdGVyIGZyYWcuIHByb2Nlc3NlZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdHVsaXAvZGU0eDUuYyBiL2RyaXZlcnMvbmV0L3R1bGlwL2RlNHg1LmMKaW5kZXggNGRiZDQ5My4uZWZhYTFkNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdHVsaXAvZGU0eDUuYworKysgYi9kcml2ZXJzL25ldC90dWxpcC9kZTR4NS5jCkBAIC03OSw3ICs3OSw3IEBACiAgICAgZXZlcnkgIHVzYWJsZSBERUNjaGlwIGJvYXJkLCAgSSAgcGluY2hlZCBEb25hbGQncyAnbmV4dF9tb2R1bGUnIGZpZWxkIHRvCiAgICAgbGluayBteSBtb2R1bGVzIHRvZ2V0aGVyLgogCi0gICAgVXB0byAxNSBFSVNBIGNhcmRzIGNhbiBiZSBzdXBwb3J0ZWQgdW5kZXIgdGhpcyBkcml2ZXIsIGxpbWl0ZWQgcHJpbWFyaWx5CisgICAgVXAgdG8gMTUgRUlTQSBjYXJkcyBjYW4gYmUgc3VwcG9ydGVkIHVuZGVyIHRoaXMgZHJpdmVyLCBsaW1pdGVkIHByaW1hcmlseQogICAgIGJ5IHRoZSBhdmFpbGFibGUgSVJRIGxpbmVzLiAgSSBoYXZlICBjaGVja2VkIGRpZmZlcmVudCBjb25maWd1cmF0aW9ucyBvZgogICAgIG11bHRpcGxlIGRlcGNhLCBFdGhlcldPUktTIDMgY2FyZHMgYW5kIGRlNHg1IGNhcmRzIGFuZCAgaGF2ZSBub3QgZm91bmQgYQogICAgIHByb2JsZW0geWV0IChwcm92aWRlZCB5b3UgaGF2ZSBhdCBsZWFzdCBkZXBjYS5jIHYwLjM4KSAuLi4KQEAgLTUxNyw3ICs1MTcsNyBAQAogICAgIHVfaW50IG1jaTsgICAgICAgICAgICAgIC8qIDIxMTQyIE1JSSBDb25uZWN0b3IgSW50ZXJydXB0IGluZm8gICAgICAgICovCiB9OwogCi0jZGVmaW5lIERFNFg1X01BWF9QSFkgOCAgICAgLyogQWxsb3cgdXB0byA4IGF0dGFjaGVkIFBIWSBkZXZpY2VzIHBlciBib2FyZCAqLworI2RlZmluZSBERTRYNV9NQVhfUEhZIDggICAgIC8qIEFsbG93IHVwIHRvIDggYXR0YWNoZWQgUEhZIGRldmljZXMgcGVyIGJvYXJkICovCiAKIHN0cnVjdCBzaWFfcGh5IHsKICAgICB1X2NoYXIgbWM7ICAgICAgICAgICAgICAvKiBNZWRpYSBDb2RlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwpAQCAtMTQzNiw3ICsxNDM2LDcgQEAKIAogICAgIC8qIFBvbGwgZm9yIHNldHVwIGZyYW1lIGNvbXBsZXRpb24gKGFkYXB0ZXIgaW50ZXJydXB0cyBhcmUgZGlzYWJsZWQgbm93KSAqLwogCi0gICAgZm9yIChqPTAsIGk9MDsoaTw1MDApICYmIChqPT0wKTtpKyspIHsgICAgICAgLyogVXB0byA1MDBtcyBkZWxheSAqLworICAgIGZvciAoaj0wLCBpPTA7KGk8NTAwKSAmJiAoaj09MCk7aSsrKSB7ICAgICAgIC8qIFVwIHRvIDUwMG1zIGRlbGF5ICovCiAJbWRlbGF5KDEpOwogCWlmICgoczMyKWxlMzJfdG9fY3B1KGxwLT50eF9yaW5nW2xwLT50eF9uZXddLnN0YXR1cykgPj0gMCkgaj0xOwogICAgIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3R1bGlwL2RtZmUuYyBiL2RyaXZlcnMvbmV0L3R1bGlwL2RtZmUuYwppbmRleCA3MDY0ZTAzLi5mYjA3ZjQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90dWxpcC9kbWZlLmMKKysrIGIvZHJpdmVycy9uZXQvdHVsaXAvZG1mZS5jCkBAIC0xMjI0LDcgKzEyMjQsNyBAQAogCiAKIAkvKiBJZiBjaGlwIHJlcG9ydHMgdGhhdCBsaW5rIGlzIGZhaWxlZCBpdCBjb3VsZCBiZSBiZWNhdXNlIGV4dGVybmFsCi0JCVBIWSBsaW5rIHN0YXR1cyBwaW4gaXMgbm90IGNvbmVjdGVkIGNvcnJlY3RseSB0byBjaGlwCisJCVBIWSBsaW5rIHN0YXR1cyBwaW4gaXMgbm90IGNvbm5lY3RlZCBjb3JyZWN0bHkgdG8gY2hpcAogCQlUbyBiZSBzdXJlIGFzayBQSFkgdG9vLgogCSovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3R1bGlwL2VlcHJvbS5jIGIvZHJpdmVycy9uZXQvdHVsaXAvZWVwcm9tLmMKaW5kZXggMzAzMWVkOS4uMjk2NDg2YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdHVsaXAvZWVwcm9tLmMKKysrIGIvZHJpdmVycy9uZXQvdHVsaXAvZWVwcm9tLmMKQEAgLTExNSw3ICsxMTUsNyBAQAogCQkJICAweDAyLCAgICAgICAvKiBwaHkgcmVzZXQgc2VxdWVuY2UgbGVuZ3RoICovCiAJCQkgIDB4MDEsIDB4MDAsIC8qIHBoeSByZXNldCBzZXF1ZW5jZSAqLwogCQkJICAweDAwLCAweDc4LCAvKiBtZWRpYSBjYXBhYmlsaXRpZXMgKi8KLQkJCSAgMHgwMCwgMHhlMCwgLyogbndheSBhZHZlcnRpc21lbnQgKi8KKwkJCSAgMHgwMCwgMHhlMCwgLyogbndheSBhZHZlcnRpc2VtZW50ICovCiAJCQkgIDB4MDAsIDB4MDUsIC8qIGZkeCBiaXQgbWFwICovCiAJCQkgIDB4MDAsIDB4MDYgIC8qIHR0bSBiaXQgbWFwICovCiAJCQl9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdHlwaG9vbi5jIGIvZHJpdmVycy9uZXQvdHlwaG9vbi5jCmluZGV4IDdmYTVlYzIuLjgyNjUzY2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3R5cGhvb24uYworKysgYi9kcml2ZXJzL25ldC90eXBob29uLmMKQEAgLTg0Niw3ICs4NDYsNyBAQAogCWlmKHR5cGhvb25fbnVtX2ZyZWVfdHgodHhSaW5nKSA8IChudW1EZXNjICsgMikpIHsKIAkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwogCi0JCS8qIEEgVHggY29tcGxldGUgSVJRIGNvdWxkIGhhdmUgZ290dGVuIGluYmV0d2VlbiwgbWFraW5nCisJCS8qIEEgVHggY29tcGxldGUgSVJRIGNvdWxkIGhhdmUgZ290dGVuIGJldHdlZW4sIG1ha2luZwogCQkgKiB0aGUgcmluZyBmcmVlIGFnYWluLiBPbmx5IG5lZWQgdG8gcmVjaGVjayBoZXJlLCBzaW5jZQogCQkgKiBUeCBpcyBzZXJpYWxpemVkLgogCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3VjY19nZXRoLmggYi9kcml2ZXJzL25ldC91Y2NfZ2V0aC5oCmluZGV4IDA1NWI4N2EuLmQxMmZjYWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VjY19nZXRoLmgKKysrIGIvZHJpdmVycy9uZXQvdWNjX2dldGguaApAQCAtODAsNyArODAsNyBAQAogCQkJCSAgIGZyYW1lcykgcmVjZWl2ZWQgdGhhdCB3ZXJlIGJldHdlZW4gMTI4CiAJCQkJICAgKEluY2x1ZGluZyBGQ1MgbGVuZ3RoPT00KSBhbmQgMjU1IG9jdGV0cyAqLwogCXUzMiB0eG9rOwkJLyogVG90YWwgbnVtYmVyIG9mIG9jdGV0cyByZXNpZGluZyBpbiBmcmFtZXMKLQkJCQkgICB0aGF0IHdoZXJlIGludm9sdmVkIGluIHN1Y2Nlc3NmdWxsCisJCQkJICAgdGhhdCB3aGVyZSBpbnZvbHZlZCBpbiBzdWNjZXNzZnVsCiAJCQkJICAgdHJhbnNtaXNzaW9uICovCiAJdTE2IHR4Y2Y7CQkvKiBUb3RhbCBudW1iZXIgb2YgUEFVU0UgY29udHJvbCBmcmFtZXMKIAkJCQkgICB0cmFuc21pdHRlZCBieSB0aGlzIE1BQyAqLwpAQCAtNzU5LDcgKzc1OSw3IEBACiAJCQkJICAgZnJhbWVzKSByZWNlaXZlZCB0aGF0IHdlcmUgYmV0d2VlbiAxMjgKIAkJCQkgICAoSW5jbHVkaW5nIEZDUyBsZW5ndGg9PTQpIGFuZCAyNTUgb2N0ZXRzICovCiAJdTMyIHR4b2s7CQkvKiBUb3RhbCBudW1iZXIgb2Ygb2N0ZXRzIHJlc2lkaW5nIGluIGZyYW1lcwotCQkJCSAgIHRoYXQgd2hlcmUgaW52b2x2ZWQgaW4gc3VjY2Vzc2Z1bGwKKwkJCQkgICB0aGF0IHdoZXJlIGludm9sdmVkIGluIHN1Y2Nlc3NmdWwKIAkJCQkgICB0cmFuc21pc3Npb24gKi8KIAl1MTYgdHhjZjsJCS8qIFRvdGFsIG51bWJlciBvZiBQQVVTRSBjb250cm9sIGZyYW1lcwogCQkJCSAgIHRyYW5zbWl0dGVkIGJ5IHRoaXMgTUFDICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2IvY2RjX2VlbS5jIGIvZHJpdmVycy9uZXQvdXNiL2NkY19lZW0uYwppbmRleCA4ZjEyODU0Li44ODJmNTNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC91c2IvY2RjX2VlbS5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9jZGNfZWVtLmMKQEAgLTE5MCw3ICsxOTAsNyBAQAogCiAJCS8qCiAJCSAqIEVFTSBwYWNrZXQgaGVhZGVyIGZvcm1hdDoKLQkJICogYjAuLjE0OglFRU0gdHlwZSBkZXBlbmRhbnQgKERhdGEgb3IgQ29tbWFuZCkKKwkJICogYjAuLjE0OglFRU0gdHlwZSBkZXBlbmRlbnQgKERhdGEgb3IgQ29tbWFuZCkKIAkJICogYjE1OgkJYm1UeXBlCiAJCSAqLwogCQloZWFkZXIgPSBnZXRfdW5hbGlnbmVkX2xlMTYoc2tiLT5kYXRhKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3VzYi9rYXdldGguYyBiL2RyaXZlcnMvbmV0L3VzYi9rYXdldGguYwppbmRleCA3ZGM4NDk3Li5hZDAyOThmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC91c2Iva2F3ZXRoLmMKKysrIGIvZHJpdmVycy9uZXQvdXNiL2thd2V0aC5jCkBAIC0xMjIxLDcgKzEyMjEsNyBAQAogCiAJdXNiX3NldF9pbnRmZGF0YShpbnRmLCBOVUxMKTsKIAlpZiAoIWthd2V0aCkgewotCQlkZXZfd2FybigmaW50Zi0+ZGV2LCAidW5yZWdpc3RlcmluZyBub24tZXhpc3RhbnQgZGV2aWNlXG4iKTsKKwkJZGV2X3dhcm4oJmludGYtPmRldiwgInVucmVnaXN0ZXJpbmcgbm9uLWV4aXN0ZW50IGRldmljZVxuIik7CiAJCXJldHVybjsKIAl9CiAJbmV0ZGV2ID0ga2F3ZXRoLT5uZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2Ivc21zYzk1eHguYyBiL2RyaXZlcnMvbmV0L3VzYi9zbXNjOTV4eC5jCmluZGV4IDcyNzg3NGQuLjQ3YTZjODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VzYi9zbXNjOTV4eC5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9zbXNjOTV4eC5jCkBAIC0xMzEzLDYgKzEzMTMsMjEgQEAKIAkJVVNCX0RFVklDRSgweDA0MjQsIDB4OTkwOSksCiAJCS5kcml2ZXJfaW5mbyA9ICh1bnNpZ25lZCBsb25nKSAmc21zYzk1eHhfaW5mbywKIAl9LAorCXsKKwkJLyogU01TQyBMQU45NTMwIFVTQiBFdGhlcm5ldCBEZXZpY2UgKi8KKwkJVVNCX0RFVklDRSgweDA0MjQsIDB4OTUzMCksCisJCS5kcml2ZXJfaW5mbyA9ICh1bnNpZ25lZCBsb25nKSAmc21zYzk1eHhfaW5mbywKKwl9LAorCXsKKwkJLyogU01TQyBMQU45NzMwIFVTQiBFdGhlcm5ldCBEZXZpY2UgKi8KKwkJVVNCX0RFVklDRSgweDA0MjQsIDB4OTczMCksCisJCS5kcml2ZXJfaW5mbyA9ICh1bnNpZ25lZCBsb25nKSAmc21zYzk1eHhfaW5mbywKKwl9LAorCXsKKwkJLyogU01TQyBMQU44OTUzMCBVU0IgRXRoZXJuZXQgRGV2aWNlICovCisJCVVTQl9ERVZJQ0UoMHgwNDI0LCAweDlFMDgpLAorCQkuZHJpdmVyX2luZm8gPSAodW5zaWduZWQgbG9uZykgJnNtc2M5NXh4X2luZm8sCisJfSwKIAl7IH0sCQkvKiBFTkQgKi8KIH07CiBNT0RVTEVfREVWSUNFX1RBQkxFKHVzYiwgcHJvZHVjdHMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdmlhLXJoaW5lLmMgYi9kcml2ZXJzL25ldC92aWEtcmhpbmUuYwppbmRleCA1ZTdmMDY5Li5lYjVkNzVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC92aWEtcmhpbmUuYworKysgYi9kcml2ZXJzL25ldC92aWEtcmhpbmUuYwpAQCAtMTg2MSw3ICsxODYxLDcgQEAKIAl1MzIgaW50cl9zdGF0dXM7CiAKIAkvKgotCSAqIElmIG5ldyBlcnJvcnMgb2NjdXJlZCwgd2UgbmVlZCB0byBzb3J0IHRoZW0gb3V0IGJlZm9yZSBkb2luZyBUeC4KKwkgKiBJZiBuZXcgZXJyb3JzIG9jY3VycmVkLCB3ZSBuZWVkIHRvIHNvcnQgdGhlbSBvdXQgYmVmb3JlIGRvaW5nIFR4LgogCSAqIEluIHRoYXQgY2FzZSB0aGUgSVNSIHdpbGwgYmUgYmFjayBoZXJlIFJTTiBhbnl3YXkuCiAJICovCiAJaW50cl9zdGF0dXMgPSBnZXRfaW50cl9zdGF0dXMoZGV2KTsKQEAgLTE4ODcsNyArMTg4Nyw3IEBACiAJCS8qIFRoaXMgc2hvdWxkIG5ldmVyIGhhcHBlbiAqLwogCQlpZiAoZGVidWcgPiAxKQogCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiJXM6IHJoaW5lX3Jlc3RhcnRfdHgoKSAiCi0JCQkgICAgICAgIkFub3RoZXIgZXJyb3Igb2NjdXJlZCAlOC44eC5cbiIsCisJCQkgICAgICAgIkFub3RoZXIgZXJyb3Igb2NjdXJyZWQgJTguOHguXG4iLAogCQkJICAgICAgIGRldi0+bmFtZSwgaW50cl9zdGF0dXMpOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdmlhLXZlbG9jaXR5LmMgYi9kcml2ZXJzL25ldC92aWEtdmVsb2NpdHkuYwppbmRleCAwZDZmZWM2Li40ZmUwNTE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC92aWEtdmVsb2NpdHkuYworKysgYi9kcml2ZXJzL25ldC92aWEtdmVsb2NpdHkuYwpAQCAtMjkyLDcgKzI5Miw3IEBACiAvKiBJUF9ieXRlX2FsaWduW10gaXMgdXNlZCBmb3IgSVAgaGVhZGVyIERXT1JEIGJ5dGUgYWxpZ25lZAogICAgMDogaW5kaWNhdGUgdGhlIElQIGhlYWRlciB3b24ndCBiZSBEV09SRCBieXRlIGFsaWduZWQuKERlZmF1bHQpIC4KICAgIDE6IGluZGljYXRlIHRoZSBJUCBoZWFkZXIgd2lsbCBiZSBEV09SRCBieXRlIGFsaWduZWQuCi0gICAgICBJbiBzb21lIGVudmlyb21lbnQsIHRoZSBJUCBoZWFkZXIgc2hvdWxkIGJlIERXT1JEIGJ5dGUgYWxpZ25lZCwKKyAgICAgIEluIHNvbWUgZW52aXJvbm1lbnQsIHRoZSBJUCBoZWFkZXIgc2hvdWxkIGJlIERXT1JEIGJ5dGUgYWxpZ25lZCwKICAgICAgIG9yIHRoZSBwYWNrZXQgd2lsbCBiZSBkcm9wZWQgd2hlbiB3ZSByZWNlaXZlIGl0LiAoZWc6IElQVlMpCiAqLwogVkVMT0NJVFlfUEFSQU0oSVBfYnl0ZV9hbGlnbiwgIkVuYWJsZSBJUCBoZWFkZXIgZHdvcmQgYWxpZ25lZCIpOwpAQCAtMTk5NCw3ICsxOTk0LDcgQEAKICAqCUBkZXY6IG5ldHdvcmsgZGV2aWNlCiAgKgogICoJUmVwbGFjZSB0aGUgY3VycmVudCBza2IgdGhhdCBpcyBzY2hlZHVsZWQgZm9yIFJ4IHByb2Nlc3NpbmcgYnkgYQotICoJc2hvcnRlciwgaW1tZWRpYXRseSBhbGxvY2F0ZWQgc2tiLCBpZiB0aGUgcmVjZWl2ZWQgcGFja2V0IGlzIHNtYWxsCisgKglzaG9ydGVyLCBpbW1lZGlhdGVseSBhbGxvY2F0ZWQgc2tiLCBpZiB0aGUgcmVjZWl2ZWQgcGFja2V0IGlzIHNtYWxsCiAgKgllbm91Z2guIFRoaXMgZnVuY3Rpb24gcmV0dXJucyBhIG5lZ2F0aXZlIHZhbHVlIGlmIHRoZSByZWNlaXZlZAogICoJcGFja2V0IGlzIHRvbyBiaWcgb3IgaWYgbWVtb3J5IGlzIGV4aGF1c3RlZC4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2Rydi5jIGIvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2Rydi5jCmluZGV4IGNjMTRiNGEuLjBkNDdjM2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3ZteG5ldDMvdm14bmV0M19kcnYuYworKysgYi9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZHJ2LmMKQEAgLTg5Miw3ICs4OTIsNyBAQAogICogVHJhbnNtaXRzIGEgcGt0IHRocnUgYSBnaXZlbiB0cQogICogUmV0dXJuczoKICAqICAgIE5FVERFVl9UWF9PSzogICAgICBkZXNjcmlwdG9ycyBhcmUgc2V0dXAgc3VjY2Vzc2Z1bGx5Ci0gKiAgICBORVRERVZfVFhfT0s6ICAgICAgZXJyb3Igb2NjdXJlZCwgdGhlIHBrdCBpcyBkcm9wcGVkCisgKiAgICBORVRERVZfVFhfT0s6ICAgICAgZXJyb3Igb2NjdXJyZWQsIHRoZSBwa3QgaXMgZHJvcHBlZAogICogICAgTkVUREVWX1RYX0JVU1k6ICAgIHR4IHJpbmcgaXMgZnVsbCwgcXVldWUgaXMgc3RvcHBlZAogICoKICAqIFNpZGUtZWZmZWN0czoKQEAgLTI2ODUsNyArMjY4NSw3IEBACiAgKiBFbmFibGUgTVNJeCB2ZWN0b3JzLgogICogUmV0dXJucyA6CiAgKgkwIG9uIHN1Y2Nlc3NmdWwgZW5hYmxpbmcgb2YgcmVxdWlyZWQgdmVjdG9ycywKLSAqCVZNWE5FVDNfTElOVVhfTUlOX01TSVhfVkVDVCB3aGVuIG9ubHkgbWludW11bSBudW1iZXIgb2YgdmVjdG9ycyByZXF1aXJlZAorICoJVk1YTkVUM19MSU5VWF9NSU5fTVNJWF9WRUNUIHdoZW4gb25seSBtaW5pbXVtIG51bWJlciBvZiB2ZWN0b3JzIHJlcXVpcmVkCiAgKgkgY291bGQgYmUgZW5hYmxlZC4KICAqCW51bWJlciBvZiB2ZWN0b3JzIHdoaWNoIGNhbiBiZSBlbmFibGVkIG90aGVyd2lzZSAodGhpcyBudW1iZXIgaXMgc21hbGxlcgogICoJIHRoYW4gVk1YTkVUM19MSU5VWF9NSU5fTVNJWF9WRUNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdnhnZS92eGdlLWNvbmZpZy5jIGIvZHJpdmVycy9uZXQvdnhnZS92eGdlLWNvbmZpZy5jCmluZGV4IGU3NGU0YjQuLjQwMWJlYmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS1jb25maWcuYworKysgYi9kcml2ZXJzL25ldC92eGdlL3Z4Z2UtY29uZmlnLmMKQEAgLTE4Nyw3ICsxODcsNyBAQAogCQkJCQkgICBWWEdFX0hXX0RFRl9ERVZJQ0VfUE9MTF9NSUxMSVMpOwogCiAJLyogVGhlIF9fdnhnZV9od19kZXZpY2VfcmVnaXN0ZXJfcG9sbCBjYW4gdWRlbGF5IGZvciBhIHNpZ25pZmljYW50Ci0JICogYW1vdW50IG9mIHRpbWUsIGJsb2NraW5nIG90aGVyIHByb2NjZXNzIGZyb20gdGhlIENQVS4gIElmIGl0IGRlbGF5cworCSAqIGFtb3VudCBvZiB0aW1lLCBibG9ja2luZyBvdGhlciBwcm9jZXNzIGZyb20gdGhlIENQVS4gIElmIGl0IGRlbGF5cwogCSAqIGZvciB+NXNlY3MsIGEgTk1JIGVycm9yIGNhbiBvY2N1ci4gIEEgd2F5IGFyb3VuZCB0aGlzIGlzIHRvIGdpdmUgdXAKIAkgKiB0aGUgcHJvY2Vzc29yIHZpYSBtc2xlZXAsIGJ1dCB0aGlzIGlzIG5vdCBhbGxvd2VkIGlzIHVuZGVyIGxvY2suCiAJICogU28sIG9ubHkgYWxsb3cgaXQgdG8gc2xlZXAgZm9yIH40c2VjcyBpZiBvcGVuLiAgT3RoZXJ3aXNlLCBkZWxheSBmb3IKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS1tYWluLmMgYi9kcml2ZXJzL25ldC92eGdlL3Z4Z2UtbWFpbi5jCmluZGV4IDM5NTQyM2EuLmFmZjY4YzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS1tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvdnhnZS92eGdlLW1haW4uYwpAQCAtMjI4Miw3ICsyMjgyLDcgQEAKIAkJVlhHRV9IV19WUEFUSF9NU0lYX0FDVElWRSkgKyBWWEdFX0FMQVJNX01TSVhfSUQ7CiAKIAlmb3IgKGkgPSAwOyBpIDwgdmRldi0+bm9fb2ZfdnBhdGg7IGkrKykgewotCQkvKiBSZWR1Y2UgdGhlIGNoYW5jZSBvZiBsb29zaW5nIGFsYXJtIGludGVycnVwdHMgYnkgbWFza2luZworCQkvKiBSZWR1Y2UgdGhlIGNoYW5jZSBvZiBsb3NpbmcgYWxhcm0gaW50ZXJydXB0cyBieSBtYXNraW5nCiAJCSAqIHRoZSB2ZWN0b3IuIEEgcGVuZGluZyBiaXQgd2lsbCBiZSBzZXQgaWYgYW4gYWxhcm0gaXMKIAkJICogZ2VuZXJhdGVkIGFuZCBvbiB1bm1hc2sgdGhlIGludGVycnVwdCB3aWxsIGJlIGZpcmVkLgogCQkgKi8KQEAgLTI3ODgsNyArMjc4OCw3IEBACiAJfQogCiAJLyogRW5hYmxlIHZwYXRoIHRvIHNuaWZmIGFsbCB1bmljYXN0L211bHRpY2FzdCB0cmFmZmljIHRoYXQgbm90Ci0JICogYWRkcmVzc2VkIHRvIHRoZW0uIFdlIGFsbG93IHByb21pc2NvdXMgbW9kZSBmb3IgUEYgb25seQorCSAqIGFkZHJlc3NlZCB0byB0aGVtLiBXZSBhbGxvdyBwcm9taXNjdW91cyBtb2RlIGZvciBQRiBvbmx5CiAJICovCiAKIAl2YWw2NCA9IDA7CkBAIC0yODkwLDcgKzI4OTAsNyBAQAogCXJldHVybiByZXQ7CiB9CiAKLS8qIExvb3AgdGhyb3VnaHQgdGhlIG1hYyBhZGRyZXNzIGxpc3QgYW5kIGRlbGV0ZSBhbGwgdGhlIGVudHJpZXMgKi8KKy8qIExvb3AgdGhyb3VnaCB0aGUgbWFjIGFkZHJlc3MgbGlzdCBhbmQgZGVsZXRlIGFsbCB0aGUgZW50cmllcyAqLwogc3RhdGljIHZvaWQgdnhnZV9mcmVlX21hY19hZGRfbGlzdChzdHJ1Y3QgdnhnZV92cGF0aCAqdnBhdGgpCiB7CiAKQEAgLTI5NTcsNyArMjk1Nyw3IEBACiAJCQkJCXZhbDY0KTsKIAkJfQogCi0JCS8qIFJlbW92ZSB0aGUgZnVuY3Rpb24gMCBmcm9tIHByb21pc2NvdXMgbW9kZSAqLworCQkvKiBSZW1vdmUgdGhlIGZ1bmN0aW9uIDAgZnJvbSBwcm9taXNjdW91cyBtb2RlICovCiAJCXZ4Z2VfaHdfbWdtdF9yZWdfd3JpdGUodmRldi0+ZGV2aCwKIAkJCXZ4Z2VfaHdfbWdtdF9yZWdfdHlwZV9tcnBjaW0sCiAJCQkwLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdnhnZS92eGdlLXRyYWZmaWMuYyBiL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS10cmFmZmljLmMKaW5kZXggODY3NGYzMy4uMjYzOGI4ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdnhnZS92eGdlLXRyYWZmaWMuYworKysgYi9kcml2ZXJzL25ldC92eGdlL3Z4Z2UtdHJhZmZpYy5jCkBAIC0xMTExLDcgKzExMTEsNyBAQAogICogdnhnZV9od19jaGFubmVsX2R0cl9jb3VudAogICogQGNoYW5uZWw6IENoYW5uZWwgaGFuZGxlLiBPYnRhaW5lZCB2aWEgdnhnZV9od19jaGFubmVsX29wZW4oKS4KICAqCi0gKiBSZXRyZWl2ZSBudW1iZXIgb2YgRFRScyBhdmFpbGFibGUuIFRoaXMgZnVuY3Rpb24gY2FuIG5vdCBiZSBjYWxsZWQKKyAqIFJldHJpZXZlIG51bWJlciBvZiBEVFJzIGF2YWlsYWJsZS4gVGhpcyBmdW5jdGlvbiBjYW4gbm90IGJlIGNhbGxlZAogICogZnJvbSBkYXRhIHBhdGguIHJpbmdfaW5pdGlhbF9yZXBsZW5pc2hpKCkgaXMgdGhlIG9ubHkgdXNlci4KICAqLwogaW50IHZ4Z2VfaHdfY2hhbm5lbF9kdHJfY291bnQoc3RydWN0IF9fdnhnZV9od19jaGFubmVsICpjaGFubmVsKQpAQCAtMjA2MCw3ICsyMDYwLDcgQEAKIAogCXZwYXRoID0gdnAtPnZwYXRoOwogCi0JLyogRW5hYmxlIHByb21pc2NvdXMgbW9kZSBmb3IgZnVuY3Rpb24gMCBvbmx5ICovCisJLyogRW5hYmxlIHByb21pc2N1b3VzIG1vZGUgZm9yIGZ1bmN0aW9uIDAgb25seSAqLwogCWlmICghKHZwYXRoLT5obGRldi0+YWNjZXNzX3JpZ2h0cyAmCiAJCVZYR0VfSFdfREVWSUNFX0FDQ0VTU19SSUdIVF9NUlBDSU0pKQogCQlyZXR1cm4gVlhHRV9IV19PSzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS10cmFmZmljLmggYi9kcml2ZXJzL25ldC92eGdlL3Z4Z2UtdHJhZmZpYy5oCmluZGV4IDlkOWRmZGEuLjZjMmZjMGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS10cmFmZmljLmgKKysrIGIvZHJpdmVycy9uZXQvdnhnZS92eGdlLXRyYWZmaWMuaApAQCAtNjgxLDcgKzY4MSw3IEBACiAgKiBAcnhfcmVkX2Rpc2NhcmQ6IENvdW50IG9mIHJlY2VpdmVkIGZyYW1lcyB0aGF0IGFyZSBkaXNjYXJkZWQgYmVjYXVzZSBvZiBSRUQKICAqICAgICAgICAgICAgKFJhbmRvbSBFYXJseSBEaXNjYXJkKS4KICAqIEByeF94Z21paV9jdHJsX2Vycl9jbnQ6IE1haW50YWlucyBhIGNvdW50IG9mIHVuZXhwZWN0ZWQgb3IgbWlzcGxhY2VkIGNvbnRyb2wKLSAqICAgICAgICAgICAgY2hhcmFjdGVycyBvY2N1cmluZyBiZXR3ZWVuIHRpbWVzIG9mIG5vcm1hbCBkYXRhIHRyYW5zbWlzc2lvbgorICogICAgICAgICAgICBjaGFyYWN0ZXJzIG9jY3VycmluZyBiZXR3ZWVuIHRpbWVzIG9mIG5vcm1hbCBkYXRhIHRyYW5zbWlzc2lvbgogICogICAgICAgICAgICAoaS5lLiBub3QgaW5jbHVkZWQgaW4gUlhfWEdNSUlfREFUQV9FUlJfQ05UKS4gVGhpcyBjb3VudGVyIGlzCiAgKiAgICAgICAgICAgIGluY3JlbWVudGVkIHdoZW4gZWl0aGVyIC0KICAqICAgICAgICAgICAgMSkgVGhlIFJlY29uY2lsaWF0aW9uIFN1YmxheWVyIChSUykgaXMgZXhwZWN0aW5nIG9uZSBjb250cm9sCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93YW4vY29zYS5jIGIvZHJpdmVycy9uZXQvd2FuL2Nvc2EuYwppbmRleCAxMGJhZmQ1Li42ZmI2ZjhlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93YW4vY29zYS5jCisrKyBiL2RyaXZlcnMvbmV0L3dhbi9jb3NhLmMKQEAgLTMyOSw3ICszMjksNyBAQAogc3RhdGljIGludCByZWFkbWVtKHN0cnVjdCBjb3NhX2RhdGEgKmNvc2EsIGNoYXIgX191c2VyICpkYXRhLCBpbnQgYWRkciwgaW50IGxlbik7CiBzdGF0aWMgaW50IGNvc2FfcmVzZXRfYW5kX3JlYWRfaWQoc3RydWN0IGNvc2FfZGF0YSAqY29zYSwgY2hhciAqaWQpOwogCi0vKiBBdXhpbGxpYXJ5IGZ1bmN0aW9ucyAqLworLyogQXV4aWxpYXJ5IGZ1bmN0aW9ucyAqLwogc3RhdGljIGludCBnZXRfd2FpdF9kYXRhKHN0cnVjdCBjb3NhX2RhdGEgKmNvc2EpOwogc3RhdGljIGludCBwdXRfd2FpdF9kYXRhKHN0cnVjdCBjb3NhX2RhdGEgKmNvc2EsIGludCBkYXRhKTsKIHN0YXRpYyBpbnQgcHV0aGV4bnVtYmVyKHN0cnVjdCBjb3NhX2RhdGEgKmNvc2EsIGludCBudW1iZXIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2FuL2RzY2M0LmMgYi9kcml2ZXJzL25ldC93YW4vZHNjYzQuYwppbmRleCA0NTc4ZTViLi5hY2I5ZWE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93YW4vZHNjYzQuYworKysgYi9kcml2ZXJzL25ldC93YW4vZHNjYzQuYwpAQCAtNTYsNyArNTYsNyBAQAogICogSVYuIE5vdGVzCiAgKiBUaGUgY3VycmVudCBlcnJvciAoWERVLCBSRk8pIHJlY292ZXJ5IGNvZGUgaXMgdW50ZXN0ZWQuCiAgKiBTbyBmYXIsIFJETyB0YWtlcyBoaXMgUlggY2hhbm5lbCBkb3duIGFuZCB0aGUgcmlnaHQgc2VxdWVuY2UgdG8gZW5hYmxlIGl0Ci0gKiBhZ2FpbiBpcyBzdGlsbCBhIG1pc3RlcnkuIElmIFJETyBoYXBwZW5zLCBwbGFuIGEgcmVib290LiBNb3JlIGRldGFpbHMKKyAqIGFnYWluIGlzIHN0aWxsIGEgbXlzdGVyeS4gSWYgUkRPIGhhcHBlbnMsIHBsYW4gYSByZWJvb3QuIE1vcmUgZGV0YWlscwogICogaW4gdGhlIGNvZGUgKE5COiBhcyB0aGlzIGhhcHBlbnMsIFRYIHN0aWxsIHdvcmtzKS4KICAqIERvbid0IG1lc3MgdGhlIGNhYmxlcyBkdXJpbmcgb3BlcmF0aW9uLCBlc3BlY2lhbGx5IG9uIERURSBwb3J0cy4gSSBkb24ndAogICogc3VnZ2VzdCBpdCBmb3IgRENFIGVpdGhlciBidXQgYXQgbGVhc3Qgb25lIGNhbiBnZXQgc29tZSBtZXNzYWdlcyBpbnN0ZWFkCkBAIC0xMDY1LDcgKzEwNjUsNyBAQAogCiAJLyoKIAkgKiBEdWUgdG8gdmFyaW91cyBidWdzLCB0aGVyZSBpcyBubyB3YXkgdG8gcmVsaWFibHkgcmVzZXQgYQotCSAqIHNwZWNpZmljIHBvcnQgKG1hbnVmYWN0dXJlcidzIGRlcGVuZGFudCBzcGVjaWFsIFBDSSAjUlNUIHdpcmluZworCSAqIHNwZWNpZmljIHBvcnQgKG1hbnVmYWN0dXJlcidzIGRlcGVuZGVudCBzcGVjaWFsIFBDSSAjUlNUIHdpcmluZwogCSAqIGFwYXJ0OiBpdCBhZmZlY3RzIGFsbCBwb3J0cykuIFRodXMgdGhlIGRldmljZSBnb2VzIGluIHRoZSBiZXN0CiAJICogc2lsZW50IG1vZGUgcG9zc2libGUgYXQgZHNjYzRfY2xvc2UoKSB0aW1lIGFuZCBzaW1wbHkgY2xhaW1zIHRvCiAJICogYmUgdXAgaWYgaXQncyBvcGVuZWQgYWdhaW4uIEl0IHN0aWxsIGlzbid0IHBvc3NpYmxlIHRvIGNoYW5nZQpAQCAtMTIzMCw5ICsxMjMwLDkgQEAKICAqICAgc2NhbGluZy4gT2YgY291cnNlIHNvbWUgcm91bmRpbmcgbWF5IHRha2UgcGxhY2UuCiAgKiAtIG5vIGhpZ2ggc3BlZWQgbW9kZSAoNDBNYi9zKS4gTWF5IGJlIHRyaXZpYWwgdG8gZG8gYnV0IEkgZG9uJ3QgaGF2ZSBhbgogICogICBhcHByb3ByaWF0ZSBleHRlcm5hbCBjbG9ja2luZyBkZXZpY2UgZm9yIHRlc3RpbmcuCi0gKiAtIG5vIHRpbWUtc2xvdC9jbG9jayBtb2RlIDU6IHNoYW1lbGVzcyBsYXp5bmVzcy4KKyAqIC0gbm8gdGltZS1zbG90L2Nsb2NrIG1vZGUgNTogc2hhbWVsZXNzIGxhemluZXNzLgogICoKLSAqIFRoZSBjbG9jayBzaWduYWxzIHdpcmluZyBjYW4gYmUgKGlzID8pIG1hbnVmYWN0dXJlciBkZXBlbmRhbnQuIEdvb2QgbHVjay4KKyAqIFRoZSBjbG9jayBzaWduYWxzIHdpcmluZyBjYW4gYmUgKGlzID8pIG1hbnVmYWN0dXJlciBkZXBlbmRlbnQuIEdvb2QgbHVjay4KICAqCiAgKiBCSUcgRkFUIFdBUk5JTkc6IGlmIHRoZSBkZXZpY2UgaXNuJ3QgcHJvdmlkZWQgZW5vdWdoIGNsb2NraW5nIHNpZ25hbCwgaXQKICAqIHdvbid0IHBhc3MgdGhlIGluaXQgc2VxdWVuY2UuIEZvciBleGFtcGxlLCBzdHJhaWdodCBiYWNrLXRvLWJhY2sgRFRFIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dhbi9ob3N0ZXNzX3N2MTEuYyBiL2RyaXZlcnMvbmV0L3dhbi9ob3N0ZXNzX3N2MTEuYwppbmRleCA0OGVkYzVmLi5lODE3NTgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93YW4vaG9zdGVzc19zdjExLmMKKysrIGIvZHJpdmVycy9uZXQvd2FuL2hvc3Rlc3Nfc3YxMS5jCkBAIC0xNSw3ICsxNSw3IEBACiAgKglUaGUgaGFyZHdhcmUgZG9lcyB0aGUgYnVzIGhhbmRsaW5nIHRvIGF2b2lkIHRoZSBuZWVkIGZvciBkZWxheXMgYmV0d2VlbgogICoJdG91Y2hpbmcgY29udHJvbCByZWdpc3RlcnMuCiAgKgotICoJUG9ydCBCIGlzbnQgd2lyZWQgKHdoeSAtIGJlYXRzIG1lKQorICoJUG9ydCBCIGlzbid0IHdpcmVkICh3aHkgLSBiZWF0cyBtZSkKICAqCiAgKglHZW5lcmljIEhETEMgcG9ydCBDb3B5cmlnaHQgKEMpIDIwMDggS3J6eXN6dG9mIEhhbGFzYSA8a2hjQHBtLndhdy5wbD4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2FuL2l4cDR4eF9oc3MuYyBiL2RyaXZlcnMvbmV0L3dhbi9peHA0eHhfaHNzLmMKaW5kZXggNmM1NzFlMS4uZjFlMTY0MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL2l4cDR4eF9oc3MuYworKysgYi9kcml2ZXJzL25ldC93YW4vaXhwNHh4X2hzcy5jCkBAIC0xNzgsNyArMTc4LDcgQEAKICAqCiAgKiBUaGUgcmVzdWx0aW5nIGF2ZXJhZ2UgY2xvY2sgZnJlcXVlbmN5IChhc3N1bWluZyAzMy4zMzMgTUh6IG9zY2lsbGF0b3IpIGlzOgogICogZnJlcSA9IDY2LjY2NiBNSHogLyAoQSArIChCICsgMSkgLyAoQyArIDEpKQotICogbWludW11bSBmcmVxID0gNjYuNjY2IE1IeiAvIChBICsgMSkKKyAqIG1pbmltdW0gZnJlcSA9IDY2LjY2NiBNSHogLyAoQSArIDEpCiAgKiBtYXhpbXVtIGZyZXEgPSA2Ni42NjYgTUh6IC8gQQogICoKICAqIEV4YW1wbGU6IEEgPSAyLCBCID0gMiwgQyA9IDcsIENMT0NLX0NSIHJlZ2lzdGVyID0gMiA8PCAyMiB8IDIgPDwgMTIgfCA3CkBAIC0yMzAsNyArMjMwLDcgQEAKICNkZWZpbmUgUEtUX1BJUEVfTU9ERV9XUklURQkJMHg1NwogCiAvKiBIRExDIHBhY2tldCBzdGF0dXMgdmFsdWVzIC0gZGVzYy0+c3RhdHVzICovCi0jZGVmaW5lIEVSUl9TSFVURE9XTgkJMSAvKiBzdG9wIG9yIHNodXRkb3duIG9jY3VycmFuY2UgKi8KKyNkZWZpbmUgRVJSX1NIVVRET1dOCQkxIC8qIHN0b3Agb3Igc2h1dGRvd24gb2NjdXJyZW5jZSAqLwogI2RlZmluZSBFUlJfSERMQ19BTElHTgkJMiAvKiBIRExDIGFsaWdubWVudCBlcnJvciAqLwogI2RlZmluZSBFUlJfSERMQ19GQ1MJCTMgLyogSERMQyBGcmFtZSBDaGVjayBTdW0gZXJyb3IgKi8KICNkZWZpbmUgRVJSX1JYRlJFRV9RX0VNUFRZCTQgLyogUlgtZnJlZSBxdWV1ZSBiZWNhbWUgZW1wdHkgd2hpbGUgcmVjZWl2aW5nCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93YW4vbG1jL2xtY19tYWluLmMgYi9kcml2ZXJzL25ldC93YW4vbG1jL2xtY19tYWluLmMKaW5kZXggNzBmZWI4NC4uYjdmMjM1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL2xtYy9sbWNfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3dhbi9sbWMvbG1jX21haW4uYwpAQCAtMjQsNyArMjQsNyBAQAogICAqCiAgICogTGludXggZHJpdmVyIG5vdGVzOgogICAqIExpbnV4IHVzZXMgdGhlIGRldmljZSBzdHJ1Y3QgbG1jX3ByaXZhdGUgdG8gcGFzcyBwcml2YXRlIGluZm9ybWF0aW9uCi0gICogYXJyb3VuZC4KKyAgKiBhcm91bmQuCiAgICoKICAgKiBUaGUgaW5pdGlhbGl6YXRpb24gcG9ydGlvbiBvZiB0aGlzIGRyaXZlciAodGhlIGxtY19yZXNldCgpIGFuZCB0aGUKICAgKiBsbWNfZGVjX3Jlc2V0KCkgZnVuY3Rpb25zLCBhcyB3ZWxsIGFzIHRoZSBsZWQgY29udHJvbHMgYW5kIHRoZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2FuL2xtYy9sbWNfdmFyLmggYi9kcml2ZXJzL25ldC93YW4vbG1jL2xtY192YXIuaAppbmRleCA2NWQwMTk3Li4wMWFkNDUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93YW4vbG1jL2xtY192YXIuaAorKysgYi9kcml2ZXJzL25ldC93YW4vbG1jL2xtY192YXIuaApAQCAtMTgwLDcgKzE4MCw3IEBACiAKIAogLyoKLSAqIENhcmVmdWxsLCBsb29rIGF0IHRoZSBkYXRhIHNoZWV0LCB0aGVyZSdzIG1vcmUgdG8gdGhpcworICogQ2FyZWZ1bCwgbG9vayBhdCB0aGUgZGF0YSBzaGVldCwgdGhlcmUncyBtb3JlIHRvIHRoaXMKICAqIHN0cnVjdHVyZSB0aGFuIG1lZXRzIHRoZSBleWUuICBJdCBzaG91bGQgcHJvYmFibHkgYmU6CiAgKgogICogc3RydWN0IHR1bGlwX2Rlc2NfdCB7CkBAIC0zODAsNyArMzgwLDcgQEAKIC8qIENTUjYgc2V0dGluZ3MgKi8KICNkZWZpbmUgT1BFUkFUSU9OX01PREUgIDB4MDAwMDAyMDAgLyogRnVsbCBEdXBsZXggICAgICAqLwogI2RlZmluZSBQUk9NSVNDX01PREUgICAgMHgwMDAwMDA0MCAvKiBQcm9taXNjdW91cyBNb2RlICovCi0jZGVmaW5lIFJFQ0lFVkVfQUxMICAgICAweDQwMDAwMDAwIC8qIFJlY2lldmUgQWxsICAgICAgKi8KKyNkZWZpbmUgUkVDSUVWRV9BTEwgICAgIDB4NDAwMDAwMDAgLyogUmVjZWl2ZSBBbGwgICAgICAqLwogI2RlZmluZSBQQVNTX0JBRF9GUkFNRVMgMHgwMDAwMDAwOCAvKiBQYXNzIEJhZCBGcmFtZXMgICovCiAKIC8qIERlYyBjb250cm9sIHJlZ2lzdGVycyAgQ1NSNiBhcyB3ZWxsICovCkBAIC0zOTgsNyArMzk4LDcgQEAKICNkZWZpbmUgVFVMSVBfQ01EX1JFQ0VJVkVBTEwgICAgMHg0MDAwMDAwMEwgLyogKFJXKSAgUmVjZWl2ZWwgYWxsIGZyYW1lcz8gKi8KICNkZWZpbmUgVFVMSVBfQ01EX01VU1RCRU9ORSAgICAgMHgwMjAwMDAwMEwgLyogKFJXKSAgTXVzdCBCZSBPbmUgKDIxMTQwKSAqLwogI2RlZmluZSBUVUxJUF9DTURfVFhUSFJTSExEQ1RMICAweDAwNDAwMDAwTCAvKiAoUlcpICBUcmFuc21pdCBUaHJlc2hvbGQgTW9kZSAoMjExNDApICovCi0jZGVmaW5lIFRVTElQX0NNRF9TVE9SRUZXRCAgICAgIDB4MDAyMDAwMDBMIC8qIChSVykgIFN0b3JlIGFuZCBGb3dhcmQgKDIxMTQwKSAqLworI2RlZmluZSBUVUxJUF9DTURfU1RPUkVGV0QgICAgICAweDAwMjAwMDAwTCAvKiAoUlcpICBTdG9yZSBhbmQgRm9yd2FyZCAoMjExNDApICovCiAjZGVmaW5lIFRVTElQX0NNRF9OT0hFQVJUQkVBVCAgIDB4MDAwODAwMDBMIC8qIChSVykgIE5vIEhlYXJ0YmVhdCAoMjExNDApICovCiAjZGVmaW5lIFRVTElQX0NNRF9QT1JUU0VMRUNUICAgIDB4MDAwNDAwMDBMIC8qIChSVykgIFBvc3QgU2VsZWN0ICgxMDBNYikgKDIxMTQwKSAqLwogI2RlZmluZSBUVUxJUF9DTURfRlVMTERVUExFWCAgICAweDAwMDAwMjAwTCAvKiAoUlcpICBGdWxsIER1cGxleCBNb2RlICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93YW4vejg1MjMwLmMgYi9kcml2ZXJzL25ldC93YW4vejg1MjMwLmMKaW5kZXggOTM5NTY4Ni4uMDgwNjIzMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL3o4NTIzMC5jCisrKyBiL2RyaXZlcnMvbmV0L3dhbi96ODUyMzAuYwpAQCAtNTQyLDcgKzU0Miw3IEBACiAJCXo4NTMwX3R4KGNoYW4pOwogCQlyZXR1cm47CiAJfQotCS8qIFRoaXMgc2hvdWxkbnQgb2NjdXIgaW4gRE1BIG1vZGUgKi8KKwkvKiBUaGlzIHNob3VsZG4ndCBvY2N1ciBpbiBETUEgbW9kZSAqLwogCXByaW50ayhLRVJOX0VSUiAiRE1BIHR4IC0gYm9ndXMgZXZlbnQhXG4iKTsKIAl6ODUzMF90eChjaGFuKTsKIH0KQEAgLTEyMTksNyArMTIxOSw3IEBACiAgKglAaW86IHRoZSBwb3J0IHZhbHVlIGluIHF1ZXN0aW9uCiAgKgogICoJRGVzY3JpYmUgYSBaODUzMCBpbiBhIHN0YW5kYXJkIGZvcm1hdC4gV2UgbXVzdCBwYXNzIHRoZSBJL08gYXMKLSAqCXRoZSBwb3J0IG9mZnNldCBpc250IHByZWRpY3RhYmxlLiBUaGUgbWFpbiByZWFzb24gZm9yIHRoaXMgZnVuY3Rpb24KKyAqCXRoZSBwb3J0IG9mZnNldCBpc24ndCBwcmVkaWN0YWJsZS4gVGhlIG1haW4gcmVhc29uIGZvciB0aGlzIGZ1bmN0aW9uCiAgKglpcyB0byB0cnkgYW5kIGdldCBhIGNvbW1vbiBmb3JtYXQgb2YgcmVwb3J0LgogICovCiAKQEAgLTE1ODgsNyArMTU4OCw3IEBACiAJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJCQogCQkvKgotCQkgKglDb21wbGV0ZSB0aGlzIERNQS4gTmVjY2Vzc2FyeSB0byBmaW5kIHRoZSBsZW5ndGgKKwkJICoJQ29tcGxldGUgdGhpcyBETUEuIE5lY2Vzc2FyeSB0byBmaW5kIHRoZSBsZW5ndGgKIAkJICovCQkKIAkJIAogCQlmbGFncz1jbGFpbV9kbWFfbG9jaygpOwpAQCAtMTY1Nyw3ICsxNjU3LDcgQEAKIAkJICoJZmlmbyBsZW5ndGggZm9yIHRoaXMuIFRodXMgd2Ugd2FudCB0byBmbGlwIHRvIHRoZSBuZXcKIAkJICoJYnVmZmVyIGFuZCB0aGVuIG1lc3MgYXJvdW5kIGNvcHlpbmcgYW5kIGFsbG9jYXRpbmcKIAkJICoJdGhpbmdzLiBGb3IgdGhlIGN1cnJlbnQgY2FzZSBpdCBkb2Vzbid0IG1hdHRlciBidXQKLQkJICoJaWYgeW91IGJ1aWxkIGEgc3lzdGVtIHdoZXJlIHRoZSBzeW5jIGlycSBpc250IGJsb2NrZWQKKwkJICoJaWYgeW91IGJ1aWxkIGEgc3lzdGVtIHdoZXJlIHRoZSBzeW5jIGlycSBpc24ndCBibG9ja2VkCiAJCSAqCWJ5IHRoZSBrZXJuZWwgSVJRIGRpc2FibGUgdGhlbiB5b3UgbmVlZCBvbmx5IGJsb2NrIHRoZQogCQkgKglzeW5jIElSUSBmb3IgdGhlIFJUX0xPQ0sgYXJlYS4KIAkJICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9jb250cm9sLmMgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vY29udHJvbC5jCmluZGV4IDEyYjg0ZWQuLjcyN2Q3MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9jb250cm9sLmMKKysrIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL2NvbnRyb2wuYwpAQCAtMzc4LDcgKzM3OCw3IEBACiAgKiB0aGUgZGV2aWNlJ3Mgc3RhdGUgYXMgc29tZXRpbWVzIHdlIG5lZWQgdG8gZG8gYSBsaW5rLXJlbmV3ICh0aGUgQlMKICAqIHdhbnRzIHVzIHRvIHJlbmV3IGEgREhDUCBsZWFzZSwgZm9yIGV4YW1wbGUpLgogICoKLSAqIEluIGZhY3QsIGRvYyBzYXlzIHRoYXQgZXZlcnl0aW1lIHdlIGdldCBhIGxpbmstdXAsIHdlIHNob3VsZCBkbyBhCisgKiBJbiBmYWN0LCBkb2Mgc2F5cyB0aGF0IGV2ZXJ5IHRpbWUgd2UgZ2V0IGEgbGluay11cCwgd2Ugc2hvdWxkIGRvIGEKICAqIERIQ1AgbmVnb3RpYXRpb24uLi4KICAqLwogc3RhdGljCkBAIC02NzUsNyArNjc1LDcgQEAKICAqICAtIHRoZSBhY2sgbWVzc2FnZSB3YXNuJ3QgZm9ybWF0dGVkIGNvcnJlY3RseQogICoKICAqIFRoZSByZXR1cm5lZCBza2IgaGFzIGJlZW4gYWxsb2NhdGVkIHdpdGggd2ltYXhfbXNnX3RvX3VzZXJfYWxsb2MoKSwKLSAqIGl0IGNvbnRhaW5zIHRoZSByZXBvbnNlIGluIGEgbmV0bGluayBhdHRyaWJ1dGUgYW5kIGlzIHJlYWR5IHRvIGJlCisgKiBpdCBjb250YWlucyB0aGUgcmVzcG9uc2UgaW4gYSBuZXRsaW5rIGF0dHJpYnV0ZSBhbmQgaXMgcmVhZHkgdG8gYmUKICAqIHBhc3NlZCB1cCB0byB1c2VyIHNwYWNlIHdpdGggd2ltYXhfbXNnX3RvX3VzZXJfc2VuZCgpLiBUbyBhY2Nlc3MKICAqIHRoZSBwYXlsb2FkIGFuZCBpdHMgbGVuZ3RoLCB1c2Ugd2ltYXhfbXNnX3tkYXRhLGxlbn0oKSBvbiB0aGUgc2tiLgogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9kcml2ZXIuYyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9kcml2ZXIuYwppbmRleCA2NWJjMzM0Li40N2NhZTcxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vZHJpdmVyLmMKKysrIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL2RyaXZlci5jCkBAIC02NTQsNyArNjU0LDcgQEAKIAlpZiAocmVzdWx0ID09IC1FVUNMRUFOKSB7CiAJCS8qCiAJCSAqIFdlIGNvbWUgaGVyZSBiZWNhdXNlIHRoZSByZXNldCBkdXJpbmcgb3BlcmF0aW9uYWwgbW9kZQotCQkgKiB3YXNuJ3Qgc3VjY2Vzc3VsbHkgZG9uZSBhbmQgbmVlZCB0byBwcm9jZWVkIHRvIGEgYnVzCisJCSAqIHdhc24ndCBzdWNjZXNzZnVsbHkgZG9uZSBhbmQgbmVlZCB0byBwcm9jZWVkIHRvIGEgYnVzCiAJCSAqIHJlc2V0LiBGb3IgdGhlIGRldl9yZXNldF9oYW5kbGUoKSB0byBiZSBhYmxlIHRvIGhhbmRsZQogCQkgKiB0aGUgcmVzZXQgZXZlbnQgbGF0ZXIgcHJvcGVybHksIHdlIHJlc3RvcmUgYm9vdF9tb2RlIGJhY2sKIAkJICogdG8gdGhlIHN0YXRlIGJlZm9yZSBwcmV2aW91cyByZXNldC4gaWU6IGp1c3QgbGlrZSB3ZSBhcmUKQEAgLTc1NSw3ICs3NTUsNyBAQAogICogQWxsb2MgdGhlIGNvbW1hbmQgYW5kIGFjayBidWZmZXJzIGZvciBib290IG1vZGUKICAqCiAgKiBHZXQgdGhlIGJ1ZmZlcnMgbmVlZGVkIHRvIGRlYWwgd2l0aCBib290IG1vZGUgbWVzc2FnZXMuICBUaGVzZQotICogYnVmZmVycyBuZWVkIHRvIGJlIGFsbG9jYXRlZCBiZWZvcmUgdGhlIHNkaW8gcmVjaWV2ZSBpcnEgaXMgc2V0dXAuCisgKiBidWZmZXJzIG5lZWQgdG8gYmUgYWxsb2NhdGVkIGJlZm9yZSB0aGUgc2RpbyByZWNlaXZlIGlycSBpcyBzZXR1cC4KICAqLwogc3RhdGljCiBpbnQgaTI0MDBtX2JtX2J1Zl9hbGxvYyhzdHJ1Y3QgaTI0MDBtICppMjQwMG0pCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vZncuYyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9mdy5jCmluZGV4IDhiNTVhNWIuLjg1ZGFkZDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9mdy5jCisrKyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9mdy5jCkBAIC01NCw3ICs1NCw3IEBACiAgKiBlbmRwb2ludCBhbmQgcmVhZCBmcm9tIGl0IGluIHRoZSBub3RpZmljYXRpb24gZW5kcG9pbnQuIEluIFNESU8gd2UKICAqIHRhbGsgdG8gaXQgdmlhIHRoZSB3cml0ZSBhZGRyZXNzIGFuZCByZWFkIGZyb20gdGhlIHJlYWQgYWRkcmVzcy4KICAqCi0gKiBVcG9uIGVudHJhbmNlIHRvIGJvb3QgbW9kZSwgdGhlIGRldmljZSBzZW5kcyAocHJlY2VlZGVkIHdpdGggYSBmZXcKKyAqIFVwb24gZW50cmFuY2UgdG8gYm9vdCBtb2RlLCB0aGUgZGV2aWNlIHNlbmRzIChwcmVjZWRlZCB3aXRoIGEgZmV3CiAgKiB6ZXJvIGxlbmd0aCBwYWNrZXRzIChaTFBzKSBvbiB0aGUgbm90aWZpY2F0aW9uIGVuZHBvaW50IGluIFVTQikgYQogICogcmVib290IGJhcmtlciAoNCBsZTMyIHdvcmRzIHdpdGggdGhlIHNhbWUgdmFsdWUpLiBXZSBhY2sgaXQgYnkKICAqIHNlbmRpbmcgdGhlIHNhbWUgYmFya2VyIHRvIHRoZSBkZXZpY2UuIFRoZSBkZXZpY2UgYWNrcyB3aXRoIGEKQEAgLTE1ODksNyArMTU4OSw3IEBACiAJCWkyNDAwbS0+ZndfbmFtZSA9IGZ3X25hbWU7CiAJCXJldCA9IGkyNDAwbV9md19ib290c3RyYXAoaTI0MDBtLCBmdywgZmxhZ3MpOwogCQlyZWxlYXNlX2Zpcm13YXJlKGZ3KTsKLQkJaWYgKHJldCA+PSAwKQkvKiBmaXJtd2FyZSBsb2FkZWQgc3VjY2VzZnVsbHkgKi8KKwkJaWYgKHJldCA+PSAwKQkvKiBmaXJtd2FyZSBsb2FkZWQgc3VjY2Vzc2Z1bGx5ICovCiAJCQlicmVhazsKIAkJaTI0MDBtLT5md19uYW1lID0gTlVMTDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vaTI0MDBtLXVzYi5oIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL2kyNDAwbS11c2IuaAppbmRleCBlYjgwMjQzLi42NjUwZmRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vaTI0MDBtLXVzYi5oCisrKyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9pMjQwMG0tdXNiLmgKQEAgLTEwNSwxNCArMTA1LDE0IEBACiAgKgogICogQGVkYzogcG9pbnRlciB0byBlcnJvciBkZW5zaXR5IGNvdW50ZXIuCiAgKiBAbWF4X2VycjogbWF4aW11bSBudW1iZXIgb2YgZXJyb3JzIHdlIGNhbiBhY2NlcHQgb3ZlciB0aGUgdGltZWZyYW1lCi0gKiBAdGltZWZyYW1lOiBsZW5naHQgb2YgdGhlIHRpbWVmcmFtZSAoaW4gamlmZmllcykuCisgKiBAdGltZWZyYW1lOiBsZW5ndGggb2YgdGhlIHRpbWVmcmFtZSAoaW4gamlmZmllcykuCiAgKgogICogUmV0dXJuczogITAgMSBpZiBtYXhpbXVtIGFjY2VwdGFibGUgZXJyb3JzIHBlciB0aW1lZnJhbWUgaGFzIGJlZW4KICAqICAgICBleGNlZWRlZC4gMCBvdGhlcndpc2UuCiAgKgogICogVGhpcyBpcyB3YXkgdG8gZGV0ZXJtaW5lIGlmIHRoZSBudW1iZXIgb2YgYWNjZXB0YWJsZSBlcnJvcnMgcGVyIHRpbWUKICAqIHBlcmlvZCBoYXMgYmVlbiBleGNlZWRlZC4gSXQgaXMgbm90IGFjY3VyYXRlIGFzIHRoZXJlIGFyZSBjYXNlcyBpbiB3aGljaAotICogdGhpcyBzY2hlbWUgd2lsbCBub3Qgd29yaywgZm9yIGV4YW1wbGUgaWYgdGhlcmUgYXJlIHBlcmlvZGljIG9jY3VyZW5jZXMKKyAqIHRoaXMgc2NoZW1lIHdpbGwgbm90IHdvcmssIGZvciBleGFtcGxlIGlmIHRoZXJlIGFyZSBwZXJpb2RpYyBvY2N1cnJlbmNlcwogICogb2YgZXJyb3JzIHRoYXQgc3RyYWRkbGUgdXBkYXRlcyB0byB0aGUgc3RhcnQgdGltZS4gVGhpcyBzY2hlbWUgaXMKICAqIHN1ZmZpY2llbnQgZm9yIG91ciB1c2FnZS4KICAqCkBAIC0yMDQsNyArMjA0LDcgQEAKICAqICAgICB1c2JfYXV0b3BtX2dldC9wdXRfaW50ZXJmYWNlKCkgYmFycmllcnMgd2hlbiBleGVjdXRpbmcKICAqICAgICBjb21tYW5kcy4gU2VlIGRvYyBpbiBpMjQwMG11X3N1c3BlbmQoKSBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KICAqCi0gKiBAcnhfc2l6ZV9hdXRvX3NocmluazogaWYgdHJ1ZSwgdGhlIHJ4X3NpemUgaXMgc2hyaW5rZWQKKyAqIEByeF9zaXplX2F1dG9fc2hyaW5rOiBpZiB0cnVlLCB0aGUgcnhfc2l6ZSBpcyBzaHJ1bmsKICAqICAgICBhdXRvbWF0aWNhbGx5IGJhc2VkIG9uIHRoZSBhdmVyYWdlIHNpemUgb2YgdGhlIHJlY2VpdmVkCiAgKiAgICAgdHJhbnNhY3Rpb25zLiBUaGlzIGFsbG93cyB0aGUgcmVjZWl2ZSBjb2RlIHRvIGFsbG9jYXRlIHNtYWxsZXIKICAqICAgICBjaHVua3Mgb2YgbWVtb3J5IGFuZCB0aHVzIHJlZHVjZSBwcmVzc3VyZSBvbiB0aGUgbWVtb3J5CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vaTI0MDBtLmggYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vaTI0MDBtLmgKaW5kZXggMDMwY2JmZC4uNWVhY2M2NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL2kyNDAwbS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9pMjQwMG0uaApAQCAtNTI2LDcgKzUyNiw3IEBACiAgKgogICogQGJhcmtlcjogYmFya2VyIHR5cGUgdGhhdCB0aGUgZGV2aWNlIHVzZXM7IHRoaXMgaXMgaW5pdGlhbGl6ZWQgYnkKICAqICAgICBpMjQwMG1faXNfYm9vdF9iYXJrZXIoKSB0aGUgZmlyc3QgdGltZSBpdCBpcyBjYWxsZWQuIFRoZW4gaXQKLSAqICAgICB3b24ndCBjaGFuZ2UgZHVyaW5nIHRoZSBsaWZlIGN5Y2xlIG9mIHRoZSBkZXZpY2UgYW5kIGV2ZXJ5dGltZQorICogICAgIHdvbid0IGNoYW5nZSBkdXJpbmcgdGhlIGxpZmUgY3ljbGUgb2YgdGhlIGRldmljZSBhbmQgZXZlcnkgdGltZQogICogICAgIGEgYm9vdCBiYXJrZXIgaXMgcmVjZWl2ZWQsIGl0IGlzIGp1c3QgdmVyaWZpZWQgZm9yIGl0IGJlaW5nIHRoZQogICogICAgIHNhbWUuCiAgKgpAQCAtOTI4LDcgKzkyOCw3IEBACiAJc3RydWN0IGkyNDAwbSAqLCBjb25zdCBzdHJ1Y3QgaTI0MDBtX3Rsdl9yZl9zd2l0Y2hlc19zdGF0dXMgKik7CiAKIC8qCi0gKiBIZWxwZXJzIGZvciBmaXJtd2FyZSBiYWNrd2FyZHMgY29tcGFiaWxpdHkKKyAqIEhlbHBlcnMgZm9yIGZpcm13YXJlIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5CiAgKgogICogQXMgd2UgYWltIHRvIHN1cHBvcnQgYXQgbGVhc3QgdGhlIGZpcm13YXJlIHZlcnNpb24gdGhhdCB3YXMKICAqIHJlbGVhc2VkIHdpdGggdGhlIHByZXZpb3VzIGtlcm5lbC9kcml2ZXIgcmVsZWFzZSwgc29tZSBjb2RlIHdpbGwgYmUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9uZXRkZXYuYyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9uZXRkZXYuYwppbmRleCA5NDc0MmUxLi4yZWRkOGZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vbmV0ZGV2LmMKKysrIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL25ldGRldi5jCkBAIC0xNjYsNyArMTY2LDcgQEAKIAlkX2Zuc3RhcnQoMywgZGV2LCAiKHdzICVwIGkyNDAwbSAlcCBza2IgJXApXG4iLCB3cywgaTI0MDBtLCBza2IpOwogCXJlc3VsdCA9IC1FSU5WQUw7CiAJaWYgKHNrYiA9PSBOVUxMKSB7Ci0JCWRldl9lcnIoZGV2LCAiV0FLRSZUWDogc2tiIGRpc3NhcGVhcmVkIVxuIik7CisJCWRldl9lcnIoZGV2LCAiV0FLRSZUWDogc2tiIGRpc2FwcGVhcmVkIVxuIik7CiAJCWdvdG8gb3V0X3B1dDsKIAl9CiAJLyogSWYgd2UgaGF2ZSwgc29tZWhvdywgbG9zdCB0aGUgY29ubmVjdGlvbiBhZnRlciB0aGlzIHdhcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL29wLXJma2lsbC5jIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL29wLXJma2lsbC5jCmluZGV4IDllMDJiOTAuLmIwZGJhMzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS9vcC1yZmtpbGwuYworKysgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vb3AtcmZraWxsLmMKQEAgLTI3LDcgKzI3LDcgQEAKICAqIC0gcmVwb3J0IGNoYW5nZXMgaW4gdGhlIEhXIFJGIEtpbGwgc3dpdGNoIFt3aXRoCiAgKiAgIHdpbWF4X3Jma2lsbF97c3csaHd9X3JlcG9ydCgpLCB3aGljaCBoYXBwZW5zIHdoZW4gd2UgZGV0ZWN0IHRob3NlCiAgKiAgIGluZGljYXRpb25zIGNvbWluZyB0aHJvdWdoIGhhcmR3YXJlIHJlcG9ydHNdLiBXZSBhbHNvIGRvIGl0IG9uCi0gKiAgIGluaXRpYWxpemF0aW9uIHRvIGxldCB0aGUgc3RhY2sga25vdyB0aGUgaW50aWFsIEhXIHN0YXRlLgorICogICBpbml0aWFsaXphdGlvbiB0byBsZXQgdGhlIHN0YWNrIGtub3cgdGhlIGluaXRpYWwgSFcgc3RhdGUuCiAgKgogICogLSBpbXBsZW1lbnQgaW5kaWNhdGlvbnMgZnJvbSB0aGUgc3RhY2sgdG8gY2hhbmdlIHRoZSBTVyBSRiBLaWxsCiAgKiAgIHN3aXRjaCAoY29taW5nIGZyb20gc3lzZnMsIHRoZSB3aW1heCBzdGFjayBvciB1c2VyIHNwYWNlKS4KQEAgLTczLDcgKzczLDcgQEAKICAqIEdlbmVyaWMgTmV0bGluayB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbiB3aGVuIGEgbWVzc2FnZSBpcyBzZW50IGZyb20KICAqIHVzZXJzcGFjZSB0byBjaGFuZ2UgdGhlIHNvZnR3YXJlIFJGLUtpbGwgc3dpdGNoIHN0YXR1cy4KICAqCi0gKiBUaGlzIGZ1bmN0aW9uIHdpbGwgc2V0IHRoZSBkZXZpY2UncyBzb2Z3YXJlIFJGLUtpbGwgc3dpdGNoIHN0YXRlIHRvCisgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgc2V0IHRoZSBkZXZpY2UncyBzb2Z0d2FyZSBSRi1LaWxsIHN3aXRjaCBzdGF0ZSB0bwogICogbWF0Y2ggd2hhdCBpcyByZXF1ZXN0ZWQuCiAgKgogICogTk9URTogdGhlIGkyNDAwbSBoYXMgYSBzdHJpY3Qgc3RhdGUgbWFjaGluZTsgd2UgY2FuIG9ubHkgc2V0IHRoZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL3J4LmMgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vcnguYwppbmRleCA4NDQxMzNiLi4yZjk0YTg3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vcnguYworKysgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vcnguYwpAQCAtMzQ5LDcgKzM0OSw3IEBACiAgKgogICogRm9yIHJlcG9ydHM6IFdlIGNhbid0IGNsb25lIHRoZSBvcmlnaW5hbCBza2Igd2hlcmUgdGhlIGRhdGEgaXMKICAqIGJlY2F1c2Ugd2UgbmVlZCB0byBzZW5kIHRoaXMgdXAgdmlhIG5ldGxpbms7IG5ldGxpbmsgaGFzIHRvIGFkZAotICogaGVhZGVycyBhbmQgd2UgY2FuJ3Qgb3ZlcndyaXRlIHdoYXQncyBwcmVjZWVkaW5nIHRoZSBwYXlsb2FkLi4uYXMKKyAqIGhlYWRlcnMgYW5kIHdlIGNhbid0IG92ZXJ3cml0ZSB3aGF0J3MgcHJlY2VkaW5nIHRoZSBwYXlsb2FkLi4uYXMKICAqIGl0IGlzIGFub3RoZXIgbWVzc2FnZS4gU28gd2UganVzdCBkdXAgdGhlbS4KICAqLwogc3RhdGljCkBAIC00MjUsNyArNDI1LDcgQEAKICAqCiAgKiBBcyBpbiBpMjQwMG1fcnhfY3RsKCksIHdlIGNhbid0IGNsb25lIHRoZSBvcmlnaW5hbCBza2Igd2hlcmUgdGhlCiAgKiBkYXRhIGlzIGJlY2F1c2Ugd2UgbmVlZCB0byBzZW5kIHRoaXMgdXAgdmlhIG5ldGxpbms7IG5ldGxpbmsgaGFzIHRvCi0gKiBhZGQgaGVhZGVycyBhbmQgd2UgY2FuJ3Qgb3ZlcndyaXRlIHdoYXQncyBwcmVjZWVkaW5nIHRoZQorICogYWRkIGhlYWRlcnMgYW5kIHdlIGNhbid0IG92ZXJ3cml0ZSB3aGF0J3MgcHJlY2VkaW5nIHRoZQogICogcGF5bG9hZC4uLmFzIGl0IGlzIGFub3RoZXIgbWVzc2FnZS4gU28gd2UganVzdCBkdXAgdGhlbS4KICAqLwogc3RhdGljCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vdHguYyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS90eC5jCmluZGV4IDNmODE5ZWYuLjRiMzBlZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS90eC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS90eC5jCkBAIC0xNDksNyArMTQ5LDcgQEAKICAqICh3aXRoIGEgbW92ZWQgbWVzc2FnZSBoZWFkZXIgdG8gbWFrZSBzdXJlIGl0IGlzIHNpemUtYWxpZ25lZCB0bwogICogMTYpLCBUQUlMIHJvb20gdGhhdCB3YXMgdW51c2FibGUgKGFuZCB0aHVzIGlzIG1hcmtlZCB3aXRoIGEgbWVzc2FnZQogICogaGVhZGVyIHRoYXQgc2F5cyAnc2tpcCB0aGlzJykgYW5kIGF0IHRoZSBoZWFkIG9mIHRoZSBidWZmZXIsIGFuCi0gKiBpbWNvbXBsZXRlIG1lc3NhZ2Ugd2l0aCBhIGNvdXBsZSBvZiBwYXlsb2Fkcy4KKyAqIGluY29tcGxldGUgbWVzc2FnZSB3aXRoIGEgY291cGxlIG9mIHBheWxvYWRzLgogICoKICAqIE4gICBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KICAqICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CkBAIC04MTksNyArODE5LDcgQEAKICAqIHRoZSBGSUYgdGhhdCBpcyByZWFkeSBmb3IgdHJhbnNtaXNzaW9uLgogICoKICAqIEl0IHNldHMgdGhlIHN0YXRlIGluIEBpMjQwMG0gdG8gaW5kaWNhdGUgdGhlIGJ1cy1zcGVjaWZpYyBkcml2ZXIgaXMKLSAqIHRyYW5zZmVyaW5nIHRoYXQgbWVzc2FnZSAoaTI0MDBtLT50eF9tc2dfc2l6ZSkuCisgKiB0cmFuc2ZlcnJpbmcgdGhhdCBtZXNzYWdlIChpMjQwMG0tPnR4X21zZ19zaXplKS4KICAqCiAgKiBPbmNlIHRoZSB0cmFuc2ZlciBpcyBjb21wbGV0ZWQsIGNhbGwgaTI0MDBtX3R4X21zZ19zZW50KCkuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL3VzYi1mdy5jIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL3VzYi1mdy5jCmluZGV4IGI1OGVjNTYuLjFmZGE0NmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS91c2ItZncuYworKysgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vdXNiLWZ3LmMKQEAgLTE2OSw3ICsxNjksNyBAQAogICoKICAqIENvbW1hbmQgY2FuIGJlIGEgcmF3IGNvbW1hbmQsIHdoaWNoIHJlcXVpcmVzIG5vIHByZXBhcmF0aW9uIChhbmQKICAqIHdoaWNoIG1pZ2h0IG5vdCBldmVuIGJlIGZvbGxvd2luZyB0aGUgY29tbWFuZCBmb3JtYXQpLiBDaGVja3MgdGhhdAotICogdGhlIHJpZ2h0IGFtb3VudCBvZiBkYXRhIHdhcyB0cmFuc2ZlcmVkLgorICogdGhlIHJpZ2h0IGFtb3VudCBvZiBkYXRhIHdhcyB0cmFuc2ZlcnJlZC4KICAqCiAgKiBUbyBzYXRpc2Z5IFVTQiByZXF1aXJlbWVudHMgKG5vIG9uc3RhY2ssIHZtYWxsb2Mgb3IgaW4gZGF0YSBzZWdtZW50CiAgKiBidWZmZXJzKSwgd2UgY29weSB0aGUgY29tbWFuZCB0byBpMjQwMG0tPmJtX2NtZF9idWYgYW5kIHNlbmQgaXQgZnJvbQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL3VzYi1yeC5jIGIvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL3VzYi1yeC5jCmluZGV4IGEyNjQ4M2EuLmUzMjU3NjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS91c2ItcnguYworKysgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vdXNiLXJ4LmMKQEAgLTU4LDcgKzU4LDcgQEAKICAqICAgIGEgemlsbGlvbiByZWFkczsgYnkgc2VyaWFsaXppbmcsIHdlIGFyZSB0aHJvdHRsaW5nLgogICoKICAqICAtIFJYIGRhdGEgcHJvY2Vzc2luZyBjYW4gZ2V0IGhlYXZ5IGVub3VnaCBzbyB0aGF0IGl0IGlzIG5vdAotICogICAgYXBwcm9waWF0ZSBmb3IgZG9pbmcgaXQgaW4gdGhlIFVTQiBjYWxsYmFjazsgdGh1cyB3ZSBydW4gaXQgaW4gYQorICogICAgYXBwcm9wcmlhdGUgZm9yIGRvaW5nIGl0IGluIHRoZSBVU0IgY2FsbGJhY2s7IHRodXMgd2UgcnVuIGl0IGluIGEKICAqICAgIHByb2Nlc3MgY29udGV4dC4KICAqCiAgKiBXZSBwcm92aWRlIGEgcmVhZCBidWZmZXIgb2YgYW4gYXJiaXRyYXJ5IHNpemUgKHNob3J0IG9mIGEgcGFnZSk7IGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vdXNiLXR4LmMgYi9kcml2ZXJzL25ldC93aW1heC9pMjQwMG0vdXNiLXR4LmMKaW5kZXggYzY1Yjk5Ny4uYWMzNTdhYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2ltYXgvaTI0MDBtL3VzYi10eC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpbWF4L2kyNDAwbS91c2ItdHguYwpAQCAtMTY4LDcgKzE2OCw3IEBACiAvKgogICogR2V0IHRoZSBuZXh0IFRYIG1lc3NhZ2UgaW4gdGhlIFRYIEZJRk8gYW5kIHNlbmQgaXQgdG8gdGhlIGRldmljZQogICoKLSAqIE5vdGUgd2UgZXhpdCB0aGUgbG9vcCBpZiBpMjQwMG11X3R4KCkgZmFpbHM7IHRoYXQgZnVudGlvbiBvbmx5CisgKiBOb3RlIHdlIGV4aXQgdGhlIGxvb3AgaWYgaTI0MDBtdV90eCgpIGZhaWxzOyB0aGF0IGZ1bmN0aW9uIG9ubHkKICAqIGZhaWxzIG9uIGhhcmQgZXJyb3IgKGZhaWxpbmcgdG8gdHggYSBidWZmZXIgbm90IGJlaW5nIG9uZSBvZiB0aGVtLAogICogc2VlIGl0cyBkb2MpLgogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2Fpcm8uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2Fpcm8uYwppbmRleCA1N2E3OWIwLi40ZTVjN2ExIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9haXJvLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWlyby5jCkBAIC0xODg0LDcgKzE4ODQsNyBAQAogCS8qIE1ha2Ugc3VyZSB0aGUgY2FyZCBpcyBjb25maWd1cmVkLgogCSAqIFdpcmVsZXNzIEV4dGVuc2lvbnMgbWF5IHBvc3Rwb25lIGNvbmZpZyBjaGFuZ2VzIHVudGlsIHRoZSBjYXJkCiAJICogaXMgb3BlbiAodG8gcGlwZWxpbmUgY2hhbmdlcyBhbmQgc3BlZWQtdXAgY2FyZCBzZXR1cCkuIElmCi0JICogdGhvc2UgY2hhbmdlcyBhcmUgbm90IHlldCBjb21taXRlZCwgZG8gaXQgbm93IC0gSmVhbiBJSSAqLworCSAqIHRob3NlIGNoYW5nZXMgYXJlIG5vdCB5ZXQgY29tbWl0dGVkLCBkbyBpdCBub3cgLSBKZWFuIElJICovCiAJaWYgKHRlc3RfYml0KEZMQUdfQ09NTUlULCAmYWktPmZsYWdzKSkgewogCQlkaXNhYmxlX01BQyhhaSwgMSk7CiAJCXdyaXRlQ29uZmlnUmlkKGFpLCAxKTsKQEAgLTE5OTIsNyArMTk5Miw3IEBACiAvKgogICogTWFnaWMsIHRoZSBjYXJkcyBmaXJtd2FyZSBuZWVkcyBhIGxlbmd0aCBjb3VudCAoMiBieXRlcykgaW4gdGhlIGhvc3QgYnVmZmVyCiAgKiByaWdodCBhZnRlciAgVFhGSURfSERSLlRoZSBUWEZJRF9IRFIgY29udGFpbnMgdGhlIHN0YXR1cyBzaG9ydCBzbyBwYXlsb2FkbGVuCi0gKiBpcyBpbW1lZGlhdGx5IGFmdGVyIGl0LiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIGlzIGltbWVkaWF0ZWx5IGFmdGVyIGl0LiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqICAgICAgICAgICAgICAgICAgICAgICAgIHxUWEZJREhEUitTVEFUVVN8UEFZTE9BRExFTnw4MDIuM0hEUnxQQUNLRVREQVRBfAogICogICAgICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKi8KQEAgLTIwMDYsNyArMjAwNiw3IEBACiAJCXNpemVvZih3aWZpY3RsaGRyODAyMykgKyAyIDsKIAogCS8qCi0JICogRmlybXdhcmUgYXV0b21hdGljbHkgcHV0cyA4MDIgaGVhZGVyIG9uIHNvCisJICogRmlybXdhcmUgYXV0b21hdGljYWxseSBwdXRzIDgwMiBoZWFkZXIgb24gc28KIAkgKiB3ZSBkb24ndCBuZWVkIHRvIGFjY291bnQgZm9yIGl0IGluIHRoZSBsZW5ndGgKIAkgKi8KIAlpZiAodGVzdF9iaXQoRkxBR19NSUNfQ0FQQUJMRSwgJmFpLT5mbGFncykgJiYgYWktPm1pY3N0YXRzLmVuYWJsZWQgJiYKQEAgLTI1MzEsNyArMjUzMSw3IEBACiAvKgogICogV2UgYXJlIHNldHRpbmcgdXAgdGhyZWUgdGhpbmdzIGhlcmU6CiAgKiAxKSBNYXAgQVVYIG1lbW9yeSBmb3IgZGVzY3JpcHRvcnM6IFJpZCwgVHhGaWQsIG9yIFJ4RmlkLgotICogMikgTWFwIFBDSSBtZW1vcnkgZm9yIGlzc3VlaW5nIGNvbW1hbmRzLgorICogMikgTWFwIFBDSSBtZW1vcnkgZm9yIGlzc3VpbmcgY29tbWFuZHMuCiAgKiAzKSBBbGxvY2F0ZSBtZW1vcnkgKHNoYXJlZCkgdG8gc2VuZCBhbmQgcmVjZWl2ZSBldGhlcm5ldCBmcmFtZXMuCiAgKi8KIHN0YXRpYyBpbnQgbXBpX21hcF9jYXJkKHN0cnVjdCBhaXJvX2luZm8gKmFpLCBzdHJ1Y3QgcGNpX2RldiAqcGNpKQpAQCAtMzk0Nyw3ICszOTQ3LDcgQEAKIAogCWlmICggbWF4X3RyaWVzID09IC0xICkgewogCQlhaXJvX3ByaW50X2VycihhaS0+ZGV2LT5uYW1lLAotCQkJIk1heCB0cmllcyBleGNlZWRlZCB3aGVuIGlzc3VlaW5nIGNvbW1hbmQiKTsKKwkJCSJNYXggdHJpZXMgZXhjZWVkZWQgd2hlbiBpc3N1aW5nIGNvbW1hbmQiKTsKIAkJaWYgKElONDUwMChhaSwgQ09NTUFORCkgJiBDT01NQU5EX0JVU1kpCiAJCQlPVVQ0NTAwKGFpLCBFVkFDSywgRVZfQ0xFQVJDT01NQU5EQlVTWSk7CiAJCXJldHVybiBFUlJPUjsKQEAgLTQxNzMsNyArNDE3Myw3IEBACiB9CiAKIC8qICBOb3RlLCB0aGF0IHdlIGFyZSB1c2luZyBCQVAxIHdoaWNoIGlzIGFsc28gdXNlZCBieSB0cmFuc21pdCwgc28KLSAqICBtYWtlIHN1cmUgdGhpcyBpc250IGNhbGxlZCB3aGVuIGEgdHJhbnNtaXQgaXMgaGFwcGVuaW5nICovCisgKiAgbWFrZSBzdXJlIHRoaXMgaXNuJ3QgY2FsbGVkIHdoZW4gYSB0cmFuc21pdCBpcyBoYXBwZW5pbmcgKi8KIHN0YXRpYyBpbnQgUEM0NTAwX3dyaXRlcmlkKHN0cnVjdCBhaXJvX2luZm8gKmFpLCB1MTYgcmlkLAogCQkJICAgY29uc3Qgdm9pZCAqcEJ1ZiwgaW50IGxlbiwgaW50IGxvY2spCiB7CkBAIC00Nzc2LDcgKzQ3NzYsNyBAQAogCQlpZiAoIXN0YXRzTGFiZWxzW2ldKSBjb250aW51ZTsKIAkJaWYgKGorc3RybGVuKHN0YXRzTGFiZWxzW2ldKSsxNj40MDk2KSB7CiAJCQlhaXJvX3ByaW50X3dhcm4oYXByaXYtPmRldi0+bmFtZSwKLQkJCSAgICAgICAiUG90ZW50aWFsbHkgZGlzYXN0ZXJvdXMgYnVmZmVyIG92ZXJmbG93IGF2ZXJ0ZWQhIik7CisJCQkgICAgICAgIlBvdGVudGlhbGx5IGRpc2FzdHJvdXMgYnVmZmVyIG92ZXJmbG93IGF2ZXJ0ZWQhIik7CiAJCQlicmVhazsKIAkJfQogCQlqKz1zcHJpbnRmKGRhdGEtPnJidWZmZXIraiwgIiVzOiAldVxuIiwgc3RhdHNMYWJlbHNbaV0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXI5MTcwL21haW4uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hcjkxNzAvbWFpbi5jCmluZGV4IGI3NjFmZWMuLmNjYzJlZGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hcjkxNzAvbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hcjkxNzAvbWFpbi5jCkBAIC05NzQsNyArOTc0LDcgQEAKIAkJCWlmIChhci0+cnhfZmFpbG92ZXJfbWlzc2luZyA8PSAwKSB7CiAJCQkJLyoKIAkJCQkgKiBuZXN0ZWQgYXI5MTcwX3J4IGNhbGwhCi0JCQkJICogdGVybWluYXRpb24gaXMgZ3VyYW50ZWVkLCBldmVuIHdoZW4gdGhlCisJCQkJICogdGVybWluYXRpb24gaXMgZ3VhcmFudGVlZCwgZXZlbiB3aGVuIHRoZQogCQkJCSAqIGNvbWJpbmVkIGZyYW1lIGFsc28gaGF2ZSBhIGVsZW1lbnQgd2l0aAogCQkJCSAqIGEgYmFkIHRhZy4KIAkJCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hcjkxNzAvcGh5LmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXI5MTcwL3BoeS5jCmluZGV4IDBkYmZjZjcuLmFhOGQwNmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hcjkxNzAvcGh5LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2FyOTE3MC9waHkuYwpAQCAtNDI0LDcgKzQyNCw3IEBACiAKIC8qCiAgKiBpbml0aWFsaXplIHNvbWUgcGh5IHJlZ3MgZnJvbSBlZXByb20gdmFsdWVzIGluIG1vZGFsX2hlYWRlcltdCi0gKiBhY2MuIHRvIGJhbmQgYW5kIGJhbmR3aXRoCisgKiBhY2MuIHRvIGJhbmQgYW5kIGJhbmR3aWR0aAogICovCiBzdGF0aWMgaW50IGFyOTE3MF9pbml0X3BoeV9mcm9tX2VlcHJvbShzdHJ1Y3QgYXI5MTcwICphciwKIAkJCQlib29sIGlzXzJnaHosIGJvb2wgaXNfNDBtaHopCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvYW5pLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvYW5pLmgKaW5kZXggZDBhNjY0MC4uMDM0MDE1MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL2FuaS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9hbmkuaApAQCAtMjcsNyArMjcsNyBAQAogI2RlZmluZSBBVEg1S19BTklfUlNTSV9USFJfSElHSAkJNDAKICNkZWZpbmUgQVRINUtfQU5JX1JTU0lfVEhSX0xPVwkJNwogCi0vKiBtYXhpbXVtIGF2YWlsYWJlIGxldmVscyAqLworLyogbWF4aW11bSBhdmFpbGFibGUgbGV2ZWxzICovCiAjZGVmaW5lIEFUSDVLX0FOSV9NQVhfRklSU1RFUF9MVkwJMgogI2RlZmluZSBBVEg1S19BTklfTUFYX05PSVNFX0lNTV9MVkwJMQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvYmFzZS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL2Jhc2UuYwppbmRleCA0ZDdmMjFlLi4zNDlhNTk2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvYmFzZS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9iYXNlLmMKQEAgLTE5NTMsNyArMTk1Myw3IEBACiAKICNkZWZpbmUgRlVER0UgQVI1S19UVU5FX1NXX0JFQUNPTl9SRVNQICsgMwogCS8qIFdlIHVzZSBGVURHRSB0byBtYWtlIHN1cmUgdGhlIG5leHQgVEJUVCBpcyBhaGVhZCBvZiB0aGUgY3VycmVudCBUVS4KLQkgKiBTaW5jZSB3ZSBsYXRlciBzdWJzdHJhY3QgQVI1S19UVU5FX1NXX0JFQUNPTl9SRVNQICgxMCkgaW4gdGhlIHRpbWVyCisJICogU2luY2Ugd2UgbGF0ZXIgc3VidHJhY3QgQVI1S19UVU5FX1NXX0JFQUNPTl9SRVNQICgxMCkgaW4gdGhlIHRpbWVyCiAJICogY29uZmlndXJhdGlvbiB3ZSBuZWVkIHRvIG1ha2Ugc3VyZSBpdCBpcyBiaWdnZXIgdGhhbiB0aGF0LiAqLwogCiAJaWYgKGJjX3RzZiA9PSAtMSkgewpAQCAtMTk3MSw3ICsxOTcxLDcgQEAKIAkJaW50dmFsIHw9IEFSNUtfQkVBQ09OX1JFU0VUX1RTRjsKIAl9IGVsc2UgaWYgKGJjX3RzZiA+IGh3X3RzZikgewogCQkvKgotCQkgKiBiZWFjb24gcmVjZWl2ZWQsIFNXIG1lcmdlIGhhcHBlbmQgYnV0IEhXIFRTRiBub3QgeWV0IHVwZGF0ZWQuCisJCSAqIGJlYWNvbiByZWNlaXZlZCwgU1cgbWVyZ2UgaGFwcGVuZWQgYnV0IEhXIFRTRiBub3QgeWV0IHVwZGF0ZWQuCiAJCSAqIG5vdCBwb3NzaWJsZSB0byByZWNvbmZpZ3VyZSB0aW1lcnMgeWV0LCBidXQgbmV4dCB0aW1lIHdlCiAJCSAqIHJlY2VpdmUgYSBiZWFjb24gd2l0aCB0aGUgc2FtZSBCU1NJRCwgdGhlIGhhcmR3YXJlIHdpbGwKIAkJICogYXV0b21hdGljYWxseSB1cGRhdGUgdGhlIFRTRiBhbmQgdGhlbiB3ZSBuZWVkIHRvIHJlY29uZmlndXJlCkBAIC0yNjUxLDcgKzI2NTEsNyBAQAogCXN5bmNocm9uaXplX2lycShzYy0+aXJxKTsKIAlzdG9wX3Rhc2tsZXRzKHNjKTsKIAotCS8qIFNhdmUgYW5pIG1vZGUgYW5kIGRpc2FibGUgQU5JIGR1cnJpbmcKKwkvKiBTYXZlIGFuaSBtb2RlIGFuZCBkaXNhYmxlIEFOSSBkdXJpbmcKIAkgKiByZXNldC4gSWYgd2UgZG9uJ3Qgd2UgbWlnaHQgZ2V0IGZhbHNlCiAJICogUEhZIGVycm9yIGludGVycnVwdHMuICovCiAJYW5pX21vZGUgPSBhaC0+YWhfc2MtPmFuaV9zdGF0ZS5hbmlfbW9kZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9kZXNjLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvZGVzYy5jCmluZGV4IDE2YjQ0ZmYuLmE4ZmNjOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9kZXNjLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL2Rlc2MuYwpAQCAtNTEsNyArNTEsNyBAQAogCS8qCiAJICogVmFsaWRhdGUgaW5wdXQKIAkgKiAtIFplcm8gcmV0cmllcyBkb24ndCBtYWtlIHNlbnNlLgotCSAqIC0gQSB6ZXJvIHJhdGUgd2lsbCBwdXQgdGhlIEhXIGludG8gYSBtb2RlIHdoZXJlIGl0IGNvbnRpbm91c2x5IHNlbmRzCisJICogLSBBIHplcm8gcmF0ZSB3aWxsIHB1dCB0aGUgSFcgaW50byBhIG1vZGUgd2hlcmUgaXQgY29udGludW91c2x5IHNlbmRzCiAJICogICBub2lzZSBvbiB0aGUgY2hhbm5lbCwgc28gaXQgaXMgaW1wb3J0YW50IHRvIGF2b2lkIHRoaXMuCiAJICovCiAJaWYgKHVubGlrZWx5KHR4X3RyaWVzMCA9PSAwKSkgewpAQCAtMTkwLDcgKzE5MCw3IEBACiAJLyoKIAkgKiBWYWxpZGF0ZSBpbnB1dAogCSAqIC0gWmVybyByZXRyaWVzIGRvbid0IG1ha2Ugc2Vuc2UuCi0JICogLSBBIHplcm8gcmF0ZSB3aWxsIHB1dCB0aGUgSFcgaW50byBhIG1vZGUgd2hlcmUgaXQgY29udGlub3VzbHkgc2VuZHMKKwkgKiAtIEEgemVybyByYXRlIHdpbGwgcHV0IHRoZSBIVyBpbnRvIGEgbW9kZSB3aGVyZSBpdCBjb250aW51b3VzbHkgc2VuZHMKIAkgKiAgIG5vaXNlIG9uIHRoZSBjaGFubmVsLCBzbyBpdCBpcyBpbXBvcnRhbnQgdG8gYXZvaWQgdGhpcy4KIAkgKi8KIAlpZiAodW5saWtlbHkodHhfdHJpZXMwID09IDApKSB7CkBAIC0zMDAsNyArMzAwLDcgQEAKIAkvKgogCSAqIFJhdGVzIGNhbiBiZSAwIGFzIGxvbmcgYXMgdGhlIHJldHJ5IGNvdW50IGlzIDAgdG9vLgogCSAqIEEgemVybyByYXRlIGFuZCBub256ZXJvIHJldHJ5IGNvdW50IHdpbGwgcHV0IHRoZSBIVyBpbnRvIGEgbW9kZSB3aGVyZQotCSAqIGl0IGNvbnRpbm91c2x5IHNlbmRzIG5vaXNlIG9uIHRoZSBjaGFubmVsLCBzbyBpdCBpcyBpbXBvcnRhbnQgdG8KKwkgKiBpdCBjb250aW51b3VzbHkgc2VuZHMgbm9pc2Ugb24gdGhlIGNoYW5uZWwsIHNvIGl0IGlzIGltcG9ydGFudCB0bwogCSAqIGF2b2lkIHRoaXMuCiAJICovCiAJaWYgKHVubGlrZWx5KCh0eF9yYXRlMSA9PSAwICYmIHR4X3RyaWVzMSAhPSAwKSB8fApAQCAtMzQyLDcgKzM0Miw3IEBACiBcKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBQcm9jY2VzcyB0aGUgdHggc3RhdHVzIGRlc2NyaXB0b3Igb24gNTIxMC81MjExCisgKiBQcm9jZXNzIHRoZSB0eCBzdGF0dXMgZGVzY3JpcHRvciBvbiA1MjEwLzUyMTEKICAqLwogc3RhdGljIGludCBhdGg1a19od19wcm9jXzJ3b3JkX3R4X3N0YXR1cyhzdHJ1Y3QgYXRoNWtfaHcgKmFoLAogCQlzdHJ1Y3QgYXRoNWtfZGVzYyAqZGVzYywgc3RydWN0IGF0aDVrX3R4X3N0YXR1cyAqdHMpCkBAIC0zOTQsNyArMzk0LDcgQEAKIH0KIAogLyoKLSAqIFByb2NjZXNzIGEgdHggc3RhdHVzIGRlc2NyaXB0b3Igb24gNTIxMgorICogUHJvY2VzcyBhIHR4IHN0YXR1cyBkZXNjcmlwdG9yIG9uIDUyMTIKICAqLwogc3RhdGljIGludCBhdGg1a19od19wcm9jXzR3b3JkX3R4X3N0YXR1cyhzdHJ1Y3QgYXRoNWtfaHcgKmFoLAogCQlzdHJ1Y3QgYXRoNWtfZGVzYyAqZGVzYywgc3RydWN0IGF0aDVrX3R4X3N0YXR1cyAqdHMpCkBAIC01MTksNyArNTE5LDcgQEAKIH0KIAogLyoKLSAqIFByb2NjZXNzIHRoZSByeCBzdGF0dXMgZGVzY3JpcHRvciBvbiA1MjEwLzUyMTEKKyAqIFByb2Nlc3MgdGhlIHJ4IHN0YXR1cyBkZXNjcmlwdG9yIG9uIDUyMTAvNTIxMQogICovCiBzdGF0aWMgaW50IGF0aDVrX2h3X3Byb2NfNTIxMF9yeF9zdGF0dXMoc3RydWN0IGF0aDVrX2h3ICphaCwKIAkJc3RydWN0IGF0aDVrX2Rlc2MgKmRlc2MsIHN0cnVjdCBhdGg1a19yeF9zdGF0dXMgKnJzKQpAQCAtNjAyLDcgKzYwMiw3IEBACiB9CiAKIC8qCi0gKiBQcm9jY2VzcyB0aGUgcnggc3RhdHVzIGRlc2NyaXB0b3Igb24gNTIxMgorICogUHJvY2VzcyB0aGUgcnggc3RhdHVzIGRlc2NyaXB0b3Igb24gNTIxMgogICovCiBzdGF0aWMgaW50IGF0aDVrX2h3X3Byb2NfNTIxMl9yeF9zdGF0dXMoc3RydWN0IGF0aDVrX2h3ICphaCwKIAkJCQkJc3RydWN0IGF0aDVrX2Rlc2MgKmRlc2MsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvZWVwcm9tLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvZWVwcm9tLmMKaW5kZXggYjY1NjFmNy4uZWZiNjcyYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL2VlcHJvbS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9lZXByb20uYwpAQCAtMTA4MCw3ICsxMDgwLDcgQEAKICAqCiAgKiBUbyByZWNyZWF0ZSB0aGUgY3VydmVzIHdlIHJlYWQgaGVyZSB0aGUgcG9pbnRzIGFuZCBpbnRlcnBvbGF0ZQogICogbGF0ZXIuIE5vdGUgdGhhdCBpbiBtb3N0IGNhc2VzIG9ubHkgMiAoaGlnaGVyIGFuZCBsb3dlcikgY3VydmVzIGFyZQotICogdXNlZCAobGlrZSBSRjUxMTIpIGJ1dCB2ZW5kb3JzIGhhdmUgdGhlIG9wb3J0dW5pdHkgdG8gaW5jbHVkZSBhbGwKKyAqIHVzZWQgKGxpa2UgUkY1MTEyKSBidXQgdmVuZG9ycyBoYXZlIHRoZSBvcHBvcnR1bml0eSB0byBpbmNsdWRlIGFsbAogICogNCBjdXJ2ZXMgb24gZWVwcm9tLiBUaGUgZmluYWwgY3VydmUgKGhpZ2hlciBwb3dlcikgaGFzIGFuIGV4dHJhCiAgKiBwb2ludCBmb3IgYmV0dGVyIGFjY3VyYWN5IGxpa2UgUkY1MTEyLgogICovCkBAIC0xMzAyLDcgKzEzMDIsNyBAQAogCQkJLyoKIAkJCSAqIFBkIGdhaW4gMCBpcyBub3QgdGhlIGxhc3QgcGQgZ2FpbgogCQkJICogc28gaXQgb25seSBoYXMgMiBwZCBwb2ludHMuCi0JCQkgKiBDb250aW51ZSB3aWggcGQgZ2FpbiAxLgorCQkJICogQ29udGludWUgd2l0aCBwZCBnYWluIDEuCiAJCQkgKi8KIAkJCXBjaW5mby0+cHdyX2lbMV0gPSAodmFsID4+IDEwKSAmIDB4MWY7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9wY2kuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9wY2kuYwppbmRleCA2NjU5OGEwLi4zYzQ0Njg5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvcGNpLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3BjaS5jCkBAIC01Nyw3ICs1Nyw3IEBACiAJKmNzeiA9IChpbnQpdTh0bXA7CiAKIAkvKgotCSAqIFRoaXMgY2hlY2sgd2FzIHB1dCBpbiB0byBhdm9pZCAidW5wbGVzYW50IiBjb25zZXF1ZW5jZXMgaWYKKwkgKiBUaGlzIGNoZWNrIHdhcyBwdXQgaW4gdG8gYXZvaWQgInVucGxlYXNhbnQiIGNvbnNlcXVlbmNlcyBpZgogCSAqIHRoZSBib290cm9tIGhhcyBub3QgZnVsbHkgaW5pdGlhbGl6ZWQgYWxsIFBDSSBkZXZpY2VzLgogCSAqIFNvbWV0aW1lcyB0aGUgY2FjaGUgbGluZSBzaXplIHJlZ2lzdGVyIGlzIG5vdCBzZXQKIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9wY3UuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9wY3UuYwppbmRleCBhNzAyODE3Li5kOWIzZjgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvcGN1LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3BjdS5jCkBAIC00NzIsNyArNDcyLDcgQEAKIAl9CiAKIAkvKgotCSAqIFRoZSBBUjUyMTAgdXNlcyBwcm9taXNjb3VzIG1vZGUgdG8gZGV0ZWN0IHJhZGFyIGFjdGl2aXR5CisJICogVGhlIEFSNTIxMCB1c2VzIHByb21pc2N1b3VzIG1vZGUgdG8gZGV0ZWN0IHJhZGFyIGFjdGl2aXR5CiAJICovCiAJaWYgKGFoLT5haF92ZXJzaW9uID09IEFSNUtfQVI1MjEwICYmCiAJCQkoZmlsdGVyICYgQVI1S19SWF9GSUxURVJfUkFEQVJFUlIpKSB7CkBAIC03MDYsOCArNzA2LDggQEAKICAqIFRoZSBuZWVkIGZvciB0aGlzIGZ1bmN0aW9uIGFyaXNlcyBmcm9tIHRoZSBmYWN0IHRoYXQgd2UgaGF2ZSA0IHNlcGFyYXRlCiAgKiBIVyB0aW1lciByZWdpc3RlcnMgKFRJTUVSMCAtIFRJTUVSMyksIHdoaWNoIGFyZSBjbG9zZWx5IHJlbGF0ZWQgdG8gdGhlCiAgKiBuZXh0IGJlYWNvbiB0YXJnZXQgdGltZSAoTkJUVCksIGFuZCB0aGF0IHRoZSBIVyB1cGRhdGVzIHRoZXNlIHRpbWVycwotICogc2VwZXJhdGVseSBiYXNlZCBvbiB0aGUgY3VycmVudCBUU0YgdmFsdWUuIFRoZSBoYXJkd2FyZSBpbmNyZW1lbnRzIGVhY2gKLSAqIHRpbWVyIGJ5IHRoZSBiZWFjb24gaW50ZXJ2YWwsIHdoZW4gdGhlIGxvY2FsIFRTRiBjb3ZlcnRlZCB0byBUVSBpcyBlcXVhbAorICogc2VwYXJhdGVseSBiYXNlZCBvbiB0aGUgY3VycmVudCBUU0YgdmFsdWUuIFRoZSBoYXJkd2FyZSBpbmNyZW1lbnRzIGVhY2gKKyAqIHRpbWVyIGJ5IHRoZSBiZWFjb24gaW50ZXJ2YWwsIHdoZW4gdGhlIGxvY2FsIFRTRiBjb252ZXJ0ZWQgdG8gVFUgaXMgZXF1YWwKICAqIHRvIHRoZSB2YWx1ZSBzdG9yZWQgaW4gdGhlIHRpbWVyLgogICoKICAqIFRoZSByZWNlcHRpb24gb2YgYSBiZWFjb24gd2l0aCB0aGUgc2FtZSBCU1NJRCBjYW4gdXBkYXRlIHRoZSBsb2NhbCBIVyBUU0YKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9waHkuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9waHkuYwppbmRleCA2MmNlMmY0Li41NTQ0MTkxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvcGh5LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3BoeS5jCkBAIC0zMzUsMTEgKzMzNSwxMSBAQAogICogaHR0cDovL21hZHdpZmktcHJvamVjdC5vcmcvdGlja2V0LzE2NTkKICAqIHdpdGggdmFyaW91cyBtZWFzdXJlbWVudHMgYW5kIGRpYWdyYW1zCiAgKgotICogVE9ETzogRGVhbCB3aXRoIHBvd2VyIGRyb3BzIGR1ZSB0byBwcm9iZXMgYnkgc2V0dGluZyBhbiBhcHJvcHJpYXRlCisgKiBUT0RPOiBEZWFsIHdpdGggcG93ZXIgZHJvcHMgZHVlIHRvIHByb2JlcyBieSBzZXR0aW5nIGFuIGFwcHJvcHJpYXRlCiAgKiB0eCBwb3dlciBvbiB0aGUgcHJvYmUgcGFja2V0cyAhIE1ha2UgdGhpcyBwYXJ0IG9mIHRoZSBjYWxpYnJhdGlvbiBwcm9jZXNzLgogICovCiAKLS8qIEluaXRpYWxpemUgYWhfZ2FpbiBkdXJyaW5nIGF0dGFjaCAqLworLyogSW5pdGlhbGl6ZSBhaF9nYWluIGR1cmluZyBhdHRhY2ggKi8KIGludCBhdGg1a19od19yZmdhaW5fb3B0X2luaXQoc3RydWN0IGF0aDVrX2h3ICphaCkKIHsKIAkvKiBJbml0aWFsaXplIHRoZSBnYWluIG9wdGltaXphdGlvbiB2YWx1ZXMgKi8KQEAgLTEwNDksNyArMTA0OSw3IEBACiBcKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb252ZXJ0aW9uIG5lZWRlZCBmb3IgUkY1MTEwCisgKiBDb252ZXJzaW9uIG5lZWRlZCBmb3IgUkY1MTEwCiAgKi8KIHN0YXRpYyB1MzIgYXRoNWtfaHdfcmY1MTEwX2NoYW4yYXRoY2hhbihzdHJ1Y3QgaWVlZTgwMjExX2NoYW5uZWwgKmNoYW5uZWwpCiB7CkBAIC0xMDg4LDcgKzEwODgsNyBAQAogfQogCiAvKgotICogQ29udmVydGlvbiBuZWVkZWQgZm9yIDUxMTEKKyAqIENvbnZlcnNpb24gbmVlZGVkIGZvciA1MTExCiAgKi8KIHN0YXRpYyBpbnQgYXRoNWtfaHdfcmY1MTExX2NoYW4yYXRoY2hhbih1bnNpZ25lZCBpbnQgaWVlZSwKIAkJc3RydWN0IGF0aDVrX2F0aGNoYW5fMmdoeiAqYXRoY2hhbikKQEAgLTIyMDEsNyArMjIwMSw3IEBACiAvKgogICogR2V0IHRoZSBzdXJyb3VuZGluZyBwZXItY2hhbm5lbCBwb3dlciBjYWxpYnJhdGlvbiBwaWVycwogICogZm9yIGEgZ2l2ZW4gZnJlcXVlbmN5IHNvIHRoYXQgd2UgY2FuIGludGVycG9sYXRlIGJldHdlZW4KLSAqIHRoZW0gYW5kIGNvbWUgdXAgd2l0aCBhbiBhcHJvcHJpYXRlIGRhdGFzZXQgZm9yIG91ciBjdXJyZW50CisgKiB0aGVtIGFuZCBjb21lIHVwIHdpdGggYW4gYXBwcm9wcmlhdGUgZGF0YXNldCBmb3Igb3VyIGN1cnJlbnQKICAqIGNoYW5uZWwuCiAgKi8KIHN0YXRpYyB2b2lkCkBAIC0yNjE4LDcgKzI2MTgsNyBAQAogLyoKICAqIFNldCB0aGUgZ2FpbiBib3VuZGFyaWVzIGFuZCBjcmVhdGUgZmluYWwgUG93ZXIgdG8gUERBREMgdGFibGUKICAqCi0gKiBXZSBjYW4gaGF2ZSB1cCB0byA0IHBkIGN1cnZlcywgd2UgbmVlZCB0byBkbyBhIHNpbW1pbGFyIHByb2Nlc3MKKyAqIFdlIGNhbiBoYXZlIHVwIHRvIDQgcGQgY3VydmVzLCB3ZSBuZWVkIHRvIGRvIGEgc2ltaWxhciBwcm9jZXNzCiAgKiBhcyB3ZSBkbyBmb3IgUkY1MTEyLiBUaGlzIHRpbWUgd2UgZG9uJ3QgaGF2ZSBhbiBlZGdlX2ZsYWcgYnV0IHdlCiAgKiBzZXQgdGhlIGdhaW4gYm91bmRhcmllcyBvbiBhIHNlcGFyYXRlIHJlZ2lzdGVyLgogICovCkBAIC0yODI2LDEzICsyODI2LDEzIEBACiAJdTMyIHRhcmdldCA9IGNoYW5uZWwtPmNlbnRlcl9mcmVxOwogCWludCBwZGcsIGk7CiAKLQkvKiBHZXQgc3Vyb3VuZGluZyBmcmVxIHBpZXJzIGZvciB0aGlzIGNoYW5uZWwgKi8KKwkvKiBHZXQgc3Vycm91bmRpbmcgZnJlcSBwaWVycyBmb3IgdGhpcyBjaGFubmVsICovCiAJYXRoNWtfZ2V0X2NoYW5fcGNhbF9zdXJyb3VuZGluZ19waWVycyhhaCwgY2hhbm5lbCwKIAkJCQkJCSZwY2luZm9fTCwKIAkJCQkJCSZwY2luZm9fUik7CiAKIAkvKiBMb29wIG92ZXIgcGQgZ2FpbiBjdXJ2ZXMgb24KLQkgKiBzdXJvdW5kaW5nIGZyZXEgcGllcnMgYnkgaW5kZXggKi8KKwkgKiBzdXJyb3VuZGluZyBmcmVxIHBpZXJzIGJ5IGluZGV4ICovCiAJZm9yIChwZGcgPSAwOyBwZGcgPCBlZS0+ZWVfcGRfZ2FpbnNbZWVfbW9kZV07IHBkZysrKSB7CiAKIAkJLyogRmlsbCBjdXJ2ZXMgaW4gcmV2ZXJzZSBvcmRlcgpAQCAtMjkyMyw3ICsyOTIzLDcgQEAKIAkJfQogCiAJCS8qIEludGVycG9sYXRlIGJldHdlZW4gY3VydmVzCi0JCSAqIG9mIHN1cm91bmRpbmcgZnJlcSBwaWVycyB0bworCQkgKiBvZiBzdXJyb3VuZGluZyBmcmVxIHBpZXJzIHRvCiAJCSAqIGdldCB0aGUgZmluYWwgY3VydmUgZm9yIHRoaXMKIAkJICogcGQgZ2Fpbi4gUmUtdXNlIHRtcEwgZm9yIGludGVycG9sYXRpb24KIAkJICogb3V0cHV0ICovCkBAIC0yOTQ3LDcgKzI5NDcsNyBAQAogCiAJLyogRmlsbCBtaW4gYW5kIG1heCBwb3dlciBsZXZlbHMgZm9yIHRoaXMKIAkgKiBjaGFubmVsIGJ5IGludGVycG9sYXRpbmcgdGhlIHZhbHVlcyBvbgotCSAqIHN1cm91bmRpbmcgY2hhbm5lbHMgdG8gY29tcGxldGUgdGhlIGRhdGFzZXQgKi8KKwkgKiBzdXJyb3VuZGluZyBjaGFubmVscyB0byBjb21wbGV0ZSB0aGUgZGF0YXNldCAqLwogCWFoLT5haF90eHBvd2VyLnR4cF9taW5fcHdyID0gYXRoNWtfZ2V0X2ludGVycG9sYXRlZF92YWx1ZSh0YXJnZXQsCiAJCQkJCShzMTYpIHBjaW5mb19MLT5mcmVxLAogCQkJCQkoczE2KSBwY2luZm9fUi0+ZnJlcSwKQEAgLTMxNzksNyArMzE3OSw3IEBACiAKIAkvKiBGSVhNRTogVFBDIHNjYWxlIHJlZHVjdGlvbiAqLwogCi0JLyogR2V0IHN1cm91bmRpbmcgY2hhbm5lbHMgZm9yIHBlci1yYXRlIHBvd2VyIHRhYmxlCisJLyogR2V0IHN1cnJvdW5kaW5nIGNoYW5uZWxzIGZvciBwZXItcmF0ZSBwb3dlciB0YWJsZQogCSAqIGNhbGlicmF0aW9uICovCiAJYXRoNWtfZ2V0X3JhdGVfcGNhbF9kYXRhKGFoLCBjaGFubmVsLCAmcmF0ZV9pbmZvKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3JlZy5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3JlZy5oCmluZGV4IGUxYzlhYmQuLmQxMmI4MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9yZWcuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvcmVnLmgKQEAgLTEzMiw4ICsxMzIsOCBAQAogICogQXMgaSBjYW4gc2VlIGluIGFyNWtfYXI1MjEwX3R4X3N0YXJ0IFJleWsgdXNlcyBzb21lIG9mIHRoZSB2YWx1ZXMgb2YgQkNSCiAgKiBmb3IgdGhpcyByZWdpc3Rlciwgc28gaSBndWVzcyBUUTFWLFRRMUZWIGFuZCBCRE1BRSBoYXZlIHRoZSBzYW1lIG1lYW5pbmcKICAqIGhlcmUgYW5kIFNOUC9TTkFQIG1lYW5zICJzbmFwc2hvdCIgKHNvIHRoaXMgcmVnaXN0ZXIgZ2V0cyBzeW5jZWQgd2l0aCBCQ1IpLgotICogU28gU05BUFBFREJDUlZBTElEIHNvdWxkIGFsc28gc3RhbmQgZm9yICJzbmFwcGVkIEJDUiAtdmFsdWVzLSB2YWxpZCIsIHNvIGkKLSAqIHJlbmFtZWQgaXQgdG8gU05BUFNIT1RTVkFMSUQgdG8gbWFrZSBtb3JlIHNlbnNlLiBJIHJlYWx5IGhhdmUgbm8gaWRlYSB3aGF0CisgKiBTbyBTTkFQUEVEQkNSVkFMSUQgc2hvdWxkIGFsc28gc3RhbmQgZm9yICJzbmFwcGVkIEJDUiAtdmFsdWVzLSB2YWxpZCIsIHNvIGkKKyAqIHJlbmFtZWQgaXQgdG8gU05BUFNIT1RTVkFMSUQgdG8gbWFrZSBtb3JlIHNlbnNlLiBJIHJlYWxseSBoYXZlIG5vIGlkZWEgd2hhdAogICogZWxzZSBjYW4gaXQgYmUuIEkgYWxzbyByZW5hbWVkIFNOUEJDTUQgdG8gU05QQURIT0MgdG8gbWF0Y2ggQkNSLgogICovCiAjZGVmaW5lIEFSNUtfQlNSCQkweDAwMmMJCQkvKiBSZWdpc3RlciBBZGRyZXNzICovCkBAIC0yODMsNyArMjgzLDcgQEAKICAqLwogI2RlZmluZSBBUjVLX0lTUgkJMHgwMDFjCQkJLyogUmVnaXN0ZXIgQWRkcmVzcyBbNTIxMF0gKi8KICNkZWZpbmUgQVI1S19QSVNSCQkweDAwODAJCQkvKiBSZWdpc3RlciBBZGRyZXNzIFs1MjExK10gKi8KLSNkZWZpbmUgQVI1S19JU1JfUlhPSwkJMHgwMDAwMDAwMQkvKiBGcmFtZSBzdWNjZXNzZnVseSByZWNpZXZlZCAqLworI2RlZmluZSBBUjVLX0lTUl9SWE9LCQkweDAwMDAwMDAxCS8qIEZyYW1lIHN1Y2Nlc3NmdWx5IHJlY2VpdmVkICovCiAjZGVmaW5lIEFSNUtfSVNSX1JYREVTQwkJMHgwMDAwMDAwMgkvKiBSWCBkZXNjcmlwdG9yIHJlcXVlc3QgKi8KICNkZWZpbmUgQVI1S19JU1JfUlhFUlIJCTB4MDAwMDAwMDQJLyogUmVjZWl2ZSBlcnJvciAqLwogI2RlZmluZSBBUjVLX0lTUl9SWE5PRlJNCTB4MDAwMDAwMDgJLyogTm8gZnJhbWUgcmVjZWl2ZWQgKHJlY2VpdmUgdGltZW91dCkgKi8KQEAgLTM3MiwxMiArMzcyLDEyIEBACiAvKgogICogSW50ZXJydXB0IE1hc2sgUmVnaXN0ZXJzCiAgKgotICogQXMgd2hpdGggSVNScyA1MjEwIGhhcyBvbmUgSU1SIChBUjVLX0lNUikgYW5kIDUyMTEvNTIxMiBoYXMgb25lIHByaW1hcnkKKyAqIEFzIHdpdGggSVNScyA1MjEwIGhhcyBvbmUgSU1SIChBUjVLX0lNUikgYW5kIDUyMTEvNTIxMiBoYXMgb25lIHByaW1hcnkKICAqIChBUjVLX1BJTVIpIGFuZCA0IHNlY29uZGFyeSBJTVJzIChBUjVLX1NJTVJ4KS4gTm90ZSB0aGF0IElTUi9JTVIgZmxhZ3MgbWF0Y2guCiAgKi8KICNkZWZpbmUJQVI1S19JTVIJCTB4MDAyMAkJCS8qIFJlZ2lzdGVyIEFkZHJlc3MgWzUyMTBdICovCiAjZGVmaW5lIEFSNUtfUElNUgkJMHgwMGEwCQkJLyogUmVnaXN0ZXIgQWRkcmVzcyBbNTIxMStdICovCi0jZGVmaW5lIEFSNUtfSU1SX1JYT0sJCTB4MDAwMDAwMDEJLyogRnJhbWUgc3VjY2Vzc2Z1bHkgcmVjaWV2ZWQqLworI2RlZmluZSBBUjVLX0lNUl9SWE9LCQkweDAwMDAwMDAxCS8qIEZyYW1lIHN1Y2Nlc3NmdWx5IHJlY2VpdmVkKi8KICNkZWZpbmUgQVI1S19JTVJfUlhERVNDCQkweDAwMDAwMDAyCS8qIFJYIGRlc2NyaXB0b3IgcmVxdWVzdCovCiAjZGVmaW5lIEFSNUtfSU1SX1JYRVJSCQkweDAwMDAwMDA0CS8qIFJlY2VpdmUgZXJyb3IqLwogI2RlZmluZSBBUjVLX0lNUl9SWE5PRlJNCTB4MDAwMDAwMDgJLyogTm8gZnJhbWUgcmVjZWl2ZWQgKHJlY2VpdmUgdGltZW91dCkqLwpAQCAtODk1LDcgKzg5NSw3IEBACiAjZGVmaW5lIEFSNUtfUENJQ0ZHX1NMX0lOVEVOCQkweDAwMDAwODAwCS8qIEVuYWJsZSBpbnRlcnJ1cHRzIHdoZW4gYXNsZWVwICovCiAjZGVmaW5lIEFSNUtfUENJQ0ZHX0xFRF9CQ1RMCQkweDAwMDAxMDAwCS8qIExlZCBibGluayAoPykgWzUyMTBdICovCiAjZGVmaW5lIEFSNUtfUENJQ0ZHX1JFVFJZX0ZJWAkJMHgwMDAwMTAwMAkvKiBFbmFibGUgcGNpIGNvcmUgcmV0cnkgZml4ICovCi0jZGVmaW5lIEFSNUtfUENJQ0ZHX1NMX0lOUEVOCQkweDAwMDAyMDAwCS8qIFNsZWVwIGV2ZW4gd2hpdGggcGVuZGluZyBpbnRlcnJ1cHRzKi8KKyNkZWZpbmUgQVI1S19QQ0lDRkdfU0xfSU5QRU4JCTB4MDAwMDIwMDAJLyogU2xlZXAgZXZlbiB3aXRoIHBlbmRpbmcgaW50ZXJydXB0cyovCiAjZGVmaW5lIEFSNUtfUENJQ0ZHX1NQV1JfRE4JCTB4MDAwMTAwMDAJLyogTWFzayBmb3IgcG93ZXIgc3RhdHVzICovCiAjZGVmaW5lIEFSNUtfUENJQ0ZHX0xFRE1PREUJCTB4MDAwZTAwMDAJLyogTGVkbW9kZSBbNTIxMStdICovCiAjZGVmaW5lIEFSNUtfUENJQ0ZHX0xFRE1PREVfUFJPUAkweDAwMDAwMDAwCS8qIEJsaW5rIG9uIHN0YW5kYXJkIHRyYWZmaWMgWzUyMTErXSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyNTAwOF9waHkuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjUwMDhfcGh5LmMKaW5kZXggZmZjZjQ0YS4uMTA2YzBiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyNTAwOF9waHkuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI1MDA4X3BoeS5jCkBAIC0xNDIsNyArMTQyLDcgQEAKIAogLyoqCiAgKiBhcjUwMDhfaHdfc2V0X2NoYW5uZWwgLSB0dW5lIHRvIGEgY2hhbm5lbCBvbiB0aGUgZXh0ZXJuYWwgQVIyMTMzL0FSNTEzMyByYWRpb3MKLSAqIEBhaDogYXRoZXJvcyBoYXJkd2FyZSBzdHVjdHVyZQorICogQGFoOiBhdGhlcm9zIGhhcmR3YXJlIHN0cnVjdHVyZQogICogQGNoYW46CiAgKgogICogRm9yIHRoZSBleHRlcm5hbCBBUjIxMzMvQVI1MTMzIHJhZGlvcywgdGFrZXMgdGhlIE1IeiBjaGFubmVsIHZhbHVlIGFuZCBzZXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDNfZWVwcm9tLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAzX2VlcHJvbS5jCmluZGV4IDRhOTI3MTguLjZlYWRmOTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDNfZWVwcm9tLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyOTAwM19lZXByb20uYwpAQCAtMzI0MCw3ICszMjQwLDcgQEAKIAkJCWVlcCA9IGFyOTAwM19lZXByb21fc3RydWN0X2ZpbmRfYnlfaWQocmVmZXJlbmNlKTsKIAkJCWlmIChlZXAgPT0gTlVMTCkgewogCQkJCWF0aF9kYmcoY29tbW9uLCBBVEhfREJHX0VFUFJPTSwKLQkJCQkJImNhbnQgZmluZCByZWZlcmVuY2UgZWVwcm9tIHN0cnVjdCAlZFxuIiwKKwkJCQkJImNhbid0IGZpbmQgcmVmZXJlbmNlIGVlcHJvbSBzdHJ1Y3QgJWRcbiIsCiAJCQkJCXJlZmVyZW5jZSk7CiAJCQkJcmV0dXJuIC0xOwogCQkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Y19oc3QuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGNfaHN0LmMKaW5kZXggYzQxYWI4Yy4uNjJlMTM5YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Y19oc3QuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHRjX2hzdC5jCkBAIC0zNjAsNyArMzYwLDcgQEAKICAqIEhUQyBNZXNzYWdlcyBhcmUgaGFuZGxlZCBkaXJlY3RseSBoZXJlIGFuZCB0aGUgb2J0YWluZWQgU0tCCiAgKiBpcyBmcmVlZC4KICAqCi0gKiBTZXZpY2UgbWVzc2FnZXMgKERhdGEsIFdNSSkgcGFzc2VkIHRvIHRoZSBjb3JyZXNwb25kaW5nCisgKiBTZXJ2aWNlIG1lc3NhZ2VzIChEYXRhLCBXTUkpIHBhc3NlZCB0byB0aGUgY29ycmVzcG9uZGluZwogICogZW5kcG9pbnQgUlggaGFuZGxlcnMsIHdoaWNoIGhhdmUgdG8gZnJlZSB0aGUgU0tCLgogICovCiB2b2lkIGF0aDlrX2h0Y19yeF9tc2coc3RydWN0IGh0Y190YXJnZXQgKmh0Y19oYW5kbGUsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHcuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5jCmluZGV4IDMzOGIwNzUuLjFlYzliY2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5jCkBAIC0yNTQ2LDYgKzI1NDYsNyBAQAogCXsgQVJfU1JFVl9WRVJTSU9OXzkyODcsICAgICAgICAgIjkyODciIH0sCiAJeyBBUl9TUkVWX1ZFUlNJT05fOTI3MSwgICAgICAgICAiOTI3MSIgfSwKIAl7IEFSX1NSRVZfVkVSU0lPTl85MzAwLCAgICAgICAgICI5MzAwIiB9LAorCXsgQVJfU1JFVl9WRVJTSU9OXzk0ODUsICAgICAgICAgIjk0ODUiIH0sCiB9OwogCiAvKiBGb3IgZGV2aWNlcyB3aXRoIGV4dGVybmFsIHJhZGlvcyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL3BjaS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL3BjaS5jCmluZGV4IGU4MzEyOGMuLjljNjU0NTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9wY2kuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvcGNpLmMKQEAgLTQ0LDcgKzQ0LDcgQEAKIAkqY3N6ID0gKGludCl1OHRtcDsKIAogCS8qCi0JICogVGhpcyBjaGVjayB3YXMgcHV0IGluIHRvIGF2b2lkICJ1bnBsZXNhbnQiIGNvbnNlcXVlbmNlcyBpZgorCSAqIFRoaXMgY2hlY2sgd2FzIHB1dCBpbiB0byBhdm9pZCAidW5wbGVhc2FudCIgY29uc2VxdWVuY2VzIGlmCiAJICogdGhlIGJvb3Ryb20gaGFzIG5vdCBmdWxseSBpbml0aWFsaXplZCBhbGwgUENJIGRldmljZXMuCiAJICogU29tZXRpbWVzIHRoZSBjYWNoZSBsaW5lIHNpemUgcmVnaXN0ZXIgaXMgbm90IHNldAogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL3JjLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvcmMuYwppbmRleCBhMzI0MWNkLi40YzBkMzZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvcmMuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvcmMuYwpAQCAtNzkyLDcgKzc5Miw3IEBACiAKIAkJdHhfaW5mby0+ZmxhZ3MgfD0gSUVFRTgwMjExX1RYX0NUTF9SQVRFX0NUUkxfUFJPQkU7CiAJfSBlbHNlIHsKLQkJLyogU2V0IHRoZSBjaG9vc2VuIHJhdGUuIE5vIFJUUyBmb3IgZmlyc3Qgc2VyaWVzIGVudHJ5LiAqLworCQkvKiBTZXQgdGhlIGNob3NlbiByYXRlLiBObyBSVFMgZm9yIGZpcnN0IHNlcmllcyBlbnRyeS4gKi8KIAkJYXRoX3JjX3JhdGVfc2V0X3NlcmllcyhyYXRlX3RhYmxlLCAmcmF0ZXNbaSsrXSwgdHhyYywKIAkJCQkgICAgICAgdHJ5X3Blcl9yYXRlLCByaXgsIDApOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay94bWl0LmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsveG1pdC5jCmluZGV4IDI2NzM0ZTUuLjg4ZmE3ZmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay94bWl0LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL3htaXQuYwpAQCAtNjI4LDggKzYyOCw4IEBACiAJCQkJICh1MzIpQVRIX0FNUERVX0xJTUlUX01BWCk7CiAKIAkvKgotCSAqIGgvdyBjYW4gYWNjZXB0IGFnZ3JlZ2F0ZXMgdXB0byAxNiBiaXQgbGVuZ3RocyAoNjU1MzUpLgotCSAqIFRoZSBJRSwgaG93ZXZlciBjYW4gaG9sZCB1cHRvIDY1NTM2LCB3aGljaCBzaG93cyB1cCBoZXJlCisJICogaC93IGNhbiBhY2NlcHQgYWdncmVnYXRlcyB1cCB0byAxNiBiaXQgbGVuZ3RocyAoNjU1MzUpLgorCSAqIFRoZSBJRSwgaG93ZXZlciBjYW4gaG9sZCB1cCB0byA2NTUzNiwgd2hpY2ggc2hvd3MgdXAgaGVyZQogCSAqIGFzIHplcm8uIElnbm9yZSA2NTUzNiBzaW5jZSB3ZSAgYXJlIGNvbnN0cmFpbmVkIGJ5IGh3LgogCSAqLwogCWlmICh0aWQtPmFuLT5tYXhhbXBkdSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC9jYXJsOTE3MC5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL2Nhcmw5MTcwLmgKaW5kZXggOWNhZDA2MS4uM2Q0ZWQ1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL2Nhcmw5MTcwLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL2Nhcmw5MTcwLmgKQEAgLTE2MSw3ICsxNjEsNyBAQAogICogTmF0dXJhbGx5OiBUaGUgaGlnaGVyIHRoZSBsaW1pdCwgdGhlIGZhc3RlciB0aGUgZGV2aWNlIENBTiBzZW5kLgogICogSG93ZXZlciwgZXZlbiBhIHNsaWdodCBvdmVyLWNvbW1pdG1lbnQgYXQgdGhlIHdyb25nIHRpbWUgYW5kIHRoZQogICogaGFyZHdhcmUgaXMgZG9vbWVkIHRvIHNlbmQgYWxsIGFscmVhZHktcXVldWVkIGZyYW1lcyBhdCBzdWJvcHRpbWFsCi0gKiByYXRlcy4gVGhpcyBpbiB0dXJuIGxlYWRzIHRvIGFuIGVub3VybW91cyBhbW91bnQgb2YgdW5zdWNjZXNzZnVsCisgKiByYXRlcy4gVGhpcyBpbiB0dXJuIGxlYWRzIHRvIGFuIGVub3Jtb3VzIGFtb3VudCBvZiB1bnN1Y2Nlc3NmdWwKICAqIHJldHJpZXMgPT4gTGF0ZW5jeSBnb2VzIHVwLCB3aGVyZWFzIHRoZSB0aHJvdWdocHV0IGdvZXMgZG93bi4gQ1JBU0ghCiAgKi8KICNkZWZpbmUgQ0FSTDkxNzBfTlVNX1RYX0xJTUlUX0hBUkQJKChBUjkxNzBfVFhRX0RFUFRIICogMykgLyAyKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3BoeS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3BoeS5jCmluZGV4IGI2YjBkZTYuLmI2YWUwZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC9waHkuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvY2FybDkxNzAvcGh5LmMKQEAgLTQyNyw3ICs0MjcsNyBAQAogCiAvKgogICogaW5pdGlhbGl6ZSBzb21lIHBoeSByZWdzIGZyb20gZWVwcm9tIHZhbHVlcyBpbiBtb2RhbF9oZWFkZXJbXQotICogYWNjLiB0byBiYW5kIGFuZCBiYW5kd2l0aAorICogYWNjLiB0byBiYW5kIGFuZCBiYW5kd2lkdGgKICAqLwogc3RhdGljIGludCBjYXJsOTE3MF9pbml0X3BoeV9mcm9tX2VlcHJvbShzdHJ1Y3QgYXI5MTcwICphciwKIAkJCQlib29sIGlzXzJnaHosIGJvb2wgaXNfNDBtaHopCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvY2FybDkxNzAvcnguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC9yeC5jCmluZGV4IDg0ODY2YTQuLmVjMjFlYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC9yeC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC9yeC5jCkBAIC04NDksNyArODQ5LDcgQEAKIAkJCQkvKgogCQkJCSAqIG5lc3RlZCBjYXJsOTE3MF9yeF9zdHJlYW0gY2FsbCEKIAkJCQkgKgotCQkJCSAqIHRlcm1pbmF0aW9uIGlzIGd1cmFudGVlZCwgZXZlbiB3aGVuIHRoZQorCQkJCSAqIHRlcm1pbmF0aW9uIGlzIGd1YXJhbnRlZWQsIGV2ZW4gd2hlbiB0aGUKIAkJCQkgKiBjb21iaW5lZCBmcmFtZSBhbHNvIGhhdmUgYW4gZWxlbWVudCB3aXRoCiAJCQkJICogYSBiYWQgdGFnLgogCQkJCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3VzYi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3VzYi5jCmluZGV4IGY4MmM0MDAuLjJmYjUzZDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC91c2IuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvY2FybDkxNzAvdXNiLmMKQEAgLTQzMCw3ICs0MzAsNyBAQAogCQkJICogVGhlIHN5c3RlbSBpcyB0b28gc2xvdyB0byBjb3BlIHdpdGgKIAkJCSAqIHRoZSBlbm9ybW91cyB3b3JrbG9hZC4gV2UgaGF2ZSBzaW1wbHkKIAkJCSAqIHJ1biBvdXQgb2YgYWN0aXZlIHJ4IHVyYnMgYW5kIHRoaXMKLQkJCSAqIHVuZm9ydHVuYXRseSBsZWFkcyB0byBhbiB1bnByZWRpY3RhYmxlCisJCQkgKiB1bmZvcnR1bmF0ZWx5IGxlYWRzIHRvIGFuIHVucHJlZGljdGFibGUKIAkJCSAqIGRldmljZS4KIAkJCSAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvaHcuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9ody5jCmluZGV4IDE4M2MyODIuLmNjMTFkNjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9ody5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9ody5jCkBAIC04Niw3ICs4Niw3IEBACiAgKiBJRlJBTUUtMDE6ICAwMTEwCiAgKgogICogQW4gZWFzeSBleWUtaW5zcGVjaXRvbiBvZiB0aGlzIGFscmVhZHkgc2hvdWxkIHRlbGwgeW91IHRoYXQgdGhpcyBmcmFtZQotICogd2lsbCBub3QgcGFzcyBvdXIgY2hlY2suIFRoaXMgaXMgYmVhY3VzZSB0aGUgYnNzaWRfbWFzayB0ZWxscyB0aGUKKyAqIHdpbGwgbm90IHBhc3Mgb3VyIGNoZWNrLiBUaGlzIGlzIGJlY2F1c2UgdGhlIGJzc2lkX21hc2sgdGVsbHMgdGhlCiAgKiBoYXJkd2FyZSB0byBvbmx5IGxvb2sgYXQgdGhlIHNlY29uZCBsZWFzdCBzaWduaWZpY2FudCBiaXQgYW5kIHRoZQogICogY29tbW9uIGJpdCBhbW9uZ3N0IHRoZSBNQUMgYW5kIEJTU0lEcyBpcyAwLCB0aGlzIGZyYW1lIGhhcyB0aGUgMm5kIExTQgogICogYXMgMSwgd2hpY2ggZG9lcyBub3QgbWF0Y2ggMC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9yZWdkLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvcmVnZC5jCmluZGV4IGY4MjhmMjkuLjBlMWI4NzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9yZWdkLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL3JlZ2QuYwpAQCAtMjY4LDcgKzI2OCw3IEBACiAJfQogCiAJLyoKLQkgKiBJZiBhIGNvdW50cnkgSUUgaGFzIGJlZW4gcmVjaWV2ZWQgY2hlY2sgaXRzIHJ1bGUgZm9yIHRoaXMKKwkgKiBJZiBhIGNvdW50cnkgSUUgaGFzIGJlZW4gcmVjZWl2ZWQgY2hlY2sgaXRzIHJ1bGUgZm9yIHRoaXMKIAkgKiBjaGFubmVsIGZpcnN0IGJlZm9yZSBlbmFibGluZyBhY3RpdmUgc2Nhbi4gVGhlIHBhc3NpdmUgc2NhbgogCSAqIHdvdWxkIGhhdmUgYmVlbiBlbmZvcmNlZCBieSB0aGUgaW5pdGlhbCBwcm9jZXNzaW5nIG9mIG91cgogCSAqIGN1c3RvbSByZWd1bGF0b3J5IGRvbWFpbi4KQEAgLTQ3Niw3ICs0NzYsNyBAQAogCQl3aXBoeS0+ZmxhZ3MgfD0gV0lQSFlfRkxBR19DVVNUT01fUkVHVUxBVE9SWTsKIAl9IGVsc2UgewogCQkvKgotCQkgKiBUaGlzIGdldHMgYXBwbGllZCBpbiB0aGUgY2FzZSBvZiB0aGUgYWJzZW5zZSBvZiBDUkRBLAorCQkgKiBUaGlzIGdldHMgYXBwbGllZCBpbiB0aGUgY2FzZSBvZiB0aGUgYWJzZW5jZSBvZiBDUkRBLAogCQkgKiBpdCdzIG91ciBvd24gY3VzdG9tIHdvcmxkIHJlZ3VsYXRvcnkgZG9tYWluLCBzaW1pbGFyIHRvCiAJCSAqIGNmZzgwMjExJ3MgYnV0IHdlIGVuYWJsZSBwYXNzaXZlIHNjYW5uaW5nLgogCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0bWVsLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdG1lbC5jCmluZGV4IDQ2ZTM4MmUuLjM5YTExZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0bWVsLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRtZWwuYwpAQCAtNDM5LDcgKzQzOSw3IEBACiB9OwogCiBzdHJ1Y3QgYXRtZWxfcHJpdmF0ZSB7Ci0Jdm9pZCAqY2FyZDsgLyogQnVzIGRlcGVuZGVudCBzdHVjdHVyZSB2YXJpZXMgZm9yIFBDY2FyZCAqLworCXZvaWQgKmNhcmQ7IC8qIEJ1cyBkZXBlbmRlbnQgc3RydWN0dXJlIHZhcmllcyBmb3IgUENjYXJkICovCiAJaW50ICgqcHJlc2VudF9jYWxsYmFjaykodm9pZCAqKTsgLyogQW5kIGNhbGxiYWNrIHdoaWNoIHVzZXMgaXQgKi8KIAljaGFyIGZpcm13YXJlX2lkWzMyXTsKIAlBdG1lbEZXVHlwZSBmaXJtd2FyZV90eXBlOwpAQCAtMzg5NSw3ICszODk1LDcgQEAKIAogCSAgIFRoaXMgcm91dGluZSBpcyBhbHNvIHJlc3BvbnNpYmxlIGZvciBpbml0aWFsaXNpbmcgc29tZQogCSAgIGhhcmR3YXJlLXNwZWNpZmljIGZpZWxkcyBpbiB0aGUgYXRtZWxfcHJpdmF0ZSBzdHJ1Y3R1cmUsCi0JICAgaW5jbHVkaW5nIGEgY29weSBvZiB0aGUgZmlybXdhcmUncyBob3N0aW5mbyBzdHVjdHVyZQorCSAgIGluY2x1ZGluZyBhIGNvcHkgb2YgdGhlIGZpcm13YXJlJ3MgaG9zdGluZm8gc3RydWN0dXJlCiAJICAgd2hpY2ggaXMgdGhlIHJvdXRlIGludG8gdGhlIHJlc3Qgb2YgdGhlIGZpcm13YXJlIGRhdGFzdHJ1Y3R1cmVzLiAqLwogCiAJc3RydWN0IGF0bWVsX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRtZWxfY3MuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0bWVsX2NzLmMKaW5kZXggYzk2ZTE5ZC4uMDUyNjM1MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRtZWxfY3MuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdG1lbF9jcy5jCkBAIC05OSw3ICs5OSw3IEBACiB9CiAKIC8qIENhbGwtYmFjayBmdW5jdGlvbiB0byBpbnRlcnJvZ2F0ZSBQQ01DSUEtc3BlY2lmaWMgaW5mb3JtYXRpb24KLSAgIGFib3V0IHRoZSBjdXJyZW50IGV4aXN0YW5jZSBvZiB0aGUgY2FyZCAqLworICAgYWJvdXQgdGhlIGN1cnJlbnQgZXhpc3RlbmNlIG9mIHRoZSBjYXJkICovCiBzdGF0aWMgaW50IGNhcmRfcHJlc2VudCh2b2lkICphcmcpCiB7CiAJc3RydWN0IHBjbWNpYV9kZXZpY2UgKmxpbmsgPSAoc3RydWN0IHBjbWNpYV9kZXZpY2UgKilhcmc7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvYjQzLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvYjQzLmgKaW5kZXggYmQ0Y2I3NS4uMjI5ZjQzOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2I0My5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9iNDMuaApAQCAtNjQ4LDcgKzY0OCw3IEBACiAJY2hhciBlcnJvcnNbQjQzX05SX0ZXVFlQRVNdWzEyOF07CiAJLyogVGVtcG9yYXJ5IGJ1ZmZlciBmb3Igc3RvcmluZyB0aGUgZmlybXdhcmUgbmFtZS4gKi8KIAljaGFyIGZ3bmFtZVs2NF07Ci0JLyogQSBmYXRhbCBlcnJvciBvY2N1cmVkIHdoaWxlIHJlcXVlc3RpbmcuIEZpcm13YXJlIHJlcWVzdAorCS8qIEEgZmF0YWwgZXJyb3Igb2NjdXJyZWQgd2hpbGUgcmVxdWVzdGluZy4gRmlybXdhcmUgcmVxZXN0CiAJICogY2FuIG5vdCBjb250aW51ZSwgYXMgYW55IG90aGVyIHJlcWVzdCB3aWxsIGFsc28gZmFpbC4gKi8KIAlpbnQgZmF0YWxfZmFpbHVyZTsKIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvZG1hLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvZG1hLmMKaW5kZXggM2Q1NTY2ZS4uZmYwZjViYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2RtYS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9kbWEuYwpAQCAtMTUzNiw3ICsxNTM2LDcgQEAKIAkJZG1hYWRkciA9IG1ldGEtPmRtYWFkZHI7CiAJCWdvdG8gZHJvcF9yZWN5Y2xlX2J1ZmZlcjsKIAl9Ci0JaWYgKHVubGlrZWx5KGxlbiA+IHJpbmctPnJ4X2J1ZmZlcnNpemUpKSB7CisJaWYgKHVubGlrZWx5KGxlbiArIHJpbmctPmZyYW1lb2Zmc2V0ID4gcmluZy0+cnhfYnVmZmVyc2l6ZSkpIHsKIAkJLyogVGhlIGRhdGEgZGlkIG5vdCBmaXQgaW50byBvbmUgZGVzY3JpcHRvciBidWZmZXIKIAkJICogYW5kIGlzIHNwbGl0IG92ZXIgbXVsdGlwbGUgYnVmZmVycy4KIAkJICogVGhpcyBzaG91bGQgbmV2ZXIgaGFwcGVuLCBhcyB3ZSB0cnkgdG8gYWxsb2NhdGUgYnVmZmVycwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2RtYS5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2RtYS5oCmluZGV4IGEwMWMyMTAuLmU4YTgwYTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9kbWEuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvZG1hLmgKQEAgLTE2Myw3ICsxNjMsNyBAQAogLyogRE1BIGVuZ2luZSB0dW5pbmcga25vYnMgKi8KICNkZWZpbmUgQjQzX1RYUklOR19TTE9UUwkJMjU2CiAjZGVmaW5lIEI0M19SWFJJTkdfU0xPVFMJCTY0Ci0jZGVmaW5lIEI0M19ETUEwX1JYX0JVRkZFUlNJWkUJCUlFRUU4MDIxMV9NQVhfRlJBTUVfTEVOCisjZGVmaW5lIEI0M19ETUEwX1JYX0JVRkZFUlNJWkUJCShCNDNfRE1BMF9SWF9GUkFNRU9GRlNFVCArIElFRUU4MDIxMV9NQVhfRlJBTUVfTEVOKQogCiAvKiBQb2ludGVyIHBvaXNvbiAqLwogI2RlZmluZSBCNDNfRE1BX1BUUl9QT0lTT04JCSgodm9pZCAqKUVSUl9QVFIoLUVOT01FTSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvbWFpbi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL21haW4uYwppbmRleCA1N2ViNWI2Li5kNTliMDE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9tYWluLmMKQEAgLTQwMTAsNyArNDAxMCw3IEBACiAJYjQzX21hY19lbmFibGUoZGV2KTsKIAliNDNfd3JpdGUzMihkZXYsIEI0M19NTUlPX0dFTl9JUlFfTUFTSywgZGV2LT5pcnFfbWFzayk7CiAKLQkvKiBTdGFydCBtYWludGFpbmFuY2Ugd29yayAqLworCS8qIFN0YXJ0IG1haW50ZW5hbmNlIHdvcmsgKi8KIAliNDNfcGVyaW9kaWNfdGFza3Nfc2V0dXAoZGV2KTsKIAogCWI0M19sZWRzX2luaXQoZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9waHlfZy5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3BoeV9nLmgKaW5kZXggODU2OWZkZC4uNTQxM2M5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3BoeV9nLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3BoeV9nLmgKQEAgLTE2NCw3ICsxNjQsNyBAQAogCS8qIEN1cnJlbnQgSW50ZXJmZXJlbmNlIE1pdGlnYXRpb24gbW9kZSAqLwogCWludCBpbnRlcmZtb2RlOwogCS8qIFN0YWNrIG9mIHNhdmVkIHZhbHVlcyBmcm9tIHRoZSBJbnRlcmZlcmVuY2UgTWl0aWdhdGlvbiBjb2RlLgotCSAqIEVhY2ggdmFsdWUgaW4gdGhlIHN0YWNrIGlzIGxheWVkIG91dCBhcyBmb2xsb3dzOgorCSAqIEVhY2ggdmFsdWUgaW4gdGhlIHN0YWNrIGlzIGxhaWQgb3V0IGFzIGZvbGxvd3M6CiAJICogYml0IDAtMTE6ICBvZmZzZXQKIAkgKiBiaXQgMTItMTU6IHJlZ2lzdGVyIElECiAJICogYml0IDE2LTMyOiB2YWx1ZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3BoeV9uLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvcGh5X24uaAppbmRleCAwMDFlODQxLi5lNzg5YTg5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvcGh5X24uaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvcGh5X24uaApAQCAtNzAzLDcgKzcwMyw3IEBACiAjZGVmaW5lIEI0M19OUEhZX0NIQU5fRVNUSEFORwkJCUI0M19QSFlfTigweDIxRCkgLyogQ2hhbm5lbCBlc3RpbWF0ZSBoYW5nICovCiAjZGVmaW5lIEI0M19OUEhZX0ZJTkVSWDJfQ0dDCQkJQjQzX1BIWV9OKDB4MjIxKSAvKiBGaW5lIFJYIDIgY2xvY2sgZ2F0ZSBjb250cm9sICovCiAjZGVmaW5lICBCNDNfTlBIWV9GSU5FUlgyX0NHQ19ERUNHQwkJMHgwMDA4IC8qIERlY29kZSBnYXRlZCBjbG9ja3MgKi8KLSNkZWZpbmUgQjQzX05QSFlfVFhQQ1RMX0lOSVQJCQlCNDNfUEhZX04oMHgyMjIpIC8qIFRYIHBvd2VyIGNvbnRyb2xsIGluaXQgKi8KKyNkZWZpbmUgQjQzX05QSFlfVFhQQ1RMX0lOSVQJCQlCNDNfUEhZX04oMHgyMjIpIC8qIFRYIHBvd2VyIGNvbnRyb2wgaW5pdCAqLwogI2RlZmluZSAgQjQzX05QSFlfVFhQQ1RMX0lOSVRfUElEWEkxCQkweDAwRkYgLyogUG93ZXIgaW5kZXggaW5pdCAxICovCiAjZGVmaW5lICBCNDNfTlBIWV9UWFBDVExfSU5JVF9QSURYSTFfU0hJRlQJMAogI2RlZmluZSBCNDNfTlBIWV9QQVBEX0VOMAkJCUI0M19QSFlfTigweDI5NykgLyogUEFQRCBFbmFibGUwIFRCRCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzbGVnYWN5L2I0M2xlZ2FjeS5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzbGVnYWN5L2I0M2xlZ2FjeS5oCmluZGV4IGM4MWIyZjUuLjIzNTgzYmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0M2xlZ2FjeS9iNDNsZWdhY3kuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDNsZWdhY3kvYjQzbGVnYWN5LmgKQEAgLTQ4OCw3ICs0ODgsNyBAQAogCS8qIEN1cnJlbnQgSW50ZXJmZXJlbmNlIE1pdGlnYXRpb24gbW9kZSAqLwogCWludCBpbnRlcmZtb2RlOwogCS8qIFN0YWNrIG9mIHNhdmVkIHZhbHVlcyBmcm9tIHRoZSBJbnRlcmZlcmVuY2UgTWl0aWdhdGlvbiBjb2RlLgotCSAqIEVhY2ggdmFsdWUgaW4gdGhlIHN0YWNrIGlzIGxheWVkIG91dCBhcyBmb2xsb3dzOgorCSAqIEVhY2ggdmFsdWUgaW4gdGhlIHN0YWNrIGlzIGxhaWQgb3V0IGFzIGZvbGxvd3M6CiAJICogYml0IDAtMTE6ICBvZmZzZXQKIAkgKiBiaXQgMTItMTU6IHJlZ2lzdGVyIElECiAJICogYml0IDE2LTMyOiB2YWx1ZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9hcC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9hcC5jCmluZGV4IDE4ZDYzZjUuLjNkMDVkYzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfYXAuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2FwLmMKQEAgLTIzNTksNyArMjM1OSw3IEBACiB9CiAKIAotLyogVHJhbnNsYXRlIG91ciBsaXN0IG9mIEFjY2VzcyBQb2ludHMgJiBTdGF0aW9ucyB0byBhIGNhcmQgaW5kZXBlbmRhbnQKKy8qIFRyYW5zbGF0ZSBvdXIgbGlzdCBvZiBBY2Nlc3MgUG9pbnRzICYgU3RhdGlvbnMgdG8gYSBjYXJkIGluZGVwZW5kZW50CiAgKiBmb3JtYXQgdGhhdCB0aGUgV2lyZWxlc3MgVG9vbHMgd2lsbCB1bmRlcnN0YW5kIC0gSmVhbiBJSSAqLwogaW50IHByaXNtMl9hcF90cmFuc2xhdGVfc2NhbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAogCQkJICAgICBzdHJ1Y3QgaXdfcmVxdWVzdF9pbmZvICppbmZvLCBjaGFyICpidWZmZXIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2FwLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2FwLmgKaW5kZXggNjU1Y2VlYi4uMzM0ZTJkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9hcC5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfYXAuaApAQCAtMTE0LDcgKzExNCw3IEBACiAgKiBoYXMgcGFzc2VkIHNpbmNlIGxhc3QgcmVjZWl2ZWQgZnJhbWUgZnJvbSB0aGUgc3RhdGlvbiwgYSBudWxsZnVuYyBkYXRhCiAgKiBmcmFtZSBpcyBzZW50IHRvIHRoZSBzdGF0aW9uLiBJZiB0aGlzIGZyYW1lIGlzIG5vdCBhY2tub3dsZWRnZWQgYW5kIG5vIG90aGVyCiAgKiBmcmFtZXMgaGF2ZSBiZWVuIHJlY2VpdmVkLCB0aGUgc3RhdGlvbiB3aWxsIGJlIGRpc2Fzc29jaWF0ZWQgYWZ0ZXIKLSAqIEFQX0RJU0FTU09DX0RFTEFZLiBTaW1pbGFyaWx5LCBhIHRoZSBzdGF0aW9uIHdpbGwgYmUgZGVhdXRoZW50aWNhdGVkIGFmdGVyCisgKiBBUF9ESVNBU1NPQ19ERUxBWS4gU2ltaWxhcmx5LCBhIHRoZSBzdGF0aW9uIHdpbGwgYmUgZGVhdXRoZW50aWNhdGVkIGFmdGVyCiAgKiBBUF9ERUFVVEhfREVMQVkuIEFQX1RJTUVPVVRfUkVTT0xVVElPTiBpcyB0aGUgcmVzb2x1dGlvbiB0aGF0IGlzIHVzZWQgd2l0aAogICogbWF4IGluYWN0aXZpdHkgdGltZXIuICovCiAjZGVmaW5lIEFQX01BWF9JTkFDVElWSVRZX1NFQyAoNSAqIDYwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9pb2N0bC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9pb2N0bC5jCmluZGV4IDYwMzg2MzMuLjEyZGU0NjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfaW9jdGwuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2lvY3RsLmMKQEAgLTE5NDUsNyArMTk0NSw3IEBACiB9CiAKIAotLyogVHJhbnNsYXRlIHNjYW4gZGF0YSByZXR1cm5lZCBmcm9tIHRoZSBjYXJkIHRvIGEgY2FyZCBpbmRlcGVuZGFudAorLyogVHJhbnNsYXRlIHNjYW4gZGF0YSByZXR1cm5lZCBmcm9tIHRoZSBjYXJkIHRvIGEgY2FyZCBpbmRlcGVuZGVudAogICogZm9ybWF0IHRoYXQgdGhlIFdpcmVsZXNzIFRvb2xzIHdpbGwgdW5kZXJzdGFuZCAtIEplYW4gSUkgKi8KIHN0YXRpYyBpbmxpbmUgaW50IHByaXNtMl90cmFuc2xhdGVfc2Nhbihsb2NhbF9pbmZvX3QgKmxvY2FsLAogCQkJCQlzdHJ1Y3QgaXdfcmVxdWVzdF9pbmZvICppbmZvLApAQCAtMjA0Myw3ICsyMDQzLDcgQEAKIAkJICogdW50aWwgcmVzdWx0cyBhcmUgcmVhZHkgZm9yIHZhcmlvdXMgcmVhc29ucy4KIAkJICogRmlyc3QsIG1hbmFnaW5nIHdhaXQgcXVldWVzIGlzIGNvbXBsZXggYW5kIHJhY3kKIAkJICogKHRoZXJlIG1heSBiZSBtdWx0aXBsZSBzaW11bHRhbmVvdXMgY2FsbGVycykuCi0JCSAqIFNlY29uZCwgd2UgZ3JhYiBzb21lIHJ0bmV0bGluayBsb2NrIGJlZm9yZSBjb21taW5nCisJCSAqIFNlY29uZCwgd2UgZ3JhYiBzb21lIHJ0bmV0bGluayBsb2NrIGJlZm9yZSBjb21pbmcKIAkJICogaGVyZSAoaW4gZGV2X2lvY3RsKCkpLgogCQkgKiBUaGlyZCwgdGhlIGNhbGxlciBjYW4gd2FpdCBvbiB0aGUgV2lyZWxlc3MgRXZlbnQKIAkJICogLSBKZWFuIElJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX3dsYW4uaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfd2xhbi5oCmluZGV4IDFjNjZiM2MuLjg4ZGM2YTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfd2xhbi5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfd2xhbi5oCkBAIC04NTMsNyArODUzLDcgQEAKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3QgY29tbXNfcXVhbF91cGRhdGU7CiAKIAkvKiBSU1NJIHRvIGRCbSBhZGp1c3RtZW50IChmb3IgUlggZGVzY3JpcHRvciBmaWVsZHMpICovCi0JaW50IHJzc2lfdG9fZEJtOyAvKiBzdWJzdHJhY3QgZnJvbSBSU1NJIHRvIGdldCBhcHByb3hpbWF0ZSBkQm0gdmFsdWUgKi8KKwlpbnQgcnNzaV90b19kQm07IC8qIHN1YnRyYWN0IGZyb20gUlNTSSB0byBnZXQgYXBwcm94aW1hdGUgZEJtIHZhbHVlICovCiAKIAkvKiBCU1MgbGlzdCAvIHByb3RlY3RlZCBieSBsb2NhbC0+bG9jayAqLwogCXN0cnVjdCBsaXN0X2hlYWQgYnNzX2xpc3Q7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pcHcyeDAwL2lwdzIxMDAuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2lwdzJ4MDAvaXB3MjEwMC5jCmluZGV4IDRiOTdmOTEuLjQ0MzA3NzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2lwdzJ4MDAvaXB3MjEwMC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2lwdzJ4MDAvaXB3MjEwMC5jCkBAIC02Myw3ICs2Myw3IEBACiBmaXJtd2FyZSBpZiBhIENvbW1hbmQgb3IgRGF0YSBpcyBiZWluZyBzZW50LiAgSWYgaXQgaXMgQ29tbWFuZCwgYWxsIG9mIHRoZQogY29tbWFuZCBpbmZvcm1hdGlvbiBpcyBjb250YWluZWQgd2l0aGluIHRoZSBwaHlzaWNhbCBhZGRyZXNzIHJlZmVycmVkIHRvIGJ5IHRoZQogVEJELiAgSWYgaXQgaXMgRGF0YSwgdGhlIGZpcnN0IFRCRCBpbmRpY2F0ZXMgdGhlIHR5cGUgb2YgZGF0YSBwYWNrZXQsIG51bWJlcgotb2YgZnJhZ21lbnRzLCBldGMuICBUaGUgbmV4dCBUQkQgdGhlbiByZWZlcnJzIHRvIHRoZSBhY3R1YWwgcGFja2V0IGxvY2F0aW9uLgorb2YgZnJhZ21lbnRzLCBldGMuICBUaGUgbmV4dCBUQkQgdGhlbiByZWZlcnMgdG8gdGhlIGFjdHVhbCBwYWNrZXQgbG9jYXRpb24uCiAKIFRoZSBUeCBmbG93IGN5Y2xlIGlzIGFzIGZvbGxvd3M6CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2lwdzJ4MDAvaXB3MjIwMC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMKaW5kZXggMTYwODgxZi4uNDJjM2ZlMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMKQEAgLTExODEsNyArMTE4MSw3IEBACiAvKgogICogVGhlIGZvbGxvd2luZyBhZGRzIGEgbmV3IGF0dHJpYnV0ZSB0byB0aGUgc3lzZnMgcmVwcmVzZW50YXRpb24KICAqIG9mIHRoaXMgZGV2aWNlIGRyaXZlciAoaS5lLiBhIG5ldyBmaWxlIGluIC9zeXMvYnVzL3BjaS9kcml2ZXJzL2lwdy8pCi0gKiB1c2VkIGZvciBjb250cm9saW5nIHRoZSBkZWJ1ZyBsZXZlbC4KKyAqIHVzZWQgZm9yIGNvbnRyb2xsaW5nIHRoZSBkZWJ1ZyBsZXZlbC4KICAqCiAgKiBTZWUgdGhlIGxldmVsIGRlZmluaXRpb25zIGluIGlwdyBmb3IgZGV0YWlscy4KICAqLwpAQCAtMzc2Myw3ICszNzYzLDcgQEAKIAogCXEtPnR4YiA9IGttYWxsb2Moc2l6ZW9mKHEtPnR4YlswXSkgKiBjb3VudCwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFxLT50eGIpIHsKLQkJSVBXX0VSUk9SKCJ2bWFsbG9jIGZvciBhdXhpbGFyeSBCRCBzdHJ1Y3R1cmVzIGZhaWxlZFxuIik7CisJCUlQV19FUlJPUigidm1hbGxvYyBmb3IgYXV4aWxpYXJ5IEJEIHN0cnVjdHVyZXMgZmFpbGVkXG4iKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCkBAIC01NTgxLDcgKzU1ODEsNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQkvKiBWZXJpZnkgcHJpdmFjeSBjb21wYXRhYmlsaXR5ICovCisJLyogVmVyaWZ5IHByaXZhY3kgY29tcGF0aWJpbGl0eSAqLwogCWlmICgoKHByaXYtPmNhcGFiaWxpdHkgJiBDQVBfUFJJVkFDWV9PTikgPyAxIDogMCkgIT0KIAkgICAgKChuZXR3b3JrLT5jYXBhYmlsaXR5ICYgV0xBTl9DQVBBQklMSVRZX1BSSVZBQ1kpID8gMSA6IDApKSB7CiAJCUlQV19ERUJVR19NRVJHRSgiTmV0d29yayAnJXMgKCVwTSknIGV4Y2x1ZGVkICIKQEAgLTU4MDgsNyArNTgwOCw3IEBACiAJCXJldHVybiAwOwogCX0KIAotCS8qIFZlcmlmeSBwcml2YWN5IGNvbXBhdGFiaWxpdHkgKi8KKwkvKiBWZXJpZnkgcHJpdmFjeSBjb21wYXRpYmlsaXR5ICovCiAJaWYgKCgocHJpdi0+Y2FwYWJpbGl0eSAmIENBUF9QUklWQUNZX09OKSA/IDEgOiAwKSAhPQogCSAgICAoKG5ldHdvcmstPmNhcGFiaWxpdHkgJiBXTEFOX0NBUEFCSUxJVFlfUFJJVkFDWSkgPyAxIDogMCkpIHsKIAkJSVBXX0RFQlVHX0FTU09DKCJOZXR3b3JrICclcyAoJXBNKScgZXhjbHVkZWQgIgpAQCAtODE4NCw3ICs4MTg0LDcgQEAKIHN0YXRpYyBpbnQgaXNfbmV0d29ya19wYWNrZXQoc3RydWN0IGlwd19wcml2ICpwcml2LAogCQkJCSAgICBzdHJ1Y3QgbGliaXB3X2hkcl80YWRkciAqaGVhZGVyKQogewotCS8qIEZpbHRlciBpbmNvbWluZyBwYWNrZXRzIHRvIGRldGVybWluZSBpZiB0aGV5IGFyZSB0YXJnZXR0ZWQgdG93YXJkCisJLyogRmlsdGVyIGluY29taW5nIHBhY2tldHMgdG8gZGV0ZXJtaW5lIGlmIHRoZXkgYXJlIHRhcmdldGVkIHRvd2FyZAogCSAqIHRoaXMgbmV0d29yaywgZGlzY2FyZGluZyBwYWNrZXRzIGNvbWluZyBmcm9tIG91cnNlbHZlcyAqLwogCXN3aXRjaCAocHJpdi0+aWVlZS0+aXdfbW9kZSkgewogCWNhc2UgSVdfTU9ERV9BREhPQzoJLyogSGVhZGVyOiBEZXN0LiB8IFNvdXJjZSAgICB8IEJTU0lEICovCkBAIC04MzQwLDkgKzgzNDAsOSBAQAogfQogCiAvKgotICogTWFpbiBlbnRyeSBmdW5jdGlvbiBmb3IgcmVjaWV2aW5nIGEgcGFja2V0IHdpdGggODAyMTEgaGVhZGVycy4gIFRoaXMKKyAqIE1haW4gZW50cnkgZnVuY3Rpb24gZm9yIHJlY2VpdmluZyBhIHBhY2tldCB3aXRoIDgwMjExIGhlYWRlcnMuICBUaGlzCiAgKiBzaG91bGQgYmUgY2FsbGVkIHdoZW4gZXZlciB0aGUgRlcgaGFzIG5vdGlmaWVkIHVzIHRoYXQgdGhlcmUgaXMgYSBuZXcKLSAqIHNrYiBpbiB0aGUgcmVjaWV2ZSBxdWV1ZS4KKyAqIHNrYiBpbiB0aGUgcmVjZWl2ZSBxdWV1ZS4KICAqLwogc3RhdGljIHZvaWQgaXB3X3J4KHN0cnVjdCBpcHdfcHJpdiAqcHJpdikKIHsKQEAgLTg2ODMsNyArODY4Myw3IEBACiAgKiBmdW5jdGlvbnMgZGVmaW5lZCBpbiBpcHdfbWFpbiB0byBwcm92aWRlIHRoZSBIVyBpbnRlcmFjdGlvbi4KICAqCiAgKiBUaGUgZXhjZXB0aW9uIHRvIHRoaXMgaXMgdGhlIHVzZSBvZiB0aGUgaXB3X2dldF9vcmRpbmFsKCkKLSAqIGZ1bmN0aW9uIHVzZWQgdG8gcG9sbCB0aGUgaGFyZHdhcmUgdnMuIG1ha2luZyB1bmVjZXNzYXJ5IGNhbGxzLgorICogZnVuY3Rpb24gdXNlZCB0byBwb2xsIHRoZSBoYXJkd2FyZSB2cy4gbWFraW5nIHVubmVjZXNzYXJ5IGNhbGxzLgogICoKICAqLwogCkBAIC0xMDQxOSw3ICsxMDQxOSw3IEBACiAKIAltZW1zZXQoJmR1bW15c3RhdHMsIDAsIHNpemVvZihkdW1teXN0YXRzKSk7CiAKLQkvKiBGaWx0ZXJpbmcgb2YgZnJhZ21lbnQgY2hhaW5zIGlzIGRvbmUgYWdhaW5zIHRoZSBmaXJzdCBmcmFnbWVudCAqLworCS8qIEZpbHRlcmluZyBvZiBmcmFnbWVudCBjaGFpbnMgaXMgZG9uZSBhZ2FpbnN0IHRoZSBmaXJzdCBmcmFnbWVudCAqLwogCWhkciA9ICh2b2lkICopdHhiLT5mcmFnbWVudHNbMF0tPmRhdGE7CiAJaWYgKGxpYmlwd19pc19tYW5hZ2VtZW50KGxlMTZfdG9fY3B1KGhkci0+ZnJhbWVfY29udHJvbCkpKSB7CiAJCWlmIChmaWx0ZXIgJiBJUFdfUFJPTV9OT19NR01UKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9saWJpcHdfcnguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2lwdzJ4MDAvbGliaXB3X3J4LmMKaW5kZXggMGRlMWIxOC4uZTVhZDc2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9saWJpcHdfcnguYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pcHcyeDAwL2xpYmlwd19yeC5jCkBAIC05MjUsNyArOTI1LDcgQEAKIHN0YXRpYyB1OCBxb3Nfb3VpW1FPU19PVUlfTEVOXSA9IHsgMHgwMCwgMHg1MCwgMHhGMiB9OwogCiAvKgotKiBNYWtlIHRoZXIgc3RydWN0dXJlIHdlIHJlYWQgZnJvbSB0aGUgYmVhY29uIHBhY2tldCBoYXMKKyogTWFrZSB0aGUgc3RydWN0dXJlIHdlIHJlYWQgZnJvbSB0aGUgYmVhY29uIHBhY2tldCB0byBoYXZlCiAqIHRoZSByaWdodCB2YWx1ZXMKICovCiBzdGF0aWMgaW50IGxpYmlwd192ZXJpZnlfcW9zX2luZm8oc3RydWN0IGxpYmlwd19xb3NfaW5mb3JtYXRpb25fZWxlbWVudApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsZWdhY3kvaXdsLWNvcmUuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bGVnYWN5L2l3bC1jb3JlLmMKaW5kZXggYTIwOWEwZS4uNzAwN2Q2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsZWdhY3kvaXdsLWNvcmUuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2xlZ2FjeS9pd2wtY29yZS5jCkBAIC0xMDMwLDcgKzEwMzAsNyBAQAogCS8qCiAJICogRW5hYmxlIEhBUCBJTlRBIChpbnRlcnJ1cHQgZnJvbSBtYW5hZ2VtZW50IGJ1cykgdG8KIAkgKiB3YWtlIGRldmljZSdzIFBDSSBFeHByZXNzIGxpbmsgTDFhIC0+IEwwcwotCSAqIE5PVEU6ICBUaGlzIGlzIG5vLW9wIGZvciAzOTQ1IChub24tZXhpc3RhbnQgYml0KQorCSAqIE5PVEU6ICBUaGlzIGlzIG5vLW9wIGZvciAzOTQ1IChub24tZXhpc3RlbnQgYml0KQogCSAqLwogCWl3bF9sZWdhY3lfc2V0X2JpdChwcml2LCBDU1JfSFdfSUZfQ09ORklHX1JFRywKIAkJCQkgICAgQ1NSX0hXX0lGX0NPTkZJR19SRUdfQklUX0hBUF9XQUtFX0wxQSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2xlZ2FjeS9pd2wtZmguaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bGVnYWN5L2l3bC1maC5oCmluZGV4IDRlMjBjN2UuLjZlNjA5MTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bGVnYWN5L2l3bC1maC5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bGVnYWN5L2l3bC1maC5oCkBAIC00MzYsNyArNDM2LDcgQEAKICAqIEBmaW5pc2hlZF9yYl9udW0gWzA6MTFdIC0gSW5kaWNhdGVzIHRoZSBpbmRleCBvZiB0aGUgY3VycmVudCBSQgogICogCWluIHdoaWNoIHRoZSBsYXN0IGZyYW1lIHdhcyB3cml0dGVuIHRvCiAgKiBAZmluaXNoZWRfZnJfbnVtIFswOjExXSAtIEluZGljYXRlcyB0aGUgaW5kZXggb2YgdGhlIFJYIEZyYW1lCi0gKiAJd2hpY2ggd2FzIHRyYW5zZmVyZWQKKyAqIAl3aGljaCB3YXMgdHJhbnNmZXJyZWQKICAqLwogc3RydWN0IGl3bF9yYl9zdGF0dXMgewogCV9fbGUxNiBjbG9zZWRfcmJfbnVtOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsZWdhY3kvaXdsLXNjYW4uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bGVnYWN5L2l3bC1zY2FuLmMKaW5kZXggNjBmNTk3Zi4uMzUzMjM0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsZWdhY3kvaXdsLXNjYW4uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2xlZ2FjeS9pd2wtc2Nhbi5jCkBAIC0xNDMsNyArMTQzLDcgQEAKIAkJSVdMX0RFQlVHX1NDQU4ocHJpdiwgIlNlbmQgc2NhbiBhYm9ydCBmYWlsZWQgJWRcbiIsIHJldCk7CiAJCWl3bF9sZWdhY3lfZm9yY2Vfc2Nhbl9lbmQocHJpdik7CiAJfSBlbHNlCi0JCUlXTF9ERUJVR19TQ0FOKHByaXYsICJTdWNlc3NmdWxseSBzZW5kIHNjYW4gYWJvcnRcbiIpOworCQlJV0xfREVCVUdfU0NBTihwcml2LCAiU3VjY2Vzc2Z1bGx5IHNlbmQgc2NhbiBhYm9ydFxuIik7CiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsZWdhY3kvaXdsLXN0YS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsZWdhY3kvaXdsLXN0YS5jCmluZGV4IDQ3YzlkYTMuLjY2ZjBmYjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bGVnYWN5L2l3bC1zdGEuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2xlZ2FjeS9pd2wtc3RhLmMKQEAgLTExMCw3ICsxMTAsNyBAQAogCS8qCiAJICogWFhYOiBUaGUgTUFDIGFkZHJlc3MgaW4gdGhlIGNvbW1hbmQgYnVmZmVyIGlzIG9mdGVuIGNoYW5nZWQgZnJvbQogCSAqIHRoZSBvcmlnaW5hbCBzZW50IHRvIHRoZSBkZXZpY2UuIFRoYXQgaXMsIHRoZSBNQUMgYWRkcmVzcwotCSAqIHdyaXR0ZW4gdG8gdGhlIGNvbW1hbmQgYnVmZmVyIG9mdGVuIGlzIG5vdCB0aGUgc2FtZSBNQUMgYWRyZXNzCisJICogd3JpdHRlbiB0byB0aGUgY29tbWFuZCBidWZmZXIgb2Z0ZW4gaXMgbm90IHRoZSBzYW1lIE1BQyBhZGRyZXNzCiAJICogcmVhZCBmcm9tIHRoZSBjb21tYW5kIGJ1ZmZlciB3aGVuIHRoZSBjb21tYW5kIHJldHVybnMuIFRoaXMKIAkgKiBpc3N1ZSBoYXMgbm90IHlldCBiZWVuIHJlc29sdmVkIGFuZCB0aGlzIGRlYnVnZ2luZyBpcyBsZWZ0IHRvCiAJICogb2JzZXJ2ZSB0aGUgcHJvYmxlbS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWFnbi1pY3QuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWFnbi1pY3QuYwppbmRleCBiNWNiM2JlLi5lZDAxNDhkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1hZ24taWN0LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLWljdC5jCkBAIC02OSw3ICs2OSw3IEBACiAJaWYgKCFwcml2LT5fYWduLmljdF90YmxfdmlyKQogCQlyZXR1cm4gLUVOT01FTTsKIAotCS8qIGFsaWduIHRhYmxlIHRvIFBBR0VfU0laRSBib3VuZHJ5ICovCisJLyogYWxpZ24gdGFibGUgdG8gUEFHRV9TSVpFIGJvdW5kYXJ5ICovCiAJcHJpdi0+X2Fnbi5hbGlnbmVkX2ljdF90YmxfZG1hID0gQUxJR04ocHJpdi0+X2Fnbi5pY3RfdGJsX2RtYSwgUEFHRV9TSVpFKTsKIAogCUlXTF9ERUJVR19JU1IocHJpdiwgImljdCBkbWEgYWRkciAlTHggZG1hIGFsaWduZWQgJUx4IGRpZmYgJWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1jb3JlLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1jb3JlLmMKaW5kZXggNmMzMGZhNi4uYmFmYmU1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtY29yZS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWNvcmUuYwpAQCAtMTA0MCw3ICsxMDQwLDcgQEAKIAkvKgogCSAqIEVuYWJsZSBIQVAgSU5UQSAoaW50ZXJydXB0IGZyb20gbWFuYWdlbWVudCBidXMpIHRvCiAJICogd2FrZSBkZXZpY2UncyBQQ0kgRXhwcmVzcyBsaW5rIEwxYSAtPiBMMHMKLQkgKiBOT1RFOiAgVGhpcyBpcyBuby1vcCBmb3IgMzk0NSAobm9uLWV4aXN0YW50IGJpdCkKKwkgKiBOT1RFOiAgVGhpcyBpcyBuby1vcCBmb3IgMzk0NSAobm9uLWV4aXN0ZW50IGJpdCkKIAkgKi8KIAlpd2xfc2V0X2JpdChwcml2LCBDU1JfSFdfSUZfQ09ORklHX1JFRywKIAkJCQkgICAgQ1NSX0hXX0lGX0NPTkZJR19SRUdfQklUX0hBUF9XQUtFX0wxQSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1lZXByb20uaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5oCmluZGV4IDk4YWE4YWYuLjIwYjY2NDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5oCkBAIC0yNDEsNyArMjQxLDcgQEAKIAogLyogNngwMCBTcGVjaWZpYyAqLwogI2RlZmluZSBFRVBST01fNjAwMF9UWF9QT1dFUl9WRVJTSU9OICAgICg0KQotI2RlZmluZSBFRVBST01fNjAwMF9FRVBST01fVkVSU0lPTgkoMHg0MzQpCisjZGVmaW5lIEVFUFJPTV82MDAwX0VFUFJPTV9WRVJTSU9OCSgweDQyMykKIAogLyogNng1MCBTcGVjaWZpYyAqLwogI2RlZmluZSBFRVBST01fNjA1MF9UWF9QT1dFUl9WRVJTSU9OICAgICg0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtZmguaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWZoLmgKaW5kZXggNTViODM3MC4uNDc0MDA5YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtZmguaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1maC5oCkBAIC00MzYsNyArNDM2LDcgQEAKICAqIEBmaW5pc2hlZF9yYl9udW0gWzA6MTFdIC0gSW5kaWNhdGVzIHRoZSBpbmRleCBvZiB0aGUgY3VycmVudCBSQgogICogCWluIHdoaWNoIHRoZSBsYXN0IGZyYW1lIHdhcyB3cml0dGVuIHRvCiAgKiBAZmluaXNoZWRfZnJfbnVtIFswOjExXSAtIEluZGljYXRlcyB0aGUgaW5kZXggb2YgdGhlIFJYIEZyYW1lCi0gKiAJd2hpY2ggd2FzIHRyYW5zZmVyZWQKKyAqIAl3aGljaCB3YXMgdHJhbnNmZXJyZWQKICAqLwogc3RydWN0IGl3bF9yYl9zdGF0dXMgewogCV9fbGUxNiBjbG9zZWRfcmJfbnVtOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtc2Nhbi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtc2Nhbi5jCmluZGV4IDNhNGQ5ZTYuLjkxNGM3N2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLXNjYW4uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1zY2FuLmMKQEAgLTE0Myw3ICsxNDMsNyBAQAogCQlJV0xfREVCVUdfU0NBTihwcml2LCAiU2VuZCBzY2FuIGFib3J0IGZhaWxlZCAlZFxuIiwgcmV0KTsKIAkJaXdsX2ZvcmNlX3NjYW5fZW5kKHByaXYpOwogCX0gZWxzZQotCQlJV0xfREVCVUdfU0NBTihwcml2LCAiU3VjZXNzZnVsbHkgc2VuZCBzY2FuIGFib3J0XG4iKTsKKwkJSVdMX0RFQlVHX1NDQU4ocHJpdiwgIlN1Y2Nlc3NmdWxseSBzZW5kIHNjYW4gYWJvcnRcbiIpOwogfQogCiAvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9oYWwuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9oYWwuYwppbmRleCA5MDdhYzg5Li4xY2FiY2IzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd21jMzIwMHdpZmkvaGFsLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL2hhbC5jCkBAIC01Nyw3ICs1Nyw3IEBACiAgKiAgIFRoaXMgaXMgZHVlIHRvIHRoZSBmYWN0IHRoZSBob3N0IHRhbGtzIGV4Y2x1c2l2ZWx5CiAgKiAgIHRvIHRoZSBVTUFDIGFuZCBzbyB0aGVyZSBuZWVkcyB0byBiZSBhIHNwZWNpYWwgVU1BQwogICogICBjb21tYW5kIGZvciB0YWxraW5nIHRvIHRoZSBMTUFDLgotICogICBUaGlzIGlzIGhvdyBhIHdpZmkgY29tbWFuZCBpcyBsYXllZCBvdXQ6CisgKiAgIFRoaXMgaXMgaG93IGEgd2lmaSBjb21tYW5kIGlzIGxhaWQgb3V0OgogICogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiAgIHwgaXdtX3VkbWFfb3V0X3dpZmlfaGRyICB8CiAgKiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTcyLDcgKzcyLDcgQEAKICAqICAgVGhvc2UgY29tbWFuZHMgYXJlIGhhbmRsZWQgYnkgdGhlIGRldmljZSdzIGJvb3Ryb20sCiAgKiAgIGFuZCBhcmUgdHlwaWNhbGx5IHNlbnQgd2hlbiB0aGUgVU1BQyBhbmQgdGhlIExNQUMKICAqICAgYXJlIG5vdCB5ZXQgYXZhaWxhYmxlLgotICogICAgKiAgIFRoaXMgaXMgaG93IGEgbm9uLXdpZmkgY29tbWFuZCBpcyBsYXllZCBvdXQ6CisgKiAgICAqICAgVGhpcyBpcyBob3cgYSBub24td2lmaSBjb21tYW5kIGlzIGxhaWQgb3V0OgogICogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiAgIHwgaXdtX3VkbWFfb3V0X25vbndpZmlfaGRyICB8CiAgKiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS90eC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL3R4LmMKaW5kZXggMzIxNjYyMS4uYmU5ODA3NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL3R4LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL3R4LmMKQEAgLTE5Nyw3ICsxOTcsNyBAQAogCXNwaW5fbG9jaygmaXdtLT50eF9jcmVkaXQubG9jayk7CiAKIAlpZiAoIWl3bV90eF9jcmVkaXRfb2soaXdtLCBpZCwgbmIpKSB7Ci0JCUlXTV9EQkdfVFgoaXdtLCBEQkcsICJObyBjcmVkaXQgYXZhbGlhYmxlIGZvciBwb29sWyVkXVxuIiwgaWQpOworCQlJV01fREJHX1RYKGl3bSwgREJHLCAiTm8gY3JlZGl0IGF2YWlsYWJsZSBmb3IgcG9vbFslZF1cbiIsIGlkKTsKIAkJcmV0ID0gLUVOT1NQQzsKIAkJZ290byBvdXQ7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvbGliZXJ0YXMvUkVBRE1FIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvbGliZXJ0YXMvUkVBRE1FCmluZGV4IDYwZmQxYWYuLjE0NTNlZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL1JFQURNRQorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9SRUFETUUKQEAgLTcwLDcgKzcwLDcgQEAKIAlUaGVzZSBjb21tYW5kcyBhcmUgdXNlZCB0byByZWFkIHRoZSBNQUMsIEJCUCBhbmQgUkYgcmVnaXN0ZXJzIGZyb20gdGhlCiAJY2FyZC4gIFRoZXNlIGNvbW1hbmRzIHRha2Ugb25lIHBhcmFtZXRlciB0aGF0IHNwZWNpZmllcyB0aGUgb2Zmc2V0CiAJbG9jYXRpb24gdGhhdCBpcyB0byBiZSByZWFkLiAgVGhpcyBwYXJhbWV0ZXIgbXVzdCBiZSBzcGVjaWZpZWQgaW4KLQloZXhhZGVjaW1hbCAoaXRzIHBvc3NpYmxlIHRvIHByZWNlZWQgcHJlY2VkaW5nIHRoZSBudW1iZXIgd2l0aCBhICIweCIpLgorCWhleGFkZWNpbWFsIChpdHMgcG9zc2libGUgdG8gcHJlY2VkZSBwcmVjZWRpbmcgdGhlIG51bWJlciB3aXRoIGEgIjB4IikuCiAKIAlQYXRoOiAvc3lzL2tlcm5lbC9kZWJ1Zy9saWJlcnRhc193aXJlbGVzcy9ldGhYL3JlZ2lzdGVycy8KIApAQCAtODQsNyArODQsNyBAQAogCVRoZXNlIGNvbW1hbmRzIGFyZSB1c2VkIHRvIHdyaXRlIHRoZSBNQUMsIEJCUCBhbmQgUkYgcmVnaXN0ZXJzIGluIHRoZQogCWNhcmQuICBUaGVzZSBjb21tYW5kcyB0YWtlIHR3byBwYXJhbWV0ZXJzIHRoYXQgc3BlY2lmeSB0aGUgb2Zmc2V0CiAJbG9jYXRpb24gYW5kIHRoZSB2YWx1ZSB0aGF0IGlzIHRvIGJlIHdyaXR0ZW4uIFRoaXMgcGFyYW1ldGVycyBtdXN0Ci0JYmUgc3BlY2lmaWVkIGluIGhleGFkZWNpbWFsIChpdHMgcG9zc2libGUgdG8gcHJlY2VlZCB0aGUgbnVtYmVyCisJYmUgc3BlY2lmaWVkIGluIGhleGFkZWNpbWFsIChpdHMgcG9zc2libGUgdG8gcHJlY2VkZSB0aGUgbnVtYmVyCiAJd2l0aCBhICIweCIpLgogCiAJVXNhZ2U6CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9jZmcuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2NmZy5jCmluZGV4IDMwZWYwMzUuLjVjYWEyYWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2NmZy5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2NmZy5jCkBAIC0xMzUwLDcgKzEzNTAsNyBAQAogCQkgKiB3ZSByZW1vdmUgYWxsIGtleXMgbGlrZSBpbiB0aGUgV1BBL1dQQTIgc2V0dXAsCiAJCSAqIHdlIGp1c3QgZG9uJ3Qgc2V0IFJTTi4KIAkJICoKLQkJICogVGhlcmVmb3JlOiBmYWxsLXRocm91Z2h0CisJCSAqIFRoZXJlZm9yZTogZmFsbC10aHJvdWdoCiAJCSAqLwogCWNhc2UgV0xBTl9DSVBIRVJfU1VJVEVfVEtJUDoKIAljYXNlIFdMQU5fQ0lQSEVSX1NVSVRFX0NDTVA6CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9pZl9jcy5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvbGliZXJ0YXMvaWZfY3MuYwppbmRleCBmYzgxMjExLi44NzEyY2IyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9pZl9jcy5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2lmX2NzLmMKQEAgLTkxMyw3ICs5MTMsNyBAQAogCQlnb3RvIG91dDM7CiAJfQogCi0JLyogQ2xlYXIgYW55IGludGVycnVwdCBjYXVzZSB0aGF0IGhhcHBlbmQgd2hpbGUgc2VuZGluZworCS8qIENsZWFyIGFueSBpbnRlcnJ1cHQgY2F1c2UgdGhhdCBoYXBwZW5lZCB3aGlsZSBzZW5kaW5nCiAJICogZmlybXdhcmUvaW5pdGlhbGl6aW5nIGNhcmQgKi8KIAlpZl9jc193cml0ZTE2KGNhcmQsIElGX0NTX0NBUkRfSU5UX0NBVVNFLCBJRl9DU19CSVRfTUFTSyk7CiAJaWZfY3NfZW5hYmxlX2ludHMoY2FyZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9pZl9zcGkuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2lmX3NwaS5oCmluZGV4IDhiMTQxN2QuLmQyYWMxZGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2lmX3NwaS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2lmX3NwaS5oCkBAIC02Niw3ICs2Niw3IEBACiAjZGVmaW5lIElGX1NQSV9IT1NUX0lOVF9DVFJMX1JFRyAweDQwCS8qIEhvc3QgaW50ZXJydXB0IGNvbnRyb2xsZXIgcmVnICovCiAKICNkZWZpbmUgSUZfU1BJX0NBUkRfSU5UX0NBVVNFX1JFRyAweDQ0CS8qIENhcmQgaW50ZXJydXB0IGNhdXNlIHJlZyAqLwotI2RlZmluZSBJRl9TUElfQ0FSRF9JTlRfU1RBVFVTX1JFRyAweDQ4IC8qIENhcmQgaW50ZXJ1cHQgc3RhdHVzIHJlZyAqLworI2RlZmluZSBJRl9TUElfQ0FSRF9JTlRfU1RBVFVTX1JFRyAweDQ4IC8qIENhcmQgaW50ZXJydXB0IHN0YXR1cyByZWcgKi8KICNkZWZpbmUgSUZfU1BJX0NBUkRfSU5UX0VWRU5UX01BU0tfUkVHIDB4NEMgLyogQ2FyZCBpbnRlcnJ1cHQgZXZlbnQgbWFzayAqLwogI2RlZmluZSBJRl9TUElfQ0FSRF9JTlRfU1RBVFVTX01BU0tfUkVHCTB4NTAgLyogQ2FyZCBpbnRlcnJ1cHQgc3RhdHVzIG1hc2sgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvbWFjODAyMTFfaHdzaW0uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL21hYzgwMjExX2h3c2ltLmMKaW5kZXggNTZmNDM5ZC4uZjRmNDI1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvbWFjODAyMTFfaHdzaW0uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9tYWM4MDIxMV9od3NpbS5jCkBAIC02Miw3ICs2Miw3IEBACiAgKiAJYW4gaW50ZXJzZWN0aW9uIHRvIG9jY3VyIGJ1dCBlYWNoIGRldmljZSB3aWxsIHN0aWxsIHVzZSB0aGVpcgogICogCXJlc3BlY3RpdmUgcmVndWxhdG9yeSByZXF1ZXN0ZWQgZG9tYWlucy4gU3Vic2VxdWVudCByYWRpb3Mgd2lsbAogICogCXVzZSB0aGUgcmVzdWx0aW5nIGludGVyc2VjdGlvbi4KLSAqIEBIV1NJTV9SRUdURVNUX1dPUkxEX1JPQU06IFVzZWQgZm9yIHRlc3RpbmcgdGhlIHdvcmxkIHJvYW1pbmcuIFdlIGFjb21wbGlzaAorICogQEhXU0lNX1JFR1RFU1RfV09STERfUk9BTTogVXNlZCBmb3IgdGVzdGluZyB0aGUgd29ybGQgcm9hbWluZy4gV2UgYWNjb21wbGlzaAogICoJdGhpcyBieSB1c2luZyBhIGN1c3RvbSBiZWFjb24tY2FwYWJsZSByZWd1bGF0b3J5IGRvbWFpbiBmb3IgdGhlIGZpcnN0CiAgKglyYWRpby4gQWxsIG90aGVyIGRldmljZSB3b3JsZCByb2FtLgogICogQEhXU0lNX1JFR1RFU1RfQ1VTVE9NX1dPUkxEOiBVc2VkIGZvciB0ZXN0aW5nIHRoZSBjdXN0b20gd29ybGQgcmVndWxhdG9yeQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvb3Jpbm9jby9ody5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3Mvb3Jpbm9jby9ody5jCmluZGV4IGI0NzcyYzEuLjNjNzg3N2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL29yaW5vY28vaHcuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9vcmlub2NvL2h3LmMKQEAgLTEwMzEsNyArMTAzMSw3IEBACiAJZWxzZQogCQlidWYudHNjWzRdID0gMHgxMDsKIAotCS8qIFdhaXQgdXB0byAxMDBtcyBmb3IgdHggcXVldWUgdG8gZW1wdHkgKi8KKwkvKiBXYWl0IHVwIHRvIDEwMG1zIGZvciB0eCBxdWV1ZSB0byBlbXB0eSAqLwogCWZvciAoayA9IDEwMDsgayA+IDA7IGstLSkgewogCQl1ZGVsYXkoMTAwMCk7CiAJCXJldCA9IGhlcm1lc19yZWFkX3dvcmRyZWMoaHcsIFVTRVJfQkFQLCBIRVJNRVNfUklEX1RYUVVFVUVFTVBUWSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3A1NC9tYWluLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvbWFpbi5jCmluZGV4IDM1NmU2YmIuLmE5NDY5OTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3A1NC9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcDU0L21haW4uYwpAQCAtNDY1LDcgKzQ2NSw3IEBACiAKIAkJaWYgKHNsb3QgPCAwKSB7CiAJCQkvKgotCQkJICogVGhlIGRldmljZSBzdXBwb3J0cyB0aGUgY2hvb3NlbiBhbGdvcml0aG0sIGJ1dCB0aGUKKwkJCSAqIFRoZSBkZXZpY2Ugc3VwcG9ydHMgdGhlIGNob3NlbiBhbGdvcml0aG0sIGJ1dCB0aGUKIAkJCSAqIGZpcm13YXJlIGRvZXMgbm90IHByb3ZpZGUgZW5vdWdoIGtleSBzbG90cyB0byBzdG9yZQogCQkJICogYWxsIG9mIHRoZW0uCiAJCQkgKiBCdXQgZW5jcnlwdGlvbiBvZmZsb2FkIGZvciBvdXRnb2luZyBmcmFtZXMgaXMgYWx3YXlzCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvcDU0c3BpLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvcDU0c3BpLmMKaW5kZXggN2VjYzBiZC4uNmQ5MjA0ZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3A1NC9wNTRzcGkuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvcDU0c3BpLmMKQEAgLTI4Nyw3ICsyODcsNyBAQAogCWVuYWJsZV9pcnEoZ3Bpb190b19pcnEocDU0c3BpX2dwaW9faXJxKSk7CiAKIAkvKgotCSAqIG5lZWQgdG8gd2FpdCBhIHdoaWxlIGJlZm9yZSBkZXZpY2UgY2FuIGJlIGFjY2Vzc2VkLCB0aGUgbGVuZ2h0CisJICogbmVlZCB0byB3YWl0IGEgd2hpbGUgYmVmb3JlIGRldmljZSBjYW4gYmUgYWNjZXNzZWQsIHRoZSBsZW5ndGgKIAkgKiBpcyBqdXN0IGEgZ3Vlc3MKIAkgKi8KIAltc2xlZXAoMTApOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcDU0L3A1NHVzYi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcDU0L3A1NHVzYi5jCmluZGV4IDliMzQ0YTkuLmUxODM1ODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3A1NC9wNTR1c2IuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvcDU0dXNiLmMKQEAgLTU2LDYgKzU2LDcgQEAKIAl7VVNCX0RFVklDRSgweDA4NDYsIDB4NDIxMCl9LAkvKiBOZXRnZWFyIFdHMTIxIHRoZSBzZWNvbmQgPyAqLwogCXtVU0JfREVWSUNFKDB4MDg0NiwgMHg0MjIwKX0sCS8qIE5ldGdlYXIgV0cxMTEgKi8KIAl7VVNCX0RFVklDRSgweDA5YWEsIDB4MTAwMCl9LAkvKiBTcGlubmFrZXIgUHJvdG8gYm9hcmQgKi8KKwl7VVNCX0RFVklDRSgweDBiZjgsIDB4MTAwNyl9LAkvKiBGdWppdHN1IEUtNTQwMCBVU0IgKi8KIAl7VVNCX0RFVklDRSgweDBjZGUsIDB4MDAwNil9LAkvKiBNZWRpb24gNDA5MDAsIFJvcGVyIEV1cm9wZSAqLwogCXtVU0JfREVWSUNFKDB4MGRiMCwgMHg2ODI2KX0sCS8qIE1TSSBVQjU0RyAoTVMtNjgyNikgKi8KIAl7VVNCX0RFVklDRSgweDEwN2IsIDB4NTVmMil9LAkvKiBHYXRld2F5IFdHVS0yMTAgKEdlbXRlaykgKi8KQEAgLTY4LDYgKzY5LDcgQEAKIAl7VVNCX0RFVklDRSgweDE5MTUsIDB4MjIzNSl9LAkvKiBMaW5rc3lzIFdVU0I1NEcgUG9ydGFibGUgT0VNICovCiAJe1VTQl9ERVZJQ0UoMHgyMDAxLCAweDM3MDEpfSwJLyogRExpbmsgRFdMLUcxMjAgU3Bpbm5ha2VyICovCiAJe1VTQl9ERVZJQ0UoMHgyMDAxLCAweDM3MDMpfSwJLyogRExpbmsgRFdMLUcxMjIgKi8KKwl7VVNCX0RFVklDRSgweDIwMDEsIDB4Mzc2Mil9LAkvKiBDb25jZXB0cm9uaWMgQzU0VSAqLwogCXtVU0JfREVWSUNFKDB4NTA0MSwgMHgyMjM0KX0sCS8qIExpbmtzeXMgV1VTQjU0RyAqLwogCXtVU0JfREVWSUNFKDB4NTA0MSwgMHgyMjM1KX0sCS8qIExpbmtzeXMgV1VTQjU0RyBQb3J0YWJsZSAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9wcmlzbTU0L2lzbHBjaV9ldGguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX2V0aC5jCmluZGV4IGQ0NGY4ZTIuLjI2NmQ0NWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX2V0aC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX2V0aC5jCkBAIC0xMTMsNyArMTEzLDcgQEAKIAkgKiBiZSBhbGlnbmVkIG9uIGEgNC1ieXRlIGJvdW5kYXJ5LiBJZiBXRFMgaXMgZW5hYmxlZCBhZGQgYW5vdGhlciA2IGJ5dGVzCiAJICogYW5kIGFkZCBXRFMgYWRkcmVzcyBpbmZvcm1hdGlvbiAqLwogCWlmIChsaWtlbHkoKChsb25nKSBza2ItPmRhdGEgJiAweDAzKSB8IGluaXRfd2RzKSkgewotCQkvKiBnZXQgdGhlIG51bWJlciBvZiBieXRlcyB0byBhZGQgYW5kIHJlLWFsbGlnbiAqLworCQkvKiBnZXQgdGhlIG51bWJlciBvZiBieXRlcyB0byBhZGQgYW5kIHJlLWFsaWduICovCiAJCW9mZnNldCA9ICg0IC0gKGxvbmcpIHNrYi0+ZGF0YSkgJiAweDAzOwogCQlvZmZzZXQgKz0gaW5pdF93ZHMgPyA2IDogMDsKIApAQCAtMzQyLDcgKzM0Miw3IEBACiAJCQkgcHJpdi0+cGNpX21hcF9yeF9hZGRyZXNzW2luZGV4XSwKIAkJCSBNQVhfRlJBR01FTlRfU0laRV9SWCArIDIsIFBDSV9ETUFfRlJPTURFVklDRSk7CiAKLQkvKiB1cGRhdGUgdGhlIHNrYiBzdHJ1Y3R1cmUgYW5kIGFsbGlnbiB0aGUgYnVmZmVyICovCisJLyogdXBkYXRlIHRoZSBza2Igc3RydWN0dXJlIGFuZCBhbGlnbiB0aGUgYnVmZmVyICovCiAJc2tiX3B1dChza2IsIHNpemUpOwogCWlmIChvZmZzZXQpIHsKIAkJLyogc2hpZnQgdGhlIGJ1ZmZlciBhbGxvY2F0aW9uIG9mZnNldCBieXRlcyB0byBnZXQgdGhlIHJpZ2h0IGZyYW1lICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9yYXljdGwuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3JheWN0bC5oCmluZGV4IDQ5ZDliMjYuLmQ3NjQ2ZjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3JheWN0bC5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3JheWN0bC5oCkBAIC01NzgsNyArNTc4LDcgQEAKICAgICBVQ0hBUiAgdmFyWzFdOwogfTsKIAotLyoqKioqKiBFQ0YgUmVjZWl2ZSBDb250cm9sIFN0dWN0dXJlIChSQ1MpIEFyZWEgYXQgU2hhcmVkIFJBTSBvZmZzZXQgMHgwODAwICAqLworLyoqKioqKiBFQ0YgUmVjZWl2ZSBDb250cm9sIFN0cnVjdHVyZSAoUkNTKSBBcmVhIGF0IFNoYXJlZCBSQU0gb2Zmc2V0IDB4MDgwMCAgKi8KIC8qIFN0cnVjdHVyZXMgZm9yIGNvbW1hbmQgc3BlY2lmaWMgcGFyYW1ldGVycyAocmNzLnZhcikgKi8KIHN0cnVjdCByeF9wYWNrZXRfY21kIHsKICAgICBVQ0hBUiByeF9kYXRhX3B0clsyXTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDI4MDAuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDI4MDAuaAppbmRleCA3MGI5YWJiLi44ZmJjNWZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyODAwLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MjgwMC5oCkBAIC02MTYsNyArNjE2LDcgQEAKICAqIFJFQURfQ09OVFJPTDogMCB3cml0ZSBCQlAsIDEgcmVhZCBCQlAKICAqIEJVU1k6IEFTSUMgaXMgYnVzeSBleGVjdXRpbmcgQkJQIGNvbW1hbmRzCiAgKiBCQlBfUEFSX0RVUjogMCA0IE1BQyBjbG9ja3MsIDEgOCBNQUMgY2xvY2tzCi0gKiBCQlBfUldfTU9ERTogMCBzZXJpYWwsIDEgcGFyYWxlbGwKKyAqIEJCUF9SV19NT0RFOiAwIHNlcmlhbCwgMSBwYXJhbGxlbAogICovCiAjZGVmaW5lIEJCUF9DU1JfQ0ZHCQkJMHgxMDFjCiAjZGVmaW5lIEJCUF9DU1JfQ0ZHX1ZBTFVFCQlGSUVMRDMyKDB4MDAwMDAwZmYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyODAwbGliLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyODAwbGliLmMKaW5kZXggMmVlNmNlYi4uZGJmNzRkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MjgwMGxpYi5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDI4MDBsaWIuYwpAQCAtMTUxOCw3ICsxNTE4LDcgQEAKIAlpZiAocmYtPmNoYW5uZWwgPiAxNCkgewogCQkvKgogCQkgKiBXaGVuIFRYIHBvd2VyIGlzIGJlbG93IDAsIHdlIHNob3VsZCBpbmNyZWFzZSBpdCBieSA3IHRvCi0JCSAqIG1ha2UgaXQgYSBwb3NpdGl2ZSB2YWx1ZSAoTWludW11bSB2YWx1ZSBpcyAtNykuCisJCSAqIG1ha2UgaXQgYSBwb3NpdGl2ZSB2YWx1ZSAoTWluaW11bSB2YWx1ZSBpcyAtNykuCiAJCSAqIEhvd2V2ZXIgdGhpcyBtZWFucyB0aGF0IHZhbHVlcyBiZXR3ZWVuIDAgYW5kIDcgaGF2ZQogCQkgKiBkb3VibGUgbWVhbmluZywgYW5kIHdlIHNob3VsZCBzZXQgYSA3REJtIGJvb3N0IGZsYWcuCiAJCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMC5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMC5oCmluZGV4IGEzOTQwZDcuLjdmMTAyMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDAuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwLmgKQEAgLTQ4NCwxMyArNDg0LDEzIEBACiAJZW51bSBubDgwMjExX2lmdHlwZSB0eXBlOwogCiAJLyoKLQkgKiBUU0Ygc3luYyB2YWx1ZSwgdGhpcyBpcyBkZXBlbmRhbnQgb24gdGhlIG9wZXJhdGlvbiB0eXBlLgorCSAqIFRTRiBzeW5jIHZhbHVlLCB0aGlzIGlzIGRlcGVuZGVudCBvbiB0aGUgb3BlcmF0aW9uIHR5cGUuCiAJICovCiAJZW51bSB0c2Zfc3luYyBzeW5jOwogCiAJLyoKLQkgKiBUaGUgTUFDIGFuZCBCU1NJRCBhZGRyZXNzZXNzIGFyZSBzaW1wbGUgYXJyYXkgb2YgYnl0ZXMsCi0JICogdGhlc2UgYXJyYXlzIGFyZSBsaXR0bGUgZW5kaWFuLCBzbyB3aGVuIHNlbmRpbmcgdGhlIGFkZHJlc3Nlc3MKKwkgKiBUaGUgTUFDIGFuZCBCU1NJRCBhZGRyZXNzZXMgYXJlIHNpbXBsZSBhcnJheSBvZiBieXRlcywKKwkgKiB0aGVzZSBhcnJheXMgYXJlIGxpdHRsZSBlbmRpYW4sIHNvIHdoZW4gc2VuZGluZyB0aGUgYWRkcmVzc2VzCiAJICogdG8gdGhlIGRyaXZlcnMsIGNvcHkgdGhlIGl0IGludG8gYSBlbmRpYW4tc2lnbmVkIHZhcmlhYmxlLgogCSAqCiAJICogTm90ZSB0aGF0IGFsbCBkZXZpY2VzIChleGNlcHQgcnQyNTAwdXNiKSBoYXZlIDMyIGJpdHMKQEAgLTExMzEsNyArMTEzMSw3IEBACiAgKiBAZHJvcDogVHJ1ZSB0byBkcm9wIGFsbCBwZW5kaW5nIGZyYW1lcy4KICAqCiAgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgZmx1c2ggdGhlIHF1ZXVlLiBBZnRlciB0aGlzIGNhbGwKLSAqIHRoZSBxdWV1ZSBpcyBndWFyZW50ZWVkIHRvIGJlIGVtcHR5LgorICogdGhlIHF1ZXVlIGlzIGd1YXJhbnRlZWQgdG8gYmUgZW1wdHkuCiAgKi8KIHZvaWQgcnQyeDAwcXVldWVfZmx1c2hfcXVldWUoc3RydWN0IGRhdGFfcXVldWUgKnF1ZXVlLCBib29sIGRyb3ApOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwY29uZmlnLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwY29uZmlnLmMKaW5kZXggZTdmNjdkNS4uOTQxNmUzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGNvbmZpZy5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBjb25maWcuYwpAQCAtNjAsNyArNjAsNyBAQAogCSAqIE5vdGUgdGhhdCB3aGVuIE5VTEwgaXMgcGFzc2VkIGFzIGFkZHJlc3Mgd2Ugd2lsbCBzZW5kCiAJICogMDA6MDA6MDA6MDA6MDAgdG8gdGhlIGRldmljZSB0byBjbGVhciB0aGUgYWRkcmVzcy4KIAkgKiBUaGlzIHdpbGwgcHJldmVudCB0aGUgZGV2aWNlIGJlaW5nIGNvbmZ1c2VkIHdoZW4gaXQgd2FudHMKLQkgKiB0byBBQ0sgZnJhbWVzIG9yIGNvbnNpZGVyZXMgaXRzZWxmIGFzc29jaWF0ZWQuCisJICogdG8gQUNLIGZyYW1lcyBvciBjb25zaWRlcnMgaXRzZWxmIGFzc29jaWF0ZWQuCiAJICovCiAJbWVtc2V0KGNvbmYubWFjLCAwLCBzaXplb2YoY29uZi5tYWMpKTsKIAlpZiAobWFjKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGNyeXB0by5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGNyeXB0by5jCmluZGV4IDVlOTA3NGIuLjNmNTY4OGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBjcnlwdG8uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwY3J5cHRvLmMKQEAgLTIzNyw3ICsyMzcsNyBAQAogCX0KIAogCS8qCi0JICogTk9URTogQWx3YXlzIGNvdW50IHRoZSBwYXlsb2FkIGFzIHRyYW5zZmVyZWQsCisJICogTk9URTogQWx3YXlzIGNvdW50IHRoZSBwYXlsb2FkIGFzIHRyYW5zZmVycmVkLAogCSAqIGV2ZW4gd2hlbiBhbGlnbm1lbnQgd2FzIHNldCB0byB6ZXJvLiBUaGlzIGlzIHJlcXVpcmVkCiAJICogZm9yIGRldGVybWluaW5nIHRoZSBjb3JyZWN0IG9mZnNldCBmb3IgdGhlIElDViBkYXRhLgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGRldi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGRldi5jCmluZGV4IDlkZTlkYmUuLjg0ZWI2YWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBkZXYuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwZGV2LmMKQEAgLTEwNjIsOCArMTA2MiwxMCBAQAogCSAqIFN0b3AgYWxsIHdvcmsuCiAJICovCiAJY2FuY2VsX3dvcmtfc3luYygmcnQyeDAwZGV2LT5pbnRmX3dvcmspOwotCWNhbmNlbF93b3JrX3N5bmMoJnJ0MngwMGRldi0+cnhkb25lX3dvcmspOwotCWNhbmNlbF93b3JrX3N5bmMoJnJ0MngwMGRldi0+dHhkb25lX3dvcmspOworCWlmIChydDJ4MDBfaXNfdXNiKHJ0MngwMGRldikpIHsKKwkJY2FuY2VsX3dvcmtfc3luYygmcnQyeDAwZGV2LT5yeGRvbmVfd29yayk7CisJCWNhbmNlbF93b3JrX3N5bmMoJnJ0MngwMGRldi0+dHhkb25lX3dvcmspOworCX0KIAlkZXN0cm95X3dvcmtxdWV1ZShydDJ4MDBkZXYtPndvcmtxdWV1ZSk7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGR1bXAuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBkdW1wLmgKaW5kZXggNWQ2ZTBiOC4uMDYzZWJjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGR1bXAuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwZHVtcC5oCkBAIC01MSw3ICs1MSw3IEBACiAgKiAgIFtydDJ4MDBkdW1wIGhlYWRlcl1baGFyZHdhcmUgZGVzY3JpcHRvcl1baWVlZTgwMi4xMSBmcmFtZV0KICAqCiAgKiBydDJ4MDBkdW1wIGhlYWRlcjogVGhlIGRlc2NyaXB0aW9uIG9mIHRoZSBkdW1wZWQgZnJhbWUsIGFzIHdlbGwgYXMKLSAqCWFkZGl0aW9uYWwgaW5mb3JtYXRpb24gdXNlZnVsbCBmb3IgZGVidWdnaW5nLiBTZWUgJnJ0MngwMGR1bXBfaGRyLgorICoJYWRkaXRpb25hbCBpbmZvcm1hdGlvbiB1c2VmdWwgZm9yIGRlYnVnZ2luZy4gU2VlICZydDJ4MDBkdW1wX2hkci4KICAqIGhhcmR3YXJlIGRlc2NyaXB0b3I6IERlc2NyaXB0b3IgdGhhdCB3YXMgdXNlZCB0byByZWNlaXZlIG9yIHRyYW5zbWl0CiAgKgl0aGUgZnJhbWUuCiAgKiBpZWVlODAyLjExIGZyYW1lOiBUaGUgYWN0dWFsIGZyYW1lIHRoYXQgd2FzIHJlY2VpdmVkIG9yIHRyYW5zbWl0dGVkLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGxpbmsuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBsaW5rLmMKaW5kZXggYzk3NWIwYS4uMjlhYmZkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGxpbmsuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwbGluay5jCkBAIC0yODMsNyArMjgzLDcgQEAKIAkvKioKIAkgKiBXaGlsZSBzY2FubmluZywgbGluayB0dW5pbmcgaXMgZGlzYWJsZWQuIEJ5IGRlZmF1bHQKIAkgKiB0aGUgbW9zdCBzZW5zaXRpdmUgc2V0dGluZ3Mgd2lsbCBiZSB1c2VkIHRvIG1ha2Ugc3VyZQotCSAqIHRoYXQgYWxsIGJlYWNvbnMgYW5kIHByb2JlIHJlc3BvbnNlcyB3aWxsIGJlIHJlY2lldmVkCisJICogdGhhdCBhbGwgYmVhY29ucyBhbmQgcHJvYmUgcmVzcG9uc2VzIHdpbGwgYmUgcmVjZWl2ZWQKIAkgKiBkdXJpbmcgdGhlIHNjYW4uCiAJICovCiAJaWYgKHRlc3RfYml0KERFVklDRV9TVEFURV9TQ0FOTklORywgJnJ0MngwMGRldi0+ZmxhZ3MpKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMHF1ZXVlLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcXVldWUuYwppbmRleCA0YjNjNzBlLi40MzU4MDUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcXVldWUuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcXVldWUuYwpAQCAtNTQ2LDcgKzU0Niw3IEBACiAJfQogCiAJLyoKLQkgKiBXaGVuIERNQSBhbGxvY2F0aW9uIGlzIHJlcXVpcmVkIHdlIHNob3VsZCBndWFyZW50ZWUgdG8gdGhlCisJICogV2hlbiBETUEgYWxsb2NhdGlvbiBpcyByZXF1aXJlZCB3ZSBzaG91bGQgZ3VhcmFudGVlIHRvIHRoZQogCSAqIGRyaXZlciB0aGF0IHRoZSBETUEgaXMgYWxpZ25lZCB0byBhIDQtYnl0ZSBib3VuZGFyeS4KIAkgKiBIb3dldmVyIHNvbWUgZHJpdmVycyByZXF1aXJlIEwyIHBhZGRpbmcgdG8gcGFkIHRoZSBwYXlsb2FkCiAJICogcmF0aGVyIHRoZW4gdGhlIGhlYWRlci4gVGhpcyBjb3VsZCBiZSBhIHJlcXVpcmVtZW50IGZvcgpAQCAtNjg5LDcgKzY4OSw3IEBACiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcXVldWUtPmluZGV4X2xvY2ssIGlycWZsYWdzKTsKIAogCS8qCi0JICogU3RhcnQgZnJvbSB0aGUgVFggZG9uZSBwb2ludGVyLCB0aGlzIGd1YXJlbnRlZXMgdGhhdCB3ZSB3aWxsCisJICogU3RhcnQgZnJvbSB0aGUgVFggZG9uZSBwb2ludGVyLCB0aGlzIGd1YXJhbnRlZXMgdGhhdCB3ZSB3aWxsCiAJICogc2VuZCBvdXQgYWxsIGZyYW1lcyBpbiB0aGUgY29ycmVjdCBvcmRlci4KIAkgKi8KIAlpZiAoaW5kZXhfc3RhcnQgPCBpbmRleF9lbmQpIHsKQEAgLTg4Myw3ICs4ODMsNyBAQAogCX0KIAogCS8qCi0JICogQ2hlY2sgaWYgZHJpdmVyIHN1cHBvcnRzIGZsdXNoaW5nLCB3ZSBjYW4gb25seSBndWFyZW50ZWUKKwkgKiBDaGVjayBpZiBkcml2ZXIgc3VwcG9ydHMgZmx1c2hpbmcsIHdlIGNhbiBvbmx5IGd1YXJhbnRlZQogCSAqIGZ1bGwgc3VwcG9ydCBmb3IgZmx1c2hpbmcgaWYgdGhlIGRyaXZlciBpcyBhYmxlCiAJICogdG8gY2FuY2VsIGFsbCBwZW5kaW5nIGZyYW1lcyAoZHJvcCA9IHRydWUpLgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMHF1ZXVlLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcXVldWUuaAppbmRleCAwYzhiMGM2Li4yMTc4NjFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcXVldWUuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcXVldWUuaApAQCAtMzQ0LDggKzM0NCw4IEBACiAgKglvbmx5IGJlIHRvdWNoZWQgYWZ0ZXIgdGhlIGRldmljZSBoYXMgc2lnbmFsZWQgaXQgaXMgZG9uZSB3aXRoIGl0LgogICogQEVOVFJZX0RBVEFfUEVORElORzogVGhpcyBlbnRyeSBjb250YWlucyBhIHZhbGlkIGZyYW1lIGFuZCBpcyB3YWl0aW5nCiAgKglmb3IgdGhlIHNpZ25hbCB0byBzdGFydCBzZW5kaW5nLgotICogQEVOVFJZX0RBVEFfSU9fRkFJTEVEOiBIYXJkd2FyZSBpbmRpY2F0ZWQgdGhhdCBhbiBJTyBlcnJvciBvY2N1cmVkCi0gKgl3aGlsZSB0cmFuc2ZlcmluZyB0aGUgZGF0YSB0byB0aGUgaGFyZHdhcmUuIE5vIFRYIHN0YXR1cyByZXBvcnQgd2lsbAorICogQEVOVFJZX0RBVEFfSU9fRkFJTEVEOiBIYXJkd2FyZSBpbmRpY2F0ZWQgdGhhdCBhbiBJTyBlcnJvciBvY2N1cnJlZAorICoJd2hpbGUgdHJhbnNmZXJyaW5nIHRoZSBkYXRhIHRvIHRoZSBoYXJkd2FyZS4gTm8gVFggc3RhdHVzIHJlcG9ydCB3aWxsCiAgKgliZSBleHBlY3RlZCBmcm9tIHRoZSBoYXJkd2FyZS4KICAqIEBFTlRSWV9EQVRBX1NUQVRVU19QRU5ESU5HOiBUaGUgZW50cnkgaGFzIGJlZW4gc2VuZCB0byB0aGUgZGV2aWNlIGFuZAogICoJcmV0dXJuZWQuIEl0IGlzIG5vdyB3YWl0aW5nIGZvciB0aGUgc3RhdHVzIHJlcG9ydGluZyBiZWZvcmUgdGhlCkBAIC0zNjUsNyArMzY1LDcgQEAKICAqIEBmbGFnczogRW50cnkgZmxhZ3MsIHNlZSAmZW51bSBxdWV1ZV9lbnRyeV9mbGFncy4KICAqIEBxdWV1ZTogVGhlIGRhdGEgcXVldWUgKCZzdHJ1Y3QgZGF0YV9xdWV1ZSkgdG8gd2hpY2ggdGhpcyBlbnRyeSBiZWxvbmdzLgogICogQHNrYjogVGhlIGJ1ZmZlciB3aGljaCBpcyBjdXJyZW50bHkgYmVpbmcgdHJhbnNtaXR0ZWQgKGZvciBUWCBxdWV1ZSksCi0gKglvciB1c2VkIHRvIGRpcmVjdGx5IHJlY2lldmUgZGF0YSBpbiAoZm9yIFJYIHF1ZXVlKS4KKyAqCW9yIHVzZWQgdG8gZGlyZWN0bHkgcmVjZWl2ZSBkYXRhIGluIChmb3IgUlggcXVldWUpLgogICogQGVudHJ5X2lkeDogVGhlIGVudHJ5IGluZGV4IG51bWJlci4KICAqIEBwcml2X2RhdGE6IFByaXZhdGUgZGF0YSBiZWxvbmdpbmcgdG8gdGhpcyBxdWV1ZSBlbnRyeS4gVGhlIHBvaW50ZXIKICAqCXBvaW50cyB0byBkYXRhIHNwZWNpZmljIHRvIGEgcGFydGljdWxhciBkcml2ZXIgYW5kIHF1ZXVlIHR5cGUuCkBAIC0zODgsNyArMzg4LDcgQEAKICAqIEBRX0lOREVYOiBJbmRleCBwb2ludGVyIHRvIHRoZSBjdXJyZW50IGVudHJ5IGluIHRoZSBxdWV1ZSwgaWYgdGhpcyBlbnRyeSBpcwogICoJb3duZWQgYnkgdGhlIGhhcmR3YXJlIHRoZW4gdGhlIHF1ZXVlIGlzIGNvbnNpZGVyZWQgdG8gYmUgZnVsbC4KICAqIEBRX0lOREVYX0RNQV9ET05FOiBJbmRleCBwb2ludGVyIGZvciB0aGUgbmV4dCBlbnRyeSB3aGljaCB3aWxsIGhhdmUgYmVlbgotICoJdHJhbnNmZXJlZCB0byB0aGUgaGFyZHdhcmUuCisgKgl0cmFuc2ZlcnJlZCB0byB0aGUgaGFyZHdhcmUuCiAgKiBAUV9JTkRFWF9ET05FOiBJbmRleCBwb2ludGVyIHRvIHRoZSBuZXh0IGVudHJ5IHdoaWNoIHdpbGwgYmUgY29tcGxldGVkIGJ5CiAgKgl0aGUgaGFyZHdhcmUgYW5kIGZvciB3aGljaCB3ZSBuZWVkIHRvIHJ1biB0aGUgdHhkb25lIGhhbmRsZXIuIElmIHRoaXMKICAqCWVudHJ5IGlzIG5vdCBvd25lZCBieSB0aGUgaGFyZHdhcmUgdGhlIHF1ZXVlIGlzIGNvbnNpZGVyZWQgdG8gYmUgZW1wdHkuCkBAIC02MjcsNyArNjI3LDcgQEAKIH0KIAogLyoqCi0gKiBydDJ4MDBxdWV1ZV9zdGF0dXNfdGltZW91dCAtIENoZWNrIGlmIGEgdGltZW91dCBvY2N1cmVkIGZvciBTVEFUVVMgcmVwb3J0cworICogcnQyeDAwcXVldWVfc3RhdHVzX3RpbWVvdXQgLSBDaGVjayBpZiBhIHRpbWVvdXQgb2NjdXJyZWQgZm9yIFNUQVRVUyByZXBvcnRzCiAgKiBAcXVldWU6IFF1ZXVlIHRvIGNoZWNrLgogICovCiBzdGF0aWMgaW5saW5lIGludCBydDJ4MDBxdWV1ZV9zdGF0dXNfdGltZW91dChzdHJ1Y3QgZGF0YV9xdWV1ZSAqcXVldWUpCkBAIC02MzcsNyArNjM3LDcgQEAKIH0KIAogLyoqCi0gKiBydDJ4MDBxdWV1ZV90aW1lb3V0IC0gQ2hlY2sgaWYgYSB0aW1lb3V0IG9jY3VyZWQgZm9yIERNQSB0cmFuc2ZlcnMKKyAqIHJ0MngwMHF1ZXVlX3RpbWVvdXQgLSBDaGVjayBpZiBhIHRpbWVvdXQgb2NjdXJyZWQgZm9yIERNQSB0cmFuc2ZlcnMKICAqIEBxdWV1ZTogUXVldWUgdG8gY2hlY2suCiAgKi8KIHN0YXRpYyBpbmxpbmUgaW50IHJ0MngwMHF1ZXVlX2RtYV90aW1lb3V0KHN0cnVjdCBkYXRhX3F1ZXVlICpxdWV1ZSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDB1c2IuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDB1c2IuYwppbmRleCBmYmU3MzVmLi4zNmYzODhmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMHVzYi5jCkBAIC0xNzMsNyArMTczLDcgQEAKIAkvKgogCSAqIElmIHRoZSB0cmFuc2ZlciB0byBoYXJkd2FyZSBzdWNjZWVkZWQsIGl0IGRvZXMgbm90IG1lYW4gdGhlCiAJICogZnJhbWUgd2FzIHNlbmQgb3V0IGNvcnJlY3RseS4gSXQgb25seSBtZWFucyB0aGUgZnJhbWUKLQkgKiB3YXMgc3VjY2VzZnVsbHkgcHVzaGVkIHRvIHRoZSBoYXJkd2FyZSwgd2UgaGF2ZSBubworCSAqIHdhcyBzdWNjZXNzZnVsbHkgcHVzaGVkIHRvIHRoZSBoYXJkd2FyZSwgd2UgaGF2ZSBubwogCSAqIHdheSB0byBkZXRlcm1pbmUgdGhlIHRyYW5zbWlzc2lvbiBzdGF0dXMgcmlnaHQgbm93LgogCSAqIChPbmx5IGluZGlyZWN0bHkgYnkgbG9va2luZyBhdCB0aGUgZmFpbGVkIFRYIGNvdW50ZXJzCiAJICogaW4gdGhlIHJlZ2lzdGVyKS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDB1c2IuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDB1c2IuaAppbmRleCA2YWFmNTFmLi5lMTFjNzU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwdXNiLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMHVzYi5oCkBAIC00MDAsNyArNDAwLDcgQEAKICAqIEBydDJ4MDBkZXY6IFBvaW50ZXIgdG8gJnN0cnVjdCBydDJ4MDBfZGV2CiAgKgogICogQ2hlY2sgdGhlIGhlYWx0aCBvZiB0aGUgVVNCIGNvbW11bmljYXRpb24gYW5kIGRldGVybWluZQotICogaWYgdGltZW91dHMgaGF2ZSBvY2N1cmVkLiBJZiB0aGlzIGlzIHRoZSBjYXNlLCB0aGlzIGZ1bmN0aW9uCisgKiBpZiB0aW1lb3V0cyBoYXZlIG9jY3VycmVkLiBJZiB0aGlzIGlzIHRoZSBjYXNlLCB0aGlzIGZ1bmN0aW9uCiAgKiB3aWxsIHJlc2V0IGFsbCBjb21tdW5pY2F0aW9uIHRvIHJlc3RvcmUgZnVuY3Rpb25hbGl0eSBhZ2Fpbi4KICAqLwogdm9pZCBydDJ4MDB1c2Jfd2F0Y2hkb2coc3RydWN0IHJ0MngwMF9kZXYgKnJ0MngwMGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL2Jhc2UuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvYmFzZS5jCmluZGV4IGJiMGM3ODEuLjBkN2Q5M2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvYmFzZS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvYmFzZS5jCkBAIC01MjAsNyArNTIwLDcgQEAKIAkJCSAqYmVjYXVzZSBodyB3aWxsIG5lcnZlciB1c2UgaHdfcmF0ZQogCQkJICp3aGVuIHRjYl9kZXNjLT51c2VfZHJpdmVyX3JhdGUgPSBmYWxzZQogCQkJICpzbyB3ZSBuZXZlciBzZXQgaGlnaGVzdCBOIHJhdGUgaGVyZSwKLQkJCSAqYW5kIE4gcmF0ZSB3aWxsIGFsbCBiZSBjb250cm9sZWQgYnkgRlcKKwkJCSAqYW5kIE4gcmF0ZSB3aWxsIGFsbCBiZSBjb250cm9sbGVkIGJ5IEZXCiAJCQkgKndoZW4gdGNiX2Rlc2MtPnVzZV9kcml2ZXJfcmF0ZSA9IGZhbHNlCiAJCQkgKi8KIAkJCWlmIChydGxtYWMtPmh0X2VuYWJsZSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9lZnVzZS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9lZnVzZS5jCmluZGV4IGY3NGE4NzAuLjU5MGYxNGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvZWZ1c2UuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL2VmdXNlLmMKQEAgLTY4NSw3ICs2ODUsNyBAQAogCiAJdTggZWZ1c2VfZGF0YSwgd29yZF9jbnRzID0gMDsKIAl1MTYgZWZ1c2VfYWRkciA9IDA7Ci0JdTggaHdvcmRlbjsKKwl1OCBod29yZGVuID0gMDsKIAl1OCB0bXBkYXRhWzhdOwogCiAJaWYgKGRhdGEgPT0gTlVMTCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcGNpLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3BjaS5jCmluZGV4IDljZDc3MDMuLjU5MzhmNmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcGNpLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9wY2kuYwpAQCAtMzk1LDcgKzM5NSw3IEBACiAJICogMCAtIERpc2FibGUgQVNQTSwKIAkgKiAxIC0gRW5hYmxlIEFTUE0gd2l0aG91dCBDbG9jayBSZXEsCiAJICogMiAtIEVuYWJsZSBBU1BNIHdpdGggQ2xvY2sgUmVxLAotCSAqIDMgLSBBbHd5YXMgRW5hYmxlIEFTUE0gd2l0aCBDbG9jayBSZXEsCisJICogMyAtIEFsd2F5cyBFbmFibGUgQVNQTSB3aXRoIENsb2NrIFJlcSwKIAkgKiA0IC0gQWx3YXlzIEVuYWJsZSBBU1BNIHdpdGhvdXQgQ2xvY2sgUmVxLgogCSAqIHNldCBkZWZ1bHQgdG8gUlRMODE5MkNFOjMgUlRMODE5MkU6MgogCSAqICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3JlZ2QuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcmVnZC5jCmluZGV4IDMzMzZjYTkuLmQyNmY5NTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcmVnZC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcmVnZC5jCkBAIC0xNzksNyArMTc5LDcgQEAKIAl9CiAKIAkvKgotCSAqSWYgYSBjb3VudHJ5IElFIGhhcyBiZWVuIHJlY2lldmVkIGNoZWNrIGl0cyBydWxlIGZvciB0aGlzCisJICpJZiBhIGNvdW50cnkgSUUgaGFzIGJlZW4gcmVjZWl2ZWQgY2hlY2sgaXRzIHJ1bGUgZm9yIHRoaXMKIAkgKmNoYW5uZWwgZmlyc3QgYmVmb3JlIGVuYWJsaW5nIGFjdGl2ZSBzY2FuLiBUaGUgcGFzc2l2ZSBzY2FuCiAJICp3b3VsZCBoYXZlIGJlZW4gZW5mb3JjZWQgYnkgdGhlIGluaXRpYWwgcHJvY2Vzc2luZyBvZiBvdXIKIAkgKmN1c3RvbSByZWd1bGF0b3J5IGRvbWFpbi4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcnRsODE5MmMvZndfY29tbW9uLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3J0bDgxOTJjL2Z3X2NvbW1vbi5jCmluZGV4IDVlZjkxMzcuLjI4YTZjZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcnRsODE5MmMvZndfY29tbW9uLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9ydGw4MTkyYy9md19jb21tb24uYwpAQCAtMzAzLDcgKzMwMyw3IEBACiAJdTE2IGJveF9yZWcsIGJveF9leHRyZWc7CiAJdTggdTFiX3RtcDsKIAlib29sIGlzZndfcmVhZCA9IGZhbHNlOwotCXU4IGJ1Zl9pbmRleDsKKwl1OCBidWZfaW5kZXggPSAwOwogCWJvb2wgYndyaXRlX3N1Y2VzcyA9IGZhbHNlOwogCXU4IHdhaXRfaDJjX2xpbW1pdCA9IDEwMDsKIAl1OCB3YWl0X3dyaXRlaDJjX2xpbW1pdCA9IDEwMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvdXNiLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3VzYi5jCmluZGV4IGE0YjI2MTMuLmY1ZDg1NzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS91c2IuYwpAQCAtMjQ2LDcgKzI0Niw3IEBACiAKIHN0YXRpYyB2b2lkIF9ydGxfdXNiX2lvX2hhbmRsZXJfcmVsZWFzZShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodykKIHsKLQlzdHJ1Y3QgcnRsX3ByaXYgKnJ0bHByaXYgPSBydGxfcHJpdihodyk7CisJc3RydWN0IHJ0bF9wcml2IF9fbWF5YmVfdW51c2VkICpydGxwcml2ID0gcnRsX3ByaXYoaHcpOwogCiAJbXV0ZXhfZGVzdHJveSgmcnRscHJpdi0+aW8uYmJfbXV0ZXgpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS93aWZpLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3dpZmkuaAppbmRleCAwMTIyNmY4Li4wN2RiOTVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3dpZmkuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3dpZmkuaApAQCAtMTU1NSw3ICsxNTU1LDcgQEAKIAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gICAgQmx1ZXRvb3RoIENvLWV4aXN0YW5jZSBSZWxhdGVkCisgICAgQmx1ZXRvb3RoIENvLWV4aXN0ZW5jZSBSZWxhdGVkCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiBlbnVtIGJ0X2FudF9udW0gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMjUxL2NtZC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMjUxL2NtZC5jCmluZGV4IDBhZGU0YmQuLjgxZjE2NGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTI1MS9jbWQuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyNTEvY21kLmMKQEAgLTEwNCw3ICsxMDQsNyBAQAogICogQHdsOiB3bCBzdHJ1Y3QKICAqIEBpZDogYWN4IGlkCiAgKiBAYnVmOiBidWZmZXIgZm9yIHRoZSByZXNwb25zZSwgaW5jbHVkaW5nIGFsbCBoZWFkZXJzLCBtdXN0IHdvcmsgd2l0aCBkbWEKLSAqIEBsZW46IGxlbmdodCBvZiBidWYKKyAqIEBsZW46IGxlbmd0aCBvZiBidWYKICAqLwogaW50IHdsMTI1MV9jbWRfaW50ZXJyb2dhdGUoc3RydWN0IHdsMTI1MSAqd2wsIHUxNiBpZCwgdm9pZCAqYnVmLCBzaXplX3QgbGVuKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMjUxL3J4LmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyNTEvcnguYwppbmRleCBjMWIzYjNmLi42YWYzNTI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyNTEvcnguYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyNTEvcnguYwpAQCAtMTc5LDcgKzE3OSw3IEBACiAJcnhfYnVmZmVyID0gc2tiX3B1dChza2IsIGxlbmd0aCk7CiAJd2wxMjUxX21lbV9yZWFkKHdsLCByeF9wYWNrZXRfcmluZ19hZGRyLCByeF9idWZmZXIsIGxlbmd0aCk7CiAKLQkvKiBUaGUgYWN0dWFsIGxlbmdodCBkb2Vzbid0IGluY2x1ZGUgdGhlIHRhcmdldCdzIGFsaWdubWVudCAqLworCS8qIFRoZSBhY3R1YWwgbGVuZ3RoIGRvZXNuJ3QgaW5jbHVkZSB0aGUgdGFyZ2V0J3MgYWxpZ25tZW50ICovCiAJc2tiLT5sZW4gPSBkZXNjLT5sZW5ndGggIC0gUExDUF9IRUFERVJfTEVOR1RIOwogCiAJZmMgPSAodTE2ICopc2tiLT5kYXRhOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L2NtZC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L2NtZC5jCmluZGV4IGYwYWE3YWIuLjk2MzI0MzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTJ4eC9jbWQuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvY21kLmMKQEAgLTM1OSw3ICszNTksNyBAQAogICogQHdsOiB3bCBzdHJ1Y3QKICAqIEBpZDogYWN4IGlkCiAgKiBAYnVmOiBidWZmZXIgZm9yIHRoZSByZXNwb25zZSwgaW5jbHVkaW5nIGFsbCBoZWFkZXJzLCBtdXN0IHdvcmsgd2l0aCBkbWEKLSAqIEBsZW46IGxlbmdodCBvZiBidWYKKyAqIEBsZW46IGxlbmd0aCBvZiBidWYKICAqLwogaW50IHdsMTI3MV9jbWRfaW50ZXJyb2dhdGUoc3RydWN0IHdsMTI3MSAqd2wsIHUxNiBpZCwgdm9pZCAqYnVmLCBzaXplX3QgbGVuKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L2NvbmYuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTJ4eC9jb25mLmgKaW5kZXggODU2YThhMi4uOGE4MzIzOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L2NvbmYuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvY29uZi5oCkBAIC00OTcsNyArNDk3LDcgQEAKICNkZWZpbmUgQ09ORl9UWF9SQVRFX1JFVFJZX0xJTUlUICAgICAgIDEwCiAKIC8qCi0gKiBSYXRlcyBzdXBwb3J0ZWQgZm9yIGRhdGEgcGFja2V0cyB3aGVuIG9wZXJhdGluZyBhcyBBUC4gTm90ZSB0aGUgYWJzZW5zZQorICogUmF0ZXMgc3VwcG9ydGVkIGZvciBkYXRhIHBhY2tldHMgd2hlbiBvcGVyYXRpbmcgYXMgQVAuIE5vdGUgdGhlIGFic2VuY2UKICAqIG9mIHRoZSAyMk1icHMgcmF0ZS4gVGhlcmUgaXMgYSBGVyBsaW1pdGF0aW9uIG9uIDEyIHJhdGVzIHNvIHdlIG11c3QgZHJvcAogICogb25lLiBUaGUgcmF0ZSBkcm9wcGVkIGlzIG5vdCBtYW5kYXRvcnkgdW5kZXIgYW55IG9wZXJhdGluZyBtb2RlLgogICovCkBAIC01NzIsNyArNTcyLDcgQEAKIAlDT05GX1RYX0FDX0JLID0gMSwgICAgICAgICAvKiBiYWNrZ3JvdW5kICovCiAJQ09ORl9UWF9BQ19WSSA9IDIsICAgICAgICAgLyogdmlkZW8gKi8KIAlDT05GX1RYX0FDX1ZPID0gMywgICAgICAgICAvKiB2b2ljZSAqLwotCUNPTkZfVFhfQUNfQ1RTMlNFTEYgPSA0LCAgIC8qIGZpY3Rpb3VzIEFDLCBmb2xsb3dzIEFDX1ZPICovCisJQ09ORl9UWF9BQ19DVFMyU0VMRiA9IDQsICAgLyogZmljdGl0aW91cyBBQywgZm9sbG93cyBBQ19WTyAqLwogCUNPTkZfVFhfQUNfQU5ZX1RJRCA9IDB4MWYKIH07CiAKQEAgLTExNjksNyArMTE2OSw3IEBACiAKIAkvKgogCSAqIE1pbmltdW0gcmVxdWlyZWQgZnJlZSB0eCBtZW1vcnkgYmxvY2tzIGluIG9yZGVyIHRvIGFzc3VyZSBvcHRpbXVtCi0JICogcGVyZm9ybWVuY2UKKwkgKiBwZXJmb3JtYW5jZQogCSAqCiAJICogUmFuZ2U6IDAtMTIwCiAJICovCkBAIC0xMTc3LDcgKzExNzcsNyBAQAogCiAJLyoKIAkgKiBNaW5pbXVtIHJlcXVpcmVkIGZyZWUgcnggbWVtb3J5IGJsb2NrcyBpbiBvcmRlciB0byBhc3N1cmUgb3B0aW11bQotCSAqIHBlcmZvcm1lbmNlCisJICogcGVyZm9ybWFuY2UKIAkgKgogCSAqIFJhbmdlOiAwLTEyMAogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L2lvLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvaW8uaAppbmRleCBjMWFhYzgyLi4wMGM3NzFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvaW8uaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvaW8uaApAQCAtOTQsNyArOTQsNyBAQAogCSAqIHRyYW5zbGF0ZWQgcmVnaW9uLgogCSAqCiAJICogVGhlIHRyYW5zbGF0ZWQgcmVnaW9ucyBvY2N1ciBuZXh0IHRvIGVhY2ggb3RoZXIgaW4gcGh5c2ljYWwgZGV2aWNlCi0JICogbWVtb3J5LCBzbyBqdXN0IGFkZCB0aGUgc2l6ZXMgb2YgdGhlIHByZWNlZWRpbmcgYWRkcmVzcyByZWdpb25zIHRvCisJICogbWVtb3J5LCBzbyBqdXN0IGFkZCB0aGUgc2l6ZXMgb2YgdGhlIHByZWNlZGluZyBhZGRyZXNzIHJlZ2lvbnMgdG8KIAkgKiBnZXQgdGhlIG9mZnNldCB0byB0aGUgbmV3IHJlZ2lvbi4KIAkgKgogCSAqIEN1cnJlbnRseSwgb25seSB0aGUgdHdvIGZpcnN0IHJlZ2lvbnMgYXJlIGFkZHJlc3NlZCwgYW5kIHRoZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L3NkaW8uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTJ4eC9zZGlvLmMKaW5kZXggNWI5ZGJlYS4uYjFjN2QwMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L3NkaW8uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvc2Rpby5jCkBAIC0zNDAsNyArMzQwLDcgQEAKIG1vZHVsZV9leGl0KHdsMTI3MV9leGl0KTsKIAogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwotTU9EVUxFX0FVVEhPUigiTHVjaWFubyBDb2VsaG8gPGx1Y2lhbm8uY29lbGhvQG5va2lhLmNvbT4iKTsKK01PRFVMRV9BVVRIT1IoIkx1Y2lhbm8gQ29lbGhvIDxjb2VsaG9AdGkuY29tPiIpOwogTU9EVUxFX0FVVEhPUigiSnV1c28gT2lrYXJpbmVuIDxqdXVzby5vaWthcmluZW5Abm9raWEuY29tPiIpOwogTU9EVUxFX0ZJUk1XQVJFKFdMMTI3MV9GV19OQU1FKTsKIE1PRFVMRV9GSVJNV0FSRShXTDEyNzFfQVBfRldfTkFNRSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvc3BpLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvc3BpLmMKaW5kZXggMThjZjAxNy4uZmZjNzQ1YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L3NwaS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTJ4eC9zcGkuYwpAQCAtNDg3LDcgKzQ4Nyw3IEBACiBtb2R1bGVfZXhpdCh3bDEyNzFfZXhpdCk7CiAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKLU1PRFVMRV9BVVRIT1IoIkx1Y2lhbm8gQ29lbGhvIDxsdWNpYW5vLmNvZWxob0Bub2tpYS5jb20+Iik7CitNT0RVTEVfQVVUSE9SKCJMdWNpYW5vIENvZWxobyA8Y29lbGhvQHRpLmNvbT4iKTsKIE1PRFVMRV9BVVRIT1IoIkp1dXNvIE9pa2FyaW5lbiA8anV1c28ub2lrYXJpbmVuQG5va2lhLmNvbT4iKTsKIE1PRFVMRV9GSVJNV0FSRShXTDEyNzFfRldfTkFNRSk7CiBNT0RVTEVfRklSTVdBUkUoV0wxMjcxX0FQX0ZXX05BTUUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L3Rlc3Rtb2RlLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvdGVzdG1vZGUuYwppbmRleCBlNjQ0MDNiLi42ZWMwNmE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvdGVzdG1vZGUuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvdGVzdG1vZGUuYwpAQCAtMjA0LDcgKzIwNCwxMCBAQAogCiAJa2ZyZWUod2wtPm52cyk7CiAKLQl3bC0+bnZzID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHdsMTI3MV9udnNfZmlsZSksIEdGUF9LRVJORUwpOworCWlmIChsZW4gIT0gc2l6ZW9mKHN0cnVjdCB3bDEyNzFfbnZzX2ZpbGUpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXdsLT5udnMgPSBremFsbG9jKGxlbiwgR0ZQX0tFUk5FTCk7CiAJaWYgKCF3bC0+bnZzKSB7CiAJCXdsMTI3MV9lcnJvcigiY291bGQgbm90IGFsbG9jYXRlIG1lbW9yeSBmb3IgdGhlIG52cyBmaWxlIik7CiAJCXJldCA9IC1FTk9NRU07CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy93bDM1MDFfY3MuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMzUwMV9jcy5jCmluZGV4IDNlNWJlZmUuLmZjMDhmMzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMzUwMV9jcy5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMzUwMV9jcy5jCkBAIC0yOTAsNyArMjkwLDcgQEAKICAqICBcICAgICAgICAgICAgICAgXC0gSUVFRSA4MDIuMTEgLS8gXC0tLS0tLS0tLS0tLS0tIGxlbiAtLS0tLS0tLS0tLS0tLS8KICAqICAgXC1zdHJ1Y3Qgd2wzNTAxXzgwMjExX3R4X2hkci0tLyAgIFwtLS0tLS0tLSBFdGhlcm5ldCBGcmFtZSAtLS0tLS0tLwogICoKLSAqIFJldHVybiA9IFBvc3Rpb24gaW4gQ2FyZAorICogUmV0dXJuID0gUG9zaXRpb24gaW4gQ2FyZAogICovCiBzdGF0aWMgdTE2IHdsMzUwMV9nZXRfdHhfYnVmZmVyKHN0cnVjdCB3bDM1MDFfY2FyZCAqdGhpcywgdTE2IGxlbikKIHsKQEAgLTE5MzIsNyArMTkzMiw3IEBACiAJdGhpcy0+YmFzZV9hZGRyID0gZGV2LT5iYXNlX2FkZHI7CiAKIAlpZiAoIXdsMzUwMV9nZXRfZmxhc2hfbWFjX2FkZHIodGhpcykpIHsKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiJXM6IENhbnQgcmVhZCBNQUMgYWRkciBpbiBmbGFzaCBST00/XG4iLAorCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogQ2FuJ3QgcmVhZCBNQUMgYWRkciBpbiBmbGFzaCBST00/XG4iLAogCQkgICAgICAgZGV2LT5uYW1lKTsKIAkJdW5yZWdpc3Rlcl9uZXRkZXYoZGV2KTsKIAkJZ290byBmYWlsZWQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy96ZDEyMTFydy96ZF9yZl9yZjI5NTkuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3JmX3JmMjk1OS5jCmluZGV4IDA1OTdkODYuLmUzNjExNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3JmX3JmMjk1OS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3JmX3JmMjk1OS5jCkBAIC0xNjksNyArMTY5LDcgQEAKIAkJeyBDUjg1LCAgMHgwMCB9LCB7IENSODYsICAweDEwIH0sIHsgQ1I4NywgIDB4MkEgfSwKIAkJeyBDUjg4LCAgMHgxMCB9LCB7IENSODksICAweDI0IH0sIHsgQ1I5MCwgIDB4MTggfSwKIAkJLyogeyBDUjkxLCAgMHgxOCB9LCAqLwotCQkvKiBzaG91bGQgc29sdmUgY29udGlub3VzIENUUyBmcmFtZSBwcm9ibGVtcyAqLworCQkvKiBzaG91bGQgc29sdmUgY29udGludW91cyBDVFMgZnJhbWUgcHJvYmxlbXMgKi8KIAkJeyBDUjkxLCAgMHgwMCB9LAogCQl7IENSOTIsICAweDBhIH0sIHsgQ1I5MywgIDB4MDAgfSwgeyBDUjk0LCAgMHgwMSB9LAogCQl7IENSOTUsICAweDAwIH0sIHsgQ1I5NiwgIDB4NDAgfSwgeyBDUjk3LCAgMHgzNyB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvemQxMjExcncvemRfcmZfdXcyNDUzLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy96ZDEyMTFydy96ZF9yZl91dzI0NTMuYwppbmRleCA5ZTc0ZWIxLi5iYTBhMGNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy96ZDEyMTFydy96ZF9yZl91dzI0NTMuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy96ZDEyMTFydy96ZF9yZl91dzI0NTMuYwpAQCAtMzUzLDcgKzM1Myw3IEBACiAJfTsKIAogCXN0YXRpYyBjb25zdCB1MzIgcnZbXSA9IHsKLQkJVVcyNDUzX1JFR1dSSVRFKDQsIDB4MmIpLCAgICAvKiBjb25maWd1cmUgcmVjaWV2ZXIgZ2FpbiAqLworCQlVVzI0NTNfUkVHV1JJVEUoNCwgMHgyYiksICAgIC8qIGNvbmZpZ3VyZSByZWNlaXZlciBnYWluICovCiAJCVVXMjQ1M19SRUdXUklURSg1LCAweDE5ZTRmKSwgLyogY29uZmlndXJlIHRyYW5zbWl0dGVyIGdhaW4gKi8KIAkJVVcyNDUzX1JFR1dSSVRFKDYsIDB4ZjgxYWQpLCAvKiBlbmFibGUgUlgvVFggZmlsdGVyIHR1bmluZyAqLwogCQlVVzI0NTNfUkVHV1JJVEUoNywgMHgzZmZmZSksIC8qIGRpc2FibGUgVFggZ2FpbiBpbiB0ZXN0IG1vZGUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3VzYi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvemQxMjExcncvemRfdXNiLmMKaW5kZXggNTgyMzZlNi4uYWI2MDdiYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvemQxMjExcncvemRfdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvemQxMjExcncvemRfdXNiLmMKQEAgLTY0Myw3ICs2NDMsNyBAQAogCXVzYiA9IHVyYi0+Y29udGV4dDsKIAlyeCA9ICZ1c2ItPnJ4OwogCi0JemRfdXNiX3Jlc2V0X3J4X2lkbGVfdGltZXIodXNiKTsKKwl0YXNrbGV0X3NjaGVkdWxlKCZyeC0+cmVzZXRfdGltZXJfdGFza2xldCk7CiAKIAlpZiAobGVuZ3RoJXJ4LT51c2JfcGFja2V0X3NpemUgPiByeC0+dXNiX3BhY2tldF9zaXplLTQpIHsKIAkJLyogSWYgdGhlcmUgaXMgYW4gb2xkIGZpcnN0IGZyYWdtZW50LCB3ZSBkb24ndCBjYXJlLiAqLwpAQCAtODEyLDYgKzgxMiw3IEBACiAJX196ZF91c2JfZGlzYWJsZV9yeCh1c2IpOwogCW11dGV4X3VubG9jaygmcngtPnNldHVwX211dGV4KTsKIAorCXRhc2tsZXRfa2lsbCgmcngtPnJlc2V0X3RpbWVyX3Rhc2tsZXQpOwogCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmcngtPmlkbGVfd29yayk7CiB9CiAKQEAgLTExMDYsNiArMTEwNywxMyBAQAogCXpkX3VzYl9yZXNldF9yeCh1c2IpOwogfQogCitzdGF0aWMgdm9pZCB6ZF91c2JfcmVzZXRfcnhfaWRsZV90aW1lcl90YXNrbGV0KHVuc2lnbmVkIGxvbmcgcGFyYW0pCit7CisJc3RydWN0IHpkX3VzYiAqdXNiID0gKHN0cnVjdCB6ZF91c2IgKilwYXJhbTsKKworCXpkX3VzYl9yZXNldF9yeF9pZGxlX3RpbWVyKHVzYik7Cit9CisKIHZvaWQgemRfdXNiX3Jlc2V0X3J4X2lkbGVfdGltZXIoc3RydWN0IHpkX3VzYiAqdXNiKQogewogCXN0cnVjdCB6ZF91c2JfcnggKnJ4ID0gJnVzYi0+cng7CkBAIC0xMTI3LDYgKzExMzUsNyBAQAogc3RhdGljIGlubGluZSB2b2lkIGluaXRfdXNiX3J4KHN0cnVjdCB6ZF91c2IgKnVzYikKIHsKIAlzdHJ1Y3QgemRfdXNiX3J4ICpyeCA9ICZ1c2ItPnJ4OworCiAJc3Bpbl9sb2NrX2luaXQoJnJ4LT5sb2NrKTsKIAltdXRleF9pbml0KCZyeC0+c2V0dXBfbXV0ZXgpOwogCWlmIChpbnRlcmZhY2VfdG9fdXNiZGV2KHVzYi0+aW50ZiktPnNwZWVkID09IFVTQl9TUEVFRF9ISUdIKSB7CkBAIC0xMTM2LDExICsxMTQ1LDE0IEBACiAJfQogCVpEX0FTU0VSVChyeC0+ZnJhZ21lbnRfbGVuZ3RoID09IDApOwogCUlOSVRfREVMQVlFRF9XT1JLKCZyeC0+aWRsZV93b3JrLCB6ZF9yeF9pZGxlX3RpbWVyX2hhbmRsZXIpOworCXJ4LT5yZXNldF90aW1lcl90YXNrbGV0LmZ1bmMgPSB6ZF91c2JfcmVzZXRfcnhfaWRsZV90aW1lcl90YXNrbGV0OworCXJ4LT5yZXNldF90aW1lcl90YXNrbGV0LmRhdGEgPSAodW5zaWduZWQgbG9uZyl1c2I7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBpbml0X3VzYl90eChzdHJ1Y3QgemRfdXNiICp1c2IpCiB7CiAJc3RydWN0IHpkX3VzYl90eCAqdHggPSAmdXNiLT50eDsKKwogCXNwaW5fbG9ja19pbml0KCZ0eC0+bG9jayk7CiAJYXRvbWljX3NldCgmdHgtPmVuYWJsZWQsIDApOwogCXR4LT5zdG9wcGVkID0gMDsKQEAgLTE2NzEsNiArMTY4MywxMCBAQAogCiAJaWYgKHVyYi0+c3RhdHVzICYmICF1c2ItPmNtZF9lcnJvcikKIAkJdXNiLT5jbWRfZXJyb3IgPSB1cmItPnN0YXR1czsKKworCWlmICghdXNiLT5jbWRfZXJyb3IgJiYKKwkJCXVyYi0+YWN0dWFsX2xlbmd0aCAhPSB1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgpCisJCXVzYi0+Y21kX2Vycm9yID0gLUVJTzsKIH0KIAogc3RhdGljIGludCB6ZF9zdWJtaXRfd2FpdGluZ191cmIoc3RydWN0IHpkX3VzYiAqdXNiLCBib29sIGxhc3QpCkBAIC0xODA1LDcgKzE4MjEsNyBAQAogCXVzYl9maWxsX2ludF91cmIodXJiLCB1ZGV2LCB1c2Jfc25kaW50cGlwZSh1ZGV2LCBFUF9SRUdTX09VVCksCiAJCQkgcmVxLCByZXFfbGVuLCBpb3dyaXRlMTZ2X3VyYl9jb21wbGV0ZSwgdXNiLAogCQkJIGVwLT5kZXNjLmJJbnRlcnZhbCk7Ci0JdXJiLT50cmFuc2Zlcl9mbGFncyB8PSBVUkJfRlJFRV9CVUZGRVIgfCBVUkJfU0hPUlRfTk9UX09LOworCXVyYi0+dHJhbnNmZXJfZmxhZ3MgfD0gVVJCX0ZSRUVfQlVGRkVSOwogCiAJLyogU3VibWl0IHByZXZpb3VzIFVSQiAqLwogCXIgPSB6ZF9zdWJtaXRfd2FpdGluZ191cmIodXNiLCBmYWxzZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy96ZDEyMTFydy96ZF91c2IuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3VzYi5oCmluZGV4IGIzZGYyYzguLjMyNWQwZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3VzYi5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3pkMTIxMXJ3L3pkX3VzYi5oCkBAIC0xODMsNiArMTgzLDcgQEAKIAlzcGlubG9ja190IGxvY2s7CiAJc3RydWN0IG11dGV4IHNldHVwX211dGV4OwogCXN0cnVjdCBkZWxheWVkX3dvcmsgaWRsZV93b3JrOworCXN0cnVjdCB0YXNrbGV0X3N0cnVjdCByZXNldF90aW1lcl90YXNrbGV0OwogCXU4IGZyYWdtZW50WzIgKiBVU0JfTUFYX1JYX1NJWkVdOwogCXVuc2lnbmVkIGludCBmcmFnbWVudF9sZW5ndGg7CiAJdW5zaWduZWQgaW50IHVzYl9wYWNrZXRfc2l6ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3hpbGlueF9lbWFjbGl0ZS5jIGIvZHJpdmVycy9uZXQveGlsaW54X2VtYWNsaXRlLmMKaW5kZXggMjY0MmFmNC4uMzcyNTcyYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQveGlsaW54X2VtYWNsaXRlLmMKKysrIGIvZHJpdmVycy9uZXQveGlsaW54X2VtYWNsaXRlLmMKQEAgLTc4Niw3ICs3ODYsNyBAQAogICogQHJlZzoJcmVnaXN0ZXIgbnVtYmVyIHRvIHdyaXRlIHRvCiAgKiBAdmFsOgl2YWx1ZSB0byB3cml0ZSB0byB0aGUgcmVnaXN0ZXIgbnVtYmVyIHNwZWNpZmllZCBieSByZWcKICAqCi0gKiBUaGlzIGZ1Y250aW9uIHdhaXRzIHRpbGwgdGhlIGRldmljZSBpcyByZWFkeSB0byBhY2NlcHQgYSBuZXcgTURJTworICogVGhpcyBmdW5jdGlvbiB3YWl0cyB0aWxsIHRoZSBkZXZpY2UgaXMgcmVhZHkgdG8gYWNjZXB0IGEgbmV3IE1ESU8KICAqIHJlcXVlc3QgYW5kIHRoZW4gd3JpdGVzIHRoZSB2YWwgdG8gdGhlIE1ESU8gV3JpdGUgRGF0YSByZWdpc3Rlci4KICAqLwogc3RhdGljIGludCB4ZW1hY2xpdGVfbWRpb193cml0ZShzdHJ1Y3QgbWlpX2J1cyAqYnVzLCBpbnQgcGh5X2lkLCBpbnQgcmVnLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvem5ldC5jIGIvZHJpdmVycy9uZXQvem5ldC5jCmluZGV4IGFlMDdiM2QuLmVjMjgwMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3puZXQuYworKysgYi9kcml2ZXJzL25ldC96bmV0LmMKQEAgLTY1Miw3ICs2NTIsNyBAQAogCQkJCQlkZXYtPnN0YXRzLnR4X2Vycm9ycysrOwogCiAJCQkJLyogVHJhbnNjZWl2ZXIgbWF5IGJlIHN0dWNrIGlmIGNhYmxlCi0JCQkJICogd2FzIHJlbW92ZWQgd2hpbGUgZW1pdGluZyBhCisJCQkJICogd2FzIHJlbW92ZWQgd2hpbGUgZW1pdHRpbmcgYQogCQkJCSAqIHBhY2tldC4gRmxpcCBpdCBvZmYsIHRoZW4gb24gdG8KIAkJCQkgKiByZXNldCBpdC4gVGhpcyBpcyB2ZXJ5IGVtcGlyaWNhbCwKIAkJCQkgKiBidXQgaXQgc2VlbXMgdG8gd29yay4gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvb2YvZmR0LmMgYi9kcml2ZXJzL29mL2ZkdC5jCmluZGV4IGM5ZGI0OWMuLjhiNjNhNjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvb2YvZmR0LmMKKysrIGIvZHJpdmVycy9vZi9mZHQuYwpAQCAtNjc2LDcgKzY3Niw3IEBACiAKIAllYXJseV9pbml0X2R0X2NoZWNrX2Zvcl9pbml0cmQobm9kZSk7CiAKLQkvKiBSZXRyZWl2ZSBjb21tYW5kIGxpbmUgKi8KKwkvKiBSZXRyaWV2ZSBjb21tYW5kIGxpbmUgKi8KIAlwID0gb2ZfZ2V0X2ZsYXRfZHRfcHJvcChub2RlLCAiYm9vdGFyZ3MiLCAmbCk7CiAJaWYgKHAgIT0gTlVMTCAmJiBsID4gMCkKIAkJc3RybGNweShjbWRfbGluZSwgcCwgbWluKChpbnQpbCwgQ09NTUFORF9MSU5FX1NJWkUpKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvb2Yvb2ZfbWRpby5jIGIvZHJpdmVycy9vZi9vZl9tZGlvLmMKaW5kZXggZGNkNzg1Ny4uZDM1ZTMwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9vZi9vZl9tZGlvLmMKKysrIGIvZHJpdmVycy9vZi9vZl9tZGlvLmMKQEAgLTEzNiw3ICsxMzYsNyBAQAogICogQGhuZGxyOiBMaW5rIHN0YXRlIGNhbGxiYWNrIGZvciB0aGUgbmV0d29yayBkZXZpY2UKICAqIEBpZmFjZTogUEhZIGRhdGEgaW50ZXJmYWNlIHR5cGUKICAqCi0gKiBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgcGh5X2RldmljZSBpZiBzdWNjZXNzZnVsbC4gIE5VTEwgb3RoZXJ3aXNlCisgKiBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgcGh5X2RldmljZSBpZiBzdWNjZXNzZnVsLiAgTlVMTCBvdGhlcndpc2UKICAqLwogc3RydWN0IHBoeV9kZXZpY2UgKm9mX3BoeV9jb25uZWN0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCQkJICBzdHJ1Y3QgZGV2aWNlX25vZGUgKnBoeV9ucCwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGFyaXNjL3BkY19zdGFibGUuYyBiL2RyaXZlcnMvcGFyaXNjL3BkY19zdGFibGUuYwppbmRleCAxMDYyYjhmLi4yNDZhOTJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BhcmlzYy9wZGNfc3RhYmxlLmMKKysrIGIvZHJpdmVycy9wYXJpc2MvcGRjX3N0YWJsZS5jCkBAIC0xNDEsNyArMTQxLDcgQEAKICAqIEBlbnRyeTogQSBwb2ludGVyIHRvIGFuIGFsbG9jYXRlZCBwZGNzcGF0aF9lbnRyeS4KICAqIAogICogVGhlIGdlbmVyYWwgaWRlYSBpcyB0aGF0IHlvdSBkb24ndCByZWFkIGZyb20gdGhlIFN0YWJsZSBTdG9yYWdlIGV2ZXJ5IHRpbWUKLSAqIHlvdSBhY2Nlc3MgdGhlIGZpbGVzIHByb3ZpZGVkIGJ5IHRoZSBmYWNpbGl0ZXMuIFdlIHN0b3JlIGEgY29weSBvZiB0aGUKKyAqIHlvdSBhY2Nlc3MgdGhlIGZpbGVzIHByb3ZpZGVkIGJ5IHRoZSBmYWNpbGl0aWVzLiBXZSBzdG9yZSBhIGNvcHkgb2YgdGhlCiAgKiBjb250ZW50IG9mIHRoZSBzdGFibGUgc3RvcmFnZSBXUlQgdmFyaW91cyBwYXRocyBpbiB0aGVzZSBzdHJ1Y3RzLiBXZSByZWFkCiAgKiB0aGVzZSBzdHJ1Y3RzIHdoZW4gcmVhZGluZyB0aGUgZmlsZXMsIGFuZCB3ZSB3aWxsIHdyaXRlIHRvIHRoZXNlIHN0cnVjdHMgd2hlbgogICogd3JpdGluZyB0byB0aGUgZmlsZXMsIGFuZCBvbmx5IHRoZW4gd3JpdGUgdGhlbSBiYWNrIHRvIHRoZSBTdGFibGUgU3RvcmFnZS4KQEAgLTIxMyw3ICsyMTMsNyBAQAogCiAJLyogYWRkciwgZGV2cGF0aCBhbmQgY291bnQgbXVzdCBiZSB3b3JkIGFsaWduZWQgKi8KIAlpZiAocGRjX3N0YWJsZV93cml0ZShlbnRyeS0+YWRkciwgZGV2cGF0aCwgc2l6ZW9mKCpkZXZwYXRoKSkgIT0gUERDX09LKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiJXM6IGFuIGVycm9yIG9jY3VyZWQgd2hlbiB3cml0aW5nIHRvIFBEQy5cbiIKKwkJcHJpbnRrKEtFUk5fRVJSICIlczogYW4gZXJyb3Igb2NjdXJyZWQgd2hlbiB3cml0aW5nIHRvIFBEQy5cbiIKIAkJCQkiSXQgaXMgbGlrZWx5IHRoYXQgdGhlIFN0YWJsZSBTdG9yYWdlIGRhdGEgaGFzIGJlZW4gY29ycnVwdGVkLlxuIgogCQkJCSJQbGVhc2UgY2hlY2sgaXQgY2FyZWZ1bGx5IHVwb24gbmV4dCByZWJvb3QuXG4iLCBfX2Z1bmNfXyk7CiAJCVdBUk5fT04oMSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BhcnBvcnQvS2NvbmZpZyBiL2RyaXZlcnMvcGFycG9ydC9LY29uZmlnCmluZGV4IDg1NWYzODkuLmQ5MjE4NWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGFycG9ydC9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGFycG9ydC9LY29uZmlnCkBAIC0xNDIsNyArMTQyLDcgQEAKIAkgIHRoZSBBWDg4Nzk2IG5ldHdvcmsgY29udHJvbGxlciBjaGlwLiBUaGlzIGNvZGUgaXMgYWxzbyBhdmFpbGFibGUKIAkgIGFzIGEgbW9kdWxlIChzYXkgTSksIGNhbGxlZCBwYXJwb3J0X2F4ODg3OTYuCiAKLQkgIFRoZSBkcml2ZXIgaXMgbm90IGRlcGVuZGFudCBvbiB0aGUgQVg4ODc5NiBuZXR3b3JrIGRyaXZlciwgYW5kCisJICBUaGUgZHJpdmVyIGlzIG5vdCBkZXBlbmRlbnQgb24gdGhlIEFYODg3OTYgbmV0d29yayBkcml2ZXIsIGFuZAogCSAgc2hvdWxkIG5vdCBpbnRlcmZlcmUgd2l0aCB0aGUgbmV0d29ya2luZyBmdW5jdGlvbnMgb2YgdGhlIGNoaXAuCiAKIGNvbmZpZyBQQVJQT1JUXzEyODQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGFycG9ydC9pZWVlMTI4NC5jIGIvZHJpdmVycy9wYXJwb3J0L2llZWUxMjg0LmMKaW5kZXggODkwMWVjZi4uZjlmZDRiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9wYXJwb3J0L2llZWUxMjg0LmMKKysrIGIvZHJpdmVycy9wYXJwb3J0L2llZWUxMjg0LmMKQEAgLTM1NSw3ICszNTUsNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQkvKiBHbyB0byBjb21wYWJpbGl0eSBmb3J3YXJkIGlkbGUgbW9kZSAqLworCS8qIEdvIHRvIGNvbXBhdGliaWxpdHkgZm9yd2FyZCBpZGxlIG1vZGUgKi8KIAlpZiAocG9ydC0+aWVlZTEyODQubW9kZSAhPSBJRUVFMTI4NF9NT0RFX0NPTVBBVCkKIAkJcGFycG9ydF9pZWVlMTI4NF90ZXJtaW5hdGUgKHBvcnQpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BhcnBvcnQvcGFycG9ydF9wYy5jIGIvZHJpdmVycy9wYXJwb3J0L3BhcnBvcnRfcGMuYwppbmRleCA4ZDYyZmI3Li5hMzc1NWZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BhcnBvcnQvcGFycG9ydF9wYy5jCisrKyBiL2RyaXZlcnMvcGFycG9ydC9wYXJwb3J0X3BjLmMKQEAgLTE0ODgsNyArMTQ4OCw3IEBACiAKIAlvdXRiKGtleSwgaW8pOwogCW91dGIoa2V5LCBpbyk7ICAgICAvKiBXcml0ZSBNYWdpYyBTZXF1ZW5jZSB0byBFRkVSLCBleHRlbmRlZAotCQkJICAgICAgZnVudGlvbiBlbmFibGUgcmVnaXN0ZXIgKi8KKwkJCSAgICAgIGZ1bmN0aW9uIGVuYWJsZSByZWdpc3RlciAqLwogCW91dGIoMHgyMCwgaW8pOyAgICAvKiBXcml0ZSBFRklSLCBleHRlbmRlZCBmdW5jdGlvbiBpbmRleCByZWdpc3RlciAqLwogCWRldmlkID0gaW5iKGlvICsgMSk7ICAvKiBSZWFkIEVGRFIsIGV4dGVuZGVkIGZ1bmN0aW9uIGRhdGEgcmVnaXN0ZXIgKi8KIAlvdXRiKDB4MjEsIGlvKTsKQEAgLTE1MjcsNyArMTUyNyw3IEBACiAJeF9vbGRpZCA9IGluYihpbyArIDIpOwogCiAJb3V0YihrZXksIGlvKTsgICAgIC8qIFdyaXRlIE1hZ2ljIEJ5dGUgdG8gRUZFUiwgZXh0ZW5kZWQKLQkJCSAgICAgIGZ1bnRpb24gZW5hYmxlIHJlZ2lzdGVyICovCisJCQkgICAgICBmdW5jdGlvbiBlbmFibGUgcmVnaXN0ZXIgKi8KIAlvdXRiKDB4MjAsIGlvICsgMik7ICAvKiBXcml0ZSBFRklSLCBleHRlbmRlZCBmdW5jdGlvbiBpbmRleCByZWdpc3RlciAqLwogCWRldmlkID0gaW5iKGlvICsgMik7ICAvKiBSZWFkIEVGRFIsIGV4dGVuZGVkIGZ1bmN0aW9uIGRhdGEgcmVnaXN0ZXIgKi8KIAlvdXRiKDB4MjEsIGlvICsgMSk7CkBAIC0xNTY5LDcgKzE1NjksNyBAQAogCiAJb3V0YihrZXksIGlvKTsKIAlvdXRiKGtleSwgaW8pOyAgICAgLyogV3JpdGUgTWFnaWMgU2VxdWVuY2UgdG8gRUZFUiwgZXh0ZW5kZWQKLQkJCSAgICAgIGZ1bnRpb24gZW5hYmxlIHJlZ2lzdGVyICovCisJCQkgICAgICBmdW5jdGlvbiBlbmFibGUgcmVnaXN0ZXIgKi8KIAlvdXRiKDB4MGQsIGlvKTsgICAgLyogV3JpdGUgRUZJUiwgZXh0ZW5kZWQgZnVuY3Rpb24gaW5kZXggcmVnaXN0ZXIgKi8KIAlvbGRpZCA9IGluYihpbyArIDEpOyAgLyogUmVhZCBFRkRSLCBleHRlbmRlZCBmdW5jdGlvbiBkYXRhIHJlZ2lzdGVyICovCiAJb3V0YigweDBlLCBpbyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3RwbHVnL2FjcGlfcGNpaHAuYyBiL2RyaXZlcnMvcGNpL2hvdHBsdWcvYWNwaV9wY2locC5jCmluZGV4IDNiYzcyZDEuLjhmM2ZhZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvYWNwaV9wY2locC5jCisrKyBiL2RyaXZlcnMvcGNpL2hvdHBsdWcvYWNwaV9wY2locC5jCkBAIC0zNTEsNyArMzUxLDcgQEAKIAkgKiBUbyBoYW5kbGUgZGlmZmVyZW50IEJJT1MgYmVoYXZpb3IsIHdlIGxvb2sgZm9yIF9PU0Mgb24gYSByb290CiAJICogYnJpZGdlIHByZWZlcmVudGlhbGx5IChhY2NvcmRpbmcgdG8gUENJIGZ3IHNwZWMpLiBMYXRlciBmb3IKIAkgKiBPU0hQIHdpdGhpbiB0aGUgc2NvcGUgb2YgdGhlIGhvdHBsdWcgY29udHJvbGxlciBhbmQgaXRzIHBhcmVudHMsCi0JICogdXB0byB0aGUgaG9zdCBicmlkZ2UgdW5kZXIgd2hpY2ggdGhpcyBjb250cm9sbGVyIGV4aXN0cy4KKwkgKiB1cCB0byB0aGUgaG9zdCBicmlkZ2UgdW5kZXIgd2hpY2ggdGhpcyBjb250cm9sbGVyIGV4aXN0cy4KIAkgKi8KIAloYW5kbGUgPSBhY3BpX2ZpbmRfcm9vdF9icmlkZ2VfaGFuZGxlKHBkZXYpOwogCWlmIChoYW5kbGUpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvYWNwaXBocF9nbHVlLmMgYi9kcml2ZXJzL3BjaS9ob3RwbHVnL2FjcGlwaHBfZ2x1ZS5jCmluZGV4IGU2MTBjZmUuLjJmNjdlOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvYWNwaXBocF9nbHVlLmMKKysrIGIvZHJpdmVycy9wY2kvaG90cGx1Zy9hY3BpcGhwX2dsdWUuYwpAQCAtNTg1LDcgKzU4NSw3IEBACiAKIAkvKgogCSAqIE9uIHJvb3QgYnJpZGdlcyB3aXRoIGhvdHBsdWcgc2xvdHMgZGlyZWN0bHkgdW5kZXJuZWF0aCAoaWUsCi0JICogbm8gcDJwIGJyaWRnZSBpbmJldHdlZW4pLCB3ZSBjYWxsIGNsZWFudXBfYnJpZGdlKCkuIAorCSAqIG5vIHAycCBicmlkZ2UgYmV0d2VlbiksIHdlIGNhbGwgY2xlYW51cF9icmlkZ2UoKS4gCiAJICoKIAkgKiBUaGUgZWxzZSBjbGF1c2UgY2xlYW5zIHVwIHJvb3QgYnJpZGdlcyB0aGF0IGVpdGhlciBoYWQgbm8KIAkgKiBob3RwbHVnIHNsb3RzIGF0IGFsbCwgb3IgaGFkIGEgcDJwIGJyaWRnZSB1bmRlcm5lYXRoLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvaG90cGx1Zy9ycGFwaHBfY29yZS5jIGIvZHJpdmVycy9wY2kvaG90cGx1Zy9ycGFwaHBfY29yZS5jCmluZGV4IGVmNzQxMWMuLjc1OGFkYjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvcnBhcGhwX2NvcmUuYworKysgYi9kcml2ZXJzL3BjaS9ob3RwbHVnL3JwYXBocF9jb3JlLmMKQEAgLTI5MCw3ICsyOTAsNyBAQAogICogQGRuOiBkZXZpY2Ugbm9kZSBvZiBzbG90CiAgKgogICogVGhpcyBzdWJyb3V0aW5lIHdpbGwgcmVnaXN0ZXIgYSBob3RwbHVnYWJsZSBzbG90IHdpdGggdGhlCi0gKiBQQ0kgaG90cGx1ZyBpbmZyYXN0cnVjdHVyZS4gVGhpcyByb3V0aW5lIGlzIHR5cGljYWx5IGNhbGxlZAorICogUENJIGhvdHBsdWcgaW5mcmFzdHJ1Y3R1cmUuIFRoaXMgcm91dGluZSBpcyB0eXBpY2FsbHkgY2FsbGVkCiAgKiBkdXJpbmcgYm9vdCB0aW1lLCBpZiB0aGUgaG90cGx1ZyBzbG90cyBhcmUgcHJlc2VudCBhdCBib290IHRpbWUsCiAgKiBvciBpcyBjYWxsZWQgbGF0ZXIsIGJ5IHRoZSBkbHBhciBhZGQgY29kZSwgaWYgdGhlIHNsb3QgaXMKICAqIGJlaW5nIGR5bmFtaWNhbGx5IGFkZGVkIGR1cmluZyBydW50aW1lLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvaW50ZWwtaW9tbXUuYyBiL2RyaXZlcnMvcGNpL2ludGVsLWlvbW11LmMKaW5kZXggN2RhM2JlZi4uNTA1YzFjNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvaW50ZWwtaW9tbXUuYworKysgYi9kcml2ZXJzL3BjaS9pbnRlbC1pb21tdS5jCkBAIC0yMjY1LDcgKzIyNjUsNyBAQAogCQkvKgogCQkgKiBUQkQ6CiAJCSAqIHdlIGNvdWxkIHNoYXJlIHRoZSBzYW1lIHJvb3QgJiBjb250ZXh0IHRhYmxlcwotCQkgKiBhbW91bmcgYWxsIElPTU1VJ3MuIE5lZWQgdG8gU3BsaXQgaXQgbGF0ZXIuCisJCSAqIGFtb25nIGFsbCBJT01NVSdzLiBOZWVkIHRvIFNwbGl0IGl0IGxhdGVyLgogCQkgKi8KIAkJcmV0ID0gaW9tbXVfYWxsb2Nfcm9vdF9lbnRyeShpb21tdSk7CiAJCWlmIChyZXQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2ludHJfcmVtYXBwaW5nLmMgYi9kcml2ZXJzL3BjaS9pbnRyX3JlbWFwcGluZy5jCmluZGV4IGEyMjU1N2IuLjM2MDdmYWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2ludHJfcmVtYXBwaW5nLmMKKysrIGIvZHJpdmVycy9wY2kvaW50cl9yZW1hcHBpbmcuYwpAQCAtMjg5LDcgKzI4OSw3IEBACiAgKiBzb3VyY2UgdmFsaWRhdGlvbiB0eXBlCiAgKi8KICNkZWZpbmUgU1ZUX05PX1ZFUklGWQkJMHgwICAvKiBubyB2ZXJpZmljYXRpb24gaXMgcmVxdWlyZWQgKi8KLSNkZWZpbmUgU1ZUX1ZFUklGWV9TSURfU1EJMHgxICAvKiB2ZXJpZnkgdXNpbmcgU0lEIGFuZCBTUSBmaWVscyAqLworI2RlZmluZSBTVlRfVkVSSUZZX1NJRF9TUQkweDEgIC8qIHZlcmlmeSB1c2luZyBTSUQgYW5kIFNRIGZpZWxkcyAqLwogI2RlZmluZSBTVlRfVkVSSUZZX0JVUwkJMHgyICAvKiB2ZXJpZnkgYnVzIG9mIHJlcXVlc3QtaWQgKi8KIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2lvdmEuYyBiL2RyaXZlcnMvcGNpL2lvdmEuYwppbmRleCA3OTE0OTUxLi45NjA2ZTU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9pb3ZhLmMKKysrIGIvZHJpdmVycy9wY2kvaW92YS5jCkBAIC0zOTEsNyArMzkxLDcgQEAKIAkJCQlicmVhazsKIAl9CiAKLQkvKiBXZSBhcmUgaGVyZSBlaXRoZXIgYmVjYXN1ZSB0aGlzIGlzIHRoZSBmaXJzdCByZXNlcnZlciBub2RlCisJLyogV2UgYXJlIGhlcmUgZWl0aGVyIGJlY2F1c2UgdGhpcyBpcyB0aGUgZmlyc3QgcmVzZXJ2ZXIgbm9kZQogCSAqIG9yIG5lZWQgdG8gaW5zZXJ0IHJlbWFpbmluZyBub24gb3ZlcmxhcCBhZGRyIHJhbmdlCiAJICovCiAJaW92YSA9IF9faW5zZXJ0X25ld19yYW5nZShpb3ZhZCwgcGZuX2xvLCBwZm5faGkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpLXN5c2ZzLmMgYi9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYwppbmRleCBhOGEyNzdhLi5mOGRlYjNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYworKysgYi9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYwpAQCAtNjQ1LDcgKzY0NSw3IEBACiAgKiBhIHBlci1idXMgYmFzaXMuICBUaGlzIHJvdXRpbmUgY3JlYXRlcyB0aGUgZmlsZXMgYW5kIHRpZXMgdGhlbSBpbnRvCiAgKiB0aGVpciBhc3NvY2lhdGVkIHJlYWQsIHdyaXRlIGFuZCBtbWFwIGZpbGVzIGZyb20gcGNpLXN5c2ZzLmMKICAqCi0gKiBPbiBlcnJvciB1bndpbmQsIGJ1dCBkb24ndCBwcm9wb2dhdGUgdGhlIGVycm9yIHRvIHRoZSBjYWxsZXIKKyAqIE9uIGVycm9yIHVud2luZCwgYnV0IGRvbid0IHByb3BhZ2F0ZSB0aGUgZXJyb3IgdG8gdGhlIGNhbGxlcgogICogYXMgaXQgaXMgb2sgdG8gc2V0IHVwIHRoZSBQQ0kgYnVzIHdpdGhvdXQgdGhlc2UgZmlsZXMuCiAgKi8KIHZvaWQgcGNpX2NyZWF0ZV9sZWdhY3lfZmlsZXMoc3RydWN0IHBjaV9idXMgKmIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9xdWlya3MuYyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCmluZGV4IGJkODBmNjMuLjUxMjllZDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3F1aXJrcy5jCisrKyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCkBAIC0yNjMsNyArMjYzLDcgQEAKIAkgKglUaGlzIGhhcHBlbnMgdG8gaW5jbHVkZSB0aGUgSURFIGNvbnRyb2xsZXJzLi4uLgogCSAqCiAJICoJVklBIG9ubHkgYXBwbHkgdGhpcyBmaXggd2hlbiBhbiBTQiBMaXZlISBpcyBwcmVzZW50IGJ1dCB1bmRlcgotCSAqCWJvdGggTGludXggYW5kIFdpbmRvd3MgdGhpcyBpc250IGVub3VnaCwgYW5kIHdlIGhhdmUgc2VlbgorCSAqCWJvdGggTGludXggYW5kIFdpbmRvd3MgdGhpcyBpc24ndCBlbm91Z2gsIGFuZCB3ZSBoYXZlIHNlZW4KIAkgKgljb3JydXB0aW9uIHdpdGhvdXQgU0IgTGl2ZSEgYnV0IHdpdGggdGhpbmdzIGxpa2UgMyBVRE1BIElERQogCSAqCWNvbnRyb2xsZXJzLiBTbyB3ZSBpZ25vcmUgdGhhdCBiaXQgb2YgdGhlIFZJQSByZWNvbW1lbmRhdGlvbi4uCiAJICovCkBAIC0yNjgwLDcgKzI2ODAsNyBAQAogICogVGhpcyBpcyBhIHF1aXJrIGZvciB0aGUgUmljb2ggTU1DIGNvbnRyb2xsZXIgZm91bmQgYXMgYSBwYXJ0IG9mCiAgKiBzb21lIG11bGlmdW5jdGlvbiBjaGlwcy4KIAotICogVGhpcyBpcyB2ZXJ5IHNpbWlsaWFyIGFuZCBiYXNlZCBvbiB0aGUgcmljb2hfbW1jIGRyaXZlciB3cml0dGVuIGJ5CisgKiBUaGlzIGlzIHZlcnkgc2ltaWxhciBhbmQgYmFzZWQgb24gdGhlIHJpY29oX21tYyBkcml2ZXIgd3JpdHRlbiBieQogICogUGhpbGlwIExhbmdkYWxlLiBUaGFuayB5b3UgZm9yIHRoZXNlIG1hZ2ljIHNlcXVlbmNlcy4KICAqCiAgKiBUaGVzZSBjaGlwcyBpbXBsZW1lbnQgdGhlIGZvdXIgbWFpbiBtZW1vcnkgY2FyZCBjb250cm9sbGVycyAoU0QsIE1NQywgTVMsIHhEKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvc2V0dXAtYnVzLmMgYi9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYwppbmRleCA4OWQwYTZhLi5lYmY1MWFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYworKysgYi9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYwpAQCAtNjc2LDEwICs2NzYsMTAgQEAKIAkJCW1pbl9hbGlnbiA9IGFsaWduMSA+PiAxOwogCQlhbGlnbiArPSBhbGlnbnNbb3JkZXJdOwogCX0KLQlzaXplMCA9IGNhbGN1bGF0ZV9tZW1zaXplKHNpemUsIG1pbl9zaXplLCAwLCByZXNvdXJjZV9zaXplKGJfcmVzKSwgYWxpZ24pOworCXNpemUwID0gY2FsY3VsYXRlX21lbXNpemUoc2l6ZSwgbWluX3NpemUsIDAsIHJlc291cmNlX3NpemUoYl9yZXMpLCBtaW5fYWxpZ24pOwogCXNpemUxID0gIWFkZF9zaXplID8gc2l6ZSA6CiAJCWNhbGN1bGF0ZV9tZW1zaXplKHNpemUsIG1pbl9zaXplK2FkZF9zaXplLCAwLAotCQkJCXJlc291cmNlX3NpemUoYl9yZXMpLCBhbGlnbik7CisJCQkJcmVzb3VyY2Vfc2l6ZShiX3JlcyksIG1pbl9hbGlnbik7CiAJaWYgKCFzaXplMCAmJiAhc2l6ZTEpIHsKIAkJaWYgKGJfcmVzLT5zdGFydCB8fCBiX3Jlcy0+ZW5kKQogCQkJZGV2X2luZm8oJmJ1cy0+c2VsZi0+ZGV2LCAiZGlzYWJsaW5nIGJyaWRnZSB3aW5kb3cgIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY21jaWEvaTgyMDkyLmMgYi9kcml2ZXJzL3BjbWNpYS9pODIwOTIuYwppbmRleCBmYzc5MDZlLi4zZTQ0N2QwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjbWNpYS9pODIwOTIuYworKysgYi9kcml2ZXJzL3BjbWNpYS9pODIwOTIuYwpAQCAtNTQsNyArNTQsNyBAQAogCS5zZXRfbWVtX21hcAkJPSBpODIwOTJhYV9zZXRfbWVtX21hcCwKIH07CiAKLS8qIFRoZSBjYXJkIGNhbiBkbyB1cHRvIDQgc29ja2V0cywgYWxsb2NhdGUgYSBzdHJ1Y3R1cmUgZm9yIGVhY2ggb2YgdGhlbSAqLworLyogVGhlIGNhcmQgY2FuIGRvIHVwIHRvIDQgc29ja2V0cywgYWxsb2NhdGUgYSBzdHJ1Y3R1cmUgZm9yIGVhY2ggb2YgdGhlbSAqLwogCiBzdHJ1Y3Qgc29ja2V0X2luZm8gewogCWludAludW1iZXI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjbWNpYS9wY21jaWFfcmVzb3VyY2UuYyBiL2RyaXZlcnMvcGNtY2lhL3BjbWNpYV9yZXNvdXJjZS5jCmluZGV4IDQyZmJmMWEuLmZlNzdlODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNtY2lhL3BjbWNpYV9yZXNvdXJjZS5jCisrKyBiL2RyaXZlcnMvcGNtY2lhL3BjbWNpYV9yZXNvdXJjZS5jCkBAIC0xNzMsNyArMTczLDcgQEAKIAljID0gcF9kZXYtPmZ1bmN0aW9uX2NvbmZpZzsKIAogCWlmICghKGMtPnN0YXRlICYgQ09ORklHX0xPQ0tFRCkpIHsKLQkJZGV2X2RiZygmcF9kZXYtPmRldiwgIkNvbmZpZ3VyYXRpb24gaXNudCd0IGxvY2tlZFxuIik7CisJCWRldl9kYmcoJnBfZGV2LT5kZXYsICJDb25maWd1cmF0aW9uIGlzbid0J3QgbG9ja2VkXG4iKTsKIAkJbXV0ZXhfdW5sb2NrKCZzLT5vcHNfbXV0ZXgpOwogCQlyZXR1cm4gLUVBQ0NFUzsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjbWNpYS9weGEyeHhfbHViYm9jay5jIGIvZHJpdmVycy9wY21jaWEvcHhhMnh4X2x1YmJvY2suYwppbmRleCAyNWFmZTYzLi5jMjE4ODhlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjbWNpYS9weGEyeHhfbHViYm9jay5jCisrKyBiL2RyaXZlcnMvcGNtY2lhL3B4YTJ4eF9sdWJib2NrLmMKQEAgLTE4Nyw3ICsxODcsNyBAQAogCQkJICogV2UgbmVlZCB0byBoYWNrIGFyb3VuZCB0aGUgY29uc3QgcXVhbGlmaWVyIGFzCiAJCQkgKiB3ZWxsIHRvIGtlZXAgdGhpcyB1Z2x5IHdvcmthcm91bmQgbG9jYWxpemVkIGFuZAogCQkJICogbm90IGZvcmNlIGl0IHRvIHRoZSByZXN0IG9mIHRoZSBjb2RlLiBCYXJmIGJhZ3MKLQkJCSAqIGF2YWxpYWJsZSBpbiB0aGUgc2VhdCBwb2NrZXQgaW4gZnJvbnQgb2YgeW91IQorCQkJICogYXZhaWxhYmxlIGluIHRoZSBzZWF0IHBvY2tldCBpbiBmcm9udCBvZiB5b3UhCiAJCQkgKi8KIAkJCSgoc29ja2V0X3N0YXRlX3QgKilzdGF0ZSktPlZjYyA9IDUwOwogCQkJKChzb2NrZXRfc3RhdGVfdCAqKXN0YXRlKS0+VnBwID0gNTA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjbWNpYS90aTExM3guaCBiL2RyaXZlcnMvcGNtY2lhL3RpMTEzeC5oCmluZGV4IDlmZmE5N2QuLmE3MTc4OTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNtY2lhL3RpMTEzeC5oCisrKyBiL2RyaXZlcnMvcGNtY2lhL3RpMTEzeC5oCkBAIC02OTEsNyArNjkxLDcgQEAKIAkJLyoKIAkJICogdGhvc2UgYXJlIGVpdGhlciBzaW5nbGUgb3IgZHVhbCBzbG90IENCIHdpdGggYWRkaXRpb25hbCBmdW5jdGlvbnMKIAkJICogbGlrZSAxMzk0LCBzbWFydGNhcmQgcmVhZGVyLCBldGMuIGNoZWNrIHRoZSBUSUVBTEwgZmxhZyBmb3IgdGhlbQotCQkgKiB0aGUgVElFQUxMIGZsYWcgYmluZHMgdGhlIElSUSBvZiBhbGwgZnVuY3Rpb25zIHRvZ2hldGhlci4KKwkJICogdGhlIFRJRUFMTCBmbGFnIGJpbmRzIHRoZSBJUlEgb2YgYWxsIGZ1bmN0aW9ucyB0b2dldGhlci4KIAkJICogd2UgY2F0Y2ggdGhlIHNpbmdsZSBzbG90IHZhcmlhbnRzIGxhdGVyLgogCQkgKi8KIAkJc3lzY3RsID0gY29uZmlnX3JlYWRsKHNvY2tldCwgVEkxMTNYX1NZU1RFTV9DT05UUk9MKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2ludGVsX21pZF90aGVybWFsLmMgYi9kcml2ZXJzL3BsYXRmb3JtL3g4Ni9pbnRlbF9taWRfdGhlcm1hbC5jCmluZGV4IDZjMTJkYjUuLmMyZjRiZDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2ludGVsX21pZF90aGVybWFsLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvaW50ZWxfbWlkX3RoZXJtYWwuYwpAQCAtMjAyLDcgKzIwMiw3IEBACiAgICAgICAgaWYgKHJldCkKICAgICAgICAgICAgICAgIHJldHVybiByZXQ7CiAKLSAgICAgICAvKiBTaGlmdCBiaXRzIHRvIGFjY29tb2RhdGUgdGhlIGxvd2VyIHR3byBkYXRhIGJpdHMgKi8KKyAgICAgICAvKiBTaGlmdCBiaXRzIHRvIGFjY29tbW9kYXRlIHRoZSBsb3dlciB0d28gZGF0YSBiaXRzICovCiAgICAgICAgYWRjX3ZhbCA9IChkYXRhIDw8IDIpOwogICAgICAgIGFkZHIrKzsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wbnAvY2FyZC5jIGIvZHJpdmVycy9wbnAvY2FyZC5jCmluZGV4IDRhNjUxZjYuLmJjMDA2OTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG5wL2NhcmQuYworKysgYi9kcml2ZXJzL3BucC9jYXJkLmMKQEAgLTMyMCw3ICszMjAsNyBAQAogICogcG5wX3JlcXVlc3RfY2FyZF9kZXZpY2UgLSBTZWFyY2hlcyBmb3IgYSBQblAgZGV2aWNlIHVuZGVyIHRoZSBzcGVjaWZpZWQgY2FyZAogICogQGNsaW5rOiBwb2ludGVyIHRvIHRoZSBjYXJkIGxpbmssIGNhbm5vdCBiZSBOVUxMCiAgKiBAaWQ6IHBvaW50ZXIgdG8gYSBQblAgSUQgc3RydWN0dXJlIHRoYXQgZXhwbGFpbnMgdGhlIHJ1bGVzIGZvciBmaW5kaW5nIHRoZSBkZXZpY2UKLSAqIEBmcm9tOiBTdGFydGluZyBwbGFjZSB0byBzZWFyY2ggZnJvbS4gSWYgTlVMTCBpdCB3aWxsIHN0YXJ0IGZyb20gdGhlIGJlZ2luaW5nLgorICogQGZyb206IFN0YXJ0aW5nIHBsYWNlIHRvIHNlYXJjaCBmcm9tLiBJZiBOVUxMIGl0IHdpbGwgc3RhcnQgZnJvbSB0aGUgYmVnaW5uaW5nLgogICovCiBzdHJ1Y3QgcG5wX2RldiAqcG5wX3JlcXVlc3RfY2FyZF9kZXZpY2Uoc3RydWN0IHBucF9jYXJkX2xpbmsgKmNsaW5rLAogCQkJCQljb25zdCBjaGFyICppZCwgc3RydWN0IHBucF9kZXYgKmZyb20pCkBAIC0zNjksNyArMzY5LDcgQEAKIAogLyoqCiAgKiBwbnBfcmVsZWFzZV9jYXJkX2RldmljZSAtIGNhbGwgdGhpcyB3aGVuIHRoZSBkcml2ZXIgbm8gbG9uZ2VyIG5lZWRzIHRoZSBkZXZpY2UKLSAqIEBkZXY6IHBvaW50ZXIgdG8gdGhlIFBuUCBkZXZpY2Ugc3R1Y3R1cmUKKyAqIEBkZXY6IHBvaW50ZXIgdG8gdGhlIFBuUCBkZXZpY2Ugc3RydWN0dXJlCiAgKi8KIHZvaWQgcG5wX3JlbGVhc2VfY2FyZF9kZXZpY2Uoc3RydWN0IHBucF9kZXYgKmRldikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG5wL3BucGJpb3MvYmlvc2NhbGxzLmMgYi9kcml2ZXJzL3BucC9wbnBiaW9zL2Jpb3NjYWxscy5jCmluZGV4IDg1OTFmNmEuLmI4NTlkMTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG5wL3BucGJpb3MvYmlvc2NhbGxzLmMKKysrIGIvZHJpdmVycy9wbnAvcG5wYmlvcy9iaW9zY2FsbHMuYwpAQCAtMjE5LDcgKzIxOSw3IEBACiAJCSAgICAgICBtb2R1bGUpOwogCQlicmVhazsKIAljYXNlIFBOUF9IQVJEV0FSRV9FUlJPUjoKLQkJcHJpbnRrKEtFUk5fRVJSICJQblBCSU9TOiAlczogYSBoYXJkd2FyZSBmYWlsdXJlIGhhcyBvY2N1cmVkXG4iLAorCQlwcmludGsoS0VSTl9FUlIgIlBuUEJJT1M6ICVzOiBhIGhhcmR3YXJlIGZhaWx1cmUgaGFzIG9jY3VycmVkXG4iLAogCQkgICAgICAgbW9kdWxlKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcHBzL0tjb25maWcgYi9kcml2ZXJzL3Bwcy9LY29uZmlnCmluZGV4IGYwZDMzNzYuLjI1OGNhNTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcHBzL0tjb25maWcKKysrIGIvZHJpdmVycy9wcHMvS2NvbmZpZwpAQCAtMzUsNyArMzUsNyBAQAogCWRlcGVuZHMgb24gUFBTICYmICFOT19IWgogCWhlbHAKIAkgIFRoaXMgb3B0aW9uIGFkZHMgc3VwcG9ydCBmb3IgZGlyZWN0IGluLWtlcm5lbCB0aW1lCi0JICBzeW5jcm9uaXphdGlvbiB1c2luZyBhbiBleHRlcm5hbCBQUFMgc2lnbmFsLgorCSAgc3luY2hyb25pemF0aW9uIHVzaW5nIGFuIGV4dGVybmFsIFBQUyBzaWduYWwuCiAKIAkgIEl0IGRvZXNuJ3Qgd29yayBvbiB0aWNrbGVzcyBzeXN0ZW1zIGF0IHRoZSBtb21lbnQuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcHMzL3BzMy1scG0uYyBiL2RyaXZlcnMvcHMzL3BzMy1scG0uYwppbmRleCA4MDAwOTg1Li42NDM2OTdmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BzMy9wczMtbHBtLmMKKysrIGIvZHJpdmVycy9wczMvcHMzLWxwbS5jCkBAIC05MTksNyArOTE5LDcgQEAKICAqIEBvZmZzZXQ6IE9mZnNldCBpbiBieXRlcyBmcm9tIHRoZSBzdGFydCBvZiB0aGUgdHJhY2UgYnVmZmVyLgogICogQGJ1ZjogQ29weSBkZXN0aW5hdGlvbi4KICAqIEBjb3VudDogTWF4aW11bSBjb3VudCBvZiBieXRlcyB0byBjb3B5LgotICogQGJ5dGVzX2NvcGllZDogUG9pbnRlciB0byBhIHZhcmlhYmxlIHRoYXQgd2lsbCByZWNpZXZlIHRoZSBudW1iZXIgb2YKKyAqIEBieXRlc19jb3BpZWQ6IFBvaW50ZXIgdG8gYSB2YXJpYWJsZSB0aGF0IHdpbGwgcmVjZWl2ZSB0aGUgbnVtYmVyIG9mCiAgKiAgYnl0ZXMgY29waWVkIHRvIEBidWYuCiAgKgogICogT24gZXJyb3IgQGJ1ZiB3aWxsIGNvbnRhaW4gYW55IHN1Y2Nlc3NmdWxseSBjb3BpZWQgdHJhY2UgYnVmZmVyIGRhdGEKQEAgLTk3NCw3ICs5NzQsNyBAQAogICogQG9mZnNldDogT2Zmc2V0IGluIGJ5dGVzIGZyb20gdGhlIHN0YXJ0IG9mIHRoZSB0cmFjZSBidWZmZXIuCiAgKiBAYnVmOiBBIF9fdXNlciBjb3B5IGRlc3RpbmF0aW9uLgogICogQGNvdW50OiBNYXhpbXVtIGNvdW50IG9mIGJ5dGVzIHRvIGNvcHkuCi0gKiBAYnl0ZXNfY29waWVkOiBQb2ludGVyIHRvIGEgdmFyaWFibGUgdGhhdCB3aWxsIHJlY2lldmUgdGhlIG51bWJlciBvZgorICogQGJ5dGVzX2NvcGllZDogUG9pbnRlciB0byBhIHZhcmlhYmxlIHRoYXQgd2lsbCByZWNlaXZlIHRoZSBudW1iZXIgb2YKICAqICBieXRlcyBjb3BpZWQgdG8gQGJ1Zi4KICAqCiAgKiBPbiBlcnJvciBAYnVmIHdpbGwgY29udGFpbiBhbnkgc3VjY2Vzc2Z1bGx5IGNvcGllZCB0cmFjZSBidWZmZXIgZGF0YQpAQCAtMTA3NCw3ICsxMDc0LDcgQEAKIAogLyoqCiAgKiBwczNfbHBtX29wZW4gLSBPcGVuIHRoZSBsb2dpY2FsIHBlcmZvcm1hbmNlIG1vbml0b3IgZGV2aWNlLgotICogQHRiX3R5cGU6IFNwZWNpZmllcyB0aGUgdHlwZSBvZiB0cmFjZSBidWZmZXIgbHYxIHNvdWxkIHVzZSBmb3IgdGhpcyBscG0KKyAqIEB0Yl90eXBlOiBTcGVjaWZpZXMgdGhlIHR5cGUgb2YgdHJhY2UgYnVmZmVyIGx2MSBzaG91bGQgdXNlIGZvciB0aGlzIGxwbQogICogIGluc3RhbmNlLCBzcGVjaWZpZWQgYnkgb25lIG9mIGVudW0gcHMzX2xwbV90Yl90eXBlLgogICogQHRiX2NhY2hlOiBPcHRpb25hbCB1c2VyIHN1cHBsaWVkIGJ1ZmZlciB0byB1c2UgYXMgdGhlIHRyYWNlIGJ1ZmZlciBjYWNoZS4KICAqICBJZiBOVUxMLCB0aGUgZHJpdmVyIHdpbGwgYWxsb2NhdGUgYW5kIG1hbmFnZSBhbiBpbnRlcm5hbCBidWZmZXIuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BzMy9wczMtc3lzLW1hbmFnZXIuYyBiL2RyaXZlcnMvcHMzL3BzMy1zeXMtbWFuYWdlci5jCmluZGV4IGQzN2M0NDUuLjFiOTgzNjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcHMzL3BzMy1zeXMtbWFuYWdlci5jCisrKyBiL2RyaXZlcnMvcHMzL3BzMy1zeXMtbWFuYWdlci5jCkBAIC04MCw3ICs4MCw3IEBACiAgKgogICogQ3VycmVudGx5IGFsbCBtZXNzYWdlcyByZWNlaXZlZCBmcm9tIHRoZSBzeXN0ZW0gbWFuYWdlciBhcmUgZWl0aGVyCiAgKiAoMTYgYnl0ZXMgaGVhZGVyICsgOCBieXRlcyBwYXlsb2FkID0gMjQgYnl0ZXMpIG9yICgxNiBieXRlcyBoZWFkZXIKLSAqICsgMTYgYnl0ZXMgcGF5bG9hZCA9IDMyIGJ5dGVzKS4gIFRoaXMga25vd2xlZ2UgaXMgdXNlZCB0byBzaW1wbGlmeQorICogKyAxNiBieXRlcyBwYXlsb2FkID0gMzIgYnl0ZXMpLiAgVGhpcyBrbm93bGVkZ2UgaXMgdXNlZCB0byBzaW1wbGlmeQogICogdGhlIGxvZ2ljLgogICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmFwaWRpby9yaW8tc2Nhbi5jIGIvZHJpdmVycy9yYXBpZGlvL3Jpby1zY2FuLmMKaW5kZXggM2E1OWQ1Zi4uZWU4OTM1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9yYXBpZGlvL3Jpby1zY2FuLmMKKysrIGIvZHJpdmVycy9yYXBpZGlvL3Jpby1zY2FuLmMKQEAgLTI5NSw3ICsyOTUsNyBAQAogfQogCiAvKioKLSAqIHJpb19lbmFibGVfcnhfdHhfcG9ydCAtIGVuYWJsZSBpbnB1dCByZWNpZXZlciBhbmQgb3V0cHV0IHRyYW5zbWl0dGVyIG9mCisgKiByaW9fZW5hYmxlX3J4X3R4X3BvcnQgLSBlbmFibGUgaW5wdXQgcmVjZWl2ZXIgYW5kIG91dHB1dCB0cmFuc21pdHRlciBvZgogICogZ2l2ZW4gcG9ydAogICogQHBvcnQ6IE1hc3RlciBwb3J0IGFzc29jaWF0ZWQgd2l0aCB0aGUgUklPIG5ldHdvcmsKICAqIEBsb2NhbDogbG9jYWw9MSBzZWxlY3QgbG9jYWwgcG9ydCBvdGhlcndpc2UgYSBmYXIgZGV2aWNlIGlzIHJlYWNoZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmVndWxhdG9yL2NvcmUuYyBiL2RyaXZlcnMvcmVndWxhdG9yL2NvcmUuYwppbmRleCAzZmZjNjk3Li4wZmFlNTFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3JlZ3VsYXRvci9jb3JlLmMKKysrIGIvZHJpdmVycy9yZWd1bGF0b3IvY29yZS5jCkBAIC0xMzEzLDcgKzEzMTMsNyBAQAogCQkJCXJldHVybiAtRUlOVkFMOwogCiAJCQkvKiBRdWVyeSBiZWZvcmUgZW5hYmxpbmcgaW4gY2FzZSBjb25maWd1cmF0aW9uCi0JCQkgKiBkZXBlbmRhbnQuICAqLworCQkJICogZGVwZW5kZW50LiAgKi8KIAkJCXJldCA9IF9yZWd1bGF0b3JfZ2V0X2VuYWJsZV90aW1lKHJkZXYpOwogCQkJaWYgKHJldCA+PSAwKSB7CiAJCQkJZGVsYXkgPSByZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3JlZ3VsYXRvci9tYXg4OTUyLmMgYi9kcml2ZXJzL3JlZ3VsYXRvci9tYXg4OTUyLmMKaW5kZXggYThmNGVjZi4uZGFmZjdmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9yZWd1bGF0b3IvbWF4ODk1Mi5jCisrKyBiL2RyaXZlcnMvcmVndWxhdG9yL21heDg5NTIuYwpAQCAtMjYyLDcgKzI2Miw3IEBACiAKIAlpZiAoZXJyKSB7CiAJCWRldl93YXJuKG1heDg5NTItPmRldiwgIlZJRDAvMSBncGlvIGludmFsaWQ6ICIKLQkJCQkiRFZTIG5vdCBhdmlsYWJsZS5cbiIpOworCQkJCSJEVlMgbm90IGF2YWlsYWJsZS5cbiIpOwogCQltYXg4OTUyLT52aWQwID0gMDsKIAkJbWF4ODk1Mi0+dmlkMSA9IDA7CiAJCS8qIE1hcmsgaW52YWxpZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ydGMvaW50ZXJmYWNlLmMgYi9kcml2ZXJzL3J0Yy9pbnRlcmZhY2UuYwppbmRleCA4ZWM2YjA2Li4yMzcxOWYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3J0Yy9pbnRlcmZhY2UuYworKysgYi9kcml2ZXJzL3J0Yy9pbnRlcmZhY2UuYwpAQCAtNDU0LDcgKzQ1NCw3IEBACiAgKiBAcnRjOiBwb2ludGVyIHRvIHRoZSBydGMgZGV2aWNlCiAgKgogICogVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgd2hlbiBhbiBBSUUsIFVJRSBvciBQSUUgbW9kZSBpbnRlcnJ1cHQKLSAqIGhhcyBvY2N1cmVkIChvciBiZWVuIGVtdWxhdGVkKS4KKyAqIGhhcyBvY2N1cnJlZCAob3IgYmVlbiBlbXVsYXRlZCkuCiAgKgogICogVHJpZ2dlcnMgdGhlIHJlZ2lzdGVyZWQgaXJxX3Rhc2sgZnVuY3Rpb24gY2FsbGJhY2suCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL3J0Yy1hdDkxcm05MjAwLmMgYi9kcml2ZXJzL3J0Yy9ydGMtYXQ5MXJtOTIwMC5jCmluZGV4IDUxOGE3NmUuLmUzOWI3N2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcnRjL3J0Yy1hdDkxcm05MjAwLmMKKysrIGIvZHJpdmVycy9ydGMvcnRjLWF0OTFybTkyMDAuYwpAQCAtNjAsNyArNjAsNyBAQAogCS8qCiAJICogVGhlIENhbGVuZGFyIEFsYXJtIHJlZ2lzdGVyIGRvZXMgbm90IGhhdmUgYSBmaWVsZCBmb3IKIAkgKiB0aGUgeWVhciAtIHNvIHRoZXNlIHdpbGwgcmV0dXJuIGFuIGludmFsaWQgdmFsdWUuICBXaGVuIGFuCi0JICogYWxhcm0gaXMgc2V0LCBhdDkxX2FsYXJtX3llYXIgd2lsbGUgc3RvcmUgdGhlIGN1cnJlbnQgeWVhci4KKwkgKiBhbGFybSBpcyBzZXQsIGF0OTFfYWxhcm1feWVhciB3aWxsIHN0b3JlIHRoZSBjdXJyZW50IHllYXIuCiAJICovCiAJdG0tPnRtX3llYXIgID0gYmNkMmJpbihkYXRlICYgQVQ5MV9SVENfQ0VOVCkgKiAxMDA7CS8qIGNlbnR1cnkgKi8KIAl0bS0+dG1feWVhciArPSBiY2QyYmluKChkYXRlICYgQVQ5MV9SVENfWUVBUikgPj4gOCk7CS8qIHllYXIgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL3J0Yy1iZmluLmMgYi9kcml2ZXJzL3J0Yy9ydGMtYmZpbi5jCmluZGV4IGNhOWNmZjguLmEwZmM0Y2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcnRjL3J0Yy1iZmluLmMKKysrIGIvZHJpdmVycy9ydGMvcnRjLWJmaW4uYwpAQCAtMjAsOSArMjAsOSBAQAogICogd3JpdGUgd291bGQgYmUgZGlzY2FyZGVkIGFuZCB0aGluZ3MgcXVpY2tseSBmYWxsIGFwYXJ0LgogICoKICAqIFRvIGtlZXAgdGhpcyBkZWxheSBmcm9tIHNpZ25pZmljYW50bHkgZGVncmFkaW5nIHBlcmZvcm1hbmNlICh3ZSwgaW4gdGhlb3J5LAotICogd291bGQgaGF2ZSB0byBzbGVlcCBmb3IgdXAgdG8gMSBzZWNvbmQgZXZlcnl0aW1lIHdlIHdhbnRlZCB0byB3cml0ZSBhCisgKiB3b3VsZCBoYXZlIHRvIHNsZWVwIGZvciB1cCB0byAxIHNlY29uZCBldmVyeSB0aW1lIHdlIHdhbnRlZCB0byB3cml0ZSBhCiAgKiByZWdpc3RlciksIHdlIG9ubHkgY2hlY2sgdGhlIHdyaXRlIHBlbmRpbmcgc3RhdHVzIGJlZm9yZSB3ZSBzdGFydCB0byBpc3N1ZQotICogYSBuZXcgd3JpdGUuICBXZSBiYW5rIG9uIHRoZSBpZGVhIHRoYXQgaXQgZG9lc250IG1hdHRlciB3aGVuIHRoZSBzeW5jCisgKiBhIG5ldyB3cml0ZS4gIFdlIGJhbmsgb24gdGhlIGlkZWEgdGhhdCBpdCBkb2Vzbid0IG1hdHRlciB3aGVuIHRoZSBzeW5jCiAgKiBoYXBwZW5zIHNvIGxvbmcgYXMgd2UgZG9uJ3QgYXR0ZW1wdCBhbm90aGVyIHdyaXRlIGJlZm9yZSBpdCBkb2VzLiAgVGhlIG9ubHkKICAqIHRpbWUgdXNlcnNwYWNlIHdvdWxkIHRha2UgdGhpcyBwZW5hbHR5IGlzIHdoZW4gdGhleSB0cnkgYW5kIGRvIG11bHRpcGxlCiAgKiBvcGVyYXRpb25zIHJpZ2h0IGFmdGVyIGFub3RoZXIgLi4uIGJ1dCBpbiB0aGlzIGNhc2UsIHRoZXkgbmVlZCB0byB0YWtlIHRoZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ydGMvcnRjLWxwYzMyeHguYyBiL2RyaXZlcnMvcnRjL3J0Yy1scGMzMnh4LmMKaW5kZXggZWM4NzAxYy4uYWUxNjI1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ydGMvcnRjLWxwYzMyeHguYworKysgYi9kcml2ZXJzL3J0Yy9ydGMtbHBjMzJ4eC5jCkBAIC0yNDAsNyArMjQwLDcgQEAKIAlzcGluX2xvY2tfaW5pdCgmcnRjLT5sb2NrKTsKIAogCS8qCi0JICogVGhlIFJUQyBpcyBvbiBhIHNlcGVyYXRlIHBvd2VyIGRvbWFpbiBhbmQgY2FuIGtlZXAgaXQncyBzdGF0ZQorCSAqIFRoZSBSVEMgaXMgb24gYSBzZXBhcmF0ZSBwb3dlciBkb21haW4gYW5kIGNhbiBrZWVwIGl0J3Mgc3RhdGUKIAkgKiBhY3Jvc3MgYSBjaGlwIHBvd2VyIGN5Y2xlLiBJZiB0aGUgUlRDIGhhcyBuZXZlciBiZWVuIHByZXZpb3VzbHkKIAkgKiBzZXR1cCwgdGhlbiBzZXQgaXQgdXAgbm93IGZvciB0aGUgZmlyc3QgdGltZS4KIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL3J0Yy1tcnN0LmMgYi9kcml2ZXJzL3J0Yy9ydGMtbXJzdC5jCmluZGV4IDMzMmEyYzQuLmIyZjA5NjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcnRjL3J0Yy1tcnN0LmMKKysrIGIvZHJpdmVycy9ydGMvcnRjLW1yc3QuYwpAQCAtMzQyLDYgKzM0Miw4IEBACiAKIAltcnN0X3J0Yy5pcnEgPSBydGNfaXJxOwogCW1yc3RfcnRjLmlvbWVtID0gaW9tZW07CisJbXJzdF9ydGMuZGV2ID0gZGV2OworCWRldl9zZXRfZHJ2ZGF0YShkZXYsICZtcnN0X3J0Yyk7CiAKIAltcnN0X3J0Yy5ydGMgPSBydGNfZGV2aWNlX3JlZ2lzdGVyKGRyaXZlcl9uYW1lLCBkZXYsCiAJCQkJJm1yc3RfcnRjX29wcywgVEhJU19NT0RVTEUpOwpAQCAtMzUwLDggKzM1Miw2IEBACiAJCWdvdG8gY2xlYW51cDA7CiAJfQogCi0JbXJzdF9ydGMuZGV2ID0gZGV2OwotCWRldl9zZXRfZHJ2ZGF0YShkZXYsICZtcnN0X3J0Yyk7CiAJcmVuYW1lX3JlZ2lvbihpb21lbSwgZGV2X25hbWUoJm1yc3RfcnRjLnJ0Yy0+ZGV2KSk7CiAKIAlzcGluX2xvY2tfaXJxKCZydGNfbG9jayk7CkBAIC0zNzYsOSArMzc2LDEwIEBACiAJcmV0dXJuIDA7CiAKIGNsZWFudXAxOgotCW1yc3RfcnRjLmRldiA9IE5VTEw7CiAJcnRjX2RldmljZV91bnJlZ2lzdGVyKG1yc3RfcnRjLnJ0Yyk7CiBjbGVhbnVwMDoKKwlkZXZfc2V0X2RydmRhdGEoZGV2LCBOVUxMKTsKKwltcnN0X3J0Yy5kZXYgPSBOVUxMOwogCXJlbGVhc2VfcmVnaW9uKGlvbWVtLT5zdGFydCwgaW9tZW0tPmVuZCArIDEgLSBpb21lbS0+c3RhcnQpOwogCWRldl9lcnIoZGV2LCAicnRjLW1yc3Q6IHVuYWJsZSB0byBpbml0aWFsaXNlXG4iKTsKIAlyZXR1cm4gcmV0dmFsOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ydGMvcnRjLXgxMjA1LmMgYi9kcml2ZXJzL3J0Yy9ydGMteDEyMDUuYwppbmRleCA5YWFlNDkxLi5iMDBhYWQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3J0Yy9ydGMteDEyMDUuYworKysgYi9kcml2ZXJzL3J0Yy9ydGMteDEyMDUuYwpAQCAtNTczLDcgKzU3Myw3IEBACiAKIAlpMmNfc2V0X2NsaWVudGRhdGEoY2xpZW50LCBydGMpOwogCi0JLyogQ2hlY2sgZm9yIHBvd2VyIGZhaWx1cmVzIGFuZCBldmVudHVhbHkgZW5hYmxlIHRoZSBvc2MgKi8KKwkvKiBDaGVjayBmb3IgcG93ZXIgZmFpbHVyZXMgYW5kIGV2ZW50dWFsbHkgZW5hYmxlIHRoZSBvc2MgKi8KIAlpZiAoKGVyciA9IHgxMjA1X2dldF9zdGF0dXMoY2xpZW50LCAmc3IpKSA9PSAwKSB7CiAJCWlmIChzciAmIFgxMjA1X1NSX1JUQ0YpIHsKIAkJCWRldl9lcnIoJmNsaWVudC0+ZGV2LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfMzk5MF9lcnAuYyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkXzM5OTBfZXJwLmMKaW5kZXggMTY1NGEyNC4uODdhMGNmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfMzk5MF9lcnAuYworKysgYi9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF8zOTkwX2VycC5jCkBAIC0yMjA3LDcgKzIyMDcsNyBAQAogICogREFTRF8zOTkwX0VSUF9DT05UUk9MX0NIRUNLCiAgKgogICogREVTQ1JJUFRJT04KLSAqICAgRG9lcyBhIGdlbmVyaWMgaW5zcGVjdGlvbiBpZiBhIGNvbnRyb2wgY2hlY2sgb2NjdXJlZCBhbmQgc2V0cyB1cAorICogICBEb2VzIGEgZ2VuZXJpYyBpbnNwZWN0aW9uIGlmIGEgY29udHJvbCBjaGVjayBvY2N1cnJlZCBhbmQgc2V0cyB1cAogICogICB0aGUgcmVsYXRlZCBlcnJvciByZWNvdmVyeSBwcm9jZWR1cmUKICAqCiAgKiBQQVJBTUVURVIKQEAgLTIyNTAsNyArMjI1MCw3IEBACiAJc3RydWN0IGRhc2RfY2N3X3JlcSAqZXJwX25ldyA9IE5VTEw7CiAJY2hhciAqc2Vuc2U7CiAKLQkvKiBpZiB0aGlzIHByb2JsZW0gb2NjdXJlZCBvbiBhbiBhbGlhcyByZXRyeSBvbiBiYXNlICovCisJLyogaWYgdGhpcyBwcm9ibGVtIG9jY3VycmVkIG9uIGFuIGFsaWFzIHJldHJ5IG9uIGJhc2UgKi8KIAllcnBfbmV3ID0gZGFzZF8zOTkwX2VycF9pbnNwZWN0X2FsaWFzKGVycCk7CiAJaWYgKGVycF9uZXcpCiAJCXJldHVybiBlcnBfbmV3OwpAQCAtMjI4Miw3ICsyMjgyLDcgQEAKICAqIERBU0RfMzk5MF9FUlBfQUREX0VSUAogICoKICAqIERFU0NSSVBUSU9OCi0gKiAgIFRoaXMgZnVudGlvbiBhZGRzIGFuIGFkZGl0aW9uYWwgcmVxdWVzdCBibG9jayAoRVJQKSB0byB0aGUgaGVhZCBvZgorICogICBUaGlzIGZ1bmN0aW9uIGFkZHMgYW4gYWRkaXRpb25hbCByZXF1ZXN0IGJsb2NrIChFUlApIHRvIHRoZSBoZWFkIG9mCiAgKiAgIHRoZSBnaXZlbiBjcXIgKG9yIGVycCkuCiAgKiAgIEZvciBhIGNvbW1hbmQgbW9kZSBjcXIgdGhlIGVycCBpcyBpbml0aWFsaXplZCBhcyBhbiBkZWZhdWx0IGVycAogICogICAocmV0cnkgVElDKS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Rldm1hcC5jIGIvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfZGV2bWFwLmMKaW5kZXggY2I2YTY3Yi4uNDJlMWJmMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfZGV2bWFwLmMKKysrIGIvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfZGV2bWFwLmMKQEAgLTMwMiw3ICszMDIsNyBAQAogLyoKICAqIFRyeSB0byBpbnRlcnByZXRlIHRoZSBmaXJzdCBlbGVtZW50IG9uIHRoZSBjb21tYSBzZXBhcmF0ZWQgcGFyc2Ugc3RyaW5nCiAgKiBhcyBhIGRldmljZSBudW1iZXIgb3IgYSByYW5nZSBvZiBkZXZpY2VzLiBJZiB0aGUgaW50ZXJwcmV0YXRpb24gaXMKLSAqIHN1Y2Nlc3NmdWxsLCBjcmVhdGUgdGhlIG1hdGNoaW5nIGRhc2RfZGV2bWFwIGVudHJpZXMgYW5kIHJldHVybiBhIHBvaW50ZXIKKyAqIHN1Y2Nlc3NmdWwsIGNyZWF0ZSB0aGUgbWF0Y2hpbmcgZGFzZF9kZXZtYXAgZW50cmllcyBhbmQgcmV0dXJuIGEgcG9pbnRlcgogICogdG8gdGhlIHJlc2lkdWFsIHN0cmluZy4KICAqIElmIGludGVycHJldGF0aW9uIGZhaWxzIG9yIGluIGNhc2Ugb2YgYW4gZXJyb3IsIHJldHVybiBhbiBlcnJvciBjb2RlLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9lY2tkLmMgYi9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9lY2tkLmMKaW5kZXggNDU5ZjJjYi4uZGI4MDA1ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfZWNrZC5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Vja2QuYwpAQCAtMjg1OCw3ICsyODU4LDcgQEAKIAkvKgogCSAqIHN0cnVjdCBQRlhfZWNrZF9kYXRhIGhhcyB1cCB0byAyIGJ5dGUgYXMgZXh0ZW5kZWQgcGFyYW1ldGVyCiAJICogdGhpcyBpcyBuZWVkZWQgZm9yIHdyaXRlIGZ1bGwgdHJhY2sgYW5kIGhhcyB0byBiZSBtZW50aW9uZWQKLQkgKiBzZXBlcmF0ZWx5CisJICogc2VwYXJhdGVseQogCSAqIGFkZCA4IGluc3RlYWQgb2YgMiB0byBrZWVwIDggYnl0ZSBib3VuZGFyeQogCSAqLwogCXBmeF9kYXRhc2l6ZSA9IHNpemVvZihzdHJ1Y3QgUEZYX2Vja2RfZGF0YSkgKyA4OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NoYXIvcmF3MzI3MC5jIGIvZHJpdmVycy9zMzkwL2NoYXIvcmF3MzI3MC5jCmluZGV4IDRjMDIzNzYuLmUyMWE1YzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaGFyL3JhdzMyNzAuYworKysgYi9kcml2ZXJzL3MzOTAvY2hhci9yYXczMjcwLmMKQEAgLTYwNCw3ICs2MDQsNyBAQAogCS8qCiAJICogVG8gZGV0ZXJtaW5lIHRoZSBzaXplIG9mIHRoZSAzMjcwIGRldmljZSB3ZSBuZWVkIHRvIGRvOgogCSAqIDEpIHNlbmQgYSAncmVhZCBwYXJ0aXRpb24nIGRhdGEgc3RyZWFtIHRvIHRoZSBkZXZpY2UKLQkgKiAyKSB3YWl0IGZvciB0aGUgYXR0biBpbnRlcnJ1cHQgdGhhdCBwcmVjZWVkcyB0aGUgcXVlcnkgcmVwbHkKKwkgKiAyKSB3YWl0IGZvciB0aGUgYXR0biBpbnRlcnJ1cHQgdGhhdCBwcmVjZWRlcyB0aGUgcXVlcnkgcmVwbHkKIAkgKiAzKSBkbyBhIHJlYWQgbW9kaWZpZWQgdG8gZ2V0IHRoZSBxdWVyeSByZXBseQogCSAqIFRvIG1ha2UgdGhpbmdzIHdvcnNlIHdlIGhhdmUgdG8gY29wZSB3aXRoIGludGVydmVudGlvbgogCSAqIHJlcXVpcmVkICgzMjcwIGRldmljZSBzd2l0Y2hlZCB0byAnc3RhbmQtYnknKSBhbmQgY29tbWFuZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NoYXIvdGFwZV9jaGFyLmMgYi9kcml2ZXJzL3MzOTAvY2hhci90YXBlX2NoYXIuYwppbmRleCBlMDkwYTMwLi44N2NkMGFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY2hhci90YXBlX2NoYXIuYworKysgYi9kcml2ZXJzL3MzOTAvY2hhci90YXBlX2NoYXIuYwpAQCAtMTM5LDcgKzEzOSw3IEBACiAJLyoKIAkgKiBJZiB0aGUgdGFwZSBpc24ndCB0ZXJtaW5hdGVkIHlldCwgZG8gaXQgbm93LiBBbmQgc2luY2Ugd2UgdGhlbgogCSAqIGFyZSBhdCB0aGUgZW5kIG9mIHRoZSB0YXBlIHRoZXJlIHdvdWxkbid0IGJlIGFueXRoaW5nIHRvIHJlYWQKLQkgKiBhbnl3YXlzLiBTbyB3ZSByZXR1cm4gaW1tZWRpYXRseS4KKwkgKiBhbnl3YXlzLiBTbyB3ZSByZXR1cm4gaW1tZWRpYXRlbHkuCiAJICovCiAJaWYoZGV2aWNlLT5yZXF1aXJlZF90YXBlbWFya3MpIHsKIAkJcmV0dXJuIHRhcGVfc3RkX3Rlcm1pbmF0ZV93cml0ZShkZXZpY2UpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NoYXIvdHR5MzI3MC5jIGIvZHJpdmVycy9zMzkwL2NoYXIvdHR5MzI3MC5jCmluZGV4IGQzMzU1NGRmLi4yZGIxNDgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY2hhci90dHkzMjcwLmMKKysrIGIvZHJpdmVycy9zMzkwL2NoYXIvdHR5MzI3MC5jCkBAIC0zMjgsNyArMzI4LDcgQEAKIAogCXRwID0gKHN0cnVjdCB0dHkzMjcwICopIHJxLT52aWV3OwogCWlmIChycS0+cmMgIT0gMCkgewotCQkvKiBXcml0ZSB3YXNuJ3Qgc3VjY2Vzc2Z1bGwuIFJlZnJlc2ggYWxsLiAqLworCQkvKiBXcml0ZSB3YXNuJ3Qgc3VjY2Vzc2Z1bC4gUmVmcmVzaCBhbGwuICovCiAJCXRwLT51cGRhdGVfZmxhZ3MgPSBUVFlfVVBEQVRFX0FMTDsKIAkJdHR5MzI3MF9zZXRfdGltZXIodHAsIDEpOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlLmMgYi9kcml2ZXJzL3MzOTAvY2lvL2RldmljZS5jCmluZGV4IGRmMTRjNTEuLjhlMDRjMDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlLmMKKysrIGIvZHJpdmVycy9zMzkwL2Npby9kZXZpY2UuYwpAQCAtNTQxLDE1ICs1NDEsMjQgQEAKIAlpbnQgZm9yY2UsIHJldDsKIAl1bnNpZ25lZCBsb25nIGk7CiAKLQlpZiAoIWRldl9mc21fZmluYWxfc3RhdGUoY2RldikgJiYKLQkgICAgY2Rldi0+cHJpdmF0ZS0+c3RhdGUgIT0gREVWX1NUQVRFX0RJU0NPTk5FQ1RFRCkKLQkJcmV0dXJuIC1FQUdBSU47CisJLyogUHJldmVudCBjb25mbGljdCBiZXR3ZWVuIG11bHRpcGxlIG9uLS9vZmZsaW5lIHByb2Nlc3NpbmcgcmVxdWVzdHMuICovCiAJaWYgKGF0b21pY19jbXB4Y2hnKCZjZGV2LT5wcml2YXRlLT5vbm9mZiwgMCwgMSkgIT0gMCkKIAkJcmV0dXJuIC1FQUdBSU47CisJLyogUHJldmVudCBjb25mbGljdCBiZXR3ZWVuIGludGVybmFsIEkvT3MgYW5kIG9uLS9vZmZsaW5lIHByb2Nlc3NpbmcuICovCisJaWYgKCFkZXZfZnNtX2ZpbmFsX3N0YXRlKGNkZXYpICYmCisJICAgIGNkZXYtPnByaXZhdGUtPnN0YXRlICE9IERFVl9TVEFURV9ESVNDT05ORUNURUQpIHsKKwkJcmV0ID0gLUVBR0FJTjsKKwkJZ290byBvdXRfb25vZmY7CisJfQorCS8qIFByZXZlbnQgY29uZmxpY3QgYmV0d2VlbiBwZW5kaW5nIHdvcmsgYW5kIG9uLS9vZmZsaW5lIHByb2Nlc3NpbmcuKi8KKwlpZiAod29ya19wZW5kaW5nKCZjZGV2LT5wcml2YXRlLT50b2RvX3dvcmspKSB7CisJCXJldCA9IC1FQUdBSU47CisJCWdvdG8gb3V0X29ub2ZmOworCX0KIAogCWlmIChjZGV2LT5kcnYgJiYgIXRyeV9tb2R1bGVfZ2V0KGNkZXYtPmRydi0+ZHJpdmVyLm93bmVyKSkgewotCQlhdG9taWNfc2V0KCZjZGV2LT5wcml2YXRlLT5vbm9mZiwgMCk7Ci0JCXJldHVybiAtRUlOVkFMOworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIG91dF9vbm9mZjsKIAl9CiAJaWYgKCFzdHJuY21wKGJ1ZiwgImZvcmNlXG4iLCBjb3VudCkpIHsKIAkJZm9yY2UgPSAxOwpAQCAtNTc0LDYgKzU4Myw3IEBACiBvdXQ6CiAJaWYgKGNkZXYtPmRydikKIAkJbW9kdWxlX3B1dChjZGV2LT5kcnYtPmRyaXZlci5vd25lcik7CitvdXRfb25vZmY6CiAJYXRvbWljX3NldCgmY2Rldi0+cHJpdmF0ZS0+b25vZmYsIDApOwogCXJldHVybiAocmV0IDwgMCkgPyByZXQgOiBjb3VudDsKIH0KQEAgLTEzMTEsMTAgKzEzMjEsMTIgQEAKIAogCXNwaW5fbG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7CiAJaWYgKGlzX2JsYWNrbGlzdGVkKGlkLT5zc2lkLCBpZC0+ZGV2bm8pICYmCi0JICAgIChjZGV2LT5wcml2YXRlLT5zdGF0ZSA9PSBERVZfU1RBVEVfT0ZGTElORSkpIHsKKwkgICAgKGNkZXYtPnByaXZhdGUtPnN0YXRlID09IERFVl9TVEFURV9PRkZMSU5FKSAmJgorCSAgICAoYXRvbWljX2NtcHhjaGcoJmNkZXYtPnByaXZhdGUtPm9ub2ZmLCAwLCAxKSA9PSAwKSkgewogCQlDSU9fTVNHX0VWRU5UKDMsICJjY3c6IHB1cmdpbmcgMC4leC4lMDR4XG4iLCBpZC0+c3NpZCwKIAkJCSAgICAgIGlkLT5kZXZubyk7CiAJCWNjd19kZXZpY2Vfc2NoZWRfdG9kbyhjZGV2LCBDREVWX1RPRE9fVU5SRUcpOworCQlhdG9taWNfc2V0KCZjZGV2LT5wcml2YXRlLT5vbm9mZiwgMCk7CiAJfQogCXNwaW5fdW5sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKIAkvKiBBYm9ydCBsb29wIGluIGNhc2Ugb2YgcGVuZGluZyBzaWduYWwuICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY2lvL2RldmljZV9mc20uYyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlX2ZzbS5jCmluZGV4IGE4NDU2OTUuLjYwODQxMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlX2ZzbS5jCisrKyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlX2ZzbS5jCkBAIC0zMTgsNyArMzE4LDcgQEAKIAogLyoqCiAgICogY2N3X2RldmljZV9ub3RpZnkoKSAtIGluZm9ybSB0aGUgZGV2aWNlJ3MgZHJpdmVyIGFib3V0IGFuIGV2ZW50Ci0gICogQGNkZXY6IGRldmljZSBmb3Igd2hpY2ggYW4gZXZlbnQgb2NjdXJlZAorICAqIEBjZGV2OiBkZXZpY2UgZm9yIHdoaWNoIGFuIGV2ZW50IG9jY3VycmVkCiAgICogQGV2ZW50OiBldmVudCB0aGF0IG9jY3VycmVkCiAgICoKICAgKiBSZXR1cm5zOgpAQCAtNjg4LDcgKzY4OCw3IEBACiAJICAgIChzY3N3X3N0Y3RsKCZjZGV2LT5wcml2YXRlLT5pcmIuc2NzdykgJiBTQ1NXX1NUQ1RMX1NUQVRVU19QRU5EKSkgewogCQkvKgogCQkgKiBObyBmaW5hbCBzdGF0dXMgeWV0IG9yIGZpbmFsIHN0YXR1cyBub3QgeWV0IGRlbGl2ZXJlZAotCQkgKiB0byB0aGUgZGV2aWNlIGRyaXZlci4gQ2FuJ3QgZG8gcGF0aCB2ZXJmaWNhdGlvbiBub3csCisJCSAqIHRvIHRoZSBkZXZpY2UgZHJpdmVyLiBDYW4ndCBkbyBwYXRoIHZlcmlmaWNhdGlvbiBub3csCiAJCSAqIGRlbGF5IHVudGlsIGZpbmFsIHN0YXR1cyB3YXMgZGVsaXZlcmVkLgogCQkgKi8KIAkJY2Rldi0+cHJpdmF0ZS0+ZmxhZ3MuZG92ZXJpZnkgPSAxOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2Npby9xZGlvX21haW4uYyBiL2RyaXZlcnMvczM5MC9jaW8vcWRpb19tYWluLmMKaW5kZXggNDc5YzY2NS4uYzUzMmJhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2Npby9xZGlvX21haW4uYworKysgYi9kcml2ZXJzL3MzOTAvY2lvL3FkaW9fbWFpbi5jCkBAIC0xNjQ5LDI2ICsxNjQ5LDI2IEBACiB7CiAJaW50IHJjOwogCi0JcmMgPSBxZGlvX3NldHVwX2luaXQoKTsKKwlyYyA9IHFkaW9fZGVidWdfaW5pdCgpOwogCWlmIChyYykKIAkJcmV0dXJuIHJjOworCXJjID0gcWRpb19zZXR1cF9pbml0KCk7CisJaWYgKHJjKQorCQlnb3RvIG91dF9kZWJ1ZzsKIAlyYyA9IHRpcWRpb19hbGxvY2F0ZV9tZW1vcnkoKTsKIAlpZiAocmMpCiAJCWdvdG8gb3V0X2NhY2hlOwotCXJjID0gcWRpb19kZWJ1Z19pbml0KCk7Ci0JaWYgKHJjKQotCQlnb3RvIG91dF90aTsKIAlyYyA9IHRpcWRpb19yZWdpc3Rlcl90aGluaW50cygpOwogCWlmIChyYykKLQkJZ290byBvdXRfZGVidWc7CisJCWdvdG8gb3V0X3RpOwogCXJldHVybiAwOwogCi1vdXRfZGVidWc6Ci0JcWRpb19kZWJ1Z19leGl0KCk7CiBvdXRfdGk6CiAJdGlxZGlvX2ZyZWVfbWVtb3J5KCk7CiBvdXRfY2FjaGU6CiAJcWRpb19zZXR1cF9leGl0KCk7CitvdXRfZGVidWc6CisJcWRpb19kZWJ1Z19leGl0KCk7CiAJcmV0dXJuIHJjOwogfQogCkBAIC0xNjc2LDggKzE2NzYsOCBAQAogewogCXRpcWRpb191bnJlZ2lzdGVyX3RoaW5pbnRzKCk7CiAJdGlxZGlvX2ZyZWVfbWVtb3J5KCk7Ci0JcWRpb19kZWJ1Z19leGl0KCk7CiAJcWRpb19zZXR1cF9leGl0KCk7CisJcWRpb19kZWJ1Z19leGl0KCk7CiB9CiAKIG1vZHVsZV9pbml0KGluaXRfUURJTyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY3J5cHRvL3pjcnlwdF9hcGkuaCBiL2RyaXZlcnMvczM5MC9jcnlwdG8vemNyeXB0X2FwaS5oCmluZGV4IDg4ZWJkMTEuLjk2ODhmMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jcnlwdG8vemNyeXB0X2FwaS5oCisrKyBiL2RyaXZlcnMvczM5MC9jcnlwdG8vemNyeXB0X2FwaS5oCkBAIC03Niw3ICs3Niw3IEBACiAKIC8qKgogICogTGFyZ2UgcmFuZG9tIG51bWJlcnMgYXJlIHB1bGxlZCBpbiA0MDk2IGJ5dGUgY2h1bmtzIGZyb20gdGhlIGNyeXB0byBjYXJkcwotICogYW5kIHN0b3JlZCBpbiBhIHBhZ2UuIEJlIGNhcmVmdWxsIHdoZW4gaW5jcmVhc2luZyB0aGlzIGJ1ZmZlciBkdWUgdG8gc2l6ZQorICogYW5kIHN0b3JlZCBpbiBhIHBhZ2UuIEJlIGNhcmVmdWwgd2hlbiBpbmNyZWFzaW5nIHRoaXMgYnVmZmVyIGR1ZSB0byBzaXplCiAgKiBsaW1pdGF0aW9ucyBmb3IgQVAgcmVxdWVzdHMuCiAgKi8KICNkZWZpbmUgWkNSWVBUX1JOR19CVUZGRVJfU0laRQk0MDk2CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvbmV0L2NsYXcuYyBiL2RyaXZlcnMvczM5MC9uZXQvY2xhdy5jCmluZGV4IDlmZWI2MmYuLmRhOGFhNzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9uZXQvY2xhdy5jCisrKyBiL2RyaXZlcnMvczM5MC9uZXQvY2xhdy5jCkBAIC03NzksNyArNzc5LDcgQEAKIAljYXNlIENMQVdfU1RBUlRfV1JJVEU6CiAJCWlmIChwX2NoLT5pcmItPnNjc3cuY21kLmRzdGF0ICYgREVWX1NUQVRfVU5JVF9DSEVDSykgewogCQkJZGV2X2luZm8oJmNkZXYtPmRldiwKLQkJCQkiJXM6IFVuaXQgQ2hlY2sgT2NjdXJlZCBpbiAiCisJCQkJIiVzOiBVbml0IENoZWNrIE9jY3VycmVkIGluICIKIAkJCQkid3JpdGUgY2hhbm5lbFxuIiwgZGV2LT5uYW1lKTsKIAkJCWNsZWFyX2JpdCgwLCAodm9pZCAqKSZwX2NoLT5JT19hY3RpdmUpOwogCQkJaWYgKHBfY2gtPmlyYi0+ZWN3WzBdICYgMHg4MCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL25ldC9jdGNtX2ZzbXMuYyBiL2RyaXZlcnMvczM5MC9uZXQvY3RjbV9mc21zLmMKaW5kZXggOGM5MjFmYy4uMmQ2MDIyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL25ldC9jdGNtX2ZzbXMuYworKysgYi9kcml2ZXJzL3MzOTAvbmV0L2N0Y21fZnNtcy5jCkBAIC0xODQsNyArMTg0LDcgQEAKIHN0YXRpYyB2b2lkIGN0Y21wY19jaHhfc2VuZF9zd2VlcChmc21faW5zdGFuY2UgKmZzbSwgaW50IGV2ZW50LCB2b2lkICphcmcpOwogCiAvKioKLSAqIENoZWNrIHJldHVybiBjb2RlIG9mIGEgcHJlY2VlZGluZyBjY3dfZGV2aWNlIGNhbGwsIGhhbHRfSU8gZXRjLi4uCisgKiBDaGVjayByZXR1cm4gY29kZSBvZiBhIHByZWNlZGluZyBjY3dfZGV2aWNlIGNhbGwsIGhhbHRfSU8gZXRjLi4uCiAgKgogICogY2gJOglUaGUgY2hhbm5lbCwgdGhlIGVycm9yIGJlbG9uZ3MgdG8uCiAgKiBSZXR1cm5zIHRoZSBlcnJvciBjb2RlICghPSAwKSB0byBpbnNwZWN0LgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL25ldC9sY3MuYyBiL2RyaXZlcnMvczM5MC9uZXQvbGNzLmMKaW5kZXggN2ZiYzRhZC4uNDlkMWNmYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL25ldC9sY3MuYworKysgYi9kcml2ZXJzL3MzOTAvbmV0L2xjcy5jCkBAIC0xMTIzLDcgKzExMjMsNyBAQAogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShpcG0sIHRtcCwgJmNhcmQtPmlwbV9saXN0LCBsaXN0KXsKIAkJc3dpdGNoIChpcG0tPmlwbV9zdGF0ZSkgewogCQljYXNlIExDU19JUE1fU1RBVEVfU0VUX1JFUVVJUkVEOgotCQkJLyogZGVsIGZyb20gaXBtX2xpc3Qgc28gbm9vbmUgZWxzZSBjYW4gdGFtcGVyIHdpdGgKKwkJCS8qIGRlbCBmcm9tIGlwbV9saXN0IHNvIG5vIG9uZSBlbHNlIGNhbiB0YW1wZXIgd2l0aAogCQkJICogdGhpcyBlbnRyeSAqLwogCQkJbGlzdF9kZWxfaW5pdCgmaXBtLT5saXN0KTsKIAkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmlwbV9sb2NrLCBmbGFncyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvbmV0L3FldGhfY29yZV9tYWluLmMgYi9kcml2ZXJzL3MzOTAvbmV0L3FldGhfY29yZV9tYWluLmMKaW5kZXggMTBhM2EzYi4uODVjYzUzMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL25ldC9xZXRoX2NvcmVfbWFpbi5jCisrKyBiL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9jb3JlX21haW4uYwpAQCAtMTEwNyw3ICsxMTA3LDcgQEAKIAlJTklUX0xJU1RfSEVBRChjYXJkLT5pcF90YmRfbGlzdCk7CiAJSU5JVF9MSVNUX0hFQUQoJmNhcmQtPmNtZF93YWl0ZXJfbGlzdCk7CiAJaW5pdF93YWl0cXVldWVfaGVhZCgmY2FyZC0+d2FpdF9xKTsKLQkvKiBpbnRpYWwgb3B0aW9ucyAqLworCS8qIGluaXRpYWwgb3B0aW9ucyAqLwogCXFldGhfc2V0X2ludGlhbF9vcHRpb25zKGNhcmQpOwogCS8qIElQIGFkZHJlc3MgdGFrZW92ZXIgKi8KIAlJTklUX0xJU1RfSEVBRCgmY2FyZC0+aXBhdG8uZW50cmllcyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2ZzZi5jIGIvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9mc2YuYwppbmRleCBhMGUwNWVmLi44NTEyYjVjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2ZzZi5jCisrKyBiL2RyaXZlcnMvczM5MC9zY3NpL3pmY3BfZnNmLmMKQEAgLTEwODMsNyArMTA4Myw3IEBACiAJCX0KIAkJYnJlYWs7CiAJY2FzZSBGU0ZfU0JBTF9NSVNNQVRDSDoKLQkJLyogc2hvdWxkIG5ldmVyIG9jY3VyZSwgYXZvaWRlZCBpbiB6ZmNwX2ZzZl9zZW5kX2VscyAqLworCQkvKiBzaG91bGQgbmV2ZXIgb2NjdXIsIGF2b2lkZWQgaW4gemZjcF9mc2Zfc2VuZF9lbHMgKi8KIAkJLyogZmFsbCB0aHJvdWdoICovCiAJZGVmYXVsdDoKIAkJcmVxLT5zdGF0dXMgfD0gWkZDUF9TVEFUVVNfRlNGUkVRX0VSUk9SOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9xZGlvLmMgYi9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX3FkaW8uYwppbmRleCA4ZGE1ZWQ2Li45OGU5N2Q5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX3FkaW8uYworKysgYi9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX3FkaW8uYwpAQCAtMzkxLDcgKzM5MSw3IEBACiAJaWYgKGRvX1FESU8oY2RldiwgUURJT19GTEFHX1NZTkNfSU5QVVQsIDAsIDAsIFFESU9fTUFYX0JVRkZFUlNfUEVSX1EpKQogCQlnb3RvIGZhaWxlZF9xZGlvOwogCi0JLyogc2V0IGluZGV4IG9mIGZpcnN0IGF2YWxhYmxlIFNCQUxTIC8gbnVtYmVyIG9mIGF2YWlsYWJsZSBTQkFMUyAqLworCS8qIHNldCBpbmRleCBvZiBmaXJzdCBhdmFpbGFibGUgU0JBTFMgLyBudW1iZXIgb2YgYXZhaWxhYmxlIFNCQUxTICovCiAJcWRpby0+cmVxX3FfaWR4ID0gMDsKIAlhdG9taWNfc2V0KCZxZGlvLT5yZXFfcV9mcmVlLCBRRElPX01BWF9CVUZGRVJTX1BFUl9RKTsKIAlhdG9taWNfc2V0X21hc2soWkZDUF9TVEFUVVNfQURBUFRFUl9RRElPVVAsICZxZGlvLT5hZGFwdGVyLT5zdGF0dXMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zYnVzL2NoYXIvanNmbGFzaC5jIGIvZHJpdmVycy9zYnVzL2NoYXIvanNmbGFzaC5jCmluZGV4IGU4NTY2MjIuLjZiNDY3OGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2J1cy9jaGFyL2pzZmxhc2guYworKysgYi9kcml2ZXJzL3NidXMvY2hhci9qc2ZsYXNoLmMKQEAgLTEzLDcgKzEzLDcgQEAKICAqIFRPRE86IEVyYXNlL3Byb2dyYW0gYm90aCBiYW5rcyBvZiBhIDhNQiBTSU1NLgogICoKICAqIEl0IGlzIGFudGljaXBhdGVkIHRoYXQgcHJvZ3JhbW1pbmcgYW4gT1MgRmxhc2ggd2lsbCBiZSBhIHJvdXRpbmUKLSAqIHByb2NlZHVyZS4gSW4gdGhlIHNhbWUgdGltZSBpdCBpcyBleGVlZGluZ2x5IGRhbmdlcm91cyBiZWNhdXNlCisgKiBwcm9jZWR1cmUuIEluIHRoZSBzYW1lIHRpbWUgaXQgaXMgZXhjZWVkaW5nbHkgZGFuZ2Vyb3VzIGJlY2F1c2UKICAqIGEgdXNlciBjYW4gcHJvZ3JhbSBpdHMgT0JQIGZsYXNoIHdpdGggT1MgaW1hZ2UgYW5kIGVmZmVjdGl2ZWx5CiAgKiBraWxsIHRoZSBtYWNoaW5lLgogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2J1cy9jaGFyL21heDE2MTcuaCBiL2RyaXZlcnMvc2J1cy9jaGFyL21heDE2MTcuaAppbmRleCAwYmIwOWMyLi5jZDMwODE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3NidXMvY2hhci9tYXgxNjE3LmgKKysrIGIvZHJpdmVycy9zYnVzL2NoYXIvbWF4MTYxNy5oCkBAIC02LDcgKzYsNyBAQAogI2RlZmluZSBNQVgxNjE3X0NQVV9URU1QCTB4MDEgLyogUHJvY2Vzc29yIGRpZSB0ZW1wIGluIEMJKi8KICNkZWZpbmUgTUFYMTYxN19TVEFUVVMJCTB4MDIgLyogQ2hpcCBzdGF0dXMgYml0cwkqLwogCi0vKiBSZWFkLW9ubHkgdmVyc2lvbnMgb2YgY2hhbmdhYmxlIHJlZ2lzdGVycy4gKi8KKy8qIFJlYWQtb25seSB2ZXJzaW9ucyBvZiBjaGFuZ2VhYmxlIHJlZ2lzdGVycy4gKi8KICNkZWZpbmUgTUFYMTYxN19SRF9DRkdfQllURQkweDAzIC8qIENvbmZpZyByZWdpc3RlcgkJKi8KICNkZWZpbmUgTUFYMTYxN19SRF9DVlJBVEVfQllURQkweDA0IC8qIFRlbXAgY29udmVyc2lvbiByYXRlCSovCiAjZGVmaW5lIE1BWDE2MTdfUkRfQU1CX0hJR0hMSU0JMHgwNSAvKiBBbWJpZW50IGhpZ2ggbGltaXQJKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS8zdy05eHh4LmggYi9kcml2ZXJzL3Njc2kvM3ctOXh4eC5oCmluZGV4IDMzNDM4MjQuLjA0MGY3MjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS8zdy05eHh4LmgKKysrIGIvZHJpdmVycy9zY3NpLzN3LTl4eHguaApAQCAtNjEsNyArNjEsNyBAQAogCXsweDAwMDAsICJBRU4gcXVldWUgZW1wdHkifSwKIAl7MHgwMDAxLCAiQ29udHJvbGxlciByZXNldCBvY2N1cnJlZCJ9LAogCXsweDAwMDIsICJEZWdyYWRlZCB1bml0IGRldGVjdGVkIn0sCi0JezB4MDAwMywgIkNvbnRyb2xsZXIgZXJyb3Igb2NjdXJlZCJ9LAorCXsweDAwMDMsICJDb250cm9sbGVyIGVycm9yIG9jY3VycmVkIn0sCiAJezB4MDAwNCwgIkJhY2tncm91bmQgcmVidWlsZCBmYWlsZWQifSwKIAl7MHgwMDA1LCAiQmFja2dyb3VuZCByZWJ1aWxkIGRvbmUifSwKIAl7MHgwMDA2LCAiSW5jb21wbGV0ZSB1bml0IGRldGVjdGVkIn0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvM3cteHh4eC5oIGIvZHJpdmVycy9zY3NpLzN3LXh4eHguaAppbmRleCA4YjlmOWQxLi40OWRjZjAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvM3cteHh4eC5oCisrKyBiL2RyaXZlcnMvc2NzaS8zdy14eHh4LmgKQEAgLTgsNyArOCw3IEBACiAKICAgIENvcHlyaWdodCAoQykgMTk5OS0yMDEwIDN3YXJlIEluYy4KIAotICAgS2VybmVsIGNvbXBhdGlibGl0eSBCeToJQW5kcmUgSGVkcmljayA8YW5kcmVAc3VzZS5jb20+CisgICBLZXJuZWwgY29tcGF0aWJpbGl0eSBCeToJQW5kcmUgSGVkcmljayA8YW5kcmVAc3VzZS5jb20+CiAgICBOb24tQ29weXJpZ2h0IChDKSAyMDAwCUFuZHJlIEhlZHJpY2sgPGFuZHJlQHN1c2UuY29tPgogCiAgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpLzUzYzcwMC5zY3IgYi9kcml2ZXJzL3Njc2kvNTNjNzAwLnNjcgppbmRleCBhMDY0YTA5Li5lYzgyMmUzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvNTNjNzAwLnNjcgorKysgYi9kcml2ZXJzL3Njc2kvNTNjNzAwLnNjcgpAQCAtMzEsNyArMzEsNyBAQAogQUJTT0xVVEUJUmVjZWl2ZU1zZ0FkZHJlc3MgPSAwCTsgQWRkciB0byByZWNlaXZlIG1zZwogOwogOyBUaGlzIGlzIHRoZSBtYWdpYyBjb21wb25lbnQgZm9yIGhhbmRsaW5nIHNjYXR0ZXItZ2F0aGVyLiAgRWFjaCBvZiB0aGUKLTsgU0cgY29tcG9uZW50cyBpcyBwcmVjZWVkZWQgYnkgYSBzY3JpcHQgZnJhZ21lbnQgd2hpY2ggbW92ZXMgdGhlCis7IFNHIGNvbXBvbmVudHMgaXMgcHJlY2VkZWQgYnkgYSBzY3JpcHQgZnJhZ21lbnQgd2hpY2ggbW92ZXMgdGhlCiA7IG5lY2Vzc2FyeSBhbW91bnQgb2YgZGF0YSBhbmQganVtcHMgdG8gdGhlIG5leHQgU0cgc2VnbWVudC4gIFRoZSBmaW5hbAogOyBTRyBzZWdtZW50IGp1bXBzIGJhY2sgdG8gLiAgSG93ZXZlciwgdGhpcyBhZGRyZXNzIGlzIHRoZSBmaXJzdCBTRyBzY3JpcHQKIDsgc2VnbWVudC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS81M2M3MDBfZC5oX3NoaXBwZWQgYi9kcml2ZXJzL3Njc2kvNTNjNzAwX2QuaF9zaGlwcGVkCmluZGV4IDBiNDJhNTEuLmFhNjIzZGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS81M2M3MDBfZC5oX3NoaXBwZWQKKysrIGIvZHJpdmVycy9zY3NpLzUzYzcwMF9kLmhfc2hpcHBlZApAQCAtMzQsNyArMzQsNyBAQAogQUJTT0xVVEUJUmVjZWl2ZU1zZ0FkZHJlc3MgPSAwCTsgQWRkciB0byByZWNlaXZlIG1zZwogOwogOyBUaGlzIGlzIHRoZSBtYWdpYyBjb21wb25lbnQgZm9yIGhhbmRsaW5nIHNjYXR0ZXItZ2F0aGVyLiAgRWFjaCBvZiB0aGUKLTsgU0cgY29tcG9uZW50cyBpcyBwcmVjZWVkZWQgYnkgYSBzY3JpcHQgZnJhZ21lbnQgd2hpY2ggbW92ZXMgdGhlCis7IFNHIGNvbXBvbmVudHMgaXMgcHJlY2VkZWQgYnkgYSBzY3JpcHQgZnJhZ21lbnQgd2hpY2ggbW92ZXMgdGhlCiA7IG5lY2Vzc2FyeSBhbW91bnQgb2YgZGF0YSBhbmQganVtcHMgdG8gdGhlIG5leHQgU0cgc2VnbWVudC4gIFRoZSBmaW5hbAogOyBTRyBzZWdtZW50IGp1bXBzIGJhY2sgdG8gLiAgSG93ZXZlciwgdGhpcyBhZGRyZXNzIGlzIHRoZSBmaXJzdCBTRyBzY3JpcHQKIDsgc2VnbWVudC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9GbGFzaFBvaW50LmMgYi9kcml2ZXJzL3Njc2kvRmxhc2hQb2ludC5jCmluZGV4IGU0MGNkZmIuLmRjZDcxNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9GbGFzaFBvaW50LmMKKysrIGIvZHJpdmVycy9zY3NpL0ZsYXNoUG9pbnQuYwpAQCAtMjUwOSw3ICsyNTA5LDcgQEAKIAkJCQlXUl9IQVJQT09OKHBvcnQgKyBocF9hdXRvc3RhcnRfMywKIAkJCQkJICAgKFNFTEVDVCArIFNFTENIS19TVFJUKSk7CiAKLQkJCQkvKiBTZXR1cCBvdXIgU1RBVEUgc28gd2Uga25vdyB3aGF0IGhhcHBlbmQgd2hlbgorCQkJCS8qIFNldHVwIG91ciBTVEFURSBzbyB3ZSBrbm93IHdoYXQgaGFwcGVuZWQgd2hlbgogCQkJCSAgIHRoZSB3aGVlbHMgZmFsbCBvZmYuICovCiAJCQkJY3VyclNDQ0ItPlNjY2Jfc2NzaXN0YXQgPSBTRUxFQ1RfU1Q7CiAKQEAgLTI5MDAsNyArMjkwMCw3IEBACiAgKgogICogRnVuY3Rpb246IEZQVF9zZGVjbQogICoKLSAqIERlc2NyaXB0aW9uOiBEZXRlcm1pbmUgdGhlIHByb3BlciByZXNwb25jZSB0byB0aGUgbWVzc2FnZSBmcm9tIHRoZQorICogRGVzY3JpcHRpb246IERldGVybWluZSB0aGUgcHJvcGVyIHJlc3BvbnNlIHRvIHRoZSBtZXNzYWdlIGZyb20gdGhlCiAgKiAgICAgICAgICAgICAgdGFyZ2V0IGRldmljZS4KICAqCiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvTkNSNTM4MC5jIGIvZHJpdmVycy9zY3NpL05DUjUzODAuYwppbmRleCBlN2NkMmZjLi4xNjVlNGRkODYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9OQ1I1MzgwLmMKKysrIGIvZHJpdmVycy9zY3NpL05DUjUzODAuYwpAQCAtMTE5OCwxMiArMTE5OCwxMiBAQAogCQkJCSAqLwogCiAJCQkJaWYgKChOQ1I1MzgwX3JlYWQoTU9ERV9SRUcpICYgTVJfRE1BKSAmJiAoKGJhc3IgJiBCQVNSX0VORF9ETUFfVFJBTlNGRVIpIHx8ICEoYmFzciAmIEJBU1JfUEhBU0VfTUFUQ0gpKSkgewotCQkJCQlpbnQgdHJhbnNmZXJlZDsKKwkJCQkJaW50IHRyYW5zZmVycmVkOwogCiAJCQkJCWlmICghaG9zdGRhdGEtPmNvbm5lY3RlZCkKIAkJCQkJCXBhbmljKCJzY3NpJWQgOiByZWNlaXZlZCBlbmQgb2YgRE1BIGludGVycnVwdCB3aXRoIG5vIGNvbm5lY3RlZCBjbWRcbiIsIGluc3RhbmNlLT5ob3N0bm8pOwogCi0JCQkJCXRyYW5zZmVyZWQgPSAoaG9zdGRhdGEtPmRtYWxlbiAtIE5DUjUzODBfZG1hX3Jlc2lkdWFsKGluc3RhbmNlKSk7CisJCQkJCXRyYW5zZmVycmVkID0gKGhvc3RkYXRhLT5kbWFsZW4gLSBOQ1I1MzgwX2RtYV9yZXNpZHVhbChpbnN0YW5jZSkpOwogCQkJCQlob3N0ZGF0YS0+Y29ubmVjdGVkLT5TQ3AudGhpc19yZXNpZHVhbCAtPSB0cmFuc2ZlcnJlZDsKIAkJCQkJaG9zdGRhdGEtPmNvbm5lY3RlZC0+U0NwLnB0ciArPSB0cmFuc2ZlcnJlZDsKIAkJCQkJaG9zdGRhdGEtPmRtYWxlbiA9IDA7CkBAIC0xNTYzLDcgKzE1NjMsNyBAQAogICogICAgICBieXRlcyB0byB0cmFuc2ZlciwgKipkYXRhIC0gcG9pbnRlciB0byBkYXRhIHBvaW50ZXIuCiAgKiAKICAqIFJldHVybnMgOiAtMSB3aGVuIGRpZmZlcmVudCBwaGFzZSBpcyBlbnRlcmVkIHdpdGhvdXQgdHJhbnNmZXJyaW5nCi0gKiAgICAgIG1heGltdW0gbnVtYmVyIG9mIGJ5dGVzLCAwIGlmIGFsbCBieXRlcyBvciB0cmFuc2ZlcmVkIG9yIGV4aXQKKyAqICAgICAgbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMsIDAgaWYgYWxsIGJ5dGVzIG9yIHRyYW5zZmVycmVkIG9yIGV4aXQKICAqICAgICAgaXMgaW4gc2FtZSBwaGFzZS4KICAqCiAgKiAgICAgIEFsc28sICpwaGFzZSwgKmNvdW50LCAqZGF0YSBhcmUgbW9kaWZpZWQgaW4gcGxhY2UuCkBAIC0xODAwLDcgKzE4MDAsNyBAQAogICogICAgICBieXRlcyB0byB0cmFuc2ZlciwgKipkYXRhIC0gcG9pbnRlciB0byBkYXRhIHBvaW50ZXIuCiAgKiAKICAqIFJldHVybnMgOiAtMSB3aGVuIGRpZmZlcmVudCBwaGFzZSBpcyBlbnRlcmVkIHdpdGhvdXQgdHJhbnNmZXJyaW5nCi0gKiAgICAgIG1heGltdW0gbnVtYmVyIG9mIGJ5dGVzLCAwIGlmIGFsbCBieXRlcyBvciB0cmFuc2ZlcmVkIG9yIGV4aXQKKyAqICAgICAgbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMsIDAgaWYgYWxsIGJ5dGVzIG9yIHRyYW5zZmVycmVkIG9yIGV4aXQKICAqICAgICAgaXMgaW4gc2FtZSBwaGFzZS4KICAqCiAgKiAgICAgIEFsc28sICpwaGFzZSwgKmNvdW50LCAqZGF0YSBhcmUgbW9kaWZpZWQgaW4gcGxhY2UuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYWFjcmFpZC9hYWNoYmEuYyBiL2RyaXZlcnMvc2NzaS9hYWNyYWlkL2FhY2hiYS5jCmluZGV4IDExOGNlODMuLjA2MTk5NTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hYWNyYWlkL2FhY2hiYS5jCisrKyBiL2RyaXZlcnMvc2NzaS9hYWNyYWlkL2FhY2hiYS5jCkBAIC03NDcsOCArNzQ3LDggQEAKICAqIEFyZ3VtZW50czogWzFdIHBvaW50ZXIgdG8gdm9pZCBbMV0gaW50CiAgKgogICogUHVycG9zZTogU2V0cyBTQ1NJIGlucXVpcnkgZGF0YSBzdHJpbmdzIGZvciB2ZW5kb3IsIHByb2R1Y3QKLSAqIGFuZCByZXZpc2lvbiBsZXZlbC4gQWxsb3dzIHN0cmluZ3MgdG8gYmUgc2V0IGluIHBsYXRmb3JtIGRlcGVuZGFudAotICogZmlsZXMgaW5zdGVhZCBvZiBpbiBPUyBkZXBlbmRhbnQgZHJpdmVyIHNvdXJjZS4KKyAqIGFuZCByZXZpc2lvbiBsZXZlbC4gQWxsb3dzIHN0cmluZ3MgdG8gYmUgc2V0IGluIHBsYXRmb3JtIGRlcGVuZGVudAorICogZmlsZXMgaW5zdGVhZCBvZiBpbiBPUyBkZXBlbmRlbnQgZHJpdmVyIHNvdXJjZS4KICAqLwogCiBzdGF0aWMgdm9pZCBzZXRpbnFzdHIoc3RydWN0IGFhY19kZXYgKmRldiwgdm9pZCAqZGF0YSwgaW50IHRpbmRleCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9hYWNyYWlkL2FhY3JhaWQuaCBiL2RyaXZlcnMvc2NzaS9hYWNyYWlkL2FhY3JhaWQuaAppbmRleCAyOWFiMDAwLi5mZmI1ODc4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWFjcmFpZC9hYWNyYWlkLmgKKysrIGIvZHJpdmVycy9zY3NpL2FhY3JhaWQvYWFjcmFpZC5oCkBAIC0xMjU5LDcgKzEyNTksNyBAQAogI2RlZmluZSBDQUNIRV9VTlNUQUJMRQkJMgogCiAvKgotICoJTGV0cyB0aGUgY2xpZW50IGtub3cgYXQgd2hpY2ggbGV2ZWwgdGhlIGRhdGEgd2FzIGNvbW1pdGVkIG9uCisgKglMZXRzIHRoZSBjbGllbnQga25vdyBhdCB3aGljaCBsZXZlbCB0aGUgZGF0YSB3YXMgY29tbWl0dGVkIG9uCiAgKglhIHdyaXRlIHJlcXVlc3QKICAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYWFjcmFpZC9jb21tc3VwLmMgYi9kcml2ZXJzL3Njc2kvYWFjcmFpZC9jb21tc3VwLmMKaW5kZXggZGQ3YWQzYi4uZTdkMGQ0NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2FhY3JhaWQvY29tbXN1cC5jCisrKyBiL2RyaXZlcnMvc2NzaS9hYWNyYWlkL2NvbW1zdXAuYwpAQCAtNDIxLDcgKzQyMSw3IEBACiAJaWYgKCEoaHdfZmliLT5oZWFkZXIuWGZlclN0YXRlICYgY3B1X3RvX2xlMzIoSG9zdE93bmVkKSkpCiAJCXJldHVybiAtRUJVU1k7CiAJLyoKLQkgKglUaGVyZSBhcmUgNSBjYXNlcyB3aXRoIHRoZSB3YWl0IGFuZCByZXBvbnNlIHJlcXVlc3RlZCBmbGFncy4KKwkgKglUaGVyZSBhcmUgNSBjYXNlcyB3aXRoIHRoZSB3YWl0IGFuZCByZXNwb25zZSByZXF1ZXN0ZWQgZmxhZ3MuCiAJICoJVGhlIG9ubHkgaW52YWxpZCBjYXNlcyBhcmUgaWYgdGhlIGNhbGxlciByZXF1ZXN0cyB0byB3YWl0IGFuZAogCSAqCWRvZXMgbm90IHJlcXVlc3QgYSByZXNwb25zZSBhbmQgaWYgdGhlIGNhbGxlciBkb2VzIG5vdCB3YW50IGEKIAkgKglyZXNwb25zZSBhbmQgdGhlIEZpYiBpcyBub3QgYWxsb2NhdGVkIGZyb20gcG9vbC4gSWYgYSByZXNwb25zZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FkdmFuc3lzLmMgYi9kcml2ZXJzL3Njc2kvYWR2YW5zeXMuYwppbmRleCAwODFjNmRlLi5iZmQ2MThhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWR2YW5zeXMuYworKysgYi9kcml2ZXJzL3Njc2kvYWR2YW5zeXMuYwpAQCAtNDU0NCw3ICs0NTQ0LDcgQEAKICAqIENvcHkgNCBieXRlcyB0byBMUkFNLgogICoKICAqIFRoZSBzb3VyY2UgZGF0YSBpcyBhc3N1bWVkIHRvIGJlIGluIGxpdHRsZS1lbmRpYW4gb3JkZXIgaW4gbWVtb3J5Ci0gKiBhbmQgaXMgbWFpbnRhaW5lZCBpbiBsaXR0bGUtZW5kaWFuIG9yZGVyIHdoZW4gd3JpdGVuIHRvIExSQU0uCisgKiBhbmQgaXMgbWFpbnRhaW5lZCBpbiBsaXR0bGUtZW5kaWFuIG9yZGVyIHdoZW4gd3JpdHRlbiB0byBMUkFNLgogICovCiBzdGF0aWMgdm9pZAogQXNjTWVtRFdvcmRDb3B5UHRyVG9McmFtKFBvcnRBZGRyIGlvcF9iYXNlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FoYTE3NDAuYyBiL2RyaXZlcnMvc2NzaS9haGExNzQwLmMKaW5kZXggZDA1OGYxYS4uMWMxMGI3OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2FoYTE3NDAuYworKysgYi9kcml2ZXJzL3Njc2kvYWhhMTc0MC5jCkBAIC00NjEsNyArNDYxLDcgQEAKIAkvKiBUaGUgQWRhcHRlYyBTcGVjIHNheXMgdGhlIGNhcmQgaXMgc28gZmFzdCB0aGF0IHRoZSBsb29wcwogICAgICAgICAgICB3aWxsIG9ubHkgYmUgZXhlY3V0ZWQgb25jZSBpbiB0aGUgY29kZSBiZWxvdy4gRXZlbiBpZiB0aGlzCiAgICAgICAgICAgIHdhcyB0cnVlIHdpdGggdGhlIGZhc3Rlc3QgcHJvY2Vzc29ycyB3aGVuIHRoZSBzcGVjIHdhcwotICAgICAgICAgICB3cml0dGVuLCBpdCBkb2Vzbid0IHNlZW0gdG8gYmUgdHJ1ZSB3aXRoIHRvZGF5cyBmYXN0CisgICAgICAgICAgIHdyaXR0ZW4sIGl0IGRvZXNuJ3Qgc2VlbSB0byBiZSB0cnVlIHdpdGggdG9kYXkncyBmYXN0CiAgICAgICAgICAgIHByb2Nlc3NvcnMuIFdlIHByaW50IGEgd2FybmluZyBpZiB0aGUgY29kZSBpcyBleGVjdXRlZCBtb3JlCiAgICAgICAgICAgIG9mdGVuIHRoYW4gTE9PUENOVF9XQVJOLiBJZiB0aGlzIGhhcHBlbnMsIGl0IHNob3VsZCBiZQogICAgICAgICAgICBpbnZlc3RpZ2F0ZWQuIElmIHRoZSBjb3VudCByZWFjaGVzIExPT1BDTlRfTUFYLCB3ZSBhc3N1bWUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHguaCBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHguaAppbmRleCA5NWVlNTAzLi45YjA1OTQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4LmgKKysrIGIvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljNzl4eC5oCkBAIC00NzMsNyArNDczLDcgQEAKICAqCW8gQSByZXNpZHVhbCBoYXMgb2NjdXJyZWQgaWYgU0dfRlVMTF9SRVNJRCBpcyBzZXQgaW4gc2dwdHIsCiAgKgkgIG9yIHJlc2lkdWFsX3NncHRyIGRvZXMgbm90IGhhdmUgU0dfTElTVF9OVUxMIHNldC4KICAqCi0gKglvIFdlIGFyZSB0cmFuc2ZlcmluZyB0aGUgbGFzdCBzZWdtZW50IGlmIHJlc2lkdWFsX2RhdGFjbnQgaGFzCisgKglvIFdlIGFyZSB0cmFuc2ZlcnJpbmcgdGhlIGxhc3Qgc2VnbWVudCBpZiByZXNpZHVhbF9kYXRhY250IGhhcwogICoJICB0aGUgU0dfTEFTVF9TRUcgZmxhZyBzZXQuCiAgKgogICogSG9zdDoKQEAgLTUxNiw3ICs1MTYsNyBAQAogICovCiAKIC8qCi0gKiBEZWZpbml0aW9uIG9mIGEgc2NhdHRlci9nYXRoZXIgZWxlbWVudCBhcyB0cmFuc2ZlcmVkIHRvIHRoZSBjb250cm9sbGVyLgorICogRGVmaW5pdGlvbiBvZiBhIHNjYXR0ZXIvZ2F0aGVyIGVsZW1lbnQgYXMgdHJhbnNmZXJyZWQgdG8gdGhlIGNvbnRyb2xsZXIuCiAgKiBUaGUgYWljN3h4eCBjaGlwcyBvbmx5IHN1cHBvcnQgYSAyNGJpdCBsZW5ndGguICBXZSB1c2UgdGhlIHRvcCBieXRlIG9mCiAgKiB0aGUgbGVuZ3RoIHRvIHN0b3JlIGFkZGl0aW9uYWwgYWRkcmVzcyBiaXRzIGFuZCBhIGZsYWcgdG8gaW5kaWNhdGUKICAqIHRoYXQgYSBnaXZlbiBzZWdtZW50IHRlcm1pbmF0ZXMgdGhlIHRyYW5zZmVyLiAgVGhpcyBnaXZlcyB1cyBhbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljNzl4eC5yZWcgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4LnJlZwppbmRleCAwNjY2YzIyLi43ZTEyYzMxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4LnJlZworKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4LnJlZwpAQCAtMzA1LDcgKzMwNSw3IEBACiB9CiAKIC8qCi0gKiBTZXF1ZW5jZXIgSW50ZXJ1cHQgU3RhdHVzCisgKiBTZXF1ZW5jZXIgSW50ZXJydXB0IFN0YXR1cwogICovCiByZWdpc3RlciBTRVFJTlRTVEFUIHsKIAlhZGRyZXNzCQkJMHgwMEMKQEAgLTY4NSw3ICs2ODUsNyBAQAogfQogCiAvKgotICogQ01DIFJlY2lldmUgTWVzc2FnZSAwCisgKiBDTUMgUmVjZWl2ZSBNZXNzYWdlIDAKICAqLwogcmVnaXN0ZXIgQ01DUlhNU0cwIHsKIAlhZGRyZXNzCQkJMHgwOTAKQEAgLTY5Niw3ICs2OTYsNyBAQAogfQogCiAvKgotICogT3ZlcmxheSBSZWNpZXZlIE1lc3NhZ2UgMAorICogT3ZlcmxheSBSZWNlaXZlIE1lc3NhZ2UgMAogICovCiByZWdpc3RlciBPVkxZUlhNU0cwIHsKIAlhZGRyZXNzCQkJMHgwOTAKQEAgLTczMiw3ICs3MzIsNyBAQAogfQogCiAvKgotICogQ01DIFJlY2lldmUgTWVzc2FnZSAxCisgKiBDTUMgUmVjZWl2ZSBNZXNzYWdlIDEKICAqLwogcmVnaXN0ZXIgQ01DUlhNU0cxIHsKIAlhZGRyZXNzCQkJMHgwOTEKQEAgLTc0Miw3ICs3NDIsNyBAQAogfQogCiAvKgotICogT3ZlcmxheSBSZWNpZXZlIE1lc3NhZ2UgMQorICogT3ZlcmxheSBSZWNlaXZlIE1lc3NhZ2UgMQogICovCiByZWdpc3RlciBPVkxZUlhNU0cxIHsKIAlhZGRyZXNzCQkJMHgwOTEKQEAgLTc3Nyw3ICs3NzcsNyBAQAogfQogCiAvKgotICogQ01DIFJlY2lldmUgTWVzc2FnZSAyCisgKiBDTUMgUmVjZWl2ZSBNZXNzYWdlIDIKICAqLwogcmVnaXN0ZXIgQ01DUlhNU0cyIHsKIAlhZGRyZXNzCQkJMHgwOTIKQEAgLTc4Nyw3ICs3ODcsNyBAQAogfQogCiAvKgotICogT3ZlcmxheSBSZWNpZXZlIE1lc3NhZ2UgMgorICogT3ZlcmxheSBSZWNlaXZlIE1lc3NhZ2UgMgogICovCiByZWdpc3RlciBPVkxZUlhNU0cyIHsKIAlhZGRyZXNzCQkJMHgwOTIKQEAgLTgxNiw3ICs4MTYsNyBAQAogfQogCiAvKgotICogQ01DIFJlY2lldmUgTWVzc2FnZSAzCisgKiBDTUMgUmVjZWl2ZSBNZXNzYWdlIDMKICAqLwogcmVnaXN0ZXIgQ01DUlhNU0czIHsKIAlhZGRyZXNzCQkJMHgwOTMKQEAgLTgyNiw3ICs4MjYsNyBAQAogfQogCiAvKgotICogT3ZlcmxheSBSZWNpZXZlIE1lc3NhZ2UgMworICogT3ZlcmxheSBSZWNlaXZlIE1lc3NhZ2UgMwogICovCiByZWdpc3RlciBPVkxZUlhNU0czIHsKIAlhZGRyZXNzCQkJMHgwOTMKQEAgLTEyNDksNyArMTI0OSw3IEBACiAKIC8qCiAgKiBMUSBQYWNrZXQgSW4KLSAqIFRoZSBsYXN0IExRIFBhY2tldCByZWNpZXZlZAorICogVGhlIGxhc3QgTFEgUGFja2V0IHJlY2VpdmVkCiAgKi8KIHJlZ2lzdGVyIExRSU4gewogCWFkZHJlc3MJCQkweDAyMApAQCAtMjU3Myw3ICsyNTczLDcgQEAKIH0KIAogLyoKLSAqIFNoYWRkb3cgSG9zdCBBZGRyZXNzLgorICogU2hhZG93IEhvc3QgQWRkcmVzcy4KICAqLwogcmVnaXN0ZXIgU0hBRERSIHsKIAlhZGRyZXNzCQkJMHgwNjAKQEAgLTM5ODMsNyArMzk4Myw3IEBACiAKIAkvKgogCSAqIFRoZSBtYXhpbXVtIGFtb3VudCBvZiB0aW1lIHRvIHdhaXQsIHdoZW4gaW50ZXJydXB0IGNvYWxlc2NpbmcKLQkgKiBpcyBlbmFibGVkLCBiZWZvcmUgaXNzdWVpbmcgYSBDTURDTVBMVCBpbnRlcnJ1cHQgZm9yIGEgY29tcGxldGVkCisJICogaXMgZW5hYmxlZCwgYmVmb3JlIGlzc3VpbmcgYSBDTURDTVBMVCBpbnRlcnJ1cHQgZm9yIGEgY29tcGxldGVkCiAJICogY29tbWFuZC4KIAkgKi8KIAlJTlRfQ09BTEVTQ0lOR19USU1FUiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4LnNlcSBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHguc2VxCmluZGV4IDJmYjc4ZTMuLjNhMzZkOTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHguc2VxCisrKyBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHguc2VxCkBAIC01NjcsNyArNTY3LDcgQEAKIAlzaHIJU0VMT0lELCA0LCBTQ0JfU0NTSUlEOwogCS8qCiAJICogSWYgd2Ugd2FudCB0byBzZW5kIGEgbWVzc2FnZSB0byB0aGUgZGV2aWNlLCBlbnN1cmUKLQkgKiB3ZSBhcmUgc2VsZWN0aW5nIHdpdGggYXRuIGlycmVnYXJkbGVzcyBvZiBvdXIgcGFja2V0aXplZAorCSAqIHdlIGFyZSBzZWxlY3Rpbmcgd2l0aCBhdG4gcmVnYXJkbGVzcyBvZiBvdXIgcGFja2V0aXplZAogCSAqIGFncmVlbWVudC4gIFNpbmNlIFNQSTQgb25seSBhbGxvd3MgdGFyZ2V0IHJlc2V0IG9yIFBQUgogCSAqIG1lc3NhZ2VzIGlmIHRoaXMgaXMgYSBwYWNrZXRpemVkIGNvbm5lY3Rpb24sIHRoZSBjaGFuZ2UKIAkgKiB0byBvdXIgbmVnb3RpYXRpb24gdGFibGUgZW50cnkgZm9yIHRoaXMgc2VsZWN0aW9uIHdpbGwKQEAgLTk2MCw3ICs5NjAsNyBAQAogICogVGhpcyBpcyBkb25lIHRvIGFsbG93IHRoZSBob3N0IHRvIHNlbmQgbWVzc2FnZXMgb3V0c2lkZSBvZiBhbiBpZGVudGlmeQogICogc2VxdWVuY2Ugd2hpbGUgcHJvdGVjdGluZyB0aGUgc2VxZW5jZXIgZnJvbSB0ZXN0aW5nIHRoZSBNS19NRVNTQUdFIGJpdAogICogb24gYW4gU0NCIHRoYXQgbWlnaHQgbm90IGJlIGZvciB0aGUgY3VycmVudCBuZXh1cy4gKEZvciBleGFtcGxlLCBhCi0gKiBCRFIgbWVzc2FnZSBpbiByZXNwb25jZSB0byBhIGJhZCByZXNlbGVjdGlvbiB3b3VsZCBsZWF2ZSB1cyBwb2ludGVkIHRvCisgKiBCRFIgbWVzc2FnZSBpbiByZXNwb25zZSB0byBhIGJhZCByZXNlbGVjdGlvbiB3b3VsZCBsZWF2ZSB1cyBwb2ludGVkIHRvCiAgKiBhbiBTQ0IgdGhhdCBkb2Vzbid0IGhhdmUgYW55dGhpbmcgdG8gZG8gd2l0aCB0aGUgY3VycmVudCB0YXJnZXQpLgogICoKICAqIE90aGVyd2lzZSwgdHJlYXQgTVNHX09VVCBhcyBhIDEgYnl0ZSBtZXNzYWdlIHRvIHNlbmQgKGFib3J0LCBhYm9ydCB0YWcsCkBAIC0xNTA3LDcgKzE1MDcsNyBAQAogCQkgKiBJZiB0aGUgb3RoZXIgRklGTyBuZWVkcyBsb2FkaW5nLCB0aGVuIGl0CiAJCSAqIG11c3Qgbm90IGhhdmUgY2xhaW1lZCB0aGUgUy9HIGNhY2hlIHlldAogCQkgKiAoU0dfQ0FDSEVfQVZBSUwgd291bGQgaGF2ZSBiZWVuIGNsZWFyZWQgaW4KLQkJICogdGhlIG9yZ2luYWwgRklGTyBtb2RlIGFuZCB3ZSB0ZXN0IHRoaXMgYWJvdmUpLgorCQkgKiB0aGUgb3JpZ2luYWwgRklGTyBtb2RlIGFuZCB3ZSB0ZXN0IHRoaXMgYWJvdmUpLgogCQkgKiBSZXR1cm4gdG8gdGhlIGlkbGUgbG9vcCBzbyB3ZSBjYW4gcHJvY2VzcyB0aGUKIAkJICogRklGTyBub3QgY3VycmVudGx5IG9uIHRoZSBidXMgZmlyc3QuCiAJCSAqLwpAQCAtMTUyMSw3ICsxNTIxLDcgQEAKIGlkbGVfc2dmZXRjaF9zdGFydDoKIAkvKgogCSAqIFdlIGZldGNoIGEgImNhY2hlbGluZSBhbGlnbmVkIiBhbmQgc2l6ZWQgYW1vdW50IG9mIGRhdGEKLQkgKiBzbyB3ZSBkb24ndCBlbmQgdXAgcmVmZXJlbmNpbmcgYSBub24tZXhpc3RhbnQgcGFnZS4KKwkgKiBzbyB3ZSBkb24ndCBlbmQgdXAgcmVmZXJlbmNpbmcgYSBub24tZXhpc3RlbnQgcGFnZS4KIAkgKiBDYWNoZWxpbmUgYWxpZ25lZCBpcyBpbiBxdW90ZXMgYmVjYXVzZSB0aGUga2VybmVsIHdpbGwKIAkgKiBzZXQgdGhlIHByZWZldGNoIGFtb3VudCB0byBhIHJlYXNvbmFibGUgbGV2ZWwgaWYgdGhlCiAJICogY2FjaGVsaW5lIHNpemUgaXMgdW5rbm93bi4KQEAgLTE1NTEsNyArMTU1MSw3IEBACiAJdGVzdAlERlNUQVRVUywgUFJFTE9BRF9BVkFJTCBqeiByZXR1cm47CiAJLyoKIAkgKiBPbiB0aGUgQSwgcHJlbG9hZGluZyBhIHNlZ21lbnQgYmVmb3JlIEhETUFFTkFDSwotCSAqIGNvbWVzIHRydWUgY2FuIGNsb2JiZXIgdGhlIHNoYWRkb3cgYWRkcmVzcyBvZiB0aGUKKwkgKiBjb21lcyB0cnVlIGNhbiBjbG9iYmVyIHRoZSBzaGFkb3cgYWRkcmVzcyBvZiB0aGUKIAkgKiBmaXJzdCBzZWdtZW50IGluIHRoZSBTL0cgRklGTy4gIFdhaXQgdW50aWwgaXQgaXMKIAkgKiBzYWZlIHRvIHByb2NlZWQuCiAJICovCkBAIC0yMDA0LDEwICsyMDA0LDEwIEBACiAJICogRGVmZXIgaGFuZGxpbmcgb2YgdGhpcyBOT05QQUNLUkVRIHVudGlsIHdlCiAJICogY2FuIGJlIHN1cmUgaXQgcGVydGFpbnMgdG8gdGhpcyBGSUZPLiAgU0FWRVBUUlMKIAkgKiB3aWxsIG5vdCBiZSBhc3NlcnRlZCBpZiB0aGUgTk9OUEFDS1JFUSBpcyBmb3IgdXMsCi0JICogc28gd2UgbXVzdCBzaW11bGF0ZSBpdCBpZiBzaGFkZG93IGlzIHZhbGlkLiAgSWYKLQkgKiBzaGFkZG93IGlzIG5vdCB2YWxpZCwga2VlcCBydW5uaW5nIHRoaXMgRklGTyB1bnRpbCB3ZQorCSAqIHNvIHdlIG11c3Qgc2ltdWxhdGUgaXQgaWYgc2hhZG93IGlzIHZhbGlkLiAgSWYKKwkgKiBzaGFkb3cgaXMgbm90IHZhbGlkLCBrZWVwIHJ1bm5pbmcgdGhpcyBGSUZPIHVudGlsIHdlCiAJICogaGF2ZSBzYXRpc2ZpZWQgdGhlIHRyYW5zZmVyIGJ5IGxvYWRpbmcgc2VnbWVudHMgYW5kCi0JICogd2FpdGluZyBmb3IgZWl0aGVyIHNoYWRkb3cgdmFsaWQgb3IgbGFzdF9zZWdfZG9uZS4KKwkgKiB3YWl0aW5nIGZvciBlaXRoZXIgc2hhZG93IHZhbGlkIG9yIGxhc3Rfc2VnX2RvbmUuCiAJICovCiAJdGVzdAlNREZGU1RBVCwgU0hWQUxJRCBqbnogcGt0X3NhdmVwdHJzOwogcGt0X3NlcnZpY2VfZmlmbzoKQEAgLTIxNzEsNyArMjE3MSw3IEBACiAJLyoKIAkgKiBUaGUgdW5leHBlY3RlZCBub25wa3QgcGhhc2UgaGFuZGxlciBhc3N1bWVzIHRoYXQgYW55CiAJICogZGF0YSBjaGFubmVsIHVzZSB3aWxsIGhhdmUgYSBGSUZPIHJlZmVyZW5jZSBjb3VudC4gIEl0Ci0JICogdHVybnMgb3V0IHRoYXQgdGhlIHN0YXR1cyBoYW5kbGVyIGRvZXNuJ3QgbmVlZCBhIHJlZmVybmNlCisJICogdHVybnMgb3V0IHRoYXQgdGhlIHN0YXR1cyBoYW5kbGVyIGRvZXNuJ3QgbmVlZCBhIHJlZmVyZW5jZXMKIAkgKiBjb3VudCBzaW5jZSB0aGUgc3RhdHVzIHJlY2VpdmVkIGZsYWcsIGFuZCB0aHVzIGNvbXBsZXRpb24KIAkgKiBwcm9jZXNzaW5nLCBjYW5ub3QgYmUgc2V0IHVudGlsIHRoZSBoYW5kbGVyIGlzIGZpbmlzaGVkLgogCSAqIFdlIGluY3JlbWVudCB0aGUgY291bnQgaGVyZSB0byBtYWtlIHRoZSBub25wa3QgaGFuZGxlcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljNzl4eF9jb3JlLmMgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4X2NvcmUuYwppbmRleCAzMjMzYmY1Li41Zjg2MTdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4X2NvcmUuYworKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4X2NvcmUuYwpAQCAtNTYyLDcgKzU2Miw3IEBACiB9CiAjZW5kaWYKIAotLyoqKioqKioqKioqKioqKioqKioqKioqIE1pc2NlbGFuZW91cyBTdXBwb3J0IEZ1bmN0aW9ucyAqKioqKioqKioqKioqKioqKioqKioqKi8KKy8qKioqKioqKioqKioqKioqKioqKioqKiBNaXNjZWxsYW5lb3VzIFN1cHBvcnQgRnVuY3Rpb25zICoqKioqKioqKioqKioqKioqKioqKioqLwogLyoKICAqIFJldHVybiBwb2ludGVycyB0byB0aGUgdHJhbnNmZXIgbmVnb3RpYXRpb24gaW5mb3JtYXRpb24KICAqIGZvciB0aGUgc3BlY2lmaWVkIG91cl9pZC9yZW1vdGVfaWQgcGFpci4KQEAgLTU5OSw3ICs1OTksNyBAQAogYWhkX291dHcoc3RydWN0IGFoZF9zb2Z0YyAqYWhkLCB1X2ludCBwb3J0LCB1X2ludCB2YWx1ZSkKIHsKIAkvKgotCSAqIFdyaXRlIGxvdyBieXRlIGZpcnN0IHRvIGFjY29tb2RhdGUgcmVnaXN0ZXJzCisJICogV3JpdGUgbG93IGJ5dGUgZmlyc3QgdG8gYWNjb21tb2RhdGUgcmVnaXN0ZXJzCiAJICogc3VjaCBhcyBQUkdNQ05UIHdoZXJlIHRoZSBvcmRlciBtYXRlcnMuCiAJICovCiAJYWhkX291dGIoYWhkLCBwb3J0LCB2YWx1ZSAmIDB4RkYpOwpAQCAtMjA2Nyw3ICsyMDY3LDcgQEAKIAkJICogdGhhdCByZXF1aXJlcyBob3N0IGFzc2lzdGFuY2UgZm9yIGNvbXBsZXRpb24uCiAJCSAqIFdoaWxlIGhhbmRsaW5nIHRoZSBtZXNzYWdlIHBoYXNlKHMpLCB3ZSB3aWxsIGJlCiAJCSAqIG5vdGlmaWVkIGJ5IHRoZSBzZXF1ZW5jZXIgYWZ0ZXIgZWFjaCBieXRlIGlzCi0JCSAqIHRyYW5zZmVyZWQgc28gd2UgY2FuIHRyYWNrIGJ1cyBwaGFzZSBjaGFuZ2VzLgorCQkgKiB0cmFuc2ZlcnJlZCBzbyB3ZSBjYW4gdHJhY2sgYnVzIHBoYXNlIGNoYW5nZXMuCiAJCSAqCiAJCSAqIElmIHRoaXMgaXMgdGhlIGZpcnN0IHRpbWUgd2UndmUgc2VlbiBhIEhPU1RfTVNHX0xPT1AKIAkJICogaW50ZXJydXB0LCBpbml0aWFsaXplIHRoZSBzdGF0ZSBvZiB0aGUgaG9zdCBtZXNzYWdlCkBAIC0yNDg3LDcgKzI0ODcsNyBAQAogCQkvKgogCQkgKiBBbHRob3VnaCB0aGUgZHJpdmVyIGRvZXMgbm90IGNhcmUgYWJvdXQgdGhlCiAJCSAqICdTZWxlY3Rpb24gaW4gUHJvZ3Jlc3MnIHN0YXR1cyBiaXQsIHRoZSBidXN5Ci0JCSAqIExFRCBkb2VzLiAgU0VMSU5HTyBpcyBvbmx5IGNsZWFyZWQgYnkgYSBzdWNjZXNzZnVsbAorCQkgKiBMRUQgZG9lcy4gIFNFTElOR08gaXMgb25seSBjbGVhcmVkIGJ5IGEgc3VjY2Vzc2Z1bAogCQkgKiBzZWxlY3Rpb24sIHNvIHdlIG11c3QgbWFudWFsbHkgY2xlYXIgaXQgdG8gaW5zdXJlCiAJCSAqIHRoZSBMRUQgdHVybnMgb2ZmIGp1c3QgaW5jYXNlIG5vIGZ1dHVyZSBzdWNjZXNzZnVsCiAJCSAqIHNlbGVjdGlvbnMgb2NjdXIgKGUuZy4gbm8gZGV2aWNlcyBvbiB0aGUgYnVzKS4KQEAgLTM1NDgsNyArMzU0OCw3IEBACiAJCWFoZF9vdXRiKGFoZCwgU0VRQ1RMMCwgYWhkX2luYihhaGQsIFNFUUNUTDApICYgflNURVApOwogICAJCWFoZF9vdXRiKGFoZCwgU0lNT0RFMSwgc2ltb2RlMSk7CiAJCS8qCi0JCSAqIFNDU0lJTlQgc2VlbXMgdG8gZ2xpdGNoIG9jY2Fzc2lvbmFsbHkgd2hlbgorCQkgKiBTQ1NJSU5UIHNlZW1zIHRvIGdsaXRjaCBvY2Nhc2lvbmFsbHkgd2hlbgogCQkgKiB0aGUgaW50ZXJydXB0IG1hc2tzIGFyZSByZXN0b3JlZC4gIENsZWFyIFNDU0lJTlQKIAkJICogb25lIG1vcmUgdGltZSBzbyB0aGF0IG9ubHkgcGVyc2lzdGVudCBlcnJvcnMKIAkJICogYXJlIHNlZW4gYXMgYSByZWFsIGludGVycnVwdC4KQEAgLTM4MzgsNyArMzgzOCw3IEBACiAKIC8qCiAgKiBVcGRhdGUgdGhlIGJpdG1hc2sgb2YgdGFyZ2V0cyBmb3Igd2hpY2ggdGhlIGNvbnRyb2xsZXIgc2hvdWxkCi0gKiBuZWdvdGlhdGUgd2l0aCBhdCB0aGUgbmV4dCBjb252ZW5pZW50IG9wb3J0dW5pdHkuICBUaGlzIGN1cnJlbnRseQorICogbmVnb3RpYXRlIHdpdGggYXQgdGhlIG5leHQgY29udmVuaWVudCBvcHBvcnR1bml0eS4gIFRoaXMgY3VycmVudGx5CiAgKiBtZWFucyB0aGUgbmV4dCB0aW1lIHdlIHNlbmQgdGhlIGluaXRpYWwgaWRlbnRpZnkgbWVzc2FnZXMgZm9yCiAgKiBhIG5ldyB0cmFuc2FjdGlvbi4KICAqLwpAQCAtNDIwMCw3ICs0MjAwLDcgQEAKIAogCS8qCiAJICogRHVyaW5nIHBhY2tldGl6ZWQgdHJhbnNmZXJzLCB0aGUgdGFyZ2V0IHdpbGwKLQkgKiBnaXZlIHVzIHRoZSBvcG9ydHVuaXR5IHRvIHNlbmQgY29tbWFuZCBwYWNrZXRzCisJICogZ2l2ZSB1cyB0aGUgb3Bwb3J0dW5pdHkgdG8gc2VuZCBjb21tYW5kIHBhY2tldHMKIAkgKiB3aXRob3V0IHVzIGFzc2VydGluZyBhdHRlbnRpb24uCiAJICovCiAJaWYgKCh0aW5mby0+cHByX29wdGlvbnMgJiBNU0dfRVhUX1BQUl9JVV9SRVEpID09IDApCkBAIC01NjUxLDcgKzU2NTEsNyBAQAogCiAJCS8qCiAJCSAqIFJlcXVldWUgYWxsIHRhZ2dlZCBjb21tYW5kcyBmb3IgdGhpcyB0YXJnZXQKLQkJICogY3VycmVudGx5IGluIG91ciBwb3Nlc3Npb24gc28gdGhleSBjYW4gYmUKKwkJICogY3VycmVudGx5IGluIG91ciBwb3NzZXNzaW9uIHNvIHRoZXkgY2FuIGJlCiAJCSAqIGNvbnZlcnRlZCB0byB1bnRhZ2dlZCBjb21tYW5kcy4KIAkJICovCiAJCWFoZF9zZWFyY2hfcWluZmlmbyhhaGQsIFNDQl9HRVRfVEFSR0VUKGFoZCwgc2NiKSwKQEAgLTYyNDUsNyArNjI0NSw3IEBACiAvKgogICogUmVzZXQgdGhlIGNvbnRyb2xsZXIgYW5kIHJlY29yZCBzb21lIGluZm9ybWF0aW9uIGFib3V0IGl0CiAgKiB0aGF0IGlzIG9ubHkgYXZhaWxhYmxlIGp1c3QgYWZ0ZXIgYSByZXNldC4gIElmICJyZWluaXQiIGlzCi0gKiBub24temVybywgdGhpcyByZXNldCBvY2N1cmVkIGFmdGVyIGluaXRpYWwgY29uZmlndXJhdGlvbgorICogbm9uLXplcm8sIHRoaXMgcmVzZXQgb2NjdXJyZWQgYWZ0ZXIgaW5pdGlhbCBjb25maWd1cmF0aW9uCiAgKiBhbmQgdGhlIGNhbGxlciByZXF1ZXN0cyB0aGF0IHRoZSBjaGlwIGJlIGZ1bGx5IHJlaW5pdGlhbGl6ZWQKICAqIHRvIGEgcnVuYWJsZSBzdGF0ZS4gIENoaXAgaW50ZXJydXB0cyBhcmUgKm5vdCogZW5hYmxlZCBhZnRlcgogICogYSByZWluaXRpYWxpemF0aW9uLiAgVGhlIGNhbGxlciBtdXN0IGVuYWJsZSBpbnRlcnJ1cHRzIHZpYQpAQCAtNjQ5NSw3ICs2NDk1LDcgQEAKIAl9CiAKIAkvKgotCSAqIE5vdGUgdGhhdCB3ZSB3ZXJlIHN1Y2Nlc3NmdWxsCisJICogTm90ZSB0aGF0IHdlIHdlcmUgc3VjY2Vzc2Z1bAogCSAqLwogCXJldHVybiAoMCk7IAogCkBAIC03MDc5LDcgKzcwNzksNyBAQAogCQlyZXR1cm4gKEVOT01FTSk7CiAKIAkvKgotCSAqIFZlcmlmeSB0aGF0IHRoZSBjb21waWxlciBoYXNuJ3Qgb3Zlci1hZ3Jlc3NpdmVseQorCSAqIFZlcmlmeSB0aGF0IHRoZSBjb21waWxlciBoYXNuJ3Qgb3Zlci1hZ2dyZXNzaXZlbHkKIAkgKiBwYWRkZWQgaW1wb3J0YW50IHN0cnVjdHVyZXMuCiAJICovCiAJaWYgKHNpemVvZihzdHJ1Y3QgaGFyZHdhcmVfc2NiKSAhPSA2NCkKQEAgLTEwMDg3LDcgKzEwMDg3LDcgQEAKIAkJcmV0dXJuIChlcnJvcik7CiAKIAkvKgotCSAqIFdyaXRlIHRoZSBkYXRhLiAgSWYgd2UgZG9uJ3QgZ2V0IHRocm91Z2h0IHRoZSBsb29wIGF0CisJICogV3JpdGUgdGhlIGRhdGEuICBJZiB3ZSBkb24ndCBnZXQgdGhyb3VnaCB0aGUgbG9vcCBhdAogCSAqIGxlYXN0IG9uY2UsIHRoZSBhcmd1bWVudHMgd2VyZSBpbnZhbGlkLgogCSAqLwogCXJldHZhbCA9IEVJTlZBTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHhfb3NtLmMgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3OXh4X29zbS5jCmluZGV4IDI1ZDA2NjYuLjdkNDg3MDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzc5eHhfb3NtLmMKKysrIGIvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljNzl4eF9vc20uYwpAQCAtMTQ0MSw3ICsxNDQxLDcgQEAKIAkJdXNlcnRhZ3MgPSBhaGRfbGludXhfdXNlcl90YWdkZXB0aChhaGQsIGRldmluZm8pOwogCQlpZiAoIXdhc19xdWV1aW5nKSB7CiAJCQkvKgotCQkJICogU3RhcnQgb3V0IGFncmVzc2l2ZWx5IGFuZCBhbGxvdyBvdXIKKwkJCSAqIFN0YXJ0IG91dCBhZ2dyZXNzaXZlbHkgYW5kIGFsbG93IG91cgogCQkJICogZHluYW1pYyBxdWV1ZSBkZXB0aCBhbGdvcml0aG0gdG8gdGFrZQogCQkJICogY2FyZSBvZiB0aGUgcmVzdC4KIAkJCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljN3h4eC5oIGIvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljN3h4eC5oCmluZGV4IDE3NDQ0YmMuLmY2OTU3NzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHguaAorKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4LmgKQEAgLTQ0MCw3ICs0NDAsNyBAQAogICoJbyBBIHJlc2lkdWFsIGhhcyBvY2N1cnJlZCBpZiBTR19GVUxMX1JFU0lEIGlzIHNldCBpbiBzZ3B0ciwKICAqCSAgb3IgcmVzaWR1YWxfc2dwdHIgZG9lcyBub3QgaGF2ZSBTR19MSVNUX05VTEwgc2V0LgogICoKLSAqCW8gV2UgYXJlIHRyYW5zZmVyaW5nIHRoZSBsYXN0IHNlZ21lbnQgaWYgcmVzaWR1YWxfZGF0YWNudCBoYXMKKyAqCW8gV2UgYXJlIHRyYW5zZmVycmluZyB0aGUgbGFzdCBzZWdtZW50IGlmIHJlc2lkdWFsX2RhdGFjbnQgaGFzCiAgKgkgIHRoZSBTR19MQVNUX1NFRyBmbGFnIHNldC4KICAqCiAgKiBIb3N0OgpAQCAtNDk0LDcgKzQ5NCw3IEBACiAgKi8KIAogLyoKLSAqIERlZmluaXRpb24gb2YgYSBzY2F0dGVyL2dhdGhlciBlbGVtZW50IGFzIHRyYW5zZmVyZWQgdG8gdGhlIGNvbnRyb2xsZXIuCisgKiBEZWZpbml0aW9uIG9mIGEgc2NhdHRlci9nYXRoZXIgZWxlbWVudCBhcyB0cmFuc2ZlcnJlZCB0byB0aGUgY29udHJvbGxlci4KICAqIFRoZSBhaWM3eHh4IGNoaXBzIG9ubHkgc3VwcG9ydCBhIDI0Yml0IGxlbmd0aC4gIFdlIHVzZSB0aGUgdG9wIGJ5dGUgb2YKICAqIHRoZSBsZW5ndGggdG8gc3RvcmUgYWRkaXRpb25hbCBhZGRyZXNzIGJpdHMgYW5kIGEgZmxhZyB0byBpbmRpY2F0ZQogICogdGhhdCBhIGdpdmVuIHNlZ21lbnQgdGVybWluYXRlcyB0aGUgdHJhbnNmZXIuICBUaGlzIGdpdmVzIHVzIGFuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4LnJlZyBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHgucmVnCmluZGV4IDlhOTZlNTUuLmJhMGI0MTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHgucmVnCisrKyBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHgucmVnCkBAIC0zNTEsNyArMzUxLDcgQEAKIAlhZGRyZXNzCQkJMHgwMGQKIAlhY2Nlc3NfbW9kZSBSTwogCWZpZWxkCU9WRVJSVU4JCTB4ODAKLQlmaWVsZAlTSFZBTElECQkweDQwCS8qIFNoYWRkb3cgTGF5ZXIgbm9uLXplcm8gKi8KKwlmaWVsZAlTSFZBTElECQkweDQwCS8qIFNoYWRvdyBMYXllciBub24temVybyAqLwogCWZpZWxkCUVYUF9BQ1RJVkUJMHgxMAkvKiBTQ1NJIEV4cGFuZGVyIEFjdGl2ZSAqLwogCWZpZWxkCUNSQ1ZBTEVSUgkweDA4CS8qIENSQyBkb2Vzbid0IG1hdGNoIChVMyBvbmx5KSAqLwogCWZpZWxkCUNSQ0VOREVSUgkweDA0CS8qIE5vIHRlcm1pbmFsIENSQyBwYWNrZXQgKFUzIG9ubHkpICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4LnNlcSBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHguc2VxCmluZGV4IDVhNGNmYzk1Li5lNjAwNDFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4LnNlcQorKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4LnNlcQpAQCAtNTcsMTAgKzU3LDEwIEBACiAgKiBhIGxhdGVyIHRpbWUuICBUaGlzIHByb2JsZW0gY2Fubm90IGJlIHJlc29sdmVkIGJ5IGhvbGRpbmcgYSBzaW5nbGUgZW50cnkKICAqIGluIHNjcmF0Y2ggcmFtIHNpbmNlIGEgcmVjb25uZWN0aW5nIHRhcmdldCBjYW4gcmVxdWVzdCBzZW5zZSBhbmQgdGhpcyB3aWxsCiAgKiBjcmVhdGUgeWV0IGFub3RoZXIgU0NCIHdhaXRpbmcgZm9yIHNlbGVjdGlvbi4gIFRoZSBzb2x1dGlvbiB1c2VkIGhlcmUgaXMgdG8gCi0gKiB1c2UgYnl0ZSAyNyBvZiB0aGUgU0NCIGFzIGEgcHN1ZWRvLW5leHQgcG9pbnRlciBhbmQgdG8gdGhyZWFkIGEgbGlzdAorICogdXNlIGJ5dGUgMjcgb2YgdGhlIFNDQiBhcyBhIHBzZXVkby1uZXh0IHBvaW50ZXIgYW5kIHRvIHRocmVhZCBhIGxpc3QKICAqIG9mIFNDQnMgdGhhdCBhcmUgYXdhaXRpbmcgc2VsZWN0aW9uLiAgU2luY2UgMC0weGZlIGFyZSB2YWxpZCBTQ0IgaW5kZXhlcywgCiAgKiBTQ0JfTElTVF9OVUxMIGlzIDB4ZmYgd2hpY2ggaXMgb3V0IG9mIHJhbmdlLiAgQW4gZW50cnkgaXMgYWxzbyBhZGRlZCB0bwotICogdGhpcyBsaXN0IGV2ZXJ5dGltZSBhIHJlcXVlc3Qgc2Vuc2Ugb2NjdXJzIG9yIGFmdGVyIGNvbXBsZXRpbmcgYSBub24tdGFnZ2VkCisgKiB0aGlzIGxpc3QgZXZlcnkgdGltZSBhIHJlcXVlc3Qgc2Vuc2Ugb2NjdXJzIG9yIGFmdGVyIGNvbXBsZXRpbmcgYSBub24tdGFnZ2VkCiAgKiBjb21tYW5kIGZvciB3aGljaCBhIHNlY29uZCBTQ0IgaGFzIGJlZW4gcXVldWVkLiAgVGhlIHNlcXVlbmNlciB3aWxsCiAgKiBhdXRvbWF0aWNhbGx5IGNvbnN1bWUgdGhlIGVudHJpZXMuCiAgKi8KQEAgLTc1Miw3ICs3NTIsNyBAQAogCiAJLyoKIAkgKiBXZSBmZXRjaCBhICJjYWNoZWxpbmUgYWxpZ25lZCIgYW5kIHNpemVkIGFtb3VudCBvZiBkYXRhCi0JICogc28gd2UgZG9uJ3QgZW5kIHVwIHJlZmVyZW5jaW5nIGEgbm9uLWV4aXN0YW50IHBhZ2UuCisJICogc28gd2UgZG9uJ3QgZW5kIHVwIHJlZmVyZW5jaW5nIGEgbm9uLWV4aXN0ZW50IHBhZ2UuCiAJICogQ2FjaGVsaW5lIGFsaWduZWQgaXMgaW4gcXVvdGVzIGJlY2F1c2UgdGhlIGtlcm5lbCB3aWxsCiAJICogc2V0IHRoZSBwcmVmZXRjaCBhbW91bnQgdG8gYSByZWFzb25hYmxlIGxldmVsIGlmIHRoZQogCSAqIGNhY2hlbGluZSBzaXplIGlzIHVua25vd24uCkBAIC0xNDg1LDcgKzE0ODUsNyBAQAogICogVGhpcyBpcyBkb25lIHRvIGFsbG93IHRoZSBob3N0IHRvIHNlbmQgbWVzc2FnZXMgb3V0c2lkZSBvZiBhbiBpZGVudGlmeQogICogc2VxdWVuY2Ugd2hpbGUgcHJvdGVjdGluZyB0aGUgc2VxZW5jZXIgZnJvbSB0ZXN0aW5nIHRoZSBNS19NRVNTQUdFIGJpdAogICogb24gYW4gU0NCIHRoYXQgbWlnaHQgbm90IGJlIGZvciB0aGUgY3VycmVudCBuZXh1cy4gKEZvciBleGFtcGxlLCBhCi0gKiBCRFIgbWVzc2FnZSBpbiByZXNwb25jZSB0byBhIGJhZCByZXNlbGVjdGlvbiB3b3VsZCBsZWF2ZSB1cyBwb2ludGVkIHRvCisgKiBCRFIgbWVzc2FnZSBpbiByZXNwb25zZSB0byBhIGJhZCByZXNlbGVjdGlvbiB3b3VsZCBsZWF2ZSB1cyBwb2ludGVkIHRvCiAgKiBhbiBTQ0IgdGhhdCBkb2Vzbid0IGhhdmUgYW55dGhpbmcgdG8gZG8gd2l0aCB0aGUgY3VycmVudCB0YXJnZXQpLgogICoKICAqIE90aGVyd2lzZSwgdHJlYXQgTVNHX09VVCBhcyBhIDEgYnl0ZSBtZXNzYWdlIHRvIHNlbmQgKGFib3J0LCBhYm9ydCB0YWcsCkBAIC0xOTk5LDcgKzE5OTksNyBAQAogICogZnJvbSBvdXQgdG8gaW4sIHdhaXQgYW4gYWRkaXRpb25hbCBkYXRhIHJlbGVhc2UgZGVsYXkgYmVmb3JlIGNvbnRpbnVpbmcuCiAgKi8KIGNoYW5nZV9waGFzZToKLQkvKiBXYWl0IGZvciBwcmVjZWVkaW5nIEkvTyBzZXNzaW9uIHRvIGNvbXBsZXRlLiAqLworCS8qIFdhaXQgZm9yIHByZWNlZGluZyBJL08gc2Vzc2lvbiB0byBjb21wbGV0ZS4gKi8KIAl0ZXN0CVNDU0lTSUdJLCBBQ0tJIGpueiAuOwogCiAJLyogQ2hhbmdlIHRoZSBwaGFzZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljN3h4eF9jb3JlLmMgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4X2NvcmUuYwppbmRleCBlMDIxYjQ4Li5kYzI4YjBhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4X2NvcmUuYworKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4X2NvcmUuYwpAQCAtNDI3LDcgKzQyNyw3IEBACiB9CiAjZW5kaWYKIAotLyoqKioqKioqKioqKioqKioqKioqKioqIE1pc2NlbGFuZW91cyBTdXBwb3J0IEZ1bmN0aW9ucyAqKioqKioqKioqKioqKioqKioqKioqKi8KKy8qKioqKioqKioqKioqKioqKioqKioqKiBNaXNjZWxsYW5lb3VzIFN1cHBvcnQgRnVuY3Rpb25zICoqKioqKioqKioqKioqKioqKioqKioqLwogLyoKICAqIERldGVybWluZSB3aGV0aGVyIHRoZSBzZXF1ZW5jZXIgcmVwb3J0ZWQgYSByZXNpZHVhbAogICogZm9yIHRoaXMgU0NCL3RyYW5zYWN0aW9uLgpAQCAtMTI0Myw3ICsxMjQzLDcgQEAKIAkJICogdGhhdCByZXF1aXJlcyBob3N0IGFzc2lzdGFuY2UgZm9yIGNvbXBsZXRpb24uCiAJCSAqIFdoaWxlIGhhbmRsaW5nIHRoZSBtZXNzYWdlIHBoYXNlKHMpLCB3ZSB3aWxsIGJlCiAJCSAqIG5vdGlmaWVkIGJ5IHRoZSBzZXF1ZW5jZXIgYWZ0ZXIgZWFjaCBieXRlIGlzCi0JCSAqIHRyYW5zZmVyZWQgc28gd2UgY2FuIHRyYWNrIGJ1cyBwaGFzZSBjaGFuZ2VzLgorCQkgKiB0cmFuc2ZlcnJlZCBzbyB3ZSBjYW4gdHJhY2sgYnVzIHBoYXNlIGNoYW5nZXMuCiAJCSAqCiAJCSAqIElmIHRoaXMgaXMgdGhlIGZpcnN0IHRpbWUgd2UndmUgc2VlbiBhIEhPU1RfTVNHX0xPT1AKIAkJICogaW50ZXJydXB0LCBpbml0aWFsaXplIHRoZSBzdGF0ZSBvZiB0aGUgaG9zdCBtZXNzYWdlCkBAIC0xNDg3LDcgKzE0ODcsNyBAQAogCQkgICAgICAgc2NicHRyLCBhaGNfaW5iKGFoYywgQVJHXzEpLAogCQkgICAgICAgYWhjLT5zY2JfZGF0YS0+aHNjYnNbc2NicHRyXS50YWcpOwogCQlhaGNfZHVtcF9jYXJkX3N0YXRlKGFoYyk7Ci0JCXBhbmljKCJmb3Igc2FmdGV5Iik7CisJCXBhbmljKCJmb3Igc2FmZXR5Iik7CiAJCWJyZWFrOwogCX0KIAljYXNlIE9VVF9PRl9SQU5HRToKQEAgLTE3MzMsNyArMTczMyw3IEBACiAJCS8qCiAJCSAqIEFsdGhvdWdoIHRoZSBkcml2ZXIgZG9lcyBub3QgY2FyZSBhYm91dCB0aGUKIAkJICogJ1NlbGVjdGlvbiBpbiBQcm9ncmVzcycgc3RhdHVzIGJpdCwgdGhlIGJ1c3kKLQkJICogTEVEIGRvZXMuICBTRUxJTkdPIGlzIG9ubHkgY2xlYXJlZCBieSBhIHN1Y2Nlc3NmdWxsCisJCSAqIExFRCBkb2VzLiAgU0VMSU5HTyBpcyBvbmx5IGNsZWFyZWQgYnkgYSBzdWNjZXNzZnVsCiAJCSAqIHNlbGVjdGlvbiwgc28gd2UgbXVzdCBtYW51YWxseSBjbGVhciBpdCB0byBpbnN1cmUKIAkJICogdGhlIExFRCB0dXJucyBvZmYganVzdCBpbmNhc2Ugbm8gZnV0dXJlIHN1Y2Nlc3NmdWwKIAkJICogc2VsZWN0aW9ucyBvY2N1ciAoZS5nLiBubyBkZXZpY2VzIG9uIHRoZSBidXMpLgpAQCAtMTk0Myw3ICsxOTQzLDcgQEAKIAkJCWlmIChsYXN0cGhhc2UgIT0gUF9CVVNGUkVFKSB7CiAJCQkJLyoKIAkJCQkgKiBSZW5lZ290aWF0ZSB3aXRoIHRoaXMgZGV2aWNlIGF0IHRoZQotCQkJCSAqIG5leHQgb3BvcnR1bml0eSBqdXN0IGluIGNhc2UgdGhpcyBidXNmcmVlCisJCQkJICogbmV4dCBvcHBvcnR1bml0eSBqdXN0IGluIGNhc2UgdGhpcyBidXNmcmVlCiAJCQkJICogaXMgZHVlIHRvIGEgbmVnb3RpYXRpb24gbWlzbWF0Y2ggd2l0aCB0aGUKIAkJCQkgKiBkZXZpY2UuCiAJCQkJICovCkBAIC0yNDQyLDcgKzI0NDIsNyBAQAogCiAvKgogICogVXBkYXRlIHRoZSBiaXRtYXNrIG9mIHRhcmdldHMgZm9yIHdoaWNoIHRoZSBjb250cm9sbGVyIHNob3VsZAotICogbmVnb3RpYXRlIHdpdGggYXQgdGhlIG5leHQgY29udmVuaWVudCBvcG9ydHVuaXR5LiAgVGhpcyBjdXJyZW50bHkKKyAqIG5lZ290aWF0ZSB3aXRoIGF0IHRoZSBuZXh0IGNvbnZlbmllbnQgb3Bwb3J0dW5pdHkuICBUaGlzIGN1cnJlbnRseQogICogbWVhbnMgdGhlIG5leHQgdGltZSB3ZSBzZW5kIHRoZSBpbml0aWFsIGlkZW50aWZ5IG1lc3NhZ2VzIGZvcgogICogYSBuZXcgdHJhbnNhY3Rpb24uCiAgKi8KQEAgLTQxMzEsNyArNDEzMSw3IEBACiAKIAkJLyoKIAkJICogUmVxdWV1ZSBhbGwgdGFnZ2VkIGNvbW1hbmRzIGZvciB0aGlzIHRhcmdldAotCQkgKiBjdXJyZW50bHkgaW4gb3VyIHBvc2Vzc2lvbiBzbyB0aGV5IGNhbiBiZQorCQkgKiBjdXJyZW50bHkgaW4gb3VyIHBvc3Nlc3Npb24gc28gdGhleSBjYW4gYmUKIAkJICogY29udmVydGVkIHRvIHVudGFnZ2VkIGNvbW1hbmRzLgogCQkgKi8KIAkJYWhjX3NlYXJjaF9xaW5maWZvKGFoYywgU0NCX0dFVF9UQVJHRVQoYWhjLCBzY2IpLApAQCAtNDU4MSw3ICs0NTgxLDcgQEAKIC8qCiAgKiBSZXNldCB0aGUgY29udHJvbGxlciBhbmQgcmVjb3JkIHNvbWUgaW5mb3JtYXRpb24gYWJvdXQgaXQKICAqIHRoYXQgaXMgb25seSBhdmFpbGFibGUganVzdCBhZnRlciBhIHJlc2V0LiAgSWYgInJlaW5pdCIgaXMKLSAqIG5vbi16ZXJvLCB0aGlzIHJlc2V0IG9jY3VyZWQgYWZ0ZXIgaW5pdGlhbCBjb25maWd1cmF0aW9uCisgKiBub24temVybywgdGhpcyByZXNldCBvY2N1cnJlZCBhZnRlciBpbml0aWFsIGNvbmZpZ3VyYXRpb24KICAqIGFuZCB0aGUgY2FsbGVyIHJlcXVlc3RzIHRoYXQgdGhlIGNoaXAgYmUgZnVsbHkgcmVpbml0aWFsaXplZAogICogdG8gYSBydW5hYmxlIHN0YXRlLiAgQ2hpcCBpbnRlcnJ1cHRzIGFyZSAqbm90KiBlbmFibGVkIGFmdGVyCiAgKiBhIHJlaW5pdGlhbGl6YXRpb24uICBUaGUgY2FsbGVyIG11c3QgZW5hYmxlIGludGVycnVwdHMgdmlhCkBAIC00ODk5LDcgKzQ4OTksNyBAQAogCWFoYy0+bmV4dF9xdWV1ZWRfc2NiID0gYWhjX2dldF9zY2IoYWhjKTsKIAogCS8qCi0JICogTm90ZSB0aGF0IHdlIHdlcmUgc3VjY2Vzc2Z1bGwKKwkgKiBOb3RlIHRoYXQgd2Ugd2VyZSBzdWNjZXNzZnVsCiAJICovCiAJcmV0dXJuICgwKTsgCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHhfb3NtLmMgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4X29zbS5jCmluZGV4IDRhMzU5YmIuLmM2MjUxYmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHhfb3NtLmMKKysrIGIvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljN3h4eF9vc20uYwpAQCAtMjk0LDcgKzI5NCw3IEBACiAgKiBkdWJpb3VzIGF0IGJlc3QuICBUbyBteSBrbm93bGVkZ2UsIHRoaXMgb3B0aW9uIGhhcyBuZXZlciBhY3R1YWxseQogICogc29sdmVkIGEgUENJIHBhcml0eSBwcm9ibGVtLCBidXQgb24gY2VydGFpbiBtYWNoaW5lcyB3aXRoIGJyb2tlbiBQQ0kKICAqIGNoaXBzZXQgY29uZmlndXJhdGlvbnMgd2hlcmUgc3RyYXkgUENJIHRyYW5zYWN0aW9ucyB3aXRoIGJhZCBwYXJpdHkgYXJlCi0gKiB0aGUgbm9ybSByYXRoZXIgdGhhbiB0aGUgZXhjZXB0aW9uLCB0aGUgZXJyb3IgbWVzc2FnZXMgY2FuIGJlIG92ZXJ3ZWxtaW5nLgorICogdGhlIG5vcm0gcmF0aGVyIHRoYW4gdGhlIGV4Y2VwdGlvbiwgdGhlIGVycm9yIG1lc3NhZ2VzIGNhbiBiZSBvdmVyd2hlbG1pbmcuCiAgKiBJdCdzIGluY2x1ZGVkIGluIHRoZSBkcml2ZXIgZm9yIGNvbXBsZXRlbmVzcy4KICAqICAgMAkgICA9IFNodXQgb2ZmIFBDSSBwYXJpdHkgY2hlY2sKICAqICAgbm9uLTAgPSByZXZlcnNlIHBvbGFyaXR5IHBjaSBwYXJpdHkgY2hlY2tpbmcKQEAgLTEzMTgsNyArMTMxOCw3IEBACiAJCXVzZXJ0YWdzID0gYWhjX2xpbnV4X3VzZXJfdGFnZGVwdGgoYWhjLCBkZXZpbmZvKTsKIAkJaWYgKCF3YXNfcXVldWluZykgewogCQkJLyoKLQkJCSAqIFN0YXJ0IG91dCBhZ3Jlc3NpdmVseSBhbmQgYWxsb3cgb3VyCisJCQkgKiBTdGFydCBvdXQgYWdncmVzc2l2ZWx5IGFuZCBhbGxvdyBvdXIKIAkJCSAqIGR5bmFtaWMgcXVldWUgZGVwdGggYWxnb3JpdGhtIHRvIHRha2UKIAkJCSAqIGNhcmUgb2YgdGhlIHJlc3QuCiAJCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHhfcGNpLmMgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWM3eHh4X3BjaS5jCmluZGV4IDJiMTFhNDIuLjY5MTdiNGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpYzd4eHhfcGNpLmMKKysrIGIvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljN3h4eF9wY2kuYwpAQCAtNzg5LDcgKzc4OSw3IEBACiAJYWhjLT5idXNfaW50ciA9IGFoY19wY2lfaW50cjsKIAlhaGMtPmJ1c19jaGlwX2luaXQgPSBhaGNfcGNpX2NoaXBfaW5pdDsKIAotCS8qIFJlbWViZXIgaG93IHRoZSBjYXJkIHdhcyBzZXR1cCBpbiBjYXNlIHRoZXJlIGlzIG5vIFNFRVBST00gKi8KKwkvKiBSZW1lbWJlciBob3cgdGhlIGNhcmQgd2FzIHNldHVwIGluIGNhc2UgdGhlcmUgaXMgbm8gU0VFUFJPTSAqLwogCWlmICgoYWhjX2luYihhaGMsIEhDTlRSTCkgJiBQT1dSRE4pID09IDApIHsKIAkJYWhjX3BhdXNlKGFoYyk7CiAJCWlmICgoYWhjLT5mZWF0dXJlcyAmIEFIQ19VTFRSQTIpICE9IDApCkBAIC04NjAsNyArODYwLDcgQEAKIAl9CiAKIAkvKgotCSAqIFdlIGNhbm5vdCBwZXJmb3JtIFVMVFJBIHNwZWVkcyB3aXRob3V0IHRoZSBwcmVzZW5zZQorCSAqIFdlIGNhbm5vdCBwZXJmb3JtIFVMVFJBIHNwZWVkcyB3aXRob3V0IHRoZSBwcmVzZW5jZQogCSAqIG9mIHRoZSBleHRlcm5hbCBwcmVjaXNpb24gcmVzaXN0b3IuCiAJICovCiAJaWYgKChhaGMtPmZlYXR1cmVzICYgQUhDX1VMVFJBKSAhPSAwKSB7CkBAIC05NjksNyArOTY5LDcgQEAKIH0KIAogLyoKLSAqIFRlc3QgZm9yIHRoZSBwcmVzZW5zZSBvZiBleHRlcm5hbCBzcmFtIGluIGFuCisgKiBUZXN0IGZvciB0aGUgcHJlc2VuY2Ugb2YgZXh0ZXJuYWwgc3JhbSBpbiBhbgogICogInVuc2hhcmVkIiBjb25maWd1cmF0aW9uLgogICovCiBzdGF0aWMgaW50CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWNhc20vYWljYXNtX2dyYW0ueSBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpY2FzbS9haWNhc21fZ3JhbS55CmluZGV4IGU0MDY0NDMuLmYxNTg2YTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpY2FzbS9haWNhc21fZ3JhbS55CisrKyBiL2RyaXZlcnMvc2NzaS9haWM3eHh4L2FpY2FzbS9haWNhc21fZ3JhbS55CkBAIC04MDMsNyArODAzLDcgQEAKIHwJbWFjcm9fYXJnbGlzdCAnLCcgVF9BUkcKIAl7CiAJCWlmICgkMSA9PSAwKSB7Ci0JCQlzdG9wKCJDb21tYSB3aXRob3V0IHByZWNlZWRpbmcgYXJndW1lbnQgaW4gYXJnIGxpc3QiLAorCQkJc3RvcCgiQ29tbWEgd2l0aG91dCBwcmVjZWRpbmcgYXJndW1lbnQgaW4gYXJnIGxpc3QiLAogCQkJICAgICBFWF9EQVRBRVJSKTsKIAkJCS8qIE5PVFJFQUNIRUQgKi8KIAkJfQpAQCAtMTMxOSw4ICsxMzE5LDggQEAKIDsKIAogCS8qCi0JICogVGhpcyBncmFtbWVyIGRpZmZlcnMgZnJvbSB0aGUgb25lIGluIHRoZSBhaWM3eHh4Ci0JICogcmVmZXJlbmNlIG1hbnVhbCBzaW5jZSB0aGUgZ3JhbW1lciBsaXN0ZWQgdGhlcmUgaXMKKwkgKiBUaGlzIGdyYW1tYXIgZGlmZmVycyBmcm9tIHRoZSBvbmUgaW4gdGhlIGFpYzd4eHgKKwkgKiByZWZlcmVuY2UgbWFudWFsIHNpbmNlIHRoZSBncmFtbWFyIGxpc3RlZCB0aGVyZSBpcwogCSAqIGFtYmlndW91cyBhbmQgY2F1c2VzIGEgc2hpZnQvcmVkdWNlIGNvbmZsaWN0LgogCSAqIEl0IGFsc28gc2VlbXMgbW9yZSBsb2dpY2FsIGFzIHRoZSAiaW1tZWRpYXRlIgogCSAqIGFyZ3VtZW50IGlzIGxpc3RlZCBhcyB0aGUgc2Vjb25kIGFyZyBsaWtlIHRoZQpAQCAtMTc5OSw3ICsxNzk5LDcgQEAKIAlpbnN0ciA9IHNlcV9hbGxvYygpOwogCWYzX2luc3RyID0gJmluc3RyLT5mb3JtYXQuZm9ybWF0MzsKIAlpZiAoYWRkcmVzcy0+c3ltYm9sID09IE5VTEwpIHsKLQkJLyogJ2RvdCcgcmVmZXJyZW5jZS4gIFVzZSB0aGUgY3VycmVudCBpbnN0cnVjdGlvbiBwb2ludGVyICovCisJCS8qICdkb3QnIHJlZmVyZW5jZS4gIFVzZSB0aGUgY3VycmVudCBpbnN0cnVjdGlvbiBwb2ludGVyICovCiAJCWFkZHIgPSBpbnN0cnVjdGlvbl9wdHIgKyBhZGRyZXNzLT5vZmZzZXQ7CiAJfSBlbHNlIGlmIChhZGRyZXNzLT5zeW1ib2wtPnR5cGUgPT0gVU5JTklUSUFMSVpFRCkgewogCQkvKiBmb3J3YXJkIHJlZmVyZW5jZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FpYzd4eHgvYWljYXNtL2FpY2FzbV9tYWNyb19ncmFtLnkgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWNhc20vYWljYXNtX21hY3JvX2dyYW0ueQppbmRleCBmZjQ2YWE2Li43MDgzMjZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWNhc20vYWljYXNtX21hY3JvX2dyYW0ueQorKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eC9haWNhc20vYWljYXNtX21hY3JvX2dyYW0ueQpAQCAtMTE1LDcgKzExNSw3IEBACiB8CW1hY3JvX2FyZ2xpc3QgJywnIFRfQVJHCiAJewogCQlpZiAoJDEgPT0gMCkgewotCQkJc3RvcCgiQ29tbWEgd2l0aG91dCBwcmVjZWVkaW5nIGFyZ3VtZW50IGluIGFyZyBsaXN0IiwKKwkJCXN0b3AoIkNvbW1hIHdpdGhvdXQgcHJlY2VkaW5nIGFyZ3VtZW50IGluIGFyZyBsaXN0IiwKIAkJCSAgICAgRVhfREFUQUVSUik7CiAJCQkvKiBOT1RSRUFDSEVEICovCiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9haWM3eHh4X29sZC5jIGIvZHJpdmVycy9zY3NpL2FpYzd4eHhfb2xkLmMKaW5kZXggNGZmNjBhMC4uNWIyMTJmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2FpYzd4eHhfb2xkLmMKKysrIGIvZHJpdmVycy9zY3NpL2FpYzd4eHhfb2xkLmMKQEAgLTkwNSw3ICs5MDUsNyBAQAogICogcHJvYmxlbXMgd2l0aCBhcmNoaXRlY3R1cmVzIEkgY2FuJ3QgdGVzdCBvbiAoYmVjYXVzZSBJIGRvbid0IGhhdmUgb25lLAogICogc3VjaCBhcyB0aGUgQWxwaGEgYmFzZWQgc3lzdGVtcykgd2hpY2ggaGFwcGVuIHRvIGdpdmUgZmF1bHRzIGZvcgogICogbm9uLWFsaWduZWQgbWVtb3J5IGFjY2Vzc2VzLCBjYXJlIHdhcyB0YWtlbiB0byBhbGlnbiB0aGlzIHN0cnVjdHVyZQotICogaW4gYSB3YXkgdGhhdCBnYXVyYW50ZWVkIGFsbCBhY2Nlc3NlcyBsYXJnZXIgdGhhbiA4IGJpdHMgd2VyZSBhbGlnbmVkCisgKiBpbiBhIHdheSB0aGF0IGd1YXJhbnRlZWQgYWxsIGFjY2Vzc2VzIGxhcmdlciB0aGFuIDggYml0cyB3ZXJlIGFsaWduZWQKICAqIG9uIHRoZSBhcHByb3ByaWF0ZSBib3VuZGFyeS4gIEl0J3MgYWxzbyBvcmdhbml6ZWQgdG8gdHJ5IGFuZCBiZSBtb3JlCiAgKiBjYWNoZSBsaW5lIGVmZmljaWVudC4gIEJlIGNhcmVmdWwgd2hlbiBjaGFuZ2luZyB0aGlzIGxlc3QgeW91IG1pZ2h0IGh1cnQKICAqIG92ZXJhbGwgcGVyZm9ybWFuY2UgYW5kIGJyaW5nIGRvd24gdGhlIHdyYXRoIG9mIHRoZSBtYXNzZXMuCkBAIC0xMTgwLDcgKzExODAsNyBAQAogICogdGhlIGNhcmQncyByZWdpc3RlcnMgaW4gYSBoZXggZHVtcCBmb3JtYXQgdGFpbG9yZWQgdG8gZWFjaCBtb2RlbCBvZgogICogY29udHJvbGxlci4KICAqIAotICogTk9URTogVEhFIENPTlRST0xMRVIgSVMgTEVGVCBJTiBBTiBVTlVTRUFCTEUgU1RBVEUgQlkgVEhJUyBPUFRJT04uCisgKiBOT1RFOiBUSEUgQ09OVFJPTExFUiBJUyBMRUZUIElOIEFOIFVOVVNBQkxFIFNUQVRFIEJZIFRISVMgT1BUSU9OLgogICogICAgICAgWU9VIENBTk5PVCBCT09UIFVQIFdJVEggVEhJUyBPUFRJT04sIElUIElTIEZPUiBERUJVR0dJTkcgUFVSUE9TRVMKICAqICAgICAgIE9OTFkKICAqLwpAQCAtMzQ2Nyw3ICszNDY3LDcgQEAKICAgLyogVHVybiBvZmYgdGhlIGJ1cycgY3VycmVudCBvcGVyYXRpb25zLCBhZnRlciBhbGwsIHdlIHNob3VsZG4ndCBoYXZlIGFueQogICAgKiB2YWxpZCBjb21tYW5kcyBsZWZ0IHRvIGNhdXNlIGEgUlNFTEkgYW5kIFNFTE8gb25jZSB3ZSd2ZSB0b3NzZWQgdGhlCiAgICAqIGJ1cyBhd2F5IHdpdGggdGhpcyByZXNldCwgc28gd2UgbWlnaHQgYXMgd2VsbCBzaHV0IGRvd24gdGhlIHNlcXVlbmNlcgotICAgKiB1bnRpbCB0aGUgYnVzIGlzIHJlc3RhcnRlZCBhcyBvcHBvc3NlZCB0byBzYXZpbmcgdGhlIGN1cnJlbnQgc2V0dGluZ3MKKyAgICogdW50aWwgdGhlIGJ1cyBpcyByZXN0YXJ0ZWQgYXMgb3Bwb3NlZCB0byBzYXZpbmcgdGhlIGN1cnJlbnQgc2V0dGluZ3MKICAgICogYW5kIHJlc3RvcmluZyB0aGVtICh3aGljaCBtYWtlcyBubyBzZW5zZSB0byBtZSkuICovCiAKICAgLyogVHVybiBvbiB0aGUgYnVzIHJlc2V0LiAqLwpAQCAtNDA3MCw3ICs0MDcwLDcgQEAKICAgICAgICAgICAgIGFpY19kZXYtPm1heF9xX2RlcHRoID0gYWljX2Rldi0+dGVtcF9xX2RlcHRoID0gMTsKICAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAgKiBXZSBzZXQgdGhpcyBjb21tYW5kIHVwIGFzIGEgYnVzIGRldmljZSByZXNldC4gIEhvd2V2ZXIsIHdlIGhhdmUKLSAgICAgICAgICAgICAqIHRvIGNsZWFyIHRoZSB0YWcgdHlwZSBhcyBpdCdzIGNhdXNpbmcgdXMgcHJvYmxlbXMuICBXZSBzaG91bGRudAorICAgICAgICAgICAgICogdG8gY2xlYXIgdGhlIHRhZyB0eXBlIGFzIGl0J3MgY2F1c2luZyB1cyBwcm9ibGVtcy4gIFdlIHNob3VsZG4ndAogICAgICAgICAgICAgICogaGF2ZSB0byB3b3JyeSBhYm91dCBhbnkgb3RoZXIgY29tbWFuZHMgYmVpbmcgYWN0aXZlLCBzaW5jZSBpZgogICAgICAgICAgICAgICogdGhlIGRldmljZSBpcyByZWZ1c2luZyB0YWdnZWQgY29tbWFuZHMsIHRoaXMgc2hvdWxkIGJlIHRoZQogICAgICAgICAgICAgICogZmlyc3QgdGFnZ2VkIGNvbW1hbmQgc2VudCB0byB0aGUgZGV2aWNlLCBob3dldmVyLCB3ZSBkbyBoYXZlCkBAIC05NzQ4LDcgKzk3NDgsNyBAQAogICAgIH0KIAogICAgIC8qCi0gICAgICogV2UgYXJlIGNvbW1pdGVkIG5vdywgZXZlcnl0aGluZyBoYXMgYmVlbiBjaGVja2VkIGFuZCB0aGlzIGNhcmQKKyAgICAgKiBXZSBhcmUgY29tbWl0dGVkIG5vdywgZXZlcnl0aGluZyBoYXMgYmVlbiBjaGVja2VkIGFuZCB0aGlzIGNhcmQKICAgICAgKiBoYXMgYmVlbiBmb3VuZCwgbm93IHdlIGp1c3Qgc2V0IGl0IHVwCiAgICAgICovCiAKQEAgLTk5MDYsNyArOTkwNiw3IEBACiAgICAqICAyOiBBbGwgUENJIGNvbnRyb2xsZXJzIHdpdGggQklPU19FTkFCTEVEIG5leHQsIGFjY29yZGluZyB0byBCSU9TCiAgICAqICAgICBhZGRyZXNzLCBnb2luZyBmcm9tIGxvd2VzdCB0byBoaWdoZXN0LgogICAgKiAgMzogUmVtYWluaW5nIFZMQi9FSVNBIGNvbnRyb2xsZXJzIGdvaW5nIGluIHNsb3Qgb3JkZXIuCi0gICAqICA0OiBSZW1haW5pbmcgUENJIGNvbnRyb2xsZXJzLCBnb2luZyBpbiBQQ0kgZGV2aWNlIG9yZGVyIChyZXZlcnNhYmxlKQorICAgKiAgNDogUmVtYWluaW5nIFBDSSBjb250cm9sbGVycywgZ29pbmcgaW4gUENJIGRldmljZSBvcmRlciAocmV2ZXJzaWJsZSkKICAgICovCiAKICAgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FpYzd4eHhfb2xkL2FpYzd4eHguc2VxIGIvZHJpdmVycy9zY3NpL2FpYzd4eHhfb2xkL2FpYzd4eHguc2VxCmluZGV4IDE1NjViZTkuLjgyM2ZmMjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9haWM3eHh4X29sZC9haWM3eHh4LnNlcQorKysgYi9kcml2ZXJzL3Njc2kvYWljN3h4eF9vbGQvYWljN3h4eC5zZXEKQEAgLTUxLDcgKzUxLDcgQEAKICAqIHVzZSBieXRlIDI3IG9mIHRoZSBTQ0IgYXMgYSBwc2V1ZG8tbmV4dCBwb2ludGVyIGFuZCB0byB0aHJlYWQgYSBsaXN0CiAgKiBvZiBTQ0JzIHRoYXQgYXJlIGF3YWl0aW5nIHNlbGVjdGlvbi4gIFNpbmNlIDAtMHhmZSBhcmUgdmFsaWQgU0NCIGluZGV4ZXMsIAogICogU0NCX0xJU1RfTlVMTCBpcyAweGZmIHdoaWNoIGlzIG91dCBvZiByYW5nZS4gIEFuIGVudHJ5IGlzIGFsc28gYWRkZWQgdG8KLSAqIHRoaXMgbGlzdCBldmVyeXRpbWUgYSByZXF1ZXN0IHNlbnNlIG9jY3VycyBvciBhZnRlciBjb21wbGV0aW5nIGEgbm9uLXRhZ2dlZAorICogdGhpcyBsaXN0IGV2ZXJ5IHRpbWUgYSByZXF1ZXN0IHNlbnNlIG9jY3VycyBvciBhZnRlciBjb21wbGV0aW5nIGEgbm9uLXRhZ2dlZAogICogY29tbWFuZCBmb3Igd2hpY2ggYSBzZWNvbmQgU0NCIGhhcyBiZWVuIHF1ZXVlZC4gIFRoZSBzZXF1ZW5jZXIgd2lsbAogICogYXV0b21hdGljYWxseSBjb25zdW1lIHRoZSBlbnRyaWVzLgogICovCkBAIC02OTYsNyArNjk2LDcgQEAKICAqIFRoaXMgaXMgZG9uZSB0byBhbGxvdyB0aGUgaHNvdCB0byBzZW5kIG1lc3NhZ2VzIG91dHNpZGUgb2YgYW4gaWRlbnRpZnkKICAqIHNlcXVlbmNlIHdoaWxlIHByb3RlY3RpbmcgdGhlIHNlcWVuY2VyIGZyb20gdGVzdGluZyB0aGUgTUtfTUVTU0FHRSBiaXQKICAqIG9uIGFuIFNDQiB0aGF0IG1pZ2h0IG5vdCBiZSBmb3IgdGhlIGN1cnJlbnQgbmV4dXMuIChGb3IgZXhhbXBsZSwgYQotICogQkRSIG1lc3NhZ2UgaW4gcmVzcG9uY2UgdG8gYSBiYWQgcmVzZWxlY3Rpb24gd291bGQgbGVhdmUgdXMgcG9pbnRlZCB0bworICogQkRSIG1lc3NhZ2UgaW4gcmVzcG9uc2UgdG8gYSBiYWQgcmVzZWxlY3Rpb24gd291bGQgbGVhdmUgdXMgcG9pbnRlZCB0bwogICogYW4gU0NCIHRoYXQgZG9lc24ndCBoYXZlIGFueXRoaW5nIHRvIGRvIHdpdGggdGhlIGN1cnJlbnQgdGFyZ2V0KS4KICAqIE90aGVyd2lzZSwgdHJlYXQgTVNHX09VVCBhcyBhIDEgYnl0ZSBtZXNzYWdlIHRvIHNlbmQgKGFib3J0LCBhYm9ydCB0YWcsCiAgKiBidXMgZGV2aWNlIHJlc2V0KS4KQEAgLTcxNiw4ICs3MTYsOCBAQAogCX0gZWxzZSB7CiAJCWFuZAlTSU5ERVgsMHg3LFNDQl9UQ0w7CS8qIGx1biAqLwogCX0KLQlhbmQJQSxESVNDRU5CLFNDQl9DT05UUk9MOwkvKiBtYXNrIG9mZiBkaXNjb25uZWN0IHByaXZsZWRnZSAqLwotCW9yCVNJTkRFWCxBOwkJLyogb3IgaW4gZGlzY29ubmVjdCBwcml2bGVkZ2UgKi8KKwlhbmQJQSxESVNDRU5CLFNDQl9DT05UUk9MOwkvKiBtYXNrIG9mZiBkaXNjb25uZWN0IHByaXZpbGVnZSAqLworCW9yCVNJTkRFWCxBOwkJLyogb3IgaW4gZGlzY29ubmVjdCBwcml2aWxlZ2UgKi8KIAlvcglTSU5ERVgsTVNHX0lERU5USUZZRkxBRzsKIHBfbWVzZ291dF9ta19tZXNzYWdlOgogCXRlc3QJU0NCX0NPTlRST0wsTUtfTUVTU0FHRSAganogcF9tZXNnb3V0X3RhZzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9haWM5NHh4L2FpYzk0eHhfcmVnX2RlZi5oIGIvZHJpdmVycy9zY3NpL2FpYzk0eHgvYWljOTR4eF9yZWdfZGVmLmgKaW5kZXggNDAyNzNhNy4uZGQ2Y2M4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2FpYzk0eHgvYWljOTR4eF9yZWdfZGVmLmgKKysrIGIvZHJpdmVycy9zY3NpL2FpYzk0eHgvYWljOTR4eF9yZWdfZGVmLmgKQEAgLTIxMzQsNyArMjEzNCw3IEBACiAqIFRoZSBob3N0IGFjY2Vzc2VzIHRoaXMgc2NyYXRjaCBpbiBhIGRpZmZlcmVudCBtYW5uZXIgZnJvbSB0aGUKICogbGluayBzZXF1ZW5jZXIuIFRoZSBzZXF1ZW5jZXIgaGFzIHRvIHVzZSBMU0VRIHJlZ2lzdGVycwogKiBMbVNDUlBBR0UgYW5kIExtTW5TQ1JQQUdFIHRvIGFjY2VzcyB0aGUgc2NyYXRjaCBtZW1vcnkuIEEgZmxhdAotKiBtYXBwaW5nIG9mIHRoZSBzY3JhdGNoIG1lbW9yeSBpcyBhdmFsaWFibGUgZm9yIHNvZnR3YXJlCisqIG1hcHBpbmcgb2YgdGhlIHNjcmF0Y2ggbWVtb3J5IGlzIGF2YWlsYWJsZSBmb3Igc29mdHdhcmUKICogY29udmVuaWVuY2UgYW5kIHRvIHByZXZlbnQgY29ycnVwdGlvbiB3aGlsZSB0aGUgc2VxdWVuY2VyIGlzCiAqIHJ1bm5pbmcuIFRoaXMgbWVtb3J5IGlzIG1hcHBlZCBvbnRvIGFkZHJlc3NlcyA4MDBoIC0gOUZGaC4KICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9hcm0vYWNvcm5zY3NpLmMgYi9kcml2ZXJzL3Njc2kvYXJtL2Fjb3Juc2NzaS5jCmluZGV4IGVjMTY2NzIuLmM0NTRlNDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hcm0vYWNvcm5zY3NpLmMKKysrIGIvZHJpdmVycy9zY3NpL2FybS9hY29ybnNjc2kuYwpAQCAtMTAwLDcgKzEwMCw3IEBACiAgKi8KICNkZWZpbmUgVElNRU9VVF9USU1FIDEwCiAvKgotICogRGVmaW5lIHRoaXMgaWYgeW91IHdhbnQgdG8gaGF2ZSB2ZXJib3NlIGV4cGxhaW5hdGlvbiBvZiBTQ1NJCisgKiBEZWZpbmUgdGhpcyBpZiB5b3Ugd2FudCB0byBoYXZlIHZlcmJvc2UgZXhwbGFuYXRpb24gb2YgU0NTSQogICogc3RhdHVzL21lc3NhZ2VzLgogICovCiAjdW5kZWYgQ09ORklHX0FDT1JOU0NTSV9DT05TVEFOVFMKQEAgLTE1NjEsNyArMTU2MSw3IEBACiAJLyoKIAkgKiBJZiB3ZSB3ZXJlIG5lZ29jaWF0aW5nIHN5bmMgdHJhbnNmZXIsIHdlIGRvbid0IHlldCBrbm93IGlmCiAJICogdGhpcyBSRUpFQ1QgaXMgZm9yIHRoZSBzeW5jIHRyYW5zZmVyIG9yIGZvciB0aGUgdGFnZ2VkIHF1ZXVlL3dpZGUKLQkgKiB0cmFuc2Zlci4gIFJlLWluaXRpYXRlIHN5bmMgdHJhbnNmZXIgbmVnb2NpYXRpb24gbm93LCBhbmQgaWYKKwkgKiB0cmFuc2Zlci4gIFJlLWluaXRpYXRlIHN5bmMgdHJhbnNmZXIgbmVnb3RpYXRpb24gbm93LCBhbmQgaWYKIAkgKiB3ZSBnb3QgYSBSRUpFQ1QgaW4gcmVzcG9uc2UgdG8gU0RUUiwgdGhlbiBpdCdsbCBiZSBzZXQgdG8gRE9ORS4KIAkgKi8KIAlpZiAoaG9zdC0+ZGV2aWNlW2hvc3QtPlNDcG50LT5kZXZpY2UtPmlkXS5zeW5jX3N0YXRlID09IFNZTkNfU0VOVF9SRVFVRVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FybS9hY29ybnNjc2kuaCBiL2RyaXZlcnMvc2NzaS9hcm0vYWNvcm5zY3NpLmgKaW5kZXggOGQyMTcyYS4uMDFiYzcxNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2FybS9hY29ybnNjc2kuaAorKysgYi9kcml2ZXJzL3Njc2kvYXJtL2Fjb3Juc2NzaS5oCkBAIC0yMjMsOCArMjIzLDggQEAKICAqIFN5bmNocm9ub3VzIHRyYW5zZmVyIHN0YXRlCiAgKi8KIHR5cGVkZWYgZW51bSB7CQkJCQkvKiBTeW5jaHJvbm91cyB0cmFuc2ZlciBzdGF0ZQkJKi8KLSAgICBTWU5DX0FTWU5DSFJPTk9VUywJCQkJLyogZG9uJ3QgbmVnb2NpYXRlIHN5bmNocm9ub3VzIHRyYW5zZmVycyovCi0gICAgU1lOQ19ORUdPQ0lBVEUsCQkJCS8qIHN0YXJ0IG5lZ29jaWF0aW9uCQkJKi8KKyAgICBTWU5DX0FTWU5DSFJPTk9VUywJCQkJLyogZG9uJ3QgbmVnb3RpYXRlIHN5bmNocm9ub3VzIHRyYW5zZmVycyovCisgICAgU1lOQ19ORUdPQ0lBVEUsCQkJCS8qIHN0YXJ0IG5lZ290aWF0aW9uCQkJKi8KICAgICBTWU5DX1NFTlRfUkVRVUVTVCwJCQkJLyogc2VudCBTRFRSIG1lc3NhZ2UJCQkqLwogICAgIFNZTkNfQ09NUExFVEVELAkJCQkvKiByZWNlaXZlZCBTRFRSIHJlcGx5CQkJKi8KIH0gc3luY3hmZXJfdDsKQEAgLTMyMiw3ICszMjIsNyBAQAogICAgIC8qIHBlci1kZXZpY2UgaW5mbyAqLwogICAgIHN0cnVjdCB7CiAJdW5zaWduZWQgY2hhcglzeW5jX3hmZXI7CQkvKiBzeW5jaHJvbm91cyB0cmFuc2ZlciAoU0JJQyB2YWx1ZSkJKi8KLQlzeW5jeGZlcl90CXN5bmNfc3RhdGU7CQkvKiBzeW5jIHhmZXIgbmVnb2NpYXRpb24gc3RhdGUJCSovCisJc3luY3hmZXJfdAlzeW5jX3N0YXRlOwkJLyogc3luYyB4ZmVyIG5lZ290aWF0aW9uIHN0YXRlCQkqLwogCXVuc2lnbmVkIGNoYXIJZGlzY29ubmVjdF9vazoxOwkvKiBkZXZpY2UgY2FuIGRpc2Nvbm5lY3QJCSovCiAgICAgfSBkZXZpY2VbOF07CiAgICAgdW5zaWduZWQgbG9uZwlidXN5bHVuc1s2NCAvIHNpemVvZih1bnNpZ25lZCBsb25nKV07LyogYXJyYXkgb2YgYml0cyBpbmRpY2F0aW5nIExVTnMgYnVzeQkqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FybS9hcnhlc2NzaS5jIGIvZHJpdmVycy9zY3NpL2FybS9hcnhlc2NzaS5jCmluZGV4IDI4MzZmZTIuLmE3NTBhYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hcm0vYXJ4ZXNjc2kuYworKysgYi9kcml2ZXJzL3Njc2kvYXJtL2FyeGVzY3NpLmMKQEAgLTIyOCw3ICsyMjgsNyBAQAogICogUGFyYW1zICA6IGJ1ZmZlciAtIGEgYnVmZmVyIHRvIHdyaXRlIGluZm9ybWF0aW9uIHRvCiAgKgkgICAgIHN0YXJ0ICAtIGEgcG9pbnRlciBpbnRvIHRoaXMgYnVmZmVyIHNldCBieSB0aGlzIHJvdXRpbmUgdG8gdGhlIHN0YXJ0CiAgKgkJICAgICAgb2YgdGhlIHJlcXVpcmVkIGluZm9ybWF0aW9uLgotICoJICAgICBvZmZzZXQgLSBvZmZzZXQgaW50byBpbmZvcm1hdGlvbiB0aGF0IHdlIGhhdmUgcmVhZCB1cHRvLgorICoJICAgICBvZmZzZXQgLSBvZmZzZXQgaW50byBpbmZvcm1hdGlvbiB0aGF0IHdlIGhhdmUgcmVhZCB1cCB0by4KICAqCSAgICAgbGVuZ3RoIC0gbGVuZ3RoIG9mIGJ1ZmZlcgogICoJICAgICBob3N0X25vIC0gaG9zdCBudW1iZXIgdG8gcmV0dXJuIGluZm9ybWF0aW9uIGZvcgogICoJICAgICBpbm91dCAgLSAwIGZvciByZWFkaW5nLCAxIGZvciB3cml0aW5nLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FybS9jdW1hbmFfMi5jIGIvZHJpdmVycy9zY3NpL2FybS9jdW1hbmFfMi5jCmluZGV4IGM5OTAyYjUuLjU0Nzk4N2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hcm0vY3VtYW5hXzIuYworKysgYi9kcml2ZXJzL3Njc2kvYXJtL2N1bWFuYV8yLmMKQEAgLTM0NCw3ICszNDQsNyBAQAogICogUGFyYW1zICAgOiBidWZmZXIgLSBhIGJ1ZmZlciB0byB3cml0ZSBpbmZvcm1hdGlvbiB0bwogICoJICAgICAgc3RhcnQgIC0gYSBwb2ludGVyIGludG8gdGhpcyBidWZmZXIgc2V0IGJ5IHRoaXMgcm91dGluZSB0byB0aGUgc3RhcnQKICAqCQkgICAgICAgb2YgdGhlIHJlcXVpcmVkIGluZm9ybWF0aW9uLgotICoJICAgICAgb2Zmc2V0IC0gb2Zmc2V0IGludG8gaW5mb3JtYXRpb24gdGhhdCB3ZSBoYXZlIHJlYWQgdXB0by4KKyAqCSAgICAgIG9mZnNldCAtIG9mZnNldCBpbnRvIGluZm9ybWF0aW9uIHRoYXQgd2UgaGF2ZSByZWFkIHVwIHRvLgogICoJICAgICAgbGVuZ3RoIC0gbGVuZ3RoIG9mIGJ1ZmZlcgogICoJICAgICAgaG9zdF9ubyAtIGhvc3QgbnVtYmVyIHRvIHJldHVybiBpbmZvcm1hdGlvbiBmb3IKICAqCSAgICAgIGlub3V0ICAtIDAgZm9yIHJlYWRpbmcsIDEgZm9yIHdyaXRpbmcuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYXJtL2Vlc294LmMgYi9kcml2ZXJzL3Njc2kvYXJtL2Vlc294LmMKaW5kZXggZDg0MzUxMy4uZWRmZDEyYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2FybS9lZXNveC5jCisrKyBiL2RyaXZlcnMvc2NzaS9hcm0vZWVzb3guYwpAQCAtNDI5LDcgKzQyOSw3IEBACiAgKiBQYXJhbXMgICA6IGJ1ZmZlciAtIGEgYnVmZmVyIHRvIHdyaXRlIGluZm9ybWF0aW9uIHRvCiAgKgkgICAgICBzdGFydCAgLSBhIHBvaW50ZXIgaW50byB0aGlzIGJ1ZmZlciBzZXQgYnkgdGhpcyByb3V0aW5lIHRvIHRoZSBzdGFydAogICoJCSAgICAgICBvZiB0aGUgcmVxdWlyZWQgaW5mb3JtYXRpb24uCi0gKgkgICAgICBvZmZzZXQgLSBvZmZzZXQgaW50byBpbmZvcm1hdGlvbiB0aGF0IHdlIGhhdmUgcmVhZCB1cHRvLgorICoJICAgICAgb2Zmc2V0IC0gb2Zmc2V0IGludG8gaW5mb3JtYXRpb24gdGhhdCB3ZSBoYXZlIHJlYWQgdXAgdG8uCiAgKgkgICAgICBsZW5ndGggLSBsZW5ndGggb2YgYnVmZmVyCiAgKgkgICAgICBob3N0X25vIC0gaG9zdCBudW1iZXIgdG8gcmV0dXJuIGluZm9ybWF0aW9uIGZvcgogICoJICAgICAgaW5vdXQgIC0gMCBmb3IgcmVhZGluZywgMSBmb3Igd3JpdGluZy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9hcm0vZmFzMjE2LmMgYi9kcml2ZXJzL3Njc2kvYXJtL2ZhczIxNi5jCmluZGV4IDJiMmNlMjEuLmU4NWM0MGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hcm0vZmFzMjE2LmMKKysrIGIvZHJpdmVycy9zY3NpL2FybS9mYXMyMTYuYwpAQCAtMjExOSw3ICsyMTE5LDcgQEAKIAkgKiBleGVjdXRlZCwgdW5sZXNzIGEgdGFyZ2V0IGNvbm5lY3RzIHRvIHVzLgogCSAqLwogCWlmIChpbmZvLT5yZXFTQ3BudCkKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAic2NzaSVkLiVjOiBsb29zaW5nIHJlcXVlc3QgY29tbWFuZFxuIiwKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAic2NzaSVkLiVjOiBsb3NpbmcgcmVxdWVzdCBjb21tYW5kXG4iLAogCQkJaW5mby0+aG9zdC0+aG9zdF9ubywgJzAnICsgU0NwbnQtPmRldmljZS0+aWQpOwogCWluZm8tPnJlcVNDcG50ID0gU0NwbnQ7CiB9CkBAIC0yMjk0LDcgKzIyOTQsNyBAQAogCQkgKiBJZiB3ZSBkb24ndCBoYXZlIGFuIElSUSwgdGhlbiB3ZSBtdXN0IHBvbGwgdGhlIGNhcmQgZm9yCiAJCSAqIGl0J3MgaW50ZXJydXB0LCBhbmQgdXNlIHRoYXQgdG8gY2FsbCB0aGlzIGRyaXZlcidzCiAJCSAqIGludGVycnVwdCByb3V0aW5lLiAgVGhhdCB3YXksIHdlIGtlZXAgdGhlIGNvbW1hbmQKLQkJICogcHJvZ3Jlc3NpbmcuICBNYXliZSB3ZSBjYW4gYWRkIHNvbWUgaW50ZWxpZ2VuY2UgaGVyZQorCQkgKiBwcm9ncmVzc2luZy4gIE1heWJlIHdlIGNhbiBhZGQgc29tZSBpbnRlbGxpZ2VuY2UgaGVyZQogCQkgKiBhbmQgZ28gdG8gc2xlZXAgaWYgd2Uga25vdyB0aGF0IHRoZSBkZXZpY2UgaXMgZ29pbmcKIAkJICogdG8gYmUgc29tZSB0aW1lIChlZywgZGlzY29ubmVjdGVkKS4KIAkJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYXJtL2ZhczIxNi5oIGIvZHJpdmVycy9zY3NpL2FybS9mYXMyMTYuaAppbmRleCBmMzBmOGQ2Li44NGI3MTI3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYXJtL2ZhczIxNi5oCisrKyBiL2RyaXZlcnMvc2NzaS9hcm0vZmFzMjE2LmgKQEAgLTIwMywxMSArMjAzLDExIEBACiB9IGZhc2RtYXR5cGVfdDsKIAogdHlwZWRlZiBlbnVtIHsKLQluZWdfd2FpdCwJCQkJCS8qIE5lZ29jaWF0ZSB3aXRoIGRldmljZQkJKi8KLQluZWdfaW5wcm9ncmVzcywJCQkJCS8qIE5lZ29jaWF0aW9uIHNlbnQJCQkqLwotCW5lZ19jb21wbGV0ZSwJCQkJCS8qIE5lZ29jaWF0aW9uIGNvbXBsZXRlCQkJKi8KLQluZWdfdGFyZ2NvbXBsZXRlLAkJCQkvKiBUYXJnZXQgY29tcGxldGVkIG5lZ29jaWF0aW9uCQkqLwotCW5lZ19pbnZhbGlkCQkJCQkvKiBOZWdvY2lhdGlvbiBub3Qgc3VwcG9ydGVkCQkqLworCW5lZ193YWl0LAkJCQkJLyogTmVnb3RpYXRlIHdpdGggZGV2aWNlCQkqLworCW5lZ19pbnByb2dyZXNzLAkJCQkJLyogTmVnb3RpYXRpb24gc2VudAkJCSovCisJbmVnX2NvbXBsZXRlLAkJCQkJLyogTmVnb3RpYXRpb24gY29tcGxldGUJCQkqLworCW5lZ190YXJnY29tcGxldGUsCQkJCS8qIFRhcmdldCBjb21wbGV0ZWQgbmVnb3RpYXRpb24JCSovCisJbmVnX2ludmFsaWQJCQkJCS8qIE5lZ290aWF0aW9uIG5vdCBzdXBwb3J0ZWQJCSovCiB9IG5lZ190OwogCiAjZGVmaW5lIE1BR0lDCTB4NDQxMjk2YmRVTApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FybS9wb3dlcnRlYy5jIGIvZHJpdmVycy9zY3NpL2FybS9wb3dlcnRlYy5jCmluZGV4IGUyMjk3YjQuLjkyNzRjMDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hcm0vcG93ZXJ0ZWMuYworKysgYi9kcml2ZXJzL3Njc2kvYXJtL3Bvd2VydGVjLmMKQEAgLTIzMiw3ICsyMzIsNyBAQAogICogUGFyYW1zICAgOiBidWZmZXIgIC0gYSBidWZmZXIgdG8gd3JpdGUgaW5mb3JtYXRpb24gdG8KICAqCSAgICAgIHN0YXJ0ICAgLSBhIHBvaW50ZXIgaW50byB0aGlzIGJ1ZmZlciBzZXQgYnkgdGhpcyByb3V0aW5lIHRvIHRoZSBzdGFydAogICoJCSAgICAgICAgb2YgdGhlIHJlcXVpcmVkIGluZm9ybWF0aW9uLgotICoJICAgICAgb2Zmc2V0ICAtIG9mZnNldCBpbnRvIGluZm9ybWF0aW9uIHRoYXQgd2UgaGF2ZSByZWFkIHVwdG8uCisgKgkgICAgICBvZmZzZXQgIC0gb2Zmc2V0IGludG8gaW5mb3JtYXRpb24gdGhhdCB3ZSBoYXZlIHJlYWQgdXAgdG8uCiAgKgkgICAgICBsZW5ndGggIC0gbGVuZ3RoIG9mIGJ1ZmZlcgogICoJICAgICAgaW5vdXQgICAtIDAgZm9yIHJlYWRpbmcsIDEgZm9yIHdyaXRpbmcuCiAgKiBSZXR1cm5zICA6IGxlbmd0aCBvZiBkYXRhIHdyaXR0ZW4gdG8gYnVmZmVyLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2F0YXJpX05DUjUzODAuYyBiL2RyaXZlcnMvc2NzaS9hdGFyaV9OQ1I1MzgwLmMKaW5kZXggODhiMjkyOC4uZWE0MzlmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2F0YXJpX05DUjUzODAuYworKysgYi9kcml2ZXJzL3Njc2kvYXRhcmlfTkNSNTM4MC5jCkBAIC00NjQsNyArNDY0LDcgQEAKICAqCiAgKiBQYXJhbWV0ZXJzOiBTY3NpX0NtbmQgKmNtZAogICogICAgVGhlIGNvbW1hbmQgdG8gd29yayBvbi4gVGhlIGZpcnN0IHNjYXR0ZXIgYnVmZmVyJ3MgZGF0YSBhcmUKLSAqICAgIGFzc3VtZWQgdG8gYmUgYWxyZWFkeSB0cmFuc2ZlcmVkIGludG8gcHRyL3RoaXNfcmVzaWR1YWwuCisgKiAgICBhc3N1bWVkIHRvIGJlIGFscmVhZHkgdHJhbnNmZXJyZWQgaW50byBwdHIvdGhpc19yZXNpZHVhbC4KICAqLwogCiBzdGF0aWMgdm9pZCBtZXJnZV9jb250aWd1b3VzX2J1ZmZlcnMoU2NzaV9DbW5kICpjbWQpCkBAIC0xNzIwLDcgKzE3MjAsNyBAQAogICoJYnl0ZXMgdG8gdHJhbnNmZXIsICoqZGF0YSAtIHBvaW50ZXIgdG8gZGF0YSBwb2ludGVyLgogICoKICAqIFJldHVybnMgOiAtMSB3aGVuIGRpZmZlcmVudCBwaGFzZSBpcyBlbnRlcmVkIHdpdGhvdXQgdHJhbnNmZXJyaW5nCi0gKgltYXhpbXVtIG51bWJlciBvZiBieXRlcywgMCBpZiBhbGwgYnl0ZXMgYXJlIHRyYW5zZmVyZWQgb3IgZXhpdAorICoJbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMsIDAgaWYgYWxsIGJ5dGVzIGFyZSB0cmFuc2ZlcnJlZCBvciBleGl0CiAgKglpcyBpbiBzYW1lIHBoYXNlLgogICoKICAqCUFsc28sICpwaGFzZSwgKmNvdW50LCAqZGF0YSBhcmUgbW9kaWZpZWQgaW4gcGxhY2UuCkBAIC0xOTExLDcgKzE5MTEsNyBAQAogICoJYnl0ZXMgdG8gdHJhbnNmZXIsICoqZGF0YSAtIHBvaW50ZXIgdG8gZGF0YSBwb2ludGVyLgogICoKICAqIFJldHVybnMgOiAtMSB3aGVuIGRpZmZlcmVudCBwaGFzZSBpcyBlbnRlcmVkIHdpdGhvdXQgdHJhbnNmZXJyaW5nCi0gKgltYXhpbXVtIG51bWJlciBvZiBieXRlcywgMCBpZiBhbGwgYnl0ZXMgb3IgdHJhbnNmZXJlZCBvciBleGl0CisgKgltYXhpbXVtIG51bWJlciBvZiBieXRlcywgMCBpZiBhbGwgYnl0ZXMgb3IgdHJhbnNmZXJyZWQgb3IgZXhpdAogICoJaXMgaW4gc2FtZSBwaGFzZS4KICAqCiAgKglBbHNvLCAqcGhhc2UsICpjb3VudCwgKmRhdGEgYXJlIG1vZGlmaWVkIGluIHBsYWNlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2F0cDg3MHUuYyBiL2RyaXZlcnMvc2NzaS9hdHA4NzB1LmMKaW5kZXggNzYwMjlkNS4uN2U2ZWNhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2F0cDg3MHUuYworKysgYi9kcml2ZXJzL3Njc2kvYXRwODcwdS5jCkBAIC0xMjI4LDcgKzEyMjgsNyBAQAogCXByaW50aygiIFxuJXggJXggJXggJXNcbiAiLGFzc2lnbmlkX21hcCxtYnVmWzBdLG1idWZbMV0sJm1idWZbMl0pOyAqLwogCWkgPSAxNTsKIAlqID0gbWJ1ZlswXTsKLQlpZiAoKGogJiAweDIwKSAhPSAwKSB7CS8qIGJpdDU9MTpJRCB1cHRvIDcgICAgICAqLworCWlmICgoaiAmIDB4MjApICE9IDApIHsJLyogYml0NT0xOklEIHVwIHRvIDcgICAgICAqLwogCQlpID0gNzsKIAl9CiAJaWYgKChqICYgMHgwNikgPT0gMCkgewkvKiBJRHZhbGlkPyAgICAgICAgICAgICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX2NtZHMuaCBiL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9jbWRzLmgKaW5kZXggNTIxOGRlNC4uZmJkMWRjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX2NtZHMuaAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfY21kcy5oCkBAIC04NzcsNyArODc3LDcgQEAKIAkJCQkJCSAqLwogI2RlZmluZSBDWE5fS0lMTEVEX1BEVV9TSVpFX0VYQ0VFRFNfRFNMIDMJLyogQ29ubmVjdGlvbiBnb3QgaW52YWxpZGF0ZWQKIAkJCQkJCSAqIGludGVybmFsbHkKLQkJCQkJCSAqIGR1ZSB0byBhIHJlY2lldmVkIFBEVQorCQkJCQkJICogZHVlIHRvIGEgcmVjZWl2ZWQgUERVCiAJCQkJCQkgKiBzaXplID4gRFNMCiAJCQkJCQkgKi8KICNkZWZpbmUgQ1hOX0tJTExFRF9CVVJTVF9MRU5fTUlTTUFUQ0ggICA0CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCkBAIC04ODYsNyArODg2LDcgQEAKIAkJCQkJCSAqIEZCTC9NQkwuCiAJCQkJCQkgKi8KICNkZWZpbmUgQ1hOX0tJTExFRF9BSFNfUkNWRAkJNQkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAotCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYSByZWNpZXZlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYSByZWNlaXZlZAogCQkJCQkJICogUERVIEhkciB0aGF0IGhhcwogCQkJCQkJICogQUhTICovCiAjZGVmaW5lIENYTl9LSUxMRURfSERSX0RJR0VTVF9FUlIJNgkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZApAQCAtODk5LDEyICs4OTksMTIgQEAKIAkJCQkJCSAqIHBkdSBoZHIKIAkJCQkJCSAqLwogI2RlZmluZSBDWE5fS0lMTEVEX1NUQUxFX0lUVF9UVFRfUkNWRAk4CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCi0JCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBhIHJlY2lldmVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBhIHJlY2VpdmVkCiAJCQkJCQkgKiBJVFQvVFRUIHRoYXQgZG9lcyBub3QgYmVsb25nCiAJCQkJCQkgKiB0byB0aGlzIENvbm5lY3Rpb24KIAkJCQkJCSAqLwogI2RlZmluZSBDWE5fS0lMTEVEX0lOVkFMSURfSVRUX1RUVF9SQ1ZEIDkJLyogQ29ubmVjdGlvbiBnb3QgaW52YWxpZGF0ZWQKLQkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIHJlY2lldmVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byByZWNlaXZlZAogCQkJCQkJICogSVRUL1RUVCB2YWx1ZSA+IE1heAogCQkJCQkJICogU3VwcG9ydGVkIElUVHMvVFRUcwogCQkJCQkJICovCkBAIC05MzYsMjEgKzkzNiwyMSBAQAogCQkJCQkJICogaW5kZXguCiAJCQkJCQkgKi8KICNkZWZpbmUgQ1hOX0tJTExFRF9PVkVSX1JVTl9SRVNJRFVBTAkxNgkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZAotCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gcmVjaXZlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gcmVjZWl2ZWQKIAkJCQkJCSAqIGNvbW1hbmQgaGFzIHJlc2lkdWFsCiAJCQkJCQkgKiBvdmVyIHJ1biBieXRlcy4KIAkJCQkJCSAqLwogI2RlZmluZSBDWE5fS0lMTEVEX1VOREVSX1JVTl9SRVNJRFVBTAkxNwkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZAotCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gcmVjaXZlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gcmVjZWl2ZWQKIAkJCQkJCSAqIGNvbW1hbmQgaGFzIHJlc2lkdWFsIHVuZGVyCiAJCQkJCQkgKiBydW4gYnl0ZXMuCiAJCQkJCQkgKi8KICNkZWZpbmUgQ01EX0tJTExFRF9JTlZBTElEX1NUQVRTTl9SQ1ZECTE4CS8qIENvbW1hbmQgZ290IGludmFsaWRhdGVkCi0JCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBhIHJlY2lldmVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBhIHJlY2VpdmVkCiAJCQkJCQkgKiBQRFUgaGFzIGFuIGludmFsaWQgU3RhdHVzU04KIAkJCQkJCSAqLwogI2RlZmluZSBDTURfS0lMTEVEX0lOVkFMSURfUjJUX1JDVkQJMTkJLyogQ29tbWFuZCBnb3QgaW52YWxpZGF0ZWQKLQkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIGEgcmVjaWV2ZWQKKwkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIGEgcmVjZWl2ZWQKIAkJCQkJCSAqIGFuIFIyVCB3aXRoIHNvbWUgaW52YWxpZAogCQkJCQkJICogZmllbGRzIGluIGl0CiAJCQkJCQkgKi8KQEAgLTk3Myw3ICs5NzMsNyBAQAogCQkJCQkJICovCiAjZGVmaW5lIENNRF9DWE5fS0lMTEVEX0lOVkFMSURfREFUQVNOX1JDVkQgMjQJLyogQ29tbWFuZCBnb3QgaW52YWxpZGF0ZWQKIAkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIGEKLQkJCQkJCSAqIHJlY2lldmVkIFBEVSBoYXMgYW4gaW52YWxpZAorCQkJCQkJICogcmVjZWl2ZWQgUERVIGhhcyBhbiBpbnZhbGlkCiAJCQkJCQkgKiBEYXRhU04KIAkJCQkJCSAqLwogI2RlZmluZSBDWE5fSU5WQUxJREFURV9OT1RJRlkJCTI1CS8qIENvbm5lY3Rpb24gaW52YWxpZGF0aW9uCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9jb3JlLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9jb3JlLmMKaW5kZXggMWNkNWM4Yi4uOTE4MzhjNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfY29yZS5jCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NvcmUuYwpAQCAtMzU1LDcgKzM1NSw3IEBACiAJCQkvKgogCQkJICogRVJSX1BTUyBiaXQgbmVlZHMgdG8gYmUgY2xlYXJlZCBhcyB3ZWxsIGluIGNhc2UKIAkJCSAqIGludGVycnVwcyBhcmUgc2hhcmVkIHNvIGRyaXZlcidzIGludGVycnVwdCBoYW5kbGVyIGlzCi0JCQkgKiBzdGlsbCBjYWxsZWQgZXZlbnRob3VnaCBpdCBpcyBhbHJlYWR5IG1hc2tlZCBvdXQuCisJCQkgKiBzdGlsbCBjYWxsZWQgZXZlbiB0aG91Z2ggaXQgaXMgYWxyZWFkeSBtYXNrZWQgb3V0LgogCQkJICovCiAJCQljdXJyX3ZhbHVlID0gcmVhZGwoCiAJCQkJCWJmYS0+aW9jLmlvY19yZWdzLnBzc19lcnJfc3RhdHVzX3JlZyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9kZWZzX3N2Yy5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZGVmc19zdmMuaAppbmRleCA2NDhjODQxLi4yMDdmNTk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9kZWZzX3N2Yy5oCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2RlZnNfc3ZjLmgKQEAgLTE0NSw3ICsxNDUsNyBAQAogCXUzMglpb2hfZGF0YV9vb3JfZXZlbnQ7CS8qICBEYXRhIG91dCBvZiByYW5nZSAqLwogCXUzMglpb2hfcm9fb29vX2V2ZW50OwkvKiAgUmVsYXRpdmUgb2Zmc2V0IG91dCBvZiByYW5nZSAqLwogCXUzMglpb2hfY3B1X293bmVkX2V2ZW50OwkvKiAgSU9IIGhpdCAtaW9zdCBvd25lZCBieSBmL3cgKi8KLQl1MzIJaW9oX3VuZXhwX2ZyYW1lX2V2ZW50OwkvKiAgdW5leHBlY3RlZCBmcmFtZSByZWNpZXZlZAorCXUzMglpb2hfdW5leHBfZnJhbWVfZXZlbnQ7CS8qICB1bmV4cGVjdGVkIGZyYW1lIHJlY2VpdmVkCiAJCQkJCQkgKiAgIGNvdW50ICovCiAJdTMyCWlvaF9lcnJfaW50OwkJLyogIElPSCBlcnJvciBpbnQgZHVyaW5nIGRhdGEtcGhhc2UKIAkJCQkJCSAqICAgZm9yIHNjc2kgd3JpdGUKQEAgLTU2Niw4ICs1NjYsOCBAQAogCXUzMglpbnB1dF9yZXFzOwkJLyogIERhdGEgaW4tYm91bmQgcmVxdWVzdHMJKi8KIAl1MzIJb3V0cHV0X3JlcXM7CQkvKiAgRGF0YSBvdXQtYm91bmQgcmVxdWVzdHMJKi8KIAl1MzIJaW9fY29tcHM7CQkvKiAgVG90YWwgSU8gQ29tcGxldGlvbnMJKi8KLQl1MzIJd3JfdGhyb3VnaHB1dDsJCS8qICBXcml0ZSBkYXRhIHRyYW5zZmVyZWQgaW4gYnl0ZXMgKi8KLQl1MzIJcmRfdGhyb3VnaHB1dDsJCS8qICBSZWFkIGRhdGEgdHJhbnNmZXJlZCBpbiBieXRlcyAgKi8KKwl1MzIJd3JfdGhyb3VnaHB1dDsJCS8qICBXcml0ZSBkYXRhIHRyYW5zZmVycmVkIGluIGJ5dGVzICovCisJdTMyCXJkX3Rocm91Z2hwdXQ7CQkvKiAgUmVhZCBkYXRhIHRyYW5zZmVycmVkIGluIGJ5dGVzICAqLwogCiAJdTMyCWlvY29tcF9vazsJCS8qICBTbG93cGF0aCBJTyBjb21wbGV0aW9ucwkqLwogCXUzMglpb2NvbXBfdW5kZXJydW47CS8qICBJTyB1bmRlcnJ1bgkJKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjLmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mYy5oCmluZGV4IDhlNzY0ZmEuLmJmMDA2N2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjLmgKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmMuaApAQCAtMzE1LDcgKzMxNSw3IEBACiAJCQlxdWVyeV9kYmM6MSwKIAkJCWhnX3N1cHA6MTsKICNlbmRpZgotCV9fYmUxNgkJcnhzejsJCS8qIHJlY2lldmUgZGF0YV9maWVsZCBzaXplICovCisJX19iZTE2CQlyeHN6OwkJLyogcmVjZWl2ZSBkYXRhX2ZpZWxkIHNpemUgKi8KIAlfX2JlMTYJCWNvbnNlcTsKIAlfX2JlMTYJCXJvX2JpdG1hcDsKIAlfX2JlMzIJCWVfZF90b3Y7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3MuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjcy5jCmluZGV4IGY2NzRmOTMuLjliNDNjYTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjcy5jCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjcy5jCkBAIC0xMDMzLDcgKzEwMzMsNyBAQAogCiAKIC8qCi0gKiBMb29rdXAgZm9yIGEgdnBvcnQgd2l0aGluZyBhIGZhYnJpYyBnaXZlbiBpdHMgcHd3bgorICogTG9va3VwIGZvciBhIHZwb3J0IHdpdGhpbiBhIGZhYnJpYyBnaXZlbiBpdHMgcHd3bgogICovCiBzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICoKIGJmYV9mY3NfZmFicmljX3Zwb3J0X2xvb2t1cChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLCB3d25fdCBwd3duKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzLmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3MuaAppbmRleCAwZmQ2MzE2Li42MWNkY2U0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3MuaAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3MuaApAQCAtNzA1LDcgKzcwNSw3IEBACiAJUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRSA9IDE1LCAvKiAgUnBvcnQncyBQSUQgaGFzIGNoYW5nZWQgICAgICovCiAJUlBTTV9FVkVOVF9BRERSRVNTX0RJU0MgPSAxNiwgICAvKiAgTmVlZCB0byBEaXNjb3ZlciBycG9ydCdzIFBJRCAqLwogCVJQU01fRVZFTlRfUFJMT19SQ1ZEICAgPSAxNywgICAgLyogIFBSTE8gZnJvbSByZW1vdGUgZGV2aWNlICAgICAqLwotCVJQU01fRVZFTlRfUExPR0lfUkVUUlkgPSAxOCwgICAgLyogIFJldHJ5IFBMT0dJIGNvbnRpbm91c2x5ICovCisJUlBTTV9FVkVOVF9QTE9HSV9SRVRSWSA9IDE4LCAgICAvKiAgUmV0cnkgUExPR0kgY29udGludW91c2x5ICovCiB9OwogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzX2xwb3J0LmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3NfbHBvcnQuYwppbmRleCA0M2ZhOTg2Yi4uMWQ2YmU4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzX2xwb3J0LmMKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzX2xwb3J0LmMKQEAgLTExNDksNyArMTE0OSw3IEBACiAJCX0gZWxzZSB7CiAJCQkvKgogCQkJICogRm9yIGEgYmFzZSBwb3J0LCB3ZSBzaG91bGQgZmlyc3QgcmVnaXN0ZXIgdGhlIEhCQQotCQkJICogYXRyaWJ1dGUuIFRoZSBIQkEgYXR0cmlidXRlIGFsc28gY29udGFpbnMgdGhlIGJhc2UKKwkJCSAqIGF0dHJpYnV0ZS4gVGhlIEhCQSBhdHRyaWJ1dGUgYWxzbyBjb250YWlucyB0aGUgYmFzZQogCQkJICogIHBvcnQgcmVnaXN0cmF0aW9uLgogCQkJICovCiAJCQliZmFfc21fc2V0X3N0YXRlKGZkbWksCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zdmMuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3N2Yy5jCmluZGV4IDFkMzQ5MjEuLjE2ZDlhNWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3N2Yy5jCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3N2Yy5jCkBAIC0xMDM1LDcgKzEwMzUsNyBAQAogICogQHBhcmFtW2luXQlycG9ydAlCRkEgcnBvcnQgcG9pbnRlci4gQ291bGQgYmUgbGVmdCBOVUxMIGZvciBXS0EgcnBvcnRzCiAgKiBAcGFyYW1baW5dCXZmX2lkCXZpcnR1YWwgRmFicmljIElECiAgKiBAcGFyYW1baW5dCWxwX3RhZwlscG9ydCB0YWcKLSAqIEBwYXJhbVtpbl0JY3RzCXVzZSBDb250aW5vdXMgc2VxdWVuY2UKKyAqIEBwYXJhbVtpbl0JY3RzCXVzZSBDb250aW51b3VzIHNlcXVlbmNlCiAgKiBAcGFyYW1baW5dCWNvcwlmYyBDbGFzcyBvZiBTZXJ2aWNlCiAgKiBAcGFyYW1baW5dCXJlcWxlbglyZXF1ZXN0IGxlbmd0aCwgZG9lcyBub3QgaW5jbHVkZSBGQ0hTIGxlbmd0aAogICogQHBhcmFtW2luXQlmY2hzCWZjIEhlYWRlciBQb2ludGVyLiBUaGUgaGVhZGVyIGNvbnRlbnQgd2lsbCBiZSBjb3BpZWQKQEAgLTUwMjIsNyArNTAyMiw3IEBACiB9CiAKIC8qCi0gKiBSZWdpc3RlciBoYW5kbGVyIGZvciBhbGwgdW5zb2xpY3RlZCByZWNpZXZlIGZyYW1lcy4KKyAqIFJlZ2lzdGVyIGhhbmRsZXIgZm9yIGFsbCB1bnNvbGljdGVkIHJlY2VpdmUgZnJhbWVzLgogICoKICAqIEBwYXJhbVtpbl0JYmZhCQlCRkEgaW5zdGFuY2UKICAqIEBwYXJhbVtpbl0JdWZyZWN2CXJlY2VpdmUgaGFuZGxlciBmdW5jdGlvbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfc3ZjLmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zdmMuaAppbmRleCAzMzFhZDk5Li41OTAyYTQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zdmMuaAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zdmMuaApAQCAtMTI3LDcgKzEyNyw3IEBACiAJCQkJCSAqIHJwb3J0IG5leHVzIGlzIGVzdGFibGlzaGVkCiAJCQkJCSAqLwogCXN0cnVjdCBmY2hzX3MJZmNoczsJLyogIHJlcXVlc3QgRkMgaGVhZGVyIHN0cnVjdHVyZSAqLwotCXU4CQljdHM7CS8qICBjb250aW5vdXMgc2VxdWVuY2UgKi8KKwl1OAkJY3RzOwkvKiAgY29udGludW91cyBzZXF1ZW5jZSAqLwogCXU4CQljbGFzczsJLyogIEZDIGNsYXNzIGZvciB0aGUgcmVxdWVzdC9yZXNwb25zZSAqLwogCXUxNgltYXhfZnJtc3o7CS8qICBtYXggc2VuZCBmcmFtZSBzaXplICovCiAJdTE2CXZmX2lkOwkvKiAgdnNhbiB0YWcgaWYgYXBwbGljYWJsZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWQuYwppbmRleCA0NDUyNGNmLi4wZmQ1MTBhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYmZhL2JmYWQuYworKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWQuYwpAQCAtMTI3OCw3ICsxMjc4LDcgQEAKIAkJCSAqIGludGVycnVwdHMgaW50byBvbmUgdmVjdG9yLCBzbyBldmVuIGlmIHdlCiAJCQkgKiBjYW4gdHJ5IHRvIHJlcXVlc3QgbGVzcyB2ZWN0b3JzLCB3ZSBkb24ndAogCQkJICoga25vdyBob3cgdG8gYXNzb2NpYXRlIGludGVycnVwdCBldmVudHMgdG8KLQkJCSAqICB2ZWN0b3JzLiBMaW51eCBkb2Vzbid0IGR1cGljYXRlIHZlY3RvcnMKKwkJCSAqICB2ZWN0b3JzLiBMaW51eCBkb2Vzbid0IGR1cGxpY2F0ZSB2ZWN0b3JzCiAJCQkgKiBpbiB0aGUgTVNJWCB0YWJsZSBmb3IgdGhpcyBjYXNlLgogCQkJICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9ibngyZmMvNTd4eF9oc2lfYm54MmZjLmggYi9kcml2ZXJzL3Njc2kvYm54MmZjLzU3eHhfaHNpX2JueDJmYy5oCmluZGV4IDY5ZDAzMWQuLjk3YTYxYjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9ibngyZmMvNTd4eF9oc2lfYm54MmZjLmgKKysrIGIvZHJpdmVycy9zY3NpL2JueDJmYy81N3h4X2hzaV9ibngyZmMuaApAQCAtODk4LDcgKzg5OCw3IEBACiAKIAogLyoKLSAqIEZDb0UgY29uZWN0aW9uIGRhdGEgYmFzZQorICogRkNvRSBjb25uZWN0aW9uIGRhdGEgYmFzZQogICovCiBzdHJ1Y3QgZmNvZV9jb25uX2RiIHsKICNpZiBkZWZpbmVkKF9fQklHX0VORElBTikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9ibngyZmMvYm54MmZjX2Vscy5jIGIvZHJpdmVycy9zY3NpL2JueDJmYy9ibngyZmNfZWxzLmMKaW5kZXggN2ExMWEyNS4uNTJjMzU4NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2JueDJmYy9ibngyZmNfZWxzLmMKKysrIGIvZHJpdmVycy9zY3NpL2JueDJmYy9ibngyZmNfZWxzLmMKQEAgLTM5Nyw3ICszOTcsNyBAQAogCQkJICAgICAmZWxzX3JlcS0+cmVxX2ZsYWdzKSkgewogCQlCTlgyRkNfRUxTX0RCRygiVGltZXIgY29udGV4dCBmaW5pc2hlZCBwcm9jZXNzaW5nIHRoaXMgIgogCQkJICAgImVscyAtIDB4JXhcbiIsIGVsc19yZXEtPnhpZCk7Ci0JCS8qIFRoaXMgSU8gZG9lc250IHJlY2VpdmUgY2xlYW51cCBjb21wbGV0aW9uICovCisJCS8qIFRoaXMgSU8gZG9lc24ndCByZWNlaXZlIGNsZWFudXAgY29tcGxldGlvbiAqLwogCQlrcmVmX3B1dCgmZWxzX3JlcS0+cmVmY291bnQsIGJueDJmY19jbWRfcmVsZWFzZSk7CiAJCXJldHVybjsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYm54MmZjL2JueDJmY19pby5jIGIvZHJpdmVycy9zY3NpL2JueDJmYy9ibngyZmNfaW8uYwppbmRleCBkM2ZjMzAyLi4xZGVjZWZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYm54MmZjL2JueDJmY19pby5jCisrKyBiL2RyaXZlcnMvc2NzaS9ibngyZmMvYm54MmZjX2lvLmMKQEAgLTEyNzMsNyArMTI3Myw3IEBACiAJCQkJCQkgYm54MmZjX2NtZF9yZWxlYXNlKTsKIAkJCQkJCQkvKiB0aW1lciBob2xkICovCiAJCQkJcmMgPSBibngyZmNfaW5pdGlhdGVfYWJ0cyhjbWQpOwotCQkJCS8qIGFidHMgc2hvdWxkbnQgZmFpbCBpbiB0aGlzIGNvbnRleHQgKi8KKwkJCQkvKiBhYnRzIHNob3VsZG4ndCBmYWlsIGluIHRoaXMgY29udGV4dCAqLwogCQkJCVdBUk5fT04ocmMgIT0gU1VDQ0VTUyk7CiAJCQl9IGVsc2UKIAkJCQlwcmludGsoS0VSTl9FUlIgUEZYICJsdW5fcnN0OiBhYnRzIGFscmVhZHkgaW4iCkBAIC0xMzA4LDcgKzEzMDgsNyBAQAogCQkJCWtyZWZfcHV0KCZpb19yZXEtPnJlZmNvdW50LAogCQkJCQkgYm54MmZjX2NtZF9yZWxlYXNlKTsgLyogdGltZXIgaG9sZCAqLwogCQkJcmMgPSBibngyZmNfaW5pdGlhdGVfYWJ0cyhjbWQpOwotCQkJLyogYWJ0cyBzaG91bGRudCBmYWlsIGluIHRoaXMgY29udGV4dCAqLworCQkJLyogYWJ0cyBzaG91bGRuJ3QgZmFpbCBpbiB0aGlzIGNvbnRleHQgKi8KIAkJCVdBUk5fT04ocmMgIT0gU1VDQ0VTUyk7CiAKIAkJfSBlbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYm54MmZjL2JueDJmY190Z3QuYyBiL2RyaXZlcnMvc2NzaS9ibngyZmMvYm54MmZjX3RndC5jCmluZGV4IDdjYzA1ZTQuLmEyZTM4MzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9ibngyZmMvYm54MmZjX3RndC5jCisrKyBiL2RyaXZlcnMvc2NzaS9ibngyZmMvYm54MmZjX3RndC5jCkBAIC0zOTUsNyArMzk1LDcgQEAKIAkJcnAgPSBycG9ydC0+ZGRfZGF0YTsKIAkJaWYgKHJwb3J0LT5wb3J0X2lkID09IEZDX0ZJRF9ESVJfU0VSVikgewogCQkJLyoKLQkJCSAqIGJueDJmY19ycG9ydCBzdHJ1Y3R1cmUgZG9lc250IGV4aXN0IGZvcgorCQkJICogYm54MmZjX3Jwb3J0IHN0cnVjdHVyZSBkb2Vzbid0IGV4aXN0IGZvcgogCQkJICogZGlyZWN0b3J5IHNlcnZlci4KIAkJCSAqIFdlIHNob3VsZCBub3QgY29tZSBoZXJlLCBhcyBscG9ydCB3aWxsCiAJCQkgKiB0YWtlIGNhcmUgb2YgZmFicmljIGxvZ2luCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmlfaHdpLmMgYi9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmlfaHdpLmMKaW5kZXggMWRhMzRjMC4uZjBiODk1MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2JueDJpL2JueDJpX2h3aS5jCisrKyBiL2RyaXZlcnMvc2NzaS9ibngyaS9ibngyaV9od2kuYwpAQCAtMTczLDcgKzE3Myw3IEBACiAKIC8qKgogICogYm54MmlfZ2V0X3JxX2J1ZiAtIGNvcHkgUlEgYnVmZmVyIGNvbnRlbnRzIHRvIGRyaXZlciBidWZmZXIKLSAqIEBjb25uOgkJaXNjc2kgY29ubmVjdGlvbiBvbiB3aGljaCBSUSBldmVudCBvY2N1cmVkCisgKiBAY29ubjoJCWlzY3NpIGNvbm5lY3Rpb24gb24gd2hpY2ggUlEgZXZlbnQgb2NjdXJyZWQKICAqIEBwdHI6CQlkcml2ZXIgYnVmZmVyIHRvIHdoaWNoIFJRIGJ1ZmZlciBjb250ZW50cyBpcyB0bwogICoJCQliZSBjb3BpZWQKICAqIEBsZW46CQlsZW5ndGggb2YgdmFsaWQgZGF0YSBpbnNpZGUgUlEgYnVmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvY3hnYmkvbGliY3hnYmkuaCBiL2RyaXZlcnMvc2NzaS9jeGdiaS9saWJjeGdiaS5oCmluZGV4IDBhMjBmZDUuLjkyNjc4NDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9jeGdiaS9saWJjeGdiaS5oCisrKyBiL2RyaXZlcnMvc2NzaS9jeGdiaS9saWJjeGdiaS5oCkBAIC0yNjIsOSArMjYyLDkgQEAKIGVudW0gY3hnYmlfc2tjYl9mbGFncyB7CiAJU0tDQkZfVFhfTkVFRF9IRFIsCS8qIHBhY2tldCBuZWVkcyBhIGhlYWRlciAqLwogCVNLQ0JGX1JYX0NPQUxFU0NFRCwJLyogcmVjZWl2ZWQgd2hvbGUgcGR1ICovCi0JU0tDQkZfUlhfSERSLAkJLyogcmVjaWV2ZWQgcGR1IGhlYWRlciAqLwotCVNLQ0JGX1JYX0RBVEEsCQkvKiByZWNpZXZlZCBwZHUgcGF5bG9hZCAqLwotCVNLQ0JGX1JYX1NUQVRVUywJLyogcmVjaWV2ZWQgZGRwIHN0YXR1cyAqLworCVNLQ0JGX1JYX0hEUiwJCS8qIHJlY2VpdmVkIHBkdSBoZWFkZXIgKi8KKwlTS0NCRl9SWF9EQVRBLAkJLyogcmVjZWl2ZWQgcGR1IHBheWxvYWQgKi8KKwlTS0NCRl9SWF9TVEFUVVMsCS8qIHJlY2VpdmVkIGRkcCBzdGF0dXMgKi8KIAlTS0NCRl9SWF9EQVRBX0REUEQsCS8qIHBkdSBwYXlsb2FkIGRkcCdkICovCiAJU0tDQkZfUlhfSENSQ19FUlIsCS8qIGhlYWRlciBkaWdlc3QgZXJyb3IgKi8KIAlTS0NCRl9SWF9EQ1JDX0VSUiwJLyogZGF0YSBkaWdlc3QgZXJyb3IgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9kYzM5NXguYyBiL2RyaXZlcnMvc2NzaS9kYzM5NXguYwppbmRleCBiMGY4NTIzLi5iMTBiMzg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZGMzOTV4LmMKKysrIGIvZHJpdmVycy9zY3NpL2RjMzk1eC5jCkBAIC0yMzUsNyArMjM1LDcgQEAKIAogCXU4IHNnX2NvdW50OwkJCS8qIE5vIG9mIEhXIHNnIGVudHJpZXMgZm9yIHRoaXMgcmVxdWVzdCAqLwogCXU4IHNnX2luZGV4OwkJCS8qIEluZGV4IG9mIEhXIHNnIGVudHJ5IGZvciB0aGlzIHJlcXVlc3QgKi8KLQlzaXplX3QgdG90YWxfeGZlcl9sZW5ndGg7CS8qIFRvdGFsIG51bWJlciBvZiBieXRlcyByZW1haW5pbmcgdG8gYmUgdHJhbnNmZXJlZCAqLworCXNpemVfdCB0b3RhbF94ZmVyX2xlbmd0aDsJLyogVG90YWwgbnVtYmVyIG9mIGJ5dGVzIHJlbWFpbmluZyB0byBiZSB0cmFuc2ZlcnJlZCAqLwogCXNpemVfdCByZXF1ZXN0X2xlbmd0aDsJCS8qIFRvdGFsIG51bWJlciBvZiBieXRlcyBpbiB0aGlzIHJlcXVlc3QgKi8KIAkvKgogCSAqIFRoZSBzZW5zZSBidWZmZXIgaGFuZGxpbmcgZnVuY3Rpb24sIHJlcXVlc3Rfc2Vuc2UsIHVzZXMKQEAgLTE3NzQsNyArMTc3NCw3IEBACiAJCWRjMzk1eF9zdGF0ZXYoYWNiLCBzcmIsICZzY3NpX3N0YXR1cyk7CiAKIAkJLyogCi0JCSAqIGlmIHRoZXJlIHdlcmUgYW55IGV4Y2VwdGlvbiBvY2N1cmVkIHNjc2lfc3RhdHVzCisJCSAqIGlmIHRoZXJlIHdlcmUgYW55IGV4Y2VwdGlvbiBvY2N1cnJlZCBzY3NpX3N0YXR1cwogCQkgKiB3aWxsIGJlIG1vZGlmeSB0byBidXMgZnJlZSBwaGFzZSBuZXcgc2NzaV9zdGF0dXMKIAkJICogdHJhbnNmZXIgb3V0IGZyb20gLi4uIHByZXZpb3VzIGRjMzk1eF9zdGF0ZXYKIAkJICovCkBAIC0xOTU0LDExICsxOTU0LDExIEBACiBzdGF0aWMgdm9pZCBzZ191cGRhdGVfbGlzdChzdHJ1Y3QgU2NzaVJlcUJsayAqc3JiLCB1MzIgbGVmdCkKIHsKIAl1OCBpZHg7Ci0JdTMyIHhmZXJyZWQgPSBzcmItPnRvdGFsX3hmZXJfbGVuZ3RoIC0gbGVmdDsgLyogYnl0ZXMgdHJhbnNmZXJlZCAqLworCXUzMiB4ZmVycmVkID0gc3JiLT50b3RhbF94ZmVyX2xlbmd0aCAtIGxlZnQ7IC8qIGJ5dGVzIHRyYW5zZmVycmVkICovCiAJc3RydWN0IFNHZW50cnkgKnBzZ2UgPSBzcmItPnNlZ21lbnRfeCArIHNyYi0+c2dfaW5kZXg7CiAKIAlkcHJpbnRrZGJnKERCR18wLAotCQkic2dfdXBkYXRlX2xpc3Q6IFRyYW5zZmVyZWQgJWkgb2YgJWkgYnl0ZXMsICVpIHJlbWFpblxuIiwKKwkJInNnX3VwZGF0ZV9saXN0OiBUcmFuc2ZlcnJlZCAlaSBvZiAlaSBieXRlcywgJWkgcmVtYWluXG4iLAogCQl4ZmVycmVkLCBzcmItPnRvdGFsX3hmZXJfbGVuZ3RoLCBsZWZ0KTsKIAlpZiAoeGZlcnJlZCA9PSAwKSB7CiAJCS8qIG5vdGhpbmcgdG8gdXBkYXRlIHNpbmNlIHdlIGRpZCBub3QgdHJhbnNmZXIgYW55IGRhdGEgKi8KQEAgLTE5OTAsNyArMTk5MCw3IEBACiAKIAogLyoKLSAqIFdlIGhhdmUgdHJhbnNmZXJlZCBhIHNpbmdsZSBieXRlIChQSU8gbW9kZT8pIGFuZCBuZWVkIHRvIHVwZGF0ZQorICogV2UgaGF2ZSB0cmFuc2ZlcnJlZCBhIHNpbmdsZSBieXRlIChQSU8gbW9kZT8pIGFuZCBuZWVkIHRvIHVwZGF0ZQogICogdGhlIGNvdW50IG9mIGJ5dGVzIHJlbWFpbmluZyAodG90YWxfeGZlcl9sZW5ndGgpIGFuZCB1cGRhdGUgdGhlIHNnCiAgKiBlbnRyeSB0byBlaXRoZXIgcG9pbnQgdG8gbmV4dCBieXRlIGluIHRoZSBjdXJyZW50IHNnIGVudHJ5LCBvciBvZgogICogYWxyZWFkeSBhdCB0aGUgZW5kIHRvIHBvaW50IHRvIHRoZSBzdGFydCBvZiB0aGUgbmV4dCBzZyBlbnRyeQpAQCAtMjAyOSw3ICsyMDI5LDcgQEAKIAogCiAvKgotICogVGhvc2Ugbm8gb2YgYnl0ZXMgd2lsbCBiZSB0cmFuc2ZlcmVkIHcvIFBJTyB0aHJvdWdoIHRoZSBTQ1NJIEZJRk8KKyAqIFRob3NlIG5vIG9mIGJ5dGVzIHdpbGwgYmUgdHJhbnNmZXJyZWQgdy8gUElPIHRocm91Z2ggdGhlIFNDU0kgRklGTwogICogU2VlbXMgdG8gYmUgbmVlZGVkIGZvciB1bmtub3duIHJlYXNvbnM7IGNvdWxkIGJlIGEgaGFyZHdhcmUgYnVnIDotKAogICovCiAjZGVmaW5lIERDMzk1eF9MQVNUUElPIDQKQEAgLTIyNTYsNyArMjI1Niw3IEBACiAJCQlEQzM5NXhfcmVhZDMyKGFjYiwgVFJNX1MxMDQwX0RNQV9DWENOVCksCiAJCQlzcmItPnRvdGFsX3hmZXJfbGVuZ3RoLCBkX2xlZnRfY291bnRlcik7CiAjaWYgREMzOTV4X0xBU1RQSU8KLQkJLyogS0c6IExlc3MgdGhhbiBvciBlcXVhbCB0byA0IGJ5dGVzIGNhbiBub3QgYmUgdHJhbnNmZXJlZCB2aWEgRE1BLCBpdCBzZWVtcy4gKi8KKwkJLyogS0c6IExlc3MgdGhhbiBvciBlcXVhbCB0byA0IGJ5dGVzIGNhbiBub3QgYmUgdHJhbnNmZXJyZWQgdmlhIERNQSwgaXQgc2VlbXMuICovCiAJCWlmIChkX2xlZnRfY291bnRlcgogCQkgICAgJiYgc3JiLT50b3RhbF94ZmVyX2xlbmd0aCA8PSBEQzM5NXhfTEFTVFBJTykgewogCQkJc2l6ZV90IGxlZnRfaW8gPSBzcmItPnRvdGFsX3hmZXJfbGVuZ3RoOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2RjMzk1eC5oIGIvZHJpdmVycy9zY3NpL2RjMzk1eC5oCmluZGV4IGIzODM2MGUuLmZiZjM1ZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9kYzM5NXguaAorKysgYi9kcml2ZXJzL3Njc2kvZGMzOTV4LmgKQEAgLTYxNyw3ICs2MTcsNyBAQAogI2RlZmluZSBOVENfRE9fU0VORF9TVEFSVAkJMHgwOAkvKiBTZW5kIHN0YXJ0IGNvbW1hbmQgU1BJTlVQCQkqLwogI2RlZmluZSBOVENfRE9fRElTQ09OTkVDVAkJMHgwNAkvKiBFbmFibGUgU0NTSSBkaXNjb25uZWN0CQkqLwogI2RlZmluZSBOVENfRE9fU1lOQ19ORUdPCQkweDAyCS8qIFN5bmMgbmVnb3RpYXRpb24JCQkqLwotI2RlZmluZSBOVENfRE9fUEFSSVRZX0NISwkJMHgwMQkvKiAoaXQgc291bGQgZGVmaW5lIGF0IE5BQykJCSovCisjZGVmaW5lIE5UQ19ET19QQVJJVFlfQ0hLCQkweDAxCS8qIChpdCBzaG91bGQgZGVmaW5lIGF0IE5BQykJCSovCiAJCQkJCQkvKiBQYXJpdHkgY2hlY2sgZW5hYmxlCQkJKi8KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9kZXZpY2VfaGFuZGxlci9zY3NpX2RoX2FsdWEuYyBiL2RyaXZlcnMvc2NzaS9kZXZpY2VfaGFuZGxlci9zY3NpX2RoX2FsdWEuYwppbmRleCA3Y2FlMGJjLi40MmZlNTI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZGV2aWNlX2hhbmRsZXIvc2NzaV9kaF9hbHVhLmMKKysrIGIvZHJpdmVycy9zY3NpL2RldmljZV9oYW5kbGVyL3Njc2lfZGhfYWx1YS5jCkBAIC01NDEsNyArNTQxLDcgQEAKICAqCiAgKiBFdmFsdWF0ZSB0aGUgVGFyZ2V0IFBvcnQgR3JvdXAgU3RhdGUuCiAgKiBSZXR1cm5zIFNDU0lfREhfREVWX09GRkxJTkVEIGlmIHRoZSBwYXRoIGlzCi0gKiBmb3VuZCB0byBiZSB1bnVzZWFibGUuCisgKiBmb3VuZCB0byBiZSB1bnVzYWJsZS4KICAqLwogc3RhdGljIGludCBhbHVhX3J0cGcoc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2LCBzdHJ1Y3QgYWx1YV9kaF9kYXRhICpoKQogewpAQCAtNjIwLDcgKzYyMCw3IEBACiAJCWJyZWFrOwogCWNhc2UgVFBHU19TVEFURV9PRkZMSU5FOgogCWNhc2UgVFBHU19TVEFURV9VTkFWQUlMQUJMRToKLQkJLyogUGF0aCB1bnVzZWFibGUgZm9yIHVuYXZhaWxhYmxlL29mZmxpbmUgKi8KKwkJLyogUGF0aCB1bnVzYWJsZSBmb3IgdW5hdmFpbGFibGUvb2ZmbGluZSAqLwogCQllcnIgPSBTQ1NJX0RIX0RFVl9PRkZMSU5FRDsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9kcHQvc3lzX2luZm8uaCBiL2RyaXZlcnMvc2NzaS9kcHQvc3lzX2luZm8uaAppbmRleCBhOTBjNGNiLi5hNGFhMWMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZHB0L3N5c19pbmZvLmgKKysrIGIvZHJpdmVycy9zY3NpL2RwdC9zeXNfaW5mby5oCkBAIC03OSw5ICs3OSw5IEBACiAgICB0eXBlZGVmIHN0cnVjdCAgewogI2VuZGlmCiAKLSAgIHVTSE9SVCAgICAgICBjeWxpbmRlcnM7ICAgICAgLyogVXB0byAxMDI0ICovCi0gICB1Q0hBUiAgICAgICAgaGVhZHM7ICAgICAgICAgIC8qIFVwdG8gMjU1ICovCi0gICB1Q0hBUiAgICAgICAgc2VjdG9yczsgICAgICAgIC8qIFVwdG8gNjMgKi8KKyAgIHVTSE9SVCAgICAgICBjeWxpbmRlcnM7ICAgICAgLyogVXAgdG8gMTAyNCAqLworICAgdUNIQVIgICAgICAgIGhlYWRzOyAgICAgICAgICAvKiBVcCB0byAyNTUgKi8KKyAgIHVDSEFSICAgICAgICBzZWN0b3JzOyAgICAgICAgLyogVXAgdG8gNjMgKi8KIAogI2lmZGVmICBfX2NwbHVzcGx1cwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvZWF0YS5jIGIvZHJpdmVycy9zY3NpL2VhdGEuYwppbmRleCA1MzkyNWFjLi4wZWI0ZmU2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZWF0YS5jCisrKyBiL2RyaXZlcnMvc2NzaS9lYXRhLmMKQEAgLTYzLDcgKzYzLDcgQEAKICAqICAgICAgICAgIGVwOlt5fG5dICAgICAgZWlzYV9wcm9iZT1bMXwwXSAgQ09ORklHX0VJU0EgZGVmaW5lZAogICogICAgICAgICAgcHA6W3l8bl0gICAgICBwY2lfcHJvYmU9WzF8MF0gICBDT05GSUdfUENJICBkZWZpbmVkCiAgKgotICogICAgICAgICAgVGhlIGRlZmF1bHQgYWN0aW9uIGlzIHRvIHBlcmZvcm0gcHJvYmluZyBpZiB0aGUgY29ycmlzcG9uZGluZworICogICAgICAgICAgVGhlIGRlZmF1bHQgYWN0aW9uIGlzIHRvIHBlcmZvcm0gcHJvYmluZyBpZiB0aGUgY29ycmVzcG9uZGluZwogICogICAgICAgICAgYnVzIGlzIGNvbmZpZ3VyZWQgYW5kIHRvIHNraXAgcHJvYmluZyBvdGhlcndpc2UuCiAgKgogICogICAgICAgICsgSWYgcGNpX3Byb2JlIGlzIGluIGVmZmVjdCBhbmQgYSBsaXN0IG9mIEkvTyAgcG9ydHMgaXMgc3BlY2lmaWVkCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvZmNvZS9mY29lX2N0bHIuYyBiL2RyaXZlcnMvc2NzaS9mY29lL2Zjb2VfY3Rsci5jCmluZGV4IGM5M2YwMDcuLjlkMzhiZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9mY29lL2Zjb2VfY3Rsci5jCisrKyBiL2RyaXZlcnMvc2NzaS9mY29lL2Zjb2VfY3Rsci5jCkBAIC02NTYsNyArNjU2LDcgQEAKIAkJICogSWYgbm9uLUZJUCwgd2UgbWF5IGhhdmUgZ290dGVuIGFuIFNJRCBieSBhY2NlcHRpbmcgYW4gRkxPR0kKIAkJICogZnJvbSBhIHBvaW50LXRvLXBvaW50IGNvbm5lY3Rpb24uICBTd2l0Y2ggdG8gdXNpbmcKIAkJICogdGhlIHNvdXJjZSBtYWMgYmFzZWQgb24gdGhlIFNJRC4gIFRoZSBkZXN0aW5hdGlvbgotCQkgKiBNQUMgaW4gdGhpcyBjYXNlIHdvdWxkIGhhdmUgYmVlbiBzZXQgYnkgcmVjZXZpbmcgdGhlCisJCSAqIE1BQyBpbiB0aGlzIGNhc2Ugd291bGQgaGF2ZSBiZWVuIHNldCBieSByZWNlaXZpbmcgdGhlCiAJCSAqIEZMT0dJLgogCQkgKi8KIAkJaWYgKGZpcC0+c3RhdGUgPT0gRklQX1NUX05PTl9GSVApIHsKQEAgLTE4NzYsNyArMTg3Niw3IEBACiAgKiBmY29lX2N0bHJfdm5fcnBvcnRfY2FsbGJhY2sgLSBFdmVudCBoYW5kbGVyIGZvciBycG9ydCBldmVudHMuCiAgKiBAbHBvcnQ6IFRoZSBscG9ydCB3aGljaCBpcyByZWNlaXZpbmcgdGhlIGV2ZW50CiAgKiBAcmRhdGE6IHJlbW90ZSBwb3J0IHByaXZhdGUgZGF0YQotICogQGV2ZW50OiBUaGUgZXZlbnQgdGhhdCBvY2N1cmVkCisgKiBAZXZlbnQ6IFRoZSBldmVudCB0aGF0IG9jY3VycmVkCiAgKgogICogTG9ja2luZyBOb3RlOiAgVGhlIHJwb3J0IGxvY2sgbXVzdCBub3QgYmUgaGVsZCB3aGVuIGNhbGxpbmcgdGhpcyBmdW5jdGlvbi4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2Zkb21haW4uYyBiL2RyaXZlcnMvc2NzaS9mZG9tYWluLmMKaW5kZXggNjliN2FhNS4uNjQzZjZkNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2Zkb21haW4uYworKysgYi9kcml2ZXJzL3Njc2kvZmRvbWFpbi5jCkBAIC0xNzQsNyArMTc0LDcgQEAKICBGdXR1cmUgRG9tYWluIHNvbGQgRE9TIEJJT1Mgc291cmNlIGZvciAkMjUwIGFuZCB0aGUgVU4qWCBkcml2ZXIgc291cmNlIHdhcwogICQ3NTAsIGJ1dCB0aGVzZSByZXF1aXJlZCBhIG5vbi1kaXNjbG9zdXJlIGFncmVlbWVudCwgc28gZXZlbiBpZiBJIGNvdWxkCiAgaGF2ZSBhZmZvcmRlZCB0aGVtLCB0aGV5IHdvdWxkICpub3QqIGhhdmUgYmVlbiB1c2VmdWwgZm9yIHdyaXRpbmcgdGhpcwotIHB1YmxpY2FsbHkgZGlzdHJpYnV0YWJsZSBkcml2ZXIuICBGdXR1cmUgRG9tYWluIHRlY2huaWNhbCBzdXBwb3J0IGhhcworIHB1YmxpY2x5IGRpc3RyaWJ1dGFibGUgZHJpdmVyLiAgRnV0dXJlIERvbWFpbiB0ZWNobmljYWwgc3VwcG9ydCBoYXMKICBwcm92aWRlZCBzb21lIGluZm9ybWF0aW9uIG9uIHRoZSBwaG9uZSBhbmQgaGF2ZSBzZW50IGEgZmV3IHVzZWZ1bCBGQVhzLgogIFRoZXkgaGF2ZSBiZWVuIG11Y2ggbW9yZSBoZWxwZnVsIHNpbmNlIHRoZXkgc3RhcnRlZCB0byByZWNvZ25pemUgdGhhdCB0aGUKICB3b3JkICJMaW51eCIgcmVmZXJzIHRvIGFuIG9wZXJhdGluZyBzeXN0ZW0gOi0pLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2ZuaWMvZm5pY19mY3MuYyBiL2RyaXZlcnMvc2NzaS9mbmljL2ZuaWNfZmNzLmMKaW5kZXggMmI0OGQ3OS4uM2M1M2MzNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2ZuaWMvZm5pY19mY3MuYworKysgYi9kcml2ZXJzL3Njc2kvZm5pYy9mbmljX2Zjcy5jCkBAIC00MTEsNyArNDExLDcgQEAKIAkJCWVyciA9IHZuaWNfcnFfZmlsbCgmZm5pYy0+cnFbaV0sIGZuaWNfYWxsb2NfcnFfZnJhbWUpOwogCQkJaWYgKGVycikKIAkJCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIGZuaWMtPmxwb3J0LT5ob3N0LAotCQkJCQkgICAgICJmbmljX2FsbG9jX3JxX2ZyYW1lIGNhbnQgYWxsb2MiCisJCQkJCSAgICAgImZuaWNfYWxsb2NfcnFfZnJhbWUgY2FuJ3QgYWxsb2MiCiAJCQkJCSAgICAgIiBmcmFtZVxuIik7CiAJCX0KIAkJdG90X3JxX3dvcmtfZG9uZSArPSBjdXJfd29ya19kb25lOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2ZuaWMvZm5pY19zY3NpLmMgYi9kcml2ZXJzL3Njc2kvZm5pYy9mbmljX3Njc2kuYwppbmRleCAyMmQwMjQwLi41MzhiMzFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZm5pYy9mbmljX3Njc2kuYworKysgYi9kcml2ZXJzL3Njc2kvZm5pYy9mbmljX3Njc2kuYwpAQCAtMTEyMyw3ICsxMTIzLDcgQEAKIAkJCQkJICAgIGZjX2x1bi5zY3NpX2x1biwgaW9fcmVxKSkgewogCQkJLyoKIAkJCSAqIFJldmVydCB0aGUgY21kIHN0YXRlIGJhY2sgdG8gb2xkIHN0YXRlLCBpZgotCQkJICogaXQgaGFzbnQgY2hhbmdlZCBpbiBiZXR3ZWVuLiBUaGlzIGNtZCB3aWxsIGdldAorCQkJICogaXQgaGFzbid0IGNoYW5nZWQgaW4gYmV0d2Vlbi4gVGhpcyBjbWQgd2lsbCBnZXQKIAkJCSAqIGFib3J0ZWQgbGF0ZXIgYnkgc2NzaV9laCwgb3IgY2xlYW5lZCB1cCBkdXJpbmcKIAkJCSAqIGx1biByZXNldAogCQkJICovCkBAIC0xMjA4LDcgKzEyMDgsNyBAQAogCQkJCQkgICAgZmNfbHVuLnNjc2lfbHVuLCBpb19yZXEpKSB7CiAJCQkvKgogCQkJICogUmV2ZXJ0IHRoZSBjbWQgc3RhdGUgYmFjayB0byBvbGQgc3RhdGUsIGlmCi0JCQkgKiBpdCBoYXNudCBjaGFuZ2VkIGluIGJldHdlZW4uIFRoaXMgY21kIHdpbGwgZ2V0CisJCQkgKiBpdCBoYXNuJ3QgY2hhbmdlZCBpbiBiZXR3ZWVuLiBUaGlzIGNtZCB3aWxsIGdldAogCQkJICogYWJvcnRlZCBsYXRlciBieSBzY3NpX2VoLCBvciBjbGVhbmVkIHVwIGR1cmluZwogCQkJICogbHVuIHJlc2V0CiAJCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9nX05DUjUzODAuYyBiL2RyaXZlcnMvc2NzaS9nX05DUjUzODAuYwppbmRleCA0MjdhNTZkLi44MTE4MmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZ19OQ1I1MzgwLmMKKysrIGIvZHJpdmVycy9zY3NpL2dfTkNSNTM4MC5jCkBAIC01NjYsNyArNTY2LDcgQEAKICAqCUBkc3Q6IGJ1ZmZlciB0byByZWFkIGludG8KICAqCUBsZW46IGJ1ZmZlciBsZW5ndGgKICAqCi0gKglQZXJmb3JtIGEgcHN1ZWRvIERNQSBtb2RlIHJlYWQgZnJvbSBhbiBOQ1I1M0M0MDAgb3IgZXF1aXZhbGVudAorICoJUGVyZm9ybSBhIHBzZXVkbyBETUEgbW9kZSByZWFkIGZyb20gYW4gTkNSNTNDNDAwIG9yIGVxdWl2YWxlbnQKICAqCWNvbnRyb2xsZXIKICAqLwogIApAQCAtNjUwLDcgKzY1MCw3IEBACiAgKglAZHN0OiBidWZmZXIgdG8gcmVhZCBpbnRvCiAgKglAbGVuOiBidWZmZXIgbGVuZ3RoCiAgKgotICoJUGVyZm9ybSBhIHBzdWVkbyBETUEgbW9kZSByZWFkIGZyb20gYW4gTkNSNTNDNDAwIG9yIGVxdWl2YWxlbnQKKyAqCVBlcmZvcm0gYSBwc2V1ZG8gRE1BIG1vZGUgcmVhZCBmcm9tIGFuIE5DUjUzQzQwMCBvciBlcXVpdmFsZW50CiAgKgljb250cm9sbGVyCiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2dkdGguaCBiL2RyaXZlcnMvc2NzaS9nZHRoLmgKaW5kZXggMTIwYTA2Mi4uZDk2OTg1NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2dkdGguaAorKysgYi9kcml2ZXJzL3Njc2kvZ2R0aC5oCkBAIC04OTUsNyArODk1LDcgQEAKICAgICAgICAgdTggICAgICAgICAgbGRyX25vOyAgICAgICAgICAgICAgICAgLyogbG9nLiBkcml2ZSBuby4gKi8KICAgICAgICAgdTggICAgICAgICAgcndfYXR0cmliczsgICAgICAgICAgICAgLyogci93IGF0dHJpYnV0ZXMgKi8KICAgICAgICAgdTggICAgICAgICAgY2x1c3Rlcl90eXBlOyAgICAgICAgICAgLyogY2x1c3RlciBwcm9wZXJ0aWVzICovCi0gICAgICAgIHU4ICAgICAgICAgIG1lZGlhX2NoYW5nZWQ7ICAgICAgICAgIC8qIEZsYWc6TU9VTlQvVU5NT1VOVCBvY2N1cmVkICovCisgICAgICAgIHU4ICAgICAgICAgIG1lZGlhX2NoYW5nZWQ7ICAgICAgICAgIC8qIEZsYWc6TU9VTlQvVU5NT1VOVCBvY2N1cnJlZCAqLwogICAgICAgICB1MzIgICAgICAgICBzdGFydF9zZWM7ICAgICAgICAgICAgICAvKiBzdGFydCBzZWN0b3IgKi8KICAgICB9IGhkcltNQVhfTERSSVZFU107ICAgICAgICAgICAgICAgICAgICAgICAgIC8qIGhvc3QgZHJpdmVzICovCiAgICAgc3RydWN0IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9ndnAxMS5jIGIvZHJpdmVycy9zY3NpL2d2cDExLmMKaW5kZXggMmNlMjZlYi4uNTBiYjU0MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2d2cDExLmMKKysrIGIvZHJpdmVycy9zY3NpL2d2cDExLmMKQEAgLTMwMCw3ICszMDAsNyBAQAogCS8qCiAJICogUnVtb3JzIHN0YXRlIHRoYXQgc29tZSBHVlAgcmFtIGJvYXJkcyB1c2UgdGhlIHNhbWUgcHJvZHVjdAogCSAqIGNvZGUgYXMgdGhlIFNDU0kgY29udHJvbGxlcnMuIFRoZXJlZm9yZSBpZiB0aGUgYm9hcmQtc2l6ZQotCSAqIGlzIG5vdCA2NEtCIHdlIGFzdW1lIGl0IGlzIGEgcmFtIGJvYXJkIGFuZCBiYWlsIG91dC4KKwkgKiBpcyBub3QgNjRLQiB3ZSBhc3N1bWUgaXQgaXMgYSByYW0gYm9hcmQgYW5kIGJhaWwgb3V0LgogCSAqLwogCWlmICh6b3Jyb19yZXNvdXJjZV9sZW4oeikgIT0gMHgxMDAwMCkKIAkJcmV0dXJuIC1FTk9ERVY7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvaW1tLmMgYi9kcml2ZXJzL3Njc2kvaW1tLmMKaW5kZXggOTlhYTBlNS4uMjZjZDlkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2ltbS5jCisrKyBiL2RyaXZlcnMvc2NzaS9pbW0uYwpAQCAtMyw3ICszLDcgQEAKICAqIAogICogKFRoZSBJTU0gaXMgdGhlIGVtYmVkZGVkIGNvbnRyb2xsZXIgaW4gdGhlIFpJUCBQbHVzIGRyaXZlLikKICAqIAotICogTXkgdW5vZmZpY2FsIGNvbXBhbnkgYWNyb255bSBsaXN0IGlzIDIxIHBhZ2VzIGxvbmc6CisgKiBNeSB1bm9mZmljaWFsIGNvbXBhbnkgYWNyb255bSBsaXN0IGlzIDIxIHBhZ2VzIGxvbmc6CiAgKiAgICAgIEZMQTogICAgRm91ciBsZXR0ZXIgYWNyb255bSB3aXRoIGJ1aWx0IGluIGZhY2lsaXR5IGZvcgogICogICAgICAgICAgICAgIGZ1dHVyZSBleHBhbnNpb24gdG8gZml2ZSBsZXR0ZXJzLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvaW5pdGlvLmMgYi9kcml2ZXJzL3Njc2kvaW5pdGlvLmMKaW5kZXggOTYyN2QwNi4uZGQ3NDFiYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2luaXRpby5jCisrKyBiL2RyaXZlcnMvc2NzaS9pbml0aW8uYwpAQCAtMjQyLDcgKzI0Miw3IEBACiAKIHN0YXRpYyB1OCBpbml0aW9fcmF0ZV90YmxbOF0gPQkvKiBmYXN0IDIwICAgICAgKi8KIHsKLQkJCQkvKiBuYW5vc2Vjb25kIGRldmlkZSBieSA0ICovCisJCQkJLyogbmFub3NlY29uZCBkaXZpZGUgYnkgNCAqLwogCTEyLAkJCS8qIDUwbnMsICAyME0gICAqLwogCTE4LAkJCS8qIDc1bnMsICAxMy4zTSAqLwogCTI1LAkJCS8qIDEwMG5zLCAxME0gICAqLwpAQCAtMTkxNyw3ICsxOTE3LDcgQEAKIH0KIAogLyoqCi0gKglpbnRfaW5pdGlvX3Njc2lfcmVzZWwJLQlSZXNlbGVjdGlvbiBvY2N1cmVkCisgKglpbnRfaW5pdGlvX3Njc2lfcmVzZWwJLQlSZXNlbGVjdGlvbiBvY2N1cnJlZAogICoJQGhvc3Q6IEluaXRJTyBob3N0IGFkYXB0ZXIKICAqCiAgKglBIFNDU0kgcmVzZWxlY3Rpb24gZXZlbnQgaGFzIGJlZW4gc2lnbmFsbGVkIGFuZCB0aGUgaW50ZXJydXB0CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvaW5pdGlvLmggYi9kcml2ZXJzL3Njc2kvaW5pdGlvLmgKaW5kZXggZTU4YWY5ZS4uMjE5YjkwMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2luaXRpby5oCisrKyBiL2RyaXZlcnMvc2NzaS9pbml0aW8uaApAQCAtMTE2LDcgKzExNiw3IEBACiAjZGVmaW5lIFRVTF9TQnVzSWQgICAgICAweDg5CS8qIDA5IFIgICBTQ1NJIEJVUyBJRCAgICAgICAgICAgICAgICAgICAqLwogI2RlZmluZSBUVUxfU1RpbWVPdXQgICAgMHg4QQkvKiAwQSBXICAgU2VsL1Jlc2VsIFRpbWUgT3V0IFJlZ2lzdGVyICAgKi8KICNkZWZpbmUgVFVMX1NJZGVudCAgICAgIDB4OEEJLyogMEEgUiAgIElkZW50aWZ5IE1lc3NhZ2UgUmVnaXN0ZXIgICAgICovCi0jZGVmaW5lIFRVTF9TQXZhaWwgICAgICAweDhBCS8qIDBBIFIgICBBdmFpbGlhYmxlIENvdW50ZXIgUmVnaXN0ZXIgICAqLworI2RlZmluZSBUVUxfU0F2YWlsICAgICAgMHg4QQkvKiAwQSBSICAgQXZhaWxhYmxlIENvdW50ZXIgUmVnaXN0ZXIgICAqLwogI2RlZmluZSBUVUxfU0RhdGEgICAgICAgMHg4QgkvKiAwQiBSL1cgU0NTSSBkYXRhIGluL291dCAgICAgICAgICAgICAgKi8KICNkZWZpbmUgVFVMX1NGaWZvICAgICAgIDB4OEMJLyogMEMgUi9XIEZJRk8gICAgICAgICAgICAgICAgICAgICAgICAgICovCiAjZGVmaW5lIFRVTF9TU2lnbmFsICAgICAweDkwCS8qIDEwIFIvVyBTQ1NJIHNpZ25hbCBpbi9vdXQgICAgICAgICAgICAqLwpAQCAtMzg5LDcgKzM4OSw3IEBACiAvKiBCaXQgRGVmaW5pdGlvbiBmb3Igc3RhdHVzICovCiAjZGVmaW5lIFNDQl9SRU5UICAgICAgICAweDAxCiAjZGVmaW5lIFNDQl9QRU5EICAgICAgICAweDAyCi0jZGVmaW5lIFNDQl9DT05USUcgICAgICAweDA0CS8qIENvbnRpZ2VudCBBbGxlZ2lhbmNlICovCisjZGVmaW5lIFNDQl9DT05USUcgICAgICAweDA0CS8qIENvbnRpbmdlbnQgQWxsZWdpYW5jZSAqLwogI2RlZmluZSBTQ0JfU0VMRUNUICAgICAgMHgwOAogI2RlZmluZSBTQ0JfQlVTWSAgICAgICAgMHgxMAogI2RlZmluZSBTQ0JfRE9ORSAgICAgICAgMHgyMApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2lwcy5jIGIvZHJpdmVycy9zY3NpL2lwcy5jCmluZGV4IGIyNTExYWMuLjIxOGY3MWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9pcHMuYworKysgYi9kcml2ZXJzL3Njc2kvaXBzLmMKQEAgLTEzNyw3ICsxMzcsNyBAQAogLyogICAgICAgICAgLSBGaXggcGF0aC9uYW1lIGZvciBzY3NpX2hvc3RzLmggaW5jbHVkZSBmb3IgMi42IGtlcm5lbHMgICAgICAgICAqLwogLyogICAgICAgICAgLSBGaXggc29ydCBvcmRlciBvZiA3ayAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwogLyogICAgICAgICAgLSBSZW1vdmUgMyB1bnVzZWQgImlubGluZSIgZnVuY3Rpb25zICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwotLyogNy4xMi54eCAgLSBVc2UgU1RBVElDIGZ1bmN0aW9ucyB3aGVyZWV2ZXIgcG9zc2libGUgICAgICAgICAgICAgICAgICAgICAgICAqLworLyogNy4xMi54eCAgLSBVc2UgU1RBVElDIGZ1bmN0aW9ucyB3aGVyZXZlciBwb3NzaWJsZSAgICAgICAgICAgICAgICAgICAgICAgICovCiAvKiAgICAgICAgICAtIENsZWFuIHVwIGRlcHJlY2F0ZWQgTU9EVUxFX1BBUk0gY2FsbHMgICAgICAgICAgICAgICAgICAgICAgICAgICovCiAvKiA3LjEyLjA1ICAtIFJlbW92ZSBWZXJzaW9uIE1hdGNoaW5nIHBlciBJQk0gcmVxdWVzdCAgICAgICAgICAgICAgICAgICAgICAgICovCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCkBAIC0xNjY1LDcgKzE2NjUsNyBAQAogCWludCBkYXRhc2l6ZTsKIAogCS8qIFRyb21ib25lIGlzIHRoZSBvbmx5IGNvcHBlcmhlYWQgdGhhdCBjYW4gZG8gcGFja2V0IGZsYXNoLCBidXQgb25seQotCSAqIGZvciBmaXJtd2FyZS4gTm8gb25lIHNhaWQgaXQgaGFkIHRvIG1ha2Ugc2VuY2UuICovCisJICogZm9yIGZpcm13YXJlLiBObyBvbmUgc2FpZCBpdCBoYWQgdG8gbWFrZSBzZW5zZS4gKi8KIAlpZiAoSVBTX0lTX1RST01CT05FKGhhKSAmJiBwdC0+Q29wcENQLmNtZC5mbGFzaGZ3LnR5cGUgPT0gSVBTX0ZXX0lNQUdFKSB7CiAJCWlmIChpcHNfdXNyY21kKGhhLCBwdCwgc2NiKSkKIAkJCXJldHVybiBJUFNfU1VDQ0VTUzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9pcHMuaCBiL2RyaXZlcnMvc2NzaS9pcHMuaAppbmRleCA0ZTQ5ZmJjLi5mMmRmMDU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvaXBzLmgKKysrIGIvZHJpdmVycy9zY3NpL2lwcy5oCkBAIC0xMTkzLDcgKzExOTMsNyBAQAogI2RlZmluZSBJUFNfVkVSX1NFQlJJTkcgIjcuMTIuMDIiCiAjZGVmaW5lIElQU19WRVJfS0VZV0VTVCAiNy4xMi4wMiIKIAotLyogQ29tcGF0YWJpbGl0eSBJRHMgZm9yIHZhcmlvdXMgYWRhcHRlcnMgKi8KKy8qIENvbXBhdGliaWxpdHkgSURzIGZvciB2YXJpb3VzIGFkYXB0ZXJzICovCiAjZGVmaW5lIElQU19DT01QQVRfVU5LTk9XTiAiIgogI2RlZmluZSBJUFNfQ09NUEFUX0NVUlJFTlQgIktXNzEwIgogI2RlZmluZSBJUFNfQ09NUEFUX1NFUlZFUkFJRDEgIjIuMjUuMDEiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvaXNjc2lfdGNwLmMgYi9kcml2ZXJzL3Njc2kvaXNjc2lfdGNwLmMKaW5kZXggYTg2MDQ1Mi4uM2RmOTg1MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2lzY3NpX3RjcC5jCisrKyBiL2RyaXZlcnMvc2NzaS9pc2NzaV90Y3AuYwpAQCAtMjk1LDcgKzI5NSw3IEBACiAJCXJjID0gaXNjc2lfc3dfdGNwX3htaXRfc2VnbWVudCh0Y3BfY29ubiwgc2VnbWVudCk7CiAJCS8qCiAJCSAqIFdlIG1heSBub3QgaGF2ZSBiZWVuIGFibGUgdG8gc2VuZCBkYXRhIGJlY2F1c2UgdGhlIGNvbm4KLQkJICogaXMgZ2V0dGluZyBzdG9wcGVkLiBsaWJpc2NzaSB3aWxsIGtub3cgc28gcHJvcG9nYXRlIGVycgorCQkgKiBpcyBnZXR0aW5nIHN0b3BwZWQuIGxpYmlzY3NpIHdpbGwga25vdyBzbyBwcm9wYWdhdGUgZXJyCiAJCSAqIGZvciBpdCB0byBkbyB0aGUgcmlnaHQgdGhpbmcuCiAJCSAqLwogCQlpZiAocmMgPT0gLUVBR0FJTikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9saWJmYy9mY19leGNoLmMgYi9kcml2ZXJzL3Njc2kvbGliZmMvZmNfZXhjaC5jCmluZGV4IDI4MjMxYmEuLjc3MDM1YTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9saWJmYy9mY19leGNoLmMKKysrIGIvZHJpdmVycy9zY3NpL2xpYmZjL2ZjX2V4Y2guYwpAQCAtMTA0Miw3ICsxMDQyLDcgQEAKIH0KIAogLyoqCi0gKiBmY19zZXFfZWxzX3JzcF9zZW5kKCkgLSBTZW5kIGFuIEVMUyByZXNwb25zZSB1c2luZyBpbmZvbWF0aW9uIGZyb20KKyAqIGZjX3NlcV9lbHNfcnNwX3NlbmQoKSAtIFNlbmQgYW4gRUxTIHJlc3BvbnNlIHVzaW5nIGluZm9ybWF0aW9uIGZyb20KICAqCQkJICAgdGhlIGV4aXN0aW5nIHNlcXVlbmNlL2V4Y2hhbmdlLgogICogQGZwOgkgICAgICBUaGUgcmVjZWl2ZWQgZnJhbWUKICAqIEBlbHNfY21kOiAgVGhlIEVMUyBjb21tYW5kIHRvIGJlIHNlbnQKQEAgLTExNTMsNyArMTE1Myw3IEBACiAgKiBmY19leGNoX3NlbmRfYmFfcmp0KCkgLSBTZW5kIEJMUyBSZWplY3QKICAqIEByeF9mcDogIFRoZSBmcmFtZSBiZWluZyByZWplY3RlZAogICogQHJlYXNvbjogVGhlIHJlYXNvbiB0aGUgZnJhbWUgaXMgYmVpbmcgcmVqZWN0ZWQKLSAqIEBleHBsYW46IFRoZSBleHBsYWluYXRpb24gZm9yIHRoZSByZWplY3Rpb24KKyAqIEBleHBsYW46IFRoZSBleHBsYW5hdGlvbiBmb3IgdGhlIHJlamVjdGlvbgogICoKICAqIFRoaXMgaXMgZm9yIHJlamVjdGluZyBCQV9BQlRTIG9ubHkuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9saWJmYy9mY19mY3AuYyBiL2RyaXZlcnMvc2NzaS9saWJmYy9mY19mY3AuYwppbmRleCBiMWIwM2FmLi41Yjc5OWEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbGliZmMvZmNfZmNwLmMKKysrIGIvZHJpdmVycy9zY3NpL2xpYmZjL2ZjX2ZjcC5jCkBAIC04NzAsNyArODcwLDcgQEAKIAkJCQlmc3AtPnNjc2lfcmVzaWQgPSBudG9obChycF9leC0+ZnJfcmVzaWQpOwogCQkJCS8qCiAJCQkJICogVGhlIGNtbmQtPnVuZGVyZmxvdyBpcyB0aGUgbWluaW11bSBudW1iZXIgb2YKLQkJCQkgKiBieXRlcyB0aGF0IG11c3QgYmUgdHJhbnNmZXJlZCBmb3IgdGhpcworCQkJCSAqIGJ5dGVzIHRoYXQgbXVzdCBiZSB0cmFuc2ZlcnJlZCBmb3IgdGhpcwogCQkJCSAqIGNvbW1hbmQuICBQcm92aWRlZCBhIHNlbnNlIGNvbmRpdGlvbiBpcyBub3QKIAkJCQkgKiBwcmVzZW50LCBtYWtlIHN1cmUgdGhlIGFjdHVhbCBhbW91bnQKIAkJCQkgKiB0cmFuc2ZlcnJlZCBpcyBhdCBsZWFzdCB0aGUgdW5kZXJmbG93IHZhbHVlCkBAIC0xMzA2LDcgKzEzMDYsNyBAQAogfQogCiAvKioKLSAqIGZjX3RtX2RvbmUoKSAtIFRhc2sgTWFuYWdtZW50IHJlc3BvbnNlIGhhbmRsZXIKKyAqIGZjX3RtX2RvbmUoKSAtIFRhc2sgTWFuYWdlbWVudCByZXNwb25zZSBoYW5kbGVyCiAgKiBAc2VxOiBUaGUgc2VxdWVuY2UgdGhhdCB0aGUgcmVzcG9uc2UgaXMgb24KICAqIEBmcDoJIFRoZSByZXNwb25zZSBmcmFtZQogICogQGFyZzogVGhlIEZDUCBwYWNrZXQgdGhlIHJlc3BvbnNlIGlzIGZvcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2xpYmZjL2ZjX2xwb3J0LmMgYi9kcml2ZXJzL3Njc2kvbGliZmMvZmNfbHBvcnQuYwppbmRleCA4YzA4YjIxLi45MDZiYmNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbGliZmMvZmNfbHBvcnQuYworKysgYi9kcml2ZXJzL3Njc2kvbGliZmMvZmNfbHBvcnQuYwpAQCAtNTIsNyArNTIsNyBAQAogICogd2hpbGUgbWFraW5nIHRoZSBjYWxsYmFjay4gVG8gZW5zdXJlIHRoYXQgdGhlIHJwb3J0IGlzIG5vdCBmcmVlJ2Qgd2hpbGUKICAqIHByb2Nlc3NpbmcgdGhlIGNhbGxiYWNrIHRoZSBycG9ydCBjYWxsYmFja3MgYXJlIHNlcmlhbGl6ZWQgdGhyb3VnaCBhCiAgKiBzaW5nbGUtdGhyZWFkZWQgd29ya3F1ZXVlLiBBbiBycG9ydCB3b3VsZCBuZXZlciBiZSBmcmVlJ2Qgd2hpbGUgaW4gYQotICogY2FsbGJhY2sgaGFuZGxlciBiZWN1YXNlIG5vIG90aGVyIHJwb3J0IHdvcmsgaW4gdGhpcyBxdWV1ZSBjYW4gYmUgZXhlY3V0ZWQKKyAqIGNhbGxiYWNrIGhhbmRsZXIgYmVjYXVzZSBubyBvdGhlciBycG9ydCB3b3JrIGluIHRoaXMgcXVldWUgY2FuIGJlIGV4ZWN1dGVkCiAgKiBhdCB0aGUgc2FtZSB0aW1lLgogICoKICAqIFdoZW4gZGlzY292ZXJ5IHN1Y2NlZWRzIG9yIGZhaWxzIGEgY2FsbGJhY2sgaXMgbWFkZSB0byB0aGUgbHBvcnQgYXMKQEAgLTE2Myw3ICsxNjMsNyBAQAogICogZmNfbHBvcnRfcnBvcnRfY2FsbGJhY2soKSAtIEV2ZW50IGhhbmRsZXIgZm9yIHJwb3J0IGV2ZW50cwogICogQGxwb3J0OiBUaGUgbHBvcnQgd2hpY2ggaXMgcmVjZWl2aW5nIHRoZSBldmVudAogICogQHJkYXRhOiBwcml2YXRlIHJlbW90ZSBwb3J0IGRhdGEKLSAqIEBldmVudDogVGhlIGV2ZW50IHRoYXQgb2NjdXJlZAorICogQGV2ZW50OiBUaGUgZXZlbnQgdGhhdCBvY2N1cnJlZAogICoKICAqIExvY2tpbmcgTm90ZTogVGhlIHJwb3J0IGxvY2sgc2hvdWxkIG5vdCBiZSBoZWxkIHdoZW4gY2FsbGluZwogICoJCSB0aGlzIGZ1bmN0aW9uLgpAQCAtMzc5LDcgKzM3OSw3IEBACiAKIC8qKgogICogZmNfbHBvcnRfcmVjdl9ybGlyX3JlcSgpIC0gSGFuZGxlIHJlY2VpdmVkIFJlZ2lzdGVyZWQgTGluayBJbmNpZGVudCBSZXBvcnQuCi0gKiBAbHBvcnQ6IEZpYnJlIENoYW5uZWwgbG9jYWwgcG9ydCByZWNpZXZpbmcgdGhlIFJMSVIKKyAqIEBscG9ydDogRmlicmUgQ2hhbm5lbCBsb2NhbCBwb3J0IHJlY2VpdmluZyB0aGUgUkxJUgogICogQGZwOgkgICBUaGUgUkxJUiByZXF1ZXN0IGZyYW1lCiAgKgogICogTG9ja2luZyBOb3RlOiBUaGUgbHBvcnQgbG9jayBpcyBleHBlY3RlZCB0byBiZSBoZWxkIGJlZm9yZSBjYWxsaW5nCkBAIC0zOTYsNyArMzk2LDcgQEAKIAogLyoqCiAgKiBmY19scG9ydF9yZWN2X2VjaG9fcmVxKCkgLSBIYW5kbGUgcmVjZWl2ZWQgRUNITyByZXF1ZXN0Ci0gKiBAbHBvcnQ6IFRoZSBsb2NhbCBwb3J0IHJlY2lldmluZyB0aGUgRUNITworICogQGxwb3J0OiBUaGUgbG9jYWwgcG9ydCByZWNlaXZpbmcgdGhlIEVDSE8KICAqIEBmcDoJICAgRUNITyByZXF1ZXN0IGZyYW1lCiAgKgogICogTG9ja2luZyBOb3RlOiBUaGUgbHBvcnQgbG9jayBpcyBleHBlY3RlZCB0byBiZSBoZWxkIGJlZm9yZSBjYWxsaW5nCkBAIC00MzIsNyArNDMyLDcgQEAKIAogLyoqCiAgKiBmY19scG9ydF9yZWN2X3JuaWRfcmVxKCkgLSBIYW5kbGUgcmVjZWl2ZWQgUmVxdWVzdCBOb2RlIElEIGRhdGEgcmVxdWVzdAotICogQGxwb3J0OiBUaGUgbG9jYWwgcG9ydCByZWNpZXZpbmcgdGhlIFJOSUQKKyAqIEBscG9ydDogVGhlIGxvY2FsIHBvcnQgcmVjZWl2aW5nIHRoZSBSTklECiAgKiBAZnA6CSAgIFRoZSBSTklEIHJlcXVlc3QgZnJhbWUKICAqCiAgKiBMb2NraW5nIE5vdGU6IFRoZSBscG9ydCBsb2NrIGlzIGV4cGVjdGVkIHRvIGJlIGhlbGQgYmVmb3JlIGNhbGxpbmcKQEAgLTQ5MSw3ICs0OTEsNyBAQAogCiAvKioKICAqIGZjX2xwb3J0X3JlY3ZfbG9nb19yZXEoKSAtIEhhbmRsZSByZWNlaXZlZCBmYWJyaWMgTE9HTyByZXF1ZXN0Ci0gKiBAbHBvcnQ6IFRoZSBsb2NhbCBwb3J0IHJlY2lldmluZyB0aGUgTE9HTworICogQGxwb3J0OiBUaGUgbG9jYWwgcG9ydCByZWNlaXZpbmcgdGhlIExPR08KICAqIEBmcDoJICAgVGhlIExPR08gcmVxdWVzdCBmcmFtZQogICoKICAqIExvY2tpbmcgTm90ZTogVGhlIGxwb3J0IGxvY2sgaXMgZXhlY3RlZCB0byBiZSBoZWxkIGJlZm9yZSBjYWxsaW5nCkBAIC03NzEsNyArNzcxLDcgQEAKIAogLyoqCiAgKiBmY19scG9ydF9yZWN2X2Zsb2dpX3JlcSgpIC0gUmVjZWl2ZSBhIEZMT0dJIHJlcXVlc3QKLSAqIEBscG9ydDogVGhlIGxvY2FsIHBvcnQgdGhhdCByZWNpZXZlZCB0aGUgcmVxdWVzdAorICogQGxwb3J0OiBUaGUgbG9jYWwgcG9ydCB0aGF0IHJlY2VpdmVkIHRoZSByZXF1ZXN0CiAgKiBAcnhfZnA6IFRoZSBGTE9HSSBmcmFtZQogICoKICAqIEEgcmVjZWl2ZWQgRkxPR0kgcmVxdWVzdCBpbmRpY2F0ZXMgYSBwb2ludC10by1wb2ludCBjb25uZWN0aW9uLgpAQCAtODU4LDcgKzg1OCw3IEBACiAgKiBpZiBhbiBycG9ydCBzaG91bGQgaGFuZGxlIHRoZSByZXF1ZXN0LgogICoKICAqIExvY2tpbmcgTm90ZTogVGhpcyBmdW5jdGlvbiBzaG91bGQgbm90IGJlIGNhbGxlZCB3aXRoIHRoZSBscG9ydAotICoJCSBsb2NrIGhlbGQgYmVjdWFzZSBpdCB3aWxsIGdyYWIgdGhlIGxvY2suCisgKgkJIGxvY2sgaGVsZCBiZWNhdXNlIGl0IHdpbGwgZ3JhYiB0aGUgbG9jay4KICAqLwogc3RhdGljIHZvaWQgZmNfbHBvcnRfcmVjdl9lbHNfcmVxKHN0cnVjdCBmY19scG9ydCAqbHBvcnQsCiAJCQkJICBzdHJ1Y3QgZmNfZnJhbWUgKmZwKQpAQCAtOTI1LDcgKzkyNSw3IEBACiAgKiBAZnA6IFRoZSBmcmFtZSB0aGUgcmVxdWVzdCBpcyBpbgogICoKICAqIExvY2tpbmcgTm90ZTogVGhpcyBmdW5jdGlvbiBzaG91bGQgbm90IGJlIGNhbGxlZCB3aXRoIHRoZSBscG9ydAotICoJCSBsb2NrIGhlbGQgYmVjdWFzZSBpdCBtYXkgZ3JhYiB0aGUgbG9jay4KKyAqCQkgbG9jayBoZWxkIGJlY2F1c2UgaXQgbWF5IGdyYWIgdGhlIGxvY2suCiAgKi8KIHN0YXRpYyB2b2lkIGZjX2xwb3J0X3JlY3ZfcmVxKHN0cnVjdCBmY19scG9ydCAqbHBvcnQsCiAJCQkgICAgICBzdHJ1Y3QgZmNfZnJhbWUgKmZwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2xpYnNhcy9zYXNfZXhwYW5kZXIuYyBiL2RyaXZlcnMvc2NzaS9saWJzYXMvc2FzX2V4cGFuZGVyLmMKaW5kZXggZjNmNjkzYi4uODc0ZTI5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2xpYnNhcy9zYXNfZXhwYW5kZXIuYworKysgYi9kcml2ZXJzL3Njc2kvbGlic2FzL3Nhc19leHBhbmRlci5jCkBAIC0yNDAsNyArMjQwLDcgQEAKIAkJCQkgICAgICAgZGlzY19yZXNwLCBESVNDT1ZFUl9SRVNQX1NJWkUpOwogCQlpZiAocmVzKQogCQkJcmV0dXJuIHJlczsKLQkJLyogVGhpcyBpcyBkZXRlY3RpbmcgYSBmYWlsdXJlIHRvIHRyYW5zbWl0IGluaXRhbAorCQkvKiBUaGlzIGlzIGRldGVjdGluZyBhIGZhaWx1cmUgdG8gdHJhbnNtaXQgaW5pdGlhbAogCQkgKiBkZXYgdG8gaG9zdCBGSVMgYXMgZGVzY3JpYmVkIGluIHNlY3Rpb24gRy41IG9mCiAJCSAqIHNhcy0yIHIgMDRiICovCiAJCWRyID0gJigoc3RydWN0IHNtcF9yZXNwICopZGlzY19yZXNwKS0+ZGlzYzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfYXR0ci5jIGIvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19hdHRyLmMKaW5kZXggNGUwZmFhMC4uMTdkNzg5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19hdHRyLmMKKysrIGIvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19hdHRyLmMKQEAgLTQ1MTUsNyArNDUxNSw3IEBACiAgKiBEZXNjcmlwdGlvbjoKICAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIGJ5IHRoZSB0cmFuc3BvcnQgYWZ0ZXIgdGhlIEBmY192cG9ydCdzIHN5bWJvbGljIG5hbWUKICAqIGhhcyBiZWVuIGNoYW5nZWQuIFRoaXMgZnVuY3Rpb24gcmUtcmVnaXN0ZXJzIHRoZSBzeW1ib2xpYyBuYW1lIHdpdGggdGhlCi0gKiBzd2l0Y2ggdG8gcHJvcG9nYXRlIHRoZSBjaGFuZ2UgaW50byB0aGUgZmFicmljIGlmIHRoZSB2cG9ydCBpcyBhY3RpdmUuCisgKiBzd2l0Y2ggdG8gcHJvcGFnYXRlIHRoZSBjaGFuZ2UgaW50byB0aGUgZmFicmljIGlmIHRoZSB2cG9ydCBpcyBhY3RpdmUuCiAgKiovCiBzdGF0aWMgdm9pZAogbHBmY19zZXRfdnBvcnRfc3ltYm9saWNfbmFtZShzdHJ1Y3QgZmNfdnBvcnQgKmZjX3Zwb3J0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19ic2cuYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfYnNnLmMKaW5kZXggNzkzYjlmMS4uNzdiMjg3MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19ic2cuYworKysgYi9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2JzZy5jCkBAIC0xOTM5LDcgKzE5MzksNyBAQAogICogQHJ4eHJpOiBSZWNlaXZlIGV4Y2hhbmdlIGlkCiAgKiBAbGVuOiBOdW1iZXIgb2YgZGF0YSBieXRlcwogICoKLSAqIFRoaXMgZnVuY3Rpb24gYWxsb2NhdGVzIGFuZCBwb3N0cyBhIGRhdGEgYnVmZmVyIG9mIHN1ZmZpY2llbnQgc2l6ZSB0byByZWNpZXZlCisgKiBUaGlzIGZ1bmN0aW9uIGFsbG9jYXRlcyBhbmQgcG9zdHMgYSBkYXRhIGJ1ZmZlciBvZiBzdWZmaWNpZW50IHNpemUgdG8gcmVjZWl2ZQogICogYW4gdW5zb2xpY3RlZCBDVCBjb21tYW5kLgogICoqLwogc3RhdGljIGludCBscGZjZGlhZ19sb29wX3Bvc3RfcnhidWZzKHN0cnVjdCBscGZjX2hiYSAqcGhiYSwgdWludDE2X3Qgcnh4cmksCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2RlYnVnZnMuYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfZGVidWdmcy5jCmluZGV4IGE3NTM1ODEuLjNkOTY3NzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfZGVidWdmcy5jCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfZGVidWdmcy5jCkBAIC05MDgsNyArOTA4LDcgQEAKIAlpZiAoIWRlYnVnKQogCQlnb3RvIG91dDsKIAotCS8qIFJvdW5kIHRvIHBhZ2UgYm91bmRyeSAqLworCS8qIFJvdW5kIHRvIHBhZ2UgYm91bmRhcnkgKi8KIAlwcmludGsoS0VSTl9FUlIgIjkwNTkgQkxLR1JEOiAgJXM6IF9kdW1wX2J1Zl9kYXRhPTB4JXBcbiIsCiAJCQlfX2Z1bmNfXywgX2R1bXBfYnVmX2RhdGEpOwogCWRlYnVnLT5idWZmZXIgPSBfZHVtcF9idWZfZGF0YTsKQEAgLTkzOCw3ICs5MzgsNyBAQAogCWlmICghZGVidWcpCiAJCWdvdG8gb3V0OwogCi0JLyogUm91bmQgdG8gcGFnZSBib3VuZHJ5ICovCisJLyogUm91bmQgdG8gcGFnZSBib3VuZGFyeSAqLwogCXByaW50ayhLRVJOX0VSUgkiOTA2MCBCTEtHUkQ6ICVzOiBfZHVtcF9idWZfZGlmPTB4JXAgZmlsZT0lc1xuIiwKIAkJX19mdW5jX18sIF9kdW1wX2J1Zl9kaWYsIGZpbGUtPmZfZGVudHJ5LT5kX25hbWUubmFtZSk7CiAJZGVidWctPmJ1ZmZlciA9IF9kdW1wX2J1Zl9kaWY7CkBAIC0yMTU4LDcgKzIxNTgsNyBAQAogCQkJZGVidWdmc19jcmVhdGVfZGlyKG5hbWUsIHBoYmEtPmhiYV9kZWJ1Z2ZzX3Jvb3QpOwogCQlpZiAoIXZwb3J0LT52cG9ydF9kZWJ1Z2ZzX3Jvb3QpIHsKIAkJCWxwZmNfcHJpbnRmX3Zsb2codnBvcnQsIEtFUk5fRVJSLCBMT0dfSU5JVCwKLQkJCQkJICIwNDE3IENhbnQgY3JlYXRlIGRlYnVnZnNcbiIpOworCQkJCQkgIjA0MTcgQ2FuJ3QgY3JlYXRlIGRlYnVnZnNcbiIpOwogCQkJZ290byBkZWJ1Z19mYWlsZWQ7CiAJCX0KIAkJYXRvbWljX2luYygmcGhiYS0+ZGVidWdmc192cG9ydF9jb3VudCk7CkBAIC0yMjExLDcgKzIyMTEsNyBAQAogCQkJCSB2cG9ydCwgJmxwZmNfZGVidWdmc19vcF9ub2RlbGlzdCk7CiAJaWYgKCF2cG9ydC0+ZGVidWdfbm9kZWxpc3QpIHsKIAkJbHBmY19wcmludGZfdmxvZyh2cG9ydCwgS0VSTl9FUlIsIExPR19JTklULAotCQkJCSAiMDQwOSBDYW50IGNyZWF0ZSBkZWJ1Z2ZzIG5vZGVsaXN0XG4iKTsKKwkJCQkgIjA0MDkgQ2FuJ3QgY3JlYXRlIGRlYnVnZnMgbm9kZWxpc3RcbiIpOwogCQlnb3RvIGRlYnVnX2ZhaWxlZDsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfZWxzLmMgYi9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2Vscy5jCmluZGV4IDczNTAyOGYuLmQzNGI2OWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfZWxzLmMKKysrIGIvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19lbHMuYwpAQCAtMTAyLDcgKzEwMiw3IEBACiAJCQkgcGhiYS0+cHBvcnQtPnBvcnRfc3RhdGUpOwogCiAJLyogQ0xFQVJfTEEgc2hvdWxkIHJlLWVuYWJsZSBsaW5rIGF0dGVudGlvbiBldmVudHMgYW5kCi0JICogd2Ugc2hvdWxkIHRoZW4gaW1lZGlhdGVseSB0YWtlIGEgTEFUVCBldmVudC4gVGhlCisJICogd2Ugc2hvdWxkIHRoZW4gaW1tZWRpYXRlbHkgdGFrZSBhIExBVFQgZXZlbnQuIFRoZQogCSAqIExBVFQgcHJvY2Vzc2luZyBzaG91bGQgY2FsbCBscGZjX2xpbmtkb3duKCkgd2hpY2gKIAkgKiB3aWxsIGNsZWFudXAgYW55IGxlZnQgb3ZlciBpbi1wcm9ncmVzcyBkaXNjb3ZlcnkKIAkgKiBldmVudHMuCkBAIC0xNTk5LDcgKzE1OTksNyBAQAogICogVGhpcyByb3V0aW5lIGlzIHRoZSBjb21wbGV0aW9uIGNhbGxiYWNrIGZ1bmN0aW9uIGZvciBpc3N1aW5nIHRoZSBQb3J0CiAgKiBMb2dpbiAoUExPR0kpIGNvbW1hbmQuIEZvciBQTE9HSSBjb21wbGV0aW9uLCB0aGVyZSBtdXN0IGJlIGFuIGFjdGl2ZQogICogbmRscCBvbiB0aGUgdnBvcnQgbm9kZSBsaXN0IHRoYXQgbWF0Y2hlcyB0aGUgcmVtb3RlIG5vZGUgSUQgZnJvbSB0aGUKLSAqIFBMT0dJIHJlcG9uc2UgSU9DQi4gSWYgc3VjaCBuZGxwIGRvZXMgbm90IGV4aXN0LCB0aGUgUExPR0kgaXMgc2ltcGx5CisgKiBQTE9HSSByZXNwb25zZSBJT0NCLiBJZiBzdWNoIG5kbHAgZG9lcyBub3QgZXhpc3QsIHRoZSBQTE9HSSBpcyBzaW1wbHkKICAqIGlnbm9yZWQgYW5kIGNvbW1hbmQgSU9DQiByZWxlYXNlZC4gVGhlIFBMT0dJIHJlc3BvbnNlIElPQ0Igc3RhdHVzIGlzCiAgKiBjaGVja2VkIGZvciBlcnJvciBjb25kaXRvbnMuIElmIHRoZXJlIGlzIGVycm9yIHN0YXR1cyByZXBvcnRlZCwgUExPR0kKICAqIHJldHJ5IHNoYWxsIGJlIGF0dGVtcHRlZCBieSBpbnZva2luZyB0aGUgbHBmY19lbHNfcmV0cnkoKSByb3V0aW5lLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19oYmFkaXNjLmMgYi9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2hiYWRpc2MuYwppbmRleCAxNTRjNzE1Li4zMDE0OTgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2hiYWRpc2MuYworKysgYi9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2hiYWRpc2MuYwpAQCAtNzM5LDcgKzczOSw3IEBACiAKIC8qCiAgKiBUaGlzIGlzIG9ubHkgY2FsbGVkIHRvIGhhbmRsZSBGQyB3b3JrZXIgZXZlbnRzLiBTaW5jZSB0aGlzIGEgcmFyZQotICogb2NjdXJhbmNlLCB3ZSBhbGxvY2F0ZSBhIHN0cnVjdCBscGZjX3dvcmtfZXZ0IHN0cnVjdHVyZSBoZXJlIGluc3RlYWQgb2YKKyAqIG9jY3VycmVuY2UsIHdlIGFsbG9jYXRlIGEgc3RydWN0IGxwZmNfd29ya19ldnQgc3RydWN0dXJlIGhlcmUgaW5zdGVhZCBvZgogICogZW1iZWRkaW5nIGl0IGluIHRoZSBJT0NCLgogICovCiBpbnQKQEAgLTEzNDgsNyArMTM0OCw3IEBACiAJaW50IHJjOwogCiAJc3Bpbl9sb2NrX2lycSgmcGhiYS0+aGJhbG9jayk7Ci0JLyogSWYgdGhlIEZDRiBpcyBub3QgYXZhaWxhYmUgZG8gbm90aGluZy4gKi8KKwkvKiBJZiB0aGUgRkNGIGlzIG5vdCBhdmFpbGFibGUgZG8gbm90aGluZy4gKi8KIAlpZiAoIShwaGJhLT5mY2YuZmNmX2ZsYWcgJiBGQ0ZfQVZBSUxBQkxFKSkgewogCQlwaGJhLT5oYmFfZmxhZyAmPSB+KEZDRl9UU19JTlBST0cgfCBGQ0ZfUlJfSU5QUk9HKTsKIAkJc3Bpbl91bmxvY2tfaXJxKCZwaGJhLT5oYmFsb2NrKTsKQEAgLTE1MzgsNyArMTUzOCw3IEBACiAKIAkJLyoKIAkJICogSWYgdXNlciBkaWQgbm90IHNwZWNpZnkgYW55IGFkZHJlc3NpbmcgbW9kZSwgb3IgaWYgdGhlCi0JCSAqIHByZWZlcmVkIGFkZHJlc3NpbmcgbW9kZSBzcGVjaWZpZWQgYnkgdXNlciBpcyBub3Qgc3VwcG9ydGVkCisJCSAqIHByZWZlcnJlZCBhZGRyZXNzaW5nIG1vZGUgc3BlY2lmaWVkIGJ5IHVzZXIgaXMgbm90IHN1cHBvcnRlZAogCQkgKiBieSBGQ0YsIGFsbG93IGZhYnJpYyB0byBwaWNrIHRoZSBhZGRyZXNzaW5nIG1vZGUuCiAJCSAqLwogCQkqYWRkcl9tb2RlID0gYmZfZ2V0KGxwZmNfZmNmX3JlY29yZF9tYWNfYWRkcl9wcm92LApAQCAtMTU1Myw3ICsxNTUzLDcgQEAKIAkJCQlGQ0ZDTkNUX0FNX1NQTUEpID8KIAkJCQlMUEZDX0ZDRl9TUE1BIDogTFBGQ19GQ0ZfRlBNQTsKIAkJLyoKLQkJICogSWYgdGhlIHVzZXIgc3BlY2lmaWVkIGEgcHJlZmVyZWQgYWRkcmVzcyBtb2RlLCB1c2UgdGhlCisJCSAqIElmIHRoZSB1c2VyIHNwZWNpZmllZCBhIHByZWZlcnJlZCBhZGRyZXNzIG1vZGUsIHVzZSB0aGUKIAkJICogYWRkciBtb2RlIG9ubHkgaWYgRkNGIHN1cHBvcnQgdGhlIGFkZHJfbW9kZS4KIAkJICovCiAJCWVsc2UgaWYgKChjb25uX2VudHJ5LT5jb25uX3JlYy5mbGFncyAmIEZDRkNOQ1RfQU1fVkFMSUQpICYmCkBAIC0zMTE3LDcgKzMxMTcsNyBAQAogCQkgKiBiYWNrIGF0IHJlZyBsb2dpbiBzdGF0ZSBzbyB0aGlzCiAJCSAqIG1ib3ggbmVlZHMgdG8gYmUgaWdub3JlZCBiZWNhc2UKIAkJICogdGhlcmUgaXMgYW5vdGhlciByZWcgbG9naW4gaW4KLQkJICogcHJvY2Nlc3MuCisJCSAqIHByb2Nlc3MuCiAJCSAqLwogCQlzcGluX2xvY2tfaXJxKHNob3N0LT5ob3N0X2xvY2spOwogCQluZGxwLT5ubHBfZmxhZyAmPSB+TkxQX0lHTlJfUkVHX0NNUEw7CkBAIC00NDc3LDcgKzQ0NzcsNyBAQAogCWlmICgodnBvcnQtPmZjX2ZsYWcgJiBGQ19SU0NOX01PREUpICYmCiAJICAgICEodnBvcnQtPmZjX2ZsYWcgJiBGQ19ORElTQ19BQ1RJVkUpKSB7CiAJCWlmIChscGZjX3JzY25fcGF5bG9hZF9jaGVjayh2cG9ydCwgZGlkKSkgewotCQkJLyogSWYgd2UndmUgYWxyZWFkeSByZWNpZXZlZCBhIFBMT0dJIGZyb20gdGhpcyBOUG9ydAorCQkJLyogSWYgd2UndmUgYWxyZWFkeSByZWNlaXZlZCBhIFBMT0dJIGZyb20gdGhpcyBOUG9ydAogCQkJICogd2UgZG9uJ3QgbmVlZCB0byB0cnkgdG8gZGlzY292ZXIgaXQgYWdhaW4uCiAJCQkgKi8KIAkJCWlmIChuZGxwLT5ubHBfZmxhZyAmIE5MUF9SQ1ZfUExPR0kpCkBAIC00NDkzLDcgKzQ0OTMsNyBAQAogCQl9IGVsc2UKIAkJCW5kbHAgPSBOVUxMOwogCX0gZWxzZSB7Ci0JCS8qIElmIHdlJ3ZlIGFscmVhZHkgcmVjaWV2ZWQgYSBQTE9HSSBmcm9tIHRoaXMgTlBvcnQsCisJCS8qIElmIHdlJ3ZlIGFscmVhZHkgcmVjZWl2ZWQgYSBQTE9HSSBmcm9tIHRoaXMgTlBvcnQsCiAJCSAqIG9yIHdlIGFyZSBhbHJlYWR5IGluIHRoZSBwcm9jZXNzIG9mIGRpc2NvdmVyeSBvbiBpdCwKIAkJICogd2UgZG9uJ3QgbmVlZCB0byB0cnkgdG8gZGlzY292ZXIgaXQgYWdhaW4uCiAJCSAqLwpAQCAtNTc1Niw3ICs1NzU2LDcgQEAKICAqIEBzaXplOiBTaXplIG9mIHRoZSBkYXRhIGJ1ZmZlci4KICAqIEByZWNfdHlwZTogUmVjb3JkIHR5cGUgdG8gYmUgc2VhcmNoZWQuCiAgKgotICogVGhpcyBmdW5jdGlvbiBzZWFyY2hlcyBjb25maWcgcmVnaW9uIGRhdGEgdG8gZmluZCB0aGUgYmVnaW5pbmcKKyAqIFRoaXMgZnVuY3Rpb24gc2VhcmNoZXMgY29uZmlnIHJlZ2lvbiBkYXRhIHRvIGZpbmQgdGhlIGJlZ2lubmluZwogICogb2YgdGhlIHJlY29yZCBzcGVjaWZpZWQgYnkgcmVjb3JkX3R5cGUuIElmIHJlY29yZCBmb3VuZCwgdGhpcwogICogZnVuY3Rpb24gcmV0dXJuIHBvaW50ZXIgdG8gdGhlIHJlY29yZCBlbHNlIHJldHVybiBOVUxMLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX2luaXQuYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfaW5pdC5jCmluZGV4IGU2ZWJlNTEuLjUwNWY4ODQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfaW5pdC5jCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfaW5pdC5jCkBAIC00NDY2LDcgKzQ0NjYsNyBAQAogfQogCiAvKioKLSAqIGxwZmNfaW5pdF9hcGlfdGFibGVfc2V0dXAgLSBTZXQgdXAgaW5pdCBhcGkgZnVjbnRpb24ganVtcCB0YWJsZQorICogbHBmY19pbml0X2FwaV90YWJsZV9zZXR1cCAtIFNldCB1cCBpbml0IGFwaSBmdW5jdGlvbiBqdW1wIHRhYmxlCiAgKiBAcGhiYTogVGhlIGhiYSBzdHJ1Y3QgZm9yIHdoaWNoIHRoaXMgY2FsbCBpcyBiZWluZyBleGVjdXRlZC4KICAqIEBkZXZfZ3JwOiBUaGUgSEJBIFBDSS1EZXZpY2UgZ3JvdXAgbnVtYmVyLgogICoKQEAgLTQ4NTAsNyArNDg1MCw3IEBACiAgKgogICogUmV0dXJuIGNvZGVzCiAgKiAJMCAtIHN1Y2Nlc3NmdWwKLSAqIAktRU5PTUVNIC0gTm8gYXZhaWxibGUgbWVtb3J5CisgKiAJLUVOT01FTSAtIE5vIGF2YWlsYWJsZSBtZW1vcnkKICAqICAgICAgLUVJTyAtIFRoZSBtYWlsYm94IGZhaWxlZCB0byBjb21wbGV0ZSBzdWNjZXNzZnVsbHkuCiAgKiovCiBpbnQKQEAgLTU3MzAsNyArNTczMCw3IEBACiAgKgogICogUmV0dXJuIGNvZGVzCiAgKiAJMCAtIHN1Y2Nlc3NmdWwKLSAqIAktRU5PTUVNIC0gTm8gYXZhaWxibGUgbWVtb3J5CisgKiAJLUVOT01FTSAtIE5vIGF2YWlsYWJsZSBtZW1vcnkKICAqICAgICAgLUVJTyAtIFRoZSBtYWlsYm94IGZhaWxlZCB0byBjb21wbGV0ZSBzdWNjZXNzZnVsbHkuCiAgKiovCiBzdGF0aWMgaW50CkBAIC01ODM1LDcgKzU4MzUsNyBAQAogICoKICAqIFJldHVybiBjb2RlcwogICogCTAgLSBzdWNjZXNzZnVsCi0gKiAJLUVOT01FTSAtIE5vIGF2YWlsYmxlIG1lbW9yeQorICogCS1FTk9NRU0gLSBObyBhdmFpbGFibGUgbWVtb3J5CiAgKiAgICAgIC1FSU8gLSBUaGUgbWFpbGJveCBmYWlsZWQgdG8gY29tcGxldGUgc3VjY2Vzc2Z1bGx5LgogICoqLwogc3RhdGljIGludApAQCAtNTg5NCw3ICs1ODk0LDcgQEAKICAqCiAgKiBSZXR1cm4gY29kZXMKICAqICAgICAgMCAtIHN1Y2Nlc3NmdWwKLSAqICAgICAgLUVOT01FTSAtIE5vIGF2YWlsYmxlIG1lbW9yeQorICogICAgICAtRU5PTUVNIC0gTm8gYXZhaWxhYmxlIG1lbW9yeQogICogICAgICAtRUlPIC0gVGhlIG1haWxib3ggZmFpbGVkIHRvIGNvbXBsZXRlIHN1Y2Nlc3NmdWxseS4KICAqKi8KIHN0YXRpYyBpbnQKQEAgLTYxODksNyArNjE4OSw3IEBACiAgKgogICogUmV0dXJuIGNvZGVzCiAgKiAgICAgIDAgLSBzdWNjZXNzZnVsCi0gKiAgICAgIC1FTk9NRU0gLSBObyBhdmFpbGJsZSBtZW1vcnkKKyAqICAgICAgLUVOT01FTSAtIE5vIGF2YWlsYWJsZSBtZW1vcnkKICAqICAgICAgLUVJTyAtIFRoZSBtYWlsYm94IGZhaWxlZCB0byBjb21wbGV0ZSBzdWNjZXNzZnVsbHkuCiAgKiovCiBzdGF0aWMgdm9pZApAQCAtNjI1Myw3ICs2MjUzLDcgQEAKICAqCiAgKiBSZXR1cm4gY29kZXMKICAqICAgICAgMCAtIHN1Y2Nlc3NmdWwKLSAqICAgICAgLUVOT01FTSAtIE5vIGF2YWlsYmxlIG1lbW9yeQorICogICAgICAtRU5PTUVNIC0gTm8gYXZhaWxhYmxlIG1lbW9yeQogICogICAgICAtRUlPIC0gVGhlIG1haWxib3ggZmFpbGVkIHRvIGNvbXBsZXRlIHN1Y2Nlc3NmdWxseS4KICAqKi8KIGludApAQCAtNjQ5OCw3ICs2NDk4LDcgQEAKICAqCiAgKiBSZXR1cm4gY29kZXMKICAqICAgICAgMCAtIHN1Y2Nlc3NmdWwKLSAqICAgICAgLUVOT01FTSAtIE5vIGF2YWlsYmxlIG1lbW9yeQorICogICAgICAtRU5PTUVNIC0gTm8gYXZhaWxhYmxlIG1lbW9yeQogICogICAgICAtRUlPIC0gVGhlIG1haWxib3ggZmFpbGVkIHRvIGNvbXBsZXRlIHN1Y2Nlc3NmdWxseS4KICAqKi8KIHZvaWQKQEAgLTY1NDMsNyArNjU0Myw3IEBACiAgKgogICogUmV0dXJuIGNvZGVzCiAgKiAgICAgIDAgLSBzdWNjZXNzZnVsCi0gKiAgICAgIC1FTk9NRU0gLSBObyBhdmFpbGJsZSBtZW1vcnkKKyAqICAgICAgLUVOT01FTSAtIE5vIGF2YWlsYWJsZSBtZW1vcnkKICAqKi8KIHN0YXRpYyBpbnQKIGxwZmNfc2xpNF9jcV9ldmVudF9wb29sX2NyZWF0ZShzdHJ1Y3QgbHBmY19oYmEgKnBoYmEpCkBAIC02NzA0LDcgKzY3MDQsNyBAQAogICoKICAqIFJldHVybiBjb2RlcwogICogICAgICAwIC0gc3VjY2Vzc2Z1bAotICogICAgICAtRU5PTUVNIC0gTm8gYXZhaWxibGUgbWVtb3J5CisgKiAgICAgIC1FTk9NRU0gLSBObyBhdmFpbGFibGUgbWVtb3J5CiAgKiAgICAgIC1FSU8gLSBUaGUgbWFpbGJveCBmYWlsZWQgdG8gY29tcGxldGUgc3VjY2Vzc2Z1bGx5LgogICoqLwogaW50CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX21ib3guYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfbWJveC5jCmluZGV4IGRiYTMyZGYuLmZiYWI5NzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfbWJveC5jCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfbWJveC5jCkBAIC0xODM0LDcgKzE4MzQsNyBAQAogICogQGZjZl9pbmRleDogaW5kZXggdG8gZmNmIHRhYmxlLgogICoKICAqIFRoaXMgcm91dGluZSByb3V0aW5lIGFsbG9jYXRlcyBhbmQgY29uc3RydWN0cyBub24tZW1iZWRkZWQgbWFpbGJveCBjb21tYW5kCi0gKiBmb3IgcmVhZGluZyBhIEZDRiB0YWJsZSBlbnRyeSByZWZlcmVkIGJ5IEBmY2ZfaW5kZXguCisgKiBmb3IgcmVhZGluZyBhIEZDRiB0YWJsZSBlbnRyeSByZWZlcnJlZCBieSBAZmNmX2luZGV4LgogICoKICAqIFJldHVybjogcG9pbnRlciB0byB0aGUgbWFpbGJveCBjb21tYW5kIGNvbnN0cnVjdGVkIGlmIHN1Y2Nlc3NmdWwsIG90aGVyd2lzZQogICogTlVMTC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfbmwuaCBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfbmwuaAppbmRleCBmM2NmYmUyLi5mMmIxYmJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX25sLmgKKysrIGIvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19ubC5oCkBAIC01MCw3ICs1MCw3IEBACiAgKiBhbmQgc3ViY2F0ZWdvcnkuIFRoZSBldmVudCB0eXBlIG11c3QgY29tZSBmaXJzdC4KICAqIFRoZSBzdWJjYXRlZ29yeSBmdXJ0aGVyIGRlZmluZXMgdGhlIGRhdGEgdGhhdCBmb2xsb3dzIGluIHRoZSByZXN0CiAgKiBvZiB0aGUgcGF5bG9hZC4gRWFjaCBjYXRlZ29yeSB3aWxsIGhhdmUgaXRzIG93biB1bmlxdWUgaGVhZGVyIHBsdXMKLSAqIGFueSBhZGR0aW9uYWwgZGF0YSB1bmlxdWUgdG8gdGhlIHN1YmNhdGVnb3J5LgorICogYW55IGFkZGl0aW9uYWwgZGF0YSB1bmlxdWUgdG8gdGhlIHN1YmNhdGVnb3J5LgogICogVGhlIHBheWxvYWQgc2VudCB2aWEgdGhlIGZjIHRyYW5zcG9ydCBpcyBvbmUtd2F5IGRyaXZlci0+YXBwbGljYXRpb24uCiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19ucG9ydGRpc2MuYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfbnBvcnRkaXNjLmMKaW5kZXggNTJiMzUxNS4uMGQ5MmQ0MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19ucG9ydGRpc2MuYworKysgYi9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX25wb3J0ZGlzYy5jCkBAIC02NTgsNyArNjU4LDcgQEAKIAlyZXR1cm4gMDsKIH0KIC8qKgotICogbHBmY19yZWxlYXNlX3JwaSAtIFJlbGVhc2UgYSBSUEkgYnkgaXNzdWVpbmcgdW5yZWdfbG9naW4gbWFpbGJveCBjbWQuCisgKiBscGZjX3JlbGVhc2VfcnBpIC0gUmVsZWFzZSBhIFJQSSBieSBpc3N1aW5nIHVucmVnX2xvZ2luIG1haWxib3ggY21kLgogICogQHBoYmEgOiBQb2ludGVyIHRvIGxwZmNfaGJhIHN0cnVjdHVyZS4KICAqIEB2cG9ydDogUG9pbnRlciB0byBscGZjX3Zwb3J0IHN0cnVjdHVyZS4KICAqIEBycGkgIDogcnBpIHRvIGJlIHJlbGVhc2UuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX3Njc2kuYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5jCmluZGV4IDJiOTYyYjAuLmZlN2NjODQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5jCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5jCkBAIC01NzcsNyArNTc3LDcgQEAKIAkJCWlvY2ItPnVuLmZjcGk2NC5iZGwuYWRkckhpZ2ggPSAwOwogCQkJaW9jYi0+dWxwQmRlQ291bnQgPSAwOwogCQkJaW9jYi0+dWxwTGUgPSAwOwotCQkJLyogZmlsbCBpbiByZXNwb25jZSBCREUgKi8KKwkJCS8qIGZpbGwgaW4gcmVzcG9uc2UgQkRFICovCiAJCQlpb2NiLT51bnNsaTMuZmNwX2V4dC5yYmRlLnR1cy5mLmJkZUZsYWdzID0KIAkJCQkJCQlCVUZGX1RZUEVfQkRFXzY0OwogCQkJaW9jYi0+dW5zbGkzLmZjcF9leHQucmJkZS50dXMuZi5iZGVTaXplID0KQEAgLTEyMTcsMTAgKzEyMTcsMTAgQEAKIAkJCQkgICAgICgyICogc2l6ZW9mKHN0cnVjdCB1bHBfYmRlNjQpKSk7CiAJCQlkYXRhX2JkZS0+YWRkckhpZ2ggPSBwdXRQYWRkckhpZ2gocGh5c2FkZHIpOwogCQkJZGF0YV9iZGUtPmFkZHJMb3cgPSBwdXRQYWRkckxvdyhwaHlzYWRkcik7Ci0JCQkvKiBlYmRlIGNvdW50IGluY2x1ZGVzIHRoZSByZXNwb25jZSBiZGUgYW5kIGRhdGEgYnBsICovCisJCQkvKiBlYmRlIGNvdW50IGluY2x1ZGVzIHRoZSByZXNwb25zZSBiZGUgYW5kIGRhdGEgYnBsICovCiAJCQlpb2NiX2NtZC0+dW5zbGkzLmZjcF9leHQuZWJkZV9jb3VudCA9IDI7CiAJCX0gZWxzZSB7Ci0JCQkvKiBlYmRlIGNvdW50IGluY2x1ZGVzIHRoZSByZXNwb25jZSBiZGUgYW5kIGRhdGEgYmRlcyAqLworCQkJLyogZWJkZSBjb3VudCBpbmNsdWRlcyB0aGUgcmVzcG9uc2UgYmRlIGFuZCBkYXRhIGJkZXMgKi8KIAkJCWlvY2JfY21kLT51bnNsaTMuZmNwX2V4dC5lYmRlX2NvdW50ID0gKG51bV9iZGUgKyAxKTsKIAkJfQogCX0gZWxzZSB7CkBAIC0yMzgwLDcgKzIzODAsNyBAQAogCQl9CiAJCS8qCiAJCSAqIFRoZSBjbW5kLT51bmRlcmZsb3cgaXMgdGhlIG1pbmltdW0gbnVtYmVyIG9mIGJ5dGVzIHRoYXQgbXVzdAotCQkgKiBiZSB0cmFuc2ZlcmVkIGZvciB0aGlzIGNvbW1hbmQuICBQcm92aWRlZCBhIHNlbnNlIGNvbmRpdGlvbgorCQkgKiBiZSB0cmFuc2ZlcnJlZCBmb3IgdGhpcyBjb21tYW5kLiAgUHJvdmlkZWQgYSBzZW5zZSBjb25kaXRpb24KIAkJICogaXMgbm90IHByZXNlbnQsIG1ha2Ugc3VyZSB0aGUgYWN0dWFsIGFtb3VudCB0cmFuc2ZlcnJlZCBpcyBhdAogCQkgKiBsZWFzdCB0aGUgdW5kZXJmbG93IHZhbHVlIG9yIGZhaWwuCiAJCSAqLwpAQCAtMjg3Myw3ICsyODczLDcgQEAKIH0KIAogLyoqCi0gKiBscGZjX3Njc2lfYXBpX3RhYmxlX3NldHVwIC0gU2V0IHVwIHNjc2kgYXBpIGZ1Y250aW9uIGp1bXAgdGFibGUKKyAqIGxwZmNfc2NzaV9hcGlfdGFibGVfc2V0dXAgLSBTZXQgdXAgc2NzaSBhcGkgZnVuY3Rpb24ganVtcCB0YWJsZQogICogQHBoYmE6IFRoZSBoYmEgc3RydWN0IGZvciB3aGljaCB0aGlzIGNhbGwgaXMgYmVpbmcgZXhlY3V0ZWQuCiAgKiBAZGV2X2dycDogVGhlIEhCQSBQQ0ktRGV2aWNlIGdyb3VwIG51bWJlci4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX3Njc2kuaCBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5oCmluZGV4IDU5MzIyNzMuLmNlNjQ1YjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5oCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5oCkBAIC0xMzAsNyArMTMwLDcgQEAKIAlkbWFfYWRkcl90IG5vbnNnX3BoeXM7CS8qIE5vbiBzY2F0dGVyLWdhdGhlciBwaHlzaWNhbCBhZGRyZXNzLiAqLwogCiAJLyoKLQkgKiBkYXRhIGFuZCBkbWFfaGFuZGxlIGFyZSB0aGUga2VybmVsIHZpcnV0YWwgYW5kIGJ1cyBhZGRyZXNzIG9mIHRoZQorCSAqIGRhdGEgYW5kIGRtYV9oYW5kbGUgYXJlIHRoZSBrZXJuZWwgdmlydHVhbCBhbmQgYnVzIGFkZHJlc3Mgb2YgdGhlCiAJICogZG1hLWFibGUgYnVmZmVyIGNvbnRhaW5pbmcgdGhlIGZjcF9jbWQsIGZjcF9yc3AgYW5kIGEgc2NhdHRlcgogCSAqIGdhdGhlciBiZGUgbGlzdCB0aGF0IHN1cHBvcnRzIHRoZSBzZ190YWJsZXNpemUgdmFsdWUuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX3NsaS5jIGIvZHJpdmVycy9zY3NpL2xwZmMvbHBmY19zbGkuYwppbmRleCA0NzQ2ZGNkLi5kYWNhYmJlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX3NsaS5jCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2xpLmMKQEAgLTI4MTcsNyArMjgxNyw3IEBACiAgKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBmcm9tIHRoZSBpbnRlcnJ1cHQgY29udGV4dCB3aGVuIHRoZXJlIGlzIGEgcmluZwogICogZXZlbnQgZm9yIHRoZSBmY3AgcmluZy4gVGhlIGNhbGxlciBkb2VzIG5vdCBob2xkIGFueSBsb2NrLgogICogVGhlIGZ1bmN0aW9uIHByb2Nlc3NlcyBlYWNoIHJlc3BvbnNlIGlvY2IgaW4gdGhlIHJlc3BvbnNlIHJpbmcgdW50aWwgaXQKLSAqIGZpbmRzIGFuIGlvY2Igd2l0aCBMRSBiaXQgc2V0IGFuZCBjaGFpbnMgYWxsIHRoZSBpb2NicyB1cHRvIHRoZSBpb2NiIHdpdGgKKyAqIGZpbmRzIGFuIGlvY2Igd2l0aCBMRSBiaXQgc2V0IGFuZCBjaGFpbnMgYWxsIHRoZSBpb2NicyB1cCB0byB0aGUgaW9jYiB3aXRoCiAgKiBMRSBiaXQgc2V0LiBUaGUgZnVuY3Rpb24gd2lsbCBjYWxsIHRoZSBjb21wbGV0aW9uIGhhbmRsZXIgb2YgdGhlIGNvbW1hbmQgaW9jYgogICogaWYgdGhlIHJlc3BvbnNlIGlvY2IgaW5kaWNhdGVzIGEgY29tcGxldGlvbiBmb3IgYSBjb21tYW5kIGlvY2Igb3IgaXQgaXMKICAqIGFuIGFib3J0IGNvbXBsZXRpb24uIFRoZSBmdW5jdGlvbiB3aWxsIGNhbGwgbHBmY19zbGlfcHJvY2Vzc191bnNvbF9pb2NiCkBAIC01MTE3LDcgKzUxMTcsNyBAQAogCiAJLyogU2V0dGluZyBzdGF0ZSB1bmtub3duIHNvIGxwZmNfc2xpX2Fib3J0X2lvY2JfcmluZwogCSAqIHdvdWxkIGdldCBJT0NCX0VSUk9SIGZyb20gbHBmY19zbGlfaXNzdWVfaW9jYiwgYWxsb3dpbmcKLQkgKiBpdCB0byBmYWlsIGFsbCBvdXN0YW5kaW5nIFNDU0kgSU8uCisJICogaXQgdG8gZmFpbCBhbGwgb3V0c3RhbmRpbmcgU0NTSSBJTy4KIAkgKi8KIAlzcGluX2xvY2tfaXJxKCZwaGJhLT5wcG9ydC0+d29ya19wb3J0X2xvY2spOwogCXBoYmEtPnBwb3J0LT53b3JrX3BvcnRfZXZlbnRzICY9IH5XT1JLRVJfTUJPWF9UTU87CkBAIC02MDMxLDcgKzYwMzEsNyBAQAogfQogCiAvKioKLSAqIGxwZmNfbWJveF9hcGlfdGFibGVfc2V0dXAgLSBTZXQgdXAgbWJveCBhcGkgZnVjbnRpb24ganVtcCB0YWJsZQorICogbHBmY19tYm94X2FwaV90YWJsZV9zZXR1cCAtIFNldCB1cCBtYm94IGFwaSBmdW5jdGlvbiBqdW1wIHRhYmxlCiAgKiBAcGhiYTogVGhlIGhiYSBzdHJ1Y3QgZm9yIHdoaWNoIHRoaXMgY2FsbCBpcyBiZWluZyBleGVjdXRlZC4KICAqIEBkZXZfZ3JwOiBUaGUgSEJBIFBDSS1EZXZpY2UgZ3JvdXAgbnVtYmVyLgogICoKQEAgLTY4NDcsNyArNjg0Nyw3IEBACiB9CiAKIC8qKgotICogbHBmY19zbGlfYXBpX3RhYmxlX3NldHVwIC0gU2V0IHVwIHNsaSBhcGkgZnVjbnRpb24ganVtcCB0YWJsZQorICogbHBmY19zbGlfYXBpX3RhYmxlX3NldHVwIC0gU2V0IHVwIHNsaSBhcGkgZnVuY3Rpb24ganVtcCB0YWJsZQogICogQHBoYmE6IFRoZSBoYmEgc3RydWN0IGZvciB3aGljaCB0aGlzIGNhbGwgaXMgYmVpbmcgZXhlY3V0ZWQuCiAgKiBAZGV2X2dycDogVGhlIEhCQSBQQ0ktRGV2aWNlIGdyb3VwIG51bWJlci4KICAqCkBAIC03NTIxLDcgKzc1MjEsNyBAQAogCXN0cnVjdCBscGZjX2RtYWJ1ZiAqbXAsICpuZXh0X21wOwogCXN0cnVjdCBsaXN0X2hlYWQgKnNscCA9ICZwcmluZy0+cG9zdGJ1ZnE7CiAKLQkvKiBTZWFyY2ggcG9zdGJ1ZnEsIGZyb20gdGhlIGJlZ2luaW5nLCBsb29raW5nIGZvciBhIG1hdGNoIG9uIHRhZyAqLworCS8qIFNlYXJjaCBwb3N0YnVmcSwgZnJvbSB0aGUgYmVnaW5uaW5nLCBsb29raW5nIGZvciBhIG1hdGNoIG9uIHRhZyAqLwogCXNwaW5fbG9ja19pcnEoJnBoYmEtPmhiYWxvY2spOwogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShtcCwgbmV4dF9tcCwgJnByaW5nLT5wb3N0YnVmcSwgbGlzdCkgewogCQlpZiAobXAtPmJ1ZmZlcl90YWcgPT0gdGFnKSB7CkBAIC03NTY1LDcgKzc1NjUsNyBAQAogCXN0cnVjdCBscGZjX2RtYWJ1ZiAqbXAsICpuZXh0X21wOwogCXN0cnVjdCBsaXN0X2hlYWQgKnNscCA9ICZwcmluZy0+cG9zdGJ1ZnE7CiAKLQkvKiBTZWFyY2ggcG9zdGJ1ZnEsIGZyb20gdGhlIGJlZ2luaW5nLCBsb29raW5nIGZvciBhIG1hdGNoIG9uIHBoeXMgKi8KKwkvKiBTZWFyY2ggcG9zdGJ1ZnEsIGZyb20gdGhlIGJlZ2lubmluZywgbG9va2luZyBmb3IgYSBtYXRjaCBvbiBwaHlzICovCiAJc3Bpbl9sb2NrX2lycSgmcGhiYS0+aGJhbG9jayk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKG1wLCBuZXh0X21wLCAmcHJpbmctPnBvc3RidWZxLCBsaXN0KSB7CiAJCWlmIChtcC0+cGh5cyA9PSBwaHlzKSB7CkBAIC04NDM4LDcgKzg0MzgsNyBAQAogICogZm9yIHBvc3NpYmxlIGVycm9yIGF0dGVudGlvbiBldmVudHMuIFRoZSBjYWxsZXIgbXVzdCBob2xkIHRoZSBob3N0bG9jawogICogd2l0aCBzcGluX2xvY2tfaXJxKCkuCiAgKgotICogVGhpcyBmdWNudGlvbiByZXR1cm5zIDEgd2hlbiB0aGVyZSBpcyBFcnJvciBBdHRlbnRpb24gaW4gdGhlIEhvc3QgQXR0ZW50aW9uCisgKiBUaGlzIGZ1bmN0aW9uIHJldHVybnMgMSB3aGVuIHRoZXJlIGlzIEVycm9yIEF0dGVudGlvbiBpbiB0aGUgSG9zdCBBdHRlbnRpb24KICAqIFJlZ2lzdGVyIGFuZCByZXR1cm5zIDAgb3RoZXJ3aXNlLgogICoqLwogc3RhdGljIGludApAQCAtODQ5MSw3ICs4NDkxLDcgQEAKICAqIGZvciBwb3NzaWJsZSBlcnJvciBhdHRlbnRpb24gZXZlbnRzLiBUaGUgY2FsbGVyIG11c3QgaG9sZCB0aGUgaG9zdGxvY2sKICAqIHdpdGggc3Bpbl9sb2NrX2lycSgpLgogICoKLSAqIFRoaXMgZnVjbnRpb24gcmV0dXJucyAxIHdoZW4gdGhlcmUgaXMgRXJyb3IgQXR0ZW50aW9uIGluIHRoZSBIb3N0IEF0dGVudGlvbgorICogVGhpcyBmdW5jdGlvbiByZXR1cm5zIDEgd2hlbiB0aGVyZSBpcyBFcnJvciBBdHRlbnRpb24gaW4gdGhlIEhvc3QgQXR0ZW50aW9uCiAgKiBSZWdpc3RlciBhbmQgcmV0dXJucyAwIG90aGVyd2lzZS4KICAqKi8KIHN0YXRpYyBpbnQKQEAgLTg1ODEsNyArODU4MSw3IEBACiAgKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBmcm9tIHRpbWVyIHNvZnQgaW50ZXJydXB0IGNvbnRleHQgdG8gY2hlY2sgSEJBJ3MKICAqIGVycm9yIGF0dGVudGlvbiByZWdpc3RlciBiaXQgZm9yIGVycm9yIGF0dGVudGlvbiBldmVudHMuCiAgKgotICogVGhpcyBmdWNudGlvbiByZXR1cm5zIDEgd2hlbiB0aGVyZSBpcyBFcnJvciBBdHRlbnRpb24gaW4gdGhlIEhvc3QgQXR0ZW50aW9uCisgKiBUaGlzIGZ1bmN0aW9uIHJldHVybnMgMSB3aGVuIHRoZXJlIGlzIEVycm9yIEF0dGVudGlvbiBpbiB0aGUgSG9zdCBBdHRlbnRpb24KICAqIFJlZ2lzdGVyIGFuZCByZXR1cm5zIDAgb3RoZXJ3aXNlLgogICoqLwogaW50CkBAIC05Njg0LDcgKzk2ODQsNyBAQAogICogQGNxOiBQb2ludGVyIHRvIHRoZSBjb21wbGV0aW9uIHF1ZXVlLgogICogQHdjcWU6IFBvaW50ZXIgdG8gYSBjb21wbGV0aW9uIHF1ZXVlIGVudHJ5LgogICoKLSAqIFRoaXMgcm91dGluZSBwcm9jZXNzIGEgc2xvdy1wYXRoIHdvcmstcXVldWUgb3IgcmVjaWV2ZSBxdWV1ZSBjb21wbGV0aW9uIHF1ZXVlCisgKiBUaGlzIHJvdXRpbmUgcHJvY2VzcyBhIHNsb3ctcGF0aCB3b3JrLXF1ZXVlIG9yIHJlY2VpdmUgcXVldWUgY29tcGxldGlvbiBxdWV1ZQogICogZW50cnkuCiAgKgogICogUmV0dXJuOiB0cnVlIGlmIHdvcmsgcG9zdGVkIHRvIHdvcmtlciB0aHJlYWQsIG90aGVyd2lzZSBmYWxzZS4KQEAgLTEyOTcxLDcgKzEyOTcxLDcgQEAKICAqIHJlY29yZCBhbmQgcHJvY2Vzc2luZyBpdCBvbmUgYXQgYSB0aW1lIHN0YXJ0aW5nIGZyb20gdGhlIEBmY2ZfaW5kZXgKICAqIGZvciBpbml0aWFsIEZDRiBkaXNjb3Zlcnkgb3IgZmFzdCBGQ0YgZmFpbG92ZXIgcmVkaXNjb3ZlcnkuCiAgKgotICogUmV0dXJuIDAgaWYgdGhlIG1haWxib3ggY29tbWFuZCBpcyBzdWJtaXR0ZWQgc3VjZXNzZnVsbHksIG5vbmUgMAorICogUmV0dXJuIDAgaWYgdGhlIG1haWxib3ggY29tbWFuZCBpcyBzdWJtaXR0ZWQgc3VjY2Vzc2Z1bGx5LCBub25lIDAKICAqIG90aGVyd2lzZS4KICAqKi8KIGludApAQCAtMTMwMzIsNyArMTMwMzIsNyBAQAogICogVGhpcyByb3V0aW5lIGlzIGludm9rZWQgdG8gcmVhZCBhbiBGQ0YgcmVjb3JkIGluZGljYXRlZCBieSBAZmNmX2luZGV4CiAgKiBhbmQgdG8gdXNlIGl0IGZvciBGTE9HSSByb3VuZHJvYmluIEZDRiBmYWlsb3Zlci4KICAqCi0gKiBSZXR1cm4gMCBpZiB0aGUgbWFpbGJveCBjb21tYW5kIGlzIHN1Ym1pdHRlZCBzdWNlc3NmdWxseSwgbm9uZSAwCisgKiBSZXR1cm4gMCBpZiB0aGUgbWFpbGJveCBjb21tYW5kIGlzIHN1Ym1pdHRlZCBzdWNjZXNzZnVsbHksIG5vbmUgMAogICogb3RoZXJ3aXNlLgogICoqLwogaW50CkBAIC0xMzA3OCw3ICsxMzA3OCw3IEBACiAgKiBUaGlzIHJvdXRpbmUgaXMgaW52b2tlZCB0byByZWFkIGFuIEZDRiByZWNvcmQgaW5kaWNhdGVkIGJ5IEBmY2ZfaW5kZXggdG8KICAqIGRldGVybWluZSB3aGV0aGVyIGl0J3MgZWxpZ2libGUgZm9yIEZMT0dJIHJvdW5kcm9iaW4gZmFpbG92ZXIgbGlzdC4KICAqCi0gKiBSZXR1cm4gMCBpZiB0aGUgbWFpbGJveCBjb21tYW5kIGlzIHN1Ym1pdHRlZCBzdWNlc3NmdWxseSwgbm9uZSAwCisgKiBSZXR1cm4gMCBpZiB0aGUgbWFpbGJveCBjb21tYW5kIGlzIHN1Ym1pdHRlZCBzdWNjZXNzZnVsbHksIG5vbmUgMAogICogb3RoZXJ3aXNlLgogICoqLwogaW50CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbWVnYXJhaWQuYyBiL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC5jCmluZGV4IGMyMTI2OTQuLmYyNjg0ZGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC5jCisrKyBiL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC5jCkBAIC0yODQsNyArMjg0LDcgQEAKIAogCWFkYXB0ZXItPmhvc3QtPm1heF9pZCA9IDE2OwkvKiBtYXggdGFyZ2V0cyBwZXIgY2hhbm5lbCAqLwogCi0JYWRhcHRlci0+aG9zdC0+bWF4X2x1biA9IDc7CS8qIFVwdG8gNyBsdW5zIGZvciBub24gZGlzayBkZXZpY2VzICovCisJYWRhcHRlci0+aG9zdC0+bWF4X2x1biA9IDc7CS8qIFVwIHRvIDcgbHVucyBmb3Igbm9uIGRpc2sgZGV2aWNlcyAqLwogCiAJYWRhcHRlci0+aG9zdC0+Y21kX3Blcl9sdW4gPSBtYXhfY21kX3Blcl9sdW47CiAKQEAgLTM3MzQsNyArMzczNCw3IEBACiAJICogY2hlY2sgaXMgdGhlIGFwcGxpY2F0aW9uIGNvbmZvcm1zIHRvIE5JVC4gV2UgZG8gbm90IGhhdmUgdG8gZG8gbXVjaAogCSAqIGluIHRoYXQgY2FzZS4KIAkgKiBXZSBleHBsb2l0IHRoZSBmYWN0IHRoYXQgdGhlIHNpZ25hdHVyZSBpcyBzdG9yZWQgaW4gdGhlIHZlcnkKLQkgKiBiZWdpbmluZyBvZiB0aGUgc3RydWN0dXJlLgorCSAqIGJlZ2lubmluZyBvZiB0aGUgc3RydWN0dXJlLgogCSAqLwogCiAJaWYoIGNvcHlfZnJvbV91c2VyKHNpZ25hdHVyZSwgYXJnLCA3KSApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbWVnYXJhaWQuaCBiL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC5oCmluZGV4IDg1MzQxMTkuLjlhNzg5N2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC5oCisrKyBiL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC5oCkBAIC01MzIsOSArNTMyLDkgQEAKIAogLyoKICAqIHN0cnVjdCBtY29udHJvbGxlciBpcyB1c2VkIHRvIHBhc3MgaW5mb3JtYXRpb24gYWJvdXQgdGhlIGNvbnRyb2xsZXJzIGluIHRoZQotICogc3lzdGVtLiBJdHMgdXB0byB0aGUgYXBwbGljYXRpb24gaG93IHRvIHVzZSB0aGUgaW5mb3JtYXRpb24uIFdlIGFyZSBwYXNzaW5nCisgKiBzeXN0ZW0uIEl0cyB1cCB0byB0aGUgYXBwbGljYXRpb24gaG93IHRvIHVzZSB0aGUgaW5mb3JtYXRpb24uIFdlIGFyZSBwYXNzaW5nCiAgKiBhcyBtdWNoIGluZm8gYWJvdXQgdGhlIGNhcmRzIGFzIHBvc3NpYmxlIGFuZCB1c2VmdWwuIEJlZm9yZSBpc3N1aW5nIHRoZQotICogY2FsbCB0byBmaW5kIGluZm9ybWF0aW9uIGFib3V0IHRoZSBjYXJkcywgdGhlIGFwcGxpY2FpdG9uIG5lZWRzIHRvIGlzc3VlIGEKKyAqIGNhbGwgdG8gZmluZCBpbmZvcm1hdGlvbiBhYm91dCB0aGUgY2FyZHMsIHRoZSBhcHBsaWNhdGlvbiBuZWVkcyB0byBpc3N1ZSBhCiAgKiBpb2N0bCBmaXJzdCB0byBmaW5kIG91dCB0aGUgbnVtYmVyIG9mIGNvbnRyb2xsZXJzIGluIHRoZSBzeXN0ZW0uCiAgKi8KICNkZWZpbmUgTUFYX0NPTlRST0xMRVJTIDMyCkBAIC04MDQsNyArODA0LDcgQEAKIAl1bnNpZ25lZCBsb25nCQliYXNlOwogCXZvaWQgX19pb21lbQkJKm1taW9fYmFzZTsKIAotCS8qIG1ib3g2NCB3aXRoIG1ib3ggbm90IGFsaWduZWQgb24gMTYtYnl0ZSBib3VuZHJ5ICovCisJLyogbWJveDY0IHdpdGggbWJveCBub3QgYWxpZ25lZCBvbiAxNi1ieXRlIGJvdW5kYXJ5ICovCiAJbWJveDY0X3QJKnVuYV9tYm94NjQ7CiAJZG1hX2FkZHJfdAl1bmFfbWJveDY0X2RtYTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21ib3hfZGVmcy5oIGIvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21ib3hfZGVmcy5oCmluZGV4IGNlMjQ4N2EuLmUwMWM2ZjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC9tYm94X2RlZnMuaAorKysgYi9kcml2ZXJzL3Njc2kvbWVnYXJhaWQvbWJveF9kZWZzLmgKQEAgLTY2MCw3ICs2NjAsNyBAQAogICogQGxwYXJhbQk6IGxvZ2ljYWwgZHJpdmVzIHBhcmFtZXRlcnMKICAqIEBzcGFuCTogc3BhbgogICoKLSAqIDgtTEQgbG9naWNhbCBkcml2ZSB3aXRoIHVwdG8gOCBzcGFucworICogOC1MRCBsb2dpY2FsIGRyaXZlIHdpdGggdXAgdG8gOCBzcGFucwogICovCiB0eXBlZGVmIHN0cnVjdCB7CiAJbG9nZHJ2X3BhcmFtX3QJbHBhcmFtOwpAQCAtNjczLDcgKzY3Myw3IEBACiAgKiBAbHBhcmFtCTogbG9naWNhbCBkcml2ZXMgcGFyYW1ldGVycwogICogQHNwYW4JOiBzcGFuCiAgKgotICogOC1MRCBsb2dpY2FsIGRyaXZlIHdpdGggdXB0byA0IHNwYW5zCisgKiA4LUxEIGxvZ2ljYWwgZHJpdmUgd2l0aCB1cCB0byA0IHNwYW5zCiAgKi8KIHR5cGVkZWYgc3RydWN0IHsKIAlsb2dkcnZfcGFyYW1fdAlscGFyYW07CkBAIC03MjAsNyArNzIwLDcgQEAKICAqIEBsZHJ2CTogbG9naWNhbCBkcml2ZXMgaW5mb3JtYXRpb24KICAqIEBwZHJ2CTogcGh5c2ljYWwgZHJpdmVzIGluZm9ybWF0aW9uCiAgKgotICogRGlzayBhcnJheSBmb3IgOExEIGxvZ2ljYWwgZHJpdmVzIHdpdGggdXB0byA4IHNwYW5zCisgKiBEaXNrIGFycmF5IGZvciA4TEQgbG9naWNhbCBkcml2ZXMgd2l0aCB1cCB0byA4IHNwYW5zCiAgKi8KIHR5cGVkZWYgc3RydWN0IHsKIAl1aW50OF90CQkJbnVtbGRydjsKQEAgLTczNyw3ICs3MzcsNyBAQAogICogQGxkcnYJOiBsb2dpY2FsIGRyaXZlcyBpbmZvcm1hdGlvbgogICogQHBkcnYJOiBwaHlzaWNhbCBkcml2ZXMgaW5mb3JtYXRpb24KICAqCi0gKiBEaXNrIGFycmF5IGZvciA4TEQgbG9naWNhbCBkcml2ZXMgd2l0aCB1cHRvIDQgc3BhbnMKKyAqIERpc2sgYXJyYXkgZm9yIDhMRCBsb2dpY2FsIGRyaXZlcyB3aXRoIHVwIHRvIDQgc3BhbnMKICAqLwogdHlwZWRlZiBzdHJ1Y3QgewogCXVpbnQ4X3QJCQludW1sZHJ2OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21lZ2FyYWlkX21ib3guYyBiL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC9tZWdhcmFpZF9tYm94LmMKaW5kZXggNTcwOGNiMi4uMWRiYTMyOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21lZ2FyYWlkX21ib3guYworKysgYi9kcml2ZXJzL3Njc2kvbWVnYXJhaWQvbWVnYXJhaWRfbWJveC5jCkBAIC0yNjg5LDcgKzI2ODksNyBAQAogCQkJCShNQk9YX1JFU0VUX1dBSVQgKyBNQk9YX1JFU0VUX0VYVF9XQUlUKSAtIGkpKTsKIAkJfQogCi0JCS8vIGJhaWxvdXQgaWYgbm8gcmVjb3ZlcnkgaGFwcGVuZGVkIGluIHJlc2V0IHRpbWUKKwkJLy8gYmFpbG91dCBpZiBubyByZWNvdmVyeSBoYXBwZW5lZCBpbiByZXNldCB0aW1lCiAJCWlmIChhZGFwdGVyLT5vdXRzdGFuZGluZ19jbWRzID09IDApIHsKIAkJCWJyZWFrOwogCQl9CkBAIC0zNDUyLDcgKzM0NTIsNyBAQAogICogbWVnYXJhaWRfbWJveF9zZXR1cF9kZXZpY2VfbWFwIC0gbWFuYWdlIGRldmljZSBpZHMKICAqIEBhZGFwdGVyCTogRHJpdmVyJ3Mgc29mdCBzdGF0ZQogICoKLSAqIE1hbmFuZ2UgdGhlIGRldmljZSBpZHMgdG8gaGF2ZSBhbiBhcHByb3ByYWl0ZSBtYXBwaW5nIGJldHdlZW4gdGhlIGtlcm5lbAorICogTWFuYW5nZSB0aGUgZGV2aWNlIGlkcyB0byBoYXZlIGFuIGFwcHJvcHJpYXRlIG1hcHBpbmcgYmV0d2VlbiB0aGUga2VybmVsCiAgKiBzY3NpIGFkZHJlc3NlcyBhbmQgbWVnYXJhaWQgc2NzaSBhbmQgbG9naWNhbCBkcml2ZSBhZGRyZXNzZXMuIFdlIGV4cG9ydAogICogc2NzaSBkZXZpY2VzIG9uIHRoZWlyIGFjdHVhbCBhZGRyZXNzZXMsIHdoZXJlYXMgdGhlIGxvZ2ljYWwgZHJpdmVzIGFyZQogICogZXhwb3J0ZWQgb24gYSB2aXJ0dWFsIHNjc2kgY2hhbm5lbC4KQEAgLTM5NzMsNyArMzk3Myw3IEBACiAgKiBOT1RFOiBUaGUgY29tbWFuZHMgaXNzdWFuY2UgZnVuY3Rpb25hbGl0eSBpcyBub3QgZ2VuZXJhbGl6ZWQgYW5kCiAgKiBpbXBsZW1lbnRlZCBpbiBjb250ZXh0IG9mICJnZXQgbGQgbWFwIiBjb21tYW5kIG9ubHkuIElmIHJlcXVpcmVkLCB0aGUKICAqIGNvbW1hbmQgaXNzdWFuY2UgbG9naWNhbCBjYW4gYmUgdHJpdmlhbGx5IHB1bGxlZCBvdXQgYW5kIGltcGxlbWVudGVkIGFzIGEKLSAqIHN0YW5kYWxvbmUgbGliYXJ5LiBGb3Igbm93LCB0aGlzIHNob3VsZCBzdWZmaWNlIHNpbmNlIHRoZXJlIGlzIG5vIG90aGVyCisgKiBzdGFuZGFsb25lIGxpYnJhcnkuIEZvciBub3csIHRoaXMgc2hvdWxkIHN1ZmZpY2Ugc2luY2UgdGhlcmUgaXMgbm8gb3RoZXIKICAqIHVzZXIgb2YgdGhpcyBpbnRlcmZhY2UuCiAgKgogICogUmV0dXJuIDAgb24gc3VjY2Vzcy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC9tZWdhcmFpZF9zYXMuaCBiL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC9tZWdhcmFpZF9zYXMuaAppbmRleCA2MzViMjI4Li4wNDZkY2M2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbWVnYXJhaWQvbWVnYXJhaWRfc2FzLmgKKysrIGIvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21lZ2FyYWlkX3Nhcy5oCkBAIC0xMzQ3LDcgKzEzNDcsNyBAQAogCXN0cnVjdCB0aW1lcl9saXN0IGlvX2NvbXBsZXRpb25fdGltZXI7CiAJc3RydWN0IGxpc3RfaGVhZCBpbnRlcm5hbF9yZXNldF9wZW5kaW5nX3E7CiAKLQkvKiBQdHIgdG8gaGJhIHNwZWNmaWMgaW5mb3JtYXRpb24gKi8KKwkvKiBQdHIgdG8gaGJhIHNwZWNpZmljIGluZm9ybWF0aW9uICovCiAJdm9pZCAqY3RybF9jb250ZXh0OwogCXU4CW1zaV9mbGFnOwogCXN0cnVjdCBtc2l4X2VudHJ5IG1zaXhlbnRyeTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tZWdhcmFpZC9tZWdhcmFpZF9zYXNfYmFzZS5jIGIvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21lZ2FyYWlkX3Nhc19iYXNlLmMKaW5kZXggYmJkMTBjOC4uNjZkNGNlYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21lZ2FyYWlkX3Nhc19iYXNlLmMKKysrIGIvZHJpdmVycy9zY3NpL21lZ2FyYWlkL21lZ2FyYWlkX3Nhc19iYXNlLmMKQEAgLTE2OTgsNyArMTY5OCw3IEBACiAgKiBtZWdhc2FzX3dhaXRfZm9yX291dHN0YW5kaW5nIC0JV2FpdCBmb3IgYWxsIG91dHN0YW5kaW5nIGNtZHMKICAqIEBpbnN0YW5jZToJCQkJQWRhcHRlciBzb2Z0IHN0YXRlCiAgKgotICogVGhpcyBmdW5jdGlvbiB3YWl0cyBmb3IgdXB0byBNRUdBU0FTX1JFU0VUX1dBSVRfVElNRSBzZWNvbmRzIGZvciBGVyB0bworICogVGhpcyBmdW5jdGlvbiB3YWl0cyBmb3IgdXAgdG8gTUVHQVNBU19SRVNFVF9XQUlUX1RJTUUgc2Vjb25kcyBmb3IgRlcgdG8KICAqIGNvbXBsZXRlIGFsbCBpdHMgb3V0c3RhbmRpbmcgY29tbWFuZHMuIFJldHVybnMgZXJyb3IgaWYgb25lIG9yIG1vcmUgSU9zCiAgKiBhcmUgcGVuZGluZyBhZnRlciB0aGlzIHRpbWUgcGVyaW9kLiBJdCBhbHNvIG1hcmtzIHRoZSBjb250cm9sbGVyIGRlYWQuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2luaXQuaCBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2luaXQuaAppbmRleCAyMGU2Yjg4Li4xNjU0NTRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMl9pbml0LmgKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfaW5pdC5oCkBAIC0yMSw3ICsyMSw3IEBACiAgKiAgMDUtMjEtMDggIDAyLjAwLjA1ICBGaXhlZCB0eXBvIGluIG5hbWUgb2YgTXBpMlNlcFJlcXVlc3RfdC4KICAqICAxMC0wMi0wOCAgMDIuMDAuMDYgIFJlbW92ZWQgVW50YWdnZWQgYW5kIE5vIERpc2Nvbm5lY3QgdmFsdWVzIGZyb20gU0NTSSBJTwogICogICAgICAgICAgICAgICAgICAgICAgQ29udHJvbCBmaWVsZCBUYXNrIEF0dHJpYnV0ZSBmbGFncy4KLSAqICAgICAgICAgICAgICAgICAgICAgIE1vdmVkIExVTiBmaWVsZCBkZWZpbmVzIHRvIG1waTIuaCBiZWNhc3VlIHRoZXkgYXJlCisgKiAgICAgICAgICAgICAgICAgICAgICBNb3ZlZCBMVU4gZmllbGQgZGVmaW5lcyB0byBtcGkyLmggYmVjYXVzZSB0aGV5IGFyZQogICogICAgICAgICAgICAgICAgICAgICAgY29tbW9uIHRvIG1hbnkgc3RydWN0dXJlcy4KICAqICAwNS0wNi0wOSAgMDIuMDAuMDcgIENoYW5nZWQgdGFzayBtYW5hZ2VtZW50IHR5cGUgb2YgUXVlcnkgVW5pdCBBdHRlbnRpb24gdG8KICAqICAgICAgICAgICAgICAgICAgICAgIFF1ZXJ5IEFzeW5jaHJvbm91cyBFdmVudC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfYmFzZS5jIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMKaW5kZXggNWUwMDFmZi4uMzM0NjM1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMKQEAgLTkyNSw3ICs5MjUsNyBAQAogfQogCiAvKioKLSAqIG1wdDJzYXNfYmFzZV9yZWxlYXNlX2NhbGxiYWNrX2hhbmRsZXIgLSBjbGVhciBpbnRlcnVwdCBjYWxsYmFjayBoYW5kbGVyCisgKiBtcHQyc2FzX2Jhc2VfcmVsZWFzZV9jYWxsYmFja19oYW5kbGVyIC0gY2xlYXIgaW50ZXJydXB0IGNhbGxiYWNrIGhhbmRsZXIKICAqIEBjYl9pZHg6IGNhbGxiYWNrIGluZGV4CiAgKgogICogUmV0dXJuIG5vdGhpbmcuCkBAIC0xMTEzLDcgKzExMTMsNyBAQAogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CiAgKgogICogQ2hlY2sgdG8gc2VlIGlmIGNhcmQgaXMgY2FwYWJsZSBvZiBNU0lYLCBhbmQgc2V0IG51bWJlcgotICogb2YgYXZhbGlhYmxlIG1zaXggdmVjdG9ycworICogb2YgYXZhaWxhYmxlIG1zaXggdmVjdG9ycwogICovCiBzdGF0aWMgaW50CiBfYmFzZV9jaGVja19lbmFibGVfbXNpeChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MpCkBAIC0xNTk1LDcgKzE1OTUsNyBAQAogCiAKIC8qKgotICogbXB0MnNhc19iYXNlX3B1dF9zbWlkX2hpX3ByaW9yaXR5IC0gc2VuZCBUYXNrIE1hbmFnbWVudCByZXF1ZXN0IHRvIGZpcm13YXJlCisgKiBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfaGlfcHJpb3JpdHkgLSBzZW5kIFRhc2sgTWFuYWdlbWVudCByZXF1ZXN0IHRvIGZpcm13YXJlCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4CiAgKgpAQCAtMjU5OSw3ICsyNTk5LDcgQEAKIAkJaW50X3N0YXR1cyA9IHJlYWRsKCZpb2MtPmNoaXAtPkhvc3RJbnRlcnJ1cHRTdGF0dXMpOwogCQlpZiAoaW50X3N0YXR1cyAmIE1QSTJfSElTX0lPQzJTWVNfREJfU1RBVFVTKSB7CiAJCQlkaHNwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAiJXM6ICIKLQkJCSAgICAic3VjY2Vzc2Z1bGwgY291bnQoJWQpLCB0aW1lb3V0KCVkKVxuIiwgaW9jLT5uYW1lLAorCQkJICAgICJzdWNjZXNzZnVsIGNvdW50KCVkKSwgdGltZW91dCglZClcbiIsIGlvYy0+bmFtZSwKIAkJCSAgICBfX2Z1bmNfXywgY291bnQsIHRpbWVvdXQpKTsKIAkJCXJldHVybiAwOwogCQl9CkBAIC0yNjQwLDcgKzI2NDAsNyBAQAogCQlpbnRfc3RhdHVzID0gcmVhZGwoJmlvYy0+Y2hpcC0+SG9zdEludGVycnVwdFN0YXR1cyk7CiAJCWlmICghKGludF9zdGF0dXMgJiBNUEkyX0hJU19TWVMySU9DX0RCX1NUQVRVUykpIHsKIAkJCWRoc3ByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICIlczogIgotCQkJICAgICJzdWNjZXNzZnVsbCBjb3VudCglZCksIHRpbWVvdXQoJWQpXG4iLCBpb2MtPm5hbWUsCisJCQkgICAgInN1Y2Nlc3NmdWwgY291bnQoJWQpLCB0aW1lb3V0KCVkKVxuIiwgaW9jLT5uYW1lLAogCQkJICAgIF9fZnVuY19fLCBjb3VudCwgdGltZW91dCkpOwogCQkJcmV0dXJuIDA7CiAJCX0gZWxzZSBpZiAoaW50X3N0YXR1cyAmIE1QSTJfSElTX0lPQzJTWVNfREJfU1RBVFVTKSB7CkBAIC0yNjg4LDcgKzI2ODgsNyBAQAogCQlkb29yYmVsbF9yZWcgPSByZWFkbCgmaW9jLT5jaGlwLT5Eb29yYmVsbCk7CiAJCWlmICghKGRvb3JiZWxsX3JlZyAmIE1QSTJfRE9PUkJFTExfVVNFRCkpIHsKIAkJCWRoc3ByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICIlczogIgotCQkJICAgICJzdWNjZXNzZnVsbCBjb3VudCglZCksIHRpbWVvdXQoJWQpXG4iLCBpb2MtPm5hbWUsCisJCQkgICAgInN1Y2Nlc3NmdWwgY291bnQoJWQpLCB0aW1lb3V0KCVkKVxuIiwgaW9jLT5uYW1lLAogCQkJICAgIF9fZnVuY19fLCBjb3VudCwgdGltZW91dCkpOwogCQkJcmV0dXJuIDA7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY29uZmlnLmMgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2NvbmZpZy5jCmluZGV4IDZhZmQ2N2IuLjY4NjEyNDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY29uZmlnLmMKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19jb25maWcuYwpAQCAtOTMsNyArOTMsNyBAQAogICogQG1waV9yZXBseTogcmVwbHkgbWVzc2FnZSBmcmFtZQogICogQ29udGV4dDogbm9uZS4KICAqCi0gKiBGdW5jdGlvbiBmb3IgZGlzcGxheWluZyBkZWJ1ZyBpbmZvIGhlbHBmdWxsIHdoZW4gZGVidWdnaW5nIGlzc3VlcworICogRnVuY3Rpb24gZm9yIGRpc3BsYXlpbmcgZGVidWcgaW5mbyBoZWxwZnVsIHdoZW4gZGVidWdnaW5nIGlzc3VlcwogICogaW4gdGhpcyBtb2R1bGUuCiAgKi8KIHN0YXRpYyB2b2lkCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2N0bC5jIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19jdGwuYwppbmRleCBlOTJiNzdhLi4xYzZkMmI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2N0bC5jCisrKyBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY3RsLmMKQEAgLTExNiw3ICsxMTYsNyBAQAogICogQG1waV9yZXBseTogcmVwbHkgbWVzc2FnZSBmcmFtZQogICogQ29udGV4dDogbm9uZS4KICAqCi0gKiBGdW5jdGlvbiBmb3IgZGlzcGxheWluZyBkZWJ1ZyBpbmZvIGhlbHBmdWxsIHdoZW4gZGVidWdnaW5nIGlzc3VlcworICogRnVuY3Rpb24gZm9yIGRpc3BsYXlpbmcgZGVidWcgaW5mbyBoZWxwZnVsIHdoZW4gZGVidWdnaW5nIGlzc3VlcwogICogaW4gdGhpcyBtb2R1bGUuCiAgKi8KIHN0YXRpYyB2b2lkCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX3Njc2loLmMgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX3Njc2loLmMKaW5kZXggNmNlYjc3NS4uZDIwNjRhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19zY3NpaC5jCisrKyBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfc2NzaWguYwpAQCAtMzk3LDcgKzM5Nyw3IEBACiAgKiBAaXNfcmFpZDogW2ZsYWddIDEgPSByYWlkIG9iamVjdCwgMCA9IHNhcyBvYmplY3QKICAqCiAgKiBEZXRlcm1pbmVzIHdoZXRoZXIgdGhpcyBkZXZpY2Ugc2hvdWxkIGJlIGZpcnN0IHJlcG9ydGVkIGRldmljZSB0bwotICogdG8gc2NzaS1tbCBvciBzYXMgdHJhbnNwb3J0LCB0aGlzIHB1cnBvc2UgaXMgZm9yIHBlcnNpc3RhbnQgYm9vdCBkZXZpY2UuCisgKiB0byBzY3NpLW1sIG9yIHNhcyB0cmFuc3BvcnQsIHRoaXMgcHVycG9zZSBpcyBmb3IgcGVyc2lzdGVudCBib290IGRldmljZS4KICAqIFRoZXJlIGFyZSBwcmltYXJ5LCBhbHRlcm5hdGUsIGFuZCBjdXJyZW50IGVudHJpZXMgaW4gYmlvcyBwYWdlIDIuIFRoZSBvcmRlcgogICogcHJpb3JpdHkgaXMgcHJpbWFyeSwgYWx0ZXJuYXRlLCB0aGVuIGN1cnJlbnQuICBUaGlzIHJvdXRpbmUgc2F2ZXMKICAqIHRoZSBjb3JyZXNwb25kaW5nIGRldmljZSBvYmplY3QgYW5kIGlzX3JhaWQgZmxhZyBpbiB0aGUgaW9jIG9iamVjdC4KQEAgLTI2NzEsMTAgKzI2NzEsMTAgQEAKICAqIEBoYW5kbGU6IGRldmljZSBoYW5kbGUKICAqIENvbnRleHQ6IGludGVycnVwdCB0aW1lLgogICoKLSAqIFRoaXMgY29kZSBpcyB0byBpbml0aWF0ZSB0aGUgZGV2aWNlIHJlbW92YWwgaGFuZHNoYWtlIHByb3RvY2FsCisgKiBUaGlzIGNvZGUgaXMgdG8gaW5pdGlhdGUgdGhlIGRldmljZSByZW1vdmFsIGhhbmRzaGFrZSBwcm90b2NvbAogICogd2l0aCBjb250cm9sbGVyIGZpcm13YXJlLiAgVGhpcyBmdW5jdGlvbiB3aWxsIGlzc3VlIHRhcmdldCByZXNldAogICogdXNpbmcgaGlnaCBwcmlvcml0eSByZXF1ZXN0IHF1ZXVlLiAgSXQgd2lsbCBzZW5kIGEgc2FzIGlvdW5pdAotICogY29udHJvbGwgcmVxdWVzdCAoTVBJMl9TQVNfT1BfUkVNT1ZFX0RFVklDRSkgZnJvbSB0aGlzIGNvbXBsZXRpb24uCisgKiBjb250cm9sIHJlcXVlc3QgKE1QSTJfU0FTX09QX1JFTU9WRV9ERVZJQ0UpIGZyb20gdGhpcyBjb21wbGV0aW9uLgogICoKICAqIFRoaXMgaXMgZGVzaWduZWQgdG8gc2VuZCBtdWxpcGxlIHRhc2sgbWFuYWdlbWVudCByZXF1ZXN0IGF0IHRoZSBzYW1lCiAgKiB0aW1lIHRvIHRoZSBmaWZvLiBJZiB0aGUgZmlmbyBpcyBmdWxsLCB3ZSB3aWxsIGFwcGVuZCB0aGUgcmVxdWVzdCwKQEAgLTI3NDksOSArMjc0OSw5IEBACiAgKiBAcmVwbHk6IHJlcGx5IG1lc3NhZ2UgZnJhbWUobG93ZXIgMzJiaXQgYWRkcikKICAqIENvbnRleHQ6IGludGVycnVwdCB0aW1lLgogICoKLSAqIFRoaXMgaXMgdGhlIHNhcyBpb3VuaXQgY29udHJvbGwgY29tcGxldGlvbiByb3V0aW5lLgorICogVGhpcyBpcyB0aGUgc2FzIGlvdW5pdCBjb250cm9sIGNvbXBsZXRpb24gcm91dGluZS4KICAqIFRoaXMgY29kZSBpcyBwYXJ0IG9mIHRoZSBjb2RlIHRvIGluaXRpYXRlIHRoZSBkZXZpY2UgcmVtb3ZhbAotICogaGFuZHNoYWtlIHByb3RvY2FsIHdpdGggY29udHJvbGxlciBmaXJtd2FyZS4KKyAqIGhhbmRzaGFrZSBwcm90b2NvbCB3aXRoIGNvbnRyb2xsZXIgZmlybXdhcmUuCiAgKgogICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKICAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCkBAIC0yODc4LDggKzI4NzgsOCBAQAogICoKICAqIFRoaXMgaXMgdGhlIHRhcmdldCByZXNldCBjb21wbGV0aW9uIHJvdXRpbmUuCiAgKiBUaGlzIGNvZGUgaXMgcGFydCBvZiB0aGUgY29kZSB0byBpbml0aWF0ZSB0aGUgZGV2aWNlIHJlbW92YWwKLSAqIGhhbmRzaGFrZSBwcm90b2NhbCB3aXRoIGNvbnRyb2xsZXIgZmlybXdhcmUuCi0gKiBJdCB3aWxsIHNlbmQgYSBzYXMgaW91bml0IGNvbnRyb2xsIHJlcXVlc3QgKE1QSTJfU0FTX09QX1JFTU9WRV9ERVZJQ0UpCisgKiBoYW5kc2hha2UgcHJvdG9jb2wgd2l0aCBjb250cm9sbGVyIGZpcm13YXJlLgorICogSXQgd2lsbCBzZW5kIGEgc2FzIGlvdW5pdCBjb250cm9sIHJlcXVlc3QgKE1QSTJfU0FTX09QX1JFTU9WRV9ERVZJQ0UpCiAgKgogICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKICAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCkBAIC0yOTg0LDcgKzI5ODQsNyBAQAogICoKICAqIFRoaXMgcm91dGluZSBhZGRlZCB0byBiZXR0ZXIgaGFuZGxlIGNhYmxlIGJyZWFrZXIuCiAgKgotICogVGhpcyBoYW5kbGVzIHRoZSBjYXNlIHdoZXJlIGRyaXZlciByZWNpZXZlcyBtdWx0aXBsZSBleHBhbmRlcgorICogVGhpcyBoYW5kbGVzIHRoZSBjYXNlIHdoZXJlIGRyaXZlciByZWNlaXZlcyBtdWx0aXBsZSBleHBhbmRlcgogICogYWRkIGFuZCBkZWxldGUgZXZlbnRzIGluIGEgc2luZ2xlIHNob3QuICBXaGVuIHRoZXJlIGlzIGEgZGVsZXRlIGV2ZW50CiAgKiB0aGUgcm91dGluZSB3aWxsIHZvaWQgYW55IHBlbmRpbmcgYWRkIGV2ZW50cyB3YWl0aW5nIGluIHRoZSBldmVudCBxdWV1ZS4KICAqCkBAIC0zNTExLDcgKzM1MTEsNyBAQAogCiAjaWZkZWYgQ09ORklHX1NDU0lfTVBUMlNBU19MT0dHSU5HCiAvKioKLSAqIF9zY3NpaF9zY3NpX2lvY19pbmZvIC0gdHJhbnNsYXRlZCBub24tc3VjY2Vzc2Z1bGwgU0NTSV9JTyByZXF1ZXN0CisgKiBfc2NzaWhfc2NzaV9pb2NfaW5mbyAtIHRyYW5zbGF0ZWQgbm9uLXN1Y2Nlc3NmdWwgU0NTSV9JTyByZXF1ZXN0CiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzY21kOiBwb2ludGVyIHRvIHNjc2kgY29tbWFuZCBvYmplY3QKICAqIEBtcGlfcmVwbHk6IHJlcGx5IG1mIHBheWxvYWQgcmV0dXJuZWQgZnJvbSBmaXJtd2FyZQpAQCAtNTEzOCw3ICs1MTM4LDcgQEAKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByOwogCi0JZGV3dHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJicm9hZGNhc3QgcHJpbWF0aXZlOiAiCisJZGV3dHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJicm9hZGNhc3QgcHJpbWl0aXZlOiAiCiAJICAgICJwaHkgbnVtYmVyKCVkKSwgd2lkdGgoJWQpXG4iLCBpb2MtPm5hbWUsIGV2ZW50X2RhdGEtPlBoeU51bSwKIAkgICAgZXZlbnRfZGF0YS0+UG9ydFdpZHRoKSk7CiAJZHRtcHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgIiVzOiBlbnRlclxuIiwgaW9jLT5uYW1lLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL25jcjUzYzh4eC5jIGIvZHJpdmVycy9zY3NpL25jcjUzYzh4eC5jCmluZGV4IDQ2Y2MzODIuLjgzNWQ4ZDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9uY3I1M2M4eHguYworKysgYi9kcml2ZXJzL3Njc2kvbmNyNTNjOHh4LmMKQEAgLTI2NzksNyArMjY3OSw3IEBACiB9LyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPCBSRVNFTF9UQUcgPi0tLS0tLS0tLS0tLS0tLS0tLS0qLyx7CiAJLyoKIAkqKglSZWFkIElERU5USUZZICsgU0lNUExFICsgVEFHIHVzaW5nIGEgc2luZ2xlIE1PVkUuCi0JKioJQWdyZXNzaXZlIG9wdGltaXphdGlvbiwgaXMnbnQgaXQ/CisJKioJQWdncmVzc2l2ZSBvcHRpbWl6YXRpb24sIGlzJ250IGl0PwogCSoqCU5vIG5lZWQgdG8gdGVzdCB0aGUgU0lNUExFIFRBRyBtZXNzYWdlLCBzaW5jZSB0aGUgCiAJKioJZHJpdmVyIG9ubHkgc3VwcG9ydHMgY29uZm9ybWFudCBkZXZpY2VzIGZvciB0YWdzLiA7LSkKIAkqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL25zcDMyLmMgYi9kcml2ZXJzL3Njc2kvbnNwMzIuYwppbmRleCA2YjhiMDIxLi5mNmE1MGM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbnNwMzIuYworKysgYi9kcml2ZXJzL3Njc2kvbnNwMzIuYwpAQCAtMTI4OCw3ICsxMjg4LDcgQEAKIAkJCW5zcDMyX2RiZyhOU1AzMl9ERUJVR19JTlRSLCAiU1NBQ0s9MHglbHgiLCAKIAkJCQkgICAgbnNwMzJfcmVhZDQoYmFzZSwgU0FWRURfU0FDS19DTlQpKTsKIAotCQkJc2NzaV9zZXRfcmVzaWQoU0NwbnQsIDApOyAvKiBhbGwgZGF0YSB0cmFuc2ZlcmVkISAqLworCQkJc2NzaV9zZXRfcmVzaWQoU0NwbnQsIDApOyAvKiBhbGwgZGF0YSB0cmFuc2ZlcnJlZCEgKi8KIAkJfQogCiAJCS8qCkBAIC0xNjMwLDcgKzE2MzAsNyBAQAogCiAJCQkvKgogCQkJICogSWYgU0FWRURTQUNLQ05UID09IDAsIGl0IG1lYW5zIFNhdmVkRGF0YVBvaW50ZXIgaXMKLQkJCSAqIGNvbWUgYWZ0ZXIgZGF0YSB0cmFuc2ZlcmluZy4KKwkJCSAqIGNvbWUgYWZ0ZXIgZGF0YSB0cmFuc2ZlcnJpbmcuCiAJCQkgKi8KIAkJCWlmIChzX3NhY2tsZW4gPiAwKSB7CiAJCQkJLyoKQEAgLTE3ODUsNyArMTc4NSw3IEBACiAJCSAgIHRoZSBoZWFkIGVsZW1lbnQgb2YgdGhlIHNnLiByZXN0bGVuIGlzIGNvcnJlY3RseSBjYWxjdWxhdGVkLiAqLwogCX0KIAotCS8qIGNhbGN1bGF0ZSB0aGUgcmVzdCBsZW5ndGggZm9yIHRyYW5zZmVyaW5nICovCisJLyogY2FsY3VsYXRlIHRoZSByZXN0IGxlbmd0aCBmb3IgdHJhbnNmZXJyaW5nICovCiAJcmVzdGxlbiA9IHNlbnRsZW4gLSBzX3NhY2tsZW47CiAKIAkvKiB1cGRhdGUgYWRqdXN0aW5nIGN1cnJlbnQgU0cgdGFibGUgZW50cnkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9uc3AzMi5oIGIvZHJpdmVycy9zY3NpL25zcDMyLmgKaW5kZXggOTU2NWFjZi4uYzAyMjE4MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL25zcDMyLmgKKysrIGIvZHJpdmVycy9zY3NpL25zcDMyLmgKQEAgLTUwNyw3ICs1MDcsNyBAQAogLyoKICAqIFNDU0kgVEFSR0VUL0xVTiBkZWZpbml0aW9uCiAgKi8KLSNkZWZpbmUgTlNQMzJfSE9TVF9TQ1NJSUQgICAgNyAgLyogU0NTSSBpbml0aWF0b3IgaXMgZXZlcnl0aW1lIGRlZmluZWQgYXMgNyAqLworI2RlZmluZSBOU1AzMl9IT1NUX1NDU0lJRCAgICA3ICAvKiBTQ1NJIGluaXRpYXRvciBpcyBldmVyeSB0aW1lIGRlZmluZWQgYXMgNyAqLwogI2RlZmluZSBNQVhfVEFSR0VUCSAgICAgOAogI2RlZmluZSBNQVhfTFVOCQkgICAgIDgJLyogWFhYOiBJbiBTUEkzLCBtYXggbnVtYmVyIG9mIExVTiBpcyA2NC4gKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL29zc3QuYyBiL2RyaXZlcnMvc2NzaS9vc3N0LmMKaW5kZXggNTIxZTIxOC4uNThmNWJlNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL29zc3QuYworKysgYi9kcml2ZXJzL3Njc2kvb3NzdC5jCkBAIC0xMzY2LDcgKzEzNjYsNyBAQAogLyogVGhlIHZhbHVlcyBiZWxvdyBhcmUgYmFzZWQgb24gdGhlIE9uU3RyZWFtIGZyYW1lIHBheWxvYWQgc2l6ZSBvZiAzMksgPT0gMioqMTUsCiAgKiB0aGF0IGlzLCBPU1NUX0ZSQU1FX1NISUZUICsgT1NTVF9TRUNUT1JfU0hJRlQgbXVzdCBiZSAxNS4gV2l0aCBhIG1pbmltdW0gYmxvY2sKICAqIHNpemUgb2YgNTEyIGJ5dGVzLCB3ZSBuZWVkIHRvIGJlIGFibGUgdG8gcmVzb2x2ZSAzMksvNTEyID09IDY0ID09IDIqKjYgcG9zaXRpb25zCi0gKiBpbnNpZGUgZWFjaCBmcmFtZS4gRmluYWx5LCBPU1NUX1NFQ1RPUl9NQVNLID09IDIqKk9TU1RfRlJBTUVfU0hJRlQgLSAxLgorICogaW5zaWRlIGVhY2ggZnJhbWUuIEZpbmFsbHksIE9TU1RfU0VDVE9SX01BU0sgPT0gMioqT1NTVF9GUkFNRV9TSElGVCAtIDEuCiAgKi8KICNkZWZpbmUgT1NTVF9GUkFNRV9TSElGVCAgNgogI2RlZmluZSBPU1NUX1NFQ1RPUl9TSElGVCA5CkBAIC0zMTMxLDcgKzMxMzEsNyBAQAogCQl9CiAjaWYgREVCVUcKIAkJaWYgKGRlYnVnZ2luZykKLQkJCXByaW50ayhPU1NUX0RFQl9NU0cgIiVzOkQ6IEZsdXNoaW5nICVkIGJ5dGVzLCBUcmFuc2ZlcmluZyAlZCBieXRlcyBpbiAlZCBsYmxvY2tzLlxuIiwKKwkJCXByaW50ayhPU1NUX0RFQl9NU0cgIiVzOkQ6IEZsdXNoaW5nICVkIGJ5dGVzLCBUcmFuc2ZlcnJpbmcgJWQgYnl0ZXMgaW4gJWQgbGJsb2Nrcy5cbiIsCiAJCQkgIAkJCSBuYW1lLCBvZmZzZXQsIHRyYW5zZmVyLCBibGtzKTsKICNlbmRpZgogCkBAIC0zODExLDcgKzM4MTEsNyBAQAogCiAJCQlpZiAodHJhbnNmZXIgPT0gMCkgewogCQkJCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJCQkgICIlczpXOiBOb3RoaW5nIGNhbiBiZSB0cmFuc2ZlcmVkLCByZXF1ZXN0ZWQgJVpkLCB0YXBlIGJsb2NrIHNpemUgKCVkJWMpLlxuIiwKKwkJCQkgICIlczpXOiBOb3RoaW5nIGNhbiBiZSB0cmFuc2ZlcnJlZCwgcmVxdWVzdGVkICVaZCwgdGFwZSBibG9jayBzaXplICglZCVjKS5cbiIsCiAJCQkgICAJCW5hbWUsIGNvdW50LCBTVHAtPmJsb2NrX3NpemUgPCAxMDI0PwogCQkJCQlTVHAtPmJsb2NrX3NpemU6U1RwLT5ibG9ja19zaXplLzEwMjQsCiAJCQkJICAgICAgIAlTVHAtPmJsb2NrX3NpemU8MTAyND8nYic6J2snKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9vc3N0LmggYi9kcml2ZXJzL3Njc2kvb3NzdC5oCmluZGV4IDExZDI2YzUuLmI0ZmVhOTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9vc3N0LmgKKysrIGIvZHJpdmVycy9zY3NpL29zc3QuaApAQCAtNDEzLDcgKzQxMyw3IEBACiAgKiBBVVgKICAqLwogdHlwZWRlZiBzdHJ1Y3Qgb3NfYXV4X3MgewotICAgICAgICBfX2JlMzIgICAgICAgICAgZm9ybWF0X2lkOyAgICAgICAgICAgICAgLyogaGFyZHdhcmUgY29tcGFiaWxpdHkgQVVYIGlzIGJhc2VkIG9uICovCisgICAgICAgIF9fYmUzMiAgICAgICAgICBmb3JtYXRfaWQ7ICAgICAgICAgICAgICAvKiBoYXJkd2FyZSBjb21wYXRpYmlsaXR5IEFVWCBpcyBiYXNlZCBvbiAqLwogICAgICAgICBjaGFyICAgICAgICAgICAgYXBwbGljYXRpb25fc2lnWzRdOyAgICAgLyogZHJpdmVyIHVzZWQgdG8gd3JpdGUgdGhpcyBtZWRpYSAqLwogICAgICAgICBfX2JlMzIgICAgICAgICAgaGR3cjsgICAgICAgICAgICAgICAgICAgLyogcmVzZXJ2ZWQgKi8KICAgICAgICAgX19iZTMyICAgICAgICAgIHVwZGF0ZV9mcmFtZV9jbnRyOyAgICAgIC8qIGZvciBjb25maWd1cmF0aW9uIGZyYW1lICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvcGNtY2lhL25zcF9jcy5jIGIvZHJpdmVycy9zY3NpL3BjbWNpYS9uc3BfY3MuYwppbmRleCBiZTNmMzNkLi41NGJkZjZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcGNtY2lhL25zcF9jcy5jCisrKyBiL2RyaXZlcnMvc2NzaS9wY21jaWEvbnNwX2NzLmMKQEAgLTc0Miw3ICs3NDIsNyBAQAogCiAJCXJlcyA9IG5zcF9maWZvX2NvdW50KFNDcG50KSAtIG9jb3VudDsKIAkJLy9uc3BfZGJnKE5TUF9ERUJVR19EQVRBX0lPLCAicHRyPTB4JXAgdGhpcz0weCV4IG9jb3VudD0weCV4IHJlcz0weCV4IiwgU0NwbnQtPlNDcC5wdHIsIFNDcG50LT5TQ3AudGhpc19yZXNpZHVhbCwgb2NvdW50LCByZXMpOwotCQlpZiAocmVzID09IDApIHsgLyogaWYgc29tZSBkYXRhIGF2aWxhYmxlID8gKi8KKwkJaWYgKHJlcyA9PSAwKSB7IC8qIGlmIHNvbWUgZGF0YSBhdmFpbGFibGUgPyAqLwogCQkJaWYgKHN0YXQgPT0gQlVTUEhBU0VfREFUQV9JTikgeyAvKiBwaGFzZSBjaGFuZ2VkPyAqLwogCQkJCS8vbnNwX2RiZyhOU1BfREVCVUdfREFUQV9JTywgIiB3YWl0IGZvciBkYXRhIHRoaXM9JWQiLCBTQ3BudC0+U0NwLnRoaXNfcmVzaWR1YWwpOwogCQkJCWNvbnRpbnVlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3BtODAwMS9wbTgwMDFfaHdpLmMgYi9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9od2kuYwppbmRleCAxOGI2YzU1Li44YjdkYjFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9od2kuYworKysgYi9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9od2kuYwpAQCAtMzM5LDcgKzMzOSw3IEBACiAKIC8qKgogICogYmFyNF9zaGlmdCAtIGZ1bmN0aW9uIGlzIGNhbGxlZCB0byBzaGlmdCBCQVIgYmFzZSBhZGRyZXNzCi0gKiBAcG04MDAxX2hhIDogb3VyIGhiYSBjYXJkIGluZm9tYXRpb24KKyAqIEBwbTgwMDFfaGEgOiBvdXIgaGJhIGNhcmQgaW5mb3JtYXRpb24KICAqIEBzaGlmdFZhbHVlIDogc2hpZnRpbmcgdmFsdWUgaW4gbWVtb3J5IGJhci4KICAqLwogc3RhdGljIGludCBiYXI0X3NoaWZ0KHN0cnVjdCBwbTgwMDFfaGJhX2luZm8gKnBtODAwMV9oYSwgdTMyIHNoaWZ0VmFsdWUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9od2kuaCBiL2RyaXZlcnMvc2NzaS9wbTgwMDEvcG04MDAxX2h3aS5oCmluZGV4IDgzM2E1MjAuLjkwOTEzMjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9wbTgwMDEvcG04MDAxX2h3aS5oCisrKyBiL2RyaXZlcnMvc2NzaS9wbTgwMDEvcG04MDAxX2h3aS5oCkBAIC0yMDksNyArMjA5LDcgQEAKIAogLyoKICAqIGJyaWVmIHRoZSBkYXRhIHN0cnVjdHVyZSBvZiBTQVRBIENvbXBsZXRpb24gUmVzcG9uc2UKLSAqIHVzZSB0byBkaXNjcmliZSB0aGUgc2F0YSB0YXNrIHJlc3BvbnNlICg2NCBieXRlcykKKyAqIHVzZSB0byBkZXNjcmliZSB0aGUgc2F0YSB0YXNrIHJlc3BvbnNlICg2NCBieXRlcykKICAqLwogc3RydWN0IHNhdGFfY29tcGxldGlvbl9yZXNwIHsKIAlfX2xlMzIJdGFnOwpAQCAtOTUxLDcgKzk1MSw3IEBACiAjZGVmaW5lIFBDSUVfRVZFTlRfSU5URVJSVVBUCQkweDAwMzA0NAogI2RlZmluZSBQQ0lFX0VSUk9SX0lOVEVSUlVQVF9FTkFCTEUJMHgwMDMwNDgKICNkZWZpbmUgUENJRV9FUlJPUl9JTlRFUlJVUFQJCTB4MDAzMDRDCi0vKiBzaWduYXR1cmUgZGVmaW50aW9uIGZvciBob3N0IHNjcmF0Y2ggcGFkMCByZWdpc3RlciAqLworLyogc2lnbmF0dXJlIGRlZmluaXRpb24gZm9yIGhvc3Qgc2NyYXRjaCBwYWQwIHJlZ2lzdGVyICovCiAjZGVmaW5lIFNQQ19TT0ZUX1JFU0VUX1NJR05BVFVSRQkweDI1MmFjYmNkCiAvKiBTaWduYXR1cmUgZm9yIFNvZnQgUmVzZXQgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3BtODAwMS9wbTgwMDFfc2FzLmggYi9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9zYXMuaAppbmRleCBiZGI2YjI3Li5hYTA1ZTY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9zYXMuaAorKysgYi9kcml2ZXJzL3Njc2kvcG04MDAxL3BtODAwMV9zYXMuaApAQCAtNDQ1LDcgKzQ0NSw3IEBACiBzdHJ1Y3QgZndfY29udHJvbF9leCB7CiAJc3RydWN0IGZ3X2NvbnRyb2xfaW5mbyAqZndfY29udHJvbDsKIAl2b2lkCQkJKmJ1ZmZlcjsvKiBrZWVwIGJ1ZmZlciBwb2ludGVyIHRvIGJlCi0JZnJlZWQgd2hlbiB0aGUgcmVzcG9uY2UgY29tZXMqLworCWZyZWVkIHdoZW4gdGhlIHJlc3BvbnNlIGNvbWVzKi8KIAl2b2lkCQkJKnZpcnRBZGRyOy8qIGtlZXAgdmlydHVhbCBhZGRyZXNzIG9mIHRoZSBkYXRhICovCiAJdm9pZAkJCSp1c3JBZGRyOy8qIGtlZXAgdmlydHVhbCBhZGRyZXNzIG9mIHRoZQogCXVzZXIgZGF0YSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3BtY3JhaWQuYyBiL2RyaXZlcnMvc2NzaS9wbWNyYWlkLmMKaW5kZXggYmNmODU4ZS4uOTZkNWFkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3BtY3JhaWQuYworKysgYi9kcml2ZXJzL3Njc2kvcG1jcmFpZC5jCkBAIC0yMTMsNyArMjEzLDcgQEAKICAqIHBtY3JhaWRfc2xhdmVfY29uZmlndXJlIC0gQ29uZmlndXJlcyBhIFNDU0kgZGV2aWNlCiAgKiBAc2NzaV9kZXY6IHNjc2kgZGV2aWNlIHN0cnVjdAogICoKLSAqIFRoaXMgZnVjbnRpb24gaXMgZXhlY3V0ZWQgYnkgU0NTSSBtaWQgbGF5ZXIganVzdCBhZnRlciBhIGRldmljZSBpcyBmaXJzdAorICogVGhpcyBmdW5jdGlvbiBpcyBleGVjdXRlZCBieSBTQ1NJIG1pZCBsYXllciBqdXN0IGFmdGVyIGEgZGV2aWNlIGlzIGZpcnN0CiAgKiBzY2FubmVkIChpLmUuIGl0IGhhcyByZXNwb25kZWQgdG8gYW4gSU5RVUlSWSkuIEZvciBWU0VUIHJlc291cmNlcywgdGhlCiAgKiB0aW1lb3V0IHZhbHVlIChkZWZhdWx0IDMwcykgd2lsbCBiZSBvdmVyLXdyaXR0ZW4gdG8gYSBoaWdoZXIgdmFsdWUgKDYwcykKICAqIGFuZCBtYXhfc2VjdG9ycyB2YWx1ZSB3aWxsIGJlIG92ZXItd3JpdHRlbiB0byA1MTIuIEl0IGFsc28gc2V0cyBxdWV1ZSBkZXB0aApAQCAtMjEyMiw3ICsyMTIyLDcgQEAKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIGV4ZWN1dGVzIG1vc3Qgb2YgdGhlIHN0ZXBzIHJlcXVpcmVkIGZvciBJT0EgcmVzZXQuIFRoaXMgZ2V0cwogICogY2FsbGVkIGJ5IHVzZXIgdGhyZWFkcyAobW9kcHJvYmUvaW5zbW9kL3JtbW9kKSB0aW1lciwgdGFza2xldCBhbmQgbWlkbGF5ZXIncwotICogJ2VoXycgdGhyZWFkLiBBY2Nlc3MgdG8gdmFyaWFibGVzIHVzZWQgZm9yIGNvbnRyb2xpbmcgdGhlIHJlc2V0IHNlcXVlbmNlIGlzCisgKiAnZWhfJyB0aHJlYWQuIEFjY2VzcyB0byB2YXJpYWJsZXMgdXNlZCBmb3IgY29udHJvbGxpbmcgdGhlIHJlc2V0IHNlcXVlbmNlIGlzCiAgKiBzeW5jaHJvbml6ZWQgdXNpbmcgaG9zdCBsb2NrLiBWYXJpb3VzIGZ1bmN0aW9ucyBjYWxsZWQgZHVyaW5nIHJlc2V0IHByb2Nlc3MKICAqIHdvdWxkIG1ha2UgdXNlIG9mIGEgc2luZ2xlIGNvbW1hbmQgYmxvY2ssIHBvaW50ZXIgdG8gd2hpY2ggaXMgYWxzbyBzdG9yZWQgaW4KICAqIGFkYXB0ZXIgaW5zdGFuY2Ugc3RydWN0dXJlLgpAQCAtMjk5NCw3ICsyOTk0LDcgQEAKIAogCS8qIElmIHRoZSBhYm9ydCB0YXNrIGlzIG5vdCB0aW1lZCBvdXQgd2Ugd2lsbCBnZXQgYSBHb29kIGNvbXBsZXRpb24KIAkgKiBhcyBzZW5zZV9rZXksIG90aGVyd2lzZSB3ZSBtYXkgZ2V0IG9uZSB0aGUgZm9sbG93aW5nIHJlc3BvbnNlcwotCSAqIGR1ZSB0byBzdWJzcXVlbnQgYnVzIHJlc2V0IG9yIGRldmljZSByZXNldC4gSW4gY2FzZSBJT0FTQyBpcworCSAqIGR1ZSB0byBzdWJzZXF1ZW50IGJ1cyByZXNldCBvciBkZXZpY2UgcmVzZXQuIEluIGNhc2UgSU9BU0MgaXMKIAkgKiBOUl9TWU5DX1JFUVVJUkVELCBzZXQgc3luY19yZXFkIGZsYWcgZm9yIHRoZSBjb3JyZXNwb25kaW5nIHJlc291cmNlCiAJICovCiAJaWYgKGlvYXNjID09IFBNQ1JBSURfSU9BU0NfVUFfQlVTX1dBU19SRVNFVCB8fApAQCAtMzkzMyw3ICszOTMzLDcgQEAKIAogCQkJLyogaWYgYWJvcnQgdGFzayBjb3VsZG4ndCBmaW5kIHRoZSBjb21tYW5kIGkuZSBpdCBnb3QKIAkJCSAqIGNvbXBsZXRlZCBwcmlvciB0byBhYm9ydGluZywgcmV0dXJuIGdvb2QgY29tcGxldGlvbi4KLQkJCSAqIGlmIGNvbW1hbmQgZ290IGFib3J0ZWQgc3VjY2VzZnVsbHkgb3IgdGhlcmUgd2FzIElPQQorCQkJICogaWYgY29tbWFuZCBnb3QgYWJvcnRlZCBzdWNjZXNzZnVsbHkgb3IgdGhlcmUgd2FzIElPQQogCQkJICogcmVzZXQgZHVlIHRvIGFib3J0IHRhc2sgaXRzZWxmIGdldHRpbmcgdGltZWRvdXQgdGhlbgogCQkJICogcmV0dXJuIC1FVElNRURPVVQKIAkJCSAqLwpAQCAtNTkzMiw3ICs1OTMyLDcgQEAKIAkgKiBIb3dldmVyLCBmaXJtd2FyZSBzdXBwb3J0cyA2NC1iaXQgc3RyZWFtaW5nIERNQSBidWZmZXJzLCB3aGVyZWFzCiAJICogY29oZXJlbnQgYnVmZmVycyBhcmUgdG8gYmUgMzItYml0LiBTaW5jZSBwY2lfYWxsb2NfY29uc2lzdGVudCBhbHdheXMKIAkgKiByZXR1cm5zIG1lbW9yeSB3aXRoaW4gNEdCIChpZiBub3QsIGNoYW5nZSB0aGlzIGxvZ2ljKSwgY29oZXJlbnQKLQkgKiBidWZmZXJzIGFyZSB3aXRoaW4gZmlybXdhcmUgYWNjZXB0aWJsZSBhZGRyZXNzIHJhbmdlcy4KKwkgKiBidWZmZXJzIGFyZSB3aXRoaW4gZmlybXdhcmUgYWNjZXB0YWJsZSBhZGRyZXNzIHJhbmdlcy4KIAkgKi8KIAlpZiAoKHNpemVvZihkbWFfYWRkcl90KSA9PSA0KSB8fAogCSAgICBwY2lfc2V0X2RtYV9tYXNrKHBkZXYsIERNQV9CSVRfTUFTSyg2NCkpKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3BtY3JhaWQuaCBiL2RyaXZlcnMvc2NzaS9wbWNyYWlkLmgKaW5kZXggNGRiMjEwZC4uMzRlNGM5MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3BtY3JhaWQuaAorKysgYi9kcml2ZXJzL3Njc2kvcG1jcmFpZC5oCkBAIC0xMDI0LDcgKzEwMjQsNyBAQAogCiAKIC8qCi0gKiBwbWNyYWlkX2lvY3RsX2hlYWRlciAtIGRlZmluaXRpb24gb2YgaGVhZGVyIHN0cnVjdHVyZSB0aGF0IHByZWNlZWRzIGFsbCB0aGUKKyAqIHBtY3JhaWRfaW9jdGxfaGVhZGVyIC0gZGVmaW5pdGlvbiBvZiBoZWFkZXIgc3RydWN0dXJlIHRoYXQgcHJlY2VkZXMgYWxsIHRoZQogICogYnVmZmVycyBnaXZlbiBhcyBpb2N0bCBhcmd1bWVudHMuCiAgKgogICogLnNpZ25hdHVyZSAgICAgICAgICAgOiBhbHdheXMgQVNDSUkgc3RyaW5nLCAiUE1DUkFJRCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9xbGExMjgwLmMgYi9kcml2ZXJzL3Njc2kvcWxhMTI4MC5jCmluZGV4IDVkZWM2ODQuLjhiYTU3NDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9xbGExMjgwLmMKKysrIGIvZHJpdmVycy9zY3NpL3FsYTEyODAuYwpAQCAtNzgsNyArNzgsNyBAQAogCS0gQ2xlYW4gdXAgdmNoYW4gaGFuZGxpbmcKICAgICBSZXYgIDMuMjMuMzMgSnVseSAzLCAyMDAzLCBKZXMgU29yZW5zZW4KIAktIERvbid0IGRlZmluZSByZWdpc3RlciBhY2Nlc3MgbWFjcm9zIGJlZm9yZSBkZWZpbmUgZGV0ZXJtaW5pbmcgTU1JTy4KLQkgIFRoaXMganVzdCBoYXBwZW5kIHRvIHdvcmsgb3V0IG9uIGlhNjQgYnV0IG5vdCBlbHNld2hlcmUuCisJICBUaGlzIGp1c3QgaGFwcGVuZWQgdG8gd29yayBvdXQgb24gaWE2NCBidXQgbm90IGVsc2V3aGVyZS4KIAktIERvbid0IHRyeSBhbmQgcmVhZCBmcm9tIHRoZSBjYXJkIHdoaWxlIGl0IGlzIGluIHJlc2V0IGFzCiAJICBpdCB3b24ndCByZXNwb25kIGFuZCBjYXVzZXMgYW4gTUNBCiAgICAgUmV2ICAzLjIzLjMyIEp1bmUgMjMsIDIwMDMsIEplcyBTb3JlbnNlbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX2RlZi5oIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX2RlZi5oCmluZGV4IDZjNTFjMGEuLmVlMjAzNTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9kZWYuaAorKysgYi9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfZGVmLmgKQEAgLTIwODYsNyArMjA4Niw3IEBACiB9OwogCiAvKgotICogU05TIGNvbW1hbmQgc3RydWN0dXJlcyAtLSBmb3IgMjIwMCBjb21wYXRhYmlsaXR5LgorICogU05TIGNvbW1hbmQgc3RydWN0dXJlcyAtLSBmb3IgMjIwMCBjb21wYXRpYmlsaXR5LgogICovCiAjZGVmaW5lCVJGVF9JRF9TTlNfU0NNRF9MRU4JMjIKICNkZWZpbmUJUkZUX0lEX1NOU19DTURfU0laRQk2MApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX2Z3LmggYi9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfZncuaAppbmRleCA2MzFmZWZjLi5mNWJhMDljIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfZncuaAorKysgYi9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfZncuaApAQCAtNTM5LDcgKzUzOSw3IEBACiAJICogSWYgRElGIEVycm9yIGlzIHNldCBpbiBjb21wX3N0YXR1cywgdGhlc2UgYWRkaXRpb25hbCBmaWVsZHMgYXJlCiAJICogZGVmaW5lZDoKIAkgKiAmZGF0YVsxMF0gOiB1aW50OF90IHJlcG9ydF9ydW50X2JnWzJdOwktIGNvbXB1dGVkIGd1YXJkCi0JICogJmRhdGFbMTJdIDogdWludDhfdCBhY3R1YWxfZGlmWzhdOwkJLSBESUYgRGF0YSByZWNpZXZlZAorCSAqICZkYXRhWzEyXSA6IHVpbnQ4X3QgYWN0dWFsX2RpZls4XTsJCS0gRElGIERhdGEgcmVjZWl2ZWQKIAkgKiAmZGF0YVsyMF0gOiB1aW50OF90IGV4cGVjdGVkX2RpZls4XTsJCS0gRElGIERhdGEgY29tcHV0ZWQKIAkqLwogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9pc3IuYyBiL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9pc3IuYwppbmRleCBkMTdlZDlhLi43MTI1MThkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfaXNyLmMKKysrIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX2lzci5jCkBAIC00MTQsNyArNDE0LDcgQEAKIAkJCQkgICAgIm1hcmtlZCBPRkZMSU5FIVxuIik7CiAJCQkJdmhhLT5mbGFncy5vbmxpbmUgPSAwOwogCQkJfSBlbHNlIHsKLQkJCQkvKiBDaGVjayB0byBzZWUgaWYgTVBJIHRpbWVvdXQgb2NjdXJlZCAqLworCQkJCS8qIENoZWNrIHRvIHNlZSBpZiBNUEkgdGltZW91dCBvY2N1cnJlZCAqLwogCQkJCWlmICgobWJ4ICYgTUJYXzMpICYmIChoYS0+ZmxhZ3MucG9ydDApKQogCQkJCQlzZXRfYml0KE1QSV9SRVNFVF9ORUVERUQsCiAJCQkJCSAgICAmdmhhLT5kcGNfZmxhZ3MpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX21ieC5jIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX21ieC5jCmluZGV4IDdhN2MwZWMuLjM0ODkzMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9tYnguYworKysgYi9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfbWJ4LmMKQEAgLTMwMyw3ICszMDMsNyBAQAogCQkJICAgICF0ZXN0X2JpdChJU1BfQUJPUlRfUkVUUlksICZ2aGEtPmRwY19mbGFncykpIHsKIAogCQkJCXFsYV9wcmludGsoS0VSTl9XQVJOSU5HLCBoYSwKLQkJCQkgICAgIk1haWxib3ggY29tbWFuZCB0aW1lb3V0IG9jY3VyZWQuICIKKwkJCQkgICAgIk1haWxib3ggY29tbWFuZCB0aW1lb3V0IG9jY3VycmVkLiAiCiAJCQkJICAgICJTY2hlZHVsaW5nIElTUCAiICJhYm9ydC4gZWVoX2J1c3k6IDB4JXhcbiIsCiAJCQkJICAgIGhhLT5mbGFncy5lZWhfYnVzeSk7CiAJCQkJc2V0X2JpdChJU1BfQUJPUlRfTkVFREVELCAmdmhhLT5kcGNfZmxhZ3MpOwpAQCAtMzIxLDcgKzMyMSw3IEBACiAJCQkgICAgIXRlc3RfYml0KElTUF9BQk9SVF9SRVRSWSwgJnZoYS0+ZHBjX2ZsYWdzKSkgewogCiAJCQkJcWxhX3ByaW50ayhLRVJOX1dBUk5JTkcsIGhhLAotCQkJCSAgICAiTWFpbGJveCBjb21tYW5kIHRpbWVvdXQgb2NjdXJlZC4gIgorCQkJCSAgICAiTWFpbGJveCBjb21tYW5kIHRpbWVvdXQgb2NjdXJyZWQuICIKIAkJCQkgICAgIklzc3VpbmcgSVNQIGFib3J0LlxuIik7CiAKIAkJCQlzZXRfYml0KEFCT1JUX0lTUF9BQ1RJVkUsICZ2aGEtPmRwY19mbGFncyk7CkBAIC0zNzg5LDcgKzM3ODksNyBAQAogCW1jcC0+bWJbMjBdID0gTFNXKE1TRChtcmVxLT5zZW5kX2RtYSkpOwogCW1jcC0+bWJbMjFdID0gTVNXKE1TRChtcmVxLT5zZW5kX2RtYSkpOwogCi0JLyogcmVjaWV2ZSBkYXRhIGFkZHJlc3MgKi8KKwkvKiByZWNlaXZlIGRhdGEgYWRkcmVzcyAqLwogCW1jcC0+bWJbMTZdID0gTFNXKG1yZXEtPnJjdl9kbWEpOwogCW1jcC0+bWJbMTddID0gTVNXKG1yZXEtPnJjdl9kbWEpOwogCW1jcC0+bWJbNl0gPSBMU1coTVNEKG1yZXEtPnJjdl9kbWEpKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9ueC5jIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX254LmMKaW5kZXggNzZlYzg3Ni4uNDU1ZmUxMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX254LmMKKysrIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX254LmMKQEAgLTI1OTgsNyArMjU5OCw3IEBACiAgKiBxbGE4Mnh4X3N0YXJ0X3Njc2koKSAtIFNlbmQgYSBTQ1NJIGNvbW1hbmQgdG8gdGhlIElTUAogICogQHNwOiBjb21tYW5kIHRvIHNlbmQgdG8gdGhlIElTUAogICoKLSAqIFJldHVybnMgbm9uLXplcm8gaWYgYSBmYWlsdXJlIG9jY3VyZWQsIGVsc2UgemVyby4KKyAqIFJldHVybnMgbm9uLXplcm8gaWYgYSBmYWlsdXJlIG9jY3VycmVkLCBlbHNlIHplcm8uCiAgKi8KIGludAogcWxhODJ4eF9zdGFydF9zY3NpKHNyYl90ICpzcCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9vcy5jIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX29zLmMKaW5kZXggNzVhOTY2Yy4uYWE3NzQ3NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX29zLmMKKysrIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX29zLmMKQEAgLTEwNDYsNyArMTA0Niw3IEBACiAKIGVoX2J1c19yZXNldF9kb25lOgogCXFsYV9wcmludGsoS0VSTl9JTkZPLCB2aGEtPmh3LCAiJXM6IHJlc2V0ICVzXG4iLCBfX2Z1bmNfXywKLQkgICAgKHJldCA9PSBGQUlMRUQpID8gImZhaWxlZCIgOiAic3VjY2VkZWQiKTsKKwkgICAgKHJldCA9PSBGQUlMRUQpID8gImZhaWxlZCIgOiAic3VjY2VlZGVkIik7CiAKIAlyZXR1cm4gcmV0OwogfQpAQCAtMTEzNiw3ICsxMTM2LDcgQEAKIAogZWhfaG9zdF9yZXNldF9sb2NrOgogCXFsYV9wcmludGsoS0VSTl9JTkZPLCBoYSwgIiVzOiByZXNldCAlc1xuIiwgX19mdW5jX18sCi0JICAgIChyZXQgPT0gRkFJTEVEKSA/ICJmYWlsZWQiIDogInN1Y2NlZGVkIik7CisJICAgIChyZXQgPT0gRkFJTEVEKSA/ICJmYWlsZWQiIDogInN1Y2NlZWRlZCIpOwogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTM5MDIsNyArMzkwMiw3IEBACiAJCQljb250aW51ZTsKIAkJaWYgKGF0b21pY19yZWFkKCZvdGhlcl9wZGV2LT5lbmFibGVfY250KSkgewogCQkJREVCVUcxNyhxbGFfcHJpbnRrKEtFUk5fSU5GTywgaGEsCi0JCQkgICAgIkZvdW5kIFBDSSBmdW5jIGF2YWlsYWJlIGFuZCBlbmFibGVkIGF0IDB4JXhcbiIsCisJCQkgICAgIkZvdW5kIFBDSSBmdW5jIGF2YWlsYWJsZSBhbmQgZW5hYmxlZCBhdCAweCV4XG4iLAogCQkJICAgIGZuKSk7CiAJCQlwY2lfZGV2X3B1dChvdGhlcl9wZGV2KTsKIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X2RlZi5oIGIvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X2RlZi5oCmluZGV4IGMxZjhkMWIuLjQ3NTc4NzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9xbGE0eHh4L3FsNF9kZWYuaAorKysgYi9kcml2ZXJzL3Njc2kvcWxhNHh4eC9xbDRfZGVmLmgKQEAgLTE4Miw3ICsxODIsNyBAQAogCXVpbnQxNl90IGZsYWdzOwkJLyogKDEpIFN0YXR1cyBmbGFncy4gKi8KIAogI2RlZmluZSBTUkJfRE1BX1ZBTElECQlCSVRfMwkvKiBETUEgQnVmZmVyIG1hcHBlZC4gKi8KLSNkZWZpbmUgU1JCX0dPVF9TRU5TRQkJQklUXzQJLyogc2Vuc2UgZGF0YSByZWNpZXZlZC4gKi8KKyNkZWZpbmUgU1JCX0dPVF9TRU5TRQkJQklUXzQJLyogc2Vuc2UgZGF0YSByZWNlaXZlZC4gKi8KIAl1aW50OF90IHN0YXRlOwkJLyogKDEpIFN0YXR1cyBmbGFncy4gKi8KIAogI2RlZmluZSBTUkJfTk9fUVVFVUVfU1RBVEUJIDAJLyogUmVxdWVzdCBpcyBpbiBiZXR3ZWVuIHN0YXRlcyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X2luaXQuYyBiL2RyaXZlcnMvc2NzaS9xbGE0eHh4L3FsNF9pbml0LmMKaW5kZXggYmJiMmU5MC4uNDhlMjI0MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X2luaXQuYworKysgYi9kcml2ZXJzL3Njc2kvcWxhNHh4eC9xbDRfaW5pdC5jCkBAIC0xMzM4LDcgKzEzMzgsNyBAQAogCX0KIAogCURFQlVHMihwcmludGsoInNjc2klbGQ6IGluaXRpYWxpemUgYWRhcHRlcjogJXNcbiIsIGhhLT5ob3N0X25vLAotCSAgICBzdGF0dXMgPT0gUUxBX0VSUk9SID8gIkZBSUxFRCIgOiAiU1VDQ0VERUQiKSk7CisJICAgIHN0YXR1cyA9PSBRTEFfRVJST1IgPyAiRkFJTEVEIiA6ICJTVUNDRUVERUQiKSk7CiAJcmV0dXJuIHN0YXR1czsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X252cmFtLmggYi9kcml2ZXJzL3Njc2kvcWxhNHh4eC9xbDRfbnZyYW0uaAppbmRleCBiMzgzMWJkLi45NDVjYzMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcWxhNHh4eC9xbDRfbnZyYW0uaAorKysgYi9kcml2ZXJzL3Njc2kvcWxhNHh4eC9xbDRfbnZyYW0uaApAQCAtMjgsNyArMjgsNyBAQAogI2RlZmluZQkgRk05M0M1NkFfRVJBU0UJICAgICAgMHgzCiAjZGVmaW5lCSBGTTkzQzU2QV9FUkFTRV9BTEwgICAweDAKIAotLyogQ29tbWFuZCBFeHRlbnRpb25zICovCisvKiBDb21tYW5kIEV4dGVuc2lvbnMgKi8KICNkZWZpbmUJIEZNOTNDNTZBX1dFTl9FWFQJIDB4MwogI2RlZmluZQkgRk05M0M1NkFfV1JJVEVfQUxMX0VYVAkgMHgxCiAjZGVmaW5lCSBGTTkzQzU2QV9XRFNfRVhUCSAweDAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9xbGE0eHh4L3FsNF9vcy5jIGIvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X29zLmMKaW5kZXggYTRhY2IwZC4uMjMwYmEwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X29zLmMKKysrIGIvZHJpdmVycy9zY3NpL3FsYTR4eHgvcWw0X29zLmMKQEAgLTEyMTMsNyArMTIxMyw3IEBACiAKIAljbGVhcl9iaXQoRFBDX1JFU0VUX0FDVElWRSwgJmhhLT5kcGNfZmxhZ3MpOwogCURFQlVHMihwcmludGsoInNjc2klbGQ6IHJlY292ZXIgYWRhcHRlcjogJXNcbiIsIGhhLT5ob3N0X25vLAotCSAgICBzdGF0dXMgPT0gUUxBX0VSUk9SID8gIkZBSUxFRCIgOiAiU1VDQ0VERUQiKSk7CisJICAgIHN0YXR1cyA9PSBRTEFfRVJST1IgPyAiRkFJTEVEIiA6ICJTVUNDRUVERUQiKSk7CiAKIAlyZXR1cm4gc3RhdHVzOwogfQpAQCAtMjExMCw3ICsyMTEwLDcgQEAKIAogCXFsNF9wcmludGsoS0VSTl9JTkZPLCBoYSwKIAkgICAgInNjc2klbGQ6JWQ6JWQ6IEFib3J0IGNvbW1hbmQgLSAlc1xuIiwKLQkgICAgaGEtPmhvc3Rfbm8sIGlkLCBsdW4sIChyZXQgPT0gU1VDQ0VTUykgPyAic3VjY2VkZWQiIDogImZhaWxlZCIpOworCSAgICBoYS0+aG9zdF9ubywgaWQsIGx1biwgKHJldCA9PSBTVUNDRVNTKSA/ICJzdWNjZWVkZWQiIDogImZhaWxlZCIpOwogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTIyNzgsNyArMjI3OCw3IEBACiAJCXJldHVybl9zdGF0dXMgPSBTVUNDRVNTOwogCiAJcWw0X3ByaW50ayhLRVJOX0lORk8sIGhhLCAiSE9TVCBSRVNFVCAlcy5cbiIsCi0JCSAgIHJldHVybl9zdGF0dXMgPT0gRkFJTEVEID8gIkZBSUxFRCIgOiAiU1VDQ0VERUQiKTsKKwkJICAgcmV0dXJuX3N0YXR1cyA9PSBGQUlMRUQgPyAiRkFJTEVEIiA6ICJTVUNDRUVERUQiKTsKIAogCXJldHVybiByZXR1cm5fc3RhdHVzOwogfQpAQCAtMjQ5Miw3ICsyNDkyLDcgQEAKIAkvKiBJbml0aWFsaXplIGRldmljZSBvciByZXN1bWUgaWYgaW4gc3VzcGVuZGVkIHN0YXRlICovCiAJcmMgPSBwY2lfZW5hYmxlX2RldmljZShwZGV2KTsKIAlpZiAocmMpIHsKLQkJcWw0X3ByaW50ayhLRVJOX1dBUk5JTkcsIGhhLCAic2NzaSVsZDogJXM6IENhbnQgcmUtZW5hYmxlICIKKwkJcWw0X3ByaW50ayhLRVJOX1dBUk5JTkcsIGhhLCAic2NzaSVsZDogJXM6IENhbid0IHJlLWVuYWJsZSAiCiAJCSAgICAiZGV2aWNlIGFmdGVyIHJlc2V0XG4iLCBoYS0+aG9zdF9ubywgX19mdW5jX18pOwogCQlnb3RvIGV4aXRfc2xvdF9yZXNldDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc2NzaV9kZWJ1Zy5jIGIvZHJpdmVycy9zY3NpL3Njc2lfZGVidWcuYwppbmRleCBmYTU3NThjLi42ODg4YjJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2NzaV9kZWJ1Zy5jCisrKyBiL2RyaXZlcnMvc2NzaS9zY3NpX2RlYnVnLmMKQEAgLTI0NTQsNyArMjQ1NCw3IEBACiAJCXByaW50ayhLRVJOX0lORk8gInNjc2lfZGVidWc6IHNsYXZlX2Rlc3Ryb3kgPCV1ICV1ICV1ICV1PlxuIiwKIAkJICAgICAgIHNkcC0+aG9zdC0+aG9zdF9ubywgc2RwLT5jaGFubmVsLCBzZHAtPmlkLCBzZHAtPmx1bik7CiAJaWYgKGRldmlwKSB7Ci0JCS8qIG1ha2UgdGhpcyBzbG90IGF2YWxpYWJsZSBmb3IgcmUtdXNlICovCisJCS8qIG1ha2UgdGhpcyBzbG90IGF2YWlsYWJsZSBmb3IgcmUtdXNlICovCiAJCWRldmlwLT51c2VkID0gMDsKIAkJc2RwLT5ob3N0ZGF0YSA9IE5VTEw7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3Njc2lfbmV0bGluay5jIGIvZHJpdmVycy9zY3NpL3Njc2lfbmV0bGluay5jCmluZGV4IGEyZWQyMDEuLjI2YThhNDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zY3NpX25ldGxpbmsuYworKysgYi9kcml2ZXJzL3Njc2kvc2NzaV9uZXRsaW5rLmMKQEAgLTQ5OSw3ICs0OTksNyBAQAogCQkJCVNDU0lfTkxfR1JQX0NOVCwgc2NzaV9ubF9yY3ZfbXNnLCBOVUxMLAogCQkJCVRISVNfTU9EVUxFKTsKIAlpZiAoIXNjc2lfbmxfc29jaykgewotCQlwcmludGsoS0VSTl9FUlIgIiVzOiByZWdpc3RlciBvZiByZWNpZXZlIGhhbmRsZXIgZmFpbGVkXG4iLAorCQlwcmludGsoS0VSTl9FUlIgIiVzOiByZWdpc3RlciBvZiByZWNlaXZlIGhhbmRsZXIgZmFpbGVkXG4iLAogCQkJCV9fZnVuY19fKTsKIAkJbmV0bGlua191bnJlZ2lzdGVyX25vdGlmaWVyKCZzY3NpX25ldGxpbmtfbm90aWZpZXIpOwogCQlyZXR1cm47CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc2NzaV90Z3RfbGliLmMgYi9kcml2ZXJzL3Njc2kvc2NzaV90Z3RfbGliLmMKaW5kZXggZjY3MjgyMC4uOGJjYThjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3Njc2lfdGd0X2xpYi5jCisrKyBiL2RyaXZlcnMvc2NzaS9zY3NpX3RndF9saWIuYwpAQCAtOTMsNyArOTMsNyBAQAogCiAJLyoKIAkgKiBUaGUgYmxrIGhlbHBlcnMgYXJlIHVzZWQgdG8gdGhlIFJFQUQvV1JJVEUgcmVxdWVzdHMKLQkgKiB0cmFuc2ZlcmluZyBkYXRhIGZyb20gYSBpbml0aWF0b3IgcG9pbnQgb2Ygdmlldy4gU2luY2UKKwkgKiB0cmFuc2ZlcnJpbmcgZGF0YSBmcm9tIGEgaW5pdGlhdG9yIHBvaW50IG9mIHZpZXcuIFNpbmNlCiAJICogd2UgYXJlIGluIHRhcmdldCBtb2RlIHdlIHdhbnQgdGhlIG9wcG9zaXRlLgogCSAqLwogCXJxID0gYmxrX2dldF9yZXF1ZXN0KHNob3N0LT51c3BhY2VfcmVxX3EsICF3cml0ZSwgZ2ZwX21hc2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3Njc2lfdHJhbnNwb3J0X2ZjLmMgYi9kcml2ZXJzL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuYwppbmRleCAyOTQxZDJkLi5mZGYzZmE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuYworKysgYi9kcml2ZXJzL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuYwpAQCAtMjM3OCw3ICsyMzc4LDcgQEAKICAqIGZjX3JlbW92ZV9ob3N0IC0gY2FsbGVkIHRvIHRlcm1pbmF0ZSBhbnkgZmNfdHJhbnNwb3J0LXJlbGF0ZWQgZWxlbWVudHMgZm9yIGEgc2NzaSBob3N0LgogICogQHNob3N0OglXaGljaCAmU2NzaV9Ib3N0CiAgKgotICogVGhpcyByb3V0aW5lIGlzIGV4cGVjdGVkIHRvIGJlIGNhbGxlZCBpbW1lZGlhdGVseSBwcmVjZWVkaW5nIHRoZQorICogVGhpcyByb3V0aW5lIGlzIGV4cGVjdGVkIHRvIGJlIGNhbGxlZCBpbW1lZGlhdGVseSBwcmVjZWRpbmcgdGhlCiAgKiBhIGRyaXZlcidzIGNhbGwgdG8gc2NzaV9yZW1vdmVfaG9zdCgpLgogICoKICAqIFdBUk5JTkc6IEEgZHJpdmVyIHV0aWxpemluZyB0aGUgZmNfdHJhbnNwb3J0LCB3aGljaCBmYWlscyB0byBjYWxsCkBAIC0yNDU4LDcgKzI0NTgsNyBAQAogfQogCiAvKioKLSAqIGZjX3N0YXJnZXRfZGVsZXRlIC0gY2FsbGVkIHRvIGRlbGV0ZSB0aGUgc2NzaSBkZWNlbmRlbnRzIG9mIGFuIHJwb3J0CisgKiBmY19zdGFyZ2V0X2RlbGV0ZSAtIGNhbGxlZCB0byBkZWxldGUgdGhlIHNjc2kgZGVzY2VuZGFudHMgb2YgYW4gcnBvcnQKICAqIEB3b3JrOglyZW1vdGUgcG9ydCB0byBiZSBvcGVyYXRlZCBvbi4KICAqCiAgKiBEZWxldGVzIHRhcmdldCBhbmQgYWxsIHNkZXZzLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NkLmMgYi9kcml2ZXJzL3Njc2kvc2QuYwppbmRleCBiNjFlYmVjLi5iZDA4MDZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2QuYworKysgYi9kcml2ZXJzL3Njc2kvc2QuYwpAQCAtMTA1NSw3ICsxMDU1LDcgQEAKICAqCUBhcmc6IHRoaXMgaXMgdGhpcmQgYXJndW1lbnQgZ2l2ZW4gdG8gaW9jdGwoMikgc3lzdGVtIGNhbGwuCiAgKglPZnRlbiBjb250YWlucyBhIHBvaW50ZXIuCiAgKgotICoJUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWwgKHNvbWUgaW9jdGxzIHJldHVybiBwb3N0aXZlIG51bWJlcnMgb24KKyAqCVJldHVybnMgMCBpZiBzdWNjZXNzZnVsIChzb21lIGlvY3RscyByZXR1cm4gcG9zaXRpdmUgbnVtYmVycyBvbgogICoJc3VjY2VzcyBhcyB3ZWxsKS4gUmV0dXJucyBhIG5lZ2F0ZWQgZXJybm8gdmFsdWUgaW4gY2FzZSBvZiBlcnJvci4KICAqCiAgKglOb3RlOiBtb3N0IGlvY3RscyBhcmUgZm9yd2FyZCBvbnRvIHRoZSBibG9jayBzdWJzeXN0ZW0gb3IgZnVydGhlcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NyLmMgYi9kcml2ZXJzL3Njc2kvc3IuYwppbmRleCBhZWZhZGM2Li45NTAxOWM3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc3IuYworKysgYi9kcml2ZXJzL3Njc2kvc3IuYwpAQCAtNTY3LDcgKzU2Nyw3IEBACiAJLnJldmFsaWRhdGVfZGlzayA9IHNyX2Jsb2NrX3JldmFsaWRhdGVfZGlzaywKIAkvKiAKIAkgKiBObyBjb21wYXRfaW9jdGwgZm9yIG5vdyBiZWNhdXNlIHNyX2Jsb2NrX2lvY3RsIG5ldmVyCi0JICogc2VlbXMgdG8gcGFzcyBhcmJpdGFyeSBpb2N0bHMgZG93biB0byBob3N0IGRyaXZlcnMuCisJICogc2VlbXMgdG8gcGFzcyBhcmJpdHJhcnkgaW9jdGxzIGRvd24gdG8gaG9zdCBkcml2ZXJzLgogCSAqLwogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3N1bjNfTkNSNTM4MC5jIGIvZHJpdmVycy9zY3NpL3N1bjNfTkNSNTM4MC5jCmluZGV4IDRmMGU1NDguLjA3ZWFlZjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zdW4zX05DUjUzODAuYworKysgYi9kcml2ZXJzL3Njc2kvc3VuM19OQ1I1MzgwLmMKQEAgLTQ2Nyw3ICs0NjcsNyBAQAogICoKICAqIFBhcmFtZXRlcnM6IHN0cnVjdCBzY3NpX2NtbmQgKmNtZAogICogICAgVGhlIGNvbW1hbmQgdG8gd29yayBvbi4gVGhlIGZpcnN0IHNjYXR0ZXIgYnVmZmVyJ3MgZGF0YSBhcmUKLSAqICAgIGFzc3VtZWQgdG8gYmUgYWxyZWFkeSB0cmFuc2ZlcmVkIGludG8gcHRyL3RoaXNfcmVzaWR1YWwuCisgKiAgICBhc3N1bWVkIHRvIGJlIGFscmVhZHkgdHJhbnNmZXJyZWQgaW50byBwdHIvdGhpc19yZXNpZHVhbC4KICAqLwogCiBzdGF0aWMgdm9pZCBtZXJnZV9jb250aWd1b3VzX2J1ZmZlcnMoc3RydWN0IHNjc2lfY21uZCAqY21kKQpAQCAtMTcxNyw3ICsxNzE3LDcgQEAKICAqCWJ5dGVzIHRvIHRyYW5zZmVyLCAqKmRhdGEgLSBwb2ludGVyIHRvIGRhdGEgcG9pbnRlci4KICAqIAogICogUmV0dXJucyA6IC0xIHdoZW4gZGlmZmVyZW50IHBoYXNlIGlzIGVudGVyZWQgd2l0aG91dCB0cmFuc2ZlcnJpbmcKLSAqCW1heGltdW0gbnVtYmVyIG9mIGJ5dGVzLCAwIGlmIGFsbCBieXRlcyBhcmUgdHJhbnNmZXJlZCBvciBleGl0CisgKgltYXhpbXVtIG51bWJlciBvZiBieXRlcywgMCBpZiBhbGwgYnl0ZXMgYXJlIHRyYW5zZmVycmVkIG9yIGV4aXQKICAqCWlzIGluIHNhbWUgcGhhc2UuCiAgKgogICogCUFsc28sICpwaGFzZSwgKmNvdW50LCAqZGF0YSBhcmUgbW9kaWZpZWQgaW4gcGxhY2UuCkBAIC0xOTA0LDcgKzE5MDQsNyBAQAogICoJYnl0ZXMgdG8gdHJhbnNmZXIsICoqZGF0YSAtIHBvaW50ZXIgdG8gZGF0YSBwb2ludGVyLgogICogCiAgKiBSZXR1cm5zIDogLTEgd2hlbiBkaWZmZXJlbnQgcGhhc2UgaXMgZW50ZXJlZCB3aXRob3V0IHRyYW5zZmVycmluZwotICoJbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMsIDAgaWYgYWxsIGJ5dGVzIG9yIHRyYW5zZmVyZWQgb3IgZXhpdAorICoJbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMsIDAgaWYgYWxsIGJ5dGVzIG9yIHRyYW5zZmVycmVkIG9yIGV4aXQKICAqCWlzIGluIHNhbWUgcGhhc2UuCiAgKgogICogCUFsc28sICpwaGFzZSwgKmNvdW50LCAqZGF0YSBhcmUgbW9kaWZpZWQgaW4gcGxhY2UuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc3ltNTNjNDE2LmMgYi9kcml2ZXJzL3Njc2kvc3ltNTNjNDE2LmMKaW5kZXggMTkwMTA3YS4uMDEyYzg2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3N5bTUzYzQxNi5jCisrKyBiL2RyaXZlcnMvc2NzaS9zeW01M2M0MTYuYwpAQCAtNzc0LDcgKzc3NCw3IEBACiAKIAkvKiBwcmludGsoInN5bTUzYzQxNl9yZXNldFxuIik7ICovCiAJYmFzZSA9IFNDcG50LT5kZXZpY2UtPmhvc3QtPmlvX3BvcnQ7Ci0JLyogc2VhcmNoIHNjc2lfaWQgLSBmaXhtZSwgd2Ugc2hvdWxkbnQgbmVlZCB0byBpdGVyYXRlIGZvciB0aGlzISAqLworCS8qIHNlYXJjaCBzY3NpX2lkIC0gZml4bWUsIHdlIHNob3VsZG4ndCBuZWVkIHRvIGl0ZXJhdGUgZm9yIHRoaXMhICovCiAJZm9yKGkgPSAwOyBpIDwgaG9zdF9pbmRleCAmJiBzY3NpX2lkID09IC0xOyBpKyspCiAJCWlmKGhvc3RzW2ldLmJhc2UgPT0gYmFzZSkKIAkJCXNjc2lfaWQgPSBob3N0c1tpXS5zY3NpX2lkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3N5bTUzYzh4eF8yL3N5bV9mdzEuaCBiL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1fZncxLmgKaW5kZXggN2IwOGQ2Yy4uNjM5NTJlZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3N5bTUzYzh4eF8yL3N5bV9mdzEuaAorKysgYi9kcml2ZXJzL3Njc2kvc3ltNTNjOHh4XzIvc3ltX2Z3MS5oCkBAIC0xNDQ5LDcgKzE0NDksNyBAQAogCQlQQUREUl9CIChtc2dfd2VpcmRfc2VlbiksCiAJLyoKIAkgKiAgV2UgZG9ubm90IGhhbmRsZSBleHRlbmRlZCBtZXNzYWdlcyBmcm9tIFNDUklQVFMuCi0JICogIFJlYWQgdGhlIGFtb3VudCBvZiBkYXRhIGNvcnJlcG9uZGluZyB0byB0aGUgCisJICogIFJlYWQgdGhlIGFtb3VudCBvZiBkYXRhIGNvcnJlc3BvbmRpbmcgdG8gdGhlIAogCSAqICBtZXNzYWdlIGxlbmd0aCBhbmQgY2FsbCB0aGUgQyBjb2RlLgogCSAqLwogCVNDUl9DT1BZICgxKSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1fZncyLmggYi9kcml2ZXJzL3Njc2kvc3ltNTNjOHh4XzIvc3ltX2Z3Mi5oCmluZGV4IGFlMWZiMTcuLmM4N2Q3MjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1fZncyLmgKKysrIGIvZHJpdmVycy9zY3NpL3N5bTUzYzh4eF8yL3N5bV9mdzIuaApAQCAtMTMyNiw3ICsxMzI2LDcgQEAKIAkJUEFERFJfQiAobXNnX3dlaXJkX3NlZW4pLAogCS8qCiAJICogIFdlIGRvbm5vdCBoYW5kbGUgZXh0ZW5kZWQgbWVzc2FnZXMgZnJvbSBTQ1JJUFRTLgotCSAqICBSZWFkIHRoZSBhbW91bnQgb2YgZGF0YSBjb3JyZXBvbmRpbmcgdG8gdGhlIAorCSAqICBSZWFkIHRoZSBhbW91bnQgb2YgZGF0YSBjb3JyZXNwb25kaW5nIHRvIHRoZSAKIAkgKiAgbWVzc2FnZSBsZW5ndGggYW5kIGNhbGwgdGhlIEMgY29kZS4KIAkgKi8KIAlTQ1JfU1RPUkVfUkVMIChzY3JhdGNoYSwgMSksCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc3ltNTNjOHh4XzIvc3ltX2hpcGQuYyBiL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1faGlwZC5jCmluZGV4IDJjM2U4OWQuLmQ5MmZlNDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1faGlwZC5jCisrKyBiL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1faGlwZC5jCkBAIC0yNDU3LDcgKzI0NTcsNyBAQAogCQl9CiAKIAkJLyoKLQkJICogIFRoZSBkYXRhIGluIHRoZSBkbWEgZmlmbyBoYXMgbm90IGJlZW4gdHJhbnNmZXJlZCB0bworCQkgKiAgVGhlIGRhdGEgaW4gdGhlIGRtYSBmaWZvIGhhcyBub3QgYmVlbiB0cmFuc2ZlcnJlZCB0bwogCQkgKiAgdGhlIHRhcmdldCAtPiBhZGQgdGhlIGFtb3VudCB0byB0aGUgcmVzdAogCQkgKiAgYW5kIGNsZWFyIHRoZSBkYXRhLgogCQkgKiAgQ2hlY2sgdGhlIHNzdGF0MiByZWdpc3RlciBpbiBjYXNlIG9mIHdpZGUgdHJhbnNmZXIuCkBAIC01MDk0LDcgKzUwOTQsNyBAQAogfQogCiAvKgotICogIEx1biBjb250cm9sIGJsb2NrIGRlYWxsb2NhdGlvbi4gUmV0dXJucyB0aGUgbnVtYmVyIG9mIHZhbGlkIHJlbWFpbmcgTENCcworICogIEx1biBjb250cm9sIGJsb2NrIGRlYWxsb2NhdGlvbi4gUmV0dXJucyB0aGUgbnVtYmVyIG9mIHZhbGlkIHJlbWFpbmluZyBMQ0JzCiAgKiAgZm9yIHRoZSB0YXJnZXQuCiAgKi8KIGludCBzeW1fZnJlZV9sY2Ioc3RydWN0IHN5bV9oY2IgKm5wLCB1X2NoYXIgdG4sIHVfY2hhciBsbikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1fbWFsbG9jLmMgYi9kcml2ZXJzL3Njc2kvc3ltNTNjOHh4XzIvc3ltX21hbGxvYy5jCmluZGV4IDg4M2NhYzEuLjZmOWFmMGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zeW01M2M4eHhfMi9zeW1fbWFsbG9jLmMKKysrIGIvZHJpdmVycy9zY3NpL3N5bTUzYzh4eF8yL3N5bV9tYWxsb2MuYwpAQCAtNTAsNyArNTAsNyBAQAogICogIGZyb20gdGhlIFNDUklQVFMgY29kZS4gSW4gYWRkaXRpb24sIGNhY2hlIGxpbmUgYWxpZ25tZW50IAogICogIGlzIGd1YXJhbnRlZWQgZm9yIHBvd2VyIG9mIDIgY2FjaGUgbGluZSBzaXplLgogICoKLSAqICBUaGlzIGFsbG9jYXRvciBoYXMgYmVlbiBkZXZlbG9wcGVkIGZvciB0aGUgTGludXggc3ltNTNjOHh4ICAKKyAqICBUaGlzIGFsbG9jYXRvciBoYXMgYmVlbiBkZXZlbG9wZWQgZm9yIHRoZSBMaW51eCBzeW01M2M4eHggIAogICogIGRyaXZlciwgc2luY2UgdGhpcyBPL1MgZG9lcyBub3QgcHJvdmlkZSBuYXR1cmFsbHkgYWxpZ25lZCAKICAqICBhbGxvY2F0aW9ucy4KICAqICBJdCBoYXMgdGhlIGFkdmFudGFnZSBvZiBhbGxvd2luZyB0aGUgZHJpdmVyIHRvIHVzZSBwcml2YXRlIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3dkMzNjOTMuYyBiL2RyaXZlcnMvc2NzaS93ZDMzYzkzLmMKaW5kZXggNWY2OTdlMC4uNDQ2OGFlMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3dkMzNjOTMuYworKysgYi9kcml2ZXJzL3Njc2kvd2QzM2M5My5jCkBAIC0xODQzLDcgKzE4NDMsNyBAQAogICoKICAqIFRoZSBvcmlnaW5hbCBkcml2ZXIgdXNlZCB0byByZWx5IG9uIGEgZml4ZWQgc3hfdGFibGUsIGNvbnRhaW5pbmcgcGVyaW9kcwogICogZm9yIChvbmx5KSB0aGUgbG93ZXIgbGltaXRzIG9mIHRoZSByZXNwZWN0aXZlIGlucHV0LWNsb2NrLWZyZXF1ZW5jeSByYW5nZXMKLSAqICg4LTEwLzEyLTE1LzE2LTIwIE1IeikuIEFsdGhvdWdoIGl0IHNlZW1zLCB0aGF0IG5vIHByb2JsZW1zIG9jdXJyZWQgd2l0aAorICogKDgtMTAvMTItMTUvMTYtMjAgTUh6KS4gQWx0aG91Z2ggaXQgc2VlbXMsIHRoYXQgbm8gcHJvYmxlbXMgb2NjdXJyZWQgd2l0aAogICogdGhpcyBzZXR0aW5nIHNvIGZhciwgaXQgbWlnaHQgYmUgZGVzaXJhYmxlIHRvIGFkanVzdCB0aGUgdHJhbnNmZXIgcGVyaW9kcwogICogY2xvc2VyIHRvIHRoZSByZWFsbHkgYXR0YWNoZWQsIHBvc3NpYmx5IDI1JSBoaWdoZXIsIGlucHV0LWNsb2NrLCBzaW5jZQogICogLSB0aGUgd2QzM2M5MyBtYXkgcmVhbGx5IHVzZSBhIHNpZ25pZmljYW50IHNob3J0ZXIgcGVyaW9kLCB0aGFuIGl0IGhhcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3dkNzAwMC5jIGIvZHJpdmVycy9zY3NpL3dkNzAwMC5jCmluZGV4IGRiNDUxYWUuLjllZTBhZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS93ZDcwMDAuYworKysgYi9kcml2ZXJzL3Njc2kvd2Q3MDAwLmMKQEAgLTgzNyw3ICs4MzcsNyBAQAogCQl9CiAJfQogCi0JLyogVGFrZSB0aGUgbG9jaywgdGhlbiBjaGVjayB3ZSBkaWRudCBnZXQgYmVhdGVuLCBpZiBzbyB0cnkgYWdhaW4gKi8KKwkvKiBUYWtlIHRoZSBsb2NrLCB0aGVuIGNoZWNrIHdlIGRpZG4ndCBnZXQgYmVhdGVuLCBpZiBzbyB0cnkgYWdhaW4gKi8KIAlzcGluX2xvY2tfaXJxc2F2ZSgmc2NicG9vbF9sb2NrLCBmbGFncyk7CiAJaWYgKGZyZWVzY2JzIDwgbmVlZGVkKSB7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjYnBvb2xfbG9jaywgZmxhZ3MpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZmkvc2ZpX2NvcmUuYyBiL2RyaXZlcnMvc2ZpL3NmaV9jb3JlLmMKaW5kZXggMDQxMTNlNS4uMWU4MjRmYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zZmkvc2ZpX2NvcmUuYworKysgYi9kcml2ZXJzL3NmaS9zZmlfY29yZS5jCkBAIC01MTUsNyArNTE1LDcgQEAKIH0KIAogLyoKLSAqIFRoZSByZWFzb24gd2UgcHV0IGl0IGhlcmUgYmVjYXN1ZSB3ZSBuZWVkIHdhaXQgdGlsbCB0aGUgL3N5cy9maXJtd2FyZQorICogVGhlIHJlYXNvbiB3ZSBwdXQgaXQgaGVyZSBiZWNhdXNlIHdlIG5lZWQgd2FpdCB0aWxsIHRoZSAvc3lzL2Zpcm13YXJlCiAgKiBpcyBzZXR1cCwgdGhlbiBvdXIgaW50ZXJmYWNlIGNhbiBiZSByZWdpc3RlcmVkIGluIC9zeXMvZmlybXdhcmUvc2ZpCiAgKi8KIGNvcmVfaW5pdGNhbGwoc2ZpX3N5c2ZzX2luaXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvYW1iYS1wbDAyMi5jIGIvZHJpdmVycy9zcGkvYW1iYS1wbDAyMi5jCmluZGV4IDRiODM1N2IuLjA4ZGU1OGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL2FtYmEtcGwwMjIuYworKysgYi9kcml2ZXJzL3NwaS9hbWJhLXBsMDIyLmMKQEAgLTY2MSw3ICs2NjEsNyBAQAogewogCiAJLyoKLQkgKiBUaGUgRklGTyBkZXB0aCBpcyBkaWZmZXJlbnQgaW5iZXR3ZWVuIHByaW1lY2VsbCB2YXJpYW50cy4KKwkgKiBUaGUgRklGTyBkZXB0aCBpcyBkaWZmZXJlbnQgYmV0d2VlbiBwcmltZWNlbGwgdmFyaWFudHMuCiAJICogSSBiZWxpZXZlIGZpbGxpbmcgaW4gdG9vIG11Y2ggaW4gdGhlIEZJRk8gbWlnaHQgY2F1c2UKIAkgKiBlcnJvbnMgaW4gOGJpdCB3aWRlIHRyYW5zZmVycyBvbiBBUk0gdmFyaWFudHMgKGp1c3QgOCB3b3JkcwogCSAqIEZJRk8sIG1lYW5zIG9ubHkgOHg4ID0gNjQgYml0cyBpbiBGSUZPKSBhdCBsZWFzdC4KQEAgLTcyMiw3ICs3MjIsNyBAQAogCQkgKiBUaGlzIGlubmVyIHJlYWRlciB0YWtlcyBjYXJlIG9mIHRoaW5ncyBhcHBlYXJpbmcgaW4gdGhlIFJYCiAJCSAqIEZJRk8gYXMgd2UncmUgdHJhbnNtaXR0aW5nLiBUaGlzIHdpbGwgaGFwcGVuIGEgbG90IHNpbmNlIHRoZQogCQkgKiBjbG9jayBzdGFydHMgcnVubmluZyB3aGVuIHlvdSBwdXQgdGhpbmdzIGludG8gdGhlIFRYIEZJRk8sCi0JCSAqIGFuZCB0aGVuIHRoaW5ncyBhcmUgY29udGlub3VzbHkgY2xvY2tlZCBpbnRvIHRoZSBSWCBGSUZPLgorCQkgKiBhbmQgdGhlbiB0aGluZ3MgYXJlIGNvbnRpbnVvdXNseSBjbG9ja2VkIGludG8gdGhlIFJYIEZJRk8uCiAJCSAqLwogCQl3aGlsZSAoKHJlYWR3KFNTUF9TUihwbDAyMi0+dmlydGJhc2UpKSAmIFNTUF9TUl9NQVNLX1JORSkKIAkJICAgICAgICYmIChwbDAyMi0+cnggPCBwbDAyMi0+cnhfZW5kKSkgewpAQCAtODQyLDcgKzg0Miw3IEBACiAKIAl1bm1hcF9mcmVlX2RtYV9zY2F0dGVyKHBsMDIyKTsKIAotCS8qIFVwZGF0ZSB0b3RhbCBieXRlcyB0cmFuc2ZlcmVkICovCisJLyogVXBkYXRlIHRvdGFsIGJ5dGVzIHRyYW5zZmVycmVkICovCiAJbXNnLT5hY3R1YWxfbGVuZ3RoICs9IHBsMDIyLT5jdXJfdHJhbnNmZXItPmxlbjsKIAlpZiAocGwwMjItPmN1cl90cmFuc2Zlci0+Y3NfY2hhbmdlKQogCQlwbDAyMi0+Y3VyX2NoaXAtPgpAQCAtMTIyNCw3ICsxMjI0LDcgQEAKIAkJCQkgIm51bWJlciBvZiBieXRlcyBvbiBhIDE2Yml0IGJ1cz8pXG4iLAogCQkJCSAodTMyKSAocGwwMjItPnJ4IC0gcGwwMjItPnJ4X2VuZCkpOwogCQl9Ci0JCS8qIFVwZGF0ZSB0b3RhbCBieXRlcyB0cmFuc2ZlcmVkICovCisJCS8qIFVwZGF0ZSB0b3RhbCBieXRlcyB0cmFuc2ZlcnJlZCAqLwogCQltc2ctPmFjdHVhbF9sZW5ndGggKz0gcGwwMjItPmN1cl90cmFuc2Zlci0+bGVuOwogCQlpZiAocGwwMjItPmN1cl90cmFuc2Zlci0+Y3NfY2hhbmdlKQogCQkJcGwwMjItPmN1cl9jaGlwLT4KQEAgLTE0MTUsMTEgKzE0MTUsMTEgQEAKIAkJICAgICAgIFNTUF9DUjEocGwwMjItPnZpcnRiYXNlKSk7CiAKIAkJZGV2X2RiZygmcGwwMjItPmFkZXYtPmRldiwgInBvbGxpbmcgdHJhbnNmZXIgb25nb2luZyAuLi5cbiIpOwotCQkvKiBGSVhNRTogaW5zZXJ0IGEgdGltZW91dCBzbyB3ZSBkb24ndCBoYW5nIGhlcmUgaW5kZWZpbmF0ZWx5ICovCisJCS8qIEZJWE1FOiBpbnNlcnQgYSB0aW1lb3V0IHNvIHdlIGRvbid0IGhhbmcgaGVyZSBpbmRlZmluaXRlbHkgKi8KIAkJd2hpbGUgKHBsMDIyLT50eCA8IHBsMDIyLT50eF9lbmQgfHwgcGwwMjItPnJ4IDwgcGwwMjItPnJ4X2VuZCkKIAkJCXJlYWR3cml0ZXIocGwwMjIpOwogCi0JCS8qIFVwZGF0ZSB0b3RhbCBieXRlIHRyYW5zZmVyZWQgKi8KKwkJLyogVXBkYXRlIHRvdGFsIGJ5dGUgdHJhbnNmZXJyZWQgKi8KIAkJbWVzc2FnZS0+YWN0dWFsX2xlbmd0aCArPSBwbDAyMi0+Y3VyX3RyYW5zZmVyLT5sZW47CiAJCWlmIChwbDAyMi0+Y3VyX3RyYW5zZmVyLT5jc19jaGFuZ2UpCiAJCQlwbDAyMi0+Y3VyX2NoaXAtPmNzX2NvbnRyb2woU1NQX0NISVBfREVTRUxFQ1QpOwpAQCAtMjEyOSw3ICsyMTI5LDcgQEAKIAkJCSJwcm9iZSAtIHByb2JsZW0gcmVnaXN0ZXJpbmcgc3BpIG1hc3RlclxuIik7CiAJCWdvdG8gZXJyX3NwaV9yZWdpc3RlcjsKIAl9Ci0JZGV2X2RiZyhkZXYsICJwcm9iZSBzdWNjZWRlZFxuIik7CisJZGV2X2RiZyhkZXYsICJwcm9iZSBzdWNjZWVkZWRcbiIpOwogCS8qCiAJICogRGlzYWJsZSB0aGUgc2lsaWNvbiBibG9jayBwY2xrIGFuZCBhbnkgdm9sdGFnZSBkb21haW4gYW5kIGp1c3QKIAkgKiBwb3dlciBpdCB1cCBhbmQgY2xvY2sgaXQgd2hlbiBpdCdzIG5lZWRlZApAQCAtMjE4NCw3ICsyMTg0LDcgQEAKIAlzcGlfdW5yZWdpc3Rlcl9tYXN0ZXIocGwwMjItPm1hc3Rlcik7CiAJc3BpX21hc3Rlcl9wdXQocGwwMjItPm1hc3Rlcik7CiAJYW1iYV9zZXRfZHJ2ZGF0YShhZGV2LCBOVUxMKTsKLQlkZXZfZGJnKCZhZGV2LT5kZXYsICJyZW1vdmUgc3VjY2VkZWRcbiIpOworCWRldl9kYmcoJmFkZXYtPmRldiwgInJlbW92ZSBzdWNjZWVkZWRcbiIpOwogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9hdTE1NTBfc3BpLmMgYi9kcml2ZXJzL3NwaS9hdTE1NTBfc3BpLmMKaW5kZXggM2M5YWRlNi4uYjUwNTYzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvYXUxNTUwX3NwaS5jCisrKyBiL2RyaXZlcnMvc3BpL2F1MTU1MF9zcGkuYwpAQCAtNDgwLDcgKzQ4MCw3IEBACiAJCWF1MXh4eF9kYmRtYV9zdG9wKGh3LT5kbWFfcnhfY2gpOwogCQlhdTF4eHhfZGJkbWFfc3RvcChody0+ZG1hX3R4X2NoKTsKIAotCQkvKiBnZXQgbnVtYmVyIG9mIHRyYW5zZmVyZWQgYnl0ZXMgKi8KKwkJLyogZ2V0IG51bWJlciBvZiB0cmFuc2ZlcnJlZCBieXRlcyAqLwogCQlody0+cnhfY291bnQgPSBody0+bGVuIC0gYXUxeHh4X2dldF9kbWFfcmVzaWR1ZShody0+ZG1hX3J4X2NoKTsKIAkJaHctPnR4X2NvdW50ID0gaHctPmxlbiAtIGF1MXh4eF9nZXRfZG1hX3Jlc2lkdWUoaHctPmRtYV90eF9jaCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL2R3X3NwaS5jIGIvZHJpdmVycy9zcGkvZHdfc3BpLmMKaW5kZXggZDA0MGRlYi4uODcxZTMzNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvZHdfc3BpLmMKKysrIGIvZHJpdmVycy9zcGkvZHdfc3BpLmMKQEAgLTM0NSw3ICszNDUsNyBAQAogCiB2b2lkIGR3X3NwaV94ZmVyX2RvbmUoc3RydWN0IGR3X3NwaSAqZHdzKQogewotCS8qIFVwZGF0ZSB0b3RhbCBieXRlIHRyYW5zZmVyZWQgcmV0dXJuIGNvdW50IGFjdHVhbCBieXRlcyByZWFkICovCisJLyogVXBkYXRlIHRvdGFsIGJ5dGUgdHJhbnNmZXJyZWQgcmV0dXJuIGNvdW50IGFjdHVhbCBieXRlcyByZWFkICovCiAJZHdzLT5jdXJfbXNnLT5hY3R1YWxfbGVuZ3RoICs9IGR3cy0+bGVuOwogCiAJLyogTW92ZSB0byBuZXh0IHRyYW5zZmVyICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9kd19zcGkuaCBiL2RyaXZlcnMvc3BpL2R3X3NwaS5oCmluZGV4IGZiMGJjZTUuLmIyM2U0NTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL2R3X3NwaS5oCisrKyBiL2RyaXZlcnMvc3BpL2R3X3NwaS5oCkBAIC00Niw3ICs0Niw3IEBACiAjZGVmaW5lIFNQSV9JTlRfUlhGSQkJCSgxIDw8IDQpCiAjZGVmaW5lIFNQSV9JTlRfTVNUSQkJCSgxIDw8IDUpCiAKLS8qIFRYIFJYIGludGVycnVwdCBsZXZlbCB0aHJlc2hob2xkLCBtYXggY2FuIGJlIDI1NiAqLworLyogVFggUlggaW50ZXJydXB0IGxldmVsIHRocmVzaG9sZCwgbWF4IGNhbiBiZSAyNTYgKi8KICNkZWZpbmUgU1BJX0lOVF9USFJFU0hPTEQJCTMyCiAKIGVudW0gZHdfc3NpX3R5cGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvZXA5M3h4X3NwaS5jIGIvZHJpdmVycy9zcGkvZXA5M3h4X3NwaS5jCmluZGV4IDBiYTM1ZGYuLmQzNTcwMDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL2VwOTN4eF9zcGkuYworKysgYi9kcml2ZXJzL3NwaS9lcDkzeHhfc3BpLmMKQEAgLTUxMiw3ICs1MTIsNyBAQAogICoKICAqIFRoaXMgZnVuY3Rpb24gcHJvY2Vzc2VzIG9uZSBTUEkgdHJhbnNmZXIgZ2l2ZW4gaW4gQHQuIEZ1bmN0aW9uIHdhaXRzIHVudGlsCiAgKiB0cmFuc2ZlciBpcyBjb21wbGV0ZSAobWF5IHNsZWVwKSBhbmQgdXBkYXRlcyBAbXNnLT5zdGF0dXMgYmFzZWQgb24gd2hldGhlcgotICogdHJhbnNmZXIgd2FzIHN1Y2Nlc2Z1bGx5IHByb2Nlc3NlZCBvciBub3QuCisgKiB0cmFuc2ZlciB3YXMgc3VjY2Vzc2Z1bGx5IHByb2Nlc3NlZCBvciBub3QuCiAgKi8KIHN0YXRpYyB2b2lkIGVwOTN4eF9zcGlfcHJvY2Vzc190cmFuc2ZlcihzdHJ1Y3QgZXA5M3h4X3NwaSAqZXNwaSwKIAkJCQkJc3RydWN0IHNwaV9tZXNzYWdlICptc2csCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9weGEyeHhfc3BpLmMgYi9kcml2ZXJzL3NwaS9weGEyeHhfc3BpLmMKaW5kZXggM2FhNzgyMC4uZGMyNWJlZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvcHhhMnh4X3NwaS5jCisrKyBiL2RyaXZlcnMvc3BpL3B4YTJ4eF9zcGkuYwpAQCAtNzAwLDcgKzcwMCw3IEBACiAJaWYgKCFweGEyNXhfc3NwX2NvbXAoZHJ2X2RhdGEpKQogCQl3cml0ZV9TU1RPKDAsIHJlZyk7CiAKLQkvKiBVcGRhdGUgdG90YWwgYnl0ZSB0cmFuc2ZlcmVkIHJldHVybiBjb3VudCBhY3R1YWwgYnl0ZXMgcmVhZCAqLworCS8qIFVwZGF0ZSB0b3RhbCBieXRlIHRyYW5zZmVycmVkIHJldHVybiBjb3VudCBhY3R1YWwgYnl0ZXMgcmVhZCAqLwogCWRydl9kYXRhLT5jdXJfbXNnLT5hY3R1YWxfbGVuZ3RoICs9IGRydl9kYXRhLT5sZW4gLQogCQkJCShkcnZfZGF0YS0+cnhfZW5kIC0gZHJ2X2RhdGEtPnJ4KTsKIApAQCAtNzU5LDcgKzc1OSw3IEBACiAKIAkJLyoKIAkJICogUFhBMjV4X1NTUCBoYXMgbm8gdGltZW91dCwgc2V0IHVwIHJ4IHRocmVzaG91bGQgZm9yIHRoZQotCQkgKiByZW1haW5nIFJYIGJ5dGVzLgorCQkgKiByZW1haW5pbmcgUlggYnl0ZXMuCiAJCSAqLwogCQlpZiAocHhhMjV4X3NzcF9jb21wKGRydl9kYXRhKSkgewogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9zcGkuYyBiL2RyaXZlcnMvc3BpL3NwaS5jCmluZGV4IDM0YmIxN2YuLjgyYjlhNDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL3NwaS5jCisrKyBiL2RyaXZlcnMvc3BpL3NwaS5jCkBAIC05NTcsNyArOTU3LDcgQEAKICAqIGRyaXZlcnMgbWF5IERNQSBkaXJlY3RseSBpbnRvIGFuZCBvdXQgb2YgdGhlIG1lc3NhZ2UgYnVmZmVycy4KICAqCiAgKiBUaGlzIGNhbGwgc2hvdWxkIGJlIHVzZWQgYnkgZHJpdmVycyB0aGF0IHJlcXVpcmUgZXhjbHVzaXZlIGFjY2VzcyB0byB0aGUKLSAqIFNQSSBidXMuIEl0IGhhcyB0byBiZSBwcmVjZWVkZWQgYnkgYSBzcGlfYnVzX2xvY2sgY2FsbC4gVGhlIFNQSSBidXMgbXVzdAorICogU1BJIGJ1cy4gSXQgaGFzIHRvIGJlIHByZWNlZGVkIGJ5IGEgc3BpX2J1c19sb2NrIGNhbGwuIFRoZSBTUEkgYnVzIG11c3QKICAqIGJlIHJlbGVhc2VkIGJ5IGEgc3BpX2J1c191bmxvY2sgY2FsbCB3aGVuIHRoZSBleGNsdXNpdmUgYWNjZXNzIGlzIG92ZXIuCiAgKgogICogSXQgcmV0dXJucyB6ZXJvIG9uIHN1Y2Nlc3MsIGVsc2UgYSBuZWdhdGl2ZSBlcnJvciBjb2RlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvc3BpX2JmaW41eHguYyBiL2RyaXZlcnMvc3BpL3NwaV9iZmluNXh4LmMKaW5kZXggZjNhMWM1Mi4uZjcwNmRiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpX2JmaW41eHguYworKysgYi9kcml2ZXJzL3NwaS9zcGlfYmZpbjV4eC5jCkBAIC05MDUsNyArOTA1LDcgQEAKIAkJCSJJTyB3cml0ZSBlcnJvciFcbiIpOwogCQltZXNzYWdlLT5zdGF0ZSA9IEVSUk9SX1NUQVRFOwogCX0gZWxzZSB7Ci0JCS8qIFVwZGF0ZSB0b3RhbCBieXRlIHRyYW5zZmVyZWQgKi8KKwkJLyogVXBkYXRlIHRvdGFsIGJ5dGUgdHJhbnNmZXJyZWQgKi8KIAkJbWVzc2FnZS0+YWN0dWFsX2xlbmd0aCArPSBkcnZfZGF0YS0+bGVuX2luX2J5dGVzOwogCQkvKiBNb3ZlIHRvIG5leHQgdHJhbnNmZXIgb2YgdGhpcyBtc2cgKi8KIAkJbWVzc2FnZS0+c3RhdGUgPSBiZmluX3NwaV9uZXh0X3RyYW5zZmVyKGRydl9kYXRhKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaV9mc2xfZXNwaS5jIGIvZHJpdmVycy9zcGkvc3BpX2ZzbF9lc3BpLmMKaW5kZXggOTAwZTkyMS4uNDk2Zjg5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpX2ZzbF9lc3BpLmMKKysrIGIvZHJpdmVycy9zcGkvc3BpX2ZzbF9lc3BpLmMKQEAgLTQ3NCw3ICs0NzQsNyBAQAogCW1wYzh4eHhfc3BpID0gc3BpX21hc3Rlcl9nZXRfZGV2ZGF0YShzcGktPm1hc3Rlcik7CiAJcmVnX2Jhc2UgPSBtcGM4eHh4X3NwaS0+cmVnX2Jhc2U7CiAKLQlod19tb2RlID0gY3MtPmh3X21vZGU7IC8qIFNhdmUgb3JnaW5hbCBzZXR0aW5ncyAqLworCWh3X21vZGUgPSBjcy0+aHdfbW9kZTsgLyogU2F2ZSBvcmlnaW5hbCBzZXR0aW5ncyAqLwogCWNzLT5od19tb2RlID0gbXBjOHh4eF9zcGlfcmVhZF9yZWcoCiAJCQkmcmVnX2Jhc2UtPmNzbW9kZVtzcGktPmNoaXBfc2VsZWN0XSk7CiAJLyogbWFzayBvdXQgYml0cyB3ZSBhcmUgZ29pbmcgdG8gc2V0ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NzYi9wY2kuYyBiL2RyaXZlcnMvc3NiL3BjaS5jCmluZGV4IGE0NjdiMjAuLjZmMzQ5NjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3NiL3BjaS5jCisrKyBiL2RyaXZlcnMvc3NiL3BjaS5jCkBAIC02NzAsNyArNjcwLDcgQEAKIAkJc3NiX3ByaW50ayhLRVJOX0VSUiBQRlggIk5vIFNQUk9NIGF2YWlsYWJsZSFcbiIpOwogCQlyZXR1cm4gLUVOT0RFVjsKIAl9Ci0JaWYgKGJ1cy0+Y2hpcGNvLmRldikgewkvKiBjYW4gYmUgdW5hdmFpbGlibGUhICovCisJaWYgKGJ1cy0+Y2hpcGNvLmRldikgewkvKiBjYW4gYmUgdW5hdmFpbGFibGUhICovCiAJCS8qCiAJCSAqIGdldCBTUFJPTSBvZmZzZXQ6IFNTQl9TUFJPTV9CQVNFMSBleGNlcHQgZm9yCiAJCSAqIGNoaXBjb21tb24gcmV2ID49IDMxIG9yIGNoaXAgSUQgaXMgMHg0MzEyIGFuZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zc2Ivc3Byb20uYyBiL2RyaXZlcnMvc3NiL3Nwcm9tLmMKaW5kZXggNGY3Y2M4ZC4uNWYzNGQ3YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zc2Ivc3Byb20uYworKysgYi9kcml2ZXJzL3NzYi9zcHJvbS5jCkBAIC0xODUsNyArMTg1LDcgQEAKIAkvKiB0aGlzIHJvdXRpbmUgZGlmZmVycyBmcm9tIHNwZWNzIGFzIHdlIGRvIG5vdCBhY2Nlc3MgU1BST00gZGlyZWN0bHkKIAkgICBvbiBQQ01DSUEgKi8KIAlpZiAoYnVzLT5idXN0eXBlID09IFNTQl9CVVNUWVBFX1BDSSAmJgotCSAgICBidXMtPmNoaXBjby5kZXYgJiYJLyogY2FuIGJlIHVuYXZhaWxpYmxlISAqLworCSAgICBidXMtPmNoaXBjby5kZXYgJiYJLyogY2FuIGJlIHVuYXZhaWxhYmxlISAqLwogCSAgICBidXMtPmNoaXBjby5kZXYtPmlkLnJldmlzaW9uID49IDMxKQogCQlyZXR1cm4gYnVzLT5jaGlwY28uY2FwYWJpbGl0aWVzICYgU1NCX0NISVBDT19DQVBfU1BST007CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9LY29uZmlnIGIvZHJpdmVycy9zdGFnaW5nL0tjb25maWcKaW5kZXggMThiNDNmYy4uZGNhNGEwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL0tjb25maWcKKysrIGIvZHJpdmVycy9zdGFnaW5nL0tjb25maWcKQEAgLTExNyw4ICsxMTcsNiBAQAogCiBzb3VyY2UgImRyaXZlcnMvc3RhZ2luZy92bWUvS2NvbmZpZyIKIAotc291cmNlICJkcml2ZXJzL3N0YWdpbmcvbWVtcmFyL0tjb25maWciCi0KIHNvdXJjZSAiZHJpdmVycy9zdGFnaW5nL3NlcC9LY29uZmlnIgogCiBzb3VyY2UgImRyaXZlcnMvc3RhZ2luZy9paW8vS2NvbmZpZyIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9NYWtlZmlsZSBiL2RyaXZlcnMvc3RhZ2luZy9NYWtlZmlsZQppbmRleCBjZmQxM2NkLi5lYjkzMDEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9zdGFnaW5nL01ha2VmaWxlCkBAIC00MCw3ICs0MCw2IEBACiBvYmotJChDT05GSUdfVlQ2NjU2KQkJKz0gdnQ2NjU2Lwogb2JqLSQoQ09ORklHX0hZUEVSVikJCSs9IGh2Lwogb2JqLSQoQ09ORklHX1ZNRV9CVVMpCQkrPSB2bWUvCi1vYmotJChDT05GSUdfTVJTVF9SQVJfSEFORExFUikJKz0gbWVtcmFyLwogb2JqLSQoQ09ORklHX0RYX1NFUCkgICAgICAgICAgICArPSBzZXAvCiBvYmotJChDT05GSUdfSUlPKQkJKz0gaWlvLwogb2JqLSQoQ09ORklHX0NTNTUzNV9HUElPKQkrPSBjczU1MzVfZ3Bpby8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaHRjMi9BUjYwMDAvYXI2a19nbWJveF9oY2l1YXJ0LmMgYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2h0YzIvQVI2MDAwL2FyNmtfZ21ib3hfaGNpdWFydC5jCmluZGV4IGM2NDg4ZTAuLjQxMjIzZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaHRjMi9BUjYwMDAvYXI2a19nbWJveF9oY2l1YXJ0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9odGMyL0FSNjAwMC9hcjZrX2dtYm94X2hjaXVhcnQuYwpAQCAtMjM3LDcgKzIzNyw3IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgcFByb3QtPkNyZWRpdHNDdXJyZW50U2VlaykpOwogICAgICAgICAKICAgICAgICAgaWYgKHBQcm90LT5DcmVkaXRzQXZhaWxhYmxlID49IHBQcm90LT5DcmVkaXRzQ3VycmVudFNlZWspIHsKLSAgICAgICAgICAgICAgICAvKiB3ZSBoYXZlIGVub3VnaCBjcmVkaXRzIHRvIGZ1bGxmaWxsIGF0IGxlYXN0IDEgcGFja2V0IHdhaXRpbmcgaW4gdGhlIHF1ZXVlICovCisgICAgICAgICAgICAgICAgLyogd2UgaGF2ZSBlbm91Z2ggY3JlZGl0cyB0byBmdWxmaWxsIGF0IGxlYXN0IDEgcGFja2V0IHdhaXRpbmcgaW4gdGhlIHF1ZXVlICovCiAgICAgICAgICAgICBwUHJvdC0+Q3JlZGl0c0N1cnJlbnRTZWVrID0gMDsKICAgICAgICAgICAgIHBQcm90LT5TZW5kU3RhdGVGbGFncyAmPSB+SENJX1NFTkRfV0FJVF9DUkVESVRTOyAgCiAgICAgICAgICAgICBkb1BlbmRpbmdTZW5kcyA9IHRydWU7CkBAIC0yODUsNyArMjg1LDcgQEAKIHsKICAgICBzdHJ1Y3QgZ21ib3hfcHJvdG9faGNpX3VhcnQgICpwUHJvdCA9IChzdHJ1Y3QgZ21ib3hfcHJvdG9faGNpX3VhcnQgKilwQ29udGV4dDsgCiAgICAgCi0gICAgICAgIC8qIHRhcmdldCBhc3NlcnRpb24gb2NjdXJlZCAqLyAgICAgICAgICAgCisgICAgICAgIC8qIHRhcmdldCBhc3NlcnRpb24gb2NjdXJyZWQgKi8gICAgICAgICAgIAogICAgIE5vdGlmeVRyYW5zcG9ydEZhaWx1cmUocFByb3QsIFN0YXR1cyk7ICAKIH0KIApAQCAtNTA3LDcgKzUwNyw3IEBACiAgICAgICAgIAogICAgIH0gd2hpbGUgKGZhbHNlKTsKICAgICAgICAgCi0gICAgICAgIC8qIGNoZWNrIGlmIHdlIG5lZWQgdG8gZGlzYWJsZSB0aGUgcmVjaWV2ZXIgKi8KKyAgICAgICAgLyogY2hlY2sgaWYgd2UgbmVlZCB0byBkaXNhYmxlIHRoZSByZWNlaXZlciAqLwogICAgIGlmIChzdGF0dXMgfHwgYmxvY2tSZWN2KSB7CiAgICAgICAgIERldkdNYm94SVJRQWN0aW9uKHBQcm90LT5wRGV2LCBHTUJPWF9SRUNWX0lSUV9ESVNBQkxFLCBQUk9DX0lPX1NZTkMpOyAKICAgICB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvYWdncl9yZWN2X2FwaS5oIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2FnZ3JfcmVjdl9hcGkuaAppbmRleCA2N2EwNTg0Li41ZWFkNThkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvYWdncl9yZWN2X2FwaS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9hZ2dyX3JlY3ZfYXBpLmgKQEAgLTcyLDcgKzcyLDcgQEAKICAqIFRoaXMgZXZlbnQgaXMgdG8gaW5pdGlhdGUvbW9kaWZ5IHRoZSByZWNlaXZlIHNpZGUgd2luZG93LgogICogVGFyZ2V0IHdpbGwgc2VuZCBXTUlfQUREQkFfUkVRX0VWRU5USUQgZXZlbnQgdG8gaG9zdCAtIHRvIHNldHVwIAogICogcmVjdiByZS1vcmRlcmluZyBxdWV1ZXMuIFRhcmdldCB3aWxsIG5lZ290aWF0ZSBBRERCQSB3aXRoIHBlZXIsIAotICogYW5kIGluZGljYXRlIHZpYSB0aGlzIGV2ZW50IGFmdGVyIHN1Y2Nlc2Z1bGx5IGNvbXBsZXRpbmcgdGhlIAorICogYW5kIGluZGljYXRlIHZpYSB0aGlzIGV2ZW50IGFmdGVyIHN1Y2Nlc3NmdWxseSBjb21wbGV0aW5nIHRoZSAKICAqIG5lZ290aWF0aW9uLiBUaGlzIGhhcHBlbnMgaW4gdHdvIHNpdHVhdGlvbnM6CiAgKiAgMS4gSW5pdGlhbCBzZXR1cCBvZiBhZ2dyZWdhdGlvbgogICogIDIuIFJlbmVnb3RpYXRpb24gb2YgY3VycmVudCByZWN2IHdpbmRvdy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vYV9oY2kuaCBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vYV9oY2kuaAppbmRleCAwOGNiMDEzLi4zNzlkNjUyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi9hX2hjaS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vYV9oY2kuaApAQCAtMTI0LDcgKzEyNCw3IEBACiAjZGVmaW5lIFBBTF9OVU1fQ09NUExfREFUQV9CTE9DS19FVkVOVCAgICAgICAgICAgICAgMHg0OAogI2RlZmluZSBQQUxfU0hPUlRfUkFOR0VfTU9ERV9DSEFOR0VfQ09NUExfRVZFTlQgICAgIDB4NEMKICNkZWZpbmUgUEFMX0FNUF9TVEFUVVNfQ0hBTkdFX0VWRU5UICAgICAgICAgICAgICAgICAweDRECi0vKj09PT09PT09IEVuZCBvZiBQQUwgZXZlbnRzIGRlZmluaXRvbiA9PT09PT09PT09PT09PT09PSovCisvKj09PT09PT09IEVuZCBvZiBQQUwgZXZlbnRzIGRlZmluaXRpb24gPT09PT09PT09PT09PT09PT0qLwogCiAKIC8qPT09PT09PT0gVGltZW91dHMgKG5vdCBwYXJ0IG9mIEhDSSBjbWQsIGJ1dCBpbnB1dCB0byBQQUwgZW5naW5lKSA9PT09PT09PT0qLwpAQCAtNDMwLDcgKzQzMCw3IEBACiAgICAgdTggaHdfZXJyX2NvZGU7CiB9IFBPU1RQQUNLIEhDSV9FVkVOVF9IV19FUlI7CiAKLS8qIEZsdXNoIG9jY3VyZWQgZXZlbnQgKi8KKy8qIEZsdXNoIG9jY3VycmVkIGV2ZW50ICovCiAvKiBRb3MgVmlvbGF0aW9uIGV2ZW50ICovCiB0eXBlZGVmIHN0cnVjdCAgaGNpX2V2ZW50X2hhbmRsZV90IHsKICAgICB1OCBldmVudF9jb2RlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi9kYmdsb2cuaCBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vZGJnbG9nLmgKaW5kZXggM2EzZDAwZC4uYjdhMTIzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi9kYmdsb2cuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvY29tbW9uL2RiZ2xvZy5oCkBAIC00NCw3ICs0NCw3IEBACiAjZGVmaW5lIERCR0xPR19NT0RVTEVJRF9OVU1fTUFYICAgICAgICAgIDE2IC8qIFVwcGVyIGxpbWl0IGlzIHdpZHRoIG9mIG1hc2sgKi8KIAogLyoKLSAqIFBsZWFzZSBlbnN1cmUgdGhhdCB0aGUgZGVmaW5pdGlvbiBvZiBhbnkgbmV3IG1vZHVsZSBpbnRyZHVjZWQgaXMgY2FwdHVyZWQKKyAqIFBsZWFzZSBlbnN1cmUgdGhhdCB0aGUgZGVmaW5pdGlvbiBvZiBhbnkgbmV3IG1vZHVsZSBpbnRyb2R1Y2VkIGlzIGNhcHR1cmVkCiAgKiBiZXR3ZWVuIHRoZSBEQkdMT0dfTU9EVUxFSURfU1RBUlQgYW5kIERCR0xPR19NT0RVTEVJRF9FTkQgZGVmaW5lcy4gVGhlIAogICogc3RydWN0dXJlIGlzIHJlcXVpcmVkIGZvciB0aGUgcGFyc2VyIHRvIGNvcnJlY3RseSBwaWNrIHVwIHRoZSB2YWx1ZXMgZm9yCiAgKiBkaWZmZXJlbnQgbW9kdWxlcy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vZXBwaW5nX3Rlc3QuaCBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vZXBwaW5nX3Rlc3QuaAppbmRleCA1YzQwZDhhLi43MDI3ZmFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvY29tbW9uL2VwcGluZ190ZXN0LmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi9lcHBpbmdfdGVzdC5oCkBAIC05Miw3ICs5Miw3IEBACiAjZGVmaW5lIEVQUElOR19DTURfUkVTRVRfUkVDVl9DTlQgICAgICAgMiAgIC8qIHJlc2V0IHJlY3YgY291bnQgKi8KICNkZWZpbmUgRVBQSU5HX0NNRF9DQVBUVVJFX1JFQ1ZfQ05UICAgICAzICAgLyogZmV0Y2ggcmVjdiBjb3VudCwgNC1ieXRlIGNvdW50IHJldHVybmVkIGluIENtZEJ1ZmZlcl90ICovCiAjZGVmaW5lIEVQUElOR19DTURfTk9fRUNITyAgICAgICAgICAgICAgNCAgIC8qIG5vbi1lY2hvIHBhY2tldCB0ZXN0ICh0eC1vbmx5KSAqLwotI2RlZmluZSBFUFBJTkdfQ01EX0NPTlRfUlhfU1RBUlQgICAgICAgIDUgICAvKiBjb250aW5vdXMgUlggcGFja2V0cywgcGFyYW1ldGVycyBhcmUgaW4gQ21kQnVmZmVyX2ggKi8KKyNkZWZpbmUgRVBQSU5HX0NNRF9DT05UX1JYX1NUQVJUICAgICAgICA1ICAgLyogY29udGludW91cyBSWCBwYWNrZXRzLCBwYXJhbWV0ZXJzIGFyZSBpbiBDbWRCdWZmZXJfaCAqLwogI2RlZmluZSBFUFBJTkdfQ01EX0NPTlRfUlhfU1RPUCAgICAgICAgIDYgICAvKiBzdG9wIGNvbnRpbnVvdXMgUlggcGFja2V0IHRyYW5zbWlzc2lvbiAqLwogCiAgICAgLyogdGVzdCBjb21tYW5kIHBhcmFtZXRlcnMgbWF5IGJlIG5vIG1vcmUgdGhhbiA4IGJ5dGVzICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvY29tbW9uL2luaV9kc2V0LmggYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvY29tbW9uL2luaV9kc2V0LmgKaW5kZXggOGJmYzc1OS4uYTllMDVmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi9pbmlfZHNldC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vaW5pX2RzZXQuaApAQCAtMzEsNyArMzEsNyBAQAogICovCiB0eXBlZGVmIGVudW0gewogI2lmIGRlZmluZWQoQVI2MDAyX1JFVjQpIHx8IGRlZmluZWQoQVI2MDAzKQotLyogQWRkIHRoZXNlIGRlZmluaXRpb25zIGZvciBjb21wYXRhYmlsaXR5ICAqLworLyogQWRkIHRoZXNlIGRlZmluaXRpb25zIGZvciBjb21wYXRpYmlsaXR5ICAqLwogI2RlZmluZSBXSEFMX0lOSV9EQVRBX0lEX0JCX1JGR0FJTl9MTkExIFdIQUxfSU5JX0RBVEFfSURfQkJfUkZHQUlOCiAjZGVmaW5lIFdIQUxfSU5JX0RBVEFfSURfQkJfUkZHQUlOX0xOQTIgV0hBTF9JTklfREFUQV9JRF9CQl9SRkdBSU4KICAgICBXSEFMX0lOSV9EQVRBX0lEX05VTEwgICAgICAgICAgICAgICA9MCwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vdGVzdGNtZC5oIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi90ZXN0Y21kLmgKaW5kZXggOWNhMWYyYS4uN2Q5NGFlZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi90ZXN0Y21kLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi90ZXN0Y21kLmgKQEAgLTQzLDggKzQzLDggQEAKICAgICBQTjE1X1BBVFRFUk4KIH1UWF9EQVRBX1BBVFRFUk47CiAKLS8qIENvbnRpbm91cyB0eAotICAgbW9kZSA6IFRDTURfQ09OVF9UWF9PRkYgLSBEaXNhYmxpbmcgY29udGlub3VzIHR4CisvKiBDb250aW51b3VzIHR4CisgICBtb2RlIDogVENNRF9DT05UX1RYX09GRiAtIERpc2FibGluZyBjb250aW51b3VzIHR4CiAgICAgICAgICAgVENNRF9DT05UX1RYX1NJTkUgLSBFbmFibGUgY29udGludW91cyB1bm1vZHVsYXRlZCB0eAogICAgICAgICAgIFRDTURfQ09OVF9UWF9GUkFNRS0gRW5hYmxlIGNvbnRpbnVvdXMgbW9kdWxhdGVkIHR4CiAgICBmcmVxIDogQ2hhbm5lbCBmcmVxIGluIE1oei4gKGUuZyAyNDEyIGZvciBjaGFubmVsIDEgaW4gMTEgZykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vd21pLmggYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvY29tbW9uL3dtaS5oCmluZGV4IGM2NDVhZjMuLjRlNjM0MzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vd21pLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2NvbW1vbi93bWkuaApAQCAtMTU2OCw4ICsxNTY4LDggQEAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3dpdGNoIHRvIHBzLXBvbGwgbW9kZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHQgPSAzICovCiAKLQl1MzIgc2NvQ29udFN0b21wTWF4OyAgIC8qIG1heCBudW1iZXIgb2YgY29udGlub3VzIHN0b21wIGFsbG93ZWQgaW4gb3B0IG1vZGUuCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIGV4Y2VkZGVkIHN3aXRjaCB0byBwc3BvbGwgbW9kZQorCXUzMiBzY29Db250U3RvbXBNYXg7ICAgLyogbWF4IG51bWJlciBvZiBjb250aW51b3VzIHN0b21wIGFsbG93ZWQgaW4gb3B0IG1vZGUuCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIGV4Y2VlZGVkIHN3aXRjaCB0byBwc3BvbGwgbW9kZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVmYXVsdCA9IDMgKi8KIAogCXUzMiBzY29NaW5sb3dSYXRlTWJwczsgLyogTG93IHJhdGUgdGhyZXNob2xkICovCkBAIC0yMDg0LDcgKzIwODQsNyBAQAogLyoKICAqIEJTUyBJTkZPIEhEUiB2ZXJzaW9uIDIuMAogICogV2l0aCA2IGJ5dGVzIEhUQyBoZWFkZXIgYW5kIDYgYnl0ZXMgb2YgV01JIGhlYWRlcgotICogV01JX0JTU19JTkZPX0hEUiBjYW5ub3QgYmUgYWNjb21vZGF0ZWQgaW4gdGhlIHJlbW92ZWQgODAyLjExIG1hbmFnZW1lbnQKKyAqIFdNSV9CU1NfSU5GT19IRFIgY2Fubm90IGJlIGFjY29tbW9kYXRlZCBpbiB0aGUgcmVtb3ZlZCA4MDIuMTEgbWFuYWdlbWVudAogICogaGVhZGVyIHNwYWNlLgogICogLSBSZWR1Y2UgdGhlIGllTWFzayB0byAyIGJ5dGVzIGFzIG9ubHkgdHdvIGJpdCBmbGFncyBhcmUgdXNlZAogICogLSBSZW1vdmUgcnNzaSBhbmQgY29tcHV0ZSBpdCBvbiB0aGUgaG9zdC4gcnNzaSA9IHNuciAtIDk1CkBAIC0yOTExLDcgKzI5MTEsNyBAQAogICAgIHU4IHBrdElEOyAvKiBwYWNrZXQgSUQgdG8gaWRlbnRpZnkgcGFyZW50IHBhY2tldCAqLwogICAgIHU4IHJhdGVJZHg7IC8qIHJhdGUgaW5kZXggb24gc3VjY2Vzc2Z1bCB0cmFuc21pc3Npb24gKi8KICAgICB1OCBhY2tGYWlsdXJlczsgLyogbnVtYmVyIG9mIEFDSyBmYWlsdXJlcyBpbiB0eCBhdHRlbXB0ICovCi0jaWYgMCAvKiBvcHRpb25hbCBwYXJhbXMgY3VycmVudGx5IG9tbWl0dGVkLiAqLworI2lmIDAgLyogb3B0aW9uYWwgcGFyYW1zIGN1cnJlbnRseSBvbWl0dGVkLiAqLwogICAgIHUzMiBxdWV1ZURlbGF5OyAvLyB1c2VjIGRlbGF5IG1lYXN1cmVkIFR4IFN0YXJ0IHRpbWUgLSBob3N0IGRlbGl2ZXJ5IHRpbWUKICAgICB1MzIgbWVkaWFEZWxheTsgLy8gdXNlYyBkZWxheSBtZWFzdXJlZCBBQ0sgcnggdGltZSAtIGhvc3QgZGVsaXZlcnkgdGltZQogI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvY29tbW9uL3dtaXguaCBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vd21peC5oCmluZGV4IDVlYmI4MjguLjM2YWNiYTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vd21peC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9jb21tb24vd21peC5oCkBAIC0xOTEsNyArMTkxLDcgQEAKIH0gUE9TVFBBQ0sgV01JWF9HUElPX0lOVFJfQUNLX0NNRDsKIAogLyoKLSAqIFRhcmdldCBpbmZvcm1zIEhvc3Qgb2YgR1BJTyBpbnRlcnJ1cHRzIHRoYXQgaGF2ZSBvY3VycmVkIHNpbmNlIHRoZQorICogVGFyZ2V0IGluZm9ybXMgSG9zdCBvZiBHUElPIGludGVycnVwdHMgdGhhdCBoYXZlIG9jY3VycmVkIHNpbmNlIHRoZQogICogbGFzdCBXTUlYX0dJUE9fSU5UUl9BQ0tfQ01EIHdhcyByZWNlaXZlZC4gIEFkZGl0aW9uYWwgaW5mb3JtYXRpb24gLS0KICAqIHRoZSBjdXJyZW50IEdQSU8gaW5wdXQgdmFsdWVzIGlzIHByb3ZpZGVkIC0tIGluIG9yZGVyIHRvIHN1cHBvcnQKICAqIHVzZSBvZiBhIEdQSU8gaW50ZXJydXB0IGFzIGEgRGF0YSBWYWxpZCBzaWduYWwgZm9yIG90aGVyIEdQSU8gcGlucy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9odGNfYXBpLmggYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL2luY2x1ZGUvaHRjX2FwaS5oCmluZGV4IDFiYzI0ODguLjRmYjc2NzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvaW5jbHVkZS9odGNfYXBpLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9pbmNsdWRlL2h0Y19hcGkuaApAQCAtMjA5LDcgKzIwOSw3IEBACiB0eXBlZGVmIGVudW0gX0hUQ19DUkVESVRfRElTVF9SRUFTT04gewogICAgIEhUQ19DUkVESVRfRElTVF9TRU5EX0NPTVBMRVRFID0gMCwgICAgIC8qIGNyZWRpdHMgYXZhaWxhYmxlIGFzIGEgcmVzdWx0IG9mIGNvbXBsZXRlZAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbmQgb3BlcmF0aW9ucyAoTUFOREFUT1JZKSByZXN1bHRpbmcgaW4gY3JlZGl0IHJlcG9ydHMgKi8KLSAgICBIVENfQ1JFRElUX0RJU1RfQUNUSVZJVFlfQ0hBTkdFID0gMSwgICAvKiBhIGNoYW5nZSBpbiBlbmRwb2ludCBhY3Rpdml0eSBvY2N1cmVkIChPUFRJT05BTCkgKi8KKyAgICBIVENfQ1JFRElUX0RJU1RfQUNUSVZJVFlfQ0hBTkdFID0gMSwgICAvKiBhIGNoYW5nZSBpbiBlbmRwb2ludCBhY3Rpdml0eSBvY2N1cnJlZCAoT1BUSU9OQUwpICovCiAgICAgSFRDX0NSRURJVF9ESVNUX1NFRUtfQ1JFRElUUywgICAgICAgICAgLyogYW4gZW5kcG9pbnQgbmVlZHMgdG8gInNlZWsiIGNyZWRpdHMgKE9QVElPTkFMKSAqLwogICAgIEhUQ19EVU1QX0NSRURJVF9TVEFURSAgICAgICAgICAgICAgICAgIC8qIGZvciBkZWJ1Z2dpbmcsIGR1bXAgYW55IHN0YXRlIGluZm9ybWF0aW9uIHRoYXQgaXMga2VwdCBieQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoZSBkaXN0cmlidXRpb24gZnVuY3Rpb24gKi8KQEAgLTI1Myw3ICsyNTMsNyBAQAogICAgIHUzMiBSeFBhY2tldHNCdW5kbGVkOyAgICAgICAvKiBjb3VudCBvZiByZWN2IHBhY2tldHMgcmVjZWl2ZWQgaW4gYSBidW5kbGUgKi8KICAgICB1MzIgUnhCdW5kbGVMb29rQWhlYWRzOyAgICAgLyogY291bnQgb2YgbnVtYmVyIG9mIGJ1bmRsZWQgbG9va2FoZWFkcyAqLwogICAgIHUzMiBSeEJ1bmRsZUluZEZyb21IZHI7ICAgICAvKiBjb3VudCBvZiB0aGUgbnVtYmVyIG9mIGJ1bmRsZSBpbmRpY2F0aW9ucyBmcm9tIHRoZSBIVEMgaGVhZGVyICovCi0gICAgdTMyIFJ4QWxsb2NUaHJlc2hIaXQ7ICAgICAgIC8qIGNvdW50IG9mIHRoZSBudW1iZXIgb2YgdGltZXMgdGhlIHJlY3YgYWxsb2NhdGlvbiB0aHJlc2hob2xkIHdhcyBoaXQgKi8KKyAgICB1MzIgUnhBbGxvY1RocmVzaEhpdDsgICAgICAgLyogY291bnQgb2YgdGhlIG51bWJlciBvZiB0aW1lcyB0aGUgcmVjdiBhbGxvY2F0aW9uIHRocmVzaG9sZCB3YXMgaGl0ICovCiAgICAgdTMyIFJ4QWxsb2NUaHJlc2hCeXRlczsgICAgIC8qIHRvdGFsIG51bWJlciBvZiBieXRlcyAqLwogfTsKIApAQCAtMzkxLDcgKzM5MSw3IEBACiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKi8KIHZvaWQgICAgICAgIEhUQ1N0b3AoSFRDX0hBTkRMRSBIVENIYW5kbGUpOwogLyorKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwotICBAZGVzYzogRGVzdG9yeSBIVEMgc2VydmljZQorICBAZGVzYzogRGVzdHJveSBIVEMgc2VydmljZQogICBAZnVuY3Rpb24gbmFtZTogSFRDRGVzdHJveQogICBAaW5wdXQ6IEhUQ0hhbmRsZSAKICAgQG91dHB1dDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvbWlzY2Rydi9jcmVkaXRfZGlzdC5jIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9taXNjZHJ2L2NyZWRpdF9kaXN0LmMKaW5kZXggYWU1NGUxZi4uMzNmYTAyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9taXNjZHJ2L2NyZWRpdF9kaXN0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9taXNjZHJ2L2NyZWRpdF9kaXN0LmMKQEAgLTM0MSw3ICszNDEsNyBAQAogICAgICAgICBjcmVkaXRzID0gbWluKHBDcmVkSW5mby0+Q3VycmVudEZyZWVDcmVkaXRzLHBFUERpc3QtPlR4Q3JlZGl0c1NlZWspOwogCiAgICAgICAgIGlmIChjcmVkaXRzID49IHBFUERpc3QtPlR4Q3JlZGl0c1NlZWspIHsKLSAgICAgICAgICAgICAgICAvKiB3ZSBmb3VuZCBzb21lIHRvIGZ1bGxmaWxsIHRoZSBzZWVrIHJlcXVlc3QgKi8KKyAgICAgICAgICAgICAgICAvKiB3ZSBmb3VuZCBzb21lIHRvIGZ1bGZpbGwgdGhlIHNlZWsgcmVxdWVzdCAqLwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KIApAQCAtMzY0LDggKzM2NCw4IEBACiAKICAgICAgICAgICAgIGlmICgocEN1ckVwRGlzdC0+VHhDcmVkaXRzQXNzaWduZWQgLSBuZWVkKSA+PSBwQ3VyRXBEaXN0LT5UeENyZWRpdHNNaW4pIHsKICAgICAgICAgICAgICAgICAgICAgLyogdGhlIGN1cnJlbnQgb25lIGhhcyBiZWVuIGFsbG9jYXRlZCBtb3JlIHRoYW4gaXQncyBtaW5pbXVtIGFuZCBpdAotICAgICAgICAgICAgICAgICAgICAgKiBoYXMgZW5vdWdoIGNyZWRpdHMgYXNzaWduZWQgYWJvdmUgaXQncyBtaW5pbXVtIHRvIGZ1bGxmaWxsIG91ciBuZWVkCi0gICAgICAgICAgICAgICAgICAgICAqIHRyeSB0byB0YWtlIGF3YXkganVzdCBlbm91Z2ggdG8gZnVsbGZpbGwgb3VyIG5lZWQgKi8KKyAgICAgICAgICAgICAgICAgICAgICogaGFzIGVub3VnaCBjcmVkaXRzIGFzc2lnbmVkIGFib3ZlIGl0J3MgbWluaW11bSB0byBmdWxmaWxsIG91ciBuZWVkCisgICAgICAgICAgICAgICAgICAgICAqIHRyeSB0byB0YWtlIGF3YXkganVzdCBlbm91Z2ggdG8gZnVsZmlsbCBvdXIgbmVlZCAqLwogICAgICAgICAgICAgICAgIFJlZHVjZUNyZWRpdHMocENyZWRJbmZvLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcEN1ckVwRGlzdCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBDdXJFcERpc3QtPlR4Q3JlZGl0c0Fzc2lnbmVkIC0gbmVlZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL29zL2xpbnV4L2FyNjAwMF9hbmRyb2lkLmMgYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL29zL2xpbnV4L2FyNjAwMF9hbmRyb2lkLmMKaW5kZXggYzk2ZjZlOS4uNGFhNzVlZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9vcy9saW51eC9hcjYwMDBfYW5kcm9pZC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvb3MvbGludXgvYXI2MDAwX2FuZHJvaWQuYwpAQCAtMzcyLDcgKzM3Miw3IEBACiAgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICAgICAgaWYgKG5lZWRXYWtlKSB7Ci0gICAgICAgICAgICAvKiBrZWVwIGhvc3Qgd2FrZSB1cCBpZiB0aGVyZSBpcyBhbnkgZXZlbnQgYW5kIHBhY2thdGUgY29tbWluZyBpbiovCisgICAgICAgICAgICAvKiBrZWVwIGhvc3Qgd2FrZSB1cCBpZiB0aGVyZSBpcyBhbnkgZXZlbnQgYW5kIHBhY2thdGUgY29taW5nIGluKi8KICAgICAgICAgICAgIGlmICh3b3dsZWRvbikgewogICAgICAgICAgICAgICAgIGNoYXIgYnVmWzMyXTsKICAgICAgICAgICAgICAgICBpbnQgbGVuID0gc3ByaW50ZihidWYsICJvbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9vcy9saW51eC9hcjYwMDBfZHJ2LmMgYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL29zL2xpbnV4L2FyNjAwMF9kcnYuYwppbmRleCAyN2NiMDJkLi45N2Q2Y2U2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL29zL2xpbnV4L2FyNjAwMF9kcnYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL29zL2xpbnV4L2FyNjAwMF9kcnYuYwpAQCAtNTIwLDcgKzUyMCw3IEBACiBpbnQKIGFyNjAwMF9kYmdsb2dfZ2V0X2RlYnVnX2xvZ3Moc3RydWN0IGFyNl9zb2Z0YyAqYXIpCiB7Ci0gICAgdTMyIGRhdGFbOF07IC8qIFNob3VsZCBiZSBhYmxlIHRvIGFjY29tb2RhdGUgc3RydWN0IGRiZ2xvZ19idWZfcyAqLworICAgIHUzMiBkYXRhWzhdOyAvKiBTaG91bGQgYmUgYWJsZSB0byBhY2NvbW1vZGF0ZSBzdHJ1Y3QgZGJnbG9nX2J1Zl9zICovCiAgICAgdTMyIGFkZHJlc3M7CiAgICAgdTMyIGxlbmd0aDsKICAgICB1MzIgZHJvcHBlZDsKQEAgLTIwNjMsNyArMjA2Myw3IEBACiAgKiAtIEluIGNhc2Ugb2Ygc3VycHJpc2UgcmVtb3ZhbCwgdGhlIGhjZCBhbHJlYWR5IGZyZWVzIHVwIHRoZSBwZW5kaW5nCiAgKiAgIGZvciB0aGUgZGV2aWNlIGFuZCBoZW5jZSB0aGVyZSBpcyBubyBuZWVkIHRvIHVucmVnaXN0ZXIgdGhlIGZ1bmN0aW9uCiAgKiAgIGRyaXZlciBpbm9yZGVyIHRvIGdldCB0aGVzZSByZXF1ZXN0cy4gRm9yIHBsYW5uZWQgcmVtb3ZhbCwgdGhlIGZ1bmN0aW9uCi0gKiAgIGRyaXZlciBoYXMgdG8gZXhwbGljdGx5IHVucmVnaXN0ZXIgaXRzZWxmIHRvIGhhdmUgdGhlIGhjZCByZXR1cm4gYWxsIHRoZQorICogICBkcml2ZXIgaGFzIHRvIGV4cGxpY2l0bHkgdW5yZWdpc3RlciBpdHNlbGYgdG8gaGF2ZSB0aGUgaGNkIHJldHVybiBhbGwgdGhlCiAgKiAgIHBlbmRpbmcgcmVxdWVzdHMgYmVmb3JlIHRoZSBkYXRhIHN0cnVjdHVyZXMgZm9yIHRoZSBkZXZpY2VzIGFyZSBmcmVlZCB1cC4KICAqICAgTm90ZSB0aGF0IGFzIHBlciB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbiwgdGhlIGZ1bmN0aW9uIGRyaXZlciB3aWxsCiAgKiAgIGVuZCB1cCByZWxlYXNpbmcgYWxsIHRoZSBkZXZpY2VzIHNpbmNlIHRoZXJlIGlzIG5vIEFQSSB0byBzZWxlY3RpdmVseQpAQCAtMjk4Miw3ICsyOTgyLDcgQEAKICAgICAvKiBJZiB0YXJnZXQgaXMgbm90IGFzc29jaWF0ZWQgKi8KICAgICBpZiggKCFhci0+YXJDb25uZWN0ZWQgJiYgIWJ5cGFzc3dtaSkKICNpZmRlZiBDT05GSUdfSE9TVF9UQ01EX1NVUFBPUlQKLSAgICAgLyogVENNRCBkb2VzbnQgc3VwcG9ydCBhbnkgZGF0YSwgZnJlZSB0aGUgYnVmIGFuZCByZXR1cm4gKi8KKyAgICAgLyogVENNRCBkb2Vzbid0IHN1cHBvcnQgYW55IGRhdGEsIGZyZWUgdGhlIGJ1ZiBhbmQgcmV0dXJuICovCiAgICAgfHwgKGFyLT5hclRhcmdldE1vZGUgPT0gQVI2MDAwX1RDTURfTU9ERSkKICNlbmRpZgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICApIHsKQEAgLTYzOTMsNyArNjM5Myw3IEBACiAvKgogICogQWRkIHN1cHBvcnQgZm9yIGFkZGluZyBhbmQgcmVtb3ZpbmcgYSB2aXJ0dWFsIGFkYXB0ZXIgZm9yIHNvZnQgQVAuCiAgKiBTb21lIE9TIHJlcXVpcmVzIGRpZmZlcmVudCBhZGFwdGVycyBuYW1lcyBmb3Igc3RhdGlvbiBhbmQgc29mdCBBUCBtb2RlLgotICogVG8gc3VwcG9ydCB0aGVzZSByZXF1aXJlbWVudCwgY3JlYXRlIGFuZCBkZXN0b3J5IGEgbmV0ZGV2aWNlICBpbnN0YW5jZQorICogVG8gc3VwcG9ydCB0aGVzZSByZXF1aXJlbWVudCwgY3JlYXRlIGFuZCBkZXN0cm95IGEgbmV0ZGV2aWNlICBpbnN0YW5jZQogICogd2hlbiB0aGUgQVAgbW9kZSBpcyBvcGVyYXRpb25hbC4gQSBmdWxsIGZsZWRnZWQgc3VwcG9ydCBmb3IgdmlydWFsIGRldmljZQogICogaXMgbm90IGltcGxlbWVudGVkLiBSYXRoZXIgYSB2aXJ0dWFsIGludGVyZmFjZSBpcyBjcmVhdGVkIGFuZCBpcyBsaW5rZWQKICAqIHdpdGggdGhlIGV4aXN0aW5nIHBoeXNpY2FsIGRldmljZSBpbnN0YW5jZSBkdXJpbmcgdGhlIG9wZXJhdGlvbiBvZiB0aGUgCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL3dtaS93bWkuYyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvd21pL3dtaS5jCmluZGV4IDBkZGFlZTIuLmEwMGJmMGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvd21pL3dtaS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvd21pL3dtaS5jCkBAIC00ODY3LDcgKzQ4NjcsNyBAQAogI2lmZGVmIENPTkZJR19IT1NUX1RDTURfU1VQUE9SVAogLyogV01JICBsYXllciBkb2Vzbid0IG5lZWQgdG8ga25vdyB0aGUgZGF0YSB0eXBlIG9mIHRoZSB0ZXN0IGNtZC4KICAgIFRoaXMgd291bGQgYmUgYmVuZWZpY2lhbCBmb3IgY3VzdG9tZXJzIGxpa2UgUXVhbGNvbW0sIHdobyBtaWdodAotICAgaGF2ZSBkaWZmZXJlbnQgdGVzdCBjb21tYW5kIHJlcXVpcmVtZW50cyBmcm9tIGRpZmZlcm50IG1hbnVmYWN0dXJlcnMKKyAgIGhhdmUgZGlmZmVyZW50IHRlc3QgY29tbWFuZCByZXF1aXJlbWVudHMgZnJvbSBkaWZmZXJlbnQgbWFudWZhY3R1cmVycwogICovCiBpbnQKIHdtaV90ZXN0X2NtZChzdHJ1Y3Qgd21pX3QgKndtaXAsIHU4ICpidWYsIHUzMiBsZW4pCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0FkYXB0ZXIuaCBiL2RyaXZlcnMvc3RhZ2luZy9iY20vQWRhcHRlci5oCmluZGV4IDMyOTA5ZTIuLjIwY2NhMjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9iY20vQWRhcHRlci5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vQWRhcHRlci5oCkBAIC00MTIsNyArNDEyLDcgQEAKIAogCS8vIHRoaXMgdG8ga2VlcCB0cmFjayBvZiB0aGUgVHggYW5kIFJ4IE1haWxCb3ggUmVnaXN0ZXJzLgogCWF0b21pY190CQkgICAgQ3Vyck51bUZyZWVUeERlc2M7Ci0JLy8gdG8ga2VlcCB0cmFjayB0aGUgbm8gb2YgYnl0ZSByZWNpZXZlZAorCS8vIHRvIGtlZXAgdHJhY2sgdGhlIG5vIG9mIGJ5dGUgcmVjZWl2ZWQKIAlVU0hPUlQJCQkJUHJldk51bVJlY3ZEZXNjczsKIAlVU0hPUlQJCQkJQ3Vyck51bVJlY3ZEZXNjczsKIAlVSU5UCQkJCXUzMlRvdGFsRFNEOwpAQCAtNTI3LDcgKzUyNyw3IEBACiAJQk9PTEVBTgkJCWJTdGF0dXNXcml0ZTsKIAlVSU5UCQkJdWlOVk1EU0RTaXplOwogCVVJTlQJCQl1aVZlbmRvckV4dG5GbGFnOwotCSAvL2l0IHdpbGwgYWx3YXlzIHJlcHJlc2VudCBjaG9vc2VkIERTRCBhdCBhbnkgcG9pbnQgb2YgdGltZS4KKwkgLy9pdCB3aWxsIGFsd2F5cyByZXByZXNlbnQgY2hvc2VuIERTRCBhdCBhbnkgcG9pbnQgb2YgdGltZS4KIAkgLy8gR2VuZXJhbGx5IGl0IGlzIEFjdGl2ZSBEU0QgYnV0IGluIGNhc2Ugb2YgTlZNIFJEL1dSIGl0IG1pZ2h0IGJlIGRpZmZlcmVudC4KIAlVSU5UCQkJdWxGbGFzaENhbFN0YXJ0OwogCVVMT05HICAgICAgICAgICAgICAgICAgIHVsRmxhc2hDb250cm9sU2VjdGlvblN0YXJ0OwpAQCAtNTQ2LDEwICs1NDYsMTAgQEAKIAlQRkxBU0hfQ1NfSU5GTyBwc0ZsYXNoQ1NJbmZvIDsKIAlQRkxBU0gyWF9WRU5ET1JTUEVDSUZJQ19JTkZPIHBzRmxhc2gyeFZlbmRvckluZm87CiAJVUlOVCB1aUZsYXNoQmFzZUFkZDsgLy9GbGFzaCBzdGFydCBhZGRyZXNzCi0JVUlOVCB1aUFjdGl2ZUlTT09mZnNldDsgLy9BY3RpdmUgSVNPIG9mZnNldCBjaG9vc2VuIGJlZm9yZSBmL3cgZG93bmxvYWQKKwlVSU5UIHVpQWN0aXZlSVNPT2Zmc2V0OyAvL0FjdGl2ZSBJU08gb2Zmc2V0IGNob3NlbiBiZWZvcmUgZi93IGRvd25sb2FkCiAJRkxBU0gyWF9TRUNUSU9OX1ZBTCBlQWN0aXZlSVNPOyAvL0FjdGl2ZSBJU08gc2VjdGlvbiB2YWwKLQlGTEFTSDJYX1NFQ1RJT05fVkFMIGVBY3RpdmVEU0Q7CS8vQWN0aXZlIERTRCB2YWwgY2hvb3NlbiBiZWZvcmUgZi93IGRvd25sb2FkCi0JVUlOVCB1aUFjdGl2ZURTRE9mZnNldEF0RndEbGQ7ICAvL0ZvciBhY2Nlc3NpbmcgQWN0aXZlIERTRCBjaG9vc2VuIGJlZm9yZSBmL3cgZG93bmxvYWQKKwlGTEFTSDJYX1NFQ1RJT05fVkFMIGVBY3RpdmVEU0Q7CS8vQWN0aXZlIERTRCB2YWwgY2hvc2VuIGJlZm9yZSBmL3cgZG93bmxvYWQKKwlVSU5UIHVpQWN0aXZlRFNET2Zmc2V0QXRGd0RsZDsgIC8vRm9yIGFjY2Vzc2luZyBBY3RpdmUgRFNEIGNob3NlbiBiZWZvcmUgZi93IGRvd25sb2FkCiAJVUlOVCB1aUZsYXNoTGF5b3V0TWFqb3JWZXJzaW9uIDsKIAlVSU5UIHVpRmxhc2hMYXlvdXRNaW5vclZlcnNpb247CiAJQk9PTEVBTiBiQWxsRFNEV3JpdGVBbGxvdyA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0NtSG9zdC5jIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9DbUhvc3QuYwppbmRleCA5YmUxODRmLi5jMGVlOTVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0NtSG9zdC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vQ21Ib3N0LmMKQEAgLTM4NCw3ICszODQsNyBAQAogCQl9CiAJCWlmKHBzZkNTVHlwZS0+Y0NQYWNrZXRDbGFzc2lmaWNhdGlvblJ1bGUudThQcm90b2NvbCA9PSAwKQogCQl7Ci0JCQkvL3dlIGRpZG50IGdldCBwcm90b2NvbCBmaWVsZCBmaWxsZWQgaW4gYnkgdGhlIEJTCisJCQkvL3dlIGRpZG4ndCBnZXQgcHJvdG9jb2wgZmllbGQgZmlsbGVkIGluIGJ5IHRoZSBCUwogCQkJcHN0Q2xhc3NpZmllckVudHJ5LT51Y1Byb3RvY29sTGVuZ3RoPTA7CiAJCX0KIAkJZWxzZQpAQCAtODc5LDcgKzg3OSw3IEBACiAKIAkJCQkJCS8qCiAJCQkJCQkJUGFzc2luZyB0aGUgYXJndW1lbnQgdThQSFNJIGluc3RlYWQgb2YgY2xzaWQuIEJlY2F1c2UgZm9yIERMIHdpdGggbm8gY2xhc3NpZmllciBydWxlLAotCQkJCQkJCWNsc2lkIHdpbGwgYmUgemVybyBoZW5jZSB3ZSBjYW50IGhhdmUgbXVsdGlwbGUgUEhTIHJ1bGVzIGZvciB0aGUgc2FtZSBTRi4KKwkJCQkJCQljbHNpZCB3aWxsIGJlIHplcm8gaGVuY2Ugd2UgY2FuJ3QgaGF2ZSBtdWx0aXBsZSBQSFMgcnVsZXMgZm9yIHRoZSBzYW1lIFNGLgogCQkJCQkJCVRvIHN1cHBvcnQgbXVsdGlwbGUgUEhTIHJ1bGUsIHBhc3NpbmcgdThQSFNJLgogCQkJCQkJKi8KIApAQCAtMTEwMyw3ICsxMTAzLDcgQEAKIAlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgInU4VHJhZmZpY0luZGljYXRpb25QcmVmZXJlbmNlCTogMHglWCIsCiAJCXBzdEFkZEluZGljYXRpb24tPnNmQXV0aG9yaXplZFNldC51OFRyYWZmaWNJbmRpY2F0aW9uUHJlZmVyZW5jZSk7CiAKLQlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgIiBUb3RhbCBDbGFzc2lmaWVycyBSZWNpZXZlZAkJOiAweCVYIixwc3RBZGRJbmRpY2F0aW9uLT5zZkF1dGhvcml6ZWRTZXQudThUb3RhbENsYXNzaWZpZXJzKTsKKwlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgIiBUb3RhbCBDbGFzc2lmaWVycyBSZWNlaXZlZAkJOiAweCVYIixwc3RBZGRJbmRpY2F0aW9uLT5zZkF1dGhvcml6ZWRTZXQudThUb3RhbENsYXNzaWZpZXJzKTsKIAogCW5DdXJDbGFzc2lmaWVyQ250ID0gcHN0QWRkSW5kaWNhdGlvbi0+c2ZBdXRob3JpemVkU2V0LnU4VG90YWxDbGFzc2lmaWVyczsKIApAQCAtMTMwNSw3ICsxMzA1LDcgQEAKIAlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgInU4VHJhZmZpY0luZGljYXRpb25QcmVmZXJlbmNlCTogMHglMDJYIiwKIAkJcHN0QWRkSW5kaWNhdGlvbi0+c2ZBZG1pdHRlZFNldC51OFRyYWZmaWNJbmRpY2F0aW9uUHJlZmVyZW5jZSk7CiAKLQlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgIiBUb3RhbCBDbGFzc2lmaWVycyBSZWNpZXZlZAkJOiAweCVYIixwc3RBZGRJbmRpY2F0aW9uLT5zZkFkbWl0dGVkU2V0LnU4VG90YWxDbGFzc2lmaWVycyk7CisJQkNNX0RFQlVHX1BSSU5UKCBBZGFwdGVyLERCR19UWVBFX09USEVSUywgRFVNUF9DT05UUk9MLCBEQkdfTFZMX0FMTCwgICIgVG90YWwgQ2xhc3NpZmllcnMgUmVjZWl2ZWQJCTogMHglWCIscHN0QWRkSW5kaWNhdGlvbi0+c2ZBZG1pdHRlZFNldC51OFRvdGFsQ2xhc3NpZmllcnMpOwogCiAJbkN1ckNsYXNzaWZpZXJDbnQgPSBwc3RBZGRJbmRpY2F0aW9uLT5zZkFkbWl0dGVkU2V0LnU4VG90YWxDbGFzc2lmaWVyczsKIApAQCAtMTUwMiw3ICsxNTAyLDcgQEAKIAlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgIiB1OFRyYWZmaWNJbmRpY2F0aW9uUHJlZmVyZW5jZQk6IDB4JVgiLAogCQlwc3RBZGRJbmRpY2F0aW9uLT5zZkFjdGl2ZVNldC51OFRyYWZmaWNJbmRpY2F0aW9uUHJlZmVyZW5jZSk7CiAKLQlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBEVU1QX0NPTlRST0wsIERCR19MVkxfQUxMLCAgIiBUb3RhbCBDbGFzc2lmaWVycyBSZWNpZXZlZAkJOiAweCVYIixwc3RBZGRJbmRpY2F0aW9uLT5zZkFjdGl2ZVNldC51OFRvdGFsQ2xhc3NpZmllcnMpOworCUJDTV9ERUJVR19QUklOVCggQWRhcHRlcixEQkdfVFlQRV9PVEhFUlMsIERVTVBfQ09OVFJPTCwgREJHX0xWTF9BTEwsICAiIFRvdGFsIENsYXNzaWZpZXJzIFJlY2VpdmVkCQk6IDB4JVgiLHBzdEFkZEluZGljYXRpb24tPnNmQWN0aXZlU2V0LnU4VG90YWxDbGFzc2lmaWVycyk7CiAKIAluQ3VyQ2xhc3NpZmllckNudCA9IHBzdEFkZEluZGljYXRpb24tPnNmQWN0aXZlU2V0LnU4VG90YWxDbGFzc2lmaWVyczsKIApAQCAtMTY5Niw3ICsxNjk2LDcgQEAKIAkJLy9ObyBTcGVjaWFsIGhhbmRsaW5nIHNlbmQgdGhlIG1lc3NhZ2UgYXMgaXQgaXMKIAkJcmV0dXJuIDE7CiAJfQotCS8vIEZvciBEU0FfUkVRLCBvbmx5IHVwdG8gInBzZkF1dGhvcml6ZWRTZXQiIHBhcmFtZXRlciBzaG91bGQgYmUgYWNjZXNzZWQgYnkgZHJpdmVyIQorCS8vIEZvciBEU0FfUkVRLCBvbmx5IHVwIHRvICJwc2ZBdXRob3JpemVkU2V0IiBwYXJhbWV0ZXIgc2hvdWxkIGJlIGFjY2Vzc2VkIGJ5IGRyaXZlciEKIAogCXBzdEFkZEluZGljYXRpb249a21hbGxvYyhzaXplb2YoKnBzdEFkZEluZGljYXRpb24pLCBHRlBfS0VSTkVMKTsKIAlpZihOVUxMPT1wc3RBZGRJbmRpY2F0aW9uKQpAQCAtMTc4OCw3ICsxNzg4LDcgQEAKIAlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfT1RIRVJTLCBDT05OX01TRywgREJHX0xWTF9BTEwsICJJbnNpZGUgUmVzdG9yZUNtQ29udHJvbFJlc3BvbnNlTWVzc2FnZSAiKTsKIAkvKgogCS8vTmVlZCB0byBBbGxvY2F0ZSBtZW1vcnkgdG8gY29udGFpbiB0aGUgU1VQRVIgTGFyZ2Ugc3RydWN0dXJlcwotCS8vT3VyIGRyaXZlciBjYW50IGNyZWF0ZSB0aGVzZSBzdHJ1Y3R1cmVzIG9uIFN0YWNrIDooCisJLy9PdXIgZHJpdmVyIGNhbid0IGNyZWF0ZSB0aGVzZSBzdHJ1Y3R1cmVzIG9uIFN0YWNrIDooCiAJKi8KIAlwc3RBZGRJbmRpY2F0aW9uRGVzdD1rbWFsbG9jKHNpemVvZihzdExvY2FsU0ZBZGRJbmRpY2F0aW9uQWx0KSwgR0ZQX0tFUk5FTCk7CiAKQEAgLTE5NTcsNyArMTk1Nyw3IEBACiB7CiAJLyoKIAkvL05lZWQgdG8gQWxsb2NhdGUgbWVtb3J5IHRvIGNvbnRhaW4gdGhlIFNVUEVSIExhcmdlIHN0cnVjdHVyZXMKLQkvL091ciBkcml2ZXIgY2FudCBjcmVhdGUgdGhlc2Ugc3RydWN0dXJlcyBvbiBTdGFjaworCS8vT3VyIGRyaXZlciBjYW4ndCBjcmVhdGUgdGhlc2Ugc3RydWN0dXJlcyBvbiBTdGFjawogCSovCiAJQWRhcHRlci0+Y2FEc3hSZXFSZXNwPWttYWxsb2Moc2l6ZW9mKHN0TG9jYWxTRkFkZEluZGljYXRpb25BbHQpK0xFQURFUl9TSVpFLCBHRlBfS0VSTkVMKTsKIAlpZighQWRhcHRlci0+Y2FEc3hSZXFSZXNwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JjbS9Ib3N0TUlCU0ludGVyZmFjZS5oIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9Ib3N0TUlCU0ludGVyZmFjZS5oCmluZGV4IGYxN2E0ZjEuLmUzNDUzMWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9iY20vSG9zdE1JQlNJbnRlcmZhY2UuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL0hvc3RNSUJTSW50ZXJmYWNlLmgKQEAgLTYyLDcgKzYyLDcgQEAKIAlVTE9ORwkJCU51bURlc1VzZWQ7CiAJVUxPTkcJCQlDdXJyTnVtRnJlZURlc2M7CiAJVUxPTkcJCQlQcmV2TnVtRnJlZURlc2M7Ci0JLy8gdG8ga2VlcCB0cmFjayB0aGUgbm8gb2YgYnl0ZSByZWNpZXZlZAorCS8vIHRvIGtlZXAgdHJhY2sgdGhlIG5vIG9mIGJ5dGUgcmVjZWl2ZWQKIAlVTE9ORwkJCVByZXZOdW1SY2V2Qnl0ZXM7CiAJVUxPTkcJCQlDdXJyTnVtUmNldkJ5dGVzOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0lQdjZQcm90b2NvbC5jIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9JUHY2UHJvdG9jb2wuYwppbmRleCA5MWI2ZmJlLi41YjRmZDM3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0lQdjZQcm90b2NvbC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vSVB2NlByb3RvY29sLmMKQEAgLTI4Nyw3ICsyODcsNyBAQAogCiAJZm9yKHVpTG9vcEluZGV4PTA7dWlMb29wSW5kZXg8dWlDb3VudElQU3JjQWRkcmVzc2VzO3VpTG9vcEluZGV4Kz11aUlwdjZBZGRyTm9Mb25nV29yZHMpCiAJewotCQlCQ01fREVCVUdfUFJJTlQoIEFkYXB0ZXIsREJHX1RZUEVfVFgsIElQVjZfREJHLCBEQkdfTFZMX0FMTCwgIlxuIFNyYyBJcHY2IEFkZHJlc3MgSW4gUmVjaWV2ZWQgUGFja2V0IDogXG4gIik7CisJCUJDTV9ERUJVR19QUklOVCggQWRhcHRlcixEQkdfVFlQRV9UWCwgSVBWNl9EQkcsIERCR19MVkxfQUxMLCAiXG4gU3JjIElwdjYgQWRkcmVzcyBJbiBSZWNlaXZlZCBQYWNrZXQgOiBcbiAiKTsKIAkJRHVtcElwdjZBZGRyZXNzKGF1bFNyY0lQKTsKIAkJQkNNX0RFQlVHX1BSSU5UKCBBZGFwdGVyLERCR19UWVBFX1RYLCBJUFY2X0RCRywgREJHX0xWTF9BTEwsICJcbiBTcmMgSXB2NiBNYXNrIEluIENsYXNzaWZpZXIgUnVsZTogXG4iKTsKIAkJRHVtcElwdjZBZGRyZXNzKCZwc3RDbGFzc2lmaWVyUnVsZS0+c3RTcmNJcEFkZHJlc3MudWxJcHY2TWFza1t1aUxvb3BJbmRleF0pOwpAQCAtMzQwLDcgKzM0MCw3IEBACiAKIAlmb3IodWlMb29wSW5kZXg9MDt1aUxvb3BJbmRleDx1aUNvdW50SVBEZXN0aW5hdGlvbkFkZHJlc3Nlczt1aUxvb3BJbmRleCs9dWlJcHY2QWRkck5vTG9uZ1dvcmRzKQogCXsKLQkJQkNNX0RFQlVHX1BSSU5UKCBBZGFwdGVyLERCR19UWVBFX1RYLCBJUFY2X0RCRywgREJHX0xWTF9BTEwsICJcbiBEZXN0aW5hdGlvbiBJcHY2IEFkZHJlc3MgSW4gUmVjaWV2ZWQgUGFja2V0IDogXG4gIik7CisJCUJDTV9ERUJVR19QUklOVCggQWRhcHRlcixEQkdfVFlQRV9UWCwgSVBWNl9EQkcsIERCR19MVkxfQUxMLCAiXG4gRGVzdGluYXRpb24gSXB2NiBBZGRyZXNzIEluIFJlY2VpdmVkIFBhY2tldCA6IFxuICIpOwogCQlEdW1wSXB2NkFkZHJlc3MoYXVsRGVzdElQKTsKIAkJQkNNX0RFQlVHX1BSSU5UKCBBZGFwdGVyLERCR19UWVBFX1RYLCBJUFY2X0RCRywgREJHX0xWTF9BTEwsICJcbiBEZXN0aW5hdGlvbiBJcHY2IE1hc2sgSW4gQ2xhc3NpZmllciBSdWxlOiBcbiIpOwogCQlEdW1wSXB2NkFkZHJlc3MoJnBzdENsYXNzaWZpZXJSdWxlLT5zdERlc3RJcEFkZHJlc3MudWxJcHY2TWFza1t1aUxvb3BJbmRleF0pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JjbS9JbnRlcmZhY2VJZGxlTW9kZS5jIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9JbnRlcmZhY2VJZGxlTW9kZS5jCmluZGV4IGJmNWMwYWQuLjk2ZmE0ZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9iY20vSW50ZXJmYWNlSWRsZU1vZGUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL0ludGVyZmFjZUlkbGVNb2RlLmMKQEAgLTExLDcgKzExLDcgQEAKIAogCiBSZXR1cm46CQkJCUJDTV9TVEFUVVNfU1VDQ0VTUyAtIElmIFdha2V1cCBvZiB0aGUgSFcgSW50ZXJmYWNlIHdhcyBzdWNjZXNzZnVsLgotCQkJCQkJT3RoZXIgICAgICAgICAgIC0gSWYgYW4gZXJyb3Igb2NjdXJlZC4KKwkJCQkJCU90aGVyICAgICAgICAgICAtIElmIGFuIGVycm9yIG9jY3VycmVkLgogKi8KIAogCkBAIC0yNiw3ICsyNiw3IEBACiAKIAogUmV0dXJuOgkJCQlCQ01fU1RBVFVTX1NVQ0NFU1MgLSBJZiBJZGxlIG1vZGUgcmVzcG9uc2UgcmVsYXRlZCBIVyBjb25maWd1cmF0aW9uIHdhcyBzdWNjZXNzZnVsLgotCQkJCQkJT3RoZXIgICAgICAgICAgIC0gSWYgYW4gZXJyb3Igb2NjdXJlZC4KKwkJCQkJCU90aGVyICAgICAgICAgICAtIElmIGFuIGVycm9yIG9jY3VycmVkLgogKi8KIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9iY20vSW50ZXJmYWNlSXNyLmMgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL0ludGVyZmFjZUlzci5jCmluZGV4IDIyMGZmOTIuLjY3NzE5ZDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9iY20vSW50ZXJmYWNlSXNyLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9JbnRlcmZhY2VJc3IuYwpAQCAtODAsOCArODAsOCBAQAogCQl9CiAJCWNhc2UgLUVJTlBST0dSRVNTOgogCQl7Ci0JCQkvL1RoaXMgc2l0dWF0aW9uIG1heSBoYXBwZW5kIHdoZW4gVVJCdW5saW5rIGlzIHVzZWQuIGZvciBkZXRhaWwgY2hlY2sgdXNiX3VubGlua191cmIgZG9jdW1lbnRhdGlvbi4KLQkJCUJDTV9ERUJVR19QUklOVChBZGFwdGVyLERCR19UWVBFX09USEVSUywgSU5URl9JTklULCBEQkdfTFZMX0FMTCwiSW1wb3NzaWJlIGNvbmRpdGlvbiBoYXMgb2NjdXJlZC4uLiBzb21ldGhpbmcgdmVyeSBiYWQgaXMgZ29pbmcgb24iKTsKKwkJCS8vVGhpcyBzaXR1YXRpb24gbWF5IGhhcHBlbmVkIHdoZW4gVVJCdW5saW5rIGlzIHVzZWQuIGZvciBkZXRhaWwgY2hlY2sgdXNiX3VubGlua191cmIgZG9jdW1lbnRhdGlvbi4KKwkJCUJDTV9ERUJVR19QUklOVChBZGFwdGVyLERCR19UWVBFX09USEVSUywgSU5URl9JTklULCBEQkdfTFZMX0FMTCwiSW1wb3NzaWJlIGNvbmRpdGlvbiBoYXMgb2NjdXJyZWQuLi4gc29tZXRoaW5nIHZlcnkgYmFkIGlzIGdvaW5nIG9uIik7CiAJCQlicmVhayA7CiAJCQkvL3JldHVybjsKIAkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JjbS9JbnRlcmZhY2VSeC5jIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9JbnRlcmZhY2VSeC5jCmluZGV4IDUzM2Y4ZWIuLjgwNmVmNWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9iY20vSW50ZXJmYWNlUnguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL0ludGVyZmFjZVJ4LmMKQEAgLTM0LDcgKzM0LDcgQEAKIAlyZXR1cm4gcFJjYjsKIH0KIAotLyp0aGlzIGlzIHJlY2VpdmUgY2FsbCBiYWNrIC0gd2hlbiBwa3QgYXZpbGFibGUgZm9yIHJlY2VpdmUgKEJVTEsgSU4tIGVuZCBwb2ludCkqLworLyp0aGlzIGlzIHJlY2VpdmUgY2FsbCBiYWNrIC0gd2hlbiBwa3QgYXZhaWxhYmxlIGZvciByZWNlaXZlIChCVUxLIElOLSBlbmQgcG9pbnQpKi8KIHN0YXRpYyB2b2lkIHJlYWRfYnVsa19jYWxsYmFjayhzdHJ1Y3QgdXJiICp1cmIpCiB7CiAJc3RydWN0IHNrX2J1ZmYgKnNrYiA9IE5VTEw7CkBAIC0xMjMsNyArMTIzLDcgQEAKIAlpZigobnRvaHMocExlYWRlci0+VmNpZCkgPT0gVkNJRF9DT05UUk9MX1BBQ0tFVCkgfHwKIAkgICAgKCEocExlYWRlci0+U3RhdHVzID49IDB4MjAgICYmICBwTGVhZGVyLT5TdGF0dXMgPD0gMHgzRikpKQogCXsKLQkgICAgQkNNX0RFQlVHX1BSSU5UKHBzSW50ZkFkYXB0ZXItPnBzQWRhcHRlcixEQkdfVFlQRV9SWCwgUlhfQ1RSTCwgREJHX0xWTF9BTEwsICJSZWNpdmVkIGNvbnRyb2wgcGt0Li4uIik7CisJICAgIEJDTV9ERUJVR19QUklOVChwc0ludGZBZGFwdGVyLT5wc0FkYXB0ZXIsREJHX1RZUEVfUlgsIFJYX0NUUkwsIERCR19MVkxfQUxMLCAiUmVjZWl2ZWQgY29udHJvbCBwa3QuLi4iKTsKIAkJKihQVVNIT1JUKXNrYi0+ZGF0YSA9IHBMZWFkZXItPlN0YXR1czsKICAgICAgICAJbWVtY3B5KHNrYi0+ZGF0YStzaXplb2YoVVNIT1JUKSwgdXJiLT50cmFuc2Zlcl9idWZmZXIgKwogCQkJKHNpemVvZihMRUFERVIpKSwgcExlYWRlci0+UExlbmd0aCk7CkBAIC0xNDIsNyArMTQyLDcgQEAKIAkJICAqIERhdGEgUGFja2V0LCBGb3JtYXQgYSBwcm9wZXIgRXRoZXJuZXQgSGVhZGVyCiAgICAgICAgIAkgICogYW5kIGdpdmUgaXQgdG8gdGhlIHN0YWNrCiAJCSAgKi8KLSAgICAgICAgQkNNX0RFQlVHX1BSSU5UKHBzSW50ZkFkYXB0ZXItPnBzQWRhcHRlcixEQkdfVFlQRV9SWCwgUlhfREFUQSwgREJHX0xWTF9BTEwsICJSZWNpdmVkIERhdGEgcGt0Li4uIik7CisgICAgICAgIEJDTV9ERUJVR19QUklOVChwc0ludGZBZGFwdGVyLT5wc0FkYXB0ZXIsREJHX1RZUEVfUlgsIFJYX0RBVEEsIERCR19MVkxfQUxMLCAiUmVjZWl2ZWQgRGF0YSBwa3QuLi4iKTsKIAkJc2tiX3Jlc2VydmUoc2tiLCAyICsgU0tCX1JFU0VSVkVfUEhTX0JZVEVTKTsKIAkJbWVtY3B5KHNrYi0+ZGF0YStFVEhfSExFTiwgKFBVQ0hBUil1cmItPnRyYW5zZmVyX2J1ZmZlciArIHNpemVvZihMRUFERVIpLCBwTGVhZGVyLT5QTGVuZ3RoKTsKIAkJc2tiLT5kZXYgPSBBZGFwdGVyLT5kZXY7CkBAIC0xNTEsNyArMTUxLDcgQEAKIAkJc2tiX3B1dCAoc2tiLCBwTGVhZGVyLT5QTGVuZ3RoICsgRVRIX0hMRU4pOwogCQlBZGFwdGVyLT5QYWNrSW5mb1tRdWV1ZUluZGV4XS51aVRvdGFsUnhCeXRlcys9cExlYWRlci0+UExlbmd0aDsKIAkJQWRhcHRlci0+UGFja0luZm9bUXVldWVJbmRleF0udWlUaGlzUGVyaW9kUnhCeXRlcys9IHBMZWFkZXItPlBMZW5ndGg7Ci0gICAgICAgIEJDTV9ERUJVR19QUklOVChwc0ludGZBZGFwdGVyLT5wc0FkYXB0ZXIsREJHX1RZUEVfUlgsIFJYX0RBVEEsIERCR19MVkxfQUxMLCAiUmVjaXZlZCBEYXRhIHBrdCBvZiBsZW4gOjB4JVgiLCBwTGVhZGVyLT5QTGVuZ3RoKTsKKyAgICAgICAgQkNNX0RFQlVHX1BSSU5UKHBzSW50ZkFkYXB0ZXItPnBzQWRhcHRlcixEQkdfVFlQRV9SWCwgUlhfREFUQSwgREJHX0xWTF9BTEwsICJSZWNlaXZlZCBEYXRhIHBrdCBvZiBsZW4gOjB4JVgiLCBwTGVhZGVyLT5QTGVuZ3RoKTsKIAogCQlpZihuZXRpZl9ydW5uaW5nKEFkYXB0ZXItPmRldikpCiAJCXsKQEAgLTIzNyw3ICsyMzcsNyBAQAogCiAKIFJldHVybjoJCQkJVFJVRSAgLSBJZiBSeCB3YXMgc3VjY2Vzc2Z1bC4KLQkJCQkJT3RoZXIgLSBJZiBhbiBlcnJvciBvY2N1cmVkLgorCQkJCQlPdGhlciAtIElmIGFuIGVycm9yIG9jY3VycmVkLgogKi8KIAogQk9PTEVBTiBJbnRlcmZhY2VSeCAoUFNfSU5URVJGQUNFX0FEQVBURVIgcHNJbnRmQWRhcHRlcikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9iY20vSW9jdGwuaCBiL2RyaXZlcnMvc3RhZ2luZy9iY20vSW9jdGwuaAppbmRleCBlNGY4ZWI3Li5mODU5Y2YxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0lvY3RsLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9Jb2N0bC5oCkBAIC0yNDEsNyArMjQxLDcgQEAKIAogdHlwZWRlZiBlbnVtIF9GTEFTSDJYX1NFQ1RJT05fVkFMCiB7Ci0JTk9fU0VDVElPTl9WQUwgPSAwLCAvL25vIHNlY3Rpb24gaXMgY2hvb3NlbiB3aGVuIGFic29sdXRlIG9mZnNldCBpcyBnaXZlbiBmb3IgUkQvV1IKKwlOT19TRUNUSU9OX1ZBTCA9IDAsIC8vbm8gc2VjdGlvbiBpcyBjaG9zZW4gd2hlbiBhYnNvbHV0ZSBvZmZzZXQgaXMgZ2l2ZW4gZm9yIFJEL1dSCiAJSVNPX0lNQUdFMSwKIAlJU09fSU1BR0UyLAogCURTRDAsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYmNtL0xlYWt5QnVja2V0LmMgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL0xlYWt5QnVja2V0LmMKaW5kZXggZjRjZjQxYy4uYTU1ZDQyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2JjbS9MZWFreUJ1Y2tldC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vTGVha3lCdWNrZXQuYwpAQCAtMjEzLDcgKzIxMyw3IEBACiAJCQkJQkNNX0RFQlVHX1BSSU5UKEFkYXB0ZXIsREJHX1RZUEVfVFgsIFRYX1BBQ0tFVFMsIERCR19MVkxfQUxMLCAiRm9yIFF1ZXVlOiAlemRcbiIsIHBzU0YtQWRhcHRlci0+UGFja0luZm8pOwogCQkJCUJDTV9ERUJVR19QUklOVChBZGFwdGVyLERCR19UWVBFX1RYLCBUWF9QQUNLRVRTLCBEQkdfTFZMX0FMTCwgIlxuQXZhaWxhYmxlIFRva2VucyA9ICVkIHJlcXVpcmVkID0gJWRcbiIsCiAJCQkJCXBzU0YtPnVpQ3VycmVudFRva2VuQ291bnQsIGlQYWNrZXRMZW4pOwotCQkJCS8vdGhpcyBwYXJ0IGluZGljYXRlcyB0aGF0IGJlY3Vhc2Ugb2Ygbm9uLWF2YWlsYWJpbGl0eSBvZiB0aGUgdG9rZW5zCisJCQkJLy90aGlzIHBhcnQgaW5kaWNhdGVzIHRoYXQgYmVjYXVzZSBvZiBub24tYXZhaWxhYmlsaXR5IG9mIHRoZSB0b2tlbnMKIAkJCQkvL3BrdCBoYXMgbm90IGJlZW4gc2VuZCBvdXQgaGVuY2Ugc2V0dGluZyB0aGUgcGVuZGluZyBmbGFnIGluZGljYXRpbmcgdGhlIGhvc3QgdG8gc2VuZCBpdCBvdXQKIAkJCQkvL2ZpcnN0IG5leHQgaXRlcmF0aW9uICAuCiAJCQkJcHNTRi0+dWlQZW5kZWRMYXN0ID0gVFJVRTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9iY20vTWlzYy5jIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9NaXNjLmMKaW5kZXggZDYyNGYzNS4uYzUwMDNiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2JjbS9NaXNjLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9NaXNjLmMKQEAgLTYwMiw3ICs2MDIsNyBAQAogCQkJCUFkYXB0ZXItPkxpbmtTdGF0dXM9TElOS1VQX0RPTkU7CiAJCQkJQWRhcHRlci0+YlBIU0VuYWJsZWQgPSAqKHB1Y0J1ZmZlciszKTsKICAgICAgICAgICAgICAgIAlBZGFwdGVyLT5iRVRIQ1NFbmFibGVkID0gKihwdWNCdWZmZXIrNCkgJiBFVEhfQ1NfTUFTSzsKLQkJCQlCQ01fREVCVUdfUFJJTlQoQWRhcHRlcixEQkdfVFlQRV9QUklOVEssIDAsIDAsICJQSFMgU3VwcG9ydCBTdGF0dXMgUmVjaWV2ZWQgSW4gTGlua1VwIEFjayA6ICV4IFxuIixBZGFwdGVyLT5iUEhTRW5hYmxlZCk7CisJCQkJQkNNX0RFQlVHX1BSSU5UKEFkYXB0ZXIsREJHX1RZUEVfUFJJTlRLLCAwLCAwLCAiUEhTIFN1cHBvcnQgU3RhdHVzIFJlY2VpdmVkIEluIExpbmtVcCBBY2sgOiAleCBcbiIsQWRhcHRlci0+YlBIU0VuYWJsZWQpOwogCQkJCWlmKChGQUxTRSA9PSBBZGFwdGVyLT5iU2h1dFN0YXR1cykmJgogCQkJCQkoRkFMU0UgPT0gQWRhcHRlci0+SWRsZU1vZGUpKQogCQkJCXsKQEAgLTExNTMsNyArMTE1Myw3IEBACiAKIAkvKgogICAgICAqIDEuIElmIHRoZSBMRUQgU2V0dGluZ3MgZmFpbHMsIGRvIG5vdCBzdG9wIGFuZCBkbyB0aGUgRmlybXdhcmUgZG93bmxvYWQuCi0gICAgICogMi4gVGhpcyBpbml0IHdvdWxkIGhhcHBlbmQgb25seSBpZiB0aGUgY2ZnIGZpbGUgaXMgcHJlc2VudCwgZWxzZQorICAgICAqIDIuIFRoaXMgaW5pdCB3b3VsZCBoYXBwZW5lZCBvbmx5IGlmIHRoZSBjZmcgZmlsZSBpcyBwcmVzZW50LCBlbHNlCiAgICAgICogICAgY2FsbCBmcm9tIHRoZSBpb2N0bCBjb250ZXh0LgogICAgICAqLwogCkBAIC0xMTg1LDcgKzExODUsNyBAQAogCQlzdGF0dXMgPSBQcm9wYWdhdGVDYWxQYXJhbXNGcm9tRmxhc2hUb01lbW9yeShwc19hZGFwdGVyKTsKIAkJaWYoc3RhdHVzKQogCQl7Ci0JCQlCQ01fREVCVUdfUFJJTlQocHNfYWRhcHRlcixEQkdfVFlQRV9JTklURVhJVCwgTVBfSU5JVCwgREJHX0xWTF9BTEwsIiBQcm9wb2dhdGlvbiBvZiBDYWwgcGFyYW0gZmFpbGVkIC4uIiApOworCQkJQkNNX0RFQlVHX1BSSU5UKHBzX2FkYXB0ZXIsREJHX1RZUEVfSU5JVEVYSVQsIE1QX0lOSVQsIERCR19MVkxfQUxMLCIgUHJvcGFnYXRpb24gb2YgQ2FsIHBhcmFtIGZhaWxlZCAuLiIgKTsKIAkJCWdvdG8gT1VUOwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JjbS9Rb3MuYyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vUW9zLmMKaW5kZXggZmVhZGU5NC4uYzk3MDIwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2JjbS9Rb3MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL1Fvcy5jCkBAIC03MjcsNyArNzI3LDcgQEAKIAogCUJDTV9ERUJVR19QUklOVChBZGFwdGVyLCBEQkdfVFlQRV9UWCwgSVBWNF9EQkcsIERCR19MVkxfQUxMLCAgIiVzICBDTFMgVXNlclByaW86JXggQ0xTIFZMQU5JRDoleFxuIixfX0ZVTkNUSU9OX18sbnRvaHMoKigoVVNIT1JUICopcHN0Q2xhc3NpZmllclJ1bGUtPnVzVXNlclByaW9yaXR5KSkscHN0Q2xhc3NpZmllclJ1bGUtPnVzVkxBTklEKTsKIAotCS8qIEluIGNhc2UgRlcgZGlkbid0IHJlY2lldmUgdGhlIFRMViwgdGhlIHByaW9yaXR5IGZpZWxkIHNob3VsZCBiZSBpZ25vcmVkICovCisJLyogSW4gY2FzZSBGVyBkaWRuJ3QgcmVjZWl2ZSB0aGUgVExWLCB0aGUgcHJpb3JpdHkgZmllbGQgc2hvdWxkIGJlIGlnbm9yZWQgKi8KIAlpZihwc3RDbGFzc2lmaWVyUnVsZS0+dXNWYWxpZGl0eUJpdE1hcCAmICgxPDxQS1RfQ0xBU1NJRklDQVRJT05fVVNFUl9QUklPUklUWV9WQUxJRCkpCiAJewogCQlpZihwc3RFdGhDc1BrdEluZm8tPmVOd3BrdEV0aEZyYW1lVHlwZSE9ZUV0aDgwMlFWTEFORnJhbWUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYmNtL2NudHJsX1NpZ25hbGluZ0ludGVyZmFjZS5oIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9jbnRybF9TaWduYWxpbmdJbnRlcmZhY2UuaAppbmRleCA4OTA3Nzg0Li5hYjEzMTgwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYmNtL2NudHJsX1NpZ25hbGluZ0ludGVyZmFjZS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vY250cmxfU2lnbmFsaW5nSW50ZXJmYWNlLmgKQEAgLTIxLDcgKzIxLDcgQEAKICNkZWZpbmUgVkVORE9SX1BIU19QQVJBTV9MRU5HVEggMTAKICNkZWZpbmUgTUFYX05VTV9BQ1RJVkVfQlMgMTAKICNkZWZpbmUgQVVUSF9UT0tFTl9MRU5HVEgJMTAKLSNkZWZpbmUgTlVNX0hBUlFfQ0hBTk5FTFMJMTYJLy9DaGFuZ2VkIGZyb20gMTAgdG8gMTYgdG8gYWNjb21vZGF0ZSBhbGwgSEFSUSBjaGFubmVscworI2RlZmluZSBOVU1fSEFSUV9DSEFOTkVMUwkxNgkvL0NoYW5nZWQgZnJvbSAxMCB0byAxNiB0byBhY2NvbW1vZGF0ZSBhbGwgSEFSUSBjaGFubmVscwogI2RlZmluZSBWRU5ET1JfQ0xBU1NJRklFUl9QQVJBTV9MRU5HVEggMSAvL0NoYW5nZWQgdGhlIHNpemUgdG8gMSBieXRlIHNpbmNlIHdlIGRudCB1c2UgaXQKICNkZWZpbmUgIFZFTkRPUl9TUEVDSUZfUU9TX1BBUkFNIDEKICNkZWZpbmUgVkVORE9SX1BIU19QQVJBTV9MRU5HVEgJMTAKQEAgLTEwOSwxMyArMTA5LDEzIEBACiAgICAgQl9VSU5UOCAgICAgICAgICAgICAgICAgICAgICAgICB1OFBIU0k7CiAJLyoqICBQSFNGIExlbmd0aCBPZiBUaGUgU2VydmljZSBGbG93Ki8KICAgICBCX1VJTlQ4ICAgICAgICAgICAgICAgICAgICAgICAgIHU4UEhTRkxlbmd0aDsKLSAgICAvKiogU3RyaW5nIG9mIGJ5dGVzIGNvbnRhaW5pbmcgaGVhZGVyIGluZm9ybWF0aW9uIHRvIGJlIHN1cHJlc3NlZCBieSB0aGUgc2VuZGluZyBDUyBhbmQgcmVjb25zdHJ1Y3RlZCBieSB0aGUgcmVjZWl2aW5nIENTKi8KKyAgICAvKiogU3RyaW5nIG9mIGJ5dGVzIGNvbnRhaW5pbmcgaGVhZGVyIGluZm9ybWF0aW9uIHRvIGJlIHN1cHByZXNzZWQgYnkgdGhlIHNlbmRpbmcgQ1MgYW5kIHJlY29uc3RydWN0ZWQgYnkgdGhlIHJlY2VpdmluZyBDUyovCiAgICAgQl9VSU5UOCAgICAgICAgICAgICAgICAgICAgICAgICB1OFBIU0ZbTUFYX1BIU19MRU5HVEhTXTsKIAkvKiogIFBIU00gTGVuZ3RoIE9mIFRoZSBTZXJ2aWNlIEZsb3cqLwogICAgIEJfVUlOVDggICAgICAgICAgICAgICAgICAgICAgICAgdThQSFNNTGVuZ3RoOwogCS8qKiAgUEhTIE1hc2sgZm9yIHRoZSBTRiovCiAgICAgQl9VSU5UOCAgICAgICAgICAgICAgICAgICAgICAgICB1OFBIU01bTUFYX1BIU19MRU5HVEhTXTsKLQkvKiogIDhiaXQgVG90YWwgbnVtYmVyIG9mIGJ5dGVzIHRvIGJlIHN1cHJlc3NlZCBmb3IgdGhlIFNlcnZpY2UgRmxvdyovCisJLyoqICA4Yml0IFRvdGFsIG51bWJlciBvZiBieXRlcyB0byBiZSBzdXBwcmVzc2VkIGZvciB0aGUgU2VydmljZSBGbG93Ki8KICAgICBCX1VJTlQ4ICAgICAgICAgICAgICAgICAgICAgICAgIHU4UEhTUzsKIAkvKiogIDhiaXQgSW5kaWNhdGVzIHdoZXRoZXIgb3Igbm90IFBhY2tldCBIZWFkZXIgY29udGVudHMgbmVlZCB0byBiZSB2ZXJpZmllZCBwcmlvciB0byBzdXByZXNzaW9uICovCiAgICAgQl9VSU5UOCAgICAgICAgICAgICAgICAgICAgICAgICB1OFBIU1Y7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYmNtL252bS5jIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9udm0uYwppbmRleCBjNzI5MjM3Li40ZGE1YjdiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYmNtL252bS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vbnZtLmMKQEAgLTMxMyw3ICszMTMsNyBAQAogLy8JCXVpTnVtQnl0ZXMgLSBOdW1iZXIgb2YgYnl0ZXMgdG8gYmUgcmVhZCBmcm9tIHRoZSBFRVBST00uCiAvLwogLy8gUmV0dXJuczoKLS8vCQlPU0FMX1NUQVRVU19TVUNDRVNTIC0gaWYgRUVQUk9NIHJlYWQgaXMgc3VjY2Vzc2Z1bGwuCisvLwkJT1NBTF9TVEFUVVNfU1VDQ0VTUyAtIGlmIEVFUFJPTSByZWFkIGlzIHN1Y2Nlc3NmdWwuCiAvLwkJPEZBSUxVUkU+CQkJLSBpZiBmYWlsZWQuCiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKQEAgLTQzMSw3ICs0MzEsNyBAQAogLy8JCXVpTnVtQnl0ZXMgLSBOdW1iZXIgb2YgYnl0ZXMgdG8gYmUgcmVhZCBmcm9tIHRoZSBGTEFTSC4KIC8vCiAvLyBSZXR1cm5zOgotLy8JCU9TQUxfU1RBVFVTX1NVQ0NFU1MgLSBpZiBGTEFTSCByZWFkIGlzIHN1Y2Nlc3NmdWxsLgorLy8JCU9TQUxfU1RBVFVTX1NVQ0NFU1MgLSBpZiBGTEFTSCByZWFkIGlzIHN1Y2Nlc3NmdWwuCiAvLwkJPEZBSUxVUkU+CQkJLSBpZiBmYWlsZWQuCiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKQEAgLTExNzQsNyArMTE3NCw3IEBACiAJaWYoTlVMTCA9PSBwVGVtcEJ1ZmYpCiAJCWdvdG8gQmVjZWVtRmxhc2hCdWxrV3JpdGVfRVhJVDsKIC8vCi0vLyBjaGVjayBpZiB0aGUgZGF0YSB0byBiZSB3cml0dGVuIGlzIG92ZXJsYXBwZWQgYWNjcm9zcyBzZWN0b3JzCisvLyBjaGVjayBpZiB0aGUgZGF0YSB0byBiZSB3cml0dGVuIGlzIG92ZXJsYXBwZWQgYWNyb3NzIHNlY3RvcnMKIC8vCiAJaWYodWlPZmZzZXQrdWlOdW1CeXRlcyA8IHVpU2VjdEJvdW5kYXJ5KQogCXsKQEAgLTEzOTAsNyArMTM5MCw3IEBACiAJCWdvdG8gQmVjZWVtRmxhc2hCdWxrV3JpdGVTdGF0dXNfRVhJVDsKIAogLy8KLS8vIGNoZWNrIGlmIHRoZSBkYXRhIHRvIGJlIHdyaXR0ZW4gaXMgb3ZlcmxhcHBlZCBhY2Nyb3NzIHNlY3RvcnMKKy8vIGNoZWNrIGlmIHRoZSBkYXRhIHRvIGJlIHdyaXR0ZW4gaXMgb3ZlcmxhcHBlZCBhY3Jvc3Mgc2VjdG9ycwogLy8KIAlpZih1aU9mZnNldCt1aU51bUJ5dGVzIDwgdWlTZWN0Qm91bmRhcnkpCiAJewpAQCAtMjAyMCw3ICsyMDIwLDcgQEAKIC8vCQl1aU51bUJ5dGVzIC0gTnVtYmVyIG9mIGJ5dGVzIHRvIGJlIHJlYWQgZnJvbSB0aGUgTlZNLgogLy8KIC8vIFJldHVybnM6Ci0vLwkJT1NBTF9TVEFUVVNfU1VDQ0VTUyAtIGlmIE5WTSByZWFkIGlzIHN1Y2Nlc3NmdWxsLgorLy8JCU9TQUxfU1RBVFVTX1NVQ0NFU1MgLSBpZiBOVk0gcmVhZCBpcyBzdWNjZXNzZnVsLgogLy8JCTxGQUlMVVJFPgkJCS0gaWYgZmFpbGVkLgogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCkBAIC0yMDgzLDcgKzIwODMsNyBAQAogLy8JCXVpTnVtQnl0ZXMgLSBOdW1iZXIgb2YgYnl0ZXMgdG8gYmUgd3JpdHRlbi4uCiAvLwogLy8gUmV0dXJuczoKLS8vCQlPU0FMX1NUQVRVU19TVUNDRVNTIC0gaWYgTlZNIHdyaXRlIGlzIHN1Y2Nlc3NmdWxsLgorLy8JCU9TQUxfU1RBVFVTX1NVQ0NFU1MgLSBpZiBOVk0gd3JpdGUgaXMgc3VjY2Vzc2Z1bC4KIC8vCQk8RkFJTFVSRT4JCQktIGlmIGZhaWxlZC4KIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIApAQCAtMjIxOCw3ICsyMjE4LDcgQEAKIC8vICAgICAgICAgIHVpU2VjdG9yU2l6ZSAtIHNlY3RvciBzaXplCiAvLwogLy8gUmV0dXJuczoKLS8vCQlPU0FMX1NUQVRVU19TVUNDRVNTIC0gaWYgTlZNIHdyaXRlIGlzIHN1Y2Nlc3NmdWxsLgorLy8JCU9TQUxfU1RBVFVTX1NVQ0NFU1MgLSBpZiBOVk0gd3JpdGUgaXMgc3VjY2Vzc2Z1bC4KIC8vCQk8RkFJTFVSRT4JCQktIGlmIGZhaWxlZC4KIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIApAQCAtMjQzMCw3ICsyNDMwLDcgQEAKICpJbnB1dCBQYXJhbWV0ZXI6CiAqCQlBZGFwdGVyIGRhdGEgc3RydWN0dXJlCiAqUmV0dXJuIFZhbHVlIDoKLSoJCTAuIG1lYW5zIHN1Y2VzczsKKyoJCTAuIG1lYW5zIHN1Y2Nlc3M7CiAqLwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIApAQCAtMjk5OCw3ICsyOTk4LDcgQEAKIAkvKgogCSoJQ29uc2lkZXJpbmcgYWxsIHRoZSBzZWN0aW9uIGZvciB3aGljaCBlbmQgb2Zmc2V0IGNhbiBiZSBjYWxjdWxhdGVkIG9yIGRpcmVjdGx5IGdpdmVuCiAJKglpbiBDUyBTdHJ1Y3R1cmUuIGlmIG1hdGNoaW5nIGNhc2UgZG9lcyBub3QgZXhpc3QsIHJldHVybiBTVEFUVVNfRkFJTFVSRSBpbmRpY2F0aW5nIHNlY3Rpb24KLQkqCWVuZG9mZnNldCBjYW4ndCBiZSBjYWxjdWxhdGVkIG9yIGdpdmVuIGluIENTIFN0dWN0dXJlLgorCSoJZW5kb2Zmc2V0IGNhbid0IGJlIGNhbGN1bGF0ZWQgb3IgZ2l2ZW4gaW4gQ1MgU3RydWN0dXJlLgogCSovCiAKIAlJTlQgU2VjdFN0YXJ0T2Zmc2V0ID0gMCA7CkBAIC0zMTczLDcgKzMxNzMsNyBAQAogKglAdWlOdW1CeXRlcyA6IE51bWJlciBvZiBCeXRlcyBmb3IgUmVhZAogKgogKglSZXR1cm4gdmFsdWU6LQotKgkJcmV0dXJuIHRydWUgb24gc3VjZXNzIGFuZCBTVEFUVVNfRkFJTFVSRSBvbiBmYWlsLgorKgkJcmV0dXJuIHRydWUgb24gc3VjY2VzcyBhbmQgU1RBVFVTX0ZBSUxVUkUgb24gZmFpbC4KICovCiAKIElOVCBCY21GbGFzaDJ4QnVsa1JlYWQoCkBAIC0zMjQxLDcgKzMyNDEsNyBAQAogKglAdWlOdW1CeXRlcyA6IE51bWJlciBvZiBCeXRlcyBmb3IgV3JpdGUKICoKICoJUmV0dXJuIHZhbHVlOi0KLSoJCXJldHVybiB0cnVlIG9uIHN1Y2VzcyBhbmQgU1RBVFVTX0ZBSUxVUkUgb24gZmFpbC4KKyoJCXJldHVybiB0cnVlIG9uIHN1Y2Nlc3MgYW5kIFNUQVRVU19GQUlMVVJFIG9uIGZhaWwuCiAqCiAqLwogCkBAIC0zMzA4LDcgKzMzMDgsNyBAQAogKglAQWRhcHRlciA6LURyaXZlcnMgcHJpdmF0ZSBEYXRhIFN0cnVjdHVyZQogKgogKglSZXR1cm4gVmFsdWU6LQotKgkJUmV0dXJuIFNUQVRVU19TVUNFU1MgaWYgZ2V0IHN1Y2VzcyBpbiBzZXR0aW5nIHRoZSByaWdodCBEU0QgZWxzZSBuZWdhaXZlIGVycm9yIGNvZGUKKyoJCVJldHVybiBTVEFUVVNfU1VDRVNTIGlmIGdldCBzdWNjZXNzIGluIHNldHRpbmcgdGhlIHJpZ2h0IERTRCBlbHNlIG5lZ2FpdmUgZXJyb3IgY29kZQogKgogKiovCiBzdGF0aWMgSU5UIEJjbUdldEFjdGl2ZURTRChQTUlOSV9BREFQVEVSIEFkYXB0ZXIpCkBAIC0zMzg0LDcgKzMzODQsNyBAQAogKglAdWlPZmZzZXQgOiBPZmZzZXQgcHJvdmlkZWQgaW4gdGhlIEZsYXNoCiAqCiAqCVJldHVybiBWYWx1ZTotCi0qCVN1Y2VzczotVFJVRSAsICBvZmZzZXQgaXMgd3JpdGFibGUKKyoJU3VjY2VzczotVFJVRSAsICBvZmZzZXQgaXMgd3JpdGFibGUKICoJRmFpbHVyZTotRkFMU0UsIG9mZnNldCBpcyBSTwogKgogKiovCkBAIC0zNDQxLDcgKzM0NDEsNyBAQAogCUBBZGFwdGVyOi1Ecml2ZXIgcHJpdmF0ZSBEYXRhIFN0cnVjdHVyZQogKgogKglSZXR1cm4gdmFsdWU6LQotKglTdWNlc3M6LSBTVEFUVVNfU1VDRVNTCisqCVN1Y2Nlc3M6LSBTVEFUVVNfU1VDRVNTCiAqCUZhaWx1cmU6LSBuZWdhdGl2ZSBlcnJvciBjb2RlCiAqKi8KIApAQCAtMzc4Myw3ICszNzgzLDcgQEAKIAkJCQkJLy8gVGhpcyBpcyBhIFNQRUNJQUwgQ2FzZSB3aGljaCB3aWxsIG9ubHkgaGFwcGVuIGlmIHRoZSBjdXJyZW50IGhpZ2hlc3QgcHJpb3JpdHkgSVNPIGhhcyBwcmlvcml0eSB2YWx1ZSA9IDB4N0ZGRkZGRkYuCiAJCQkJCS8vIFdlIHdpbGwgd3JpdGUgMSB0byB0aGUgY3VycmVudCBIaWdoZXN0IHByaW9yaXR5IElTTyBBbmQgdGhlbiBzaGFsbCBpbmNyZWFzZSB0aGUgcHJpb3JpdHkgb2YgdGhlIHJlcXVlc3RlZCBJU08KIAkJCQkJLy8gYnkgdXNlcgotCQkJCQlCQ01fREVCVUdfUFJJTlQoQWRhcHRlcixEQkdfVFlQRV9PVEhFUlMsIE5WTV9SVywgREJHX0xWTF9BTEwsICJTZWN0SW1hZ2VQcmlvcml0eSB3cmFwYXJvdW5kIGhhcHBlbmQsIGVGbGFzaDJ4U2VjdFZhbDogMHgleFxuIixlRmxhc2gyeFNlY3RWYWwpOworCQkJCQlCQ01fREVCVUdfUFJJTlQoQWRhcHRlcixEQkdfVFlQRV9PVEhFUlMsIE5WTV9SVywgREJHX0xWTF9BTEwsICJTZWN0SW1hZ2VQcmlvcml0eSB3cmFwYXJvdW5kIGhhcHBlbmVkLCBlRmxhc2gyeFNlY3RWYWw6IDB4JXhcbiIsZUZsYXNoMnhTZWN0VmFsKTsKIAkJCQkJU2VjdEltYWdlUHJpb3JpdHkgPSBodG9ubCgweDEpOwogCQkJCQlTdGF0dXMgPSBCY21GbGFzaDJ4QnVsa1dyaXRlKEFkYXB0ZXIsCiAJCQkJCQkJCSZTZWN0SW1hZ2VQcmlvcml0eSwKQEAgLTM4NTMsNyArMzg1Myw3IEBACiAJCQkJCS8vIFRoaXMgaXMgYSBTUEVDSUFMIENhc2Ugd2hpY2ggd2lsbCBvbmx5IGhhcHBlbiBpZiB0aGUgY3VycmVudCBoaWdoZXN0IHByaW9yaXR5IERTRCBoYXMgcHJpb3JpdHkgdmFsdWUgPSAweDdGRkZGRkZGLgogCQkJCQkvLyBXZSB3aWxsIHdyaXRlIDEgdG8gdGhlIGN1cnJlbnQgSGlnaGVzdCBwcmlvcml0eSBEU0QgQW5kIHRoZW4gc2hhbGwgaW5jcmVhc2UgdGhlIHByaW9yaXR5IG9mIHRoZSByZXF1ZXN0ZWQgRFNECiAJCQkJCS8vIGJ5IHVzZXIKLQkJCQkJQkNNX0RFQlVHX1BSSU5UKEFkYXB0ZXIsREJHX1RZUEVfUFJJTlRLLCBOVk1fUlcsIERCR19MVkxfQUxMLCAiU2VjdEltYWdlUHJpb3JpdHkgd3JhcGFyb3VuZCBoYXBwZW5kLCBlRmxhc2gyeFNlY3RWYWw6IDB4JXhcbiIsZUZsYXNoMnhTZWN0VmFsKTsKKwkJCQkJQkNNX0RFQlVHX1BSSU5UKEFkYXB0ZXIsREJHX1RZUEVfUFJJTlRLLCBOVk1fUlcsIERCR19MVkxfQUxMLCAiU2VjdEltYWdlUHJpb3JpdHkgd3JhcGFyb3VuZCBoYXBwZW5lZCwgZUZsYXNoMnhTZWN0VmFsOiAweCV4XG4iLGVGbGFzaDJ4U2VjdFZhbCk7CiAJCQkJCVNlY3RJbWFnZVByaW9yaXR5ID0gaHRvbmwoMHgxKTsKIAogCQkJCQlTdGF0dXMgPSBCY21GbGFzaDJ4QnVsa1dyaXRlKEFkYXB0ZXIsCkBAIC00MTE5LDcgKzQxMTksNyBAQAogCQkJCQkJCQkJCQkJTUFYX1JXX1NJWkUpOwogCQkJCUlzVGhpc0hlYWRlclNlY3RvciA9IEZBTFNFIDsKIAkJCX0KLQkJCS8vc3Vic3RyYWN0aW5nIHRoZSB3cml0dGVuIERhdGEKKwkJCS8vc3VidHJhY3RpbmcgdGhlIHdyaXR0ZW4gRGF0YQogCQkJdWlUb3RhbERhdGFUb0NvcHkgPSB1aVRvdGFsRGF0YVRvQ29weSAtIEFkYXB0ZXItPnVpU2VjdG9yU2l6ZSA7CiAJCX0KIApAQCAtNDI1MCw3ICs0MjUwLDcgQEAKIAkJCQlJc1RoaXNIZWFkZXJTZWN0b3IgPSBGQUxTRSA7CiAJCQl9CiAKLQkJCS8vc3Vic3RyYWN0aW5nIHRoZSB3cml0dGVuIERhdGEKKwkJCS8vc3VidHJhY3RpbmcgdGhlIHdyaXR0ZW4gRGF0YQogCQkJdWlUb3RhbERhdGFUb0NvcHkgPSB1aVRvdGFsRGF0YVRvQ29weSAtIEFkYXB0ZXItPnVpU2VjdG9yU2l6ZSA7CiAJCX0KIApAQCAtNDI2OCw3ICs0MjY4LDcgQEAKIEBlRmxhc2gyeFNlY3Rpb25WYWwgOi0gRmxhc2ggc2VjdGlvbiB2YWwgd2hpY2ggaGFzIGhlYWRlcgogCiBSZXR1cm4gVmFsdWUgOi0KLQlTdWNlc3MgOi0gSWYgU2VjdGlvbiBpcyBwcmVzZW50IGFuZCB3cml0YWJsZSwgY29ycnVwdCB0aGUgc2lnIGFuZCByZXR1cm4gU1RBVFVTX1NVQ0NFU1MKKwlTdWNjZXNzIDotIElmIFNlY3Rpb24gaXMgcHJlc2VudCBhbmQgd3JpdGFibGUsIGNvcnJ1cHQgdGhlIHNpZyBhbmQgcmV0dXJuIFNUQVRVU19TVUNDRVNTCiAJRmFpbHVyZSA6LVJldHVybiBuZWdhdGl2ZSBlcnJvciBjb2RlCiAKIApAQCAtNDMwMSw3ICs0MzAxLDcgQEAKIEBlRmxhc2hTZWN0aW9uVmFsIDotIEZsYXNoIHNlY3Rpb24gdmFsIHdoaWNoIGhhcyBoZWFkZXIKIAogUmV0dXJuIFZhbHVlIDotCi0JU3VjZXNzIDotIElmIFNlY3Rpb24gaXMgcHJlc2VudCBhbmQgd3JpdGFibGUgd3JpdGUgdGhlIHNpZyBhbmQgcmV0dXJuIFNUQVRVU19TVUNDRVNTCisJU3VjY2VzcyA6LSBJZiBTZWN0aW9uIGlzIHByZXNlbnQgYW5kIHdyaXRhYmxlIHdyaXRlIHRoZSBzaWcgYW5kIHJldHVybiBTVEFUVVNfU1VDQ0VTUwogCUZhaWx1cmUgOi1SZXR1cm4gbmVnYXRpdmUgZXJyb3IgY29kZQogCiAqKi8KQEAgLTQ1MDQsNyArNDUwNCw3IEBACiAJCQkgICAgIGluIGNhc2Ugb2YgbnVtb2ZCeXRlcyAgZXF1YWwgemVybyBjb21wbGV0ZSBzZWN0aW9uIHdpbGwgYmUgY29waWVkLgogCiBSZXR1cm4gVmFsdWVzLQotCVN1Y2VzcyA6IFJldHVybiBTVEFUVVNfU1VDQ0VTUworCVN1Y2Nlc3MgOiBSZXR1cm4gU1RBVFVTX1NVQ0NFU1MKIAlGYWlsbHVyZSA6LSByZXR1cm4gbmVnYXRpdmUgZXJyb3IgY29kZQogCiAqKi8KQEAgLTQ2MjEsNyArNDYyMSw3IEBACiBAdWlPZmZzZXQgOi0gRmxhc2ggb2Zmc2V0IHRoYXQgaGFzIHRvIGJlIHdyaXR0ZW4uCiAKIFJldHVybiB2YWx1ZSA6LQotCVN1Y2VzcyA6LSBPbiBzdWNlc3MgcmV0dXJuIFNUQVRVU19TVUNDRVNTCisJU3VjY2VzcyA6LSBPbiBzdWNjZXNzIHJldHVybiBTVEFUVVNfU1VDQ0VTUwogCUZhaWxsdXJlIDotIFJldHVybiBuZWdhdGl2ZSBlcnJvciBjb2RlCiAKICoqLwpAQCAtNDYzNCw3ICs0NjM0LDcgQEAKIAlVSU5UIHVpU2VjdEFsaWduQWRkciA9IDA7CiAJVUlOVCBzaWcgPSAwOwogCi0JLy9tYWtpbmcgdGhlIG9mZnNldCBzZWN0b3IgYWxsaWduZWQKKwkvL21ha2luZyB0aGUgb2Zmc2V0IHNlY3RvciBhbGlnbmVkCiAJdWlTZWN0QWxpZ25BZGRyID0gdWlPZmZzZXQgJiB+KEFkYXB0ZXItPnVpU2VjdG9yU2l6ZSAtIDEpOwogCiAKQEAgLTQ2NDMsNyArNDY0Myw3IEBACiAJKHVpU2VjdEFsaWduQWRkciA9PSBCY21HZXRTZWN0aW9uVmFsRW5kT2Zmc2V0KEFkYXB0ZXIsRFNEMCktIEFkYXB0ZXItPnVpU2VjdG9yU2l6ZSkpCiAJewogCi0JCS8vb2Zmc2V0IGZyb20gdGhlIHNlY3RvciBib3VuZHJ5IGhhdmluZyB0aGUgaGVhZGVyIG1hcAorCQkvL29mZnNldCBmcm9tIHRoZSBzZWN0b3IgYm91bmRhcnkgaGF2aW5nIHRoZSBoZWFkZXIgbWFwCiAJCW9mZnNldFRvUHJvdGVjdCA9IEFkYXB0ZXItPnBzRmxhc2gyeENTSW5mby0+T2Zmc2V0RnJvbURTRFN0YXJ0Rm9yRFNESGVhZGVyICUgQWRhcHRlci0+dWlTZWN0b3JTaXplOwogCQlIZWFkZXJTaXplVG9Qcm90ZWN0ID0gc2l6ZW9mKERTRF9IRUFERVIpOwogCQliSGFzSGVhZGVyID0gVFJVRSA7CkBAIC00Njk3LDcgKzQ2OTcsNyBAQAogQEFkYXBhdGVyIDotIEJjbSBEcml2ZXIgUHJpdmF0ZSBEYXRhIFN0cnVjdHVyZQogCiBPdXRQdXQ6LQotCVNlbGVjdCB0aGUgQXBwcm9wcmlhdGUgY2hpcCBhbmQgcmV0cm4gc3RhdHVzIFN1Y2VzcworCVNlbGVjdCB0aGUgQXBwcm9wcmlhdGUgY2hpcCBhbmQgcmV0cm4gc3RhdHVzIFN1Y2Nlc3MKICoqLwogc3RhdGljIElOVCBCY21Eb0NoaXBTZWxlY3QoUE1JTklfQURBUFRFUiBBZGFwdGVyLCBVSU5UIG9mZnNldCkKIHsKQEAgLTUwODYsNyArNTA4Niw3IEBACiAJewogCQlpZihJc1NlY3Rpb25Xcml0YWJsZShBZGFwdGVyLGVGbGFzaDJ4U2VjdGlvblZhbCkgIT0gVFJVRSkKIAkJewotCQkJQkNNX0RFQlVHX1BSSU5UKEFkYXB0ZXIsREJHX1RZUEVfUFJJTlRLLCAwLCAwLCJTZWN0aW9uIGlzIG5vdCBXcml0YWJsZS4uLkhlbmNlIGNhbnQgQ29ycnVwdCBzaWduYXR1cmUiKTsKKwkJCUJDTV9ERUJVR19QUklOVChBZGFwdGVyLERCR19UWVBFX1BSSU5USywgMCwgMCwiU2VjdGlvbiBpcyBub3QgV3JpdGFibGUuLi5IZW5jZSBjYW4ndCBDb3JydXB0IHNpZ25hdHVyZSIpOwogCQkJcmV0dXJuIFNFQ1RPUl9JU19OT1RfV1JJVEFCTEU7CiAJCX0KIAl9CkBAIC01MTU1LDcgKzUxNTUsNyBAQAogCiAJaWYoSXNTZWN0aW9uV3JpdGFibGUoQWRhcHRlcixlRmxhc2gyeFNlY3Rpb25WYWwpICE9IFRSVUUpCiAJewotCQlCQ01fREVCVUdfUFJJTlQoQWRhcHRlcixEQkdfVFlQRV9QUklOVEssIDAsIDAsIlNlY3Rpb24gaXMgbm90IFdyaXRhYmxlLi4uSGVuY2UgY2FudCBDb3JydXB0IHNpZ25hdHVyZSIpOworCQlCQ01fREVCVUdfUFJJTlQoQWRhcHRlcixEQkdfVFlQRV9QUklOVEssIDAsIDAsIlNlY3Rpb24gaXMgbm90IFdyaXRhYmxlLi4uSGVuY2UgY2FuJ3QgQ29ycnVwdCBzaWduYXR1cmUiKTsKIAkJcmV0dXJuIFNFQ1RPUl9JU19OT1RfV1JJVEFCTEU7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL1JFQURNRSBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvUkVBRE1FCmluZGV4IDk5ZTY3NjYuLmY4ZmFjYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvUkVBRE1FCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvUkVBRE1FCkBAIC03MSw3ICs3MSw3IEBACiBwYXNzaXZlIG9wZXJhdGlvbi4gVHJhbnNtaXNzaW9uIG9uIHRob3NlIGNoYW5uZWxzIGlzIHN1cHByZXNzZWQgdW50aWwKIGFwcHJvcHJpYXRlIG90aGVyIHRyYWZmaWMgaXMgb2JzZXJ2ZWQgb24gdGhvc2UgY2hhbm5lbHMuCiAKLVdpdGhpbiB0aGUgZHJpdmVyLCB3ZSB1c2UgdGhlIGZpY3RpY2lvdXMgY291bnRyeSBjb2RlICJYMiIgdG8gcmVwcmVzZW50IHRoaXMKK1dpdGhpbiB0aGUgZHJpdmVyLCB3ZSB1c2UgdGhlIGZpY3RpdGlvdXMgY291bnRyeSBjb2RlICJYMiIgdG8gcmVwcmVzZW50IHRoaXMKIHdvcmxkd2lkZSByZWd1bGF0b3J5IGRvbWFpbi4gVGhlcmUgaXMgY3VycmVudGx5IG5vIGludGVyZmFjZSB0byBjb25maWd1cmUgYQogZGlmZmVyZW50IGRvbWFpbi4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtZm1hYy9iY21zZGhfc2RtbWMuYyBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbWZtYWMvYmNtc2RoX3NkbW1jLmMKaW5kZXggNjUzMTNmYS4uNzFjMzU3MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtZm1hYy9iY21zZGhfc2RtbWMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21mbWFjL2JjbXNkaF9zZG1tYy5jCkBAIC0yNjQsNyArMjY0LDcgQEAKIH0KICNlbmRpZgkJCQkvKiBkZWZpbmVkKE9PQl9JTlRSX09OTFkpICYmIGRlZmluZWQoSFdfT09CKSAqLwogCi0vKiBDb25maWd1cmUgY2FsbGJhY2sgdG8gY2xpZW50IHdoZW4gd2UgcmVjaWV2ZSBjbGllbnQgaW50ZXJydXB0ICovCisvKiBDb25maWd1cmUgY2FsbGJhY2sgdG8gY2xpZW50IHdoZW4gd2UgcmVjZWl2ZSBjbGllbnQgaW50ZXJydXB0ICovCiBleHRlcm4gU0RJT0hfQVBJX1JDCiBzZGlvaF9pbnRlcnJ1cHRfcmVnaXN0ZXIoc2Rpb2hfaW5mb190ICpzZCwgc2Rpb2hfY2JfZm5fdCBmbiwgdm9pZCAqYXJnaCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbWZtYWMvZGhkX2N1c3RvbV9ncGlvLmMgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21mbWFjL2RoZF9jdXN0b21fZ3Bpby5jCmluZGV4IGNiZmExYzEuLjFjZjZjNWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbWZtYWMvZGhkX2N1c3RvbV9ncGlvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtZm1hYy9kaGRfY3VzdG9tX2dwaW8uYwpAQCAtNDYsNyArNDYsNyBAQAogI2luY2x1ZGUgPG1hY2gvZ3Bpby5oPgogI2VuZGlmCiAKLS8qIEN1c3RvbWVyIHNwZWNpZmljIEhvc3QgR1BJTyBkZWZpbnRpb24gICovCisvKiBDdXN0b21lciBzcGVjaWZpYyBIb3N0IEdQSU8gZGVmaW5pdGlvbiAgKi8KIHN0YXRpYyBpbnQgZGhkX29vYl9ncGlvX251bSA9IC0xOwkvKiBHRyAxOSAqLwogCiBtb2R1bGVfcGFyYW0oZGhkX29vYl9ncGlvX251bSwgaW50LCAwNjQ0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbWZtYWMvZGhkX2xpbnV4LmMgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21mbWFjL2RoZF9saW51eC5jCmluZGV4IDAyYzZkNDQuLmRkMDM3NTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbWZtYWMvZGhkX2xpbnV4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtZm1hYy9kaGRfbGludXguYwpAQCAtNDc4LDcgKzQ3OCw3IEBACiAJCQlkaGRfc2V0X3BhY2tldF9maWx0ZXIoMSwgZGhkKTsKIAogCQkJLyogaWYgZHRpbSBza2lwIHNldHVwIGFzIGRlZmF1bHQgZm9yY2UgaXQKLQkJCSAqIHRvIHdha2UgZWFjaCB0aHJpZCBkdGltCisJCQkgKiB0byB3YWtlIGVhY2ggdGhpcmQgZHRpbQogCQkJICogZm9yIGJldHRlciBwb3dlciBzYXZpbmcuCiAJCQkgKiBOb3RlIHRoYXQgc2lkZSBlZmZlY3QgaXMgY2hhbmNlIHRvIG1pc3MgQkMvTUMKIAkJCSAqIHBhY2tldApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtZm1hYy9kaGRfc2Rpby5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtZm1hYy9kaGRfc2Rpby5jCmluZGV4IDEwNjYyNzAuLjQ2NGY1MmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbWZtYWMvZGhkX3NkaW8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21mbWFjL2RoZF9zZGlvLmMKQEAgLTM2NTksNyArMzY1OSw3IEBACiAJCQkgKiBjb250cm9sIHBrdCByZWNlaXZlcy4KIAkJCSAqIExhdGVyIHdlIHVzZSBidWZmZXItcG9sbCBmb3IgZGF0YSBhcyB3ZWxsCiAJCQkgKiBhcyBjb250cm9sIHBhY2tldHMuCi0JCQkgKiBUaGlzIGlzIHJlcXVpcmVkIGJlY3Vhc2UgZGhkIHJlY2VpdmVzIGZ1bGwKKwkJCSAqIFRoaXMgaXMgcmVxdWlyZWQgYmVjYXVzZSBkaGQgcmVjZWl2ZXMgZnVsbAogCQkJICogZnJhbWUgaW4gZ1NQSSB1bmxpa2UgU0RJTy4KIAkJCSAqIEFmdGVyIHRoZSBmcmFtZSBpcyByZWNlaXZlZCB3ZSBoYXZlIHRvCiAJCQkgKiBkaXN0aW5ndWlzaCB3aGV0aGVyIGl0IGlzIGRhdGEKQEAgLTM3NDQsNyArMzc0NCw3IEBACiAJCQkJCWJ1cy0+ZGhkLT5yeF9lcnJvcnMrKzsKIAkJCQkJZGhkX29zX3NkdW5sb2NrX3J4cShidXMtPmRoZCk7CiAJCQkJCS8qIEZvcmNlIHJldHJ5IHcvbm9ybWFsIGhlYWRlciByZWFkLgotCQkJCQkgKiBEb24ndCBhdHRlbXAgTkFLIGZvcgorCQkJCQkgKiBEb24ndCBhdHRlbXB0IE5BSyBmb3IKIAkJCQkJICogZ1NQSQogCQkJCQkgKi8KIAkJCQkJZGhkc2Rpb19yeGZhaWwoYnVzLCB0cnVlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bF9tYWM4MDIxMS5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bF9tYWM4MDIxMS5jCmluZGV4IDc3NGI0ZTkuLmMxYjA3YWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbXNtYWMvd2xfbWFjODAyMTEuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21zbWFjL3dsX21hYzgwMjExLmMKQEAgLTEwNzksNyArMTA3OSw3IEBACiAJICovCiAJaHctPm1heF9yYXRlcyA9IDI7CS8qIFByaW1hcnkgcmF0ZSBhbmQgMSBmYWxsYmFjayByYXRlICovCiAKLQlody0+Y2hhbm5lbF9jaGFuZ2VfdGltZSA9IDcgKiAxMDAwOwkvKiBjaGFubmVsIGNoYW5nZSB0aW1lIGlzIGRlcGVuZGFudCBvbiBjaGlwIGFuZCBiYW5kICAqLworCWh3LT5jaGFubmVsX2NoYW5nZV90aW1lID0gNyAqIDEwMDA7CS8qIGNoYW5uZWwgY2hhbmdlIHRpbWUgaXMgZGVwZW5kZW50IG9uIGNoaXAgYW5kIGJhbmQgICovCiAJaHctPndpcGh5LT5pbnRlcmZhY2VfbW9kZXMgPSBCSVQoTkw4MDIxMV9JRlRZUEVfU1RBVElPTik7CiAKIAlody0+cmF0ZV9jb250cm9sX2FsZ29yaXRobSA9ICJtaW5zdHJlbF9odCI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21zbWFjL3dsY19hbXBkdS5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bGNfYW1wZHUuYwppbmRleCBjNmNkY2Q5Li5mMDA4NjU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21zbWFjL3dsY19hbXBkdS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbXNtYWMvd2xjX2FtcGR1LmMKQEAgLTg5LDcgKzg5LDcgQEAKIC8qIHN0cnVjdHVyZSB0byBob2xkIHR4IGZpZm8gaW5mb3JtYXRpb24gYW5kIHByZS1sb2FkaW5nIHN0YXRlCiAgKiBjb3VudGVycyBzcGVjaWZpYyB0byB0eCB1bmRlcmZsb3dzIG9mIGFtcGR1cwogICogc29tZSBjb3VudGVycyBtaWdodCBiZSByZWR1bmRhbnQgd2l0aCB0aGUgb25lcyBpbiB3bGMgb3IgYW1wZHUgc3RydWN0dXJlcy4KLSAqIFRoaXMgYWxsb3dzIHRvIG1haW50YWluIGEgc3BlY2lmaWMgc3RhdGUgaW5kZXBlbmRhbnRseSBvZgorICogVGhpcyBhbGxvd3MgdG8gbWFpbnRhaW4gYSBzcGVjaWZpYyBzdGF0ZSBpbmRlcGVuZGVudGx5IG9mCiAgKiBob3cgb2Z0ZW4gYW5kL29yIHdoZW4gdGhlIHdsYyBjb3VudGVycyBhcmUgdXBkYXRlZC4KICAqLwogdHlwZWRlZiBzdHJ1Y3Qgd2xjX2ZpZm9faW5mbyB7CkBAIC0yNjUsNyArMjY1LDcgQEAKIAogCXNjYl9hbXBkdS0+bWF4X3BkdSA9ICh1OCkgYW1wZHUtPndsYy0+cHViLT50dW5hYmxlcy0+YW1wZHVudW1tcGR1OwogCi0JLyogZ28gYmFjayB0byBsZWdhY3kgc2l6ZSBpZiBzb21lIHByZWxvYWRpbmcgaXMgb2NjdXJpbmcgKi8KKwkvKiBnbyBiYWNrIHRvIGxlZ2FjeSBzaXplIGlmIHNvbWUgcHJlbG9hZGluZyBpcyBvY2N1cnJpbmcgKi8KIAlmb3IgKGkgPSAwOyBpIDwgTlVNX0ZGUExEX0ZJRk87IGkrKykgewogCQlpZiAoYW1wZHUtPmZpZm9fdGJbaV0uYW1wZHVfcGxkX3NpemUgPiBGRlBMRF9QTERfSU5DUikKIAkJCXNjYl9hbXBkdS0+bWF4X3BkdSA9IEFNUERVX05VTV9NUERVX0xFR0FDWTsKQEAgLTQwNiw3ICs0MDYsNyBAQAogCQkvKgogCQkgICBjb21wdXRlIGEgbmV3IGRtYSB4ZmVyIHJhdGUgZm9yIG1heF9tcGR1IEAgbWF4IG1jcy4KIAkJICAgVGhpcyBpcyB0aGUgbWluaW11bSBkbWEgcmF0ZSB0aGF0Ci0JCSAgIGNhbiBhY2hlaXZlIG5vIHVuZmVyZmxvdyBjb25kaXRpb24gZm9yIHRoZSBjdXJyZW50IG1wZHUgc2l6ZS4KKwkJICAgY2FuIGFjaGlldmUgbm8gdW5mZXJmbG93IGNvbmRpdGlvbiBmb3IgdGhlIGN1cnJlbnQgbXBkdSBzaXplLgogCQkgKi8KIAkJLyogbm90ZSA6IHdlIGRpdmlkZS9tdWx0aXBseSBieSAxMDAgdG8gYXZvaWQgaW50ZWdlciBvdmVyZmxvd3MgKi8KIAkJZmlmby0+ZG1heGZlcnJhdGUgPQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bGNfYm1hYy5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bGNfYm1hYy5jCmluZGV4IDVhOTZkYzMuLjRiNmUxODEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbXNtYWMvd2xjX2JtYWMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21zbWFjL3dsY19ibWFjLmMKQEAgLTE5MTUsNyArMTkxNSw3IEBACiAKIAlwaHlfYndfY2xrYml0cyA9IHdsY19waHlfY2xrX2J3Yml0cyh3bGNfaHctPmJhbmQtPnBpKTsKIAotCS8qIFNwZWNmaWMgcmVzZXQgc2VxdWVuY2UgcmVxdWlyZWQgZm9yIE5QSFkgcmV2IDMgYW5kIDQgKi8KKwkvKiBTcGVjaWZpYyByZXNldCBzZXF1ZW5jZSByZXF1aXJlZCBmb3IgTlBIWSByZXYgMyBhbmQgNCAqLwogCWlmIChXTENJU05QSFkod2xjX2h3LT5iYW5kKSAmJiBOUkVWX0dFKHdsY19ody0+YmFuZC0+cGh5cmV2LCAzKSAmJgogCSAgICBOUkVWX0xFKHdsY19ody0+YmFuZC0+cGh5cmV2LCA0KSkgewogCQkvKiBTZXQgdGhlIFBIWSBiYW5kd2lkdGggKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbXNtYWMvd2xjX21haW4uYyBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbXNtYWMvd2xjX21haW4uYwppbmRleCA2MzliNWQ3Li5hYjdhYjg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21zbWFjL3dsY19tYWluLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bGNfbWFpbi5jCkBAIC02MjgzLDcgKzYyODMsNyBAQAogCSAgICAgICAoKHByZWFtYmxlX3R5cGVbMV0gPT0gV0xDX01NX1BSRUFNQkxFKSA9PQogCQkodHhoLT5NTW9kZUZickxlbiAhPSAwKSkpOwogCi0JYWMgPSB3bWVfZmlmbzJhY1txdWV1ZV07CisJYWMgPSBza2JfZ2V0X3F1ZXVlX21hcHBpbmcocCk7CiAJaWYgKFNDQl9XTUUoc2NiKSAmJiBxb3MgJiYgd2xjLT5lZGNmX3R4b3BbYWNdKSB7CiAJCXVpbnQgZnJhZ19kdXIsIGR1ciwgZHVyX2ZhbGxiYWNrOwogCkBAIC02OTE5LDggKzY5MTksNyBAQAogCQlwcmVhbWJsZSA9IDA7CiAJCWlmIChJU19DQ0socnNwZWMpKSB7CiAJCQlpZiAocnhoLT5QaHlSeFN0YXR1c18wICYgUFJYUzBfU0hPUlRIKQotCQkJCVdMX0VSUk9SKCJTaG9ydCBDQ0tcbiIpOwotCQkJcnhfc3RhdHVzLT5mbGFnIHw9IFJYX0ZMQUdfU0hPUlRQUkU7CisJCQkJcnhfc3RhdHVzLT5mbGFnIHw9IFJYX0ZMQUdfU0hPUlRQUkU7CiAJCX0gZWxzZSBpZiAoSVNfT0ZETShyc3BlYykpIHsKIAkJCXJ4X3N0YXR1cy0+ZmxhZyB8PSBSWF9GTEFHX1NIT1JUUFJFOwogCQl9IGVsc2UgewpAQCAtNzA3OSwxMCArNzA3OCw4IEBACiAJaWYgKGllZWU4MDIxMV9pc19wcm9iZV9yZXEoaC0+ZnJhbWVfY29udHJvbCkpCiAJCWdvdG8gdG9zczsKIAotCWlmIChpc19hbXNkdSkgewotCQlXTF9FUlJPUigiJXM6IGlzX2Ftc2R1IGNhdXNpbmcgdG9zc1xuIiwgX19mdW5jX18pOworCWlmIChpc19hbXNkdSkKIAkJZ290byB0b3NzOwotCX0KIAogCXdsY19yZWN2Y3RsKHdsYywgcnhoLCBwKTsKIAlyZXR1cm47CkBAIC04Mjk1LDcgKzgyOTIsNyBAQAogCXJldHVybiAocS0+c3RvcHBlZCAmIHByaW9fbWFzaykgPT0gcHJpb19tYXNrOwogfQogCi0vKiBwcm9wb2dhdGUgdGhlIGZsb3cgY29udHJvbCB0byBhbGwgaW50ZXJmYWNlcyB1c2luZyB0aGUgZ2l2ZW4gdHggcXVldWUgKi8KKy8qIHByb3BhZ2F0ZSB0aGUgZmxvdyBjb250cm9sIHRvIGFsbCBpbnRlcmZhY2VzIHVzaW5nIHRoZSBnaXZlbiB0eCBxdWV1ZSAqLwogdm9pZCB3bGNfdHhmbG93Y29udHJvbChzdHJ1Y3Qgd2xjX2luZm8gKndsYywgc3RydWN0IHdsY190eHFfaW5mbyAqcWksCiAJCSAgICAgICBib29sIG9uLCBpbnQgcHJpbykKIHsKQEAgLTg0NjIsNyArODQ1OSw3IEBACiB9CiAKIC8qCi0gKiBGbGFnICdzY2FuIGluIHByb2dyZXNzJyB0byB3aXRob2xkIGR5bmFtaWMgcGh5IGNhbGlicmF0aW9uCisgKiBGbGFnICdzY2FuIGluIHByb2dyZXNzJyB0byB3aXRoaG9sZCBkeW5hbWljIHBoeSBjYWxpYnJhdGlvbgogICovCiB2b2lkIHdsY19zY2FuX3N0YXJ0KHN0cnVjdCB3bGNfaW5mbyAqd2xjKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bGNfcmF0ZS5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9icmNtc21hYy93bGNfcmF0ZS5jCmluZGV4IDBjZmEzNjAuLmQyODRmMWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvYnJjbXNtYWMvd2xjX3JhdGUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2JyY21zbWFjL3dsY19yYXRlLmMKQEAgLTMzMiw3ICszMzIsNyBAQAogCQlyZXR1cm4gZmFsc2U7CiB9CiAKLS8qIGNhbHVjbGF0ZSB0aGUgcmF0ZSBvZiBhIHJ4J2QgZnJhbWUgYW5kIHJldHVybiBpdCBhcyBhIHJhdGVzcGVjICovCisvKiBjYWxjdWxhdGUgdGhlIHJhdGUgb2YgYSByeCdkIGZyYW1lIGFuZCByZXR1cm4gaXQgYXMgYSByYXRlc3BlYyAqLwogcmF0ZXNwZWNfdCBCQ01GQVNUUEFUSCB3bGNfY29tcHV0ZV9yc3BlYyhkMTFyeGhkcl90ICpyeGgsIHU4ICpwbGNwKQogewogCWludCBwaHlfdHlwZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvaW5jbHVkZS9iY21zcm9tX2ZtdC5oIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9pbmNsdWRlL2JjbXNyb21fZm10LmgKaW5kZXggYWUyYmZmOC4uNDc2ODk2OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9pbmNsdWRlL2JjbXNyb21fZm10LmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9pbmNsdWRlL2JjbXNyb21fZm10LmgKQEAgLTEwMyw3ICsxMDMsNyBAQAogCiAjZGVmaW5lCVNST01fQ1JDUkVWCQk2MwogCi0vKiBTUk9NIFJldiA0OiBSZWFsbG9jYXRlIHRoZSBzb2Z0d2FyZSBwYXJ0IG9mIHRoZSBzcm9tIHRvIGFjY29tb2RhdGUKKy8qIFNST00gUmV2IDQ6IFJlYWxsb2NhdGUgdGhlIHNvZnR3YXJlIHBhcnQgb2YgdGhlIHNyb20gdG8gYWNjb21tb2RhdGUKICAqIE1JTU8gZmVhdHVyZXMuIEl0IGFzc3VtZXMgdXAgdG8gdHdvIFBDSUUgZnVuY3Rpb25zIGFuZCA0NDAgYnl0ZXMKICAqIG9mIHVzZWFibGUgc3JvbSBpLmUuIHRoZSB1c2VhYmxlIHN0b3JhZ2UgaW4gY2hpcHMgd2l0aCBPVFAgdGhhdAogICogaW1wbGVtZW50cyBoYXJkd2FyZSByZWR1bmRhbmN5LgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9pbmNsdWRlL2huZHNvYy5oIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9pbmNsdWRlL2huZHNvYy5oCmluZGV4IDk3NDdjYzQuLjY0MzU2ODYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvaW5jbHVkZS9obmRzb2MuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL2luY2x1ZGUvaG5kc29jLmgKQEAgLTE4MSw3ICsxODEsNyBAQAogICogY29udmVudGlvbnMgZm9yIHRoZSB1c2UgdGhlIGZsYXNoIHNwYWNlOgogICovCiAKLS8qIE1pbnVtdW0gYW1vdW50IG9mIGZsYXNoIHdlIHN1cHBvcnQgKi8KKy8qIE1pbmltdW0gYW1vdW50IG9mIGZsYXNoIHdlIHN1cHBvcnQgKi8KICNkZWZpbmUgRkxBU0hfTUlOCQkweDAwMDIwMDAwCS8qIE1pbmltdW0gZmxhc2ggc2l6ZSAqLwogCiAvKiBBIGJvb3QvYmluYXJ5IG1heSBoYXZlIGFuIGVtYmVkZGVkIGJsb2NrIHRoYXQgZGVzY3JpYmVzIGl0cyBzaXplICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL2JjbW90cC5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL2JjbW90cC5jCmluZGV4IGJhNzFjMTAuLjE3OTkxMjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9iY21vdHAuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3V0aWwvYmNtb3RwLmMKQEAgLTIxMyw3ICsyMTMsNyBAQAogCXJldHVybiAoaW50KXN0OwogfQogCi0vKiBDYWxjdWxhdGUgbWF4IEhXL1NXIHJlZ2lvbiBieXRlIHNpemUgYnkgc3Vic3RyYWN0aW5nIGZ1c2UgcmVnaW9uIGFuZCBjaGVja3N1bSBzaXplLAorLyogQ2FsY3VsYXRlIG1heCBIVy9TVyByZWdpb24gYnl0ZSBzaXplIGJ5IHN1YnRyYWN0aW5nIGZ1c2UgcmVnaW9uIGFuZCBjaGVja3N1bSBzaXplLAogICogb3NpemV3IGlzIG9pLT53c2l6ZSAoT1RQIHNpemUgLSBHVSBzaXplKSBpbiB3b3JkcwogICovCiBzdGF0aWMgaW50IGlweG90cF9tYXhfcmduc3ooc2lfdCAqc2loLCBpbnQgb3NpemV3KQpAQCAtMjI5LDcgKzIyOSw3IEBACiAJCXJldCA9IG9zaXpldyAqIDIgLSBPVFBfU1pfRlVfNzIgLSBPVFBfU1pfQ0hFQ0tTVU07CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCUFTU0VSVCgwKTsJLyogRG9uJ3Qga29udyBhYm91dCB0aGlzIGNoaXAgKi8KKwkJQVNTRVJUKDApOwkvKiBEb24ndCBrbm93IGFib3V0IHRoaXMgY2hpcCAqLwogCX0KIAogCXJldHVybiByZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3V0aWwvYmNtc3JvbS5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL2JjbXNyb20uYwppbmRleCBlY2EzNWI5Li44NTBiZmE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3V0aWwvYmNtc3JvbS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9iY21zcm9tLmMKQEAgLTE4NTksNyArMTg1OSw3IEBACiAKIAkvKgogCSAqIEFwcGx5IENSQyBvdmVyIFNST00gY29udGVudCByZWdhcmRsZXNzIFNST00gaXMgcHJlc2VudCBvciBub3QsCi0JICogYW5kIHVzZSB2YXJpYWJsZSA8ZGV2cGF0aD5zcm9tcmV2J3MgZXhpc3RhbmNlIGluIGZsYXNoIHRvIGRlY2lkZQorCSAqIGFuZCB1c2UgdmFyaWFibGUgPGRldnBhdGg+c3JvbXJldidzIGV4aXN0ZW5jZSBpbiBmbGFzaCB0byBkZWNpZGUKIAkgKiBpZiB3ZSBzaG91bGQgcmV0dXJuIGFuIGVycm9yIHdoZW4gQ1JDIGZhaWxzIG9yIHJlYWQgU1JPTSB2YXJpYWJsZXMKIAkgKiBmcm9tIGZsYXNoLgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL2huZGRtYS5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL2huZGRtYS5jCmluZGV4IDhhODFlYjkuLmJlMzM5ZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9obmRkbWEuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3V0aWwvaG5kZG1hLmMKQEAgLTExNzksNyArMTE3OSw3IEBACiAJCSAgIChyYW5nZSA9PSBITkRETUFfUkFOR0VfQUxMKSA/ICJhbGwiIDoKIAkJICAgKChyYW5nZSA9PQogCQkgICAgIEhORERNQV9SQU5HRV9UUkFOU01JVFRFRCkgPyAidHJhbnNtaXR0ZWQiIDoKLQkJICAgICJ0cmFuc2ZlcmVkIikpKTsKKwkJICAgICJ0cmFuc2ZlcnJlZCIpKSk7CiAKIAlpZiAoZGktPnR4aW4gPT0gZGktPnR4b3V0KQogCQlyZXR1cm47CkBAIC0xNTQ5LDcgKzE1NDksNyBAQAogICogSWYgcmFuZ2UgaXMgSE5ERE1BX1JBTkdFX1RSQU5TTUlUVEVELCByZWNsYWltIGRlc2NyaXB0b3JzIHRoYXQgaGF2ZSBiZQogICogdHJhbnNtaXR0ZWQgYXMgbm90ZWQgYnkgdGhlIGhhcmR3YXJlICJDdXJyRGVzY3IiIHBvaW50ZXIuCiAgKiBJZiByYW5nZSBpcyBITkRETUFfUkFOR0VfVFJBTlNGRVJFRCwgcmVjbGFpbSBkZXNjcmlwdG9ycyB0aGF0IGhhdmUgYmUKLSAqIHRyYW5zZmVyZWQgYnkgdGhlIERNQSBhcyBub3RlZCBieSB0aGUgaGFyZHdhcmUgIkFjdGl2ZURlc2NyIiBwb2ludGVyLgorICogdHJhbnNmZXJyZWQgYnkgdGhlIERNQSBhcyBub3RlZCBieSB0aGUgaGFyZHdhcmUgIkFjdGl2ZURlc2NyIiBwb2ludGVyLgogICogSWYgcmFuZ2UgaXMgSE5ERE1BX1JBTkdFX0FMTCwgcmVjbGFpbSBhbGwgdHhkKHMpIHBvc3RlZCB0byB0aGUgcmluZyBhbmQKICAqIHJldHVybiBhc3NvY2lhdGVkIHBhY2tldCByZWdhcmRsZXNzIG9mIHRoZSB2YWx1ZSBvZiBoYXJkd2FyZSBwb2ludGVycy4KICAqLwpAQCAtMTU2Myw3ICsxNTYzLDcgQEAKIAkJICAgKHJhbmdlID09IEhORERNQV9SQU5HRV9BTEwpID8gImFsbCIgOgogCQkgICAoKHJhbmdlID09CiAJCSAgICAgSE5ERE1BX1JBTkdFX1RSQU5TTUlUVEVEKSA/ICJ0cmFuc21pdHRlZCIgOgotCQkgICAgInRyYW5zZmVyZWQiKSkpOworCQkgICAgInRyYW5zZmVycmVkIikpKTsKIAogCWlmIChkaS0+bnR4ZCA9PSAwKQogCQlyZXR1cm4gTlVMTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9zYnBjbWNpYS5oIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL3NicGNtY2lhLmgKaW5kZXggNmI5OTIzZjUuLmQ0YzE1NjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9zYnBjbWNpYS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9zYnBjbWNpYS5oCkBAIC0xMDksNyArMTA5LDcgQEAKICNkZWZpbmUJQ0lTVFBMX0NGVEFCTEUJCTB4MWIJLyogQ29uZmlnIHRhYmxlIGVudHJ5ICovCiAjZGVmaW5lCUNJU1RQTF9FTkQJCTB4ZmYJLyogRW5kIG9mIHRoZSBDSVMgdHVwbGUgY2hhaW4gKi8KIAotLyogRnVuY3Rpb24gaWRlbnRpZmllciBwcm92aWRlcyBjb250ZXh0IGZvciB0aGUgZnVuY3Rpb24gZXh0ZW50aW9ucyB0dXBsZSAqLworLyogRnVuY3Rpb24gaWRlbnRpZmllciBwcm92aWRlcyBjb250ZXh0IGZvciB0aGUgZnVuY3Rpb24gZXh0ZW5zaW9ucyB0dXBsZSAqLwogI2RlZmluZSBDSVNUUExfRklEX1NESU8JCTB4MGMJLyogRXh0ZW5zaW9ucyBkZWZpbmVkIGJ5IFNESU8gc3BlYyAqLwogCiAvKiBGdW5jdGlvbiBleHRlbnNpb25zIGZvciBMQU5zIChhc3N1bWVkIGZvciBleHRlbnNpb25zIG90aGVyIHRoYW4gU0RJTykgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9zaXV0aWxzLmMgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3V0aWwvc2l1dGlscy5jCmluZGV4IGVkMTY4Y2UuLjZlYmQ3ZjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvdXRpbC9zaXV0aWxzLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS91dGlsL3NpdXRpbHMuYwpAQCAtMTMxOSw3ICsxMzE5LDcgQEAKIH0KIAogLyoKLSAqICBjbG9jayBjb250cm9sIHBvbGljeSBmdW5jdGlvbiB0aHJvdWdodCBjaGlwY29tbW9uCisgKiAgY2xvY2sgY29udHJvbCBwb2xpY3kgZnVuY3Rpb24gdGhyb3VnaCBjaGlwY29tbW9uCiAgKgogICogICAgc2V0IGR5bmFtaWMgY2xrIGNvbnRyb2wgbW9kZSAoZm9yY2VzbG93LCBmb3JjZWZhc3QsIGR5bmFtaWMpCiAgKiAgICByZXR1cm5zIHRydWUgaWYgd2UgYXJlIGZvcmNpbmcgZmFzdCBjbG9jawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9jb21lZGlfZm9wcy5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9jb21lZGlfZm9wcy5jCmluZGV4IGE0Y2ViMjljLi5lN2U3MmI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2NvbWVkaV9mb3BzLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9jb21lZGlfZm9wcy5jCkBAIC0yMDY0LDcgKzIwNjQsNyBAQAogCQkJICAgICBDT01FRElfQ0JfT1ZFUkZMT1cpKSB7CiAJCXJ1bmZsYWdzX21hc2sgfD0gU1JGX1JVTk5JTkc7CiAJfQotCS8qIHJlbWVtYmVyIGlmIGFuIGVycm9yIGV2ZW50IGhhcyBvY2N1cmVkLCBzbyBhbiBlcnJvcgorCS8qIHJlbWVtYmVyIGlmIGFuIGVycm9yIGV2ZW50IGhhcyBvY2N1cnJlZCwgc28gYW4gZXJyb3IKIAkgKiBjYW4gYmUgcmV0dXJuZWQgdGhlIG5leHQgdGltZSB0aGUgdXNlciBkb2VzIGEgcmVhZCgpICovCiAJaWYgKHMtPmFzeW5jLT5ldmVudHMgJiAoQ09NRURJX0NCX0VSUk9SIHwgQ09NRURJX0NCX09WRVJGTE9XKSkgewogCQlydW5mbGFnc19tYXNrIHw9IFNSRl9FUlJPUjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvQVBDSTE3MTBfQ2hyb25vLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL0FQQ0kxNzEwX0Nocm9uby5jCmluZGV4IDY0NGJkYTQuLjQ4MmE0MTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvQVBDSTE3MTBfQ2hyb25vLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9BUENJMTcxMF9DaHJvbm8uYwpAQCAtMTI0LDkgKzEyNCw5IEBACiB8ICAgICAgICAgICAgICAgICAgICAgLTU6IFRoZSBzZWxlY3RlZCBQQ0kgaW5wdXQgY2xvY2sgaXMgd3JvbmcgICAgICAgICAgICAgIHwKIHwgICAgICAgICAgICAgICAgICAgICAtNjogVGltaW5nIHVuaXR5IHNlbGVjdGlvbiBpcyB3cm9uZyAgICAgICAgICAgICAgICAgICAgfAogfCAgICAgICAgICAgICAgICAgICAgIC03OiBCYXNlIHRpbWluZyBzZWxlY3Rpb24gaXMgd3JvbmcgICAgICAgICAgICAgICAgICAgICB8Ci18ICAgICAgICAgICAgICAgICAgICAgLTg6IFlvdSBjYW4gbm90IHVzZWQgdGhlIDQwTUh6IGNsb2NrIHNlbGVjdGlvbiB3aWNoICAgIHwKK3wgICAgICAgICAgICAgICAgICAgICAtODogWW91IGNhbiBub3QgdXNlZCB0aGUgNDBNSHogY2xvY2sgc2VsZWN0aW9uIHdpdGggICAgfAogfCAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzIGJvYXJkICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci18ICAgICAgICAgICAgICAgICAgICAgLTk6IFlvdSBjYW4gbm90IHVzZWQgdGhlIDQwTUh6IGNsb2NrIHNlbGVjdGlvbiB3aWNoICAgIHwKK3wgICAgICAgICAgICAgICAgICAgICAtOTogWW91IGNhbiBub3QgdXNlZCB0aGUgNDBNSHogY2xvY2sgc2VsZWN0aW9uIHdpdGggICAgfAogfCAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzIENIUk9OT1MgdmVyc2lvbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICovCkBAIC03MjEsMTAgKzcyMSwxMCBAQAogCQkJCQkJCQl9CiAJCQkJCQkJfSBlbHNlIHsKIAkJCSAgICAgLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotCQkJCQkJCQkvKiBZb3UgY2FuIG5vdCB1c2VkIHRoZSA0ME1IeiBjbG9jayBzZWxlY3Rpb24gd2ljaCB0aGlzIGJvYXJkICovCisJCQkJCQkJCS8qIFlvdSBjYW4gbm90IHVzZSB0aGUgNDBNSHogY2xvY2sgc2VsZWN0aW9uIHdpdGggdGhpcyBib2FyZCAqLwogCQkJICAgICAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKLQkJCQkJCQkJRFBSSU5USygiWW91IGNhbiBub3QgdXNlZCB0aGUgNDBNSHogY2xvY2sgc2VsZWN0aW9uIHdpY2ggdGhpcyBib2FyZFxuIik7CisJCQkJCQkJCURQUklOVEsoIllvdSBjYW4gbm90IHVzZWQgdGhlIDQwTUh6IGNsb2NrIHNlbGVjdGlvbiB3aXRoIHRoaXMgYm9hcmRcbiIpOwogCQkJCQkJCQlpX1JldHVyblZhbHVlID0KIAkJCQkJCQkJCS04OwogCQkJCQkJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvYWRkaV9hbWNjX1M1OTIwLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2FkZGlfYW1jY19TNTkyMC5jCmluZGV4IDkwZTcxZTEuLmI5NzMwOTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvYWRkaV9hbWNjX1M1OTIwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9hZGRpX2FtY2NfUzU5MjAuYwpAQCAtNTksNyArNTksNyBAQAogLyorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsqLwogLyp8IElucHV0IFBhcmFtZXRlcnMgIDogaW50ICAgIGlfTmJPZldvcmRzVG9SZWFkIDogTmJyLiBvZiB3b3JkIHRvIHJlYWQgICAgICAgIHwqLwogLyp8ICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50IGR3X1BDSUJvYXJkRWVwcm9tQWRkcmVzcyA6IEFkZHJlc3Mgb2YgdGhlIGVlcHJvbSB8Ki8KLS8qfCAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIHNob3J0ICAgd19FZXByb21TdGFydEFkZHJlc3MgOiBFZXByb20gc3RyYXQgYWRkcmVzcyAgICAgfCovCisvKnwgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBzaG9ydCAgIHdfRWVwcm9tU3RhcnRBZGRyZXNzIDogRWVwcm9tIHN0YXJ0IGFkZHJlc3MgICAgIHwqLwogLyorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsqLwogLyp8IE91dHB1dCBQYXJhbWV0ZXJzIDogdW5zaWduZWQgc2hvcnQgKiBwd19EYXRhUmVhZCA6IFJlYWQgZGF0YSAgICAgICAgICAgICAgICAgICAgICAgICAgfCovCiAvKistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKyovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2h3ZHJ2X2FwY2kyMDMyLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2h3ZHJ2X2FwY2kyMDMyLmMKaW5kZXggOWRkODU3ZC4uMDAyMjk3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9od2Rydl9hcGNpMjAzMi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvaHdkcnZfYXBjaTIwMzIuYwpAQCAtNDk4LDcgKzQ5OCw3IEBACiAJc3RydWN0IGNvbWVkaV9kZXZpY2UgKmRldiA9IGQ7CiAJdW5zaWduZWQgaW50IHVpX0RPOwogCi0JdWlfRE8gPSBpbmwoZGV2cHJpdi0+aW9iYXNlICsgQVBDSTIwMzJfRElHSVRBTF9PUF9JUlEpICYgMHgxOwkvKiBDaGVjayBpZiBWQ0MgT1IgQ0MgaW50ZXJydXB0IGhhcyBvY2N1cmVkLiAqLworCXVpX0RPID0gaW5sKGRldnByaXYtPmlvYmFzZSArIEFQQ0kyMDMyX0RJR0lUQUxfT1BfSVJRKSAmIDB4MTsJLyogQ2hlY2sgaWYgVkNDIE9SIENDIGludGVycnVwdCBoYXMgb2NjdXJyZWQuICovCiAKIAlpZiAodWlfRE8gPT0gMCkgewogCQlwcmludGsoIlxuSW50ZXJydXB0IGZyb20gdW5Lbm93biBzb3VyY2VcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9od2Rydl9hcGNpMzEyMC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9od2Rydl9hcGNpMzEyMC5jCmluZGV4IGE4MTNmZGIuLmZjNjEyMTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvaHdkcnZfYXBjaTMxMjAuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2h3ZHJ2X2FwY2kzMTIwLmMKQEAgLTE0OCw3ICsxNDgsNyBAQAogCXVuc2lnbmVkIHNob3J0IHVzX0NvbnZlcnRUaW1pbmcsIHVzX1RtcFZhbHVlLCBpOwogCXVuc2lnbmVkIGNoYXIgYl9UbXA7CiAKLQkvKiAgZml4IGNvbnZlcnRpb24gdGltZSB0byAxMCB1cyAqLworCS8qICBmaXggY29udmVyc2lvbiB0aW1lIHRvIDEwIHVzICovCiAJaWYgKCFkZXZwcml2LT51aV9Fb2NFb3NDb252ZXJzaW9uVGltZSkgewogCQlwcmludGsoIk5vIHRpbWVyMCBWYWx1ZSB1c2luZyAxMCB1c1xuIik7CiAJCXVzX0NvbnZlcnRUaW1pbmcgPSAxMDsKQEAgLTI1MSw3ICsyNTEsNyBAQAogCQkJCUFQQ0kzMTIwX1NFTEVDVF9USU1FUl8wX1dPUkQ7CiAJCQlvdXRiKGJfVG1wLCBkZXZwcml2LT5pb2Jhc2UgKyBBUENJMzEyMF9USU1FUl9DUlQwKTsKIAotCQkJLyogU2V0IHRoZSBjb252ZXJ0aW9uIHRpbWUgKi8KKwkJCS8qIFNldCB0aGUgY29udmVyc2lvbiB0aW1lICovCiAJCQlvdXR3KHVzX0NvbnZlcnRUaW1pbmcsCiAJCQkJZGV2cHJpdi0+aW9iYXNlICsgQVBDSTMxMjBfVElNRVJfVkFMVUUpOwogCkBAIC0zMTEsNyArMzExLDcgQEAKIAkJCQlBUENJMzEyMF9TRUxFQ1RfVElNRVJfMF9XT1JEOwogCQkJb3V0YihiX1RtcCwgZGV2cHJpdi0+aW9iYXNlICsgQVBDSTMxMjBfVElNRVJfQ1JUMCk7CiAKLQkJCS8qIFNldCB0aGUgY29udmVydGlvbiB0aW1lICovCisJCQkvKiBTZXQgdGhlIGNvbnZlcnNpb24gdGltZSAqLwogCQkJb3V0dyh1c19Db252ZXJ0VGltaW5nLAogCQkJCWRldnByaXYtPmlvYmFzZSArIEFQQ0kzMTIwX1RJTUVSX1ZBTFVFKTsKIApAQCAtMzU0LDkgKzM1NCw5IEBACiAJCQkvKiBTdGFydCBjb252ZXJzaW9uICovCiAJCQlvdXR3KDAsIGRldnByaXYtPmlvYmFzZSArIEFQQ0kzMTIwX1NUQVJUX0NPTlZFUlNJT04pOwogCi0JCQkvKiBXYWl0aW5nIG9mIGVuZCBvZiBjb252ZXJ0aW9uIGlmIGludGVycnVwdCBpcyBub3QgaW5zdGFsbGVkICovCisJCQkvKiBXYWl0aW5nIG9mIGVuZCBvZiBjb252ZXJzaW9uIGlmIGludGVycnVwdCBpcyBub3QgaW5zdGFsbGVkICovCiAJCQlpZiAoZGV2cHJpdi0+Yl9Fb2NFb3NJbnRlcnJ1cHQgPT0gQVBDSTMxMjBfRElTQUJMRSkgewotCQkJCS8qIFdhaXRpbmcgdGhlIGVuZCBvZiBjb252ZXJ0aW9uICovCisJCQkJLyogV2FpdGluZyB0aGUgZW5kIG9mIGNvbnZlcnNpb24gKi8KIAkJCQlkbyB7CiAJCQkJCXVzX1RtcFZhbHVlID0KIAkJCQkJCWludyhkZXZwcml2LT5pb2Jhc2UgKwpAQCAtODU0LDcgKzg1NCw3IEBACiAJCQkJYl9EaWdpdGFsT3V0cHV0UmVnaXN0ZXIpICYgMHhGMCkgfAogCQkJQVBDSTMxMjBfU0VMRUNUX1RJTUVSXzBfV09SRDsKIAkJb3V0YihiX1RtcCwgZGV2LT5pb2Jhc2UgKyBBUENJMzEyMF9USU1FUl9DUlQwKTsKLQkJLyogU2V0IHRoZSBjb252ZXJ0aW9uIHRpbWUgKi8KKwkJLyogU2V0IHRoZSBjb252ZXJzaW9uIHRpbWUgKi8KIAkJb3V0dygoKHVuc2lnbmVkIHNob3J0KSB1aV9UaW1lclZhbHVlMCksCiAJCQlkZXYtPmlvYmFzZSArIEFQQ0kzMTIwX1RJTUVSX1ZBTFVFKTsKIAkJYnJlYWs7CkBAIC04NzIsNyArODcyLDcgQEAKIAkJCQliX0RpZ2l0YWxPdXRwdXRSZWdpc3RlcikgJiAweEYwKSB8CiAJCQlBUENJMzEyMF9TRUxFQ1RfVElNRVJfMV9XT1JEOwogCQlvdXRiKGJfVG1wLCBkZXYtPmlvYmFzZSArIEFQQ0kzMTIwX1RJTUVSX0NSVDApOwotCQkvKiBTZXQgdGhlIGNvbnZlcnRpb24gdGltZSAqLworCQkvKiBTZXQgdGhlIGNvbnZlcnNpb24gdGltZSAqLwogCQlvdXR3KCgodW5zaWduZWQgc2hvcnQpIHVpX1RpbWVyVmFsdWUxKSwKIAkJCWRldi0+aW9iYXNlICsgQVBDSTMxMjBfVElNRVJfVkFMVUUpOwogCkBAIC04ODksNyArODg5LDcgQEAKIAkJCUFQQ0kzMTIwX1NFTEVDVF9USU1FUl8wX1dPUkQ7CiAJCW91dGIoYl9UbXAsIGRldi0+aW9iYXNlICsgQVBDSTMxMjBfVElNRVJfQ1JUMCk7CiAKLQkJLyogU2V0IHRoZSBjb252ZXJ0aW9uIHRpbWUgKi8KKwkJLyogU2V0IHRoZSBjb252ZXJzaW9uIHRpbWUgKi8KIAkJb3V0dygoKHVuc2lnbmVkIHNob3J0KSB1aV9UaW1lclZhbHVlMCksCiAJCQlkZXYtPmlvYmFzZSArIEFQQ0kzMTIwX1RJTUVSX1ZBTFVFKTsKIAkJYnJlYWs7CkBAIC0xMTA0LDcgKzExMDQsNyBAQAogCiAvKgogICogNAotICogYW1vdW50IG9mIGJ5dGVzIHRvIGJlIHRyYW5zZmVyZWQgc2V0IHRyYW5zZmVyIGNvdW50IHVzZWQgQURET04KKyAqIGFtb3VudCBvZiBieXRlcyB0byBiZSB0cmFuc2ZlcnJlZCBzZXQgdHJhbnNmZXIgY291bnQgdXNlZCBBRERPTgogICogTVdUQyByZWdpc3RlciBjb21tZW50ZWQgdGVzdGluZwogICogb3V0bChkZXZwcml2LT51aV9EbWFCdWZmZXJVc2VzaXplWzBdLAogICogZGV2cHJpdi0+aV9Jb2Jhc2VBZGRvbitBTUNDX09QX1JFR19BTVdUQyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2h3ZHJ2X2FwY2kzMTIwLmggYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2h3ZHJ2X2FwY2kzMTIwLmgKaW5kZXggYjNjODE5Ny4uNTBlYjBhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9od2Rydl9hcGNpMzEyMC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvaHdkcnZfYXBjaTMxMjAuaApAQCAtMTY5LDcgKzE2OSw3IEBACiAKIAl1bnNpZ25lZCBjaGFyIGJfVHlwZTsJCS8qIEVPQyBvciBFT1MgKi8KIAl1bnNpZ25lZCBjaGFyIGJfSW50ZXJydXB0RmxhZzsJLyogSW50ZXJydXB0IHVzZSBvciBub3QgICAgICAgICAgICAgICAgICAgICovCi0JdW5zaWduZWQgaW50IHVpX0NvbnZlcnRUaW1pbmc7CS8qIFNlbGVjdGlvbiBvZiB0aGUgY29udmVydGlvbiB0aW1lICAgICAgICAqLworCXVuc2lnbmVkIGludCB1aV9Db252ZXJ0VGltaW5nOwkvKiBTZWxlY3Rpb24gb2YgdGhlIGNvbnZlcnNpb24gdGltZSAgICAgICAgKi8KIAl1bnNpZ25lZCBjaGFyIGJfTmJyT2ZDaGFubmVsOwkvKiBOdW1iZXIgb2YgY2hhbm5lbCB0byByZWFkICAgICAgICAgICAgICAgKi8KIAl1bnNpZ25lZCBpbnQgdWlfQ2hhbm5lbExpc3RbTUFYX0FOQUxPR0lOUFVUX0NIQU5ORUxTXTsJLyogTnVtYmVyIG9mIHRoZSBjaGFubmVsIHRvIGJlIHJlYWQgICAgICAgICovCiAJdW5zaWduZWQgaW50IHVpX1JhbmdlTGlzdFtNQVhfQU5BTE9HSU5QVVRfQ0hBTk5FTFNdOwkvKiBHYWluIG9mIGVhY2ggY2hhbm5lbCAgICAgICAgICAgICAgICAgICAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvaHdkcnZfYXBjaTMyMDAuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGRpLWRhdGEvaHdkcnZfYXBjaTMyMDAuYwppbmRleCBhOTNlMjM0Li5jNzVhMWExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRkaS1kYXRhL2h3ZHJ2X2FwY2kzMjAwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkZGktZGF0YS9od2Rydl9hcGNpMzIwMC5jCkBAIC0xMDMsNyArMTAzLDcgQEAKIC8qKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rKi8KIC8qfCBJbnB1dCBQYXJhbWV0ZXJzICA6IGludCAgICBpX05iT2ZXb3Jkc1RvUmVhZCA6IE5ici4gb2Ygd29yZCB0byByZWFkICAgICAgICB8Ki8KIC8qfCAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBkd19QQ0lCb2FyZEVlcHJvbUFkZHJlc3MgOiBBZGRyZXNzIG9mIHRoZSBlZXByb20gfCovCi0vKnwgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBzaG9ydCAgIHdfRWVwcm9tU3RhcnRBZGRyZXNzIDogRWVwcm9tIHN0cmF0IGFkZHJlc3MgICAgIHwqLworLyp8ICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgc2hvcnQgICB3X0VlcHJvbVN0YXJ0QWRkcmVzcyA6IEVlcHJvbSBzdGFydCBhZGRyZXNzICAgICB8Ki8KIC8qKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rKi8KIC8qfCBPdXRwdXQgUGFyYW1ldGVycyA6IHVuc2lnbmVkIHNob3J0ICogcHdfRGF0YVJlYWQgOiBSZWFkIGRhdGEgICAgICAgICAgICAgICAgICAgICAgICAgIHwqLwogLyorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsqLwpAQCAtODQ5LDcgKzg0OSw3IEBACiAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwOlNpbmdsZSBSZWFkCiAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxOlJlYWQgbW9yZSBjaGFubmVsCiAgIDI6U2luZ2xlIHNjYW4KLSAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDM6Q29udGlub3VzIFNjYW4KKyAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDM6Q29udGludW91cyBTY2FuCiAgIGRhdGFbMTNdICAgICAgICAgIDpOdW1iZXIgb2YgY2hhbm5lbHMgdG8gcmVhZAogICB8ICAgICAgICAgICAgICAgICAgICAgICAgICBkYXRhWzE0XSAgICAgICAgICA6UlREIGNvbm5lY3Rpb24gdHlwZQogICA6MDpSVEQgbm90IHVzZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZGxfcGNpOTExOC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkbF9wY2k5MTE4LmMKaW5kZXggNzY2MTAzYy4uNjMyZDVkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkbF9wY2k5MTE4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkbF9wY2k5MTE4LmMKQEAgLTIzLDcgKzIzLDcgQEAKIC0gSWYgY21kLT5zY2FuX2JlZ2luX3NyYz1UUklHX0VYVCB0aGVuIHRyaWdnZXIgaW5wdXQgaXMgVEdJTiAocGluIDQ2KS4KIC0gSWYgY21kLT5jb252ZXJ0X3NyYz1UUklHX0VYVCB0aGVuIHRyaWdnZXIgaW5wdXQgaXMgRVhUVFJHIChwaW4gNDQpLgogLSBJZiBjbWQtPnN0YXJ0X3NyYy9zdG9wX3NyYz1UUklHX0VYVCB0aGVuIHRyaWdnZXIgaW5wdXQgaXMgVEdJTiAocGluIDQ2KS4KLS0gSXQgaXMgbm90IG5lY2Nlc3NhcnkgdG8gaGF2ZSBjbWQuc2Nhbl9lbmRfYXJnPWNtZC5jaGFubGlzdF9sZW4gYnV0CistIEl0IGlzIG5vdCBuZWNlc3NhcnkgdG8gaGF2ZSBjbWQuc2Nhbl9lbmRfYXJnPWNtZC5jaGFubGlzdF9sZW4gYnV0CiAgIGNtZC5zY2FuX2VuZF9hcmcgbW9kdWxvIGNtZC5jaGFubGlzdF9sZW4gbXVzdCBieSAwLgogLSBJZiByZXR1cm4gdmFsdWUgb2YgY21kdGVzdCBpcyA1IHRoZW4geW91J3ZlIGJhZCBjaGFubmVsIGxpc3QKICAgKGl0IGlzbid0IHBvc3NpYmxlIG1peHR1cmUgUy5FLiBhbmQgRElGRiBpbnB1dHMgb3IgYmlwb2xhciBhbmQgdW5pcG9sYXIKQEAgLTgyMyw3ICs4MjMsNyBAQAogCQltb3ZlX2Jsb2NrX2Zyb21fZG1hKGRldiwgcywKIAkJCQkgICAgZGV2cHJpdi0+ZG1hYnVmX3ZpcnRbZGV2cHJpdi0+ZG1hX2FjdGJ1Zl0sCiAJCQkJICAgIHNhbXBsZXNpbmJ1Zik7Ci0JCW0gPSBtIC0gc2FtcGxzOwkJLyogbT0gaG93IG1hbnkgc2FtcGxlcyB3YXMgdHJhbnNmZXJlZCAqLworCQltID0gbSAtIHNhbXBsczsJCS8qIG09IGhvdyBtYW55IHNhbXBsZXMgd2FzIHRyYW5zZmVycmVkICovCiAJfQogLyogRFBSSU5USygiWVlZXG4iKTsgKi8KIApAQCAtMTI5Nyw3ICsxMjk3LDcgQEAKIAlEUFJJTlRLKCIzIGRtYWxlbjA9JWQgZG1hbGVuMT0lZFxuIiwgZG1hbGVuMCwgZG1hbGVuMSk7CiAJLyogdHJhbnNmZXIgd2l0aG91dCBUUklHX1dBS0VfRU9TICovCiAJaWYgKCEoZGV2cHJpdi0+YWlfZmxhZ3MgJiBUUklHX1dBS0VfRU9TKSkgewotCQkvKiBpZiBpdCdzIHBvc3NpYmxlIHRoZW4gYWxsaWduIERNQSBidWZmZXJzIHRvIGxlbmd0aCBvZiBzY2FuICovCisJCS8qIGlmIGl0J3MgcG9zc2libGUgdGhlbiBhbGlnbiBETUEgYnVmZmVycyB0byBsZW5ndGggb2Ygc2NhbiAqLwogCQlpID0gZG1hbGVuMDsKIAkJZG1hbGVuMCA9CiAJCSAgICAoZG1hbGVuMCAvIChkZXZwcml2LT5haV9uX3JlYWxzY2FubGVuIDw8IDEpKSAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRxMTJiLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWRxMTJiLmMKaW5kZXggNGI0NzAwMC4uNTM2MWYzMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2FkcTEyYi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9hZHExMmIuYwpAQCAtNjUsNyArNjUsNyBAQAogICAgd3JpdHRlbiBieSBqZXJlbXkgdGhlbGVyIDx0aGVsZXJnQGliLmNuZWEuZ292LmFyPgogCiAgICBpbnN0aXR1dG8gYmFsc2Vpcm8KLSAgIGNvbWlzaW9uIG5hY2lvbmFsIGRlIGVuZXJnaWEgYXRvbWljYQorICAgY29tbWlzc2lvbiBuYWNpb25hbCBkZSBlbmVyZ2lhIGF0b21pY2EKICAgIHVuaXZlcnNpZGFkIG5hY2lvbmFsIGRlIGN1eW8KICAgIGFyZ2VudGluYQogCkBAIC0zNDIsNyArMzQyLDcgQEAKIAkvKiBjb252ZXJ0IG4gc2FtcGxlcyAqLwogCWZvciAobiA9IDA7IG4gPCBpbnNuLT5uOyBuKyspIHsKIAotCQkvKiB3YWl0IGZvciBlbmQgb2YgY29udmVydGlvbiAqLworCQkvKiB3YWl0IGZvciBlbmQgb2YgY29udmVyc2lvbiAqLwogCQlpID0gMDsKIAkJZG8gewogCQkJLyogdWRlbGF5KDEpOyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2Fkdl9wY2kxNzEwLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWR2X3BjaTE3MTAuYwppbmRleCA0NjZlNjlmLi5kYTJiNzViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWR2X3BjaTE3MTAuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvYWR2X3BjaTE3MTAuYwpAQCAtOTgsNyArOTgsNyBAQAogI2RlZmluZQlTdGF0dXNfRkUJMHgwMTAwCS8qIDE9RklGTyBpcyBlbXB0eSAqLwogI2RlZmluZSBTdGF0dXNfRkgJMHgwMjAwCS8qIDE9RklGTyBpcyBoYWxmIGZ1bGwgKi8KICNkZWZpbmUgU3RhdHVzX0ZGCTB4MDQwMAkvKiAxPUZJRk8gaXMgZnVsbCwgZmF0YWwgZXJyb3IgKi8KLSNkZWZpbmUgU3RhdHVzX0lSUQkweDA4MDAJLyogMT1JUlEgb2NjdXJlZCAqLworI2RlZmluZSBTdGF0dXNfSVJRCTB4MDgwMAkvKiAxPUlSUSBvY2N1cnJlZCAqLwogLyogYml0cyBmcm9tIGNvbnRyb2wgcmVnaXN0ZXIgKFBDSTE3MXhfQ09OVFJPTCkgKi8KICNkZWZpbmUgQ29udHJvbF9DTlQwCTB4MDA0MAkvKiAxPUNOVDAgaGF2ZSBleHRlcm5hbCBzb3VyY2UsCiAJCQkJICogMD1oYXZlIGludGVybmFsIDEwMGtIeiBzb3VyY2UgKi8KQEAgLTExNjEsNyArMTE2MSw3IEBACiAJfQogCiAJaWYgKG5fY2hhbiA+IDEpIHsKLQkJY2hhbnNlZ21lbnRbMF0gPSBjaGFubGlzdFswXTsJLyogIGZpcnN0IGNoYW5uZWwgaXMgZXZlcnl0aW1lIG9rICovCisJCWNoYW5zZWdtZW50WzBdID0gY2hhbmxpc3RbMF07CS8qICBmaXJzdCBjaGFubmVsIGlzIGV2ZXJ5IHRpbWUgb2sgKi8KIAkJZm9yIChpID0gMSwgc2VnbGVuID0gMTsgaSA8IG5fY2hhbjsgaSsrLCBzZWdsZW4rKykgewkvKiAgYnVpbGQgcGFydCBvZiBjaGFubGlzdCAqLwogCQkJLyogIHByaW50aygiJWQuICVkICVkXG4iLGksQ1JfQ0hBTihjaGFubGlzdFtpXSksQ1JfUkFOR0UoY2hhbmxpc3RbaV0pKTsgKi8KIAkJCWlmIChjaGFubGlzdFswXSA9PSBjaGFubGlzdFtpXSkKQEAgLTExNzYsOSArMTE3Niw5IEBACiAJCQkgICAgKENSX0NIQU4oY2hhbnNlZ21lbnRbaSAtIDFdKSArIDEpICUgcy0+bl9jaGFuOwogCQkJaWYgKENSX0FSRUYoY2hhbnNlZ21lbnRbaSAtIDFdKSA9PSBBUkVGX0RJRkYpCiAJCQkJbm93bXVzdGJlY2hhbiA9IChub3dtdXN0YmVjaGFuICsgMSkgJSBzLT5uX2NoYW47Ci0JCQlpZiAobm93bXVzdGJlY2hhbiAhPSBDUl9DSEFOKGNoYW5saXN0W2ldKSkgewkvKiAgY2hhbm5lbCBsaXN0IGlzbid0IGNvbnRpbm91cyA6LSggKi8KKwkJCWlmIChub3dtdXN0YmVjaGFuICE9IENSX0NIQU4oY2hhbmxpc3RbaV0pKSB7CS8qICBjaGFubmVsIGxpc3QgaXNuJ3QgY29udGludW91cyA6LSggKi8KIAkJCQlwcmludGsKLQkJCQkgICAgKCJjaGFubmVsIGxpc3QgbXVzdCBiZSBjb250aW5vdXMhIGNoYW5saXN0WyVpXT0lZCBidXQgbXVzdCBiZSAlZCBvciAlZCFcbiIsCisJCQkJICAgICgiY2hhbm5lbCBsaXN0IG11c3QgYmUgY29udGludW91cyEgY2hhbmxpc3RbJWldPSVkIGJ1dCBtdXN0IGJlICVkIG9yICVkIVxuIiwKIAkJCQkgICAgIGksIENSX0NIQU4oY2hhbmxpc3RbaV0pLCBub3dtdXN0YmVjaGFuLAogCQkJCSAgICAgQ1JfQ0hBTihjaGFubGlzdFswXSkpOwogCQkJCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2NiX3BjaWRhcy5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2NiX3BjaWRhcy5jCmluZGV4IDA5NDE2NDMuLjYxOTY4YTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9jYl9wY2lkYXMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY2JfcGNpZGFzLmMKQEAgLTExNSw3ICsxMTUsNyBAQAogI2RlZmluZSAgIElOVF9NQVNLIDB4MwkJLyogIG1hc2sgb2YgaW50ZXJydXB0IHNlbGVjdCBiaXRzICovCiAjZGVmaW5lICAgSU5URSAweDQJCS8qICBpbnRlcnJ1cHQgZW5hYmxlICovCiAjZGVmaW5lICAgREFIRklFIDB4OAkJLyogIGRhYyBoYWxmIGZ1bGwgaW50ZXJydXB0IGVuYWJsZSAqLwotI2RlZmluZSAgIEVPQUlFCTB4MTAJCS8qICBlbmQgb2YgYXF1aXNpdGlvbiBpbnRlcnJ1cHQgZW5hYmxlICovCisjZGVmaW5lICAgRU9BSUUJMHgxMAkJLyogIGVuZCBvZiBhY3F1aXNpdGlvbiBpbnRlcnJ1cHQgZW5hYmxlICovCiAjZGVmaW5lICAgREFIRkkJMHgyMAkJLyogIGRhYyBoYWxmIGZ1bGwgcmVhZCBzdGF0dXMgLyB3cml0ZSBpbnRlcnJ1cHQgY2xlYXIgKi8KICNkZWZpbmUgICBFT0FJIDB4NDAJCS8qICByZWFkIGVuZCBvZiBhY3EuIGludGVycnVwdCBzdGF0dXMgLyB3cml0ZSBjbGVhciAqLwogI2RlZmluZSAgIElOVCAweDgwCQkvKiAgcmVhZCBpbnRlcnJ1cHQgc3RhdHVzIC8gd3JpdGUgY2xlYXIgKi8KQEAgLTQ0MCw3ICs0NDAsNyBAQAogCXVuc2lnbmVkIGludCBkaXZpc29yMTsKIAl1bnNpZ25lZCBpbnQgZGl2aXNvcjI7CiAJdm9sYXRpbGUgdW5zaWduZWQgaW50IGNvdW50OwkvKiAgbnVtYmVyIG9mIGFuYWxvZyBpbnB1dCBzYW1wbGVzIHJlbWFpbmluZyAqLwotCXZvbGF0aWxlIHVuc2lnbmVkIGludCBhZGNfZmlmb19iaXRzOwkvKiAgYml0cyB0byB3cml0ZSB0byBpbnRlcnVwdC9hZGNmaWZvIHJlZ2lzdGVyICovCisJdm9sYXRpbGUgdW5zaWduZWQgaW50IGFkY19maWZvX2JpdHM7CS8qICBiaXRzIHRvIHdyaXRlIHRvIGludGVycnVwdC9hZGNmaWZvIHJlZ2lzdGVyICovCiAJdm9sYXRpbGUgdW5zaWduZWQgaW50IHM1OTMzX2ludGNzcl9iaXRzOwkvKiAgYml0cyB0byB3cml0ZSB0byBhbWNjIHM1OTMzIGludGVycnVwdCBjb250cm9sL3N0YXR1cyByZWdpc3RlciAqLwogCXZvbGF0aWxlIHVuc2lnbmVkIGludCBhb19jb250cm9sX2JpdHM7CS8qICBiaXRzIHRvIHdyaXRlIHRvIGFvIGNvbnRyb2wgYW5kIHN0YXR1cyByZWdpc3RlciAqLwogCXNob3J0IGFpX2J1ZmZlcltBSV9CVUZGRVJfU0laRV07CkBAIC0xNjUzLDcgKzE2NTMsNyBAQAogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPnNwaW5sb2NrLCBmbGFncyk7CiAJfSBlbHNlIGlmIChzdGF0dXMgJiBFT0FJKSB7CiAJCWNvbWVkaV9lcnJvcihkZXYsCi0JCQkgICAgICJidWchIGVuY291bnRlcmVkIGVuZCBvZiBhcXVpc2l0aW9uIGludGVycnVwdD8iKTsKKwkJCSAgICAgImJ1ZyEgZW5jb3VudGVyZWQgZW5kIG9mIGFjcXVpc2l0aW9uIGludGVycnVwdD8iKTsKIAkJLyogIGNsZWFyIEVPQSBpbnRlcnJ1cHQgbGF0Y2ggKi8KIAkJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+c3BpbmxvY2ssIGZsYWdzKTsKIAkJb3V0dyhkZXZwcml2LT5hZGNfZmlmb19iaXRzIHwgRU9BSSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9jYl9wY2lkYXM2NC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2NiX3BjaWRhczY0LmMKaW5kZXggMjU4M2UxNi4uMWUzMjQxOTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9jYl9wY2lkYXM2NC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9jYl9wY2lkYXM2NC5jCkBAIC0xMDQsNyArMTA0LDcgQEAKICNlbmRpZgogCiAjZGVmaW5lIFRJTUVSX0JBU0UgMjUJCS8qICA0ME1IeiBtYXN0ZXIgY2xvY2sgKi8KLSNkZWZpbmUgUFJFU0NBTEVEX1RJTUVSX0JBU0UJMTAwMDAJLyogIDEwMGtIeiAncHJlc2NhbGVkJyBjbG9jayBmb3Igc2xvdyBhcXVpc2l0aW9uLCBtYXliZSBJJ2xsIHN1cHBvcnQgdGhpcyBzb21lZGF5ICovCisjZGVmaW5lIFBSRVNDQUxFRF9USU1FUl9CQVNFCTEwMDAwCS8qICAxMDBrSHogJ3ByZXNjYWxlZCcgY2xvY2sgZm9yIHNsb3cgYWNxdWlzaXRpb24sIG1heWJlIEknbGwgc3VwcG9ydCB0aGlzIHNvbWVkYXkgKi8KICNkZWZpbmUgRE1BX0JVRkZFUl9TSVpFIDB4MTAwMAogCiAjZGVmaW5lIFBDSV9WRU5ET1JfSURfQ09NUFVURVJCT0FSRFMJMHgxMzA3CkBAIC0xMzYsNyArMTM2LDcgQEAKIAlBRENfREVMQVlfSU5URVJWQUxfVVBQRVJfUkVHID0gMHgxYywJLyogIHVwcGVyIDggYml0cyBvZiBkZWxheSBpbnRlcnZhbCBjb3VudGVyICovCiAJQURDX0NPVU5UX0xPV0VSX1JFRyA9IDB4MWUsCS8qICBsb3dlciAxNiBiaXRzIG9mIGhhcmR3YXJlIGNvbnZlcnNpb24vc2NhbiBjb3VudGVyICovCiAJQURDX0NPVU5UX1VQUEVSX1JFRyA9IDB4MjAsCS8qICB1cHBlciA4IGJpdHMgb2YgaGFyZHdhcmUgY29udmVyc2lvbi9zY2FuIGNvdW50ZXIgKi8KLQlBRENfU1RBUlRfUkVHID0gMHgyMiwJLyogIHNvZnR3YXJlIHRyaWdnZXIgdG8gc3RhcnQgYXF1aXNpdGlvbiAqLworCUFEQ19TVEFSVF9SRUcgPSAweDIyLAkvKiAgc29mdHdhcmUgdHJpZ2dlciB0byBzdGFydCBhY3F1aXNpdGlvbiAqLwogCUFEQ19DT05WRVJUX1JFRyA9IDB4MjQsCS8qICBpbml0aWF0ZXMgc2luZ2xlIGNvbnZlcnNpb24gKi8KIAlBRENfUVVFVUVfQ0xFQVJfUkVHID0gMHgyNiwJLyogIGNsZWFycyBhZGMgcXVldWUgKi8KIAlBRENfUVVFVUVfTE9BRF9SRUcgPSAweDI4LAkvKiAgbG9hZHMgYWRjIHF1ZXVlICovCkBAIC0xOTksNyArMTk5LDcgQEAKIAlBRENfSU5UUl9FT1NDQU5fQklUUyA9IDB4MiwJLyogIGludGVycnVwdCBlbmQgb2Ygc2NhbiAqLwogCUFEQ19JTlRSX0VPU0VRX0JJVFMgPSAweDMsCS8qICBpbnRlcnJ1cHQgZW5kIG9mIHNlcXVlbmNlIChwcm9iYWJseSB3b250IHVzZSB0aGlzIGl0J3MgcHJldHR5IGZhbmN5KSAqLwogCUVOX0FEQ19JTlRSX1NSQ19CSVQgPSAweDQsCS8qICBlbmFibGUgYWRjIGludGVycnVwdCBzb3VyY2UgKi8KLQlFTl9BRENfRE9ORV9JTlRSX0JJVCA9IDB4OCwJLyogIGVuYWJsZSBhZGMgYXF1aXNpdGlvbiBkb25lIGludGVycnVwdCAqLworCUVOX0FEQ19ET05FX0lOVFJfQklUID0gMHg4LAkvKiAgZW5hYmxlIGFkYyBhY3F1aXNpdGlvbiBkb25lIGludGVycnVwdCAqLwogCURBQ19JTlRSX1NSQ19NQVNLID0gMHgzMCwKIAlEQUNfSU5UUl9RRU1QVFlfQklUUyA9IDB4MCwKIAlEQUNfSU5UUl9ISUdIX0NIQU5fQklUUyA9IDB4MTAsCkBAIC0yODY3LDcgKzI4NjcsNyBAQAogCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2LT5zcGlubG9jaywgZmxhZ3MpOwogCi0JLyogIHN0YXJ0IGFxdWlzaXRpb24gKi8KKwkvKiAgc3RhcnQgYWNxdWlzaXRpb24gKi8KIAlpZiAoY21kLT5zdGFydF9zcmMgPT0gVFJJR19OT1cpIHsKIAkJd3JpdGV3KDAsIHByaXYoZGV2KS0+bWFpbl9pb2Jhc2UgKyBBRENfU1RBUlRfUkVHKTsKIAkJREVCVUdfUFJJTlQoInNvZnQgdHJpZ1xuIik7CkBAIC0yOTQyLDcgKzI5NDIsNyBAQAogLyogUmVhZCBmcm9tIDMyIGJpdCB3aWRlIGFpIGZpZm8gb2YgNDAyMCAtIGRlYWwgd2l0aCBpbnNhbmUgZ3JleSBjb2Rpbmcgb2YgcG9pbnRlcnMuCiAgKiBUaGUgcGNpLTQwMjAgaGFyZHdhcmUgb25seSBzdXBwb3J0cwogICogZG1hIHRyYW5zZmVycyAoaXQgb25seSBzdXBwb3J0cyB0aGUgdXNlIG9mIHBpbyBmb3IgZHJhaW5pbmcgdGhlIGxhc3QgcmVtYWluaW5nCi0gKiBwb2ludHMgZnJvbSB0aGUgZmlmbyB3aGVuIGEgZGF0YSBhcXVpc2l0aW9uIG9wZXJhdGlvbiBoYXMgY29tcGxldGVkKS4KKyAqIHBvaW50cyBmcm9tIHRoZSBmaWZvIHdoZW4gYSBkYXRhIGFjcXVpc2l0aW9uIG9wZXJhdGlvbiBoYXMgY29tcGxldGVkKS4KICAqLwogc3RhdGljIHZvaWQgcGlvX2RyYWluX2FpX2ZpZm9fMzIoc3RydWN0IGNvbWVkaV9kZXZpY2UgKmRldikKIHsKQEAgLTMwNDYsNyArMzA0Niw3IEBACiAJCWNvbWVkaV9lcnJvcihkZXYsICJmaWZvIG92ZXJydW4iKTsKIAkJYXN5bmMtPmV2ZW50cyB8PSBDT01FRElfQ0JfRU9BIHwgQ09NRURJX0NCX0VSUk9SOwogCX0KLQkvKiAgc3BpbiBsb2NrIG1ha2VzIHN1cmUgbm9vbmUgZWxzZSBjaGFuZ2VzIHBseCBkbWEgY29udHJvbCByZWcgKi8KKwkvKiAgc3BpbiBsb2NrIG1ha2VzIHN1cmUgbm8gb25lIGVsc2UgY2hhbmdlcyBwbHggZG1hIGNvbnRyb2wgcmVnICovCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+c3BpbmxvY2ssIGZsYWdzKTsKIAlkbWExX3N0YXR1cyA9IHJlYWRiKHByaXYoZGV2KS0+cGx4OTA4MF9pb2Jhc2UgKyBQTFhfRE1BMV9DU19SRUcpOwogCWlmIChwbHhfc3RhdHVzICYgSUNTX0RNQTFfQSkgewkvKiAgZG1hIGNoYW4gMSBpbnRlcnJ1cHQgKi8KQEAgLTMxNzAsNyArMzE3MCw3IEBACiAJYXN5bmMgPSBzLT5hc3luYzsKIAljbWQgPSAmYXN5bmMtPmNtZDsKIAotCS8qICBzcGluIGxvY2sgbWFrZXMgc3VyZSBub29uZSBlbHNlIGNoYW5nZXMgcGx4IGRtYSBjb250cm9sIHJlZyAqLworCS8qICBzcGluIGxvY2sgbWFrZXMgc3VyZSBubyBvbmUgZWxzZSBjaGFuZ2VzIHBseCBkbWEgY29udHJvbCByZWcgKi8KIAlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5zcGlubG9jaywgZmxhZ3MpOwogCWRtYTBfc3RhdHVzID0gcmVhZGIocHJpdihkZXYpLT5wbHg5MDgwX2lvYmFzZSArIFBMWF9ETUEwX0NTX1JFRyk7CiAJaWYgKHBseF9zdGF0dXMgJiBJQ1NfRE1BMF9BKSB7CS8qICBkbWEgY2hhbiAwIGludGVycnVwdCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2NvbWVkaV90ZXN0LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY29tZWRpX3Rlc3QuYwppbmRleCBiMjIwYjMwLi5hODA0NzQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY29tZWRpX3Rlc3QuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY29tZWRpX3Rlc3QuYwpAQCAtODEsNyArODEsNyBAQAogLyogRGF0YSB1bmlxdWUgdG8gdGhpcyBkcml2ZXIgKi8KIHN0cnVjdCB3YXZlZm9ybV9wcml2YXRlIHsKIAlzdHJ1Y3QgdGltZXJfbGlzdCB0aW1lcjsKLQlzdHJ1Y3QgdGltZXZhbCBsYXN0OwkvKiB0aW1lIGF0IHdoaWNoIGxhc3QgdGltZXIgaW50ZXJydXB0IG9jY3VyZWQgKi8KKwlzdHJ1Y3QgdGltZXZhbCBsYXN0OwkvKiB0aW1lIGF0IHdoaWNoIGxhc3QgdGltZXIgaW50ZXJydXB0IG9jY3VycmVkICovCiAJdW5zaWduZWQgaW50IHV2b2x0X2FtcGxpdHVkZTsJLyogd2F2ZWZvcm0gYW1wbGl0dWRlIGluIG1pY3Jvdm9sdHMgKi8KIAl1bnNpZ25lZCBsb25nIHVzZWNfcGVyaW9kOwkvKiB3YXZlZm9ybSBwZXJpb2QgaW4gbWljcm9zZWNvbmRzICovCiAJdW5zaWduZWQgbG9uZyB1c2VjX2N1cnJlbnQ7CS8qIGN1cnJlbnQgdGltZSAobW9kdWxvIHdhdmVmb3JtIHBlcmlvZCkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kYXMxODAwLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZGFzMTgwMC5jCmluZGV4IDZlYTkzZjkuLjYwYzJiMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kYXMxODAwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2RhczE4MDAuYwpAQCAtMTA4Nyw3ICsxMDg3LDcgQEAKIAlyZXR1cm47CiB9CiAKLS8qIGZsdXNoZXMgcmVtYWluaW5nIGRhdGEgZnJvbSBib2FyZCB3aGVuIGV4dGVybmFsIHRyaWdnZXIgaGFzIHN0b3BwZWQgYXF1aXNpdGlvbgorLyogZmx1c2hlcyByZW1haW5pbmcgZGF0YSBmcm9tIGJvYXJkIHdoZW4gZXh0ZXJuYWwgdHJpZ2dlciBoYXMgc3RvcHBlZCBhY3F1aXNpdGlvbgogICogYW5kIHdlIGFyZSB1c2luZyBkbWEgdHJhbnNmZXJzICovCiBzdGF0aWMgdm9pZCBkYXMxODAwX2ZsdXNoX2RtYShzdHJ1Y3QgY29tZWRpX2RldmljZSAqZGV2LAogCQkJICAgICAgc3RydWN0IGNvbWVkaV9zdWJkZXZpY2UgKnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZGFzODAwLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZGFzODAwLmMKaW5kZXggYWVjYWVkYy4uOTZkNDFhZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2RhczgwMC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kYXM4MDAuYwpAQCAtMzkxLDcgKzM5MSw3IEBACiAJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+c3BpbmxvY2ssIGlycV9mbGFncyk7CiAJb3V0YihDT05UUk9MMSwgZGV2LT5pb2Jhc2UgKyBEQVM4MDBfR0FJTik7CS8qIHNlbGVjdCBiYXNlIGFkZHJlc3MgKyA3IHRvIGJlIFNUQVRVUzIgcmVnaXN0ZXIgKi8KIAlzdGF0dXMgPSBpbmIoZGV2LT5pb2Jhc2UgKyBEQVM4MDBfU1RBVFVTMikgJiBTVEFUVVMyX0hDRU47Ci0JLyogZG9uJ3QgcmVsZWFzZSBzcGlubG9jayB5ZXQgc2luY2Ugd2Ugd2FudCB0byBtYWtlIHN1cmUgbm9vbmUgZWxzZSBkaXNhYmxlcyBoYXJkd2FyZSBjb252ZXJzaW9ucyAqLworCS8qIGRvbid0IHJlbGVhc2Ugc3BpbmxvY2sgeWV0IHNpbmNlIHdlIHdhbnQgdG8gbWFrZSBzdXJlIG5vIG9uZSBlbHNlIGRpc2FibGVzIGhhcmR3YXJlIGNvbnZlcnNpb25zICovCiAJaWYgKHN0YXR1cyA9PSAwKSB7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+c3BpbmxvY2ssIGlycV9mbGFncyk7CiAJCXJldHVybiBJUlFfSEFORExFRDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kbW0zMmF0LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZG1tMzJhdC5jCmluZGV4IDY5MzcyOGUuLjJiNGU2ZTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kbW0zMmF0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2RtbTMyYXQuYwpAQCAtNTMyLDcgKzUzMiw3IEBACiAJCW1zYiA9IGRtbV9pbmIoZGV2LCBETU0zMkFUX0FJTVNCKTsKIAogCQkvKiBpbnZlcnQgc2lnbiBiaXQgdG8gbWFrZSByYW5nZSB1bnNpZ25lZCwgdGhpcyBpcyBhbgotCQkgICBpZGlvc3luY3JhY3kgb2YgdGhlIGRpYW1vbmQgYm9hcmQsIGl0IHJldHVybgorCQkgICBpZGlvc3luY3Jhc3kgb2YgdGhlIGRpYW1vbmQgYm9hcmQsIGl0IHJldHVybgogCQkgICBjb252ZXJzaW9ucyBhcyBhIHNpZ25lZCB2YWx1ZSwgaS5lLiAtMzI3NjggdG8KIAkJICAgMzI3NjcsIGZsaXBwaW5nIHRoZSBiaXQgYW5kIGludGVycHJldGluZyBpdCBhcwogCQkgICBzaWduZWQgZ2l2ZXMgeW91IGEgcmFuZ2Ugb2YgMCB0byA2NTUzNSB3aGljaCBpcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2R0MjgxMS5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2R0MjgxMS5jCmluZGV4IGExNjY0Y2EuLjAxMzFkNTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kdDI4MTEuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZHQyODExLmMKQEAgLTU2MCw3ICs1NjAsNyBAQAogCXN3aXRjaCAoZGV2LT5pX2FkbW9kZSkgewogCWNhc2UgQ09NRURJX01ERU1BTkQ6CiAJCWRldi0+bnRyaWcgPSBhZHRyaWctPm4gLSAxOwotCQkvKiBub3QgbmVjY2Vzc2FyeSAqLworCQkvKiBub3QgbmVjZXNzYXJ5ICovCiAJCS8qcHJpbnRrKCJkdDI4MTE6IEFEIHNvZnQgdHJpZ2dlclxuIik7ICovCiAJCS8qb3V0YihEVDI4MTFfQ0xSRVJST1J8RFQyODExX0lOVEVOQiwKIAkJCWRldi0+aW9iYXNlK0RUMjgxMV9BRENTUik7ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZHQ5ODEyLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvZHQ5ODEyLmMKaW5kZXggMDYwNTk4NS4uMzJkOWM0MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2R0OTgxMi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9kdDk4MTIuYwpAQCAtNzczLDcgKzc3Myw3IEBACiAJCQlyZXR2YWwgPSBkdDk4MTJfcmVhZF9pbmZvKGRldiwgMSwgJmZ3LCBzaXplb2YoZncpKTsKIAkJCWlmIChyZXR2YWwgPT0gMCkgewogCQkJCWRldl9pbmZvKCZpbnRlcmZhY2UtPmRldiwKLQkJCQkJICJ1c2JfcmVzZXRfY29uZmlndXJhdGlvbiBzdWNjZWRlZCAiCisJCQkJCSAidXNiX3Jlc2V0X2NvbmZpZ3VyYXRpb24gc3VjY2VlZGVkICIKIAkJCQkJICJhZnRlciAlZCBpdGVyYXRpb25zXG4iLCBpKTsKIAkJCQlicmVhazsKIAkJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9nc2NfaHBkaS5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2dzY19ocGRpLmMKaW5kZXggMTY2MWI1Ny4uYmMwMjBkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2dzY19ocGRpLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2dzY19ocGRpLmMKQEAgLTEwMzEsNyArMTAzMSw3IEBACiAJCXdyaXRlbChocGRpX2ludHJfc3RhdHVzLAogCQkgICAgICAgcHJpdihkZXYpLT5ocGRpX2lvYmFzZSArIElOVEVSUlVQVF9TVEFUVVNfUkVHKTsKIAl9Ci0JLyogIHNwaW4gbG9jayBtYWtlcyBzdXJlIG5vb25lIGVsc2UgY2hhbmdlcyBwbHggZG1hIGNvbnRyb2wgcmVnICovCisJLyogIHNwaW4gbG9jayBtYWtlcyBzdXJlIG5vIG9uZSBlbHNlIGNoYW5nZXMgcGx4IGRtYSBjb250cm9sIHJlZyAqLwogCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPnNwaW5sb2NrLCBmbGFncyk7CiAJZG1hMF9zdGF0dXMgPSByZWFkYihwcml2KGRldiktPnBseDkwODBfaW9iYXNlICsgUExYX0RNQTBfQ1NfUkVHKTsKIAlpZiAocGx4X3N0YXR1cyAmIElDU19ETUEwX0EpIHsJLyogIGRtYSBjaGFuIDAgaW50ZXJydXB0ICovCkBAIC0xMDQ1LDcgKzEwNDUsNyBAQAogCX0KIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPnNwaW5sb2NrLCBmbGFncyk7CiAKLQkvKiAgc3BpbiBsb2NrIG1ha2VzIHN1cmUgbm9vbmUgZWxzZSBjaGFuZ2VzIHBseCBkbWEgY29udHJvbCByZWcgKi8KKwkvKiAgc3BpbiBsb2NrIG1ha2VzIHN1cmUgbm8gb25lIGVsc2UgY2hhbmdlcyBwbHggZG1hIGNvbnRyb2wgcmVnICovCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+c3BpbmxvY2ssIGZsYWdzKTsKIAlkbWExX3N0YXR1cyA9IHJlYWRiKHByaXYoZGV2KS0+cGx4OTA4MF9pb2Jhc2UgKyBQTFhfRE1BMV9DU19SRUcpOwogCWlmIChwbHhfc3RhdHVzICYgSUNTX0RNQTFfQSkgewkvKiAgWFhYICovLyogIGRtYSBjaGFuIDEgaW50ZXJydXB0ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvaWNwX211bHRpLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvaWNwX211bHRpLmMKaW5kZXggMGJhYjM5Yi4uMTI2NTUwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2ljcF9tdWx0aS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9pY3BfbXVsdGkuYwpAQCAtNzE1LDcgKzcxNSw3IEBACiAJaXMgYnVpbHQgY29ycmVjdGx5CiAKIFBhcmFtZXRlcnM6Ci0Jc3RydWN0IGNvbWVkaV9kZXZpY2UgKmRldglQb2ludGVyIHRvIGN1cnJlbnQgc2V2aWNlIHN0cnVjdHVyZQorCXN0cnVjdCBjb21lZGlfZGV2aWNlICpkZXYJUG9pbnRlciB0byBjdXJyZW50IHNlcnZpY2Ugc3RydWN0dXJlCiAJc3RydWN0IGNvbWVkaV9zdWJkZXZpY2UgKnMJUG9pbnRlciB0byBjdXJyZW50IHN1YmRldmljZSBzdHJ1Y3R1cmUKIAl1bnNpZ25lZCBpbnQgKmNoYW5saXN0CVBvaW50ZXIgdG8gcGFja2VkIGNoYW5uZWwgbGlzdAogCXVuc2lnbmVkIGludCBuX2NoYW4JTnVtYmVyIG9mIGNoYW5uZWxzIHRvIHNjYW4KQEAgLTc3Miw3ICs3NzIsNyBAQAogCVN0YXR1cyByZWdpc3Rlci4KIAogUGFyYW1ldGVyczoKLQlzdHJ1Y3QgY29tZWRpX2RldmljZSAqZGV2CVBvaW50ZXIgdG8gY3VycmVudCBzZXZpY2Ugc3RydWN0dXJlCisJc3RydWN0IGNvbWVkaV9kZXZpY2UgKmRldglQb2ludGVyIHRvIGN1cnJlbnQgc2VydmljZSBzdHJ1Y3R1cmUKIAlzdHJ1Y3QgY29tZWRpX3N1YmRldmljZSAqcwlQb2ludGVyIHRvIGN1cnJlbnQgc3ViZGV2aWNlIHN0cnVjdHVyZQogCXVuc2lnbmVkIGludCAqY2hhbmxpc3QJUG9pbnRlciB0byBwYWNrZWQgY2hhbm5lbCBsaXN0CiAJdW5zaWduZWQgaW50IG5fY2hhbglOdW1iZXIgb2YgY2hhbm5lbHMgdG8gc2NhbgpAQCAtODQ4LDcgKzg0OCw3IEBACiAJVGhpcyBmdW5jdGlvbiByZXNldHMgdGhlIGljcCBtdWx0aSBkZXZpY2UgdG8gYSAnc2FmZScgc3RhdGUKIAogUGFyYW1ldGVyczoKLQlzdHJ1Y3QgY29tZWRpX2RldmljZSAqZGV2CVBvaW50ZXIgdG8gY3VycmVudCBzZXZpY2Ugc3RydWN0dXJlCisJc3RydWN0IGNvbWVkaV9kZXZpY2UgKmRldglQb2ludGVyIHRvIGN1cnJlbnQgc2VydmljZSBzdHJ1Y3R1cmUKIAogUmV0dXJuczppbnQJMCA9IHN1Y2Nlc3MKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL21lNDAwMC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL21lNDAwMC5jCmluZGV4IDc1NTExYmEuLmI2OTJmZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9tZTQwMDAuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbWU0MDAwLmMKQEAgLTE4MTAsNyArMTgxMCw3IEBACiAJCSAgICAgICBhaV9jb250ZXh0LT5pcnFfc3RhdHVzX3JlZykgJgogCSAgICBNRTQwMDBfSVJRX1NUQVRVU19CSVRfQUlfSEYpIHsKIAkJSVNSX1BERUJVRwotCQkgICAgKCJtZTQwMDBfYWlfaXNyKCk6IEZpZm8gaGFsZiBmdWxsIGludGVycnVwdCBvY2N1cmVkXG4iKTsKKwkJICAgICgibWU0MDAwX2FpX2lzcigpOiBGaWZvIGhhbGYgZnVsbCBpbnRlcnJ1cHQgb2NjdXJyZWRcbiIpOwogCiAJCS8qIFJlYWQgc3RhdHVzIHJlZ2lzdGVyIHRvIGZpbmQgb3V0IHdoYXQgaGFwcGVuZWQgKi8KIAkJdG1wID0gbWU0MDAwX2lubChkZXYsIGFpX2NvbnRleHQtPmN0cmxfcmVnKTsKQEAgLTE5MDMsNyArMTkwMyw3IEBACiAJaWYgKG1lNDAwMF9pbmwoZGV2LAogCQkgICAgICAgYWlfY29udGV4dC0+aXJxX3N0YXR1c19yZWcpICYgTUU0MDAwX0lSUV9TVEFUVVNfQklUX1NDKSB7CiAJCUlTUl9QREVCVUcKLQkJICAgICgibWU0MDAwX2FpX2lzcigpOiBTYW1wbGUgY291bnRlciBpbnRlcnJ1cHQgb2NjdXJlZFxuIik7CisJCSAgICAoIm1lNDAwMF9haV9pc3IoKTogU2FtcGxlIGNvdW50ZXIgaW50ZXJydXB0IG9jY3VycmVkXG4iKTsKIAogCQlzLT5hc3luYy0+ZXZlbnRzIHw9IENPTUVESV9DQl9CTE9DSyB8IENPTUVESV9DQl9FT0E7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9tcGM2MjQuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9tcGM2MjQuYwppbmRleCBhODllZWJkLi5kZDA5YTZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbXBjNjI0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL21wYzYyNC5jCkBAIC0zOSw4ICszOSw4IEBACiAKIENvbmZpZ3VyYXRpb24gT3B0aW9uczoKICAgWzBdIC0gSS9PIGJhc2UgYWRkcmVzcwotICBbMV0gLSBjb252ZXJ0aW9uIHJhdGUKLQlDb252ZXJ0aW9uIHJhdGUgIFJNUyBub2lzZSAgRWZmZWN0aXZlIE51bWJlciBPZiBCaXRzCisgIFsxXSAtIGNvbnZlcnNpb24gcmF0ZQorCUNvbnZlcnNpb24gcmF0ZSAgUk1TIG5vaXNlICBFZmZlY3RpdmUgTnVtYmVyIE9mIEJpdHMKIAkwICAgICAgMy41MmtIeiAgICAgICAgMjN1ViAgICAgICAgICAgICAgICAxNwogCTEgICAgICAxLjc2a0h6ICAgICAgIDMuNXVWICAgICAgICAgICAgICAgIDIwCiAJMiAgICAgICA4ODBIeiAgICAgICAgIDJ1ViAgICAgICAgICAgICAgICAyMS4zCkBAIC05Myw4ICs5Myw4IEBACiAjZGVmaW5lIE1QQzYyNF9ETVlfQklUICAgICAgICAgICgxPDwzMCkKICNkZWZpbmUgTVBDNjI0X1NHTl9CSVQgICAgICAgICAgKDE8PDI5KQogCi0vKiBDb252ZXJ0aW9uIHNwZWVkcyAqLwotLyogT1NSNCBPU1IzIE9TUjIgT1NSMSBPU1IwICBDb252ZXJ0aW9uIHJhdGUgIFJNUyBub2lzZSAgRU5PQl4KKy8qIENvbnZlcnNpb24gc3BlZWRzICovCisvKiBPU1I0IE9TUjMgT1NSMiBPU1IxIE9TUjAgIENvbnZlcnNpb24gcmF0ZSAgUk1TIG5vaXNlICBFTk9CXgogICogIFggICAgMCAgICAwICAgIDAgICAgMSAgICAgICAgMy41MmtIeiAgICAgICAgMjN1ViAgICAgIDE3CiAgKiAgWCAgICAwICAgIDAgICAgMSAgICAwICAgICAgICAxLjc2a0h6ICAgICAgIDMuNXVWICAgICAgMjAKICAqICBYICAgIDAgICAgMCAgICAxICAgIDEgICAgICAgICA4ODBIeiAgICAgICAgIDJ1ViAgICAgIDIxLjMKQEAgLTIyNyw3ICsyMjcsNyBAQAogCQlicmVhazsKIAlkZWZhdWx0OgogCQlwcmludGsKLQkJICAgIChLRVJOX0VSUiAiaWxsZWdhbCBjb252ZXJ0aW9uIHJhdGUgc2V0dGluZyEiCisJCSAgICAoS0VSTl9FUlIgImlsbGVnYWwgY29udmVyc2lvbiByYXRlIHNldHRpbmchIgogCQkJIiBWYWxpZCBudW1iZXJzIGFyZSAwLi45LiBVc2luZyA5ID0+IDYuODc1IEh6LCAiKTsKIAkJZGV2cHJpdi0+dWxDb252ZXJ0aW9uUmF0ZSA9IE1QQzYyNF9TUEVFRF8zXzUyX2tIejsKIAl9CkBAIC0yOTYsNyArMjk2LDcgQEAKIAl9CiAKIAlmb3IgKG4gPSAwOyBuIDwgaW5zbi0+bjsgbisrKSB7Ci0JCS8qICBUcmlnZ2VyIHRoZSBjb252ZXJ0aW9uICovCisJCS8qICBUcmlnZ2VyIHRoZSBjb252ZXJzaW9uICovCiAJCW91dGIoTVBDNjI0X0FEU0NLLCBkZXYtPmlvYmFzZSArIE1QQzYyNF9BREMpOwogCQl1ZGVsYXkoMSk7CiAJCW91dGIoTVBDNjI0X0FEQ1MgfCBNUEM2MjRfQURTQ0ssIGRldi0+aW9iYXNlICsgTVBDNjI0X0FEQyk7CkBAIC0zMDQsNyArMzA0LDcgQEAKIAkJb3V0YigwLCBkZXYtPmlvYmFzZSArIE1QQzYyNF9BREMpOwogCQl1ZGVsYXkoMSk7CiAKLQkJLyogIFdhaXQgZm9yIHRoZSBjb252ZXJ0aW9uIHRvIGVuZCAqLworCQkvKiAgV2FpdCBmb3IgdGhlIGNvbnZlcnNpb24gdG8gZW5kICovCiAJCWZvciAoaSA9IDA7IGkgPCBUSU1FT1VUOyBpKyspIHsKIAkJCXVjUG9ydCA9IGluYihkZXYtPmlvYmFzZSArIE1QQzYyNF9BREMpOwogCQkJaWYgKHVjUG9ydCAmIE1QQzYyNF9BREJVU1kpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfYXRfYTIxNTAuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9hdF9hMjE1MC5jCmluZGV4IDRkMDA1M2UuLmMxOTJiNzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9hdF9hMjE1MC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9hdF9hMjE1MC5jCkBAIC0xMDQsMTAgKzEwNCwxMCBAQAogI2RlZmluZSBTVEFUVVNfUkVHCQkweDEyCS8qICByZWFkIG9ubHkgKi8KICNkZWZpbmUgICBGTkVfQklUCQkweDEJLyogIGZpZm8gbm90IGVtcHR5ICovCiAjZGVmaW5lICAgT1ZGTF9CSVQJCTB4OAkvKiAgZmlmbyBvdmVyZmxvdyAqLwotI2RlZmluZSAgIEVEQVFfQklUCQkweDEwCS8qICBlbmQgb2YgYXF1aXNpdGlvbiBpbnRlcnJ1cHQgKi8KKyNkZWZpbmUgICBFREFRX0JJVAkJMHgxMAkvKiAgZW5kIG9mIGFjcXVpc2l0aW9uIGludGVycnVwdCAqLwogI2RlZmluZSAgIERDQUxfQklUCQkweDIwCS8qICBvZmZzZXQgY2FsaWJyYXRpb24gaW4gcHJvZ3Jlc3MgKi8KLSNkZWZpbmUgICBJTlRSX0JJVAkJMHg0MAkvKiAgaW50ZXJydXB0IGhhcyBvY2N1cmVkICovCi0jZGVmaW5lICAgRE1BX1RDX0JJVAkJMHg4MAkvKiAgZG1hIHRlcm1pbmFsIGNvdW50IGludGVycnVwdCBoYXMgb2NjdXJlZCAqLworI2RlZmluZSAgIElOVFJfQklUCQkweDQwCS8qICBpbnRlcnJ1cHQgaGFzIG9jY3VycmVkICovCisjZGVmaW5lICAgRE1BX1RDX0JJVAkJMHg4MAkvKiAgZG1hIHRlcm1pbmFsIGNvdW50IGludGVycnVwdCBoYXMgb2NjdXJyZWQgKi8KICNkZWZpbmUgICBJRF9CSVRTKHgpCSgoKHgpID4+IDgpICYgMHgzKQogI2RlZmluZSBJUlFfRE1BX0NOVFJMX1JFRwkJMHgxMgkvKiAgd3JpdGUgb25seSAqLwogI2RlZmluZSAgIERNQV9DSEFOX0JJVFMoeCkJCSgoeCkgJiAweDcpCS8qICBzZXRzIGRtYSBjaGFubmVsICovCkBAIC00MzQsNyArNDM0LDcgQEAKIAlzLT5jYW5jZWwgPSBhMjE1MF9jYW5jZWw7CiAKIAkvKiBuZWVkIHRvIGRvIHRoaXMgZm9yIHNvZnR3YXJlIGNvdW50aW5nIG9mIGNvbXBsZXRlZCBjb252ZXJzaW9ucywgdG8KLQkgKiBwcmV2ZW50IGhhcmR3YXJlIGNvdW50IGZyb20gc3RvcHBpbmcgYXF1aXNpdGlvbiAqLworCSAqIHByZXZlbnQgaGFyZHdhcmUgY291bnQgZnJvbSBzdG9wcGluZyBhY3F1aXNpdGlvbiAqLwogCW91dHcoSFdfQ09VTlRfRElTQUJMRSwgZGV2LT5pb2Jhc2UgKyBJODI1M19NT0RFX1JFRyk7CiAKIAkvKiAgc2V0IGNhcmQncyBpcnEgYW5kIGRtYSBsZXZlbHMgKi8KQEAgLTcyOSw3ICs3MjksNyBAQAogCS8qICBzZW5kIHRyaWdnZXIgY29uZmlnIGJpdHMgKi8KIAlvdXR3KHRyaWdnZXJfYml0cywgZGV2LT5pb2Jhc2UgKyBUUklHR0VSX1JFRyk7CiAKLQkvKiAgc3RhcnQgYXF1aXNpdGlvbiBmb3Igc29mdCB0cmlnZ2VyICovCisJLyogIHN0YXJ0IGFjcXVpc2l0aW9uIGZvciBzb2Z0IHRyaWdnZXIgKi8KIAlpZiAoY21kLT5zdGFydF9zcmMgPT0gVFJJR19OT1cpIHsKIAkJb3V0dygwLCBkZXYtPmlvYmFzZSArIEZJRk9fU1RBUlRfUkVHKTsKIAl9CkBAIC03NjgsNyArNzY4LDcgQEAKIAkvKiAgc2V0dXAgc3RhcnQgdHJpZ2dlcmluZyAqLwogCW91dHcoMCwgZGV2LT5pb2Jhc2UgKyBUUklHR0VSX1JFRyk7CiAKLQkvKiAgc3RhcnQgYXF1aXNpdGlvbiBmb3Igc29mdCB0cmlnZ2VyICovCisJLyogIHN0YXJ0IGFjcXVpc2l0aW9uIGZvciBzb2Z0IHRyaWdnZXIgKi8KIAlvdXR3KDAsIGRldi0+aW9iYXNlICsgRklGT19TVEFSVF9SRUcpOwogCiAJLyogdGhlcmUgaXMgYSAzNS42IHNhbXBsZSBkZWxheSBmb3IgZGF0YSB0byBnZXQgdGhyb3VnaCB0aGUgYW50aWFsaWFzIGZpbHRlciAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfbGFicGMuYwppbmRleCAyNDFmZTUyLi5hYjhmMzcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfbGFicGMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfbGFicGMuYwpAQCAtMTgzLDExICsxODMsMTEgQEAKICNkZWZpbmUgICBPVkVSUlVOX0JJVAkweDIKIC8qIGZpZm8gb3ZlcmZsb3cgKi8KICNkZWZpbmUgICBPVkVSRkxPV19CSVQJMHg0Ci0vKiB0aW1lciBpbnRlcnJ1cHQgaGFzIG9jY3VyZWQgKi8KKy8qIHRpbWVyIGludGVycnVwdCBoYXMgb2NjdXJyZWQgKi8KICNkZWZpbmUgICBUSU1FUl9CSVQJMHg4Ci0vKiBkbWEgdGVybWluYWwgY291bnQgaGFzIG9jY3VyZWQgKi8KKy8qIGRtYSB0ZXJtaW5hbCBjb3VudCBoYXMgb2NjdXJyZWQgKi8KICNkZWZpbmUgICBETUFUQ19CSVQJMHgxMAotLyogZXh0ZXJuYWwgdHJpZ2dlciBoYXMgb2NjdXJlZCAqLworLyogZXh0ZXJuYWwgdHJpZ2dlciBoYXMgb2NjdXJyZWQgKi8KICNkZWZpbmUgICBFWFRfVFJJR19CSVQJMHg0MAogLyogMTIwMCBib2FyZHMgb25seSAqLwogI2RlZmluZSBTVEFUVVMyX1JFRwkweDFkCkBAIC0xMTQ5LDcgKzExNDksNyBAQAogCXJhbmdlID0gQ1JfUkFOR0UoY21kLT5jaGFubGlzdFswXSk7CiAJYXJlZiA9IENSX0FSRUYoY21kLT5jaGFubGlzdFswXSk7CiAKLQkvKiBtYWtlIHN1cmUgYm9hcmQgaXMgZGlzYWJsZWQgYmVmb3JlIHNldHRpbmcgdXAgYXF1aXNpdGlvbiAqLworCS8qIG1ha2Ugc3VyZSBib2FyZCBpcyBkaXNhYmxlZCBiZWZvcmUgc2V0dGluZyB1cCBhY3F1aXNpdGlvbiAqLwogCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPnNwaW5sb2NrLCBmbGFncyk7CiAJZGV2cHJpdi0+Y29tbWFuZDJfYml0cyAmPSB+U1dUUklHX0JJVCAmIH5IV1RSSUdfQklUICYgflBSRVRSSUdfQklUOwogCWRldnByaXYtPndyaXRlX2J5dGUoZGV2cHJpdi0+Y29tbWFuZDJfYml0cywgZGV2LT5pb2Jhc2UgKyBDT01NQU5EMl9SRUcpOwpAQCAtMTM0OSw3ICsxMzQ5LDcgQEAKIAkJZGV2cHJpdi0+Y29tbWFuZDNfYml0cyAmPSB+QURDX0ZORV9JTlRSX0VOX0JJVDsKIAlkZXZwcml2LT53cml0ZV9ieXRlKGRldnByaXYtPmNvbW1hbmQzX2JpdHMsIGRldi0+aW9iYXNlICsgQ09NTUFORDNfUkVHKTsKIAotCS8qICBzdGFydHVwIGFxdWlzaXRpb24gKi8KKwkvKiAgc3RhcnR1cCBhY3F1aXNpdGlvbiAqLwogCiAJLyogIGNvbW1hbmQyIHJlZyAqLwogCS8qICB1c2UgMiBjYXNjYWRlZCBjb3VudGVycyBmb3IgcGFjaW5nICovCkBAIC0xNTcxLDggKzE1NzEsOCBAQAogCWRldnByaXYtPndyaXRlX2J5dGUoMHgxLCBkZXYtPmlvYmFzZSArIERNQVRDX0NMRUFSX1JFRyk7CiB9CiAKLS8qIG1ha2VzIHN1cmUgYWxsIGRhdGEgYWNxdWlyZWQgYnkgYm9hcmQgaXMgdHJhbnNmZXJlZCB0byBjb21lZGkgKHVzZWQKLSAqIHdoZW4gYXF1aXNpdGlvbiBpcyB0ZXJtaW5hdGVkIGJ5IHN0b3Bfc3JjID09IFRSSUdfRVhUKS4gKi8KKy8qIG1ha2VzIHN1cmUgYWxsIGRhdGEgYWNxdWlyZWQgYnkgYm9hcmQgaXMgdHJhbnNmZXJyZWQgdG8gY29tZWRpICh1c2VkCisgKiB3aGVuIGFjcXVpc2l0aW9uIGlzIHRlcm1pbmF0ZWQgYnkgc3RvcF9zcmMgPT0gVFJJR19FWFQpLiAqLwogc3RhdGljIHZvaWQgbGFicGNfZHJhaW5fZHJlZ3Moc3RydWN0IGNvbWVkaV9kZXZpY2UgKmRldikKIHsKIAlpZiAoZGV2cHJpdi0+Y3VycmVudF90cmFuc2ZlciA9PSBpc2FfZG1hX3RyYW5zZmVyKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaWRpby5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaWRpby5jCmluZGV4IDAwNWQyZmUuLjhkZDNhMDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2lkaW8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfcGNpZGlvLmMKQEAgLTgyMSw3ICs4MjEsNyBAQAogCQkJY21kLT5zY2FuX2JlZ2luX2FyZyA9IE1BWF9TUEVFRDsKIAkJCWVycisrOwogCQl9Ci0JCS8qIG5vIG1pbnVtdW0gc3BlZWQgKi8KKwkJLyogbm8gbWluaW11bSBzcGVlZCAqLwogCX0gZWxzZSB7CiAJCS8qIFRSSUdfRVhUICovCiAJCS8qIHNob3VsZCBiZSBsZXZlbC9lZGdlLCBoaS9sbyBzcGVjaWZpY2F0aW9uIGhlcmUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY2w4MTIuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY2w4MTIuYwppbmRleCBjNmRjZTRhLi4wOWZmNDcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcGNsODEyLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbDgxMi5jCkBAIC0zNCw3ICszNCw3IEBACiAgKgkgICAgICAgYW5kIEkgY2Fubid0IHRlc3QgYWxsIGZlYXR1cmVzLikKICAqCiAgKiBUaGlzIGRyaXZlciBzdXBwb3J0cyBpbnNuIGFuZCBjbWQgaW50ZXJmYWNlcy4gU29tZSBib2FyZHMgc3VwcG9ydCBvbmx5IGluc24KLSAqIGJlY291c2UgdGhlaXIgaGFyZHdhcmUgZG9uJ3QgYWxsb3cgbW9yZSAoUENMLTgxMy9CLCBBQ0wtODExMywgSVNPLTgxMykuCisgKiBiZWNhdXNlIHRoZWlyIGhhcmR3YXJlIGRvbid0IGFsbG93IG1vcmUgKFBDTC04MTMvQiwgQUNMLTgxMTMsIElTTy04MTMpLgogICogRGF0YSB0cmFuc2ZlciBvdmVyIERNQSBpcyBzdXBwb3J0ZWQgb25seSB3aGVuIHlvdSBtZWFzdXJlIG9ubHkgb25lCiAgKiBjaGFubmVsLCB0aGlzIGlzIHRvbyBoYXJkd2FyZSBsaW1pdGF0aW9uIG9mIHRoZXNlIGJvYXJkcy4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcGNsODE2LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcGNsODE2LmMKaW5kZXggZWYzY2M0Zi4uOGYzZmM2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbDgxNi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY2w4MTYuYwpAQCAtOTU0LDcgKzk1NCw3IEBACiAJfQogCiAJaWYgKGNoYW5sZW4gPiAxKSB7Ci0JCS8qICBmaXJzdCBjaGFubmVsIGlzIGV2ZXJ5dGltZSBvayAqLworCQkvKiAgZmlyc3QgY2hhbm5lbCBpcyBldmVyeSB0aW1lIG9rICovCiAJCWNoYW5zZWdtZW50WzBdID0gY2hhbmxpc3RbMF07CiAJCWZvciAoaSA9IDEsIHNlZ2xlbiA9IDE7IGkgPCBjaGFubGVuOyBpKyssIHNlZ2xlbisrKSB7CiAJCQkvKiAgYnVpbGQgcGFydCBvZiBjaGFubGlzdCAqLwpAQCAtOTY4LDEwICs5NjgsMTAgQEAKIAkJCW5vd211c3RiZWNoYW4gPQogCQkJICAgIChDUl9DSEFOKGNoYW5zZWdtZW50W2kgLSAxXSkgKyAxKSAlIGNoYW5sZW47CiAJCQlpZiAobm93bXVzdGJlY2hhbiAhPSBDUl9DSEFOKGNoYW5saXN0W2ldKSkgewotCQkJCS8qICBjaGFubmVsIGxpc3QgaXNuJ3QgY29udGlub3VzIDotKCAqLworCQkJCS8qICBjaGFubmVsIGxpc3QgaXNuJ3QgY29udGludW91cyA6LSggKi8KIAkJCQlwcmludGsoS0VSTl9XQVJOSU5HCiAJCQkJICAgICAgICJjb21lZGklZDogcGNsODE2OiBjaGFubmVsIGxpc3QgbXVzdCAiCi0JCQkJICAgICAgICJiZSBjb250aW5vdXMhIGNoYW5saXN0WyVpXT0lZCBidXQgIgorCQkJCSAgICAgICAiYmUgY29udGludW91cyEgY2hhbmxpc3RbJWldPSVkIGJ1dCAiCiAJCQkJICAgICAgICJtdXN0IGJlICVkIG9yICVkIVxuIiwgZGV2LT5taW5vciwKIAkJCQkgICAgICAgaSwgQ1JfQ0hBTihjaGFubGlzdFtpXSksIG5vd211c3RiZWNoYW4sCiAJCQkJICAgICAgIENSX0NIQU4oY2hhbmxpc3RbMF0pKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY2w4MTguYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY2w4MTguYwppbmRleCBmNThkNzViLi5lM2VlYTA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcGNsODE4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbDgxOC5jCkBAIC0xMjMxLDcgKzEyMzEsNyBAQAogCX0KIAogCWlmIChuX2NoYW4gPiAxKSB7Ci0JCS8qICBmaXJzdCBjaGFubmVsIGlzIGV2ZXJ5dGltZSBvayAqLworCQkvKiAgZmlyc3QgY2hhbm5lbCBpcyBldmVyeSB0aW1lIG9rICovCiAJCWNoYW5zZWdtZW50WzBdID0gY2hhbmxpc3RbMF07CiAJCS8qICBidWlsZCBwYXJ0IG9mIGNoYW5saXN0ICovCiAJCWZvciAoaSA9IDEsIHNlZ2xlbiA9IDE7IGkgPCBuX2NoYW47IGkrKywgc2VnbGVuKyspIHsKQEAgLTEyNDUsOSArMTI0NSw5IEBACiAJCQkJYnJlYWs7CiAJCQlub3dtdXN0YmVjaGFuID0KIAkJCSAgICAoQ1JfQ0hBTihjaGFuc2VnbWVudFtpIC0gMV0pICsgMSkgJSBzLT5uX2NoYW47Ci0JCQlpZiAobm93bXVzdGJlY2hhbiAhPSBDUl9DSEFOKGNoYW5saXN0W2ldKSkgewkvKiAgY2hhbm5lbCBsaXN0IGlzbid0IGNvbnRpbm91cyA6LSggKi8KKwkJCWlmIChub3dtdXN0YmVjaGFuICE9IENSX0NIQU4oY2hhbmxpc3RbaV0pKSB7CS8qICBjaGFubmVsIGxpc3QgaXNuJ3QgY29udGludW91cyA6LSggKi8KIAkJCQlwcmludGsKLQkJCQkgICAgKCJjb21lZGklZDogcGNsODE4OiBjaGFubmVsIGxpc3QgbXVzdCBiZSBjb250aW5vdXMhIGNoYW5saXN0WyVpXT0lZCBidXQgbXVzdCBiZSAlZCBvciAlZCFcbiIsCisJCQkJICAgICgiY29tZWRpJWQ6IHBjbDgxODogY2hhbm5lbCBsaXN0IG11c3QgYmUgY29udGludW91cyEgY2hhbmxpc3RbJWldPSVkIGJ1dCBtdXN0IGJlICVkIG9yICVkIVxuIiwKIAkJCQkgICAgIGRldi0+bWlub3IsIGksIENSX0NIQU4oY2hhbmxpc3RbaV0pLAogCQkJCSAgICAgbm93bXVzdGJlY2hhbiwgQ1JfQ0hBTihjaGFubGlzdFswXSkpOwogCQkJCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbW1pby5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbW1pby5jCmluZGV4IDVjODMyZDcuLmYyZTg4ZTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY21taW8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcGNtbWlvLmMKQEAgLTczMyw3ICs3MzMsNyBAQAogCQlicmVhazsKIAogCWNhc2UgSU5TTl9DT05GSUdfRElPX1FVRVJZOgotCQkvKiByZXRyZWl2ZSBmcm9tIHNoYWRvdyByZWdpc3RlciAqLworCQkvKiByZXRyaWV2ZSBmcm9tIHNoYWRvdyByZWdpc3RlciAqLwogCQlkYXRhWzFdID0KIAkJICAgIChzLT5pb19iaXRzICYgKDEgPDwgY2hhbikpID8gQ09NRURJX09VVFBVVCA6IENPTUVESV9JTlBVVDsKIAkJcmV0dXJuIGluc24tPm47CkBAIC0xMjc5LDcgKzEyNzksNyBAQAogCSAgICJubyBidXN5IHdhaXRpbmciIHBvbGljeS4gVGhlIGZhY3QgaXMgdGhhdCB0aGUgaGFyZHdhcmUgaXMKIAkgICBub3JtYWxseSBzbyBmYXN0IHRoYXQgd2UgdXN1YWxseSBvbmx5IG5lZWQgb25lIHRpbWUgdGhyb3VnaCB0aGUgbG9vcAogCSAgIGFueXdheS4gVGhlIGxvbmdlciB0aW1lb3V0IGlzIGZvciByYXJlIG9jY2FzaW9ucyBhbmQgZm9yIGRldGVjdGluZwotCSAgIG5vbi1leGlzdGFudCBoYXJkd2FyZS4gICovCisJICAgbm9uLWV4aXN0ZW50IGhhcmR3YXJlLiAgKi8KIAogCXdoaWxlIChyZXRyeS0tKSB7CiAJCWlmIChpbmIoaW9iYXNlICsgMykgJiAweDgwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbXVpby5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3BjbXVpby5jCmluZGV4IDdhOTI4NzQuLmIyYzJjODkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9wY211aW8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcGNtdWlvLmMKQEAgLTYwNSw3ICs2MDUsNyBAQAogCQlicmVhazsKIAogCWNhc2UgSU5TTl9DT05GSUdfRElPX1FVRVJZOgotCQkvKiByZXRyZWl2ZSBmcm9tIHNoYWRvdyByZWdpc3RlciAqLworCQkvKiByZXRyaWV2ZSBmcm9tIHNoYWRvdyByZWdpc3RlciAqLwogCQlkYXRhWzFdID0KIAkJICAgIChzLT5pb19iaXRzICYgKDEgPDwgY2hhbikpID8gQ09NRURJX09VVFBVVCA6IENPTUVESV9JTlBVVDsKIAkJcmV0dXJuIGluc24tPm47CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcXVhdGVjaF9kYXFwX2NzLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcXVhdGVjaF9kYXFwX2NzLmMKaW5kZXggZWJiYTliYi4uODI5NDJlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3F1YXRlY2hfZGFxcF9jcy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9xdWF0ZWNoX2RhcXBfY3MuYwpAQCAtMzkwLDcgKzM5MCw3IEBACiAKIAlvdXRiKHYsIGRldi0+aW9iYXNlICsgREFRUF9DT05UUk9MKTsKIAotCS8qIFJlc2V0IGFueSBwZW5kaW5nIGludGVycnVwdHMgKG15IGNhcmQgaGFzIGEgdGVuZGFuY3kgdG8gcmVxdWlyZQorCS8qIFJlc2V0IGFueSBwZW5kaW5nIGludGVycnVwdHMgKG15IGNhcmQgaGFzIGEgdGVuZGVuY3kgdG8gcmVxdWlyZQogCSAqIHJlcXVpcmUgbXVsdGlwbGUgcmVhZHMgb24gdGhlIHN0YXR1cyByZWdpc3RlciB0byBhY2hpZXZlIHRoaXMpCiAJICovCiAKQEAgLTc1Miw3ICs3NTIsNyBAQAogCiAJb3V0Yih2LCBkZXYtPmlvYmFzZSArIERBUVBfQ09OVFJPTCk7CiAKLQkvKiBSZXNldCBhbnkgcGVuZGluZyBpbnRlcnJ1cHRzIChteSBjYXJkIGhhcyBhIHRlbmRhbmN5IHRvIHJlcXVpcmUKKwkvKiBSZXNldCBhbnkgcGVuZGluZyBpbnRlcnJ1cHRzIChteSBjYXJkIGhhcyBhIHRlbmRlbmN5IHRvIHJlcXVpcmUKIAkgKiByZXF1aXJlIG11bHRpcGxlIHJlYWRzIG9uIHRoZSBzdGF0dXMgcmVnaXN0ZXIgdG8gYWNoaWV2ZSB0aGlzKQogCSAqLwogCWNvdW50ZXIgPSAxMDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcnRkNTIwLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcnRkNTIwLmMKaW5kZXggMzU3ODU4ZC4uN2YwOWVkNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3J0ZDUyMC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9ydGQ1MjAuYwpAQCAtNzUsNyArNzUsNyBAQAogICAgIGRhczE4MDAsIHNpbmNlIHRoZXkgaGF2ZSB0aGUgYmVzdCBkb2N1bWVudGVkIGNvZGUuICBEcml2ZXIKICAgICBjYl9wY2lkYXM2NC5jIHVzZXMgdGhlIHNhbWUgRE1BIGNvbnRyb2xsZXIuCiAKLSAgICBBcyBmYXIgYXMgSSBjYW4gdGVsbCwgdGhlIEFib3V0IGludGVycnVwdCBkb2VzbnQgd29yayBpZiBTYW1wbGUgaXMKKyAgICBBcyBmYXIgYXMgSSBjYW4gdGVsbCwgdGhlIEFib3V0IGludGVycnVwdCBkb2Vzbid0IHdvcmsgaWYgU2FtcGxlIGlzCiAgICAgYWxzbyBlbmFibGVkLiAgSXQgdHVybnMgb3V0IHRoYXQgQWJvdXQgcmVhbGx5IGlzbid0IG5lZWRlZCwgc2luY2UKICAgICB3ZSBhbHdheXMgY291bnQgZG93biBzYW1wbGVzIHJlYWQuCiAKQEAgLTM3MCw3ICszNzAsNyBAQAogCS8qIHRpbWVyIGdhdGUgKHdoZW4gZW5hYmxlZCkgKi8KIAl1OCB1dGNHYXRlWzRdOwkJLyogMSBleHRyYSBhbGxvd3Mgc2ltcGxlIHJhbmdlIGNoZWNrICovCiAKLQkvKiBzaGFkb3cgcmVnaXN0ZXJzIGFmZmVjdCBvdGhlciByZWdpc3RlcnMsIGJ1dCBjYW50IGJlIHJlYWQgYmFjayAqLworCS8qIHNoYWRvdyByZWdpc3RlcnMgYWZmZWN0IG90aGVyIHJlZ2lzdGVycywgYnV0IGNhbid0IGJlIHJlYWQgYmFjayAqLwogCS8qIFRoZSBtYWNyb3MgYmVsb3cgdXBkYXRlIHRoZXNlIG9uIHdyaXRlcyAqLwogCXUxNiBpbnRNYXNrOwkJLyogaW50ZXJydXB0IG1hc2sgKi8KIAl1MTYgaW50Q2xlYXJNYXNrOwkvKiBpbnRlcnJ1cHQgY2xlYXIgbWFzayAqLwpAQCAtNDg1LDcgKzQ4NSw3IEBACiAjZGVmaW5lIFJ0ZEFkY0ZpZm9HZXQoZGV2KSBcCiAJcmVhZHcoZGV2cHJpdi0+bGFzMStMQVMxX0FEQ19GSUZPKQogCi0vKiBSZWFkIHR3byBBREMgZGF0YSB2YWx1ZXMgKERPRVNOVCBXT1JLKSAqLworLyogUmVhZCB0d28gQURDIGRhdGEgdmFsdWVzIChET0VTTidUIFdPUkspICovCiAjZGVmaW5lIFJ0ZEFkY0ZpZm9HZXQyKGRldikgXAogCXJlYWRsKGRldnByaXYtPmxhczErTEFTMV9BRENfRklGTykKIApAQCAtODU3LDcgKzg1Nyw3IEBACiAJCQlEUFJJTlRLKCJydGQ1MjA6IFBDSSBsYXRlbmN5ID0gJWRcbiIsIHBjaV9sYXRlbmN5KTsKIAkJfQogCi0JCS8qIFVuZG9jdW1lbnRlZCBFUExEIHZlcnNpb24gKGRvZXNudCBtYXRjaCBSVEQgZHJpdmVyIHJlc3VsdHMpICovCisJCS8qIFVuZG9jdW1lbnRlZCBFUExEIHZlcnNpb24gKGRvZXNuJ3QgbWF0Y2ggUlREIGRyaXZlciByZXN1bHRzKSAqLwogCQkvKkRQUklOVEsgKCJydGQ1MjA6IFJlYWRpbmcgZXBsZCBmcm9tICVwXG4iLAogCQkgICBkZXZwcml2LT5sYXMwKzApOwogCQkgICBlcGxkX3ZlcnNpb24gPSByZWFkbCAoZGV2cHJpdi0+bGFzMCswKTsKQEAgLTEyOTEsNyArMTI5MSw3IEBACiAvKgogICAiaW5zdHJ1Y3Rpb25zIiByZWFkL3dyaXRlIGRhdGEgaW4gIm9uZS1zaG90IiBvciAic29mdHdhcmUtdHJpZ2dlcmVkIgogICBtb2RlIChzaW1wbGVzdCBjYXNlKS4KLSAgVGhpcyBkb2VzbnQgdXNlIGludGVycnVwdHMuCisgIFRoaXMgZG9lc24ndCB1c2UgaW50ZXJydXB0cy4KIAogICBOb3RlLCB3ZSBkb24ndCBkbyBhbnkgc2V0dGxpbmcgZGVsYXlzLiAgVXNlIGEgaW5zdHJ1Y3Rpb24gbGlzdCB0bwogICBzZWxlY3QsIGRlbGF5LCB0aGVuIHJlYWQuCkBAIC0yMTIwLDcgKzIxMjAsNyBAQAogfQogCiAvKgotICBTdG9wIGEgcnVubmluZyBkYXRhIGFxdWlzaXRpb24uCisgIFN0b3AgYSBydW5uaW5nIGRhdGEgYWNxdWlzaXRpb24uCiAqLwogc3RhdGljIGludCBydGRfYWlfY2FuY2VsKHN0cnVjdCBjb21lZGlfZGV2aWNlICpkZXYsIHN0cnVjdCBjb21lZGlfc3ViZGV2aWNlICpzKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3M2MjYuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9zNjI2LmMKaW5kZXggZDViYTNhYi4uMjNmYzY0YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3M2MjYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvczYyNi5jCkBAIC0xMzksNyArMTM5LDcgQEAKIAlpbnQgZ290X3JlZ2lvbnM7CiAJc2hvcnQgYWxsb2NhdGVkQnVmOwogCXVpbnQ4X3QgYWlfY21kX3J1bm5pbmc7CS8qICBhaV9jbWQgaXMgcnVubmluZyAqLwotCXVpbnQ4X3QgYWlfY29udGlub3VzOwkvKiAgY29udGlub3VzIGFxdWlzaXRpb24gKi8KKwl1aW50OF90IGFpX2NvbnRpbm91czsJLyogIGNvbnRpbm91cyBhY3F1aXNpdGlvbiAqLwogCWludCBhaV9zYW1wbGVfY291bnQ7CS8qICBudW1iZXIgb2Ygc2FtcGxlcyB0byBhY3F1aXJlICovCiAJdW5zaWduZWQgaW50IGFpX3NhbXBsZV90aW1lcjsKIAkvKiAgdGltZSBiZXR3ZWVuIHNhbXBsZXMgaW4gIHVuaXRzIG9mIHRoZSB0aW1lciAqLwpAQCAtMTA0OCw3ICsxMDQ4LDcgQEAKIAl1aW50OF90IGdyb3VwOwogCXVpbnQxNl90IGlycWJpdDsKIAotCURFQlVHKCJzNjI2X2lycV9oYW5kbGVyOiBpbnRlcnJ1cHQgcmVxdWVzdCByZWNpZXZlZCEhIVxuIik7CisJREVCVUcoInM2MjZfaXJxX2hhbmRsZXI6IGludGVycnVwdCByZXF1ZXN0IHJlY2VpdmVkISEhXG4iKTsKIAogCWlmIChkZXYtPmF0dGFjaGVkID09IDApCiAJCXJldHVybiBJUlFfTk9ORTsKQEAgLTExNjUsMTQgKzExNjUsMTQgQEAKIAkJCQkJCQkoMTYgKiBncm91cCkpKQogCQkJCQkgICAgPT0gMSAmJiBjbWQtPnN0YXJ0X3NyYyA9PSBUUklHX0VYVCkgewogCQkJCQkJREVCVUcKLQkJCQkJCSAgICAoInM2MjZfaXJxX2hhbmRsZXI6IEVkZ2UgY2FwdHVyZSBpbnRlcnJ1cHQgcmVjaWV2ZWQgZnJvbSBjaGFubmVsICVkXG4iLAorCQkJCQkJICAgICgiczYyNl9pcnFfaGFuZGxlcjogRWRnZSBjYXB0dXJlIGludGVycnVwdCByZWNlaXZlZCBmcm9tIGNoYW5uZWwgJWRcbiIsCiAJCQkJCQkgICAgIGNtZC0+c3RhcnRfYXJnKTsKIAogCQkJCQkJLyogIFN0YXJ0IGV4ZWN1dGluZyB0aGUgUlBTIHByb2dyYW0uICovCiAJCQkJCQlNQ19FTkFCTEUoUF9NQzEsIE1DMV9FUlBTMSk7CiAKIAkJCQkJCURFQlVHCi0JCQkJCQkgICAgKCJzNjI2X2lycV9oYW5kbGVyOiBhcXVpc2l0aW9uIHN0YXJ0IHRyaWdnZXJlZCEhIVxuIik7CisJCQkJCQkgICAgKCJzNjI2X2lycV9oYW5kbGVyOiBhY3F1aXNpdGlvbiBzdGFydCB0cmlnZ2VyZWQhISFcbiIpOwogCiAJCQkJCQlpZiAoY21kLT5zY2FuX2JlZ2luX3NyYyA9PQogCQkJCQkJICAgIFRSSUdfRVhUKSB7CkBAIC0xMTk0LDcgKzExOTQsNyBAQAogCQkJCQkgICAgJiYgY21kLT5zY2FuX2JlZ2luX3NyYyA9PQogCQkJCQkgICAgVFJJR19FWFQpIHsKIAkJCQkJCURFQlVHCi0JCQkJCQkgICAgKCJzNjI2X2lycV9oYW5kbGVyOiBFZGdlIGNhcHR1cmUgaW50ZXJydXB0IHJlY2lldmVkIGZyb20gY2hhbm5lbCAlZFxuIiwKKwkJCQkJCSAgICAoInM2MjZfaXJxX2hhbmRsZXI6IEVkZ2UgY2FwdHVyZSBpbnRlcnJ1cHQgcmVjZWl2ZWQgZnJvbSBjaGFubmVsICVkXG4iLAogCQkJCQkJICAgICBjbWQtPnNjYW5fYmVnaW5fYXJnKTsKIAogCQkJCQkJLyogIFRyaWdnZXIgQURDIHNjYW4gbG9vcCBzdGFydCBieSBzZXR0aW5nIFJQUyBTaWduYWwgMC4gKi8KQEAgLTEyMzYsNyArMTIzNiw3IEBACiAJCQkJCSAgICA9PSAxCiAJCQkJCSAgICAmJiBjbWQtPmNvbnZlcnRfc3JjID09IFRSSUdfRVhUKSB7CiAJCQkJCQlERUJVRwotCQkJCQkJICAgICgiczYyNl9pcnFfaGFuZGxlcjogRWRnZSBjYXB0dXJlIGludGVycnVwdCByZWNpZXZlZCBmcm9tIGNoYW5uZWwgJWRcbiIsCisJCQkJCQkgICAgKCJzNjI2X2lycV9oYW5kbGVyOiBFZGdlIGNhcHR1cmUgaW50ZXJydXB0IHJlY2VpdmVkIGZyb20gY2hhbm5lbCAlZFxuIiwKIAkJCQkJCSAgICAgY21kLT5jb252ZXJ0X2FyZyk7CiAKIAkJCQkJCS8qICBUcmlnZ2VyIEFEQyBzY2FuIGxvb3Agc3RhcnQgYnkgc2V0dGluZyBSUFMgU2lnbmFsIDAuICovCkBAIC0xODA1LDcgKzE4MDUsNyBAQAogCQlERUJVRygiczYyNl9haV9jbWQ6IE5VTEwgY29tbWFuZFxuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0gZWxzZSB7Ci0JCURFQlVHKCJzNjI2X2FpX2NtZDogY29tbWFuZCByZWNpZXZlZCEhIVxuIik7CisJCURFQlVHKCJzNjI2X2FpX2NtZDogY29tbWFuZCByZWNlaXZlZCEhIVxuIik7CiAJfQogCiAJaWYgKGRldi0+aXJxID09IDApIHsKQEAgLTE4ODAsNyArMTg4MCw3IEBACiAJCWRldnByaXYtPmFpX2NvbnRpbm91cyA9IDA7CiAJCWJyZWFrOwogCWNhc2UgVFJJR19OT05FOgotCQkvKiAgY29udGlub3VzIGFxdWlzaXRpb24gKi8KKwkJLyogIGNvbnRpbm91cyBhY3F1aXNpdGlvbiAqLwogCQlkZXZwcml2LT5haV9jb250aW5vdXMgPSAxOwogCQlkZXZwcml2LT5haV9zYW1wbGVfY291bnQgPSAwOwogCQlicmVhazsKQEAgLTI1NzAsNyArMjU3MCw3IEBACiAJd2hpbGUgKChSUjcxNDYoUF9JMkNDVFJMKSAmIChJMkNfQlVTWSB8IEkyQ19FUlIpKSA9PSBJMkNfQlVTWSkKIAkJOwogCi0JLyogIFJldHVybiBub24temVybyBpZiBJMkMgZXJyb3Igb2NjdXJlZC4gKi8KKwkvKiAgUmV0dXJuIG5vbi16ZXJvIGlmIEkyQyBlcnJvciBvY2N1cnJlZC4gKi8KIAlyZXR1cm4gUlI3MTQ2KFBfSTJDQ1RSTCkgJiBJMkNfRVJSOwogCiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvdXNiZHV4LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvdXNiZHV4LmMKaW5kZXggYmU5M2MzMC4uZTU0M2U2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3VzYmR1eC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy91c2JkdXguYwpAQCAtMjg1LDcgKzI4NSw3IEBACiAJc2hvcnQgaW50IGFvX2NtZF9ydW5uaW5nOwogCS8qIHB3bSBpcyBydW5uaW5nICovCiAJc2hvcnQgaW50IHB3bV9jbWRfcnVubmluZzsKLQkvKiBjb250aW5vdXMgYXF1aXNpdGlvbiAqLworCS8qIGNvbnRpbm91cyBhY3F1aXNpdGlvbiAqLwogCXNob3J0IGludCBhaV9jb250aW5vdXM7CiAJc2hvcnQgaW50IGFvX2NvbnRpbm91czsKIAkvKiBudW1iZXIgb2Ygc2FtcGxlcyB0byBhY3F1aXJlICovCkBAIC01MDAsNyArNTAwLDcgQEAKIAogCS8qIHRlc3QsIGlmIHdlIHRyYW5zbWl0IG9ubHkgYSBmaXhlZCBudW1iZXIgb2Ygc2FtcGxlcyAqLwogCWlmICghKHRoaXNfdXNiZHV4c3ViLT5haV9jb250aW5vdXMpKSB7Ci0JCS8qIG5vdCBjb250aW5vdXMsIGZpeGVkIG51bWJlciBvZiBzYW1wbGVzICovCisJCS8qIG5vdCBjb250aW51b3VzLCBmaXhlZCBudW1iZXIgb2Ygc2FtcGxlcyAqLwogCQl0aGlzX3VzYmR1eHN1Yi0+YWlfc2FtcGxlX2NvdW50LS07CiAJCS8qIGFsbCBzYW1wbGVzIHJlY2VpdmVkPyAqLwogCQlpZiAodGhpc191c2JkdXhzdWItPmFpX3NhbXBsZV9jb3VudCA8IDApIHsKQEAgLTY1Myw3ICs2NTMsNyBAQAogCQkvKiB0aW1lciB6ZXJvICovCiAJCXRoaXNfdXNiZHV4c3ViLT5hb19jb3VudGVyID0gdGhpc191c2JkdXhzdWItPmFvX3RpbWVyOwogCi0JCS8qIGhhbmRsZSBub24gY29udGlub3VzIGFxdWlzaXRpb24gKi8KKwkJLyogaGFuZGxlIG5vbiBjb250aW5vdXMgYWNxdWlzaXRpb24gKi8KIAkJaWYgKCEodGhpc191c2JkdXhzdWItPmFvX2NvbnRpbm91cykpIHsKIAkJCS8qIGZpeGVkIG51bWJlciBvZiBzYW1wbGVzICovCiAJCQl0aGlzX3VzYmR1eHN1Yi0+YW9fc2FtcGxlX2NvdW50LS07CkBAIC05NTcsNyArOTU3LDcgQEAKIAlpZiAoIWNtZC0+c2Nhbl9iZWdpbl9zcmMgfHwgdG1wICE9IGNtZC0+c2Nhbl9iZWdpbl9zcmMpCiAJCWVycisrOwogCi0JLyogc2Nhbm5pbmcgaXMgY29udGlub3VzICovCisJLyogc2Nhbm5pbmcgaXMgY29udGludW91cyAqLwogCXRtcCA9IGNtZC0+Y29udmVydF9zcmM7CiAJY21kLT5jb252ZXJ0X3NyYyAmPSBUUklHX05PVzsKIAlpZiAoIWNtZC0+Y29udmVydF9zcmMgfHwgdG1wICE9IGNtZC0+Y29udmVydF9zcmMpCkBAIC0xMjIyLDcgKzEyMjIsNyBAQAogCQl1cCgmdGhpc191c2JkdXhzdWItPnNlbSk7CiAJCXJldHVybiAtRUJVU1k7CiAJfQotCS8qIHNldCBjdXJyZW50IGNoYW5uZWwgb2YgdGhlIHJ1bm5pbmcgYXF1aXNpdGlvbiB0byB6ZXJvICovCisJLyogc2V0IGN1cnJlbnQgY2hhbm5lbCBvZiB0aGUgcnVubmluZyBhY3F1aXNpdGlvbiB0byB6ZXJvICovCiAJcy0+YXN5bmMtPmN1cl9jaGFuID0gMDsKIAogCXRoaXNfdXNiZHV4c3ViLT5kdXhfY29tbWFuZHNbMV0gPSBjbWQtPmNoYW5saXN0X2xlbjsKQEAgLTEyODQsNyArMTI4NCw3IEBACiAJCXRoaXNfdXNiZHV4c3ViLT5haV9zYW1wbGVfY291bnQgPSBjbWQtPnN0b3BfYXJnOwogCQl0aGlzX3VzYmR1eHN1Yi0+YWlfY29udGlub3VzID0gMDsKIAl9IGVsc2UgewotCQkvKiBjb250aW5vdXMgYXF1aXNpdGlvbiAqLworCQkvKiBjb250aW5vdXMgYWNxdWlzaXRpb24gKi8KIAkJdGhpc191c2JkdXhzdWItPmFpX2NvbnRpbm91cyA9IDE7CiAJCXRoaXNfdXNiZHV4c3ViLT5haV9zYW1wbGVfY291bnQgPSAwOwogCX0KQEAgLTE1MTUsNyArMTUxNSw3IEBACiAJLyoganVzdCBub3cgd2Ugc2NhbiBhbHNvIGluIHRoZSBoaWdoIHNwZWVkIG1vZGUgZXZlcnkgZnJhbWUgKi8KIAkvKiB0aGlzIGlzIGR1ZSB0byBlaGNpIGRyaXZlciBsaW1pdGF0aW9ucyAqLwogCWlmICgwKSB7CQkvKiAodGhpc191c2JkdXhzdWItPmhpZ2hfc3BlZWQpICovCi0JCS8qIHN0YXJ0IGltbWlkaWF0ZWx5IGEgbmV3IHNjYW4gKi8KKwkJLyogc3RhcnQgaW1tZWRpYXRlbHkgYSBuZXcgc2NhbiAqLwogCQkvKiB0aGUgc2FtcGxpbmcgcmF0ZSBpcyBzZXQgYnkgdGhlIGNvdmVyc2lvbiByYXRlICovCiAJCWNtZC0+c2Nhbl9iZWdpbl9zcmMgJj0gVFJJR19GT0xMT1c7CiAJfSBlbHNlIHsKQEAgLTE1MjUsNyArMTUyNSw3IEBACiAJaWYgKCFjbWQtPnNjYW5fYmVnaW5fc3JjIHx8IHRtcCAhPSBjbWQtPnNjYW5fYmVnaW5fc3JjKQogCQllcnIrKzsKIAotCS8qIHNjYW5uaW5nIGlzIGNvbnRpbm91cyAqLworCS8qIHNjYW5uaW5nIGlzIGNvbnRpbnVvdXMgKi8KIAl0bXAgPSBjbWQtPmNvbnZlcnRfc3JjOwogCS8qIHdlIGFsd2F5cyBvdXRwdXQgYXQgMWtIeiBqdXN0IG5vdyBhbGwgY2hhbm5lbHMgYXQgb25jZSAqLwogCWlmICgwKSB7CQkvKiAodGhpc191c2JkdXhzdWItPmhpZ2hfc3BlZWQpICovCkBAIC0xNjQ1LDcgKzE2NDUsNyBAQAogCWRldl9kYmcoJnRoaXNfdXNiZHV4c3ViLT5pbnRlcmZhY2UtPmRldiwKIAkJImNvbWVkaSVkOiAlc1xuIiwgZGV2LT5taW5vciwgX19mdW5jX18pOwogCi0JLyogc2V0IGN1cnJlbnQgY2hhbm5lbCBvZiB0aGUgcnVubmluZyBhcXVpc2l0aW9uIHRvIHplcm8gKi8KKwkvKiBzZXQgY3VycmVudCBjaGFubmVsIG9mIHRoZSBydW5uaW5nIGFjcXVpc2l0aW9uIHRvIHplcm8gKi8KIAlzLT5hc3luYy0+Y3VyX2NoYW4gPSAwOwogCWZvciAoaSA9IDA7IGkgPCBjbWQtPmNoYW5saXN0X2xlbjsgKytpKSB7CiAJCWNoYW4gPSBDUl9DSEFOKGNtZC0+Y2hhbmxpc3RbaV0pOwpAQCAtMTY5NCw3ICsxNjk0LDcgQEAKIAl0aGlzX3VzYmR1eHN1Yi0+YW9fY291bnRlciA9IHRoaXNfdXNiZHV4c3ViLT5hb190aW1lcjsKIAogCWlmIChjbWQtPnN0b3Bfc3JjID09IFRSSUdfQ09VTlQpIHsKLQkJLyogbm90IGNvbnRpbm91cyAqLworCQkvKiBub3QgY29udGludW91cyAqLwogCQkvKiBjb3VudGVyICovCiAJCS8qIGhpZ2ggc3BlZWQgYWxzbyBzY2FucyBldmVyeXRoaW5nIGF0IG9uY2UgKi8KIAkJaWYgKDApIHsJLyogKHRoaXNfdXNiZHV4c3ViLT5oaWdoX3NwZWVkKSAqLwpAQCAtMTcwOCw3ICsxNzA4LDcgQEAKIAkJfQogCQl0aGlzX3VzYmR1eHN1Yi0+YW9fY29udGlub3VzID0gMDsKIAl9IGVsc2UgewotCQkvKiBjb250aW5vdXMgYXF1aXNpdGlvbiAqLworCQkvKiBjb250aW5vdXMgYWNxdWlzaXRpb24gKi8KIAkJdGhpc191c2JkdXhzdWItPmFvX2NvbnRpbm91cyA9IDE7CiAJCXRoaXNfdXNiZHV4c3ViLT5hb19zYW1wbGVfY291bnQgPSAwOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy91c2JkdXhmYXN0LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvdXNiZHV4ZmFzdC5jCmluZGV4IDViMTVlNmQuLjJhOGU3MjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy91c2JkdXhmYXN0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3VzYmR1eGZhc3QuYwpAQCAtMTgwLDcgKzE4MCw3IEBACiAJLyogY29tZWRpIGRldmljZSBmb3IgdGhlIGludGVycnVwdCBjb250ZXh0ICovCiAJc3RydWN0IGNvbWVkaV9kZXZpY2UgKmNvbWVkaWRldjsKIAlzaG9ydCBpbnQgYWlfY21kX3J1bm5pbmc7CS8qIGFzeW5jaHJvbm91cyBjb21tYW5kIGlzIHJ1bm5pbmcgKi8KLQlzaG9ydCBpbnQgYWlfY29udGlub3VzOwkvKiBjb250aW5vdXMgYXF1aXNpdGlvbiAqLworCXNob3J0IGludCBhaV9jb250aW5vdXM7CS8qIGNvbnRpbm91cyBhY3F1aXNpdGlvbiAqLwogCWxvbmcgaW50IGFpX3NhbXBsZV9jb3VudDsJLyogbnVtYmVyIG9mIHNhbXBsZXMgdG8gYWNxdWlyZSAqLwogCXVpbnQ4X3QgKmR1eF9jb21tYW5kczsJLyogY29tbWFuZHMgKi8KIAlpbnQgaWdub3JlOwkJLyogY291bnRlciB3aGljaCBpZ25vcmVzIHRoZSBmaXJzdApAQCAtMzkyLDcgKzM5Miw3IEBACiAJcCA9IHVyYi0+dHJhbnNmZXJfYnVmZmVyOwogCWlmICghdWRmcy0+aWdub3JlKSB7CiAJCWlmICghdWRmcy0+YWlfY29udGlub3VzKSB7Ci0JCQkvKiBub3QgY29udGlub3VzLCBmaXhlZCBudW1iZXIgb2Ygc2FtcGxlcyAqLworCQkJLyogbm90IGNvbnRpbnVvdXMsIGZpeGVkIG51bWJlciBvZiBzYW1wbGVzICovCiAJCQluID0gdXJiLT5hY3R1YWxfbGVuZ3RoIC8gc2l6ZW9mKHVpbnQxNl90KTsKIAkJCWlmICh1bmxpa2VseSh1ZGZzLT5haV9zYW1wbGVfY291bnQgPCBuKSkgewogCQkJCS8qCkBAIC03NzUsNyArNzc1LDcgQEAKIAkJdXAoJnVkZnMtPnNlbSk7CiAJCXJldHVybiAtRUJVU1k7CiAJfQotCS8qIHNldCBjdXJyZW50IGNoYW5uZWwgb2YgdGhlIHJ1bm5pbmcgYXF1aXNpdGlvbiB0byB6ZXJvICovCisJLyogc2V0IGN1cnJlbnQgY2hhbm5lbCBvZiB0aGUgcnVubmluZyBhY3F1aXNpdGlvbiB0byB6ZXJvICovCiAJcy0+YXN5bmMtPmN1cl9jaGFuID0gMDsKIAogCS8qCkBAIC0xMTgyLDcgKzExODIsNyBAQAogCQl9CiAJCXVkZnMtPmFpX2NvbnRpbm91cyA9IDA7CiAJfSBlbHNlIHsKLQkJLyogY29udGlub3VzIGFxdWlzaXRpb24gKi8KKwkJLyogY29udGlub3VzIGFjcXVpc2l0aW9uICovCiAJCXVkZnMtPmFpX2NvbnRpbm91cyA9IDE7CiAJCXVkZnMtPmFpX3NhbXBsZV9jb3VudCA9IDA7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NwdG0xMjE3L2NsZWFycGFkX3RtMTIxNy5jIGIvZHJpdmVycy9zdGFnaW5nL2NwdG0xMjE3L2NsZWFycGFkX3RtMTIxNy5jCmluZGV4IDc2ZTRiNzguLjBmZTcxM2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jcHRtMTIxNy9jbGVhcnBhZF90bTEyMTcuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY3B0bTEyMTcvY2xlYXJwYWRfdG0xMjE3LmMKQEAgLTUyLDcgKzUyLDcgQEAKICNkZWZpbmUgVE1BMTIxN19ERVZfU1RBVFVTCQkweDEzCS8qIERldmljZSBTdGF0dXMgKi8KICNkZWZpbmUgVE1BMTIxN19JTlRfU1RBVFVTCQkweDE0CS8qIEludGVycnVwdCBTdGF0dXMgKi8KIAotLyogQ29udHJvbGxlciBjYW4gZGV0ZWN0IHVwdG8gMiBwb3NzaWJsZSBmaW5nZXIgdG91Y2hlcy4KKy8qIENvbnRyb2xsZXIgY2FuIGRldGVjdCB1cCB0byAyIHBvc3NpYmxlIGZpbmdlciB0b3VjaGVzLgogICogRWFjaCBmaW5nZXIgdG91Y2ggcHJvdmlkZXMgIDEyIGJpdCBYIFkgY28tb3JkaW5hdGVzLCB0aGUgdmFsdWVzIGFyZSBzcGxpdAogICogYWNyb3NzIDIgcmVnaXN0ZXJzLCBhbmQgYW4gOCBiaXQgIFogdmFsdWUgKi8KICNkZWZpbmUgVE1BMTIxN19GSU5HRVJfU1RBVEUJCTB4MTggLyogRmluZ2VyIFN0YXRlICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY3J5c3RhbGhkL2NyeXN0YWxoZF9jbWRzLmMgYi9kcml2ZXJzL3N0YWdpbmcvY3J5c3RhbGhkL2NyeXN0YWxoZF9jbWRzLmMKaW5kZXggMTQyOTYwODUuLjM3MzVlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jcnlzdGFsaGQvY3J5c3RhbGhkX2NtZHMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY3J5c3RhbGhkL2NyeXN0YWxoZF9jbWRzLmMKQEAgLTkxNCw3ICs5MTQsNyBAQAogICogUmV0dXJuOgogICoJc3RhdHVzCiAgKgotICogQ2xvc2VyIGFwbGljYXRpb24gaGFuZGxlIGFuZCByZWxlYXNlIGFwcCBzcGVjaWZpYworICogQ2xvc2VyIGFwcGxpY2F0aW9uIGhhbmRsZSBhbmQgcmVsZWFzZSBhcHAgc3BlY2lmaWMKICAqIHJlc291cmNlcy4KICAqLwogZW51bSBCQ19TVEFUVVMgY3J5c3RhbGhkX3VzZXJfY2xvc2Uoc3RydWN0IGNyeXN0YWxoZF9jbWQgKmN0eCwgc3RydWN0IGNyeXN0YWxoZF91c2VyICp1YykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jcnlzdGFsaGQvY3J5c3RhbGhkX2h3LmMgYi9kcml2ZXJzL3N0YWdpbmcvY3J5c3RhbGhkL2NyeXN0YWxoZF9ody5jCmluZGV4IDEzYTUxNGQuLjVhY2YzOWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jcnlzdGFsaGQvY3J5c3RhbGhkX2h3LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NyeXN0YWxoZC9jcnlzdGFsaGRfaHcuYwpAQCAtMzAyLDcgKzMwMiw3IEBACiAJY3J5c3RhbGhkX2VuYWJsZV9pbnRlcnJ1cHRzKGFkcCk7CiAKIAkvKiBFbmFibGUgdGhlIG9wdGlvbiBmb3IgZ2V0dGluZyB0aGUgdG90YWwgbm8uIG9mIERXT1JEUwotCSAqIHRoYXQgaGF2ZSBiZWVuIHRyYW5zZmVyZWQgYnkgdGhlIFJYRE1BIGVuZ2luZQorCSAqIHRoYXQgaGF2ZSBiZWVuIHRyYW5zZmVycmVkIGJ5IHRoZSBSWERNQSBlbmdpbmUKIAkgKi8KIAlkYmdfb3B0aW9ucyA9IGNyeXN0YWxoZF9yZWdfcmQoYWRwLCBNSVNDMV9ETUFfREVCVUdfT1BUSU9OU19SRUcpOwogCWRiZ19vcHRpb25zIHw9IDB4MTA7CkBAIC0xNzc2LDcgKzE3NzYsNyBAQAogCQlyZXR1cm4gc3RzOwogCX0KIAotCS8qR2V0IHRoZSBSZXNwb25jZSBBZGRyZXNzKi8KKwkvKkdldCB0aGUgUmVzcG9uc2UgQWRkcmVzcyovCiAJY21kX3Jlc19hZGRyID0gYmNfZGVjX3JlZ19yZChody0+YWRwLCBDcHUySHN0TWJ4MSk7CiAKIAkvKlJlYWQgdGhlIFJlc3BvbnNlKi8KQEAgLTIzNjcsNyArMjM2Nyw3IEBACiAJQkNNTE9HKEJDTUxPR19JTkZPLCAiY2xvY2sgaXMgbW92aW5nIHRvICVkIHdpdGggbiAlZCB3aXRoIHZjb19tZyAlZFxuIiwKIAkgICAgICAgaHctPmNvcmVfY2xvY2tfbWh6LCBuLCB2Y29fbWcpOwogCi0JLyogQ2hhbmdlIHRoZSBEUkFNIHJlZnJlc2ggcmF0ZSB0byBhY2NvbW9kYXRlIHRoZSBuZXcgZnJlcXVlbmN5ICovCisJLyogQ2hhbmdlIHRoZSBEUkFNIHJlZnJlc2ggcmF0ZSB0byBhY2NvbW1vZGF0ZSB0aGUgbmV3IGZyZXF1ZW5jeSAqLwogCS8qIHJlZnJlc2ggcmVnID0gKChyZWZyZXNoX3JhdGUgKiBjbG9ja19yYXRlKS8xNikgLSAxOyByb3VuZGluZyB1cCovCiAJcmVmcmVzaF9yZWcgPSAoNyAqIGh3LT5jb3JlX2Nsb2NrX21oeiAvIDE2KTsKIAliY19kZWNfcmVnX3dyKGh3LT5hZHAsIFNEUkFNX1JFRl9QQVJBTSwgKCgxIDw8IDEyKSB8IHJlZnJlc2hfcmVnKSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL211c3ljYy5jIGIvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9tdXN5Y2MuYwppbmRleCBmMjc0Yzc3Li41Y2MzNDIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL211c3ljYy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jeHQxZTEvbXVzeWNjLmMKQEAgLTE0NTUsNyArMTQ1NSw3IEBACiAgICAgICAgICAgICAvKgogICAgICAgICAgICAgICogSWYgdGhlIGRlc2NyaXB0b3IgaGFzIG5vdCByZWNvdmVyZWQsIHRoZW4gbGVhdmluZyB0aGUgRU1QVFkKICAgICAgICAgICAgICAqIGVudHJ5IHNldCB3aWxsIG5vdCBzaWduYWwgdG8gdGhlIE1VU1lDQyB0aGF0IHRoaXMgZGVzY3JpcHRvcgotICAgICAgICAgICAgICogaGFzIGJlZW4gc2VydmljZWQuIFRoZSBJbnRlcnJ1cHQgUXVldWUgY2FuIHRoZW4gc3RhcnQgbG9vc2luZworICAgICAgICAgICAgICogaGFzIGJlZW4gc2VydmljZWQuIFRoZSBJbnRlcnJ1cHQgUXVldWUgY2FuIHRoZW4gc3RhcnQgbG9zaW5nCiAgICAgICAgICAgICAgKiBhdmFpbGFibGUgZGVzY3JpcHRvcnMgYW5kIE1VU1lDQyBldmVudHVhbGx5IGVuY291bnRlcnMgYW5kCiAgICAgICAgICAgICAgKiByZXBvcnRzIHRoZSBJTlRGVUxMIGNvbmRpdGlvbi4gIFBlciBtYW51YWwsIGNoYW5naW5nIGFueSBiaXQKICAgICAgICAgICAgICAqIG1hcmtzIGRlc2NyaXB0b3IgYXMgYXZhaWxhYmxlLCB0aHVzIHRoZSB1c2Ugb2YgZGlmZmVyZW50CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL211c3ljYy5oIGIvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9tdXN5Y2MuaAppbmRleCBkMmM5MWVmLi42OGYzNjYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL211c3ljYy5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jeHQxZTEvbXVzeWNjLmgKQEAgLTc0LDcgKzc0LDcgQEAKIAogI2RlZmluZSBJTlRfUVVFVUVfU0laRSAgICBNVVNZQ0NfTklRRAogCi0vKiBSQU0gaW1hZ2Ugb2YgTVVTWUNDIHJlZ2lzdGVycyBsYXllZCBvdXQgYXMgYSBDIHN0cnVjdHVyZSAqLworLyogUkFNIGltYWdlIG9mIE1VU1lDQyByZWdpc3RlcnMgbGFpZCBvdXQgYXMgYSBDIHN0cnVjdHVyZSAqLwogICAgIHN0cnVjdCBtdXN5Y2NfZ3JvdXByCiAgICAgewogICAgICAgICBWSU5UMzIgICAgICB0aHBbMzJdOyAgICAvKiBUcmFuc21pdCBIZWFkIFBvaW50ZXIgWzUtMjldICAgICAgICAgICAqLwpAQCAtOTYsNyArOTYsNyBAQAogICAgICAgICBWSU5UMzIgICAgICBwY2Q7ICAgICAgICAvKiBQb3J0IENvbmZpZ3VyYXRpb24gRGVzY3JpcHRvciBbNS0xOV0gICAqLwogICAgIH07CiAKLS8qIGhhcmR3YXJlIE1VU1lDQyByZWdpc3RlcnMgbGF5ZWQgb3V0IGFzIGEgQyBzdHJ1Y3R1cmUgKi8KKy8qIGhhcmR3YXJlIE1VU1lDQyByZWdpc3RlcnMgbGFpZCBvdXQgYXMgYSBDIHN0cnVjdHVyZSAqLwogICAgIHN0cnVjdCBtdXN5Y2NfZ2xvYmFscgogICAgIHsKICAgICAgICAgVklOVDMyICAgICAgZ2JwOyAgICAgICAgLyogR3JvdXAgQmFzZSBQb2ludGVyICAgICAgICAgICAgICAgICAgICAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jeHQxZTEvcG1jYzRfZGVmcy5oIGIvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9wbWNjNF9kZWZzLmgKaW5kZXggMTg2MzQ3Yi4uYTM5NTA1ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9wbWNjNF9kZWZzLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9wbWNjNF9kZWZzLmgKQEAgLTU0LDggKzU0LDggQEAKICNkZWZpbmUgTVVTWUNDX01UVSAgICAgICAgICAyMDQ4ICAvKiBkZWZhdWx0ICovCiAjZGVmaW5lIE1VU1lDQ19UWERFU0NfTUlOICAgMTAgICAgLyogSERMQyBtb2RlIGRlZmF1bHQgKi8KICNkZWZpbmUgTVVTWUNDX1JYREVTQ19NSU4gICAxOCAgICAvKiBIRExDIG1vZGUgZGVmYXVsdCAqLwotI2RlZmluZSBNVVNZQ0NfVFhERVNDX1RSQU5TIDQgICAgIC8qIFRyYW5zcGFyZW50IG1vZGUgbWludW11bSAjIG9mIFRYIGRlc2NyaXB0b3JzICovCi0jZGVmaW5lIE1VU1lDQ19SWERFU0NfVFJBTlMgMTIgICAgLyogVHJhbnNwYXJlbnQgbW9kZSBtaW51bXVtICMgb2YgUlggZGVzY3JpcHRvcnMgKi8KKyNkZWZpbmUgTVVTWUNDX1RYREVTQ19UUkFOUyA0ICAgICAvKiBUcmFuc3BhcmVudCBtb2RlIG1pbmltdW0gIyBvZiBUWCBkZXNjcmlwdG9ycyAqLworI2RlZmluZSBNVVNZQ0NfUlhERVNDX1RSQU5TIDEyICAgIC8qIFRyYW5zcGFyZW50IG1vZGUgbWluaW11bSAjIG9mIFJYIGRlc2NyaXB0b3JzICovCiAKICNkZWZpbmUgTUFYX0RFRkFVTFRfSUZRTEVOICAzMiAgICAvKiBuZXR3b3JrIHFsZW4gKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9zYmVjcmMuYyBiL2RyaXZlcnMvc3RhZ2luZy9jeHQxZTEvc2JlY3JjLmMKaW5kZXggNTEyMzI5NC4uM2YzY2Q2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9zYmVjcmMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL3NiZWNyYy5jCkBAIC05NSw3ICs5NSw3IEBACiAKICAgICAvKgogICAgICAqIGlmIHRhYmxlIG5vdCB5ZXQgY3JlYXRlZCwgZG8gc28uIERvbid0IGNhcmUgYWJvdXQgImV4dHJhIiB0aW1lCi0gICAgICogY2hlY2tpbmcgdGhpcyBldmVyeXRpbWUgc2JlQ3JjKCkgaXMgY2FsbGVkLCBzaW5jZSBDUkMgY2FsY3VsYXRpb25zIGFyZQorICAgICAqIGNoZWNraW5nIHRoaXMgZXZlcnkgdGltZSBzYmVDcmMoKSBpcyBjYWxsZWQsIHNpbmNlIENSQyBjYWxjdWxhdGlvbnMgYXJlCiAgICAgICogYWxyZWFkeSB0aW1lIGNvbnN1bWluZwogICAgICAqLwogICAgIGlmICghY3JjVGFibGVJbml0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2N4dDFlMS9zYmVwcm9jLmMgYi9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL3NiZXByb2MuYwppbmRleCA3MGI5YjMzLi5mNDI1MzFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL3NiZXByb2MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY3h0MWUxL3NiZXByb2MuYwpAQCAtMjM5LDcgKzIzOSw3IEBACiAgICAgICovCiAKICNpZiAxCi0gICAgLyogIzQgLSBpbnRlcHJldGF0aW9uIG9mIGFib3ZlID0gc2V0IEVPRiwgcmV0dXJuIGxlbiAqLworICAgIC8qICM0IC0gaW50ZXJwcmV0YXRpb24gb2YgYWJvdmUgPSBzZXQgRU9GLCByZXR1cm4gbGVuICovCiAgICAgKmVvZiA9IDE7CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfYWRkcmVzc19tYXAuaCBiL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX2FkZHJlc3NfbWFwLmgKaW5kZXggZTZjOGNiMy4uNDI1ZTkyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfYWRkcmVzc19tYXAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxMF9hZGRyZXNzX21hcC5oCkBAIC04NTYsNyArODU2LDcgQEAKICAqLwogCiAvKgotICogc3RydWN0dXJlIGZvciBzcGFjZSBhdmFpbGlhYmxlIHJlZyBpbiByeG1hYyBhZGRyZXNzIG1hcC4KKyAqIHN0cnVjdHVyZSBmb3Igc3BhY2UgYXZhaWxhYmxlIHJlZyBpbiByeG1hYyBhZGRyZXNzIG1hcC4KICAqIGxvY2F0ZWQgYXQgYWRkcmVzcyAweDQwOTQKICAqCiAgKiAzMS0xNzogcmVzZXJ2ZWQKQEAgLTEwMzEsNyArMTAzMSw3IEBACiAgKiAzMTogcmVzZXQgTUlJIG1nbXQKICAqIDMwLTY6IHVudXNlZAogICogNTogc2NhbiBhdXRvIGluY3JlbWVudAotICogNDogcHJlYW1ibGUgc3VwcmVzcworICogNDogcHJlYW1ibGUgc3VwcHJlc3MKICAqIDM6IHVuZGVmaW5lZAogICogMi0wOiBtZ210IGNsb2NrIHJlc2V0CiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX3BoeS5oIGIvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfcGh5LmgKaW5kZXggNzgzNDlhZC4uOTQ2YzBjNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfcGh5LmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfcGh5LmgKQEAgLTQ2OCw3ICs0NjgsNyBAQAogI2RlZmluZSBUUlVFUEhZX0FORUdfQ09NUExFVEUgICAgICAgICAgIDEKICNkZWZpbmUgVFJVRVBIWV9BTkVHX0RJU0FCTEVEICAgICAgICAgICAyCiAKLS8qIERlZmluZSBkdXBsZXggYWR2ZXJ0aXNtZW50IGZsYWdzICovCisvKiBEZWZpbmUgZHVwbGV4IGFkdmVydGlzZW1lbnQgZmxhZ3MgKi8KICNkZWZpbmUgVFJVRVBIWV9BRFZfRFVQTEVYX05PTkUgICAgICAgICAweDAwCiAjZGVmaW5lIFRSVUVQSFlfQURWX0RVUExFWF9GVUxMICAgICAgICAgMHgwMQogI2RlZmluZSBUUlVFUEhZX0FEVl9EVVBMRVhfSEFMRiAgICAgICAgIDB4MDIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX3J4LmMgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxMF9yeC5jCmluZGV4IDMzOTEzNmYuLmZjNmJkNDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX3J4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfcnguYwpAQCAtMTIyLDcgKzEyMiw3IEBACiAJICogbnVtYmVyIG9mIGVudHJpZXMgaW4gRkJSMS4KIAkgKgogCSAqIEZCUjEgaG9sZHMgImxhcmdlIiBmcmFtZXMsIEZCUjAgaG9sZHMgInNtYWxsIiBmcmFtZXMuICBJZiBGQlIxCi0JICogZW50cmllcyBhcmUgaHVnZSBpbiBvcmRlciB0byBhY2NvbW9kYXRlIGEgImp1bWJvIiBmcmFtZSwgdGhlbiBpdAorCSAqIGVudHJpZXMgYXJlIGh1Z2UgaW4gb3JkZXIgdG8gYWNjb21tb2RhdGUgYSAianVtYm8iIGZyYW1lLCB0aGVuIGl0CiAJICogd2lsbCBoYXZlIGxlc3MgZW50cmllcy4gIENvbnZlcnNlbHksIEZCUjEgd2lsbCBub3cgYmUgcmVsaWVkIHVwb24KIAkgKiB0byBjYXJyeSBtb3JlICJub3JtYWwiIGZyYW1lcywgdGh1cyBpdCdzIGVudHJ5IHNpemUgYWxzbyBpbmNyZWFzZXMKIAkgKiBhbmQgdGhlIG51bWJlciBvZiBlbnRyaWVzIGdvZXMgdXAgdG9vIChzaW5jZSBpdCBub3cgY2FycmllcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMXhfaXNyLmMgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxeF9pc3IuYwppbmRleCBjZTRkOTMwLi5mNzE2ZTQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxeF9pc3IuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxeF9pc3IuYwpAQCAtNDY2LDcgKzQ2Niw3IEBACiAJCS8qIEhhbmRsZSBTTFYgVGltZW91dCBJbnRlcnJ1cHQgKi8KIAkJaWYgKHN0YXR1cyAmIEVUX0lOVFJfU0xWX1RJTUVPVVQpIHsKIAkJCS8qCi0JCQkgKiBUaGlzIG1lYW5zIGEgdGltZW91dCBoYXMgb2NjdXJlZCBvbiBhIHJlYWQgb3IKKwkJCSAqIFRoaXMgbWVhbnMgYSB0aW1lb3V0IGhhcyBvY2N1cnJlZCBvbiBhIHJlYWQgb3IKIAkJCSAqIHdyaXRlIHJlcXVlc3QgdG8gb25lIG9mIHRoZSBKQUdDb3JlIHJlZ2lzdGVycy4gVGhlCiAJCQkgKiBHbG9iYWwgUmVzb3VyY2VzIGJsb2NrIGhhcyB0ZXJtaW5hdGVkIHRoZSByZXF1ZXN0CiAJCQkgKiBhbmQgb24gYSByZWFkIHJlcXVlc3QsIHJldHVybmVkIGEgImZha2UiIHZhbHVlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMXhfbmV0ZGV2LmMgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxeF9uZXRkZXYuYwppbmRleCAwYzI5OGNhLi5iMjViYWUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxeF9uZXRkZXYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxeF9uZXRkZXYuYwpAQCAtNDE1LDcgKzQxNSw3IEBACiAJICovCiAJUGFja2V0RmlsdGVyID0gYWRhcHRlci0+UGFja2V0RmlsdGVyOwogCi0JLyogQ2xlYXIgdGhlICdtdWx0aWNhc3QnIGZsYWcgbG9jYWxseTsgYmVjdWFzZSB3ZSBvbmx5IGhhdmUgYSBzaW5nbGUKKwkvKiBDbGVhciB0aGUgJ211bHRpY2FzdCcgZmxhZyBsb2NhbGx5OyBiZWNhdXNlIHdlIG9ubHkgaGF2ZSBhIHNpbmdsZQogCSAqIGZsYWcgdG8gY2hlY2sgbXVsdGljYXN0LCBhbmQgbXVsdGlwbGUgbXVsdGljYXN0IGFkZHJlc3NlcyBjYW4gYmUKIAkgKiBzZXQsIHRoaXMgaXMgdGhlIGVhc2llc3Qgd2F5IHRvIGRldGVybWluZSBpZiBtb3JlIHRoYW4gb25lCiAJICogbXVsdGljYXN0IGFkZHJlc3MgaXMgYmVpbmcgc2V0LgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtcGNtY2lhL2Z0MTAwMF9kZXYuaCBiL2RyaXZlcnMvc3RhZ2luZy9mdDEwMDAvZnQxMDAwLXBjbWNpYS9mdDEwMDBfZGV2LmgKaW5kZXggNGE4OWJkMS4uMGI2M2YwNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtcGNtY2lhL2Z0MTAwMF9kZXYuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC1wY21jaWEvZnQxMDAwX2Rldi5oCkBAIC0zMCw3ICszMCw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9yZWFkX3JlZwotLy8gRGVzY3JpcHRvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHJlYWQgdGhlIHZhbHVlIG9mIGEgZ2l2ZW4gQVNJQyByZWdpc3Rlci4KKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVhZCB0aGUgdmFsdWUgb2YgYSBnaXZlbiBBU0lDIHJlZ2lzdGVyLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQogLy8gICAgIG9mZnNldCAtIEFTSUMgcmVnaXN0ZXIgb2Zmc2V0CkBAIC00OSw3ICs0OSw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF93cml0ZV9yZWcKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBzZXQgdGhlIHZhbHVlIGZvciBhIGdpdmVuIEFTSUMgcmVnaXN0ZXIuCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHNldCB0aGUgdmFsdWUgZm9yIGEgZ2l2ZW4gQVNJQyByZWdpc3Rlci4KIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKIC8vICAgICBvZmZzZXQgLSBBU0lDIHJlZ2lzdGVyIG9mZnNldApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtcGNtY2lhL2Z0MTAwMF9kbmxkLmMgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC1wY21jaWEvZnQxMDAwX2RubGQuYwppbmRleCBiMDcyOWZjLi5mYjM3NWVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC1wY21jaWEvZnQxMDAwX2RubGQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC1wY21jaWEvZnQxMDAwX2RubGQuYwpAQCAtOTUsNDcgKzk1LDQ3IEBACiBVU0hPUlQgaGRyX2NoZWNrc3VtKFBQU0VVRE9fSERSIHBIZHIpOwogCiB0eXBlZGVmIHN0cnVjdCBfRFNQX0ZJTEVfSERSIHsKLQlsb25nIGJ1aWxkX2RhdGU7Ci0JbG9uZyBkc3BfY29mZl9kYXRlOwotCWxvbmcgbG9hZGVyX2NvZGVfYWRkcmVzczsKLQlsb25nIGxvYWRlcl9jb2RlX3NpemU7Ci0JbG9uZyBsb2FkZXJfY29kZV9lbmQ7Ci0JbG9uZyBkc3BfY29kZV9hZGRyZXNzOwotCWxvbmcgZHNwX2NvZGVfc2l6ZTsKLQlsb25nIGRzcF9jb2RlX2VuZDsKLQlsb25nIHJlc2VydmVkWzhdOworCXUzMiAgYnVpbGRfZGF0ZTsKKwl1MzIgIGRzcF9jb2ZmX2RhdGU7CisJdTMyICBsb2FkZXJfY29kZV9hZGRyZXNzOworCXUzMiAgbG9hZGVyX2NvZGVfc2l6ZTsKKwl1MzIgIGxvYWRlcl9jb2RlX2VuZDsKKwl1MzIgIGRzcF9jb2RlX2FkZHJlc3M7CisJdTMyICBkc3BfY29kZV9zaXplOworCXUzMiAgZHNwX2NvZGVfZW5kOworCXUzMiAgcmVzZXJ2ZWRbOF07CiB9IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKSBEU1BfRklMRV9IRFIsICpQRFNQX0ZJTEVfSERSOwogCiB0eXBlZGVmIHN0cnVjdCBfRFNQX0ZJTEVfSERSXzUgewotCWxvbmcgdmVyc2lvbl9pZDsJLy8gVmVyc2lvbiBJRCBvZiB0aGlzIGltYWdlIGZvcm1hdC4KLQlsb25nIHBhY2thZ2VfaWQ7CS8vIFBhY2thZ2UgSUQgb2YgY29kZSByZWxlYXNlLgotCWxvbmcgYnVpbGRfZGF0ZTsJLy8gRGF0ZS90aW1lIHN0YW1wIHdoZW4gZmlsZSB3YXMgYnVpbHQuCi0JbG9uZyBjb21tYW5kc19vZmZzZXQ7CS8vIE9mZnNldCB0byBhdHRhY2hlZCBjb21tYW5kcyBpbiBQc2V1ZG8gSGRyIGZvcm1hdC4KLQlsb25nIGxvYWRlcl9vZmZzZXQ7CS8vIE9mZnNldCB0byBib290bG9hZGVyIGNvZGUuCi0JbG9uZyBsb2FkZXJfY29kZV9hZGRyZXNzOwkvLyBTdGFydCBhZGRyZXNzIG9mIGJvb3Rsb2FkZXIuCi0JbG9uZyBsb2FkZXJfY29kZV9lbmQ7CS8vIFdoZXJlIGJvb3Rsb2FkZXIgY29kZSBlbmRzLgotCWxvbmcgbG9hZGVyX2NvZGVfc2l6ZTsKLQlsb25nIHZlcnNpb25fZGF0YV9vZmZzZXQ7CS8vIE9mZnNldCB3ZXJlIHNjcmFtYmxlZCB2ZXJzaW9uIGRhdGEgYmVnaW5zLgotCWxvbmcgdmVyc2lvbl9kYXRhX3NpemU7CS8vIFNpemUsIGluIHdvcmRzLCBvZiBzY3JhbWJsZWQgdmVyc2lvbiBkYXRhLgotCWxvbmcgbkRzcEltYWdlczsJLy8gTnVtYmVyIG9mIERTUCBpbWFnZXMgaW4gZmlsZS4KKwl1MzIgIHZlcnNpb25faWQ7CS8vIFZlcnNpb24gSUQgb2YgdGhpcyBpbWFnZSBmb3JtYXQuCisJdTMyICBwYWNrYWdlX2lkOwkvLyBQYWNrYWdlIElEIG9mIGNvZGUgcmVsZWFzZS4KKwl1MzIgIGJ1aWxkX2RhdGU7CS8vIERhdGUvdGltZSBzdGFtcCB3aGVuIGZpbGUgd2FzIGJ1aWx0LgorCXUzMiAgY29tbWFuZHNfb2Zmc2V0OwkvLyBPZmZzZXQgdG8gYXR0YWNoZWQgY29tbWFuZHMgaW4gUHNldWRvIEhkciBmb3JtYXQuCisJdTMyICBsb2FkZXJfb2Zmc2V0OwkvLyBPZmZzZXQgdG8gYm9vdGxvYWRlciBjb2RlLgorCXUzMiAgbG9hZGVyX2NvZGVfYWRkcmVzczsJLy8gU3RhcnQgYWRkcmVzcyBvZiBib290bG9hZGVyLgorCXUzMiAgbG9hZGVyX2NvZGVfZW5kOwkvLyBXaGVyZSBib290bG9hZGVyIGNvZGUgZW5kcy4KKwl1MzIgIGxvYWRlcl9jb2RlX3NpemU7CisJdTMyICB2ZXJzaW9uX2RhdGFfb2Zmc2V0OwkvLyBPZmZzZXQgd2VyZSBzY3JhbWJsZWQgdmVyc2lvbiBkYXRhIGJlZ2lucy4KKwl1MzIgIHZlcnNpb25fZGF0YV9zaXplOwkvLyBTaXplLCBpbiB3b3Jkcywgb2Ygc2NyYW1ibGVkIHZlcnNpb24gZGF0YS4KKwl1MzIgIG5Ec3BJbWFnZXM7CS8vIE51bWJlciBvZiBEU1AgaW1hZ2VzIGluIGZpbGUuCiB9IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKSBEU1BfRklMRV9IRFJfNSwgKlBEU1BfRklMRV9IRFJfNTsKIAogdHlwZWRlZiBzdHJ1Y3QgX0RTUF9JTUFHRV9JTkZPIHsKLQlsb25nIGNvZmZfZGF0ZTsJCS8vIERhdGUvdGltZSB3aGVuIERTUCBDb2ZmIGltYWdlIHdhcyBidWlsdC4KLQlsb25nIGJlZ2luX29mZnNldDsJLy8gT2Zmc2V0IGluIGZpbGUgd2hlcmUgaW1hZ2UgYmVnaW5zLgotCWxvbmcgZW5kX29mZnNldDsJLy8gT2Zmc2V0IGluIGZpbGUgd2hlcmUgaW1hZ2UgYmVnaW5zLgotCWxvbmcgcnVuX2FkZHJlc3M7CS8vIE9uIGNoaXAgU3RhcnQgYWRkcmVzcyBvZiBEU1AgY29kZS4KLQlsb25nIGltYWdlX3NpemU7CS8vIFNpemUgb2YgaW1hZ2UuCi0JbG9uZyB2ZXJzaW9uOwkJLy8gRW1iZWRkZWQgdmVyc2lvbiAjIG9mIERTUCBjb2RlLgorCXUzMiAgY29mZl9kYXRlOwkJLy8gRGF0ZS90aW1lIHdoZW4gRFNQIENvZmYgaW1hZ2Ugd2FzIGJ1aWx0LgorCXUzMiAgYmVnaW5fb2Zmc2V0OwkvLyBPZmZzZXQgaW4gZmlsZSB3aGVyZSBpbWFnZSBiZWdpbnMuCisJdTMyICBlbmRfb2Zmc2V0OwkvLyBPZmZzZXQgaW4gZmlsZSB3aGVyZSBpbWFnZSBiZWdpbnMuCisJdTMyICBydW5fYWRkcmVzczsJLy8gT24gY2hpcCBTdGFydCBhZGRyZXNzIG9mIERTUCBjb2RlLgorCXUzMiAgaW1hZ2Vfc2l6ZTsJLy8gU2l6ZSBvZiBpbWFnZS4KKwl1MzIgIHZlcnNpb247CQkvLyBFbWJlZGRlZCB2ZXJzaW9uICMgb2YgRFNQIGNvZGUuCiB9IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKSBEU1BfSU1BR0VfSU5GTywgKlBEU1BfSU1BR0VfSU5GTzsKIAogdHlwZWRlZiBzdHJ1Y3QgX0RTUF9JTUFHRV9JTkZPX1Y2IHsKLQlsb25nIGNvZmZfZGF0ZTsJCS8vIERhdGUvdGltZSB3aGVuIERTUCBDb2ZmIGltYWdlIHdhcyBidWlsdC4KLQlsb25nIGJlZ2luX29mZnNldDsJLy8gT2Zmc2V0IGluIGZpbGUgd2hlcmUgaW1hZ2UgYmVnaW5zLgotCWxvbmcgZW5kX29mZnNldDsJLy8gT2Zmc2V0IGluIGZpbGUgd2hlcmUgaW1hZ2UgYmVnaW5zLgotCWxvbmcgcnVuX2FkZHJlc3M7CS8vIE9uIGNoaXAgU3RhcnQgYWRkcmVzcyBvZiBEU1AgY29kZS4KLQlsb25nIGltYWdlX3NpemU7CS8vIFNpemUgb2YgaW1hZ2UuCi0JbG9uZyB2ZXJzaW9uOwkJLy8gRW1iZWRkZWQgdmVyc2lvbiAjIG9mIERTUCBjb2RlLgorCXUzMiAgY29mZl9kYXRlOwkJLy8gRGF0ZS90aW1lIHdoZW4gRFNQIENvZmYgaW1hZ2Ugd2FzIGJ1aWx0LgorCXUzMiAgYmVnaW5fb2Zmc2V0OwkvLyBPZmZzZXQgaW4gZmlsZSB3aGVyZSBpbWFnZSBiZWdpbnMuCisJdTMyICBlbmRfb2Zmc2V0OwkvLyBPZmZzZXQgaW4gZmlsZSB3aGVyZSBpbWFnZSBiZWdpbnMuCisJdTMyICBydW5fYWRkcmVzczsJLy8gT24gY2hpcCBTdGFydCBhZGRyZXNzIG9mIERTUCBjb2RlLgorCXUzMiAgaW1hZ2Vfc2l6ZTsJLy8gU2l6ZSBvZiBpbWFnZS4KKwl1MzIgIHZlcnNpb247CQkvLyBFbWJlZGRlZCB2ZXJzaW9uICMgb2YgRFNQIGNvZGUuCiAJdW5zaWduZWQgc2hvcnQgY2hlY2tzdW07CS8vIERzcCBGaWxlIGNoZWNrc3VtCiAJdW5zaWduZWQgc2hvcnQgcGFkMTsKIH0gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpIERTUF9JTUFHRV9JTkZPX1Y2LCAqUERTUF9JTUFHRV9JTkZPX1Y2OwpAQCAtODQ2LDggKzg0Niw4IEBACiAJCQlicmVhazsKIAogCQljYXNlIFNUQVRFX0RPTkVfRFdOTEQ6Ci0JCQlpZiAoKChVSU5UKSAocFVjRmlsZSkgLSAoVUlOVCkgcEZpbGVTdGFydCkgPj0KLQkJCQkoVUlOVCkgRmlsZUxlbmd0aCkgeworCQkJaWYgKCgodW5zaWduZWQgbG9uZykgKHBVY0ZpbGUpIC0gKHVuc2lnbmVkIGxvbmcpIHBGaWxlU3RhcnQpID49CisJCQkJKHVuc2lnbmVkIGxvbmcpIEZpbGVMZW5ndGgpIHsKIAkJCQl1aVN0YXRlID0gU1RBVEVfRE9ORV9GSUxFOwogCQkJCWJyZWFrOwogCQkJfQpAQCAtOTAxLDExICs5MDEsMTEgQEAKIAkJCQkJCQkJICAmaW5mby0+cHJvdl9saXN0KTsKIAkJCQkJCS8vIE1vdmUgdG8gbmV4dCBlbnRyeSBpZiBhdmFpbGFibGUKIAkJCQkJCXBVY0ZpbGUgPQotCQkJCQkJCShVQ0hBUiAqKSAoKFVJTlQpIHBVY0ZpbGUgKwotCQkJCQkJCQkgICAoVUlOVCkgKCh1c0hkckxlbmd0aCArIDEpICYgMHhGRkZGRkZGRSkgKyBzaXplb2YoUFNFVURPX0hEUikpOwotCQkJCQkJaWYgKChVSU5UKSAocFVjRmlsZSkgLQotCQkJCQkJCShVSU5UKSAocEZpbGVTdGFydCkgPj0KLQkJCQkJCQkoVUlOVCkgRmlsZUxlbmd0aCkgeworCQkJCQkJCShVQ0hBUiAqKSAoKHVuc2lnbmVkIGxvbmcpIHBVY0ZpbGUgKworCQkJCQkJCQkgICAodW5zaWduZWQgbG9uZykgKCh1c0hkckxlbmd0aCArIDEpICYgMHhGRkZGRkZGRSkgKyBzaXplb2YoUFNFVURPX0hEUikpOworCQkJCQkJaWYgKCh1bnNpZ25lZCBsb25nKSAocFVjRmlsZSkgLQorCQkJCQkJCSh1bnNpZ25lZCBsb25nKSAocEZpbGVTdGFydCkgPj0KKwkJCQkJCQkodW5zaWduZWQgbG9uZykgRmlsZUxlbmd0aCkgewogCQkJCQkJCXVpU3RhdGUgPQogCQkJCQkJCQlTVEFURV9ET05FX0ZJTEU7CiAJCQkJCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC1wY21jaWEvZnQxMDAwX2h3LmMgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC1wY21jaWEvZnQxMDAwX2h3LmMKaW5kZXggZmY2OTFkOS4uZWViN2RkNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtcGNtY2lhL2Z0MTAwMF9ody5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9mdDEwMDAvZnQxMDAwLXBjbWNpYS9mdDEwMDBfaHcuYwpAQCAtOTAsNyArOTAsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfYXNpY19yZWFkCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0cmlldmUgdGhlIHZhbHVlIG9mIGEgc3BlY2lmaWMgQVNJQworLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCByZXRyaWV2ZSB0aGUgdmFsdWUgb2YgYSBzcGVjaWZpYyBBU0lDCiAvLyAgICAgICAgICAgICByZWdpc3Rlci4KIC8vIElucHV0OgogLy8gICAgZGV2IC0gbmV0d29yayBkZXZpY2Ugc3RydWN0dXJlCkBAIC0xMDcsNyArMTA3LDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX2FzaWNfd3JpdGUKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBzZXQgdGhlIHZhbHVlIG9mIGEgc3BlY2lmaWMgQVNJQworLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBzZXQgdGhlIHZhbHVlIG9mIGEgc3BlY2lmaWMgQVNJQwogLy8gICAgICAgICAgICAgcmVnaXN0ZXIuCiAvLyBJbnB1dDoKIC8vICAgIGRldiAtIG5ldHdvcmsgZGV2aWNlIHN0cnVjdHVyZQpAQCAtMTI0LDcgKzEyNCw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9yZWFkX2ZpZm9fbGVuCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVhZCB0aGUgQVNJQyBVcGxpbmsgRklGTyBzdGF0dXMgcmVnaXN0ZXIKKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVhZCB0aGUgQVNJQyBVcGxpbmsgRklGTyBzdGF0dXMgcmVnaXN0ZXIKIC8vICAgICAgICAgICAgIHdoaWNoIHdpbGwgcmV0dXJuIHRoZSBudW1iZXIgb2YgYnl0ZXMgcmVtYWluaW5nIGluIHRoZSBVcGxpbmsgRklGTy4KIC8vICAgICAgICAgICAgIFNpeHRlZW4gYnl0ZXMgYXJlIHN1YnRyYWN0ZWQgdG8gbWFrZSBzdXJlIHRoYXQgdGhlIEFTSUMgZG9lcyBub3QKIC8vICAgICAgICAgICAgIHJlYWNoIGl0cyB0aHJlc2hvbGQuCkBAIC0xNDgsNyArMTQ4LDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX3JlYWRfZHByYW0KLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIHRoZSBzcGVjaWZpYyBhcmVhIG9mIGRwcmFtCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHJlYWQgdGhlIHNwZWNpZmljIGFyZWEgb2YgZHByYW0KIC8vICAgICAgICAgICAgIChFbGVjdHJhYnV6eiBBU0lDIG9ubHkpCiAvLyBJbnB1dDoKIC8vICAgICBkZXYgICAgLSBkZXZpY2Ugc3RydWN0dXJlCkBAIC0xNzUsNyArMTc1LDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX3dyaXRlX2RwcmFtCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgd3JpdGUgdG8gYSBzcGVjaWZpYyBhcmVhIG9mIGRwcmFtCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHdyaXRlIHRvIGEgc3BlY2lmaWMgYXJlYSBvZiBkcHJhbQogLy8gICAgICAgICAgICAgKEVsZWN0cmFidXp6IEFTSUMgb25seSkKIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKQEAgLTIwMSw3ICsyMDEsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfcmVhZF9kcHJhbV9tYWdfMTYKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIHRoZSBzcGVjaWZpYyBhcmVhIG9mIGRwcmFtCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHJlYWQgdGhlIHNwZWNpZmljIGFyZWEgb2YgZHByYW0KIC8vICAgICAgICAgICAgIChNYWduZW1pdGUgQVNJQyBvbmx5KQogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQpAQCAtMjMzLDcgKzIzMyw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF93cml0ZV9kcHJhbV9tYWdfMTYKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCB3cml0ZSB0byBhIHNwZWNpZmljIGFyZWEgb2YgZHByYW0KKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgd3JpdGUgdG8gYSBzcGVjaWZpYyBhcmVhIG9mIGRwcmFtCiAvLyAgICAgICAgICAgICAoTWFnbmVtaXRlIEFTSUMgb25seSkKIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKQEAgLTI2Myw3ICsyNjMsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfcmVhZF9kcHJhbV9tYWdfMzIKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIHRoZSBzcGVjaWZpYyBhcmVhIG9mIGRwcmFtCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHJlYWQgdGhlIHNwZWNpZmljIGFyZWEgb2YgZHByYW0KIC8vICAgICAgICAgICAgIChNYWduZW1pdGUgQVNJQyBvbmx5KQogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQpAQCAtMjkwLDcgKzI5MCw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF93cml0ZV9kcHJhbV9tYWdfMzIKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCB3cml0ZSB0byBhIHNwZWNpZmljIGFyZWEgb2YgZHByYW0KKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgd3JpdGUgdG8gYSBzcGVjaWZpYyBhcmVhIG9mIGRwcmFtCiAvLyAgICAgICAgICAgICAoTWFnbmVtaXRlIEFTSUMgb25seSkKIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKQEAgLTMxNSw3ICszMTUsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfZW5hYmxlX2ludGVycnVwdHMKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBlbmFibGUgaW50ZXJydXB0cyBiYXNlIG9uIHRoZSBjdXJyZW50IGludGVycnVwdCBtYXNrLgorLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBlbmFibGUgaW50ZXJydXB0cyBiYXNlIG9uIHRoZSBjdXJyZW50IGludGVycnVwdCBtYXNrLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQogLy8gT3V0cHV0OgpAQCAtMzQwLDcgKzM0MCw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9kaXNhYmxlX2ludGVycnVwdHMKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBkaXNhYmxlIGFsbCBpbnRlcnJ1cHRzLgorLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBkaXNhYmxlIGFsbCBpbnRlcnJ1cHRzLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQogLy8gT3V0cHV0OgpAQCAtMzY0LDcgKzM2NCw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9yZXNldF9hc2ljCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgY2FsbCB0aGUgQ2FyZCBTZXJ2aWNlIGZ1bmN0aW9uIHRvIHJlc2V0IHRoZQorLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBjYWxsIHRoZSBDYXJkIFNlcnZpY2UgZnVuY3Rpb24gdG8gcmVzZXQgdGhlCiAvLyAgICAgICAgICAgICBBU0lDLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQpAQCAtNDA4LDcgKzQwOCw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9yZXNldF9jYXJkCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVzZXQgdGhlIGNhcmQKKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVzZXQgdGhlIGNhcmQKIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKIC8vIE91dHB1dDoKQEAgLTU3MSw3ICs1NzEsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfY2hrY2FyZAotLy8gRGVzY3JpcHRvbjogVGhpcyBmdW5jdGlvbiB3aWxsIGNoZWNrIGlmIHRoZSBkZXZpY2UgaXMgcHJlc2VudGx5IGF2YWlsYWJsZSBvbgorLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBjaGVjayBpZiB0aGUgZGV2aWNlIGlzIHByZXNlbnRseSBhdmFpbGFibGUgb24KIC8vICAgICAgICAgICAgIHRoZSBzeXN0ZW0uCiAvLyBJbnB1dDoKIC8vICAgICBkZXYgICAgLSBkZXZpY2Ugc3RydWN0dXJlCkBAIC02MDcsNyArNjA3LDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX2hiY2hrCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcGVyZm9ybSB0aGUgaGVhcnQgYmVhdCBjaGVjayBvZiB0aGUgRFNQIGFzCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHBlcmZvcm0gdGhlIGhlYXJ0IGJlYXQgY2hlY2sgb2YgdGhlIERTUCBhcwogLy8gICAgICAgICAgICAgd2VsbCBhcyB0aGUgQVNJQy4KIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKQEAgLTgyOCw3ICs4MjgsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfc2VuZF9jbWQKLS8vIERlc2NyaXB0b246CisvLyBEZXNjcmlwdGlvbjoKIC8vIElucHV0OgogLy8gT3V0cHV0OgogLy8KQEAgLTkwOCw3ICs5MDgsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfcmVjZWl2ZV9jbWQKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIGEgbWVzc2FnZSBmcm9tIHRoZSBkcHJhbSBhcmVhLgorLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCByZWFkIGEgbWVzc2FnZSBmcm9tIHRoZSBkcHJhbSBhcmVhLgogLy8gSW5wdXQ6CiAvLyAgICBkZXYgLSBuZXR3b3JrIGRldmljZSBzdHJ1Y3R1cmUKIC8vICAgIHBidWZmZXIgLSBjYWxsZXIgc3VwcGx5IGFkZHJlc3MgdG8gYnVmZmVyCkBAIC0xMDAzLDcgKzEwMDMsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfcHJvY19kcnZtc2cKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBwcm9jZXNzIHRoZSB2YXJpb3VzIGRyaXZlciBtZXNzYWdlcy4KKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcHJvY2VzcyB0aGUgdmFyaW91cyBkcml2ZXIgbWVzc2FnZXMuCiAvLyBJbnB1dDoKIC8vICAgICBkZXYgICAgLSBkZXZpY2Ugc3RydWN0dXJlCiAvLyAgICAgcG54dHBoIC0gcG9pbnRlciB0byBuZXh0IHBzZXVkbyBoZWFkZXIKQEAgLTEyODUsNyArMTI4NSw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9wYXJzZV9kcHJhbV9tc2cKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBwYXJzZSB0aGUgbWVzc2FnZSByZWNlaXZlZCBmcm9tIHRoZSBEU1AKKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcGFyc2UgdGhlIG1lc3NhZ2UgcmVjZWl2ZWQgZnJvbSB0aGUgRFNQCiAvLyAgICAgICAgICAgICB2aWEgdGhlIERQUkFNIGludGVyZmFjZS4KIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKQEAgLTE0NDIsNyArMTQ0Miw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9mbHVzaF9maWZvCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgZmx1c2ggb25lIHBhY2tldCBmcm9tIHRoZSBkb3dubGluaworLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBmbHVzaCBvbmUgcGFja2V0IGZyb20gdGhlIGRvd25saW5rCiAvLyAgICAgICAgICAgICBGSUZPLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgICAgLSBkZXZpY2Ugc3RydWN0dXJlCkBAIC0xNTg3LDcgKzE1ODcsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfY29weV91cF9wa3QKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBwdWxsIEZsYXJpb24gcGFja2V0cyBvdXQgb2YgdGhlIERvd25saW5rCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHB1bGwgRmxhcmlvbiBwYWNrZXRzIG91dCBvZiB0aGUgRG93bmxpbmsKIC8vICAgICAgICAgICAgIEZJRk8gYW5kIGNvbnZlcnQgaXQgdG8gYW4gZXRoZXJuZXQgcGFja2V0LiAgVGhlIGV0aGVybmV0IHBhY2tldCB3aWxsCiAvLyAgICAgICAgICAgICB0aGVuIGJlIGRlbGl2ZXIgdG8gdGhlIFRDUC9JUCBzdGFjay4KIC8vIElucHV0OgpAQCAtMTc3Myw3ICsxNzczLDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX2NvcHlfZG93bl9wa3QKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCB0YWtlIGFuIGV0aGVybmV0IHBhY2tldCBhbmQgY29udmVydCBpdCB0bworLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCB0YWtlIGFuIGV0aGVybmV0IHBhY2tldCBhbmQgY29udmVydCBpdCB0bwogLy8gICAgICAgICAgICAgYSBGbGFyaW9uIHBhY2tldCBwcmlvciB0byBzZW5kaW5nIGl0IHRvIHRoZSBBU0lDIERvd25saW5rCiAvLyAgICAgICAgICAgICBGSUZPLgogLy8gSW5wdXQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC11c2IvZnQxMDAwX2Rvd25sb2FkLmMgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC11c2IvZnQxMDAwX2Rvd25sb2FkLmMKaW5kZXggOGU2MjI0Mi4uMTk3MmI3MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtdXNiL2Z0MTAwMF9kb3dubG9hZC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9mdDEwMDAvZnQxMDAwLXVzYi9mdDEwMDBfZG93bmxvYWQuYwpAQCAtNDg4LDcgKzQ4OCw3IEBACiAvLyBQYXJhbWV0ZXJzOiAgc3RydWN0IGZ0MTAwMF9kZXZpY2UgIC0gZGV2aWNlIHN0cnVjdHVyZQogLy8gICAgICAgICAgICAgIHUxNiAqKnBVc0ZpbGUgLSBEU1AgaW1hZ2UgZmlsZSBwb2ludGVyIGluIHUxNgogLy8gICAgICAgICAgICAgIHU4ICAqKnBVY0ZpbGUgLSBEU1AgaW1hZ2UgZmlsZSBwb2ludGVyIGluIHU4Ci0vLyAgICAgICAgICAgICAgbG9uZyAgIHdvcmRfbGVuZ3RoIC0gbGVuZ2h0IG9mIHRoZSBidWZmZXIgdG8gYmUgd3JpdHRlbgorLy8gICAgICAgICAgICAgIGxvbmcgICB3b3JkX2xlbmd0aCAtIGxlbmd0aCBvZiB0aGUgYnVmZmVyIHRvIGJlIHdyaXR0ZW4KIC8vICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0byBEUFJBTQogLy8KIC8vIFJldHVybnM6ICAgICBTVEFUVVNfU1VDQ0VTUyAtIHN1Y2Nlc3MKQEAgLTYyOCw3ICs2MjgsNyBAQAogLy8gUGFyYW1ldGVyczogIHN0cnVjdCBmdDEwMDBfZGV2aWNlICAtIGRldmljZSBzdHJ1Y3R1cmUKIC8vICAgICAgICAgICAgICB1MTYgKipwVXNGaWxlIC0gRFNQIGltYWdlIGZpbGUgcG9pbnRlciBpbiB1MTYKIC8vICAgICAgICAgICAgICB1OCAgKipwVWNGaWxlIC0gRFNQIGltYWdlIGZpbGUgcG9pbnRlciBpbiB1OAotLy8gICAgICAgICAgICAgIGxvbmcgICB3b3JkX2xlbmd0aCAtIGxlbmdodCBvZiB0aGUgYnVmZmVyIHRvIGJlIHdyaXR0ZW4KKy8vICAgICAgICAgICAgICBsb25nICAgd29yZF9sZW5ndGggLSBsZW5ndGggb2YgdGhlIGJ1ZmZlciB0byBiZSB3cml0dGVuCiAvLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdG8gRFBSQU0KIC8vCiAvLyBSZXR1cm5zOiAgICAgU1RBVFVTX1NVQ0NFU1MgLSBzdWNjZXNzCkBAIC04MTcsNyArODE3LDcgQEAKIAkJCQkJCSAqIEVycm9yLCBiZXlvbmQgYm9vdCBjb2RlIHJhbmdlLgogCQkJCQkJICovCiAJCQkJCQlERUJVRwotCQkJCQkJICAgICgiRlQxMDAwOmRvd25sb2FkOkRvd25sb2FkIGVycm9yOiBSZXF1ZXN0ZWQgbGVuPSVkIGV4Y2VlZHMgQk9PVCBjb2RlIGJvdW5kcnkuXG4iLAorCQkJCQkJICAgICgiRlQxMDAwOmRvd25sb2FkOkRvd25sb2FkIGVycm9yOiBSZXF1ZXN0ZWQgbGVuPSVkIGV4Y2VlZHMgQk9PVCBjb2RlIGJvdW5kYXJ5LlxuIiwKIAkJCQkJCSAgICAgKGludCl3b3JkX2xlbmd0aCk7CiAJCQkJCQlzdGF0dXMgPSBTVEFUVVNfRkFJTFVSRTsKIAkJCQkJCWJyZWFrOwpAQCAtOTUwLDcgKzk1MCw3IEBACiAJCQkJCQkgKiBFcnJvciwgYmV5b25kIGJvb3QgY29kZSByYW5nZS4KIAkJCQkJCSAqLwogCQkJCQkJREVCVUcKLQkJCQkJCSAgICAoIkZUMTAwMDpkb3dubG9hZDpEb3dubG9hZCBlcnJvcjogUmVxdWVzdGVkIGxlbj0lZCBleGNlZWRzIERTUCBjb2RlIGJvdW5kcnkuXG4iLAorCQkJCQkJICAgICgiRlQxMDAwOmRvd25sb2FkOkRvd25sb2FkIGVycm9yOiBSZXF1ZXN0ZWQgbGVuPSVkIGV4Y2VlZHMgRFNQIGNvZGUgYm91bmRhcnkuXG4iLAogCQkJCQkJICAgICAoaW50KXdvcmRfbGVuZ3RoKTsKIAkJCQkJCXN0YXR1cyA9IFNUQVRVU19GQUlMVVJFOwogCQkJCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC11c2IvZnQxMDAwX2h3LmMgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC11c2IvZnQxMDAwX2h3LmMKaW5kZXggNzhkY2Q0OS4uNjg0ZTY5ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtdXNiL2Z0MTAwMF9ody5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9mdDEwMDAvZnQxMDAwLXVzYi9mdDEwMDBfaHcuYwpAQCAtNTg1LDcgKzU4NSw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9yZXNldF9hc2ljCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgY2FsbCB0aGUgQ2FyZCBTZXJ2aWNlIGZ1bmN0aW9uIHRvIHJlc2V0IHRoZQorLy8gRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gd2lsbCBjYWxsIHRoZSBDYXJkIFNlcnZpY2UgZnVuY3Rpb24gdG8gcmVzZXQgdGhlCiAvLyAgICAgICAgICAgICBBU0lDLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQpAQCAtNjI2LDcgKzYyNiw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9yZXNldF9jYXJkCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVzZXQgdGhlIGNhcmQKKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVzZXQgdGhlIGNhcmQKIC8vIElucHV0OgogLy8gICAgIGRldiAgICAtIGRldmljZSBzdHJ1Y3R1cmUKIC8vIE91dHB1dDoKQEAgLTkxNyw3ICs5MTcsNyBAQAogLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vCiAvLyBGdW5jdGlvbjogICBmdDEwMDBfY29weV9kb3duX3BrdAotLy8gRGVzY3JpcHRvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHRha2UgYW4gZXRoZXJuZXQgcGFja2V0IGFuZCBjb252ZXJ0IGl0IHRvCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHRha2UgYW4gZXRoZXJuZXQgcGFja2V0IGFuZCBjb252ZXJ0IGl0IHRvCiAvLyAgICAgICAgICAgICBhIEZsYXJpb24gcGFja2V0IHByaW9yIHRvIHNlbmRpbmcgaXQgdG8gdGhlIEFTSUMgRG93bmxpbmsKIC8vICAgICAgICAgICAgIEZJRk8uCiAvLyBJbnB1dDoKQEAgLTEwNzUsMTAgKzEwNzUsMTAgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX2NvcHlfdXBfcGt0Ci0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgdGFrZSBhIHBhY2tldCBmcm9tIHRoZSBGSUZPIHVwIGxpbmsgYW5kCisvLyBEZXNjcmlwdGlvbjogVGhpcyBmdW5jdGlvbiB3aWxsIHRha2UgYSBwYWNrZXQgZnJvbSB0aGUgRklGTyB1cCBsaW5rIGFuZAogLy8gICAgICAgICAgICAgY29udmVydCBpdCBpbnRvIGFuIGV0aGVybmV0IHBhY2tldCBhbmQgZGVsaXZlciBpdCB0byB0aGUgSVAgc3RhY2sKIC8vIElucHV0OgotLy8gICAgIHVyYiAtIHRoZSByZWNldmluZyB1c2IgdXJiCisvLyAgICAgdXJiIC0gdGhlIHJlY2VpdmluZyB1c2IgdXJiCiAvLwogLy8gT3V0cHV0OgogLy8gICAgIHN0YXR1cyAtIEZBSUxVUkUKQEAgLTExODIsNyArMTE4Miw3IEBACiAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8KIC8vIEZ1bmN0aW9uOiAgIGZ0MTAwMF9zdWJtaXRfcnhfdXJiCi0vLyBEZXNjcmlwdG9uOiB0aGUgcmVjZWl2aW5nIGZ1bmN0aW9uIG9mIHRoZSBuZXR3b3JrIGRyaXZlcgorLy8gRGVzY3JpcHRpb246IHRoZSByZWNlaXZpbmcgZnVuY3Rpb24gb2YgdGhlIG5ldHdvcmsgZHJpdmVyCiAvLwogLy8gSW5wdXQ6CiAvLyAgICAgaW5mbyAtIGEgcHJpdmF0ZSBzdHJ1Y3R1cmUgY29udGFpbnMgdGhlIGRldmljZSBpbmZvcm1hdGlvbgpAQCAtMTMxNiw3ICsxMzE2LDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX2Noa2NhcmQKLS8vIERlc2NyaXB0b246IFRoaXMgZnVuY3Rpb24gd2lsbCBjaGVjayBpZiB0aGUgZGV2aWNlIGlzIHByZXNlbnRseSBhdmFpbGFibGUgb24KKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgY2hlY2sgaWYgdGhlIGRldmljZSBpcyBwcmVzZW50bHkgYXZhaWxhYmxlIG9uCiAvLyAgICAgICAgICAgICB0aGUgc3lzdGVtLgogLy8gSW5wdXQ6CiAvLyAgICAgZGV2ICAgIC0gZGV2aWNlIHN0cnVjdHVyZQpAQCAtMTM2Myw3ICsxMzYzLDcgQEAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvLwogLy8gRnVuY3Rpb246ICAgZnQxMDAwX3JlY2VpdmVfY21kCi0vLyBEZXNjcmlwdG9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVhZCBhIG1lc3NhZ2UgZnJvbSB0aGUgZHByYW0gYXJlYS4KKy8vIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVhZCBhIG1lc3NhZ2UgZnJvbSB0aGUgZHByYW0gYXJlYS4KIC8vIElucHV0OgogLy8gICAgZGV2IC0gbmV0d29yayBkZXZpY2Ugc3RydWN0dXJlCiAvLyAgICBwYnVmZmVyIC0gY2FsbGVyIHN1cHBseSBhZGRyZXNzIHRvIGJ1ZmZlcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtdXNiL2Z0MTAwMF9pb2N0bC5oIGIvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtdXNiL2Z0MTAwMF9pb2N0bC5oCmluZGV4IDNmNzJkNWIuLjZhOGExOTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9mdDEwMDAvZnQxMDAwLXVzYi9mdDEwMDBfaW9jdGwuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC11c2IvZnQxMDAwX2lvY3RsLmgKQEAgLTU1LDcgKzU1LDcgQEAKICAgIHVuc2lnbmVkIGNoYXIgICAgIHNlcV9udW07ICAgICAgICAgIC8vc2VxdWVuY2UgbnVtYmVyCiAgICB1bnNpZ25lZCBjaGFyICAgICByc3ZkMjsgICAgICAgICAgICAvL3Jlc2VydmVkCiAgICB1bnNpZ25lZCBzaG9ydCAgICBxb3NfY2xhc3M7ICAgICAgICAvL1F1YWxpdHkgb2YgU2VydmljZSBjbGFzcyAoTm90IGFwcGxpY2FibGUgb24gTW9iaWxlKQotICAgdW5zaWduZWQgc2hvcnQgICAgY2hlY2tzdW07ICAgICAgICAgLy9Qc3VlZG8gaGVhZGVyIGNoZWNrc3VtCisgICB1bnNpZ25lZCBzaG9ydCAgICBjaGVja3N1bTsgICAgICAgICAvL1BzZXVkbyBoZWFkZXIgY2hlY2tzdW0KIH0gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOwogCiB0eXBlZGVmIHN0cnVjdCBfSU9DVExfR0VUX1ZFUgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtdXNiL2Z0MTAwMF91c2IuaCBiL2RyaXZlcnMvc3RhZ2luZy9mdDEwMDAvZnQxMDAwLXVzYi9mdDEwMDBfdXNiLmgKaW5kZXggZTA0N2MwMy4uZjJlY2IzZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Z0MTAwMC9mdDEwMDAtdXNiL2Z0MTAwMF91c2IuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZnQxMDAwL2Z0MTAwMC11c2IvZnQxMDAwX3VzYi5oCkBAIC0zNjQsNyArMzY0LDcgQEAKIAogI2RlZmluZSBJU1JfRU1QVFkJCQkodTgpMHgwMCAJIC8vIG5vIGJpdHMgc2V0IGluIElTUgogCi0jZGVmaW5lIElTUl9ET09SQkVMTF9BQ0sJKHU4KTB4MDEJCSAvLyAgdGhlIGRvb3JiZWxsIGkgc2VudCBoYXMgYmVlbiByZWNpZXZlZC4KKyNkZWZpbmUgSVNSX0RPT1JCRUxMX0FDSwkodTgpMHgwMQkJIC8vICB0aGUgZG9vcmJlbGwgaSBzZW50IGhhcyBiZWVuIHJlY2VpdmVkLgogCiAjZGVmaW5lIElTUl9ET09SQkVMTF9QRU5ECSh1OCkweDAyIAkgLy8gIGRvb3JiZWxsIGZvciBtZQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvZ2VuZXJpY19zZXJpYWwuYyBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9nZW5lcmljX3NlcmlhbC5jCmluZGV4IDQ2Njk4OGQuLmYyOWRkYTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9nZW5lcmljX3NlcmlhbC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9nZW5lcmljX3NlcmlhbC5jCkBAIC0xMTMsNyArMTEzLDcgQEAKIAogCQljID0gY291bnQ7CiAgCi0JCS8qIFRoaXMgaXMgc2FmZSBiZWNhdXNlIHdlICJPV04iIHRoZSAiaGVhZCIuIE5vb25lIGVsc2UgY2FuIAorCQkvKiBUaGlzIGlzIHNhZmUgYmVjYXVzZSB3ZSAiT1dOIiB0aGUgImhlYWQiLiBObyBvbmUgZWxzZSBjYW4gCiAJCSAgIGNoYW5nZSB0aGUgImhlYWQiOiB3ZSBvd24gdGhlIHBvcnRfd3JpdGVfbXV0ZXguICovCiAJCS8qIERvbid0IG92ZXJydW4gdGhlIGVuZCBvZiB0aGUgYnVmZmVyICovCiAJCXQgPSBTRVJJQUxfWE1JVF9TSVpFIC0gcG9ydC0+eG1pdF9oZWFkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9tYXAuaCBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vbWFwLmgKaW5kZXggODM2Njk3OC4uMjhhNjYxMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9tYXAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvcmlvL21hcC5oCkBAIC04Nyw3ICs4Nyw3IEBACiAqKiBUaGUgVG9wb2xvZ3kgYXJyYXkgY29udGFpbnMgdGhlIElEIG9mIHRoZSB1bml0IGNvbm5lY3RlZCB0byBlYWNoIG9mIHRoZQogKiogZm91ciBsaW5rcyBvbiB0aGlzIHVuaXQuIFRoZSBlbnRyeSB3aWxsIGJlIDB4RkZGRiBpZiBOT1RISU5HIGlzIGNvbm5lY3RlZAogKiogdG8gdGhlIGxpbmssIG9yIHdpbGwgYmUgMHhGRjAwIGlmIGFuIFVOS05PV04gdW5pdCBpcyBjb25uZWN0ZWQgdG8gdGhlIGxpbmsuCi0qKiBUaGUgTmFtZSBmaWVsZCBpcyBhIG51bGwtdGVybWluYXRlZCBzdHJpbmcsIHVwdG8gMzEgY2hhcmFjdGVycywgY29udGFpbmluZworKiogVGhlIE5hbWUgZmllbGQgaXMgYSBudWxsLXRlcm1pbmF0ZWQgc3RyaW5nLCB1cCB0byAzMSBjaGFyYWN0ZXJzLCBjb250YWluaW5nCiAqKiB0aGUgJ2N1dGUnIG5hbWUgdGhhdCB0aGUgc3lzYWRtaW4vdXNlcnMga25vdyB0aGUgUlRBIGJ5LiBJdCBpcyBwZXJtaXNzaWJsZQogKiogZm9yIHRoaXMgc3RyaW5nIHRvIGNvbnRhaW4gYW55IGNoYXJhY3RlciBpbiB0aGUgcmFuZ2UgXDA0MCB0byBcMTc2IGluY2x1c2l2ZS4KICoqIEluIHBhcnRpY3VsYXIsIGN0cmwgc2VxdWVuY2VzIGFuZCBERUwgKDB4N0YsIFwxNzcpIGFyZSBub3QgYWxsb3dlZC4gVGhlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvcmlvL3Jpb2Jvb3QuYyBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vcmlvYm9vdC5jCmluZGV4IGQ5NTZkZDMuLmZmYTAxYzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vcmlvYm9vdC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vcmlvYm9vdC5jCkBAIC0xMDksNyArMTA5LDcgQEAKIAlyaW9fZHByaW50ayhSSU9fREVCVUdfQk9PVCwgIkRhdGEgYXQgdXNlciBhZGRyZXNzICVwXG4iLCByYnAtPkRhdGFQKTsKIAogCS8qCi0JICoqIENoZWNrIHRoYXQgd2UgaGF2ZSBzZXQgYXNzaWRlIGVub3VnaCBtZW1vcnkgZm9yIHRoaXMKKwkgKiogQ2hlY2sgdGhhdCB3ZSBoYXZlIHNldCBhc2lkZSBlbm91Z2ggbWVtb3J5IGZvciB0aGlzCiAJICovCiAJaWYgKHJicC0+Q291bnQgPiBTSVhUWV9GT1VSX0spIHsKIAkJcmlvX2RwcmludGsoUklPX0RFQlVHX0JPT1QsICJSVEEgQm9vdCBDb2RlIFRvbyBMYXJnZSFcbiIpOwpAQCAtMjkzLDcgKzI5Myw3IEBACiAJCS8qCiAJCSAqKiAgICAgICAgICAgICAgICAgICAgIFMgVCBPIFAgIQogCQkgKioKLQkJICoqIFVwdG8gdGhpcyBwb2ludCB0aGUgY29kZSBoYXMgYmVlbiBmYWlybHkgcmF0aW9uYWwsIGFuZCBwb3NzaWJseQorCQkgKiogVXAgdG8gdGhpcyBwb2ludCB0aGUgY29kZSBoYXMgYmVlbiBmYWlybHkgcmF0aW9uYWwsIGFuZCBwb3NzaWJseQogCQkgKiogZXZlbiBzdHJhaWdodCBmb3J3YXJkLiBXaGF0IGZvbGxvd3MgaXMgYSBwaWxlIG9mIGNydWQgdGhhdCB3aWxsCiAJCSAqKiBtYWdpY2FsbHkgdHVybiBpbnRvIHNpeCBieXRlcyBvZiB0cmFuc3B1dGVyIGFzc2VtYmxlci4gTm9ybWFsbHkKIAkJICoqIHlvdSB3b3VsZCBleHBlY3QgYW4gYXJyYXkgb3Igc29tZXRoaW5nLCBidXQsIGJlaW5nIG1lLCBJIGhhdmUKQEAgLTQxOSw3ICs0MTksNyBAQAogCQlyaW9fZHByaW50ayhSSU9fREVCVUdfQk9PVCwgIlNldCBjb250cm9sIHBvcnRcbiIpOwogCiAJCS8qCi0JCSAqKiBOb3csIHdhaXQgZm9yIHVwdG8gZml2ZSBzZWNvbmRzIGZvciB0aGUgVHAgdG8gc2V0dXAgdGhlIHBhcm1tYXAKKwkJICoqIE5vdywgd2FpdCBmb3IgdXAgdG8gZml2ZSBzZWNvbmRzIGZvciB0aGUgVHAgdG8gc2V0dXAgdGhlIHBhcm1tYXAKIAkJICoqIHBvaW50ZXI6CiAJCSAqLwogCQlmb3IgKHdhaXRfY291bnQgPSAwOyAod2FpdF9jb3VudCA8IHAtPlJJT0NvbmYuU3RhcnR1cFRpbWUpICYmIChyZWFkdygmSG9zdFAtPl9fUGFybU1hcFIpID09IE9sZFBhcm1NYXApOyB3YWl0X2NvdW50KyspIHsKQEAgLTQ3NSw3ICs0NzUsNyBAQAogCiAJCS8qCiAJCSAqKiBub3cgd2FpdCBmb3IgdGhlIGNhcmQgdG8gc2V0IGFsbCB0aGUgcGFybW1hcC0+WFhYIHN0dWZmCi0JCSAqKiB0aGlzIGlzIGEgd2FpdCBvZiB1cHRvIHR3byBzZWNvbmRzLi4uLgorCQkgKiogdGhpcyBpcyBhIHdhaXQgb2YgdXAgdG8gdHdvIHNlY29uZHMuLi4uCiAJCSAqLwogCQlyaW9fZHByaW50ayhSSU9fREVCVUdfQk9PVCwgIkxvb2tpbmcgZm9yIGluaXRfZG9uZSAtICVkIHRpY2tzXG4iLCBwLT5SSU9Db25mLlN0YXJ0dXBUaW1lKTsKIAkJSG9zdFAtPnRpbWVvdXRfaWQgPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9yaW9jbWQuYyBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vcmlvY21kLmMKaW5kZXggZjEyMTM1Ny4uNjFlZmQ1MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9yaW9jbWQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvcmlvL3Jpb2NtZC5jCkBAIC04NjMsNyArODYzLDcgQEAKIAkgKiogYmVpbmcgdHJhbnNmZXJyZWQgZnJvbSB0aGUgd3JpdGUgcXVldWUgaW50byB0aGUgdHJhbnNtaXQgcGFja2V0cwogCSAqKiAoYWRkX3RyYW5zbWl0KSBhbmQgbm8gZnVydGh1ciB0cmFuc21pdCBpbnRlcnJ1cHQgd2lsbCBiZSBzZW50IGZvciB0aGF0CiAJICoqIGRhdGEuIFRoZSBuZXh0IGludGVycnVwdCB3aWxsIG9jY3VyIHVwIHRvIDUwMG1zIGxhdGVyIChSSU9JbnRyIGlzIGNhbGxlZAotCSAqKiB0d2ljZSBhIHNlY29uZCBhcyBhIHNhZnRleSBtZWFzdXJlKS4gVGhpcyB3YXMgdGhlIGNhc2Ugd2hlbiBrZXJtaXQgd2FzCisJICoqIHR3aWNlIGEgc2Vjb25kIGFzIGEgc2FmZXR5IG1lYXN1cmUpLiBUaGlzIHdhcyB0aGUgY2FzZSB3aGVuIGtlcm1pdCB3YXMKIAkgKiogdXNlZCB0byBzZW5kIGRhdGEgaW50byBhIFJJTyBwb3J0LiBBZnRlciBlYWNoIHBhY2tldCB3YXMgc2VudCwgVENGTFNICiAJICoqIHdhcyBjYWxsZWQgdG8gZmx1c2ggdGhlIHJlYWQgcXVldWUgcHJlZW1wdGl2ZWx5LiBQb3J0UC0+SW5Vc2Ugd2FzCiAJICoqIGluY3JlbWVudGVkLCB0aGVyZWJ5IGJsb2NraW5nIHRoZSA2IGJ5dGUgYWNrbm93bGVkZ2VtZW50IHBhY2tldApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9yaW9yb3V0ZS5jIGIvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9yaW9yb3V0ZS5jCmluZGV4IGY5YjkzNmEuLjg3NTczNzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vcmlvcm91dGUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvcmlvL3Jpb3JvdXRlLmMKQEAgLTQ1MCw3ICs0NTAsNyBAQAogCQkgKiogd2UgcmVzZXQgdGhlIHVuaXQsIGJlY2F1c2Ugd2UgZGlkbid0IGJvb3QgaXQuCiAJCSAqKiBIb3dldmVyLCBpZiB0aGUgdGFibGUgaXMgZnVsbCwgaXQgY291bGQgYmUgdGhhdCB3ZSBkaWQgYm9vdAogCQkgKiogdGhpcyB1bml0LCBhbmQgc28gd2Ugd29uJ3QgcmVib290IGl0LCBiZWNhdXNlIGl0IGlzbid0IHJlYWxseQotCQkgKiogYWxsIHRoYXQgZGlzYXN0ZXJvdXMgdG8ga2VlcCB0aGUgb2xkIGJpbnMgaW4gbW9zdCBjYXNlcy4gVGhpcworCQkgKiogYWxsIHRoYXQgZGlzYXN0cm91cyB0byBrZWVwIHRoZSBvbGQgYmlucyBpbiBtb3N0IGNhc2VzLiBUaGlzCiAJCSAqKiBpcyBhIHJhdGhlciB0YWNreSBmZWF0dXJlLCBidXQgd2UgYXJlIG9uIHRoZSBlZGdlIG9mIHJlYWxsaXR5CiAJCSAqKiBoZXJlLCBiZWNhdXNlIHRoZSBpbXBsaWNhdGlvbiBpcyB0aGF0IHNvbWVvbmUgaGFzIGNvbm5lY3RlZAogCQkgKiogMTYrTUFYX0VYVFJBX1VOSVRTIG9udG8gb25lIGhvc3QuCkBAIC02NzgsNyArNjc4LDcgQEAKIAogCUhvc3RQLT5NYXBwaW5nW1VuaXRJZF0uRmxhZ3MgJj0gfkJFRU5fSEVSRTsKIAotCS8qIHJpb19kcHJpbnQoUklPX0RFQlVHX1JPVVRFLCAoIlVuaXQgJWQgRE9FU05UIEtOT1cgVEhFIEhPU1QhXG4iLCBVbml0SWQpKTsgKi8KKwkvKiByaW9fZHByaW50KFJJT19ERUJVR19ST1VURSwgKCJVbml0ICVkIERPRVNOJ1QgS05PVyBUSEUgSE9TVCFcbiIsIFVuaXRJZCkpOyAqLwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvcmlvL3Jpb3R0eS5jIGIvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3Jpby9yaW90dHkuYwppbmRleCA4YTkwMzkzLi5lN2U5OTExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvcmlvL3Jpb3R0eS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9nZW5lcmljX3NlcmlhbC9yaW8vcmlvdHR5LmMKQEAgLTEyNCw3ICsxMjQsNyBAQAogCX0KIAogCS8qCi0JICoqIEdyYWIgcG9pbnRlciB0byB0aGUgcG9ydCBzdHVjdHVyZQorCSAqKiBHcmFiIHBvaW50ZXIgdG8gdGhlIHBvcnQgc3RydWN0dXJlCiAJICovCiAJUG9ydFAgPSBwLT5SSU9Qb3J0cFtTeXNQb3J0XTsJLyogR2V0IGNvbnRyb2wgc3RydWMgKi8KIAlyaW9fZHByaW50ayhSSU9fREVCVUdfVFRZLCAiUG9ydFA6ICVwXG4iLCBQb3J0UCk7CkBAIC0xNjEsNyArMTYxLDcgQEAKIAl9CiAKIAkvKgotCSAqKiBJZiB0aGUgUlRBIGhhcyBub3QgYm9vdGVkIHlldCBhbmQgdGhlIHVzZXIgaGFzIGNob29zZW4gdG8gYmxvY2sKKwkgKiogSWYgdGhlIFJUQSBoYXMgbm90IGJvb3RlZCB5ZXQgYW5kIHRoZSB1c2VyIGhhcyBjaG9zZW4gdG8gYmxvY2sKIAkgKiogdW50aWwgdGhlIFJUQSBpcyBwcmVzZW50IHRoZW4gd2UgbXVzdCBzcGluIGhlcmUgd2FpdGluZyBmb3IKIAkgKiogdGhlIFJUQSB0byBib290LgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dlbmVyaWNfc2VyaWFsL3N4LmMgYi9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvc3guYwppbmRleCAxMjkxNDYyLi40Zjk0YWFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvc3guYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZ2VuZXJpY19zZXJpYWwvc3guYwpAQCAtMTU4LDEzICsxNTgsMTMgQEAKICAqIFJlYWR5aW5nIGZvciByZWxlYXNlIG9uIDIuMC54IChzb3JyeSBEYXZpZCwgMS4wMSBiZWNvbWVzIDEuMSBmb3IgUkNTKS4gCiAgKgogICogUmV2aXNpb24gMC4xMiAgMTk5OS8wMy8yOCAwOToyMDoxMCAgd29sZmYKLSAqIEZpeGVkIHByb2JsZW0gaW4gMC4xMSwgY29udGludWVpbmcgY2xlYW51cC4KKyAqIEZpeGVkIHByb2JsZW0gaW4gMC4xMSwgY29udGludWluZyBjbGVhbnVwLgogICoKICAqIFJldmlzaW9uIDAuMTEgIDE5OTkvMDMvMjggMDg6NDY6NDQgIHdvbGZmCiAgKiBjbGVhbnVwLiBOb3QgZ29vZC4KICAqCiAgKiBSZXZpc2lvbiAwLjEwICAxOTk5LzAzLzI4IDA4OjA5OjQzICB3b2xmZgotICogRml4ZWQgbG9vc2luZyBjaGFyYWN0ZXJzIG9uIGNsb3NlLgorICogRml4ZWQgbG9zaW5nIGNoYXJhY3RlcnMgb24gY2xvc2UuCiAgKgogICogUmV2aXNpb24gMC45ICAxOTk5LzAzLzIxIDIyOjUyOjAxICB3b2xmZgogICogUG9ydGVkIGJhY2sgdG8gMi4yLi4uLiAobWlub3IgdGhpbmdzKQpAQCAtMTU4OCw3ICsxNTg4LDcgQEAKICNkZWZpbmUgUjAJCWlmIChyZWFkX3N4X2J5dGUoYm9hcmQsIGkpICE9IDB4NTUpIHJldHVybiAxCiAjZGVmaW5lIFIxCQlpZiAocmVhZF9zeF9ieXRlKGJvYXJkLCBpKSAhPSAweGFhKSByZXR1cm4gMQogCi0vKiBUaGlzIG1lbXRlc3QgdGFrZXMgYSBodW1hbi1ub3RpY2FibGUgdGltZS4gWW91IG5vcm1hbGx5IG9ubHkgZG8gaXQKKy8qIFRoaXMgbWVtdGVzdCB0YWtlcyBhIGh1bWFuLW5vdGljZWFibGUgdGltZS4gWW91IG5vcm1hbGx5IG9ubHkgZG8gaXQKICAgIG9uY2UgYSBib290LCBzbyBJIGd1ZXNzIHRoYXQgaXQgaXMgd29ydGggaXQuICovCiBzdGF0aWMgaW50IGRvX21lbXRlc3Qoc3RydWN0IHN4X2JvYXJkICpib2FyZCwgaW50IG1pbiwgaW50IG1heCkKIHsKQEAgLTE2NDUsNyArMTY0NSw3IEBACiAjZGVmaW5lIFIxCQlpZiAocmVhZF9zeF93b3JkKGJvYXJkLCBpKSAhPSAweGFhNTUpIHJldHVybiAxCiAKICNpZiAwCi0vKiBUaGlzIG1lbXRlc3QgdGFrZXMgYSBodW1hbi1ub3RpY2FibGUgdGltZS4gWW91IG5vcm1hbGx5IG9ubHkgZG8gaXQKKy8qIFRoaXMgbWVtdGVzdCB0YWtlcyBhIGh1bWFuLW5vdGljZWFibGUgdGltZS4gWW91IG5vcm1hbGx5IG9ubHkgZG8gaXQKICAgIG9uY2UgYSBib290LCBzbyBJIGd1ZXNzIHRoYXQgaXQgaXMgd29ydGggaXQuICovCiBzdGF0aWMgaW50IGRvX21lbXRlc3RfdyhzdHJ1Y3Qgc3hfYm9hcmQgKmJvYXJkLCBpbnQgbWluLCBpbnQgbWF4KQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfZHJtLmggYi9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl9kcm0uaAppbmRleCBmYjliNDI0Li5hMzM5NDA2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl9kcm0uaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl9kcm0uaApAQCAtMTMxLDcgKzEzMSw3IEBACiAJdTMyIHByZV9hZGQ7CS8qIERlc3RpbmF0aW9uIGZvcm1hdDogKi8KIAl1MzIgYmFja2dyb3VuZDsJLyogRGVzdGluYXRpb24gYWRkICovCiAJdTMyIGRzdF9idWZmZXI7CS8qIERlc3RpbmF0aW9uIGJ1ZmZlci4gSW5kZXggaW50byBidWZmZXJfbGlzdCAqLwotCXUzMiBhcmcwOwkJLyogUmVsb2Mtb3AgZGVwZW5kYW50ICovCisJdTMyIGFyZzA7CQkvKiBSZWxvYy1vcCBkZXBlbmRlbnQgKi8KIAl1MzIgYXJnMTsKIH07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2Rydi5jIGIvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfZHJ2LmMKaW5kZXggNDRjZDA5NS4uZDAxZDQ1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfZHJ2LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfZHJ2LmMKQEAgLTU2MSw3ICs1NjEsNyBAQAogCQlrZnJlZShkZXZfcHJpdik7CiAJCWRldi0+ZGV2X3ByaXZhdGUgPSBOVUxMOwogCi0JCS8qZGVzdG9yeSBWQlQgZGF0YSovCisJCS8qZGVzdHJveSBWQlQgZGF0YSovCiAJCXBzYl9pbnRlbF9kZXN0cm95X2Jpb3MoZGV2KTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2ludGVsX2Jpb3MuYyBiL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2ludGVsX2Jpb3MuYwppbmRleCBmNWJjZDExLi40OGFjOGJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl9pbnRlbF9iaW9zLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfaW50ZWxfYmlvcy5jCkBAIC0yNzEsNyArMjcxLDcgQEAKIH0KIAogLyoqCi0gKiBEZXN0b3J5IGFuZCBmcmVlIFZCVCBkYXRhCisgKiBEZXN0cm95IGFuZCBmcmVlIFZCVCBkYXRhCiAgKi8KIHZvaWQgcHNiX2ludGVsX2Rlc3Ryb3lfYmlvcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfaW50ZWxfc2R2by5jIGIvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfaW50ZWxfc2R2by5jCmluZGV4IDczMWE1YTIuLjFkMmJiMDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2ludGVsX3Nkdm8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl9pbnRlbF9zZHZvLmMKQEAgLTU3Myw3ICs1NzMsNyBAQAogCS8qIE1ha2UgYWxsIGZpZWxkcyBvZiB0aGUgIGFyZ3MvcmV0IHRvIHplcm8gKi8KIAltZW1zZXQoYnlBcmdzLCAwLCBzaXplb2YoYnlBcmdzKSk7CiAKLQkvKiBGaWxsIHVwIHRoZSBhcmd1ZW1lbnQgdmFsdWVzOyAqLworCS8qIEZpbGwgdXAgdGhlIGFyZ3VtZW50IHZhbHVlczsgKi8KIAlieUFyZ3NbMF0gPSAodTgpIChpbjBvdXRwdXRtYXNrICYgMHhGRik7CiAJYnlBcmdzWzFdID0gKHU4KSAoKGluMG91dHB1dG1hc2sgPj4gOCkgJiAweEZGKTsKIAlieUFyZ3NbMl0gPSAodTgpIChpbjFvdXRwdXRtYXNrICYgMHhGRik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl9pbnRlbF9zZHZvX3JlZ3MuaCBiL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2ludGVsX3Nkdm9fcmVncy5oCmluZGV4IGExZDE0NzUuLmM3MTA3YTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2ludGVsX3Nkdm9fcmVncy5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX2ludGVsX3Nkdm9fcmVncy5oCkBAIC0yMTcsNyArMjE3LDcgQEAKIH0gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOwogCiAvKioKLSAqIFRha2VzIGEgc3RydWN0IHBzYl9pbnRlbF9zZHZvX291dHB1dF9mbGFncyBvZiB3aGljaCBvdXRwdXRzIGFyZSB0YXJnZXR0ZWQgYnkKKyAqIFRha2VzIGEgc3RydWN0IHBzYl9pbnRlbF9zZHZvX291dHB1dF9mbGFncyBvZiB3aGljaCBvdXRwdXRzIGFyZSB0YXJnZXRlZCBieQogICogZnV0dXJlIG91dHB1dCBjb21tYW5kcy4KICAqCiAgKiBBZmZlY3RlZCBjb21tYW5kcyBpbmNsdWUgU0VUX09VVFBVVF9USU1JTkdTX1BBUlRbMTJdLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfdHRtX2ZlbmNlX3VzZXIuaCBiL2RyaXZlcnMvc3RhZ2luZy9nbWE1MDAvcHNiX3R0bV9mZW5jZV91c2VyLmgKaW5kZXggZmMxM2Y4OS4uNzYyYTA1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2dtYTUwMC9wc2JfdHRtX2ZlbmNlX3VzZXIuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvZ21hNTAwL3BzYl90dG1fZmVuY2VfdXNlci5oCkBAIC0xMzAsNyArMTMwLDcgQEAKIH07CiAKIC8qCi0gKiBJb2N0bCBvZmZzZXRzIGZyb21lIGV4dGVuc3Rpb24gc3RhcnQuCisgKiBJb2N0bCBvZmZzZXRzIGZyb20gZXh0ZW5zdGlvbiBzdGFydC4KICAqLwogCiAjZGVmaW5lIFRUTV9GRU5DRV9TSUdOQUxFRCAweDAxCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvZ283MDA3L2dvNzAwNy50eHQgYi9kcml2ZXJzL3N0YWdpbmcvZ283MDA3L2dvNzAwNy50eHQKaW5kZXggMDZhNzZkYS4uOWRiMWYzOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2dvNzAwNy9nbzcwMDcudHh0CisrKyBiL2RyaXZlcnMvc3RhZ2luZy9nbzcwMDcvZ283MDA3LnR4dApAQCAtMiw3ICsyLDcgQEAKIAogUGV0ZSBFYmVybGVpbiA8cGV0ZUBzZW5zb3JheS5jb20+CiAKLVRoZSBkcml2ZXIgd2FzIG9yaWduYWxseSByZWxlYXNlZCB1bmRlciB0aGUgR1BMIGFuZCBpcyBjdXJyZW50bHkgaG9zdGVkIGF0OgorVGhlIGRyaXZlciB3YXMgb3JpZ2luYWxseSByZWxlYXNlZCB1bmRlciB0aGUgR1BMIGFuZCBpcyBjdXJyZW50bHkgaG9zdGVkIGF0OgogaHR0cDovL25pa29zYXBpLm9yZy93aWtpL2luZGV4LnBocC9XSVNfR283MDA3X0xpbnV4X2RyaXZlcgogVGhlIGdvNzAwNyBmaXJtd2FyZSBjYW4gYmUgYWNxdWlyZWQgZnJvbSB0aGUgcGFja2FnZSBvbiB0aGUgc2l0ZSBhYm92ZS4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L2Jsa3ZzY19kcnYuYyBiL2RyaXZlcnMvc3RhZ2luZy9odi9ibGt2c2NfZHJ2LmMKaW5kZXggYWY3ODk5My4uNjhhZDE3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L2Jsa3ZzY19kcnYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvYmxrdnNjX2Rydi5jCkBAIC04OTQsNyArODk0LDcgQEAKIAogLyoKICAqIFdlIGJyZWFrIHRoZSByZXF1ZXN0IGludG8gMSBvciBtb3JlIGJsa3ZzY19yZXF1ZXN0cyBhbmQgc3VibWl0Ci0gKiB0aGVtLiAgSWYgd2UgY2FudCBzdWJtaXQgdGhlbSBhbGwsIHdlIHB1dCB0aGVtIG9uIHRoZQorICogdGhlbS4gIElmIHdlIGNhbid0IHN1Ym1pdCB0aGVtIGFsbCwgd2UgcHV0IHRoZW0gb24gdGhlCiAgKiBwZW5kaW5nX2xpc3QuIFRoZSBibGt2c2NfcmVxdWVzdCgpIHdpbGwgd29yayBvbiB0aGUgcGVuZGluZ19saXN0LgogICovCiBzdGF0aWMgaW50IGJsa3ZzY19kb19yZXF1ZXN0KHN0cnVjdCBibG9ja19kZXZpY2VfY29udGV4dCAqYmxrZGV2LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L2NoYW5uZWwuYyBiL2RyaXZlcnMvc3RhZ2luZy9odi9jaGFubmVsLmMKaW5kZXggNzc1YTUyYS4uZjdjZTdkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L2NoYW5uZWwuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvY2hhbm5lbC5jCkBAIC04MSwxNCArODEsMTQgQEAKIAogCWlmIChjaGFubmVsLT5vZmZlcm1zZy5tb25pdG9yX2FsbG9jYXRlZCkgewogCQkvKiBFYWNoIHUzMiByZXByZXNlbnRzIDMyIGNoYW5uZWxzICovCi0JCXNldF9iaXQoY2hhbm5lbC0+b2ZmZXJtc2cuY2hpbGRfcmVsaWQgJiAzMSwKKwkJc3luY19zZXRfYml0KGNoYW5uZWwtPm9mZmVybXNnLmNoaWxkX3JlbGlkICYgMzEsCiAJCQkodW5zaWduZWQgbG9uZyAqKSB2bWJ1c19jb25uZWN0aW9uLnNlbmRfaW50X3BhZ2UgKwogCQkJKGNoYW5uZWwtPm9mZmVybXNnLmNoaWxkX3JlbGlkID4+IDUpKTsKIAogCQltb25pdG9ycGFnZSA9IHZtYnVzX2Nvbm5lY3Rpb24ubW9uaXRvcl9wYWdlczsKIAkJbW9uaXRvcnBhZ2UrKzsgLyogR2V0IHRoZSBjaGlsZCB0byBwYXJlbnQgbW9uaXRvciBwYWdlICovCiAKLQkJc2V0X2JpdChjaGFubmVsLT5tb25pdG9yX2JpdCwKKwkJc3luY19zZXRfYml0KGNoYW5uZWwtPm1vbml0b3JfYml0LAogCQkJKHVuc2lnbmVkIGxvbmcgKikmbW9uaXRvcnBhZ2UtPnRyaWdnZXJfZ3JvdXAKIAkJCQkJW2NoYW5uZWwtPm1vbml0b3JfZ3JwXS5wZW5kaW5nKTsKIApAQCAtMTA0LDcgKzEwNCw3IEBACiAKIAlpZiAoQ2hhbm5lbC0+b2ZmZXJtc2cubW9uaXRvcl9hbGxvY2F0ZWQpIHsKIAkJLyogRWFjaCB1MzIgcmVwcmVzZW50cyAzMiBjaGFubmVscyAqLwotCQljbGVhcl9iaXQoQ2hhbm5lbC0+b2ZmZXJtc2cuY2hpbGRfcmVsaWQgJiAzMSwKKwkJc3luY19jbGVhcl9iaXQoQ2hhbm5lbC0+b2ZmZXJtc2cuY2hpbGRfcmVsaWQgJiAzMSwKIAkJCSAgKHVuc2lnbmVkIGxvbmcgKil2bWJ1c19jb25uZWN0aW9uLnNlbmRfaW50X3BhZ2UgKwogCQkJICAoQ2hhbm5lbC0+b2ZmZXJtc2cuY2hpbGRfcmVsaWQgPj4gNSkpOwogCkBAIC0xMTIsNyArMTEyLDcgQEAKIAkJCXZtYnVzX2Nvbm5lY3Rpb24ubW9uaXRvcl9wYWdlczsKIAkJbW9uaXRvclBhZ2UrKzsgLyogR2V0IHRoZSBjaGlsZCB0byBwYXJlbnQgbW9uaXRvciBwYWdlICovCiAKLQkJY2xlYXJfYml0KENoYW5uZWwtPm1vbml0b3JfYml0LAorCQlzeW5jX2NsZWFyX2JpdChDaGFubmVsLT5tb25pdG9yX2JpdCwKIAkJCSAgKHVuc2lnbmVkIGxvbmcgKikmbW9uaXRvclBhZ2UtPnRyaWdnZXJfZ3JvdXAKIAkJCQkJW0NoYW5uZWwtPm1vbml0b3JfZ3JwXS5QZW5kaW5nKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvY2hhbm5lbF9tZ210LmMgYi9kcml2ZXJzL3N0YWdpbmcvaHYvY2hhbm5lbF9tZ210LmMKaW5kZXggYmMwMzkzYS4uMDZiNTczMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L2NoYW5uZWxfbWdtdC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9jaGFubmVsX21nbXQuYwpAQCAtMTY2LDcgKzE2Niw3IEBACiAgKiBmcm9tIEh5cGVyLVYuIFRoaXMgc3R1YiByZXNwb25kcyB0byB0aGUgZGVmYXVsdCBuZWdvdGlhdGUgbWVzc2FnZXMKICAqIHRoYXQgY29tZSBpbiBmb3IgZXZlcnkgbm9uIElERS9TQ1NJL05ldHdvcmsgcmVxdWVzdC4KICAqIFRoaXMgYmVoYXZpb3IgaXMgbm9ybWFsbHkgb3ZlcndyaXR0ZW4gaW4gdGhlIGh2X3V0aWxzIGRyaXZlci4gVGhhdAotICogZHJpdmVyIGhhbmRsZXMgcmVxdWVzdHMgbGlrZSBncmFjZWZ1bGwgc2h1dGRvd24sIGhlYXJ0YmVhdHMgZXRjLgorICogZHJpdmVyIGhhbmRsZXMgcmVxdWVzdHMgbGlrZSBncmFjZWZ1bCBzaHV0ZG93biwgaGVhcnRiZWF0cyBldGMuCiAgKgogICogTWFpbmx5IHVzZWQgYnkgSHlwZXItViBkcml2ZXJzLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvY29ubmVjdGlvbi5jIGIvZHJpdmVycy9zdGFnaW5nL2h2L2Nvbm5lY3Rpb24uYwppbmRleCA0NGIyMDNiLi5hZmM4MTE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvY29ubmVjdGlvbi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9jb25uZWN0aW9uLmMKQEAgLTI5Niw3ICsyOTYsNyBAQAogCQlmb3IgKGR3b3JkID0gMDsgZHdvcmQgPCBtYXhkd29yZDsgZHdvcmQrKykgewogCQkJaWYgKHJlY3ZfaW50X3BhZ2VbZHdvcmRdKSB7CiAJCQkJZm9yIChiaXQgPSAwOyBiaXQgPCAzMjsgYml0KyspIHsKLQkJCQkJaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChiaXQsCisJCQkJCWlmIChzeW5jX3Rlc3RfYW5kX2NsZWFyX2JpdChiaXQsCiAJCQkJCQkodW5zaWduZWQgbG9uZyAqKQogCQkJCQkJJnJlY3ZfaW50X3BhZ2VbZHdvcmRdKSkgewogCQkJCQkJcmVsaWQgPSAoZHdvcmQgPDwgNSkgKyBiaXQ7CkBAIC0zMzgsNyArMzM4LDcgQEAKIGludCB2bWJ1c19zZXRfZXZlbnQodTMyIGNoaWxkX3JlbGlkKQogewogCS8qIEVhY2ggdTMyIHJlcHJlc2VudHMgMzIgY2hhbm5lbHMgKi8KLQlzZXRfYml0KGNoaWxkX3JlbGlkICYgMzEsCisJc3luY19zZXRfYml0KGNoaWxkX3JlbGlkICYgMzEsCiAJCSh1bnNpZ25lZCBsb25nICopdm1idXNfY29ubmVjdGlvbi5zZW5kX2ludF9wYWdlICsKIAkJKGNoaWxkX3JlbGlkID4+IDUpKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L2h2LmMgYi9kcml2ZXJzL3N0YWdpbmcvaHYvaHYuYwppbmRleCAyZDQ5MmFkLi4wYjA2ZjRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvaHYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvaHYuYwpAQCAtMzcsNyArMzcsNyBAQAogCiAvKgogICogcXVlcnlfaHlwZXJ2aXNvcl9wcmVzZW5jZQotICogLSBRdWVyeSB0aGUgY3B1aWQgZm9yIHByZXNlbnNlIG9mIHdpbmRvd3MgaHlwZXJ2aXNvcgorICogLSBRdWVyeSB0aGUgY3B1aWQgZm9yIHByZXNlbmNlIG9mIHdpbmRvd3MgaHlwZXJ2aXNvcgogICovCiBzdGF0aWMgaW50IHF1ZXJ5X2h5cGVydmlzb3JfcHJlc2VuY2Uodm9pZCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9odi9odl9hcGkuaCBiL2RyaXZlcnMvc3RhZ2luZy9odi9odl9hcGkuaAppbmRleCA3MTE0ZmNlLi40M2E3MjI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvaHZfYXBpLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2h2L2h2X2FwaS5oCkBAIC01MywxNCArNTMsMTQgQEAKIAogLyoKICAqIEhWX1NUQVRVU19JTlZBTElEX0FMSUdOTUVOVAotICogVGhlIGh5cGVydmlzb3IgY291bGQgbm90IHBlcmZvcm0gdGhlIG9wZXJhdGlvbiBiZWFjdXNlIGEgcGFyYW1ldGVyIGhhcyBhbgorICogVGhlIGh5cGVydmlzb3IgY291bGQgbm90IHBlcmZvcm0gdGhlIG9wZXJhdGlvbiBiZWNhdXNlIGEgcGFyYW1ldGVyIGhhcyBhbgogICogaW52YWxpZCBhbGlnbm1lbnQuCiAgKi8KICNkZWZpbmUgSFZfU1RBVFVTX0lOVkFMSURfQUxJR05NRU5UCQkJKCh1MTYpMHgwMDA0KQogCiAvKgogICogSFZfU1RBVFVTX0lOVkFMSURfUEFSQU1FVEVSCi0gKiBUaGUgaHlwZXJ2aXNvciBjb3VsZCBub3QgcGVyZm9ybSB0aGUgb3BlcmF0aW9uIGJlYWN1c2UgYW4gaW52YWxpZCBwYXJhbWV0ZXIKKyAqIFRoZSBoeXBlcnZpc29yIGNvdWxkIG5vdCBwZXJmb3JtIHRoZSBvcGVyYXRpb24gYmVjYXVzZSBhbiBpbnZhbGlkIHBhcmFtZXRlcgogICogd2FzIHNwZWNpZmllZC4KICAqLwogI2RlZmluZSBIVl9TVEFUVVNfSU5WQUxJRF9QQVJBTUVURVIJCQkoKHUxNikweDAwMDUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvaHZfa3ZwLmggYi9kcml2ZXJzL3N0YWdpbmcvaHYvaHZfa3ZwLmgKaW5kZXggZTA2OWY1OS4uOGM0MDJmMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L2h2X2t2cC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9odl9rdnAuaApAQCAtMzYsNyArMzYsNyBAQAogICogcmVnaXN0cnkuCiAgKgogICogTm90ZTogIFRoaXMgdmFsdWUgaXMgdXNlZCBpbiBkZWZpbmluZyB0aGUgS1ZQIGV4Y2hhbmdlIG1lc3NhZ2UgLSB0aGlzIHZhbHVlCi0gKiBjYW5ub3QgYmUgbW9kaWZpZWQgd2l0aG91dCBhZmZlY3RpbmcgdGhlIG1lc3NhZ2Ugc2l6ZSBhbmQgY29tcGF0YWJpbGl0eS4KKyAqIGNhbm5vdCBiZSBtb2RpZmllZCB3aXRob3V0IGFmZmVjdGluZyB0aGUgbWVzc2FnZSBzaXplIGFuZCBjb21wYXRpYmlsaXR5LgogICovCiAKIC8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvaHZfbW91c2UuYyBiL2RyaXZlcnMvc3RhZ2luZy9odi9odl9tb3VzZS5jCmluZGV4IDUwMTQ3ZjguLjExOGM3YmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9odi9odl9tb3VzZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9odl9tb3VzZS5jCkBAIC0xNCw2ICsxNCw3IEBACiAgKi8KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgpAQCAtMjMsNiArMjQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2hpZGRldi5oPgogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgogI2luY2x1ZGUgPGxpbnV4L2RtaS5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAKICNpbmNsdWRlICJodl9hcGkuaCIKICNpbmNsdWRlICJsb2dnaW5nLmgiCkBAIC0zNzQsNyArMzc2LDcgQEAKIAkgICAgICAgZGVzYy0+ZGVzY1swXS53RGVzY3JpcHRvckxlbmd0aCk7CiAKIAkvKiBTZW5kIHRoZSBhY2sgKi8KLQltZW1zZXQoJmFjaywgc2l6ZW9mKHN0cnVjdCBtb3VzZXZzY19wcnRfbXNnKSwgMCk7CisJbWVtc2V0KCZhY2ssIDAsIHNpemVvZihzdHJ1Y3QgbW91c2V2c2NfcHJ0X21zZykpOwogCiAJYWNrLnR5cGUgPSBQaXBlTWVzc2FnZURhdGE7CiAJYWNrLnNpemUgPSBzaXplb2Yoc3RydWN0IHN5bnRoaGlkX2RldmljZV9pbmZvX2Fjayk7CkBAIC01OTUsNyArNTk3LDcgQEAKIAkvKgogCSAqIE5vdywgaW5pdGlhdGUgdGhlIHZzYy92c3AgaW5pdGlhbGl6YXRpb24gcHJvdG9jb2wgb24gdGhlIG9wZW4gY2hhbm5lbAogCSAqLwotCW1lbXNldChyZXF1ZXN0LCBzaXplb2Yoc3RydWN0IG1vdXNldnNjX3BydF9tc2cpLCAwKTsKKwltZW1zZXQocmVxdWVzdCwgMCwgc2l6ZW9mKHN0cnVjdCBtb3VzZXZzY19wcnRfbXNnKSk7CiAKIAlyZXF1ZXN0LT50eXBlID0gUGlwZU1lc3NhZ2VEYXRhOwogCXJlcXVlc3QtPnNpemUgPSBzaXplb2Yoc3RydWN0IHN5bnRoaGlkX3Byb3RvY29sX3JlcXVlc3QpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L2h2X3V0aWwuYyBiL2RyaXZlcnMvc3RhZ2luZy9odi9odl91dGlsLmMKaW5kZXggNDc5MmYyYy4uMmRmMTU2OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L2h2X3V0aWwuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvaHZfdXRpbC5jCkBAIC04MCw3ICs4MCw3IEBACiAJCQkJZXhlY3V0ZV9zaHV0ZG93biA9IHRydWU7CiAKIAkJCQlEUFJJTlRfSU5GTyhWTUJVUywgIlNodXRkb3duIHJlcXVlc3QgcmVjZWl2ZWQgLSIKLQkJCQkJICAgICIgZ3JhY2VmdWxsIHNodXRkb3duIGluaXRpYXRlZCIpOworCQkJCQkgICAgIiBncmFjZWZ1bCBzaHV0ZG93biBpbml0aWF0ZWQiKTsKIAkJCQlicmVhazsKIAkJCWRlZmF1bHQ6CiAJCQkJaWNtc2doZHJwLT5zdGF0dXMgPSBIVl9FX0ZBSUw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvbmV0dnNjX2Rydi5jIGIvZHJpdmVycy9zdGFnaW5nL2h2L25ldHZzY19kcnYuYwppbmRleCAyZDQwZjVmLi4zMzk3MzU2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvbmV0dnNjX2Rydi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9uZXR2c2NfZHJ2LmMKQEAgLTQ2LDYgKzQ2LDcgQEAKIAkvKiBwb2ludCBiYWNrIHRvIG91ciBkZXZpY2UgY29udGV4dCAqLwogCXN0cnVjdCBodl9kZXZpY2UgKmRldmljZV9jdHg7CiAJdW5zaWduZWQgbG9uZyBhdmFpbDsKKwlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgd29yazsKIH07CiAKIApAQCAtMjE5LDYgKzIyMCw3IEBACiAJCQkJICAgICAgIHVuc2lnbmVkIGludCBzdGF0dXMpCiB7CiAJc3RydWN0IG5ldF9kZXZpY2UgKm5ldCA9IGRldl9nZXRfZHJ2ZGF0YSgmZGV2aWNlX29iai0+ZGV2aWNlKTsKKwlzdHJ1Y3QgbmV0X2RldmljZV9jb250ZXh0ICpuZGV2X2N0eDsKIAogCWlmICghbmV0KSB7CiAJCURQUklOVF9FUlIoTkVUVlNDX0RSViwgImdvdCBsaW5rIHN0YXR1cyBidXQgbmV0IGRldmljZSAiCkBAIC0yMzAsNiArMjMyLDggQEAKIAkJbmV0aWZfY2Fycmllcl9vbihuZXQpOwogCQluZXRpZl93YWtlX3F1ZXVlKG5ldCk7CiAJCW5ldGlmX25vdGlmeV9wZWVycyhuZXQpOworCQluZGV2X2N0eCA9IG5ldGRldl9wcml2KG5ldCk7CisJCXNjaGVkdWxlX3dvcmsoJm5kZXZfY3R4LT53b3JrKTsKIAl9IGVsc2UgewogCQluZXRpZl9jYXJyaWVyX29mZihuZXQpOwogCQluZXRpZl9zdG9wX3F1ZXVlKG5ldCk7CkBAIC0zMjgsNiArMzMyLDI1IEBACiAJLm5kb19zZXRfbWFjX2FkZHJlc3MgPQkJZXRoX21hY19hZGRyLAogfTsKIAorLyoKKyAqIFNlbmQgR0FSUCBwYWNrZXQgdG8gbmV0d29yayBwZWVycyBhZnRlciBtaWdyYXRpb25zLgorICogQWZ0ZXIgUXVpY2sgTWlncmF0aW9uLCB0aGUgbmV0d29yayBpcyBub3QgaW1tZWRpYXRlbHkgb3BlcmF0aW9uYWwgaW4gdGhlCisgKiBjdXJyZW50IGNvbnRleHQgd2hlbiByZWNlaXZpbmcgUk5ESVNfU1RBVFVTX01FRElBX0NPTk5FQ1QgZXZlbnQuIFNvLCBhZGQKKyAqIGFub3RoZXIgbmV0aWZfbm90aWZ5X3BlZXJzKCkgaW50byBhIHNjaGVkdWxlZCB3b3JrLCBvdGhlcndpc2UgR0FSUCBwYWNrZXQKKyAqIHdpbGwgbm90IGJlIHNlbnQgYWZ0ZXIgcXVpY2sgbWlncmF0aW9uLCBhbmQgY2F1c2UgbmV0d29yayBkaXNjb25uZWN0aW9uLgorICovCitzdGF0aWMgdm9pZCBuZXR2c2Nfc2VuZF9nYXJwKHN0cnVjdCB3b3JrX3N0cnVjdCAqdykKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZV9jb250ZXh0ICpuZGV2X2N0eDsKKwlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0OworCisJbXNsZWVwKDIwKTsKKwluZGV2X2N0eCA9IGNvbnRhaW5lcl9vZih3LCBzdHJ1Y3QgbmV0X2RldmljZV9jb250ZXh0LCB3b3JrKTsKKwluZXQgPSBkZXZfZ2V0X2RydmRhdGEoJm5kZXZfY3R4LT5kZXZpY2VfY3R4LT5kZXZpY2UpOworCW5ldGlmX25vdGlmeV9wZWVycyhuZXQpOworfQorCisKIHN0YXRpYyBpbnQgbmV0dnNjX3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldmljZSkKIHsKIAlzdHJ1Y3QgaHZfZHJpdmVyICpkcnYgPQpAQCAtMzUzLDYgKzM3Niw3IEBACiAJbmV0X2RldmljZV9jdHgtPmRldmljZV9jdHggPSBkZXZpY2Vfb2JqOwogCW5ldF9kZXZpY2VfY3R4LT5hdmFpbCA9IHJpbmdfc2l6ZTsKIAlkZXZfc2V0X2RydmRhdGEoZGV2aWNlLCBuZXQpOworCUlOSVRfV09SSygmbmV0X2RldmljZV9jdHgtPndvcmssIG5ldHZzY19zZW5kX2dhcnApOwogCiAJLyogTm90aWZ5IHRoZSBuZXR2c2MgZHJpdmVyIG9mIHRoZSBuZXcgZGV2aWNlICovCiAJcmV0ID0gbmV0X2Rydl9vYmotPmJhc2UuZGV2X2FkZChkZXZpY2Vfb2JqLCAmZGV2aWNlX2luZm8pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L3JuZGlzX2ZpbHRlci5jIGIvZHJpdmVycy9zdGFnaW5nL2h2L3JuZGlzX2ZpbHRlci5jCmluZGV4IGU3MTg5Y2QuLjA0ODM3NmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9odi9ybmRpc19maWx0ZXIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvcm5kaXNfZmlsdGVyLmMKQEAgLTU4NSw3ICs1ODUsNyBAQAogCQlyZXQgPSAtMTsKIAkJRFBSSU5UX0VSUihORVRWU0MsICJ0aW1lb3V0IGJlZm9yZSB3ZSBnb3QgYSBzZXQgcmVzcG9uc2UuLi4iKTsKIAkJLyoKLQkJICogV2UgY2FudCBkZWFsbG9jYXRlIHRoZSByZXF1ZXN0IHNpbmNlIHdlIG1heSBzdGlsbCByZWNlaXZlIGEKKwkJICogV2UgY2FuJ3QgZGVhbGxvY2F0ZSB0aGUgcmVxdWVzdCBzaW5jZSB3ZSBtYXkgc3RpbGwgcmVjZWl2ZSBhCiAJCSAqIHNlbmQgY29tcGxldGlvbiBmb3IgaXQuCiAJCSAqLwogCQlnb3RvIEV4aXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvdG9vbHMvaHZfa3ZwX2RhZW1vbi5jIGIvZHJpdmVycy9zdGFnaW5nL2h2L3Rvb2xzL2h2X2t2cF9kYWVtb24uYwppbmRleCBmNWEyZGQ2Li4zM2YwZjFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvdG9vbHMvaHZfa3ZwX2RhZW1vbi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi90b29scy9odl9rdnBfZGFlbW9uLmMKQEAgLTEwMiwyMiArMTAyLDIyIEBACiBzdGF0aWMgY2hhciBrdnBfcmVjdl9idWZmZXJbNDA5Nl07CiBzdGF0aWMgc3RydWN0IHNvY2thZGRyX25sIGFkZHI7CiAKLXN0YXRpYyBjaGFyIG9zX25hbWVbMTAwXTsKLXN0YXRpYyBjaGFyIG9zX21ham9yWzUwXTsKLXN0YXRpYyBjaGFyIG9zX21pbm9yWzUwXTsKLXN0YXRpYyBjaGFyIHByb2Nlc3Nvcl9hcmNoWzUwXTsKLXN0YXRpYyBjaGFyIG9zX2J1aWxkWzEwMF07CitzdGF0aWMgY2hhciAqb3NfbmFtZSA9ICIiOworc3RhdGljIGNoYXIgKm9zX21ham9yID0gIiI7CitzdGF0aWMgY2hhciAqb3NfbWlub3IgPSAiIjsKK3N0YXRpYyBjaGFyICpwcm9jZXNzb3JfYXJjaDsKK3N0YXRpYyBjaGFyICpvc19idWlsZDsKIHN0YXRpYyBjaGFyICpsaWNfdmVyc2lvbjsKK3N0YXRpYyBzdHJ1Y3QgdXRzbmFtZSB1dHNfYnVmOwogCiB2b2lkIGt2cF9nZXRfb3NfaW5mbyh2b2lkKQogewogCUZJTEUJKmZpbGU7Ci0JY2hhcgkqZW9sOwotCXN0cnVjdCB1dHNuYW1lIGJ1ZjsKKwljaGFyCSpwLCBidWZbNTEyXTsKIAotCXVuYW1lKCZidWYpOwotCXN0cmNweShvc19idWlsZCwgYnVmLnJlbGVhc2UpOwotCXN0cmNweShwcm9jZXNzb3JfYXJjaCwgYnVmLm1hY2hpbmUpOworCXVuYW1lKCZ1dHNfYnVmKTsKKwlvc19idWlsZCA9IHV0c19idWYucmVsZWFzZTsKKwlwcm9jZXNzb3JfYXJjaD0gdXRzX2J1Zi5tYWNoaW5lOwogCiAJZmlsZSA9IGZvcGVuKCIvZXRjL1N1U0UtcmVsZWFzZSIsICJyIik7CiAJaWYgKGZpbGUgIT0gTlVMTCkKQEAgLTEzMiwyMSArMTMyLDQ2IEBACiAJLyoKIAkgKiBXZSBkb24ndCBoYXZlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBvcy4KIAkgKi8KLQlzdHJjcHkob3NfbmFtZSwgIkxpbnV4Iik7Ci0Jc3RyY3B5KG9zX21ham9yLCAiMCIpOwotCXN0cmNweShvc19taW5vciwgIjAiKTsKKwlvc19uYW1lID0gdXRzX2J1Zi5zeXNuYW1lOwogCXJldHVybjsKIAoga3ZwX29zaW5mb19mb3VuZDoKLQlmZ2V0cyhvc19uYW1lLCA5OSwgZmlsZSk7Ci0JZW9sID0gaW5kZXgob3NfbmFtZSwgJ1xuJyk7Ci0JKmVvbCA9ICdcMCc7Ci0JZmdldHMob3NfbWFqb3IsIDQ5LCBmaWxlKTsKLQllb2wgPSBpbmRleChvc19tYWpvciwgJ1xuJyk7Ci0JKmVvbCA9ICdcMCc7Ci0JZmdldHMob3NfbWlub3IsIDQ5LCBmaWxlKTsKLQllb2wgPSBpbmRleChvc19taW5vciwgJ1xuJyk7Ci0JKmVvbCA9ICdcMCc7CisJLyogdXAgdG8gdGhyZWUgbGluZXMgKi8KKwlwID0gZmdldHMoYnVmLCBzaXplb2YoYnVmKSwgZmlsZSk7CisJaWYgKHApIHsKKwkJcCA9IHN0cmNocihidWYsICdcbicpOworCQlpZiAocCkKKwkJCSpwID0gJ1wwJzsKKwkJcCA9IHN0cmR1cChidWYpOworCQlpZiAoIXApCisJCQlnb3RvIGRvbmU7CisJCW9zX25hbWUgPSBwOworCisJCS8qIHNlY29uZCBsaW5lICovCisJCXAgPSBmZ2V0cyhidWYsIHNpemVvZihidWYpLCBmaWxlKTsKKwkJaWYgKHApIHsKKwkJCXAgPSBzdHJjaHIoYnVmLCAnXG4nKTsKKwkJCWlmIChwKQorCQkJCSpwID0gJ1wwJzsKKwkJCXAgPSBzdHJkdXAoYnVmKTsKKwkJCWlmICghcCkKKwkJCQlnb3RvIGRvbmU7CisJCQlvc19tYWpvciA9IHA7CisKKwkJCS8qIHRoaXJkIGxpbmUgKi8KKwkJCXAgPSBmZ2V0cyhidWYsIHNpemVvZihidWYpLCBmaWxlKTsKKwkJCWlmIChwKSAgeworCQkJCXAgPSBzdHJjaHIoYnVmLCAnXG4nKTsKKwkJCQlpZiAocCkKKwkJCQkJKnAgPSAnXDAnOworCQkJCXAgPSBzdHJkdXAoYnVmKTsKKwkJCQlpZiAocCkKKwkJCQkJb3NfbWlub3IgPSBwOworCQkJfQorCQl9CisJfQorCitkb25lOgogCWZjbG9zZShmaWxlKTsKIAlyZXR1cm47CiB9CkBAIC0yMDIsNyArMjI3LDcgQEAKIAogCQkJLyoKIAkJCSAqIFdlIG9ubHkgc3VwcG9ydCBBRl9JTkVUIGFuZCBBRl9JTkVUNgotCQkJICogYW5kIHRoZSBsaXN0IG9mIGFkZHJlc3NlcyBpcyBzZXBlcmF0ZWQgYnkgYSAiOyIuCisJCQkgKiBhbmQgdGhlIGxpc3Qgb2YgYWRkcmVzc2VzIGlzIHNlcGFyYXRlZCBieSBhICI7Ii4KIAkJCSAqLwogCQkJCXN0cnVjdCBzb2NrYWRkcl9pbjYgKmFkZHIgPQogCQkJCShzdHJ1Y3Qgc29ja2FkZHJfaW42ICopIGN1cnAtPmlmYV9hZGRyOwpAQCAtMjkzLDcgKzMxOCw3IEBACiAJcmV0dXJuIHNlbmRtc2coZmQsICZtZXNzYWdlLCAwKTsKIH0KIAotbWFpbih2b2lkKQoraW50IG1haW4odm9pZCkKIHsKIAlpbnQgZmQsIGxlbiwgc29ja19vcHQ7CiAJaW50IGVycm9yOwpAQCAtMzAxLDkgKzMyNiwxMCBAQAogCXN0cnVjdCBwb2xsZmQgcGZkOwogCXN0cnVjdCBubG1zZ2hkciAqaW5jb21pbmdfbXNnOwogCXN0cnVjdCBjbl9tc2cJKmluY29taW5nX2NuX21zZzsKKwlzdHJ1Y3QgaHZfa3VfbXNnICpodl9tc2c7CisJY2hhcgkqcDsKIAljaGFyCSprZXlfdmFsdWU7CiAJY2hhcgkqa2V5X25hbWU7Ci0JaW50CSBrZXlfaW5kZXg7CiAKIAlkYWVtb24oMSwgMCk7CiAJb3BlbmxvZygiS1ZQIiwgMCwgTE9HX1VTRVIpOwpAQCAtMzczLDkgKzM5OSwxMCBAQAogCQkJICogRHJpdmVyIGlzIHJlZ2lzdGVyaW5nIHdpdGggdXM7IHN0YXNoIGF3YXkgdGhlIHZlcnNpb24KIAkJCSAqIGluZm9ybWF0aW9uLgogCQkJICovCi0JCQlsaWNfdmVyc2lvbiA9IG1hbGxvYyhzdHJsZW4oaW5jb21pbmdfY25fbXNnLT5kYXRhKSArIDEpOworCQkJcCA9IChjaGFyICopaW5jb21pbmdfY25fbXNnLT5kYXRhOworCQkJbGljX3ZlcnNpb24gPSBtYWxsb2Moc3RybGVuKHApICsgMSk7CiAJCQlpZiAobGljX3ZlcnNpb24pIHsKLQkJCQlzdHJjcHkobGljX3ZlcnNpb24sIGluY29taW5nX2NuX21zZy0+ZGF0YSk7CisJCQkJc3RyY3B5KGxpY192ZXJzaW9uLCBwKTsKIAkJCQlzeXNsb2coTE9HX0lORk8sICJLVlAgTElDIFZlcnNpb246ICVzIiwKIAkJCQkJbGljX3ZlcnNpb24pOwogCQkJfSBlbHNlIHsKQEAgLTM4OSwxNCArNDE2LDExIEBACiAJCQljb250aW51ZTsKIAkJfQogCi0JCWtleV9pbmRleCA9Ci0JCSgoc3RydWN0IGh2X2t1X21zZyAqKWluY29taW5nX2NuX21zZy0+ZGF0YSktPmt2cF9pbmRleDsKLQkJa2V5X25hbWUgPQotCQkoKHN0cnVjdCBodl9rdV9tc2cgKilpbmNvbWluZ19jbl9tc2ctPmRhdGEpLT5rdnBfa2V5OwotCQlrZXlfdmFsdWUgPQotCQkoKHN0cnVjdCBodl9rdV9tc2cgKilpbmNvbWluZ19jbl9tc2ctPmRhdGEpLT5rdnBfdmFsdWU7CisJCWh2X21zZyA9IChzdHJ1Y3QgaHZfa3VfbXNnICopaW5jb21pbmdfY25fbXNnLT5kYXRhOworCQlrZXlfbmFtZSA9IChjaGFyICopaHZfbXNnLT5rdnBfa2V5OworCQlrZXlfdmFsdWUgPSAoY2hhciAqKWh2X21zZy0+a3ZwX3ZhbHVlOwogCi0JCXN3aXRjaCAoa2V5X2luZGV4KSB7CisJCXN3aXRjaCAoaHZfbXNnLT5rdnBfaW5kZXgpIHsKIAkJY2FzZSBGdWxseVF1YWxpZmllZERvbWFpbk5hbWU6CiAJCQlrdnBfZ2V0X2RvbWFpbl9uYW1lKGtleV92YWx1ZSwKIAkJCQkJSFZfS1ZQX0VYQ0hBTkdFX01BWF9WQUxVRV9TSVpFKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9odi92bWJ1c19kcnYuYyBiL2RyaXZlcnMvc3RhZ2luZy9odi92bWJ1c19kcnYuYwppbmRleCBiNDczZjQ2Li43OTA4OWY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvdm1idXNfZHJ2LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2h2L3ZtYnVzX2Rydi5jCkBAIC0yNTQsNyArMjU0LDcgQEAKIAlldmVudCA9ICh1bmlvbiBodl9zeW5pY19ldmVudF9mbGFncyAqKXBhZ2VfYWRkciArIFZNQlVTX01FU1NBR0VfU0lOVDsKIAogCS8qIFNpbmNlIHdlIGFyZSBhIGNoaWxkLCB3ZSBvbmx5IG5lZWQgdG8gY2hlY2sgYml0IDAgKi8KLQlpZiAodGVzdF9hbmRfY2xlYXJfYml0KDAsICh1bnNpZ25lZCBsb25nICopICZldmVudC0+ZmxhZ3MzMlswXSkpIHsKKwlpZiAoc3luY190ZXN0X2FuZF9jbGVhcl9iaXQoMCwgKHVuc2lnbmVkIGxvbmcgKikgJmV2ZW50LT5mbGFnczMyWzBdKSkgewogCQlEUFJJTlRfREJHKFZNQlVTLCAicmVjZWl2ZWQgZXZlbnQgJWQiLCBldmVudC0+ZmxhZ3MzMlswXSk7CiAJCXJldCB8PSAweDI7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L3ZtYnVzX3ByaXZhdGUuaCBiL2RyaXZlcnMvc3RhZ2luZy9odi92bWJ1c19wcml2YXRlLmgKaW5kZXggY2EwNTBhNC4uNmYwZDhkZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L3ZtYnVzX3ByaXZhdGUuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvdm1idXNfcHJpdmF0ZS5oCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiY2hhbm5lbF9tZ210LmgiCiAjaW5jbHVkZSAicmluZ19idWZmZXIuaCIKICNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CisjaW5jbHVkZSA8YXNtL3N5bmNfYml0b3BzLmg+CiAKIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vRG9jdW1lbnRhdGlvbi9paW9fdXRpbHMuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vRG9jdW1lbnRhdGlvbi9paW9fdXRpbHMuaAppbmRleCA4MDk1NzI3Li5mZDc4ZTRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL0RvY3VtZW50YXRpb24vaWlvX3V0aWxzLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9Eb2N1bWVudGF0aW9uL2lpb191dGlscy5oCkBAIC01NTYsNyArNTU2LDcgQEAKIAkJaWYgKHN0cmNtcCh0ZW1wLCB2YWwpICE9IDApIHsKIAkJCXByaW50ZigiUG9zc2libGUgZmFpbHVyZSBpbiBzdHJpbmcgd3JpdGUgb2YgJXMgIgogCQkJCSJTaG91bGQgYmUgJXMgIgotCQkJCSJ3cml0ZW4gdG8gJXNcJXNcbiIsCisJCQkJIndyaXR0ZW4gdG8gJXNcJXNcbiIsCiAJCQkJdGVtcCwKIAkJCQl2YWwsCiAJCQkJYmFzZWRpciwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjAxLmggYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIwMS5oCmluZGV4IGM5YmYyMmMuLjIzZmU1NGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjAxLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyMDEuaApAQCAtNzAsNyArNzAsNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjIwMV9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIwMy5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyMDMuaAppbmRleCBiMzkzMjNlLi5iODg2ODgxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIwMy5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjAzLmgKQEAgLTY1LDcgKzY1LDcgQEAKICAqIEBpbmRpb19kZXY6CQlpbmR1c3RyaWFsIEkvTyBkZXZpY2Ugc3RydWN0dXJlCiAgKiBAdHJpZzoJCWRhdGEgcmVhZHkgdHJpZ2dlciByZWdpc3RlcmVkIHdpdGggaWlvCiAgKiBAdHg6CQkJdHJhbnNtaXQgYnVmZmVyCi0gKiBAcng6CQkJcmVjaWV2ZSBidWZmZXIKKyAqIEByeDoJCQlyZWNlaXZlIGJ1ZmZlcgogICogQGJ1Zl9sb2NrOgkJbXV0ZXggdG8gcHJvdGVjdCB0eCBhbmQgcngKICAqKi8KIHN0cnVjdCBhZGlzMTYyMDNfc3RhdGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyMDQuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjA0LmgKaW5kZXggZTllZDdjYi4uZTYxODQ0NjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjA0LmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyMDQuaApAQCAtNzMsNyArNzMsNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjIwNF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIwOS5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyMDkuaAppbmRleCA0ZTk3NTk2Li44YjBkYTEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIwOS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjA5LmgKQEAgLTEwOSw3ICsxMDksNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjIwOV9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIyMC5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyMjAuaAppbmRleCA3MDEzMzE0Li40ZDU3NThjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjIyMC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjIwLmgKQEAgLTEzMiw3ICsxMzIsNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjIyMF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjI0MC5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9hZGlzMTYyNDAuaAppbmRleCA1MWE4MDdkLi43NmE0NTc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2FkaXMxNjI0MC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvYWRpczE2MjQwLmgKQEAgLTEzMiw3ICsxMzIsNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjI0MF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2xpczNsMDJkcS5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9saXMzbDAyZHEuaAppbmRleCA1NzliM2EyLi4xMTQwMjE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2xpczNsMDJkcS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvbGlzM2wwMmRxLmgKQEAgLTU3LDcgKzU3LDcgQEAKIC8qIFJlYm9vdCBtZW1vcnkgY29udGVudCAqLwogI2RlZmluZSBMSVMzTDAyRFFfUkVHX0NUUkxfMl9SRUJPT1RfTUVNT1JZCTB4MTAKIAotLyogSW50ZXJ1cHQgRW5hYmxlIC0gYXBwbGllcyBkYXRhIHJlYWR5IHRvIHRoZSBSRFkgcGFkICovCisvKiBJbnRlcnJ1cHQgRW5hYmxlIC0gYXBwbGllcyBkYXRhIHJlYWR5IHRvIHRoZSBSRFkgcGFkICovCiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfQ1RSTF8yX0VOQUJMRV9JTlRFUlJVUFQJMHgwOAogCiAvKiBFbmFibGUgRGF0YSBSZWFkeSBHZW5lcmF0aW9uIC0gcmVsYXRpb25zaGlwIHdpdGggcHJldmlvdXMgdW5jbGVhciBpbiBkb2NzICovCkBAIC03MCwzNCArNzAsMzQgQEAKICAqIC0gb3B0aW9uIGZvciAxNiBiaXQgbGVmdCBqdXN0aWZpZWQgKi8KICNkZWZpbmUgTElTM0wwMkRRX1JFR19DVFJMXzJfREFUQV9BTElHTk1FTlRfMTZfQklUX0xFRlRfSlVTVElGSUVECTB4MDEKIAotLyogSW50ZXJ1cHQgcmVsYXRlZCBzdHVmZiAqLworLyogSW50ZXJydXB0IHJlbGF0ZWQgc3R1ZmYgKi8KICNkZWZpbmUgTElTM0wwMkRRX1JFR19XQUtFX1VQX0NGR19BRERSCQkJMHgyMwogCiAvKiBTd2l0Y2ggZnJvbSBvciBjb21iaW5hdGlvbiBmbyBjb25kaXRpb25zIHRvIGFuZCAqLwogI2RlZmluZSBMSVMzTDAyRFFfUkVHX1dBS0VfVVBfQ0ZHX0JPT0xFQU5fQU5ECQkweDgwCiAKLS8qIExhdGNoIGludGVydXB0IHJlcXVlc3QsCisvKiBMYXRjaCBpbnRlcnJ1cHQgcmVxdWVzdCwKICAqIGlmIG9uIGFjayBtdXN0IGJlIGdpdmVuIGJ5IHJlYWRpbmcgdGhlIGFjayByZWdpc3RlciAqLwogI2RlZmluZSBMSVMzTDAyRFFfUkVHX1dBS0VfVVBfQ0ZHX0xBVENIX1NSQwkJMHg0MAogCi0vKiBaIEludGVydXB0IG9uIEhpZ2ggKGFib3ZlIHRocmVzaG9sZCkqLworLyogWiBJbnRlcnJ1cHQgb24gSGlnaCAoYWJvdmUgdGhyZXNob2xkKSovCiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfV0FLRV9VUF9DRkdfSU5URVJSVVBUX1pfSElHSAkweDIwCi0vKiBaIEludGVydXB0IG9uIExvdyAqLworLyogWiBJbnRlcnJ1cHQgb24gTG93ICovCiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfV0FLRV9VUF9DRkdfSU5URVJSVVBUX1pfTE9XCTB4MTAKLS8qIFkgSW50ZXJ1cHQgb24gSGlnaCAqLworLyogWSBJbnRlcnJ1cHQgb24gSGlnaCAqLwogI2RlZmluZSBMSVMzTDAyRFFfUkVHX1dBS0VfVVBfQ0ZHX0lOVEVSUlVQVF9ZX0hJR0gJMHgwOAotLyogWSBJbnRlcnVwdCBvbiBMb3cgKi8KKy8qIFkgSW50ZXJydXB0IG9uIExvdyAqLwogI2RlZmluZSBMSVMzTDAyRFFfUkVHX1dBS0VfVVBfQ0ZHX0lOVEVSUlVQVF9ZX0xPVwkweDA0Ci0vKiBYIEludGVydXB0IG9uIEhpZ2ggKi8KKy8qIFggSW50ZXJydXB0IG9uIEhpZ2ggKi8KICNkZWZpbmUgTElTM0wwMkRRX1JFR19XQUtFX1VQX0NGR19JTlRFUlJVUFRfWF9ISUdICTB4MDIKLS8qIFggSW50ZXJ1cHQgb24gTG93ICovCisvKiBYIEludGVycnVwdCBvbiBMb3cgKi8KICNkZWZpbmUgTElTM0wwMkRRX1JFR19XQUtFX1VQX0NGR19JTlRFUlJVUFRfWF9MT1cgMHgwMQogCi0vKiBSZWdpc3RlciB0aGF0IGdpdmVzIGRlc2NyaXB0aW9uIG9mIHdoYXQgY2F1c2VkIGludGVydXB0CisvKiBSZWdpc3RlciB0aGF0IGdpdmVzIGRlc2NyaXB0aW9uIG9mIHdoYXQgY2F1c2VkIGludGVycnVwdAogICogLSBsYXRjaGVkIGlmIHNldCBpbiBDRkdfQUREUkVTICovCiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfV0FLRV9VUF9TUkNfQUREUgkJCTB4MjQKIC8qIHRvcCBiaXQgaWdub3JlZCAqLwotLyogSW50ZXJ1cHQgQWN0aXZlICovCisvKiBJbnRlcnJ1cHQgQWN0aXZlICovCiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfV0FLRV9VUF9TUkNfSU5URVJSVVBUX0FDVElWQVRFRAkweDQwCiAvKiBJbnRlcnVwdHMgdGhhdCBoYXZlIGJlZW4gdHJpZ2dlcmVkICovCiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfV0FLRV9VUF9TUkNfSU5URVJSVVBUX1pfSElHSAkweDIwCkBAIC0xMjMsNyArMTIzLDcgQEAKICNkZWZpbmUgTElTM0wwMkRRX1JFR19TVEFUVVNfWF9ORVdfREFUQQkJCTB4MDEKIAogLyogVGhlIGFjY2VsZXJvbWV0ZXIgcmVhZGluZ3MgLSBsb3cgYW5kIGhpZ2ggYnl0ZXMuCi1Gb3JtIG9mIGhpZ2ggYnl0ZSBkZXBlbmRhbnQgb24ganVzdGlmaWNhdGlvbiBzZXQgaW4gY3RybCByZWcgKi8KK0Zvcm0gb2YgaGlnaCBieXRlIGRlcGVuZGVudCBvbiBqdXN0aWZpY2F0aW9uIHNldCBpbiBjdHJsIHJlZyAqLwogI2RlZmluZSBMSVMzTDAyRFFfUkVHX09VVF9YX0xfQUREUgkJCTB4MjgKICNkZWZpbmUgTElTM0wwMkRRX1JFR19PVVRfWF9IX0FERFIJCQkweDI5CiAjZGVmaW5lIExJUzNMMDJEUV9SRUdfT1VUX1lfTF9BRERSCQkJMHgyQQpAQCAtMTU1LDcgKzE1NSw3IEBACiAgKiBAaW50ZXI6CQl1c2VkIHRvIGNoZWNrIGlmIG5ldyBpbnRlcnJ1cHQgaGFzIGJlZW4gdHJpZ2dlcmVkCiAgKiBAdHJpZzoJCWRhdGEgcmVhZHkgdHJpZ2dlciByZWdpc3RlcmVkIHdpdGggaWlvCiAgKiBAdHg6CQkJdHJhbnNtaXQgYnVmZmVyCi0gKiBAcng6CQkJcmVjaWV2ZSBidWZmZXIKKyAqIEByeDoJCQlyZWNlaXZlIGJ1ZmZlcgogICogQGJ1Zl9sb2NrOgkJbXV0ZXggdG8gcHJvdGVjdCB0eCBhbmQgcngKICAqKi8KIHN0cnVjdCBsaXMzbDAyZHFfc3RhdGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9saXMzbDAyZHFfY29yZS5jIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9saXMzbDAyZHFfY29yZS5jCmluZGV4IGM0YjRhYjcuLjMwNjdmOTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvbGlzM2wwMmRxX2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2xpczNsMDJkcV9jb3JlLmMKQEAgLTc3LDcgKzc3LDcgQEAKIC8qKgogICogbGlzM2wwMmRxX3NwaV93cml0ZV9yZWdfOCgpIC0gd3JpdGUgc2luZ2xlIGJ5dGUgdG8gYSByZWdpc3RlcgogICogQGRldjogZGV2aWNlIGFzc29jaWF0ZWQgd2l0aCBjaGlsZCBvZiBhY3R1YWwgZGV2aWNlIChpaW9fZGV2IG9yIGlpb190cmlnKQotICogQHJlZ19hZGRyZXNzOiB0aGUgYWRkcmVzcyBvZiB0aGUgcmVnaXN0ZXIgdG8gYmUgd3JpdGVuCisgKiBAcmVnX2FkZHJlc3M6IHRoZSBhZGRyZXNzIG9mIHRoZSByZWdpc3RlciB0byBiZSB3cml0dGVuCiAgKiBAdmFsOiB0aGUgdmFsdWUgdG8gd3JpdGUKICAqKi8KIGludCBsaXMzbDAyZHFfc3BpX3dyaXRlX3JlZ184KHN0cnVjdCBkZXZpY2UgKmRldiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvbGlzM2wwMmRxX3JpbmcuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvbGlzM2wwMmRxX3JpbmcuYwppbmRleCAyYzQ2MWEzLi41MjlhM2NjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2xpczNsMDJkcV9yaW5nLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9saXMzbDAyZHFfcmluZy5jCkBAIC0yMTcsNyArMjE3LDcgQEAKIC8qKgogICogbGlzM2wwMmRxX3JlYWRfYWxsKCkgUmVhZHMgYWxsIGNoYW5uZWxzIGN1cnJlbnRseSBzZWxlY3RlZAogICogQHN0OgkJZGV2aWNlIHNwZWNpZmljIHN0YXRlCi0gKiBAcnhfYXJyYXk6CShkbWEgY2FwYWJsZSkgcmVjaWV2ZSBhcnJheSwgbXVzdCBiZSBhdCBsZWFzdAorICogQHJ4X2FycmF5OgkoZG1hIGNhcGFibGUpIHJlY2VpdmUgYXJyYXksIG11c3QgYmUgYXQgbGVhc3QKICAqCQk0Km51bWJlciBvZiBjaGFubmVscwogICoqLwogc3RhdGljIGludCBsaXMzbDAyZHFfcmVhZF9hbGwoc3RydWN0IGxpczNsMDJkcV9zdGF0ZSAqc3QsIHU4ICpyeF9hcnJheSkKQEAgLTQwOSw3ICs0MDksNyBAQAogICoKICAqIEFzIHRoZSB0cmlnZ2VyIG1heSBvY2N1ciBvbiBhbnkgZGF0YSBlbGVtZW50IGJlaW5nIHVwZGF0ZWQgaXQgaXMKICAqIHJlYWxseSByYXRoZXIgbGlrZWx5IHRvIG9jY3VyIGR1cmluZyB0aGUgcmVhZCBmcm9tIHRoZSBwcmV2aW91cwotICogdHJpZ2dlciBldmVudC4gIFRoZSBvbmx5IHdheSB0byBkaXNjb3ZlciBpZiB0aGlzIGhhcyBvY2N1cmVkIG9uCisgKiB0cmlnZ2VyIGV2ZW50LiAgVGhlIG9ubHkgd2F5IHRvIGRpc2NvdmVyIGlmIHRoaXMgaGFzIG9jY3VycmVkIG9uCiAgKiBib2FyZHMgbm90IHN1cHBvcnRpbmcgbGV2ZWwgaW50ZXJydXB0cyBpcyB0byB0YWtlIGEgbG9vayBhdCB0aGUgbGluZS4KICAqIElmIGl0IGlzIGluZGljYXRpbmcgYW5vdGhlciBpbnRlcnJ1cHQgYW5kIHdlIGRvbid0IHNlZW0gdG8gaGF2ZSBhCiAgKiBoYW5kbGVyIGxvb2tpbmcgYXQgaXQsIHRoZW4gd2UgbmVlZCB0byBub3RpZnkgdGhlIGNvcmUgdGhhdCB3ZSBuZWVkCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL3NjYTMwMDAuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvc2NhMzAwMC5oCmluZGV4IDIzODkyODQuLmRiNzEwMzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvc2NhMzAwMC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvc2NhMzAwMC5oCkBAIC0xODUsNyArMTg1LDcgQEAKIH07CiAKIC8qKgotICogc3RydWN0IHNjYTMwMDBfY2hpcF9pbmZvIC0gbW9kZWwgZGVwZW5kYW50IHBhcmFtZXRlcnMKKyAqIHN0cnVjdCBzY2EzMDAwX2NoaXBfaW5mbyAtIG1vZGVsIGRlcGVuZGVudCBwYXJhbWV0ZXJzCiAgKiBAbmFtZTogCQkJbW9kZWwgaWRlbnRpZmljYXRpb24KICAqIEBzY2FsZToJCQlzdHJpbmcgY29udGFpbmluZyBmbG9hdGluZyBwb2ludCBzY2FsZSBmYWN0b3IKICAqIEB0ZW1wX291dHB1dDoJCXNvbWUgZGV2aWNlcyBoYXZlIHRlbXBlcmF0dXJlIHNlbnNvcnMuCkBAIC0yMTMsNyArMjEzLDcgQEAKICAqIHNjYTMwMDBfcmVhZF9kYXRhKCkgcmVhZCBhIHNlcmllcyBvZiB2YWx1ZXMgZnJvbSB0aGUgZGV2aWNlCiAgKiBAZGV2OgkJZGV2aWNlCiAgKiBAcmVnX2FkZHJlc3NfaGlnaDoJc3RhcnQgYWRkcmVzcyAoZGVjcmVtZW50ZWQgcmVhZCkKLSAqIEByeDoJCQlwb2ludGVyIHdoZXJlIHJlY2lldmVkIGRhdGEgaXMgcGxhY2VkLiBDYWxsZWUKKyAqIEByeDoJCQlwb2ludGVyIHdoZXJlIHJlY2VpdmVkIGRhdGEgaXMgcGxhY2VkLiBDYWxsZWUKICAqCQkJcmVzcG9uc2libGUgZm9yIGZyZWVpbmcgdGhpcy4KICAqIEBsZW46CQludW1iZXIgb2YgYnl0ZXMgdG8gcmVhZAogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvc2NhMzAwMF9yaW5nLmMgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL3NjYTMwMDBfcmluZy5jCmluZGV4IGM4NzJmZGQuLmE3MzBhNzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWNjZWwvc2NhMzAwMF9yaW5nLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9zY2EzMDAwX3JpbmcuYwpAQCAtNDMsNyArNDMsNyBAQAogICoJCQlsZWFkaW5nIGJ5dGUgdXNlZCBpbiBidXMgY29tbXMuCiAgKgogICogQ3VycmVudGx5IGRvZXMgbm90IHByb3ZpZGUgdGltZXN0YW1wcy4gIEFzIHRoZSBoYXJkd2FyZSBkb2Vzbid0IGFkZCB0aGVtIHRoZXkKLSAqIGNhbiBvbmx5IGJlIGluZmVycmVkIGFwcm94aW1hdGVseSBmcm9tIHJpbmcgYnVmZmVyIGV2ZW50cyBzdWNoIGFzIDUwJSBmdWxsCisgKiBjYW4gb25seSBiZSBpbmZlcnJlZCBhcHByb3hpbWF0ZWx5IGZyb20gcmluZyBidWZmZXIgZXZlbnRzIHN1Y2ggYXMgNTAlIGZ1bGwKICAqIGFuZCBrbm93bGVkZ2Ugb2Ygd2hlbiBidWZmZXIgd2FzIGxhc3QgZW1wdGllZC4gIFRoaXMgaXMgbGVmdCB0byB1c2Vyc3BhY2UuCiAgKiovCiBzdGF0aWMgaW50IHNjYTMwMDBfcmlwX2h3X3JiKHN0cnVjdCBpaW9fcmluZ19idWZmZXIgKnIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDcyOThfcmluZy5jIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3Mjk4X3JpbmcuYwppbmRleCAxOWQxYWNlLi45MDY4ZDdmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDcyOThfcmluZy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzI5OF9yaW5nLmMKQEAgLTE1Nyw3ICsxNTcsNyBAQAogLyoqCiAgKiBhZDcyOThfcG9sbF9mdW5jX3RoKCkgdGggb2YgdHJpZ2dlciBsYXVuY2hlZCBwb2xsaW5nIHRvIHJpbmcgYnVmZmVyCiAgKgotICogQXMgc2FtcGxpbmcgb25seSBvY2N1cnMgb24gc3BpIGNvbW1zIG9jY3VyaW5nLCBsZWF2ZSB0aW1lc3RhbXBpbmcgdW50aWwKKyAqIEFzIHNhbXBsaW5nIG9ubHkgb2NjdXJzIG9uIHNwaSBjb21tcyBvY2N1cnJpbmcsIGxlYXZlIHRpbWVzdGFtcGluZyB1bnRpbAogICogdGhlbi4gIFNvbWUgdHJpZ2dlcnMgd2lsbCBnZW5lcmF0ZSB0aGVpciBvd24gdGltZSBzdGFtcC4gIEN1cnJlbnRseQogICogdGhlcmUgaXMgbm8gd2F5IG9mIG5vdGlmeWluZyB0aGVtIHdoZW4gbm8gb25lIGNhcmVzLgogICoqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NDc2X3JpbmcuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzQ3Nl9yaW5nLmMKaW5kZXggMWQ2NTRjOC4uOTJkOTM3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NDc2X3JpbmcuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc0NzZfcmluZy5jCkBAIC0xMTIsNyArMTEyLDcgQEAKIC8qKgogICogYWQ3NDc2X3BvbGxfZnVuY190aCgpIHRoIG9mIHRyaWdnZXIgbGF1bmNoZWQgcG9sbGluZyB0byByaW5nIGJ1ZmZlcgogICoKLSAqIEFzIHNhbXBsaW5nIG9ubHkgb2NjdXJzIG9uIGkyYyBjb21tcyBvY2N1cmluZywgbGVhdmUgdGltZXN0YW1waW5nIHVudGlsCisgKiBBcyBzYW1wbGluZyBvbmx5IG9jY3VycyBvbiBpMmMgY29tbXMgb2NjdXJyaW5nLCBsZWF2ZSB0aW1lc3RhbXBpbmcgdW50aWwKICAqIHRoZW4uICBTb21lIHRyaWdnZXJzIHdpbGwgZ2VuZXJhdGUgdGhlaXIgb3duIHRpbWUgc3RhbXAuICBDdXJyZW50bHkKICAqIHRoZXJlIGlzIG5vIHdheSBvZiBub3RpZnlpbmcgdGhlbSB3aGVuIG5vIG9uZSBjYXJlcy4KICAqKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzg4N19yaW5nLmMgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc4ODdfcmluZy5jCmluZGV4IDJkN2ZlNjUuLmRhNzdmMjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzg4N19yaW5nLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3ODg3X3JpbmcuYwpAQCAtMTY1LDcgKzE2NSw3IEBACiAvKioKICAqIGFkNzg4N19wb2xsX2Z1bmNfdGgoKSB0aCBvZiB0cmlnZ2VyIGxhdW5jaGVkIHBvbGxpbmcgdG8gcmluZyBidWZmZXIKICAqCi0gKiBBcyBzYW1wbGluZyBvbmx5IG9jY3VycyBvbiBzcGkgY29tbXMgb2NjdXJpbmcsIGxlYXZlIHRpbWVzdGFtcGluZyB1bnRpbAorICogQXMgc2FtcGxpbmcgb25seSBvY2N1cnMgb24gc3BpIGNvbW1zIG9jY3VycmluZywgbGVhdmUgdGltZXN0YW1waW5nIHVudGlsCiAgKiB0aGVuLiAgU29tZSB0cmlnZ2VycyB3aWxsIGdlbmVyYXRlIHRoZWlyIG93biB0aW1lIHN0YW1wLiAgQ3VycmVudGx5CiAgKiB0aGVyZSBpcyBubyB3YXkgb2Ygbm90aWZ5aW5nIHRoZW0gd2hlbiBubyBvbmUgY2FyZXMuCiAgKiovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc5OXhfY29yZS5jIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3OTl4X2NvcmUuYwppbmRleCBlNTA4NDFiLi5mMDRlNjQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc5OXhfY29yZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzk5eF9jb3JlLmMKQEAgLTE4NCw3ICsxODQsNyBAQAogCiAJbXV0ZXhfbG9jaygmZGV2X2luZm8tPm1sb2NrKTsKIAltYXNrID0gMSA8PCB0aGlzX2F0dHItPmFkZHJlc3M7Ci0JLyogSWYgcmluZyBidWZmZXIgY2FwdHVyZSBpcyBvY2N1cmluZywgcXVlcnkgdGhlIGJ1ZmZlciAqLworCS8qIElmIHJpbmcgYnVmZmVyIGNhcHR1cmUgaXMgb2NjdXJyaW5nLCBxdWVyeSB0aGUgYnVmZmVyICovCiAJaWYgKGlpb19yaW5nX2VuYWJsZWQoZGV2X2luZm8pKSB7CiAJCWRhdGEgPSByZXQgPSBhZDc5OXhfc2luZ2xlX2NoYW5uZWxfZnJvbV9yaW5nKHN0LCBtYXNrKTsKIAkJaWYgKHJldCA8IDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc5OXhfcmluZy5jIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3OTl4X3JpbmcuYwppbmRleCA1NmFiYzM5Li4wODc1YTdlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc5OXhfcmluZy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzk5eF9yaW5nLmMKQEAgLTEwMSw3ICsxMDEsNyBAQAogLyoqCiAgKiBhZDc5OXhfcG9sbF9mdW5jX3RoKCkgdGggb2YgdHJpZ2dlciBsYXVuY2hlZCBwb2xsaW5nIHRvIHJpbmcgYnVmZmVyCiAgKgotICogQXMgc2FtcGxpbmcgb25seSBvY2N1cnMgb24gaTJjIGNvbW1zIG9jY3VyaW5nLCBsZWF2ZSB0aW1lc3RhbXBpbmcgdW50aWwKKyAqIEFzIHNhbXBsaW5nIG9ubHkgb2NjdXJzIG9uIGkyYyBjb21tcyBvY2N1cnJpbmcsIGxlYXZlIHRpbWVzdGFtcGluZyB1bnRpbAogICogdGhlbi4gIFNvbWUgdHJpZ2dlcnMgd2lsbCBnZW5lcmF0ZSB0aGVpciBvd24gdGltZSBzdGFtcC4gIEN1cnJlbnRseQogICogdGhlcmUgaXMgbm8gd2F5IG9mIG5vdGlmeWluZyB0aGVtIHdoZW4gbm8gb25lIGNhcmVzLgogICoqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvbWF4MTM2M19jb3JlLmMgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9tYXgxMzYzX2NvcmUuYwppbmRleCBkZGUwOTdhLi5kZTgzYzNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9tYXgxMzYzX2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9tYXgxMzYzX2NvcmUuYwpAQCAtMjU1LDcgKzI1NSw3IEBACiAJCWdvdG8gZXJyb3JfcmV0OwogCX0KIAotCS8qIElmIHJpbmcgYnVmZmVyIGNhcHR1cmUgaXMgb2NjdXJpbmcsIHF1ZXJ5IHRoZSBidWZmZXIgKi8KKwkvKiBJZiByaW5nIGJ1ZmZlciBjYXB0dXJlIGlzIG9jY3VycmluZywgcXVlcnkgdGhlIGJ1ZmZlciAqLwogCWlmIChpaW9fcmluZ19lbmFibGVkKGRldl9pbmZvKSkgewogCQltYXNrID0gbWF4MTM2M19tb2RlX3RhYmxlW3RoaXNfYXR0ci0+YWRkcmVzc10ubW9kZW1hc2s7CiAJCWRhdGEgPSBtYXgxMzYzX3NpbmdsZV9jaGFubmVsX2Zyb21fcmluZyhtYXNrLCBzdCk7CkBAIC0xNDI1LDcgKzE0MjUsNyBAQAogfQogCiAvKgotICogVG8ga2VlcCB0aGlzIG1hbmFnYWJsZSB3ZSBhbHdheXMgdXNlIG9uZSBvZiAzIHNjYW4gbW9kZXMuCisgKiBUbyBrZWVwIHRoaXMgbWFuYWdlYWJsZSB3ZSBhbHdheXMgdXNlIG9uZSBvZiAzIHNjYW4gbW9kZXMuCiAgKiBTY2FuIDAuLi4zLCAwLTEsMi0zIGFuZCAxLTAsMy0yCiAgKi8KIHN0YXRpYyBpbmxpbmUgaW50IF9fbWF4MTM2M19jaGVja19ldmVudF9tYXNrKGludCB0aGlzbWFzaywgaW50IGNoZWNrbWFzaykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL21heDEzNjNfcmluZy5jIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvbWF4MTM2M19yaW5nLmMKaW5kZXggNTUzMmYzZS4uZDM2ZmNjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvbWF4MTM2M19yaW5nLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvbWF4MTM2M19yaW5nLmMKQEAgLTEwOCw3ICsxMDgsNyBAQAogLyoqCiAgKiBtYXgxMzYzX3BvbGxfZnVuY190aCgpIC0gdGggb2YgdHJpZ2dlciBsYXVuY2hlZCBwb2xsaW5nIHRvIHJpbmcgYnVmZmVyCiAgKgotICogQXMgc2FtcGxpbmcgb25seSBvY2N1cnMgb24gaTJjIGNvbW1zIG9jY3VyaW5nLCBsZWF2ZSB0aW1lc3RhbXBpbmcgdW50aWwKKyAqIEFzIHNhbXBsaW5nIG9ubHkgb2NjdXJzIG9uIGkyYyBjb21tcyBvY2N1cnJpbmcsIGxlYXZlIHRpbWVzdGFtcGluZyB1bnRpbAogICogdGhlbi4gIFNvbWUgdHJpZ2dlcnMgd2lsbCBnZW5lcmF0ZSB0aGVpciBvd24gdGltZSBzdGFtcC4gIEN1cnJlbnRseQogICogdGhlcmUgaXMgbm8gd2F5IG9mIG5vdGlmeWluZyB0aGVtIHdoZW4gbm8gb25lIGNhcmVzLgogICoqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9jaHJkZXYuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vY2hyZGV2LmgKaW5kZXggOThkMWEyYy4uNGZjYjk5YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9jaHJkZXYuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2NocmRldi5oCkBAIC0zMyw3ICszMyw3IEBACiAvKioKICAqIHN0cnVjdCBpaW9fZXZlbnRfZGF0YSAtIFRoZSBhY3R1YWwgZXZlbnQgYmVpbmcgcHVzaGVkIHRvIHVzZXJzcGFjZQogICogQGlkOgkJZXZlbnQgaWRlbnRpZmllcgotICogQHRpbWVzdGFtcDoJYmVzdCBlc3RpbWF0ZSBvZiB0aW1lIG9mIGV2ZW50IG9jY3VyYW5jZSAob2Z0ZW4gZnJvbQorICogQHRpbWVzdGFtcDoJYmVzdCBlc3RpbWF0ZSBvZiB0aW1lIG9mIGV2ZW50IG9jY3VycmVuY2UgKG9mdGVuIGZyb20KICAqCQl0aGUgaW50ZXJydXB0IGhhbmRsZXIpCiAgKi8KIHN0cnVjdCBpaW9fZXZlbnRfZGF0YSB7CkBAIC00Miw3ICs0Miw3IEBACiB9OwogCiAvKioKLSAqIHN0cnVjdCBpaW9fZGV0ZWN0ZWRfZXZlbnRfbGlzdCAtIGxpc3QgZWxlbWVudCBmb3IgZXZlbnRzIHRoYXQgaGF2ZSBvY2N1cmVkCisgKiBzdHJ1Y3QgaWlvX2RldGVjdGVkX2V2ZW50X2xpc3QgLSBsaXN0IGVsZW1lbnQgZm9yIGV2ZW50cyB0aGF0IGhhdmUgb2NjdXJyZWQKICAqIEBsaXN0OgkJbGlua2VkIGxpc3QgaGVhZGVyCiAgKiBAZXY6CQkJdGhlIGV2ZW50IGl0c2VsZgogICogQHNoYXJlZF9wb2ludGVyOgl1c2VkIHdoZW4gdGhlIGV2ZW50IGlzIHNoYXJlZCAtIGkuZS4gY2FuIGJlIGVzY2FsbGF0ZWQKQEAgLTk4LDcgKzk4LDcgQEAKICAqIEBsaXN0OgkJbGlzdCBoZWFkZXIKICAqIEByZWZjb3VudDoJCWFzIHRoZSBoYW5kbGVyIG1heSBiZSBzaGFyZWQgYmV0d2VlbiBtdWx0aXBsZSBkZXZpY2UKICAqCQkJc2lkZSBldmVudHMsIHJlZmVyZW5jZSBjb3VudGluZyBlbnN1cmVzIGNsZWFuIHJlbW92YWwKLSAqIEBleGlzdF9sb2NrOgkJcHJldmVudHMgcmFjZSBjb25kaXRpb25zIHJlbGF0ZWQgdG8gcmVmY291bnQgdXNlYWdlLgorICogQGV4aXN0X2xvY2s6CQlwcmV2ZW50cyByYWNlIGNvbmRpdGlvbnMgcmVsYXRlZCB0byByZWZjb3VudCB1c2FnZS4KICAqIEBoYW5kbGVyOgkJZXZlbnQgaGFuZGxlciBmdW5jdGlvbiAtIGNhbGxlZCBvbiBldmVudCBpZiB0aGlzCiAgKgkJCWV2ZW50X2hhbmRsZXIgaXMgZW5hYmxlZC4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2d5cm8vYWRpczE2MDYwX2NvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYwNjBfY29yZS5jCmluZGV4IDcwMGViMzkuLmFlNTNlNzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYwNjBfY29yZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYwNjBfY29yZS5jCkBAIC0zMCw3ICszMCw3IEBACiAgKiBAdXNfdzoJCWFjdHVhbCBzcGlfZGV2aWNlIHRvIHdyaXRlIGNvbmZpZwogICogQHVzX3I6CQlhY3R1YWwgc3BpX2RldmljZSB0byByZWFkIGJhY2sgZGF0YQogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKLSAqIEBidWY6CQl0cmFuc21pdCBvciByZWNpZXZlIGJ1ZmZlcgorICogQGJ1ZjoJCXRyYW5zbWl0IG9yIHJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjA2MF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2d5cm8vYWRpczE2MDgwX2NvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYwODBfY29yZS5jCmluZGV4IGZiNDMzNmMuLmVmOWUzMDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYwODBfY29yZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYwODBfY29yZS5jCkBAIC0zNSw3ICszNSw3IEBACiAgKiBzdHJ1Y3QgYWRpczE2MDgwX3N0YXRlIC0gZGV2aWNlIGluc3RhbmNlIHNwZWNpZmljIGRhdGEKICAqIEB1czoJCQlhY3R1YWwgc3BpX2RldmljZSB0byB3cml0ZSBkYXRhCiAgKiBAaW5kaW9fZGV2OgkJaW5kdXN0cmlhbCBJL08gZGV2aWNlIHN0cnVjdHVyZQotICogQGJ1ZjoJCXRyYW5zbWl0IG9yIHJlY2lldmUgYnVmZmVyCisgKiBAYnVmOgkJdHJhbnNtaXQgb3IgcmVjZWl2ZSBidWZmZXIKICAqIEBidWZfbG9jazoJCW11dGV4IHRvIHByb3RlY3QgdHggYW5kIHJ4CiAgKiovCiBzdHJ1Y3QgYWRpczE2MDgwX3N0YXRlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYyNjAuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYyNjAuaAppbmRleCBjMWZkNDM2NC4uMTM2OTUwMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9neXJvL2FkaXMxNjI2MC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZ3lyby9hZGlzMTYyNjAuaApAQCAtOTEsNyArOTEsNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICogQG5lZ2F0ZToJCW5lZ2F0ZSB0aGUgc2NhbGUgcGFyYW1ldGVyCiAgKiovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2lpby5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9paW8uaAppbmRleCAyNDhiZGQyLi43MTI3ZjI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2lpby5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaWlvLmgKQEAgLTkyLDcgKzkyLDcgQEAKICAqCQkJY2hhbmdlcwogICogQGF2YWlsYWJsZV9zY2FuX21hc2tzOiBbRFJJVkVSXSBvcHRpb25hbCBhcnJheSBvZiBhbGxvd2VkIGJpdG1hc2tzCiAgKiBAdHJpZzoJCVtJTlRFUk5dIGN1cnJlbnQgZGV2aWNlIHRyaWdnZXIgKHJpbmcgYnVmZmVyIG1vZGVzKQotICogQHBvbGxmdW5jOgkJW0RSSVZFUl0gZnVuY3Rpb24gcnVuIG9uIHRyaWdnZXIgYmVpbmcgcmVjaWV2ZWQKKyAqIEBwb2xsZnVuYzoJCVtEUklWRVJdIGZ1bmN0aW9uIHJ1biBvbiB0cmlnZ2VyIGJlaW5nIHJlY2VpdmVkCiAgKiovCiBzdHJ1Y3QgaWlvX2RldiB7CiAJaW50CQkJCWlkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbXUvYWRpczE2MzAwLmggYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTYzMDAuaAppbmRleCAxZjI1ZDY4Li5jMDk1NzU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTYzMDAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTYzMDAuaApAQCAtOTksNyArOTksNyBAQAogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0cmlnOgkJZGF0YSByZWFkeSB0cmlnZ2VyIHJlZ2lzdGVyZWQgd2l0aCBpaW8KICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkaXMxNjMwMF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTYzNTAuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaW11L2FkaXMxNjM1MC5oCmluZGV4IGIwMDAwMWUuLmIxYWQ0ODYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vaW11L2FkaXMxNjM1MC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaW11L2FkaXMxNjM1MC5oCkBAIC0xMDUsNyArMTA1LDcgQEAKICAqIEBpbmRpb19kZXY6CQlpbmR1c3RyaWFsIEkvTyBkZXZpY2Ugc3RydWN0dXJlCiAgKiBAdHJpZzoJCWRhdGEgcmVhZHkgdHJpZ2dlciByZWdpc3RlcmVkIHdpdGggaWlvCiAgKiBAdHg6CQkJdHJhbnNtaXQgYnVmZmVyCi0gKiBAcng6CQkJcmVjaWV2ZSBidWZmZXIKKyAqIEByeDoJCQlyZWNlaXZlIGJ1ZmZlcgogICogQGJ1Zl9sb2NrOgkJbXV0ZXggdG8gcHJvdGVjdCB0eCBhbmQgcngKICAqKi8KIHN0cnVjdCBhZGlzMTYzNTBfc3RhdGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbXUvYWRpczE2NDAwLmggYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTY0MDAuaAppbmRleCA2ZmYzM2UxLi5lMzI4YmNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTY0MDAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTY0MDAuaApAQCAtMTcsNyArMTcsOCBAQAogI2lmbmRlZiBTUElfQURJUzE2NDAwX0hfCiAjZGVmaW5lIFNQSV9BRElTMTY0MDBfSF8KIAotI2RlZmluZSBBRElTMTY0MDBfU1RBUlRVUF9ERUxBWQkyMjAgLyogbXMgKi8KKyNkZWZpbmUgQURJUzE2NDAwX1NUQVJUVVBfREVMQVkJMjkwIC8qIG1zICovCisjZGVmaW5lIEFESVMxNjQwMF9NVEVTVF9ERUxBWSA5MCAvKiBtcyAqLwogCiAjZGVmaW5lIEFESVMxNjQwMF9SRUFEX1JFRyhhKSAgICBhCiAjZGVmaW5lIEFESVMxNjQwMF9XUklURV9SRUcoYSkgKChhKSB8IDB4ODApCkBAIC0xMzEsNyArMTMyLDcgQEAKICAqIEBpbmRpb19kZXY6CQlpbmR1c3RyaWFsIEkvTyBkZXZpY2Ugc3RydWN0dXJlCiAgKiBAdHJpZzoJCWRhdGEgcmVhZHkgdHJpZ2dlciByZWdpc3RlcmVkIHdpdGggaWlvCiAgKiBAdHg6CQkJdHJhbnNtaXQgYnVmZmVyCi0gKiBAcng6CQkJcmVjaWV2ZSBidWZmZXIKKyAqIEByeDoJCQlyZWNlaXZlIGJ1ZmZlcgogICogQGJ1Zl9sb2NrOgkJbXV0ZXggdG8gcHJvdGVjdCB0eCBhbmQgcngKICAqKi8KIHN0cnVjdCBhZGlzMTY0MDBfc3RhdGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbXUvYWRpczE2NDAwX2NvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaW11L2FkaXMxNjQwMF9jb3JlLmMKaW5kZXggY2ZiMTA4YS4uNTQwYmRlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbXUvYWRpczE2NDAwX2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTY0MDBfY29yZS5jCkBAIC02LDYgKzYsNyBAQAogICoKICAqIENvcHlyaWdodCAoYykgMjAwOSBNYW51ZWwgU3RhaGwgPG1hbnVlbC5zdGFobEBpaXMuZnJhdW5ob2Zlci5kZT4KICAqIENvcHlyaWdodCAoYykgMjAwNyBKb25hdGhhbiBDYW1lcm9uIDxqaWMyM0BjYW0uYWMudWs+CisgKiBDb3B5cmlnaHQgKGMpIDIwMTEgQW5hbG9nIERldmljZXMgSW5jLgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwpAQCAtOTMsNyArOTQsNiBAQAogCQkJLnR4X2J1ZiA9IHN0LT50eCArIDIsCiAJCQkuYml0c19wZXJfd29yZCA9IDgsCiAJCQkubGVuID0gMiwKLQkJCS5jc19jaGFuZ2UgPSAxLAogCQl9LAogCX07CiAKQEAgLTEzNyw3ICsxMzcsNiBAQAogCQkJLnJ4X2J1ZiA9IHN0LT5yeCwKIAkJCS5iaXRzX3Blcl93b3JkID0gOCwKIAkJCS5sZW4gPSAyLAotCQkJLmNzX2NoYW5nZSA9IDEsCiAJCX0sCiAJfTsKIApAQCAtMzc1LDcgKzM3NCw3IEBACiAJCWRldl9lcnIoZGV2LCAicHJvYmxlbSBzdGFydGluZyBzZWxmIHRlc3QiKTsKIAkJZ290byBlcnJfcmV0OwogCX0KLQorCW1zbGVlcChBRElTMTY0MDBfTVRFU1RfREVMQVkpOwogCWFkaXMxNjQwMF9jaGVja19zdGF0dXMoZGV2KTsKIAogZXJyX3JldDoKQEAgLTQ3MSwxMCArNDcwLDExIEBACiAJaWYgKHJldCkKIAkJZ290byBlcnJfcmV0OwogCi0JaWYgKHByb2RfaWQgIT0gQURJUzE2NDAwX1BST0RVQ1RfSURfREVGQVVMVCkKKwlpZiAoKHByb2RfaWQgJiAweEYwMDApICE9IEFESVMxNjQwMF9QUk9EVUNUX0lEX0RFRkFVTFQpCiAJCWRldl93YXJuKGRldiwgInVua25vd24gcHJvZHVjdCBpZCIpOwogCi0JcHJpbnRrKEtFUk5fSU5GTyBEUklWRVJfTkFNRSAiOiBwcm9kX2lkIDB4JTA0eCBhdCBDUyVkIChpcnEgJWQpXG4iLAorCisJZGV2X2luZm8oZGV2LCAiOiBwcm9kX2lkIDB4JTA0eCBhdCBDUyVkIChpcnEgJWQpXG4iLAogCQkJcHJvZF9pZCwgc3QtPnVzLT5jaGlwX3NlbGVjdCwgc3QtPnVzLT5pcnEpOwogCiAJLyogdXNlIGhpZ2ggc3BpIHNwZWVkIGlmIHBvc3NpYmxlICovCkBAIC00OTcsMTIgKzQ5NywxMiBAQAogCQkJX3JlZykKIAogc3RhdGljIEFESVMxNjQwMF9ERVZfQVRUUl9DQUxJQkJJQVMoR1lST19YLCBBRElTMTY0MDBfWEdZUk9fT0ZGKTsKLXN0YXRpYyBBRElTMTY0MDBfREVWX0FUVFJfQ0FMSUJCSUFTKEdZUk9fWSwgQURJUzE2NDAwX1hHWVJPX09GRik7Ci1zdGF0aWMgQURJUzE2NDAwX0RFVl9BVFRSX0NBTElCQklBUyhHWVJPX1osIEFESVMxNjQwMF9YR1lST19PRkYpOworc3RhdGljIEFESVMxNjQwMF9ERVZfQVRUUl9DQUxJQkJJQVMoR1lST19ZLCBBRElTMTY0MDBfWUdZUk9fT0ZGKTsKK3N0YXRpYyBBRElTMTY0MDBfREVWX0FUVFJfQ0FMSUJCSUFTKEdZUk9fWiwgQURJUzE2NDAwX1pHWVJPX09GRik7CiAKIHN0YXRpYyBBRElTMTY0MDBfREVWX0FUVFJfQ0FMSUJCSUFTKEFDQ0VMX1gsIEFESVMxNjQwMF9YQUNDTF9PRkYpOwotc3RhdGljIEFESVMxNjQwMF9ERVZfQVRUUl9DQUxJQkJJQVMoQUNDRUxfWSwgQURJUzE2NDAwX1hBQ0NMX09GRik7Ci1zdGF0aWMgQURJUzE2NDAwX0RFVl9BVFRSX0NBTElCQklBUyhBQ0NFTF9aLCBBRElTMTY0MDBfWEFDQ0xfT0ZGKTsKK3N0YXRpYyBBRElTMTY0MDBfREVWX0FUVFJfQ0FMSUJCSUFTKEFDQ0VMX1ksIEFESVMxNjQwMF9ZQUNDTF9PRkYpOworc3RhdGljIEFESVMxNjQwMF9ERVZfQVRUUl9DQUxJQkJJQVMoQUNDRUxfWiwgQURJUzE2NDAwX1pBQ0NMX09GRik7CiAKIAogc3RhdGljIElJT19ERVZfQVRUUl9JTl9OQU1FRF9SQVcoMCwgc3VwcGx5LCBhZGlzMTY0MDBfcmVhZF8xNGJpdF9zaWduZWQsCkBAIC02NDcsNyArNjQ3LDcgQEAKIAogCXJldCA9IGlpb19yaW5nX2J1ZmZlcl9yZWdpc3RlcihzdC0+aW5kaW9fZGV2LT5yaW5nLCAwKTsKIAlpZiAocmV0KSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiZmFpbGVkIHRvIGluaXRpYWxpemUgdGhlIHJpbmdcbiIpOworCQlkZXZfZXJyKCZzcGktPmRldiwgImZhaWxlZCB0byBpbml0aWFsaXplIHRoZSByaW5nXG4iKTsKIAkJZ290byBlcnJvcl91bnJlZ19yaW5nX2Z1bmNzOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbXUvYWRpczE2NDAwX3JpbmcuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaW11L2FkaXMxNjQwMF9yaW5nLmMKaW5kZXggMzMyOTNmYi4uZGEyOGNiNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbXUvYWRpczE2NDAwX3JpbmcuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2ltdS9hZGlzMTY0MDBfcmluZy5jCkBAIC0xMjIsMTIgKzEyMiwxMCBAQAogCQkJLnR4X2J1ZiA9IHN0LT50eCwKIAkJCS5iaXRzX3Blcl93b3JkID0gOCwKIAkJCS5sZW4gPSAyLAotCQkJLmNzX2NoYW5nZSA9IDAsCiAJCX0sIHsKIAkJCS5yeF9idWYgPSByeCwKIAkJCS5iaXRzX3Blcl93b3JkID0gOCwKIAkJCS5sZW4gPSAyNCwKLQkJCS5jc19jaGFuZ2UgPSAxLAogCQl9LAogCX07CiAKQEAgLTE2Miw5ICsxNjAsMTAgQEAKIAkJCSAgICAgICB3b3JrX3RyaWdnZXJfdG9fcmluZyk7CiAJc3RydWN0IGlpb19yaW5nX2J1ZmZlciAqcmluZyA9IHN0LT5pbmRpb19kZXYtPnJpbmc7CiAKLQlpbnQgaSA9IDA7CisJaW50IGkgPSAwLCBqOwogCXMxNiAqZGF0YTsKIAlzaXplX3QgZGF0YXNpemUgPSByaW5nLT5hY2Nlc3MuZ2V0X2J5dGVzX3Blcl9kYXR1bShyaW5nKTsKKwl1bnNpZ25lZCBsb25nIG1hc2sgPSByaW5nLT5zY2FuX21hc2s7CiAKIAlkYXRhID0ga21hbGxvYyhkYXRhc2l6ZSAsIEdGUF9LRVJORUwpOwogCWlmIChkYXRhID09IE5VTEwpIHsKQEAgLTE3NCw5ICsxNzMsMTIgQEAKIAogCWlmIChyaW5nLT5zY2FuX2NvdW50KQogCQlpZiAoYWRpczE2NDAwX3NwaV9yZWFkX2J1cnN0KCZzdC0+aW5kaW9fZGV2LT5kZXYsIHN0LT5yeCkgPj0gMCkKLQkJCWZvciAoOyBpIDwgcmluZy0+c2Nhbl9jb3VudDsgaSsrKQorCQkJZm9yICg7IGkgPCByaW5nLT5zY2FuX2NvdW50OyBpKyspIHsKKwkJCQlqID0gX19mZnMobWFzayk7CisJCQkJbWFzayAmPSB+KDEgPDwgaik7CiAJCQkJZGF0YVtpXQk9IGJlMTZfdG9fY3B1cCgKLQkJCQkJKF9fYmUxNiAqKSYoc3QtPnJ4W2kqMl0pKTsKKwkJCQkJKF9fYmUxNiAqKSYoc3QtPnJ4W2oqMl0pKTsKKwkJCX0KIAogCS8qIEd1YXJhbnRlZWQgdG8gYmUgYWxpZ25lZCB3aXRoIDggYnl0ZSBib3VuZGFyeSAqLwogCWlmIChyaW5nLT5zY2FuX3RpbWVzdGFtcCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vaW5kdXN0cmlhbGlvLWNvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaW5kdXN0cmlhbGlvLWNvcmUuYwppbmRleCBmM2JmMTExLi4xNzk1ZWUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2luZHVzdHJpYWxpby1jb3JlLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9pbmR1c3RyaWFsaW8tY29yZS5jCkBAIC0yNTgsNyArMjU4LDcgQEAKIAkJCQkJCQkgICAtPmRldF9ldmVudHMubGlzdCkpOwogCQlpZiAocmV0KQogCQkJZ290byBlcnJvcl9yZXQ7Ci0JCS8qIFNpbmdsZSBhY2Nlc3MgZGV2aWNlIHNvIG5vb25lIGVsc2UgY2FuIGdldCB0aGUgZGF0YSAqLworCQkvKiBTaW5nbGUgYWNjZXNzIGRldmljZSBzbyBubyBvbmUgZWxzZSBjYW4gZ2V0IHRoZSBkYXRhICovCiAJCW11dGV4X2xvY2soJmV2X2ludC0+ZXZlbnRfbGlzdF9sb2NrKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1My5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3NzUzLmgKaW5kZXggNzBkYWJhZS4uM2I5YzdmNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3NzUzLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3NzUzLmgKQEAgLTYyLDcgKzYyLDcgQEAKICAqIEB1czoJCQlhY3R1YWwgc3BpX2RldmljZQogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkZTc3NTNfc3RhdGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3NzU0LmggYi9kcml2ZXJzL3N0YWdpbmcvaWlvL21ldGVyL2FkZTc3NTQuaAppbmRleCA4ZmFhOWIzLi4wYWEwNTIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL21ldGVyL2FkZTc3NTQuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL21ldGVyL2FkZTc3NTQuaApAQCAtODAsNyArODAsNyBAQAogICogQHVzOgkJCWFjdHVhbCBzcGlfZGV2aWNlCiAgKiBAaW5kaW9fZGV2OgkJaW5kdXN0cmlhbCBJL08gZGV2aWNlIHN0cnVjdHVyZQogICogQHR4OgkJCXRyYW5zbWl0IGJ1ZmZlcgotICogQHJ4OgkJCXJlY2lldmUgYnVmZmVyCisgKiBAcng6CQkJcmVjZWl2ZSBidWZmZXIKICAqIEBidWZfbG9jazoJCW11dGV4IHRvIHByb3RlY3QgdHggYW5kIHJ4CiAgKiovCiBzdHJ1Y3QgYWRlNzc1NF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL21ldGVyL2FkZTc3NTguaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1OC5oCmluZGV4IGRmNWJiN2IuLmM2ZmQ5NGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1OC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1OC5oCkBAIC05OCw3ICs5OCw3IEBACiAgKiBAaW5kaW9fZGV2OgkJaW5kdXN0cmlhbCBJL08gZGV2aWNlIHN0cnVjdHVyZQogICogQHRyaWc6CQlkYXRhIHJlYWR5IHRyaWdnZXIgcmVnaXN0ZXJlZCB3aXRoIGlpbwogICogQHR4OgkJCXRyYW5zbWl0IGJ1ZmZlcgotICogQHJ4OgkJCXJlY2lldmUgYnVmZmVyCisgKiBAcng6CQkJcmVjZWl2ZSBidWZmZXIKICAqIEBidWZfbG9jazoJCW11dGV4IHRvIHByb3RlY3QgdHggYW5kIHJ4CiAgKiovCiBzdHJ1Y3QgYWRlNzc1OF9zdGF0ZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL21ldGVyL2FkZTc3NTkuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1OS5oCmluZGV4IGU5ZDFjNDMuLmNjNzZjMmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1OS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzc1OS5oCkBAIC00Myw3ICs0Myw3IEBACiAgKiBAdXM6CQkJYWN0dWFsIHNwaV9kZXZpY2UKICAqIEBpbmRpb19kZXY6CQlpbmR1c3RyaWFsIEkvTyBkZXZpY2Ugc3RydWN0dXJlCiAgKiBAdHg6CQkJdHJhbnNtaXQgYnVmZmVyCi0gKiBAcng6CQkJcmVjaWV2ZSBidWZmZXIKKyAqIEByeDoJCQlyZWNlaXZlIGJ1ZmZlcgogICogQGJ1Zl9sb2NrOgkJbXV0ZXggdG8gcHJvdGVjdCB0eCBhbmQgcngKICAqKi8KIHN0cnVjdCBhZGU3NzU5X3N0YXRlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vbWV0ZXIvYWRlNzg1NC5oIGIvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3ODU0LmgKaW5kZXggNGFkODRhMy4uNzlhMjExMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3ODU0LmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2lpby9tZXRlci9hZGU3ODU0LmgKQEAgLTE0OSw3ICsxNDksNyBAQAogICogQHNwaToJCQlhY3R1YWwgc3BpX2RldmljZQogICogQGluZGlvX2RldjoJCWluZHVzdHJpYWwgSS9PIGRldmljZSBzdHJ1Y3R1cmUKICAqIEB0eDoJCQl0cmFuc21pdCBidWZmZXIKLSAqIEByeDoJCQlyZWNpZXZlIGJ1ZmZlcgorICogQHJ4OgkJCXJlY2VpdmUgYnVmZmVyCiAgKiBAYnVmX2xvY2s6CQltdXRleCB0byBwcm90ZWN0IHR4IGFuZCByeAogICoqLwogc3RydWN0IGFkZTc4NTRfc3RhdGUgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9yaW5nX2dlbmVyaWMuaCBiL2RyaXZlcnMvc3RhZ2luZy9paW8vcmluZ19nZW5lcmljLmgKaW5kZXggZjIxYWMwOS4uMzI5NDhlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9yaW5nX2dlbmVyaWMuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL3JpbmdfZ2VuZXJpYy5oCkBAIC0zMCw3ICszMCw3IEBACiAgKiBAZXZlbnRfY29kZToJCWV2ZW50IGluZGVudGlmaWNhdGlvbiBjb2RlCiAgKiBAdGltZXN0YW1wOgkJdGltZSBvZiBldmVudAogICoKLSAqIFR5cGljYWwgdXNlY2FzZSBpcyB0byBlc2NhbGF0ZSBhIDUwJSByaW5nIGZ1bGwgdG8gNzUlIGZ1bGwgaWYgbm9vbmUgaGFzIHlldAorICogVHlwaWNhbCB1c2VjYXNlIGlzIHRvIGVzY2FsYXRlIGEgNTAlIHJpbmcgZnVsbCB0byA3NSUgZnVsbCBpZiBubyBvbmUgaGFzIHlldAogICogcmVhZCB0aGUgZmlyc3QgZXZlbnQuIENsZWFybHkgdGhlIDUwJSBmdWxsIGlzIG5vIGxvbmdlciBvZiBpbnRlcmVzdCBpbgogICogdHlwaWNhbCB1c2UgY2FzZS4KICAqKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvVE9ETyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvVE9ETwppbmRleCBhMjRlNWVkLi5jNzMzZDcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L1RPRE8KKysrIGIvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9UT0RPCkBAIC0xLDcgKzEsNyBAQAogVE9ETwogLS0tLQogCi1HZXQgdGhlIG1lbXJhciBkcml2ZXIgY2xlYW5lZCB1cCBhbmQgdXBzdHJlYW0gKGRlcGVuZGFuY3kgYmxvY2tpbmcgU1NUKQorR2V0IHRoZSBtZW1yYXIgZHJpdmVyIGNsZWFuZWQgdXAgYW5kIHVwc3RyZWFtIChkZXBlbmRlbmN5IGJsb2NraW5nIFNTVCkKIFJlcGxhY2UgbG9uZy9zaG9ydCBwcmVzcyB3aXRoIHR3byB2aXJ0dWFsIGJ1dHRvbnMKIFJldmlldyB0aGUgcHJpbnRrcyBhbmQga2lsbCBvZmYgYW55IGxlZnQgb3ZlciBTVF9FUlI6IG1lc3NhZ2VzCiBSZXZpZXcgdGhlIG1pc2MgZGV2aWNlIGlvY3RscyBmb3IgMzIvNjRiaXQgc2FmZXR5IGFuZCBzYW5pdHkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0LmMgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdC5jCmluZGV4IGNlNGE5ZjcuLjgxYzI0ZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3QuYwpAQCAtMjYzLDcgKzI2Myw3IEBACiAJLyogSW5pdCB0aGUgZGV2aWNlICovCiAJcmV0ID0gcGNpX2VuYWJsZV9kZXZpY2UocGNpKTsKIAlpZiAocmV0KSB7Ci0JCXByX2VycigiZGV2aWNlIGNhbnQgYmUgZW5hYmxlZFxuIik7CisJCXByX2VycigiZGV2aWNlIGNhbid0IGJlIGVuYWJsZWRcbiIpOwogCQlnb3RvIGRvX2ZyZWVfbWVtOwogCX0KIAlzc3RfZHJ2X2N0eC0+cGNpID0gcGNpX2Rldl9nZXQocGNpKTsKQEAgLTQ1Myw3ICs0NTMsNyBAQAogCXBjaV9yZXN0b3JlX3N0YXRlKHBjaSk7CiAJcmV0ID0gcGNpX2VuYWJsZV9kZXZpY2UocGNpKTsKIAlpZiAocmV0KQotCQlwcl9lcnIoImRldmljZSBjYW50IGJlIGVuYWJsZWRcbiIpOworCQlwcl9lcnIoImRldmljZSBjYW4ndCBiZSBlbmFibGVkXG4iKTsKIAogCW11dGV4X2xvY2soJnNzdF9kcnZfY3R4LT5zc3RfbG9jayk7CiAJc3N0X2Rydl9jdHgtPnNzdF9zdGF0ZSA9IFNTVF9VTl9JTklUOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3RfYXBwX2ludGVyZmFjZS5jIGIvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3RfYXBwX2ludGVyZmFjZS5jCmluZGV4IGEzNjc5OTEuLjFkMDYyMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2FwcF9pbnRlcmZhY2UuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9hcHBfaW50ZXJmYWNlLmMKQEAgLTIzNiw3ICsyMzYsNyBAQAogCWlmICghc3N0X2Rydl9jdHgtPm1tYXBfbWVtKQogCQlyZXR1cm4gLUVJTzsKIAotCS8qIHJvdW5kIGl0IHVwIHRvIHRoZSBwYWdlIGJvbmRhcnkgICovCisJLyogcm91bmQgaXQgdXAgdG8gdGhlIHBhZ2UgYm91bmRhcnkgICovCiAJLyptZW1fYXJlYSA9ICh2b2lkICopKCgoKHVuc2lnbmVkIGxvbmcpc3N0X2Rydl9jdHgtPm1tYXBfbWVtKQogCQkJCSsgUEFHRV9TSVpFIC0gMSkgJiBQQUdFX01BU0spOyovCiAJbWVtX2FyZWEgPSAodm9pZCAqKSBQQUdFX0FMSUdOKCh1bnNpZ25lZCBpbnQpIHNzdF9kcnZfY3R4LT5tbWFwX21lbSk7CkBAIC04NzEsNyArODcxLDcgQEAKIH0KIAogLyoqCi0gKiBpbnRlbF9zc3RfaW9jdGxfZHNwIC0gcmVjaWV2ZXMgdGhlIGRldmljZSBpb2N0bCdzCisgKiBpbnRlbF9zc3RfaW9jdGxfZHNwIC0gcmVjZWl2ZXMgdGhlIGRldmljZSBpb2N0bCdzCiAgKgogICogQGNtZDpJb2N0bCBjbWQKICAqIEBhcmc6ZGF0YQpAQCAtMTA2Nyw3ICsxMDY3LDcgQEAKIAkJCXJldHZhbCA9IC1FRkFVTFQ7CiAJCQlicmVhazsKIAkJfQotCQlwcl9kZWJ1ZygiU0VUX1ZPTFVNRSByZWNpZXZlZCBmb3IgJWQhXG4iLAorCQlwcl9kZWJ1ZygiU0VUX1ZPTFVNRSByZWNlaXZlZCBmb3IgJWQhXG4iLAogCQkJCXNldF92b2wuc3RyZWFtX2lkKTsKIAkJaWYgKG1pbm9yID09IFNUUkVBTV9NT0RVTEUgJiYgc2V0X3ZvbC5zdHJlYW1faWQgPT0gMCkgewogCQkJcHJfZGVidWcoImludmFsaWQgb3BlcmF0aW9uIVxuIik7CkBAIC0xMDg1LDcgKzEwODUsNyBAQAogCQkJcmV0dmFsID0gLUVGQVVMVDsKIAkJCWJyZWFrOwogCQl9Ci0JCXByX2RlYnVnKCJJT0NUTF9HRVRfVk9MVU1FIHJlY2lldmVkIGZvciBzdHJlYW0gPSAlZCFcbiIsCisJCXByX2RlYnVnKCJJT0NUTF9HRVRfVk9MVU1FIHJlY2VpdmVkIGZvciBzdHJlYW0gPSAlZCFcbiIsCiAJCQkJZ2V0X3ZvbC5zdHJlYW1faWQpOwogCQlpZiAobWlub3IgPT0gU1RSRUFNX01PRFVMRSAmJiBnZXRfdm9sLnN0cmVhbV9pZCA9PSAwKSB7CiAJCQlwcl9kZWJ1ZygiaW52YWxpZCBvcGVyYXRpb24hXG4iKTsKQEAgLTExMTcsNyArMTExNyw3IEBACiAJCQlyZXR2YWwgPSAtRUZBVUxUOwogCQkJYnJlYWs7CiAJCX0KLQkJcHJfZGVidWcoIlNORFJWX1NTVF9TRVRfVk9MVU1FIHJlY2lldmVkIGZvciAlZCFcbiIsCisJCXByX2RlYnVnKCJTTkRSVl9TU1RfU0VUX1ZPTFVNRSByZWNlaXZlZCBmb3IgJWQhXG4iLAogCQkJc2V0X211dGUuc3RyZWFtX2lkKTsKIAkJaWYgKG1pbm9yID09IFNUUkVBTV9NT0RVTEUgJiYgc2V0X211dGUuc3RyZWFtX2lkID09IDApIHsKIAkJCXJldHZhbCA9IC1FUEVSTTsKQEAgLTExNTMsNyArMTE1Myw3IEBACiAJY2FzZSBfSU9DX05SKFNORFJWX1NTVF9NTUFQX0NBUFRVUkUpOiB7CiAJCXN0cnVjdCBzbmRfc3N0X21tYXBfYnVmZnMgbW1hcF9idWY7CiAKLQkJcHJfZGVidWcoIlNORFJWX1NTVF9NTUFQX1BMQVkvQ0FQVFVSRSByZWNpZXZlZCFcbiIpOworCQlwcl9kZWJ1ZygiU05EUlZfU1NUX01NQVBfUExBWS9DQVBUVVJFIHJlY2VpdmVkIVxuIik7CiAJCWlmIChtaW5vciAhPSBTVFJFQU1fTU9EVUxFKSB7CiAJCQlyZXR2YWwgPSAtRUJBRFJRQzsKIAkJCWJyZWFrOwpAQCAtMTIzOSw3ICsxMjM5LDcgQEAKIAljYXNlIF9JT0NfTlIoU05EUlZfU1NUX1NFVF9UQVJHRVRfREVWSUNFKTogewogCQlzdHJ1Y3Qgc25kX3NzdF90YXJnZXRfZGV2aWNlIHRhcmdldF9kZXZpY2U7CiAKLQkJcHJfZGVidWcoIlNFVF9UQVJHRVRfREVWSUNFIHJlY2lldmVkIVxuIik7CisJCXByX2RlYnVnKCJTRVRfVEFSR0VUX0RFVklDRSByZWNlaXZlZCFcbiIpOwogCQlpZiAoY29weV9mcm9tX3VzZXIoJnRhcmdldF9kZXZpY2UsICh2b2lkIF9fdXNlciAqKWFyZywKIAkJCQlzaXplb2YodGFyZ2V0X2RldmljZSkpKSB7CiAJCQlyZXR2YWwgPSAtRUZBVUxUOwpAQCAtMTI1Niw3ICsxMjU2LDcgQEAKIAljYXNlIF9JT0NfTlIoU05EUlZfU1NUX0RSSVZFUl9JTkZPKTogewogCQlzdHJ1Y3Qgc25kX3NzdF9kcml2ZXJfaW5mbyBpbmZvOwogCi0JCXByX2RlYnVnKCJTTkRSVl9TU1RfRFJJVkVSX0lORk8gcmVjaXZlZFxuIik7CisJCXByX2RlYnVnKCJTTkRSVl9TU1RfRFJJVkVSX0lORk8gcmVjZWl2ZWRcbiIpOwogCQlpbmZvLnZlcnNpb24gPSBTU1RfVkVSU0lPTl9OVU07CiAJCS8qIGhhcmQgY29kaW5nLCBzaHVkIGdldCBzdW1ob3cgbGF0ZXIgKi8KIAkJaW5mby5hY3RpdmVfcGNtX3N0cmVhbXMgPSBzc3RfZHJ2X2N0eC0+c3RyZWFtX2NudCAtCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9kcnZfaW50ZXJmYWNlLmMgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9kcnZfaW50ZXJmYWNlLmMKaW5kZXggZWE4ZTI1MS4uZTljMTgyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3RfZHJ2X2ludGVyZmFjZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2Rydl9pbnRlcmZhY2UuYwpAQCAtMzE1LDcgKzMxNSw3IEBACiAJcG1fcnVudGltZV9nZXRfc3luYygmc3N0X2Rydl9jdHgtPnBjaS0+ZGV2KTsKIAogCWlmIChzc3RfZHJ2X2N0eC0+c3N0X3N0YXRlID09IFNTVF9TVVNQRU5ERUQpIHsKLQkJLyogTFBFIGlzIHN1c3BlbmRlZCwgcmVzdW1lIGl0IGJlZm9yZSBwcm9jZWRpbmcqLworCQkvKiBMUEUgaXMgc3VzcGVuZGVkLCByZXN1bWUgaXQgYmVmb3JlIHByb2NlZWRpbmcqLwogCQlwcl9kZWJ1ZygiUmVzdW1pbmcgZnJvbSBTdXNwZW5kZWQgc3RhdGVcbiIpOwogCQlyZXR2YWwgPSBpbnRlbF9zc3RfcmVzdW1lKHNzdF9kcnZfY3R4LT5wY2kpOwogCQlpZiAocmV0dmFsKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9kc3AuYyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2RzcC5jCmluZGV4IDZlNWM5MTUuLmJmZmU0YzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2RzcC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2RzcC5jCkBAIC0zNTAsNyArMzUwLDcgQEAKIAogfQogCi0vKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBiZWZvZXIgZG93bmxvYWRpbmcgdGhlIGNvZGVjL3Bvc3Rwcm9jZXNzaW5nCisvKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBiZWZvcmUgZG93bmxvYWRpbmcgdGhlIGNvZGVjL3Bvc3Rwcm9jZXNzaW5nCiBsaWJyYXJ5IGlzIHNldCBmb3IgZG93bmxvYWQgdG8gU1NUIERTUCovCiBzdGF0aWMgaW50IHNzdF92YWxpZGF0ZV9saWJyYXJ5KGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZndfbGliLAogCQlzdHJ1Y3QgbGliX3Nsb3RfaW5mbyAqc2xvdCwKQEAgLTQwNSw3ICs0MDUsNyBAQAogCiB9CiAKLS8qIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHdoZW4gRlcgcmVxdWVzdHMgZm9yIGEgcGFydGljdWxhciBsaWJhcnkgZG93bmxvYWQKKy8qIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHdoZW4gRlcgcmVxdWVzdHMgZm9yIGEgcGFydGljdWxhciBsaWJyYXJ5IGRvd25sb2FkCiBUaGlzIGZ1bmN0aW9uIHByZXBhcmVzIHRoZSBsaWJyYXJ5IHRvIGRvd25sb2FkKi8KIGludCBzc3RfbG9hZF9saWJyYXJ5KHN0cnVjdCBzbmRfc3N0X2xpYl9kb3dubG9hZCAqbGliLCB1OCBvcHMpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9md19pcGMuaCBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2Z3X2lwYy5oCmluZGV4IDhkZjMxM2QuLjBmMGM1YmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2Z3X2lwYy5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X2Z3X2lwYy5oCkBAIC0xMTEsNyArMTExLDcgQEAKICNkZWZpbmUgSVBDX1NTVF9QRVJJT0RfRUxBUFNFRCAweDk3IC8qIHBlcmlvZCBlbGFwc2VkICovCiAjZGVmaW5lIElQQ19JQV9UQVJHRVRfREVWX0NITkdEIDB4OTggLyogZXJyb3IgaW4gcHJvY2Vzc2luZyBhIHN0cmVhbSAqLwogCi0jZGVmaW5lIElQQ19TU1RfRVJST1JfRVZFTlQgMHg5OSAvKiBCdWZmZXIgb3ZlciBydW4gb2NjdXJlZCAqLworI2RlZmluZSBJUENfU1NUX0VSUk9SX0VWRU5UIDB4OTkgLyogQnVmZmVyIG92ZXIgcnVuIG9jY3VycmVkICovCiAvKiBMMlMgbWVzc2FnZXMgKi8KICNkZWZpbmUgSVBDX1NDX0REUl9MSU5LX1VQIDB4QzAKICNkZWZpbmUgSVBDX1NDX0REUl9MSU5LX0RPV04gMHhDMQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3Rfc3RyZWFtLmMgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9zdHJlYW0uYwppbmRleCA3OTVlNDJhLi5kZDU4YmU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9zdHJlYW0uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9zdHJlYW0uYwpAQCAtOTgsNyArOTgsNyBAQAogCQlpZiAoc3N0X2Rydl9jdHgtPnN0cmVhbXNbaV0uc3RhdHVzID09IFNUUkVBTV9VTl9JTklUKQogCQkJcmV0dXJuIGk7CiAJfQotCXByX2RlYnVnKCJEaWRudCBmaW5kIGVtcHR5IHN0cmVhbSBmb3IgbXJzdFxuIik7CisJcHJfZGVidWcoIkRpZG4ndCBmaW5kIGVtcHR5IHN0cmVhbSBmb3IgbXJzdFxuIik7CiAJcmV0dXJuIC1FQlVTWTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3Rfc3RyZWFtX2VuY29kZWQuYyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxfc3N0X3N0cmVhbV9lbmNvZGVkLmMKaW5kZXggMjk3NTNjNy4uZDVmMDdiOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbF9zc3Rfc3RyZWFtX2VuY29kZWQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsX3NzdF9zdHJlYW1fZW5jb2RlZC5jCkBAIC05MTQsNyArOTE0LDcgQEAKIAkJKHZvaWQgKikgKCh1bnNpZ25lZCBsb25nKSByYXJfYnVmZmVycy5idXNfYWRkcmVzcyk7CiAJCXByX2RlYnVnKCJSQVIgYnVmIGFkZHIgaW4gRG5SIChpbnB1dCBidWZmZXIgZnVuY3Rpb24pMHglbHUiLAogCQkJCSAodW5zaWduZWQgbG9uZykgc3RyX2luZm8tPmRlY29kZV9pYnVmKTsKLQkJcHJfZGVidWcoInJhciBpbiBEblIgZGVjb2RlIGZ1bnRpb24vb3V0cHV0IGJfYWRkIHJhciA9MHglbHUiLAorCQlwcl9kZWJ1ZygicmFyIGluIERuUiBkZWNvZGUgZnVuY3Rpb24vb3V0cHV0IGJfYWRkIHJhciA9MHglbHUiLAogCQkJCSh1bnNpZ25lZCBsb25nKSByYXJfYnVmZmVycy5idXNfYWRkcmVzcyk7CiAJCSppbnB1dF9pbmRleCA9IGkgKyAxOwogCQlzdHJfaW5mby0+ZGVjb2RlX2lzaXplID0gZGJ1ZnMtPmlidWZzLT5idWZmX2VudHJ5W2ldLnNpemU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsbWlkLmMgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsbWlkLmMKaW5kZXggZmIyMjkyMS4uZDIwNzYzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbG1pZC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxtaWQuYwpAQCAtNzczLDcgKzc3Myw3IEBACiAJCWlmIChyZXRfdmFsKQogCQkJcmV0dXJuIHJldF92YWw7CiAJCXNzdF9jYXJkX3ZlbmRvcl9pZCA9ICh2ZW5kb3JfYWRkci52YWx1ZSAmIChNQVNLMnxNQVNLMXxNQVNLMCkpOwotCQlwcl9kZWJ1Zygib3JnaW5hbCBuIGV4dHJhdGVkIHZlbmRvciBpZCA9IDB4JXggJWRcbiIsCisJCXByX2RlYnVnKCJvcmlnaW5hbCBuIGV4dHJhdGVkIHZlbmRvciBpZCA9IDB4JXggJWRcbiIsCiAJCQkJdmVuZG9yX2FkZHIudmFsdWUsIHNzdF9jYXJkX3ZlbmRvcl9pZCk7CiAJCWlmIChzc3RfY2FyZF92ZW5kb3JfaWQgPCAwIHx8IHNzdF9jYXJkX3ZlbmRvcl9pZCA+IDIpIHsKIAkJCXByX2VycigidmVuZG9yIGNhcmQgbm90IHN1cHBvcnRlZCEhXG4iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxtaWQuaCBiL2RyaXZlcnMvc3RhZ2luZy9pbnRlbF9zc3QvaW50ZWxtaWQuaAppbmRleCBjYTg4MWI3Li5lNzdkYTg3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsbWlkLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbG1pZC5oCkBAIC05MCw3ICs5MCw3IEBACiAgKiBAY2FyZF9pbmRleDogc291bmQgY2FyZCBpbmRleAogICogQGNhcmRfaWQ6IHNvdW5kIGNhcmQgaWQgZGV0ZWN0ZWQKICAqIEBzc3RkcnZfb3BzOiBwdHIgdG8gc3N0IGRyaXZlciBvcHMKLSAqIEBwZGV2OiBwdHIgdG8gcGxhdGZyb20gZGV2aWNlCisgKiBAcGRldjogcHRyIHRvIHBsYXRmb3JtIGRldmljZQogICogQGlycTogaW50ZXJydXB0IG51bWJlciBkZXRlY3RlZAogICogQHBtaWNfc3RhdHVzOiBEZXZpY2Ugc3RhdHVzIG9mIHNvdW5kIGNhcmQKICAqIEBpbnRfYmFzZTogcHRyIHRvIE1NSU8gaW50ZXJydXB0IHJlZ2lvbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2tldWNyL2luaXQuYyBiL2RyaXZlcnMvc3RhZ2luZy9rZXVjci9pbml0LmMKaW5kZXggNWMwMWYyOC4uOGFmN2M4NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2tldWNyL2luaXQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcva2V1Y3IvaW5pdC5jCkBAIC05MCw3ICs5MCw3IEBACiAKIAlyZXN1bHQgPSBFTkVfU2VuZFNjc2lDbWQodXMsIEZESVJfUkVBRCwgJmJ1ZiwgMCk7CiAJaWYgKHJlc3VsdCAhPSBVU0JfU1RPUl9YRkVSX0dPT0QpIHsKLQkJcHJpbnRrKEtFUk5fRVJSICJFeGVjdGlvbiBNUyBJbml0IENvZGUgRmFpbCAhIVxuIik7CisJCXByaW50ayhLRVJOX0VSUiAiRXhlY3V0aW9uIE1TIEluaXQgQ29kZSBGYWlsICEhXG4iKTsKIAkJcmV0dXJuIFVTQl9TVE9SX1RSQU5TUE9SVF9FUlJPUjsKIAl9CiAKQEAgLTE0NSw3ICsxNDUsNyBAQAogCXJlc3VsdCA9IEVORV9TZW5kU2NzaUNtZCh1cywgRkRJUl9SRUFELCAmYnVmLCAwKTsKIAlpZiAocmVzdWx0ICE9IFVTQl9TVE9SX1hGRVJfR09PRCkgewogCQlwcmludGsoS0VSTl9FUlIKLQkJICAgICAgICJFeGVjdGlvbiBTTSBJbml0IENvZGUgRmFpbCAhISByZXN1bHQgPSAleFxuIiwgcmVzdWx0KTsKKwkJICAgICAgICJFeGVjdXRpb24gU00gSW5pdCBDb2RlIEZhaWwgISEgcmVzdWx0ID0gJXhcbiIsIHJlc3VsdCk7CiAJCXJldHVybiBVU0JfU1RPUl9UUkFOU1BPUlRfRVJST1I7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcva2V1Y3Ivc21pbG1haW4uYyBiL2RyaXZlcnMvc3RhZ2luZy9rZXVjci9zbWlsbWFpbi5jCmluZGV4IDJjYmU5ZjguLjk1YzY4OGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9rZXVjci9zbWlsbWFpbi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9rZXVjci9zbWlsbWFpbi5jCkBAIC02NCw3ICs2NCw3IEBACiBleHRlcm4gc3RydWN0IEFERFJFU1MgICAgTWVkaWE7CiBleHRlcm4gc3RydWN0IENJU19BUkVBICAgQ2lzQXJlYTsKIAotLy9CSVQgQ29udHJvbGwgTWFjcm8KKy8vQklUIENvbnRyb2wgTWFjcm8KIEJZVEUgQml0RGF0YVtdID0geyAweDAxLDB4MDIsMHgwNCwweDA4LDB4MTAsMHgyMCwweDQwLDB4ODAgfSA7CiAjZGVmaW5lIFNldF9EX0JpdChhLGIpICAgIChhWyhCWVRFKSgoYikvOCldfD0gQml0RGF0YVsoYiklOF0pCiAjZGVmaW5lIENscl9EX0JpdChhLGIpICAgIChhWyhCWVRFKSgoYikvOCldJj1+Qml0RGF0YVsoYiklOF0pCkBAIC03Niw3ICs3Niw3IEBACiAKIAogLy8KLS8vLy9Qb3dlciBDb250cm9sbCAmIE1lZGlhIEV4aXN0IENoZWNrIEZ1bmN0aW9uCisvLy8vUG93ZXIgQ29udHJvbCAmIE1lZGlhIEV4aXN0IENoZWNrIEZ1bmN0aW9uCiAvLy8vLS0tLS0gSW5pdF9EX1NtYXJ0TWVkaWEoKSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy9pbnQgSW5pdF9EX1NtYXJ0TWVkaWEodm9pZCkKIC8vewpAQCAtNTc1LDcgKzU3NSw3IEBACiAvLyAgICByZXR1cm4oU1VDQ0VTUyk7CiAvL30KIC8vCi0vLy8vUG93ZXIgQ29udHJvbGwgJiBNZWRpYSBFeGlzdCBDaGVjayBTdWJyb3V0aW5lCisvLy8vUG93ZXIgQ29udHJvbCAmIE1lZGlhIEV4aXN0IENoZWNrIFN1YnJvdXRpbmUKIC8vLy8tLS0tLSBJbml0aWFsaXplX0RfTWVkaWEoKSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAvL3ZvaWQgSW5pdGlhbGl6ZV9EX01lZGlhKHZvaWQpCiAvL3sKQEAgLTczOCw3ICs3MzgsNyBAQAogLy8gICAgcmV0dXJuKFNVQ0NFU1MpOwogLy99CiAqLwotLy9TbWFydE1lZGlhIFBoeXNpY2FsIEFkZHJlc3MgQ29udHJvbGwgU3Vicm91dGluZQorLy9TbWFydE1lZGlhIFBoeXNpY2FsIEFkZHJlc3MgQ29udHJvbCBTdWJyb3V0aW5lCiAvLy0tLS0tIENvbnZfRF9NZWRpYUFkZHIoKSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGludCBDb252X0RfTWVkaWFBZGRyKHN0cnVjdCB1c19kYXRhICp1cywgRFdPUkQgYWRkcikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9rZXVjci9zbWlsc3ViLmMgYi9kcml2ZXJzL3N0YWdpbmcva2V1Y3Ivc21pbHN1Yi5jCmluZGV4IDgwZGE2MWMuLjRmZTQ3NDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9rZXVjci9zbWlsc3ViLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2tldWNyL3NtaWxzdWIuYwpAQCAtNTcsNyArNTcsNyBAQAogI2RlZmluZSBPREQgICAgICAgICAgICAgICAgICAgICAxICAgICAgICAgICAgIC8vIE9kZCBQYWdlIGZvciAyNTZieXRlL3BhZ2UKIAogCi0vL1NtYXJ0TWVkaWEgUmVkdW5kYW50IGJ1ZmZlciBkYXRhIENvbnRyb2xsIFN1YnJvdXRpbmUKKy8vU21hcnRNZWRpYSBSZWR1bmRhbnQgYnVmZmVyIGRhdGEgQ29udHJvbCBTdWJyb3V0aW5lCiAvLy0tLS0tIENoZWNrX0RfRGF0YUJsYW5rKCkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGludCBDaGVja19EX0RhdGFCbGFuayhCWVRFICpyZWR1bmRhbnQpCiB7CkBAIC0xMzY3LDcgKzEzNjcsNyBAQAogICAgIH0KIH0KIC8qCi0vLy8vU21hcnRNZWRpYSBQb3dlciBDb250cm9sbCBTdWJyb3V0aW5lCisvLy8vU21hcnRNZWRpYSBQb3dlciBDb250cm9sIFN1YnJvdXRpbmUKIC8vLy8tLS0tLSBDbnRfRF9SZXNldCgpIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIC8vdm9pZCBDbnRfRF9SZXNldCh2b2lkKQogLy97CkBAIC0xNDc4LDcgKzE0NzgsNyBAQAogLy99CiAvLwogKi8KLS8vU21hcnRNZWRpYSBFQ0MgQ29udHJvbGwgU3Vicm91dGluZQorLy9TbWFydE1lZGlhIEVDQyBDb250cm9sIFN1YnJvdXRpbmUKIC8vLS0tLS0gQ2hlY2tfRF9SZWFkRXJyb3IoKSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBpbnQgQ2hlY2tfRF9SZWFkRXJyb3IoQllURSAqcmVkdW5kYW50KQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19lbmUwMTAwLmggYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX2VuZTAxMDAuaAppbmRleCA3NzZiNjkzLi4wNmJlYmQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX2VuZTAxMDAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX2VuZTAxMDAuaApAQCAtODEsNyArODEsNyBAQAogCiAvKiBDSVIgYmxvY2sgc2V0dGluZ3MgKi8KICNkZWZpbmUgRU5FX0NJUl9DT05GMQkJMHhGRUMwCi0jZGVmaW5lIEVORV9DSVJfQ09ORjFfQURDX09OCTB4NwkgLyogcmVjaWV2ZXIgb24gZ3BpbzQwIGVuYWJsZWQgKi8KKyNkZWZpbmUgRU5FX0NJUl9DT05GMV9BRENfT04JMHg3CSAvKiByZWNlaXZlciBvbiBncGlvNDAgZW5hYmxlZCAqLwogI2RlZmluZSBFTkVfQ0lSX0NPTkYxX0xFQVJOMQkoMSA8PCAzKSAvKiBlbmFibGVkIG9uIGxlYXJuaW5nIG1vZGUgKi8KICNkZWZpbmUgRU5FX0NJUl9DT05GMV9UWF9PTgkweDMwCSAvKiBlbmFibGVkIG9uIHRyYW5zbWl0ICovCiAjZGVmaW5lIEVORV9DSVJfQ09ORjFfVFhfQ0FSUgkoMSA8PCA3KSAvKiBzZW5kIFRYIGNhcnJpZXIgb3Igbm90ICovCkBAIC05Niw3ICs5Niw3IEBACiAKIC8qIHRyYW5zbWl0dGVyIC0gbm90IGltcGxlbWVudGVkIHlldCAqLwogLyogS0IzOTI2QyBhbmQgaGlnaGVyICovCi0vKiB0cmFuc21pc3Npb24gaXMgdmVyeSBzaW1pbGlhciB0byByZWNpZXZpbmcsIGEgYnl0ZSBpcyB3cml0dGVuIHRvICovCisvKiB0cmFuc21pc3Npb24gaXMgdmVyeSBzaW1pbGFyIHRvIHJlY2VpdmluZywgYSBieXRlIGlzIHdyaXR0ZW4gdG8gKi8KIC8qIEVORV9UWF9JTlBVVCwgaW4gc2FtZSBtYW5uZXIgYXMgaXQgaXMgcmVhZCBmcm9tIHNhbXBsZSBidWZmZXIgKi8KIC8qIHNhbXBsZSBwZXJpb2QgaXMgZml4ZWQqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL0tjb25maWcgYi9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL0tjb25maWcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNiZWViYzUuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9LY29uZmlnCisrKyAvZGV2L251bGwKQEAgLTEsMTUgKzAsMCBAQAotY29uZmlnIE1SU1RfUkFSX0hBTkRMRVIKLQl0cmlzdGF0ZSAiUkFSIGhhbmRsZXIgZHJpdmVyIGZvciBJbnRlbCBNb29yZXN0b3duIHBsYXRmb3JtIgotCWRlcGVuZHMgb24gUkFSX1JFR0lTVEVSCi0JLS0taGVscC0tLQotCSAgVGhpcyBkcml2ZXIgcHJvdmlkZXMgYSBtZW1vcnkgbWFuYWdlbWVudCBpbnRlcmZhY2UgdG8KLQkgIHJlc3RyaWN0ZWQgYWNjZXNzIHJlZ2lvbnMgKFJBUikgYXZhaWxhYmxlIG9uIHRoZSBJbnRlbAotCSAgTW9vcmVzdG93biBwbGF0Zm9ybS4KLQotCSAgT25jZSBsb2NrZWQgZG93biwgcmVzdHJpY3RlZCBhY2Nlc3MgcmVnaW9ucyBhcmUgb25seQotCSAgYWNjZXNzaWJsZSBieSBzcGVjaWZpYyBoYXJkd2FyZSBvbiB0aGUgcGxhdGZvcm0uICBUaGUgeDg2Ci0JICBDUFUgaXMgdHlwaWNhbGx5IG5vdCBvbmUgb2YgdGhvc2UgcGxhdGZvcm1zLiAgQXMgc3VjaCB0aGlzCi0JICBkcml2ZXIgZG9lcyBub3QgYWNjZXNzIFJBUiwgYW5kIG9ubHkgcHJvdmlkZXMgYSBidWZmZXIKLQkgIGFsbG9jYXRpb24vYm9va2tlZXBpbmcgbWVjaGFuaXNtLgotCi0JICBJZiB1bnN1cmUsIHNheSBOLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9NYWtlZmlsZSBiL2RyaXZlcnMvc3RhZ2luZy9tZW1yYXIvTWFrZWZpbGUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEzMzM2YzAuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9NYWtlZmlsZQorKysgL2Rldi9udWxsCkBAIC0xLDIgKzAsMCBAQAotb2JqLSQoQ09ORklHX01SU1RfUkFSX0hBTkRMRVIpCSs9IG1lbXJhci5vCi1tZW1yYXIteQkJCTo9IG1lbXJhcl9hbGxvY2F0b3IubyBtZW1yYXJfaGFuZGxlci5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL1RPRE8gYi9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL1RPRE8KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQzNWUwOWIuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9UT0RPCisrKyAvZGV2L251bGwKQEAgLTEsNDMgKzAsMCBAQAotUkFSIEhhbmRsZXIgKG1lbXJhcikgRHJpdmVyIFRPRE8gSXRlbXMKLT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0KLU1haW50YWluZXI6IEV1Z2VuZSBFcHNodGV5biA8ZXVnZW5lLmVwc2h0ZXluQGludGVsLmNvbT4KLQotbWVtcmFyLmgKLS0tLS0tLS0tCi0xLiBUaGlzIGhlYWRlciBleHBvc2VzIHRoZSBkcml2ZXIncyB1c2VyIHNwYWNlIGFuZCBrZXJuZWwgc3BhY2UKLSAgIGludGVyZmFjZXMuICBJdCBzaG91bGQgYmUgbW92ZWQgdG8gPGxpbnV4L3Jhci9tZW1yYXIuaD4sIG9yCi0gICBzb21ldGhpbmcgYWxvbmcgdGhvc2UgbGluZXMsIHdoZW4gdGhpcyBtZW1yYXIgZHJpdmVyIGlzIG1vdmVkIG91dAotICAgb2YgYHN0YWdpbmcnLgotICAgICBhLiBJdCB3b3VsZCBiZSBpZGVhbCBpZiBzdGFnaW5nL3Jhcl9yZWdpc3Rlci9yYXJfcmVnaXN0ZXIuaCB3YXMKLSAgICAgICAgbW92ZWQgdG8gdGhlIHNhbWUgZGlyZWN0b3J5LgotCi1tZW1yYXJfYWxsb2NhdG9yLltjaF0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotMS4gQWRkcmVzcyBwb3RlbnRpYWwgZnJhZ21lbnRhdGlvbiBpc3N1ZXMgd2l0aCB0aGUgbWVtcmFyX2FsbG9jYXRvci4KLQotMi4gSGlkZSBzdHJ1Y3QgbWVtcmFyX2FsbG9jYXRvciBkZXRhaWxzL2ZpZWxkcy4gIFRoZXkgbmVlZCBub3QgYmUKLSAgIGV4cG9zZWQgdG8gdGhlIHVzZXIuCi0gICAgIGEuIEZvcndhcmQgZGVjbGFyZSBzdHJ1Y3QgbWVtcmFyX2FsbG9jYXRvci4KLSAgICAgYi4gTW92ZSBhbGwgdGhyZWUgc3RydWN0IGRlZmluaXRpb25zIHRvIGBtZW1yYXJfYWxsb2NhdG9yLmMnCi0gICAgICAgIHNvdXJjZSBmaWxlLgotICAgICBjLiBBZGQgYSBtZW1yYXJfYWxsb2NhdG9yX2xhcmdlc3RfZnJlZV9hcmVhKCkgZnVuY3Rpb24sIG9yCi0gICAgICAgIHNvbWV0aGluZyBsaWtlIHRoYXQgdG8gZ2V0IGFjY2VzcyB0byB0aGUgdmFsdWUgb2YgdGhlIHN0cnVjdAotICAgICAgICBtZW1yYXJfYWxsb2NhdG9yICJsYXJnZXN0X2ZyZWVfYXJlYSIgZmllbGQuICBUaGlzIGFsbG93cyB0aGUKLSAgICAgICAgc3RydWN0IG1lbXJhcl9hbGxvY2F0b3IgZmllbGRzIHRvIGJlIGNvbXBsZXRlbHkgaGlkZGVuIGZyb20KLSAgICAgICAgdGhlIHVzZXIuICBUaGUgbWVtcmFyX2hhbmRsZXIgY29kZSByZWFsbHkgb25seSBuZWVkcyB0aGlzIGZvcgotICAgICAgICBzdGF0aXN0aWMgZ2F0aGVyaW5nIG9uLWRlbWFuZC4KLSAgICAgZC4gRG8gdGhlIHNhbWUgZm9yIHRoZSAiY2FwYWNpdHkiIGZpZWxkIGFzIHRoZQotICAgICAgICAibGFyZ2VzdF9mcmVlX2FyZWEiIGZpZWxkLgotCi0zLiBNb3ZlIG1lbXJhcl9hbGxvY2F0b3IuKiB0byBrZXJuZWwgYGxpYicgZGlyZWN0b3J5IHNpbmNlIGl0IGlzIEhXCi0gICBuZXV0cmFsLgotICAgICBhLiBBbHRlcm5hdGl2ZWx5LCB1c2UgbGliL2dlbmFsbG9jLmMgaW5zdGVhZC4KLSAgICAgYi4gQSBrZXJuZWwgcG9ydCBvZiBEb3VnIExlYSdzIG1hbGxvYygpIGltcGxlbWVudGF0aW9uIG1heSBhbHNvCi0gICAgICAgIGJlIGFuIG9wdGlvbi4KLQotbWVtcmFyX2hhbmRsZXIuYwotLS0tLS0tLS0tLS0tLS0tLQotMS4gU3BsaXQgdXNlciBzcGFjZSBpbnRlcmZhY2UgKGlvY3RsIGNvZGUpIGZyb20gY29yZS9rZXJuZWwgY29kZSwKLSAgIGUuZy46Ci0gICAgIG1lbXJhcl9oYW5kbGVyLmMgLT4gbWVtcmFyX2NvcmUuYywgbWVtcmFyX3VzZXIuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9tZW1yYXItYWJpIGIvZHJpdmVycy9zdGFnaW5nL21lbXJhci9tZW1yYXItYWJpCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMjNmYzk5Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9tZW1yYXIvbWVtcmFyLWFiaQorKysgL2Rldi9udWxsCkBAIC0xLDg5ICswLDAgQEAKLVdoYXQ6CQkvZGV2L21lbXJhcgotRGF0ZToJCU1hcmNoIDIwMTAKLUtlcm5lbFZlcnNpb246CTIuNi4zNAotQ29udGFjdDoJRXVnZW5lIEVwc2h0ZXluIDxldWdlbmUuZXBzaHRleW5AaW50ZWwuY29tPgotRGVzY3JpcHRpb246CVRoZSBJbnRlbCBNb29yZXN0b3duIFJlc3RyaWN0ZWQgQWNjZXNzIFJlZ2lvbiAoUkFSKQotCQlIYW5kbGVyIGRyaXZlciBleHBvc2VzIGFuIGlvY3RsKCkgYmFzZWQgaW50ZXJmYWNlIHRoYXQKLQkJYWxsb3dzIGEgdXNlciB0byByZXNlcnZlIGFuZCByZWxlYXNlIGJsb2NrcyBvZiBSQVIKLQkJbWVtb3J5LgotCi0JCU5vdGU6ICBBIHN5c2ZzIGJhc2VkIG9uZSB3YXMgbm90IGFwcHJvcHJpYXRlIGZvciB0aGUKLQkJUkFSIGhhbmRsZXIncyB1c2FnZSBtb2RlbC4KLQotCQk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQkJCQlpb2N0bCgpIFJlcXVlc3RzCi0JCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotCQlSQVJfSEFORExFUl9SRVNFUlZFCi0JCS0tLS0tLS0tLS0tLS0tLS0tLS0KLQkJRGVzY3JpcHRpb246CVJlc2VydmUgUkFSIGJsb2NrLgotCQlUeXBlOgkJc3RydWN0IFJBUl9ibG9ja19pbmZvCi0JCURpcmVjdGlvbjoJaW4vb3V0Ci0JCUVycm9yczoJCUVJTlZBTCAoaW52YWxpZCBSQVIgdHlwZSBvciBzaXplKQotCQkJCUVOT01FTSAobm90IGVub3VnaCBSQVIgbWVtb3J5KQotCi0JCVJBUl9IQU5ETEVSX1NUQVQKLQkJLS0tLS0tLS0tLS0tLS0tLQotCQlEZXNjcmlwdGlvbjoJR2V0IFJBUiBzdGF0aXN0aWNzLgotCQlUeXBlOgkJc3RydWN0IFJBUl9zdGF0Ci0JCURpcmVjdGlvbjoJaW4vb3V0Ci0JCUVycm9yczoJCUVJTlZBTCAoaW52YWxpZCBSQVIgdHlwZSkKLQotCQlSQVJfSEFORExFUl9SRUxFQVNFCi0JCS0tLS0tLS0tLS0tLS0tLS0tLS0KLQkJRGVzY3JpcHRpb246CVJlbGVhc2UgcHJldmlvdXNseSByZXNlcnZlZCBSQVIgYmxvY2suCi0JCVR5cGU6CQkzMiBiaXQgdW5zaWduZWQgaW50ZWdlcgotCQkJCShlLmcuIHVpbnQzMl90KSwgaS5lIHRoZSBSQVIgImhhbmRsZSIuCi0JCURpcmVjdGlvbjoJaW4KLQkJRXJyb3JzOgkJRUlOVkFMIChpbnZhbGlkIFJBUiBoYW5kbGUpCi0KLQotCQk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLQkJCWlvY3RsKCkgUmVxdWVzdCBQYXJhbWV0ZXIgVHlwZXMKLQkJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0JCVRoZSBzdHJ1Y3R1cmVzIHJlZmVycmVkIHRvIGFib3ZlIGFyZSBkZWZpbmVkIGFzCi0JCWZvbGxvd3M6Ci0KLQkJLyoqCi0JCSAqIHN0cnVjdCBSQVJfYmxvY2tfaW5mbyAtIHVzZXIgc3BhY2Ugc3RydWN0IHRoYXQKLQkJICoJCQkgICBkZXNjcmliZXMgUkFSIGJ1ZmZlcgotCQkgKiBAdHlwZToJVHlwZSBvZiBSQVIgbWVtb3J5IChlLmcuLAotCQkgKgkJUkFSX1RZUEVfVklERU8gb3IgUkFSX1RZUEVfQVVESU8pIFtpbl0KLQkJICogQHNpemU6CVJlcXVlc3RlZCBzaXplIG9mIGEgYmxvY2sgaW4gYnl0ZXMgdG8KLQkJICoJCWJlIHJlc2VydmVkIGluIFJBUi4gW2luXQotCQkgKiBAaGFuZGxlOglIYW5kbGUgdGhhdCBjYW4gYmUgdXNlZCB0byByZWZlciB0bwotCQkgKgkJcmVzZXJ2ZWQgYmxvY2suIFtvdXRdCi0JCSAqCi0JCSAqIFRoaXMgaXMgdGhlIGJhc2ljIHN0cnVjdHVyZSBleHBvc2VkIHRvIHRoZSB1c2VyCi0JCSAqIHNwYWNlIHRoYXQgZGVzY3JpYmVzIGEgZ2l2ZW4gUkFSIGJ1ZmZlci4gIEl0IHVzZWQKLQkJICogYXMgdGhlIHBhcmFtZXRlciBmb3IgdGhlIFJBUl9IQU5ETEVSX1JFU0VSVkUgaW9jdGwuCi0JCSAqIFRoZSBidWZmZXIncyB1bmRlcmx5aW5nIGJ1cyBhZGRyZXNzIGlzIG5vdCBleHBvc2VkCi0JCSAqIHRvIHRoZSB1c2VyLiAgVXNlciBzcGFjZSBjb2RlIHJlZmVycyB0byB0aGUgYnVmZmVyCi0JCSAqIGVudGlyZWx5IGJ5ICJoYW5kbGUiLgotCQkgKi8KLQkJc3RydWN0IFJBUl9ibG9ja19pbmZvIHsKLQkJCV9fdTMyIHR5cGU7Ci0JCQlfX3UzMiBzaXplOwotCQkJX191MzIgaGFuZGxlOwotCQl9OwotCi0JCS8qKgotCQkgKiBzdHJ1Y3QgUkFSX3N0YXQgLSBSQVIgc3RhdGlzdGljcyBzdHJ1Y3R1cmUKLQkJICogQHR5cGU6CQlUeXBlIG9mIFJBUiBtZW1vcnkgKGUuZy4sCi0JCSAqCQkJUkFSX1RZUEVfVklERU8gb3IKLQkJICoJCQlSQVJfVFlQRV9BVURJTykgW2luXQotCQkgKiBAY2FwYWNpdHk6CQlUb3RhbCBzaXplIG9mIFJBUiBtZW1vcnkKLQkJICoJCQlyZWdpb24uIFtvdXRdCi0JCSAqIEBsYXJnZXN0X2Jsb2NrX3NpemU6CVNpemUgb2YgdGhlIGxhcmdlc3QgcmVzZXJ2YWJsZQotCQkgKgkJCWJsb2NrLiBbb3V0XQotCQkgKgotCQkgKiBUaGlzIHN0cnVjdHVyZSBpcyB1c2VkIGZvciBSQVJfSEFORExFUl9TVEFUIGlvY3RsLgotCQkgKi8KLQkJc3RydWN0IFJBUl9zdGF0IHsKLQkJCV9fdTMyIHR5cGU7Ci0JCQlfX3UzMiBjYXBhY2l0eTsKLQkJCV9fdTMyIGxhcmdlc3RfYmxvY2tfc2l6ZTsKLQkJfTsKLQotCQlMYXN0bHksIHRoZSBSQVJfSEFORExFUl9SRUxFQVNFIGlvY3RsIGV4cGVjdHMgYQotCQkiaGFuZGxlIiB0byB0aGUgUkFSIGJsb2NrIG9mIG1lbW9yeS4gIEl0IGlzIGEgMzIgYml0Ci0JCXVuc2lnbmVkIGludGVnZXIuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL21lbXJhci5oIGIvZHJpdmVycy9zdGFnaW5nL21lbXJhci9tZW1yYXIuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMGZlYjczYi4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL21lbXJhci5oCisrKyAvZGV2L251bGwKQEAgLTEsMTc0ICswLDAgQEAKLS8qCi0gKiAgICAgIFJBUiBIYW5kbGVyICgvZGV2L21lbXJhcikgaW50ZXJuYWwgZHJpdmVyIEFQSS4KLSAqICAgICAgQ29weXJpZ2h0IChDKSAyMDEwIEludGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqICAgICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgotICogICAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwKLSAqICAgICAgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogICAgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlCi0gKiAgICAgIHVzZWZ1bCwgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQKLSAqICAgICAgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogICAgICBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICogICAgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMKLSAqICAgICAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQotICogICAgICBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCi0gKiAgICAgIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcsIFVTQS4KLSAqICAgICAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcwotICogICAgICBkaXN0cmlidXRpb24gaW4gdGhlIGZpbGUgY2FsbGVkIENPUFlJTkcuCi0gKi8KLQotCi0jaWZuZGVmIF9NRU1SQVJfSAotI2RlZmluZSBfTUVNUkFSX0gKLQotI2luY2x1ZGUgPGxpbnV4L2lvY3RsLmg+Ci0jaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KLQotCi0vKioKLSAqIHN0cnVjdCBSQVJfc3RhdCAtIFJBUiBzdGF0aXN0aWNzIHN0cnVjdHVyZQotICogQHR5cGU6CQlUeXBlIG9mIFJBUiBtZW1vcnkgKGUuZy4sIGF1ZGlvIHZzLiB2aWRlbykKLSAqIEBjYXBhY2l0eToJCVRvdGFsIHNpemUgb2YgUkFSIG1lbW9yeSByZWdpb24uCi0gKiBAbGFyZ2VzdF9ibG9ja19zaXplOglTaXplIG9mIHRoZSBsYXJnZXN0IHJlc2VydmFibGUgYmxvY2suCi0gKgotICogVGhpcyBzdHJ1Y3R1cmUgaXMgdXNlZCBmb3IgUkFSX0hBTkRMRVJfU1RBVCBpb2N0bCBhbmQgZm9yIHRoZQotICogUkFSX2dldF9zdGF0KCkgdXNlciBzcGFjZSB3cmFwcGVyIGZ1bmN0aW9uLgotICovCi1zdHJ1Y3QgUkFSX3N0YXQgewotCV9fdTMyIHR5cGU7Ci0JX191MzIgY2FwYWNpdHk7Ci0JX191MzIgbGFyZ2VzdF9ibG9ja19zaXplOwotfTsKLQotCi0vKioKLSAqIHN0cnVjdCBSQVJfYmxvY2tfaW5mbyAtIHVzZXIgc3BhY2Ugc3RydWN0IHRoYXQgZGVzY3JpYmVzIFJBUiBidWZmZXIKLSAqIEB0eXBlOglUeXBlIG9mIFJBUiBtZW1vcnkgKGUuZy4sIGF1ZGlvIHZzLiB2aWRlbykKLSAqIEBzaXplOglSZXF1ZXN0ZWQgc2l6ZSBvZiBhIGJsb2NrIHRvIGJlIHJlc2VydmVkIGluIFJBUi4KLSAqIEBoYW5kbGU6CUhhbmRsZSB0aGF0IGNhbiBiZSB1c2VkIHRvIHJlZmVyIHRvIHJlc2VydmVkIGJsb2NrLgotICoKLSAqIFRoaXMgaXMgdGhlIGJhc2ljIHN0cnVjdHVyZSBleHBvc2VkIHRvIHRoZSB1c2VyIHNwYWNlIHRoYXQKLSAqIGRlc2NyaWJlcyBhIGdpdmVuIFJBUiBidWZmZXIuICBUaGUgYnVmZmVyJ3MgdW5kZXJseWluZyBidXMgYWRkcmVzcwotICogaXMgbm90IGV4cG9zZWQgdG8gdGhlIHVzZXIuICBVc2VyIHNwYWNlIGNvZGUgcmVmZXJzIHRvIHRoZSBidWZmZXIKLSAqIGVudGlyZWx5IGJ5ICJoYW5kbGUiLgotICovCi1zdHJ1Y3QgUkFSX2Jsb2NrX2luZm8gewotCV9fdTMyIHR5cGU7Ci0JX191MzIgc2l6ZTsKLQlfX3UzMiBoYW5kbGU7Ci19OwotCi0KLSNkZWZpbmUgUkFSX0lPQ1RMX0JBU0UgMHhFMAotCi0vKiBSZXNlcnZlIFJBUiBibG9jay4gKi8KLSNkZWZpbmUgUkFSX0hBTkRMRVJfUkVTRVJWRSBfSU9XUihSQVJfSU9DVExfQkFTRSwgMHgwMCwgc3RydWN0IFJBUl9ibG9ja19pbmZvKQotCi0vKiBSZWxlYXNlIHByZXZpb3VzbHkgcmVzZXJ2ZWQgUkFSIGJsb2NrLiAqLwotI2RlZmluZSBSQVJfSEFORExFUl9SRUxFQVNFIF9JT1coUkFSX0lPQ1RMX0JBU0UsIDB4MDEsIF9fdTMyKQotCi0vKiBHZXQgUkFSIHN0YXRzLiAqLwotI2RlZmluZSBSQVJfSEFORExFUl9TVEFUICAgIF9JT1dSKFJBUl9JT0NUTF9CQVNFLCAweDAyLCBzdHJ1Y3QgUkFSX3N0YXQpCi0KLQotI2lmZGVmIF9fS0VSTkVMX18KLQotLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLS8qICAgICAgICAgICAgICAgS2VybmVsIFNpZGUgUkFSIEhhbmRsZXIgSW50ZXJmYWNlICAgICAgICAgICAgICAgICovCi0vKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotCi0vKioKLSAqIHN0cnVjdCBSQVJfYnVmZmVyIC0ga2VybmVsIHNwYWNlIHN0cnVjdCB0aGF0IGRlc2NyaWJlcyBSQVIgYnVmZmVyCi0gKiBAaW5mbzoJCXN0cnVjdHVyZSBjb250YWluaW5nIGJhc2UgUkFSIGJ1ZmZlciBpbmZvcm1hdGlvbgotICogQGJ1c19hZGRyZXNzOglidWZmZXIgYnVzIGFkZHJlc3MKLSAqCi0gKiBTdHJ1Y3R1cmUgdGhhdCBjb250YWlucyBhbGwgaW5mb3JtYXRpb24gcmVsYXRlZCB0byBhIGdpdmVuIGJsb2NrIG9mCi0gKiBtZW1vcnkgaW4gUkFSLiAgSXQgaXMgZ2VuZXJhbGx5IG9ubHkgdXNlZCB3aGVuIHJldHJpZXZpbmcgUkFSCi0gKiByZWxhdGVkIGJ1cyBhZGRyZXNzZXMuCi0gKgotICogTm90ZTogVGhpcyBzdHJ1Y3R1cmUgaXMgdXNlZCBvbmx5IGJ5IFJBUi1lbmFibGVkIGRyaXZlcnMsIGFuZCBpcwotICogICAgICAgbm90IGludGVuZGVkIHRvIGJlIGV4cG9zZWQgdG8gdGhlIHVzZXIgc3BhY2UuCi0gKi8KLXN0cnVjdCBSQVJfYnVmZmVyIHsKLQlzdHJ1Y3QgUkFSX2Jsb2NrX2luZm8gaW5mbzsKLQlkbWFfYWRkcl90IGJ1c19hZGRyZXNzOwotfTsKLQotI2lmIGRlZmluZWQoQ09ORklHX01SU1RfUkFSX0hBTkRMRVIpCi0vKioKLSAqIHJhcl9yZXNlcnZlKCkgLSByZXNlcnZlIFJBUiBidWZmZXJzCi0gKiBAYnVmZmVyczoJYXJyYXkgb2YgUkFSX2J1ZmZlcnMgd2hlcmUgdHlwZSBhbmQgc2l6ZSBvZiBidWZmZXJzIHRvCi0gKgkJcmVzZXJ2ZSBhcmUgcGFzc2VkIGluLCBoYW5kbGUgYW5kIGJ1cyBhZGRyZXNzIGFyZQotICoJCXBhc3NlZCBvdXQKLSAqIEBjb3VudDoJbnVtYmVyIG9mIFJBUl9idWZmZXJzIGluIHRoZSAiYnVmZmVycyIgYXJyYXkKLSAqCi0gKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmVzZXJ2ZSBidWZmZXJzIGluIHRoZSByZXN0cmljdGVkIGFjY2VzcyByZWdpb25zCi0gKiBvZiBnaXZlbiB0eXBlcy4KLSAqCi0gKiBJdCByZXR1cm5zIHRoZSBudW1iZXIgb2Ygc3VjY2Vzc2Z1bGx5IHJlc2VydmVkIGJ1ZmZlcnMuICBTdWNjZXNzZnVsCi0gKiBidWZmZXIgcmVzZXJ2YXRpb25zIHdpbGwgaGF2ZSB0aGUgY29ycmVzcG9uZGluZyBidXNfYWRkcmVzcyBmaWVsZAotICogc2V0IHRvIGEgbm9uLXplcm8gdmFsdWUgaW4gdGhlIGdpdmVuIGJ1ZmZlcnMgdmVjdG9yLgotICovCi1leHRlcm4gc2l6ZV90IHJhcl9yZXNlcnZlKHN0cnVjdCBSQVJfYnVmZmVyICpidWZmZXJzLAotCQkJICBzaXplX3QgY291bnQpOwotCi0vKioKLSAqIHJhcl9yZWxlYXNlKCkgLSByZWxlYXNlIFJBUiBidWZmZXJzCi0gKiBAYnVmZmVyczoJYXJyYXkgb2YgUkFSX2J1ZmZlcnMgd2hlcmUgaGFuZGxlcyB0byBidWZmZXJzIHRvIGJlCi0gKgkJcmVsZWFzZWQgYXJlIHBhc3NlZCBpbgotICogQGNvdW50OgludW1iZXIgb2YgUkFSX2J1ZmZlcnMgaW4gdGhlICJidWZmZXJzIiBhcnJheQotICoKLSAqIFRoaXMgZnVuY3Rpb24gd2lsbCByZWxlYXNlIFJBUiBidWZmZXJzIHRoYXQgd2VyZSByZXRyaWV2ZWQgdGhyb3VnaAotICogYSBjYWxsIHRvIHJhcl9yZXNlcnZlKCkgb3IgcmFyX2hhbmRsZV90b19idXMoKSBieSBkZWNyZW1lbnRpbmcgdGhlCi0gKiByZWZlcmVuY2UgY291bnQuICBUaGUgUkFSIGJ1ZmZlciB3aWxsIGJlIHJlY2xhaW1lZCB3aGVuIHRoZQotICogcmVmZXJlbmNlIGNvdW50IGRyb3BzIHRvIHplcm8uCi0gKgotICogSXQgcmV0dXJucyB0aGUgbnVtYmVyIG9mIHN1Y2Nlc3NmdWxseSByZWxlYXNlZCBidWZmZXJzLiAgU3VjY2Vzc2Z1bAotICogcmVsZWFzZXMgd2lsbCBoYXZlIHRoZWlyIGhhbmRsZSBmaWVsZCBzZXQgdG8gemVybyBpbiB0aGUgZ2l2ZW4KLSAqIGJ1ZmZlcnMgdmVjdG9yLgotICovCi1leHRlcm4gc2l6ZV90IHJhcl9yZWxlYXNlKHN0cnVjdCBSQVJfYnVmZmVyICpidWZmZXJzLAotCQkJICBzaXplX3QgY291bnQpOwotCi0vKioKLSAqIHJhcl9oYW5kbGVfdG9fYnVzKCkgLSBjb252ZXJ0IGEgdmVjdG9yIG9mIFJBUiBoYW5kbGVzIHRvIGJ1cyBhZGRyZXNzZXMKLSAqIEBidWZmZXJzOglhcnJheSBvZiBSQVJfYnVmZmVycyBjb250YWluaW5nIGhhbmRsZXMgdG8gYmUKLSAqCQljb252ZXJ0ZWQgdG8gYnVzX2FkZHJlc3NlcwotICogQGNvdW50OgludW1iZXIgb2YgUkFSX2J1ZmZlcnMgaW4gdGhlICJidWZmZXJzIiBhcnJheQotCi0gKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0cmlldmUgdGhlIFJBUiBidWZmZXIgYnVzIGFkZHJlc3NlcywgdHlwZSBhbmQKLSAqIHNpemUgY29ycmVzcG9uZGluZyB0byB0aGUgUkFSIGhhbmRsZXMgcHJvdmlkZWQgaW4gdGhlIGJ1ZmZlcnMKLSAqIHZlY3Rvci4KLSAqCi0gKiBJdCByZXR1cm5zIHRoZSBudW1iZXIgb2Ygc3VjY2Vzc2Z1bGx5IGNvbnZlcnRlZCBidWZmZXJzLiAgVGhlIGJ1cwotICogYWRkcmVzcyB3aWxsIGJlIHNldCB0byAwIGZvciB1bnJlY29nbml6ZWQgaGFuZGxlcy4KLSAqCi0gKiBUaGUgcmVmZXJlbmNlIGNvdW50IGZvciBlYWNoIGNvcnJlc3BvbmRpbmcgYnVmZmVyIGluIFJBUiB3aWxsIGJlCi0gKiBpbmNyZW1lbnRlZC4gIENhbGwgcmFyX3JlbGVhc2UoKSB3aGVuIGRvbmUgd2l0aCB0aGUgYnVmZmVycy4KLSAqLwotZXh0ZXJuIHNpemVfdCByYXJfaGFuZGxlX3RvX2J1cyhzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywKLQkJCQlzaXplX3QgY291bnQpOwotCi0jZWxzZQotCi1leHRlcm4gaW5saW5lIHNpemVfdCByYXJfcmVzZXJ2ZShzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywgc2l6ZV90IGNvdW50KQotewotCXJldHVybiAwOwotfQotCi1leHRlcm4gaW5saW5lIHNpemVfdCByYXJfcmVsZWFzZShzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywgc2l6ZV90IGNvdW50KQotewotCXJldHVybiAwOwotfQotCi1leHRlcm4gaW5saW5lIHNpemVfdCByYXJfaGFuZGxlX3RvX2J1cyhzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywKLQkJCQlzaXplX3QgY291bnQpCi17Ci0JcmV0dXJuIDA7Ci19Ci0KLSNlbmRpZiAgLyogTVJTVF9SQVJfSEFORExFUiAqLwotI2VuZGlmICAvKiBfX0tFUk5FTF9fICovCi0KLSNlbmRpZiAgLyogX01FTVJBUl9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL21lbXJhcl9hbGxvY2F0b3IuYyBiL2RyaXZlcnMvc3RhZ2luZy9tZW1yYXIvbWVtcmFyX2FsbG9jYXRvci5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBhNGY4YzU4Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9tZW1yYXIvbWVtcmFyX2FsbG9jYXRvci5jCisrKyAvZGV2L251bGwKQEAgLTEsNDMyICswLDAgQEAKLS8qCi0gKiAgICAgIG1lbXJhcl9hbGxvY2F0b3IgMS4wOiAgQW4gYWxsb2NhdG9yIGZvciBJbnRlbCBSQVIuCi0gKgotICogICAgICBDb3B5cmlnaHQgKEMpIDIwMTAgSW50ZWwgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogICAgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCi0gKiAgICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdmVyc2lvbiAyIG9mIHRoZSBHTlUgR2VuZXJhbAotICogICAgICBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiAgICAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUKLSAqICAgICAgdXNlZnVsLCBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZAotICogICAgICB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCi0gKiAgICAgIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKiAgICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYwotICogICAgICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlCi0gKiAgICAgIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKLSAqICAgICAgQm9zdG9uLCBNQSAgMDIxMTEtMTMwNywgVVNBLgotICogICAgICBUaGUgZnVsbCBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBpcyBpbmNsdWRlZCBpbiB0aGlzCi0gKiAgICAgIGRpc3RyaWJ1dGlvbiBpbiB0aGUgZmlsZSBjYWxsZWQgQ09QWUlORy4KLSAqCi0gKgotICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICoKLSAqICAgICAgVGhpcyBzaW1wbGUgYWxsb2NhdG9yIGltcGxlbWVudGF0aW9uIHByb3ZpZGVzIGEKLSAqICAgICAgbWFsbG9jKCkvZnJlZSgpLWxpa2UgaW50ZXJmYWNlIGZvciByZXNlcnZpbmcgc3BhY2Ugd2l0aGluIGEKLSAqICAgICAgcHJldmlvdXNseSByZXNlcnZlZCBibG9jayBvZiBtZW1vcnkuICBJdCBpcyBub3Qgc3BlY2lmaWMgdG8KLSAqICAgICAgYW55IGhhcmR3YXJlLCBub3IgaXMgaXQgY291cGxlZCB3aXRoIHRoZSBsb3dlciBsZXZlbCBwYWdpbmcKLSAqICAgICAgbWVjaGFuaXNtLgotICoKLSAqICAgICAgVGhlIHByaW1hcnkgZ29hbCBvZiB0aGlzIGltcGxlbWVudGF0aW9uIGlzIHRvIHByb3ZpZGUgYSBtZWFucwotICogICAgICB0byBwYXJ0aXRpb24gYW4gYXJiaXRyYXJ5IGJsb2NrIG9mIG1lbW9yeSB3aXRob3V0IGFjdHVhbGx5Ci0gKiAgICAgIGFjY2Vzc2luZyB0aGUgbWVtb3J5IG9yIGluY3VycmluZyBhbnkgaGFyZHdhcmUgc2lkZS1lZmZlY3RzCi0gKiAgICAgIChlLmcuIHBhZ2luZykuICBJdCBpcywgaW4gZWZmZWN0LCBhIGJvb2trZWVwaW5nIG1lY2hhbmlzbSBmb3IKLSAqICAgICAgYnVmZmVycy4KLSAqLwotCi0KLSNpbmNsdWRlICJtZW1yYXJfYWxsb2NhdG9yLmgiCi0jaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4L2J1Zy5oPgotI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgotCi0KLXN0cnVjdCBtZW1yYXJfYWxsb2NhdG9yICptZW1yYXJfY3JlYXRlX2FsbG9jYXRvcih1bnNpZ25lZCBsb25nIGJhc2UsCi0JCQkJCQkgc2l6ZV90IGNhcGFjaXR5LAotCQkJCQkJIHNpemVfdCBibG9ja19zaXplKQotewotCXN0cnVjdCBtZW1yYXJfYWxsb2NhdG9yICphbGxvY2F0b3IgID0gTlVMTDsKLQlzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzICpmaXJzdF9ub2RlID0gTlVMTDsKLQotCS8qCi0JICogTWFrZSBzdXJlIHRoZSBiYXNlIGFkZHJlc3MgaXMgYWxpZ25lZCBvbiBhIGJsb2NrX3NpemUKLQkgKiBib3VuZGFyeS4KLQkgKgotCSAqIEB0b2RvIElzIHRoaXMgbmVjZXNzYXJ5PwotCSAqLwotCS8qIGJhc2UgPSBBTElHTihiYXNlLCBibG9ja19zaXplKTsgKi8KLQotCS8qIFZhbGlkYXRlIHBhcmFtZXRlcnMuCi0JICoKLQkgKiBNYWtlIHN1cmUgd2UgY2FuIGFsbG9jYXRlIHRoZSBlbnRpcmUgbWVtb3J5IHNwYWNlLiAgWmVybwotCSAqIGNhcGFjaXR5IG9yIGJsb2NrIHNpemUgYXJlIG9idmlvdXNseSBpbnZhbGlkLgotCSAqLwotCWlmIChiYXNlID09IDAKLQkgICAgfHwgY2FwYWNpdHkgPT0gMAotCSAgICB8fCBibG9ja19zaXplID09IDAKLQkgICAgfHwgVUxPTkdfTUFYIC0gY2FwYWNpdHkgPCBiYXNlCi0JICAgIHx8IGNhcGFjaXR5IDwgYmxvY2tfc2l6ZSkKLQkJcmV0dXJuIGFsbG9jYXRvcjsKLQotCS8qCi0JICogVGhlcmUgaXNuJ3QgbXVjaCBwb2ludCBpbiBjcmVhdGluZyBhIG1lbW9yeSBhbGxvY2F0b3IgdGhhdAotCSAqIGlzIG9ubHkgY2FwYWJsZSBvZiBob2xkaW5nIG9uZSBibG9jayBidXQgd2UnbGwgYWxsb3cgaXQsCi0JICogYW5kIGlzc3VlIGEgZGlhZ25vc3RpYy4KLQkgKi8KLQlXQVJOKGNhcGFjaXR5IDwgYmxvY2tfc2l6ZSAqIDIsCi0JICAgICAibWVtcmFyOiBPbmx5IG9uZSBibG9jayBhdmFpbGFibGUgdG8gYWxsb2NhdG9yLlxuIik7Ci0KLQlhbGxvY2F0b3IgPSBrbWFsbG9jKHNpemVvZigqYWxsb2NhdG9yKSwgR0ZQX0tFUk5FTCk7Ci0KLQlpZiAoYWxsb2NhdG9yID09IE5VTEwpCi0JCXJldHVybiBhbGxvY2F0b3I7Ci0KLQltdXRleF9pbml0KCZhbGxvY2F0b3ItPmxvY2spOwotCWFsbG9jYXRvci0+YmFzZSA9IGJhc2U7Ci0KLQkvKiBSb3VuZCB0aGUgY2FwYWNpdHkgZG93biB0byBhIG11bHRpcGxlIG9mIGJsb2NrX3NpemUuICovCi0JYWxsb2NhdG9yLT5jYXBhY2l0eSA9IChjYXBhY2l0eSAvIGJsb2NrX3NpemUpICogYmxvY2tfc2l6ZTsKLQotCWFsbG9jYXRvci0+YmxvY2tfc2l6ZSA9IGJsb2NrX3NpemU7Ci0KLQlhbGxvY2F0b3ItPmxhcmdlc3RfZnJlZV9hcmVhID0gYWxsb2NhdG9yLT5jYXBhY2l0eTsKLQotCS8qIEluaXRpYWxpemUgdGhlIGhhbmRsZSBhbmQgZnJlZSBsaXN0cy4gKi8KLQlJTklUX0xJU1RfSEVBRCgmYWxsb2NhdG9yLT5hbGxvY2F0ZWRfbGlzdC5saXN0KTsKLQlJTklUX0xJU1RfSEVBRCgmYWxsb2NhdG9yLT5mcmVlX2xpc3QubGlzdCk7Ci0KLQlmaXJzdF9ub2RlID0ga21hbGxvYyhzaXplb2YoKmZpcnN0X25vZGUpLCBHRlBfS0VSTkVMKTsKLQlpZiAoZmlyc3Rfbm9kZSA9PSBOVUxMKQl7Ci0JCWtmcmVlKGFsbG9jYXRvcik7Ci0JCWFsbG9jYXRvciA9IE5VTEw7Ci0JfSBlbHNlIHsKLQkJLyogRnVsbCByYW5nZSBvZiBibG9ja3MgaXMgYXZhaWxhYmxlLiAqLwotCQlmaXJzdF9ub2RlLT5yYW5nZS5iZWdpbiA9IGJhc2U7Ci0JCWZpcnN0X25vZGUtPnJhbmdlLmVuZCAgID0gYmFzZSArIGFsbG9jYXRvci0+Y2FwYWNpdHk7Ci0JCWxpc3RfYWRkKCZmaXJzdF9ub2RlLT5saXN0LAotCQkJICZhbGxvY2F0b3ItPmZyZWVfbGlzdC5saXN0KTsKLQl9Ci0KLQlyZXR1cm4gYWxsb2NhdG9yOwotfQotCi12b2lkIG1lbXJhcl9kZXN0cm95X2FsbG9jYXRvcihzdHJ1Y3QgbWVtcmFyX2FsbG9jYXRvciAqYWxsb2NhdG9yKQotewotCS8qCi0JICogQXNzdW1lIHRoYXQgdGhlIG1lbW9yeSBhbGxvY2F0b3IgbG9jayBpc24ndCBoZWxkIGF0IHRoaXMKLQkgKiBwb2ludCBpbiB0aW1lLiAgQ2FsbGVyIG11c3QgZW5zdXJlIHRoYXQuCi0JICovCi0KLQlzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzICpwb3MgPSBOVUxMOwotCXN0cnVjdCBtZW1yYXJfYWRkcmVzc19yYW5nZXMgKm4gICA9IE5VTEw7Ci0KLQlpZiAoYWxsb2NhdG9yID09IE5VTEwpCi0JCXJldHVybjsKLQotCW11dGV4X2xvY2soJmFsbG9jYXRvci0+bG9jayk7Ci0KLQkvKiBSZWNsYWltIGZyZWUgbGlzdCByZXNvdXJjZXMuICovCi0JbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHBvcywKLQkJCQkgbiwKLQkJCQkgJmFsbG9jYXRvci0+ZnJlZV9saXN0Lmxpc3QsCi0JCQkJIGxpc3QpIHsKLQkJbGlzdF9kZWwoJnBvcy0+bGlzdCk7Ci0JCWtmcmVlKHBvcyk7Ci0JfQotCi0JbXV0ZXhfdW5sb2NrKCZhbGxvY2F0b3ItPmxvY2spOwotCi0Ja2ZyZWUoYWxsb2NhdG9yKTsKLX0KLQotdW5zaWduZWQgbG9uZyBtZW1yYXJfYWxsb2NhdG9yX2FsbG9jKHN0cnVjdCBtZW1yYXJfYWxsb2NhdG9yICphbGxvY2F0b3IsCi0JCQkJICAgICBzaXplX3Qgc2l6ZSkKLXsKLQlzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzICpwb3MgPSBOVUxMOwotCi0Jc2l6ZV90IG51bV9ibG9ja3M7Ci0JdW5zaWduZWQgbG9uZyByZXNlcnZlZF9ieXRlczsKLQotCS8qCi0JICogQWRkcmVzcyBvZiBhbGxvY2F0ZWQgYnVmZmVyLiAgV2UgYXNzdW1lIHRoYXQgemVybyBpcyBub3QgYQotCSAqIHZhbGlkIGFkZHJlc3MuCi0JICovCi0JdW5zaWduZWQgbG9uZyBhZGRyID0gMDsKLQotCWlmIChhbGxvY2F0b3IgPT0gTlVMTCB8fCBzaXplID09IDApCi0JCXJldHVybiBhZGRyOwotCi0JLyogUmVzZXJ2ZSBlbm91Z2ggYmxvY2tzIHRvIGhvbGQgdGhlIGFtb3VudCBvZiBieXRlcyByZXF1ZXN0ZWQuICovCi0JbnVtX2Jsb2NrcyA9IERJVl9ST1VORF9VUChzaXplLCBhbGxvY2F0b3ItPmJsb2NrX3NpemUpOwotCi0JcmVzZXJ2ZWRfYnl0ZXMgPSBudW1fYmxvY2tzICogYWxsb2NhdG9yLT5ibG9ja19zaXplOwotCi0JbXV0ZXhfbG9jaygmYWxsb2NhdG9yLT5sb2NrKTsKLQotCWlmIChyZXNlcnZlZF9ieXRlcyA+IGFsbG9jYXRvci0+bGFyZ2VzdF9mcmVlX2FyZWEpIHsKLQkJbXV0ZXhfdW5sb2NrKCZhbGxvY2F0b3ItPmxvY2spOwotCQlyZXR1cm4gYWRkcjsKLQl9Ci0KLQkvKgotCSAqIEl0ZXJhdGUgdGhyb3VnaCB0aGUgZnJlZSBsaXN0IHRvIGZpbmQgYSBzdWl0YWJseSBzaXplZAotCSAqIHJhbmdlIG9mIGZyZWUgY29udGlndW91cyBtZW1vcnkgYmxvY2tzLgotCSAqCi0JICogV2UgYWxzbyB0YWtlIHRoZSBvcHBvcnR1bml0eSB0byByZXNldCB0aGUgc2l6ZSBvZiB0aGUKLQkgKiBsYXJnZXN0IGZyZWUgYXJlYSBzaXplIHN0YXRpc3RpYy4KLQkgKi8KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJmFsbG9jYXRvci0+ZnJlZV9saXN0Lmxpc3QsIGxpc3QpIHsKLQkJc3RydWN0IG1lbXJhcl9hZGRyZXNzX3JhbmdlICogY29uc3QgZnIgPSAmcG9zLT5yYW5nZTsKLQkJc2l6ZV90IGNvbnN0IGN1cnJfc2l6ZSA9IGZyLT5lbmQgLSBmci0+YmVnaW47Ci0KLQkJaWYgKGN1cnJfc2l6ZSA+PSByZXNlcnZlZF9ieXRlcyAmJiBhZGRyID09IDApIHsKLQkJCXN0cnVjdCBtZW1yYXJfYWRkcmVzc19yYW5nZSAqcmFuZ2UgPSBOVUxMOwotCQkJc3RydWN0IG1lbXJhcl9hZGRyZXNzX3JhbmdlcyAqIGNvbnN0IG5ld19ub2RlID0KLQkJCQlrbWFsbG9jKHNpemVvZigqbmV3X25vZGUpLCBHRlBfS0VSTkVMKTsKLQotCQkJaWYgKG5ld19ub2RlID09IE5VTEwpCi0JCQkJYnJlYWs7Ci0KLQkJCWxpc3RfYWRkKCZuZXdfbm9kZS0+bGlzdCwKLQkJCQkgJmFsbG9jYXRvci0+YWxsb2NhdGVkX2xpc3QubGlzdCk7Ci0KLQkJCS8qCi0JCQkgKiBDYXJ2ZSBvdXQgYXJlYSBvZiBtZW1vcnkgZnJvbSBlbmQgb2YgZnJlZQotCQkJICogcmFuZ2UuCi0JCQkgKi8KLQkJCXJhbmdlICAgICAgICA9ICZuZXdfbm9kZS0+cmFuZ2U7Ci0JCQlyYW5nZS0+ZW5kICAgPSBmci0+ZW5kOwotCQkJZnItPmVuZCAgICAgLT0gcmVzZXJ2ZWRfYnl0ZXM7Ci0JCQlyYW5nZS0+YmVnaW4gPSBmci0+ZW5kOwotCQkJYWRkciAgICAgICAgID0gcmFuZ2UtPmJlZ2luOwotCi0JCQkvKgotCQkJICogQ2hlY2sgaWYgbGFyZ2VzdCBhcmVhIGhhcyBkZWNyZWFzZWQgaW4KLQkJCSAqIHNpemUuICBXZSdsbCBuZWVkIHRvIGNvbnRpbnVlIHNjYW5uaW5nIGZvcgotCQkJICogdGhlIG5leHQgbGFyZ2VzdCBhcmVhIGlmIGl0IGhhcy4KLQkJCSAqLwotCQkJaWYgKGN1cnJfc2l6ZSA9PSBhbGxvY2F0b3ItPmxhcmdlc3RfZnJlZV9hcmVhKQotCQkJCWFsbG9jYXRvci0+bGFyZ2VzdF9mcmVlX2FyZWEgLT0KLQkJCQkJcmVzZXJ2ZWRfYnl0ZXM7Ci0JCQllbHNlCi0JCQkJYnJlYWs7Ci0JCX0KLQotCQkvKgotCQkgKiBSZXNldCBsYXJnZXN0IGZyZWUgYXJlYSBzaXplIHN0YXRpc3RpYyBhcyBuZWVkZWQsCi0JCSAqIGJ1dCBvbmx5IGlmIHdlJ3ZlIGFjdHVhbGx5IGFsbG9jYXRlZCBtZW1vcnkuCi0JCSAqLwotCQlpZiAoYWRkciAhPSAwCi0JCSAgICAmJiBjdXJyX3NpemUgPiBhbGxvY2F0b3ItPmxhcmdlc3RfZnJlZV9hcmVhKSB7Ci0JCQlhbGxvY2F0b3ItPmxhcmdlc3RfZnJlZV9hcmVhID0gY3Vycl9zaXplOwotCQkJYnJlYWs7Ci0JCX0KLQl9Ci0KLQltdXRleF91bmxvY2soJmFsbG9jYXRvci0+bG9jayk7Ci0KLQlyZXR1cm4gYWRkcjsKLX0KLQotbG9uZyBtZW1yYXJfYWxsb2NhdG9yX2ZyZWUoc3RydWN0IG1lbXJhcl9hbGxvY2F0b3IgKmFsbG9jYXRvciwKLQkJCSAgIHVuc2lnbmVkIGxvbmcgYWRkcikKLXsKLQlzdHJ1Y3QgbGlzdF9oZWFkICpwb3MgPSBOVUxMOwotCXN0cnVjdCBsaXN0X2hlYWQgKnRtcCA9IE5VTEw7Ci0Jc3RydWN0IGxpc3RfaGVhZCAqZHN0ID0gTlVMTDsKLQotCXN0cnVjdCBtZW1yYXJfYWRkcmVzc19yYW5nZXMgICAgICAqYWxsb2NhdGVkID0gTlVMTDsKLQlzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2UgY29uc3QgKmhhbmRsZSAgICA9IE5VTEw7Ci0KLQl1bnNpZ25lZCBsb25nIG9sZF9lbmQgICAgICAgID0gMDsKLQl1bnNpZ25lZCBsb25nIG5ld19jaHVua19zaXplID0gMDsKLQotCWlmIChhbGxvY2F0b3IgPT0gTlVMTCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAoYWRkciA9PSAwKQotCQlyZXR1cm4gMDsgIC8qIElnbm9yZSAiZnJlZSgwKSIuICovCi0KLQltdXRleF9sb2NrKCZhbGxvY2F0b3ItPmxvY2spOwotCi0JLyogRmluZCB0aGUgY29ycmVzcG9uZGluZyBoYW5kbGUuICovCi0JbGlzdF9mb3JfZWFjaF9lbnRyeShhbGxvY2F0ZWQsCi0JCQkgICAgJmFsbG9jYXRvci0+YWxsb2NhdGVkX2xpc3QubGlzdCwKLQkJCSAgICBsaXN0KSB7Ci0JCWlmIChhbGxvY2F0ZWQtPnJhbmdlLmJlZ2luID09IGFkZHIpIHsKLQkJCWhhbmRsZSA9ICZhbGxvY2F0ZWQtPnJhbmdlOwotCQkJYnJlYWs7Ci0JCX0KLQl9Ci0KLQkvKiBObyBzdWNoIGJ1ZmZlciBjcmVhdGVkIGJ5IHRoaXMgYWxsb2NhdG9yLiAqLwotCWlmIChoYW5kbGUgPT0gTlVMTCkgewotCQltdXRleF91bmxvY2soJmFsbG9jYXRvci0+bG9jayk7Ci0JCXJldHVybiAtRUZBVUxUOwotCX0KLQotCS8qCi0JICogQ29hbGVzY2UgYWRqYWNlbnQgY2h1bmtzIG9mIG1lbW9yeSBpZiBwb3NzaWJsZS4KLQkgKgotCSAqIEBub3RlIFRoaXMgaXNuJ3QgZnVsbCBibG93biBjb2FsZXNjaW5nIHNpbmNlIHdlJ3JlIG9ubHkKLQkgKiAgICAgICBjb2FsZXNjaW5nIGF0IG1vc3QgdGhyZWUgY2h1bmtzIG9mIG1lbW9yeS4KLQkgKi8KLQlsaXN0X2Zvcl9lYWNoX3NhZmUocG9zLCB0bXAsICZhbGxvY2F0b3ItPmZyZWVfbGlzdC5saXN0KSB7Ci0JCS8qIEB0b2RvIE8obikgcGVyZm9ybWFuY2UuICBPcHRpbWl6ZS4gKi8KLQotCQlzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2UgKiBjb25zdCBjaHVuayA9Ci0JCQkmbGlzdF9lbnRyeShwb3MsCi0JCQkJICAgIHN0cnVjdCBtZW1yYXJfYWRkcmVzc19yYW5nZXMsCi0JCQkJICAgIGxpc3QpLT5yYW5nZTsKLQotCQkvKiBFeHRlbmQgc2l6ZSBvZiBleGlzdGluZyBmcmVlIGFkamFjZW50IGNodW5rLiAqLwotCQlpZiAoY2h1bmstPmVuZCA9PSBoYW5kbGUtPmJlZ2luKSB7Ci0JCQkvKgotCQkJICogQ2h1bmsgImxlc3MgdGhhbiIgdGhhbiB0aGUgb25lIHdlJ3JlCi0JCQkgKiBmcmVlaW5nIGlzIGFkamFjZW50LgotCQkJICoKLQkJCSAqIEJlZm9yZToKLQkJCSAqCi0JCQkgKiAgICstLS0tLSstLS0tLS0rCi0JCQkgKiAgIHxjaHVua3xoYW5kbGV8Ci0JCQkgKiAgICstLS0tLSstLS0tLS0rCi0JCQkgKgotCQkJICogQWZ0ZXI6Ci0JCQkgKgotCQkJICogICArLS0tLS0tLS0tLS0tKwotCQkJICogICB8ICAgY2h1bmsgICAgfAotCQkJICogICArLS0tLS0tLS0tLS0tKwotCQkJICovCi0KLQkJCXN0cnVjdCBtZW1yYXJfYWRkcmVzc19yYW5nZXMgY29uc3QgKiBjb25zdCBuZXh0ID0KLQkJCQlsaXN0X2VudHJ5KHBvcy0+bmV4dCwKLQkJCQkJICAgc3RydWN0IG1lbXJhcl9hZGRyZXNzX3JhbmdlcywKLQkJCQkJICAgbGlzdCk7Ci0KLQkJCWNodW5rLT5lbmQgPSBoYW5kbGUtPmVuZDsKLQotCQkJLyoKLQkJCSAqIE5vdyBjaGVjayBpZiBuZXh0IGZyZWUgY2h1bmsgaXMgYWRqYWNlbnQgdG8KLQkJCSAqIHRoZSBjdXJyZW50IGV4dGVuZGVkIGZyZWUgY2h1bmsuCi0JCQkgKgotCQkJICogQmVmb3JlOgotCQkJICoKLQkJCSAqICAgKy0tLS0tLS0tLS0tLSstLS0tKwotCQkJICogICB8ICAgY2h1bmsgICAgfG5leHR8Ci0JCQkgKiAgICstLS0tLS0tLS0tLS0rLS0tLSsKLQkJCSAqCi0JCQkgKiBBZnRlcjoKLQkJCSAqCi0JCQkgKiAgICstLS0tLS0tLS0tLS0tLS0tLSsKLQkJCSAqICAgfCAgICAgIGNodW5rICAgICAgfAotCQkJICogICArLS0tLS0tLS0tLS0tLS0tLS0rCi0JCQkgKi8KLQkJCWlmICghbGlzdF9pc19zaW5ndWxhcihwb3MpCi0JCQkgICAgJiYgY2h1bmstPmVuZCA9PSBuZXh0LT5yYW5nZS5iZWdpbikgewotCQkJCWNodW5rLT5lbmQgPSBuZXh0LT5yYW5nZS5lbmQ7Ci0JCQkJbGlzdF9kZWwocG9zLT5uZXh0KTsKLQkJCQlrZnJlZShuZXh0KTsKLQkJCX0KLQotCQkJbGlzdF9kZWwoJmFsbG9jYXRlZC0+bGlzdCk7Ci0KLQkJCW5ld19jaHVua19zaXplID0gY2h1bmstPmVuZCAtIGNodW5rLT5iZWdpbjsKLQotCQkJZ290byBleGl0X21lbXJhcl9mcmVlOwotCi0JCX0gZWxzZSBpZiAoaGFuZGxlLT5lbmQgPT0gY2h1bmstPmJlZ2luKSB7Ci0JCQkvKgotCQkJICogQ2h1bmsgImdyZWF0ZXIgdGhhbiIgdGhhbiB0aGUgb25lIHdlJ3JlCi0JCQkgKiBmcmVlaW5nIGlzIGFkamFjZW50LgotCQkJICoKLQkJCSAqICAgKy0tLS0tLSstLS0tLSsKLQkJCSAqICAgfGhhbmRsZXxjaHVua3wKLQkJCSAqICAgKy0tLS0tLSstLS0tLSsKLQkJCSAqCi0JCQkgKiBBZnRlcjoKLQkJCSAqCi0JCQkgKiAgICstLS0tLS0tLS0tLS0rCi0JCQkgKiAgIHwgICBjaHVuayAgICB8Ci0JCQkgKiAgICstLS0tLS0tLS0tLS0rCi0JCQkgKi8KLQotCQkJc3RydWN0IG1lbXJhcl9hZGRyZXNzX3JhbmdlcyBjb25zdCAqIGNvbnN0IHByZXYgPQotCQkJCWxpc3RfZW50cnkocG9zLT5wcmV2LAotCQkJCQkgICBzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzLAotCQkJCQkgICBsaXN0KTsKLQotCQkJY2h1bmstPmJlZ2luID0gaGFuZGxlLT5iZWdpbjsKLQotCQkJLyoKLQkJCSAqIE5vdyBjaGVjayBpZiBwcmV2aW91cyBmcmVlIGNodW5rIGlzCi0JCQkgKiBhZGphY2VudCB0byB0aGUgY3VycmVudCBleHRlbmRlZCBmcmVlCi0JCQkgKiBjaHVuay4KLQkJCSAqCi0JCQkgKgotCQkJICogQmVmb3JlOgotCQkJICoKLQkJCSAqICAgKy0tLS0rLS0tLS0tLS0tLS0tKwotCQkJICogICB8cHJldnwgICBjaHVuayAgICB8Ci0JCQkgKiAgICstLS0tKy0tLS0tLS0tLS0tLSsKLQkJCSAqCi0JCQkgKiBBZnRlcjoKLQkJCSAqCi0JCQkgKiAgICstLS0tLS0tLS0tLS0tLS0tLSsKLQkJCSAqICAgfCAgICAgIGNodW5rICAgICAgfAotCQkJICogICArLS0tLS0tLS0tLS0tLS0tLS0rCi0JCQkgKi8KLQkJCWlmICghbGlzdF9pc19zaW5ndWxhcihwb3MpCi0JCQkgICAgJiYgcHJldi0+cmFuZ2UuZW5kID09IGNodW5rLT5iZWdpbikgewotCQkJCWNodW5rLT5iZWdpbiA9IHByZXYtPnJhbmdlLmJlZ2luOwotCQkJCWxpc3RfZGVsKHBvcy0+cHJldik7Ci0JCQkJa2ZyZWUocHJldik7Ci0JCQl9Ci0KLQkJCWxpc3RfZGVsKCZhbGxvY2F0ZWQtPmxpc3QpOwotCi0JCQluZXdfY2h1bmtfc2l6ZSA9IGNodW5rLT5lbmQgLSBjaHVuay0+YmVnaW47Ci0KLQkJCWdvdG8gZXhpdF9tZW1yYXJfZnJlZTsKLQotCQl9IGVsc2UgaWYgKGNodW5rLT5lbmQgPCBoYW5kbGUtPmJlZ2luCi0JCQkgICAmJiBjaHVuay0+ZW5kID4gb2xkX2VuZCkgewotCQkJLyogS2VlcCB0cmFjayBvZiB3aGVyZSB0aGUgZW50cnkgY291bGQgYmUKLQkJCSAqIHBvdGVudGlhbGx5IG1vdmVkIGZyb20gdGhlICJhbGxvY2F0ZWQiIGxpc3QKLQkJCSAqIHRvIHRoZSAiZnJlZSIgbGlzdCBpZiBjb2FsZXNjaW5nIGRvZXNuJ3QKLQkJCSAqIG9jY3VyLCBtYWtpbmcgc3VyZSB0aGUgImZyZWUiIGxpc3QgcmVtYWlucwotCQkJICogc29ydGVkLgotCQkJICovCi0JCQlvbGRfZW5kID0gY2h1bmstPmVuZDsKLQkJCWRzdCA9IHBvczsKLQkJfQotCX0KLQotCS8qCi0JICogTm90aGluZyB0byBjb2FsZXNjZS4KLQkgKgotCSAqIE1vdmUgdGhlIGVudHJ5IGZyb20gdGhlICJhbGxvY2F0ZWQiIGxpc3QgdG8gdGhlICJmcmVlIgotCSAqIGxpc3QuCi0JICovCi0JbGlzdF9tb3ZlKCZhbGxvY2F0ZWQtPmxpc3QsIGRzdCk7Ci0JbmV3X2NodW5rX3NpemUgPSBoYW5kbGUtPmVuZCAtIGhhbmRsZS0+YmVnaW47Ci0JYWxsb2NhdGVkID0gTlVMTDsKLQotZXhpdF9tZW1yYXJfZnJlZToKLQotCWlmIChuZXdfY2h1bmtfc2l6ZSA+IGFsbG9jYXRvci0+bGFyZ2VzdF9mcmVlX2FyZWEpCi0JCWFsbG9jYXRvci0+bGFyZ2VzdF9mcmVlX2FyZWEgPSBuZXdfY2h1bmtfc2l6ZTsKLQotCW11dGV4X3VubG9jaygmYWxsb2NhdG9yLT5sb2NrKTsKLQotCWtmcmVlKGFsbG9jYXRlZCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi0KLS8qCi0gIExvY2FsIFZhcmlhYmxlczoKLSAgICBjLWZpbGUtc3R5bGU6ICJsaW51eCIKLSAgRW5kOgotKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9tZW1yYXIvbWVtcmFyX2FsbG9jYXRvci5oIGIvZHJpdmVycy9zdGFnaW5nL21lbXJhci9tZW1yYXJfYWxsb2NhdG9yLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDBiODBkZWEuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9tZW1yYXJfYWxsb2NhdG9yLmgKKysrIC9kZXYvbnVsbApAQCAtMSwxNDkgKzAsMCBAQAotLyoKLSAqICAgICAgQ29weXJpZ2h0IChDKSAyMDEwIEludGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqICAgICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgotICogICAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwKLSAqICAgICAgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogICAgICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlCi0gKiAgICAgIHVzZWZ1bCwgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQKLSAqICAgICAgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogICAgICBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICogICAgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMKLSAqICAgICAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQotICogICAgICBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCi0gKiAgICAgIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcsIFVTQS4KLSAqICAgICAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcwotICogICAgICBkaXN0cmlidXRpb24gaW4gdGhlIGZpbGUgY2FsbGVkIENPUFlJTkcuCi0gKi8KLQotI2lmbmRlZiBNRU1SQVJfQUxMT0NBVE9SX0gKLSNkZWZpbmUgTUVNUkFSX0FMTE9DQVRPUl9ICi0KLQotI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Ci0jaW5jbHVkZSA8bGludXgvbGlzdC5oPgotI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Ci0jaW5jbHVkZSA8bGludXgva2VybmVsLmg+Ci0KLQotLyoqCi0gKiBzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2UgLSBzdHJ1Y3QgdGhhdCBkZXNjcmliZXMgYSBtZW1vcnkgcmFuZ2UKLSAqIEBiZWdpbjoJQmVnaW5uaW5nIG9mIGF2YWlsYWJsZSBhZGRyZXNzIHJhbmdlLgotICogQGVuZDoJRW5kIG9mIGF2YWlsYWJsZSBhZGRyZXNzIHJhbmdlLCBvbmUgcGFzdCB0aGUgZW5kLAotICoJCWkuZS4gW2JlZ2luLCBlbmQpLgotICovCi1zdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2UgewotLyogcHJpdmF0ZTogaW50ZXJuYWwgdXNlIG9ubHkgKi8KLQl1bnNpZ25lZCBsb25nIGJlZ2luOwotCXVuc2lnbmVkIGxvbmcgZW5kOwotfTsKLQotLyoqCi0gKiBzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzIC0gbGlzdCBvZiBhcmVhcyBvZiBtZW1vcnkuCi0gKiBAbGlzdDoJTGlua2VkIGxpc3Qgb2YgYWRkcmVzcyByYW5nZXMuCi0gKiBAcmFuZ2U6CU1lbW9yeSBhZGRyZXNzIHJhbmdlIGNvcnJlc3BvbmRpbmcgdG8gZ2l2ZW4gbGlzdCBub2RlLgotICovCi1zdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzIHsKLS8qIHByaXZhdGU6IGludGVybmFsIHVzZSBvbmx5ICovCi0Jc3RydWN0IGxpc3RfaGVhZCBsaXN0OwotCXN0cnVjdCBtZW1yYXJfYWRkcmVzc19yYW5nZSByYW5nZTsKLX07Ci0KLS8qKgotICogc3RydWN0IG1lbXJhcl9hbGxvY2F0b3IgLSBlbmNhcHN1bGF0aW9uIG9mIHRoZSBtZW1vcnkgYWxsb2NhdG9yIHN0YXRlCi0gKiBAbG9jazoJCUxvY2sgdXNlZCB0byBzeW5jaHJvbml6ZSBhY2Nlc3MgdG8gdGhlIG1lbW9yeQotICoJCQlhbGxvY2F0b3Igc3RhdGUuCi0gKiBAYmFzZToJCUJhc2UgKHN0YXJ0KSBhZGRyZXNzIG9mIHRoZSBhbGxvY2F0b3IgbWVtb3J5Ci0gKgkJCXNwYWNlLgotICogQGNhcGFjaXR5OgkJU2l6ZSBvZiB0aGUgYWxsb2NhdG9yIG1lbW9yeSBzcGFjZSBpbiBieXRlcy4KLSAqIEBibG9ja19zaXplOgkJVGhlIHNpemUgaW4gYnl0ZXMgb2YgaW5kaXZpZHVhbCBibG9ja3Mgd2l0aGluCi0gKgkJCXRoZSBhbGxvY2F0b3IgbWVtb3J5IHNwYWNlLgotICogQGxhcmdlc3RfZnJlZV9hcmVhOglMYXJnZXN0IGZyZWUgYXJlYSBvZiBtZW1vcnkgaW4gdGhlIGFsbG9jYXRvcgotICoJCQlpbiBieXRlcy4KLSAqIEBhbGxvY2F0ZWRfbGlzdDoJTGlzdCBvZiBhbGxvY2F0ZWQgbWVtb3J5IGJsb2NrIGFkZHJlc3MKLSAqCQkJcmFuZ2VzLgotICogQGZyZWVfbGlzdDoJCUxpc3Qgb2YgZnJlZSBhZGRyZXNzIHJhbmdlcy4KLSAqCi0gKiBUaGlzIHN0cnVjdHVyZSBjb250YWlucyBhbGwgbWVtb3J5IGFsbG9jYXRvciBzdGF0ZSwgaW5jbHVkaW5nIHRoZQotICogYmFzZSBhZGRyZXNzLCBjYXBhY2l0eSwgZnJlZSBsaXN0LCBsb2NrLCBldGMuCi0gKi8KLXN0cnVjdCBtZW1yYXJfYWxsb2NhdG9yIHsKLS8qIHByaXZhdGU6IGludGVybmFsIHVzZSBvbmx5ICovCi0Jc3RydWN0IG11dGV4IGxvY2s7Ci0JdW5zaWduZWQgbG9uZyBiYXNlOwotCXNpemVfdCBjYXBhY2l0eTsKLQlzaXplX3QgYmxvY2tfc2l6ZTsKLQlzaXplX3QgbGFyZ2VzdF9mcmVlX2FyZWE7Ci0Jc3RydWN0IG1lbXJhcl9hZGRyZXNzX3JhbmdlcyBhbGxvY2F0ZWRfbGlzdDsKLQlzdHJ1Y3QgbWVtcmFyX2FkZHJlc3NfcmFuZ2VzIGZyZWVfbGlzdDsKLX07Ci0KLS8qKgotICogbWVtcmFyX2NyZWF0ZV9hbGxvY2F0b3IoKSAtIGNyZWF0ZSBhIG1lbW9yeSBhbGxvY2F0b3IKLSAqIEBiYXNlOglBZGRyZXNzIGF0IHdoaWNoIHRoZSBtZW1vcnkgYWxsb2NhdG9yIGJlZ2lucy4KLSAqIEBjYXBhY2l0eToJRGVzaXJlZCBzaXplIG9mIHRoZSBtZW1vcnkgYWxsb2NhdG9yLiAgVGhpcyB2YWx1ZSBtdXN0Ci0gKgkJYmUgbGFyZ2VyIHRoYW4gdGhlIGJsb2NrX3NpemUsIGlkZWFsbHkgbW9yZSB0aGFuIHR3aWNlCi0gKgkJYXMgbGFyZ2Ugc2luY2UgdGhlcmUgd291bGRuJ3QgYmUgbXVjaCBwb2ludCBpbiB1c2luZyBhCi0gKgkJbWVtb3J5IGFsbG9jYXRvciBvdGhlcndpc2UuCi0gKiBAYmxvY2tfc2l6ZToJVGhlIHNpemUgb2YgaW5kaXZpZHVhbCBibG9ja3Mgd2l0aGluIHRoZSBtZW1vcnkKLSAqCQlhbGxvY2F0b3IuICBUaGlzIHZhbHVlIG11c3Qgc21hbGxlciB0aGFuIHRoZQotICoJCWNhcGFjaXR5LgotICoKLSAqIENyZWF0ZSBhIG1lbW9yeSBhbGxvY2F0b3Igd2l0aCB0aGUgZ2l2ZW4gY2FwYWNpdHkgYW5kIGJsb2NrIHNpemUuCi0gKiBUaGUgY2FwYWNpdHkgd2lsbCBiZSByZWR1Y2VkIHRvIGJlIGEgbXVsdGlwbGUgb2YgdGhlIGJsb2NrIHNpemUsIGlmCi0gKiBuZWNlc3NhcnkuCi0gKgotICogUmV0dXJucyBhbiBpbnN0YW5jZSBvZiB0aGUgbWVtb3J5IGFsbG9jYXRvciwgaWYgY3JlYXRpb24gc3VjY2VlZHMsCi0gKiBvdGhlcndpc2UgemVybyBpZiBjcmVhdGlvbiBmYWlscy4gIEZhaWx1cmUgbWF5IG9jY3VyIGlmIG5vdCBlbm91Z2gKLSAqIGtlcm5lbCBtZW1vcnkgZXhpc3RzIHRvIGNyZWF0ZSB0aGUgbWVtcmFyX2FsbG9jYXRvciBpbnN0YW5jZQotICogaXRzZWxmLCBvciBpZiB0aGUgY2FwYWNpdHkgYW5kIGJsb2NrX3NpemUgYXJndW1lbnRzIGFyZSBub3QKLSAqIGNvbXBhdGlibGUgb3IgbWFrZSBzZW5zZS4KLSAqLwotc3RydWN0IG1lbXJhcl9hbGxvY2F0b3IgKm1lbXJhcl9jcmVhdGVfYWxsb2NhdG9yKHVuc2lnbmVkIGxvbmcgYmFzZSwKLQkJCQkJCSBzaXplX3QgY2FwYWNpdHksCi0JCQkJCQkgc2l6ZV90IGJsb2NrX3NpemUpOwotCi0vKioKLSAqIG1lbXJhcl9kZXN0cm95X2FsbG9jYXRvcigpIC0gZGVzdHJveSBhbGxvY2F0b3IKLSAqIEBhbGxvY2F0b3I6CVRoZSBhbGxvY2F0b3IgYmVpbmcgZGVzdHJveWVkLgotICoKLSAqIFJlY2xhaW0gcmVzb3VyY2VzIGhlbGQgYnkgdGhlIG1lbW9yeSBhbGxvY2F0b3IuICBUaGUgY2FsbGVyIG11c3QKLSAqIGV4cGxpY2l0bHkgZnJlZSBhbGwgbWVtb3J5IHJlc2VydmVkIGJ5IG1lbXJhcl9hbGxvY2F0b3JfYWxsb2MoKQotICogcHJpb3IgdG8gY2FsbGluZyB0aGlzIGZ1bmN0aW9uLiAgT3RoZXJ3aXNlIGxlYWtzIHdpbGwgb2NjdXIuCi0gKi8KLXZvaWQgbWVtcmFyX2Rlc3Ryb3lfYWxsb2NhdG9yKHN0cnVjdCBtZW1yYXJfYWxsb2NhdG9yICphbGxvY2F0b3IpOwotCi0vKioKLSAqIG1lbXJhcl9hbGxvY2F0b3JfYWxsb2MoKSAtIHJlc2VydmUgYW4gYXJlYSBvZiBtZW1vcnkgb2YgZ2l2ZW4gc2l6ZQotICogQGFsbG9jYXRvcjoJVGhlIGFsbG9jYXRvciBpbnN0YW5jZSBiZWluZyB1c2VkIHRvIHJlc2VydmUgYnVmZmVyLgotICogQHNpemU6CVRoZSBzaXplIGluIGJ5dGVzIG9mIHRoZSBidWZmZXIgdG8gYWxsb2NhdGUuCi0gKgotICogVGhpcyBmdW5jdGlvbnMgcmVzZXJ2ZXMgYW4gYXJlYSBvZiBtZW1vcnkgbWFuYWdlZCBieSB0aGUgZ2l2ZW4KLSAqIGFsbG9jYXRvci4gIEl0IHJldHVybnMgemVybyBpZiBhbGxvY2F0aW9uIHdhcyBub3QgcG9zc2libGUuCi0gKiBGYWlsdXJlIG1heSBvY2N1ciBpZiB0aGUgYWxsb2NhdG9yIG5vIGxvbmdlciBoYXMgc3BhY2UgYXZhaWxhYmxlLgotICovCi11bnNpZ25lZCBsb25nIG1lbXJhcl9hbGxvY2F0b3JfYWxsb2Moc3RydWN0IG1lbXJhcl9hbGxvY2F0b3IgKmFsbG9jYXRvciwKLQkJCQkgICAgIHNpemVfdCBzaXplKTsKLQotLyoqCi0gKiBtZW1yYXJfYWxsb2NhdG9yX2ZyZWUoKSAtIHJlbGVhc2UgYnVmZmVyIHN0YXJ0aW5nIGF0IGdpdmVuIGFkZHJlc3MKLSAqIEBhbGxvY2F0b3I6CVRoZSBhbGxvY2F0b3IgaW5zdGFuY2UgYmVpbmcgdXNlZCB0byByZWxlYXNlIHRoZSBidWZmZXIuCi0gKiBAYWRkcmVzczoJVGhlIGFkZHJlc3Mgb2YgdGhlIGJ1ZmZlciBiZWluZyByZWxlYXNlZC4KLSAqCi0gKiBSZWxlYXNlIGFuIGFyZWEgb2YgbWVtb3J5IHN0YXJ0aW5nIGF0IHRoZSBnaXZlbiBhZGRyZXNzLiAgRmFpbHVyZQotICogY291bGQgb2NjdXIgaWYgdGhlIGdpdmVuIGFkZHJlc3MgaXMgbm90IGluIHRoZSBhZGRyZXNzIHNwYWNlCi0gKiBtYW5hZ2VkIGJ5IHRoZSBhbGxvY2F0b3IuICBSZXR1cm5zIHplcm8gb24gc3VjY2VzcyBvciBhbiBlcnJubwotICogKG5lZ2F0aXZlIHZhbHVlKSBvbiBmYWlsdXJlLgotICovCi1sb25nIG1lbXJhcl9hbGxvY2F0b3JfZnJlZShzdHJ1Y3QgbWVtcmFyX2FsbG9jYXRvciAqYWxsb2NhdG9yLAotCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzKTsKLQotI2VuZGlmICAvKiBNRU1SQVJfQUxMT0NBVE9SX0ggKi8KLQotCi0vKgotICBMb2NhbCBWYXJpYWJsZXM6Ci0gICAgYy1maWxlLXN0eWxlOiAibGludXgiCi0gIEVuZDoKLSovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL21lbXJhcl9oYW5kbGVyLmMgYi9kcml2ZXJzL3N0YWdpbmcvbWVtcmFyL21lbXJhcl9oYW5kbGVyLmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGNmY2FhOGUuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lbXJhci9tZW1yYXJfaGFuZGxlci5jCisrKyAvZGV2L251bGwKQEAgLTEsMTAwNyArMCwwIEBACi0vKgotICogICAgICBtZW1yYXJfaGFuZGxlciAxLjA6ICBBbiBJbnRlbCByZXN0cmljdGVkIGFjY2VzcyByZWdpb24gaGFuZGxlciBkZXZpY2UKLSAqCi0gKiAgICAgIENvcHlyaWdodCAoQykgMjAxMCBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiAgICAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKLSAqICAgICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB2ZXJzaW9uIDIgb2YgdGhlIEdOVSBHZW5lcmFsCi0gKiAgICAgIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqICAgICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZQotICogICAgICB1c2VmdWwsIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkCi0gKiAgICAgIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKLSAqICAgICAgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqICAgICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCi0gKiAgICAgIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKLSAqICAgICAgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAotICogICAgICBCb3N0b24sIE1BICAwMjExMS0xMzA3LCBVU0EuCi0gKiAgICAgIFRoZSBmdWxsIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMKLSAqICAgICAgZGlzdHJpYnV0aW9uIGluIHRoZSBmaWxlIGNhbGxlZCBDT1BZSU5HLgotICoKLSAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqCi0gKiAgICAgIE1vb3Jlc3Rvd24gcmVzdHJpY3RlZCBhY2Nlc3MgcmVnaW9ucyAoUkFSKSBwcm92aWRlIGlzb2xhdGVkCi0gKiAgICAgIGFyZWFzIG9mIG1haW4gbWVtb3J5IHRoYXQgYXJlIG9ubHkgYWNjZWVzc2libGUgYnkgYXV0aG9yaXplZAotICogICAgICBkZXZpY2VzLgotICoKLSAqICAgICAgVGhlIEludGVsIE1vb3Jlc3Rvd24gUkFSIGhhbmRsZXIgbW9kdWxlIGV4cG9zZXMgYSBrZXJuZWwgc3BhY2UKLSAqICAgICAgUkFSIG1lbW9yeSBtYW5hZ2VtZW50IG1lY2hhbmlzbS4gIEl0IGlzIGVzc2VudGlhbGx5IGEKLSAqICAgICAgUkFSLXNwZWNpZmljIGFsbG9jYXRvci4KLSAqCi0gKiAgICAgIEJlc2lkZXMgcHJvdmlkaW5nIFJBUiBidWZmZXIgbWFuYWdlbWVudCwgdGhlIFJBUiBoYW5kbGVyIGFsc28KLSAqICAgICAgYmVoYXZlcyBpbiBtYW55IHdheXMgbGlrZSBhbiBPUyB2aXJ0dWFsIG1lbW9yeSBtYW5hZ2VyLiAgRm9yCi0gKiAgICAgIGV4YW1wbGUsIHRoZSBSQVIgImhhbmRsZXMiIGNyZWF0ZWQgYnkgdGhlIFJBUiBoYW5kbGVyIGFyZQotICogICAgICBhbmFsb2dvdXMgdG8gdXNlciBzcGFjZSB2aXJ0dWFsIGFkZHJlc3Nlcy4KLSAqCi0gKiAgICAgIFJBUiBtZW1vcnkgaXRzZWxmIGlzIG5ldmVyIGFjY2Vzc2VkIGRpcmVjdGx5IGJ5IHRoZSBSQVIKLSAqICAgICAgaGFuZGxlci4KLSAqLwotCi0jaW5jbHVkZSA8bGludXgvbWlzY2RldmljZS5oPgotI2luY2x1ZGUgPGxpbnV4L2ZzLmg+Ci0jaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4L2tyZWYuaD4KLSNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgotI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgotI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KLSNpbmNsdWRlIDxsaW51eC9tbS5oPgotI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgotI2luY2x1ZGUgPGxpbnV4L2lvLmg+Ci0jaW5jbHVkZSA8bGludXgvcmFyX3JlZ2lzdGVyLmg+Ci0KLSNpbmNsdWRlICJtZW1yYXIuaCIKLSNpbmNsdWRlICJtZW1yYXJfYWxsb2NhdG9yLmgiCi0KLQotI2RlZmluZSBNRU1SQVJfVkVSICIxLjAiCi0KLS8qCi0gKiBNb29yZXN0b3duIHN1cHBvcnRzIHRocmVlIHJlc3RyaWN0ZWQgYWNjZXNzIHJlZ2lvbnMuCi0gKgotICogV2Ugb25seSBjYXJlIGFib3V0IHRoZSBmaXJzdCB0d28sIHZpZGVvIGFuZCBhdWRpby4gIFRoZSB0aGlyZCwKLSAqIHJlc2VydmVkIGZvciBDaGFhYmkgYW5kIHRoZSBQLXVuaXQsIHdpbGwgYmUgaGFuZGxlZCBieSB0aGVpcgotICogcmVzcGVjdGl2ZSBkcml2ZXJzLgotICovCi0jZGVmaW5lIE1SU1RfTlVNX1JBUiAyCi0KLS8qIC0tLS0tLS0tLS0tLS0tLS0gLS0tLS0tLS0tLS0tLS0tLS0tLS0gLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotCi0vKioKLSAqIHN0cnVjdCBtZW1yYXJfYnVmZmVyX2luZm8gLSBzdHJ1Y3QgdGhhdCBrZWVwcyB0cmFjayBvZiBhbGwgUkFSIGJ1ZmZlcnMKLSAqIEBsaXN0OglMaW5rZWQgbGlzdCBvZiBtZW1yYXJfYnVmZmVyX2luZm8gb2JqZWN0cy4KLSAqIEBidWZmZXI6CUNvcmUgUkFSIGJ1ZmZlciBpbmZvcm1hdGlvbi4KLSAqIEByZWZjb3VudDoJUmVmZXJlbmNlIGNvdW50LgotICogQG93bmVyOglGaWxlIGhhbmRsZSBjb3JyZXNwb25kaW5nIHRvIHByb2Nlc3MgdGhhdCByZXNlcnZlZCB0aGUKLSAqCQlibG9jayBvZiBtZW1vcnkgaW4gUkFSLiAgVGhpcyB3aWxsIGJlIHplcm8gZm9yIGJ1ZmZlcnMKLSAqCQlhbGxvY2F0ZWQgYnkgb3RoZXIgZHJpdmVycyBpbnN0ZWFkIG9mIGJ5IGEgdXNlciBzcGFjZQotICoJCXByb2Nlc3MuCi0gKgotICogVGhpcyBzdHJ1Y3R1cmUgZW5jYXBzdWxhdGVzIGEgbGluayBsaXN0IG9mIFJBUiBidWZmZXJzLCBhcyB3ZWxsIGFzCi0gKiBvdGhlciBjaGFyYWN0ZXJpc3RpY3Mgc3BlY2lmaWMgdG8gYSBnaXZlbiBsaXN0IG5vZGUsIHN1Y2ggYXMgdGhlCi0gKiByZWZlcmVuY2UgY291bnQgb24gdGhlIGNvcnJlc3BvbmRpbmcgUkFSIGJ1ZmZlci4KLSAqLwotc3RydWN0IG1lbXJhcl9idWZmZXJfaW5mbyB7Ci0Jc3RydWN0IGxpc3RfaGVhZCBsaXN0OwotCXN0cnVjdCBSQVJfYnVmZmVyIGJ1ZmZlcjsKLQlzdHJ1Y3Qga3JlZiByZWZjb3VudDsKLQlzdHJ1Y3QgZmlsZSAqb3duZXI7Ci19OwotCi0vKioKLSAqIHN0cnVjdCBtZW1yYXJfcmFyX2luZm8gLSBjaGFyYWN0ZXJpc3RpY3Mgb2YgYSBnaXZlbiBSQVIKLSAqIEBiYXNlOglCYXNlIGJ1cyBhZGRyZXNzIG9mIHRoZSBSQVIuCi0gKiBAbGVuZ3RoOglMZW5ndGggb2YgdGhlIFJBUi4KLSAqIEBpb2Jhc2U6CVZpcnR1YWwgYWRkcmVzcyBvZiBSQVIgbWFwcGVkIGludG8ga2VybmVsLgotICogQGFsbG9jYXRvcjoJQWxsb2NhdG9yIGFzc29jaWF0ZWQgd2l0aCB0aGUgUkFSLiAgTm90ZSB0aGUgYWxsb2NhdG9yCi0gKgkJImNhcGFjaXR5IiBtYXkgYmUgc21hbGxlciB0aGFuIHRoZSBSQVIgbGVuZ3RoIGlmIHRoZQotICoJCWxlbmd0aCBpcyBub3QgYSBtdWx0aXBsZSBvZiB0aGUgY29uZmlndXJlZCBhbGxvY2F0b3IKLSAqCQlibG9jayBzaXplLgotICogQGJ1ZmZlcnM6CVRhYmxlIHRoYXQga2VlcHMgdHJhY2sgb2YgYWxsIHJlc2VydmVkIFJBUiBidWZmZXJzLgotICogQGxvY2s6CUxvY2sgdXNlZCB0byBzeW5jaHJvbml6ZSBhY2Nlc3MgdG8gUkFSLXNwZWNpZmljIGRhdGEKLSAqCQlzdHJ1Y3R1cmVzLgotICoKLSAqIEVhY2ggUkFSIGhhcyBhbiBhc3NvY2lhdGVkIG1lbXJhcl9yYXJfaW5mbyBzdHJ1Y3R1cmUgdGhhdCBkZXNjcmliZXMKLSAqIHdoZXJlIGluIG1lbW9yeSB0aGUgUkFSIGlzIGxvY2F0ZWQsIGhvdyBsYXJnZSBpdCBpcywgYW5kIGEgbGlzdCBvZgotICogcmVzZXJ2ZWQgUkFSIGJ1ZmZlcnMgaW5zaWRlIHRoYXQgUkFSLiAgRWFjaCBSQVIgYWxzbyBoYXMgYSBtdXRleAotICogYXNzb2NpYXRlZCB3aXRoIGl0IHRvIHJlZHVjZSBsb2NrIGNvbnRlbnRpb24gd2hlbiBvcGVyYXRpb25zIG9uCi0gKiBtdWx0aXBsZSBSQVJzIGFyZSBwZXJmb3JtZWQgaW4gcGFyYWxsZWwuCi0gKi8KLXN0cnVjdCBtZW1yYXJfcmFyX2luZm8gewotCWRtYV9hZGRyX3QgYmFzZTsKLQl1bnNpZ25lZCBsb25nIGxlbmd0aDsKLQl2b2lkIF9faW9tZW0gKmlvYmFzZTsKLQlzdHJ1Y3QgbWVtcmFyX2FsbG9jYXRvciAqYWxsb2NhdG9yOwotCXN0cnVjdCBtZW1yYXJfYnVmZmVyX2luZm8gYnVmZmVyczsKLQlzdHJ1Y3QgbXV0ZXggbG9jazsKLQlpbnQgYWxsb2NhdGVkOwkvKiBUcnVlIGlmIHdlIG93biB0aGlzIFJBUiAqLwotfTsKLQotLyoKLSAqIEFycmF5IG9mIFJBUiBjaGFyYWN0ZXJpc3RpY3MuCi0gKi8KLXN0YXRpYyBzdHJ1Y3QgbWVtcmFyX3Jhcl9pbmZvIG1lbXJhcnNbTVJTVF9OVU1fUkFSXTsKLQotLyogLS0tLS0tLS0tLS0tLS0tLSAtLS0tLS0tLS0tLS0tLS0tLS0tLSAtLS0tLS0tLS0tLS0tLS0tLS0tICovCi0KLS8qIFZhbGlkYXRlIFJBUiB0eXBlLiAqLwotc3RhdGljIGlubGluZSBpbnQgbWVtcmFyX2lzX3ZhbGlkX3Jhcl90eXBlKHUzMiB0eXBlKQotewotCXJldHVybiB0eXBlID09IFJBUl9UWVBFX1ZJREVPIHx8IHR5cGUgPT0gUkFSX1RZUEVfQVVESU87Ci19Ci0KLS8qIENoZWNrIGlmIGFuIGFkZHJlc3MvaGFuZGxlIGZhbGxzIHdpdGggdGhlIGdpdmVuIFJBUiBtZW1vcnkgcmFuZ2UuICovCi1zdGF0aWMgaW5saW5lIGludCBtZW1yYXJfaGFuZGxlX2luX3JhbmdlKHN0cnVjdCBtZW1yYXJfcmFyX2luZm8gKnJhciwKLQkJCQkJIHUzMiB2YWRkcikKLXsKLQl1bnNpZ25lZCBsb25nIGNvbnN0IGlvYmFzZSA9ICh1bnNpZ25lZCBsb25nKSAocmFyLT5pb2Jhc2UpOwotCXJldHVybiAodmFkZHIgPj0gaW9iYXNlICYmIHZhZGRyIDwgaW9iYXNlICsgcmFyLT5sZW5ndGgpOwotfQotCi0vKiBSZXRyaWV2ZSBSQVIgaW5mb3JtYXRpb24gYXNzb2NpYXRlZCB3aXRoIHRoZSBnaXZlbiBoYW5kbGUuICovCi1zdGF0aWMgc3RydWN0IG1lbXJhcl9yYXJfaW5mbyAqbWVtcmFyX2dldF9yYXJfaW5mbyh1MzIgdmFkZHIpCi17Ci0JaW50IGk7Ci0JZm9yIChpID0gMDsgaSA8IE1SU1RfTlVNX1JBUjsgKytpKSB7Ci0JCXN0cnVjdCBtZW1yYXJfcmFyX2luZm8gKiBjb25zdCByYXIgPSAmbWVtcmFyc1tpXTsKLQkJaWYgKG1lbXJhcl9oYW5kbGVfaW5fcmFuZ2UocmFyLCB2YWRkcikpCi0JCQlyZXR1cm4gcmFyOwotCX0KLQotCXJldHVybiBOVUxMOwotfQotCi0vKioKLSAqCW1lbXJhcl9nZXRfYnVzIGFkZHJlc3MJCS0JaGFuZGxlIHRvIGJ1cyBhZGRyZXNzCi0gKgotICoJUmV0cmlldmUgYnVzIGFkZHJlc3MgZnJvbSBnaXZlbiBoYW5kbGUuCi0gKgotICoJUmV0dXJucyBhZGRyZXNzIGNvcnJlc3BvbmRpbmcgdG8gZ2l2ZW4gaGFuZGxlLiAgWmVybyBpZiBoYW5kbGUgaXMKLSAqCWludmFsaWQuCi0gKi8KLXN0YXRpYyBkbWFfYWRkcl90IG1lbXJhcl9nZXRfYnVzX2FkZHJlc3MoCi0Jc3RydWN0IG1lbXJhcl9yYXJfaW5mbyAqcmFyLAotCXUzMiB2YWRkcikKLXsKLQl1bnNpZ25lZCBsb25nIGNvbnN0IGlvYmFzZSA9ICh1bnNpZ25lZCBsb25nKSAocmFyLT5pb2Jhc2UpOwotCi0JaWYgKCFtZW1yYXJfaGFuZGxlX2luX3JhbmdlKHJhciwgdmFkZHIpKQotCQlyZXR1cm4gMDsKLQotCS8qCi0JICogQW4gYXNzdW1wdGlvbiBpcyBtYWRlIHRoYXQgdGhlIHZpcnR1YWwgYWRkcmVzcyBvZmZzZXQgaXMKLQkgKiB0aGUgc2FtZSBhcyB0aGUgYnVzIGFkZHJlc3Mgb2Zmc2V0LCBhdCBsZWFzdCBiYXNlZCBvbiB0aGUKLQkgKiB3YXkgdGhpcyBkcml2ZXIgaXMgaW1wbGVtZW50ZWQuICBGb3IgZXhhbXBsZSwgdmFkZHIgKyAyID09Ci0JICogYmFkZHIgKyAyLgotCSAqCi0JICogQHRvZG8gSXMgdGhhdCBhIHZhbGlkIGFzc3VtcHRpb24/Ci0JICovCi0JcmV0dXJuIHJhci0+YmFzZSArICh2YWRkciAtIGlvYmFzZSk7Ci19Ci0KLS8qKgotICoJbWVtcmFyX2dldF9waHlzaWNhbF9hZGRyZXNzCS0JaGFuZGxlIHRvIHBoeXNpY2FsIGFkZHJlc3MKLSAqCi0gKglSZXRyaWV2ZSBwaHlzaWNhbCBhZGRyZXNzIGZyb20gZ2l2ZW4gaGFuZGxlLgotICoKLSAqCVJldHVybnMgYWRkcmVzcyBjb3JyZXNwb25kaW5nIHRvIGdpdmVuIGhhbmRsZS4gIFplcm8gaWYgaGFuZGxlIGlzCi0gKglpbnZhbGlkLgotICovCi1zdGF0aWMgZG1hX2FkZHJfdCBtZW1yYXJfZ2V0X3BoeXNpY2FsX2FkZHJlc3MoCi0Jc3RydWN0IG1lbXJhcl9yYXJfaW5mbyAqcmFyLAotCXUzMiB2YWRkcikKLXsKLQkvKgotCSAqIEB0b2RvIFRoaXMgYXNzdW1lcyB0aGF0IHRoZSBidXMgYWRkcmVzcyBhbmQgcGh5c2ljYWwKLQkgKiAgICAgICBhZGRyZXNzIGFyZSB0aGUgc2FtZS4gIFRoYXQgaXMgdHJ1ZSBmb3IgTW9vcmVzdG93bgotCSAqICAgICAgIGJ1dCBub3QgbmVjZXNzYXJpbHkgb24gb3RoZXIgcGxhdGZvcm1zLiAgVGhpcwotCSAqICAgICAgIGRlZmljaWVuY3kgc2hvdWxkIGJlIGFkZHJlc3NlZCBhdCBzb21lIHBvaW50LgotCSAqLwotCXJldHVybiBtZW1yYXJfZ2V0X2J1c19hZGRyZXNzKHJhciwgdmFkZHIpOwotfQotCi0vKioKLSAqCW1lbXJhcl9yZWxlYXNlX2Jsb2NrCS0JcmVsZWFzZSBhIGJsb2NrIHRvIHRoZSBwb29sCi0gKglAa3JlZjoga3JlZiBvZiBibG9jawotICoKLSAqCUNvcmUgYmxvY2sgcmVsZWFzZSBjb2RlLiBBIG5vZGUgaGFzIGhpdCB6ZXJvIHJlZmVyZW5jZXMgc28gY2FuCi0gKgliZSByZWxlYXNlZCBhbmQgdGhlIGxpc3RzIG11c3QgYmUgdXBkYXRlZC4KLSAqCi0gKglOb3RlOiBUaGlzIGNvZGUgcmVtb3ZlcyB0aGUgbm9kZSBmcm9tIGEgbGlzdC4gIE1ha2Ugc3VyZSBhbnkgbGlzdAotICoJaXRlcmF0aW9uIGlzIHBlcmZvcm1lZCB1c2luZyBsaXN0X2Zvcl9lYWNoX3NhZmUoKS4KLSAqLwotc3RhdGljIHZvaWQgbWVtcmFyX3JlbGVhc2VfYmxvY2tfaShzdHJ1Y3Qga3JlZiAqcmVmKQotewotCS8qCi0JICogTGFzdCByZWZlcmVuY2UgaXMgYmVpbmcgcmVsZWFzZWQuICBSZW1vdmUgZnJvbSB0aGUgdGFibGUsCi0JICogYW5kIHJlY2xhaW0gcmVzb3VyY2VzLgotCSAqLwotCi0Jc3RydWN0IG1lbXJhcl9idWZmZXJfaW5mbyAqIGNvbnN0IG5vZGUgPQotCQljb250YWluZXJfb2YocmVmLCBzdHJ1Y3QgbWVtcmFyX2J1ZmZlcl9pbmZvLCByZWZjb3VudCk7Ci0KLQlzdHJ1Y3QgUkFSX2Jsb2NrX2luZm8gKiBjb25zdCB1c2VyX2luZm8gPQotCQkmbm9kZS0+YnVmZmVyLmluZm87Ci0KLQlzdHJ1Y3QgbWVtcmFyX2FsbG9jYXRvciAqIGNvbnN0IGFsbG9jYXRvciA9Ci0JCW1lbXJhcnNbdXNlcl9pbmZvLT50eXBlXS5hbGxvY2F0b3I7Ci0KLQlsaXN0X2RlbCgmbm9kZS0+bGlzdCk7Ci0KLQltZW1yYXJfYWxsb2NhdG9yX2ZyZWUoYWxsb2NhdG9yLCB1c2VyX2luZm8tPmhhbmRsZSk7Ci0KLQlrZnJlZShub2RlKTsKLX0KLQotLyoqCi0gKgltZW1yYXJfaW5pdF9yYXJfcmVzb3VyY2VzCS0JY29uZmlndXJlIGEgUkFSCi0gKglAcmFybnVtOiByYXIgdGhhdCBoYXMgYmVlbiBhbGxvY2F0ZWQKLSAqCUBkZXZuYW1lOiBuYW1lIG9mIG91ciBkZXZpY2UKLSAqCi0gKglJbml0aWFsaXplIFJBUiBwYXJhbWV0ZXJzLCBzdWNoIGFzIGJ1cyBhZGRyZXNzZXMsIGV0YyBhbmQgbWFrZQotICoJdGhlIHJlc291cmNlIGFjY2Vzc2libGUuCi0gKi8KLXN0YXRpYyBpbnQgbWVtcmFyX2luaXRfcmFyX3Jlc291cmNlcyhpbnQgcmFybnVtLCBjaGFyIGNvbnN0ICpkZXZuYW1lKQotewotCS8qIC0tLS0gU2FuaXR5IENoZWNrcyAtLS0tCi0JICogMS4gUkFSIGJ1cyBhZGRyZXNzZXMgaW4gYm90aCBMaW5jcm9mdCBhbmQgTGFuZ3dlbGwgUkFSCi0JICogICAgcmVnaXN0ZXJzIHNob3VsZCBiZSB0aGUgc2FtZS4KLQkgKiAgICBhLiBUaGVyZSdzIG5vIHdheSB3ZSBjYW4gZG8gdGhpcyB0aHJvdWdoIElBLgotCSAqCi0JICogMi4gU2VjdXJlIGRldmljZSBJRCBpbiBMYW5nd2VsbCBSQVIgcmVnaXN0ZXJzIHNob3VsZCBiZSBzZXQKLQkgKiAgICBhcHByb3ByaWF0ZWx5LCBlLmcuIG9ubHkgTFBFIERNQSBmb3IgdGhlIGF1ZGlvIFJBUiwgYW5kCi0JICogICAgc2VjdXJpdHkgZm9yIHRoZSBvdGhlciBMYW5nd2VsbCBiYXNlZCBSQVIgcmVnaXN0ZXJzLgotCSAqICAgIGEuIFRoZXJlJ3Mgbm8gd2F5IHdlIGNhbiBkbyB0aGlzIHRocm91Z2ggSUEuCi0JICoKLQkgKiAzLiBBdWRpbyBhbmQgdmlkZW8gUkFSIHJlZ2lzdGVycyBhbmQgUkFSIGFjY2VzcyBzaG91bGQgYmUKLQkgKiAgICBsb2NrZWQgZG93bi4gIElmIG5vdCwgZW5hYmxlIFJBUiBhY2Nlc3MgY29udHJvbC4gIEV4Y2VwdAotCSAqICAgIGZvciBkZWJ1Z2dpbmcgcHVycG9zZXMsIHRoZXJlIGlzIG5vIHJlYXNvbiBmb3IgdGhlbSB0bwotCSAqICAgIGJlIHVubG9ja2VkLgotCSAqICAgIGEuICBXZSBjYW4gb25seSBkbyB0aGlzIGZvciB0aGUgTGluY3JvZnQgKElBKSBzaWRlLgotCSAqCi0JICogQHRvZG8gU2hvdWxkIHRoZSBSQVIgaGFuZGxlciBkcml2ZXIgZXZlbiBiZSBhd2FyZSBvZiBhdWRpbwotCSAqICAgICAgIGFuZCB2aWRlbyBSQVIgc2V0dGluZ3M/Ci0JICovCi0KLQkvKgotCSAqIFJBUiBidWZmZXIgYmxvY2sgc2l6ZS4KLQkgKgotCSAqIFdlIGNob29zZSBpdCB0byBiZSB0aGUgc2l6ZSBvZiBhIHBhZ2UgdG8gc2ltcGxpZnkgdGhlCi0JICogL2Rldi9tZW1yYXIgbW1hcCgpIGltcGxlbWVudGF0aW9uIGFuZCB1c2FnZS4gIE90aGVyd2lzZQotCSAqIHBhZ2luZyBpcyBub3QgaW52b2x2ZWQgb25jZSBhbiBSQVIgaXMgbG9ja2VkIGRvd24uCi0JICovCi0Jc3RhdGljIHNpemVfdCBjb25zdCBSQVJfQkxPQ0tfU0laRSA9IFBBR0VfU0laRTsKLQotCWRtYV9hZGRyX3QgbG93LCBoaWdoOwotCXN0cnVjdCBtZW1yYXJfcmFyX2luZm8gKiBjb25zdCByYXIgPSAmbWVtcmFyc1tyYXJudW1dOwotCi0JQlVHX09OKE1SU1RfTlVNX1JBUiAhPSBBUlJBWV9TSVpFKG1lbXJhcnMpKTsKLQlCVUdfT04oIW1lbXJhcl9pc192YWxpZF9yYXJfdHlwZShyYXJudW0pKTsKLQlCVUdfT04ocmFyLT5hbGxvY2F0ZWQpOwotCi0JaWYgKHJhcl9nZXRfYWRkcmVzcyhyYXJudW0sICZsb3csICZoaWdoKSAhPSAwKQotCQkvKiBObyBSQVIgaXMgYXZhaWxhYmxlLiAqLwotCQlyZXR1cm4gLUVOT0RFVjsKLQotCWlmIChsb3cgPT0gMCB8fCBoaWdoID09IDApIHsKLQkJcmFyLT5iYXNlICAgICAgPSAwOwotCQlyYXItPmxlbmd0aCAgICA9IDA7Ci0JCXJhci0+aW9iYXNlICAgID0gTlVMTDsKLQkJcmFyLT5hbGxvY2F0b3IgPSBOVUxMOwotCQlyZXR1cm4gLUVOT1NQQzsKLQl9Ci0KLQkvKgotCSAqIEB0b2RvIFZlcmlmeSB0aGF0IExOQyBhbmQgTE5XIFJBUiByZWdpc3RlciBjb250ZW50cwotCSAqICAgICAgIGFkZHJlc3Nlcywgc2VjdXJpdHksIGV0YyBhcmUgY29tcGF0aWJsZSBhbmQKLQkgKiAgICAgICBjb25zaXN0ZW50KS4KLQkgKi8KLQotCXJhci0+bGVuZ3RoID0gaGlnaCAtIGxvdyArIDE7Ci0KLQkvKiBDbGFpbSBSQVIgbWVtb3J5IGFzIG91ciBvd24uICovCi0JaWYgKHJlcXVlc3RfbWVtX3JlZ2lvbihsb3csIHJhci0+bGVuZ3RoLCBkZXZuYW1lKSA9PSBOVUxMKSB7Ci0JCXJhci0+bGVuZ3RoID0gMDsKLQkJcHJfZXJyKCIlczogVW5hYmxlIHRvIGNsYWltIFJBUlslZF0gbWVtb3J5LlxuIiwKLQkJICAgICAgIGRldm5hbWUsIHJhcm51bSk7Ci0JCXByX2VycigiJXM6IFJBUlslZF0gZGlzYWJsZWQuXG4iLCBkZXZuYW1lLCByYXJudW0pOwotCQlyZXR1cm4gLUVCVVNZOwotCX0KLQotCXJhci0+YmFzZSA9IGxvdzsKLQotCS8qCi0JICogTm93IG1hcCBpdCBpbnRvIHRoZSBrZXJuZWwgYWRkcmVzcyBzcGFjZS4KLQkgKgotCSAqIE5vdGUgdGhhdCB0aGUgUkFSIG1lbW9yeSBtYXkgb25seSBiZSBhY2Nlc3NlZCBieSBJQQotCSAqIHdoZW4gZGVidWdnaW5nLiAgT3RoZXJ3aXNlIGF0dGVtcHRzIHRvIGFjY2VzcyB0aGUKLQkgKiBSQVIgbWVtb3J5IHdoZW4gaXQgaXMgbG9ja2VkIGRvd24gd2lsbCByZXN1bHQgaW4KLQkgKiBiZWhhdmlvciBzaW1pbGFyIHRvIHdyaXRpbmcgdG8gL2Rldi9udWxsIGFuZAotCSAqIHJlYWRpbmcgZnJvbSAvZGV2L3plcm8uICBUaGlzIGJlaGF2aW9yIGlzIGVuZm9yY2VkCi0JICogYnkgdGhlIGhhcmR3YXJlLiAgRXZlbiBpZiB3ZSBkb24ndCBhY2Nlc3MgdGhlCi0JICogbWVtb3J5LCBtYXBwaW5nIGl0IGludG8gdGhlIGtlcm5lbCBwcm92aWRlcyB1cyB3aXRoCi0JICogYSBjb252ZW5pZW50IFJBUiBoYW5kbGUgdG8gYnVzIGFkZHJlc3MgbWFwcGluZy4KLQkgKi8KLQlyYXItPmlvYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShyYXItPmJhc2UsIHJhci0+bGVuZ3RoKTsKLQlpZiAocmFyLT5pb2Jhc2UgPT0gTlVMTCkgewotCQlwcl9lcnIoIiVzOiBVbmFibGUgdG8gbWFwIFJBUiBtZW1vcnkuXG4iLCBkZXZuYW1lKTsKLQkJcmVsZWFzZV9tZW1fcmVnaW9uKGxvdywgcmFyLT5sZW5ndGgpOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0KLQkvKiBJbml0aWFsaXplIGNvcnJlc3BvbmRpbmcgbWVtb3J5IGFsbG9jYXRvci4gKi8KLQlyYXItPmFsbG9jYXRvciA9IG1lbXJhcl9jcmVhdGVfYWxsb2NhdG9yKCh1bnNpZ25lZCBsb25nKSByYXItPmlvYmFzZSwKLQkJCQkJCXJhci0+bGVuZ3RoLCBSQVJfQkxPQ0tfU0laRSk7Ci0JaWYgKHJhci0+YWxsb2NhdG9yID09IE5VTEwpIHsKLQkJaW91bm1hcChyYXItPmlvYmFzZSk7Ci0JCXJlbGVhc2VfbWVtX3JlZ2lvbihsb3csIHJhci0+bGVuZ3RoKTsKLQkJcmV0dXJuIC1FTk9NRU07Ci0JfQotCi0JcHJfaW5mbygiJXM6IEJSQVJbJWRdIGJ1cyBhZGRyZXNzIHJhbmdlID0gWzB4JWx4LCAweCVseF1cbiIsCi0JCWRldm5hbWUsIHJhcm51bSwgKHVuc2lnbmVkIGxvbmcpIGxvdywgKHVuc2lnbmVkIGxvbmcpIGhpZ2gpOwotCi0JcHJfaW5mbygiJXM6IEJSQVJbJWRdIHNpemUgPSAlenUgS2lCXG4iLAotCQkJZGV2bmFtZSwgcmFybnVtLCByYXItPmFsbG9jYXRvci0+Y2FwYWNpdHkgLyAxMDI0KTsKLQotCXJhci0+YWxsb2NhdGVkID0gMTsKLQlyZXR1cm4gMDsKLX0KLQotLyoqCi0gKgltZW1yYXJfZmluaV9yYXJfcmVzb3VyY2VzCS0JZnJlZSB1cCBSQVIgcmVzb3VyY2VzCi0gKgotICoJRmluYWxpemUgUkFSIHJlc291cmNlcy4gRnJlZSB1cCB0aGUgcmVzb3VyY2UgdGFibGVzLCBoYW5kIHRoZSBtZW1vcnkKLSAqCWJhY2sgdG8gdGhlIGtlcm5lbCwgdW5tYXAgdGhlIGRldmljZSBhbmQgcmVsZWFzZSB0aGUgYWRkcmVzcyBzcGFjZS4KLSAqLwotc3RhdGljIHZvaWQgbWVtcmFyX2ZpbmlfcmFyX3Jlc291cmNlcyh2b2lkKQotewotCWludCB6OwotCXN0cnVjdCBtZW1yYXJfYnVmZmVyX2luZm8gKnBvczsKLQlzdHJ1Y3QgbWVtcmFyX2J1ZmZlcl9pbmZvICp0bXA7Ci0KLQkvKgotCSAqIEB0b2RvIERvIHdlIG5lZWQgdG8gaG9sZCBhIGxvY2sgYXQgdGhpcyBwb2ludCBpbiB0aW1lPwotCSAqICAgICAgIChtb2R1bGUgaW5pdGlhbGl6YXRpb24gZmFpbHVyZSBvciBleGl0PykKLQkgKi8KLQotCWZvciAoeiA9IE1SU1RfTlVNX1JBUjsgei0tICE9IDA7ICkgewotCQlzdHJ1Y3QgbWVtcmFyX3Jhcl9pbmZvICogY29uc3QgcmFyID0gJm1lbXJhcnNbel07Ci0KLQkJaWYgKCFyYXItPmFsbG9jYXRlZCkKLQkJCWNvbnRpbnVlOwotCi0JCS8qIENsZWFuIHVwIHJlbWFpbmluZyByZXNvdXJjZXMuICovCi0KLQkJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHBvcywKLQkJCQkJIHRtcCwKLQkJCQkJICZyYXItPmJ1ZmZlcnMubGlzdCwKLQkJCQkJIGxpc3QpIHsKLQkJCWtyZWZfcHV0KCZwb3MtPnJlZmNvdW50LCBtZW1yYXJfcmVsZWFzZV9ibG9ja19pKTsKLQkJfQotCi0JCW1lbXJhcl9kZXN0cm95X2FsbG9jYXRvcihyYXItPmFsbG9jYXRvcik7Ci0JCXJhci0+YWxsb2NhdG9yID0gTlVMTDsKLQotCQlpb3VubWFwKHJhci0+aW9iYXNlKTsKLQkJcmVsZWFzZV9tZW1fcmVnaW9uKHJhci0+YmFzZSwgcmFyLT5sZW5ndGgpOwotCi0JCXJhci0+aW9iYXNlID0gTlVMTDsKLQkJcmFyLT5iYXNlID0gMDsKLQkJcmFyLT5sZW5ndGggPSAwOwotCi0JCXVucmVnaXN0ZXJfcmFyKHopOwotCX0KLX0KLQotLyoqCi0gKgltZW1yYXJfcmVzZXJ2ZV9ibG9jawktCWhhbmRsZSBhbiBhbGxvY2F0aW9uIHJlcXVlc3QKLSAqCUByZXF1ZXN0OiBibG9jayBiZWluZyByZXF1ZXN0ZWQKLSAqCUBmaWxwOiBvd25lciBpdCBpcyB0aWVkIHRvCi0gKgotICoJQWxsb2NhdGUgYSBibG9jayBvZiB0aGUgcmVxdWVzdGVkIFJBUi4gSWYgc3VjY2Vzc2Z1bCByZXR1cm4gdGhlCi0gKglyZXF1ZXN0IG9iamVjdCBmaWxsZWQgaW4gYW5kIHplcm8sIGlmIG5vdCByZXBvcnQgYW4gZXJyb3IgY29kZQotICovCi0KLXN0YXRpYyBsb25nIG1lbXJhcl9yZXNlcnZlX2Jsb2NrKHN0cnVjdCBSQVJfYnVmZmVyICpyZXF1ZXN0LAotCQkJCSBzdHJ1Y3QgZmlsZSAqZmlscCkKLXsKLQlzdHJ1Y3QgUkFSX2Jsb2NrX2luZm8gKiBjb25zdCByaW5mbyA9ICZyZXF1ZXN0LT5pbmZvOwotCXN0cnVjdCBSQVJfYnVmZmVyICpidWZmZXI7Ci0Jc3RydWN0IG1lbXJhcl9idWZmZXJfaW5mbyAqYnVmZmVyX2luZm87Ci0JdTMyIGhhbmRsZTsKLQlzdHJ1Y3QgbWVtcmFyX3Jhcl9pbmZvICpyYXIgPSBOVUxMOwotCi0JLyogUHJldmVudCBhcnJheSBvdmVyZmxvdy4gKi8KLQlpZiAoIW1lbXJhcl9pc192YWxpZF9yYXJfdHlwZShyaW5mby0+dHlwZSkpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JcmFyID0gJm1lbXJhcnNbcmluZm8tPnR5cGVdOwotCWlmICghcmFyLT5hbGxvY2F0ZWQpCi0JCXJldHVybiAtRU5PREVWOwotCi0JLyogUmVzZXJ2ZSBtZW1vcnkgaW4gUkFSLiAqLwotCWhhbmRsZSA9IG1lbXJhcl9hbGxvY2F0b3JfYWxsb2MocmFyLT5hbGxvY2F0b3IsIHJpbmZvLT5zaXplKTsKLQlpZiAoaGFuZGxlID09IDApCi0JCXJldHVybiAtRU5PTUVNOwotCi0JYnVmZmVyX2luZm8gPSBrbWFsbG9jKHNpemVvZigqYnVmZmVyX2luZm8pLCBHRlBfS0VSTkVMKTsKLQotCWlmIChidWZmZXJfaW5mbyA9PSBOVUxMKSB7Ci0JCW1lbXJhcl9hbGxvY2F0b3JfZnJlZShyYXItPmFsbG9jYXRvciwgaGFuZGxlKTsKLQkJcmV0dXJuIC1FTk9NRU07Ci0JfQotCi0JYnVmZmVyID0gJmJ1ZmZlcl9pbmZvLT5idWZmZXI7Ci0JYnVmZmVyLT5pbmZvLnR5cGUgPSByaW5mby0+dHlwZTsKLQlidWZmZXItPmluZm8uc2l6ZSA9IHJpbmZvLT5zaXplOwotCi0JLyogTWVtb3J5IGhhbmRsZSBjb3JyZXNwb25kaW5nIHRvIHRoZSBidXMgYWRkcmVzcy4gKi8KLQlidWZmZXItPmluZm8uaGFuZGxlID0gaGFuZGxlOwotCWJ1ZmZlci0+YnVzX2FkZHJlc3MgPSBtZW1yYXJfZ2V0X2J1c19hZGRyZXNzKHJhciwgaGFuZGxlKTsKLQotCS8qCi0JICogS2VlcCB0cmFjayBvZiBvd25lciBzbyB0aGF0IHdlIGNhbiBsYXRlciBjbGVhbnVwIGlmCi0JICogbmVjZXNzYXJ5LgotCSAqLwotCWJ1ZmZlcl9pbmZvLT5vd25lciA9IGZpbHA7Ci0KLQlrcmVmX2luaXQoJmJ1ZmZlcl9pbmZvLT5yZWZjb3VudCk7Ci0KLQltdXRleF9sb2NrKCZyYXItPmxvY2spOwotCWxpc3RfYWRkKCZidWZmZXJfaW5mby0+bGlzdCwgJnJhci0+YnVmZmVycy5saXN0KTsKLQltdXRleF91bmxvY2soJnJhci0+bG9jayk7Ci0KLQlyaW5mby0+aGFuZGxlID0gYnVmZmVyLT5pbmZvLmhhbmRsZTsKLQlyZXF1ZXN0LT5idXNfYWRkcmVzcyA9IGJ1ZmZlci0+YnVzX2FkZHJlc3M7Ci0KLQlyZXR1cm4gMDsKLX0KLQotLyoqCi0gKgltZW1yYXJfcmVsZWFzZV9ibG9jawkJLQlyZWxlYXNlIGEgUkFSIGJsb2NrCi0gKglAYWRkcjogYWRkcmVzcyBpbiBSQVIgc3BhY2UKLSAqCi0gKglSZWxlYXNlIGEgcHJldmlvdXNseSBhbGxvY2F0ZWQgYmxvY2suIFJlbGVhc2VzIGFjdCBvbiBjb21wbGV0ZQotICoJYmxvY2tzLCBwYXJ0aWFsbHkgZnJlZWluZyBhIGJsb2NrIGlzIG5vdCBzdXBwb3J0ZWQKLSAqLwotCi1zdGF0aWMgbG9uZyBtZW1yYXJfcmVsZWFzZV9ibG9jayh1MzIgYWRkcikKLXsKLQlzdHJ1Y3QgbWVtcmFyX2J1ZmZlcl9pbmZvICpwb3M7Ci0Jc3RydWN0IG1lbXJhcl9idWZmZXJfaW5mbyAqdG1wOwotCXN0cnVjdCBtZW1yYXJfcmFyX2luZm8gKiBjb25zdCByYXIgPSBtZW1yYXJfZ2V0X3Jhcl9pbmZvKGFkZHIpOwotCWxvbmcgcmVzdWx0ID0gLUVJTlZBTDsKLQotCWlmIChyYXIgPT0gTlVMTCkKLQkJcmV0dXJuIC1FTk9FTlQ7Ci0KLQltdXRleF9sb2NrKCZyYXItPmxvY2spOwotCi0JLyoKLQkgKiBJdGVyYXRlIHRocm91Z2ggdGhlIGJ1ZmZlciBsaXN0IHRvIGZpbmQgdGhlIGNvcnJlc3BvbmRpbmcKLQkgKiBidWZmZXIgdG8gYmUgcmVsZWFzZWQuCi0JICovCi0JbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHBvcywKLQkJCQkgdG1wLAotCQkJCSAmcmFyLT5idWZmZXJzLmxpc3QsCi0JCQkJIGxpc3QpIHsKLQkJc3RydWN0IFJBUl9ibG9ja19pbmZvICogY29uc3QgaW5mbyA9Ci0JCQkmcG9zLT5idWZmZXIuaW5mbzsKLQotCQkvKgotCQkgKiBUYWtlIGludG8gYWNjb3VudCBoYW5kbGUgb2Zmc2V0cyB0aGF0IG1heSBoYXZlIGJlZW4KLQkJICogYWRkZWQgdG8gdGhlIGJhc2UgaGFuZGxlLCBzdWNoIGFzIGluIHRoZSBmb2xsb3dpbmcKLQkJICogc2NlbmFyaW86Ci0JCSAqCi0JCSAqICAgICB1MzIgaGFuZGxlID0gYmFzZSArIG9mZnNldDsKLQkJICogICAgIHJhcl9oYW5kbGVfdG9fYnVzKGhhbmRsZSk7Ci0JCSAqICAgICByYXJfcmVsZWFzZShoYW5kbGUpOwotCQkgKi8KLQkJaWYgKGFkZHIgPj0gaW5mby0+aGFuZGxlCi0JCSAgICAmJiBhZGRyIDwgKGluZm8tPmhhbmRsZSArIGluZm8tPnNpemUpCi0JCSAgICAmJiBtZW1yYXJfaXNfdmFsaWRfcmFyX3R5cGUoaW5mby0+dHlwZSkpIHsKLQkJCWtyZWZfcHV0KCZwb3MtPnJlZmNvdW50LCBtZW1yYXJfcmVsZWFzZV9ibG9ja19pKTsKLQkJCXJlc3VsdCA9IDA7Ci0JCQlicmVhazsKLQkJfQotCX0KLQotCW11dGV4X3VubG9jaygmcmFyLT5sb2NrKTsKLQotCXJldHVybiByZXN1bHQ7Ci19Ci0KLS8qKgotICoJbWVtcmFyX2dldF9zdGF0cwktCXJlYWQgc3RhdGlzdGljcyBmb3IgYSBSQVIKLSAqCUByOiBzdGF0aXN0aWNzIHRvIGJlIGZpbGxlZCBpbgotICoKLSAqCVJldHVybnMgdGhlIHN0YXRpc3RpY3MgZGF0YSBmb3IgdGhlIFJBUiwgb3IgYW4gZXJyb3IgY29kZSBpZgotICoJdGhlIHJlcXVlc3QgY2Fubm90IGJlIGNvbXBsZXRlZAotICovCi1zdGF0aWMgbG9uZyBtZW1yYXJfZ2V0X3N0YXQoc3RydWN0IFJBUl9zdGF0ICpyKQotewotCXN0cnVjdCBtZW1yYXJfYWxsb2NhdG9yICphbGxvY2F0b3I7Ci0KLQlpZiAoIW1lbXJhcl9pc192YWxpZF9yYXJfdHlwZShyLT50eXBlKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAoIW1lbXJhcnNbci0+dHlwZV0uYWxsb2NhdGVkKQotCQlyZXR1cm4gLUVOT0RFVjsKLQotCWFsbG9jYXRvciA9IG1lbXJhcnNbci0+dHlwZV0uYWxsb2NhdG9yOwotCi0JQlVHX09OKGFsbG9jYXRvciA9PSBOVUxMKTsKLQotCS8qCi0JICogQWxsb2NhdG9yIGNhcGFjaXR5IGRvZXNuJ3QgY2hhbmdlIG92ZXIgdGltZS4gIE5vCi0JICogbmVlZCB0byBzeW5jaHJvbml6ZS4KLQkgKi8KLQlyLT5jYXBhY2l0eSA9IGFsbG9jYXRvci0+Y2FwYWNpdHk7Ci0KLQltdXRleF9sb2NrKCZhbGxvY2F0b3ItPmxvY2spOwotCXItPmxhcmdlc3RfYmxvY2tfc2l6ZSA9IGFsbG9jYXRvci0+bGFyZ2VzdF9mcmVlX2FyZWE7Ci0JbXV0ZXhfdW5sb2NrKCZhbGxvY2F0b3ItPmxvY2spOwotCXJldHVybiAwOwotfQotCi0vKioKLSAqCW1lbXJhcl9pb2N0bAkJLQlpb2N0bCBjYWxsYmFjawotICoJQGZpbHA6IGZpbGUgaXNzdWluZyB0aGUgcmVxdWVzdAotICoJQGNtZDogY29tbWFuZAotICoJQGFyZzogcG9pbnRlciB0byBjb250cm9sIGluZm9ybWF0aW9uCi0gKgotICoJUGVyZm9ybSBvbmUgb2YgdGhlIGlvY3RscyBzdXBwb3J0ZWQgYnkgdGhlIG1lbXJhciBkZXZpY2UKLSAqLwotCi1zdGF0aWMgbG9uZyBtZW1yYXJfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsCi0JCQkgdW5zaWduZWQgaW50IGNtZCwKLQkJCSB1bnNpZ25lZCBsb25nIGFyZykKLXsKLQl2b2lkIF9fdXNlciAqYXJncCA9ICh2b2lkIF9fdXNlciAqKWFyZzsKLQlsb25nIHJlc3VsdCA9IDA7Ci0KLQlzdHJ1Y3QgUkFSX2J1ZmZlciBidWZmZXI7Ci0Jc3RydWN0IFJBUl9ibG9ja19pbmZvICogY29uc3QgcmVxdWVzdCA9ICZidWZmZXIuaW5mbzsKLQlzdHJ1Y3QgUkFSX3N0YXQgcmFyX2luZm87Ci0JdTMyIHJhcl9oYW5kbGU7Ci0KLQlzd2l0Y2ggKGNtZCkgewotCWNhc2UgUkFSX0hBTkRMRVJfUkVTRVJWRToKLQkJaWYgKGNvcHlfZnJvbV91c2VyKHJlcXVlc3QsCi0JCQkJICAgYXJncCwKLQkJCQkgICBzaXplb2YoKnJlcXVlc3QpKSkKLQkJCXJldHVybiAtRUZBVUxUOwotCi0JCXJlc3VsdCA9IG1lbXJhcl9yZXNlcnZlX2Jsb2NrKCZidWZmZXIsIGZpbHApOwotCQlpZiAocmVzdWx0ICE9IDApCi0JCQlyZXR1cm4gcmVzdWx0OwotCi0JCXJldHVybiBjb3B5X3RvX3VzZXIoYXJncCwgcmVxdWVzdCwgc2l6ZW9mKCpyZXF1ZXN0KSk7Ci0KLQljYXNlIFJBUl9IQU5ETEVSX1JFTEVBU0U6Ci0JCWlmIChjb3B5X2Zyb21fdXNlcigmcmFyX2hhbmRsZSwKLQkJCQkgICBhcmdwLAotCQkJCSAgIHNpemVvZihyYXJfaGFuZGxlKSkpCi0JCQlyZXR1cm4gLUVGQVVMVDsKLQotCQlyZXR1cm4gbWVtcmFyX3JlbGVhc2VfYmxvY2socmFyX2hhbmRsZSk7Ci0KLQljYXNlIFJBUl9IQU5ETEVSX1NUQVQ6Ci0JCWlmIChjb3B5X2Zyb21fdXNlcigmcmFyX2luZm8sCi0JCQkJICAgYXJncCwKLQkJCQkgICBzaXplb2YocmFyX2luZm8pKSkKLQkJCXJldHVybiAtRUZBVUxUOwotCi0JCS8qCi0JCSAqIFBvcHVsYXRlIHRoZSBSQVJfc3RhdCBzdHJ1Y3R1cmUgYmFzZWQgb24gdGhlIFJBUgotCQkgKiB0eXBlIGdpdmVuIGJ5IHRoZSB1c2VyCi0JCSAqLwotCQlpZiAobWVtcmFyX2dldF9zdGF0KCZyYXJfaW5mbykgIT0gMCkKLQkJCXJldHVybiAtRUlOVkFMOwotCi0JCS8qCi0JCSAqIEB0b2RvIERvIHdlIG5lZWQgdG8gdmVyaWZ5IGRlc3RpbmF0aW9uIHBvaW50ZXIKLQkJICogICAgICAgImFyZ3AiIGlzIG5vbi16ZXJvPyAgSXMgdGhhdCBhbHJlYWR5IGRvbmUgYnkKLQkJICogICAgICAgY29weV90b191c2VyKCk/Ci0JCSAqLwotCQlyZXR1cm4gY29weV90b191c2VyKGFyZ3AsCi0JCQkJICAgICZyYXJfaW5mbywKLQkJCQkgICAgc2l6ZW9mKHJhcl9pbmZvKSkgPyAtRUZBVUxUIDogMDsKLQotCWRlZmF1bHQ6Ci0JCXJldHVybiAtRU5PVFRZOwotCX0KLQotCXJldHVybiAwOwotfQotCi0vKioKLSAqCW1lbXJhcl9tbWFwCQktCW1tYXAgaGVscGVyIGZvciBkZXViZ2dpbmcKLSAqCUBmaWxwOiBoYW5kbGUgZG9pbmcgdGhlIG1hcHBpbmcKLSAqCUB2bWE6IG1lbW9yeSBhcmVhCi0gKgotICoJU3VwcG9ydCB0aGUgbW1hcCBvcGVyYXRpb24gb24gdGhlIFJBUiBzcGFjZSBmb3IgZGVidWdnaW5nIHN5c3RlbXMKLSAqCXdoZW4gdGhlIG1lbW9yeSBpcyBub3QgbG9ja2VkIGRvd24uCi0gKi8KLQotc3RhdGljIGludCBtZW1yYXJfbW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCi17Ci0JLyoKLQkgKiBUaGlzIG1tYXAoKSBpbXBsZW1lbnRhdGlvbiBpcyBwcmVkb21pbmFudGx5IHVzZWZ1bCBmb3IKLQkgKiBkZWJ1Z2dpbmcgc2luY2UgdGhlIENQVSB3aWxsIGJlIHByZXZlbnRlZCBmcm9tIGFjY2Vzc2luZwotCSAqIFJBUiBtZW1vcnkgYnkgdGhlIGhhcmR3YXJlIHdoZW4gUkFSIGlzIHByb3Blcmx5IGxvY2tlZAotCSAqIGRvd24uCi0JICoKLQkgKiBJbiBvcmRlciBmb3IgdGhpcyBpbXBsZW1lbnRhdGlvbiB0byBiZSB1c2VmdWwgUkFSIG1lbW9yeQotCSAqIG11c3QgYmUgbm90IGJlIGxvY2tlZCBkb3duLiAgSG93ZXZlciwgd2Ugb25seSB3YW50IHRvIGRvCi0JICogdGhhdCB3aGVuIGRlYnVnZ2luZy4gIERPIE5PVCBsZWF2ZSBSQVIgbWVtb3J5IHVubG9ja2VkIGluIGEKLQkgKiBkZXBsb3llZCBkZXZpY2UgdGhhdCB1dGlsaXplcyBSQVIuCi0JICovCi0KLQlzaXplX3QgY29uc3Qgc2l6ZSA9IHZtYS0+dm1fZW5kIC0gdm1hLT52bV9zdGFydDsKLQotCS8qIFVzZXJzIHBhc3MgdGhlIFJBUiBoYW5kbGUgYXMgdGhlIG1tYXAoKSBvZmZzZXQgcGFyYW1ldGVyLiAqLwotCXVuc2lnbmVkIGxvbmcgY29uc3QgaGFuZGxlID0gdm1hLT52bV9wZ29mZiA8PCBQQUdFX1NISUZUOwotCi0Jc3RydWN0IG1lbXJhcl9yYXJfaW5mbyAqIGNvbnN0IHJhciA9IG1lbXJhcl9nZXRfcmFyX2luZm8oaGFuZGxlKTsKLQl1bnNpZ25lZCBsb25nIHBmbjsKLQotCS8qIE9ubHkgYWxsb3cgcHJpdmlsZWRnZWQgYXBwcyB0byBnbyBwb2tpbmcgYXJvdW5kIHRoaXMgd2F5ICovCi0JaWYgKCFjYXBhYmxlKENBUF9TWVNfUkFXSU8pKQotCQlyZXR1cm4gLUVQRVJNOwotCi0JLyogSW52YWxpZCBSQVIgaGFuZGxlIG9yIHNpemUgcGFzc2VkIHRvIG1tYXAoKS4gKi8KLQlpZiAocmFyID09IE5VTEwKLQkgICAgfHwgaGFuZGxlID09IDAKLQkgICAgfHwgc2l6ZSA+IChoYW5kbGUgLSAodW5zaWduZWQgbG9uZykgcmFyLT5pb2Jhc2UpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCS8qCi0JICogUmV0cmlldmUgcGh5c2ljYWwgYWRkcmVzcyBjb3JyZXNwb25kaW5nIHRvIHRoZSBSQVIgaGFuZGxlLAotCSAqIGFuZCBjb252ZXJ0IGl0IHRvIGEgcGFnZSBmcmFtZS4KLQkgKi8KLQlwZm4gPSBtZW1yYXJfZ2V0X3BoeXNpY2FsX2FkZHJlc3MocmFyLCBoYW5kbGUpID4+IFBBR0VfU0hJRlQ7Ci0KLQotCXByX2RlYnVnKCJtZW1yYXI6IG1hcHBpbmcgUkFSIHJhbmdlIFsweCVseCwgMHglbHgpIGludG8gdXNlciBzcGFjZS5cbiIsCi0JCSBoYW5kbGUsCi0JCSBoYW5kbGUgKyBzaXplKTsKLQotCS8qCi0JICogTWFwIFJBUiBtZW1vcnkgaW50byB1c2VyIHNwYWNlLiAgVGhpcyBpcyByZWFsbHkgb25seSB1c2VmdWwKLQkgKiBmb3IgZGVidWdnaW5nIHB1cnBvc2VzIHNpbmNlIHRoZSBtZW1vcnkgd29uJ3QgYmUKLQkgKiBhY2Nlc3NpYmxlLCBpLmUuIHJlYWRzIHJldHVybiB6ZXJvIGFuZCB3cml0ZXMgYXJlIGlnbm9yZWQsCi0JICogd2hlbiBSQVIgYWNjZXNzIGNvbnRyb2wgaXMgZW5hYmxlZC4KLQkgKi8KLQlpZiAocmVtYXBfcGZuX3JhbmdlKHZtYSwKLQkJCSAgICB2bWEtPnZtX3N0YXJ0LAotCQkJICAgIHBmbiwKLQkJCSAgICBzaXplLAotCQkJICAgIHZtYS0+dm1fcGFnZV9wcm90KSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQkvKiB2bWEtPnZtX29wcyA9ICZtZW1yYXJfbWVtX29wczsgKi8KLQotCXJldHVybiAwOwotfQotCi0vKioKLSAqCW1lbXJhcl9vcGVuCQktCWRldmljZSBvcGVuIG1ldGhvZAotICoJQGlub2RlOiBpbm9kZSB0byBvcGVuCi0gKglAZmlscDogZmlsZSBoYW5kbGUKLSAqCi0gKglBcyB3ZSBzdXBwb3J0IG11bHRpcGxlIGFyYml0YXJ5IG9wZW5zIHRoZXJlIGlzIG5vIHdvcmsgdG8gYmUgZG9uZQotICoJcmVhbGx5LgotICovCi0KLXN0YXRpYyBpbnQgbWVtcmFyX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCi17Ci0Jbm9uc2Vla2FibGVfb3Blbihpbm9kZSwgZmlscCk7Ci0JcmV0dXJuIDA7Ci19Ci0KLS8qKgotICoJbWVtcmFyX3JlbGVhc2UJCS0JY2xvc2UgbWV0aG9kIGZvciBtaXNjZXYKLSAqCUBpbm9kZTogaW5vZGUgb2YgZGV2aWNlCi0gKglAZmlscDogaGFuZGxlIHRoYXQgaXMgZ29pbmcgYXdheQotICoKLSAqCUZyZWUgdXAgYWxsIHRoZSByZWdpb25zIHRoYXQgYmVsb25nIHRvIHRoaXMgZmlsZSBoYW5kbGUuIFdlIHVzZQotICoJdGhlIGhhbmRsZSBhcyBhIG5hdHVyYWwgTGludXggc3R5bGUgJ2xpZmV0aW1lJyBpbmRpY2F0b3IgYW5kIHRvCi0gKgllbnN1cmUgcmVzb3VyY2VzIGFyZSBub3QgbGVha2VkIHdoZW4gdGhlaXIgb3duZXIgZXhwbG9kZXMgaW4gYW4KLSAqCXVucGxhbm5lZCBmYXNoaW9uLgotICovCi0KLXN0YXRpYyBpbnQgbWVtcmFyX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCi17Ci0JLyogRnJlZSBhbGwgcmVnaW9ucyBhc3NvY2lhdGVkIHdpdGggdGhlIGdpdmVuIGZpbGUgaGFuZGxlLiAqLwotCi0Jc3RydWN0IG1lbXJhcl9idWZmZXJfaW5mbyAqcG9zOwotCXN0cnVjdCBtZW1yYXJfYnVmZmVyX2luZm8gKnRtcDsKLQlpbnQgejsKLQotCWZvciAoeiA9IDA7IHogIT0gTVJTVF9OVU1fUkFSOyArK3opIHsKLQkJc3RydWN0IG1lbXJhcl9yYXJfaW5mbyAqIGNvbnN0IHJhciA9ICZtZW1yYXJzW3pdOwotCi0JCW11dGV4X2xvY2soJnJhci0+bG9jayk7Ci0KLQkJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHBvcywKLQkJCQkJIHRtcCwKLQkJCQkJICZyYXItPmJ1ZmZlcnMubGlzdCwKLQkJCQkJIGxpc3QpIHsKLQkJCWlmIChmaWxwID09IHBvcy0+b3duZXIpCi0JCQkJa3JlZl9wdXQoJnBvcy0+cmVmY291bnQsCi0JCQkJCSBtZW1yYXJfcmVsZWFzZV9ibG9ja19pKTsKLQkJfQotCi0JCW11dGV4X3VubG9jaygmcmFyLT5sb2NrKTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotLyoqCi0gKglyYXJfcmVzZXJ2ZQkJLQlyZXNlcnZlIFJBUiBtZW1vcnkKLSAqCUBidWZmZXJzOiBidWZmZXJzIHRvIHJlc2VydmUKLSAqCUBjb3VudDogbnVtYmVyIHdhbnRlZAotICoKLSAqCVJlc2VydmUgYSBzZXJpZXMgb2YgYnVmZmVycyBpbiB0aGUgUkFSIHNwYWNlLiBSZXR1cm5zIHRoZSBudW1iZXIgb2YKLSAqCWJ1ZmZlcnMgc3VjY2Vzc2Z1bGx5IGFsbG9jYXRlZAotICovCi0KLXNpemVfdCByYXJfcmVzZXJ2ZShzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywgc2l6ZV90IGNvdW50KQotewotCXN0cnVjdCBSQVJfYnVmZmVyICogY29uc3QgZW5kID0KLQkJKGJ1ZmZlcnMgPT0gTlVMTCA/IGJ1ZmZlcnMgOiBidWZmZXJzICsgY291bnQpOwotCXN0cnVjdCBSQVJfYnVmZmVyICppOwotCi0Jc2l6ZV90IHJlc2VydmVfY291bnQgPSAwOwotCi0JZm9yIChpID0gYnVmZmVyczsgaSAhPSBlbmQ7ICsraSkgewotCQlpZiAobWVtcmFyX3Jlc2VydmVfYmxvY2soaSwgTlVMTCkgPT0gMCkKLQkJCSsrcmVzZXJ2ZV9jb3VudDsKLQkJZWxzZQotCQkJaS0+YnVzX2FkZHJlc3MgPSAwOwotCX0KLQotCXJldHVybiByZXNlcnZlX2NvdW50OwotfQotRVhQT1JUX1NZTUJPTChyYXJfcmVzZXJ2ZSk7Ci0KLS8qKgotICoJcmFyX3JlbGVhc2UJCS0JcmV0dXJuIFJBUiBidWZmZXJzCi0gKglAYnVmZmVyczogYnVmZmVycyB0byByZWxlYXNlCi0gKglAc2l6ZTogc2l6ZSBvZiByZWxlYXNlZCBibG9jawotICoKLSAqCVJldHVybiBhIHNldCBvZiBidWZmZXJzIHRvIHRoZSBSQVIgcG9vbAotICovCi0KLXNpemVfdCByYXJfcmVsZWFzZShzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywgc2l6ZV90IGNvdW50KQotewotCXN0cnVjdCBSQVJfYnVmZmVyICogY29uc3QgZW5kID0KLQkJKGJ1ZmZlcnMgPT0gTlVMTCA/IGJ1ZmZlcnMgOiBidWZmZXJzICsgY291bnQpOwotCXN0cnVjdCBSQVJfYnVmZmVyICppOwotCi0Jc2l6ZV90IHJlbGVhc2VfY291bnQgPSAwOwotCi0JZm9yIChpID0gYnVmZmVyczsgaSAhPSBlbmQ7ICsraSkgewotCQl1MzIgKiBjb25zdCBoYW5kbGUgPSAmaS0+aW5mby5oYW5kbGU7Ci0JCWlmIChtZW1yYXJfcmVsZWFzZV9ibG9jaygqaGFuZGxlKSA9PSAwKSB7Ci0JCQkvKgotCQkJICogQHRvZG8gV2UgYXNzdW1lIHdlIHNob3VsZCBkbyB0aGlzIGVhY2ggdGltZQotCQkJICogICAgICAgdGhlIHJlZiBjb3VudCBpcyBkZWNyZW1lbnRlZC4gIFNob3VsZAotCQkJICogICAgICAgd2UgaW5zdGVhZCBvbmx5IGRvIHRoaXMgd2hlbiB0aGUgcmVmCi0JCQkgKiAgICAgICBjb3VudCBoYXMgZHJvcHBlZCB0byB6ZXJvLCBhbmQgdGhlCi0JCQkgKiAgICAgICBidWZmZXIgaGFzIGJlZW4gY29tcGxldGVseQotCQkJICogICAgICAgcmVsZWFzZWQvdW5tYXBwZWQ/Ci0JCQkgKi8KLQkJCSpoYW5kbGUgPSAwOwotCQkJKytyZWxlYXNlX2NvdW50OwotCQl9Ci0JfQotCi0JcmV0dXJuIHJlbGVhc2VfY291bnQ7Ci19Ci1FWFBPUlRfU1lNQk9MKHJhcl9yZWxlYXNlKTsKLQotLyoqCi0gKglyYXJfaGFuZGxlX3RvX2J1cwktCVJBUiB0byBidXMgYWRkcmVzcwotICoJQGJ1ZmZlcnM6IFJBUiBidWZmZXIgc3RydWN0dXJlCi0gKglAY291bnQ6IG51bWJlciBvZiBidWZmZXJzIHRvIGNvbnZlcnQKLSAqCi0gKglUdXJuIGEgbGlzdCBvZiBSQVIgaGFuZGxlIG1hcHBpbmdzIGludG8gYWN0dWFsIGJ1cyBhZGRyZXNzZXMuIE5vdGUKLSAqCXRoYXQgd2hlbiB0aGUgZGV2aWNlIGlzIGxvY2tlZCBkb3duIHRoZSBidXMgYWRkcmVzc2VzIGluIHF1ZXN0aW9uCi0gKglhcmUgbm90IENQVSBhY2Nlc3NpYmxlLgotICovCi0KLXNpemVfdCByYXJfaGFuZGxlX3RvX2J1cyhzdHJ1Y3QgUkFSX2J1ZmZlciAqYnVmZmVycywgc2l6ZV90IGNvdW50KQotewotCXN0cnVjdCBSQVJfYnVmZmVyICogY29uc3QgZW5kID0KLQkJKGJ1ZmZlcnMgPT0gTlVMTCA/IGJ1ZmZlcnMgOiBidWZmZXJzICsgY291bnQpOwotCXN0cnVjdCBSQVJfYnVmZmVyICppOwotCXN0cnVjdCBtZW1yYXJfYnVmZmVyX2luZm8gKnBvczsKLQotCXNpemVfdCBjb252ZXJzaW9uX2NvdW50ID0gMDsKLQotCS8qCi0JICogRmluZCBhbGwgYnVzIGFkZHJlc3NlcyBjb3JyZXNwb25kaW5nIHRvIHRoZSBnaXZlbiBoYW5kbGVzLgotCSAqCi0JICogQHRvZG8gTm90IGxpa2luZyB0aGlzIG5lc3RlZCBsb29wLiAgT3B0aW1pemUuCi0JICovCi0JZm9yIChpID0gYnVmZmVyczsgaSAhPSBlbmQ7ICsraSkgewotCQlzdHJ1Y3QgbWVtcmFyX3Jhcl9pbmZvICogY29uc3QgcmFyID0KLQkJCW1lbXJhcl9nZXRfcmFyX2luZm8oaS0+aW5mby5oYW5kbGUpOwotCi0JCS8qCi0JCSAqIENoZWNrIGlmIHdlIGhhdmUgYSBib2d1cyBoYW5kbGUsIGFuZCB0aGVuIGNvbnRpbnVlCi0JCSAqIHdpdGggcmVtYWluaW5nIGJ1ZmZlcnMuCi0JCSAqLwotCQlpZiAocmFyID09IE5VTEwpIHsKLQkJCWktPmJ1c19hZGRyZXNzID0gMDsKLQkJCWNvbnRpbnVlOwotCQl9Ci0KLQkJbXV0ZXhfbG9jaygmcmFyLT5sb2NrKTsKLQotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJnJhci0+YnVmZmVycy5saXN0LCBsaXN0KSB7Ci0JCQlzdHJ1Y3QgUkFSX2Jsb2NrX2luZm8gKiBjb25zdCB1c2VyX2luZm8gPQotCQkJCSZwb3MtPmJ1ZmZlci5pbmZvOwotCi0JCQkvKgotCQkJICogVGFrZSBpbnRvIGFjY291bnQgaGFuZGxlIG9mZnNldHMgdGhhdCBtYXkKLQkJCSAqIGhhdmUgYmVlbiBhZGRlZCB0byB0aGUgYmFzZSBoYW5kbGUsIHN1Y2ggYXMKLQkJCSAqIGluIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW86Ci0JCQkgKgotCQkJICogICAgIHUzMiBoYW5kbGUgPSBiYXNlICsgb2Zmc2V0OwotCQkJICogICAgIHJhcl9oYW5kbGVfdG9fYnVzKGhhbmRsZSk7Ci0JCQkgKi8KLQotCQkJaWYgKGktPmluZm8uaGFuZGxlID49IHVzZXJfaW5mby0+aGFuZGxlCi0JCQkgICAgJiYgaS0+aW5mby5oYW5kbGUgPCAodXNlcl9pbmZvLT5oYW5kbGUKLQkJCQkJCSArIHVzZXJfaW5mby0+c2l6ZSkpIHsKLQkJCQl1MzIgY29uc3Qgb2Zmc2V0ID0KLQkJCQkJaS0+aW5mby5oYW5kbGUgLSB1c2VyX2luZm8tPmhhbmRsZTsKLQotCQkJCWktPmluZm8udHlwZSA9IHVzZXJfaW5mby0+dHlwZTsKLQkJCQlpLT5pbmZvLnNpemUgPSB1c2VyX2luZm8tPnNpemUgLSBvZmZzZXQ7Ci0JCQkJaS0+YnVzX2FkZHJlc3MgPQotCQkJCQlwb3MtPmJ1ZmZlci5idXNfYWRkcmVzcwotCQkJCQkrIG9mZnNldDsKLQotCQkJCS8qIEluY3JlbWVudCB0aGUgcmVmZXJlbmNlIGNvdW50LiAqLwotCQkJCWtyZWZfZ2V0KCZwb3MtPnJlZmNvdW50KTsKLQotCQkJCSsrY29udmVyc2lvbl9jb3VudDsKLQkJCQlicmVhazsKLQkJCX0gZWxzZSB7Ci0JCQkJaS0+YnVzX2FkZHJlc3MgPSAwOwotCQkJfQotCQl9Ci0KLQkJbXV0ZXhfdW5sb2NrKCZyYXItPmxvY2spOwotCX0KLQotCXJldHVybiBjb252ZXJzaW9uX2NvdW50OwotfQotRVhQT1JUX1NZTUJPTChyYXJfaGFuZGxlX3RvX2J1cyk7Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIG1lbXJhcl9mb3BzID0gewotCS5vd25lciA9IFRISVNfTU9EVUxFLAotCS51bmxvY2tlZF9pb2N0bCA9IG1lbXJhcl9pb2N0bCwKLQkubW1hcCAgICAgICAgICAgPSBtZW1yYXJfbW1hcCwKLQkub3BlbiAgICAgICAgICAgPSBtZW1yYXJfb3BlbiwKLQkucmVsZWFzZSAgICAgICAgPSBtZW1yYXJfcmVsZWFzZSwKLQkubGxzZWVrCQk9IG5vX2xsc2VlaywKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgbWlzY2RldmljZSBtZW1yYXJfbWlzY2RldiA9IHsKLQkubWlub3IgPSBNSVNDX0RZTkFNSUNfTUlOT1IsICAgIC8qIGR5bmFtaWMgYWxsb2NhdGlvbiAqLwotCS5uYW1lID0gIm1lbXJhciIsICAgICAgICAgICAgICAgLyogL2Rldi9tZW1yYXIgKi8KLQkuZm9wcyA9ICZtZW1yYXJfZm9wcwotfTsKLQotc3RhdGljIGNoYXIgY29uc3QgYmFubmVyW10gX19pbml0ZGF0YSA9Ci0JS0VSTl9JTkZPCi0JIkludGVsIFJBUiBIYW5kbGVyOiAiIE1FTVJBUl9WRVIgIiBpbml0aWFsaXplZC5cbiI7Ci0KLS8qKgotICoJbWVtcmFyX3JlZ2lzdHJhdGlvbl9jYWxsYmFjawktCVJBUiBvYnRhaW5lZAotICoJQHJhcjogUkFSIG51bWJlcgotICoKLSAqCVdlIGhhdmUgYmVlbiBncmFudGVkIG93bmVyc2hpcCBvZiB0aGUgUkFSLiBBZGQgaXQgdG8gb3VyIG1lbW9yeQotICoJbWFuYWdlbWVudCB0YWJsZXMKLSAqLwotCi1zdGF0aWMgaW50IG1lbXJhcl9yZWdpc3RyYXRpb25fY2FsbGJhY2sodW5zaWduZWQgbG9uZyByYXIpCi17Ci0JLyoKLQkgKiBXZSBpbml0aWFsaXplIHRoZSBSQVIgcGFyYW1ldGVycyBlYXJseSBvbiBzbyB0aGF0IHdlIGNhbgotCSAqIGRpc2NvbnRpbnVlIG1lbXJhciBkZXZpY2UgaW5pdGlhbGl6YXRpb24gYW5kIHJlZ2lzdHJhdGlvbgotCSAqIGlmIHN1aXRhYmx5IGNvbmZpZ3VyZWQgUkFScyBhcmUgbm90IGF2YWlsYWJsZS4KLQkgKi8KLQlyZXR1cm4gbWVtcmFyX2luaXRfcmFyX3Jlc291cmNlcyhyYXIsIG1lbXJhcl9taXNjZGV2Lm5hbWUpOwotfQotCi0vKioKLSAqCW1lbXJhcl9pbml0CS0JaW5pdGlhbGlzZSBSQVIgc3VwcG9ydAotICoKLSAqCUluaXRpYWxpc2Ugc3VwcG9ydCBmb3IgUkFSIGhhbmRsZXJzLiBUaGlzIG1heSBnZXQgbG9hZGVkIGJlZm9yZQotICoJdGhlIFJBUiBzdXBwb3J0IGlzIGFjdGl2YXRlZCwgYnV0IHRoZSBjYWxsYmFja3Mgb24gdGhlIHJlZ2lzdHJhdGlvbgotICoJd2lsbCBoYW5kbGUgdGhhdCBzaXR1YXRpb24gZm9yIHVzIGFueXdheS4KLSAqLwotCi1zdGF0aWMgaW50IF9faW5pdCBtZW1yYXJfaW5pdCh2b2lkKQotewotCWludCBlcnI7Ci0JaW50IGk7Ci0KLQlwcmludGsoYmFubmVyKTsKLQotCS8qCi0JICogU29tZSBkZWxheWVkIGluaXRpYWxpemF0aW9uIGlzIHBlcmZvcm1lZCBpbiB0aGlzIGRyaXZlci4KLQkgKiBNYWtlIHN1cmUgcmVzb3VyY2VzIHRoYXQgYXJlIHVzZWQgZHVyaW5nIGRyaXZlciBjbGVhbi11cAotCSAqIChlLmcuIGR1cmluZyBkcml2ZXIncyByZWxlYXNlKCkgZnVuY3Rpb24pIGFyZSBmdWxseQotCSAqIGluaXRpYWxpemVkIGJlZm9yZSBmaXJzdCB1c2UuICBUaGlzIGlzIHBhcnRpY3VsYXJseQotCSAqIGltcG9ydGFudCBmb3IgdGhlIGNhc2Ugd2hlbiB0aGUgZGVsYXllZCBpbml0aWFsaXphdGlvbgotCSAqIGlzbid0IGNvbXBsZXRlZCwgbGVhdmluZyBiZWhpbmQgYSBwYXJ0aWFsbHkgaW5pdGlhbGl6ZWQKLQkgKiBkcml2ZXIuCi0JICoKLQkgKiBTdWNoIGEgc2NlbmFyaW8gY2FuIG9jY3VyIHdoZW4gUkFSIGlzIG5vdCBhdmFpbGFibGUgb24gdGhlCi0JICogcGxhdGZvcm0sIGFuZCB0aGUgZHJpdmVyIGlzIHJlbGVhc2UoKWQuCi0JICovCi0JZm9yIChpID0gMDsgaSAhPSBBUlJBWV9TSVpFKG1lbXJhcnMpOyArK2kpIHsKLQkJc3RydWN0IG1lbXJhcl9yYXJfaW5mbyAqIGNvbnN0IHJhciA9ICZtZW1yYXJzW2ldOwotCQltdXRleF9pbml0KCZyYXItPmxvY2spOwotCQlJTklUX0xJU1RfSEVBRCgmcmFyLT5idWZmZXJzLmxpc3QpOwotCX0KLQotCWVyciA9IG1pc2NfcmVnaXN0ZXIoJm1lbXJhcl9taXNjZGV2KTsKLQlpZiAoZXJyKQotCQlyZXR1cm4gZXJyOwotCi0JLyogTm93IGNsYWltIHRoZSB0d28gUkFScyB3ZSB3YW50ICovCi0JZXJyID0gcmVnaXN0ZXJfcmFyKDAsIG1lbXJhcl9yZWdpc3RyYXRpb25fY2FsbGJhY2ssIDApOwotCWlmIChlcnIpCi0JCWdvdG8gZmFpbDsKLQotCWVyciA9IHJlZ2lzdGVyX3JhcigxLCBtZW1yYXJfcmVnaXN0cmF0aW9uX2NhbGxiYWNrLCAxKTsKLQlpZiAoZXJyID09IDApCi0JCXJldHVybiAwOwotCi0JLyogSXQgaXMgcG9zc2libGUgcmFyIDAgcmVnaXN0ZXJlZCBhbmQgYWxsb2NhdGVkIHJlc291cmNlcyB0aGVuIHJhciAxCi0JICAgZmFpbGVkIHNvIGRvIGEgZnVsbCByZXNvdXJjZSBmcmVlICovCi0JbWVtcmFyX2ZpbmlfcmFyX3Jlc291cmNlcygpOwotZmFpbDoKLQltaXNjX2RlcmVnaXN0ZXIoJm1lbXJhcl9taXNjZGV2KTsKLQlyZXR1cm4gZXJyOwotfQotCi0vKioKLSAqCW1lbXJhcl9leGl0CS0JdW5yZWdpc3RlciBhbmQgdW5sb2FkCi0gKgotICoJVW5yZWdpc3RlciB0aGUgZGV2aWNlIGFuZCB0aGVuIHVubG9hZCBhbnkgbWFwcGluZ3MgYW5kIHJlbGVhc2UKLSAqCXRoZSBSQVIgcmVzb3VyY2VzCi0gKi8KLQotc3RhdGljIHZvaWQgX19leGl0IG1lbXJhcl9leGl0KHZvaWQpCi17Ci0JbWlzY19kZXJlZ2lzdGVyKCZtZW1yYXJfbWlzY2Rldik7Ci0JbWVtcmFyX2ZpbmlfcmFyX3Jlc291cmNlcygpOwotfQotCi0KLW1vZHVsZV9pbml0KG1lbXJhcl9pbml0KTsKLW1vZHVsZV9leGl0KG1lbXJhcl9leGl0KTsKLQotCi1NT0RVTEVfQVVUSE9SKCJPc3NhbWEgT3RobWFuIDxvc3NhbWEub3RobWFuQGludGVsLmNvbT4iKTsKLU1PRFVMRV9ERVNDUklQVElPTigiSW50ZWwgUmVzdHJpY3RlZCBBY2Nlc3MgUmVnaW9uIEhhbmRsZXIiKTsKLU1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKLU1PRFVMRV9WRVJTSU9OKE1FTVJBUl9WRVIpOwotCi0KLQotLyoKLSAgTG9jYWwgVmFyaWFibGVzOgotICAgIGMtZmlsZS1zdHlsZTogImxpbnV4IgotICBFbmQ6Ci0qLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL21zbS9tZHA0X292ZXJsYXkuYyBiL2RyaXZlcnMvc3RhZ2luZy9tc20vbWRwNF9vdmVybGF5LmMKaW5kZXggZGUyODRjMi4uYjlhY2Y1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21zbS9tZHA0X292ZXJsYXkuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbXNtL21kcDRfb3ZlcmxheS5jCkBAIC02OTYsNyArNjk2LDcgQEAKIAlzdGFnZSA9IHBpcGUtPm1peGVyX3N0YWdlOwogCW1peGVyID0gcGlwZS0+bWl4ZXJfbnVtOwogCi0JaWYgKHBpcGUgIT0gY3RybC0+c3RhZ2VbbWl4ZXJdW3N0YWdlXSkJLyogbm90IHJ1bmluZyAqLworCWlmIChwaXBlICE9IGN0cmwtPnN0YWdlW21peGVyXVtzdGFnZV0pCS8qIG5vdCBydW5uaW5nICovCiAJCXJldHVybjsKIAogCS8qIE1EUF9MQVlFUk1JWEVSX0lOX0NGRywgc2hhcmQgYnkgYm90aCBtaXhlciAwIGFuZCAxICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL21zbS9tZHBfcHBwX2RxLmMgYi9kcml2ZXJzL3N0YWdpbmcvbXNtL21kcF9wcHBfZHEuYwppbmRleCAzZGMxYzBjLi4zYTY4N2M3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvbXNtL21kcF9wcHBfZHEuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbXNtL21kcF9wcHBfZHEuYwpAQCAtMjAwLDcgKzIwMCw3IEBACiAJCW1zbV9mYl9lbnN1cmVfbWVtX2NvaGVyZW5jeV9hZnRlcl9kbWEoam9iLT5pbmZvLCAmam9iLT5yZXEsIDEpOwogCiAJCS8qIFNjaGVkdWxlIGpvYnMgZm9yIGNsZWFudXAKLQkJICogQSBzZXBlcmF0ZSB3b3JrZXIgdGhyZWFkIGRvZXMgdGhpcyAqLworCQkgKiBBIHNlcGFyYXRlIHdvcmtlciB0aHJlYWQgZG9lcyB0aGlzICovCiAJCXF1ZXVlX2RlbGF5ZWRfd29yayhtZHBfcHBwX2Rqb2JfY2xuciwgJmpvYi0+Y2xlYW5lciwKIAkJCW1kcF90aW1lcl9kdXJhdGlvbik7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL21zbS9tc21fZmIuYyBiL2RyaXZlcnMvc3RhZ2luZy9tc20vbXNtX2ZiLmMKaW5kZXggYTJmMjlkNC4uZTdlZjgzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21zbS9tc21fZmIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbXNtL21zbV9mYi5jCkBAIC04NTksNyArODU5LDcgQEAKIAkJYnJlYWs7CiAKIAlkZWZhdWx0OgotCQlNU01fRkJfRVJSKCJtc21fZmJfaW5pdDogZmIgJWQgdW5rb3duIGltYWdlIHR5cGUhXG4iLAorCQlNU01fRkJfRVJSKCJtc21fZmJfaW5pdDogZmIgJWQgdW5rbm93biBpbWFnZSB0eXBlIVxuIiwKIAkJCSAgIG1mZC0+aW5kZXgpOwogCQlyZXR1cm4gcmV0OwogCX0KQEAgLTE3OTMsOSArMTc5Myw5IEBACiAvKgogICogTk9URTogVGhlIHVzZXJzcGFjZSBpc3N1ZXMgYmxpdCBvcGVyYXRpb25zIGluIGEgc2VxdWVuY2UsIHRoZSBzZXF1ZW5jZQogICogc3RhcnQgd2l0aCBhIG9wZXJhdGlvbiBtYXJrZWQgU1RBUlQgYW5kIGVuZHMgaW4gYW4gb3BlcmF0aW9uIG1hcmtlZAotICogRU5ELiBJdCBpcyBndXJhbnRlZWQgYnkgdGhlIHVzZXJzcGFjZSB0aGF0IGFsbCB0aGUgYmxpdCBvcGVyYXRpb25zCisgKiBFTkQuIEl0IGlzIGd1YXJhbnRlZWQgYnkgdGhlIHVzZXJzcGFjZSB0aGF0IGFsbCB0aGUgYmxpdCBvcGVyYXRpb25zCiAgKiBiZXR3ZWVuIFNUQVJUIGFuZCBFTkQgYXJlIG9ubHkgd2l0aGluIHRoZSByZWdpb25zIG9mIGFyZWFzIGRlc2lnbmF0ZWQKLSAqIGJ5IHRoZSBTVEFSVCBhbmQgRU5EIG9wZXJhdGlvbnMgYW5kIHRoYXQgdGhlIHVzZXJzcGFjZSBkb2VzbnQgbW9kaWZ5CisgKiBieSB0aGUgU1RBUlQgYW5kIEVORCBvcGVyYXRpb25zIGFuZCB0aGF0IHRoZSB1c2Vyc3BhY2UgZG9lc24ndCBtb2RpZnkKICAqIHRob3NlIGFyZWFzLiBIZW5jZSBpdCB3b3VsZCBiZSBlbm91Z2ggdG8gcGVyZm9ybSBiYXJyaWVyL2NhY2hlIG9wZXJhdGlvbnMKICAqIG9ubHkgb24gdGhlIFNUQVJUIGFuZCBFTkQgb3BlcmF0aW9ucy4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWNtZC1xdWV1ZS5oIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWNtZC1xdWV1ZS5oCmluZGV4IDU5ZDIyMTQuLjYxNDY1M2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1jbWQtcXVldWUuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtY21kLXF1ZXVlLmgKQEAgLTIxNCw3ICsyMTQsNyBAQAogCS8qCiAJICogV2FybmluZzogVGhpcyBjb2RlIGN1cnJlbnRseSBvbmx5IHdvcmtzIHdpdGggZGV2aWNlcyB0aGF0CiAJICogaGF2ZSAyNTYgcXVldWVzIG9yIGxlc3MuIERldmljZXMgd2l0aCBtb3JlIHRoYW4gMTYgcXVldWVzCi0JICogYXJlIGxheWVkIG91dCBpbiBtZW1vcnkgdG8gYWxsb3cgY29yZXMgcXVpY2sgYWNjZXNzIHRvCisJICogYXJlIGxhaWQgb3V0IGluIG1lbW9yeSB0byBhbGxvdyBjb3JlcyBxdWljayBhY2Nlc3MgdG8KIAkgKiBldmVyeSAxNnRoIHF1ZXVlLiBUaGlzIHJlZHVjZXMgY2FjaGUgdGhyYXNoaW5nIHdoZW4geW91IGFyZQogCSAqIHJ1bm5pbmcgMTYgcXVldWVzIHBlciBwb3J0IHRvIHN1cHBvcnQgbG9ja2xlc3Mgb3BlcmF0aW9uLgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWZwYS5oIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWZwYS5oCmluZGV4IDUwYThjOTEuLjFmMDRmOTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1mcGEuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtZnBhLmgKQEAgLTE5NSw3ICsxOTUsNyBAQAogCWN2bXhfZnBhX2lvYmRtYV9kYXRhX3QgZGF0YTsKIAogCS8qCi0JICogSGFyZHdhcmUgb25seSB1c2VzIDY0IGJpdCBhbGxpZ25lZCBsb2NhdGlvbnMsIHNvIGNvbnZlcnQKKwkgKiBIYXJkd2FyZSBvbmx5IHVzZXMgNjQgYml0IGFsaWduZWQgbG9jYXRpb25zLCBzbyBjb252ZXJ0CiAJICogZnJvbSBieXRlIGFkZHJlc3MgdG8gNjQtYml0IGluZGV4CiAJICovCiAJZGF0YS5zLnNjcmFkZHIgPSBzY3JfYWRkciA+PiAzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWhlbHBlci1ib2FyZC5oIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWhlbHBlci1ib2FyZC5oCmluZGV4IDYxMWE4ZTAuLmI0NjViZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1oZWxwZXItYm9hcmQuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtaGVscGVyLWJvYXJkLmgKQEAgLTgxLDcgKzgxLDcgQEAKICAqIEBwaHlfYWRkcjogIFRoZSBhZGRyZXNzIG9mIHRoZSBQSFkgdG8gcHJvZ3JhbQogICogQGxpbmtfZmxhZ3M6CiAgKiAgICAgICAgICAgICAgICAgIEZsYWdzIHRvIGNvbnRyb2wgYXV0b25lZ290aWF0aW9uLiAgQml0IDAgaXMgYXV0b25lZ290aWF0aW9uCi0gKiAgICAgICAgICAgICAgICAgIGVuYWJsZS9kaXNhYmxlIHRvIG1haW50YWluIGJhY2t3YXJlIGNvbXBhdGFiaWxpdHkuCisgKiAgICAgICAgICAgICAgICAgIGVuYWJsZS9kaXNhYmxlIHRvIG1haW50YWluIGJhY2t3YXJlIGNvbXBhdGliaWxpdHkuCiAgKiBAbGlua19pbmZvOiBMaW5rIHNwZWVkIHRvIHByb2dyYW0uIElmIHRoZSBzcGVlZCBpcyB6ZXJvIGFuZCBhdXRvbmVnb3RpYXRpb24KICAqICAgICAgICAgICAgICAgICAgaXMgZW5hYmxlZCwgYWxsIHBvc3NpYmxlIG5lZ290aWF0aW9uIHNwZWVkcyBhcmUgYWR2ZXJ0aXNlZC4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtaGVscGVyLXV0aWwuYyBiL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1oZWxwZXItdXRpbC5jCmluZGV4IDQxZWY4YTQuLjEzMTE4MmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1oZWxwZXItdXRpbC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1oZWxwZXItdXRpbC5jCkBAIC0zNjIsNyArMzYyLDcgQEAKIH0KIAogLyoqCi0gKiBSZXR1cm5zIHRoZSBJUEQvUEtPIHBvcnQgbnVtYmVyIGZvciBhIHBvcnQgb24gdGVoIGdpdmVuCisgKiBSZXR1cm5zIHRoZSBJUEQvUEtPIHBvcnQgbnVtYmVyIGZvciBhIHBvcnQgb24gdGhlIGdpdmVuCiAgKiBpbnRlcmZhY2UuCiAgKgogICogQGludGVyZmFjZTogSW50ZXJmYWNlIHRvIHVzZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWhlbHBlci5jIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LWhlbHBlci5jCmluZGV4IDU5MTUwNjYuLmU5YzVjODMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1oZWxwZXIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtaGVscGVyLmMKQEAgLTY5MSw3ICs2OTEsNyBAQAogCiAJCWlmICghcmV0cnlfY250KQogCQkJY3ZteF9kcHJpbnRmKCJXQVJOSU5HOiBGSVhfSVBEX1BUUl9BTElHTk1FTlQgIgotCQkJCSAgICAgImdldF93b3JrKCkgdGltZW91dCBvY2N1cmVkLlxuIik7CisJCQkJICAgICAiZ2V0X3dvcmsoKSB0aW1lb3V0IG9jY3VycmVkLlxuIik7CiAKIAkJLyogRnJlZSBwYWNrZXQgKi8KIAkJaWYgKHdvcmspCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtbWRpby5oIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LW1kaW8uaAppbmRleCBmNDVkYzQ5Li5kODhhYjhkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtbWRpby5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1tZGlvLmgKQEAgLTI1NCw3ICsyNTQsNyBAQAogI2RlZmluZSBNRElPX0NMQVVTRV80NV9SRUFEX0lOQyAyCiAjZGVmaW5lIE1ESU9fQ0xBVVNFXzQ1X1JFQUQgICAgIDMKIAotLyogTU1EIGlkZW50aWZpZXJzLCBtb3N0bHkgZm9yIGFjY2Vzc2luZyBkZXZpY2VzIHdpdGhpbmcgWEVOUEFLIG1vZHVsZXMuICovCisvKiBNTUQgaWRlbnRpZmllcnMsIG1vc3RseSBmb3IgYWNjZXNzaW5nIGRldmljZXMgd2l0aGluIFhFTlBBSyBtb2R1bGVzLiAqLwogI2RlZmluZSBDVk1YX01NRF9ERVZJQ0VfUE1BX1BNRCAgICAgIDEKICNkZWZpbmUgQ1ZNWF9NTURfREVWSUNFX1dJUyAgICAgICAgICAyCiAjZGVmaW5lIENWTVhfTU1EX0RFVklDRV9QQ1MgICAgICAgICAgMwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LXBrby5oIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LXBrby5oCmluZGV4IGYwNjhjMTkuLmRlMzQxMmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1wa28uaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtcGtvLmgKQEAgLTk4LDcgKzk4LDcgQEAKIAkvKgogCSAqIFBLTyBkb2Vzbid0IGRvIGFueSBsb2NraW5nLiBJdCBpcyB0aGUgcmVzcG9uc2liaWxpdHkgb2YgdGhlCiAJICogYXBwbGljYXRpb24gdG8gbWFrZSBzdXJlIHRoYXQgbm8gb3RoZXIgY29yZSBpcyBhY2Nlc3NpbmcKLQkgKiB0aGUgc2FtZSBxdWV1ZSBhdCB0aGUgc21hZSB0aW1lCisJICogdGhlIHNhbWUgcXVldWUgYXQgdGhlIHNhbWUgdGltZQogCSAqLwogCUNWTVhfUEtPX0xPQ0tfTk9ORSA9IDAsCiAJLyoKQEAgLTMyNCw3ICszMjQsNyBAQAogICogLSBDVk1YX1BLT19MT0NLX05PTkUKICAqICAgICAgLSBQS08gZG9lc24ndCBkbyBhbnkgbG9ja2luZy4gSXQgaXMgdGhlIHJlc3BvbnNpYmlsaXR5CiAgKiAgICAgICAgICBvZiB0aGUgYXBwbGljYXRpb24gdG8gbWFrZSBzdXJlIHRoYXQgbm8gb3RoZXIgY29yZQotICogICAgICAgICAgaXMgYWNjZXNzaW5nIHRoZSBzYW1lIHF1ZXVlIGF0IHRoZSBzbWFlIHRpbWUuCisgKiAgICAgICAgICBpcyBhY2Nlc3NpbmcgdGhlIHNhbWUgcXVldWUgYXQgdGhlIHNhbWUgdGltZS4KICAqIC0gQ1ZNWF9QS09fTE9DS19BVE9NSUNfVEFHCiAgKiAgICAgIC0gUEtPIHBlcmZvcm1zIGFuIGF0b21pYyB0YWdzd2l0Y2ggdG8gaW5zdXJlIGV4Y2x1c2l2ZQogICogICAgICAgICAgYWNjZXNzIHRvIHRoZSBvdXRwdXQgcXVldWUuIFRoaXMgd2lsbCBtYWludGFpbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LXBvdy5oIGIvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9jdm14LXBvdy5oCmluZGV4IGJmOWUwNjkuLjk5OWFlZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vY3Rlb24vY3ZteC1wb3cuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2N2bXgtcG93LmgKQEAgLTE0OTIsOCArMTQ5Miw4IEBACiAvKioKICAqIFN3aXRjaCB0byBhIE5VTEwgdGFnLCB3aGljaCBlbmRzIGFueSBvcmRlcmluZyBvcgogICogc3luY2hyb25pemF0aW9uIHByb3ZpZGVkIGJ5IHRoZSBQT1cgZm9yIHRoZSBjdXJyZW50Ci0gKiB3b3JrIHF1ZXVlIGVudHJ5LiAgVGhpcyBvcGVyYXRpb24gY29tcGxldGVzIGltbWVkaWF0bHksCi0gKiBzbyBjb21wbGV0ZXRpb24gc2hvdWxkIG5vdCBiZSB3YWl0ZWQgZm9yLgorICogd29yayBxdWV1ZSBlbnRyeS4gIFRoaXMgb3BlcmF0aW9uIGNvbXBsZXRlcyBpbW1lZGlhdGVseSwKKyAqIHNvIGNvbXBsZXRpb24gc2hvdWxkIG5vdCBiZSB3YWl0ZWQgZm9yLgogICogVGhpcyBmdW5jdGlvbiBkb2VzIE5PVCB3YWl0IGZvciBwcmV2aW91cyB0YWcgc3dpdGNoZXMgdG8gY29tcGxldGUsCiAgKiBzbyB0aGUgY2FsbGVyIG11c3QgZW5zdXJlIHRoYXQgYW55IHByZXZpb3VzIHRhZyBzd2l0Y2hlcyBoYXZlIGNvbXBsZXRlZC4KICAqLwpAQCAtMTUzMiw4ICsxNTMyLDggQEAKIC8qKgogICogU3dpdGNoIHRvIGEgTlVMTCB0YWcsIHdoaWNoIGVuZHMgYW55IG9yZGVyaW5nIG9yCiAgKiBzeW5jaHJvbml6YXRpb24gcHJvdmlkZWQgYnkgdGhlIFBPVyBmb3IgdGhlIGN1cnJlbnQKLSAqIHdvcmsgcXVldWUgZW50cnkuICBUaGlzIG9wZXJhdGlvbiBjb21wbGV0ZXMgaW1tZWRpYXRseSwKLSAqIHNvIGNvbXBsZXRldGlvbiBzaG91bGQgbm90IGJlIHdhaXRlZCBmb3IuCisgKiB3b3JrIHF1ZXVlIGVudHJ5LiAgVGhpcyBvcGVyYXRpb24gY29tcGxldGVzIGltbWVkaWF0ZWx5LAorICogc28gY29tcGxldGlvbiBzaG91bGQgbm90IGJlIHdhaXRlZCBmb3IuCiAgKiBUaGlzIGZ1bmN0aW9uIHdhaXRzIGZvciBhbnkgcGVuZGluZyB0YWcgc3dpdGNoZXMgdG8gY29tcGxldGUKICAqIGJlZm9yZSByZXF1ZXN0aW5nIHRoZSBzd2l0Y2ggdG8gTlVMTC4KICAqLwpAQCAtMTY3Miw3ICsxNjcyLDcgQEAKIAogLyoqCiAgKiBQZXJmb3JtcyBhIHRhZyBzd2l0Y2ggYW5kIHRoZW4gYW4gaW1tZWRpYXRlIGRlc2NoZWR1bGUuIFRoaXMgY29tcGxldGVzCi0gKiBpbW1lZGlhdGx5LCBzbyBjb21wbGV0aW9uIG11c3Qgbm90IGJlIHdhaXRlZCBmb3IuICBUaGlzIGZ1bmN0aW9uIGRvZXMgTk9UCisgKiBpbW1lZGlhdGVseSwgc28gY29tcGxldGlvbiBtdXN0IG5vdCBiZSB3YWl0ZWQgZm9yLiAgVGhpcyBmdW5jdGlvbiBkb2VzIE5PVAogICogdXBkYXRlIHRoZSB3cWUgaW4gRFJBTSB0byBtYXRjaCBhcmd1bWVudHMuCiAgKgogICogVGhpcyBmdW5jdGlvbiBkb2VzIE5PVCB3YWl0IGZvciBhbnkgcHJpb3IgdGFnIHN3aXRjaGVzIHRvIGNvbXBsZXRlLCBzbyB0aGUKQEAgLTE3NTgsNyArMTc1OCw3IEBACiAKIC8qKgogICogUGVyZm9ybXMgYSB0YWcgc3dpdGNoIGFuZCB0aGVuIGFuIGltbWVkaWF0ZSBkZXNjaGVkdWxlLiBUaGlzIGNvbXBsZXRlcwotICogaW1tZWRpYXRseSwgc28gY29tcGxldGlvbiBtdXN0IG5vdCBiZSB3YWl0ZWQgZm9yLiAgVGhpcyBmdW5jdGlvbiBkb2VzIE5PVAorICogaW1tZWRpYXRlbHksIHNvIGNvbXBsZXRpb24gbXVzdCBub3QgYmUgd2FpdGVkIGZvci4gIFRoaXMgZnVuY3Rpb24gZG9lcyBOT1QKICAqIHVwZGF0ZSB0aGUgd3FlIGluIERSQU0gdG8gbWF0Y2ggYXJndW1lbnRzLgogICoKICAqIFRoaXMgZnVuY3Rpb24gd2FpdHMgZm9yIGFueSBwcmlvciB0YWcgc3dpdGNoZXMgdG8gY29tcGxldGUsIHNvIHRoZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29jdGVvbi9ldGhlcm5ldC11dGlsLmggYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2V0aGVybmV0LXV0aWwuaAppbmRleCAyMzQ2NzU2Li5jNzQ1YTcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2V0aGVybmV0LXV0aWwuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvb2N0ZW9uL2V0aGVybmV0LXV0aWwuaApAQCAtNTUsNyArNTUsNyBAQAogCQlyZXR1cm4gMjsKIAllbHNlIGlmIChpcGRfcG9ydCA8IDQwKQkvKiBJbnRlcmZhY2UgMyBmb3IgbG9vcGJhY2sgKi8KIAkJcmV0dXJuIDM7Ci0JZWxzZSBpZiAoaXBkX3BvcnQgPT0gNDApCS8qIE5vbiBleGlzdGFudCBpbnRlcmZhY2UgZm9yIFBPVzAgKi8KKwllbHNlIGlmIChpcGRfcG9ydCA9PSA0MCkJLyogTm9uIGV4aXN0ZW50IGludGVyZmFjZSBmb3IgUE9XMCAqLwogCQlyZXR1cm4gNDsKIAllbHNlCiAJCXBhbmljKCJJbGxlZ2FsIGlwZF9wb3J0ICVkIHBhc3NlZCB0byBJTlRFUkZBQ0VcbiIsIGlwZF9wb3J0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vS2NvbmZpZyBiL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vS2NvbmZpZwppbmRleCBmMTA4MmY1Li5iMDUzMDY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvb2xwY19kY29uL0tjb25maWcKKysrIGIvZHJpdmVycy9zdGFnaW5nL29scGNfZGNvbi9LY29uZmlnCkBAIC05LDcgKzksNyBAQAogCiBjb25maWcgRkJfT0xQQ19EQ09OXzEKIAlib29sICJPTFBDIFhPLTEgRENPTiBzdXBwb3J0IgotCWRlcGVuZHMgb24gRkJfT0xQQ19EQ09OCisJZGVwZW5kcyBvbiBGQl9PTFBDX0RDT04gJiYgR1BJT19DUzU1MzUKIAlkZWZhdWx0IHkKIAktLS1oZWxwLS0tCiAJICBFbmFibGUgc3VwcG9ydCBmb3IgdGhlIERDT04gaW4gWE8tMSBtb2RlbCBsYXB0b3BzLiAgVGhlIGtlcm5lbApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL29scGNfZGNvbi9vbHBjX2Rjb25feG9fMS5jIGIvZHJpdmVycy9zdGFnaW5nL29scGNfZGNvbi9vbHBjX2Rjb25feG9fMS5jCmluZGV4IGIxNTRiZTcuLmI1ZDIxZjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vb2xwY19kY29uX3hvXzEuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvb2xwY19kY29uL29scGNfZGNvbl94b18xLmMKQEAgLTgwLDcgKzgwLDcgQEAKIAlsb2IgJj0gfigxIDw8IERDT05fSVJRKTsKIAlvdXRiKGxvYiwgMHg0ZDApOwogCi0JLyogUmVnaXN0ZXIgdGhlIGludGVydXB0IGhhbmRsZXIgKi8KKwkvKiBSZWdpc3RlciB0aGUgaW50ZXJydXB0IGhhbmRsZXIgKi8KIAlpZiAocmVxdWVzdF9pcnEoRENPTl9JUlEsICZkY29uX2ludGVycnVwdCwgMCwgIkRDT04iLCBkY29uKSkgewogCQlwcmludGsoS0VSTl9FUlIgIm9scGMtZGNvbjogZmFpbGVkIHRvIHJlcXVlc3QgRENPTidzIGlycVxuIik7CiAJCWdvdG8gZXJyX3JlcV9pcnE7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvb2xwY19kY29uL29scGNfZGNvbl94b18xXzUuYyBiL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vb2xwY19kY29uX3hvXzFfNS5jCmluZGV4IGUyMTNiNjMuLjdhYTliMWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vb2xwY19kY29uX3hvXzFfNS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vb2xwY19kY29uX3hvXzFfNS5jCkBAIC03LDYgKzcsNyBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9hY3BpLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CiAjaW5jbHVkZSA8YXNtL29scGMuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9wb2htZWxmcy9jcnlwdG8uYyBiL2RyaXZlcnMvc3RhZ2luZy9wb2htZWxmcy9jcnlwdG8uYwppbmRleCA2NTQwODY0Li41Y2NhMjRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcG9obWVsZnMvY3J5cHRvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3BvaG1lbGZzL2NyeXB0by5jCkBAIC03NDUsNyArNzQ1LDcgQEAKIAogCS8qCiAJICogQXQgdGhpcyBwb2ludCBORVRGU19DQVBBQklMSVRJRVMgcmVzcG9uc2UgY29tbWFuZAotCSAqIHNob3VsZCBzZXR1cCBzdXBlcmJsb2NrIGluIGEgd2F5LCB3aGljaCBpcyBhY2NlcHRpYmxlCisJICogc2hvdWxkIHNldHVwIHN1cGVyYmxvY2sgaW4gYSB3YXksIHdoaWNoIGlzIGFjY2VwdGFibGUKIAkgKiBmb3IgYm90aCBjbGllbnQgYW5kIHNlcnZlciwgc28gaWYgc2VydmVyIHJlZnVzZXMgY29ubmVjdGlvbiwKIAkgKiBpdCB3aWxsIHNlbmQgZXJyb3IgaW4gdHJhbnNhY3Rpb24gcmVzcG9uc2UuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcXVhdGVjaF91c2IyL3F1YXRlY2hfdXNiMi5jIGIvZHJpdmVycy9zdGFnaW5nL3F1YXRlY2hfdXNiMi9xdWF0ZWNoX3VzYjIuYwppbmRleCBjNDViMDllLi5jYTA5OGNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcXVhdGVjaF91c2IyL3F1YXRlY2hfdXNiMi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9xdWF0ZWNoX3VzYjIvcXVhdGVjaF91c2IyLmMKQEAgLTE0OCw3ICsxNDgsNyBAQAogICogdmFsdWUgb2YgdGhlIGxpbmUgc3RhdHVzIGZsYWdzIGZyb20gdGhlIHBvcnQKICAqIEBzaGFkb3dNU1I6IExhc3QgcmVjZWl2ZWQgc3RhdGUgb2YgdGhlIG1vZGVtIHN0YXR1cyByZWdpc3RlciwgaG9sZHMKICAqIHRoZSB2YWx1ZSBvZiB0aGUgbW9kZW0gc3RhdHVzIHJlY2VpdmVkIGZyb20gdGhlIHBvcnQKLSAqIEByY3ZfZmx1c2g6IEZsYWcgaW5kaWNhdGluZyB0aGF0IGEgcmVjZWl2ZSBmbHVzaCBoYXMgb2NjdXJlZCBvbgorICogQHJjdl9mbHVzaDogRmxhZyBpbmRpY2F0aW5nIHRoYXQgYSByZWNlaXZlIGZsdXNoIGhhcyBvY2N1cnJlZCBvbgogICogdGhlIGhhcmR3YXJlLgogICogQHhtaXRfZmx1c2g6IEZsYWcgaW5kaWNhdGluZyB0aGF0IGEgdHJhbnNtaXQgZmx1c2ggaGFzIGJlZW4gcHJvY2Vzc2VkIGJ5CiAgKiB0aGUgaGFyZHdhcmUuCkBAIC0xNTYsNyArMTU2LDcgQEAKICAqIGluY2x1ZGVzIHRoZSBzaXplIChleGNsdWRpbmcgaGVhZGVyKSBvZiBVUkJzIHRoYXQgaGF2ZSBiZWVuIHN1Ym1pdHRlZCBidXQKICAqIGhhdmUgbm90IHlldCBiZWVuIHNlbnQgdG8gdG8gdGhlIGRldmljZSwgYW5kIGJ5dGVzIHRoYXQgaGF2ZSBiZWVuIHNlbnQgb3V0CiAgKiBvZiB0aGUgcG9ydCBidXQgbm90IHlldCByZXBvcnRlZCBzZW50IGJ5IHRoZSAieG1pdF9lbXB0eSIgbWVzc2FnZXMgKHdoaWNoCi0gKiBpbmRpY2F0ZSB0aGUgbnVtYmVyIG9mIGJ5dGVzIHNlbnQgZWFjaCB0aW1lIHRoZXkgYXJlIHJlY2lldmVkLCBkZXNwaXRlIHRoZQorICogaW5kaWNhdGUgdGhlIG51bWJlciBvZiBieXRlcyBzZW50IGVhY2ggdGltZSB0aGV5IGFyZSByZWNlaXZlZCwgZGVzcGl0ZSB0aGUKICAqIG1pc2xlYWRpbmcgbmFtZSkuCiAgKiAtIFN0YXJ0cyBhdCB6ZXJvIHdoZW4gcG9ydCBpcyBpbml0aWFsaXNlZC4KICAqIC0gaXMgaW5jcmVtZW50ZWQgYnkgdGhlIHNpemUgb2YgdGhlIGRhdGEgdG8gYmUgd3JpdHRlbiAobm8gaGVhZGVycykKQEAgLTY0OSw3ICs2NDksNyBAQAogCS8qIGFsdGhvdWdoIHRoZSBVU0Igc2lkZSBpcyBub3cgZW1wdHksIHRoZSBVQVJUIGl0c2VsZiBtYXkKIAkgKiBzdGlsbCBiZSBwdXNoaW5nIGNoYXJhY3RlcnMgb3V0IG92ZXIgdGhlIGxpbmUsIHNvIHdlIGhhdmUgdG8KIAkgKiB3YWl0IHRlc3RpbmcgdGhlIGFjdHVhbCBsaW5lIHN0YXR1cyB1bnRpbCB0aGUgbGluZXMgY2hhbmdlCi0JICogaW5kaWNhdGluZyB0aGF0IHRoZSBkYXRhIGlzIGRvbmUgdHJhbnNmZXJpbmcuICovCisJICogaW5kaWNhdGluZyB0aGF0IHRoZSBkYXRhIGlzIGRvbmUgdHJhbnNmZXJyaW5nLiAqLwogCS8qIEZJWE1FOiBzbG93IHRoaXMgcG9sbGluZyBkb3duIHNvIGl0IGRvZXNuJ3QgcnVuIHRoZSBVU0IgYnVzIGZsYXQgb3V0CiAJICogaWYgaXQgYWN0dWFsbHkgaGFzIHRvIHNwZW5kIGFueSB0aW1lIGluIHRoaXMgbG9vcCAod2hpY2ggaXQgbm9ybWFsbHkKIAkgKiBkb2Vzbid0IGJlY2F1c2UgdGhlIGJ1ZmZlciBpcyBuZWFybHkgZW1wdHkpICovCkBAIC03MjYsNyArNzI2LDcgQEAKIAkJcmV0dXJuIDA7CiAJfSBlbHNlIGlmIChwb3J0X2V4dHJhLT50eF9wZW5kaW5nX2J5dGVzID49IFFUMl9GSUZPX0RFUFRIKSB7CiAJCS8qIGJ1ZmZlciBpcyBmdWxsICg9PSkuID4gc2hvdWxkIG5vdCBvY2N1ciwgYnV0IHdvdWxkIGluZGljYXRlCi0JCSAqIHRoYXQgYW4gb3ZlcmZsb3cgaGFkIG9jY3VyZWQgKi8KKwkJICogdGhhdCBhbiBvdmVyZmxvdyBoYWQgb2NjdXJyZWQgKi8KIAkJZGJnKCIlcygpOiBwb3J0IHRyYW5zbWl0IGJ1ZmZlciBpcyBmdWxsISIsIF9fZnVuY19fKTsKIAkJLyogc2NoZWR1bGVfd29yaygmcG9ydC0+d29yayk7IGNvbW1lbnRlZCBpbiB2ZW5kb3IgZHJpdmVyICovCiAJCXJldHVybiAwOwpAQCAtODIzLDcgKzgyMyw3IEBACiAJICogcmVkdWNlIHRoZSBmcmVlIHNwYWNlIGNvdW50IGJ5IHRoZSBzaXplIG9mIHRoZSBkaXNwYXRjaGVkIHdyaXRlLgogCSAqIFdoZW4gYSAidHJhbnNtaXQgZW1wdHkiIG1lc3NhZ2UgY29tZXMgYmFjayB1cCB0aGUgVVNCIHJlYWQgc3RyZWFtLAogCSAqIHdlIGRlY3JlbWVudCB0aGUgY291bnQgYnkgdGhlIG51bWJlciBvZiBieXRlcyByZXBvcnRlZCBzZW50LCB0aHVzCi0JICoga2VlcGluZyB0cmFjayBvZiB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHNlbnQgYW5kIHJlY2lldmVkIGJ5dGVzLgorCSAqIGtlZXBpbmcgdHJhY2sgb2YgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiBzZW50IGFuZCByZWNlaXZlZCBieXRlcy4KIAkgKi8KIAogCXJvb20gPSAoUVQyX0ZJRk9fREVQVEggLSBwb3J0X2V4dHJhLT50eF9wZW5kaW5nX2J5dGVzKTsKQEAgLTE3OTUsNyArMTc5NSw3IEBACiAJfQogfQogCi0vKiogQGJyaWVmIFJldHJlaXZlIHRoZSB2YWx1ZSBvZiBhIHJlZ2lzdGVyIGZyb20gdGhlIGRldmljZQorLyoqIEBicmllZiBSZXRyaWV2ZSB0aGUgdmFsdWUgb2YgYSByZWdpc3RlciBmcm9tIHRoZSBkZXZpY2UKICAqCiAgKiBJc3N1ZXMgYSBHRVRfUkVHSVNURVIgdmVuZG9yLXNwY2lmaWMgcmVxdWVzdCBvdmVyIHRoZSBVU0IgY29udHJvbAogICogcGlwZSB0byBvYnRhaW4gYSB2YWx1ZSBiYWNrIGZyb20gYSBzcGVjaWZpYyByZWdpc3RlciBvbiBhIHNwZWNpZmljCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NoaXAvcnRtcF9waHkuaCBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY2hpcC9ydG1wX3BoeS5oCmluZGV4IDk4NDU0ZGYuLmE1MjIyMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY2hpcC9ydG1wX3BoeS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY2hpcC9ydG1wX3BoeS5oCkBAIC00NjcsNyArNDY3LDcgQEAKIAkJCURCR1BSSU5UX0VSUigiQkJQIHdyaXRlIFIlZD0weCV4IGZhaWwuIEJ1c3lDbnQ9ICVkLmJQQ0ljbGtPZmYgPSAlZC4gXG4iLCBfSSwgQmJwQ3NyLndvcmQsIEJ1c3lDbnQsIChfQSktPmJQQ0ljbGtPZmYpOwlcCiAJCX0JCQkJCQkJCQkJCQkJCQkJCVwKIAl9IGVsc2UgewkJCQkJCQlcCi0JCURCR1BSSU5UX0VSUigiKioqKioqIEJCUF9Xcml0ZV9MYXRjaCBCdWZmZXIgZXhjZWVkcyBtYXggYm91bmRyeSAqKioqKiogXG4iKTsJXAorCQlEQkdQUklOVF9FUlIoIioqKioqKiBCQlBfV3JpdGVfTGF0Y2ggQnVmZmVyIGV4Y2VlZHMgbWF4IGJvdW5kYXJ5ICoqKioqKiBcbiIpOwlcCiAJfQkJCQkJCQkJCQkJCQkJCQkJCVwKIH0KICNlbmRpZiAvKiBSVE1QX01BQ19QQ0kgLy8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2JhX2FjdGlvbi5jIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vYmFfYWN0aW9uLmMKaW5kZXggNjJmNmY2Yi4uMTMzYmMxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vYmFfYWN0aW9uLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vYmFfYWN0aW9uLmMKQEAgLTI4LDcgKzI4LDcgQEAKICNpbmNsdWRlICIuLi9ydF9jb25maWcuaCIKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KIAotI2RlZmluZSBCQV9PUklfSU5JVF9TRVEJCShwRW50cnktPlR4U2VxW1RJRF0pCS8qMSAgICAgICAgICAgICAgICAgICAgICAgIC8vIGluaXRhbCBzZXF1ZW5jZSBudW1iZXIgb2YgQkEgc2Vzc2lvbiAqLworI2RlZmluZSBCQV9PUklfSU5JVF9TRVEJCShwRW50cnktPlR4U2VxW1RJRF0pCS8qMSAgICAgICAgICAgICAgICAgICAgICAgIC8vIGluaXRpYWwgc2VxdWVuY2UgbnVtYmVyIG9mIEJBIHNlc3Npb24gKi8KIAogI2RlZmluZSBPUklfU0VTU0lPTl9NQVhfUkVUUlkJOAogI2RlZmluZSBPUklfQkFfU0VTU0lPTl9USU1FT1VUCSgyMDAwKQkvKiBtcyAqLwpAQCAtMTQ4Nyw3ICsxNDg3LDcgQEAKIAogCQkvKgogCQkgKiBmbHVzaCBhbGwgcGVuZGluZyByZW9yZGVyaW5nIG1wZHVzCi0JCSAqIGFuZCByZWNldmluZyBtcGR1IHRvIHVwcGVyIGxheWVyCisJCSAqIGFuZCByZWNlaXZpbmcgbXBkdSB0byB1cHBlciBsYXllcgogCQkgKiBtYWtlIHRjcC9pcCB0byB0YWtlIGNhcmUgcmVvcmRlcmluZyBtZWNoYW5pc20KIAkJICovCiAJCS8qYmFfcmVmcmVzaF9yZW9yZGVyaW5nX21wZHVzKHBBZCwgcEJBRW50cnkpOyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2Flcy5jIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2Flcy5jCmluZGV4IGE5OTg3OWIuLmQ3MGQyMjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9hZXMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fYWVzLmMKQEAgLTg1OCw3ICs4NTgsNyBAQAogc3RhdGljIHVpbnQzMiBLVDJbMjU2XTsKIHN0YXRpYyB1aW50MzIgS1QzWzI1Nl07CiAKLS8qIHBsYXRmb3JtLWluZGVwZW5kYW50CTMyLWJpdCBpbnRlZ2VyIG1hbmlwdWxhdGlvbgltYWNyb3MgKi8KKy8qIHBsYXRmb3JtLWluZGVwZW5kZW50CTMyLWJpdCBpbnRlZ2VyIG1hbmlwdWxhdGlvbgltYWNyb3MgKi8KIAogI2RlZmluZQlHRVRfVUlOVDMyKG4sYixpKQkJCQkJCVwKIHsJCQkJCQkJCQkJCQlcCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fY2ZnLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fY2ZnLmMKaW5kZXggMjRmNDM5My4uNzI3Zjc5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2NmZy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9jZmcuYwpAQCAtMjIzLDcgKzIyMyw3IEBACiAgICAgICAgIHBBZGFwdGVyCVBvaW50ZXIgdG8gb3VyIGFkYXB0ZXIKICAgICAgICAga2V5U3RyaW5nCVdQQSBwcmUtc2hhcmVkIGtleSBzdHJpbmcKICAgICAgICAgcEhhc2hTdHIJU3RyaW5nIHVzZWQgZm9yIHBhc3N3b3JkIGhhc2ggZnVuY3Rpb24KLSAgICAgICAgaGFzaFN0ckxlbglMZW5naHQgb2YgdGhlIGhhc2ggc3RyaW5nCisgICAgICAgIGhhc2hTdHJMZW4JTGVuZ3RoIG9mIHRoZSBoYXNoIHN0cmluZwogICAgICAgICBwUE1LQnVmCQlPdXRwdXQgYnVmZmVyIG9mIFdQQVBTSyBrZXkKIAogICAgIFJldHVybjoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9kYXRhLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YS5jCmluZGV4IGY2YzE5M2MuLjMzNzk5ZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9kYXRhLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2RhdGEuYwpAQCAtMzM3LDcgKzMzNyw3IEBACiAKIAkvKiAqLwogCS8qIEluIFdNTS1VQVBTRCwgbWxtZSBmcmFtZSBzaG91bGQgYmUgc2V0IHBzbSBhcyBwb3dlciBzYXZpbmcgYnV0IHByb2JlIHJlcXVlc3QgZnJhbWUgKi8KLQkvKiBEYXRhLU51bGwgcGFja2V0cyBhbHNlIHBhc3MgdGhyb3VnaCBNTVJlcXVlc3QgaW4gUlQyODYwLCBob3dldmVyLCB3ZSBob3BlIGNvbnRyb2wgdGhlIHBzbSBiaXQgdG8gcGFzcyBBUFNEICovCisJLyogRGF0YS1OdWxsIHBhY2tldHMgYWxzbyBwYXNzIHRocm91Z2ggTU1SZXF1ZXN0IGluIFJUMjg2MCwgaG93ZXZlciwgd2UgaG9wZSBjb250cm9sIHRoZSBwc20gYml0IHRvIHBhc3MgQVBTRCAqLwogLyogICAgICBpZiAoKHBIZWFkZXJfODAyXzExLT5GQy5UeXBlICE9IEJUWVBFX0RBVEEpICYmIChwSGVhZGVyXzgwMl8xMS0+RkMuVHlwZSAhPSBCVFlQRV9DTlRMKSkgKi8KIAl7CiAJCWlmICgocEhlYWRlcl84MDJfMTEtPkZDLlN1YlR5cGUgPT0gU1VCVFlQRV9BQ1RJT04pIHx8CkBAIC0xOTMzLDcgKzE5MzMsNyBAQAogCiAJaWYgKFR5cGVMZW4gPD0gMTUwMCkgewkvKiA4MDIuMywgODAyLjMgTExDICovCiAJCS8qCi0JCSAgIERlc3RNQUMoNikgKyBTcmNNQUMoNikgKyBMZW5naHQoMikgKworCQkgICBEZXN0TUFDKDYpICsgU3JjTUFDKDYpICsgTGVuZ3RoKDIpICsKIAkJICAgRFNBUCgxKSArIFNTQVAoMSkgKyBDb250cm9sKDEpICsKIAkJICAgaWYgdGhlIERTQVAgPSAweEFBLCBTU0FQPTB4QUEsIENvbnRvcmwgPSAweDAzLCBpdCBoYXMgYSA1LWJ5dGVzIFNOQVAgaGVhZGVyLgogCQkgICA9PiArIFNOQVAgKDUsIE9yaWdpbmF0aW9uSUQoMykgKyBldGhlclR5cGUoMikpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YV9wY2kuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9kYXRhX3BjaS5jCmluZGV4IDdhZjU5ZmYuLmJlZjBiYmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9kYXRhX3BjaS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9kYXRhX3BjaS5jCkBAIC00MzgsMTMgKzQzOCwxMyBAQAogCS8qIEFkZCBSeCBzaXplIHRvIGNoYW5uZWwgbG9hZCBjb3VudGVyLCB3ZSBzaG91bGQgaWdub3JlIGVycm9yIGNvdW50cyAqLwogCXBBZC0+U3RhQ2ZnLkNMQnVzeUJ5dGVzICs9IChwUnhELT5TREwwICsgMTQpOwogCi0JLyogRHJvcCBUb0RzIHByb21pc2NvdXMgZnJhbWUsIGl0IGlzIG9wZW5lZCBkdWUgdG8gQ0NYIDIgY2hhbm5lbCBsb2FkIHN0YXRpc3RpY3MgKi8KKwkvKiBEcm9wIFRvRHMgcHJvbWlzY3VvdXMgZnJhbWUsIGl0IGlzIG9wZW5lZCBkdWUgdG8gQ0NYIDIgY2hhbm5lbCBsb2FkIHN0YXRpc3RpY3MgKi8KIAlpZiAocEhlYWRlciAhPSBOVUxMKSB7CiAJCWlmIChwSGVhZGVyLT5GQy5Ub0RzKSB7CiAJCQlyZXR1cm4gKE5ESVNfU1RBVFVTX0ZBSUxVUkUpOwogCQl9CiAJfQotCS8qIERyb3Agbm90IFUyTSBmcmFtZXMsIGNhbnQncyBkcm9wIGhlcmUgYmVjYXVzZSB3ZSB3aWxsIGRyb3AgYmVhY29uIGluIHRoaXMgY2FzZSAqLworCS8qIERyb3Agbm90IFUyTSBmcmFtZXMsIGNhbid0J3MgZHJvcCBoZXJlIGJlY2F1c2Ugd2Ugd2lsbCBkcm9wIGJlYWNvbiBpbiB0aGlzIGNhc2UgKi8KIAkvKiBJIGFtIGtpbmQgb2YgZG91YnRpbmcgdGhlIFUyTSBiaXQgb3BlcmF0aW9uICovCiAJLyogaWYgKHBSeEQtPlUyTSA9PSAwKSAqLwogCS8qICAgICAgcmV0dXJuKE5ESVNfU1RBVFVTX0ZBSUxVUkUpOyAqLwpAQCAtOTM5LDcgKzkzOSw3IEBACiAJLyogKi8KIAkvKiAqLwogCS8qIEluIFdNTS1VQVBTRCwgbWxtZSBmcmFtZSBzaG91bGQgYmUgc2V0IHBzbSBhcyBwb3dlciBzYXZpbmcgYnV0IHByb2JlIHJlcXVlc3QgZnJhbWUgKi8KLQkvKiBEYXRhLU51bGwgcGFja2V0cyBhbHNlIHBhc3MgdGhyb3VnaCBNTVJlcXVlc3QgaW4gUlQyODYwLCBob3dldmVyLCB3ZSBob3BlIGNvbnRyb2wgdGhlIHBzbSBiaXQgdG8gcGFzcyBBUFNEICovCisJLyogRGF0YS1OdWxsIHBhY2tldHMgYWxzbyBwYXNzIHRocm91Z2ggTU1SZXF1ZXN0IGluIFJUMjg2MCwgaG93ZXZlciwgd2UgaG9wZSBjb250cm9sIHRoZSBwc20gYml0IHRvIHBhc3MgQVBTRCAqLwogCWlmIChwSGVhZGVyXzgwMl8xMS0+RkMuVHlwZSAhPSBCVFlQRV9EQVRBKSB7CiAJCWlmICgocEhlYWRlcl84MDJfMTEtPkZDLlN1YlR5cGUgPT0gU1VCVFlQRV9QUk9CRV9SRVEpCiAJCSAgICB8fCAhKHBBZC0+Q29tbW9uQ2ZnLmJBUFNEQ2FwYWJsZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2RhdGFfdXNiLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YV91c2IuYwppbmRleCA3YzU2YzJmLi41NjM3ODU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YV91c2IuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YV91c2IuYwpAQCAtNzAyLDcgKzcwMiw3IEBACiAJKnBSeFBlbmRpbmcJCQlwZW5kaW5nIHJlY2VpdmVkIHBhY2tldCBmbGFnCiAKIFJldHVybiBWYWx1ZToKLSAgICB0aGUgcmVjaWV2ZWQgcGFja2V0CisgICAgdGhlIHJlY2VpdmVkIHBhY2tldAogCiBOb3RlOgogPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CkBAIC04NTAsNyArODUwLDcgQEAKIAkvKiBBZGQgUnggc2l6ZSB0byBjaGFubmVsIGxvYWQgY291bnRlciwgd2Ugc2hvdWxkIGlnbm9yZSBlcnJvciBjb3VudHMgKi8KIAlwQWQtPlN0YUNmZy5DTEJ1c3lCeXRlcyArPSAocFJ4V0ktPk1QRFV0b3RhbEJ5dGVDb3VudCArIDE0KTsKIAotCS8qIERyb3AgVG9EcyBwcm9taXNjb3VzIGZyYW1lLCBpdCBpcyBvcGVuZWQgZHVlIHRvIENDWCAyIGNoYW5uZWwgbG9hZCBzdGF0aXN0aWNzICovCisJLyogRHJvcCBUb0RzIHByb21pc2N1b3VzIGZyYW1lLCBpdCBpcyBvcGVuZWQgZHVlIHRvIENDWCAyIGNoYW5uZWwgbG9hZCBzdGF0aXN0aWNzICovCiAJaWYgKHBIZWFkZXItPkZDLlRvRHMpIHsKIAkJREJHUFJJTlRfUkFXKFJUX0RFQlVHX0VSUk9SLCAoIkVycjtGQy5Ub0RzXG4iKSk7CiAJCXJldHVybiBORElTX1NUQVRVU19GQUlMVVJFOwpAQCAtODYwLDcgKzg2MCw3IEBACiAJCURCR1BSSU5UX1JBVyhSVF9ERUJVR19FUlJPUiwgKCJyZWNlaXZlZCBwYWNrZXQgdG9vIGxvbmdcbiIpKTsKIAkJcmV0dXJuIE5ESVNfU1RBVFVTX0ZBSUxVUkU7CiAJfQotCS8qIERyb3Agbm90IFUyTSBmcmFtZXMsIGNhbnQncyBkcm9wIGhlcmUgYmVjYXVzZSB3ZSB3aWxsIGRyb3AgYmVhY29uIGluIHRoaXMgY2FzZSAqLworCS8qIERyb3Agbm90IFUyTSBmcmFtZXMsIGNhbid0J3MgZHJvcCBoZXJlIGJlY2F1c2Ugd2Ugd2lsbCBkcm9wIGJlYWNvbiBpbiB0aGlzIGNhc2UgKi8KIAkvKiBJIGFtIGtpbmQgb2YgZG91YnRpbmcgdGhlIFUyTSBiaXQgb3BlcmF0aW9uICovCiAJLyogaWYgKHBSeEQtPlUyTSA9PSAwKSAqLwogCS8qICAgICAgcmV0dXJuKE5ESVNfU1RBVFVTX0ZBSUxVUkUpOyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX21hY19wY2kuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9tYWNfcGNpLmMKaW5kZXggMjFlZWQyNS4uZDA2ZjBhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX21hY19wY2kuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fbWFjX3BjaS5jCkBAIC0xNDQ2LDcgKzE0NDYsNyBAQAogCSAgIHBBZC0+Q2hlY2tEbWFCdXN5Q291bnQgPSAwOwogCSAgIH0KIAkgKi8KLS8qS0ggRGVidWc6TXkgb3JpZ2luYWwgY29kZXMgaGF2ZSB0aGUgZm9sbHdvaW5nIGNvZGVzLCBidXQgY3VycmVjbnQgY29kZXMgZG8gbm90IGhhdmUgaXQuICovCisvKktIIERlYnVnOk15IG9yaWdpbmFsIGNvZGVzIGhhdmUgdGhlIGZvbGxvd2luZyBjb2RlcywgYnV0IGN1cnJlY250IGNvZGVzIGRvIG5vdCBoYXZlIGl0LiAqLwogLyogRGlzYWJsZSBmb3Igc3RhYmlsaXR5LiBJZiBQQ0lFIExpbmsgQ29udHJvbCBpcyBtb2RpZmllZCBmb3IgYWR2YW5jZSBwb3dlciBzYXZlLCByZS1jb3ZlcnkgdGhpcyBjb2RlIHNlZ21lbnQuICovCiAJUlRNUF9JT19XUklURTMyKHBBZCwgUEJGX1NZU19DVFJMLCAweDEyODApOwogLypPUFNUQVRVU19TRVRfRkxBRyhwQWQsIGZPUF9TVEFUVVNfQ0xLU0VMRUNUXzQwTUhaKTsgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9zYW5pdHkuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9zYW5pdHkuYwppbmRleCA2YjAwM2M5Li4zYmZiNGFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fc2FuaXR5LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX3Nhbml0eS5jCkBAIC02Nyw3ICs2Nyw3IEBACiAKIAlpZiAoKE1zZ0xlbiAhPSBzaXplb2Yoc3RydWN0IHJ0X21sbWVfYWRkYmFfcmVxKSkpIHsKIAkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsCi0JCQkgKCJNbG1lQWRkQkFSZXFTYW5pdHkgZmFpbCAtIG1lc3NhZ2UgbGVuZ2h0IG5vdCBjb3JyZWN0LlxuIikpOworCQkJICgiTWxtZUFkZEJBUmVxU2FuaXR5IGZhaWwgLSBtZXNzYWdlIGxlbmd0aCBub3QgY29ycmVjdC5cbiIpKTsKIAkJcmV0dXJuIEZBTFNFOwogCX0KIApAQCAtMTA0LDcgKzEwNCw3IEBACiAKIAlpZiAoKE1zZ0xlbiAhPSBzaXplb2Yoc3RydWN0IHJ0X21sbWVfZGVsYmFfcmVxKSkpIHsKIAkJREJHUFJJTlQoUlRfREVCVUdfRVJST1IsCi0JCQkgKCJNbG1lRGVsQkFSZXFTYW5pdHkgZmFpbCAtIG1lc3NhZ2UgbGVuZ2h0IG5vdCBjb3JyZWN0LlxuIikpOworCQkJICgiTWxtZURlbEJBUmVxU2FuaXR5IGZhaWwgLSBtZXNzYWdlIGxlbmd0aCBub3QgY29ycmVjdC5cbiIpKTsKIAkJcmV0dXJuIEZBTFNFOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX3N5bmMuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9zeW5jLmMKaW5kZXggZjg0MTk0ZC4uYWVmZTFiNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX3N5bmMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fc3luYy5jCkBAIC02OTQsNyArNjk0LDcgQEAKIAkJCU1pbmlwb3J0TU1SZXF1ZXN0KHBBZCwgMCwgcE91dEJ1ZmZlciwgRnJhbWVMZW4pOwogCQkJTWxtZUZyZWVNZW1vcnkocEFkLCBwT3V0QnVmZmVyKTsKIAkJfQotCQkvKiBGb3IgU0NBTl9DSVNDT19QQVNTSVZFLCBkbyBub3RoaW5nIGFuZCBzaWxlbnRseSB3YWl0IGZvciBiZWFjb24gb3Igb3RoZXIgcHJvYmUgcmVwb25zZSAqLworCQkvKiBGb3IgU0NBTl9DSVNDT19QQVNTSVZFLCBkbyBub3RoaW5nIGFuZCBzaWxlbnRseSB3YWl0IGZvciBiZWFjb24gb3Igb3RoZXIgcHJvYmUgcmVzcG9uc2UgKi8KIAogCQlwQWQtPk1sbWUuU3luY01hY2hpbmUuQ3VyclN0YXRlID0gU0NBTl9MSVNURU47CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX3dwYS5jIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX3dwYS5jCmluZGV4IDAwNDBmNDUuLjYxNmViZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV93cGEuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fd3BhLmMKQEAgLTEyMjIsNyArMTIyMiw3IEBACiAKIAlOb3RlOgogCQlBbGwgdGhlc2UgY29uc3RhbnRzIGFyZSBkZWZpbmVkIGluIHdwYS5oCi0JCUZvciBzdXBwbGljYW50LCB0aGVyZSBpcyBvbmx5IEVBUE9MIEtleSBtZXNzYWdlIGF2YWxpYWJsZQorCQlGb3Igc3VwcGxpY2FudCwgdGhlcmUgaXMgb25seSBFQVBPTCBLZXkgbWVzc2FnZSBhdmFpbGFibGUKIAogCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKi8KQEAgLTEyNjcsNyArMTI2Nyw3IEBACiAJCWludAkJcHJlZml4X2xlbgktCXRoZSBsZW5ndGggb2YgdGhlIGxhYmVsCiAJCXU4CSpkYXRhCQktCWEgc3BlY2lmaWMgZGF0YSB3aXRoIHZhcmlhYmxlIGxlbmd0aAogCQlpbnQJCWRhdGFfbGVuCS0JdGhlIGxlbmd0aCBvZiBhIHNwZWNpZmljIGRhdGEKLQkJaW50CQlsZW4JCQktCXRoZSBvdXRwdXQgbGVuZ2h0CisJCWludAkJbGVuCQkJLQl0aGUgb3V0cHV0IGxlbmd0aAogCiAJUmV0dXJuIFZhbHVlOgogCQl1OAkqb3V0cHV0CQktCXRoZSBjYWxjdWxhdGVkIHJlc3VsdApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vbWxtZS5jIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vbWxtZS5jCmluZGV4IGQ5YzNmZDUuLmU0OGVhYzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL21sbWUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9tbG1lLmMKQEAgLTYzMiw3ICs2MzIsNyBAQAogCQkJcENoaXBPcHMtPkFzaWNIYWx0QWN0aW9uKHBBZCk7CiAJfQogCi0JUlRNUHVzZWNEZWxheSg1MDAwKTsJLyogIDUgbXNlYyB0byBndXJhbnRlZSBBbnQgRGl2ZXJzaXR5IHRpbWVyIGNhbmNlbGVkICovCisJUlRNUHVzZWNEZWxheSg1MDAwKTsJLyogIDUgbXNlYyB0byBndWFyYW50ZWUgQW50IERpdmVyc2l0eSB0aW1lciBjYW5jZWxlZCAqLwogCiAJTWxtZVF1ZXVlRGVzdHJveSgmcEFkLT5NbG1lLlF1ZXVlKTsKIAlOZGlzRnJlZVNwaW5Mb2NrKCZwQWQtPk1sbWUuVGFza0xvY2spOwpAQCAtMTEwNywxNCArMTEwNywxNCBAQAogCQkJCQkqcEluaXRUeFJhdGVJZHggPQogCQkJCQkgICAgUmF0ZVN3aXRjaFRhYmxlMTFOMVNbMV07CiAJCQkJCURCR1BSSU5UX1JBVyhSVF9ERUJVR19FUlJPUiwKLQkJCQkJCSAgICAgKCJEUlM6IHVua293biBtb2RlLGRlZmF1bHQgdXNlIDExTiAxUyBBUCBcbiIpKTsKKwkJCQkJCSAgICAgKCJEUlM6IHVua25vd24gbW9kZSxkZWZhdWx0IHVzZSAxMU4gMVMgQVAgXG4iKSk7CiAJCQkJfSBlbHNlIHsKIAkJCQkJKnBwVGFibGUgPSBSYXRlU3dpdGNoVGFibGUxMU4yUzsKIAkJCQkJKnBUYWJsZVNpemUgPSBSYXRlU3dpdGNoVGFibGUxMU4yU1swXTsKIAkJCQkJKnBJbml0VHhSYXRlSWR4ID0KIAkJCQkJICAgIFJhdGVTd2l0Y2hUYWJsZTExTjJTWzFdOwogCQkJCQlEQkdQUklOVF9SQVcoUlRfREVCVUdfRVJST1IsCi0JCQkJCQkgICAgICgiRFJTOiB1bmtvd24gbW9kZSxkZWZhdWx0IHVzZSAxMU4gMlMgQVAgXG4iKSk7CisJCQkJCQkgICAgICgiRFJTOiB1bmtub3duIG1vZGUsZGVmYXVsdCB1c2UgMTFOIDJTIEFQIFxuIikpOwogCQkJCX0KIAkJCX0gZWxzZSB7CiAJCQkJaWYgKHBBZC0+Q29tbW9uQ2ZnLlR4U3RyZWFtID09IDEpIHsKQEAgLTExMjMsNyArMTEyMyw3IEBACiAJCQkJCSpwSW5pdFR4UmF0ZUlkeCA9CiAJCQkJCSAgICBSYXRlU3dpdGNoVGFibGUxMU4xU1sxXTsKIAkJCQkJREJHUFJJTlRfUkFXKFJUX0RFQlVHX0VSUk9SLAotCQkJCQkJICAgICAoIkRSUzogdW5rb3duIG1vZGUsZGVmYXVsdCB1c2UgMTFOIDFTIEFQIFxuIikpOworCQkJCQkJICAgICAoIkRSUzogdW5rbm93biBtb2RlLGRlZmF1bHQgdXNlIDExTiAxUyBBUCBcbiIpKTsKIAkJCQl9IGVsc2UgewogCQkJCQkqcHBUYWJsZSA9IFJhdGVTd2l0Y2hUYWJsZTExTjJTRm9yQUJhbmQ7CiAJCQkJCSpwVGFibGVTaXplID0KQEAgLTExMzEsMTEgKzExMzEsMTEgQEAKIAkJCQkJKnBJbml0VHhSYXRlSWR4ID0KIAkJCQkJICAgIFJhdGVTd2l0Y2hUYWJsZTExTjJTRm9yQUJhbmRbMV07CiAJCQkJCURCR1BSSU5UX1JBVyhSVF9ERUJVR19FUlJPUiwKLQkJCQkJCSAgICAgKCJEUlM6IHVua293biBtb2RlLGRlZmF1bHQgdXNlIDExTiAyUyBBUCBcbiIpKTsKKwkJCQkJCSAgICAgKCJEUlM6IHVua25vd24gbW9kZSxkZWZhdWx0IHVzZSAxMU4gMlMgQVAgXG4iKSk7CiAJCQkJfQogCQkJfQogCQkJREJHUFJJTlRfUkFXKFJUX0RFQlVHX0VSUk9SLAotCQkJCSAgICAgKCJEUlM6IHVua293biBtb2RlIChTdXBSYXRlTGVuPSVkLCBFeHRSYXRlTGVuPSVkLCBNQ1NTZXRbMF09MHgleCwgTUNTU2V0WzFdPTB4JXgpXG4iLAorCQkJCSAgICAgKCJEUlM6IHVua25vd24gbW9kZSAoU3VwUmF0ZUxlbj0lZCwgRXh0UmF0ZUxlbj0lZCwgTUNTU2V0WzBdPTB4JXgsIE1DU1NldFsxXT0weCV4KVxuIiwKIAkJCQkgICAgICBwQWQtPlN0YUFjdGl2ZS5TdXBSYXRlTGVuLAogCQkJCSAgICAgIHBBZC0+U3RhQWN0aXZlLkV4dFJhdGVMZW4sCiAJCQkJICAgICAgcEFkLT5TdGFBY3RpdmUuU3VwcG9ydGVkUGh5SW5mby5NQ1NTZXRbMF0sCkBAIC0xMzY4LDcgKzEzNjgsNyBAQAogCQkJCQlpZiAoKHBBZC0+U3RhQ2ZnLkxhc3RTY2FuVGltZSArCiAJCQkJCSAgICAgMTAgKiBPU19IWikgPCBwQWQtPk1sbWUuTm93MzIpIHsKIAkJCQkJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLAotCQkJCQkJCSAoIk1NQ0hLIC0gUm9hbWluZywgTm8gZWxpZ2FibGUgZW50cnksIHRyeSBuZXcgc2NhbiFcbiIpKTsKKwkJCQkJCQkgKCJNTUNISyAtIFJvYW1pbmcsIE5vIGVsaWdpYmxlIGVudHJ5LCB0cnkgbmV3IHNjYW4hXG4iKSk7CiAJCQkJCQlwQWQtPlN0YUNmZy5TY2FuQ250ID0gMjsKIAkJCQkJCXBBZC0+U3RhQ2ZnLkxhc3RTY2FuVGltZSA9CiAJCQkJCQkgICAgcEFkLT5NbG1lLk5vdzMyOwpAQCAtMjgyOCw3ICsyODI4LDcgQEAKIAogLyogSVJRTCA9IFBBU1NJVkVfTEVWRUwgKi8KIC8qIElSUUwgPSBESVNQQVRDSF9MRVZFTCAqLwotLyogYkxpbmtVcCBpcyB0byBpZGVudGlmeSB0aGUgaW5pdGFsIGxpbmsgc3BlZWQuICovCisvKiBiTGlua1VwIGlzIHRvIGlkZW50aWZ5IHRoZSBpbml0aWFsIGxpbmsgc3BlZWQuICovCiAvKiBUUlVFIGluZGljYXRlcyB0aGUgcmF0ZSB1cGRhdGUgYXQgbGlua3VwLCB3ZSBzaG91bGQgbm90IHRyeSB0byBzZXQgdGhlIHJhdGUgYXQgNTRNYnBzLiAqLwogdm9pZCBNbG1lVXBkYXRlVHhSYXRlcyhzdHJ1Y3QgcnRfcnRtcF9hZGFwdGVyICpwQWQsIElOIEJPT0xFQU4gYkxpbmtVcCwgdTggYXBpZHgpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9ydG1wX2luaXQuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL3J0bXBfaW5pdC5jCmluZGV4IGQzNTlhMTQuLjVmYTE5M2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL3J0bXBfaW5pdC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL3J0bXBfaW5pdC5jCkBAIC0yMDM3LDcgKzIwMzcsNyBAQAogCiAJCQlwRW50cnktPkZJRk9Db3VudCA9IDA7CiAJCQlwRW50cnktPk9uZVNlY1R4Tm9SZXRyeU9rQ291bnQrKzsKLQkJCS8qIHVwZGF0ZSBOb0RhdGFJZGxlQ291bnQgd2hlbiBzdWNlc3NmdWwgc2VuZCBwYWNrZXQgdG8gU1RBLiAqLworCQkJLyogdXBkYXRlIE5vRGF0YUlkbGVDb3VudCB3aGVuIHN1Y2Nlc3NmdWwgc2VuZCBwYWNrZXQgdG8gU1RBLiAqLwogCQkJcEVudHJ5LT5Ob0RhdGFJZGxlQ291bnQgPSAwOwogCQkJcEVudHJ5LT5Db250aW51ZVR4RmFpbENudCA9IDA7CiAJCX0KQEAgLTI1MTYsNyArMjUxNiw3IEBACiAJLypwQWQtPlR1cm5BZ2dyQnVsa0luQ291bnQgPSAwOyAqLwogCXBBZC0+YlVzYlR4QnVsa0FnZ3JlID0gMDsKIAotCS8qIGluaXQgYXMgdW5zZWQgdmFsdWUgdG8gZW5zdXJlIGRyaXZlciB3aWxsIHNldCB0byBNQ1Ugb25jZS4gKi8KKwkvKiBpbml0IGFzIHVudXNlZCB2YWx1ZSB0byBlbnN1cmUgZHJpdmVyIHdpbGwgc2V0IHRvIE1DVSBvbmNlLiAqLwogCXBBZC0+TGVkSW5kaWNhdG9yU3RyZW5ndGggPSAweEZGOwogCiAJcEFkLT5Db21tb25DZmcuTWF4UGt0T25lVHhCdWxrID0gMjsKQEAgLTMwNzYsMTEgKzMwNzYsMTEgQEAKIAk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KIAogCVJvdXRpbmUgRGVzY3JpcHRpb246Ci0JCVNldCBMRUQgU2lnbmFsIFN0cmVndGgKKwkJU2V0IExFRCBTaWduYWwgU3RyZW5ndGgKIAogCUFyZ3VtZW50czoKIAkJcEFkCQkJCQkJUG9pbnRlciB0byBvdXIgYWRhcHRlcgotCQlEYm0JCQkJCQlTaWduYWwgU3RyZWd0aAorCQlEYm0JCQkJCQlTaWduYWwgU3RyZW5ndGgKIAogCVJldHVybiBWYWx1ZToKIAkJTm9uZQpAQCAtMzA5MCw3ICszMDkwLDcgQEAKIAlOb3RlOgogCQlDYW4gYmUgcnVuIG9uIGFueSBJUlFMIGxldmVsLgogCi0JCUFjY29yZGluZyB0byBNaWNyb3NvZnQgWmVybyBDb25maWcgV2lyZWxlc3MgU2lnbmFsIFN0cmVndGggZGVmaW5pdGlvbiBhcyBiZWxvd3MuCisJCUFjY29yZGluZyB0byBNaWNyb3NvZnQgWmVybyBDb25maWcgV2lyZWxlc3MgU2lnbmFsIFN0cmVuZ3RoIGRlZmluaXRpb24gYXMgYmVsb3dzLgogCQk8PSAtOTAgIE5vIFNpZ25hbAogCQk8PSAtODEgIFZlcnkgTG93CiAJCTw9IC03MSAgTG93CkBAIC0zMTE4LDcgKzMxMTgsNyBAQAogCQkJbkxlZCA9IDMxOwogCiAJCS8qICovCi0JCS8qIFVwZGF0ZSBTaWduYWwgU3RyZWd0aCB0byBmaXJtd2FyZSBpZiBjaGFuZ2VkLiAqLworCQkvKiBVcGRhdGUgU2lnbmFsIFN0cmVuZ3RoIHRvIGZpcm13YXJlIGlmIGNoYW5nZWQuICovCiAJCS8qICovCiAJCWlmIChwQWQtPkxlZEluZGljYXRvclN0cmVuZ3RoICE9IG5MZWQpIHsKIAkJCUFzaWNTZW5kQ29tbWFuZFRvTWN1KHBBZCwgMHg1MSwgMHhmZiwgbkxlZCwKQEAgLTMxNjYsNyArMzE2Niw3IEBACiAJCWlmIChwQWQtPkNvbW1vbkNmZy5QU1BYbGluaykKIAkJCXJ4X2ZpbHRlcl9mbGFnID0gUFNQWExJTks7CiAJCWVsc2UKLQkJCXJ4X2ZpbHRlcl9mbGFnID0gU1RBTk9STUFMOwkvKiBTdGFpb24gbm90IGRyb3AgY29udHJvbCBmcmFtZSB3aWxsIGZhaWwgV2lGaSBDZXJ0aWZpY2F0aW9uLiAqLworCQkJcnhfZmlsdGVyX2ZsYWcgPSBTVEFOT1JNQUw7CS8qIFN0YXRpb24gbm90IGRyb3AgY29udHJvbCBmcmFtZSB3aWxsIGZhaWwgV2lGaSBDZXJ0aWZpY2F0aW9uLiAqLwogCQlSVE1QX0lPX1dSSVRFMzIocEFkLCBSWF9GSUxUUl9DRkcsIHJ4X2ZpbHRlcl9mbGFnKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL3NwZWN0cnVtLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9zcGVjdHJ1bS5jCmluZGV4IGMwZDJmNDIuLmNlYjYyMmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL3NwZWN0cnVtLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vc3BlY3RydW0uYwpAQCAtMTA1OCw4ICsxMDU4LDggQEAKIAkJMy4gTWVhc3VyZSBUb2tlbi4KIAkJNC4gTWVhc3VyZSBSZXF1ZXN0IE1vZGUuCiAJCTUuIE1lYXN1cmUgUmVxdWVzdCBUeXBlLgotCQk2LiBMZW5ndGggb2YgUmVwb3J0IEluZm9tYXRpb24KLQkJNy4gUG9pbnRlciBvZiBSZXBvcnQgSW5mb21hdGlvbiBCdWZmZXIuCisJCTYuIExlbmd0aCBvZiBSZXBvcnQgSW5mb3JtYXRpb24KKwkJNy4gUG9pbnRlciBvZiBSZXBvcnQgSW5mb3JtYXRpb24gQnVmZmVyLgogCiAJUmV0dXJuCTogTm9uZS4KIAk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpAQCAtMTQwMCw3ICsxNDAwLDcgQEAKIAlQYXJhbWV0cnM6CiAJCTEuIE1MTUUgbWVzc2FnZSBjb250YWluaW5nIHRoZSByZWNlaXZlZCBmcmFtZQogCQkyLiBtZXNzYWdlIGxlbmd0aC4KLQkJMy4gQ2hhbm5lbCBzd2l0Y2ggYW5ub3VuY2VtZW50IGluZm9tYXRpb24gYnVmZmVyLgorCQkzLiBDaGFubmVsIHN3aXRjaCBhbm5vdW5jZW1lbnQgaW5mb3JtYXRpb24gYnVmZmVyLgogCiAJUmV0dXJuCTogTm9uZS4KIAk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpAQCAtMTQ2NSw3ICsxNDY1LDcgQEAKIAlQYXJhbWV0cnM6CiAJCTEuIE1MTUUgbWVzc2FnZSBjb250YWluaW5nIHRoZSByZWNlaXZlZCBmcmFtZQogCQkyLiBtZXNzYWdlIGxlbmd0aC4KLQkJMy4gTWVhc3VyZW1lbnQgcmVxdWVzdCBpbmZvbWF0aW9uIGJ1ZmZlci4KKwkJMy4gTWVhc3VyZW1lbnQgcmVxdWVzdCBpbmZvcm1hdGlvbiBidWZmZXIuCiAKIAlSZXR1cm4JOiBOb25lLgogCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CkBAIC0xNTM4LDggKzE1MzgsOCBAQAogCVBhcmFtZXRyczoKIAkJMS4gTUxNRSBtZXNzYWdlIGNvbnRhaW5pbmcgdGhlIHJlY2VpdmVkIGZyYW1lCiAJCTIuIG1lc3NhZ2UgbGVuZ3RoLgotCQkzLiBNZWFzdXJlbWVudCByZXBvcnQgaW5mb21hdGlvbiBidWZmZXIuCi0JCTQuIGJhc2ljIHJlcG9ydCBpbmZvbWF0aW9uIGJ1ZmZlci4KKwkJMy4gTWVhc3VyZW1lbnQgcmVwb3J0IGluZm9ybWF0aW9uIGJ1ZmZlci4KKwkJNC4gYmFzaWMgcmVwb3J0IGluZm9ybWF0aW9uIGJ1ZmZlci4KIAogCVJldHVybgk6IE5vbmUuCiAJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvbWxtZS5oIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9tbG1lLmgKaW5kZXggY2QxZWUzZC4uYTI4NTg1MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9tbG1lLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9tbG1lLmgKQEAgLTM3NCw3ICszNzQsNyBAQAogc3RydWN0IHJ0X2h0X3BoeV9pbmZvIHsKIAlCT09MRUFOIGJIdEVuYWJsZTsJLyogSWYgd2Ugc2hvdWxkIHVzZSBodCByYXRlLiAqLwogCUJPT0xFQU4gYlByZU5IdDsJLyogSWYgd2Ugc2hvdWxkIHVzZSBodCByYXRlLiAqLwotCS8qU3Vic3RyYWN0IGZyb20gSFQgQ2FwYWJpbGl0eSBJRSAqLworCS8qU3VidHJhY3QgZnJvbSBIVCBDYXBhYmlsaXR5IElFICovCiAJdTggTUNTU2V0WzE2XTsKIH07CiAKQEAgLTM5Miw3ICszOTIsNyBAQAogCXUxNiBBbXNkdVNpemU6MTsJLyogTWF4IHJlY2VpdmluZyBBLU1TRFUgc2l6ZSAqLwogCXUxNiByc3Y6NTsKIAotCS8qU3Vic3RyYWN0IGZyb20gQWRkaW9udCBIVCBJTkZPIElFICovCisJLypTdWJ0cmFjdCBmcm9tIEFkZGlvbnQgSFQgSU5GTyBJRSAqLwogCXU4IE1heFJBbXBkdUZhY3RvcjoyOwogCXU4IE1wZHVEZW5zaXR5OjM7CiAJdTggRXh0Q2hhbk9mZnNldDoyOwkvKiBQbGVhc2Ugbm90ZSB0aGUgZGlmZmVyZW5jZSB3aXRoIGZvbGxvd2luZyAgICAgdTggICBOZXdFeHRDaGFubmVsT2Zmc2V0OyBmcm9tIDgwMi4xMW4gKi8KQEAgLTQxMCw3ICs0MTAsNyBAQAogCXU4IEJTU0NvZXhpc3QyMDQwOwogfTsKIAotLyogICBmaWVsZCBpbiBBZGR0aW9uYWwgSFQgSW5mb3JtYXRpb24gSUUgLiAqLworLyogICBmaWVsZCBpbiBBZGRpdGlvbmFsIEhUIEluZm9ybWF0aW9uIElFIC4gKi8KIHN0cnVjdCBQQUNLRUQgcnRfYWRkX2h0aW5mbyB7CiAJdTggRXh0Q2hhbk9mZnNldDoyOwogCXU4IFJlY29tV2lkdGg6MTsKQEAgLTg1Nyw3ICs4NTcsNyBAQAogfTsKIAogLyogTUxNRSBBVVggZGF0YSBzdHJ1Y3R1cmUgdGhhdCBob2xkcyB0ZW1wb3JhcmxpeSBzZXR0aW5ncyBkdXJpbmcgYSBjb25uZWN0aW9uIGF0dGVtcHQuICovCi0vKiBPbmNlIHRoaXMgYXR0ZW1wIHN1Y2NlZWRzLCBhbGwgc2V0dGluZ3Mgd2lsbCBiZSBjb3B5IHRvIHBBZC0+U3RhQWN0aXZlLiAqLworLyogT25jZSB0aGlzIGF0dGVtcHQgc3VjY2VlZHMsIGFsbCBzZXR0aW5ncyB3aWxsIGJlIGNvcHkgdG8gcEFkLT5TdGFBY3RpdmUuICovCiAvKiBBIGNvbm5lY3Rpb24gYXR0ZW1wdCAodXNlciBzZXQgT0lELCByb2FtaW5nLCBDQ1ggZmFzdCByb2FtaW5nLC4uKSBjb25zaXN0cyBvZiAqLwogLyogc2V2ZXJhbCBzdGVwcyAoSk9JTiwgQVVUSCwgQVNTT0Mgb3IgUkVBU1NPQykgYW5kIG1heSBmYWlsIGF0IGFueSBzdGVwLiBXZSBwdXJwb3NlbHkgKi8KIC8qIHNlcGFyYXRlIHRoaXMgdW5kZXItdHJpYWwgc2V0dGluZ3MgYXdheSBmcm9tIHBBZC0+U3RhQWN0aXZlIHNvIHRoYXQgb25jZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydF9saW51eC5jIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydF9saW51eC5jCmluZGV4IGU1YjA0MjcuLjE1ODMzNDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvcnRfbGludXguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X2xpbnV4LmMKQEAgLTI4Myw3ICsyODMsNyBAQAogCUFyZ3VtZW50czoKIAkJcEFkIAlQb2ludGVyIHRvIG91ciBhZGFwdGVyCiAJCXBJbnNBTVNEVUhkcglFV0MgQS1NU0RVIGZvcm1hdCBoYXMgZXh0cmEgMTQtYnl0ZXMgaGVhZGVyLiBpZiBUUlVFLCBpbnNlcnQgdGhpcyAxNC1ieXRlIGhkciBpbiBmcm9udCBvZiBNU0RVLgotCQkqcFNyY1RvdGFsTGVuCQkJcmV0dXJuIHRvdGFsIHBhY2tldCBsZW5ndGguIFRoaXMgbGVuZ2h0IGlzIGNhbGN1bGF0ZWQgd2l0aCA4MDIuMyBmb3JtYXQgcGFja2V0LgorCQkqcFNyY1RvdGFsTGVuCQkJcmV0dXJuIHRvdGFsIHBhY2tldCBsZW5ndGguIFRoaXMgbGVuZ3RoIGlzIGNhbGN1bGF0ZWQgd2l0aCA4MDIuMyBmb3JtYXQgcGFja2V0LgogCiAJUmV0dXJuIFZhbHVlOgogCQlORElTX1NUQVRVU19TVUNDRVNTCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X3BjaV9yYnVzLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X3BjaV9yYnVzLmMKaW5kZXggZTVmYjY3Yy4uZjgwYWI0ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydF9wY2lfcmJ1cy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvcnRfcGNpX3JidXMuYwpAQCAtNjE5LDcgKzYxOSw3IEBACiAJICAgT3Iga2VybmVsIHdpbGwgcGFuaWMgYWZ0ZXIgaWZjb25maWcgcmEwIGRvd24gc29tZXRpbWVzICovCiAKIAkvKiAqLwotCS8qIEluaXRhbCB0aGUgSW50ZXJydXB0IHNvdXJjZS4gKi8KKwkvKiBJbml0aWFsIHRoZSBJbnRlcnJ1cHQgc291cmNlLiAqLwogCS8qICovCiAJSW50U291cmNlLndvcmQgPSAweDAwMDAwMDAwTDsKIC8qICAgICAgTWN1SW50U291cmNlLndvcmQgPSAweDAwMDAwMDAwTDsgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvcnRtcC5oIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydG1wLmgKaW5kZXggZDE2YjA2YS4uM2MzMTM0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydG1wLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydG1wLmgKQEAgLTc1Niw3ICs3NTYsNyBAQAogLyogKi8KIHN0cnVjdCBydF9wcml2YXRlIHsKIAl1MzIgU3lzdGVtUmVzZXRDbnQ7CS8qIFN5c3RlbSByZXNldCBjb3VudGVyICovCi0JdTMyIFR4UmluZ0Z1bGxDbnQ7CS8qIFR4IHJpbmcgZnVsbCBvY2N1cnJhbmNlIG51bWJlciAqLworCXUzMiBUeFJpbmdGdWxsQ250OwkvKiBUeCByaW5nIGZ1bGwgb2NjdXJyZW5jZSBudW1iZXIgKi8KIAl1MzIgUGh5UnhFcnJDbnQ7CS8qIFBIWSBSeCBlcnJvciBjb3VudCwgZm9yIGRlYnVnIHB1cnBvc2UsIG1pZ2h0IG1vdmUgdG8gZ2xvYmFsIGNvdW50ZXIgKi8KIAkvKiBWYXJpYWJsZXMgZm9yIFdFUCBlbmNyeXB0aW9uIC8gZGVjcnlwdGlvbiBpbiBydG1wX3dlcC5jICovCiAJdTMyIEZDU0NSQzMyOwpAQCAtOTI1LDcgKzkyNSw3IEBACiAgICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogc3RydWN0IHJlb3JkZXJpbmdfbXBkdSB7CiAJc3RydWN0IHJlb3JkZXJpbmdfbXBkdSAqbmV4dDsKLQl2b2lkICpwUGFja2V0OwkvKiBjb3ZlcnRlZCB0byA4MDIuMyBmcmFtZSAqLworCXZvaWQgKnBQYWNrZXQ7CS8qIGNvbnZlcnRlZCB0byA4MDIuMyBmcmFtZSAqLwogCWludCBTZXF1ZW5jZTsJCS8qIHNlcXVlbmNlIG51bWJlciBvZiBNUERVICovCiAJQk9PTEVBTiBiQU1TRFU7CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9zdGFfaW9jdGwuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvc3RhX2lvY3RsLmMKaW5kZXggNTcxN2UxMi4uNDliMTAxMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9zdGFfaW9jdGwuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3N0YV9pb2N0bC5jCkBAIC0yNDYwLDcgKzI0NjAsNyBAQAogCQl9CiAJfQogCi0JewkJCS8qIGRldGVybWluZSB0aGlzIGlvY3RsIGNvbW1hbmQgaXMgY29tbWluZyBmcm9tIHdoaWNoIGludGVyZmFjZS4gKi8KKwl7CQkJLyogZGV0ZXJtaW5lIHRoaXMgaW9jdGwgY29tbWFuZCBpcyBjb21pbmcgZnJvbSB3aGljaCBpbnRlcmZhY2UuICovCiAJCXBPYmotPmlvY3RsX2lmX3R5cGUgPSBJTlRfTUFJTjsKIAkJcE9iai0+aW9jdGxfaWYgPSBNQUlOX01CU1NJRDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODcwL2NvbW1vbi9ydHVzYl9idWxrLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODcwL2NvbW1vbi9ydHVzYl9idWxrLmMKaW5kZXggZDI3NDZmOC4uNjc5YjgwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg3MC9jb21tb24vcnR1c2JfYnVsay5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NzAvY29tbW9uL3J0dXNiX2J1bGsuYwpAQCAtMjk4LDcgKzI5OCw3IEBACiAJCQkJLyp8fCAoIChUaGlzQnVsa1NpemUgIT0gMCkgICYmIChwVHhXSS0+QU1QRFUgPT0gMCkpICovCiAJCQkJKSB7CiAJCQkJLyogRm9yIFVTQiAxLjEgb3IgcGVlciB3aGljaCBkaWRuJ3Qgc3VwcG9ydCBBTVBEVSwgbGltaXQgdGhlIEJ1bGtPdXQgc2l6ZS4gKi8KLQkJCQkvKiBGb3IgcGVyZm9ybWVuY2UgaW4gYi9nIG1vZGUsIG5vdyBqdXN0IGNoZWNrIGZvciBVU0IgMS4xIGFuZCBkaWRuJ3QgY2FyZSBhYm91dCB0aGUgQVBNRFUgb3Igbm90ISAyMDA4LzA2LzA0LiAqLworCQkJCS8qIEZvciBwZXJmb3JtYW5jZSBpbiBiL2cgbW9kZSwgbm93IGp1c3QgY2hlY2sgZm9yIFVTQiAxLjEgYW5kIGRpZG4ndCBjYXJlIGFib3V0IHRoZSBBUE1EVSBvciBub3QhIDIwMDgvMDYvMDQuICovCiAJCQkJcEhUVFhDb250ZXh0LT5FTmV4dEJ1bGtPdXRQb3NpdGlvbiA9CiAJCQkJICAgIFRtcEJ1bGtFbmRQb3M7CiAJCQkJYnJlYWs7CkBAIC0zMTEsNyArMzExLDcgQEAKIAkJCQkgICAgVG1wQnVsa0VuZFBvczsKIAkJCQlicmVhazsKIAkJCX0gZWxzZSBpZiAoKChwQWQtPkJ1bGtPdXRNYXhQYWNrZXRTaXplIDwgNTEyKSAmJiAoKFRoaXNCdWxrU2l6ZSAmIDB4ZmZmZmY4MDApICE9IDApKSAvKnx8ICggKFRoaXNCdWxrU2l6ZSAhPSAwKSAgJiYgKHBUeFdJLT5BTVBEVSA9PSAwKSkgKi8pIHsJLyogRm9yIFVTQiAxLjEgb3IgcGVlciB3aGljaCBkaWRuJ3Qgc3VwcG9ydCBBTVBEVSwgbGltaXQgdGhlIEJ1bGtPdXQgc2l6ZS4gKi8KLQkJCQkvKiBGb3IgcGVyZm9ybWVuY2UgaW4gYi9nIG1vZGUsIG5vdyBqdXN0IGNoZWNrIGZvciBVU0IgMS4xIGFuZCBkaWRuJ3QgY2FyZSBhYm91dCB0aGUgQVBNRFUgb3Igbm90ISAyMDA4LzA2LzA0LiAqLworCQkJCS8qIEZvciBwZXJmb3JtYW5jZSBpbiBiL2cgbW9kZSwgbm93IGp1c3QgY2hlY2sgZm9yIFVTQiAxLjEgYW5kIGRpZG4ndCBjYXJlIGFib3V0IHRoZSBBUE1EVSBvciBub3QhIDIwMDgvMDYvMDQuICovCiAJCQkJcEhUVFhDb250ZXh0LT5FTmV4dEJ1bGtPdXRQb3NpdGlvbiA9CiAJCQkJICAgIFRtcEJ1bGtFbmRQb3M7CiAJCQkJYnJlYWs7CkBAIC0xMDE2LDcgKzEwMTYsNyBAQAogCQkJCVJUVVNCQnVsa091dE51bGxGcmFtZShwQWQpOwogCQkJfQogCQl9Ci0JCS8qIDguIE5vIGRhdGEgYXZhbGlhYmxlICovCisJCS8qIDguIE5vIGRhdGEgYXZhaWxhYmxlICovCiAJCWVsc2UKIAkJCTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODcwL2NvbW1vbi9ydHVzYl9kYXRhLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODcwL2NvbW1vbi9ydHVzYl9kYXRhLmMKaW5kZXggNjkzNjg4Ni4uNWI3MmJjZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg3MC9jb21tb24vcnR1c2JfZGF0YS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NzAvY29tbW9uL3J0dXNiX2RhdGEuYwpAQCAtNzEsNyArNzEsNyBAQAogCiAJUm91dGluZQlEZXNjcmlwdGlvbjoKIAkJVGhpcyBzdWJyb3V0aW5lIHdpbGwgc2NhbiB0aHJvdWdoIHJlbGVhdGl2ZSByaW5nIGRlc2NyaXB0b3IgdG8gZmluZAotCQlvdXQgYXZhbGlhYmxlIGZyZWUgcmluZyBkZXNjcmlwdG9yIGFuZCBjb21wYXJlIHdpdGggcmVxdWVzdCBzaXplLgorCQlvdXQgYXZhaWxhYmxlIGZyZWUgcmluZyBkZXNjcmlwdG9yIGFuZCBjb21wYXJlIHdpdGggcmVxdWVzdCBzaXplLgogCiAJQXJndW1lbnRzOgogCQlwQWQJUG9pbnRlcgl0byBvdXIgYWRhcHRlcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9LY29uZmlnIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9LY29uZmlnCmluZGV4IDFiMzEwM2YuLjMxNjJhYWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvS2NvbmZpZworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL0tjb25maWcKQEAgLTEsNiArMSw3IEBACiBjb25maWcgUjgxODdTRQogCXRyaXN0YXRlICJSZWFsVGVrIFJUTDgxODdTRSBXaXJlbGVzcyBMQU4gTklDIGRyaXZlciIKIAlkZXBlbmRzIG9uIFBDSSAmJiBXTEFOCisJZGVwZW5kcyBvbiBtCiAJc2VsZWN0IFdJUkVMRVNTX0VYVAogCXNlbGVjdCBXRVhUX1BSSVYKIAlzZWxlY3QgRUVQUk9NXzkzQ1g2CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL2llZWU4MDIxMS9pZWVlODAyMTEuaCBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvaWVlZTgwMjExL2llZWU4MDIxMS5oCmluZGV4IGRjNjA4YzcuLjE2YWE2YTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvaWVlZTgwMjExL2llZWU4MDIxMS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvaWVlZTgwMjExL2llZWU4MDIxMS5oCkBAIC0xMDk5LDcgKzEwOTksNyBAQAogCSAqIG5vdCBzZXQuIEFzIHNvbWUgY2FyZHMgbWF5IGhhdmUgZGlmZmVyZW50IEhXIHF1ZXVlcyB0aGF0CiAJICogb25lIG1pZ2h0IHdhbnQgdG8gdXNlIGZvciBkYXRhIGFuZCBtYW5hZ2VtZW50IGZyYW1lcwogCSAqIHRoZSBvcHRpb24gdG8gaGF2ZSB0d28gY2FsbGJhY2tzIG1pZ2h0IGJlIHVzZWZ1bC4KLQkgKiBUaGlzIGZ1Y250aW9uIGNhbid0IHNsZWVwLgorCSAqIFRoaXMgZnVuY3Rpb24gY2FuJ3Qgc2xlZXAuCiAJICovCiAJaW50ICgqc29mdG1hY19oYXJkX3N0YXJ0X3htaXQpKHN0cnVjdCBza19idWZmICpza2IsCiAJCQkgICAgICAgc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CkBAIC0xMTM4LDkgKzExMzgsOSBAQAogCSAqIGl0IGlzIGNhbGxlZCBpbiBhIHdvcmtfcXVldWUgd2hlbiBzd2l0aGNpbmcgdG8gYWQtaG9jIG1vZGUKIAkgKiBvciBpbiBiZWhhbGYgb2YgaXdsaXN0IHNjYW4gd2hlbiB0aGUgY2FyZCBpcyBhc3NvY2lhdGVkCiAJICogYW5kIHJvb3QgdXNlciBhc2sgZm9yIGEgc2Nhbi4KLQkgKiB0aGUgZnVjbnRpb24gc3RvcF9zY2FuIHNob3VsZCBzdG9wIGJvdGggdGhlIHN5bmNybyBhbmQKKwkgKiB0aGUgZnVuY3Rpb24gc3RvcF9zY2FuIHNob3VsZCBzdG9wIGJvdGggdGhlIHN5bmNybyBhbmQKIAkgKiBiYWNrZ3JvdW5kIHNjYW5uaW5nIGFuZCBjYW4gc2xlZXAuCi0JICogVGhlIGZ1Y250aW9uIHN0YXJ0X3NjYW4gc2hvdWxkIGluaXRpYXRlIHRoZSBiYWNrZ3JvdW5kCisJICogVGhlIGZ1bmN0aW9uIHN0YXJ0X3NjYW4gc2hvdWxkIGluaXRpYXRlIHRoZSBiYWNrZ3JvdW5kCiAJICogc2Nhbm5pbmcgYW5kIGNhbid0IHNsZWVwLgogCSAqLwogCXZvaWQgKCpzY2FuX3N5bmNybykoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL2llZWU4MDIxMS9pZWVlODAyMTFfc29mdG1hYy5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9pZWVlODAyMTEvaWVlZTgwMjExX3NvZnRtYWMuYwppbmRleCA3NzFlMDE5Li43MzZhMTQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL2llZWU4MDIxMS9pZWVlODAyMTFfc29mdG1hYy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvaWVlZTgwMjExL2llZWU4MDIxMV9zb2Z0bWFjLmMKQEAgLTE5NTQsNyArMTk1NCw3IEBACiAKIAogCi0vKiBmb2xsb3dpbmcgYXJlIGZvciBhIHNpbXBsaWVyIFRYIHF1ZXVlIG1hbmFnZW1lbnQuCisvKiBmb2xsb3dpbmcgYXJlIGZvciBhIHNpbXBsZXIgVFggcXVldWUgbWFuYWdlbWVudC4KICAqIEluc3RlYWQgb2YgdXNpbmcgbmV0aWZfW3N0b3Avd2FrZV1fcXVldWUgdGhlIGRyaXZlcgogICogd2lsbCB1c2VzIHRoZXNlIHR3byBmdW5jdGlvbiAocGx1cyBhIHJlc2V0IG9uZSksIHRoYXQKICAqIHdpbGwgaW50ZXJuYWxseSB1c2VzIHRoZSBrZXJuZWwgbmV0aWZfKiBhbmQgdGFrZXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvcjgxODBfY29yZS5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9yODE4MF9jb3JlLmMKaW5kZXggNzBhYjAwOC4uMjE1NWE3NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9yODE4MF9jb3JlLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9yODE4MF9jb3JlLmMKQEAgLTE1OTEsNyArMTU5MSw3IEBACiAJCXByaXYtPlJTU0kgPSBSU1NJOwogCQkvKiBTUSB0cmFuc2xhdGlvbiBmb3JtdWxhIGlzIHByb3ZpZGVkIGJ5IFNEMyBEWi4gMjAwNi4wNi4yNyAqLwogCQlpZiAocXVhbGl0eSA+PSAxMjcpCi0JCQlxdWFsaXR5ID0gMTsgLyowOyAqLyAvKiAwIHdpbGwgY2F1c2UgZXBjIHRvIHNob3cgc2lnbmFsIHplcm8gLCB3YWxrIGFyb3VkIG5vdzsgKi8KKwkJCXF1YWxpdHkgPSAxOyAvKjA7ICovIC8qIDAgd2lsbCBjYXVzZSBlcGMgdG8gc2hvdyBzaWduYWwgemVybyAsIHdhbGsgYXJvdW5kIG5vdzsgKi8KIAkJZWxzZSBpZiAocXVhbGl0eSA8IDI3KQogCQkJcXVhbGl0eSA9IDEwMDsKIAkJZWxzZQpAQCAtMzg4Myw3ICszODgzLDcgQEAKIAkgKiBJZiB0aGUgcGFja2V0IHByZXZpb3VzIG9mIHRoZSBuaWMgcG9pbnRlciBoYXMgYmVlbgogCSAqIHByb2Nlc3NlZCB0aGlzIGRvZXNuJ3QgbWF0dGVyOiBpdCB3aWxsIGJlIGNoZWNrZWQKIAkgKiBoZXJlIGF0IHRoZSBuZXh0IHJvdW5kLiBBbnl3YXkgaWYgbm8gbW9yZSBwYWNrZXQgYXJlCi0JICogVFhlZCBubyBtZW1vcnkgbGVhayBvY2NvdXIgYXQgYWxsLgorCSAqIFRYZWQgbm8gbWVtb3J5IGxlYWsgb2NjdXIgYXQgYWxsLgogCSAqLwogCiAJc3dpdGNoIChwcmkpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvcjgxODBfZG0uYyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvcjgxODBfZG0uYwppbmRleCBmYzQ5MDc4Li4yNjEwODVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL3I4MTgwX2RtLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9yODE4MF9kbS5jCkBAIC0xMjMsNyArMTIzLDcgQEAKIC8vCiAvLwlEZXNjcmlwdGlvbjoKIC8vCQlDYWxsYmFjayBmdW5jdGlvbiBvZiBVcGRhdGVUeFBvd2VyV29ya0l0ZW0uCi0vLwkJQmVjYXVzZSBvZiBzb21lIGV2ZW50IGhhcHBlbmQsIGUuZy4gQ0NYIFRQQywgSGlnaCBQb3dlciBNZWNoYW5pc20sCisvLwkJQmVjYXVzZSBvZiBzb21lIGV2ZW50IGhhcHBlbmVkLCBlLmcuIENDWCBUUEMsIEhpZ2ggUG93ZXIgTWVjaGFuaXNtLAogLy8JCVdlIHVwZGF0ZSBUeCBwb3dlciBvZiBjdXJyZW50IGNoYW5uZWwgYWdhaW4uCiAvLwogdm9pZCBydGw4MTgwX3R4X3B3X3dxIChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCkBAIC05ODQsNyArOTg0LDcgQEAKIAkJewogCQkJcHJpdi0+VHJ5dXBpbmdDb3VudCA9IDA7CiAJCQkvLwotCQkJLy8gV2hlbiB0cmFuc2ZlcmluZyBmcm9tIENDSyB0byBPRkRNLCBESUcgaXMgYW4gaW1wb3J0YW50IGlzc3VlLgorCQkJLy8gV2hlbiB0cmFuc2ZlcnJpbmcgZnJvbSBDQ0sgdG8gT0ZETSwgRElHIGlzIGFuIGltcG9ydGFudCBpc3N1ZS4KIAkJCS8vCiAJCQlpZihwcml2LT5DdXJyZW50T3BlcmFSYXRlID09IDIyKQogCQkJCWJVcGRhdGVJbml0aWFsR2FpbiA9IHRydWU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL3I4MTgwX3J0bDgyMjV6Mi5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9yODE4MF9ydGw4MjI1ejIuYwppbmRleCAyYTJhZmQ1Li4zZjA5Zjc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL3I4MTgwX3J0bDgyMjV6Mi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvcjgxODBfcnRsODIyNXoyLmMKQEAgLTM3OCw3ICszNzgsNyBAQAogCW1hc2sgPSAobG93MmhpZ2gpID8gMHgwMSA6ICgoKHUzMikweDAxKSA8PCAoMTItMSkpOwogCiAJLyoKLQkgKiBXZSBtdXN0IHNldCBkYXRhIHBpbiB0byBIVyBjb250cm9sZWQsIG90aGVyd2lzZSBSRiBjYW4ndCBkcml2ZXIgaXQKKwkgKiBXZSBtdXN0IHNldCBkYXRhIHBpbiB0byBIVyBjb250cm9sbGVkLCBvdGhlcndpc2UgUkYgY2FuJ3QgZHJpdmVyIGl0CiAJICogYW5kIHZhbHVlIFJGIHJlZ2lzdGVyIHdvbid0IGJlIGFibGUgdG8gcmVhZCBiYWNrIHByb3Blcmx5LgogCSAqLwogCXdyaXRlX25pY193b3JkKGRldiwgUkZQaW5zRW5hYmxlLCAob3ZhbDIgJiAofjB4MDEpKSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL3I4MTg1Yl9pbml0LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE4N3NlL3I4MTg1Yl9pbml0LmMKaW5kZXggM2JkZjliMy4uNGIwYjgzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxODdzZS9yODE4NWJfaW5pdC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTg3c2UvcjgxODViX2luaXQuYwpAQCAtMTI3Myw3ICsxMjczLDcgQEAKIAkvKgogCQlTdG9wIEJlYWNvbi4KIAotCQlWaXN0YSBhZGQgYSBBZGhvYyBwcm9maWxlLCBIVyByYWRpbyBvZmYgdW50aWxsIE9JRF9ET1QxMV9SRVNFVF9SRVFVRVNUCisJCVZpc3RhIGFkZCBhIEFkaG9jIHByb2ZpbGUsIEhXIHJhZGlvIG9mZiB1bnRpbCBPSURfRE9UMTFfUkVTRVRfUkVRVUVTVAogCQlEcml2ZXIgd291bGQgc2V0IE1TUj1OT19MSU5LLCB0aGVuIEhXIFJhZGlvIE9OLCBNZ250UXVldWUgU3R1Y2suCiAJCUJlY2F1c2UgQmNuIERNQSBpc24ndCBjb21wbGV0ZSwgbWdudCBxdWV1ZSB3b3VsZCBzdHVjayB1bnRpbCBCY24gcGFja2V0IHNlbmQuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9LY29uZmlnIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL0tjb25maWcKaW5kZXggMmU2NGIyMy4uNzUwYzM0NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL0tjb25maWcKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL0tjb25maWcKQEAgLTEsNiArMSw3IEBACiBjb25maWcgUlRMODE5MkUKIAl0cmlzdGF0ZSAiUmVhbFRlayBSVEw4MTkyRSBXaXJlbGVzcyBMQU4gTklDIGRyaXZlciIKIAlkZXBlbmRzIG9uIFBDSSAmJiBXTEFOCisJZGVwZW5kcyBvbiBtCiAJc2VsZWN0IFdJUkVMRVNTX0VYVAogCXNlbGVjdCBXRVhUX1BSSVYKIAlzZWxlY3QgQ1JZUFRPCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL2llZWU4MDIxMS5oIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9pZWVlODAyMTEuaAppbmRleCAzY2EzODgxLi5kYmUyMWFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL2llZWU4MDIxMS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvaWVlZTgwMjExLmgKQEAgLTE5NjcsNyArMTk2Nyw3IEBACiAgICAgICAgIHUxNiBwcmV2X3NlcV9jdGw7ICAgICAgIC8qIHVzZWQgdG8gZHJvcCBkdXBsaWNhdGUgZnJhbWVzICovCiAKIAkvKiBtYXAgb2YgYWxsb3dlZCBjaGFubmVscy4gMCBpcyBkdW1teSAqLwotCS8vIEZJWE1FOiByZW1lYmVyIHRvIGRlZmF1bHQgdG8gYSBiYXNpYyBjaGFubmVsIHBsYW4gZGVwZW5kaW5nIG9mIHRoZSBQSFkgdHlwZQorCS8vIEZJWE1FOiByZW1lbWJlciB0byBkZWZhdWx0IHRvIGEgYmFzaWMgY2hhbm5lbCBwbGFuIGRlcGVuZGluZyBvZiB0aGUgUEhZIHR5cGUKICNpZmRlZiBFTkFCTEVfRE9UMTFECiAJdm9pZCogcERvdDExZEluZm87CiAJYm9vbCBiR2xvYmFsRG9tYWluOwpAQCAtMjEyMSw3ICsyMTIxLDcgQEAKIAkgKiBub3Qgc2V0LiBBcyBzb21lIGNhcmRzIG1heSBoYXZlIGRpZmZlcmVudCBIVyBxdWV1ZXMgdGhhdAogCSAqIG9uZSBtaWdodCB3YW50IHRvIHVzZSBmb3IgZGF0YSBhbmQgbWFuYWdlbWVudCBmcmFtZXMKIAkgKiB0aGUgb3B0aW9uIHRvIGhhdmUgdHdvIGNhbGxiYWNrcyBtaWdodCBiZSB1c2VmdWwuCi0JICogVGhpcyBmdWNudGlvbiBjYW4ndCBzbGVlcC4KKwkgKiBUaGlzIGZ1bmN0aW9uIGNhbid0IHNsZWVwLgogCSAqLwogCWludCAoKnNvZnRtYWNfaGFyZF9zdGFydF94bWl0KShzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAogCQkJICAgICAgIHN0cnVjdCBpZWVlODAyMTFfZGV2aWNlICppZWVlODAyMTEpOwpAQCAtMjE2MCw5ICsyMTYwLDkgQEAKIAkgKiBpdCBpcyBjYWxsZWQgaW4gYSB3b3JrX3F1ZXVlIHdoZW4gc3dpdGhjaW5nIHRvIGFkLWhvYyBtb2RlCiAJICogb3IgaW4gYmVoYWxmIG9mIGl3bGlzdCBzY2FuIHdoZW4gdGhlIGNhcmQgaXMgYXNzb2NpYXRlZAogCSAqIGFuZCByb290IHVzZXIgYXNrIGZvciBhIHNjYW4uCi0JICogdGhlIGZ1Y250aW9uIHN0b3Bfc2NhbiBzaG91bGQgc3RvcCBib3RoIHRoZSBzeW5jcm8gYW5kCisJICogdGhlIGZ1bmN0aW9uIHN0b3Bfc2NhbiBzaG91bGQgc3RvcCBib3RoIHRoZSBzeW5jcm8gYW5kCiAJICogYmFja2dyb3VuZCBzY2FubmluZyBhbmQgY2FuIHNsZWVwLgotCSAqIFRoZSBmdWNudGlvbiBzdGFydF9zY2FuIHNob3VsZCBpbml0aWF0ZSB0aGUgYmFja2dyb3VuZAorCSAqIFRoZSBmdW5jdGlvbiBzdGFydF9zY2FuIHNob3VsZCBpbml0aWF0ZSB0aGUgYmFja2dyb3VuZAogCSAqIHNjYW5uaW5nIGFuZCBjYW4ndCBzbGVlcC4KIAkgKi8KIAl2b2lkICgqc2Nhbl9zeW5jcm8pKHN0cnVjdCBpZWVlODAyMTFfZGV2aWNlICppZWVlODAyMTEpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9pZWVlODAyMTFfcnguYyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvaWVlZTgwMjExX3J4LmMKaW5kZXggYWRkMDE1ZS4uZWQ1YTM4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9pZWVlODAyMTFfcnguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL2llZWU4MDIxMV9yeC5jCkBAIC0xNDI2LDcgKzE0MjYsNyBAQAogc3RhdGljIHU4IHFvc19vdWlbUU9TX09VSV9MRU5dID0geyAweDAwLCAweDUwLCAweEYyIH07CiAKIC8qCi0qIE1ha2UgdGhlciBzdHJ1Y3R1cmUgd2UgcmVhZCBmcm9tIHRoZSBiZWFjb24gcGFja2V0IGhhcworKiBNYWtlIHRoZSBzdHJ1Y3R1cmUgd2UgcmVhZCBmcm9tIHRoZSBiZWFjb24gcGFja2V0IHRvIGhhdmUKICogdGhlIHJpZ2h0IHZhbHVlcwogKi8KIHN0YXRpYyBpbnQgaWVlZTgwMjExX3ZlcmlmeV9xb3NfaW5mbyhzdHJ1Y3QgaWVlZTgwMjExX3Fvc19pbmZvcm1hdGlvbl9lbGVtZW50CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL2llZWU4MDIxMV9zb2Z0bWFjLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL2llZWU4MDIxMV9zb2Z0bWFjLmMKaW5kZXggZjY5MjJkNC4uN2Q0Y2JhMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9pZWVlODAyMTFfc29mdG1hYy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvaWVlZTgwMjExX3NvZnRtYWMuYwpAQCAtMjAyMyw3ICsyMDIzLDcgQEAKIAkJCQkJCQlyZXR1cm4gMTsKIAkJCQkJCX0KIAkJCQkJCWVsc2UKLQkJCQkJCXsJLy9maWxsaW5nIHRoZSBQZWVySFRDYXAuIC8vbWF5YmUgbm90IG5lY2Nlc2FyeSBhcyB3ZSBjYW4gZ2V0IGl0cyBpbmZvIGZyb20gY3VycmVudF9uZXR3b3JrLgorCQkJCQkJewkvL2ZpbGxpbmcgdGhlIFBlZXJIVENhcC4gLy9tYXliZSBub3QgbmVjZXNzYXJ5IGFzIHdlIGNhbiBnZXQgaXRzIGluZm8gZnJvbSBjdXJyZW50X25ldHdvcmsuCiAJCQkJCQkJbWVtY3B5KGllZWUtPnBIVEluZm8tPlBlZXJIVENhcEJ1ZiwgbmV0d29yay0+YnNzaHQuYmRIVENhcEJ1ZiwgbmV0d29yay0+YnNzaHQuYmRIVENhcExlbik7CiAJCQkJCQkJbWVtY3B5KGllZWUtPnBIVEluZm8tPlBlZXJIVEluZm9CdWYsIG5ldHdvcmstPmJzc2h0LmJkSFRJbmZvQnVmLCBuZXR3b3JrLT5ic3NodC5iZEhUSW5mb0xlbik7CiAJCQkJCQl9CkBAIC0yMTYzLDcgKzIxNjMsNyBAQAogCXJldHVybiAwOwogfQogCi0vKiBmb2xsb3dpbmcgYXJlIGZvciBhIHNpbXBsaWVyIFRYIHF1ZXVlIG1hbmFnZW1lbnQuCisvKiBmb2xsb3dpbmcgYXJlIGZvciBhIHNpbXBsZXIgVFggcXVldWUgbWFuYWdlbWVudC4KICAqIEluc3RlYWQgb2YgdXNpbmcgbmV0aWZfW3N0b3Avd2FrZV1fcXVldWUgdGhlIGRyaXZlcgogICogd2lsbCB1c2VzIHRoZXNlIHR3byBmdW5jdGlvbiAocGx1cyBhIHJlc2V0IG9uZSksIHRoYXQKICAqIHdpbGwgaW50ZXJuYWxseSB1c2VzIHRoZSBrZXJuZWwgbmV0aWZfKiBhbmQgdGFrZXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvcnRsODE5eF9IVC5oIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X0hULmgKaW5kZXggZjk2ODgxNy4uNTZhMTIwYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X0hULmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X0hULmgKQEAgLTY0LDcgKzY0LDcgQEAKIH1IVF9DSEFOTkVMX1dJRFRILCAqUEhUX0NIQU5ORUxfV0lEVEg7CiAKIC8vCi0vLyBSZXByZXNlbnQgRXh0ZW50aW9uIENoYW5uZWwgT2Zmc2V0IGluIEhUIENhcGFiaWxpdGllcworLy8gUmVwcmVzZW50IEV4dGVuc2lvbiBDaGFubmVsIE9mZnNldCBpbiBIVCBDYXBhYmlsaXRpZXMKIC8vIFRoaXMgaXMgYXZhaWxhYmxlIG9ubHkgaW4gNDBNaHogbW9kZS4KIC8vCiB0eXBlZGVmIGVudW0gX0hUX0VYVENITkxfT0ZGU0VUewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X0hUUHJvYy5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X0hUUHJvYy5jCmluZGV4IGEyYTRmZTkuLmY3YTlkYTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvcnRsODE5eF9IVFByb2MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL3J0bDgxOXhfSFRQcm9jLmMKQEAgLTQ1OSw3ICs0NTksNyBAQAogLyoqCiAqIEZ1bmN0aW9uOglIVElPVEFjdElzRGlzYWJsZU1DUzE1CiAqCi0qIE92ZXJ2aWV3OglDaGVjayB3aGV0aGVyIGRyaXZlciBzaG91bGQgZGVjbGFyZSBjYXBhYmlsaXR5IG9mIHJlY2V2aW5nIE1DUzE1CisqIE92ZXJ2aWV3OglDaGVjayB3aGV0aGVyIGRyaXZlciBzaG91bGQgZGVjbGFyZSBjYXBhYmlsaXR5IG9mIHJlY2VpdmluZyBNQ1MxNQogKgogKiBJbnB1dDoKICoJCQlQQURBUFRFUgkJQWRhcHRlciwKQEAgLTQ5Niw3ICs0OTYsNyBAQAogLyoqCiAqIEZ1bmN0aW9uOglIVElPVEFjdElzRGlzYWJsZU1DU1R3b1NwYXRpYWxTdHJlYW0KICoKLSogT3ZlcnZpZXc6CUNoZWNrIHdoZXRoZXIgZHJpdmVyIHNob3VsZCBkZWNsYXJlIGNhcGFiaWxpdHkgb2YgcmVjZXZpbmcgQWxsIDIgc3MgcGFja2V0cworKiBPdmVydmlldzoJQ2hlY2sgd2hldGhlciBkcml2ZXIgc2hvdWxkIGRlY2xhcmUgY2FwYWJpbGl0eSBvZiByZWNlaXZpbmcgQWxsIDIgc3MgcGFja2V0cwogKgogKiBJbnB1dDoKICoJCQlQQURBUFRFUgkJQWRhcHRlciwKQEAgLTE2ODEsNyArMTY4MSw3IEBACiAJLy9pZiBpbiBoYWxmIE4gbW9kZSwgc2V0IHRvIDIwTSBiYW5kd2lkdGggcGxlYXNlIDA5LjA4LjIwMDggV0IuCiAJaWYgKEJhbmR3aWR0aD09SFRfQ0hBTk5FTF9XSURUSF8yMF80MCAmJiAoIWllZWUtPkdldEhhbGZObW9kZVN1cHBvcnRCeUFQc0hhbmRsZXIoaWVlZSkpKQogCSB7Ci0JIAkJLy8gSGFuZGxlIElsbGVnYWwgZXh0ZW50aW9uIGNoYW5uZWwgb2Zmc2V0ISEKKwkgCQkvLyBIYW5kbGUgSWxsZWdhbCBleHRlbnNpb24gY2hhbm5lbCBvZmZzZXQhIQogCQlpZihpZWVlLT5jdXJyZW50X25ldHdvcmsuY2hhbm5lbDwyICYmIE9mZnNldD09SFRfRVhUQ0hOTF9PRkZTRVRfTE9XRVIpCiAJCQlPZmZzZXQgPSBIVF9FWFRDSE5MX09GRlNFVF9OT19FWFQ7CiAJCWlmKE9mZnNldD09SFRfRVhUQ0hOTF9PRkZTRVRfVVBQRVIgfHwgT2Zmc2V0PT1IVF9FWFRDSE5MX09GRlNFVF9MT1dFUikgewpAQCAtMTY5OCw3ICsxNjk4LDcgQEAKIAogCXBIVEluZm8tPmJTd0J3SW5Qcm9ncmVzcyA9IHRydWU7CiAKLQkvLyBUT0RPOiAyMDA3LjcuMTMgYnkgRW1pbHkgV2FpdCAyMDAwbXMgIGluIG9yZGVyIHRvIGdhcmFudGVlIHRoYXQgc3dpdGNoaW5nCisJLy8gVE9ETzogMjAwNy43LjEzIGJ5IEVtaWx5IFdhaXQgMjAwMG1zICBpbiBvcmRlciB0byBndWFyYW50ZWUgdGhhdCBzd2l0Y2hpbmcKIAkvLyAgIGJhbmR3aWR0aCBpcyBleGVjdXRlZCBhZnRlciBzY2FuIGlzIGZpbmlzaGVkLiBJdCBpcyBhIHRlbXBvcmFsIHNvbHV0aW9uCiAJLy8gICBiZWNhdXNlIHNvZnR3YXJlIHNob3VsZCBnYW5yYW50ZWUgdGhlIGxhc3Qgb3BlcmF0aW9uIG9mIHN3aXRjaGluZyBiYW5kd2lkdGgKIAkvLyAgIGlzIGV4ZWN1dGVkIHByb3BlcmxseS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvcnRsODE5eF9UUy5oIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X1RTLmgKaW5kZXggYmFhYWMyMS4uZTdlMjZmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X1RTLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X1RTLmgKQEAgLTQ0LDcgKzQ0LDcgQEAKIAl1MTYJCQkJUnhUaW1lb3V0SW5kaWNhdGVTZXE7CiAJc3RydWN0IGxpc3RfaGVhZAkJUnhQZW5kaW5nUGt0TGlzdDsKIAlzdHJ1Y3QgdGltZXJfbGlzdAkJUnhQa3RQZW5kaW5nVGltZXI7Ci0JQkFfUkVDT1JECQkJUnhBZG1pdHRlZEJBUmVjb3JkOwkgLy8gRm9yIEJBIFJlY2VwaWVudAorCUJBX1JFQ09SRAkJCVJ4QWRtaXR0ZWRCQVJlY29yZDsJIC8vIEZvciBCQSBSZWNpcGllbnQKIAl1MTYJCQkJUnhMYXN0U2VxTnVtOwogCXU4CQkJCVJ4TGFzdEZyYWdOdW07CiAJdTgJCQkJbnVtOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X1RTUHJvYy5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL2llZWU4MDIxMS9ydGw4MTl4X1RTUHJvYy5jCmluZGV4IDI5ZWVjZjAuLmFkNjg3MmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9pZWVlODAyMTEvcnRsODE5eF9UU1Byb2MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvaWVlZTgwMjExL3J0bDgxOXhfVFNQcm9jLmMKQEAgLTEzNSw3ICsxMzUsNyBAQAogCVJlc2V0VHNDb21tb25JbmZvKCZwVFMtPlRzQ29tbW9uSW5mbyk7CiAJcFRTLT5SeEluZGljYXRlU2VxID0gMHhmZmZmOyAvLyBUaGlzIGluZGljYXRlIHRoZSBSeEluZGljYXRlU2VxIGlzIG5vdCB1c2VkIG5vdyEhCiAJcFRTLT5SeFRpbWVvdXRJbmRpY2F0ZVNlcSA9IDB4ZmZmZjsgLy8gVGhpcyBpbmRpY2F0ZSB0aGUgUnhUaW1lb3V0SW5kaWNhdGVTZXEgaXMgbm90IHVzZWQgbm93ISEKLQlSZXNldEJhRW50cnkoJnBUUy0+UnhBZG1pdHRlZEJBUmVjb3JkKTsJICAvLyBGb3IgQkEgUmVjZXBpZW50CisJUmVzZXRCYUVudHJ5KCZwVFMtPlJ4QWRtaXR0ZWRCQVJlY29yZCk7CSAgLy8gRm9yIEJBIFJlY2lwaWVudAogfQogCiB2b2lkIFRTSW5pdGlhbGl6ZShzdHJ1Y3QgaWVlZTgwMjExX2RldmljZSAqaWVlZSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9yODE5eEVfcGh5LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvcjgxOXhFX3BoeS5jCmluZGV4IGRmYTRlMTEuLjllNzgyOGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkyZS9yODE5eEVfcGh5LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL3I4MTl4RV9waHkuYwpAQCAtMjAzMiwxMyArMjAzMiwxMyBAQAogCXsKIAkJY2FzZSBIVF9DSEFOTkVMX1dJRFRIXzIwOgogCQkJcmVnQndPcE1vZGUgfD0gQldfT1BNT0RFXzIwTUhaOwotCQkgICAgICAgLy8gMjAwNy8wMi8wNyBNYXJrIGJ5IEVtaWx5IGJlY2FzdWUgd2UgaGF2ZSBub3QgdmVyaWZ5IHdoZXRoZXIgdGhpcyByZWdpc3RlciB3b3JrcworCQkgICAgICAgLy8gMjAwNy8wMi8wNyBNYXJrIGJ5IEVtaWx5IGJlY2F1c2Ugd2UgaGF2ZSBub3QgdmVyaWZ5IHdoZXRoZXIgdGhpcyByZWdpc3RlciB3b3JrcwogCQkJd3JpdGVfbmljX2J5dGUocHJpdiwgQldfT1BNT0RFLCByZWdCd09wTW9kZSk7CiAJCQlicmVhazsKIAogCQljYXNlIEhUX0NIQU5ORUxfV0lEVEhfMjBfNDA6CiAJCQlyZWdCd09wTW9kZSAmPSB+QldfT1BNT0RFXzIwTUhaOwotICAgICAgICAJCS8vIDIwMDcvMDIvMDcgTWFyayBieSBFbWlseSBiZWNhc3VlIHdlIGhhdmUgbm90IHZlcmlmeSB3aGV0aGVyIHRoaXMgcmVnaXN0ZXIgd29ya3MKKyAgICAgICAgCQkvLyAyMDA3LzAyLzA3IE1hcmsgYnkgRW1pbHkgYmVjYXVzZSB3ZSBoYXZlIG5vdCB2ZXJpZnkgd2hldGhlciB0aGlzIHJlZ2lzdGVyIHdvcmtzCiAJCQl3cml0ZV9uaWNfYnl0ZShwcml2LCBCV19PUE1PREUsIHJlZ0J3T3BNb2RlKTsKIAkJCWJyZWFrOwogCkBAIC0yMTE2LDcgKzIxMTYsNyBAQAogfQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKmZ1bmN0aW9uOiAgVGhpcyBmdW5jdGlvbiBzY2hlZHVsZXMgYmFuZHdpdGggc3dpdGNoIHdvcmsuCisgKmZ1bmN0aW9uOiAgVGhpcyBmdW5jdGlvbiBzY2hlZHVsZXMgYmFuZHdpZHRoIHN3aXRjaCB3b3JrLgogICogICBpbnB1dDogIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYKICAqICAgCSAgICAgSFRfQ0hBTk5FTF9XSURUSAlCYW5kd2lkdGggIC8vMjBNIG9yIDQwTQogICogICAJICAgICBIVF9FWFRDSE5MX09GRlNFVCBPZmZzZXQgCSAgIC8vVXBwZXIsIExvd2VyLCBvciBEb24ndCBjYXJlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvS2NvbmZpZyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9LY29uZmlnCmluZGV4IDI4OTY5MTkuLjNmMDU1MDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9LY29uZmlnCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9LY29uZmlnCkBAIC0xLDYgKzEsNyBAQAogY29uZmlnIFJUTDgxOTJVCiAJdHJpc3RhdGUgIlJlYWxUZWsgUlRMODE5MlUgV2lyZWxlc3MgTEFOIE5JQyBkcml2ZXIiCiAJZGVwZW5kcyBvbiBQQ0kgJiYgV0xBTiAmJiBVU0IKKwlkZXBlbmRzIG9uIG0KIAlzZWxlY3QgV0lSRUxFU1NfRVhUCiAJc2VsZWN0IFdFWFRfUFJJVgogCXNlbGVjdCBDUllQVE8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvaWVlZTgwMjExLmggYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL2llZWU4MDIxMS5oCmluZGV4IGMwYjg0NGQuLmU3MTZmN2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvaWVlZTgwMjExLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9pZWVlODAyMTEuaApAQCAtMTk2NSw3ICsxOTY1LDcgQEAKIAl1MTYgcHJldl9zZXFfY3RsOyAgICAgICAvKiB1c2VkIHRvIGRyb3AgZHVwbGljYXRlIGZyYW1lcyAqLwogCiAJLyogbWFwIG9mIGFsbG93ZWQgY2hhbm5lbHMuIDAgaXMgZHVtbXkgKi8KLQkvLyBGSVhNRTogcmVtZWJlciB0byBkZWZhdWx0IHRvIGEgYmFzaWMgY2hhbm5lbCBwbGFuIGRlcGVuZGluZyBvZiB0aGUgUEhZIHR5cGUKKwkvLyBGSVhNRTogcmVtZW1iZXIgdG8gZGVmYXVsdCB0byBhIGJhc2ljIGNoYW5uZWwgcGxhbiBkZXBlbmRpbmcgb2YgdGhlIFBIWSB0eXBlCiAJdm9pZCogcERvdDExZEluZm87CiAJYm9vbCBiR2xvYmFsRG9tYWluOwogCWludCByYXRlOyAgICAgICAvKiBjdXJyZW50IHJhdGUgKi8KQEAgLTIxMTksNyArMjExOSw3IEBACiAJICogbm90IHNldC4gQXMgc29tZSBjYXJkcyBtYXkgaGF2ZSBkaWZmZXJlbnQgSFcgcXVldWVzIHRoYXQKIAkgKiBvbmUgbWlnaHQgd2FudCB0byB1c2UgZm9yIGRhdGEgYW5kIG1hbmFnZW1lbnQgZnJhbWVzCiAJICogdGhlIG9wdGlvbiB0byBoYXZlIHR3byBjYWxsYmFja3MgbWlnaHQgYmUgdXNlZnVsLgotCSAqIFRoaXMgZnVjbnRpb24gY2FuJ3Qgc2xlZXAuCisJICogVGhpcyBmdW5jdGlvbiBjYW4ndCBzbGVlcC4KIAkgKi8KIAlpbnQgKCpzb2Z0bWFjX2hhcmRfc3RhcnRfeG1pdCkoc3RydWN0IHNrX2J1ZmYgKnNrYiwKIAkJCSAgICAgICBzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKQEAgLTIxNTgsOSArMjE1OCw5IEBACiAJICogaXQgaXMgY2FsbGVkIGluIGEgd29ya19xdWV1ZSB3aGVuIHN3aXRoY2luZyB0byBhZC1ob2MgbW9kZQogCSAqIG9yIGluIGJlaGFsZiBvZiBpd2xpc3Qgc2NhbiB3aGVuIHRoZSBjYXJkIGlzIGFzc29jaWF0ZWQKIAkgKiBhbmQgcm9vdCB1c2VyIGFzayBmb3IgYSBzY2FuLgotCSAqIHRoZSBmdWNudGlvbiBzdG9wX3NjYW4gc2hvdWxkIHN0b3AgYm90aCB0aGUgc3luY3JvIGFuZAorCSAqIHRoZSBmdW5jdGlvbiBzdG9wX3NjYW4gc2hvdWxkIHN0b3AgYm90aCB0aGUgc3luY3JvIGFuZAogCSAqIGJhY2tncm91bmQgc2Nhbm5pbmcgYW5kIGNhbiBzbGVlcC4KLQkgKiBUaGUgZnVjbnRpb24gc3RhcnRfc2NhbiBzaG91bGQgaW5pdGlhdGUgdGhlIGJhY2tncm91bmQKKwkgKiBUaGUgZnVuY3Rpb24gc3RhcnRfc2NhbiBzaG91bGQgaW5pdGlhdGUgdGhlIGJhY2tncm91bmQKIAkgKiBzY2FubmluZyBhbmQgY2FuJ3Qgc2xlZXAuCiAJICovCiAJdm9pZCAoKnNjYW5fc3luY3JvKShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvaWVlZTgwMjExX3J4LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL2llZWU4MDIxMV9yeC5jCmluZGV4IDQ5OGI1MjAuLmE0MTQzMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvaWVlZTgwMjExX3J4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9pZWVlODAyMTFfcnguYwpAQCAtMTM5OSw3ICsxMzk5LDcgQEAKIHN0YXRpYyB1OCBxb3Nfb3VpW1FPU19PVUlfTEVOXSA9IHsgMHgwMCwgMHg1MCwgMHhGMiB9OwogCiAvKgotKiBNYWtlIHRoZXIgc3RydWN0dXJlIHdlIHJlYWQgZnJvbSB0aGUgYmVhY29uIHBhY2tldCBoYXMKKyogTWFrZSB0aGUgc3RydWN0dXJlIHdlIHJlYWQgZnJvbSB0aGUgYmVhY29uIHBhY2tldCB0byBoYXZlCiAqIHRoZSByaWdodCB2YWx1ZXMKICovCiBzdGF0aWMgaW50IGllZWU4MDIxMV92ZXJpZnlfcW9zX2luZm8oc3RydWN0IGllZWU4MDIxMV9xb3NfaW5mb3JtYXRpb25fZWxlbWVudApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9pZWVlODAyMTFfc29mdG1hYy5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9pZWVlODAyMTFfc29mdG1hYy5jCmluZGV4IDQ5OTJkNjMuLjRlYzBhNjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvaWVlZTgwMjExX3NvZnRtYWMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL2llZWU4MDIxMV9zb2Z0bWFjLmMKQEAgLTE5NzMsNyArMTk3Myw3IEBACiAJCQkJCQkJcmV0dXJuIDE7CiAJCQkJCQl9CiAJCQkJCQllbHNlCi0JCQkJCQl7CS8vZmlsbGluZyB0aGUgUGVlckhUQ2FwLiAvL21heWJlIG5vdCBuZWNjZXNhcnkgYXMgd2UgY2FuIGdldCBpdHMgaW5mbyBmcm9tIGN1cnJlbnRfbmV0d29yay4KKwkJCQkJCXsJLy9maWxsaW5nIHRoZSBQZWVySFRDYXAuIC8vbWF5YmUgbm90IG5lY2Vzc2FyeSBhcyB3ZSBjYW4gZ2V0IGl0cyBpbmZvIGZyb20gY3VycmVudF9uZXR3b3JrLgogCQkJCQkJCW1lbWNweShpZWVlLT5wSFRJbmZvLT5QZWVySFRDYXBCdWYsIG5ldHdvcmstPmJzc2h0LmJkSFRDYXBCdWYsIG5ldHdvcmstPmJzc2h0LmJkSFRDYXBMZW4pOwogCQkJCQkJCW1lbWNweShpZWVlLT5wSFRJbmZvLT5QZWVySFRJbmZvQnVmLCBuZXR3b3JrLT5ic3NodC5iZEhUSW5mb0J1ZiwgbmV0d29yay0+YnNzaHQuYmRIVEluZm9MZW4pOwogCQkJCQkJfQpAQCAtMjExMyw3ICsyMTEzLDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotLyogZm9sbG93aW5nIGFyZSBmb3IgYSBzaW1wbGllciBUWCBxdWV1ZSBtYW5hZ2VtZW50LgorLyogZm9sbG93aW5nIGFyZSBmb3IgYSBzaW1wbGVyIFRYIHF1ZXVlIG1hbmFnZW1lbnQuCiAgKiBJbnN0ZWFkIG9mIHVzaW5nIG5ldGlmX1tzdG9wL3dha2VdX3F1ZXVlIHRoZSBkcml2ZXIKICAqIHdpbGwgdXNlcyB0aGVzZSB0d28gZnVuY3Rpb24gKHBsdXMgYSByZXNldCBvbmUpLCB0aGF0CiAgKiB3aWxsIGludGVybmFsbHkgdXNlcyB0aGUga2VybmVsIG5ldGlmXyogYW5kIHRha2VzCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL3J0bDgxOXhfSFQuaCBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9IVC5oCmluZGV4IGNkZTYwM2YuLjBiMWExZmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9IVC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9IVC5oCkBAIC02NCw3ICs2NCw3IEBACiB9SFRfQ0hBTk5FTF9XSURUSCwgKlBIVF9DSEFOTkVMX1dJRFRIOwogCiAvLwotLy8gUmVwcmVzZW50IEV4dGVudGlvbiBDaGFubmVsIE9mZnNldCBpbiBIVCBDYXBhYmlsaXRpZXMKKy8vIFJlcHJlc2VudCBFeHRlbnNpb24gQ2hhbm5lbCBPZmZzZXQgaW4gSFQgQ2FwYWJpbGl0aWVzCiAvLyBUaGlzIGlzIGF2YWlsYWJsZSBvbmx5IGluIDQwTWh6IG1vZGUuCiAvLwogdHlwZWRlZiBlbnVtIF9IVF9FWFRDSE5MX09GRlNFVHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9IVFByb2MuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9IVFByb2MuYwppbmRleCA1MGY0ZjU5Li5lODhhODM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL3J0bDgxOXhfSFRQcm9jLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9ydGw4MTl4X0hUUHJvYy5jCkBAIC00MjMsNyArNDIzLDcgQEAKIC8qKgogKiBGdW5jdGlvbjoJSFRJT1RBY3RJc0Rpc2FibGVNQ1MxNQogKgotKiBPdmVydmlldzoJQ2hlY2sgd2hldGhlciBkcml2ZXIgc2hvdWxkIGRlY2xhcmUgY2FwYWJpbGl0eSBvZiByZWNldmluZyBNQ1MxNQorKiBPdmVydmlldzoJQ2hlY2sgd2hldGhlciBkcml2ZXIgc2hvdWxkIGRlY2xhcmUgY2FwYWJpbGl0eSBvZiByZWNlaXZpbmcgTUNTMTUKICoKICogSW5wdXQ6CiAqCQkJUEFEQVBURVIJCUFkYXB0ZXIsCkBAIC00NjAsNyArNDYwLDcgQEAKIC8qKgogKiBGdW5jdGlvbjoJSFRJT1RBY3RJc0Rpc2FibGVNQ1NUd29TcGF0aWFsU3RyZWFtCiAqCi0qIE92ZXJ2aWV3OglDaGVjayB3aGV0aGVyIGRyaXZlciBzaG91bGQgZGVjbGFyZSBjYXBhYmlsaXR5IG9mIHJlY2V2aW5nIEFsbCAyIHNzIHBhY2tldHMKKyogT3ZlcnZpZXc6CUNoZWNrIHdoZXRoZXIgZHJpdmVyIHNob3VsZCBkZWNsYXJlIGNhcGFiaWxpdHkgb2YgcmVjZWl2aW5nIEFsbCAyIHNzIHBhY2tldHMKICoKICogSW5wdXQ6CiAqCQkJUEFEQVBURVIJCUFkYXB0ZXIsCkBAIC0xNDA5LDcgKzE0MDksNyBAQAogCS8vaWYgaW4gaGFsZiBOIG1vZGUsIHNldCB0byAyME0gYmFuZHdpZHRoIHBsZWFzZSAwOS4wOC4yMDA4IFdCLgogCWlmKEJhbmR3aWR0aD09SFRfQ0hBTk5FTF9XSURUSF8yMF80MCAmJiAoIWllZWUtPkdldEhhbGZObW9kZVN1cHBvcnRCeUFQc0hhbmRsZXIoaWVlZS0+ZGV2KSkpCiAJIHsKLQkJCS8vIEhhbmRsZSBJbGxlZ2FsIGV4dGVudGlvbiBjaGFubmVsIG9mZnNldCEhCisJCQkvLyBIYW5kbGUgSWxsZWdhbCBleHRlbnNpb24gY2hhbm5lbCBvZmZzZXQhIQogCQlpZihpZWVlLT5jdXJyZW50X25ldHdvcmsuY2hhbm5lbDwyICYmIE9mZnNldD09SFRfRVhUQ0hOTF9PRkZTRVRfTE9XRVIpCiAJCQlPZmZzZXQgPSBIVF9FWFRDSE5MX09GRlNFVF9OT19FWFQ7CiAJCWlmKE9mZnNldD09SFRfRVhUQ0hOTF9PRkZTRVRfVVBQRVIgfHwgT2Zmc2V0PT1IVF9FWFRDSE5MX09GRlNFVF9MT1dFUikgewpAQCAtMTQyNiw3ICsxNDI2LDcgQEAKIAogCXBIVEluZm8tPmJTd0J3SW5Qcm9ncmVzcyA9IHRydWU7CiAKLQkvLyBUT0RPOiAyMDA3LjcuMTMgYnkgRW1pbHkgV2FpdCAyMDAwbXMgIGluIG9yZGVyIHRvIGdhcmFudGVlIHRoYXQgc3dpdGNoaW5nCisJLy8gVE9ETzogMjAwNy43LjEzIGJ5IEVtaWx5IFdhaXQgMjAwMG1zICBpbiBvcmRlciB0byBndWFyYW50ZWUgdGhhdCBzd2l0Y2hpbmcKIAkvLyAgIGJhbmR3aWR0aCBpcyBleGVjdXRlZCBhZnRlciBzY2FuIGlzIGZpbmlzaGVkLiBJdCBpcyBhIHRlbXBvcmFsIHNvbHV0aW9uCiAJLy8gICBiZWNhdXNlIHNvZnR3YXJlIHNob3VsZCBnYW5yYW50ZWUgdGhlIGxhc3Qgb3BlcmF0aW9uIG9mIHN3aXRjaGluZyBiYW5kd2lkdGgKIAkvLyAgIGlzIGV4ZWN1dGVkIHByb3BlcmxseS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9UUy5oIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9ydGw4MTl4X1RTLmgKaW5kZXggYmFhYWMyMS4uZTdlMjZmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9ydGw4MTl4X1RTLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9ydGw4MTl4X1RTLmgKQEAgLTQ0LDcgKzQ0LDcgQEAKIAl1MTYJCQkJUnhUaW1lb3V0SW5kaWNhdGVTZXE7CiAJc3RydWN0IGxpc3RfaGVhZAkJUnhQZW5kaW5nUGt0TGlzdDsKIAlzdHJ1Y3QgdGltZXJfbGlzdAkJUnhQa3RQZW5kaW5nVGltZXI7Ci0JQkFfUkVDT1JECQkJUnhBZG1pdHRlZEJBUmVjb3JkOwkgLy8gRm9yIEJBIFJlY2VwaWVudAorCUJBX1JFQ09SRAkJCVJ4QWRtaXR0ZWRCQVJlY29yZDsJIC8vIEZvciBCQSBSZWNpcGllbnQKIAl1MTYJCQkJUnhMYXN0U2VxTnVtOwogCXU4CQkJCVJ4TGFzdEZyYWdOdW07CiAJdTgJCQkJbnVtOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9ydGw4MTl4X1RTUHJvYy5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9ydGw4MTl4X1RTUHJvYy5jCmluZGV4IGMzZmNhYWUuLjk1N2NlNGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvcnRsODE5eF9UU1Byb2MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL3J0bDgxOXhfVFNQcm9jLmMKQEAgLTEzNSw3ICsxMzUsNyBAQAogCVJlc2V0VHNDb21tb25JbmZvKCZwVFMtPlRzQ29tbW9uSW5mbyk7CiAJcFRTLT5SeEluZGljYXRlU2VxID0gMHhmZmZmOyAvLyBUaGlzIGluZGljYXRlIHRoZSBSeEluZGljYXRlU2VxIGlzIG5vdCB1c2VkIG5vdyEhCiAJcFRTLT5SeFRpbWVvdXRJbmRpY2F0ZVNlcSA9IDB4ZmZmZjsgLy8gVGhpcyBpbmRpY2F0ZSB0aGUgUnhUaW1lb3V0SW5kaWNhdGVTZXEgaXMgbm90IHVzZWQgbm93ISEKLQlSZXNldEJhRW50cnkoJnBUUy0+UnhBZG1pdHRlZEJBUmVjb3JkKTsJICAvLyBGb3IgQkEgUmVjZXBpZW50CisJUmVzZXRCYUVudHJ5KCZwVFMtPlJ4QWRtaXR0ZWRCQVJlY29yZCk7CSAgLy8gRm9yIEJBIFJlY2lwaWVudAogfQogCiB2b2lkIFRTSW5pdGlhbGl6ZShzdHJ1Y3QgaWVlZTgwMjExX2RldmljZSAqaWVlZSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvc2NhdHRlcndhbGsuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9pZWVlODAyMTEvc2NhdHRlcndhbGsuYwppbmRleCA0OWY0MDFmLi4zNTQzYTYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvaWVlZTgwMjExL3NjYXR0ZXJ3YWxrLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L2llZWU4MDIxMS9zY2F0dGVyd2Fsay5jCkBAIC03MSw3ICs3MSw3IEBACiAJCQkJIHVuc2lnbmVkIGludCBtb3JlKQogewogCS8qIHdhbGstPmRhdGEgbWF5IGJlIHBvaW50aW5nIHRoZSBmaXJzdCBieXRlIG9mIHRoZSBuZXh0IHBhZ2U7Ci0JICAgaG93ZXZlciwgd2Uga25vdyB3ZSB0cmFuc2ZlcmVkIGF0IGxlYXN0IG9uZSBieXRlLiAgU28sCisJICAgaG93ZXZlciwgd2Uga25vdyB3ZSB0cmFuc2ZlcnJlZCBhdCBsZWFzdCBvbmUgYnl0ZS4gIFNvLAogCSAgIHdhbGstPmRhdGEgLSAxIHdpbGwgYmUgYSB2aXJ0dWFsIGFkZHJlc3MgaW4gdGhlIG1hcHBlZCBwYWdlLiAqLwogCiAJaWYgKG91dCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9yODE5MlVfY29yZS5jIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L3I4MTkyVV9jb3JlLmMKaW5kZXggZGE2MTJlNi4uZTgxYjhhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L3I4MTkyVV9jb3JlLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L3I4MTkyVV9jb3JlLmMKQEAgLTQ2MCw3ICs0NjAsNyBAQAogLyogdTggcmVhZF9waHlfY2NrKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHU4IGFkcik7ICovCiAvKiB1OCByZWFkX3BoeV9vZmRtKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHU4IGFkcik7ICovCiAvKiB0aGlzIG1pZ2h0IHN0aWxsIGNhbGxlZCBpbiB3aGF0IHdhcyB0aGUgUEhZIHJ0bDgxODUvcnRsODE5MiBjb21tb24gY29kZQotICogcGxhbnMgYXJlIHRvIHBvc3NpYmlsdHkgdHVybiBpdCBhZ2FpbiBpbiBvbmUgY29tbW9uIGNvZGUuLi4KKyAqIHBsYW5zIGFyZSB0byBwb3NzaWJpbGl0eSB0dXJuIGl0IGFnYWluIGluIG9uZSBjb21tb24gY29kZS4uLgogICovCiBpbmxpbmUgdm9pZCBmb3JjZV9wY2lfcG9zdGluZyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogewpAQCAtMTM3OCw3ICsxMzc4LDcgQEAKIAkJLy90eF9hZ2dfZGVzYy0+TElOSVAgPSAwOwogCQkvL3R4X2FnZ19kZXNjLT5DbWRJbml0ID0gMTsKIAkJdHhfYWdnX2Rlc2MtPk9mZnNldCA9ICBzaXplb2YodHhfZndpbmZvXzgxOXhfdXNiKSArIDg7Ci0JCS8qIGFscmVhZHkgcmF3IGRhdGEsIG5lZWQgbm90IHRvIHN1YnN0cmFjdCBoZWFkZXIgbGVuZ3RoICovCisJCS8qIGFscmVhZHkgcmF3IGRhdGEsIG5lZWQgbm90IHRvIHN1YnRyYWN0IGhlYWRlciBsZW5ndGggKi8KIAkJdHhfYWdnX2Rlc2MtPlBrdFNpemUgPSBza2ItPmxlbiAmIDB4ZmZmZjsKIAogCQkvKkRXT1JEIDEqLwpAQCAtMjg4OCw3ICsyODg4LDcgQEAKIAlSVF9UUkFDRShDT01QX0VQUk9NLCAiPD09PT09PT09PT09JXMoKSwgZXByb210eXBlOiVkXG4iLCBfX0ZVTkNUSU9OX18sIHByaXYtPmVwcm9tdHlwZSk7CiB9CiAKLS8vdXNlZCB0byBzd2FwIGVuZGlhbi4gYXMgbnRvaGwgJiBodG9ubCBhcmUgbm90IG5lY2Nlc3NhcnkgdG8gc3dhcCBlbmRpYW4sIHNvIHVzZSB0aGlzIGluc3RlYWQuCisvL3VzZWQgdG8gc3dhcCBlbmRpYW4uIGFzIG50b2hsICYgaHRvbmwgYXJlIG5vdCBuZWNlc3NhcnkgdG8gc3dhcCBlbmRpYW4sIHNvIHVzZSB0aGlzIGluc3RlYWQuCiBzdGF0aWMgaW5saW5lIHUxNiBlbmRpYW5fc3dhcCh1MTYqIGRhdGEpCiB7CiAJdTE2IHRtcCA9ICpkYXRhOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L3I4MTl4VV9IVFR5cGUuaCBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9yODE5eFVfSFRUeXBlLmgKaW5kZXggMDFmNThiOS4uMmFjNDIxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L3I4MTl4VV9IVFR5cGUuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvcjgxOXhVX0hUVHlwZS5oCkBAIC02NSw3ICs2NSw3IEBACiB9SFRfQ0hBTk5FTF9XSURUSCwgKlBIVF9DSEFOTkVMX1dJRFRIOwogCiAvLwotLy8gUmVwcmVzZW50IEV4dGVudGlvbiBDaGFubmVsIE9mZnNldCBpbiBIVCBDYXBhYmlsaXRpZXMKKy8vIFJlcHJlc2VudCBFeHRlbnNpb24gQ2hhbm5lbCBPZmZzZXQgaW4gSFQgQ2FwYWJpbGl0aWVzCiAvLyBUaGlzIGlzIGF2YWlsYWJsZSBvbmx5IGluIDQwTWh6IG1vZGUuCiAvLwogdHlwZWRlZiBlbnVtIF9IVF9FWFRDSE5MX09GRlNFVHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9yODE5eFVfcGh5LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MnUvcjgxOXhVX3BoeS5jCmluZGV4IDQxNjg0ZTguLmM0NTg2YjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4MTkydS9yODE5eFVfcGh5LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJ1L3I4MTl4VV9waHkuYwpAQCAtMTUzMSwxMyArMTUzMSwxMyBAQAogCXsKIAkJY2FzZSBIVF9DSEFOTkVMX1dJRFRIXzIwOgogCQkJcmVnQndPcE1vZGUgfD0gQldfT1BNT0RFXzIwTUhaOwotCQkgICAgICAgLy8gMjAwNy8wMi8wNyBNYXJrIGJ5IEVtaWx5IGJlY2FzdWUgd2UgaGF2ZSBub3QgdmVyaWZ5IHdoZXRoZXIgdGhpcyByZWdpc3RlciB3b3JrcworCQkgICAgICAgLy8gMjAwNy8wMi8wNyBNYXJrIGJ5IEVtaWx5IGJlY2F1c2Ugd2UgaGF2ZSBub3QgdmVyaWZ5IHdoZXRoZXIgdGhpcyByZWdpc3RlciB3b3JrcwogCQkJd3JpdGVfbmljX2J5dGUoZGV2LCBCV19PUE1PREUsIHJlZ0J3T3BNb2RlKTsKIAkJCWJyZWFrOwogCiAJCWNhc2UgSFRfQ0hBTk5FTF9XSURUSF8yMF80MDoKIAkJCXJlZ0J3T3BNb2RlICY9IH5CV19PUE1PREVfMjBNSFo7Ci0JCQkvLyAyMDA3LzAyLzA3IE1hcmsgYnkgRW1pbHkgYmVjYXN1ZSB3ZSBoYXZlIG5vdCB2ZXJpZnkgd2hldGhlciB0aGlzIHJlZ2lzdGVyIHdvcmtzCisJCQkvLyAyMDA3LzAyLzA3IE1hcmsgYnkgRW1pbHkgYmVjYXVzZSB3ZSBoYXZlIG5vdCB2ZXJpZnkgd2hldGhlciB0aGlzIHJlZ2lzdGVyIHdvcmtzCiAJCQl3cml0ZV9uaWNfYnl0ZShkZXYsIEJXX09QTU9ERSwgcmVnQndPcE1vZGUpOwogCQkJYnJlYWs7CiAKQEAgLTE2NDcsNyArMTY0Nyw3IEBACiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqZnVuY3Rpb246ICBUaGlzIGZ1bmN0aW9uIHNjaGVkdWxlcyBiYW5kd2l0aCBzd2l0Y2ggd29yay4KKyAqZnVuY3Rpb246ICBUaGlzIGZ1bmN0aW9uIHNjaGVkdWxlcyBiYW5kd2lkdGggc3dpdGNoIHdvcmsuCiAgKiAgIGlucHV0OiAgc3RydWN0IG5ldF9kZXZpY2UgKmRldgogICogICAJICAgICBIVF9DSEFOTkVMX1dJRFRICUJhbmR3aWR0aCAgLy8yME0gb3IgNDBNCiAgKiAgIAkgICAgIEhUX0VYVENITkxfT0ZGU0VUIE9mZnNldCAJICAgLy9VcHBlciwgTG93ZXIsIG9yIERvbid0IGNhcmUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfY21kLmggYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9ydGw4NzF4X2NtZC5oCmluZGV4IDNhOTQ1YjUuLjJkYzc4NDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfY21kLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9jbWQuaApAQCAtNjU2LDcgKzY1Niw3IEBACiAvKgogICogUmVzdWx0OgogICogMHgwMDogc3VjY2VzcwotICogMHgwMTogc3VjZXNzLCBhbmQgY2hlY2sgUmVzcG9uc2UuCisgKiAweDAxOiBzdWNjZXNzLCBhbmQgY2hlY2sgUmVzcG9uc2UuCiAgKiAweDAyOiBjbWQgaWdub3JlZCBkdWUgdG8gZHVwbGljYXRlZCBzZXF1Y25lIG51bWJlcgogICogMHgwMzogY21kIGRyb3BwZWQgZHVlIHRvIGludmFsaWQgY21kIGNvZGUKICAqIDB4MDQ6IHJlc2VydmVkLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9sZWQuaCBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfbGVkLmgKaW5kZXggOTk0ZWY4Mi4uODA4NWU1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9sZWQuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9ydGw4NzF4X2xlZC5oCkBAIC03OCwxNCArNzgsMTQgQEAKIH07CiAKIHN0cnVjdCBsZWRfcHJpdiB7Ci0JLyogYWRkIGZvciBsZWQgY29udHJvbGwgKi8KKwkvKiBhZGQgZm9yIGxlZCBjb250cm9sICovCiAJc3RydWN0IExFRF84NzF4CQlTd0xlZDA7CiAJc3RydWN0IExFRF84NzF4CQlTd0xlZDE7CiAJZW51bSBMRURfU1RSQVRFR1lfODcxeAlMZWRTdHJhdGVneTsKIAl1OAkJCWJSZWdVc2VMZWQ7CiAJdm9pZCAoKkxlZENvbnRyb2xIYW5kbGVyKShzdHJ1Y3QgX2FkYXB0ZXIgKnBhZGFwdGVyLAogCQkJCSAgZW51bSBMRURfQ1RMX01PREUgTGVkQWN0aW9uKTsKLQkvKiBhZGQgZm9yIGxlZCBjb250cm9sbCAqLworCS8qIGFkZCBmb3IgbGVkIGNvbnRyb2wgKi8KIH07CiAKIC8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9ydGw4NzF4X21sbWUuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfbWxtZS5jCmluZGV4IDk4YmE3NjAuLjg2NjU1NGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfbWxtZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfbWxtZS5jCkBAIC0xNjYzLDcgKzE2NjMsNyBAQAogCQkJICAgICAgKHN0cnVjdCBuZGlzX3dsYW5fYnNzaWRfZXggKilwZGV2X25ldHdvcmspOwogfQogCi0vKnRoZSBmdWNudGlvbiBpcyBhdCBwYXNzaXZlX2xldmVsKi8KKy8qdGhlIGZ1bmN0aW9uIGlzIGF0IHBhc3NpdmVfbGV2ZWwqLwogdm9pZCByODcxMl9qb2luYnNzX3Jlc2V0KHN0cnVjdCBfYWRhcHRlciAqcGFkYXB0ZXIpCiB7CiAJaW50IGk7CkBAIC0xNzI2LDcgKzE3MjYsNyBAQAogCXJldHVybiBwaHRwcml2LT5odF9vcHRpb247CiB9CiAKLS8qIHRoZSBmdWNudGlvbiBpcyA+IHBhc3NpdmVfbGV2ZWwgKGluIGNyaXRpY2FsX3NlY3Rpb24pICovCisvKiB0aGUgZnVuY3Rpb24gaXMgPiBwYXNzaXZlX2xldmVsIChpbiBjcml0aWNhbF9zZWN0aW9uKSAqLwogc3RhdGljIHZvaWQgdXBkYXRlX2h0X2NhcChzdHJ1Y3QgX2FkYXB0ZXIgKnBhZGFwdGVyLCB1OCAqcGllLCB1aW50IGllX2xlbikKIHsKIAl1OCAqcCwgbWF4X2FtcGR1X3N6OwpAQCAtMTgwMyw3ICsxODAzLDcgQEAKIAl9CiB9CiAKLS8qdGhlIGZ1Y250aW9uIGlzID49IHBhc3NpdmVfbGV2ZWwqLworLyp0aGUgZnVuY3Rpb24gaXMgPj0gcGFzc2l2ZV9sZXZlbCovCiB1bnNpZ25lZCBpbnQgcjg3MTJfYWRkX2h0X2FkZHRfaW5mbyhzdHJ1Y3QgX2FkYXB0ZXIgKnBhZGFwdGVyLAogCQkJICAgICAgdTggKmluX2llLCB1OCAqb3V0X2llLAogCQkJICAgICAgdWludCBpbl9sZW4sIHVpbnQgKnBvdXRfbGVuKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9tbG1lLmggYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9ydGw4NzF4X21sbWUuaAppbmRleCAyYjM1Yjc0Li4yNzk0ODA0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9ydGw4NzF4X21sbWUuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9ydGw4NzF4X21sbWUuaApAQCAtMjksNyArMjksNyBAQAogCQkJCQkJICogIHNpbmdsZS10b25lKi8KICNkZWZpbmUJV0lGSV9NUF9DVFhfQkFDS0dST1VORF9QRU5ESU5HCTB4MDAwODAwMDAgLyogcGVuZGluZyBpbiBjb250LCB0eAogCQkJCQkqIGJhY2tncm91bmQgZHVlIHRvIG91dCBvZiBza2IqLwotI2RlZmluZQlXSUZJX01QX0NUWF9DQ0tfSFcJMHgwMDEwMDAwMAkvKiBpbiBjb250aW5vdXMgdHgqLworI2RlZmluZQlXSUZJX01QX0NUWF9DQ0tfSFcJMHgwMDEwMDAwMAkvKiBpbiBjb250aW51b3VzIHR4Ki8KICNkZWZpbmUJV0lGSV9NUF9DVFhfQ0NLX0NTCTB4MDAyMDAwMDAJLyogaW4gY29udCwgdHggd2l0aCBjYXJyaWVyCiAJCQkJCQkgKiBzdXBwcmVzc2lvbiovCiAjZGVmaW5lICAgV0lGSV9NUF9MUEJLX1NUQVRFCTB4MDA0MDAwMDAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3J0bDg3MXhfbXBfcGh5X3JlZ2RlZi5oIGIvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9tcF9waHlfcmVnZGVmLmgKaW5kZXggZTM4NmZiMC4uMjM1MzJhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9tcF9waHlfcmVnZGVmLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvcnRsODcxeF9tcF9waHlfcmVnZGVmLmgKQEAgLTM4LDcgKzM4LDcgQEAKICAqIDIuIDB4ODAwLzB4OTAwLzB4QTAwLzB4QzAwLzB4RDAwLzB4RTAwCiAgKiAzLiBSRiByZWdpc3RlciAweDAwLTJFCiAgKiA0LiBCaXQgTWFzayBmb3IgQkIvUkYgcmVnaXN0ZXIKLSAqIDUuIE90aGVyIGRlZmludGlvbiBmb3IgQkIvUkYgUi9XCisgKiA1LiBPdGhlciBkZWZpbml0aW9uIGZvciBCQi9SRiBSL1cKICAqCiAgKiAxLiBQTUFDIGR1cGxpY2F0ZSByZWdpc3RlciBkdWUgdG8gY29ubmVjdGlvbjogUkZfTW9kZSwgVFJ4Uk4sIE51bU9mIEwtU1RGCiAgKiAxLiBQYWdlMSgweDEwMCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3VzYl9oYWxpbml0LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi91c2JfaGFsaW5pdC5jCmluZGV4IDBlOTQ4M2IuLjQ2Mjg3YzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3VzYl9oYWxpbml0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvdXNiX2hhbGluaXQuYwpAQCAtMTEyLDcgKzExMiw3IEBACiAJCS8qIEluaXRpYWxpemF0aW9uIGZvciBwb3dlciBvbiBzZXF1ZW5jZSwgKi8KIAkJcjg3MTJfd3JpdGU4KHBhZGFwdGVyLCBTUFMwX0NUUkwgKyAxLCAweDUzKTsKIAkJcjg3MTJfd3JpdGU4KHBhZGFwdGVyLCBTUFMwX0NUUkwsIDB4NTcpOwotCQkvKiBFbmFibGUgQUZFIE1hY3JvIEJsb2NrJ3MgQmFuZGdhcCBhZG4gRW5hYmxlIEFGRSBNYWNybworCQkvKiBFbmFibGUgQUZFIE1hY3JvIEJsb2NrJ3MgQmFuZGdhcCBhbmQgRW5hYmxlIEFGRSBNYWNybwogCQkgKiBCbG9jaydzIE1iaWFzCiAJCSAqLwogCQl2YWw4ID0gcjg3MTJfcmVhZDgocGFkYXB0ZXIsIEFGRV9NSVNDKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydHNfcHN0b3IvcnRzeC5jIGIvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4LmMKaW5kZXggNDUxNDQxOS4uMDI1MjVkNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4LmMKQEAgLTgyNCwxMyArODI0LDEzIEBACiAJY2hpcC0+ZnBnYV9tc19oZ19jbGsgPSBDTEtfODA7CiAJY2hpcC0+ZnBnYV9tc180Yml0X2NsayA9IENMS184MDsKIAljaGlwLT5mcGdhX21zXzFiaXRfY2xrID0gQ0xLXzQwOwotCWNoaXAtPmFzaWNfc2Rfc2RyMTA0X2NsayA9IDIwNzsKLQljaGlwLT5hc2ljX3NkX3NkcjUwX2NsayA9IDk5OwotCWNoaXAtPmFzaWNfc2RfZGRyNTBfY2xrID0gOTk7Ci0JY2hpcC0+YXNpY19zZF9oc19jbGsgPSA5OTsKLQljaGlwLT5hc2ljX21tY181Mm1fY2xrID0gOTk7Ci0JY2hpcC0+YXNpY19tc19oZ19jbGsgPSAxMTk7Ci0JY2hpcC0+YXNpY19tc180Yml0X2NsayA9IDc5OworCWNoaXAtPmFzaWNfc2Rfc2RyMTA0X2NsayA9IDIwMzsKKwljaGlwLT5hc2ljX3NkX3NkcjUwX2NsayA9IDk4OworCWNoaXAtPmFzaWNfc2RfZGRyNTBfY2xrID0gOTg7CisJY2hpcC0+YXNpY19zZF9oc19jbGsgPSA5ODsKKwljaGlwLT5hc2ljX21tY181Mm1fY2xrID0gOTg7CisJY2hpcC0+YXNpY19tc19oZ19jbGsgPSAxMTc7CisJY2hpcC0+YXNpY19tc180Yml0X2NsayA9IDc4OwogCWNoaXAtPmFzaWNfbXNfMWJpdF9jbGsgPSAzOTsKIAljaGlwLT5zc2NfZGVwdGhfc2Rfc2RyMTA0ID0gU1NDX0RFUFRIXzJNOwogCWNoaXAtPnNzY19kZXB0aF9zZF9zZHI1MCA9IFNTQ19ERVBUSF8yTTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydHNfcHN0b3IvcnRzeF9jaGlwLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRzX3BzdG9yL3J0c3hfY2hpcC5jCmluZGV4IGY0NDNkOTcuLmQyZjFjNzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydHNfcHN0b3IvcnRzeF9jaGlwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4X2NoaXAuYwpAQCAtNjg0LDYgKzY4NCwxMSBAQAogCVJUU1hfREVCVUdQKCJkdyBpbiAweDcyNDogMHgleFxuIiwgbHZhbCk7CiAJdmFsID0gKHU4KWx2YWw7CiAJaWYgKCEodmFsICYgMHg4MCkpIHsKKwkJaWYgKHZhbCAmIDB4MDgpCisJCQljaGlwLT5sdW5fbW9kZSA9IERFRkFVTFRfU0lOR0xFOworCQllbHNlCisJCQljaGlwLT5sdW5fbW9kZSA9IFNEX01TXzJMVU47CisKIAkJaWYgKHZhbCAmIDB4MDQpIHsKIAkJCVNFVF9TRElPX0VYSVNUKGNoaXApOwogCQl9IGVsc2UgewpAQCAtNzA1LDEyICs3MTAsNiBAQAogCiAJCWNoaXAtPmFzcG1fbDBzX2wxX2VuID0gKHZhbCA+PiA1KSAmIDB4MDM7CiAKLQkJaWYgKHZhbCAmIDB4MDgpIHsKLQkJCWNoaXAtPmx1bl9tb2RlID0gREVGQVVMVF9TSU5HTEU7Ci0JCX0gZWxzZSB7Ci0JCQljaGlwLT5sdW5fbW9kZSA9IFNEX01TXzJMVU47Ci0JCX0KLQogCQl2YWwgPSAodTgpKGx2YWwgPj4gOCk7CiAKIAkJY2xrID0gKHZhbCA+PiA1KSAmIDB4MDc7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnRzX3BzdG9yL3J0c3hfY2hpcC5oIGIvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4X2NoaXAuaAppbmRleCA3MTNjNWVhLi45ZjdjZDgyYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4X2NoaXAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRzX3BzdG9yL3J0c3hfY2hpcC5oCkBAIC0xODAsOCArMTgwLDggQEAKICNkZWZpbmUgQ1VSX0VSUiAgICAgICAgICAgICAgICAgMHg3MCAgICAvKiBjdXJyZW50IGVycm9yICAgICAgICAgICAgICAgICAgICAqLwogI2RlZmluZSBERUZfRVJSICAgICAgICAgICAgICAgICAweDcxICAgIC8qIHNwZWNpZmljIGNvbW1hbmQgZXJyb3IgICAgICAgICAgICovCiAKLS8qLS0tLSBzZW5zZSBrZXkgSW5mb21hdGlvbiAtLS0tKi8KLSNkZWZpbmUgU05TS0VZSU5GT19MRU4gICAgICAgICAgMyAgICAgICAvKiBsZW5ndGggb2Ygc2Vuc2Uga2V5IGluZm9tYXRpb24gICAqLworLyotLS0tIHNlbnNlIGtleSBJbmZvcm1hdGlvbiAtLS0tKi8KKyNkZWZpbmUgU05TS0VZSU5GT19MRU4gICAgICAgICAgMyAgICAgICAvKiBsZW5ndGggb2Ygc2Vuc2Uga2V5IGluZm9ybWF0aW9uICAgKi8KIAogI2RlZmluZSBTS1NWICAgICAgICAgICAgICAgICAgICAweDgwCiAjZGVmaW5lIENEQl9JTExFR0FMICAgICAgICAgICAgIDB4NDAKQEAgLTIzNSwxMyArMjM1LDEzIEBACiAgICAgdW5zaWduZWQgY2hhciAgIHNlZ19ubzsJCS8qIHNlZ21lbnQgTm8uICAgICAgICAgICAgICAgICAgICAgICovCiAgICAgdW5zaWduZWQgY2hhciAgIHNlbnNlX2tleTsJCS8qIGJ5dGU1IDogSUxJICAgICAgICAgICAgICAgICAgICAgICovCiAJCQkJCQkvKiBiaXQzLTAgOiBzZW5zZSBrZXkgICAgICAgICAgICAgICovCi0gICAgdW5zaWduZWQgY2hhciAgIGluZm9bNF07CQkvKiBpbmZvbWF0aW9uICAgICAgICAgICAgICAgICAgICAgICAqLworICAgIHVuc2lnbmVkIGNoYXIgICBpbmZvWzRdOwkJLyogaW5mb3JtYXRpb24gICAgICAgICAgICAgICAgICAgICAgICovCiAgICAgdW5zaWduZWQgY2hhciAgIGFkX3NlbnNlX2xlbjsJLyogYWRkaXRpb25hbCBzZW5zZSBkYXRhIGxlbmd0aCAgICAgKi8KLSAgICB1bnNpZ25lZCBjaGFyICAgY21kX2luZm9bNF07CS8qIGNvbW1hbmQgc3BlY2lmaWMgaW5mb21hdGlvbiAgICAgICovCisgICAgdW5zaWduZWQgY2hhciAgIGNtZF9pbmZvWzRdOwkvKiBjb21tYW5kIHNwZWNpZmljIGluZm9ybWF0aW9uICAgICAgKi8KICAgICB1bnNpZ25lZCBjaGFyICAgYXNjOwkJLyogQVNDICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KICAgICB1bnNpZ25lZCBjaGFyICAgYXNjcTsJCS8qIEFTQ1EgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCiAgICAgdW5zaWduZWQgY2hhciAgIHJmdTsJCS8qIEZSVSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi0gICAgdW5zaWduZWQgY2hhciAgIHNuc19rZXlfaW5mb1szXTsJLyogc2Vuc2Uga2V5IHNwZWNpZmljIGluZm9tYXRpb24gICAgKi8KKyAgICB1bnNpZ25lZCBjaGFyICAgc25zX2tleV9pbmZvWzNdOwkvKiBzZW5zZSBrZXkgc3BlY2lmaWMgaW5mb3JtYXRpb24gICAgKi8KIH07CiAKIC8qIFBDSSBPcGVyYXRpb24gUmVnaXN0ZXIgQWRkcmVzcyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4X3Njc2kuaCBiL2RyaXZlcnMvc3RhZ2luZy9ydHNfcHN0b3IvcnRzeF9zY3NpLmgKaW5kZXggZmFjMTIyYy4uNjRiODQ5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9ydHN4X3Njc2kuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRzX3BzdG9yL3J0c3hfc2NzaS5oCkBAIC04NSw3ICs4NSw3IEBACiAjZGVmaW5lIENISVBfTk9STUFMTU9ERQkJMHgwMAogI2RlZmluZSBDSElQX0RFQlVHTU9ERQkJMHgwMQogCi0vKiBTRCBQYXNzIFRocm91Z2ggQ29tbWFuZCBFeHRlbnRpb24gKi8KKy8qIFNEIFBhc3MgVGhyb3VnaCBDb21tYW5kIEV4dGVuc2lvbiAqLwogI2RlZmluZSBTRF9QQVNTX1RIUlVfTU9ERQkweEQwCiAjZGVmaW5lIFNEX0VYRUNVVEVfTk9fREFUQQkweEQxCiAjZGVmaW5lIFNEX0VYRUNVVEVfUkVBRAkJMHhEMgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9zZC5jIGIvZHJpdmVycy9zdGFnaW5nL3J0c19wc3Rvci9zZC5jCmluZGV4IDIxYmZhNTcuLjhkMDY2YmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydHNfcHN0b3Ivc2QuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRzX3BzdG9yL3NkLmMKQEAgLTE3MTksNyArMTcxOSw3IEBACiAJfQogCiBTZWFyY2hfRmluaXNoOgotCVJUU1hfREVCVUdQKCJGaW5hbCBjaG9vc2VuIHBoYXNlOiAlZFxuIiwgZmluYWxfcGhhc2UpOworCVJUU1hfREVCVUdQKCJGaW5hbCBjaG9zZW4gcGhhc2U6ICVkXG4iLCBmaW5hbF9waGFzZSk7CiAJcmV0dXJuIGZpbmFsX3BoYXNlOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvc2VwL3NlcF9kcml2ZXIuYyBiL2RyaXZlcnMvc3RhZ2luZy9zZXAvc2VwX2RyaXZlci5jCmluZGV4IDcxYTVmYmMuLjg5MGVlZGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9zZXAvc2VwX2RyaXZlci5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9zZXAvc2VwX2RyaXZlci5jCkBAIC01NSw4ICs1NSw2IEBACiAjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgogI2luY2x1ZGUgPGxpbnV4L3Jhcl9yZWdpc3Rlci5oPgogCi0jaW5jbHVkZSAiLi4vbWVtcmFyL21lbXJhci5oIgotCiAjaW5jbHVkZSAic2VwX2RyaXZlcl9od19kZWZzLmgiCiAjaW5jbHVkZSAic2VwX2RyaXZlcl9jb25maWcuaCIKICNpbmNsdWRlICJzZXBfZHJpdmVyX2FwaS5oIgpAQCAtNTg2LDcgKzU4NCw3IEBACiAJZGV2X2RiZygmc2VwLT5wZGV2LT5kZXYsICJwb2xsOiBzZW5kX2N0IGlzICVseCByZXBseSBjdCBpcyAlbHhcbiIsCiAJCXNlcC0+c2VuZF9jdCwgc2VwLT5yZXBseV9jdCk7CiAKLQkvKiBDaGVjayBpZiBlcnJvciBvY2N1cmVkIGR1cmluZyBwb2xsICovCisJLyogQ2hlY2sgaWYgZXJyb3Igb2NjdXJyZWQgZHVyaW5nIHBvbGwgKi8KIAlyZXR2YWwyID0gc2VwX3JlYWRfcmVnKHNlcCwgSFdfSE9TVF9TRVBfSE9TVF9HUFIzX1JFR19BRERSKTsKIAlpZiAocmV0dmFsMiAhPSAweDApIHsKIAkJZGV2X3dhcm4oJnNlcC0+cGRldi0+ZGV2LCAicG9sbDsgcG9sbCBlcnJvciAleFxuIiwgcmV0dmFsMik7CkBAIC0xMTA2LDcgKzExMDQsNyBAQAogCQkJbGxpX2FycmF5W2NvdW50XS5ibG9ja19zaXplKTsKIAl9CiAKLQkvKiBTZXQgb3V0cHV0IHBhcmFtcyBhY29yZGluZyB0byB0aGUgaW5fb3V0IGZsYWcgKi8KKwkvKiBTZXQgb3V0cHV0IHBhcmFtcyBhY2NvcmRpbmcgdG8gdGhlIGluX291dCBmbGFnICovCiAJaWYgKGluX291dF9mbGFnID09IFNFUF9EUklWRVJfSU5fRkxBRykgewogCQkqbGxpX2FycmF5X3B0ciA9IGxsaV9hcnJheTsKIAkJc2VwLT5kbWFfcmVzX2FycltzZXAtPm5yX2RjYl9jcmVhdF0uaW5fbnVtX3BhZ2VzID0gbnVtX3BhZ2VzOwpAQCAtMTU3Nyw3ICsxNTc1LDcgQEAKIAogCQkvKgogCQkgKiBJZiB0aGlzIGlzIG5vdCB0aGUgbGFzdCB0YWJsZSAtCi0JCSAqIHRoZW4gYWxsaWduIGl0IHRvIHRoZSBibG9jayBzaXplCisJCSAqIHRoZW4gYWxpZ24gaXQgdG8gdGhlIGJsb2NrIHNpemUKIAkJICovCiAJCWlmICghbGFzdF90YWJsZV9mbGFnKQogCQkJdGFibGVfZGF0YV9zaXplID0KQEAgLTE5NzQsNyArMTk3Miw3IEBACiAJZGV2X2RiZygmc2VwLT5wZGV2LT5kZXYsICJTRVBfRFJJVkVSX0VOVFJJRVNfUEVSX1RBQkxFX0lOX1NFUCBpcyAleFxuIiwKIAkJU0VQX0RSSVZFUl9FTlRSSUVTX1BFUl9UQUJMRV9JTl9TRVApOwogCi0JLyogQ2FsbCB0aGUgZnVjbnRpb24gdGhhdCBjcmVhdGVzIHRhYmxlIGZyb20gdGhlIGxsaSBhcnJheXMgKi8KKwkvKiBDYWxsIHRoZSBmdW5jdGlvbiB0aGF0IGNyZWF0ZXMgdGFibGUgZnJvbSB0aGUgbGxpIGFycmF5cyAqLwogCWVycm9yID0gc2VwX2NvbnN0cnVjdF9kbWFfdGFibGVzX2Zyb21fbGxpKHNlcCwgbGxpX2luX2FycmF5LAogCQlzZXAtPmRtYV9yZXNfYXJyW3NlcC0+bnJfZGNiX2NyZWF0XS5pbl9udW1fcGFnZXMsCiAJCWxsaV9vdXRfYXJyYXksCkBAIC0yMzcyLDcgKzIzNzAsNiBAQAogCWludCBlcnJvciA9IDA7CiAJLyogQ29tbWFuZCBhcmdzICovCiAJc3RydWN0IHJhcl9obmRsX3RvX2J1c19zdHJ1Y3QgY29tbWFuZF9hcmdzOwotCXN0cnVjdCBSQVJfYnVmZmVyIHJhcl9idWY7CiAJLyogQnVzIGFkZHJlc3MgKi8KIAlkbWFfYWRkcl90ICByYXJfYnVzID0gMDsKIAkvKiBIb2xkcyB0aGUgUkFSIGFkZHJlc3MgaW4gdGhlIHN5c3RlbSBtZW1vcnkgb2Zmc2V0ICovCkBAIC0yMzg2LDE2ICsyMzgzLDggQEAKIAl9CiAKIAkvKiBDYWxsIHRvIHRyYW5zbGF0aW9uIGZ1bmN0aW9uIG9ubHkgaWYgdXNlciBoYW5kbGUgaXMgbm90IE5VTEwgKi8KLQlpZiAoY29tbWFuZF9hcmdzLnJhcl9oYW5kbGUpIHsKLQkJbWVtc2V0KCZyYXJfYnVmLCAwLCBzaXplb2YocmFyX2J1ZikpOwotCQlyYXJfYnVmLmluZm8uaGFuZGxlID0gKHUzMiljb21tYW5kX2FyZ3MucmFyX2hhbmRsZTsKLQotCQlpZiAocmFyX2hhbmRsZV90b19idXMoJnJhcl9idWYsIDEpICE9IDEpIHsKLQkJCWVycm9yID0gLUVGQVVMVDsKLQkJCWdvdG8gZW5kX2Z1bmN0aW9uOwotCQl9Ci0JCXJhcl9idXMgPSByYXJfYnVmLmJ1c19hZGRyZXNzOwotCX0KKwlpZiAoY29tbWFuZF9hcmdzLnJhcl9oYW5kbGUpCisJCXJldHVybiAtRU9QTk9UU1VQUDsKIAlkZXZfZGJnKCZzZXAtPnBkZXYtPmRldiwgInJhciBtc2c7IHJhcl9hZGRyX2J1cyA9ICV4XG4iLCAodTMyKXJhcl9idXMpOwogCiAJLyogU2V0IHZhbHVlIGluIHRoZSBTWVNURU0gTUVNT1JZIG9mZnNldCAqLwpAQCAtMjQxNiw3ICsyNDA1LDcgQEAKICAqCUBjbWQ6IGNvbW1hbmQKICAqCUBhcmc6IHBvaW50ZXIgdG8gYXJndW1lbnQgc3RydWN0dXJlCiAgKgotICoJSW1wbGVtZW50IHRoZSBpb2N0bCBtZXRob2RzIGF2YWlsYmxlIG9uIHRoZSBTRVAgZGV2aWNlLgorICoJSW1wbGVtZW50IHRoZSBpb2N0bCBtZXRob2RzIGF2YWlsYWJsZSBvbiB0aGUgU0VQIGRldmljZS4KICAqLwogc3RhdGljIGxvbmcgc2VwX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9zZXAvc2VwX2RyaXZlcl9jb25maWcuaCBiL2RyaXZlcnMvc3RhZ2luZy9zZXAvc2VwX2RyaXZlcl9jb25maWcuaAppbmRleCBkM2I5MjIwLi4xMDMzNDI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvc2VwL3NlcF9kcml2ZXJfY29uZmlnLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3NlcC9zZXBfZHJpdmVyX2NvbmZpZy5oCkBAIC02NSwxMSArNjUsMTEgQEAKICNkZWZpbmUgU0VQX0RSSVZFUl9NSU5fREFUQV9TSVpFX1BFUl9UQUJMRQkJMTYKIAogLyogZmxhZyB0aGF0IHNpZ25pZmllcyB0YWggdGhlIGxvY2sgaXMKLWN1cnJlbnRseSBoZWxkIGJ5IHRoZSBwcm9jY2VzcyAoc3RydWN0IGZpbGUpICovCitjdXJyZW50bHkgaGVsZCBieSB0aGUgcHJvY2VzcyAoc3RydWN0IGZpbGUpICovCiAjZGVmaW5lIFNFUF9EUklWRVJfT1dOX0xPQ0tfRkxBRyAgICAgICAgICAgICAgICAgICAgICAgIDEKIAogLyogZmxhZyB0aGF0IHNpZ25pZmllcyB0YWggdGhlIGxvY2sgaXMgY3VycmVudGx5IE5PVAotaGVsZCBieSB0aGUgcHJvY2Nlc3MgKHN0cnVjdCBmaWxlKSAqLworaGVsZCBieSB0aGUgcHJvY2VzcyAoc3RydWN0IGZpbGUpICovCiAjZGVmaW5lIFNFUF9EUklWRVJfRElTT1dOX0xPQ0tfRkxBRyAgICAgICAgICAgICAgICAgICAgIDAKIAogLyogaW5kaWNhdGVzIHdoZXRoZXIgZHJpdmVyIGhhcyBtYXBwZWQvdW5tYXBwZWQgc2hhcmVkIGFyZWEgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9zbGljb3NzL1JFQURNRSBiL2RyaXZlcnMvc3RhZ2luZy9zbGljb3NzL1JFQURNRQppbmRleCA3MGY0OTA5Li5iODNiYmExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvc2xpY29zcy9SRUFETUUKKysrIGIvZHJpdmVycy9zdGFnaW5nL3NsaWNvc3MvUkVBRE1FCkBAIC0zMyw3ICszMyw3IEBACiAJLSBOQVBJPwogCS0gd2FzdGVkIG92ZXJoZWFkIG9mIGV4dHJhIHN0YXRzCiAJLSBzdGF0ZSB2YXJpYWJsZXMgZm9yIHRoaW5ncyB0aGF0IGFyZQotCSAgZWFzaWx5IGF2YWlsYmxlIGFuZCBzaG91bGRuJ3QgYmUga2VwdCBpbiBjYXJkIHN0cnVjdHVyZSwgY2FyZG51bSwgLi4uCisJICBlYXNpbHkgYXZhaWxhYmxlIGFuZCBzaG91bGRuJ3QgYmUga2VwdCBpbiBjYXJkIHN0cnVjdHVyZSwgY2FyZG51bSwgLi4uCiAJICBzbG90bnVtYmVyLCBldmVudHMsIC4uLgogCS0gZ2V0IHJpZCBvZiBzbGljX3NwaW5sb2NrIHdyYXBwZXIKIAktIHZvbGF0aWxlID09IGJhZCBkZXNpZ24gPT4gYmFkIGNvZGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9zbTd4eC9zbXRjZmIuYyBiL2RyaXZlcnMvc3RhZ2luZy9zbTd4eC9zbXRjZmIuYwppbmRleCBkMDA3ZTRhLi4zZTIyMzBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvc203eHgvc210Y2ZiLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3NtN3h4L3NtdGNmYi5jCkBAIC0yNiwxMCArMjYsNiBAQAogICoJQm95b2QueWFuZyA8Ym95b2QueWFuZ0BzaWxpY29ubW90aW9uLmNvbS5jbj4KICAqLwogCi0jaWZuZGVmIF9fS0VSTkVMX18KLSNkZWZpbmUgX19LRVJORUxfXwotI2VuZGlmCi0KICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGxpbnV4L2ZiLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CkBAIC05NjUsNyArOTYxLDcgQEAKIAkJZ290byBmYWlsZWQ7CiAKIAlzbXRjZmJfc2V0bW9kZShzZmIpOwotCS8qIFByaW1hcnkgZGlzcGxheSBzdGFydGluZyBmcm9tIDAgcG9zdGlvbiAqLworCS8qIFByaW1hcnkgZGlzcGxheSBzdGFydGluZyBmcm9tIDAgcG9zaXRpb24gKi8KIAlody5CYXNlQWRkcmVzc0luVlJBTSA9IDA7CiAJc2ZiLT5mYi5wYXIgPSAmaHc7CiAKQEAgLTEwMTksNiArMTAxNSw3IEBACiAJc210Y19mcmVlX2ZiX2luZm8oc2ZiKTsKIH0KIAorI2lmZGVmIENPTkZJR19QTQogLyogSmFzb24gKDA4LzE0LzIwMDkpCiAgKiBzdXNwZW5kIGZ1bmN0aW9uLCBjYWxsZWQgd2hlbiB0aGUgc3VzcGVuZCBldmVudCBpcyB0cmlnZ2VyZWQKICAqLwpAQCAtMTA1NSw3ICsxMDUyLDcgQEAKIAogCXBkZXYtPmRldi5wb3dlci5wb3dlcl9zdGF0ZSA9IG1zZzsKIAotCS8qIGFkZGl0aW9uYWx5IHR1cm4gb2ZmIGFsbCBmdW5jdGlvbiBibG9ja3MgaW5jbHVkaW5nIGludGVybmFsIFBMTHMgKi8KKwkvKiBhZGRpdGlvbmFsbHkgdHVybiBvZmYgYWxsIGZ1bmN0aW9uIGJsb2NrcyBpbmNsdWRpbmcgaW50ZXJuYWwgUExMcyAqLwogCXNtdGNfc2VxdygweDIxLCAweGZmKTsKIAogCXJldHVybiAwOwpAQCAtMTExMSw2ICsxMTA4LDcgQEAKIAogCXJldHVybiAwOwogfQorI2VuZGlmCiAKIC8qIEphc29uICgwOC8xMy8yMDA5KQogICogcGNpX2RyaXZlciBzdHJ1Y3QgdXNlZCB0byB3cmFwIHRoZSBvcmlnaW5hbCBkcml2ZXIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9zcGVha3VwL2tleWhlbHAuYyBiL2RyaXZlcnMvc3RhZ2luZy9zcGVha3VwL2tleWhlbHAuYwppbmRleCAyM2NmN2Y0Li4xNzBmMzg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvc3BlYWt1cC9rZXloZWxwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3NwZWFrdXAva2V5aGVscC5jCkBAIC02OSw3ICs2OSw3IEBACiAJbWVtc2V0KGtleV9vZmZzZXRzLCAwLCBzaXplb2Yoa2V5X29mZnNldHMpKTsKIAlrcCA9IHN0YXRlX3RibCArIG5zdGF0ZXMgKyAxOwogCXdoaWxlICgqa3ArKykgewotCQkvKiBjb3VudCBvY2N1cnJhbmNlcyBvZiBlYWNoIGZ1bmN0aW9uICovCisJCS8qIGNvdW50IG9jY3VycmVuY2VzIG9mIGVhY2ggZnVuY3Rpb24gKi8KIAkJZm9yIChpID0gMDsgaSA8IG5zdGF0ZXM7IGkrKywga3ArKykgewogCQkJaWYgKCEqa3ApCiAJCQkJY29udGludWU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvc3BlYWt1cC9zcGtndWlkZS50eHQgYi9kcml2ZXJzL3N0YWdpbmcvc3BlYWt1cC9zcGtndWlkZS50eHQKaW5kZXggMjQzNjJlYi4uZjMyMTA1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3NwZWFrdXAvc3BrZ3VpZGUudHh0CisrKyBiL2RyaXZlcnMvc3RhZ2luZy9zcGVha3VwL3Nwa2d1aWRlLnR4dApAQCAtMTA5MSw3ICsxMDkxLDcgQEAKIAogVGhlcmUgaXMgbm8gd2F5IHRvIHNhdmUgdGhlc2Ugd2luZG93IHNldHRpbmdzLCBhbmQgeW91IGNhbiBvbmx5IGhhdmUgb25lCiB3aW5kb3cgZGVmaW5lZCBmb3IgZWFjaCB2aXJ0dWFsIGNvbnNvbGUuICBUaGVyZSBpcyBhbHNvIG5vIHdheSB0byBoYXZlCi13aW5kb3dzIGF1dG9tYXRpY2x5IGRlZmluZWQgZm9yIHNwZWNpZmljIGFwcGxpY2F0aW9ucy4KK3dpbmRvd3MgYXV0b21hdGljYWxseSBkZWZpbmVkIGZvciBzcGVjaWZpYyBhcHBsaWNhdGlvbnMuCiAKIEluIG9yZGVyIHRvIGRlZmluZSBhIHdpbmRvdywgdXNlIHRoZSByZXZpZXcga2V5cyB0byBtb3ZlIHlvdXIgcmVhZGluZwogY3Vyc29yIHRvIHRoZSBiZWdpbm5pbmcgb2YgdGhlIGFyZWEgeW91IHdhbnQgdG8gZGVmaW5lLiAgVGhlbiBwcmVzcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3NwZWN0cmEvZmZzcG9ydC5jIGIvZHJpdmVycy9zdGFnaW5nL3NwZWN0cmEvZmZzcG9ydC5jCmluZGV4IDAwN2IyNGIuLjIwZGFlNzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9zcGVjdHJhL2Zmc3BvcnQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvc3BlY3RyYS9mZnNwb3J0LmMKQEAgLTM4LDcgKzM4LDcgQEAKICogT3V0cHV0czogICAgICBOdW1iZXIgb2YgVXNlZCBCaXRzCiAqICAgICAgICAgICAgICAgMCwgaWYgdGhlIGFyZ3VtZW50IGlzIDAKICogRGVzY3JpcHRpb246ICBDYWxjdWxhdGUgdGhlIG51bWJlciBvZiBiaXRzIHVzZWQgYnkgYSBnaXZlbiBwb3dlciBvZiAyIG51bWJlcgotKiAgICAgICAgICAgICAgIE51bWJlciBjYW4gYmUgdXB0byAzMiBiaXQKKyogICAgICAgICAgICAgICBOdW1iZXIgY2FuIGJlIHVwIHRvIDMyIGJpdAogKiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmKi8KIGludCBHTE9CX0NhbGNfVXNlZF9CaXRzKHUzMiBuKQogewpAQCAtNjUzLDcgKzY1Myw3IEBACiAJfQogCWRldi0+cXVldWUtPnF1ZXVlZGF0YSA9IGRldjsKIAotCS8qIEFzIExpbnV4IGJsb2NrIGxheWVyIGRvZW5zJ3Qgc3VwcG9ydCA+NEtCIGhhcmR3YXJlIHNlY3RvciwgICovCisJLyogQXMgTGludXggYmxvY2sgbGF5ZXIgZG9lcyd0IHN1cHBvcnQgPjRLQiBoYXJkd2FyZSBzZWN0b3IsICAqLwogCS8qIEhlcmUgd2UgZm9yY2UgcmVwb3J0IDUxMiBieXRlIGhhcmR3YXJlIHNlY3RvciBzaXplIHRvIEtlcm5lbCAqLwogCWJsa19xdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUoZGV2LT5xdWV1ZSwgNTEyKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3NwZWN0cmEvZmxhc2guYyBiL2RyaXZlcnMvc3RhZ2luZy9zcGVjdHJhL2ZsYXNoLmMKaW5kZXggYTJmODIwMC4uYWVhZDM1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3NwZWN0cmEvZmxhc2guYworKysgYi9kcml2ZXJzL3N0YWdpbmcvc3BlY3RyYS9mbGFzaC5jCkBAIC05NjUsNyArOTY1LDcgQEAKIAlpZiAoMCA9PSAqZmlyc3RfZmFpbGVkX2NtZCkKIAkJKmZpcnN0X2ZhaWxlZF9jbWQgPSBQZW5kaW5nQ01EW2lkeF0uU0JEQ21kSW5kZXg7CiAKLQluYW5kX2RiZ19wcmludChOQU5EX0RCR19ERUJVRywgIlVuY29ycmVjdGFibGUgZXJyb3IgaGFzIG9jY3VyZWQgIgorCW5hbmRfZGJnX3ByaW50KE5BTkRfREJHX0RFQlVHLCAiVW5jb3JyZWN0YWJsZSBlcnJvciBoYXMgb2NjdXJyZWQgIgogCQkid2hpbGUgZXhlY3V0aW5nICV1IENvbW1hbmQgJXUgYWNjZXNpbmcgQmxvY2sgJXVcbiIsCiAJCSh1bnNpZ25lZCBpbnQpcF9CVGFibGVDaGFuZ2VzRGVsdGEtPmZ0bF9jbWRfY250LAogCQlQZW5kaW5nQ01EW2lkeF0uQ01ELApAQCAtMTg3OSw3ICsxODc5LDcgQEAKIH0KIAogLyoKLSAqIFNlYWNoIGluIHRoZSBMZXZlbDIgQ2FjaGUgdGFibGUgdG8gZmluZCB0aGUgY2FjaGUgaXRlbS4KKyAqIFNlYXJjaCBpbiB0aGUgTGV2ZWwyIENhY2hlIHRhYmxlIHRvIGZpbmQgdGhlIGNhY2hlIGl0ZW0uCiAgKiBJZiBmaW5kLCByZWFkIHRoZSBkYXRhIGZyb20gdGhlIE5BTkQgcGFnZSBvZiBMMiBDYWNoZSwKICAqIE90aGVyd2lzZSwgcmV0dXJuIEZBSUwuCiAgKi8KQEAgLTM5ODksNyArMzk4OSw3IEBACiAqIElucHV0czogICAgICAgaW5kZXggdG8gYmxvY2sgdGhhdCB3YXMganVzdCBpbmNyZW1lbnRlZCBhbmQgaXMgYXQgdGhlIG1heAogKiBPdXRwdXRzOiAgICAgIFBBU1M9MCAvIEZBSUw9MQogKiBEZXNjcmlwdGlvbjogIElmIGFueSBlcmFzZSBjb3VudHMgYXQgTUFYLCBhZGp1c3RzIGVyYXNlIGNvdW50IG9mIGV2ZXJ5Ci0qICAgICAgICAgICAgICAgYmxvY2sgYnkgc3Vic3RyYWN0aW5nIGxlYXN0IHdvcm4KKyogICAgICAgICAgICAgICBibG9jayBieSBzdWJ0cmFjdGluZyBsZWFzdCB3b3JuCiAqICAgICAgICAgICAgICAgY291bnRlciBmcm9tIGNvdW50ZXIgdmFsdWUgb2YgZXZlcnkgZW50cnkgaW4gd2VhciB0YWJsZQogKiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmKi8KIHN0YXRpYyBpbnQgRlRMX0FkanVzdF9SZWxhdGl2ZV9FcmFzZV9Db3VudCh1MzIgSW5kZXhfb2ZfTUFYKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3N0ZV9ybWk0L3N5bmFwdGljc19pMmNfcm1pNC5jIGIvZHJpdmVycy9zdGFnaW5nL3N0ZV9ybWk0L3N5bmFwdGljc19pMmNfcm1pNC5jCmluZGV4IGQ1NWE4ZTQuLjNlNjhkNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9zdGVfcm1pNC9zeW5hcHRpY3NfaTJjX3JtaTQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvc3RlX3JtaTQvc3luYXB0aWNzX2kyY19ybWk0LmMKQEAgLTcxLDcgKzcxLDcgQEAKICNkZWZpbmUgU1lOQVBUSUNTX1JNSTRfREVWSUNFX0NPTlRST0xfRlVOQ19OVU0JKDB4MDEpCiAKIC8qKgotICogc3RydWN0IHN5bmFwdGljc19ybWk0X2ZuX2Rlc2MgLSBjb250YWlucyB0aGUgZnVudGlvbiBkZXNjcmlwdG9yIGluZm9ybWF0aW9uCisgKiBzdHJ1Y3Qgc3luYXB0aWNzX3JtaTRfZm5fZGVzYyAtIGNvbnRhaW5zIHRoZSBmdW5jdGlvbiBkZXNjcmlwdG9yIGluZm9ybWF0aW9uCiAgKiBAcXVlcnlfYmFzZV9hZGRyOiBiYXNlIGFkZHJlc3MgZm9yIHF1ZXJ5CiAgKiBAY21kX2Jhc2VfYWRkcjogYmFzZSBhZGRyZXNzIGZvciBjb21tYW5kCiAgKiBAY3RybF9iYXNlX2FkZHI6IGJhc2UgYWRkcmVzcyBmb3IgY29udHJvbApAQCAtOTIsNyArOTIsNyBAQAogfTsKIAogLyoqCi0gKiBzdHJ1Y3Qgc3luYXB0aWNzX3JtaTRfZm4gLSBjb250YWlucyB0aGUgZnVudGlvbiBpbmZvcm1hdGlvbgorICogc3RydWN0IHN5bmFwdGljc19ybWk0X2ZuIC0gY29udGFpbnMgdGhlIGZ1bmN0aW9uIGluZm9ybWF0aW9uCiAgKiBAZm5fbnVtYmVyOiBmdW5jdGlvbiBudW1iZXIKICAqIEBudW1fb2ZfZGF0YV9zb3VyY2VzOiBudW1iZXIgb2YgZGF0YSBzb3VyY2VzCiAgKiBAbnVtX29mX2RhdGFfcG9pbnRzOiBudW1iZXIgb2YgZmluZ2VycyB0b3VjaGVkCkBAIC0xNTEsNyArMTUxLDcgQEAKICAqIEBpbnB1dF9kZXY6IHBvaW50ZXIgZm9yIGlucHV0IGRldmljZQogICogQGkyY19jbGllbnQ6IHBvaW50ZXIgZm9yIGkyYyBjbGllbnQKICAqIEBib2FyZDogY29uc3RhbnQgcG9pbnRlciBmb3IgdG91Y2ggcGxhdGZvcm0gZGF0YQotICogQGZuX2xpc3RfbXV0ZXg6IG11dGV4IGZvciBmdW50aW9uIGxpc3QKKyAqIEBmbl9saXN0X211dGV4OiBtdXRleCBmb3IgZnVuY3Rpb24gbGlzdAogICogQHJtaTRfcGFnZV9tdXRleDogbXV0ZXggZm9yIHJtaTQgcGFnZQogICogQGN1cnJlbnRfcGFnZTogdmFyaWFibGUgZm9yIGludGVnZXIKICAqIEBudW1iZXJfb2ZfaW50ZXJydXB0X3JlZ2lzdGVyOiBpbnRlcnJ1cHQgcmVnaXN0ZXJzIGNvdW50CkBAIC0yNzgsNyArMjc4LDcgQEAKIAl0eGJ1ZlswXQk9IGFkZHJlc3MgJiBNQVNLXzhCSVQ7CiAJdHhidWZbMV0JPSBkYXRhOwogCXJldHZhbAkJPSBpMmNfbWFzdGVyX3NlbmQocGRhdGEtPmkyY19jbGllbnQsIHR4YnVmLCAyKTsKLQkvKiBBZGQgaW4gcmV0cnkgb24gd3JpdGVzIG9ubHkgaW4gY2VydGlhbiBlcnJvciByZXR1cm4gdmFsdWVzICovCisJLyogQWRkIGluIHJldHJ5IG9uIHdyaXRlcyBvbmx5IGluIGNlcnRhaW4gZXJyb3IgcmV0dXJuIHZhbHVlcyAqLwogCWlmIChyZXR2YWwgIT0gMikgewogCQlkZXZfZXJyKCZpMmMtPmRldiwgIiVzOmZhaWxlZDolZFxuIiwgX19mdW5jX18sIHJldHZhbCk7CiAJCXJldHZhbCA9IC1FSU87CkBAIC01NjEsNyArNTYxLDcgQEAKIAl9CiAJLyoKIAkgKiAyRCBkYXRhIHNvdXJjZXMgaGF2ZSBvbmx5IDMgYml0cyBmb3IgdGhlIG51bWJlciBvZiBmaW5nZXJzCi0JICogc3VwcG9ydGVkIC0gc28gdGhlIGVuY29kaW5nIGlzIGEgYml0IHdpZXJkLgorCSAqIHN1cHBvcnRlZCAtIHNvIHRoZSBlbmNvZGluZyBpcyBhIGJpdCB3ZWlyZC4KIAkgKi8KIAlpZiAoKHF1ZXJpZXNbMV0gJiBNQVNLXzNCSVQpIDw9IDQpCiAJCS8qIGFkZCAxIHNpbmNlIHplcm8gYmFzZWQgKi8KQEAgLTEwMjcsNyArMTAyNyw3IEBACiAgKiBzeW5hcHRpY3Nfcm1pNF9yZW1vdmUoKSAtIFJlbW92ZXMgdGhlIGkyYy1jbGllbnQgdG91Y2hzY3JlZW4gZHJpdmVyCiAgKiBAY2xpZW50OiBpMmMgY2xpZW50IHN0cnVjdHVyZSBwb2ludGVyCiAgKgotICogVGhpcyBmdW50aW9uIHVzZXMgdG8gcmVtb3ZlIHRoZSBpMmMtY2xpZW50CisgKiBUaGlzIGZ1bmN0aW9uIHVzZXMgdG8gcmVtb3ZlIHRoZSBpMmMtY2xpZW50CiAgKiB0b3VjaHNjcmVlbiBkcml2ZXIgYW5kIHJldHVybnMgaW50ZWdlci4KICAqLwogc3RhdGljIGludCBfX2RldmV4aXQgc3luYXB0aWNzX3JtaTRfcmVtb3ZlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCkBAIC0xMDUzLDcgKzEwNTMsNyBAQAogICogc3luYXB0aWNzX3JtaTRfc3VzcGVuZCgpIC0gc3VzcGVuZCB0aGUgdG91Y2ggc2NyZWVuIGNvbnRyb2xsZXIKICAqIEBkZXY6IHBvaW50ZXIgdG8gZGV2aWNlIHN0cnVjdHVyZQogICoKLSAqIFRoaXMgZnVudGlvbiBpcyB1c2VkIHRvIHN1c3BlbmQgdGhlCisgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gc3VzcGVuZCB0aGUKICAqIHRvdWNoIHBhbmVsIGNvbnRyb2xsZXIgYW5kIHJldHVybnMgaW50ZWdlcgogICovCiBzdGF0aWMgaW50IHN5bmFwdGljc19ybWk0X3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQpAQCAtMTA4OSw3ICsxMDg5LDcgQEAKICAqIHN5bmFwdGljc19ybWk0X3Jlc3VtZSgpIC0gcmVzdW1lIHRoZSB0b3VjaCBzY3JlZW4gY29udHJvbGxlcgogICogQGRldjogcG9pbnRlciB0byBkZXZpY2Ugc3RydWN0dXJlCiAgKgotICogVGhpcyBmdW50aW9uIGlzIHVzZWQgdG8gcmVzdW1lIHRoZSB0b3VjaCBwYW5lbAorICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIHJlc3VtZSB0aGUgdG91Y2ggcGFuZWwKICAqIGNvbnRyb2xsZXIgYW5kIHJldHVybnMgaW50ZWdlci4KICAqLwogc3RhdGljIGludCBzeW5hcHRpY3Nfcm1pNF9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQpAQCAtMTE0OCw3ICsxMTQ4LDcgQEAKIC8qKgogICogc3luYXB0aWNzX3JtaTRfaW5pdCgpIC0gSW5pdGlhbGl6ZSB0aGUgdG91Y2hzY3JlZW4gZHJpdmVyCiAgKgotICogVGhpcyBmdW50aW9uIHVzZXMgdG8gaW5pdGlhbGl6ZXMgdGhlIHN5bmFwdGljcworICogVGhpcyBmdW5jdGlvbiB1c2VzIHRvIGluaXRpYWxpemVzIHRoZSBzeW5hcHRpY3MKICAqIHRvdWNoc2NyZWVuIGRyaXZlciBhbmQgcmV0dXJucyBpbnRlZ2VyLgogICovCiBzdGF0aWMgaW50IF9faW5pdCBzeW5hcHRpY3Nfcm1pNF9pbml0KHZvaWQpCkBAIC0xMTU4LDcgKzExNTgsNyBAQAogLyoqCiAgKiBzeW5hcHRpY3Nfcm1pNF9leGl0KCkgLSBEZS1pbml0aWFsaXplIHRoZSB0b3VjaHNjcmVlbiBkcml2ZXIKICAqCi0gKiBUaGlzIGZ1bnRpb24gdXNlcyB0byBkZS1pbml0aWFsaXplIHRoZSBzeW5hcHRpY3MKKyAqIFRoaXMgZnVuY3Rpb24gdXNlcyB0byBkZS1pbml0aWFsaXplIHRoZSBzeW5hcHRpY3MKICAqIHRvdWNoc2NyZWVuIGRyaXZlciBhbmQgcmV0dXJucyBub25lLgogICovCiBzdGF0aWMgdm9pZCBfX2V4aXQgc3luYXB0aWNzX3JtaTRfZXhpdCh2b2lkKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2NvcmUvX3Rpb21hcC5oIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2NvcmUvX3Rpb21hcC5oCmluZGV4IDFlMDI3M2UuLjdjYjU4NzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9jb3JlL190aW9tYXAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvY29yZS9fdGlvbWFwLmgKQEAgLTM2Niw3ICszNjYsNyBAQAogICogID09PT09PT09IHNtX2ludGVycnVwdF9kc3AgPT09PT09PT0KICAqICBQdXJwb3NlOgogICogICAgICBTZXQgaW50ZXJydXB0IHZhbHVlICYgc2VuZCBhbiBpbnRlcnJ1cHQgdG8gdGhlIERTUCBwcm9jZXNzb3IocykuCi0gKiAgICAgIFRoaXMgaXMgdHlwaWNhbHkgdXNlZCB3aGVuIG1haWxib3ggaW50ZXJydXB0IG1lY2hhbmlzbXMgYWxsb3cgZGF0YQorICogICAgICBUaGlzIGlzIHR5cGljYWxseSB1c2VkIHdoZW4gbWFpbGJveCBpbnRlcnJ1cHQgbWVjaGFuaXNtcyBhbGxvdyBkYXRhCiAgKiAgICAgIHRvIGJlIGFzc29jaWF0ZWQgd2l0aCBpbnRlcnJ1cHQgc3VjaCBhcyBmb3IgT01BUCdzIENNRC9EQVRBIHJlZ3MuCiAgKiAgUGFyYW1ldGVyczoKICAqICAgICAgZGV2X2NvbnRleHQ6ICAgIEhhbmRsZSB0byBCcmlkZ2UgZHJpdmVyIGRlZmluZWQgZGV2aWNlIGluZm8uCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvY29yZS9jaG5sX3NtLmMgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvY29yZS9jaG5sX3NtLmMKaW5kZXggODM4MTEzMC4uNmQ2NmU3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2NvcmUvY2hubF9zbS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9jb3JlL2Nobmxfc20uYwpAQCAtNTc4LDcgKzU3OCw3IEBACiAJCX0gZWxzZSBpZiAoc3RhdF9zeW5jID09IC1FUEVSTSkgewogCQkJLyogVGhpcyBjYW4gb2NjdXIgd2hlbiB0aGUgdXNlciBtb2RlIHRocmVhZCBpcwogCQkJICogYWJvcnRlZCAoXkMpLCBvciB3aGVuIF9WV0lOMzJfV2FpdFNpbmdsZU9iamVjdCgpCi0JCQkgKiBmYWlscyBkdWUgdG8gdW5rb3duIGNhdXNlcy4gKi8KKwkJCSAqIGZhaWxzIGR1ZSB0byB1bmtub3duIGNhdXNlcy4gKi8KIAkJCS8qIEV2ZW4gdGhvdWdoIFdhaXQgZmFpbGVkLCB0aGVyZSBtYXkgYmUgc29tZXRoaW5nIGluCiAJCQkgKiB0aGUgUTogKi8KIAkJCWlmIChsaXN0X2VtcHR5KCZwY2hubC0+aW9fY29tcGxldGlvbnMpKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvZHlubG9hZC9jbG9hZC5jIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2R5bmxvYWQvY2xvYWQuYwppbmRleCAzOTAwNDA5Li41Y2VjZDIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvZHlubG9hZC9jbG9hZC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9keW5sb2FkL2Nsb2FkLmMKQEAgLTcxOCw3ICs3MTgsNyBAQAogCSAqIGFzIGEgdGVtcG9yYXJ5IGZvciAuZGxsdmlldyByZWNvcmQgY29uc3RydWN0aW9uLgogCSAqIEFsbG9jYXRlIHN0b3JhZ2UgZm9yIHRoZSB3aG9sZSB0YWJsZS4gIEFkZCAxIHRvIHRoZSBzZWN0aW9uIGNvdW50CiAJICogaW4gY2FzZSBhIHRyYW1wb2xpbmUgc2VjdGlvbiBpcyBhdXRvLWdlbmVyYXRlZCBhcyB3ZWxsIGFzIHRoZQotCSAqIHNpemUgb2YgdGhlIHRyYW1wb2xpbmUgc2VjdGlvbiBuYW1lIHNvIERMTFZpZXcgZG9lbnMndCBnZXQgbG9zdC4KKwkgKiBzaXplIG9mIHRoZSB0cmFtcG9saW5lIHNlY3Rpb24gbmFtZSBzbyBETExWaWV3IGRvZXMndCBnZXQgbG9zdC4KIAkgKi8KIAogCXNpeiA9IHN5bV9jb3VudCAqIHNpemVvZihzdHJ1Y3QgbG9jYWxfc3ltYm9sKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9ody9od19tbXUuYyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9ody9od19tbXUuYwppbmRleCAwMTRmNWQ1Li5jMjE0ZGY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaHcvaHdfbW11LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2h3L2h3X21tdS5jCkBAIC01OSw3ICs1OSw3IEBACiAgKiBSRVRVUk5TOgogICoKICAqICAgICAgIFR5cGUJCTogaHdfc3RhdHVzCi0gKiAgICAgICBEZXNjcmlwdGlvbiAgICAgOiAwCQkgLS0gTm8gZXJyb3JzIG9jY3VyZWQKKyAqICAgICAgIERlc2NyaXB0aW9uICAgICA6IDAJCSAtLSBObyBlcnJvcnMgb2NjdXJyZWQKICAqCQkJIFJFVF9CQURfTlVMTF9QQVJBTSAgICAgLS0gQSBQb2ludGVyCiAgKgkJCQkJCVBhcmFtYXRlciB3YXMgc2V0IHRvIE5VTEwKICAqCkBAIC0xMDIsNyArMTAyLDcgQEAKICAqIFJFVFVSTlM6CiAgKgogICogICAgICAgVHlwZQkgICAgCTogaHdfc3RhdHVzCi0gKiAgICAgICBEZXNjcmlwdGlvbiAgICAgOiAwCQkgLS0gTm8gZXJyb3JzIG9jY3VyZWQKKyAqICAgICAgIERlc2NyaXB0aW9uICAgICA6IDAJCSAtLSBObyBlcnJvcnMgb2NjdXJyZWQKICAqCQkJIFJFVF9CQURfTlVMTF9QQVJBTSAgICAgLS0gQSBQb2ludGVyIFBhcmFtYXRlcgogICoJCQkJCQkgICB3YXMgc2V0IHRvIE5VTEwKICAqCQkJIFJFVF9QQVJBTV9PVVRfT0ZfUkFOR0UgLS0gSW5wdXQgUGFyYW1ldGVyIG91dApAQCAtMTQ3LDcgKzE0Nyw3IEBACiAgKiBSRVRVUk5TOgogICoKICAqICAgICAgIFR5cGUJICAgIAk6IGh3X3N0YXR1cwotICogICAgICAgRGVzY3JpcHRpb24gICAgIDogMAkJIC0tIE5vIGVycm9ycyBvY2N1cmVkCisgKiAgICAgICBEZXNjcmlwdGlvbiAgICAgOiAwCQkgLS0gTm8gZXJyb3JzIG9jY3VycmVkCiAgKgkJCSBSRVRfQkFEX05VTExfUEFSQU0gICAgIC0tIEEgUG9pbnRlciBQYXJhbWF0ZXIKICAqCQkJCQkJCXdhcyBzZXQgdG8gTlVMTAogICoJCQkgUkVUX1BBUkFNX09VVF9PRl9SQU5HRSAtLSBJbnB1dCBQYXJhbWV0ZXIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9fY2hubF9zbS5oIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL19jaG5sX3NtLmgKaW5kZXggZDYwZTI1Mi4uNmU3YWI0ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL19jaG5sX3NtLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL19jaG5sX3NtLmgKQEAgLTE0NCw3ICsxNDQsNyBAQAogCXM4IGNobmxfbW9kZTsJCS8qIENobmwgbW9kZSBhbmQgYXR0cmlidXRlcyAqLwogCS8qIENobmwgSS9PIGNvbXBsZXRpb24gZXZlbnQgKHVzZXIgbW9kZSkgKi8KIAl2b2lkICp1c2VyX2V2ZW50OwotCS8qIEFic3RyYWN0IHN5bmNyb25pemF0aW9uIG9iamVjdCAqLworCS8qIEFic3RyYWN0IHN5bmNocm9uaXphdGlvbiBvYmplY3QgKi8KIAlzdHJ1Y3Qgc3luY19vYmplY3QgKnN5bmNfZXZlbnQ7CiAJdTMyIHByb2Nlc3M7CQkvKiBQcm9jZXNzIHdoaWNoIGNyZWF0ZWQgdGhpcyBjaGFubmVsICovCiAJdTMyIGNiX2FyZzsJCS8qIEFyZ3VtZW50IHRvIHVzZSB3aXRoIGNhbGxiYWNrICovCkBAIC0xNTYsNyArMTU2LDcgQEAKIAlzdHJ1Y3QgbGlzdF9oZWFkIGlvX2NvbXBsZXRpb25zOwogCXN0cnVjdCBsaXN0X2hlYWQgZnJlZV9wYWNrZXRzX2xpc3Q7CS8qIExpc3Qgb2YgZnJlZSBJcnBzICovCiAJc3RydWN0IG50Znlfb2JqZWN0ICpudGZ5X29iajsKLQl1MzIgYnl0ZXNfbW92ZWQ7CS8qIFRvdGFsIG51bWJlciBvZiBieXRlcyB0cmFuc2ZlcmVkICovCisJdTMyIGJ5dGVzX21vdmVkOwkvKiBUb3RhbCBudW1iZXIgb2YgYnl0ZXMgdHJhbnNmZXJyZWQgKi8KIAogCS8qIEZvciBEU1AtRE1BICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9jbGsuaCBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9jbGsuaAppbmRleCBiMjM5NTAzLi42ODUzNDFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvY2xrLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2Nsay5oCkBAIC01NSw3ICs1NSw3IEBACiAgKiAgICAgIEluaXRpYWxpemVzIHByaXZhdGUgc3RhdGUgb2YgQ0xLIG1vZHVsZS4KICAqICBQYXJhbWV0ZXJzOgogICogIFJldHVybnM6Ci0gKiAgICAgIFRSVUUgaWYgaW5pdGlhbGl6ZWQ7IEZBTFNFIGlmIGVycm9yIG9jY3VyZWQuCisgKiAgICAgIFRSVUUgaWYgaW5pdGlhbGl6ZWQ7IEZBTFNFIGlmIGVycm9yIG9jY3VycmVkLgogICogIFJlcXVpcmVzOgogICogIEVuc3VyZXM6CiAgKiAgICAgIENMSyBpbml0aWFsaXplZC4KQEAgLTcxLDcgKzcxLDcgQEAKICAqICBQYXJhbWV0ZXJzOgogICogIFJldHVybnM6CiAgKiAgICAgIDA6CVN1Y2Nlc3MuCi0gKgktRVBFUk06CUVycm9yIG9jY3VyZWQgd2hpbGUgZW5hYmxpbmcgdGhlIGNsb2NrLgorICoJLUVQRVJNOglFcnJvciBvY2N1cnJlZCB3aGlsZSBlbmFibGluZyB0aGUgY2xvY2suCiAgKiAgUmVxdWlyZXM6CiAgKiAgRW5zdXJlczoKICAqLwpAQCAtODYsNyArODYsNyBAQAogICogIFBhcmFtZXRlcnM6CiAgKiAgUmV0dXJuczoKICAqICAgICAgMDogICAgICAgIFN1Y2Nlc3MuCi0gKiAgICAgIC1FUEVSTTogICAgICBFcnJvciBvY2N1cmVkIHdoaWxlIGRpc2FibGluZyB0aGUgY2xvY2suCisgKiAgICAgIC1FUEVSTTogICAgICBFcnJvciBvY2N1cnJlZCB3aGlsZSBkaXNhYmxpbmcgdGhlIGNsb2NrLgogICogIFJlcXVpcmVzOgogICogIEVuc3VyZXM6CiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9jbW0uaCBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9jbW0uaAppbmRleCAyN2EyMWI1Li5hZmYyMjA1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvY21tLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2NtbS5oCkBAIC0xOTAsNyArMTkwLDcgQEAKICAqICAgICAgSW5pdGlhbGl6ZXMgcHJpdmF0ZSBzdGF0ZSBvZiBDTU0gbW9kdWxlLgogICogIFBhcmFtZXRlcnM6CiAgKiAgUmV0dXJuczoKLSAqICAgICAgVFJVRSBpZiBpbml0aWFsaXplZDsgRkFMU0UgaWYgZXJyb3Igb2NjdXJlZC4KKyAqICAgICAgVFJVRSBpZiBpbml0aWFsaXplZDsgRkFMU0UgaWYgZXJyb3Igb2NjdXJyZWQuCiAgKiAgUmVxdWlyZXM6CiAgKiAgRW5zdXJlczoKICAqICAgICAgQ01NIGluaXRpYWxpemVkLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2NvZC5oIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2NvZC5oCmluZGV4IDUzYmQ0YmIuLmNiNjg0YzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9jb2QuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvY29kLmgKQEAgLTI0OSw3ICsyNDksNyBAQAogICogIFBhcmFtZXRlcnM6CiAgKiAgICAgIE5vbmUuCiAgKiAgUmV0dXJuczoKLSAqICAgICAgVFJVRSBpZiBpbml0aWFsaXplZDsgRkFMU0UgaWYgZXJyb3Igb2NjdXJlZC4KKyAqICAgICAgVFJVRSBpZiBpbml0aWFsaXplZDsgRkFMU0UgaWYgZXJyb3Igb2NjdXJyZWQuCiAgKiAgUmVxdWlyZXM6CiAgKiAgRW5zdXJlczoKICAqICAgICAgQSByZXF1aXJlbWVudCBmb3IgZWFjaCBvZiB0aGUgb3RoZXIgcHVibGljIENPRCBmdW5jdGlvbnMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvZGV2LmggYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvZGV2LmgKaW5kZXggZjQxZTQ3OC4uZjkyYjRiZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2Rldi5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9kZXYuaApAQCAtNDk3LDcgKzQ5Nyw3IEBACiAgKiAgICAgIEluaXRpYWxpemUgREVWJ3MgcHJpdmF0ZSBzdGF0ZSwga2VlcGluZyBhIHJlZmVyZW5jZSBjb3VudCBvbiBlYWNoIGNhbGwuCiAgKiAgUGFyYW1ldGVyczoKICAqICBSZXR1cm5zOgotICogICAgICBUUlVFIGlmIGluaXRpYWxpemVkOyBGQUxTRSBpZiBlcnJvciBvY2N1cmVkLgorICogICAgICBUUlVFIGlmIGluaXRpYWxpemVkOyBGQUxTRSBpZiBlcnJvciBvY2N1cnJlZC4KICAqICBSZXF1aXJlczoKICAqICBFbnN1cmVzOgogICogICAgICBUUlVFOiBBIHJlcXVpcmVtZW50IGZvciB0aGUgb3RoZXIgcHVibGljIERFViBmdW5jdGlvbnMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvZHJ2LmggYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvZHJ2LmgKaW5kZXggMjVlZjFhMi4uOWNkYmQ5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2Rydi5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9kcnYuaApAQCAtMTU0LDcgKzE1NCw3IEBACiAgKiAgUGFyYW1ldGVyczoKICAqICAgICAgZHJ2X29iajogICAgICAgIExvY2F0aW9uIHRvIHN0b3JlIGNyZWF0ZWQgRFJWIE9iamVjdCBoYW5kbGUuCiAgKiAgUmV0dXJuczoKLSAqICAgICAgMDogICAgICAgIFN1Y2VzcworICogICAgICAwOiAgICAgICAgU3VjY2VzcwogICogICAgICAtRU5PTUVNOiAgICBGYWlsZWQgaW4gTWVtb3J5IGFsbG9jYXRpb24KICAqICAgICAgLUVQRVJNOiAgICAgIEdlbmVyYWwgRmFpbHVyZQogICogIFJlcXVpcmVzOgpAQCAtMTcwLDcgKzE3MCw3IEBACiAgKiAgICAgIFRoZXJlIGlzIG9uZSBEcml2ZXIgT2JqZWN0IGZvciB0aGUgRHJpdmVyIHJlcHJlc2VudGluZwogICogICAgICB0aGUgZHJpdmVyIGl0c2VsZi4gSXQgY29udGFpbnMgdGhlIGxpc3Qgb2YgZGV2aWNlCiAgKiAgICAgIE9iamVjdHMgYW5kIHRoZSBsaXN0IG9mIERldmljZSBFeHRlbnNpb25zIGluIHRoZSBzeXN0ZW0uCi0gKiAgICAgIEFsc28gaXQgY2FuIGhvbGQgb3RoZXIgbmVjY2Vzc2FyeQorICogICAgICBBbHNvIGl0IGNhbiBob2xkIG90aGVyIG5lY2Vzc2FyeQogICogICAgICBpbmZvcm1hdGlvbiBpbiBpdHMgc3RvcmFnZSBhcmVhLgogICovCiBleHRlcm4gaW50IGRydl9jcmVhdGUoc3RydWN0IGRydl9vYmplY3QgKipkcnZfb2JqKTsKQEAgLTE4MCw3ICsxODAsNyBAQAogICogIFB1cnBvc2U6CiAgKiAgICAgIGRlc3Ryb3lzIHRoZSBEZXYgT2JqZWN0IGxpc3QsIERydkV4dCBsaXN0CiAgKiAgICAgIGFuZCBkZXN0cm95IHRoZSBEUlYgb2JqZWN0Ci0gKiAgICAgIENhbGxlZCB1cG9uIGRyaXZlciB1bkxvYWRpbmcub3IgdW5zdWNjZXNmdWwgbG9hZGluZyBvZiB0aGUgZHJpdmVyLgorICogICAgICBDYWxsZWQgdXBvbiBkcml2ZXIgdW5Mb2FkaW5nLm9yIHVuc3VjY2Vzc2Z1bCBsb2FkaW5nIG9mIHRoZSBkcml2ZXIuCiAgKiAgUGFyYW1ldGVyczoKICAqICAgICAgZHJpdmVyX29iajogICAgIEhhbmRsZSB0byBEcml2ZXIgb2JqZWN0IC4KICAqICBSZXR1cm5zOgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2RzcGRlZnMuaCBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9kc3BkZWZzLmgKaW5kZXggYzJiYTI2Yy4uZWQzMmJmMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL2RzcGRlZnMuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvZHNwZGVmcy5oCkBAIC01Miw3ICs1Miw3IEBACiAgKiAgICAgIGRldl9jdHh0OiAgICBIYW5kbGUgdG8gQnJpZGdlIGRyaXZlciBkZWZpbmVkIGRldmljZSBjb250ZXh0LgogICogIFJldHVybnM6CiAgKiAgICAgIDA6ICAgICAgICBTdWNjZXNzLgotICogICAgICAtRVRJTUVET1VUOiAgVGltZW91dCBvY2N1cmVkIHdhaXRpbmcgZm9yIGEgcmVzcG9uc2UgZnJvbSBoYXJkd2FyZS4KKyAqICAgICAgLUVUSU1FRE9VVDogIFRpbWVvdXQgb2NjdXJyZWQgd2FpdGluZyBmb3IgYSByZXNwb25zZSBmcm9tIGhhcmR3YXJlLgogICogICAgICAtRVBFUk06ICAgICAgT3RoZXIsIHVuc3BlY2lmaWVkIGVycm9yLgogICogIFJlcXVpcmVzOgogICogICAgICBkZXZfY3R4dCAhPSBOVUxMCkBAIC05MSw3ICs5MSw3IEBACiAgKiAgICAgIGRzcF9hZGRyOiAgICAgICBEU1AgYWRkcmVzcyBhdCB3aGljaCB0byBzdGFydCBleGVjdXRpb24uCiAgKiAgUmV0dXJuczoKICAqICAgICAgMDogICAgICAgIFN1Y2Nlc3MuCi0gKiAgICAgIC1FVElNRURPVVQ6ICBUaW1lb3V0IG9jY3VyZWQgd2FpdGluZyBmb3IgYSByZXNwb25zZSBmcm9tIGhhcmR3YXJlLgorICogICAgICAtRVRJTUVET1VUOiAgVGltZW91dCBvY2N1cnJlZCB3YWl0aW5nIGZvciBhIHJlc3BvbnNlIGZyb20gaGFyZHdhcmUuCiAgKiAgICAgIC1FUEVSTTogICAgICBPdGhlciwgdW5zcGVjaWZpZWQgZXJyb3IuCiAgKiAgUmVxdWlyZXM6CiAgKiAgICAgIGRldl9jdHh0ICE9IE5VTEwKQEAgLTE0Miw3ICsxNDIsNyBAQAogICogICAgICBtZW1fdHlwZTogICAgICAgTWVtb3J5IHNwYWNlIG9uIERTUCB0byB3aGljaCB0byB0cmFuc2Zlci4KICAqICBSZXR1cm5zOgogICogICAgICAwOiAgICAgICAgU3VjY2Vzcy4KLSAqICAgICAgLUVUSU1FRE9VVDogIFRpbWVvdXQgb2NjdXJlZCB3YWl0aW5nIGZvciBhIHJlc3BvbnNlIGZyb20gaGFyZHdhcmUuCisgKiAgICAgIC1FVElNRURPVVQ6ICBUaW1lb3V0IG9jY3VycmVkIHdhaXRpbmcgZm9yIGEgcmVzcG9uc2UgZnJvbSBoYXJkd2FyZS4KICAqICAgICAgLUVQRVJNOiAgICAgIE90aGVyLCB1bnNwZWNpZmllZCBlcnJvci4KICAqICBSZXF1aXJlczoKICAqICAgICAgZGV2X2N0eHQgIT0gTlVMTDsKQEAgLTIwNSw3ICsyMDUsNyBAQAogICogICAgICBkZXZfY3R4dDogICAgSGFuZGxlIHRvIEJyaWRnZSBkcml2ZXIgZGVmaW5lZCBkZXZpY2UgY29udGV4dC4KICAqICBSZXR1cm5zOgogICogICAgICAwOiAgICAgICAgU3VjY2Vzcy4KLSAqICAgICAgLUVUSU1FRE9VVDogIFRpbWVvdXQgb2NjdXJlZCB3YWl0aW5nIGZvciBhIHJlc3BvbnNlIGZyb20gaGFyZHdhcmUuCisgKiAgICAgIC1FVElNRURPVVQ6ICBUaW1lb3V0IG9jY3VycmVkIHdhaXRpbmcgZm9yIGEgcmVzcG9uc2UgZnJvbSBoYXJkd2FyZS4KICAqICAgICAgLUVQRVJNOiAgICAgIE90aGVyLCB1bnNwZWNpZmllZCBlcnJvci4KICAqICBSZXF1aXJlczoKICAqICAgICAgZGV2X2N0eHQgIT0gTlVMTApAQCAtMjQ4LDcgKzI0OCw3IEBACiAgKiAgICAgIG1lbV90eXBlOiAgICAgICBNZW1vcnkgc3BhY2Ugb24gRFNQIGZyb20gd2hpY2ggdG8gdHJhbnNmZXIuCiAgKiAgUmV0dXJuczoKICAqICAgICAgMDogICAgICAgIFN1Y2Nlc3MuCi0gKiAgICAgIC1FVElNRURPVVQ6ICBUaW1lb3V0IG9jY3VyZWQgd2FpdGluZyBmb3IgYSByZXNwb25zZSBmcm9tIGhhcmR3YXJlLgorICogICAgICAtRVRJTUVET1VUOiAgVGltZW91dCBvY2N1cnJlZCB3YWl0aW5nIGZvciBhIHJlc3BvbnNlIGZyb20gaGFyZHdhcmUuCiAgKiAgICAgIC1FUEVSTTogICAgICBPdGhlciwgdW5zcGVjaWZpZWQgZXJyb3IuCiAgKiAgUmVxdWlyZXM6CiAgKiAgICAgIGRldl9jdHh0ICE9IE5VTEw7CkBAIC0yNzQsNyArMjc0LDcgQEAKICAqICAgICAgbWVtX3R5cGU6ICAgICAgIE1lbW9yeSBzcGFjZSBvbiBEU1AgdG8gd2hpY2ggdG8gdHJhbnNmZXIuCiAgKiAgUmV0dXJuczoKICAqICAgICAgMDogICAgICAgIFN1Y2Nlc3MuCi0gKiAgICAgIC1FVElNRURPVVQ6ICBUaW1lb3V0IG9jY3VyZWQgd2FpdGluZyBmb3IgYSByZXNwb25zZSBmcm9tIGhhcmR3YXJlLgorICogICAgICAtRVRJTUVET1VUOiAgVGltZW91dCBvY2N1cnJlZCB3YWl0aW5nIGZvciBhIHJlc3BvbnNlIGZyb20gaGFyZHdhcmUuCiAgKiAgICAgIC1FUEVSTTogICAgICBPdGhlciwgdW5zcGVjaWZpZWQgZXJyb3IuCiAgKiAgUmVxdWlyZXM6CiAgKiAgICAgIGRldl9jdHh0ICE9IE5VTEw7CkBAIC02MDEsNyArNjAxLDcgQEAKICAqICBSZXR1cm5zOgogICogICAgICAwOiAgICAgICAgICAgIFN1Y2Nlc3M7CiAgKiAgICAgIC1FRkFVTFQ6ICAgICAgICBJbnZhbGlkIGNobmxfb2JqLgotICogICAgICAtRVRJTUVET1VUOiBUaW1lb3V0IG9jY3VyZWQgYmVmb3JlIGNoYW5uZWwgY291bGQgYmUgaWRsZWQuCisgKiAgICAgIC1FVElNRURPVVQ6IFRpbWVvdXQgb2NjdXJyZWQgYmVmb3JlIGNoYW5uZWwgY291bGQgYmUgaWRsZWQuCiAgKiAgUmVxdWlyZXM6CiAgKiAgRW5zdXJlczoKICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL21nci5oIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL21nci5oCmluZGV4IGU1MDZjNGQuLjQ3YjAzMTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9tZ3IuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvbWdyLmgKQEAgLTE3Niw3ICsxNzYsNyBAQAogICogICAgICBtZ3JfaGFuZGxlOiAgICAgSGFuZGxlIHRvIHRoZSBNYW5hZ2VyIE9iamVjdAogICogICAgICBkY2RfaGFuZGxlOiAgICAgUHRyIHRvIHJlY2VpdmUgdGhlIERDRCBIYW5kbGUuCiAgKiAgUmV0dXJuczoKLSAqICAgICAgMDogICAgICAgIFN1Y2VzcworICogICAgICAwOiAgICAgICAgU3VjY2VzcwogICogICAgICAtRVBFUk06ICAgICAgRmFpbHVyZSB0byBnZXQgdGhlIEhhbmRsZQogICogIFJlcXVpcmVzOgogICogICAgICBNR1IgaXMgaW5pdGlhbGl6ZWQuCkBAIC0xOTUsNyArMTk1LDcgQEAKICAqICAgICAgY2FsbC4gSW5pdGlhbGl6ZXMgdGhlIERDRC4KICAqICBQYXJhbWV0ZXJzOgogICogIFJldHVybnM6Ci0gKiAgICAgIFRSVUUgaWYgaW5pdGlhbGl6ZWQ7IEZBTFNFIGlmIGVycm9yIG9jY3VyZWQuCisgKiAgICAgIFRSVUUgaWYgaW5pdGlhbGl6ZWQ7IEZBTFNFIGlmIGVycm9yIG9jY3VycmVkLgogICogIFJlcXVpcmVzOgogICogIEVuc3VyZXM6CiAgKiAgICAgIFRSVUU6IEEgcmVxdWlyZW1lbnQgZm9yIHRoZSBvdGhlciBwdWJsaWMgTUdSIGZ1bmN0aW9ucy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9ub2RlLmggYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2Uvbm9kZS5oCmluZGV4IDUzZGEwZWYuLjE2MzcxZDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9ub2RlLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL25vZGUuaApAQCAtNDQsNyArNDQsNyBAQAogICogICAgICAtRVNQSVBFOiAgICAgICAgaUFsZyBmdW5jdGlvbnMgbm90IGZvdW5kIGZvciBhIERBSVMgbm9kZS4KICAqICAgICAgLUVET006ICAgICAgICAgYXR0cl9pbiAhPSBOVUxMIGFuZCBhdHRyX2luLT5wcmlvIG91dCBvZgogICogICAgICAgICAgICAgICAgICAgICAgICAgIHJhbmdlLgotICogICAgICAtRVBFUk06ICAgICAgICAgIEEgZmFpbHVyZSBvY2N1cmVkLCB1bmFibGUgdG8gYWxsb2NhdGUgbm9kZS4KKyAqICAgICAgLUVQRVJNOiAgICAgICAgICBBIGZhaWx1cmUgb2NjdXJyZWQsIHVuYWJsZSB0byBhbGxvY2F0ZSBub2RlLgogICogICAgICAtRUJBRFI6ICAgIFByb2NjZXNzb3IgaXMgbm90IGluIHRoZSBydW5uaW5nIHN0YXRlLgogICogIFJlcXVpcmVzOgogICogICAgICBub2RlX2luaXQodm9pZCkgY2FsbGVkLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL3Byb2MuaCBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9wcm9jLmgKaW5kZXggNWUwOWZkMS4uZjAwZGZmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL3Byb2MuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvcHJvYy5oCkBAIC04OSw3ICs4OSw3IEBACiAgKiAgUmV0dXJuczoKICAqICAgICAgMCAgICAgOiAgICAgICBTVUNDRVNTCiAgKiAgICAgIC1FRkFVTFQgOiAgICAgICBJbnZhbGlkIHByb2Nlc3NvciBoYW5kbGUuCi0gKiAgICAgIC1FVElNRTogICAgICAgQSBUaW1lb3V0IE9jY3VyZWQgYmVmb3JlIHRoZSBDb250cm9sIGluZm9ybWF0aW9uCisgKiAgICAgIC1FVElNRTogICAgICAgQSBUaW1lb3V0IE9jY3VycmVkIGJlZm9yZSB0aGUgQ29udHJvbCBpbmZvcm1hdGlvbgogICoJCQkgIGNvdWxkIGJlIHNlbnQuCiAgKiAgICAgIC1FUEVSTSAgIDogICAgICAgR2VuZXJhbCBGYWlsdXJlLgogICogIFJlcXVpcmVzOgpAQCAtMTY5LDcgKzE2OSw3IEBACiAgKiAgICAgIDAgICAgIDogICAgICAgU3VjY2Vzcy4KICAqICAgICAgLUVGQVVMVCA6ICAgICAgIEludmFsaWQgcHJvY2Vzc29yIGhhbmRsZS4KICAqICAgICAgLUVCQURSOiAgICBUaGUgcHJvY2Vzc29yIGlzIG5vdCBpbiB0aGUgUFJPQ19SVU5OSU5HIHN0YXRlLgotICogICAgICAtRVRJTUU6ICAgICAgIEEgdGltZW91dCBvY2N1cmVkIGJlZm9yZSB0aGUgRFNQIHJlc3BvbmRlZCB0byB0aGUKKyAqICAgICAgLUVUSU1FOiAgICAgICBBIHRpbWVvdXQgb2NjdXJyZWQgYmVmb3JlIHRoZSBEU1AgcmVzcG9uZGVkIHRvIHRoZQogICoJCQkgIHF1ZXJyeS4KICAqICAgICAgLUVQRVJNICAgOiAgICAgICBVbmFibGUgdG8gZ2V0IFJlc291cmNlIEluZm9ybWF0aW9uCiAgKiAgUmVxdWlyZXM6CkBAIC0yMjksNyArMjI5LDcgQEAKICAqICAgICAgY2FsbC4KICAqICBQYXJhbWV0ZXJzOgogICogIFJldHVybnM6Ci0gKiAgICAgIFRSVUUgaWYgaW5pdGlhbGl6ZWQ7IEZBTFNFIGlmIGVycm9yIG9jY3VyZWQuCisgKiAgICAgIFRSVUUgaWYgaW5pdGlhbGl6ZWQ7IEZBTFNFIGlmIGVycm9yIG9jY3VycmVkLgogICogIFJlcXVpcmVzOgogICogIEVuc3VyZXM6CiAgKiAgICAgIFRSVUU6IEEgcmVxdWlyZW1lbnQgZm9yIHRoZSBvdGhlciBwdWJsaWMgUFJPQyBmdW5jdGlvbnMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvcHdyLmggYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvcHdyLmgKaW5kZXggNWUzYWIyMS4uMGZiMDY2NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2luY2x1ZGUvZHNwYnJpZGdlL3B3ci5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9wd3IuaApAQCAtNDYsNyArNDYsNyBAQAogICogICAgICAwOiAgICAgICAgICAgIFN1Y2Nlc3MuCiAgKiAgICAgIDA6IFN1Y2Nlc3MsIGJ1dCB0aGUgRFNQIHdhcyBhbHJlYWR5IGFzbGVlcC4KICAqICAgICAgLUVJTlZBTDogICAgVGhlIHNwZWNpZmllZCBzbGVlcF9jb2RlIGlzIG5vdCBzdXBwb3J0ZWQuCi0gKiAgICAgIC1FVElNRTogICAgICAgQSB0aW1lb3V0IG9jY3VyZWQgd2hpbGUgd2FpdGluZyBmb3IgRFNQIHNsZWVwCisgKiAgICAgIC1FVElNRTogICAgICAgQSB0aW1lb3V0IG9jY3VycmVkIHdoaWxlIHdhaXRpbmcgZm9yIERTUCBzbGVlcAogICogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbmZpcm1hdGlvbi4KICAqICAgICAgLUVQRVJNOiAgICAgICAgICBHZW5lcmFsIGZhaWx1cmUsIHVuYWJsZSB0byBzZW5kIHNsZWVwIGNvbW1hbmQgdG8KICAqICAgICAgICAgICAgICAgICAgICAgICAgICB0aGUgRFNQLgpAQCAtNjcsNyArNjcsNyBAQAogICogIFJldHVybnM6CiAgKiAgICAgIDA6ICAgICAgICAgICAgU3VjY2Vzcy4KICAqICAgICAgMDogIFN1Y2Nlc3MsIGJ1dCB0aGUgRFNQIHdhcyBhbHJlYWR5IGF3YWtlLgotICogICAgICAtRVRJTUU6ICAgICAgIEEgdGltZW91dCBvY2N1cmVkIHdoaWxlIHdhaXRpbmcgZm9yIHdha2UKKyAqICAgICAgLUVUSU1FOiAgICAgICBBIHRpbWVvdXQgb2NjdXJyZWQgd2hpbGUgd2FpdGluZyBmb3Igd2FrZQogICogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbmZpcm1hdGlvbi4KICAqICAgICAgLUVQRVJNOiAgICAgICAgICBHZW5lcmFsIGZhaWx1cmUsIHVuYWJsZSB0byBzZW5kIHdha2UgY29tbWFuZCB0bwogICogICAgICAgICAgICAgICAgICAgICAgICAgIHRoZSBEU1AuCkBAIC04NSw3ICs4NSw3IEBACiAgKiAgUmV0dXJuczoKICAqICAgICAgMDogICAgICAgICAgICBTdWNjZXNzLgogICogICAgICAwOiAgU3VjY2VzcywgYnV0IHRoZSBEU1Agd2FzIGFscmVhZHkgYXdha2UuCi0gKiAgICAgIC1FVElNRTogICAgICAgQSB0aW1lb3V0IG9jY3VyZWQgd2hpbGUgd2FpdGluZyBmb3Igd2FrZQorICogICAgICAtRVRJTUU6ICAgICAgIEEgdGltZW91dCBvY2N1cnJlZCB3aGlsZSB3YWl0aW5nIGZvciB3YWtlCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgY29uZmlybWF0aW9uLgogICogICAgICAtRVBFUk06ICAgICAgICAgIEdlbmVyYWwgZmFpbHVyZSwgdW5hYmxlIHRvIHNlbmQgd2FrZSBjb21tYW5kIHRvCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgdGhlIERTUC4KQEAgLTEwMyw3ICsxMDMsNyBAQAogICogIFJldHVybnM6CiAgKiAgICAgIDA6ICAgICAgICAgICAgU3VjY2Vzcy4KICAqICAgICAgMDogIFN1Y2Nlc3MsIGJ1dCB0aGUgRFNQIHdhcyBhbHJlYWR5IGF3YWtlLgotICogICAgICAtRVRJTUU6ICAgICAgIEEgdGltZW91dCBvY2N1cmVkIHdoaWxlIHdhaXRpbmcgZm9yIHdha2UKKyAqICAgICAgLUVUSU1FOiAgICAgICBBIHRpbWVvdXQgb2NjdXJyZWQgd2hpbGUgd2FpdGluZyBmb3Igd2FrZQogICogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbmZpcm1hdGlvbi4KICAqICAgICAgLUVQRVJNOiAgICAgICAgICBHZW5lcmFsIGZhaWx1cmUsIHVuYWJsZSB0byBzZW5kIHdha2UgY29tbWFuZCB0bwogICogICAgICAgICAgICAgICAgICAgICAgICAgIHRoZSBEU1AuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvcG1nci9kZXYuYyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9wbWdyL2Rldi5jCmluZGV4IDlhMzhkODYuLjUyMjgxMGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9wbWdyL2Rldi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9wbWdyL2Rldi5jCkBAIC03ODcsNyArNzg3LDcgQEAKIAogCS8qCiAJICogRklYTUU6IHRoaXMgY29kZSBuZWVkcyBzdHJ1Y3QgcHJvY19vYmplY3QgdG8gaGF2ZSBhIGxpc3RfaGVhZAotCSAqIGF0IHRoZSBiZWdpbmluZy4gSWYgbm90LCB0aGlzIGNhbiBnbyBob3JyaWJseSB3cm9uZy4KKwkgKiBhdCB0aGUgYmVnaW5uaW5nLiBJZiBub3QsIHRoaXMgY2FuIGdvIGhvcnJpYmx5IHdyb25nLgogCSAqLwogCWxpc3RfZm9yX2VhY2goY3VyciwgJmRldl9vYmotPnByb2NfbGlzdCkKIAkJcHJvY19ub3RpZnlfY2xpZW50cygodm9pZCAqKWN1cnIsIHJldCk7CkBAIC04MTAsNyArODEwLDcgQEAKIAlpZiAoIWRldl9ub2RlX29iaikKIAkJc3RhdHVzID0gLUVGQVVMVDsKIAotCS8qIFJldHJpZXZlIHRoZSBkZXZpY2Ugb2JqZWN0IGhhbmRsZSBvcmlnaW5hbHkgc3RvcmVkIHdpdGgKKwkvKiBSZXRyaWV2ZSB0aGUgZGV2aWNlIG9iamVjdCBoYW5kbGUgb3JpZ2luYWxseSBzdG9yZWQgd2l0aAogCSAqIHRoZSBkZXZfbm9kZTogKi8KIAlpZiAoIXN0YXR1cykgewogCQkvKiBjaGVjayB0aGUgZGV2aWNlIHN0cmluZyBhbmQgdGhlbiBzdG9yZSBkZXYgb2JqZWN0ICovCkBAIC05ODYsNyArOTg2LDcgQEAKIAkvKiBBZGQgRGV2T2JqZWN0IHRvIHRhaWwuICovCiAJLyoKIAkgKiBGSVhNRTogdGhpcyBjb2RlIG5lZWRzIHN0cnVjdCBwcm9jX29iamVjdCB0byBoYXZlIGEgbGlzdF9oZWFkCi0JICogYXQgdGhlIGJlZ2luaW5nLiBJZiBub3QsIHRoaXMgY2FuIGdvIGhvcnJpYmx5IHdyb25nLgorCSAqIGF0IHRoZSBiZWdpbm5pbmcuIElmIG5vdCwgdGhpcyBjYW4gZ28gaG9ycmlibHkgd3JvbmcuCiAJICovCiAJbGlzdF9hZGRfdGFpbCgoc3RydWN0IGxpc3RfaGVhZCAqKXByb2Nfb2JqLCAmZGV2X29iai0+cHJvY19saXN0KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL3JtZ3IvZHJ2LmMgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2Uvcm1nci9kcnYuYwppbmRleCA4Yzg4NTgzLi5kYjgyMTVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2Uvcm1nci9kcnYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2Uvcm1nci9kcnYuYwpAQCAtNjA5LDcgKzYwOSw3IEBACiAJREJDX1JFUVVJUkUoZGV2X25vZGVfc3RyZyAhPSBOVUxMKTsKIAogCS8qCi0JICogIEFsbG9jYXRlIG1lbW9yeSB0byBob2xkIHRoZSBzdHJpbmcuIFRoaXMgd2lsbCBsaXZlIHVudGlsbAorCSAqICBBbGxvY2F0ZSBtZW1vcnkgdG8gaG9sZCB0aGUgc3RyaW5nLiBUaGlzIHdpbGwgbGl2ZSB1bnRpbAogCSAqICBpdCBpcyBmcmVlZCBpbiB0aGUgUmVsZWFzZSByZXNvdXJjZXMuIFVwZGF0ZSB0aGUgZHJpdmVyIG9iamVjdAogCSAqICBsaXN0LgogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL3JtZ3Ivbmxkci5jIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL3JtZ3Ivbmxkci5jCmluZGV4IGZiNWMyYmEuLjBlNzBjYmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9ybWdyL25sZHIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2Uvcm1nci9ubGRyLmMKQEAgLTU3LDkgKzU3LDkgQEAKICAqICAgdXV1dXV1dXV8ZnVlZWVlZWV8ZnVkZGRkZGR8ZnVjY2NjY2N8CiAgKiAgd2hlcmUKICAqICAgICAgdSA9IHVudXNlZAotICogICAgICBjY2NjY2MgPSBwcmVmZXJlZC9yZXF1aXJlZCBkeW5hbWljIG1lbSBzZWdpZCBmb3IgY3JlYXRlIHBoYXNlIGRhdGEvY29kZQotICogICAgICBkZGRkZGQgPSBwcmVmZXJlZC9yZXF1aXJlZCBkeW5hbWljIG1lbSBzZWdpZCBmb3IgZGVsZXRlIHBoYXNlIGRhdGEvY29kZQotICogICAgICBlZWVlZWUgPSBwcmVmZXJlZC9yZXEuIGR5bmFtaWMgbWVtIHNlZ2lkIGZvciBleGVjdXRlIHBoYXNlIGRhdGEvY29kZQorICogICAgICBjY2NjY2MgPSBwcmVmZXJyZWQvcmVxdWlyZWQgZHluYW1pYyBtZW0gc2VnaWQgZm9yIGNyZWF0ZSBwaGFzZSBkYXRhL2NvZGUKKyAqICAgICAgZGRkZGRkID0gcHJlZmVycmVkL3JlcXVpcmVkIGR5bmFtaWMgbWVtIHNlZ2lkIGZvciBkZWxldGUgcGhhc2UgZGF0YS9jb2RlCisgKiAgICAgIGVlZWVlZSA9IHByZWZlcnJlZC9yZXEuIGR5bmFtaWMgbWVtIHNlZ2lkIGZvciBleGVjdXRlIHBoYXNlIGRhdGEvY29kZQogICogICAgICBmID0gZmxhZyBpbmRpY2F0aW5nIGlmIG1lbW9yeSBpcyBwcmVmZXJyZWQgb3IgcmVxdWlyZWQ6CiAgKgkgIGYgPSAxIGlmIHJlcXVpcmVkLCBmID0gMCBpZiBwcmVmZXJyZWQuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL3JtZ3IvcHJvYy5jIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL3JtZ3IvcHJvYy5jCmluZGV4IGM0ZTVjNGUuLjI0MmRkMTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9ybWdyL3Byb2MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2Uvcm1nci9wcm9jLmMKQEAgLTE2NzAsNyArMTY3MCw3IEBACiAJaWYgKCFzdGF0dXMpIHsKIAkJZGV2X2RiZyhicmlkZ2UsICIlczogcHJvY2Vzc29yIGluIHN0YW5kYnkgbW9kZVxuIiwgX19mdW5jX18pOwogCQlwX3Byb2Nfb2JqZWN0LT5wcm9jX3N0YXRlID0gUFJPQ19TVE9QUEVEOwotCQkvKiBEZXN0b3J5IHRoZSBOb2RlIE1hbmFnZXIsIG1zZ19jdHJsIE1hbmFnZXIgKi8KKwkJLyogRGVzdHJveSB0aGUgTm9kZSBNYW5hZ2VyLCBtc2dfY3RybCBNYW5hZ2VyICovCiAJCWlmICghKGRldl9kZXN0cm95MihwX3Byb2Nfb2JqZWN0LT5kZXZfb2JqKSkpIHsKIAkJCS8qIERlc3Ryb3kgdGhlIG1zZ19jdHJsIGJ5IGNhbGxpbmcgbXNnX2RlbGV0ZSAqLwogCQkJZGV2X2dldF9tc2dfbWdyKHBfcHJvY19vYmplY3QtPmRldl9vYmosICZobXNnX21ncik7CkBAIC0xODI3LDcgKzE4MjcsNyBAQAogCiAJLyogVGhpcyBpcyBuZWVkZWQgb25seSB3aGVuIERldmljZSBpcyBsb2FkZWQgd2hlbiBpdCBpcwogCSAqIGFscmVhZHkgJ0FDVElWRScgKi8KLQkvKiBEZXN0b3J5IHRoZSBOb2RlIE1hbmFnZXIsIG1zZ19jdHJsIE1hbmFnZXIgKi8KKwkvKiBEZXN0cm95IHRoZSBOb2RlIE1hbmFnZXIsIG1zZ19jdHJsIE1hbmFnZXIgKi8KIAlpZiAoIWRldl9kZXN0cm95Mihwcm9jX29iai0+ZGV2X29iaikpIHsKIAkJLyogRGVzdHJveSB0aGUgbXNnX2N0cmwgYnkgY2FsbGluZyBtc2dfZGVsZXRlICovCiAJCWRldl9nZXRfbXNnX21ncihwcm9jX29iai0+ZGV2X29iaiwgJmhtc2dfbWdyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90bTYwMDAvdG02MDAwLXZpZGVvLmMgYi9kcml2ZXJzL3N0YWdpbmcvdG02MDAwL3RtNjAwMC12aWRlby5jCmluZGV4IGM4MGEzMTYuLjE3ZGI2NjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90bTYwMDAvdG02MDAwLXZpZGVvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RtNjAwMC90bTYwMDAtdmlkZW8uYwpAQCAtMTgyLDcgKzE4Miw3IEBACiAJaWYgKCFidWYpCiAJCXJldHVybjsKIAotCS8qIENsZWFucyB1cCBidWZmZXIgLSBVc2VmdWxsIGZvciB0ZXN0aW5nIGZvciBmcmFtZS9VUkIgbG9zcyAqLworCS8qIENsZWFucyB1cCBidWZmZXIgLSBVc2VmdWwgZm9yIHRlc3RpbmcgZm9yIGZyYW1lL1VSQiBsb3NzICovCiAJb3V0cCA9IHZpZGVvYnVmX3RvX3ZtYWxsb2MoJigqYnVmKS0+dmIpOwogCiAJcmV0dXJuOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3R0eS9jZDE4NjUuaCBiL2RyaXZlcnMvc3RhZ2luZy90dHkvY2QxODY1LmgKaW5kZXggOTk0MDk2Ni4uOGMyYWQ2NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3R0eS9jZDE4NjUuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdHR5L2NkMTg2NS5oCkBAIC05LDcgKzksNyBAQAogICogICAgICBQbGVhc2UgRE8gY29udGFjdCBpbzgtbGludXhAc3BlY2lhbGl4LmNvLnVrIGlmIHlvdSByZXF1aXJlCiAgKiAgICAgIHN1cHBvcnQuCiAgKgotICogICAgICBUaGlzIGRyaXZlciB3YXMgZGV2ZWxvcHBlZCBpbiB0aGUgQml0V2l6YXJkIGxpbnV4IGRldmljZQorICogICAgICBUaGlzIGRyaXZlciB3YXMgZGV2ZWxvcGVkIGluIHRoZSBCaXRXaXphcmQgbGludXggZGV2aWNlCiAgKiAgICAgIGRyaXZlciBzZXJ2aWNlLiBJZiB5b3UgcmVxdWlyZSBhIGxpbnV4IGRldmljZSBkcml2ZXIgZm9yIHlvdXIKICAqICAgICAgcHJvZHVjdCwgcGxlYXNlIGNvbnRhY3QgZGV2aWNlc0BCaXRXaXphcmQubmwgZm9yIGEgcXVvdGUuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3R0eS9lcGNhLmMgYi9kcml2ZXJzL3N0YWdpbmcvdHR5L2VwY2EuYwppbmRleCA3YWQzNjM4Li43ZjEzNjllIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdHR5L2VwY2EuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdHR5L2VwY2EuYwpAQCAtNyw3ICs3LDcgQEAKIAkqKiBUaGlzIGRyaXZlciBpcyBubyBsb25nZXIgc3VwcG9ydGVkIGJ5IERpZ2kgKioKIAogCU11Y2ggb2YgdGhpcyBkZXNpZ24gYW5kIGNvZGUgY2FtZSBmcm9tIGVwY2EuYyB3aGljaCB3YXMKLQljb3B5cmlnaHQgKEMpIDE5OTQsIDE5OTUgVHJveSBEZSBKb25naCwgYW5kIHN1YnNxdWVudGx5CisJY29weXJpZ2h0IChDKSAxOTk0LCAxOTk1IFRyb3kgRGUgSm9uZ2gsIGFuZCBzdWJzZXF1ZW50bHkKIAltb2RpZmllZCBieSBEYXZpZCBOdWdlbnQsIENocmlzdG9waCBMYW1ldGVyLCBNaWtlIE1jTGFnYW4uCiAKIAlUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpAQCAtNDcxLDcgKzQ3MSw3IEBACiAJbWVtb2ZmKGNoKTsKIAogCS8qCi0JICogVGhlIGNoYW5uZWwgaGFzIG9mZmljaWFseSBiZWVuIGNsb3NlZC4gVGhlIG5leHQgdGltZSBpdCBpcyBvcGVuZWQgaXQKKwkgKiBUaGUgY2hhbm5lbCBoYXMgb2ZmaWNpYWxseSBiZWVuIGNsb3NlZC4gVGhlIG5leHQgdGltZSBpdCBpcyBvcGVuZWQgaXQKIAkgKiB3aWxsIGhhdmUgdG8gcmVpbml0aWFsaXplZC4gU2V0IGEgZmxhZyB0byBpbmRpY2F0ZSB0aGlzLgogCSAqLwogCS8qIFByZXZlbnQgZnV0dXJlIERpZ2kgcHJvZ3JhbW1lZCBpbnRlcnJ1cHRzIGZyb20gY29taW5nIGFjdGl2ZSAqLwpAQCAtOTc1LDcgKzk3NSw3IEBACiAKIAkvKgogCSAqIE5vdGUgOiBJZiBsaWxvIHdhcyB1c2VkIHRvIGNvbmZpZ3VyZSB0aGUgZHJpdmVyIGFuZCB0aGUgaWdub3JlCi0JICogZXBjYWNvbmZpZyBvcHRpb24gd2FzIGNob29zZW4gKGRpZ2llcGNhPTIpIHRoZW4gbmJkZXZzIGFuZCBudW1fY2FyZHMKKwkgKiBlcGNhY29uZmlnIG9wdGlvbiB3YXMgY2hvc2VuIChkaWdpZXBjYT0yKSB0aGVuIG5iZGV2cyBhbmQgbnVtX2NhcmRzCiAJICogd2lsbCBlcXVhbCAwIGF0IHRoaXMgcG9pbnQuIFRoaXMgaXMgb2theTsgUENJIGNhcmRzIHdpbGwgc3RpbGwgYmUKIAkgKiBwaWNrZWQgdXAgaWYgZGV0ZWN0ZWQuCiAJICovCkBAIC0xMjMwLDE0ICsxMjMwLDE0IEBACiAJbWVtYWRkciA9IGJkLT5yZV9tYXBfbWVtYmFzZTsKIAogCS8qCi0JICogVGhlIGJlbG93IGFzc2lnbm1lbnQgd2lsbCBzZXQgYmMgdG8gcG9pbnQgYXQgdGhlIEJFR0lOSU5HIG9mIHRoZQorCSAqIFRoZSBiZWxvdyBhc3NpZ25tZW50IHdpbGwgc2V0IGJjIHRvIHBvaW50IGF0IHRoZSBCRUdJTk5JTkcgb2YgdGhlCiAJICogY2FyZHMgY2hhbm5lbCBzdHJ1Y3R1cmVzLiBGb3IgMSBjYXJkIHRoZXJlIHdpbGwgYmUgYmV0d2VlbiA4IGFuZCA2NAogCSAqIG9mIHRoZXNlIHN0cnVjdHVyZXMuCiAJICovCiAJYmMgPSBtZW1hZGRyICsgQ0hBTlNUUlVDVDsKIAogCS8qCi0JICogVGhlIGJlbG93IGFzc2lnbm1lbnQgd2lsbCBzZXQgZ2QgdG8gcG9pbnQgYXQgdGhlIEJFR0lOSU5HIG9mIGdsb2JhbAorCSAqIFRoZSBiZWxvdyBhc3NpZ25tZW50IHdpbGwgc2V0IGdkIHRvIHBvaW50IGF0IHRoZSBCRUdJTk5JTkcgb2YgZ2xvYmFsCiAJICogbWVtb3J5IGFkZHJlc3MgMHhjMDAuIFRoZSBmaXJzdCBkYXRhIGluIHRoYXQgZ2xvYmFsIG1lbW9yeSBhY3R1YWxseQogCSAqIHN0YXJ0cyBhdCBhZGRyZXNzIDB4YzFhLiBUaGUgY29tbWFuZCBpbiBwb2ludGVyIGJlZ2lucyBhdCAweGQxMC4KIAkgKi8KQEAgLTE0OTIsNyArMTQ5Miw3IEBACiAJCS8qCiAJCSAqIFRoZSB0d28gYXNzaWdubWVudHMgYmVsb3cgZ2V0IHRoZSBjdXJyZW50IG1vZGVtIHN0YXR1cwogCQkgKiAobXN0YXQpIGFuZCB0aGUgcHJldmlvdXMgbW9kZW0gc3RhdHVzIChsc3RhdCkuIFRoZXNlIGFyZQotCQkgKiB1c2VmdWwgYmVjdWFzZSBhbiBldmVudCBjb3VsZCBzaWduYWwgYSBjaGFuZ2UgaW4gbW9kZW0KKwkJICogdXNlZnVsIGJlY2F1c2UgYW4gZXZlbnQgY291bGQgc2lnbmFsIGEgY2hhbmdlIGluIG1vZGVtCiAJCSAqIHNpZ25hbHMgaXRzZWxmLgogCQkgKi8KIAkJbXN0YXQgPSByZWFkYihldmVudGJ1ZiArIDIpOwpAQCAtMTg5Nyw3ICsxODk3LDcgQEAKIAkJLyoKIAkJICogRXZlbiBpZiBoZWFkIGhhcyB3cmFwcGVkIGFyb3VuZCBvbmx5IHJlcG9ydCB0aGUgYW1vdW50IG9mCiAJCSAqIGRhdGEgdG8gYmUgZXF1YWwgdG8gdGhlIHNpemUgLSB0YWlsLiBSZW1lbWJlciBtZW1jcHkgY2FuJ3QKLQkJICogYXV0b21hdGljbHkgd3JhcCBhcm91bmQgdGhlIHJlY2VpdmUgYnVmZmVyLgorCQkgKiBhdXRvbWF0aWNhbGx5IHdyYXAgYXJvdW5kIHRoZSByZWNlaXZlIGJ1ZmZlci4KIAkJICovCiAJCWRhdGFUb1JlYWQgPSAod3JhcGdhcCA8IGJ5dGVzQXZhaWxhYmxlKSA/IHdyYXBnYXAKIAkJCQkJCQk6IGJ5dGVzQXZhaWxhYmxlOwpAQCAtMjU0Myw3ICsyNTQzLDcgQEAKIAkJCQkJYnJlYWs7CiAJCQkvKgogCQkJICogSWYgdGhlIGluZGV4IGluY3JlbWVudGVkIGFib3ZlIHJlZmVycyB0byBhCi0JCQkgKiBsZWdpdGFtYXRlIGJvYXJkIHR5cGUgc2V0IGl0IGhlcmUuCisJCQkgKiBsZWdpdGltYXRlIGJvYXJkIHR5cGUgc2V0IGl0IGhlcmUuCiAJCQkgKi8KIAkJCWlmIChpbmRleCA8IEVQQ0FfTlVNX1RZUEVTKQogCQkJCWJvYXJkLnR5cGUgPSBsb29wOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3R0eS9pcDIvaTJody5oIGIvZHJpdmVycy9zdGFnaW5nL3R0eS9pcDIvaTJody5oCmluZGV4IGMwYmE2YzAuLjhkZjJmNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90dHkvaXAyL2kyaHcuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdHR5L2lwMi9pMmh3LmgKQEAgLTMzNSw3ICszMzUsNyBAQAogaW4gZmFjdCBnZW5lcmF0ZXMgYSByZXNldCBwdWxzZSBvbiB0aGUgYm9hcmQuIFRoaXMgcHVsc2UgaXMgZ3VhcmFudGVlZCB0byBsYXN0CiBsZXNzIHRoYW4gMTAgbWlsbGlzZWNvbmRzLiBUaGUgYWRkaXRpb25hbCBkZWxheSBlbnN1cmVzIHRoZSAxNDAwIGhhcyBoYWQgdGhlCiBjaGFuY2UgdG8gcmVzcG9uZCBzdWZmaWNpZW50bHkgdG8gdGhlIGZpcnN0IHJlc2V0LiBXaHkgbm90IGEgbG9uZ2VyIGRlbGF5PyBNdWNoCi1tb3JlIHRoYW4gNTAgbWlsbGlzZWNvbmRzIGdldHMgdG8gYmUgbm90aWNhYmxlLCBidXQgdGhlIGJvYXJkIHdvdWxkIHN0aWxsIHdvcmsuCittb3JlIHRoYW4gNTAgbWlsbGlzZWNvbmRzIGdldHMgdG8gYmUgbm90aWNlYWJsZSwgYnV0IHRoZSBib2FyZCB3b3VsZCBzdGlsbCB3b3JrLgogCiBPbmNlIGFsbCAxNiBieXRlcyBvZiB0aGUgUG93ZXItb24gUmVzZXQgTWVzc2FnZSBoYXZlIGJlZW4gcmVhZCwgdGhlIGJvb3RzdHJhcAogZmlybXdhcmUgaXMgcmVhZHkgdG8gcmVjZWl2ZSBsb2Fkd2FyZS4KQEAgLTM5OSw3ICszOTksNyBAQAogCQkvLyBleHBhbmRhYmxlIHByb2R1Y3RzIG11c3QgcmVwb3J0IGEgTUFQIG9mIGF2YWlsYWJsZSBjaGFubmVscy4gU2luY2UgCiAJCS8vIGVhY2ggVUFSVCBzdXBwb3J0cyBmb3VyIHBvcnRzLCB3ZSByZXByZXNlbnQgZWFjaCBVQVJUIGZvdW5kIGJ5IGEKIAkJLy8gc2luZ2xlIGJpdC4gVXNpbmcgdHdvIGJ5dGVzIHRvIHN1cHBseSB0aGUgbWFwcGluZyBpbmZvcm1hdGlvbiB3ZQotCQkvLyByZXBvcnQgdGhlIHByZXNlbnNlIG9yIGFic2Vuc2Ugb2YgdXAgdG8gMTYgVUFSVFMsIG9yIDY0IHBvcnRzIGluCisJCS8vIHJlcG9ydCB0aGUgcHJlc2VuY2Ugb3IgYWJzZW5jZSBvZiB1cCB0byAxNiBVQVJUUywgb3IgNjQgcG9ydHMgaW4KIAkJLy8gc3RlcHMgb2YgNCBwb3J0cy4gRm9yIC1JSUVYIHByb2R1Y3RzLCB0aGUgcG9ydHMgYXJlIG51bWJlcmVkCiAJCS8vIHN0YXJ0aW5nIGF0IHRoZSBib3ggY2xvc2VzdCB0byB0aGUgY29udHJvbGxlciBpbiB0aGUgImNoYWluIi4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3R0eS9pcDIvaTJsaWIuYyBiL2RyaXZlcnMvc3RhZ2luZy90dHkvaXAyL2kybGliLmMKaW5kZXggMGQxMGI4OS4uMTNhM2NhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3R0eS9pcDIvaTJsaWIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdHR5L2lwMi9pMmxpYi5jCkBAIC04MjEsNyArODIxLDcgQEAKIC8vCiAvLyBEZXNjcmlwdGlvbjoKIC8vIFN0cmlwcyBkYXRhIGZyb20gdGhlIGlucHV0IGJ1ZmZlciBhbmQgd3JpdGVzIGl0IHRvIHBEZXN0LiBJZiB0aGVyZSBpcyBhCi0vLyBjb2xsb3NhbCBibHVuZGVyLCAoaW52YWxpZCBzdHJ1Y3R1cmUgcG9pbnRlcnMgb3IgdGhlIGxpa2UpLCByZXR1cm5zIC0xLgorLy8gY29sb3NzYWwgYmx1bmRlciwgKGludmFsaWQgc3RydWN0dXJlIHBvaW50ZXJzIG9yIHRoZSBsaWtlKSwgcmV0dXJucyAtMS4KIC8vIE90aGVyd2lzZSwgcmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHJlYWQuCiAvLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogc3RhdGljIGludApAQCAtOTA5LDcgKzkwOSw3IEBACiAvLyBSZXR1cm5zOiAgICBOdW1iZXIgb2YgYnl0ZXMgc3RyaXBwZWQsIG9yIC0xIGZvciBlcnJvcgogLy8KIC8vIERlc2NyaXB0aW9uOgotLy8gU3RyaXBzIGFueSBkYXRhIGZyb20gdGhlIGlucHV0IGJ1ZmZlci4gSWYgdGhlcmUgaXMgYSBjb2xsb3NhbCBibHVuZGVyLAorLy8gU3RyaXBzIGFueSBkYXRhIGZyb20gdGhlIGlucHV0IGJ1ZmZlci4gSWYgdGhlcmUgaXMgYSBjb2xvc3NhbCBibHVuZGVyLAogLy8gKGludmFsaWQgc3RydWN0dXJlIHBvaW50ZXJzIG9yIHRoZSBsaWtlKSwgcmV0dXJucyAtMS4gT3RoZXJ3aXNlLCByZXR1cm5zIHRoZQogLy8gbnVtYmVyIG9mIGJ5dGVzIHN0cmlwcGVkLgogLy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTk2Myw3ICs5NjMsNyBAQAogLy8gUmV0dXJuczogICAgTnVtYmVyIG9mIGJ5dGVzIGF2YWlsYWJsZSwgb3IgLTEgZm9yIGVycm9yCiAvLwogLy8gRGVzY3JpcHRpb246Ci0vLyBJZiB0aGVyZSBpcyBhIGNvbGxvc2FsIGJsdW5kZXIsIChpbnZhbGlkIHN0cnVjdHVyZSBwb2ludGVycyBvciB0aGUgbGlrZSksCisvLyBJZiB0aGVyZSBpcyBhIGNvbG9zc2FsIGJsdW5kZXIsIChpbnZhbGlkIHN0cnVjdHVyZSBwb2ludGVycyBvciB0aGUgbGlrZSksCiAvLyByZXR1cm5zIC0xLiBPdGhlcndpc2UsIHJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBzdHJpcHBlZC4gT3RoZXJ3aXNlLAogLy8gcmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIGF2YWlsYWJsZSBpbiB0aGUgYnVmZmVyLgogLy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTEwMDEsNyArMTAwMSw3IEBACiAvLwogLy8gRGVzY3JpcHRpb246CiAvLyBRdWV1ZXMgdGhlIGRhdGEgYXQgcFNvdXJjZSB0byBiZSBzZW50IGFzIGRhdGEgcGFja2V0cyB0byB0aGUgYm9hcmQuIElmIHRoZXJlCi0vLyBpcyBhIGNvbGxvc2FsIGJsdW5kZXIsIChpbnZhbGlkIHN0cnVjdHVyZSBwb2ludGVycyBvciB0aGUgbGlrZSksIHJldHVybnMgLTEuCisvLyBpcyBhIGNvbG9zc2FsIGJsdW5kZXIsIChpbnZhbGlkIHN0cnVjdHVyZSBwb2ludGVycyBvciB0aGUgbGlrZSksIHJldHVybnMgLTEuCiAvLyBPdGhlcndpc2UsIHJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyB3cml0dGVuLiBXaGF0IGlmIHRoZXJlIGlzIG5vdCBlbm91Z2gKIC8vIHJvb20gZm9yIGFsbCB0aGUgZGF0YT8gSWYgcENoLT5jaGFubmVsT3B0aW9ucyAmIENPX05CTE9DS19XUklURSBpcyBzZXQsIHRoZW4KIC8vIHdlIHRyYW5zZmVyIGFzIG1hbnkgY2hhcmFjdGVycyBhcyB3ZSBjYW4gbm93LCB0aGVuIHJldHVybi4gSWYgdGhpcyBiaXQgaXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90dHkvaXAyL2lwMm1haW4uYyBiL2RyaXZlcnMvc3RhZ2luZy90dHkvaXAyL2lwMm1haW4uYwppbmRleCBlYTdhOGZiLi5iYTA3NGZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdHR5L2lwMi9pcDJtYWluLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3R0eS9pcDIvaXAybWFpbi5jCkBAIC0xODI0LDcgKzE4MjQsNyBAQAogLy8JCWlwMnRyYWNlIChDSEFOTiwgSVRSQ19QVVRDLCAxMCwgMSwgc3RyaXAgKTsKIAogCQkvLwotCQkvLyBXZSBtYXkgbmVlZCB0byByZXN0YXJ0IGkyT3V0cHV0IGlmIGl0IGRvZXMgbm90IGZ1bGxmaWxsIHRoaXMgcmVxdWVzdAorCQkvLyBXZSBtYXkgbmVlZCB0byByZXN0YXJ0IGkyT3V0cHV0IGlmIGl0IGRvZXMgbm90IGZ1bGZpbGwgdGhpcyByZXF1ZXN0CiAJCS8vCiAJCXN0cmlwID0gaTJPdXRwdXQoIHBDaCwgcENoLT5QYnVmLCBwQ2gtPlBidWZfc3R1ZmYpOwogCQlpZiAoIHN0cmlwICE9IHBDaC0+UGJ1Zl9zdHVmZiApIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90dHkvc3BlY2lhbGl4LmMgYi9kcml2ZXJzL3N0YWdpbmcvdHR5L3NwZWNpYWxpeC5jCmluZGV4IDE3YTFiZTUuLmNiMjRjNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90dHkvc3BlY2lhbGl4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3R0eS9zcGVjaWFsaXguYwpAQCAtOSw3ICs5LDcgQEAKICAqICAgICAgc3VwcG9ydC4gQnV0IHBsZWFzZSByZWFkIHRoZSBkb2N1bWVudGF0aW9uIChzcGVjaWFsaXgudHh0KQogICogICAgICBmaXJzdC4KICAqCi0gKiAgICAgIFRoaXMgZHJpdmVyIHdhcyBkZXZlbG9wcGVkIGluIHRoZSBCaXRXaXphcmQgbGludXggZGV2aWNlCisgKiAgICAgIFRoaXMgZHJpdmVyIHdhcyBkZXZlbG9wZWQgaW4gdGhlIEJpdFdpemFyZCBsaW51eCBkZXZpY2UKICAqICAgICAgZHJpdmVyIHNlcnZpY2UuIElmIHlvdSByZXF1aXJlIGEgbGludXggZGV2aWNlIGRyaXZlciBmb3IgeW91cgogICogICAgICBwcm9kdWN0LCBwbGVhc2UgY29udGFjdCBkZXZpY2VzQEJpdFdpemFyZC5ubCBmb3IgYSBxdW90ZS4KICAqCkBAIC05NzgsNyArOTc4LDcgQEAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmYnAtPmxvY2ssIGZsYWdzKTsKIAlzeF9vdXQoYnAsIENEMTg2eF9DQVIsIHBvcnRfTm8ocG9ydCkpOwogCi0JLyogVGhlIFNwZWNpYWxpeCBib2FyZCBkb2Vucyd0IGltcGxlbWVudCB0aGUgUlRTIGxpbmVzLgorCS8qIFRoZSBTcGVjaWFsaXggYm9hcmQgZG9lcyd0IGltcGxlbWVudCB0aGUgUlRTIGxpbmVzLgogCSAgIFRoZXkgYXJlIHVzZWQgdG8gc2V0IHRoZSBJUlEgbGV2ZWwuIERvbid0IHRvdWNoIHRoZW0uICovCiAJaWYgKHN4X2NydHNjdHModHR5KSkKIAkJcG9ydC0+TVNWUiA9IE1TVlJfRFRSIHwgKHN4X2luKGJwLCBDRDE4NnhfTVNWUikgJiBNU1ZSX1JUUyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdHR5L3NwZWNpYWxpeF9pbzguaCBiL2RyaXZlcnMvc3RhZ2luZy90dHkvc3BlY2lhbGl4X2lvOC5oCmluZGV4IGM2MzAwNTIuLjEyMTVkN2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90dHkvc3BlY2lhbGl4X2lvOC5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90dHkvc3BlY2lhbGl4X2lvOC5oCkBAIC0xMCw3ICsxMCw3IEBACiAgKiAgICAgIFBsZWFzZSBETyBjb250YWN0IGlvOC1saW51eEBzcGVjaWFsaXguY28udWsgaWYgeW91IHJlcXVpcmUKICAqICAgICAgc3VwcG9ydC4KICAqCi0gKiAgICAgIFRoaXMgZHJpdmVyIHdhcyBkZXZlbG9wcGVkIGluIHRoZSBCaXRXaXphcmQgbGludXggZGV2aWNlCisgKiAgICAgIFRoaXMgZHJpdmVyIHdhcyBkZXZlbG9wZWQgaW4gdGhlIEJpdFdpemFyZCBsaW51eCBkZXZpY2UKICAqICAgICAgZHJpdmVyIHNlcnZpY2UuIElmIHlvdSByZXF1aXJlIGEgbGludXggZGV2aWNlIGRyaXZlciBmb3IgeW91cgogICogICAgICBwcm9kdWN0LCBwbGVhc2UgY29udGFjdCBkZXZpY2VzQEJpdFdpemFyZC5ubCBmb3IgYSBxdW90ZS4KICAqCkBAIC03OSw3ICs3OSw3IEBACiAKICNkZWZpbmUgU1BFQ0lBTElYX01BR0lDCQkweDA5MDcKIAotI2RlZmluZSBTWF9DQ1JfVElNRU9VVCAxMDAwMCAgIC8qIENDUiB0aW1lb3V0LiBZb3UgbWF5IG5lZWQgdG8gd2FpdCB1cHRvCisjZGVmaW5lIFNYX0NDUl9USU1FT1VUIDEwMDAwICAgLyogQ0NSIHRpbWVvdXQuIFlvdSBtYXkgbmVlZCB0byB3YWl0IHVwIHRvCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMTAgbWlsbGlzZWNvbmRzIGJlZm9yZSB0aGUgaW50ZXJuYWwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcm9jZXNzb3IgaXMgYXZhaWxhYmxlIGFnYWluIGFmdGVyCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeW91IGdpdmUgaXQgYSBjb21tYW5kICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9kZXYuYyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX2Rldi5jCmluZGV4IDgyMTRjMzUuLmJjZTdkMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX2Rldi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX2Rldi5jCkBAIC0yMjAsOCArMjIwLDEwIEBACiAJfQogCiAJLyogMS4gc3RvcCB0aHJlYWRzICovCi0Ja3RocmVhZF9zdG9wKHVkLT50Y3BfcngpOwotCWt0aHJlYWRfc3RvcCh1ZC0+dGNwX3R4KTsKKwlpZiAodWQtPnRjcF9yeCAmJiAhdGFza19pc19kZWFkKHVkLT50Y3BfcngpKQorCQlrdGhyZWFkX3N0b3AodWQtPnRjcF9yeCk7CisJaWYgKHVkLT50Y3BfdHggJiYgIXRhc2tfaXNfZGVhZCh1ZC0+dGNwX3R4KSkKKwkJa3RocmVhZF9zdG9wKHVkLT50Y3BfdHgpOwogCiAJLyogMi4gY2xvc2UgdGhlIHNvY2tldCAqLwogCS8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9yeC5jIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3N0dWJfcnguYwppbmRleCA2NDQ1ZjEyLi41MWZiZDA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9yeC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX3J4LmMKQEAgLTE3MSwzMyArMTcxLDIzIEBACiAKIHN0YXRpYyBpbnQgdHdlYWtfcmVzZXRfZGV2aWNlX2NtZChzdHJ1Y3QgdXJiICp1cmIpCiB7Ci0Jc3RydWN0IHVzYl9jdHJscmVxdWVzdCAqcmVxOwotCV9fdTE2IHZhbHVlOwotCV9fdTE2IGluZGV4OwotCWludCByZXQ7CisJc3RydWN0IHN0dWJfcHJpdiAqcHJpdiA9IChzdHJ1Y3Qgc3R1Yl9wcml2ICopIHVyYi0+Y29udGV4dDsKKwlzdHJ1Y3Qgc3R1Yl9kZXZpY2UgKnNkZXYgPSBwcml2LT5zZGV2OwogCi0JcmVxID0gKHN0cnVjdCB1c2JfY3RybHJlcXVlc3QgKikgdXJiLT5zZXR1cF9wYWNrZXQ7Ci0JdmFsdWUgPSBsZTE2X3RvX2NwdShyZXEtPndWYWx1ZSk7Ci0JaW5kZXggPSBsZTE2X3RvX2NwdShyZXEtPndJbmRleCk7CisJdXNiaXBfdWluZm8oInJlc2V0X2RldmljZSAlc1xuIiwgZGV2X25hbWUoJnVyYi0+ZGV2LT5kZXYpKTsKIAotCXVzYmlwX3VpbmZvKCJyZXNldF9kZXZpY2UgKHBvcnQgJWQpIHRvICVzXG4iLCBpbmRleCwKLQkJCQkJCWRldl9uYW1lKCZ1cmItPmRldi0+ZGV2KSk7Ci0KLQkvKiBhbGwgaW50ZXJmYWNlcyBzaG91bGQgYmUgb3duZWQgYnkgdXNiaXAgZHJpdmVyLCBzbyBqdXN0IHJlc2V0IGl0LiAgKi8KLQlyZXQgPSB1c2JfbG9ja19kZXZpY2VfZm9yX3Jlc2V0KHVyYi0+ZGV2LCBOVUxMKTsKLQlpZiAocmV0IDwgMCkgewotCQlkZXZfZXJyKCZ1cmItPmRldi0+ZGV2LCAibG9jayBmb3IgcmVzZXRcbiIpOwotCQlyZXR1cm4gcmV0OwotCX0KLQotCS8qIHRyeSB0byByZXNldCB0aGUgZGV2aWNlICovCi0JcmV0ID0gdXNiX3Jlc2V0X2RldmljZSh1cmItPmRldik7Ci0JaWYgKHJldCA8IDApCi0JCWRldl9lcnIoJnVyYi0+ZGV2LT5kZXYsICJkZXZpY2UgcmVzZXRcbiIpOwotCi0JdXNiX3VubG9ja19kZXZpY2UodXJiLT5kZXYpOwotCi0JcmV0dXJuIHJldDsKKwkvKgorCSAqIHVzYl9sb2NrX2RldmljZV9mb3JfcmVzZXQgY2F1c2VkIGEgZGVhZGxvY2s6IGl0IGNhdXNlcyB0aGUgZHJpdmVyCisJICogdG8gdW5iaW5kLiBJbiB0aGUgc2h1dGRvd24gdGhlIHJ4IHRocmVhZCBpcyBzaWduYWxsZWQgdG8gc2h1dCBkb3duCisJICogYnV0IHRoaXMgdGhyZWFkIGlzIHBlbmRpbmcgaW4gdGhlIHVzYl9sb2NrX2RldmljZV9mb3JfcmVzZXQuCisJICoKKwkgKiBJbnN0ZWFkIHF1ZXVlIHRoZSByZXNldC4KKwkgKgorCSAqIFVuZm9ydHVuYXRseSBhbiBleGlzdGluZyB1c2JpcCBjb25uZWN0aW9uIHdpbGwgYmUgZHJvcHBlZCBkdWUgdG8KKwkgKiBkcml2ZXIgdW5iaW5kaW5nLgorCSAqLworCXVzYl9xdWV1ZV9yZXNldF9kZXZpY2Uoc2Rldi0+aW50ZXJmYWNlKTsKKwlyZXR1cm4gMDsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX3R4LmMgYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl90eC5jCmluZGV4IDU1MjNmMjUuLjY0YTUyYjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX3R4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3N0dWJfdHguYwpAQCAtMTcwLDcgKzE3MCw2IEBACiAJc3RydWN0IHN0dWJfcHJpdiAqcHJpdiwgKnRtcDsKIAogCXN0cnVjdCBtc2doZHIgbXNnOwotCXN0cnVjdCBrdmVjIGlvdlszXTsKIAlzaXplX3QgdHhzaXplOwogCiAJc2l6ZV90IHRvdGFsX3NpemUgPSAwOwpAQCAtMTgwLDI4ICsxNzksNzMgQEAKIAkJc3RydWN0IHVyYiAqdXJiID0gcHJpdi0+dXJiOwogCQlzdHJ1Y3QgdXNiaXBfaGVhZGVyIHBkdV9oZWFkZXI7CiAJCXZvaWQgKmlzb19idWZmZXIgPSBOVUxMOworCQlzdHJ1Y3Qga3ZlYyAqaW92ID0gTlVMTDsKKwkJaW50IGlvdm51bSA9IDA7CiAKIAkJdHhzaXplID0gMDsKIAkJbWVtc2V0KCZwZHVfaGVhZGVyLCAwLCBzaXplb2YocGR1X2hlYWRlcikpOwogCQltZW1zZXQoJm1zZywgMCwgc2l6ZW9mKG1zZykpOwotCQltZW1zZXQoJmlvdiwgMCwgc2l6ZW9mKGlvdikpOwogCi0JCXVzYmlwX2RiZ19zdHViX3R4KCJzZXR1cCB0eGRhdGEgdXJiICVwXG4iLCB1cmIpOworCQlpZiAodXNiX3BpcGV0eXBlKHVyYi0+cGlwZSkgPT0gUElQRV9JU09DSFJPTk9VUykKKwkJCWlvdm51bSA9IDIgKyB1cmItPm51bWJlcl9vZl9wYWNrZXRzOworCQllbHNlCisJCQlpb3ZudW0gPSAyOwogCisJCWlvdiA9IGt6YWxsb2MoaW92bnVtICogc2l6ZW9mKHN0cnVjdCBrdmVjKSwgR0ZQX0tFUk5FTCk7CisKKwkJaWYgKCFpb3YpIHsKKwkJCXVzYmlwX2V2ZW50X2FkZCgmc2Rldi0+dWQsIFNERVZfRVZFTlRfRVJST1JfTUFMTE9DKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCisJCWlvdm51bSA9IDA7CiAKIAkJLyogMS4gc2V0dXAgdXNiaXBfaGVhZGVyICovCiAJCXNldHVwX3JldF9zdWJtaXRfcGR1KCZwZHVfaGVhZGVyLCB1cmIpOworCQl1c2JpcF9kYmdfc3R1Yl90eCgic2V0dXAgdHhkYXRhIHNlcW51bTogJWQgdXJiOiAlcFxuIiwKKwkJCQkJCXBkdV9oZWFkZXIuYmFzZS5zZXFudW0sIHVyYik7CisJCS8qdXNiaXBfZHVtcF9oZWFkZXIocGR1X2hlYWRlcik7Ki8KIAkJdXNiaXBfaGVhZGVyX2NvcnJlY3RfZW5kaWFuKCZwZHVfaGVhZGVyLCAxKTsKIAotCQlpb3ZbMF0uaW92X2Jhc2UgPSAmcGR1X2hlYWRlcjsKLQkJaW92WzBdLmlvdl9sZW4gID0gc2l6ZW9mKHBkdV9oZWFkZXIpOworCQlpb3ZbaW92bnVtXS5pb3ZfYmFzZSA9ICZwZHVfaGVhZGVyOworCQlpb3ZbaW92bnVtXS5pb3ZfbGVuICA9IHNpemVvZihwZHVfaGVhZGVyKTsKKwkJaW92bnVtKys7CiAJCXR4c2l6ZSArPSBzaXplb2YocGR1X2hlYWRlcik7CiAKIAkJLyogMi4gc2V0dXAgdHJhbnNmZXIgYnVmZmVyICovCi0JCWlmICh1c2JfcGlwZWluKHVyYi0+cGlwZSkgJiYgdXJiLT5hY3R1YWxfbGVuZ3RoID4gMCkgewotCQkJaW92WzFdLmlvdl9iYXNlID0gdXJiLT50cmFuc2Zlcl9idWZmZXI7Ci0JCQlpb3ZbMV0uaW92X2xlbiAgPSB1cmItPmFjdHVhbF9sZW5ndGg7CisJCWlmICh1c2JfcGlwZWluKHVyYi0+cGlwZSkgJiYKKwkJCQl1c2JfcGlwZXR5cGUodXJiLT5waXBlKSAhPSBQSVBFX0lTT0NIUk9OT1VTICYmCisJCQkJCXVyYi0+YWN0dWFsX2xlbmd0aCA+IDApIHsKKwkJCWlvdltpb3ZudW1dLmlvdl9iYXNlID0gdXJiLT50cmFuc2Zlcl9idWZmZXI7CisJCQlpb3ZbaW92bnVtXS5pb3ZfbGVuICA9IHVyYi0+YWN0dWFsX2xlbmd0aDsKKwkJCWlvdm51bSsrOwogCQkJdHhzaXplICs9IHVyYi0+YWN0dWFsX2xlbmd0aDsKKwkJfSBlbHNlIGlmICh1c2JfcGlwZWluKHVyYi0+cGlwZSkgJiYKKwkJCQl1c2JfcGlwZXR5cGUodXJiLT5waXBlKSA9PSBQSVBFX0lTT0NIUk9OT1VTKSB7CisJCQkvKgorCQkJICogRm9yIGlzb2Nocm9ub3VzIHBhY2tldHM6IGFjdHVhbCBsZW5ndGggaXMgdGhlIHN1bSBvZgorCQkJICogdGhlIGFjdHVhbCBsZW5ndGggb2YgdGhlIGluZGl2aWR1YWwsIHBhY2tldHMsIGJ1dCBhcworCQkJICogdGhlIHBhY2tldCBvZmZzZXRzIGFyZSBub3QgY2hhbmdlZCB0aGVyZSB3aWxsIGJlCisJCQkgKiBwYWRkaW5nIGJldHdlZW4gdGhlIHBhY2tldHMuIFRvIG9wdGltYWxseSB1c2UgdGhlCisJCQkgKiBiYW5kd2lkdGggdGhlIHBhZGRpbmcgaXMgbm90IHRyYW5zbWl0dGVkLgorCQkJICovCisKKwkJCWludCBpOworCQkJZm9yIChpID0gMDsgaSA8IHVyYi0+bnVtYmVyX29mX3BhY2tldHM7IGkrKykgeworCQkJCWlvdltpb3ZudW1dLmlvdl9iYXNlID0gdXJiLT50cmFuc2Zlcl9idWZmZXIgKyB1cmItPmlzb19mcmFtZV9kZXNjW2ldLm9mZnNldDsKKwkJCQlpb3ZbaW92bnVtXS5pb3ZfbGVuID0gdXJiLT5pc29fZnJhbWVfZGVzY1tpXS5hY3R1YWxfbGVuZ3RoOworCQkJCWlvdm51bSsrOworCQkJCXR4c2l6ZSArPSB1cmItPmlzb19mcmFtZV9kZXNjW2ldLmFjdHVhbF9sZW5ndGg7CisJCQl9CisKKwkJCWlmICh0eHNpemUgIT0gc2l6ZW9mKHBkdV9oZWFkZXIpICsgdXJiLT5hY3R1YWxfbGVuZ3RoKSB7CisJCQkJZGV2X2Vycigmc2Rldi0+aW50ZXJmYWNlLT5kZXYsCisJCQkJCSJhY3R1YWwgbGVuZ3RoIG9mIHVyYiAoJWQpIGRvZXMgbm90IG1hdGNoIGlzbyBwYWNrZXQgc2l6ZXMgKCVkKVxuIiwKKwkJCQkJdXJiLT5hY3R1YWxfbGVuZ3RoLCB0eHNpemUtc2l6ZW9mKHBkdV9oZWFkZXIpKTsKKwkJCQlrZnJlZShpb3YpOworCQkJCXVzYmlwX2V2ZW50X2FkZCgmc2Rldi0+dWQsIFNERVZfRVZFTlRfRVJST1JfVENQKTsKKwkJCSAgIHJldHVybiAtMTsKKwkJCX0KIAkJfQogCiAJCS8qIDMuIHNldHVwIGlzb19wYWNrZXRfZGVzY3JpcHRvciAqLwpAQCAtMjEyLDMyICsyNTYsMzQgQEAKIAkJCWlmICghaXNvX2J1ZmZlcikgewogCQkJCXVzYmlwX2V2ZW50X2FkZCgmc2Rldi0+dWQsCiAJCQkJCQlTREVWX0VWRU5UX0VSUk9SX01BTExPQyk7CisJCQkJa2ZyZWUoaW92KTsKIAkJCQlyZXR1cm4gLTE7CiAJCQl9CiAKLQkJCWlvdlsyXS5pb3ZfYmFzZSA9IGlzb19idWZmZXI7Ci0JCQlpb3ZbMl0uaW92X2xlbiAgPSBsZW47CisJCQlpb3ZbaW92bnVtXS5pb3ZfYmFzZSA9IGlzb19idWZmZXI7CisJCQlpb3ZbaW92bnVtXS5pb3ZfbGVuICA9IGxlbjsKIAkJCXR4c2l6ZSArPSBsZW47CisJCQlpb3ZudW0rKzsKIAkJfQogCi0JCXJldCA9IGtlcm5lbF9zZW5kbXNnKHNkZXYtPnVkLnRjcF9zb2NrZXQsICZtc2csIGlvdiwKLQkJCQkgICAgIDMsIHR4c2l6ZSk7CisJCXJldCA9IGtlcm5lbF9zZW5kbXNnKHNkZXYtPnVkLnRjcF9zb2NrZXQsICZtc2csCisJCQkJCQlpb3YsICBpb3ZudW0sIHR4c2l6ZSk7CiAJCWlmIChyZXQgIT0gdHhzaXplKSB7CiAJCQlkZXZfZXJyKCZzZGV2LT5pbnRlcmZhY2UtPmRldiwKIAkJCQkic2VuZG1zZyBmYWlsZWQhLCByZXR2YWwgJWQgZm9yICV6ZFxuIiwKIAkJCQlyZXQsIHR4c2l6ZSk7CisJCQlrZnJlZShpb3YpOwogCQkJa2ZyZWUoaXNvX2J1ZmZlcik7CiAJCQl1c2JpcF9ldmVudF9hZGQoJnNkZXYtPnVkLCBTREVWX0VWRU5UX0VSUk9SX1RDUCk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAorCQlrZnJlZShpb3YpOwogCQlrZnJlZShpc29fYnVmZmVyKTsKLQkJdXNiaXBfZGJnX3N0dWJfdHgoInNlbmQgdHhkYXRhXG4iKTsKIAogCQl0b3RhbF9zaXplICs9IHR4c2l6ZTsKIAl9CiAKLQogCXNwaW5fbG9ja19pcnFzYXZlKCZzZGV2LT5wcml2X2xvY2ssIGZsYWdzKTsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwcml2LCB0bXAsICZzZGV2LT5wcml2X2ZyZWUsIGxpc3QpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC91c2JpcF9jb21tb24uYyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC91c2JpcF9jb21tb24uYwppbmRleCAzMzdhYmM0Li43YjFmZTQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdXNiaXBfY29tbW9uLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3VzYmlwX2NvbW1vbi5jCkBAIC0zMzMsMTAgKzMzMywxMSBAQAogCQl1c2JpcF91ZGJnKCJDTURfVU5MSU5LOiBzZXEgJXVcbiIsIHBkdS0+dS5jbWRfdW5saW5rLnNlcW51bSk7CiAJCWJyZWFrOwogCWNhc2UgVVNCSVBfUkVUX1NVQk1JVDoKLQkJdXNiaXBfdWRiZygiUkVUX1NVQk1JVDogc3QgJWQgYWwgJXUgc2YgJWQgZWMgJWRcbiIsCisJCXVzYmlwX3VkYmcoIlJFVF9TVUJNSVQ6IHN0ICVkIGFsICV1IHNmICVkICNwICVkIGVjICVkXG4iLAogCQkJCXBkdS0+dS5yZXRfc3VibWl0LnN0YXR1cywKIAkJCQlwZHUtPnUucmV0X3N1Ym1pdC5hY3R1YWxfbGVuZ3RoLAogCQkJCXBkdS0+dS5yZXRfc3VibWl0LnN0YXJ0X2ZyYW1lLAorCQkJCXBkdS0+dS5yZXRfc3VibWl0Lm51bWJlcl9vZl9wYWNrZXRzLAogCQkJCXBkdS0+dS5yZXRfc3VibWl0LmVycm9yX2NvdW50KTsKIAljYXNlIFVTQklQX1JFVF9VTkxJTks6CiAJCXVzYmlwX3VkYmcoIlJFVF9VTkxJTks6IHN0YXR1cyAlZFxuIiwgcGR1LT51LnJldF91bmxpbmsuc3RhdHVzKTsKQEAgLTUyMCw2ICs1MjEsNyBAQAogCQlycGR1LT5zdGF0dXMJCT0gdXJiLT5zdGF0dXM7CiAJCXJwZHUtPmFjdHVhbF9sZW5ndGgJPSB1cmItPmFjdHVhbF9sZW5ndGg7CiAJCXJwZHUtPnN0YXJ0X2ZyYW1lCT0gdXJiLT5zdGFydF9mcmFtZTsKKwkJcnBkdS0+bnVtYmVyX29mX3BhY2tldHMgPSB1cmItPm51bWJlcl9vZl9wYWNrZXRzOwogCQlycGR1LT5lcnJvcl9jb3VudAk9IHVyYi0+ZXJyb3JfY291bnQ7CiAJfSBlbHNlIHsKIAkJLyogdmhjaV9yeC5jICovCkBAIC01MjcsNiArNTI5LDcgQEAKIAkJdXJiLT5zdGF0dXMJCT0gcnBkdS0+c3RhdHVzOwogCQl1cmItPmFjdHVhbF9sZW5ndGgJPSBycGR1LT5hY3R1YWxfbGVuZ3RoOwogCQl1cmItPnN0YXJ0X2ZyYW1lCT0gcnBkdS0+c3RhcnRfZnJhbWU7CisJCXVyYi0+bnVtYmVyX29mX3BhY2tldHMgPSBycGR1LT5udW1iZXJfb2ZfcGFja2V0czsKIAkJdXJiLT5lcnJvcl9jb3VudAk9IHJwZHUtPmVycm9yX2NvdW50OwogCX0KIH0KQEAgLTU5NSwxMSArNTk4LDEzIEBACiAJCWNwdV90b19iZTMycygmcGR1LT5zdGF0dXMpOwogCQljcHVfdG9fYmUzMnMoJnBkdS0+YWN0dWFsX2xlbmd0aCk7CiAJCWNwdV90b19iZTMycygmcGR1LT5zdGFydF9mcmFtZSk7CisJCWNwdV90b19iZTMycygmcGR1LT5udW1iZXJfb2ZfcGFja2V0cyk7CiAJCWNwdV90b19iZTMycygmcGR1LT5lcnJvcl9jb3VudCk7CiAJfSBlbHNlIHsKIAkJYmUzMl90b19jcHVzKCZwZHUtPnN0YXR1cyk7CiAJCWJlMzJfdG9fY3B1cygmcGR1LT5hY3R1YWxfbGVuZ3RoKTsKIAkJYmUzMl90b19jcHVzKCZwZHUtPnN0YXJ0X2ZyYW1lKTsKKwkJY3B1X3RvX2JlMzJzKCZwZHUtPm51bWJlcl9vZl9wYWNrZXRzKTsKIAkJYmUzMl90b19jcHVzKCZwZHUtPmVycm9yX2NvdW50KTsKIAl9CiB9CkBAIC03MjUsNiArNzMwLDcgQEAKIAlpbnQgc2l6ZSA9IG5wICogc2l6ZW9mKCppc28pOwogCWludCBpOwogCWludCByZXQ7CisJaW50IHRvdGFsX2xlbmd0aCA9IDA7CiAKIAlpZiAoIXVzYl9waXBlaXNvYyh1cmItPnBpcGUpKQogCQlyZXR1cm4gMDsKQEAgLTc1NCwxOSArNzYwLDc1IEBACiAJCXJldHVybiAtRVBJUEU7CiAJfQogCisKIAlmb3IgKGkgPSAwOyBpIDwgbnA7IGkrKykgewogCQlpc28gPSBidWZmICsgKGkgKiBzaXplb2YoKmlzbykpOwogCiAJCXVzYmlwX2lzb19wYWtjZXRfY29ycmVjdF9lbmRpYW4oaXNvLCAwKTsKIAkJdXNiaXBfcGFja19pc28oaXNvLCAmdXJiLT5pc29fZnJhbWVfZGVzY1tpXSwgMCk7CisJCXRvdGFsX2xlbmd0aCArPSB1cmItPmlzb19mcmFtZV9kZXNjW2ldLmFjdHVhbF9sZW5ndGg7CiAJfQogCiAJa2ZyZWUoYnVmZik7CiAKKwlpZiAodG90YWxfbGVuZ3RoICE9IHVyYi0+YWN0dWFsX2xlbmd0aCkgeworCQlkZXZfZXJyKCZ1cmItPmRldi0+ZGV2LAorCQkgICJ0b3RhbCBsZW5ndGggb2YgaXNvIHBhY2tldHMgKCVkKSBub3QgZXF1YWwgdG8gYWN0dWFsIGxlbmd0aCBvZiBidWZmZXIgKCVkKVxuIiwKKwkJICB0b3RhbF9sZW5ndGgsIHVyYi0+YWN0dWFsX2xlbmd0aCk7CisKKwkJaWYgKHVkLT5zaWRlID09IFVTQklQX1NUVUIpCisJCQl1c2JpcF9ldmVudF9hZGQodWQsIFNERVZfRVZFTlRfRVJST1JfVENQKTsKKwkJZWxzZQorCQkJdXNiaXBfZXZlbnRfYWRkKHVkLCBWREVWX0VWRU5UX0VSUk9SX1RDUCk7CisKKwkJcmV0dXJuIC1FUElQRTsKKwl9CisKIAlyZXR1cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTF9HUEwodXNiaXBfcmVjdl9pc28pOwogCisvKgorICogVGhpcyBmdW5jdGlvbnMgcmVzdG9yZXMgdGhlIHBhZGRpbmcgd2hpY2ggd2FzIHJlbW92ZWQgZm9yIG9wdGltaXppbmcKKyAqIHRoZSBiYW5kd2lkdGggZHVyaW5nIHRyYW5zZmVyIG92ZXIgdGNwL2lwCisgKgorICogYnVmZmVyIGFuZCBpc28gcGFja2V0cyBuZWVkIHRvIGJlIHN0b3JlZCBhbmQgYmUgaW4gcHJvcGVwZXIgZW5kaWFuIGluIHVyYgorICogYmVmb3JlIGNhbGxpbmcgdGhpcyBmdW5jdGlvbgorICovCitpbnQgdXNiaXBfcGFkX2lzbyhzdHJ1Y3QgdXNiaXBfZGV2aWNlICp1ZCwgc3RydWN0IHVyYiAqdXJiKQoreworCWludCBucCA9IHVyYi0+bnVtYmVyX29mX3BhY2tldHM7CisJaW50IGk7CisJaW50IHJldDsKKwlpbnQgYWN0dWFsb2Zmc2V0ID0gdXJiLT5hY3R1YWxfbGVuZ3RoOworCisJaWYgKCF1c2JfcGlwZWlzb2ModXJiLT5waXBlKSkKKwkJcmV0dXJuIDA7CisKKwkvKiBpZiBubyBwYWNrZXRzIG9yIGxlbmd0aCBvZiBkYXRhIGlzIDAsIHRoZW4gbm90aGluZyB0byB1bnBhY2sgKi8KKwlpZiAobnAgPT0gMCB8fCB1cmItPmFjdHVhbF9sZW5ndGggPT0gMCkKKwkJcmV0dXJuIDA7CisKKwkvKgorCSAqIGlmIGFjdHVhbF9sZW5ndGggaXMgdHJhbnNmZXJfYnVmZmVyX2xlbmd0aCB0aGVuIG5vIHBhZGRpbmcgaXMKKwkgKiBwcmVzZW50LgorCSovCisJaWYgKHVyYi0+YWN0dWFsX2xlbmd0aCA9PSB1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgpCisJCXJldHVybiAwOworCisJLyoKKwkgKiBsb29wIG92ZXIgYWxsIHBhY2tldHMgZnJvbSBsYXN0IHRvIGZpcnN0ICh0byBwcmV2ZW50IG92ZXJ3cml0dGluZworCSAqIG1lbW9yeSB3aGVuIHBhZGRpbmcpIGFuZCBtb3ZlIHRoZW0gaW50byB0aGUgcHJvcGVyIHBsYWNlCisJICovCisJZm9yIChpID0gbnAtMTsgaSA+IDA7IGktLSkgeworCQlhY3R1YWxvZmZzZXQgLT0gdXJiLT5pc29fZnJhbWVfZGVzY1tpXS5hY3R1YWxfbGVuZ3RoOworCQltZW1tb3ZlKHVyYi0+dHJhbnNmZXJfYnVmZmVyICsgdXJiLT5pc29fZnJhbWVfZGVzY1tpXS5vZmZzZXQsCisJCQkJICB1cmItPnRyYW5zZmVyX2J1ZmZlciArIGFjdHVhbG9mZnNldCwKKwkJCQkgIHVyYi0+aXNvX2ZyYW1lX2Rlc2NbaV0uYWN0dWFsX2xlbmd0aCk7CisJfQorCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTCh1c2JpcF9wYWRfaXNvKTsKIAogLyogc29tZSBtZW1iZXJzIG9mIHVyYiBtdXN0IGJlIHN1YnN0aXR1dGVkIGJlZm9yZS4gKi8KIGludCB1c2JpcF9yZWN2X3hidWZmKHN0cnVjdCB1c2JpcF9kZXZpY2UgKnVkLCBzdHJ1Y3QgdXJiICp1cmIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdXNiaXBfY29tbW9uLmggYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdXNiaXBfY29tbW9uLmgKaW5kZXggOWY4MDljMy4uYzc2N2Y1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3VzYmlwX2NvbW1vbi5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC91c2JpcF9jb21tb24uaApAQCAtMzc5LDYgKzM3OSw4IEBACiBpbnQgdXNiaXBfcmVjdl94YnVmZihzdHJ1Y3QgdXNiaXBfZGV2aWNlICp1ZCwgc3RydWN0IHVyYiAqdXJiKTsKIC8qIHNvbWUgbWVtYmVycyBvZiB1cmIgbXVzdCBiZSBzdWJzdGl0dXRlZCBiZWZvcmUuICovCiBpbnQgdXNiaXBfcmVjdl9pc28oc3RydWN0IHVzYmlwX2RldmljZSAqdWQsIHN0cnVjdCB1cmIgKnVyYik7CisvKiBzb21lIG1lbWJlcnMgb2YgdXJiIG11c3QgYmUgc3Vic3RpdHV0ZWQgYmVmb3JlLiAqLworaW50IHVzYmlwX3BhZF9pc28oc3RydWN0IHVzYmlwX2RldmljZSAqdWQsIHN0cnVjdCB1cmIgKnVyYik7CiB2b2lkICp1c2JpcF9hbGxvY19pc29fZGVzY19wZHUoc3RydWN0IHVyYiAqdXJiLCBzc2l6ZV90ICpidWZmbGVuKTsKIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdmhjaV9oY2QuYyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpX2hjZC5jCmluZGV4IGUyMzQ4NDkuLjBmMDJhNGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpX2hjZC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpX2hjZC5jCkBAIC0xOTQsNyArMTk0LDcgQEAKICAqCiAgKiBTbywgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBvcnRzIGlzIDMxICggcG9ydCAwIHRvIHBvcnQgMzApID8KICAqCi0gKiBUaGUgcmV0dXJuIHZhbHVlIGlzIHRoZSBhY3R1YWwgdHJhbnNmZXJlZCBsZW5ndGggaW4gYnl0ZS4gSWYgbm90aGluZyBoYXMKKyAqIFRoZSByZXR1cm4gdmFsdWUgaXMgdGhlIGFjdHVhbCB0cmFuc2ZlcnJlZCBsZW5ndGggaW4gYnl0ZS4gSWYgbm90aGluZyBoYXMKICAqIGJlZW4gY2hhbmdlZCwgcmV0dXJuIDAuIEluIHRoZSBjYXNlIHRoYXQgdGhlIG51bWJlciBvZiBwb3J0cyBpcyBsZXNzIHRoYW4gb3IKICAqIGVxdWFsIHRvIDYgKFZIQ0lfTlBPUlRTPT03KSwgcmV0dXJuIDEuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2lfcnguYyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpX3J4LmMKaW5kZXggMDliZjIzNS4uMmZmYzk2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2lfcnguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdmhjaV9yeC5jCkBAIC0xMDAsNiArMTAwLDkgQEAKIAlpZiAodXNiaXBfcmVjdl9pc28odWQsIHVyYikgPCAwKQogCQlyZXR1cm47CiAKKwkvKiByZXN0b3JlIHRoZSBwYWRkaW5nIGluIGlzbyBwYWNrZXRzICovCisJaWYgKHVzYmlwX3BhZF9pc28odWQsIHVyYikgPCAwKQorCQlyZXR1cm47CiAKIAlpZiAodXNiaXBfZGJnX2ZsYWdfdmhjaV9yeCkKIAkJdXNiaXBfZHVtcF91cmIodXJiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy92bWVfY2E5MWN4NDIuYyBiL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy92bWVfY2E5MWN4NDIuYwppbmRleCBkNGE0OGM0Li5hNDAwNzI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvdm1lX2NhOTFjeDQyLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV9jYTkxY3g0Mi5jCkBAIC02MjEsNyArNjIxLDcgQEAKIAogCS8qCiAJICogTGV0J3MgYWxsb2NhdGUgdGhlIHJlc291cmNlIGhlcmUgcmF0aGVyIHRoYW4gZnVydGhlciB1cCB0aGUgc3RhY2sgYXMKLQkgKiBpdCBhdm9pZHMgcHVzaGluZyBsb2FkcyBvZiBidXMgZGVwZW5kYW50IHN0dWZmIHVwIHRoZSBzdGFjaworCSAqIGl0IGF2b2lkcyBwdXNoaW5nIGxvYWRzIG9mIGJ1cyBkZXBlbmRlbnQgc3R1ZmYgdXAgdGhlIHN0YWNrCiAJICovCiAJcmV0dmFsID0gY2E5MWN4NDJfYWxsb2NfcmVzb3VyY2UoaW1hZ2UsIHNpemUpOwogCWlmIChyZXR2YWwpIHsKQEAgLTEwNTIsNyArMTA1Miw3IEBACiAJCXBjaV9hdHRyID0gZGVzdC0+cHJpdmF0ZTsKIAl9CiAKLQkvKiBDaGVjayB3ZSBjYW4gZG8gZnVsbGZpbGwgcmVxdWlyZWQgYXR0cmlidXRlcyAqLworCS8qIENoZWNrIHdlIGNhbiBkbyBmdWxmaWxsIHJlcXVpcmVkIGF0dHJpYnV0ZXMgKi8KIAlpZiAoKHZtZV9hdHRyLT5hc3BhY2UgJiB+KFZNRV9BMTYgfCBWTUVfQTI0IHwgVk1FX0EzMiB8IFZNRV9VU0VSMSB8CiAJCVZNRV9VU0VSMikpICE9IDApIHsKIApAQCAtMTA2OSw3ICsxMDY5LDcgQEAKIAkJZ290byBlcnJfY3ljbGU7CiAJfQogCi0JLyogQ2hlY2sgdG8gc2VlIGlmIHdlIGNhbiBmdWxsZmlsbCBzb3VyY2UgYW5kIGRlc3RpbmF0aW9uICovCisJLyogQ2hlY2sgdG8gc2VlIGlmIHdlIGNhbiBmdWxmaWxsIHNvdXJjZSBhbmQgZGVzdGluYXRpb24gKi8KIAlpZiAoISgoKHNyYy0+dHlwZSA9PSBWTUVfRE1BX1BDSSkgJiYgKGRlc3QtPnR5cGUgPT0gVk1FX0RNQV9WTUUpKSB8fAogCQkoKHNyYy0+dHlwZSA9PSBWTUVfRE1BX1ZNRSkgJiYgKGRlc3QtPnR5cGUgPT0gVk1FX0RNQV9QQ0kpKSkpIHsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV90c2kxNDguYyBiL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy92bWVfdHNpMTQ4LmMKaW5kZXggYjAwYTUzZS4uMTA2YWE5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV90c2kxNDguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvdm1lX3RzaTE0OC5jCkBAIC05MjgsNyArOTI4LDcgQEAKIAlzcGluX2xvY2soJmltYWdlLT5sb2NrKTsKIAogCS8qIExldCdzIGFsbG9jYXRlIHRoZSByZXNvdXJjZSBoZXJlIHJhdGhlciB0aGFuIGZ1cnRoZXIgdXAgdGhlIHN0YWNrIGFzCi0JICogaXQgYXZvaWRzIHB1c2hpbmcgbG9hZHMgb2YgYnVzIGRlcGVuZGFudCBzdHVmZiB1cCB0aGUgc3RhY2suIElmIHNpemUKKwkgKiBpdCBhdm9pZHMgcHVzaGluZyBsb2FkcyBvZiBidXMgZGVwZW5kZW50IHN0dWZmIHVwIHRoZSBzdGFjay4gSWYgc2l6ZQogCSAqIGlzIHplcm8sIGFueSBleGlzdGluZyByZXNvdXJjZSB3aWxsIGJlIGZyZWVkLgogCSAqLwogCXJldHZhbCA9IHRzaTE0OF9hbGxvY19yZXNvdXJjZShpbWFnZSwgc2l6ZSk7CkBAIC0xMzIwLDcgKzEzMjAsNyBAQAogCiAJLyoKIAkgKiBXcml0ZXMgYXJlIHBvc3RlZC4gV2UgbmVlZCB0byBkbyBhIHJlYWQgb24gdGhlIFZNRSBidXMgdG8gZmx1c2ggb3V0Ci0JICogYWxsIG9mIHRoZSB3cml0ZXMgYmVmb3JlIHdlIGNoZWNrIGZvciBlcnJvcnMuIFdlIGNhbid0IGd1YXJlbnRlZQorCSAqIGFsbCBvZiB0aGUgd3JpdGVzIGJlZm9yZSB3ZSBjaGVjayBmb3IgZXJyb3JzLiBXZSBjYW4ndCBndWFyYW50ZWUKIAkgKiB0aGF0IHJlYWRpbmcgdGhlIGRhdGEgd2UgaGF2ZSBqdXN0IHdyaXR0ZW4gaXMgc2FmZS4gSXQgaXMgYmVsaWV2ZWQKIAkgKiB0aGF0IHRoZXJlIGlzbid0IGFueSByZWFkLCB3cml0ZSByZS1vcmRlcmluZywgc28gd2UgY2FuIHJlYWQgYW55CiAJICogbG9jYXRpb24gaW4gVk1FIHNwYWNlLCBzbyBsZXRzIHJlYWQgdGhlIERldmljZSBJRCBmcm9tIHRoZSB0c2kxNDgncwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV90c2kxNDguaCBiL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy92bWVfdHNpMTQ4LmgKaW5kZXggOWY5N2ZhOC4uYTNhYzJmZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV90c2kxNDguaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvdm1lX3RzaTE0OC5oCkBAIC0yMTIsNyArMjEyLDcgQEAKICNkZWZpbmUgVFNJMTQ4X0xDU1JfT0ZGU0VUX09UQVQJCTB4MUMKIAogLyoKLSAqIFZNRWJ1cyBpbnRlcnVwdCBhY2sKKyAqIFZNRWJ1cyBpbnRlcnJ1cHQgYWNrCiAgKiBvZmZzZXQgIDIwMAogICovCiAjZGVmaW5lIFRTSTE0OF9MQ1NSX1ZJQUNLMQkweDIwNApAQCAtNjEzLDcgKzYxMyw3IEBACiAvKgogICogIFBDSS1YIFN0YXR1cyBSZWdpc3RlciAoQ1JHICskMDU0KQogICovCi0jZGVmaW5lIFRTSTE0OF9QQ0ZTX1BDSVhTVEFUX1JTQ0VNICAgICAoMTw8MjkpCS8qIFJlY2lldmVkIFNwbGl0IENvbXAgRXJyb3IgKi8KKyNkZWZpbmUgVFNJMTQ4X1BDRlNfUENJWFNUQVRfUlNDRU0gICAgICgxPDwyOSkJLyogUmVjZWl2ZWQgU3BsaXQgQ29tcCBFcnJvciAqLwogI2RlZmluZSBUU0kxNDhfUENGU19QQ0lYU1RBVF9ETUNSU19NICAgKDc8PDI2KQkvKiBtYXggQ3VtdWxhdGl2ZSBSZWFkIFNpemUgKi8KICNkZWZpbmUgVFNJMTQ4X1BDRlNfUENJWFNUQVRfRE1PU1RfTSAgICg3PDwyMykJLyogbWF4IG91dHN0YW5kaW5nIFNwbGl0IFRyYW5zCiAJCQkJCQkgKi8KQEAgLTk4Miw4ICs5ODIsOCBAQAogI2RlZmluZSBUU0kxNDhfTENTUl9WSUNSX0NOVFNfSVJRMSAgICAgKDI8PDIyKQkvKiBJUlExIHRvIENudHIgKi8KICNkZWZpbmUgVFNJMTQ4X0xDU1JfVklDUl9DTlRTX0lSUTIgICAgICgzPDwyMikJLyogSVJRMiB0byBDbnRyICovCiAKLSNkZWZpbmUgVFNJMTQ4X0xDU1JfVklDUl9FREdJU19NICAgICAgICgzPDwyMCkJLyogRWRnZSBpbnRlcnVwdCBNQVNLICovCi0jZGVmaW5lIFRTSTE0OF9MQ1NSX1ZJQ1JfRURHSVNfRElTICAgICAoMTw8MjApCS8qIEVkZ2UgaW50ZXJ1cHQgRGlzYWJsZSAqLworI2RlZmluZSBUU0kxNDhfTENTUl9WSUNSX0VER0lTX00gICAgICAgKDM8PDIwKQkvKiBFZGdlIGludGVycnVwdCBNQVNLICovCisjZGVmaW5lIFRTSTE0OF9MQ1NSX1ZJQ1JfRURHSVNfRElTICAgICAoMTw8MjApCS8qIEVkZ2UgaW50ZXJydXB0IERpc2FibGUgKi8KICNkZWZpbmUgVFNJMTQ4X0xDU1JfVklDUl9FREdJU19JUlExICAgICgyPDwyMCkJLyogSVJRMSB0byBFZGdlICovCiAjZGVmaW5lIFRTSTE0OF9MQ1NSX1ZJQ1JfRURHSVNfSVJRMiAgICAoMzw8MjApCS8qIElSUTIgdG8gRWRnZSAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdm1lL3ZtZV9hcGkudHh0IGIvZHJpdmVycy9zdGFnaW5nL3ZtZS92bWVfYXBpLnR4dAppbmRleCBhOTEwYTBjLi40OTEwZTkyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdm1lL3ZtZV9hcGkudHh0CisrKyBiL2RyaXZlcnMvc3RhZ2luZy92bWUvdm1lX2FwaS50eHQKQEAgLTYsNyArNiw3IEBACiAKIEFzIHdpdGggb3RoZXIgc3Vic3lzdGVtcyB3aXRoaW4gdGhlIExpbnV4IGtlcm5lbCwgVk1FIGRldmljZSBkcml2ZXJzIHJlZ2lzdGVyCiB3aXRoIHRoZSBWTUUgc3Vic3lzdGVtLCB0eXBpY2FsbHkgY2FsbGVkIGZyb20gdGhlIGRldmljZXMgaW5pdCByb3V0aW5lLiAgVGhpcyBpcwotYWNoaWV2ZWQgdmlhIGEgY2FsbCB0byB0aGUgZm9sbHdvaW5nIGZ1bmN0aW9uOgorYWNoaWV2ZWQgdmlhIGEgY2FsbCB0byB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uOgogCiAJaW50IHZtZV9yZWdpc3Rlcl9kcml2ZXIgKHN0cnVjdCB2bWVfZHJpdmVyICpkcml2ZXIpOwogCkBAIC0xMDgsNyArMTA4LDcgQEAKID09PT09PT09PT09PT09CiAKIE1hc3RlciB3aW5kb3dzIHByb3ZpZGUgYWNjZXNzIGZyb20gdGhlIGxvY2FsIHByb2Nlc3NvcltzXSBvdXQgb250byB0aGUgVk1FIGJ1cy4KLVRoZSBudW1iZXIgb2Ygd2luZG93cyBhdmFpbGFibGUgYW5kIHRoZSBhdmFpbGFibGUgYWNjZXNzIG1vZGVzIGlzIGRlcGVuZGFudCBvbgorVGhlIG51bWJlciBvZiB3aW5kb3dzIGF2YWlsYWJsZSBhbmQgdGhlIGF2YWlsYWJsZSBhY2Nlc3MgbW9kZXMgaXMgZGVwZW5kZW50IG9uCiB0aGUgdW5kZXJseWluZyBjaGlwc2V0LiBBIHdpbmRvdyBtdXN0IGJlIGNvbmZpZ3VyZWQgYmVmb3JlIGl0IGNhbiBiZSB1c2VkLgogCiAKQEAgLTE2Myw3ICsxNjMsNyBAQAogCiBTbGF2ZSB3aW5kb3dzIHByb3ZpZGUgZGV2aWNlcyBvbiB0aGUgVk1FIGJ1cyBhY2Nlc3MgaW50byBtYXBwZWQgcG9ydGlvbnMgb2YgdGhlCiBsb2NhbCBtZW1vcnkuIFRoZSBudW1iZXIgb2Ygd2luZG93cyBhdmFpbGFibGUgYW5kIHRoZSBhY2Nlc3MgbW9kZXMgdGhhdCBjYW4gYmUKLXVzZWQgaXMgZGVwZW5kYW50IG9uIHRoZSB1bmRlcmx5aW5nIGNoaXBzZXQuIEEgd2luZG93IG11c3QgYmUgY29uZmlndXJlZCBiZWZvcmUKK3VzZWQgaXMgZGVwZW5kZW50IG9uIHRoZSB1bmRlcmx5aW5nIGNoaXBzZXQuIEEgd2luZG93IG11c3QgYmUgY29uZmlndXJlZCBiZWZvcmUKIGl0IGNhbiBiZSB1c2VkLgogCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvS2NvbmZpZyBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvS2NvbmZpZwppbmRleCAwNjFlNzMwLi5jM2JhNjkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU1L0tjb25maWcKKysrIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS9LY29uZmlnCkBAIC0xLDYgKzEsNiBAQAogY29uZmlnIFZUNjY1NQogICAgdHJpc3RhdGUgIlZJQSBUZWNobm9sb2dpZXMgVlQ2NjU1IHN1cHBvcnQiCi0gICBkZXBlbmRzIG9uIFBDSSAmJiBXTEFOCisgICBkZXBlbmRzIG9uIFBDSSAmJiBXTEFOICYmIG0KICAgIHNlbGVjdCBXSVJFTEVTU19FWFQKICAgIHNlbGVjdCBXRVhUX1BSSVYKICAgIC0tLWhlbHAtLS0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvY2FyZC5jIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS9jYXJkLmMKaW5kZXggOTUxYTNhOC4uMjcyMWUwNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS9jYXJkLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS9jYXJkLmMKQEAgLTExODYsNyArMTE4Niw3IEBACiAgICAgICAgICAgICB3RHVyYXRpb24gKz0gMTsgLy8gMSBUVSBmb3IgY2hhbm5lbCBzd2l0Y2hpbmcKIAogICAgICAgICAgICAgaWYgKChMT0RXT1JEKHF3U3RhcnRUU0YpID09IDApICYmIChISURXT1JEKHF3U3RhcnRUU0YpID09IDApKSB7Ci0gICAgICAgICAgICAgICAgLy8gc3RhcnQgaW1lZGlhdGVseSBieSBzZXR0aW5nIHN0YXJ0IFRTRiA9PSBjdXJyZW50IFRTRiArIDIgVFUKKyAgICAgICAgICAgICAgICAvLyBzdGFydCBpbW1lZGlhdGVseSBieSBzZXR0aW5nIHN0YXJ0IFRTRiA9PSBjdXJyZW50IFRTRiArIDIgVFUKICAgICAgICAgICAgICAgICBMT0RXT1JEKHF3U3RhcnRUU0YpID0gTE9EV09SRChxd0N1cnJUU0YpICsgMjA0ODsKICAgICAgICAgICAgICAgICBISURXT1JEKHF3U3RhcnRUU0YpID0gSElEV09SRChxd0N1cnJUU0YpOwogICAgICAgICAgICAgICAgIGlmIChMT0RXT1JEKHF3Q3VyclRTRikgPiBMT0RXT1JEKHF3U3RhcnRUU0YpKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU1L2RldmljZV9tYWluLmMgYi9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU1L2RldmljZV9tYWluLmMKaW5kZXggZWZhZjE5Yi4uYWQzOWM4NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS9kZXZpY2VfbWFpbi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvZGV2aWNlX21haW4uYwpAQCAtMTM3LDcgKzEzNyw3IEBACiAvKiBJUF9ieXRlX2FsaWduW10gaXMgdXNlZCBmb3IgSVAgaGVhZGVyIHVuc2lnbmVkIGxvbmcgYnl0ZSBhbGlnbmVkCiAgICAwOiBpbmRpY2F0ZSB0aGUgSVAgaGVhZGVyIHdvbid0IGJlIHVuc2lnbmVkIGxvbmcgYnl0ZSBhbGlnbmVkLihEZWZhdWx0KSAuCiAgICAxOiBpbmRpY2F0ZSB0aGUgSVAgaGVhZGVyIHdpbGwgYmUgdW5zaWduZWQgbG9uZyBieXRlIGFsaWduZWQuCi0gICAgICBJbiBzb21lIGVudmlyb21lbnQsIHRoZSBJUCBoZWFkZXIgc2hvdWxkIGJlIHVuc2lnbmVkIGxvbmcgYnl0ZSBhbGlnbmVkLAorICAgICAgSW4gc29tZSBlbnZpcm9ubWVudCwgdGhlIElQIGhlYWRlciBzaG91bGQgYmUgdW5zaWduZWQgbG9uZyBieXRlIGFsaWduZWQsCiAgICAgICBvciB0aGUgcGFja2V0IHdpbGwgYmUgZHJvcGVkIHdoZW4gd2UgcmVjZWl2ZSBpdC4gKGVnOiBJUFZTKQogKi8KIERFVklDRV9QQVJBTShJUF9ieXRlX2FsaWduLCJFbmFibGUgSVAgaGVhZGVyIGR3b3JkIGFsaWduZWQiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvd2NtZC5jIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS93Y21kLmMKaW5kZXggYWJkNjc0NS4uYzMwMTcwYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS93Y21kLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1NS93Y21kLmMKQEAgLTU4Nyw3ICs1ODcsNyBAQAogICAgICAgICAgICAgaWYgKChwTWdtdC0+ZUN1cnJNb2RlID09IFdNQUNfTU9ERV9FU1NfU1RBKSAmJiAocE1nbXQtPmVDdXJyU3RhdGUgPT0gV01BQ19TVEFURV9KT0lOVEVEKSkgewogCiAJCS8vIENhbGwgbWdyIHRvIGJlZ2luIHRoZSBkZWF1dGhlbnRpY2F0aW9uCi0gICAgICAgICAgICAgICAgLy8gcmVhc29uID0gKDMpIGJlYWN1c2Ugc3RhIGhhcyBsZWZ0IEVTUworICAgICAgICAgICAgICAgIC8vIHJlYXNvbiA9ICgzKSBiZWNhdXNlIHN0YSBoYXMgbGVmdCBFU1MKICAgICAgICAgICAgICAgICBpZiAocE1nbXQtPmVDdXJyU3RhdGU+PSBXTUFDX1NUQVRFX0FVVEgpIHsKICAgICAgICAgICAgICAgICAgICAgdk1nckRlQXV0aGVuQmVnaW5TdGEoKHZvaWQgKilwRGV2aWNlLCBwTWdtdCwgcE1nbXQtPmFieUN1cnJCU1NJRCwgKDMpLCAmU3RhdHVzKTsKICAgICAgICAgICAgICAgICB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU1L3dtZ3IuaCBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvd21nci5oCmluZGV4IDE0MWU4MGIuLmUzYWU1NjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvd21nci5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTUvd21nci5oCkBAIC0yMjAsNyArMjIwLDcgQEAKICovCiAKIAotLy8gVHggTWFuYWdtZW50IFBhY2tldCBkZXNjcmlwdG9yCisvLyBUeCBNYW5hZ2VtZW50IFBhY2tldCBkZXNjcmlwdG9yCiB0eXBlZGVmIHN0cnVjdCB0YWdTVHhNZ210UGFja2V0IHsKIAogICAgIFBVV0xBTl84MDIxMUhEUiAgICAgcDgwMjExSGVhZGVyOwpAQCAtMjMwLDcgKzIzMCw3IEBACiB9IFNUeE1nbXRQYWNrZXQsICpQU1R4TWdtdFBhY2tldDsKIAogCi0vLyBSeCBNYW5hZ21lbnQgUGFja2V0IGRlc2NyaXB0b3IKKy8vIFJ4IE1hbmFnZW1lbnQgUGFja2V0IGRlc2NyaXB0b3IKIHR5cGVkZWYgc3RydWN0IHRhZ1NSeE1nbXRQYWNrZXQgewogCiAgICAgUFVXTEFOXzgwMjExSERSICAgICBwODAyMTFIZWFkZXI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU2L0tjb25maWcgYi9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU2L0tjb25maWcKaW5kZXggYTQ0MWJhNS4uZjg5YWIyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3Z0NjY1Ni9LY29uZmlnCisrKyBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTYvS2NvbmZpZwpAQCAtMSw2ICsxLDYgQEAKIGNvbmZpZyBWVDY2NTYKIAl0cmlzdGF0ZSAiVklBIFRlY2hub2xvZ2llcyBWVDY2NTYgc3VwcG9ydCIKLQlkZXBlbmRzIG9uIFVTQiAmJiBXTEFOCisJZGVwZW5kcyBvbiBVU0IgJiYgV0xBTiAmJiBtCiAJc2VsZWN0IFdJUkVMRVNTX0VYVAogCXNlbGVjdCBXRVhUX1BSSVYKIAlzZWxlY3QgRldfTE9BREVSCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU2L3J4dHguYyBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTYvcnh0eC5jCmluZGV4IDhmMTg1NzguLjUxODVkNjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy92dDY2NTYvcnh0eC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy92dDY2NTYvcnh0eC5jCkBAIC0xOTM4LDcgKzE5MzgsNyBAQAogICogIE91dDoKICAqICAgICAgbm9uZQogICoKLSAqIFJldHVybiBWYWx1ZTogQ01EX1NUQVRVU19QRU5ESU5HIGlmIE1BQyBUeCByZXNvdXJjZSBhdmFsaWFibGU7IG90aGVyd2lzZSBGQUxTRQorICogUmV0dXJuIFZhbHVlOiBDTURfU1RBVFVTX1BFTkRJTkcgaWYgTUFDIFR4IHJlc291cmNlIGF2YWlsYWJsZTsgb3RoZXJ3aXNlIEZBTFNFCiAgKgogLSovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy92dDY2NTYvd2NtZC5jIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1Ni93Y21kLmMKaW5kZXggYjgzYjY2MC4uMDE5ZmI1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3Z0NjY1Ni93Y21kLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3Z0NjY1Ni93Y21kLmMKQEAgLTQyMSw3ICs0MjEsNyBAQAogICAgICAgICAgICAgICAgICAgICBwTWdtdC0+ZVNjYW5TdGF0ZSA9IFdNQUNfSVNfU0NBTk5JTkc7CiAgICAgICAgICAgICAgICAgICAgIHBEZXZpY2UtPmJ5U2NhbkJCVHlwZSA9IHBEZXZpY2UtPmJ5QkJUeXBlOyAgLy9sdWNhcwogICAgICAgICAgICAgICAgICAgICBwRGV2aWNlLT5iU3RvcERhdGFQa3QgPSBUUlVFOwotICAgICAgICAgICAgICAgICAgICAvLyBUdXJuIG9mZiBSQ1JfQlNTSUQgZmlsdGVyIGV2ZXJ5dGltZQorICAgICAgICAgICAgICAgICAgICAvLyBUdXJuIG9mZiBSQ1JfQlNTSUQgZmlsdGVyIGV2ZXJ5IHRpbWUKICAgICAgICAgICAgICAgICAgICAgTUFDdlJlZ0JpdHNPZmYocERldmljZSwgTUFDX1JFR19SQ1IsIFJDUl9CU1NJRCk7CiAgICAgICAgICAgICAgICAgICAgIHBEZXZpY2UtPmJ5UnhNb2RlICY9IH5SQ1JfQlNTSUQ7CiAKQEAgLTYwNCw3ICs2MDQsNyBAQAogICAgICAgICAgICAgLy8gaWYgSW5mcmEgbW9kZQogICAgICAgICAgICAgaWYgKChwTWdtdC0+ZUN1cnJNb2RlID09IFdNQUNfTU9ERV9FU1NfU1RBKSAmJiAocE1nbXQtPmVDdXJyU3RhdGUgPT0gV01BQ19TVEFURV9KT0lOVEVEKSkgewogICAgICAgICAgICAgICAgIC8vIENhbGwgbWdyIHRvIGJlZ2luIHRoZSBkZWF1dGhlbnRpY2F0aW9uCi0gICAgICAgICAgICAgICAgLy8gcmVhc29uID0gKDMpIGJlYWN1c2Ugc3RhIGhhcyBsZWZ0IEVTUworICAgICAgICAgICAgICAgIC8vIHJlYXNvbiA9ICgzKSBiZWNhdXNlIHN0YSBoYXMgbGVmdCBFU1MKIAkgICAgICBpZiAocE1nbXQtPmVDdXJyU3RhdGUgPj0gV01BQ19TVEFURV9BVVRIKSB7CiAJCXZNZ3JEZUF1dGhlbkJlZ2luU3RhKCh2b2lkICopcERldmljZSwKIAkJCQkgICAgIHBNZ210LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3Z0NjY1Ni93bWdyLmggYi9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU2L3dtZ3IuaAppbmRleCA1OTRmM2E4Li4xM2RmYjNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU2L3dtZ3IuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdnQ2NjU2L3dtZ3IuaApAQCAtMjE4LDcgKzIxOCw3IEBACiAKIAogCi0vLyBUeCBNYW5hZ21lbnQgUGFja2V0IGRlc2NyaXB0b3IKKy8vIFR4IE1hbmFnZW1lbnQgUGFja2V0IGRlc2NyaXB0b3IKIHR5cGVkZWYgc3RydWN0IHRhZ1NUeE1nbXRQYWNrZXQgewogCiAgICAgUFVXTEFOXzgwMjExSERSICAgICBwODAyMTFIZWFkZXI7CkBAIC0yMjgsNyArMjI4LDcgQEAKIH0gU1R4TWdtdFBhY2tldCwgKlBTVHhNZ210UGFja2V0OwogCiAKLS8vIFJ4IE1hbmFnbWVudCBQYWNrZXQgZGVzY3JpcHRvcgorLy8gUnggTWFuYWdlbWVudCBQYWNrZXQgZGVzY3JpcHRvcgogdHlwZWRlZiBzdHJ1Y3QgdGFnU1J4TWdtdFBhY2tldCB7CiAKICAgICBQVVdMQU5fODAyMTFIRFIgICAgIHA4MDIxMUhlYWRlcjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzZG1hLmMgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc2RtYS5jCmluZGV4IDE2YjhlYzEuLmM0NjFkNGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzZG1hLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcGkvc3JjL2N5YXNkbWEuYwpAQCAtMTA4Miw3ICsxMDgyLDcgQEAKIAkvKgogCSAqIGlmIHRoZSBkYXRhIHJlY2VpdmVkIGV4Y2VlZHMgdGhlIHNpemUgb2YgdGhlIERNQSBidWZmZXIsCiAJICogY2xpcCB0aGUgZGF0YSB0byB0aGUgc2l6ZSBvZiB0aGUgYnVmZmVyLiAgdGhpcyBjYW4gbGVhZAotCSAqIHRvIGxvb3Npbmcgc29tZSBkYXRhLCBidXQgaXMgbm90IGRpZmZlcmVudCB0aGFuIGRvaW5nCisJICogdG8gbG9zaW5nIHNvbWUgZGF0YSwgYnV0IGlzIG5vdCBkaWZmZXJlbnQgdGhhbiBkb2luZwogCSAqIG5vbi1wYWNrZXQgcmVhZHMgb24gdGhlIG90aGVyIGVuZHBvaW50cy4KIAkgKi8KIAlpZiAoZHNpemUgPiBkbWFfcC0+c2l6ZSAtIGRtYV9wLT5vZmZzZXQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc2xlcDJwZXAuYyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbGVwMnBlcC5jCmluZGV4IDYwYjZmMzUuLjc2ODIxZTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbGVwMnBlcC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbGVwMnBlcC5jCkBAIC0xMjYsNyArMTI2LDcgQEAKIAljeV9hc19waHlzaWNhbF9lbmRwb2ludF9zdGF0ZSBkZXNpcmVkOwogCiAJLyoKLQkgKiBub3RlLCB0aGVyZSBpcyBubyBlcnJvciBjaGVja2luZyBoZXJlIGJlY3Vhc2UKKwkgKiBub3RlLCB0aGVyZSBpcyBubyBlcnJvciBjaGVja2luZyBoZXJlIGJlY2F1c2UKIAkgKiBJU08gZXJyb3IgY2hlY2tpbmcgaGFwcGVucyB3aGVuIHRoZSBBUEkgaXMgY2FsbGVkLgogCSAqLwogCWZvciAoaSA9IDA7IGkgPCAxMDsgaSsrKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc2xvd2xldmVsLmMgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc2xvd2xldmVsLmMKaW5kZXggZDQzZGQ4NS4uOTZhODZkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcGkvc3JjL2N5YXNsb3dsZXZlbC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbG93bGV2ZWwuYwpAQCAtNDMyLDcgKzQzMiw3IEBACiAqIGlzIHJlY2VpdmVkLiAgV2hlbiBhIGNvbXBsZXRlIHJlcXVlc3QgaXMgcmVjZWl2ZWQsIHRoZSBjYWxsYmFjawogKiBhc3NvY2lhdGVkIHdpdGggcmVxdWVzdHMgb24gdGhhdCBjb250ZXh0IGlzIGNhbGxlZC4gIFdoZW4gYSBjb21wbGV0ZQogKiByZXNwb25zZSBpcyByZWNldmllZCwgdGhlIGNhbGxiYWNrIGFzc29jaWF0ZWQgd2l0aCB0aGUgcmVxdWVzdCB0aGF0Ci0qIGdlbmVyYXRlZCB0aGUgcmVwb25zZSBpcyBjYWxsZWQuCisqIGdlbmVyYXRlZCB0aGUgcmVzcG9uc2UgaXMgY2FsbGVkLgogKi8KIHZvaWQKIGN5X2FzX21haWxfYm94X2ludGVycnVwdF9oYW5kbGVyKGN5X2FzX2RldmljZSAqZGV2X3ApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc21pc2MuYyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbWlzYy5jCmluZGV4IDc4NTI0MTAuLjQ1NjRmYzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbWlzYy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbWlzYy5jCkBAIC00MjgsNyArNDI4LDcgQEAKIAkJCQlpZiAodiAmIENZX0FTX01FTV9QMF9WTV9TRVRfQ0ZHTU9ERSkKIAkJCQkJY3lfYXNfaGFsX3ByaW50X21lc3NhZ2UoCiAJCQkJCSJpbml0aWFsaXphdGlvbiBtZXNzYWdlICIKLQkJCQkJInJlY2lldmVkLCBidXQgY29uZmlnIGJpdCAiCisJCQkJCSJyZWNlaXZlZCwgYnV0IGNvbmZpZyBiaXQgIgogCQkJCQkic3RpbGwgc2V0XG4iKTsKIAogCQkJCXYgPSBjeV9hc19oYWxfcmVhZF9yZWdpc3RlcihkZXZfcC0+dGFnLApAQCAtNDM2LDcgKzQzNiw3IEBACiAJCQkJaWYgKCh2ICYgQ1lfQVNfTUVNX1JTVF9SU1RDTVBUKSA9PSAwKQogCQkJCQljeV9hc19oYWxfcHJpbnRfbWVzc2FnZSgKIAkJCQkJImluaXRpYWxpemF0aW9uIG1lc3NhZ2UgIgotCQkJCQkicmVjaWV2ZWQsIGJ1dCByZXNldCBjb21wbGV0ZSAiCisJCQkJCSJyZWNlaXZlZCwgYnV0IHJlc2V0IGNvbXBsZXRlICIKIAkJCQkJImJpdCBzdGlsbCBub3Qgc2V0XG4iKTsKIAkJCX0KIAkJCWJyZWFrOwpAQCAtMjM4MSw3ICsyMzgxLDcgQEAKIAkvKgogCSAqIHJlbGVhc2UgdGhlIHdlc3QgYnJpZGdlIG1pY3JvLV9jb250cm9sbGVyIGZyb20gcmVzZXQsCiAJICogc28gdGhhdCBmaXJtd2FyZSBpbml0aWFsaXphdGlvbiBjYW4gY29tcGxldGUuIHRoZSBhdHRlbXB0Ci0JICogdG8gcmVsZWFzZSBhbnRpb2NoIHJlc2V0IGlzIG1hZGUgdXB0byA4IHRpbWVzLgorCSAqIHRvIHJlbGVhc2UgYW50aW9jaCByZXNldCBpcyBtYWRlIHVwIHRvIDggdGltZXMuCiAJICovCiAJdiA9IDB4MDM7CiAJY291bnQgPSAweDA4OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcGkvc3JjL2N5YXNtdHAuYyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzbXRwLmMKaW5kZXggMzY4OTg0Ni4uODU5ODM2NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcGkvc3JjL2N5YXNtdHAuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc210cC5jCkBAIC0zNDYsNyArMzQ2LDcgQEAKIAogCQlkZXZfcC0+bXRwX2V2ZW50X2NiID0gZXZlbnRfY19iOwogCQkvKgotCQkqIHdlIHJlZ2lzdGVyIGhlcmUgYmVjdWFzZSB0aGUgc3RhcnQgcmVxdWVzdCBtYXkgY2F1c2UKKwkJKiB3ZSByZWdpc3RlciBoZXJlIGJlY2F1c2UgdGhlIHN0YXJ0IHJlcXVlc3QgbWF5IGNhdXNlCiAJCSogZXZlbnRzIHRvIG9jY3VyIGJlZm9yZSB0aGUgcmVzcG9uc2UgdG8gdGhlIHN0YXJ0IHJlcXVlc3QuCiAJCSovCiAJCWN5X2FzX2xsX3JlZ2lzdGVyX3JlcXVlc3RfY2FsbGJhY2soZGV2X3AsCkBAIC00MjQsNyArNDI0LDcgQEAKIAkJZ290byBkZXN0cm95OwogCiAJLyoKLQkqIHdlIHN1Y2Vzc2Z1bGx5IHNodXRkb3duIHRoZSBzdGFjaywgc28gZGVjcmVtZW50CisJKiB3ZSBzdWNjZXNzZnVsbHkgc2h1dGRvd24gdGhlIHN0YWNrLCBzbyBkZWNyZW1lbnQKIAkqIHRvIG1ha2UgdGhlIGNvdW50IHplcm8uCiAJKi8KIAlkZXZfcC0+bXRwX2NvdW50LS07CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc3N0b3JhZ2UuYyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzc3RvcmFnZS5jCmluZGV4IDI0NTE0MDQuLjdhYmQ2YTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzc3RvcmFnZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzc3RvcmFnZS5jCkBAIC0xNzczLDcgKzE3NzMsNyBAQAogCWlmICh1bml0ID4gMjU1KQogCQlyZXR1cm4gQ1lfQVNfRVJST1JfTk9fU1VDSF9VTklUOwogCi0JLyogV2UgYXJlIHN1cHBvc2VkIHRvIHJldHVybiBzdWNlc3MgaWYgdGhlIG51bWJlciBvZgorCS8qIFdlIGFyZSBzdXBwb3NlZCB0byByZXR1cm4gc3VjY2VzcyBpZiB0aGUgbnVtYmVyIG9mCiAJKiBibG9ja3MgaXMgemVybwogCSovCiAJaWYgKG51bV9ibG9ja3MgPT0gMCkgewpAQCAtMTk2OSw3ICsxOTY5LDcgQEAKIAlpZiAoY3lfYXNfZGV2aWNlX2lzX3VzYl9hc3luY19wZW5kaW5nKGRldl9wLCA2KSkKIAkJcmV0dXJuIENZX0FTX0VSUk9SX0FTWU5DX1BFTkRJTkc7CiAKLQkvKiBXZSBhcmUgc3VwcG9zZWQgdG8gcmV0dXJuIHN1Y2VzcyBpZiB0aGUgbnVtYmVyIG9mCisJLyogV2UgYXJlIHN1cHBvc2VkIHRvIHJldHVybiBzdWNjZXNzIGlmIHRoZSBudW1iZXIgb2YKIAkqIGJsb2NrcyBpcyB6ZXJvCiAJKi8KIAlpZiAobnVtX2Jsb2NrcyA9PSAwKQpAQCAtMzI4NSw3ICszMjg1LDcgQEAKIAlpZiAoY2FsbGJhY2sgPT0gMCkKIAkJcmV0dXJuIENZX0FTX0VSUk9SX05VTExfQ0FMTEJBQ0s7CiAKLQkvKiBXZSBhcmUgc3VwcG9zZWQgdG8gcmV0dXJuIHN1Y2VzcyBpZiB0aGUgbnVtYmVyIG9mCisJLyogV2UgYXJlIHN1cHBvc2VkIHRvIHJldHVybiBzdWNjZXNzIGlmIHRoZSBudW1iZXIgb2YKIAkgKiBibG9ja3MgaXMgemVybwogCSAqLwogCWlmICgoKG1pc2NfYnVmJkNZX1NESU9fQkxPQ0tNT0RFKSAhPSAwKSAmJiAoYXJndW1lbnQgPT0gMCkpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzdXNiLmMgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FwaS9zcmMvY3lhc3VzYi5jCmluZGV4IDkyZWE0MjUuLjFiNTVlNjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXBpL3NyYy9jeWFzdXNiLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcGkvc3JjL2N5YXN1c2IuYwpAQCAtNzM5LDcgKzczOSw3IEBACiAJCWN5X2FzX3VzYl9yZXNldF9lX3AwX3N0YXRlKGRldl9wKTsKIAogCQkvKgotCQkqIHdlIHJlZ2lzdGVyIGhlcmUgYmVjdWFzZSB0aGUgc3RhcnQgcmVxdWVzdCBtYXkgY2F1c2UKKwkJKiB3ZSByZWdpc3RlciBoZXJlIGJlY2F1c2UgdGhlIHN0YXJ0IHJlcXVlc3QgbWF5IGNhdXNlCiAJCSogZXZlbnRzIHRvIG9jY3VyIGJlZm9yZSB0aGUgcmVzcG9uc2UgdG8gdGhlIHN0YXJ0IHJlcXVlc3QuCiAJCSovCiAJCWN5X2FzX2xsX3JlZ2lzdGVyX3JlcXVlc3RfY2FsbGJhY2soZGV2X3AsCkBAIC04NjcsNyArODY3LDcgQEAKIAkJZ290byBkZXN0cm95OwogCiAJLyoKLQkgKiB3ZSBzdWNlc3NmdWxseSBzaHV0ZG93biB0aGUgc3RhY2ssIHNvCisJICogd2Ugc3VjY2Vzc2Z1bGx5IHNodXRkb3duIHRoZSBzdGFjaywgc28KIAkgKiBkZWNyZW1lbnQgdG8gbWFrZSB0aGUgY291bnQgemVyby4KIAkgKi8KIAljeV9hc191c2JfY2xlYW51cChkZXZfcCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FyY2gvYXJtL21hY2gtb21hcDIvY3lhc2hhbG9tYXBfa2VybmVsLmMgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FyY2gvYXJtL21hY2gtb21hcDIvY3lhc2hhbG9tYXBfa2VybmVsLmMKaW5kZXggMjFjZGIwNi4uM2JjZWRjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcmNoL2FybS9tYWNoLW9tYXAyL2N5YXNoYWxvbWFwX2tlcm5lbC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jeWFzaGFsb21hcF9rZXJuZWwuYwpAQCAtODcsNyArODcsNyBAQAogCiAKIC8qCi0gKiBGb3IgcGVyZm9ybWFuY2UgcmVhc29ucywgd2UgaGFuZGxlIHN0b3JhZ2UgZW5kcG9pbnQgdHJhbnNmZXJzIHVwdG8gNCBLQgorICogRm9yIHBlcmZvcm1hbmNlIHJlYXNvbnMsIHdlIGhhbmRsZSBzdG9yYWdlIGVuZHBvaW50IHRyYW5zZmVycyB1cCB0byA0IEtCCiAgKiB3aXRoaW4gdGhlIEhBTCBpdHNlbGYuCiAgKi8KICAjZGVmaW5lIENZQVNTVE9SQUdFX1dSSVRFX0VQX05VTQkoNCkKQEAgLTEwOCwxMiArMTA4LDEyIEBACiAJCQkJKChlcCkgPT0gNikgfHwgKChlcCkgPT0gOCkpCiAKIC8qCi0gKiBwZXJzaXN0YW50LCBzdG9yZXMgY3VycmVudCBHUE1DIGludGVyZmFjZSBjZmcgbW9kZQorICogcGVyc2lzdGVudCwgc3RvcmVzIGN1cnJlbnQgR1BNQyBpbnRlcmZhY2UgY2ZnIG1vZGUKICAqLwogc3RhdGljIHVpbnQ4X3QgcG5hbmRfMTZiaXQ7CiAKIC8qCi0gKiBrZWVwIHByb2Nlc3NpbmcgbmV3IFdCIERSUSBpbiBJU1IgdW50aWxsIGFsbCBoYW5kbGVkIChwZXJmb3JtYW5jZSBmZWF0dXJlKQorICoga2VlcCBwcm9jZXNzaW5nIG5ldyBXQiBEUlEgaW4gSVNSIHVudGlsIGFsbCBoYW5kbGVkIChwZXJmb3JtYW5jZSBmZWF0dXJlKQogICovCiAjZGVmaW5lIFBST0NFU1NfTVVMVElQTEVfRFJRX0lOX0lTUiAoMSkKIApAQCAtMTU3LDcgKzE1Nyw3IEBACiAJICogZG1hX3hmZXJfc3ogLSBzaXplIG9mIHRoZSBuZXh0IGRtYSB4ZmVyIG9uIFAgcG9ydAogCSAqIHNlZ194ZmVyX2NudCAtICBjb3VudHMgeGZlcmVkIGJ5dGVzIGZvciBpbiBjdXJyZW50IHNnX2xpc3QKIAkgKgkJbWVtb3J5IHNlZ21lbnQKLQkgKiByZXFfeGZlcl9jbnQgLSB0b3RhbCBudW1iZXIgb2YgYnl0ZXMgdHJhbnNmZXJlZCBzbyBmYXIgaW4KKwkgKiByZXFfeGZlcl9jbnQgLSB0b3RhbCBudW1iZXIgb2YgYnl0ZXMgdHJhbnNmZXJyZWQgc28gZmFyIGluCiAJICoJCWN1cnJlbnQgcmVxdWVzdAogCSAqIHJlcV9sZW5ndGggLSB0b3RhbCByZXF1ZXN0IGxlbmd0aAogCSAqLwpAQCAtMjE2MCw3ICsyMTYwLDcgQEAKIC8qCiAgKiBUaGlzIGZ1bmN0aW9uIGlzIGV4cGVjdGVkIHRvIGNyZWF0ZSBhIHNsZWVwIGNoYW5uZWwuCiAgKiBUaGUgZGF0YSBzdHJ1Y3R1cmUgdGhhdCByZXByZXNlbnRzIHRoZSBzbGVlcCBjaGFubmVsIG9iamVjdAotICogc2xlZXAgY2hhbm5lbCAod2hpY2ggaXMgTGludXggIndhaXRfcXVldWVfaGVhZF90IHdxIiBmb3IgdGhpcyBwYXRpY3VsYXIgSEFMKQorICogc2xlZXAgY2hhbm5lbCAod2hpY2ggaXMgTGludXggIndhaXRfcXVldWVfaGVhZF90IHdxIiBmb3IgdGhpcyBwYXJ0aWN1bGFyIEhBTCkKICAqIHBhc3NlZCBhcyBhIHBvaW50ZXIsIGFuZCBhbGxwb2NhdGVkIGJ5IHRoZSBjYWxsZXIKICAqICh0eXBpY2FsbHkgYXMgYSBsb2NhbCB2YXIgb24gdGhlIHN0YWNrKSAiQ3JlYXRlIiB3b3JkIHNob3VsZCByZWFkIGFzCiAgKiAiU2xlZXBPbiIsIHRoaXMgZnVuYyBkb2Vzbid0IGFjdHVhbGx5IGNyZWF0ZSBhbnl0aGluZwpAQCAtMjM2NCw3ICsyMzY0LDcgQEAKIAkgKi8KIAljeV9hc19oYWxfZ3BtY19lbmFibGVfMTZiaXRfYnVzKGN5X3RydWUpOwogI2Vsc2UKLSAgIC8qIEFzdG9yaWEgYW5kIEdQTUMgYXJlIGFscmVhZHkgaW4gOCBiaXQgbW9kZSwganN1dCBpbml0aWFsaXplIFBOQU5EX0NGRyAqLworICAgLyogQXN0b3JpYSBhbmQgR1BNQyBhcmUgYWxyZWFkeSBpbiA4IGJpdCBtb2RlLCBqdXN0IGluaXRpYWxpemUgUE5BTkRfQ0ZHICovCiAJYXN0X3BfbmFuZF9jYXNkaV93cml0ZShDWV9BU19NRU1fUE5BTkRfQ0ZHLCAweDAwMDApOwogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvbWFjaC93ZXN0YnJpZGdlL3dlc3RicmlkZ2Utb21hcDMtcG5hbmQtaGFsL2N5YXNoYWxvbWFwX2tlcm5lbC5oIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9tYWNoL3dlc3RicmlkZ2Uvd2VzdGJyaWRnZS1vbWFwMy1wbmFuZC1oYWwvY3lhc2hhbG9tYXBfa2VybmVsLmgKaW5kZXggODBkZDUzMC4uNjQyNmVhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9tYWNoL3dlc3RicmlkZ2Uvd2VzdGJyaWRnZS1vbWFwMy1wbmFuZC1oYWwvY3lhc2hhbG9tYXBfa2VybmVsLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9tYWNoL3dlc3RicmlkZ2Uvd2VzdGJyaWRnZS1vbWFwMy1wbmFuZC1oYWwvY3lhc2hhbG9tYXBfa2VybmVsLmgKQEAgLTIwLDcgKzIwLDcgQEAKICovCiAKIC8qCi0gKiBUaGlzIGZpbGUgY29udGFpbnMgdGhlIGRlZmludGlvbiBvZiB0aGUgaGFyZHdhcmUgYWJzdHJhY3Rpb24KKyAqIFRoaXMgZmlsZSBjb250YWlucyB0aGUgZGVmaW5pdGlvbiBvZiB0aGUgaGFyZHdhcmUgYWJzdHJhY3Rpb24KICAqIGxheWVyIG9uIE9NQVAzNDMwIHRhbGtpbmcgdG8gdGhlIFdlc3QgQnJpZGdlIEFzdG9yaWEgZGV2aWNlCiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9tYWNoL3dlc3RicmlkZ2Uvd2VzdGJyaWRnZS1vbWFwMy1wbmFuZC1oYWwvY3lhc21lbW1hcC5oIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9tYWNoL3dlc3RicmlkZ2Uvd2VzdGJyaWRnZS1vbWFwMy1wbmFuZC1oYWwvY3lhc21lbW1hcC5oCmluZGV4IDNlZWUxOTIuLjQ2ZjA2ZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvbWFjaC93ZXN0YnJpZGdlL3dlc3RicmlkZ2Utb21hcDMtcG5hbmQtaGFsL2N5YXNtZW1tYXAuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL21hY2gvd2VzdGJyaWRnZS93ZXN0YnJpZGdlLW9tYXAzLXBuYW5kLWhhbC9jeWFzbWVtbWFwLmgKQEAgLTUxLDcgKzUxLDcgQEAKICAqIAkJCQkJCQlHUE1DX0FERFIKICAqCQkJCQkJCVtBODpBMV0tPnVwRFs3OjBdCiAgKiBJTlQjCS1HUE1DX25XUF9HUElPXzYyCi0gKiBEQUNLCS1OL0MJCQkJIG5vdCBjb25lY3RlZAorICogREFDSwktTi9DCQkJCSBub3QgY29ubmVjdGVkCiAgKiBXQUtFVVAtR1BJT18xNjcKICAqIFJFU0VULUdQSU9fMTI2CiAgKiBSL0IJLUdQTUNfV0FJVDJfR1BJT182NApAQCAtMTA4LDcgKzEwOCw3IEBACiAJICoJCQkJCXdpbGwgYmUgbW9uaXRvcmVkCiAJICogUEZfRU5fRU5HSU5FIC0gMS0gRU5BQkxFUyBFTkdJTkUsIGJ1dCBpdCBuZWVkcyB0byBiZSBzdGFydGVkIGFmdGVyCiAJICoJCQkJCXRoYXQgQyBjdHJsIHJlZyBiaXQgMAotCSAqIFBGX0ZJRk9fVEhSRVNIT0xEIC0gRklGTyB0aHJlc2hob2xkIGluIG51bWJlciBvZiBCVVMoOCBvciAxNikgd29yZHMKKwkgKiBQRl9GSUZPX1RIUkVTSE9MRCAtIEZJRk8gdGhyZXNob2xkIGluIG51bWJlciBvZiBCVVMoOCBvciAxNikgd29yZHMKIAkgKiBQRl9XRUlHSFRFRF9QUklPICAtIE5VTSBvZiBjeWNsZXMgZ3JhbnRlZCB0byBQRkUgaWYgUk5EX1JPQklOCiAJICoJCQkJCXByaW9yaXRpemF0aW9uIGlzIGVuYWJsZWQKIAkgKiBQRl9ST1VORF9ST0JJTiAgLSBpZiBlbmFibGVkLCBnaXZlcyBwcmlvcml0eSB0byBvdGhlciBDUywgYnV0CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2Jsb2NrL2N5YXNibGtkZXZfcXVldWUuYyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYmxvY2svY3lhc2Jsa2Rldl9xdWV1ZS5jCmluZGV4IDBiYmI4YTMuLmQxOTk2YTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYmxvY2svY3lhc2Jsa2Rldl9xdWV1ZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvYmxvY2svY3lhc2Jsa2Rldl9xdWV1ZS5jCkBAIC0yMjIsNyArMjIyLDcgQEAKIAkJCWNvbnRpbnVlOwogCQl9CiAKLQkJLyogbmV3IHJlcSByZWNpZXZlZCwgaXNzdWUgaXQgdG8gdGhlIGRyaXZlciAgKi8KKwkJLyogbmV3IHJlcSByZWNlaXZlZCwgaXNzdWUgaXQgdG8gdGhlIGRyaXZlciAgKi8KIAkJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKTsKIAogCQkjaWZuZGVmIFdFU1RCUklER0VfTkRFQlVHCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2dhZGdldC9jeWFzZ2FkZ2V0LmMgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2dhZGdldC9jeWFzZ2FkZ2V0LmMKaW5kZXggZGVmYTA1Yy4uYmU4NTFjYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9nYWRnZXQvY3lhc2dhZGdldC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvZ2FkZ2V0L2N5YXNnYWRnZXQuYwpAQCAtNTg3LDYgKzU4Nyw3IEBACiAJCQkiY3lfYXNfdXNiX2VuZF9wb2ludF9jb25maWcgRVAgJXMgbWlzbWF0Y2ggIgogCQkJIm9uIGVuYWJsZWRcbiIsIGFuX2VwLT51c2JfZXBfaW5zdC5uYW1lKTsKIAkJI2VuZGlmCisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFuX2Rldi0+bG9jaywgZmxhZ3MpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNkZXZpY2UuaCBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNkZXZpY2UuaAppbmRleCAwYzA3MjZiNi4uNjQ1MmE5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2RldmljZS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNkZXZpY2UuaApAQCAtMTE5LDcgKzExOSw3IEBACiAjZGVmaW5lIENZX0FTX1JFUVVFU1RfTElTVF9TVEFURV9RVUVVRUQgKDB4MDApCiAvKiBUaGUgcmVxdWVzdCBpcyBzZW50LCB3YWl0aW5nIGZvciByZXNwb25zZSAqLwogI2RlZmluZSBDWV9BU19SRVFVRVNUX0xJU1RfU1RBVEVfV0FJVElORyAoMHgwMSkKLS8qIFRoZSByZXNwb25zZSBoYXMgYmVlbiByZWNlaXZlZCwgcHJvY2Vzc2luZyByZXBvbnNlICovCisvKiBUaGUgcmVzcG9uc2UgaGFzIGJlZW4gcmVjZWl2ZWQsIHByb2Nlc3NpbmcgcmVzcG9uc2UgKi8KICNkZWZpbmUgQ1lfQVNfUkVRVUVTVF9MSVNUX1NUQVRFX1JFQ0VJVkVEICgweDAyKQogLyogVGhlIHJlcXVlc3QvcmVzcG9uc2UgaXMgYmVpbmcgY2FuY2VsZWQgKi8KICNkZWZpbmUgQ1lfQVNfUkVRVUVTVF9MSVNUX1NUQVRFX0NBTkNFTElORyAoMHgwMykKQEAgLTUxNyw3ICs1MTcsNyBAQAogCWN5X2FzX2xsX3JlcXVlc3RfbGlzdF9ub2RlICpyZXF1ZXN0X3F1ZXVlX3A7CiAJLyogVGhlIGxpc3Qgbm9kZSBpbiB0aGUgcmVxdWVzdCBxdWV1ZSAqLwogCWN5X2FzX2xsX3JlcXVlc3RfbGlzdF9ub2RlICpsYXN0X25vZGVfcDsKLQkvKiBJbmRleCB1cHRvIHdoaWNoIGRhdGEgaXMgc3RvcmVkLiAqLworCS8qIEluZGV4IHVwIHRvIHdoaWNoIGRhdGEgaXMgc3RvcmVkLiAqLwogCXVpbnQxNl90IHF1ZXVlX2luZGV4OwogCS8qIEluZGV4IHRvIHRoZSBuZXh0IHJlcXVlc3QgaW4gdGhlIHF1ZXVlLiAqLwogCXVpbnQxNl90IHJxdF9pbmRleDsKQEAgLTc2OCw3ICs3NjgsNyBAQAogCXVpbnQzMl90IG10cF9jb3VudDsKIAkvKiBUaGUgTVRQIGV2ZW50IGNhbGxiYWNrIHN1cHBsaWVkIGJ5IHRoZSBjbGllbnQgKi8KIAljeV9hc19tdHBfZXZlbnRfY2FsbGJhY2sgbXRwX2V2ZW50X2NiOwotCS8qIFRoZSBjdXJyZW50IGJsb2NrIHRhYmxlIHRvIGJlIHRyYW5zZmVyZWQgKi8KKwkvKiBUaGUgY3VycmVudCBibG9jayB0YWJsZSB0byBiZSB0cmFuc2ZlcnJlZCAqLwogCWN5X2FzX210cF9ibG9ja190YWJsZSAqdHBfYmxrX3RibDsKIAogCWN5X2FzX2NfYl9xdWV1ZSAqZnVuY19jYnNfbXRwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2RtYS5oIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2RtYS5oCmluZGV4IDhkYWI1ZTkuLjE2ZGM5ZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNkbWEuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzZG1hLmgKQEAgLTEwOCw3ICsxMDgsNyBAQAogICAgY29tcGxldGVzIGEgcmVxdWVzdGVkIERNQSBvcGVyYXRpb24uCiAKICAgIFJldHVybnMKLSAgIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGUgbW9kdWxlIGluaXRpYWxpemVkIHN1Y2Vzc2Z1bGx5CisgICBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIG1vZHVsZSBpbml0aWFsaXplZCBzdWNjZXNzZnVsbHkKICAgIENZX0FTX0VSUk9SX09VVF9PRl9NRU1PUlkgLSBtZW1vcnkgYWxsb2NhdGlvbiBmYWlsZWQgZHVyaW5nCiAJCWluaXRpYWxpemF0aW9uCiAgICBDWV9BU19FUlJPUl9BTFJFQURZX1JVTk5JTkcgLSB0aGUgRE1BIG1vZHVsZSB3YXMgYWxyZWFkeSBydW5uaW5nCkBAIC0xMzEsNyArMTMxLDcgQEAKICAgIHRoZW4gZnJlZWluZyB0aGUgcmVzb3VyY2VzIGFzc29jaWF0ZWQgd2l0aCBlYWNoIERNQSBlbmRwb2ludC4KIAogICAgUmV0dXJucwotICAgQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoZSBtb2R1bGUgc2h1dGRvd24gc3VjZXNzZnVsbHkKKyAgIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGUgbW9kdWxlIHNodXRkb3duIHN1Y2Nlc3NmdWxseQogICAgQ1lfQVNfRVJST1JfTk9UX1JVTk5JTkcgLSB0aGUgRE1BIG1vZHVsZSB3YXMgbm90IHJ1bm5pbmcKIAogICAgU2VlIEFsc28KQEAgLTE2MSw3ICsxNjEsNyBAQAogCiAgICBSZXR1cm5zCiAgICBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIHRyYWZmaWMgb24gdGhlIGVuZHBvaW50IGlzIGNhbmNlbGVkCi0Jc3VjZXNzZnVsbHkKKwlzdWNjZXNzZnVsbHkKIAogICAgU2VlIEFsc28KICovCkBAIC0yNjYsNyArMjY2LDcgQEAKICAgIHdpbGwgaGF2ZSB0byBtYWludGFpbiBhIGxpc3Qgb2Ygc2xlZXAgY2hhbm5lbHMgdG8gd2FrZS4KIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIHF1ZXVlIGhhcyBkcmFpbmVkIHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGUgcXVldWUgaGFzIGRyYWluZWQgc3VjY2Vzc2Z1bGx5CiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfRU5EUE9JTlQgLSB0aGUgZW5kcG9pbnQgZ2l2ZW4gaXMgbm90IHZhbGlkCiAgICAqIENZX0FTX0VSUk9SX05FU1RFRF9TTEVFUCAtIEN5QXNEbWFRdWV1ZVJlcXVlc3QoKSB3YXMgcmVxdWVzdGVkCiAgICAqCW9uIGFuIGVuZHBvaW50IHdoZXJlIEN5QXNEbWFRdWV1ZVJlcXVlc3Qgd2FzIGFscmVhZHkgY2FsbGVkCkBAIC0yOTUsNyArMjk1LDcgQEAKICAgIEN5QXNIYWxEbWFTZXR1cFJlYWQoKSBmdW5jdG9pbnMuCiAKICAgIFJldHVybnMKLSAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoZSB2YWx1ZSB3YXMgc2V0IHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGUgdmFsdWUgd2FzIHNldCBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfSU5WQUxJRF9TSVpFIC0gdGhlIHNpemUgdmFsdWUgd2FzIG5vdCB2YWxpZAogKi8KIGV4dGVybiBjeV9hc19yZXR1cm5fc3RhdHVzX3QKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNlcnIuaCBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNlcnIuaAppbmRleCBmNzhkNjAyLi4yY2QwYWYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzZXJyLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2Vyci5oCkBAIC0yOSw3ICsyOSw3IEBACiAqLwogCiAvKiBTdW1tYXJ5Ci0gICBUaGUgZnVuY3Rpb24gY29tcGxldGVkIHN1Y2Vzc2Z1bGx5CisgICBUaGUgZnVuY3Rpb24gY29tcGxldGVkIHN1Y2Nlc3NmdWxseQogKi8KICNkZWZpbmUgQ1lfQVNfRVJST1JfU1VDQ0VTUwkgKDApCiAKQEAgLTc5Niw3ICs3OTYsNyBAQAogICAgRGVzY3JpcHRpb24KICAgIFRoaXMgZXJyb3IgaXMgcmV0dXJuZWQgd2hlbiBhbiBvcGVyYXRpb24gaXMgYXR0ZW1wdGVkIHRoYXQgY2Fubm90IGJlCiAgICBjb21wbGV0ZWQgd2hpbGUgdGhlIFVTQiBzdGFjayBpcyBjb25uZWN0ZWQgdG8gYSBVU0IgaG9zdC4gIEluIG9yZGVyCi0gICB0byBzdWNlc3NmdWxseSBjb21wbGV0ZSB0aGUgZGVzaXJlZCBvcGVyYXRpb24sIEN5QXNVc2JEaXNjb25uZWN0KCkKKyAgIHRvIHN1Y2Nlc3NmdWxseSBjb21wbGV0ZSB0aGUgZGVzaXJlZCBvcGVyYXRpb24sIEN5QXNVc2JEaXNjb25uZWN0KCkKICAgIG11c3QgYmUgY2FsbGVkIHRvIGRpc2Nvbm5lY3QgZnJvbSB0aGUgaG9zdC4KICovCiAjZGVmaW5lIENZX0FTX0VSUk9SX1VTQl9DT05ORUNURUQgKDUzKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2hhbGRvYy5oIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2hhbGRvYy5oCmluZGV4IDI4MTM2YWQuLjViY2JlOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNoYWxkb2MuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzaGFsZG9jLmgKQEAgLTU5Nyw3ICs1OTcsNyBAQAogICAgQ3lBc0hhbFNsZWVwQ2hhbm5lbC4KIAogICAgUmV0dXJucwotICAgQ3lUcnVlIGlzIHRoZSBpbml0aWFsaXphdGlvbiB3YXMgc3VjZXNzZnVsLCBhbmQgQ3lGYWxzZSBvdGhlcndpc2UKKyAgIEN5VHJ1ZSBpcyB0aGUgaW5pdGlhbGl6YXRpb24gd2FzIHN1Y2Nlc3NmdWwsIGFuZCBDeUZhbHNlIG90aGVyd2lzZQogCiAgICBTZWUgQWxzbwogICAgKiBDeUFzSGFsU2xlZXBDaGFubmVsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzaW50ci5oIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc2ludHIuaAppbmRleCAzZDcwNjNlLi42MGE2ZmZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzaW50ci5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNpbnRyLmgKQEAgLTY5LDcgKzY5LDcgQEAKIAogICAgUmV0dXJucwogICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIGludGVycnVwdCBtb2R1bGUgd2FzIHN0b3BwZWQKLSAgICoJc3VjZXNzZnVsbHkKKyAgICoJc3VjY2Vzc2Z1bGx5CiAgICAqIENZX0FTX0VSUk9SX05PVF9SVU5OSU5HIC0gdGhlIGludGVycnVwdCBtb2R1bGUgd2FzIG5vdAogICAgKglydW5uaW5nCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNtaXNjLmggYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzbWlzYy5oCmluZGV4IDJmMDcwMTguLmRmN2MyYjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNtaXNjLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc21pc2MuaApAQCAtNjIwLDcgKzYyMCw3IEBACiAgICAqIE5lc3RhYmxlOiBZRVMKIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIGZpcm13YXJlIHdhcyBzdWNlc3NmdWxseSBkb3dubG9hZGVkCisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGUgZmlybXdhcmUgd2FzIHN1Y2Nlc3NmdWxseSBkb3dubG9hZGVkCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfSEFORExFCiAgICAqIENZX0FTX0VSUk9SX05PVF9DT05GSUdVUkVEIC0gdGhlIFdlc3QgQnJpZGdlIGRldmljZQogICAgKgl3YXMgbm90IGNvbmZpZ3VyZWQKQEAgLTgzNiw3ICs4MzYsNyBAQAogICAgb3duZXJzaGlwLgogCiAgICBSZXR1cm5zCi0gICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGUgcCBwb3J0IHN1Y2Vzc2Z1bGx5IGFjcXVpcmVkIHRoZQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIHAgcG9ydCBzdWNjZXNzZnVsbHkgYWNxdWlyZWQgdGhlCiAgICAqIAlyZXNvdXJjZSBvZiBpbnRlcmVzdAogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX0hBTkRMRQogICAgKiBDWV9BU19FUlJPUl9OT1RfQ09ORklHVVJFRApAQCAtODc5LDcgKzg3OSw3IEBACiAgICAqIFZhbGlkIEluIEFzeW5jaHJvbm91cyBDYWxsYmFjazogTk8KIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIHAgcG9ydCBzdWNlc3NmdWxseSByZWxlYXNlZAorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIHAgcG9ydCBzdWNjZXNzZnVsbHkgcmVsZWFzZWQKICAgICoJdGhlIHJlc291cmNlIG9mIGludGVyZXN0CiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfSEFORExFCiAgICAqIENZX0FTX0VSUk9SX05PVF9DT05GSUdVUkVECkBAIC05MjksNyArOTI5LDcgQEAKIAogICAgUmV0dXJucwogICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIHRyYWNlIGNvbmZpZ3VyYXRpb24gaGFzIGJlZW4KLSAgICoJc3VjZXNzZnVsbHkgY2hhbmdlZAorICAgKglzdWNjZXNzZnVsbHkgY2hhbmdlZAogICAgKiBDWV9BU19FUlJPUl9OT19TVUNIX0JVUyAtIHRoZSBidXMgc3BlY2lmaWVkIGRvZXMgbm90IGV4aXN0CiAgICAqIENZX0FTX0VSUk9SX05PX1NVQ0hfREVWSUNFIC0gdGhlIHNwZWNpZmllZCBtZWRpYS9kZXZpY2UKICAgICoJcGFpciBkb2VzIG5vdCBleGlzdApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc3Byb3RvY29sLmggYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzcHJvdG9jb2wuaAppbmRleCAzMTc4MDVmLi43NzNiNjQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzcHJvdG9jb2wuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzcHJvdG9jb2wuaApAQCAtNzU2LDcgKzc1Niw3IEBACiAJICogMSA6IERlYnVnIG1vZGUKIAogICAgRGVzY3JpcHRpb24KLSAgIFRoaXMgcmVwb25zZSBpcyBzZW50IHRvIHJldHVybiB0aGUgZmlybXdhcmUgdmVyc2lvbgorICAgVGhpcyByZXNwb25zZSBpcyBzZW50IHRvIHJldHVybiB0aGUgZmlybXdhcmUgdmVyc2lvbgogICAgbnVtYmVyIHRvIHRoZSByZXF1ZXN0b3IuCiAgKi8KICNkZWZpbmUgQ1lfUkVTUF9GSVJNV0FSRV9WRVJTSU9OICgxNikKQEAgLTM2NTUsNyArMzY1NSw3IEBACiAgICBUaGlzIHJlcXVlc3QgaXMgc2VudCB0byB0aGUgV2VzdCBCcmlkZ2Ugd2hlbiB0aGUgUCBwb3J0CiAgICBuZWVkcyB0byBzZW5kIGRhdGEgdG8gdGhlIEhvc3QgaW4gYSBUdXJibyBFbmRwb2ludC4KICAgIFVwb24gcmVjZWl2aW5nIHRoaXMgZXZlbnQsIEZpcm13YXJlIHdpbGwgbWFrZSB0aGUgZW5kIHBvaW50Ci0gICBhdmlsYWJsZSBmb3IgdGhlIFAgcG9ydC4gSWYgdGhlIGxlbmd0aCBpcyB6ZXJvLCB0aGVuCisgICBhdmFpbGFibGUgZm9yIHRoZSBQIHBvcnQuIElmIHRoZSBsZW5ndGggaXMgemVybywgdGhlbgogICAgZmlybXdhcmUgd2lsbCBzZW5kIGEgemVybyBsZW5ndGggcGFja2V0LgogCiAgICBEaXJlY3Rpb24KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNzdG9yYWdlLmggYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzc3RvcmFnZS5oCmluZGV4IDY0ZjA3OGMuLjUyYjkzYzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXNzdG9yYWdlLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc3N0b3JhZ2UuaApAQCAtODMyLDcgKzgzMiw3IEBACiAgICAqIENZX0FTX0VSUk9SX05PX0ZJUk1XQVJFIC0gdGhlIGZpcm13YXJlIGhhcyBub3QgYmVlbgogICAgKglsb2FkZWQgaW50byBXZXN0IEJyaWRnZQogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX0hBTkRMRSAtIGFuIGludmFsaWQgaGFuZGxlIHdhcyBwYXNzZWQgaW4KLSAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoZSBtb2R1bGUgc3RhcnRlZCBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIG1vZHVsZSBzdGFydGVkIHN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9USU1FT1VUIC0gYSB0aW1lb3V0IG9jY3VycmVkIGNvbW11bmljYXRpbmcKICAgICoJd2l0aCB0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlCiAgICAqIENZX0FTX0VSUk9SX09VVF9PRl9NRU1PUlkKQEAgLTg4Miw3ICs4ODIsNyBAQAogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX0hBTkRMRSAtIGFuIGludmFsaWQgaGFuZGxlIHdhcwogICAgKglwYXNzZWQgaW4KICAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0Ci0gICAqCWRvd24gc3VjZXNzZnVsbHkKKyAgICoJZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfVElNRU9VVCAtIGEgdGltZW91dCBvY2N1cnJlZAogICAgKgljb21tdW5pY2F0aW5nIHdpdGggdGhlIFdlc3QgQnJpZGdlIGRldmljZQogICAgKiBDWV9BU19FUlJPUl9OT1RfUlVOTklORwpAQCAtOTM0LDcgKzkzNCw3IEBACiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfSEFORExFIC0gYW4gaW52YWxpZCBoYW5kbGUKICAgICoJd2FzIHBhc3NlZCBpbgogICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIGZ1bmN0aW9uIHdhcyByZWdpc3RlcmVkCi0gICAqCXN1Y2Vzc2Z1bGx5CisgICAqCXN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9OT1RfUlVOTklORyAtIHRoZSBzdGFjayBpcyBub3QgcnVubmluZwogCiAgICBTZWUgQWxzbwpAQCAtOTgxLDcgKzk4MSw3IEBACiAgICAqCWJlZW4gc3RhcnRlZAogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX0hBTkRMRSAtIGFuIGludmFsaWQgaGFuZGxlIHdhcwogICAgKglwYXNzZWQgaW4KLSAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgcmVxdWVzdCB3YXMgc3VjZXNzZnVsbHkKKyAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgcmVxdWVzdCB3YXMgc3VjY2Vzc2Z1bGx5CiAgICAqCXRyYW5zbWl0dGVkIHRvIHRoZSBXZXN0IEJyaWRnZSBkZXZpY2UKICAgICogQ1lfQVNfRVJST1JfVElNRU9VVCAtIGEgdGltZW91dCBvY2N1cnJlZCBjb21tdW5pY2F0aW5nCiAgICAqCXdpdGggdGhlIFdlc3QgQnJpZGdlIGRldmljZQpAQCAtMTAzNCw3ICsxMDM0LDcgQEAKICAgICoJYmVlbiBzdGFydGVkCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfSEFORExFIC0gYW4gaW52YWxpZCBoYW5kbGUKICAgICoJd2FzIHBhc3NlZCBpbgotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIG1lZGlhIHdhcyBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhlIG1lZGlhIHdhcyBzdWNjZXNzZnVsbHkKICAgICoJcmVsZWFzZWQKICAgICogQ1lfQVNfRVJST1JfTUVESUFfTk9UX0NMQUlNRUQgLSB0aGUgbWVkaWEgd2FzIG5vdAogICAgKgljbGFpbWVkIGJ5IHRoZSBQIHBvcnQKQEAgLTE5MDUsNyArMTkwNSw3IEBACiAgICBkaWZmZXIgYmV0d2VlbiBTRCBjYXJkcy4KIAogICAgQSBsYXJnZSBlcmFzZSBjYW4gdGFrZSBhIHdoaWxlIHRvIGNvbXBsZXRlIGRlcGVuZGluZyBvbiB0aGUgU0QKLSAgIGNhcmQuIEluIHN1Y2ggYSBjYXNlIGl0IGlzIHJlY2NvbWVuZGVkIHRoYXQgYW4gYXN5bmMgY2FsbCBpcyBtYWRlLgorICAgY2FyZC4gSW4gc3VjaCBhIGNhc2UgaXQgaXMgcmVjb21tZW5kZWQgdGhhdCBhbiBhc3luYyBjYWxsIGlzIG1hZGUuCiAKICAgIFJldHVybnMKICAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIEFQSSBjYWxsIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkKQEAgLTE5MjYsNyArMTkyNiw3IEBACiAgICAqCXJlcXVpcmVkIGJlZm9yZSBlcmFzZSBpcyBhbGxvd2VkCiAgICAqIENZX0FTX0VSUk9SX05PX1NVQ0hfQlVTCiAgICAqIENZX0FTX0VSUk9SX05PX1NVQ0hfREVWSUNFCi0gICAqIENZX0FTX0VSUk9SX05PVF9TVVBQT1JURUQgLSBFcmFzZSBpcyBjdXJyZW5seSBvbmx5IHN1cHBvcnRlZAorICAgKiBDWV9BU19FUlJPUl9OT1RfU1VQUE9SVEVEIC0gRXJhc2UgaXMgY3VycmVudGx5IG9ubHkgc3VwcG9ydGVkCiAgICAqCW9uIFNEIGFuZCB1c2luZyBTRCBvbmx5IGZpcm13YXJlCiAgICAqIENZX0FTX0VSUk9SX09VVF9PRl9NRU1PUlkKIApAQCAtMTk4NSw3ICsxOTg1LDcgQEAKICAgICoJdHlwZSB3YXMgbWFkZQogICAgKiBDWV9BU19FUlJPUl9PVVRfT0ZfTUVNT1JZIC0gaW5zdWZmaWNpZW50IG1lbW9yeSBhdmFpbGFibGUKICAgICogQ1lfQVNfRVJST1JfSU5WQUxJRF9SRVNQT05TRSAtIGFuIGVycm9yIG1lc3NhZ2Ugd2FzCi0gICAqCXJlY2lldmVkIGZyb20gdGhlIGZpcm13YXJlCisgICAqCXJlY2VpdmVkIGZyb20gdGhlIGZpcm13YXJlCiAgICAqIENZX0FTX0VSUk9SX01FRElBX0FDQ0VTU19GQUlMVVJFIC0gdGhlcmUgd2FzIGVycm9yIGluCiAgICAqCXJlYWRpbmcgZnJvbSB0aGUgbWVkaWEKICAgICogQ1lfQVNfRVJST1JfSU5WQUxJRF9GVU5DVElPTiAtIEFuIElPIGF0dGVtcHQgd2FzIG1hZGUgdG8KQEAgLTIwNDcsNyArMjA0Nyw3IEBACiAgICAqCXBhaXIgZG9lcyBub3QgZXhpc3QKICAgICogQ1lfQVNfRVJST1JfT1VUX09GX01FTU9SWSAtIGluc3VmZmljaWVudCBtZW1vcnkgYXZhaWxhYmxlCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcwotICAgKglyZWNpZXZlZCBmcm9tIHRoZSBmaXJtd2FyZQorICAgKglyZWNlaXZlZCBmcm9tIHRoZSBmaXJtd2FyZQogCiAqLwogY3lfYXNfcmV0dXJuX3N0YXR1c190CkBAIC0yMDk1LDcgKzIwOTUsNyBAQAogICAgKglwYWlyIGRvZXMgbm90IGV4aXN0CiAgICAqIENZX0FTX0VSUk9SX09VVF9PRl9NRU1PUlkgLSBpbnN1ZmZpY2llbnQgbWVtb3J5IGF2YWlsYWJsZQogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX1JFU1BPTlNFIC0gYW4gZXJyb3IgbWVzc2FnZSB3YXMKLSAgICoJcmVjaWV2ZWQgZnJvbSB0aGUgZmlybXdhcmUKKyAgICoJcmVjZWl2ZWQgZnJvbSB0aGUgZmlybXdhcmUKICAgICovCiBjeV9hc19yZXR1cm5fc3RhdHVzX3QKIGN5X2FzX3NkaW9fcmVzZXRfY2FyZCgKQEAgLTIxMzksNyArMjEzOSw3IEBACiAgICAqIENZX0FTX0VSUk9SX05PX1NVQ0hfREVWSUNFIC0gdGhlIHNwZWNpZmllZCBtZWRpYS9kZXZpY2UgcGFpcgogICAgKglkb2VzIG5vdCBleGlzdAogICAgKiBDWV9BU19FUlJPUl9PVVRfT0ZfTUVNT1JZIC0gaW5zdWZmaWNpZW50IG1lbW9yeSBhdmFpbGFibGUKLSAgICogQ1lfQVNfRVJST1JfSU5WQUxJRF9SRVNQT05TRSAtIGFuIGVycm9yIG1lc3NhZ2Ugd2FzIHJlY2lldmVkCisgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcyByZWNlaXZlZAogICAgKglmcm9tIHRoZSBmaXJtd2FyZQogICAgKiBDWV9BU19FUlJPUl9NRURJQV9BQ0NFU1NfRkFJTFVSRSAtIHRoZXJlIHdhcyBlcnJvciBpbiByZWFkaW5nCiAgICAqCWZyb20gdGhlIG1lZGlhCkBAIC0yMTk4LDcgKzIxOTgsNyBAQAogICAgKiBDWV9BU19FUlJPUl9OT19TVUNIX0RFVklDRSAtIHRoZSBzcGVjaWZpZWQgbWVkaWEvZGV2aWNlCiAgICAqIHBhaXIgZG9lcyBub3QgZXhpc3QKICAgICogQ1lfQVNfRVJST1JfT1VUX09GX01FTU9SWSAtIGluc3VmZmljaWVudCBtZW1vcnkgYXZhaWxhYmxlCi0gICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcyByZWNpZXZlZAorICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX1JFU1BPTlNFIC0gYW4gZXJyb3IgbWVzc2FnZSB3YXMgcmVjZWl2ZWQKICAgICogZnJvbSB0aGUgZmlybXdhcmUKICAgICogQ1lfQVNfRVJST1JfTUVESUFfQUNDRVNTX0ZBSUxVUkUgLSB0aGVyZSB3YXMgZXJyb3IgaW4KICAgICogcmVhZGluZyBmcm9tIHRoZSBtZWRpYQpAQCAtMjI2Miw3ICsyMjYyLDcgQEAKICAgICogQ1lfQVNfRVJST1JfT1VUX09GX01FTU9SWSAtIGluc3VmZmljaWVudCBtZW1vcnkKICAgICoJYXZhaWxhYmxlCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcwotICAgKglyZWNpZXZlZCBmcm9tIHRoZSBmaXJtd2FyZQorICAgKglyZWNlaXZlZCBmcm9tIHRoZSBmaXJtd2FyZQogICAgKiBDWV9BU19FUlJPUl9NRURJQV9BQ0NFU1NfRkFJTFVSRSAtIHRoZXJlIHdhcyBlcnJvciBpbgogICAgKglyZWFkaW5nIGZyb20gdGhlIG1lZGlhCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfRlVOQ1RJT04gLSBBbiBJTyBhdHRlbXB0IHdhcyBtYWRlCkBAIC0yMzE5LDcgKzIzMTksNyBAQAogICAgKglwYWlyIGRvZXMgbm90IGV4aXN0CiAgICAqIENZX0FTX0VSUk9SX0FTWU5DX1BFTkRJTkcgLSBhbiBhc3luYyBvcGVyYXRpb24gaXMgcGVuZGluZwogICAgKiBDWV9BU19FUlJPUl9PVVRfT0ZfTUVNT1JZIC0gaW5zdWZmaWNpZW50IG1lbW9yeSBhdmFpbGFibGUKLSAgICogQ1lfQVNfRVJST1JfSU5WQUxJRF9SRVNQT05TRSAtIGFuIGVycm9yIG1lc3NhZ2Ugd2FzIHJlY2lldmVkCisgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcyByZWNlaXZlZAogICAgKglmcm9tIHRoZSBmaXJtd2FyZQogICAgKiBDWV9BU19FUlJPUl9NRURJQV9BQ0NFU1NfRkFJTFVSRSAtIHRoZXJlIHdhcyBlcnJvciBpbgogICAgKglyZWFkaW5nIGZyb20gdGhlIG1lZGlhCkBAIC0yMzk2LDcgKzIzOTYsNyBAQAogICAgKiBDWV9BU19FUlJPUl9BU1lOQ19QRU5ESU5HIC0gYW4gYXN5bmMgb3BlcmF0aW9uIGlzIHBlbmRpbmcKICAgICogQ1lfQVNfRVJST1JfT1VUX09GX01FTU9SWSAtIGluc3VmZmljaWVudCBtZW1vcnkgYXZhaWxhYmxlCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcwotICAgKglyZWNpZXZlZCBmcm9tIHRoZSBmaXJtd2FyZQorICAgKglyZWNlaXZlZCBmcm9tIHRoZSBmaXJtd2FyZQogICAgKiBDWV9BU19FUlJPUl9NRURJQV9BQ0NFU1NfRkFJTFVSRSAtIHRoZXJlIHdhcyBlcnJvciBpbgogICAgKglyZWFkaW5nIGZyb20gdGhlIG1lZGlhCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfRlVOQ1RJT04gLSBBbiBJTyBhdHRlbXB0IHdhcyBtYWRlCkBAIC0yNDcxLDcgKzI0NzEsNyBAQAogICAgKiBwYWlyIGRvZXMgbm90IGV4aXN0CiAgICAqIENZX0FTX0VSUk9SX09VVF9PRl9NRU1PUlkgLSBpbnN1ZmZpY2llbnQgbWVtb3J5IGF2YWlsYWJsZQogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX1JFU1BPTlNFIC0gYW4gZXJyb3IgbWVzc2FnZSB3YXMKLSAgICoJcmVjaWV2ZWQgZnJvbSB0aGUgZmlybXdhcmUKKyAgICoJcmVjZWl2ZWQgZnJvbSB0aGUgZmlybXdhcmUKICAgICogQ1lfQVNfRVJST1JfTUVESUFfQUNDRVNTX0ZBSUxVUkUgLSB0aGVyZSB3YXMgZXJyb3IgaW4KICAgICoJcmVhZGluZyBmcm9tIHRoZSBtZWRpYQogICAgKiBDWV9BU19FUlJPUl9JTlZBTElEX0ZVTkNUSU9OIC0gQW4gSU8gYXR0ZW1wdCB3YXMgbWFkZQpAQCAtMjcxNCw3ICsyNzE0LDcgQEAKICAgICogQ1lfQVNfRVJST1JfT1VUX09GX01FTU9SWSAtIGluc3VmZmljaWVudCBtZW1vcnkKICAgICoJYXZhaWxhYmxlCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfUkVTUE9OU0UgLSBhbiBlcnJvciBtZXNzYWdlIHdhcwotICAgKglyZWNpZXZlZCBmcm9tIHRoZSBmaXJtd2FyZQorICAgKglyZWNlaXZlZCBmcm9tIHRoZSBmaXJtd2FyZQogICAgKiBDWV9BU19FUlJPUl9NRURJQV9BQ0NFU1NfRkFJTFVSRSAtIHRoZXJlIHdhcyBlcnJvcgogICAgKglpbiByZWFkaW5nIGZyb20gdGhlIG1lZGlhCiAgICAqIENZX0FTX0VSUk9SX0lOVkFMSURfRlVOQ1RJT04gLSBBbiBJTyBhdHRlbXB0IHdhcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc3VzYi5oIGIvZHJpdmVycy9zdGFnaW5nL3dlc3RicmlkZ2UvYXN0b3JpYS9pbmNsdWRlL2xpbnV4L3dlc3RicmlkZ2UvY3lhc3VzYi5oCmluZGV4IDRhNTQ5ZTEuLmUzYmE5Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93ZXN0YnJpZGdlL2FzdG9yaWEvaW5jbHVkZS9saW51eC93ZXN0YnJpZGdlL2N5YXN1c2IuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvd2VzdGJyaWRnZS9hc3RvcmlhL2luY2x1ZGUvbGludXgvd2VzdGJyaWRnZS9jeWFzdXNiLmgKQEAgLTQ2NCw3ICs0NjQsNyBAQAogICAgYmUgc2VsZWN0ZWQgb24gYSBwYXJ0aXRpb25lZCBzdG9yYWdlIGRldmljZS4KIAogICAgRGVzY3JpcHRpb24KLSAgIFdlc3QgQnJpZGdlIGZpcm13YXJlIHN1cHBvcnRzIGNyZWF0aW5nIHVwdG8gdHdvCisgICBXZXN0IEJyaWRnZSBmaXJtd2FyZSBzdXBwb3J0cyBjcmVhdGluZyB1cCB0byB0d28KICAgIHBhcnRpdGlvbnMgb24gbWFzcyBzdG9yYWdlIGRldmljZXMgY29ubmVjdGVkIHRvCiAgICBXZXN0IEJyaWRnZS4gIFdoZW4gdGhlcmUgYXJlIHR3byBwYXJ0aXRpb25zIG9uIGEgZGV2aWNlLAogICAgdGhlIHVzZXIgY2FuIGNob29zZSB3aGljaCBvZiB0aGVzZSBwYXJ0aXRpb25zIHNob3VsZCBiZQpAQCAtNjk4LDcgKzY5OCw3IEBACiAgICAqCWJlZW4gY29uZmlndXJlZAogICAgKiBDWV9BU19FUlJPUl9OT19GSVJNV0FSRSAtIHRoZSBmaXJtd2FyZSBoYXMgbm90IGJlZW4gbG9hZGVkCiAgICAqCWludG8gV2VzdCBCcmlkZ2UKLSAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24gc3VjZXNzZnVsbHkKKyAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24gc3VjY2Vzc2Z1bGx5CiAgICAqIENZX0FTX0VSUk9SX1RJTUVPVVQgLSBhIHRpbWVvdXQgb2NjdXJyZWQgY29tbXVuaWNhdGluZyB3aXRoCiAgICAqCXRoZSBXZXN0IEJyaWRnZSBkZXZpY2UKIApAQCAtNzUyLDcgKzc1Miw3IEBACiAgICAqIE5lc3RhYmxlOiBZRVMKIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfTk9UX0NPTkZJR1VSRUQgLSB0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlIGhhcyBub3QKICAgICoJYmVlbiBjb25maWd1cmVkCiAgICAqIENZX0FTX0VSUk9SX05PX0ZJUk1XQVJFIC0gdGhlIGZpcm13YXJlIGhhcyBub3QgYmVlbiBsb2FkZWQKQEAgLTc5MSw3ICs3OTEsNyBAQAogICAgKiBOZXN0YWJsZTogWUVTCiAKICAgIFJldHVybnMKLSAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24gc3VjZXNzZnVsbHkKKyAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24gc3VjY2Vzc2Z1bGx5CiAgICAqIENZX0FTX0VSUk9SX05PVF9DT05GSUdVUkVEIC0gdGhlIFdlc3QgQnJpZGdlIGRldmljZSBoYXMgbm90CiAgICAqCWJlZW4gY29uZmlndXJlZAogICAgKiBDWV9BU19FUlJPUl9OT19GSVJNV0FSRSAtIHRoZSBmaXJtd2FyZSBoYXMgbm90IGJlZW4gbG9hZGVkCkBAIC04MjUsNyArODI1LDcgQEAKICAgICogVmFsaWQgSW4gQXN5bmNocm9ub3VzIENhbGxiYWNrOiBZZXMgKGlmIGNiIHN1cHBsaWVkKQogCiAgICBSZXR1cm5zCi0gICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9OT1RfQ09ORklHVVJFRCAtIHRoZSBXZXN0IEJyaWRnZSBkZXZpY2UgaGFzIG5vdAogICAgKgliZWVuIGNvbmZpZ3VyZWQKICAgICogQ1lfQVNfRVJST1JfTk9fRklSTVdBUkUgLSB0aGUgZmlybXdhcmUgaGFzIG5vdCBiZWVuIGxvYWRlZApAQCAtODU1LDEzICs4NTUsMTMgQEAKICAgIHRoZSBVU0Igc3RhY2sKIAogICAgRGVzY3JpcHRpb24KLSAgIFRoaXMgZnVuY3Rpb24gc2VuZHMgYSByZXF1ZXN0IHRvIFdlc3QgQnJpZGdlIHRvIHJldHJlaXZlCisgICBUaGlzIGZ1bmN0aW9uIHNlbmRzIGEgcmVxdWVzdCB0byBXZXN0IEJyaWRnZSB0byByZXRyaWV2ZQogICAgdGhlIGN1cnJlbnQgY29uZmlndXJhdGlvbgogCiAgICAqIFZhbGlkIEluIEFzeW5jaHJvbm91cyBDYWxsYmFjazogWWVzIChpZiBjYiBzdXBwbGllZCkKIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfTk9UX0NPTkZJR1VSRUQgLSB0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlIGhhcyBub3QKICAgICoJYmVlbiBjb25maWd1cmVkCiAgICAqIENZX0FTX0VSUk9SX05PX0ZJUk1XQVJFIC0gdGhlIGZpcm13YXJlIGhhcyBub3QgYmVlbiBsb2FkZWQKQEAgLTkwNiw3ICs5MDYsNyBAQAogICAgQ2hhcHRlciA5LgogCiAgICBSZXR1cm5zCi0gICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9OT1RfQ09ORklHVVJFRCAtIHRoZSBXZXN0IEJyaWRnZSBkZXZpY2UgaGFzIG5vdAogICAgKgliZWVuIGNvbmZpZ3VyZWQKICAgICogQ1lfQVNfRVJST1JfTk9fRklSTVdBUkUgLSB0aGUgZmlybXdhcmUgaGFzIG5vdCBiZWVuIGxvYWRlZApAQCAtOTkzLDcgKzk5Myw3IEBACiAgICBEZXNjcmlwdGlvbgogICAgVGhpcyBkYXRhIHN0cnVjdHVyZSB0aGUgYnVmZmVyIHRvIGhvbGQgdGhlIGRlc2NyaXB0b3IKICAgIGRhdGEsIGFuZCBhbiBpbi9vdXQgcGFyYW1ldGVyIHRpIGluZGljYXRlIHRoZQotICAgbGVuZ2h0IG9mIHRoZSBidWZmZXIgYW5kIGRlc2NyaXB0b3IgZGF0YSBpbiBieXRlcy4KKyAgIGxlbmd0aCBvZiB0aGUgYnVmZmVyIGFuZCBkZXNjcmlwdG9yIGRhdGEgaW4gYnl0ZXMuCiAKICAgIFNlZSBBbHNvCiAgICAqIEN5QXNVc2JHZXREZXNjcmlwdG9yCkBAIC0xMDI3LDcgKzEwMjcsNyBAQAogICAgQ2hhcHRlciA5LgogCiAgICBSZXR1cm5zCi0gICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9OT1RfQ09ORklHVVJFRCAtIHRoZSBXZXN0IEJyaWRnZSBkZXZpY2UgaGFzIG5vdAogICAgKgliZWVuIGNvbmZpZ3VyZWQKICAgICogQ1lfQVNfRVJST1JfTk9fRklSTVdBUkUgLSB0aGUgZmlybXdhcmUgaGFzIG5vdCBiZWVuIGxvYWRlZApAQCAtMTEwNiw3ICsxMTA2LDcgQEAKICAgICogVmFsaWQgSW4gQXN5bmNocm9ub3VzIENhbGxiYWNrOiBOTwogCiAgICBSZXR1cm5zCi0gICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9OT1RfQ09ORklHVVJFRCAtIHRoZSBXZXN0IEJyaWRnZSBkZXZpY2UgaGFzIG5vdAogICAgKgliZWVuIGNvbmZpZ3VyZWQKICAgICogQ1lfQVNfRVJST1JfTk9fRklSTVdBUkUgLSB0aGUgZmlybXdhcmUgaGFzIG5vdCBiZWVuIGxvYWRlZApAQCAtMTE0MCw3ICsxMTQwLDcgQEAKICAgIEFkZCBkb2N1bWVudGF0aW9uIGFib3V0IGVuZHBvaW50IGNvbmZpZ3VyYXRpb24gbGltaXRhdGlvbnMKIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfTk9UX0NPTkZJR1VSRUQgLSB0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlIGhhcyBub3QKICAgICoJYmVlbiBjb25maWd1cmVkCiAgICAqIENZX0FTX0VSUk9SX05PX0ZJUk1XQVJFIC0gdGhlIGZpcm13YXJlIGhhcyBub3QgYmVlbiBsb2FkZWQKQEAgLTExODEsNyArMTE4MSw3IEBACiAgICAqIFZhbGlkIEluIEFzeW5jaHJvbm91cyBDYWxsYmFjazogTk8KIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfTk9UX0NPTkZJR1VSRUQgLSB0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlIGhhcyBub3QKICAgICoJYmVlbiBjb25maWd1cmVkCiAgICAqIENZX0FTX0VSUk9SX05PX0ZJUk1XQVJFIC0gdGhlIGZpcm13YXJlIGhhcyBub3QgYmVlbiBsb2FkZWQKQEAgLTEyMTksNyArMTIxOSw3IEBACiAgICBmdW5jdGlvbnMgc3RvcmUgYXdheSB0aGUgY29uZmlndXJhdGlvbiBpbmZvcm1hdGlvbiBhbmQgdGhpcwogICAgQ3lBc1VzYkNvbW1pdENvbmZpZygpIGFjdHVhbGx5IGZpbmRzIHRoZQogICAgYmVzdCBoYXJkd2FyZSBjb25maWd1cmF0aW9uIGJhc2VkIG9uIHRoZSByZXF1ZXN0ZWQgZW5kcG9pbnQKLSAgIGNvbmZpZ3VyYXRpb24gYW5kIHNlbmRzIHRoc2kgb3B0aW1hbAorICAgY29uZmlndXJhdGlvbiBhbmQgc2VuZHMgdGhpcyBvcHRpbWFsCiAgICBjb25maXVyYXRpb24gZG93biB0byB0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlLgogCiAgICAqIFZhbGlkIEluIEFzeW5jaHJvbm91cyBDYWxsYmFjazogWUVTIChpZiBjYiBzdXBwbGllZCkKQEAgLTEyNjgsNyArMTI2OCw3IEBACiAgICAqIFZhbGlkIEluIEFzeW5jaHJvbm91cyBDYWxsYmFjazogTk8KIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfVElNRU9VVCAtIGEgdGltZW91dCBvY2N1cnJlZCBjb21tdW5pY2F0aW5nIHdpdGgKICAgICoJdGhlIFdlc3QgQnJpZGdlIGRldmljZQogICAgKiBDWV9BU19FUlJPUl9OT1RfUlVOTklORyAtIHRoZSBVU0Igc3RhY2sgaXMgbm90IHJ1bm5pbmcKQEAgLTEzMTEsNyArMTMxMSw3IEBACiAgICAqIFZhbGlkIEluIEFzeW5jaHJvbm91cyBDYWxsYmFjazogWUVTCiAKICAgIFJldHVybnMKLSAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24gc3VjZXNzZnVsbHkKKyAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24gc3VjY2Vzc2Z1bGx5CiAgICAqIENZX0FTX0VSUk9SX1RJTUVPVVQgLSBhIHRpbWVvdXQgb2NjdXJyZWQgY29tbXVuaWNhdGluZyB3aXRoCiAgICAqCXRoZSBXZXN0IEJyaWRnZSBkZXZpY2UKICAgICogQ1lfQVNfRVJST1JfTk9UX1JVTk5JTkcgLSB0aGUgVVNCIHN0YWNrIGlzIG5vdCBydW5uaW5nCkBAIC0xMzU1LDcgKzEzNTUsNyBAQAogICAgYSB6ZXJvIGxlbmd0aCBwYWNrZXQgdHJhbnNtaXR0ZWQgdG8gdGhlIFVTQiBob3N0LgogCiAgICBSZXR1cm5zCi0gICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Vzc2Z1bGx5CisgICAqIENZX0FTX0VSUk9SX1NVQ0NFU1MgLSB0aGlzIG1vZHVsZSB3YXMgc2h1dCBkb3duIHN1Y2Nlc3NmdWxseQogICAgKiBDWV9BU19FUlJPUl9USU1FT1VUIC0gYSB0aW1lb3V0IG9jY3VycmVkIGNvbW11bmljYXRpbmcgd2l0aAogICAgKgl0aGUgV2VzdCBCcmlkZ2UgZGV2aWNlCiAgICAqIENZX0FTX0VSUk9SX05PVF9SVU5OSU5HIC0gdGhlIFVTQiBzdGFjayBpcyBub3QgcnVubmluZwpAQCAtMTM5NSw3ICsxMzk1LDcgQEAKICAgIGluIGEgemVybyBsZW5ndGggcGFja2V0IHRyYW5zbWl0dGVkIHRvIHRoZSBVU0IgaG9zdC4KIAogICAgUmV0dXJucwotICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNlc3NmdWxseQorICAgKiBDWV9BU19FUlJPUl9TVUNDRVNTIC0gdGhpcyBtb2R1bGUgd2FzIHNodXQgZG93biBzdWNjZXNzZnVsbHkKICAgICogQ1lfQVNfRVJST1JfVElNRU9VVCAtIGEgdGltZW91dCBvY2N1cnJlZCBjb21tdW5pY2F0aW5nIHdpdGgKICAgICoJdGhlIFdlc3QgQnJpZGdlIGRldmljZQogICAgKiBDWV9BU19FUlJPUl9OT1RfUlVOTklORyAtIHRoZSBVU0Igc3RhY2sgaXMgbm90IHJ1bm5pbmcKQEAgLTE0MzUsNyArMTQzNSw3IEBACiAKICAgIFJldHVybnMKICAgICogQ1lfQVNfRVJST1JfU1VDQ0VTUyAtIHRoaXMgbW9kdWxlIHdhcyBzaHV0IGRvd24KLSAgICoJc3VjZXNzZnVsbHkKKyAgICoJc3VjY2Vzc2Z1bGx5CiAgICAqIENZX0FTX0VSUk9SX05PVF9SVU5OSU5HIC0gdGhlIFVTQiBzdGFjayBpcyBub3QKICAgICoJcnVubmluZwogICAgKiBDWV9BU19FUlJPUl9BU1lOQ19OT1RfUEVORElORyAtIG5vIGFzeW5jaHJvbm91cyBVU0IKQEAgLTE3OTEsNyArMTc5MSw3IEBACiAgICBkZXZpY2Ugc2hvdWxkIGJlIG1hZGUgdmlzaWJsZSB0byBVU0IuCiAKICAgIERlc2NyaXB0aW9uCi0gICBXZXN0IEJyaWRnZSBmaXJtd2FyZSBzdXBwb3J0cyB0aGUgY3JlYXRpb24gb2YgdXB0byB0d28KKyAgIFdlc3QgQnJpZGdlIGZpcm13YXJlIHN1cHBvcnRzIHRoZSBjcmVhdGlvbiBvZiB1cCB0byB0d28KICAgIHBhcnRpdGlvbnMgb24gbWFzcyBzdG9yYWdlIGRldmljZXMgY29ubmVjdGVkIHRvIHRoZSBXZXN0IEJyaWRnZQogICAgZGV2aWNlLiAgV2hlbiB0aGVyZSBhcmUgdHdvIHBhcnRpdGlvbnMgb24gYSBkZXZpY2UsIHRoZSB1c2VyIGNhbgogICAgY2hvb3NlIHdoaWNoIG9mIHRoZXNlIHBhcnRpdGlvbnMgc2hvdWxkIGJlIG1hZGUgdmlzaWJsZSB0byB0aGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93aW5ib25kL21kcy5jIGIvZHJpdmVycy9zdGFnaW5nL3dpbmJvbmQvbWRzLmMKaW5kZXggOWNmZWE5NC4uYzlmMGU4ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dpbmJvbmQvbWRzLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dpbmJvbmQvbWRzLmMKQEAgLTQ5Miw3ICs0OTIsNyBAQAogCiAJCQlUeERlc0luZGV4ID0gcE1kcy0+VHhEZXNJbmRleDsgLyogR2V0IHRoZSBjdXJyZW50IElEICovCiAJCQlwVHhEZXMtPkRlc2NyaXB0b3JfSUQgPSBUeERlc0luZGV4OwotCQkJcE1kcy0+VHhEZXNGcm9tW1R4RGVzSW5kZXhdID0gMjsgLyogU3RvcmluZyB0aGUgaW5mb3JtYXRpb24gb2Ygc291cmNlIGNvbW1pbmcgZnJvbSAqLworCQkJcE1kcy0+VHhEZXNGcm9tW1R4RGVzSW5kZXhdID0gMjsgLyogU3RvcmluZyB0aGUgaW5mb3JtYXRpb24gb2Ygc291cmNlIGNvbWluZyBmcm9tICovCiAJCQlwTWRzLT5UeERlc0luZGV4Kys7CiAJCQlwTWRzLT5UeERlc0luZGV4ICU9IE1BWF9VU0JfVFhfREVTQ1JJUFRPUjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvUkVBRE1FLnVidW50dSBiL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyL1JFQURNRS51YnVudHUKaW5kZXggNDdiZWFlYy4uZWRlZThiOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvUkVBRE1FLnVidW50dQorKysgYi9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMi9SRUFETUUudWJ1bnR1CkBAIC0xMTYsNyArMTE2LDcgQEAKIAogVGhlIEFnZXJlIFN5c3RlbXMgbGljZW5zZSBhcHBsaWVzLiBUaGlzIGlzIHdoeSBJIGluY2x1ZGUgdGhlIG9yaWdpbmFsCiBSRUFETUUud2xhZ3M0OS4gVGhlIGluc3RydWN0aW9ucyBpbiB0aGF0IGZpbGUgYXJlIGJvZ3VzIG5vdy4gSSBhbHNvCi1pbmNsdWRlIHRoZSBtYW4gcGFnZS4gRXZlbnRob3VnaCBzZXR0aW5nIHBhcmFtZXRlcnMgb24gdGhlIG1vZHVsZQoraW5jbHVkZSB0aGUgbWFuIHBhZ2UuIEV2ZW4gdGhvdWdoIHNldHRpbmcgcGFyYW1ldGVycyBvbiB0aGUgbW9kdWxlCiBkb2VzIG5vdCB3b3JrIGFueW1vcmUgYnV0IGl0IHByb3ZpZGVzIHNvbWUgaW5mb3JtYXRpb24gYWJvdXQgYWxsIHRoZQogc2V0dGluZ3MuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyL1RPRE8gYi9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMi9UT0RPCmluZGV4IDE0YWE0MTUuLjk0MDMyYjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyL1RPRE8KKysrIGIvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvVE9ETwpAQCAtMSw3ICsxLDcgQEAKIEZpcnN0IG9mIGFsbCwgdGhlIGJlc3QgdGhpbmcgd291bGQgYmUgdGhhdCB0aGlzIGRyaXZlciBiZWNvbWVzIG9ic29sdGUgYnkKIGFkZGluZyBzdXBwb3J0IGZvciBIZXJtZXMgSUkgYW5kIEhlcm1lcyBJSS41IGNhcmRzIHRvIHRoZSBleGlzdGluZyBvcmlub2NvCiBkcml2ZXIuIFRoZSBvcmlub2NvIGRyaXZlciBjdXJyZW50bHkgb25seSBzdXBwb3J0cyBIZXJtZXMgSSBiYXNlZCBjYXJkcy4KLVNpbmNlIHRoaXMgd2lsbCBub3QgaGFwcGVuIGJ5IG1hZ2ljIGFuZCBoYXMgbm90IGhhcHBlbmQgdW50aWwgbm93IHRoaXMKK1NpbmNlIHRoaXMgd2lsbCBub3QgaGFwcGVuIGJ5IG1hZ2ljIGFuZCBoYXMgbm90IGhhcHBlbmVkIHVudGlsIG5vdyB0aGlzCiBkcml2ZXIgcHJvdmlkZXMgYSBzdG9wLWdhcCBzb2x1dGlvbiBmb3IgdGhlc2UgdHlwZSBvZiBjYXJkcy4KIAogSGF2aW5nIHNhaWQgdGhhdCwgdGhlIGZvbGxvd2luZyB3aXNobGlzdCBjb21lcyB0byBtaW5kIHRvIG1ha2UgdGhlIGRyaXZlcgpAQCAtMTgsNyArMTgsNyBAQAogCS0gdGhlIGRyaXZlciBpcyBzcGxpdCBpbnRvIGEgSGVybWVzIElJIGFuZCBhIEhlcm1lcyBJSS41IHBhcnQsIGl0CiAJICB3b3VsZCBiZSBuaWNlIHRvIGhhbmRsZSBib3RoIHdpdGggb25lIG1vZHVsZSBpbnN0ZWFkIG9mIHR3bwogCS0gcmV2aWV3IGJ5IHRoZSB3aXJlbGVzcyBkZXZlbG9wZXIgY29tbXVuaXR5Ci0JLSB2ZXJpZnkgdGhlIGNvZGUgYWdhaW5zdCB0aGUgY29kaW5nIHN0YW5kYXJkcyBmb3IgYSBwcm9wcGVyIGxpbnV4CisJLSB2ZXJpZnkgdGhlIGNvZGUgYWdhaW5zdCB0aGUgY29kaW5nIHN0YW5kYXJkcyBmb3IgYSBwcm9wZXIgbGludXgKIAkgIGRyaXZlcgogCS0gcmVzb2x2ZSBsaWNlbnNlIGlzc3VlcyAoPykKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvaGNmLmMgYi9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMi9oY2YuYwppbmRleCBkNGJkZDNlLi5hNzMzMTdlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMi9oY2YuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMi9oY2YuYwpAQCAtNTQwLDcgKzU0MCw3IEBACiAqCiAqLkNPTkRJVElPTlMKICogRXhjZXB0IGZvciBoY2ZfYWN0aW9uIHdpdGggSENGX0FDVF9JTlRfRk9SQ0VfT04gb3IgSENGX0FDVF9JTlRfT0ZGIGFzIHBhcmFtZXRlciBvciBoY2ZfY29ubmVjdCB3aXRoIGFuIEkvTwotKiBhZGRyZXNzIChpLmUuIG5vdCBIQ0ZfRElTQ09OTkVDVCksIGFsbCBoY2YtZnVuY3Rpb24gY2FsbHMgTVVTVCBiZSBwcmVjZWVkZWQgYnkgYSBjYWxsIG9mIGhjZl9hY3Rpb24gd2l0aAorKiBhZGRyZXNzIChpLmUuIG5vdCBIQ0ZfRElTQ09OTkVDVCksIGFsbCBoY2YtZnVuY3Rpb24gY2FsbHMgTVVTVCBiZSBwcmVjZWRlZCBieSBhIGNhbGwgb2YgaGNmX2FjdGlvbiB3aXRoCiAqIEhDRl9BQ1RfSU5UX09GRiBhcyBwYXJhbWV0ZXIuCiAqIE5vdGUgdGhhdCBoY2ZfY29ubmVjdCBkZWZhdWx0cyB0byBOSUMgaW50ZXJydXB0IGRpc2FibGVkIG1vZGUsIGkuZS4gYXMgaWYgaGNmX2FjdGlvbiggSENGX0FDVF9JTlRfT0ZGICkKICogd2FzIGNhbGxlZC4KQEAgLTg0Myw3ICs4NDMsNyBAQAogKi5NT0RVTEUJCWludCBoY2ZfY250bCggSUZCUCBpZmJwLCBoY2ZfMTYgY21kICkKICouUFVSUE9TRQkJQ29ubmVjdCBvciBkaXNjb25uZWN0IGEgc3BlY2lmaWMgcG9ydCB0byBhIHNwZWNpZmljIG5ldHdvcmsuCiAqISEgIDs/Pz8/Pz8/Pz8/Pz8/Pz8/IGNvbnRpbnVlIG5lZWRzIG1vcmUgZXhwbGFuYXRpb24KLSoJCQkJcmVjb3ZlcnMgYnkgbWVhbnMgb2YgImNvbnRpbnVlIiB3aGVuIHRoZSBjb25uZWN0IHByb2NlcyBpbiBDQ1ggbW9kZSBmYWlscworKgkJCQlyZWNvdmVycyBieSBtZWFucyBvZiAiY29udGludWUiIHdoZW4gdGhlIGNvbm5lY3QgcHJvY2VzcyBpbiBDQ1ggbW9kZSBmYWlscwogKgkJCQlFbmFibGVzIG9yIGRpc2FibGVzIGRhdGEgdHJhbnNtaXNzaW9uIGFuZCByZWNlcHRpb24gZm9yIHRoZSBOSUMuCiAqCQkJCUFjdGl2YXRlcyBzdGF0aWMgTklDIGNvbmZpZ3VyYXRpb24gZm9yIGEgc3BlY2lmaWMgcG9ydCBhdCBjb25uZWN0LgogKgkJCQlBY3RpdmF0ZXMgc3RhdGljIGNvbmZpZ3VyYXRpb24gZm9yIGFsbCBwb3J0cyBhdCBlbmFibGUuCkBAIC0xMTcwLDEyICsxMTcwLDEyIEBACiAJCWlvX2FkZHIgPSBpb19iYXNlOwogCX0KIAotI2lmIDAgLy87PyBpZiBhIHN1YnNlcXVlbnQgaGNmX2Nvbm5lY3QgaXMgcHJlY2VlZGVkIGJ5IGFuIGhjZl9kaXNjb25uZWN0IHRoZSB3YWtldXAgaXMgbm90IG5lZWRlZCAhIQorI2lmIDAgLy87PyBpZiBhIHN1YnNlcXVlbnQgaGNmX2Nvbm5lY3QgaXMgcHJlY2VkZWQgYnkgYW4gaGNmX2Rpc2Nvbm5lY3QgdGhlIHdha2V1cCBpcyBub3QgbmVlZGVkICEhCiAjaWYgSENGX1NMRUVQCiAgICAgT1VUX1BPUlRfV09SRCggLi4uLi4rSFJFR19JTywgSFJFR19JT19XQUtFVVBfQVNZTkMgKTsgCSAgICAvL09QVyBub3QgeWV0IHVzZWFibGUKIAlNU0ZfV0FJVCg4MDApOwkJCQkJCQkJLy8gTVNGLWRlZmluZWQgZnVuY3Rpb24gdG8gd2FpdCBuIG1pY3Jvc2Vjb25kcy4KIAlub3RlIHRoYXQgTVNGX1dBSVQgdXNlcyBub3QgeWV0IGRlZmluZWQhISEhIElGQl9JT0Jhc2UgYW5kIElGQl9UaWNrSW5pICh2aWEgUFJPVF9DTlRfSU5JKQotCXNvIGJlIGNhcmVmdWxsIGlmIHRoaXMgY29kZSBpcyByZXN0b3JlZAorCXNvIGJlIGNhcmVmdWwgaWYgdGhpcyBjb2RlIGlzIHJlc3RvcmVkCiAjZW5kaWYgLy8gSENGX1NMRUVQCiAjZW5kaWYgLy8gMAogCkBAIC0xNTYzLDcgKzE1NjMsNyBAQAogKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBieSB0aGUgTVNGIHRvIHN1cHBseSB0aGUgSENGIHdpdGggbmV3L21vcmUgYnVmZmVycyBmb3IgcmVjZWl2ZSBwdXJwb3Nlcy4KICogVGhlIEhDRiBjYW4gYmUgdXNlZCBpbiAyIGZhc2hpb25zOiB3aXRoIGFuZCB3aXRob3V0IGVuY2Fwc3VsYXRpb24gZm9yIGRhdGEgdHJhbnNmZXIuCiAqIFRoaXMgaXMgY29udHJvbGxlZCBhdCBjb21waWxlIHRpbWUgYnkgdGhlIEhDRl9FTkMgYml0IG9mIHRoZSBIQ0ZfRU5DQVAgc3lzdGVtIGNvbnN0YW50LgotKiBBcyBhIGNvbnNlcXVlbmNlLCBzb21lIGFkZGl0aW9uYWwgY29uc3RhaW50cyBhcHBseSB0byB0aGUgbnVtYmVyIG9mIGRlc2NyaXB0b3IgYW5kIHRoZSBidWZmZXJzIGFzc29jaWF0ZWQKKyogQXMgYSBjb25zZXF1ZW5jZSwgc29tZSBhZGRpdGlvbmFsIGNvbnN0cmFpbnRzIGFwcGx5IHRvIHRoZSBudW1iZXIgb2YgZGVzY3JpcHRvciBhbmQgdGhlIGJ1ZmZlcnMgYXNzb2NpYXRlZAogKiB3aXRoIHRoZSBmaXJzdCAyIGRlc2NyaXB0b3JzLiBJbmRlcGVuZGVudCBvZiB0aGUgZW5jYXBzdWxhdGlvbiBmZWF0dXJlLCB0aGUgQ09VTlQgZmllbGRzIGFyZSBpZ25vcmVkLgogKiBBIHNwZWNpYWwgY2FzZSBpcyB0aGUgc3VwcGx5aW5nIG9mIHRoZSBERUxXQSBkZXNjcmlwdG9yLCB3aGljaCBtdXN0IGJlIHN1cHBsaWVkIGFzIHRoZSBmaXJzdCBkZXNjcmlwdG9yLgogKgpAQCAtMTczNSw3ICsxNzM1LDcgQEAKICogLSBpbiBjYXNlIGVuY2Fwc3VsYXRpb24gYnkgdGhlIEhDRiBpcyBzZWxlY3RlZDoKICoJICAtCVRoZSBGcmFtZUxpc3QgZG9lcyBub3QgY29uc2lzdHMgb2YgYXQgbGVhc3QgMiBEZXNjcmlwdG9ycy4KICoJICAtCVRoZSBmaXJzdCBkYXRhYnVmZmVyIGRvZXMgbm90IGNvbnRhaW4gZXhhY3RseSB0aGUgKHNwYWNlIGZvcikgdGhlIDgwMi4xMSBoZWFkZXIgKD09IDI4IHdvcmRzKQotKgkgIC0JVGhlIGZpcnN0IGRhdGFidWZmZXIgZG9lcyBub3QgaGF2ZSBhIHNpemUgdG8gYWRkaXRpb25hbGx5IGFjY29tb2RhdGUgdGhlIDgwMi4zIGhlYWRlciBhbmQgdGhlCisqCSAgLQlUaGUgZmlyc3QgZGF0YWJ1ZmZlciBkb2VzIG5vdCBoYXZlIGEgc2l6ZSB0byBhZGRpdGlvbmFsbHkgYWNjb21tb2RhdGUgdGhlIDgwMi4zIGhlYWRlciBhbmQgdGhlCiAqCQlTTkFQIGhlYWRlciBvZiB0aGUgZnJhbWUgYWZ0ZXIgZW5jYXBzdWxhdGlvbiAoPT0gMzkgd29yZHMpLgogKgkgIC0JVGhlIHNlY29uZCBkYXRhYnVmZmVyIGRvZXMgbm90IGNvbnRhaW4gYXQgbGVhc3QgREEsIFNBIGFuZCAndHlwZS9sZW5ndGgnICg9PTE0IGJ5dGVzIG9yIDcgd29yZHMpCiAqISEgVGhlIDJuZCBwYXJ0IG9mIHRoZSBsaXN0IG9mIGFzc2VydHMgc2hvdWxkIGJlIGtlcHQgaW4gc3luYyB3aXRoIHB1dF9mcmFtZV9sc3QsIGluIG9yZGVyIHRvIGdldApAQCAtMTc2MiwxNCArMTc2MiwxNCBAQAogKgktIENvcHkgREEvU0EgZmllbGRzIGZyb20gdGhlIDJuZCBidWZmZXIKICogICAtIENhbGN1bGF0ZSB0b3RhbCBsZW5ndGggb2YgdGhlIG1lc3NhZ2UgKHNuYXAtaGVhZGVyICsgdHlwZS1maWVsZCArIHRoZSBsZW5ndGggb2YgYWxsIGJ1ZmZlciBmcmFnbWVudHMKICogICAgIGFzc29jaWF0ZWQgd2l0aCB0aGUgODAyLjMgZnJhbWUgKGkuZSBhbGwgZGVzY3JpcHRvcnMgZXhjZXB0IHRoZSBmaXJzdCksIGJ1dCBub3QgdGhlIERlc3RpbmF0aW9uQWRkcmVzcywKLSogICAgIFNvdXJjZUFkZHJlc3MgYW5kIGxlbmdodC1maWVsZCkKKyogICAgIFNvdXJjZUFkZHJlc3MgYW5kIGxlbmd0aC1maWVsZCkKICogICAgIEFzc2VydCB0aGUgbWVzc2FnZSBsZW5ndGgKICoJICBXcml0ZSBsZW5ndGguIE5vdGUgdGhhdCB0aGUgbWVzc2FnZSBpcyBpbiBCRSBmb3JtYXQsIGhlbmNlIG9uIExFIHBsYXRmb3JtcyB0aGUgbGVuZ3RoIG11c3QgYmUgY29udmVydGVkCiAqCSAgOz8gVEhJUyBJUyBOT1QgV0hBVCBDVVJSRU5UTFkgSVMgSU1QTEVNRU5URUQKICoJLSBXcml0ZSBzbmFwIGhlYWRlci4gTm90ZSB0aGF0IHRoZSBsYXN0IGJ5dGUgb2YgdGhlIHNuYXAgaGVhZGVyIGlzIE5PVCBjb3BpZWQsIHRoYXQgYnl0ZSBpcyBhbHJlYWR5IGluCiAqCSAgcGxhY2UgYXMgcmVzdWx0IG9mIHRoZSBjYWxsIHRvIGhjZl9lbmNhcC4KICoJTm90ZSB0aGF0IHRoZXJlIGFyZSBtYW55IHdheXMgdG8gc2tpbiBhIGNhdC4gVG8gZXhwcmVzcyB0aGUgb2Zmc2V0cyBpbiB0aGUgMXN0IGJ1ZmZlciB3aGlsZSB3cml0aW5nCi0qCXRoZSBzbmFwIGhlYWRlciwgSEZTX1RZUEUgaXMgY2hvb3NlbiBhcyBhIHJlZmVyZW5jZSBwb2ludCB0byBtYWtlIGl0IGVhc2llciB0byBncmFzcCB0aGF0IHRoZSBzbmFwIGhlYWRlcgorKgl0aGUgc25hcCBoZWFkZXIsIEhGU19UWVBFIGlzIGNob3NlbiBhcyBhIHJlZmVyZW5jZSBwb2ludCB0byBtYWtlIGl0IGVhc2llciB0byBncmFzcCB0aGF0IHRoZSBzbmFwIGhlYWRlcgogKglhbmQgZW5jYXBzdWFsdGlvbiB0eXBlIGFyZSBhdCBsZWFzdCByZWxhdGl2ZSBpbiB0aGUgcmlnaHQuCiAqODoJbW9kaWZ5IDFzdCBkZXNjcmlwdG9yIHRvIHJlZmxlY3QgbW92ZWQgcGFydCBvZiB0aGUgODAyLjMgaGVhZGVyICsgU25hcC1oZWFkZXIKICoJbW9kaWZ5IDJuZCBkZXNjcmlwdG9yIHRvIHNraXAgdGhlIG1vdmVkIHBhcnQgb2YgdGhlIDgwMi4zIGhlYWRlciAoREEvU0EKQEAgLTE5MzMsNyArMTkzMyw3IEBACiAqCUhDRl9TVUNDRVNTCQkJU3VjY2VzcwogKiEhCXZpYSBjbWRfZXhlICggdHlwZSA+PSBDRkdfUklEX0ZXX01JTiApCiAqCUhDRl9FUlJfTk9fTklDCQlOSUMgcmVtb3ZlZCBkdXJpbmcgcmV0cmlldmFsCi0qCUhDRl9FUlJfVElNRV9PVVQJRXhwZWN0ZWQgSGVybWVzIGV2ZW50IGRpZCBub3Qgb2NjdXJlIGluIGV4cGVjdGVkIHRpbWUKKyoJSENGX0VSUl9USU1FX09VVAlFeHBlY3RlZCBIZXJtZXMgZXZlbnQgZGlkIG5vdCBvY2N1ciBpbiBleHBlY3RlZCB0aW1lCiAqISEJdmlhIGNtZF9leGUgYW5kIHNldHVwX2JhcCAodHlwZSA+PSBDRkdfUklEX0ZXX01JTiApCiAqCUhDRl9FUlJfREVGVU5DVF8uLi4JSENGIGlzIGluIGRlZnVuY3QgbW9kZSAoYml0cyAweDdGIHJlZmxlY3QgY2F1c2UpCiAqCkBAIC0yOTU4LDcgKzI5NTgsNyBAQAogKgloY2Zfc2VydmljZV9uaWMgaXMgYWxzbyBza2lwcGVkIGluIHRob3NlIGNhc2VzLgogKglUbyBwcmV2ZW50IHRoYXQgaGNmX3NlcnZpY2VfbmljIHJlcG9ydHMgYm9ndXMgaW5mb3JtYXRpb24gdG8gdGhlIE1TRiB3aXRoIGFsbCAtIHBvc3NpYmx5IGRpZmZpY3VsdCB0bwogKglkZWJ1ZyAtIHVuZGVzaXJhYmxlIHNpZGUgZWZmZWN0cywgaXQgaXMgcGFyYW1vdW50IHRvIGNoZWNrIHRoZSBOSUMgcHJlc2VuY2UuIEluIGZvcm1lciBkYXlzIHRoZSBwcmVzZW5jZQotKgl0ZXN0IHdhcyBiYXNlZCBvbiB0aGUgSGVybWVzIHJlZ2lzdGVyIEhSRUdfU1dfMC4gU2luY2UgaW4gSENGX0FDVF9JTlRfT0ZGIGlzIGNob29zZW4gZm9yIHN0cmF0ZWd5IGJhc2VkIG9uCisqCXRlc3Qgd2FzIGJhc2VkIG9uIHRoZSBIZXJtZXMgcmVnaXN0ZXIgSFJFR19TV18wLiBTaW5jZSBpbiBIQ0ZfQUNUX0lOVF9PRkYgaXMgY2hvc2VuIGZvciBzdHJhdGVneSBiYXNlZCBvbgogKglIUkVHX0VWX1NUQVQsIHRoaXMgaXMgbm93IGFsc28gdXNlZCBpbiBoY2Zfc2VydmljZV9uaWMuIFRoZSBtb3RpdmF0aW9uIHRvIGNoYW5nZSBzdHJhdGVneSBpcyBwYXJ0bHkKICoJZHVlIHRvIGluY29uc2lzdGVudCBGL1cgaW1wbGVtZW50YXRpb25zIHdpdGggcmVzcGVjdCB0byBIUkVHX1NXXzAgbWFuaXB1bGF0aW9uIGFyb3VuZCByZXNldCBhbmQgZG93bmxvYWQuCiAqCU5vdGUgdGhhdCBpbiBwb2xsZWQgZW52aXJvbm1lbnRzIENhcmQgUmVtb3ZhbCBpcyBub3QgZGV0ZWN0ZWQgYnkgSU5UX09GRiB3aGljaCBtYWtlcyB0aGUgY2hlY2sgaW4KQEAgLTQwNDgsNyArNDA0OCw3IEBACiAJSENGQVNTRVJUKCB3b3JkX2xlbiA9PSAwIHx8IHdvcmRfbGVuID09IDIgfHwgd29yZF9sZW4gPT0gNCwgd29yZF9sZW4gKQogCUhDRkFTU0VSVCggd29yZF9sZW4gPT0gMCB8fCAoKGhjZl8zMilidWZwICYgMSApID09IDAsIChoY2ZfMzIpYnVmcCApCiAJSENGQVNTRVJUKCB3b3JkX2xlbiA8PSBsZW4sIE1FUkdFMiggd29yZF9sZW4sIGxlbiApICkKLQkvL3NlZSBwdXRfZnJhZyBmb3IgYW4gYWx0ZXJuYXRpdmUgaW1wbGVtZW50YXRpb24sIGJ1dCBiZSBjYXJlZnVsbCBhYm91dCB3aGF0IGFyZSBpbnQncyBhbmQgd2hhdCBhcmUKKwkvL3NlZSBwdXRfZnJhZyBmb3IgYW4gYWx0ZXJuYXRpdmUgaW1wbGVtZW50YXRpb24sIGJ1dCBiZSBjYXJlZnVsIGFib3V0IHdoYXQgYXJlIGludCdzIGFuZCB3aGF0IGFyZQogCS8vaGNmXzE2J3MKIAlpZiAoIHdvcmRfbGVuICkgewkJCQkJCQkJLy8uICBpZiB0aGVyZSBpcyBhbnl0aGluZyB0byBjb252ZXJ0CiBoY2ZfOCBjOwpAQCAtNDcxMiw3ICs0NzEyLDcgQEAKICoJTm90ZSB0aGF0IGxlbiBpcyB1bnNpZ25lZCwgc28gZXZlbiBNU0YgSS9GIHZpb2xhdGlvbiB3b3JrcyBvdXQgTy5LLgogKglUaGUgJzInIGluIHRoZSBleHByZXNzaW9uICJsZW4rMiIgaXMgdXNlZCBiZWNhdXNlIDEgd29yZCBpcyBuZWVkZWQgZm9yIEwgaXRzZWxmIGFuZCAxIHdvcmQgaXMgbmVlZGVkCiAqCWZvciB0aGUgemVyby1zZW50aW5lbAotKjg6CXVwZGF0ZSBNYWlsQm94IEluZm8gbGVuZ3RoIHJlcG9ydCB0byBNU0Ygd2l0aCAib2xkZXN0IiBNQiBJbmZvIEJsb2NrIHNpemUuIEJlIGNhcmVmdWxsIGhlcmUsIGlmIHlvdSBnZXQKKyo4Ogl1cGRhdGUgTWFpbEJveCBJbmZvIGxlbmd0aCByZXBvcnQgdG8gTVNGIHdpdGggIm9sZGVzdCIgTUIgSW5mbyBCbG9jayBzaXplLiBCZSBjYXJlZnVsIGhlcmUsIGlmIHlvdSBnZXQKICoJaGVyZSBiZWZvcmUgdGhlIE1haWxCb3ggaXMgcmVnaXN0ZXJlZCwgeW91IGNhbid0IHJlYWQgZnJvbSB0aGUgYnVmZmVyIGFkZHJlc3NlZCBieSBJRkJfTUJwIChpdCBpcyB0aGUKICoJTnVsbCBidWZmZXIpIHNvIGRvbid0IG1vdmUgdGhpcyBjb2RlIHRpbGwgdGhlIGVuZCBvZiB0aGlzIHJvdXRpbmUgYnV0IGtlZXAgaXQgd2hlcmUgdGhlcmUgaXMgZ2FydWFudGVlZAogKglhIGJ1ZmZlci4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyL2hjZmRlZi5oIGIvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvaGNmZGVmLmgKaW5kZXggNGUyMDE3MS4uY2IxOTY2ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvaGNmZGVmLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvaGNmZGVmLmgKQEAgLTMxNSw3ICszMTUsNyBAQAogCiAjaWYgSENGX0RNQQogLy8qKioqKioqKioqKioqKioqKioqKioqKioqIERNQSAoYnVzIG1hc3RlcmluZykKLQkvLyBCZSBjYXJlZnVsbCB0byB1c2UgdGhlc2UgcmVnaXN0ZXJzIG9ubHkgYXQgYSBnZW51aW5lIDMyIGJpdHMgTklDCisJLy8gQmUgY2FyZWZ1bCB0byB1c2UgdGhlc2UgcmVnaXN0ZXJzIG9ubHkgYXQgYSBnZW51aW5lIDMyIGJpdHMgTklDCiAJLy8gT24gMTYgYml0cyBOSUNzLCB0aGVzZSBhZGRyZXNzZXMgYXJlIG1hcHBlZCBpbnRvIHRoZSByYW5nZSAweDAwIHRocm91Z2ggMHgzRiB3aXRoIGFsbCBjb25zZXF1ZW5jZXMKIAkvLyB0aGVyZW9mLCBlLmcuICBIUkVHX0RNQV9DVFJMIHJlZ2lzdGVyIG1hcHMgdG8gSFJFR19DTUQuCiAjZGVmaW5lIEhSRUdfRE1BX0NUUkwJCQkJCQkweDAwNDAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyL3dsX3dleHQuYyBiL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyL3dsX3dleHQuYwppbmRleCA5ZTVkYTA4Li41MjJhMzEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMi93bF93ZXh0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3dsYWdzNDlfaDIvd2xfd2V4dC5jCkBAIC0yNTc1LDcgKzI1NzUsNyBAQAogICAgICAgICAgKiBUaGlzIGxvb2tzIGxpa2UgYSBuaWNlIHBsYWNlIHRvIHRlc3QgaWYgdGhlIEhDRiBpcyBzdGlsbAogICAgICAgICAgKiBjb21tdW5pY2F0aW5nIHdpdGggdGhlIGNhcmQuIEl0IHNlZW1zIHRoYXQgc29tZXRpbWVzIEJBUF8xCiAgICAgICAgICAqIGdldHMgY29ycnVwdGVkLiBCeSBsb29raW5nIGF0IHRoZSBjb21tZW50cyBpbiBIQ0YgdGhlCi0gICAgICAgICAqIGNhdXNlIGlzIHN0aWxsIGEgbWlzdGVyeS4gT2theSwgdGhlIGNvbW11bmljYXRpb24gdG8gdGhlCisgICAgICAgICAqIGNhdXNlIGlzIHN0aWxsIGEgbXlzdGVyeS4gT2theSwgdGhlIGNvbW11bmljYXRpb24gdG8gdGhlCiAgICAgICAgICAqIGNhcmQgaXMgZGVhZCwgcmVzZXQgdGhlIGNhcmQgdG8gcmV2aXZlLgogICAgICAgICAgKi8KIAlpZigobHAtPmhjZkN0eC5JRkJfQ2FyZFN0YXQgJiBDQVJEX1NUQVRfREVGVU5DVCkgIT0gMCkKQEAgLTM5MjQsNyArMzkyNCw3IEBACiAJbWVtc2V0KCBtc2csIDAsIHNpemVvZiggbXNnICkpOwogCiAKLQkvKiBCZWN1YXNlIE1JQyBmYWlsdXJlcyBhcmUgbm90IHBhcnQgb2YgdGhlIFdpcmVsZXNzIEV4dGVuc2lvbnMgeWV0LCB0aGV5CisJLyogQmVjYXVzZSBNSUMgZmFpbHVyZXMgYXJlIG5vdCBwYXJ0IG9mIHRoZSBXaXJlbGVzcyBFeHRlbnNpb25zIHlldCwgdGhleQogCSAgIG11c3QgYmUgcGFzc2VkIGFzIGEgc3RyaW5nIHVzaW5nIGFuIElXRVZDVVNUT00gZXZlbnQuIEluIG9yZGVyIGZvciB0aGUKIAkgICBldmVudCB0byBiZSBlZmZlY3RpdmUsIHRoZSBzdHJpbmcgZm9ybWF0IG11c3QgYmUga25vd24gYnkgYm90aCB0aGUKIAkgICBkcml2ZXIgYW5kIHRoZSBzdXBwbGljYW50LiBUaGUgZm9sbG93aW5nIGlzIHRoZSBzdHJpbmcgZm9ybWF0IHVzZWQgYnkgdGhlCkBAIC0zOTk5LDcgKzM5OTksNyBAQAogCQltZW1jcHkoICZkYXRhLnJhd0RhdGEsICYoIGxwLT5sdHZSZWNvcmQudS51OFsxXSApLCA4OCApOwogCQl3cGFfaWUgPSB3bF9wYXJzZV93cGFfaWUoICZkYXRhLCAmbGVuZ3RoICk7CiAKLQkJLyogQmVjdWFzZSB0aGlzIGV2ZW50IChBc3NvY2lhdGlvbiBXUEEtSUUpIGlzIG5vdCBwYXJ0IG9mIHRoZSBXaXJlbGVzcworCQkvKiBCZWNhdXNlIHRoaXMgZXZlbnQgKEFzc29jaWF0aW9uIFdQQS1JRSkgaXMgbm90IHBhcnQgb2YgdGhlIFdpcmVsZXNzCiAJCUV4dGVuc2lvbnMgeWV0LCBpdCBtdXN0IGJlIHBhc3NlZCBhcyBhIHN0cmluZyB1c2luZyBhbiBJV0VWQ1VTVE9NIGV2ZW50LgogCQlJbiBvcmRlciBmb3IgdGhlIGV2ZW50IHRvIGJlIGVmZmVjdGl2ZSwgdGhlIHN0cmluZyBmb3JtYXQgbXVzdCBiZSBrbm93bgogCQlieSBib3RoIHRoZSBkcml2ZXIgYW5kIHRoZSBzdXBwbGljYW50LiBUaGUgZm9sbG93aW5nIGlzIHRoZSBzdHJpbmcgZm9ybWF0CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2xhZ3M0OV9oMjUvVE9ETyBiL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyNS9UT0RPCmluZGV4IDE0YWE0MTUuLjk0MDMyYjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyNS9UT0RPCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93bGFnczQ5X2gyNS9UT0RPCkBAIC0xLDcgKzEsNyBAQAogRmlyc3Qgb2YgYWxsLCB0aGUgYmVzdCB0aGluZyB3b3VsZCBiZSB0aGF0IHRoaXMgZHJpdmVyIGJlY29tZXMgb2Jzb2x0ZSBieQogYWRkaW5nIHN1cHBvcnQgZm9yIEhlcm1lcyBJSSBhbmQgSGVybWVzIElJLjUgY2FyZHMgdG8gdGhlIGV4aXN0aW5nIG9yaW5vY28KIGRyaXZlci4gVGhlIG9yaW5vY28gZHJpdmVyIGN1cnJlbnRseSBvbmx5IHN1cHBvcnRzIEhlcm1lcyBJIGJhc2VkIGNhcmRzLgotU2luY2UgdGhpcyB3aWxsIG5vdCBoYXBwZW4gYnkgbWFnaWMgYW5kIGhhcyBub3QgaGFwcGVuZCB1bnRpbCBub3cgdGhpcworU2luY2UgdGhpcyB3aWxsIG5vdCBoYXBwZW4gYnkgbWFnaWMgYW5kIGhhcyBub3QgaGFwcGVuZWQgdW50aWwgbm93IHRoaXMKIGRyaXZlciBwcm92aWRlcyBhIHN0b3AtZ2FwIHNvbHV0aW9uIGZvciB0aGVzZSB0eXBlIG9mIGNhcmRzLgogCiBIYXZpbmcgc2FpZCB0aGF0LCB0aGUgZm9sbG93aW5nIHdpc2hsaXN0IGNvbWVzIHRvIG1pbmQgdG8gbWFrZSB0aGUgZHJpdmVyCkBAIC0xOCw3ICsxOCw3IEBACiAJLSB0aGUgZHJpdmVyIGlzIHNwbGl0IGludG8gYSBIZXJtZXMgSUkgYW5kIGEgSGVybWVzIElJLjUgcGFydCwgaXQKIAkgIHdvdWxkIGJlIG5pY2UgdG8gaGFuZGxlIGJvdGggd2l0aCBvbmUgbW9kdWxlIGluc3RlYWQgb2YgdHdvCiAJLSByZXZpZXcgYnkgdGhlIHdpcmVsZXNzIGRldmVsb3BlciBjb21tdW5pdHkKLQktIHZlcmlmeSB0aGUgY29kZSBhZ2FpbnN0IHRoZSBjb2Rpbmcgc3RhbmRhcmRzIGZvciBhIHByb3BwZXIgbGludXgKKwktIHZlcmlmeSB0aGUgY29kZSBhZ2FpbnN0IHRoZSBjb2Rpbmcgc3RhbmRhcmRzIGZvciBhIHByb3BlciBsaW51eAogCSAgZHJpdmVyCiAJLSByZXNvbHZlIGxpY2Vuc2UgaXNzdWVzICg/KQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvd2xhbi1uZy9wcmlzbTJzdGEuYyBiL2RyaXZlcnMvc3RhZ2luZy93bGFuLW5nL3ByaXNtMnN0YS5jCmluZGV4IGVkNzUxZjQuLjIxZjI1YTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy93bGFuLW5nL3ByaXNtMnN0YS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy93bGFuLW5nL3ByaXNtMnN0YS5jCkBAIC0xOTc2LDcgKzE5NzYsNyBAQAogCiAJd2xhbmRldi0+bnNkY2FwcyA9IFA4MDIxMV9OU0RDQVBfSFdGUkFHTUVOVCB8IFA4MDIxMV9OU0RDQVBfQVVUT0pPSU47CiAKLQkvKiBJbml0aWFsaXplIHRoZSBkZXZpY2UgcHJpdmF0ZSBkYXRhIHN0dWN0dXJlLiAqLworCS8qIEluaXRpYWxpemUgdGhlIGRldmljZSBwcml2YXRlIGRhdGEgc3RydWN0dXJlLiAqLwogCWh3LT5kb3QxMV9kZXNpcmVkX2Jzc190eXBlID0gMTsKIAogCXJldHVybiB3bGFuZGV2OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3hnaWZiL3ZiX3NldG1vZGUuYyBiL2RyaXZlcnMvc3RhZ2luZy94Z2lmYi92Yl9zZXRtb2RlLmMKaW5kZXggODc2MmE1My4uOTY2OWMyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3hnaWZiL3ZiX3NldG1vZGUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcveGdpZmIvdmJfc2V0bW9kZS5jCkBAIC03ODM0LDcgKzc4MzQsNyBAQAogCQkJCQkJPT0gNjAwKSkgewogCQkJaW5kZXgrKzsKIAkJfQotCQkvKiBBbGFuIDEwLzE5LzIwMDc7IGRvIHRoZSBzaW1pbGlhciBhZGp1c3RtZW50IGxpa2UgWEdJU2VhcmNoQ1JUMVJhdGUoKSAqLworCQkvKiBBbGFuIDEwLzE5LzIwMDc7IGRvIHRoZSBzaW1pbGFyIGFkanVzdG1lbnQgbGlrZSBYR0lTZWFyY2hDUlQxUmF0ZSgpICovCiAJCWlmICgocFZCSW5mby0+UmVmSW5kZXhbUmVmcmVzaFJhdGVUYWJsZUluZGV4XS5YUmVzID09IDEwMjQpCiAJCQkJJiYgKHBWQkluZm8tPlJlZkluZGV4W1JlZnJlc2hSYXRlVGFibGVJbmRleF0uWVJlcwogCQkJCQkJPT0gNzY4KSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3hnaWZiL3ZnYXR5cGVzLmggYi9kcml2ZXJzL3N0YWdpbmcveGdpZmIvdmdhdHlwZXMuaAppbmRleCA0Yjg3OTUxLi5kNjEzZTg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcveGdpZmIvdmdhdHlwZXMuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcveGdpZmIvdmdhdHlwZXMuaApAQCAtODUsNyArODUsNyBAQAogCQkJCQkgICAgdW5zaWduZWQgbG9uZyAqKTsKIH07CiAKLS8qIEFkZHRpb25hbCBJT0NUTCBmb3IgY29tbXVuaWNhdGlvbiB4Z2lmYiA8PiBYIGRyaXZlciAgICAgICAgKi8KKy8qIEFkZGl0aW9uYWwgSU9DVEwgZm9yIGNvbW11bmljYXRpb24geGdpZmIgPD4gWCBkcml2ZXIgICAgICAgICovCiAvKiBJZiBjaGFuZ2luZyB0aGlzLCB4Z2lmYi5oIG11c3QgYWxzbyBiZSBjaGFuZ2VkIChmb3IgeGdpZmIpICovCiAKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfYWx1YS5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfYWx1YS5jCmluZGV4IDJjNWZjZmUuLjMwY2JiNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2FsdWEuYworKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9hbHVhLmMKQEAgLTQ5Niw4ICs0OTYsOCBAQAogCW5vbm9wX2RlbGF5X21zZWNzID0gdGdfcHRfZ3AtPnRnX3B0X2dwX25vbm9wX2RlbGF5X21zZWNzOwogCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKIAkvKgotCSAqIFByb2Nlc3MgQUxVQV9BQ0NFU1NfU1RBVEVfQUNUSVZFX09QVE1JWkVEIGluIGEgc2VwZXJhdGUgY29uZGl0aW9uYWwKLQkgKiBzdGF0ZW1lbnQgc28gdGhlIGNvbXBsaWVyIGtub3dzIGV4cGxpY3RseSB0byBjaGVjayB0aGlzIGNhc2UgZmlyc3QuCisJICogUHJvY2VzcyBBTFVBX0FDQ0VTU19TVEFURV9BQ1RJVkVfT1BUTUlaRUQgaW4gYSBzZXBhcmF0ZSBjb25kaXRpb25hbAorCSAqIHN0YXRlbWVudCBzbyB0aGUgY29tcGlsZXIga25vd3MgZXhwbGljaXRseSB0byBjaGVjayB0aGlzIGNhc2UgZmlyc3QuCiAJICogRm9yIHRoZSBPcHRpbWl6ZWQgQUxVQSBhY2Nlc3Mgc3RhdGUgY2FzZSwgd2Ugd2FudCB0byBwcm9jZXNzIHRoZQogCSAqIGluY29taW5nIGZhYnJpYyBjbWQgQVNBUC4uCiAJICovCkBAIC0xMTU3LDcgKzExNTcsNyBAQAogCQlzcGluX3VubG9jaygmbHVfZ3AtPmx1X2dwX2xvY2spOwogCQkvKgogCQkgKgotCQkgKiBsdV9ncF9tZW0gaXMgYXNzb2ljYXRlZCB3aXRoIGEgc2luZ2xlCisJCSAqIGx1X2dwX21lbSBpcyBhc3NvY2lhdGVkIHdpdGggYSBzaW5nbGUKIAkJICogc3RydWN0IHNlX2RldmljZS0+ZGV2X2FsdWFfbHVfZ3BfbWVtLCBhbmQgaXMgcmVsZWFzZWQgd2hlbgogCQkgKiBzdHJ1Y3Qgc2VfZGV2aWNlIGlzIHJlbGVhc2VkIHZpYSBjb3JlX2FsdWFfZnJlZV9sdV9ncF9tZW0oKS4KIAkJICoKQEAgLTE0MjksNyArMTQyOSw3IEBACiAJCX0KIAkJc3Bpbl91bmxvY2soJnRnX3B0X2dwLT50Z19wdF9ncF9sb2NrKTsKIAkJLyoKLQkJICogdGdfcHRfZ3BfbWVtIGlzIGFzc29pY2F0ZWQgd2l0aCBhIHNpbmdsZQorCQkgKiB0Z19wdF9ncF9tZW0gaXMgYXNzb2NpYXRlZCB3aXRoIGEgc2luZ2xlCiAJCSAqIHNlX3BvcnQtPnNlcF9hbHVhX3RnX3B0X2dwX21lbSwgYW5kIGlzIHJlbGVhc2VkIHZpYQogCQkgKiBjb3JlX2FsdWFfZnJlZV90Z19wdF9ncF9tZW0oKS4KIAkJICoKQEAgLTE5NjMsNyArMTk2Myw3IEBACiAJCXByaW50ayhLRVJOX0lORk8gIiVzOiBFbmFibGluZyBBTFVBIEVtdWxhdGlvbiBmb3IgU1BDLTMiCiAJCQkiIGRldmljZVxuIiwgVFJBTlNQT1JUKGRldiktPm5hbWUpOwogCQkvKgotCQkgKiBBc3NvaWNhdGUgdGhpcyBzdHJ1Y3Qgc2VfZGV2aWNlIHdpdGggdGhlIGRlZmF1bHQgQUxVQQorCQkgKiBBc3NvY2lhdGUgdGhpcyBzdHJ1Y3Qgc2VfZGV2aWNlIHdpdGggdGhlIGRlZmF1bHQgQUxVQQogCQkgKiBMVU4gR3JvdXAuCiAJCSAqLwogCQlsdV9ncF9tZW0gPSBjb3JlX2FsdWFfYWxsb2NhdGVfbHVfZ3BfbWVtKGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCmluZGV4IDNmYjhlMzIuLmQyNWUyMDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC0zNzEsNyArMzcxLDcgQEAKIAlpZiAoIShlbmFibGUpKSB7CiAJCS8qCiAJCSAqIGRldmUtPnNlX2x1bl9hY2wgd2lsbCBiZSBOVUxMIGZvciBkZW1vLW1vZGUgY3JlYXRlZCBMVU5zCi0JCSAqIHRoYXQgaGF2ZSBub3QgYmVlbiBleHBsaWN0bHkgY29uY2VydGVkIHRvIE1hcHBlZExVTnMgLT4KKwkJICogdGhhdCBoYXZlIG5vdCBiZWVuIGV4cGxpY2l0bHkgY29uY2VydGVkIHRvIE1hcHBlZExVTnMgLT4KIAkJICogc3RydWN0IHNlX2x1bl9hY2wsIGJ1dCB3ZSByZW1vdmUgZGV2ZS0+YWx1YV9wb3J0X2xpc3QgZnJvbQogCQkgKiBwb3J0LT5zZXBfYWx1YV9saXN0LiBUaGlzIGFsc28gbWVhbnMgdGhhdCBhY3RpdmUgVUFzIGFuZAogCQkgKiBOb2RlQUNMIGNvbnRleHQgc3BlY2lmaWMgUFIgbWV0YWRhdGEgZm9yIGRlbW8tbW9kZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2xpYi5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2xpYi5jCmluZGV4IGQ1N2FkNjcuLjFlMTkzZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19saWIuYworKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfbGliLmMKQEAgLTQzMyw3ICs0MzMsNyBAQAogCQkvKgogCQkgKiBHbyBhaGVhZCBhbmQgZG8gdGhlIGxvd2VyIGNhc2UgY29udmVyc2lvbiBvZiB0aGUgcmVjZWl2ZWQKIAkJICogMTIgQVNDSUkgY2hhcmFjdGVycyByZXByZXNlbnRpbmcgdGhlIElTSUQgaW4gdGhlIFRyYW5zcG9ydElECi0JCSAqIGZvciBjb21wYXJpc2lvbiBhZ2FpbnN0IHRoZSBydW5uaW5nIGlTQ1NJIHNlc3Npb24ncyBJU0lEIGZyb20KKwkJICogZm9yIGNvbXBhcmlzb24gYWdhaW5zdCB0aGUgcnVubmluZyBpU0NTSSBzZXNzaW9uJ3MgSVNJRCBmcm9tCiAJCSAqIGlzY3NpX3RhcmdldC5jOmxpb19zZXNzX2dldF9pbml0aWF0b3Jfc2lkKCkKIAkJICovCiAJCWZvciAoaSA9IDA7IGkgPCAxMjsgaSsrKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9maWxlLmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9maWxlLmMKaW5kZXggMDJmNTUzYS4uMTUwYzQzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmlsZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2ZpbGUuYwpAQCAtMTU5LDcgKzE1OSw3IEBACiAjZW5kaWYKIC8qCWZsYWdzIHw9IE9fRElSRUNUOyAqLwogCS8qCi0JICogSWYgZmRfYnVmZmVyZWRfaW89MSBoYXMgbm90IGJlZW4gc2V0IGV4cGxpY3RseSAodGhlIGRlZmF1bHQpLAorCSAqIElmIGZkX2J1ZmZlcmVkX2lvPTEgaGFzIG5vdCBiZWVuIHNldCBleHBsaWNpdGx5ICh0aGUgZGVmYXVsdCksCiAJICogdXNlIE9fU1lOQyB0byBmb3JjZSBGSUxFSU8gd3JpdGVzIHRvIGRpc2suCiAJICovCiAJaWYgKCEoZmRfZGV2LT5mYmRfZmxhZ3MgJiBGREJEX1VTRV9CVUZGRVJFRF9JTykpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wci5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcHIuYwppbmRleCAyNTIxZjc1Li5hNzlmNTE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wci5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3ByLmMKQEAgLTQ3OCw3ICs0NzgsNyBAQAogCQlicmVhazsKIAl9CiAJLyoKLQkgKiBDYXNlIHdoZXJlIHRoZSBDREIgaXMgZXhwbGljdGx5IGFsbG93ZWQgaW4gdGhlIGFib3ZlIHN3aXRjaAorCSAqIENhc2Ugd2hlcmUgdGhlIENEQiBpcyBleHBsaWNpdGx5IGFsbG93ZWQgaW4gdGhlIGFib3ZlIHN3aXRjaAogCSAqIHN0YXRlbWVudC4KIAkgKi8KIAlpZiAoIShyZXQpICYmICEob3RoZXJfY2RiKSkgewpAQCAtMzczNSw3ICszNzM1LDcgQEAKIAkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOwogCiAJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCAyNCkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtUFI6IFJlY2lldmVkIFBSIE9VVCBwYXJhbWV0ZXIgbGlzdCIKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiU1BDLVBSOiBSZWNlaXZlZCBQUiBPVVQgcGFyYW1ldGVyIGxpc3QiCiAJCQkiIGxlbmd0aCB0b28gc21hbGw6ICV1XG4iLCBjbWQtPmRhdGFfbGVuZ3RoKTsKIAkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKIAl9CkBAIC0zNzc4LDcgKzM3NzgsNyBAQAogCSAqLwogCWlmICghKHNwZWNfaV9wdCkgJiYgKChjZGJbMV0gJiAweDFmKSAhPSBQUk9fUkVHSVNURVJfQU5EX01PVkUpICYmCiAJICAgIChjbWQtPmRhdGFfbGVuZ3RoICE9IDI0KSkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtUFI6IFJlY2lldmVkIFBSIE9VVCBpbGxlZ2FsIHBhcmFtZXRlciIKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiU1BDLVBSOiBSZWNlaXZlZCBQUiBPVVQgaWxsZWdhbCBwYXJhbWV0ZXIiCiAJCQkiIGxpc3QgbGVuZ3RoOiAldVxuIiwgY21kLT5kYXRhX2xlbmd0aCk7CiAJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0LmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuYwppbmRleCBiZjZhYThhLi45NTgzYjIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuYworKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuYwpAQCAtNzE5LDcgKzcxOSw3IEBACiAJCQljbWQtPnNlX2x1biA9IE5VTEw7CiAJCQkvKgogCQkJICogU29tZSBmYWJyaWMgbW9kdWxlcyBsaWtlIHRjbV9sb29wIGNhbiByZWxlYXNlCi0JCQkgKiB0aGVpciBpbnRlcm5hbGx5IGFsbG9jYXRlZCBJL08gcmVmcmVuY2Ugbm93IGFuZAorCQkJICogdGhlaXIgaW50ZXJuYWxseSBhbGxvY2F0ZWQgSS9PIHJlZmVyZW5jZSBub3cgYW5kCiAJCQkgKiBzdHJ1Y3Qgc2VfY21kIG5vdy4KIAkJCSAqLwogCQkJaWYgKENNRF9URk8oY21kKS0+Y2hlY2tfc3RvcF9mcmVlICE9IE5VTEwpIHsKQEAgLTIwMjksNyArMjAyOSw3IEBACiAJICogSWYgdGhlIHJlY2VpdmVkIENEQiBoYXMgYWxlYWR5IGJlZW4gQUJPUlRFRCBieSB0aGUgZ2VuZXJpYwogCSAqIHRhcmdldCBlbmdpbmUsIHdlIG5vdyBjYWxsIHRyYW5zcG9ydF9jaGVja19hYm9ydGVkX3N0YXR1cygpCiAJICogdG8gcXVldWUgYW55IGRlbGF0ZWQgVEFTS19BQk9SVEVEIHN0YXR1cyBmb3IgdGhlIHJlY2VpdmVkIENEQiB0byB0aGUKLQkgKiBmYWJyaWMgbW9kdWxlIGFzIHdlIGFyZSBleHBlY3Rpbmcgbm8gZnV0aGVyIGluY29taW5nIERBVEEgT1VUCisJICogZmFicmljIG1vZHVsZSBhcyB3ZSBhcmUgZXhwZWN0aW5nIG5vIGZ1cnRoZXIgaW5jb21pbmcgREFUQSBPVVQKIAkgKiBzZXF1ZW5jZXMgYXQgdGhpcyBwb2ludC4KIAkgKi8KIAlpZiAodHJhbnNwb3J0X2NoZWNrX2Fib3J0ZWRfc3RhdHVzKGNtZCwgMSkgIT0gMCkKQEAgLTI1MDEsNyArMjUwMSw3IEBACiAJaWYgKFNFX0RFVihjbWQpLT5kZXZfdGFza19hdHRyX3R5cGUgIT0gU0FNX1RBU0tfQVRUUl9FTVVMQVRFRCkKIAkJcmV0dXJuIDE7CiAJLyoKLQkgKiBDaGVjayBmb3IgdGhlIGV4aXN0YW5jZSBvZiBIRUFEX09GX1FVRVVFLCBhbmQgaWYgdHJ1ZSByZXR1cm4gMQorCSAqIENoZWNrIGZvciB0aGUgZXhpc3RlbmNlIG9mIEhFQURfT0ZfUVVFVUUsIGFuZCBpZiB0cnVlIHJldHVybiAxCiAJICogdG8gYWxsb3cgdGhlIHBhc3NlZCBzdHJ1Y3Qgc2VfY21kIGxpc3Qgb2YgdGFza3MgdG8gdGhlIGZyb250IG9mIHRoZSBsaXN0LgogCSAqLwogCSBpZiAoY21kLT5zYW1fdGFza19hdHRyID09IFRBU0tfQVRUUl9IT1EpIHsKQEAgLTI1NDcsNyArMjU0Nyw3IEBACiAJaWYgKGF0b21pY19yZWFkKCZTRV9ERVYoY21kKS0+ZGV2X29yZGVyZWRfc3luYykgIT0gMCkgewogCQkvKgogCQkgKiBPdGhlcndpc2UsIGFkZCBjbWQgdy8gdGFza3MgdG8gZGVsYXllZCBjbWQgcXVldWUgdGhhdAotCQkgKiB3aWxsIGJlIGRyYWluZWQgdXBvbiBjb21wZXRpb24gb2YgSEVBRF9PRl9RVUVVRSB0YXNrLgorCQkgKiB3aWxsIGJlIGRyYWluZWQgdXBvbiBjb21wbGV0aW9uIG9mIEhFQURfT0ZfUVVFVUUgdGFzay4KIAkJICovCiAJCXNwaW5fbG9jaygmU0VfREVWKGNtZCktPmRlbGF5ZWRfY21kX2xvY2spOwogCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfREVMQVlFRF9DTURfRlJPTV9TQU1fQVRUUjsKQEAgLTI1ODksNyArMjU4OSw3IEBACiAJfQogCS8qCiAJICogQ2FsbCB0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3AoKSB0byBzZWUgaWYgYSBmYWJyaWMgZXhjZXB0aW9uCi0JICogaGFzIG9jY3VyZWQgdGhhdCBwcmV2ZW50cyBleGVjdXRpb24uCisJICogaGFzIG9jY3VycmVkIHRoYXQgcHJldmVudHMgZXhlY3V0aW9uLgogCSAqLwogCWlmICghKHRyYW5zcG9ydF9jbWRfY2hlY2tfc3RvcChjbWQsIDAsIFRSQU5TUE9SVF9QUk9DRVNTSU5HKSkpIHsKIAkJLyoKQEAgLTMxMDksNyArMzEwOSw3IEBACiAJaWYgKHJldCAhPSAwKSB7CiAJCWNtZC0+dHJhbnNwb3J0X3dhaXRfZm9yX3Rhc2tzID0gJnRyYW5zcG9ydF9ub3Bfd2FpdF9mb3JfdGFza3M7CiAJCS8qCi0JCSAqIFNldCBTQ1NJIGFkZGl0aW9uYWwgc2Vuc2UgY29kZSAoQVNDKSB0byAnTFVOIE5vdCBBY2Nlc3NhYmxlJzsKKwkJICogU2V0IFNDU0kgYWRkaXRpb25hbCBzZW5zZSBjb2RlIChBU0MpIHRvICdMVU4gTm90IEFjY2Vzc2libGUnOwogCQkgKiBUaGUgQUxVQSBhZGRpdGlvbmFsIHNlbnNlIGNvZGUgcXVhbGlmaWVyIChBU0NRKSBpcyBkZXRlcm1pbmVkCiAJCSAqIGJ5IHRoZSBBTFVBIHByaW1hcnkgb3Igc2Vjb25kYXJ5IGFjY2VzcyBzdGF0ZS4uCiAJCSAqLwpAQCAtMzg2Nyw3ICszODY3LDcgQEAKIAkJfQogCX0KIAkvKgotCSAqIENoZWNrIGZvciBhIGNhbGxiYWNrLCB1c2VkIGJ5IGFtb3VuZ3N0IG90aGVyIHRoaW5ncworCSAqIENoZWNrIGZvciBhIGNhbGxiYWNrLCB1c2VkIGJ5IGFtb25nc3Qgb3RoZXIgdGhpbmdzCiAJICogWERXUklURV9SRUFEXzEwIGVtdWxhdGlvbi4KIAkgKi8KIAlpZiAoY21kLT50cmFuc3BvcnRfY29tcGxldGVfY2FsbGJhY2spCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV91YS5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdWEuYwppbmRleCBhMmVmMzQ2Li5kZjM1NTE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV91YS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3VhLmMKQEAgLTI0Nyw3ICsyNDcsNyBAQAogCQl9CiAJCS8qCiAJCSAqIE90aGVyd2lzZSBmb3IgdGhlIGRlZmF1bHQgMDBiLCByZWxlYXNlIHRoZSBVTklUIEFUVEVOVElPTgotCQkgKiBjb25kaXRpb24uICBSZXR1cm4gdGhlIEFTQy9BU0NRIG9mIHRoZSBoaWdlc3QgcHJpb3JpdHkgVUEKKwkJICogY29uZGl0aW9uLiAgUmV0dXJuIHRoZSBBU0MvQVNDUSBvZiB0aGUgaGlnaGVzdCBwcmlvcml0eSBVQQogCQkgKiAoaGVhZCBvZiB0aGUgbGlzdCkgaW4gdGhlIG91dGdvaW5nIENIRUNLX0NPTkRJVElPTiArIHNlbnNlLgogCQkgKi8KIAkJaWYgKGhlYWQpIHsKQEAgLTMwNCw3ICszMDQsNyBAQAogCSAqIG1hdGNoaW5nIHN0cnVjdCBzZV9sdW4uCiAJICoKIAkgKiBPbmNlIHRoZSByZXR1cm5pbmcgQVNDL0FTQ1EgdmFsdWVzIGFyZSBzZXQsIHdlIGdvIGFoZWFkIGFuZAotCSAqIHJlbGVhc2UgYWxsIG9mIHRoZSBVbml0IEF0dGVudGlvbiBjb25kaXRpb25zIGZvciB0aGUgYXNzb2ljYXRlZAorCSAqIHJlbGVhc2UgYWxsIG9mIHRoZSBVbml0IEF0dGVudGlvbiBjb25kaXRpb25zIGZvciB0aGUgYXNzb2NpYXRlZAogCSAqIHN0cnVjdCBzZV9sdW4uCiAJICovCiAJc3Bpbl9sb2NrKCZkZXZlLT51YV9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGVsZXBob255L2l4ai5jIGIvZHJpdmVycy90ZWxlcGhvbnkvaXhqLmMKaW5kZXggYjAwMTAxOS4uZDVmOTIzYiAxMDA2NDQKLS0tIGEvZHJpdmVycy90ZWxlcGhvbnkvaXhqLmMKKysrIGIvZHJpdmVycy90ZWxlcGhvbnkvaXhqLmMKQEAgLTE2OSw3ICsxNjksNyBAQAogICogQWRkZWQgc3VwcG9ydCBmb3IgTGludXggMi40Lngga2VybmVscy4KICAqCiAgKiBSZXZpc2lvbiAzLjc3ICAyMDAxLzAxLzA5IDA0OjAwOjUyICBlb2tlcnNvbgotICogTGluZXRlc3Qgd2lsbCBub3cgdGVzdCB0aGUgbGluZSwgZXZlbiBpZiBpdCBoYXMgcHJldmlvdXNseSBzdWNjZWRlZC4KKyAqIExpbmV0ZXN0IHdpbGwgbm93IHRlc3QgdGhlIGxpbmUsIGV2ZW4gaWYgaXQgaGFzIHByZXZpb3VzbHkgc3VjY2VlZGVkLgogICoKICAqIFJldmlzaW9uIDMuNzYgIDIwMDEvMDEvMDggMTk6Mjc6MDAgIGVva2Vyc29uCiAgKiBGaXhlZCBwcm9ibGVtIHdpdGggc3RhbmRhcmQgY2FibGUgb24gSW50ZXJuZXQgUGhvbmVDQVJELgpAQCAtMzUyLDcgKzM1Miw3IEBACiAJCX0gZWxzZSB7CiAJCQlqLT5mc2tzaXplID0gODAwMDsKIAkJCWlmKGl4amRlYnVnICYgMHgwMjAwKSB7Ci0JCQkJcHJpbnRrKCJJWEogcGhvbmUlZCAtIGFsbG9jYXRlIHN1Y2NlZGVkXG4iLCBqLT5ib2FyZCk7CisJCQkJcHJpbnRrKCJJWEogcGhvbmUlZCAtIGFsbG9jYXRlIHN1Y2NlZWRlZFxuIiwgai0+Ym9hcmQpOwogCQkJfQogCQl9CiAJfQpAQCAtNDg3LDcgKzQ4Nyw3IEBACiA4LTkJCUhhcmR3YXJlIFN0YXR1cyBSZWdpc3RlcgkJCVJlYWQgT25seQogQS1CCQlIYXJkd2FyZSBDb250cm9sIFJlZ2lzdGVyCQkJUmVhZCBXcml0ZQogQy1EIEhvc3QgVHJhbnNtaXQgKFdyaXRlKSBEYXRhIEJ1ZmZlciBBY2Nlc3MgUG9ydCAoYnVmZmVyIGlucHV0KVdyaXRlIE9ubHkKLUUtRiBIb3N0IFJlY2lldmUgKFJlYWQpIERhdGEgQnVmZmVyIEFjY2VzcyBQb3J0IChidWZmZXIgaW5wdXQpCVJlYWQgT25seQorRS1GIEhvc3QgUmVjZWl2ZSAoUmVhZCkgRGF0YSBCdWZmZXIgQWNjZXNzIFBvcnQgKGJ1ZmZlciBpbnB1dCkJUmVhZCBPbmx5CiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBpeGpfcmVhZF9IU1IoSVhKICpqKQpAQCAtNDE5NSw3ICs0MTk1LDcgQEAKIAkJCWl4al9Xcml0ZURTUENvbW1hbmQoMHhFMzM4LCBqKTsJLyogU2V0IEVjaG8gU3VwcHJlc3NlciBBdHRlbnVhdGlvbiB0byAwZEIgKi8KIAogCQkJLyogTm93IHdlIGNhbiBzZXQgdGhlIEFHQyBpbml0aWFsIHBhcmFtZXRlcnMgYW5kIHR1cm4gaXQgb24gKi8KLQkJCWl4al9Xcml0ZURTUENvbW1hbmQoMHhDRjkwLCBqKTsJLyogU2V0IEFHQyBNaW51bXVtIGdhaW4gKi8KKwkJCWl4al9Xcml0ZURTUENvbW1hbmQoMHhDRjkwLCBqKTsJLyogU2V0IEFHQyBNaW5pbXVtIGdhaW4gKi8KIAkJCWl4al9Xcml0ZURTUENvbW1hbmQoMHgwMDIwLCBqKTsJLyogdG8gMC4xMjUgKC0xOGRCKSAqLwogCQogCQkJaXhqX1dyaXRlRFNQQ29tbWFuZCgweENGOTEsIGopOwkvKiBTZXQgQUdDIE1heGltdW0gZ2FpbiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90ZWxlcGhvbnkvaXhqLmggYi9kcml2ZXJzL3RlbGVwaG9ueS9peGouaAppbmRleCA0YzMyYTQzLi4yYzg0MTEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3RlbGVwaG9ueS9peGouaAorKysgYi9kcml2ZXJzL3RlbGVwaG9ueS9peGouaApAQCAtMTE0OSw3ICsxMTQ5LDcgQEAKIAl1bnNpZ25lZCBpbnQgZmlyc3RyaW5nOjE7IC8qIEZpcnN0IHJpbmcgY2FkZW5jZSBpcyBjb21wbGV0ZSAqLwogCXVuc2lnbmVkIGludCBwc3RuY2hlY2s6MTsJLyogQ3VycmVudGx5IGNoZWNraW5nIHRoZSBQU1ROIExpbmUgKi8KIAl1bnNpZ25lZCBpbnQgcHN0bl9ybXI6MTsKLQl1bnNpZ25lZCBpbnQgeDozOwkvKiB1bnNlZCBiaXRzICovCisJdW5zaWduZWQgaW50IHg6MzsJLyogdW51c2VkIGJpdHMgKi8KIAogfSBJWEpfRkxBR1M7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L2h2Yy9odmNfaXVjdi5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y19pdWN2LmMKaW5kZXggYzM0MjViYi4uYjZmN2Q1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvaHZjL2h2Y19pdWN2LmMKKysrIGIvZHJpdmVycy90dHkvaHZjL2h2Y19pdWN2LmMKQEAgLTI1NSw3ICsyNTUsNyBAQAogCQlkZWZhdWx0OgogCQkJd3JpdHRlbiA9IC1FSU87CiAJCX0KLQkJLyogcmVtb3ZlIGJ1ZmZlciBpZiBhbiBlcnJvciBoYXMgb2NjdXJlZCBvciByZWNlaXZlZCBkYXRhCisJCS8qIHJlbW92ZSBidWZmZXIgaWYgYW4gZXJyb3IgaGFzIG9jY3VycmVkIG9yIHJlY2VpdmVkIGRhdGEKIAkJICogaXMgbm90IGNvcnJlY3QgKi8KIAkJaWYgKHJjIHx8IChyYi0+bWJ1Zi0+dmVyc2lvbiAhPSBNU0dfVkVSU0lPTikgfHwKIAkJCSAgKHJiLT5tc2cubGVuZ3RoICAgICE9IE1TR19TSVpFKHJiLT5tYnVmLT5kYXRhbGVuKSkpCkBAIC02MjAsNyArNjIwLDcgQEAKICAqCQl0aGUgaW5kZXggb2YgYW4gc3RydWN0IGh2Y19pdWN2X3ByaXZhdGUgaW5zdGFuY2UuCiAgKgogICogVGhpcyByb3V0aW5lIG5vdGlmaWVzIHRoZSBIVkMgYmFjay1lbmQgdGhhdCBhIHR0eSBoYW5ndXAgKGNhcnJpZXIgbG9zcywKLSAqIHZpcnR1YWwgb3Igb3RoZXJ3aXNlKSBoYXMgb2NjdXJlZC4KKyAqIHZpcnR1YWwgb3Igb3RoZXJ3aXNlKSBoYXMgb2NjdXJyZWQuCiAgKiBUaGUgei9WTSBJVUNWIEhWQyBkZXZpY2UgZHJpdmVyIGlnbm9yZXMgdmlydHVhbCBoYW5ndXBzICh2aGFuZ3VwKCkpCiAgKiB0byBrZWVwIGFuIGV4aXN0aW5nIElVQ1YgY29tbXVuaWNhdGlvbiBwYXRoIGVzdGFibGlzaGVkLgogICogKEJhY2tncm91bmQ6IHZoYW5ndXAoKSBpcyBjYWxsZWQgZnJvbSB1c2VyIHNwYWNlIChieSBnZXR0eSBvciBsb2dpbikgdG8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L2h2Yy9odmNfdmlvLmMgYi9kcml2ZXJzL3R0eS9odmMvaHZjX3Zpby5jCmluZGV4IDVlMmY1MmIuLmU2ZWVhMTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L2h2Yy9odmNfdmlvLmMKKysrIGIvZHJpdmVycy90dHkvaHZjL2h2Y192aW8uYwpAQCAtMSw3ICsxLDcgQEAKIC8qCiAgKiB2aW8gZHJpdmVyIGludGVyZmFjZSB0byBodmNfY29uc29sZS5jCiAgKgotICogVGhpcyBjb2RlIHdhcyBtb3ZlZCBoZXJlIHRvIGFsbG93IHRoZSByZW1haW5nIGNvZGUgdG8gYmUgcmV1c2VkIGFzIGEKKyAqIFRoaXMgY29kZSB3YXMgbW92ZWQgaGVyZSB0byBhbGxvdyB0aGUgcmVtYWluaW5nIGNvZGUgdG8gYmUgcmV1c2VkIGFzIGEKICAqIGdlbmVyaWMgcG9sbGluZyBtb2RlIHdpdGggc2VtaS1yZWxpYWJsZSB0cmFuc3BvcnQgZHJpdmVyIGNvcmUgdG8gdGhlCiAgKiBjb25zb2xlIGFuZCB0dHkgc3Vic3lzdGVtcy4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9odmMvaHZjcy5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y3MuYwppbmRleCBiZWYyMzhmLi40YzhiNjY1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9odmMvaHZjcy5jCisrKyBiL2RyaXZlcnMvdHR5L2h2Yy9odmNzLmMKQEAgLTExOCw3ICsxMTgsNyBAQAogICogYXJjaC9wb3dlcmVwYy9pbmNsdWRlL2FzbS9odmNzZXJ2ZXIuaAogICoKICAqIDEuMy4yIC0+IDEuMy4zIFJlcGxhY2VkIHlpZWxkKCkgaW4gaHZjc19jbG9zZSgpIHdpdGggdHR5X3dhaXRfdW50aWxfc2VudCgpIHRvCi0gKiBwcmV2ZW50IHBvc3NpYmxlIGxvY2t1cCB3aXRoIHJlYWx0aW1lIHNjaGVkdWxpbmcgYXMgc2ltaWxhcmlseSBwb2ludGVkIG91dCBieQorICogcHJldmVudCBwb3NzaWJsZSBsb2NrdXAgd2l0aCByZWFsdGltZSBzY2hlZHVsaW5nIGFzIHNpbWlsYXJseSBwb2ludGVkIG91dCBieQogICogYWtwbSBpbiBodmNfY29uc29sZS4gIENoYW5nZWQgcmVzdWx0ZWQgaW4gdGhlIHJlbW92YWwgb2YgaHZjc19maW5hbF9jbG9zZSgpCiAgKiB0byByZW9yZGVyIGNsZWFudXAgb3BlcmF0aW9ucyBhbmQgcHJldmVudCBkaXNjYXJkaW5nIG9mIHBlbmRpbmcgZGF0YSBkdXJpbmcKICAqIGFuIGh2Y3NfY2xvc2UoKS4gIFJlbW92ZWQgc3BpbmxvY2sgcHJvdGVjdGlvbiBvZiBodmNzX3N0cnVjdCBkYXRhIG1lbWJlcnMgaW4KQEAgLTU4MSw3ICs1ODEsNyBAQAogCQkJLyoKIAkJCSAqIFdlIGFyZSBzdGlsbCBvYmxpZ2F0ZWQgdG8gZGVsaXZlciB0aGUgZGF0YSB0byB0aGUKIAkJCSAqIGh5cGVydmlzb3IgZXZlbiBpZiB0aGUgdHR5IGhhcyBiZWVuIGNsb3NlZCBiZWNhdXNlCi0JCQkgKiB3ZSBjb21taXRlZCB0byBkZWxpdmVyaW5nIGl0LiAgQnV0IGRvbid0IHRyeSB0byB3YWtlCisJCQkgKiB3ZSBjb21taXR0ZWQgdG8gZGVsaXZlcmluZyBpdC4gIEJ1dCBkb24ndCB0cnkgdG8gd2FrZQogCQkJICogYSBub24tZXhpc3RlbnQgdHR5LgogCQkJICovCiAJCQlpZiAodHR5KSB7CkBAIC0xMzQ5LDcgKzEzNDksNyBAQAogCXNwaW5fbG9ja19pcnFzYXZlKCZodmNzZC0+bG9jaywgZmxhZ3MpOwogCiAJLyoKLQkgKiBTb21laG93IGFuIG9wZW4gc3VjY2VkZGVkIGJ1dCB0aGUgZGV2aWNlIHdhcyByZW1vdmVkIG9yIHRoZQorCSAqIFNvbWVob3cgYW4gb3BlbiBzdWNjZWVkZWQgYnV0IHRoZSBkZXZpY2Ugd2FzIHJlbW92ZWQgb3IgdGhlCiAJICogY29ubmVjdGlvbiB0ZXJtaW5hdGVkIGJldHdlZW4gdGhlIHZ0eS1zZXJ2ZXIgYW5kIHBhcnRuZXIgdnR5IGR1cmluZwogCSAqIHRoZSBtaWRkbGUgb2YgYSB3cml0ZSBvcGVyYXRpb24/ICBUaGlzIGlzIGEgY3J1bW15IHBsYWNlIHRvIGRvIHRoaXMKIAkgKiBidXQgd2Ugd2FudCB0byBrZWVwIGl0IGFsbCBpbiB0aGUgc3BpbmxvY2suCkBAIC0xNDIwLDcgKzE0MjAsNyBAQAogfQogCiAvKgotICogVGhpcyBpcyByZWFsbHkgYXNraW5nIGhvdyBtdWNoIGNhbiB3ZSBndWFyZW50ZWUgdGhhdCB3ZSBjYW4gc2VuZCBvciB0aGF0IHdlCisgKiBUaGlzIGlzIHJlYWxseSBhc2tpbmcgaG93IG11Y2ggY2FuIHdlIGd1YXJhbnRlZSB0aGF0IHdlIGNhbiBzZW5kIG9yIHRoYXQgd2UKICAqIGFic29sdXRlbHkgV0lMTCBCVUZGRVIgaWYgd2UgY2FuJ3Qgc2VuZCBpdC4gIFRoaXMgZHJpdmVyIE1VU1QgaG9ub3IgdGhlCiAgKiByZXR1cm4gdmFsdWUsIGhlbmNlIHRoZSByZWFzb24gZm9yIGh2Y3Nfc3RydWN0IGJ1ZmZlcmluZy4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvbXhzZXIuaCBiL2RyaXZlcnMvdHR5L214c2VyLmgKaW5kZXggNDE4NzhhNi4uMGJmNzk0MyAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvbXhzZXIuaAorKysgYi9kcml2ZXJzL3R0eS9teHNlci5oCkBAIC0xMTMsNyArMTEzLDcgQEAKICNkZWZpbmUgTU9YQV9NVVNUX0lJUl9SVE8JCTB4MEMKICNkZWZpbmUgTU9YQV9NVVNUX0lJUl9MU1IJCTB4MDYKIAotLyogcmVjaWV2ZWQgWG9uL1hvZmYgb3Igc3BlY2ljYWwgaW50ZXJydXB0IHBlbmRpbmcgKi8KKy8qIHJlY2VpdmVkIFhvbi9Yb2ZmIG9yIHNwZWNpY2FsIGludGVycnVwdCBwZW5kaW5nICovCiAjZGVmaW5lIE1PWEFfTVVTVF9JSVJfWFNDCQkweDEwCiAKIC8qIFJUUy9DVFMgY2hhbmdlIHN0YXRlIGludGVycnVwdCBwZW5kaW5nICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9uX2dzbS5jIGIvZHJpdmVycy90dHkvbl9nc20uYwppbmRleCAxNzZmNjMyLi40N2Y4Y2RiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9uX2dzbS5jCisrKyBiL2RyaXZlcnMvdHR5L25fZ3NtLmMKQEAgLTc0LDcgKzc0LDcgQEAKICNlbmRpZgogCiAvKgotICogU2VtaS1hcmJpdGFyeSBidWZmZXIgc2l6ZSBsaW1pdHMuIDA3MTAgaXMgbm9ybWFsbHkgcnVuIHdpdGggMzItNjQgYnl0ZQorICogU2VtaS1hcmJpdHJhcnkgYnVmZmVyIHNpemUgbGltaXRzLiAwNzEwIGlzIG5vcm1hbGx5IHJ1biB3aXRoIDMyLTY0IGJ5dGUKICAqIGxpbWl0cyBzbyB0aGlzIGlzIHBsZW50eQogICovCiAjZGVmaW5lIE1BWF9NUlUgNTEyCkBAIC04Miw3ICs4Miw3IEBACiAKIC8qCiAgKglFYWNoIGJsb2NrIG9mIGRhdGEgd2UgaGF2ZSBxdWV1ZWQgdG8gZ28gb3V0IGlzIGluIHRoZSBmb3JtIG9mCi0gKglhIGdzbV9tc2cgd2hpY2ggaG9sZHMgZXZlcnl0aGluZyB3ZSBuZWVkIGluIGEgbGluayBsYXllciBpbmRlcGVuZGFudAorICoJYSBnc21fbXNnIHdoaWNoIGhvbGRzIGV2ZXJ5dGhpbmcgd2UgbmVlZCBpbiBhIGxpbmsgbGF5ZXIgaW5kZXBlbmRlbnQKICAqCWZvcm1hdAogICovCiAKQEAgLTExOTMsOCArMTE5Myw4IEBACiAJCWJyZWFrOwogCQkvKiBPcHRpb25hbCB1bnN1cHBvcnRlZCBjb21tYW5kcyAqLwogCWNhc2UgQ01EX1BOOgkvKiBQYXJhbWV0ZXIgbmVnb3RpYXRpb24gKi8KLQljYXNlIENNRF9SUE46CS8qIFJlbW90ZSBwb3J0IG5lZ290YXRpb24gKi8KLQljYXNlIENNRF9TTkM6CS8qIFNlcnZpY2UgbmVnb3RhdGlvbiBjb21tYW5kICovCisJY2FzZSBDTURfUlBOOgkvKiBSZW1vdGUgcG9ydCBuZWdvdGlhdGlvbiAqLworCWNhc2UgQ01EX1NOQzoJLyogU2VydmljZSBuZWdvdGlhdGlvbiBjb21tYW5kICovCiAJZGVmYXVsdDoKIAkJLyogUmVwbHkgdG8gYmFkIGNvbW1hbmRzIHdpdGggYW4gTlNDICovCiAJCWJ1ZlswXSA9IGNvbW1hbmQ7CkBAIC0yMDI2LDcgKzIwMjYsNyBAQAogICoJQG11eDogbXV4IHRvIGZyZWUKICAqCiAgKglEaXNwb3NlIG9mIGFsbG9jYXRlZCByZXNvdXJjZXMgZm9yIGEgZGVhZCBtdXguIE5vIHJlZmNvdW50aW5nCi0gKglhdCBwcmVzZW50IHNvIHRoZSBtdXggbXVzdCBiZSB0cnVlbHkgZGVhZC4KKyAqCWF0IHByZXNlbnQgc28gdGhlIG11eCBtdXN0IGJlIHRydWx5IGRlYWQuCiAgKi8KIHZvaWQgZ3NtX2ZyZWVfbXV4KHN0cnVjdCBnc21fbXV4ICpnc20pCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9ub3pvbWkuYyBiL2RyaXZlcnMvdHR5L25vem9taS5jCmluZGV4IGY0ZjExMTYuLmZkMGE5ODUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9ub3pvbWkuYworKysgYi9kcml2ZXJzL3R0eS9ub3pvbWkuYwpAQCAtMTY3Myw3ICsxNjczLDcgQEAKIAogLyoKICAqIGNhbGxlZCB3aGVuIHRoZSB1c2Vyc3BhY2UgcHJvY2VzcyB3cml0ZXMgdG8gdGhlIHR0eSAoL2Rldi9ub3oqKS4KLSAqIERhdGEgaXMgaW5zZXJ0ZWQgaW50byBhIGZpZm8sIHdoaWNoIGlzIHRoZW4gcmVhZCBhbmQgdHJhbnNmZXJlZCB0byB0aGUgbW9kZW0uCisgKiBEYXRhIGlzIGluc2VydGVkIGludG8gYSBmaWZvLCB3aGljaCBpcyB0aGVuIHJlYWQgYW5kIHRyYW5zZmVycmVkIHRvIHRoZSBtb2RlbS4KICAqLwogc3RhdGljIGludCBudHR5X3dyaXRlKHN0cnVjdCB0dHlfc3RydWN0ICp0dHksIGNvbnN0IHVuc2lnbmVkIGNoYXIgKmJ1ZmZlciwKIAkJICAgICAgaW50IGNvdW50KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvcm9ja2V0LmMgYi9kcml2ZXJzL3R0eS9yb2NrZXQuYwppbmRleCAzNzgwZGE4Li4wMzZmZWViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9yb2NrZXQuYworKysgYi9kcml2ZXJzL3R0eS9yb2NrZXQuYwpAQCAtMjA2MCw3ICsyMDYwLDcgQEAKIAkJCXNDbG9ja1ByZXNjYWxlID0gMHgxOTsKIAkJCXJwX2JhdWRfYmFzZVtpXSA9IDIzMDQwMDsKIAkJfSBlbHNlIHsKLQkJCS8qIG1vZCA0IChkZXZpZGUgYnkgNSkgcHJlc2NhbGUgKi8KKwkJCS8qIG1vZCA0IChkaXZpZGUgYnkgNSkgcHJlc2NhbGUgKi8KIAkJCXNDbG9ja1ByZXNjYWxlID0gMHgxNDsKIAkJCXJwX2JhdWRfYmFzZVtpXSA9IDQ2MDgwMDsKIAkJfQpAQCAtMjE4Myw3ICsyMTgzLDcgQEAKIAkJc0Nsb2NrUHJlc2NhbGUgPSAweDE5OwkvKiBtb2QgOSAoZGl2aWRlIGJ5IDEwKSBwcmVzY2FsZSAqLwogCQlycF9iYXVkX2Jhc2VbaV0gPSAyMzA0MDA7CiAJfSBlbHNlIHsKLQkJc0Nsb2NrUHJlc2NhbGUgPSAweDE0OwkvKiBtb2QgNCAoZGV2aWRlIGJ5IDUpIHByZXNjYWxlICovCisJCXNDbG9ja1ByZXNjYWxlID0gMHgxNDsJLyogbW9kIDQgKGRpdmlkZSBieSA1KSBwcmVzY2FsZSAqLwogCQlycF9iYXVkX2Jhc2VbaV0gPSA0NjA4MDA7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvODI1MC5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTAuYwppbmRleCBiM2I4ODFiLi42NjExNTM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvODI1MC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwLmMKQEAgLTE2MjksNyArMTYyOSw3IEBACiAJCQkgICAgdXAtPnBvcnQuaW90eXBlID09IFVQSU9fRFdBUEIzMikgJiYKIAkJCSAgKGlpciAmIFVBUlRfSUlSX0JVU1kpID09IFVBUlRfSUlSX0JVU1kpIHsKIAkJCS8qIFRoZSBEZXNpZ25XYXJlIEFQQiBVQVJUIGhhcyBhbiBCdXN5IERldGVjdCAoMHgwNykKLQkJCSAqIGludGVycnVwdCBtZWFuaW5nIGFuIExDUiB3cml0ZSBhdHRlbXB0IG9jY3VyZWQgd2hpbGUgdGhlCisJCQkgKiBpbnRlcnJ1cHQgbWVhbmluZyBhbiBMQ1Igd3JpdGUgYXR0ZW1wdCBvY2N1cnJlZCB3aGlsZSB0aGUKIAkJCSAqIFVBUlQgd2FzIGJ1c3kuIFRoZSBpbnRlcnJ1cHQgbXVzdCBiZSBjbGVhcmVkIGJ5IHJlYWRpbmcKIAkJCSAqIHRoZSBVQVJUIHN0YXR1cyByZWdpc3RlciAoVVNSKSBhbmQgdGhlIExDUiByZS13cml0dGVuLiAqLwogCQkJdW5zaWduZWQgaW50IHN0YXR1czsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwX3BjaS5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfcGNpLmMKaW5kZXggOGI4OTMwZi4uNzM4Y2VjOSAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfcGNpLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfcGNpLmMKQEAgLTQzMyw3ICs0MzMsNyBAQAogLyoKICAqIFNJSUcgc2VyaWFsIGNhcmRzIGhhdmUgYW4gUENJIGludGVyZmFjZSBjaGlwIHdoaWNoIGFsc28gY29udHJvbHMKICAqIHRoZSBVQVJUIGNsb2NraW5nIGZyZXF1ZW5jeS4gRWFjaCBVQVJUIGNhbiBiZSBjbG9ja2VkIGluZGVwZW5kZW50bHkKLSAqIChleGNlcHQgY2FyZHMgZXF1aXBlZCB3aXRoIDQgVUFSVHMpIGFuZCBpbml0aWFsIGNsb2NraW5nIHNldHRpbmdzCisgKiAoZXhjZXB0IGNhcmRzIGVxdWlwcGVkIHdpdGggNCBVQVJUcykgYW5kIGluaXRpYWwgY2xvY2tpbmcgc2V0dGluZ3MKICAqIGFyZSBzdG9yZWQgaW4gdGhlIEVFUFJPTSBjaGlwLiBJdCBjYW4gY2F1c2UgcHJvYmxlbXMgYmVjYXVzZSB0aGlzCiAgKiB2ZXJzaW9uIG9mIHNlcmlhbCBkcml2ZXIgZG9lc24ndCBzdXBwb3J0IGRpZmZlcmVudGx5IGNsb2NrZWQgVUFSVCdzCiAgKiBvbiBzaW5nbGUgUENJIGNhcmQuIFRvIHByZXZlbnQgdGhpcywgaW5pdGlhbGl6YXRpb24gZnVuY3Rpb25zIHNldApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTEuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hbWJhLXBsMDExLmMKaW5kZXggNTc3MzFlOC4uNmRlZWU0ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTEuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYW1iYS1wbDAxMS5jCkBAIC01MjAsNyArNTIwLDcgQEAKIAogCS8qCiAJICogV2UgZG9uJ3QgaGF2ZSBhIFRYIGJ1ZmZlciBxdWV1ZWQsIHNvIHRyeSB0byBxdWV1ZSBvbmUuCi0JICogSWYgd2Ugc3VjY2VzZnVsbHkgcXVldWVkIGEgYnVmZmVyLCBtYXNrIHRoZSBUWCBJUlEuCisJICogSWYgd2Ugc3VjY2Vzc2Z1bGx5IHF1ZXVlZCBhIGJ1ZmZlciwgbWFzayB0aGUgVFggSVJRLgogCSAqLwogCWlmIChwbDAxMV9kbWFfdHhfcmVmaWxsKHVhcCkgPiAwKSB7CiAJCXVhcC0+aW0gJj0gflVBUlQwMTFfVFhJTTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9pY29tLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvaWNvbS5jCmluZGV4IDUzYTQ2ODIuLjhhODY5ZTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9pY29tLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL2ljb20uYwpAQCAtMTI0OCw3ICsxMjQ4LDcgQEAKIAkJfQogCX0KIAotCS8qIEVuYWJsZSBUcmFuc21pdHRlciBhbmQgUmVjaWV2ZXIgKi8KKwkvKiBFbmFibGUgVHJhbnNtaXR0ZXIgYW5kIFJlY2VpdmVyICovCiAJb2Zmc2V0ID0KIAkgICAgKHVuc2lnbmVkIGxvbmcpICZJQ09NX1BPUlQtPnN0YXRTdGctPnJjdlswXSAtCiAJICAgICh1bnNpZ25lZCBsb25nKSBJQ09NX1BPUlQtPnN0YXRTdGc7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvaW14LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvaW14LmMKaW5kZXggZGZjZjRiMS4uY2IzNmIwZCAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL2lteC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9pbXguYwpAQCAtNzgsNyArNzgsNyBAQAogI2RlZmluZSAgVVJYRF9GUk1FUlIgICAgICgxPDwxMikKICNkZWZpbmUgIFVSWERfQlJLICAgICAgICAoMTw8MTEpCiAjZGVmaW5lICBVUlhEX1BSRVJSICAgICAgKDE8PDEwKQotI2RlZmluZSAgVUNSMV9BREVOICAgICAgICgxPDwxNSkgLyogQXV0byBkZWN0ZWN0IGludGVycnVwdCAqLworI2RlZmluZSAgVUNSMV9BREVOICAgICAgICgxPDwxNSkgLyogQXV0byBkZXRlY3QgaW50ZXJydXB0ICovCiAjZGVmaW5lICBVQ1IxX0FEQlIgICAgICAgKDE8PDE0KSAvKiBBdXRvIGRldGVjdCBiYXVkIHJhdGUgKi8KICNkZWZpbmUgIFVDUjFfVFJEWUVOICAgICAoMTw8MTMpIC8qIFRyYW5zbWl0dGVyIHJlYWR5IGludGVycnVwdCBlbmFibGUgKi8KICNkZWZpbmUgIFVDUjFfSURFTiAgICAgICAoMTw8MTIpIC8qIElkbGUgY29uZGl0aW9uIGludGVycnVwdCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL2lwMjJ6aWxvZy5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2lwMjJ6aWxvZy5jCmluZGV4IGViZmY0YTEuLjdiMWNkYTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9pcDIyemlsb2cuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvaXAyMnppbG9nLmMKQEAgLTM3NSw3ICszNzUsNyBAQAogCQkgKiBiZSBuaWNlIHRvIHRyYW5zbWl0IGNvbnNvbGUgd3JpdGVzIGp1c3QgbGlrZSB3ZSBub3JtYWxseSB3b3VsZCBmb3IKIAkJICogYSBUVFkgbGluZS4gKGllLiBidWZmZXJlZCBhbmQgVFggaW50ZXJydXB0IGRyaXZlbikuICBUaGF0IGlzIG5vdAogCQkgKiBlYXN5IGJlY2F1c2UgY29uc29sZSB3cml0ZXMgY2Fubm90IHNsZWVwLiAgT25lIHNvbHV0aW9uIG1pZ2h0IGJlCi0JCSAqIHRvIHBvbGwgb24gZW5vdWdoIHBvcnQtPnhtaXQgc3BhY2UgYmVjb21taW5nIGZyZWUuICAtRGF2ZU0KKwkJICogdG8gcG9sbCBvbiBlbm91Z2ggcG9ydC0+eG1pdCBzcGFjZSBiZWNvbWluZyBmcmVlLiAgLURhdmVNCiAJCSAqLwogCQlpZiAoIShzdGF0dXMgJiBUeF9CVUZfRU1QKSkKIAkJCXJldHVybjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtLmggYi9kcml2ZXJzL3R0eS9zZXJpYWwvanNtL2pzbS5oCmluZGV4IDM4YTUwOWMuLmI3MDRjOGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtLmgKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL2pzbS9qc20uaApAQCAtMjczLDcgKzI3Myw3IEBACiAJIHU4IGZjdHI7CQkvKiBXUglGQ1RSIC0gRmVhdHVyZSBDb250cm9sIFJlZyAqLwogCSB1OCBlZnI7CQkvKiBXUglFRlIgLSBFbmhhbmNlZCBGdW5jdGlvbiBSZWcgKi8KIAkgdTggdGZpZm87CQkvKiBXUglUWENOVC9UWFRSRyAtIFRyYW5zbWl0IEZJRk8gUmVnICovCi0JIHU4IHJmaWZvOwkJLyogV1IJUlhDTlQvUlhUUkcgLSBSZWNpZXZlIEZJRk8gUmVnICovCisJIHU4IHJmaWZvOwkJLyogV1IJUlhDTlQvUlhUUkcgLSBSZWNlaXZlIEZJRk8gUmVnICovCiAJIHU4IHhvZmZjaGFyMTsJLyogV1IJWE9GRiAxIC0gWE9mZiBDaGFyYWN0ZXIgMSBSZWcgKi8KIAkgdTggeG9mZmNoYXIyOwkvKiBXUglYT0ZGIDIgLSBYT2ZmIENoYXJhY3RlciAyIFJlZyAqLwogCSB1OCB4b25jaGFyMTsJLyogV1IJWE9OIDEgLSBYb24gQ2hhcmFjdGVyIDEgUmVnICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvanNtL2pzbV9uZW8uYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtX25lby5jCmluZGV4IDc5NjBkOTYuLjQ1MzhjM2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtX25lby5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtX25lby5jCkBAIC0zODEsNyArMzgxLDcgQEAKIAkJLyogQ29weSBkYXRhIGZyb20gdWFydCB0byB0aGUgcXVldWUgKi8KIAkJbWVtY3B5X2Zyb21pbyhjaC0+Y2hfcnF1ZXVlICsgaGVhZCwgJmNoLT5jaF9uZW9fdWFydC0+dHhyeGJ1cnN0LCBuKTsKIAkJLyoKLQkJICogU2luY2UgUlhfRklGT19EQVRBX0VSUk9SIHdhcyAwLCB3ZSBhcmUgZ3VhcmVudGVlZAorCQkgKiBTaW5jZSBSWF9GSUZPX0RBVEFfRVJST1Igd2FzIDAsIHdlIGFyZSBndWFyYW50ZWVkCiAJCSAqIHRoYXQgYWxsIHRoZSBkYXRhIGN1cnJlbnRseSBpbiB0aGUgRklGTyBpcyBmcmVlIG9mCiAJCSAqIGJyZWFrcyBhbmQgcGFyaXR5L2ZyYW1lL29ydW4gZXJyb3JzLgogCQkgKi8KQEAgLTEyMTAsNyArMTIxMCw3IEBACiAJCQkgKiBXaHkgd291bGQgSSBjaGVjayBFVkVSWSBwb3NzaWJpbGl0eSBvZiB0eXBlIG9mCiAJCQkgKiBpbnRlcnJ1cHQsIHdoZW4gd2Uga25vdyBpdHMgVFhSRFk/Pz8KIAkJCSAqIEJlY3V6IGZvciBzb21lIHJlYXNvbiwgZXZlbiB0aG8gd2UgZ290IHRyaWdnZXJlZCBmb3IgVFhSRFksCi0JCQkgKiBpdCBzZWVtcyB0byBiZSBvY2Nhc3Npb25hbGx5IHdyb25nLiBJbnN0ZWFkIG9mIFRYLCB3aGljaAorCQkJICogaXQgc2VlbXMgdG8gYmUgb2NjYXNpb25hbGx5IHdyb25nLiBJbnN0ZWFkIG9mIFRYLCB3aGljaAogCQkJICogaXQgc2hvdWxkIGJlLCBJIHdhcyBnZXR0aW5nIHRoaW5ncyBsaWtlIFJYRFkgdG9vLiBXZWlyZC4KIAkJCSAqLwogCQkJbmVvX3BhcnNlX2lzcihicmQsIHBvcnQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL21heDMxMDcuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tYXgzMTA3LmgKaW5kZXggN2FiNjMyMzkuLjg0MTVmYzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9tYXgzMTA3LmgKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL21heDMxMDcuaApAQCAtMzY5LDcgKzM2OSw3IEBACiAJc3RydWN0IHNwaV9kZXZpY2UgKnNwaTsKIAogI2lmIGRlZmluZWQoQ09ORklHX0dQSU9MSUIpCi0JLyogR1BJTyBjaGlwIHN0dWN0dXJlICovCisJLyogR1BJTyBjaGlwIHN0cnVjdHVyZSAqLwogCXN0cnVjdCBncGlvX2NoaXAgY2hpcDsKICNlbmRpZgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvbXJzdF9tYXgzMTEwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbXJzdF9tYXgzMTEwLmMKaW5kZXggMzdlMTNjMy4uMmY1NDhhZiAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL21yc3RfbWF4MzExMC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tcnN0X21heDMxMTAuYwpAQCAtMjMsNyArMjMsNyBAQAogICogICAgMSB3b3JkLiBJZiBTUEkgbWFzdGVyIGNvbnRyb2xsZXIgZG9lc24ndCBzdXBwb3J0IHNjbGsgZnJlcXVlbmN5IGNoYW5nZSwKICAqICAgIHRoZW4gdGhlIGNoYXIgbmVlZCBiZSBzZW50IG91dCBvbmUgYnkgb25lIHdpdGggc29tZSBkZWxheQogICoKLSAqIDIuIEN1cnJlbnRseSBvbmx5IFJYIGF2YWlsYWJlIGludGVycnJ1cHQgaXMgdXNlZCwgbm8gbmVlZCBmb3Igd2FpdGluZyBUWEUKKyAqIDIuIEN1cnJlbnRseSBvbmx5IFJYIGF2YWlsYWJsZSBpbnRlcnJydXB0IGlzIHVzZWQsIG5vIG5lZWQgZm9yIHdhaXRpbmcgVFhFCiAgKiAgICBpbnRlcnJ1cHQgZm9yIGEgbG93IHNwZWVkIFVBUlQgZGV2aWNlCiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL21yc3RfbWF4MzExMC5oIGIvZHJpdmVycy90dHkvc2VyaWFsL21yc3RfbWF4MzExMC5oCmluZGV4IGQxZWY0M2EuLmMzN2VhNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9tcnN0X21heDMxMTAuaAorKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbXJzdF9tYXgzMTEwLmgKQEAgLTIxLDcgKzIxLDcgQEAKIAogI2RlZmluZSBXQ19JUlFfTUFTSwkJKDB4RiA8PCA4KQogI2RlZmluZSBXQ19UWEVfSVJRX0VOQUJMRQkoMSA8PCAxMSkJLyogVFggZW1wdHkgaXJxICovCi0jZGVmaW5lIFdDX1JYQV9JUlFfRU5BQkxFCSgxIDw8IDEwKQkvKiBSWCBhdmFpbGFiZSBpcnEgKi8KKyNkZWZpbmUgV0NfUlhBX0lSUV9FTkFCTEUJKDEgPDwgMTApCS8qIFJYIGF2YWlsYWJsZSBpcnEgKi8KICNkZWZpbmUgV0NfUEFSX0hJR0hfSVJRX0VOQUJMRQkoMSA8PCA5KQogI2RlZmluZSBXQ19SRUNfQUNUX0lSUV9FTkFCTEUJKDEgPDwgOCkKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL21zbV9zZXJpYWxfaHMuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tc21fc2VyaWFsX2hzLmMKaW5kZXggYjkwNmYxMS4uNjI0NzAxZiAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL21zbV9zZXJpYWxfaHMuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbXNtX3NlcmlhbF9ocy5jCkBAIC00OTUsNyArNDk1LDcgQEAKICAqCiAgKiBJbnRlcnJ1cHRzIHNob3VsZCBiZSBkaXNhYmxlZCBiZWZvcmUgd2UgYXJlIGNhbGxlZCwgYXMKICAqIHdlIG1vZGlmeSBTZXQgQmF1ZCByYXRlCi0gKiBTZXQgcmVjZWl2ZSBzdGFsZSBpbnRlcnJ1cHQgbGV2ZWwsIGRlcGVuZGFudCBvbiBCaXQgUmF0ZQorICogU2V0IHJlY2VpdmUgc3RhbGUgaW50ZXJydXB0IGxldmVsLCBkZXBlbmRlbnQgb24gQml0IFJhdGUKICAqIEdvYWwgaXMgdG8gaGF2ZSBhcm91bmQgOCBtcyBiZWZvcmUgaW5kaWNhdGUgc3RhbGUuCiAgKiByb3VuZHVwICgoKEJpdCBSYXRlICogLjAwOCkgLyAxMCkgKyAxCiAgKi8KQEAgLTEzNTAsNyArMTM1MCw3IEBACiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmdXBvcnQtPmxvY2ssIGZsYWdzKTsKIAlpZiAobXNtX3Vwb3J0LT5jbGtfc3RhdGUgPT0gTVNNX0hTX0NMS19PRkYpIHsKLQkJLyogaWdub3JlIHRoZSBmaXJzdCBpcnEgLSBpdCBpcyBhIHBlbmRpbmcgaXJxIHRoYXQgb2NjdXJlZAorCQkvKiBpZ25vcmUgdGhlIGZpcnN0IGlycSAtIGl0IGlzIGEgcGVuZGluZyBpcnEgdGhhdCBvY2N1cnJlZAogCQkgKiBiZWZvcmUgZW5hYmxlX2lycSgpICovCiAJCWlmIChtc21fdXBvcnQtPnJ4X3dha2V1cC5pZ25vcmUpCiAJCQltc21fdXBvcnQtPnJ4X3dha2V1cC5pZ25vcmUgPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwuYwppbmRleCA3NjM1Mzc5Li40N2NhZGY0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwuYwpAQCAtMTMsNyArMTMsNyBAQAogICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAgKgotICogTm90ZTogVGhpcyBkcml2ZXIgaXMgbWFkZSBzZXBlcmF0ZSBmcm9tIDgyNTAgZHJpdmVyIGFzIHdlIGNhbm5vdAorICogTm90ZTogVGhpcyBkcml2ZXIgaXMgbWFkZSBzZXBhcmF0ZSBmcm9tIDgyNTAgZHJpdmVyIGFzIHdlIGNhbm5vdAogICogb3ZlciBsb2FkIDgyNTAgZHJpdmVyIHdpdGggb21hcCBwbGF0Zm9ybSBzcGVjaWZpYyBjb25maWd1cmF0aW9uIGZvcgogICogZmVhdHVyZXMgbGlrZSBETUEsIGl0IG1ha2VzIGVhc2llciB0byBpbXBsZW1lbnQgZmVhdHVyZXMgbGlrZSBETUEgYW5kCiAgKiBoYXJkd2FyZSBmbG93IGNvbnRyb2wgYW5kIHNvZnR3YXJlIGZsb3cgY29udHJvbCBjb25maWd1cmF0aW9uIHdpdGgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9wbWFjX3ppbG9nLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvcG1hY196aWxvZy5jCmluZGV4IDViOWNkZTcuLmUxYzhkNGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9wbWFjX3ppbG9nLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL3BtYWNfemlsb2cuYwpAQCAtMzMwLDcgKzMzMCw3IEBACiAJCSAqIFdoZW4gdGhhdCBoYXBwZW5zLCBJIGRpc2FibGUgdGhlIHJlY2VpdmUgc2lkZSBvZiB0aGUgZHJpdmVyLgogCQkgKiBOb3RlIHRoYXQgd2hhdCBJJ3ZlIGJlZW4gZXhwZXJpZW5jaW5nIGlzIGEgcmVhbCBpcnEgbG9vcCB3aGVyZQogCQkgKiBJJ20gZ2V0dGluZyBmbG9vZGVkIHJlZ2FyZGxlc3Mgb2YgdGhlIGFjdHVhbCBwb3J0IHNwZWVkLgotCQkgKiBTb21ldGhpbmcgc3RhbmdlIGlzIGdvaW5nIG9uIHdpdGggdGhlIEhXCisJCSAqIFNvbWV0aGluZyBzdHJhbmdlIGlzIGdvaW5nIG9uIHdpdGggdGhlIEhXCiAJCSAqLwogCQlpZiAoKCsrbG9vcHMpID4gMTAwMCkKIAkJCWdvdG8gZmxvb2Q7CkBAIC0zOTYsNyArMzk2LDcgQEAKIAkJICogYmUgbmljZSB0byB0cmFuc21pdCBjb25zb2xlIHdyaXRlcyBqdXN0IGxpa2Ugd2Ugbm9ybWFsbHkgd291bGQgZm9yCiAJCSAqIGEgVFRZIGxpbmUuIChpZS4gYnVmZmVyZWQgYW5kIFRYIGludGVycnVwdCBkcml2ZW4pLiAgVGhhdCBpcyBub3QKIAkJICogZWFzeSBiZWNhdXNlIGNvbnNvbGUgd3JpdGVzIGNhbm5vdCBzbGVlcC4gIE9uZSBzb2x1dGlvbiBtaWdodCBiZQotCQkgKiB0byBwb2xsIG9uIGVub3VnaCBwb3J0LT54bWl0IHNwYWNlIGJlY29tbWluZyBmcmVlLiAgLURhdmVNCisJCSAqIHRvIHBvbGwgb24gZW5vdWdoIHBvcnQtPnhtaXQgc3BhY2UgYmVjb21pbmcgZnJlZS4gIC1EYXZlTQogCQkgKi8KIAkJaWYgKCEoc3RhdHVzICYgVHhfQlVGX0VNUCkpCiAJCQlyZXR1cm47CkBAIC04MDksNyArODA5LDcgQEAKICNlbmRpZiAvKiAhQ09ORklHX1BQQ19QTUFDICovCiAKIC8qCi0gKiBGaXhaZXJvQnVnLi4uLldvcmtzIGFyb3VuZCBhIGJ1ZyBpbiB0aGUgU0NDIHJlY2V2aW5nIGNoYW5uZWwuCisgKiBGaXhaZXJvQnVnLi4uLldvcmtzIGFyb3VuZCBhIGJ1ZyBpbiB0aGUgU0NDIHJlY2VpdmluZyBjaGFubmVsLgogICogSW5zcGlyZWQgZnJvbSBEYXJ3aW4gY29kZSwgMTUgU2VwdC4gMjAwMCAgLURhbk0KICAqCiAgKiBUaGUgZm9sbG93aW5nIHNlcXVlbmNlIHByZXZlbnRzIGEgcHJvYmxlbSB0aGF0IGlzIHNlZW4gd2l0aCBPJ0hhcmUgQVNJQ3MKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zYW1zdW5nLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2Ftc3VuZy5jCmluZGV4IDIzMzVlZGEuLjllMmZhOGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zYW1zdW5nLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL3NhbXN1bmcuYwpAQCAtNjQsNyArNjQsNyBAQAogI2RlZmluZSB0eF9lbmFibGVkKHBvcnQpICgocG9ydCktPnVudXNlZFswXSkKICNkZWZpbmUgcnhfZW5hYmxlZChwb3J0KSAoKHBvcnQpLT51bnVzZWRbMV0pCiAKLS8qIGZsYWcgdG8gaWdub3JlIGFsbCBjaGFyYWN0ZXJzIGNvbW1pbmcgaW4gKi8KKy8qIGZsYWcgdG8gaWdub3JlIGFsbCBjaGFyYWN0ZXJzIGNvbWluZyBpbiAqLwogI2RlZmluZSBSWFNUQVRfRFVNTVlfUkVBRCAoMHgxMDAwMDAwMCkKIAogc3RhdGljIGlubGluZSBzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQgKnRvX291cnBvcnQoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKQEAgLTI5MSw3ICsyOTEsNyBAQAogCQlnb3RvIG91dDsKIAl9CiAKLQkvKiBpZiB0aGVyZSBpc250IGFueXRoaW5nIG1vcmUgdG8gdHJhbnNtaXQsIG9yIHRoZSB1YXJ0IGlzIG5vdworCS8qIGlmIHRoZXJlIGlzbid0IGFueXRoaW5nIG1vcmUgdG8gdHJhbnNtaXQsIG9yIHRoZSB1YXJ0IGlzIG5vdwogCSAqIHN0b3BwZWQsIGRpc2FibGUgdGhlIHVhcnQgYW5kIGV4aXQKIAkqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2gtc2NpLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2gtc2NpLmMKaW5kZXggZWI3OTU4Yy4uOTIwYTZmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL3NoLXNjaS5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zaC1zY2kuYwpAQCAtODEyLDcgKzgxMiw3IEBACiB9CiAKIC8qCi0gKiBIZXJlIHdlIGRlZmluZSBhIHRyYW5zaXN0aW9uIG5vdGlmaWVyIHNvIHRoYXQgd2UgY2FuIHVwZGF0ZSBhbGwgb2Ygb3VyCisgKiBIZXJlIHdlIGRlZmluZSBhIHRyYW5zaXRpb24gbm90aWZpZXIgc28gdGhhdCB3ZSBjYW4gdXBkYXRlIGFsbCBvZiBvdXIKICAqIHBvcnRzJyBiYXVkIHJhdGUgd2hlbiB0aGUgcGVyaXBoZXJhbCBjbG9jayBjaGFuZ2VzLgogICovCiBzdGF0aWMgaW50IHNjaV9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnNlbGYsCkBAIC0xODM2LDYgKzE4MzYsMTIgQEAKIAlzY2lfcG9ydCA9ICZzY2lfcG9ydHNbY28tPmluZGV4XTsKIAlwb3J0ID0gJnNjaV9wb3J0LT5wb3J0OwogCisJLyoKKwkgKiBSZWZ1c2UgdG8gaGFuZGxlIHVuaW5pdGlhbGl6ZWQgcG9ydHMuCisJICovCisJaWYgKCFwb3J0LT5vcHMpCisJCXJldHVybiAtRU5PREVWOworCiAJcmV0ID0gc2NpX3JlbWFwX3BvcnQocG9ydCk7CiAJaWYgKHVubGlrZWx5KHJldCAhPSAwKSkKIAkJcmV0dXJuIHJldDsKQEAgLTE4NjYsMTMgKzE4NzIsNiBAQAogCS5kYXRhCQk9ICZzY2lfdWFydF9kcml2ZXIsCiB9OwogCi1zdGF0aWMgaW50IF9faW5pdCBzY2lfY29uc29sZV9pbml0KHZvaWQpCi17Ci0JcmVnaXN0ZXJfY29uc29sZSgmc2VyaWFsX2NvbnNvbGUpOwotCXJldHVybiAwOwotfQotY29uc29sZV9pbml0Y2FsbChzY2lfY29uc29sZV9pbml0KTsKLQogc3RhdGljIHN0cnVjdCBjb25zb2xlIGVhcmx5X3NlcmlhbF9jb25zb2xlID0gewogCS5uYW1lICAgICAgICAgICA9ICJlYXJseV90dHlTQyIsCiAJLndyaXRlICAgICAgICAgID0gc2VyaWFsX2NvbnNvbGVfd3JpdGUsCkBAIC0xOTAxLDE4ICsxOTAwLDE4IEBACiAJcmVnaXN0ZXJfY29uc29sZSgmZWFybHlfc2VyaWFsX2NvbnNvbGUpOwogCXJldHVybiAwOwogfQorCisjZGVmaW5lIFNDSV9DT05TT0xFCSgmc2VyaWFsX2NvbnNvbGUpCisKICNlbHNlCiBzdGF0aWMgaW5saW5lIGludCBfX2RldmluaXQgc2NpX3Byb2JlX2Vhcmx5cHJpbnRrKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CiAJcmV0dXJuIC1FSU5WQUw7CiB9Ci0jZW5kaWYgLyogQ09ORklHX1NFUklBTF9TSF9TQ0lfQ09OU09MRSAqLwogCi0jaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMX1NIX1NDSV9DT05TT0xFKQotI2RlZmluZSBTQ0lfQ09OU09MRQkoJnNlcmlhbF9jb25zb2xlKQotI2Vsc2UKLSNkZWZpbmUgU0NJX0NPTlNPTEUJMAotI2VuZGlmCisjZGVmaW5lIFNDSV9DT05TT0xFCU5VTEwKKworI2VuZGlmIC8qIENPTkZJR19TRVJJQUxfU0hfU0NJX0NPTlNPTEUgKi8KIAogc3RhdGljIGNoYXIgYmFubmVyW10gX19pbml0ZGF0YSA9CiAJS0VSTl9JTkZPICJTdXBlckggU0NJKEYpIGRyaXZlciBpbml0aWFsaXplZFxuIjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zbl9jb25zb2xlLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc25fY29uc29sZS5jCmluZGV4IGNmZjlhMzA2Li4zNzdhZTc0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc25fY29uc29sZS5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zbl9jb25zb2xlLmMKQEAgLTE0Niw3ICsxNDYsNyBAQAogfTsKIAogLyogdGhlIGNvbnNvbGUgZG9lcyBvdXRwdXQgaW4gdHdvIGRpc3RpbmN0bHkgZGlmZmVyZW50IHdheXM6Ci0gKiBzeW5jaHJvbm91cyAocmF3KSBhbmQgYXN5bmNocm9ub3VzIChidWZmZXJlZCkuICBpbml0YWxseSwgZWFybHlfcHJpbnRrCisgKiBzeW5jaHJvbm91cyAocmF3KSBhbmQgYXN5bmNocm9ub3VzIChidWZmZXJlZCkuICBpbml0aWFsbHksIGVhcmx5X3ByaW50awogICogZG9lcyBzeW5jaHJvbm91cyBvdXRwdXQuICBhbnkgZGF0YSB3cml0dGVuIGdvZXMgZGlyZWN0bHkgdG8gdGhlIFNBTAogICogdG8gYmUgb3V0cHV0IChpbmNpZGVudGFsbHksIGl0IGlzIGludGVybmFsbHkgYnVmZmVyZWQgYnkgdGhlIFNBTCkKICAqIGFmdGVyIGludGVycnVwdHMgYW5kIHRpbWVycyBhcmUgaW5pdGlhbGl6ZWQgYW5kIGF2YWlsYWJsZSBmb3IgdXNlLApAQCAtNDgxLDcgKzQ4MSw3IEBACiAJd2hpbGUgKHBvcnQtPnNjX29wcy0+c2FsX2lucHV0X3BlbmRpbmcoKSkgewogCQljaCA9IHBvcnQtPnNjX29wcy0+c2FsX2dldGMoKTsKIAkJaWYgKGNoIDwgMCkgewotCQkJcHJpbnRrKEtFUk5fRVJSICJzbl9jb25zb2xlOiBBbiBlcnJvciBvY2N1cmVkIHdoaWxlICIKKwkJCXByaW50ayhLRVJOX0VSUiAic25fY29uc29sZTogQW4gZXJyb3Igb2NjdXJyZWQgd2hpbGUgIgogCQkJICAgICAgICJvYnRhaW5pbmcgZGF0YSBmcm9tIHRoZSBjb25zb2xlICgweCUweClcbiIsIGNoKTsKIAkJCWJyZWFrOwogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc3Vuemlsb2cuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zdW56aWxvZy5jCmluZGV4IDk5ZmY5YWIuLjhlOTE2ZTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zdW56aWxvZy5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zdW56aWxvZy5jCkBAIC00NzQsNyArNDc0LDcgQEAKIAkJICogYmUgbmljZSB0byB0cmFuc21pdCBjb25zb2xlIHdyaXRlcyBqdXN0IGxpa2Ugd2Ugbm9ybWFsbHkgd291bGQgZm9yCiAJCSAqIGEgVFRZIGxpbmUuIChpZS4gYnVmZmVyZWQgYW5kIFRYIGludGVycnVwdCBkcml2ZW4pLiAgVGhhdCBpcyBub3QKIAkJICogZWFzeSBiZWNhdXNlIGNvbnNvbGUgd3JpdGVzIGNhbm5vdCBzbGVlcC4gIE9uZSBzb2x1dGlvbiBtaWdodCBiZQotCQkgKiB0byBwb2xsIG9uIGVub3VnaCBwb3J0LT54bWl0IHNwYWNlIGJlY29tbWluZyBmcmVlLiAgLURhdmVNCisJCSAqIHRvIHBvbGwgb24gZW5vdWdoIHBvcnQtPnhtaXQgc3BhY2UgYmVjb21pbmcgZnJlZS4gIC1EYXZlTQogCQkgKi8KIAkJaWYgKCEoc3RhdHVzICYgVHhfQlVGX0VNUCkpCiAJCQlyZXR1cm47CmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zeW5jbGluay5jIGIvZHJpdmVycy90dHkvc3luY2xpbmsuYwppbmRleCAxODg4OGQwLi4yN2RhMjNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zeW5jbGluay5jCisrKyBiL2RyaXZlcnMvdHR5L3N5bmNsaW5rLmMKQEAgLTQwNzIsNyArNDA3Miw3IEBACiAJCiAJaWYgKCByZXF1ZXN0X2lycShpbmZvLT5pcnFfbGV2ZWwsbWdzbF9pbnRlcnJ1cHQsaW5mby0+aXJxX2ZsYWdzLAogCQlpbmZvLT5kZXZpY2VfbmFtZSwgaW5mbyApIDwgMCApIHsKLQkJcHJpbnRrKCAiJXMoJWQpOkNhbnQgcmVxdWVzdCBpbnRlcnJ1cHQgb24gZGV2aWNlICVzIElSUT0lZFxuIiwKKwkJcHJpbnRrKCAiJXMoJWQpOkNhbid0IHJlcXVlc3QgaW50ZXJydXB0IG9uIGRldmljZSAlcyBJUlE9JWRcbiIsCiAJCQlfX0ZJTEVfXyxfX0xJTkVfXyxpbmZvLT5kZXZpY2VfbmFtZSwgaW5mby0+aXJxX2xldmVsICk7CiAJCWdvdG8gZXJyb3V0OwogCX0KQEAgLTQwOTUsNyArNDA5NSw3IEBACiAJCWluZm8tPm1lbW9yeV9iYXNlID0gaW9yZW1hcF9ub2NhY2hlKGluZm8tPnBoeXNfbWVtb3J5X2Jhc2UsCiAJCQkJCQkJCTB4NDAwMDApOwogCQlpZiAoIWluZm8tPm1lbW9yeV9iYXNlKSB7Ci0JCQlwcmludGsoICIlcyglZCk6Q2FudCBtYXAgc2hhcmVkIG1lbW9yeSBvbiBkZXZpY2UgJXMgTWVtQWRkcj0lMDhYXG4iLAorCQkJcHJpbnRrKCAiJXMoJWQpOkNhbid0IG1hcCBzaGFyZWQgbWVtb3J5IG9uIGRldmljZSAlcyBNZW1BZGRyPSUwOFhcbiIsCiAJCQkJX19GSUxFX18sX19MSU5FX18saW5mby0+ZGV2aWNlX25hbWUsIGluZm8tPnBoeXNfbWVtb3J5X2Jhc2UgKTsKIAkJCWdvdG8gZXJyb3V0OwogCQl9CkBAIC00MTA5LDcgKzQxMDksNyBAQAogCQlpbmZvLT5sY3JfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShpbmZvLT5waHlzX2xjcl9iYXNlLAogCQkJCQkJCQlQQUdFX1NJWkUpOwogCQlpZiAoIWluZm8tPmxjcl9iYXNlKSB7Ci0JCQlwcmludGsoICIlcyglZCk6Q2FudCBtYXAgTENSIG1lbW9yeSBvbiBkZXZpY2UgJXMgTWVtQWRkcj0lMDhYXG4iLAorCQkJcHJpbnRrKCAiJXMoJWQpOkNhbid0IG1hcCBMQ1IgbWVtb3J5IG9uIGRldmljZSAlcyBNZW1BZGRyPSUwOFhcbiIsCiAJCQkJX19GSUxFX18sX19MSU5FX18saW5mby0+ZGV2aWNlX25hbWUsIGluZm8tPnBoeXNfbGNyX2Jhc2UgKTsKIAkJCWdvdG8gZXJyb3V0OwogCQl9CkBAIC00MTE5LDcgKzQxMTksNyBAQAogCQkvKiBjbGFpbSBETUEgY2hhbm5lbCAqLwogCQkKIAkJaWYgKHJlcXVlc3RfZG1hKGluZm8tPmRtYV9sZXZlbCxpbmZvLT5kZXZpY2VfbmFtZSkgPCAwKXsKLQkJCXByaW50ayggIiVzKCVkKTpDYW50IHJlcXVlc3QgRE1BIGNoYW5uZWwgb24gZGV2aWNlICVzIERNQT0lZFxuIiwKKwkJCXByaW50ayggIiVzKCVkKTpDYW4ndCByZXF1ZXN0IERNQSBjaGFubmVsIG9uIGRldmljZSAlcyBETUE9JWRcbiIsCiAJCQkJX19GSUxFX18sX19MSU5FX18saW5mby0+ZGV2aWNlX25hbWUsIGluZm8tPmRtYV9sZXZlbCApOwogCQkJbWdzbF9yZWxlYXNlX3Jlc291cmNlcyggaW5mbyApOwogCQkJcmV0dXJuIC1FTk9ERVY7CkBAIC00MTMyLDcgKzQxMzIsNyBAQAogCX0KIAkKIAlpZiAoIG1nc2xfYWxsb2NhdGVfZG1hX2J1ZmZlcnMoaW5mbykgPCAwICkgewotCQlwcmludGsoICIlcyglZCk6Q2FudCBhbGxvY2F0ZSBETUEgYnVmZmVycyBvbiBkZXZpY2UgJXMgRE1BPSVkXG4iLAorCQlwcmludGsoICIlcyglZCk6Q2FuJ3QgYWxsb2NhdGUgRE1BIGJ1ZmZlcnMgb24gZGV2aWNlICVzIERNQT0lZFxuIiwKIAkJCV9fRklMRV9fLF9fTElORV9fLGluZm8tPmRldmljZV9uYW1lLCBpbmZvLT5kbWFfbGV2ZWwgKTsKIAkJZ290byBlcnJvdXQ7CiAJfQkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3N5bmNsaW5rX2d0LmMgYi9kcml2ZXJzL3R0eS9zeW5jbGlua19ndC5jCmluZGV4IGEzNWRkNTQuLjE4YjQ4Y2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3N5bmNsaW5rX2d0LmMKKysrIGIvZHJpdmVycy90dHkvc3luY2xpbmtfZ3QuYwpAQCAtMzQ5MSw3ICszNDkxLDcgQEAKIAogCWluZm8tPnJlZ19hZGRyID0gaW9yZW1hcF9ub2NhY2hlKGluZm8tPnBoeXNfcmVnX2FkZHIsIFNMR1RfUkVHX1NJWkUpOwogCWlmICghaW5mby0+cmVnX2FkZHIpIHsKLQkJREJHRVJSKCgiJXMgY2FudCBtYXAgZGV2aWNlIHJlZ2lzdGVycywgYWRkcj0lMDhYXG4iLAorCQlEQkdFUlIoKCIlcyBjYW4ndCBtYXAgZGV2aWNlIHJlZ2lzdGVycywgYWRkcj0lMDhYXG4iLAogCQkJaW5mby0+ZGV2aWNlX25hbWUsIGluZm8tPnBoeXNfcmVnX2FkZHIpKTsKIAkJaW5mby0+aW5pdF9lcnJvciA9IERpYWdTdGF0dXNfQ2FudEFzc2lnblBjaVJlc291cmNlczsKIAkJZ290byBlcnJvdXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zeW5jbGlua21wLmMgYi9kcml2ZXJzL3R0eS9zeW5jbGlua21wLmMKaW5kZXggMzI3MzQzNi4uYzc3ODMxYyAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc3luY2xpbmttcC5jCisrKyBiL2RyaXZlcnMvdHR5L3N5bmNsaW5rbXAuYwpAQCAtMzU5NSw3ICszNTk1LDcgQEAKIAlpbmZvLT5tZW1vcnlfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShpbmZvLT5waHlzX21lbW9yeV9iYXNlLAogCQkJCQkJCQlTQ0FfTUVNX1NJWkUpOwogCWlmICghaW5mby0+bWVtb3J5X2Jhc2UpIHsKLQkJcHJpbnRrKCAiJXMoJWQpOiVzIENhbnQgbWFwIHNoYXJlZCBtZW1vcnksIE1lbUFkZHI9JTA4WFxuIiwKKwkJcHJpbnRrKCAiJXMoJWQpOiVzIENhbid0IG1hcCBzaGFyZWQgbWVtb3J5LCBNZW1BZGRyPSUwOFhcbiIsCiAJCQlfX0ZJTEVfXyxfX0xJTkVfXyxpbmZvLT5kZXZpY2VfbmFtZSwgaW5mby0+cGh5c19tZW1vcnlfYmFzZSApOwogCQlpbmZvLT5pbml0X2Vycm9yID0gRGlhZ1N0YXR1c19DYW50QXNzaWduUGNpUmVzb3VyY2VzOwogCQlnb3RvIGVycm91dDsKQEAgLTM2MDMsNyArMzYwMyw3IEBACiAKIAlpbmZvLT5sY3JfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShpbmZvLT5waHlzX2xjcl9iYXNlLCBQQUdFX1NJWkUpOwogCWlmICghaW5mby0+bGNyX2Jhc2UpIHsKLQkJcHJpbnRrKCAiJXMoJWQpOiVzIENhbnQgbWFwIExDUiBtZW1vcnksIE1lbUFkZHI9JTA4WFxuIiwKKwkJcHJpbnRrKCAiJXMoJWQpOiVzIENhbid0IG1hcCBMQ1IgbWVtb3J5LCBNZW1BZGRyPSUwOFhcbiIsCiAJCQlfX0ZJTEVfXyxfX0xJTkVfXyxpbmZvLT5kZXZpY2VfbmFtZSwgaW5mby0+cGh5c19sY3JfYmFzZSApOwogCQlpbmZvLT5pbml0X2Vycm9yID0gRGlhZ1N0YXR1c19DYW50QXNzaWduUGNpUmVzb3VyY2VzOwogCQlnb3RvIGVycm91dDsKQEAgLTM2MTIsNyArMzYxMiw3IEBACiAKIAlpbmZvLT5zY2FfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShpbmZvLT5waHlzX3NjYV9iYXNlLCBQQUdFX1NJWkUpOwogCWlmICghaW5mby0+c2NhX2Jhc2UpIHsKLQkJcHJpbnRrKCAiJXMoJWQpOiVzIENhbnQgbWFwIFNDQSBtZW1vcnksIE1lbUFkZHI9JTA4WFxuIiwKKwkJcHJpbnRrKCAiJXMoJWQpOiVzIENhbid0IG1hcCBTQ0EgbWVtb3J5LCBNZW1BZGRyPSUwOFhcbiIsCiAJCQlfX0ZJTEVfXyxfX0xJTkVfXyxpbmZvLT5kZXZpY2VfbmFtZSwgaW5mby0+cGh5c19zY2FfYmFzZSApOwogCQlpbmZvLT5pbml0X2Vycm9yID0gRGlhZ1N0YXR1c19DYW50QXNzaWduUGNpUmVzb3VyY2VzOwogCQlnb3RvIGVycm91dDsKQEAgLTM2MjIsNyArMzYyMiw3IEBACiAJaW5mby0+c3RhdGN0cmxfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShpbmZvLT5waHlzX3N0YXRjdHJsX2Jhc2UsCiAJCQkJCQkJCVBBR0VfU0laRSk7CiAJaWYgKCFpbmZvLT5zdGF0Y3RybF9iYXNlKSB7Ci0JCXByaW50ayggIiVzKCVkKTolcyBDYW50IG1hcCBTQ0EgU3RhdHVzL0NvbnRyb2wgbWVtb3J5LCBNZW1BZGRyPSUwOFhcbiIsCisJCXByaW50ayggIiVzKCVkKTolcyBDYW4ndCBtYXAgU0NBIFN0YXR1cy9Db250cm9sIG1lbW9yeSwgTWVtQWRkcj0lMDhYXG4iLAogCQkJX19GSUxFX18sX19MSU5FX18saW5mby0+ZGV2aWNlX25hbWUsIGluZm8tPnBoeXNfc3RhdGN0cmxfYmFzZSApOwogCQlpbmZvLT5pbml0X2Vycm9yID0gRGlhZ1N0YXR1c19DYW50QXNzaWduUGNpUmVzb3VyY2VzOwogCQlnb3RvIGVycm91dDsKQEAgLTM4NjksNyArMzg2OSw3IEBACiAJCQkJCXBvcnRfYXJyYXlbMF0tPmlycV9mbGFncywKIAkJCQkJcG9ydF9hcnJheVswXS0+ZGV2aWNlX25hbWUsCiAJCQkJCXBvcnRfYXJyYXlbMF0pIDwgMCApIHsKLQkJCXByaW50ayggIiVzKCVkKTolcyBDYW50IHJlcXVlc3QgaW50ZXJydXB0LCBJUlE9JWRcbiIsCisJCQlwcmludGsoICIlcyglZCk6JXMgQ2FuJ3QgcmVxdWVzdCBpbnRlcnJ1cHQsIElSUT0lZFxuIiwKIAkJCQlfX0ZJTEVfXyxfX0xJTkVfXywKIAkJCQlwb3J0X2FycmF5WzBdLT5kZXZpY2VfbmFtZSwKIAkJCQlwb3J0X2FycmF5WzBdLT5pcnFfbGV2ZWwgKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3R0eV9pby5jIGIvZHJpdmVycy90dHkvdHR5X2lvLmMKaW5kZXggOTM2YTRlYS4uZDdkNTBiNCAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvdHR5X2lvLmMKKysrIGIvZHJpdmVycy90dHkvdHR5X2lvLmMKQEAgLTIxMzQsNyArMjEzNCw3IEBACiAgKglhY3R1YWxseSBoYXMgZHJpdmVyIGxldmVsIG1lYW5pbmcgYW5kIHRyaWdnZXJzIGEgVkMgcmVzaXplLgogICoKICAqCUxvY2tpbmc6Ci0gKgkJRHJpdmVyIGRlcGVuZGFudC4gVGhlIGRlZmF1bHQgZG9fcmVzaXplIG1ldGhvZCB0YWtlcyB0aGUKKyAqCQlEcml2ZXIgZGVwZW5kZW50LiBUaGUgZGVmYXVsdCBkb19yZXNpemUgbWV0aG9kIHRha2VzIHRoZQogICoJdHR5IHRlcm1pb3MgbXV0ZXggYW5kIGN0cmxfbG9jay4gVGhlIGNvbnNvbGUgdGFrZXMgaXRzIG93biBsb2NrCiAgKgl0aGVuIGNhbGxzIGludG8gdGhlIGRlZmF1bHQgbWV0aG9kLgogICovCkBAIC0yMTU1LDcgKzIxNTUsNyBAQAogICoJdGlvY2NvbnMJLQlhbGxvdyBhZG1pbiB0byBtb3ZlIGxvZ2ljYWwgY29uc29sZQogICoJQGZpbGU6IHRoZSBmaWxlIHRvIGJlY29tZSBjb25zb2xlCiAgKgotICoJQWxsb3cgdGhlIGFkbWluc3RyYXRvciB0byBtb3ZlIHRoZSByZWRpcmVjdGVkIGNvbnNvbGUgZGV2aWNlCisgKglBbGxvdyB0aGUgYWRtaW5pc3RyYXRvciB0byBtb3ZlIHRoZSByZWRpcmVjdGVkIGNvbnNvbGUgZGV2aWNlCiAgKgogICoJTG9ja2luZzogdXNlcyByZWRpcmVjdF9sb2NrIHRvIGd1YXJkIHRoZSByZWRpcmVjdCBpbmZvcm1hdGlvbgogICovCkBAIC0yMjkwLDcgKzIyOTAsNyBAQAogLyoqCiAgKgl0aW9jZ3BncnAJCS0JZ2V0IHByb2Nlc3MgZ3JvdXAKICAqCUB0dHk6IHR0eSBwYXNzZWQgYnkgdXNlcgotICoJQHJlYWxfdHR5OiB0dHkgc2lkZSBvZiB0aGUgdHR5IHBhc2VkIGJ5IHRoZSB1c2VyIGlmIGEgcHR5IGVsc2UgdGhlIHR0eQorICoJQHJlYWxfdHR5OiB0dHkgc2lkZSBvZiB0aGUgdHR5IHBhc3NlZCBieSB0aGUgdXNlciBpZiBhIHB0eSBlbHNlIHRoZSB0dHkKICAqCUBwOiByZXR1cm5lZCBwaWQKICAqCiAgKglPYnRhaW4gdGhlIHByb2Nlc3MgZ3JvdXAgb2YgdGhlIHR0eS4gSWYgdGhlcmUgaXMgbm8gcHJvY2VzcyBncm91cApAQCAtMjM2Nyw3ICsyMzY3LDcgQEAKIC8qKgogICoJdGlvY2dzaWQJCS0JZ2V0IHNlc3Npb24gaWQKICAqCUB0dHk6IHR0eSBwYXNzZWQgYnkgdXNlcgotICoJQHJlYWxfdHR5OiB0dHkgc2lkZSBvZiB0aGUgdHR5IHBhc2VkIGJ5IHRoZSB1c2VyIGlmIGEgcHR5IGVsc2UgdGhlIHR0eQorICoJQHJlYWxfdHR5OiB0dHkgc2lkZSBvZiB0aGUgdHR5IHBhc3NlZCBieSB0aGUgdXNlciBpZiBhIHB0eSBlbHNlIHRoZSB0dHkKICAqCUBwOiBwb2ludGVyIHRvIHJldHVybmVkIHNlc3Npb24gaWQKICAqCiAgKglPYnRhaW4gdGhlIHNlc3Npb24gaWQgb2YgdGhlIHR0eS4gSWYgdGhlcmUgaXMgbm8gc2Vzc2lvbgpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvdHR5X2lvY3RsLmMgYi9kcml2ZXJzL3R0eS90dHlfaW9jdGwuYwppbmRleCAxYTExMzVkLi4yMTU3NGNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS90dHlfaW9jdGwuYworKysgYi9kcml2ZXJzL3R0eS90dHlfaW9jdGwuYwpAQCAtMjQ3LDcgKzI0Nyw3IEBACiAJY2JhdWQgPSB0ZXJtaW9zLT5jX2NmbGFnICYgQ0JBVUQ7CiAKICNpZmRlZiBCT1RIRVIKLQkvKiBNYWdpYyB0b2tlbiBmb3IgYXJiaXRhcnkgc3BlZWQgdmlhIGNfaXNwZWVkL2Nfb3NwZWVkICovCisJLyogTWFnaWMgdG9rZW4gZm9yIGFyYml0cmFyeSBzcGVlZCB2aWEgY19pc3BlZWQvY19vc3BlZWQgKi8KIAlpZiAoY2JhdWQgPT0gQk9USEVSKQogCQlyZXR1cm4gdGVybWlvcy0+Y19vc3BlZWQ7CiAjZW5kaWYKQEAgLTI4Myw3ICsyODMsNyBAQAogCWlmIChjYmF1ZCA9PSBCMCkKIAkJcmV0dXJuIHR0eV90ZXJtaW9zX2JhdWRfcmF0ZSh0ZXJtaW9zKTsKIAotCS8qIE1hZ2ljIHRva2VuIGZvciBhcmJpdGFyeSBzcGVlZCB2aWEgY19pc3BlZWQqLworCS8qIE1hZ2ljIHRva2VuIGZvciBhcmJpdHJhcnkgc3BlZWQgdmlhIGNfaXNwZWVkKi8KIAlpZiAoY2JhdWQgPT0gQk9USEVSKQogCQlyZXR1cm4gdGVybWlvcy0+Y19pc3BlZWQ7CiAKQEAgLTQ0OSw3ICs0NDksNyBAQAogICoJQG5ldzogTmV3IHRlcm1pb3MKICAqCUBvbGQ6IE9sZCB0ZXJtaW9zCiAgKgotICoJUHJvcG9nYXRlIHRoZSBoYXJkd2FyZSBzcGVjaWZpYyB0ZXJtaW5hbCBzZXR0aW5nIGJpdHMgZnJvbQorICoJUHJvcGFnYXRlIHRoZSBoYXJkd2FyZSBzcGVjaWZpYyB0ZXJtaW5hbCBzZXR0aW5nIGJpdHMgZnJvbQogICoJdGhlIG9sZCB0ZXJtaW9zIHN0cnVjdHVyZSB0byB0aGUgbmV3IG9uZS4gVGhpcyBpcyB1c2VkIGluIGNhc2VzCiAgKgl3aGVyZSB0aGUgaGFyZHdhcmUgZG9lcyBub3Qgc3VwcG9ydCByZWNvbmZpZ3VyYXRpb24gb3IgYXMgYSBoZWxwZXIKICAqCWluIHNvbWUgY2FzZXMgd2hlcmUgb25seSBtaW5pbWFsIHJlY29uZmlndXJhdGlvbiBpcyBzdXBwb3J0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3Z0L3Z0LmMgYi9kcml2ZXJzL3R0eS92dC92dC5jCmluZGV4IGM4M2NkZmIuLjRiZWExZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3Z0L3Z0LmMKKysrIGIvZHJpdmVycy90dHkvdnQvdnQuYwpAQCAtMzk2Myw3ICszOTYzLDcgQEAKICAqICBvZiAzMiBwaXhlbHMuIFVzZXJzcGFjZSBmb250ZGF0YSBpcyBzdG9yZWQgd2l0aCAzMiBieXRlcyAoc2hvcnRzL2ludHMsIAogICogIGRlcGVuZGluZyBvbiB3aWR0aCkgcmVzZXJ2ZWQgZm9yIGVhY2ggY2hhcmFjdGVyIHdoaWNoIGlzIGtpbmRhIHdhc3R5LCBidXQgCiAgKiAgdGhpcyBpcyBkb25lIGluIG9yZGVyIHRvIG1haW50YWluIGNvbXBhdGliaWxpdHkgd2l0aCB0aGUgRUdBL1ZHQSBmb250cy4gSXQgCi0gKiAgaXMgdXB0byB0aGUgYWN0dWFsIGxvdy1sZXZlbCBjb25zb2xlLWRyaXZlciBjb252ZXJ0IGRhdGEgaW50byBpdHMgZmF2b3JpdGUKKyAqICBpcyB1cCB0byB0aGUgYWN0dWFsIGxvdy1sZXZlbCBjb25zb2xlLWRyaXZlciBjb252ZXJ0IGRhdGEgaW50byBpdHMgZmF2b3JpdGUKICAqICBmb3JtYXQgKG1heWJlIHdlIHNob3VsZCBhZGQgYSBgZm9udG9mZnNldCcgZmllbGQgdG8gdGhlIGBkaXNwbGF5JwogICogIHN0cnVjdHVyZSBzbyB3ZSB3b24ndCBoYXZlIHRvIGNvbnZlcnQgdGhlIGZvbnRkYXRhIGFsbCB0aGUgdGltZS4KICAqICAvSmVzCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Vpby91aW9fcHJ1c3MuYyBiL2RyaXZlcnMvdWlvL3Vpb19wcnVzcy5jCmluZGV4IGRhZjZlNzcuLmU2N2I1NjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdWlvL3Vpb19wcnVzcy5jCisrKyBiL2RyaXZlcnMvdWlvL3Vpb19wcnVzcy5jCkBAIC0zOSw3ICszOSw3IEBACiBNT0RVTEVfUEFSTV9ERVNDKGV4dHJhbV9wb29sX3N6LCAiZXh0ZXJuYWwgcmFtIHBvb2wgc2l6ZSB0byBhbGxvY2F0ZSIpOwogCiAvKgotICogSG9zdCBldmVudCBJUlEgbnVtYmVycyBmcm9tIFBSVVNTIC0gUFJVU1MgY2FuIGdlbmVyYXRlIHVwdG8gOCBpbnRlcnJ1cHQKKyAqIEhvc3QgZXZlbnQgSVJRIG51bWJlcnMgZnJvbSBQUlVTUyAtIFBSVVNTIGNhbiBnZW5lcmF0ZSB1cCB0byA4IGludGVycnVwdAogICogZXZlbnRzIHRvIEFJTlRDIG9mIEFSTSBob3N0IHByb2Nlc3NvciAtIHdoaWNoIGNhbiBiZSB1c2VkIGZvciBJUEMgYi93IFBSVVNTCiAgKiBmaXJtd2FyZSBhbmQgdXNlciBzcGFjZSBhcHBsaWNhdGlvbiwgYXN5bmMgbm90aWZpY2F0aW9uIGZyb20gUFJVIGZpcm13YXJlCiAgKiB0byB1c2VyIHNwYWNlIGFwcGxpY2F0aW9uCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9hdG0vdWVhZ2xlLWF0bS5jIGIvZHJpdmVycy91c2IvYXRtL3VlYWdsZS1hdG0uYwppbmRleCBiMjY4ZTlmLi5lNzE1MjFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9hdG0vdWVhZ2xlLWF0bS5jCisrKyBiL2RyaXZlcnMvdXNiL2F0bS91ZWFnbGUtYXRtLmMKQEAgLTEyODMsNyArMTI4Myw3IEBACiAKIAkvKiBpbiBidWxrIG1vZGUgdGhlIG1vZGVtIGhhdmUgcHJvYmxlbSB3aXRoIGhpZ2ggcmF0ZQogCSAqIGNoYW5naW5nIGludGVybmFsIHRpbWluZyBjb3VsZCBpbXByb3ZlIHRoaW5ncywgYnV0IHRoZQotCSAqIHZhbHVlIGlzIG1pc3RlcmlvdXMuCisJICogdmFsdWUgaXMgbXlzdGVyaW91cy4KIAkgKiBBREk5MzAgZG9uJ3Qgc3VwcG9ydCBpdCAoLUVQSVBFIGVycm9yKS4KIAkgKi8KIApAQCAtMTc0Myw3ICsxNzQzLDcgQEAKIAkJCQlnb3RvIG91dDsKIAkJfQogCX0gZWxzZSB7Ci0JCS8qIFRoaXMgcmVhbHkgc2hvdWxkIG5vdCBoYXBwZW4gKi8KKwkJLyogVGhpcyByZWFsbHkgc2hvdWxkIG5vdCBoYXBwZW4gKi8KIAkJdWVhX2VycihJTlNfVE9fVVNCREVWKHNjKSwgImJhZCBjbXZzIHZlcnNpb24gJWRcbiIsIHZlcik7CiAJCWdvdG8gb3V0OwogCX0KQEAgLTE3OTgsNyArMTc5OCw3IEBACiAJCQkJZ290byBvdXQ7CiAJCX0KIAl9IGVsc2UgewotCQkvKiBUaGlzIHJlYWx5IHNob3VsZCBub3QgaGFwcGVuICovCisJCS8qIFRoaXMgcmVhbGx5IHNob3VsZCBub3QgaGFwcGVuICovCiAJCXVlYV9lcnIoSU5TX1RPX1VTQkRFVihzYyksICJiYWQgY212cyB2ZXJzaW9uICVkXG4iLCB2ZXIpOwogCQlnb3RvIG91dDsKIAl9CkBAIC0xODI5LDcgKzE4MjksNyBAQAogCiAJLyogbWFzayBpbnRlcnJ1cHQgKi8KIAlzYy0+Ym9vdGluZyA9IDE7Ci0JLyogV2UgbmVlZCB0byBzZXQgdGhpcyBoZXJlIGJlY2F1c2UsIGEgYWNrIHRpbWVvdXQgY291bGQgaGF2ZSBvY2N1cmVkLAorCS8qIFdlIG5lZWQgdG8gc2V0IHRoaXMgaGVyZSBiZWNhdXNlLCBhIGFjayB0aW1lb3V0IGNvdWxkIGhhdmUgb2NjdXJyZWQsCiAJICogYnV0IGJlZm9yZSB3ZSBzdGFydCB0aGUgcmVib290LCB0aGUgYWNrIG9jY3VycyBhbmQgc2V0IHRoaXMgdG8gMS4KIAkgKiBTbyB3ZSB3aWxsIGZhaWxlZCB0byB3YWl0IFJlYWR5IENNVi4KIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2M2N3gwMC9jNjd4MDAtZHJ2LmMgYi9kcml2ZXJzL3VzYi9jNjd4MDAvYzY3eDAwLWRydi5jCmluZGV4IGI2ZDQ5MjMuLjYyMDUwZjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2M2N3gwMC9jNjd4MDAtZHJ2LmMKKysrIGIvZHJpdmVycy91c2IvYzY3eDAwL2M2N3gwMC1kcnYuYwpAQCAtMjcsNyArMjcsNyBAQAogICogdGhlIGxpbmsgYmV0d2VlbiB0aGUgY29tbW9uIGhhcmR3YXJlIHBhcnRzIGFuZCB0aGUgc3ViZHJpdmVycyAoZS5nLgogICogaW50ZXJydXB0IGhhbmRsaW5nKS4KICAqCi0gKiBUaGUgYzY3eDAwIGhhcyAyIFNJRSdzIChzZXJpYWwgaW50ZXJmYWNlIGVuZ2luZSkgd2ljaCBjYW4gYmUgY29uZmlndXJlZAorICogVGhlIGM2N3gwMCBoYXMgMiBTSUUncyAoc2VyaWFsIGludGVyZmFjZSBlbmdpbmUpIHdoaWNoIGNhbiBiZSBjb25maWd1cmVkCiAgKiB0byBiZSBob3N0LCBkZXZpY2Ugb3IgT1RHICh3aXRoIHNvbWUgbGltaXRhdGlvbnMsIEUuRy4gb25seSBTSUUxIGNhbiBiZSBPVEcpLgogICoKICAqIERlcGVuZGluZyBvbiB0aGUgcGxhdGZvcm0gY29uZmlndXJhdGlvbiwgdGhlIFNJRSdzIGFyZSBjcmVhdGVkIGFuZApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvYzY3eDAwL2M2N3gwMC1oY2QuaCBiL2RyaXZlcnMvdXNiL2M2N3gwMC9jNjd4MDAtaGNkLmgKaW5kZXggNzRlNDQ2Mi4uZTNkNDkzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvYzY3eDAwL2M2N3gwMC1oY2QuaAorKysgYi9kcml2ZXJzL3VzYi9jNjd4MDAvYzY3eDAwLWhjZC5oCkBAIC0zNCw3ICszNCw3IEBACiAvKgogICogVGhlIGZvbGxvd2luZyBwYXJhbWV0ZXJzIGRlcGVuZCBvbiB0aGUgQ1BVIHNwZWVkLCBidXMgc3BlZWQsIC4uLgogICogVGhlc2UgY2FuIGJlIHR1bmVkIGZvciBzcGVjaWZpYyB1c2UgY2FzZXMsIGUuZy4gaWYgaXNvY2hyb25vdXMgdHJhbnNmZXJzCi0gKiBhcmUgdmVyeSBpbXBvcnRhbnQsIGJhbmR3aXRoIGNhbiBiZSBzYWNyaWZpY2VkIHRvIGd1YXJhbnRlZSB0aGF0IHRoZQorICogYXJlIHZlcnkgaW1wb3J0YW50LCBiYW5kd2lkdGggY2FuIGJlIHNhY3JpZmljZWQgdG8gZ3VhcmFudGVlIHRoYXQgdGhlCiAgKiAxbXMgZGVhZGxpbmUgd2lsbCBiZSBtZXQuCiAgKiBJZiBidWxrIHRyYW5zZmVycyBhcmUgaW1wb3J0YW50LCB0aGUgTUFYX0ZSQU1FX0JXIGNhbiBiZSBpbmNyZWFzZWQsCiAgKiBidXQgc29tZSAob3IgbWFueSkgaXNvY2hyb25vdXMgZGVhZGxpbmVzIG1pZ2h0IG5vdCBiZSBtZXQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jNjd4MDAvYzY3eDAwLXNjaGVkLmMgYi9kcml2ZXJzL3VzYi9jNjd4MDAvYzY3eDAwLXNjaGVkLmMKaW5kZXggZjZiM2MyNS4uYTAzZmJjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvYzY3eDAwL2M2N3gwMC1zY2hlZC5jCisrKyBiL2RyaXZlcnMvdXNiL2M2N3gwMC9jNjd4MDAtc2NoZWQuYwpAQCAtOTA3LDcgKzkwNyw3IEBACiAKIC8qIFJlbW92ZSBhbGwgdGQncyBmcm9tIHRoZSBsaXN0IHdoaWNoIGNvbWUKICAqIGFmdGVyIGxhc3RfdGQgYW5kIGFyZSBtZWFudCBmb3IgdGhlIHNhbWUgcGlwZS4KLSAqIFRoaXMgaXMgdXNlZCB3aGVuIGEgc2hvcnQgcGFja2V0IGhhcyBvY2N1cmVkICovCisgKiBUaGlzIGlzIHVzZWQgd2hlbiBhIHNob3J0IHBhY2tldCBoYXMgb2NjdXJyZWQgKi8KIHN0YXRpYyBpbmxpbmUgdm9pZCBjNjd4MDBfY2xlYXJfcGlwZShzdHJ1Y3QgYzY3eDAwX2hjZCAqYzY3eDAwLAogCQkJCSAgICAgc3RydWN0IGM2N3gwMF90ZCAqbGFzdF90ZCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NsYXNzL2NkYy1hY20uaCBiL2RyaXZlcnMvdXNiL2NsYXNzL2NkYy1hY20uaAppbmRleCA1ZWViNTcwLi5iNGVhNTRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jbGFzcy9jZGMtYWNtLmgKKysrIGIvZHJpdmVycy91c2IvY2xhc3MvY2RjLWFjbS5oCkBAIC01Miw3ICs1Miw3IEBACiAgKi8KIAogLyoKLSAqIFRoZSBvbmx5IHJlYXNvbiB0byBoYXZlIHNldmVyYWwgYnVmZmVycyBpcyB0byBhY2NvbW9kYXRlIGFzc3VtcHRpb25zCisgKiBUaGUgb25seSByZWFzb24gdG8gaGF2ZSBzZXZlcmFsIGJ1ZmZlcnMgaXMgdG8gYWNjb21tb2RhdGUgYXNzdW1wdGlvbnMKICAqIGluIGxpbmUgZGlzY2lwbGluZXMuIFRoZXkgYXNrIGZvciBlbXB0eSBzcGFjZSBhbW91bnQsIHJlY2VpdmUgb3VyIFVSQiBzaXplLAogICogYW5kIHByb2NlZWQgdG8gaXNzdWUgc2V2ZXJhbCAxLWNoYXJhY3RlciB3cml0ZXMsIGFzc3VtaW5nIHRoZXkgd2lsbCBmaXQuCiAgKiBUaGUgdmVyeSBmaXJzdCB3cml0ZSB0YWtlcyBhIGNvbXBsZXRlIFVSQi4gRm9ydHVuYXRlbHksIHRoaXMgb25seSBoYXBwZW5zCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jbGFzcy91c2J0bWMuYyBiL2RyaXZlcnMvdXNiL2NsYXNzL3VzYnRtYy5jCmluZGV4IDZhNTQ2MzQuLjM4NWFjYjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NsYXNzL3VzYnRtYy5jCisrKyBiL2RyaXZlcnMvdXNiL2NsYXNzL3VzYnRtYy5jCkBAIC00ODMsNyArNDgzLDcgQEAKIAkJfQogCiAJCWRvbmUgKz0gbl9jaGFyYWN0ZXJzOwotCQkvKiBUZXJtaW5hdGUgaWYgZW5kLW9mLW1lc3NhZ2UgYml0IHJlY2lldmVkIGZyb20gZGV2aWNlICovCisJCS8qIFRlcm1pbmF0ZSBpZiBlbmQtb2YtbWVzc2FnZSBiaXQgcmVjZWl2ZWQgZnJvbSBkZXZpY2UgKi8KIAkJaWYgKChidWZmZXJbOF0gJiAgMHgwMSkgJiYgKGFjdHVhbCA+PSBuX2NoYXJhY3RlcnMgKyAxMikpCiAJCQlyZW1haW5pbmcgPSAwOwogCQllbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jb3JlL2hjZC5jIGIvZHJpdmVycy91c2IvY29yZS9oY2QuYwppbmRleCAwMmI0ZGJmLi44ZWVkMDVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jb3JlL2hjZC5jCisrKyBiL2RyaXZlcnMvdXNiL2NvcmUvaGNkLmMKQEAgLTcwMCw3ICs3MDAsNyBAQAogCS8qIFRoZSBVU0IgMi4wIHNwZWMgc2F5cyAyNTYgbXMuICBUaGlzIGlzIGNsb3NlIGVub3VnaCBhbmQgd29uJ3QKIAkgKiBleGNlZWQgdGhhdCBsaW1pdCBpZiBIWiBpcyAxMDAuIFRoZSBtYXRoIGlzIG1vcmUgY2x1bmt5IHRoYW4KIAkgKiBtYXliZSBleHBlY3RlZCwgdGhpcyBpcyB0byBtYWtlIHN1cmUgdGhhdCBhbGwgdGltZXJzIGZvciBVU0IgZGV2aWNlcwotCSAqIGZpcmUgYXQgdGhlIHNhbWUgdGltZSB0byBnaXZlIHRoZSBDUFUgYSBicmVhayBpbmJldHdlZW4gKi8KKwkgKiBmaXJlIGF0IHRoZSBzYW1lIHRpbWUgdG8gZ2l2ZSB0aGUgQ1BVIGEgYnJlYWsgaW4gYmV0d2VlbiAqLwogCWlmIChoY2QtPnVzZXNfbmV3X3BvbGxpbmcgPyBIQ0RfUE9MTF9SSChoY2QpIDoKIAkJCShsZW5ndGggPT0gMCAmJiBoY2QtPnN0YXR1c191cmIgIT0gTlVMTCkpCiAJCW1vZF90aW1lciAoJmhjZC0+cmhfdGltZXIsIChqaWZmaWVzLyhIWi80KSArIDEpICogKEhaLzQpKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvaHViLmMgYi9kcml2ZXJzL3VzYi9jb3JlL2h1Yi5jCmluZGV4IDU2NGVhYTUuLjhmYjc1NDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvaHViLmMKKysrIGIvZHJpdmVycy91c2IvY29yZS9odWIuYwpAQCAtMTY0OSw3ICsxNjQ5LDcgQEAKIAogCS8qIG1hcmsgdGhlIGRldmljZSBhcyBpbmFjdGl2ZSwgc28gYW55IGZ1cnRoZXIgdXJiIHN1Ym1pc3Npb25zIGZvcgogCSAqIHRoaXMgZGV2aWNlIChhbmQgYW55IG9mIGl0cyBjaGlsZHJlbikgd2lsbCBmYWlsIGltbWVkaWF0ZWx5LgotCSAqIHRoaXMgcXVpZXNjZXMgZXZlcnl0aW5nIGV4Y2VwdCBwZW5kaW5nIHVyYnMuCisJICogdGhpcyBxdWllc2NlcyBldmVyeXRoaW5nIGV4Y2VwdCBwZW5kaW5nIHVyYnMuCiAJICovCiAJdXNiX3NldF9kZXZpY2Vfc3RhdGUodWRldiwgVVNCX1NUQVRFX05PVEFUVEFDSEVEKTsKIAlkZXZfaW5mbygmdWRldi0+ZGV2LCAiVVNCIGRpc2Nvbm5lY3QsIGRldmljZSBudW1iZXIgJWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9lYXJseS9laGNpLWRiZ3AuYyBiL2RyaXZlcnMvdXNiL2Vhcmx5L2VoY2ktZGJncC5jCmluZGV4IDBiYzA2ZTIuLmE2YTM1MGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2Vhcmx5L2VoY2ktZGJncC5jCisrKyBiL2RyaXZlcnMvdXNiL2Vhcmx5L2VoY2ktZGJncC5jCkBAIC02NDgsNyArNjQ4LDcgQEAKIAkJaWYgKCEocG9ydHNjICYgUE9SVF9DT05ORUNUKSkKIAkJCXJldHVybiAtRU5PVENPTk47CiAKLQkJLyogYm9tYiBvdXQgY29tcGxldGVseSBpZiBzb21ldGhpbmcgd2VpcmQgaGFwcGVuZCAqLworCQkvKiBib21iIG91dCBjb21wbGV0ZWx5IGlmIHNvbWV0aGluZyB3ZWlyZCBoYXBwZW5lZCAqLwogCQlpZiAoKHBvcnRzYyAmIFBPUlRfQ1NDKSkKIAkJCXJldHVybiAtRUlOVkFMOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvYW1kNTUzNnVkYy5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2FtZDU1MzZ1ZGMuYwppbmRleCBmOGRkNzI2Li42ZTQyYWFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvYW1kNTUzNnVkYy5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9hbWQ1NTM2dWRjLmMKQEAgLTI3OCw3ICsyNzgsNyBAQAogCXJldHVybiAwOwogfQogCi0vKiBDYWxjdWxhdGVzIGZpZm8gc3RhcnQgb2YgZW5kcG9pbnQgYmFzZWQgb24gcHJlY2VlZGluZyBlbmRwb2ludHMgKi8KKy8qIENhbGN1bGF0ZXMgZmlmbyBzdGFydCBvZiBlbmRwb2ludCBiYXNlZCBvbiBwcmVjZWRpbmcgZW5kcG9pbnRzICovCiBzdGF0aWMgaW50IHVkY19zZXRfdHhmaWZvX2FkZHIoc3RydWN0IHVkY19lcCAqZXApCiB7CiAJc3RydWN0IHVkYwkqZGV2OwpAQCAtMjEzNyw3ICsyMTM3LDcgQEAKIAlpZiAodXNlX2RtYSkgewogCQkvKiBCTkEgZXZlbnQgPyAqLwogCQlpZiAodG1wICYgQU1EX0JJVChVRENfRVBTVFNfQk5BKSkgewotCQkJREJHKGRldiwgIkJOQSBlcCVkb3V0IG9jY3VyZWQgLSBERVNQVFIgPSAleCBcbiIsCisJCQlEQkcoZGV2LCAiQk5BIGVwJWRvdXQgb2NjdXJyZWQgLSBERVNQVFIgPSAleCBcbiIsCiAJCQkJCWVwLT5udW0sIHJlYWRsKCZlcC0+cmVncy0+ZGVzcHRyKSk7CiAJCQkvKiBjbGVhciBCTkEgKi8KIAkJCXdyaXRlbCh0bXAgfCBBTURfQklUKFVEQ19FUFNUU19CTkEpLCAmZXAtPnJlZ3MtPnN0cyk7CkBAIC0yMTUxLDcgKzIxNTEsNyBAQAogCX0KIAkvKiBIRSBldmVudCA/ICovCiAJaWYgKHRtcCAmIEFNRF9CSVQoVURDX0VQU1RTX0hFKSkgewotCQlkZXZfZXJyKCZkZXYtPnBkZXYtPmRldiwgIkhFIGVwJWRvdXQgb2NjdXJlZFxuIiwgZXAtPm51bSk7CisJCWRldl9lcnIoJmRldi0+cGRldi0+ZGV2LCAiSEUgZXAlZG91dCBvY2N1cnJlZFxuIiwgZXAtPm51bSk7CiAKIAkJLyogY2xlYXIgSEUgKi8KIAkJd3JpdGVsKHRtcCB8IEFNRF9CSVQoVURDX0VQU1RTX0hFKSwgJmVwLT5yZWdzLT5zdHMpOwpAQCAtMjM1NCw3ICsyMzU0LDcgQEAKIAkJLyogQk5BID8gKi8KIAkJaWYgKGVwc3RzICYgQU1EX0JJVChVRENfRVBTVFNfQk5BKSkgewogCQkJZGV2X2VycigmZGV2LT5wZGV2LT5kZXYsCi0JCQkJIkJOQSBlcCVkaW4gb2NjdXJlZCAtIERFU1BUUiA9ICUwOGx4IFxuIiwKKwkJCQkiQk5BIGVwJWRpbiBvY2N1cnJlZCAtIERFU1BUUiA9ICUwOGx4IFxuIiwKIAkJCQllcC0+bnVtLAogCQkJCSh1bnNpZ25lZCBsb25nKSByZWFkbCgmZXAtPnJlZ3MtPmRlc3B0cikpOwogCkBAIC0yMzY3LDcgKzIzNjcsNyBAQAogCS8qIEhFIGV2ZW50ID8gKi8KIAlpZiAoZXBzdHMgJiBBTURfQklUKFVEQ19FUFNUU19IRSkpIHsKIAkJZGV2X2VycigmZGV2LT5wZGV2LT5kZXYsCi0JCQkiSEUgZXAlZG4gb2NjdXJlZCAtIERFU1BUUiA9ICUwOGx4IFxuIiwKKwkJCSJIRSBlcCVkbiBvY2N1cnJlZCAtIERFU1BUUiA9ICUwOGx4IFxuIiwKIAkJCWVwLT5udW0sICh1bnNpZ25lZCBsb25nKSByZWFkbCgmZXAtPnJlZ3MtPmRlc3B0cikpOwogCiAJCS8qIGNsZWFyIEhFICovCkBAIC0yMzg0LDcgKzIzODQsNyBAQAogCQkJcmVxID0gbGlzdF9lbnRyeShlcC0+cXVldWUubmV4dCwKIAkJCQkJc3RydWN0IHVkY19yZXF1ZXN0LCBxdWV1ZSk7CiAJCQkvKgotCQkJICogbGVuZ3RoIGJ5dGVzIHRyYW5zZmVyZWQKKwkJCSAqIGxlbmd0aCBieXRlcyB0cmFuc2ZlcnJlZAogCQkJICogY2hlY2sgZG1hIGRvbmUgb2YgbGFzdCBkZXNjLiBpbiBQUEJEVSBtb2RlCiAJCQkgKi8KIAkJCWlmICh1c2VfZG1hX3BwYl9kdSkgewpAQCAtMjc4NCw3ICsyNzg0LDcgQEAKIAkJCQkJLyogd3JpdGUgZmlmbyAqLwogCQkJCQl1ZGNfdHhmaWZvX3dyaXRlKGVwLCAmcmVxLT5yZXEpOwogCi0JCQkJCS8qIGxlbmdoIGJ5dGVzIHRyYW5zZmVyZWQgKi8KKwkJCQkJLyogbGVuZ2ggYnl0ZXMgdHJhbnNmZXJyZWQgKi8KIAkJCQkJbGVuID0gcmVxLT5yZXEubGVuZ3RoIC0gcmVxLT5yZXEuYWN0dWFsOwogCQkJCQlpZiAobGVuID4gZXAtPmVwLm1heHBhY2tldCkKIAkJCQkJCWxlbiA9IGVwLT5lcC5tYXhwYWNrZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvYW1kNTUzNnVkYy5oIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2FtZDU1MzZ1ZGMuaAppbmRleCA0YmJhYmJiLi4xZDFjNzU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvYW1kNTUzNnVkYy5oCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9hbWQ1NTM2dWRjLmgKQEAgLTU4NCw3ICs1ODQsNyBAQAogICogU0VUIGFuZCBHRVQgYml0ZmllbGRzIGluIHUzMiB2YWx1ZXMKICAqIHZpYSBjb25zdGFudHMgZm9yIG1hc2svb2Zmc2V0OgogICogPGJpdF9maWVsZF9zdHViX25hbWU+IGlzIHRoZSB0ZXh0IGJldHdlZW4KLSAqIFVEQ18gYW5kIF9NQVNLfF9PRlMgb2YgYXBwcm9waWF0ZQorICogVURDXyBhbmQgX01BU0t8X09GUyBvZiBhcHByb3ByaWF0ZQogICogY29uc3RhbnQKICAqCiAgKiBzZXQgYml0ZmllbGQgdmFsdWUgaW4gdTMyIHUzMlZhbApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L2F0OTFfdWRjLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvYXQ5MV91ZGMuYwppbmRleCBiYjhkZGYwLi45YjdjZGIxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvYXQ5MV91ZGMuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvYXQ5MV91ZGMuYwpAQCAtODI2LDcgKzgyNiw3IEBACiAJcmV0dXJuIHN0YXR1czsKIH0KIAotLyogcmVpbml0ID09IHJlc3RvcmUgaW5pdGFsIHNvZnR3YXJlIHN0YXRlICovCisvKiByZWluaXQgPT0gcmVzdG9yZSBpbml0aWFsIHNvZnR3YXJlIHN0YXRlICovCiBzdGF0aWMgdm9pZCB1ZGNfcmVpbml0KHN0cnVjdCBhdDkxX3VkYyAqdWRjKQogewogCXUzMiBpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L2NvbXBvc2l0ZS5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2NvbXBvc2l0ZS5jCmluZGV4IGMyMjUxYzQuLjgyMzE0ZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2dhZGdldC9jb21wb3NpdGUuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvY29tcG9zaXRlLmMKQEAgLTQyLDcgKzQyLDcgQEAKIHN0YXRpYyBzdHJ1Y3QgdXNiX2NvbXBvc2l0ZV9kcml2ZXIgKmNvbXBvc2l0ZTsKIHN0YXRpYyBpbnQgKCpjb21wb3NpdGVfZ2FkZ2V0X2JpbmQpKHN0cnVjdCB1c2JfY29tcG9zaXRlX2RldiAqY2Rldik7CiAKLS8qIFNvbWUgc3lzdGVtcyB3aWxsIG5lZWQgcnVudGltZSBvdmVycmlkZXMgZm9yIHRoZSAgcHJvZHVjdCBpZGVudGlmZXJzCisvKiBTb21lIHN5c3RlbXMgd2lsbCBuZWVkIHJ1bnRpbWUgb3ZlcnJpZGVzIGZvciB0aGUgIHByb2R1Y3QgaWRlbnRpZmllcnMKICAqIHB1Ymxpc2hlZCBpbiB0aGUgZGV2aWNlIGRlc2NyaXB0b3IsIGVpdGhlciBudW1iZXJzIG9yIHN0cmluZ3Mgb3IgYm90aC4KICAqIFN0cmluZyBwYXJhbWV0ZXJzIGFyZSBpbiBVVEYtOCAoc3VwZXJzZXQgb2YgQVNDSUkncyA3IGJpdCBjaGFyYWN0ZXJzKS4KICAqLwpAQCAtMjA1LDE0ICsyMDUsMTQgQEAKICAqIHVzYl9pbnRlcmZhY2VfaWQoKSBpcyBjYWxsZWQgZnJvbSB1c2JfZnVuY3Rpb24uYmluZCgpIGNhbGxiYWNrcyB0bwogICogYWxsb2NhdGUgbmV3IGludGVyZmFjZSBJRHMuICBUaGUgZnVuY3Rpb24gZHJpdmVyIHdpbGwgdGhlbiBzdG9yZSB0aGF0CiAgKiBJRCBpbiBpbnRlcmZhY2UsIGFzc29jaWF0aW9uLCBDREMgdW5pb24sIGFuZCBvdGhlciBkZXNjcmlwdG9ycy4gIEl0Ci0gKiB3aWxsIGFsc28gaGFuZGxlIGFueSBjb250cm9sIHJlcXVlc3RzIHRhcmdldHRlZCBhdCB0aGF0IGludGVyZmFjZSwKKyAqIHdpbGwgYWxzbyBoYW5kbGUgYW55IGNvbnRyb2wgcmVxdWVzdHMgdGFyZ2V0ZWQgYXQgdGhhdCBpbnRlcmZhY2UsCiAgKiBwYXJ0aWN1bGFybHkgY2hhbmdpbmcgaXRzIGFsdHNldHRpbmcgdmlhIHNldF9hbHQoKS4gIFRoZXJlIG1heQogICogYWxzbyBiZSBjbGFzcy1zcGVjaWZpYyBvciB2ZW5kb3Itc3BlY2lmaWMgcmVxdWVzdHMgdG8gaGFuZGxlLgogICoKICAqIEFsbCBpbnRlcmZhY2UgaWRlbnRpZmllciBzaG91bGQgYmUgYWxsb2NhdGVkIHVzaW5nIHRoaXMgcm91dGluZSwgdG8KICAqIGVuc3VyZSB0aGF0IGZvciBleGFtcGxlIGRpZmZlcmVudCBmdW5jdGlvbnMgZG9uJ3Qgd3JvbmdseSBhc3NpZ24KICAqIGRpZmZlcmVudCBtZWFuaW5ncyB0byB0aGUgc2FtZSBpZGVudGlmaWVyLiAgTm90ZSB0aGF0IHNpbmNlIGludGVyZmFjZQotICogaWRlbnRpZmVycyBhcmUgY29uZmlndXJhdGlvbi1zcGVjaWZpYywgZnVuY3Rpb25zIHVzZWQgaW4gbW9yZSB0aGFuCisgKiBpZGVudGlmaWVycyBhcmUgY29uZmlndXJhdGlvbi1zcGVjaWZpYywgZnVuY3Rpb25zIHVzZWQgaW4gbW9yZSB0aGFuCiAgKiBvbmUgY29uZmlndXJhdGlvbiAob3IgbW9yZSB0aGFuIG9uY2UgaW4gYSBnaXZlbiBjb25maWd1cmF0aW9uKSBuZWVkCiAgKiBtdWx0aXBsZSB2ZXJzaW9ucyBvZiB0aGUgcmVsZXZhbnQgZGVzY3JpcHRvcnMuCiAgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfYXVkaW8uYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9mX2F1ZGlvLmMKaW5kZXggMDA5NzVlZC4uOWFiZWNmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfYXVkaW8uYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvZl9hdWRpby5jCkBAIC03NDIsNyArNzQyLDcgQEAKIH0KIAogLyoqCi0gKiBhdWRpb19iaW5kX2NvbmZpZyAtIGFkZCBVU0IgYXVkaW8gZnVjbnRpb24gdG8gYSBjb25maWd1cmF0aW9uCisgKiBhdWRpb19iaW5kX2NvbmZpZyAtIGFkZCBVU0IgYXVkaW8gZnVuY3Rpb24gdG8gYSBjb25maWd1cmF0aW9uCiAgKiBAYzogdGhlIGNvbmZpZ3VyYXRpb24gdG8gc3VwY2FyZCB0aGUgVVNCIGF1ZGlvIGZ1bmN0aW9uCiAgKiBDb250ZXh0OiBzaW5nbGUgdGhyZWFkZWQgZHVyaW5nIGdhZGdldCBzZXR1cAogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9mX25jbS5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfbmNtLmMKaW5kZXggMTMwZWVlNi4uODY5MDJhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfbmNtLmMKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfbmNtLmMKQEAgLTExMSw3ICsxMTEsNyBAQAogI2RlZmluZSBOVEJfT1VUX1NJWkUJCTE2Mzg0CiAKIC8qCi0gKiBza2JzIG9mIHNpemUgbGVzcyB0aGFuIHRoYXQgd2lsbCBub3QgYmUgYWxsaWduZWQKKyAqIHNrYnMgb2Ygc2l6ZSBsZXNzIHRoYW4gdGhhdCB3aWxsIG5vdCBiZSBhbGlnbmVkCiAgKiB0byBOQ00ncyBkd050YkluTWF4U2l6ZSB0byBzYXZlIGJ1cyBiYW5kd2lkdGgKICAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvZnNsX3FlX3VkYy5oIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2ZzbF9xZV91ZGMuaAppbmRleCBiZWE1YjgyLi5lMzVlMjRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvZnNsX3FlX3VkYy5oCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9mc2xfcWVfdWRjLmgKQEAgLTIwOCwxNCArMjA4LDE0IEBACiAvKiBGcmFtZSBzdGF0dXMgZmllbGQgKi8KIC8qIFJlY2VpdmUgc2lkZSAqLwogI2RlZmluZSBGUkFNRV9PSyAgICAgICAgICAgICAgIDB4MDAwMDAwMDAgLyogRnJhbWUgdHJhbm1pdHRlZCBvciByZWNlaXZlZCBPSyAqLwotI2RlZmluZSBGUkFNRV9FUlJPUiAgICAgICAgICAgIDB4ODAwMDAwMDAgLyogRXJyb3Igb2NjdXJlZCBvbiBmcmFtZSAqLworI2RlZmluZSBGUkFNRV9FUlJPUiAgICAgICAgICAgIDB4ODAwMDAwMDAgLyogRXJyb3Igb2NjdXJyZWQgb24gZnJhbWUgKi8KICNkZWZpbmUgU1RBUlRfRlJBTUVfTE9TVCAgICAgICAweDQwMDAwMDAwIC8qIFNUQVJUX0ZSQU1FX0xPU1QgKi8KICNkZWZpbmUgRU5EX0ZSQU1FX0xPU1QgICAgICAgICAweDIwMDAwMDAwIC8qIEVORF9GUkFNRV9MT1NUICovCiAjZGVmaW5lIFJYX0VSX05PTk9DVCAgICAgICAgICAgMHgxMDAwMDAwMCAvKiBSeCBOb24gT2N0ZXQgQWxpZ25lZCBQYWNrZXQgKi8KICNkZWZpbmUgUlhfRVJfQklUU1RVRkYgICAgICAgICAweDA4MDAwMDAwIC8qIEZyYW1lIEFib3J0ZWQgLS1SZWNlaXZlZCBwYWNrZXQKIAkJCQkJICAgICB3aXRoIGJpdCBzdHVmZiBlcnJvciAqLwogI2RlZmluZSBSWF9FUl9DUkMgICAgICAgICAgICAgIDB4MDQwMDAwMDAgLyogUmVjZWl2ZWQgcGFja2V0IHdpdGggQ1JDIGVycm9yICovCi0jZGVmaW5lIFJYX0VSX09WRVJVTiAgICAgICAgICAgMHgwMjAwMDAwMCAvKiBPdmVyLXJ1biBvY2N1cmVkIG9uIHJlY2VwdGlvbiAqLworI2RlZmluZSBSWF9FUl9PVkVSVU4gICAgICAgICAgIDB4MDIwMDAwMDAgLyogT3Zlci1ydW4gb2NjdXJyZWQgb24gcmVjZXB0aW9uICovCiAjZGVmaW5lIFJYX0VSX1BJRCAgICAgICAgICAgICAgMHgwMTAwMDAwMCAvKiBXcm9uZyBQSUQgcmVjZWl2ZWQgKi8KIC8qIFRyYW5taXQgc2lkZSAqLwogI2RlZmluZSBUWF9FUl9OQUsgICAgICAgICAgICAgIDB4MDA4MDAwMDAgLyogUmVjZWl2ZWQgTkFLIGhhbmRzaGFrZSAqLwpAQCAtMzc5LDcgKzM3OSw3IEBACiAjZGVmaW5lIFRfTFNQICAgICAgICAgMHgwMTAwMDAwMCAgICAgICAgIC8qIExvdy1zcGVlZCB0cmFuc2FjdGlvbiAqLwogI2RlZmluZSBUX1BJRCAgICAgICAgIDB4MDBjMDAwMDAgICAgICAgICAvKiBwYWNrZXQgaWQgKi8KICNkZWZpbmUgVF9OQUsgICAgICAgICAweDAwMTAwMDAwICAgICAgICAgLyogTm8gYWNrLiAqLwotI2RlZmluZSBUX1NUQUwgICAgICAgIDB4MDAwODAwMDAgICAgICAgICAvKiBTdGFsbCByZWNpZXZlZCAqLworI2RlZmluZSBUX1NUQUwgICAgICAgIDB4MDAwODAwMDAgICAgICAgICAvKiBTdGFsbCByZWNlaXZlZCAqLwogI2RlZmluZSBUX1RPICAgICAgICAgIDB4MDAwNDAwMDAgICAgICAgICAvKiB0aW1lIG91dCAqLwogI2RlZmluZSBUX1VOICAgICAgICAgIDB4MDAwMjAwMDAgICAgICAgICAvKiB1bmRlcnJ1biAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvZnNsX3VkY19jb3JlLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvZnNsX3VkY19jb3JlLmMKaW5kZXggOTEyY2I4ZS4uMDc0OTljMSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L2ZzbF91ZGNfY29yZS5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9mc2xfdWRjX2NvcmUuYwpAQCAtNDY0LDcgKzQ2NCw3IEBACiAKIAltYXggPSBsZTE2X3RvX2NwdShkZXNjLT53TWF4UGFja2V0U2l6ZSk7CiAKLQkvKiBEaXNhYmxlIGF1dG9tYXRpYyB6bHAgZ2VuZXJhdGlvbi4gIERyaXZlciBpcyByZXBvbnNpYmxlIHRvIGluZGljYXRlCisJLyogRGlzYWJsZSBhdXRvbWF0aWMgemxwIGdlbmVyYXRpb24uICBEcml2ZXIgaXMgcmVzcG9uc2libGUgdG8gaW5kaWNhdGUKIAkgKiBleHBsaWNpdGx5IHRocm91Z2ggcmVxLT5yZXEuemVyby4gIFRoaXMgaXMgbmVlZGVkIHRvIGVuYWJsZSBtdWx0aS10ZAogCSAqIHJlcXVlc3QuICovCiAJemx0ID0gMTsKQEAgLTY0OCw3ICs2NDgsNyBAQAogCQkJfCBFUF9RVUVVRV9IRUFEX1NUQVRVU19IQUxUKSk7CiAJZFFILT5zaXplX2lvY19pbnRfc3RzICY9IHRlbXA7CiAKLQkvKiBFbnN1cmUgdGhhdCB1cGRhdGVzIHRvIHRoZSBRSCB3aWxsIG9jY3VyZSBiZWZvcmUgcHJpbWluZy4gKi8KKwkvKiBFbnN1cmUgdGhhdCB1cGRhdGVzIHRvIHRoZSBRSCB3aWxsIG9jY3VyIGJlZm9yZSBwcmltaW5nLiAqLwogCXdtYigpOwogCiAJLyogUHJpbWUgZW5kcG9pbnQgYnkgd3JpdGluZyAxIHRvIEVORFBUUFJJTUUgKi8KQEAgLTE0NTksNyArMTQ1OSw3IEBACiAJCQkJc3RhdHVzID0gLUVJTFNFUTsKIAkJCQlicmVhazsKIAkJCX0gZWxzZQotCQkJCUVSUigiVW5rbm93biBlcnJvciBoYXMgb2NjdXJlZCAoMHgleCkhXG4iLAorCQkJCUVSUigiVW5rbm93biBlcnJvciBoYXMgb2NjdXJyZWQgKDB4JXgpIVxuIiwKIAkJCQkJZXJyb3JzKTsKIAogCQl9IGVsc2UgaWYgKGxlMzJfdG9fY3B1KGN1cnJfdGQtPnNpemVfaW9jX3N0cykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9mc2xfdXNiMl91ZGMuaCBiL2RyaXZlcnMvdXNiL2dhZGdldC9mc2xfdXNiMl91ZGMuaAppbmRleCAyMGFlY2VlLi5lODhjY2U1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvZnNsX3VzYjJfdWRjLmgKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2ZzbF91c2IyX3VkYy5oCkBAIC0xNSw3ICsxNSw3IEBACiAJdTggcmVzMVsyNTZdOwogCXUxNiBjYXBsZW5ndGg7CQkvKiBDYXBhYmlsaXR5IFJlZ2lzdGVyIExlbmd0aCAqLwogCXUxNiBoY2l2ZXJzaW9uOwkJLyogSG9zdCBDb250cm9sbGVyIEludGVyZmFjZSBWZXJzaW9uICovCi0JdTMyIGhjc3BhcmFtczsJCS8qIEhvc3QgQ29udHJvbGxlciBTdHJ1Y3R1YWwgUGFyYW1ldGVycyAqLworCXUzMiBoY3NwYXJhbXM7CQkvKiBIb3N0IENvbnRyb2xsZXIgU3RydWN0dXJhbCBQYXJhbWV0ZXJzICovCiAJdTMyIGhjY3BhcmFtczsJCS8qIEhvc3QgQ29udHJvbGxlciBDYXBhYmlsaXR5IFBhcmFtZXRlcnMgKi8KIAl1OCByZXMyWzIwXTsKIAl1MzIgZGNpdmVyc2lvbjsJCS8qIERldmljZSBDb250cm9sbGVyIEludGVyZmFjZSBWZXJzaW9uICovCkBAIC01Miw3ICs1Miw3IEBACiAJdTggcmVzMVsyNTZdOwogCXUxNiBjYXBsZW5ndGg7CQkvKiBDYXBhYmlsaXR5IFJlZ2lzdGVyIExlbmd0aCAqLwogCXUxNiBoY2l2ZXJzaW9uOwkJLyogSG9zdCBDb250cm9sbGVyIEludGVyZmFjZSBWZXJzaW9uICovCi0JdTMyIGhjc3BhcmFtczsJCS8qIEhvc3QgQ29udHJvbGxlciBTdHJ1Y3R1YWwgUGFyYW1ldGVycyAqLworCXUzMiBoY3NwYXJhbXM7CQkvKiBIb3N0IENvbnRyb2xsZXIgU3RydWN0dXJhbCBQYXJhbWV0ZXJzICovCiAJdTMyIGhjY3BhcmFtczsJCS8qIEhvc3QgQ29udHJvbGxlciBDYXBhYmlsaXR5IFBhcmFtZXRlcnMgKi8KIAl1OCByZXMyWzIwXTsKIAl1MzIgZGNpdmVyc2lvbjsJCS8qIERldmljZSBDb250cm9sbGVyIEludGVyZmFjZSBWZXJzaW9uICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvZ21pZGkuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9nbWlkaS5jCmluZGV4IDBhYjdlMTQuLjQ3Yjg2YjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2dhZGdldC9nbWlkaS5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9nbWlkaS5jCkBAIC02Nyw3ICs2Nyw3IEBACiBtb2R1bGVfcGFyYW0oaWQsIGNoYXJwLCAwNDQ0KTsKIE1PRFVMRV9QQVJNX0RFU0MoaWQsICJJRCBzdHJpbmcgZm9yIHRoZSBVU0IgTUlESSBHYWRnZXQgYWRhcHRlci4iKTsKIAotLyogU29tZSBzeXN0ZW1zIHdpbGwgd2FudCBkaWZmZXJlbnQgcHJvZHVjdCBpZGVudGlmZXJzIHB1Ymxpc2hlZCBpbiB0aGUKKy8qIFNvbWUgc3lzdGVtcyB3aWxsIHdhbnQgZGlmZmVyZW50IHByb2R1Y3QgaWRlbnRpZmllcnMgcHVibGlzaGVkIGluIHRoZQogICogZGV2aWNlIGRlc2NyaXB0b3IsIGVpdGhlciBudW1iZXJzIG9yIHN0cmluZ3Mgb3IgYm90aC4gIFRoZXNlIHN0cmluZwogICogcGFyYW1ldGVycyBhcmUgaW4gVVRGLTggKHN1cGVyc2V0IG9mIEFTQ0lJJ3MgNyBiaXQgY2hhcmFjdGVycykuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9sYW5nd2VsbF91ZGMuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9sYW5nd2VsbF91ZGMuYwppbmRleCAxZWNhOGI0Li45Y2VlODhhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvbGFuZ3dlbGxfdWRjLmMKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2xhbmd3ZWxsX3VkYy5jCkBAIC02NDIsNyArNjQyLDcgQEAKIAlkcWgtPmR0ZF9zdGF0dXMgJj0gZHRkX3N0YXR1czsKIAlkZXZfdmRiZygmZGV2LT5wZGV2LT5kZXYsICJkcWgtPmR0ZF9zdGF0dXMgPSAweCV4XG4iLCBkcWgtPmR0ZF9zdGF0dXMpOwogCi0JLyogZW5zdXJlIHRoYXQgdXBkYXRlcyB0byB0aGUgZFFIIHdpbGwgb2NjdXJlIGJlZm9yZSBwcmltaW5nICovCisJLyogZW5zdXJlIHRoYXQgdXBkYXRlcyB0byB0aGUgZFFIIHdpbGwgb2NjdXIgYmVmb3JlIHByaW1pbmcgKi8KIAl3bWIoKTsKIAogCS8qIHdyaXRlIDEgdG8gZW5kcHRwcmltZSByZWdpc3RlciB0byBQUklNRSBlbmRwb2ludCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L212X3VkY19jb3JlLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvbXZfdWRjX2NvcmUuYwppbmRleCBkNTQ2OGE3Li5iNjJiMjY0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvbXZfdWRjX2NvcmUuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvbXZfdWRjX2NvcmUuYwpAQCAtMzI1LDcgKzMyNSw3IEBACiAKIAkJCS8qCiAJCQkgKiBFbnN1cmUgdGhhdCB1cGRhdGVzIHRvIHRoZSBRSCB3aWxsCi0JCQkgKiBvY2N1cmUgYmVmb3JlIHByaW1pbmcuCisJCQkgKiBvY2N1ciBiZWZvcmUgcHJpbWluZy4KIAkJCSAqLwogCQkJd21iKCk7CiAKQEAgLTMzOCw3ICszMzgsNyBAQAogCQkJJiBFUF9RVUVVRV9IRUFEX05FWFRfUE9JTlRFUl9NQVNLOzsKIAkJZHFoLT5zaXplX2lvY19pbnRfc3RzID0gMDsKIAotCQkvKiBFbnN1cmUgdGhhdCB1cGRhdGVzIHRvIHRoZSBRSCB3aWxsIG9jY3VyZSBiZWZvcmUgcHJpbWluZy4gKi8KKwkJLyogRW5zdXJlIHRoYXQgdXBkYXRlcyB0byB0aGUgUUggd2lsbCBvY2N1ciBiZWZvcmUgcHJpbWluZy4gKi8KIAkJd21iKCk7CiAKIAkJLyogUHJpbWUgdGhlIEVuZHBvaW50ICovCkBAIC0xODQ1LDcgKzE4NDUsNyBAQAogCQlyZXR1cm4gSVJRX05PTkU7CiAJfQogCi0JLyogQ2xlYXIgYWxsIHRoZSBpbnRlcnJ1cHRzIG9jY3VyZWQgKi8KKwkvKiBDbGVhciBhbGwgdGhlIGludGVycnVwdHMgb2NjdXJyZWQgKi8KIAl3cml0ZWwoc3RhdHVzLCAmdWRjLT5vcF9yZWdzLT51c2JzdHMpOwogCiAJaWYgKHN0YXR1cyAmIFVTQlNUU19FUlIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvbmV0MjI4MC5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L25ldDIyODAuYwppbmRleCBkMDkxNTViLi4yNDY5NmY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvbmV0MjI4MC5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9uZXQyMjgwLmMKQEAgLTExNyw3ICsxMTcsNyBAQAogCiAvKiBlbmFibGVfc3VzcGVuZCAtLSBXaGVuIGVuYWJsZWQsIHRoZSBkcml2ZXIgd2lsbCByZXNwb25kIHRvCiAgKiBVU0Igc3VzcGVuZCByZXF1ZXN0cyBieSBwb3dlcmluZyBkb3duIHRoZSBORVQyMjgwLiAgT3RoZXJ3aXNlLAotICogVVNCIHN1c3BlbmQgcmVxdWVzdHMgd2lsbCBiZSBpZ25vcmVkLiAgVGhpcyBpcyBhY2NlcHRpYmxlIGZvcgorICogVVNCIHN1c3BlbmQgcmVxdWVzdHMgd2lsbCBiZSBpZ25vcmVkLiAgVGhpcyBpcyBhY2NlcHRhYmxlIGZvcgogICogc2VsZi1wb3dlcmVkIGRldmljZXMKICAqLwogc3RhdGljIGludCBlbmFibGVfc3VzcGVuZCA9IDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvbm9raWEuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9ub2tpYS5jCmluZGV4IGI1MzY0ZjlkLi41NWNhNjNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvbm9raWEuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvbm9raWEuYwpAQCAtMjAzLDcgKzIwMyw3IEBACiAJCWdvdG8gZXJyX3VzYjsKIAl9CiAKLQkvKiBmaW5hbHkgcmVnaXN0ZXIgdGhlIGNvbmZpZ3VyYXRpb24gKi8KKwkvKiBmaW5hbGx5IHJlZ2lzdGVyIHRoZSBjb25maWd1cmF0aW9uICovCiAJc3RhdHVzID0gdXNiX2FkZF9jb25maWcoY2RldiwgJm5va2lhX2NvbmZpZ181MDBtYV9kcml2ZXIsCiAJCQlub2tpYV9iaW5kX2NvbmZpZyk7CiAJaWYgKHN0YXR1cyA8IDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvcHJpbnRlci5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L3ByaW50ZXIuYwppbmRleCAxMmZmNmNmLi5jM2YyYmQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvcHJpbnRlci5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9wcmludGVyLmMKQEAgLTEyNiw3ICsxMjYsNyBAQAogI2RlZmluZSBQUklOVEVSX1ZFTkRPUl9OVU0JMHgwNTI1CQkvKiBOZXRDaGlwICovCiAjZGVmaW5lIFBSSU5URVJfUFJPRFVDVF9OVU0JMHhhNGE4CQkvKiBMaW51eC1VU0IgUHJpbnRlciBHYWRnZXQgKi8KIAotLyogU29tZSBzeXN0ZW1zIHdpbGwgd2FudCBkaWZmZXJlbnQgcHJvZHVjdCBpZGVudGlmZXJzIHB1Ymxpc2hlZCBpbiB0aGUKKy8qIFNvbWUgc3lzdGVtcyB3aWxsIHdhbnQgZGlmZmVyZW50IHByb2R1Y3QgaWRlbnRpZmllcnMgcHVibGlzaGVkIGluIHRoZQogICogZGV2aWNlIGRlc2NyaXB0b3IsIGVpdGhlciBudW1iZXJzIG9yIHN0cmluZ3Mgb3IgYm90aC4gIFRoZXNlIHN0cmluZwogICogcGFyYW1ldGVycyBhcmUgaW4gVVRGLTggKHN1cGVyc2V0IG9mIEFTQ0lJJ3MgNyBiaXQgY2hhcmFjdGVycykuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9weGEyN3hfdWRjLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvcHhhMjd4X3VkYy5jCmluZGV4IDJlZmQ2NzMuLjc4YTM5YTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2dhZGdldC9weGEyN3hfdWRjLmMKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L3B4YTI3eF91ZGMuYwpAQCAtNjAyLDcgKzYwMiw3IEBACiAvKioKICAqIGluY19lcF9zdGF0c19ieXRlcyAtIFVwZGF0ZSBlcCBzdGF0cyBjb3VudHMKICAqIEBlcDogcGh5c2ljYWwgZW5kcG9pbnQKLSAqIEBjb3VudDogYnl0ZXMgdHJhbnNmZXJlZCBvbiBlbmRwb2ludAorICogQGNvdW50OiBieXRlcyB0cmFuc2ZlcnJlZCBvbiBlbmRwb2ludAogICogQGlzX2luOiBlcCBkaXJlY3Rpb24gKFVTQl9ESVJfSU4gb3IgMCkKICAqLwogc3RhdGljIHZvaWQgaW5jX2VwX3N0YXRzX2J5dGVzKHN0cnVjdCBweGFfZXAgKmVwLCBpbnQgY291bnQsIGludCBpc19pbikKQEAgLTg3Nyw3ICs4NzcsNyBAQAogICogSWYgdGhlcmUgaXMgbGVzcyBzcGFjZSBpbiByZXF1ZXN0IHRoYW4gYnl0ZXMgcmVjZWl2ZWQgaW4gT1VUIGVuZHBvaW50LAogICogYnl0ZXMgYXJlIGxlZnQgaW4gdGhlIE9VVCBlbmRwb2ludC4KICAqCi0gKiBSZXR1cm5zIGhvdyBtYW55IGJ5dGVzIHdlcmUgYWN0dWFsbHkgdHJhbnNmZXJlZAorICogUmV0dXJucyBob3cgbWFueSBieXRlcyB3ZXJlIGFjdHVhbGx5IHRyYW5zZmVycmVkCiAgKi8KIHN0YXRpYyBpbnQgcmVhZF9wYWNrZXQoc3RydWN0IHB4YV9lcCAqZXAsIHN0cnVjdCBweGEyN3hfcmVxdWVzdCAqcmVxKQogewpAQCAtOTE0LDcgKzkxNCw3IEBACiAgKiBlbmRwb2ludC4gSWYgdGhlcmUgYXJlIG5vIGJ5dGVzIHRvIHRyYW5zZmVyLCBkb2Vzbid0IHdyaXRlIGFueXRoaW5nCiAgKiB0byBwaHlzaWNhbCBlbmRwb2ludC4KICAqCi0gKiBSZXR1cm5zIGhvdyBtYW55IGJ5dGVzIHdlcmUgYWN0dWFsbHkgdHJhbnNmZXJlZC4KKyAqIFJldHVybnMgaG93IG1hbnkgYnl0ZXMgd2VyZSBhY3R1YWxseSB0cmFuc2ZlcnJlZC4KICAqLwogc3RhdGljIGludCB3cml0ZV9wYWNrZXQoc3RydWN0IHB4YV9lcCAqZXAsIHN0cnVjdCBweGEyN3hfcmVxdWVzdCAqcmVxLAogCQkJdW5zaWduZWQgaW50IG1heCkKQEAgLTk5MSw3ICs5OTEsNyBAQAogICogY2FsbGVyIGd1YXJhbnRlZXMgYXQgbGVhc3Qgb25lIHBhY2tldCBidWZmZXIgaXMgcmVhZHkgKG9yIGEgemxwKS4KICAqIERvZXNuJ3QgY29tcGxldGUgdGhlIHJlcXVlc3QsIHRoYXQncyB0aGUgY2FsbGVyJ3Mgam9iCiAgKgotICogUmV0dXJucyAxIGlmIHJlcXVlc3QgZnVsbHkgdHJhbnNmZXJlZCwgMCBpZiBwYXJ0aWFsIHRyYW5zZmVyCisgKiBSZXR1cm5zIDEgaWYgcmVxdWVzdCBmdWxseSB0cmFuc2ZlcnJlZCwgMCBpZiBwYXJ0aWFsIHRyYW5zZmVyCiAgKi8KIHN0YXRpYyBpbnQgd3JpdGVfZmlmbyhzdHJ1Y3QgcHhhX2VwICplcCwgc3RydWN0IHB4YTI3eF9yZXF1ZXN0ICpyZXEpCiB7CkBAIC0xMDk0LDcgKzEwOTQsNyBAQAogICogU2VuZHMgYSByZXF1ZXN0IChvciBhIHBhcnQgb2YgdGhlIHJlcXVlc3QpIHRvIHRoZSBjb250cm9sIGVuZHBvaW50IChlcDAgaW4pLgogICogSWYgdGhlIHJlcXVlc3QgZG9lc24ndCBmaXQsIHRoZSByZW1haW5pbmcgcGFydCB3aWxsIGJlIHNlbnQgZnJvbSBpcnEuCiAgKiBUaGUgcmVxdWVzdCBpcyBjb25zaWRlcmVkIGZ1bGx5IHdyaXR0ZW4gb25seSBpZiBlaXRoZXIgOgotICogICAtIGxhc3Qgd3JpdGUgdHJhbnNmZXJlZCBhbGwgcmVtYWluaW5nIGJ5dGVzLCBidXQgZmlmbyB3YXMgbm90IGZ1bGx5IGZpbGxlZAorICogICAtIGxhc3Qgd3JpdGUgdHJhbnNmZXJyZWQgYWxsIHJlbWFpbmluZyBieXRlcywgYnV0IGZpZm8gd2FzIG5vdCBmdWxseSBmaWxsZWQKICAqICAgLSBsYXN0IHdyaXRlIHdhcyBhIDAgbGVuZ3RoIHdyaXRlCiAgKgogICogUmV0dXJucyAxIGlmIHJlcXVlc3QgZnVsbHkgd3JpdHRlbiwgMCBpZiByZXF1ZXN0IG9ubHkgcGFydGlhbGx5IHNlbnQKQEAgLTE1NDgsNyArMTU0OCw3IEBACiAgKiBweGFfdWRjX3dha2V1cCAtIEZvcmNlIHVkYyBkZXZpY2Ugb3V0IG9mIHN1c3BlbmQKICAqIEBfZ2FkZ2V0OiB1c2IgZ2FkZ2V0CiAgKgotICogUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWxsLCBlcnJvciBjb2RlIG90aGVyd2lzZQorICogUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWwsIGVycm9yIGNvZGUgb3RoZXJ3aXNlCiAgKi8KIHN0YXRpYyBpbnQgcHhhX3VkY193YWtldXAoc3RydWN0IHVzYl9nYWRnZXQgKl9nYWRnZXQpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvczNjLWhzb3RnLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvczNjLWhzb3RnLmMKaW5kZXggZWY4MjVjMy4uMDkxMjY3OSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L3MzYy1oc290Zy5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9zM2MtaHNvdGcuYwpAQCAtNDEsOCArNDEsOCBAQAogLyogRVAwX01QU19MSU1JVAogICoKICAqIFVuZm9ydHVuYXRlbHkgdGhlcmUgc2VlbXMgdG8gYmUgYSBsaW1pdCBvZiB0aGUgYW1vdW50IG9mIGRhdGEgdGhhdCBjYW4KLSAqIGJlIHRyYW5zZmVyZWQgYnkgSU4gdHJhbnNhY3Rpb25zIG9uIEVQMC4gVGhpcyBpcyBlaXRoZXIgMTI3IGJ5dGVzIG9yIDMKLSAqIHBhY2tldHMgKHdoaWNoIHByYWN0aWFsbHkgbWVhbnMgMSBwYWNrZXQgYW5kIDYzIGJ5dGVzIG9mIGRhdGEpIHdoZW4gdGhlCisgKiBiZSB0cmFuc2ZlcnJlZCBieSBJTiB0cmFuc2FjdGlvbnMgb24gRVAwLiBUaGlzIGlzIGVpdGhlciAxMjcgYnl0ZXMgb3IgMworICogcGFja2V0cyAod2hpY2ggcHJhY3RpY2FsbHkgbWVhbnMgMSBwYWNrZXQgYW5kIDYzIGJ5dGVzIG9mIGRhdGEpIHdoZW4gdGhlCiAgKiBNUFMgaXMgc2V0IHRvIDY0LgogICoKICAqIFRoaXMgbWVhbnMgaWYgd2UgYXJlIHdhbnRpbmcgdG8gbW92ZSA+MTI3IGJ5dGVzIG9mIGRhdGEsIHdlIG5lZWQgdG8KQEAgLTc4Myw3ICs3ODMsNyBAQAogCQkgICAgICAgaHNvdGctPnJlZ3MgKyBTM0NfRElFUElOVChpbmRleCkpOwogCiAJLyogTm90ZSwgdHJ5aW5nIHRvIGNsZWFyIHRoZSBOQUsgaGVyZSBjYXVzZXMgcHJvYmxlbXMgd2l0aCB0cmFuc21pdAotCSAqIG9uIHRoZSBTM0M2NDAwIGVuZGluZyB1cCB3aXRoIHRoZSBUWEZJRk8gYmVjb21taW5nIGZ1bGwuICovCisJICogb24gdGhlIFMzQzY0MDAgZW5kaW5nIHVwIHdpdGggdGhlIFRYRklGTyBiZWNvbWluZyBmdWxsLiAqLwogCiAJLyogY2hlY2sgZXAgaXMgZW5hYmxlZCAqLwogCWlmICghKHJlYWRsKGhzb3RnLT5yZWdzICsgZXBjdHJsX3JlZykgJiBTM0NfRHhFUENUTF9FUEVuYSkpCkBAIC0xMTc2LDEwICsxMTc2LDEwIEBACiAJCXdyaXRlbChjdHJsLCBoc290Zy0+cmVncyArIHJlZyk7CiAKIAkJZGV2X2RiZyhoc290Zy0+ZGV2LAotCQkJIndyaXRlbiBEeEVQQ1RMPTB4JTA4eCB0byAlMDh4IChEeEVQQ1RMPTB4JTA4eClcbiIsCisJCQkid3JpdHRlbiBEeEVQQ1RMPTB4JTA4eCB0byAlMDh4IChEeEVQQ1RMPTB4JTA4eClcbiIsCiAJCQljdHJsLCByZWcsIHJlYWRsKGhzb3RnLT5yZWdzICsgcmVnKSk7CiAKLQkJLyogZG9uJ3QgYmVsaXZlIHdlIG5lZWQgdG8gYW55dGhpbmcgbW9yZSB0byBnZXQgdGhlIEVQCisJCS8qIGRvbid0IGJlbGlldmUgd2UgbmVlZCB0byBhbnl0aGluZyBtb3JlIHRvIGdldCB0aGUgRVAKIAkJICogdG8gcmVwbHkgd2l0aCBhIFNUQUxMIHBhY2tldCAqLwogCX0KIH0KQEAgLTE0MTYsNyArMTQxNiw3IEBACiAgKiB0cmFuc2FjdGlvbi4KICAqCiAgKiBOb3RlLCBzaW5jZSB3ZSBkb24ndCB3cml0ZSBhbnkgZGF0YSB0byB0aGUgVHhGSUZPLCB0aGVuIGl0IGlzCi0gKiBjdXJyZW50bHkgYmVsaXZlZCB0aGF0IHdlIGRvIG5vdCBuZWVkIHRvIHdhaXQgZm9yIGFueSBzcGFjZSBpbgorICogY3VycmVudGx5IGJlbGlldmVkIHRoYXQgd2UgZG8gbm90IG5lZWQgdG8gd2FpdCBmb3IgYW55IHNwYWNlIGluCiAgKiB0aGUgVHhGSUZPLgogICovCiBzdGF0aWMgdm9pZCBzM2NfaHNvdGdfc2VuZF96bHAoc3RydWN0IHMzY19oc290ZyAqaHNvdGcsCkBAIC0xNTQwLDcgKzE1NDAsNyBAQAogICogdGhhdCByZXF1aXJlcyBwcm9jZXNzaW5nLCBzbyBmaW5kIG91dCB3aGF0IGlzIGluIHRoZXJlIGFuZCBkbyB0aGUKICAqIGFwcHJvcHJpYXRlIHJlYWQuCiAgKgotICogVGhlIFJYRklGTyBpcyBhIHRydWUgRklGTywgdGhlIHBhY2tldHMgY29tbWluZyBvdXQgYXJlIHN0aWxsIGluIHBhY2tldAorICogVGhlIFJYRklGTyBpcyBhIHRydWUgRklGTywgdGhlIHBhY2tldHMgY29taW5nIG91dCBhcmUgc3RpbGwgaW4gcGFja2V0CiAgKiBjaHVua3MsIHNvIGlmIHlvdSBoYXZlIHggcGFja2V0cyByZWNlaXZlZCBvbiBhbiBlbmRwb2ludCB5b3UnbGwgZ2V0IHgKICAqIEZJRk8gZXZlbnRzIGRlbGl2ZXJlZCwgZWFjaCB3aXRoIGEgcGFja2V0J3Mgd29ydGggb2YgZGF0YSBpbiBpdC4KICAqCkBAIC0yMTg4LDcgKzIxODgsNyBAQAogCiAJLyogdGhlc2UgbmV4dCB0d28gc2VlbSB0byBjcm9wLXVwIG9jY2FzaW9uYWxseSBjYXVzaW5nIHRoZSBjb3JlCiAJICogdG8gc2h1dGRvd24gdGhlIFVTQiB0cmFuc2Zlciwgc28gdHJ5IGNsZWFyaW5nIHRoZW0gYW5kIGxvZ2dpbmcKLQkgKiB0aGUgb2NjdXJlbmNlLiAqLworCSAqIHRoZSBvY2N1cnJlbmNlLiAqLwogCiAJaWYgKGdpbnRzdHMgJiBTM0NfR0lOVFNUU19HT1VUTmFrRWZmKSB7CiAJCWRldl9pbmZvKGhzb3RnLT5kZXYsICJHT1VUTmFrRWZmIHRyaWdnZXJlZFxuIik7CkBAIC0yNDY5LDcgKzI0NjksNyBAQAogCS5xdWV1ZQkJPSBzM2NfaHNvdGdfZXBfcXVldWUsCiAJLmRlcXVldWUJPSBzM2NfaHNvdGdfZXBfZGVxdWV1ZSwKIAkuc2V0X2hhbHQJPSBzM2NfaHNvdGdfZXBfc2V0aGFsdCwKLQkvKiBub3RlLCBkb24ndCBiZWxpdmUgd2UgaGF2ZSBhbnkgY2FsbCBmb3IgdGhlIGZpZm8gcm91dGluZXMgKi8KKwkvKiBub3RlLCBkb24ndCBiZWxpZXZlIHdlIGhhdmUgYW55IGNhbGwgZm9yIHRoZSBmaWZvIHJvdXRpbmVzICovCiB9OwogCiAvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QvS2NvbmZpZyBiL2RyaXZlcnMvdXNiL2hvc3QvS2NvbmZpZwppbmRleCA5NDgzYWNkLi5lMGUwNzg3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L0tjb25maWcKKysrIGIvZHJpdmVycy91c2IvaG9zdC9LY29uZmlnCkBAIC00MDIsNyArNDAyLDcgQEAKIAlkZXBlbmRzIG9uIFVTQl9GSENJX0hDRCAmJiBERUJVR19GUwogCWhlbHAKIAkgIFNheSAieSIgdG8gc2VlIHNvbWUgRkhDSSBkZWJ1ZyBpbmZvcm1hdGlvbiBhbmQgc3RhdGlzdGljcwotCSAgdGhyb3VnaHQgZGVidWdmcy4KKwkgIHRocm91Z2ggZGVidWdmcy4KIAogY29uZmlnIFVTQl9VMTMyX0hDRAogCXRyaXN0YXRlICJFbGFuIFUxMzIgQWRhcHRlciBIb3N0IENvbnRyb2xsZXIiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2kuaCBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS5oCmluZGV4IGY4NmQzZmEuLjMzM2RkYzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS5oCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS5oCkBAIC02NDQsNyArNjQ0LDcgQEAKIC8qCiAgKiBPbiBjZXJ0YWluIHBwYy00NHggU29DIHRoZXJlIGlzIGEgSFcgaXNzdWUsIHRoYXQgY291bGQgb25seSB3b3JrZWQgYXJvdW5kIHdpdGgKICAqIGV4cGxpY2l0IHN1c3BlbmQvb3BlcmF0ZSBvZiBPSENJLiBUaGlzIGZ1bmN0aW9uIGhlcmVieSBtYWtlcyBzZW5zZSBvbmx5IG9uIHRoYXQgYXJjaC4KLSAqIE90aGVyIGNvbW1vbiBiaXRzIGFyZSBkZXBlbmRhbnQgb24gaGFzX2FtY2NfdXNiMjMgcXVpcmsgZmxhZy4KKyAqIE90aGVyIGNvbW1vbiBiaXRzIGFyZSBkZXBlbmRlbnQgb24gaGFzX2FtY2NfdXNiMjMgcXVpcmsgZmxhZy4KICAqLwogI2lmZGVmIENPTkZJR180NHgKIHN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfb2hjaV9oY2ZzKHN0cnVjdCBlaGNpX2hjZCAqZWhjaSwgaW50IG9wZXJhdGlvbmFsKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9maGNpLWhjZC5jIGIvZHJpdmVycy91c2IvaG9zdC9maGNpLWhjZC5jCmluZGV4IGI4NGZmN2UuLjE5MjIzYzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvZmhjaS1oY2QuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L2ZoY2ktaGNkLmMKQEAgLTQwMSw3ICs0MDEsNyBAQAogCQkvKiAxIHRkIGZybyBzZXR1cCwxIGZvciBhY2sgKi8KIAkJc2l6ZSA9IDI7CiAJY2FzZSBQSVBFX0JVTEs6Ci0JCS8qIG9uZSB0ZCBmb3IgZXZlcnkgNDA5NiBieXRlcyhjYW4gYmUgdXB0byA4aykgKi8KKwkJLyogb25lIHRkIGZvciBldmVyeSA0MDk2IGJ5dGVzKGNhbiBiZSB1cCB0byA4aykgKi8KIAkJc2l6ZSArPSB1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGggLyA0MDk2OwogCQkvKiAuLi5hZGQgZm9yIGFueSByZW1haW5pbmcgYnl0ZXMuLi4gKi8KIAkJaWYgKCh1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGggJSA0MDk2KSAhPSAwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9maGNpLXRkcy5jIGIvZHJpdmVycy91c2IvaG9zdC9maGNpLXRkcy5jCmluZGV4IDM4ZmUwNTguLjBlYTU3N2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvZmhjaS10ZHMuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L2ZoY2ktdGRzLmMKQEAgLTQwLDcgKzQwLDcgQEAKICNkZWZpbmUgVERfUlhFUgkJMHgwMDIwIC8qIFJ4IGVycm9yIG9yIG5vdCAqLwogCiAjZGVmaW5lIFREX05BSwkJMHgwMDEwIC8qIE5vIGFjay4gKi8KLSNkZWZpbmUgVERfU1RBTAkJMHgwMDA4IC8qIFN0YWxsIHJlY2lldmVkICovCisjZGVmaW5lIFREX1NUQUwJCTB4MDAwOCAvKiBTdGFsbCByZWNlaXZlZCAqLwogI2RlZmluZSBURF9UTwkJMHgwMDA0IC8qIHRpbWUgb3V0ICovCiAjZGVmaW5lIFREX1VOCQkweDAwMDIgLyogdW5kZXJydW4gKi8KICNkZWZpbmUgVERfTk8JCTB4MDAxMCAvKiBSeCBOb24gT2N0ZXQgQWxpZ25lZCBQYWNrZXQgKi8KQEAgLTI3NCw3ICsyNzQsNyBAQAogICogSXQgaXMgYWxzbyBwcmVwYXJpbmcgdGhlIFREcyBmb3IgbmV3IGZyYW1lcy4gSWYgdGhlIFR4IGludGVycnVwdHMKICAqIGFyZSBkaXNhYmxlZCwgdGhlIGFwcGxpY2F0aW9uIHNob3VsZCBjYWxsIHRoYXQgcm91dGluZSB0byBnZXQKICAqIGNvbmZpcm1hdGlvbiBhYm91dCB0aGUgc3VibWl0dGVkIGZyYW1lcy4gT3RoZXJ3aXNlLCB0aGUgcm91dGluZSBpcwotICogY2FsbGVkIGZyb21lIHRoZSBpbnRlcnJ1cHQgc2VydmljZSByb3V0aW5lIGR1cmluZyB0aGUgVHggaW50ZXJydXB0LgorICogY2FsbGVkIGZyb20gdGhlIGludGVycnVwdCBzZXJ2aWNlIHJvdXRpbmUgZHVyaW5nIHRoZSBUeCBpbnRlcnJ1cHQuCiAgKiBJbiB0aGF0IGNhc2UgdGhlIGFwcGxpY2F0aW9uIGlzIGluZm9ybWVkIGJ5IGNhbGxpbmcgdGhlIGFwcGxpY2F0aW9uCiAgKiBzcGVjaWZpYyAnZmhjaV90cmFuc2FjdGlvbl9jb25maXJtJyByb3V0aW5lCiAgKi8KQEAgLTMzNyw3ICszMzcsNyBAQAogCQkJCQlwa3QtPnN0YXR1cyA9IFVTQl9URF9SWF9FUl9OT05PQ1Q7CiAJCQkJZWxzZQogCQkJCQlmaGNpX2Vycih1c2ItPmZoY2ksICJpbGxlZ2FsIGVycm9yICIKLQkJCQkJCSAib2NjdXJlZFxuIik7CisJCQkJCQkgIm9jY3VycmVkXG4iKTsKIAkJCX0gZWxzZSBpZiAodGRfc3RhdHVzICYgVERfTkFLKQogCQkJCXBrdC0+c3RhdHVzID0gVVNCX1REX1RYX0VSX05BSzsKIAkJCWVsc2UgaWYgKHRkX3N0YXR1cyAmIFREX1RPKQpAQCAtMzQ3LDcgKzM0Nyw3IEBACiAJCQllbHNlIGlmICh0ZF9zdGF0dXMgJiBURF9TVEFMKQogCQkJCXBrdC0+c3RhdHVzID0gVVNCX1REX1RYX0VSX1NUQUxMOwogCQkJZWxzZQotCQkJCWZoY2lfZXJyKHVzYi0+ZmhjaSwgImlsbGVnYWwgZXJyb3Igb2NjdXJlZFxuIik7CisJCQkJZmhjaV9lcnIodXNiLT5maGNpLCAiaWxsZWdhbCBlcnJvciBvY2N1cnJlZFxuIik7CiAJCX0gZWxzZSBpZiAoKGV4dHJhX2RhdGEgJiBURF9UT0tfSU4pICYmCiAJCQkJcGt0LT5sZW4gPiB0ZF9sZW5ndGggLSBDUkNfU0laRSkgewogCQkJcGt0LT5zdGF0dXMgPSBVU0JfVERfUlhfREFUQV9VTkRFUlVOOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9maGNpLmggYi9kcml2ZXJzL3VzYi9ob3N0L2ZoY2kuaAppbmRleCA3MWMzY2FhLi5kYzY5MzlhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2ZoY2kuaAorKysgYi9kcml2ZXJzL3VzYi9ob3N0L2ZoY2kuaApAQCAtODIsNyArODIsNyBAQAogI2RlZmluZSBVU0JfVERfUlhfRVJfTk9OT0NUCTB4NDAwMDAwMDAgLyogVHggTm9uIE9jdGV0IEFsaWduZWQgUGFja2V0ICovCiAjZGVmaW5lIFVTQl9URF9SWF9FUl9CSVRTVFVGRgkweDIwMDAwMDAwIC8qIEZyYW1lIEFib3J0ZWQtUmVjZWl2ZWQgcGt0ICovCiAjZGVmaW5lIFVTQl9URF9SWF9FUl9DUkMJMHgxMDAwMDAwMCAvKiBDUkMgZXJyb3IgKi8KLSNkZWZpbmUgVVNCX1REX1JYX0VSX09WRVJVTgkweDA4MDAwMDAwIC8qIE92ZXIgLSBydW4gb2NjdXJlZCAqLworI2RlZmluZSBVU0JfVERfUlhfRVJfT1ZFUlVOCTB4MDgwMDAwMDAgLyogT3ZlciAtIHJ1biBvY2N1cnJlZCAqLwogI2RlZmluZSBVU0JfVERfUlhfRVJfUElECTB4MDQwMDAwMDAgLyogd3JvbmcgUElEIHJlY2VpdmVkICovCiAjZGVmaW5lIFVTQl9URF9SWF9EQVRBX1VOREVSVU4JMHgwMjAwMDAwMCAvKiBzaG9ydGVyIHRoYW4gZXhwZWN0ZWQgKi8KICNkZWZpbmUgVVNCX1REX1JYX0RBVEFfT1ZFUlVOCTB4MDEwMDAwMDAgLyogbG9uZ2VyIHRoYW4gZXhwZWN0ZWQgKi8KQEAgLTM2Myw3ICszNjMsNyBAQAogc3RydWN0IHRkIHsKIAl2b2lkICpkYXRhOwkJIC8qIGEgcG9pbnRlciB0byB0aGUgZGF0YSBidWZmZXIgKi8KIAl1bnNpZ25lZCBpbnQgbGVuOwkgLyogbGVuZ3RoIG9mIHRoZSBkYXRhIHRvIGJlIHN1Ym1pdHRlZCAqLwotCXVuc2lnbmVkIGludCBhY3R1YWxfbGVuOyAvKiBhY3R1YWwgYnl0ZXMgdHJhbnNmZXJlZCBvbiB0aGlzIHRkICovCisJdW5zaWduZWQgaW50IGFjdHVhbF9sZW47IC8qIGFjdHVhbCBieXRlcyB0cmFuc2ZlcnJlZCBvbiB0aGlzIHRkICovCiAJZW51bSBmaGNpX3RhX3R5cGUgdHlwZTsJIC8qIHRyYW5zYWN0aW9uIHR5cGUgKi8KIAl1OCB0b2dnbGU7CQkgLyogdG9nZ2xlIGZvciBuZXh0IHRyYW5zLiB3aXRoaW4gdGhpcyBURCAqLwogCXUxNiBpc29faW5kZXg7CQkgLyogSVNPIHRyYW5zYWN0aW9uIGluZGV4ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2lteDIxLWhjZC5jIGIvZHJpdmVycy91c2IvaG9zdC9pbXgyMS1oY2QuYwppbmRleCAyNTYyZTkyLi5hZjA1NzE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2lteDIxLWhjZC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvaW14MjEtaGNkLmMKQEAgLTEzMjMsNyArMTMyMyw3IEBACiAgKiAoYW5kIGhlbmNlIG5vIGludGVycnVwdCBvY2N1cnMpLgogICogVGhpcyBjYXVzZXMgdGhlIHRyYW5zZmVyIGluIHF1ZXN0aW9uIHRvIGhhbmcuCiAgKiBUaGUga2x1ZGdlIGJlbG93IGNoZWNrcyBmb3IgdGhpcyBjb25kaXRpb24gYXQgZWFjaCBTT0YgYW5kIHByb2Nlc3NlcyBhbnkKLSAqIGJsb2NrZWQgRVREcyAoYWZ0ZXIgYW4gYXJiaXRhcnkgMTAgZnJhbWUgd2FpdCkKKyAqIGJsb2NrZWQgRVREcyAoYWZ0ZXIgYW4gYXJiaXRyYXJ5IDEwIGZyYW1lIHdhaXQpCiAgKgogICogV2l0aCBhIHNpbmdsZSBhY3RpdmUgdHJhbnNmZXIgdGhlIHVzYnRlc3QgdGVzdCBzdWl0ZSB3aWxsIHJ1biBmb3IgZGF5cwogICogd2l0aG91dCB0aGUga2x1ZGdlLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9pc3AxMTZ4LmggYi9kcml2ZXJzL3VzYi9ob3N0L2lzcDExNnguaAppbmRleCAxMmRiOTYxLi45YTJjNDAwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2lzcDExNnguaAorKysgYi9kcml2ZXJzL3VzYi9ob3N0L2lzcDExNnguaApAQCAtMTMsNyArMTMsNyBAQAogCiAvKiBGdWxsIHNwZWVkOiBtYXggIyBvZiBieXRlcyB0byB0cmFuc2ZlciBmb3IgYSBzaW5nbGUgdXJiCiAgICBhdCBhIHRpbWUgbXVzdCBiZSA8IDEwMjQgJiYgbXVzdCBiZSBtdWx0aXBsZSBvZiA2NC4KLSAgIDgzMiBhbGxvd3MgdHJhbnNmZXJpbmcgNGtpQiB3aXRoaW4gNSBmcmFtZXMuICovCisgICA4MzIgYWxsb3dzIHRyYW5zZmVycmluZyA0a2lCIHdpdGhpbiA1IGZyYW1lcy4gKi8KICNkZWZpbmUgTUFYX1RSQU5TRkVSX1NJWkVfRlVMTFNQRUVECTgzMgogCiAvKiBMb3cgc3BlZWQ6IHRoZXJlIGlzIG5vIHJlYXNvbiB0byBzY2hlZHVsZSBpbiB2ZXJ5IGJpZwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9pc3AxMzYyLWhjZC5jIGIvZHJpdmVycy91c2IvaG9zdC9pc3AxMzYyLWhjZC5jCmluZGV4IDY2MmNkMDAuLmY5NzU3MGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvaXNwMTM2Mi1oY2QuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L2lzcDEzNjItaGNkLmMKQEAgLTU0Niw3ICs1NDYsNyBAQAogCQkJaWYgKHVzYl9waXBlY29udHJvbCh1cmItPnBpcGUpKSB7CiAJCQkJZXAtPm5leHRwaWQgPSBVU0JfUElEX0FDSzsKIAkJCQkvKiBzYXZlIHRoZSBkYXRhIHVuZGVycnVuIGVycm9yIGNvZGUgZm9yIGxhdGVyIGFuZAotCQkJCSAqIHByb2NlZGUgd2l0aCB0aGUgc3RhdHVzIHN0YWdlCisJCQkJICogcHJvY2VlZCB3aXRoIHRoZSBzdGF0dXMgc3RhZ2UKIAkJCQkgKi8KIAkJCQl1cmItPmFjdHVhbF9sZW5ndGggKz0gUFREX0dFVF9DT1VOVChwdGQpOwogCQkJCUJVR19PTih1cmItPmFjdHVhbF9sZW5ndGggPiB1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9vaGNpLWhjZC5jIGIvZHJpdmVycy91c2IvaG9zdC9vaGNpLWhjZC5jCmluZGV4IGU3Mjg4NjMuLmQ1NTcyMzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3Qvb2hjaS1oY2QuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L29oY2ktaGNkLmMKQEAgLTE2Miw3ICsxNjIsNyBAQAogCQkvLyBjYXNlIFBJUEVfSU5URVJSVVBUOgogCQkvLyBjYXNlIFBJUEVfQlVMSzoKIAkJZGVmYXVsdDoKLQkJCS8qIG9uZSBURCBmb3IgZXZlcnkgNDA5NiBCeXRlcyAoY2FuIGJlIHVwdG8gOEspICovCisJCQkvKiBvbmUgVEQgZm9yIGV2ZXJ5IDQwOTYgQnl0ZXMgKGNhbiBiZSB1cCB0byA4SykgKi8KIAkJCXNpemUgKz0gdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoIC8gNDA5NjsKIAkJCS8qIC4uLiBhbmQgZm9yIGFueSByZW1haW5pbmcgYnl0ZXMgLi4uICovCiAJCQlpZiAoKHVyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCAlIDQwOTYpICE9IDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L294dTIxMGhwLWhjZC5jIGIvZHJpdmVycy91c2IvaG9zdC9veHUyMTBocC1oY2QuYwppbmRleCA0NGU0ZGViLi40YTc3MWY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L294dTIxMGhwLWhjZC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3Qvb3h1MjEwaHAtaGNkLmMKQEAgLTI4NzksNyArMjg3OSw3IEBACiAJLyogT2ssIHdlIGhhdmUgbW9yZSBqb2IgdG8gZG8hIDopICovCiAKIAlmb3IgKGkgPSAwOyBpIDwgbnVtIC0gMTsgaSsrKSB7Ci0JCS8qIEdldCBmcmVlIG1pY3JvIFVSQiBwb2xsIHRpbGwgYSBmcmVlIHVyYiBpcyByZWNpZXZlZCAqLworCQkvKiBHZXQgZnJlZSBtaWNybyBVUkIgcG9sbCB0aWxsIGEgZnJlZSB1cmIgaXMgcmVjZWl2ZWQgKi8KIAogCQlkbyB7CiAJCQltdXJiID0gKHN0cnVjdCB1cmIgKikgb3h1X211cmJfYWxsb2Mob3h1KTsKQEAgLTI5MTEsNyArMjkxMSw3IEBACiAKIAkvKiBMYXN0IHVyYiByZXF1aXJlcyBzcGVjaWFsIGhhbmRsaW5nICAqLwogCi0JLyogR2V0IGZyZWUgbWljcm8gVVJCIHBvbGwgdGlsbCBhIGZyZWUgdXJiIGlzIHJlY2lldmVkICovCisJLyogR2V0IGZyZWUgbWljcm8gVVJCIHBvbGwgdGlsbCBhIGZyZWUgdXJiIGlzIHJlY2VpdmVkICovCiAJZG8gewogCQltdXJiID0gKHN0cnVjdCB1cmIgKikgb3h1X211cmJfYWxsb2Mob3h1KTsKIAkJaWYgKCFtdXJiKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC93aGNpL3FzZXQuYyBiL2RyaXZlcnMvdXNiL2hvc3Qvd2hjaS9xc2V0LmMKaW5kZXggZGMwYWI4My4uZDZlMTc1NCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC93aGNpL3FzZXQuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L3doY2kvcXNldC5jCkBAIC03MzksNyArNzM5LDcgQEAKICAqIHByb2Nlc3NfaW5hY3RpdmVfcXRkIC0gcHJvY2VzcyBhbiBpbmFjdGl2ZSAoYnV0IG5vdCBoYWx0ZWQpIHFURC4KICAqCiAgKiBVcGRhdGUgdGhlIHVyYiB3aXRoIHRoZSB0cmFuc2ZlciBieXRlcyBmcm9tIHRoZSBxVEQsIGlmIHRoZSB1cmIgaXMKLSAqIGNvbXBsZXRlbHkgdHJhbnNmZXJlZCBvciAoaW4gdGhlIGNhc2Ugb2YgYW4gSU4gb25seSkgdGhlIExQRiBpcworICogY29tcGxldGVseSB0cmFuc2ZlcnJlZCBvciAoaW4gdGhlIGNhc2Ugb2YgYW4gSU4gb25seSkgdGhlIExQRiBpcwogICogc2V0LCB0aGVuIHRoZSB0cmFuc2ZlciBpcyBjb21wbGV0ZSBhbmQgdGhlIHVyYiBzaG91bGQgYmUgcmV0dXJuZWQKICAqIHRvIHRoZSBzeXN0ZW0uCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5jIGIvZHJpdmVycy91c2IvaG9zdC94aGNpLmMKaW5kZXggOWEzNjQ1Zi4uMTk2ZTAxOCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC94aGNpLmMKKysrIGIvZHJpdmVycy91c2IvaG9zdC94aGNpLmMKQEAgLTc0MSw3ICs3NDEsNyBAQAogCWludAkJCXJldHZhbDsKIAogCS8qIFdhaXQgYSBiaXQgaWYgZWl0aGVyIG9mIHRoZSByb290aHVicyBuZWVkIHRvIHNldHRsZSBmcm9tIHRoZQotCSAqIHRyYW5zaXN0aW9uIGludG8gYnVzIHN1c3BlbmQuCisJICogdHJhbnNpdGlvbiBpbnRvIGJ1cyBzdXNwZW5kLgogCSAqLwogCWlmICh0aW1lX2JlZm9yZShqaWZmaWVzLCB4aGNpLT5idXNfc3RhdGVbMF0ubmV4dF9zdGF0ZWNoYW5nZSkgfHwKIAkJCXRpbWVfYmVmb3JlKGppZmZpZXMsCkBAIC0yMDcyLDcgKzIwNzIsNyBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAJdmRldiA9IHhoY2ktPmRldnNbdWRldi0+c2xvdF9pZF07Ci0JLyogTWFyayBlYWNoIGVuZHBvaW50IGFzIGJlaW5nIGluIHRyYW5zaXN0aW9uLCBzbworCS8qIE1hcmsgZWFjaCBlbmRwb2ludCBhcyBiZWluZyBpbiB0cmFuc2l0aW9uLCBzbwogCSAqIHhoY2lfdXJiX2VucXVldWUoKSB3aWxsIHJlamVjdCBhbGwgVVJCcy4KIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgbnVtX2VwczsgaSsrKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuaCBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5oCmluZGV4IDcxMWRlMjUuLjA3ZTI2MzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5oCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5oCkBAIC04NzMsNyArODczLDcgQEAKICNkZWZpbmUgQ09NUF9DTURfQUJPUlQJMjUKIC8qIFN0b3BwZWQgLSB0cmFuc2ZlciB3YXMgdGVybWluYXRlZCBieSBhIHN0b3AgZW5kcG9pbnQgY29tbWFuZCAqLwogI2RlZmluZSBDT01QX1NUT1AJMjYKLS8qIFNhbWUgYXMgQ09NUF9FUF9TVE9QUEVELCBidXQgdGhlIHRyYW5zZmVyZWQgbGVuZ3RoIGluIHRoZSBldmVudCBpcyBpbnZhbGlkICovCisvKiBTYW1lIGFzIENPTVBfRVBfU1RPUFBFRCwgYnV0IHRoZSB0cmFuc2ZlcnJlZCBsZW5ndGggaW4gdGhlIGV2ZW50IGlzIGludmFsaWQgKi8KICNkZWZpbmUgQ09NUF9TVE9QX0lOVkFMCTI3CiAvKiBDb250cm9sIEFib3J0IEVycm9yIC0gRGVidWcgQ2FwYWJpbGl0eSAtIGNvbnRyb2wgcGlwZSBhYm9ydGVkICovCiAjZGVmaW5lIENPTVBfREJHX0FCT1JUCTI4CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9pbWFnZS9taWNyb3Rlay5jIGIvZHJpdmVycy91c2IvaW1hZ2UvbWljcm90ZWsuYwppbmRleCBjOTBjODlkLi5hMDAzNzk2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9pbWFnZS9taWNyb3Rlay5jCisrKyBiL2RyaXZlcnMvdXNiL2ltYWdlL21pY3JvdGVrLmMKQEAgLTY5LDcgKzY5LDcgQEAKICAqCTIwMDAwNTEzIGFkZGVkIElEcyBmb3IgYWxsIHByb2R1Y3RzIHN1cHBvcnRlZCBieSBXaW5kb3dzIGRyaXZlciAoam9obikKICAqCTIwMDAwNTE0IFJld3JvdGUgbXRzX3Njc2lfcXVldWVjb21tYW5kIHRvIHVzZSBVUkJzIChqb2huKQogICoJMjAwMDA1MTQgVmVyc2lvbiAwLjAuOGoKLSAqICAgICAgMjAwMDA1MTQgRml4IHJlcG9ydGluZyBvZiBub24tZXhpc3RhbnQgZGV2aWNlcyB0byBTQ1NJIGxheWVyIChqb2huKQorICogICAgICAyMDAwMDUxNCBGaXggcmVwb3J0aW5nIG9mIG5vbi1leGlzdGVudCBkZXZpY2VzIHRvIFNDU0kgbGF5ZXIgKGpvaG4pCiAgKgkyMDAwMDUxNCBBZGRlZCBNVFNfREVCVUdfSU5UIChqb2huKQogICoJMjAwMDA1MTQgQ2hhbmdlZCAidXNiLW1pY3JvdGVrIiB0byAibWljcm90ZWsiIGZvciBjb25zaXN0ZW5jeSAoam9obikKICAqCTIwMDAwNTE0IFN0dXBpZCBidWcgZml4ZXMgKGpvaG4pCkBAIC01NTcsMTQgKzU1NywxNCBAQAogCiAJaWYgKCAhbWVtY21wKCBzcmItPmNtbmQsIG10c19yZWFkX2ltYWdlX3NpZywgbXRzX3JlYWRfaW1hZ2Vfc2lnX2xlbiApCiApIHsgCQlwaXBlID0gdXNiX3JjdmJ1bGtwaXBlKGRlc2MtPnVzYl9kZXYsZGVzYy0+ZXBfaW1hZ2UpOwotCQlNVFNfREVCVUcoICJ0cmFuc2ZlcmluZyBmcm9tIGRlc2MtPmVwX2ltYWdlID09ICVkXG4iLAorCQlNVFNfREVCVUcoICJ0cmFuc2ZlcnJpbmcgZnJvbSBkZXNjLT5lcF9pbWFnZSA9PSAlZFxuIiwKIAkJCSAgIChpbnQpZGVzYy0+ZXBfaW1hZ2UgKTsKIAl9IGVsc2UgaWYgKCBNVFNfRElSRUNUSU9OX0lTX0lOKHNyYi0+Y21uZFswXSkgKSB7CiAJCQlwaXBlID0gdXNiX3JjdmJ1bGtwaXBlKGRlc2MtPnVzYl9kZXYsZGVzYy0+ZXBfcmVzcG9uc2UpOwotCQkJTVRTX0RFQlVHKCAidHJhbnNmZXJpbmcgZnJvbSBkZXNjLT5lcF9yZXNwb25zZSA9PSAlZFxuIiwKKwkJCU1UU19ERUJVRyggInRyYW5zZmVycmluZyBmcm9tIGRlc2MtPmVwX3Jlc3BvbnNlID09ICVkXG4iLAogCQkJCSAgIChpbnQpZGVzYy0+ZXBfcmVzcG9uc2UpOwogCX0gZWxzZSB7Ci0JCU1UU19ERUJVRygidHJhbnNmZXJpbmcgdG8gZGVzYy0+ZXBfb3V0ID09ICVkXG4iLAorCQlNVFNfREVCVUcoInRyYW5zZmVycmluZyB0byBkZXNjLT5lcF9vdXQgPT0gJWRcbiIsCiAJCQkgIChpbnQpZGVzYy0+ZXBfb3V0KTsKIAkJcGlwZSA9IHVzYl9zbmRidWxrcGlwZShkZXNjLT51c2JfZGV2LGRlc2MtPmVwX291dCk7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvbWlzYy9pb3dhcnJpb3IuYyBiL2RyaXZlcnMvdXNiL21pc2MvaW93YXJyaW9yLmMKaW5kZXggZTU3M2U0Ny4uYTIxOTBiOSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvbWlzYy9pb3dhcnJpb3IuYworKysgYi9kcml2ZXJzL3VzYi9taXNjL2lvd2Fycmlvci5jCkBAIC00MCw3ICs0MCw3IEBACiAjaWZkZWYgQ09ORklHX1VTQl9EWU5BTUlDX01JTk9SUwogI2RlZmluZSBJT1dBUlJJT1JfTUlOT1JfQkFTRQkwCiAjZWxzZQotI2RlZmluZSBJT1dBUlJJT1JfTUlOT1JfQkFTRQkyMDgJLy8gU0tFTEVUT05fTUlOT1JfQkFTRSAxOTIgKyAxNiwgbm90IG9mZmljYWwgeWV0CisjZGVmaW5lIElPV0FSUklPUl9NSU5PUl9CQVNFCTIwOAkvLyBTS0VMRVRPTl9NSU5PUl9CQVNFIDE5MiArIDE2LCBub3Qgb2ZmaWNpYWwgeWV0CiAjZW5kaWYKIAogLyogaW50ZXJydXB0IGlucHV0IHF1ZXVlIHNpemUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL290Zy9pc3AxMzAxX29tYXAuYyBiL2RyaXZlcnMvdXNiL290Zy9pc3AxMzAxX29tYXAuYwppbmRleCA4YzZmZGVmLi5lMjU3MDBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9vdGcvaXNwMTMwMV9vbWFwLmMKKysrIGIvZHJpdmVycy91c2Ivb3RnL2lzcDEzMDFfb21hcC5jCkBAIC0xNTMxLDcgKzE1MzEsNyBAQAogCWkyY19zZXRfY2xpZW50ZGF0YShpMmMsIGlzcCk7CiAJaXNwLT5jbGllbnQgPSBpMmM7CiAKLQkvKiB2ZXJpZnkgdGhlIGNoaXAgKHNob3VsZG4ndCBiZSBuZWNlc2FyeSkgKi8KKwkvKiB2ZXJpZnkgdGhlIGNoaXAgKHNob3VsZG4ndCBiZSBuZWNlc3NhcnkpICovCiAJc3RhdHVzID0gaXNwMTMwMV9nZXRfdTE2KGlzcCwgSVNQMTMwMV9WRU5ET1JfSUQpOwogCWlmIChzdGF0dXMgIT0gSTJDX1ZFTkRPUl9JRF9QSElMSVBTKSB7CiAJCWRldl9kYmcoJmkyYy0+ZGV2LCAibm90IHBoaWxpcHMgaWQ6ICVkXG4iLCBzdGF0dXMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivb3RnL2xhbmd3ZWxsX290Zy5jIGIvZHJpdmVycy91c2Ivb3RnL2xhbmd3ZWxsX290Zy5jCmluZGV4IDdmOWI4Y2QuLmU5NzNmZjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL290Zy9sYW5nd2VsbF9vdGcuYworKysgYi9kcml2ZXJzL3VzYi9vdGcvbGFuZ3dlbGxfb3RnLmMKQEAgLTU4MCw3ICs1ODAsNyBAQAogCQl0aW1lID0gVEJfQlVTX1NVU1BFTkQ7CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCWRldl9kYmcobG53LT5kZXYsICJ1bmtvd24gdGltZXIsIGNhbm5vdCBlbmFibGUgaXRcbiIpOworCQlkZXZfZGJnKGxudy0+ZGV2LCAidW5rbm93biB0aW1lciwgY2Fubm90IGVuYWJsZSBpdFxuIik7CiAJCXJldHVybjsKIAl9CiAKQEAgLTEzODEsNyArMTM4MSw3IEBACiAJCQl9IGVsc2UgaWYgKCFpb3RnLT5oc20uYV9idXNfcmVxICYmIGlvdGctPm90Zy5ob3N0ICYmCiAJCQkJCWlvdGctPm90Zy5ob3N0LT5iX2hucF9lbmFibGUpIHsKIAkJCQkvKiBJdCBpcyBub3Qgc2FmZSBlbm91Z2ggdG8gZG8gYSBmYXN0Ci0JCQkJICogdHJhbnNpc3Rpb24gZnJvbSBBX1dBSVRfQkNPTiB0bworCQkJCSAqIHRyYW5zaXRpb24gZnJvbSBBX1dBSVRfQkNPTiB0bwogCQkJCSAqIEFfU1VTUEVORCAqLwogCQkJCW1zbGVlcCgxMDAwMCk7CiAJCQkJaWYgKGlvdGctPmhzbS5hX2J1c19yZXEpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvYWlyY2FibGUuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9haXJjYWJsZS5jCmluZGV4IDBkYjZhY2UuLmFiYTIwMWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9haXJjYWJsZS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9haXJjYWJsZS5jCkBAIC0xNiw3ICsxNiw3IEBACiAgKiBXaGVuIHJlYWRpbmcgdGhlIHByb2Nlc3MgaXMgYWxtb3N0IGVxdWFsIGV4Y2VwdCB0aGF0IHRoZSBoZWFkZXIgc3RhcnRzIHdpdGgKICAqIDB4MDAgMHgyMC4KICAqCi0gKiBUaGUgZGV2aWNlIHNpbXBseSBuZWVkIHNvbWUgc3R1ZmYgdG8gdW5kZXJzdGFuZCBkYXRhIGNvbW1pbmcgZnJvbSB0aGUgdXNiCisgKiBUaGUgZGV2aWNlIHNpbXBseSBuZWVkIHNvbWUgc3R1ZmYgdG8gdW5kZXJzdGFuZCBkYXRhIGNvbWluZyBmcm9tIHRoZSB1c2IKICAqIGJ1ZmZlcjogVGhlIEZpcnN0IGFuZCBTZWNvbmQgYnl0ZSBpcyB1c2VkIGZvciBhIEhlYWRlciwgdGhlIFRoaXJkIGFuZCBGb3VydGgKICAqIHRlbGxzIHRoZSAgZGV2aWNlIHRoZSBhbW91bnQgb2YgaW5mb3JtYXRpb24gdGhlIHBhY2thZ2UgaG9sZHMuCiAgKiBQYWNrYWdlcyBhcmUgNjAgYnl0ZXMgbG9uZyBIZWFkZXIgU3R1ZmYuCkBAIC0zMCw3ICszMCw3IEBACiAgKiBvbmUuCiAgKgogICogVGhlIGRyaXZlciByZWdpc3RlcnMgaGltc2VsZiB3aXRoIHRoZSBVU0Itc2VyaWFsIGNvcmUgYW5kIHRoZSBVU0IgQ29yZS4gSSBoYWQKLSAqIHRvIGltcGxlbWVudCBhIHByb2JlIGZ1bmN0aW9uIGFnYWlucyBVU0Itc2VyaWFsLCBiZWNhdXNlIG90aGVyIHdheSwgdGhlCisgKiB0byBpbXBsZW1lbnQgYSBwcm9iZSBmdW5jdGlvbiBhZ2FpbnN0IFVTQi1zZXJpYWwsIGJlY2F1c2Ugb3RoZXIgd2F5LCB0aGUKICAqIGRyaXZlciB3YXMgYXR0YWNoaW5nIGhpbXNlbGYgdG8gYm90aCBpbnRlcmZhY2VzLiBJIGhhdmUgdHJ5ZWQgd2l0aCBkaWZmZXJlbnQKICAqIGNvbmZpZ3VyYXRpb25zIG9mIHVzYl9zZXJpYWxfZHJpdmVyIHdpdGggb3V0IGV4aXQsIG9ubHkgdGhlIHByb2JlIGZ1bmN0aW9uCiAgKiBjb3VsZCBoYW5kbGUgdGhpcyBjb3JyZWN0bHkuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvY3AyMTB4LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvY3AyMTB4LmMKaW5kZXggNGRmM2UwYy4uMGYxMWFmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2NwMjEweC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9jcDIxMHguYwpAQCAtMTAxLDcgKzEwMSw3IEBACiAJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4MUYyKSB9LCAvKiBDMTAwNyBIRiBiYW5kIFJGSUQgY29udHJvbGxlciAqLwogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODIxOCkgfSwgLyogTGlwb3dza3kgSW5kdXN0cmllIEVsZWt0cm9uaWsgR21iSCwgSEFSUC0xICovCiAJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4MjJCKSB9LCAvKiBNb2RlbSBFREdFKEdTTSkgQ29tYW5kZXIgMiAqLwotCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODI2QikgfSwgLyogQ3lnbmFsIEludGVncmF0ZWQgUHJvZHVjdHMsIEluYy4sIEZhc3R0cmF4IEdQUyBkZW1vc3RyYXRpb24gbW9kdWxlICovCisJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4MjZCKSB9LCAvKiBDeWduYWwgSW50ZWdyYXRlZCBQcm9kdWN0cywgSW5jLiwgRmFzdHRyYXggR1BTIGRlbW9uc3RyYXRpb24gbW9kdWxlICovCiAJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4MjkzKSB9LCAvKiBUZWxlZ2VzeXMgRVRSWDJVU0IgKi8KIAl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgyRjkpIH0sIC8qIFByb2N5b24gQVZTICovCiAJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4MzQxKSB9LCAvKiBTaWVtZW5zIE1DMzVQVSBHUFJTIE1vZGVtICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvY3lwcmVzc19tOC5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2N5cHJlc3NfbTguYwppbmRleCA5ODdlOWJmLi5kOTkwNmViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvY3lwcmVzc19tOC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9jeXByZXNzX204LmMKQEAgLTM1LDcgKzM1LDcgQEAKICAqCiAgKiAgTG9ubmllIE1lbmRleiA8ZGlnbm9tZUBnbWFpbC5jb20+CiAgKiAgMDQtMTAtMjAwNAotICoJRHJpdmVyIG1vZGlmaWVkIHRvIHN1cHBvcnQgZHluYW1pYyBsaW5lIHNldHRpbmdzLiAgVmFyaW91cyBpbXByb3ZtZW50cworICoJRHJpdmVyIG1vZGlmaWVkIHRvIHN1cHBvcnQgZHluYW1pYyBsaW5lIHNldHRpbmdzLiAgVmFyaW91cyBpbXByb3ZlbWVudHMKICAqICAgICAgYW5kIGZlYXR1cmVzLgogICoKICAqICBOZWlsIFdoZWxjaGVsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvZnRkaV9zaW8uYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jCmluZGV4IDY1OTY3YjMuLmE5NzNjN2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jCkBAIC0xNyw3ICsxNyw3IEBACiAgKiBTZWUgRG9jdW1lbnRhdGlvbi91c2IvdXNiLXNlcmlhbC50eHQgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gdXNpbmcgdGhpcwogICogZHJpdmVyCiAgKgotICogU2VlIGh0dHA6Ly9mdGRpLXVzYi1zaW8uc291cmNlZm9yZ2UubmV0IGZvciB1cHRvIGRhdGUgdGVzdGluZyBpbmZvCisgKiBTZWUgaHR0cDovL2Z0ZGktdXNiLXNpby5zb3VyY2Vmb3JnZS5uZXQgZm9yIHVwIHRvIGRhdGUgdGVzdGluZyBpbmZvCiAgKglhbmQgZXh0cmEgZG9jdW1lbnRhdGlvbgogICoKICAqIENoYW5nZSBlbnRyaWVzIGZyb20gMjAwNCBhbmQgZWFybGllciBjYW4gYmUgZm91bmQgaW4gdmVyc2lvbnMgb2YgdGhpcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2lvX2VkZ2Vwb3J0LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuYwppbmRleCBmMWFlZGZhLi5hYmYwOTViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuYwpAQCAtMTk4MSw3ICsxOTgxLDcgQEAKIAlpZiAoY29kZSA9PSBJT1NQX1NUQVRVU19PUEVOX1JTUCkgewogCQllZGdlX3BvcnQtPnR4Q3JlZGl0cyA9IEdFVF9UWF9CVUZGRVJfU0laRShieXRlMyk7CiAJCWVkZ2VfcG9ydC0+bWF4VHhDcmVkaXRzID0gZWRnZV9wb3J0LT50eENyZWRpdHM7Ci0JCWRiZygiJXMgLSBQb3J0ICV1IE9wZW4gUmVzcG9uc2UgSW5pdGFsIE1TUiA9ICUwMnggVHhCdWZmZXJTaXplID0gJWQiLCBfX2Z1bmNfXywgZWRnZV9zZXJpYWwtPnJ4UG9ydCwgYnl0ZTIsIGVkZ2VfcG9ydC0+dHhDcmVkaXRzKTsKKwkJZGJnKCIlcyAtIFBvcnQgJXUgT3BlbiBSZXNwb25zZSBJbml0aWFsIE1TUiA9ICUwMnggVHhCdWZmZXJTaXplID0gJWQiLCBfX2Z1bmNfXywgZWRnZV9zZXJpYWwtPnJ4UG9ydCwgYnl0ZTIsIGVkZ2VfcG9ydC0+dHhDcmVkaXRzKTsKIAkJaGFuZGxlX25ld19tc3IoZWRnZV9wb3J0LCBieXRlMik7CiAKIAkJLyogc2VuZCB0aGUgY3VycmVudCBsaW5lIHNldHRpbmdzIHRvIHRoZSBwb3J0IHNvIHdlIGFyZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2lvX2VkZ2Vwb3J0LmggYi9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuaAppbmRleCBkY2VkN2VjLi5hZDljMWQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuaAorKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuaApAQCAtNjgsNyArNjgsNyBAQAogI2RlZmluZSBQUk9DX1NFVF9DT01fRU5UUlkJCTIKIAogCi0vKiBUaGUgZm9sbG93aW5nIHN0dXJjdHVyZSBpcyBwYXNzZWQgdG8gdGhlIHdyaXRlICovCisvKiBUaGUgZm9sbG93aW5nIHN0cnVjdHVyZSBpcyBwYXNzZWQgdG8gdGhlIHdyaXRlICovCiBzdHJ1Y3QgcHJvY1dyaXRlIHsKIAlpbnQJQ29tbWFuZDsKIAl1bmlvbiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fdGkuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pb190aS5jCmluZGV4IGQ4NDM0OTEuLjBhYWMwMGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9pb190aS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pb190aS5jCkBAIC00MzMsNyArNDMzLDcgQEAKIAogCS8qIFdlIGNhbiBvbmx5IHNlbmQgYSBtYXhpbXVtIG9mIDEgYWxpZ25lZCBieXRlIHBhZ2UgYXQgYSB0aW1lICovCiAKLQkvKiBjYWx1bGF0ZSB0aGUgbnVtYmVyIG9mIGJ5dGVzIGxlZnQgaW4gdGhlIGZpcnN0IHBhZ2UgKi8KKwkvKiBjYWxjdWxhdGUgdGhlIG51bWJlciBvZiBieXRlcyBsZWZ0IGluIHRoZSBmaXJzdCBwYWdlICovCiAJd3JpdGVfbGVuZ3RoID0gRVBST01fUEFHRV9TSVpFIC0KIAkJCQkoc3RhcnRfYWRkcmVzcyAmIChFUFJPTV9QQUdFX1NJWkUgLSAxKSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vcHRpY29uLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvb3B0aWNvbi5jCmluZGV4IGExZGQ0ZDQuLjFiNTYzM2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vcHRpY29uLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL29wdGljb24uYwpAQCAtMTE2LDcgKzExNiw3IEBACiAJCX0gZWxzZSB7CiAJCQlpZiAoKGRhdGFbMF0gPT0gMHgwMCkgJiYgKGRhdGFbMV0gPT0gMHgwMSkpIHsKIAkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwotCQkJCS8qIENUUyBzdGF0dXMgaW5mb21hdGlvbiBwYWNrYWdlICovCisJCQkJLyogQ1RTIHN0YXR1cyBpbmZvcm1hdGlvbiBwYWNrYWdlICovCiAJCQkJaWYgKGRhdGFbMl0gPT0gMHgwMCkKIAkJCQkJcHJpdi0+Y3RzID0gZmFsc2U7CiAJCQkJZWxzZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc3RvcmFnZS9lbmVfdWI2MjUwLmMgYi9kcml2ZXJzL3VzYi9zdG9yYWdlL2VuZV91YjYyNTAuYwppbmRleCAwOGUwMzc0Li4wZTVhYWZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zdG9yYWdlL2VuZV91YjYyNTAuYworKysgYi9kcml2ZXJzL3VzYi9zdG9yYWdlL2VuZV91YjYyNTAuYwpAQCAtNTYyLDcgKzU2Miw3IEBACiAKIAlyZXN1bHQgPSBlbmVfc2VuZF9zY3NpX2NtZCh1cywgRkRJUl9SRUFELCBOVUxMLCAwKTsKIAlpZiAocmVzdWx0ICE9IFVTQl9TVE9SX1hGRVJfR09PRCkgewotCQlVU19ERUJVR1AoIkV4ZWN0aW9uIFNEIEluaXQgQ29kZSBGYWlsICEhXG4iKTsKKwkJVVNfREVCVUdQKCJFeGVjdXRpb24gU0QgSW5pdCBDb2RlIEZhaWwgISFcbiIpOwogCQlyZXR1cm4gVVNCX1NUT1JfVFJBTlNQT1JUX0VSUk9SOwogCX0KIApAQCAtNTgxLDcgKzU4MSw3IEBACiAKIAlyZXN1bHQgPSBlbmVfc2VuZF9zY3NpX2NtZCh1cywgRkRJUl9SRUFELCAmYnVmLCAwKTsKIAlpZiAocmVzdWx0ICE9IFVTQl9TVE9SX1hGRVJfR09PRCkgewotCQlVU19ERUJVR1AoIkV4ZWN0aW9uIFNEIEluaXQgQ29kZSBGYWlsICEhXG4iKTsKKwkJVVNfREVCVUdQKCJFeGVjdXRpb24gU0QgSW5pdCBDb2RlIEZhaWwgISFcbiIpOwogCQlyZXR1cm4gVVNCX1NUT1JfVFJBTlNQT1JUX0VSUk9SOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc3RvcmFnZS9pc2QyMDAuYyBiL2RyaXZlcnMvdXNiL3N0b3JhZ2UvaXNkMjAwLmMKaW5kZXggNmI5OTgyYy4uMDllNTJiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc3RvcmFnZS9pc2QyMDAuYworKysgYi9kcml2ZXJzL3VzYi9zdG9yYWdlL2lzZDIwMC5jCkBAIC0xNTEwLDcgKzE1MTAsNyBAQAogICogUHJvdG9jb2wgYW5kIFRyYW5zcG9ydCBmb3IgdGhlIElTRDIwMCBBU0lDCiAgKgogICogVGhpcyBwcm90b2NvbCBhbmQgdHJhbnNwb3J0IGFyZSBmb3IgQVRBIGRldmljZXMgY29ubmVjdGVkIHRvIGFuIElTRDIwMAotICogQVNJQy4gIEFuIEFUQVBJIGRldmljZSB0aGF0IGlzIGNvbmVjdGVkIGFzIGEgc2xhdmUgZGV2aWNlIHdpbGwgYmUKKyAqIEFTSUMuICBBbiBBVEFQSSBkZXZpY2UgdGhhdCBpcyBjb25uZWN0ZWQgYXMgYSBzbGF2ZSBkZXZpY2Ugd2lsbCBiZQogICogZGV0ZWN0ZWQgaW4gdGhlIGRyaXZlciBpbml0aWFsaXphdGlvbiBmdW5jdGlvbiBhbmQgdGhlIHByb3RvY29sIHdpbGwKICAqIGJlIGNoYW5nZWQgdG8gYW4gQVRBUEkgcHJvdG9jb2wgKFRyYW5zcGFyZW50IFNDU0kpLgogICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3N0b3JhZ2Uvc2NzaWdsdWUuYyBiL2RyaXZlcnMvdXNiL3N0b3JhZ2Uvc2NzaWdsdWUuYwppbmRleCA2ODllZTFmLi4xM2I4YmNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zdG9yYWdlL3Njc2lnbHVlLmMKKysrIGIvZHJpdmVycy91c2Ivc3RvcmFnZS9zY3NpZ2x1ZS5jCkBAIC0xMjMsNyArMTIzLDcgQEAKIHsKIAlzdHJ1Y3QgdXNfZGF0YSAqdXMgPSBob3N0X3RvX3VzKHNkZXYtPmhvc3QpOwogCi0JLyogTWFueSBkZXZpY2VzIGhhdmUgdHJvdWJsZSB0cmFuc2ZlcmluZyBtb3JlIHRoYW4gMzJLQiBhdCBhIHRpbWUsCisJLyogTWFueSBkZXZpY2VzIGhhdmUgdHJvdWJsZSB0cmFuc2ZlcnJpbmcgbW9yZSB0aGFuIDMyS0IgYXQgYSB0aW1lLAogCSAqIHdoaWxlIG90aGVycyBoYXZlIHRyb3VibGUgd2l0aCBtb3JlIHRoYW4gNjRLLiBBdCB0aGlzIHRpbWUgd2UKIAkgKiBhcmUgbGltaXRpbmcgYm90aCB0byAzMksgKDY0IHNlY3RvcmVzKS4KIAkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3N0b3JhZ2Uvc2h1dHRsZV91c2JhdC5jIGIvZHJpdmVycy91c2Ivc3RvcmFnZS9zaHV0dGxlX3VzYmF0LmMKaW5kZXggYmQzZjQxNS4uMGIwMDA5MSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc3RvcmFnZS9zaHV0dGxlX3VzYmF0LmMKKysrIGIvZHJpdmVycy91c2Ivc3RvcmFnZS9zaHV0dGxlX3VzYmF0LmMKQEAgLTM0MCw3ICszNDAsNyBAQAogfQogCiAvKgotICogU3RvcmVzIGNyaXRpY2FsIGluZm9ybWF0aW9uIGluIGludGVybmFsIHJlZ2lzdGVycyBpbiBwcmVwYXJ0aW9uIGZvciB0aGUgZXhlY3V0aW9uCisgKiBTdG9yZXMgY3JpdGljYWwgaW5mb3JtYXRpb24gaW4gaW50ZXJuYWwgcmVnaXN0ZXJzIGluIHByZXBhcmF0aW9uIGZvciB0aGUgZXhlY3V0aW9uCiAgKiBvZiBhIGNvbmRpdGlvbmFsIHVzYmF0X3JlYWRfYmxvY2tzIG9yIHVzYmF0X3dyaXRlX2Jsb2NrcyBjYWxsLgogICovCiBzdGF0aWMgaW50IHVzYmF0X3NldF9zaHV0dGxlX2ZlYXR1cmVzKHN0cnVjdCB1c19kYXRhICp1cywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL2NyeXB0by5jIGIvZHJpdmVycy91c2Ivd3VzYmNvcmUvY3J5cHRvLmMKaW5kZXggODI3Yzg3Zi4uN2U0YmY5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvY3J5cHRvLmMKKysrIGIvZHJpdmVycy91c2Ivd3VzYmNvcmUvY3J5cHRvLmMKQEAgLTE4MCw3ICsxODAsNyBAQAogICogICAgIHVzaW5nIHRoZSAxNCBieXRlcyBvZiBAYSB0byBmaWxsIHVwCiAgKiAgICAgYjEue21hY19oZWFkZXIsZTAsc2VjdXJpdHlfcmVzZXJ2ZWQscGFkZGluZ30uCiAgKgotICogTk9URTogVGhlIGRlZmluaXRvbiBvZiBsKGEpIGluIFdVU0IxLjBbNi41XSB2cyB0aGUgZGVmaW5pdGlvbiBvZgorICogTk9URTogVGhlIGRlZmluaXRpb24gb2YgbChhKSBpbiBXVVNCMS4wWzYuNV0gdnMgdGhlIGRlZmluaXRpb24gb2YKICAqICAgICAgIGwobSkgaXMgb3J0aG9nb25hbCwgdGhleSBiZWFyIG5vIHJlbGF0aW9uc2hpcCwgc28gaXQgaXMgbm90CiAgKiAgICAgICBpbiBjb25mbGljdCB3aXRoIHRoZSBwYXJhbWV0ZXIncyByZWxhdGlvbiB0aGF0CiAgKiAgICAgICBXVVNCMS4wWzYuNC4yXSkgZGVmaW5lcy4KQEAgLTI3Miw3ICsyNzIsNyBAQAogCiAJLyogTm93IHdlIGNyeXB0IHRoZSBNSUMgVGFnICgqaXYpIHdpdGggQXggLS0gdmFsdWVzIHBlciBXVVNCMS4wWzYuNV0KIAkgKiBUaGUgcHJvY2VkdXJlIGlzIHRvIEFFUyBjcnlwdCB0aGUgQTAgYmxvY2sgYW5kIFhPUiB0aGUgTUlDCi0JICogVGFnIGFnYWlucyBpdDsgd2Ugb25seSBkbyB0aGUgZmlyc3QgOCBieXRlcyBhbmQgcGxhY2UgaXQKKwkgKiBUYWcgYWdhaW5zdCBpdDsgd2Ugb25seSBkbyB0aGUgZmlyc3QgOCBieXRlcyBhbmQgcGxhY2UgaXQKIAkgKiBkaXJlY3RseSBpbiB0aGUgZGVzdGluYXRpb24gYnVmZmVyLgogCSAqCiAJICogUE9TIENyeXB0byBBUEk6IHNpemUgaXMgYXNzdW1lZCB0byBiZSBBRVMncyBibG9jayBzaXplLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvcmVzZXJ2YXRpb24uYyBiL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL3Jlc2VydmF0aW9uLmMKaW5kZXggNGVkOTczNi4uNmY0ZmFmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvcmVzZXJ2YXRpb24uYworKysgYi9kcml2ZXJzL3VzYi93dXNiY29yZS9yZXNlcnZhdGlvbi5jCkBAIC03MSw3ICs3MSw3IEBACiAKIC8qKgogICogd3VzYmhjX3Jzdl9lc3RhYmxpc2ggLSBlc3RhYmxpc2ggYSByZXNlcnZhdGlvbiBmb3IgdGhlIGNsdXN0ZXIKLSAqIEB3dXNiaGM6IHRoZSBXVVNCIEhDIHJlcXVlc3RpbmcgYSBiYW5kd2l0aCByZXNlcnZhdGlvbgorICogQHd1c2JoYzogdGhlIFdVU0IgSEMgcmVxdWVzdGluZyBhIGJhbmR3aWR0aCByZXNlcnZhdGlvbgogICovCiBpbnQgd3VzYmhjX3Jzdl9lc3RhYmxpc2goc3RydWN0IHd1c2JoYyAqd3VzYmhjKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvcmguYyBiL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL3JoLmMKaW5kZXggYzE3NWI3My4uMzlkZTM5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvcmguYworKysgYi9kcml2ZXJzL3VzYi93dXNiY29yZS9yaC5jCkBAIC0xMzMsNyArMTMzLDcgQEAKICAqICAgICAgICAgICBiaWcgb2YgYSBwcm9ibGVtIFthbmQgd2UgY2FuJ3QgbWFrZSBpdCBhbiBzcGlubG9jawogICogICAgICAgICAgIGJlY2F1c2Ugb3RoZXIgcGFydHMgbmVlZCB0byB0YWtlIGl0IGFuZCBzbGVlcF0gLgogICoKLSAqICAgICAgICAgICBAdXNiX2hjZCBpcyByZWZjb3VudGVkLCBzbyBpdCB3b24ndCBkaXNzYXBlYXIgdW5kZXIgdXMKKyAqICAgICAgICAgICBAdXNiX2hjZCBpcyByZWZjb3VudGVkLCBzbyBpdCB3b24ndCBkaXNhcHBlYXIgdW5kZXIgdXMKICAqICAgICAgICAgICBhbmQgYmVmb3JlIGtpbGxpbmcgYSBob3N0LCB0aGUgcG9sbGluZyBvZiB0aGUgcm9vdCBodWIKICAqICAgICAgICAgICB3b3VsZCBiZSBzdG9wcGVkIGFueXdheS4KICAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvd2EtcnBpcGUuYyBiL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL3dhLXJwaXBlLmMKaW5kZXggOGNiOWQ4MC4uY2E4MDE3MSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvd2EtcnBpcGUuYworKysgYi9kcml2ZXJzL3VzYi93dXNiY29yZS93YS1ycGlwZS5jCkBAIC0yNCw3ICsyNCw3IEBACiAgKgogICogUlBJUEUKICAqCi0gKiAgIFRhcmdldHRlZCBhdCBkaWZmZXJlbnQgZG93bnN0cmVhbSBlbmRwb2ludHMKKyAqICAgVGFyZ2V0ZWQgYXQgZGlmZmVyZW50IGRvd25zdHJlYW0gZW5kcG9pbnRzCiAgKgogICogICBEZXNjcmlwdG9yOiB1c2UgdG8gY29uZmlnIHRoZSByZW1vdGUgcGlwZS4KICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi93dXNiY29yZS93YS14ZmVyLmMgYi9kcml2ZXJzL3VzYi93dXNiY29yZS93YS14ZmVyLmMKaW5kZXggODRiNzQ0Yy4uNmNjZDkzYSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvd2EteGZlci5jCisrKyBiL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL3dhLXhmZXIuYwpAQCAtNjEsNyArNjEsNyBAQAogICoKICAqICAgICBUd28gbWV0aG9kcyBpdCBjb3VsZCBiZSBkb25lOgogICoKLSAqICAgICAoYSkgc2V0IHVwIGEgdGltZXIgZXZlcnl0aW1lIGFuIHJwaXBlJ3MgdXNlIGNvdW50IGRyb3BzIHRvIDEKKyAqICAgICAoYSkgc2V0IHVwIGEgdGltZXIgZXZlcnkgdGltZSBhbiBycGlwZSdzIHVzZSBjb3VudCBkcm9wcyB0byAxCiAgKiAgICAgICAgICh3aGljaCBtZWFucyB1bnVzZWQpIG9yIHdoZW4gYSB0cmFuc2ZlciBlbmRzLiBSZXNldCB0aGUKICAqICAgICAgICAgdGltZXIgd2hlbiBhIHhmZXIgaXMgcXVldWVkLiBJZiB0aGUgdGltZXIgZXhwaXJlcywgcmVsZWFzZQogICogICAgICAgICB0aGUgcnBpcGUgW3NlZSBycGlwZV9lcF9kaXNhYmxlKCldLgpAQCAtMTQwLDcgKzE0MCw3IEBACiAKIAlzdHJ1Y3Qgd2FoYyAqd2E7CQkvKiBXaXJlIGFkYXB0ZXIgd2UgYXJlIHBsdWdnZWQgdG8gKi8KIAlzdHJ1Y3QgdXNiX2hvc3RfZW5kcG9pbnQgKmVwOwotCXN0cnVjdCB1cmIgKnVyYjsJCS8qIFVSQiB3ZSBhcmUgdHJhbnNmZXJpbmcgZm9yICovCisJc3RydWN0IHVyYiAqdXJiOwkJLyogVVJCIHdlIGFyZSB0cmFuc2ZlcnJpbmcgZm9yICovCiAJc3RydWN0IHdhX3NlZyAqKnNlZzsJCS8qIHRyYW5zZmVyIHNlZ21lbnRzICovCiAJdTggc2Vncywgc2Vnc19zdWJtaXR0ZWQsIHNlZ3NfZG9uZTsKIAl1bnNpZ25lZCBpc19pbmJvdW5kOjE7CkBAIC0xNjEsNyArMTYxLDcgQEAKIH0KIAogLyoKLSAqIERlc3RvcnkgYSB0cmFuc2ZlciBzdHJ1Y3R1cmUKKyAqIERlc3Ryb3kgYSB0cmFuc2ZlciBzdHJ1Y3R1cmUKICAqCiAgKiBOb3RlIHRoYXQgdGhlIHhmZXItPnNlZ1tpbmRleF0gdGhpbmdpZXMgZm9sbG93IHRoZSBVUkIgbGlmZSBjeWNsZSwKICAqIHNvIHdlIG5lZWQgdG8gcHV0IHRoZW0sIG5vdCBmcmVlIHRoZW0uCkBAIC00OTQsNyArNDk0LDcgQEAKICAqIGZ1bmN0aW9uIGRvZXMgYWxtb3N0IHRoZSBzYW1lIHRoaW5nIGFuZCB0aGV5IHdvcmsgY2xvc2VseQogICogdG9nZXRoZXIuCiAgKgotICogSWYgdGhlIHNlZyByZXF1ZXN0IGhhcyBmYWlsZWQgYnV0IHRoaXMgRFRPIHBoYXNlIGhhcyBzdWNlZWRlZCwKKyAqIElmIHRoZSBzZWcgcmVxdWVzdCBoYXMgZmFpbGVkIGJ1dCB0aGlzIERUTyBwaGFzZSBoYXMgc3VjY2VlZGVkLAogICogd2Ffc2VnX2NiKCkgaGFzIGFscmVhZHkgZmFpbGVkIHRoZSBzZWdtZW50IGFuZCBtb3ZlZCB0aGUKICAqIHN0YXR1cyB0byBXQV9TRUdfRVJST1IsIHNvIHRoaXMgd2lsbCBnbyB0aHJvdWdoICdjYXNlIDAnIGFuZAogICogZWZmZWN0aXZlbHkgZG8gbm90aGluZy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL3d1c2JoYy5oIGIvZHJpdmVycy91c2Ivd3VzYmNvcmUvd3VzYmhjLmgKaW5kZXggNmJkNDI2Yi4uM2EyZDA5MSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivd3VzYmNvcmUvd3VzYmhjLmgKKysrIGIvZHJpdmVycy91c2Ivd3VzYmNvcmUvd3VzYmhjLmgKQEAgLTIzMSw3ICsyMzEsNyBAQAogICoKICAqICAgIE1vc3Qgb2YgdGhlIHRpbWVzIHdoZW4geW91IG5lZWQgdG8gdXNlIGl0LCBpdCB3aWxsIGJlIG5vbi1OVUxMLAogICogICAgc28gdGhlcmUgaXMgbm8gcmVhbCBuZWVkIHRvIGNoZWNrIGZvciBpdCAod3VzYl9kZXYgd2lsbAotICogICAgZGlzc2FwZWFyIGJlZm9yZSB1c2JfZGV2KS4KKyAqICAgIGRpc2FwcGVhciBiZWZvcmUgdXNiX2RldikuCiAgKgogICogIC0gVGhlIGZvbGxvd2luZyBmaWVsZHMgbmVlZCB0byBiZSBmaWxsZWQgb3V0IGJlZm9yZSBjYWxsaW5nCiAgKiAgICB3dXNiaGNfY3JlYXRlKCk6IHBvcnRzX21heCwgbW1jaWVzX21heCwgbW1jaWVfe2FkZCxybX0uCmRpZmYgLS1naXQgYS9kcml2ZXJzL3V3Yi9kcml2ZXIuYyBiL2RyaXZlcnMvdXdiL2RyaXZlci5jCmluZGV4IDA4YmQ2ZGIuLjNlNTQ1NGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXdiL2RyaXZlci5jCisrKyBiL2RyaXZlcnMvdXdiL2RyaXZlci5jCkBAIC02MSw3ICs2MSw3IEBACiAKIAogLyoqCi0gKiBJZiBhIGJlYWNvbiBkaXNzYXBlYXJzIGZvciBsb25nZXIgdGhhbiB0aGlzLCB0aGVuIHdlIGNvbnNpZGVyIHRoZQorICogSWYgYSBiZWFjb24gZGlzYXBwZWFycyBmb3IgbG9uZ2VyIHRoYW4gdGhpcywgdGhlbiB3ZSBjb25zaWRlciB0aGUKICAqIGRldmljZSB3aG8gd2FzIHJlcHJlc2VudGVkIGJ5IHRoYXQgYmVhY29uIHRvIGJlIGdvbmUuCiAgKgogICogRUNNQS0zNjhbMTcuMi4zLCBsYXN0IHBhcmFdIGVzdGFibGlzaGVzIHRoYXQgYSBkZXZpY2UgbXVzdCBub3QKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXdiL2RycC5jIGIvZHJpdmVycy91d2IvZHJwLmMKaW5kZXggYThkODNlMi4uM2ZiY2Y3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy91d2IvZHJwLmMKKysrIGIvZHJpdmVycy91d2IvZHJwLmMKQEAgLTI3LDcgKzI3LDcgQEAKIAogLyogRFJQIENvbmZsaWN0IEFjdGlvbnMgKFtFQ01BLTM2OCAybmQgRWRpdGlvbl0gMTcuNC42KSAqLwogZW51bSB1d2JfZHJwX2NvbmZsaWN0X2FjdGlvbiB7Ci0JLyogUmVzZXJ2YXRpb24gaXMgbWFudGFpbmVkLCBubyBhY3Rpb24gbmVlZGVkICovCisJLyogUmVzZXJ2YXRpb24gaXMgbWFpbnRhaW5lZCwgbm8gYWN0aW9uIG5lZWRlZCAqLwogCVVXQl9EUlBfQ09ORkxJQ1RfTUFOVEFJTiA9IDAsCiAJCiAJLyogdGhlIGRldmljZSBzaGFsbCBub3QgdHJhbnNtaXQgZnJhbWVzIGluIGNvbmZsaWN0aW5nIE1BU3MgaW4KQEAgLTc0MSwxMiArNzQxLDEyIEBACiAgKiBEUlAgbm90aWZpY2F0aW9ucyBjYW4gb2NjdXIgZm9yIHRocmVlIGRpZmZlcmVudCByZWFzb25zOgogICoKICAqIC0gVVdCX0RSUF9OT1RJRl9EUlBfSUVfUkVDVkQ6IG9uZSBvciBtb3JlIERSUCBJRXMgd2l0aCB0aGUgUkMgYXMKLSAqICAgdGhlIHRhcmdldCBvciBzb3VyY2UgaGF2ZSBiZWVuIHJlY2lldmVkLgorICogICB0aGUgdGFyZ2V0IG9yIHNvdXJjZSBoYXZlIGJlZW4gcmVjZWl2ZWQuCiAgKgogICogICBUaGVzZSBEUlAgSUVzIGNvdWxkIGJlIG5ldyBvciBmb3IgYW4gZXhpc3RpbmcgcmVzZXJ2YXRpb24uCiAgKgogICogICBJZiB0aGUgRFJQIElFIGZvciBhbiBleGlzdGluZyByZXNlcnZhdGlvbiBjZWFzZXMgdG8gYmUgdG8KLSAqICAgcmVjaWV2ZWQgZm9yIGF0IGxlYXN0IG1NYXhMb3N0QmVhY29ucywgdGhlIHJlc2VydmF0aW9uIHNob3VsZCBiZQorICogICByZWNlaXZlZCBmb3IgYXQgbGVhc3QgbU1heExvc3RCZWFjb25zLCB0aGUgcmVzZXJ2YXRpb24gc2hvdWxkIGJlCiAgKiAgIGNvbnNpZGVyZWQgdG8gYmUgdGVybWluYXRlZC4gIE5vdGUgdGhhdCB0aGUgVEVSTUlOQVRFIHJlYXNvbiAoc2VlCiAgKiAgIGJlbG93KSBtYXkgbm90IGFsd2F5cyBiZSBzaWduYWxsZWQgKGUuZy4sIHRoZSByZW1vdGUgZGV2aWNlIGhhcwogICogICB0d28gb3IgbW9yZSByZXNlcnZhdGlvbnMgZXN0YWJsaXNoZWQgd2l0aCB0aGUgUkMpLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy91d2IvbGMtcmMuYyBiL2RyaXZlcnMvdXdiL2xjLXJjLmMKaW5kZXggYjAwOTFjNy4uYjQzOTVmNCAxMDA2NDQKLS0tIGEvZHJpdmVycy91d2IvbGMtcmMuYworKysgYi9kcml2ZXJzL3V3Yi9sYy1yYy5jCkBAIC0xNjgsNyArMTY4LDcgQEAKIAl9CiAKIAlpZiAodXdiX21hY19hZGRyX3Vuc2V0KCZhZGRyKSB8fCB1d2JfbWFjX2FkZHJfYmNhc3QoJmFkZHIpKSB7Ci0JCWFkZHIuZGF0YVswXSA9IDB4MDI7IC8qIGxvY2FsbHkgYWRtaW5zdGVyZWQgYW5kIHVuaWNhc3QgKi8KKwkJYWRkci5kYXRhWzBdID0gMHgwMjsgLyogbG9jYWxseSBhZG1pbmlzdGVyZWQgYW5kIHVuaWNhc3QgKi8KIAkJZ2V0X3JhbmRvbV9ieXRlcygmYWRkci5kYXRhWzFdLCBzaXplb2YoYWRkci5kYXRhKS0xKTsKIAogCQlyZXN1bHQgPSB1d2JfcmNfbWFjX2FkZHJfc2V0KHJjLCAmYWRkcik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3V3Yi9yZXNldC5jIGIvZHJpdmVycy91d2IvcmVzZXQuYwppbmRleCAyNzg0OTI5Li4zZGU2MzBiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3V3Yi9yZXNldC5jCisrKyBiL2RyaXZlcnMvdXdiL3Jlc2V0LmMKQEAgLTUyLDcgKzUyLDcgQEAKIAkiY2FuY2VsbGVkIiwKIAkiaW52YWxpZCBzdGF0ZSIsCiAJImludmFsaWQgc2l6ZSIsCi0JImFjayBub3QgcmVjaWV2ZWQiLAorCSJhY2sgbm90IHJlY2VpdmVkIiwKIAkibm8gbW9yZSBhc2llIG5vdGlmaWNhdGlvbiIsCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3V3Yi91bWMtZGV2LmMgYi9kcml2ZXJzL3V3Yi91bWMtZGV2LmMKaW5kZXggY2NkMjE4NC4uYjI5NDhlYyAxMDA2NDQKLS0tIGEvZHJpdmVycy91d2IvdW1jLWRldi5jCisrKyBiL2RyaXZlcnMvdXdiL3VtYy1kZXYuYwpAQCAtNzgsNyArNzgsNyBAQAogICogRmlyc3Qgd2UgdW5yZWdpc3RlciB0aGUgZGV2aWNlLCBtYWtlIHN1cmUgdGhlIGRyaXZlciBjYW4gZG8gaXQncwogICogcmVzb3VyY2UgcmVsZWFzZSB0aGluZyBhbmQgdGhlbiB3ZSB0cnkgdG8gcmVsZWFzZSBhbnkgbGVmdCBvdmVyCiAgKiByZXNvdXJjZXMuIFdlIHRha2UgYSByZWYgdG8gdGhlIGRldmljZSwgdG8gbWFrZSBzdXJlIGl0IGRvZXNuJ3QKLSAqIGRpc3NhcGVhciB1bmRlciBvdXIgZmVldC4KKyAqIGRpc2FwcGVhciB1bmRlciBvdXIgZmVldC4KICAqLwogdm9pZCB1bWNfZGV2aWNlX3VucmVnaXN0ZXIoc3RydWN0IHVtY19kZXYgKnVtYykKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYXRtZWxfbGNkZmIuYyBiL2RyaXZlcnMvdmlkZW8vYXRtZWxfbGNkZmIuYwppbmRleCBjY2VjZjk5Li40NDg0YzcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2F0bWVsX2xjZGZiLmMKKysrIGIvZHJpdmVycy92aWRlby9hdG1lbF9sY2RmYi5jCkBAIC02MzcsNyArNjM3LDcgQEAKICAqICAJbWFnbml0dWRlIHdoaWNoIG5lZWRzIHRvIGJlIHNjYWxlZCBpbiB0aGlzIGZ1bmN0aW9uIGZvciB0aGUgaGFyZHdhcmUuCiAgKglUaGluZ3MgdG8gdGFrZSBpbnRvIGNvbnNpZGVyYXRpb24gYXJlIGhvdyBtYW55IGNvbG9yIHJlZ2lzdGVycywgaWYKICAqCWFueSwgYXJlIHN1cHBvcnRlZCB3aXRoIHRoZSBjdXJyZW50IGNvbG9yIHZpc3VhbC4gV2l0aCB0cnVlY29sb3IgbW9kZQotICoJbm8gY29sb3IgcGFsZXR0ZXMgYXJlIHN1cHBvcnRlZC4gSGVyZSBhIHBzdWVkbyBwYWxldHRlIGlzIGNyZWF0ZWQKKyAqCW5vIGNvbG9yIHBhbGV0dGVzIGFyZSBzdXBwb3J0ZWQuIEhlcmUgYSBwc2V1ZG8gcGFsZXR0ZSBpcyBjcmVhdGVkCiAgKgl3aGljaCB3ZSBzdG9yZSB0aGUgdmFsdWUgaW4gcHNldWRvX3BhbGV0dGUgaW4gc3RydWN0IGZiX2luZm8uIEZvcgogICoJcHNldWRvY29sb3IgbW9kZSB3ZSBoYXZlIGEgbGltaXRlZCBjb2xvciBwYWxldHRlLiBUbyBkZWFsIHdpdGggdGhpcwogICoJd2UgY2FuIHByb2dyYW0gd2hhdCBjb2xvciBpcyBkaXNwbGF5ZWQgZm9yIGEgcGFydGljdWxhciBwaXhlbCB2YWx1ZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYXR5L2F0eWZiX2Jhc2UuYyBiL2RyaXZlcnMvdmlkZW8vYXR5L2F0eWZiX2Jhc2UuYwppbmRleCBkNDM3YjNkLi5lYmI4OTNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2F0eS9hdHlmYl9iYXNlLmMKKysrIGIvZHJpdmVycy92aWRlby9hdHkvYXR5ZmJfYmFzZS5jCkBAIC0zMTI0LDEyICszMTI0LDEyIEBACiAJCU0gPSBwbGxfcmVnc1syXTsKIAogCQkvKgotCQkgKiBQTEwgRmVlZGJhY2sgRGl2aWRlciBOIChEZXBlbmRhbnQgb24gQ0xPQ0tfQ05UTCk6CisJCSAqIFBMTCBGZWVkYmFjayBEaXZpZGVyIE4gKERlcGVuZGVudCBvbiBDTE9DS19DTlRMKToKIAkJICovCiAJCU4gPSBwbGxfcmVnc1s3ICsgKGNsb2NrX2NudGwgJiAzKV07CiAKIAkJLyoKLQkJICogUExMIFBvc3QgRGl2aWRlciBQIChEZXBlbmRhbnQgb24gQ0xPQ0tfQ05UTCk6CisJCSAqIFBMTCBQb3N0IERpdmlkZXIgUCAoRGVwZW5kZW50IG9uIENMT0NLX0NOVEwpOgogCQkgKi8KIAkJUCA9IDEgPDwgKHBsbF9yZWdzWzZdID4+ICgoY2xvY2tfY250bCAmIDMpIDw8IDEpKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9hdHkvbWFjaDY0X2N1cnNvci5jIGIvZHJpdmVycy92aWRlby9hdHkvbWFjaDY0X2N1cnNvci5jCmluZGV4IDJiYThiM2MuLjQ2ZjcyZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vYXR5L21hY2g2NF9jdXJzb3IuYworKysgYi9kcml2ZXJzL3ZpZGVvL2F0eS9tYWNoNjRfY3Vyc29yLmMKQEAgLTUxLDcgKzUxLDcgQEAKICAqIHRvIGEgbGFyZ2VyIG51bWJlciBhbmQgc2F0dXJhdGUgQ1VSX0hPUlpfUE9TTiB0byB6ZXJvLgogICoKICAqIGlmIFkgYmVjb21lcyBuZWdhdGl2ZSwgQ1VSX1ZFUlRfT0ZGU0VUIG11c3QgYmUgYWRqdXN0ZWQgdG8gYSBsYXJnZXIgbnVtYmVyLAotICogQ1VSX09GRlNFVCBtdXN0IGJlIGFkanVzdGVkIHRvIGEgcG9pbnQgdG8gdGhlIGFwcHJvcHJhaXRlIGxpbmUgaW4gdGhlIGN1cnNvcgorICogQ1VSX09GRlNFVCBtdXN0IGJlIGFkanVzdGVkIHRvIGEgcG9pbnQgdG8gdGhlIGFwcHJvcHJpYXRlIGxpbmUgaW4gdGhlIGN1cnNvcgogICogZGVmaW5pdGF0aW9uIGFuZCBDVVJfVkVSVF9QT1NOIG11c3QgYmUgc2F0dXJhdGVkIHRvIHplcm8uCiAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9hdTEyMDBmYi5jIGIvZHJpdmVycy92aWRlby9hdTEyMDBmYi5jCmluZGV4IDRlYTE4N2QuLjVkZmYzMmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vYXUxMjAwZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL2F1MTIwMGZiLmMKQEAgLTE1NzIsNyArMTU3Miw3IEBACiAJLyogQ29weSBtb25pdG9yIHNwZWNzIGZyb20gcGFuZWwgZGF0YSAqLwogCS8qIGZpeG1lOiB3ZSdyZSBzZXR0aW5nIHVwIExDRCBjb250cm9sbGVyIHdpbmRvd3MsIHNvIHRoZXNlIGRvbnQgZ2l2ZSBhCiAJZGFtbiBhcyB0byB3aGF0IHRoZSBtb25pdG9yIHNwZWNzIGFyZSAodGhlIHBhbmVsIGl0c2VsZiBkb2VzLCBidXQgdGhhdAotCWlzbnQgZG9uZSBoZXJlLi4uc28gbWF5YmUgbmVlZCBhIGdlbmVyaWMgY2F0Y2hhbGwgbW9uaXRvciBzZXR0aW5nPz8/ICovCisJaXNuJ3QgZG9uZSBoZXJlLi4uc28gbWF5YmUgbmVlZCBhIGdlbmVyaWMgY2F0Y2hhbGwgbW9uaXRvciBzZXR0aW5nPz8/ICovCiAJbWVtY3B5KCZmYmktPm1vbnNwZWNzLCAmcGFuZWwtPm1vbnNwZWNzLCBzaXplb2Yoc3RydWN0IGZiX21vbnNwZWNzKSk7CiAKIAkvKiBXZSBmaXJzdCB0cnkgdGhlIHVzZXIgbW9kZSBwYXNzZWQgaW4gYXJndW1lbnQuIElmIHRoYXQgZmFpbGVkLApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9iYWNrbGlnaHQvY29yZ2lfbGNkLmMgYi9kcml2ZXJzL3ZpZGVvL2JhY2tsaWdodC9jb3JnaV9sY2QuYwppbmRleCBhZjYwOTgzLi5jNjUzM2JhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2JhY2tsaWdodC9jb3JnaV9sY2QuYworKysgYi9kcml2ZXJzL3ZpZGVvL2JhY2tsaWdodC9jb3JnaV9sY2QuYwpAQCAtMTA5LDcgKzEwOSw3IEBACiAjZGVmaW5lIENPUkdJQkxfQkFUVExPVyAgICAgICAweDAyCiAKIC8qCi0gKiBUaGlzIGlzIG9ubHkgYSBwc3VlZG8gSTJDIGludGVyZmFjZS4gV2UgY2FuJ3QgdXNlIHRoZSBzdGFuZGFyZCBrZXJuZWwKKyAqIFRoaXMgaXMgb25seSBhIHBzZXVkbyBJMkMgaW50ZXJmYWNlLiBXZSBjYW4ndCB1c2UgdGhlIHN0YW5kYXJkIGtlcm5lbAogICogcm91dGluZXMgYXMgdGhlIGludGVyZmFjZSBpcyB3cml0ZSBvbmx5LiBXZSBqdXN0IGFzc3VtZSB0aGUgZGF0YSBpcyBhY2tlZC4uLgogICovCiBzdGF0aWMgdm9pZCBsY2R0Z19zc3BfaTJjX3NlbmQoc3RydWN0IGNvcmdpX2xjZCAqbGNkLCB1aW50OF90IGRhdGEpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2JhY2tsaWdodC9sb2NvbW9sY2QuYyBiL2RyaXZlcnMvdmlkZW8vYmFja2xpZ2h0L2xvY29tb2xjZC5jCmluZGV4IGJiY2EzMTIuLmJlMjBiNWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vYmFja2xpZ2h0L2xvY29tb2xjZC5jCisrKyBiL2RyaXZlcnMvdmlkZW8vYmFja2xpZ2h0L2xvY29tb2xjZC5jCkBAIC02LDcgKzYsNyBAQAogICogR1BMIHYyCiAgKgogICogVGhpcyBkcml2ZXIgYXNzdW1lcyBzaW5nbGUgQ1BVLiBUaGF0J3Mgb2theSwgYmVjYXVzZSBjb2xsaWUgaXMKLSAqIHNsaWdodGx5IG9sZCBoYXJkd2FyZSwgYW5kIG5vb25lIGlzIGdvaW5nIHRvIHJldHJvZml0IHNlY29uZCBDUFUgdG8KKyAqIHNsaWdodGx5IG9sZCBoYXJkd2FyZSwgYW5kIG5vIG9uZSBpcyBnb2luZyB0byByZXRyb2ZpdCBzZWNvbmQgQ1BVIHRvCiAgKiBvbGQgUERBLgogICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYmZpbi1scTAzNXExLWZiLmMgYi9kcml2ZXJzL3ZpZGVvL2JmaW4tbHEwMzVxMS1mYi5jCmluZGV4IGM4ZTFmMDQuLjIzYjZjNGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vYmZpbi1scTAzNXExLWZiLmMKKysrIGIvZHJpdmVycy92aWRlby9iZmluLWxxMDM1cTEtZmIuYwpAQCAtMTU0LDggKzE1NCwxMCBAQAogCiAJcmV0ID0gbHEwMzVxMV9jb250cm9sKHNwaSwgTFEwMzVfU0hVVF9DVEwsIExRMDM1X09OKTsKIAlyZXQgfD0gbHEwMzVxMV9jb250cm9sKHNwaSwgTFEwMzVfRFJJVkVSX09VVFBVVF9DVEwsIGN0bC0+bW9kZSk7Ci0JaWYgKHJldCkKKwlpZiAocmV0KSB7CisJCWtmcmVlKGN0bCk7CiAJCXJldHVybiByZXQ7CisJfQogCiAJc3BpX3NldF9kcnZkYXRhKHNwaSwgY3RsKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9iZmluX2FkdjczOTNmYi5oIGIvZHJpdmVycy92aWRlby9iZmluX2FkdjczOTNmYi5oCmluZGV4IDhjN2Y5ZTQuLmNkNTkxYjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vYmZpbl9hZHY3MzkzZmIuaAorKysgYi9kcml2ZXJzL3ZpZGVvL2JmaW5fYWR2NzM5M2ZiLmgKQEAgLTg3LDEyICs4NywxMiBAQAogCiBzdGF0aWMgY29uc3QgdTggaW5pdF9OVFNDW10gPSB7CiAJMHgwMCwgMHgxRSwJLyogUG93ZXIgdXAgYWxsIERBQ3MgYW5kIFBMTCAqLwotCTB4QzMsIDB4MjYsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QzUsIDB4MTIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QzIsIDB4NEEsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QzYsIDB4NUUsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QkQsIDB4MTksCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QkYsIDB4NDIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLworCTB4QzMsIDB4MjYsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QzUsIDB4MTIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QzIsIDB4NEEsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QzYsIDB4NUUsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QkQsIDB4MTksCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QkYsIDB4NDIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLwogCTB4OEMsIDB4MUYsCS8qIE5UU0MgU3ViY2FycmllciBGcmVxdWVuY3kgKi8KIAkweDhELCAweDdDLAkvKiBOVFNDIFN1YmNhcnJpZXIgRnJlcXVlbmN5ICovCiAJMHg4RSwgMHhGMCwJLyogTlRTQyBTdWJjYXJyaWVyIEZyZXF1ZW5jeSAqLwpAQCAtMTA5LDEyICsxMDksMTIgQEAKIAogc3RhdGljIGNvbnN0IHU4IGluaXRfUEFMW10gPSB7CiAJMHgwMCwgMHgxRSwJLyogUG93ZXIgdXAgYWxsIERBQ3MgYW5kIFBMTCAqLwotCTB4QzMsIDB4MjYsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QzUsIDB4MTIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QzIsIDB4NEEsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QzYsIDB4NUUsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QkQsIDB4MTksCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLwotCTB4QkYsIDB4NDIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJ0aW9uIG1hdHJpeCAqLworCTB4QzMsIDB4MjYsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QzUsIDB4MTIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QzIsIDB4NEEsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QzYsIDB4NUUsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QkQsIDB4MTksCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLworCTB4QkYsIDB4NDIsCS8qIFByb2dyYW0gUkdCLT5ZQ3JDYiBDb2xvciBTcGFjZSBjb252ZXJzaW9uIG1hdHJpeCAqLwogCTB4OEMsIDB4Q0IsCS8qIFBBTCBTdWJjYXJyaWVyIEZyZXF1ZW5jeSAqLwogCTB4OEQsIDB4OEEsCS8qIFBBTCBTdWJjYXJyaWVyIEZyZXF1ZW5jeSAqLwogCTB4OEUsIDB4MDksCS8qIFBBTCBTdWJjYXJyaWVyIEZyZXF1ZW5jeSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9jb25zb2xlL2ZiY29uLmMgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZmJjb24uYwppbmRleCBjNTgzOTM0Li44NzQ1NjM3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZmJjb24uYworKysgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZmJjb24uYwpAQCAtMzcwLDcgKzM3MCw2IEBACiB7CiAJc3RydWN0IGZiX2luZm8gKmluZm8gPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IGZiX2luZm8sIHF1ZXVlKTsKIAlzdHJ1Y3QgZmJjb25fb3BzICpvcHMgPSBpbmZvLT5mYmNvbl9wYXI7Ci0Jc3RydWN0IGRpc3BsYXkgKnA7CiAJc3RydWN0IHZjX2RhdGEgKnZjID0gTlVMTDsKIAlpbnQgYzsKIAlpbnQgbW9kZTsKQEAgLTM4Niw3ICszODUsNiBAQAogCQlyZXR1cm47CiAJfQogCi0JcCA9ICZmYl9kaXNwbGF5W3ZjLT52Y19udW1dOwogCWMgPSBzY3JfcmVhZHcoKHUxNiAqKSB2Yy0+dmNfcG9zKTsKIAltb2RlID0gKCFvcHMtPmN1cnNvcl9mbGFzaCB8fCBvcHMtPmN1cnNvcl9zdGF0ZS5lbmFibGUpID8KIAkJQ01fRVJBU0UgOiBDTV9EUkFXOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9jb25zb2xlL2ZvbnRfbWluaV80eDYuYyBiL2RyaXZlcnMvdmlkZW8vY29uc29sZS9mb250X21pbmlfNHg2LmMKaW5kZXggYTE5YTdmMy4uZmE2ZTY5OCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9jb25zb2xlL2ZvbnRfbWluaV80eDYuYworKysgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZm9udF9taW5pXzR4Ni5jCkBAIC0xLDUgKzEsNSBAQAogCi0vKiBIYW5kIGNvbXBvc2VkICJNaW5pc2N1bGUiIDR4NiBmb250LCB3aXRoIGJpbmFyeSBkYXRhIGdlbmVyYXRlZCB1c2luZworLyogSGFuZCBjb21wb3NlZCAiTWludXNjdWxlIiA0eDYgZm9udCwgd2l0aCBiaW5hcnkgZGF0YSBnZW5lcmF0ZWQgdXNpbmcKICAqIFBlcmwgc3R1Yi4KICAqCiAgKiBVc2UgJ3BlcmwgLXggbWluaV80eDYuYyA8IG1pbmlfNHg2LmMgPiBuZXdfdmVyc2lvbi5jJyB0byByZWdlbmVyYXRlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2RhOHh4LWZiLmMgYi9kcml2ZXJzL3ZpZGVvL2RhOHh4LWZiLmMKaW5kZXggOGQ2MWVmOS4uOGI3ZDQ3MyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9kYTh4eC1mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vZGE4eHgtZmIuYwpAQCAtNzYzLDcgKzc2Myw3IEBACiAKIAkvKgogCSAqIFNldCBmbGFnIHRvIDAgYW5kIHdhaXQgZm9yIGlzciB0byBzZXQgdG8gMS4gSXQgd291bGQgc2VlbSB0aGVyZSBpcyBhCi0JICogcmFjZSBjb25kaXRpb24gaGVyZSB3aGVyZSB0aGUgSVNSIGNvdWxkIGhhdmUgb2NjdXJlZCBqdXN0IGJlZm9yZSBvcgorCSAqIHJhY2UgY29uZGl0aW9uIGhlcmUgd2hlcmUgdGhlIElTUiBjb3VsZCBoYXZlIG9jY3VycmVkIGp1c3QgYmVmb3JlIG9yCiAJICoganVzdCBhZnRlciB0aGlzIHNldC4gQnV0IHNpbmNlIHdlIGFyZSBqdXN0IGNvYXJzZWx5IHdhaXRpbmcgZm9yCiAJICogYSBmcmFtZSB0byBjb21wbGV0ZSB0aGVuIHRoYXQncyBPSy4gaS5lLiBpZiB0aGUgZnJhbWUgY29tcGxldGVkCiAJICoganVzdCBiZWZvcmUgdGhpcyBjb2RlIGV4ZWN1dGVkIHRoZW4gd2UgaGF2ZSB0byB3YWl0IGFub3RoZXIgZnVsbApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9kaXNwbGF5L2Rpc3BsYXktc3lzZnMuYyBiL2RyaXZlcnMvdmlkZW8vZGlzcGxheS9kaXNwbGF5LXN5c2ZzLmMKaW5kZXggZjZhMDlhYi4uMGM2NDdkNyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9kaXNwbGF5L2Rpc3BsYXktc3lzZnMuYworKysgYi9kcml2ZXJzL3ZpZGVvL2Rpc3BsYXkvZGlzcGxheS1zeXNmcy5jCkBAIC0xODIsNyArMTgyLDcgQEAKIAltdXRleF9sb2NrKCZkZGV2LT5sb2NrKTsKIAlkZXZpY2VfdW5yZWdpc3RlcihkZGV2LT5kZXYpOwogCW11dGV4X3VubG9jaygmZGRldi0+bG9jayk7Ci0JLy8gTWFyayBkZXZpY2UgaW5kZXggYXMgYXZhbGlhYmxlCisJLy8gTWFyayBkZXZpY2UgaW5kZXggYXMgYXZhaWxhYmxlCiAJbXV0ZXhfbG9jaygmYWxsb2NhdGVkX2RzcF9sb2NrKTsKIAlpZHJfcmVtb3ZlKCZhbGxvY2F0ZWRfZHNwLCBkZGV2LT5pZHgpOwogCW11dGV4X3VubG9jaygmYWxsb2NhdGVkX2RzcF9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vZWZpZmIuYyBiL2RyaXZlcnMvdmlkZW8vZWZpZmIuYwppbmRleCA3MDQ3N2MyLi40ZWIzOGRiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2VmaWZiLmMKKysrIGIvZHJpdmVycy92aWRlby9lZmlmYi5jCkBAIC01Myw2ICs1Myw3IEBACiAJTV9NQl83XzEsCS8qIE1hY0Jvb2ssIDd0aCByZXYuICovCiAJTV9NQl9TUiwJLyogTWFjQm9vaywgMm5kIGdlbiwgKFNhbnRhIFJvc2EpICovCiAJTV9NQkEsCQkvKiBNYWNCb29rIEFpciAqLworCU1fTUJBXzMsCS8qIE1hY2Jvb2sgQWlyLCAzcmQgcmV2ICovCiAJTV9NQlAsCQkvKiBNYWNCb29rIFBybyAqLwogCU1fTUJQXzIsCS8qIE1hY0Jvb2sgUHJvIDJuZCBnZW4gKi8KIAlNX01CUF8yXzIsCS8qIE1hY0Jvb2sgUHJvIDIsMm5kIGdlbiAqLwpAQCAtNjQsNDMgKzY1LDU0IEBACiAJTV9NQlBfNl8xLAkvKiBNYWNCb29rIFBybywgNiwxdGggZ2VuICovCiAJTV9NQlBfNl8yLAkvKiBNYWNCb29rIFBybywgNiwydGggZ2VuICovCiAJTV9NQlBfN18xLAkvKiBNYWNCb29rIFBybywgNywxdGggZ2VuICovCisJTV9NQlBfOF8yLAkvKiBNYWNCb29rIFBybywgOCwybmQgZ2VuICovCiAJTV9VTktOT1dOCS8qIHBsYWNlaG9sZGVyICovCiB9OwogCisjZGVmaW5lIE9WRVJSSURFX05PTkUJMHgwCisjZGVmaW5lIE9WRVJSSURFX0JBU0UJMHgxCisjZGVmaW5lIE9WRVJSSURFX1NUUklERQkweDIKKyNkZWZpbmUgT1ZFUlJJREVfSEVJR0hUCTB4NAorI2RlZmluZSBPVkVSUklERV9XSURUSAkweDgKKwogc3RhdGljIHN0cnVjdCBlZmlmYl9kbWlfaW5mbyB7CiAJY2hhciAqb3B0bmFtZTsKIAl1bnNpZ25lZCBsb25nIGJhc2U7CiAJaW50IHN0cmlkZTsKIAlpbnQgd2lkdGg7CiAJaW50IGhlaWdodDsKKwlpbnQgZmxhZ3M7CiB9IGRtaV9saXN0W10gX19pbml0ZGF0YSA9IHsKLQlbTV9JMTddID0geyAiaTE3IiwgMHg4MDAxMDAwMCwgMTQ3MiAqIDQsIDE0NDAsIDkwMCB9LAotCVtNX0kyMF0gPSB7ICJpMjAiLCAweDgwMDEwMDAwLCAxNzI4ICogNCwgMTY4MCwgMTA1MCB9LCAvKiBndWVzcyAqLwotCVtNX0kyMF9TUl0gPSB7ICJpbWFjNyIsIDB4NDAwMTAwMDAsIDE3MjggKiA0LCAxNjgwLCAxMDUwIH0sCi0JW01fSTI0XSA9IHsgImkyNCIsIDB4ODAwMTAwMDAsIDIwNDggKiA0LCAxOTIwLCAxMjAwIH0sIC8qIGd1ZXNzICovCi0JW01fSTI0XzhfMV0gPSB7ICJpbWFjOCIsIDB4YzAwNjAwMDAsIDIwNDggKiA0LCAxOTIwLCAxMjAwIH0sCi0JW01fSTI0XzEwXzFdID0geyAiaW1hYzEwIiwgMHhjMDAxMDAwMCwgMjA0OCAqIDQsIDE5MjAsIDEwODAgfSwKLQlbTV9JMjdfMTFfMV0gPSB7ICJpbWFjMTEiLCAweGMwMDEwMDAwLCAyNTYwICogNCwgMjU2MCwgMTQ0MCB9LAotCVtNX01JTkldPSB7ICJtaW5pIiwgMHg4MDAwMDAwMCwgMjA0OCAqIDQsIDEwMjQsIDc2OCB9LAotCVtNX01JTklfM18xXSA9IHsgIm1pbmkzMSIsIDB4NDAwMTAwMDAsIDEwMjQgKiA0LCAxMDI0LCA3NjggfSwKLQlbTV9NSU5JXzRfMV0gPSB7ICJtaW5pNDEiLCAweGMwMDEwMDAwLCAyMDQ4ICogNCwgMTkyMCwgMTIwMCB9LAotCVtNX01CXSA9IHsgIm1hY2Jvb2siLCAweDgwMDAwMDAwLCAyMDQ4ICogNCwgMTI4MCwgODAwIH0sCi0JW01fTUJfNV8xXSA9IHsgIm1hY2Jvb2s1MSIsIDB4ODAwMTAwMDAsIDIwNDggKiA0LCAxMjgwLCA4MDAgfSwKLQlbTV9NQl82XzFdID0geyAibWFjYm9vazYxIiwgMHg4MDAxMDAwMCwgMjA0OCAqIDQsIDEyODAsIDgwMCB9LAotCVtNX01CXzdfMV0gPSB7ICJtYWNib29rNzEiLCAweDgwMDEwMDAwLCAyMDQ4ICogNCwgMTI4MCwgODAwIH0sCi0JW01fTUJBXSA9IHsgIm1iYSIsIDB4ODAwMDAwMDAsIDIwNDggKiA0LCAxMjgwLCA4MDAgfSwKLQlbTV9NQlBdID0geyAibWJwIiwgMHg4MDAxMDAwMCwgMTQ3MiAqIDQsIDE0NDAsIDkwMCB9LAotCVtNX01CUF8yXSA9IHsgIm1icDIiLCAwLCAwLCAwLCAwIH0sIC8qIHBsYWNlaG9sZGVyICovCi0JW01fTUJQXzJfMl0gPSB7ICJtYnAyMiIsIDB4ODAwMTAwMDAsIDE0NzIgKiA0LCAxNDQwLCA5MDAgfSwKLQlbTV9NQlBfU1JdID0geyAibWJwMyIsIDB4ODAwMzAwMDAsIDIwNDggKiA0LCAxNDQwLCA5MDAgfSwKLQlbTV9NQlBfNF0gPSB7ICJtYnA0IiwgMHhjMDA2MDAwMCwgMjA0OCAqIDQsIDE5MjAsIDEyMDAgfSwKLQlbTV9NQlBfNV8xXSA9IHsgIm1icDUxIiwgMHhjMDAxMDAwMCwgMjA0OCAqIDQsIDE0NDAsIDkwMCB9LAotCVtNX01CUF81XzJdID0geyAibWJwNTIiLCAweGMwMDEwMDAwLCAyMDQ4ICogNCwgMTkyMCwgMTIwMCB9LAotCVtNX01CUF81XzNdID0geyAibWJwNTMiLCAweGQwMDEwMDAwLCAyMDQ4ICogNCwgMTQ0MCwgOTAwIH0sCi0JW01fTUJQXzZfMV0gPSB7ICJtYnA2MSIsIDB4OTAwMzAwMDAsIDIwNDggKiA0LCAxOTIwLCAxMjAwIH0sCi0JW01fTUJQXzZfMl0gPSB7ICJtYnA2MiIsIDB4OTAwMzAwMDAsIDIwNDggKiA0LCAxNjgwLCAxMDUwIH0sCi0JW01fTUJQXzdfMV0gPSB7ICJtYnA3MSIsIDB4YzAwMTAwMDAsIDIwNDggKiA0LCAxMjgwLCA4MDAgfSwKLQlbTV9VTktOT1dOXSA9IHsgTlVMTCwgMCwgMCwgMCwgMCB9CisJW01fSTE3XSA9IHsgImkxNyIsIDB4ODAwMTAwMDAsIDE0NzIgKiA0LCAxNDQwLCA5MDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9JMjBdID0geyAiaTIwIiwgMHg4MDAxMDAwMCwgMTcyOCAqIDQsIDE2ODAsIDEwNTAsIE9WRVJSSURFX05PTkUgfSwgLyogZ3Vlc3MgKi8KKwlbTV9JMjBfU1JdID0geyAiaW1hYzciLCAweDQwMDEwMDAwLCAxNzI4ICogNCwgMTY4MCwgMTA1MCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX0kyNF0gPSB7ICJpMjQiLCAweDgwMDEwMDAwLCAyMDQ4ICogNCwgMTkyMCwgMTIwMCwgT1ZFUlJJREVfTk9ORSB9LCAvKiBndWVzcyAqLworCVtNX0kyNF84XzFdID0geyAiaW1hYzgiLCAweGMwMDYwMDAwLCAyMDQ4ICogNCwgMTkyMCwgMTIwMCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX0kyNF8xMF8xXSA9IHsgImltYWMxMCIsIDB4YzAwMTAwMDAsIDIwNDggKiA0LCAxOTIwLCAxMDgwLCBPVkVSUklERV9OT05FIH0sCisJW01fSTI3XzExXzFdID0geyAiaW1hYzExIiwgMHhjMDAxMDAwMCwgMjU2MCAqIDQsIDI1NjAsIDE0NDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NSU5JXT0geyAibWluaSIsIDB4ODAwMDAwMDAsIDIwNDggKiA0LCAxMDI0LCA3NjgsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NSU5JXzNfMV0gPSB7ICJtaW5pMzEiLCAweDQwMDEwMDAwLCAxMDI0ICogNCwgMTAyNCwgNzY4LCBPVkVSUklERV9OT05FIH0sCisJW01fTUlOSV80XzFdID0geyAibWluaTQxIiwgMHhjMDAxMDAwMCwgMjA0OCAqIDQsIDE5MjAsIDEyMDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NQl0gPSB7ICJtYWNib29rIiwgMHg4MDAwMDAwMCwgMjA0OCAqIDQsIDEyODAsIDgwMCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX01CXzVfMV0gPSB7ICJtYWNib29rNTEiLCAweDgwMDEwMDAwLCAyMDQ4ICogNCwgMTI4MCwgODAwLCBPVkVSUklERV9OT05FIH0sCisJW01fTUJfNl8xXSA9IHsgIm1hY2Jvb2s2MSIsIDB4ODAwMTAwMDAsIDIwNDggKiA0LCAxMjgwLCA4MDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NQl83XzFdID0geyAibWFjYm9vazcxIiwgMHg4MDAxMDAwMCwgMjA0OCAqIDQsIDEyODAsIDgwMCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX01CQV0gPSB7ICJtYmEiLCAweDgwMDAwMDAwLCAyMDQ4ICogNCwgMTI4MCwgODAwLCBPVkVSUklERV9OT05FIH0sCisJLyogMTEiIE1hY2Jvb2sgQWlyIDMsMSBwYXNzZXMgdGhlIHdyb25nIHN0cmlkZSAqLworCVtNX01CQV8zXSA9IHsgIm1iYTMiLCAwLCAyMDQ4ICogNCwgMCwgMCwgT1ZFUlJJREVfU1RSSURFIH0sCisJW01fTUJQXSA9IHsgIm1icCIsIDB4ODAwMTAwMDAsIDE0NzIgKiA0LCAxNDQwLCA5MDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NQlBfMl0gPSB7ICJtYnAyIiwgMCwgMCwgMCwgMCwgT1ZFUlJJREVfTk9ORSB9LCAvKiBwbGFjZWhvbGRlciAqLworCVtNX01CUF8yXzJdID0geyAibWJwMjIiLCAweDgwMDEwMDAwLCAxNDcyICogNCwgMTQ0MCwgOTAwLCBPVkVSUklERV9OT05FIH0sCisJW01fTUJQX1NSXSA9IHsgIm1icDMiLCAweDgwMDMwMDAwLCAyMDQ4ICogNCwgMTQ0MCwgOTAwLCBPVkVSUklERV9OT05FIH0sCisJW01fTUJQXzRdID0geyAibWJwNCIsIDB4YzAwNjAwMDAsIDIwNDggKiA0LCAxOTIwLCAxMjAwLCBPVkVSUklERV9OT05FIH0sCisJW01fTUJQXzVfMV0gPSB7ICJtYnA1MSIsIDB4YzAwMTAwMDAsIDIwNDggKiA0LCAxNDQwLCA5MDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NQlBfNV8yXSA9IHsgIm1icDUyIiwgMHhjMDAxMDAwMCwgMjA0OCAqIDQsIDE5MjAsIDEyMDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9NQlBfNV8zXSA9IHsgIm1icDUzIiwgMHhkMDAxMDAwMCwgMjA0OCAqIDQsIDE0NDAsIDkwMCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX01CUF82XzFdID0geyAibWJwNjEiLCAweDkwMDMwMDAwLCAyMDQ4ICogNCwgMTkyMCwgMTIwMCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX01CUF82XzJdID0geyAibWJwNjIiLCAweDkwMDMwMDAwLCAyMDQ4ICogNCwgMTY4MCwgMTA1MCwgT1ZFUlJJREVfTk9ORSB9LAorCVtNX01CUF83XzFdID0geyAibWJwNzEiLCAweGMwMDEwMDAwLCAyMDQ4ICogNCwgMTI4MCwgODAwLCBPVkVSUklERV9OT05FIH0sCisJW01fTUJQXzhfMl0gPSB7ICJtYnA4MiIsIDB4OTAwMTAwMDAsIDE0NzIgKiA0LCAxNDQwLCA5MDAsIE9WRVJSSURFX05PTkUgfSwKKwlbTV9VTktOT1dOXSA9IHsgTlVMTCwgMCwgMCwgMCwgMCwgT1ZFUlJJREVfTk9ORSB9CiB9OwogCiBzdGF0aWMgaW50IHNldF9zeXN0ZW0oY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgKmlkKTsKQEAgLTEzOCw2ICsxNTAsNyBAQAogCUVGSUZCX0RNSV9TWVNURU1fSUQoIkFwcGxlIEluYy4iLCAiTWFjQm9vazYsMSIsIE1fTUJfNl8xKSwKIAlFRklGQl9ETUlfU1lTVEVNX0lEKCJBcHBsZSBJbmMuIiwgIk1hY0Jvb2s3LDEiLCBNX01CXzdfMSksCiAJRUZJRkJfRE1JX1NZU1RFTV9JRCgiQXBwbGUgSW5jLiIsICJNYWNCb29rQWlyMSwxIiwgTV9NQkEpLAorCUVGSUZCX0RNSV9TWVNURU1fSUQoIkFwcGxlIEluYy4iLCAiTWFjQm9va0FpcjMsMSIsIE1fTUJBXzMpLAogCUVGSUZCX0RNSV9TWVNURU1fSUQoIkFwcGxlIENvbXB1dGVyLCBJbmMuIiwgIk1hY0Jvb2tQcm8xLDEiLCBNX01CUCksCiAJRUZJRkJfRE1JX1NZU1RFTV9JRCgiQXBwbGUgQ29tcHV0ZXIsIEluYy4iLCAiTWFjQm9va1BybzIsMSIsIE1fTUJQXzIpLAogCUVGSUZCX0RNSV9TWVNURU1fSUQoIkFwcGxlIENvbXB1dGVyLCBJbmMuIiwgIk1hY0Jvb2tQcm8yLDIiLCBNX01CUF8yXzIpLApAQCAtMTUxLDE5ICsxNjQsMjYgQEAKIAlFRklGQl9ETUlfU1lTVEVNX0lEKCJBcHBsZSBJbmMuIiwgIk1hY0Jvb2tQcm82LDEiLCBNX01CUF82XzEpLAogCUVGSUZCX0RNSV9TWVNURU1fSUQoIkFwcGxlIEluYy4iLCAiTWFjQm9va1BybzYsMiIsIE1fTUJQXzZfMiksCiAJRUZJRkJfRE1JX1NZU1RFTV9JRCgiQXBwbGUgSW5jLiIsICJNYWNCb29rUHJvNywxIiwgTV9NQlBfN18xKSwKKwlFRklGQl9ETUlfU1lTVEVNX0lEKCJBcHBsZSBJbmMuIiwgIk1hY0Jvb2tQcm84LDIiLCBNX01CUF84XzIpLAogCXt9LAogfTsKIAorI2RlZmluZSBjaG9vc2VfdmFsdWUoZG1pdmFsdWUsIGZ3dmFsdWUsIGZpZWxkLCBmbGFncykgKHsJXAorCQl0eXBlb2YoZnd2YWx1ZSkgX3JldF8gPSBmd3ZhbHVlOwkJXAorCQlpZiAoKGZsYWdzKSAmIChmaWVsZCkpCQkJCVwKKwkJCV9yZXRfID0gZG1pdmFsdWU7CQkJXAorCQllbHNlIGlmICgoZnd2YWx1ZSkgPT0gMCkJCQlcCisJCQlfcmV0XyA9IGRtaXZhbHVlOwkJCVwKKwkJX3JldF87CQkJCQkJXAorCX0pCisKIHN0YXRpYyBpbnQgc2V0X3N5c3RlbShjb25zdCBzdHJ1Y3QgZG1pX3N5c3RlbV9pZCAqaWQpCiB7CiAJc3RydWN0IGVmaWZiX2RtaV9pbmZvICppbmZvID0gaWQtPmRyaXZlcl9kYXRhOwotCWlmIChpbmZvLT5iYXNlID09IDApCi0JCXJldHVybiAwOwogCi0JcHJpbnRrKEtFUk5fSU5GTyAiZWZpZmI6IGRtaSBkZXRlY3RlZCAlcyAtIGZyYW1lYnVmZmVyIGF0ICVwICIKLQkJCSAiKCVkeCVkLCBzdHJpZGUgJWQpXG4iLCBpZC0+aWRlbnQsCi0JCQkgKHZvaWQgKilpbmZvLT5iYXNlLCBpbmZvLT53aWR0aCwgaW5mby0+aGVpZ2h0LAotCQkJIGluZm8tPnN0cmlkZSk7CisJaWYgKGluZm8tPmJhc2UgPT0gMCAmJiBpbmZvLT5oZWlnaHQgPT0gMCAmJiBpbmZvLT53aWR0aCA9PSAwCisJCQkmJiBpbmZvLT5zdHJpZGUgPT0gMCkKKwkJcmV0dXJuIDA7CiAKIAkvKiBUcnVzdCB0aGUgYm9vdGxvYWRlciBvdmVyIHRoZSBETUkgdGFibGVzICovCiAJaWYgKHNjcmVlbl9pbmZvLmxmYl9iYXNlID09IDApIHsKQEAgLTE3MSw0MCArMTkxLDQ3IEBACiAJCXN0cnVjdCBwY2lfZGV2ICpkZXYgPSBOVUxMOwogCQlpbnQgZm91bmRfYmFyID0gMDsKICNlbmRpZgotCQlzY3JlZW5faW5mby5sZmJfYmFzZSA9IGluZm8tPmJhc2U7CisJCWlmIChpbmZvLT5iYXNlKSB7CisJCQlzY3JlZW5faW5mby5sZmJfYmFzZSA9IGNob29zZV92YWx1ZShpbmZvLT5iYXNlLAorCQkJCXNjcmVlbl9pbmZvLmxmYl9iYXNlLCBPVkVSUklERV9CQVNFLAorCQkJCWluZm8tPmZsYWdzKTsKIAogI2lmIGRlZmluZWQoQ09ORklHX1BDSSkKLQkJLyogbWFrZSBzdXJlIHRoYXQgdGhlIGFkZHJlc3MgaW4gdGhlIHRhYmxlIGlzIGFjdHVhbGx5IG9uIGEKLQkJICogVkdBIGRldmljZSdzIFBDSSBCQVIgKi8KKwkJCS8qIG1ha2Ugc3VyZSB0aGF0IHRoZSBhZGRyZXNzIGluIHRoZSB0YWJsZSBpcyBhY3R1YWxseQorCQkJICogb24gYSBWR0EgZGV2aWNlJ3MgUENJIEJBUiAqLwogCi0JCWZvcl9lYWNoX3BjaV9kZXYoZGV2KSB7Ci0JCQlpbnQgaTsKLQkJCWlmICgoZGV2LT5jbGFzcyA+PiA4KSAhPSBQQ0lfQ0xBU1NfRElTUExBWV9WR0EpCi0JCQkJY29udGludWU7Ci0JCQlmb3IgKGkgPSAwOyBpIDwgREVWSUNFX0NPVU5UX1JFU09VUkNFOyBpKyspIHsKLQkJCQlyZXNvdXJjZV9zaXplX3Qgc3RhcnQsIGVuZDsKKwkJCWZvcl9lYWNoX3BjaV9kZXYoZGV2KSB7CisJCQkJaW50IGk7CisJCQkJaWYgKChkZXYtPmNsYXNzID4+IDgpICE9IFBDSV9DTEFTU19ESVNQTEFZX1ZHQSkKKwkJCQkJY29udGludWU7CisJCQkJZm9yIChpID0gMDsgaSA8IERFVklDRV9DT1VOVF9SRVNPVVJDRTsgaSsrKSB7CisJCQkJCXJlc291cmNlX3NpemVfdCBzdGFydCwgZW5kOwogCi0JCQkJc3RhcnQgPSBwY2lfcmVzb3VyY2Vfc3RhcnQoZGV2LCBpKTsKLQkJCQlpZiAoc3RhcnQgPT0gMCkKLQkJCQkJYnJlYWs7Ci0JCQkJZW5kID0gcGNpX3Jlc291cmNlX2VuZChkZXYsIGkpOwotCQkJCWlmIChzY3JlZW5faW5mby5sZmJfYmFzZSA+PSBzdGFydCAmJgotCQkJCQkJc2NyZWVuX2luZm8ubGZiX2Jhc2UgPCBlbmQpIHsKLQkJCQkJZm91bmRfYmFyID0gMTsKKwkJCQkJc3RhcnQgPSBwY2lfcmVzb3VyY2Vfc3RhcnQoZGV2LCBpKTsKKwkJCQkJaWYgKHN0YXJ0ID09IDApCisJCQkJCQlicmVhazsKKwkJCQkJZW5kID0gcGNpX3Jlc291cmNlX2VuZChkZXYsIGkpOworCQkJCQlpZiAoc2NyZWVuX2luZm8ubGZiX2Jhc2UgPj0gc3RhcnQgJiYKKwkJCQkJICAgIHNjcmVlbl9pbmZvLmxmYl9iYXNlIDwgZW5kKSB7CisJCQkJCQlmb3VuZF9iYXIgPSAxOworCQkJCQl9CiAJCQkJfQogCQkJfQotCQl9Ci0JCWlmICghZm91bmRfYmFyKQotCQkJc2NyZWVuX2luZm8ubGZiX2Jhc2UgPSAwOworCQkJaWYgKCFmb3VuZF9iYXIpCisJCQkJc2NyZWVuX2luZm8ubGZiX2Jhc2UgPSAwOwogI2VuZGlmCisJCX0KIAl9CiAJaWYgKHNjcmVlbl9pbmZvLmxmYl9iYXNlKSB7Ci0JCWlmIChzY3JlZW5faW5mby5sZmJfbGluZWxlbmd0aCA9PSAwKQotCQkJc2NyZWVuX2luZm8ubGZiX2xpbmVsZW5ndGggPSBpbmZvLT5zdHJpZGU7Ci0JCWlmIChzY3JlZW5faW5mby5sZmJfd2lkdGggPT0gMCkKLQkJCXNjcmVlbl9pbmZvLmxmYl93aWR0aCA9IGluZm8tPndpZHRoOwotCQlpZiAoc2NyZWVuX2luZm8ubGZiX2hlaWdodCA9PSAwKQotCQkJc2NyZWVuX2luZm8ubGZiX2hlaWdodCA9IGluZm8tPmhlaWdodDsKKwkJc2NyZWVuX2luZm8ubGZiX2xpbmVsZW5ndGggPSBjaG9vc2VfdmFsdWUoaW5mby0+c3RyaWRlLAorCQkJc2NyZWVuX2luZm8ubGZiX2xpbmVsZW5ndGgsIE9WRVJSSURFX1NUUklERSwKKwkJCWluZm8tPmZsYWdzKTsKKwkJc2NyZWVuX2luZm8ubGZiX3dpZHRoID0gY2hvb3NlX3ZhbHVlKGluZm8tPndpZHRoLAorCQkJc2NyZWVuX2luZm8ubGZiX3dpZHRoLCBPVkVSUklERV9XSURUSCwKKwkJCWluZm8tPmZsYWdzKTsKKwkJc2NyZWVuX2luZm8ubGZiX2hlaWdodCA9IGNob29zZV92YWx1ZShpbmZvLT5oZWlnaHQsCisJCQlzY3JlZW5faW5mby5sZmJfaGVpZ2h0LCBPVkVSUklERV9IRUlHSFQsCisJCQlpbmZvLT5mbGFncyk7CiAJCWlmIChzY3JlZW5faW5mby5vcmlnX3ZpZGVvX2lzVkdBID09IDApCiAJCQlzY3JlZW5faW5mby5vcmlnX3ZpZGVvX2lzVkdBID0gVklERU9fVFlQRV9FRkk7CiAJfSBlbHNlIHsKQEAgLTIxNCw2ICsyNDEsMTMgQEAKIAkJc2NyZWVuX2luZm8ub3JpZ192aWRlb19pc1ZHQSA9IDA7CiAJCXJldHVybiAwOwogCX0KKworCXByaW50ayhLRVJOX0lORk8gImVmaWZiOiBkbWkgZGV0ZWN0ZWQgJXMgLSBmcmFtZWJ1ZmZlciBhdCAlcCAiCisJCQkgIiglZHglZCwgc3RyaWRlICVkKVxuIiwgaWQtPmlkZW50LAorCQkJICh2b2lkICopc2NyZWVuX2luZm8ubGZiX2Jhc2UsIHNjcmVlbl9pbmZvLmxmYl93aWR0aCwKKwkJCSBzY3JlZW5faW5mby5sZmJfaGVpZ2h0LCBzY3JlZW5faW5mby5sZmJfbGluZWxlbmd0aCk7CisKKwogCXJldHVybiAxOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2VwOTN4eC1mYi5jIGIvZHJpdmVycy92aWRlby9lcDkzeHgtZmIuYwppbmRleCBiMzU4ZDA0Li5jYmRiMWJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2VwOTN4eC1mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vZXA5M3h4LWZiLmMKQEAgLTQ1Niw3ICs0NTYsNyBAQAogCSAqIFRoZXJlIGlzIGEgYnVnIGluIHRoZSBlcDkzeHggZnJhbWVidWZmZXIgd2hpY2ggY2F1c2VzIHByb2JsZW1zCiAJICogaWYgYml0IDI3IG9mIHRoZSBwaHlzaWNhbCBhZGRyZXNzIGlzIHNldC4KIAkgKiBTZWU6IGh0dHA6Ly9tYXJjLmluZm8vP2w9bGludXgtYXJtLWtlcm5lbCZtPTExMDA2MTI0NTUwMjAwMCZ3PTIKLQkgKiBUaGVyZSBkb2VzIG5vdCBzZWVtIHRvIGJlIGFueSBvZmZpY2FsIGVycmF0YSBmb3IgdGhpcywgYnV0IEkKKwkgKiBUaGVyZSBkb2VzIG5vdCBzZWVtIHRvIGJlIGFueSBvZmZpY2lhbCBlcnJhdGEgZm9yIHRoaXMsIGJ1dCBJCiAJICogaGF2ZSBjb25maXJtZWQgdGhlIHByb2JsZW0gZXhpc3RzIG9uIG15IGhhcmR3YXJlIChlcDkzMTUpIGF0CiAJICogbGVhc3QuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2ZibWVtLmMgYi9kcml2ZXJzL3ZpZGVvL2ZibWVtLmMKaW5kZXggZTJiZjk1My4uZTBjMjI4NCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9mYm1lbS5jCisrKyBiL2RyaXZlcnMvdmlkZW8vZmJtZW0uYwpAQCAtMTUwNyw3ICsxNTA3LDcgQEAKIAkJCShwcmltYXJ5ICYmIGdlbl9hcGVyICYmIGdlbl9hcGVyLT5jb3VudCAmJgogCQkJIGdlbl9hcGVyLT5yYW5nZXNbMF0uYmFzZSA9PSBWR0FfRkJfUEhZUykpIHsKIAotCQkJcHJpbnRrKEtFUk5fRVJSICJmYjogY29uZmxpY3RpbmcgZmIgaHcgdXNhZ2UgIgorCQkJcHJpbnRrKEtFUk5fSU5GTyAiZmI6IGNvbmZsaWN0aW5nIGZiIGh3IHVzYWdlICIKIAkJCSAgICAgICAiJXMgdnMgJXMgLSByZW1vdmluZyBnZW5lcmljIGRyaXZlclxuIiwKIAkJCSAgICAgICBuYW1lLCByZWdpc3RlcmVkX2ZiW2ldLT5maXguaWQpOwogCQkJdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcihyZWdpc3RlcmVkX2ZiW2ldKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vZmJzeXNmcy5jIGIvZHJpdmVycy92aWRlby9mYnN5c2ZzLmMKaW5kZXggZjRhMzI3Ny4uMDQyNTFjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9mYnN5c2ZzLmMKKysrIGIvZHJpdmVycy92aWRlby9mYnN5c2ZzLmMKQEAgLTMzLDcgKzMzLDcgQEAKICAqIGZvciBkcml2ZXIgcHJpdmF0ZSBkYXRhIChpbmZvLT5wYXIpLiBpbmZvLT5wYXIgKGlmIGFueSkgd2lsbCBiZQogICogYWxpZ25lZCB0byBzaXplb2YobG9uZykuCiAgKgotICogUmV0dXJucyB0aGUgbmV3IHN0cnVjdHVyZSwgb3IgTlVMTCBpZiBhbiBlcnJvciBvY2N1cmVkLgorICogUmV0dXJucyB0aGUgbmV3IHN0cnVjdHVyZSwgb3IgTlVMTCBpZiBhbiBlcnJvciBvY2N1cnJlZC4KICAqCiAgKi8KIHN0cnVjdCBmYl9pbmZvICpmcmFtZWJ1ZmZlcl9hbGxvYyhzaXplX3Qgc2l6ZSwgc3RydWN0IGRldmljZSAqZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9mbTJmYi5jIGIvZHJpdmVycy92aWRlby9mbTJmYi5jCmluZGV4IDFiMGZlYjguLmQwNTMzYjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vZm0yZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL2ZtMmZiLmMKQEAgLTQ1LDcgKzQ1LDcgQEAKICAqCWJ1ZmZlciBuZWVkcyBhbiBhbW91bnQgb2YgbWVtb3J5IG9mIDEuNzY5LjQ3MiBieXRlcyB3aGljaAogICoJaXMgbmVhciB0byAyIE1CeXRlICh0aGUgYWxsb2NhdGVkIGFkZHJlc3Mgc3BhY2Ugb2YgWm9ycm8yKS4KICAqCVRoZSBtZW1vcnkgaXMgY2hhbm5lbCBpbnRlcmxlYXZlZC4gVGhhdCBtZWFucyBldmVyeSBjaGFubmVsCi0gKglvd25zIGZvdXIgVlJBTXMuIFVuZm9ydHVuYXRseSBtb3N0IEZyYW1lTWFzdGVycyBJSSBhcmUKKyAqCW93bnMgZm91ciBWUkFNcy4gVW5mb3J0dW5hdGVseSBtb3N0IEZyYW1lTWFzdGVycyBJSSBhcmUKICAqCW5vdCBhc3NlbWJsZWQgd2l0aCBtZW1vcnkgZm9yIHRoZSBhbHBoYSBjaGFubmVsLiBJbiB0aGlzCiAgKgljYXNlIGl0IGNvdWxkIGJlIHBvc3NpYmxlIHRvIGFkZCB0aGUgZnJhbWUgYnVmZmVyIGludG8gdGhlCiAgKglub3JtYWwgbWVtb3J5IHBvb2wuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2ZzbC1kaXUtZmIuYyBiL2RyaXZlcnMvdmlkZW8vZnNsLWRpdS1mYi5jCmluZGV4IDkwNDhmODcuLmJlZGY1YmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vZnNsLWRpdS1mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vZnNsLWRpdS1mYi5jCkBAIC04ODIsNyArODgyLDcgQEAKICAqIHdoaWNoIG5lZWRzIHRvIGJlIHNjYWxlZCBpbiB0aGlzIGZ1bmN0aW9uIGZvciB0aGUgaGFyZHdhcmUuIFRoaW5ncyB0byB0YWtlCiAgKiBpbnRvIGNvbnNpZGVyYXRpb24gYXJlIGhvdyBtYW55IGNvbG9yIHJlZ2lzdGVycywgaWYgYW55LCBhcmUgc3VwcG9ydGVkIHdpdGgKICAqIHRoZSBjdXJyZW50IGNvbG9yIHZpc3VhbC4gV2l0aCB0cnVlY29sb3IgbW9kZSBubyBjb2xvciBwYWxldHRlcyBhcmUKLSAqIHN1cHBvcnRlZC4gSGVyZSBhIHBzdWVkbyBwYWxldHRlIGlzIGNyZWF0ZWQgd2hpY2ggd2Ugc3RvcmUgdGhlIHZhbHVlIGluCisgKiBzdXBwb3J0ZWQuIEhlcmUgYSBwc2V1ZG8gcGFsZXR0ZSBpcyBjcmVhdGVkIHdoaWNoIHdlIHN0b3JlIHRoZSB2YWx1ZSBpbgogICogcHNldWRvX3BhbGV0dGUgaW4gc3RydWN0IGZiX2luZm8uIEZvciBwc2V1ZG9jb2xvciBtb2RlIHdlIGhhdmUgYSBsaW1pdGVkCiAgKiBjb2xvciBwYWxldHRlLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2diZWZiLmMgYi9kcml2ZXJzL3ZpZGVvL2diZWZiLmMKaW5kZXggOTMzODk5ZC4uN2U3YjdhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9nYmVmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vZ2JlZmIuYwpAQCAtNzIxLDcgKzcyMSw3IEBACiAKIAkgICBUaWxlcyBoYXZlIHRoZSBhZHZhbnRhZ2UgdGhhdCB0aGV5IGNhbiBiZSBhbGxvY2F0ZWQgaW5kaXZpZHVhbGx5IGluCiAJICAgbWVtb3J5LiBIb3dldmVyLCB0aGlzIG1hcHBpbmcgaXMgbm90IGxpbmVhciBhdCBhbGwsIHdoaWNoIGlzIG5vdAotCSAgIHJlYWxseSBjb252aWVuaWVudC4gSW4gb3JkZXIgdG8gc3VwcG9ydCBsaW5lYXIgYWRkcmVzc2luZywgdGhlIEdCRQorCSAgIHJlYWxseSBjb252ZW5pZW50LiBJbiBvcmRlciB0byBzdXBwb3J0IGxpbmVhciBhZGRyZXNzaW5nLCB0aGUgR0JFCiAJICAgRE1BIGhhcmR3YXJlIGlzIGZvb2xlZCBpbnRvIHRoaW5raW5nIHRoZSBzY3JlZW4gaXMgb25seSBvbmUgdGlsZQogCSAgIGxhcmdlIGFuZCBidXQgaGFzIGEgZ3JlYXRlciBoZWlnaHQsIHNvIHRoYXQgdGhlIERNQSB0cmFuc2ZlciBjb3ZlcnMKIAkgICB0aGUgc2FtZSByZWdpb24uCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2dlb2RlL2x4ZmIuaCBiL2RyaXZlcnMvdmlkZW8vZ2VvZGUvbHhmYi5oCmluZGV4IGJlOGNjYjQuLmNmY2Q4MDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vZ2VvZGUvbHhmYi5oCisrKyBiL2RyaXZlcnMvdmlkZW8vZ2VvZGUvbHhmYi5oCkBAIC0xMTcsNyArMTE3LDcgQEAKIH07CiAKICNkZWZpbmUgR1BfQkxUX1NUQVRVU19DRQkJKDEgPDwgNCkJLyogY21kIGJ1ZiBlbXB0eSAqLwotI2RlZmluZSBHUF9CTFRfU1RBVFVTX1BCCQkoMSA8PCAwKQkvKiBwcmltYXRpdmUgYnVzeSAqLworI2RlZmluZSBHUF9CTFRfU1RBVFVTX1BCCQkoMSA8PCAwKQkvKiBwcmltaXRpdmUgYnVzeSAqLwogCiAKIC8qIERpc3BsYXkgQ29udHJvbGxlciByZWdpc3RlcnMgKHRhYmxlIDYtNDcgZnJvbSB0aGUgZGF0YSBib29rKSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9pODEwL2k4MTBfYWNjZWwuYyBiL2RyaXZlcnMvdmlkZW8vaTgxMC9pODEwX2FjY2VsLmMKaW5kZXggZjViZWRlZS4uNzY3MmQyZSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9pODEwL2k4MTBfYWNjZWwuYworKysgYi9kcml2ZXJzL3ZpZGVvL2k4MTAvaTgxMF9hY2NlbC5jCkBAIC0xMTIsNyArMTEyLDcgQEAKICAqIEBwYXI6IHBvaW50ZXIgdG8gaTgxMGZiX3BhciBzdHJ1Y3R1cmUKICAqCiAgKiBERVNDUklQVElPTjoKLSAqIENoZWNrcy93YWl0cyBmb3Igc3VmZmljZW50IHNwYWNlIGluIHJpbmdidWZmZXIgb2Ygc2l6ZQorICogQ2hlY2tzL3dhaXRzIGZvciBzdWZmaWNpZW50IHNwYWNlIGluIHJpbmdidWZmZXIgb2Ygc2l6ZQogICogc3BhY2UuICBSZXR1cm5zIHRoZSB0YWlsIG9mIHRoZSBidWZmZXIKICAqLyAKIHN0YXRpYyBpbmxpbmUgdTMyIGJlZ2luX2lyaW5nKHN0cnVjdCBmYl9pbmZvICppbmZvLCB1MzIgc3BhY2UpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2t5cm8vU1RHNDAwME92ZXJsYXlEZXZpY2UuYyBiL2RyaXZlcnMvdmlkZW8va3lyby9TVEc0MDAwT3ZlcmxheURldmljZS5jCmluZGV4IGE4Yzk3MTMuLjBhZWVhYTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8va3lyby9TVEc0MDAwT3ZlcmxheURldmljZS5jCisrKyBiL2RyaXZlcnMvdmlkZW8va3lyby9TVEc0MDAwT3ZlcmxheURldmljZS5jCkBAIC00MTcsNyArNDE3LDcgQEAKIAkvKioqKioqKioqKioqKioqKiogSG9yaXpvbnRhbCBkZWNpbWF0aW9uL3NjYWxpbmcgKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAJLyoKLQkgKiBOb3cgd2UgaGFuZGxlIHRoZSBob3Jpem9udGFsIGNhc2UsIHRoaXMgaXMgYSBzaW1wbGlmaWVkIHZlcmlzb24gb2YKKwkgKiBOb3cgd2UgaGFuZGxlIHRoZSBob3Jpem9udGFsIGNhc2UsIHRoaXMgaXMgYSBzaW1wbGlmaWVkIHZlcnNpb24gb2YKIAkgKiB0aGUgdmVydGljYWwgY2FzZSBpbiB0aGF0IHdlIGRlY2ltYXRlIGJ5IGZhY3RvcnMgb2YgMi4gIGFzIHdlIGFyZQogCSAqIHdvcmtpbmcgaW4gd29yZHMgd2Ugc2hvdWxkIGFsd2F5cyBiZSBhYmxlIHRvIGRlY2ltYXRlIGJ5IHRoZXNlCiAJICogZmFjdG9ycy4gIGFzIHdlIGFsd2F5cyBoYXZlIHRvIGhhdmUgYSBidWZmZXIgd2hpY2ggaXMgYWxpZ25lZCB0byBhCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2t5cm8vU1RHNDAwMFJlZy5oIGIvZHJpdmVycy92aWRlby9reXJvL1NURzQwMDBSZWcuaAppbmRleCAyNDQ1NDllLi41ZDYyNjk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2t5cm8vU1RHNDAwMFJlZy5oCisrKyBiL2RyaXZlcnMvdmlkZW8va3lyby9TVEc0MDAwUmVnLmgKQEAgLTE2LDcgKzE2LDcgQEAKIAogLyoKICAqIE1hY3JvcyB0aGF0IGFjY2VzcyBtZW1vcnkgbWFwcGVkIGNhcmQgcmVnaXN0ZXJzIGluIFBDSSBzcGFjZQotICogQWRkIGFuIGFwcHJvcHJhaXRlIHNlY3Rpb24gZm9yIHlvdXIgT1Mgb3IgcHJvY2Vzc29yIGFyY2hpdGVjdHVyZS4KKyAqIEFkZCBhbiBhcHByb3ByaWF0ZSBzZWN0aW9uIGZvciB5b3VyIE9TIG9yIHByb2Nlc3NvciBhcmNoaXRlY3R1cmUuCiAgKi8KICNpZiBkZWZpbmVkKF9fS0VSTkVMX18pCiAjaW5jbHVkZSA8YXNtL3BhZ2UuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vbWF0cm94L21hdHJveGZiX0RBQzEwNjQuaCBiL2RyaXZlcnMvdmlkZW8vbWF0cm94L21hdHJveGZiX0RBQzEwNjQuaAppbmRleCBjNmVkNzgwLi4xZTZlNDViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL21hdHJveC9tYXRyb3hmYl9EQUMxMDY0LmgKKysrIGIvZHJpdmVycy92aWRlby9tYXRyb3gvbWF0cm94ZmJfREFDMTA2NC5oCkBAIC00Niw3ICs0Niw3IEBACiAjZGVmaW5lICAgICAgTTEwNjRfWERWSUNMS0NUUkxfRFZJTE9PUENUTCAgICAgICAweDMwCiAJLyogQ1JUQzIgcGl4ZWwgY2xvY2sgYWxsb3dlZCB0bygwKS9ibG9ja2VkIGZyb20oMSkgZHJpdmluZyBDUlRDMiAqLwogI2RlZmluZSAgICAgIE0xMDY0X1hEVklDTEtDVFJMX0MyRFZJQ0xLRU4gICAgICAgMHg0MAotCS8qIFAxUExMIGxvb3AgZmlsdGVyIGJhbmR3aXRoIHNlbGVjdGlvbiAqLworCS8qIFAxUExMIGxvb3AgZmlsdGVyIGJhbmR3aWR0aCBzZWxlY3Rpb24gKi8KICNkZWZpbmUgICAgICBNMTA2NF9YRFZJQ0xLQ1RSTF9QMUxPT1BCV0RUQ1RMICAgIDB4ODAKICNkZWZpbmUgTTEwNjRfWENVUkNPTDBSRUQJMHgwOAogI2RlZmluZSBNMTA2NF9YQ1VSQ09MMEdSRUVOCTB4MDkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vbWF0cm94L21hdHJveGZiX1RpMzAyNi5jIGIvZHJpdmVycy92aWRlby9tYXRyb3gvbWF0cm94ZmJfVGkzMDI2LmMKaW5kZXggODM1YWFhYS4uOWE0NGNlYyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9tYXRyb3gvbWF0cm94ZmJfVGkzMDI2LmMKKysrIGIvZHJpdmVycy92aWRlby9tYXRyb3gvbWF0cm94ZmJfVGkzMDI2LmMKQEAgLTM4Nyw3ICszODcsNyBAQAogCQkJaHctPkRBQ3JlZ1tQT1MzMDI2X1hNSVNDQ1RSTF0gPSBUVlAzMDI2X1hNSVNDQ1RSTF9EQUNfUFVQIHwgVFZQMzAyNl9YTUlTQ0NUUkxfREFDXzhCSVQgfCBUVlAzMDI2X1hNSVNDQ1RSTF9QU0VMX0RJUyB8IFRWUDMwMjZfWE1JU0NDVFJMX1BTRUxfTE9XOwogCQkJYnJlYWs7CiAJCWNhc2UgMTY6Ci0JCQkvKiBYTEFUQ0hDVFJMIHNob3VsZCBiZSBfNF8xIC8gXzJfMS4uLiBXaHkgaXMgbm90PyAoXzJfMSBpcyB1c2VkIGV2ZXJ5dGltZSkgKi8KKwkJCS8qIFhMQVRDSENUUkwgc2hvdWxkIGJlIF80XzEgLyBfMl8xLi4uIFdoeSBpcyBub3Q/IChfMl8xIGlzIHVzZWQgZXZlcnkgdGltZSkgKi8KIAkJCWh3LT5EQUNyZWdbUE9TMzAyNl9YVFJVRUNPTE9SQ1RSTF0gPSAobWluZm8tPmZiY29uLnZhci5ncmVlbi5sZW5ndGggPT0gNSkgPyAoVFZQMzAyNl9YVFJVRUNPTE9SQ1RSTF9ESVJFQ1RDT0xPUiB8IFRWUDMwMjZfWFRSVUVDT0xPUkNUUkxfT1JHQl8xNTU1KSA6IChUVlAzMDI2X1hUUlVFQ09MT1JDVFJMX0RJUkVDVENPTE9SIHwgVFZQMzAyNl9YVFJVRUNPTE9SQ1RSTF9SR0JfNTY1KTsKIAkJCWh3LT5EQUNyZWdbUE9TMzAyNl9YTVVYQ1RSTF0gPSBtdXhjdHJsIHwgVFZQMzAyNl9YTVVYQ1RSTF9QSVhFTF8xNkJJVDsKIAkJCWh3LT5EQUNyZWdbUE9TMzAyNl9YQ0xLQ1RSTF0gPSBUVlAzMDI2X1hDTEtDVFJMX1NSQ19QTEwgfCBUVlAzMDI2X1hDTEtDVFJMX0RJVjI7CkBAIC0zOTksNyArMzk5LDcgQEAKIAkJCWh3LT5EQUNyZWdbUE9TMzAyNl9YQ0xLQ1RSTF0gPSBUVlAzMDI2X1hDTEtDVFJMX1NSQ19QTEwgfCBUVlAzMDI2X1hDTEtDVFJMX0RJVjQ7CiAJCQlicmVhazsKIAkJY2FzZSAzMjoKLQkJCS8qIFhMQVRDSENUUkwgc2hvdWxkIGJlIF8yXzEgLyBfMV8xLi4uIFdoeSBpcyBub3Q/IChfMl8xIGlzIHVzZWQgZXZlcnl0aW1lKSAqLworCQkJLyogWExBVENIQ1RSTCBzaG91bGQgYmUgXzJfMSAvIF8xXzEuLi4gV2h5IGlzIG5vdD8gKF8yXzEgaXMgdXNlZCBldmVyeSB0aW1lKSAqLwogCQkJaHctPkRBQ3JlZ1tQT1MzMDI2X1hNVVhDVFJMXSA9IG11eGN0cmwgfCBUVlAzMDI2X1hNVVhDVFJMX1BJWEVMXzMyQklUOwogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL21hdHJveC9tYXRyb3hmYl9iYXNlLmMgYi9kcml2ZXJzL3ZpZGVvL21hdHJveC9tYXRyb3hmYl9iYXNlLmMKaW5kZXggNWNlNmZhNi4uNDRiZjhkNCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9tYXRyb3gvbWF0cm94ZmJfYmFzZS5jCisrKyBiL2RyaXZlcnMvdmlkZW8vbWF0cm94L21hdHJveGZiX2Jhc2UuYwpAQCAtNjIxLDcgKzYyMSw3IEBACiAJCXZhci0+eW9mZnNldCA9IHZhci0+eXJlc192aXJ0dWFsIC0gdmFyLT55cmVzOwogCiAJaWYgKGJwcCA9PSAxNiAmJiB2YXItPmdyZWVuLmxlbmd0aCA9PSA1KSB7Ci0JCWJwcC0tOyAvKiBhbiBhcnRpZmljYWwgdmFsdWUgLSAxNSAqLworCQlicHAtLTsgLyogYW4gYXJ0aWZpY2lhbCB2YWx1ZSAtIDE1ICovCiAJfQogCiAJZm9yIChyZ2J0ID0gdGFibGU7IHJnYnQtPmJwcCA8IGJwcDsgcmdidCsrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vbWF0cm94L21hdHJveGZiX2Jhc2UuaCBiL2RyaXZlcnMvdmlkZW8vbWF0cm94L21hdHJveGZiX2Jhc2UuaAppbmRleCBmOTZhNDcxLi4xMWVkNTdiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL21hdHJveC9tYXRyb3hmYl9iYXNlLmgKKysrIGIvZHJpdmVycy92aWRlby9tYXRyb3gvbWF0cm94ZmJfYmFzZS5oCkBAIC0xMiw3ICsxMiw3IEBACiAjdW5kZWYgTUFUUk9YRkJfREVCVUcKIAogLyogaGVhdnkgZGVidWdnaW5nOiAqLwotLyogLS0gbG9ncyBwdXRjW3NdLCBzbyBldmVyeXRpbWUgYSBjaGFyIGlzIGRpc3BsYXllZCwgaXQncyBsb2dnZWQgKi8KKy8qIC0tIGxvZ3MgcHV0Y1tzXSwgc28gZXZlcnkgdGltZSBhIGNoYXIgaXMgZGlzcGxheWVkLCBpdCdzIGxvZ2dlZCAqLwogI3VuZGVmIE1BVFJPWEZCX0RFQlVHX0hFQVZZCiAKIC8qIFRoaXMgb25lIF9jb3VsZF8gY2F1c2UgaW5maW5pdGUgbG9vcHMgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vbnVjOTAwZmIuaCBiL2RyaXZlcnMvdmlkZW8vbnVjOTAwZmIuaAppbmRleCA2YzIzYWEzLi5iYzdjOTMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL251YzkwMGZiLmgKKysrIGIvZHJpdmVycy92aWRlby9udWM5MDBmYi5oCkBAIC04LDcgKzgsNyBAQAogICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAgKgotICogICBBdXRoZXI6CisgKiAgIEF1dGhvcjoKICAqICAgICAgICBXYW5nIFFpYW5nKHJ1cmFsaXR5LmxpbnV4QGdtYWlsLmNvbSkgIDIwMDkvMTIvMTYKICAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL29tYXAvS2NvbmZpZyBiL2RyaXZlcnMvdmlkZW8vb21hcC9LY29uZmlnCmluZGV4IDE1ZTdmMTkuLjE5NmZhMmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vb21hcC9LY29uZmlnCisrKyBiL2RyaXZlcnMvdmlkZW8vb21hcC9LY29uZmlnCkBAIC02NCw3ICs2NCw3IEBACiAJZGVwZW5kcyBvbiBGQl9PTUFQICYmIEZCX09NQVBfTENEQ19FWFRFUk5BTAogCWhlbHAKIAkgIFNheSBZIGhlcmUsIGlmIHlvdXIgdXNlci1zcGFjZSBhcHBsaWNhdGlvbnMgYXJlIGNhcGFibGUgb2YKLQkgIG5vdGlmeWluZyB0aGUgZnJhbWUgYnVmZmVyIGRyaXZlciB3aGVuIGEgY2hhbmdlIGhhcyBvY2N1cmVkIGluCisJICBub3RpZnlpbmcgdGhlIGZyYW1lIGJ1ZmZlciBkcml2ZXIgd2hlbiBhIGNoYW5nZSBoYXMgb2NjdXJyZWQgaW4KIAkgIHRoZSBmcmFtZSBidWZmZXIgY29udGVudCBhbmQgdGh1cyBhIHJlbG9hZCBvZiB0aGUgaW1hZ2UgZGF0YSB0bwogCSAgdGhlIGV4dGVybmFsIGZyYW1lIGJ1ZmZlciBpcyByZXF1aXJlZC4gSWYgdW5zdXJlLCBzYXkgTi4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9vbWFwMi9kc3MvaGRtaS5jIGIvZHJpdmVycy92aWRlby9vbWFwMi9kc3MvaGRtaS5jCmluZGV4IDBkNDRmMDcuLmE5ODFkZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vb21hcDIvZHNzL2hkbWkuYworKysgYi9kcml2ZXJzL3ZpZGVvL29tYXAyL2Rzcy9oZG1pLmMKQEAgLTU4Nyw3ICs1ODcsNyBAQAogCXN0cnVjdCBoZG1pX2NtIGNtOwogCXN0cnVjdCBvbWFwX3ZpZGVvX3RpbWluZ3MgZWRpZF90aW1pbmdzOwogCi0JLyogc2VhY2ggYmxvY2sgMCwgdGhlcmUgYXJlIDQgRFREcyBhcnJhbmdlZCBpbiBwcmlvcml0eSBvcmRlciAqLworCS8qIHNlYXJjaCBibG9jayAwLCB0aGVyZSBhcmUgNCBEVERzIGFycmFuZ2VkIGluIHByaW9yaXR5IG9yZGVyICovCiAJZm9yIChjb3VudCA9IDA7IGNvdW50IDwgRURJRF9TSVpFX0JMT0NLMF9USU1JTkdfREVTQ1JJUFRPUjsgY291bnQrKykgewogCQljdXJyZW50X2Rlc2NyaXB0b3JfYWRkcnMgPQogCQkJRURJRF9ERVNDUklQVE9SX0JMT0NLMF9BRERSRVNTICsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vcHhhM3h4LWdjdS5jIGIvZHJpdmVycy92aWRlby9weGEzeHgtZ2N1LmMKaW5kZXggY2Y0YmViOS4uMDI4M2M3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9weGEzeHgtZ2N1LmMKKysrIGIvZHJpdmVycy92aWRlby9weGEzeHgtZ2N1LmMKQEAgLTI1LDcgKzI1LDcgQEAKIAogLyoKICAqIFdBUk5JTkc6IFRoaXMgY29udHJvbGxlciBpcyBhdHRhY2hlZCB0byBTeXN0ZW0gQnVzIDIgb2YgdGhlIFBYQSB3aGljaAotICogbmVlZHMgaXRzIGFyYml0ZXIgdG8gYmUgZW5hYmxlZCBleHBsaWN0bHkgKENLRU5CICYgMTw8OSkuCisgKiBuZWVkcyBpdHMgYXJiaXRlciB0byBiZSBlbmFibGVkIGV4cGxpY2l0bHkgKENLRU5CICYgMTw8OSkuCiAgKiBUaGVyZSBpcyBjdXJyZW50bHkgbm8gd2F5IHRvIGRvIHRoaXMgZnJvbSBMaW51eCwgc28geW91IG5lZWQgdG8gdGVhY2gKICAqIHlvdXIgYm9vdGxvYWRlciBmb3Igbm93LgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3MzYy1mYi5jIGIvZHJpdmVycy92aWRlby9zM2MtZmIuYwppbmRleCA2ODE3ZDE4Li4zYjZjZGNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3MzYy1mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vczNjLWZiLmMKQEAgLTQ4LDcgKzQ4LDcgQEAKICN1bmRlZiB3cml0ZWwKICNkZWZpbmUgd3JpdGVsKHYsIHIpIGRvIHsgXAogCXByaW50ayhLRVJOX0RFQlVHICIlczogJTA4eCA9PiAlcFxuIiwgX19mdW5jX18sICh1bnNpZ25lZCBpbnQpdiwgcik7IFwKLQlfX3Jhd193cml0ZWwodiwgcik7IH0gd2hpbGUoMCkKKwlfX3Jhd193cml0ZWwodiwgcik7IH0gd2hpbGUgKDApCiAjZW5kaWYgLyogRkJfUzNDX0RFQlVHX1JFR1dSSVRFICovCiAKIC8qIGlycV9mbGFncyBiaXRzICovCkBAIC01MTgsNyArNTE4LDcgQEAKIAogCQlkYXRhID0gVklEVENPTjJfTElORVZBTCh2YXItPnlyZXMgLSAxKSB8CiAJCSAgICAgICBWSURUQ09OMl9IT1pWQUwodmFyLT54cmVzIC0gMSk7Ci0JCXdyaXRlbChkYXRhLCByZWdzICtzZmItPnZhcmlhbnQudmlkdGNvbiArIDggKTsKKwkJd3JpdGVsKGRhdGEsIHJlZ3MgKyBzZmItPnZhcmlhbnQudmlkdGNvbiArIDgpOwogCX0KIAogCS8qIHdyaXRlIHRoZSBidWZmZXIgYWRkcmVzcyAqLwpAQCAtMTMwNCw2ICsxMzA0LDcgQEAKIAogc3RhdGljIGludCBfX2RldmluaXQgczNjX2ZiX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CisJY29uc3Qgc3RydWN0IHBsYXRmb3JtX2RldmljZV9pZCAqcGxhdGlkOwogCXN0cnVjdCBzM2NfZmJfZHJpdmVyZGF0YSAqZmJkcnY7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKIAlzdHJ1Y3QgczNjX2ZiX3BsYXRkYXRhICpwZDsKQEAgLTEzMTIsNyArMTMxMyw4IEBACiAJaW50IHdpbjsKIAlpbnQgcmV0ID0gMDsKIAotCWZiZHJ2ID0gKHN0cnVjdCBzM2NfZmJfZHJpdmVyZGF0YSAqKXBsYXRmb3JtX2dldF9kZXZpY2VfaWQocGRldiktPmRyaXZlcl9kYXRhOworCXBsYXRpZCA9IHBsYXRmb3JtX2dldF9kZXZpY2VfaWQocGRldik7CisJZmJkcnYgPSAoc3RydWN0IHMzY19mYl9kcml2ZXJkYXRhICopcGxhdGlkLT5kcml2ZXJfZGF0YTsKIAogCWlmIChmYmRydi0+dmFyaWFudC5ucl93aW5kb3dzID4gUzNDX0ZCX01BWF9XSU4pIHsKIAkJZGV2X2VycihkZXYsICJ0b28gbWFueSB3aW5kb3dzLCBjYW5ub3QgYXR0YWNoXG4iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vczNmYi5jIGIvZHJpdmVycy92aWRlby9zM2ZiLmMKaW5kZXggZGRlZGFkOS4uYzQ0ODJmMiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9zM2ZiLmMKKysrIGIvZHJpdmVycy92aWRlby9zM2ZiLmMKQEAgLTcxLDkgKzcxLDkgQEAKIAogc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzM19uYW1lc1tdID0geyJTMyBVbmtub3duIiwgIlMzIFRyaW8zMiIsICJTMyBUcmlvNjQiLCAiUzMgVHJpbzY0VisiLAogCQkJIlMzIFRyaW82NFVWKyIsICJTMyBUcmlvNjRWMi9EWCIsICJTMyBUcmlvNjRWMi9HWCIsCi0JCQkiUzMgUGxhdG8vUFgiLCAiUzMgQXVyb3JhNjRWUCIsICJTMyBWaXJnZSIsCisJCQkiUzMgUGxhdG8vUFgiLCAiUzMgQXVyb3JhNjRWKyIsICJTMyBWaXJnZSIsCiAJCQkiUzMgVmlyZ2UvVlgiLCAiUzMgVmlyZ2UvRFgiLCAiUzMgVmlyZ2UvR1giLAotCQkJIlMzIFZpcmdlL0dYMiIsICJTMyBWaXJnZS9HWDJQIiwgIlMzIFZpcmdlL0dYMlAiLAorCQkJIlMzIFZpcmdlL0dYMiIsICJTMyBWaXJnZS9HWDIrIiwgIiIsCiAJCQkiUzMgVHJpbzNELzFYIiwgIlMzIFRyaW8zRC8yWCIsICJTMyBUcmlvM0QvMlgiLAogCQkJIlMzIFRyaW8zRCJ9OwogCkBAIC05MCw5ICs5MCw4IEBACiAjZGVmaW5lIENISVBfOTg4X1ZJUkdFX1ZYCTB4MEEKICNkZWZpbmUgQ0hJUF8zNzVfVklSR0VfRFgJMHgwQgogI2RlZmluZSBDSElQXzM4NV9WSVJHRV9HWAkweDBDCi0jZGVmaW5lIENISVBfMzU2X1ZJUkdFX0dYMgkweDBECi0jZGVmaW5lIENISVBfMzU3X1ZJUkdFX0dYMlAJMHgwRQotI2RlZmluZSBDSElQXzM1OV9WSVJHRV9HWDJQCTB4MEYKKyNkZWZpbmUgQ0hJUF8zNTdfVklSR0VfR1gyCTB4MEQKKyNkZWZpbmUgQ0hJUF8zNTlfVklSR0VfR1gyUAkweDBFCiAjZGVmaW5lIENISVBfMzYwX1RSSU8zRF8xWAkweDEwCiAjZGVmaW5lIENISVBfMzYyX1RSSU8zRF8yWAkweDExCiAjZGVmaW5lIENISVBfMzY4X1RSSU8zRF8yWAkweDEyCkBAIC0zNTksNyArMzU4LDkgQEAKIAl2Z2FfdyhwYXItPnN0YXRlLnZnYWJhc2UsIFZHQV9NSVNfVywgcmVndmFsIHwgVkdBX01JU19FTkJfUExMX0xPQUQpOwogCiAJLyogU2V0IFMzIGNsb2NrIHJlZ2lzdGVycyAqLwotCWlmIChwYXItPmNoaXAgPT0gQ0hJUF8zNjBfVFJJTzNEXzFYIHx8CisJaWYgKHBhci0+Y2hpcCA9PSBDSElQXzM1N19WSVJHRV9HWDIgfHwKKwkgICAgcGFyLT5jaGlwID09IENISVBfMzU5X1ZJUkdFX0dYMlAgfHwKKwkgICAgcGFyLT5jaGlwID09IENISVBfMzYwX1RSSU8zRF8xWCB8fAogCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNjJfVFJJTzNEXzJYIHx8CiAJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM2OF9UUklPM0RfMlgpIHsKIAkJdmdhX3dzZXEocGFyLT5zdGF0ZS52Z2FiYXNlLCAweDEyLCAobiAtIDIpIHwgKChyICYgMykgPDwgNikpOwkvKiBuIGFuZCB0d28gYml0cyBvZiByICovCkBAIC01NjAsNyArNTYxLDkgQEAKIAlwcl9kZWJ1ZygiZmIlZDogb2Zmc2V0IHJlZ2lzdGVyICAgICAgIDogJWRcbiIsIGluZm8tPm5vZGUsIG9mZnNldF92YWx1ZSk7CiAJc3ZnYV93Y3J0X211bHRpKHBhci0+c3RhdGUudmdhYmFzZSwgczNfb2Zmc2V0X3JlZ3MsIG9mZnNldF92YWx1ZSk7CiAKLQlpZiAocGFyLT5jaGlwICE9IENISVBfMzYwX1RSSU8zRF8xWCAmJgorCWlmIChwYXItPmNoaXAgIT0gQ0hJUF8zNTdfVklSR0VfR1gyICYmCisJICAgIHBhci0+Y2hpcCAhPSBDSElQXzM1OV9WSVJHRV9HWDJQICYmCisJICAgIHBhci0+Y2hpcCAhPSBDSElQXzM2MF9UUklPM0RfMVggJiYKIAkgICAgcGFyLT5jaGlwICE9IENISVBfMzYyX1RSSU8zRF8yWCAmJgogCSAgICBwYXItPmNoaXAgIT0gQ0hJUF8zNjhfVFJJTzNEXzJYKSB7CiAJCXZnYV93Y3J0KHBhci0+c3RhdGUudmdhYmFzZSwgMHg1NCwgMHgxOCk7IC8qIE0gcGFyYW1ldGVyICovCkBAIC02MDQsNyArNjA3LDkgQEAKIAkJdmdhX3djcnQocGFyLT5zdGF0ZS52Z2FiYXNlLCAweDY2LCAweDkwKTsKIAl9CiAKLQlpZiAocGFyLT5jaGlwID09IENISVBfMzYwX1RSSU8zRF8xWCB8fAorCWlmIChwYXItPmNoaXAgPT0gQ0hJUF8zNTdfVklSR0VfR1gyIHx8CisJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM1OV9WSVJHRV9HWDJQIHx8CisJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM2MF9UUklPM0RfMVggfHwKIAkgICAgcGFyLT5jaGlwID09IENISVBfMzYyX1RSSU8zRF8yWCB8fAogCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNjhfVFJJTzNEXzJYIHx8CiAJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM2NV9UUklPM0QgICAgfHwKQEAgLTYxNyw4ICs2MjIsNyBAQAogCQl2Z2Ffd2NydChwYXItPnN0YXRlLnZnYWJhc2UsIDB4NjYsIDB4ODEpOwogCX0KIAotCWlmIChwYXItPmNoaXAgPT0gQ0hJUF8zNTZfVklSR0VfR1gyICB8fAotCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNTdfVklSR0VfR1gyUCB8fAorCWlmIChwYXItPmNoaXAgPT0gQ0hJUF8zNTdfVklSR0VfR1gyICB8fAogCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNTlfVklSR0VfR1gyUCB8fAogCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNjBfVFJJTzNEXzFYIHx8CiAJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM2Ml9UUklPM0RfMlggfHwKQEAgLTY3NCw2ICs2NzgsOCBAQAogCQlwcl9kZWJ1ZygiZmIlZDogOCBiaXQgcHNldWRvY29sb3JcbiIsIGluZm8tPm5vZGUpOwogCQlzdmdhX3djcnRfbWFzayhwYXItPnN0YXRlLnZnYWJhc2UsIDB4NTAsIDB4MDAsIDB4MzApOwogCQlpZiAoaW5mby0+dmFyLnBpeGNsb2NrID4gMjAwMDAgfHwKKwkJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM1N19WSVJHRV9HWDIgfHwKKwkJICAgIHBhci0+Y2hpcCA9PSBDSElQXzM1OV9WSVJHRV9HWDJQIHx8CiAJCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNjBfVFJJTzNEXzFYIHx8CiAJCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNjJfVFJJTzNEXzJYIHx8CiAJCSAgICBwYXItPmNoaXAgPT0gQ0hJUF8zNjhfVFJJTzNEXzJYKQpAQCAtNzAyLDcgKzcwOCw5IEBACiAJCX0gZWxzZSB7CiAJCQlzdmdhX3djcnRfbWFzayhwYXItPnN0YXRlLnZnYWJhc2UsIDB4NTAsIDB4MTAsIDB4MzApOwogCQkJc3ZnYV93Y3J0X21hc2socGFyLT5zdGF0ZS52Z2FiYXNlLCAweDY3LCAweDMwLCAweEYwKTsKLQkJCWlmIChwYXItPmNoaXAgIT0gQ0hJUF8zNjBfVFJJTzNEXzFYICYmCisJCQlpZiAocGFyLT5jaGlwICE9IENISVBfMzU3X1ZJUkdFX0dYMiAmJgorCQkJICAgIHBhci0+Y2hpcCAhPSBDSElQXzM1OV9WSVJHRV9HWDJQICYmCisJCQkgICAgcGFyLT5jaGlwICE9IENISVBfMzYwX1RSSU8zRF8xWCAmJgogCQkJICAgIHBhci0+Y2hpcCAhPSBDSElQXzM2Ml9UUklPM0RfMlggJiYKIAkJCSAgICBwYXItPmNoaXAgIT0gQ0hJUF8zNjhfVFJJTzNEXzJYKQogCQkJCWhtdWwgPSAyOwpAQCAtNzI3LDcgKzczNSw5IEBACiAJCX0gZWxzZSB7CiAJCQlzdmdhX3djcnRfbWFzayhwYXItPnN0YXRlLnZnYWJhc2UsIDB4NTAsIDB4MTAsIDB4MzApOwogCQkJc3ZnYV93Y3J0X21hc2socGFyLT5zdGF0ZS52Z2FiYXNlLCAweDY3LCAweDUwLCAweEYwKTsKLQkJCWlmIChwYXItPmNoaXAgIT0gQ0hJUF8zNjBfVFJJTzNEXzFYICYmCisJCQlpZiAocGFyLT5jaGlwICE9IENISVBfMzU3X1ZJUkdFX0dYMiAmJgorCQkJICAgIHBhci0+Y2hpcCAhPSBDSElQXzM1OV9WSVJHRV9HWDJQICYmCisJCQkgICAgcGFyLT5jaGlwICE9IENISVBfMzYwX1RSSU8zRF8xWCAmJgogCQkJICAgIHBhci0+Y2hpcCAhPSBDSElQXzM2Ml9UUklPM0RfMlggJiYKIAkJCSAgICBwYXItPmNoaXAgIT0gQ0hJUF8zNjhfVFJJTzNEXzJYKQogCQkJCWhtdWwgPSAyOwpAQCAtMTA2OSw2ICsxMDc5LDE2IEBACiAJCQlpbmZvLT5zY3JlZW5fc2l6ZSA9IDIgPDwgMjA7CiAJCQlicmVhazsKIAkJfQorCX0gZWxzZSBpZiAocGFyLT5jaGlwID09IENISVBfMzU3X1ZJUkdFX0dYMiB8fAorCQkgICBwYXItPmNoaXAgPT0gQ0hJUF8zNTlfVklSR0VfR1gyUCkgeworCQlzd2l0Y2ggKChyZWd2YWwgJiAweEMwKSA+PiA2KSB7CisJCWNhc2UgMTogLyogNE1CICovCisJCQlpbmZvLT5zY3JlZW5fc2l6ZSA9IDQgPDwgMjA7CisJCQlicmVhazsKKwkJY2FzZSAzOiAvKiAyTUIgKi8KKwkJCWluZm8tPnNjcmVlbl9zaXplID0gMiA8PCAyMDsKKwkJCWJyZWFrOworCQl9CiAJfSBlbHNlCiAJCWluZm8tPnNjcmVlbl9zaXplID0gczNfbWVtc2l6ZXNbcmVndmFsID4+IDVdIDw8IDEwOwogCWluZm8tPmZpeC5zbWVtX2xlbiA9IGluZm8tPnNjcmVlbl9zaXplOwpAQCAtMTI2OCw4ICsxMjg4LDggQEAKIAl7UENJX0RFVklDRShQQ0lfVkVORE9SX0lEX1MzLCAweDU2MzEpLCAuZHJpdmVyX2RhdGEgPSBDSElQXzMyNV9WSVJHRX0sCiAJe1BDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9TMywgMHg4ODNEKSwgLmRyaXZlcl9kYXRhID0gQ0hJUF85ODhfVklSR0VfVlh9LAogCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfUzMsIDB4OEEwMSksIC5kcml2ZXJfZGF0YSA9IENISVBfWFhYX1ZJUkdFX0RYR1h9LAotCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfUzMsIDB4OEExMCksIC5kcml2ZXJfZGF0YSA9IENISVBfMzU2X1ZJUkdFX0dYMn0sCi0Je1BDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9TMywgMHg4QTExKSwgLmRyaXZlcl9kYXRhID0gQ0hJUF8zNTdfVklSR0VfR1gyUH0sCisJe1BDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9TMywgMHg4QTEwKSwgLmRyaXZlcl9kYXRhID0gQ0hJUF8zNTdfVklSR0VfR1gyfSwKKwl7UENJX0RFVklDRShQQ0lfVkVORE9SX0lEX1MzLCAweDhBMTEpLCAuZHJpdmVyX2RhdGEgPSBDSElQXzM1OV9WSVJHRV9HWDJQfSwKIAl7UENJX0RFVklDRShQQ0lfVkVORE9SX0lEX1MzLCAweDhBMTIpLCAuZHJpdmVyX2RhdGEgPSBDSElQXzM1OV9WSVJHRV9HWDJQfSwKIAl7UENJX0RFVklDRShQQ0lfVkVORE9SX0lEX1MzLCAweDhBMTMpLCAuZHJpdmVyX2RhdGEgPSBDSElQXzM2WF9UUklPM0RfMVhfMlh9LAogCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfUzMsIDB4ODkwNCksIC5kcml2ZXJfZGF0YSA9IENISVBfMzY1X1RSSU8zRH0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3NhdmFnZS9zYXZhZ2VmYi1pMmMuYyBiL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiLWkyYy5jCmluZGV4IGIxNmU2MTMuLmJiNzFmZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiLWkyYy5jCisrKyBiL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiLWkyYy5jCkBAIC0xNTksOCArMTU5LDcgQEAKIAkJZWxzZQogCQkJZGV2X3dhcm4oJmNoYW4tPnBhci0+cGNpZGV2LT5kZXYsCiAJCQkJICJGYWlsZWQgdG8gcmVnaXN0ZXIgSTJDIGJ1cyAlcy5cbiIsIG5hbWUpOwotCX0gZWxzZQotCQljaGFuLT5wYXIgPSBOVUxMOworCX0KIAogCXJldHVybiByYzsKIH0KQEAgLTE3MCw5ICsxNjksOCBAQAogCXN0cnVjdCBzYXZhZ2VmYl9wYXIgKnBhciA9IGluZm8tPnBhcjsKIAlwYXItPmNoYW4ucGFyCT0gcGFyOwogCi0Jc3dpdGNoKGluZm8tPmZpeC5hY2NlbCkgewotCWNhc2UgRkJfQUNDRUxfUFJPU0FWQUdFX0REUks6Ci0JY2FzZSBGQl9BQ0NFTF9QUk9TQVZBR0VfUE06CisJc3dpdGNoIChwYXItPmNoaXApIHsKKwljYXNlIFMzX1BST1NBVkFHRToKIAkJcGFyLT5jaGFuLnJlZyAgICAgICAgID0gQ1JfU0VSSUFMMjsKIAkJcGFyLT5jaGFuLmlvYWRkciAgICAgID0gcGFyLT5tbWlvLnZiYXNlOwogCQlwYXItPmNoYW4uYWxnby5zZXRzZGEgPSBwcm9zYXZhZ2VfZ3Bpb19zZXRzZGE7CkBAIC0xODAsNyArMTc4LDcgQEAKIAkJcGFyLT5jaGFuLmFsZ28uZ2V0c2RhID0gcHJvc2F2YWdlX2dwaW9fZ2V0c2RhOwogCQlwYXItPmNoYW4uYWxnby5nZXRzY2wgPSBwcm9zYXZhZ2VfZ3Bpb19nZXRzY2w7CiAJCWJyZWFrOwotCWNhc2UgRkJfQUNDRUxfU0FWQUdFNDoKKwljYXNlIFMzX1NBVkFHRTQ6CiAJCXBhci0+Y2hhbi5yZWcgPSBDUl9TRVJJQUwxOwogCQlpZiAocGFyLT5wY2lkZXYtPnJldmlzaW9uID4gMSAmJiAhKFZHQXJDUigweGE2LCBwYXIpICYgMHg0MCkpCiAJCQlwYXItPmNoYW4ucmVnID0gQ1JfU0VSSUFMMjsKQEAgLTE5MCw4ICsxODgsOCBAQAogCQlwYXItPmNoYW4uYWxnby5nZXRzZGEgPSBwcm9zYXZhZ2VfZ3Bpb19nZXRzZGE7CiAJCXBhci0+Y2hhbi5hbGdvLmdldHNjbCA9IHByb3NhdmFnZV9ncGlvX2dldHNjbDsKIAkJYnJlYWs7Ci0JY2FzZSBGQl9BQ0NFTF9TQVZBR0UyMDAwOgotCQlwYXItPmNoYW4ucmVnICAgICAgICAgPSAweGZmMjA7CisJY2FzZSBTM19TQVZBR0UyMDAwOgorCQlwYXItPmNoYW4ucmVnICAgICAgICAgPSBNTV9TRVJJQUwxOwogCQlwYXItPmNoYW4uaW9hZGRyICAgICAgPSBwYXItPm1taW8udmJhc2U7CiAJCXBhci0+Y2hhbi5hbGdvLnNldHNkYSA9IHNhdmFnZTRfZ3Bpb19zZXRzZGE7CiAJCXBhci0+Y2hhbi5hbGdvLnNldHNjbCA9IHNhdmFnZTRfZ3Bpb19zZXRzY2w7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3NhdmFnZS9zYXZhZ2VmYi5oIGIvZHJpdmVycy92aWRlby9zYXZhZ2Uvc2F2YWdlZmIuaAppbmRleCBlNGMzZjIxLi40ZTk0OTBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3NhdmFnZS9zYXZhZ2VmYi5oCisrKyBiL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiLmgKQEAgLTE1Myw3ICsxNTMsNyBAQAogCXVuc2lnbmVkIGNoYXIgQ1JUQ1syNV07ICAgICAgIC8qIENydGMgQ29udHJvbGxlciAqLwogCXVuc2lnbmVkIGNoYXIgU2VxdWVuY2VyWzVdOyAgIC8qIFZpZGVvIFNlcXVlbmNlciAqLwogCXVuc2lnbmVkIGNoYXIgR3JhcGhpY3NbOV07ICAgIC8qIFZpZGVvIEdyYXBoaWNzICovCi0JdW5zaWduZWQgY2hhciBBdHRyaWJ1dGVbMjFdOyAgLyogVmlkZW8gQXRyaWJ1dGUgKi8KKwl1bnNpZ25lZCBjaGFyIEF0dHJpYnV0ZVsyMV07ICAvKiBWaWRlbyBBdHRyaWJ1dGUgKi8KIAogCXVuc2lnbmVkIGludCBtb2RlLCByZWZyZXNoOwogCXVuc2lnbmVkIGNoYXIgU1IwOCwgU1IwRSwgU1IwRjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiX2RyaXZlci5jIGIvZHJpdmVycy92aWRlby9zYXZhZ2Uvc2F2YWdlZmJfZHJpdmVyLmMKaW5kZXggNDg3OTExZS4uYTJkYzFhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9zYXZhZ2Uvc2F2YWdlZmJfZHJpdmVyLmMKKysrIGIvZHJpdmVycy92aWRlby9zYXZhZ2Uvc2F2YWdlZmJfZHJpdmVyLmMKQEAgLTM4NSw3ICszODUsNyBAQAogCUJDSV9TRU5EKEdsb2JhbEJpdG1hcERlc2NyaXB0b3IpOwogCiAJLyoKLQkgKiBJIGRvbid0IGtub3cgd2h5LCBzZW5kaW5nIHRoaXMgdHdpY2UgZml4ZXMgdGhlIGludGlhbCBibGFjayBzY3JlZW4sCisJICogSSBkb24ndCBrbm93IHdoeSwgc2VuZGluZyB0aGlzIHR3aWNlIGZpeGVzIHRoZSBpbml0aWFsIGJsYWNrIHNjcmVlbiwKIAkgKiBwcmV2ZW50cyBYIGZyb20gY3Jhc2hpbmcgYXQgbGVhc3QgaW4gVG9zaGliYSBsYXB0b3BzIHdpdGggU2F2YWdlSVguCiAJICogLS1Ub255CiAJICovCkBAIC0yMjExLDcgKzIyMTEsNyBAQAogCQlnb3RvIGZhaWxlZF9tbWlvOwogCiAJdmlkZW9fbGVuID0gc2F2YWdlX2luaXRfaHcocGFyKTsKLQkvKiBGSVhNRTogY2FudCBiZSBuZWdhdGl2ZSAqLworCS8qIEZJWE1FOiBjYW4ndCBiZSBuZWdhdGl2ZSAqLwogCWlmICh2aWRlb19sZW4gPCAwKSB7CiAJCWVyciA9IHZpZGVvX2xlbjsKIAkJZ290byBmYWlsZWRfbW1pbzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2xjZGNmYi5jIGIvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfbGNkY2ZiLmMKaW5kZXggNzU3NjY1Yi4uOWJjYzYxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfbGNkY2ZiLmMKKysrIGIvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfbGNkY2ZiLmMKQEAgLTY0Myw3ICs2NDMsNyBAQAogCQkJY29udGludWU7CiAKIAkJYm9hcmRfY2ZnID0gJmNoLT5jZmcuYm9hcmRfY2ZnOwotCQlpZiAodHJ5X21vZHVsZV9nZXQoYm9hcmRfY2ZnLT5vd25lcikgJiYgYm9hcmRfY2ZnLT5kaXNwbGF5X29uKSB7CisJCWlmIChib2FyZF9jZmctPmRpc3BsYXlfb24gJiYgdHJ5X21vZHVsZV9nZXQoYm9hcmRfY2ZnLT5vd25lcikpIHsKIAkJCWJvYXJkX2NmZy0+ZGlzcGxheV9vbihib2FyZF9jZmctPmJvYXJkX2RhdGEsIGNoLT5pbmZvKTsKIAkJCW1vZHVsZV9wdXQoYm9hcmRfY2ZnLT5vd25lcik7CiAJCX0KQEAgLTY4OCw3ICs2ODgsNyBAQAogCQl9CiAKIAkJYm9hcmRfY2ZnID0gJmNoLT5jZmcuYm9hcmRfY2ZnOwotCQlpZiAodHJ5X21vZHVsZV9nZXQoYm9hcmRfY2ZnLT5vd25lcikgJiYgYm9hcmRfY2ZnLT5kaXNwbGF5X29mZikgeworCQlpZiAoYm9hcmRfY2ZnLT5kaXNwbGF5X29mZiAmJiB0cnlfbW9kdWxlX2dldChib2FyZF9jZmctPm93bmVyKSkgewogCQkJYm9hcmRfY2ZnLT5kaXNwbGF5X29mZihib2FyZF9jZmctPmJvYXJkX2RhdGEpOwogCQkJbW9kdWxlX3B1dChib2FyZF9jZmctPm93bmVyKTsKIAkJfQpAQCAtMTAzMiw2ICsxMDMyLDQ5IEBACiAJcmV0dXJuIDA7CiB9CiAKKy8qCisgKiBTY3JlZW4gYmxhbmtpbmcuIEJlaGF2aW9yIGlzIGFzIGZvbGxvd3M6CisgKiBGQl9CTEFOS19VTkJMQU5LOiBzY3JlZW4gdW5ibGFua2VkLCBjbG9ja3MgZW5hYmxlZAorICogRkJfQkxBTktfTk9STUFMOiBzY3JlZW4gYmxhbmtlZCwgY2xvY2tzIGVuYWJsZWQKKyAqIEZCX0JMQU5LX1ZTWU5DLAorICogRkJfQkxBTktfSFNZTkMsCisgKiBGQl9CTEFOS19QT1dFUk9GRjogc2NyZWVuIGJsYW5rZWQsIGNsb2NrcyBkaXNhYmxlZAorICovCitzdGF0aWMgaW50IHNoX21vYmlsZV9sY2RjX2JsYW5rKGludCBibGFuaywgc3RydWN0IGZiX2luZm8gKmluZm8pCit7CisJc3RydWN0IHNoX21vYmlsZV9sY2RjX2NoYW4gKmNoID0gaW5mby0+cGFyOworCXN0cnVjdCBzaF9tb2JpbGVfbGNkY19wcml2ICpwID0gY2gtPmxjZGM7CisKKwkvKiBibGFuayB0aGUgc2NyZWVuPyAqLworCWlmIChibGFuayA+IEZCX0JMQU5LX1VOQkxBTksgJiYgY2gtPmJsYW5rX3N0YXR1cyA9PSBGQl9CTEFOS19VTkJMQU5LKSB7CisJCXN0cnVjdCBmYl9maWxscmVjdCByZWN0ID0geworCQkJLndpZHRoID0gaW5mby0+dmFyLnhyZXMsCisJCQkuaGVpZ2h0ID0gaW5mby0+dmFyLnlyZXMsCisJCX07CisJCXNoX21vYmlsZV9sY2RjX2ZpbGxyZWN0KGluZm8sICZyZWN0KTsKKwl9CisJLyogdHVybiBjbG9ja3Mgb24/ICovCisJaWYgKGJsYW5rIDw9IEZCX0JMQU5LX05PUk1BTCAmJiBjaC0+Ymxhbmtfc3RhdHVzID4gRkJfQkxBTktfTk9STUFMKSB7CisJCXNoX21vYmlsZV9sY2RjX2Nsa19vbihwKTsKKwl9CisJLyogdHVybiBjbG9ja3Mgb2ZmPyAqLworCWlmIChibGFuayA+IEZCX0JMQU5LX05PUk1BTCAmJiBjaC0+Ymxhbmtfc3RhdHVzIDw9IEZCX0JMQU5LX05PUk1BTCkgeworCQkvKiBtYWtlIHN1cmUgdGhlIHNjcmVlbiBpcyB1cGRhdGVkIHdpdGggdGhlIGJsYWNrIGZpbGwgYmVmb3JlCisJCSAqIHN3aXRjaGluZyB0aGUgY2xvY2tzIG9mZi4gb25lIHZzeW5jIGlzIG5vdCBlbm91Z2ggc2luY2UKKwkJICogYmxhbmtpbmcgbWF5IG9jY3VyIGluIHRoZSBtaWRkbGUgb2YgYSByZWZyZXNoLiBkZWZlcnJlZCBpbworCQkgKiBtb2RlIHdpbGwgcmVlbmFibGUgdGhlIGNsb2NrcyBhbmQgdXBkYXRlIHRoZSBzY3JlZW4gaW4gdGltZSwKKwkJICogc28gaXQgZG9lcyBub3QgbmVlZCB0aGlzLiAqLworCQlpZiAoIWluZm8tPmZiZGVmaW8pIHsKKwkJCXNoX21vYmlsZV93YWl0X2Zvcl92c3luYyhpbmZvKTsKKwkJCXNoX21vYmlsZV93YWl0X2Zvcl92c3luYyhpbmZvKTsKKwkJfQorCQlzaF9tb2JpbGVfbGNkY19jbGtfb2ZmKHApOworCX0KKworCWNoLT5ibGFua19zdGF0dXMgPSBibGFuazsKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHN0cnVjdCBmYl9vcHMgc2hfbW9iaWxlX2xjZGNfb3BzID0gewogCS5vd25lciAgICAgICAgICA9IFRISVNfTU9EVUxFLAogCS5mYl9zZXRjb2xyZWcJPSBzaF9tb2JpbGVfbGNkY19zZXRjb2xyZWcsCkBAIC0xMDQwLDYgKzEwODMsNyBAQAogCS5mYl9maWxscmVjdAk9IHNoX21vYmlsZV9sY2RjX2ZpbGxyZWN0LAogCS5mYl9jb3B5YXJlYQk9IHNoX21vYmlsZV9sY2RjX2NvcHlhcmVhLAogCS5mYl9pbWFnZWJsaXQJPSBzaF9tb2JpbGVfbGNkY19pbWFnZWJsaXQsCisJLmZiX2JsYW5rCT0gc2hfbW9iaWxlX2xjZGNfYmxhbmssCiAJLmZiX3Bhbl9kaXNwbGF5ID0gc2hfbW9iaWxlX2ZiX3Bhbl9kaXNwbGF5LAogCS5mYl9pb2N0bCAgICAgICA9IHNoX21vYmlsZV9pb2N0bCwKIAkuZmJfb3Blbgk9IHNoX21vYmlsZV9vcGVuLApAQCAtMTI1NCw3ICsxMjk4LDcgQEAKIAogCXN3aXRjaChhY3Rpb24pIHsKIAljYXNlIEZCX0VWRU5UX1NVU1BFTkQ6Ci0JCWlmICh0cnlfbW9kdWxlX2dldChib2FyZF9jZmctPm93bmVyKSAmJiBib2FyZF9jZmctPmRpc3BsYXlfb2ZmKSB7CisJCWlmIChib2FyZF9jZmctPmRpc3BsYXlfb2ZmICYmIHRyeV9tb2R1bGVfZ2V0KGJvYXJkX2NmZy0+b3duZXIpKSB7CiAJCQlib2FyZF9jZmctPmRpc3BsYXlfb2ZmKGJvYXJkX2NmZy0+Ym9hcmRfZGF0YSk7CiAJCQltb2R1bGVfcHV0KGJvYXJkX2NmZy0+b3duZXIpOwogCQl9CkBAIC0xMjY3LDcgKzEzMTEsNyBAQAogCQltdXRleF91bmxvY2soJmNoLT5vcGVuX2xvY2spOwogCiAJCS8qIEhETUkgbXVzdCBiZSBlbmFibGVkIGJlZm9yZSBMQ0RDIGNvbmZpZ3VyYXRpb24gKi8KLQkJaWYgKHRyeV9tb2R1bGVfZ2V0KGJvYXJkX2NmZy0+b3duZXIpICYmIGJvYXJkX2NmZy0+ZGlzcGxheV9vbikgeworCQlpZiAoYm9hcmRfY2ZnLT5kaXNwbGF5X29uICYmIHRyeV9tb2R1bGVfZ2V0KGJvYXJkX2NmZy0+b3duZXIpKSB7CiAJCQlib2FyZF9jZmctPmRpc3BsYXlfb24oYm9hcmRfY2ZnLT5ib2FyZF9kYXRhLCBpbmZvKTsKIAkJCW1vZHVsZV9wdXQoYm9hcmRfY2ZnLT5vd25lcik7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2xjZGNmYi5oIGIvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfbGNkY2ZiLmgKaW5kZXggNDYzNWVlZC4uZjE2Y2I1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfbGNkY2ZiLmgKKysrIGIvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfbGNkY2ZiLmgKQEAgLTM3LDYgKzM3LDcgQEAKIAlzdHJ1Y3QgY29tcGxldGlvbiB2c3luY19jb21wbGV0aW9uOwogCXN0cnVjdCBmYl92YXJfc2NyZWVuaW5mbyBkaXNwbGF5X3ZhcjsKIAlpbnQgdXNlX2NvdW50OworCWludCBibGFua19zdGF0dXM7CiAJc3RydWN0IG11dGV4IG9wZW5fbG9jazsJCS8qIHByb3RlY3RzIHRoZSB1c2UgY291bnRlciAqLwogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9zbTUwMWZiLmMgYi9kcml2ZXJzL3ZpZGVvL3NtNTAxZmIuYwppbmRleCA0NmQxYTY0Li41NmVmNmIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3NtNTAxZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL3NtNTAxZmIuYwpAQCAtMjY1LDcgKzI2NSw3IEBACiAJcmV0dXJuICh1bnNpZ25lZCBsb25nKW51bWVyYXRvcjsKIH0KIAotLyogc201MDFmYl9oel90b19wcyBpcyBpZGVudGljYWwgdG8gdGhlIG9wb3NpdGUgdHJhbnNmb3JtICovCisvKiBzbTUwMWZiX2h6X3RvX3BzIGlzIGlkZW50aWNhbCB0byB0aGUgb3Bwb3NpdGUgdHJhbnNmb3JtICovCiAKICNkZWZpbmUgc201MDFmYl9oel90b19wcyh4KSBzbTUwMWZiX3BzX3RvX2h6KHgpCiAKQEAgLTE3MTksNyArMTcxOSw3IEBACiAJICAgICAgIChoZWFkID09IEhFQURfQ1JUKSA/ICZzbTUwMWZiX29wc19jcnQgOiAmc201MDFmYl9vcHNfcG5sLAogCSAgICAgICBzaXplb2Yoc3RydWN0IGZiX29wcykpOwogCi0JLyogdXBkYXRlIG9wcyBkZXBlbmRhbnQgb24gd2hhdCB3ZSd2ZSBiZWVuIHBhc3NlZCAqLworCS8qIHVwZGF0ZSBvcHMgZGVwZW5kZW50IG9uIHdoYXQgd2UndmUgYmVlbiBwYXNzZWQgKi8KIAogCWlmICgocGQtPmZsYWdzICYgU001MDFGQl9GTEFHX1VTRV9IV0NVUlNPUikgPT0gMCkKIAkJcGFyLT5vcHMuZmJfY3Vyc29yID0gTlVMTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vc3N0ZmIuYyBiL2RyaXZlcnMvdmlkZW8vc3N0ZmIuYwppbmRleCAyYWI3MDQxLi4yMzAxYzI3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3NzdGZiLmMKKysrIGIvZHJpdmVycy92aWRlby9zc3RmYi5jCkBAIC0yMjEsNyArMjIxLDcgQEAKIAl3aGlsZSgxKSB7CiAJCWlmIChfX3NzdF9yZWFkKHZiYXNlLCBTVEFUVVMpICYgU1RBVFVTX0ZCSV9CVVNZKSB7CiAJCQlmX2RkZHByaW50aygic3RhdHVzOiBidXN5XG4iKTsKLS8qIEZJWE1FIGJhc2ljYWx5LCB0aGlzIGlzIGEgYnVzeSB3YWl0LiBtYXliZSBub3QgdGhhdCBnb29kLiBvaCB3ZWxsOworLyogRklYTUUgYmFzaWNhbGx5LCB0aGlzIGlzIGEgYnVzeSB3YWl0LiBtYXliZSBub3QgdGhhdCBnb29kLiBvaCB3ZWxsOwogICogdGhpcyBpcyBhIHNtYWxsIGxvb3AgYWZ0ZXIgYWxsLgogICogT3IgbWF5YmUgd2Ugc2hvdWxkIHVzZSBtZGVsYXkoKSBvciB1ZGVsYXkoKSBoZXJlIGluc3RlYWQgPyAqLwogCQkJY291bnQgPSAwOwpAQCAtNTAxLDcgKzUwMSw3IEBACiAJfQogCiAJaWYgKElTX1ZPT0RPTzIocGFyKSkgewotCQkvKiB2b29kb28yIGhhcyAzMiBwaXhlbCB3aWRlIHRpbGVzICwgQlVUIHN0YW5nZSB0aGluZ3MKKwkJLyogdm9vZG9vMiBoYXMgMzIgcGl4ZWwgd2lkZSB0aWxlcyAsIEJVVCBzdHJhbmdlIHRoaW5ncwogCQkgICBoYXBwZW4gd2l0aCBvZGQgbnVtYmVyIG9mIHRpbGVzICovCiAJCXBhci0+dGlsZXNfaW5fWCA9IChpbmZvLT52YXIueHJlcyArIDYzICkgLyA2NCAqIDI7CiAJfSBlbHNlIHsKQEAgLTkyMCwxMSArOTIwLDExIEBACiAgKiB3ZSBnZXQgdGhlIDFzdCBieXRlIChNIHZhbHVlKSBvZiBwcmVzZXQgZjEsZjcgYW5kIGZCCiAgKiB3aHkgdGhvc2UgMyA/IG1tbWguLi4gZm9yIG5vdywgaSdsbCBkbyBpdCB0aGUgZ2xpZGUgd2F5Li4uCiAgKiBhbmQgYXNrIHF1ZXN0aW9ucyBsYXRlci4gYW55d2F5LCBpdCBzZWVtcyB0aGF0IGFsbCB0aGUgZnJlcSByZWdpc3RlcnMgYXJlCi0gKiByZWFseSBhdCB0aGVpciBkZWZhdWx0IHN0YXRlIChjZiBzcGVjcykgc28gaSBhc2sgYWdhaW4sIHdoeSB0aG9zZSAzIHJlZ3MgPworICogcmVhbGx5IGF0IHRoZWlyIGRlZmF1bHQgc3RhdGUgKGNmIHNwZWNzKSBzbyBpIGFzayBhZ2Fpbiwgd2h5IHRob3NlIDMgcmVncyA/CiAgKiBtbW1taC4uIGl0IHNlZW1zIHRoYXQncyBtdWNoIG1vcmUgdWdseSB0aGFuIGkgdGhvdWdodC4gd2UgdXNlIGYwIGFuZCBmQSBmb3IKICAqIHBsbCBwcm9ncmFtbWluZywgc28gaW4gZmFjdCwgd2UgKmhvcGUqIHRoYXQgdGhlIGYxLCBmNyAmIGZCIHdvbid0IGJlCiAgKiB0b3VjaGVkLi4uCi0gKiBpcyBpdCByZWFseSBzYWZlID8gaG93IGNhbiBpIHJlc2V0IHRoaXMgcmFtZGFjID8gZ2VlZS4uLgorICogaXMgaXQgcmVhbGx5IHNhZmUgPyBob3cgY2FuIGkgcmVzZXQgdGhpcyByYW1kYWMgPyBnZWVlLi4uCiAgKi8KIHN0YXRpYyBpbnQgX19kZXZpbml0IHNzdF9kZXRlY3RfaWNzKHN0cnVjdCBmYl9pbmZvICppbmZvKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9zdGljb3JlLmggYi9kcml2ZXJzL3ZpZGVvL3N0aWNvcmUuaAppbmRleCA3ZmU1YmU0Li5hZGRmN2I2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3N0aWNvcmUuaAorKysgYi9kcml2ZXJzL3ZpZGVvL3N0aWNvcmUuaApAQCAtNzksNyArNzksNyBAQAogCSB1OCBjdXJyX21vbjsJCQkvKiBjdXJyZW50IG1vbml0b3IgY29uZmlndXJlZCAqLwogCSB1OCBmcmllbmRseV9ib290OwkJLyogaW4gZnJpZW5kbHkgYm9vdCBtb2RlICovCiAJczE2IHBvd2VyOwkJCS8qIHBvd2VyIGNhbGN1bGF0aW9uIChpbiBXYXR0cykgKi8KLQlzMzIgZnJlcV9yZWY7CQkJLyogZnJlcXVlbmN5IHJlZnJlbmNlICovCisJczMyIGZyZXFfcmVmOwkJCS8qIGZyZXF1ZW5jeSByZWZlcmVuY2UgKi8KIAl1MzIgc3RpX21lbV9hZGRyOwkJLyogcG9pbnRlciB0byBnbG9iYWwgc3RpIG1lbW9yeSAoc2l6ZT1zdGlfbWVtX3JlcXVlc3QpICovCiAJdTMyIGZ1dHVyZV9wdHI7IAkJLyogcG9pbnRlciB0byBmdXR1cmUgZGF0YSAqLwogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vdGRmeGZiLmMgYi9kcml2ZXJzL3ZpZGVvL3RkZnhmYi5jCmluZGV4IDNlZTVlNjMuLmE5OWI5OTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vdGRmeGZiLmMKKysrIGIvZHJpdmVycy92aWRlby90ZGZ4ZmIuYwpAQCAtODc3LDEyICs4NzcsMTIgQEAKIAllbHNlCiAJCXRkZnhfcm9wID0gVERGWF9ST1BfWE9SOwogCi0JLyogYXN1bWUgYWx3YXlzIHJlY3QtPmhlaWdodCA8IDQwOTYgKi8KKwkvKiBhc3N1bWUgYWx3YXlzIHJlY3QtPmhlaWdodCA8IDQwOTYgKi8KIAlpZiAoZHkgKyByZWN0LT5oZWlnaHQgPiA0MDk1KSB7CiAJCWRzdGJhc2UgPSBzdHJpZGUgKiBkeTsKIAkJZHkgPSAwOwogCX0KLQkvKiBhc3VtZSBhbHdheXMgcmVjdC0+d2lkdGggPCA0MDk2ICovCisJLyogYXNzdW1lIGFsd2F5cyByZWN0LT53aWR0aCA8IDQwOTYgKi8KIAlpZiAoZHggKyByZWN0LT53aWR0aCA+IDQwOTUpIHsKIAkJZHN0YmFzZSArPSBkeCAqIGJwcCA+PiAzOwogCQlkeCA9IDA7CkBAIC05MTUsMjIgKzkxNSwyMiBAQAogCXUzMiBkc3RiYXNlID0gMDsKIAl1MzIgc3JjYmFzZSA9IDA7CiAKLQkvKiBhc3VtZSBhbHdheXMgYXJlYS0+aGVpZ2h0IDwgNDA5NiAqLworCS8qIGFzc3VtZSBhbHdheXMgYXJlYS0+aGVpZ2h0IDwgNDA5NiAqLwogCWlmIChzeSArIGFyZWEtPmhlaWdodCA+IDQwOTUpIHsKIAkJc3JjYmFzZSA9IHN0cmlkZSAqIHN5OwogCQlzeSA9IDA7CiAJfQotCS8qIGFzdW1lIGFsd2F5cyBhcmVhLT53aWR0aCA8IDQwOTYgKi8KKwkvKiBhc3N1bWUgYWx3YXlzIGFyZWEtPndpZHRoIDwgNDA5NiAqLwogCWlmIChzeCArIGFyZWEtPndpZHRoID4gNDA5NSkgewogCQlzcmNiYXNlICs9IHN4ICogYnBwID4+IDM7CiAJCXN4ID0gMDsKIAl9Ci0JLyogYXN1bWUgYWx3YXlzIGFyZWEtPmhlaWdodCA8IDQwOTYgKi8KKwkvKiBhc3N1bWUgYWx3YXlzIGFyZWEtPmhlaWdodCA8IDQwOTYgKi8KIAlpZiAoZHkgKyBhcmVhLT5oZWlnaHQgPiA0MDk1KSB7CiAJCWRzdGJhc2UgPSBzdHJpZGUgKiBkeTsKIAkJZHkgPSAwOwogCX0KLQkvKiBhc3VtZSBhbHdheXMgYXJlYS0+d2lkdGggPCA0MDk2ICovCisJLyogYXNzdW1lIGFsd2F5cyBhcmVhLT53aWR0aCA8IDQwOTYgKi8KIAlpZiAoZHggKyBhcmVhLT53aWR0aCA+IDQwOTUpIHsKIAkJZHN0YmFzZSArPSBkeCAqIGJwcCA+PiAzOwogCQlkeCA9IDA7CkBAIC0xMDAzLDEyICsxMDAzLDEyIEBACiAjZWxzZQogCXNyY2ZtdCA9IDB4NDAwMDAwOwogI2VuZGlmCi0JLyogYXN1bWUgYWx3YXlzIGltYWdlLT5oZWlnaHQgPCA0MDk2ICovCisJLyogYXNzdW1lIGFsd2F5cyBpbWFnZS0+aGVpZ2h0IDwgNDA5NiAqLwogCWlmIChkeSArIGltYWdlLT5oZWlnaHQgPiA0MDk1KSB7CiAJCWRzdGJhc2UgPSBzdHJpZGUgKiBkeTsKIAkJZHkgPSAwOwogCX0KLQkvKiBhc3VtZSBhbHdheXMgaW1hZ2UtPndpZHRoIDwgNDA5NiAqLworCS8qIGFzc3VtZSBhbHdheXMgaW1hZ2UtPndpZHRoIDwgNDA5NiAqLwogCWlmIChkeCArIGltYWdlLT53aWR0aCA+IDQwOTUpIHsKIAkJZHN0YmFzZSArPSBkeCAqIGJwcCA+PiAzOwogCQlkeCA9IDA7CkBAIC0xMTI0LDcgKzExMjQsNyBAQAogCQkgKiBsb3dlciBoYWxmIChsZWFzdCBzaWduaWZpY2FudCA2NCBiaXRzKSBvZiBhIDEyOCBiaXQgd29yZAogCQkgKiBhbmQgcGF0dGVybiAxIHRoZSB1cHBlciBoYWxmLiBJZiB5b3UgZXhhbWluZSB0aGUgZGF0YSBvZgogCQkgKiB0aGUgY3Vyc29yIGltYWdlIHRoZSBncmFwaGljcyBjYXJkIHVzZXMgdGhlbiBmcm9tIHRoZQotCQkgKiBiZWdpbmluZyB5b3Ugc2VlIGxpbmUgb25lIG9mIHBhdHRlcm4gMCwgbGluZSBvbmUgb2YKKwkJICogYmVnaW5uaW5nIHlvdSBzZWUgbGluZSBvbmUgb2YgcGF0dGVybiAwLCBsaW5lIG9uZSBvZgogCQkgKiBwYXR0ZXJuIDEsIGxpbmUgdHdvIG9mIHBhdHRlcm4gMCwgbGluZSB0d28gb2YgcGF0dGVybiAxLAogCQkgKiBldGMgZXRjLiBUaGUgbGluZWFyIHN0cmlkZSBmb3IgdGhlIGN1cnNvciBpcyBhbHdheXMgMTYgYnl0ZXMKIAkJICogKDEyOCBiaXRzKSB3aGljaCBpcyB0aGUgbWF4aW11bSBjdXJzb3Igd2lkdGggdGltZXMgdHdvIGZvcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby90bWlvZmIuYyBiL2RyaXZlcnMvdmlkZW8vdG1pb2ZiLmMKaW5kZXggOTcxMGJmOC4uMGMzNDFkNyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby90bWlvZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL3RtaW9mYi5jCkBAIC0zNTksNyArMzU5LDcgQEAKIHsKIAlzdHJ1Y3QgdG1pb2ZiX3BhciAqcGFyID0gaW5mby0+cGFyOwogCS8qCi0JICogVGhpcyBjb2RlIGNhbiBiZSBjYWxsZWQgd2hpdGggaW50ZXJydXB0cyBkaXNhYmxlZC4KKwkgKiBUaGlzIGNvZGUgY2FuIGJlIGNhbGxlZCB3aXRoIGludGVycnVwdHMgZGlzYWJsZWQuCiAJICogU28gaW5zdGVhZCBvZiByZWxheWluZyBvbiBpcnEgdG8gdHJpZ2dlciB0aGUgZXZlbnQsCiAJICogcG9sbCB0aGUgc3RhdGUgdGlsbCB0aGUgbmVjZXNzYXJ5IGNvbW1hbmQgaXMgZXhlY3V0ZWQuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3VkbGZiLmMgYi9kcml2ZXJzL3ZpZGVvL3VkbGZiLmMKaW5kZXggMmM4MzY0ZS4uNjgwNDFkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby91ZGxmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vdWRsZmIuYwpAQCAtNzY5LDcgKzc2OSw3IEBACiAKIAkJLyoKIAkJICogSWYgd2UgaGF2ZSBhIGRhbWFnZS1hd2FyZSBjbGllbnQsIHR1cm4gZmJfZGVmaW8gIm9mZiIKLQkJICogVG8gYXZvaWQgcGVyZiBpbWFjdCBvZiB1bmVjZXNzYXJ5IHBhZ2UgZmF1bHQgaGFuZGxpbmcuCisJCSAqIFRvIGF2b2lkIHBlcmYgaW1hY3Qgb2YgdW5uZWNlc3NhcnkgcGFnZSBmYXVsdCBoYW5kbGluZy4KIAkJICogRG9uZSBieSByZXNldHRpbmcgdGhlIGRlbGF5IGZvciB0aGlzIGZiX2luZm8gdG8gYSB2ZXJ5CiAJCSAqIGxvbmcgcGVyaW9kLiBQYWdlcyB3aWxsIGJlY29tZSB3cml0YWJsZSBhbmQgc3RheSB0aGF0IHdheS4KIAkJICogUmVzZXQgdG8gbm9ybWFsIHZhbHVlIHdoZW4gYWxsIGNsaWVudHMgaGF2ZSBjbG9zZWQgdGhpcyBmYi4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vdmdhMTZmYi5jIGIvZHJpdmVycy92aWRlby92Z2ExNmZiLmMKaW5kZXggMjhjY2FiNC4uNTNiMmM1YSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby92Z2ExNmZiLmMKKysrIGIvZHJpdmVycy92aWRlby92Z2ExNmZiLmMKQEAgLTE1Miw3ICsxNTIsNyBAQAogfQogCiAvKiBTZXQgdGhlIEVuYWJsZSBTZXQvUmVzZXQgUmVnaXN0ZXIgYW5kIHJldHVybiBpdHMgb2xkIHZhbHVlLiAgCi0gICBUaGUgY29kZSBoZXJlIGFsd2F5cyB1c2VzIHZhbHVlIDB4ZiBmb3IgdGhzaSByZWdpc3Rlci4gKi8KKyAgIFRoZSBjb2RlIGhlcmUgYWx3YXlzIHVzZXMgdmFsdWUgMHhmIGZvciB0aGlzIHJlZ2lzdGVyLiAqLwogc3RhdGljIGlubGluZSBpbnQgc2V0c3IoaW50IHNyKQogewogCWludCBvbGRzcjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vdmlhL2NoaXAuaCBiL2RyaXZlcnMvdmlkZW8vdmlhL2NoaXAuaAppbmRleCA3ODFmM2FhLi4yOWQ3MDI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3ZpYS9jaGlwLmgKKysrIGIvZHJpdmVycy92aWRlby92aWEvY2hpcC5oCkBAIC0xMzksNyArMTM5LDYgQEAKIAogc3RydWN0IGNydF9zZXR0aW5nX2luZm9ybWF0aW9uIHsKIAlpbnQgaWdhX3BhdGg7Ci0JaW50IHJlZnJlc2hfcmF0ZTsKIH07CiAKIHN0cnVjdCB0bWRzX3NldHRpbmdfaW5mb3JtYXRpb24gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby92aWEvaHcuYyBiL2RyaXZlcnMvdmlkZW8vdmlhL2h3LmMKaW5kZXggNTcyOGZkNy4uZGM0Yzc3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby92aWEvaHcuYworKysgYi9kcml2ZXJzL3ZpZGVvL3ZpYS9ody5jCkBAIC0yMDAyLDEzICsyMDAyLDE1IEBACiAJaW50IGk7CiAJaW50IGluZGV4ID0gMDsKIAlpbnQgaF9hZGRyLCB2X2FkZHI7Ci0JdTMyIHBsbF9EX04sIGNsb2NrOworCXUzMiBwbGxfRF9OLCBjbG9jaywgcmVmcmVzaCA9IHZpYWZiX3JlZnJlc2g7CisKKwlpZiAodmlhZmJfU0FNTV9PTiAmJiBzZXRfaWdhID09IElHQTIpCisJCXJlZnJlc2ggPSB2aWFmYl9yZWZyZXNoMTsKIAogCWZvciAoaSA9IDA7IGkgPCB2aWRlb19tb2RlLT5tb2RlX2FycmF5OyBpKyspIHsKIAkJaW5kZXggPSBpOwogCi0JCWlmIChjcnRfdGFibGVbaV0ucmVmcmVzaF9yYXRlID09IHZpYXBhcmluZm8tPgotCQkJY3J0X3NldHRpbmdfaW5mby0+cmVmcmVzaF9yYXRlKQorCQlpZiAoY3J0X3RhYmxlW2ldLnJlZnJlc2hfcmF0ZSA9PSByZWZyZXNoKQogCQkJYnJlYWs7CiAJfQogCkBAIC0yMDE5LDcgKzIwMjEsNyBAQAogCWlmICgodmlhZmJfTENEX09OIHwgdmlhZmJfRFZJX09OKQogCSAgICAmJiB2aWRlb19tb2RlLT5jcnRjWzBdLmNydGMuaG9yX2FkZHIgPT0gNjQwCiAJICAgICYmIHZpZGVvX21vZGUtPmNydGNbMF0uY3J0Yy52ZXJfYWRkciA9PSA0ODAKLQkgICAgJiYgdmlhcGFyaW5mby0+Y3J0X3NldHRpbmdfaW5mby0+cmVmcmVzaF9yYXRlID09IDYwKSB7CisJICAgICYmIHJlZnJlc2ggPT0gNjApIHsKIAkJLyogVGhlIGJvcmRlciBpcyA4IHBpeGVscy4gKi8KIAkJY3J0X3JlZy5ob3JfYmxhbmtfc3RhcnQgPSBjcnRfcmVnLmhvcl9ibGFua19zdGFydCAtIDg7CiAKQEAgLTIwNzAsNyArMjA3Miw2IEBACiAJaW5pdF9sdmRzX2NoaXBfaW5mbygpOwogCiAJdmlhcGFyaW5mby0+Y3J0X3NldHRpbmdfaW5mby0+aWdhX3BhdGggPSBJR0ExOwotCXZpYXBhcmluZm8tPmNydF9zZXR0aW5nX2luZm8tPnJlZnJlc2hfcmF0ZSA9IHZpYWZiX3JlZnJlc2g7CiAKIAkvKlNldCBJR0EgcGF0aCBmb3IgZWFjaCBkZXZpY2UgKi8KIAl2aWFmYl9zZXRfaWdhX3BhdGgoKTsKQEAgLTIwODMsMTMgKzIwODQsOSBAQAogCQl2aWFwYXJpbmZvLT5sdmRzX3NldHRpbmdfaW5mby0+bGNkX21vZGU7CiB9CiAKLXZvaWQgdmlhZmJfdXBkYXRlX2RldmljZV9zZXR0aW5nKGludCBocmVzLCBpbnQgdnJlcywKLQlpbnQgYnBwLCBpbnQgdm1vZGVfcmVmcmVzaCwgaW50IGZsYWcpCit2b2lkIHZpYWZiX3VwZGF0ZV9kZXZpY2Vfc2V0dGluZyhpbnQgaHJlcywgaW50IHZyZXMsIGludCBicHAsIGludCBmbGFnKQogewogCWlmIChmbGFnID09IDApIHsKLQkJdmlhcGFyaW5mby0+Y3J0X3NldHRpbmdfaW5mby0+cmVmcmVzaF9yYXRlID0KLQkJCXZtb2RlX3JlZnJlc2g7Ci0KIAkJdmlhcGFyaW5mby0+dG1kc19zZXR0aW5nX2luZm8tPmhfYWN0aXZlID0gaHJlczsKIAkJdmlhcGFyaW5mby0+dG1kc19zZXR0aW5nX2luZm8tPnZfYWN0aXZlID0gdnJlczsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby92aWEvaHcuaCBiL2RyaXZlcnMvdmlkZW8vdmlhL2h3LmgKaW5kZXggNzI5NTI2My4uODg1ODU5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby92aWEvaHcuaAorKysgYi9kcml2ZXJzL3ZpZGVvL3ZpYS9ody5oCkBAIC05NDksOCArOTQ5LDcgQEAKIHZvaWQgX19kZXZpbml0IHZpYWZiX2luaXRfZGFjKGludCBzZXRfaWdhKTsKIGludCB2aWFmYl9nZXRfcGl4Y2xvY2soaW50IGhyZXMsIGludCB2cmVzLCBpbnQgdm1vZGVfcmVmcmVzaCk7CiBpbnQgdmlhZmJfZ2V0X3JlZnJlc2goaW50IGhyZXMsIGludCB2cmVzLCB1MzIgZmxvYXRfcmVmcmVzaCk7Ci12b2lkIHZpYWZiX3VwZGF0ZV9kZXZpY2Vfc2V0dGluZyhpbnQgaHJlcywgaW50IHZyZXMsIGludCBicHAsCi0JCQkgICBpbnQgdm1vZGVfcmVmcmVzaCwgaW50IGZsYWcpOwordm9pZCB2aWFmYl91cGRhdGVfZGV2aWNlX3NldHRpbmcoaW50IGhyZXMsIGludCB2cmVzLCBpbnQgYnBwLCBpbnQgZmxhZyk7CiAKIHZvaWQgdmlhZmJfc2V0X2lnYV9wYXRoKHZvaWQpOwogdm9pZCB2aWFmYl9zZXRfcHJpbWFyeV9jb2xvcl9yZWdpc3Rlcih1OCBpbmRleCwgdTggcmVkLCB1OCBncmVlbiwgdTggYmx1ZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3ZpYS92aWFfdXRpbGl0eS5jIGIvZHJpdmVycy92aWRlby92aWEvdmlhX3V0aWxpdHkuYwppbmRleCBkMDVjY2I2Li4zNTQ1OGE1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3ZpYS92aWFfdXRpbGl0eS5jCisrKyBiL2RyaXZlcnMvdmlkZW8vdmlhL3ZpYV91dGlsaXR5LmMKQEAgLTE3NCw3ICsxNzQsNyBAQAogCX0KIAogCS8qIElmIGFkanVzdCBHYW1tYSB2YWx1ZSBpbiBTQU1NLCBmaWxsIElHQTEsCi0JICAgSUdBMiBHYW1tYSB0YWJsZSBzaW11bHRhbm91cy4gKi8KKwkgICBJR0EyIEdhbW1hIHRhYmxlIHNpbXVsdGFuZW91cy4gKi8KIAkvKiBTd2l0Y2ggdG8gSUdBMiBHYW1tYSBUYWJsZSAqLwogCWlmICgoYWN0aXZlX2RldmljZV9hbW91bnQgPiAxKSAmJgogCQkhKCh2aWFwYXJpbmZvLT5jaGlwX2luZm8tPmdmeF9jaGlwX25hbWUgPT0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vdmlhL3ZpYV91dGlsaXR5LmggYi9kcml2ZXJzL3ZpZGVvL3ZpYS92aWFfdXRpbGl0eS5oCmluZGV4IDE2NzBiYTguLmYyM2JlMTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vdmlhL3ZpYV91dGlsaXR5LmgKKysrIGIvZHJpdmVycy92aWRlby92aWEvdmlhX3V0aWxpdHkuaApAQCAtMjEsNyArMjEsNyBAQAogI2lmbmRlZiBfX1ZJQVVUSUxJVFlfSF9fCiAjZGVmaW5lIF9fVklBVVRJTElUWV9IX18KIAotLyogVGhlc2UgZnVuY3Rpb25zIGFyZSB1c2VkIHRvIGdldCBpbmZvbWF0aW9uIGFib3V0IGRldmljZSdzIHN0YXRlICovCisvKiBUaGVzZSBmdW5jdGlvbnMgYXJlIHVzZWQgdG8gZ2V0IGluZm9ybWF0aW9uIGFib3V0IGRldmljZSdzIHN0YXRlICovCiB2b2lkIHZpYWZiX2dldF9kZXZpY2Vfc3VwcG9ydF9zdGF0ZSh1MzIgKnN1cHBvcnRfc3RhdGUpOwogdm9pZCB2aWFmYl9nZXRfZGV2aWNlX2Nvbm5lY3Rfc3RhdGUodTMyICpjb25uZWN0X3N0YXRlKTsKIGJvb2wgdmlhZmJfbGNkX2dldF9zdXBwb3J0X2V4cGFuZF9zdGF0ZSh1MzIgeHJlcywgdTMyIHlyZXMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby92aWEvdmlhZmJkZXYuYyBiL2RyaXZlcnMvdmlkZW8vdmlhL3ZpYWZiZGV2LmMKaW5kZXggZjU1NWI4OS4uYTU0MmJlZCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby92aWEvdmlhZmJkZXYuYworKysgYi9kcml2ZXJzL3ZpZGVvL3ZpYS92aWFmYmRldi5jCkBAIC0xODIsMTMgKzE4MiwyNCBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW5saW5lIGludCBnZXRfdmFyX3JlZnJlc2goc3RydWN0IGZiX3Zhcl9zY3JlZW5pbmZvICp2YXIpCit7CisJdTMyIGh0b3RhbCwgdnRvdGFsOworCisJaHRvdGFsID0gdmFyLT5sZWZ0X21hcmdpbiArIHZhci0+eHJlcyArIHZhci0+cmlnaHRfbWFyZ2luCisJCSsgdmFyLT5oc3luY19sZW47CisJdnRvdGFsID0gdmFyLT51cHBlcl9tYXJnaW4gKyB2YXItPnlyZXMgKyB2YXItPmxvd2VyX21hcmdpbgorCQkrIHZhci0+dnN5bmNfbGVuOworCXJldHVybiBQSUNPUzJLSFoodmFyLT5waXhjbG9jaykgKiAxMDAwIC8gKGh0b3RhbCAqIHZ0b3RhbCk7Cit9CisKIHN0YXRpYyBpbnQgdmlhZmJfY2hlY2tfdmFyKHN0cnVjdCBmYl92YXJfc2NyZWVuaW5mbyAqdmFyLAogCXN0cnVjdCBmYl9pbmZvICppbmZvKQogewotCWludCBodG90YWwsIHZ0b3RhbCwgZGVwdGg7CisJaW50IGRlcHRoLCByZWZyZXNoOwogCXN0cnVjdCBWaWRlb01vZGVUYWJsZSAqdm1vZGVfZW50cnk7CiAJc3RydWN0IHZpYWZiX3BhciAqcHBhciA9IGluZm8tPnBhcjsKLQl1MzIgbG9uZ19yZWZyZXNoLCBsaW5lOworCXUzMiBsaW5lOwogCiAJREVCVUdfTVNHKEtFUk5fSU5GTyAidmlhZmJfY2hlY2tfdmFyIVxuIik7CiAJLyogU2FuaXR5IGNoZWNrICovCkBAIC0yMzEsMTcgKzI0MiwxMSBAQAogCS8qIEJhc2VkIG9uIHZhciBwYXNzZWQgaW4gdG8gY2FsY3VsYXRlIHRoZSByZWZyZXNoLAogCSAqIGJlY2F1c2Ugb3VyIGRyaXZlciB1c2Ugc29tZSBtb2RlcyBzcGVjaWFsLgogCSAqLwotCWh0b3RhbCA9IHZhci0+eHJlcyArIHZhci0+bGVmdF9tYXJnaW4gKwotCXZhci0+cmlnaHRfbWFyZ2luICsgdmFyLT5oc3luY19sZW47Ci0JdnRvdGFsID0gdmFyLT55cmVzICsgdmFyLT51cHBlcl9tYXJnaW4gKwotCQl2YXItPmxvd2VyX21hcmdpbiArIHZhci0+dnN5bmNfbGVuOwotCWxvbmdfcmVmcmVzaCA9IDEwMDAwMDAwMDBVTCAvIHZhci0+cGl4Y2xvY2sgKiAxMDAwOwotCWxvbmdfcmVmcmVzaCAvPSAoaHRvdGFsICogdnRvdGFsKTsKLQotCXZpYWZiX3JlZnJlc2ggPSB2aWFmYl9nZXRfcmVmcmVzaCh2YXItPnhyZXMsIHZhci0+eXJlcywgbG9uZ19yZWZyZXNoKTsKKwlyZWZyZXNoID0gdmlhZmJfZ2V0X3JlZnJlc2godmFyLT54cmVzLCB2YXItPnlyZXMsCisJCWdldF92YXJfcmVmcmVzaCh2YXIpKTsKIAogCS8qIEFkanVzdCB2YXIgYWNjb3JkaW5nIHRvIG91ciBkcml2ZXIncyBvd24gdGFibGUgKi8KLQl2aWFmYl9maWxsX3Zhcl90aW1pbmdfaW5mbyh2YXIsIHZpYWZiX3JlZnJlc2gsIHZtb2RlX2VudHJ5KTsKKwl2aWFmYl9maWxsX3Zhcl90aW1pbmdfaW5mbyh2YXIsIHJlZnJlc2gsIHZtb2RlX2VudHJ5KTsKIAlpZiAodmFyLT5hY2NlbF9mbGFncyAmIEZCX0FDQ0VMRl9URVhUICYmCiAJCSFwcGFyLT5zaGFyZWQtPnZkZXYtPmVuZ2luZV9tbWlvKQogCQl2YXItPmFjY2VsX2ZsYWdzID0gMDsKQEAgLTI1MywxMiArMjU4LDEzIEBACiB7CiAJc3RydWN0IHZpYWZiX3BhciAqdmlhcGFyID0gaW5mby0+cGFyOwogCXN0cnVjdCBWaWRlb01vZGVUYWJsZSAqdm1vZGVfZW50cnksICp2bW9kZV9lbnRyeTEgPSBOVUxMOworCWludCByZWZyZXNoOwogCURFQlVHX01TRyhLRVJOX0lORk8gInZpYWZiX3NldF9wYXIhXG4iKTsKIAogCXZpYWZiX3VwZGF0ZV9maXgoaW5mbyk7CiAJdmlhcGFyLT5kZXB0aCA9IGZiX2dldF9jb2xvcl9kZXB0aCgmaW5mby0+dmFyLCAmaW5mby0+Zml4KTsKIAl2aWFmYl91cGRhdGVfZGV2aWNlX3NldHRpbmcodmlhZmJpbmZvLT52YXIueHJlcywgdmlhZmJpbmZvLT52YXIueXJlcywKLQkJdmlhZmJpbmZvLT52YXIuYml0c19wZXJfcGl4ZWwsIHZpYWZiX3JlZnJlc2gsIDApOworCQl2aWFmYmluZm8tPnZhci5iaXRzX3Blcl9waXhlbCwgMCk7CiAKIAl2bW9kZV9lbnRyeSA9IHZpYWZiX2dldF9tb2RlKHZpYWZiaW5mby0+dmFyLnhyZXMsIHZpYWZiaW5mby0+dmFyLnlyZXMpOwogCWlmICh2aWFmYl9kdWFsX2ZiKSB7CkBAIC0yNjYsNyArMjcyLDcgQEAKIAkJCXZpYWZiaW5mbzEtPnZhci55cmVzKTsKIAkJdmlhZmJfdXBkYXRlX2RldmljZV9zZXR0aW5nKHZpYWZiaW5mbzEtPnZhci54cmVzLAogCQkJdmlhZmJpbmZvMS0+dmFyLnlyZXMsIHZpYWZiaW5mbzEtPnZhci5iaXRzX3Blcl9waXhlbCwKLQkJCXZpYWZiX3JlZnJlc2gxLCAxKTsKKwkJCTEpOwogCX0gZWxzZSBpZiAodmlhZmJfU0FNTV9PTiA9PSAxKSB7CiAJCURFQlVHX01TRyhLRVJOX0lORk8KIAkJInZpYWZiX3NlY29uZF94cmVzID0gJWQsIHZpYWZiX3NlY29uZF95cmVzID0gJWQsIGJwcCA9ICVkXG4iLApAQCAtMjc1LDE0ICsyODEsMTkgQEAKIAkJCXZpYWZiX3NlY29uZF95cmVzKTsKIAogCQl2aWFmYl91cGRhdGVfZGV2aWNlX3NldHRpbmcodmlhZmJfc2Vjb25kX3hyZXMsCi0JCQl2aWFmYl9zZWNvbmRfeXJlcywgdmlhZmJfYnBwMSwgdmlhZmJfcmVmcmVzaDEsIDEpOworCQkJdmlhZmJfc2Vjb25kX3lyZXMsIHZpYWZiX2JwcDEsIDEpOwogCX0KIAorCXJlZnJlc2ggPSB2aWFmYl9nZXRfcmVmcmVzaChpbmZvLT52YXIueHJlcywgaW5mby0+dmFyLnlyZXMsCisJCWdldF92YXJfcmVmcmVzaCgmaW5mby0+dmFyKSk7CiAJaWYgKHZtb2RlX2VudHJ5KSB7Ci0JCWlmICh2aWFmYl9kdWFsX2ZiICYmIHZpYXBhci0+aWdhX3BhdGggPT0gSUdBMikKKwkJaWYgKHZpYWZiX2R1YWxfZmIgJiYgdmlhcGFyLT5pZ2FfcGF0aCA9PSBJR0EyKSB7CiAJCQl2aWFmYl9icHAxID0gaW5mby0+dmFyLmJpdHNfcGVyX3BpeGVsOwotCQllbHNlCisJCQl2aWFmYl9yZWZyZXNoMSA9IHJlZnJlc2g7CisJCX0gZWxzZSB7CiAJCQl2aWFmYl9icHAgPSBpbmZvLT52YXIuYml0c19wZXJfcGl4ZWw7CisJCQl2aWFmYl9yZWZyZXNoID0gcmVmcmVzaDsKKwkJfQogCiAJCWlmIChpbmZvLT52YXIuYWNjZWxfZmxhZ3MgJiBGQl9BQ0NFTEZfVEVYVCkKIAkJCWluZm8tPmZsYWdzICY9IH5GQklORk9fSFdBQ0NFTF9ESVNBQkxFRDsKQEAgLTE3OTUsMTQgKzE4MDYsOSBAQAogCWRlZmF1bHRfdmFyLnhyZXNfdmlydHVhbCA9IGRlZmF1bHRfeHJlczsKIAlkZWZhdWx0X3Zhci55cmVzX3ZpcnR1YWwgPSBkZWZhdWx0X3lyZXM7CiAJZGVmYXVsdF92YXIuYml0c19wZXJfcGl4ZWwgPSB2aWFmYl9icHA7Ci0JZGVmYXVsdF92YXIucGl4Y2xvY2sgPQotCSAgICB2aWFmYl9nZXRfcGl4Y2xvY2soZGVmYXVsdF94cmVzLCBkZWZhdWx0X3lyZXMsIHZpYWZiX3JlZnJlc2gpOwotCWRlZmF1bHRfdmFyLmxlZnRfbWFyZ2luID0gKGRlZmF1bHRfeHJlcyA+PiAzKSAmIDB4Zjg7Ci0JZGVmYXVsdF92YXIucmlnaHRfbWFyZ2luID0gMzI7Ci0JZGVmYXVsdF92YXIudXBwZXJfbWFyZ2luID0gMTY7Ci0JZGVmYXVsdF92YXIubG93ZXJfbWFyZ2luID0gNDsKLQlkZWZhdWx0X3Zhci5oc3luY19sZW4gPSBkZWZhdWx0X3Zhci5sZWZ0X21hcmdpbjsKLQlkZWZhdWx0X3Zhci52c3luY19sZW4gPSA0OworCXZpYWZiX2ZpbGxfdmFyX3RpbWluZ19pbmZvKCZkZWZhdWx0X3ZhciwgdmlhZmJfZ2V0X3JlZnJlc2goCisJCWRlZmF1bHRfdmFyLnhyZXMsIGRlZmF1bHRfdmFyLnlyZXMsIHZpYWZiX3JlZnJlc2gpLAorCQl2aWFmYl9nZXRfbW9kZShkZWZhdWx0X3Zhci54cmVzLCBkZWZhdWx0X3Zhci55cmVzKSk7CiAJdmlhZmJfc2V0dXBfZml4aW5mbygmdmlhZmJpbmZvLT5maXgsIHZpYXBhcmluZm8pOwogCXZpYWZiaW5mby0+dmFyID0gZGVmYXVsdF92YXI7CiAKQEAgLTE4NDEsMTUgKzE4NDcsOSBAQAogCQlkZWZhdWx0X3Zhci54cmVzX3ZpcnR1YWwgPSB2aWFmYl9zZWNvbmRfdmlydHVhbF94cmVzOwogCQlkZWZhdWx0X3Zhci55cmVzX3ZpcnR1YWwgPSB2aWFmYl9zZWNvbmRfdmlydHVhbF95cmVzOwogCQlkZWZhdWx0X3Zhci5iaXRzX3Blcl9waXhlbCA9IHZpYWZiX2JwcDE7Ci0JCWRlZmF1bHRfdmFyLnBpeGNsb2NrID0KLQkJICAgIHZpYWZiX2dldF9waXhjbG9jayh2aWFmYl9zZWNvbmRfeHJlcywgdmlhZmJfc2Vjb25kX3lyZXMsCi0JCSAgICB2aWFmYl9yZWZyZXNoKTsKLQkJZGVmYXVsdF92YXIubGVmdF9tYXJnaW4gPSAodmlhZmJfc2Vjb25kX3hyZXMgPj4gMykgJiAweGY4OwotCQlkZWZhdWx0X3Zhci5yaWdodF9tYXJnaW4gPSAzMjsKLQkJZGVmYXVsdF92YXIudXBwZXJfbWFyZ2luID0gMTY7Ci0JCWRlZmF1bHRfdmFyLmxvd2VyX21hcmdpbiA9IDQ7Ci0JCWRlZmF1bHRfdmFyLmhzeW5jX2xlbiA9IGRlZmF1bHRfdmFyLmxlZnRfbWFyZ2luOwotCQlkZWZhdWx0X3Zhci52c3luY19sZW4gPSA0OworCQl2aWFmYl9maWxsX3Zhcl90aW1pbmdfaW5mbygmZGVmYXVsdF92YXIsIHZpYWZiX2dldF9yZWZyZXNoKAorCQkJZGVmYXVsdF92YXIueHJlcywgZGVmYXVsdF92YXIueXJlcywgdmlhZmJfcmVmcmVzaDEpLAorCQkJdmlhZmJfZ2V0X21vZGUoZGVmYXVsdF92YXIueHJlcywgZGVmYXVsdF92YXIueXJlcykpOwogCiAJCXZpYWZiX3NldHVwX2ZpeGluZm8oJnZpYWZiaW5mbzEtPmZpeCwgdmlhcGFyaW5mbzEpOwogCQl2aWFmYl9jaGVja192YXIoJmRlZmF1bHRfdmFyLCB2aWFmYmluZm8xKTsKQEAgLTIwMDQsMjIgKzIwMDQsMjQgQEAKICAqLwogaW50IF9faW5pdCB2aWFmYl9pbml0KHZvaWQpCiB7Ci0JdTMyIGR1bW15OworCXUzMiBkdW1teV94LCBkdW1teV95OwogI2lmbmRlZiBNT0RVTEUKIAljaGFyICpvcHRpb24gPSBOVUxMOwogCWlmIChmYl9nZXRfb3B0aW9ucygidmlhZmIiLCAmb3B0aW9uKSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAJdmlhZmJfc2V0dXAob3B0aW9uKTsKICNlbmRpZgotCWlmIChwYXJzZV9tb2RlKHZpYWZiX21vZGUsICZkdW1teSwgJmR1bW15KQotCQl8fCBwYXJzZV9tb2RlKHZpYWZiX21vZGUxLCAmZHVtbXksICZkdW1teSkKKwlpZiAocGFyc2VfbW9kZSh2aWFmYl9tb2RlLCAmZHVtbXlfeCwgJmR1bW15X3kpCisJCXx8ICF2aWFmYl9nZXRfbW9kZShkdW1teV94LCBkdW1teV95KQorCQl8fCBwYXJzZV9tb2RlKHZpYWZiX21vZGUxLCAmZHVtbXlfeCwgJmR1bW15X3kpCisJCXx8ICF2aWFmYl9nZXRfbW9kZShkdW1teV94LCBkdW1teV95KQogCQl8fCB2aWFmYl9icHAgPCAwIHx8IHZpYWZiX2JwcCA+IDMyCiAJCXx8IHZpYWZiX2JwcDEgPCAwIHx8IHZpYWZiX2JwcDEgPiAzMgogCQl8fCBwYXJzZV9hY3RpdmVfZGV2KCkpCiAJCXJldHVybiAtRUlOVkFMOwogCiAJcHJpbnRrKEtFUk5fSU5GTwotICAgICAgICJWSUEgR3JhcGhpY3MgSW50ZXJncmF0aW9uIENoaXBzZXQgZnJhbWVidWZmZXIgJWQuJWQgaW5pdGlhbGl6aW5nXG4iLAorICAgICAgICJWSUEgR3JhcGhpY3MgSW50ZWdyYXRpb24gQ2hpcHNldCBmcmFtZWJ1ZmZlciAlZC4lZCBpbml0aWFsaXppbmdcbiIsCiAJICAgICAgIFZFUlNJT05fTUFKT1IsIFZFUlNJT05fTUlOT1IpOwogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby93MTAwZmIuYyBiL2RyaXZlcnMvdmlkZW8vdzEwMGZiLmMKaW5kZXggZDhiMTJjMy4uYzhiZThhZiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby93MTAwZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL3cxMDBmYi5jCkBAIC0xMzA2LDcgKzEzMDYsNyBAQAogCXVuaW9uIGdyYXBoaWNfdl9kaXNwX3UgZ3JhcGhpY192X2Rpc3A7CiAJdW5pb24gY3J0Y190b3RhbF91IGNydGNfdG90YWw7CiAKLQkvKiB3MzIwMCBkb2VzbnQgbGlrZSB1bmRlZmluZWQgYml0cyBiZWluZyBzZXQgc28gemVybyByZWdpc3RlciB2YWx1ZXMgZmlyc3QgKi8KKwkvKiB3MzIwMCBkb2Vzbid0IGxpa2UgdW5kZWZpbmVkIGJpdHMgYmVpbmcgc2V0IHNvIHplcm8gcmVnaXN0ZXIgdmFsdWVzIGZpcnN0ICovCiAKIAlhY3RpdmVfaF9kaXNwLnZhbCA9IDA7CiAJYWN0aXZlX2hfZGlzcC5mLmFjdGl2ZV9oX3N0YXJ0PW1vZGUtPmxlZnRfbWFyZ2luOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy93MS9tYXN0ZXJzL29tYXBfaGRxLmMgYi9kcml2ZXJzL3cxL21hc3RlcnMvb21hcF9oZHEuYwppbmRleCAzOGU5NmFiLi41ZWYzODViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3cxL21hc3RlcnMvb21hcF9oZHEuYworKysgYi9kcml2ZXJzL3cxL21hc3RlcnMvb21hcF9oZHEuYwpAQCAtNTQ1LDcgKzU0NSw3IEBACiAJCXJldHVybjsKIAl9CiAKLQkvKiBTZWNvbmQgd3JpdGUsIGRhdGEgdHJhbnNmZXJlZC4gUmVsZWFzZSB0aGUgbW9kdWxlICovCisJLyogU2Vjb25kIHdyaXRlLCBkYXRhIHRyYW5zZmVycmVkLiBSZWxlYXNlIHRoZSBtb2R1bGUgKi8KIAlpZiAoaGRxX2RhdGEtPmluaXRfdHJhbnMgPiAxKSB7CiAJCW9tYXBfaGRxX3B1dChoZHFfZGF0YSk7CiAJCXJldCA9IG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmaGRxX2RhdGEtPmhkcV9tdXRleCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL0tjb25maWcgYi9kcml2ZXJzL3dhdGNoZG9nL0tjb25maWcKaW5kZXggYjY5ZDcxNC4uMWIwZjk4YiAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9LY29uZmlnCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvS2NvbmZpZwpAQCAtOTMzLDcgKzkzMyw3IEBACiAJZGVwZW5kcyBvbiBTT0NfUE5YODMzNQogCWhlbHAKIAkgIEhhcmR3YXJlIGRyaXZlciBmb3IgdGhlIFBOWDgzM3gncyB3YXRjaGRvZy4gVGhpcyBpcyBhCi0JICB3YXRjaGRvZyB0aW1lciB0aGF0IHdpbGwgcmVib290IHRoZSBtYWNoaW5lIGFmdGVyIGEgcHJvZ3JhbWFibGUKKwkgIHdhdGNoZG9nIHRpbWVyIHRoYXQgd2lsbCByZWJvb3QgdGhlIG1hY2hpbmUgYWZ0ZXIgYSBwcm9ncmFtbWFibGUKIAkgIHRpbWVyIGhhcyBleHBpcmVkIGFuZCBubyBwcm9jZXNzIGhhcyB3cml0dGVuIHRvIC9kZXYvd2F0Y2hkb2cgZHVyaW5nCiAJICB0aGF0IHRpbWUuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvd2F0Y2hkb2cvTWFrZWZpbGUgYi9kcml2ZXJzL3dhdGNoZG9nL01ha2VmaWxlCmluZGV4IGQ1MjBiZjkuLjNmODYwOGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvd2F0Y2hkb2cvTWFrZWZpbGUKKysrIGIvZHJpdmVycy93YXRjaGRvZy9NYWtlZmlsZQpAQCAtNCw3ICs0LDcgQEAKIAogIyBPbmx5IG9uZSB3YXRjaGRvZyBjYW4gc3VjY2VlZC4gV2UgcHJvYmUgdGhlIElTQS9QQ0kvVVNCIGJhc2VkCiAjIHdhdGNoZG9nLWNhcmRzIGZpcnN0LCB0aGVuIHRoZSBhcmNoaXRlY3R1cmUgc3BlY2lmaWMgd2F0Y2hkb2cKLSMgZHJpdmVycyBhbmQgdGhlbiB0aGUgYXJjaGl0ZWN0dXJlIGluZGVwZW5kYW50ICJzb2Z0ZG9nIiBkcml2ZXIuCisjIGRyaXZlcnMgYW5kIHRoZW4gdGhlIGFyY2hpdGVjdHVyZSBpbmRlcGVuZGVudCAic29mdGRvZyIgZHJpdmVyLgogIyBUaGlzIG1lYW5zIHRoYXQgaWYgeW91ciBJU0EvUENJL1VTQiBjYXJkIGlzbid0IGRldGVjdGVkIHRoYXQKICMgeW91IGNhbiBmYWxsIGJhY2sgdG8gYW4gYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGRyaXZlciBhbmQgaWYKICMgdGhhdCBhbHNvIGZhaWxzIHRoZW4geW91IGNhbiBmYWxsIGJhY2sgdG8gdGhlIHNvZnR3YXJlIHdhdGNoZG9nCkBAIC0xNTMsNyArMTUzLDcgQEAKICMgWGVuCiBvYmotJChDT05GSUdfWEVOX1dEVCkgKz0geGVuX3dkdC5vCiAKLSMgQXJjaGl0ZWN0dXJlIEluZGVwZW5kYW50CisjIEFyY2hpdGVjdHVyZSBJbmRlcGVuZGVudAogb2JqLSQoQ09ORklHX1dNODMxWF9XQVRDSERPRykgKz0gd204MzF4X3dkdC5vCiBvYmotJChDT05GSUdfV004MzUwX1dBVENIRE9HKSArPSB3bTgzNTBfd2R0Lm8KIG9iai0kKENPTkZJR19NQVg2M1hYX1dBVENIRE9HKSArPSBtYXg2M3h4X3dkdC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL2FjcXVpcmV3ZHQuYyBiL2RyaXZlcnMvd2F0Y2hkb2cvYWNxdWlyZXdkdC5jCmluZGV4IDJmZmNlNGQuLmI2YTJiNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvd2F0Y2hkb2cvYWNxdWlyZXdkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvYWNxdWlyZXdkdC5jCkBAIC0yNiw3ICsyNiw3IEBACiAgKglUaGVvcnkgb2YgT3BlcmF0aW9uOgogICoJCVRoZSBXYXRjaC1Eb2cgVGltZXIgaXMgcHJvdmlkZWQgdG8gZW5zdXJlIHRoYXQgc3RhbmRhbG9uZQogICoJCVN5c3RlbXMgY2FuIGFsd2F5cyByZWNvdmVyIGZyb20gY2F0YXN0cm9waGljIGNvbmRpdGlvbnMgdGhhdAotICoJCWNhdXNlZCB0aGUgQ1BVIHRvIGNyYXNoLiBUaGlzIGNvbmRpdGlvbiBtYXkgaGF2ZSBvY2N1cmVkIGJ5CisgKgkJY2F1c2VkIHRoZSBDUFUgdG8gY3Jhc2guIFRoaXMgY29uZGl0aW9uIG1heSBoYXZlIG9jY3VycmVkIGJ5CiAgKgkJZXh0ZXJuYWwgRU1JIG9yIGEgc29mdHdhcmUgYnVnLiBXaGVuIHRoZSBDUFUgc3RvcHMgd29ya2luZwogICoJCWNvcnJlY3RseSwgaGFyZHdhcmUgb24gdGhlIGJvYXJkIHdpbGwgZWl0aGVyIHBlcmZvcm0gYSBoYXJkd2FyZQogICoJCXJlc2V0IChjb2xkIGJvb3QpIG9yIGEgbm9uLW1hc2thYmxlIGludGVycnVwdCAoTk1JKSB0byBicmluZyB0aGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvd2F0Y2hkb2cvbXBjOHh4eF93ZHQuYyBiL2RyaXZlcnMvd2F0Y2hkb2cvbXBjOHh4eF93ZHQuYwppbmRleCA2NzA5ZDcyLi41MjhiY2ViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3dhdGNoZG9nL21wYzh4eHhfd2R0LmMKKysrIGIvZHJpdmVycy93YXRjaGRvZy9tcGM4eHh4X3dkdC5jCkBAIC0xOTUsNyArMTk1LDcgQEAKIAogCWlmICghb2ZkZXYtPmRldi5vZl9tYXRjaCkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0Jd2R0X3R5cGUgPSBtYXRjaC0+ZGF0YTsKKwl3ZHRfdHlwZSA9IG9mZGV2LT5kZXYub2ZfbWF0Y2gtPmRhdGE7CiAKIAlpZiAoIWZyZXEgfHwgZnJlcSA9PSAtMSkKIAkJcmV0dXJuIC1FSU5WQUw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL3BjODc0MTNfd2R0LmMgYi9kcml2ZXJzL3dhdGNoZG9nL3BjODc0MTNfd2R0LmMKaW5kZXggMTM5ZDc3My4uYjdjMTM5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9wYzg3NDEzX3dkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvcGM4NzQxM193ZHQuYwpAQCAtNDksNyArNDksNyBAQAogI2RlZmluZSBXRFRfREFUQV9JT19QT1JUICAgIChXRFRfSU5ERVhfSU9fUE9SVCsxKQogI2RlZmluZSBTV0NfTEROICAgICAgICAgICAgIDB4MDQKICNkZWZpbmUgU0lPQ0ZHMiAgICAgICAgICAgICAweDIyCS8qIFNlcmlhbCBJTyByZWdpc3RlciAqLwotI2RlZmluZSBXRENUTCAgICAgICAgICAgICAgIDB4MTAJLyogV2F0Y2hkb2ctVGltZXItQ29udHJvbGwtUmVnaXN0ZXIgKi8KKyNkZWZpbmUgV0RDVEwgICAgICAgICAgICAgICAweDEwCS8qIFdhdGNoZG9nLVRpbWVyLUNvbnRyb2wtUmVnaXN0ZXIgKi8KICNkZWZpbmUgV0RUTyAgICAgICAgICAgICAgICAweDExCS8qIFdhdGNoZG9nIHRpbWVvdXQgcmVnaXN0ZXIgKi8KICNkZWZpbmUgV0RDRkcgICAgICAgICAgICAgICAweDEyCS8qIFdhdGNoZG9nIGNvbmZpZyByZWdpc3RlciAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL3NiYzcyNDBfd2R0LmMgYi9kcml2ZXJzL3dhdGNoZG9nL3NiYzcyNDBfd2R0LmMKaW5kZXggNjdkZGViMS4uZmYxMTUwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9zYmM3MjQwX3dkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvc2JjNzI0MF93ZHQuYwpAQCAtMjczLDcgKzI3Myw3IEBACiAKIAkvKiBUaGUgSU8gcG9ydCAweDA0MyB1c2VkIHRvIGRpc2FibGUgdGhlIHdhdGNoZG9nCiAJICogaXMgYWxyZWFkeSBjbGFpbWVkIGJ5IHRoZSBzeXN0ZW0gdGltZXIsIHNvIHdlCi0JICogY2FudCByZXF1ZXN0X3JlZ2lvbigpIGl0IC4uLiovCisJICogY2FuJ3QgcmVxdWVzdF9yZWdpb24oKSBpdCAuLi4qLwogCiAJaWYgKHRpbWVvdXQgPCAxIHx8IHRpbWVvdXQgPiBTQkM3MjQwX01BWF9USU1FT1VUKSB7CiAJCXRpbWVvdXQgPSBTQkM3MjQwX1RJTUVPVVQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL3NjaDMxMXhfd2R0LmMgYi9kcml2ZXJzL3dhdGNoZG9nL3NjaDMxMXhfd2R0LmMKaW5kZXggYjYxYWIxYy4uYzdjZjRiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9zY2gzMTF4X3dkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvc2NoMzExeF93ZHQuYwpAQCAtMjAxLDcgKzIwMSw3IEBACiAJc3Bpbl9sb2NrKCZzY2gzMTF4X3dkdF9kYXRhLmlvX2xvY2spOwogCiAJLyogLS0gV2F0Y2hkb2cgdGltZXIgY29udHJvbCAtLQotCSAqIEJpdCAwICAgU3RhdHVzIEJpdDogMCA9IFRpbWVyIGNvdW50aW5nLCAxID0gVGltZW91dCBvY2N1cmVkCisJICogQml0IDAgICBTdGF0dXMgQml0OiAwID0gVGltZXIgY291bnRpbmcsIDEgPSBUaW1lb3V0IG9jY3VycmVkCiAJICogQml0IDEgICBSZXNlcnZlZAogCSAqIEJpdCAyICAgRm9yY2UgVGltZW91dDogMSA9IEZvcmNlcyBXRCB0aW1lb3V0IGV2ZW50IChzZWxmLWNsZWFuaW5nKQogCSAqIEJpdCAzICAgUDIwIEZvcmNlIFRpbWVvdXQgZW5hYmxlZDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvd2F0Y2hkb2cvc2h3ZHQuYyBiL2RyaXZlcnMvd2F0Y2hkb2cvc2h3ZHQuYwppbmRleCA0ZTNlN2ViLi5kYjg0ZjIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3dhdGNoZG9nL3Nod2R0LmMKKysrIGIvZHJpdmVycy93YXRjaGRvZy9zaHdkdC5jCkBAIC01MCw3ICs1MCw3IEBACiAgKiBuZWNzc2FyeS4KICAqCiAgKiBBcyBhIHJlc3VsdCBvZiB0aGlzIHRpbWluZyBwcm9ibGVtLCB0aGUgb25seSBtb2RlcyB0aGF0IGFyZSBwYXJ0aWN1bGFybHkKLSAqIGZlYXNpYmxlIGFyZSB0aGUgNDA5NiBhbmQgdGhlIDIwNDggZGl2aXNvcnMsIHdoaWNoIHllaWxkIDUuMjUgYW5kIDIuNjJtcworICogZmVhc2libGUgYXJlIHRoZSA0MDk2IGFuZCB0aGUgMjA0OCBkaXZpc29ycywgd2hpY2ggeWllbGQgNS4yNSBhbmQgMi42Mm1zCiAgKiBvdmVyZmxvdyBwZXJpb2RzIHJlc3BlY3RpdmVseS4KICAqCiAgKiBBbHNvLCBzaW5jZSB3ZSBjYW4ndCByZWFsbHkgZXhwZWN0IHVzZXJzcGFjZSB0byBiZSByZXNwb25zaXZlIGVub3VnaApkaWZmIC0tZ2l0IGEvZHJpdmVycy93YXRjaGRvZy9zbXNjMzdiNzg3X3dkdC5jIGIvZHJpdmVycy93YXRjaGRvZy9zbXNjMzdiNzg3X3dkdC5jCmluZGV4IGRmODhjZmEuLmU5N2IwNDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvd2F0Y2hkb2cvc21zYzM3Yjc4N193ZHQuYworKysgYi9kcml2ZXJzL3dhdGNoZG9nL3Ntc2MzN2I3ODdfd2R0LmMKQEAgLTE5MSw3ICsxOTEsNyBAQAogc3RhdGljIGlubGluZSB2b2lkIHdkdF90aW1lcl9jdHJsKHVuc2lnbmVkIGNoYXIgcmVnKQogewogCS8qIC0tIFdhdGNoZG9nIHRpbWVyIGNvbnRyb2wgLS0KLQkgKiBCaXQgMCAgIFN0YXR1cyBCaXQ6IDAgPSBUaW1lciBjb3VudGluZywgMSA9IFRpbWVvdXQgb2NjdXJlZAorCSAqIEJpdCAwICAgU3RhdHVzIEJpdDogMCA9IFRpbWVyIGNvdW50aW5nLCAxID0gVGltZW91dCBvY2N1cnJlZAogCSAqIEJpdCAxICAgUG93ZXIgTEVEIFRvZ2dsZTogMCA9IERpc2FibGUgVG9nZ2xlLCAxID0gVG9nZ2xlIGF0IDEgSHoKIAkgKiBCaXQgMiAgIEZvcmNlIFRpbWVvdXQ6IDEgPSBGb3JjZXMgV0QgdGltZW91dCBldmVudCAoc2VsZi1jbGVhbmluZykKIAkgKiBCaXQgMyAgIFAyMCBGb3JjZSBUaW1lb3V0IGVuYWJsZWQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL3NwODA1X3dkdC5jIGIvZHJpdmVycy93YXRjaGRvZy9zcDgwNV93ZHQuYwppbmRleCAwYTBlZmU3Li4wZDgwZTA4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3dhdGNoZG9nL3NwODA1X3dkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvc3A4MDVfd2R0LmMKQEAgLTkwLDcgKzkwLDcgQEAKIAkvKgogCSAqIHNwODA1IHJ1bnMgY291bnRlciB3aXRoIGdpdmVuIHZhbHVlIHR3aWNlLCBhZnRlciB0aGUgZW5kIG9mIGZpcnN0CiAJICogY291bnRlciBpdCBnaXZlcyBhbiBpbnRlcnJ1cHQgYW5kIHRoZW4gc3RhcnRzIGNvdW50ZXIgYWdhaW4uIElmCi0JICogaW50ZXJydXB0IGFscmVhZHkgb2NjdXJlZCB0aGVuIGl0IHJlc2V0cyB0aGUgc3lzdGVtLiBUaGlzIGlzIHdoeQorCSAqIGludGVycnVwdCBhbHJlYWR5IG9jY3VycmVkIHRoZW4gaXQgcmVzZXRzIHRoZSBzeXN0ZW0uIFRoaXMgaXMgd2h5CiAJICogbG9hZCBpcyBoYWxmIG9mIHdoYXQgc2hvdWxkIGJlIHJlcXVpcmVkLgogCSAqLwogCWxvYWQgPSBkaXZfdTY0KHJhdGUsIDIpICogdGltZW91dCAtIDE7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9ldmVudHMuYyBiL2RyaXZlcnMveGVuL2V2ZW50cy5jCmluZGV4IDAzNjM0M2JhLi40MmQ2YzkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9ldmVudHMuYworKysgYi9kcml2ZXJzL3hlbi9ldmVudHMuYwpAQCAtNSw3ICs1LDcgQEAKICAqIGRvbWFpbiBnZXRzIDEwMjQgZXZlbnQgY2hhbm5lbHMsIGJ1dCBOUl9JUlEgaXMgbm90IHRoYXQgbGFyZ2UsIHdlCiAgKiBtdXN0IGR5bmFtaWNhbGx5IG1hcCBpcnFzPC0+ZXZlbnQgY2hhbm5lbHMuICBUaGUgZXZlbnQgY2hhbm5lbHMKICAqIGludGVyZmFjZSB3aXRoIHRoZSByZXN0IG9mIHRoZSBrZXJuZWwgYnkgZGVmaW5pbmcgYSB4ZW4gaW50ZXJydXB0Ci0gKiBjaGlwLiAgV2hlbiBhbiBldmVudCBpcyByZWNpZXZlZCwgaXQgaXMgbWFwcGVkIHRvIGFuIGlycSBhbmQgc2VudAorICogY2hpcC4gIFdoZW4gYW4gZXZlbnQgaXMgcmVjZWl2ZWQsIGl0IGlzIG1hcHBlZCB0byBhbiBpcnEgYW5kIHNlbnQKICAqIHRocm91Z2ggdGhlIG5vcm1hbCBpbnRlcnJ1cHQgcHJvY2Vzc2luZyBwYXRoLgogICoKICAqIFRoZXJlIGFyZSBmb3VyIGtpbmRzIG9mIGV2ZW50cyB3aGljaCBjYW4gYmUgbWFwcGVkIHRvIGFuIGV2ZW50CkBAIC00MTYsNyArNDE2LDcgQEAKICNpZmRlZiBDT05GSUdfWDg2X0lPX0FQSUMKIAkvKgogCSAqIEZvciBhbiBIVk0gZ3Vlc3Qgb3IgZG9tYWluIDAgd2hpY2ggc2VlICJyZWFsIiAoZW11bGF0ZWQgb3IKLQkgKiBhY3R1YWwgcmVwZWN0aXZlbHkpIEdTSXMgd2UgYWxsb2NhdGUgZHluYW1pYyBJUlFzCisJICogYWN0dWFsIHJlc3BlY3RpdmVseSkgR1NJcyB3ZSBhbGxvY2F0ZSBkeW5hbWljIElSUXMKIAkgKiBlLmcuIHRob3NlIGNvcnJlc3BvbmRpbmcgdG8gZXZlbnQgY2hhbm5lbHMgb3IgTVNJcwogCSAqIGV0Yy4gZnJvbSB0aGUgcmFuZ2UgYWJvdmUgdGhvc2UgInJlYWwiIEdTSXMgdG8gYXZvaWQKIAkgKiBjb2xsaXNpb25zLgpkaWZmIC0tZ2l0IGEvZnMvYWRmcy9tYXAuYyBiL2ZzL2FkZnMvbWFwLmMKaW5kZXggZDFhNTkzMi4uNjkzNWYwNSAxMDA2NDQKLS0tIGEvZnMvYWRmcy9tYXAuYworKysgYi9mcy9hZGZzL21hcC5jCkBAIC01MSw3ICs1MSw3IEBACiAKIC8qCiAgKiBUaGlzIGlzIGZ1bi4gIFdlIG5lZWQgdG8gbG9hZCB1cCB0byAxOSBiaXRzIGZyb20gdGhlIG1hcCBhdCBhbgotICogYXJiaXRhcnkgYml0IGFsaWdubWVudC4gIChXZSdyZSBsaW1pdGVkIHRvIDE5IGJpdHMgYnkgRisgdmVyc2lvbiAyKS4KKyAqIGFyYml0cmFyeSBiaXQgYWxpZ25tZW50LiAgKFdlJ3JlIGxpbWl0ZWQgdG8gMTkgYml0cyBieSBGKyB2ZXJzaW9uIDIpLgogICovCiAjZGVmaW5lIEdFVF9GUkFHX0lEKF9tYXAsX3N0YXJ0LF9pZG1hc2spCQkJCVwKIAkoewkJCQkJCQkJXApkaWZmIC0tZ2l0IGEvZnMvYWZzL2NhY2hlLmMgYi9mcy9hZnMvY2FjaGUuYwppbmRleCAwZmIzMTVkLi41Nzc3NjNjIDEwMDY0NAotLS0gYS9mcy9hZnMvY2FjaGUuYworKysgYi9mcy9hZnMvY2FjaGUuYwpAQCAtOTgsNyArOTgsNyBAQAogfQogCiAvKgotICogcHJvdmlkZSBuZXcgYXV4aWxsaWFyeSBjYWNoZSBkYXRhCisgKiBwcm92aWRlIG5ldyBhdXhpbGlhcnkgY2FjaGUgZGF0YQogICovCiBzdGF0aWMgdWludDE2X3QgYWZzX2NlbGxfY2FjaGVfZ2V0X2F1eChjb25zdCB2b2lkICpjb29raWVfbmV0ZnNfZGF0YSwKIAkJCQkgICAgICAgdm9pZCAqYnVmZmVyLCB1aW50MTZfdCBidWZtYXgpCkBAIC0xMTcsNyArMTE3LDcgQEAKIH0KIAogLyoKLSAqIGNoZWNrIHRoYXQgdGhlIGF1eGlsbGlhcnkgZGF0YSBpbmRpY2F0ZXMgdGhhdCB0aGUgZW50cnkgaXMgc3RpbGwgdmFsaWQKKyAqIGNoZWNrIHRoYXQgdGhlIGF1eGlsaWFyeSBkYXRhIGluZGljYXRlcyB0aGF0IHRoZSBlbnRyeSBpcyBzdGlsbCB2YWxpZAogICovCiBzdGF0aWMgZW51bSBmc2NhY2hlX2NoZWNrYXV4IGFmc19jZWxsX2NhY2hlX2NoZWNrX2F1eCh2b2lkICpjb29raWVfbmV0ZnNfZGF0YSwKIAkJCQkJCSAgICAgIGNvbnN0IHZvaWQgKmJ1ZmZlciwKQEAgLTE1MCw3ICsxNTAsNyBAQAogfQogCiAvKgotICogcHJvdmlkZSBuZXcgYXV4aWxsaWFyeSBjYWNoZSBkYXRhCisgKiBwcm92aWRlIG5ldyBhdXhpbGlhcnkgY2FjaGUgZGF0YQogICovCiBzdGF0aWMgdWludDE2X3QgYWZzX3Zsb2NhdGlvbl9jYWNoZV9nZXRfYXV4KGNvbnN0IHZvaWQgKmNvb2tpZV9uZXRmc19kYXRhLAogCQkJCQkgICAgdm9pZCAqYnVmZmVyLCB1aW50MTZfdCBidWZtYXgpCkBAIC0xNzIsNyArMTcyLDcgQEAKIH0KIAogLyoKLSAqIGNoZWNrIHRoYXQgdGhlIGF1eGlsbGlhcnkgZGF0YSBpbmRpY2F0ZXMgdGhhdCB0aGUgZW50cnkgaXMgc3RpbGwgdmFsaWQKKyAqIGNoZWNrIHRoYXQgdGhlIGF1eGlsaWFyeSBkYXRhIGluZGljYXRlcyB0aGF0IHRoZSBlbnRyeSBpcyBzdGlsbCB2YWxpZAogICovCiBzdGF0aWMKIGVudW0gZnNjYWNoZV9jaGVja2F1eCBhZnNfdmxvY2F0aW9uX2NhY2hlX2NoZWNrX2F1eCh2b2lkICpjb29raWVfbmV0ZnNfZGF0YSwKQEAgLTI4Myw3ICsyODMsNyBAQAogfQogCiAvKgotICogcHJvdmlkZSBuZXcgYXV4aWxsaWFyeSBjYWNoZSBkYXRhCisgKiBwcm92aWRlIG5ldyBhdXhpbGlhcnkgY2FjaGUgZGF0YQogICovCiBzdGF0aWMgdWludDE2X3QgYWZzX3Zub2RlX2NhY2hlX2dldF9hdXgoY29uc3Qgdm9pZCAqY29va2llX25ldGZzX2RhdGEsCiAJCQkJCXZvaWQgKmJ1ZmZlciwgdWludDE2X3QgYnVmbWF4KQpAQCAtMzA5LDcgKzMwOSw3IEBACiB9CiAKIC8qCi0gKiBjaGVjayB0aGF0IHRoZSBhdXhpbGxpYXJ5IGRhdGEgaW5kaWNhdGVzIHRoYXQgdGhlIGVudHJ5IGlzIHN0aWxsIHZhbGlkCisgKiBjaGVjayB0aGF0IHRoZSBhdXhpbGlhcnkgZGF0YSBpbmRpY2F0ZXMgdGhhdCB0aGUgZW50cnkgaXMgc3RpbGwgdmFsaWQKICAqLwogc3RhdGljIGVudW0gZnNjYWNoZV9jaGVja2F1eCBhZnNfdm5vZGVfY2FjaGVfY2hlY2tfYXV4KHZvaWQgKmNvb2tpZV9uZXRmc19kYXRhLAogCQkJCQkJICAgICAgIGNvbnN0IHZvaWQgKmJ1ZmZlciwKZGlmZiAtLWdpdCBhL2ZzL2Fmcy9jZWxsLmMgYi9mcy9hZnMvY2VsbC5jCmluZGV4IDBkNWVlYWQuLjNjMDkwYjcgMTAwNjQ0Ci0tLSBhL2ZzL2Fmcy9jZWxsLmMKKysrIGIvZnMvYWZzL2NlbGwuYwpAQCAtMjkzLDcgKzI5Myw3IEBACiAJCWlmICghY2VsbCkgewogCQkJLyogdGhpcyBzaG91bGQgbm90IGhhcHBlbiB1bmxlc3MgdXNlciB0cmllcyB0byBtb3VudAogCQkJICogd2hlbiByb290IGNlbGwgaXMgbm90IHNldC4gUmV0dXJuIGFuIGltcG9zc2libHkKLQkJCSAqIGJpenphcmUgZXJybm8gdG8gYWxlcnQgdGhlIHVzZXIuIFRoaW5ncyBsaWtlCisJCQkgKiBiaXphcnJlIGVycm5vIHRvIGFsZXJ0IHRoZSB1c2VyLiBUaGluZ3MgbGlrZQogCQkJICogRU5PRU5UIG1pZ2h0IGJlICJtb3JlIGFwcHJvcHJpYXRlIiBidXQgdGhleSBoYXBwZW4KIAkJCSAqIGZvciBvdGhlciByZWFzb25zLgogCQkJICovCmRpZmYgLS1naXQgYS9mcy9hdHRyLmMgYi9mcy9hdHRyLmMKaW5kZXggMTAwN2VkNi4uOTFkYmUyYSAxMDA2NDQKLS0tIGEvZnMvYXR0ci5jCisrKyBiL2ZzL2F0dHIuYwpAQCAtMTI4LDcgKzEyOCw3IEBACiAgKiBzZXRhdHRyX2NvcHkgbXVzdCBiZSBjYWxsZWQgd2l0aCBpX211dGV4IGhlbGQuCiAgKgogICogc2V0YXR0cl9jb3B5IHVwZGF0ZXMgdGhlIGlub2RlJ3MgbWV0YWRhdGEgd2l0aCB0aGF0IHNwZWNpZmllZAotICogaW4gYXR0ci4gTm90aWNhYmx5IG1pc3NpbmcgaXMgaW5vZGUgc2l6ZSB1cGRhdGUsIHdoaWNoIGlzIG1vcmUgY29tcGxleAorICogaW4gYXR0ci4gTm90aWNlYWJseSBtaXNzaW5nIGlzIGlub2RlIHNpemUgdXBkYXRlLCB3aGljaCBpcyBtb3JlIGNvbXBsZXgKICAqIGFzIGl0IHJlcXVpcmVzIHBhZ2VjYWNoZSB1cGRhdGVzLgogICoKICAqIFRoZSBpbm9kZSBpcyBub3QgbWFya2VkIGFzIGRpcnR5IGFmdGVyIHRoaXMgb3BlcmF0aW9uLiBUaGUgcmF0aW9uYWxlIGlzCmRpZmYgLS1naXQgYS9mcy9hdXRvZnM0L3Jvb3QuYyBiL2ZzL2F1dG9mczQvcm9vdC5jCmluZGV4IDk2ODA0YTEuLmY1NWFlMjMgMTAwNjQ0Ci0tLSBhL2ZzL2F1dG9mczQvcm9vdC5jCisrKyBiL2ZzL2F1dG9mczQvcm9vdC5jCkBAIC02MTIsNyArNjEyLDcgQEAKICAqIHNldCB0aGUgRE1BTkFHRURfQVVUT01PVU5UIGFuZCBETUFOQUdFRF9UUkFOU0lUIGZsYWdzIG9uIHRoZSBsZWF2ZXMKICAqIG9mIHRoZSBkaXJlY3RvcnkgdHJlZS4gVGhlcmUgaXMgbm8gbmVlZCB0byBjbGVhciB0aGUgYXV0b21vdW50IGZsYWcKICAqIGZvbGxvd2luZyBhIG1vdW50IG9yIHJlc3RvcmUgaXQgYWZ0ZXIgYW4gZXhwaXJlIGJlY2F1c2UgdGhlc2UgbW91bnRzCi0gKiBhcmUgYWx3YXlzIGNvdmVyZWQuIEhvd2V2ZXIsIGl0IGlzIG5lY2Nlc3NhcnkgdG8gZW5zdXJlIHRoYXQgdGhlc2UKKyAqIGFyZSBhbHdheXMgY292ZXJlZC4gSG93ZXZlciwgaXQgaXMgbmVjZXNzYXJ5IHRvIGVuc3VyZSB0aGF0IHRoZXNlCiAgKiBmbGFncyBhcmUgY2xlYXIgb24gbm9uLWVtcHR5IGRpcmVjdG9yaWVzIHRvIGF2b2lkIHVubmVjZXNzYXJ5IGNhbGxzCiAgKiBkdXJpbmcgcGF0aCB3YWxrcy4KICAqLwpkaWZmIC0tZ2l0IGEvZnMvYmVmcy9DaGFuZ2VMb2cgYi9mcy9iZWZzL0NoYW5nZUxvZwppbmRleCBjZThjNzg3Li43NWE0NjFjIDEwMDY0NAotLS0gYS9mcy9iZWZzL0NoYW5nZUxvZworKysgYi9mcy9iZWZzL0NoYW5nZUxvZwpAQCAtMjQsNyArMjQsNyBAQAogCiBWZXJzaW9uIDAuNjQgKDIwMDItMDItMDcpCiA9PT09PT09PT09Ci0qIERpZCB0aGUgc3RyaW5nIGNvbXBhcmlzaW9uIHJlYWxseSByaWdodCB0aGlzIHRpbWUgKGJ0cmVlLmMpIFtXRF0KKyogRGlkIHRoZSBzdHJpbmcgY29tcGFyaXNvbiByZWFsbHkgcmlnaHQgdGhpcyB0aW1lIChidHJlZS5jKSBbV0RdCiAKICogRml4ZWQgdXAgc29tZSBwbGFjZXMgd2hlcmUgSSBhc3N1bWVkIHRoYXQgYSBsb25nIGludCBjb3VsZCBob2xkCiAJYSBwb2ludGVyIHZhbHVlLiAoYnRyZWUuYykgW1dEXQpAQCAtMTE0LDcgKzExNCw3IEBACiAJTW9yZSBmbGV4aWJsZS4gV2lsbCBzb29uIGJlIGNvbnRyb2xsYWJsZSBhdCBtb3VudCB0aW1lIAogCShzZWUgVE9ETykuIFtXRF0KIAotKiBSZXdyb3RlIGRhdGFzdHJlYW0gcG9zaXRvbiBsb29rdXBzLgorKiBSZXdyb3RlIGRhdGFzdHJlYW0gcG9zaXRpb24gbG9va3Vwcy4KIAkoZGF0YXN0cmVhbS5jKSBbV0RdCiAKICogTW92ZWQgdGhlIFRPRE8gbGlzdCB0byBpdHMgb3duIGZpbGUuCkBAIC0xNTAsNyArMTUwLDcgQEAKICogQW50b24gYWxzbyB0b2xkIG1lIHRoYXQgdGhlIGJsb2Nrc2l6ZSBpcyBub3QgYWxsb3dlZCB0byBiZSBsYXJnZXIgdGhhbiAKIAl0aGUgcGFnZSBzaXplIGluIGxpbnV4LCB3aGljaCBpcyA0ayBpMzg2LiBPb3BzLiBBZGRlZCBhIHRlc3QgZm9yIAogCShibG9ja3NpemUgPiBQQUdFX1NJWkUpLCBhbmQgcmVmdXNlIHRvIG1vdW50IGluIHRoYXQgY2FzZS4gV2hhdCB0aGlzIAotCXByYWN0aWNhbHkgbWVhbnMgaXMgdGhhdCA4ayBibG9ja3NpemUgdm9sdW1lcyB3b24ndCB3b3JrIHdpdGhvdXQgYSBtYWpvcgorCXByYWN0aWNhbGx5IG1lYW5zIGlzIHRoYXQgOGsgYmxvY2tzaXplIHZvbHVtZXMgd29uJ3Qgd29yayB3aXRob3V0IGEgbWFqb3IKIAlyZXN0cnVjdHVyaW5nIG9mIHRoZSBkcml2ZXIgKG9yIGFuIGFscGhhIG9yIG90aGVyIDY0Yml0IGhhcmR3YXJlKS4gW1dEXQogCiAqIENsZWFuZWQgdXAgdGhlIGJlZnNfY291bnRfYmxvY2tzKCkgZnVuY3Rpb24uIE11Y2ggc21hcnRlciBub3cuIApAQCAtMTgzLDcgKzE4Myw3IEBACiAJc3RydWN0dXJlcyBpbnRvIHRoZSBnZW5lcmljIHBvaW50ZXIgZmllbGRzIG9mIHRoZSBwdWJsaWMgc3RydWN0dXJlcyAKIAl3aXRoIGttYWxsb2MoKS4gcHV0X3N1cGVyIGFuZCBwdXRfaW5vZGUgZnJlZSB0aGVtLiBUaGlzIGFsbG93cyB1cyBub3QgCiAJdG8gaGF2ZSB0byB0b3VjaCB0aGUgZGVmaW5pdGlvbnMgb2YgdGhlIHB1YmxpYyBzdHJ1Y3R1cmVzIGluIAotCWluY2x1ZGUvbGludXgvZnMuaC4gQWxzbywgYmVmc19pbm9kZV9pbmZvIGlzIGh1Z2UgKGJlY3Vhc2Ugb2YgdGhlIAorCWluY2x1ZGUvbGludXgvZnMuaC4gQWxzbywgYmVmc19pbm9kZV9pbmZvIGlzIGh1Z2UgKGJlY2F1c2Ugb2YgdGhlIAogCXN5bWxpbmsgc3RyaW5nKS4gKHN1cGVyLmMsIGlub2RlLmMsIGJlZnNfZnMuaCkgW1dEXQogCiAqIEZpeGVkIGEgdGhpbmtvIHRoYXQgd2FzIGNvcnJ1cHRpbmcgZmlsZSByZWFkcyBhZnRlciB0aGUgZmlyc3QgYmxvY2tfcnVuIApAQCAtNDA0LDcgKzQwNCw3IEBACiAKICogRml4ZWQgY29tcGlsZSBlcnJvcnMgb24gMi40LjEga2VybmVsIChXRCkKIAlSZXNvbHZlIHJlamVjdGVkIHBhdGNoZXMKLQlBY2NvbW9kYXRlIGNoYW5nZWQgTkxTIGludGVyZmFjZSAodXRpbC5oKQorCUFjY29tbW9kYXRlIGNoYW5nZWQgTkxTIGludGVyZmFjZSAodXRpbC5oKQogCU5lZWRlZCB0byBpbmNsdWRlIDxsaW51eC9zbGFiLmg+IGluIG1vc3QgZmlsZXMKIAlNYWtlZmlsZSBjaGFuZ2VzCiAJZnMvQ29uZmlnLmluIGNoYW5nZXMKZGlmZiAtLWdpdCBhL2ZzL2JlZnMvYmVmc19mc190eXBlcy5oIGIvZnMvYmVmcy9iZWZzX2ZzX3R5cGVzLmgKaW5kZXggNzg5M2VhYS4uZWI1NTdkOSAxMDA2NDQKLS0tIGEvZnMvYmVmcy9iZWZzX2ZzX3R5cGVzLmgKKysrIGIvZnMvYmVmcy9iZWZzX2ZzX3R5cGVzLmgKQEAgLTIzNCw3ICsyMzQsNyBAQAogfSBQQUNLRUQgYmVmc19idHJlZV9zdXBlcjsKIAogLyoKLSAqIEhlYWRlciBzdHVjdHVyZSBvZiBlYWNoIGJ0cmVlIG5vZGUKKyAqIEhlYWRlciBzdHJ1Y3R1cmUgb2YgZWFjaCBidHJlZSBub2RlCiAgKi8KIHR5cGVkZWYgc3RydWN0IHsKIAlmczY0IGxlZnQ7CmRpZmYgLS1naXQgYS9mcy9iZWZzL2J0cmVlLmMgYi9mcy9iZWZzL2J0cmVlLmMKaW5kZXggNDIwMmRiNy4uYTY2YzliMSAxMDA2NDQKLS0tIGEvZnMvYmVmcy9idHJlZS5jCisrKyBiL2ZzL2JlZnMvYnRyZWUuYwpAQCAtNSw3ICs1LDcgQEAKICAqCiAgKiBMaWNlbnNlZCB1bmRlciB0aGUgR05VIEdQTC4gU2VlIHRoZSBmaWxlIENPUFlJTkcgZm9yIGRldGFpbHMuCiAgKgotICogMjAwMi0wMi0wNTogU2VyZ2V5IFMuIEtvc3R5bGlvdiBhZGRlZCBiaW5hcnkgc2VhcmNoIHdpdGhpbmcKKyAqIDIwMDItMDItMDU6IFNlcmdleSBTLiBLb3N0eWxpb3YgYWRkZWQgYmluYXJ5IHNlYXJjaCB3aXRoaW4KICAqIAkJYnRyZWUgbm9kZXMuCiAgKgogICogTWFueSB0aGFua3MgdG86CmRpZmYgLS1naXQgYS9mcy9iZWZzL2xpbnV4dmZzLmMgYi9mcy9iZWZzL2xpbnV4dmZzLmMKaW5kZXggMDY0NTdlZC4uNTRiOGMyOCAxMDA2NDQKLS0tIGEvZnMvYmVmcy9saW51eHZmcy5jCisrKyBiL2ZzL2JlZnMvbGludXh2ZnMuYwpAQCAtNzM0LDcgKzczNCw3IEBACiAKIC8qIFRoaXMgZnVuY3Rpb24gaGFzIHRoZSByZXNwb25zaWJpbHRpeSBvZiBnZXR0aW5nIHRoZQogICogZmlsZXN5c3RlbSByZWFkeSBmb3IgdW5tb3VudGluZy4gCi0gKiBCYXNpY2x5LCB3ZSBmcmVlIGV2ZXJ5dGhpbmcgdGhhdCB3ZSBhbGxvY2F0ZWQgaW4KKyAqIEJhc2ljYWxseSwgd2UgZnJlZSBldmVyeXRoaW5nIHRoYXQgd2UgYWxsb2NhdGVkIGluCiAgKiBiZWZzX3JlYWRfaW5vZGUKICAqLwogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2ZzL2JpbmZtdF9mbGF0LmMgYi9mcy9iaW5mbXRfZmxhdC5jCmluZGV4IDgxMTM4NGIuLjM5N2QzMDUgMTAwNjQ0Ci0tLSBhL2ZzL2JpbmZtdF9mbGF0LmMKKysrIGIvZnMvYmluZm10X2ZsYXQuYwpAQCAtNzE3LDcgKzcxNyw3IEBACiAJICogaGVscCBzaW1wbGlmeSBhbGwgdGhpcyBtdW1ibyBqdW1ibwogCSAqCiAJICogV2UndmUgZ290IHR3byBkaWZmZXJlbnQgc2VjdGlvbnMgb2YgcmVsb2NhdGlvbiBlbnRyaWVzLgotCSAqIFRoZSBmaXJzdCBpcyB0aGUgR09UIHdoaWNoIHJlc2lkZXMgYXQgdGhlIGJlZ2luaW5nIG9mIHRoZSBkYXRhIHNlZ21lbnQKKwkgKiBUaGUgZmlyc3QgaXMgdGhlIEdPVCB3aGljaCByZXNpZGVzIGF0IHRoZSBiZWdpbm5pbmcgb2YgdGhlIGRhdGEgc2VnbWVudAogCSAqIGFuZCBpcyB0ZXJtaW5hdGVkIHdpdGggYSAtMS4gIFRoaXMgb25lIGNhbiBiZSByZWxvY2F0ZWQgaW4gcGxhY2UuCiAJICogVGhlIHNlY29uZCBpcyB0aGUgZXh0cmEgcmVsb2NhdGlvbiBlbnRyaWVzIHRhY2tlZCBhZnRlciB0aGUgaW1hZ2UncwogCSAqIGRhdGEgc2VnbWVudC4gVGhlc2UgcmVxdWlyZSBhIGxpdHRsZSBtb3JlIHByb2Nlc3NpbmcgYXMgdGhlIGVudHJ5IGlzCmRpZmYgLS1naXQgYS9mcy9iaW8uYyBiL2ZzL2Jpby5jCmluZGV4IDRkNmQ0YjYuLjg0MGEwZDcgMTAwNjQ0Ci0tLSBhL2ZzL2Jpby5jCisrKyBiL2ZzL2Jpby5jCkBAIC0xNDM2LDcgKzE0MzYsNyBAQAogICogICBwcmVmZXJyZWQgd2F5IHRvIGVuZCBJL08gb24gYSBiaW8sIGl0IHRha2VzIGNhcmUgb2YgY2xlYXJpbmcKICAqICAgQklPX1VQVE9EQVRFIG9uIGVycm9yLiBAZXJyb3IgaXMgMCBvbiBzdWNjZXNzLCBhbmQgYW5kIG9uZSBvZiB0aGUKICAqICAgZXN0YWJsaXNoZWQgLUV4eHh4ICgtRUlPLCBmb3IgaW5zdGFuY2UpIGVycm9yIHZhbHVlcyBpbiBjYXNlCi0gKiAgIHNvbWV0aGluZyB3ZW50IHdyb25nLiBOb29uZSBzaG91bGQgY2FsbCBiaV9lbmRfaW8oKSBkaXJlY3RseSBvbiBhCisgKiAgIHNvbWV0aGluZyB3ZW50IHdyb25nLiBObyBvbmUgc2hvdWxkIGNhbGwgYmlfZW5kX2lvKCkgZGlyZWN0bHkgb24gYQogICogICBiaW8gdW5sZXNzIHRoZXkgb3duIGl0IGFuZCB0aHVzIGtub3cgdGhhdCBpdCBoYXMgYW4gZW5kX2lvCiAgKiAgIGZ1bmN0aW9uLgogICoqLwpkaWZmIC0tZ2l0IGEvZnMvYmxvY2tfZGV2LmMgYi9mcy9ibG9ja19kZXYuYwppbmRleCBjMTUxMWM2Li41MTQ3YmRkIDEwMDY0NAotLS0gYS9mcy9ibG9ja19kZXYuYworKysgYi9mcy9ibG9ja19kZXYuYwpAQCAtNjUzLDcgKzY1Myw3IEBACiAgKiBAd2hvbGU6IHdob2xlIGJsb2NrIGRldmljZSBjb250YWluaW5nIEBiZGV2LCBtYXkgZXF1YWwgQGJkZXYKICAqIEBob2xkZXI6IGhvbGRlciB0cnlpbmcgdG8gY2xhaW0gQGJkZXYKICAqCi0gKiBUZXN0IHdodGhlciBAYmRldiBjYW4gYmUgY2xhaW1lZCBieSBAaG9sZGVyLgorICogVGVzdCB3aGV0aGVyIEBiZGV2IGNhbiBiZSBjbGFpbWVkIGJ5IEBob2xkZXIuCiAgKgogICogQ09OVEVYVDoKICAqIHNwaW5fbG9jaygmYmRldl9sb2NrKS4KZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2V4dGVudF9tYXAuYyBiL2ZzL2J0cmZzL2V4dGVudF9tYXAuYwppbmRleCAyYjZjMTJlLi5hMjRhM2YyIDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHRlbnRfbWFwLmMKKysrIGIvZnMvYnRyZnMvZXh0ZW50X21hcC5jCkBAIC0yNDMsNyArMjQzLDcgQEAKICAqIEluc2VydCBAZW0gaW50byBAdHJlZSBvciBwZXJmb3JtIGEgc2ltcGxlIGZvcndhcmQvYmFja3dhcmQgbWVyZ2Ugd2l0aAogICogZXhpc3RpbmcgbWFwcGluZ3MuICBUaGUgZXh0ZW50X21hcCBzdHJ1Y3QgcGFzc2VkIGluIHdpbGwgYmUgaW5zZXJ0ZWQKICAqIGludG8gdGhlIHRyZWUgZGlyZWN0bHksIHdpdGggYW4gYWRkaXRpb25hbCByZWZlcmVuY2UgdGFrZW4sIG9yIGEKLSAqIHJlZmVyZW5jZSBkcm9wcGVkIGlmIHRoZSBtZXJnZSBhdHRlbXB0IHdhcyBzdWNjZXNzZnVsbC4KKyAqIHJlZmVyZW5jZSBkcm9wcGVkIGlmIHRoZSBtZXJnZSBhdHRlbXB0IHdhcyBzdWNjZXNzZnVsLgogICovCiBpbnQgYWRkX2V4dGVudF9tYXBwaW5nKHN0cnVjdCBleHRlbnRfbWFwX3RyZWUgKnRyZWUsCiAJCSAgICAgICBzdHJ1Y3QgZXh0ZW50X21hcCAqZW0pCmRpZmYgLS1naXQgYS9mcy9idHJmcy9pbm9kZS5jIGIvZnMvYnRyZnMvaW5vZGUuYwppbmRleCA2NTQxMzM5Li41Y2M2NGFiIDEwMDY0NAotLS0gYS9mcy9idHJmcy9pbm9kZS5jCisrKyBiL2ZzL2J0cmZzL2lub2RlLmMKQEAgLTIzMjEsNyArMjMyMSw3IEBACiAKIAkJLyoKIAkJICogaWYgcmV0ID09IDAgbWVhbnMgd2UgZm91bmQgd2hhdCB3ZSB3ZXJlIHNlYXJjaGluZyBmb3IsIHdoaWNoCi0JCSAqIGlzIHdlaXJkLCBidXQgcG9zc2libGUsIHNvIG9ubHkgc2NyZXcgd2l0aCBwYXRoIGlmIHdlIGRpZG50CisJCSAqIGlzIHdlaXJkLCBidXQgcG9zc2libGUsIHNvIG9ubHkgc2NyZXcgd2l0aCBwYXRoIGlmIHdlIGRpZG4ndAogCQkgKiBmaW5kIHRoZSBrZXkgYW5kIHNlZSBpZiB3ZSBoYXZlIHN0dWZmIHRoYXQgbWF0Y2hlcwogCQkgKi8KIAkJaWYgKHJldCA+IDApIHsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3JlbG9jYXRpb24uYyBiL2ZzL2J0cmZzL3JlbG9jYXRpb24uYwppbmRleCA1ODI1MGUwLi4xOTlhODAxIDEwMDY0NAotLS0gYS9mcy9idHJmcy9yZWxvY2F0aW9uLmMKKysrIGIvZnMvYnRyZnMvcmVsb2NhdGlvbi5jCkBAIC0yMzQ2LDcgKzIzNDYsNyBAQAogCQlyb290ID0gbmV4dC0+cm9vdDsKIAkJQlVHX09OKCFyb290KTsKIAotCQkvKiBubyBvdGhlciBjaG9pY2UgZm9yIG5vbi1yZWZlcm5jZSBjb3VudGVkIHRyZWUgKi8KKwkJLyogbm8gb3RoZXIgY2hvaWNlIGZvciBub24tcmVmZXJlbmNlcyBjb3VudGVkIHRyZWUgKi8KIAkJaWYgKCFyb290LT5yZWZfY293cykKIAkJCXJldHVybiByb290OwogCmRpZmYgLS1naXQgYS9mcy9jYWNoZWZpbGVzL2ludGVyZmFjZS5jIGIvZnMvY2FjaGVmaWxlcy9pbnRlcmZhY2UuYwppbmRleCAzN2ZlMTAxLi4xMDY0ODA1IDEwMDY0NAotLS0gYS9mcy9jYWNoZWZpbGVzL2ludGVyZmFjZS5jCisrKyBiL2ZzL2NhY2hlZmlsZXMvaW50ZXJmYWNlLmMKQEAgLTE5Nyw3ICsxOTcsNyBAQAogfQogCiAvKgotICogdXBkYXRlIHRoZSBhdXhpbGxpYXJ5IGRhdGEgZm9yIGFuIG9iamVjdCBvYmplY3Qgb24gZGlzaworICogdXBkYXRlIHRoZSBhdXhpbGlhcnkgZGF0YSBmb3IgYW4gb2JqZWN0IG9iamVjdCBvbiBkaXNrCiAgKi8KIHN0YXRpYyB2b2lkIGNhY2hlZmlsZXNfdXBkYXRlX29iamVjdChzdHJ1Y3QgZnNjYWNoZV9vYmplY3QgKl9vYmplY3QpCiB7CmRpZmYgLS1naXQgYS9mcy9jZXBoL2FkZHIuYyBiL2ZzL2NlcGgvYWRkci5jCmluZGV4IDM3MzY4YmEuLmUxNTljNTIgMTAwNjQ0Ci0tLSBhL2ZzL2NlcGgvYWRkci5jCisrKyBiL2ZzL2NlcGgvYWRkci5jCkBAIC0yNCw3ICsyNCw3IEBACiAgKiBjb250ZXh0IG5lZWRzIHRvIGJlIGFzc29jaWF0ZWQgd2l0aCB0aGUgb3NkIHdyaXRlIGR1cmluZyB3cml0ZWJhY2suCiAgKgogICogU2ltaWxhcmx5LCBzdHJ1Y3QgY2VwaF9pbm9kZV9pbmZvIG1haW50YWlucyBhIHNldCBvZiBjb3VudGVycyB0bwotICogY291bnQgZGlydHkgcGFnZXMgb24gdGhlIGlub2RlLiAgSW4gdGhlIGFic2Vuc2Ugb2Ygc25hcHNob3RzLAorICogY291bnQgZGlydHkgcGFnZXMgb24gdGhlIGlub2RlLiAgSW4gdGhlIGFic2VuY2Ugb2Ygc25hcHNob3RzLAogICogaV93cmJ1ZmZlcl9yZWYgPT0gaV93cmJ1ZmZlcl9yZWZfaGVhZCA9PSB0aGUgZGlydHkgcGFnZSBjb3VudC4KICAqCiAgKiBXaGVuIGEgc25hcHNob3QgaXMgdGFrZW4gKHRoYXQgaXMsIHdoZW4gdGhlIGNsaWVudCByZWNlaXZlcwpkaWZmIC0tZ2l0IGEvZnMvY2VwaC9jYXBzLmMgYi9mcy9jZXBoL2NhcHMuYwppbmRleCA2YjYxZGVkLi41MzIzYzMzIDEwMDY0NAotLS0gYS9mcy9jZXBoL2NhcHMuYworKysgYi9mcy9jZXBoL2NhcHMuYwpAQCAtNzY1LDcgKzc2NSw3IEBACiAJCQlpZiAodG91Y2gpIHsKIAkJCQlzdHJ1Y3QgcmJfbm9kZSAqcTsKIAotCQkJCS8qIHRvdWNoIHRoaXMgKyBwcmVjZWVkaW5nIGNhcHMgKi8KKwkJCQkvKiB0b3VjaCB0aGlzICsgcHJlY2VkaW5nIGNhcHMgKi8KIAkJCQlfX3RvdWNoX2NhcChjYXApOwogCQkJCWZvciAocSA9IHJiX2ZpcnN0KCZjaS0+aV9jYXBzKTsgcSAhPSBwOwogCQkJCSAgICAgcSA9IHJiX25leHQocSkpIHsKZGlmZiAtLWdpdCBhL2ZzL2NlcGgvc25hcC5jIGIvZnMvY2VwaC9zbmFwLmMKaW5kZXggMGFlZTY2Yi4uZTg2ZWMxMSAxMDA2NDQKLS0tIGEvZnMvY2VwaC9zbmFwLmMKKysrIGIvZnMvY2VwaC9zbmFwLmMKQEAgLTM0Miw3ICszNDIsNyBAQAogCW51bSA9IDA7CiAJc25hcGMtPnNlcSA9IHJlYWxtLT5zZXE7CiAJaWYgKHBhcmVudCkgewotCQkvKiBpbmNsdWRlIGFueSBvZiBwYXJlbnQncyBzbmFwcyBvY2N1cmluZyBfYWZ0ZXJfIG15CisJCS8qIGluY2x1ZGUgYW55IG9mIHBhcmVudCdzIHNuYXBzIG9jY3VycmluZyBfYWZ0ZXJfIG15CiAJCSAgIHBhcmVudCBiZWNhbWUgbXkgcGFyZW50ICovCiAJCWZvciAoaSA9IDA7IGkgPCBwYXJlbnQtPmNhY2hlZF9jb250ZXh0LT5udW1fc25hcHM7IGkrKykKIAkJCWlmIChwYXJlbnQtPmNhY2hlZF9jb250ZXh0LT5zbmFwc1tpXSA+PQpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9BVVRIT1JTIGIvZnMvY2lmcy9BVVRIT1JTCmluZGV4IDdmN2ZhM2MuLmVhOTQwYjEgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvQVVUSE9SUworKysgYi9mcy9jaWZzL0FVVEhPUlMKQEAgLTM1LDcgKzM1LDcgQEAKIE1pa2xvcyBTemVyZWRpIAogS2F6ZW9uIHRlYW0gZm9yIHZhcmlvdXMgZml4ZXMgZXNwZWNpYWxseSBmb3IgMi40IHZlcnNpb24uCiBBc3NlciBGZXJubyAoQ2hhbmdlIE5vdGlmeSBzdXBwb3J0KQotU2hhZ2d5IChEYXZlIEtsZWlrYW1wKSBmb3IgaW51bWVyYWJsZSBzbWFsbCBmcyBzdWdnZXN0aW9ucyBhbmQgc29tZSBnb29kIGNsZWFudXAKK1NoYWdneSAoRGF2ZSBLbGVpa2FtcCkgZm9yIGlubnVtZXJhYmxlIHNtYWxsIGZzIHN1Z2dlc3Rpb25zIGFuZCBzb21lIGdvb2QgY2xlYW51cAogR3VudGVyIEt1a2t1a2sgKHRlc3RpbmcgYW5kIHN1Z2dlc3Rpb25zIGZvciBzdXBwb3J0IG9mIG9sZCBzZXJ2ZXJzKQogSWdvciBNYW1tZWRvdiAoREZTIHN1cHBvcnQpCiBKZWZmIExheXRvbiAobWFueSwgbWFueSBmaXhlcywgYXMgd2VsbCBhcyBncmVhdCB3b3JrIG9uIHRoZSBjaWZzIEtlcmJlcm9zIGNvZGUpCmRpZmYgLS1naXQgYS9mcy9jaWZzL2NpZnNfZGZzX3JlZi5jIGIvZnMvY2lmcy9jaWZzX2Rmc19yZWYuYwppbmRleCAwYTI2NWFkLi4yYjY4YWM1IDEwMDY0NAotLS0gYS9mcy9jaWZzL2NpZnNfZGZzX3JlZi5jCisrKyBiL2ZzL2NpZnMvY2lmc19kZnNfcmVmLmMKQEAgLTUzLDcgKzUzLDcgQEAKICAqCiAgKiBFeHRyYWN0cyBzaGFyZW5hbWUgZm9ybSBmdWxsIFVOQy4KICAqIGkuZS4gc3RyaXBzIGZyb20gVU5DIHRyYWlsaW5nIHBhdGggdGhhdCBpcyBub3QgcGFydCBvZiBzaGFyZQotICogbmFtZSBhbmQgZml4dXAgbWlzc2luZyAnXCcgaW4gdGhlIGJlZ2luaW5nIG9mIERGUyBub2RlIHJlZmZlcmFsCisgKiBuYW1lIGFuZCBmaXh1cCBtaXNzaW5nICdcJyBpbiB0aGUgYmVnaW5uaW5nIG9mIERGUyBub2RlIHJlZmZlcmFsCiAgKiBpZiBuZWNlc3NhcnkuCiAgKiBSZXR1cm5zIHBvaW50ZXIgdG8gc2hhcmUgbmFtZSBvbiBzdWNjZXNzIG9yIEVSUl9QVFIgb24gZXJyb3IuCiAgKiBDYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yIGZyZWVpbmcgcmV0dXJuZWQgc3RyaW5nLgpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzc21iLmMgYi9mcy9jaWZzL2NpZnNzbWIuYwppbmRleCA5MDRhYTQ3Li4yNjQ0YTVkIDEwMDY0NAotLS0gYS9mcy9jaWZzL2NpZnNzbWIuYworKysgYi9mcy9jaWZzL2NpZnNzbWIuYwpAQCAtNTI0Nyw3ICs1MjQ3LDcgQEAKIAkgKiBTYW1iYSBzZXJ2ZXIgaWdub3JlcyBzZXQgb2YgZmlsZSBzaXplIHRvIHplcm8gZHVlIHRvIGJ1Z3MgaW4gc29tZQogCSAqIG9sZGVyIGNsaWVudHMsIGJ1dCB3ZSBzaG91bGQgYmUgcHJlY2lzZSAtIHdlIHVzZSBTZXRGaWxlU2l6ZSB0bwogCSAqIHNldCBmaWxlIHNpemUgYW5kIGRvIG5vdCB3YW50IHRvIHRydW5jYXRlIGZpbGUgc2l6ZSB0byB6ZXJvCi0JICogYWNjaWRlbnRseSBhcyBoYXBwZW5lZCBvbiBvbmUgU2FtYmEgc2VydmVyIGJldGEgYnkgcHV0dGluZworCSAqIGFjY2lkZW50YWxseSBhcyBoYXBwZW5lZCBvbiBvbmUgU2FtYmEgc2VydmVyIGJldGEgYnkgcHV0dGluZwogCSAqIHplcm8gaW5zdGVhZCBvZiAtMSBoZXJlCiAJICovCiAJZGF0YV9vZmZzZXQtPkVuZE9mRmlsZSA9IGNwdV90b19sZTY0KE5PX0NIQU5HRV82NCk7CmRpZmYgLS1naXQgYS9mcy9jaWZzL2Nvbm5lY3QuYyBiL2ZzL2NpZnMvY29ubmVjdC5jCmluZGV4IDhkNmMxN2EuLjZlMmIyYWQgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY29ubmVjdC5jCisrKyBiL2ZzL2NpZnMvY29ubmVjdC5jCkBAIC0xNTcyLDcgKzE1NzIsNyBAQAogCQlyZXR1cm4gZmFsc2U7CiAJfQogCi0JLyogbm93IGNoZWNrIGlmIHNpZ25pbmcgbW9kZSBpcyBhY2NlcHRpYmxlICovCisJLyogbm93IGNoZWNrIGlmIHNpZ25pbmcgbW9kZSBpcyBhY2NlcHRhYmxlICovCiAJaWYgKChzZWNGbGFncyAmIENJRlNTRUNfTUFZX1NJR04pID09IDAgJiYKIAkgICAgKHNlcnZlci0+c2VjTW9kZSAmIFNFQ01PREVfU0lHTl9SRVFVSVJFRCkpCiAJCQlyZXR1cm4gZmFsc2U7CkBAIC0yOTMzLDcgKzI5MzMsNyBAQAogCQlpZiAobW91bnRfZGF0YSAhPSBtb3VudF9kYXRhX2dsb2JhbCkKIAkJCWtmcmVlKG1vdW50X2RhdGEpOwogCQkvKiBJZiBmaW5kX3VuYyBzdWNjZWVkZWQgdGhlbiByYyA9PSAwIHNvIHdlIGNhbiBub3QgZW5kICovCi0JCS8qIHVwIGFjY2lkZW50bHkgZnJlZWluZyBzb21lb25lIGVsc2VzIHRjb24gc3RydWN0ICovCisJCS8qIHVwIGFjY2lkZW50YWxseSBmcmVlaW5nIHNvbWVvbmUgZWxzZXMgdGNvbiBzdHJ1Y3QgKi8KIAkJaWYgKHRjb24pCiAJCQljaWZzX3B1dF90Y29uKHRjb24pOwogCQllbHNlIGlmIChwU2VzSW5mbykKZGlmZiAtLWdpdCBhL2ZzL2NpZnMvZGlyLmMgYi9mcy9jaWZzL2Rpci5jCmluZGV4IGRkNWYyMjkuLjllYTY1Y2YgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvZGlyLmMKKysrIGIvZnMvY2lmcy9kaXIuYwpAQCAtMTg5LDcgKzE4OSw3IEBACiAJCQlpbm9kZS0+aV9zYiwgbW9kZSwgb2ZsYWdzLCAmb3Bsb2NrLCAmZmlsZUhhbmRsZSwgeGlkKTsKIAkJLyogRUlPIGNvdWxkIGluZGljYXRlIHRoYXQgKHBvc2l4IG9wZW4pIG9wZXJhdGlvbiBpcyBub3QKIAkJICAgc3VwcG9ydGVkLCBkZXNwaXRlIHdoYXQgc2VydmVyIGNsYWltZWQgaW4gY2FwYWJpbGl0eQotCQkgICBuZWdvdGF0aW9uLiAgRVJFTU9URSBpbmRpY2F0ZXMgREZTIGp1bmN0aW9uLCB3aGljaCBpcyBub3QKKwkJICAgbmVnb3RpYXRpb24uICBFUkVNT1RFIGluZGljYXRlcyBERlMganVuY3Rpb24sIHdoaWNoIGlzIG5vdAogCQkgICBoYW5kbGVkIGluIHBvc2l4IG9wZW4gKi8KIAogCQlpZiAocmMgPT0gMCkgewpkaWZmIC0tZ2l0IGEvZnMvY29uZmlnZnMvZGlyLmMgYi9mcy9jb25maWdmcy9kaXIuYwppbmRleCA5MGZmM2NiLi4zMzEzZGQxIDEwMDY0NAotLS0gYS9mcy9jb25maWdmcy9kaXIuYworKysgYi9mcy9jb25maWdmcy9kaXIuYwpAQCAtOTkwLDcgKzk5MCw3IEBACiAgKiBUaGlzIGRlc2NyaWJlcyB0aGVzZSBmdW5jdGlvbnMgYW5kIHRoZWlyIGhlbHBlcnMuCiAgKgogICogQWxsb3cgYW5vdGhlciBrZXJuZWwgc3lzdGVtIHRvIGRlcGVuZCBvbiBhIGNvbmZpZ19pdGVtLiAgSWYgdGhpcwotICogaGFwcGVucywgdGhlIGl0ZW0gY2Fubm90IGdvIGF3YXkgdW50aWwgdGhlIGRlcGVuZGFudCBjYW4gbGl2ZSB3aXRob3V0CisgKiBoYXBwZW5zLCB0aGUgaXRlbSBjYW5ub3QgZ28gYXdheSB1bnRpbCB0aGUgZGVwZW5kZW50IGNhbiBsaXZlIHdpdGhvdXQKICAqIGl0LiAgVGhlIGlkZWEgaXMgdG8gZ2l2ZSBjbGllbnQgbW9kdWxlcyBhcyBzaW1wbGUgYW4gaW50ZXJmYWNlIGFzCiAgKiBwb3NzaWJsZS4gIFdoZW4gYSBzeXN0ZW0gYXNrcyB0aGVtIHRvIGRlcGVuZCBvbiBhbiBpdGVtLCB0aGV5IGp1c3QKICAqIGNhbGwgY29uZmlnZnNfZGVwZW5kX2l0ZW0oKS4gIElmIHRoZSBpdGVtIGlzIGxpdmUgYW5kIHRoZSBjbGllbnQKZGlmZiAtLWdpdCBhL2ZzL2RsbS9sb2NrLmMgYi9mcy9kbG0vbG9jay5jCmluZGV4IDA0YjhjNDQuLjU2ZDZiZmMgMTAwNjQ0Ci0tLSBhL2ZzL2RsbS9sb2NrLmMKKysrIGIvZnMvZGxtL2xvY2suYwpAQCAtNTE5LDcgKzUxOSw3IEBACiAJfQogfQogCi0vKiBXaGVuIGFsbCByZWZlcmVuY2VzIHRvIHRoZSByc2IgYXJlIGdvbmUgaXQncyB0cmFuc2ZlcmVkIHRvCisvKiBXaGVuIGFsbCByZWZlcmVuY2VzIHRvIHRoZSByc2IgYXJlIGdvbmUgaXQncyB0cmFuc2ZlcnJlZCB0bwogICAgdGhlIHRvc3NlZCBsaXN0IGZvciBsYXRlciBkaXNwb3NhbC4gKi8KIAogc3RhdGljIHZvaWQgcHV0X3JzYihzdHJ1Y3QgZGxtX3JzYiAqcikKZGlmZiAtLWdpdCBhL2ZzL2RsbS9sb3djb21tcy5jIGIvZnMvZGxtL2xvd2NvbW1zLmMKaW5kZXggYmZmYTFlNy4uNWUyYzcxZiAxMDA2NDQKLS0tIGEvZnMvZGxtL2xvd2NvbW1zLmMKKysrIGIvZnMvZGxtL2xvd2NvbW1zLmMKQEAgLTgxMCw3ICs4MTAsNyBAQAogCiAJLyoKIAkgKiBBZGQgaXQgdG8gdGhlIGFjdGl2ZSBxdWV1ZSBpbiBjYXNlIHdlIGdvdCBkYXRhCi0JICogYmV3ZWVuIHByb2Nlc3NpbmcgdGhlIGFjY2VwdCBhZGRpbmcgdGhlIHNvY2tldAorCSAqIGJldHdlZW4gcHJvY2Vzc2luZyB0aGUgYWNjZXB0IGFkZGluZyB0aGUgc29ja2V0CiAJICogdG8gdGhlIHJlYWRfc29ja2V0cyBsaXN0CiAJICovCiAJaWYgKCF0ZXN0X2FuZF9zZXRfYml0KENGX1JFQURfUEVORElORywgJmFkZGNvbi0+ZmxhZ3MpKQpkaWZmIC0tZ2l0IGEvZnMvZGxtL3JlY292ZXIuYyBiL2ZzL2RsbS9yZWNvdmVyLmMKaW5kZXggZWRhNDNmMy4uMTQ2MzgyMyAxMDA2NDQKLS0tIGEvZnMvZGxtL3JlY292ZXIuYworKysgYi9mcy9kbG0vcmVjb3Zlci5jCkBAIC0zMDQsNyArMzA0LDcgQEAKIH0KIAogLyoKLSAqIFByb3BvZ2F0ZSB0aGUgbmV3IG1hc3RlciBub2RlaWQgdG8gbG9ja3MKKyAqIFByb3BhZ2F0ZSB0aGUgbmV3IG1hc3RlciBub2RlaWQgdG8gbG9ja3MKICAqIFRoZSBORVdfTUFTVEVSIGZsYWcgdGVsbHMgZGxtX3JlY292ZXJfbG9ja3MoKSB3aGljaCByc2IncyB0byBjb25zaWRlci4KICAqIFRoZSBORVdfTUFTVEVSMiBmbGFnIHRlbGxzIHJlY292ZXJfbHZiKCkgYW5kIHNldF9sb2Nrc19wdXJnZWQoKSB3aGljaAogICogcnNiJ3MgdG8gY29uc2lkZXIuCmRpZmYgLS1naXQgYS9mcy9lY3J5cHRmcy9tYWluLmMgYi9mcy9lY3J5cHRmcy9tYWluLmMKaW5kZXggYzI3YzBlYy4uZmRiMmViMCAxMDA2NDQKLS0tIGEvZnMvZWNyeXB0ZnMvbWFpbi5jCisrKyBiL2ZzL2VjcnlwdGZzL21haW4uYwpAQCAtMjc2LDcgKzI3Niw3IEBACiAvKioKICAqIGVjcnlwdGZzX3BhcnNlX29wdGlvbnMKICAqIEBzYjogVGhlIGVjcnlwdGZzIHN1cGVyIGJsb2NrCi0gKiBAb3B0aW9uczogVGhlIG9wdGlvbnMgcGFzZWQgdG8gdGhlIGtlcm5lbAorICogQG9wdGlvbnM6IFRoZSBvcHRpb25zIHBhc3NlZCB0byB0aGUga2VybmVsCiAgKgogICogUGFyc2UgbW91bnQgb3B0aW9uczoKICAqIGRlYnVnPU4gCSAgIC0gZWNyeXB0ZnNfdmVyYm9zaXR5IGxldmVsIGZvciBkZWJ1ZyBvdXRwdXQKQEAgLTg0MCw3ICs4NDAsNyBAQAogCX0KIAlyYyA9IGVjcnlwdGZzX2luaXRfbWVzc2FnaW5nKCk7CiAJaWYgKHJjKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiRmFpbHVyZSBvY2N1cmVkIHdoaWxlIGF0dGVtcHRpbmcgdG8gIgorCQlwcmludGsoS0VSTl9FUlIgIkZhaWx1cmUgb2NjdXJyZWQgd2hpbGUgYXR0ZW1wdGluZyB0byAiCiAJCQkJImluaXRpYWxpemUgdGhlIGNvbW11bmljYXRpb25zIGNoYW5uZWwgdG8gIgogCQkJCSJlY3J5cHRmc2RcbiIpOwogCQlnb3RvIG91dF9kZXN0cm95X2t0aHJlYWQ7CmRpZmYgLS1naXQgYS9mcy9ldmVudHBvbGwuYyBiL2ZzL2V2ZW50cG9sbC5jCmluZGV4IGVkMzg4MDEuLmY5Y2ZkMTYgMTAwNjQ0Ci0tLSBhL2ZzL2V2ZW50cG9sbC5jCisrKyBiL2ZzL2V2ZW50cG9sbC5jCkBAIC0xODEsNyArMTgxLDcgQEAKIAogCS8qCiAJICogVGhpcyBpcyBhIHNpbmdsZSBsaW5rZWQgbGlzdCB0aGF0IGNoYWlucyBhbGwgdGhlICJzdHJ1Y3QgZXBpdGVtIiB0aGF0Ci0JICogaGFwcGVuZWQgd2hpbGUgdHJhbnNmZXJpbmcgcmVhZHkgZXZlbnRzIHRvIHVzZXJzcGFjZSB3L291dAorCSAqIGhhcHBlbmVkIHdoaWxlIHRyYW5zZmVycmluZyByZWFkeSBldmVudHMgdG8gdXNlcnNwYWNlIHcvb3V0CiAJICogaG9sZGluZyAtPmxvY2suCiAJICovCiAJc3RydWN0IGVwaXRlbSAqb3ZmbGlzdDsKQEAgLTYwNiw3ICs2MDYsNyBAQAogCSAqIFdlIGRvIG5vdCBuZWVkIHRvIGhvbGQgImVwLT5tdHgiIGhlcmUgYmVjYXVzZSB0aGUgZXBvbGwgZmlsZQogCSAqIGlzIG9uIHRoZSB3YXkgdG8gYmUgcmVtb3ZlZCBhbmQgbm8gb25lIGhhcyByZWZlcmVuY2VzIHRvIGl0CiAJICogYW55bW9yZS4gVGhlIG9ubHkgaGl0IG1pZ2h0IGNvbWUgZnJvbSBldmVudHBvbGxfcmVsZWFzZV9maWxlKCkgYnV0Ci0JICogaG9sZGluZyAiZXBtdXRleCIgaXMgc3VmZmljZW50IGhlcmUuCisJICogaG9sZGluZyAiZXBtdXRleCIgaXMgc3VmZmljaWVudCBoZXJlLgogCSAqLwogCW11dGV4X2xvY2soJmVwbXV0ZXgpOwogCkBAIC03MjAsNyArNzIwLDcgQEAKIAkvKgogCSAqIFdlIGRvbid0IHdhbnQgdG8gZ2V0ICJmaWxlLT5mX2xvY2siIGJlY2F1c2UgaXQgaXMgbm90CiAJICogbmVjZXNzYXJ5LiBJdCBpcyBub3QgbmVjZXNzYXJ5IGJlY2F1c2Ugd2UncmUgaW4gdGhlICJzdHJ1Y3QgZmlsZSIKLQkgKiBjbGVhbnVwIHBhdGgsIGFuZCB0aGlzIG1lYW5zIHRoYXQgbm9vbmUgaXMgdXNpbmcgdGhpcyBmaWxlIGFueW1vcmUuCisJICogY2xlYW51cCBwYXRoLCBhbmQgdGhpcyBtZWFucyB0aGF0IG5vIG9uZSBpcyB1c2luZyB0aGlzIGZpbGUgYW55bW9yZS4KIAkgKiBTbywgZm9yIGV4YW1wbGUsIGVwb2xsX2N0bCgpIGNhbm5vdCBoaXQgaGVyZSBzaW5jZSBpZiB3ZSByZWFjaCB0aGlzCiAJICogcG9pbnQsIHRoZSBmaWxlIGNvdW50ZXIgYWxyZWFkeSB3ZW50IHRvIHplcm8gYW5kIGZnZXQoKSB3b3VsZCBmYWlsLgogCSAqIFRoZSBvbmx5IGhpdCBtaWdodCBjb21lIGZyb20gZXBfZnJlZSgpIGJ1dCBieSBob2xkaW5nIHRoZSBtdXRleApAQCAtMTExMiw3ICsxMTEyLDcgQEAKIAkJCQkgKiBUcmlnZ2VyIG1vZGUsIHdlIG5lZWQgdG8gaW5zZXJ0IGJhY2sgaW5zaWRlCiAJCQkJICogdGhlIHJlYWR5IGxpc3QsIHNvIHRoYXQgdGhlIG5leHQgY2FsbCB0bwogCQkJCSAqIGVwb2xsX3dhaXQoKSB3aWxsIGNoZWNrIGFnYWluIHRoZSBldmVudHMKLQkJCQkgKiBhdmFpbGFiaWxpdHkuIEF0IHRoaXMgcG9pbnQsIG5vb25lIGNhbiBpbnNlcnQKKwkJCQkgKiBhdmFpbGFiaWxpdHkuIEF0IHRoaXMgcG9pbnQsIG5vIG9uZSBjYW4gaW5zZXJ0CiAJCQkJICogaW50byBlcC0+cmRsbGlzdCBiZXNpZGVzIHVzLiBUaGUgZXBvbGxfY3RsKCkKIAkJCQkgKiBjYWxsZXJzIGFyZSBsb2NrZWQgb3V0IGJ5CiAJCQkJICogZXBfc2Nhbl9yZWFkeV9saXN0KCkgaG9sZGluZyAibXR4IiBhbmQgdGhlCmRpZmYgLS1naXQgYS9mcy9leG9mcy9jb21tb24uaCBiL2ZzL2V4b2ZzL2NvbW1vbi5oCmluZGV4IDVlNzRhZDMuLjNiYmQ0NjkgMTAwNjQ0Ci0tLSBhL2ZzL2V4b2ZzL2NvbW1vbi5oCisrKyBiL2ZzL2V4b2ZzL2NvbW1vbi5oCkBAIC0xMTUsNyArMTE1LDcgQEAKICAqIERlc2NyaWJlcyB0aGUgcmFpZCB1c2VkIGluIHRoZSBGUy4gSXQgaXMgcGFydCBvZiB0aGUgZGV2aWNlIHRhYmxlLgogICogVGhpcyBoZXJlIGlzIHRha2VuIGZyb20gdGhlIHBORlMtb2JqZWN0cyBkZWZpbml0aW9uLiBJbiBleG9mcyB3ZQogICogdXNlIG9uZSByYWlkIHBvbGljeSB0aHJvdWdoLW91dCB0aGUgZmlsZXN5c3RlbS4gKE5PVEU6IHRoZSBmdW5ueQotICogYWxpZ25tZW50IGF0IGJlZ2luaW5nLiBXZSB0YWtlIGNhcmUgb2YgaXQgYXQgZXhvZnNfZGV2aWNlX3RhYmxlLgorICogYWxpZ25tZW50IGF0IGJlZ2lubmluZy4gV2UgdGFrZSBjYXJlIG9mIGl0IGF0IGV4b2ZzX2RldmljZV90YWJsZS4KICAqLwogc3RydWN0IGV4b2ZzX2R0X2RhdGFfbWFwIHsKIAlfX2xlMzIJY2JfbnVtX2NvbXBzOwpAQCAtMTM2LDcgKzEzNiw3IEBACiAJdTgJc3lzdGVtaWRbT1NEX1NZU1RFTUlEX0xFTl07CiAJX19sZTY0CWxvbmdfbmFtZV9vZmZzZXQ7CS8qIElmICEwIHRoZW4gb2Zmc2V0LWluLWZpbGUgKi8KIAlfX2xlMzIJb3NkbmFtZV9sZW47CQkvKiAqLwotCXU4CW9zZG5hbWVbNDRdOwkJLyogRW1iYmVkZWQsIFVzdXNhbGx5IGFuIGFzY2kgdXVpZCAqLworCXU4CW9zZG5hbWVbNDRdOwkJLyogRW1iYmVkZWQsIFVzdWFsbHkgYW4gYXNjaSB1dWlkICovCiB9IF9fcGFja2VkOwogCiAvKgpkaWZmIC0tZ2l0IGEvZnMvZXh0Mi9iYWxsb2MuYyBiL2ZzL2V4dDIvYmFsbG9jLmMKaW5kZXggMGQwNmY0ZS4uOGY0NGNlZiAxMDA2NDQKLS0tIGEvZnMvZXh0Mi9iYWxsb2MuYworKysgYi9mcy9leHQyL2JhbGxvYy5jCkBAIC04NTAsNyArODUwLDcgQEAKIAkJcnN2X3dpbmRvd19yZW1vdmUoc2IsIG15X3Jzdik7CiAKIAkvKgotCSAqIExldCdzIGJvb2sgdGhlIHdob2xlIGF2YWxpYWJsZSB3aW5kb3cgZm9yIG5vdy4gIFdlIHdpbGwgY2hlY2sgdGhlCisJICogTGV0J3MgYm9vayB0aGUgd2hvbGUgYXZhaWxhYmxlIHdpbmRvdyBmb3Igbm93LiAgV2Ugd2lsbCBjaGVjayB0aGUKIAkgKiBkaXNrIGJpdG1hcCBsYXRlciBhbmQgdGhlbiwgaWYgdGhlcmUgYXJlIGZyZWUgYmxvY2tzIHRoZW4gd2UgYWRqdXN0CiAJICogdGhlIHdpbmRvdyBzaXplIGlmIGl0J3MgbGFyZ2VyIHRoYW4gcmVxdWVzdGVkLgogCSAqIE90aGVyd2lzZSwgd2Ugd2lsbCByZW1vdmUgdGhpcyBub2RlIGZyb20gdGhlIHRyZWUgbmV4dCB0aW1lCkBAIC0xMzU3LDkgKzEzNTcsOSBAQAogCQkJZ290byBhbGxvY2F0ZWQ7CiAJfQogCS8qCi0JICogV2UgbWF5IGVuZCB1cCBhIGJvZ3VzIGVhbGllciBFTk9TUEMgZXJyb3IgZHVlIHRvCisJICogV2UgbWF5IGVuZCB1cCBhIGJvZ3VzIGVhcmxpZXIgRU5PU1BDIGVycm9yIGR1ZSB0bwogCSAqIGZpbGVzeXN0ZW0gaXMgImZ1bGwiIG9mIHJlc2VydmF0aW9ucywgYnV0Ci0JICogdGhlcmUgbWF5YmUgaW5kZWVkIGZyZWUgYmxvY2tzIGF2YWxpYWJsZSBvbiBkaXNrCisJICogdGhlcmUgbWF5YmUgaW5kZWVkIGZyZWUgYmxvY2tzIGF2YWlsYWJsZSBvbiBkaXNrCiAJICogSW4gdGhpcyBjYXNlLCB3ZSBqdXN0IGZvcmdldCBhYm91dCB0aGUgcmVzZXJ2YXRpb25zCiAJICoganVzdCBkbyBibG9jayBhbGxvY2F0aW9uIGFzIHdpdGhvdXQgcmVzZXJ2YXRpb25zLgogCSAqLwpkaWZmIC0tZ2l0IGEvZnMvZXh0Mi9pbm9kZS5jIGIvZnMvZXh0Mi9pbm9kZS5jCmluZGV4IGM0N2Y3MDYuLjc4OGUwOWEgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDIvaW5vZGUuYworKysgYi9mcy9leHQyL2lub2RlLmMKQEAgLTMwNSw3ICszMDUsNyBAQAogCQlyZXR1cm4gaW5kLT5iaC0+Yl9ibG9ja25yOwogCiAJLyoKLQkgKiBJdCBpcyBnb2luZyB0byBiZSByZWZlcmVkIGZyb20gaW5vZGUgaXRzZWxmPyBPSywganVzdCBwdXQgaXQgaW50bworCSAqIEl0IGlzIGdvaW5nIHRvIGJlIHJlZmVycmVkIGZyb20gaW5vZGUgaXRzZWxmPyBPSywganVzdCBwdXQgaXQgaW50bwogCSAqIHRoZSBzYW1lIGN5bGluZGVyIGdyb3VwIHRoZW4uCiAJICovCiAJYmdfc3RhcnQgPSBleHQyX2dyb3VwX2ZpcnN0X2Jsb2NrX25vKGlub2RlLT5pX3NiLCBlaS0+aV9ibG9ja19ncm91cCk7CkBAIC05MTMsNyArOTEzLDcgQEAKICAqCiAgKglXaGVuIHdlIGRvIHRydW5jYXRlKCkgd2UgbWF5IGhhdmUgdG8gY2xlYW4gdGhlIGVuZHMgb2Ygc2V2ZXJhbCBpbmRpcmVjdAogICoJYmxvY2tzIGJ1dCBsZWF2ZSB0aGUgYmxvY2tzIHRoZW1zZWx2ZXMgYWxpdmUuIEJsb2NrIGlzIHBhcnRpYWxseQotICoJdHJ1bmNhdGVkIGlmIHNvbWUgZGF0YSBiZWxvdyB0aGUgbmV3IGlfc2l6ZSBpcyByZWZlcmVkIGZyb20gaXQgKGFuZAorICoJdHJ1bmNhdGVkIGlmIHNvbWUgZGF0YSBiZWxvdyB0aGUgbmV3IGlfc2l6ZSBpcyByZWZlcnJlZCBmcm9tIGl0IChhbmQKICAqCWl0IGlzIG9uIHRoZSBwYXRoIHRvIHRoZSBmaXJzdCBjb21wbGV0ZWx5IHRydW5jYXRlZCBkYXRhIGJsb2NrLCBpbmRlZWQpLgogICoJV2UgaGF2ZSB0byBmcmVlIHRoZSB0b3Agb2YgdGhhdCBwYXRoIGFsb25nIHdpdGggZXZlcnl0aGluZyB0byB0aGUgcmlnaHQKICAqCW9mIHRoZSBwYXRoLiBTaW5jZSBubyBhbGxvY2F0aW9uIHBhc3QgdGhlIHRydW5jYXRpb24gcG9pbnQgaXMgcG9zc2libGUKQEAgLTk5MCw3ICs5OTAsNyBAQAogICoJQHA6CWFycmF5IG9mIGJsb2NrIG51bWJlcnMKICAqCUBxOglwb2ludHMgaW1tZWRpYXRlbHkgcGFzdCB0aGUgZW5kIG9mIGFycmF5CiAgKgotICoJV2UgYXJlIGZyZWVpbmcgYWxsIGJsb2NrcyByZWZlcmVkIGZyb20gdGhhdCBhcnJheSAobnVtYmVycyBhcmUKKyAqCVdlIGFyZSBmcmVlaW5nIGFsbCBibG9ja3MgcmVmZXJyZWQgZnJvbSB0aGF0IGFycmF5IChudW1iZXJzIGFyZQogICoJc3RvcmVkIGFzIGxpdHRsZS1lbmRpYW4gMzItYml0KSBhbmQgdXBkYXRpbmcgQGlub2RlLT5pX2Jsb2NrcwogICoJYXBwcm9wcmlhdGVseS4KICAqLwpAQCAtMTAzMCw3ICsxMDMwLDcgQEAKICAqCUBxOglwb2ludGVyIGltbWVkaWF0ZWx5IHBhc3QgdGhlIGVuZCBvZiBhcnJheQogICoJQGRlcHRoOglkZXB0aCBvZiB0aGUgYnJhbmNoZXMgdG8gZnJlZQogICoKLSAqCVdlIGFyZSBmcmVlaW5nIGFsbCBibG9ja3MgcmVmZXJlZCBmcm9tIHRoZXNlIGJyYW5jaGVzIChudW1iZXJzIGFyZQorICoJV2UgYXJlIGZyZWVpbmcgYWxsIGJsb2NrcyByZWZlcnJlZCBmcm9tIHRoZXNlIGJyYW5jaGVzIChudW1iZXJzIGFyZQogICoJc3RvcmVkIGFzIGxpdHRsZS1lbmRpYW4gMzItYml0KSBhbmQgdXBkYXRpbmcgQGlub2RlLT5pX2Jsb2NrcwogICoJYXBwcm9wcmlhdGVseS4KICAqLwpkaWZmIC0tZ2l0IGEvZnMvZXh0Mi9zdXBlci5jIGIvZnMvZXh0Mi9zdXBlci5jCmluZGV4IDc3MzE2OTUuLjBhNzhkYWUgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDIvc3VwZXIuYworKysgYi9mcy9leHQyL3N1cGVyLmMKQEAgLTEzODIsNyArMTM4Miw3IEBACiAKIC8qIFJlYWQgZGF0YSBmcm9tIHF1b3RhZmlsZSAtIGF2b2lkIHBhZ2VjYWNoZSBhbmQgc3VjaCBiZWNhdXNlIHdlIGNhbm5vdCBhZmZvcmQKICAqIGFjcXVpcmluZyB0aGUgbG9ja3MuLi4gQXMgcXVvdGEgZmlsZXMgYXJlIG5ldmVyIHRydW5jYXRlZCBhbmQgcXVvdGEgY29kZQotICogaXRzZWxmIHNlcmlhbGl6ZXMgdGhlIG9wZXJhdGlvbnMgKGFuZCBub29uZSBlbHNlIHNob3VsZCB0b3VjaCB0aGUgZmlsZXMpCisgKiBpdHNlbGYgc2VyaWFsaXplcyB0aGUgb3BlcmF0aW9ucyAoYW5kIG5vIG9uZSBlbHNlIHNob3VsZCB0b3VjaCB0aGUgZmlsZXMpCiAgKiB3ZSBkb24ndCBoYXZlIHRvIGJlIGFmcmFpZCBvZiByYWNlcyAqLwogc3RhdGljIHNzaXplX3QgZXh0Ml9xdW90YV9yZWFkKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBjaGFyICpkYXRhLAogCQkJICAgICAgIHNpemVfdCBsZW4sIGxvZmZfdCBvZmYpCmRpZmYgLS1naXQgYS9mcy9leHQyL3hhdHRyLmMgYi9mcy9leHQyL3hhdHRyLmMKaW5kZXggYzJlNGRjZS4uNTI5OTcwNiAxMDA2NDQKLS0tIGEvZnMvZXh0Mi94YXR0ci5jCisrKyBiL2ZzL2V4dDIveGF0dHIuYwpAQCAtMzUsNyArMzUsNyBAQAogICogICArLS0tLS0tLS0tLS0tLS0tLS0tKwogICoKICAqIFRoZSBibG9jayBoZWFkZXIgaXMgZm9sbG93ZWQgYnkgbXVsdGlwbGUgZW50cnkgZGVzY3JpcHRvcnMuIFRoZXNlIGVudHJ5Ci0gKiBkZXNjcmlwdG9ycyBhcmUgdmFyaWFibGUgaW4gc2l6ZSwgYW5kIGFsbGlnbmVkIHRvIEVYVDJfWEFUVFJfUEFECisgKiBkZXNjcmlwdG9ycyBhcmUgdmFyaWFibGUgaW4gc2l6ZSwgYW5kIGFsaWduZWQgdG8gRVhUMl9YQVRUUl9QQUQKICAqIGJ5dGUgYm91bmRhcmllcy4gVGhlIGVudHJ5IGRlc2NyaXB0b3JzIGFyZSBzb3J0ZWQgYnkgYXR0cmlidXRlIG5hbWUsCiAgKiBzbyB0aGF0IHR3byBleHRlbmRlZCBhdHRyaWJ1dGUgYmxvY2tzIGNhbiBiZSBjb21wYXJlZCBlZmZpY2llbnRseS4KICAqCmRpZmYgLS1naXQgYS9mcy9leHQzL2JhbGxvYy5jIGIvZnMvZXh0My9iYWxsb2MuYwppbmRleCAxNTMyNDIxLi5mZTUyMjk3IDEwMDY0NAotLS0gYS9mcy9leHQzL2JhbGxvYy5jCisrKyBiL2ZzL2V4dDMvYmFsbG9jLmMKQEAgLTU5MCw3ICs1OTAsNyBAQAogCQkJCUJVRkZFUl9UUkFDRShkZWJ1Z19iaCwgIkRlbGV0ZWQhIik7CiAJCQkJaWYgKCFiaDJqaChiaXRtYXBfYmgpLT5iX2NvbW1pdHRlZF9kYXRhKQogCQkJCQlCVUZGRVJfVFJBQ0UoZGVidWdfYmgsCi0JCQkJCQkiTm8gY29tbWl0ZWQgZGF0YSBpbiBiaXRtYXAiKTsKKwkJCQkJCSJObyBjb21taXR0ZWQgZGF0YSBpbiBiaXRtYXAiKTsKIAkJCQlCVUZGRVJfVFJBQ0UyKGRlYnVnX2JoLCBiaXRtYXBfYmgsICJiaXRtYXAiKTsKIAkJCQlfX2JyZWxzZShkZWJ1Z19iaCk7CiAJCQl9CkBAIC0xMDYzLDcgKzEwNjMsNyBAQAogCQlyc3Zfd2luZG93X3JlbW92ZShzYiwgbXlfcnN2KTsKIAogCS8qCi0JICogTGV0J3MgYm9vayB0aGUgd2hvbGUgYXZhbGlhYmxlIHdpbmRvdyBmb3Igbm93LiAgV2Ugd2lsbCBjaGVjayB0aGUKKwkgKiBMZXQncyBib29rIHRoZSB3aG9sZSBhdmFpbGFibGUgd2luZG93IGZvciBub3cuICBXZSB3aWxsIGNoZWNrIHRoZQogCSAqIGRpc2sgYml0bWFwIGxhdGVyIGFuZCB0aGVuLCBpZiB0aGVyZSBhcmUgZnJlZSBibG9ja3MgdGhlbiB3ZSBhZGp1c3QKIAkgKiB0aGUgd2luZG93IHNpemUgaWYgaXQncyBsYXJnZXIgdGhhbiByZXF1ZXN0ZWQuCiAJICogT3RoZXJ3aXNlLCB3ZSB3aWxsIHJlbW92ZSB0aGlzIG5vZGUgZnJvbSB0aGUgdHJlZSBuZXh0IHRpbWUKQEAgLTE0NTYsNyArMTQ1Niw3IEBACiAgKgogICogZXh0M19zaG91bGRfcmV0cnlfYWxsb2MoKSBpcyBjYWxsZWQgd2hlbiBFTk9TUEMgaXMgcmV0dXJuZWQsIGFuZCBpZgogICogaXQgaXMgcHJvZml0YWJsZSB0byByZXRyeSB0aGUgb3BlcmF0aW9uLCB0aGlzIGZ1bmN0aW9uIHdpbGwgd2FpdAotICogZm9yIHRoZSBjdXJyZW50IG9yIGNvbW1pdGluZyB0cmFuc2FjdGlvbiB0byBjb21wbGV0ZSwgYW5kIHRoZW4KKyAqIGZvciB0aGUgY3VycmVudCBvciBjb21taXR0aW5nIHRyYW5zYWN0aW9uIHRvIGNvbXBsZXRlLCBhbmQgdGhlbgogICogcmV0dXJuIFRSVUUuCiAgKgogICogaWYgdGhlIHRvdGFsIG51bWJlciBvZiByZXRyaWVzIGV4Y2VlZCB0aHJlZSB0aW1lcywgcmV0dXJuIEZBTFNFLgpAQCAtMTYzMiw5ICsxNjMyLDkgQEAKIAkJCWdvdG8gYWxsb2NhdGVkOwogCX0KIAkvKgotCSAqIFdlIG1heSBlbmQgdXAgYSBib2d1cyBlYWxpZXIgRU5PU1BDIGVycm9yIGR1ZSB0bworCSAqIFdlIG1heSBlbmQgdXAgYSBib2d1cyBlYXJsaWVyIEVOT1NQQyBlcnJvciBkdWUgdG8KIAkgKiBmaWxlc3lzdGVtIGlzICJmdWxsIiBvZiByZXNlcnZhdGlvbnMsIGJ1dAotCSAqIHRoZXJlIG1heWJlIGluZGVlZCBmcmVlIGJsb2NrcyBhdmFsaWFibGUgb24gZGlzaworCSAqIHRoZXJlIG1heWJlIGluZGVlZCBmcmVlIGJsb2NrcyBhdmFpbGFibGUgb24gZGlzawogCSAqIEluIHRoaXMgY2FzZSwgd2UganVzdCBmb3JnZXQgYWJvdXQgdGhlIHJlc2VydmF0aW9ucwogCSAqIGp1c3QgZG8gYmxvY2sgYWxsb2NhdGlvbiBhcyB3aXRob3V0IHJlc2VydmF0aW9ucy4KIAkgKi8KZGlmZiAtLWdpdCBhL2ZzL2V4dDMvaW5vZGUuYyBiL2ZzL2V4dDMvaW5vZGUuYwppbmRleCBmZTI1NDFkLi42OGIyZTQzIDEwMDY0NAotLS0gYS9mcy9leHQzL2lub2RlLmMKKysrIGIvZnMvZXh0My9pbm9kZS5jCkBAIC0yMDU1LDcgKzIwNTUsNyBAQAogICoKICAqCVdoZW4gd2UgZG8gdHJ1bmNhdGUoKSB3ZSBtYXkgaGF2ZSB0byBjbGVhbiB0aGUgZW5kcyBvZiBzZXZlcmFsCiAgKglpbmRpcmVjdCBibG9ja3MgYnV0IGxlYXZlIHRoZSBibG9ja3MgdGhlbXNlbHZlcyBhbGl2ZS4gQmxvY2sgaXMKLSAqCXBhcnRpYWxseSB0cnVuY2F0ZWQgaWYgc29tZSBkYXRhIGJlbG93IHRoZSBuZXcgaV9zaXplIGlzIHJlZmVyZWQKKyAqCXBhcnRpYWxseSB0cnVuY2F0ZWQgaWYgc29tZSBkYXRhIGJlbG93IHRoZSBuZXcgaV9zaXplIGlzIHJlZmVycmVkCiAgKglmcm9tIGl0IChhbmQgaXQgaXMgb24gdGhlIHBhdGggdG8gdGhlIGZpcnN0IGNvbXBsZXRlbHkgdHJ1bmNhdGVkCiAgKglkYXRhIGJsb2NrLCBpbmRlZWQpLiAgV2UgaGF2ZSB0byBmcmVlIHRoZSB0b3Agb2YgdGhhdCBwYXRoIGFsb25nCiAgKgl3aXRoIGV2ZXJ5dGhpbmcgdG8gdGhlIHJpZ2h0IG9mIHRoZSBwYXRoLiBTaW5jZSBubyBhbGxvY2F0aW9uCkBAIC0yMTg0LDcgKzIxODQsNyBAQAogICogQGZpcnN0OglhcnJheSBvZiBibG9jayBudW1iZXJzCiAgKiBAbGFzdDoJcG9pbnRzIGltbWVkaWF0ZWx5IHBhc3QgdGhlIGVuZCBvZiBhcnJheQogICoKLSAqIFdlIGFyZSBmcmVlaW5nIGFsbCBibG9ja3MgcmVmZXJlZCBmcm9tIHRoYXQgYXJyYXkgKG51bWJlcnMgYXJlIHN0b3JlZCBhcworICogV2UgYXJlIGZyZWVpbmcgYWxsIGJsb2NrcyByZWZlcnJlZCBmcm9tIHRoYXQgYXJyYXkgKG51bWJlcnMgYXJlIHN0b3JlZCBhcwogICogbGl0dGxlLWVuZGlhbiAzMi1iaXQpIGFuZCB1cGRhdGluZyBAaW5vZGUtPmlfYmxvY2tzIGFwcHJvcHJpYXRlbHkuCiAgKgogICogV2UgYWNjdW11bGF0ZSBjb250aWd1b3VzIHJ1bnMgb2YgYmxvY2tzIHRvIGZyZWUuICBDb252ZW5pZW50bHksIGlmIHRoZXNlCkBAIC0yMjcyLDcgKzIyNzIsNyBAQAogICoJQGxhc3Q6CXBvaW50ZXIgaW1tZWRpYXRlbHkgcGFzdCB0aGUgZW5kIG9mIGFycmF5CiAgKglAZGVwdGg6CWRlcHRoIG9mIHRoZSBicmFuY2hlcyB0byBmcmVlCiAgKgotICoJV2UgYXJlIGZyZWVpbmcgYWxsIGJsb2NrcyByZWZlcmVkIGZyb20gdGhlc2UgYnJhbmNoZXMgKG51bWJlcnMgYXJlCisgKglXZSBhcmUgZnJlZWluZyBhbGwgYmxvY2tzIHJlZmVycmVkIGZyb20gdGhlc2UgYnJhbmNoZXMgKG51bWJlcnMgYXJlCiAgKglzdG9yZWQgYXMgbGl0dGxlLWVuZGlhbiAzMi1iaXQpIGFuZCB1cGRhdGluZyBAaW5vZGUtPmlfYmxvY2tzCiAgKglhcHByb3ByaWF0ZWx5LgogICovCkBAIC0zMjkxLDcgKzMyOTEsNyBAQAogCWlmIChleHQzX3Nob3VsZF9qb3VybmFsX2RhdGEoaW5vZGUpKQogCQlyZXQgPSAzICogKGJwcCArIGluZGlyZWN0cykgKyAyOwogCWVsc2UKLQkJcmV0ID0gMiAqIChicHAgKyBpbmRpcmVjdHMpICsgMjsKKwkJcmV0ID0gMiAqIChicHAgKyBpbmRpcmVjdHMpICsgaW5kaXJlY3RzICsgMjsKIAogI2lmZGVmIENPTkZJR19RVU9UQQogCS8qIFdlIGtub3cgdGhhdCBzdHJ1Y3R1cmUgd2FzIGFscmVhZHkgYWxsb2NhdGVkIGR1cmluZyBkcXVvdF9pbml0aWFsaXplIHNvCmRpZmYgLS1naXQgYS9mcy9leHQzL3Jlc2l6ZS5jIGIvZnMvZXh0My9yZXNpemUuYwppbmRleCAxMDhiMTQyLi43OTE2ZTRjZSAxMDA2NDQKLS0tIGEvZnMvZXh0My9yZXNpemUuYworKysgYi9mcy9leHQzL3Jlc2l6ZS5jCkBAIC0xMDA5LDcgKzEwMDksNyBAQAogCiAJaWYgKHRlc3Rfb3B0KHNiLCBERUJVRykpCiAJCXByaW50ayhLRVJOX0RFQlVHICJFWFQzLWZzOiBleHRlbmRpbmcgbGFzdCBncm91cCBmcm9tICJFM0ZTQkxLCi0JCSAgICAgICAiIHVwdG8gIkUzRlNCTEsiIGJsb2Nrc1xuIiwKKwkJICAgICAgICIgdXAgdG8gIkUzRlNCTEsiIGJsb2Nrc1xuIiwKIAkJICAgICAgIG9fYmxvY2tzX2NvdW50LCBuX2Jsb2Nrc19jb3VudCk7CiAKIAlpZiAobl9ibG9ja3NfY291bnQgPT0gMCB8fCBuX2Jsb2Nrc19jb3VudCA9PSBvX2Jsb2Nrc19jb3VudCkKZGlmZiAtLWdpdCBhL2ZzL2V4dDMvc3VwZXIuYyBiL2ZzL2V4dDMvc3VwZXIuYwppbmRleCAwNzE2ODlmLi4zYzZhOWUwIDEwMDY0NAotLS0gYS9mcy9leHQzL3N1cGVyLmMKKysrIGIvZnMvZXh0My9zdXBlci5jCkBAIC0yOTI1LDcgKzI5MjUsNyBAQAogCiAvKiBSZWFkIGRhdGEgZnJvbSBxdW90YWZpbGUgLSBhdm9pZCBwYWdlY2FjaGUgYW5kIHN1Y2ggYmVjYXVzZSB3ZSBjYW5ub3QgYWZmb3JkCiAgKiBhY3F1aXJpbmcgdGhlIGxvY2tzLi4uIEFzIHF1b3RhIGZpbGVzIGFyZSBuZXZlciB0cnVuY2F0ZWQgYW5kIHF1b3RhIGNvZGUKLSAqIGl0c2VsZiBzZXJpYWxpemVzIHRoZSBvcGVyYXRpb25zIChhbmQgbm9vbmUgZWxzZSBzaG91bGQgdG91Y2ggdGhlIGZpbGVzKQorICogaXRzZWxmIHNlcmlhbGl6ZXMgdGhlIG9wZXJhdGlvbnMgKGFuZCBubyBvbmUgZWxzZSBzaG91bGQgdG91Y2ggdGhlIGZpbGVzKQogICogd2UgZG9uJ3QgaGF2ZSB0byBiZSBhZnJhaWQgb2YgcmFjZXMgKi8KIHN0YXRpYyBzc2l6ZV90IGV4dDNfcXVvdGFfcmVhZChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgY2hhciAqZGF0YSwKIAkJCSAgICAgICBzaXplX3QgbGVuLCBsb2ZmX3Qgb2ZmKQpkaWZmIC0tZ2l0IGEvZnMvZXh0NC9iYWxsb2MuYyBiL2ZzL2V4dDQvYmFsbG9jLmMKaW5kZXggOTdiOTcwZS4uMWM2NzEzOSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9iYWxsb2MuYworKysgYi9mcy9leHQ0L2JhbGxvYy5jCkBAIC01NDcsNyArNTQ3LDcgQEAKICAqCiAgKiBleHQ0X3Nob3VsZF9yZXRyeV9hbGxvYygpIGlzIGNhbGxlZCB3aGVuIEVOT1NQQyBpcyByZXR1cm5lZCwgYW5kIGlmCiAgKiBpdCBpcyBwcm9maXRhYmxlIHRvIHJldHJ5IHRoZSBvcGVyYXRpb24sIHRoaXMgZnVuY3Rpb24gd2lsbCB3YWl0Ci0gKiBmb3IgdGhlIGN1cnJlbnQgb3IgY29tbWl0aW5nIHRyYW5zYWN0aW9uIHRvIGNvbXBsZXRlLCBhbmQgdGhlbgorICogZm9yIHRoZSBjdXJyZW50IG9yIGNvbW1pdHRpbmcgdHJhbnNhY3Rpb24gdG8gY29tcGxldGUsIGFuZCB0aGVuCiAgKiByZXR1cm4gVFJVRS4KICAqCiAgKiBpZiB0aGUgdG90YWwgbnVtYmVyIG9mIHJldHJpZXMgZXhjZWVkIHRocmVlIHRpbWVzLCByZXR1cm4gRkFMU0UuCmRpZmYgLS1naXQgYS9mcy9leHQ0L2V4dGVudHMuYyBiL2ZzL2V4dDQvZXh0ZW50cy5jCmluZGV4IGRkMmNiNTAuLjQ4OTBkNmYgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDQvZXh0ZW50cy5jCisrKyBiL2ZzL2V4dDQvZXh0ZW50cy5jCkBAIC0xNzI5LDcgKzE3MjksNyBAQAogCQlCVUdfT04obnBhdGgtPnBfZGVwdGggIT0gcGF0aC0+cF9kZXB0aCk7CiAJCWVoID0gbnBhdGhbZGVwdGhdLnBfaGRyOwogCQlpZiAobGUxNl90b19jcHUoZWgtPmVoX2VudHJpZXMpIDwgbGUxNl90b19jcHUoZWgtPmVoX21heCkpIHsKLQkJCWV4dF9kZWJ1ZygibmV4dCBsZWFmIGlzbnQgZnVsbCglZClcbiIsCisJCQlleHRfZGVidWcoIm5leHQgbGVhZiBpc24ndCBmdWxsKCVkKVxuIiwKIAkJCQkgIGxlMTZfdG9fY3B1KGVoLT5laF9lbnRyaWVzKSk7CiAJCQlwYXRoID0gbnBhdGg7CiAJCQlnb3RvIHJlcGVhdDsKQEAgLTI1MzMsNyArMjUzMyw3IEBACiAvKgogICogVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgYnkgZXh0NF9leHRfbWFwX2Jsb2NrcygpIGlmIHNvbWVvbmUgdHJpZXMgdG8gd3JpdGUKICAqIHRvIGFuIHVuaW5pdGlhbGl6ZWQgZXh0ZW50LiBJdCBtYXkgcmVzdWx0IGluIHNwbGl0dGluZyB0aGUgdW5pbml0aWFsaXplZAotICogZXh0ZW50IGludG8gbXVsdGlwbGUgZXh0ZW50cyAodXB0byB0aHJlZSAtIG9uZSBpbml0aWFsaXplZCBhbmQgdHdvCisgKiBleHRlbnQgaW50byBtdWx0aXBsZSBleHRlbnRzICh1cCB0byB0aHJlZSAtIG9uZSBpbml0aWFsaXplZCBhbmQgdHdvCiAgKiB1bmluaXRpYWxpemVkKS4KICAqIFRoZXJlIGFyZSB0aHJlZSBwb3NzaWJpbGl0aWVzOgogICogICBhPiBUaGVyZSBpcyBubyBzcGxpdCByZXF1aXJlZDogRW50aXJlIGV4dGVudCBzaG91bGQgYmUgaW5pdGlhbGl6ZWQKQEAgLTMxNzQsNyArMzE3NCw3IEBACiAJCQkJCQkgICBwYXRoLCBmbGFncyk7CiAJCS8qCiAJCSAqIEZsYWcgdGhlIGlub2RlKG5vbiBhaW8gY2FzZSkgb3IgZW5kX2lvIHN0cnVjdCAoYWlvIGNhc2UpCi0JCSAqIHRoYXQgdGhpcyBJTyBuZWVkcyB0byBjb252ZXJ0aW9uIHRvIHdyaXR0ZW4gd2hlbiBJTyBpcworCQkgKiB0aGF0IHRoaXMgSU8gbmVlZHMgdG8gY29udmVyc2lvbiB0byB3cml0dGVuIHdoZW4gSU8gaXMKIAkJICogY29tcGxldGVkCiAJCSAqLwogCQlpZiAoaW8gJiYgIShpby0+ZmxhZyAmIEVYVDRfSU9fRU5EX1VOV1JJVFRFTikpIHsKQEAgLTM0NjAsMTAgKzM0NjAsMTAgQEAKIAkJZXh0NF9leHRfbWFya191bmluaXRpYWxpemVkKCZuZXdleCk7CiAJCS8qCiAJCSAqIGlvX2VuZCBzdHJ1Y3R1cmUgd2FzIGNyZWF0ZWQgZm9yIGV2ZXJ5IElPIHdyaXRlIHRvIGFuCi0JCSAqIHVuaW5pdGlhbGl6ZWQgZXh0ZW50LiBUbyBhdm9pZCB1bmVjZXNzYXJ5IGNvbnZlcnNpb24sCisJCSAqIHVuaW5pdGlhbGl6ZWQgZXh0ZW50LiBUbyBhdm9pZCB1bm5lY2Vzc2FyeSBjb252ZXJzaW9uLAogCQkgKiBoZXJlIHdlIGZsYWcgdGhlIElPIHRoYXQgcmVhbGx5IG5lZWRzIHRoZSBjb252ZXJzaW9uLgogCQkgKiBGb3Igbm9uIGFzeWNuIGRpcmVjdCBJTyBjYXNlLCBmbGFnIHRoZSBpbm9kZSBzdGF0ZQotCQkgKiB0aGF0IHdlIG5lZWQgdG8gcGVyZm9ybSBjb252ZXJ0aW9uIHdoZW4gSU8gaXMgZG9uZS4KKwkJICogdGhhdCB3ZSBuZWVkIHRvIHBlcmZvcm0gY29udmVyc2lvbiB3aGVuIElPIGlzIGRvbmUuCiAJCSAqLwogCQlpZiAoKGZsYWdzICYgRVhUNF9HRVRfQkxPQ0tTX1BSRV9JTykpIHsKIAkJCWlmIChpbyAmJiAhKGlvLT5mbGFnICYgRVhUNF9JT19FTkRfVU5XUklUVEVOKSkgewpkaWZmIC0tZ2l0IGEvZnMvZXh0NC9mc3luYy5jIGIvZnMvZXh0NC9mc3luYy5jCmluZGV4IDdmNzQwMTkuLjQ2NzNiYzAgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDQvZnN5bmMuYworKysgYi9mcy9leHQ0L2ZzeW5jLmMKQEAgLTEwMSw3ICsxMDEsNyBAQAogCQkgKiB0byB0aGUgd29yay10by1iZSBzY2hlZHVsZSBpcyBmcmVlZC4KIAkJICoKIAkJICogVGh1cyB3ZSBuZWVkIHRvIGtlZXAgdGhlIGlvIHN0cnVjdHVyZSBzdGlsbCB2YWxpZCBoZXJlIGFmdGVyCi0JCSAqIGNvbnZlcnRpb24gZmluaXNoZWQuIFRoZSBpbyBzdHJ1Y3R1cmUgaGFzIGEgZmxhZyB0bworCQkgKiBjb252ZXJzaW9uIGZpbmlzaGVkLiBUaGUgaW8gc3RydWN0dXJlIGhhcyBhIGZsYWcgdG8KIAkJICogYXZvaWQgZG91YmxlIGNvbnZlcnRpbmcgZnJvbSBib3RoIGZzeW5jIGFuZCBiYWNrZ3JvdW5kIHdvcmsKIAkJICogcXVldWUgd29yay4KIAkJICovCmRpZmYgLS1naXQgYS9mcy9leHQ0L2lub2RlLmMgYi9mcy9leHQ0L2lub2RlLmMKaW5kZXggMWE4NjI4Mi4uYWQ4ZTMwMyAxMDA2NDQKLS0tIGEvZnMvZXh0NC9pbm9kZS5jCisrKyBiL2ZzL2V4dDQvaW5vZGUuYwpAQCAtMjU4OCw3ICsyNTg4LDcgQEAKICAqIGJlY2F1c2Ugd2Ugc2hvdWxkIGhhdmUgaG9sZXMgZmlsbGVkIGZyb20gZXh0NF9wYWdlX21rd3JpdGUoKS4gV2UgZXZlbiBkb24ndAogICogbmVlZCB0byBmaWxlIHRoZSBpbm9kZSB0byB0aGUgdHJhbnNhY3Rpb24ncyBsaXN0IGluIG9yZGVyZWQgbW9kZSBiZWNhdXNlIGlmCiAgKiB3ZSBhcmUgd3JpdGluZyBiYWNrIGRhdGEgYWRkZWQgYnkgd3JpdGUoKSwgdGhlIGlub2RlIGlzIGFscmVhZHkgdGhlcmUgYW5kIGlmCi0gKiB3ZSBhcmUgd3JpdGluZyBiYWNrIGRhdGEgbW9kaWZpZWQgdmlhIG1tYXAoKSwgbm9vbmUgZ3VhcmFudGVlcyBpbiB3aGljaAorICogd2UgYXJlIHdyaXRpbmcgYmFjayBkYXRhIG1vZGlmaWVkIHZpYSBtbWFwKCksIG5vIG9uZSBndWFyYW50ZWVzIGluIHdoaWNoCiAgKiB0cmFuc2FjdGlvbiB0aGUgZGF0YSB3aWxsIGhpdCB0aGUgZGlzay4gSW4gY2FzZSB3ZSBhcmUgam91cm5hbGluZyBkYXRhLCB3ZQogICogY2Fubm90IHN0YXJ0IHRyYW5zYWN0aW9uIGRpcmVjdGx5IGJlY2F1c2UgdHJhbnNhY3Rpb24gc3RhcnQgcmFua3MgYWJvdmUgcGFnZQogICogbG9jayBzbyB3ZSBoYXZlIHRvIGRvIHNvbWUgbWFnaWMuCkBAIC0yNjkwLDcgKzI2OTAsNyBAQAogCiAvKgogICogVGhpcyBpcyBjYWxsZWQgdmlhIGV4dDRfZGFfd3JpdGVwYWdlcygpIHRvCi0gKiBjYWx1bGF0ZSB0aGUgdG90YWwgbnVtYmVyIG9mIGNyZWRpdHMgdG8gcmVzZXJ2ZSB0byBmaXQKKyAqIGNhbGN1bGF0ZSB0aGUgdG90YWwgbnVtYmVyIG9mIGNyZWRpdHMgdG8gcmVzZXJ2ZSB0byBmaXQKICAqIGEgc2luZ2xlIGV4dGVudCBhbGxvY2F0aW9uIGludG8gYSBzaW5nbGUgdHJhbnNhY3Rpb24sCiAgKiBleHQ0X2RhX3dyaXRwZWFnZXMoKSB3aWxsIGxvb3AgY2FsbGluZyB0aGlzIGJlZm9yZQogICogdGhlIGJsb2NrIGFsbG9jYXRpb24uCkBAIC0zMzA0LDcgKzMzMDQsNyBAQAogCSAqIHRoZSBwYWdlcyBieSBjYWxsaW5nIHJlZGlydHlfcGFnZV9mb3Jfd3JpdGVwYWdlKCkgYnV0IHRoYXQKIAkgKiB3b3VsZCBiZSB1Z2x5IGluIHRoZSBleHRyZW1lLiAgU28gaW5zdGVhZCB3ZSB3b3VsZCBuZWVkIHRvCiAJICogcmVwbGljYXRlIHBhcnRzIG9mIHRoZSBjb2RlIGluIHRoZSBhYm92ZSBmdW5jdGlvbnMsCi0JICogc2ltcGxpZnlpbmcgdGhlbSBiZWN1YXNlIHdlIHdvdWxkbid0IGFjdHVhbGx5IGludGVuZCB0bworCSAqIHNpbXBsaWZ5aW5nIHRoZW0gYmVjYXVzZSB3ZSB3b3VsZG4ndCBhY3R1YWxseSBpbnRlbmQgdG8KIAkgKiB3cml0ZSBvdXQgdGhlIHBhZ2VzLCBidXQgcmF0aGVyIG9ubHkgY29sbGVjdCBjb250aWd1b3VzCiAJICogbG9naWNhbCBibG9jayBleHRlbnRzLCBjYWxsIHRoZSBtdWx0aS1ibG9jayBhbGxvY2F0b3IsIGFuZAogCSAqIHRoZW4gdXBkYXRlIHRoZSBidWZmZXIgaGVhZHMgd2l0aCB0aGUgYmxvY2sgYWxsb2NhdGlvbnMuCkBAIC0zNjk0LDcgKzM2OTQsNyBAQAogICoKICAqIFRoZSB1bndycml0dGVuIGV4dGVudHMgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gd3JpdHRlbiB3aGVuIERJTyBpcyBjb21wbGV0ZWQuCiAgKiBGb3IgYXN5bmMgZGlyZWN0IElPLCBzaW5jZSB0aGUgSU8gbWF5IHN0aWxsIHBlbmRpbmcgd2hlbiByZXR1cm4sIHdlCi0gKiBzZXQgdXAgYW4gZW5kX2lvIGNhbGwgYmFjayBmdW5jdGlvbiwgd2hpY2ggd2lsbCBkbyB0aGUgY29udmVydGlvbgorICogc2V0IHVwIGFuIGVuZF9pbyBjYWxsIGJhY2sgZnVuY3Rpb24sIHdoaWNoIHdpbGwgZG8gdGhlIGNvbnZlcnNpb24KICAqIHdoZW4gYXN5bmMgZGlyZWN0IElPIGNvbXBsZXRlZC4KICAqCiAgKiBJZiB0aGUgT19ESVJFQ1Qgd3JpdGUgd2lsbCBleHRlbmQgdGhlIGZpbGUgdGhlbiBhZGQgdGhpcyBpbm9kZSB0byB0aGUKQEAgLTM3MTcsNyArMzcxNyw3IEBACiAgCQkgKiBXZSBjb3VsZCBkaXJlY3Qgd3JpdGUgdG8gaG9sZXMgYW5kIGZhbGxvY2F0ZS4KIAkJICoKICAJCSAqIEFsbG9jYXRlZCBibG9ja3MgdG8gZmlsbCB0aGUgaG9sZSBhcmUgbWFya2VkIGFzIHVuaW5pdGlhbGl6ZWQKLSAJCSAqIHRvIHByZXZlbnQgcGFyYWxlbCBidWZmZXJlZCByZWFkIHRvIGV4cG9zZSB0aGUgc3RhbGUgZGF0YQorIAkJICogdG8gcHJldmVudCBwYXJhbGxlbCBidWZmZXJlZCByZWFkIHRvIGV4cG9zZSB0aGUgc3RhbGUgZGF0YQogIAkJICogYmVmb3JlIERJTyBjb21wbGV0ZSB0aGUgZGF0YSBJTy4KIAkJICoKICAJCSAqIEFzIHRvIHByZXZpb3VzbHkgZmFsbG9jYXRlZCBleHRlbnRzLCBleHQ0IGdldF9ibG9jawpAQCAtMzc3OCw3ICszNzc4LDcgQEAKIAkJCWludCBlcnI7CiAJCQkvKgogCQkJICogZm9yIG5vbiBBSU8gY2FzZSwgc2luY2UgdGhlIElPIGlzIGFscmVhZHkKLQkJCSAqIGNvbXBsZXRlZCwgd2UgY291bGQgZG8gdGhlIGNvbnZlcnRpb24gcmlnaHQgaGVyZQorCQkJICogY29tcGxldGVkLCB3ZSBjb3VsZCBkbyB0aGUgY29udmVyc2lvbiByaWdodCBoZXJlCiAJCQkgKi8KIAkJCWVyciA9IGV4dDRfY29udmVydF91bndyaXR0ZW5fZXh0ZW50cyhpbm9kZSwKIAkJCQkJCQkgICAgIG9mZnNldCwgcmV0KTsKQEAgLTQwMjUsNyArNDAyNSw3IEBACiAgKgogICoJV2hlbiB3ZSBkbyB0cnVuY2F0ZSgpIHdlIG1heSBoYXZlIHRvIGNsZWFuIHRoZSBlbmRzIG9mIHNldmVyYWwKICAqCWluZGlyZWN0IGJsb2NrcyBidXQgbGVhdmUgdGhlIGJsb2NrcyB0aGVtc2VsdmVzIGFsaXZlLiBCbG9jayBpcwotICoJcGFydGlhbGx5IHRydW5jYXRlZCBpZiBzb21lIGRhdGEgYmVsb3cgdGhlIG5ldyBpX3NpemUgaXMgcmVmZXJlZAorICoJcGFydGlhbGx5IHRydW5jYXRlZCBpZiBzb21lIGRhdGEgYmVsb3cgdGhlIG5ldyBpX3NpemUgaXMgcmVmZXJyZWQKICAqCWZyb20gaXQgKGFuZCBpdCBpcyBvbiB0aGUgcGF0aCB0byB0aGUgZmlyc3QgY29tcGxldGVseSB0cnVuY2F0ZWQKICAqCWRhdGEgYmxvY2ssIGluZGVlZCkuICBXZSBoYXZlIHRvIGZyZWUgdGhlIHRvcCBvZiB0aGF0IHBhdGggYWxvbmcKICAqCXdpdGggZXZlcnl0aGluZyB0byB0aGUgcmlnaHQgb2YgdGhlIHBhdGguIFNpbmNlIG5vIGFsbG9jYXRpb24KQEAgLTQxNjksNyArNDE2OSw3IEBACiAgKiBAZmlyc3Q6CWFycmF5IG9mIGJsb2NrIG51bWJlcnMKICAqIEBsYXN0Oglwb2ludHMgaW1tZWRpYXRlbHkgcGFzdCB0aGUgZW5kIG9mIGFycmF5CiAgKgotICogV2UgYXJlIGZyZWVpbmcgYWxsIGJsb2NrcyByZWZlcmVkIGZyb20gdGhhdCBhcnJheSAobnVtYmVycyBhcmUgc3RvcmVkIGFzCisgKiBXZSBhcmUgZnJlZWluZyBhbGwgYmxvY2tzIHJlZmVycmVkIGZyb20gdGhhdCBhcnJheSAobnVtYmVycyBhcmUgc3RvcmVkIGFzCiAgKiBsaXR0bGUtZW5kaWFuIDMyLWJpdCkgYW5kIHVwZGF0aW5nIEBpbm9kZS0+aV9ibG9ja3MgYXBwcm9wcmlhdGVseS4KICAqCiAgKiBXZSBhY2N1bXVsYXRlIGNvbnRpZ3VvdXMgcnVucyBvZiBibG9ja3MgdG8gZnJlZS4gIENvbnZlbmllbnRseSwgaWYgdGhlc2UKQEAgLTQyNjEsNyArNDI2MSw3IEBACiAgKglAbGFzdDoJcG9pbnRlciBpbW1lZGlhdGVseSBwYXN0IHRoZSBlbmQgb2YgYXJyYXkKICAqCUBkZXB0aDoJZGVwdGggb2YgdGhlIGJyYW5jaGVzIHRvIGZyZWUKICAqCi0gKglXZSBhcmUgZnJlZWluZyBhbGwgYmxvY2tzIHJlZmVyZWQgZnJvbSB0aGVzZSBicmFuY2hlcyAobnVtYmVycyBhcmUKKyAqCVdlIGFyZSBmcmVlaW5nIGFsbCBibG9ja3MgcmVmZXJyZWQgZnJvbSB0aGVzZSBicmFuY2hlcyAobnVtYmVycyBhcmUKICAqCXN0b3JlZCBhcyBsaXR0bGUtZW5kaWFuIDMyLWJpdCkgYW5kIHVwZGF0aW5nIEBpbm9kZS0+aV9ibG9ja3MKICAqCWFwcHJvcHJpYXRlbHkuCiAgKi8KQEAgLTU0NzgsNyArNTQ3OCw3IEBACiB9CiAKIC8qCi0gKiBDYWx1bGF0ZSB0aGUgdG90YWwgbnVtYmVyIG9mIGNyZWRpdHMgdG8gcmVzZXJ2ZSB0byBmaXQKKyAqIENhbGN1bGF0ZSB0aGUgdG90YWwgbnVtYmVyIG9mIGNyZWRpdHMgdG8gcmVzZXJ2ZSB0byBmaXQKICAqIHRoZSBtb2RpZmljYXRpb24gb2YgYSBzaW5nbGUgcGFnZXMgaW50byBhIHNpbmdsZSB0cmFuc2FjdGlvbiwKICAqIHdoaWNoIG1heSBpbmNsdWRlIG11bHRpcGxlIGNodW5rcyBvZiBibG9jayBhbGxvY2F0aW9ucy4KICAqCmRpZmYgLS1naXQgYS9mcy9leHQ0L21iYWxsb2MuYyBiL2ZzL2V4dDQvbWJhbGxvYy5jCmluZGV4IGE1ODM3YTguLmQ4YTE2ZWUgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDQvbWJhbGxvYy5jCisrKyBiL2ZzL2V4dDQvbWJhbGxvYy5jCkBAIC05Miw3ICs5Miw3IEBACiAgKiBiZXR3ZWVuIENQVXMuIEl0IGlzIHBvc3NpYmxlIHRvIGdldCBzY2hlZHVsZWQgYXQgdGhpcyBwb2ludC4KICAqCiAgKiBUaGUgbG9jYWxpdHkgZ3JvdXAgcHJlYWxsb2Mgc3BhY2UgaXMgdXNlZCBsb29raW5nIGF0IHdoZXRoZXIgd2UgaGF2ZQotICogZW5vdWdoIGZyZWUgc3BhY2UgKHBhX2ZyZWUpIHdpdGhpbmcgdGhlIHByZWFsbG9jIHNwYWNlLgorICogZW5vdWdoIGZyZWUgc3BhY2UgKHBhX2ZyZWUpIHdpdGhpbiB0aGUgcHJlYWxsb2Mgc3BhY2UuCiAgKgogICogSWYgd2UgY2FuJ3QgYWxsb2NhdGUgYmxvY2tzIHZpYSBpbm9kZSBwcmVhbGxvYyBvci9hbmQgbG9jYWxpdHkgZ3JvdXAKICAqIHByZWFsbG9jIHRoZW4gd2UgbG9vayBhdCB0aGUgYnVkZHkgY2FjaGUuIFRoZSBidWRkeSBjYWNoZSBpcyByZXByZXNlbnRlZApkaWZmIC0tZ2l0IGEvZnMvZXh0NC9taWdyYXRlLmMgYi9mcy9leHQ0L21pZ3JhdGUuYwppbmRleCBkMWJhZmE1Li45MjgxNmI0IDEwMDY0NAotLS0gYS9mcy9leHQ0L21pZ3JhdGUuYworKysgYi9mcy9leHQ0L21pZ3JhdGUuYwpAQCAtNTE3LDcgKzUxNyw3IEBACiAJICogc3RhcnQgd2l0aCBvbmUgY3JlZGl0IGFjY291bnRlZCBmb3IKIAkgKiBzdXBlcmJsb2NrIG1vZGlmaWNhdGlvbi4KIAkgKgotCSAqIEZvciB0aGUgdG1wX2lub2RlIHdlIGFscmVhZHkgaGF2ZSBjb21taXRlZCB0aGUKKwkgKiBGb3IgdGhlIHRtcF9pbm9kZSB3ZSBhbHJlYWR5IGhhdmUgY29tbWl0dGVkIHRoZQogCSAqIHRyYXNjYXRpb24gdGhhdCBjcmVhdGVkIHRoZSBpbm9kZS4gTGF0ZXIgYXMgYW5kCiAJICogd2hlbiB3ZSBhZGQgZXh0ZW50cyB3ZSBleHRlbnQgdGhlIGpvdXJuYWwKIAkgKi8KZGlmZiAtLWdpdCBhL2ZzL2V4dDQvc3VwZXIuYyBiL2ZzL2V4dDQvc3VwZXIuYwppbmRleCAyMjU0NmFkLi4wNTY0NzRiIDEwMDY0NAotLS0gYS9mcy9leHQ0L3N1cGVyLmMKKysrIGIvZnMvZXh0NC9zdXBlci5jCkBAIC02MTcsNyArNjE3LDcgQEAKIAkgKiBmaWxlc3lzdGVtIHdpbGwgaGF2ZSBhbHJlYWR5IGJlZW4gbWFya2VkIHJlYWQvb25seSBhbmQgdGhlCiAJICogam91cm5hbCBoYXMgYmVlbiBhYm9ydGVkLiAgV2UgcmV0dXJuIDEgYXMgYSBoaW50IHRvIGNhbGxlcnMKIAkgKiB3aG8gbWlnaHQgd2hhdCB0byB1c2UgdGhlIHJldHVybiB2YWx1ZSBmcm9tCi0JICogZXh0NF9ncnBfbG9ja2VkX2Vycm9yKCkgdG8gZGlzdGluZ3Vpc2ggYmV3ZWVuIHRoZQorCSAqIGV4dDRfZ3JwX2xvY2tlZF9lcnJvcigpIHRvIGRpc3Rpbmd1aXNoIGJldHdlZW4gdGhlCiAJICogRVJST1JTX0NPTlQgYW5kIEVSUk9SU19STyBjYXNlLCBhbmQgcGVyaGFwcyByZXR1cm4gbW9yZQogCSAqIGFnZ3Jlc3NpdmVseSBmcm9tIHRoZSBleHQ0IGZ1bmN0aW9uIGluIHF1ZXN0aW9uLCB3aXRoIGEKIAkgKiBtb3JlIGFwcHJvcHJpYXRlIGVycm9yIGNvZGUuCkBAIC00NjI0LDcgKzQ2MjQsNyBAQAogCiAvKiBSZWFkIGRhdGEgZnJvbSBxdW90YWZpbGUgLSBhdm9pZCBwYWdlY2FjaGUgYW5kIHN1Y2ggYmVjYXVzZSB3ZSBjYW5ub3QgYWZmb3JkCiAgKiBhY3F1aXJpbmcgdGhlIGxvY2tzLi4uIEFzIHF1b3RhIGZpbGVzIGFyZSBuZXZlciB0cnVuY2F0ZWQgYW5kIHF1b3RhIGNvZGUKLSAqIGl0c2VsZiBzZXJpYWxpemVzIHRoZSBvcGVyYXRpb25zIChhbmQgbm9vbmUgZWxzZSBzaG91bGQgdG91Y2ggdGhlIGZpbGVzKQorICogaXRzZWxmIHNlcmlhbGl6ZXMgdGhlIG9wZXJhdGlvbnMgKGFuZCBubyBvbmUgZWxzZSBzaG91bGQgdG91Y2ggdGhlIGZpbGVzKQogICogd2UgZG9uJ3QgaGF2ZSB0byBiZSBhZnJhaWQgb2YgcmFjZXMgKi8KIHN0YXRpYyBzc2l6ZV90IGV4dDRfcXVvdGFfcmVhZChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgY2hhciAqZGF0YSwKIAkJCSAgICAgICBzaXplX3QgbGVuLCBsb2ZmX3Qgb2ZmKQpkaWZmIC0tZ2l0IGEvZnMvZnJlZXZ4ZnMvdnhmc19mc2hlYWQuYyBiL2ZzL2ZyZWV2eGZzL3Z4ZnNfZnNoZWFkLmMKaW5kZXggNzg5NDhiNC4uYzlhNmE5NCAxMDA2NDQKLS0tIGEvZnMvZnJlZXZ4ZnMvdnhmc19mc2hlYWQuYworKysgYi9mcy9mcmVldnhmcy92eGZzX2ZzaGVhZC5jCkBAIC0xNjQsNyArMTY0LDcgQEAKIAkJZ290byBvdXRfZnJlZV9wZnA7CiAJfQogCWlmICghVlhGU19JU0lMVChWWEZTX0lOTyhpbmZwLT52c2lfc3RpbGlzdCkpKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAidnhmczogc3RydWN0dWFsIGxpc3QgaW5vZGUgaXMgb2Ygd3JvbmcgdHlwZSAoJXgpXG4iLAorCQlwcmludGsoS0VSTl9FUlIgInZ4ZnM6IHN0cnVjdHVyYWwgbGlzdCBpbm9kZSBpcyBvZiB3cm9uZyB0eXBlICgleClcbiIsCiAJCQkJVlhGU19JTk8oaW5mcC0+dnNpX3N0aWxpc3QpLT52aWlfbW9kZSAmIFZYRlNfVFlQRV9NQVNLKTsgCiAJCWdvdG8gb3V0X2lwdXRfc3RpbGlzdDsKIAl9CmRpZmYgLS1naXQgYS9mcy9mcmVldnhmcy92eGZzX2xvb2t1cC5jIGIvZnMvZnJlZXZ4ZnMvdnhmc19sb29rdXAuYwppbmRleCA2YzUxMzFkLi4zMzYwZjFlIDEwMDY0NAotLS0gYS9mcy9mcmVldnhmcy92eGZzX2xvb2t1cC5jCisrKyBiL2ZzL2ZyZWV2eGZzL3Z4ZnNfbG9va3VwLmMKQEAgLTE2Miw3ICsxNjIsNyBAQAogLyoqCiAgKiB2eGZzX2lub2RlX2J5X25hbWUgLSBmaW5kIGlub2RlIG51bWJlciBmb3IgZGVudHJ5CiAgKiBAZGlwOglkaXJlY3RvcnkgdG8gc2VhcmNoIGluCi0gKiBAZHA6CQlkZW50cnkgd2Ugc2VhY2ggZm9yCisgKiBAZHA6CQlkZW50cnkgd2Ugc2VhcmNoIGZvcgogICoKICAqIERlc2NyaXB0aW9uOgogICogICB2eGZzX2lub2RlX2J5X25hbWUgZmluZHMgb3V0IHRoZSBpbm9kZSBudW1iZXIgb2YKZGlmZiAtLWdpdCBhL2ZzL2ZyZWV2eGZzL3Z4ZnNfb2x0LmggYi9mcy9mcmVldnhmcy92eGZzX29sdC5oCmluZGV4IGQ4MzI0MjkuLmI3YjNhZjUgMTAwNjQ0Ci0tLSBhL2ZzL2ZyZWV2eGZzL3Z4ZnNfb2x0LmgKKysrIGIvZnMvZnJlZXZ4ZnMvdnhmc19vbHQuaApAQCAtNjAsNyArNjAsNyBAQAogICoKICAqIFRoZSBPYmplY3QgTG9jYXRpb24gVGFibGUgaGVhZGVyIGlzIHBsYWNlZCBhdCB0aGUgYmVnaW5uaW5nIG9mIGVhY2gKICAqIE9MVCBleHRlbnQuICBJdCBpcyB1c2VkIHRvIGZpbmcgY2VydGFpbiBmaWxlc3lzdGVtLXdpZGUgbWV0YWRhdGEsIGUuZy4KLSAqIHRoZSBpbml0YWwgaW5vZGUgbGlzdCwgdGhlIGZpbGVzZXQgaGVhZGVyIG9yIHRoZSBkZXZpY2UgY29uZmlndXJhdGlvbi4KKyAqIHRoZSBpbml0aWFsIGlub2RlIGxpc3QsIHRoZSBmaWxlc2V0IGhlYWRlciBvciB0aGUgZGV2aWNlIGNvbmZpZ3VyYXRpb24uCiAgKi8KIHN0cnVjdCB2eGZzX29sdCB7CiAJdV9pbnQzMl90CW9sdF9tYWdpYzsJLyogbWFnaWMgbnVtYmVyCQkJKi8KZGlmZiAtLWdpdCBhL2ZzL2ZzLXdyaXRlYmFjay5jIGIvZnMvZnMtd3JpdGViYWNrLmMKaW5kZXggYjVlZDU0MS4uMzQ1OTFlZTggMTAwNjQ0Ci0tLSBhL2ZzL2ZzLXdyaXRlYmFjay5jCisrKyBiL2ZzL2ZzLXdyaXRlYmFjay5jCkBAIC0xNDQsNyArMTQ0LDcgQEAKICAqCiAgKiBEZXNjcmlwdGlvbjoKICAqICAgVGhpcyBkb2VzIFdCX1NZTkNfTk9ORSBvcHBvcnR1bmlzdGljIHdyaXRlYmFjay4gVGhlIElPIGlzIG9ubHkKLSAqICAgc3RhcnRlZCB3aGVuIHRoaXMgZnVuY3Rpb24gcmV0dXJucywgd2UgbWFrZSBubyBndWFyZW50ZWVzIG9uCisgKiAgIHN0YXJ0ZWQgd2hlbiB0aGlzIGZ1bmN0aW9uIHJldHVybnMsIHdlIG1ha2Ugbm8gZ3VhcmFudGVlcyBvbgogICogICBjb21wbGV0aW9uLiBDYWxsZXIgbmVlZCBub3QgaG9sZCBzYiBzX3Vtb3VudCBzZW1hcGhvcmUuCiAgKgogICovCmRpZmYgLS1naXQgYS9mcy9mdXNlL2ZpbGUuYyBiL2ZzL2Z1c2UvZmlsZS5jCmluZGV4IDZlYTAwNzMuLjgyYTY2NDYgMTAwNjQ0Ci0tLSBhL2ZzL2Z1c2UvZmlsZS5jCisrKyBiL2ZzL2Z1c2UvZmlsZS5jCkBAIC01MjMsNyArNTIzLDcgQEAKIAkJZ290byBvdXQ7CiAKIAkvKgotCSAqIFBhZ2Ugd3JpdGViYWNrIGNhbiBleHRlbmQgYmV5b25kIHRoZSBsaWZ0aW1lIG9mIHRoZQorCSAqIFBhZ2Ugd3JpdGViYWNrIGNhbiBleHRlbmQgYmV5b25kIHRoZSBsaWZldGltZSBvZiB0aGUKIAkgKiBwYWdlLWNhY2hlIHBhZ2UsIHNvIG1ha2Ugc3VyZSB3ZSByZWFkIGEgcHJvcGVybHkgc3luY2VkCiAJICogcGFnZS4KIAkgKi8KZGlmZiAtLWdpdCBhL2ZzL2dmczIvYm1hcC5jIGIvZnMvZ2ZzMi9ibWFwLmMKaW5kZXggZWYzZGM0Yi4uNzRhZGQyZCAxMDA2NDQKLS0tIGEvZnMvZ2ZzMi9ibWFwLmMKKysrIGIvZnMvZ2ZzMi9ibWFwLmMKQEAgLTExMzYsNyArMTEzNiw3IEBACiAgKiBlYXJsaWVyIHZlcnNpb25zIG9mIEdGUzIgaGF2ZSBhIGJ1ZyBpbiB0aGUgc3R1ZmZlZCBmaWxlIHJlYWRpbmcKICAqIGNvZGUgd2hpY2ggd2lsbCByZXN1bHQgaW4gYSBidWZmZXIgb3ZlcnJ1biBpZiB0aGUgc2l6ZSBpcyBsYXJnZXIKICAqIHRoYW4gdGhlIG1heCBzdHVmZmVkIGZpbGUgc2l6ZS4gSW4gb3JkZXIgdG8gcHJldmVudCB0aGlzIGZyb20KLSAqIG9jY3VyaW5nLCBzdWNoIGZpbGVzIGFyZSB1bnN0dWZmZWQsIGJ1dCBpbiBvdGhlciBjYXNlcyB3ZSBjYW4KKyAqIG9jY3VycmluZywgc3VjaCBmaWxlcyBhcmUgdW5zdHVmZmVkLCBidXQgaW4gb3RoZXIgY2FzZXMgd2UgY2FuCiAgKiBqdXN0IHVwZGF0ZSB0aGUgaW5vZGUgc2l6ZSBkaXJlY3RseS4KICAqCiAgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIG9yIC12ZSBvbiBlcnJvcgpkaWZmIC0tZ2l0IGEvZnMvZ2ZzMi9nbG9jay5jIGIvZnMvZ2ZzMi9nbG9jay5jCmluZGV4IGUyNDMxMzEuLmYwNzY0M2UgMTAwNjQ0Ci0tLSBhL2ZzL2dmczIvZ2xvY2suYworKysgYi9mcy9nZnMyL2dsb2NrLmMKQEAgLTExMjMsNyArMTEyMyw3IEBACiAgKiBAbnVtYmVyOiB0aGUgbG9jayBudW1iZXIKICAqIEBnbG9wczogdGhlIGdsb2NrIG9wZXJhdGlvbnMgZm9yIHRoZSB0eXBlIG9mIGdsb2NrCiAgKiBAc3RhdGU6IHRoZSBzdGF0ZSB0byBhY3F1aXJlIHRoZSBnbG9jayBpbgotICogQGZsYWdzOiBtb2RpZmllciBmbGFncyBmb3IgdGhlIGFxdWlzaXRpb24KKyAqIEBmbGFnczogbW9kaWZpZXIgZmxhZ3MgZm9yIHRoZSBhY3F1aXNpdGlvbgogICogQGdoOiB0aGUgc3RydWN0IGdmczJfaG9sZGVyCiAgKgogICogUmV0dXJuczogZXJybm8KZGlmZiAtLWdpdCBhL2ZzL2dmczIvc3VwZXIuYyBiL2ZzL2dmczIvc3VwZXIuYwppbmRleCBlYzczZWQ3Li5hNGUyM2Q2IDEwMDY0NAotLS0gYS9mcy9nZnMyL3N1cGVyLmMKKysrIGIvZnMvZ2ZzMi9zdXBlci5jCkBAIC02NTcsNyArNjU3LDcgQEAKICAqIEBzZHA6IHRoZSBmaWxlIHN5c3RlbQogICoKICAqIFRoaXMgZnVuY3Rpb24gZmx1c2hlcyBkYXRhIGFuZCBtZXRhIGRhdGEgZm9yIGFsbCBtYWNoaW5lcyBieQotICogYXF1aXJpbmcgdGhlIHRyYW5zYWN0aW9uIGxvZyBleGNsdXNpdmVseS4gIEFsbCBqb3VybmFscyBhcmUKKyAqIGFjcXVpcmluZyB0aGUgdHJhbnNhY3Rpb24gbG9nIGV4Y2x1c2l2ZWx5LiAgQWxsIGpvdXJuYWxzIGFyZQogICogZW5zdXJlZCB0byBiZSBpbiBhIGNsZWFuIHN0YXRlIGFzIHdlbGwuCiAgKgogICogUmV0dXJuczogZXJybm8KZGlmZiAtLWdpdCBhL2ZzL2piZC9jb21taXQuYyBiL2ZzL2piZC9jb21taXQuYwppbmRleCBkYTg3MWVlLi42OWIxODA0IDEwMDY0NAotLS0gYS9mcy9qYmQvY29tbWl0LmMKKysrIGIvZnMvamJkL2NvbW1pdC5jCkBAIC0zNjIsNyArMzYyLDcgQEAKIAkgKiB3ZSBkbyBub3QgcmVxdWlyZSBpdCB0byByZW1lbWJlciBleGFjdGx5IHdoaWNoIG9sZCBidWZmZXJzIGl0CiAJICogaGFzIHJlc2VydmVkLiAgVGhpcyBpcyBjb25zaXN0ZW50IHdpdGggdGhlIGV4aXN0aW5nIGJlaGF2aW91cgogCSAqIHRoYXQgbXVsdGlwbGUgam91cm5hbF9nZXRfd3JpdGVfYWNjZXNzKCkgY2FsbHMgdG8gdGhlIHNhbWUKLQkgKiBidWZmZXIgYXJlIHBlcmZlY3RseSBwZXJtaXNzYWJsZS4KKwkgKiBidWZmZXIgYXJlIHBlcmZlY3RseSBwZXJtaXNzaWJsZS4KIAkgKi8KIAl3aGlsZSAoY29tbWl0X3RyYW5zYWN0aW9uLT50X3Jlc2VydmVkX2xpc3QpIHsKIAkJamggPSBjb21taXRfdHJhbnNhY3Rpb24tPnRfcmVzZXJ2ZWRfbGlzdDsKZGlmZiAtLWdpdCBhL2ZzL2piZC9qb3VybmFsLmMgYi9mcy9qYmQvam91cm5hbC5jCmluZGV4IGViMTE2MDEuLmIzNzEzYWYgMTAwNjQ0Ci0tLSBhL2ZzL2piZC9qb3VybmFsLmMKKysrIGIvZnMvamJkL2pvdXJuYWwuYwpAQCAtNzcwLDcgKzc3MCw3IEBACiAJam91cm5hbC0+al93YnVmc2l6ZSA9IG47CiAJam91cm5hbC0+al93YnVmID0ga21hbGxvYyhuICogc2l6ZW9mKHN0cnVjdCBidWZmZXJfaGVhZCopLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWpvdXJuYWwtPmpfd2J1ZikgewotCQlwcmludGsoS0VSTl9FUlIgIiVzOiBDYW50IGFsbG9jYXRlIGJocyBmb3IgY29tbWl0IHRocmVhZFxuIiwKKwkJcHJpbnRrKEtFUk5fRVJSICIlczogQ2FuJ3QgYWxsb2NhdGUgYmhzIGZvciBjb21taXQgdGhyZWFkXG4iLAogCQkJX19mdW5jX18pOwogCQlnb3RvIG91dF9lcnI7CiAJfQpAQCAtODMxLDcgKzgzMSw3IEBACiAJam91cm5hbC0+al93YnVmc2l6ZSA9IG47CiAJam91cm5hbC0+al93YnVmID0ga21hbGxvYyhuICogc2l6ZW9mKHN0cnVjdCBidWZmZXJfaGVhZCopLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWpvdXJuYWwtPmpfd2J1ZikgewotCQlwcmludGsoS0VSTl9FUlIgIiVzOiBDYW50IGFsbG9jYXRlIGJocyBmb3IgY29tbWl0IHRocmVhZFxuIiwKKwkJcHJpbnRrKEtFUk5fRVJSICIlczogQ2FuJ3QgYWxsb2NhdGUgYmhzIGZvciBjb21taXQgdGhyZWFkXG4iLAogCQkJX19mdW5jX18pOwogCQlnb3RvIG91dF9lcnI7CiAJfQpkaWZmIC0tZ2l0IGEvZnMvamJkL3Jldm9rZS5jIGIvZnMvamJkL3Jldm9rZS5jCmluZGV4IGQyOTAxODMuLjMwNWE5MDcgMTAwNjQ0Ci0tLSBhL2ZzL2piZC9yZXZva2UuYworKysgYi9mcy9qYmQvcmV2b2tlLmMKQEAgLTcxLDcgKzcxLDcgQEAKICAqIHN3aXRjaGluZyBoYXNoIHRhYmxlcyB1bmRlciB0aGVtLiBGb3Igb3BlcmF0aW9ucyBvbiB0aGUgbGlzdHMgb2YgZW50cmllcyBpbgogICogdGhlIGhhc2ggdGFibGUgal9yZXZva2VfbG9jayBpcyB1c2VkLgogICoKLSAqIEZpbmFsbHksIGFsc28gcmVwbGF5IGNvZGUgdXNlcyB0aGUgaGFzaCB0YWJsZXMgYnV0IGF0IHRoaXMgbW9tZW50IG5vb25lIGVsc2UKKyAqIEZpbmFsbHksIGFsc28gcmVwbGF5IGNvZGUgdXNlcyB0aGUgaGFzaCB0YWJsZXMgYnV0IGF0IHRoaXMgbW9tZW50IG5vIG9uZSBlbHNlCiAgKiBjYW4gdG91Y2ggdGhlbSAoZmlsZXN5c3RlbSBpc24ndCBtb3VudGVkIHlldCkgYW5kIGhlbmNlIG5vIGxvY2tpbmcgaXMKICAqIG5lZWRlZC4KICAqLwpkaWZmIC0tZ2l0IGEvZnMvamJkL3RyYW5zYWN0aW9uLmMgYi9mcy9qYmQvdHJhbnNhY3Rpb24uYwppbmRleCA1YjJlNGMzLi42MGQyMzE5IDEwMDY0NAotLS0gYS9mcy9qYmQvdHJhbnNhY3Rpb24uYworKysgYi9mcy9qYmQvdHJhbnNhY3Rpb24uYwpAQCAtMTM5Miw3ICsxMzkyLDcgQEAKIAkgKiBieSAzMHggb3IgbW9yZS4uLgogCSAqCiAJICogV2UgdHJ5IGFuZCBvcHRpbWl6ZSB0aGUgc2xlZXAgdGltZSBhZ2FpbnN0IHdoYXQgdGhlIHVuZGVybHlpbmcgZGlzawotCSAqIGNhbiBkbywgaW5zdGVhZCBvZiBoYXZpbmcgYSBzdGF0aWMgc2xlZXAgdGltZS4gIFRoaXMgaXMgdXNlZnVsbCBmb3IKKwkgKiBjYW4gZG8sIGluc3RlYWQgb2YgaGF2aW5nIGEgc3RhdGljIHNsZWVwIHRpbWUuICBUaGlzIGlzIHVzZWZ1bCBmb3IKIAkgKiB0aGUgY2FzZSB3aGVyZSBvdXIgc3RvcmFnZSBpcyBzbyBmYXN0IHRoYXQgaXQgaXMgbW9yZSBvcHRpbWFsIHRvIGdvCiAJICogYWhlYWQgYW5kIGZvcmNlIGEgZmx1c2ggYW5kIHdhaXQgZm9yIHRoZSB0cmFuc2FjdGlvbiB0byBiZSBjb21taXR0ZWQKIAkgKiB0aGFuIGl0IGlzIHRvIHdhaXQgZm9yIGFuIGFyYml0cmFyeSBhbW91bnQgb2YgdGltZSBmb3IgbmV3IHdyaXRlcnMgdG8KZGlmZiAtLWdpdCBhL2ZzL2piZDIvY29tbWl0LmMgYi9mcy9qYmQyL2NvbW1pdC5jCmluZGV4IGZhMzZkNzYuLjIwYWY2MmYgMTAwNjQ0Ci0tLSBhL2ZzL2piZDIvY29tbWl0LmMKKysrIGIvZnMvamJkMi9jb21taXQuYwpAQCAtNDAzLDcgKzQwMyw3IEBACiAJICogd2UgZG8gbm90IHJlcXVpcmUgaXQgdG8gcmVtZW1iZXIgZXhhY3RseSB3aGljaCBvbGQgYnVmZmVycyBpdAogCSAqIGhhcyByZXNlcnZlZC4gIFRoaXMgaXMgY29uc2lzdGVudCB3aXRoIHRoZSBleGlzdGluZyBiZWhhdmlvdXIKIAkgKiB0aGF0IG11bHRpcGxlIGpiZDJfam91cm5hbF9nZXRfd3JpdGVfYWNjZXNzKCkgY2FsbHMgdG8gdGhlIHNhbWUKLQkgKiBidWZmZXIgYXJlIHBlcmZlY3RseSBwZXJtaXNzYWJsZS4KKwkgKiBidWZmZXIgYXJlIHBlcmZlY3RseSBwZXJtaXNzaWJsZS4KIAkgKi8KIAl3aGlsZSAoY29tbWl0X3RyYW5zYWN0aW9uLT50X3Jlc2VydmVkX2xpc3QpIHsKIAkJamggPSBjb21taXRfdHJhbnNhY3Rpb24tPnRfcmVzZXJ2ZWRfbGlzdDsKZGlmZiAtLWdpdCBhL2ZzL2piZDIvam91cm5hbC5jIGIvZnMvamJkMi9qb3VybmFsLmMKaW5kZXggOTA0MDdiOC4uYWJhOGViYSAxMDA2NDQKLS0tIGEvZnMvamJkMi9qb3VybmFsLmMKKysrIGIvZnMvamJkMi9qb3VybmFsLmMKQEAgLTkxNyw3ICs5MTcsNyBAQAogCWpvdXJuYWwtPmpfd2J1ZnNpemUgPSBuOwogCWpvdXJuYWwtPmpfd2J1ZiA9IGttYWxsb2MobiAqIHNpemVvZihzdHJ1Y3QgYnVmZmVyX2hlYWQqKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFqb3VybmFsLT5qX3didWYpIHsKLQkJcHJpbnRrKEtFUk5fRVJSICIlczogQ2FudCBhbGxvY2F0ZSBiaHMgZm9yIGNvbW1pdCB0aHJlYWRcbiIsCisJCXByaW50ayhLRVJOX0VSUiAiJXM6IENhbid0IGFsbG9jYXRlIGJocyBmb3IgY29tbWl0IHRocmVhZFxuIiwKIAkJCV9fZnVuY19fKTsKIAkJZ290byBvdXRfZXJyOwogCX0KQEAgLTk4Myw3ICs5ODMsNyBAQAogCWpvdXJuYWwtPmpfd2J1ZnNpemUgPSBuOwogCWpvdXJuYWwtPmpfd2J1ZiA9IGttYWxsb2MobiAqIHNpemVvZihzdHJ1Y3QgYnVmZmVyX2hlYWQqKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFqb3VybmFsLT5qX3didWYpIHsKLQkJcHJpbnRrKEtFUk5fRVJSICIlczogQ2FudCBhbGxvY2F0ZSBiaHMgZm9yIGNvbW1pdCB0aHJlYWRcbiIsCisJCXByaW50ayhLRVJOX0VSUiAiJXM6IENhbid0IGFsbG9jYXRlIGJocyBmb3IgY29tbWl0IHRocmVhZFxuIiwKIAkJCV9fZnVuY19fKTsKIAkJZ290byBvdXRfZXJyOwogCX0KZGlmZiAtLWdpdCBhL2ZzL2piZDIvcmV2b2tlLmMgYi9mcy9qYmQyL3Jldm9rZS5jCmluZGV4IDlhZDMyMWYuLjY5ZmQ5MzUgMTAwNjQ0Ci0tLSBhL2ZzL2piZDIvcmV2b2tlLmMKKysrIGIvZnMvamJkMi9yZXZva2UuYwpAQCAtNzEsNyArNzEsNyBAQAogICogc3dpdGNoaW5nIGhhc2ggdGFibGVzIHVuZGVyIHRoZW0uIEZvciBvcGVyYXRpb25zIG9uIHRoZSBsaXN0cyBvZiBlbnRyaWVzIGluCiAgKiB0aGUgaGFzaCB0YWJsZSBqX3Jldm9rZV9sb2NrIGlzIHVzZWQuCiAgKgotICogRmluYWxseSwgYWxzbyByZXBsYXkgY29kZSB1c2VzIHRoZSBoYXNoIHRhYmxlcyBidXQgYXQgdGhpcyBtb21lbnQgbm9vbmUgZWxzZQorICogRmluYWxseSwgYWxzbyByZXBsYXkgY29kZSB1c2VzIHRoZSBoYXNoIHRhYmxlcyBidXQgYXQgdGhpcyBtb21lbnQgbm8gb25lIGVsc2UKICAqIGNhbiB0b3VjaCB0aGVtIChmaWxlc3lzdGVtIGlzbid0IG1vdW50ZWQgeWV0KSBhbmQgaGVuY2Ugbm8gbG9ja2luZyBpcwogICogbmVlZGVkLgogICovCmRpZmYgLS1naXQgYS9mcy9qYmQyL3RyYW5zYWN0aW9uLmMgYi9mcy9qYmQyL3RyYW5zYWN0aW9uLmMKaW5kZXggMWQxMTkxMC4uMDVmYTc3YSAxMDA2NDQKLS0tIGEvZnMvamJkMi90cmFuc2FjdGlvbi5jCisrKyBiL2ZzL2piZDIvdHJhbnNhY3Rpb24uYwpAQCAtMTQwMyw3ICsxNDAzLDcgQEAKIAogCS8qCiAJICogT25jZSB3ZSBkcm9wIHRfdXBkYXRlcywgaWYgaXQgZ29lcyB0byB6ZXJvIHRoZSB0cmFuc2FjdGlvbgotCSAqIGNvdWxkIHN0YXJ0IGNvbW1pdGluZyBvbiB1cyBhbmQgZXZlbnR1YWxseSBkaXNhcHBlYXIuICBTbworCSAqIGNvdWxkIHN0YXJ0IGNvbW1pdHRpbmcgb24gdXMgYW5kIGV2ZW50dWFsbHkgZGlzYXBwZWFyLiAgU28KIAkgKiBvbmNlIHdlIGRvIHRoaXMsIHdlIG11c3Qgbm90IGRlcmVmZXJlbmNlIHRyYW5zYWN0aW9uCiAJICogcG9pbnRlciBhZ2Fpbi4KIAkgKi8KZGlmZiAtLWdpdCBhL2ZzL2pmZnMyL1RPRE8gYi9mcy9qZmZzMi9UT0RPCmluZGV4IDVkM2VhNDAuLmNhMjg5NjQgMTAwNjQ0Ci0tLSBhL2ZzL2pmZnMyL1RPRE8KKysrIGIvZnMvamZmczIvVE9ETwpAQCAtMTEsNyArMTEsNyBAQAogIC0gY2hlY2twb2ludGluZyAoZG8gd2UgbmVlZCB0aGlzPyBzY2FuIGlzIHF1aXRlIGZhc3QpCiAgLSBtYWtlIHRoZSBzY2FuIGNvZGUgcG9wdWxhdGUgcmVhbCBpbm9kZXMgc28gcmVhZF9pbm9kZSBqdXN0IGFmdGVyIAogCW1vdW50IGRvZXNuJ3QgaGF2ZSB0byByZWFkIHRoZSBmbGFzaCB0d2ljZSBmb3IgbGFyZ2UgZmlsZXMuCi0JTWFrZSB0aGlzIGEgcGVyLWlub2RlIG9wdGlvbiwgY2hhbmdhYmxlIHdpdGggY2hhdHRyLCBzbyB5b3UgY2FuCisJTWFrZSB0aGlzIGEgcGVyLWlub2RlIG9wdGlvbiwgY2hhbmdlYWJsZSB3aXRoIGNoYXR0ciwgc28geW91IGNhbgogCWRlY2lkZSB3aGljaCBpbm9kZXMgc2hvdWxkIGJlIGluLWNvcmUgaW1tZWRpYXRlbHkgYWZ0ZXIgbW91bnQuCiAgLSB0ZXN0LCB0ZXN0LCB0ZXN0CiAKZGlmZiAtLWdpdCBhL2ZzL2pmZnMyL3JlYWRpbm9kZS5jIGIvZnMvamZmczIvcmVhZGlub2RlLmMKaW5kZXggZDMyZWU5NC4uMmFiMWEwZCAxMDA2NDQKLS0tIGEvZnMvamZmczIvcmVhZGlub2RlLmMKKysrIGIvZnMvamZmczIvcmVhZGlub2RlLmMKQEAgLTI0LDcgKzI0LDcgQEAKICAqCiAgKiBSZXR1cm5zOiAwIGlmIHRoZSBkYXRhIENSQyBpcyBjb3JyZWN0OwogICogCSAgICAxIC0gaWYgaW5jb3JyZWN0OwotICoJICAgIGVycm9yIGNvZGUgaWYgYW4gZXJyb3Igb2NjdXJlZC4KKyAqCSAgICBlcnJvciBjb2RlIGlmIGFuIGVycm9yIG9jY3VycmVkLgogICovCiBzdGF0aWMgaW50IGNoZWNrX25vZGVfZGF0YShzdHJ1Y3QgamZmczJfc2JfaW5mbyAqYywgc3RydWN0IGpmZnMyX3RtcF9kbm9kZV9pbmZvICp0bikKIHsKZGlmZiAtLWdpdCBhL2ZzL2pmZnMyL3N1bW1hcnkuYyBiL2ZzL2pmZnMyL3N1bW1hcnkuYwppbmRleCA4MDAxNzFkLi5lNTM3ZmIwIDEwMDY0NAotLS0gYS9mcy9qZmZzMi9zdW1tYXJ5LmMKKysrIGIvZnMvamZmczIvc3VtbWFyeS5jCkBAIC0xMjEsNyArMTIxLDcgQEAKIAl0ZW1wLT5ub2RldHlwZSA9IHJpLT5ub2RldHlwZTsKIAl0ZW1wLT5pbm9kZSA9IHJpLT5pbm87CiAJdGVtcC0+dmVyc2lvbiA9IHJpLT52ZXJzaW9uOwotCXRlbXAtPm9mZnNldCA9IGNwdV90b19qZTMyKG9mcyk7IC8qIHJlbGF0aXZlIG9mZnNldCBmcm9tIHRoZSBiZWdpbmluZyBvZiB0aGUgamViICovCisJdGVtcC0+b2Zmc2V0ID0gY3B1X3RvX2plMzIob2ZzKTsgLyogcmVsYXRpdmUgb2Zmc2V0IGZyb20gdGhlIGJlZ2lubmluZyBvZiB0aGUgamViICovCiAJdGVtcC0+dG90bGVuID0gcmktPnRvdGxlbjsKIAl0ZW1wLT5uZXh0ID0gTlVMTDsKIApAQCAtMTM5LDcgKzEzOSw3IEBACiAKIAl0ZW1wLT5ub2RldHlwZSA9IHJkLT5ub2RldHlwZTsKIAl0ZW1wLT50b3RsZW4gPSByZC0+dG90bGVuOwotCXRlbXAtPm9mZnNldCA9IGNwdV90b19qZTMyKG9mcyk7CS8qIHJlbGF0aXZlIGZyb20gdGhlIGJlZ2luaW5nIG9mIHRoZSBqZWIgKi8KKwl0ZW1wLT5vZmZzZXQgPSBjcHVfdG9famUzMihvZnMpOwkvKiByZWxhdGl2ZSBmcm9tIHRoZSBiZWdpbm5pbmcgb2YgdGhlIGplYiAqLwogCXRlbXAtPnBpbm8gPSByZC0+cGlubzsKIAl0ZW1wLT52ZXJzaW9uID0gcmQtPnZlcnNpb247CiAJdGVtcC0+aW5vID0gcmQtPmlubzsKZGlmZiAtLWdpdCBhL2ZzL2pmZnMyL3didWYuYyBiL2ZzL2pmZnMyL3didWYuYwppbmRleCAwN2VlMTU0Li40NTE1YmVhIDEwMDY0NAotLS0gYS9mcy9qZmZzMi93YnVmLmMKKysrIGIvZnMvamZmczIvd2J1Zi5jCkBAIC0xMTE2LDcgKzExMTYsNyBAQAogCiAvKgogICogT24gTkFORCB3ZSB0cnkgdG8gbWFyayB0aGlzIGJsb2NrIGJhZC4gSWYgdGhlIGJsb2NrIHdhcyBlcmFzZWQgbW9yZQotICogdGhhbiBNQVhfRVJBU0VfRkFJTFVSRVMgd2UgbWFyayBpdCBmaW5hbHkgYmFkLgorICogdGhhbiBNQVhfRVJBU0VfRkFJTFVSRVMgd2UgbWFyayBpdCBmaW5hbGx5IGJhZC4KICAqIERvbid0IGNhcmUgYWJvdXQgZmFpbHVyZXMuIFRoaXMgYmxvY2sgcmVtYWlucyBvbiB0aGUgZXJhc2UtcGVuZGluZwogICogb3IgYmFkYmxvY2sgbGlzdCBhcyBsb25nIGFzIG5vYm9keSBtYW5pcHVsYXRlcyB0aGUgZmxhc2ggd2l0aAogICogYSBib290bG9hZGVyIG9yIHNvbWV0aGluZyBsaWtlIHRoYXQuCmRpZmYgLS1naXQgYS9mcy9qZnMvamZzX2RtYXAuYyBiL2ZzL2pmcy9qZnNfZG1hcC5jCmluZGV4IGM5MmVhM2IuLjQ0OTY4NzIgMTAwNjQ0Ci0tLSBhL2ZzL2pmcy9qZnNfZG1hcC5jCisrKyBiL2ZzL2pmcy9qZnNfZG1hcC5jCkBAIC0xNjQ5LDcgKzE2NDksNyBAQAogCQl9CiAKIAkJLyogc2VhcmNoIHRoZSB0cmVlIHdpdGhpbiB0aGUgZG1hcCBjb250cm9sIHBhZ2UgZm9yCi0JCSAqIHN1ZmZpY2VudCBmcmVlIHNwYWNlLiAgaWYgc3VmZmljaWVudCBmcmVlIHNwYWNlIGlzIGZvdW5kLAorCQkgKiBzdWZmaWNpZW50IGZyZWUgc3BhY2UuICBpZiBzdWZmaWNpZW50IGZyZWUgc3BhY2UgaXMgZm91bmQsCiAJCSAqIGRiRmluZExlYWYoKSByZXR1cm5zIHRoZSBpbmRleCBvZiB0aGUgbGVhZiBhdCB3aGljaAogCQkgKiBmcmVlIHNwYWNlIHdhcyBmb3VuZC4KIAkJICovCkBAIC0yNzQ0LDcgKzI3NDQsNyBAQAogCQkJLyogY2hlY2sgd2hpY2ggKGxlYWZubyBvciBidWRkeSkgaXMgdGhlIGxlZnQgYnVkZHkuCiAJCQkgKiB0aGUgbGVmdCBidWRkeSBnZXRzIHRvIGNsYWltIHRoZSBibG9ja3MgcmVzdWx0aW5nCiAJCQkgKiBmcm9tIHRoZSBqb2luIHdoaWxlIHRoZSByaWdodCBnZXRzIHRvIGNsYWltIG5vbmUuCi0JCQkgKiB0aGUgbGVmdCBidWRkeSBpcyBhbHNvIGVsaWdhYmxlIHRvIHBhcnRpY2lwYXRlIGluCisJCQkgKiB0aGUgbGVmdCBidWRkeSBpcyBhbHNvIGVsaWdpYmxlIHRvIHBhcnRpY2lwYXRlIGluCiAJCQkgKiBhIGpvaW4gYXQgdGhlIG5leHQgaGlnaGVyIGxldmVsIHdoaWxlIHRoZSByaWdodAogCQkJICogaXMgbm90LgogCQkJICoKZGlmZiAtLWdpdCBhL2ZzL2pmcy9qZnNfZXh0ZW50LmMgYi9mcy9qZnMvamZzX2V4dGVudC5jCmluZGV4IDVkM2JiZDEuLmU1ZmU4NTAgMTAwNjQ0Ci0tLSBhL2ZzL2pmcy9qZnNfZXh0ZW50LmMKKysrIGIvZnMvamZzL2pmc19leHRlbnQuYwpAQCAtMTI2LDcgKzEyNiw3IEBACiAKIAkvKiBhbGxvY2F0ZSB0aGUgZGlzayBibG9ja3MgZm9yIHRoZSBleHRlbnQuICBpbml0aWFsbHksIGV4dEJhbGxvYygpCiAJICogd2lsbCB0cnkgdG8gYWxsb2NhdGUgZGlzayBibG9ja3MgZm9yIHRoZSByZXF1ZXN0ZWQgc2l6ZSAoeGxlbikuCi0JICogaWYgdGhpcyBmYWlscyAoeGxlbiBjb250aWd1b3VzIGZyZWUgYmxvY2tzIG5vdCBhdmFsaWFibGUpLCBpdCdsbAorCSAqIGlmIHRoaXMgZmFpbHMgKHhsZW4gY29udGlndW91cyBmcmVlIGJsb2NrcyBub3QgYXZhaWxhYmxlKSwgaXQnbGwKIAkgKiB0cnkgdG8gYWxsb2NhdGUgYSBzbWFsbGVyIG51bWJlciBvZiBibG9ja3MgKHByb2R1Y2luZyBhIHNtYWxsZXIKIAkgKiBleHRlbnQpLCB3aXRoIHRoaXMgc21hbGxlciBudW1iZXIgb2YgYmxvY2tzIGNvbnNpc3Rpbmcgb2YgdGhlCiAJICogcmVxdWVzdGVkIG51bWJlciBvZiBibG9ja3Mgcm91bmRlZCBkb3duIHRvIHRoZSBuZXh0IHNtYWxsZXIKQEAgLTQ4MSw3ICs0ODEsNyBAQAogICoKICAqCQlpbml0aWFsbHksIHdlIHdpbGwgdHJ5IHRvIGFsbG9jYXRlIGRpc2sgYmxvY2tzIGZvciB0aGUKICAqCQlyZXF1ZXN0ZWQgc2l6ZSAobmJsb2NrcykuICBpZiB0aGlzIGZhaWxzIChuYmxvY2tzCi0gKgkJY29udGlndW91cyBmcmVlIGJsb2NrcyBub3QgYXZhbGlhYmxlKSwgd2UnbGwgdHJ5IHRvIGFsbG9jYXRlCisgKgkJY29udGlndW91cyBmcmVlIGJsb2NrcyBub3QgYXZhaWxhYmxlKSwgd2UnbGwgdHJ5IHRvIGFsbG9jYXRlCiAgKgkJYSBzbWFsbGVyIG51bWJlciBvZiBibG9ja3MgKHByb2R1Y2luZyBhIHNtYWxsZXIgZXh0ZW50KSwgd2l0aAogICoJCXRoaXMgc21hbGxlciBudW1iZXIgb2YgYmxvY2tzIGNvbnNpc3Rpbmcgb2YgdGhlIHJlcXVlc3RlZAogICoJCW51bWJlciBvZiBibG9ja3Mgcm91bmRlZCBkb3duIHRvIHRoZSBuZXh0IHNtYWxsZXIgcG93ZXIgb2YgMgpAQCAtNTc1LDcgKzU3NSw3IEBACiAgKgkJdG8gYSBuZXcgc2V0IG9mIGJsb2Nrcy4gIElmIG1vdmluZyB0aGUgZXh0ZW50LCB3ZSBpbml0aWFsbHkKICAqCQl3aWxsIHRyeSB0byBhbGxvY2F0ZSBkaXNrIGJsb2NrcyBmb3IgdGhlIHJlcXVlc3RlZCBzaXplCiAgKgkJKG5ld25ibGtzKS4gIGlmIHRoaXMgZmFpbHMgKG5ldyBjb250aWd1b3VzIGZyZWUgYmxvY2tzIG5vdAotICoJCWF2YWxpYWJsZSksIHdlJ2xsIHRyeSB0byBhbGxvY2F0ZSBhIHNtYWxsZXIgbnVtYmVyIG9mCisgKgkJYXZhaWxhYmxlKSwgd2UnbGwgdHJ5IHRvIGFsbG9jYXRlIGEgc21hbGxlciBudW1iZXIgb2YKICAqCQlibG9ja3MgKHByb2R1Y2luZyBhIHNtYWxsZXIgZXh0ZW50KSwgd2l0aCB0aGlzIHNtYWxsZXIKICAqCQludW1iZXIgb2YgYmxvY2tzIGNvbnNpc3Rpbmcgb2YgdGhlIHJlcXVlc3RlZCBudW1iZXIgb2YKICAqCQlibG9ja3Mgcm91bmRlZCBkb3duIHRvIHRoZSBuZXh0IHNtYWxsZXIgcG93ZXIgb2YgMgpkaWZmIC0tZ2l0IGEvZnMvamZzL2pmc19pbWFwLmMgYi9mcy9qZnMvamZzX2ltYXAuYwppbmRleCAzYTA5NDIzLi5lZDUzYTQ3IDEwMDY0NAotLS0gYS9mcy9qZnMvamZzX2ltYXAuYworKysgYi9mcy9qZnMvamZzX2ltYXAuYwpAQCAtMTA2OSw3ICsxMDY5LDcgQEAKIAkJICovCiAJCWlmIChpYWdwLT5uZnJlZWV4dHMgPT0gY3B1X3RvX2xlMzIoRVhUU1BFUklBRyAtIDEpKSB7CiAJCQkvKiBpbiBwcmVwYXJhdGlvbiBmb3IgcmVtb3ZpbmcgdGhlIGlhZyBmcm9tIHRoZQotCQkJICogYWcgZXh0ZW50IGZyZWUgbGlzdCwgcmVhZCB0aGUgaWFncyBwcmVjZWVkaW5nCisJCQkgKiBhZyBleHRlbnQgZnJlZSBsaXN0LCByZWFkIHRoZSBpYWdzIHByZWNlZGluZwogCQkJICogYW5kIGZvbGxvd2luZyB0aGUgaWFnIG9uIHRoZSBhZyBleHRlbnQgZnJlZQogCQkJICogbGlzdC4KIAkJCSAqLwpAQCAtMTA5NSw3ICsxMDk1LDcgQEAKIAkJaW50IGlub2ZyZWVmd2QgPSBsZTMyX3RvX2NwdShpYWdwLT5pbm9mcmVlZndkKTsKIAogCQkvKiBpbiBwcmVwYXJhdGlvbiBmb3IgcmVtb3ZpbmcgdGhlIGlhZyBmcm9tIHRoZQotCQkgKiBhZyBpbm9kZSBmcmVlIGxpc3QsIHJlYWQgdGhlIGlhZ3MgcHJlY2VlZGluZworCQkgKiBhZyBpbm9kZSBmcmVlIGxpc3QsIHJlYWQgdGhlIGlhZ3MgcHJlY2VkaW5nCiAJCSAqIGFuZCBmb2xsb3dpbmcgdGhlIGlhZyBvbiB0aGUgYWcgaW5vZGUgZnJlZQogCQkgKiBsaXN0LiAgYmVmb3JlIHJlYWRpbmcgdGhlc2UgaWFncywgd2UgbXVzdCBtYWtlCiAJCSAqIHN1cmUgdGhhdCB3ZSBhbHJlYWR5IGRvbid0IGhhdmUgdGhlbSBpbiBoYW5kCkBAIC0xNjgxLDcgKzE2ODEsNyBAQAogCSAqIHRyeSB0byBhbGxvY2F0ZSBhIG5ldyBleHRlbnQgb2YgZnJlZSBpbm9kZXMuCiAJICovCiAJaWYgKGFkZGV4dCkgewotCQkvKiBpZiBmcmVlIHNwYWNlIGlzIG5vdCBhdmFsaWFibGUgZm9yIHRoaXMgbmV3IGV4dGVudCwgdHJ5CisJCS8qIGlmIGZyZWUgc3BhY2UgaXMgbm90IGF2YWlsYWJsZSBmb3IgdGhpcyBuZXcgZXh0ZW50LCB0cnkKIAkJICogYmVsb3cgdG8gYWxsb2NhdGUgYSBmcmVlIGFuZCBleGlzdGluZyAoYWxyZWFkeSBiYWNrZWQpCiAJCSAqIGlub2RlIGZyb20gdGhlIGFnLgogCQkgKi8KQEAgLTIwMzYsNyArMjAzNiw3IEBACiAKIAkvKiBjaGVjayBpZiB0aGlzIGlzIHRoZSBsYXN0IGZyZWUgaW5vZGUgd2l0aGluIHRoZSBpYWcuCiAJICogaWYgc28sIGl0IHdpbGwgaGF2ZSB0byBiZSByZW1vdmVkIGZyb20gdGhlIGFnIGZyZWUKLQkgKiBpbm9kZSBsaXN0LCBzbyBnZXQgdGhlIGlhZ3MgcHJlY2VlZGluZyBhbmQgZm9sbG93aW5nCisJICogaW5vZGUgbGlzdCwgc28gZ2V0IHRoZSBpYWdzIHByZWNlZGluZyBhbmQgZm9sbG93aW5nCiAJICogaXQgb24gdGhlIGxpc3QuCiAJICovCiAJaWYgKGlhZ3AtPm5mcmVlaW5vcyA9PSBjcHVfdG9fbGUzMigxKSkgewpAQCAtMjIwOCw3ICsyMjA4LDcgQEAKIAogCS8qIGNoZWNrIGlmIHRoaXMgaXMgdGhlIGxhc3QgZnJlZSBleHRlbnQgd2l0aGluIHRoZQogCSAqIGlhZy4gIGlmIHNvLCB0aGUgaWFnIG11c3QgYmUgcmVtb3ZlZCBmcm9tIHRoZSBhZwotCSAqIGZyZWUgZXh0ZW50IGxpc3QsIHNvIGdldCB0aGUgaWFncyBwcmVjZWVkaW5nIGFuZAorCSAqIGZyZWUgZXh0ZW50IGxpc3QsIHNvIGdldCB0aGUgaWFncyBwcmVjZWRpbmcgYW5kCiAJICogZm9sbG93aW5nIHRoZSBpYWcgb24gdGhpcyBsaXN0LgogCSAqLwogCWlmIChpYWdwLT5uZnJlZWV4dHMgPT0gY3B1X3RvX2xlMzIoMSkpIHsKQEAgLTI1MDQsNyArMjUwNCw3IEBACiAJCX0KIAogCi0JCS8qIGdldCB0aGUgbmV4dCBhdmFsaWFibGUgaWFnIG51bWJlciAqLworCQkvKiBnZXQgdGhlIG5leHQgYXZhaWxhYmxlIGlhZyBudW1iZXIgKi8KIAkJaWFnbm8gPSBpbWFwLT5pbV9uZXh0aWFnOwogCiAJCS8qIG1ha2Ugc3VyZSB0aGF0IHdlIGhhdmUgbm90IGV4Y2VlZGVkIHRoZSBtYXhpbXVtIGlub2RlCkBAIC0yNjE1LDcgKzI2MTUsNyBAQAogCiAJCWR1cGxpY2F0ZUlYdHJlZShzYiwgYmxrbm8sIHhsZW4sICZ4YWRkcik7CiAKLQkJLyogdXBkYXRlIHRoZSBuZXh0IGF2YWxpYWJsZSBpYWcgbnVtYmVyICovCisJCS8qIHVwZGF0ZSB0aGUgbmV4dCBhdmFpbGFibGUgaWFnIG51bWJlciAqLwogCQlpbWFwLT5pbV9uZXh0aWFnICs9IDE7CiAKIAkJLyogQWRkIHRoZSBpYWcgdG8gdGhlIGlhZyBmcmVlIGxpc3Qgc28gd2UgZG9uJ3QgbG9zZSB0aGUgaWFnCmRpZmYgLS1naXQgYS9mcy9qZnMvamZzX2xvZ21nci5oIGIvZnMvamZzL2pmc19sb2dtZ3IuaAppbmRleCA5MjM2YmM0Li5lMzhjMjE1IDEwMDY0NAotLS0gYS9mcy9qZnMvamZzX2xvZ21nci5oCisrKyBiL2ZzL2pmcy9qZnNfbG9nbWdyLmgKQEAgLTI4OCw3ICsyODgsNyBAQAogCQkvKgogCQkgKglTWU5DUFQ6IGxvZyBzeW5jIHBvaW50CiAJCSAqCi0JCSAqIHJlcGxheSBsb2cgdXB0byBzeW5jcHQgYWRkcmVzcyBzcGVjaWZpZWQ7CisJCSAqIHJlcGxheSBsb2cgdXAgdG8gc3luY3B0IGFkZHJlc3Mgc3BlY2lmaWVkOwogCQkgKi8KIAkJc3RydWN0IHsKIAkJCV9fbGUzMiBzeW5jOwkvKiA0OiBzeW5jcHQgYWRkcmVzcyAoMCA9IGhlcmUpICovCmRpZmYgLS1naXQgYS9mcy9qZnMvamZzX21ldGFwYWdlLmggYi9mcy9qZnMvamZzX21ldGFwYWdlLmgKaW5kZXggZDk0ZjhkOS4uYTc4YmVkYSAxMDA2NDQKLS0tIGEvZnMvamZzL2pmc19tZXRhcGFnZS5oCisrKyBiL2ZzL2pmcy9qZnNfbWV0YXBhZ2UuaApAQCAtNzUsNyArNzUsNyBAQAogZXh0ZXJuIHZvaWQgZm9yY2VfbWV0YXBhZ2Uoc3RydWN0IG1ldGFwYWdlICopOwogCiAvKgotICogaG9sZF9tZXRhcGFnZSBhbmQgcHV0X21ldGFwYWdlIGFyZSB1c2VkIGluIGNvbmp1Y3Rpb24uICBUaGUgcGFnZSBsb2NrCisgKiBob2xkX21ldGFwYWdlIGFuZCBwdXRfbWV0YXBhZ2UgYXJlIHVzZWQgaW4gY29uanVuY3Rpb24uICBUaGUgcGFnZSBsb2NrCiAgKiBpcyBub3QgZHJvcHBlZCBiZXR3ZWVuIHRoZSB0d28sIHNvIG5vIG90aGVyIHRocmVhZHMgY2FuIGdldCBvciByZWxlYXNlCiAgKiB0aGUgbWV0YXBhZ2UKICAqLwpkaWZmIC0tZ2l0IGEvZnMvamZzL2pmc190eG5tZ3IuYyBiL2ZzL2pmcy9qZnNfdHhubWdyLmMKaW5kZXggOTQ2Njk1Ny4uZjZjYzBjMCAxMDA2NDQKLS0tIGEvZnMvamZzL2pmc190eG5tZ3IuYworKysgYi9mcy9qZnMvamZzX3R4bm1nci5jCkBAIC02MzYsNyArNjM2LDcgQEAKIAkgKiB0aGUgaW5vZGUgb2YgdGhlIHBhZ2UgYW5kIGF2YWlsYWJsZSB0byBhbGwgYW5vbnltb3VzCiAJICogdHJhbnNhY3Rpb25zIHVudGlsIHR4Q29tbWl0KCkgdGltZSBhdCB3aGljaCBwb2ludAogCSAqIHRoZXkgYXJlIHRyYW5zZmVycmVkIHRvIHRoZSB0cmFuc2FjdGlvbiB0bG9jayBsaXN0IG9mCi0JICogdGhlIGNvbW1pdGluZyB0cmFuc2FjdGlvbiBvZiB0aGUgaW5vZGUpCisJICogdGhlIGNvbW1pdHRpbmcgdHJhbnNhY3Rpb24gb2YgdGhlIGlub2RlKQogCSAqLwogCWlmICh4dGlkID09IDApIHsKIAkJdGxjay0+dGlkID0gdGlkOwpkaWZmIC0tZ2l0IGEvZnMvamZzL3Jlc2l6ZS5jIGIvZnMvamZzL3Jlc2l6ZS5jCmluZGV4IDFhYmEwMDMuLjhlYTVlZmIgMTAwNjQ0Ci0tLSBhL2ZzL2pmcy9yZXNpemUuYworKysgYi9mcy9qZnMvcmVzaXplLmMKQEAgLTU3LDcgKzU3LDcgQEAKICAqIDIuIGNvbXB1dGUgbmV3IEZTQ0tTaXplIGZyb20gbmV3IExWU2l6ZTsKICAqIDMuIHNldCBuZXcgRlNTaXplIGFzIE1JTihGU1NpemUsIExWU2l6ZS0oTG9nU2l6ZStGU0NLU2l6ZSkpIHdoZXJlCiAgKiAgICBhc3NlcnQobmV3IEZTU2l6ZSA+PSBvbGQgRlNTaXplKSwKLSAqICAgIGkuZS4sIGZpbGUgc3lzdGVtIG11c3Qgbm90IGJlIHNocmlua2VkOworICogICAgaS5lLiwgZmlsZSBzeXN0ZW0gbXVzdCBub3QgYmUgc2hydW5rOwogICovCiBpbnQgamZzX2V4dGVuZGZzKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHM2NCBuZXdMVlNpemUsIGludCBuZXdMb2dTaXplKQogewpAQCAtMTgyLDcgKzE4Miw3IEBACiAJICovCiAJbmV3RlNTaXplID0gbmV3TFZTaXplIC0gbmV3TG9nU2l6ZSAtIG5ld0ZTQ0tTaXplOwogCi0JLyogZmlsZSBzeXN0ZW0gY2Fubm90IGJlIHNocmlua2VkICovCisJLyogZmlsZSBzeXN0ZW0gY2Fubm90IGJlIHNocnVuayAqLwogCWlmIChuZXdGU1NpemUgPCBibXAtPmRiX21hcHNpemUpIHsKIAkJcmMgPSAtRUlOVkFMOwogCQlnb3RvIG91dDsKZGlmZiAtLWdpdCBhL2ZzL2pmcy9zdXBlci5jIGIvZnMvamZzL3N1cGVyLmMKaW5kZXggZWVjYTQ4YS4uMDZjOGE2NyAxMDA2NDQKLS0tIGEvZnMvamZzL3N1cGVyLmMKKysrIGIvZnMvamZzL3N1cGVyLmMKQEAgLTY0NCw3ICs2NDQsNyBAQAogCiAvKiBSZWFkIGRhdGEgZnJvbSBxdW90YWZpbGUgLSBhdm9pZCBwYWdlY2FjaGUgYW5kIHN1Y2ggYmVjYXVzZSB3ZSBjYW5ub3QgYWZmb3JkCiAgKiBhY3F1aXJpbmcgdGhlIGxvY2tzLi4uIEFzIHF1b3RhIGZpbGVzIGFyZSBuZXZlciB0cnVuY2F0ZWQgYW5kIHF1b3RhIGNvZGUKLSAqIGl0c2VsZiBzZXJpYWxpemVzIHRoZSBvcGVyYXRpb25zIChhbmQgbm9vbmUgZWxzZSBzaG91bGQgdG91Y2ggdGhlIGZpbGVzKQorICogaXRzZWxmIHNlcmlhbGl6ZXMgdGhlIG9wZXJhdGlvbnMgKGFuZCBubyBvbmUgZWxzZSBzaG91bGQgdG91Y2ggdGhlIGZpbGVzKQogICogd2UgZG9uJ3QgaGF2ZSB0byBiZSBhZnJhaWQgb2YgcmFjZXMgKi8KIHN0YXRpYyBzc2l6ZV90IGpmc19xdW90YV9yZWFkKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBjaGFyICpkYXRhLAogCQkJICAgICAgc2l6ZV90IGxlbiwgbG9mZl90IG9mZikKZGlmZiAtLWdpdCBhL2ZzL2xvZ2ZzL2Rldl9tdGQuYyBiL2ZzL2xvZ2ZzL2Rldl9tdGQuYwppbmRleCA3NDY2ZTlkLi4zMzllMTdlIDEwMDY0NAotLS0gYS9mcy9sb2dmcy9kZXZfbXRkLmMKKysrIGIvZnMvbG9nZnMvZGV2X210ZC5jCkBAIC02MCw3ICs2MCw3IEBACiAgKiBhc3luY2hyb25vdXMgcHJvcGVydGllcy4gIFNvIGp1c3QgdG8gcHJldmVudCB0aGUgZmlyc3QgaW1wbGVtZW50b3Igb2Ygc3VjaAogICogYSB0aGluZyBmcm9tIGJyZWFraW5nIGxvZ2ZzIGluIDIzNTAsIHdlIGRvIHRoZSB1c3VhbCBwb2ludGxlc3MgZGFuY2UgdG8KICAqIGRlY2xhcmUgYSBjb21wbGV0aW9uIHZhcmlhYmxlIGFuZCB3YWl0IGZvciBjb21wbGV0aW9uIGJlZm9yZSByZXR1cm5pbmcKLSAqIGZyb20gbXRkX2VyYXNlKCkuICBXaGF0IGFuIGV4Y2VyY2lzZSBpbiBmdXRpbGl0eSEKKyAqIGZyb20gbXRkX2VyYXNlKCkuICBXaGF0IGFuIGV4ZXJjaXNlIGluIGZ1dGlsaXR5IQogICovCiBzdGF0aWMgdm9pZCBsb2dmc19lcmFzZV9jYWxsYmFjayhzdHJ1Y3QgZXJhc2VfaW5mbyAqZWkpCiB7CmRpZmYgLS1naXQgYS9mcy9sb2dmcy9kaXIuYyBiL2ZzL2xvZ2ZzL2Rpci5jCmluZGV4IGY5ZGRmMGMuLjllZDg5ZDEgMTAwNjQ0Ci0tLSBhL2ZzL2xvZ2ZzL2Rpci5jCisrKyBiL2ZzL2xvZ2ZzL2Rpci5jCkBAIC05Miw3ICs5Miw3IEBACiAgKiBzbyBzaG9ydCBuYW1lcyAobGVuIDw9IDkpIGRvbid0IGV2ZW4gb2NjdXB5IHRoZSBjb21wbGV0ZSAzMmJpdCBuYW1lCiAgKiBzcGFjZS4gIEEgcHJpbWUgPjI1NiBlbnN1cmVzIHNob3J0IG5hbWVzIHF1aWNrbHkgc3ByZWFkIHRoZSAzMmJpdAogICogbmFtZSBzcGFjZS4gIEFkZCBhYm91dCAyNiBmb3IgdGhlIGVzdGltYXRlZCBhbW91bnQgb2YgaW5mb3JtYXRpb24KLSAqIG9mIGVhY2ggY2hhcmFjdGVyIGFuZCBwaWNrIGEgcHJpbWUgbmVhcmJ5LCBwcmVmZXJyYWJseSBhIGJpdC1zcGFyc2UKKyAqIG9mIGVhY2ggY2hhcmFjdGVyIGFuZCBwaWNrIGEgcHJpbWUgbmVhcmJ5LCBwcmVmZXJhYmx5IGEgYml0LXNwYXJzZQogICogb25lLgogICovCiBzdGF0aWMgdTMyIGhhc2hfMzIoY29uc3QgY2hhciAqcywgaW50IGxlbiwgdTMyIHNlZWQpCmRpZmYgLS1naXQgYS9mcy9sb2dmcy9yZWFkd3JpdGUuYyBiL2ZzL2xvZ2ZzL3JlYWR3cml0ZS5jCmluZGV4IGVlOTlhOWYuLjllMjIwODUgMTAwNjQ0Ci0tLSBhL2ZzL2xvZ2ZzL3JlYWR3cml0ZS5jCisrKyBiL2ZzL2xvZ2ZzL3JlYWR3cml0ZS5jCkBAIC0xNjE2LDcgKzE2MTYsNyBAQAogCQllcnIgPSBsb2dmc193cml0ZV9idWYoaW5vZGUsIHBhZ2UsIGZsYWdzKTsKIAkJaWYgKCFlcnIgJiYgc2hyaW5rX2xldmVsKGdjX2xldmVsKSA9PSAwKSB7CiAJCQkvKiBSZXdyaXRlIGNhbm5vdCBtYXJrIHRoZSBpbm9kZSBkaXJ0eSBidXQgaGFzIHRvCi0JCQkgKiB3cml0ZSBpdCBpbW1lZGlhdGx5LgorCQkJICogd3JpdGUgaXQgaW1tZWRpYXRlbHkuCiAJCQkgKiBROiBDYW4ndCB3ZSBqdXN0IGNyZWF0ZSBhbiBhbGlhcyBmb3IgdGhlIGlub2RlCiAJCQkgKiBpbnN0ZWFkPyAgQW5kIGlmIG5vdCwgd2h5IG5vdD8KIAkJCSAqLwpkaWZmIC0tZ2l0IGEvZnMvbWJjYWNoZS5jIGIvZnMvbWJjYWNoZS5jCmluZGV4IGEyNTQ0NGFiLi4yZjE3NGJlIDEwMDY0NAotLS0gYS9mcy9tYmNhY2hlLmMKKysrIGIvZnMvbWJjYWNoZS5jCkBAIC01NDIsNyArNTQyLDcgQEAKICAqIG1iX2NhY2hlX2VudHJ5X2ZpbmRfZmlyc3QoKQogICoKICAqIEZpbmQgdGhlIGZpcnN0IGNhY2hlIGVudHJ5IG9uIGEgZ2l2ZW4gZGV2aWNlIHdpdGggYSBjZXJ0YWluIGtleSBpbgotICogYW4gYWRkaXRpb25hbCBpbmRleC4gQWRkaXRvbmFsIG1hdGNoZXMgY2FuIGJlIGZvdW5kIHdpdGgKKyAqIGFuIGFkZGl0aW9uYWwgaW5kZXguIEFkZGl0aW9uYWwgbWF0Y2hlcyBjYW4gYmUgZm91bmQgd2l0aAogICogbWJfY2FjaGVfZW50cnlfZmluZF9uZXh0KCkuIFJldHVybnMgTlVMTCBpZiBubyBtYXRjaCB3YXMgZm91bmQuIFRoZQogICogcmV0dXJuZWQgY2FjaGUgZW50cnkgaXMgbG9ja2VkIGZvciBzaGFyZWQgYWNjZXNzICgibXVsdGlwbGUgcmVhZGVycyIpLgogICoKZGlmZiAtLWdpdCBhL2ZzL25hbWVpLmMgYi9mcy9uYW1laS5jCmluZGV4IDNjYjYxNmQuLmU2Y2Q2MTEgMTAwNjQ0Ci0tLSBhL2ZzL25hbWVpLmMKKysrIGIvZnMvbmFtZWkuYwpAQCAtNzAsNyArNzAsNyBAQAogICogbmFtZSBpbmRpY2F0ZWQgYnkgdGhlIHN5bWxpbmsuIFRoZSBvbGQgY29kZSBhbHdheXMgY29tcGxhaW5lZCB0aGF0IHRoZQogICogbmFtZSBhbHJlYWR5IGV4aXN0cywgZHVlIHRvIG5vdCBmb2xsb3dpbmcgdGhlIHN5bWxpbmsgZXZlbiBpZiBpdHMgdGFyZ2V0CiAgKiBpcyBub25leGlzdGVudC4gIFRoZSBuZXcgc2VtYW50aWNzIGFmZmVjdHMgYWxzbyBta25vZCgpIGFuZCBsaW5rKCkgd2hlbgotICogdGhlIG5hbWUgaXMgYSBzeW1saW5rIHBvaW50aW5nIHRvIGEgbm9uLWV4aXN0YW50IG5hbWUuCisgKiB0aGUgbmFtZSBpcyBhIHN5bWxpbmsgcG9pbnRpbmcgdG8gYSBub24tZXhpc3RlbnQgbmFtZS4KICAqCiAgKiBJIGRvbid0IGtub3cgd2hpY2ggc2VtYW50aWNzIGlzIHRoZSByaWdodCBvbmUsIHNpbmNlIEkgaGF2ZSBubyBhY2Nlc3MKICAqIHRvIHN0YW5kYXJkcy4gQnV0IEkgZm91bmQgYnkgdHJpYWwgdGhhdCBIUC1VWCA5LjAgaGFzIHRoZSBmdWxsICJuZXciCmRpZmYgLS1naXQgYS9mcy9uY3Bmcy9pbm9kZS5jIGIvZnMvbmNwZnMvaW5vZGUuYwppbmRleCAwMGExZDFjLi4wMjUwZTRjIDEwMDY0NAotLS0gYS9mcy9uY3Bmcy9pbm9kZS5jCisrKyBiL2ZzL25jcGZzL2lub2RlLmMKQEAgLTU5Niw3ICs1OTYsNyBAQAogLyoJc2VydmVyLT5wcml2LmRhdGEgPSBOVUxMOwkJKi8KIAogCXNlcnZlci0+bSA9IGRhdGE7Ci0JLyogQWx0aG91Z2h0IGFueXRoaW5nIHByb2R1Y2luZyB0aGlzIGlzIGJ1Z2d5LCBpdCBoYXBwZW5zCisJLyogQWx0aG91Z2ggYW55dGhpbmcgcHJvZHVjaW5nIHRoaXMgaXMgYnVnZ3ksIGl0IGhhcHBlbnMKIAkgICBub3cgYmVjYXVzZSBvZiBQQVRIX01BWCBjaGFuZ2VzLi4gKi8KIAlpZiAoc2VydmVyLT5tLnRpbWVfb3V0IDwgMSkgewogCQlzZXJ2ZXItPm0udGltZV9vdXQgPSAxMDsKZGlmZiAtLWdpdCBhL2ZzL25mcy9jYWxsYmFja194ZHIuYyBiL2ZzL25mcy9jYWxsYmFja194ZHIuYwppbmRleCAxNGUwZjkzLi4wMGVjZjYyIDEwMDY0NAotLS0gYS9mcy9uZnMvY2FsbGJhY2tfeGRyLmMKKysrIGIvZnMvbmZzL2NhbGxiYWNrX3hkci5jCkBAIC0yNDEsNyArMjQxLDcgQEAKIAogCWFyZ3MtPmNibF9sYXlvdXRfdHlwZSA9IG50b2hsKCpwKyspOwogCS8qIERlcGl0ZSB0aGUgc3BlYydzIHhkciwgaW9tb2RlIHJlYWxseSBiZWxvbmdzIGluIHRoZSBGSUxFIHN3aXRjaCwKLQkgKiBhcyBpdCBpcyB1bnVzZWFibGUgYW5kIGlnbm9yZWQgd2l0aCB0aGUgb3RoZXIgdHlwZXMuCisJICogYXMgaXQgaXMgdW51c2FibGUgYW5kIGlnbm9yZWQgd2l0aCB0aGUgb3RoZXIgdHlwZXMuCiAJICovCiAJaW9tb2RlID0gbnRvaGwoKnArKyk7CiAJYXJncy0+Y2JsX2xheW91dGNoYW5nZWQgPSBudG9obCgqcCsrKTsKZGlmZiAtLWdpdCBhL2ZzL25mcy9maWxlLmMgYi9mcy9uZnMvZmlsZS5jCmluZGV4IDNhYzViZDYuLjJmMDkzZWQgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9maWxlLmMKKysrIGIvZnMvbmZzL2ZpbGUuYwpAQCAtMzAxLDcgKzMwMSw3IEBACiAgKiBkaXNrLCBidXQgaXQgcmV0cmlldmVzIGFuZCBjbGVhcnMgY3R4LT5lcnJvciBhZnRlciBzeW5jaGluZywgZGVzcGl0ZQogICogdGhlIHR3byBiZWluZyBzZXQgYXQgdGhlIHNhbWUgdGltZSBpbiBuZnNfY29udGV4dF9zZXRfd3JpdGVfZXJyb3IoKS4KICAqIFRoaXMgaXMgYmVjYXVzZSB0aGUgZm9ybWVyIGlzIHVzZWQgdG8gbm90aWZ5IHRoZSBfbmV4dF8gY2FsbCB0bwotICogbmZzX2ZpbGVfd3JpdGUoKSB0aGF0IGEgd3JpdGUgZXJyb3Igb2NjdXJlZCwgYW5kIGhlbmNlIGNhdXNlIGl0IHRvCisgKiBuZnNfZmlsZV93cml0ZSgpIHRoYXQgYSB3cml0ZSBlcnJvciBvY2N1cnJlZCwgYW5kIGhlbmNlIGNhdXNlIGl0IHRvCiAgKiBmYWxsIGJhY2sgdG8gZG9pbmcgYSBzeW5jaHJvbm91cyB3cml0ZS4KICAqLwogc3RhdGljIGludApkaWZmIC0tZ2l0IGEvZnMvbmZzL25hbWVzcGFjZS5jIGIvZnMvbmZzL25hbWVzcGFjZS5jCmluZGV4IDkxNjZmY2IuLjg5ZmMxNjAgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uYW1lc3BhY2UuYworKysgYi9mcy9uZnMvbmFtZXNwYWNlLmMKQEAgLTE0OCw2NyArMTQ4LDY0IEBACiAJcmV0dXJuIHBzZXVkb2ZsYXZvcjsKIH0KIAotc3RhdGljIHJwY19hdXRoZmxhdm9yX3QgbmZzX25lZ290aWF0ZV9zZWN1cml0eShjb25zdCBzdHJ1Y3QgZGVudHJ5ICpwYXJlbnQsIGNvbnN0IHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3N0YXRpYyBpbnQgbmZzX25lZ290aWF0ZV9zZWN1cml0eShjb25zdCBzdHJ1Y3QgZGVudHJ5ICpwYXJlbnQsCisJCQkJICBjb25zdCBzdHJ1Y3QgZGVudHJ5ICpkZW50cnksCisJCQkJICBycGNfYXV0aGZsYXZvcl90ICpmbGF2b3IpCiB7Ci0JaW50IHN0YXR1cyA9IDA7CiAJc3RydWN0IHBhZ2UgKnBhZ2U7CiAJc3RydWN0IG5mczRfc2VjaW5mb19mbGF2b3JzICpmbGF2b3JzOwogCWludCAoKnNlY2luZm8pKHN0cnVjdCBpbm9kZSAqLCBjb25zdCBzdHJ1Y3QgcXN0ciAqLCBzdHJ1Y3QgbmZzNF9zZWNpbmZvX2ZsYXZvcnMgKik7Ci0JcnBjX2F1dGhmbGF2b3JfdCBmbGF2b3IgPSBSUENfQVVUSF9VTklYOworCWludCByZXQgPSAtRVBFUk07CiAKIAlzZWNpbmZvID0gTkZTX1BST1RPKHBhcmVudC0+ZF9pbm9kZSktPnNlY2luZm87CiAJaWYgKHNlY2luZm8gIT0gTlVMTCkgewogCQlwYWdlID0gYWxsb2NfcGFnZShHRlBfS0VSTkVMKTsKIAkJaWYgKCFwYWdlKSB7Ci0JCQlzdGF0dXMgPSAtRU5PTUVNOworCQkJcmV0ID0gLUVOT01FTTsKIAkJCWdvdG8gb3V0OwogCQl9CiAJCWZsYXZvcnMgPSBwYWdlX2FkZHJlc3MocGFnZSk7Ci0JCXN0YXR1cyA9IHNlY2luZm8ocGFyZW50LT5kX2lub2RlLCAmZGVudHJ5LT5kX25hbWUsIGZsYXZvcnMpOwotCQlmbGF2b3IgPSBuZnNfZmluZF9iZXN0X3NlYyhmbGF2b3JzLCBkZW50cnktPmRfaW5vZGUpOworCQlyZXQgPSBzZWNpbmZvKHBhcmVudC0+ZF9pbm9kZSwgJmRlbnRyeS0+ZF9uYW1lLCBmbGF2b3JzKTsKKwkJKmZsYXZvciA9IG5mc19maW5kX2Jlc3Rfc2VjKGZsYXZvcnMsIGRlbnRyeS0+ZF9pbm9kZSk7CiAJCXB1dF9wYWdlKHBhZ2UpOwogCX0KIAotCXJldHVybiBmbGF2b3I7Ci0KIG91dDoKLQlzdGF0dXMgPSAtRU5PTUVNOwotCXJldHVybiBzdGF0dXM7CisJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHJwY19hdXRoZmxhdm9yX3QgbmZzX2xvb2t1cF93aXRoX3NlYyhzdHJ1Y3QgbmZzX3NlcnZlciAqc2VydmVyLCBzdHJ1Y3QgZGVudHJ5ICpwYXJlbnQsCi0JCQkJICAgICBzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBwYXRoICpwYXRoLAotCQkJCSAgICAgc3RydWN0IG5mc19maCAqZmgsIHN0cnVjdCBuZnNfZmF0dHIgKmZhdHRyKQorc3RhdGljIGludCBuZnNfbG9va3VwX3dpdGhfc2VjKHN0cnVjdCBuZnNfc2VydmVyICpzZXJ2ZXIsIHN0cnVjdCBkZW50cnkgKnBhcmVudCwKKwkJCSAgICAgICBzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBwYXRoICpwYXRoLAorCQkJICAgICAgIHN0cnVjdCBuZnNfZmggKmZoLCBzdHJ1Y3QgbmZzX2ZhdHRyICpmYXR0ciwKKwkJCSAgICAgICBycGNfYXV0aGZsYXZvcl90ICpmbGF2b3IpCiB7Ci0JcnBjX2F1dGhmbGF2b3JfdCBmbGF2b3I7CiAJc3RydWN0IHJwY19jbG50ICpjbG9uZTsKIAlzdHJ1Y3QgcnBjX2F1dGggKmF1dGg7CiAJaW50IGVycjsKIAotCWZsYXZvciA9IG5mc19uZWdvdGlhdGVfc2VjdXJpdHkocGFyZW50LCBwYXRoLT5kZW50cnkpOwotCWlmIChmbGF2b3IgPCAwKQorCWVyciA9IG5mc19uZWdvdGlhdGVfc2VjdXJpdHkocGFyZW50LCBwYXRoLT5kZW50cnksIGZsYXZvcik7CisJaWYgKGVyciA8IDApCiAJCWdvdG8gb3V0OwogCWNsb25lICA9IHJwY19jbG9uZV9jbGllbnQoc2VydmVyLT5jbGllbnQpOwotCWF1dGggICA9IHJwY2F1dGhfY3JlYXRlKGZsYXZvciwgY2xvbmUpOworCWF1dGggICA9IHJwY2F1dGhfY3JlYXRlKCpmbGF2b3IsIGNsb25lKTsKIAlpZiAoIWF1dGgpIHsKLQkJZmxhdm9yID0gLUVJTzsKKwkJZXJyID0gLUVJTzsKIAkJZ290byBvdXRfc2h1dGRvd247CiAJfQogCWVyciA9IHNlcnZlci0+bmZzX2NsaWVudC0+cnBjX29wcy0+bG9va3VwKGNsb25lLCBwYXJlbnQtPmRfaW5vZGUsCiAJCQkJCQkgICZwYXRoLT5kZW50cnktPmRfbmFtZSwKIAkJCQkJCSAgZmgsIGZhdHRyKTsKLQlpZiAoZXJyIDwgMCkKLQkJZmxhdm9yID0gZXJyOwogb3V0X3NodXRkb3duOgogCXJwY19zaHV0ZG93bl9jbGllbnQoY2xvbmUpOwogb3V0OgotCXJldHVybiBmbGF2b3I7CisJcmV0dXJuIGVycjsKIH0KICNlbHNlIC8qIENPTkZJR19ORlNfVjQgKi8KLXN0YXRpYyBpbmxpbmUgcnBjX2F1dGhmbGF2b3JfdCBuZnNfbG9va3VwX3dpdGhfc2VjKHN0cnVjdCBuZnNfc2VydmVyICpzZXJ2ZXIsCi0JCQkJICAgICBzdHJ1Y3QgZGVudHJ5ICpwYXJlbnQsIHN0cnVjdCBkZW50cnkgKmRlbnRyeSwKLQkJCQkgICAgIHN0cnVjdCBwYXRoICpwYXRoLCBzdHJ1Y3QgbmZzX2ZoICpmaCwKLQkJCQkgICAgIHN0cnVjdCBuZnNfZmF0dHIgKmZhdHRyKQorc3RhdGljIGlubGluZSBpbnQgbmZzX2xvb2t1cF93aXRoX3NlYyhzdHJ1Y3QgbmZzX3NlcnZlciAqc2VydmVyLAorCQkJCSAgICAgIHN0cnVjdCBkZW50cnkgKnBhcmVudCwgc3RydWN0IGRlbnRyeSAqZGVudHJ5LAorCQkJCSAgICAgIHN0cnVjdCBwYXRoICpwYXRoLCBzdHJ1Y3QgbmZzX2ZoICpmaCwKKwkJCQkgICAgICBzdHJ1Y3QgbmZzX2ZhdHRyICpmYXR0ciwKKwkJCQkgICAgICBycGNfYXV0aGZsYXZvcl90ICpmbGF2b3IpCiB7CiAJcmV0dXJuIC1FUEVSTTsKIH0KQEAgLTIzNCw3ICsyMzEsNyBAQAogCXN0cnVjdCBuZnNfZmggKmZoID0gTlVMTDsKIAlzdHJ1Y3QgbmZzX2ZhdHRyICpmYXR0ciA9IE5VTEw7CiAJaW50IGVycjsKLQlycGNfYXV0aGZsYXZvcl90IGZsYXZvciA9IDE7CisJcnBjX2F1dGhmbGF2b3JfdCBmbGF2b3IgPSBSUENfQVVUSF9VTklYOwogCiAJZHByaW50aygiLS0+IG5mc19kX2F1dG9tb3VudCgpXG4iKTsKIApAQCAtMjU1LDEzICsyNTIsOCBAQAogCWVyciA9IHNlcnZlci0+bmZzX2NsaWVudC0+cnBjX29wcy0+bG9va3VwKHNlcnZlci0+Y2xpZW50LCBwYXJlbnQtPmRfaW5vZGUsCiAJCQkJCQkgICZwYXRoLT5kZW50cnktPmRfbmFtZSwKIAkJCQkJCSAgZmgsIGZhdHRyKTsKLQlpZiAoZXJyID09IC1FUEVSTSkgewotCQlmbGF2b3IgPSBuZnNfbG9va3VwX3dpdGhfc2VjKHNlcnZlciwgcGFyZW50LCBwYXRoLT5kZW50cnksIHBhdGgsIGZoLCBmYXR0cik7Ci0JCWlmIChmbGF2b3IgPCAwKQotCQkJZXJyID0gZmxhdm9yOwotCQllbHNlCi0JCQllcnIgPSAwOwotCX0KKwlpZiAoZXJyID09IC1FUEVSTSAmJiBORlNfUFJPVE8ocGFyZW50LT5kX2lub2RlKS0+c2VjaW5mbyAhPSBOVUxMKQorCQllcnIgPSBuZnNfbG9va3VwX3dpdGhfc2VjKHNlcnZlciwgcGFyZW50LCBwYXRoLT5kZW50cnksIHBhdGgsIGZoLCBmYXR0ciwgJmZsYXZvcik7CiAJZHB1dChwYXJlbnQpOwogCWlmIChlcnIgIT0gMCkgewogCQltbnQgPSBFUlJfUFRSKGVycik7CmRpZmYgLS1naXQgYS9mcy9uZnMvbmZzNGZpbGVsYXlvdXQuaCBiL2ZzL25mcy9uZnM0ZmlsZWxheW91dC5oCmluZGV4IDA4NWEzNTQuLjdjNDQ1NzkgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uZnM0ZmlsZWxheW91dC5oCisrKyBiL2ZzL25mcy9uZnM0ZmlsZWxheW91dC5oCkBAIC0zMyw3ICszMyw3IEBACiAjaW5jbHVkZSAicG5mcy5oIgogCiAvKgotICogRmllbGQgdGVzdGluZyBzaG93cyB3ZSBuZWVkIHRvIHN1cHBvcnQgdXB0byA0MDk2IHN0cmlwZSBpbmRpY2VzLgorICogRmllbGQgdGVzdGluZyBzaG93cyB3ZSBuZWVkIHRvIHN1cHBvcnQgdXAgdG8gNDA5NiBzdHJpcGUgaW5kaWNlcy4KICAqIFdlIHN0b3JlIGVhY2ggaW5kZXggYXMgYSB1OCAodTMyIG9uIHRoZSB3aXJlKSB0byBrZWVwIHRoZSBtZW1vcnkgZm9vdHByaW50CiAgKiByZWFzb25hYmxlLiBUaGlzIGluIHR1cm4gbWVhbnMgd2Ugc3VwcG9ydCBhIG1heGltdW0gb2YgMjU2CiAgKiBSRkMgNTY2MSBtdWx0aXBhdGhfbGlzdDQgc3RydWN0dXJlcy4KZGlmZiAtLWdpdCBhL2ZzL25mcy9uZnM0cHJvYy5jIGIvZnMvbmZzL25mczRwcm9jLmMKaW5kZXggZGZkMWU2ZC4uOWJmNDFlYSAxMDA2NDQKLS0tIGEvZnMvbmZzL25mczRwcm9jLmMKKysrIGIvZnMvbmZzL25mczRwcm9jLmMKQEAgLTIyMDQsOCArMjIwNCw2IEBACiAJCWdvdG8gb3V0OwogCX0KIAlyZXQgPSBuZnM0X2xvb2t1cF9yb290KHNlcnZlciwgZmhhbmRsZSwgaW5mbyk7Ci0JaWYgKHJldCA8IDApCi0JCXJldCA9IC1FQUdBSU47CiBvdXQ6CiAJcmV0dXJuIHJldDsKIH0KQEAgLTIyMjYsNyArMjIyNCw3IEBACiAKIAlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKIAkJc3RhdHVzID0gbmZzNF9sb29rdXBfcm9vdF9zZWMoc2VydmVyLCBmaGFuZGxlLCBpbmZvLCBmbGF2X2FycmF5W2ldKTsKLQkJaWYgKHN0YXR1cyA9PSAwKQorCQlpZiAoc3RhdHVzICE9IC1FUEVSTSkKIAkJCWJyZWFrOwogCX0KIAlpZiAoc3RhdHVzID09IDApCmRpZmYgLS1naXQgYS9mcy9uZnNfY29tbW9uL25mc2FjbC5jIGIvZnMvbmZzX2NvbW1vbi9uZnNhY2wuYwppbmRleCBlYzBmMjc3Li42OTQwNDM5IDEwMDY0NAotLS0gYS9mcy9uZnNfY29tbW9uL25mc2FjbC5jCisrKyBiL2ZzL25mc19jb21tb24vbmZzYWNsLmMKQEAgLTE3Myw3ICsxNzMsNyBAQAogCQkJCXJldHVybiAtRUlOVkFMOwogCQkJYnJlYWs7CiAJCWNhc2UgQUNMX01BU0s6Ci0JCQkvKiBTb2xhcmlzIHNvbWV0aW1lcyBzZXRzIGFkZGl0b25hbCBiaXRzIGluIHRoZSBtYXNrICovCisJCQkvKiBTb2xhcmlzIHNvbWV0aW1lcyBzZXRzIGFkZGl0aW9uYWwgYml0cyBpbiB0aGUgbWFzayAqLwogCQkJZW50cnktPmVfcGVybSAmPSBTX0lSV1hPOwogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CmRpZmYgLS1naXQgYS9mcy9uZnNkL25mczN4ZHIuYyBiL2ZzL25mc2QvbmZzM3hkci5jCmluZGV4IDdlODRhODUuLmFkNDhmYWMgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzM3hkci5jCisrKyBiL2ZzL25mc2QvbmZzM3hkci5jCkBAIC03MDIsNyArNzAyLDcgQEAKIAkJKnArKyA9IGh0b25sKHJlc3AtPmVvZik7CiAJCSpwKysgPSBodG9ubChyZXNwLT5jb3VudCk7CS8qIHhkciBvcGFxdWUgY291bnQgKi8KIAkJeGRyX3Jlc3NpemVfY2hlY2socnFzdHAsIHApOwotCQkvKiBub3cgdXBkYXRlIHJxc3RwLT5ycV9yZXMgdG8gcmVmbGVjdCBkYXRhIGFzd2VsbCAqLworCQkvKiBub3cgdXBkYXRlIHJxc3RwLT5ycV9yZXMgdG8gcmVmbGVjdCBkYXRhIGFzIHdlbGwgKi8KIAkJcnFzdHAtPnJxX3Jlcy5wYWdlX2xlbiA9IHJlc3AtPmNvdW50OwogCQlpZiAocmVzcC0+Y291bnQgJiAzKSB7CiAJCQkvKiBuZWVkIHRvIHBhZCB0aGUgdGFpbCAqLwpkaWZmIC0tZ2l0IGEvZnMvbmZzZC9uZnM0c3RhdGUuYyBiL2ZzL25mc2QvbmZzNHN0YXRlLmMKaW5kZXggZmJkZTZmNy4uNGIzNmVjMyAxMDA2NDQKLS0tIGEvZnMvbmZzZC9uZnM0c3RhdGUuYworKysgYi9mcy9uZnNkL25mczRzdGF0ZS5jCkBAIC0zMDU1LDcgKzMwNTUsNyBAQAogCWlmIChPTkVfU1RBVEVJRChzdGF0ZWlkKSAmJiAoZmxhZ3MgJiBSRF9TVEFURSkpCiAJCXJldHVybiBuZnNfb2s7CiAJZWxzZSBpZiAobG9ja3NfaW5fZ3JhY2UoKSkgewotCQkvKiBBbnN3ZXIgaW4gcmVtYWluaW5nIGNhc2VzIGRlcGVuZHMgb24gZXhpc3RhbmNlIG9mCisJCS8qIEFuc3dlciBpbiByZW1haW5pbmcgY2FzZXMgZGVwZW5kcyBvbiBleGlzdGVuY2Ugb2YKIAkJICogY29uZmxpY3Rpbmcgc3RhdGU7IHNvIHdlIG11c3Qgd2FpdCBvdXQgdGhlIGdyYWNlIHBlcmlvZC4gKi8KIAkJcmV0dXJuIG5mc2Vycl9ncmFjZTsKIAl9IGVsc2UgaWYgKGZsYWdzICYgV1JfU1RBVEUpCkBAIC0zNjc1LDcgKzM2NzUsNyBAQAogLyoKICAqIEFsbG9jIGEgbG9jayBvd25lciBzdHJ1Y3R1cmUuCiAgKiBDYWxsZWQgaW4gbmZzZDRfbG9jayAtIHRoZXJlZm9yZSwgT1BFTiBhbmQgT1BFTl9DT05GSVJNIChpZiBuZWVkZWQpIGhhcyAKLSAqIG9jY3VyZWQuIAorICogb2NjdXJyZWQuIAogICoKICAqIHN0cmhhc2h2YWwgPSBsb2NrX293bmVyc3RyX2hhc2h2YWwgCiAgKi8KZGlmZiAtLWdpdCBhL2ZzL25mc2QvbmZzeGRyLmMgYi9mcy9uZnNkL25mc3hkci5jCmluZGV4IDRjZTAwNWQuLjY1ZWM1OTUgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzeGRyLmMKKysrIGIvZnMvbmZzZC9uZnN4ZHIuYwpAQCAtNDUxLDcgKzQ1MSw3IEBACiAJKnArKyA9IGh0b25sKHJlc3AtPmNvdW50KTsKIAl4ZHJfcmVzc2l6ZV9jaGVjayhycXN0cCwgcCk7CiAKLQkvKiBub3cgdXBkYXRlIHJxc3RwLT5ycV9yZXMgdG8gcmVmbGVjdCBkYXRhIGFzd2VsbCAqLworCS8qIG5vdyB1cGRhdGUgcnFzdHAtPnJxX3JlcyB0byByZWZsZWN0IGRhdGEgYXMgd2VsbCAqLwogCXJxc3RwLT5ycV9yZXMucGFnZV9sZW4gPSByZXNwLT5jb3VudDsKIAlpZiAocmVzcC0+Y291bnQgJiAzKSB7CiAJCS8qIG5lZWQgdG8gcGFkIHRoZSB0YWlsICovCmRpZmYgLS1naXQgYS9mcy9ub3RpZnkvZmFub3RpZnkvZmFub3RpZnlfdXNlci5jIGIvZnMvbm90aWZ5L2Zhbm90aWZ5L2Zhbm90aWZ5X3VzZXIuYwppbmRleCA2YjEzMDVkLi45ZmRlMWMwIDEwMDY0NAotLS0gYS9mcy9ub3RpZnkvZmFub3RpZnkvZmFub3RpZnlfdXNlci5jCisrKyBiL2ZzL25vdGlmeS9mYW5vdGlmeS9mYW5vdGlmeV91c2VyLmMKQEAgLTE2NCw3ICsxNjQsNyBAQAogCQkgZmQsIHJlc3BvbnNlKTsKIAkvKgogCSAqIG1ha2Ugc3VyZSB0aGUgcmVzcG9uc2UgaXMgdmFsaWQsIGlmIGludmFsaWQgd2UgZG8gbm90aGluZyBhbmQgZWl0aGVyCi0JICogdXNlcnNwYWNlIGNhbiBzZW5kIGEgdmFsaWQgcmVzcG9uY2Ugb3Igd2Ugd2lsbCBjbGVhbiBpdCB1cCBhZnRlciB0aGUKKwkgKiB1c2Vyc3BhY2UgY2FuIHNlbmQgYSB2YWxpZCByZXNwb25zZSBvciB3ZSB3aWxsIGNsZWFuIGl0IHVwIGFmdGVyIHRoZQogCSAqIHRpbWVvdXQKIAkgKi8KIAlzd2l0Y2ggKHJlc3BvbnNlKSB7CmRpZmYgLS1naXQgYS9mcy9ub3RpZnkvaW5vdGlmeS9pbm90aWZ5X2Zzbm90aWZ5LmMgYi9mcy9ub3RpZnkvaW5vdGlmeS9pbm90aWZ5X2Zzbm90aWZ5LmMKaW5kZXggMDM0OGQwYy4uZTNjYmQ3NCAxMDA2NDQKLS0tIGEvZnMvbm90aWZ5L2lub3RpZnkvaW5vdGlmeV9mc25vdGlmeS5jCisrKyBiL2ZzL25vdGlmeS9pbm90aWZ5L2lub3RpZnlfZnNub3RpZnkuYwpAQCAtMTk0LDcgKzE5NCw3IEBACiAKIHN0YXRpYyB2b2lkIGlub3RpZnlfZnJlZV9ncm91cF9wcml2KHN0cnVjdCBmc25vdGlmeV9ncm91cCAqZ3JvdXApCiB7Ci0JLyogaWRlYWxseSB0aGUgaWRyIGlzIGVtcHR5IGFuZCB3ZSB3b24ndCBoaXQgdGhlIEJVRyBpbiB0ZWggY2FsbGJhY2sgKi8KKwkvKiBpZGVhbGx5IHRoZSBpZHIgaXMgZW1wdHkgYW5kIHdlIHdvbid0IGhpdCB0aGUgQlVHIGluIHRoZSBjYWxsYmFjayAqLwogCWlkcl9mb3JfZWFjaCgmZ3JvdXAtPmlub3RpZnlfZGF0YS5pZHIsIGlkcl9jYWxsYmFjaywgZ3JvdXApOwogCWlkcl9yZW1vdmVfYWxsKCZncm91cC0+aW5vdGlmeV9kYXRhLmlkcik7CiAJaWRyX2Rlc3Ryb3koJmdyb3VwLT5pbm90aWZ5X2RhdGEuaWRyKTsKZGlmZiAtLWdpdCBhL2ZzL25vdGlmeS9tYXJrLmMgYi9mcy9ub3RpZnkvbWFyay5jCmluZGV4IDUwYzAwODUuLjI1MmFiMWYgMTAwNjQ0Ci0tLSBhL2ZzL25vdGlmeS9tYXJrLmMKKysrIGIvZnMvbm90aWZ5L21hcmsuYwpAQCAtMjQsNyArMjQsNyBAQAogICogcmVmZXJlbmNpbmcgdGhpcyBvYmplY3QuICBUaGUgb2JqZWN0IHR5cGljYWxseSB3aWxsIGxpdmUgaW5zaWRlIHRoZSBrZXJuZWwKICAqIHdpdGggYSByZWZjbnQgb2YgMiwgb25lIGZvciBlYWNoIGxpc3QgaXQgaXMgb24gKGlfbGlzdCwgZ19saXN0KS4gIEFueSB0YXNrCiAgKiB3aGljaCBjYW4gZmluZCB0aGlzIG9iamVjdCBob2xkaW5nIHRoZSBhcHByb3ByaWV0ZSBsb2NrcywgY2FuIHRha2UgYSByZWZlcmVuY2UKLSAqIGFuZCB0aGUgb2JqZWN0IGl0c2VsZiBpcyBndWFyZW50ZWVkIHRvIHN1cnZpdmUgdW50aWwgdGhlIHJlZmVyZW5jZSBpcyBkcm9wcGVkLgorICogYW5kIHRoZSBvYmplY3QgaXRzZWxmIGlzIGd1YXJhbnRlZWQgdG8gc3Vydml2ZSB1bnRpbCB0aGUgcmVmZXJlbmNlIGlzIGRyb3BwZWQuCiAgKgogICogTE9DS0lORzoKICAqIFRoZXJlIGFyZSAzIHNwaW5sb2NrcyBpbnZvbHZlZCB3aXRoIGZzbm90aWZ5IGlub2RlIG1hcmtzIGFuZCB0aGV5IE1VU1QKZGlmZiAtLWdpdCBhL2ZzL250ZnMvYXR0cmliLmMgYi9mcy9udGZzL2F0dHJpYi5jCmluZGV4IGY1MDk0ZWUuLmYxNGZkZTIgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMvYXR0cmliLmMKKysrIGIvZnMvbnRmcy9hdHRyaWIuYwpAQCAtMTk3LDcgKzE5Nyw3IEBACiAJfSBlbHNlIGlmIChjdHhfbmVlZHNfcmVzZXQpIHsKIAkJLyoKIAkJICogSWYgdGhlcmUgaXMgbm8gYXR0cmlidXRlIGxpc3QsIHJlc3RvcmluZyB0aGUgc2VhcmNoIGNvbnRleHQKLQkJICogaXMgYWNvbXBsaXNoZWQgc2ltcGx5IGJ5IGNvcHlpbmcgdGhlIHNhdmVkIGNvbnRleHQgYmFjayBvdmVyCisJCSAqIGlzIGFjY29tcGxpc2hlZCBzaW1wbHkgYnkgY29weWluZyB0aGUgc2F2ZWQgY29udGV4dCBiYWNrIG92ZXIKIAkJICogdGhlIGNhbGxlciBzdXBwbGllZCBjb250ZXh0LiAgSWYgdGhlcmUgaXMgYW4gYXR0cmlidXRlIGxpc3QsCiAJCSAqIHRoaW5ncyBhcmUgbW9yZSBjb21wbGljYXRlZCBhcyB3ZSBuZWVkIHRvIGRlYWwgd2l0aCBtYXBwaW5nCiAJCSAqIG9mIG1mdCByZWNvcmRzIGFuZCByZXN1bHRpbmcgcG90ZW50aWFsIGNoYW5nZXMgaW4gcG9pbnRlcnMuCkBAIC0xMTgxLDcgKzExODEsNyBAQAogICogZm9yLCBpLmUuIGlmIG9uZSB3YW50cyB0byBhZGQgdGhlIGF0dHJpYnV0ZSB0byB0aGUgbWZ0IHJlY29yZCB0aGlzIGlzIHRoZQogICogY29ycmVjdCBwbGFjZSB0byBpbnNlcnQgaXRzIGF0dHJpYnV0ZSBsaXN0IGVudHJ5IGludG8uCiAgKgotICogV2hlbiAtZXJybm8gIT0gLUVOT0VOVCwgYW4gZXJyb3Igb2NjdXJlZCBkdXJpbmcgdGhlIGxvb2t1cC4gIEBjdHgtPmF0dHIgaXMKKyAqIFdoZW4gLWVycm5vICE9IC1FTk9FTlQsIGFuIGVycm9yIG9jY3VycmVkIGR1cmluZyB0aGUgbG9va3VwLiAgQGN0eC0+YXR0ciBpcwogICogdGhlbiB1bmRlZmluZWQgYW5kIGluIHBhcnRpY3VsYXIgeW91IHNob3VsZCBub3QgcmVseSBvbiBpdCBub3QgY2hhbmdpbmcuCiAgKi8KIGludCBudGZzX2F0dHJfbG9va3VwKGNvbnN0IEFUVFJfVFlQRSB0eXBlLCBjb25zdCBudGZzY2hhciAqbmFtZSwKZGlmZiAtLWdpdCBhL2ZzL250ZnMvY29tcHJlc3MuYyBiL2ZzL250ZnMvY29tcHJlc3MuYwppbmRleCBlZjllZDg1Li5lZTQxNDRjIDEwMDY0NAotLS0gYS9mcy9udGZzL2NvbXByZXNzLmMKKysrIGIvZnMvbnRmcy9jb21wcmVzcy5jCkBAIC01MDEsNyArNTAxLDcgQEAKIAlWQ04gc3RhcnRfdmNuID0gKCgoczY0KWluZGV4IDw8IFBBR0VfQ0FDSEVfU0hJRlQpICYgfmNiX3NpemVfbWFzaykgPj4KIAkJCXZvbC0+Y2x1c3Rlcl9zaXplX2JpdHM7CiAJLyoKLQkgKiBUaGUgZmlyc3QgdmNuIGFmdGVyIHRoZSBsYXN0IHdhbnRlZCB2Y24gKG1pbnVtdW0gYWxpZ25tZW50IGlzIGFnYWluCisJICogVGhlIGZpcnN0IHZjbiBhZnRlciB0aGUgbGFzdCB3YW50ZWQgdmNuIChtaW5pbXVtIGFsaWdubWVudCBpcyBhZ2FpbgogCSAqIFBBR0VfQ0FDSEVfU0laRS4KIAkgKi8KIAlWQ04gZW5kX3ZjbiA9ICgoKChzNjQpKGluZGV4ICsgMVVMKSA8PCBQQUdFX0NBQ0hFX1NISUZUKSArIGNiX3NpemUgLSAxKQpkaWZmIC0tZ2l0IGEvZnMvbnRmcy9pbm9kZS5jIGIvZnMvbnRmcy9pbm9kZS5jCmluZGV4IDBiNTZjNmIuLmMwNWQ2ZGMgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMvaW5vZGUuYworKysgYi9mcy9udGZzL2lub2RlLmMKQEAgLTYyMiw3ICs2MjIsNyBAQAogCSAqLwogCS8qIEV2ZXJ5b25lIGdldHMgYWxsIHBlcm1pc3Npb25zLiAqLwogCXZpLT5pX21vZGUgfD0gU19JUldYVUdPOwotCS8qIElmIHJlYWQtb25seSwgbm9vbmUgZ2V0cyB3cml0ZSBwZXJtaXNzaW9ucy4gKi8KKwkvKiBJZiByZWFkLW9ubHksIG5vIG9uZSBnZXRzIHdyaXRlIHBlcm1pc3Npb25zLiAqLwogCWlmIChJU19SRE9OTFkodmkpKQogCQl2aS0+aV9tb2RlICY9IH5TX0lXVUdPOwogCWlmIChtLT5mbGFncyAmIE1GVF9SRUNPUkRfSVNfRElSRUNUT1JZKSB7CkBAIC0yNTI5LDcgKzI1MjksNyBAQAogCQkgKiBzcGVjaWZpZXMgdGhhdCB0aGUgYmVoYXZpb3VyIGlzIHVuc3BlY2lmaWVkIHRodXMgd2UgZG8gbm90CiAJCSAqIGhhdmUgdG8gZG8gYW55dGhpbmcuICBUaGlzIG1lYW5zIHRoYXQgaW4gb3VyIGltcGxlbWVudGF0aW9uCiAJCSAqIGluIHRoZSByYXJlIGNhc2UgdGhhdCB0aGUgZmlsZSBpcyBtbWFwKClwZWQgYW5kIGEgd3JpdGUKLQkJICogb2NjdXJlZCBpbnRvIHRoZSBtbWFwKClwZWQgcmVnaW9uIGp1c3QgYmV5b25kIHRoZSBmaWxlIHNpemUKKwkJICogb2NjdXJyZWQgaW50byB0aGUgbW1hcCgpcGVkIHJlZ2lvbiBqdXN0IGJleW9uZCB0aGUgZmlsZSBzaXplCiAJCSAqIGFuZCB3cml0ZXBhZ2UgaGFzIG5vdCB5ZXQgYmVlbiBjYWxsZWQgdG8gd3JpdGUgb3V0IHRoZSBwYWdlCiAJCSAqICh3aGljaCB3b3VsZCBjbGVhciB0aGUgYXJlYSBiZXlvbmQgdGhlIGZpbGUgc2l6ZSkgYW5kIHdlIG5vdwogCQkgKiBleHRlbmQgdGhlIGZpbGUgc2l6ZSB0byBpbmNvcnBvcmF0ZSB0aGlzIGRpcnR5IHJlZ2lvbgpkaWZmIC0tZ2l0IGEvZnMvbnRmcy9sYXlvdXQuaCBiL2ZzL250ZnMvbGF5b3V0LmgKaW5kZXggOGIyNTQ5Zi4uZmFlY2U3MSAxMDA2NDQKLS0tIGEvZnMvbnRmcy9sYXlvdXQuaAorKysgYi9mcy9udGZzL2xheW91dC5oCkBAIC0yODYsNyArMjg2LDcgQEAKICAqIGZyYWdtZW50ZWQuIFZvbHVtZSBmcmVlIHNwYWNlIGluY2x1ZGVzIHRoZSBlbXB0eSBwYXJ0IG9mIHRoZSBtZnQgem9uZSBhbmQKICAqIHdoZW4gdGhlIHZvbHVtZSdzIGZyZWUgODglIGFyZSB1c2VkIHVwLCB0aGUgbWZ0IHpvbmUgaXMgc2hydW5rIGJ5IGEgZmFjdG9yCiAgKiBvZiAyLCB0aHVzIG1ha2luZyBtb3JlIHNwYWNlIGF2YWlsYWJsZSBmb3IgbW9yZSBmaWxlcy9kYXRhLiBUaGlzIHByb2Nlc3MgaXMKLSAqIHJlcGVhdGVkIGV2ZXJ5dGltZSB0aGVyZSBpcyBubyBtb3JlIGZyZWUgc3BhY2UgZXhjZXB0IGZvciB0aGUgbWZ0IHpvbmUgdW50aWwKKyAqIHJlcGVhdGVkIGV2ZXJ5IHRpbWUgdGhlcmUgaXMgbm8gbW9yZSBmcmVlIHNwYWNlIGV4Y2VwdCBmb3IgdGhlIG1mdCB6b25lIHVudGlsCiAgKiB0aGVyZSByZWFsbHkgaXMgbm8gbW9yZSBmcmVlIHNwYWNlLgogICovCiAKQEAgLTE2NTcsMTMgKzE2NTcsMTMgQEAKICAqCXBvaW50ZWQgdG8gYnkgdGhlIE93bmVyIGZpZWxkIHdhcyBwcm92aWRlZCBieSBhIGRlZmF1bHRpbmcgbWVjaGFuaXNtCiAgKglyYXRoZXIgdGhhbiBleHBsaWNpdGx5IHByb3ZpZGVkIGJ5IHRoZSBvcmlnaW5hbCBwcm92aWRlciBvZiB0aGUKICAqCXNlY3VyaXR5IGRlc2NyaXB0b3IuICBUaGlzIG1heSBhZmZlY3QgdGhlIHRyZWF0bWVudCBvZiB0aGUgU0lEIHdpdGgKLSAqCXJlc3BlY3QgdG8gaW5oZXJpdGVuY2Ugb2YgYW4gb3duZXIuCisgKglyZXNwZWN0IHRvIGluaGVyaXRhbmNlIG9mIGFuIG93bmVyLgogICoKICAqIFNFX0dST1VQX0RFRkFVTFRFRCAtIFRoaXMgYm9vbGVhbiBmbGFnLCB3aGVuIHNldCwgaW5kaWNhdGVzIHRoYXQgdGhlIFNJRCBpbgogICoJdGhlIEdyb3VwIGZpZWxkIHdhcyBwcm92aWRlZCBieSBhIGRlZmF1bHRpbmcgbWVjaGFuaXNtIHJhdGhlciB0aGFuCiAgKglleHBsaWNpdGx5IHByb3ZpZGVkIGJ5IHRoZSBvcmlnaW5hbCBwcm92aWRlciBvZiB0aGUgc2VjdXJpdHkKICAqCWRlc2NyaXB0b3IuICBUaGlzIG1heSBhZmZlY3QgdGhlIHRyZWF0bWVudCBvZiB0aGUgU0lEIHdpdGggcmVzcGVjdCB0bwotICoJaW5oZXJpdGVuY2Ugb2YgYSBwcmltYXJ5IGdyb3VwLgorICoJaW5oZXJpdGFuY2Ugb2YgYSBwcmltYXJ5IGdyb3VwLgogICoKICAqIFNFX0RBQ0xfUFJFU0VOVCAtIFRoaXMgYm9vbGVhbiBmbGFnLCB3aGVuIHNldCwgaW5kaWNhdGVzIHRoYXQgdGhlIHNlY3VyaXR5CiAgKglkZXNjcmlwdG9yIGNvbnRhaW5zIGEgZGlzY3JldGlvbmFyeSBBQ0wuICBJZiB0aGlzIGZsYWcgaXMgc2V0IGFuZCB0aGUKQEAgLTE2NzQsNyArMTY3NCw3IEBACiAgKglwb2ludGVkIHRvIGJ5IHRoZSBEYWNsIGZpZWxkIHdhcyBwcm92aWRlZCBieSBhIGRlZmF1bHRpbmcgbWVjaGFuaXNtCiAgKglyYXRoZXIgdGhhbiBleHBsaWNpdGx5IHByb3ZpZGVkIGJ5IHRoZSBvcmlnaW5hbCBwcm92aWRlciBvZiB0aGUKICAqCXNlY3VyaXR5IGRlc2NyaXB0b3IuICBUaGlzIG1heSBhZmZlY3QgdGhlIHRyZWF0bWVudCBvZiB0aGUgQUNMIHdpdGgKLSAqCXJlc3BlY3QgdG8gaW5oZXJpdGVuY2Ugb2YgYW4gQUNMLiAgVGhpcyBmbGFnIGlzIGlnbm9yZWQgaWYgdGhlCisgKglyZXNwZWN0IHRvIGluaGVyaXRhbmNlIG9mIGFuIEFDTC4gIFRoaXMgZmxhZyBpcyBpZ25vcmVkIGlmIHRoZQogICoJRGFjbFByZXNlbnQgZmxhZyBpcyBub3Qgc2V0LgogICoKICAqIFNFX1NBQ0xfUFJFU0VOVCAtIFRoaXMgYm9vbGVhbiBmbGFnLCB3aGVuIHNldCwgIGluZGljYXRlcyB0aGF0IHRoZSBzZWN1cml0eQpAQCAtMTY4Niw3ICsxNjg2LDcgQEAKICAqCXBvaW50ZWQgdG8gYnkgdGhlIFNhY2wgZmllbGQgd2FzIHByb3ZpZGVkIGJ5IGEgZGVmYXVsdGluZyBtZWNoYW5pc20KICAqCXJhdGhlciB0aGFuIGV4cGxpY2l0bHkgcHJvdmlkZWQgYnkgdGhlIG9yaWdpbmFsIHByb3ZpZGVyIG9mIHRoZQogICoJc2VjdXJpdHkgZGVzY3JpcHRvci4gIFRoaXMgbWF5IGFmZmVjdCB0aGUgdHJlYXRtZW50IG9mIHRoZSBBQ0wgd2l0aAotICoJcmVzcGVjdCB0byBpbmhlcml0ZW5jZSBvZiBhbiBBQ0wuICBUaGlzIGZsYWcgaXMgaWdub3JlZCBpZiB0aGUKKyAqCXJlc3BlY3QgdG8gaW5oZXJpdGFuY2Ugb2YgYW4gQUNMLiAgVGhpcyBmbGFnIGlzIGlnbm9yZWQgaWYgdGhlCiAgKglTYWNsUHJlc2VudCBmbGFnIGlzIG5vdCBzZXQuCiAgKgogICogU0VfU0VMRl9SRUxBVElWRSAtIFRoaXMgYm9vbGVhbiBmbGFnLCB3aGVuIHNldCwgaW5kaWNhdGVzIHRoYXQgdGhlIHNlY3VyaXR5CkBAIC0yMjgzLDcgKzIyODMsNyBAQAogCS8vCQkgICB0aGUga2V5X2xlbmd0aCBpcyB6ZXJvLCB0aGVuIHRoZSB2Y24gaW1tZWRpYXRlbHkKIAkvLwkJICAgZm9sbG93cyB0aGUgSU5ERVhfRU5UUllfSEVBREVSLiBSZWdhcmRsZXNzIG9mCiAJLy8JCSAgIGtleV9sZW5ndGgsIHRoZSBhZGRyZXNzIG9mIHRoZSA4LWJ5dGUgYm91bmRhcnkKLQkvLwkJICAgYWxsaWduZWQgdmNuIG9mIElOREVYX0VOVFJZe19IRUFERVJ9ICppZSBpcyBnaXZlbiBieQorCS8vCQkgICBhbGlnbmVkIHZjbiBvZiBJTkRFWF9FTlRSWXtfSEVBREVSfSAqaWUgaXMgZ2l2ZW4gYnkKIAkvLwkJICAgKGNoYXIqKWllICsgbGUxNl90b19jcHUoaWUqKS0+bGVuZ3RoKSAtIHNpemVvZihWQ04pLAogCS8vCQkgICB3aGVyZSBzaXplb2YoVkNOKSBjYW4gYmUgaGFyZGNvZGVkIGFzIDggaWYgd2FudGVkLiAqLwogfSBfX2F0dHJpYnV0ZV9fICgoX19wYWNrZWRfXykpIElOREVYX0VOVFJZOwpkaWZmIC0tZ2l0IGEvZnMvbnRmcy9sb2dmaWxlLmMgYi9mcy9udGZzL2xvZ2ZpbGUuYwppbmRleCA0ZGFkY2RmLi5jNzFkZTI5IDEwMDY0NAotLS0gYS9mcy9udGZzL2xvZ2ZpbGUuYworKysgYi9mcy9udGZzL2xvZ2ZpbGUuYwpAQCAtNjY5LDcgKzY2OSw3IEBACiAgKiBvZiBjYXNlcyB3aGVyZSB3ZSB0aGluayB0aGF0IGEgdm9sdW1lIGlzIGRpcnR5IHdoZW4gaW4gZmFjdCBpdCBpcyBjbGVhbi4KICAqIFRoaXMgc2hvdWxkIG9ubHkgYWZmZWN0IHZvbHVtZXMgdGhhdCBoYXZlIG5vdCBiZWVuIHNodXRkb3duIGNsZWFubHkgYnV0IGRpZAogICogbm90IGhhdmUgYW55IHBlbmRpbmcsIG5vbi1jaGVjay1wb2ludGVkIGkvbywgaS5lLiB0aGV5IHdlcmUgY29tcGxldGVseSBpZGxlCi0gKiBhdCBsZWFzdCBmb3IgdGhlIGZpdmUgc2Vjb25kcyBwcmVjZWVkaW5nIHRoZSB1bmNsZWFuIHNodXRkb3duLgorICogYXQgbGVhc3QgZm9yIHRoZSBmaXZlIHNlY29uZHMgcHJlY2VkaW5nIHRoZSB1bmNsZWFuIHNodXRkb3duLgogICoKICAqIFRoaXMgZnVuY3Rpb24gYXNzdW1lcyB0aGF0IHRoZSAkTG9nRmlsZSBqb3VybmFsIGhhcyBhbHJlYWR5IGJlZW4gY29uc2lzdGVuY3kKICAqIGNoZWNrZWQgYnkgYSBjYWxsIHRvIG50ZnNfY2hlY2tfbG9nZmlsZSgpIGFuZCBpbiBwYXJ0aWN1bGFyIGlmIHRoZSAkTG9nRmlsZQpkaWZmIC0tZ2l0IGEvZnMvbnRmcy9sb2dmaWxlLmggYi9mcy9udGZzL2xvZ2ZpbGUuaAppbmRleCBiNWE2ZjA4Li5hYTJiNmFjIDEwMDY0NAotLS0gYS9mcy9udGZzL2xvZ2ZpbGUuaAorKysgYi9mcy9udGZzL2xvZ2ZpbGUuaApAQCAtMjIyLDcgKzIyMiw3IEBACiAvKiAyNCovCXNsZTY0IGZpbGVfc2l6ZTsJLyogVXNhYmxlIGJ5dGUgc2l6ZSBvZiB0aGUgbG9nIGZpbGUuICBJZiB0aGUKIAkJCQkgICByZXN0YXJ0X2FyZWFfb2Zmc2V0ICsgdGhlIG9mZnNldCBvZiB0aGUKIAkJCQkgICBmaWxlX3NpemUgYXJlID4gNTEwIHRoZW4gY29ycnVwdGlvbiBoYXMKLQkJCQkgICBvY2N1cmVkLiAgVGhpcyBpcyB0aGUgdmVyeSBmaXJzdCBjaGVjayB3aGVuCisJCQkJICAgb2NjdXJyZWQuICBUaGlzIGlzIHRoZSB2ZXJ5IGZpcnN0IGNoZWNrIHdoZW4KIAkJCQkgICBzdGFydGluZyB3aXRoIHRoZSByZXN0YXJ0X2FyZWEgYXMgaWYgaXQKIAkJCQkgICBmYWlscyBpdCBtZWFucyB0aGF0IHNvbWUgb2YgdGhlIGFib3ZlIHZhbHVlcwogCQkJCSAgIHdpbGwgYmUgY29ycnVwdGVkIGJ5IHRoZSBtdWx0aSBzZWN0b3IKZGlmZiAtLWdpdCBhL2ZzL250ZnMvbWZ0LmMgYi9mcy9udGZzL21mdC5jCmluZGV4IDMyNmU3NDcuLjM4Mjg1N2YgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMvbWZ0LmMKKysrIGIvZnMvbnRmcy9tZnQuYwpAQCAtNzMsNyArNzMsNyBAQAogCQlpZiAoaW5kZXggPiBlbmRfaW5kZXggfHwgKGlfc2l6ZSAmIH5QQUdFX0NBQ0hFX01BU0spIDwgb2ZzICsKIAkJCQl2b2wtPm1mdF9yZWNvcmRfc2l6ZSkgewogCQkJcGFnZSA9IEVSUl9QVFIoLUVOT0VOVCk7Ci0JCQludGZzX2Vycm9yKHZvbC0+c2IsICJBdHRlbXQgdG8gcmVhZCBtZnQgcmVjb3JkIDB4JWx4LCAiCisJCQludGZzX2Vycm9yKHZvbC0+c2IsICJBdHRlbXB0IHRvIHJlYWQgbWZ0IHJlY29yZCAweCVseCwgIgogCQkJCQkid2hpY2ggaXMgYmV5b25kIHRoZSBlbmQgb2YgdGhlIG1mdC4gICIKIAkJCQkJIlRoaXMgaXMgcHJvYmFibHkgYSBidWcgaW4gdGhlIG50ZnMgIgogCQkJCQkiZHJpdmVyLiIsIG5pLT5tZnRfbm8pOwpAQCAtMTQ0Miw3ICsxNDQyLDcgQEAKIAkJLy8gTm90ZTogSXQgd2lsbCBuZWVkIHRvIGJlIGEgc3BlY2lhbCBtZnQgcmVjb3JkIGFuZCBpZiBub25lIG9mCiAJCS8vIHRob3NlIGFyZSBhdmFpbGFibGUgaXQgZ2V0cyByYXRoZXIgY29tcGxpY2F0ZWQuLi4KIAkJbnRmc19lcnJvcih2b2wtPnNiLCAiTm90IGVub3VnaCBzcGFjZSBpbiB0aGlzIG1mdCByZWNvcmQgdG8gIgotCQkJCSJhY2NvbW9kYXRlIGV4dGVuZGVkIG1mdCBiaXRtYXAgYXR0cmlidXRlICIKKwkJCQkiYWNjb21tb2RhdGUgZXh0ZW5kZWQgbWZ0IGJpdG1hcCBhdHRyaWJ1dGUgIgogCQkJCSJleHRlbnQuICBDYW5ub3QgaGFuZGxlIHRoaXMgeWV0LiIpOwogCQlyZXQgPSAtRU9QTk9UU1VQUDsKIAkJZ290byB1bmRvX2FsbG9jOwpAQCAtMTg3OSw3ICsxODc5LDcgQEAKIAkJLy8gYW5kIHdlIHdvdWxkIHRoZW4gbmVlZCB0byB1cGRhdGUgYWxsIHJlZmVyZW5jZXMgdG8gdGhpcyBtZnQKIAkJLy8gcmVjb3JkIGFwcHJvcHJpYXRlbHkuICBUaGlzIGlzIHJhdGhlciBjb21wbGljYXRlZC4uLgogCQludGZzX2Vycm9yKHZvbC0+c2IsICJOb3QgZW5vdWdoIHNwYWNlIGluIHRoaXMgbWZ0IHJlY29yZCB0byAiCi0JCQkJImFjY29tb2RhdGUgZXh0ZW5kZWQgbWZ0IGRhdGEgYXR0cmlidXRlICIKKwkJCQkiYWNjb21tb2RhdGUgZXh0ZW5kZWQgbWZ0IGRhdGEgYXR0cmlidXRlICIKIAkJCQkiZXh0ZW50LiAgQ2Fubm90IGhhbmRsZSB0aGlzIHlldC4iKTsKIAkJcmV0ID0gLUVPUE5PVFNVUFA7CiAJCWdvdG8gdW5kb19hbGxvYzsKQEAgLTIzNTcsNyArMjM1Nyw3IEBACiAJfQogI2lmZGVmIERFQlVHCiAJcmVhZF9sb2NrX2lycXNhdmUoJm1mdGJtcF9uaS0+c2l6ZV9sb2NrLCBmbGFncyk7Ci0JbnRmc19kZWJ1ZygiU3RhdHVzIG9mIG1mdGJtcCBhZnRlciBpbml0aWFsaXplZCBleHRlbnRpb246ICIKKwludGZzX2RlYnVnKCJTdGF0dXMgb2YgbWZ0Ym1wIGFmdGVyIGluaXRpYWxpemVkIGV4dGVuc2lvbjogIgogCQkJImFsbG9jYXRlZF9zaXplIDB4JWxseCwgZGF0YV9zaXplIDB4JWxseCwgIgogCQkJImluaXRpYWxpemVkX3NpemUgMHglbGx4LiIsCiAJCQkobG9uZyBsb25nKW1mdGJtcF9uaS0+YWxsb2NhdGVkX3NpemUsCmRpZmYgLS1naXQgYS9mcy9udGZzL3J1bmxpc3QuYyBiL2ZzL250ZnMvcnVubGlzdC5jCmluZGV4IDU2YTlhNmQuLmVhYzdkNjcgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMvcnVubGlzdC5jCisrKyBiL2ZzL250ZnMvcnVubGlzdC5jCkBAIC0xMjQzLDcgKzEyNDMsNyBAQAogICogd3JpdGUuCiAgKgogICogVGhpcyBpcyB1c2VkIHdoZW4gYnVpbGRpbmcgdGhlIG1hcHBpbmcgcGFpcnMgYXJyYXkgb2YgYSBydW5saXN0IHRvIGNvbXByZXNzCi0gKiBhIGdpdmVuIGxvZ2ljYWwgY2x1c3RlciBudW1iZXIgKGxjbikgb3IgYSBzcGVjaWZpYyBydW4gbGVuZ3RoIHRvIHRoZSBtaW51bXVtCisgKiBhIGdpdmVuIGxvZ2ljYWwgY2x1c3RlciBudW1iZXIgKGxjbikgb3IgYSBzcGVjaWZpYyBydW4gbGVuZ3RoIHRvIHRoZSBtaW5pbXVtCiAgKiBzaXplIHBvc3NpYmxlLgogICoKICAqIFJldHVybiB0aGUgbnVtYmVyIG9mIGJ5dGVzIHdyaXR0ZW4gb24gc3VjY2Vzcy4gIE9uIGVycm9yLCBpLmUuIHRoZQpkaWZmIC0tZ2l0IGEvZnMvbnRmcy9zdXBlci5jIGIvZnMvbnRmcy9zdXBlci5jCmluZGV4IDI5MDk5YTAuLmI1MjcwNmQgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMvc3VwZXIuYworKysgYi9mcy9udGZzL3N1cGVyLmMKQEAgLTQ1OCw3ICs0NTgsNyBAQAogCSAqIHRoZSB2b2x1bWUgb24gYm9vdCBhbmQgdXBkYXRlcyB0aGVtLgogCSAqCiAJICogV2hlbiByZW1vdW50aW5nIHJlYWQtb25seSwgbWFyayB0aGUgdm9sdW1lIGNsZWFuIGlmIG5vIHZvbHVtZSBlcnJvcnMKLQkgKiBoYXZlIG9jY3VyZWQuCisJICogaGF2ZSBvY2N1cnJlZC4KIAkgKi8KIAlpZiAoKHNiLT5zX2ZsYWdzICYgTVNfUkRPTkxZKSAmJiAhKCpmbGFncyAmIE1TX1JET05MWSkpIHsKIAkJc3RhdGljIGNvbnN0IGNoYXIgKmVzID0gIi4gIENhbm5vdCByZW1vdW50IHJlYWQtd3JpdGUuIjsKQEAgLTEyNjksNyArMTI2OSw3IEBACiAJCQkJCSJoaWJlcm5hdGVkIG9uIHRoZSB2b2x1bWUuIik7CiAJCQlyZXR1cm4gMDsKIAkJfQotCQkvKiBBIHJlYWwgZXJyb3Igb2NjdXJlZC4gKi8KKwkJLyogQSByZWFsIGVycm9yIG9jY3VycmVkLiAqLwogCQludGZzX2Vycm9yKHZvbC0+c2IsICJGYWlsZWQgdG8gZmluZCBpbm9kZSBudW1iZXIgZm9yICIKIAkJCQkiaGliZXJmaWwuc3lzLiIpOwogCQlyZXR1cm4gcmV0OwpAQCAtMTM3MCw3ICsxMzcwLDcgQEAKIAkJCU5Wb2xTZXRRdW90YU91dE9mRGF0ZSh2b2wpOwogCQkJcmV0dXJuIHRydWU7CiAJCX0KLQkJLyogQSByZWFsIGVycm9yIG9jY3VyZWQuICovCisJCS8qIEEgcmVhbCBlcnJvciBvY2N1cnJlZC4gKi8KIAkJbnRmc19lcnJvcih2b2wtPnNiLCAiRmFpbGVkIHRvIGZpbmQgaW5vZGUgbnVtYmVyIGZvciAkUXVvdGEuIik7CiAJCXJldHVybiBmYWxzZTsKIAl9CkBAIC0xNDU0LDcgKzE0NTQsNyBAQAogCQkJTlZvbFNldFVzbkpybmxTdGFtcGVkKHZvbCk7CiAJCQlyZXR1cm4gdHJ1ZTsKIAkJfQotCQkvKiBBIHJlYWwgZXJyb3Igb2NjdXJlZC4gKi8KKwkJLyogQSByZWFsIGVycm9yIG9jY3VycmVkLiAqLwogCQludGZzX2Vycm9yKHZvbC0+c2IsICJGYWlsZWQgdG8gZmluZCBpbm9kZSBudW1iZXIgZm9yICIKIAkJCQkiJFVzbkpybmwuIik7CiAJCXJldHVybiBmYWxzZTsKQEAgLTIyOTIsNyArMjI5Miw3IEBACiAJbnRmc19jb21taXRfaW5vZGUodm9sLT5tZnRfaW5vKTsKIAogCS8qCi0JICogSWYgYSByZWFkLXdyaXRlIG1vdW50IGFuZCBubyB2b2x1bWUgZXJyb3JzIGhhdmUgb2NjdXJlZCwgbWFyayB0aGUKKwkgKiBJZiBhIHJlYWQtd3JpdGUgbW91bnQgYW5kIG5vIHZvbHVtZSBlcnJvcnMgaGF2ZSBvY2N1cnJlZCwgbWFyayB0aGUKIAkgKiB2b2x1bWUgY2xlYW4uICBBbHNvLCByZS1jb21taXQgYWxsIGFmZmVjdGVkIGlub2Rlcy4KIAkgKi8KIAlpZiAoIShzYi0+c19mbGFncyAmIE1TX1JET05MWSkpIHsKQEAgLTI0OTYsNyArMjQ5Niw3IEBACiAJaWYgKHZvbC0+bnJfY2x1c3RlcnMgJiA2MykKIAkJbnJfZnJlZSArPSA2NCAtICh2b2wtPm5yX2NsdXN0ZXJzICYgNjMpOwogCXVwX3JlYWQoJnZvbC0+bGNuYm1wX2xvY2spOwotCS8qIElmIGVycm9ycyBvY2N1cmVkIHdlIG1heSB3ZWxsIGhhdmUgZ29uZSBiZWxvdyB6ZXJvLCBmaXggdGhpcy4gKi8KKwkvKiBJZiBlcnJvcnMgb2NjdXJyZWQgd2UgbWF5IHdlbGwgaGF2ZSBnb25lIGJlbG93IHplcm8sIGZpeCB0aGlzLiAqLwogCWlmIChucl9mcmVlIDwgMCkKIAkJbnJfZnJlZSA9IDA7CiAJbnRmc19kZWJ1ZygiRXhpdGluZy4iKTsKQEAgLTI1NjEsNyArMjU2MSw3IEBACiAJfQogCW50ZnNfZGVidWcoIkZpbmlzaGVkIHJlYWRpbmcgJE1GVC8kQklUTUFQLCBsYXN0IGluZGV4ID0gMHglbHguIiwKIAkJCWluZGV4IC0gMSk7Ci0JLyogSWYgZXJyb3JzIG9jY3VyZWQgd2UgbWF5IHdlbGwgaGF2ZSBnb25lIGJlbG93IHplcm8sIGZpeCB0aGlzLiAqLworCS8qIElmIGVycm9ycyBvY2N1cnJlZCB3ZSBtYXkgd2VsbCBoYXZlIGdvbmUgYmVsb3cgemVybywgZml4IHRoaXMuICovCiAJaWYgKG5yX2ZyZWUgPCAwKQogCQlucl9mcmVlID0gMDsKIAludGZzX2RlYnVnKCJFeGl0aW5nLiIpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvYWxsb2MuYyBiL2ZzL29jZnMyL2FsbG9jLmMKaW5kZXggYjI3YTBkOC4uNDhhYTljNyAxMDA2NDQKLS0tIGEvZnMvb2NmczIvYWxsb2MuYworKysgYi9mcy9vY2ZzMi9hbGxvYy5jCkBAIC00NTE5LDcgKzQ1MTksNyBAQAogfQogCiAvKgotICogSGVscGVyIGZ1bmN0aW9uIGNhbGxlZCBhdCB0aGUgYmVnaW5pbmcgb2YgYW4gaW5zZXJ0LgorICogSGVscGVyIGZ1bmN0aW9uIGNhbGxlZCBhdCB0aGUgYmVnaW5uaW5nIG9mIGFuIGluc2VydC4KICAqCiAgKiBUaGlzIGNvbXB1dGVzIGEgZmV3IHRoaW5ncyB0aGF0IGFyZSBjb21tb25seSB1c2VkIGluIHRoZSBwcm9jZXNzIG9mCiAgKiBpbnNlcnRpbmcgaW50byB0aGUgYnRyZWU6CmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9hb3BzLmggYi9mcy9vY2ZzMi9hb3BzLmgKaW5kZXggZWNlYjQ1Ni4uNzVjZjNhZCAxMDA2NDQKLS0tIGEvZnMvb2NmczIvYW9wcy5oCisrKyBiL2ZzL29jZnMyL2FvcHMuaApAQCAtNzEsNyArNzEsNyBAQAogCiAvKgogICogVXNpbmcgYSBuYW1lZCBlbnVtIHJlcHJlc2VudGluZyBsb2NrIHR5cGVzIGluIHRlcm1zIG9mICNOIGJpdCBzdG9yZWQgaW4KLSAqIGlvY2ItPnByaXZhdGUsIHdoaWNoIGlzIGdvaW5nIHRvIGJlIHVzZWQgZm9yIGNvbW11bmljYXRpb24gYmV3dGVlbgorICogaW9jYi0+cHJpdmF0ZSwgd2hpY2ggaXMgZ29pbmcgdG8gYmUgdXNlZCBmb3IgY29tbXVuaWNhdGlvbiBiZXR3ZWVuCiAgKiBvY2ZzMl9kaW9fZW5kX2lvKCkgYW5kIG9jZnMyX2ZpbGVfYWlvX3dyaXRlL3JlYWQoKS4KICAqLwogZW51bSBvY2ZzMl9pb2NiX2xvY2tfYml0cyB7CmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9jbHVzdGVyL2hlYXJ0YmVhdC5jIGIvZnMvb2NmczIvY2x1c3Rlci9oZWFydGJlYXQuYwppbmRleCAyNDYxZWIzLi42NDM3MjAyIDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9jbHVzdGVyL2hlYXJ0YmVhdC5jCisrKyBiL2ZzL29jZnMyL2NsdXN0ZXIvaGVhcnRiZWF0LmMKQEAgLTIyNzUsNyArMjI3NSw3IEBACiAJa2ZyZWUoaHMpOwogfQogCi0vKiBoYiBjYWxsYmFjayByZWdpc3RyYXRpb24gYW5kIGlzc3VlaW5nICovCisvKiBoYiBjYWxsYmFjayByZWdpc3RyYXRpb24gYW5kIGlzc3VpbmcgKi8KIAogc3RhdGljIHN0cnVjdCBvMmhiX2NhbGxiYWNrICpoYmNhbGxfZnJvbV90eXBlKGVudW0gbzJoYl9jYWxsYmFja190eXBlIHR5cGUpCiB7CmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9jbHVzdGVyL3F1b3J1bS5jIGIvZnMvb2NmczIvY2x1c3Rlci9xdW9ydW0uYwppbmRleCBhODczNjY3Li44ZjljZWExIDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9jbHVzdGVyL3F1b3J1bS5jCisrKyBiL2ZzL29jZnMyL2NsdXN0ZXIvcXVvcnVtLmMKQEAgLTg5LDcgKzg5LDcgQEAKIAl9OwogfQogCi0vKiBJbmRpY2F0ZSB0aGF0IGEgdGltZW91dCBvY2N1cmVkIG9uIGEgaGVhcmJlYXQgcmVnaW9uIHdyaXRlLiBUaGUKKy8qIEluZGljYXRlIHRoYXQgYSB0aW1lb3V0IG9jY3VycmVkIG9uIGEgaGVhcmJlYXQgcmVnaW9uIHdyaXRlLiBUaGUKICAqIG90aGVyIG5vZGVzIGluIHRoZSBjbHVzdGVyIG1heSBjb25zaWRlciB1cyBkZWFkIGF0IHRoYXQgdGltZSBzbyB3ZQogICogd2FudCB0byAiZmVuY2UiIG91cnNlbHZlcyBzbyB0aGF0IHdlIGRvbid0IHNjcmliYmxlIG9uIHRoZSBkaXNrCiAgKiBhZnRlciB0aGV5IHRoaW5rIHRoZXkndmUgcmVjb3ZlcmVkIHVzLiBUaGlzIGNhbid0IHNvbHZlIGFsbApAQCAtMjYxLDcgKzI2MSw3IEBACiAJc3Bpbl91bmxvY2soJnFzLT5xc19sb2NrKTsKIH0KIAotLyogVGhpcyBpcyBhbmFsYWdvdXMgdG8gaGJfdXAuICBhcyBhIG5vZGUncyBjb25uZWN0aW9uIGNvbWVzIHVwIHdlIGRlbGF5IHRoZQorLyogVGhpcyBpcyBhbmFsb2dvdXMgdG8gaGJfdXAuICBhcyBhIG5vZGUncyBjb25uZWN0aW9uIGNvbWVzIHVwIHdlIGRlbGF5IHRoZQogICogcXVvcnVtIGRlY2lzaW9uIHVudGlsIHdlIHNlZSBpdCBoZWFydGJlYXRpbmcuICB0aGUgaG9sZCB3aWxsIGJlIGRyb3BlZCBpbgogICogaGJfdXAgb3IgaGJfZG93bi4gIGl0IG1pZ2h0IGJlIHBlcnBldHVhdGVkIGJ5IGNvbl9lcnIgdW50aWwgaGJfZG93bi4gIGlmCiAgKiBpdCdzIGFscmVhZHkgaGVhcnRiZWF0aW5nIHdlIHdlIG1pZ2h0IGJlIGRyb3BwaW5nIGEgaG9sZCB0aGF0IGNvbm5fdXAgZ290LgpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvY2x1c3Rlci90Y3AuYyBiL2ZzL29jZnMyL2NsdXN0ZXIvdGNwLmMKaW5kZXggZWUwNGZmNS4uZGI1ZWU0YiAxMDA2NDQKLS0tIGEvZnMvb2NmczIvY2x1c3Rlci90Y3AuYworKysgYi9mcy9vY2ZzMi9jbHVzdGVyL3RjcC5jCkBAIC01NjUsNyArNTY1LDcgQEAKIAkgKiB0aGUgd29yayBxdWV1ZSBhY3R1YWxseSBiZWluZyB1cC4gKi8KIAlpZiAoIXZhbGlkICYmIG8ybmV0X3dxKSB7CiAJCXVuc2lnbmVkIGxvbmcgZGVsYXk7Ci0JCS8qIGRlbGF5IGlmIHdlJ3JlIHdpdGhpbmcgYSBSRUNPTk5FQ1RfREVMQVkgb2YgdGhlCisJCS8qIGRlbGF5IGlmIHdlJ3JlIHdpdGhpbiBhIFJFQ09OTkVDVF9ERUxBWSBvZiB0aGUKIAkJICogbGFzdCBhdHRlbXB0ICovCiAJCWRlbGF5ID0gKG5uLT5ubl9sYXN0X2Nvbm5lY3RfYXR0ZW1wdCArCiAJCQkgbXNlY3NfdG9famlmZmllcyhvMm5ldF9yZWNvbm5lY3RfZGVsYXkoKSkpCmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9kbG0vZGxtbWFzdGVyLmMgYi9mcy9vY2ZzMi9kbG0vZGxtbWFzdGVyLmMKaW5kZXggOWQ2NzYxMC4uZmVkZTU3ZSAxMDA2NDQKLS0tIGEvZnMvb2NmczIvZGxtL2RsbW1hc3Rlci5jCisrKyBiL2ZzL29jZnMyL2RsbS9kbG1tYXN0ZXIuYwpAQCAtODA4LDcgKzgwOCw3IEBACiAJCQkJZGxtX21sZV9kZXRhY2hfaGJfZXZlbnRzKGRsbSwgbWxlKTsKIAkJCWRsbV9wdXRfbWxlKG1sZSk7CiAJCQltbGUgPSBOVUxMOwotCQkJLyogdGhpcyBpcyBsYW1lLCBidXQgd2UgY2FudCB3YWl0IG9uIGVpdGhlcgorCQkJLyogdGhpcyBpcyBsYW1lLCBidXQgd2UgY2FuJ3Qgd2FpdCBvbiBlaXRoZXIKIAkJCSAqIHRoZSBtbGUgb3IgbG9ja3JlcyB3YWl0cXVldWUgaGVyZSAqLwogCQkJaWYgKG1pZykKIAkJCQltc2xlZXAoMTAwKTsKQEAgLTg0Myw3ICs4NDMsNyBAQAogCiAJLyogZmluYWxseSBhZGQgdGhlIGxvY2tyZXMgdG8gaXRzIGhhc2ggYnVja2V0ICovCiAJX19kbG1faW5zZXJ0X2xvY2tyZXMoZGxtLCByZXMpOwotCS8qIHNpbmNlIHRoaXMgbG9ja3JlcyBpcyBuZXcgaXQgZG9lc250IG5vdCByZXF1aXJlIHRoZSBzcGlubG9jayAqLworCS8qIHNpbmNlIHRoaXMgbG9ja3JlcyBpcyBuZXcgaXQgZG9lc24ndCBub3QgcmVxdWlyZSB0aGUgc3BpbmxvY2sgKi8KIAlkbG1fbG9ja3Jlc19ncmFiX2luZmxpZ2h0X3JlZl9uZXcoZGxtLCByZXMpOwogCiAJLyogaWYgdGhpcyBub2RlIGRvZXMgbm90IGJlY29tZSB0aGUgbWFzdGVyIG1ha2Ugc3VyZSB0byBkcm9wCmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9pbm9kZS5jIGIvZnMvb2NmczIvaW5vZGUuYwppbmRleCAxNzdkM2E2Li5iNGM4YmI2IDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9pbm9kZS5jCisrKyBiL2ZzL29jZnMyL2lub2RlLmMKQEAgLTgzNSw3ICs4MzUsNyBAQAogCiAJLyogSWYgd2UgaGF2ZSBhbGxvd2Qgd2lwZSBvZiB0aGlzIGlub2RlIGZvciBhbm90aGVyIG5vZGUsIGl0CiAJICogd2lsbCBiZSBtYXJrZWQgaGVyZSBzbyB3ZSBjYW4gc2FmZWx5IHNraXAgaXQuIFJlY292ZXJ5IHdpbGwKLQkgKiBjbGVhbnVwIGFueSBpbm9kZXMgd2UgbWlnaHQgaW5hZHZlcnRhbnRseSBza2lwIGhlcmUuICovCisJICogY2xlYW51cCBhbnkgaW5vZGVzIHdlIG1pZ2h0IGluYWR2ZXJ0ZW50bHkgc2tpcCBoZXJlLiAqLwogCWlmIChvaS0+aXBfZmxhZ3MgJiBPQ0ZTMl9JTk9ERV9TS0lQX0RFTEVURSkKIAkJZ290byBiYWlsX3VubG9jazsKIApAQCAtOTE3LDcgKzkxNyw3IEBACiAJICogdGhlIGlub2RlIG9wZW4gbG9jayBpbiBvY2ZzMl9yZWFkX2xvY2tlZF9pbm9kZSgpLiBXaGVuIHdlCiAJICogZ2V0IHRvIC0+ZGVsZXRlX2lub2RlKCksIGVhY2ggbm9kZSB0cmllcyB0byBjb252ZXJ0IGl0J3MKIAkgKiBsb2NrIHRvIGFuIGV4Y2x1c2l2ZS4gVHJ5bG9ja3MgYXJlIHNlcmlhbGl6ZWQgYnkgdGhlIGlub2RlCi0JICogbWV0YSBkYXRhIGxvY2suIElmIHRoZSB1cGNvbnZlcnQgc3VjZWVkcywgd2Uga25vdyB0aGUgaW5vZGUKKwkgKiBtZXRhIGRhdGEgbG9jay4gSWYgdGhlIHVwY29udmVydCBzdWNjZWVkcywgd2Uga25vdyB0aGUgaW5vZGUKIAkgKiBpcyBubyBsb25nZXIgbGl2ZSBhbmQgY2FuIGJlIGRlbGV0ZWQuCiAJICoKIAkgKiBUaG91Z2ggd2UgY2FsbCB0aGlzIHdpdGggdGhlIG1ldGEgZGF0YSBsb2NrIGhlbGQsIHRoZQpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvam91cm5hbC5jIGIvZnMvb2NmczIvam91cm5hbC5jCmluZGV4IGRjYzJkOTMuLmIxNDFhNDQgMTAwNjQ0Ci0tLSBhL2ZzL29jZnMyL2pvdXJuYWwuYworKysgYi9mcy9vY2ZzMi9qb3VybmFsLmMKQEAgLTEzNjgsNyArMTM2OCw3IEBACiAJCW1sb2dfZXJybm8oc3RhdHVzKTsKIAogCS8qIE5vdyBpdCBpcyByaWdodCB0aW1lIHRvIHJlY292ZXIgcXVvdGFzLi4uIFdlIGhhdmUgdG8gZG8gdGhpcyB1bmRlcgotCSAqIHN1cGVyYmxvY2sgbG9jayBzbyB0aGF0IG5vb25lIGNhbiBzdGFydCB1c2luZyB0aGUgc2xvdCAoYW5kIGNyYXNoKQorCSAqIHN1cGVyYmxvY2sgbG9jayBzbyB0aGF0IG5vIG9uZSBjYW4gc3RhcnQgdXNpbmcgdGhlIHNsb3QgKGFuZCBjcmFzaCkKIAkgKiBiZWZvcmUgd2UgcmVjb3ZlciBpdCAqLwogCWZvciAoaSA9IDA7IGkgPCBybV9xdW90YV91c2VkOyBpKyspIHsKIAkJcXJlYyA9IG9jZnMyX2JlZ2luX3F1b3RhX3JlY292ZXJ5KG9zYiwgcm1fcXVvdGFbaV0pOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvam91cm5hbC5oIGIvZnMvb2NmczIvam91cm5hbC5oCmluZGV4IDYxODBkYTEuLjY4Y2YyZjYgMTAwNjQ0Ci0tLSBhL2ZzL29jZnMyL2pvdXJuYWwuaAorKysgYi9mcy9vY2ZzMi9qb3VybmFsLmgKQEAgLTIxNSw3ICsyMTUsNyBAQAogCQkvKiBXQVJOSU5HOiBUaGlzIG9ubHkga2lja3Mgb2ZmIGEgc2luZ2xlCiAJCSAqIGNoZWNrcG9pbnQuIElmIHNvbWVvbmUgcmFjZXMgeW91IGFuZCBhZGRzIG1vcmUKIAkJICogbWV0YWRhdGEgdG8gdGhlIGpvdXJuYWwsIHlvdSB3b24ndCBrbm93LCBhbmQgd2lsbAotCQkgKiB3aW5kIHVwIHdhaXRpbmcgKmFsb3QqIGxvbmdlciB0aGFuIG5lY2Vzc2FyeS4gUmlnaHQKKwkJICogd2luZCB1cCB3YWl0aW5nICphIGxvdCogbG9uZ2VyIHRoYW4gbmVjZXNzYXJ5LiBSaWdodAogCQkgKiBub3cgd2Ugb25seSB1c2UgdGhpcyBpbiBjbGVhcl9pbm9kZSBzbyB0aGF0J3MKIAkJICogT0suICovCiAJCW9jZnMyX3N0YXJ0X2NoZWNrcG9pbnQob3NiKTsKZGlmZiAtLWdpdCBhL2ZzL29jZnMyL25hbWVpLmMgYi9mcy9vY2ZzMi9uYW1laS5jCmluZGV4IDI4ZjJjYzEuLmU1ZDczOGMgMTAwNjQ0Ci0tLSBhL2ZzL29jZnMyL25hbWVpLmMKKysrIGIvZnMvb2NmczIvbmFtZWkuYwpAQCAtMjEyOCw3ICsyMTI4LDcgQEAKIH0KIAogLyoqCi0gKiBvY2ZzMl9wcmVwX25ld19vcnBoYW5lZF9maWxlKCkgLSBQcmVwYXJlIHRoZSBvcnBoYW4gZGlyIHRvIHJlY2lldmUgYSBuZXdseQorICogb2NmczJfcHJlcF9uZXdfb3JwaGFuZWRfZmlsZSgpIC0gUHJlcGFyZSB0aGUgb3JwaGFuIGRpciB0byByZWNlaXZlIGEgbmV3bHkKICAqIGFsbG9jYXRlZCBmaWxlLiBUaGlzIGlzIGRpZmZlcmVudCBmcm9tIHRoZSB0eXBpY2FsICdhZGQgdG8gb3JwaGFuIGRpcicKICAqIG9wZXJhdGlvbiBpbiB0aGF0IHRoZSBpbm9kZSBkb2VzIG5vdCB5ZXQgZXhpc3QuIFRoaXMgaXMgYSBwcm9ibGVtIGJlY2F1c2UKICAqIHRoZSBvcnBoYW4gZGlyIHN0cmluZ2lmaWVzIHRoZSBpbm9kZSBibG9jayBudW1iZXIgdG8gY29tZSB1cCB3aXRoIGl0J3MKZGlmZiAtLWdpdCBhL2ZzL29jZnMyL29jZnMyX2ZzLmggYi9mcy9vY2ZzMi9vY2ZzMl9mcy5oCmluZGV4IGJmMmU3NzYuLmI2OGY4N2EgMTAwNjQ0Ci0tLSBhL2ZzL29jZnMyL29jZnMyX2ZzLmgKKysrIGIvZnMvb2NmczIvb2NmczJfZnMuaApAQCAtNDQxLDcgKzQ0MSw3IEBACiBzdHJ1Y3Qgb2NmczJfYmxvY2tfY2hlY2sgewogLyowMCovCV9fbGUzMiBiY19jcmMzMmU7CS8qIDgwMi4zIEV0aGVybmV0IElJIENSQzMyICovCiAJX19sZTE2IGJjX2VjYzsJCS8qIFNpbmdsZS1lcnJvci1jb3JyZWN0aW9uIHBhcml0eSB2ZWN0b3IuCi0JCQkJICAgVGhpcyBpcyBhIHNpbXBsZSBIYW1taW5nIGNvZGUgZGVwZW5kYW50CisJCQkJICAgVGhpcyBpcyBhIHNpbXBsZSBIYW1taW5nIGNvZGUgZGVwZW5kZW50CiAJCQkJICAgb24gdGhlIGJsb2Nrc2l6ZS4gIE9DRlMyJ3MgbWF4aW11bQogCQkJCSAgIGJsb2Nrc2l6ZSwgNEssIHJlcXVpcmVzIDE2IHBhcml0eSBiaXRzLAogCQkJCSAgIHNvIHdlIGZpdCBpbiBfX2xlMTYuICovCkBAIC03NTAsNyArNzUwLDcgQEAKIAkJCQkJCQkgIGFmdGVyIGFuIHVuY2xlYW4KIAkJCQkJCQkgIHNodXRkb3duICovCiAJCX0gam91cm5hbDE7Ci0JfSBpZDE7CQkJCS8qIElub2RlIHR5cGUgZGVwZW5kYW50IDEgKi8KKwl9IGlkMTsJCQkJLyogSW5vZGUgdHlwZSBkZXBlbmRlbnQgMSAqLwogLypDMCovCXVuaW9uIHsKIAkJc3RydWN0IG9jZnMyX3N1cGVyX2Jsb2NrCWlfc3VwZXI7CiAJCXN0cnVjdCBvY2ZzMl9sb2NhbF9hbGxvYwlpX2xhYjsKZGlmZiAtLWdpdCBhL2ZzL29jZnMyL3F1b3RhX2dsb2JhbC5jIGIvZnMvb2NmczIvcXVvdGFfZ2xvYmFsLmMKaW5kZXggMjc5YWVmNi4uOTJmY2Q1NyAxMDA2NDQKLS0tIGEvZnMvb2NmczIvcXVvdGFfZ2xvYmFsLmMKKysrIGIvZnMvb2NmczIvcXVvdGFfZ2xvYmFsLmMKQEAgLTU1Niw3ICs1NTYsNyBAQAogCXNwaW5fdW5sb2NrKCZkcV9kYXRhX2xvY2spOwogCWVyciA9IG9jZnMyX3FpbmZvX2xvY2soaW5mbywgZnJlZWluZyk7CiAJaWYgKGVyciA8IDApIHsKLQkJbWxvZyhNTF9FUlJPUiwgIkZhaWxlZCB0byBsb2NrIHF1b3RhIGluZm8sIGxvb3NpbmcgcXVvdGEgd3JpdGUiCisJCW1sb2coTUxfRVJST1IsICJGYWlsZWQgdG8gbG9jayBxdW90YSBpbmZvLCBsb3NpbmcgcXVvdGEgd3JpdGUiCiAJCQkgICAgICAgIiAodHlwZT0lZCwgaWQ9JXUpXG4iLCBkcXVvdC0+ZHFfdHlwZSwKIAkJCSAgICAgICAodW5zaWduZWQpZHF1b3QtPmRxX2lkKTsKIAkJZ290byBvdXQ7CmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9yZXNlcnZhdGlvbnMuaCBiL2ZzL29jZnMyL3Jlc2VydmF0aW9ucy5oCmluZGV4IDFlNDljYzIuLjQyYzJiODAgMTAwNjQ0Ci0tLSBhL2ZzL29jZnMyL3Jlc2VydmF0aW9ucy5oCisrKyBiL2ZzL29jZnMyL3Jlc2VydmF0aW9ucy5oCkBAIC0yOSw3ICsyOSw3IEBACiBzdHJ1Y3Qgb2NmczJfYWxsb2NfcmVzZXJ2YXRpb24gewogCXN0cnVjdCByYl9ub2RlCXJfbm9kZTsKIAotCXVuc2lnbmVkIGludAlyX3N0YXJ0OwkvKiBCZWdpbmluZyBvZiBjdXJyZW50IHdpbmRvdyAqLworCXVuc2lnbmVkIGludAlyX3N0YXJ0OwkvKiBCZWdpbm5pbmcgb2YgY3VycmVudCB3aW5kb3cgKi8KIAl1bnNpZ25lZCBpbnQJcl9sZW47CQkvKiBMZW5ndGggb2YgdGhlIHdpbmRvdyAqLwogCiAJdW5zaWduZWQgaW50CXJfbGFzdF9sZW47CS8qIExlbmd0aCBvZiBtb3N0IHJlY2VudCBhbGxvYyAqLwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvc3RhY2tnbHVlLmggYi9mcy9vY2ZzMi9zdGFja2dsdWUuaAppbmRleCA4Y2U3Mzk4Li4xZWM1NmZkIDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9zdGFja2dsdWUuaAorKysgYi9mcy9vY2ZzMi9zdGFja2dsdWUuaApAQCAtMTI2LDcgKzEyNiw3IEBACiAJICoKIAkgKiAtPmNvbm5lY3QoKSBtdXN0IG5vdCByZXR1cm4gdW50aWwgaXQgaXMgZ3VhcmFudGVlZCB0aGF0CiAJICoKLQkgKiAgLSBOb2RlIGRvd24gbm90aWZpY2F0aW9ucyBmb3IgdGhlIGZpbGVzeXN0ZW0gd2lsbCBiZSByZWNpZXZlZAorCSAqICAtIE5vZGUgZG93biBub3RpZmljYXRpb25zIGZvciB0aGUgZmlsZXN5c3RlbSB3aWxsIGJlIHJlY2VpdmVkCiAJICogICAgYW5kIHBhc3NlZCB0byBjb25uLT5jY19yZWNvdmVyeV9oYW5kbGVyKCkuCiAJICogIC0gTG9ja2luZyByZXF1ZXN0cyBmb3IgdGhlIGZpbGVzeXN0ZW0gd2lsbCBiZSBwcm9jZXNzZWQuCiAJICovCmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9zdWJhbGxvYy5jIGIvZnMvb2NmczIvc3ViYWxsb2MuYwppbmRleCBhYjZlMjA2Li5iYTVkOTdlIDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9zdWJhbGxvYy5jCisrKyBiL2ZzL29jZnMyL3N1YmFsbG9jLmMKQEAgLTE1MTEsNyArMTUxMSw3IEBACiAJCW1heF9iaXRzID0gbGUxNl90b19jcHUoZ2QtPmJnX2JpdHMpOwogCiAJCS8qIFRhaWwgZ3JvdXBzIGluIGNsdXN0ZXIgYml0bWFwcyB3aGljaCBhcmVuJ3QgY3BnCi0JCSAqIGFsaWduZWQgYXJlIHByb25lIHRvIHBhcnRpYWwgZXh0ZW50aW9uIGJ5IGEgZmFpbGVkCisJCSAqIGFsaWduZWQgYXJlIHByb25lIHRvIHBhcnRpYWwgZXh0ZW5zaW9uIGJ5IGEgZmFpbGVkCiAJCSAqIGZzIHJlc2l6ZS4gSWYgdGhlIGZpbGUgc3lzdGVtIHJlc2l6ZSBuZXZlciBnb3QgdG8KIAkJICogdXBkYXRlIHRoZSBkaW5vZGUgY2x1c3RlciBjb3VudCwgdGhlbiB3ZSBkb24ndCB3YW50CiAJCSAqIHRvIHRydXN0IGFueSBjbHVzdGVycyBwYXN0IGl0LCByZWdhcmRsZXNzIG9mIHdoYXQKQEAgLTI0NTksNyArMjQ1OSw3IEBACiAJLyogVGhlIGFsbG9jX2JoIGNvbWVzIGZyb20gb2NmczJfZnJlZV9kaW5vZGUoKSBvcgogCSAqIG9jZnMyX2ZyZWVfY2x1c3RlcnMoKS4gIFRoZSBjYWxsZXJzIGhhdmUgYWxsIGxvY2tlZCB0aGUKIAkgKiBhbGxvY2F0b3IgYW5kIGdvdHRlbiBhbGxvY19iaCBmcm9tIHRoZSBsb2NrIGNhbGwuICBUaGlzCi0JICogdmFsaWRhdGVzIHRoZSBkaW5vZGUgYnVmZmVyLiAgQW55IGNvcnJ1cHRpb24gdGhhdCBoYXMgaGFwcGVuZGVkCisJICogdmFsaWRhdGVzIHRoZSBkaW5vZGUgYnVmZmVyLiAgQW55IGNvcnJ1cHRpb24gdGhhdCBoYXMgaGFwcGVuZWQKIAkgKiBpcyBhIGNvZGUgYnVnLiAqLwogCUJVR19PTighT0NGUzJfSVNfVkFMSURfRElOT0RFKGZlKSk7CiAJQlVHX09OKChjb3VudCArIHN0YXJ0X2JpdCkgPiBvY2ZzMl9iaXRzX3Blcl9ncm91cChjbCkpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvc3VwZXIuYyBiL2ZzL29jZnMyL3N1cGVyLmMKaW5kZXggNjlmYTExYi4uNWE1MjFjNyAxMDA2NDQKLS0tIGEvZnMvb2NmczIvc3VwZXIuYworKysgYi9mcy9vY2ZzMi9zdXBlci5jCkBAIC03OCw3ICs3OCw3IEBACiBzdHJ1Y3Qga21lbV9jYWNoZSAqb2NmczJfZHF1b3RfY2FjaGVwOwogc3RydWN0IGttZW1fY2FjaGUgKm9jZnMyX3FmX2NodW5rX2NhY2hlcDsKIAotLyogT0NGUzIgbmVlZHMgdG8gc2NoZWR1bGUgc2V2ZXJhbCBkaWZmZXJudCB0eXBlcyBvZiB3b3JrIHdoaWNoCisvKiBPQ0ZTMiBuZWVkcyB0byBzY2hlZHVsZSBzZXZlcmFsIGRpZmZlcmVudCB0eXBlcyBvZiB3b3JrIHdoaWNoCiAgKiByZXF1aXJlIGNsdXN0ZXIgbG9ja2luZywgZGlzayBJL08sIHJlY292ZXJ5IHdhaXRzLCBldGMuIFNpbmNlIHRoZXNlCiAgKiB0eXBlcyBvZiB3b3JrIHRlbmQgdG8gYmUgaGVhdnkgd2UgYXZvaWQgdXNpbmcgdGhlIGtlcm5lbCBldmVudHMKICAqIHdvcmtxdWV1ZSBhbmQgc2NoZWR1bGUgb24gb3VyIG93bi4gKi8KZGlmZiAtLWdpdCBhL2ZzL29jZnMyL3hhdHRyLmMgYi9mcy9vY2ZzMi94YXR0ci5jCmluZGV4IDU3YTIxNWQuLjgxZWNmOWMgMTAwNjQ0Ci0tLSBhL2ZzL29jZnMyL3hhdHRyLmMKKysrIGIvZnMvb2NmczIveGF0dHIuYwpAQCAtMzU1NCw3ICszNTU0LDcgQEAKIAlkb3duX3dyaXRlKCZPQ0ZTMl9JKGlub2RlKS0+aXBfeGF0dHJfc2VtKTsKIAkvKgogCSAqIFNjYW4gaW5vZGUgYW5kIGV4dGVybmFsIGJsb2NrIHRvIGZpbmQgdGhlIHNhbWUgbmFtZQotCSAqIGV4dGVuZGVkIGF0dHJpYnV0ZSBhbmQgY29sbGVjdCBzZWFyY2ggaW5mb21hdGlvbi4KKwkgKiBleHRlbmRlZCBhdHRyaWJ1dGUgYW5kIGNvbGxlY3Qgc2VhcmNoIGluZm9ybWF0aW9uLgogCSAqLwogCXJldCA9IG9jZnMyX3hhdHRyX2lib2R5X2ZpbmQoaW5vZGUsIG5hbWVfaW5kZXgsIG5hbWUsICZ4aXMpOwogCWlmIChyZXQpCkBAIC0zNTc4LDcgKzM1NzgsNyBAQAogCQkJZ290byBjbGVhbnVwOwogCX0KIAotCS8qIENoZWNrIHdoZXRoZXIgdGhlIHZhbHVlIGlzIHJlZmNvdW50ZWQgYW5kIGRvIHNvbWUgcHJlcGFydGlvbi4gKi8KKwkvKiBDaGVjayB3aGV0aGVyIHRoZSB2YWx1ZSBpcyByZWZjb3VudGVkIGFuZCBkbyBzb21lIHByZXBhcmF0aW9uLiAqLwogCWlmIChPQ0ZTMl9JKGlub2RlKS0+aXBfZHluX2ZlYXR1cmVzICYgT0NGUzJfSEFTX1JFRkNPVU5UX0ZMICYmCiAJICAgICgheGlzLm5vdF9mb3VuZCB8fCAheGJzLm5vdF9mb3VuZCkpIHsKIAkJcmV0ID0gb2NmczJfcHJlcGFyZV9yZWZjb3VudF94YXR0cihpbm9kZSwgZGksICZ4aSwKZGlmZiAtLWdpdCBhL2ZzL3BhcnRpdGlvbnMvY2hlY2suYyBiL2ZzL3BhcnRpdGlvbnMvY2hlY2suYwppbmRleCBhYzU0Njk3Li5kNTQ1ZTk3IDEwMDY0NAotLS0gYS9mcy9wYXJ0aXRpb25zL2NoZWNrLmMKKysrIGIvZnMvcGFydGl0aW9ucy9jaGVjay5jCkBAIC01MDAsNyArNTAwLDcgQEAKIAkvKiBldmVyeXRoaW5nIGlzIHVwIGFuZCBydW5uaW5nLCBjb21tZW5jZSAqLwogCXJjdV9hc3NpZ25fcG9pbnRlcihwdGJsLT5wYXJ0W3BhcnRub10sIHApOwogCi0JLyogc3VwcHJlc3MgdWV2ZW50IGlmIHRoZSBkaXNrIHN1cHJlc3NlcyBpdCAqLworCS8qIHN1cHByZXNzIHVldmVudCBpZiB0aGUgZGlzayBzdXBwcmVzc2VzIGl0ICovCiAJaWYgKCFkZXZfZ2V0X3VldmVudF9zdXBwcmVzcyhkZGV2KSkKIAkJa29iamVjdF91ZXZlbnQoJnBkZXYtPmtvYmosIEtPQkpfQUREKTsKIApAQCAtNTg1LDcgKzU4NSw3IEBACiAJLyoKIAkgKiBJZiBhbnkgcGFydGl0aW9uIGNvZGUgdHJpZWQgdG8gcmVhZCBiZXlvbmQgRU9ELCB0cnkKIAkgKiB1bmxvY2tpbmcgbmF0aXZlIGNhcGFjaXR5IGV2ZW4gaWYgcGFydGl0aW9uIHRhYmxlIGlzCi0JICogc3VjZXNzZnVsbHkgcmVhZCBhcyB3ZSBjb3VsZCBiZSBtaXNzaW5nIHNvbWUgcGFydGl0aW9ucy4KKwkgKiBzdWNjZXNzZnVsbHkgcmVhZCBhcyB3ZSBjb3VsZCBiZSBtaXNzaW5nIHNvbWUgcGFydGl0aW9ucy4KIAkgKi8KIAlpZiAoc3RhdGUtPmFjY2Vzc19iZXlvbmRfZW9kKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcKZGlmZiAtLWdpdCBhL2ZzL3Byb2MvYmFzZS5jIGIvZnMvcHJvYy9iYXNlLmMKaW5kZXggNWE2NzBjMS4uZGQ2NjI4ZCAxMDA2NDQKLS0tIGEvZnMvcHJvYy9iYXNlLmMKKysrIGIvZnMvcHJvYy9iYXNlLmMKQEAgLTIyMCw3ICsyMjAsNyBAQAogCX0KIAogCS8qCi0JICogTm9vbmUgZWxzZSBpcyBhbGxvd2VkLgorCSAqIE5vIG9uZSBlbHNlIGlzIGFsbG93ZWQuCiAJICovCiAJbW1wdXQobW0pOwogCXJldHVybiBFUlJfUFRSKC1FUEVSTSk7CmRpZmYgLS1naXQgYS9mcy9wc3RvcmUvS2NvbmZpZyBiL2ZzL3BzdG9yZS9LY29uZmlnCmluZGV4IDg2N2QwYWMuLjgwMDdhZTcgMTAwNjQ0Ci0tLSBhL2ZzL3BzdG9yZS9LY29uZmlnCisrKyBiL2ZzL3BzdG9yZS9LY29uZmlnCkBAIC0xLDUgKzEsNSBAQAogY29uZmlnIFBTVE9SRQotCWJvb2wgIlBlcnNpc3RhbnQgc3RvcmUgc3VwcG9ydCIKKwlib29sICJQZXJzaXN0ZW50IHN0b3JlIHN1cHBvcnQiCiAJZGVmYXVsdCBuCiAJaGVscAogCSAgIFRoaXMgb3B0aW9uIGVuYWJsZXMgZ2VuZXJpYyBhY2Nlc3MgdG8gcGxhdGZvcm0gbGV2ZWwKZGlmZiAtLWdpdCBhL2ZzL3F1b3RhL2RxdW90LmMgYi9mcy9xdW90YS9kcXVvdC5jCmluZGV4IGZjYzhhZTcuLmQzYzAzMmYgMTAwNjQ0Ci0tLSBhL2ZzL3F1b3RhL2RxdW90LmMKKysrIGIvZnMvcXVvdGEvZHF1b3QuYwpAQCAtNDQyLDcgKzQ0Miw3IEBACiAgKi8KIGludCBkcXVvdF9jb21taXQoc3RydWN0IGRxdW90ICpkcXVvdCkKIHsKLQlpbnQgcmV0ID0gMCwgcmV0MiA9IDA7CisJaW50IHJldCA9IDA7CiAJc3RydWN0IHF1b3RhX2luZm8gKmRxb3B0ID0gc2JfZHFvcHQoZHF1b3QtPmRxX3NiKTsKIAogCW11dGV4X2xvY2soJmRxb3B0LT5kcWlvX211dGV4KTsKQEAgLTQ1NCwxNSArNDU0LDEwIEBACiAJc3Bpbl91bmxvY2soJmRxX2xpc3RfbG9jayk7CiAJLyogSW5hY3RpdmUgZHF1b3QgY2FuIGJlIG9ubHkgaWYgdGhlcmUgd2FzIGVycm9yIGR1cmluZyByZWFkL2luaXQKIAkgKiA9PiB3ZSBoYXZlIGJldHRlciBub3Qgd3JpdGluZyBpdCAqLwotCWlmICh0ZXN0X2JpdChEUV9BQ1RJVkVfQiwgJmRxdW90LT5kcV9mbGFncykpIHsKKwlpZiAodGVzdF9iaXQoRFFfQUNUSVZFX0IsICZkcXVvdC0+ZHFfZmxhZ3MpKQogCQlyZXQgPSBkcW9wdC0+b3BzW2RxdW90LT5kcV90eXBlXS0+Y29tbWl0X2RxYmxrKGRxdW90KTsKLQkJaWYgKGluZm9fZGlydHkoJmRxb3B0LT5pbmZvW2RxdW90LT5kcV90eXBlXSkpIHsKLQkJCXJldDIgPSBkcW9wdC0+b3BzW2RxdW90LT5kcV90eXBlXS0+d3JpdGVfZmlsZV9pbmZvKAotCQkJCQkJZHF1b3QtPmRxX3NiLCBkcXVvdC0+ZHFfdHlwZSk7Ci0JCX0KLQkJaWYgKHJldCA+PSAwKQotCQkJcmV0ID0gcmV0MjsKLQl9CisJZWxzZQorCQlyZXQgPSAtRUlPOwogb3V0X3NlbToKIAltdXRleF91bmxvY2soJmRxb3B0LT5kcWlvX211dGV4KTsKIAlyZXR1cm4gcmV0OwpAQCAtOTU2LDcgKzk1MSw3IEBACiAKIC8qCiAgKiBSZW1vdmUgcmVmZXJlbmNlcyB0byBkcXVvdHMgZnJvbSBpbm9kZSBhbmQgYWRkIGRxdW90IHRvIGxpc3QgZm9yIGZyZWVpbmcKLSAqIGlmIHdlIGhhdmUgdGhlIGxhc3QgcmVmZXJlY2UgdG8gZHF1b3QKKyAqIGlmIHdlIGhhdmUgdGhlIGxhc3QgcmVmZXJlbmNlIHRvIGRxdW90CiAgKiBXZSBjYW4ndCByYWNlIHdpdGggYW55Ym9keSBiZWNhdXNlIHdlIGhvbGQgZHFwdHJfc2VtIGZvciB3cml0aW5nLi4uCiAgKi8KIHN0YXRpYyBpbnQgcmVtb3ZlX2lub2RlX2RxdW90X3JlZihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBpbnQgdHlwZSwKZGlmZiAtLWdpdCBhL2ZzL3JlaXNlcmZzL2pvdXJuYWwuYyBiL2ZzL3JlaXNlcmZzL2pvdXJuYWwuYwppbmRleCBjNzc1MTRiLi5jNWU4MmVjIDEwMDY0NAotLS0gYS9mcy9yZWlzZXJmcy9qb3VybmFsLmMKKysrIGIvZnMvcmVpc2VyZnMvam91cm5hbC5jCkBAIC0xLDcgKzEsNyBAQAogLyoKICoqIFdyaXRlIGFoZWFkIGxvZ2dpbmcgaW1wbGVtZW50YXRpb24gY29weXJpZ2h0IENocmlzIE1hc29uIDIwMDAKICoqCi0qKiBUaGUgYmFja2dyb3VuZCBjb21taXRzIG1ha2UgdGhpcyBjb2RlIHZlcnkgaW50ZXJlbGF0ZWQsIGFuZAorKiogVGhlIGJhY2tncm91bmQgY29tbWl0cyBtYWtlIHRoaXMgY29kZSB2ZXJ5IGludGVycmVsYXRlZCwgYW5kCiAqKiBvdmVybHkgY29tcGxleC4gIEkgbmVlZCB0byByZXRoaW5rIHRoaW5ncyBhIGJpdC4uLi5UaGUgbWFqb3IgcGxheWVyczoKICoqCiAqKiBqb3VybmFsX2JlZ2luIC0tIGNhbGwgd2l0aCB0aGUgbnVtYmVyIG9mIGJsb2NrcyB5b3UgZXhwZWN0IHRvIGxvZy4KQEAgLTI3MjUsNyArMjcyNSw3IEBACiAJCQkJCQkgUkVJU0VSRlNfRElTS19PRkZTRVRfSU5fQllURVMgLwogCQkJCQkJIHNiLT5zX2Jsb2Nrc2l6ZSArIDIpOwogCi0JLyogU2FuaXR5IGNoZWNrIHRvIHNlZSBpcyB0aGUgc3RhbmRhcmQgam91cm5hbCBmaXR0aW5nIHdpdGhpbmcgZmlyc3QgYml0bWFwCisJLyogU2FuaXR5IGNoZWNrIHRvIHNlZSBpcyB0aGUgc3RhbmRhcmQgam91cm5hbCBmaXR0aW5nIHdpdGhpbiBmaXJzdCBiaXRtYXAKIAkgICAoYWN0dWFsIGZvciBzbWFsbCBibG9ja3NpemVzKSAqLwogCWlmICghU0JfT05ESVNLX0pPVVJOQUxfREVWSUNFKHNiKSAmJgogCSAgICAoU0JfSk9VUk5BTF8xc3RfUkVTRVJWRURfQkxPQ0soc2IpICsKZGlmZiAtLWdpdCBhL2ZzL3JlaXNlcmZzL2xvY2suYyBiL2ZzL3JlaXNlcmZzL2xvY2suYwppbmRleCBiODdhYTJjLi43ZGYxY2U0IDEwMDY0NAotLS0gYS9mcy9yZWlzZXJmcy9sb2NrLmMKKysrIGIvZnMvcmVpc2VyZnMvbG9jay5jCkBAIC0xNSw3ICsxNSw3IEBACiAgKiBmb3IgdGhpcyBtdXRleCwgbm8gbmVlZCBmb3IgYSBzeXN0ZW0gd2lkZSBtdXRleCBmYWNpbGl0eS4KICAqCiAgKiBBbHNvIHRoaXMgbG9jayBpcyBvZnRlbiByZWxlYXNlZCBiZWZvcmUgYSBjYWxsIHRoYXQgY291bGQgYmxvY2sgYmVjYXVzZQotICogcmVpc2VyZnMgcGVyZm9ybWFuY2VzIHdlcmUgcGFydGlhbHkgYmFzZWQgb24gdGhlIHJlbGVhc2Ugd2hpbGUgc2NoZWR1bGUoKQorICogcmVpc2VyZnMgcGVyZm9ybWFuY2VzIHdlcmUgcGFydGlhbGx5IGJhc2VkIG9uIHRoZSByZWxlYXNlIHdoaWxlIHNjaGVkdWxlKCkKICAqIHByb3BlcnR5IG9mIHRoZSBCa2wuCiAgKi8KIHZvaWQgcmVpc2VyZnNfd3JpdGVfbG9jayhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMpCmRpZmYgLS1naXQgYS9mcy9yZWlzZXJmcy9zdXBlci5jIGIvZnMvcmVpc2VyZnMvc3VwZXIuYwppbmRleCAwYWFiMDRmLi5iMjE2ZmY2IDEwMDY0NAotLS0gYS9mcy9yZWlzZXJmcy9zdXBlci5jCisrKyBiL2ZzL3JlaXNlcmZzL3N1cGVyLmMKQEAgLTM5Myw3ICszOTMsNyBAQAogCS8qIGJvZHkgb2YgInNhdmUiIGxpbmsgKi8KIAlsaW5rID0gSU5PREVfUEtFWShpbm9kZSktPmtfZGlyX2lkOwogCi0JLyogcHV0ICJzYXZlIiBsaW5rIGlub3QgdHJlZSwgZG9uJ3QgY2hhcmdlIHF1b3RhIHRvIGFueW9uZSAqLworCS8qIHB1dCAic2F2ZSIgbGluayBpbnRvIHRyZWUsIGRvbid0IGNoYXJnZSBxdW90YSB0byBhbnlvbmUgKi8KIAlyZXR2YWwgPQogCSAgICByZWlzZXJmc19pbnNlcnRfaXRlbSh0aCwgJnBhdGgsICZrZXksICZpaCwgTlVMTCwgKGNoYXIgKikmbGluayk7CiAJaWYgKHJldHZhbCkgewpAQCAtMjEwNCw3ICsyMTA0LDcgQEAKIAogLyogUmVhZCBkYXRhIGZyb20gcXVvdGFmaWxlIC0gYXZvaWQgcGFnZWNhY2hlIGFuZCBzdWNoIGJlY2F1c2Ugd2UgY2Fubm90IGFmZm9yZAogICogYWNxdWlyaW5nIHRoZSBsb2Nrcy4uLiBBcyBxdW90YSBmaWxlcyBhcmUgbmV2ZXIgdHJ1bmNhdGVkIGFuZCBxdW90YSBjb2RlCi0gKiBpdHNlbGYgc2VyaWFsaXplcyB0aGUgb3BlcmF0aW9ucyAoYW5kIG5vb25lIGVsc2Ugc2hvdWxkIHRvdWNoIHRoZSBmaWxlcykKKyAqIGl0c2VsZiBzZXJpYWxpemVzIHRoZSBvcGVyYXRpb25zIChhbmQgbm8gb25lIGVsc2Ugc2hvdWxkIHRvdWNoIHRoZSBmaWxlcykKICAqIHdlIGRvbid0IGhhdmUgdG8gYmUgYWZyYWlkIG9mIHJhY2VzICovCiBzdGF0aWMgc3NpemVfdCByZWlzZXJmc19xdW90YV9yZWFkKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBjaGFyICpkYXRhLAogCQkJCSAgIHNpemVfdCBsZW4sIGxvZmZfdCBvZmYpCmRpZmYgLS1naXQgYS9mcy9yZWlzZXJmcy94YXR0ci5jIGIvZnMvcmVpc2VyZnMveGF0dHIuYwppbmRleCA1YzExY2E4Li40N2QyYTQ0IDEwMDY0NAotLS0gYS9mcy9yZWlzZXJmcy94YXR0ci5jCisrKyBiL2ZzL3JlaXNlcmZzL3hhdHRyLmMKQEAgLTM5Niw3ICszOTYsNyBAQAogCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nID0gZGlyLT5pX21hcHBpbmc7CiAJc3RydWN0IHBhZ2UgKnBhZ2U7CiAJLyogV2UgY2FuIGRlYWRsb2NrIGlmIHdlIHRyeSB0byBmcmVlIGRlbnRyaWVzLAotCSAgIGFuZCBhbiB1bmxpbmsvcm1kaXIgaGFzIGp1c3Qgb2NjdXJlZCAtIEdGUF9OT0ZTIGF2b2lkcyB0aGlzICovCisJICAgYW5kIGFuIHVubGluay9ybWRpciBoYXMganVzdCBvY2N1cnJlZCAtIEdGUF9OT0ZTIGF2b2lkcyB0aGlzICovCiAJbWFwcGluZ19zZXRfZ2ZwX21hc2sobWFwcGluZywgR0ZQX05PRlMpOwogCXBhZ2UgPSByZWFkX21hcHBpbmdfcGFnZShtYXBwaW5nLCBuID4+IFBBR0VfQ0FDSEVfU0hJRlQsIE5VTEwpOwogCWlmICghSVNfRVJSKHBhZ2UpKSB7CmRpZmYgLS1naXQgYS9mcy9zcXVhc2hmcy9jYWNoZS5jIGIvZnMvc3F1YXNoZnMvY2FjaGUuYwppbmRleCAyNmIxNWFlLi5jMzdiNTIwIDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9jYWNoZS5jCisrKyBiL2ZzL3NxdWFzaGZzL2NhY2hlLmMKQEAgLTEwNCw3ICsxMDQsNyBAQAogCQkJZW50cnkgPSAmY2FjaGUtPmVudHJ5W2ldOwogCiAJCQkvKgotCQkJICogSW5pdGlhbGlzZSBjaG9vc2VuIGNhY2hlIGVudHJ5LCBhbmQgZmlsbCBpdCBpbiBmcm9tCisJCQkgKiBJbml0aWFsaXNlIGNob3NlbiBjYWNoZSBlbnRyeSwgYW5kIGZpbGwgaXQgaW4gZnJvbQogCQkJICogZGlzay4KIAkJCSAqLwogCQkJY2FjaGUtPnVudXNlZC0tOwpAQCAtMjg2LDcgKzI4Niw3IEBACiAKIAogLyoKLSAqIENvcHkgdXB0byBsZW5ndGggYnl0ZXMgZnJvbSBjYWNoZSBlbnRyeSB0byBidWZmZXIgc3RhcnRpbmcgYXQgb2Zmc2V0IGJ5dGVzCisgKiBDb3B5IHVwIHRvIGxlbmd0aCBieXRlcyBmcm9tIGNhY2hlIGVudHJ5IHRvIGJ1ZmZlciBzdGFydGluZyBhdCBvZmZzZXQgYnl0ZXMKICAqIGludG8gdGhlIGNhY2hlIGVudHJ5LiAgSWYgdGhlcmUncyBub3QgbGVuZ3RoIGJ5dGVzIHRoZW4gY29weSB0aGUgbnVtYmVyIG9mCiAgKiBieXRlcyBhdmFpbGFibGUuICBJbiBhbGwgY2FzZXMgcmV0dXJuIHRoZSBudW1iZXIgb2YgYnl0ZXMgY29waWVkLgogICovCmRpZmYgLS1naXQgYS9mcy91Ymlmcy9LY29uZmlnIGIvZnMvdWJpZnMvS2NvbmZpZwppbmRleCBkNzQ0MDkwLi5mOGIwMTYwIDEwMDY0NAotLS0gYS9mcy91Ymlmcy9LY29uZmlnCisrKyBiL2ZzL3ViaWZzL0tjb25maWcKQEAgLTQ3LDcgKzQ3LDcgQEAKIAlib29sICJFbmFibGUgZGVidWdnaW5nIHN1cHBvcnQiCiAJZGVwZW5kcyBvbiBVQklGU19GUwogCXNlbGVjdCBERUJVR19GUwotCXNlbGVjdCBLQUxMU1lNU19BTEwKKwlzZWxlY3QgS0FMTFNZTVMKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBlbmFibGVzIFVCSUZTIGRlYnVnZ2luZyBzdXBwb3J0LiBJdCBtYWtlcyBzdXJlIHZhcmlvdXMKIAkgIGFzc2VydGlvbnMsIHNlbGYtY2hlY2tzLCBkZWJ1Z2dpbmcgbWVzc2FnZXMgYW5kIHRlc3QgbW9kZXMgYXJlIGNvbXBpbGVkCmRpZmYgLS1naXQgYS9mcy91Ymlmcy9idWRnZXQuYyBiL2ZzL3ViaWZzL2J1ZGdldC5jCmluZGV4IGM4ZmYwZDEuLjhiM2E3ZGEgMTAwNjQ0Ci0tLSBhL2ZzL3ViaWZzL2J1ZGdldC5jCisrKyBiL2ZzL3ViaWZzL2J1ZGdldC5jCkBAIC0xNDcsNyArMTQ3LDcgQEAKIAkJaWYgKGxpYWIyIDwgbGlhYjEpCiAJCQlyZXR1cm4gLUVBR0FJTjsKIAotCQlkYmdfYnVkZygibmV3IGxpYWJpbGl0eSAlbGxkIChub3Qgc2hyaW5rZWQpIiwgbGlhYjIpOworCQlkYmdfYnVkZygibmV3IGxpYWJpbGl0eSAlbGxkIChub3Qgc2hydW5rKSIsIGxpYWIyKTsKIAogCQkvKiBMaWFiaWxpdHkgZGlkIG5vdCBzaHJpbmsgYWdhaW4sIHRyeSBHQyAqLwogCQlkYmdfYnVkZygiUnVuIEdDIik7CmRpZmYgLS1naXQgYS9mcy91Ymlmcy9jb21taXQuYyBiL2ZzL3ViaWZzL2NvbW1pdC5jCmluZGV4IGIxNDhmYmMuLjFiZDAxZGUgMTAwNjQ0Ci0tLSBhL2ZzL3ViaWZzL2NvbW1pdC5jCisrKyBiL2ZzL3ViaWZzL2NvbW1pdC5jCkBAIC01NzcsNyArNTc3LDcgQEAKIAlzaXplX3Qgc3o7CiAKIAlpZiAoISh1Ymlmc19jaGtfZmxhZ3MgJiBVQklGU19DSEtfT0xEX0lEWCkpCi0JCWdvdG8gb3V0OworCQlyZXR1cm4gMDsKIAogCUlOSVRfTElTVF9IRUFEKCZsaXN0KTsKIApkaWZmIC0tZ2l0IGEvZnMvdWJpZnMvZGVidWcuYyBiL2ZzL3ViaWZzL2RlYnVnLmMKaW5kZXggZjI1YTczMy4uMDA0ZDM3NCAxMDA2NDQKLS0tIGEvZnMvdWJpZnMvZGVidWcuYworKysgYi9mcy91Ymlmcy9kZWJ1Zy5jCkBAIC05NzIsMTEgKzk3MiwzOSBAQAogdm9pZCBkYmdfc2F2ZV9zcGFjZV9pbmZvKHN0cnVjdCB1Ymlmc19pbmZvICpjKQogewogCXN0cnVjdCB1Ymlmc19kZWJ1Z19pbmZvICpkID0gYy0+ZGJnOwotCi0JdWJpZnNfZ2V0X2xwX3N0YXRzKGMsICZkLT5zYXZlZF9sc3QpOworCWludCBmcmVlYWJsZV9jbnQ7CiAKIAlzcGluX2xvY2soJmMtPnNwYWNlX2xvY2spOworCW1lbWNweSgmZC0+c2F2ZWRfbHN0LCAmYy0+bHN0LCBzaXplb2Yoc3RydWN0IHViaWZzX2xwX3N0YXRzKSk7CisKKwkvKgorCSAqIFdlIHVzZSBhIGRpcnR5IGhhY2sgaGVyZSBhbmQgemVybyBvdXQgQGMtPmZyZWVhYmxlX2NudCwgYmVjYXVzZSBpdAorCSAqIGFmZmVjdHMgdGhlIGZyZWUgc3BhY2UgY2FsY3VsYXRpb25zLCBhbmQgVUJJRlMgbWlnaHQgbm90IGtub3cgYWJvdXQKKwkgKiBhbGwgZnJlZWFibGUgZXJhc2VibG9ja3MuIEluZGVlZCwgd2Uga25vdyBhYm91dCBmcmVlYWJsZSBlcmFzZWJsb2NrcworCSAqIG9ubHkgd2hlbiB3ZSByZWFkIHRoZWlyIGxwcm9wcywgYW5kIHdlIGRvIHRoaXMgb25seSBsYXppbHksIHVwb24gdGhlCisJICogbmVlZC4gU28gYXQgYW55IGdpdmVuIHBvaW50IG9mIHRpbWUgQGMtPmZyZWVhYmxlX2NudCBtaWdodCBiZSBub3QKKwkgKiBleGFjdGx5IGFjY3VyYXRlLgorCSAqCisJICogSnVzdCBvbmUgZXhhbXBsZSBhYm91dCB0aGUgaXNzdWUgd2UgaGl0IHdoZW4gd2UgZGlkIG5vdCB6ZXJvCisJICogQGMtPmZyZWVhYmxlX2NudC4KKwkgKiAxLiBUaGUgZmlsZS1zeXN0ZW0gaXMgbW91bnRlZCBSL08sIGMtPmZyZWVhYmxlX2NudCBpcyAlMC4gV2Ugc2F2ZSB0aGUKKwkgKiAgICBhbW91bnQgb2YgZnJlZSBzcGFjZSBpbiBAZC0+c2F2ZWRfZnJlZQorCSAqIDIuIFdlIHJlLW1vdW50IFIvVywgd2hpY2ggbWFrZXMgVUJJRlMgdG8gcmVhZCB0aGUgImxzYXZlIgorCSAqICAgIGluZm9ybWF0aW9uIGZyb20gZmxhc2gsIHdoZXJlIHdlIGNhY2hlIExFQnMgZnJvbSB2YXJpb3VzCisJICogICAgY2F0ZWdvcmllcyAoJ3ViaWZzX3JlbW91bnRfZnMoKScgLT4gJ3ViaWZzX2xwdF9pbml0KCknCisJICogICAgLT4gJ2xwdF9pbml0X3dyKCknIC0+ICdyZWFkX2xzYXZlKCknIC0+ICd1Ymlmc19scHRfbG9va3VwKCknCisJICogICAgLT4gJ3ViaWZzX2dldF9wbm9kZSgpJyAtPiAndXBkYXRlX2NhdHMoKScKKwkgKiAgICAtPiAndWJpZnNfYWRkX3RvX2NhdCgpJykuCisJICogMy4gTHNhdmUgY29udGFpbnMgYSBmcmVlYWJsZSBlcmFzZWJsb2NrLCBhbmQgQGMtPmZyZWVhYmxlX2NudAorCSAqICAgIGJlY29tZXMgJTEuCisJICogNC4gV2UgY2FsY3VsYXRlIHRoZSBhbW91bnQgb2YgZnJlZSBzcGFjZSB3aGVuIHRoZSByZS1tb3VudCBpcworCSAqICAgIGZpbmlzaGVkIGluICdkYmdfY2hlY2tfc3BhY2VfaW5mbygpJyBhbmQgaXQgZG9lcyBub3QgbWF0Y2gKKwkgKiAgICBAZC0+c2F2ZWRfZnJlZS4KKwkgKi8KKwlmcmVlYWJsZV9jbnQgPSBjLT5mcmVlYWJsZV9jbnQ7CisJYy0+ZnJlZWFibGVfY250ID0gMDsKIAlkLT5zYXZlZF9mcmVlID0gdWJpZnNfZ2V0X2ZyZWVfc3BhY2Vfbm9sb2NrKGMpOworCWMtPmZyZWVhYmxlX2NudCA9IGZyZWVhYmxlX2NudDsKIAlzcGluX3VubG9jaygmYy0+c3BhY2VfbG9jayk7CiB9CiAKQEAgLTk5MywxMiArMTAyMSwxNSBAQAogewogCXN0cnVjdCB1Ymlmc19kZWJ1Z19pbmZvICpkID0gYy0+ZGJnOwogCXN0cnVjdCB1Ymlmc19scF9zdGF0cyBsc3Q7Ci0JbG9uZyBsb25nIGF2YWlsLCBmcmVlOworCWxvbmcgbG9uZyBmcmVlOworCWludCBmcmVlYWJsZV9jbnQ7CiAKIAlzcGluX2xvY2soJmMtPnNwYWNlX2xvY2spOwotCWF2YWlsID0gdWJpZnNfY2FsY19hdmFpbGFibGUoYywgYy0+bWluX2lkeF9sZWJzKTsKKwlmcmVlYWJsZV9jbnQgPSBjLT5mcmVlYWJsZV9jbnQ7CisJYy0+ZnJlZWFibGVfY250ID0gMDsKKwlmcmVlID0gdWJpZnNfZ2V0X2ZyZWVfc3BhY2Vfbm9sb2NrKGMpOworCWMtPmZyZWVhYmxlX2NudCA9IGZyZWVhYmxlX2NudDsKIAlzcGluX3VubG9jaygmYy0+c3BhY2VfbG9jayk7Ci0JZnJlZSA9IHViaWZzX2dldF9mcmVlX3NwYWNlKGMpOwogCiAJaWYgKGZyZWUgIT0gZC0+c2F2ZWRfZnJlZSkgewogCQl1Ymlmc19lcnIoImZyZWUgc3BhY2UgY2hhbmdlZCBmcm9tICVsbGQgdG8gJWxsZCIsCkBAIC0yODA2LDQwICsyODM3LDM4IEBACiAJc3RydWN0IHViaWZzX2RlYnVnX2luZm8gKmQgPSBjLT5kYmc7CiAKIAlzcHJpbnRmKGQtPmRmc19kaXJfbmFtZSwgInViaSVkXyVkIiwgYy0+dmkudWJpX251bSwgYy0+dmkudm9sX2lkKTsKLQlkLT5kZnNfZGlyID0gZGVidWdmc19jcmVhdGVfZGlyKGQtPmRmc19kaXJfbmFtZSwgZGZzX3Jvb3RkaXIpOwotCWlmIChJU19FUlIoZC0+ZGZzX2RpcikpIHsKLQkJZXJyID0gUFRSX0VSUihkLT5kZnNfZGlyKTsKLQkJdWJpZnNfZXJyKCJjYW5ub3QgY3JlYXRlIFwiJXNcIiBkZWJ1Z2ZzIGRpcmVjdG9yeSwgZXJyb3IgJWRcbiIsCi0JCQkgIGQtPmRmc19kaXJfbmFtZSwgZXJyKTsKKwlmbmFtZSA9IGQtPmRmc19kaXJfbmFtZTsKKwlkZW50ID0gZGVidWdmc19jcmVhdGVfZGlyKGZuYW1lLCBkZnNfcm9vdGRpcik7CisJaWYgKElTX0VSUl9PUl9OVUxMKGRlbnQpKQogCQlnb3RvIG91dDsKLQl9CisJZC0+ZGZzX2RpciA9IGRlbnQ7CiAKIAlmbmFtZSA9ICJkdW1wX2xwcm9wcyI7CiAJZGVudCA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoZm5hbWUsIFNfSVdVU1IsIGQtPmRmc19kaXIsIGMsICZkZnNfZm9wcyk7Ci0JaWYgKElTX0VSUihkZW50KSkKKwlpZiAoSVNfRVJSX09SX05VTEwoZGVudCkpCiAJCWdvdG8gb3V0X3JlbW92ZTsKIAlkLT5kZnNfZHVtcF9scHJvcHMgPSBkZW50OwogCiAJZm5hbWUgPSAiZHVtcF9idWRnIjsKIAlkZW50ID0gZGVidWdmc19jcmVhdGVfZmlsZShmbmFtZSwgU19JV1VTUiwgZC0+ZGZzX2RpciwgYywgJmRmc19mb3BzKTsKLQlpZiAoSVNfRVJSKGRlbnQpKQorCWlmIChJU19FUlJfT1JfTlVMTChkZW50KSkKIAkJZ290byBvdXRfcmVtb3ZlOwogCWQtPmRmc19kdW1wX2J1ZGcgPSBkZW50OwogCiAJZm5hbWUgPSAiZHVtcF90bmMiOwogCWRlbnQgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKGZuYW1lLCBTX0lXVVNSLCBkLT5kZnNfZGlyLCBjLCAmZGZzX2ZvcHMpOwotCWlmIChJU19FUlIoZGVudCkpCisJaWYgKElTX0VSUl9PUl9OVUxMKGRlbnQpKQogCQlnb3RvIG91dF9yZW1vdmU7CiAJZC0+ZGZzX2R1bXBfdG5jID0gZGVudDsKIAogCXJldHVybiAwOwogCiBvdXRfcmVtb3ZlOgotCWVyciA9IFBUUl9FUlIoZGVudCk7Ci0JdWJpZnNfZXJyKCJjYW5ub3QgY3JlYXRlIFwiJXNcIiBkZWJ1Z2ZzIGRpcmVjdG9yeSwgZXJyb3IgJWRcbiIsCi0JCSAgZm5hbWUsIGVycik7CiAJZGVidWdmc19yZW1vdmVfcmVjdXJzaXZlKGQtPmRmc19kaXIpOwogb3V0OgorCWVyciA9IGRlbnQgPyBQVFJfRVJSKGRlbnQpIDogLUVOT0RFVjsKKwl1Ymlmc19lcnIoImNhbm5vdCBjcmVhdGUgXCIlc1wiIGRlYnVnZnMgZGlyZWN0b3J5LCBlcnJvciAlZFxuIiwKKwkJICBmbmFtZSwgZXJyKTsKIAlyZXR1cm4gZXJyOwogfQogCmRpZmYgLS1naXQgYS9mcy91Ymlmcy9scHQuYyBiL2ZzL3ViaWZzL2xwdC5jCmluZGV4IDcyNzc1ZDMuLmVmNTE1NWUgMTAwNjQ0Ci0tLSBhL2ZzL3ViaWZzL2xwdC5jCisrKyBiL2ZzL3ViaWZzL2xwdC5jCkBAIC0xMjcwLDEwICsxMjcwLDkgQEAKIAlsbnVtID0gYnJhbmNoLT5sbnVtOwogCW9mZnMgPSBicmFuY2gtPm9mZnM7CiAJcG5vZGUgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgdWJpZnNfcG5vZGUpLCBHRlBfTk9GUyk7Ci0JaWYgKCFwbm9kZSkgewotCQllcnIgPSAtRU5PTUVNOwotCQlnb3RvIG91dDsKLQl9CisJaWYgKCFwbm9kZSkKKwkJcmV0dXJuIC1FTk9NRU07CisKIAlpZiAobG51bSA9PSAwKSB7CiAJCS8qCiAJCSAqIFRoaXMgcG5vZGUgd2FzIG5vdCB3cml0dGVuIHdoaWNoIGp1c3QgbWVhbnMgdGhhdCB0aGUgTEVCCmRpZmYgLS1naXQgYS9mcy91Ymlmcy9zdXBlci5jIGIvZnMvdWJpZnMvc3VwZXIuYwppbmRleCA2ZGRkOTk3Li5jNzVmNjEzIDEwMDY0NAotLS0gYS9mcy91Ymlmcy9zdXBlci5jCisrKyBiL2ZzL3ViaWZzL3N1cGVyLmMKQEAgLTE1NjgsNiArMTU2OCw3IEBACiAJbXV0ZXhfbG9jaygmYy0+dW1vdW50X211dGV4KTsKIAlkYmdfc2F2ZV9zcGFjZV9pbmZvKGMpOwogCWMtPnJlbW91bnRpbmdfcncgPSAxOworCWMtPnJvX21vdW50ID0gMDsKIAogCWVyciA9IGNoZWNrX2ZyZWVfc3BhY2UoYyk7CiAJaWYgKGVycikKQEAgLTE2NzYsMTMgKzE2NzcsMTMgQEAKIAl9CiAKIAlkYmdfZ2VuKCJyZS1tb3VudGVkIHJlYWQtd3JpdGUiKTsKLQljLT5yb19tb3VudCA9IDA7CiAJYy0+cmVtb3VudGluZ19ydyA9IDA7CiAJZXJyID0gZGJnX2NoZWNrX3NwYWNlX2luZm8oYyk7CiAJbXV0ZXhfdW5sb2NrKCZjLT51bW91bnRfbXV0ZXgpOwogCXJldHVybiBlcnI7CiAKIG91dDoKKwljLT5yb19tb3VudCA9IDE7CiAJdmZyZWUoYy0+b3JwaF9idWYpOwogCWMtPm9ycGhfYnVmID0gTlVMTDsKIAlpZiAoYy0+Ymd0KSB7CmRpZmYgLS1naXQgYS9mcy91ZnMvaW5vZGUuYyBiL2ZzL3Vmcy9pbm9kZS5jCmluZGV4IDI3YTRiYWIuLmU3NjU3NDMgMTAwNjQ0Ci0tLSBhL2ZzL3Vmcy9pbm9kZS5jCisrKyBiL2ZzL3Vmcy9pbm9kZS5jCkBAIC03OCw3ICs3OCw3IEBACiAKIC8qCiAgKiBSZXR1cm5zIHRoZSBsb2NhdGlvbiBvZiB0aGUgZnJhZ21lbnQgZnJvbQotICogdGhlIGJlZ2luaW5nIG9mIHRoZSBmaWxlc3lzdGVtLgorICogdGhlIGJlZ2lubmluZyBvZiB0aGUgZmlsZXN5c3RlbS4KICAqLwogCiBzdGF0aWMgdTY0IHVmc19mcmFnX21hcChzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzZWN0b3JfdCBmcmFnLCBib29sIG5lZWRzX2xvY2spCmRpZmYgLS1naXQgYS9mcy91ZnMvc3VwZXIuYyBiL2ZzL3Vmcy9zdXBlci5jCmluZGV4IDc2OTNkNjIuLjM5MTVhZGUgMTAwNjQ0Ci0tLSBhL2ZzL3Vmcy9zdXBlci5jCisrKyBiL2ZzL3Vmcy9zdXBlci5jCkBAIC00ODMsOSArNDgzLDkgQEAKIH0KIAogLyoKLSAqIERpZmZyZW50IHR5cGVzIG9mIFVGUyBob2xkIGZzX2NzdG90YWwgaW4gZGlmZmVyZW50Ci0gKiBwbGFjZXMsIGFuZCB1c2UgZGlmZnJlbnQgZGF0YSBzdHJ1Y3R1cmUgZm9yIGl0LgotICogVG8gbWFrZSB0aGluZ3Mgc2ltcGxpZXIgd2UganVzdCBjb3B5IGZzX2NzdG90YWwgdG8gdWZzX3NiX3ByaXZhdGVfaW5mbworICogRGlmZmVyZW50IHR5cGVzIG9mIFVGUyBob2xkIGZzX2NzdG90YWwgaW4gZGlmZmVyZW50CisgKiBwbGFjZXMsIGFuZCB1c2UgZGlmZmVyZW50IGRhdGEgc3RydWN0dXJlIGZvciBpdC4KKyAqIFRvIG1ha2UgdGhpbmdzIHNpbXBsZXIgd2UganVzdCBjb3B5IGZzX2NzdG90YWwgdG8gdWZzX3NiX3ByaXZhdGVfaW5mbwogICovCiBzdGF0aWMgdm9pZCB1ZnNfc2V0dXBfY3N0b3RhbChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQogewpkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfYW9wcy5jIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfYW9wcy5jCmluZGV4IDUyZGJkMTQuLjc5Y2UzOGIgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2FvcHMuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19hb3BzLmMKQEAgLTEyOTUsNyArMTI5NSw3IEBACiAgKiBJZiB0aGUgcHJpdmF0ZSBhcmd1bWVudCBpcyBub24tTlVMTCBfX3hmc19nZXRfYmxvY2tzIHNpZ25hbHMgdXMgdGhhdCB3ZQogICogbmVlZCB0byBpc3N1ZSBhIHRyYW5zYWN0aW9uIHRvIGNvbnZlcnQgdGhlIHJhbmdlIGZyb20gdW53cml0dGVuIHRvIHdyaXR0ZW4KICAqIGV4dGVudHMuICBJbiBjYXNlIHRoaXMgaXMgcmVndWxhciBzeW5jaHJvbm91cyBJL08gd2UganVzdCBjYWxsIHhmc19lbmRfaW8KLSAqIHRvIGRvIHRoaXMgYW5kIHdlIGFyZSBkb25lLiAgQnV0IGluIGNhc2UgdGhpcyB3YXMgYSBzdWNjZXNzZnVsbCBBSU8KKyAqIHRvIGRvIHRoaXMgYW5kIHdlIGFyZSBkb25lLiAgQnV0IGluIGNhc2UgdGhpcyB3YXMgYSBzdWNjZXNzZnVsIEFJTwogICogcmVxdWVzdCB0aGlzIGhhbmRsZXIgaXMgY2FsbGVkIGZyb20gaW50ZXJydXB0IGNvbnRleHQsIGZyb20gd2hpY2ggd2UKICAqIGNhbid0IHN0YXJ0IHRyYW5zYWN0aW9ucy4gIEluIHRoYXQgY2FzZSBvZmZsb2FkIHRoZSBJL08gY29tcGxldGlvbiB0bwogICogdGhlIHdvcmtxdWV1ZXMgd2UgYWxzbyB1c2UgZm9yIGJ1ZmZlcmVkIEkvTyBjb21wbGV0aW9uLgpkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfYnVmLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19idWYuYwppbmRleCA1OTZiYjJjLi41ZWE0MDIwIDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19idWYuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19idWYuYwpAQCAtMTIwLDcgKzEyMCw3IEBACiAgKiBUaGUgdW5sb2NrZWQgY2hlY2sgaXMgc2FmZSBoZXJlIGJlY2F1c2UgaXQgb25seSBvY2N1cnMgd2hlbiB0aGVyZSBhcmUgbm90CiAgKiBiX2xydV9yZWYgY291bnRzIGxlZnQgb24gdGhlIGlub2RlIHVuZGVyIHRoZSBwYWctPnBhZ19idWZfbG9jay4gaXQgaXMgdGhlcmUKICAqIHRvIG9wdGltaXNlIHRoZSBzaHJpbmtlciByZW1vdmluZyB0aGUgYnVmZmVyIGZyb20gdGhlIExSVSBhbmQgY2FsbGluZwotICogeGZzX2J1Zl9mcmVlKCkuIGkuZS4gaXQgcmVtb3ZlcyBhbiB1bm5lY2Nlc3Nhcnkgcm91bmQgdHJpcCBvbiB0aGUKKyAqIHhmc19idWZfZnJlZSgpLiBpLmUuIGl0IHJlbW92ZXMgYW4gdW5uZWNlc3Nhcnkgcm91bmQgdHJpcCBvbiB0aGUKICAqIGJ0X2xydV9sb2NrLgogICovCiBTVEFUSUMgdm9pZApAQCAtMzgwLDcgKzM4MCw3IEBACiB9CiAKIC8qCi0gKglNYXAgYnVmZmVyIGludG8ga2VybmVsIGFkZHJlc3Mtc3BhY2UgaWYgbmVzc2VjYXJ5LgorICoJTWFwIGJ1ZmZlciBpbnRvIGtlcm5lbCBhZGRyZXNzLXNwYWNlIGlmIG5lY2Vzc2FyeS4KICAqLwogU1RBVElDIGludAogX3hmc19idWZfbWFwX3BhZ2VzKApkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfZmlsZS5jIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfZmlsZS5jCmluZGV4IDUyYWFkZmIuLmY0MjEzYmEgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2ZpbGUuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19maWxlLmMKQEAgLTM4MSw3ICszODEsNyBAQAogCiAvKgogICogSWYgdGhpcyB3YXMgYSBkaXJlY3Qgb3Igc3luY2hyb25vdXMgSS9PIHRoYXQgZmFpbGVkIChzdWNoIGFzIEVOT1NQQykgdGhlbgotICogcGFydCBvZiB0aGUgSS9PIG1heSBoYXZlIGJlZW4gd3JpdHRlbiB0byBkaXNrIGJlZm9yZSB0aGUgZXJyb3Igb2NjdXJlZC4gIEluCisgKiBwYXJ0IG9mIHRoZSBJL08gbWF5IGhhdmUgYmVlbiB3cml0dGVuIHRvIGRpc2sgYmVmb3JlIHRoZSBlcnJvciBvY2N1cnJlZC4gIEluCiAgKiB0aGlzIGNhc2UgdGhlIG9uLWRpc2sgZmlsZSBzaXplIG1heSBoYXZlIGJlZW4gYWRqdXN0ZWQgYmV5b25kIHRoZSBpbi1tZW1vcnkKICAqIGZpbGUgc2l6ZSBhbmQgbm93IG5lZWRzIHRvIGJlIHRydW5jYXRlZCBiYWNrLgogICovCmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19pb3BzLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19pb3BzLmMKaW5kZXggOWZmN2ZjNi4uZGQyMTc4NCAxMDA2NDQKLS0tIGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfaW9wcy5jCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2lvcHMuYwpAQCAtNzAsNyArNzAsNyBAQAogCiAvKgogICogSWYgdGhlIGxpbnV4IGlub2RlIGlzIHZhbGlkLCBtYXJrIGl0IGRpcnR5LgotICogVXNlZCB3aGVuIGNvbW1pdGluZyBhIGRpcnR5IGlub2RlIGludG8gYSB0cmFuc2FjdGlvbiBzbyB0aGF0CisgKiBVc2VkIHdoZW4gY29tbWl0dGluZyBhIGRpcnR5IGlub2RlIGludG8gYSB0cmFuc2FjdGlvbiBzbyB0aGF0CiAgKiB0aGUgaW5vZGUgd2lsbCBnZXQgd3JpdHRlbiBiYWNrIGJ5IHRoZSBsaW51eCBjb2RlCiAgKi8KIHZvaWQKZGlmZiAtLWdpdCBhL2ZzL3hmcy9saW51eC0yLjYveGZzX3N5bmMuYyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX3N5bmMuYwppbmRleCA1OTRjZDgyLi45Y2YzNWE2IDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19zeW5jLmMKKysrIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3luYy5jCkBAIC00MDEsNyArNDAxLDcgQEAKIC8qCiAgKiBTZWNvbmQgc3RhZ2Ugb2YgYSBxdWllc2NlLiBUaGUgZGF0YSBpcyBhbHJlYWR5IHN5bmNlZCwgbm93IHdlIGhhdmUgdG8gdGFrZQogICogY2FyZSBvZiB0aGUgbWV0YWRhdGEuIE5ldyB0cmFuc2FjdGlvbnMgYXJlIGFscmVhZHkgYmxvY2tlZCwgc28gd2UgbmVlZCB0bwotICogd2FpdCBmb3IgYW55IHJlbWFpbmluZyB0cmFuc2FjdGlvbnMgdG8gZHJhaW4gb3V0IGJlZm9yZSBwcm9jZWRpbmcuCisgKiB3YWl0IGZvciBhbnkgcmVtYWluaW5nIHRyYW5zYWN0aW9ucyB0byBkcmFpbiBvdXQgYmVmb3JlIHByb2NlZWRpbmcuCiAgKi8KIHZvaWQKIHhmc19xdWllc2NlX2F0dHIoCmRpZmYgLS1naXQgYS9mcy94ZnMvcXVvdGEveGZzX2RxdW90LmMgYi9mcy94ZnMvcXVvdGEveGZzX2RxdW90LmMKaW5kZXggN2UyNDE2NC4uNmZhMjE0NiAxMDA2NDQKLS0tIGEvZnMveGZzL3F1b3RhL3hmc19kcXVvdC5jCisrKyBiL2ZzL3hmcy9xdW90YS94ZnNfZHF1b3QuYwpAQCAtNjAwLDcgKzYwMCw3IEBACiAKIAkvKgogCSAqIFJlc2VydmF0aW9uIGNvdW50ZXJzIGFyZSBkZWZpbmVkIGFzIHJlc2VydmF0aW9uIHBsdXMgY3VycmVudCB1c2FnZQotCSAqIHRvIGF2b2lkIGhhdmluZyB0byBhZGQgZXZlcnl0aW1lLgorCSAqIHRvIGF2b2lkIGhhdmluZyB0byBhZGQgZXZlcnkgdGltZS4KIAkgKi8KIAlkcXAtPnFfcmVzX2Jjb3VudCA9IGJlNjRfdG9fY3B1KGRkcXAtPmRfYmNvdW50KTsKIAlkcXAtPnFfcmVzX2ljb3VudCA9IGJlNjRfdG9fY3B1KGRkcXAtPmRfaWNvdW50KTsKZGlmZiAtLWdpdCBhL2ZzL3hmcy9xdW90YS94ZnNfcW1fYmh2LmMgYi9mcy94ZnMvcXVvdGEveGZzX3FtX2Jodi5jCmluZGV4IDc3NGQ3ZWMuLmEwYTgyOWEgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9xdW90YS94ZnNfcW1fYmh2LmMKKysrIGIvZnMveGZzL3F1b3RhL3hmc19xbV9iaHYuYwpAQCAtMTM0LDcgKzEzNCw3IEBACiAJCSAqLwogCQlpZiAocXVvdGFvbmRpc2sgJiYgIVhGU19RTV9ORUVEX1FVT1RBQ0hFQ0sobXApKSB7CiAJCQkvKgotCQkJICogSWYgYW4gZXJyb3Igb2NjdXJlZCwgcW1fbW91bnRfcXVvdGFzIGNvZGUKKwkJCSAqIElmIGFuIGVycm9yIG9jY3VycmVkLCBxbV9tb3VudF9xdW90YXMgY29kZQogCQkJICogaGFzIGFscmVhZHkgZGlzYWJsZWQgcXVvdGFzLiBTbywganVzdCBmaW5pc2gKIAkJCSAqIG1vdW50aW5nLCBhbmQgZ2V0IG9uIHdpdGggdGhlIGJvcmluZyBsaWZlCiAJCQkgKiB3aXRob3V0IGRpc2sgcXVvdGFzLgpkaWZmIC0tZ2l0IGEvZnMveGZzL3F1b3RhL3hmc19xbV9zeXNjYWxscy5jIGIvZnMveGZzL3F1b3RhL3hmc19xbV9zeXNjYWxscy5jCmluZGV4IGM4MmYwNjcuLjBkNjJhMDcgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9xdW90YS94ZnNfcW1fc3lzY2FsbHMuYworKysgYi9mcy94ZnMvcXVvdGEveGZzX3FtX3N5c2NhbGxzLmMKQEAgLTE3Miw3ICsxNzIsNyBAQAogCS8qCiAJICogTmV4dCB3ZSBtYWtlIHRoZSBjaGFuZ2VzIGluIHRoZSBxdW90YSBmbGFnIGluIHRoZSBtb3VudCBzdHJ1Y3QuCiAJICogVGhpcyBpc24ndCBwcm90ZWN0ZWQgYnkgYSBwYXJ0aWN1bGFyIGxvY2sgZGlyZWN0bHksIGJlY2F1c2Ugd2UKLQkgKiBkb24ndCB3YW50IHRvIHRha2UgYSBtcmxvY2sgZXZlcnl0aW1lIHdlIGRlcGVuZCBvbiBxdW90YXMgYmVpbmcgb24uCisJICogZG9uJ3Qgd2FudCB0byB0YWtlIGEgbXJsb2NrIGV2ZXJ5IHRpbWUgd2UgZGVwZW5kIG9uIHF1b3RhcyBiZWluZyBvbi4KIAkgKi8KIAltcC0+bV9xZmxhZ3MgJj0gfihmbGFncyk7CiAKQEAgLTM1NCw3ICszNTQsNyBAQAogCQlyZXR1cm4gWEZTX0VSUk9SKEVJTlZBTCk7CiAJfQogCS8qCi0JICogSWYgZXZlcnl0aGluZydzIHVwdG8tZGF0ZSBpbmNvcmUsIHRoZW4gZG9uJ3Qgd2FzdGUgdGltZS4KKwkgKiBJZiBldmVyeXRoaW5nJ3MgdXAgdG8tZGF0ZSBpbmNvcmUsIHRoZW4gZG9uJ3Qgd2FzdGUgdGltZS4KIAkgKi8KIAlpZiAoKG1wLT5tX3FmbGFncyAmIGZsYWdzKSA9PSBmbGFncykKIAkJcmV0dXJuIFhGU19FUlJPUihFRVhJU1QpOwpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19idWZfaXRlbS5jIGIvZnMveGZzL3hmc19idWZfaXRlbS5jCmluZGV4IGU1NDEzZDkuLjdiN2UwMDUgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfYnVmX2l0ZW0uYworKysgYi9mcy94ZnMveGZzX2J1Zl9pdGVtLmMKQEAgLTk5Miw3ICs5OTIsNyBAQAogCWxhc3R0YXJnID0gWEZTX0JVRl9UQVJHRVQoYnApOwogCiAJLyoKLQkgKiBJZiB0aGUgd3JpdGUgd2FzIGFzeW5jaHJvbm91cyB0aGVuIG5vb25lIHdpbGwgYmUgbG9va2luZyBmb3IgdGhlCisJICogSWYgdGhlIHdyaXRlIHdhcyBhc3luY2hyb25vdXMgdGhlbiBubyBvbmUgd2lsbCBiZSBsb29raW5nIGZvciB0aGUKIAkgKiBlcnJvci4gIENsZWFyIHRoZSBlcnJvciBzdGF0ZSBhbmQgd3JpdGUgdGhlIGJ1ZmZlciBvdXQgYWdhaW4uCiAJICoKIAkgKiBEdXJpbmcgc3luYyBvciB1bW91bnQgd2UnbGwgd3JpdGUgYWxsIHBlbmRpbmcgYnVmZmVycyBhZ2FpbgpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19pbm9kZS5jIGIvZnMveGZzL3hmc19pbm9kZS5jCmluZGV4IDc0MmM4MzMuLmEzNzQ4MGEgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfaW5vZGUuYworKysgYi9mcy94ZnMveGZzX2lub2RlLmMKQEAgLTI3ODksNyArMjc4OSw3IEBACiAKIAkvKgogCSAqIFdlIGNhbid0IGZsdXNoIHRoZSBpbm9kZSB1bnRpbCBpdCBpcyB1bnBpbm5lZCwgc28gd2FpdCBmb3IgaXQgaWYgd2UKLQkgKiBhcmUgYWxsb3dlZCB0byBibG9jay4gIFdlIGtub3cgbm9vbmUgbmV3IGNhbiBwaW4gaXQsIGJlY2F1c2Ugd2UgYXJlCisJICogYXJlIGFsbG93ZWQgdG8gYmxvY2suICBXZSBrbm93IG5vIG9uZSBuZXcgY2FuIHBpbiBpdCwgYmVjYXVzZSB3ZSBhcmUKIAkgKiBob2xkaW5nIHRoZSBpbm9kZSBsb2NrIHNoYXJlZCBhbmQgeW91IG5lZWQgdG8gaG9sZCBpdCBleGNsdXNpdmVseSB0bwogCSAqIHBpbiB0aGUgaW5vZGUuCiAJICoKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfaW5vZGUuaCBiL2ZzL3hmcy94ZnNfaW5vZGUuaAppbmRleCBmNzUzMjAwLi5mZjRlMmEzIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2lub2RlLmgKKysrIGIvZnMveGZzL3hmc19pbm9kZS5oCkBAIC0xMTEsNyArMTExLDcgQEAKICAqIEdlbmVyYWxseSwgd2UgZG8gbm90IHdhbnQgdG8gaG9sZCB0aGUgaV9ybG9jayB3aGlsZSBob2xkaW5nIHRoZQogICogaV9pbG9jay4gSGllcmFyY2h5IGlzIGlfaW9sb2NrIGZvbGxvd2VkIGJ5IGlfcmxvY2suCiAgKgotICogeGZzX2lwdHJfdCBjb250YWlucyBhbGwgdGhlIGlub2RlIGZpZWxkcyB1cHRvIGFuZCBpbmNsdWRpbmcgdGhlCisgKiB4ZnNfaXB0cl90IGNvbnRhaW5zIGFsbCB0aGUgaW5vZGUgZmllbGRzIHVwIHRvIGFuZCBpbmNsdWRpbmcgdGhlCiAgKiBpX21uZXh0IGFuZCBpX21wcmV2IGZpZWxkcywgaXQgaXMgdXNlZCBhcyBhIG1hcmtlciBpbiB0aGUgaW5vZGUKICAqIGNoYWluIG9mZiB0aGUgbW91bnQgc3RydWN0dXJlIGJ5IHhmc19zeW5jIGNhbGxzLgogICovCkBAIC0zMzYsNyArMzM2LDcgQEAKIAogLyoKICAqIFByb2plY3QgcXVvdGEgaWQgaGVscGVycyAocHJldmlvdXNseSBwcm9qaWQgd2FzIDE2Yml0IG9ubHkKLSAqIGFuZCB1c2luZyB0d28gMTZiaXQgdmFsdWVzIHRvIGhvbGQgbmV3IDMyYml0IHByb2ppZCB3YXMgY2hvb3NlbgorICogYW5kIHVzaW5nIHR3byAxNmJpdCB2YWx1ZXMgdG8gaG9sZCBuZXcgMzJiaXQgcHJvamlkIHdhcyBjaG9zZW4KICAqIHRvIHJldGFpbiBjb21wYXRpYmlsaXR5IHdpdGggIm9sZCIgZmlsZXN5c3RlbXMpLgogICovCiBzdGF0aWMgaW5saW5lIHByaWRfdApkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19sb2dfcHJpdi5oIGIvZnMveGZzL3hmc19sb2dfcHJpdi5oCmluZGV4IDE1ZGJmMWYuLmZmYWU2OTIgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfbG9nX3ByaXYuaAorKysgYi9mcy94ZnMveGZzX2xvZ19wcml2LmgKQEAgLTU3MCw3ICs1NzAsNyBAQAogICogV2hlbiB3ZSBjcmFjayBhbiBhdG9taWMgTFNOLCB3ZSBzYW1wbGUgaXQgZmlyc3Qgc28gdGhhdCB0aGUgdmFsdWUgd2lsbCBub3QKICAqIGNoYW5nZSB3aGlsZSB3ZSBhcmUgY3JhY2tpbmcgaXQgaW50byB0aGUgY29tcG9uZW50IHZhbHVlcy4gVGhpcyBtZWFucyB3ZQogICogd2lsbCBhbHdheXMgZ2V0IGNvbnNpc3RlbnQgY29tcG9uZW50IHZhbHVlcyB0byB3b3JrIGZyb20uIFRoaXMgc2hvdWxkIGFsd2F5cwotICogYmUgdXNlZCB0byBzbWFwbGUgYW5kIGNyYWNrIExTTnMgdGFodCBhcmUgc3RvcmVkIGFuZCB1cGRhdGVkIGluIGF0b21pYworICogYmUgdXNlZCB0byBzYW1wbGUgYW5kIGNyYWNrIExTTnMgdGhhdCBhcmUgc3RvcmVkIGFuZCB1cGRhdGVkIGluIGF0b21pYwogICogdmFyaWFibGVzLgogICovCiBzdGF0aWMgaW5saW5lIHZvaWQKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfbG9nX3JlY292ZXIuYyBiL2ZzL3hmcy94ZnNfbG9nX3JlY292ZXIuYwppbmRleCAwYzRhNTYxLi41Y2M0NjRhIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2xvZ19yZWNvdmVyLmMKKysrIGIvZnMveGZzL3hmc19sb2dfcmVjb3Zlci5jCkBAIC0xMDEsNyArMTAxLDcgQEAKIAkvKgogCSAqIFdlIGRvIGxvZyBJL08gaW4gdW5pdHMgb2YgbG9nIHNlY3RvcnMgKGEgcG93ZXItb2YtMgogCSAqIG11bHRpcGxlIG9mIHRoZSBiYXNpYyBibG9jayBzaXplKSwgc28gd2Ugcm91bmQgdXAgdGhlCi0JICogcmVxdWVzdGVkIHNpemUgdG8gYWNvbW1vZGF0ZSB0aGUgYmFzaWMgYmxvY2tzIHJlcXVpcmVkCisJICogcmVxdWVzdGVkIHNpemUgdG8gYWNjb21tb2RhdGUgdGhlIGJhc2ljIGJsb2NrcyByZXF1aXJlZAogCSAqIGZvciBjb21wbGV0ZSBsb2cgc2VjdG9ycy4KIAkgKgogCSAqIEluIGFkZGl0aW9uLCB0aGUgYnVmZmVyIG1heSBiZSB1c2VkIGZvciBhIG5vbi1zZWN0b3ItCkBAIC0xMTIsNyArMTEyLDcgQEAKIAkgKiBhbiBpc3N1ZS4gIE5vciB3aWxsIHRoaXMgYmUgYSBwcm9ibGVtIGlmIHRoZSBsb2cgSS9PIGlzCiAJICogZG9uZSBpbiBiYXNpYyBibG9ja3MgKHNlY3RvciBzaXplIDEpLiAgQnV0IG90aGVyd2lzZSB3ZQogCSAqIGV4dGVuZCB0aGUgYnVmZmVyIGJ5IG9uZSBleHRyYSBsb2cgc2VjdG9yIHRvIGVuc3VyZQotCSAqIHRoZXJlJ3Mgc3BhY2UgdG8gYWNjb21vZGF0ZSB0aGlzIHBvc3NpYmxpbGl0eS4KKwkgKiB0aGVyZSdzIHNwYWNlIHRvIGFjY29tbW9kYXRlIHRoaXMgcG9zc2liaWxpdHkuCiAJICovCiAJaWYgKG5iYmxrcyA+IDEgJiYgbG9nLT5sX3NlY3RCQnNpemUgPiAxKQogCQluYmJsa3MgKz0gbG9nLT5sX3NlY3RCQnNpemU7CmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3RyYW5zX2lub2RlLmMgYi9mcy94ZnMveGZzX3RyYW5zX2lub2RlLmMKaW5kZXggMTYwODRkOC4uMDQ4YjBjNiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc190cmFuc19pbm9kZS5jCisrKyBiL2ZzL3hmcy94ZnNfdHJhbnNfaW5vZGUuYwpAQCAtODEsNyArODEsNyBAQAogICoKICAqCiAgKiBHcmFicyBhIHJlZmVyZW5jZSB0byB0aGUgaW5vZGUgd2hpY2ggd2lsbCBiZSBkcm9wcGVkIHdoZW4gdGhlIHRyYW5zYWN0aW9uCi0gKiBpcyBjb21taXRlZC4gIFRoZSBpbm9kZSB3aWxsIGFsc28gYmUgdW5sb2NrZWQgYXQgdGhhdCBwb2ludC4gIFRoZSBpbm9kZQorICogaXMgY29tbWl0dGVkLiAgVGhlIGlub2RlIHdpbGwgYWxzbyBiZSB1bmxvY2tlZCBhdCB0aGF0IHBvaW50LiAgVGhlIGlub2RlCiAgKiBtdXN0IGJlIGxvY2tlZCwgYW5kIGl0IGNhbm5vdCBiZSBhc3NvY2lhdGVkIHdpdGggYW55IHRyYW5zYWN0aW9uLgogICovCiB2b2lkCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3Zub2Rlb3BzLmMgYi9mcy94ZnMveGZzX3Zub2Rlb3BzLmMKaW5kZXggYzQ4YjQyMS4uYjdhNWZlNyAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc192bm9kZW9wcy5jCisrKyBiL2ZzL3hmcy94ZnNfdm5vZGVvcHMuYwpAQCAtOTUzLDcgKzk1Myw3IEBACiAJCSAqIElmIHdlIHByZXZpb3VzbHkgdHJ1bmNhdGVkIHRoaXMgZmlsZSBhbmQgcmVtb3ZlZCBvbGQgZGF0YQogCQkgKiBpbiB0aGUgcHJvY2Vzcywgd2Ugd2FudCB0byBpbml0aWF0ZSAiZWFybHkiIHdyaXRlb3V0IG9uCiAJCSAqIHRoZSBsYXN0IGNsb3NlLiAgVGhpcyBpcyBhbiBhdHRlbXB0IHRvIGNvbWJhdCB0aGUgbm90b3Jpb3VzCi0JCSAqIE5VTEwgZmlsZXMgcHJvYmxlbSB3aGljaCBpcyBwYXJ0aWN1bGFybHkgbm90aWNhYmxlIGZyb20gYQorCQkgKiBOVUxMIGZpbGVzIHByb2JsZW0gd2hpY2ggaXMgcGFydGljdWxhcmx5IG5vdGljZWFibGUgZnJvbSBhCiAJCSAqIHRydW5jYXRlIGRvd24sIGJ1ZmZlcmVkIChyZS0pd3JpdGUgKGRlbGFsbG9jKSwgZm9sbG93ZWQgYnkKIAkJICogYSBjcmFzaC4gIFdoYXQgd2UgYXJlIGVmZmVjdGl2ZWx5IGRvaW5nIGhlcmUgaXMKIAkJICogc2lnbmlmaWNhbnRseSByZWR1Y2luZyB0aGUgdGltZSB3aW5kb3cgd2hlcmUgd2UnZCBvdGhlcndpc2UKQEAgLTk4Miw3ICs5ODIsNyBAQAogCQkgKgogCQkgKiBGdXJ0aGVyLCBjaGVjayBpZiB0aGUgaW5vZGUgaXMgYmVpbmcgb3BlbmVkLCB3cml0dGVuIGFuZAogCQkgKiBjbG9zZWQgZnJlcXVlbnRseSBhbmQgd2UgaGF2ZSBkZWxheWVkIGFsbG9jYXRpb24gYmxvY2tzCi0JCSAqIG91c3RhbmRpbmcgKGUuZy4gc3RyZWFtaW5nIHdyaXRlcyBmcm9tIHRoZSBORlMgc2VydmVyKSwKKwkJICogb3V0c3RhbmRpbmcgKGUuZy4gc3RyZWFtaW5nIHdyaXRlcyBmcm9tIHRoZSBORlMgc2VydmVyKSwKIAkJICogdHJ1bmNhdGluZyB0aGUgYmxvY2tzIHBhc3QgRU9GIHdpbGwgY2F1c2UgZnJhZ21lbnRhdGlvbiB0bwogCQkgKiBvY2N1ci4KIAkJICoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3RibC5oIGIvaW5jbHVkZS9hY3BpL2FjdGJsLmgKaW5kZXggZDQxYzk0OC4uZjEzODAyOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjdGJsLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjdGJsLmgKQEAgLTI5MCw3ICsyOTAsNyBAQAogI2RlZmluZSBBQ1BJX0ZBRFRfQVBJQ19DTFVTVEVSICAgICAgKDE8PDE4KQkvKiAxODogW1Y0XSBBbGwgbG9jYWwgQVBJQ3MgbXVzdCB1c2UgY2x1c3RlciBtb2RlbCAoQUNQSSAzLjApICovCiAjZGVmaW5lIEFDUElfRkFEVF9BUElDX1BIWVNJQ0FMICAgICAoMTw8MTkpCS8qIDE5OiBbVjRdIEFsbCBsb2NhbCB4X2FQSUNzIG11c3QgdXNlIHBoeXNpY2FsIGRlc3QgbW9kZSAoQUNQSSAzLjApICovCiAKLS8qIFZhbHVlcyBmb3IgcHJlZmVycmVkX3Byb2ZpbGUgKFByZWZlcmVkIFBvd2VyIE1hbmFnZW1lbnQgUHJvZmlsZXMpICovCisvKiBWYWx1ZXMgZm9yIHByZWZlcnJlZF9wcm9maWxlIChQcmVmZXJyZWQgUG93ZXIgTWFuYWdlbWVudCBQcm9maWxlcykgKi8KIAogZW51bSBhY3BpX3ByZWZlcmVkX3BtX3Byb2ZpbGVzIHsKIAlQTV9VTlNQRUNJRklFRCA9IDAsCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL3NpZ2luZm8uaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2lnaW5mby5oCmluZGV4IDk0MmQzMGIuLjBkZDRlODcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2lnaW5mby5oCisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2lnaW5mby5oCkBAIC0xOTIsNyArMTkyLDcgQEAKICAqIFNJR0JVUyBzaV9jb2RlcwogICovCiAjZGVmaW5lIEJVU19BRFJBTE4JKF9fU0lfRkFVTFR8MSkJLyogaW52YWxpZCBhZGRyZXNzIGFsaWdubWVudCAqLwotI2RlZmluZSBCVVNfQURSRVJSCShfX1NJX0ZBVUxUfDIpCS8qIG5vbi1leGlzdGFudCBwaHlzaWNhbCBhZGRyZXNzICovCisjZGVmaW5lIEJVU19BRFJFUlIJKF9fU0lfRkFVTFR8MikJLyogbm9uLWV4aXN0ZW50IHBoeXNpY2FsIGFkZHJlc3MgKi8KICNkZWZpbmUgQlVTX09CSkVSUgkoX19TSV9GQVVMVHwzKQkvKiBvYmplY3Qgc3BlY2lmaWMgaGFyZHdhcmUgZXJyb3IgKi8KIC8qIGhhcmR3YXJlIG1lbW9yeSBlcnJvciBjb25zdW1lZCBvbiBhIG1hY2hpbmUgY2hlY2s6IGFjdGlvbiByZXF1aXJlZCAqLwogI2RlZmluZSBCVVNfTUNFRVJSX0FSCShfX1NJX0ZBVUxUfDQpCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgKaW5kZXggMzJjNDVlNS4uYmQyOTdhMiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oCisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaApAQCAtNzczLDcgKzc3Myw3IEBACiAgKiB0aGUgc2VjdGlvbnMgdGhhdCBoYXMgdGhpcyByZXN0cmljdGlvbiAob3Igc2ltaWxhcikKICAqIGlzIGxvY2F0ZWQgYmVmb3JlIHRoZSBvbmVzIHJlcXVpcmluZyBQQUdFX1NJWkUgYWxpZ25tZW50LgogICogTk9TQVZFX0RBVEEgc3RhcnRzIGFuZCBlbmRzIHdpdGggYSBQQUdFX1NJWkUgYWxpZ25tZW50IHdoaWNoCi0gKiBtYXRjaGVzIHRoZSByZXF1aXJtZW50IG9mIFBBR0VfQUxJR05FRF9EQVRBLgorICogbWF0Y2hlcyB0aGUgcmVxdWlyZW1lbnQgb2YgUEFHRV9BTElHTkVEX0RBVEEuCiAgKgogICogdXNlIDAgYXMgcGFnZV9hbGlnbiBpZiBwYWdlX2FsaWduZWQgZGF0YSBpcyBub3QgdXNlZCAqLwogI2RlZmluZSBSV19EQVRBX1NFQ1RJT04oY2FjaGVsaW5lLCBwYWdlYWxpZ25lZCwgaW5pdHRhc2spCQlcCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1QLmggYi9pbmNsdWRlL2RybS9kcm1QLmgKaW5kZXggYWQ1NzcwZi4uMjAyNDI0ZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtUC5oCisrKyBiL2luY2x1ZGUvZHJtL2RybVAuaApAQCAtOTUsNyArOTUsNyBAQAogICogZHJtX2NvcmUsIGRybV9kcml2ZXIsIGRybV9rbXMKICAqIGRybV9jb3JlIGxldmVsIGNhbiBiZSB1c2VkIGluIHRoZSBnZW5lcmljIGRybSBjb2RlLiBGb3IgZXhhbXBsZToKICAqIAlkcm1faW9jdGwsIGRybV9tbSwgZHJtX21lbW9yeQotICogVGhlIG1hY3JvIGRlZmluaXRvbiBvZiBEUk1fREVCVUcgaXMgdXNlZC4KKyAqIFRoZSBtYWNybyBkZWZpbml0aW9uIG9mIERSTV9ERUJVRyBpcyB1c2VkLgogICogCURSTV9ERUJVRyhmbXQsIGFyZ3MuLi4pCiAgKiAJVGhlIGRlYnVnIGluZm8gYnkgdXNpbmcgdGhlIERSTV9ERUJVRyBjYW4gYmUgb2J0YWluZWQgYnkgYWRkaW5nCiAgKiAJdGhlIGJvb3Qgb3B0aW9uIG9mICJkcm0uZGVidWc9MSIuCkBAIC04MDgsNyArODA4LDcgQEAKIAkgKgogCSAqIFxyZXR1cm4gRmxhZ3MsIG9yJ2VkIHRvZ2V0aGVyIGFzIGZvbGxvd3M6CiAJICoKLQkgKiBEUk1fU0NBTk9VVFBPU19WQUxJRCA9IFF1ZXJ5IHN1Y2Nlc3NmdWxsLgorCSAqIERSTV9TQ0FOT1VUUE9TX1ZBTElEID0gUXVlcnkgc3VjY2Vzc2Z1bC4KIAkgKiBEUk1fU0NBTk9VVFBPU19JTlZCTCA9IEluc2lkZSB2YmxhbmsuCiAJICogRFJNX1NDQU5PVVRQT1NfQUNDVVJBVEUgPSBSZXR1cm5lZCBwb3NpdGlvbiBpcyBhY2N1cmF0ZS4gQSBsYWNrIG9mCiAJICogdGhpcyBmbGFnIG1lYW5zIHRoYXQgcmV0dXJuZWQgcG9zaXRpb24gbWF5IGJlIG9mZnNldCBieSBhIGNvbnN0YW50CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fY3J0Yy5oIGIvaW5jbHVkZS9kcm0vZHJtX2NydGMuaAppbmRleCBhYWVjMDk3Li5kOTQ2ODRiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1fY3J0Yy5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9jcnRjLmgKQEAgLTY1LDcgKzY1LDcgQEAKICAgICBNT0RFX0hfSUxMRUdBTCwJLyogbW9kZSBoYXMgaWxsZWdhbCBob3Jpem9udGFsIHRpbWluZ3MgKi8KICAgICBNT0RFX1ZfSUxMRUdBTCwJLyogbW9kZSBoYXMgaWxsZWdhbCBob3Jpem9udGFsIHRpbWluZ3MgKi8KICAgICBNT0RFX0JBRF9XSURUSCwJLyogcmVxdWlyZXMgYW4gdW5zdXBwb3J0ZWQgbGluZXBpdGNoICovCi0gICAgTU9ERV9OT01PREUsCS8qIG5vIG1vZGUgd2l0aCBhIG1hY2hpbmcgbmFtZSAqLworICAgIE1PREVfTk9NT0RFLAkvKiBubyBtb2RlIHdpdGggYSBtYXRjaGluZyBuYW1lICovCiAgICAgTU9ERV9OT19JTlRFUkxBQ0UsCS8qIGludGVybGFjZWQgbW9kZSBub3Qgc3VwcG9ydGVkICovCiAgICAgTU9ERV9OT19EQkxFU0NBTiwJLyogZG91Ymxlc2NhbiBtb2RlIG5vdCBzdXBwb3J0ZWQgKi8KICAgICBNT0RFX05PX1ZTQ0FOLAkvKiBtdWx0aXNjYW4gbW9kZSBub3Qgc3VwcG9ydGVkICovCkBAIC0zMjEsNyArMzIxLDcgQEAKIAogCS8qCiAJICogRmxpcCB0byB0aGUgZ2l2ZW4gZnJhbWVidWZmZXIuICBUaGlzIGltcGxlbWVudHMgdGhlIHBhZ2UKLQkgKiBmbGlwIGlvY3RsIGRlc2NpYmVkIGluIGRybV9tb2RlLmgsIHNwZWNpZmljYWxseSwgdGhlCisJICogZmxpcCBpb2N0bCBkZXNjcmliZWQgaW4gZHJtX21vZGUuaCwgc3BlY2lmaWNhbGx5LCB0aGUKIAkgKiBpbXBsZW1lbnRhdGlvbiBtdXN0IHJldHVybiBpbW1lZGlhdGVseSBhbmQgYmxvY2sgYWxsCiAJICogcmVuZGVyaW5nIHRvIHRoZSBjdXJyZW50IGZiIHVudGlsIHRoZSBmbGlwIGhhcyBjb21wbGV0ZWQuCiAJICogSWYgdXNlcnNwYWNlIHNldCB0aGUgZXZlbnQgZmxhZyBpbiB0aGUgaW9jdGwsIHRoZSBldmVudApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX21tLmggYi9pbmNsdWRlL2RybS9kcm1fbW0uaAppbmRleCBiMWU3ODA5Li5jMmY5M2E4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1fbW0uaAorKysgYi9pbmNsdWRlL2RybS9kcm1fbW0uaApAQCAtNTYsNyArNTYsNyBAQAogfTsKIAogc3RydWN0IGRybV9tbSB7Ci0JLyogTGlzdCBvZiBhbGwgbWVtb3J5IG5vZGVzIHRoYXQgaW1tZWRpYXRseSBwcmVjZWVkIGEgZnJlZSBob2xlLiAqLworCS8qIExpc3Qgb2YgYWxsIG1lbW9yeSBub2RlcyB0aGF0IGltbWVkaWF0ZWx5IHByZWNlZGUgYSBmcmVlIGhvbGUuICovCiAJc3RydWN0IGxpc3RfaGVhZCBob2xlX3N0YWNrOwogCS8qIGhlYWRfbm9kZS5ub2RlX2xpc3QgaXMgdGhlIGxpc3Qgb2YgYWxsIG1lbW9yeSBub2Rlcywgb3JkZXJlZAogCSAqIGFjY29yZGluZyB0byB0aGUgKGluY3JlYXNpbmcpIHN0YXJ0IGFkZHJlc3Mgb2YgdGhlIG1lbW9yeSBub2RlLiAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX21vZGUuaCBiL2luY2x1ZGUvZHJtL2RybV9tb2RlLmgKaW5kZXggYWU2YjdhMy4uYzQ5NjFlYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX21vZGUuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fbW9kZS5oCkBAIC0yNzcsNyArMjc3LDcgQEAKICNkZWZpbmUgRFJNX01PREVfQ1VSU09SX01PVkUJKDE8PDEpCiAKIC8qCi0gKiBkZXBlbmRpbmcgb24gdGhlIHZhbHVlIGluIGZsYWdzIGRpZmZyZW50IG1lbWJlcnMgYXJlIHVzZWQuCisgKiBkZXBlbmRpbmcgb24gdGhlIHZhbHVlIGluIGZsYWdzIGRpZmZlcmVudCBtZW1iZXJzIGFyZSB1c2VkLgogICoKICAqIENVUlNPUl9CTyB1c2VzCiAgKiAgICBjcnRjCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9tZ2FfZHJtLmggYi9pbmNsdWRlL2RybS9tZ2FfZHJtLmgKaW5kZXggYzE2MDk3Zi4uZmNhODE3MCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vbWdhX2RybS5oCisrKyBiL2luY2x1ZGUvZHJtL21nYV9kcm0uaApAQCAtMTA3LDcgKzEwNyw3IEBACiAgKi8KICNkZWZpbmUgTUdBX05SX1NBUkVBX0NMSVBSRUNUUwk4CiAKLS8qIDIgaGVhcHMgKDEgZm9yIGNhcmQsIDEgZm9yIGFncCksIGVhY2ggZGl2aWRlZCBpbnRvIHVwdG8gMTI4CisvKiAyIGhlYXBzICgxIGZvciBjYXJkLCAxIGZvciBhZ3ApLCBlYWNoIGRpdmlkZWQgaW50byB1cCB0byAxMjgKICAqIHJlZ2lvbnMsIHN1YmplY3QgdG8gYSBtaW5pbXVtIHJlZ2lvbiBzaXplIG9mICgxPDwxNikgPT0gNjRrLgogICoKICAqIENsaWVudHMgbWF5IHN1YmRpdmlkZSByZWdpb25zIGludGVybmFsbHksIGJ1dCB3aGVuIHNoYXJpbmcgYmV0d2VlbgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vcmFkZW9uX2RybS5oIGIvaW5jbHVkZS9kcm0vcmFkZW9uX2RybS5oCmluZGV4IDNkZWM0MWMuLjNiY2UxYTQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL3JhZGVvbl9kcm0uaAorKysgYi9pbmNsdWRlL2RybS9yYWRlb25fZHJtLmgKQEAgLTY0MSw3ICs2NDEsNyBAQAogfSBkcm1fcmFkZW9uX3ZlcnRleDJfdDsKIAogLyogdjEuMyAtIG9ic29sZXRlcyBkcm1fcmFkZW9uX3ZlcnRleDIKLSAqICAgICAgLSBhbGxvd3MgYXJiaXRhcmlseSBsYXJnZSBjbGlwcmVjdCBsaXN0CisgKiAgICAgIC0gYWxsb3dzIGFyYml0cmFyaWx5IGxhcmdlIGNsaXByZWN0IGxpc3QKICAqICAgICAgLSBhbGxvd3MgdXBkYXRpbmcgb2YgdGNsIHBhY2tldCwgdmVjdG9yIGFuZCBzY2FsYXIgc3RhdGUKICAqICAgICAgLSBhbGxvd3MgbWVtb3J5LWVmZmljaWVudCBkZXNjcmlwdGlvbiBvZiBzdGF0ZSB1cGRhdGVzCiAgKiAgICAgIC0gYWxsb3dzIHN0YXRlIHRvIGJlIGVtaXR0ZWQgd2l0aG91dCBhIHByaW1pdGl2ZQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vc2F2YWdlX2RybS5oIGIvaW5jbHVkZS9kcm0vc2F2YWdlX2RybS5oCmluZGV4IDQ4NjNjZjYuLjgxOGQ0OWIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL3NhdmFnZV9kcm0uaAorKysgYi9pbmNsdWRlL2RybS9zYXZhZ2VfZHJtLmgKQEAgLTI5LDcgKzI5LDcgQEAKICNpZm5kZWYgX19TQVZBR0VfU0FSRUFfREVGSU5FU19fCiAjZGVmaW5lIF9fU0FWQUdFX1NBUkVBX0RFRklORVNfXwogCi0vKiAyIGhlYXBzICgxIGZvciBjYXJkLCAxIGZvciBhZ3ApLCBlYWNoIGRpdmlkZWQgaW50byB1cHRvIDEyOAorLyogMiBoZWFwcyAoMSBmb3IgY2FyZCwgMSBmb3IgYWdwKSwgZWFjaCBkaXZpZGVkIGludG8gdXAgdG8gMTI4CiAgKiByZWdpb25zLCBzdWJqZWN0IHRvIGEgbWluaW11bSByZWdpb24gc2l6ZSBvZiAoMTw8MTYpID09IDY0ay4KICAqCiAgKiBDbGllbnRzIG1heSBzdWJkaXZpZGUgcmVnaW9ucyBpbnRlcm5hbGx5LCBidXQgd2hlbiBzaGFyaW5nIGJldHdlZW4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL3R0bS90dG1fYm9fYXBpLmggYi9pbmNsdWRlL2RybS90dG0vdHRtX2JvX2FwaS5oCmluZGV4IGE2YmQxMTcuLjYyYTBlNGMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL3R0bS90dG1fYm9fYXBpLmgKKysrIGIvaW5jbHVkZS9kcm0vdHRtL3R0bV9ib19hcGkuaApAQCAtNTAsMTAgKzUwLDEwIEBACiAgKgogICogQGZwZm46CQlmaXJzdCB2YWxpZCBwYWdlIGZyYW1lIG51bWJlciB0byBwdXQgdGhlIG9iamVjdAogICogQGxwZm46CQlsYXN0IHZhbGlkIHBhZ2UgZnJhbWUgbnVtYmVyIHRvIHB1dCB0aGUgb2JqZWN0Ci0gKiBAbnVtX3BsYWNlbWVudDoJbnVtYmVyIG9mIHByZWZlcmVkIHBsYWNlbWVudHMKLSAqIEBwbGFjZW1lbnQ6CQlwcmVmZXJlZCBwbGFjZW1lbnRzCi0gKiBAbnVtX2J1c3lfcGxhY2VtZW50OgludW1iZXIgb2YgcHJlZmVyZWQgcGxhY2VtZW50cyB3aGVuIG5lZWQgdG8gZXZpY3QgYnVmZmVyCi0gKiBAYnVzeV9wbGFjZW1lbnQ6CXByZWZlcmVkIHBsYWNlbWVudHMgd2hlbiBuZWVkIHRvIGV2aWN0IGJ1ZmZlcgorICogQG51bV9wbGFjZW1lbnQ6CW51bWJlciBvZiBwcmVmZXJyZWQgcGxhY2VtZW50cworICogQHBsYWNlbWVudDoJCXByZWZlcnJlZCBwbGFjZW1lbnRzCisgKiBAbnVtX2J1c3lfcGxhY2VtZW50OgludW1iZXIgb2YgcHJlZmVycmVkIHBsYWNlbWVudHMgd2hlbiBuZWVkIHRvIGV2aWN0IGJ1ZmZlcgorICogQGJ1c3lfcGxhY2VtZW50OglwcmVmZXJyZWQgcGxhY2VtZW50cyB3aGVuIG5lZWQgdG8gZXZpY3QgYnVmZmVyCiAgKgogICogU3RydWN0dXJlIGluZGljYXRpbmcgdGhlIHBsYWNlbWVudCB5b3UgcmVxdWVzdCBmb3IgYW4gb2JqZWN0LgogICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS90dG0vdHRtX2JvX2RyaXZlci5oIGIvaW5jbHVkZS9kcm0vdHRtL3R0bV9ib19kcml2ZXIuaAppbmRleCA5NjBiNTIxLi4wOWFmMmQ3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS90dG0vdHRtX2JvX2RyaXZlci5oCisrKyBiL2luY2x1ZGUvZHJtL3R0bS90dG1fYm9fZHJpdmVyLmgKQEAgLTIyMyw5ICsyMjMsOSBAQAogCSAqIEBtZW06Om1tX25vZGUgc2hvdWxkIGJlIHNldCB0byBhIG5vbi1udWxsIHZhbHVlLCBhbmQKIAkgKiBAbWVtOjpzdGFydCBzaG91bGQgYmUgc2V0IHRvIGEgdmFsdWUgaWRlbnRpZnlpbmcgdGhlIGJlZ2lubmluZwogCSAqIG9mIHRoZSByYW5nZSBhbGxvY2F0ZWQsIGFuZCB0aGUgZnVuY3Rpb24gc2hvdWxkIHJldHVybiB6ZXJvLgotCSAqIElmIHRoZSBtZW1vcnkgcmVnaW9uIGFjY29tb2RhdGUgdGhlIGJ1ZmZlciBvYmplY3QsIEBtZW06Om1tX25vZGUKKwkgKiBJZiB0aGUgbWVtb3J5IHJlZ2lvbiBhY2NvbW1vZGF0ZSB0aGUgYnVmZmVyIG9iamVjdCwgQG1lbTo6bW1fbm9kZQogCSAqIHNob3VsZCBiZSBzZXQgdG8gTlVMTCwgYW5kIHRoZSBmdW5jdGlvbiBzaG91bGQgcmV0dXJuIDAuCi0JICogSWYgYSBzeXN0ZW0gZXJyb3Igb2NjdXJlZCwgcHJldmVudGluZyB0aGUgcmVxdWVzdCB0byBiZSBmdWxmaWxsZWQsCisJICogSWYgYSBzeXN0ZW0gZXJyb3Igb2NjdXJyZWQsIHByZXZlbnRpbmcgdGhlIHJlcXVlc3QgdG8gYmUgZnVsZmlsbGVkLAogCSAqIHRoZSBmdW5jdGlvbiBzaG91bGQgcmV0dXJuIGEgbmVnYXRpdmUgZXJyb3IgY29kZS4KIAkgKgogCSAqIE5vdGUgdGhhdCBAbWVtOjptbV9ub2RlIHdpbGwgb25seSBiZSBkZXJlZmVyZW5jZWQgYnkKQEAgLTg0MSw3ICs4NDEsNyBAQAogICogZGlmZmVyZW50IG9yZGVyLCBlaXRoZXIgYnkgd2lsbCBvciBhcyBhIHJlc3VsdCBvZiBhIGJ1ZmZlciBiZWluZyBldmljdGVkCiAgKiB0byBtYWtlIHJvb20gZm9yIGEgYnVmZmVyIGFscmVhZHkgcmVzZXJ2ZWQuIChCdWZmZXJzIGFyZSByZXNlcnZlZCBiZWZvcmUKICAqIHRoZXkgYXJlIGV2aWN0ZWQpLiBUaGUgZm9sbG93aW5nIGFsZ29yaXRobSBwcmV2ZW50cyBzdWNoIGRlYWRsb2NrcyBmcm9tCi0gKiBvY2N1cmluZzoKKyAqIG9jY3VycmluZzoKICAqIDEpIEJ1ZmZlcnMgYXJlIHJlc2VydmVkIHdpdGggdGhlIGxydSBzcGlubG9jayBoZWxkLiBVcG9uIHN1Y2Nlc3NmdWwKICAqIHJlc2VydmF0aW9uIHRoZXkgYXJlIHJlbW92ZWQgZnJvbSB0aGUgbHJ1IGxpc3QuIFRoaXMgc3RvcHMgYSByZXNlcnZlZCBidWZmZXIKICAqIGZyb20gYmVpbmcgZXZpY3RlZC4gSG93ZXZlciB0aGUgbHJ1IHNwaW5sb2NrIGlzIHJlbGVhc2VkIGJldHdlZW4gdGhlIHRpbWUKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL3Ztd2dmeF9kcm0uaCBiL2luY2x1ZGUvZHJtL3Ztd2dmeF9kcm0uaAppbmRleCA2NTBlNmJmLi41YzM2NDMyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS92bXdnZnhfZHJtLmgKKysrIGIvaW5jbHVkZS9kcm0vdm13Z2Z4X2RybS5oCkBAIC01OTIsNyArNTkyLDcgQEAKIC8qKgogICogRFJNX1ZNV19VUERBVEVfTEFZT1VUIC0gVXBkYXRlIGxheW91dAogICoKLSAqIFVwZGF0ZXMgdGhlIHByZWZlcmVkIG1vZGVzIGFuZCBjb25uZWN0aW9uIHN0YXR1cyBmb3IgY29ubmVjdG9ycy4gVGhlCisgKiBVcGRhdGVzIHRoZSBwcmVmZXJyZWQgbW9kZXMgYW5kIGNvbm5lY3Rpb24gc3RhdHVzIGZvciBjb25uZWN0b3JzLiBUaGUKICAqIGNvbW1hbmQgY29uaXNpdHMgb2Ygb25lIGRybV92bXdfdXBkYXRlX2xheW91dF9hcmcgcG9pbnRpbmcgb3V0IGEgYXJyYXkKICAqIG9mIG51bV9vdXRwdXRzIGRybV92bXdfcmVjdCdzLgogICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2FtYmEvY2xjZC5oIGIvaW5jbHVkZS9saW51eC9hbWJhL2NsY2QuaAppbmRleCAyNGQyNmVmLi5lODJlM2VlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2FtYmEvY2xjZC5oCisrKyBiL2luY2x1ZGUvbGludXgvYW1iYS9jbGNkLmgKQEAgLTEzNiw3ICsxMzYsNyBAQAogCWludAkoKmNoZWNrKShzdHJ1Y3QgY2xjZF9mYiAqZmIsIHN0cnVjdCBmYl92YXJfc2NyZWVuaW5mbyAqdmFyKTsKIAogCS8qCi0JICogQ29tcHVsc2FyeS4gIERlY29kZSBmYi0+ZmIudmFyIGludG8gcmVncy0+Ki4gIEluIHRoZSBjYXNlIG9mCisJICogQ29tcHVsc29yeS4gIERlY29kZSBmYi0+ZmIudmFyIGludG8gcmVncy0+Ki4gIEluIHRoZSBjYXNlIG9mCiAJICogZml4ZWQgdGltaW5nLCBzZXQgcmVncy0+KiB0byB0aGUgcmVnaXN0ZXIgdmFsdWVzIHJlcXVpcmVkLgogCSAqLwogCXZvaWQJKCpkZWNvZGUpKHN0cnVjdCBjbGNkX2ZiICpmYiwgc3RydWN0IGNsY2RfcmVncyAqcmVncyk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2FtYmEvbW1jaS5oIGIvaW5jbHVkZS9saW51eC9hbWJhL21tY2kuaAppbmRleCBmNjAyMjcwLi4yMTExNDgxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2FtYmEvbW1jaS5oCisrKyBiL2luY2x1ZGUvbGludXgvYW1iYS9tbWNpLmgKQEAgLTMwLDE1ICszMCwxNSBAQAogICogQGNkX2ludmVydDogdHJ1ZSBpZiB0aGUgZ3Bpb19jZCBwaW4gdmFsdWUgaXMgYWN0aXZlIGxvdwogICogQGNhcGFiaWxpdGllczogdGhlIGNhcGFiaWxpdGllcyBvZiB0aGUgYmxvY2sgYXMgaW1wbGVtZW50ZWQgaW4KICAqIHRoaXMgcGxhdGZvcm0sIHNpZ25pZnkgYW55dGhpbmcgTU1DX0NBUF8qIGZyb20gbW1jL2hvc3QuaAotICogQGRtYV9maWx0ZXI6IGZ1bmN0aW9uIHVzZWQgdG8gc2VsZWN0IGFuIGFwcm9wcmlhdGUgUlggYW5kIFRYCisgKiBAZG1hX2ZpbHRlcjogZnVuY3Rpb24gdXNlZCB0byBzZWxlY3QgYW4gYXBwcm9wcmlhdGUgUlggYW5kIFRYCiAgKiBETUEgY2hhbm5lbCB0byBiZSB1c2VkIGZvciBETUEsIGlmIGFuZCBvbmx5IGlmIHlvdSdyZSBkZXBsb3lpbmcgdGhlCiAgKiBnZW5lcmljIERNQSBlbmdpbmUKICAqIEBkbWFfcnhfcGFyYW06IHBhcmFtZXRlciBwYXNzZWQgdG8gdGhlIERNQSBhbGxvY2F0aW9uCi0gKiBmaWx0ZXIgaW4gb3JkZXIgdG8gc2VsZWN0IGFuIGFwcm9wcmlhdGUgUlggY2hhbm5lbC4gSWYKKyAqIGZpbHRlciBpbiBvcmRlciB0byBzZWxlY3QgYW4gYXBwcm9wcmlhdGUgUlggY2hhbm5lbC4gSWYKICAqIHRoZXJlIGlzIGEgYmlkaXJlY3Rpb25hbCBSWCtUWCBjaGFubmVsLCB0aGVuIGp1c3Qgc3BlY2lmeQogICogdGhpcyBhbmQgbGVhdmUgZG1hX3R4X3BhcmFtIHNldCB0byBOVUxMCiAgKiBAZG1hX3R4X3BhcmFtOiBwYXJhbWV0ZXIgcGFzc2VkIHRvIHRoZSBETUEgYWxsb2NhdGlvbgotICogZmlsdGVyIGluIG9yZGVyIHRvIHNlbGVjdCBhbiBhcHJvcHJpYXRlIFRYIGNoYW5uZWwuIElmIHRoaXMKKyAqIGZpbHRlciBpbiBvcmRlciB0byBzZWxlY3QgYW4gYXBwcm9wcmlhdGUgVFggY2hhbm5lbC4gSWYgdGhpcwogICogaXMgTlVMTCB0aGUgZHJpdmVyIHdpbGwgYXR0ZW1wdCB0byB1c2UgdGhlIFJYIGNoYW5uZWwgYXMgYQogICogYmlkaXJlY3Rpb25hbCBjaGFubmVsCiAgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY2FuL2Vycm9yLmggYi9pbmNsdWRlL2xpbnV4L2Nhbi9lcnJvci5oCmluZGV4IGQ0MTI3ZmQuLjU5NTgwNzQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY2FuL2Vycm9yLmgKKysrIGIvaW5jbHVkZS9saW51eC9jYW4vZXJyb3IuaApAQCAtNTEsNyArNTEsNyBAQAogI2RlZmluZSBDQU5fRVJSX1BST1RfQklUMSAgICAgICAgMHgxMCAvKiB1bmFibGUgdG8gc2VuZCByZWNlc3NpdmUgYml0ICovCiAjZGVmaW5lIENBTl9FUlJfUFJPVF9PVkVSTE9BRCAgICAweDIwIC8qIGJ1cyBvdmVybG9hZCAqLwogI2RlZmluZSBDQU5fRVJSX1BST1RfQUNUSVZFICAgICAgMHg0MCAvKiBhY3RpdmUgZXJyb3IgYW5ub3VuY2VtZW50ICovCi0jZGVmaW5lIENBTl9FUlJfUFJPVF9UWCAgICAgICAgICAweDgwIC8qIGVycm9yIG9jY3VyZWQgb24gdHJhbnNtaXNzaW9uICovCisjZGVmaW5lIENBTl9FUlJfUFJPVF9UWCAgICAgICAgICAweDgwIC8qIGVycm9yIG9jY3VycmVkIG9uIHRyYW5zbWlzc2lvbiAqLwogCiAvKiBlcnJvciBpbiBDQU4gcHJvdG9jb2wgKGxvY2F0aW9uKSAvIGRhdGFbM10gKi8KICNkZWZpbmUgQ0FOX0VSUl9QUk9UX0xPQ19VTlNQRUMgIDB4MDAgLyogdW5zcGVjaWZpZWQgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY2FuL25ldGxpbmsuaCBiL2luY2x1ZGUvbGludXgvY2FuL25ldGxpbmsuaAppbmRleCAzMjUwZGU5Li4zNDU0MmQzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Nhbi9uZXRsaW5rLmgKKysrIGIvaW5jbHVkZS9saW51eC9jYW4vbmV0bGluay5oCkBAIC0xNyw3ICsxNyw3IEBACiAvKgogICogQ0FOIGJpdC10aW1pbmcgcGFyYW1ldGVycwogICoKLSAqIEZvciBmdXRoZXIgaW5mb3JtYXRpb24sIHBsZWFzZSByZWFkIGNoYXB0ZXIgIjggQklUIFRJTUlORworICogRm9yIGZ1cnRoZXIgaW5mb3JtYXRpb24sIHBsZWFzZSByZWFkIGNoYXB0ZXIgIjggQklUIFRJTUlORwogICogUkVRVUlSRU1FTlRTIiBvZiB0aGUgIkJvc2NoIENBTiBTcGVjaWZpY2F0aW9uIHZlcnNpb24gMi4wIgogICogYXQgaHR0cDovL3d3dy5zZW1pY29uZHVjdG9ycy5ib3NjaC5kZS9wZGYvY2FuMnNwZWMucGRmLgogICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Nhbi9wbGF0Zm9ybS9tY3AyNTF4LmggYi9pbmNsdWRlL2xpbnV4L2Nhbi9wbGF0Zm9ybS9tY3AyNTF4LmgKaW5kZXggOGUyMDU0MC4uMDg5ZmU0MyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9jYW4vcGxhdGZvcm0vbWNwMjUxeC5oCisrKyBiL2luY2x1ZGUvbGludXgvY2FuL3BsYXRmb3JtL21jcDI1MXguaApAQCAtMTIsNiArMTIsNyBAQAogLyoqCiAgKiBzdHJ1Y3QgbWNwMjUxeF9wbGF0Zm9ybV9kYXRhIC0gTUNQMjUxWCBTUEkgQ0FOIGNvbnRyb2xsZXIgcGxhdGZvcm0gZGF0YQogICogQG9zY2lsbGF0b3JfZnJlcXVlbmN5OiAgICAgICAtIG9zY2lsbGF0b3IgZnJlcXVlbmN5IGluIEh6CisgKiBAaXJxX2ZsYWdzOiAgICAgICAgICAgICAgICAgIC0gSVJRRiBjb25maWd1cmF0aW9uIGZsYWdzCiAgKiBAYm9hcmRfc3BlY2lmaWNfc2V0dXA6ICAgICAgIC0gY2FsbGVkIGJlZm9yZSBwcm9iaW5nIHRoZSBjaGlwIChwb3dlcixyZXNldCkKICAqIEB0cmFuc2NlaXZlcl9lbmFibGU6ICAgICAgICAgLSBjYWxsZWQgdG8gcG93ZXIgb24vb2ZmIHRoZSB0cmFuc2NlaXZlcgogICogQHBvd2VyX2VuYWJsZTogICAgICAgICAgICAgICAtIGNhbGxlZCB0byBwb3dlciBvbi9vZmYgdGhlIG1jcCAqYW5kKiB0aGUKQEAgLTI0LDYgKzI1LDcgQEAKIAogc3RydWN0IG1jcDI1MXhfcGxhdGZvcm1fZGF0YSB7CiAJdW5zaWduZWQgbG9uZyBvc2NpbGxhdG9yX2ZyZXF1ZW5jeTsKKwl1bnNpZ25lZCBsb25nIGlycV9mbGFnczsKIAlpbnQgKCpib2FyZF9zcGVjaWZpY19zZXR1cCkoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSk7CiAJaW50ICgqdHJhbnNjZWl2ZXJfZW5hYmxlKShpbnQgZW5hYmxlKTsKIAlpbnQgKCpwb3dlcl9lbmFibGUpIChpbnQgZW5hYmxlKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY2RrLmggYi9pbmNsdWRlL2xpbnV4L2Nkay5oCmluZGV4IDA5MDhkYWYuLjgwMDkzYTggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY2RrLmgKKysrIGIvaW5jbHVkZS9saW51eC9jZGsuaApAQCAtMTQ5LDcgKzE0OSw3IEBACiAvKgogICoJRGVmaW5lIHRoZSBtZW1vcnkgbWFwcGluZyBzdHJ1Y3R1cmUuIFRoaXMgc3RydWN0dXJlIGlzIHBvaW50ZWQgdG8gYnkKICAqCXRoZSBtZW1wIGZpZWxkIGluIHRoZSBzdGxjZGtoZHIgc3RydWN0LiBBcyBtYW55IGFzIHRoZXNlIHN0cnVjdHVyZXMKLSAqCWFzIHJlcXVpcmVkIGFyZSBsYXllZCBvdXQgaW4gc2hhcmVkIG1lbW9yeSB0byBkZWZpbmUgaG93IHRoZSByZXN0IG9mCisgKglhcyByZXF1aXJlZCBhcmUgbGFpZCBvdXQgaW4gc2hhcmVkIG1lbW9yeSB0byBkZWZpbmUgaG93IHRoZSByZXN0IG9mCiAgKglzaGFyZWQgbWVtb3J5IGlzIGRpdmlkZWQgdXAuIFRoZXJlIHdpbGwgYmUgb25lIGZvciBlYWNoIHBvcnQuCiAgKi8KIHR5cGVkZWYgc3RydWN0IGNka21lbSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NmYWcxMjg2NGIuaCBiL2luY2x1ZGUvbGludXgvY2ZhZzEyODY0Yi5oCmluZGV4IDZmOWYxOWQuLmI0NTRkZmMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY2ZhZzEyODY0Yi5oCisrKyBiL2luY2x1ZGUvbGludXgvY2ZhZzEyODY0Yi5oCkBAIC00NCw3ICs0NCw3IEBACiAvKgogICogR2V0IHRoZSByZWZyZXNoIHJhdGUgb2YgdGhlIExDRAogICoKLSAqIFJldHVybnMgdGhlIHJlZnJlc2ggcmF0ZSAoaGVydHpzKS4KKyAqIFJldHVybnMgdGhlIHJlZnJlc2ggcmF0ZSAoaGVydHopLgogICovCiBleHRlcm4gdW5zaWduZWQgaW50IGNmYWcxMjg2NGJfZ2V0cmF0ZSh2b2lkKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9jZ3JvdXAuaCBiL2luY2x1ZGUvbGludXgvY2dyb3VwLmgKaW5kZXggZTY1NGZhMi4uNWFjN2ViYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9jZ3JvdXAuaAorKysgYi9pbmNsdWRlL2xpbnV4L2Nncm91cC5oCkBAIC0yNDAsNyArMjQwLDcgQEAKIAkvKiBGb3IgUkNVLXByb3RlY3RlZCBkZWxldGlvbiAqLwogCXN0cnVjdCByY3VfaGVhZCByY3VfaGVhZDsKIAotCS8qIExpc3Qgb2YgZXZlbnRzIHdoaWNoIHVzZXJzcGFjZSB3YW50IHRvIHJlY2lldmUgKi8KKwkvKiBMaXN0IG9mIGV2ZW50cyB3aGljaCB1c2Vyc3BhY2Ugd2FudCB0byByZWNlaXZlICovCiAJc3RydWN0IGxpc3RfaGVhZCBldmVudF9saXN0OwogCXNwaW5sb2NrX3QgZXZlbnRfbGlzdF9sb2NrOwogfTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY200MDAwX2NzLmggYi9pbmNsdWRlL2xpbnV4L2NtNDAwMF9jcy5oCmluZGV4IDcyYmZlZmQuLjNjNGFhYzQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY200MDAwX2NzLmgKKysrIGIvaW5jbHVkZS9saW51eC9jbTQwMDBfY3MuaApAQCAtMjAsNyArMjAsNyBAQAogfSBhdHJlcV90OwogCiAKLS8qIHdoYXQgaXMgcGFydGljdWxhcmx5IHN0dXBpZCBpbiB0aGUgb3JpZ2luYWwgZHJpdmVyIGlzIHRoZSBhcmNoLWRlcGVuZGFudAorLyogd2hhdCBpcyBwYXJ0aWN1bGFybHkgc3R1cGlkIGluIHRoZSBvcmlnaW5hbCBkcml2ZXIgaXMgdGhlIGFyY2gtZGVwZW5kZW50CiAgKiBtZW1iZXIgc2l6ZXMuIFRoaXMgbGVhZHMgdG8gQ09ORklHX0NPTVBBVCBicmVha2FnZSwgc2luY2UgMzJiaXQgdXNlcnNwYWNlCiAgKiB3aWxsIGxheSBvdXQgdGhlIHN0cnVjdHVyZSBtZW1iZXJzIGRpZmZlcmVudGx5IHRoYW4gdGhlIDY0Yml0IGtlcm5lbC4KICAqCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbmZpZ2ZzLmggYi9pbmNsdWRlL2xpbnV4L2NvbmZpZ2ZzLmgKaW5kZXggZGRiN2E5Ny4uNjQ1Nzc4YSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9jb25maWdmcy5oCisrKyBiL2luY2x1ZGUvbGludXgvY29uZmlnZnMuaApAQCAtMjE4LDcgKzIxOCw3IEBACiAgKiBncm91cCBjaGlsZHJlbi4gIGRlZmF1bHRfZ3JvdXBzIG1heSBjb2V4aXN0IGFsb25nc2l6ZSBtYWtlX2dyb3VwKCkgb3IKICAqIG1ha2VfaXRlbSgpLCBidXQgaWYgdGhlIGdyb3VwIHdpc2hlcyB0byBoYXZlIG9ubHkgZGVmYXVsdF9ncm91cHMKICAqIGNoaWxkcmVuIChkaXNhbGxvd2luZyBta2RpcigyKSksIGl0IG5lZWQgbm90IHByb3ZpZGUgZWl0aGVyIGZ1bmN0aW9uLgotICogSWYgdGhlIGdyb3VwIGhhcyBjb21taXQoKSwgaXQgc3VwcG9ydHMgcGVuZGluZyBhbmQgY29tbWl0ZWQgKGFjdGl2ZSkKKyAqIElmIHRoZSBncm91cCBoYXMgY29tbWl0KCksIGl0IHN1cHBvcnRzIHBlbmRpbmcgYW5kIGNvbW1pdHRlZCAoYWN0aXZlKQogICogaXRlbXMuCiAgKi8KIHN0cnVjdCBjb25maWdmc19pdGVtX29wZXJhdGlvbnMgewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9jcGVyLmggYi9pbmNsdWRlL2xpbnV4L2NwZXIuaAppbmRleCAzNzJhMjU4Li5jMjMwNDk0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2NwZXIuaAorKysgYi9pbmNsdWRlL2xpbnV4L2NwZXIuaApAQCAtMzEwLDcgKzMxMCw3IEBACiAJX191OAljcHVpZFs0OF07CiB9OwogCi0vKiBJQTMyL1g2NCBQcm9jZXNzb3IgRXJyb3IgSW5mb21hdGlvbiBTdHJ1Y3R1cmUgKi8KKy8qIElBMzIvWDY0IFByb2Nlc3NvciBFcnJvciBJbmZvcm1hdGlvbiBTdHJ1Y3R1cmUgKi8KIHN0cnVjdCBjcGVyX2lhX2Vycl9pbmZvIHsKIAl1dWlkX2xlCWVycl90eXBlOwogCV9fdTY0CXZhbGlkYXRpb25fYml0czsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZGVjb21wcmVzcy9tbS5oIGIvaW5jbHVkZS9saW51eC9kZWNvbXByZXNzL21tLmgKaW5kZXggNGNiNzJiOS4uNzkyNWJmMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9kZWNvbXByZXNzL21tLmgKKysrIGIvaW5jbHVkZS9saW51eC9kZWNvbXByZXNzL21tLmgKQEAgLTE2LDcgKzE2LDcgQEAKIAogLyoKICAqIFNvbWUgYXJjaGl0ZWN0dXJlcyB3YW50IHRvIGVuc3VyZSB0aGVyZSBpcyBubyBsb2NhbCBkYXRhIGluIHRoZWlyCi0gKiBwcmUtYm9vdCBlbnZpcm9ubWVudCwgc28gdGhhdCBkYXRhIGNhbiBhcmJpdGFyaWx5IHJlbG9jYXRlZCAodmlhCisgKiBwcmUtYm9vdCBlbnZpcm9ubWVudCwgc28gdGhhdCBkYXRhIGNhbiBhcmJpdHJhcmlseSByZWxvY2F0ZWQgKHZpYQogICogR09UIHJlZmVyZW5jZXMpLiAgVGhpcyBpcyBhY2hpZXZlZCBieSBkZWZpbmluZyBTVEFUSUNfUldfREFUQSB0bwogICogYmUgbnVsbC4KICAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWFlbmdpbmUuaCBiL2luY2x1ZGUvbGludXgvZG1hZW5naW5lLmgKaW5kZXggOWJlYmQ3Zi4uZWVlN2FkZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9kbWFlbmdpbmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L2RtYWVuZ2luZS5oCkBAIC00MzQsNyArNDM0LDcgQEAKICAqCXplcm8gb3IgZXJyb3IgY29kZQogICogQGRldmljZV90eF9zdGF0dXM6IHBvbGwgZm9yIHRyYW5zYWN0aW9uIGNvbXBsZXRpb24sIHRoZSBvcHRpb25hbAogICoJdHhzdGF0ZSBwYXJhbWV0ZXIgY2FuIGJlIHN1cHBsaWVkIHdpdGggYSBwb2ludGVyIHRvIGdldCBhCi0gKglzdHJ1Y3Qgd2l0aCBhdXhpbGFyeSB0cmFuc2ZlciBzdGF0dXMgaW5mb3JtYXRpb24sIG90aGVyd2lzZSB0aGUgY2FsbAorICoJc3RydWN0IHdpdGggYXV4aWxpYXJ5IHRyYW5zZmVyIHN0YXR1cyBpbmZvcm1hdGlvbiwgb3RoZXJ3aXNlIHRoZSBjYWxsCiAgKgl3aWxsIGp1c3QgcmV0dXJuIGEgc2ltcGxlIHN0YXR1cyBjb2RlCiAgKiBAZGV2aWNlX2lzc3VlX3BlbmRpbmc6IHB1c2ggcGVuZGluZyB0cmFuc2FjdGlvbnMgdG8gaGFyZHdhcmUKICAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kcmJkLmggYi9pbmNsdWRlL2xpbnV4L2RyYmQuaAppbmRleCBkMThkNjczLi5jZWM0NjdmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2RyYmQuaAorKysgYi9pbmNsdWRlL2xpbnV4L2RyYmQuaApAQCAtMzYsNyArMzYsNyBAQAogI2luY2x1ZGUgPHN5cy93YWl0Lmg+CiAjaW5jbHVkZSA8bGltaXRzLmg+CiAKLS8qIEFsdG91Z2ggdGhlIExpbnV4IHNvdXJjZSBjb2RlIG1ha2VzIGEgZGlmZmVyZW5jZSBiZXR3ZWVuCisvKiBBbHRob3VnaCB0aGUgTGludXggc291cmNlIGNvZGUgbWFrZXMgYSBkaWZmZXJlbmNlIGJldHdlZW4KICAgIGdlbmVyaWMgZW5kaWFubmVzcyBhbmQgdGhlIGJpdGZpZWxkcycgZW5kaWFubmVzcywgdGhlcmUgaXMgbm8KICAgIGFyY2hpdGVjdHVyZSBhcyBvZiBMaW51eC0yLjYuMjQtcmM0IHdoZXJlIHRoZSBiaXRmaWxlZHMnIGVuZGlhbm5lc3MKICAgIGRvZXMgbm90IG1hdGNoIHRoZSBnZW5lcmljIGVuZGlhbm5lc3MuICovCkBAIC0xODQsNyArMTg0LDcgQEAKIAkvKiBUaGVzZSB0ZW1wb3JhbCBzdGF0ZXMgYXJlIGFsbCB1c2VkIG9uIHRoZSB3YXkKIAkgKiBmcm9tID49IENfQ09OTkVDVEVEIHRvIFVuY29ubmVjdGVkLgogCSAqIFRoZSAnZGlzY29ubmVjdCByZWFzb24nIHN0YXRlcwotCSAqIEkgZG8gbm90IGFsbG93IHRvIGNoYW5nZSBiZXdlZW4gdGhlbS4gKi8KKwkgKiBJIGRvIG5vdCBhbGxvdyB0byBjaGFuZ2UgYmV0d2VlbiB0aGVtLiAqLwogCUNfVElNRU9VVCwKIAlDX0JST0tFTl9QSVBFLAogCUNfTkVUV09SS19GQUlMVVJFLApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kcmJkX2xpbWl0cy5oIGIvaW5jbHVkZS9saW51eC9kcmJkX2xpbWl0cy5oCmluZGV4IGJiMjY0YTUuLjI0NmY1NzYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZHJiZF9saW1pdHMuaAorKysgYi9pbmNsdWRlL2xpbnV4L2RyYmRfbGltaXRzLmgKQEAgLTQzLDcgKzQzLDcgQEAKIAogLyogbmV0IHsgKi8KICAgLyogdGltZW91dCwgdW5pdCBjZW50aSBzZWNvbmRzCi0gICAqIG1vcmUgdGhhbiBvbmUgbWludXRlIHRpbWVvdXQgaXMgbm90IHVzZWZ1bGwgKi8KKyAgICogbW9yZSB0aGFuIG9uZSBtaW51dGUgdGltZW91dCBpcyBub3QgdXNlZnVsICovCiAjZGVmaW5lIERSQkRfVElNRU9VVF9NSU4gMQogI2RlZmluZSBEUkJEX1RJTUVPVVRfTUFYIDYwMAogI2RlZmluZSBEUkJEX1RJTUVPVVRfREVGIDYwICAgICAgIC8qIDYgc2Vjb25kcyAqLwpAQCAtNjgsNyArNjgsNyBAQAogI2RlZmluZSBEUkJEX01BWF9FUE9DSF9TSVpFX01BWCAyMDAwMAogI2RlZmluZSBEUkJEX01BWF9FUE9DSF9TSVpFX0RFRiAyMDQ4CiAKLSAgLyogSSBkb24ndCB0aGluayB0aGF0IGEgdGNwIHNlbmQgYnVmZmVyIG9mIG1vcmUgdGhhbiAxME0gaXMgdXNlZnVsbCAqLworICAvKiBJIGRvbid0IHRoaW5rIHRoYXQgYSB0Y3Agc2VuZCBidWZmZXIgb2YgbW9yZSB0aGFuIDEwTSBpcyB1c2VmdWwgKi8KICNkZWZpbmUgRFJCRF9TTkRCVUZfU0laRV9NSU4gIDAKICNkZWZpbmUgRFJCRF9TTkRCVUZfU0laRV9NQVggICgxMDw8MjApCiAjZGVmaW5lIERSQkRfU05EQlVGX1NJWkVfREVGICAwCkBAIC0xMDEsNyArMTAxLDcgQEAKICNkZWZpbmUgRFJCRF9SQVRFX01BWCAoNCA8PCAyMCkKICNkZWZpbmUgRFJCRF9SQVRFX0RFRiAyNTAgIC8qIGtiL3NlY29uZCAqLwogCi0gIC8qIGxlc3MgdGhhbiA3IHdvdWxkIGhpdCBwZXJmb3JtYW5jZSB1bm5lY2Nlc3NhcmlseS4KKyAgLyogbGVzcyB0aGFuIDcgd291bGQgaGl0IHBlcmZvcm1hbmNlIHVubmVjZXNzYXJpbHkuCiAgICAqIDM4MzMgaXMgdGhlIGxhcmdlc3QgcHJpbWUgdGhhdCBzdGlsbCBkb2VzIGZpdAogICAgKiBpbnRvIDY0IHNlY3RvcnMgb2YgYWN0aXZpdHkgbG9nICovCiAjZGVmaW5lIERSQkRfQUxfRVhURU5UU19NSU4gIDcKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZXRodG9vbC5oIGIvaW5jbHVkZS9saW51eC9ldGh0b29sLmgKaW5kZXggYzhmY2JkZC4uZGM4MGQ4MiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ldGh0b29sLmgKKysrIGIvaW5jbHVkZS9saW51eC9ldGh0b29sLmgKQEAgLTYxNCw3ICs2MTQsNyBAQAogICogdmFsdWVzIG9mIGNvcnJlc3BvbmRpbmcgYml0cyBpbiBmZWF0dXJlc1tdLnJlcXVlc3RlZC4gQml0cyBpbiAucmVxdWVzdGVkCiAgKiBub3Qgc2V0IGluIC52YWxpZCBvciBub3QgY2hhbmdlYWJsZSBhcmUgaWdub3JlZC4KICAqCi0gKiBSZXR1cm5zICVFSU5WQUwgd2hlbiAudmFsaWQgY29udGFpbnMgdW5kZWZpbmVkIG9yIG5ldmVyLWNoYW5nYWJsZSBiaXRzCisgKiBSZXR1cm5zICVFSU5WQUwgd2hlbiAudmFsaWQgY29udGFpbnMgdW5kZWZpbmVkIG9yIG5ldmVyLWNoYW5nZWFibGUgYml0cwogICogb3Igc2l6ZSBpcyBub3QgZXF1YWwgdG8gcmVxdWlyZWQgbnVtYmVyIG9mIGZlYXR1cmVzIHdvcmRzICgzMi1iaXQgYmxvY2tzKS4KICAqIFJldHVybnMgPj0gMCBpZiByZXF1ZXN0IHdhcyBjb21wbGV0ZWQ7IGJpdHMgc2V0IGluIHRoZSB2YWx1ZSBtZWFuOgogICogICAlRVRIVE9PTF9GX1VOU1VQUE9SVEVEIC0gdGhlcmUgd2VyZSBiaXRzIHNldCBpbiAudmFsaWQgdGhhdCBhcmUgbm90CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2V2ZW50cG9sbC5oIGIvaW5jbHVkZS9saW51eC9ldmVudHBvbGwuaAppbmRleCBmNjg1NmE1Li5mMzYyNzMzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2V2ZW50cG9sbC5oCisrKyBiL2luY2x1ZGUvbGludXgvZXZlbnRwb2xsLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogIGluY2x1ZGUvbGludXgvZXZlbnRwb2xsLmggKCBFZmZpY2VudCBldmVudCBwb2xsaW5nIGltcGxlbWVudGF0aW9uICkKKyAqICBpbmNsdWRlL2xpbnV4L2V2ZW50cG9sbC5oICggRWZmaWNpZW50IGV2ZW50IHBvbGxpbmcgaW1wbGVtZW50YXRpb24gKQogICogIENvcHlyaWdodCAoQykgMjAwMSwuLi4sMjAwNgkgRGF2aWRlIExpYmVuemkKICAqCiAgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZXhwb3J0ZnMuaCBiL2luY2x1ZGUvbGludXgvZXhwb3J0ZnMuaAppbmRleCAzM2E0MmYyLi4zYTRjZWY1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2V4cG9ydGZzLmgKKysrIGIvaW5jbHVkZS9saW51eC9leHBvcnRmcy5oCkBAIC0xMjAsNyArMTIwLDcgQEAKICAqIGVuY29kZV9maDoKICAqICAgIEBlbmNvZGVfZmggc2hvdWxkIHN0b3JlIGluIHRoZSBmaWxlIGhhbmRsZSBmcmFnbWVudCBAZmggKHVzaW5nIGF0IG1vc3QKICAqICAgIEBtYXhfbGVuIGJ5dGVzKSBpbmZvcm1hdGlvbiB0aGF0IGNhbiBiZSB1c2VkIGJ5IEBkZWNvZGVfZmggdG8gcmVjb3ZlciB0aGUKLSAqICAgIGZpbGUgcmVmZXJlZCB0byBieSB0aGUgJnN0cnVjdCBkZW50cnkgQGRlLiAgSWYgdGhlIEBjb25uZWN0YWJsZSBmbGFnIGlzCisgKiAgICBmaWxlIHJlZmVycmVkIHRvIGJ5IHRoZSAmc3RydWN0IGRlbnRyeSBAZGUuICBJZiB0aGUgQGNvbm5lY3RhYmxlIGZsYWcgaXMKICAqICAgIHNldCwgdGhlIGVuY29kZV9maCgpIHNob3VsZCBzdG9yZSBzdWZmaWNpZW50IGluZm9ybWF0aW9uIHNvIHRoYXQgYSBnb29kCiAgKiAgICBhdHRlbXB0IGNhbiBiZSBtYWRlIHRvIGZpbmQgbm90IG9ubHkgdGhlIGZpbGUgYnV0IGFsc28gaXQncyBwbGFjZSBpbiB0aGUKICAqICAgIGZpbGVzeXN0ZW0uICAgVGhpcyB0eXBpY2FsbHkgbWVhbnMgc3RvcmluZyBhIHJlZmVyZW5jZSB0byBkZS0+ZF9wYXJlbnQgaW4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZmIuaCBiL2luY2x1ZGUvbGludXgvZmIuaAppbmRleCBiMmEzNjM5Li5kZjcyOGMxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2ZiLmgKKysrIGIvaW5jbHVkZS9saW51eC9mYi5oCkBAIC01MzQsMTQgKzUzNCwxNCBAQAogI2RlZmluZSBGQl9FVkVOVF9HRVRfQ09OU09MRV9NQVAgICAgICAgIDB4MDcKIC8qICAgICAgQ09OU09MRS1TUEVDSUZJQzogc2V0IGNvbnNvbGUgdG8gZnJhbWVidWZmZXIgbWFwcGluZyAqLwogI2RlZmluZSBGQl9FVkVOVF9TRVRfQ09OU09MRV9NQVAgICAgICAgIDB4MDgKLS8qICAgICAgQSBoYXJkd2FyZSBkaXNwbGF5IGJsYW5rIGNoYW5nZSBvY2N1cmVkICovCisvKiAgICAgIEEgaGFyZHdhcmUgZGlzcGxheSBibGFuayBjaGFuZ2Ugb2NjdXJyZWQgKi8KICNkZWZpbmUgRkJfRVZFTlRfQkxBTksgICAgICAgICAgICAgICAgICAweDA5CiAvKiAgICAgIFByaXZhdGUgbW9kZWxpc3QgaXMgdG8gYmUgcmVwbGFjZWQgKi8KICNkZWZpbmUgRkJfRVZFTlRfTkVXX01PREVMSVNUICAgICAgICAgICAweDBBCiAvKglUaGUgcmVzb2x1dGlvbiBvZiB0aGUgcGFzc2VkIGluIGZiX2luZm8gYWJvdXQgdG8gY2hhbmdlIGFuZAogICAgICAgICBhbGwgdmMncyBzaG91bGQgYmUgY2hhbmdlZCAgICAgICAgICovCiAjZGVmaW5lIEZCX0VWRU5UX01PREVfQ0hBTkdFX0FMTAkweDBCCi0vKglBIHNvZnR3YXJlIGRpc3BsYXkgYmxhbmsgY2hhbmdlIG9jY3VyZWQgKi8KKy8qCUEgc29mdHdhcmUgZGlzcGxheSBibGFuayBjaGFuZ2Ugb2NjdXJyZWQgKi8KICNkZWZpbmUgRkJfRVZFTlRfQ09OQkxBTksgICAgICAgICAgICAgICAweDBDCiAvKiAgICAgIEdldCBkcmF3aW5nIHJlcXVpcmVtZW50cyAgICAgICAgKi8KICNkZWZpbmUgRkJfRVZFTlRfR0VUX1JFUSAgICAgICAgICAgICAgICAweDBECkBAIC04MDUsNyArODA1LDcgQEAKIC8qIEEgZHJpdmVyIG1heSBzZXQgdGhpcyBmbGFnIHRvIGluZGljYXRlIHRoYXQgaXQgZG9lcyB3YW50IGEgc2V0X3BhciB0byBiZQogICogY2FsbGVkIGV2ZXJ5IHRpbWUgd2hlbiBmYmNvbl9zd2l0Y2ggaXMgZXhlY3V0ZWQuIFRoZSBhZHZhbnRhZ2UgaXMgdGhhdCB3aXRoCiAgKiB0aGlzIGZsYWcgc2V0IHlvdSBjYW4gcmVhbGx5IGJlIHN1cmUgdGhhdCBzZXRfcGFyIGlzIGFsd2F5cyBjYWxsZWQgYmVmb3JlCi0gKiBhbnkgb2YgdGhlIGZ1bmN0aW9ucyBkZXBlbmRhbnQgb24gdGhlIGNvcnJlY3QgaGFyZHdhcmUgc3RhdGUgb3IgYWx0ZXJpbmcKKyAqIGFueSBvZiB0aGUgZnVuY3Rpb25zIGRlcGVuZGVudCBvbiB0aGUgY29ycmVjdCBoYXJkd2FyZSBzdGF0ZSBvciBhbHRlcmluZwogICogdGhhdCBzdGF0ZSwgZXZlbiBpZiB5b3UgYXJlIHVzaW5nIHNvbWUgYnJva2VuIFggcmVsZWFzZXMuIFRoZSBkaXNhZHZhbnRhZ2UKICAqIGlzIHRoYXQgaXQgaW50cm9kdWNlcyB1bndhbnRlZCBkZWxheXMgdG8gZXZlcnkgY29uc29sZSBzd2l0Y2ggaWYgc2V0X3BhcgogICogaXMgc2xvdy4gSXQgaXMgYSBnb29kIGlkZWEgdG8gdHJ5IHRoaXMgZmxhZyBpbiB0aGUgZHJpdmVycyBpbml0aWFsaXphdGlvbgpAQCAtODc3LDcgKzg3Nyw3IEBACiAJdm9pZCAqZmJjb25fcGFyOyAgICAgICAgICAgICAgICAvKiBmYmNvbiB1c2Utb25seSBwcml2YXRlIGFyZWEgKi8KIAkvKiBGcm9tIGhlcmUgb24gZXZlcnl0aGluZyBpcyBkZXZpY2UgZGVwZW5kZW50ICovCiAJdm9pZCAqcGFyOwotCS8qIHdlIG5lZWQgdGhlIFBDSSBvciBzaW1pbGlhciBhcGVydHVyZSBiYXNlL3NpemUgbm90CisJLyogd2UgbmVlZCB0aGUgUENJIG9yIHNpbWlsYXIgYXBlcnR1cmUgYmFzZS9zaXplIG5vdAogCSAgIHNtZW1fc3RhcnQvc2l6ZSBhcyBzbWVtX3N0YXJ0IG1heSBqdXN0IGJlIGFuIG9iamVjdAogCSAgIGFsbG9jYXRlZCBpbnNpZGUgdGhlIGFwZXJ0dXJlIHNvIG1heSBub3QgYWN0dWFsbHkgb3ZlcmxhcCAqLwogCXN0cnVjdCBhcGVydHVyZXNfc3RydWN0IHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZmlyZXdpcmUtY2Rldi5oIGIvaW5jbHVkZS9saW51eC9maXJld2lyZS1jZGV2LmgKaW5kZXggNTllYTQwNi4uNGZmMDk4OCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9maXJld2lyZS1jZGV2LmgKKysrIGIvaW5jbHVkZS9saW51eC9maXJld2lyZS1jZGV2LmgKQEAgLTkwMCw3ICs5MDAsNyBAQAogCiAvKioKICAqIHN0cnVjdCBmd19jZGV2X2FsbG9jYXRlX2lzb19yZXNvdXJjZSAtIChEZSlhbGxvY2F0ZSBhIGNoYW5uZWwgb3IgYmFuZHdpZHRoCi0gKiBAY2xvc3VyZToJUGFzc2VkIGJhY2sgdG8gdXNlcnNwYWNlIGluIGNvcnJlcG9uZGluZyBpc28gcmVzb3VyY2UgZXZlbnRzCisgKiBAY2xvc3VyZToJUGFzc2VkIGJhY2sgdG8gdXNlcnNwYWNlIGluIGNvcnJlc3BvbmRpbmcgaXNvIHJlc291cmNlIGV2ZW50cwogICogQGNoYW5uZWxzOglJc29jaHJvbm91cyBjaGFubmVscyBvZiB3aGljaCBvbmUgaXMgdG8gYmUgKGRlKWFsbG9jYXRlZAogICogQGJhbmR3aWR0aDoJSXNvY2hyb25vdXMgYmFuZHdpZHRoIHVuaXRzIHRvIGJlIChkZSlhbGxvY2F0ZWQKICAqIEBoYW5kbGU6CUhhbmRsZSB0byB0aGUgYWxsb2NhdGlvbiwgd3JpdHRlbiBieSB0aGUga2VybmVsIChvbmx5IHZhbGlkIGluCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ZzLmggYi9pbmNsdWRlL2xpbnV4L2ZzLmgKaW5kZXggMWI5NWFmMy4uZGJkODYwYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9mcy5oCisrKyBiL2luY2x1ZGUvbGludXgvZnMuaApAQCAtNDY1LDcgKzQ2NSw3IEBACiAJc3RydWN0IHRpbWVzcGVjCWlhX2N0aW1lOwogCiAJLyoKLQkgKiBOb3QgYW4gYXR0cmlidXRlLCBidXQgYW4gYXV4aWxhcnkgaW5mbyBmb3IgZmlsZXN5c3RlbXMgd2FudGluZyB0bworCSAqIE5vdCBhbiBhdHRyaWJ1dGUsIGJ1dCBhbiBhdXhpbGlhcnkgaW5mbyBmb3IgZmlsZXN5c3RlbXMgd2FudGluZyB0bwogCSAqIGltcGxlbWVudCBhbiBmdHJ1bmNhdGUoKSBsaWtlIG1ldGhvZC4gIE5PVEU6IGZpbGVzeXN0ZW0gc2hvdWxkCiAJICogY2hlY2sgZm9yIChpYV92YWxpZCAmIEFUVFJfRklMRSksIGFuZCBub3QgZm9yIChpYV9maWxlICE9IE5VTEwpLgogCSAqLwpAQCAtNjQ5LDcgKzY0OSw3IEBACiB9IF9fYXR0cmlidXRlX18oKGFsaWduZWQoc2l6ZW9mKGxvbmcpKSkpOwogCS8qCiAJICogT24gbW9zdCBhcmNoaXRlY3R1cmVzIHRoYXQgYWxpZ25tZW50IGlzIGFscmVhZHkgdGhlIGNhc2U7IGJ1dAotCSAqIG11c3QgYmUgZW5mb3JjZWQgaGVyZSBmb3IgQ1JJUywgdG8gbGV0IHRoZSBsZWFzdCBzaWduZmljYW50IGJpdAorCSAqIG11c3QgYmUgZW5mb3JjZWQgaGVyZSBmb3IgQ1JJUywgdG8gbGV0IHRoZSBsZWFzdCBzaWduaWZpY2FudCBiaXQKIAkgKiBvZiBzdHJ1Y3QgcGFnZSdzICJtYXBwaW5nIiBwb2ludGVyIGJlIHVzZWQgZm9yIFBBR0VfTUFQUElOR19BTk9OLgogCSAqLwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ZzY2FjaGUtY2FjaGUuaCBiL2luY2x1ZGUvbGludXgvZnNjYWNoZS1jYWNoZS5oCmluZGV4IGI4NTgxYzAuLjc2NDI3ZTYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZnNjYWNoZS1jYWNoZS5oCisrKyBiL2luY2x1ZGUvbGludXgvZnNjYWNoZS1jYWNoZS5oCkBAIC0yMzYsNyArMjM2LDcgQEAKIAkvKiB1bnBpbiBhbiBvYmplY3QgaW4gdGhlIGNhY2hlICovCiAJdm9pZCAoKnVucGluX29iamVjdCkoc3RydWN0IGZzY2FjaGVfb2JqZWN0ICpvYmplY3QpOwogCi0JLyogc3RvcmUgdGhlIHVwZGF0ZWQgYXV4aWxsaWFyeSBkYXRhIG9uIGFuIG9iamVjdCAqLworCS8qIHN0b3JlIHRoZSB1cGRhdGVkIGF1eGlsaWFyeSBkYXRhIG9uIGFuIG9iamVjdCAqLwogCXZvaWQgKCp1cGRhdGVfb2JqZWN0KShzdHJ1Y3QgZnNjYWNoZV9vYmplY3QgKm9iamVjdCk7CiAKIAkvKiBkaXNjYXJkIHRoZSByZXNvdXJjZXMgcGlubmVkIGJ5IGFuIG9iamVjdCBhbmQgZWZmZWN0IHJldGlyZW1lbnQgaWYKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZnNjYWNoZS5oIGIvaW5jbHVkZS9saW51eC9mc2NhY2hlLmgKaW5kZXggZWMwZGFkNS4uN2M0ZDcyZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9mc2NhY2hlLmgKKysrIGIvaW5jbHVkZS9saW51eC9mc2NhY2hlLmgKQEAgLTEwMiw5ICsxMDIsOSBAQAogCSAqLwogCXZvaWQgKCpnZXRfYXR0cikoY29uc3Qgdm9pZCAqY29va2llX25ldGZzX2RhdGEsIHVpbnQ2NF90ICpzaXplKTsKIAotCS8qIGdldCB0aGUgYXV4aWxsaWFyeSBkYXRhIGZyb20gbmV0ZnMgZGF0YQorCS8qIGdldCB0aGUgYXV4aWxpYXJ5IGRhdGEgZnJvbSBuZXRmcyBkYXRhCiAJICogLSB0aGlzIGZ1bmN0aW9uIGNhbiBiZSBhYnNlbnQgaWYgdGhlIGluZGV4IGNhcnJpZXMgbm8gc3RhdGUgZGF0YQotCSAqIC0gc2hvdWxkIHN0b3JlIHRoZSBhdXhpbGxpYXJ5IGRhdGEgaW4gdGhlIGJ1ZmZlcgorCSAqIC0gc2hvdWxkIHN0b3JlIHRoZSBhdXhpbGlhcnkgZGF0YSBpbiB0aGUgYnVmZmVyCiAJICogLSBzaG91bGQgcmV0dXJuIHRoZSBhbW91bnQgb2YgYW1vdW50IHN0b3JlZAogCSAqIC0gbm90IHBlcm1pdHRlZCB0byByZXR1cm4gYW4gZXJyb3IKIAkgKiAtIHRoZSBuZXRmcyBkYXRhIGZyb20gdGhlIGNvb2tpZSBiZWluZyB1c2VkIGFzIHRoZSBzb3VyY2UgaXMKQEAgLTExNyw3ICsxMTcsNyBAQAogCS8qIGNvbnN1bHQgdGhlIG5ldGZzIGFib3V0IHRoZSBzdGF0ZSBvZiBhbiBvYmplY3QKIAkgKiAtIHRoaXMgZnVuY3Rpb24gY2FuIGJlIGFic2VudCBpZiB0aGUgaW5kZXggY2FycmllcyBubyBzdGF0ZSBkYXRhCiAJICogLSB0aGUgbmV0ZnMgZGF0YSBmcm9tIHRoZSBjb29raWUgYmVpbmcgdXNlZCBhcyB0aGUgdGFyZ2V0IGlzCi0JICogICBwcmVzZW50ZWQsIGFzIGlzIHRoZSBhdXhpbGxpYXJ5IGRhdGEKKwkgKiAgIHByZXNlbnRlZCwgYXMgaXMgdGhlIGF1eGlsaWFyeSBkYXRhCiAJICovCiAJZW51bSBmc2NhY2hlX2NoZWNrYXV4ICgqY2hlY2tfYXV4KSh2b2lkICpjb29raWVfbmV0ZnNfZGF0YSwKIAkJCQkJICAgY29uc3Qgdm9pZCAqZGF0YSwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaGlkLmggYi9pbmNsdWRlL2xpbnV4L2hpZC5oCmluZGV4IGJiMjliYjEuLjQyZjdlMmYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaGlkLmgKKysrIGIvaW5jbHVkZS9saW51eC9oaWQuaApAQCAtNzk5LDcgKzc5OSw3IEBACiAgKgogICogQ2FsbCB0aGlzIGluIHByb2JlIGZ1bmN0aW9uICphZnRlciogaGlkX3BhcnNlLiBUaGlzIHdpbGwgc2V0dXAgSFcgYnVmZmVycwogICogYW5kIHN0YXJ0IHRoZSBkZXZpY2UgKGlmIG5vdCBkZWZmZXJlZCB0byBkZXZpY2Ugb3BlbikuIGhpZF9od19zdG9wIG11c3QgYmUKLSAqIGNhbGxlZCBpZiB0aGlzIHdhcyBzdWNjZXNzZnVsbC4KKyAqIGNhbGxlZCBpZiB0aGlzIHdhcyBzdWNjZXNzZnVsLgogICovCiBzdGF0aWMgaW5saW5lIGludCBfX211c3RfY2hlY2sgaGlkX2h3X3N0YXJ0KHN0cnVjdCBoaWRfZGV2aWNlICpoZGV2LAogCQl1bnNpZ25lZCBpbnQgY29ubmVjdF9tYXNrKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9ocF9zZGMuaCBiL2luY2x1ZGUvbGludXgvaHBfc2RjLmgKaW5kZXggOWRiM2Q0NS4uZDM5Mjk3NSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ocF9zZGMuaAorKysgYi9pbmNsdWRlL2xpbnV4L2hwX3NkYy5oCkBAIC0xMDEsNyArMTAxLDcgQEAKICNkZWZpbmUgSFBfU0RDX1NUQVRVU19SRUcJMHg0MAkvKiBEYXRhIGZyb20gYW4gaTgwNDIgcmVnaXN0ZXIgKi8KICNkZWZpbmUgSFBfU0RDX1NUQVRVU19ISUxDTUQgICAgMHg1MAkvKiBDb21tYW5kIGZyb20gSElMIE1MQyAqLwogI2RlZmluZSBIUF9TRENfU1RBVFVTX0hJTERBVEEgICAweDYwCS8qIERhdGEgZnJvbSBISUwgTUxDICovCi0jZGVmaW5lIEhQX1NEQ19TVEFUVVNfUFVQCTB4NzAJLyogU3VjZXNzZnVsIHBvd2VyLXVwIHNlbGYgdGVzdCAqLworI2RlZmluZSBIUF9TRENfU1RBVFVTX1BVUAkweDcwCS8qIFN1Y2Nlc3NmdWwgcG93ZXItdXAgc2VsZiB0ZXN0ICovCiAjZGVmaW5lIEhQX1NEQ19TVEFUVVNfS0NPT0tFRAkweDgwCS8qIEtleSBmcm9tIGNvb2tlZCBrYmQgKi8KICNkZWZpbmUgSFBfU0RDX1NUQVRVU19LUlBHCTB4YzAJLyogS2V5IGZyb20gUmVwZWF0IEdlbiAqLwogI2RlZmluZSBIUF9TRENfU1RBVFVTX0tNT0RfU1VQCTB4MTAJLyogU2hpZnQga2V5IGlzIHVwICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2kyby5oIGIvaW5jbHVkZS9saW51eC9pMm8uaAppbmRleCA5ZTdhMTJkLi5hNmRlZWY0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2kyby5oCisrKyBiL2luY2x1ZGUvbGludXgvaTJvLmgKQEAgLTgyNiw3ICs4MjYsNyBAQAogICoJQGM6IEkyTyBjb250cm9sbGVyCiAgKgogICoJVGhpcyBmdW5jdGlvbiB0cmllcyB0byBnZXQgYSBtZXNzYWdlIGZyYW1lLiBJZiBubyBtZXNzYWdlIGZyYW1lIGlzCi0gKglhdmFpbGFibGUgZG8gbm90IHdhaXQgdW50aWwgb25lIGlzIGF2YWlsYWJlIChzZWUgYWxzbyBpMm9fbXNnX2dldF93YWl0KS4KKyAqCWF2YWlsYWJsZSBkbyBub3Qgd2FpdCB1bnRpbCBvbmUgaXMgYXZhaWxhYmxlIChzZWUgYWxzbyBpMm9fbXNnX2dldF93YWl0KS4KICAqCVRoZSByZXR1cm5lZCBwb2ludGVyIHRvIHRoZSBtZXNzYWdlIGZyYW1lIGlzIG5vdCBpbiBJL08gbWVtb3J5LCBpdCBpcwogICoJYWxsb2NhdGVkIGZyb20gYSBtZW1wb29sLiBCdXQgYmVjYXVzZSBhIE1GQSBpcyBhbGxvY2F0ZWQgZnJvbSB0aGUKICAqCWNvbnRyb2xsZXIgdG9vIGl0IGlzIGd1YXJhbnRlZWQgdGhhdCBpMm9fbXNnX3Bvc3QoKSB3aWxsIG5ldmVyIGZhaWwuCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ludGVycnVwdC5oIGIvaW5jbHVkZS9saW51eC9pbnRlcnJ1cHQuaAppbmRleCA5NDNjOWI1Li5iZWEwYWM3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2ludGVycnVwdC5oCisrKyBiL2luY2x1ZGUvbGludXgvaW50ZXJydXB0LmgKQEAgLTk4LDcgKzk4LDcgQEAKICAqIEBuZXh0Oglwb2ludGVyIHRvIHRoZSBuZXh0IGlycWFjdGlvbiBmb3Igc2hhcmVkIGludGVycnVwdHMKICAqIEBpcnE6CWludGVycnVwdCBudW1iZXIKICAqIEBkaXI6CXBvaW50ZXIgdG8gdGhlIHByb2MvaXJxL05OL25hbWUgZW50cnkKLSAqIEB0aHJlYWRfZm46CWludGVydXB0IGhhbmRsZXIgZnVuY3Rpb24gZm9yIHRocmVhZGVkIGludGVycnVwdHMKKyAqIEB0aHJlYWRfZm46CWludGVycnVwdCBoYW5kbGVyIGZ1bmN0aW9uIGZvciB0aHJlYWRlZCBpbnRlcnJ1cHRzCiAgKiBAdGhyZWFkOgl0aHJlYWQgcG9pbnRlciBmb3IgdGhyZWFkZWQgaW50ZXJydXB0cwogICogQHRocmVhZF9mbGFnczoJZmxhZ3MgcmVsYXRlZCB0byBAdGhyZWFkCiAgKiBAdGhyZWFkX21hc2s6CWJpdG1hc2sgZm9yIGtlZXBpbmcgdHJhY2sgb2YgQHRocmVhZCBhY3Rpdml0eQpAQCAtNDg0LDcgKzQ4NCw3IEBACiAgICBQcm9wZXJ0aWVzOgogICAgKiBJZiB0YXNrbGV0X3NjaGVkdWxlKCkgaXMgY2FsbGVkLCB0aGVuIHRhc2tsZXQgaXMgZ3VhcmFudGVlZAogICAgICB0byBiZSBleGVjdXRlZCBvbiBzb21lIGNwdSBhdCBsZWFzdCBvbmNlIGFmdGVyIHRoaXMuCi0gICAqIElmIHRoZSB0YXNrbGV0IGlzIGFscmVhZHkgc2NoZWR1bGVkLCBidXQgaXRzIGV4Y2VjdXRpb24gaXMgc3RpbGwgbm90CisgICAqIElmIHRoZSB0YXNrbGV0IGlzIGFscmVhZHkgc2NoZWR1bGVkLCBidXQgaXRzIGV4ZWN1dGlvbiBpcyBzdGlsbCBub3QKICAgICAgc3RhcnRlZCwgaXQgd2lsbCBiZSBleGVjdXRlZCBvbmx5IG9uY2UuCiAgICAqIElmIHRoaXMgdGFza2xldCBpcyBhbHJlYWR5IHJ1bm5pbmcgb24gYW5vdGhlciBDUFUgKG9yIHNjaGVkdWxlIGlzIGNhbGxlZAogICAgICBmcm9tIHRhc2tsZXQgaXRzZWxmKSwgaXQgaXMgcmVzY2hlZHVsZWQgZm9yIGxhdGVyLgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pcG1pLmggYi9pbmNsdWRlL2xpbnV4L2lwbWkuaAppbmRleCAwNDVmMmYyLi5jYTg1Y2Y4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2lwbWkuaAorKysgYi9pbmNsdWRlL2xpbnV4L2lwbWkuaApAQCAtMTExLDcgKzExMSw3IEBACiAgKiBBIExBTiBBZGRyZXNzLiAgVGhpcyBpcyBhbiBhZGRyZXNzIHRvL2Zyb20gYSBMQU4gaW50ZXJmYWNlIGJyaWRnZWQKICAqIGJ5IHRoZSBCTUMsIG5vdCBhbiBhZGRyZXNzIGFjdHVhbGx5IG91dCBvbiB0aGUgTEFOLgogICoKLSAqIEEgY29uY2lvdXMgZGVjaXNpb24gd2FzIG1hZGUgaGVyZSB0byBkZXZpYXRlIHNsaWdodGx5IGZyb20gdGhlIElQTUkKKyAqIEEgY29uc2Npb3VzIGRlY2lzaW9uIHdhcyBtYWRlIGhlcmUgdG8gZGV2aWF0ZSBzbGlnaHRseSBmcm9tIHRoZSBJUE1JCiAgKiBzcGVjLiAgV2UgZG8gbm90IHVzZSBycVNXSUQgYW5kIHJzU1dJRCBsaWtlIGl0IHNob3dzIGluIHRoZQogICogbWVzc2FnZS4gIEluc3RlYWQsIHdlIHVzZSByZW1vdGVfU1dJRCBhbmQgbG9jYWxfU1dJRC4gIFRoaXMgbWVhbnMKICAqIHRoYXQgYW55IG1lc3NhZ2UgKGEgcmVxdWVzdCBvciByZXNwb25zZSkgZnJvbSBhbm90aGVyIGRldmljZSB3aWxsCkBAIC0yNTksNyArMjU5LDcgQEAKIAl2b2lkICgqZG9uZSkoc3RydWN0IGlwbWlfcmVjdl9tc2cgKm1zZyk7CiAKIAkvKiBQbGFjZS1ob2xkZXIgZm9yIHRoZSBkYXRhLCBkb24ndCBtYWtlIGFueSBhc3N1bXB0aW9ucyBhYm91dAotCSAgIHRoZSBzaXplIG9yIGV4aXN0YW5jZSBvZiB0aGlzLCBzaW5jZSBpdCBtYXkgY2hhbmdlLiAqLworCSAgIHRoZSBzaXplIG9yIGV4aXN0ZW5jZSBvZiB0aGlzLCBzaW5jZSBpdCBtYXkgY2hhbmdlLiAqLwogCXVuc2lnbmVkIGNoYXIgICBtc2dfZGF0YVtJUE1JX01BWF9NU0dfTEVOR1RIXTsKIH07CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaXNkbi9oZGxjLmggYi9pbmNsdWRlL2xpbnV4L2lzZG4vaGRsYy5oCmluZGV4IDRiM2VjYzQuLjk2NTIxMzcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaXNkbi9oZGxjLmgKKysrIGIvaW5jbHVkZS9saW51eC9pc2RuL2hkbGMuaApAQCAtMiw3ICsyLDcgQEAKICAqIGhkbGMuaCAgLS0gIEdlbmVyYWwgcHVycG9zZSBJU0ROIEhETEMgZGVjb2Rlci4KICAqCiAgKiBJbXBsZW1lbnRhdGlvbiBvZiBhIEhETEMgZGVjb2Rlci9lbmNvZGVyIGluIHNvZnR3YXJlLgotICogTmVjY2Vzc2FyeSBiZWNhdXNlIHNvbWUgSVNETiBkZXZpY2VzIGRvbid0IGhhdmUgSERMQworICogTmVjZXNzYXJ5IGJlY2F1c2Ugc29tZSBJU0ROIGRldmljZXMgZG9uJ3QgaGF2ZSBIRExDCiAgKiBjb250cm9sbGVycy4KICAqCiAgKiBDb3B5cmlnaHQgKEMpCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2l4anVzZXIuaCBiL2luY2x1ZGUvbGludXgvaXhqdXNlci5oCmluZGV4IDg4YjQ1ODkuLjk0YWI1ZTkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaXhqdXNlci5oCisrKyBiL2luY2x1ZGUvbGludXgvaXhqdXNlci5oCkBAIC01MCw3ICs1MCw3IEBACiAqIElPQ1RMJ3MgdXNlZCBmb3IgdGhlIFF1aWNrbmV0IFRlbGVwaG9ueSBDYXJkcwogKgogKiBJZiB5b3UgdXNlIHRoZSBJWEpDVExfVEVTVFJBTSBjb21tYW5kLCB0aGUgY2FyZCBtdXN0IGJlIHBvd2VyIGN5Y2xlZCB0bwotKiByZXNldCB0aGUgU1JBTSB2YWx1ZXMgYmVmb3JlIGZ1dGhlciB1c2UuCisqIHJlc2V0IHRoZSBTUkFNIHZhbHVlcyBiZWZvcmUgZnVydGhlciB1c2UuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvamlmZmllcy5oIGIvaW5jbHVkZS9saW51eC9qaWZmaWVzLmgKaW5kZXggOTIyYWEzMS4uZjk3NjcyYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9qaWZmaWVzLmgKKysrIGIvaW5jbHVkZS9saW51eC9qaWZmaWVzLmgKQEAgLTQyLDcgKzQyLDcgQEAKIC8qIExBVENIIGlzIHVzZWQgaW4gdGhlIGludGVydmFsIHRpbWVyIGFuZCBmdGFwZSBzZXR1cC4gKi8KICNkZWZpbmUgTEFUQ0ggICgoQ0xPQ0tfVElDS19SQVRFICsgSFovMikgLyBIWikJLyogRm9yIGRpdmlkZXIgKi8KIAotLyogU3VwcG9zZSB3ZSB3YW50IHRvIGRldmlkZSB0d28gbnVtYmVycyBOT00gYW5kIERFTjogTk9NL0RFTiwgdGhlbiB3ZSBjYW4KKy8qIFN1cHBvc2Ugd2Ugd2FudCB0byBkaXZpZGUgdHdvIG51bWJlcnMgTk9NIGFuZCBERU46IE5PTS9ERU4sIHRoZW4gd2UgY2FuCiAgKiBpbXByb3ZlIGFjY3VyYWN5IGJ5IHNoaWZ0aW5nIExTSCBiaXRzLCBoZW5jZSBjYWxjdWxhdGluZzoKICAqICAgICAoTk9NIDw8IExTSCkgLyBERU4KICAqIFRoaXMgaG93ZXZlciBtZWFucyB0cm91YmxlIGZvciBsYXJnZSBOT00sIGJlY2F1c2UgKE5PTSA8PCBMU0gpIG1heSBubwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9rdGltZS5oIGIvaW5jbHVkZS9saW51eC9rdGltZS5oCmluZGV4IGUxY2VhYTkuLjYwM2JlYzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva3RpbWUuaAorKysgYi9pbmNsdWRlL2xpbnV4L2t0aW1lLmgKQEAgLTM1LDcgKzM1LDcgQEAKICAqCiAgKiBPbiAzMi1iaXQgQ1BVcyBhbiBvcHRpbWl6ZWQgcmVwcmVzZW50YXRpb24gb2YgdGhlIHRpbWVzcGVjIHN0cnVjdHVyZQogICogaXMgdXNlZCB0byBhdm9pZCBleHBlbnNpdmUgY29udmVyc2lvbnMgZnJvbSBhbmQgdG8gdGltZXNwZWNzLiBUaGUKLSAqIGVuZGlhbi1hd2FyZSBvcmRlciBvZiB0aGUgdHYgc3RydWN0IG1lbWJlcnMgaXMgY2hvb3NlbiB0byBhbGxvdworICogZW5kaWFuLWF3YXJlIG9yZGVyIG9mIHRoZSB0diBzdHJ1Y3QgbWVtYmVycyBpcyBjaG9zZW4gdG8gYWxsb3cKICAqIG1hdGhlbWF0aWNhbCBvcGVyYXRpb25zIG9uIHRoZSB0djY0IG1lbWJlciBvZiB0aGUgdW5pb24gdG9vLCB3aGljaAogICogZm9yIGNlcnRhaW4gb3BlcmF0aW9ucyBwcm9kdWNlcyBiZXR0ZXIgY29kZS4KICAqCkBAIC0xNTgsNyArMTU4LDcgQEAKICAqIEBsaHM6CW1pbnVlbmQKICAqIEByaHM6CXN1YnRyYWhlbmQKICAqCi0gKiBSZXR1cm5zIHRoZSByZW1haW5kZXIgb2YgdGhlIHN1YnN0cmFjdGlvbgorICogUmV0dXJucyB0aGUgcmVtYWluZGVyIG9mIHRoZSBzdWJ0cmFjdGlvbgogICovCiBzdGF0aWMgaW5saW5lIGt0aW1lX3Qga3RpbWVfc3ViKGNvbnN0IGt0aW1lX3QgbGhzLCBjb25zdCBrdGltZV90IHJocykKIHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbGVkLWxtMzUzMC5oIGIvaW5jbHVkZS9saW51eC9sZWQtbG0zNTMwLmgKaW5kZXggYmI2OWQyMC4uNTg1OTJmYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9sZWQtbG0zNTMwLmgKKysrIGIvaW5jbHVkZS9saW51eC9sZWQtbG0zNTMwLmgKQEAgLTQxLDcgKzQxLDcgQEAKICNkZWZpbmUgTE0zNTMwX1JBTVBfVElNRV84cwkJKDcpCiAKIC8qIEFMUyBSZXNpc3RvciBTZWxlY3QgKi8KLSNkZWZpbmUgTE0zNTMwX0FMU19JTVBEX1oJCSgweDAwKSAvKiBBTFMgSW1wZWRlbmNlICovCisjZGVmaW5lIExNMzUzMF9BTFNfSU1QRF9aCQkoMHgwMCkgLyogQUxTIEltcGVkYW5jZSAqLwogI2RlZmluZSBMTTM1MzBfQUxTX0lNUERfMTNfNTNrT2htCSgweDAxKQogI2RlZmluZSBMTTM1MzBfQUxTX0lNUERfOV8wMWtPaG0JKDB4MDIpCiAjZGVmaW5lIExNMzUzMF9BTFNfSU1QRF81XzQxa09obQkoMHgwMykKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbGliYXRhLmggYi9pbmNsdWRlL2xpbnV4L2xpYmF0YS5oCmluZGV4IGM3MWY0NjkuLjdmNjc1YWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbGliYXRhLmgKKysrIGIvaW5jbHVkZS9saW51eC9saWJhdGEuaApAQCAtMzY0LDcgKzM2NCw3IEBACiAJQVRBX0VIX0NNRF9USU1FT1VUX1RBQkxFX1NJWkUgPSA2LAogCiAJLyogSG9ya2FnZSB0eXBlcy4gTWF5IGJlIHNldCBieSBsaWJhdGEgb3IgY29udHJvbGxlciBvbiBkcml2ZXMKLQkgICAoc29tZSBob3JrYWdlIG1heSBiZSBkcml2ZS9jb250cm9sbGVyIHBhaXIgZGVwZW5kYW50ICovCisJICAgKHNvbWUgaG9ya2FnZSBtYXkgYmUgZHJpdmUvY29udHJvbGxlciBwYWlyIGRlcGVuZGVudCAqLwogCiAJQVRBX0hPUktBR0VfRElBR05PU1RJQwk9ICgxIDw8IDApLAkvKiBGYWlsZWQgYm9vdCBkaWFnICovCiAJQVRBX0hPUktBR0VfTk9ETUEJPSAoMSA8PCAxKSwJLyogRE1BIHByb2JsZW1zICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2xydV9jYWNoZS5oIGIvaW5jbHVkZS9saW51eC9scnVfY2FjaGUuaAppbmRleCA3OGZiZjI0Li42YTRmYWI3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2xydV9jYWNoZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbHJ1X2NhY2hlLmgKQEAgLTE0OCw3ICsxNDgsNyBAQAogICoKICAqIERSQkQgY3VycmVudGx5IChNYXkgMjAwOSkgb25seSB1c2VzIDYxIGVsZW1lbnRzIG9uIHRoZSByZXN5bmMgbHJ1X2NhY2hlCiAgKiAodG90YWwgbWVtb3J5IHVzYWdlIDIgcGFnZXMpLCBhbmQgdXAgdG8gMzgzMyBlbGVtZW50cyBvbiB0aGUgYWN0X2xvZwotICogbHJ1X2NhY2hlLCB0b3RhbGxpbmcgfjIxNSBrQiBmb3IgNjRiaXQgYXJjaGl0ZWNodHVyZSwgfjUzIHBhZ2VzLgorICogbHJ1X2NhY2hlLCB0b3RhbGxpbmcgfjIxNSBrQiBmb3IgNjRiaXQgYXJjaGl0ZWN0dXJlLCB+NTMgcGFnZXMuCiAgKgogICogV2UgdXN1YWxseSBkbyBub3QgYWN0dWFsbHkgZnJlZSB0aGVzZSBvYmplY3RzIGFnYWluLCBidXQgb25seSAicmVjeWNsZSIKICAqIHRoZW0sIGFzIHRoZSBjaGFuZ2UgImluZGV4OiAtb2xkX2xhYmVsLCArTENfRlJFRSIgd291bGQgbmVlZCBhIHRyYW5zYWN0aW9uCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21mZC93bTgzNTAvcG1pYy5oIGIvaW5jbHVkZS9saW51eC9tZmQvd204MzUwL3BtaWMuaAppbmRleCBlNzg2ZmU5Li41NzliNTBjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21mZC93bTgzNTAvcG1pYy5oCisrKyBiL2luY2x1ZGUvbGludXgvbWZkL3dtODM1MC9wbWljLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogcG1pYy5oICAtLSAgUG93ZXIgTWFuYWdtZW50IERyaXZlciBmb3IgV29sZnNvbiBXTTgzNTAgUE1JQworICogcG1pYy5oICAtLSAgUG93ZXIgTWFuYWdlbWVudCBEcml2ZXIgZm9yIFdvbGZzb24gV004MzUwIFBNSUMKICAqCiAgKiBDb3B5cmlnaHQgMjAwNyBXb2xmc29uIE1pY3JvZWxlY3Ryb25pY3MgUExDCiAgKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbS5oIGIvaW5jbHVkZS9saW51eC9tbS5oCmluZGV4IDc2MDZkN2QuLjY5MmRiYWUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW0uaAorKysgYi9pbmNsdWRlL2xpbnV4L21tLmgKQEAgLTYwOCw3ICs2MDgsNyBAQAogI2VuZGlmCiAKIC8qCi0gKiBEZWZpbmUgdGhlIGJpdCBzaGlmdHMgdG8gYWNjZXNzIGVhY2ggc2VjdGlvbi4gIEZvciBub24tZXhpc3RhbnQKKyAqIERlZmluZSB0aGUgYml0IHNoaWZ0cyB0byBhY2Nlc3MgZWFjaCBzZWN0aW9uLiAgRm9yIG5vbi1leGlzdGVudAogICogc2VjdGlvbnMgd2UgZGVmaW5lIHRoZSBzaGlmdCBhcyAwOyB0aGF0IHBsdXMgYSAwIG1hc2sgZW5zdXJlcwogICogdGhlIGNvbXBpbGVyIHdpbGwgb3B0aW1pc2UgYXdheSByZWZlcmVuY2UgdG8gdGhlbS4KICAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbWMvZHdfbW1jLmggYi9pbmNsdWRlL2xpbnV4L21tYy9kd19tbWMuaAppbmRleCBjMDIwN2E3Li5iZGQ3Y2VlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21tYy9kd19tbWMuaAorKysgYi9pbmNsdWRlL2xpbnV4L21tYy9kd19tbWMuaApAQCAtOTgsNyArOTgsNyBAQAogICogRVZFTlRfREFUQV9DT01QTEVURSBpcyBzZXQgaW4gQHBlbmRpbmdfZXZlbnRzLCBhbGwgZGF0YS1yZWxhdGVkCiAgKiBpbnRlcnJ1cHRzIG11c3QgYmUgZGlzYWJsZWQgYW5kIEBkYXRhX3N0YXR1cyB1cGRhdGVkIHdpdGggYQogICogc25hcHNob3Qgb2YgU1IuIFNpbWlsYXJseSwgYmVmb3JlIEVWRU5UX0NNRF9DT01QTEVURSBpcyBzZXQsIHRoZQotICogQ01EUkRZIGludGVydXB0IG11c3QgYmUgZGlzYWJsZWQgYW5kIEBjbWRfc3RhdHVzIHVwZGF0ZWQgd2l0aCBhCisgKiBDTURSRFkgaW50ZXJydXB0IG11c3QgYmUgZGlzYWJsZWQgYW5kIEBjbWRfc3RhdHVzIHVwZGF0ZWQgd2l0aCBhCiAgKiBzbmFwc2hvdCBvZiBTUiwgYW5kIGJlZm9yZSBFVkVOVF9YRkVSX0NPTVBMRVRFIGNhbiBiZSBzZXQsIHRoZQogICogYnl0ZXNfeGZlcmVkIGZpZWxkIG9mIEBkYXRhIG11c3QgYmUgd3JpdHRlbi4gVGhpcyBpcyBlbnN1cmVkIGJ5CiAgKiB1c2luZyBiYXJyaWVycy4KQEAgLTE3Miw3ICsxNzIsNyBAQAogI2RlZmluZSBEV19NQ0lfUVVJUktfSURNQUNfRFRPCQkJQklUKDApCiAvKiBkZWxheSBuZWVkZWQgYmV0d2VlbiByZXRyaWVzIG9uIHNvbWUgMi4xMWEgaW1wbGVtZW50YXRpb25zICovCiAjZGVmaW5lIERXX01DSV9RVUlSS19SRVRSWV9ERUxBWQkJQklUKDEpCi0vKiBIaWdoIFNwZWVkIENhcGFibGUgLSBTdXBwb3J0cyBIUyBjYXJkcyAodXB0byA1ME1IeikgKi8KKy8qIEhpZ2ggU3BlZWQgQ2FwYWJsZSAtIFN1cHBvcnRzIEhTIGNhcmRzICh1cCB0byA1ME1IeikgKi8KICNkZWZpbmUgRFdfTUNJX1FVSVJLX0hJR0hTUEVFRAkJCUJJVCgyKQogLyogVW5yZWxpYWJsZSBjYXJkIGRldGVjdGlvbiAqLwogI2RlZmluZSBEV19NQ0lfUVVJUktfQlJPS0VOX0NBUkRfREVURUNUSU9OCUJJVCgzKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tcm91dGU2LmggYi9pbmNsdWRlL2xpbnV4L21yb3V0ZTYuaAppbmRleCA5ZDJkZWIyLi5hMzc1OWNiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21yb3V0ZTYuaAorKysgYi9pbmNsdWRlL2xpbnV4L21yb3V0ZTYuaApAQCAtMjQ5LDcgKzI0OSw3IEBACiAgKiBTdHJ1Y3R1cmUgdXNlZCB0byBjb21tdW5pY2F0ZSBmcm9tIGtlcm5lbCB0byBtdWx0aWNhc3Qgcm91dGVyLgogICogV2UnbGwgb3ZlcmxheSB0aGUgc3RydWN0dXJlIG9udG8gYW4gTUxEIGhlYWRlciAobm90IGFuIElQdjYgaGVkZXIgbGlrZSBpZ21wbXNne30KICAqIHVzZWQgZm9yIElQdjQgaW1wbGVtZW50YXRpb24pLiBUaGlzIGlzIGJlY2F1c2UgdGhpcyBzdHJ1Y3R1cmUgd2lsbCBiZSBwYXNzZWQgdmlhIGFuCi0gKiBJUHY2IHJhdyBzb2NrZXQsIG9uIHdpY2ggYW4gYXBwbGljYXRpb24gd2lsbCBvbmx5IHJlY2VpdmVyIHRoZSBwYXlsb2FkIGkuZSB0aGUgZGF0YSBhZnRlcgorICogSVB2NiByYXcgc29ja2V0LCBvbiB3aGljaCBhbiBhcHBsaWNhdGlvbiB3aWxsIG9ubHkgcmVjZWl2ZXIgdGhlIHBheWxvYWQgaS5lIHRoZSBkYXRhIGFmdGVyCiAgKiB0aGUgSVB2NiBoZWFkZXIgYW5kIGFsbCB0aGUgZXh0ZW5zaW9uIGhlYWRlcnMuIChTZWUgc2VjdGlvbiAzIG9mIFJGQyAzNTQyKQogICovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXRkL2NmaS5oIGIvaW5jbHVkZS9saW51eC9tdGQvY2ZpLmgKaW5kZXggMGQ4MjNmMi4uZDI0OTI1NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdGQvY2ZpLmgKKysrIGIvaW5jbHVkZS9saW51eC9tdGQvY2ZpLmgKQEAgLTMwOCw3ICszMDgsNyBAQAogCQogCWFkZHIgPSAoY21kX29mcyAqIHR5cGUpICogaW50ZXJsZWF2ZTsKIAotCS8qIE1vZGlmeSB0aGUgdW5sb2NrIGFkZHJlc3MgaWYgd2UgYXJlIGluIGNvbXBhdGlibGl0eSBtb2RlLgorCS8qIE1vZGlmeSB0aGUgdW5sb2NrIGFkZHJlc3MgaWYgd2UgYXJlIGluIGNvbXBhdGliaWxpdHkgbW9kZS4KIAkgKiBGb3IgMTZiaXQgZGV2aWNlcyBvbiA4IGJpdCBidXNzZXMKIAkgKiBhbmQgMzJiaXQgZGV2aWNlcyBvbiAxNiBiaXQgYnVzc2VzCiAJICogc2V0IHRoZSBsb3cgYml0IG9mIHRoZSBhbHRlcm5hdGluZyBiaXQgc2VxdWVuY2Ugb2YgdGhlIGFkZHJlc3MuCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L210ZC9uYW5kLmggYi9pbmNsdWRlL2xpbnV4L210ZC9uYW5kLmgKaW5kZXggYWU2N2VmNS4uZDQ0MTkyNyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdGQvbmFuZC5oCisrKyBiL2luY2x1ZGUvbGludXgvbXRkL25hbmQuaApAQCAtNDE2LDkgKzQxNiw5IEBACiAgKiBAc2VsZWN0X2NoaXA6CVtSRVBMQUNFQUJMRV0gc2VsZWN0IGNoaXAgbnIKICAqIEBibG9ja19iYWQ6CQlbUkVQTEFDRUFCTEVdIGNoZWNrLCBpZiB0aGUgYmxvY2sgaXMgYmFkCiAgKiBAYmxvY2tfbWFya2JhZDoJW1JFUExBQ0VBQkxFXSBtYXJrIHRoZSBibG9jayBiYWQKLSAqIEBjbWRfY3RybDoJCVtCT0FSRFNQRUNJRklDXSBoYXJkd2FyZXNwZWNpZmljIGZ1bnRpb24gZm9yIGNvbnRyb2xsaW5nCisgKiBAY21kX2N0cmw6CQlbQk9BUkRTUEVDSUZJQ10gaGFyZHdhcmVzcGVjaWZpYyBmdW5jdGlvbiBmb3IgY29udHJvbGxpbmcKICAqCQkJQUxFL0NMRS9uQ0UuIEFsc28gdXNlZCB0byB3cml0ZSBjb21tYW5kIGFuZCBhZGRyZXNzCi0gKiBAaW5pdF9zaXplOgkJW0JPQVJEU1BFQ0lGSUNdIGhhcmR3YXJlc3BlY2lmaWMgZnVudGlvbiBmb3Igc2V0dGluZworICogQGluaXRfc2l6ZToJCVtCT0FSRFNQRUNJRklDXSBoYXJkd2FyZXNwZWNpZmljIGZ1bmN0aW9uIGZvciBzZXR0aW5nCiAgKgkJCW10ZC0+b29ic2l6ZSwgbXRkLT53cml0ZXNpemUgYW5kIHNvIG9uLgogICoJCQlAaWRfZGF0YSBjb250YWlucyB0aGUgOCBieXRlcyB2YWx1ZXMgb2YgTkFORF9DTURfUkVBRElELgogICoJCQlSZXR1cm4gd2l0aCB0aGUgYnVzIHdpZHRoLgpAQCAtNDM3LDcgKzQzNyw3IEBACiAgKiBAZXJhc2VfY21kOgkJW0lOVEVSTl0gZXJhc2UgY29tbWFuZCB3cml0ZSBmdW5jdGlvbiwgc2VsZWN0YWJsZSBkdWUKICAqCQkJdG8gQU5EIHN1cHBvcnQuCiAgKiBAc2Nhbl9iYnQ6CQlbUkVQTEFDRUFCTEVdIGZ1bmN0aW9uIHRvIHNjYW4gYmFkIGJsb2NrIHRhYmxlCi0gKiBAY2hpcF9kZWxheToJCVtCT0FSRFNQRUNJRklDXSBjaGlwIGRlcGVuZGVudCBkZWxheSBmb3IgdHJhbnNmZXJpbmcKKyAqIEBjaGlwX2RlbGF5OgkJW0JPQVJEU1BFQ0lGSUNdIGNoaXAgZGVwZW5kZW50IGRlbGF5IGZvciB0cmFuc2ZlcnJpbmcKICAqCQkJZGF0YSBmcm9tIGFycmF5IHRvIHJlYWQgcmVncyAodFIpLgogICogQHN0YXRlOgkJW0lOVEVSTl0gdGhlIGN1cnJlbnQgc3RhdGUgb2YgdGhlIE5BTkQgZGV2aWNlCiAgKiBAb29iX3BvaToJCXBvaXNvbiB2YWx1ZSBidWZmZXIKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXRkL3hpcC5oIGIvaW5jbHVkZS9saW51eC9tdGQveGlwLmgKaW5kZXggMzZlZmNiYS4uYWJlZDRkZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdGQveGlwLmgKKysrIGIvaW5jbHVkZS9saW51eC9tdGQveGlwLmgKQEAgLTUxLDcgKzUxLDcgQEAKICAqIAlyZXR1cm4gaW4gdXNlY3MgdGhlIGVsYXBzZWQgdGltZWJldHdlZW4gbm93IGFuZCB0aGUgcmVmZXJlbmNlIHggYXMKICAqIAlyZXR1cm5lZCBieSB4aXBfY3VycnRpbWUoKS4KICAqCi0gKiAJbm90ZSAxOiBjb252ZXJ0aW9uIHRvIHVzZWMgY2FuIGJlIGFwcHJveGltYXRlZCwgYXMgbG9uZyBhcyB0aGUKKyAqIAlub3RlIDE6IGNvbnZlcnNpb24gdG8gdXNlYyBjYW4gYmUgYXBwcm94aW1hdGVkLCBhcyBsb25nIGFzIHRoZQogICogCQlyZXR1cm5lZCB2YWx1ZSBpcyA8PSB0aGUgcmVhbCBlbGFwc2VkIHRpbWUuCiAgKiAJbm90ZSAyOiB0aGlzIHNob3VsZCBiZSBhYmxlIHRvIGNvcGUgd2l0aCBhIGZldyBzZWNvbmRzIHdpdGhvdXQKICAqIAkJb3ZlcmZsb3dpbmcuCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci5oIGIvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXIuaAppbmRleCBlZWVjMDBhLi43ZmE5NWRmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci5oCisrKyBiL2luY2x1ZGUvbGludXgvbmV0ZmlsdGVyLmgKQEAgLTI3MCw3ICsyNzAsOCBAQAogCQkJCQkgICAgdW5zaWduZWQgaW50IGRhdGFvZmYsCiAJCQkJCSAgICB1bnNpZ25lZCBpbnQgbGVuLAogCQkJCQkgICAgdV9pbnQ4X3QgcHJvdG9jb2wpOwotCWludAkJKCpyb3V0ZSkoc3RydWN0IGRzdF9lbnRyeSAqKmRzdCwgc3RydWN0IGZsb3dpICpmbCk7CisJaW50CQkoKnJvdXRlKShzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCBkc3RfZW50cnkgKipkc3QsCisJCQkJIHN0cnVjdCBmbG93aSAqZmwsIGJvb2wgc3RyaWN0KTsKIAl2b2lkCQkoKnNhdmVyb3V0ZSkoY29uc3Qgc3RydWN0IHNrX2J1ZmYgKnNrYiwKIAkJCQkgICAgIHN0cnVjdCBuZl9xdWV1ZV9lbnRyeSAqZW50cnkpOwogCWludAkJKCpyZXJvdXRlKShzdHJ1Y3Qgc2tfYnVmZiAqc2tiLApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0LmggYi9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci9pcHNldC9pcF9zZXQuaAppbmRleCBlYzMzM2Q4Li41YTI2MmUzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci9pcHNldC9pcF9zZXQuaAorKysgYi9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci9pcHNldC9pcF9zZXQuaApAQCAtMjkzLDcgKzI5Myw3IEBACiAJLyogTG9jayBwcm90ZWN0aW5nIHRoZSBzZXQgZGF0YSAqLwogCXJ3bG9ja190IGxvY2s7CiAJLyogUmVmZXJlbmNlcyB0byB0aGUgc2V0ICovCi0JYXRvbWljX3QgcmVmOworCXUzMiByZWY7CiAJLyogVGhlIGNvcmUgc2V0IHR5cGUgKi8KIAlzdHJ1Y3QgaXBfc2V0X3R5cGUgKnR5cGU7CiAJLyogVGhlIHR5cGUgdmFyaWFudCBkb2luZyB0aGUgcmVhbCBqb2IgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmV0ZmlsdGVyL2lwc2V0L2lwX3NldF9haGFzaC5oIGIvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2FoYXNoLmgKaW5kZXggZWM5ZDliZS4uYTAxOTZhYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2FoYXNoLmgKKysrIGIvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2FoYXNoLmgKQEAgLTUxNSw4ICs1MTUsNyBAQAogCWlmIChoLT5uZXRtYXNrICE9IEhPU1RfTUFTSykKIAkJTkxBX1BVVF9VOChza2IsIElQU0VUX0FUVFJfTkVUTUFTSywgaC0+bmV0bWFzayk7CiAjZW5kaWYKLQlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9SRUZFUkVOQ0VTLAotCQkgICAgICBodG9ubChhdG9taWNfcmVhZCgmc2V0LT5yZWYpIC0gMSkpOworCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX1JFRkVSRU5DRVMsIGh0b25sKHNldC0+cmVmIC0gMSkpOwogCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX01FTVNJWkUsIGh0b25sKG1lbXNpemUpKTsKIAlpZiAod2l0aF90aW1lb3V0KGgtPnRpbWVvdXQpKQogCQlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9USU1FT1VULCBodG9ubChoLT50aW1lb3V0KSk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci9uZl9jb25udHJhY2tfcHJvdG9fZ3JlLmggYi9pbmNsdWRlL2xpbnV4L25ldGZpbHRlci9uZl9jb25udHJhY2tfcHJvdG9fZ3JlLmgKaW5kZXggMmExMGVmZC4uNmEwNjY0YyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3Byb3RvX2dyZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19wcm90b19ncmUuaApAQCAtNjAsNyArNjAsNyBAQAogCV9fYmUxNiBwYXlsb2FkX2xlbjsJLyogc2l6ZSBvZiBwcHAgcGF5bG9hZCwgbm90IGluYy4gZ3JlIGhlYWRlciAqLwogCV9fYmUxNiBjYWxsX2lkOwkJLyogcGVlcidzIGNhbGxfaWQgZm9yIHRoaXMgc2Vzc2lvbiAqLwogCV9fYmUzMiBzZXE7CQkvKiBzZXF1ZW5jZSBudW1iZXIuICBQcmVzZW50IGlmIFM9PTEgKi8KLQlfX2JlMzIgYWNrOwkJLyogc2VxIG51bWJlciBvZiBoaWdoZXN0IHBhY2tldCByZWNpZXZlZCBieSAqLworCV9fYmUzMiBhY2s7CQkvKiBzZXEgbnVtYmVyIG9mIGhpZ2hlc3QgcGFja2V0IHJlY2VpdmVkIGJ5ICovCiAJCQkJLyogIHNlbmRlciBpbiB0aGlzIHNlc3Npb24gKi8KIH07CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmV0ZmlsdGVyX2JyaWRnZS9lYnRhYmxlcy5oIGIvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXJfYnJpZGdlL2VidGFibGVzLmgKaW5kZXggMWM2ZjBjNS4uODc5N2VkMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXJfYnJpZGdlL2VidGFibGVzLmgKKysrIGIvaW5jbHVkZS9saW51eC9uZXRmaWx0ZXJfYnJpZGdlL2VidGFibGVzLmgKQEAgLTkyLDcgKzkyLDcgQEAKIAogLyogVGhpcyBpcyBhIGhhY2sgdG8gbWFrZSBhIGRpZmZlcmVuY2UgYmV0d2VlbiBhbiBlYnRfZW50cnkgc3RydWN0IGFuZCBhbgogICogZWJ0X2VudHJpZXMgc3RydWN0IHdoZW4gdHJhdmVyc2luZyB0aGUgZW50cmllcyBmcm9tIHN0YXJ0IHRvIGVuZC4KLSAqIFVzaW5nIHRoaXMgc2ltcGxpZmllcyB0aGUgY29kZSBhbG90LCB3aGlsZSBzdGlsbCBiZWluZyBhYmxlIHRvIHVzZQorICogVXNpbmcgdGhpcyBzaW1wbGlmaWVzIHRoZSBjb2RlIGEgbG90LCB3aGlsZSBzdGlsbCBiZWluZyBhYmxlIHRvIHVzZQogICogZWJ0X2VudHJpZXMuCiAgKiBDb250cmFyeSwgaXB0YWJsZXMgZG9lc24ndCB1c2Ugc29tZXRoaW5nIGxpa2UgZWJ0X2VudHJpZXMgYW5kIHRoZXJlZm9yZSB1c2VzCiAgKiBkaWZmZXJlbnQgdGVjaG5pcXVlcyBmb3IgbmFtaW5nIHRoZSBwb2xpY3kgYW5kIHN1Y2guIFNvLCBpcHRhYmxlcyBkb2Vzbid0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L25mczQuaCBiL2luY2x1ZGUvbGludXgvbmZzNC5oCmluZGV4IGI1MjhmNmQuLjE3OGZhZmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmZzNC5oCisrKyBiL2luY2x1ZGUvbGludXgvbmZzNC5oCkBAIC0zNTksNyArMzU5LDcgQEAKIAkJCQkJCS8qIEVycm9yIDEwMDczIGlzIHVudXNlZC4gKi8KIAlORlM0RVJSX0NMSUVOVElEX0JVU1kJPSAxMDA3NCwJLyogY2xpZW50aWQgaGFzIHN0YXRlICovCiAJTkZTNEVSUl9QTkZTX0lPX0hPTEUJPSAxMDA3NSwJLyogSU8gdG8gX1NQQVJTRSBmaWxlIGhvbGUgKi8KLQlORlM0RVJSX1NFUV9GQUxTRV9SRVRSWQk9IDEwMDc2LAkvKiByZXRyeSBub3Qgb3JpZ2lvbmFsICovCisJTkZTNEVSUl9TRVFfRkFMU0VfUkVUUlkJPSAxMDA3NiwJLyogcmV0cnkgbm90IG9yaWdpbmFsICovCiAJTkZTNEVSUl9CQURfSElHSF9TTE9UCT0gMTAwNzcsCS8qIHNlcXVlbmNlIGFyZyBiYWQgKi8KIAlORlM0RVJSX0RFQURTRVNTSU9OCT0gMTAwNzgsCS8qIHBlcnNpc3RlbnQgc2Vzc2lvbiBkZWFkICovCiAJTkZTNEVSUl9FTkNSX0FMR19VTlNVUFAgPSAxMDA3OSwJLyogU1NWIGFsZyBtaXNtYXRjaCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9uZnNkL2V4cG9ydC5oIGIvaW5jbHVkZS9saW51eC9uZnNkL2V4cG9ydC5oCmluZGV4IGJkMzE2MTUuLjg0MDU4ZWMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmZzZC9leHBvcnQuaAorKysgYi9pbmNsdWRlL2xpbnV4L25mc2QvZXhwb3J0LmgKQEAgLTgwLDcgKzgwLDcgQEAKIAogLyoKICAqIFdlIGtlZXAgYW4gYXJyYXkgb2YgcHNldWRvZmxhdm9ycyB3aXRoIHRoZSBleHBvcnQsIGluIG9yZGVyIGZyb20gbW9zdAotICogdG8gbGVhc3QgcHJlZmVycmVkLiAgRm9yIHRoZSBmb3JzZWVhYmxlIGZ1dHVyZSwgd2UgZG9uJ3QgZXhwZWN0IG1vcmUKKyAqIHRvIGxlYXN0IHByZWZlcnJlZC4gIEZvciB0aGUgZm9yZXNlZWFibGUgZnV0dXJlLCB3ZSBkb24ndCBleHBlY3QgbW9yZQogICogdGhhbiB0aGUgZWlnaHQgcHNldWRvZmxhdm9ycyBudWxsLCB1bml4LCBrcmI1LCBrcmI1aSwga3JiNXAsIHNrcG0zLAogICogc3BrbTNpLCBhbmQgc3BrbTNwIChhbmQgdXNpbmcgYWxsIDggYXQgb25jZSBzaG91bGQgYmUgcmFyZSkuCiAgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmZzZC9uZnNmaC5oIGIvaW5jbHVkZS9saW51eC9uZnNkL25mc2ZoLmgKaW5kZXggODBkNTViYi4uZjc2ZDgwYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZnNkL25mc2ZoLmgKKysrIGIvaW5jbHVkZS9saW51eC9uZnNkL25mc2ZoLmgKQEAgLTQ5LDcgKzQ5LDcgQEAKICAqCiAgKiBUaGUgYXV0aF90eXBlIGZpZWxkIHNwZWNpZmllcyBob3cgdGhlIGZpbGVoYW5kbGUgY2FuIGJlIGF1dGhlbnRpY2F0ZWQKICAqIFRoaXMgbWlnaHQgYWxsb3cgYSBmaWxlIHRvIGJlIGNvbmZpcm1lZCB0byBiZSBpbiBhIHdyaXRhYmxlIHBhcnQgb2YgYQotICogZmlsZXRyZWUgd2l0aG91dCBjaGVja2luZyB0aGUgcGF0aCBmcm9tIGl0IHVwdG8gdGhlIHJvb3QuCisgKiBmaWxldHJlZSB3aXRob3V0IGNoZWNraW5nIHRoZSBwYXRoIGZyb20gaXQgdXAgdG8gdGhlIHJvb3QuCiAgKiBDdXJyZW50IHZhbHVlczoKICAqICAgICAwICAtIE5vIGF1dGhlbnRpY2F0aW9uLiAgZmJfYXV0aCBpcyAwIGJ5dGVzIGxvbmcKICAqIFBvc3NpYmxlIGZ1dHVyZSB2YWx1ZXM6CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L25sODAyMTEuaCBiL2luY2x1ZGUvbGludXgvbmw4MDIxMS5oCmluZGV4IDMwMDIyMTguLmJiZmExMDkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmw4MDIxMS5oCisrKyBiL2luY2x1ZGUvbGludXgvbmw4MDIxMS5oCkBAIC00MTQsNyArNDE0LDcgQEAKICAqIEBfX05MODAyMTFfQ01EX0FGVEVSX0xBU1Q6IGludGVybmFsIHVzZQogICovCiBlbnVtIG5sODAyMTFfY29tbWFuZHMgewotLyogZG9uJ3QgY2hhbmdlIHRoZSBvcmRlciBvciBhZGQgYW55dGhpbmcgaW5iZXR3ZWVuLCB0aGlzIGlzIEFCSSEgKi8KKy8qIGRvbid0IGNoYW5nZSB0aGUgb3JkZXIgb3IgYWRkIGFueXRoaW5nIGJldHdlZW4sIHRoaXMgaXMgQUJJISAqLwogCU5MODAyMTFfQ01EX1VOU1BFQywKIAogCU5MODAyMTFfQ01EX0dFVF9XSVBIWSwJCS8qIGNhbiBkdW1wICovCkBAIC04NjAsNyArODYwLDcgQEAKICAqCVRoaXMgY2FuIGJlIHVzZWQgdG8gbWFzayBvdXQgYW50ZW5uYXMgd2hpY2ggYXJlIG5vdCBhdHRhY2hlZCBvciBzaG91bGQKICAqCW5vdCBiZSB1c2VkIGZvciByZWNlaXZpbmcuIElmIGFuIGFudGVubmEgaXMgbm90IHNlbGVjdGVkIGluIHRoaXMgYml0bWFwCiAgKgl0aGUgaGFyZHdhcmUgc2hvdWxkIG5vdCBiZSBjb25maWd1cmVkIHRvIHJlY2VpdmUgb24gdGhpcyBhbnRlbm5hLgotICoJRm9yIGEgbW9yZSBkZXRhaWxlZCBkZXNjcmlwdG9uIHNlZSBATkw4MDIxMV9BVFRSX1dJUEhZX0FOVEVOTkFfVFguCisgKglGb3IgYSBtb3JlIGRldGFpbGVkIGRlc2NyaXB0aW9uIHNlZSBATkw4MDIxMV9BVFRSX1dJUEhZX0FOVEVOTkFfVFguCiAgKgogICogQE5MODAyMTFfQVRUUl9XSVBIWV9BTlRFTk5BX0FWQUlMX1RYOiBCaXRtYXAgb2YgYW50ZW5uYXMgd2hpY2ggYXJlIGF2YWlsYWJsZQogICoJZm9yIGNvbmZpZ3VyYXRpb24gYXMgVFggYW50ZW5uYXMgdmlhIHRoZSBhYm92ZSBwYXJhbWV0ZXJzLgpAQCAtODkxLDcgKzg5MSw3IEBACiAgKiBAX19OTDgwMjExX0FUVFJfQUZURVJfTEFTVDogaW50ZXJuYWwgdXNlCiAgKi8KIGVudW0gbmw4MDIxMV9hdHRycyB7Ci0vKiBkb24ndCBjaGFuZ2UgdGhlIG9yZGVyIG9yIGFkZCBhbnl0aGluZyBpbmJldHdlZW4sIHRoaXMgaXMgQUJJISAqLworLyogZG9uJ3QgY2hhbmdlIHRoZSBvcmRlciBvciBhZGQgYW55dGhpbmcgYmV0d2VlbiwgdGhpcyBpcyBBQkkhICovCiAJTkw4MDIxMV9BVFRSX1VOU1BFQywKIAogCU5MODAyMTFfQVRUUl9XSVBIWSwKQEAgLTE0MTksNyArMTQxOSw3IEBACiAgKiAJODAyLjExIGNvdW50cnkgaW5mb3JtYXRpb24gZWxlbWVudCB3aXRoIHJlZ3VsYXRvcnkgaW5mb3JtYXRpb24gaXQKICAqIAl0aGlua3Mgd2Ugc2hvdWxkIGNvbnNpZGVyLiBjZmc4MDIxMSBvbmx5IHByb2Nlc3NlcyB0aGUgY291bnRyeQogICoJY29kZSBmcm9tIHRoZSBJRSwgYW5kIHJlbGllcyBvbiB0aGUgcmVndWxhdG9yeSBkb21haW4gaW5mb3JtYXRpb24KLSAqCXN0cnVjdHVyZSBwYXNlZCBieSB1c2Vyc3BhY2UgKENSREEpIGZyb20gb3VyIHdpcmVsZXNzLXJlZ2RiLgorICoJc3RydWN0dXJlIHBhc3NlZCBieSB1c2Vyc3BhY2UgKENSREEpIGZyb20gb3VyIHdpcmVsZXNzLXJlZ2RiLgogICoJSWYgYSBjaGFubmVsIGlzIGVuYWJsZWQgYnV0IHRoZSBjb3VudHJ5IGNvZGUgaW5kaWNhdGVzIGl0IHNob3VsZAogICoJYmUgZGlzYWJsZWQgd2UgZGlzYWJsZSB0aGUgY2hhbm5lbCBhbmQgcmUtZW5hYmxlIGl0IHVwb24gZGlzYXNzb2NpYXRpb24uCiAgKi8KQEAgLTE1OTgsNyArMTU5OCw3IEBACiAgKiBATkw4MDIxMV9NRVNIQ09ORl9SRVRSWV9USU1FT1VUOiBzcGVjaWZpZXMgdGhlIGluaXRpYWwgcmV0cnkgdGltZW91dCBpbgogICogbWlsbGlzZWNvbmQgdW5pdHMsIHVzZWQgYnkgdGhlIFBlZXIgTGluayBPcGVuIG1lc3NhZ2UKICAqCi0gKiBATkw4MDIxMV9NRVNIQ09ORl9DT05GSVJNX1RJTUVPVVQ6IHNwZWNpZmllcyB0aGUgaW5pdGFsIGNvbmZpcm0gdGltZW91dCwgaW4KKyAqIEBOTDgwMjExX01FU0hDT05GX0NPTkZJUk1fVElNRU9VVDogc3BlY2lmaWVzIHRoZSBpbml0aWFsIGNvbmZpcm0gdGltZW91dCwgaW4KICAqIG1pbGxpc2Vjb25kIHVuaXRzLCB1c2VkIGJ5IHRoZSBwZWVyIGxpbmsgbWFuYWdlbWVudCB0byBjbG9zZSBhIHBlZXIgbGluawogICoKICAqIEBOTDgwMjExX01FU0hDT05GX0hPTERJTkdfVElNRU9VVDogc3BlY2lmaWVzIHRoZSBob2xkaW5nIHRpbWVvdXQsIGluCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L25vdGlmaWVyLmggYi9pbmNsdWRlL2xpbnV4L25vdGlmaWVyLmgKaW5kZXggMjAyNmY5ZS4uNjIxZGZhMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ub3RpZmllci5oCisrKyBiL2luY2x1ZGUvbGludXgvbm90aWZpZXIuaApAQCAtMjM3LDcgKzIzNyw3IEBACiAJCQkJCSogZW5hYmxpbmcgaW50ZXJydXB0cy4gTXVzdCBub3Qgc2xlZXAsCiAJCQkJCSogbXVzdCBub3QgZmFpbCAqLwogCi0vKiBVc2VkIGZvciBDUFUgaG90cGx1ZyBldmVudHMgb2NjdXJpbmcgd2hpbGUgdGFza3MgYXJlIGZyb3plbiBkdWUgdG8gYSBzdXNwZW5kCisvKiBVc2VkIGZvciBDUFUgaG90cGx1ZyBldmVudHMgb2NjdXJyaW5nIHdoaWxlIHRhc2tzIGFyZSBmcm96ZW4gZHVlIHRvIGEgc3VzcGVuZAogICogb3BlcmF0aW9uIGluIHByb2dyZXNzCiAgKi8KICNkZWZpbmUgQ1BVX1RBU0tTX0ZST1pFTgkweDAwMTAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvb21hcDNpc3AuaCBiL2luY2x1ZGUvbGludXgvb21hcDNpc3AuaAppbmRleCAxNTA4MjJiLi5iNjExMWY4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L29tYXAzaXNwLmgKKysrIGIvaW5jbHVkZS9saW51eC9vbWFwM2lzcC5oCkBAIC0yNTAsNyArMjUwLDcgQEAKIC8qIENvbnRhaW5zIHRoZSBpbmZvcm1hdGlvbiByZWdhcmRpbmcgdGhlIEhvcml6b250YWwgTWVkaWFuIEZpbHRlciAqLwogc3RydWN0IG9tYXAzaXNwX2gzYV9hZl9obWYgewogCV9fdTggZW5hYmxlOwkvKiBTdGF0dXMgb2YgSG9yaXpvbnRhbCBNZWRpYW4gRmlsdGVyICovCi0JX191OCB0aHJlc2hvbGQ7CS8qIFRocmVzaGhvbGQgVmFsdWUgZm9yIEhvcml6b250YWwgTWVkaWFuIEZpbHRlciAqLworCV9fdTggdGhyZXNob2xkOwkvKiBUaHJlc2hvbGQgVmFsdWUgZm9yIEhvcml6b250YWwgTWVkaWFuIEZpbHRlciAqLwogfTsKIAogLyogQ29udGFpbnMgdGhlIGluZm9ybWF0aW9uIHJlZ2FyZGluZyB0aGUgSUlSIEZpbHRlcnMgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGFnZV9jZ3JvdXAuaCBiL2luY2x1ZGUvbGludXgvcGFnZV9jZ3JvdXAuaAppbmRleCBmNWRlMjFkLi45NjFlY2M3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BhZ2VfY2dyb3VwLmgKKysrIGIvaW5jbHVkZS9saW51eC9wYWdlX2Nncm91cC5oCkBAIC0xMzgsNyArMTM4LDcgQEAKIAogI2RlZmluZSBQQ0dfQVJSQVlJRF9PRkZTRVQJKEJJVFNfUEVSX0xPTkcgLSBQQ0dfQVJSQVlJRF9XSURUSCkKIC8qCi0gKiBaZXJvIHRoZSBzaGlmdCBjb3VudCBmb3Igbm9uLWV4aXN0YW50IGZpZWxkcywgdG8gcHJldmVudCBjb21waWxlcgorICogWmVybyB0aGUgc2hpZnQgY291bnQgZm9yIG5vbi1leGlzdGVudCBmaWVsZHMsIHRvIHByZXZlbnQgY29tcGlsZXIKICAqIHdhcm5pbmdzIGFuZCBlbnN1cmUgcmVmZXJlbmNlcyBhcmUgb3B0aW1pemVkIGF3YXkuCiAgKi8KICNkZWZpbmUgUENHX0FSUkFZSURfU0hJRlQJKFBDR19BUlJBWUlEX09GRlNFVCAqIChQQ0dfQVJSQVlJRF9XSURUSCAhPSAwKSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpX3JlZ3MuaCBiL2luY2x1ZGUvbGludXgvcGNpX3JlZ3MuaAppbmRleCA1YjdlNmIxLi5iZTAxMzgwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BjaV9yZWdzLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2lfcmVncy5oCkBAIC0yMjMsNyArMjIzLDcgQEAKICNkZWZpbmUgIFBDSV9QTV9DQVBfUE1FX0NMT0NLCTB4MDAwOAkvKiBQTUUgY2xvY2sgcmVxdWlyZWQgKi8KICNkZWZpbmUgIFBDSV9QTV9DQVBfUkVTRVJWRUQgICAgMHgwMDEwICAvKiBSZXNlcnZlZCBmaWVsZCAqLwogI2RlZmluZSAgUENJX1BNX0NBUF9EU0kJCTB4MDAyMAkvKiBEZXZpY2Ugc3BlY2lmaWMgaW5pdGlhbGl6YXRpb24gKi8KLSNkZWZpbmUgIFBDSV9QTV9DQVBfQVVYX1BPV0VSCTB4MDFDMAkvKiBBdXhpbGxpYXJ5IHBvd2VyIHN1cHBvcnQgbWFzayAqLworI2RlZmluZSAgUENJX1BNX0NBUF9BVVhfUE9XRVIJMHgwMUMwCS8qIEF1eGlsaWFyeSBwb3dlciBzdXBwb3J0IG1hc2sgKi8KICNkZWZpbmUgIFBDSV9QTV9DQVBfRDEJCTB4MDIwMAkvKiBEMSBwb3dlciBzdGF0ZSBzdXBwb3J0ICovCiAjZGVmaW5lICBQQ0lfUE1fQ0FQX0QyCQkweDA0MDAJLyogRDIgcG93ZXIgc3RhdGUgc3VwcG9ydCAqLwogI2RlZmluZSAgUENJX1BNX0NBUF9QTUUJCTB4MDgwMAkvKiBQTUUgcGluIHN1cHBvcnRlZCAqLwpAQCAtNDM1LDcgKzQzNSw3IEBACiAjZGVmaW5lICBQQ0lfRVhQX0xOS0NBUF9MMFNFTAkweDAwMDA3MDAwIC8qIEwwcyBFeGl0IExhdGVuY3kgKi8KICNkZWZpbmUgIFBDSV9FWFBfTE5LQ0FQX0wxRUwJMHgwMDAzODAwMCAvKiBMMSBFeGl0IExhdGVuY3kgKi8KICNkZWZpbmUgIFBDSV9FWFBfTE5LQ0FQX0NMS1BNCTB4MDAwNDAwMDAgLyogTDEgQ2xvY2sgUG93ZXIgTWFuYWdlbWVudCAqLwotI2RlZmluZSAgUENJX0VYUF9MTktDQVBfU0RFUkMJMHgwMDA4MDAwMCAvKiBTdXByaXNlIERvd24gRXJyb3IgUmVwb3J0aW5nIENhcGFibGUgKi8KKyNkZWZpbmUgIFBDSV9FWFBfTE5LQ0FQX1NERVJDCTB4MDAwODAwMDAgLyogU3VycHJpc2UgRG93biBFcnJvciBSZXBvcnRpbmcgQ2FwYWJsZSAqLwogI2RlZmluZSAgUENJX0VYUF9MTktDQVBfRExMTEFSQwkweDAwMTAwMDAwIC8qIERhdGEgTGluayBMYXllciBMaW5rIEFjdGl2ZSBSZXBvcnRpbmcgQ2FwYWJsZSAqLwogI2RlZmluZSAgUENJX0VYUF9MTktDQVBfTEJOQwkweDAwMjAwMDAwIC8qIExpbmsgQmFuZHdpZHRoIE5vdGlmaWNhdGlvbiBDYXBhYmlsaXR5ICovCiAjZGVmaW5lICBQQ0lfRVhQX0xOS0NBUF9QTgkweGZmMDAwMDAwIC8qIFBvcnQgTnVtYmVyICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BlcmZfZXZlbnQuaCBiL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCmluZGV4IDA0ZDc1YTguLmVlOWYxZTcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCisrKyBiL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCkBAIC02NjIsNyArNjYyLDcgQEAKIAlpbnQgICgqY29tbWl0X3R4bikJKHN0cnVjdCBwbXUgKnBtdSk7IC8qIG9wdGlvbmFsICovCiAJLyoKIAkgKiBXaWxsIGNhbmNlbCB0aGUgdHJhbnNhY3Rpb24sIGFzc3VtZXMgLT5kZWwoKSBpcyBjYWxsZWQKLQkgKiBmb3IgZWFjaCBzdWNjZXNzZnVsbCAtPmFkZCgpIGR1cmluZyB0aGUgdHJhbnNhY3Rpb24uCisJICogZm9yIGVhY2ggc3VjY2Vzc2Z1bCAtPmFkZCgpIGR1cmluZyB0aGUgdHJhbnNhY3Rpb24uCiAJICovCiAJdm9pZCAoKmNhbmNlbF90eG4pCShzdHJ1Y3QgcG11ICpwbXUpOyAvKiBvcHRpb25hbCAqLwogfTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGlkLmggYi9pbmNsdWRlL2xpbnV4L3BpZC5oCmluZGV4IGVmY2VkYTAuLjMxYWZiN2UgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcGlkLmgKKysrIGIvaW5jbHVkZS9saW51eC9waWQuaApAQCAtMjEsNyArMjEsNyBAQAogICogcXVpY2tseSBmcm9tIHRoZSBudW1lcmljIHBpZCB2YWx1ZS4gIFRoZSBhdHRhY2hlZCBwcm9jZXNzZXMgbWF5IGJlCiAgKiBxdWlja2x5IGFjY2Vzc2VkIGJ5IGZvbGxvd2luZyBwb2ludGVycyBmcm9tIHN0cnVjdCBwaWQuCiAgKgotICogU3RvcmluZyBwaWRfdCB2YWx1ZXMgaW4gdGhlIGtlcm5lbCBhbmQgcmVmZXJpbmcgdG8gdGhlbSBsYXRlciBoYXMgYQorICogU3RvcmluZyBwaWRfdCB2YWx1ZXMgaW4gdGhlIGtlcm5lbCBhbmQgcmVmZXJyaW5nIHRvIHRoZW0gbGF0ZXIgaGFzIGEKICAqIHByb2JsZW0uICBUaGUgcHJvY2VzcyBvcmlnaW5hbGx5IHdpdGggdGhhdCBwaWQgbWF5IGhhdmUgZXhpdGVkIGFuZCB0aGUKICAqIHBpZCBhbGxvY2F0b3Igd3JhcHBlZCwgYW5kIGFub3RoZXIgcHJvY2VzcyBjb3VsZCBoYXZlIGNvbWUgYWxvbmcKICAqIGFuZCBiZWVuIGFzc2lnbmVkIHRoYXQgcGlkLgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wa3Rfc2NoZWQuaCBiL2luY2x1ZGUvbGludXgvcGt0X3NjaGVkLmgKaW5kZXggYjEwMzJhMy4uM2EwMmUwMiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wa3Rfc2NoZWQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3BrdF9zY2hlZC5oCkBAIC0yMjMsNyArMjIzLDcgQEAKIAlfX3UzMgkJbGltaXQ7ICAgICAgICAvKiBIQVJEIG1heGltYWwgcXVldWUgbGVuZ3RoIChieXRlcykgICAgKi8KIAlfX3UzMgkJcXRoX21pbjsgICAgICAvKiBNaW4gYXZlcmFnZSBsZW5ndGggdGhyZXNob2xkIChieXRlcykgKi8KIAlfX3UzMgkJcXRoX21heDsgICAgICAvKiBNYXggYXZlcmFnZSBsZW5ndGggdGhyZXNob2xkIChieXRlcykgKi8KLQlfX3UzMgkJRFA7ICAgICAgICAgICAvKiB1cHRvIDJeMzIgRFBzICovCisJX191MzIJCURQOyAgICAgICAgICAgLyogdXAgdG8gMl4zMiBEUHMgKi8KIAlfX3UzMgkJYmFja2xvZzsKIAlfX3UzMgkJcWF2ZTsKIAlfX3UzMgkJZm9yY2VkOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wb2xsLmggYi9pbmNsdWRlL2xpbnV4L3BvbGwuaAppbmRleCAxYTJjY2Q2Li5jZjQwMDEwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BvbGwuaAorKysgYi9pbmNsdWRlL2xpbnV4L3BvbGwuaApAQCAtODIsNyArODIsNyBAQAogfQogCiAvKgotICogU2NhbGVhYmxlIHZlcnNpb24gb2YgdGhlIGZkX3NldC4KKyAqIFNjYWxhYmxlIHZlcnNpb24gb2YgdGhlIGZkX3NldC4KICAqLwogCiB0eXBlZGVmIHN0cnVjdCB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3ByZWZldGNoLmggYi9pbmNsdWRlL2xpbnV4L3ByZWZldGNoLmgKaW5kZXggYWY3YzM2YS4uYTNiZmJkZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wcmVmZXRjaC5oCisrKyBiL2luY2x1ZGUvbGludXgvcHJlZmV0Y2guaApAQCAtMjksNyArMjksNyBAQAogCXByZWZldGNodyh4KQktIHByZWZldGNoZXMgdGhlIGNhY2hlbGluZSBhdCAieCIgZm9yIHdyaXRlCiAJc3Bpbl9sb2NrX3ByZWZldGNoKHgpIC0gcHJlZmV0Y2hlcyB0aGUgc3BpbmxvY2sgKnggZm9yIHRha2luZwogCQotCXRoZXJlIGlzIGFsc28gUFJFRkVUQ0hfU1RSSURFIHdoaWNoIGlzIHRoZSBhcmNoaXRlY3VyZS1wcmVmZXJlZCAKKwl0aGVyZSBpcyBhbHNvIFBSRUZFVENIX1NUUklERSB3aGljaCBpcyB0aGUgYXJjaGl0ZWN1cmUtcHJlZmVycmVkIAogCSJsb29rYWhlYWQiIHNpemUgZm9yIHByZWZldGNoaW5nIHN0cmVhbWVkIG9wZXJhdGlvbnMuCiAJCiAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9weGEyeHhfc3NwLmggYi9pbmNsdWRlL2xpbnV4L3B4YTJ4eF9zc3AuaAppbmRleCAyZjY5MWU0Li40NDgzNWZiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3B4YTJ4eF9zc3AuaAorKysgYi9pbmNsdWRlL2xpbnV4L3B4YTJ4eF9zc3AuaApAQCAtMTIyLDcgKzEyMiw3IEBACiAjZGVmaW5lIFNTQ1IxX1RTUkUJCSgxIDw8IDIxKQkvKiBUcmFuc21pdCBTZXJ2aWNlIFJlcXVlc3QgRW5hYmxlICovCiAjZGVmaW5lIFNTQ1IxX1JTUkUJCSgxIDw8IDIwKQkvKiBSZWNlaXZlIFNlcnZpY2UgUmVxdWVzdCBFbmFibGUgKi8KICNkZWZpbmUgU1NDUjFfVElOVEUJCSgxIDw8IDE5KQkvKiBSZWNlaXZlciBUaW1lLW91dCBJbnRlcnJ1cHQgZW5hYmxlICovCi0jZGVmaW5lIFNTQ1IxX1BJTlRFCQkoMSA8PCAxOCkJLyogUGVyaXBoZXJhbCBUcmFpbGluZyBCeXRlIEludGVydXB0IEVuYWJsZSAqLworI2RlZmluZSBTU0NSMV9QSU5URQkJKDEgPDwgMTgpCS8qIFBlcmlwaGVyYWwgVHJhaWxpbmcgQnl0ZSBJbnRlcnJ1cHQgRW5hYmxlICovCiAjZGVmaW5lIFNTQ1IxX0lGUwkJKDEgPDwgMTYpCS8qIEludmVydCBGcmFtZSBTaWduYWwgKi8KICNkZWZpbmUgU1NDUjFfU1RSRgkJKDEgPDwgMTUpCS8qIFNlbGVjdCBGSUZPIG9yIEVGV1IgKi8KICNkZWZpbmUgU1NDUjFfRUZXUgkJKDEgPDwgMTQpCS8qIEVuYWJsZSBGSUZPIFdyaXRlL1JlYWQgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcmFpZC9tZF9wLmggYi9pbmNsdWRlL2xpbnV4L3JhaWQvbWRfcC5oCmluZGV4IGZmYTJlZmIuLjc1Y2JmNGYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcmFpZC9tZF9wLmgKKysrIGIvaW5jbHVkZS9saW51eC9yYWlkL21kX3AuaApAQCAtMjUxLDcgKzI1MSw3IEBACiAJX19sZTY0CXV0aW1lOwkJLyogNDAgYml0cyBzZWNvbmQsIDI0IGJ0ZXMgbWljcm9zZWNvbmRzICovCiAJX19sZTY0CWV2ZW50czsJCS8qIGluY3JlbWVudGVkIHdoZW4gc3VwZXJibG9jayB1cGRhdGVkICovCiAJX19sZTY0CXJlc3luY19vZmZzZXQ7CS8qIGRhdGEgYmVmb3JlIHRoaXMgb2Zmc2V0IChmcm9tIGRhdGFfb2Zmc2V0KSBrbm93biB0byBiZSBpbiBzeW5jICovCi0JX19sZTMyCXNiX2NzdW07CS8qIGNoZWNrc3VtIHVwdG8gZGV2c1ttYXhfZGV2XSAqLworCV9fbGUzMglzYl9jc3VtOwkvKiBjaGVja3N1bSB1cCB0byBkZXZzW21heF9kZXZdICovCiAJX19sZTMyCW1heF9kZXY7CS8qIHNpemUgb2YgZGV2c1tdIGFycmF5IHRvIGNvbnNpZGVyICovCiAJX191OAlwYWQzWzY0LTMyXTsJLyogc2V0IHRvIDAgd2hlbiB3cml0aW5nICovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcmVpc2VyZnNfZnMuaCBiL2luY2x1ZGUvbGludXgvcmVpc2VyZnNfZnMuaAppbmRleCAwYTM4NDJhLi5lY2E3NWRmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3JlaXNlcmZzX2ZzLmgKKysrIGIvaW5jbHVkZS9saW51eC9yZWlzZXJmc19mcy5oCkBAIC0xNTU3LDcgKzE1NTcsNyBAQAogLyogV2hlbiBpbnNlcnRpbmcgYW4gaXRlbS4gKi8KICNkZWZpbmUgTV9JTlNFUlQJJ2knCiAvKiBXaGVuIGluc2VydGluZyBpbnRvIChkaXJlY3RvcmllcyBvbmx5KSBvciBhcHBlbmRpbmcgb250byBhbiBhbHJlYWR5Ci0gICBleGlzdGFudCBpdGVtLiAqLworICAgZXhpc3RlbnQgaXRlbS4gKi8KICNkZWZpbmUgTV9QQVNURQkJJ3AnCiAvKiBXaGVuIGRlbGV0aW5nIGFuIGl0ZW0uICovCiAjZGVmaW5lIE1fREVMRVRFCSdkJwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zY2hlZC5oIGIvaW5jbHVkZS9saW51eC9zY2hlZC5oCmluZGV4IDgzYmQyZTIuLjRlYzJjMDIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc2NoZWQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKQEAgLTg1NCw3ICs4NTQsNyBAQAogCiAvKgogICogT3B0aW1pc2UgU0QgZmxhZ3MgZm9yIHBvd2VyIHNhdmluZ3M6Ci0gKiBTRF9CQUxBTkNFX05FV0lETEUgaGVscHMgYWdyZXNzaXZlIHRhc2sgY29uc29saWRhdGlvbiBhbmQgcG93ZXIgc2F2aW5ncy4KKyAqIFNEX0JBTEFOQ0VfTkVXSURMRSBoZWxwcyBhZ2dyZXNzaXZlIHRhc2sgY29uc29saWRhdGlvbiBhbmQgcG93ZXIgc2F2aW5ncy4KICAqIEtlZXAgZGVmYXVsdCBTRCBmbGFncyBpZiBzY2hlZF97c210LG1jfV9wb3dlcl9zYXZpbmc9MAogICovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc2tidWZmLmggYi9pbmNsdWRlL2xpbnV4L3NrYnVmZi5oCmluZGV4IGQ5ZTUyZmEuLmQwYWU5MGEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc2tidWZmLmgKKysrIGIvaW5jbHVkZS9saW51eC9za2J1ZmYuaApAQCAtNDc0LDcgKzQ3NCw3IEBACiBleHRlcm4gdm9pZCBza2JfZHN0X3NldF9ub3JlZihzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgZHN0X2VudHJ5ICpkc3QpOwogCiAvKioKLSAqIHNrYl9kc3RfaXNfbm9yZWYgLSBUZXN0IGlmIHNrYiBkc3QgaXNudCByZWZjb3VudGVkCisgKiBza2JfZHN0X2lzX25vcmVmIC0gVGVzdCBpZiBza2IgZHN0IGlzbid0IHJlZmNvdW50ZWQKICAqIEBza2I6IGJ1ZmZlcgogICovCiBzdGF0aWMgaW5saW5lIGJvb2wgc2tiX2RzdF9pc19ub3JlZihjb25zdCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zbWM5MXguaCBiL2luY2x1ZGUvbGludXgvc21jOTF4LmgKaW5kZXggYmMyMWRiNS4uNzYxOTliNyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zbWM5MXguaAorKysgYi9pbmNsdWRlL2xpbnV4L3NtYzkxeC5oCkBAIC0yMSw3ICsyMSw3IEBACiAjZGVmaW5lIFJQQ19MRURfMTAJKDB4MDIpCS8qIExFRCA9IDEwTWJwcyBsaW5rIGRldGVjdCAqLwogI2RlZmluZSBSUENfTEVEX0ZECSgweDAzKQkvKiBMRUQgPSBGdWxsIER1cGxleCBNb2RlICovCiAjZGVmaW5lIFJQQ19MRURfVFhfUlgJKDB4MDQpCS8qIExFRCA9IFRYIG9yIFJYIHBhY2tldCBvY2N1cnJlZCAqLwotI2RlZmluZSBSUENfTEVEXzEwMAkoMHgwNSkJLyogTEVEID0gMTAwTWJwcyBsaW5rIGRlY3RlY3QgKi8KKyNkZWZpbmUgUlBDX0xFRF8xMDAJKDB4MDUpCS8qIExFRCA9IDEwME1icHMgbGluayBkZXRlY3QgKi8KICNkZWZpbmUgUlBDX0xFRF9UWAkoMHgwNikJLyogTEVEID0gVFggcGFja2V0IG9jY3VycmVkICovCiAjZGVmaW5lIFJQQ19MRURfUlgJKDB4MDcpCS8qIExFRCA9IFJYIHBhY2tldCBvY2N1cnJlZCAqLwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3NvY2tldC5oIGIvaW5jbHVkZS9saW51eC9zb2NrZXQuaAppbmRleCBlZGJiMWQwLi5kMmI1ZTk4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3NvY2tldC5oCisrKyBiL2luY2x1ZGUvbGludXgvc29ja2V0LmgKQEAgLTg4LDcgKzg4LDcgQEAKIH07CiAKIC8qCi0gKglBbmNpbGxpYXJ5IGRhdGEgb2JqZWN0IGluZm9ybWF0aW9uIE1BQ1JPUworICoJQW5jaWxsYXJ5IGRhdGEgb2JqZWN0IGluZm9ybWF0aW9uIE1BQ1JPUwogICoJVGFibGUgNS0xNCBvZiBQT1NJWCAxMDAzLjFnCiAgKi8KIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zb3VuZGNhcmQuaCBiL2luY2x1ZGUvbGludXgvc291bmRjYXJkLmgKaW5kZXggMTkwNGFmZS4uZmUyMDRmZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zb3VuZGNhcmQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3NvdW5kY2FyZC5oCkBAIC0xMjMxLDcgKzEyMzEsNyBAQAogI2RlZmluZSBTRVFfUEFOTklORyhkZXYsIHZvaWNlLCBwb3MpIFNFUV9DT05UUk9MKGRldiwgdm9pY2UsIENUTF9QQU4sIChwb3MrMTI4KSAvIDIpCiAKIC8qCi0gKiBUaW1pbmcgYW5kIHN5bmNyb25pemF0aW9uIG1hY3JvcworICogVGltaW5nIGFuZCBzeW5jaHJvbml6YXRpb24gbWFjcm9zCiAgKi8KIAogI2RlZmluZSBfVElNRVJfRVZFTlQoZXYsIHBhcm0pCQl7X1NFUV9ORUVEQlVGKDgpO1wKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3BpL3NwaWRldi5oIGIvaW5jbHVkZS9saW51eC9zcGkvc3BpZGV2LmgKaW5kZXggYmYwNTcwYS4uNTJkOWVkMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zcGkvc3BpZGV2LmgKKysrIGIvaW5jbHVkZS9saW51eC9zcGkvc3BpZGV2LmgKQEAgLTY2LDcgKzY2LDcgQEAKICAqIGFyZSBpbiBhIGRpZmZlcmVudCBhZGRyZXNzIHNwYWNlIChhbmQgbWF5IGJlIG9mIGRpZmZlcmVudCBzaXplcyBpbiBzb21lCiAgKiBjYXNlcywgc3VjaCBhcyAzMi1iaXQgaTM4NiB1c2Vyc3BhY2Ugb3ZlciBhIDY0LWJpdCB4ODZfNjQga2VybmVsKS4KICAqIFplcm8taW5pdGlhbGl6ZSB0aGUgc3RydWN0dXJlLCBpbmNsdWRpbmcgY3VycmVudGx5IHVudXNlZCBmaWVsZHMsIHRvCi0gKiBhY2NvbW9kYXRlIHBvdGVudGlhbCBmdXR1cmUgdXBkYXRlcy4KKyAqIGFjY29tbW9kYXRlIHBvdGVudGlhbCBmdXR1cmUgdXBkYXRlcy4KICAqCiAgKiBTUElfSU9DX01FU1NBR0UgZ2l2ZXMgdXNlcnNwYWNlIHRoZSBlcXVpdmFsZW50IG9mIGtlcm5lbCBzcGlfc3luYygpLgogICogUGFzcyBpdCBhbiBhcnJheSBvZiByZWxhdGVkIHRyYW5zZmVycywgdGhleSdsbCBleGVjdXRlIHRvZ2V0aGVyLgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zcGlubG9jay5oIGIvaW5jbHVkZS9saW51eC9zcGlubG9jay5oCmluZGV4IDgwZTUzNTguLjBiMjJkNTEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3BpbmxvY2suaAorKysgYi9pbmNsdWRlL2xpbnV4L3NwaW5sb2NrLmgKQEAgLTgxLDcgKzgxLDcgQEAKICNpbmNsdWRlIDxsaW51eC9zcGlubG9ja190eXBlcy5oPgogCiAvKgotICogUHVsbCB0aGUgYXJjaF9zcGluKigpIGZ1bmN0aW9ucy9kZWNsYXJhdGlvbnMgKFVQLW5vbmRlYnVnIGRvZXNudCBuZWVkIHRoZW0pOgorICogUHVsbCB0aGUgYXJjaF9zcGluKigpIGZ1bmN0aW9ucy9kZWNsYXJhdGlvbnMgKFVQLW5vbmRlYnVnIGRvZXNuJ3QgbmVlZCB0aGVtKToKICAqLwogI2lmZGVmIENPTkZJR19TTVAKICMgaW5jbHVkZSA8YXNtL3NwaW5sb2NrLmg+CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3N0bW1hYy5oIGIvaW5jbHVkZS9saW51eC9zdG1tYWMuaAppbmRleCBlMTAzNTI5Li5mMjkxOTdhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N0bW1hYy5oCisrKyBiL2luY2x1ZGUvbGludXgvc3RtbWFjLmgKQEAgLTI2LDcgKzI2LDcgQEAKICNpZm5kZWYgX19TVE1NQUNfUExBVEZPUk1fREFUQQogI2RlZmluZSBfX1NUTU1BQ19QTEFURk9STV9EQVRBCiAKLS8qIHBsYXRmcm9tIGRhdGEgZm9yIHBsYXRmcm9tIGRldmljZSBzdHJ1Y3R1cmUncyBwbGF0ZnJvbV9kYXRhIGZpZWxkICovCisvKiBwbGF0Zm9ybSBkYXRhIGZvciBwbGF0Zm9ybSBkZXZpY2Ugc3RydWN0dXJlJ3MgcGxhdGZvcm1fZGF0YSBmaWVsZCAqLwogCiAvKiBQcml2YXRlIGRhdGEgZm9yIHRoZSBTVE0gb24tYm9hcmQgZXRoZXJuZXQgZHJpdmVyICovCiBzdHJ1Y3QgcGxhdF9zdG1tYWNlbmV0X2RhdGEgewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zdG9wX21hY2hpbmUuaCBiL2luY2x1ZGUvbGludXgvc3RvcF9tYWNoaW5lLmgKaW5kZXggMTgwODk2MC4uMDkyZGM5YiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zdG9wX21hY2hpbmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L3N0b3BfbWFjaGluZS5oCkBAIC0xMDUsNyArMTA1LDcgQEAKICAqIEBjcHVzOiB0aGUgY3B1cyB0byBydW4gdGhlIEBmbigpIG9uIChOVUxMID0gYW55IG9ubGluZSBjcHUpCiAgKgogICogRGVzY3JpcHRpb246IFRoaXMgY2F1c2VzIGEgdGhyZWFkIHRvIGJlIHNjaGVkdWxlZCBvbiBldmVyeSBjcHUsCi0gKiBlYWNoIG9mIHdoaWNoIGRpc2FibGVzIGludGVycnVwdHMuICBUaGUgcmVzdWx0IGlzIHRoYXQgbm9vbmUgaXMKKyAqIGVhY2ggb2Ygd2hpY2ggZGlzYWJsZXMgaW50ZXJydXB0cy4gIFRoZSByZXN1bHQgaXMgdGhhdCBubyBvbmUgaXMKICAqIGhvbGRpbmcgYSBzcGlubG9jayBvciBpbnNpZGUgYW55IG90aGVyIHByZWVtcHQtZGlzYWJsZWQgcmVnaW9uIHdoZW4KICAqIEBmbigpIHJ1bnMuCiAgKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zdW5ycGMvY2FjaGUuaCBiL2luY2x1ZGUvbGludXgvc3VucnBjL2NhY2hlLmgKaW5kZXggNzg5OGVhMS4uOGQyZWVmMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zdW5ycGMvY2FjaGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L3N1bnJwYy9jYWNoZS5oCkBAIC0zNSwxMCArMzUsMTAgQEAKICAqIEVhY2ggY2FjaGUgbXVzdCBiZSByZWdpc3RlcmVkIHNvIHRoYXQgaXQgY2FuIGJlIGNsZWFuZWQgcmVndWxhcmx5LgogICogV2hlbiB0aGUgY2FjaGUgaXMgdW5yZWdpc3RlcmVkLCBpdCBpcyBmbHVzaGVkIGNvbXBsZXRlbHkuCiAgKgotICogRW50cmllcyBoYXZlIGEgcmVmIGNvdW50IGFuZCBhICdoYXNoZWQnIGZsYWcgd2hpY2ggY291bnRzIHRoZSBleGlzdGFuY2UKKyAqIEVudHJpZXMgaGF2ZSBhIHJlZiBjb3VudCBhbmQgYSAnaGFzaGVkJyBmbGFnIHdoaWNoIGNvdW50cyB0aGUgZXhpc3RlbmNlCiAgKiBpbiB0aGUgaGFzaCB0YWJsZS4KICAqIFdlIG9ubHkgZXhwaXJlIGVudHJpZXMgd2hlbiByZWZjb3VudCBpcyB6ZXJvLgotICogRXhpc3RhbmNlIGluIHRoZSBjYWNoZSBpcyBjb3VudGVkICB0aGUgcmVmY291bnQuCisgKiBFeGlzdGVuY2UgaW4gdGhlIGNhY2hlIGlzIGNvdW50ZWQgIHRoZSByZWZjb3VudC4KICAqLwogCiAvKiBFdmVyeSBjYWNoZSBpdGVtIGhhcyBhIGNvbW1vbiBoZWFkZXIgdGhhdCBpcyB1c2VkCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3N1bnJwYy9zdmNhdXRoX2dzcy5oIGIvaW5jbHVkZS9saW51eC9zdW5ycGMvc3ZjYXV0aF9nc3MuaAppbmRleCBjYTdkNzI1Li44M2JiZWUzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N1bnJwYy9zdmNhdXRoX2dzcy5oCisrKyBiL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Y2F1dGhfZ3NzLmgKQEAgLTIsNyArMiw3IEBACiAgKiBsaW51eC9pbmNsdWRlL2xpbnV4L3N1bnJwYy9zdmNhdXRoX2dzcy5oCiAgKgogICogQnJ1Y2UgRmllbGRzIDxiZmllbGRzQHVtaWNoLmVkdT4KLSAqIENvcHlyaWdodCAoYykgMjAwMiBUaGUgUmVnZW50cyBvZiB0aGUgVW52aWVyc2l0eSBvZiBNaWNoaWdhbgorICogQ29weXJpZ2h0IChjKSAyMDAyIFRoZSBSZWdlbnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9mIE1pY2hpZ2FuCiAgKi8KIAogI2lmbmRlZiBfTElOVVhfU1VOUlBDX1NWQ0FVVEhfR1NTX0gKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3lzZGV2LmggYi9pbmNsdWRlL2xpbnV4L3N5c2Rldi5oCmluZGV4IDhhNzVkYTUuLmRmYjA3OGQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3lzZGV2LmgKKysrIGIvaW5jbHVkZS9saW51eC9zeXNkZXYuaApAQCAtNywxMyArNywxMyBAQAogICogV2Ugc3RpbGwgaGF2ZSBhIG5vdGlvbiBvZiBhIGRyaXZlciBmb3IgYSBzeXN0ZW0gZGV2aWNlLCBiZWNhdXNlIHdlIHN0aWxsCiAgKiB3YW50IHRvIHBlcmZvcm0gYmFzaWMgb3BlcmF0aW9ucyBvbiB0aGVzZSBkZXZpY2VzLiAKICAqCi0gKiBXZSBhbHNvIHN1cHBvcnQgYXV4aWxsYXJ5IGRyaXZlcnMgYmluZGluZyB0byBkZXZpY2VzIG9mIGEgY2VydGFpbiBjbGFzcy4KKyAqIFdlIGFsc28gc3VwcG9ydCBhdXhpbGlhcnkgZHJpdmVycyBiaW5kaW5nIHRvIGRldmljZXMgb2YgYSBjZXJ0YWluIGNsYXNzLgogICogCiAgKiBUaGlzIGFsbG93cyBjb25maWd1cmFibGUgZHJpdmVycyB0byByZWdpc3RlciB0aGVtc2VsdmVzIGZvciBkZXZpY2VzIG9mCiAgKiBhIGNlcnRhaW4gdHlwZS4gQW5kLCBpdCBhbGxvd3MgY2xhc3MgZGVmaW5pdGlvbnMgdG8gcmVzaWRlIGluIGdlbmVyaWMKICAqIGNvZGUgd2hpbGUgYXJjaC1zcGVjaWZpYyBjb2RlIGNhbiByZWdpc3RlciBzcGVjaWZpYyBkcml2ZXJzLgogICoKLSAqIEF1eGlsbGFyeSBkcml2ZXJzIHJlZ2lzdGVyZWQgd2l0aCBhIE5VTEwgY2xzIGFyZSByZWdpc3RlcmVkIGFzIGRyaXZlcnMKKyAqIEF1eGlsaWFyeSBkcml2ZXJzIHJlZ2lzdGVyZWQgd2l0aCBhIE5VTEwgY2xzIGFyZSByZWdpc3RlcmVkIGFzIGRyaXZlcnMKICAqIGZvciBhbGwgc3lzdGVtIGRldmljZXMsIGFuZCBnZXQgbm90aWZpY2F0aW9uIGNhbGxzIGZvciBlYWNoIGRldmljZS4gCiAgKi8KIApAQCAtNzAsNyArNzAsNyBAQAogZXh0ZXJuIHZvaWQgc3lzZGV2X2NsYXNzX3JlbW92ZV9maWxlKHN0cnVjdCBzeXNkZXZfY2xhc3MgKiwKIAlzdHJ1Y3Qgc3lzZGV2X2NsYXNzX2F0dHJpYnV0ZSAqKTsKIC8qKgotICogQXV4aWxsYXJ5IHN5c3RlbSBkZXZpY2UgZHJpdmVycy4KKyAqIEF1eGlsaWFyeSBzeXN0ZW0gZGV2aWNlIGRyaXZlcnMuCiAgKi8KIAogc3RydWN0IHN5c2Rldl9kcml2ZXIgewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC90aW1lcnF1ZXVlLmggYi9pbmNsdWRlL2xpbnV4L3RpbWVycXVldWUuaAppbmRleCBkMjRhYWJhLi5hNTIwZmQ3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3RpbWVycXVldWUuaAorKysgYi9pbmNsdWRlL2xpbnV4L3RpbWVycXVldWUuaApAQCAtMjQsNyArMjQsNyBAQAogCQkJCQkJc3RydWN0IHRpbWVycXVldWVfbm9kZSAqbm9kZSk7CiAKIC8qKgotICogdGltZXJxdWV1ZV9nZXRuZXh0IC0gUmV0dXJucyB0aGUgdGltZXIgd2l0aCB0aGUgZWFybGllcyBleHBpcmF0aW9uIHRpbWUKKyAqIHRpbWVycXVldWVfZ2V0bmV4dCAtIFJldHVybnMgdGhlIHRpbWVyIHdpdGggdGhlIGVhcmxpZXN0IGV4cGlyYXRpb24gdGltZQogICoKICAqIEBoZWFkOiBoZWFkIG9mIHRpbWVycXVldWUKICAqCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3RyYWNlaG9vay5oIGIvaW5jbHVkZS9saW51eC90cmFjZWhvb2suaAppbmRleCAzYTJlNjZkLi5lYmNmYTRlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3RyYWNlaG9vay5oCisrKyBiL2luY2x1ZGUvbGludXgvdHJhY2Vob29rLmgKQEAgLTE2OSw3ICsxNjksNyBAQAogICogdHJhY2Vob29rX3RyYWNlcl90YXNrIC0gcmV0dXJuIHRoZSB0YXNrIHRoYXQgaXMgdHJhY2luZyB0aGUgZ2l2ZW4gdGFzawogICogQHRzazoJCXRhc2sgdG8gY29uc2lkZXIKICAqCi0gKiBSZXR1cm5zIE5VTEwgaWYgbm9vbmUgaXMgdHJhY2luZyBAdGFzaywgb3IgdGhlICZzdHJ1Y3QgdGFza19zdHJ1Y3QKKyAqIFJldHVybnMgTlVMTCBpZiBubyBvbmUgaXMgdHJhY2luZyBAdGFzaywgb3IgdGhlICZzdHJ1Y3QgdGFza19zdHJ1Y3QKICAqIHBvaW50ZXIgdG8gaXRzIHRyYWNlci4KICAqCiAgKiBNdXN0IGNhbGxlZCB1bmRlciByY3VfcmVhZF9sb2NrKCkuICBUaGUgcG9pbnRlciByZXR1cm5lZCBtaWdodCBiZSBrZXB0CkBAIC00NDgsNyArNDQ4LDcgQEAKICAqCiAgKiBSZXR1cm4gemVybyB0byBjaGVjayBmb3IgYSByZWFsIHBlbmRpbmcgc2lnbmFsIG5vcm1hbGx5LgogICogUmV0dXJuIC0xIGFmdGVyIHJlbGVhc2luZyB0aGUgc2lnbG9jayB0byByZXBlYXQgdGhlIGNoZWNrLgotICogUmV0dXJuIGEgc2lnbmFsIG51bWJlciB0byBpbmR1Y2UgYW4gYXJ0aWZpY2FsIHNpZ25hbCBkZWxpdmVyeSwKKyAqIFJldHVybiBhIHNpZ25hbCBudW1iZXIgdG8gaW5kdWNlIGFuIGFydGlmaWNpYWwgc2lnbmFsIGRlbGl2ZXJ5LAogICogc2V0dGluZyAqQGluZm8gYW5kICpAcmV0dXJuX2thIHRvIHNwZWNpZnkgaXRzIGRldGFpbHMgYW5kIGJlaGF2aW9yLgogICoKICAqIFRoZSBAcmV0dXJuX2thLT5zYV9oYW5kbGVyIHZhbHVlIGNvbnRyb2xzIHRoZSBkaXNwb3NpdGlvbiBvZiB0aGUKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdWNiMTQwMC5oIGIvaW5jbHVkZS9saW51eC91Y2IxNDAwLmgKaW5kZXggMWI0NzkwOS4uNWM3NTE1MyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91Y2IxNDAwLmgKKysrIGIvaW5jbHVkZS9saW51eC91Y2IxNDAwLmgKQEAgLTgsNyArOCw3IEBACiAgKiAgQ29weXJpZ2h0OglNb250YVZpc3RhIFNvZnR3YXJlLCBJbmMuCiAgKgogICogU3BsaXRpbmcgZG9uZSBieTogTWFyZWsgVmFzdXQgPG1hcmVrLnZhc3V0QGdtYWlsLmNvbT4KLSAqIElmIHNvbWV0aGluZyBkb2VzbnQgd29yayBhbmQgaXQgd29ya2VkIGJlZm9yZSBzcGxpdGluZywgZS1tYWlsIG1lLAorICogSWYgc29tZXRoaW5nIGRvZXNuJ3Qgd29yayBhbmQgaXQgd29ya2VkIGJlZm9yZSBzcGxpdGluZywgZS1tYWlsIG1lLAogICogZG9udCBib3RoZXIgTmljb2xhcyBwbGVhc2UgOy0pCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiLmggYi9pbmNsdWRlL2xpbnV4L3VzYi5oCmluZGV4IGU2M2VmZWIuLjY1Zjc4Y2EgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdXNiLmgKKysrIGIvaW5jbHVkZS9saW51eC91c2IuaApAQCAtNjIzLDcgKzYyMyw3IEBACiAgKiBVU0IgaHVicy4gIFRoYXQgbWFrZXMgaXQgc3RheSB0aGUgc2FtZSB1bnRpbCBzeXN0ZW1zIGFyZSBwaHlzaWNhbGx5CiAgKiByZWNvbmZpZ3VyZWQsIGJ5IHJlLWNhYmxpbmcgYSB0cmVlIG9mIFVTQiBkZXZpY2VzIG9yIGJ5IG1vdmluZyBVU0IgaG9zdAogICogY29udHJvbGxlcnMuICBBZGRpbmcgYW5kIHJlbW92aW5nIGRldmljZXMsIGluY2x1ZGluZyB2aXJ0dWFsIHJvb3QgaHVicwotICogaW4gaG9zdCBjb250cm9sbGVyIGRyaXZlciBtb2R1bGVzLCBkb2VzIG5vdCBjaGFuZ2UgdGhlc2UgcGF0aCBpZGVudGlmZXJzOworICogaW4gaG9zdCBjb250cm9sbGVyIGRyaXZlciBtb2R1bGVzLCBkb2VzIG5vdCBjaGFuZ2UgdGhlc2UgcGF0aCBpZGVudGlmaWVyczsKICAqIG5laXRoZXIgZG9lcyByZWJvb3Rpbmcgb3IgcmUtZW51bWVyYXRpbmcuICBUaGVzZSBhcmUgbW9yZSB1c2VmdWwgaWRlbnRpZmllcnMKICAqIHRoYW4gY2hhbmdlYWJsZSAoInVuc3RhYmxlIikgb25lcyBsaWtlIGJ1cyBudW1iZXJzIG9yIGRldmljZSBhZGRyZXNzZXMuCiAgKgpAQCAtNzkzLDcgKzc5Myw3IEBACiAgKgl1c2Jfc2V0X2ludGZkYXRhKCkgdG8gYXNzb2NpYXRlIGRyaXZlci1zcGVjaWZpYyBkYXRhIHdpdGggdGhlCiAgKglpbnRlcmZhY2UuICBJdCBtYXkgYWxzbyB1c2UgdXNiX3NldF9pbnRlcmZhY2UoKSB0byBzcGVjaWZ5IHRoZQogICoJYXBwcm9wcmlhdGUgYWx0c2V0dGluZy4gIElmIHVud2lsbGluZyB0byBtYW5hZ2UgdGhlIGludGVyZmFjZSwKLSAqCXJldHVybiAtRU5PREVWLCBpZiBnZW51aW5lIElPIGVycm9ycyBvY2N1cmVkLCBhbiBhcHByb3ByaWF0ZQorICoJcmV0dXJuIC1FTk9ERVYsIGlmIGdlbnVpbmUgSU8gZXJyb3JzIG9jY3VycmVkLCBhbiBhcHByb3ByaWF0ZQogICoJbmVnYXRpdmUgZXJybm8gdmFsdWUuCiAgKiBAZGlzY29ubmVjdDogQ2FsbGVkIHdoZW4gdGhlIGludGVyZmFjZSBpcyBubyBsb25nZXIgYWNjZXNzaWJsZSwgdXN1YWxseQogICoJYmVjYXVzZSBpdHMgZGV2aWNlIGhhcyBiZWVuIChvciBpcyBiZWluZykgZGlzY29ubmVjdGVkIG9yIHRoZQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91c2IvY29tcG9zaXRlLmggYi9pbmNsdWRlL2xpbnV4L3VzYi9jb21wb3NpdGUuaAppbmRleCAzZDI5YTdkLi44ODJhMDg0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3VzYi9jb21wb3NpdGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L3VzYi9jb21wb3NpdGUuaApAQCAtMTg4LDcgKzE4OCw3IEBACiAgKiBAYmluZCgpIG1ldGhvZCBpcyB0aGVuIHVzZWQgdG8gaW5pdGlhbGl6ZSBhbGwgdGhlIGZ1bmN0aW9ucyBhbmQgdGhlbgogICogY2FsbCBAdXNiX2FkZF9mdW5jdGlvbigpIGZvciB0aGVtLgogICoKLSAqIFRob3NlIGZ1bmN0aW9ucyB3b3VsZCBub3JtYWxseSBiZSBpbmRlcGVuZGFudCBvZiBlYWNoIG90aGVyLCBidXQgdGhhdCdzCisgKiBUaG9zZSBmdW5jdGlvbnMgd291bGQgbm9ybWFsbHkgYmUgaW5kZXBlbmRlbnQgb2YgZWFjaCBvdGhlciwgYnV0IHRoYXQncwogICogbm90IG1hbmRhdG9yeS4gIENEQyBXTUMgZGV2aWNlcyBhcmUgYW4gZXhhbXBsZSB3aGVyZSBmdW5jdGlvbnMgb2Z0ZW4KICAqIGRlcGVuZCBvbiBvdGhlciBmdW5jdGlvbnMsIHdpdGggc29tZSBmdW5jdGlvbnMgc3Vic2lkaWFyeSB0byBvdGhlcnMuCiAgKiBTdWNoIGludGVyZGVwZW5kZW5jeSBtYXkgYmUgbWFuYWdlZCBpbiBhbnkgd2F5LCBzbyBsb25nIGFzIGFsbCBvZiB0aGUKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL2VoY2lfZGVmLmggYi9pbmNsdWRlL2xpbnV4L3VzYi9laGNpX2RlZi5oCmluZGV4IDY1NjM4MDIuLmU0OWRmZDQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdXNiL2VoY2lfZGVmLmgKKysrIGIvaW5jbHVkZS9saW51eC91c2IvZWhjaV9kZWYuaApAQCAtMTU5LDcgKzE1OSw3IEBACiAjZGVmaW5lIFVTQk1PREVfQ01fSURMRQkoMDw8MCkJCS8qIGlkbGUgc3RhdGUgKi8KIAogLyogTW9vcmVzdG93biBoYXMgc29tZSBub24tc3RhbmRhcmQgcmVnaXN0ZXJzLCBwYXJ0aWFsbHkgZHVlIHRvIHRoZSBmYWN0IHRoYXQKLSAqIGl0cyBFSENJIGNvbnRyb2xsZXIgaGFzIGJvdGggVFQgYW5kIExQTSBzdXBwb3J0LiBIT1NUUEN4IGFyZSBleHRlbnRpb25zIHRvCisgKiBpdHMgRUhDSSBjb250cm9sbGVyIGhhcyBib3RoIFRUIGFuZCBMUE0gc3VwcG9ydC4gSE9TVFBDeCBhcmUgZXh0ZW5zaW9ucyB0bwogICogUE9SVFNDeAogICovCiAjZGVmaW5lIEhPU1RQQzAJCTB4ODQJCS8qIEhPU1RQQyBleHRlbnNpb24gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL2Z1bmN0aW9uZnMuaCBiL2luY2x1ZGUvbGludXgvdXNiL2Z1bmN0aW9uZnMuaAppbmRleCA2ZjY0OWMxLi43NTg3ZWY5IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3VzYi9mdW5jdGlvbmZzLmgKKysrIGIvaW5jbHVkZS9saW51eC91c2IvZnVuY3Rpb25mcy5oCkBAIC00NSw3ICs0NSw3IEBACiAgKiB8IG9mZiB8IG5hbWUgICAgICB8IHR5cGUgICAgICAgICB8IGRlc2NyaXB0aW9uICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgKiB8LS0tLS0rLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18CiAgKiB8ICAgMCB8IG1hZ2ljICAgICB8IExFMzIgICAgICAgICB8IEZVTkNUSU9ORlNfe0ZTLEhTfV9ERVNDUklQVE9SU19NQUdJQyB8Ci0gKiB8ICAgNCB8IGxlbmdodCAgICB8IExFMzIgICAgICAgICB8IGxlbmd0aCBvZiB0aGUgd2hvbGUgZGF0YSBjaHVuayAgICAgICB8CisgKiB8ICAgNCB8IGxlbmd0aCAgICB8IExFMzIgICAgICAgICB8IGxlbmd0aCBvZiB0aGUgd2hvbGUgZGF0YSBjaHVuayAgICAgICB8CiAgKiB8ICAgOCB8IGZzX2NvdW50ICB8IExFMzIgICAgICAgICB8IG51bWJlciBvZiBmdWxsLXNwZWVkIGRlc2NyaXB0b3JzICAgICB8CiAgKiB8ICAxMiB8IGhzX2NvdW50ICB8IExFMzIgICAgICAgICB8IG51bWJlciBvZiBoaWdoLXNwZWVkIGRlc2NyaXB0b3JzICAgICB8CiAgKiB8ICAxNiB8IGZzX2Rlc2NycyB8IERlc2NyaXB0b3JbXSB8IGxpc3Qgb2YgZnVsbC1zcGVlZCBkZXNjcmlwdG9ycyAgICAgICB8CkBAIC04Niw3ICs4Niw3IEBACiAgKiB8ICAgMCB8IGxhbmcgICAgfCBMRTE2ICAgICAgICAgICAgICB8IGxhbmd1YWdlIGNvZGUgICAgICAgICAgICAgICAgICAgICAgfAogICogfCAgIDIgfCBzdHJpbmdzIHwgU3RyaW5nW3N0cl9jb3VudF0gfCBhcnJheSBvZiBzdHJpbmdzIGluIGdpdmVuIGxhbmd1YWdlIHwKICAqCi0gKiBGb3IgZWFjaCBzdHJpbmcgdGhlciBpcyBvbmUgc3RyaW5ncyBlbnRyeSAoaWUuIHRoZXJlIGFyZSBzdHJfY291bnQKKyAqIEZvciBlYWNoIHN0cmluZyB0aGVyZSBpcyBvbmUgc3RyaW5ncyBlbnRyeSAoaWUuIHRoZXJlIGFyZSBzdHJfY291bnQKICAqIHN0cmluZyBlbnRyaWVzKS4gIEVhY2ggU3RyaW5nIGlzIGEgTlVMIHRlcm1pbmF0ZWQgc3RyaW5nIGVuY29kZWQgaW4KICAqIFVURi04LgogICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3VzYi9nYWRnZXQuaCBiL2luY2x1ZGUvbGludXgvdXNiL2dhZGdldC5oCmluZGV4IDAwNjQxMmMuLmU1MzgxNzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdXNiL2dhZGdldC5oCisrKyBiL2luY2x1ZGUvbGludXgvdXNiL2dhZGdldC5oCkBAIC03Miw3ICs3Miw3IEBACiAgKiBCdWxrIGVuZHBvaW50cyBjYW4gdXNlIGFueSBzaXplIGJ1ZmZlcnMsIGFuZCBjYW4gYWxzbyBiZSB1c2VkIGZvciBpbnRlcnJ1cHQKICAqIHRyYW5zZmVycy4gaW50ZXJydXB0LW9ubHkgZW5kcG9pbnRzIGNhbiBiZSBtdWNoIGxlc3MgZnVuY3Rpb25hbC4KICAqCi0gKiBOT1RFOiAgdGhpcyBpcyBhbmFsYWdvdXMgdG8gJ3N0cnVjdCB1cmInIG9uIHRoZSBob3N0IHNpZGUsIGV4Y2VwdCB0aGF0CisgKiBOT1RFOiAgdGhpcyBpcyBhbmFsb2dvdXMgdG8gJ3N0cnVjdCB1cmInIG9uIHRoZSBob3N0IHNpZGUsIGV4Y2VwdCB0aGF0CiAgKiBpdCdzIHRoaW5uZXIgYW5kIHByb21vdGVzIG1vcmUgcHJlLWFsbG9jYXRpb24uCiAgKi8KIApAQCAtMjY5LDcgKzI2OSw3IEBACiAgKgogICogQ29udHJvbCBlbmRwb2ludHMgLi4uIGFmdGVyIGdldHRpbmcgYSBzZXR1cCgpIGNhbGxiYWNrLCB0aGUgZHJpdmVyIHF1ZXVlcwogICogb25lIHJlc3BvbnNlIChldmVuIGlmIGl0IHdvdWxkIGJlIHplcm8gbGVuZ3RoKS4gIFRoYXQgZW5hYmxlcyB0aGUKLSAqIHN0YXR1cyBhY2ssIGFmdGVyIHRyYW5zZmVyaW5nIGRhdGEgYXMgc3BlY2lmaWVkIGluIHRoZSByZXNwb25zZS4gIFNldHVwCisgKiBzdGF0dXMgYWNrLCBhZnRlciB0cmFuc2ZlcnJpbmcgZGF0YSBhcyBzcGVjaWZpZWQgaW4gdGhlIHJlc3BvbnNlLiAgU2V0dXAKICAqIGZ1bmN0aW9ucyBtYXkgcmV0dXJuIG5lZ2F0aXZlIGVycm9yIGNvZGVzIHRvIGdlbmVyYXRlIHByb3RvY29sIHN0YWxscy4KICAqIChOb3RlIHRoYXQgc29tZSBVU0IgZGV2aWNlIGNvbnRyb2xsZXJzIGRpc2FsbG93IHByb3RvY29sIHN0YWxsIHJlc3BvbnNlcwogICogaW4gc29tZSBjYXNlcy4pICBXaGVuIGNvbnRyb2wgcmVzcG9uc2VzIGFyZSBkZWZlcnJlZCAodGhlIHJlc3BvbnNlIGlzCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3VzYi9taWRpLmggYi9pbmNsdWRlL2xpbnV4L3VzYi9taWRpLmgKaW5kZXggMWQxMDQwOC4uYzhjNTJlMyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91c2IvbWlkaS5oCisrKyBiL2luY2x1ZGUvbGludXgvdXNiL21pZGkuaApAQCAtNzAsNyArNzAsNyBAQAogCV9fdTggIGJKYWNrSUQ7CiAJX191OCAgYk5ySW5wdXRQaW5zOwkJLyogcCAqLwogCXN0cnVjdCB1c2JfbWlkaV9zb3VyY2VfcGluIHBpbnNbXTsgLyogW3BdICovCi0JLypfX3U4ICBpSmFjazsgIC0tIG9tbWl0dGVkIGR1ZSB0byB2YXJpYWJsZS1zaXplZCBwaW5zW10gKi8KKwkvKl9fdTggIGlKYWNrOyAgLS0gb21pdHRlZCBkdWUgdG8gdmFyaWFibGUtc2l6ZWQgcGluc1tdICovCiB9IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKTsKIAogI2RlZmluZSBVU0JfRFRfTUlESV9PVVRfU0laRShwKQkoNyArIDIgKiAocCkpCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3VzYi93dXNiLmggYi9pbmNsdWRlL2xpbnV4L3VzYi93dXNiLmgKaW5kZXggNjNlYmRjYy4uMGM0ZDRjYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91c2Ivd3VzYi5oCisrKyBiL2luY2x1ZGUvbGludXgvdXNiL3d1c2IuaApAQCAtMTI2LDcgKzEyNiw3IEBACiAvKioKICAqIFdVU0IgSUU6IENoYW5uZWwgU3RvcCAoV1VTQjEuMFs3LjUuOF0pCiAgKgotICogVGVsbHMgZGV2aWNlcyB0aGUgaG9zdCBpcyBnb2luZyB0byBzdG9wIHNlbmRpbmcgTU1DcyBhbmQgd2lsbCBkaXNzYXBlYXIuCisgKiBUZWxscyBkZXZpY2VzIHRoZSBob3N0IGlzIGdvaW5nIHRvIHN0b3Agc2VuZGluZyBNTUNzIGFuZCB3aWxsIGRpc2FwcGVhci4KICAqLwogc3RydWN0IHd1aWVfY2hhbm5lbF9zdG9wIHsKIAlzdHJ1Y3Qgd3VpZV9oZHIgaGRyOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91d2IuaCBiL2luY2x1ZGUvbGludXgvdXdiLmgKaW5kZXggN2ZjOTc0Ni4uYjBjNTY0ZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91d2IuaAorKysgYi9pbmNsdWRlL2xpbnV4L3V3Yi5oCkBAIC0yNzQsNyArMjc0LDcgQEAKIAogLyoqCiAgKiBzdHJ1Y3QgdXdiX2RycF9hdmFpbCAtIGEgcmFkaW8gY29udHJvbGxlcidzIHZpZXcgb2YgTUFTIHVzYWdlCi0gKiBAZ2xvYmFsOiAgIE1BUyB1bnVzZWQgYnkgbmVpZ2hib3JzIChleGNsdWRpbmcgcmVzZXJ2YXRpb25zIHRhcmdldHRlZAorICogQGdsb2JhbDogICBNQVMgdW51c2VkIGJ5IG5laWdoYm9ycyAoZXhjbHVkaW5nIHJlc2VydmF0aW9ucyB0YXJnZXRlZAogICogICAgICAgICAgICBvciBvd25lZCBieSB0aGUgbG9jYWwgcmFkaW8gY29udHJvbGxlcikgb3IgdGhlIGJlYW9uIHBlcmlvZAogICogQGxvY2FsOiAgICBNQVMgdW51c2VkIGJ5IGxvY2FsIGVzdGFibGlzaGVkIHJlc2VydmF0aW9ucwogICogQHBlbmRpbmc6ICBNQVMgdW51c2VkIGJ5IGxvY2FsIHBlbmRpbmcgcmVzZXJ2YXRpb25zCkBAIC03MDIsMTAgKzcwMiwxMCBAQAogCWVkYy0+dGltZXN0YXJ0ID0gamlmZmllczsKIH0KIAotLyogQ2FsbGVkIHdoZW4gYW4gZXJyb3Igb2NjdXJlZC4KKy8qIENhbGxlZCB3aGVuIGFuIGVycm9yIG9jY3VycmVkLgogICogVGhpcyBpcyB3YXkgdG8gZGV0ZXJtaW5lIGlmIHRoZSBudW1iZXIgb2YgYWNjZXB0YWJsZSBlcnJvcnMgcGVyIHRpbWUKICAqIHBlcmlvZCBoYXMgYmVlbiBleGNlZWRlZC4gSXQgaXMgbm90IGFjY3VyYXRlIGFzIHRoZXJlIGFyZSBjYXNlcyBpbiB3aGljaAotICogdGhpcyBzY2hlbWUgd2lsbCBub3Qgd29yaywgZm9yIGV4YW1wbGUgaWYgdGhlcmUgYXJlIHBlcmlvZGljIG9jY3VyZW5jZXMKKyAqIHRoaXMgc2NoZW1lIHdpbGwgbm90IHdvcmssIGZvciBleGFtcGxlIGlmIHRoZXJlIGFyZSBwZXJpb2RpYyBvY2N1cnJlbmNlcwogICogb2YgZXJyb3JzIHRoYXQgc3RyYWRkbGUgdXBkYXRlcyB0byB0aGUgc3RhcnQgdGltZS4gVGhpcyBzY2hlbWUgaXMKICAqIHN1ZmZpY2llbnQgZm9yIG91ciB1c2FnZS4KICAqCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3V3Yi91bWMuaCBiL2luY2x1ZGUvbGludXgvdXdiL3VtYy5oCmluZGV4IDRiNGZjMGYuLjdiNDg0MjAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdXdiL3VtYy5oCisrKyBiL2luY2x1ZGUvbGludXgvdXdiL3VtYy5oCkBAIC0xMzIsNyArMTMyLDcgQEAKICAqCiAgKiBGSVhNRTogVGhpcyBpcyBhcyBkaXJ0eSBhcyBpdCBnZXRzLCBidXQgd2UgbmVlZCBzb21lIHdheSB0byBjaGVjawogICogdGhlIGNvcnJlY3QgdHlwZSBvZiB1bWNfZGV2LT5wYXJlbnQgKHNvIHRoYXQgZm9yIGV4YW1wbGUsIHdlIGNhbgotICogY2FzdCB0byBwY2lfZGV2KS4gQ2FzdGluZyB0byBwY2lfZGV2IGlzIG5lY2VzYXJ5IGJlY2F1c2UgYXQgc29tZQorICogY2FzdCB0byBwY2lfZGV2KS4gQ2FzdGluZyB0byBwY2lfZGV2IGlzIG5lY2Vzc2FyeSBiZWNhdXNlIGF0IHNvbWUKICAqIHBvaW50IHdlIG5lZWQgdG8gcmVxdWVzdCByZXNvdXJjZXMgZnJvbSB0aGUgZGV2aWNlLiBNYXBwaW5nIGlzCiAgKiBlYXNpbHkgb3ZlciBjb21lIChpb3JlbWFwIGFuZCBzdHVmZiBhcmUgYnVzIGFnbm9zdGljKSwgYnV0IGhvb2tpbmcKICAqIHVwIHRvIHNvbWUgZXJyb3IgaGFuZGxlcnMgKHN1Y2ggYXMgcGNpIGVycm9yIGhhbmRsZXJzKSBtaWdodCBuZWVkCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3ZnYWFyYi5oIGIvaW5jbHVkZS9saW51eC92Z2FhcmIuaAppbmRleCBlOWUxNTI0Li45YzMxMjBkIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3ZnYWFyYi5oCisrKyBiL2luY2x1ZGUvbGludXgvdmdhYXJiLmgKQEAgLTc4LDcgKzc4LDcgQEAKICAqICAgICB3ZXRoZXIgdGhlIGNhcmQgaXMgZG9pbmcgbGVnYWN5IGRlY29kaW5nIGZvciB0aGF0IHR5cGUgb2YgcmVzb3VyY2UuIElmCiAgKiAgICAgeWVzLCB0aGUgbG9jayBpcyAiY29udmVydGVkIiBpbnRvIGEgbGVnYWN5IHJlc291cmNlIGxvY2suCiAgKiAgICAgVGhlIGFyYml0ZXIgd2lsbCBmaXJzdCBsb29rIGZvciBhbGwgVkdBIGNhcmRzIHRoYXQgbWlnaHQgY29uZmxpY3QKLSAqICAgICBhbmQgZGlzYWJsZSB0aGVpciBJT3MgYW5kL29yIE1lbW9yeSBhY2Nlc3MsIGlubGN1ZGluZyBWR0EgZm9yd2FyZGluZworICogICAgIGFuZCBkaXNhYmxlIHRoZWlyIElPcyBhbmQvb3IgTWVtb3J5IGFjY2VzcywgaW5jbHVkaW5nIFZHQSBmb3J3YXJkaW5nCiAgKiAgICAgb24gUDJQIGJyaWRnZXMgaWYgbmVjZXNzYXJ5LCBzbyB0aGF0IHRoZSByZXF1ZXN0ZWQgcmVzb3VyY2VzIGNhbgogICogICAgIGJlIHVzZWQuIFRoZW4sIHRoZSBjYXJkIGlzIG1hcmtlZCBhcyBsb2NraW5nIHRoZXNlIHJlc291cmNlcyBhbmQKICAqICAgICB0aGUgSU8gYW5kL29yIE1lbW9yeSBhY2Nlc3NlIGFyZSBlbmFibGVkIG9uIHRoZSBjYXJkIChpbmNsdWRpbmcKQEAgLTE4Nyw3ICsxODcsNyBAQAogICogICAgIHZnYV9jb25mbGljdHMKICAqCiAgKiAgICAgQXJjaGl0ZWN0dXJlcyBzaG91bGQgZGVmaW5lIHRoaXMgaWYgdGhleSBoYXZlIHNldmVyYWwKLSAqICAgICBpbmRlcGVuZGFudCBQQ0kgZG9tYWlucyB0aGF0IGNhbiBhZmZvcmQgY29uY3VycmVudCBWR0EKKyAqICAgICBpbmRlcGVuZGVudCBQQ0kgZG9tYWlucyB0aGF0IGNhbiBhZmZvcmQgY29uY3VycmVudCBWR0EKICAqICAgICBkZWNvZGluZwogICovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvd2ltYXguaCBiL2luY2x1ZGUvbGludXgvd2ltYXguaAppbmRleCA0ZmRjYzU2Li45ZjZiNzdhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3dpbWF4LmgKKysrIGIvaW5jbHVkZS9saW51eC93aW1heC5oCkBAIC0xMTQsNyArMTE0LDcgQEAKIAlXSU1BWF9HTkxfUkVTRVRfSUZJRFggPSAxLAogfTsKIAotLyogQXRyaWJ1dGVzIGZvciB3aW1heF9zdGF0ZV9nZXQoKSAqLworLyogQXR0cmlidXRlcyBmb3Igd2ltYXhfc3RhdGVfZ2V0KCkgKi8KIGVudW0gewogCVdJTUFYX0dOTF9TVEdFVF9JRklEWCA9IDEsCiB9OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC94aWxpbnhmYi5oIGIvaW5jbHVkZS9saW51eC94aWxpbnhmYi5oCmluZGV4IGYyNDYzZjUuLjVhMTU1YTkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgveGlsaW54ZmIuaAorKysgYi9pbmNsdWRlL2xpbnV4L3hpbGlueGZiLmgKQEAgLTE2LDcgKzE2LDcgQEAKIC8qIE1MMzAwLzQwMyByZWZlcmVuY2UgZGVzaWduIGZyYW1lYnVmZmVyIGRyaXZlciBwbGF0Zm9ybSBkYXRhIHN0cnVjdCAqLwogc3RydWN0IHhpbGlueGZiX3BsYXRmb3JtX2RhdGEgewogCXUzMiByb3RhdGVfc2NyZWVuOwkvKiBGbGFnIHRvIHJvdGF0ZSBkaXNwbGF5IDE4MCBkZWdyZWVzICovCi0JdTMyIHNjcmVlbl9oZWlnaHRfbW07CS8qIFBoeXNpY2FsIGRpbWVudGlvbnMgb2Ygc2NyZWVuIGluIG1tICovCisJdTMyIHNjcmVlbl9oZWlnaHRfbW07CS8qIFBoeXNpY2FsIGRpbWVuc2lvbnMgb2Ygc2NyZWVuIGluIG1tICovCiAJdTMyIHNjcmVlbl93aWR0aF9tbTsKIAl1MzIgeHJlcywgeXJlczsJCS8qIHJlc29sdXRpb24gb2Ygc2NyZWVuIGluIHBpeGVscyAqLwogCXUzMiB4dmlydCwgeXZpcnQ7CS8qIHJlc29sdXRpb24gb2YgbWVtb3J5IGJ1ZmZlciAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9tZWRpYS9kYXZpbmNpL2RtMzU1X2NjZGMuaCBiL2luY2x1ZGUvbWVkaWEvZGF2aW5jaS9kbTM1NV9jY2RjLmgKaW5kZXggZGY4YTdiMS4uYWRmMmZlNCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZWRpYS9kYXZpbmNpL2RtMzU1X2NjZGMuaAorKysgYi9pbmNsdWRlL21lZGlhL2RhdmluY2kvZG0zNTVfY2NkYy5oCkBAIC0xOTMsNyArMTkzLDcgQEAKICNkZWZpbmUgQ0NEQ19ERlRfVEFCTEVfU0laRQkxNgogLyoKICAqIE1haW4gU3RydWN0dXJlIGZvciB2ZXJ0aWNhbCBkZWZlY3QgY29ycmVjdGlvbi4gVmVydGljYWwgZGVmZWN0Ci0gKiBjb3JyZWN0aW9uIGNhbiBjb3JyZWN0IHVwdG8gMTYgZGVmZWN0cyBpZiBkZWZlY3RzIGxlc3MgdGhhbiAxNgorICogY29ycmVjdGlvbiBjYW4gY29ycmVjdCB1cCB0byAxNiBkZWZlY3RzIGlmIGRlZmVjdHMgbGVzcyB0aGFuIDE2CiAgKiB0aGVuIHBhZCB0aGUgcmVzdCB3aXRoIDAKICAqLwogc3RydWN0IGNjZGNfdmVydGljYWxfZGZ0IHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbWVkaWEvZGF2aW5jaS9pc2lmLmggYi9pbmNsdWRlL21lZGlhL2RhdmluY2kvaXNpZi5oCmluZGV4IGIwYjc0YWQuLjdmM2Q3NmE0IDEwMDY0NAotLS0gYS9pbmNsdWRlL21lZGlhL2RhdmluY2kvaXNpZi5oCisrKyBiL2luY2x1ZGUvbWVkaWEvZGF2aW5jaS9pc2lmLmgKQEAgLTE5OSw3ICsxOTksNyBAQAogfTsKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSoqIENvbG9yIFNwYWNlIENvbnZlcnRpb24gKENTQykKKyoqIENvbG9yIFNwYWNlIENvbnZlcnNpb24gKENTQykKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAjZGVmaW5lIElTSUZfQ1NDX05VTV9DT0VGRgkxNgogc3RydWN0IGlzaWZfY29sb3Jfc3BhY2VfY29udiB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL2xpcmMuaCBiL2luY2x1ZGUvbWVkaWEvbGlyYy5oCmluZGV4IDY2NzhhMTY5Li40YjNhYjI5IDEwMDY0NAotLS0gYS9pbmNsdWRlL21lZGlhL2xpcmMuaAorKysgYi9pbmNsdWRlL21lZGlhL2xpcmMuaApAQCAtMTM3LDcgKzEzNyw3IEBACiAgKi8KICNkZWZpbmUgTElSQ19TRVRfUkVDX0ZJTFRFUl9TUEFDRSAgICAgIF9JT1coJ2knLCAweDAwMDAwMDFiLCBfX3UzMikKIC8qCi0gKiBpZiBmaWx0ZXIgY2Fubm90IGJlIHNldCBpbmRlcGVuZGFudGx5IGZvciBwdWxzZS9zcGFjZSwgdGhpcyBzaG91bGQKKyAqIGlmIGZpbHRlciBjYW5ub3QgYmUgc2V0IGluZGVwZW5kZW50bHkgZm9yIHB1bHNlL3NwYWNlLCB0aGlzIHNob3VsZAogICogYmUgdXNlZAogICovCiAjZGVmaW5lIExJUkNfU0VUX1JFQ19GSUxURVIgICAgICAgICAgICBfSU9XKCdpJywgMHgwMDAwMDAxYywgX191MzIpCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC85cC85cC5oIGIvaW5jbHVkZS9uZXQvOXAvOXAuaAppbmRleCA2Yjc1YTY5Li5jZGYyZThhIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC85cC85cC5oCisrKyBiL2luY2x1ZGUvbmV0LzlwLzlwLmgKQEAgLTExOSw3ICsxMTksNyBAQAogICogQFA5X1RSRUFEOiByZXF1ZXN0IHRvIHRyYW5zZmVyIGRhdGEgZnJvbSBhIGZpbGUgb3IgZGlyZWN0b3J5CiAgKiBAUDlfUlJFQUQ6IHJlc3BvbnNlIHdpdGggZGF0YSByZXF1ZXN0ZWQKICAqIEBQOV9UV1JJVEU6IHJldXFlc3QgdG8gdHJhbnNmZXIgZGF0YSB0byBhIGZpbGUKLSAqIEBQOV9SV1JJVEU6IHJlc3BvbnNlIHdpdGggb3V0IG11Y2ggZGF0YSB3YXMgdHJhbnNmZXJlZCB0byBmaWxlCisgKiBAUDlfUldSSVRFOiByZXNwb25zZSB3aXRoIG91dCBtdWNoIGRhdGEgd2FzIHRyYW5zZmVycmVkIHRvIGZpbGUKICAqIEBQOV9UQ0xVTks6IGZvcmdldCBhYm91dCBhIGhhbmRsZSB0byBhbiBlbnRpdHkgd2l0aGluIHRoZSBmaWxlIHN5c3RlbQogICogQFA5X1JDTFVOSzogcmVzcG9uc2Ugd2hlbiBzZXJ2ZXIgaGFzIGZvcmdvdHRlbiBhYm91dCB0aGUgaGFuZGxlCiAgKiBAUDlfVFJFTU9WRTogcmVxdWVzdCB0byByZW1vdmUgYW4gZW50aXR5IGZyb20gdGhlIGhpZXJhcmNoeQpAQCAtMjk0LDcgKzI5NCw3IEBACiAgKgogICogUUlEIHR5cGVzIGFyZSBhIHN1YnNldCBvZiBwZXJtaXNzaW9ucyAtIHRoZXkgYXJlIHByaW1hcmlseQogICogdXNlZCB0byBkaWZmZXJlbnRpYXRlIHNlbWFudGljcyBmb3IgYSBmaWxlIHN5c3RlbSBlbnRpdHkgdmlhCi0gKiBhIGp1bXAtdGFibGUuICBUaGVpciB2YWx1ZSBpcyBhbHNvIHRoZSBtb3N0IHNpZ25pZmlnYW50IDE2IGJpdHMKKyAqIGEganVtcC10YWJsZS4gIFRoZWlyIHZhbHVlIGlzIGFsc28gdGhlIG1vc3Qgc2lnbmlmaWNhbnQgMTYgYml0cwogICogb2YgdGhlIHBlcm1pc3Npb25fdAogICoKICAqIFNlZSBBbHNvOiBodHRwOi8vcGxhbjkuYmVsbC1sYWJzLmNvbS9tYWdpYy9tYW4yaHRtbC8yL3N0YXQKQEAgLTM2Niw4ICszNjYsOCBAQAogLyoqCiAgKiBzdHJ1Y3QgcDlfc3RhdCAtIGZpbGUgc3lzdGVtIG1ldGFkYXRhIGluZm9ybWF0aW9uCiAgKiBAc2l6ZTogbGVuZ3RoIHByZWZpeCBmb3IgdGhpcyBzdGF0IHN0cnVjdHVyZSBpbnN0YW5jZQotICogQHR5cGU6IHRoZSB0eXBlIG9mIHRoZSBzZXJ2ZXIgKGVxdWl2aWxlbnQgdG8gYSBtYWpvciBudW1iZXIpCi0gKiBAZGV2OiB0aGUgc3ViLXR5cGUgb2YgdGhlIHNlcnZlciAoZXF1aXZpbGVudCB0byBhIG1pbm9yIG51bWJlcikKKyAqIEB0eXBlOiB0aGUgdHlwZSBvZiB0aGUgc2VydmVyIChlcXVpdmFsZW50IHRvIGEgbWFqb3IgbnVtYmVyKQorICogQGRldjogdGhlIHN1Yi10eXBlIG9mIHRoZSBzZXJ2ZXIgKGVxdWl2YWxlbnQgdG8gYSBtaW5vciBudW1iZXIpCiAgKiBAcWlkOiB1bmlxdWUgaWQgZnJvbSB0aGUgc2VydmVyIG9mIHR5cGUgJnA5X3FpZAogICogQG1vZGU6IFBsYW4gOSBmb3JtYXQgcGVybWlzc2lvbnMgb2YgdHlwZSAmcDlfcGVybV90CiAgKiBAYXRpbWU6IExhc3QgYWNjZXNzL3JlYWQgdGltZQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvOXAvY2xpZW50LmggYi9pbmNsdWRlL25ldC85cC9jbGllbnQuaAppbmRleCAwYTMwOTc3Li44NWMxNDEzIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC85cC9jbGllbnQuaAorKysgYi9pbmNsdWRlL25ldC85cC9jbGllbnQuaApAQCAtMTAxLDcgKzEwMSw3IEBACiAgKiBUcmFuc3BvcnQgdXNlIGFuIGFycmF5IHRvIHRyYWNrIG91dHN0YW5kaW5nIHJlcXVlc3RzCiAgKiBpbnN0ZWFkIG9mIGEgbGlzdC4gIFdoaWxlIHRoaXMgbWF5IGluY3VyciBvdmVyaGVhZCBkdXJpbmcgaW5pdGlhbAogICogYWxsb2NhdGlvbiBvciBleHBhbnNpb24sIGl0IG1ha2VzIHJlcXVlc3QgbG9va3VwIG11Y2ggZWFzaWVyIGFzIHRoZQotICogdGFnIGlkIGlzIGEgaW5kZXggaW50byBhbiBhcnJheS4gIChXZSB1c2UgdGFnKzEgc28gdGhhdCB3ZSBjYW4gYWNjb21vZGF0ZQorICogdGFnIGlkIGlzIGEgaW5kZXggaW50byBhbiBhcnJheS4gIChXZSB1c2UgdGFnKzEgc28gdGhhdCB3ZSBjYW4gYWNjb21tb2RhdGUKICAqIHRoZSAtMSB0YWcgZm9yIHRoZSBUX1ZFUlNJT04gcmVxdWVzdCkuCiAgKiBUaGlzIGFsc28gaGFzIHRoZSBuaWNlIGVmZmVjdCBvZiBvbmx5IGhhdmluZyB0byBhbGxvY2F0ZSB3YWl0X3F1ZXVlcwogICogb25jZSwgaW5zdGVhZCBvZiBjb25zdGFudGx5IGFsbG9jYXRpbmcgYW5kIGZyZWVpbmcgdGhlbS4gIEl0cyBwb3NzaWJsZQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvOXAvdHJhbnNwb3J0LmggYi9pbmNsdWRlL25ldC85cC90cmFuc3BvcnQuaAppbmRleCA4Mjg2OGYxLi44ZjA4YzczIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC85cC90cmFuc3BvcnQuaAorKysgYi9pbmNsdWRlL25ldC85cC90cmFuc3BvcnQuaApAQCAtMzAsNyArMzAsNyBAQAogCiAvKiBEZWZhdWx0LiBBZGQgUGF5bG9hZCB0byBQRFUgYmVmb3JlIHNlbmRpbmcgaXQgZG93biB0byB0cmFuc3BvcnQgbGF5ZXIgKi8KICNkZWZpbmUgUDlfVFJBTlNfUFJFRl9QQVlMT0FEX0RFRiAgMHgwCi0vKiBTZW5kIHBheSBsb2FkIHNlcGVyYXRlbHkgdG8gdHJhbnNwb3J0IGxheWVyIGFsb25nIHdpdGggUERVLiovCisvKiBTZW5kIHBheSBsb2FkIHNlcGFyYXRlbHkgdG8gdHJhbnNwb3J0IGxheWVyIGFsb25nIHdpdGggUERVLiovCiAjZGVmaW5lIFA5X1RSQU5TX1BSRUZfUEFZTE9BRF9TRVAgIDB4MQogCiAvKioKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L2NhaWYvY2ZjbmZnLmggYi9pbmNsdWRlL25ldC9jYWlmL2NmY25mZy5oCmluZGV4IGY2ODg0NzguLmYzM2QzNjMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2NhaWYvY2ZjbmZnLmgKKysrIGIvaW5jbHVkZS9uZXQvY2FpZi9jZmNuZmcuaApAQCAtNjksNyArNjksNyBAQAogICoJCWNmY25mZ19hZGRfYWRhcHRfbGF5ZXIgdG8gc3BlY2lmeSBQSFkgZm9yIHRoZSBsaW5rLgogICogQHByZWY6CVRoZSBwaHkgKGxpbmsgbGF5ZXIpIHByZWZlcmVuY2UuCiAgKiBAZmNzOglTcGVjaWZ5IGlmIGNoZWNrc3VtIGlzIHVzZWQgaW4gQ0FJRiBGcmFtaW5nIExheWVyLgotICogQHN0eDoJU3BlY2lmeSBpZiBTdGFydCBPZiBGcmFtZSBlWHRlbnRpb24gaXMgdXNlZC4KKyAqIEBzdHg6CVNwZWNpZnkgaWYgU3RhcnQgT2YgRnJhbWUgZXh0ZW5zaW9uIGlzIHVzZWQuCiAgKi8KIAogdm9pZApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvZ2VuX3N0YXRzLmggYi9pbmNsdWRlL25ldC9nZW5fc3RhdHMuaAppbmRleCBmYTE1NzcxLi5hNzliNmNmIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9nZW5fc3RhdHMuaAorKysgYi9pbmNsdWRlL25ldC9nZW5fc3RhdHMuaApAQCAtMTEsNyArMTEsNyBAQAogCXN0cnVjdCBza19idWZmICogIHNrYjsKIAlzdHJ1Y3QgbmxhdHRyICogICB0YWlsOwogCi0JLyogQmFja3dhcmQgY29tcGF0YWJpbGl0eSAqLworCS8qIEJhY2t3YXJkIGNvbXBhdGliaWxpdHkgKi8KIAlpbnQgICAgICAgICAgICAgICBjb21wYXRfdGNfc3RhdHM7CiAJaW50ICAgICAgICAgICAgICAgY29tcGF0X3hzdGF0czsKIAl2b2lkICogICAgICAgICAgICB4c3RhdHM7CmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9pcF92cy5oIGIvaW5jbHVkZS9uZXQvaXBfdnMuaAppbmRleCAzMGI0OWVkLi5kNTE2ZjAwIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9pcF92cy5oCisrKyBiL2luY2x1ZGUvbmV0L2lwX3ZzLmgKQEAgLTUyLDcgKzUyLDcgQEAKIAkgKi8KIAlpZiAobGlrZWx5KHNrYi0+ZGV2ICYmIHNrYi0+ZGV2LT5uZF9uZXQpKQogCQlyZXR1cm4gZGV2X25ldChza2ItPmRldik7Ci0JaWYgKHNrYl9kc3Qoc2tiKS0+ZGV2KQorCWlmIChza2JfZHN0KHNrYikgJiYgc2tiX2RzdChza2IpLT5kZXYpCiAJCXJldHVybiBkZXZfbmV0KHNrYl9kc3Qoc2tiKS0+ZGV2KTsKIAlXQVJOKHNrYi0+c2ssICJNYXliZSBza2Jfc2tuZXQgc2hvdWxkIGJlIHVzZWQgaW4gJXMoKSBhdCBsaW5lOiVkXG4iLAogCQkgICAgICBfX2Z1bmNfXywgX19MSU5FX18pOwpAQCAtOTIsNyArOTIsNyBAQAogfQogLyoKICAqIFRoaXMgb25lIG5lZWRlZCBmb3Igc2luZ2xlX29wZW5fbmV0IHNpbmNlIG5ldCBpcyBzdG9yZWQgZGlyZWN0bHkgaW4KLSAqIHByaXZhdGUgbm90IGFzIGEgc3RydWN0IGkuZS4gc2VxX2ZpbGVfbmV0IGNhbnQgYmUgdXNlZC4KKyAqIHByaXZhdGUgbm90IGFzIGEgc3RydWN0IGkuZS4gc2VxX2ZpbGVfbmV0IGNhbid0IGJlIHVzZWQuCiAgKi8KIHN0YXRpYyBpbmxpbmUgc3RydWN0IG5ldCAqc2VxX2ZpbGVfc2luZ2xlX25ldChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSkKIHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L2lyZGEvaXJsYXAuaCBiL2luY2x1ZGUvbmV0L2lyZGEvaXJsYXAuaAppbmRleCAxN2ZjZDk2Li5mYjRiNzZkIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9pcmRhL2lybGFwLmgKKysrIGIvaW5jbHVkZS9uZXQvaXJkYS9pcmxhcC5oCkBAIC0yMDQsNyArMjA0LDcgQEAKIAogCW5vdGlmeV90IG5vdGlmeTsgLyogQ2FsbGJhY2tzIHRvIElyTE1QICovCiAKLQlpbnQgICAgbXR0X3JlcXVpcmVkOyAgLyogTWludW11bSB0dXJuYXJvdW5kIHRpbWUgcmVxdWlyZWQgKi8KKwlpbnQgICAgbXR0X3JlcXVpcmVkOyAgLyogTWluaW11bSB0dXJuYXJvdW5kIHRpbWUgcmVxdWlyZWQgKi8KIAlpbnQgICAgeGJvZnNfZGVsYXk7ICAgLyogTnIgb2YgWEJPRidzIHVzZWQgdG8gTVRUICovCiAJaW50ICAgIGJvZnNfY291bnQ7ICAgIC8qIE5lZ290aWF0ZWQgZXh0cmEgQk9GcyAqLwogCWludCAgICBuZXh0X2JvZnM7ICAgICAvKiBOZWdvdGlhdGVkIGV4dHJhIEJPRnMgYWZ0ZXIgbmV4dCBmcmFtZSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvaXJkYS93cmFwcGVyLmggYi9pbmNsdWRlL25ldC9pcmRhL3dyYXBwZXIuaAppbmRleCAyOTQyYWQ2Li5lZWY1M2ViIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9pcmRhL3dyYXBwZXIuaAorKysgYi9pbmNsdWRlL25ldC9pcmRhL3dyYXBwZXIuaApAQCAtNDIsNyArNDIsNyBAQAogCiAjZGVmaW5lIElSREFfVFJBTlMgMHgyMCAgICAvKiBBc3luY2hyb25vdXMgdHJhbnNwYXJlbmN5IG1vZGlmaWVyICovICAgICAgIAogCi0vKiBTdGF0ZXMgZm9yIHJlY2V2aW5nIGEgZnJhbWUgaW4gYXN5bmMgbW9kZSAqLworLyogU3RhdGVzIGZvciByZWNlaXZpbmcgYSBmcmFtZSBpbiBhc3luYyBtb2RlICovCiBlbnVtIHsKIAlPVVRTSURFX0ZSQU1FLCAKIAlCRUdJTl9GUkFNRSwgCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9pdWN2L2l1Y3YuaCBiL2luY2x1ZGUvbmV0L2l1Y3YvaXVjdi5oCmluZGV4IDIwNWEzMzYuLjExMjFiYWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2l1Y3YvaXVjdi5oCisrKyBiL2luY2x1ZGUvbmV0L2l1Y3YvaXVjdi5oCkBAIC0xNzMsNyArMTczLDcgQEAKIAkvKgogCSAqIFRoZSBtZXNzYWdlX3BlbmRpbmcgZnVuY3Rpb24gaXMgY2FsbGVkIGFmdGVyIGFuIGljdXYgaW50ZXJydXB0CiAJICogdHlwZSAweDA2IG9yIHR5cGUgMHgwNyBoYXMgYmVlbiByZWNlaXZlZC4gQSBuZXcgbWVzc2FnZSBpcwotCSAqIGF2YWlsYWJlIGFuZCBjYW4gYmUgcmVjZWl2ZWQgd2l0aCBpdWN2X21lc3NhZ2VfcmVjZWl2ZS4KKwkgKiBhdmFpbGFibGUgYW5kIGNhbiBiZSByZWNlaXZlZCB3aXRoIGl1Y3ZfbWVzc2FnZV9yZWNlaXZlLgogCSAqLwogCXZvaWQgKCptZXNzYWdlX3BlbmRpbmcpKHN0cnVjdCBpdWN2X3BhdGggKiwgc3RydWN0IGl1Y3ZfbWVzc2FnZSAqKTsKIAkvKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvaXdfaGFuZGxlci5oIGIvaW5jbHVkZS9uZXQvaXdfaGFuZGxlci5oCmluZGV4IDNhZmRiMjEuLjVkNWE2YTQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2l3X2hhbmRsZXIuaAorKysgYi9pbmNsdWRlL25ldC9pd19oYW5kbGVyLmgKQEAgLTkxLDcgKzkxLDcgQEAKICAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBUaGUgaW1wbGVtZW50YXRpb24gZ29hbHMgd2VyZSBhcyBmb2xsb3cgOgogICoJbyBPYnZpb3VzIDogeW91IHNob3VsZCBub3QgbmVlZCBhIFBoRCB0byB1bmRlcnN0YW5kIHdoYXQncyBoYXBwZW5pbmcsCi0gKgkJdGhlIGJlbmVmaXQgaXMgZWFzaWVyIG1haW50YWluYW5jZS4KKyAqCQl0aGUgYmVuZWZpdCBpcyBlYXNpZXIgbWFpbnRlbmFuY2UuCiAgKglvIEZsZXhpYmxlIDogaXQgc2hvdWxkIGFjY29tbW9kYXRlIGEgd2lkZSB2YXJpZXR5IG9mIGRyaXZlcgogICoJCWltcGxlbWVudGF0aW9ucyBhbmQgYmUgYXMgZmxleGlibGUgYXMgdGhlIG9sZCBBUEkuCiAgKglvIExlYW4gOiBpdCBzaG91bGQgYmUgZWZmaWNpZW50IG1lbW9yeSB3aXNlIHRvIG1pbmltaXNlIHRoZSBpbXBhY3QKQEAgLTEyOSw3ICsxMjksNyBAQAogICoKICAqIEZ1bmN0aW9ucyBwcm90b3R5cGUgdXNlcyB1bmlvbiBpd3JlcV9kYXRhCiAgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogU29tZSB3b3VsZCBoYXZlIHByZWZlcmVkIGZ1bmN0aW9ucyBkZWZpbmVkIHRoaXMgd2F5IDoKKyAqIFNvbWUgd291bGQgaGF2ZSBwcmVmZXJyZWQgZnVuY3Rpb25zIGRlZmluZWQgdGhpcyB3YXkgOgogICoJc3RhdGljIGludCBteWRyaXZlcl9pb2N0bF9zZXRyYXRlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIAogICoJCQkJCSAgbG9uZyByYXRlLCBpbnQgYXV0bykKICAqIDEpIFRoZSBrZXJuZWwgY29kZSBkb2Vzbid0ICJ2YWxpZGF0ZSIgdGhlIGNvbnRlbnQgb2YgaXdyZXFfZGF0YSwgYW5kCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9tYWM4MDIxMS5oIGIvaW5jbHVkZS9uZXQvbWFjODAyMTEuaAppbmRleCBjZWZlMWIzLi4wMjVkNGNjIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9tYWM4MDIxMS5oCisrKyBiL2luY2x1ZGUvbmV0L21hYzgwMjExLmgKQEAgLTEyOTQsNyArMTI5NCw3IEBACiAgKiBhY2NlbGVyYXRpb24gKGkuZS4gaXdsd2lmaSkuIFRob3NlIGRyaXZlcnMgc2hvdWxkIHByb3ZpZGUgdXBkYXRlX3RraXBfa2V5CiAgKiBoYW5kbGVyLgogICogVGhlIHVwZGF0ZV90a2lwX2tleSgpIGNhbGwgdXBkYXRlcyB0aGUgZHJpdmVyIHdpdGggdGhlIG5ldyBwaGFzZSAxIGtleS4KLSAqIFRoaXMgaGFwcGVucyBldmVyeXRpbWUgdGhlIGl2MTYgd3JhcHMgYXJvdW5kIChldmVyeSA2NTUzNiBwYWNrZXRzKS4gVGhlCisgKiBUaGlzIGhhcHBlbnMgZXZlcnkgdGltZSB0aGUgaXYxNiB3cmFwcyBhcm91bmQgKGV2ZXJ5IDY1NTM2IHBhY2tldHMpLiBUaGUKICAqIHNldF9rZXkoKSBjYWxsIHdpbGwgaGFwcGVuIG9ubHkgb25jZSBmb3IgZWFjaCBrZXkgKHVubGVzcyB0aGUgQVAgZGlkCiAgKiByZWtleWluZyksIGl0IHdpbGwgbm90IGluY2x1ZGUgYSB2YWxpZCBwaGFzZSAxIGtleS4gVGhlIHZhbGlkIHBoYXNlIDEga2V5IGlzCiAgKiBwcm92aWRlZCBieSB1cGRhdGVfdGtpcF9rZXkgb25seS4gVGhlIHRyaWdnZXIgdGhhdCBtYWtlcyBtYWM4MDIxMSBjYWxsIHRoaXMKQEAgLTE3NTMsOCArMTc1MywxOSBAQAogICogCXRoYXQgVFgvUlhfU1RPUCBjYW4gcGFzcyBOVUxMIGZvciB0aGlzIHBhcmFtZXRlci4KICAqCVRoZSBAYnVmX3NpemUgcGFyYW1ldGVyIGlzIG9ubHkgdmFsaWQgd2hlbiB0aGUgYWN0aW9uIGlzIHNldCB0bwogICoJJUlFRUU4MDIxMV9BTVBEVV9UWF9PUEVSQVRJT05BTCBhbmQgaW5kaWNhdGVzIHRoZSBwZWVyJ3MgcmVvcmRlcgotICoJYnVmZmVyIHNpemUgKG51bWJlciBvZiBzdWJmcmFtZXMpIGZvciB0aGlzIHNlc3Npb24gLS0gYWdncmVnYXRlcwotICoJY29udGFpbmluZyBtb3JlIHN1YmZyYW1lcyB0aGFuIHRoaXMgbWF5IG5vdCBiZSB0cmFuc21pdHRlZCB0byB0aGUgcGVlci4KKyAqCWJ1ZmZlciBzaXplIChudW1iZXIgb2Ygc3ViZnJhbWVzKSBmb3IgdGhpcyBzZXNzaW9uIC0tIHRoZSBkcml2ZXIKKyAqCW1heSBuZWl0aGVyIHNlbmQgYWdncmVnYXRlcyBjb250YWluaW5nIG1vcmUgc3ViZnJhbWVzIHRoYW4gdGhpcworICoJbm9yIHNlbmQgYWdncmVnYXRlcyBpbiBhIHdheSB0aGF0IGxvc3QgZnJhbWVzIHdvdWxkIGV4Y2VlZCB0aGUKKyAqCWJ1ZmZlciBzaXplLiBJZiBqdXN0IGxpbWl0aW5nIHRoZSBhZ2dyZWdhdGUgc2l6ZSwgdGhpcyB3b3VsZCBiZQorICoJcG9zc2libGUgd2l0aCBhIGJ1Zl9zaXplIG9mIDg6CisgKgkgLSBUWDogMS4uLi4uNworICoJIC0gUlg6ICAyLi4uLjcgKGxvc3QgZnJhbWUgIzEpCisgKgkgLSBUWDogICAgICAgIDguLjEuLi4KKyAqCXdoaWNoIGlzIGludmFsaWQgc2luY2UgIzEgd2FzIG5vdyByZS10cmFuc21pdHRlZCB3ZWxsIHBhc3QgdGhlCisgKglidWZmZXIgc2l6ZSBvZiA4LiBDb3JyZWN0IHdheXMgdG8gcmV0cmFuc21pdCAjMSB3b3VsZCBiZToKKyAqCSAtIFRYOiAgICAgICAxIG9yIDE4IG9yIDgxCisgKglFdmVuICIxODkiIHdvdWxkIGJlIHdyb25nIHNpbmNlIDEgY291bGQgYmUgbG9zdCBhZ2Fpbi4KKyAqCiAgKglSZXR1cm5zIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogICoJVGhlIGNhbGxiYWNrIGNhbiBzbGVlcC4KICAqCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9wa3Rfc2NoZWQuaCBiL2luY2x1ZGUvbmV0L3BrdF9zY2hlZC5oCmluZGV4IGQ5NTQ5YWYuLjY1YWZjNDkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L3BrdF9zY2hlZC5oCisrKyBiL2luY2x1ZGUvbmV0L3BrdF9zY2hlZC5oCkBAIC0zMiw3ICszMiw3IEBACiAgICAKICAgIFRoZSByZXN1bHQ6IFszNF04NiBpcyBub3QgZ29vZCBjaG9pY2UgZm9yIFFvUyByb3V0ZXIgOi0oCiAKLSAgIFRoZSB0aGluZ3MgYXJlIG5vdCBzbyBiYWQsIGJlY2F1c2Ugd2UgbWF5IHVzZSBhcnRpZmljYWwKKyAgIFRoZSB0aGluZ3MgYXJlIG5vdCBzbyBiYWQsIGJlY2F1c2Ugd2UgbWF5IHVzZSBhcnRpZmljaWFsCiAgICBjbG9jayBldmFsdWF0ZWQgYnkgaW50ZWdyYXRpb24gb2YgbmV0d29yayBkYXRhIGZsb3cKICAgIGluIHRoZSBtb3N0IGNyaXRpY2FsIHBsYWNlcy4KICAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvcm91dGUuaCBiL2luY2x1ZGUvbmV0L3JvdXRlLmgKaW5kZXggZjg4NDI5Yy4uOGZjZTA2MiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9uZXQvcm91dGUuaAorKysgYi9pbmNsdWRlL25ldC9yb3V0ZS5oCkBAIC02NCw2ICs2NCw3IEBACiAKIAlfX2JlMzIJCQlydF9kc3Q7CS8qIFBhdGggZGVzdGluYXRpb24JKi8KIAlfX2JlMzIJCQlydF9zcmM7CS8qIFBhdGggc291cmNlCQkqLworCWludAkJCXJ0X3JvdXRlX2lpZjsKIAlpbnQJCQlydF9paWY7CiAJaW50CQkJcnRfb2lmOwogCV9fdTMyCQkJcnRfbWFyazsKQEAgLTgwLDEyICs4MSwxMiBAQAogCiBzdGF0aWMgaW5saW5lIGJvb2wgcnRfaXNfaW5wdXRfcm91dGUoc3RydWN0IHJ0YWJsZSAqcnQpCiB7Ci0JcmV0dXJuIHJ0LT5ydF9paWYgIT0gMDsKKwlyZXR1cm4gcnQtPnJ0X3JvdXRlX2lpZiAhPSAwOwogfQogCiBzdGF0aWMgaW5saW5lIGJvb2wgcnRfaXNfb3V0cHV0X3JvdXRlKHN0cnVjdCBydGFibGUgKnJ0KQogewotCXJldHVybiBydC0+cnRfaWlmID09IDA7CisJcmV0dXJuIHJ0LT5ydF9yb3V0ZV9paWYgPT0gMDsKIH0KIAogc3RydWN0IGlwX3J0X2FjY3QgewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvc29jay5oIGIvaW5jbHVkZS9uZXQvc29jay5oCmluZGV4IGRhMDUzNGQuLjAxODEwYTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L3NvY2suaAorKysgYi9pbmNsdWRlL25ldC9zb2NrLmgKQEAgLTE3NDksNyArMTc0OSw3IEBACiAKIC8qCiAgKiBLZXJuZWwgc29ja2V0cywgZi5lLiBydG5sIG9yIGljbXBfc29ja2V0LCBhcmUgYSBwYXJ0IG9mIGEgbmFtZXNwYWNlLgotICogVGhleSBzaG91bGQgbm90IGhvbGQgYSByZWZlcnJlbmNlIHRvIGEgbmFtZXNwYWNlIGluIG9yZGVyIHRvIGFsbG93CisgKiBUaGV5IHNob3VsZCBub3QgaG9sZCBhIHJlZmVyZW5jZSB0byBhIG5hbWVzcGFjZSBpbiBvcmRlciB0byBhbGxvdwogICogdG8gc3RvcCBpdC4KICAqIFNvY2tldHMgYWZ0ZXIgc2tfY2hhbmdlX25ldCBzaG91bGQgYmUgcmVsZWFzZWQgdXNpbmcgc2tfcmVsZWFzZV9rZXJuZWwKICAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvdHJhbnNwX3Y2LmggYi9pbmNsdWRlL25ldC90cmFuc3BfdjYuaAppbmRleCBlZWIwNzdkLi5hODEyMmRjIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC90cmFuc3BfdjYuaAorKysgYi9pbmNsdWRlL25ldC90cmFuc3BfdjYuaApAQCAtMTYsNyArMTYsNyBAQAogCiBzdHJ1Y3QgZmxvd2k2OwogCi0vKiBleHRlbnRpb24gaGVhZGVycyAqLworLyogZXh0ZW5zaW9uIGhlYWRlcnMgKi8KIGV4dGVybiBpbnQJCQkJaXB2Nl9leHRoZHJzX2luaXQodm9pZCk7CiBleHRlcm4gdm9pZAkJCQlpcHY2X2V4dGhkcnNfZXhpdCh2b2lkKTsKIGV4dGVybiBpbnQJCQkJaXB2Nl9mcmFnX2luaXQodm9pZCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC93aW1heC5oIGIvaW5jbHVkZS9uZXQvd2ltYXguaAppbmRleCAzNDYxYWExLi5jNzk5YmE3IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC93aW1heC5oCisrKyBiL2luY2x1ZGUvbmV0L3dpbWF4LmgKQEAgLTI4Niw3ICsyODYsNyBAQAogICogICAgIGRvZXMgbm90IGRpc2Nvbm5lY3QgdGhlIGRldmljZSBmcm9tIHRoZSBidXMgYW5kIHJldHVybiAwLgogICogICAgIElmIHRoYXQgZmFpbHMsIGl0IHNob3VsZCByZXNvcnQgdG8gc29tZSBzb3J0IG9mIGNvbGQgb3IgYnVzCiAgKiAgICAgcmVzZXQgKGV2ZW4gaWYgaXQgaW1wbGllcyBhIGJ1cyBkaXNjb25uZWN0aW9uIGFuZCBkZXZpY2UKLSAqICAgICBkaXNzYXBlYXJhbmNlKS4gSW4gdGhhdCBjYXNlLCAtRU5PREVWIHNob3VsZCBiZSByZXR1cm5lZCB0bworICogICAgIGRpc2FwcGVhcmFuY2UpLiBJbiB0aGF0IGNhc2UsIC1FTk9ERVYgc2hvdWxkIGJlIHJldHVybmVkIHRvCiAgKiAgICAgaW5kaWNhdGUgdGhlIGRldmljZSBpcyBnb25lLgogICogICAgIFRoaXMgb3BlcmF0aW9uIGhhcyB0byBiZSBzeW5jaHJvbm91cywgYW5kIHJldHVybiBvbmx5IHdoZW4gdGhlCiAgKiAgICAgcmVzZXQgaXMgY29tcGxldGUuIEluIGNhc2Ugb2YgaGF2aW5nIGhhZCB0byByZXNvcnQgdG8gYnVzL2NvbGQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L3dwYW4tcGh5LmggYi9pbmNsdWRlL25ldC93cGFuLXBoeS5oCmluZGV4IDg1OTI2MjMuLmQ4NmZmZmQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L3dwYW4tcGh5LmgKKysrIGIvaW5jbHVkZS9uZXQvd3Bhbi1waHkuaApAQCAtMjgsNyArMjgsNyBAQAogCXN0cnVjdCBtdXRleCBwaWJfbG9jazsKIAogCS8qCi0JICogVGhpcyBpcyBhIFBJQiBhY29yZGluZyB0byA4MDIuMTUuNC0yMDA2LgorCSAqIFRoaXMgaXMgYSBQSUIgYWNjb3JkaW5nIHRvIDgwMi4xNS40LTIwMDYuCiAJICogV2UgZG8gbm90IHByb3ZpZGUgdGltaW5nLXJlbGF0ZWQgdmFyaWFibGVzLCBhcyB0aGV5CiAJICogYXJlbid0IHVzZWQgb3V0c2lkZSBvZiBkcml2ZXIKIAkgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvcnhycGMvcGFja2V0LmggYi9pbmNsdWRlL3J4cnBjL3BhY2tldC5oCmluZGV4IDliMmMzMDguLmYyOTAyZWYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvcnhycGMvcGFja2V0LmgKKysrIGIvaW5jbHVkZS9yeHJwYy9wYWNrZXQuaApAQCAtMTQ4LDcgKzE0OCw3IEBACiAgKiBLZXJiZXJvcyBzZWN1cml0eSB0eXBlLTIgcmVzcG9uc2UgcGFja2V0CiAgKi8KIHN0cnVjdCByeGthZF9yZXNwb25zZSB7Ci0JX19iZTMyCQl2ZXJzaW9uOwkvKiB2ZXJzaW9uIG9mIHRoaXMgcmVwb25zZSB0eXBlICovCisJX19iZTMyCQl2ZXJzaW9uOwkvKiB2ZXJzaW9uIG9mIHRoaXMgcmVzcG9uc2UgdHlwZSAqLwogCV9fYmUzMgkJX19wYWQ7CiAKIAkvKiBlbmNyeXB0ZWQgYml0IG9mIHRoZSByZXNwb25zZSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zY3NpL2ZjL2ZjX2ZjcC5oIGIvaW5jbHVkZS9zY3NpL2ZjL2ZjX2ZjcC5oCmluZGV4IDhhMTQzY2EuLjY1MmRlYzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc2NzaS9mYy9mY19mY3AuaAorKysgYi9pbmNsdWRlL3Njc2kvZmMvZmNfZmNwLmgKQEAgLTc1LDcgKzc1LDcgQEAKICNkZWZpbmUJRkNQX1BUQV9TSU1QTEUJICAgIDAJLyogc2ltcGxlIHRhc2sgYXR0cmlidXRlICovCiAjZGVmaW5lCUZDUF9QVEFfSEVBRFEJICAgIDEJLyogaGVhZCBvZiBxdWV1ZSB0YXNrIGF0dHJpYnV0ZSAqLwogI2RlZmluZQlGQ1BfUFRBX09SREVSRUQgICAgIDIJLyogb3JkZXJlZCB0YXNrIGF0dHJpYnV0ZSAqLwotI2RlZmluZQlGQ1BfUFRBX0FDQQkgICAgNAkvKiBhdXRvLiBjb250aWdlbnQgYWxsZWdpYW5jZSAqLworI2RlZmluZQlGQ1BfUFRBX0FDQQkgICAgNAkvKiBhdXRvLiBjb250aW5nZW50IGFsbGVnaWFuY2UgKi8KICNkZWZpbmUJRkNQX1BUQV9NQVNLCSAgICA3CS8qIG1hc2sgZm9yIHRhc2sgYXR0cmlidXRlIGZpZWxkICovCiAjZGVmaW5lCUZDUF9QUklfU0hJRlQJICAgIDMJLyogcHJpb3JpdHkgZmllbGQgc3RhcnRzIGluIGJpdCAzICovCiAjZGVmaW5lCUZDUF9QUklfUkVTVkRfTUFTSyAgMHg4MAkvKiByZXNlcnZlZCBiaXRzIGluIHByaW9yaXR5IGZpZWxkICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3Njc2kvaXNjc2lfaWYuaCBiL2luY2x1ZGUvc2NzaS9pc2NzaV9pZi5oCmluZGV4IGMzZTFjYmMuLmRkYjA0NTYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc2NzaS9pc2NzaV9pZi5oCisrKyBiL2luY2x1ZGUvc2NzaS9pc2NzaV9pZi5oCkBAIC0yOTIsNyArMjkyLDcgQEAKIAlJU0NTSV9QQVJBTV9QRVJTSVNURU5UX1BPUlQsCiAJSVNDU0lfUEFSQU1fU0VTU19SRUNPVkVSWV9UTU8sCiAKLQkvKiBwYXNlZCBpbiB0aHJvdWdoIGJpbmQgY29ubiB1c2luZyB0cmFuc3BvcnRfZmQgKi8KKwkvKiBwYXNzZWQgaW4gdGhyb3VnaCBiaW5kIGNvbm4gdXNpbmcgdHJhbnNwb3J0X2ZkICovCiAJSVNDU0lfUEFSQU1fQ09OTl9QT1JULAogCUlTQ1NJX1BBUkFNX0NPTk5fQUREUkVTUywKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zY3NpL2xpYmZjLmggYi9pbmNsdWRlL3Njc2kvbGliZmMuaAppbmRleCAyNDE5M2MxLi5hM2NiZGE0IDEwMDY0NAotLS0gYS9pbmNsdWRlL3Njc2kvbGliZmMuaAorKysgYi9pbmNsdWRlL3Njc2kvbGliZmMuaApAQCAtMjYwLDcgKzI2MCw3IEBACiAvKioKICAqIHN0cnVjdCBmY19zZXFfZWxzX2RhdGEgLSBFTFMgZGF0YSB1c2VkIGZvciBwYXNzaW5nIEVMUyBzcGVjaWZpYyByZXNwb25zZXMKICAqIEByZWFzb246IFRoZSByZWFzb24gZm9yIHJlamVjdGlvbgotICogQGV4cGxhbjogVGhlIGV4cGxhaW5hdGlvbiBvZiB0aGUgcmVqZWN0aW9uCisgKiBAZXhwbGFuOiBUaGUgZXhwbGFuYXRpb24gb2YgdGhlIHJlamVjdGlvbgogICoKICAqIE1haW5seSB1c2VkIGJ5IHRoZSBleGNoYW5nZSBtYW5hZ2VyIGxheWVyLgogICovCkBAIC01MjUsNyArNTI1LDcgQEAKIAkJCXN0cnVjdCBmY19mcmFtZSAqKTsKIAogCS8qCi0JICogU2VuZCBhbiBFTFMgcmVzcG9uc2UgdXNpbmcgaW5mb21hdGlvbiBmcm9tIHRoZSByZWNlaXZlZCBmcmFtZS4KKwkgKiBTZW5kIGFuIEVMUyByZXNwb25zZSB1c2luZyBpbmZvcm1hdGlvbiBmcm9tIHRoZSByZWNlaXZlZCBmcmFtZS4KIAkgKgogCSAqIFNUQVRVUzogT1BUSU9OQUwKIAkgKi8KQEAgLTY2Myw3ICs2NjMsNyBAQAogCWludCAoKnJwb3J0X2xvZ29mZikoc3RydWN0IGZjX3Jwb3J0X3ByaXYgKik7CiAKIAkvKgotCSAqIFJlY2lldmUgYSByZXF1ZXN0IGZyb20gYSByZW1vdGUgcG9ydC4KKwkgKiBSZWNlaXZlIGEgcmVxdWVzdCBmcm9tIGEgcmVtb3RlIHBvcnQuCiAJICoKIAkgKiBTVEFUVVM6IE9QVElPTkFMCiAJICovCkBAIC03MDQsNyArNzA0LDcgQEAKIAkJCQkJIHZvaWQgKikpOwogCiAJLyoKLQkgKiBDbGVhbnVwIHRoZSBGQ1AgbGF5ZXIsIHVzZWQgZHVycmluZyBsaW5rIGRvd24gYW5kIHJlc2V0CisJICogQ2xlYW51cCB0aGUgRkNQIGxheWVyLCB1c2VkIGR1cmluZyBsaW5rIGRvd24gYW5kIHJlc2V0CiAJICoKIAkgKiBTVEFUVVM6IE9QVElPTkFMCiAJICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3Njc2kvbGliaXNjc2lfdGNwLmggYi9pbmNsdWRlL3Njc2kvbGliaXNjc2lfdGNwLmgKaW5kZXggZTZiOWZkMi4uYWMwY2MxZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zY3NpL2xpYmlzY3NpX3RjcC5oCisrKyBiL2luY2x1ZGUvc2NzaS9saWJpc2NzaV90Y3AuaApAQCAtNTIsNyArNTIsNyBAQAogCWlzY3NpX3NlZ21lbnRfZG9uZV9mbl90CSpkb25lOwogfTsKIAotLyogU29ja2V0IGNvbm5lY3Rpb24gcmVjaWV2ZSBoZWxwZXIgKi8KKy8qIFNvY2tldCBjb25uZWN0aW9uIHJlY2VpdmUgaGVscGVyICovCiBzdHJ1Y3QgaXNjc2lfdGNwX3JlY3YgewogCXN0cnVjdCBpc2NzaV9oZHIJKmhkcjsKIAlzdHJ1Y3QgaXNjc2lfc2VnbWVudAlzZWdtZW50OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zY3NpL29zZF9pbml0aWF0b3IuaCBiL2luY2x1ZGUvc2NzaS9vc2RfaW5pdGlhdG9yLmgKaW5kZXggNTNhOWU4OC4uMGE1MDc5OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zY3NpL29zZF9pbml0aWF0b3IuaAorKysgYi9pbmNsdWRlL3Njc2kvb3NkX2luaXRpYXRvci5oCkBAIC0yNjUsNyArMjY1LDcgQEAKICAqIEBvc2kgICAgICAgICAgIC0gUmVjaWV2cyBhIG1vcmUgZGV0YWlsZWQgZXJyb3IgcmVwb3J0IGluZm9ybWF0aW9uIChvcHRpb25hbCkuCiAgKiBAc2lsZW50ICAgICAgICAtIERvIG5vdCBwcmludCB0byBkbXNnIChFdmVuIGlmIGVuYWJsZWQpCiAgKiBAYmFkX29ial9saXN0ICAtIFNvbWUgY29tbWFuZHMgYWN0IG9uIG11bHRpcGxlIG9iamVjdHMuIEZhaWxlZCBvYmplY3RzIHdpbGwKLSAqICAgICAgICAgICAgICAgICAgYmUgcmVjaWV2ZWQgaGVyZSAob3B0aW9uYWwpCisgKiAgICAgICAgICAgICAgICAgIGJlIHJlY2VpdmVkIGhlcmUgKG9wdGlvbmFsKQogICogQG1heF9vYmogICAgICAgLSBTaXplIG9mIEBiYWRfb2JqX2xpc3QuCiAgKiBAYmFkX2F0dHJfbGlzdCAtIExpc3Qgb2YgZmFpbGluZyBhdHRyaWJ1dGVzIChvcHRpb25hbCkKICAqIEBtYXhfYXR0ciAgICAgIC0gU2l6ZSBvZiBAYmFkX2F0dHJfbGlzdC4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvc2NzaS9zY3NpX2hvc3QuaCBiL2luY2x1ZGUvc2NzaS9zY3NpX2hvc3QuaAppbmRleCBlN2UzODU4Li5mMWYyNjQ0IDEwMDY0NAotLS0gYS9pbmNsdWRlL3Njc2kvc2NzaV9ob3N0LmgKKysrIGIvaW5jbHVkZS9zY3NpL3Njc2lfaG9zdC5oCkBAIC00Niw3ICs0Niw3IEBACiBlbnVtIHsKIAlTQ1NJX1FERVBUSF9ERUZBVUxULAkvKiBkZWZhdWx0IHJlcXVlc3RlZCBjaGFuZ2UsIGUuZy4gZnJvbSBzeXNmcyAqLwogCVNDU0lfUURFUFRIX1FGVUxMLAkvKiBzY3NpLW1sIHJlcXVlc3RlZCBkdWUgdG8gcXVldWUgZnVsbCAqLwotCVNDU0lfUURFUFRIX1JBTVBfVVAsCS8qIHNjc2ktbWwgcmVxdWVzdGVkIGR1ZSB0byB0aHJlc2hob2xkIGV2ZW50ICovCisJU0NTSV9RREVQVEhfUkFNUF9VUCwJLyogc2NzaS1tbCByZXF1ZXN0ZWQgZHVlIHRvIHRocmVzaG9sZCBldmVudCAqLwogfTsKIAogc3RydWN0IHNjc2lfaG9zdF90ZW1wbGF0ZSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuaCBiL2luY2x1ZGUvc2NzaS9zY3NpX3RyYW5zcG9ydF9mYy5oCmluZGV4IDU5ODE2ZmUuLjJhNjUxNjcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc2NzaS9zY3NpX3RyYW5zcG9ydF9mYy5oCisrKyBiL2luY2x1ZGUvc2NzaS9zY3NpX3RyYW5zcG9ydF9mYy5oCkBAIC0xOTIsOSArMTkyLDkgQEAKICAqCiAgKiBUaGlzIHN0cnVjdHVyZSBleGlzdHMgZm9yIGVhY2ggRkMgcG9ydCBpcyBhIHZpcnR1YWwgRkMgcG9ydC4gVmlydHVhbAogICogcG9ydHMgc2hhcmUgdGhlIHBoeXNpY2FsIGxpbmsgd2l0aCB0aGUgUGh5c2ljYWwgcG9ydC4gRWFjaCB2aXJ0dWFsCi0gKiBwb3J0cyBoYXMgYSB1bmlxdWUgcHJlc2Vuc2Ugb24gdGhlIFNBTiwgYW5kIG1heSBiZSBpbnN0YW50aWF0ZWQgdmlhCisgKiBwb3J0cyBoYXMgYSB1bmlxdWUgcHJlc2VuY2Ugb24gdGhlIFNBTiwgYW5kIG1heSBiZSBpbnN0YW50aWF0ZWQgdmlhCiAgKiBOUElWLCBWaXJ0dWFsIEZhYnJpY3MsIG9yIHZpYSBhZGRpdGlvbmFsIEFMUEFzLiBBcyB0aGUgdnBvcnQgaXMgYQotICogdW5pcXVlIHByZXNlbnNlLCBlYWNoIHZwb3J0IGhhcyBpdCdzIG93biB2aWV3IG9mIHRoZSBmYWJyaWMsCisgKiB1bmlxdWUgcHJlc2VuY2UsIGVhY2ggdnBvcnQgaGFzIGl0J3Mgb3duIHZpZXcgb2YgdGhlIGZhYnJpYywKICAqIGF1dGhlbnRpY2F0aW9uIHByaXZpbGVnZSwgYW5kIHByaW9yaXRpZXMuCiAgKgogICogQSB2aXJ0dWFsIHBvcnQgbWF5IHN1cHBvcnQgMSBvciBtb3JlIEZDNCByb2xlcy4gVHlwaWNhbGx5IGl0IGlzIGEKQEAgLTM3MCw3ICszNzAsNyBAQAogLyoKICAqIEZDIFNDU0kgVGFyZ2V0IEF0dHJpYnV0ZXMKICAqCi0gKiBUaGUgU0NTSSBUYXJnZXQgaXMgY29uc2lkZXJlZCBhbiBleHRlbnRpb24gb2YgYSByZW1vdGUgcG9ydCAoYXMKKyAqIFRoZSBTQ1NJIFRhcmdldCBpcyBjb25zaWRlcmVkIGFuIGV4dGVuc2lvbiBvZiBhIHJlbW90ZSBwb3J0IChhcwogICogYSByZW1vdGUgcG9ydCBjYW4gYmUgbW9yZSB0aGFuIGEgU0NTSSBUYXJnZXQpLiBXaXRoaW4gdGhlIHNjc2kKICAqIHN1YnN5c3RlbSwgd2UgbGVhdmUgdGhlIFRhcmdldCBhcyBhIHNlcGFyYXRlIGVudGl0eS4gRG9pbmcgc28KICAqIHByb3ZpZGVzIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2l0aCBwcmlvciBGQyB0cmFuc3BvcnQgYXBpJ3MsCmRpZmYgLS1naXQgYS9pbmNsdWRlL3NvdW5kL2FjOTdfY29kZWMuaCBiL2luY2x1ZGUvc291bmQvYWM5N19jb2RlYy5oCmluZGV4IGYxZGNlZmU0Li4wMmNiYjUwIDEwMDY0NAotLS0gYS9pbmNsdWRlL3NvdW5kL2FjOTdfY29kZWMuaAorKysgYi9pbmNsdWRlL3NvdW5kL2FjOTdfY29kZWMuaApAQCAtMzg1LDcgKzM4NSw3IEBACiAjZGVmaW5lIEFDOTdfU0NBUF9ERVRFQ1RfQllfVkVORE9SICgxPDw4KSAvKiB1c2UgdmVuZG9yIHJlZ2lzdGVycyBmb3IgcmVhZCB0ZXN0cyAqLwogI2RlZmluZSBBQzk3X1NDQVBfTk9fU1BESUYJKDE8PDkpCS8qIGRvbid0IGJ1aWxkIFNQRElGIGNvbnRyb2xzICovCiAjZGVmaW5lIEFDOTdfU0NBUF9FQVBEX0xFRAkoMTw8MTApCS8qIEVBUEQgYXMgbXV0ZSBMRUQgKi8KLSNkZWZpbmUgQUM5N19TQ0FQX1BPV0VSX1NBVkUJKDE8PDExKQkvKiBjYXBhYmxlIGZvciBhZ2dyZXNpdmUgcG93ZXItc2F2aW5nICovCisjZGVmaW5lIEFDOTdfU0NBUF9QT1dFUl9TQVZFCSgxPDwxMSkJLyogY2FwYWJsZSBmb3IgYWdncmVzc2l2ZSBwb3dlci1zYXZpbmcgKi8KIAogLyogYWM5Ny0+ZmxhZ3MgKi8KICNkZWZpbmUgQUM5N19IQVNfUENfQkVFUAkoMTw8MCkJLyogZm9yY2UgUEMgU3BlYWtlciB1c2FnZSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zb3VuZC9jb250cm9sLmggYi9pbmNsdWRlL3NvdW5kL2NvbnRyb2wuaAppbmRleCBlNjdkYjI4Li40MDRhY2I4IDEwMDY0NAotLS0gYS9pbmNsdWRlL3NvdW5kL2NvbnRyb2wuaAorKysgYi9pbmNsdWRlL3NvdW5kL2NvbnRyb2wuaApAQCAtMTkxLDcgKzE5MSw3IEBACiAgKiBSZXR1cm5zIHplcm8gaWYgc3VjY2Vzc2Z1bCBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUuCiAgKgogICogQWxsIHNsYXZlcyBtdXN0IGJlIHRoZSBzYW1lIHR5cGUgKHJldHVybmluZyB0aGUgc2FtZSBpbmZvcm1hdGlvbgotICogdmlhIGluZm8gY2FsbGJhY2spLiAgVGhlIGZ1Y250aW9uIGRvZXNuJ3QgY2hlY2sgaXQsIHNvIGl0J3MgeW91cgorICogdmlhIGluZm8gY2FsbGJhY2spLiAgVGhlIGZ1bmN0aW9uIGRvZXNuJ3QgY2hlY2sgaXQsIHNvIGl0J3MgeW91cgogICogcmVzcG9uc2liaWxpdHkuCiAgKgogICogQWxzbywgc29tZSBhZGRpdGlvbmFsIGxpbWl0YXRpb25zOgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zb3VuZC9jczQ2eHhfZHNwX3Nwb3MuaCBiL2luY2x1ZGUvc291bmQvY3M0Nnh4X2RzcF9zcG9zLmgKaW5kZXggNDliMDNjOS4uODAwOGM1OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zb3VuZC9jczQ2eHhfZHNwX3Nwb3MuaAorKysgYi9pbmNsdWRlL3NvdW5kL2NzNDZ4eF9kc3Bfc3Bvcy5oCkBAIC0xNDcsNyArMTQ3LDcgQEAKIH07CiAKIHN0cnVjdCBkc3Bfc3Bvc19pbnN0YW5jZSB7Ci0Jc3RydWN0IGRzcF9zeW1ib2xfZGVzYyBzeW1ib2xfdGFibGU7IC8qIGN1cnJlbnRseSBhdmFpbGJsZSBsb2FkZWQgc3ltYm9scyBpbiBTUCAqLworCXN0cnVjdCBkc3Bfc3ltYm9sX2Rlc2Mgc3ltYm9sX3RhYmxlOyAvKiBjdXJyZW50bHkgYXZhaWxhYmxlIGxvYWRlZCBzeW1ib2xzIGluIFNQICovCiAKIAlpbnQgbm1vZHVsZXM7CiAJc3RydWN0IGRzcF9tb2R1bGVfZGVzYyAqIG1vZHVsZXM7IC8qIG1vZHVsZXMgbG9hZGVkIGludG8gU1AgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvc291bmQvaGRzcG0uaCBiL2luY2x1ZGUvc291bmQvaGRzcG0uaAppbmRleCAxNzc0ZmY1Li4xZjU5ZWEyIDEwMDY0NAotLS0gYS9pbmNsdWRlL3NvdW5kL2hkc3BtLmgKKysrIGIvaW5jbHVkZS9zb3VuZC9oZHNwbS5oCkBAIC0xOTMsNyArMTkzLDcgQEAKICAqIDMyNzY4IEJ5dGVzCiAgKi8KIAotLyogb3JnYW5pc2F0aW9uIGlzIDY0IGNoYW5uZWxmYWRlciBpbiBhIGNvbnRpbm91cyBtZW1vcnkgYmxvY2sgKi8KKy8qIG9yZ2FuaXNhdGlvbiBpcyA2NCBjaGFubmVsZmFkZXIgaW4gYSBjb250aW51b3VzIG1lbW9yeSBibG9jayAqLwogLyogZXF1aXZhbGVudCB0byBoYXJkd2FyZSBkZWZpbml0aW9uLCBtYXliZSBmb3IgZnV0dXJlIGZlYXR1cmUgb2YgbW1hcCBvZgogICogdGhlbQogICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3NvdW5kL3NvYy1kYXBtLmggYi9pbmNsdWRlL3NvdW5kL3NvYy1kYXBtLmgKaW5kZXggZGRjMmIzZC4uZjcyYzEwMyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zb3VuZC9zb2MtZGFwbS5oCisrKyBiL2luY2x1ZGUvc291bmQvc29jLWRhcG0uaApAQCAtMjMsNyArMjMsNyBAQAogLyoKICAqIFNvQyBkeW5hbWljIGF1ZGlvIHBvd2VyIG1hbmFnZW1lbnQKICAqCi0gKiBXZSBjYW4gaGF2ZSB1cHRvIDQgcG93ZXIgZG9tYWlucworICogV2UgY2FuIGhhdmUgdXAgdG8gNCBwb3dlciBkb21haW5zCiAgKiAJMS4gQ29kZWMgZG9tYWluIC0gVlJFRiwgVk1JRAogICogICAgIFVzdWFsbHkgY29udHJvbGxlZCBhdCBjb2RlYyBwcm9iZS9yZW1vdmUsIGFsdGhvdWdoIGNhbiBiZSBzZXQKICAqICAgICBhdCBzdHJlYW0gdGltZSBpZiBwb3dlciBpcyBub3QgbmVlZGVkIGZvciBzaWRldG9uZSwgZXRjLgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oCmluZGV4IGMxNWVkNTAuLjFkM2I1YjIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaAorKysgYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9iYXNlLmgKQEAgLTIyLDcgKzIyLDcgQEAKICAqIE5vdGUgdGhhdCBib3RoIGluY2x1ZGUvc2NzaS9zY3NpX2NtbmQuaDpNQVhfQ09NTUFORF9TSVpFIGFuZAogICogaW5jbHVkZS9saW51eC9ibGtkZXYuaDpCTE9DS19NQVhfQ0RCIGFzIG9mIHYyLjYuMzYtcmM0IHN0aWxsIHVzZQogICogMTYtYnl0ZSBDREJzIGJ5IGRlZmF1bHQgYW5kIHJlcXVpcmUgYW4gZXh0cmEgYWxsb2NhdGlvbiBmb3IKLSAqIDMyLWJ5dGUgQ0RCcyB0byBiZWNhc3VlIG9mIGxlZ2FjeSBpc3N1ZXMuCisgKiAzMi1ieXRlIENEQnMgdG8gYmVjYXVzZSBvZiBsZWdhY3kgaXNzdWVzLgogICoKICAqIFdpdGhpbiBUQ00gQ29yZSB0aGVyZSBhcmUgbm8gc3VjaCBsZWdhY3kgbGltaXRpYXRpb25zLCBzbyB3ZSBnbyBhaGVhZAogICogdXNlIDMyLWJ5dGUgQ0RCcyBieSBkZWZhdWx0IGFuZCB1c2UgaW5jbHVkZS9zY3NpL3Njc2kuaDpzY3NpX2NvbW1hbmRfc2l6ZSgpCkBAIC0zMDIsNyArMzAyLDcgQEAKIAogCiAvKgotICogVXNlZCBieSBUQ00gQ29yZSBpbnRlcm5hbGx5IHRvIHNpZ25hbCBpZiA+PSBTUEMtMyBwZXJpc3RlbnQgcmVzZXJ2YXRpb25zCisgKiBVc2VkIGJ5IFRDTSBDb3JlIGludGVybmFsbHkgdG8gc2lnbmFsIGlmID49IFNQQy0zIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb25zCiAgKiBlbXVsYXRpb24gaXMgZW5hYmxlZCBvciBkaXNhYmxlZCwgb3IgcnVubmluZyBpbiB3aXRoIFRDTS9wU0NTSSBwYXNzdGhyb3VnaAogICogbW9kZQogICovCkBAIC05MzQsNyArOTM0LDcgQEAKIAlzdHJ1Y3QgbGlzdF9oZWFkCWFjbF9ub2RlX2xpc3Q7CiAJc3RydWN0IHNlX2x1bgkJKnRwZ19sdW5fbGlzdDsKIAlzdHJ1Y3Qgc2VfbHVuCQl0cGdfdmlydF9sdW4wOwotCS8qIExpc3Qgb2YgVENNIHNlc3Npb25zIGFzc29pY2F0ZWQgd3RoIHRoaXMgVFBHICovCisJLyogTGlzdCBvZiBUQ00gc2Vzc2lvbnMgYXNzb2NpYXRlZCB3dGggdGhpcyBUUEcgKi8KIAlzdHJ1Y3QgbGlzdF9oZWFkCXRwZ19zZXNzX2xpc3Q7CiAJLyogUG9pbnRlciB0byAkRkFCUklDX01PRCBkZXBlbmRlbnQgY29kZSAqLwogCXN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICpzZV90cGdfdGZvOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oCmluZGV4IDVlYjhiMWEuLmRjNzhmNzcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaAorKysgYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmgKQEAgLTM1LDcgKzM1LDcgQEAKIAkvKgogCSAqIE9wdGlvbmFsIGZ1bmN0aW9uIHBvaW50ZXIgZm9yIFRDTSB0byBwZXJmb3JtIGNvbW1hbmQgbWFwCiAJICogZnJvbSBUQ00gcHJvY2Vzc2luZyB0aHJlYWQgY29udGV4dCwgZm9yIHRob3NlIHN0cnVjdCBzZV9jbWQKLQkgKiBpbml0YWxseSBhbGxvY2F0ZWQgaW4gaW50ZXJydXB0IGNvbnRleHQuCisJICogaW5pdGlhbGx5IGFsbG9jYXRlZCBpbiBpbnRlcnJ1cHQgY29udGV4dC4KIAkgKi8KIAlpbnQgKCpuZXdfY21kX21hcCkoc3RydWN0IHNlX2NtZCAqKTsKIAkvKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS92aWRlby9reXJvLmggYi9pbmNsdWRlL3ZpZGVvL2t5cm8uaAppbmRleCBkYmE3ZGUyLi5jNTYzOTY4IDEwMDY0NAotLS0gYS9pbmNsdWRlL3ZpZGVvL2t5cm8uaAorKysgYi9pbmNsdWRlL3ZpZGVvL2t5cm8uaApAQCAtMzIsNyArMzIsNyBAQAogCXUzMiBQSVhDTEs7CS8qIFBpeGVsIENsb2NrICAgICAgICovCiAJdTMyIEhDTEs7CS8qIEhvciBDbG9jayAgICAgICAgICovCiAKLQkvKiBVc2VmdWxsIHRvIGhvbGQgZGVwdGggaGVyZSBmb3IgTGludXggKi8KKwkvKiBVc2VmdWwgdG8gaG9sZCBkZXB0aCBoZXJlIGZvciBMaW51eCAqLwogCXU4IFBJWERFUFRIOwogCiAjaWZkZWYgQ09ORklHX01UUlIKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdmlkZW8vbmVvbWFnaWMuaCBiL2luY2x1ZGUvdmlkZW8vbmVvbWFnaWMuaAppbmRleCAwOGI2NjM3Li5iYzUwMTNlIDEwMDY0NAotLS0gYS9pbmNsdWRlL3ZpZGVvL25lb21hZ2ljLmgKKysrIGIvaW5jbHVkZS92aWRlby9uZW9tYWdpYy5oCkBAIC0xMjksNyArMTI5LDcgQEAKIAl1bnNpZ25lZCBjaGFyIENSVENbMjVdOwkJLyogQ3J0YyBDb250cm9sbGVyICovCiAJdW5zaWduZWQgY2hhciBTZXF1ZW5jZXJbNV07CS8qIFZpZGVvIFNlcXVlbmNlciAqLwogCXVuc2lnbmVkIGNoYXIgR3JhcGhpY3NbOV07CS8qIFZpZGVvIEdyYXBoaWNzICovCi0JdW5zaWduZWQgY2hhciBBdHRyaWJ1dGVbMjFdOwkvKiBWaWRlbyBBdHJpYnV0ZSAqLworCXVuc2lnbmVkIGNoYXIgQXR0cmlidXRlWzIxXTsJLyogVmlkZW8gQXR0cmlidXRlICovCiAKIAl1bnNpZ25lZCBjaGFyIEdlbmVyYWxMb2NrUmVnOwogCXVuc2lnbmVkIGNoYXIgRXh0Q1JURGlzcEFkZHI7CmRpZmYgLS1naXQgYS9pbmNsdWRlL3ZpZGVvL25ld3BvcnQuaCBiL2luY2x1ZGUvdmlkZW8vbmV3cG9ydC5oCmluZGV4IDAwMWI5MzUuLjNkN2M0YjQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdmlkZW8vbmV3cG9ydC5oCisrKyBiL2luY2x1ZGUvdmlkZW8vbmV3cG9ydC5oCkBAIC01LDcgKzUsNyBAQAogICoKICAqIENvcHlyaWdodCAoQykgMTk5NiBEYXZpZCBTLiBNaWxsZXIgKGRtQGVuZ3Iuc2dpLmNvbSkKICAqIAotICogVWxmIENhcmxzc29uIC0gQ29tcGFiaWxpdHkgd2l0aCB0aGUgSVJJWCBzdHJ1Y3R1cmVzIGFkZGVkCisgKiBVbGYgQ2FybHNzb24gLSBDb21wYXRpYmlsaXR5IHdpdGggdGhlIElSSVggc3RydWN0dXJlcyBhZGRlZAogICovCiAKICNpZm5kZWYgX1NHSV9ORVdQT1JUX0gKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdmlkZW8vc2lzZmIuaCBiL2luY2x1ZGUvdmlkZW8vc2lzZmIuaAppbmRleCBmZGQ3NGYxLi42ZGM1ZGY5IDEwMDY0NAotLS0gYS9pbmNsdWRlL3ZpZGVvL3Npc2ZiLmgKKysrIGIvaW5jbHVkZS92aWRlby9zaXNmYi5oCkBAIC0xNTEsNyArMTUxLDcgQEAKIAlfX3UzMiAgc2lzZmJfcmVzdWx0WzRdOwogfTsKIAotLyogQWRkdGlvbmFsIElPQ1RMcyBmb3IgY29tbXVuaWNhdGlvbiBzaXNmYiA8PiBYIGRyaXZlciAgICAgICAgICAgICAgICAqLworLyogQWRkaXRpb25hbCBJT0NUTHMgZm9yIGNvbW11bmljYXRpb24gc2lzZmIgPD4gWCBkcml2ZXIgICAgICAgICAgICAgICAgKi8KIC8qIElmIGNoYW5naW5nIHRoaXMsIHZnYXR5cGVzLmggbXVzdCBhbHNvIGJlIGNoYW5nZWQgKGZvciBYIGRyaXZlcikgICAgKi8KIAogLyogaW9jdGwgZm9yIGlkZW50aWZ5aW5nIGFuZCBnaXZpbmcgc29tZSBpbmZvIChlc3AuIG1lbW9yeSBoZWFwIHN0YXJ0KSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS92aWRlby9zc3RmYi5oIGIvaW5jbHVkZS92aWRlby9zc3RmYi5oCmluZGV4IGI1MmYwNzMuLmM0NDllYWMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdmlkZW8vc3N0ZmIuaAorKysgYi9pbmNsdWRlL3ZpZGVvL3NzdGZiLmgKQEAgLTE1Niw3ICsxNTYsNyBAQAogI2RlZmluZSBEQUNfUkVBRAkJRkJJSU5JVDIJLyogaW4gcmVtYXAgbW9kZSAqLwogI2RlZmluZSBGQklJTklUMwkJMHgwMjFjCQkvKiBmYmkgY29udHJvbHMgKi8KICMgIGRlZmluZSBESVNBQkxFX1RFWFRVUkUJICBCSVQoNikKLSMgIGRlZmluZSBZX1NXQVBfT1JJR0lOX1NISUZUCSAgMjIJCS8qIFkgc3dhcCBzdWJzdHJhY3Rpb24gdmFsdWUgKi8KKyMgIGRlZmluZSBZX1NXQVBfT1JJR0lOX1NISUZUCSAgMjIJCS8qIFkgc3dhcCBzdWJ0cmFjdGlvbiB2YWx1ZSAqLwogI2RlZmluZSBIU1lOQwkJCTB4MDIyMAogI2RlZmluZSBWU1lOQwkJCTB4MDIyNAogI2RlZmluZSBEQUNfREFUQQkJMHgwMjJjCkBAIC0yMTIsOSArMjEyLDkgQEAKICMgIGRlZmluZSBEQUNSRUdfQ1IwXzI0QlBQCSAgMHg1MAkJLyogbW9kZSA1ICovCiAjZGVmaW5lCURBQ1JFR19DUjFfSQkJMHgwNQogI2RlZmluZSBEQUNSRUdfQ0NfSQkJMHgwNgotIyAgZGVmaW5lIERBQ1JFR19DQ19DTEtBCSAgQklUKDcpCS8qIGNsayBBIGNvbnRyb2xlZCBieSByZWdzICovCisjICBkZWZpbmUgREFDUkVHX0NDX0NMS0EJICBCSVQoNykJLyogY2xrIEEgY29udHJvbGxlZCBieSByZWdzICovCiAjICBkZWZpbmUgREFDUkVHX0NDX0NMS0FfQwkgICgyPDw0KQkvKiBjbGsgQSB1c2VzIHJlZyBDICovCi0jICBkZWZpbmUgREFDUkVHX0NDX0NMS0IJICBCSVQoMykJLyogY2xrIEIgY29udHJvbGVkIGJ5IHJlZ3MgKi8KKyMgIGRlZmluZSBEQUNSRUdfQ0NfQ0xLQgkgIEJJVCgzKQkvKiBjbGsgQiBjb250cm9sbGVkIGJ5IHJlZ3MgKi8KICMgIGRlZmluZSBEQUNSRUdfQ0NfQ0xLQl9ECSAgMwkJLyogY2xrQiB1c2VzIHJlZyBEICovCiAjZGVmaW5lIERBQ1JFR19BQzBfSQkJMHg0OAkJLyogY2xvY2sgQSByZWcgQyAqLwogI2RlZmluZSBEQUNSRUdfQUMxX0kJCTB4NDkKZGlmZiAtLWdpdCBhL2luY2x1ZGUveGVuL2ludGVyZmFjZS9lbGZub3RlLmggYi9pbmNsdWRlL3hlbi9pbnRlcmZhY2UvZWxmbm90ZS5oCmluZGV4IDdhODI2MmMuLjAzNjBiMTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUveGVuL2ludGVyZmFjZS9lbGZub3RlLmgKKysrIGIvaW5jbHVkZS94ZW4vaW50ZXJmYWNlL2VsZm5vdGUuaApAQCAtNTEsNyArNTEsNyBAQAogCiAvKgogICogVGhlIG9mZnNldCBvZiB0aGUgRUxGIHBhZGRyIGZpZWxkIGZyb20gdGhlIGFjdXRhbCByZXF1aXJlZAotICogcHN1ZWRvLXBoeXNpY2FsIGFkZHJlc3MgKG51bWVyaWMpLgorICogcHNldWRvLXBoeXNpY2FsIGFkZHJlc3MgKG51bWVyaWMpLgogICoKICAqIFRoaXMgaXMgdXNlZCB0byBtYWludGFpbiBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSB3aXRoIG9sZGVyIGtlcm5lbHMKICAqIHdoaWNoIHdyb3RlIF9fUEFHRV9PRkZTRVQgaW50byB0aGF0IGZpZWxkLiBUaGlzIGZpZWxkIGRlZmF1bHRzIHRvIDAKZGlmZiAtLWdpdCBhL2luaXQvZG9fbW91bnRzLmMgYi9pbml0L2RvX21vdW50cy5jCmluZGV4IDNlMDExMjEuLmMwODUxYTggMTAwNjQ0Ci0tLSBhL2luaXQvZG9fbW91bnRzLmMKKysrIGIvaW5pdC9kb19tb3VudHMuYwpAQCAtMTg2LDcgKzE4Niw3IEBACiAJCWdvdG8gZG9uZTsKIAogCS8qCi0JICogdHJ5IG5vbi1leGlzdGFudCwgYnV0IHZhbGlkIHBhcnRpdGlvbiwgd2hpY2ggbWF5IG9ubHkgZXhpc3QKKwkgKiB0cnkgbm9uLWV4aXN0ZW50LCBidXQgdmFsaWQgcGFydGl0aW9uLCB3aGljaCBtYXkgb25seSBleGlzdAogCSAqIGFmdGVyIHJldmFsaWRhdGluZyB0aGUgZGlzaywgbGlrZSBwYXJ0aXRpb25lZCBtZCBkZXZpY2VzCiAJICovCiAJd2hpbGUgKHAgPiBzICYmIGlzZGlnaXQocFstMV0pKQpkaWZmIC0tZ2l0IGEvaXBjL21zZy5jIGIvaXBjL21zZy5jCmluZGV4IDBlNzMyZTkuLjczODVkZTIgMTAwNjQ0Ci0tLSBhL2lwYy9tc2cuYworKysgYi9pcGMvbXNnLmMKQEAgLTcwNCw3ICs3MDQsNyBAQAogCW1zcS0+cV9zdGltZSA9IGdldF9zZWNvbmRzKCk7CiAKIAlpZiAoIXBpcGVsaW5lZF9zZW5kKG1zcSwgbXNnKSkgewotCQkvKiBub29uZSBpcyB3YWl0aW5nIGZvciB0aGlzIG1lc3NhZ2UsIGVucXVldWUgaXQgKi8KKwkJLyogbm8gb25lIGlzIHdhaXRpbmcgZm9yIHRoaXMgbWVzc2FnZSwgZW5xdWV1ZSBpdCAqLwogCQlsaXN0X2FkZF90YWlsKCZtc2ctPm1fbGlzdCwgJm1zcS0+cV9tZXNzYWdlcyk7CiAJCW1zcS0+cV9jYnl0ZXMgKz0gbXNnc3o7CiAJCW1zcS0+cV9xbnVtKys7CkBAIC04NDIsNyArODQyLDcgQEAKIAkJICogRGlzYWJsZSBwcmVlbXB0aW9uLiAgV2UgZG9uJ3QgaG9sZCBhIHJlZmVyZW5jZSB0byB0aGUgcXVldWUKIAkJICogYW5kIGdldHRpbmcgYSByZWZlcmVuY2Ugd291bGQgZGVmZWF0IHRoZSBpZGVhIG9mIGEgbG9ja2xlc3MKIAkJICogb3BlcmF0aW9uLCB0aHVzIHRoZSBjb2RlIHJlbGllcyBvbiByY3UgdG8gZ3VhcmFudGVlIHRoZQotCQkgKiBleGlzdGFuY2Ugb2YgbXNxOgorCQkgKiBleGlzdGVuY2Ugb2YgbXNxOgogCQkgKiBQcmlvciB0byBkZXN0cnVjdGlvbiwgZXhwdW5nZV9hbGwoLUVJUkRNKSBjaGFuZ2VzIHJfbXNnLgogCQkgKiBUaHVzIGlmIHJfbXNnIGlzIC1FQUdBSU4sIHRoZW4gdGhlIHF1ZXVlIG5vdCB5ZXQgZGVzdHJveWVkLgogCQkgKiByY3VfcmVhZF9sb2NrKCkgcHJldmVudHMgcHJlZW1wdGlvbiBiZXR3ZWVuIHJlYWRpbmcgcl9tc2cKZGlmZiAtLWdpdCBhL2lwYy9zZW0uYyBiL2lwYy9zZW0uYwppbmRleCBhZTA0MGEwLi4zNDE5M2VkIDEwMDY0NAotLS0gYS9pcGMvc2VtLmMKKysrIGIvaXBjL3NlbS5jCkBAIC0xMzYyLDcgKzEzNjIsNyBAQAogCSAqIHNlbWlkIGlkZW50aWZpZXJzIGFyZSBub3QgdW5pcXVlIC0gZmluZF9hbGxvY191bmRvIG1heSBoYXZlCiAJICogYWxsb2NhdGVkIGFuIHVuZG8gc3RydWN0dXJlLCBpdCB3YXMgaW52YWxpZGF0ZWQgYnkgYW4gUk1JRAogCSAqIGFuZCBub3cgYSBuZXcgYXJyYXkgd2l0aCByZWNlaXZlZCB0aGUgc2FtZSBpZC4gQ2hlY2sgYW5kIGZhaWwuCi0JICogVGhpcyBjYXNlIGNhbiBiZSBkZXRlY3RlZCBjaGVja2luZyB1bi0+c2VtaWQuIFRoZSBleGlzdGFuY2Ugb2YKKwkgKiBUaGlzIGNhc2UgY2FuIGJlIGRldGVjdGVkIGNoZWNraW5nIHVuLT5zZW1pZC4gVGhlIGV4aXN0ZW5jZSBvZgogCSAqICJ1biIgaXRzZWxmIGlzIGd1YXJhbnRlZWQgYnkgcmN1LgogCSAqLwogCWVycm9yID0gLUVJRFJNOwpkaWZmIC0tZ2l0IGEvaXBjL3NobS5jIGIvaXBjL3NobS5jCmluZGV4IDg2NDQ0NTIuLjcyOWFjYjcgMTAwNjQ0Ci0tLSBhL2lwYy9zaG0uYworKysgYi9pcGMvc2htLmMKQEAgLTEwNTYsNyArMTA1Niw3IEBACiAJLyoKIAkgKiBXZSBuZWVkIGxvb2sgbm8gZnVydGhlciB0aGFuIHRoZSBtYXhpbXVtIGFkZHJlc3MgYSBmcmFnbWVudAogCSAqIGNvdWxkIHBvc3NpYmx5IGhhdmUgbGFuZGVkIGF0LiBBbHNvIGNhc3QgdGhpbmdzIHRvIGxvZmZfdCB0bwotCSAqIHByZXZlbnQgb3ZlcmZsb3dzIGFuZCBtYWtlIGNvbXBhcmlzaW9ucyB2cy4gZXF1YWwtd2lkdGggdHlwZXMuCisJICogcHJldmVudCBvdmVyZmxvd3MgYW5kIG1ha2UgY29tcGFyaXNvbnMgdnMuIGVxdWFsLXdpZHRoIHR5cGVzLgogCSAqLwogCXNpemUgPSBQQUdFX0FMSUdOKHNpemUpOwogCXdoaWxlICh2bWEgJiYgKGxvZmZfdCkodm1hLT52bV9lbmQgLSBhZGRyKSA8PSBzaXplKSB7CmRpZmYgLS1naXQgYS9rZXJuZWwvYXVkaXRfdHJlZS5jIGIva2VybmVsL2F1ZGl0X3RyZWUuYwppbmRleCAzN2IyYmVhLi5lOTlkZGEwIDEwMDY0NAotLS0gYS9rZXJuZWwvYXVkaXRfdHJlZS5jCisrKyBiL2tlcm5lbC9hdWRpdF90cmVlLmMKQEAgLTYwNyw3ICs2MDcsNyBAQAogCQlzcGluX2xvY2soJmhhc2hfbG9jayk7CiAJCWxpc3RfZm9yX2VhY2hfZW50cnkobm9kZSwgJnRyZWUtPmNodW5rcywgbGlzdCkgewogCQkJc3RydWN0IGF1ZGl0X2NodW5rICpjaHVuayA9IGZpbmRfY2h1bmsobm9kZSk7Ci0JCQkvKiB0aGlzIGNvdWxkIGJlIE5VTEwgaWYgdGhlIHdhdGNoIGlzIGRpZWluZyBlbHNlIHdoZXJlLi4uICovCisJCQkvKiB0aGlzIGNvdWxkIGJlIE5VTEwgaWYgdGhlIHdhdGNoIGlzIGR5aW5nIGVsc2Ugd2hlcmUuLi4gKi8KIAkJCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBjaHVuay0+bWFyay5pLmlub2RlOwogCQkJbm9kZS0+aW5kZXggfD0gMVU8PDMxOwogCQkJaWYgKGl0ZXJhdGVfbW91bnRzKGNvbXBhcmVfcm9vdCwgaW5vZGUsIHJvb3RfbW50KSkKZGlmZiAtLWdpdCBhL2tlcm5lbC9hdWRpdHNjLmMgYi9rZXJuZWwvYXVkaXRzYy5jCmluZGV4IGY0OWEwMzEuLmIzMzUxM2EgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9hdWRpdHNjLmMKKysrIGIva2VybmVsL2F1ZGl0c2MuYwpAQCAtMTAxMSw3ICsxMDExLDcgQEAKIC8qCiAgKiB0b19zZW5kIGFuZCBsZW5fc2VudCBhY2NvdW50aW5nIGFyZSB2ZXJ5IGxvb3NlIGVzdGltYXRlcy4gIFdlIGFyZW4ndAogICogcmVhbGx5IHdvcnJpZWQgYWJvdXQgYSBoYXJkIGNhcCB0byBNQVhfRVhFQ1ZFX0FVRElUX0xFTiBzbyBtdWNoIGFzIGJlaW5nCi0gKiB3aXRoaW4gYWJvdXQgNTAwIGJ5dGVzIChuZXh0IHBhZ2UgYm91bmRyeSkKKyAqIHdpdGhpbiBhYm91dCA1MDAgYnl0ZXMgKG5leHQgcGFnZSBib3VuZGFyeSkKICAqCiAgKiB3aHkgc25wcmludGY/ICBhbiBpbnQgaXMgdXAgdG8gMTIgZGlnaXRzIGxvbmcuICBpZiB3ZSBqdXN0IGFzc3VtZWQgd2hlbgogICogbG9nZ2luZyB0aGF0IGFbJWRdPSB3YXMgZ29pbmcgdG8gYmUgMTYgY2hhcmFjdGVycyBsb25nIHdlIHdvdWxkIGJlIHdhc3RpbmcKZGlmZiAtLWdpdCBhL2tlcm5lbC9jZ3JvdXAuYyBiL2tlcm5lbC9jZ3JvdXAuYwppbmRleCBlMzFiMjIwLi4yNWM3ZWI1IDEwMDY0NAotLS0gYS9rZXJuZWwvY2dyb3VwLmMKKysrIGIva2VybmVsL2Nncm91cC5jCkBAIC0xNTcsNyArMTU3LDcgQEAKIH07CiAKIC8qCi0gKiBjZ3JvdXBfZXZlbnQgcmVwcmVzZW50cyBldmVudHMgd2hpY2ggdXNlcnNwYWNlIHdhbnQgdG8gcmVjaWV2ZS4KKyAqIGNncm91cF9ldmVudCByZXByZXNlbnRzIGV2ZW50cyB3aGljaCB1c2Vyc3BhY2Ugd2FudCB0byByZWNlaXZlLgogICovCiBzdHJ1Y3QgY2dyb3VwX2V2ZW50IHsKIAkvKgpkaWZmIC0tZ2l0IGEva2VybmVsL2NwdS5jIGIva2VybmVsL2NwdS5jCmluZGV4IGM5NWZjNGQuLjEyYjc0NTggMTAwNjQ0Ci0tLSBhL2tlcm5lbC9jcHUuYworKysgYi9rZXJuZWwvY3B1LmMKQEAgLTEyNiw3ICsxMjYsNyBAQAogI2Vsc2UgLyogI2lmIENPTkZJR19IT1RQTFVHX0NQVSAqLwogc3RhdGljIHZvaWQgY3B1X2hvdHBsdWdfYmVnaW4odm9pZCkge30KIHN0YXRpYyB2b2lkIGNwdV9ob3RwbHVnX2RvbmUodm9pZCkge30KLSNlbmRpZgkvKiAjZXNsZSAjaWYgQ09ORklHX0hPVFBMVUdfQ1BVICovCisjZW5kaWYJLyogI2Vsc2UgI2lmIENPTkZJR19IT1RQTFVHX0NQVSAqLwogCiAvKiBOZWVkIHRvIGtub3cgYWJvdXQgQ1BVcyBnb2luZyB1cC9kb3duPyAqLwogaW50IF9fcmVmIHJlZ2lzdGVyX2NwdV9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iKQpkaWZmIC0tZ2l0IGEva2VybmVsL2RlYnVnL2RlYnVnX2NvcmUuYyBiL2tlcm5lbC9kZWJ1Zy9kZWJ1Z19jb3JlLmMKaW5kZXggY2VmZDRhMS4uYmFkNjc4NiAxMDA2NDQKLS0tIGEva2VybmVsL2RlYnVnL2RlYnVnX2NvcmUuYworKysgYi9rZXJuZWwvZGVidWcvZGVidWdfY29yZS5jCkBAIC01MzgsNyArNTM4LDcgQEAKIAogCS8qCiAJICogRm9yIHNpbmdsZSBzdGVwcGluZywgdHJ5IHRvIG9ubHkgZW50ZXIgb24gdGhlIHByb2Nlc3NvcgotCSAqIHRoYXQgd2FzIHNpbmdsZSBzdGVwcGluZy4gIFRvIGdhdXJkIGFnYWluc3QgYSBkZWFkbG9jaywgdGhlCisJICogdGhhdCB3YXMgc2luZ2xlIHN0ZXBwaW5nLiAgVG8gZ3VhcmQgYWdhaW5zdCBhIGRlYWRsb2NrLCB0aGUKIAkgKiBrZXJuZWwgd2lsbCBvbmx5IHRyeSBmb3IgdGhlIHZhbHVlIG9mIHNzdGVwX3RyaWVzIGJlZm9yZQogCSAqIGdpdmluZyB1cCBhbmQgY29udGludWluZyBvbi4KIAkgKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9kZWJ1Zy9rZGIva2RiX21haW4uYyBiL2tlcm5lbC9kZWJ1Zy9rZGIva2RiX21haW4uYwppbmRleCA2YmM2ZTNiLi5iZTE0Nzc5IDEwMDY0NAotLS0gYS9rZXJuZWwvZGVidWcva2RiL2tkYl9tYWluLmMKKysrIGIva2VybmVsL2RlYnVnL2tkYi9rZGJfbWFpbi5jCkBAIC00NDEsOSArNDQxLDkgQEAKICAqCXN5bWJvbCBuYW1lLCBhbmQgb2Zmc2V0IHRvIHRoZSBjYWxsZXIuCiAgKgogICoJVGhlIGFyZ3VtZW50IG1heSBjb25zaXN0IG9mIGEgbnVtZXJpYyB2YWx1ZSAoZGVjaW1hbCBvcgotICoJaGV4aWRlY2ltYWwpLCBhIHN5bWJvbCBuYW1lLCBhIHJlZ2lzdGVyIG5hbWUgKHByZWNlZWRlZCBieSB0aGUKKyAqCWhleGlkZWNpbWFsKSwgYSBzeW1ib2wgbmFtZSwgYSByZWdpc3RlciBuYW1lIChwcmVjZWRlZCBieSB0aGUKICAqCXBlcmNlbnQgc2lnbiksIGFuIGVudmlyb25tZW50IHZhcmlhYmxlIHdpdGggYSBudW1lcmljIHZhbHVlCi0gKgkocHJlY2VlZGVkIGJ5IGEgZG9sbGFyIHNpZ24pIG9yIGEgc2ltcGxlIGFyaXRobWV0aWMgZXhwcmVzc2lvbgorICoJKHByZWNlZGVkIGJ5IGEgZG9sbGFyIHNpZ24pIG9yIGEgc2ltcGxlIGFyaXRobWV0aWMgZXhwcmVzc2lvbgogICoJY29uc2lzdGluZyBvZiBhIHN5bWJvbCBuYW1lLCArLy0sIGFuZCBhIG51bWVyaWMgY29uc3RhbnQgdmFsdWUKICAqCShvZmZzZXQpLgogICogUGFyYW1ldGVyczoKQEAgLTEzMzUsNyArMTMzNSw3IEBACiAgKgllcnJvcgkJVGhlIGhhcmR3YXJlLWRlZmluZWQgZXJyb3IgY29kZQogICoJcmVhc29uMgkJa2RiJ3MgY3VycmVudCByZWFzb24gY29kZS4KICAqCQkJSW5pdGlhbGx5IGVycm9yIGJ1dCBjYW4gY2hhbmdlCi0gKgkJCWFjb3JkaW5nIHRvIGtkYiBzdGF0ZS4KKyAqCQkJYWNjb3JkaW5nIHRvIGtkYiBzdGF0ZS4KICAqCWRiX3Jlc3VsdAlSZXN1bHQgY29kZSBmcm9tIGJyZWFrIG9yIGRlYnVnIHBvaW50LgogICoJcmVncwkJVGhlIGV4Y2VwdGlvbiBmcmFtZSBhdCB0aW1lIG9mIGZhdWx0L2JyZWFrcG9pbnQuCiAgKgkJCXNob3VsZCBhbHdheXMgYmUgdmFsaWQuCmRpZmYgLS1naXQgYS9rZXJuZWwvZGVidWcva2RiL2tkYl9zdXBwb3J0LmMgYi9rZXJuZWwvZGVidWcva2RiL2tkYl9zdXBwb3J0LmMKaW5kZXggNmIyNDg1ZC4uNTUzMmRkMyAxMDA2NDQKLS0tIGEva2VybmVsL2RlYnVnL2tkYi9rZGJfc3VwcG9ydC5jCisrKyBiL2tlcm5lbC9kZWJ1Zy9rZGIva2RiX3N1cHBvcnQuYwpAQCAtNTQ1LDcgKzU0NSw3IEBACiAgKglNYXNrIGZvciBwcm9jZXNzIHN0YXRlLgogICogTm90ZXM6CiAgKglUaGUgbWFzayBmb2xkcyBkYXRhIGZyb20gc2V2ZXJhbCBzb3VyY2VzIGludG8gYSBzaW5nbGUgbG9uZyB2YWx1ZSwgc28KLSAqCWJlIGNhcmVmdWxsIG5vdCB0byBvdmVybGFwIHRoZSBiaXRzLiAgVEFTS18qIGJpdHMgYXJlIGluIHRoZSBMU0IsCisgKgliZSBjYXJlZnVsIG5vdCB0byBvdmVybGFwIHRoZSBiaXRzLiAgVEFTS18qIGJpdHMgYXJlIGluIHRoZSBMU0IsCiAgKglzcGVjaWFsIGNhc2VzIGxpa2UgVU5SVU5OQUJMRSBhcmUgaW4gdGhlIE1TQi4gIEFzIG9mIDIuNi4xMC1yYzEgdGhlcmUKICAqCWlzIG5vIG92ZXJsYXAgYmV0d2VlbiBUQVNLXyogYW5kIEVYSVRfKiBidXQgdGhhdCBtYXkgbm90IGFsd2F5cyBiZQogICoJdHJ1ZSwgc28gRVhJVF8qIGJpdHMgYXJlIHNoaWZ0ZWQgbGVmdCAxNiBiaXRzIGJlZm9yZSBiZWluZyBzdG9yZWQgaW4KZGlmZiAtLWdpdCBhL2tlcm5lbC9leGl0LmMgYi9rZXJuZWwvZXhpdC5jCmluZGV4IDZhNDg4YWQuLmY1ZDJmNjMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9leGl0LmMKKysrIGIva2VybmVsL2V4aXQuYwpAQCAtODQxLDcgKzg0MSw3IEBACiAJLyogTGV0IGZhdGhlciBrbm93IHdlIGRpZWQKIAkgKgogCSAqIFRocmVhZCBzaWduYWxzIGFyZSBjb25maWd1cmFibGUsIGJ1dCB5b3UgYXJlbid0IGdvaW5nIHRvIHVzZQotCSAqIHRoYXQgdG8gc2VuZCBzaWduYWxzIHRvIGFyYml0YXJ5IHByb2Nlc3Nlcy4KKwkgKiB0aGF0IHRvIHNlbmQgc2lnbmFscyB0byBhcmJpdHJhcnkgcHJvY2Vzc2VzLgogCSAqIFRoYXQgc3RvcHMgcmlnaHQgbm93LgogCSAqCiAJICogSWYgdGhlIHBhcmVudCBleGVjIGlkIGRvZXNuJ3QgbWF0Y2ggdGhlIGV4ZWMgaWQgd2Ugc2F2ZWQKZGlmZiAtLWdpdCBhL2tlcm5lbC9pcnEvY2hpcC5jIGIva2VybmVsL2lycS9jaGlwLmMKaW5kZXggMWRhZmM4Ni4uNGFmMWUyYiAxMDA2NDQKLS0tIGEva2VybmVsL2lycS9jaGlwLmMKKysrIGIva2VybmVsL2lycS9jaGlwLmMKQEAgLTQxNSw3ICs0MTUsNyBAQAogICoJQGRlc2M6CXRoZSBpbnRlcnJ1cHQgZGVzY3JpcHRpb24gc3RydWN0dXJlIGZvciB0aGlzIGlycQogICoKICAqCUludGVycnVwdCBvY2N1cmVzIG9uIHRoZSBmYWxsaW5nIGFuZC9vciByaXNpbmcgZWRnZSBvZiBhIGhhcmR3YXJlCi0gKglzaWduYWwuIFRoZSBvY2N1cmVuY2UgaXMgbGF0Y2hlZCBpbnRvIHRoZSBpcnEgY29udHJvbGxlciBoYXJkd2FyZQorICoJc2lnbmFsLiBUaGUgb2NjdXJyZW5jZSBpcyBsYXRjaGVkIGludG8gdGhlIGlycSBjb250cm9sbGVyIGhhcmR3YXJlCiAgKglhbmQgbXVzdCBiZSBhY2tlZCBpbiBvcmRlciB0byBiZSByZWVuYWJsZWQuIEFmdGVyIHRoZSBhY2sgYW5vdGhlcgogICoJaW50ZXJydXB0IGNhbiBoYXBwZW4gb24gdGhlIHNhbWUgc291cmNlIGV2ZW4gYmVmb3JlIHRoZSBmaXJzdCBvbmUKICAqCWlzIGhhbmRsZWQgYnkgdGhlIGFzc29jaWF0ZWQgZXZlbnQgaGFuZGxlci4gSWYgdGhpcyBoYXBwZW5zIGl0CmRpZmYgLS1naXQgYS9rZXJuZWwvaXJxL21hbmFnZS5jIGIva2VybmVsL2lycS9tYW5hZ2UuYwppbmRleCAxMmE4MGZkLi4wN2MxNjExIDEwMDY0NAotLS0gYS9rZXJuZWwvaXJxL21hbmFnZS5jCisrKyBiL2tlcm5lbC9pcnEvbWFuYWdlLmMKQEAgLTEwNTEsNiArMTA1MSw3IEBACiAJcmVnaXN0ZXJfaXJxX3Byb2MoaXJxLCBkZXNjKTsKIAluZXctPmRpciA9IE5VTEw7CiAJcmVnaXN0ZXJfaGFuZGxlcl9wcm9jKGlycSwgbmV3KTsKKwlmcmVlX2NwdW1hc2tfdmFyKG1hc2spOwogCiAJcmV0dXJuIDA7CiAKZGlmZiAtLWdpdCBhL2tlcm5lbC9pcnEvbWlncmF0aW9uLmMgYi9rZXJuZWwvaXJxL21pZ3JhdGlvbi5jCmluZGV4IGJjNjE5NDYuLjQ3NDIwOTAgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9pcnEvbWlncmF0aW9uLmMKKysrIGIva2VybmVsL2lycS9taWdyYXRpb24uYwpAQCAtMzUsNyArMzUsNyBAQAogCSAqIGRvIHRoZSBkaXNhYmxlLCByZS1wcm9ncmFtLCBlbmFibGUgc2VxdWVuY2UuCiAJICogVGhpcyBpcyAqbm90KiBwYXJ0aWN1bGFybHkgaW1wb3J0YW50IGZvciBsZXZlbCB0cmlnZ2VyZWQKIAkgKiBidXQgaW4gYSBlZGdlIHRyaWdnZXIgY2FzZSwgd2UgbWlnaHQgYmUgc2V0dGluZyBydGUKLQkgKiB3aGVuIGFuIGFjdGl2ZSB0cmlnZ2VyIGlzIGNvbW1pbmcgaW4uIFRoaXMgY291bGQKKwkgKiB3aGVuIGFuIGFjdGl2ZSB0cmlnZ2VyIGlzIGNvbWluZyBpbi4gVGhpcyBjb3VsZAogCSAqIGNhdXNlIHNvbWUgaW9hcGljcyB0byBtYWwtZnVuY3Rpb24uCiAJICogQmVpbmcgcGFyYW5vaWQgaSBndWVzcyEKIAkgKgpkaWZmIC0tZ2l0IGEva2VybmVsL2tleGVjLmMgYi9rZXJuZWwva2V4ZWMuYwppbmRleCA0ZTI0MGEzLi41NTkzNmY5IDEwMDY0NAotLS0gYS9rZXJuZWwva2V4ZWMuYworKysgYi9rZXJuZWwva2V4ZWMuYwpAQCAtMTQ0LDcgKzE0NCw3IEBACiAJLyogSW5pdGlhbGl6ZSB0aGUgbGlzdCBvZiBkZXN0aW5hdGlvbiBwYWdlcyAqLwogCUlOSVRfTElTVF9IRUFEKCZpbWFnZS0+ZGVzdF9wYWdlcyk7CiAKLQkvKiBJbml0aWFsaXplIHRoZSBsaXN0IG9mIHVudXNlYWJsZSBwYWdlcyAqLworCS8qIEluaXRpYWxpemUgdGhlIGxpc3Qgb2YgdW51c2FibGUgcGFnZXMgKi8KIAlJTklUX0xJU1RfSEVBRCgmaW1hZ2UtPnVudXNlYWJsZV9wYWdlcyk7CiAKIAkvKiBSZWFkIGluIHRoZSBzZWdtZW50cyAqLwpAQCAtNDU0LDcgKzQ1NCw3IEBACiAJLyogRGVhbCB3aXRoIHRoZSBkZXN0aW5hdGlvbiBwYWdlcyBJIGhhdmUgaW5hZHZlcnRlbnRseSBhbGxvY2F0ZWQuCiAJICoKIAkgKiBJZGVhbGx5IEkgd291bGQgY29udmVydCBtdWx0aS1wYWdlIGFsbG9jYXRpb25zIGludG8gc2luZ2xlCi0JICogcGFnZSBhbGxvY2F0aW9ucywgYW5kIGFkZCBldmVyeXRpbmcgdG8gaW1hZ2UtPmRlc3RfcGFnZXMuCisJICogcGFnZSBhbGxvY2F0aW9ucywgYW5kIGFkZCBldmVyeXRoaW5nIHRvIGltYWdlLT5kZXN0X3BhZ2VzLgogCSAqCiAJICogRm9yIG5vdyBpdCBpcyBzaW1wbGVyIHRvIGp1c3QgZnJlZSB0aGUgcGFnZXMuCiAJICovCkBAIC02MDIsNyArNjAyLDcgQEAKIAkvKiBXYWxrIHRocm91Z2ggYW5kIGZyZWUgYW55IGV4dHJhIGRlc3RpbmF0aW9uIHBhZ2VzIEkgbWF5IGhhdmUgKi8KIAlraW1hZ2VfZnJlZV9wYWdlX2xpc3QoJmltYWdlLT5kZXN0X3BhZ2VzKTsKIAotCS8qIFdhbGsgdGhyb3VnaCBhbmQgZnJlZSBhbnkgdW51c2VhYmxlIHBhZ2VzIEkgaGF2ZSBjYWNoZWQgKi8KKwkvKiBXYWxrIHRocm91Z2ggYW5kIGZyZWUgYW55IHVudXNhYmxlIHBhZ2VzIEkgaGF2ZSBjYWNoZWQgKi8KIAlraW1hZ2VfZnJlZV9wYWdlX2xpc3QoJmltYWdlLT51bnVzZWFibGVfcGFnZXMpOwogCiB9CmRpZmYgLS1naXQgYS9rZXJuZWwva3RocmVhZC5jIGIva2VybmVsL2t0aHJlYWQuYwppbmRleCA2ODRhYjNmLi4zYjM0ZDI3IDEwMDY0NAotLS0gYS9rZXJuZWwva3RocmVhZC5jCisrKyBiL2tlcm5lbC9rdGhyZWFkLmMKQEAgLTEzOSw3ICsxMzksNyBAQAogICogaW4gQG5vZGUsIHRvIGdldCBOVU1BIGFmZmluaXR5IGZvciBrdGhyZWFkIHN0YWNrLCBvciBlbHNlIGdpdmUgLTEuCiAgKiBXaGVuIHdva2VuLCB0aGUgdGhyZWFkIHdpbGwgcnVuIEB0aHJlYWRmbigpIHdpdGggQGRhdGEgYXMgaXRzCiAgKiBhcmd1bWVudC4gQHRocmVhZGZuKCkgY2FuIGVpdGhlciBjYWxsIGRvX2V4aXQoKSBkaXJlY3RseSBpZiBpdCBpcyBhCi0gKiBzdGFuZGFsb25lIHRocmVhZCBmb3Igd2hpY2ggbm9vbmUgd2lsbCBjYWxsIGt0aHJlYWRfc3RvcCgpLCBvcgorICogc3RhbmRhbG9uZSB0aHJlYWQgZm9yIHdoaWNoIG5vIG9uZSB3aWxsIGNhbGwga3RocmVhZF9zdG9wKCksIG9yCiAgKiByZXR1cm4gd2hlbiAna3RocmVhZF9zaG91bGRfc3RvcCgpJyBpcyB0cnVlICh3aGljaCBtZWFucwogICoga3RocmVhZF9zdG9wKCkgaGFzIGJlZW4gY2FsbGVkKS4gIFRoZSByZXR1cm4gdmFsdWUgc2hvdWxkIGJlIHplcm8KICAqIG9yIGEgbmVnYXRpdmUgZXJyb3IgbnVtYmVyOyBpdCB3aWxsIGJlIHBhc3NlZCB0byBrdGhyZWFkX3N0b3AoKS4KZGlmZiAtLWdpdCBhL2tlcm5lbC9sYXRlbmN5dG9wLmMgYi9rZXJuZWwvbGF0ZW5jeXRvcC5jCmluZGV4IGVlNzRiMzUuLjM3NjA2NmUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9sYXRlbmN5dG9wLmMKKysrIGIva2VybmVsL2xhdGVuY3l0b3AuYwpAQCAtMTUzLDcgKzE1Myw3IEBACiB9CiAKIC8qKgotICogX19hY2NvdW50X3NjaGVkdWxlcl9sYXRlbmN5IC0gcmVjb3JkIGFuIG9jY3VyZWQgbGF0ZW5jeQorICogX19hY2NvdW50X3NjaGVkdWxlcl9sYXRlbmN5IC0gcmVjb3JkIGFuIG9jY3VycmVkIGxhdGVuY3kKICAqIEB0c2sgLSB0aGUgdGFzayBzdHJ1Y3Qgb2YgdGhlIHRhc2sgaGl0dGluZyB0aGUgbGF0ZW5jeQogICogQHVzZWNzIC0gdGhlIGR1cmF0aW9uIG9mIHRoZSBsYXRlbmN5IGluIG1pY3Jvc2Vjb25kcwogICogQGludGVyIC0gMSBpZiB0aGUgc2xlZXAgd2FzIGludGVycnVwdGlibGUsIDAgaWYgdW5pbnRlcnJ1cHRpYmxlCmRpZmYgLS1naXQgYS9rZXJuZWwvbG9ja2RlcC5jIGIva2VybmVsL2xvY2tkZXAuYwppbmRleCAwZDIwNThkLi41M2E2ODk1IDEwMDY0NAotLS0gYS9rZXJuZWwvbG9ja2RlcC5jCisrKyBiL2tlcm5lbC9sb2NrZGVwLmMKQEAgLTIzMDksNyArMjMwOSw3IEBACiAJaWYgKHVubGlrZWx5KGN1cnItPmhhcmRpcnFzX2VuYWJsZWQpKSB7CiAJCS8qCiAJCSAqIE5laXRoZXIgaXJxIG5vciBwcmVlbXB0aW9uIGFyZSBkaXNhYmxlZCBoZXJlCi0JCSAqIHNvIHRoaXMgaXMgcmFjeSBieSBuYXR1cmUgYnV0IGxvb3Npbmcgb25lIGhpdAorCQkgKiBzbyB0aGlzIGlzIHJhY3kgYnkgbmF0dXJlIGJ1dCBsb3Npbmcgb25lIGhpdAogCQkgKiBpbiBhIHN0YXQgaXMgbm90IGEgYmlnIGRlYWwuCiAJCSAqLwogCQlfX2RlYnVnX2F0b21pY19pbmMocmVkdW5kYW50X2hhcmRpcnFzX29uKTsKQEAgLTI2MjAsNyArMjYyMCw3IEBACiAJaWYgKCFncmFwaF9sb2NrKCkpCiAJCXJldHVybiAwOwogCS8qCi0JICogTWFrZSBzdXJlIHdlIGRpZG50IHJhY2U6CisJICogTWFrZSBzdXJlIHdlIGRpZG4ndCByYWNlOgogCSAqLwogCWlmICh1bmxpa2VseShobG9ja19jbGFzcyh0aGlzKS0+dXNhZ2VfbWFzayAmIG5ld19tYXNrKSkgewogCQlncmFwaF91bmxvY2soKTsKZGlmZiAtLWdpdCBhL2tlcm5lbC9tb2R1bGUuYyBiL2tlcm5lbC9tb2R1bGUuYwppbmRleCAxZjlmN2JjLi5kNTkzOGE1IDEwMDY0NAotLS0gYS9rZXJuZWwvbW9kdWxlLmMKKysrIGIva2VybmVsL21vZHVsZS5jCkBAIC04MDksNyArODA5LDcgQEAKIAkJd2FpdF9mb3JfemVyb19yZWZjb3VudChtb2QpOwogCiAJbXV0ZXhfdW5sb2NrKCZtb2R1bGVfbXV0ZXgpOwotCS8qIEZpbmFsIGRlc3RydWN0aW9uIG5vdyBub29uZSBpcyB1c2luZyBpdC4gKi8KKwkvKiBGaW5hbCBkZXN0cnVjdGlvbiBub3cgbm8gb25lIGlzIHVzaW5nIGl0LiAqLwogCWlmIChtb2QtPmV4aXQgIT0gTlVMTCkKIAkJbW9kLT5leGl0KCk7CiAJYmxvY2tpbmdfbm90aWZpZXJfY2FsbF9jaGFpbigmbW9kdWxlX25vdGlmeV9saXN0LApAQCAtMjc3Nyw3ICsyNzc3LDcgQEAKIAltb2QtPnN0YXRlID0gTU9EVUxFX1NUQVRFX0NPTUlORzsKIAogCS8qIE5vdyBzZXcgaXQgaW50byB0aGUgbGlzdHMgc28gd2UgY2FuIGdldCBsb2NrZGVwIGFuZCBvb3BzCi0JICogaW5mbyBkdXJpbmcgYXJndW1lbnQgcGFyc2luZy4gIE5vb25lIHNob3VsZCBhY2Nlc3MgdXMsIHNpbmNlCisJICogaW5mbyBkdXJpbmcgYXJndW1lbnQgcGFyc2luZy4gIE5vIG9uZSBzaG91bGQgYWNjZXNzIHVzLCBzaW5jZQogCSAqIHN0cm9uZ190cnlfbW9kdWxlX2dldCgpIHdpbGwgZmFpbC4KIAkgKiBsb2NrZGVwL29vcHMgY2FuIHJ1biBhc3luY2hyb25vdXMsIHNvIHVzZSB0aGUgUkNVIGxpc3QgaW5zZXJ0aW9uCiAJICogZnVuY3Rpb24gdG8gaW5zZXJ0IGluIGEgd2F5IHNhZmUgdG8gY29uY3VycmVudCByZWFkZXJzLgpAQCAtMjk3MSw3ICsyOTcxLDcgQEAKIAllbHNlCiAJCW5leHR2YWwgPSAodW5zaWduZWQgbG9uZyltb2QtPm1vZHVsZV9jb3JlK21vZC0+Y29yZV90ZXh0X3NpemU7CiAKLQkvKiBTY2FuIGZvciBjbG9zZXN0IHByZWNlZWRpbmcgc3ltYm9sLCBhbmQgbmV4dCBzeW1ib2wuIChFTEYKKwkvKiBTY2FuIGZvciBjbG9zZXN0IHByZWNlZGluZyBzeW1ib2wsIGFuZCBuZXh0IHN5bWJvbC4gKEVMRgogCSAgIHN0YXJ0cyByZWFsIHN5bWJvbHMgYXQgMSkuICovCiAJZm9yIChpID0gMTsgaSA8IG1vZC0+bnVtX3N5bXRhYjsgaSsrKSB7CiAJCWlmIChtb2QtPnN5bXRhYltpXS5zdF9zaG5keCA9PSBTSE5fVU5ERUYpCmRpZmYgLS1naXQgYS9rZXJuZWwvbXV0ZXguYyBiL2tlcm5lbC9tdXRleC5jCmluZGV4IGE1ODg5ZmIuLmM0MTk1ZmEgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9tdXRleC5jCisrKyBiL2tlcm5lbC9tdXRleC5jCkBAIC0yNDUsNyArMjQ1LDcgQEAKIAkJfQogCQlfX3NldF90YXNrX3N0YXRlKHRhc2ssIHN0YXRlKTsKIAotCQkvKiBkaWRudCBnZXQgdGhlIGxvY2ssIGdvIHRvIHNsZWVwOiAqLworCQkvKiBkaWRuJ3QgZ2V0IHRoZSBsb2NrLCBnbyB0byBzbGVlcDogKi8KIAkJc3Bpbl91bmxvY2tfbXV0ZXgoJmxvY2stPndhaXRfbG9jaywgZmxhZ3MpOwogCQlwcmVlbXB0X2VuYWJsZV9ub19yZXNjaGVkKCk7CiAJCXNjaGVkdWxlKCk7CmRpZmYgLS1naXQgYS9rZXJuZWwvcGFkYXRhLmMgYi9rZXJuZWwvcGFkYXRhLmMKaW5kZXggNzUxMDE5NC4uYjkxOTQxZCAxMDA2NDQKLS0tIGEva2VybmVsL3BhZGF0YS5jCisrKyBiL2tlcm5lbC9wYWRhdGEuYwpAQCAtMjYyLDcgKzI2Miw3IEBACiAJCS8qCiAJCSAqIFRoaXMgY3B1IGhhcyB0byBkbyB0aGUgcGFyYWxsZWwgcHJvY2Vzc2luZyBvZiB0aGUgbmV4dAogCQkgKiBvYmplY3QuIEl0J3Mgd2FpdGluZyBpbiB0aGUgY3B1J3MgcGFyYWxsZWxpemF0aW9uIHF1ZXVlLAotCQkgKiBzbyBleGl0IGltZWRpYXRlbHkuCisJCSAqIHNvIGV4aXQgaW1tZWRpYXRlbHkuCiAJCSAqLwogCQlpZiAoUFRSX0VSUihwYWRhdGEpID09IC1FTk9EQVRBKSB7CiAJCQlkZWxfdGltZXIoJnBkLT50aW1lcik7CkBAIC0yODQsNyArMjg0LDcgQEAKIAkvKgogCSAqIFRoZSBuZXh0IG9iamVjdCB0aGF0IG5lZWRzIHNlcmlhbGl6YXRpb24gbWlnaHQgaGF2ZSBhcnJpdmVkIHRvCiAJICogdGhlIHJlb3JkZXIgcXVldWVzIGluIHRoZSBtZWFudGltZSwgd2Ugd2lsbCBiZSBjYWxsZWQgYWdhaW4KLQkgKiBmcm9tIHRoZSB0aW1lciBmdW5jdGlvbiBpZiBub29uZSBlbHNlIGNhcmVzIGZvciBpdC4KKwkgKiBmcm9tIHRoZSB0aW1lciBmdW5jdGlvbiBpZiBubyBvbmUgZWxzZSBjYXJlcyBmb3IgaXQuCiAJICovCiAJaWYgKGF0b21pY19yZWFkKCZwZC0+cmVvcmRlcl9vYmplY3RzKQogCQkJJiYgIShwaW5zdC0+ZmxhZ3MgJiBQQURBVEFfUkVTRVQpKQpAQCAtNTE1LDcgKzUxNSw3IEBACiAJcHV0X29ubGluZV9jcHVzKCk7CiB9CiAKLS8qIFJlcGxhY2UgdGhlIGludGVybmFsIGNvbnRyb2wgc3R1Y3R1cmUgd2l0aCBhIG5ldyBvbmUuICovCisvKiBSZXBsYWNlIHRoZSBpbnRlcm5hbCBjb250cm9sIHN0cnVjdHVyZSB3aXRoIGEgbmV3IG9uZS4gKi8KIHN0YXRpYyB2b2lkIHBhZGF0YV9yZXBsYWNlKHN0cnVjdCBwYWRhdGFfaW5zdGFuY2UgKnBpbnN0LAogCQkJICAgc3RydWN0IHBhcmFsbGVsX2RhdGEgKnBkX25ldykKIHsKQEAgLTc2OCw3ICs3NjgsNyBAQAogfQogCiAgLyoqCi0gKiBwYWRhdGFfcmVtb3ZlX2NwdSAtIHJlbW92ZSBhIGNwdSBmcm9tIHRoZSBvbmUgb3IgYm90aChzZXJpYWwgYW5kIHBhcmFsZWxsKQorICogcGFkYXRhX3JlbW92ZV9jcHUgLSByZW1vdmUgYSBjcHUgZnJvbSB0aGUgb25lIG9yIGJvdGgoc2VyaWFsIGFuZCBwYXJhbGxlbCkKICAqICAgICAgICAgICAgICAgICAgICAgcGFkYXRhIGNwdW1hc2tzLgogICoKICAqIEBwaW5zdDogcGFkYXRhIGluc3RhbmNlCmRpZmYgLS1naXQgYS9rZXJuZWwvcGFyYW1zLmMgYi9rZXJuZWwvcGFyYW1zLmMKaW5kZXggMGRhMTQxMS4uN2FiMzg4YSAxMDA2NDQKLS0tIGEva2VybmVsL3BhcmFtcy5jCisrKyBiL2tlcm5lbC9wYXJhbXMuYwpAQCAtOTUsNyArOTUsNyBAQAogCS8qIEZpbmQgcGFyYW1ldGVyICovCiAJZm9yIChpID0gMDsgaSA8IG51bV9wYXJhbXM7IGkrKykgewogCQlpZiAocGFyYW1lcShwYXJhbSwgcGFyYW1zW2ldLm5hbWUpKSB7Ci0JCQkvKiBOb29uZSBoYW5kbGVkIE5VTEwsIHNvIGRvIGl0IGhlcmUuICovCisJCQkvKiBObyBvbmUgaGFuZGxlZCBOVUxMLCBzbyBkbyBpdCBoZXJlLiAqLwogCQkJaWYgKCF2YWwgJiYgcGFyYW1zW2ldLm9wcy0+c2V0ICE9IHBhcmFtX3NldF9ib29sKQogCQkJCXJldHVybiAtRUlOVkFMOwogCQkJREVCVUdQKCJUaGV5IGFyZSBlcXVhbCEgIENhbGxpbmcgJXBcbiIsCmRpZmYgLS1naXQgYS9rZXJuZWwvcG9zaXgtY3B1LXRpbWVycy5jIGIva2VybmVsL3Bvc2l4LWNwdS10aW1lcnMuYwppbmRleCA2N2ZlYTlkLi4wNzkxYjEzIDEwMDY0NAotLS0gYS9rZXJuZWwvcG9zaXgtY3B1LXRpbWVycy5jCisrKyBiL2tlcm5lbC9wb3NpeC1jcHUtdGltZXJzLmMKQEAgLTEzNDcsNyArMTM0Nyw3IEBACiAKIAkvKgogCSAqIE5vdyB0aGF0IGFsbCB0aGUgdGltZXJzIG9uIG91ciBsaXN0IGhhdmUgdGhlIGZpcmluZyBmbGFnLAotCSAqIG5vb25lIHdpbGwgdG91Y2ggdGhlaXIgbGlzdCBlbnRyaWVzIGJ1dCB1cy4gIFdlJ2xsIHRha2UKKwkgKiBubyBvbmUgd2lsbCB0b3VjaCB0aGVpciBsaXN0IGVudHJpZXMgYnV0IHVzLiAgV2UnbGwgdGFrZQogCSAqIGVhY2ggdGltZXIncyBsb2NrIGJlZm9yZSBjbGVhcmluZyBpdHMgZmlyaW5nIGZsYWcsIHNvIG5vCiAJICogdGltZXIgY2FsbCB3aWxsIGludGVyZmVyZS4KIAkgKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3NpeC10aW1lcnMuYyBiL2tlcm5lbC9wb3NpeC10aW1lcnMuYwppbmRleCA0YzAxMjQ5Li5lNTQ5OGQ3IDEwMDY0NAotLS0gYS9rZXJuZWwvcG9zaXgtdGltZXJzLmMKKysrIGIva2VybmVsL3Bvc2l4LXRpbWVycy5jCkBAIC0zMTMsNyArMzEzLDcgQEAKICAqIHJlc3RhcnRlZCAoaS5lLiB3ZSBoYXZlIGZsYWdnZWQgdGhpcyBpbiB0aGUgc3lzX3ByaXZhdGUgZW50cnkgb2YgdGhlCiAgKiBpbmZvIGJsb2NrKS4KICAqCi0gKiBUbyBwcm90ZWN0IGFnaW5zdCB0aGUgdGltZXIgZ29pbmcgYXdheSB3aGlsZSB0aGUgaW50ZXJydXB0IGlzIHF1ZXVlZCwKKyAqIFRvIHByb3RlY3QgYWdhaW5zdCB0aGUgdGltZXIgZ29pbmcgYXdheSB3aGlsZSB0aGUgaW50ZXJydXB0IGlzIHF1ZXVlZCwKICAqIHdlIHJlcXVpcmUgdGhhdCB0aGUgaXRfcmVxdWV1ZV9wZW5kaW5nIGZsYWcgYmUgc2V0LgogICovCiB2b2lkIGRvX3NjaGVkdWxlX25leHRfdGltZXIoc3RydWN0IHNpZ2luZm8gKmluZm8pCmRpZmYgLS1naXQgYS9rZXJuZWwvcG93ZXIvbWFpbi5jIGIva2VybmVsL3Bvd2VyL21haW4uYwppbmRleCA4ZWFiYTVmLi5kZTlhZWY4IDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvbWFpbi5jCisrKyBiL2tlcm5lbC9wb3dlci9tYWluLmMKQEAgLTIyNCw3ICsyMjQsNyBAQAogICogd3JpdGluZyB0byAnc3RhdGUnLiAgSXQgZmlyc3Qgc2hvdWxkIHJlYWQgZnJvbSAnd2FrZXVwX2NvdW50JyBhbmQgc3RvcmUKICAqIHRoZSByZWFkIHZhbHVlLiAgVGhlbiwgYWZ0ZXIgY2Fycnlpbmcgb3V0IGl0cyBvd24gcHJlcGFyYXRpb25zIGZvciB0aGUgc3lzdGVtCiAgKiB0cmFuc2l0aW9uIHRvIGEgc2xlZXAgc3RhdGUsIGl0IHNob3VsZCB3cml0ZSB0aGUgc3RvcmVkIHZhbHVlIHRvCi0gKiAnd2FrZXVwX2NvdW50Jy4gIElmIHRoYXQgZmFpbHMsIGF0IGxlYXN0IG9uZSB3YWtldXAgZXZlbnQgaGFzIG9jY3VyZWQgc2luY2UKKyAqICd3YWtldXBfY291bnQnLiAgSWYgdGhhdCBmYWlscywgYXQgbGVhc3Qgb25lIHdha2V1cCBldmVudCBoYXMgb2NjdXJyZWQgc2luY2UKICAqICd3YWtldXBfY291bnQnIHdhcyByZWFkIGFuZCAnc3RhdGUnIHNob3VsZCBub3QgYmUgd3JpdHRlbiB0by4gIE90aGVyd2lzZSwgaXQKICAqIGlzIGFsbG93ZWQgdG8gd3JpdGUgdG8gJ3N0YXRlJywgYnV0IHRoZSB0cmFuc2l0aW9uIHdpbGwgYmUgYWJvcnRlZCBpZiB0aGVyZQogICogYXJlIGFueSB3YWtldXAgZXZlbnRzIGRldGVjdGVkIGFmdGVyICd3YWtldXBfY291bnQnIHdhcyB3cml0dGVuIHRvLgpkaWZmIC0tZ2l0IGEva2VybmVsL3NjaGVkLmMgYi9rZXJuZWwvc2NoZWQuYwppbmRleCBhODg0NTUxLi40ODAxMzYzIDEwMDY0NAotLS0gYS9rZXJuZWwvc2NoZWQuYworKysgYi9rZXJuZWwvc2NoZWQuYwpAQCAtMjMwOSw3ICsyMzA5LDcgQEAKICAqIENhdXNlIGEgcHJvY2VzcyB3aGljaCBpcyBydW5uaW5nIG9uIGFub3RoZXIgQ1BVIHRvIGVudGVyCiAgKiBrZXJuZWwtbW9kZSwgd2l0aG91dCBhbnkgZGVsYXkuICh0byBnZXQgc2lnbmFscyBoYW5kbGVkLikKICAqCi0gKiBOT1RFOiB0aGlzIGZ1bmN0aW9uIGRvZXNudCBoYXZlIHRvIHRha2UgdGhlIHJ1bnF1ZXVlIGxvY2ssCisgKiBOT1RFOiB0aGlzIGZ1bmN0aW9uIGRvZXNuJ3QgaGF2ZSB0byB0YWtlIHRoZSBydW5xdWV1ZSBsb2NrLAogICogYmVjYXVzZSBhbGwgaXQgd2FudHMgdG8gZW5zdXJlIGlzIHRoYXQgdGhlIHJlbW90ZSB0YXNrIGVudGVycwogICogdGhlIGtlcm5lbC4gSWYgdGhlIElQSSByYWNlcyBhbmQgdGhlIHRhc2sgaGFzIGJlZW4gbWlncmF0ZWQKICAqIHRvIGFub3RoZXIgQ1BVIHRoZW4gbm8gaGFybSBpcyBkb25lIGFuZCB0aGUgcHVycG9zZSBoYXMgYmVlbgpAQCAtNDk5Nyw3ICs0OTk3LDcgQEAKIAkgKi8KIAlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJnAtPnBpX2xvY2ssIGZsYWdzKTsKIAkvKgotCSAqIFRvIGJlIGFibGUgdG8gY2hhbmdlIHAtPnBvbGljeSBzYWZlbHksIHRoZSBhcHJvcHJpYXRlCisJICogVG8gYmUgYWJsZSB0byBjaGFuZ2UgcC0+cG9saWN5IHNhZmVseSwgdGhlIGFwcHJvcHJpYXRlCiAJICogcnVucXVldWUgbG9jayBtdXN0IGJlIGhlbGQuCiAJICovCiAJcnEgPSBfX3Rhc2tfcnFfbG9jayhwKTsKQEAgLTU3MTYsNyArNTcxNiw3IEBACiAJZG9fZWFjaF90aHJlYWQoZywgcCkgewogCQkvKgogCQkgKiByZXNldCB0aGUgTk1JLXRpbWVvdXQsIGxpc3RpbmcgYWxsIGZpbGVzIG9uIGEgc2xvdwotCQkgKiBjb25zb2xlIG1pZ2h0IHRha2UgYWxvdCBvZiB0aW1lOgorCQkgKiBjb25zb2xlIG1pZ2h0IHRha2UgYSBsb3Qgb2YgdGltZToKIAkJICovCiAJCXRvdWNoX25taV93YXRjaGRvZygpOwogCQlpZiAoIXN0YXRlX2ZpbHRlciB8fCAocC0+c3RhdGUgJiBzdGF0ZV9maWx0ZXIpKQpAQCAtNjMzMSw2ICs2MzMxLDkgQEAKIAkJYnJlYWs7CiAjZW5kaWYKIAl9CisKKwl1cGRhdGVfbWF4X2ludGVydmFsKCk7CisKIAlyZXR1cm4gTk9USUZZX09LOwogfQogCmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWRfYXV0b2dyb3VwLmMgYi9rZXJuZWwvc2NoZWRfYXV0b2dyb3VwLmMKaW5kZXggNTk0NmFjNS4uNDI5MjQyZiAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkX2F1dG9ncm91cC5jCisrKyBiL2tlcm5lbC9zY2hlZF9hdXRvZ3JvdXAuYwpAQCAtMTc5LDcgKzE3OSw3IEBACiAJc3RydWN0IGF1dG9ncm91cCAqYWcgPSBhdXRvZ3JvdXBfY3JlYXRlKCk7CiAKIAlhdXRvZ3JvdXBfbW92ZV9ncm91cChwLCBhZyk7Ci0JLyogZHJvcCBleHRyYSByZWZyZW5jZSBhZGRlZCBieSBhdXRvZ3JvdXBfY3JlYXRlKCkgKi8KKwkvKiBkcm9wIGV4dHJhIHJlZmVyZW5jZSBhZGRlZCBieSBhdXRvZ3JvdXBfY3JlYXRlKCkgKi8KIAlhdXRvZ3JvdXBfa3JlZl9wdXQoYWcpOwogfQogRVhQT1JUX1NZTUJPTChzY2hlZF9hdXRvZ3JvdXBfY3JlYXRlX2F0dGFjaCk7CmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWRfZmFpci5jIGIva2VybmVsL3NjaGVkX2ZhaXIuYwppbmRleCBjN2VjNWM4Li43ZjAwNzcyIDEwMDY0NAotLS0gYS9rZXJuZWwvc2NoZWRfZmFpci5jCisrKyBiL2tlcm5lbC9zY2hlZF9mYWlyLmMKQEAgLTMwNjIsNyArMzA2Miw3IEBACiAKIAkvKgogCSAqIGlmICppbWJhbGFuY2UgaXMgbGVzcyB0aGFuIHRoZSBhdmVyYWdlIGxvYWQgcGVyIHJ1bm5hYmxlIHRhc2sKLQkgKiB0aGVyZSBpcyBubyBnYXVyYW50ZWUgdGhhdCBhbnkgdGFza3Mgd2lsbCBiZSBtb3ZlZCBzbyB3ZSdsbCBoYXZlCisJICogdGhlcmUgaXMgbm8gZ3VhcmFudGVlIHRoYXQgYW55IHRhc2tzIHdpbGwgYmUgbW92ZWQgc28gd2UnbGwgaGF2ZQogCSAqIGEgdGhpbmsgYWJvdXQgYnVtcGluZyBpdHMgdmFsdWUgdG8gZm9yY2UgYXQgbGVhc3Qgb25lIHRhc2sgdG8gYmUKIAkgKiBtb3ZlZAogCSAqLwpAQCAtMzgyMCw2ICszODIwLDE3IEBACiAKIHN0YXRpYyBERUZJTkVfU1BJTkxPQ0soYmFsYW5jaW5nKTsKIAorc3RhdGljIHVuc2lnbmVkIGxvbmcgX19yZWFkX21vc3RseSBtYXhfbG9hZF9iYWxhbmNlX2ludGVydmFsID0gSFovMTA7CisKKy8qCisgKiBTY2FsZSB0aGUgbWF4IGxvYWRfYmFsYW5jZSBpbnRlcnZhbCB3aXRoIHRoZSBudW1iZXIgb2YgQ1BVcyBpbiB0aGUgc3lzdGVtLgorICogVGhpcyB0cmFkZXMgbG9hZC1iYWxhbmNlIGxhdGVuY3kgb24gbGFyZ2VyIG1hY2hpbmVzIGZvciBsZXNzIGNyb3NzIHRhbGsuCisgKi8KK3N0YXRpYyB2b2lkIHVwZGF0ZV9tYXhfaW50ZXJ2YWwodm9pZCkKK3sKKwltYXhfbG9hZF9iYWxhbmNlX2ludGVydmFsID0gSFoqbnVtX29ubGluZV9jcHVzKCkvMTA7Cit9CisKIC8qCiAgKiBJdCBjaGVja3MgZWFjaCBzY2hlZHVsaW5nIGRvbWFpbiB0byBzZWUgaWYgaXQgaXMgZHVlIHRvIGJlIGJhbGFuY2VkLAogICogYW5kIGluaXRpYXRlcyBhIGJhbGFuY2luZyBvcGVyYXRpb24gaWYgc28uCkBAIC0zODQ5LDEwICszODYwLDcgQEAKIAogCQkvKiBzY2FsZSBtcyB0byBqaWZmaWVzICovCiAJCWludGVydmFsID0gbXNlY3NfdG9famlmZmllcyhpbnRlcnZhbCk7Ci0JCWlmICh1bmxpa2VseSghaW50ZXJ2YWwpKQotCQkJaW50ZXJ2YWwgPSAxOwotCQlpZiAoaW50ZXJ2YWwgPiBIWipudW1fb25saW5lX2NwdXMoKS8xMCkKLQkJCWludGVydmFsID0gSFoqbnVtX29ubGluZV9jcHVzKCkvMTA7CisJCWludGVydmFsID0gY2xhbXAoaW50ZXJ2YWwsIDFVTCwgbWF4X2xvYWRfYmFsYW5jZV9pbnRlcnZhbCk7CiAKIAkJbmVlZF9zZXJpYWxpemUgPSBzZC0+ZmxhZ3MgJiBTRF9TRVJJQUxJWkU7CiAKZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZF9ydC5jIGIva2VybmVsL3NjaGVkX3J0LmMKaW5kZXggZGIzMDhjYi4uZTdjZWJkYyAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkX3J0LmMKKysrIGIva2VybmVsL3NjaGVkX3J0LmMKQEAgLTEzNzgsNyArMTM3OCw3IEBACiAJCXRhc2sgPSBwaWNrX25leHRfcHVzaGFibGVfdGFzayhycSk7CiAJCWlmICh0YXNrX2NwdShuZXh0X3Rhc2spID09IHJxLT5jcHUgJiYgdGFzayA9PSBuZXh0X3Rhc2spIHsKIAkJCS8qCi0JCQkgKiBJZiB3ZSBnZXQgaGVyZSwgdGhlIHRhc2sgaGFzbnQgbW92ZWQgYXQgYWxsLCBidXQKKwkJCSAqIElmIHdlIGdldCBoZXJlLCB0aGUgdGFzayBoYXNuJ3QgbW92ZWQgYXQgYWxsLCBidXQKIAkJCSAqIGl0IGhhcyBmYWlsZWQgdG8gcHVzaC4gIFdlIHdpbGwgbm90IHRyeSBhZ2FpbiwKIAkJCSAqIHNpbmNlIHRoZSBvdGhlciBjcHVzIHdpbGwgcHVsbCBmcm9tIHVzIHdoZW4gdGhleQogCQkJICogYXJlIHJlYWR5LgpAQCAtMTQ4OCw3ICsxNDg4LDcgQEAKIAkJCS8qCiAJCQkgKiBXZSBjb250aW51ZSB3aXRoIHRoZSBzZWFyY2gsIGp1c3QgaW4KIAkJCSAqIGNhc2UgdGhlcmUncyBhbiBldmVuIGhpZ2hlciBwcmlvIHRhc2sKLQkJCSAqIGluIGFub3RoZXIgcnVucXVldWUuIChsb3cgbGlrZWx5aG9vZAorCQkJICogaW4gYW5vdGhlciBydW5xdWV1ZS4gKGxvdyBsaWtlbGlob29kCiAJCQkgKiBidXQgcG9zc2libGUpCiAJCQkgKi8KIAkJfQpkaWZmIC0tZ2l0IGEva2VybmVsL3NpZ25hbC5jIGIva2VybmVsL3NpZ25hbC5jCmluZGV4IGRjMTc5MjkuLjcxNjVhZjUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zaWduYWwuYworKysgYi9rZXJuZWwvc2lnbmFsLmMKQEAgLTE4ODcsNyArMTg4Nyw3IEBACiAJZm9yICg7OykgewogCQlzdHJ1Y3Qga19zaWdhY3Rpb24gKmthOwogCQkvKgotCQkgKiBUcmFjaW5nIGNhbiBpbmR1Y2UgYW4gYXJ0aWZpY2FsIHNpZ25hbCBhbmQgY2hvb3NlIHNpZ2FjdGlvbi4KKwkJICogVHJhY2luZyBjYW4gaW5kdWNlIGFuIGFydGlmaWNpYWwgc2lnbmFsIGFuZCBjaG9vc2Ugc2lnYWN0aW9uLgogCQkgKiBUaGUgcmV0dXJuIHZhbHVlIGluIEBzaWduciBkZXRlcm1pbmVzIHRoZSBkZWZhdWx0IGFjdGlvbiwKIAkJICogYnV0IEBpbmZvLT5zaV9zaWdubyBpcyB0aGUgc2lnbmFsIG51bWJlciB3ZSB3aWxsIHJlcG9ydC4KIAkJICovCkBAIC0yNzExLDggKzI3MTEsOCBAQAogLyoqCiAgKiAgc3lzX3J0X3NpZ2FjdGlvbiAtIGFsdGVyIGFuIGFjdGlvbiB0YWtlbiBieSBhIHByb2Nlc3MKICAqICBAc2lnOiBzaWduYWwgdG8gYmUgc2VudAotICogIEBhY3Q6IHRoZSB0aHJlYWQgZ3JvdXAgSUQgb2YgdGhlIHRocmVhZAotICogIEBvYWN0OiB0aGUgUElEIG9mIHRoZSB0aHJlYWQKKyAqICBAYWN0OiBuZXcgc2lnYWN0aW9uCisgKiAgQG9hY3Q6IHVzZWQgdG8gc2F2ZSB0aGUgcHJldmlvdXMgc2lnYWN0aW9uCiAgKiAgQHNpZ3NldHNpemU6IHNpemUgb2Ygc2lnc2V0X3QgdHlwZQogICovCiBTWVNDQUxMX0RFRklORTQocnRfc2lnYWN0aW9uLCBpbnQsIHNpZywKZGlmZiAtLWdpdCBhL2tlcm5lbC9zb2Z0aXJxLmMgYi9rZXJuZWwvc29mdGlycS5jCmluZGV4IDczNWQ4NzAuLjE3NGY5NzYgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zb2Z0aXJxLmMKKysrIGIva2VybmVsL3NvZnRpcnEuYwpAQCAtNTY3LDcgKzU2Nyw3IEBACiAvKioKICAqIHRhc2tsZXRfaHJ0aW1lcl9pbml0IC0gSW5pdCBhIHRhc2tsZXQvaHJ0aW1lciBjb21ibyBmb3Igc29mdGlycSBjYWxsYmFja3MKICAqIEB0dGltZXI6CSB0YXNrbGV0X2hydGltZXIgd2hpY2ggaXMgaW5pdGlhbGl6ZWQKLSAqIEBmdW5jdGlvbjoJIGhydGltZXIgY2FsbGJhY2sgZnVudGlvbiB3aGljaCBnZXRzIGNhbGxlZCBmcm9tIHNvZnRpcnEgY29udGV4dAorICogQGZ1bmN0aW9uOgkgaHJ0aW1lciBjYWxsYmFjayBmdW5jdGlvbiB3aGljaCBnZXRzIGNhbGxlZCBmcm9tIHNvZnRpcnEgY29udGV4dAogICogQHdoaWNoX2Nsb2NrOiBjbG9jayBpZCAoQ0xPQ0tfTU9OT1RPTklDL0NMT0NLX1JFQUxUSU1FKQogICogQG1vZGU6CSBocnRpbWVyIG1vZGUgKEhSVElNRVJfTU9ERV9BQlMvSFJUSU1FUl9NT0RFX1JFTCkKICAqLwpkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWUvamlmZmllcy5jIGIva2VybmVsL3RpbWUvamlmZmllcy5jCmluZGV4IGIyZmE1MDYuLmE0NzAxNTQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL2ppZmZpZXMuYworKysgYi9rZXJuZWwvdGltZS9qaWZmaWVzLmMKQEAgLTM0LDcgKzM0LDcgQEAKICAqIGluYWNjdXJhY2llcyBjYXVzZWQgYnkgbWlzc2VkIG9yIGxvc3QgdGltZXIKICAqIGludGVycnVwdHMgYW5kIHRoZSBpbmFiaWxpdHkgZm9yIHRoZSB0aW1lcgogICogaW50ZXJydXB0IGhhcmR3YXJlIHRvIGFjY3VyYXRseSB0aWNrIGF0IHRoZQotICogcmVxdWVzdGVkIEhaIHZhbHVlLiBJdCBpcyBhbHNvIG5vdCByZWNjb21lbmRlZAorICogcmVxdWVzdGVkIEhaIHZhbHVlLiBJdCBpcyBhbHNvIG5vdCByZWNvbW1lbmRlZAogICogZm9yICJ0aWNrLWxlc3MiIHN5c3RlbXMuCiAgKi8KICNkZWZpbmUgTlNFQ19QRVJfSklGRlkJKCh1MzIpKCgoKHU2NClOU0VDX1BFUl9TRUMpPDw4KS9BQ1RIWikpCmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZS90aW1lcl9zdGF0cy5jIGIva2VybmVsL3RpbWUvdGltZXJfc3RhdHMuYwppbmRleCAyZjNiNTg1Li5hNWQwYTNhIDEwMDY0NAotLS0gYS9rZXJuZWwvdGltZS90aW1lcl9zdGF0cy5jCisrKyBiL2tlcm5lbC90aW1lL3RpbWVyX3N0YXRzLmMKQEAgLTIzNiw3ICsyMzYsNyBAQAogCQkJICAgICAgdW5zaWduZWQgaW50IHRpbWVyX2ZsYWcpCiB7CiAJLyoKLQkgKiBJdCBkb2VzbnQgbWF0dGVyIHdoaWNoIGxvY2sgd2UgdGFrZToKKwkgKiBJdCBkb2Vzbid0IG1hdHRlciB3aGljaCBsb2NrIHdlIHRha2U6CiAJICovCiAJcmF3X3NwaW5sb2NrX3QgKmxvY2s7CiAJc3RydWN0IGVudHJ5ICplbnRyeSwgaW5wdXQ7CmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvZnRyYWNlLmMgYi9rZXJuZWwvdHJhY2UvZnRyYWNlLmMKaW5kZXggYzA3NWY0ZS4uZWUyNGZhMSAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL2Z0cmFjZS5jCisrKyBiL2tlcm5lbC90cmFjZS9mdHJhY2UuYwpAQCAtMTI2OCw3ICsxMjY4LDcgQEAKIAkJcC0+ZmxhZ3MgPSAwTDsKIAogCQkvKgotCQkgKiBEbyB0aGUgaW5pdGlhbCByZWNvcmQgY29udmVydGlvbiBmcm9tIG1jb3VudCBqdW1wCisJCSAqIERvIHRoZSBpbml0aWFsIHJlY29yZCBjb252ZXJzaW9uIGZyb20gbWNvdW50IGp1bXAKIAkJICogdG8gdGhlIE5PUCBpbnN0cnVjdGlvbnMuCiAJCSAqLwogCQlpZiAoIWZ0cmFjZV9jb2RlX2Rpc2FibGUobW9kLCBwKSkgewpAQCAtMzQyNSw3ICszNDI1LDcgQEAKIAlhdG9taWNfc2V0KCZ0LT50cmFjaW5nX2dyYXBoX3BhdXNlLCAwKTsKIAlhdG9taWNfc2V0KCZ0LT50cmFjZV9vdmVycnVuLCAwKTsKIAl0LT5mdHJhY2VfdGltZXN0YW1wID0gMDsKLQkvKiBtYWtlIGN1cnJfcmV0X3N0YWNrIHZpc2FibGUgYmVmb3JlIHdlIGFkZCB0aGUgcmV0X3N0YWNrICovCisJLyogbWFrZSBjdXJyX3JldF9zdGFjayB2aXNpYmxlIGJlZm9yZSB3ZSBhZGQgdGhlIHJldF9zdGFjayAqLwogCXNtcF93bWIoKTsKIAl0LT5yZXRfc3RhY2sgPSByZXRfc3RhY2s7CiB9CmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvcmluZ19idWZmZXIuYyBiL2tlcm5lbC90cmFjZS9yaW5nX2J1ZmZlci5jCmluZGV4IGQ5YzhiY2EuLjBlZjdiNGIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90cmFjZS9yaW5nX2J1ZmZlci5jCisrKyBiL2tlcm5lbC90cmFjZS9yaW5nX2J1ZmZlci5jCkBAIC0xNDc4LDcgKzE0NzgsNyBAQAogCXJldHVybiBsb2NhbF9yZWFkKCZicGFnZS0+ZW50cmllcykgJiBSQl9XUklURV9NQVNLOwogfQogCi0vKiBTaXplIGlzIGRldGVybWluZWQgYnkgd2hhdCBoYXMgYmVlbiBjb21taXRlZCAqLworLyogU2l6ZSBpcyBkZXRlcm1pbmVkIGJ5IHdoYXQgaGFzIGJlZW4gY29tbWl0dGVkICovCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIHJiX3BhZ2Vfc2l6ZShzdHJ1Y3QgYnVmZmVyX3BhZ2UgKmJwYWdlKQogewogCXJldHVybiByYl9wYWdlX2NvbW1pdChicGFnZSk7CkBAIC0yOTMyLDcgKzI5MzIsNyBAQAogCS8qCiAJICogY3B1X2J1ZmZlci0+cGFnZXMganVzdCBuZWVkcyB0byBwb2ludCB0byB0aGUgYnVmZmVyLCBpdAogCSAqICBoYXMgbm8gc3BlY2lmaWMgYnVmZmVyIHBhZ2UgdG8gcG9pbnQgdG8uIExldHMgbW92ZSBpdCBvdXQKLQkgKiAgb2Ygb3VyIHdheSBzbyB3ZSBkb24ndCBhY2NpZGVudGx5IHN3YXAgaXQuCisJICogIG9mIG91ciB3YXkgc28gd2UgZG9uJ3QgYWNjaWRlbnRhbGx5IHN3YXAgaXQuCiAJICovCiAJY3B1X2J1ZmZlci0+cGFnZXMgPSByZWFkZXItPmxpc3QucHJldjsKIApkaWZmIC0tZ2l0IGEva2VybmVsL3RyYWNlL3RyYWNlLmMgYi9rZXJuZWwvdHJhY2UvdHJhY2UuYwppbmRleCA5NTQxYzI3Li5kMzhjMTZhIDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2UuYworKysgYi9rZXJuZWwvdHJhY2UvdHJhY2UuYwpAQCAtMzIzOSw3ICszMjM5LDcgQEAKIAkJdHJhY2Vfc2VxX2luaXQoJml0ZXItPnNlcSk7CiAKIAkvKgotCSAqIElmIHRoZXJlIHdhcyBub3RoaW5nIHRvIHNlbmQgdG8gdXNlciwgaW5zcGl0ZSBvZiBjb25zdW1pbmcgdHJhY2UKKwkgKiBJZiB0aGVyZSB3YXMgbm90aGluZyB0byBzZW5kIHRvIHVzZXIsIGluIHNwaXRlIG9mIGNvbnN1bWluZyB0cmFjZQogCSAqIGVudHJpZXMsIGdvIGJhY2sgdG8gd2FpdCBmb3IgbW9yZSBlbnRyaWVzLgogCSAqLwogCWlmIChzcmV0ID09IC1FQlVTWSkKZGlmZiAtLWdpdCBhL2tlcm5lbC90cmFjZS90cmFjZV9jbG9jay5jIGIva2VybmVsL3RyYWNlL3RyYWNlX2Nsb2NrLmMKaW5kZXggNjg1YTY3ZC4uNjMwMjc0NyAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL3RyYWNlX2Nsb2NrLmMKKysrIGIva2VybmVsL3RyYWNlL3RyYWNlX2Nsb2NrLmMKQEAgLTQ2LDcgKzQ2LDcgQEAKIH0KIAogLyoKLSAqIHRyYWNlX2Nsb2NrKCk6ICdpbmJldHdlZW4nIHRyYWNlIGNsb2NrLiBOb3QgY29tcGxldGVseSBzZXJpYWxpemVkLAorICogdHJhY2VfY2xvY2soKTogJ2JldHdlZW4nIHRyYWNlIGNsb2NrLiBOb3QgY29tcGxldGVseSBzZXJpYWxpemVkLAogICogYnV0IG5vdCBjb21wbGV0ZWx5IGluY29ycmVjdCB3aGVuIGNyb3NzaW5nIENQVXMgZWl0aGVyLgogICoKICAqIFRoaXMgaXMgYmFzZWQgb24gY3B1X2Nsb2NrKCksIHdoaWNoIHdpbGwgYWxsb3cgYXQgbW9zdCB+MSBqaWZmeSBvZgpkaWZmIC0tZ2l0IGEva2VybmVsL3RyYWNlL3RyYWNlX2VudHJpZXMuaCBiL2tlcm5lbC90cmFjZS90cmFjZV9lbnRyaWVzLmgKaW5kZXggMTUxNmNiMy4uZTMyNzQ0YyAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL3RyYWNlX2VudHJpZXMuaAorKysgYi9rZXJuZWwvdHJhY2UvdHJhY2VfZW50cmllcy5oCkBAIC0yNyw3ICsyNyw3IEBACiAgKgkgIGluIHRoZSBzdHJ1Y3R1cmUuCiAgKgogICogICAqIGZvciBzdHJ1Y3R1cmVzIHdpdGhpbiBzdHJ1Y3R1cmVzLCB0aGUgZm9ybWF0IG9mIHRoZSBpbnRlcm5hbAotICoJc3RydWN0dXJlIGlzIGxheWVkIG91dC4gVGhpcyBhbGxvd3MgdGhlIGludGVybmFsIHN0cnVjdHVyZQorICoJc3RydWN0dXJlIGlzIGxhaWQgb3V0LiBUaGlzIGFsbG93cyB0aGUgaW50ZXJuYWwgc3RydWN0dXJlCiAgKgl0byBiZSBkZWNpcGhlcmVkIGZvciB0aGUgZm9ybWF0IGZpbGUuIEFsdGhvdWdoIHRoZXNlIG1hY3JvcwogICoJbWF5IGJlY29tZSBvdXQgb2Ygc3luYyB3aXRoIHRoZSBpbnRlcm5hbCBzdHJ1Y3R1cmUsIHRoZXkKICAqCXdpbGwgY3JlYXRlIGEgY29tcGlsZSBlcnJvciBpZiBpdCBoYXBwZW5zLiBTaW5jZSB0aGUKZGlmZiAtLWdpdCBhL2tlcm5lbC90cmFjZS90cmFjZV9mdW5jdGlvbnNfZ3JhcGguYyBiL2tlcm5lbC90cmFjZS90cmFjZV9mdW5jdGlvbnNfZ3JhcGguYwppbmRleCA3NmIwNTk4Li45NjJjZGIyIDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2VfZnVuY3Rpb25zX2dyYXBoLmMKKysrIGIva2VybmVsL3RyYWNlL3RyYWNlX2Z1bmN0aW9uc19ncmFwaC5jCkBAIC05MDUsNyArOTA1LDcgQEAKICAqCiAgKiByZXR1cm5zIDEgaWYKICAqICAtIHdlIGFyZSBpbnNpZGUgaXJxIGNvZGUKLSAqICAtIHdlIGp1c3QgZXh0ZXJlZCBpcnEgY29kZQorICogIC0gd2UganVzdCBlbnRlcmVkIGlycSBjb2RlCiAgKgogICogcmV0dW5ucyAwIGlmCiAgKiAgLSBmdW5jZ3JhcGgtaW50ZXJydXB0cyBvcHRpb24gaXMgc2V0CmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvdHJhY2VfaXJxc29mZi5jIGIva2VybmVsL3RyYWNlL3RyYWNlX2lycXNvZmYuYwppbmRleCA5MmI2ZTFlLi5hNDk2OWI0IDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2VfaXJxc29mZi5jCisrKyBiL2tlcm5lbC90cmFjZS90cmFjZV9pcnFzb2ZmLmMKQEAgLTgwLDcgKzgwLDcgQEAKICAqIHNraXAgdGhlIGxhdGVuY3kgaWYgdGhlIHNlcXVlbmNlIGhhcyBjaGFuZ2VkIC0gc29tZSBvdGhlciBzZWN0aW9uCiAgKiBkaWQgYSBtYXhpbXVtIGFuZCBjb3VsZCBkaXN0dXJiIG91ciBtZWFzdXJlbWVudCB3aXRoIHNlcmlhbCBjb25zb2xlCiAgKiBwcmludG91dHMsIGV0Yy4gVHJ1bHkgY29pbmNpZGluZyBtYXhpbXVtIGxhdGVuY2llcyBzaG91bGQgYmUgcmFyZQotICogYW5kIHdoYXQgaGFwcGVucyB0b2dldGhlciBoYXBwZW5zIHNlcGFyYXRlbHkgYXMgd2VsbCwgc28gdGhpcyBkb2VzbnQKKyAqIGFuZCB3aGF0IGhhcHBlbnMgdG9nZXRoZXIgaGFwcGVucyBzZXBhcmF0ZWx5IGFzIHdlbGwsIHNvIHRoaXMgZG9lc24ndAogICogZGVjcmVhc2UgdGhlIHZhbGlkaXR5IG9mIHRoZSBtYXhpbXVtIGZvdW5kOgogICovCiBzdGF0aWMgX19jYWNoZWxpbmVfYWxpZ25lZF9pbl9zbXAJdW5zaWduZWQgbG9uZyBtYXhfc2VxdWVuY2U7CmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvdHJhY2Vfa3Byb2JlLmMgYi9rZXJuZWwvdHJhY2UvdHJhY2Vfa3Byb2JlLmMKaW5kZXggODQzNWI0My4uMzVkNTVhMyAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL3RyYWNlX2twcm9iZS5jCisrKyBiL2tlcm5lbC90cmFjZS90cmFjZV9rcHJvYmUuYwpAQCAtMTgzOSw3ICsxODM5LDcgQEAKIAlrZnJlZSh0cC0+Y2FsbC5wcmludF9mbXQpOwogfQogCi0vKiBNYWtlIGEgZGVidWdmcyBpbnRlcmZhY2UgZm9yIGNvbnRyb2xpbmcgcHJvYmUgcG9pbnRzICovCisvKiBNYWtlIGEgZGVidWdmcyBpbnRlcmZhY2UgZm9yIGNvbnRyb2xsaW5nIHByb2JlIHBvaW50cyAqLwogc3RhdGljIF9faW5pdCBpbnQgaW5pdF9rcHJvYmVfdHJhY2Uodm9pZCkKIHsKIAlzdHJ1Y3QgZGVudHJ5ICpkX3RyYWNlcjsKZGlmZiAtLWdpdCBhL2tlcm5lbC91c2VyLXJldHVybi1ub3RpZmllci5jIGIva2VybmVsL3VzZXItcmV0dXJuLW5vdGlmaWVyLmMKaW5kZXggZWIyN2ZkMy4uOTJjYjcwNiAxMDA2NDQKLS0tIGEva2VybmVsL3VzZXItcmV0dXJuLW5vdGlmaWVyLmMKKysrIGIva2VybmVsL3VzZXItcmV0dXJuLW5vdGlmaWVyLmMKQEAgLTIwLDcgKzIwLDcgQEAKIAogLyoKICAqIFJlbW92ZXMgYSByZWdpc3RlcmVkIHVzZXIgcmV0dXJuIG5vdGlmaWVyLiAgTXVzdCBiZSBjYWxsZWQgZnJvbSBhdG9taWMKLSAqIGNvbnRleHQsIGFuZCBmcm9tIHRoZSBzYW1lIGNwdSByZWdpc3RyYXRpb24gb2NjdXJlZCBpbi4KKyAqIGNvbnRleHQsIGFuZCBmcm9tIHRoZSBzYW1lIGNwdSByZWdpc3RyYXRpb24gb2NjdXJyZWQgaW4uCiAgKi8KIHZvaWQgdXNlcl9yZXR1cm5fbm90aWZpZXJfdW5yZWdpc3RlcihzdHJ1Y3QgdXNlcl9yZXR1cm5fbm90aWZpZXIgKnVybikKIHsKZGlmZiAtLWdpdCBhL2tlcm5lbC93YWl0LmMgYi9rZXJuZWwvd2FpdC5jCmluZGV4IGIwMzEwZWIuLmY0NWVhOGQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC93YWl0LmMKKysrIGIva2VybmVsL3dhaXQuYwpAQCAtMTQyLDcgKzE0Miw3IEBACiAgKiB3b2tlbiB1cCB0aHJvdWdoIHRoZSBxdWV1ZS4KICAqCiAgKiBUaGlzIHByZXZlbnRzIHdhaXRlciBzdGFydmF0aW9uIHdoZXJlIGFuIGV4Y2x1c2l2ZSB3YWl0ZXIKLSAqIGFib3J0cyBhbmQgaXMgd29rZW4gdXAgY29uY3VycmVudGx5IGFuZCBub29uZSB3YWtlcyB1cAorICogYWJvcnRzIGFuZCBpcyB3b2tlbiB1cCBjb25jdXJyZW50bHkgYW5kIG5vIG9uZSB3YWtlcyB1cAogICogdGhlIG5leHQgd2FpdGVyLgogICovCiB2b2lkIGFib3J0X2V4Y2x1c2l2ZV93YWl0KHdhaXRfcXVldWVfaGVhZF90ICpxLCB3YWl0X3F1ZXVlX3QgKndhaXQsCmRpZmYgLS1naXQgYS9rZXJuZWwvd29ya3F1ZXVlLmMgYi9rZXJuZWwvd29ya3F1ZXVlLmMKaW5kZXggMDRlZjgzMC4uODg1OWE0MSAxMDA2NDQKLS0tIGEva2VybmVsL3dvcmtxdWV1ZS5jCisrKyBiL2tlcm5lbC93b3JrcXVldWUuYwpAQCAtMTI5MSw3ICsxMjkxLDcgQEAKIAkJCXJldHVybiB0cnVlOwogCQlzcGluX3VubG9ja19pcnEoJmdjd3EtPmxvY2spOwogCi0JCS8qIENQVSBoYXMgY29tZSB1cCBpbmJldHdlZW4sIHJldHJ5IG1pZ3JhdGlvbiAqLworCQkvKiBDUFUgaGFzIGNvbWUgdXAgaW4gYmV0d2VlbiwgcmV0cnkgbWlncmF0aW9uICovCiAJCWNwdV9yZWxheCgpOwogCX0KIH0KZGlmZiAtLWdpdCBhL2xpYi9iaXRtYXAuYyBiL2xpYi9iaXRtYXAuYwppbmRleCA3NDFmYWU5Li45MWUwY2NmIDEwMDY0NAotLS0gYS9saWIvYml0bWFwLmMKKysrIGIvbGliL2JpdG1hcC5jCkBAIC04MzAsNyArODMwLDcgQEAKICAqICBAb3JpZyAoaS5lLiBiaXRzIDMsIDUsIDcgYW5kIDkpIHdlcmUgYWxzbyBzZXQuCiAgKgogICogIFdoZW4gYml0IDExIGlzIHNldCBpbiBAb3JpZywgaXQgbWVhbnMgdHVybiBvbiB0aGUgYml0IGluCi0gKiAgQGRzdCBjb3JyZXNwb25kaW5nIHRvIHdoYXRldmVyIGlzIHRoZSB0d2VsdGggYml0IHRoYXQgaXMKKyAqICBAZHN0IGNvcnJlc3BvbmRpbmcgdG8gd2hhdGV2ZXIgaXMgdGhlIHR3ZWxmdGggYml0IHRoYXQgaXMKICAqICB0dXJuZWQgb24gaW4gQHJlbG1hcC4gIEluIHRoZSBhYm92ZSBleGFtcGxlLCB0aGVyZSB3ZXJlCiAgKiAgb25seSB0ZW4gYml0cyB0dXJuZWQgb24gaW4gQHJlbG1hcCAoMzAuLjM5KSwgc28gdGhhdCBiaXQKICAqICAxMSB3YXMgc2V0IGluIEBvcmlnIGhhZCBubyBhZmZlY3Qgb24gQGRzdC4KZGlmZiAtLWdpdCBhL2xpYi9idHJlZS5jIGIvbGliL2J0cmVlLmMKaW5kZXggYzljNmYwMy4uMmEzNDM5MiAxMDA2NDQKLS0tIGEvbGliL2J0cmVlLmMKKysrIGIvbGliL2J0cmVlLmMKQEAgLTExLDcgKzExLDcgQEAKICAqIHNlZSBodHRwOi8vcHJvZ3JhbW1pbmcua2lja3MtYXNzLm5ldC9rZXJuZWwtcGF0Y2hlcy92bWFfbG9va3VwL2J0cmVlLnBhdGNoCiAgKgogICogQSByZWxhdGl2ZWx5IHNpbXBsZSBCK1RyZWUgaW1wbGVtZW50YXRpb24uICBJIGhhdmUgd3JpdHRlbiBpdCBhcyBhIGxlYXJuaW5nCi0gKiBleGNlcmNpc2UgdG8gdW5kZXJzdGFuZCBob3cgQitUcmVlcyB3b3JrLiAgVHVybmVkIG91dCB0byBiZSB1c2VmdWwgYXMgd2VsbC4KKyAqIGV4ZXJjaXNlIHRvIHVuZGVyc3RhbmQgaG93IEIrVHJlZXMgd29yay4gIFR1cm5lZCBvdXQgdG8gYmUgdXNlZnVsIGFzIHdlbGwuCiAgKgogICogQitUcmVlcyBjYW4gYmUgdXNlZCBzaW1pbGFyIHRvIExpbnV4IHJhZGl4IHRyZWVzICh3aGljaCBkb24ndCBoYXZlIGFueXRoaW5nCiAgKiBpbiBjb21tb24gd2l0aCB0ZXh0Ym9vayByYWRpeCB0cmVlcywgYmV3YXJlKS4gIFByZXJlcXVpc2l0ZSBmb3IgdGhlbSB3b3JraW5nCkBAIC01NDEsNyArNTQxLDcgQEAKIAlpbnQgaSwgbm9fbGVmdCwgbm9fcmlnaHQ7CiAKIAlpZiAoZmlsbCA9PSAwKSB7Ci0JCS8qIEJlY2F1c2Ugd2UgZG9uJ3Qgc3RlYWwgZW50cmllcyBmcm9tIGEgbmVpZ2JvdXIsIHRoaXMgY2FzZQorCQkvKiBCZWNhdXNlIHdlIGRvbid0IHN0ZWFsIGVudHJpZXMgZnJvbSBhIG5laWdoYm91ciwgdGhpcyBjYXNlCiAJCSAqIGNhbiBoYXBwZW4uICBQYXJlbnQgbm9kZSBjb250YWlucyBhIHNpbmdsZSBjaGlsZCwgdGhpcwogCQkgKiBub2RlLCBzbyBtZXJnaW5nIHdpdGggYSBzaWJsaW5nIG5ldmVyIGhhcHBlbnMuCiAJCSAqLwpkaWZmIC0tZ2l0IGEvbGliL2RlY29tcHJlc3NfdW54ei5jIGIvbGliL2RlY29tcHJlc3NfdW54ei5jCmluZGV4IGNlY2QyM2QuLjlmMzRlYjUgMTAwNjQ0Ci0tLSBhL2xpYi9kZWNvbXByZXNzX3VueHouYworKysgYi9saWIvZGVjb21wcmVzc191bnh6LmMKQEAgLTgzLDcgKzgzLDcgQEAKICAqICAgIHNhZmV0eV9tYXJnaW4gPSAxMjggKyB1bmNvbXByZXNzZWRfc2l6ZSAqIDggLyAzMjc2OCArIDY1NTM2CiAgKiAgICAgICAgICAgICAgICAgID0gMTI4ICsgKHVuY29tcHJlc3NlZF9zaXplID4+IDEyKSArIDY1NTM2CiAgKgotICogRm9yIGNvbXBhcmlzaW9uLCBhY2NvcmRpbmcgdG8gYXJjaC94ODYvYm9vdC9jb21wcmVzc2VkL21pc2MuYywgdGhlCisgKiBGb3IgY29tcGFyaXNvbiwgYWNjb3JkaW5nIHRvIGFyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9taXNjLmMsIHRoZQogICogZXF1aXZhbGVudCBmb3JtdWxhIGZvciBEZWZsYXRlIGlzIHRoaXM6CiAgKgogICogICAgc2FmZXR5X21hcmdpbiA9IDE4ICsgKHVuY29tcHJlc3NlZF9zaXplID4+IDEyKSArIDMyNzY4CmRpZmYgLS1naXQgYS9saWIvcGFyc2VyLmMgYi9saWIvcGFyc2VyLmMKaW5kZXggNmU4OWVjYS4uZGNiYWFlZiAxMDA2NDQKLS0tIGEvbGliL3BhcnNlci5jCisrKyBiL2xpYi9wYXJzZXIuYwpAQCAtMTMsNyArMTMsNyBAQAogCiAvKioKICAqIG1hdGNoX29uZTogLSBEZXRlcm1pbmVzIGlmIGEgc3RyaW5nIG1hdGNoZXMgYSBzaW1wbGUgcGF0dGVybgotICogQHM6IHRoZSBzdHJpbmcgdG8gZXhhbWluZSBmb3IgcHJlc2Vuc2Ugb2YgdGhlIHBhdHRlcm4KKyAqIEBzOiB0aGUgc3RyaW5nIHRvIGV4YW1pbmUgZm9yIHByZXNlbmNlIG9mIHRoZSBwYXR0ZXJuCiAgKiBAcDogdGhlIHN0cmluZyBjb250YWluaW5nIHRoZSBwYXR0ZXJuCiAgKiBAYXJnczogYXJyYXkgb2YgJU1BWF9PUFRfQVJHUyAmc3Vic3RyaW5nX3QgZWxlbWVudHMuIFVzZWQgdG8gcmV0dXJuIG1hdGNoCiAgKiBsb2NhdGlvbnMuCmRpZmYgLS1naXQgYS9saWIvdGltZXJxdWV1ZS5jIGIvbGliL3RpbWVycXVldWUuYwppbmRleCBlM2ExMDUwLi4xOTExNzZhIDEwMDY0NAotLS0gYS9saWIvdGltZXJxdWV1ZS5jCisrKyBiL2xpYi90aW1lcnF1ZXVlLmMKQEAgLTUsNyArNSw3IEBACiAgKiAgVXNlcyByYnRyZWVzIGZvciBxdWljayBsaXN0IGFkZHMgYW5kIGV4cGlyYXRpb24uCiAgKgogICogIE5PVEU6IEFsbCBvZiB0aGUgZm9sbG93aW5nIGZ1bmN0aW9ucyBuZWVkIHRvIGJlIHNlcmlhbGl6ZWQKLSAqICB0byBhdm9pZCByYWNlcy4gTm8gbG9ja2luZyBpcyBkb25lIGJ5IHRoaXMgbGliYXJ5IGNvZGUuCisgKiAgdG8gYXZvaWQgcmFjZXMuIE5vIGxvY2tpbmcgaXMgZG9uZSBieSB0aGlzIGxpYnJhcnkgY29kZS4KICAqCiAgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICAqICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQpkaWZmIC0tZ2l0IGEvbW0vYmFja2luZy1kZXYuYyBiL21tL2JhY2tpbmctZGV2LmMKaW5kZXggMGQ5YTAzNi4uYmVmYzg3NSAxMDA2NDQKLS0tIGEvbW0vYmFja2luZy1kZXYuYworKysgYi9tbS9iYWNraW5nLWRldi5jCkBAIC03ODcsNyArNzg3LDcgQEAKICAqIGppZmZpZXMgZm9yIGVpdGhlciBhIEJESSB0byBleGl0IGNvbmdlc3Rpb24gb2YgdGhlIGdpdmVuIEBzeW5jIHF1ZXVlCiAgKiBvciBhIHdyaXRlIHRvIGNvbXBsZXRlLgogICoKLSAqIEluIHRoZSBhYnNlbnNlIG9mIHpvbmUgY29uZ2VzdGlvbiwgY29uZF9yZXNjaGVkKCkgaXMgY2FsbGVkIHRvIHlpZWxkCisgKiBJbiB0aGUgYWJzZW5jZSBvZiB6b25lIGNvbmdlc3Rpb24sIGNvbmRfcmVzY2hlZCgpIGlzIGNhbGxlZCB0byB5aWVsZAogICogdGhlIHByb2Nlc3NvciBpZiBuZWNlc3NhcnkgYnV0IG90aGVyd2lzZSBkb2VzIG5vdCBzbGVlcC4KICAqCiAgKiBUaGUgcmV0dXJuIHZhbHVlIGlzIDAgaWYgdGhlIHNsZWVwIGlzIGZvciB0aGUgZnVsbCB0aW1lb3V0LiBPdGhlcndpc2UsCmRpZmYgLS1naXQgYS9tbS9odWdldGxiLmMgYi9tbS9odWdldGxiLmMKaW5kZXggMDZkZTVhYS4uOGVlM2JkOCAxMDA2NDQKLS0tIGEvbW0vaHVnZXRsYi5jCisrKyBiL21tL2h1Z2V0bGIuYwpAQCAtMTQ2LDcgKzE0Niw3IEBACiAJCWlmIChyZy0+ZnJvbSA+IHQpCiAJCQlyZXR1cm4gY2hnOwogCi0JCS8qIFdlIG92ZXJsYXAgd2l0aCB0aGlzIGFyZWEsIGlmIGl0IGV4dGVuZHMgZnV0aGVyIHRoYW4KKwkJLyogV2Ugb3ZlcmxhcCB3aXRoIHRoaXMgYXJlYSwgaWYgaXQgZXh0ZW5kcyBmdXJ0aGVyIHRoYW4KIAkJICogdXMgdGhlbiB3ZSBtdXN0IGV4dGVuZCBvdXJzZWx2ZXMuICBBY2NvdW50IGZvciBpdHMKIAkJICogZXhpc3RpbmcgcmVzZXJ2YXRpb24uICovCiAJCWlmIChyZy0+dG8gPiB0KSB7CkBAIC04NDIsNyArODQyLDcgQEAKIH0KIAogLyoKLSAqIEluY3JlYXNlIHRoZSBodWdldGxiIHBvb2wgc3VjaCB0aGF0IGl0IGNhbiBhY2NvbW9kYXRlIGEgcmVzZXJ2YXRpb24KKyAqIEluY3JlYXNlIHRoZSBodWdldGxiIHBvb2wgc3VjaCB0aGF0IGl0IGNhbiBhY2NvbW1vZGF0ZSBhIHJlc2VydmF0aW9uCiAgKiBvZiBzaXplICdkZWx0YScuCiAgKi8KIHN0YXRpYyBpbnQgZ2F0aGVyX3N1cnBsdXNfcGFnZXMoc3RydWN0IGhzdGF0ZSAqaCwgaW50IGRlbHRhKQpAQCAtODkwLDcgKzg5MCw3IEBACiAKIAkvKgogCSAqIFRoZSBzdXJwbHVzX2xpc3Qgbm93IGNvbnRhaW5zIF9hdF9sZWFzdF8gdGhlIG51bWJlciBvZiBleHRyYSBwYWdlcwotCSAqIG5lZWRlZCB0byBhY2NvbW9kYXRlIHRoZSByZXNlcnZhdGlvbi4gIEFkZCB0aGUgYXBwcm9wcmlhdGUgbnVtYmVyCisJICogbmVlZGVkIHRvIGFjY29tbW9kYXRlIHRoZSByZXNlcnZhdGlvbi4gIEFkZCB0aGUgYXBwcm9wcmlhdGUgbnVtYmVyCiAJICogb2YgcGFnZXMgdG8gdGhlIGh1Z2V0bGIgcG9vbCBhbmQgZnJlZSB0aGUgZXh0cmFzIGJhY2sgdG8gdGhlIGJ1ZGR5CiAJICogYWxsb2NhdG9yLiAgQ29tbWl0IHRoZSBlbnRpcmUgcmVzZXJ2YXRpb24gaGVyZSB0byBwcmV2ZW50IGFub3RoZXIKIAkgKiBwcm9jZXNzIGZyb20gc3RlYWxpbmcgdGhlIHBhZ2VzIGFzIHRoZXkgYXJlIGFkZGVkIHRvIHRoZSBwb29sIGJ1dApAQCAtMjA0Myw3ICsyMDQzLDcgQEAKIAkgKiBUaGlzIG5ldyBWTUEgc2hvdWxkIHNoYXJlIGl0cyBzaWJsaW5ncyByZXNlcnZhdGlvbiBtYXAgaWYgcHJlc2VudC4KIAkgKiBUaGUgVk1BIHdpbGwgb25seSBldmVyIGhhdmUgYSB2YWxpZCByZXNlcnZhdGlvbiBtYXAgcG9pbnRlciB3aGVyZQogCSAqIGl0IGlzIGJlaW5nIGNvcGllZCBmb3IgYW5vdGhlciBzdGlsbCBleGlzdGluZyBWTUEuICBBcyB0aGF0IFZNQQotCSAqIGhhcyBhIHJlZmVyZW5jZSB0byB0aGUgcmVzZXJ2YXRpb24gbWFwIGl0IGNhbm5vdCBkaXNzYXBwZWFyIHVudGlsCisJICogaGFzIGEgcmVmZXJlbmNlIHRvIHRoZSByZXNlcnZhdGlvbiBtYXAgaXQgY2Fubm90IGRpc2FwcGVhciB1bnRpbAogCSAqIGFmdGVyIHRoaXMgb3BlbiBjYWxsIGNvbXBsZXRlcy4gIEl0IGlzIHRoZXJlZm9yZSBzYWZlIHRvIHRha2UgYQogCSAqIG5ldyByZWZlcmVuY2UgaGVyZSB3aXRob3V0IGFkZGl0aW9uYWwgbG9ja2luZy4KIAkgKi8KQEAgLTI0OTAsNyArMjQ5MCw3IEBACiAJLyoKIAkgKiBDdXJyZW50bHksIHdlIGFyZSBmb3JjZWQgdG8ga2lsbCB0aGUgcHJvY2VzcyBpbiB0aGUgZXZlbnQgdGhlCiAJICogb3JpZ2luYWwgbWFwcGVyIGhhcyB1bm1hcHBlZCBwYWdlcyBmcm9tIHRoZSBjaGlsZCBkdWUgdG8gYSBmYWlsZWQKLQkgKiBDT1cuIFdhcm4gdGhhdCBzdWNoIGEgc2l0dWF0aW9uIGhhcyBvY2N1cmVkIGFzIGl0IG1heSBub3QgYmUgb2J2aW91cworCSAqIENPVy4gV2FybiB0aGF0IHN1Y2ggYSBzaXR1YXRpb24gaGFzIG9jY3VycmVkIGFzIGl0IG1heSBub3QgYmUgb2J2aW91cwogCSAqLwogCWlmIChpc192bWFfcmVzdl9zZXQodm1hLCBIUEFHRV9SRVNWX1VOTUFQUEVEKSkgewogCQlwcmludGsoS0VSTl9XQVJOSU5HCmRpZmYgLS1naXQgYS9tbS9od3BvaXNvbi1pbmplY3QuYyBiL21tL2h3cG9pc29uLWluamVjdC5jCmluZGV4IDA5NDhmMTAuLmM3ZmM3ZmQgMTAwNjQ0Ci0tLSBhL21tL2h3cG9pc29uLWluamVjdC5jCisrKyBiL21tL2h3cG9pc29uLWluamVjdC5jCkBAIC0xLDQgKzEsNCBAQAotLyogSW5qZWN0IGEgaHdwb2lzb24gbWVtb3J5IGZhaWx1cmUgb24gYSBhcmJpdGFyeSBwZm4gKi8KKy8qIEluamVjdCBhIGh3cG9pc29uIG1lbW9yeSBmYWlsdXJlIG9uIGEgYXJiaXRyYXJ5IHBmbiAqLwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KZGlmZiAtLWdpdCBhL21tL2ludGVybmFsLmggYi9tbS9pbnRlcm5hbC5oCmluZGV4IDM0MzhkZDQuLjlkMGNlZDggMTAwNjQ0Ci0tLSBhL21tL2ludGVybmFsLmgKKysrIGIvbW0vaW50ZXJuYWwuaApAQCAtMTYyLDcgKzE2Miw3IEBACiB9CiAKIC8qCi0gKiBJdGVyYXRvciBvdmVyIGFsbCBzdWJwYWdlcyB3aXRoaW5nIHRoZSBtYXhpbWFsbHkgYWxpZ25lZCBnaWdhbnRpYworICogSXRlcmF0b3Igb3ZlciBhbGwgc3VicGFnZXMgd2l0aGluIHRoZSBtYXhpbWFsbHkgYWxpZ25lZCBnaWdhbnRpYwogICogcGFnZSAnYmFzZScuICBIYW5kbGUgYW55IGRpc2NvbnRpZ3VpdHkgaW4gdGhlIG1lbV9tYXAuCiAgKi8KIHN0YXRpYyBpbmxpbmUgc3RydWN0IHBhZ2UgKm1lbV9tYXBfbmV4dChzdHJ1Y3QgcGFnZSAqaXRlciwKZGlmZiAtLWdpdCBhL21tL2ttZW1sZWFrLmMgYi9tbS9rbWVtbGVhay5jCmluZGV4IDg0MjI1ZjMuLmMxZDU4NjcgMTAwNjQ0Ci0tLSBhL21tL2ttZW1sZWFrLmMKKysrIGIvbW0va21lbWxlYWsuYwpAQCAtMjY1LDcgKzI2NSw3IEBACiB9IHdoaWxlICgwKQogCiAvKgotICogTWFjcm8gaW52b2tlZCB3aGVuIGEgc2VyaW91cyBrbWVtbGVhayBjb25kaXRpb24gb2NjdXJlZCBhbmQgY2Fubm90IGJlCisgKiBNYWNybyBpbnZva2VkIHdoZW4gYSBzZXJpb3VzIGttZW1sZWFrIGNvbmRpdGlvbiBvY2N1cnJlZCBhbmQgY2Fubm90IGJlCiAgKiByZWNvdmVyZWQgZnJvbS4gS21lbWxlYWsgd2lsbCBiZSBkaXNhYmxlZCBhbmQgZnVydGhlciBhbGxvY2F0aW9uL2ZyZWVpbmcKICAqIHRyYWNpbmcgbm8gbG9uZ2VyIGF2YWlsYWJsZS4KICAqLwpAQCAtMTAwNiw3ICsxMDA2LDcgQEAKIAogLyoKICAqIE1lbW9yeSBzY2FubmluZyBpcyBhIGxvbmcgcHJvY2VzcyBhbmQgaXQgbmVlZHMgdG8gYmUgaW50ZXJydXB0YWJsZS4gVGhpcwotICogZnVuY3Rpb24gY2hlY2tzIHdoZXRoZXIgc3VjaCBpbnRlcnJ1cHQgY29uZGl0aW9uIG9jY3VyZWQuCisgKiBmdW5jdGlvbiBjaGVja3Mgd2hldGhlciBzdWNoIGludGVycnVwdCBjb25kaXRpb24gb2NjdXJyZWQuCiAgKi8KIHN0YXRpYyBpbnQgc2Nhbl9zaG91bGRfc3RvcCh2b2lkKQogewpAQCAtMTczMyw3ICsxNzMzLDcgQEAKIAogCWlmIChhdG9taWNfcmVhZCgma21lbWxlYWtfZXJyb3IpKSB7CiAJCS8qCi0JCSAqIFNvbWUgZXJyb3Igb2NjdXJlZCBhbmQga21lbWxlYWsgd2FzIGRpc2FibGVkLiBUaGVyZSBpcyBhCisJCSAqIFNvbWUgZXJyb3Igb2NjdXJyZWQgYW5kIGttZW1sZWFrIHdhcyBkaXNhYmxlZC4gVGhlcmUgaXMgYQogCQkgKiBzbWFsbCBjaGFuY2UgdGhhdCBrbWVtbGVha19kaXNhYmxlKCkgd2FzIGNhbGxlZCBpbW1lZGlhdGVseQogCQkgKiBhZnRlciBzZXR0aW5nIGttZW1sZWFrX2luaXRpYWxpemVkIGFuZCB3ZSBtYXkgZW5kIHVwIHdpdGgKIAkJICogdHdvIGNsZWFuLXVwIHRocmVhZHMgYnV0IHNlcmlhbGl6ZWQgYnkgc2Nhbl9tdXRleC4KZGlmZiAtLWdpdCBhL21tL2tzbS5jIGIvbW0va3NtLmMKaW5kZXggMWJiZTc4NS4uOTQyZGZjNyAxMDA2NDQKLS0tIGEvbW0va3NtLmMKKysrIGIvbW0va3NtLmMKQEAgLTcyMCw3ICs3MjAsNyBAQAogCQlzd2FwcGVkID0gUGFnZVN3YXBDYWNoZShwYWdlKTsKIAkJZmx1c2hfY2FjaGVfcGFnZSh2bWEsIGFkZHIsIHBhZ2VfdG9fcGZuKHBhZ2UpKTsKIAkJLyoKLQkJICogT2sgdGhpcyBpcyB0cmlja3ksIHdoZW4gZ2V0X3VzZXJfcGFnZXNfZmFzdCgpIHJ1biBpdCBkb2VzbnQKKwkJICogT2sgdGhpcyBpcyB0cmlja3ksIHdoZW4gZ2V0X3VzZXJfcGFnZXNfZmFzdCgpIHJ1biBpdCBkb2Vzbid0CiAJCSAqIHRha2UgYW55IGxvY2ssIHRoZXJlZm9yZSB0aGUgY2hlY2sgdGhhdCB3ZSBhcmUgZ29pbmcgdG8gbWFrZQogCQkgKiB3aXRoIHRoZSBwYWdlY291bnQgYWdhaW5zdCB0aGUgbWFwY291bnQgaXMgcmFjZXkgYW5kCiAJCSAqIE9fRElSRUNUIGNhbiBoYXBwZW4gcmlnaHQgYWZ0ZXIgdGhlIGNoZWNrLgpkaWZmIC0tZ2l0IGEvbW0vbWVtY29udHJvbC5jIGIvbW0vbWVtY29udHJvbC5jCmluZGV4IDFmMGI0NjAuLjAxMGY5MTYgMTAwNjQ0Ci0tLSBhL21tL21lbWNvbnRyb2wuYworKysgYi9tbS9tZW1jb250cm9sLmMKQEAgLTE0NjYsNyArMTQ2Niw3IEBACiAJCQkJCWJyZWFrOwogCQkJCX0KIAkJCQkvKgotCQkJCSAqIFdlIHdhbnQgdG8gZG8gbW9yZSB0YXJnZXR0ZWQgcmVjbGFpbS4KKwkJCQkgKiBXZSB3YW50IHRvIGRvIG1vcmUgdGFyZ2V0ZWQgcmVjbGFpbS4KIAkJCQkgKiBleGNlc3MgPj4gMiBpcyBub3QgdG8gZXhjZXNzaXZlIHNvIGFzIHRvCiAJCQkJICogcmVjbGFpbSB0b28gbXVjaCwgbm9yIHRvbyBsZXNzIHRoYXQgd2Uga2VlcAogCQkJCSAqIGNvbWluZyBiYWNrIHRvIHJlY2xhaW0gZnJvbSB0aGlzIGNncm91cApAQCAtMjI2NSw3ICsyMjY1LDcgQEAKICAqIC0gY29tcG91bmRfbG9jayBpcyBoZWxkIHdoZW4gbnJfcGFnZXMgPiAxCiAgKgogICogVGhpcyBmdW5jdGlvbiBkb2Vzbid0IGRvICJjaGFyZ2UiIG5vciBjc3NfZ2V0IHRvIG5ldyBjZ3JvdXAuIEl0IHNob3VsZCBiZQotICogZG9uZSBieSBhIGNhbGxlcihfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZSB3b3VsZCBiZSB1c2VmdWxsKS4gSWYgQHVuY2hhcmdlIGlzCisgKiBkb25lIGJ5IGEgY2FsbGVyKF9fbWVtX2Nncm91cF90cnlfY2hhcmdlIHdvdWxkIGJlIHVzZWZ1bCkuIElmIEB1bmNoYXJnZSBpcwogICogdHJ1ZSwgdGhpcyBmdW5jdGlvbiBkb2VzICJ1bmNoYXJnZSIgZnJvbSBvbGQgY2dyb3VwLCBidXQgaXQgZG9lc24ndCBpZgogICogQHVuY2hhcmdlIGlzIGZhbHNlLCBzbyBhIGNhbGxlciBzaG91bGQgZG8gInVuY2hhcmdlIi4KICAqLwpAQCAtMjMxOCw3ICsyMzE4LDcgQEAKIAkgKiBXZSBjaGFyZ2VzIGFnYWluc3QgInRvIiB3aGljaCBtYXkgbm90IGhhdmUgYW55IHRhc2tzLiBUaGVuLCAidG8iCiAJICogY2FuIGJlIHVuZGVyIHJtZGlyKCkuIEJ1dCBpbiBjdXJyZW50IGltcGxlbWVudGF0aW9uLCBjYWxsZXIgb2YKIAkgKiB0aGlzIGZ1bmN0aW9uIGlzIGp1c3QgZm9yY2VfZW1wdHkoKSBhbmQgbW92ZSBjaGFyZ2UsIHNvIGl0J3MKLQkgKiBnYXJhbnRlZWQgdGhhdCAidG8iIGlzIG5ldmVyIHJlbW92ZWQuIFNvLCB3ZSBkb24ndCBjaGVjayBybWRpcgorCSAqIGd1YXJhbnRlZWQgdGhhdCAidG8iIGlzIG5ldmVyIHJlbW92ZWQuIFNvLCB3ZSBkb24ndCBjaGVjayBybWRpcgogCSAqIHN0YXR1cyBoZXJlLgogCSAqLwogCW1vdmVfdW5sb2NrX3BhZ2VfY2dyb3VwKHBjLCAmZmxhZ3MpOwpAQCAtMjY0OCw3ICsyNjQ4LDcgQEAKIAkJYmF0Y2gtPm1lbWNnID0gbWVtOwogCS8qCiAJICogZG9fYmF0Y2ggPiAwIHdoZW4gdW5tYXBwaW5nIHBhZ2VzIG9yIGlub2RlIGludmFsaWRhdGUvdHJ1bmNhdGUuCi0JICogSW4gdGhvc2UgY2FzZXMsIGFsbCBwYWdlcyBmcmVlZCBjb250aW5vdXNseSBjYW4gYmUgZXhwZWN0ZWQgdG8gYmUgaW4KKwkgKiBJbiB0aG9zZSBjYXNlcywgYWxsIHBhZ2VzIGZyZWVkIGNvbnRpbnVvdXNseSBjYW4gYmUgZXhwZWN0ZWQgdG8gYmUgaW4KIAkgKiB0aGUgc2FtZSBjZ3JvdXAgYW5kIHdlIGhhdmUgY2hhbmNlIHRvIGNvYWxlc2NlIHVuY2hhcmdlcy4KIAkgKiBCdXQgd2UgZG8gdW5jaGFyZ2Ugb25lIGJ5IG9uZSBpZiB0aGlzIGlzIGtpbGxlZCBieSBPT00oVElGX01FTURJRSkKIAkgKiBiZWNhdXNlIHdlIHdhbnQgdG8gZG8gdW5jaGFyZ2UgYXMgc29vbiBhcyBwb3NzaWJsZS4KZGlmZiAtLWdpdCBhL21tL21lbW9yeS1mYWlsdXJlLmMgYi9tbS9tZW1vcnktZmFpbHVyZS5jCmluZGV4IDM3ZmViOWYuLjJiOWE1ZWUgMTAwNjQ0Ci0tLSBhL21tL21lbW9yeS1mYWlsdXJlLmMKKysrIGIvbW0vbWVtb3J5LWZhaWx1cmUuYwpAQCAtMjA4LDcgKzIwOCw3IEBACiAJICogRG9uJ3QgdXNlIGZvcmNlIGhlcmUsIGl0J3MgY29udmVuaWVudCBpZiB0aGUgc2lnbmFsCiAJICogY2FuIGJlIHRlbXBvcmFyaWx5IGJsb2NrZWQuCiAJICogVGhpcyBjb3VsZCBjYXVzZSBhIGxvb3Agd2hlbiB0aGUgdXNlciBzZXRzIFNJR0JVUwotCSAqIHRvIFNJR19JR04sIGJ1dCBob3BlZnVsbHkgbm9vbmUgd2lsbCBkbyB0aGF0PworCSAqIHRvIFNJR19JR04sIGJ1dCBob3BlZnVsbHkgbm8gb25lIHdpbGwgZG8gdGhhdD8KIAkgKi8KIAlyZXQgPSBzZW5kX3NpZ19pbmZvKFNJR0JVUywgJnNpLCB0KTsgIC8qIHN5bmNocm9ub3VzPyAqLwogCWlmIChyZXQgPCAwKQpAQCAtNjM0LDcgKzYzNCw3IEBACiAJCSAqIHdoZW4gdGhlIHBhZ2UgaXMgcmVyZWFkIG9yIGRyb3BwZWQuICBJZiBhbgogCQkgKiBhcHBsaWNhdGlvbiBhc3N1bWVzIGl0IHdpbGwgYWx3YXlzIGdldCBlcnJvciBvbgogCQkgKiBmc3luYywgYnV0IGRvZXMgb3RoZXIgb3BlcmF0aW9ucyBvbiB0aGUgZmQgYmVmb3JlCi0JCSAqIGFuZCB0aGUgcGFnZSBpcyBkcm9wcGVkIGluYmV0d2VlbiB0aGVuIHRoZSBlcnJvcgorCQkgKiBhbmQgdGhlIHBhZ2UgaXMgZHJvcHBlZCBiZXR3ZWVuIHRoZW4gdGhlIGVycm9yCiAJCSAqIHdpbGwgbm90IGJlIHByb3Blcmx5IHJlcG9ydGVkLgogCQkgKgogCQkgKiBUaGlzIGNhbiBhbHJlYWR5IGhhcHBlbiBldmVuIHdpdGhvdXQgaHdwb2lzb25lZApAQCAtNzI4LDcgKzcyOCw3IEBACiAgKiBUaGUgdGFibGUgbWF0Y2hlcyB0aGVtIGluIG9yZGVyIGFuZCBjYWxscyB0aGUgcmlnaHQgaGFuZGxlci4KICAqCiAgKiBUaGlzIGlzIHF1aXRlIHRyaWNreSBiZWNhdXNlIHdlIGNhbiBhY2Nlc3MgcGFnZSBhdCBhbnkgdGltZQotICogaW4gaXRzIGxpdmUgY3ljbGUsIHNvIGFsbCBhY2Nlc3NlcyBoYXZlIHRvIGJlIGV4dHJlbWx5IGNhcmVmdWwuCisgKiBpbiBpdHMgbGl2ZSBjeWNsZSwgc28gYWxsIGFjY2Vzc2VzIGhhdmUgdG8gYmUgZXh0cmVtZWx5IGNhcmVmdWwuCiAgKgogICogVGhpcyBpcyBub3QgY29tcGxldGUuIE1vcmUgc3RhdGVzIGNvdWxkIGJlIGFkZGVkLgogICogRm9yIGFueSBtaXNzaW5nIHN0YXRlIGRvbid0IGF0dGVtcHQgcmVjb3ZlcnkuCmRpZmYgLS1naXQgYS9tbS9tZW1vcnlfaG90cGx1Zy5jIGIvbW0vbWVtb3J5X2hvdHBsdWcuYwppbmRleCAzMjFmYzc0Li5hMmFjYWY4IDEwMDY0NAotLS0gYS9tbS9tZW1vcnlfaG90cGx1Zy5jCisrKyBiL21tL21lbW9yeV9ob3RwbHVnLmMKQEAgLTcyNCw3ICs3MjQsNyBAQAogCQkJICAgICAgIHBmbik7CiAJCQlkdW1wX3BhZ2UocGFnZSk7CiAjZW5kaWYKLQkJCS8qIEJlY2FzdWUgd2UgZG9uJ3QgaGF2ZSBiaWcgem9uZS0+bG9jay4gd2Ugc2hvdWxkCisJCQkvKiBCZWNhdXNlIHdlIGRvbid0IGhhdmUgYmlnIHpvbmUtPmxvY2suIHdlIHNob3VsZAogCQkJICAgY2hlY2sgdGhpcyBhZ2FpbiBoZXJlLiAqLwogCQkJaWYgKHBhZ2VfY291bnQocGFnZSkpIHsKIAkJCQlub3RfbWFuYWdlZCsrOwpkaWZmIC0tZ2l0IGEvbW0vbWlncmF0ZS5jIGIvbW0vbWlncmF0ZS5jCmluZGV4IGIwNDA2ZDcuLjM0MTMyZjggMTAwNjQ0Ci0tLSBhL21tL21pZ3JhdGUuYworKysgYi9tbS9taWdyYXRlLmMKQEAgLTM3NSw3ICszNzUsNyBAQAogCQkgKiByZWRvIHRoZSBhY2NvdW50aW5nIHRoYXQgY2xlYXJfcGFnZV9kaXJ0eV9mb3JfaW8gdW5kaWQsCiAJCSAqIGJ1dCB3ZSBjYW4ndCB1c2Ugc2V0X3BhZ2VfZGlydHkgYmVjYXVzZSB0aGF0IGZ1bmN0aW9uCiAJCSAqIGlzIGFjdHVhbGx5IGEgc2lnbmFsIHRoYXQgYWxsIG9mIHRoZSBwYWdlIGhhcyBiZWNvbWUgZGlydHkuCi0JCSAqIFdoZXJhcyBvbmx5IHBhcnQgb2Ygb3VyIHBhZ2UgbWF5IGJlIGRpcnR5LgorCQkgKiBXaGVyZWFzIG9ubHkgcGFydCBvZiBvdXIgcGFnZSBtYXkgYmUgZGlydHkuCiAJCSAqLwogCQlfX3NldF9wYWdlX2RpcnR5X25vYnVmZmVycyhuZXdwYWdlKTsKICAJfQpkaWZmIC0tZ2l0IGEvbW0vbXJlbWFwLmMgYi9tbS9tcmVtYXAuYwppbmRleCAxZGU5OGQ0Li5hN2MxZjlmIDEwMDY0NAotLS0gYS9tbS9tcmVtYXAuYworKysgYi9tbS9tcmVtYXAuYwpAQCAtMjc3LDkgKzI3NywxNiBAQAogCWlmIChvbGRfbGVuID4gdm1hLT52bV9lbmQgLSBhZGRyKQogCQlnb3RvIEVmYXVsdDsKIAotCWlmICh2bWEtPnZtX2ZsYWdzICYgKFZNX0RPTlRFWFBBTkQgfCBWTV9QRk5NQVApKSB7Ci0JCWlmIChuZXdfbGVuID4gb2xkX2xlbikKKwkvKiBOZWVkIHRvIGJlIGNhcmVmdWwgYWJvdXQgYSBncm93aW5nIG1hcHBpbmcgKi8KKwlpZiAobmV3X2xlbiA+IG9sZF9sZW4pIHsKKwkJdW5zaWduZWQgbG9uZyBwZ29mZjsKKworCQlpZiAodm1hLT52bV9mbGFncyAmIChWTV9ET05URVhQQU5EIHwgVk1fUEZOTUFQKSkKIAkJCWdvdG8gRWZhdWx0OworCQlwZ29mZiA9IChhZGRyIC0gdm1hLT52bV9zdGFydCkgPj4gUEFHRV9TSElGVDsKKwkJcGdvZmYgKz0gdm1hLT52bV9wZ29mZjsKKwkJaWYgKHBnb2ZmICsgKG5ld19sZW4gPj4gUEFHRV9TSElGVCkgPCBwZ29mZikKKwkJCWdvdG8gRWludmFsOwogCX0KIAogCWlmICh2bWEtPnZtX2ZsYWdzICYgVk1fTE9DS0VEKSB7CmRpZmYgLS1naXQgYS9tbS9ub2Jvb3RtZW0uYyBiL21tL25vYm9vdG1lbS5jCmluZGV4IGU5OWY2Y2QuLjkxMDkwNDkgMTAwNjQ0Ci0tLSBhL21tL25vYm9vdG1lbS5jCisrKyBiL21tL25vYm9vdG1lbS5jCkBAIC0xNTAsNyArMTUwLDcgQEAKIHsKIAkvKgogCSAqIFdlIG5lZWQgdG8gdXNlIE1BWF9OVU1OT0RFUyBpbnN0ZWFkIG9mIE5PREVfREFUQSgwKS0+bm9kZV9pZAotCSAqICBiZWNhdXNlIGluIHNvbWUgY2FzZSBsaWtlIE5vZGUwIGRvZXNudCBoYXZlIFJBTSBpbnN0YWxsZWQKKwkgKiAgYmVjYXVzZSBpbiBzb21lIGNhc2UgbGlrZSBOb2RlMCBkb2Vzbid0IGhhdmUgUkFNIGluc3RhbGxlZAogCSAqICBsb3cgcmFtIHdpbGwgYmUgb24gTm9kZTEKIAkgKiBVc2UgTUFYX05VTU5PREVTIHdpbGwgbWFrZSBzdXJlIGFsbCByYW5nZXMgaW4gZWFybHlfbm9kZV9tYXBbXQogCSAqICB3aWxsIGJlIHVzZWQgaW5zdGVhZCBvZiBvbmx5IE5vZGUwIHJlbGF0ZWQKZGlmZiAtLWdpdCBhL21tL3BhZ2VfYWxsb2MuYyBiL21tL3BhZ2VfYWxsb2MuYwppbmRleCBkNmU3YmE3Li4yNzQ3ZjVlNWEgMTAwNjQ0Ci0tLSBhL21tL3BhZ2VfYWxsb2MuYworKysgYi9tbS9wYWdlX2FsbG9jLmMKQEAgLTk0Miw3ICs5NDIsNyBAQAogCQkJICogSWYgYnJlYWtpbmcgYSBsYXJnZSBibG9jayBvZiBwYWdlcywgbW92ZSBhbGwgZnJlZQogCQkJICogcGFnZXMgdG8gdGhlIHByZWZlcnJlZCBhbGxvY2F0aW9uIGxpc3QuIElmIGZhbGxpbmcKIAkJCSAqIGJhY2sgZm9yIGEgcmVjbGFpbWFibGUga2VybmVsIGFsbG9jYXRpb24sIGJlIG1vcmUKLQkJCSAqIGFncmVzc2l2ZSBhYm91dCB0YWtpbmcgb3duZXJzaGlwIG9mIGZyZWUgcGFnZXMKKwkJCSAqIGFnZ3Jlc3NpdmUgYWJvdXQgdGFraW5nIG93bmVyc2hpcCBvZiBmcmVlIHBhZ2VzCiAJCQkgKi8KIAkJCWlmICh1bmxpa2VseShjdXJyZW50X29yZGVyID49IChwYWdlYmxvY2tfb3JkZXIgPj4gMSkpIHx8CiAJCQkJCXN0YXJ0X21pZ3JhdGV0eXBlID09IE1JR1JBVEVfUkVDTEFJTUFCTEUgfHwKQEAgLTM5MjYsNyArMzkyNiw3IEBACiAKIC8qCiAgKiBUaGUgem9uZSByYW5nZXMgcHJvdmlkZWQgYnkgdGhlIGFyY2hpdGVjdHVyZSBkbyBub3QgaW5jbHVkZSBaT05FX01PVkFCTEUKLSAqIGJlY2F1c2UgaXQgaXMgc2l6ZWQgaW5kZXBlbmRhbnQgb2YgYXJjaGl0ZWN0dXJlLiBVbmxpa2UgdGhlIG90aGVyIHpvbmVzLAorICogYmVjYXVzZSBpdCBpcyBzaXplZCBpbmRlcGVuZGVudCBvZiBhcmNoaXRlY3R1cmUuIFVubGlrZSB0aGUgb3RoZXIgem9uZXMsCiAgKiB0aGUgc3RhcnRpbmcgcG9pbnQgZm9yIFpPTkVfTU9WQUJMRSBpcyBub3QgZml4ZWQuIEl0IG1heSBiZSBkaWZmZXJlbnQKICAqIGluIGVhY2ggbm9kZSBkZXBlbmRpbmcgb24gdGhlIHNpemUgb2YgZWFjaCBub2RlIGFuZCBob3cgZXZlbmx5IGtlcm5lbGNvcmUKICAqIGlzIGRpc3RyaWJ1dGVkLiBUaGlzIGhlbHBlciBmdW5jdGlvbiBhZGp1c3RzIHRoZSB6b25lIHJhbmdlcwpkaWZmIC0tZ2l0IGEvbW0vcGFnZV9jZ3JvdXAuYyBiL21tL3BhZ2VfY2dyb3VwLmMKaW5kZXggYTEyY2MzZi4uOTkwNTUwMSAxMDA2NDQKLS0tIGEvbW0vcGFnZV9jZ3JvdXAuYworKysgYi9tbS9wYWdlX2Nncm91cC5jCkBAIC0zNzcsNyArMzc3LDcgQEAKICAqIEBuZXc6IG5ldyBpZAogICoKICAqIFJldHVybnMgb2xkIGlkIGF0IHN1Y2Nlc3MsIDAgYXQgZmFpbHVyZS4KLSAqIChUaGVyZSBpcyBubyBtZW1fY2dyb3VwIHVzZWluZyAwIGFzIGl0cyBpZCkKKyAqIChUaGVyZSBpcyBubyBtZW1fY2dyb3VwIHVzaW5nIDAgYXMgaXRzIGlkKQogICovCiB1bnNpZ25lZCBzaG9ydCBzd2FwX2Nncm91cF9jbXB4Y2hnKHN3cF9lbnRyeV90IGVudCwKIAkJCQkJdW5zaWduZWQgc2hvcnQgb2xkLCB1bnNpZ25lZCBzaG9ydCBuZXcpCmRpZmYgLS1naXQgYS9tbS9wZXJjcHUuYyBiL21tL3BlcmNwdS5jCmluZGV4IDU1ZDRkMTEuLmExNjBkYjMgMTAwNjQ0Ci0tLSBhL21tL3BlcmNwdS5jCisrKyBiL21tL3BlcmNwdS5jCkBAIC0zNDIsNyArMzQyLDcgQEAKICAqIEBjaHVuazogY2h1bmsgb2YgaW50ZXJlc3QKICAqCiAgKiBEZXRlcm1pbmUgd2hldGhlciBhcmVhIG1hcCBvZiBAY2h1bmsgbmVlZHMgdG8gYmUgZXh0ZW5kZWQgdG8KLSAqIGFjY29tb2RhdGUgYSBuZXcgYWxsb2NhdGlvbi4KKyAqIGFjY29tbW9kYXRlIGEgbmV3IGFsbG9jYXRpb24uCiAgKgogICogQ09OVEVYVDoKICAqIHBjcHVfbG9jay4KQEAgLTQzMSw3ICs0MzEsNyBAQAogICogZGVwZW5kaW5nIG9uIEBoZWFkLCBpcyByZWR1Y2VkIGJ5IEB0YWlsIGJ5dGVzIGFuZCBAdGFpbCBieXRlIGJsb2NrCiAgKiBpcyBpbnNlcnRlZCBhZnRlciB0aGUgdGFyZ2V0IGJsb2NrLgogICoKLSAqIEBjaHVuay0+bWFwIG11c3QgaGF2ZSBlbm91Z2ggZnJlZSBzbG90cyB0byBhY2NvbW9kYXRlIHRoZSBzcGxpdC4KKyAqIEBjaHVuay0+bWFwIG11c3QgaGF2ZSBlbm91Z2ggZnJlZSBzbG90cyB0byBhY2NvbW1vZGF0ZSB0aGUgc3BsaXQuCiAgKgogICogQ09OVEVYVDoKICAqIHBjcHVfbG9jay4KQEAgLTE0MzUsNyArMTQzNSw3IEBACiAJLyoKIAkgKiBEZXRlcm1pbmUgbWluX3VuaXRfc2l6ZSwgYWxsb2Nfc2l6ZSBhbmQgbWF4X3VwYSBzdWNoIHRoYXQKIAkgKiBhbGxvY19zaXplIGlzIG11bHRpcGxlIG9mIGF0b21fc2l6ZSBhbmQgaXMgdGhlIHNtYWxsZXN0Ci0JICogd2hpY2ggY2FuIGFjY29tb2RhdGUgNGsgYWxpZ25lZCBzZWdtZW50cyB3aGljaCBhcmUgZXF1YWwgdG8KKwkgKiB3aGljaCBjYW4gYWNjb21tb2RhdGUgNGsgYWxpZ25lZCBzZWdtZW50cyB3aGljaCBhcmUgZXF1YWwgdG8KIAkgKiBvciBsYXJnZXIgdGhhbiBtaW5fdW5pdF9zaXplLgogCSAqLwogCW1pbl91bml0X3NpemUgPSBtYXhfdChzaXplX3QsIHNpemVfc3VtLCBQQ1BVX01JTl9VTklUX1NJWkUpOwpAQCAtMTU1MCw3ICsxNTUwLDcgQEAKICAqIEBhdG9tX3NpemU6IGFsbG9jYXRpb24gYXRvbSBzaXplCiAgKiBAY3B1X2Rpc3RhbmNlX2ZuOiBjYWxsYmFjayB0byBkZXRlcm1pbmUgZGlzdGFuY2UgYmV0d2VlbiBjcHVzLCBvcHRpb25hbAogICogQGFsbG9jX2ZuOiBmdW5jdGlvbiB0byBhbGxvY2F0ZSBwZXJjcHUgcGFnZQotICogQGZyZWVfZm46IGZ1bnRpb24gdG8gZnJlZSBwZXJjcHUgcGFnZQorICogQGZyZWVfZm46IGZ1bmN0aW9uIHRvIGZyZWUgcGVyY3B1IHBhZ2UKICAqCiAgKiBUaGlzIGlzIGEgaGVscGVyIHRvIGVhc2Ugc2V0dGluZyB1cCBlbWJlZGRlZCBmaXJzdCBwZXJjcHUgY2h1bmsgYW5kCiAgKiBjYW4gYmUgY2FsbGVkIHdoZXJlIHBjcHVfc2V0dXBfZmlyc3RfY2h1bmsoKSBpcyBleHBlY3RlZC4KQEAgLTE2NzgsNyArMTY3OCw3IEBACiAgKiBwY3B1X3BhZ2VfZmlyc3RfY2h1bmsgLSBtYXAgdGhlIGZpcnN0IGNodW5rIHVzaW5nIFBBR0VfU0laRSBwYWdlcwogICogQHJlc2VydmVkX3NpemU6IHRoZSBzaXplIG9mIHJlc2VydmVkIHBlcmNwdSBhcmVhIGluIGJ5dGVzCiAgKiBAYWxsb2NfZm46IGZ1bmN0aW9uIHRvIGFsbG9jYXRlIHBlcmNwdSBwYWdlLCBhbHdheXMgY2FsbGVkIHdpdGggUEFHRV9TSVpFCi0gKiBAZnJlZV9mbjogZnVudGlvbiB0byBmcmVlIHBlcmNwdSBwYWdlLCBhbHdheXMgY2FsbGVkIHdpdGggUEFHRV9TSVpFCisgKiBAZnJlZV9mbjogZnVuY3Rpb24gdG8gZnJlZSBwZXJjcHUgcGFnZSwgYWx3YXlzIGNhbGxlZCB3aXRoIFBBR0VfU0laRQogICogQHBvcHVsYXRlX3B0ZV9mbjogZnVuY3Rpb24gdG8gcG9wdWxhdGUgcHRlCiAgKgogICogVGhpcyBpcyBhIGhlbHBlciB0byBlYXNlIHNldHRpbmcgdXAgcGFnZS1yZW1hcHBlZCBmaXJzdCBwZXJjcHUKZGlmZiAtLWdpdCBhL21tL3NsYWIuYyBiL21tL3NsYWIuYwppbmRleCA1Njg4MDNmLi40NmE5YzE2IDEwMDY0NAotLS0gYS9tbS9zbGFiLmMKKysrIGIvbW0vc2xhYi5jCkBAIC04NzgsNyArODc4LDcgQEAKIAluYyA9IGttYWxsb2Nfbm9kZShtZW1zaXplLCBnZnAsIG5vZGUpOwogCS8qCiAJICogVGhlIGFycmF5X2NhY2hlIHN0cnVjdHVyZXMgY29udGFpbiBwb2ludGVycyB0byBmcmVlIG9iamVjdC4KLQkgKiBIb3dldmVyLCB3aGVuIHN1Y2ggb2JqZWN0cyBhcmUgYWxsb2NhdGVkIG9yIHRyYW5zZmVyZWQgdG8gYW5vdGhlcgorCSAqIEhvd2V2ZXIsIHdoZW4gc3VjaCBvYmplY3RzIGFyZSBhbGxvY2F0ZWQgb3IgdHJhbnNmZXJyZWQgdG8gYW5vdGhlcgogCSAqIGNhY2hlIHRoZSBwb2ludGVycyBhcmUgbm90IGNsZWFyZWQgYW5kIHRoZXkgY291bGQgYmUgY291bnRlZCBhcwogCSAqIHZhbGlkIHJlZmVyZW5jZXMgZHVyaW5nIGEga21lbWxlYWsgc2Nhbi4gVGhlcmVmb3JlLCBrbWVtbGVhayBtdXN0CiAJICogbm90IHNjYW4gc3VjaCBvYmplY3RzLgpAQCAtMjYwNiw3ICsyNjA2LDcgQEAKICAqCiAgKiBUaGUgY2FjaGUgbXVzdCBiZSBlbXB0eSBiZWZvcmUgY2FsbGluZyB0aGlzIGZ1bmN0aW9uLgogICoKLSAqIFRoZSBjYWxsZXIgbXVzdCBndWFyYW50ZWUgdGhhdCBub29uZSB3aWxsIGFsbG9jYXRlIG1lbW9yeSBmcm9tIHRoZSBjYWNoZQorICogVGhlIGNhbGxlciBtdXN0IGd1YXJhbnRlZSB0aGF0IG5vIG9uZSB3aWxsIGFsbG9jYXRlIG1lbW9yeSBmcm9tIHRoZSBjYWNoZQogICogZHVyaW5nIHRoZSBrbWVtX2NhY2hlX2Rlc3Ryb3koKS4KICAqLwogdm9pZCBrbWVtX2NhY2hlX2Rlc3Ryb3koc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcCkKZGlmZiAtLWdpdCBhL21tL3NsdWIuYyBiL21tL3NsdWIuYwppbmRleCBmODgxODc0Li45NGQyYTMzIDEwMDY0NAotLS0gYS9tbS9zbHViLmMKKysrIGIvbW0vc2x1Yi5jCkBAIC02NCw3ICs2NCw3IEBACiAgKiAgIHdlIG11c3Qgc3RheSBhd2F5IGZyb20gaXQgZm9yIGEgd2hpbGUgc2luY2Ugd2UgbWF5IGNhdXNlIGEgYm91bmNpbmcKICAqICAgY2FjaGVsaW5lIGlmIHdlIHRyeSB0byBhY3F1aXJlIHRoZSBsb2NrLiBTbyBnbyBvbnRvIHRoZSBuZXh0IHNsYWIuCiAgKiAgIElmIGFsbCBwYWdlcyBhcmUgYnVzeSB0aGVuIHdlIG1heSBhbGxvY2F0ZSBhIG5ldyBzbGFiIGluc3RlYWQgb2YgcmV1c2luZwotICogICBhIHBhcnRpYWwgc2xhYi4gQSBuZXcgc2xhYiBoYXMgbm9vbmUgb3BlcmF0aW5nIG9uIGl0IGFuZCB0aHVzIHRoZXJlIGlzCisgKiAgIGEgcGFydGlhbCBzbGFiLiBBIG5ldyBzbGFiIGhhcyBubyBvbmUgb3BlcmF0aW5nIG9uIGl0IGFuZCB0aHVzIHRoZXJlIGlzCiAgKiAgIG5vIGRhbmdlciBvZiBjYWNoZWxpbmUgY29udGVudGlvbi4KICAqCiAgKiAgIEludGVycnVwdHMgYXJlIGRpc2FibGVkIGR1cmluZyBhbGxvY2F0aW9uIGFuZCBkZWFsbG9jYXRpb24gaW4gb3JkZXIgdG8KQEAgLTE5MjksNyArMTkyOSw3IEBACiAJZWxzZSB7CiAjaWZkZWYgQ09ORklHX0NNUFhDSEdfTE9DQUwKIAkJLyoKLQkJICogVGhlIGNtcHhjaGcgd2lsbCBvbmx5IG1hdGNoIGlmIHRoZXJlIHdhcyBubyBhZGRpdG9uYWwKKwkJICogVGhlIGNtcHhjaGcgd2lsbCBvbmx5IG1hdGNoIGlmIHRoZXJlIHdhcyBubyBhZGRpdGlvbmFsCiAJCSAqIG9wZXJhdGlvbiBhbmQgaWYgd2UgYXJlIG9uIHRoZSByaWdodCBwcm9jZXNzb3IuCiAJCSAqCiAJCSAqIFRoZSBjbXB4Y2hnIGRvZXMgdGhlIGZvbGxvd2luZyBhdG9taWNhbGx5ICh3aXRob3V0IGxvY2sgc2VtYW50aWNzISkKQEAgLTM1NDcsNyArMzU0Nyw3IEBACiAKIAlyZXQgPSBzbGFiX2FsbG9jKHMsIGdmcGZsYWdzLCBOVU1BX05PX05PREUsIGNhbGxlcik7CiAKLQkvKiBIb25vciB0aGUgY2FsbCBzaXRlIHBvaW50ZXIgd2UgcmVjaWV2ZWQuICovCisJLyogSG9ub3IgdGhlIGNhbGwgc2l0ZSBwb2ludGVyIHdlIHJlY2VpdmVkLiAqLwogCXRyYWNlX2ttYWxsb2MoY2FsbGVyLCByZXQsIHNpemUsIHMtPnNpemUsIGdmcGZsYWdzKTsKIAogCXJldHVybiByZXQ7CkBAIC0zNTc3LDcgKzM1NzcsNyBAQAogCiAJcmV0ID0gc2xhYl9hbGxvYyhzLCBnZnBmbGFncywgbm9kZSwgY2FsbGVyKTsKIAotCS8qIEhvbm9yIHRoZSBjYWxsIHNpdGUgcG9pbnRlciB3ZSByZWNpZXZlZC4gKi8KKwkvKiBIb25vciB0aGUgY2FsbCBzaXRlIHBvaW50ZXIgd2UgcmVjZWl2ZWQuICovCiAJdHJhY2Vfa21hbGxvY19ub2RlKGNhbGxlciwgcmV0LCBzaXplLCBzLT5zaXplLCBnZnBmbGFncywgbm9kZSk7CiAKIAlyZXR1cm4gcmV0OwpkaWZmIC0tZ2l0IGEvbW0vc3BhcnNlLmMgYi9tbS9zcGFyc2UuYwppbmRleCA5MzI1MDIwLi5hYTY0YjEyIDEwMDY0NAotLS0gYS9tbS9zcGFyc2UuYworKysgYi9tbS9zcGFyc2UuYwpAQCAtNTAwLDcgKzUwMCw3IEBACiAJICogc28gYWxsb2MgMk0gKHdpdGggMk0gYWxpZ24pIGFuZCAyNCBieXRlcyBpbiB0dXJuIHdpbGwKIAkgKiBtYWtlIG5leHQgMk0gc2xpcCB0byBvbmUgbW9yZSAyTSBsYXRlci4KIAkgKiB0aGVuIGluIGJpZyBzeXN0ZW0sIHRoZSBtZW1vcnkgd2lsbCBoYXZlIGEgbG90IG9mIGhvbGVzLi4uCi0JICogaGVyZSB0cnkgdG8gYWxsb2NhdGUgMk0gcGFnZXMgY29udGlub3VzbHkuCisJICogaGVyZSB0cnkgdG8gYWxsb2NhdGUgMk0gcGFnZXMgY29udGludW91c2x5LgogCSAqCiAJICogcG93ZXJwYyBuZWVkIHRvIGNhbGwgc3BhcnNlX2luaXRfb25lX3NlY3Rpb24gcmlnaHQgYWZ0ZXIgZWFjaAogCSAqIHNwYXJzZV9lYXJseV9tZW1fbWFwX2FsbG9jLCBzbyBhbGxvY2F0ZSB1c2VtYXBfbWFwIGF0IGZpcnN0LgpkaWZmIC0tZ2l0IGEvbW0vdXRpbC5jIGIvbW0vdXRpbC5jCmluZGV4IGYxMjY5NzUuLmU3YjEwM2EgMTAwNjQ0Ci0tLSBhL21tL3V0aWwuYworKysgYi9tbS91dGlsLmMKQEAgLTIyNyw3ICsyMjcsNyBAQAogLyoKICAqIExpa2UgZ2V0X3VzZXJfcGFnZXNfZmFzdCgpIGV4Y2VwdCBpdHMgSVJRLXNhZmUgaW4gdGhhdCBpdCB3b24ndCBmYWxsCiAgKiBiYWNrIHRvIHRoZSByZWd1bGFyIEdVUC4KLSAqIElmIHRoZSBhcmNoaXRlY3R1cmUgbm90IHN1cHBvcnQgdGhpcyBmdWNudGlvbiwgc2ltcGx5IHJldHVybiB3aXRoIG5vCisgKiBJZiB0aGUgYXJjaGl0ZWN0dXJlIG5vdCBzdXBwb3J0IHRoaXMgZnVuY3Rpb24sIHNpbXBseSByZXR1cm4gd2l0aCBubwogICogcGFnZSBwaW5uZWQKICAqLwogaW50IF9fYXR0cmlidXRlX18oKHdlYWspKSBfX2dldF91c2VyX3BhZ2VzX2Zhc3QodW5zaWduZWQgbG9uZyBzdGFydCwKZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0vdm1zY2FuLmMKaW5kZXggZjczYjg2NS4uYzdmNWE2ZCAxMDA2NDQKLS0tIGEvbW0vdm1zY2FuLmMKKysrIGIvbW0vdm1zY2FuLmMKQEAgLTEwNjUsNyArMTA2NSw3IEBACiAJCSAqIHN1cnJvdW5kaW5nIHRoZSB0YWcgcGFnZS4gIE9ubHkgdGFrZSB0aG9zZSBwYWdlcyBvZgogCQkgKiB0aGUgc2FtZSBhY3RpdmUgc3RhdGUgYXMgdGhhdCB0YWcgcGFnZS4gIFdlIG1heSBzYWZlbHkKIAkJICogcm91bmQgdGhlIHRhcmdldCBwYWdlIHBmbiBkb3duIHRvIHRoZSByZXF1ZXN0ZWQgb3JkZXIKLQkJICogYXMgdGhlIG1lbV9tYXAgaXMgZ3VhcmVudGVlZCB2YWxpZCBvdXQgdG8gTUFYX09SREVSLAorCQkgKiBhcyB0aGUgbWVtX21hcCBpcyBndWFyYW50ZWVkIHZhbGlkIG91dCB0byBNQVhfT1JERVIsCiAJCSAqIHdoZXJlIHRoYXQgcGFnZSBpcyBpbiBhIGRpZmZlcmVudCB6b25lIHdlIHdpbGwgZGV0ZWN0CiAJCSAqIGl0IGZyb20gaXRzIHpvbmUgaWQgYW5kIGFib3J0IHRoaXMgYmxvY2sgc2Nhbi4KIAkJICovCkBAIC0yMjI0LDcgKzIyMjQsNyBAQAogICogICBvIGEgMTZNIERNQSB6b25lIHRoYXQgaXMgYmFsYW5jZWQgd2lsbCBub3QgYmFsYW5jZSBhIHpvbmUgb24gYW55CiAgKiAgICAgcmVhc29uYWJsZSBzaXplZCBtYWNoaW5lCiAgKiAgIG8gT24gYWxsIG90aGVyIG1hY2hpbmVzLCB0aGUgdG9wIHpvbmUgbXVzdCBiZSBhdCBsZWFzdCBhIHJlYXNvbmFibGUKLSAqICAgICBwcmVjZW50YWdlIG9mIHRoZSBtaWRkbGUgem9uZXMuIEZvciBleGFtcGxlLCBvbiAzMi1iaXQgeDg2LCBoaWdobWVtCisgKiAgICAgcGVyY2VudGFnZSBvZiB0aGUgbWlkZGxlIHpvbmVzLiBGb3IgZXhhbXBsZSwgb24gMzItYml0IHg4NiwgaGlnaG1lbQogICogICAgIHdvdWxkIG5lZWQgdG8gYmUgYXQgbGVhc3QgMjU2TSBmb3IgaXQgdG8gYmUgYmFsYW5jZSBhIHdob2xlIG5vZGUuCiAgKiAgICAgU2ltaWxhcmx5LCBvbiB4ODYtNjQgdGhlIE5vcm1hbCB6b25lIHdvdWxkIG5lZWQgdG8gYmUgYXQgbGVhc3QgMUcKICAqICAgICB0byBiYWxhbmNlIGEgbm9kZSBvbiBpdHMgb3duLiBUaGVzZSBzZWVtZWQgbGlrZSByZWFzb25hYmxlIHJhdGlvcy4KZGlmZiAtLWdpdCBhL25ldC84MDIxcS92bGFucHJvYy5jIGIvbmV0LzgwMjFxL3ZsYW5wcm9jLmMKaW5kZXggZDEzMTRjZi4uZDk0MGM0OSAxMDA2NDQKLS0tIGEvbmV0LzgwMjFxL3ZsYW5wcm9jLmMKKysrIGIvbmV0LzgwMjFxL3ZsYW5wcm9jLmMKQEAgLTU0LDcgKzU0LDcgQEAKIAogLyoKICAqCVN0cnVjdHVyZXMgZm9yIGludGVyZmFjaW5nIHdpdGggdGhlIC9wcm9jIGZpbGVzeXN0ZW0uCi0gKglWTEFOIGNyZWF0ZXMgaXRzIG93biBkaXJlY3RvcnkgL3Byb2MvbmV0L3ZsYW4gd2l0aCB0aGUgZm9sb3dpbmcKKyAqCVZMQU4gY3JlYXRlcyBpdHMgb3duIGRpcmVjdG9yeSAvcHJvYy9uZXQvdmxhbiB3aXRoIHRoZSBmb2xsb3dpbmcKICAqCWVudHJpZXM6CiAgKgljb25maWcJCWRldmljZSBzdGF0dXMvY29uZmlndXJhdGlvbgogICoJPGRldmljZT4JZW50cnkgZm9yIGVhY2ggIGRldmljZQpkaWZmIC0tZ2l0IGEvbmV0LzlwL2NsaWVudC5jIGIvbmV0LzlwL2NsaWVudC5jCmluZGV4IDJjY2JmMDQuLjQ4YjhlMDggMTAwNjQ0Ci0tLSBhL25ldC85cC9jbGllbnQuYworKysgYi9uZXQvOXAvY2xpZW50LmMKQEAgLTE3OCw3ICsxNzgsNyBAQAogICogQHRhZzogbnVtZXJpYyBpZCBmb3IgdHJhbnNhY3Rpb24KICAqCiAgKiB0aGlzIGlzIGEgc2ltcGxlIGFycmF5IGxvb2t1cCwgYnV0IHdpbGwgZ3JvdyB0aGUKLSAqIHJlcXVlc3Rfc2xvdHMgYXMgbmVjZXNzYXJ5IHRvIGFjY29tb2RhdGUgdHJhbnNhY3Rpb24KKyAqIHJlcXVlc3Rfc2xvdHMgYXMgbmVjZXNzYXJ5IHRvIGFjY29tbW9kYXRlIHRyYW5zYWN0aW9uCiAgKiBpZHMgd2hpY2ggZGlkIG5vdCBwcmV2aW91c2x5IGhhdmUgYSBzbG90LgogICoKICAqIHRoaXMgY29kZSByZWxpZXMgb24gdGhlIGNsaWVudCBzcGlubG9jayB0byBtYW5hZ2UgbG9ja3MsIGl0cwpkaWZmIC0tZ2l0IGEvbmV0LzlwL3RyYW5zX2NvbW1vbi5jIGIvbmV0LzlwL3RyYW5zX2NvbW1vbi5jCmluZGV4IDkxNzJhYjcuLmQ0Nzg4MGUgMTAwNjQ0Ci0tLSBhL25ldC85cC90cmFuc19jb21tb24uYworKysgYi9uZXQvOXAvdHJhbnNfY29tbW9uLmMKQEAgLTM2LDcgKzM2LDcgQEAKIEVYUE9SVF9TWU1CT0wocDlfcmVsZWFzZV9yZXFfcGFnZXMpOwogCiAvKioKLSAqIHA5X25yX3BhZ2VzIC0gUmV0dXJuIG51bWJlciBvZiBwYWdlcyBuZWVkZWQgdG8gYWNjb21vZGF0ZSB0aGUgcGF5bG9hZC4KKyAqIHA5X25yX3BhZ2VzIC0gUmV0dXJuIG51bWJlciBvZiBwYWdlcyBuZWVkZWQgdG8gYWNjb21tb2RhdGUgdGhlIHBheWxvYWQuCiAgKi8KIGludAogcDlfbnJfcGFnZXMoc3RydWN0IHA5X3JlcV90ICpyZXEpCkBAIC01NSw3ICs1NSw3IEBACiAgKiBAcmVxOiBSZXF1ZXN0IHRvIGJlIHNlbnQgdG8gc2VydmVyLgogICogQHBkYXRhX29mZjogZGF0YSBvZmZzZXQgaW50byB0aGUgZmlyc3QgcGFnZSBhZnRlciB0cmFuc2xhdGlvbiAoZ3VwKS4KICAqIEBwZGF0YV9sZW46IFRvdGFsIGxlbmd0aCBvZiB0aGUgSU8uIGd1cCBtYXkgbm90IHJldHVybiByZXF1ZXN0ZWQgIyBvZiBwYWdlcy4KLSAqIEBucl9wYWdlczogbnVtYmVyIG9mIHBhZ2VzIHRvIGFjY29tb2RhdGUgdGhlIHBheWxvYWQKKyAqIEBucl9wYWdlczogbnVtYmVyIG9mIHBhZ2VzIHRvIGFjY29tbW9kYXRlIHRoZSBwYXlsb2FkCiAgKiBAcnc6IEluZGljYXRlcyBpZiB0aGUgcGFnZXMgYXJlIGZvciByZWFkIG9yIHdyaXRlLgogICovCiBpbnQKZGlmZiAtLWdpdCBhL25ldC85cC91dGlsLmMgYi9uZXQvOXAvdXRpbC5jCmluZGV4IGI4NDYxOWIuLmRhNmFmODEgMTAwNjQ0Ci0tLSBhL25ldC85cC91dGlsLmMKKysrIGIvbmV0LzlwL3V0aWwuYwpAQCAtNjcsNyArNjcsNyBAQAogCiAvKioKICAqIHA5X2lkcG9vbF9kZXN0cm95IC0gY3JlYXRlIGEgbmV3IHBlci1jb25uZWN0aW9uIGlkIHBvb2wKLSAqIEBwOiBpZHBvb2wgdG8gZGVzdG9yeQorICogQHA6IGlkcG9vbCB0byBkZXN0cm95CiAgKi8KIAogdm9pZCBwOV9pZHBvb2xfZGVzdHJveShzdHJ1Y3QgcDlfaWRwb29sICpwKQpkaWZmIC0tZ2l0IGEvbmV0L2F0bS9icjI2ODQuYyBiL25ldC9hdG0vYnIyNjg0LmMKaW5kZXggZmNlMmVhZS4uMjI1MmMyMCAxMDA2NDQKLS0tIGEvbmV0L2F0bS9icjI2ODQuYworKysgYi9uZXQvYXRtL2JyMjY4NC5jCkBAIC01MDksNyArNTA5LDcgQEAKIAl3cml0ZV9sb2NrX2lycSgmZGV2c19sb2NrKTsKIAluZXRfZGV2ID0gYnIyNjg0X2ZpbmRfZGV2KCZiZS5pZnNwZWMpOwogCWlmIChuZXRfZGV2ID09IE5VTEwpIHsKLQkJcHJfZXJyKCJ0cmllZCB0byBhdHRhY2ggdG8gbm9uLWV4aXN0YW50IGRldmljZVxuIik7CisJCXByX2VycigidHJpZWQgdG8gYXR0YWNoIHRvIG5vbi1leGlzdGVudCBkZXZpY2VcbiIpOwogCQllcnIgPSAtRU5YSU87CiAJCWdvdG8gZXJyb3I7CiAJfQpkaWZmIC0tZ2l0IGEvbmV0L2F0bS9sZWMuaCBiL25ldC9hdG0vbGVjLmgKaW5kZXggOWQxNGQxOS4uZGZjMDcxOSAxMDA2NDQKLS0tIGEvbmV0L2F0bS9sZWMuaAorKysgYi9uZXQvYXRtL2xlYy5oCkBAIC0zNSw3ICszNSw3IEBACiAgKiBPcGVyYXRpb25zIHRoYXQgTEFORTIgY2FwYWJsZSBkZXZpY2UgY2FuIGRvLiBUd28gZmlyc3QgZnVuY3Rpb25zCiAgKiBhcmUgdXNlZCB0byBtYWtlIHRoZSBkZXZpY2UgZG8gdGhpbmdzLiBTZWUgc3BlYyAzLjEuMyBhbmQgMy4xLjQuCiAgKgotICogVGhlIHRoaXJkIGZ1bmN0aW9uIGlzIGludGVudGVkIGZvciB0aGUgTVBPQSBjb21wb25lbnQgc2l0dGluZyBvbgorICogVGhlIHRoaXJkIGZ1bmN0aW9uIGlzIGludGVuZGVkIGZvciB0aGUgTVBPQSBjb21wb25lbnQgc2l0dGluZyBvbgogICogdG9wIG9mIHRoZSBMQU5FIGRldmljZS4gVGhlIE1QT0EgY29tcG9uZW50IGFzc2lnbnMgaXQncyBvd24gZnVuY3Rpb24KICAqIHRvICgqYXNzb2NpYXRlX2luZGljYXRvcikoKSBhbmQgdGhlIExBTkUgZGV2aWNlIHdpbGwgdXNlIHRoYXQKICAqIGZ1bmN0aW9uIHRvIHRlbGwgYWJvdXQgVExWcyBpdCBzZWVzIGZsb2F0aW5nIHRocm91Z2guCmRpZmYgLS1naXQgYS9uZXQvYmF0bWFuLWFkdi9zb2Z0LWludGVyZmFjZS5jIGIvbmV0L2JhdG1hbi1hZHYvc29mdC1pbnRlcmZhY2UuYwppbmRleCA5ZWQyNjE0Li44MjRlMWY2IDEwMDY0NAotLS0gYS9uZXQvYmF0bWFuLWFkdi9zb2Z0LWludGVyZmFjZS5jCisrKyBiL25ldC9iYXRtYW4tYWR2L3NvZnQtaW50ZXJmYWNlLmMKQEAgLTQ3NCw3ICs0NzQsNyBAQAogCQlnb3RvIGRyb3BwZWQ7CiAJc2tiLT5wcm90b2NvbCA9IGV0aF90eXBlX3RyYW5zKHNrYiwgc29mdF9pZmFjZSk7CiAKLQkvKiBzaG91bGQgbm90IGJlIG5lY2Nlc2FyeSBhbnltb3JlIGFzIHdlIHVzZSBza2JfcHVsbF9yY3N1bSgpCisJLyogc2hvdWxkIG5vdCBiZSBuZWNlc3NhcnkgYW55bW9yZSBhcyB3ZSB1c2Ugc2tiX3B1bGxfcmNzdW0oKQogCSAqIFRPRE86IHBsZWFzZSB2ZXJpZnkgdGhpcyBhbmQgcmVtb3ZlIHRoaXMgVE9ETwogCSAqIC0tIERlYyAyMXN0IDIwMDksIFNpbW9uIFd1bmRlcmxpY2ggKi8KIApkaWZmIC0tZ2l0IGEvbmV0L2JsdWV0b290aC9oY2lfY29yZS5jIGIvbmV0L2JsdWV0b290aC9oY2lfY29yZS5jCmluZGV4IDIyMTY2MjAuLmM4M2Y2MTggMTAwNjQ0Ci0tLSBhL25ldC9ibHVldG9vdGgvaGNpX2NvcmUuYworKysgYi9uZXQvYmx1ZXRvb3RoL2hjaV9jb3JlLmMKQEAgLTE4ODMsNyArMTg4Myw3IEBACiAJcmVhZF91bmxvY2soJmhjaV90YXNrX2xvY2spOwogfQogCi0vKiAtLS0tLSBIQ0kgUlggdGFzayAoaW5jb21pbmcgZGF0YSBwcm9jY2Vzc2luZykgLS0tLS0gKi8KKy8qIC0tLS0tIEhDSSBSWCB0YXNrIChpbmNvbWluZyBkYXRhIHByb2Nlc3NpbmcpIC0tLS0tICovCiAKIC8qIEFDTCBkYXRhIHBhY2tldCAqLwogc3RhdGljIGlubGluZSB2b2lkIGhjaV9hY2xkYXRhX3BhY2tldChzdHJ1Y3QgaGNpX2RldiAqaGRldiwgc3RydWN0IHNrX2J1ZmYgKnNrYikKZGlmZiAtLWdpdCBhL25ldC9ibHVldG9vdGgvbDJjYXBfc29jay5jIGIvbmV0L2JsdWV0b290aC9sMmNhcF9zb2NrLmMKaW5kZXggZjc3MzA4ZS4uMjk5ZmU1NiAxMDA2NDQKLS0tIGEvbmV0L2JsdWV0b290aC9sMmNhcF9zb2NrLmMKKysrIGIvbmV0L2JsdWV0b290aC9sMmNhcF9zb2NrLmMKQEAgLTY3OSw3ICs2NzksNyBAQAogCiAJCWlmIChvcHQgPT0gQlRfRkxVU0hBQkxFX09GRikgewogCQkJc3RydWN0IGwyY2FwX2Nvbm4gKmNvbm4gPSBsMmNhcF9waShzayktPmNvbm47Ci0JCQkvKiBwcm9jZWVkIGZ1dGhlciBvbmx5IHdoZW4gd2UgaGF2ZSBsMmNhcF9jb25uIGFuZAorCQkJLyogcHJvY2VlZCBmdXJ0aGVyIG9ubHkgd2hlbiB3ZSBoYXZlIGwyY2FwX2Nvbm4gYW5kCiAJCQkgICBObyBGbHVzaCBzdXBwb3J0IGluIHRoZSBMTSAqLwogCQkJaWYgKCFjb25uIHx8ICFsbXBfbm9fZmx1c2hfY2FwYWJsZShjb25uLT5oY29uLT5oZGV2KSkgewogCQkJCWVyciA9IC1FSU5WQUw7CmRpZmYgLS1naXQgYS9uZXQvYnJpZGdlL2JyX2ZkYi5jIGIvbmV0L2JyaWRnZS9icl9mZGIuYwppbmRleCA4ODQ4NWNjLi5jYzRkM2M1IDEwMDY0NAotLS0gYS9uZXQvYnJpZGdlL2JyX2ZkYi5jCisrKyBiL25ldC9icmlkZ2UvYnJfZmRiLmMKQEAgLTE2OSw3ICsxNjksNyBAQAogCXNwaW5fdW5sb2NrX2JoKCZici0+aGFzaF9sb2NrKTsKIH0KIAotLyogRmx1c2ggYWxsIGVudHJpZXMgcmVmZXJpbmcgdG8gYSBzcGVjaWZpYyBwb3J0LgorLyogRmx1c2ggYWxsIGVudHJpZXMgcmVmZXJyaW5nIHRvIGEgc3BlY2lmaWMgcG9ydC4KICAqIGlmIGRvX2FsbCBpcyBzZXQgYWxzbyBmbHVzaCBzdGF0aWMgZW50cmllcwogICovCiB2b2lkIGJyX2ZkYl9kZWxldGVfYnlfcG9ydChzdHJ1Y3QgbmV0X2JyaWRnZSAqYnIsCmRpZmYgLS1naXQgYS9uZXQvYnJpZGdlL2JyX2lvY3RsLmMgYi9uZXQvYnJpZGdlL2JyX2lvY3RsLmMKaW5kZXggY2I0MzMxMi4uM2Q5ZmNhMCAxMDA2NDQKLS0tIGEvbmV0L2JyaWRnZS9icl9pb2N0bC5jCisrKyBiL25ldC9icmlkZ2UvYnJfaW9jdGwuYwpAQCAtMTA2LDcgKzEwNiw3IEBACiAvKgogICogTGVnYWN5IGlvY3RsJ3MgdGhyb3VnaCBTSU9DREVWUFJJVkFURQogICogVGhpcyBpbnRlcmZhY2UgaXMgZGVwcmVjYXRlZCBiZWNhdXNlIGl0IHdhcyB0b28gZGlmZmljdWx0IHRvCi0gKiB0byBkbyB0aGUgdHJhbnNsYXRpb24gZm9yIDMyLzY0Yml0IGlvY3RsIGNvbXBhdGFiaWxpdHkuCisgKiB0byBkbyB0aGUgdHJhbnNsYXRpb24gZm9yIDMyLzY0Yml0IGlvY3RsIGNvbXBhdGliaWxpdHkuCiAgKi8KIHN0YXRpYyBpbnQgb2xkX2Rldl9pb2N0bChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKnJxLCBpbnQgY21kKQogewpkaWZmIC0tZ2l0IGEvbmV0L2NhaWYvY2FpZl9zb2NrZXQuYyBiL25ldC9jYWlmL2NhaWZfc29ja2V0LmMKaW5kZXggODE4NGMwMy4uMzdhNDAzNCAxMDA2NDQKLS0tIGEvbmV0L2NhaWYvY2FpZl9zb2NrZXQuYworKysgYi9uZXQvY2FpZi9jYWlmX3NvY2tldC5jCkBAIC04NTIsNyArODUyLDcgQEAKIAlzb2NrLT5zdGF0ZSA9IFNTX0NPTk5FQ1RJTkc7CiAJc2stPnNrX3N0YXRlID0gQ0FJRl9DT05ORUNUSU5HOwogCi0JLyogQ2hlY2sgcHJpb3JpdHkgdmFsdWUgY29tbWluZyBmcm9tIHNvY2tldCAqLworCS8qIENoZWNrIHByaW9yaXR5IHZhbHVlIGNvbWluZyBmcm9tIHNvY2tldCAqLwogCS8qIGlmIHByaW9yaXR5IHZhbHVlIGlzIG91dCBvZiByYW5nZSBpdCB3aWxsIGJlIGFqdXN0ZWQgKi8KIAlpZiAoY2Zfc2stPnNrLnNrX3ByaW9yaXR5ID4gQ0FJRl9QUklPX01BWCkKIAkJY2Zfc2stPmNvbm5fcmVxLnByaW9yaXR5ID0gQ0FJRl9QUklPX01BWDsKZGlmZiAtLWdpdCBhL25ldC9jYW4vYmNtLmMgYi9uZXQvY2FuL2JjbS5jCmluZGV4IDg3MWEwYWQuLjU3YjFhZWQgMTAwNjQ0Ci0tLSBhL25ldC9jYW4vYmNtLmMKKysrIGIvbmV0L2Nhbi9iY20uYwpAQCAtMzg3LDcgKzM4Nyw3IEBACiB9CiAKIC8qCi0gKiBiY21fdHhfdGltZW91dF9oYW5kbGVyIC0gcGVyZm9ybWVzIGN5Y2xpYyBDQU4gZnJhbWUgdHJhbnNtaXNzaW9ucworICogYmNtX3R4X3RpbWVvdXRfaGFuZGxlciAtIHBlcmZvcm1zIGN5Y2xpYyBDQU4gZnJhbWUgdHJhbnNtaXNzaW9ucwogICovCiBzdGF0aWMgZW51bSBocnRpbWVyX3Jlc3RhcnQgYmNtX3R4X3RpbWVvdXRfaGFuZGxlcihzdHJ1Y3QgaHJ0aW1lciAqaHJ0aW1lcikKIHsKZGlmZiAtLWdpdCBhL25ldC9jZXBoL29zZF9jbGllbnQuYyBiL25ldC9jZXBoL29zZF9jbGllbnQuYwppbmRleCAzYjkxZDY1Li41MGFmMDI3IDEwMDY0NAotLS0gYS9uZXQvY2VwaC9vc2RfY2xpZW50LmMKKysrIGIvbmV0L2NlcGgvb3NkX2NsaWVudC5jCkBAIC05MTcsNyArOTE3LDcgQEAKIC8qCiAgKiBQaWNrIGFuIG9zZCAodGhlIGZpcnN0ICd1cCcgb3NkIGluIHRoZSBwZyksIGFsbG9jYXRlIHRoZSBvc2Qgc3RydWN0CiAgKiAoYXMgbmVlZGVkKSwgYW5kIHNldCB0aGUgcmVxdWVzdCByX29zZCBhcHByb3ByaWF0ZWx5LiAgSWYgdGhlcmUgaXMKLSAqIG5vIHVwIG9zZCwgc2V0IHJfb3NkIHRvIE5VTEwuICBNb3ZlIHRoZSByZXF1ZXN0IHRvIHRoZSBhcHByb3BpYXRlIGxpc3QKKyAqIG5vIHVwIG9zZCwgc2V0IHJfb3NkIHRvIE5VTEwuICBNb3ZlIHRoZSByZXF1ZXN0IHRvIHRoZSBhcHByb3ByaWF0ZSBsaXN0CiAgKiAodW5zZW50LCBob21lbGVzcykgb3IgbGVhdmUgb24gaW4tZmxpZ2h0IGxydS4KICAqCiAgKiBSZXR1cm4gMCBpZiB1bmNoYW5nZWQsIDEgaWYgY2hhbmdlZCwgb3IgbmVnYXRpdmUgb24gZXJyb3IuCmRpZmYgLS1naXQgYS9uZXQvY29yZS9kZXYuYyBiL25ldC9jb3JlL2Rldi5jCmluZGV4IDNkYTlmYjAuLjk1NmQzYjAgMTAwNjQ0Ci0tLSBhL25ldC9jb3JlL2Rldi5jCisrKyBiL25ldC9jb3JlL2Rldi5jCkBAIC0yMDkxLDcgKzIwOTEsNyBAQAogCQl1MzIgZmVhdHVyZXM7CiAKIAkJLyoKLQkJICogSWYgZGV2aWNlIGRvZXNudCBuZWVkIHNrYi0+ZHN0LCByZWxlYXNlIGl0IHJpZ2h0IG5vdyB3aGlsZQorCQkgKiBJZiBkZXZpY2UgZG9lc24ndCBuZWVkIHNrYi0+ZHN0LCByZWxlYXNlIGl0IHJpZ2h0IG5vdyB3aGlsZQogCQkgKiBpdHMgaG90IGluIHRoaXMgY3B1IGNhY2hlCiAJCSAqLwogCQlpZiAoZGV2LT5wcml2X2ZsYWdzICYgSUZGX1hNSVRfRFNUX1JFTEVBU0UpCkBAIC0yMTUxLDcgKzIxNTEsNyBAQAogCQluc2tiLT5uZXh0ID0gTlVMTDsKIAogCQkvKgotCQkgKiBJZiBkZXZpY2UgZG9lc250IG5lZWQgbnNrYi0+ZHN0LCByZWxlYXNlIGl0IHJpZ2h0IG5vdyB3aGlsZQorCQkgKiBJZiBkZXZpY2UgZG9lc24ndCBuZWVkIG5za2ItPmRzdCwgcmVsZWFzZSBpdCByaWdodCBub3cgd2hpbGUKIAkJICogaXRzIGhvdCBpbiB0aGlzIGNwdSBjYWNoZQogCQkgKi8KIAkJaWYgKGRldi0+cHJpdl9mbGFncyAmIElGRl9YTUlUX0RTVF9SRUxFQVNFKQpAQCAtMjk3MCw4ICsyOTcwLDggQEAKICAqIHdoZW4gQ09ORklHX05FVF9DTFNfQUNUIGlzPyBvdGhlcndpc2Ugc29tZSB1c2VsZXNzIGluc3RydWN0aW9ucwogICogYSBjb21wYXJlIGFuZCAyIHN0b3JlcyBleHRyYSByaWdodCBub3cgaWYgd2UgZG9udCBoYXZlIGl0IG9uCiAgKiBidXQgaGF2ZSBDT05GSUdfTkVUX0NMU19BQ1QKLSAqIE5PVEU6IFRoaXMgZG9lc250IHN0b3AgYW55IGZ1bmN0aW9uYWxpdHk7IGlmIHlvdSBkb250IGhhdmUKLSAqIHRoZSBpbmdyZXNzIHNjaGVkdWxlciwgeW91IGp1c3QgY2FudCBhZGQgcG9saWNpZXMgb24gaW5ncmVzcy4KKyAqIE5PVEU6IFRoaXMgZG9lc24ndCBzdG9wIGFueSBmdW5jdGlvbmFsaXR5OyBpZiB5b3UgZG9udCBoYXZlCisgKiB0aGUgaW5ncmVzcyBzY2hlZHVsZXIsIHlvdSBqdXN0IGNhbid0IGFkZCBwb2xpY2llcyBvbiBpbmdyZXNzLgogICoKICAqLwogc3RhdGljIGludCBpbmdfZmlsdGVyKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRkZXZfcXVldWUgKnJ4cSkKQEAgLTM4MDAsNyArMzgwMCw3IEBACiAJCSAqIHdpdGggbmV0cG9sbCdzIHBvbGxfbmFwaSgpLiAgT25seSB0aGUgZW50aXR5IHdoaWNoCiAJCSAqIG9idGFpbnMgdGhlIGxvY2sgYW5kIHNlZXMgTkFQSV9TVEFURV9TQ0hFRCBzZXQgd2lsbAogCQkgKiBhY3R1YWxseSBtYWtlIHRoZSAtPnBvbGwoKSBjYWxsLiAgVGhlcmVmb3JlIHdlIGF2b2lkCi0JCSAqIGFjY2lkZW50bHkgY2FsbGluZyAtPnBvbGwoKSB3aGVuIE5BUEkgaXMgbm90IHNjaGVkdWxlZC4KKwkJICogYWNjaWRlbnRhbGx5IGNhbGxpbmcgLT5wb2xsKCkgd2hlbiBOQVBJIGlzIG5vdCBzY2hlZHVsZWQuCiAJCSAqLwogCQl3b3JrID0gMDsKIAkJaWYgKHRlc3RfYml0KE5BUElfU1RBVEVfU0NIRUQsICZuLT5zdGF0ZSkpIHsKQEAgLTYzMzYsNyArNjMzNiw3IEBACiAJCWlmIChkZXYtPnJ0bmxfbGlua19vcHMpCiAJCQljb250aW51ZTsKIAotCQkvKiBQdXNoIHJlbWFpbmcgbmV0d29yayBkZXZpY2VzIHRvIGluaXRfbmV0ICovCisJCS8qIFB1c2ggcmVtYWluaW5nIG5ldHdvcmsgZGV2aWNlcyB0byBpbml0X25ldCAqLwogCQlzbnByaW50ZihmYl9uYW1lLCBJRk5BTVNJWiwgImRldiVkIiwgZGV2LT5pZmluZGV4KTsKIAkJZXJyID0gZGV2X2NoYW5nZV9uZXRfbmFtZXNwYWNlKGRldiwgJmluaXRfbmV0LCBmYl9uYW1lKTsKIAkJaWYgKGVycikgewpkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvZmlsdGVyLmMgYi9uZXQvY29yZS9maWx0ZXIuYwppbmRleCAyMzJiMTg3Li5hZmI4YWZiIDEwMDY0NAotLS0gYS9uZXQvY29yZS9maWx0ZXIuYworKysgYi9uZXQvY29yZS9maWx0ZXIuYwpAQCAtNDI1LDcgKzQyNSw3IEBACiAgKiBBcyB3ZSBkb250IHdhbnQgdG8gY2xlYXIgbWVtW10gYXJyYXkgZm9yIGVhY2ggcGFja2V0IGdvaW5nIHRocm91Z2gKICAqIHNrX3J1bl9maWx0ZXIoKSwgd2UgY2hlY2sgdGhhdCBmaWx0ZXIgbG9hZGVkIGJ5IHVzZXIgbmV2ZXIgdHJ5IHRvIHJlYWQKICAqIGEgY2VsbCBpZiBub3QgcHJldmlvdXNseSB3cml0dGVuLCBhbmQgd2UgY2hlY2sgYWxsIGJyYW5jaGVzIHRvIGJlIHN1cmUKLSAqIGEgbWFsaWNpb3VzIHVzZXIgZG9lc250IHRyeSB0byBhYnVzZSB1cy4KKyAqIGEgbWFsaWNpb3VzIHVzZXIgZG9lc24ndCB0cnkgdG8gYWJ1c2UgdXMuCiAgKi8KIHN0YXRpYyBpbnQgY2hlY2tfbG9hZF9hbmRfc3RvcmVzKHN0cnVjdCBzb2NrX2ZpbHRlciAqZmlsdGVyLCBpbnQgZmxlbikKIHsKZGlmZiAtLWdpdCBhL25ldC9jb3JlL2xpbmtfd2F0Y2guYyBiL25ldC9jb3JlL2xpbmtfd2F0Y2guYwppbmRleCAwMWExMTAxLi5hN2IzNDIxIDEwMDY0NAotLS0gYS9uZXQvY29yZS9saW5rX3dhdGNoLmMKKysrIGIvbmV0L2NvcmUvbGlua193YXRjaC5jCkBAIC0xMjksNyArMTI5LDcgQEAKIAlpZiAoIWNhbmNlbF9kZWxheWVkX3dvcmsoJmxpbmt3YXRjaF93b3JrKSkKIAkJcmV0dXJuOwogCi0JLyogT3RoZXJ3aXNlIHdlIHJlc2NoZWR1bGUgaXQgYWdhaW4gZm9yIGltbWVkaWF0ZSBleGVjdGlvbi4gKi8KKwkvKiBPdGhlcndpc2Ugd2UgcmVzY2hlZHVsZSBpdCBhZ2FpbiBmb3IgaW1tZWRpYXRlIGV4ZWN1dGlvbi4gKi8KIAlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmxpbmt3YXRjaF93b3JrLCAwKTsKIH0KIApkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvcnRuZXRsaW5rLmMgYi9uZXQvY29yZS9ydG5ldGxpbmsuYwppbmRleCA0OWY3ZWE1Li5kN2M0YmI0IDEwMDY0NAotLS0gYS9uZXQvY29yZS9ydG5ldGxpbmsuYworKysgYi9uZXQvY29yZS9ydG5ldGxpbmsuYwpAQCAtMTk2LDcgKzE5Niw3IEBACiAgKiBhcyBmYWlsdXJlIG9mIHRoaXMgZnVuY3Rpb24gaXMgdmVyeSB1bmxpa2VseSwgaXQgY2FuIG9ubHkgaGFwcGVuIGR1ZQogICogdG8gbGFjayBvZiBtZW1vcnkgd2hlbiBhbGxvY2F0aW5nIHRoZSBjaGFpbiB0byBzdG9yZSBhbGwgbWVzc2FnZQogICogaGFuZGxlcnMgZm9yIGEgcHJvdG9jb2wuIE1lYW50IGZvciB1c2UgaW4gaW5pdCBmdW5jdGlvbnMgd2hlcmUgbGFjawotICogb2YgbWVtb3J5IGltcGxpZXMgbm8gc2Vuc2UgaW4gY29udGludWVpbmcuCisgKiBvZiBtZW1vcnkgaW1wbGllcyBubyBzZW5zZSBpbiBjb250aW51aW5nLgogICovCiB2b2lkIHJ0bmxfcmVnaXN0ZXIoaW50IHByb3RvY29sLCBpbnQgbXNndHlwZSwKIAkJICAgcnRubF9kb2l0X2Z1bmMgZG9pdCwgcnRubF9kdW1waXRfZnVuYyBkdW1waXQpCkBAIC0xNDQwLDcgKzE0NDAsNyBAQAogZXJyb3V0OgogCWlmIChlcnIgPCAwICYmIG1vZGlmaWVkICYmIG5ldF9yYXRlbGltaXQoKSkKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiQSBsaW5rIGNoYW5nZSByZXF1ZXN0IGZhaWxlZCB3aXRoICIKLQkJICAgICAgICJzb21lIGNoYW5nZXMgY29taXR0ZWQgYWxyZWFkeS4gSW50ZXJmYWNlICVzIG1heSAiCisJCSAgICAgICAic29tZSBjaGFuZ2VzIGNvbW1pdHRlZCBhbHJlYWR5LiBJbnRlcmZhY2UgJXMgbWF5ICIKIAkJICAgICAgICJoYXZlIGJlZW4gbGVmdCB3aXRoIGFuIGluY29uc2lzdGVudCBjb25maWd1cmF0aW9uLCAiCiAJCSAgICAgICAicGxlYXNlIGNoZWNrLlxuIiwgZGV2LT5uYW1lKTsKIApkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvc2tidWZmLmMgYi9uZXQvY29yZS9za2J1ZmYuYwppbmRleCA4MDFkZDA4Li43ZWJlZWQwIDEwMDY0NAotLS0gYS9uZXQvY29yZS9za2J1ZmYuYworKysgYi9uZXQvY29yZS9za2J1ZmYuYwpAQCAtMjI2Nyw3ICsyMjY3LDcgQEAKICAqIG9mIGJ5dGVzIGFscmVhZHkgY29uc3VtZWQgYW5kIHRoZSBuZXh0IGNhbGwgdG8KICAqIHNrYl9zZXFfcmVhZCgpIHdpbGwgcmV0dXJuIHRoZSByZW1haW5pbmcgcGFydCBvZiB0aGUgYmxvY2suCiAgKgotICogTm90ZSAxOiBUaGUgc2l6ZSBvZiBlYWNoIGJsb2NrIG9mIGRhdGEgcmV0dXJuZWQgY2FuIGJlIGFyYml0YXJ5LAorICogTm90ZSAxOiBUaGUgc2l6ZSBvZiBlYWNoIGJsb2NrIG9mIGRhdGEgcmV0dXJuZWQgY2FuIGJlIGFyYml0cmFyeSwKICAqICAgICAgIHRoaXMgbGltaXRhdGlvbiBpcyB0aGUgY29zdCBmb3IgemVyb2NvcHkgc2VxZXVlbnRhbAogICogICAgICAgcmVhZHMgb2YgcG90ZW50aWFsbHkgbm9uIGxpbmVhciBkYXRhLgogICoKZGlmZiAtLWdpdCBhL25ldC9jb3JlL3NvY2suYyBiL25ldC9jb3JlL3NvY2suYwppbmRleCA3ZGZlZDc5Li42ZTgxOTc4IDEwMDY0NAotLS0gYS9uZXQvY29yZS9zb2NrLmMKKysrIGIvbmV0L2NvcmUvc29jay5jCkBAIC0yMTUsNyArMjE1LDcgQEAKIF9fdTMyIHN5c2N0bF93bWVtX2RlZmF1bHQgX19yZWFkX21vc3RseSA9IFNLX1dNRU1fTUFYOwogX191MzIgc3lzY3RsX3JtZW1fZGVmYXVsdCBfX3JlYWRfbW9zdGx5ID0gU0tfUk1FTV9NQVg7CiAKLS8qIE1heGltYWwgc3BhY2UgZWF0ZW4gYnkgaW92ZWMgb3IgYW5jaWxsaWFyeSBkYXRhIHBsdXMgc29tZSBzcGFjZSAqLworLyogTWF4aW1hbCBzcGFjZSBlYXRlbiBieSBpb3ZlYyBvciBhbmNpbGxhcnkgZGF0YSBwbHVzIHNvbWUgc3BhY2UgKi8KIGludCBzeXNjdGxfb3B0bWVtX21heCBfX3JlYWRfbW9zdGx5ID0gc2l6ZW9mKHVuc2lnbmVkIGxvbmcpKigyKlVJT19NQVhJT1YrNTEyKTsKIEVYUE9SVF9TWU1CT0woc3lzY3RsX29wdG1lbV9tYXgpOwogCkBAIC0xMTc1LDcgKzExNzUsNyBAQAogdm9pZCBza19mcmVlKHN0cnVjdCBzb2NrICpzaykKIHsKIAkvKgotCSAqIFdlIHN1YnN0cmFjdCBvbmUgZnJvbSBza193bWVtX2FsbG9jIGFuZCBjYW4ga25vdyBpZgorCSAqIFdlIHN1YnRyYWN0IG9uZSBmcm9tIHNrX3dtZW1fYWxsb2MgYW5kIGNhbiBrbm93IGlmCiAJICogc29tZSBwYWNrZXRzIGFyZSBzdGlsbCBpbiBzb21lIHR4IHF1ZXVlLgogCSAqIElmIG5vdCBudWxsLCBzb2NrX3dmcmVlKCkgd2lsbCBjYWxsIF9fc2tfZnJlZShzaykgbGF0ZXIKIAkgKi8KQEAgLTExODUsMTAgKzExODUsMTAgQEAKIEVYUE9SVF9TWU1CT0woc2tfZnJlZSk7CiAKIC8qCi0gKiBMYXN0IHNvY2tfcHV0IHNob3VsZCBkcm9wIHJlZmVycmVuY2UgdG8gc2stPnNrX25ldC4gSXQgaGFzIGFscmVhZHkKLSAqIGJlZW4gZHJvcHBlZCBpbiBza19jaGFuZ2VfbmV0LiBUYWtpbmcgcmVmZXJyZW5jZSB0byBzdG9wcGluZyBuYW1lc3BhY2UKKyAqIExhc3Qgc29ja19wdXQgc2hvdWxkIGRyb3AgcmVmZXJlbmNlIHRvIHNrLT5za19uZXQuIEl0IGhhcyBhbHJlYWR5CisgKiBiZWVuIGRyb3BwZWQgaW4gc2tfY2hhbmdlX25ldC4gVGFraW5nIHJlZmVyZW5jZSB0byBzdG9wcGluZyBuYW1lc3BhY2UKICAqIGlzIG5vdCBhbiBvcHRpb24uCi0gKiBUYWtlIHJlZmVycmVuY2UgdG8gYSBzb2NrZXQgdG8gcmVtb3ZlIGl0IGZyb20gaGFzaCBfYWxpdmVfIGFuZCBhZnRlciB0aGF0CisgKiBUYWtlIHJlZmVyZW5jZSB0byBhIHNvY2tldCB0byByZW1vdmUgaXQgZnJvbSBoYXNoIF9hbGl2ZV8gYW5kIGFmdGVyIHRoYXQKICAqIGRlc3Ryb3kgaXQgaW4gdGhlIGNvbnRleHQgb2YgaW5pdF9uZXQuCiAgKi8KIHZvaWQgc2tfcmVsZWFzZV9rZXJuZWwoc3RydWN0IHNvY2sgKnNrKQpkaWZmIC0tZ2l0IGEvbmV0L2RjY3Avb3V0cHV0LmMgYi9uZXQvZGNjcC9vdXRwdXQuYwppbmRleCA3ODRkMzAyMS4uMTM2ZDQxYyAxMDA2NDQKLS0tIGEvbmV0L2RjY3Avb3V0cHV0LmMKKysrIGIvbmV0L2RjY3Avb3V0cHV0LmMKQEAgLTE0Myw3ICsxNDMsNyBAQAogfQogCiAvKioKLSAqIGRjY3BfZGV0ZXJtaW5lX2NjbXBzICAtICBGaW5kIG91dCBhYm91dCBDQ0lELXNwZWNmaWMgcGFja2V0LXNpemUgbGltaXRzCisgKiBkY2NwX2RldGVybWluZV9jY21wcyAgLSAgRmluZCBvdXQgYWJvdXQgQ0NJRC1zcGVjaWZpYyBwYWNrZXQtc2l6ZSBsaW1pdHMKICAqIFdlIG9ubHkgY29uc2lkZXIgdGhlIEhDLXNlbmRlciBDQ0lEIGZvciBzZXR0aW5nIHRoZSBDQ01QUyAoUkZDIDQzNDAsIDE0LiksCiAgKiBzaW5jZSB0aGUgUlggQ0NJRCBpcyByZXN0cmljdGVkIHRvIGZlZWRiYWNrIHBhY2tldHMgKEFja3MpLCB3aGljaCBhcmUgc21hbGwKICAqIGluIGNvbXBhcmlzb24gd2l0aCB0aGUgZGF0YSB0cmFmZmljLiBBIHZhbHVlIG9mIDAgbWVhbnMgIm5vIGN1cnJlbnQgQ0NNUFMiLgpkaWZmIC0tZ2l0IGEvbmV0L2RzYS9tdjg4ZTYxMzEuYyBiL25ldC9kc2EvbXY4OGU2MTMxLmMKaW5kZXggYmIyYjQxYi4uM2RhNDE4OCAxMDA2NDQKLS0tIGEvbmV0L2RzYS9tdjg4ZTYxMzEuYworKysgYi9uZXQvZHNhL212ODhlNjEzMS5jCkBAIC0xNCw2ICsxNCwxMyBAQAogI2luY2x1ZGUgImRzYV9wcml2LmgiCiAjaW5jbHVkZSAibXY4OGU2eHh4LmgiCiAKKy8qCisgKiBTd2l0Y2ggcHJvZHVjdCBJRHMKKyAqLworI2RlZmluZSBJRF82MDg1CQkweDA0YTAKKyNkZWZpbmUgSURfNjA5NQkJMHgwOTUwCisjZGVmaW5lIElEXzYxMzEJCTB4MTA2MAorCiBzdGF0aWMgY2hhciAqbXY4OGU2MTMxX3Byb2JlKHN0cnVjdCBtaWlfYnVzICpidXMsIGludCBzd19hZGRyKQogewogCWludCByZXQ7CkBAIC0yMSw5ICsyOCwxMSBAQAogCXJldCA9IF9fbXY4OGU2eHh4X3JlZ19yZWFkKGJ1cywgc3dfYWRkciwgUkVHX1BPUlQoMCksIDB4MDMpOwogCWlmIChyZXQgPj0gMCkgewogCQlyZXQgJj0gMHhmZmYwOwotCQlpZiAocmV0ID09IDB4MDk1MCkKKwkJaWYgKHJldCA9PSBJRF82MDg1KQorCQkJcmV0dXJuICJNYXJ2ZWxsIDg4RTYwODUiOworCQlpZiAocmV0ID09IElEXzYwOTUpCiAJCQlyZXR1cm4gIk1hcnZlbGwgODhFNjA5NS84OEU2MDk1RiI7Ci0JCWlmIChyZXQgPT0gMHgxMDYwKQorCQlpZiAocmV0ID09IElEXzYxMzEpCiAJCQlyZXR1cm4gIk1hcnZlbGwgODhFNjEzMSI7CiAJfQogCkBAIC0xMjQsNyArMTMzLDcgQEAKIAkgKiBJZ25vcmUgcmVtb3ZlZCB0YWcgZGF0YSBvbiBkb3VibHkgdGFnZ2VkIHBhY2tldHMsIGRpc2FibGUKIAkgKiBmbG93IGNvbnRyb2wgbWVzc2FnZXMsIGZvcmNlIGZsb3cgY29udHJvbCBwcmlvcml0eSB0byB0aGUKIAkgKiBoaWdoZXN0LCBhbmQgc2VuZCBhbGwgc3BlY2lhbCBtdWx0aWNhc3QgZnJhbWVzIHRvIHRoZSBDUFUKLQkgKiBwb3J0IGF0IHRoZSBoaWdlc3QgcHJpb3JpdHkuCisJICogcG9ydCBhdCB0aGUgaGlnaGVzdCBwcmlvcml0eS4KIAkgKi8KIAlSRUdfV1JJVEUoUkVHX0dMT0JBTDIsIDB4MDUsIDB4MDBmZik7CiAKQEAgLTE2NCw2ICsxNzMsNyBAQAogCiBzdGF0aWMgaW50IG12ODhlNjEzMV9zZXR1cF9wb3J0KHN0cnVjdCBkc2Ffc3dpdGNoICpkcywgaW50IHApCiB7CisJc3RydWN0IG12ODhlNnh4eF9wcml2X3N0YXRlICpwcyA9ICh2b2lkICopKGRzICsgMSk7CiAJaW50IGFkZHIgPSBSRUdfUE9SVChwKTsKIAl1MTYgdmFsOwogCkBAIC0xNzEsMTAgKzE4MSwxMyBAQAogCSAqIE1BQyBGb3JjaW5nIHJlZ2lzdGVyOiBkb24ndCBmb3JjZSBsaW5rLCBzcGVlZCwgZHVwbGV4CiAJICogb3IgZmxvdyBjb250cm9sIHN0YXRlIHRvIGFueSBwYXJ0aWN1bGFyIHZhbHVlcyBvbiBwaHlzaWNhbAogCSAqIHBvcnRzLCBidXQgZm9yY2UgdGhlIENQVSBwb3J0IGFuZCBhbGwgRFNBIHBvcnRzIHRvIDEwMDAgTWIvcwotCSAqIGZ1bGwgZHVwbGV4LgorCSAqICgxMDAgTWIvcyBvbiA2MDg1KSBmdWxsIGR1cGxleC4KIAkgKi8KIAlpZiAoZHNhX2lzX2NwdV9wb3J0KGRzLCBwKSB8fCBkcy0+ZHNhX3BvcnRfbWFzayAmICgxIDw8IHApKQotCQlSRUdfV1JJVEUoYWRkciwgMHgwMSwgMHgwMDNlKTsKKwkJaWYgKHBzLT5pZCA9PSBJRF82MDg1KQorCQkJUkVHX1dSSVRFKGFkZHIsIDB4MDEsIDB4MDAzZCk7IC8qIDEwMCBNYi9zICovCisJCWVsc2UKKwkJCVJFR19XUklURShhZGRyLCAweDAxLCAweDAwM2UpOyAvKiAxMDAwIE1iL3MgKi8KIAllbHNlCiAJCVJFR19XUklURShhZGRyLCAweDAxLCAweDAwMDMpOwogCkBAIC0yODYsNiArMjk5LDggQEAKIAltdjg4ZTZ4eHhfcHB1X3N0YXRlX2luaXQoZHMpOwogCW11dGV4X2luaXQoJnBzLT5zdGF0c19tdXRleCk7CiAKKwlwcy0+aWQgPSBSRUdfUkVBRChSRUdfUE9SVCgwKSwgMHgwMykgJiAweGZmZjA7CisKIAlyZXQgPSBtdjg4ZTYxMzFfc3dpdGNoX3Jlc2V0KGRzKTsKIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL25ldC9kc2EvbXY4OGU2eHh4LmggYi9uZXQvZHNhL212ODhlNnh4eC5oCmluZGV4IGViMGUwYWEuLjYxMTU2Y2EyIDEwMDY0NAotLS0gYS9uZXQvZHNhL212ODhlNnh4eC5oCisrKyBiL25ldC9kc2EvbXY4OGU2eHh4LmgKQEAgLTM5LDYgKzM5LDggQEAKIAkgKiBIb2xkIHRoaXMgbXV0ZXggb3ZlciBzbmFwc2hvdCArIGR1bXAgc2VxdWVuY2VzLgogCSAqLwogCXN0cnVjdCBtdXRleAlzdGF0c19tdXRleDsKKworCWludAkJaWQ7IC8qIHN3aXRjaCBwcm9kdWN0IGlkICovCiB9OwogCiBzdHJ1Y3QgbXY4OGU2eHh4X2h3X3N0YXQgewpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvY2lwc29faXB2NC5jIGIvbmV0L2lwdjQvY2lwc29faXB2NC5jCmluZGV4IDA5NGUxNTAuLmEwYWY3ZWEgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L2NpcHNvX2lwdjQuYworKysgYi9uZXQvaXB2NC9jaXBzb19pcHY0LmMKQEAgLTExMiw3ICsxMTIsNyBAQAogLyogVGhlIG1heGltdW0gbnVtYmVyIG9mIGNhdGVnb3J5IHJhbmdlcyBwZXJtaXR0ZWQgaW4gdGhlIHJhbmdlZCBjYXRlZ29yeSB0YWcKICAqICh0YWcgIzUpLiAgWW91IG1heSBub3RlIHRoYXQgdGhlIElFVEYgZHJhZnQgc3RhdGVzIHRoYXQgdGhlIG1heGltdW0gbnVtYmVyCiAgKiBvZiBjYXRlZ29yeSByYW5nZXMgaXMgNywgYnV0IGlmIHRoZSBsb3cgZW5kIG9mIHRoZSBsYXN0IGNhdGVnb3J5IHJhbmdlIGlzCi0gKiB6ZXJvIHRoZW4gaXQgaXMgcG9zc2liaWxlIHRvIGZpdCA4IGNhdGVnb3J5IHJhbmdlcyBiZWNhdXNlIHRoZSB6ZXJvIHNob3VsZAorICogemVybyB0aGVuIGl0IGlzIHBvc3NpYmxlIHRvIGZpdCA4IGNhdGVnb3J5IHJhbmdlcyBiZWNhdXNlIHRoZSB6ZXJvIHNob3VsZAogICogYmUgb21pdHRlZC4gKi8KICNkZWZpbmUgQ0lQU09fVjRfVEFHX1JOR19DQVRfTUFYICAgICAgOAogCkBAIC00MzgsNyArNDM4LDcgQEAKICAqCiAgKiBEZXNjcmlwdGlvbjoKICAqIFNlYXJjaCB0aGUgRE9JIGRlZmluaXRpb24gbGlzdCBmb3IgYSBET0kgZGVmaW5pdGlvbiB3aXRoIGEgRE9JIHZhbHVlIHRoYXQKLSAqIG1hdGNoZXMgQGRvaS4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2liaWxlIGZvciBjYWxsaW5nIHJjdV9yZWFkX1t1bl1sb2NrKCkuCisgKiBtYXRjaGVzIEBkb2kuICBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmxlIGZvciBjYWxsaW5nIHJjdV9yZWFkX1t1bl1sb2NrKCkuCiAgKiBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgRE9JIGRlZmluaXRpb24gb24gc3VjY2VzcyBhbmQgTlVMTCBvbiBmYWlsdXJlLgogICovCiBzdGF0aWMgc3RydWN0IGNpcHNvX3Y0X2RvaSAqY2lwc29fdjRfZG9pX3NlYXJjaCh1MzIgZG9pKQpAQCAtMTI5Myw3ICsxMjkzLDcgQEAKIAkJCXJldHVybiByZXRfdmFsOwogCiAJCS8qIFRoaXMgd2lsbCBzZW5kIHBhY2tldHMgdXNpbmcgdGhlICJvcHRpbWl6ZWQiIGZvcm1hdCB3aGVuCi0JCSAqIHBvc3NpYmlsZSBhcyBzcGVjaWZpZWQgaW4gIHNlY3Rpb24gMy40LjIuNiBvZiB0aGUKKwkJICogcG9zc2libGUgYXMgc3BlY2lmaWVkIGluICBzZWN0aW9uIDMuNC4yLjYgb2YgdGhlCiAJCSAqIENJUFNPIGRyYWZ0LiAqLwogCQlpZiAoY2lwc29fdjRfcmJtX29wdGZtdCAmJiByZXRfdmFsID4gMCAmJiByZXRfdmFsIDw9IDEwKQogCQkJdGFnX2xlbiA9IDE0OwpAQCAtMTc1Miw3ICsxNzUyLDcgQEAKIH0KIAogLyoqCi0gKiBjaXBzb192NF9lcnJvciAtIFNlbmQgdGhlIGNvcnJlY3QgcmVwb25zZSBmb3IgYSBiYWQgcGFja2V0CisgKiBjaXBzb192NF9lcnJvciAtIFNlbmQgdGhlIGNvcnJlY3QgcmVzcG9uc2UgZm9yIGEgYmFkIHBhY2tldAogICogQHNrYjogdGhlIHBhY2tldAogICogQGVycm9yOiB0aGUgZXJyb3IgY29kZQogICogQGdhdGV3YXk6IENJUFNPIGdhdGV3YXkgZmxhZwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvZmliX3RyaWUuYyBiL25ldC9pcHY0L2ZpYl90cmllLmMKaW5kZXggYjkyYzg2Zi4uZTkwMTNkNiAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvZmliX3RyaWUuYworKysgYi9uZXQvaXB2NC9maWJfdHJpZS5jCkBAIC0xMiw3ICsxMiw3IEBACiAgKgogICogICBIYW5zIExpc3MgPGhhbnMubGlzc0BpdHMudXUuc2U+ICBVcHBzYWxhIFVuaXZlcnNpdGV0CiAgKgotICogVGhpcyB3b3JrIGlzIGJhc2VkIG9uIHRoZSBMUEMtdHJpZSB3aGljaCBpcyBvcmlnaW5hbGx5IGRlc2NpYmVkIGluOgorICogVGhpcyB3b3JrIGlzIGJhc2VkIG9uIHRoZSBMUEMtdHJpZSB3aGljaCBpcyBvcmlnaW5hbGx5IGRlc2NyaWJlZCBpbjoKICAqCiAgKiBBbiBleHBlcmltZW50YWwgc3R1ZHkgb2YgY29tcHJlc3Npb24gbWV0aG9kcyBmb3IgZHluYW1pYyB0cmllcwogICogU3RlZmFuIE5pbHNzb24gYW5kIE1hdHRpIFRpa2thbmVuLiBBbGdvcml0aG1pY2EsIDMzKDEpOjE5LTMzLCAyMDAyLgpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvaWNtcC5jIGIvbmV0L2lwdjQvaWNtcC5jCmluZGV4IGE5MWRjMTYuLmU1ZjhhNzEgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L2ljbXAuYworKysgYi9uZXQvaXB2NC9pY21wLmMKQEAgLTcwNCw3ICs3MDQsNyBAQAogCSAqLwogCiAJLyoKLQkgKglDaGVjayB0aGUgb3RoZXIgZW5kIGlzbnQgdmlvbGF0aW5nIFJGQyAxMTIyLiBTb21lIHJvdXRlcnMgc2VuZAorCSAqCUNoZWNrIHRoZSBvdGhlciBlbmQgaXNuJ3QgdmlvbGF0aW5nIFJGQyAxMTIyLiBTb21lIHJvdXRlcnMgc2VuZAogCSAqCWJvZ3VzIHJlc3BvbnNlcyB0byBicm9hZGNhc3QgZnJhbWVzLiBJZiB5b3Ugc2VlIHRoaXMgbWVzc2FnZQogCSAqCWZpcnN0IGNoZWNrIHlvdXIgbmV0bWFzayBtYXRjaGVzIGF0IGJvdGggZW5kcywgaWYgaXQgZG9lcyB0aGVuCiAJICoJZ2V0IHRoZSBvdGhlciB2ZW5kb3IgdG8gZml4IHRoZWlyIGtpdC4KZGlmZiAtLWdpdCBhL25ldC9pcHY0L2lwX291dHB1dC5jIGIvbmV0L2lwdjQvaXBfb3V0cHV0LmMKaW5kZXggNjdmMjQxYi4uNDU5YzAxMSAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvaXBfb3V0cHV0LmMKKysrIGIvbmV0L2lwdjQvaXBfb3V0cHV0LmMKQEAgLTYwMyw3ICs2MDMsNyBAQAogCQkvKiBJRjogaXQgZG9lc24ndCBmaXQsIHVzZSAnbXR1JyAtIHRoZSBkYXRhIHNwYWNlIGxlZnQgKi8KIAkJaWYgKGxlbiA+IG10dSkKIAkJCWxlbiA9IG10dTsKLQkJLyogSUY6IHdlIGFyZSBub3Qgc2VuZGluZyB1cHRvIGFuZCBpbmNsdWRpbmcgdGhlIHBhY2tldCBlbmQKKwkJLyogSUY6IHdlIGFyZSBub3Qgc2VuZGluZyB1cCB0byBhbmQgaW5jbHVkaW5nIHRoZSBwYWNrZXQgZW5kCiAJCSAgIHRoZW4gYWxpZ24gdGhlIG5leHQgc3RhcnQgb24gYW4gZWlnaHQgYnl0ZSBib3VuZGFyeSAqLwogCQlpZiAobGVuIDwgbGVmdCkJewogCQkJbGVuICY9IH43OwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvaXBjb25maWcuYyBiL25ldC9pcHY0L2lwY29uZmlnLmMKaW5kZXggMmIwOTc3NS4uY2JmZjJlYyAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvaXBjb25maWcuYworKysgYi9uZXQvaXB2NC9pcGNvbmZpZy5jCkBAIC0xNDQ0LDcgKzE0NDQsNyBAQAogCQlyb290X3NlcnZlcl9hZGRyID0gYWRkcjsKIAogCS8qCi0JICogVXNlIGRlZmF1bHRzIHdoZXJlZXZlciBhcHBsaWNhYmxlLgorCSAqIFVzZSBkZWZhdWx0cyB3aGVyZXZlciBhcHBsaWNhYmxlLgogCSAqLwogCWlmIChpY19kZWZhdWx0cygpIDwgMCkKIAkJcmV0dXJuIC0xOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvbmV0ZmlsdGVyLmMgYi9uZXQvaXB2NC9uZXRmaWx0ZXIuYwppbmRleCBmM2MwYjU0Li40NjE0YmFiIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9uZXRmaWx0ZXIuYworKysgYi9uZXQvaXB2NC9uZXRmaWx0ZXIuYwpAQCAtMjIxLDkgKzIyMSwxMCBAQAogCXJldHVybiBjc3VtOwogfQogCi1zdGF0aWMgaW50IG5mX2lwX3JvdXRlKHN0cnVjdCBkc3RfZW50cnkgKipkc3QsIHN0cnVjdCBmbG93aSAqZmwpCitzdGF0aWMgaW50IG5mX2lwX3JvdXRlKHN0cnVjdCBuZXQgKm5ldCwgc3RydWN0IGRzdF9lbnRyeSAqKmRzdCwKKwkJICAgICAgIHN0cnVjdCBmbG93aSAqZmwsIGJvb2wgc3RyaWN0IF9fYWx3YXlzX3VudXNlZCkKIHsKLQlzdHJ1Y3QgcnRhYmxlICpydCA9IGlwX3JvdXRlX291dHB1dF9rZXkoJmluaXRfbmV0LCAmZmwtPnUuaXA0KTsKKwlzdHJ1Y3QgcnRhYmxlICpydCA9IGlwX3JvdXRlX291dHB1dF9rZXkobmV0LCAmZmwtPnUuaXA0KTsKIAlpZiAoSVNfRVJSKHJ0KSkKIAkJcmV0dXJuIFBUUl9FUlIocnQpOwogCSpkc3QgPSAmcnQtPmRzdDsKZGlmZiAtLWdpdCBhL25ldC9pcHY0L25ldGZpbHRlci9hcnBfdGFibGVzLmMgYi9uZXQvaXB2NC9uZXRmaWx0ZXIvYXJwX3RhYmxlcy5jCmluZGV4IDRiNWQ0NTcuLjg5YmM3ZTYgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L25ldGZpbHRlci9hcnBfdGFibGVzLmMKKysrIGIvbmV0L2lwdjQvbmV0ZmlsdGVyL2FycF90YWJsZXMuYwpAQCAtNzYsNyArNzYsNyBAQAogfQogCiAvKgotICogVW5mb3J0dW5hdGx5LCBfYiBhbmQgX21hc2sgYXJlIG5vdCBhbGlnbmVkIHRvIGFuIGludCAob3IgbG9uZyBpbnQpCisgKiBVbmZvcnR1bmF0ZWx5LCBfYiBhbmQgX21hc2sgYXJlIG5vdCBhbGlnbmVkIHRvIGFuIGludCAob3IgbG9uZyBpbnQpCiAgKiBTb21lIGFyY2hlcyBkb250IGNhcmUsIHVucm9sbGluZyB0aGUgbG9vcCBpcyBhIHdpbiBvbiB0aGVtLgogICogRm9yIG90aGVyIGFyY2hlcywgd2Ugb25seSBoYXZlIGEgMTZiaXQgYWxpZ25lbWVudC4KICAqLwpAQCAtMTg3NCw3ICsxODc0LDcgQEAKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnIxOwogCi0JLyogTm9vbmUgZWxzZSB3aWxsIGJlIGRvd25pbmcgc2VtIG5vdywgc28gd2Ugd29uJ3Qgc2xlZXAgKi8KKwkvKiBObyBvbmUgZWxzZSB3aWxsIGJlIGRvd25pbmcgc2VtIG5vdywgc28gd2Ugd29uJ3Qgc2xlZXAgKi8KIAlyZXQgPSB4dF9yZWdpc3Rlcl90YXJnZXRzKGFycHRfYnVpbHRpbl90ZywgQVJSQVlfU0laRShhcnB0X2J1aWx0aW5fdGcpKTsKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnIyOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvbmV0ZmlsdGVyL2lwX3RhYmxlcy5jIGIvbmV0L2lwdjQvbmV0ZmlsdGVyL2lwX3RhYmxlcy5jCmluZGV4IGZmY2VhMGQuLjcwNDkxNTAgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L25ldGZpbHRlci9pcF90YWJsZXMuYworKysgYi9uZXQvaXB2NC9uZXRmaWx0ZXIvaXBfdGFibGVzLmMKQEAgLTIyMzMsNyArMjIzMyw3IEBACiAJaWYgKHJldCA8IDApCiAJCWdvdG8gZXJyMTsKIAotCS8qIE5vb25lIGVsc2Ugd2lsbCBiZSBkb3duaW5nIHNlbSBub3csIHNvIHdlIHdvbid0IHNsZWVwICovCisJLyogTm8gb25lIGVsc2Ugd2lsbCBiZSBkb3duaW5nIHNlbSBub3csIHNvIHdlIHdvbid0IHNsZWVwICovCiAJcmV0ID0geHRfcmVnaXN0ZXJfdGFyZ2V0cyhpcHRfYnVpbHRpbl90ZywgQVJSQVlfU0laRShpcHRfYnVpbHRpbl90ZykpOwogCWlmIChyZXQgPCAwKQogCQlnb3RvIGVycjI7CmRpZmYgLS1naXQgYS9uZXQvaXB2NC9uZXRmaWx0ZXIvbmZfbmF0X2NvcmUuYyBiL25ldC9pcHY0L25ldGZpbHRlci9uZl9uYXRfY29yZS5jCmluZGV4IDIxYmNmNDcuLjljNzFiMjcgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L25ldGZpbHRlci9uZl9uYXRfY29yZS5jCisrKyBiL25ldC9pcHY0L25ldGZpbHRlci9uZl9uYXRfY29yZS5jCkBAIC01MjEsNyArNTIxLDcgQEAKIH0KIEVYUE9SVF9TWU1CT0wobmZfbmF0X3Byb3RvY29sX3JlZ2lzdGVyKTsKIAotLyogTm9vbmUgc3RvcmVzIHRoZSBwcm90b2NvbCBhbnl3aGVyZTsgc2ltcGx5IGRlbGV0ZSBpdC4gKi8KKy8qIE5vIG9uZSBzdG9yZXMgdGhlIHByb3RvY29sIGFueXdoZXJlOyBzaW1wbHkgZGVsZXRlIGl0LiAqLwogdm9pZCBuZl9uYXRfcHJvdG9jb2xfdW5yZWdpc3Rlcihjb25zdCBzdHJ1Y3QgbmZfbmF0X3Byb3RvY29sICpwcm90bykKIHsKIAlzcGluX2xvY2tfYmgoJm5mX25hdF9sb2NrKTsKQEAgLTUzMiw3ICs1MzIsNyBAQAogfQogRVhQT1JUX1NZTUJPTChuZl9uYXRfcHJvdG9jb2xfdW5yZWdpc3Rlcik7CiAKLS8qIE5vb25lIHVzaW5nIGNvbm50cmFjayBieSB0aGUgdGltZSB0aGlzIGNhbGxlZC4gKi8KKy8qIE5vIG9uZSB1c2luZyBjb25udHJhY2sgYnkgdGhlIHRpbWUgdGhpcyBjYWxsZWQuICovCiBzdGF0aWMgdm9pZCBuZl9uYXRfY2xlYW51cF9jb25udHJhY2soc3RydWN0IG5mX2Nvbm4gKmN0KQogewogCXN0cnVjdCBuZl9jb25uX25hdCAqbmF0ID0gbmZfY3RfZXh0X2ZpbmQoY3QsIE5GX0NUX0VYVF9OQVQpOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvcmF3LmMgYi9uZXQvaXB2NC9yYXcuYwppbmRleCAyZDNjNzJlLi5iY2VhZWM0IDEwMDY0NAotLS0gYS9uZXQvaXB2NC9yYXcuYworKysgYi9uZXQvaXB2NC9yYXcuYwpAQCAtNjIyLDcgKzYyMiw3IEBACiBzdGF0aWMgdm9pZCByYXdfY2xvc2Uoc3RydWN0IHNvY2sgKnNrLCBsb25nIHRpbWVvdXQpCiB7CiAJLyoKLQkgKiBSYXcgc29ja2V0cyBtYXkgaGF2ZSBkaXJlY3Qga2VybmVsIHJlZmVyZW5lY2VzLiBLaWxsIHRoZW0uCisJICogUmF3IHNvY2tldHMgbWF5IGhhdmUgZGlyZWN0IGtlcm5lbCByZWZlcmVuY2VzLiBLaWxsIHRoZW0uCiAJICovCiAJaXBfcmFfY29udHJvbChzaywgMCwgTlVMTCk7CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3JvdXRlLmMgYi9uZXQvaXB2NC9yb3V0ZS5jCmluZGV4IDRiMGM4MTEuLmMxYWNmNjkgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3JvdXRlLmMKKysrIGIvbmV0L2lwdjQvcm91dGUuYwpAQCAtODIxLDcgKzgyMSw3IEBACiB9CiAKIC8qCi0gKiBQZXJ0dWJhdGlvbiBvZiBydF9nZW5pZCBieSBhIHNtYWxsIHF1YW50aXR5IFsxLi4yNTZdCisgKiBQZXJ0dXJiYXRpb24gb2YgcnRfZ2VuaWQgYnkgYSBzbWFsbCBxdWFudGl0eSBbMS4uMjU2XQogICogVXNpbmcgOCBiaXRzIG9mIHNodWZmbGluZyBlbnN1cmUgd2UgY2FuIGNhbGwgcnRfY2FjaGVfaW52YWxpZGF0ZSgpCiAgKiBtYW55IHRpbWVzICgyXjI0KSB3aXRob3V0IGdpdmluZyByZWNlbnQgcnRfZ2VuaWQuCiAgKiBKZW5raW5zIGhhc2ggaXMgc3Ryb25nIGVub3VnaCB0aGF0IGxpdGxlIGNoYW5nZXMgb2YgcnRfZ2VuaWQgYXJlIE9LLgpAQCAtMTE5MSw3ICsxMTkxLDcgQEAKICNlbmRpZgogCS8qCiAJICogU2luY2UgbG9va3VwIGlzIGxvY2tmcmVlLCB3ZSBtdXN0IG1ha2Ugc3VyZQotCSAqIHByZXZpb3VzIHdyaXRlcyB0byBydCBhcmUgY29taXR0ZWQgdG8gbWVtb3J5CisJICogcHJldmlvdXMgd3JpdGVzIHRvIHJ0IGFyZSBjb21taXR0ZWQgdG8gbWVtb3J5CiAJICogYmVmb3JlIG1ha2luZyBydCB2aXNpYmxlIHRvIG90aGVyIENQVVMuCiAJICovCiAJcmN1X2Fzc2lnbl9wb2ludGVyKHJ0X2hhc2hfdGFibGVbaGFzaF0uY2hhaW4sIHJ0KTsKQEAgLTE4OTEsNiArMTg5MSw3IEBACiAjaWZkZWYgQ09ORklHX0lQX1JPVVRFX0NMQVNTSUQKIAlydGgtPmRzdC50Y2xhc3NpZCA9IGl0YWc7CiAjZW5kaWYKKwlydGgtPnJ0X3JvdXRlX2lpZiA9IGRldi0+aWZpbmRleDsKIAlydGgtPnJ0X2lpZgk9IGRldi0+aWZpbmRleDsKIAlydGgtPmRzdC5kZXYJPSBpbml0X25ldC5sb29wYmFja19kZXY7CiAJZGV2X2hvbGQocnRoLT5kc3QuZGV2KTsKQEAgLTIwMjYsNiArMjAyNyw3IEBACiAJcnRoLT5ydF9rZXlfc3JjCT0gc2FkZHI7CiAJcnRoLT5ydF9zcmMJPSBzYWRkcjsKIAlydGgtPnJ0X2dhdGV3YXkJPSBkYWRkcjsKKwlydGgtPnJ0X3JvdXRlX2lpZiA9IGluX2Rldi0+ZGV2LT5pZmluZGV4OwogCXJ0aC0+cnRfaWlmIAk9IGluX2Rldi0+ZGV2LT5pZmluZGV4OwogCXJ0aC0+ZHN0LmRldgk9IChvdXRfZGV2KS0+ZGV2OwogCWRldl9ob2xkKHJ0aC0+ZHN0LmRldik7CkBAIC0yMjAyLDYgKzIyMDQsNyBAQAogI2lmZGVmIENPTkZJR19JUF9ST1VURV9DTEFTU0lECiAJcnRoLT5kc3QudGNsYXNzaWQgPSBpdGFnOwogI2VuZGlmCisJcnRoLT5ydF9yb3V0ZV9paWYgPSBkZXYtPmlmaW5kZXg7CiAJcnRoLT5ydF9paWYJPSBkZXYtPmlmaW5kZXg7CiAJcnRoLT5kc3QuZGV2CT0gbmV0LT5sb29wYmFja19kZXY7CiAJZGV2X2hvbGQocnRoLT5kc3QuZGV2KTsKQEAgLTI0MDEsNyArMjQwNCw4IEBACiAJcnRoLT5ydF9tYXJrICAgID0gb2xkZmxwNC0+Zmxvd2k0X21hcms7CiAJcnRoLT5ydF9kc3QJPSBmbDQtPmRhZGRyOwogCXJ0aC0+cnRfc3JjCT0gZmw0LT5zYWRkcjsKLQlydGgtPnJ0X2lpZgk9IDA7CisJcnRoLT5ydF9yb3V0ZV9paWYgPSAwOworCXJ0aC0+cnRfaWlmCT0gb2xkZmxwNC0+Zmxvd2k0X29pZiA/IDogZGV2X291dC0+aWZpbmRleDsKIAkvKiBnZXQgcmVmZXJlbmNlcyB0byB0aGUgZGV2aWNlcyB0aGF0IGFyZSB0byBiZSBob2xkIGJ5IHRoZSByb3V0aW5nCiAJICAgY2FjaGUgZW50cnkgKi8KIAlydGgtPmRzdC5kZXYJPSBkZXZfb3V0OwpAQCAtMjcxNiw2ICsyNzIwLDcgQEAKIAkJcnQtPnJ0X2tleV9kc3QgPSBvcnQtPnJ0X2tleV9kc3Q7CiAJCXJ0LT5ydF9rZXlfc3JjID0gb3J0LT5ydF9rZXlfc3JjOwogCQlydC0+cnRfdG9zID0gb3J0LT5ydF90b3M7CisJCXJ0LT5ydF9yb3V0ZV9paWYgPSBvcnQtPnJ0X3JvdXRlX2lpZjsKIAkJcnQtPnJ0X2lpZiA9IG9ydC0+cnRfaWlmOwogCQlydC0+cnRfb2lmID0gb3J0LT5ydF9vaWY7CiAJCXJ0LT5ydF9tYXJrID0gb3J0LT5ydF9tYXJrOwpAQCAtMjcyNSw3ICsyNzMwLDYgQEAKIAkJcnQtPnJ0X3R5cGUgPSBvcnQtPnJ0X3R5cGU7CiAJCXJ0LT5ydF9kc3QgPSBvcnQtPnJ0X2RzdDsKIAkJcnQtPnJ0X3NyYyA9IG9ydC0+cnRfc3JjOwotCQlydC0+cnRfaWlmID0gb3J0LT5ydF9paWY7CiAJCXJ0LT5ydF9nYXRld2F5ID0gb3J0LT5ydF9nYXRld2F5OwogCQlydC0+cnRfc3BlY19kc3QgPSBvcnQtPnJ0X3NwZWNfZHN0OwogCQlydC0+cGVlciA9IG9ydC0+cGVlcjsKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3RjcF9scC5jIGIvbmV0L2lwdjQvdGNwX2xwLmMKaW5kZXggNjU2ZDQzMS4uNzJmNzIxOCAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvdGNwX2xwLmMKKysrIGIvbmV0L2lwdjQvdGNwX2xwLmMKQEAgLTEyLDcgKzEyLDcgQEAKICAqICAgICB3aXRoaW4gY29uZ19hdm9pZC4KICAqICAgbyBFcnJvciBjb3JyZWN0aW5nIGluIHJlbW90ZSBIWiwgdGhlcmVmb3JlIHJlbW90ZSBIWiB3aWxsIGJlIGtlZXBlZAogICogICAgIG9uIGNoZWNraW5nIGFuZCB1cGRhdGluZy4KLSAqICAgbyBIYW5kbGluZyBjYWxjdWxhdGlvbiBvZiBPbmUtV2F5LURlbGF5IChPV0QpIHdpdGhpbiBydHRfc2FtcGxlLCBzaWNuZQorICogICBvIEhhbmRsaW5nIGNhbGN1bGF0aW9uIG9mIE9uZS1XYXktRGVsYXkgKE9XRCkgd2l0aGluIHJ0dF9zYW1wbGUsIHNpbmNlCiAgKiAgICAgT1dEIGhhdmUgYSBzaW1pbGFyIG1lYW5pbmcgYXMgUlRULiBBbHNvIGNvcnJlY3QgdGhlIGJ1Z2d5IGZvcm11bGFyLgogICogICBvIEhhbmRsZSByZWFjdGlvbiBmb3IgRWFybHkgQ29uZ2VzdGlvbiBJbmRpY2F0aW9uIChFQ0kpIHdpdGhpbgogICogICAgIHBrdHNfYWNrZWQsIGFzIG1lbnRpb25lZCB3aXRoaW4gcHNldWRvIGNvZGUuCmRpZmYgLS1naXQgYS9uZXQvaXB2NC90Y3Bfb3V0cHV0LmMgYi9uZXQvaXB2NC90Y3Bfb3V0cHV0LmMKaW5kZXggOGIwZDAxNi4uMTczODhjNyAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvdGNwX291dHB1dC5jCisrKyBiL25ldC9pcHY0L3RjcF9vdXRwdXQuYwpAQCAtNzMsNyArNzMsNyBAQAogCXRjcF9hZHZhbmNlX3NlbmRfaGVhZChzaywgc2tiKTsKIAl0cC0+c25kX254dCA9IFRDUF9TS0JfQ0Ioc2tiKS0+ZW5kX3NlcTsKIAotCS8qIERvbid0IG92ZXJyaWRlIE5hZ2xlIGluZGVmaW5hdGVseSB3aXRoIEYtUlRPICovCisJLyogRG9uJ3Qgb3ZlcnJpZGUgTmFnbGUgaW5kZWZpbml0ZWx5IHdpdGggRi1SVE8gKi8KIAlpZiAodHAtPmZydG9fY291bnRlciA9PSAyKQogCQl0cC0+ZnJ0b19jb3VudGVyID0gMzsKIApkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvdGNwX3llYWguYyBiL25ldC9pcHY0L3RjcF95ZWFoLmMKaW5kZXggZGM3ZjQzMS4uMDVjM2I2ZiAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvdGNwX3llYWguYworKysgYi9uZXQvaXB2NC90Y3BfeWVhaC5jCkBAIC0yMCw3ICsyMCw3IEBACiAjZGVmaW5lIFRDUF9ZRUFIX0RFTFRBICAgICAgICAzIC8vbG9nIG1pbmltdW0gZnJhY3Rpb24gb2YgY3duZCB0byBiZSByZW1vdmVkIG9uIGxvc3MKICNkZWZpbmUgVENQX1lFQUhfRVBTSUxPTiAgICAgIDEgLy9sb2cgbWF4aW11bSBmcmFjdGlvbiB0byBiZSByZW1vdmVkIG9uIGVhcmx5IGRlY29uZ2VzdGlvbgogI2RlZmluZSBUQ1BfWUVBSF9QSFkgICAgICAgICAgOCAvL2xpbiBtYXhpbXVtIGRlbHRhIGZyb20gYmFzZQotI2RlZmluZSBUQ1BfWUVBSF9SSE8gICAgICAgICAxNiAvL2xpbiBtaW51bXVtIG51bWJlciBvZiBjb25zZWN1dGl2ZSBydHQgdG8gY29uc2lkZXIgY29tcGV0aXRpb24gb24gbG9zcworI2RlZmluZSBUQ1BfWUVBSF9SSE8gICAgICAgICAxNiAvL2xpbiBtaW5pbXVtIG51bWJlciBvZiBjb25zZWN1dGl2ZSBydHQgdG8gY29uc2lkZXIgY29tcGV0aXRpb24gb24gbG9zcwogI2RlZmluZSBUQ1BfWUVBSF9aRVRBICAgICAgICA1MCAvL2xpbiBtaW5pbXVtIG51bWJlciBvZiBzdGF0ZSBzd2l0Y2hzIHRvIHJlc2V0IHJlbm9fY291bnQKIAogI2RlZmluZSBUQ1BfU0NBTEFCTEVfQUlfQ05UCSAxMDBVCmRpZmYgLS1naXQgYS9uZXQvaXB2NC91ZHAuYyBiL25ldC9pcHY0L3VkcC5jCmluZGV4IDU4OGY0N2EuLmY4N2E4ZWIgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3VkcC5jCisrKyBiL25ldC9pcHY0L3VkcC5jCkBAIC0xODksNyArMTg5LDcgQEAKICAqICBAc2s6ICAgICAgICAgIHNvY2tldCBzdHJ1Y3QgaW4gcXVlc3Rpb24KICAqICBAc251bTogICAgICAgIHBvcnQgbnVtYmVyIHRvIGxvb2sgdXAKICAqICBAc2FkZHJfY29tcDogIEFGLWRlcGVuZGVudCBjb21wYXJpc29uIG9mIGJvdW5kIGxvY2FsIElQIGFkZHJlc3NlcwotICogIEBoYXNoMl9udWxsYWRkcjogQUYtZGVwZW5kYW50IGhhc2ggdmFsdWUgaW4gc2Vjb25kYXJ5IGhhc2ggY2hhaW5zLAorICogIEBoYXNoMl9udWxsYWRkcjogQUYtZGVwZW5kZW50IGhhc2ggdmFsdWUgaW4gc2Vjb25kYXJ5IGhhc2ggY2hhaW5zLAogICogICAgICAgICAgICAgICAgICAgd2l0aCBOVUxMIGFkZHJlc3MKICAqLwogaW50IHVkcF9saWJfZ2V0X3BvcnQoc3RydWN0IHNvY2sgKnNrLCB1bnNpZ25lZCBzaG9ydCBzbnVtLApkaWZmIC0tZ2l0IGEvbmV0L2lwdjQveGZybTRfcG9saWN5LmMgYi9uZXQvaXB2NC94ZnJtNF9wb2xpY3kuYwppbmRleCAxM2UwZTdmLi5kMjBhMDVlIDEwMDY0NAotLS0gYS9uZXQvaXB2NC94ZnJtNF9wb2xpY3kuYworKysgYi9uZXQvaXB2NC94ZnJtNF9wb2xpY3kuYwpAQCAtNzQsNiArNzQsNyBAQAogCXJ0LT5ydF9rZXlfZHN0ID0gZmw0LT5kYWRkcjsKIAlydC0+cnRfa2V5X3NyYyA9IGZsNC0+c2FkZHI7CiAJcnQtPnJ0X3RvcyA9IGZsNC0+Zmxvd2k0X3RvczsKKwlydC0+cnRfcm91dGVfaWlmID0gZmw0LT5mbG93aTRfaWlmOwogCXJ0LT5ydF9paWYgPSBmbDQtPmZsb3dpNF9paWY7CiAJcnQtPnJ0X29pZiA9IGZsNC0+Zmxvd2k0X29pZjsKIAlydC0+cnRfbWFyayA9IGZsNC0+Zmxvd2k0X21hcms7CmRpZmYgLS1naXQgYS9uZXQvaXB2Ni9hZGRyY29uZi5jIGIvbmV0L2lwdjYvYWRkcmNvbmYuYwppbmRleCAzZGFhZjNjLi4xNDkzNTM0IDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9hZGRyY29uZi5jCisrKyBiL25ldC9pcHY2L2FkZHJjb25mLmMKQEAgLTEwODQsNyArMTA4NCw3IEBACiAJY2FzZSBJUFY2X1NBRERSX1JVTEVfUFJJVkFDWToKIAkgICAgewogCQkvKiBSdWxlIDc6IFByZWZlciBwdWJsaWMgYWRkcmVzcwotCQkgKiBOb3RlOiBwcmVmZXIgdGVtcHJhcnkgYWRkcmVzcyBpZiB1c2VfdGVtcGFkZHIgPj0gMgorCQkgKiBOb3RlOiBwcmVmZXIgdGVtcG9yYXJ5IGFkZHJlc3MgaWYgdXNlX3RlbXBhZGRyID49IDIKIAkJICovCiAJCWludCBwcmVmdG1wID0gZHN0LT5wcmVmcyAmIChJUFY2X1BSRUZFUl9TUkNfUFVCTElDfElQVjZfUFJFRkVSX1NSQ19UTVApID8KIAkJCQkhIShkc3QtPnByZWZzICYgSVBWNl9QUkVGRVJfU1JDX1RNUCkgOgpAQCAtMTk2OCw3ICsxOTY4LDcgQEAKIAkJCQkJICogIHRvIHRoZSBzdG9yZWQgbGlmZXRpbWUgc2luY2Ugd2UnbGwKIAkJCQkJICogIGJlIHVwZGF0aW5nIHRoZSB0aW1lc3RhbXAgYmVsb3csCiAJCQkJCSAqICBlbHNlIHdlJ2xsIHNldCBpdCBiYWNrIHRvIHRoZQotCQkJCQkgKiAgbWludW11bS4KKwkJCQkJICogIG1pbmltdW0uCiAJCQkJCSAqLwogCQkJCQlpZiAocHJlZmVyZWRfbGZ0ICE9IGlmcC0+cHJlZmVyZWRfbGZ0KSB7CiAJCQkJCQl2YWxpZF9sZnQgPSBzdG9yZWRfbGZ0OwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvYWZfaW5ldDYuYyBiL25ldC9pcHY2L2FmX2luZXQ2LmMKaW5kZXggNGIxM2Q1ZC4uYWZjYzcwOSAxMDA2NDQKLS0tIGEvbmV0L2lwdjYvYWZfaW5ldDYuYworKysgYi9uZXQvaXB2Ni9hZl9pbmV0Ni5jCkBAIC0xMTEzLDcgKzExMTMsNyBAQAogCS8qCiAJICoJaXBuZ3dnIEFQSSBkcmFmdCBtYWtlcyBjbGVhciB0aGF0IHRoZSBjb3JyZWN0IHNlbWFudGljcwogCSAqCWZvciBUQ1AgYW5kIFVEUCBpcyB0byBjb25zaWRlciBvbmUgVENQIGFuZCBVRFAgaW5zdGFuY2UKLQkgKglpbiBhIGhvc3QgYXZhaWxpYWJsZSBieSBib3RoIElORVQgYW5kIElORVQ2IEFQSXMgYW5kCisJICoJaW4gYSBob3N0IGF2YWlsYWJsZSBieSBib3RoIElORVQgYW5kIElORVQ2IEFQSXMgYW5kCiAJICoJYWJsZSB0byBjb21tdW5pY2F0ZSB2aWEgYm90aCBuZXR3b3JrIHByb3RvY29scy4KIAkgKi8KIApkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvaXA2X291dHB1dC5jIGIvbmV0L2lwdjYvaXA2X291dHB1dC5jCmluZGV4IDE4MjA4ODcuLjQ2Y2Y3YmUgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L2lwNl9vdXRwdXQuYworKysgYi9uZXQvaXB2Ni9pcDZfb3V0cHV0LmMKQEAgLTc3OSw3ICs3NzksNyBAQAogCQkvKiBJRjogaXQgZG9lc24ndCBmaXQsIHVzZSAnbXR1JyAtIHRoZSBkYXRhIHNwYWNlIGxlZnQgKi8KIAkJaWYgKGxlbiA+IG10dSkKIAkJCWxlbiA9IG10dTsKLQkJLyogSUY6IHdlIGFyZSBub3Qgc2VuZGluZyB1cHRvIGFuZCBpbmNsdWRpbmcgdGhlIHBhY2tldCBlbmQKKwkJLyogSUY6IHdlIGFyZSBub3Qgc2VuZGluZyB1cCB0byBhbmQgaW5jbHVkaW5nIHRoZSBwYWNrZXQgZW5kCiAJCSAgIHRoZW4gYWxpZ24gdGhlIG5leHQgc3RhcnQgb24gYW4gZWlnaHQgYnl0ZSBib3VuZGFyeSAqLwogCQlpZiAobGVuIDwgbGVmdCkJewogCQkJbGVuICY9IH43OwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvbmV0ZmlsdGVyLmMgYi9uZXQvaXB2Ni9uZXRmaWx0ZXIuYwppbmRleCAzOWFhY2EyLi4yOGJjMWY2IDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9uZXRmaWx0ZXIuYworKysgYi9uZXQvaXB2Ni9uZXRmaWx0ZXIuYwpAQCAtOTAsOSArOTAsMTggQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBuZl9pcDZfcm91dGUoc3RydWN0IGRzdF9lbnRyeSAqKmRzdCwgc3RydWN0IGZsb3dpICpmbCkKK3N0YXRpYyBpbnQgbmZfaXA2X3JvdXRlKHN0cnVjdCBuZXQgKm5ldCwgc3RydWN0IGRzdF9lbnRyeSAqKmRzdCwKKwkJCXN0cnVjdCBmbG93aSAqZmwsIGJvb2wgc3RyaWN0KQogewotCSpkc3QgPSBpcDZfcm91dGVfb3V0cHV0KCZpbml0X25ldCwgTlVMTCwgJmZsLT51LmlwNik7CisJc3RhdGljIGNvbnN0IHN0cnVjdCBpcHY2X3BpbmZvIGZha2VfcGluZm87CisJc3RhdGljIGNvbnN0IHN0cnVjdCBpbmV0X3NvY2sgZmFrZV9zayA9IHsKKwkJLyogbWFrZXMgaXA2X3JvdXRlX291dHB1dCBzZXQgUlQ2X0xPT0tVUF9GX0lGQUNFOiAqLworCQkuc2suc2tfYm91bmRfZGV2X2lmID0gMSwKKwkJLnBpbmV0NiA9IChzdHJ1Y3QgaXB2Nl9waW5mbyAqKSAmZmFrZV9waW5mbywKKwl9OworCWNvbnN0IHZvaWQgKnNrID0gc3RyaWN0ID8gJmZha2Vfc2sgOiBOVUxMOworCisJKmRzdCA9IGlwNl9yb3V0ZV9vdXRwdXQobmV0LCBzaywgJmZsLT51LmlwNik7CiAJcmV0dXJuICgqZHN0KS0+ZXJyb3I7CiB9CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY2L25ldGZpbHRlci9pcDZfdGFibGVzLmMgYi9uZXQvaXB2Ni9uZXRmaWx0ZXIvaXA2X3RhYmxlcy5jCmluZGV4IDBiMmFmOWIuLjVhMWM2ZjIgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L25ldGZpbHRlci9pcDZfdGFibGVzLmMKKysrIGIvbmV0L2lwdjYvbmV0ZmlsdGVyL2lwNl90YWJsZXMuYwpAQCAtMjI0OCw3ICsyMjQ4LDcgQEAKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnIxOwogCi0JLyogTm9vbmUgZWxzZSB3aWxsIGJlIGRvd25pbmcgc2VtIG5vdywgc28gd2Ugd29uJ3Qgc2xlZXAgKi8KKwkvKiBObyBvbmUgZWxzZSB3aWxsIGJlIGRvd25pbmcgc2VtIG5vdywgc28gd2Ugd29uJ3Qgc2xlZXAgKi8KIAlyZXQgPSB4dF9yZWdpc3Rlcl90YXJnZXRzKGlwNnRfYnVpbHRpbl90ZywgQVJSQVlfU0laRShpcDZ0X2J1aWx0aW5fdGcpKTsKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnIyOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvbmV0ZmlsdGVyL25mX2RlZnJhZ19pcHY2X2hvb2tzLmMgYi9uZXQvaXB2Ni9uZXRmaWx0ZXIvbmZfZGVmcmFnX2lwdjZfaG9va3MuYwppbmRleCA5N2M1YjIxLi5jZGQ2ZDA0IDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9uZXRmaWx0ZXIvbmZfZGVmcmFnX2lwdjZfaG9va3MuYworKysgYi9uZXQvaXB2Ni9uZXRmaWx0ZXIvbmZfZGVmcmFnX2lwdjZfaG9va3MuYwpAQCAtNzEsNyArNzEsNyBAQAogCWlmIChyZWFzbSA9PSBOVUxMKQogCQlyZXR1cm4gTkZfU1RPTEVOOwogCi0JLyogZXJyb3Igb2NjdXJlZCBvciBub3QgZnJhZ21lbnRlZCAqLworCS8qIGVycm9yIG9jY3VycmVkIG9yIG5vdCBmcmFnbWVudGVkICovCiAJaWYgKHJlYXNtID09IHNrYikKIAkJcmV0dXJuIE5GX0FDQ0VQVDsKIApkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvdGNwX2lwdjYuYyBiL25ldC9pcHY2L3RjcF9pcHY2LmMKaW5kZXggNTZmYTEyNS4uNGY0OWU1ZCAxMDA2NDQKLS0tIGEvbmV0L2lwdjYvdGNwX2lwdjYuYworKysgYi9uZXQvaXB2Ni90Y3BfaXB2Ni5jCkBAIC0xNjIyLDYgKzE2MjIsNyBAQAogCQlvcHRfc2tiID0gc2tiX2Nsb25lKHNrYiwgR0ZQX0FUT01JQyk7CiAKIAlpZiAoc2stPnNrX3N0YXRlID09IFRDUF9FU1RBQkxJU0hFRCkgeyAvKiBGYXN0IHBhdGggKi8KKwkJc29ja19ycHNfc2F2ZV9yeGhhc2goc2ssIHNrYi0+cnhoYXNoKTsKIAkJaWYgKHRjcF9yY3ZfZXN0YWJsaXNoZWQoc2ssIHNrYiwgdGNwX2hkcihza2IpLCBza2ItPmxlbikpCiAJCQlnb3RvIHJlc2V0OwogCQlpZiAob3B0X3NrYikKQEAgLTE2NDksNyArMTY1MCw4IEBACiAJCQkJX19rZnJlZV9za2Iob3B0X3NrYik7CiAJCQlyZXR1cm4gMDsKIAkJfQotCX0KKwl9IGVsc2UKKwkJc29ja19ycHNfc2F2ZV9yeGhhc2goc2ssIHNrYi0+cnhoYXNoKTsKIAogCWlmICh0Y3BfcmN2X3N0YXRlX3Byb2Nlc3Moc2ssIHNrYiwgdGNwX2hkcihza2IpLCBza2ItPmxlbikpCiAJCWdvdG8gcmVzZXQ7CmRpZmYgLS1naXQgYS9uZXQvaXB2Ni91ZHAuYyBiL25ldC9pcHY2L3VkcC5jCmluZGV4IGQ3MDM3YzAuLjE1YzM3NzQgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L3VkcC5jCisrKyBiL25ldC9pcHY2L3VkcC5jCkBAIC01MDUsNiArNTA1LDkgQEAKIAlpbnQgcmM7CiAJaW50IGlzX3VkcGxpdGUgPSBJU19VRFBMSVRFKHNrKTsKIAorCWlmICghaXB2Nl9hZGRyX2FueSgmaW5ldDZfc2soc2spLT5kYWRkcikpCisJCXNvY2tfcnBzX3NhdmVfcnhoYXNoKHNrLCBza2ItPnJ4aGFzaCk7CisKIAlpZiAoIXhmcm02X3BvbGljeV9jaGVjayhzaywgWEZSTV9QT0xJQ1lfSU4sIHNrYikpCiAJCWdvdG8gZHJvcDsKIApkaWZmIC0tZ2l0IGEvbmV0L2lyZGEvaXJsYXAuYyBiL25ldC9pcmRhL2lybGFwLmMKaW5kZXggNzgzYzVmMy4uMDA1YjQyNCAxMDA2NDQKLS0tIGEvbmV0L2lyZGEvaXJsYXAuYworKysgYi9uZXQvaXJkYS9pcmxhcC5jCkBAIC0xNjUsNyArMTY1LDcgQEAKIAogCWlybGFwX2FwcGx5X2RlZmF1bHRfY29ubmVjdGlvbl9wYXJhbWV0ZXJzKHNlbGYpOwogCi0Jc2VsZi0+TjMgPSAzOyAvKiAjIGNvbm5lY3Rpb25zIGF0dGVtdHMgdG8gdHJ5IGJlZm9yZSBnaXZpbmcgdXAgKi8KKwlzZWxmLT5OMyA9IDM7IC8qICMgY29ubmVjdGlvbnMgYXR0ZW1wdHMgdG8gdHJ5IGJlZm9yZSBnaXZpbmcgdXAgKi8KIAogCXNlbGYtPnN0YXRlID0gTEFQX05ETTsKIApkaWZmIC0tZ2l0IGEvbmV0L2lyZGEvaXJsYXBfZXZlbnQuYyBiL25ldC9pcmRhL2lybGFwX2V2ZW50LmMKaW5kZXggZDQzNGM4OC4uYmI0NzAyMSAxMDA2NDQKLS0tIGEvbmV0L2lyZGEvaXJsYXBfZXZlbnQuYworKysgYi9uZXQvaXJkYS9pcmxhcF9ldmVudC5jCkBAIC03MDgsNyArNzA4LDcgQEAKIAogCQkJCXNlbGYtPmZyYW1lX3NlbnQgPSBUUlVFOwogCQkJfQotCQkJLyogUmVhZGp1c3Qgb3VyIHRpbWVyIHRvIGFjY29tb2RhdGUgZGV2aWNlcworCQkJLyogUmVhZGp1c3Qgb3VyIHRpbWVyIHRvIGFjY29tbW9kYXRlIGRldmljZXMKIAkJCSAqIGRvaW5nIGZhc3RlciBvciBzbG93ZXIgZGlzY292ZXJ5IHRoYW4gdXMuLi4KIAkJCSAqIEplYW4gSUkgKi8KIAkJCWlybGFwX3N0YXJ0X3F1ZXJ5X3RpbWVyKHNlbGYsIGluZm8tPlMsIGluZm8tPnMpOwpAQCAtOTMxLDcgKzkzMSw3IEBACiAJCWlybGFwX3NlbmRfcnJfZnJhbWUoc2VsZiwgQ01EX0ZSQU1FKTsKIAogCQkvKiBUaGUgdGltZXIgaXMgc2V0IHRvIGhhbGYgdGhlIG5vcm1hbCB0aW1lciB0byBxdWlja2x5Ci0JCSAqIGRldGVjdCBhIGZhaWx1cmUgdG8gbmVnb2NpYXRlIHRoZSBuZXcgY29ubmVjdGlvbgorCQkgKiBkZXRlY3QgYSBmYWlsdXJlIHRvIG5lZ290aWF0ZSB0aGUgbmV3IGNvbm5lY3Rpb24KIAkJICogcGFyYW1ldGVycy4gSXJMQVAgNi4xMS4zLjIsIG5vdGUgMy4KIAkJICogTm90ZSB0aGF0IGN1cnJlbnRseSB3ZSBkb24ndCBwcm9jZXNzIHRoaXMgZmFpbHVyZQogCQkgKiBwcm9wZXJseSwgYXMgd2Ugc2hvdWxkIGRvIGEgcXVpY2sgZGlzY29ubmVjdC4KQEAgLTEwNTIsNyArMTA1Miw3IEBACiAJCQkJcmV0dXJuIC1FUFJPVE87CiAJCQl9CiAKLQkJCS8qIFN1YnN0cmFjdCBzcGFjZSB1c2VkIGJ5IHRoaXMgc2tiICovCisJCQkvKiBTdWJ0cmFjdCBzcGFjZSB1c2VkIGJ5IHRoaXMgc2tiICovCiAJCQlzZWxmLT5ieXRlc19sZWZ0IC09IHNrYi0+bGVuOwogI2Vsc2UJLyogQ09ORklHX0lSREFfRFlOQU1JQ19XSU5ET1cgKi8KIAkJCS8qIFdpbmRvdyBoYXMgYmVlbiBhZGp1c3RlZCBmb3IgdGhlIG1heCBwYWNrZXQKQEAgLTE4MDgsNyArMTgwOCw3IEBACiAKIAkJCQlyZXR1cm4gLUVQUk9UTzsgLyogVHJ5IGFnYWluIGxhdGVyICovCiAJCQl9Ci0JCQkvKiBTdWJzdHJhY3Qgc3BhY2UgdXNlZCBieSB0aGlzIHNrYiAqLworCQkJLyogU3VidHJhY3Qgc3BhY2UgdXNlZCBieSB0aGlzIHNrYiAqLwogCQkJc2VsZi0+Ynl0ZXNfbGVmdCAtPSBza2ItPmxlbjsKICNlbHNlCS8qIENPTkZJR19JUkRBX0RZTkFNSUNfV0lORE9XICovCiAJCQkvKiBXaW5kb3cgaGFzIGJlZW4gYWRqdXN0ZWQgZm9yIHRoZSBtYXggcGFja2V0CmRpZmYgLS1naXQgYS9uZXQvaXJkYS9pcmxhcF9mcmFtZS5jIGIvbmV0L2lyZGEvaXJsYXBfZnJhbWUuYwppbmRleCA2ODgyMjJjLi44YzAwNDE2IDEwMDY0NAotLS0gYS9uZXQvaXJkYS9pcmxhcF9mcmFtZS5jCisrKyBiL25ldC9pcmRhL2lybGFwX2ZyYW1lLmMKQEAgLTg0OCw3ICs4NDgsNyBAQAogCSAqIHRob3VnaCBJckxBUCBpcyBjdXJyZW50bHkgc2VuZGluZyB0aGUgKmxhc3QqIGZyYW1lIG9mIHRoZQogCSAqIHR4LXdpbmRvdywgdGhlIGRyaXZlciBtb3N0IGxpa2VseSBoYXMgb25seSBqdXN0IHN0YXJ0ZWQKIAkgKiBzZW5kaW5nIHRoZSAqZmlyc3QqIGZyYW1lIG9mIHRoZSBzYW1lIHR4LXdpbmRvdy4KLQkgKiBJLmUuIHdlIGFyZSBhbHdheXMgYXQgdGhlIHZlcnkgYmVnaW5pbmcgb2Ygb3IgVHggd2luZG93LgorCSAqIEkuZS4gd2UgYXJlIGFsd2F5cyBhdCB0aGUgdmVyeSBiZWdpbm5pbmcgb2Ygb3IgVHggd2luZG93LgogCSAqIE5vdywgd2UgYXJlIHN1cHBvc2VkIHRvIHNldCB0aGUgZmluYWwgdGltZXIgZnJvbSB0aGUgZW5kCiAJICogb2Ygb3VyIHR4LXdpbmRvdyB0byBsZXQgdGhlIG90aGVyIHBlZXIgcmVwbHkuIFNvLCB3ZSBuZWVkCiAJICogdG8gYWRkIGV4dHJhIHRpbWUgdG8gY29tcGVuc2F0ZSBmb3IgdGhlIGZhY3QgdGhhdCB3ZQpkaWZmIC0tZ2l0IGEvbmV0L2lyZGEvaXJsbXBfZXZlbnQuYyBiL25ldC9pcmRhL2lybG1wX2V2ZW50LmMKaW5kZXggYzFmYjVkYi4uOTUwNWE3ZCAxMDA2NDQKLS0tIGEvbmV0L2lyZGEvaXJsbXBfZXZlbnQuYworKysgYi9uZXQvaXJkYS9pcmxtcF9ldmVudC5jCkBAIC00OTgsNyArNDk4LDcgQEAKIAlzd2l0Y2ggKGV2ZW50KSB7CiAjaWZkZWYgQ09ORklHX0lSREFfVUxUUkEKIAljYXNlIExNX1VEQVRBX0lORElDQVRJT046Ci0JCS8qIFRoaXMgaXMgbW9zdCBiaXp6YXJlLiBUaG9zZSBwYWNrZXRzIGFyZSAgYWthIHVucmVsaWFibGUKKwkJLyogVGhpcyBpcyBtb3N0IGJpemFycmUuIFRob3NlIHBhY2tldHMgYXJlICBha2EgdW5yZWxpYWJsZQogCQkgKiBjb25uZWN0ZWQsIGFrYSBJckxQVCBvciBTT0NLX0RHUkFNL0lSREFQUk9UT19VTklUREFUQS4KIAkJICogV2h5IGRvIHdlIHBhc3MgdGhlbSBhcyBVbHRyYSA/Pz8gSmVhbiBJSSAqLwogCQlpcmxtcF9jb25ubGVzc19kYXRhX2luZGljYXRpb24oc2VsZiwgc2tiKTsKZGlmZiAtLWdpdCBhL25ldC9pcmRhL2lybmV0L2lybmV0LmggYi9uZXQvaXJkYS9pcm5ldC9pcm5ldC5oCmluZGV4IDBkODJmZjUuLjk3OWVjYjIgMTAwNjQ0Ci0tLSBhL25ldC9pcmRhL2lybmV0L2lybmV0LmgKKysrIGIvbmV0L2lyZGEvaXJuZXQvaXJuZXQuaApAQCAtNzMsNyArNzMsNyBAQAogICogSW5maW5pdGUgdGhhbmtzIHRvIHRob3NlIGJyYXZlIHNvdWxzIGZvciBwcm92aWRpbmcgdGhlIGluZnJhc3RydWN0dXJlCiAgKiB1cG9uIHdoaWNoIElyTkVUIGlzIGJ1aWx0LgogICoKLSAqIFRoYW5rcyB0byBhbGwgbXkgY29sbGVndWVzIGluIEhQIGZvciBoZWxwaW5nIG1lLiBJbiBwYXJ0aWN1bGFyLAorICogVGhhbmtzIHRvIGFsbCBteSBjb2xsZWFndWVzIGluIEhQIGZvciBoZWxwaW5nIG1lLiBJbiBwYXJ0aWN1bGFyLAogICogdGhhbmtzIHRvIFNhbGlsIFByYWRoYW4gYW5kIEJpbGwgU2VycmEgZm9yIFcyayB0ZXN0aW5nLi4uCiAgKiBUaGFua3MgdG8gTHVpeiBNYWdhbGhhZXMgZm9yIGlybmV0ZCBhbmQgbXVjaCB0ZXN0aW5nLi4uCiAgKgpkaWZmIC0tZ2l0IGEvbmV0L2lyZGEvaXJxdWV1ZS5jIGIvbmV0L2lyZGEvaXJxdWV1ZS5jCmluZGV4IDg0OWFhZjAuLjk3MTVlNmUgMTAwNjQ0Ci0tLSBhL25ldC9pcmRhL2lycXVldWUuYworKysgYi9uZXQvaXJkYS9pcnF1ZXVlLmMKQEAgLTQwLDcgKzQwLDcgQEAKICAqCW8gdGhlIGhhc2ggZnVuY3Rpb24gZm9yIGludHMgaXMgcGF0aGV0aWMgKGJ1dCBjb3VsZCBiZSBjaGFuZ2VkKQogICoJbyBsb2NraW5nIGlzIHNvbWV0aW1lIHN1c3BpY2lvdXMgKGVzcGVjaWFsbHkgZHVyaW5nIGVudW1lcmF0aW9uKQogICoJbyBtb3N0IHVzZXJzIGhhdmUgb25seSBhIGZldyBlbGVtZW50cyAoPT0gb3ZlcmhlYWQpCi0gKglvIG1vc3QgdXNlcnMgbmV2ZXIgdXNlIHNlYWNoLCBzbyBkb24ndCBiZW5lZml0IGZyb20gaGFzaGluZworICoJbyBtb3N0IHVzZXJzIG5ldmVyIHVzZSBzZWFyY2gsIHNvIGRvbid0IGJlbmVmaXQgZnJvbSBoYXNoaW5nCiAgKiBQcm9ibGVtIGFscmVhZHkgZml4ZWQgOgogICoJbyBub3QgNjQgYml0IGNvbXBsaWFudCAobW9zdCB1c2VycyBkbyBoYXNodiA9IChpbnQpIHNlbGYpCiAgKglvIGhhc2hiaW5fcmVtb3ZlKCkgaXMgYnJva2VuID0+IHVzZSBoYXNoYmluX3JlbW92ZV90aGlzKCkKZGlmZiAtLWdpdCBhL25ldC9pcmRhL2lydHRwLmMgYi9uZXQvaXJkYS9pcnR0cC5jCmluZGV4IGY2MDU0ZjkuLjlkOWFmNDYgMTAwNjQ0Ci0tLSBhL25ldC9pcmRhL2lydHRwLmMKKysrIGIvbmV0L2lyZGEvaXJ0dHAuYwpAQCAtMTE5Myw3ICsxMTkzLDcgQEAKIC8qCiAgKiBGdW5jdGlvbiBpcnR0cF9jb25uZWN0X2NvbmZpcm0gKGhhbmRsZSwgcW9zLCBza2IpCiAgKgotICogICAgU2V2aWNlIHVzZXIgY29uZmlybXMgVFNBUCBjb25uZWN0aW9uIHdpdGggcGVlci4KKyAqICAgIFNlcnZpY2UgdXNlciBjb25maXJtcyBUU0FQIGNvbm5lY3Rpb24gd2l0aCBwZWVyLgogICoKICAqLwogc3RhdGljIHZvaWQgaXJ0dHBfY29ubmVjdF9jb25maXJtKHZvaWQgKmluc3RhbmNlLCB2b2lkICpzYXAsCmRpZmYgLS1naXQgYS9uZXQvaXJkYS9xb3MuYyBiL25ldC9pcmRhL3Fvcy5jCmluZGV4IDJiMDA5NzQuLjFiNTFiY2YgMTAwNjQ0Ci0tLSBhL25ldC9pcmRhL3Fvcy5jCisrKyBiL25ldC9pcmRhL3Fvcy5jCkBAIC0zOSwxNiArMzksMTYgQEAKICNpbmNsdWRlIDxuZXQvaXJkYS9pcmxhcF9mcmFtZS5oPgogCiAvKgotICogTWF4aW11bSB2YWx1ZXMgb2YgdGhlIGJhdWQgcmF0ZSB3ZSBuZWdvY2lhdGUgd2l0aCB0aGUgb3RoZXIgZW5kLgorICogTWF4aW11bSB2YWx1ZXMgb2YgdGhlIGJhdWQgcmF0ZSB3ZSBuZWdvdGlhdGUgd2l0aCB0aGUgb3RoZXIgZW5kLgogICogTW9zdCBvZnRlbiwgeW91IGRvbid0IGhhdmUgdG8gY2hhbmdlIHRoYXQsIGJlY2F1c2UgTGludXgtSXJEQSB3aWxsCiAgKiB1c2UgdGhlIG1heGltdW0gb2ZmZXJlZCBieSB0aGUgbGluayBsYXllciwgd2hpY2ggdXN1YWxseSB3b3JrcyBmaW5lLgogICogSW4gc29tZSB2ZXJ5IHJhcmUgY2FzZXMsIHlvdSBtYXkgd2FudCB0byBsaW1pdCBpdCB0byBsb3dlciBzcGVlZHMuLi4KICAqLwogaW50IHN5c2N0bF9tYXhfYmF1ZF9yYXRlID0gMTYwMDAwMDA7CiAvKgotICogTWF4aW11bSB2YWx1ZSBvZiB0aGUgbGFwIGRpc2Nvbm5lY3QgdGltZXIgd2UgbmVnb2NpYXRlIHdpdGggdGhlIG90aGVyIGVuZC4KKyAqIE1heGltdW0gdmFsdWUgb2YgdGhlIGxhcCBkaXNjb25uZWN0IHRpbWVyIHdlIG5lZ290aWF0ZSB3aXRoIHRoZSBvdGhlciBlbmQuCiAgKiBNb3N0IG9mdGVuLCB0aGUgdmFsdWUgYmVsb3cgcmVwcmVzZW50IHRoZSBiZXN0IGNvbXByb21pc2UsIGJ1dCBzb21lIHVzZXIKLSAqIG1heSB3YW50IHRvIGtlZXAgdGhlIExBUCBhbGl2ZSBsb25ndWVyIG9yIHNob3J0ZXIgaW4gY2FzZSBvZiBsaW5rIGZhaWx1cmUuCisgKiBtYXkgd2FudCB0byBrZWVwIHRoZSBMQVAgYWxpdmUgbG9uZ2VyIG9yIHNob3J0ZXIgaW4gY2FzZSBvZiBsaW5rIGZhaWx1cmUuCiAgKiBSZW1lbWJlciB0aGF0IHRoZSB0aHJlc2hvbGQgdGltZSAoZWFybHkgd2FybmluZykgaXMgZml4ZWQgdG8gM3MuLi4KICAqLwogaW50IHN5c2N0bF9tYXhfbm9yZXBseV90aW1lID0gMTI7CkBAIC00MTEsNyArNDExLDcgQEAKIAkgKiBGaXggdHggZGF0YSBzaXplIGFjY29yZGluZyB0byB1c2VyIGxpbWl0cyAtIEplYW4gSUkKIAkgKi8KIAlpZiAocW9zLT5kYXRhX3NpemUudmFsdWUgPiBzeXNjdGxfbWF4X3R4X2RhdGFfc2l6ZSkKLQkJLyogQWxsb3cgbm9uIGRpc2NyZXRlIGFkanVzdGVtZW50IHRvIGF2b2lkIGxvb3NpbmcgY2FwYWNpdHkgKi8KKwkJLyogQWxsb3cgbm9uIGRpc2NyZXRlIGFkanVzdGVtZW50IHRvIGF2b2lkIGxvc2luZyBjYXBhY2l0eSAqLwogCQlxb3MtPmRhdGFfc2l6ZS52YWx1ZSA9IHN5c2N0bF9tYXhfdHhfZGF0YV9zaXplOwogCS8qCiAJICogT3ZlcnJpZGUgVHggd2luZG93IGlmIHVzZXIgcmVxdWVzdCBpdC4gLSBKZWFuIElJCmRpZmYgLS1naXQgYS9uZXQvaXJkYS90aW1lci5jIGIvbmV0L2lyZGEvdGltZXIuYwppbmRleCAwMzM1YmEwLi5mNDE4Y2IyIDEwMDY0NAotLS0gYS9uZXQvaXJkYS90aW1lci5jCisrKyBiL25ldC9pcmRhL3RpbWVyLmMKQEAgLTU5LDcgKzU5LDcgQEAKIAkgKiBzbG90IHRpbWUsIHBsdXMgYWRkIHNvbWUgZXh0cmEgdGltZSB0byBwcm9wZXJseSByZWNlaXZlIHRoZSBsYXN0CiAJICogZGlzY292ZXJ5IHBhY2tldCAod2hpY2ggaXMgbG9uZ2VyIGR1ZSB0byBleHRyYSBkaXNjb3ZlcnkgaW5mbyksCiAJICogdG8gYXZvaWQgbWVzc2luZyB3aXRoIGZvciBpbmNvbW1pbmcgY29ubmVjdGlvbnMgcmVxdWVzdHMgYW5kCi0JICogdG8gYWNjb21vZGF0ZSBkZXZpY2VzIHRoYXQgcGVyZm9ybSBkaXNjb3Zlcnkgc2xvd2VyIHRoYW4gdXMuCisJICogdG8gYWNjb21tb2RhdGUgZGV2aWNlcyB0aGF0IHBlcmZvcm0gZGlzY292ZXJ5IHNsb3dlciB0aGFuIHVzLgogCSAqIEplYW4gSUkgKi8KIAl0aW1lb3V0ID0gKChzeXNjdGxfc2xvdF90aW1lb3V0ICogSFogLyAxMDAwKSAqIChTIC0gcykKIAkJICAgKyBYSURFWFRSQV9USU1FT1VUICsgU01BTExCVVNZX1RJTUVPVVQpOwpkaWZmIC0tZ2l0IGEvbmV0L2l1Y3YvYWZfaXVjdi5jIGIvbmV0L2l1Y3YvYWZfaXVjdi5jCmluZGV4IDk2MzdlNDUuLjk4NmIyYTUgMTAwNjQ0Ci0tLSBhL25ldC9pdWN2L2FmX2l1Y3YuYworKysgYi9uZXQvaXVjdi9hZl9pdWN2LmMKQEAgLTI1MCw3ICsyNTAsNyBAQAogICoJUFJNREFUQVswLi42XQlzb2NrZXQgZGF0YSAobWF4IDcgYnl0ZXMpOwogICoJUFJNREFUQVs3XQlzb2NrZXQgZGF0YSBsZW5ndGggdmFsdWUgKGxlbiBpcyAweGZmIC0gUFJNREFUQVs3XSkKICAqCi0gKiBUaGUgc29ja2V0IGRhdGEgbGVuZ3RoIGlzIGNvbXB1dGVkIGJ5IHN1YnN0cmFjdGluZyB0aGUgc29ja2V0IGRhdGEgbGVuZ3RoCisgKiBUaGUgc29ja2V0IGRhdGEgbGVuZ3RoIGlzIGNvbXB1dGVkIGJ5IHN1YnRyYWN0aW5nIHRoZSBzb2NrZXQgZGF0YSBsZW5ndGgKICAqIHZhbHVlIGZyb20gMHhGRi4KICAqIElmIHRoZSBzb2NrZXQgZGF0YSBsZW4gaXMgZ3JlYXRlciA3LCB0aGVuIFBSTURBVEEgY2FuIGJlIHVzZWQgZm9yIHNwZWNpYWwKICAqIG5vdGlmaWNhdGlvbnMgKHNlZSBpdWN2X3NvY2tfc2h1dGRvd24pOyBhbmQgZnVydGhlciwKZGlmZiAtLWdpdCBhL25ldC9pdWN2L2l1Y3YuYyBiL25ldC9pdWN2L2l1Y3YuYwppbmRleCAxZWU1ZGFiLi44ZjE1NmJkIDEwMDY0NAotLS0gYS9uZXQvaXVjdi9pdWN2LmMKKysrIGIvbmV0L2l1Y3YvaXVjdi5jCkBAIC03MzUsNyArNzM1LDcgQEAKIAlzdHJ1Y3QgaXVjdl9pcnFfbGlzdCAqcCwgKm47CiAKIAkvKgotCSAqIFdoZW4gYSBwYXRoIGlzIHNldmVyZWQsIHRoZSBwYXRoaWQgY2FuIGJlIHJldXNlZCBpbW1lZGlhdGx5CisJICogV2hlbiBhIHBhdGggaXMgc2V2ZXJlZCwgdGhlIHBhdGhpZCBjYW4gYmUgcmV1c2VkIGltbWVkaWF0ZWx5CiAJICogb24gYSBpdWN2IGNvbm5lY3Qgb3IgYSBjb25uZWN0aW9uIHBlbmRpbmcgaW50ZXJydXB0LiBSZW1vdmUKIAkgKiBhbGwgZW50cmllcyBmcm9tIHRoZSB0YXNrIHF1ZXVlIHRoYXQgcmVmZXIgdG8gYSBzdGFsZSBwYXRoaWQKIAkgKiAoaXVjdl9wYXRoX3RhYmxlW2l4XSA9PSBOVUxMKS4gT25seSB0aGVuIGRvIHRoZSBpdWN2IGNvbm5lY3QKQEAgLTgwNyw3ICs4MDcsNyBAQAogCXNwaW5fbG9ja19iaCgmaXVjdl90YWJsZV9sb2NrKTsKIAkvKiBSZW1vdmUgaGFuZGxlciBmcm9tIHRoZSBpdWN2X2hhbmRsZXJfbGlzdC4gKi8KIAlsaXN0X2RlbF9pbml0KCZoYW5kbGVyLT5saXN0KTsKLQkvKiBTZXZlciBhbGwgcGF0aGlkcyBzdGlsbCByZWZlcmluZyB0byB0aGUgaGFuZGxlci4gKi8KKwkvKiBTZXZlciBhbGwgcGF0aGlkcyBzdGlsbCByZWZlcnJpbmcgdG8gdGhlIGhhbmRsZXIuICovCiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHAsIG4sICZoYW5kbGVyLT5wYXRocywgbGlzdCkgewogCQlpdWN2X3NldmVyX3BhdGhpZChwLT5wYXRoaWQsIE5VTEwpOwogCQlpdWN2X3BhdGhfdGFibGVbcC0+cGF0aGlkXSA9IE5VTEw7CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvaWVlZTgwMjExX2kuaCBiL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCmluZGV4IGE0MDQwMTcuLmMxODM5NmMgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCisrKyBiL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCkBAIC05Nyw3ICs5Nyw3IEBACiAJc2l6ZV90IHN1cHBfcmF0ZXNfbGVuOwogCiAJLyoKLQkgKiBEdXJpbmcgYXNzb2NhdGlvbiwgd2Ugc2F2ZSBhbiBFUlAgdmFsdWUgZnJvbSBhIHByb2JlIHJlc3BvbnNlIHNvCisJICogRHVyaW5nIGFzc29jaWF0aW9uLCB3ZSBzYXZlIGFuIEVSUCB2YWx1ZSBmcm9tIGEgcHJvYmUgcmVzcG9uc2Ugc28KIAkgKiB0aGF0IHdlIGNhbiBmZWVkIEVSUCBpbmZvIHRvIHRoZSBkcml2ZXIgd2hlbiBoYW5kbGluZyB0aGUKIAkgKiBhc3NvY2lhdGlvbiBjb21wbGV0ZXMuIHRoZXNlIGZpZWxkcyBwcm9iYWJseSB3b24ndCBiZSB1cC10by1kYXRlCiAJICogb3RoZXJ3aXNlLCB5b3UgcHJvYmFibHkgZG9uJ3Qgd2FudCB0byB1c2UgdGhlbS4KZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9tZXNoX3BhdGh0YmwuYyBiL25ldC9tYWM4MDIxMS9tZXNoX3BhdGh0YmwuYwppbmRleCA4ZDY1YjQ3Li4zMzZjYTlkIDEwMDY0NAotLS0gYS9uZXQvbWFjODAyMTEvbWVzaF9wYXRodGJsLmMKKysrIGIvbmV0L21hYzgwMjExL21lc2hfcGF0aHRibC5jCkBAIC02MjgsNyArNjI4LDcgQEAKICAqCiAgKiBAbXBhdGg6IG1lc2ggcGF0aCB3aG9zZSBxdWV1ZSBoYXMgdG8gYmUgZnJlZWQKICAqCi0gKiBMb2NraW5nOiB0aGUgZnVuY3Rpb24gbXVzdCBtZSBjYWxsZWQgd2l0aGluZyBhIHJjdV9yZWFkX2xvY2sgcmVnaW9uCisgKiBMb2NraW5nOiB0aGUgZnVuY3Rpb24gbXVzdCBtZSBjYWxsZWQgd2l0aGluIGEgcmN1X3JlYWRfbG9jayByZWdpb24KICAqLwogdm9pZCBtZXNoX3BhdGhfZmx1c2hfcGVuZGluZyhzdHJ1Y3QgbWVzaF9wYXRoICptcGF0aCkKIHsKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9yYzgwMjExX21pbnN0cmVsX2h0LmMgYi9uZXQvbWFjODAyMTEvcmM4MDIxMV9taW5zdHJlbF9odC5jCmluZGV4IGRiZGViZWRhLi5jMDZhYTNhIDEwMDY0NAotLS0gYS9uZXQvbWFjODAyMTEvcmM4MDIxMV9taW5zdHJlbF9odC5jCisrKyBiL25ldC9tYWM4MDIxMS9yYzgwMjExX21pbnN0cmVsX2h0LmMKQEAgLTI1OSw3ICsyNTksNyBAQAogCQl9CiAJfQogCi0JLyogdHJ5IHRvIHNhbXBsZSB1cCB0byBoYWxmIG9mIHRoZSBhdmFpbGJsZSByYXRlcyBkdXJpbmcgZWFjaCBpbnRlcnZhbCAqLworCS8qIHRyeSB0byBzYW1wbGUgdXAgdG8gaGFsZiBvZiB0aGUgYXZhaWxhYmxlIHJhdGVzIGR1cmluZyBlYWNoIGludGVydmFsICovCiAJbWktPnNhbXBsZV9jb3VudCAqPSA0OwogCiAJY3VyX3Byb2IgPSAwOwpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL3JjODAyMTFfcGlkLmggYi9uZXQvbWFjODAyMTEvcmM4MDIxMV9waWQuaAppbmRleCA2NTEwZjhlLi4xOTExMWM3IDEwMDY0NAotLS0gYS9uZXQvbWFjODAyMTEvcmM4MDIxMV9waWQuaAorKysgYi9uZXQvbWFjODAyMTEvcmM4MDIxMV9waWQuaApAQCAtNzcsNyArNzcsNyBAQAogfTsKIAogc3RydWN0IHJjX3BpZF9ldmVudCB7Ci0JLyogVGhlIHRpbWUgd2hlbiB0aGUgZXZlbnQgb2NjdXJlZCAqLworCS8qIFRoZSB0aW1lIHdoZW4gdGhlIGV2ZW50IG9jY3VycmVkICovCiAJdW5zaWduZWQgbG9uZyB0aW1lc3RhbXA7CiAKIAkvKiBFdmVudCBJRCBudW1iZXIgKi8KZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9yeC5jIGIvbmV0L21hYzgwMjExL3J4LmMKaW5kZXggYWE1Y2MzNy4uYzVkNDUzMCAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3J4LmMKKysrIGIvbmV0L21hYzgwMjExL3J4LmMKQEAgLTM4MSw3ICszODEsNyBAQAogICogc3BlY3Mgd2VyZSBzYW5lIGVub3VnaCB0aGlzIHRpbWUgYXJvdW5kIHRvIHJlcXVpcmUgcGFkZGluZyBlYWNoIEEtTVNEVQogICogc3ViZnJhbWUgdG8gYSBsZW5ndGggdGhhdCBpcyBhIG11bHRpcGxlIG9mIGZvdXIuCiAgKgotICogUGFkZGluZyBsaWtlIEF0aGVyb3MgaGFyZHdhcmUgYWRkcyB3aGljaCBpcyBpbmJldHdlZW4gdGhlIDgwMi4xMSBoZWFkZXIgYW5kCisgKiBQYWRkaW5nIGxpa2UgQXRoZXJvcyBoYXJkd2FyZSBhZGRzIHdoaWNoIGlzIGJldHdlZW4gdGhlIDgwMi4xMSBoZWFkZXIgYW5kCiAgKiB0aGUgcGF5bG9hZCBpcyBub3Qgc3VwcG9ydGVkLCB0aGUgZHJpdmVyIGlzIHJlcXVpcmVkIHRvIG1vdmUgdGhlIDgwMi4xMQogICogaGVhZGVyIHRvIGJlIGRpcmVjdGx5IGluIGZyb250IG9mIHRoZSBwYXlsb2FkIGluIHRoYXQgY2FzZS4KICAqLwpAQCAtMjU0MSw3ICsyNTQxLDYgQEAKIAkJICogc2FtZSBUSUQgZnJvbSB0aGUgc2FtZSBzdGF0aW9uCiAJCSAqLwogCQlyeC0+c2tiID0gc2tiOwotCQlyeC0+ZmxhZ3MgPSAwOwogCiAJCUNBTExfUlhIKGllZWU4MDIxMV9yeF9oX2RlY3J5cHQpCiAJCUNBTExfUlhIKGllZWU4MDIxMV9yeF9oX2NoZWNrX21vcmVfZGF0YSkKQEAgLTI2MTIsNiArMjYxMSw3IEBACiAJCS5zZGF0YSA9IHN0YS0+c2RhdGEsCiAJCS5sb2NhbCA9IHN0YS0+bG9jYWwsCiAJCS5xdWV1ZSA9IHRpZCwKKwkJLmZsYWdzID0gMCwKIAl9OwogCXN0cnVjdCB0aWRfYW1wZHVfcnggKnRpZF9hZ2dfcng7CiAKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5jIGIvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKaW5kZXggZDAzMTFhMy4uMTNlOGMzMCAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKKysrIGIvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKQEAgLTQ3LDkgKzQ3LDkgQEAKICAqIFN0YXRpb24gZW50cmllcyBhcmUgYWRkZWQgYnkgbWFjODAyMTEgd2hlbiB5b3UgZXN0YWJsaXNoIGEgbGluayB3aXRoIGEKICAqIHBlZXIuIFRoaXMgbWVhbnMgZGlmZmVyZW50IHRoaW5ncyBmb3IgdGhlIGRpZmZlcmVudCB0eXBlIG9mIGludGVyZmFjZXMKICAqIHdlIHN1cHBvcnQuIEZvciBhIHJlZ3VsYXIgc3RhdGlvbiB0aGlzIG1lYW4gd2UgYWRkIHRoZSBBUCBzdGEgd2hlbiB3ZQotICogcmVjZWl2ZSBhbiBhc3NvY2F0aW9uIHJlc3BvbnNlIGZyb20gdGhlIEFQLiBGb3IgSUJTUyB0aGlzIG9jY3VycyB3aGVuCisgKiByZWNlaXZlIGFuIGFzc29jaWF0aW9uIHJlc3BvbnNlIGZyb20gdGhlIEFQLiBGb3IgSUJTUyB0aGlzIG9jY3VycyB3aGVuCiAgKiBnZXQgdG8ga25vdyBhYm91dCBhIHBlZXIgb24gdGhlIHNhbWUgSUJTUy4gRm9yIFdEUyB3ZSBhZGQgdGhlIHN0YSBmb3IKLSAqIHRoZSBwZWVyIGltZWRpYXRlbHkgdXBvbiBkZXZpY2Ugb3Blbi4gV2hlbiB1c2luZyBBUCBtb2RlIHdlIGFkZCBzdGF0aW9ucworICogdGhlIHBlZXIgaW1tZWRpYXRlbHkgdXBvbiBkZXZpY2Ugb3Blbi4gV2hlbiB1c2luZyBBUCBtb2RlIHdlIGFkZCBzdGF0aW9ucwogICogZm9yIGVhY2ggcmVzcGVjdGl2ZSBzdGF0aW9uIHVwb24gcmVxdWVzdCBmcm9tIHVzZXJzcGFjZSB0aHJvdWdoIG5sODAyMTEuCiAgKgogICogSW4gb3JkZXIgdG8gcmVtb3ZlIGEgU1RBIGluZm8gc3RydWN0dXJlLCB2YXJpb3VzIHN0YV9pbmZvX2Rlc3Ryb3lfKigpCmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvc3RhX2luZm8uaCBiL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oCmluZGV4IDU3NjgxMTQuLmIyZjk1OTYgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oCisrKyBiL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oCkBAIC0xNzMsNyArMTczLDcgQEAKIC8qKgogICogZW51bSBwbGlua19zdGF0ZSAtIHN0YXRlIG9mIGEgbWVzaCBwZWVyIGxpbmsgZmluaXRlIHN0YXRlIG1hY2hpbmUKICAqCi0gKiBAUExJTktfTElTVEVOOiBpbml0aWFsIHN0YXRlLCBjb25zaWRlcmVkIHRoZSBpbXBsaWNpdCBzdGF0ZSBvZiBub24gZXhpc3RhbnQKKyAqIEBQTElOS19MSVNURU46IGluaXRpYWwgc3RhdGUsIGNvbnNpZGVyZWQgdGhlIGltcGxpY2l0IHN0YXRlIG9mIG5vbiBleGlzdGVudAogICogCW1lc2ggcGVlciBsaW5rcwogICogQFBMSU5LX09QTl9TTlQ6IG1lc2ggcGxpbmsgb3BlbiBmcmFtZSBoYXMgYmVlbiBzZW50IHRvIHRoaXMgbWVzaCBwZWVyCiAgKiBAUExJTktfT1BOX1JDVkQ6IG1lc2ggcGxpbmsgb3BlbiBmcmFtZSBoYXMgYmVlbiByZWNlaXZlZCBmcm9tIHRoaXMgbWVzaCBwZWVyCmRpZmYgLS1naXQgYS9uZXQvbmV0ZmlsdGVyL0tjb25maWcgYi9uZXQvbmV0ZmlsdGVyL0tjb25maWcKaW5kZXggYzNmOTg4YS4uMzJiZmY2ZCAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9LY29uZmlnCisrKyBiL25ldC9uZXRmaWx0ZXIvS2NvbmZpZwpAQCAtNjUyLDcgKzY1Miw2IEBACiBjb25maWcgTkVURklMVEVSX1hUX01BVENIX0FERFJUWVBFCiAJdHJpc3RhdGUgJyJhZGRydHlwZSIgYWRkcmVzcyB0eXBlIG1hdGNoIHN1cHBvcnQnCiAJZGVwZW5kcyBvbiBORVRGSUxURVJfQURWQU5DRUQKLQlkZXBlbmRzIG9uIChJUFY2IHx8IElQVjY9bikKIAktLS1oZWxwLS0tCiAJICBUaGlzIG9wdGlvbiBhbGxvd3MgeW91IHRvIG1hdGNoIHdoYXQgcm91dGluZyB0aGlua3Mgb2YgYW4gYWRkcmVzcywKIAkgIGVnLiBVTklDQVNULCBMT0NBTCwgQlJPQURDQVNULCAuLi4KZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2JpdG1hcF9pcC5jIGIvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfYml0bWFwX2lwLmMKaW5kZXggYmNhOTY5OS4uYTExM2ZmMCAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfYml0bWFwX2lwLmMKKysrIGIvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfYml0bWFwX2lwLmMKQEAgLTMzOCw4ICszMzgsNyBAQAogCU5MQV9QVVRfSVBBRERSNChza2IsIElQU0VUX0FUVFJfSVBfVE8sIGh0b25sKG1hcC0+bGFzdF9pcCkpOwogCWlmIChtYXAtPm5ldG1hc2sgIT0gMzIpCiAJCU5MQV9QVVRfVTgoc2tiLCBJUFNFVF9BVFRSX05FVE1BU0ssIG1hcC0+bmV0bWFzayk7Ci0JTkxBX1BVVF9ORVQzMihza2IsIElQU0VUX0FUVFJfUkVGRVJFTkNFUywKLQkJICAgICAgaHRvbmwoYXRvbWljX3JlYWQoJnNldC0+cmVmKSAtIDEpKTsKKwlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9SRUZFUkVOQ0VTLCBodG9ubChzZXQtPnJlZiAtIDEpKTsKIAlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9NRU1TSVpFLAogCQkgICAgICBodG9ubChzaXplb2YoKm1hcCkgKyBtYXAtPm1lbXNpemUpKTsKIAlpZiAod2l0aF90aW1lb3V0KG1hcC0+dGltZW91dCkpCmRpZmYgLS1naXQgYS9uZXQvbmV0ZmlsdGVyL2lwc2V0L2lwX3NldF9iaXRtYXBfaXBtYWMuYyBiL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2JpdG1hcF9pcG1hYy5jCmluZGV4IDVlNzkwMTcuLjAwYTMzMjQgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2JpdG1hcF9pcG1hYy5jCisrKyBiL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2JpdG1hcF9pcG1hYy5jCkBAIC00MzQsOCArNDM0LDcgQEAKIAkJZ290byBubGFfcHV0X2ZhaWx1cmU7CiAJTkxBX1BVVF9JUEFERFI0KHNrYiwgSVBTRVRfQVRUUl9JUCwgaHRvbmwobWFwLT5maXJzdF9pcCkpOwogCU5MQV9QVVRfSVBBRERSNChza2IsIElQU0VUX0FUVFJfSVBfVE8sIGh0b25sKG1hcC0+bGFzdF9pcCkpOwotCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX1JFRkVSRU5DRVMsCi0JCSAgICAgIGh0b25sKGF0b21pY19yZWFkKCZzZXQtPnJlZikgLSAxKSk7CisJTkxBX1BVVF9ORVQzMihza2IsIElQU0VUX0FUVFJfUkVGRVJFTkNFUywgaHRvbmwoc2V0LT5yZWYgLSAxKSk7CiAJTkxBX1BVVF9ORVQzMihza2IsIElQU0VUX0FUVFJfTUVNU0laRSwKIAkJICAgICAgaHRvbmwoc2l6ZW9mKCptYXApCiAJCQkgICAgKyAobWFwLT5sYXN0X2lwIC0gbWFwLT5maXJzdF9pcCArIDEpICogbWFwLT5kc2l6ZSkpOwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfYml0bWFwX3BvcnQuYyBiL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2JpdG1hcF9wb3J0LmMKaW5kZXggMTY1ZjA5Yi4uNmIzOGViOCAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfYml0bWFwX3BvcnQuYworKysgYi9uZXQvbmV0ZmlsdGVyL2lwc2V0L2lwX3NldF9iaXRtYXBfcG9ydC5jCkBAIC0zMjAsOCArMzIwLDcgQEAKIAkJZ290byBubGFfcHV0X2ZhaWx1cmU7CiAJTkxBX1BVVF9ORVQxNihza2IsIElQU0VUX0FUVFJfUE9SVCwgaHRvbnMobWFwLT5maXJzdF9wb3J0KSk7CiAJTkxBX1BVVF9ORVQxNihza2IsIElQU0VUX0FUVFJfUE9SVF9UTywgaHRvbnMobWFwLT5sYXN0X3BvcnQpKTsKLQlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9SRUZFUkVOQ0VTLAotCQkgICAgICBodG9ubChhdG9taWNfcmVhZCgmc2V0LT5yZWYpIC0gMSkpOworCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX1JFRkVSRU5DRVMsIGh0b25sKHNldC0+cmVmIC0gMSkpOwogCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX01FTVNJWkUsCiAJCSAgICAgIGh0b25sKHNpemVvZigqbWFwKSArIG1hcC0+bWVtc2l6ZSkpOwogCWlmICh3aXRoX3RpbWVvdXQobWFwLT50aW1lb3V0KSkKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2NvcmUuYyBiL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2NvcmUuYwppbmRleCBkNmI0ODIzLi45MTUyZTY5IDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL2lwc2V0L2lwX3NldF9jb3JlLmMKKysrIGIvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfY29yZS5jCkBAIC0yNiw2ICsyNiw3IEBACiAKIHN0YXRpYyBMSVNUX0hFQUQoaXBfc2V0X3R5cGVfbGlzdCk7CQkvKiBhbGwgcmVnaXN0ZXJlZCBzZXQgdHlwZXMgKi8KIHN0YXRpYyBERUZJTkVfTVVURVgoaXBfc2V0X3R5cGVfbXV0ZXgpOwkJLyogcHJvdGVjdHMgaXBfc2V0X3R5cGVfbGlzdCAqLworc3RhdGljIERFRklORV9SV0xPQ0soaXBfc2V0X3JlZl9sb2NrKTsJCS8qIHByb3RlY3RzIHRoZSBzZXQgcmVmcyAqLwogCiBzdGF0aWMgc3RydWN0IGlwX3NldCAqKmlwX3NldF9saXN0OwkJLyogYWxsIGluZGl2aWR1YWwgc2V0cyAqLwogc3RhdGljIGlwX3NldF9pZF90IGlwX3NldF9tYXggPSBDT05GSUdfSVBfU0VUX01BWDsgLyogbWF4IG51bWJlciBvZiBzZXRzICovCkBAIC0zMDEsMTMgKzMwMiwxOCBAQAogc3RhdGljIGlubGluZSB2b2lkCiBfX2lwX3NldF9nZXQoaXBfc2V0X2lkX3QgaW5kZXgpCiB7Ci0JYXRvbWljX2luYygmaXBfc2V0X2xpc3RbaW5kZXhdLT5yZWYpOworCXdyaXRlX2xvY2tfYmgoJmlwX3NldF9yZWZfbG9jayk7CisJaXBfc2V0X2xpc3RbaW5kZXhdLT5yZWYrKzsKKwl3cml0ZV91bmxvY2tfYmgoJmlwX3NldF9yZWZfbG9jayk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZAogX19pcF9zZXRfcHV0KGlwX3NldF9pZF90IGluZGV4KQogewotCWF0b21pY19kZWMoJmlwX3NldF9saXN0W2luZGV4XS0+cmVmKTsKKwl3cml0ZV9sb2NrX2JoKCZpcF9zZXRfcmVmX2xvY2spOworCUJVR19PTihpcF9zZXRfbGlzdFtpbmRleF0tPnJlZiA9PSAwKTsKKwlpcF9zZXRfbGlzdFtpbmRleF0tPnJlZi0tOworCXdyaXRlX3VubG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKIH0KIAogLyoKQEAgLTMyNCw3ICszMzAsNyBAQAogCXN0cnVjdCBpcF9zZXQgKnNldCA9IGlwX3NldF9saXN0W2luZGV4XTsKIAlpbnQgcmV0ID0gMDsKIAotCUJVR19PTihzZXQgPT0gTlVMTCB8fCBhdG9taWNfcmVhZCgmc2V0LT5yZWYpID09IDApOworCUJVR19PTihzZXQgPT0gTlVMTCk7CiAJcHJfZGVidWcoInNldCAlcywgaW5kZXggJXVcbiIsIHNldC0+bmFtZSwgaW5kZXgpOwogCiAJaWYgKGRpbSA8IHNldC0+dHlwZS0+ZGltZW5zaW9uIHx8CkBAIC0zNTYsNyArMzYyLDcgQEAKIAlzdHJ1Y3QgaXBfc2V0ICpzZXQgPSBpcF9zZXRfbGlzdFtpbmRleF07CiAJaW50IHJldDsKIAotCUJVR19PTihzZXQgPT0gTlVMTCB8fCBhdG9taWNfcmVhZCgmc2V0LT5yZWYpID09IDApOworCUJVR19PTihzZXQgPT0gTlVMTCk7CiAJcHJfZGVidWcoInNldCAlcywgaW5kZXggJXVcbiIsIHNldC0+bmFtZSwgaW5kZXgpOwogCiAJaWYgKGRpbSA8IHNldC0+dHlwZS0+ZGltZW5zaW9uIHx8CkBAIC0zNzgsNyArMzg0LDcgQEAKIAlzdHJ1Y3QgaXBfc2V0ICpzZXQgPSBpcF9zZXRfbGlzdFtpbmRleF07CiAJaW50IHJldCA9IDA7CiAKLQlCVUdfT04oc2V0ID09IE5VTEwgfHwgYXRvbWljX3JlYWQoJnNldC0+cmVmKSA9PSAwKTsKKwlCVUdfT04oc2V0ID09IE5VTEwpOwogCXByX2RlYnVnKCJzZXQgJXMsIGluZGV4ICV1XG4iLCBzZXQtPm5hbWUsIGluZGV4KTsKIAogCWlmIChkaW0gPCBzZXQtPnR5cGUtPmRpbWVuc2lvbiB8fApAQCAtMzk3LDcgKzQwMyw2IEBACiAgKiBGaW5kIHNldCBieSBuYW1lLCByZWZlcmVuY2UgaXQgb25jZS4gVGhlIHJlZmVyZW5jZSBtYWtlcyBzdXJlIHRoZQogICogdGhpbmcgcG9pbnRlZCB0bywgZG9lcyBub3QgZ28gYXdheSB1bmRlciBvdXIgZmVldC4KICAqCi0gKiBUaGUgbmZubCBtdXRleCBtdXN0IGFscmVhZHkgYmUgYWN0aXZhdGVkLgogICovCiBpcF9zZXRfaWRfdAogaXBfc2V0X2dldF9ieW5hbWUoY29uc3QgY2hhciAqbmFtZSwgc3RydWN0IGlwX3NldCAqKnNldCkKQEAgLTQyMywxNSArNDI4LDEyIEBACiAgKiByZWZlcmVuY2UgY291bnQgYnkgMS4gVGhlIGNhbGxlciBzaGFsbCBub3QgYXNzdW1lIHRoZSBpbmRleAogICogdG8gYmUgdmFsaWQsIGFmdGVyIGNhbGxpbmcgdGhpcyBmdW5jdGlvbi4KICAqCi0gKiBUaGUgbmZubCBtdXRleCBtdXN0IGFscmVhZHkgYmUgYWN0aXZhdGVkLgogICovCiB2b2lkCiBpcF9zZXRfcHV0X2J5aW5kZXgoaXBfc2V0X2lkX3QgaW5kZXgpCiB7Ci0JaWYgKGlwX3NldF9saXN0W2luZGV4XSAhPSBOVUxMKSB7Ci0JCUJVR19PTihhdG9taWNfcmVhZCgmaXBfc2V0X2xpc3RbaW5kZXhdLT5yZWYpID09IDApOworCWlmIChpcF9zZXRfbGlzdFtpbmRleF0gIT0gTlVMTCkKIAkJX19pcF9zZXRfcHV0KGluZGV4KTsKLQl9CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChpcF9zZXRfcHV0X2J5aW5kZXgpOwogCkBAIC00NDEsNyArNDQzLDYgQEAKICAqIGNhbid0IGJlIGRlc3Ryb3llZC4gVGhlIHNldCBjYW5ub3QgYmUgcmVuYW1lZCBkdWUgdG8KICAqIHRoZSByZWZlcmVuY2luZyBlaXRoZXIuCiAgKgotICogVGhlIG5mbmwgbXV0ZXggbXVzdCBhbHJlYWR5IGJlIGFjdGl2YXRlZC4KICAqLwogY29uc3QgY2hhciAqCiBpcF9zZXRfbmFtZV9ieWluZGV4KGlwX3NldF9pZF90IGluZGV4KQpAQCAtNDQ5LDcgKzQ1MCw3IEBACiAJY29uc3Qgc3RydWN0IGlwX3NldCAqc2V0ID0gaXBfc2V0X2xpc3RbaW5kZXhdOwogCiAJQlVHX09OKHNldCA9PSBOVUxMKTsKLQlCVUdfT04oYXRvbWljX3JlYWQoJnNldC0+cmVmKSA9PSAwKTsKKwlCVUdfT04oc2V0LT5yZWYgPT0gMCk7CiAKIAkvKiBSZWZlcmVuY2VkLCBzbyBpdCdzIHNhZmUgKi8KIAlyZXR1cm4gc2V0LT5uYW1lOwpAQCAtNTE1LDEwICs1MTYsNyBAQAogaXBfc2V0X25mbmxfcHV0KGlwX3NldF9pZF90IGluZGV4KQogewogCW5mbmxfbG9jaygpOwotCWlmIChpcF9zZXRfbGlzdFtpbmRleF0gIT0gTlVMTCkgewotCQlCVUdfT04oYXRvbWljX3JlYWQoJmlwX3NldF9saXN0W2luZGV4XS0+cmVmKSA9PSAwKTsKLQkJX19pcF9zZXRfcHV0KGluZGV4KTsKLQl9CisJaXBfc2V0X3B1dF9ieWluZGV4KGluZGV4KTsKIAluZm5sX3VubG9jaygpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoaXBfc2V0X25mbmxfcHV0KTsKQEAgLTUyNiw3ICs1MjQsNyBAQAogLyoKICAqIENvbW11bmljYXRpb24gcHJvdG9jb2wgd2l0aCB1c2Vyc3BhY2Ugb3ZlciBuZXRsaW5rLgogICoKLSAqIFdlIGFscmVhZHkgbG9ja2VkIGJ5IG5mbmxfbG9jay4KKyAqIFRoZSBjb21tYW5kcyBhcmUgc2VyaWFsaXplZCBieSB0aGUgbmZubCBtdXRleC4KICAqLwogCiBzdGF0aWMgaW5saW5lIGJvb2wKQEAgLTY1Nyw3ICs2NTUsNiBAQAogCQlyZXR1cm4gLUVOT01FTTsKIAlyd2xvY2tfaW5pdCgmc2V0LT5sb2NrKTsKIAlzdHJsY3B5KHNldC0+bmFtZSwgbmFtZSwgSVBTRVRfTUFYTkFNRUxFTik7Ci0JYXRvbWljX3NldCgmc2V0LT5yZWYsIDApOwogCXNldC0+ZmFtaWx5ID0gZmFtaWx5OwogCiAJLyoKQEAgLTY5MCw4ICs2ODcsOCBAQAogCiAJLyoKIAkgKiBIZXJlLCB3ZSBoYXZlIGEgdmFsaWQsIGNvbnN0cnVjdGVkIHNldCBhbmQgd2UgYXJlIHByb3RlY3RlZAotCSAqIGJ5IG5mbmxfbG9jay4gRmluZCB0aGUgZmlyc3QgZnJlZSBpbmRleCBpbiBpcF9zZXRfbGlzdCBhbmQKLQkgKiBjaGVjayBjbGFzaGluZy4KKwkgKiBieSB0aGUgbmZubCBtdXRleC4gRmluZCB0aGUgZmlyc3QgZnJlZSBpbmRleCBpbiBpcF9zZXRfbGlzdAorCSAqIGFuZCBjaGVjayBjbGFzaGluZy4KIAkgKi8KIAlpZiAoKHJldCA9IGZpbmRfZnJlZV9pZChzZXQtPm5hbWUsICZpbmRleCwgJmNsYXNoKSkgIT0gMCkgewogCQkvKiBJZiB0aGlzIGlzIHRoZSBzYW1lIHNldCBhbmQgcmVxdWVzdGVkLCBpZ25vcmUgZXJyb3IgKi8KQEAgLTc1MSwzMSArNzQ4LDUxIEBACiAJICAgICAgIGNvbnN0IHN0cnVjdCBubGF0dHIgKiBjb25zdCBhdHRyW10pCiB7CiAJaXBfc2V0X2lkX3QgaTsKKwlpbnQgcmV0ID0gMDsKIAogCWlmICh1bmxpa2VseShwcm90b2NvbF9mYWlsZWQoYXR0cikpKQogCQlyZXR1cm4gLUlQU0VUX0VSUl9QUk9UT0NPTDsKIAotCS8qIFJlZmVyZW5jZXMgYXJlIHByb3RlY3RlZCBieSB0aGUgbmZubCBtdXRleCAqLworCS8qIENvbW1hbmRzIGFyZSBzZXJpYWxpemVkIGFuZCByZWZlcmVuY2VzIGFyZQorCSAqIHByb3RlY3RlZCBieSB0aGUgaXBfc2V0X3JlZl9sb2NrLgorCSAqIEV4dGVybmFsIHN5c3RlbXMgKGkuZS4geHRfc2V0KSBtdXN0IGNhbGwKKwkgKiBpcF9zZXRfcHV0fGdldF9uZm5sXyogZnVuY3Rpb25zLCB0aGF0IHdheSB3ZQorCSAqIGNhbiBzYWZlbHkgY2hlY2sgcmVmZXJlbmNlcyBoZXJlLgorCSAqCisJICogbGlzdDpzZXQgdGltZXIgY2FuIG9ubHkgZGVjcmVtZW50IHRoZSByZWZlcmVuY2UKKwkgKiBjb3VudGVyLCBzbyBpZiBpdCdzIGFscmVhZHkgemVybywgd2UgY2FuIHByb2NlZWQKKwkgKiB3aXRob3V0IGhvbGRpbmcgdGhlIGxvY2suCisJICovCisJcmVhZF9sb2NrX2JoKCZpcF9zZXRfcmVmX2xvY2spOwogCWlmICghYXR0cltJUFNFVF9BVFRSX1NFVE5BTUVdKSB7CiAJCWZvciAoaSA9IDA7IGkgPCBpcF9zZXRfbWF4OyBpKyspIHsKLQkJCWlmIChpcF9zZXRfbGlzdFtpXSAhPSBOVUxMICYmCi0JCQkgICAgKGF0b21pY19yZWFkKCZpcF9zZXRfbGlzdFtpXS0+cmVmKSkpCi0JCQkJcmV0dXJuIC1JUFNFVF9FUlJfQlVTWTsKKwkJCWlmIChpcF9zZXRfbGlzdFtpXSAhPSBOVUxMICYmIGlwX3NldF9saXN0W2ldLT5yZWYpIHsKKwkJCQlyZXQgPSBJUFNFVF9FUlJfQlVTWTsKKwkJCQlnb3RvIG91dDsKKwkJCX0KIAkJfQorCQlyZWFkX3VubG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKIAkJZm9yIChpID0gMDsgaSA8IGlwX3NldF9tYXg7IGkrKykgewogCQkJaWYgKGlwX3NldF9saXN0W2ldICE9IE5VTEwpCiAJCQkJaXBfc2V0X2Rlc3Ryb3lfc2V0KGkpOwogCQl9CiAJfSBlbHNlIHsKIAkJaSA9IGZpbmRfc2V0X2lkKG5sYV9kYXRhKGF0dHJbSVBTRVRfQVRUUl9TRVROQU1FXSkpOwotCQlpZiAoaSA9PSBJUFNFVF9JTlZBTElEX0lEKQotCQkJcmV0dXJuIC1FTk9FTlQ7Ci0JCWVsc2UgaWYgKGF0b21pY19yZWFkKCZpcF9zZXRfbGlzdFtpXS0+cmVmKSkKLQkJCXJldHVybiAtSVBTRVRfRVJSX0JVU1k7CisJCWlmIChpID09IElQU0VUX0lOVkFMSURfSUQpIHsKKwkJCXJldCA9IC1FTk9FTlQ7CisJCQlnb3RvIG91dDsKKwkJfSBlbHNlIGlmIChpcF9zZXRfbGlzdFtpXS0+cmVmKSB7CisJCQlyZXQgPSAtSVBTRVRfRVJSX0JVU1k7CisJCQlnb3RvIG91dDsKKwkJfQorCQlyZWFkX3VubG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKIAogCQlpcF9zZXRfZGVzdHJveV9zZXQoaSk7CiAJfQogCXJldHVybiAwOworb3V0OgorCXJlYWRfdW5sb2NrX2JoKCZpcF9zZXRfcmVmX2xvY2spOworCXJldHVybiByZXQ7CiB9CiAKIC8qIEZsdXNoIHNldHMgKi8KQEAgLTgzNCw2ICs4NTEsNyBAQAogCXN0cnVjdCBpcF9zZXQgKnNldDsKIAljb25zdCBjaGFyICpuYW1lMjsKIAlpcF9zZXRfaWRfdCBpOworCWludCByZXQgPSAwOwogCiAJaWYgKHVubGlrZWx5KHByb3RvY29sX2ZhaWxlZChhdHRyKSB8fAogCQkgICAgIGF0dHJbSVBTRVRfQVRUUl9TRVROQU1FXSA9PSBOVUxMIHx8CkBAIC04NDMsMjUgKzg2MSwzMyBAQAogCXNldCA9IGZpbmRfc2V0KG5sYV9kYXRhKGF0dHJbSVBTRVRfQVRUUl9TRVROQU1FXSkpOwogCWlmIChzZXQgPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9FTlQ7Ci0JaWYgKGF0b21pY19yZWFkKCZzZXQtPnJlZikgIT0gMCkKLQkJcmV0dXJuIC1JUFNFVF9FUlJfUkVGRVJFTkNFRDsKKworCXJlYWRfbG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKKwlpZiAoc2V0LT5yZWYgIT0gMCkgeworCQlyZXQgPSAtSVBTRVRfRVJSX1JFRkVSRU5DRUQ7CisJCWdvdG8gb3V0OworCX0KIAogCW5hbWUyID0gbmxhX2RhdGEoYXR0cltJUFNFVF9BVFRSX1NFVE5BTUUyXSk7CiAJZm9yIChpID0gMDsgaSA8IGlwX3NldF9tYXg7IGkrKykgewogCQlpZiAoaXBfc2V0X2xpc3RbaV0gIT0gTlVMTCAmJgotCQkgICAgU1RSRVEoaXBfc2V0X2xpc3RbaV0tPm5hbWUsIG5hbWUyKSkKLQkJCXJldHVybiAtSVBTRVRfRVJSX0VYSVNUX1NFVE5BTUUyOworCQkgICAgU1RSRVEoaXBfc2V0X2xpc3RbaV0tPm5hbWUsIG5hbWUyKSkgeworCQkJcmV0ID0gLUlQU0VUX0VSUl9FWElTVF9TRVROQU1FMjsKKwkJCWdvdG8gb3V0OworCQl9CiAJfQogCXN0cm5jcHkoc2V0LT5uYW1lLCBuYW1lMiwgSVBTRVRfTUFYTkFNRUxFTik7CiAKLQlyZXR1cm4gMDsKK291dDoKKwlyZWFkX3VubG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKKwlyZXR1cm4gcmV0OwogfQogCiAvKiBTd2FwIHR3byBzZXRzIHNvIHRoYXQgbmFtZS9pbmRleCBwb2ludHMgdG8gdGhlIG90aGVyLgogICogUmVmZXJlbmNlcyBhbmQgc2V0IG5hbWVzIGFyZSBhbHNvIHN3YXBwZWQuCiAgKgotICogV2UgYXJlIHByb3RlY3RlZCBieSB0aGUgbmZubCBtdXRleCBhbmQgcmVmZXJlbmNlcyBhcmUKLSAqIG1hbmlwdWxhdGVkIG9ubHkgYnkgaG9sZGluZyB0aGUgbXV0ZXguIFRoZSBrZXJuZWwgaW50ZXJmYWNlcworICogVGhlIGNvbW1hbmRzIGFyZSBzZXJpYWxpemVkIGJ5IHRoZSBuZm5sIG11dGV4IGFuZCByZWZlcmVuY2VzIGFyZQorICogcHJvdGVjdGVkIGJ5IHRoZSBpcF9zZXRfcmVmX2xvY2suIFRoZSBrZXJuZWwgaW50ZXJmYWNlcwogICogZG8gbm90IGhvbGQgdGhlIG11dGV4IGJ1dCB0aGUgcG9pbnRlciBzZXR0aW5ncyBhcmUgYXRvbWljCiAgKiBzbyB0aGUgaXBfc2V0X2xpc3QgYWx3YXlzIGNvbnRhaW5zIHZhbGlkIHBvaW50ZXJzIHRvIHRoZSBzZXRzLgogICovCkBAIC04NzQsNyArOTAwLDYgQEAKIAlzdHJ1Y3QgaXBfc2V0ICpmcm9tLCAqdG87CiAJaXBfc2V0X2lkX3QgZnJvbV9pZCwgdG9faWQ7CiAJY2hhciBmcm9tX25hbWVbSVBTRVRfTUFYTkFNRUxFTl07Ci0JdTMyIGZyb21fcmVmOwogCiAJaWYgKHVubGlrZWx5KHByb3RvY29sX2ZhaWxlZChhdHRyKSB8fAogCQkgICAgIGF0dHJbSVBTRVRfQVRUUl9TRVROQU1FXSA9PSBOVUxMIHx8CkBAIC04OTMsMjMgKzkxOCwyMSBAQAogCXRvID0gaXBfc2V0X2xpc3RbdG9faWRdOwogCiAJLyogRmVhdHVyZXMgbXVzdCBub3QgY2hhbmdlLgotCSAqIE5vdCBhbiBhcnRpZmljYWwgcmVzdHJpY3Rpb24gYW55bW9yZSwgYXMgd2UgbXVzdCBwcmV2ZW50CisJICogTm90IGFuIGFydGlmaWNpYWwgcmVzdHJpY3Rpb24gYW55bW9yZSwgYXMgd2UgbXVzdCBwcmV2ZW50CiAJICogcG9zc2libGUgbG9vcHMgY3JlYXRlZCBieSBzd2FwcGluZyBpbiBzZXRsaXN0IHR5cGUgb2Ygc2V0cy4gKi8KIAlpZiAoIShmcm9tLT50eXBlLT5mZWF0dXJlcyA9PSB0by0+dHlwZS0+ZmVhdHVyZXMgJiYKIAkgICAgICBmcm9tLT50eXBlLT5mYW1pbHkgPT0gdG8tPnR5cGUtPmZhbWlseSkpCiAJCXJldHVybiAtSVBTRVRfRVJSX1RZUEVfTUlTTUFUQ0g7CiAKLQkvKiBObyBtYWdpYyBoZXJlOiByZWYgbXVuZ2luZyBwcm90ZWN0ZWQgYnkgdGhlIG5mbmxfbG9jayAqLwogCXN0cm5jcHkoZnJvbV9uYW1lLCBmcm9tLT5uYW1lLCBJUFNFVF9NQVhOQU1FTEVOKTsKLQlmcm9tX3JlZiA9IGF0b21pY19yZWFkKCZmcm9tLT5yZWYpOwotCiAJc3RybmNweShmcm9tLT5uYW1lLCB0by0+bmFtZSwgSVBTRVRfTUFYTkFNRUxFTik7Ci0JYXRvbWljX3NldCgmZnJvbS0+cmVmLCBhdG9taWNfcmVhZCgmdG8tPnJlZikpOwogCXN0cm5jcHkodG8tPm5hbWUsIGZyb21fbmFtZSwgSVBTRVRfTUFYTkFNRUxFTik7Ci0JYXRvbWljX3NldCgmdG8tPnJlZiwgZnJvbV9yZWYpOwogCisJd3JpdGVfbG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKKwlzd2FwKGZyb20tPnJlZiwgdG8tPnJlZik7CiAJaXBfc2V0X2xpc3RbZnJvbV9pZF0gPSB0bzsKIAlpcF9zZXRfbGlzdFt0b19pZF0gPSBmcm9tOworCXdyaXRlX3VubG9ja19iaCgmaXBfc2V0X3JlZl9sb2NrKTsKIAogCXJldHVybiAwOwogfQpAQCAtOTI2LDcgKzk0OSw3IEBACiB7CiAJaWYgKGNiLT5hcmdzWzJdKSB7CiAJCXByX2RlYnVnKCJyZWxlYXNlIHNldCAlc1xuIiwgaXBfc2V0X2xpc3RbY2ItPmFyZ3NbMV1dLT5uYW1lKTsKLQkJX19pcF9zZXRfcHV0KChpcF9zZXRfaWRfdCkgY2ItPmFyZ3NbMV0pOworCQlpcF9zZXRfcHV0X2J5aW5kZXgoKGlwX3NldF9pZF90KSBjYi0+YXJnc1sxXSk7CiAJfQogCXJldHVybiAwOwogfQpAQCAtMTA2OCw3ICsxMDkxLDcgQEAKIAkvKiBJZiB0aGVyZSB3YXMgYW4gZXJyb3Igb3Igc2V0IGlzIGRvbmUsIHJlbGVhc2Ugc2V0ICovCiAJaWYgKHJldCB8fCAhY2ItPmFyZ3NbMl0pIHsKIAkJcHJfZGVidWcoInJlbGVhc2Ugc2V0ICVzXG4iLCBpcF9zZXRfbGlzdFtpbmRleF0tPm5hbWUpOwotCQlfX2lwX3NldF9wdXQoaW5kZXgpOworCQlpcF9zZXRfcHV0X2J5aW5kZXgoaW5kZXgpOwogCX0KIAogCS8qIElmIHdlIGR1bXAgYWxsIHNldHMsIGNvbnRpbnVlIHdpdGggZHVtcGluZyBsYXN0IG9uZXMgKi8KZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2xpc3Rfc2V0LmMgYi9uZXQvbmV0ZmlsdGVyL2lwc2V0L2lwX3NldF9saXN0X3NldC5jCmluZGV4IGE0N2MzMjkuLmU5MTU5ZTkgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvaXBzZXQvaXBfc2V0X2xpc3Rfc2V0LmMKKysrIGIvbmV0L25ldGZpbHRlci9pcHNldC9pcF9zZXRfbGlzdF9zZXQuYwpAQCAtNDMsMTQgKzQzLDE5IEBACiBzdGF0aWMgaW5saW5lIHN0cnVjdCBzZXRfZWxlbSAqCiBsaXN0X3NldF9lbGVtKGNvbnN0IHN0cnVjdCBsaXN0X3NldCAqbWFwLCB1MzIgaWQpCiB7Ci0JcmV0dXJuIChzdHJ1Y3Qgc2V0X2VsZW0gKikoKGNoYXIgKiltYXAtPm1lbWJlcnMgKyBpZCAqIG1hcC0+ZHNpemUpOworCXJldHVybiAoc3RydWN0IHNldF9lbGVtICopKCh2b2lkICopbWFwLT5tZW1iZXJzICsgaWQgKiBtYXAtPmRzaXplKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3Qgc2V0X3RlbGVtICoKK2xpc3Rfc2V0X3RlbGVtKGNvbnN0IHN0cnVjdCBsaXN0X3NldCAqbWFwLCB1MzIgaWQpCit7CisJcmV0dXJuIChzdHJ1Y3Qgc2V0X3RlbGVtICopKCh2b2lkICopbWFwLT5tZW1iZXJzICsgaWQgKiBtYXAtPmRzaXplKTsKIH0KIAogc3RhdGljIGlubGluZSBib29sCiBsaXN0X3NldF90aW1lb3V0KGNvbnN0IHN0cnVjdCBsaXN0X3NldCAqbWFwLCB1MzIgaWQpCiB7Ci0JY29uc3Qgc3RydWN0IHNldF90ZWxlbSAqZWxlbSA9Ci0JCShjb25zdCBzdHJ1Y3Qgc2V0X3RlbGVtICopIGxpc3Rfc2V0X2VsZW0obWFwLCBpZCk7CisJY29uc3Qgc3RydWN0IHNldF90ZWxlbSAqZWxlbSA9IGxpc3Rfc2V0X3RlbGVtKG1hcCwgaWQpOwogCiAJcmV0dXJuIGlwX3NldF90aW1lb3V0X3Rlc3QoZWxlbS0+dGltZW91dCk7CiB9CkBAIC01OCwxOSArNjMsMTEgQEAKIHN0YXRpYyBpbmxpbmUgYm9vbAogbGlzdF9zZXRfZXhwaXJlZChjb25zdCBzdHJ1Y3QgbGlzdF9zZXQgKm1hcCwgdTMyIGlkKQogewotCWNvbnN0IHN0cnVjdCBzZXRfdGVsZW0gKmVsZW0gPQotCQkoY29uc3Qgc3RydWN0IHNldF90ZWxlbSAqKSBsaXN0X3NldF9lbGVtKG1hcCwgaWQpOworCWNvbnN0IHN0cnVjdCBzZXRfdGVsZW0gKmVsZW0gPSBsaXN0X3NldF90ZWxlbShtYXAsIGlkKTsKIAogCXJldHVybiBpcF9zZXRfdGltZW91dF9leHBpcmVkKGVsZW0tPnRpbWVvdXQpOwogfQogCi1zdGF0aWMgaW5saW5lIGludAotbGlzdF9zZXRfZXhpc3QoY29uc3Qgc3RydWN0IHNldF90ZWxlbSAqZWxlbSkKLXsKLQlyZXR1cm4gZWxlbS0+aWQgIT0gSVBTRVRfSU5WQUxJRF9JRCAmJgotCSAgICAgICAhaXBfc2V0X3RpbWVvdXRfZXhwaXJlZChlbGVtLT50aW1lb3V0KTsKLX0KLQogLyogU2V0IGxpc3Qgd2l0aG91dCBhbmQgd2l0aCB0aW1lb3V0ICovCiAKIHN0YXRpYyBpbnQKQEAgLTE0NiwxMSArMTQzLDExIEBACiAJc3RydWN0IHNldF90ZWxlbSAqZTsKIAogCWZvciAoOyBpIDwgbWFwLT5zaXplOyBpKyspIHsKLQkJZSA9IChzdHJ1Y3Qgc2V0X3RlbGVtICopbGlzdF9zZXRfZWxlbShtYXAsIGkpOworCQllID0gbGlzdF9zZXRfdGVsZW0obWFwLCBpKTsKIAkJc3dhcChlLT5pZCwgaWQpOworCQlzd2FwKGUtPnRpbWVvdXQsIHRpbWVvdXQpOwogCQlpZiAoZS0+aWQgPT0gSVBTRVRfSU5WQUxJRF9JRCkKIAkJCWJyZWFrOwotCQlzd2FwKGUtPnRpbWVvdXQsIHRpbWVvdXQpOwogCX0KIH0KIApAQCAtMTY0LDcgKzE2MSw3IEBACiAJCS8qIExhc3QgZWxlbWVudCByZXBsYWNlZDogZS5nLiBhZGQgbmV3LGJlZm9yZSxsYXN0ICovCiAJCWlwX3NldF9wdXRfYnlpbmRleChlLT5pZCk7CiAJaWYgKHdpdGhfdGltZW91dChtYXAtPnRpbWVvdXQpKQotCQlsaXN0X2VsZW1fdGFkZChtYXAsIGksIGlkLCB0aW1lb3V0KTsKKwkJbGlzdF9lbGVtX3RhZGQobWFwLCBpLCBpZCwgaXBfc2V0X3RpbWVvdXRfc2V0KHRpbWVvdXQpKTsKIAllbHNlCiAJCWxpc3RfZWxlbV9hZGQobWFwLCBpLCBpZCk7CiAKQEAgLTE3MiwxMSArMTY5LDExIEBACiB9CiAKIHN0YXRpYyBpbnQKLWxpc3Rfc2V0X2RlbChzdHJ1Y3QgbGlzdF9zZXQgKm1hcCwgaXBfc2V0X2lkX3QgaWQsIHUzMiBpKQorbGlzdF9zZXRfZGVsKHN0cnVjdCBsaXN0X3NldCAqbWFwLCB1MzIgaSkKIHsKIAlzdHJ1Y3Qgc2V0X2VsZW0gKmEgPSBsaXN0X3NldF9lbGVtKG1hcCwgaSksICpiOwogCi0JaXBfc2V0X3B1dF9ieWluZGV4KGlkKTsKKwlpcF9zZXRfcHV0X2J5aW5kZXgoYS0+aWQpOwogCiAJZm9yICg7IGkgPCBtYXAtPnNpemUgLSAxOyBpKyspIHsKIAkJYiA9IGxpc3Rfc2V0X2VsZW0obWFwLCBpICsgMSk7CkBAIC0zMDgsMTEgKzMwNSwxMSBAQAogCQkJCSAoYmVmb3JlID09IDAgfHwKIAkJCQkgIChiZWZvcmUgPiAwICYmCiAJCQkJICAgbmV4dF9pZF9lcShtYXAsIGksIHJlZmlkKSkpKQotCQkJCXJldCA9IGxpc3Rfc2V0X2RlbChtYXAsIGlkLCBpKTsKKwkJCQlyZXQgPSBsaXN0X3NldF9kZWwobWFwLCBpKTsKIAkJCWVsc2UgaWYgKGJlZm9yZSA8IDAgJiYKIAkJCQkgZWxlbS0+aWQgPT0gcmVmaWQgJiYKIAkJCQkgbmV4dF9pZF9lcShtYXAsIGksIGlkKSkKLQkJCQlyZXQgPSBsaXN0X3NldF9kZWwobWFwLCBpZCwgaSArIDEpOworCQkJCXJldCA9IGxpc3Rfc2V0X2RlbChtYXAsIGkgKyAxKTsKIAkJfQogCQlicmVhazsKIAlkZWZhdWx0OgpAQCAtMzY5LDggKzM2Niw3IEBACiAJTkxBX1BVVF9ORVQzMihza2IsIElQU0VUX0FUVFJfU0laRSwgaHRvbmwobWFwLT5zaXplKSk7CiAJaWYgKHdpdGhfdGltZW91dChtYXAtPnRpbWVvdXQpKQogCQlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9USU1FT1VULCBodG9ubChtYXAtPnRpbWVvdXQpKTsKLQlOTEFfUFVUX05FVDMyKHNrYiwgSVBTRVRfQVRUUl9SRUZFUkVOQ0VTLAotCQkgICAgICBodG9ubChhdG9taWNfcmVhZCgmc2V0LT5yZWYpIC0gMSkpOworCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX1JFRkVSRU5DRVMsIGh0b25sKHNldC0+cmVmIC0gMSkpOwogCU5MQV9QVVRfTkVUMzIoc2tiLCBJUFNFVF9BVFRSX01FTVNJWkUsCiAJCSAgICAgIGh0b25sKHNpemVvZigqbWFwKSArIG1hcC0+c2l6ZSAqIG1hcC0+ZHNpemUpKTsKIAlpcHNldF9uZXN0X2VuZChza2IsIG5lc3RlZCk7CkBAIC00NjEsMTYgKzQ1NywxMyBAQAogCXN0cnVjdCBzZXRfdGVsZW0gKmU7CiAJdTMyIGk7CiAKLQkvKiBXZSBydW4gcGFyYWxsZWwgd2l0aCBvdGhlciByZWFkZXJzICh0ZXN0IGVsZW1lbnQpCi0JICogYnV0IGFkZGluZy9kZWxldGluZyBuZXcgZW50cmllcyBpcyBsb2NrZWQgb3V0ICovCi0JcmVhZF9sb2NrX2JoKCZzZXQtPmxvY2spOwotCWZvciAoaSA9IG1hcC0+c2l6ZSAtIDE7IGkgPj0gMDsgaS0tKSB7Ci0JCWUgPSAoc3RydWN0IHNldF90ZWxlbSAqKSBsaXN0X3NldF9lbGVtKG1hcCwgaSk7Ci0JCWlmIChlLT5pZCAhPSBJUFNFVF9JTlZBTElEX0lEICYmCi0JCSAgICBsaXN0X3NldF9leHBpcmVkKG1hcCwgaSkpCi0JCQlsaXN0X3NldF9kZWwobWFwLCBlLT5pZCwgaSk7CisJd3JpdGVfbG9ja19iaCgmc2V0LT5sb2NrKTsKKwlmb3IgKGkgPSAwOyBpIDwgbWFwLT5zaXplOyBpKyspIHsKKwkJZSA9IGxpc3Rfc2V0X3RlbGVtKG1hcCwgaSk7CisJCWlmIChlLT5pZCAhPSBJUFNFVF9JTlZBTElEX0lEICYmIGxpc3Rfc2V0X2V4cGlyZWQobWFwLCBpKSkKKwkJCWxpc3Rfc2V0X2RlbChtYXAsIGkpOwogCX0KLQlyZWFkX3VubG9ja19iaCgmc2V0LT5sb2NrKTsKKwl3cml0ZV91bmxvY2tfYmgoJnNldC0+bG9jayk7CiAKIAltYXAtPmdjLmV4cGlyZXMgPSBqaWZmaWVzICsgSVBTRVRfR0NfUEVSSU9EKG1hcC0+dGltZW91dCkgKiBIWjsKIAlhZGRfdGltZXIoJm1hcC0+Z2MpOwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2Nvbm4uYyBiL25ldC9uZXRmaWx0ZXIvaXB2cy9pcF92c19jb25uLmMKaW5kZXggZjI4OTMwNi4uYzk3YmQ0NSAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2Nvbm4uYworKysgYi9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfY29ubi5jCkBAIC01OTUsNyArNTk1LDcgQEAKIAkJCWF0b21pY19pbmMoJmRlc3QtPmluYWN0Y29ubnMpOwogCX0gZWxzZSB7CiAJCS8qIEl0IGlzIGEgcGVyc2lzdGVudCBjb25uZWN0aW9uL3RlbXBsYXRlLCBzbyBpbmNyZWFzZQotCQkgICB0aGUgcGVyaXN0ZW50IGNvbm5lY3Rpb24gY291bnRlciAqLworCQkgICB0aGUgcGVyc2lzdGVudCBjb25uZWN0aW9uIGNvdW50ZXIgKi8KIAkJYXRvbWljX2luYygmZGVzdC0+cGVyc2lzdGNvbm5zKTsKIAl9CiAKQEAgLTY1Nyw3ICs2NTcsNyBAQAogCQl9CiAJfSBlbHNlIHsKIAkJLyogSXQgaXMgYSBwZXJzaXN0ZW50IGNvbm5lY3Rpb24vdGVtcGxhdGUsIHNvIGRlY3JlYXNlCi0JCSAgIHRoZSBwZXJpc3RlbnQgY29ubmVjdGlvbiBjb3VudGVyICovCisJCSAgIHRoZSBwZXJzaXN0ZW50IGNvbm5lY3Rpb24gY291bnRlciAqLwogCQlhdG9taWNfZGVjKCZkZXN0LT5wZXJzaXN0Y29ubnMpOwogCX0KIApkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2N0bC5jIGIvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2N0bC5jCmluZGV4IDMzNzMzYzguLmFlNDcwOTAgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvaXB2cy9pcF92c19jdGwuYworKysgYi9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfY3RsLmMKQEAgLTMxMjAsNyArMzEyMCw3IEBACiBzdGF0aWMgaW50IGlwX3ZzX2dlbmxfZHVtcF9kYWVtb25zKHN0cnVjdCBza19idWZmICpza2IsCiAJCQkJICAgc3RydWN0IG5ldGxpbmtfY2FsbGJhY2sgKmNiKQogewotCXN0cnVjdCBuZXQgKm5ldCA9IHNrYl9uZXQoc2tiKTsKKwlzdHJ1Y3QgbmV0ICpuZXQgPSBza2Jfc2tuZXQoc2tiKTsKIAlzdHJ1Y3QgbmV0bnNfaXB2cyAqaXB2cyA9IG5ldF9pcHZzKG5ldCk7CiAKIAltdXRleF9sb2NrKCZfX2lwX3ZzX211dGV4KTsKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvaXB2cy9pcF92c19sYmxjLmMgYi9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfbGJsYy5jCmluZGV4IGYyNzZkZjkuLjg3ZTQwZWEgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvaXB2cy9pcF92c19sYmxjLmMKKysrIGIvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2xibGMuYwpAQCAtMTMxLDcgKzEzMSw3IEBACiB7CiAJbGlzdF9kZWwoJmVuLT5saXN0KTsKIAkvKgotCSAqIFdlIGRvbid0IGtmcmVlIGRlc3QgYmVjYXVzZSBpdCBpcyByZWZlcmVkIGVpdGhlciBieSBpdHMgc2VydmljZQorCSAqIFdlIGRvbid0IGtmcmVlIGRlc3QgYmVjYXVzZSBpdCBpcyByZWZlcnJlZCBlaXRoZXIgYnkgaXRzIHNlcnZpY2UKIAkgKiBvciB0aGUgdHJhc2ggZGVzdCBsaXN0LgogCSAqLwogCWF0b21pY19kZWMoJmVuLT5kZXN0LT5yZWZjbnQpOwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2xibGNyLmMgYi9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfbGJsY3IuYwppbmRleCBjYjFjOTkxLi45MGY2MThhIDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfbGJsY3IuYworKysgYi9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfbGJsY3IuYwpAQCAtMTUyLDcgKzE1Miw3IEBACiAJd3JpdGVfbG9jaygmc2V0LT5sb2NrKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZSwgZXAsICZzZXQtPmxpc3QsIGxpc3QpIHsKIAkJLyoKLQkJICogV2UgZG9uJ3Qga2ZyZWUgZGVzdCBiZWNhdXNlIGl0IGlzIHJlZmVyZWQgZWl0aGVyCisJCSAqIFdlIGRvbid0IGtmcmVlIGRlc3QgYmVjYXVzZSBpdCBpcyByZWZlcnJlZCBlaXRoZXIKIAkJICogYnkgaXRzIHNlcnZpY2Ugb3IgYnkgdGhlIHRyYXNoIGRlc3QgbGlzdC4KIAkJICovCiAJCWF0b21pY19kZWMoJmUtPmRlc3QtPnJlZmNudCk7CmRpZmYgLS1naXQgYS9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfcHJvdG9fc2N0cC5jIGIvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX3Byb3RvX3NjdHAuYwppbmRleCBiMDI3Y2NjLi5kMTJlZDUzIDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfcHJvdG9fc2N0cC5jCisrKyBiL25ldC9uZXRmaWx0ZXIvaXB2cy9pcF92c19wcm90b19zY3RwLmMKQEAgLTU2Niw3ICs1NjYsNyBAQAogCSAqIFNIVVRET1dOIHNlbnQgZnJvbSB0aGUgY2xpZW50LCB3YWl0aW5mIGZvciBTSFVUIEFDSyBmcm9tIHRoZSBzZXJ2ZXIKIAkgKi8KIAkvKgotCSAqIFdlIHJlY2lldmVkIHRoZSBkYXRhIGNodWNrLCBrZWVwIHRoZSBzdGF0ZSB1bmNoYW5nZWQuIEkgYXNzdW1lCisJICogV2UgcmVjZWl2ZWQgdGhlIGRhdGEgY2h1Y2ssIGtlZXAgdGhlIHN0YXRlIHVuY2hhbmdlZC4gSSBhc3N1bWUKIAkgKiB0aGF0IHN0aWxsIGRhdGEgY2h1bmNrcyAgY2FuIGJlIHJlY2VpdmVkIGJ5IGJvdGggdGhlIHBlZXJzIGluCiAJICogU0hVRE9XTiBzdGF0ZQogCSAqLwpAQCAtNjMzLDcgKzYzMyw3IEBACiAJICogU0hVVERPV04gc2VudCBmcm9tIHRoZSBzZXJ2ZXIsIHdhaXRpbmYgZm9yIFNIVVRET1dOIEFDSyBmcm9tIGNsaWVudAogCSAqLwogCS8qCi0JICogV2UgcmVjaWV2ZWQgdGhlIGRhdGEgY2h1Y2ssIGtlZXAgdGhlIHN0YXRlIHVuY2hhbmdlZC4gSSBhc3N1bWUKKwkgKiBXZSByZWNlaXZlZCB0aGUgZGF0YSBjaHVjaywga2VlcCB0aGUgc3RhdGUgdW5jaGFuZ2VkLiBJIGFzc3VtZQogCSAqIHRoYXQgc3RpbGwgZGF0YSBjaHVuY2tzICBjYW4gYmUgcmVjZWl2ZWQgYnkgYm90aCB0aGUgcGVlcnMgaW4KIAkgKiBTSFVET1dOIHN0YXRlCiAJICovCkBAIC03MDEsNyArNzAxLDcgQEAKIAkgKiBTSFVURE9XTiBBQ0sgZnJvbSB0aGUgY2xpZW50LCBhd2FpdGluZyBmb3IgU0hVVERPV04gQ09NIGZyb20gc2VydmVyCiAJICovCiAJLyoKLQkgKiBXZSByZWNpZXZlZCB0aGUgZGF0YSBjaHVjaywga2VlcCB0aGUgc3RhdGUgdW5jaGFuZ2VkLiBJIGFzc3VtZQorCSAqIFdlIHJlY2VpdmVkIHRoZSBkYXRhIGNodWNrLCBrZWVwIHRoZSBzdGF0ZSB1bmNoYW5nZWQuIEkgYXNzdW1lCiAJICogdGhhdCBzdGlsbCBkYXRhIGNodW5ja3MgIGNhbiBiZSByZWNlaXZlZCBieSBib3RoIHRoZSBwZWVycyBpbgogCSAqIFNIVURPV04gc3RhdGUKIAkgKi8KQEAgLTc3MSw3ICs3NzEsNyBAQAogCSAqIFNIVVRET1dOIEFDSyBmcm9tIHRoZSBzZXJ2ZXIsIGF3YWl0aW5nIGZvciBTSFVURE9XTiBDT00gZnJvbSBjbGllbnQKIAkgKi8KIAkvKgotCSAqIFdlIHJlY2lldmVkIHRoZSBkYXRhIGNodWNrLCBrZWVwIHRoZSBzdGF0ZSB1bmNoYW5nZWQuIEkgYXNzdW1lCisJICogV2UgcmVjZWl2ZWQgdGhlIGRhdGEgY2h1Y2ssIGtlZXAgdGhlIHN0YXRlIHVuY2hhbmdlZC4gSSBhc3N1bWUKIAkgKiB0aGF0IHN0aWxsIGRhdGEgY2h1bmNrcyAgY2FuIGJlIHJlY2VpdmVkIGJ5IGJvdGggdGhlIHBlZXJzIGluCiAJICogU0hVRE9XTiBzdGF0ZQogCSAqLwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfY29yZS5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfY29yZS5jCmluZGV4IDk0MTI4NmMuLjJlMWMxMWYgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2NvcmUuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19jb3JlLmMKQEAgLTQ1Myw3ICs0NTMsNyBAQAogCSAgIFJFSkVDVCB3aWxsIGdpdmUgc3B1cmlvdXMgd2FybmluZ3MgaGVyZS4gKi8KIAkvKiBORl9DVF9BU1NFUlQoYXRvbWljX3JlYWQoJmN0LT5jdF9nZW5lcmFsLnVzZSkgPT0gMSk7ICovCiAKLQkvKiBObyBleHRlcm5hbCByZWZlcmVuY2VzIG1lYW5zIG5vb25lIGVsc2UgY291bGQgaGF2ZQorCS8qIE5vIGV4dGVybmFsIHJlZmVyZW5jZXMgbWVhbnMgbm8gb25lIGVsc2UgY291bGQgaGF2ZQogCSAgIGNvbmZpcm1lZCB1cy4gKi8KIAlORl9DVF9BU1NFUlQoIW5mX2N0X2lzX2NvbmZpcm1lZChjdCkpOwogCXByX2RlYnVnKCJDb25maXJtaW5nIGNvbm50cmFjayAlcFxuIiwgY3QpOwpAQCAtOTAxLDcgKzkwMSw3IEBACiAJcmV0ID0gbDNwcm90by0+Z2V0X2w0cHJvdG8oc2tiLCBza2JfbmV0d29ya19vZmZzZXQoc2tiKSwKIAkJCQkgICAmZGF0YW9mZiwgJnByb3RvbnVtKTsKIAlpZiAocmV0IDw9IDApIHsKLQkJcHJfZGVidWcoIm5vdCBwcmVwYXJlZCB0byB0cmFjayB5ZXQgb3IgZXJyb3Igb2NjdXJlZFxuIik7CisJCXByX2RlYnVnKCJub3QgcHJlcGFyZWQgdG8gdHJhY2sgeWV0IG9yIGVycm9yIG9jY3VycmVkXG4iKTsKIAkJTkZfQ1RfU1RBVF9JTkNfQVRPTUlDKG5ldCwgZXJyb3IpOwogCQlORl9DVF9TVEFUX0lOQ19BVE9NSUMobmV0LCBpbnZhbGlkKTsKIAkJcmV0ID0gLXJldDsKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2gzMjNfYXNuMS5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaDMyM19hc24xLmMKaW5kZXggODY3ODgyMy4uYmNkNWVkNiAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaDMyM19hc24xLmMKKysrIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaDMyM19hc24xLmMKQEAgLTYzMSw3ICs2MzEsNyBAQAogCQlDSEVDS19CT1VORChicywgMik7CiAJCWNvdW50ID0gKmJzLT5jdXIrKzsKIAkJY291bnQgPDw9IDg7Ci0JCWNvdW50ID0gKmJzLT5jdXIrKzsKKwkJY291bnQgKz0gKmJzLT5jdXIrKzsKIAkJYnJlYWs7CiAJY2FzZSBTRU1JOgogCQlCWVRFX0FMSUdOKGJzKTsKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2gzMjNfbWFpbi5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaDMyM19tYWluLmMKaW5kZXggNTMzYTE4My4uMThiMmNlNSAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaDMyM19tYWluLmMKKysrIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaDMyM19tYWluLmMKQEAgLTczMSwxMCArNzMxLDEwIEBACiAKIAkJbWVtc2V0KCZmbDIsIDAsIHNpemVvZihmbDIpKTsKIAkJZmwyLmRhZGRyID0gZHN0LT5pcDsKLQkJaWYgKCFhZmluZm8tPnJvdXRlKChzdHJ1Y3QgZHN0X2VudHJ5ICoqKSZydDEsCi0JCQkJICAgZmxvd2k0X3RvX2Zsb3dpKCZmbDEpKSkgewotCQkJaWYgKCFhZmluZm8tPnJvdXRlKChzdHJ1Y3QgZHN0X2VudHJ5ICoqKSZydDIsCi0JCQkJCSAgIGZsb3dpNF90b19mbG93aSgmZmwyKSkpIHsKKwkJaWYgKCFhZmluZm8tPnJvdXRlKCZpbml0X25ldCwgKHN0cnVjdCBkc3RfZW50cnkgKiopJnJ0MSwKKwkJCQkgICBmbG93aTRfdG9fZmxvd2koJmZsMSksIGZhbHNlKSkgeworCQkJaWYgKCFhZmluZm8tPnJvdXRlKCZpbml0X25ldCwgKHN0cnVjdCBkc3RfZW50cnkgKiopJnJ0MiwKKwkJCQkJICAgZmxvd2k0X3RvX2Zsb3dpKCZmbDIpLCBmYWxzZSkpIHsKIAkJCQlpZiAocnQxLT5ydF9nYXRld2F5ID09IHJ0Mi0+cnRfZ2F0ZXdheSAmJgogCQkJCSAgICBydDEtPmRzdC5kZXYgID09IHJ0Mi0+ZHN0LmRldikKIAkJCQkJcmV0ID0gMTsKQEAgLTc1NSwxMCArNzU1LDEwIEBACiAKIAkJbWVtc2V0KCZmbDIsIDAsIHNpemVvZihmbDIpKTsKIAkJaXB2Nl9hZGRyX2NvcHkoJmZsMi5kYWRkciwgJmRzdC0+aW42KTsKLQkJaWYgKCFhZmluZm8tPnJvdXRlKChzdHJ1Y3QgZHN0X2VudHJ5ICoqKSZydDEsCi0JCQkJICAgZmxvd2k2X3RvX2Zsb3dpKCZmbDEpKSkgewotCQkJaWYgKCFhZmluZm8tPnJvdXRlKChzdHJ1Y3QgZHN0X2VudHJ5ICoqKSZydDIsCi0JCQkJCSAgIGZsb3dpNl90b19mbG93aSgmZmwyKSkpIHsKKwkJaWYgKCFhZmluZm8tPnJvdXRlKCZpbml0X25ldCwgKHN0cnVjdCBkc3RfZW50cnkgKiopJnJ0MSwKKwkJCQkgICBmbG93aTZfdG9fZmxvd2koJmZsMSksIGZhbHNlKSkgeworCQkJaWYgKCFhZmluZm8tPnJvdXRlKCZpbml0X25ldCwgKHN0cnVjdCBkc3RfZW50cnkgKiopJnJ0MiwKKwkJCQkJICAgZmxvd2k2X3RvX2Zsb3dpKCZmbDIpLCBmYWxzZSkpIHsKIAkJCQlpZiAoIW1lbWNtcCgmcnQxLT5ydDZpX2dhdGV3YXksICZydDItPnJ0NmlfZ2F0ZXdheSwKIAkJCQkJICAgIHNpemVvZihydDEtPnJ0NmlfZ2F0ZXdheSkpICYmCiAJCQkJICAgIHJ0MS0+ZHN0LmRldiA9PSBydDItPmRzdC5kZXYpCmRpZmYgLS1naXQgYS9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19wcm90b19kY2NwLmMgYi9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19wcm90b19kY2NwLmMKaW5kZXggOWFlNTdjNS4uMmU2NjRhNiAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfcHJvdG9fZGNjcC5jCisrKyBiL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3Byb3RvX2RjY3AuYwpAQCAtOTgsNyArOTgsNyBAQAogI2RlZmluZSBzSVYJQ1RfRENDUF9JTlZBTElECiAKIC8qCi0gKiBEQ0NQIHN0YXRlIHRyYW5zaXN0aW9uIHRhYmxlCisgKiBEQ0NQIHN0YXRlIHRyYW5zaXRpb24gdGFibGUKICAqCiAgKiBUaGUgYXNzdW1wdGlvbiBpcyB0aGUgc2FtZSBhcyBmb3IgVENQIHRyYWNraW5nOgogICoKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3Byb3RvX3NjdHAuYyBiL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3Byb3RvX3NjdHAuYwppbmRleCA2ZjRlZTcwLi42NzcyYjExIDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19wcm90b19zY3RwLmMKKysrIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfcHJvdG9fc2N0cC5jCkBAIC0xMDcsOSArMTA3LDkgQEAKIC8qIGFib3J0ICAgICAgICAqLyB7c0NMLCBzQ0wsIHNDTCwgc0NMLCBzQ0wsIHNDTCwgc0NMLCBzQ0x9LAogLyogc2h1dGRvd24gICAgICovIHtzQ0wsIHNDTCwgc0NXLCBzQ0UsIHNTUywgc1NTLCBzU1IsIHNTQX0sCiAvKiBzaHV0ZG93bl9hY2sgKi8ge3NTQSwgc0NMLCBzQ1csIHNDRSwgc0VTLCBzU0EsIHNTQSwgc1NBfSwKLS8qIGVycm9yICAgICAgICAqLyB7c0NMLCBzQ0wsIHNDVywgc0NFLCBzRVMsIHNTUywgc1NSLCBzU0F9LC8qIENhbnQgaGF2ZSBTdGFsZSBjb29raWUqLworLyogZXJyb3IgICAgICAgICovIHtzQ0wsIHNDTCwgc0NXLCBzQ0UsIHNFUywgc1NTLCBzU1IsIHNTQX0sLyogQ2FuJ3QgaGF2ZSBTdGFsZSBjb29raWUqLwogLyogY29va2llX2VjaG8gICovIHtzQ0wsIHNDTCwgc0NFLCBzQ0UsIHNFUywgc1NTLCBzU1IsIHNTQX0sLyogNS4yLjQgLSBCaWcgVE9ETyAqLwotLyogY29va2llX2FjayAgICovIHtzQ0wsIHNDTCwgc0NXLCBzQ0UsIHNFUywgc1NTLCBzU1IsIHNTQX0sLyogQ2FudCBjb21lIGluIG9yaWcgZGlyICovCisvKiBjb29raWVfYWNrICAgKi8ge3NDTCwgc0NMLCBzQ1csIHNDRSwgc0VTLCBzU1MsIHNTUiwgc1NBfSwvKiBDYW4ndCBjb21lIGluIG9yaWcgZGlyICovCiAvKiBzaHV0ZG93bl9jb21wKi8ge3NDTCwgc0NMLCBzQ1csIHNDRSwgc0VTLCBzU1MsIHNTUiwgc0NMfQogCX0sCiAJewpAQCAtMTIxLDcgKzEyMSw3IEBACiAvKiBzaHV0ZG93biAgICAgKi8ge3NJViwgc0NMLCBzQ1csIHNDRSwgc1NSLCBzU1MsIHNTUiwgc1NBfSwKIC8qIHNodXRkb3duX2FjayAqLyB7c0lWLCBzQ0wsIHNDVywgc0NFLCBzRVMsIHNTQSwgc1NBLCBzU0F9LAogLyogZXJyb3IgICAgICAgICovIHtzSVYsIHNDTCwgc0NXLCBzQ0wsIHNFUywgc1NTLCBzU1IsIHNTQX0sCi0vKiBjb29raWVfZWNobyAgKi8ge3NJViwgc0NMLCBzQ1csIHNDRSwgc0VTLCBzU1MsIHNTUiwgc1NBfSwvKiBDYW50IGNvbWUgaW4gcmVwbHkgZGlyICovCisvKiBjb29raWVfZWNobyAgKi8ge3NJViwgc0NMLCBzQ1csIHNDRSwgc0VTLCBzU1MsIHNTUiwgc1NBfSwvKiBDYW4ndCBjb21lIGluIHJlcGx5IGRpciAqLwogLyogY29va2llX2FjayAgICovIHtzSVYsIHNDTCwgc0NXLCBzRVMsIHNFUywgc1NTLCBzU1IsIHNTQX0sCiAvKiBzaHV0ZG93bl9jb21wKi8ge3NJViwgc0NMLCBzQ1csIHNDRSwgc0VTLCBzU1MsIHNTUiwgc0NMfQogCX0KZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3NpcC5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfc2lwLmMKaW5kZXggYmNmNDdlYi4uMjM3Y2MxOSAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfc2lwLmMKKysrIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfc2lwLmMKQEAgLTcwNyw3ICs3MDcsNyBAQAogfQogCiAvKiBMb2NhdGUgYSBTRFAgaGVhZGVyIChvcHRpb25hbGx5IGEgc3Vic3RyaW5nIHdpdGhpbiB0aGUgaGVhZGVyIHZhbHVlKSwKLSAqIG9wdGlvbmFsbHkgc3RvcHBpbmcgYXQgdGhlIGZpcnN0IG9jY3VyZW5jZSBvZiB0aGUgdGVybSBoZWFkZXIsIHBhcnNlCisgKiBvcHRpb25hbGx5IHN0b3BwaW5nIGF0IHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZSB0ZXJtIGhlYWRlciwgcGFyc2UKICAqIGl0IGFuZCByZXR1cm4gdGhlIG9mZnNldCBhbmQgbGVuZ3RoIG9mIHRoZSBkYXRhIHdlJ3JlIGludGVyZXN0ZWQgaW4uCiAgKi8KIGludCBjdF9zaXBfZ2V0X3NkcF9oZWFkZXIoY29uc3Qgc3RydWN0IG5mX2Nvbm4gKmN0LCBjb25zdCBjaGFyICpkcHRyLApkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZl9xdWV1ZS5jIGIvbmV0L25ldGZpbHRlci9uZl9xdWV1ZS5jCmluZGV4IDVhYjIyZTIuLjViNDY2Y2QgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvbmZfcXVldWUuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mX3F1ZXVlLmMKQEAgLTEzNCw3ICsxMzQsNyBAQAogCWNvbnN0IHN0cnVjdCBuZl9hZmluZm8gKmFmaW5mbzsKIAljb25zdCBzdHJ1Y3QgbmZfcXVldWVfaGFuZGxlciAqcWg7CiAKLQkvKiBRVUVVRSA9PSBEUk9QIGlmIG5vb25lIGlzIHdhaXRpbmcsIHRvIGJlIHNhZmUuICovCisJLyogUVVFVUUgPT0gRFJPUCBpZiBubyBvbmUgaXMgd2FpdGluZywgdG8gYmUgc2FmZS4gKi8KIAlyY3VfcmVhZF9sb2NrKCk7CiAKIAlxaCA9IHJjdV9kZXJlZmVyZW5jZShxdWV1ZV9oYW5kbGVyW3BmXSk7CmRpZmYgLS1naXQgYS9uZXQvbmV0ZmlsdGVyL3h0X1RDUE1TUy5jIGIvbmV0L25ldGZpbHRlci94dF9UQ1BNU1MuYwppbmRleCA2ZTZiNDZjLi45ZTYzYjQzIDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL3h0X1RDUE1TUy5jCisrKyBiL25ldC9uZXRmaWx0ZXIveHRfVENQTVNTLmMKQEAgLTE2Niw3ICsxNjYsNyBAQAogCXJjdV9yZWFkX2xvY2soKTsKIAlhaSA9IG5mX2dldF9hZmluZm8oZmFtaWx5KTsKIAlpZiAoYWkgIT0gTlVMTCkKLQkJYWktPnJvdXRlKChzdHJ1Y3QgZHN0X2VudHJ5ICoqKSZydCwgJmZsKTsKKwkJYWktPnJvdXRlKCZpbml0X25ldCwgKHN0cnVjdCBkc3RfZW50cnkgKiopJnJ0LCAmZmwsIGZhbHNlKTsKIAlyY3VfcmVhZF91bmxvY2soKTsKIAogCWlmIChydCAhPSBOVUxMKSB7CmRpZmYgLS1naXQgYS9uZXQvbmV0ZmlsdGVyL3h0X2FkZHJ0eXBlLmMgYi9uZXQvbmV0ZmlsdGVyL3h0X2FkZHJ0eXBlLmMKaW5kZXggMjIyMGI4NS4uYjc3ZDM4MyAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci94dF9hZGRydHlwZS5jCisrKyBiL25ldC9uZXRmaWx0ZXIveHRfYWRkcnR5cGUuYwpAQCAtMzIsMTEgKzMyLDMyIEBACiBNT0RVTEVfQUxJQVMoImlwNnRfYWRkcnR5cGUiKTsKIAogI2lmIGRlZmluZWQoQ09ORklHX0lQNl9ORl9JUFRBQkxFUykgfHwgZGVmaW5lZChDT05GSUdfSVA2X05GX0lQVEFCTEVTX01PRFVMRSkKLXN0YXRpYyB1MzIgeHRfYWRkcnR5cGVfcnQ2X3RvX3R5cGUoY29uc3Qgc3RydWN0IHJ0Nl9pbmZvICpydCkKK3N0YXRpYyB1MzIgbWF0Y2hfbG9va3VwX3J0NihzdHJ1Y3QgbmV0ICpuZXQsIGNvbnN0IHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCisJCQkgICAgY29uc3Qgc3RydWN0IGluNl9hZGRyICphZGRyKQogeworCWNvbnN0IHN0cnVjdCBuZl9hZmluZm8gKmFmaW5mbzsKKwlzdHJ1Y3QgZmxvd2k2IGZsb3c7CisJc3RydWN0IHJ0Nl9pbmZvICpydDsKIAl1MzIgcmV0OworCWludCByb3V0ZV9lcnI7CiAKLQlpZiAoIXJ0KQorCW1lbXNldCgmZmxvdywgMCwgc2l6ZW9mKGZsb3cpKTsKKwlpcHY2X2FkZHJfY29weSgmZmxvdy5kYWRkciwgYWRkcik7CisJaWYgKGRldikKKwkJZmxvdy5mbG93aTZfb2lmID0gZGV2LT5pZmluZGV4OworCisJcmN1X3JlYWRfbG9jaygpOworCisJYWZpbmZvID0gbmZfZ2V0X2FmaW5mbyhORlBST1RPX0lQVjYpOworCWlmIChhZmluZm8gIT0gTlVMTCkKKwkJcm91dGVfZXJyID0gYWZpbmZvLT5yb3V0ZShuZXQsIChzdHJ1Y3QgZHN0X2VudHJ5ICoqKSZydCwKKwkJCQkJZmxvd2k2X3RvX2Zsb3dpKCZmbG93KSwgISFkZXYpOworCWVsc2UKKwkJcm91dGVfZXJyID0gMTsKKworCXJjdV9yZWFkX3VubG9jaygpOworCisJaWYgKHJvdXRlX2VycikKIAkJcmV0dXJuIFhUX0FERFJUWVBFX1VOUkVBQ0hBQkxFOwogCiAJaWYgKHJ0LT5ydDZpX2ZsYWdzICYgUlRGX1JFSkVDVCkKQEAgLTQ4LDYgKzY5LDkgQEAKIAkJcmV0IHw9IFhUX0FERFJUWVBFX0xPQ0FMOwogCWlmIChydC0+cnQ2aV9mbGFncyAmIFJURl9BTllDQVNUKQogCQlyZXQgfD0gWFRfQUREUlRZUEVfQU5ZQ0FTVDsKKworCisJZHN0X3JlbGVhc2UoJnJ0LT5kc3QpOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTY1LDE4ICs4OSw4IEBACiAJCXJldHVybiBmYWxzZTsKIAogCWlmICgoWFRfQUREUlRZUEVfTE9DQUwgfCBYVF9BRERSVFlQRV9BTllDQVNUIHwKLQkgICAgIFhUX0FERFJUWVBFX1VOUkVBQ0hBQkxFKSAmIG1hc2spIHsKLQkJc3RydWN0IHJ0Nl9pbmZvICpydDsKLQkJdTMyIHR5cGU7Ci0JCWludCBpZmluZGV4ID0gZGV2ID8gZGV2LT5pZmluZGV4IDogMDsKLQotCQlydCA9IHJ0Nl9sb29rdXAobmV0LCBhZGRyLCBOVUxMLCBpZmluZGV4LCAhIWRldik7Ci0KLQkJdHlwZSA9IHh0X2FkZHJ0eXBlX3J0Nl90b190eXBlKHJ0KTsKLQotCQlkc3RfcmVsZWFzZSgmcnQtPmRzdCk7Ci0JCXJldHVybiAhIShtYXNrICYgdHlwZSk7Ci0JfQorCSAgICAgWFRfQUREUlRZUEVfVU5SRUFDSEFCTEUpICYgbWFzaykKKwkJcmV0dXJuICEhKG1hc2sgJiBtYXRjaF9sb29rdXBfcnQ2KG5ldCwgZGV2LCBhZGRyKSk7CiAJcmV0dXJuIHRydWU7CiB9CiAKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIveHRfY29ubnRyYWNrLmMgYi9uZXQvbmV0ZmlsdGVyL3h0X2Nvbm50cmFjay5jCmluZGV4IDJjMDA4NmEuLjQ4MWE4NmYgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIveHRfY29ubnRyYWNrLmMKKysrIGIvbmV0L25ldGZpbHRlci94dF9jb25udHJhY2suYwpAQCAtMTk1LDcgKzE5NSw3IEBACiAJCXJldHVybiBpbmZvLT5tYXRjaF9mbGFncyAmIFhUX0NPTk5UUkFDS19TVEFURTsKIAlpZiAoKGluZm8tPm1hdGNoX2ZsYWdzICYgWFRfQ09OTlRSQUNLX0RJUkVDVElPTikgJiYKIAkgICAgKENUSU5GTzJESVIoY3RpbmZvKSA9PSBJUF9DVF9ESVJfT1JJR0lOQUwpIF4KLQkgICAgISEoaW5mby0+aW52ZXJ0X2ZsYWdzICYgWFRfQ09OTlRSQUNLX0RJUkVDVElPTikpCisJICAgICEoaW5mby0+aW52ZXJ0X2ZsYWdzICYgWFRfQ09OTlRSQUNLX0RJUkVDVElPTikpCiAJCXJldHVybiBmYWxzZTsKIAogCWlmIChpbmZvLT5tYXRjaF9mbGFncyAmIFhUX0NPTk5UUkFDS19PUklHU1JDKQpkaWZmIC0tZ2l0IGEvbmV0L25ldGxhYmVsL25ldGxhYmVsX2RvbWFpbmhhc2guYyBiL25ldC9uZXRsYWJlbC9uZXRsYWJlbF9kb21haW5oYXNoLmMKaW5kZXggZDM3YjdmOC4uZGUwZDhlNCAxMDA2NDQKLS0tIGEvbmV0L25ldGxhYmVsL25ldGxhYmVsX2RvbWFpbmhhc2guYworKysgYi9uZXQvbmV0bGFiZWwvbmV0bGFiZWxfZG9tYWluaGFzaC5jCkBAIC0xMDksNyArMTA5LDcgQEAKICAqCiAgKiBEZXNjcmlwdGlvbjoKICAqIFRoaXMgaXMgdGhlIGhhc2hpbmcgZnVuY3Rpb24gZm9yIHRoZSBkb21haW4gaGFzaCB0YWJsZSwgaXQgcmV0dXJucyB0aGUKLSAqIGNvcnJlY3QgYnVja2V0IG51bWJlciBmb3IgdGhlIGRvbWFpbi4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2liaWxlIGZvcgorICogY29ycmVjdCBidWNrZXQgbnVtYmVyIGZvciB0aGUgZG9tYWluLiAgVGhlIGNhbGxlciBpcyByZXNwb25zaWJsZSBmb3IKICAqIGVuc3VyaW5nIHRoYXQgdGhlIGhhc2ggdGFibGUgaXMgcHJvdGVjdGVkIHdpdGggZWl0aGVyIGEgUkNVIHJlYWQgbG9jayBvciB0aGUKICAqIGhhc2ggdGFibGUgbG9jay4KICAqCkBAIC0xMzQsNyArMTM0LDcgQEAKICAqCiAgKiBEZXNjcmlwdGlvbjoKICAqIFNlYXJjaGVzIHRoZSBkb21haW4gaGFzaCB0YWJsZSBhbmQgcmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIGhhc2ggdGFibGUKLSAqIGVudHJ5IGlmIGZvdW5kLCBvdGhlcndpc2UgTlVMTCBpcyByZXR1cm5lZC4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2liaWxlIGZvcgorICogZW50cnkgaWYgZm91bmQsIG90aGVyd2lzZSBOVUxMIGlzIHJldHVybmVkLiAgVGhlIGNhbGxlciBpcyByZXNwb25zaWJsZSBmb3IKICAqIGVuc3VyaW5nIHRoYXQgdGhlIGhhc2ggdGFibGUgaXMgcHJvdGVjdGVkIHdpdGggZWl0aGVyIGEgUkNVIHJlYWQgbG9jayBvciB0aGUKICAqIGhhc2ggdGFibGUgbG9jay4KICAqCkBAIC0xNjUsNyArMTY1LDcgQEAKICAqIFNlYXJjaGVzIHRoZSBkb21haW4gaGFzaCB0YWJsZSBhbmQgcmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIGhhc2ggdGFibGUKICAqIGVudHJ5IGlmIGFuIGV4YWN0IG1hdGNoIGlzIGZvdW5kLCBpZiBhbiBleGFjdCBtYXRjaCBpcyBub3QgcHJlc2VudCBpbiB0aGUKICAqIGhhc2ggdGFibGUgdGhlbiB0aGUgZGVmYXVsdCBlbnRyeSBpcyByZXR1cm5lZCBpZiB2YWxpZCBvdGhlcndpc2UgTlVMTCBpcwotICogcmV0dXJuZWQuICBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmlsZSBlbnN1cmluZyB0aGF0IHRoZSBoYXNoIHRhYmxlIGlzCisgKiByZXR1cm5lZC4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUgZW5zdXJpbmcgdGhhdCB0aGUgaGFzaCB0YWJsZSBpcwogICogcHJvdGVjdGVkIHdpdGggZWl0aGVyIGEgUkNVIHJlYWQgbG9jayBvciB0aGUgaGFzaCB0YWJsZSBsb2NrLgogICoKICAqLwpAQCAtMTkzLDcgKzE5Myw3IEBACiAgKgogICogRGVzY3JpcHRpb246CiAgKiBHZW5lcmF0ZSBhbiBhdWRpdCByZWNvcmQgZm9yIGFkZGluZyBhIG5ldyBOZXRMYWJlbC9MU00gbWFwcGluZyBlbnRyeSB3aXRoCi0gKiB0aGUgZ2l2ZW4gaW5mb3JtYXRpb24uICBDYWxsZXIgaXMgcmVzcG9uc2liaWxlIGZvciBob2xkaW5nIHRoZSBuZWNlc3NhcnkKKyAqIHRoZSBnaXZlbiBpbmZvcm1hdGlvbi4gIENhbGxlciBpcyByZXNwb25zaWJsZSBmb3IgaG9sZGluZyB0aGUgbmVjZXNzYXJ5CiAgKiBsb2Nrcy4KICAqCiAgKi8KQEAgLTYwNSw3ICs2MDUsNyBAQAogICoKICAqIERlc2NyaXB0aW9uOgogICogTG9vayB0aHJvdWdoIHRoZSBkb21haW4gaGFzaCB0YWJsZSBzZWFyY2hpbmcgZm9yIGFuIGVudHJ5IHRvIG1hdGNoIEBkb21haW4sCi0gKiByZXR1cm4gYSBwb2ludGVyIHRvIGEgY29weSBvZiB0aGUgZW50cnkgb3IgTlVMTC4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2liaWxlCisgKiByZXR1cm4gYSBwb2ludGVyIHRvIGEgY29weSBvZiB0aGUgZW50cnkgb3IgTlVMTC4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUKICAqIGZvciBlbnN1cmluZyB0aGF0IHJjdV9yZWFkX1t1bl1sb2NrKCkgaXMgY2FsbGVkLgogICoKICAqLwpkaWZmIC0tZ2l0IGEvbmV0L25ldGxhYmVsL25ldGxhYmVsX21nbXQuYyBiL25ldC9uZXRsYWJlbC9uZXRsYWJlbF9tZ210LmMKaW5kZXggOTk4ZTg1ZS4uNGYyNTFiMSAxMDA2NDQKLS0tIGEvbmV0L25ldGxhYmVsL25ldGxhYmVsX21nbXQuYworKysgYi9uZXQvbmV0bGFiZWwvbmV0bGFiZWxfbWdtdC5jCkBAIC0yNTksNyArMjU5LDcgQEAKICAqCiAgKiBEZXNjcmlwdGlvbjoKICAqIFRoaXMgZnVuY3Rpb24gaXMgYSBoZWxwZXIgZnVuY3Rpb24gdXNlZCBieSB0aGUgTElTVEFMTCBhbmQgTElTVERFRiBjb21tYW5kCi0gKiBoYW5kbGVycy4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2liaWxlIGZvciBlbnN1cmluZyB0aGF0IHRoZSBSQ1UgcmVhZCBsb2NrCisgKiBoYW5kbGVycy4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yIGVuc3VyaW5nIHRoYXQgdGhlIFJDVSByZWFkIGxvY2sKICAqIGlzIGhlbGQuICBSZXR1cm5zIHplcm8gb24gc3VjY2VzcywgbmVnYXRpdmUgdmFsdWVzIG9uIGZhaWx1cmUuCiAgKgogICovCmRpZmYgLS1naXQgYS9uZXQvcmRzL2liX3NlbmQuYyBiL25ldC9yZHMvaWJfc2VuZC5jCmluZGV4IGM0N2E1MTEuLjdjNGRjZTggMTAwNjQ0Ci0tLSBhL25ldC9yZHMvaWJfc2VuZC5jCisrKyBiL25ldC9yZHMvaWJfc2VuZC5jCkBAIC0zNTUsNyArMzU1LDcgQEAKICAqCiAgKiBDb25jZXB0dWFsbHksIHdlIGhhdmUgdHdvIGNvdW50ZXJzOgogICogIC0Jc2VuZCBjcmVkaXRzOiB0aGlzIHRlbGxzIHVzIGhvdyBtYW55IFdScyB3ZSdyZSBhbGxvd2VkCi0gKgl0byBzdWJtaXQgd2l0aG91dCBvdmVycnVuaW5nIHRoZSByZWNpZXZlcidzIHF1ZXVlLiBGb3IKKyAqCXRvIHN1Ym1pdCB3aXRob3V0IG92ZXJydW5pbmcgdGhlIHJlY2VpdmVyJ3MgcXVldWUuIEZvcgogICoJZWFjaCBTRU5EIFdSIHdlIHBvc3QsIHdlIGRlY3JlbWVudCB0aGlzIGJ5IG9uZS4KICAqCiAgKiAgLQlwb3N0ZWQgY3JlZGl0czogdGhpcyB0ZWxscyB1cyBob3cgbWFueSBXUnMgd2UgcmVjZW50bHkKZGlmZiAtLWdpdCBhL25ldC9yZHMvaXdfY20uYyBiL25ldC9yZHMvaXdfY20uYwppbmRleCA3MTJjZjJkLi4zYTYwYTE1IDEwMDY0NAotLS0gYS9uZXQvcmRzL2l3X2NtLmMKKysrIGIvbmV0L3Jkcy9pd19jbS5jCkBAIC0xODEsNyArMTgxLDcgQEAKIAl1bnNpZ25lZCBpbnQgc2VuZF9zaXplLCByZWN2X3NpemU7CiAJaW50IHJldDsKIAotCS8qIFRoZSBvZmZzZXQgb2YgMSBpcyB0byBhY2NvbW9kYXRlIHRoZSBhZGRpdGlvbmFsIEFDSyBXUi4gKi8KKwkvKiBUaGUgb2Zmc2V0IG9mIDEgaXMgdG8gYWNjb21tb2RhdGUgdGhlIGFkZGl0aW9uYWwgQUNLIFdSLiAqLwogCXNlbmRfc2l6ZSA9IG1pbl90KHVuc2lnbmVkIGludCwgcmRzX2l3ZGV2LT5tYXhfd3JzLCByZHNfaXdfc3lzY3RsX21heF9zZW5kX3dyICsgMSk7CiAJcmVjdl9zaXplID0gbWluX3QodW5zaWduZWQgaW50LCByZHNfaXdkZXYtPm1heF93cnMsIHJkc19pd19zeXNjdGxfbWF4X3JlY3Zfd3IgKyAxKTsKIAlyZHNfaXdfcmluZ19yZXNpemUoc2VuZF9yaW5nLCBzZW5kX3NpemUgLSAxKTsKZGlmZiAtLWdpdCBhL25ldC9yZHMvaXdfcmRtYS5jIGIvbmV0L3Jkcy9pd19yZG1hLmMKaW5kZXggNTk1MDllOS4uNmRlYWE3NyAxMDA2NDQKLS0tIGEvbmV0L3Jkcy9pd19yZG1hLmMKKysrIGIvbmV0L3Jkcy9pd19yZG1hLmMKQEAgLTEyMiw3ICsxMjIsNyBAQAogI2Vsc2UKIAkJCS8qIEZJWE1FIC0gbmVlZHMgdG8gY29tcGFyZSB0aGUgbG9jYWwgYW5kIHJlbW90ZQogCQkJICogaXBhZGRyL3BvcnQgdHVwbGUsIGJ1dCB0aGUgaXBhZGRyIGlzIHRoZSBvbmx5Ci0JCQkgKiBhdmFpbGFibGUgaW5mb21hdGlvbiBpbiB0aGUgcmRzX3NvY2sgKGFzIHRoZSByZXN0IGFyZQorCQkJICogYXZhaWxhYmxlIGluZm9ybWF0aW9uIGluIHRoZSByZHNfc29jayAoYXMgdGhlIHJlc3QgYXJlCiAJCQkgKiB6ZXJvJ2VkLiAgSXQgZG9lc24ndCBhcHBlYXIgdG8gYmUgcHJvcGVybHkgcG9wdWxhdGVkCiAJCQkgKiBkdXJpbmcgY29ubmVjdGlvbiBzZXR1cC4uLgogCQkJICovCmRpZmYgLS1naXQgYS9uZXQvcmRzL2l3X3NlbmQuYyBiL25ldC9yZHMvaXdfc2VuZC5jCmluZGV4IDYyODBlYTAuLjU0NWQ4ZWUgMTAwNjQ0Ci0tLSBhL25ldC9yZHMvaXdfc2VuZC5jCisrKyBiL25ldC9yZHMvaXdfc2VuZC5jCkBAIC0zMDcsNyArMzA3LDcgQEAKICAqCiAgKiBDb25jZXB0dWFsbHksIHdlIGhhdmUgdHdvIGNvdW50ZXJzOgogICogIC0Jc2VuZCBjcmVkaXRzOiB0aGlzIHRlbGxzIHVzIGhvdyBtYW55IFdScyB3ZSdyZSBhbGxvd2VkCi0gKgl0byBzdWJtaXQgd2l0aG91dCBvdmVycnVuaW5nIHRoZSByZWNpZXZlcidzIHF1ZXVlLiBGb3IKKyAqCXRvIHN1Ym1pdCB3aXRob3V0IG92ZXJydW5pbmcgdGhlIHJlY2VpdmVyJ3MgcXVldWUuIEZvcgogICoJZWFjaCBTRU5EIFdSIHdlIHBvc3QsIHdlIGRlY3JlbWVudCB0aGlzIGJ5IG9uZS4KICAqCiAgKiAgLQlwb3N0ZWQgY3JlZGl0czogdGhpcyB0ZWxscyB1cyBob3cgbWFueSBXUnMgd2UgcmVjZW50bHkKZGlmZiAtLWdpdCBhL25ldC9yZHMvc2VuZC5jIGIvbmV0L3Jkcy9zZW5kLmMKaW5kZXggMzViOWMyZS4uZDU4YWU1ZiAxMDA2NDQKLS0tIGEvbmV0L3Jkcy9zZW5kLmMKKysrIGIvbmV0L3Jkcy9zZW5kLmMKQEAgLTExNiw3ICsxMTYsNyBAQAogfQogCiAvKgotICogV2UncmUgbWFraW5nIHRoZSBjb25jaW91cyB0cmFkZS1vZmYgaGVyZSB0byBvbmx5IHNlbmQgb25lIG1lc3NhZ2UKKyAqIFdlJ3JlIG1ha2luZyB0aGUgY29uc2Npb3VzIHRyYWRlLW9mZiBoZXJlIHRvIG9ubHkgc2VuZCBvbmUgbWVzc2FnZQogICogZG93biB0aGUgY29ubmVjdGlvbiBhdCBhIHRpbWUuCiAgKiAgIFBybzoKICAqICAgICAgLSB0eCBxdWV1ZWluZyBpcyBhIHNpbXBsZSBmaWZvIGxpc3QKZGlmZiAtLWdpdCBhL25ldC9yb3NlL3Jvc2Vfcm91dGUuYyBiL25ldC9yb3NlL3Jvc2Vfcm91dGUuYwppbmRleCAwOGRjZDJmLi40NzljYWU1IDEwMDY0NAotLS0gYS9uZXQvcm9zZS9yb3NlX3JvdXRlLmMKKysrIGIvbmV0L3Jvc2Uvcm9zZV9yb3V0ZS5jCkBAIC01ODcsNyArNTg3LDcgQEAKIAogLyoKICAqCUNoZWNrIHRoYXQgdGhlIGRldmljZSBnaXZlbiBpcyBhIHZhbGlkIEFYLjI1IGludGVyZmFjZSB0aGF0IGlzICJ1cCIuCi0gKiAJY2FsbGVkIHdoaXRoIFJUTkwKKyAqIAljYWxsZWQgd2l0aCBSVE5MCiAgKi8KIHN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZSAqcm9zZV9heDI1X2Rldl9maW5kKGNoYXIgKmRldm5hbWUpCiB7CmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvYWN0X2FwaS5jIGIvbmV0L3NjaGVkL2FjdF9hcGkuYwppbmRleCAxNTg3M2UxLi4xNGI0MmY0IDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvYWN0X2FwaS5jCisrKyBiL25ldC9zY2hlZC9hY3RfYXBpLmMKQEAgLTk5OSw3ICs5OTksNyBAQAogCXN3aXRjaCAobi0+bmxtc2dfdHlwZSkgewogCWNhc2UgUlRNX05FV0FDVElPTjoKIAkJLyogd2UgYXJlIGdvaW5nIHRvIGFzc3VtZSBhbGwgb3RoZXIgZmxhZ3MKLQkJICogaW1wbHkgY3JlYXRlIG9ubHkgaWYgaXQgZG9lc250IGV4aXN0CisJCSAqIGltcGx5IGNyZWF0ZSBvbmx5IGlmIGl0IGRvZXNuJ3QgZXhpc3QKIAkJICogTm90ZSB0aGF0IENSRUFURSB8IEVYQ0wgaW1wbGllcyB0aGF0CiAJCSAqIGJ1dCBzaW5jZSB3ZSB3YW50IGF2b2lkIGFtYmlndWl0eSAoZWcgd2hlbiBmbGFncwogCQkgKiBpcyB6ZXJvKSB0aGVuIGp1c3Qgc2V0IHRoaXMKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9hY3RfcGVkaXQuYyBiL25ldC9zY2hlZC9hY3RfcGVkaXQuYwppbmRleCA1MGM3YzA2Li43YWZmZTlhIDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvYWN0X3BlZGl0LmMKKysrIGIvbmV0L3NjaGVkL2FjdF9wZWRpdC5jCkBAIC0xNjEsNyArMTYxLDcgQEAKIAkJCX0KIAkJCWlmIChvZmZzZXQgPiAwICYmIG9mZnNldCA+IHNrYi0+bGVuKSB7CiAJCQkJcHJfaW5mbygidGMgZmlsdGVyIHBlZGl0IgotCQkJCQkiIG9mZnNldCAlZCBjYW50IGV4Y2VlZCBwa3QgbGVuZ3RoICVkXG4iLAorCQkJCQkiIG9mZnNldCAlZCBjYW4ndCBleGNlZWQgcGt0IGxlbmd0aCAlZFxuIiwKIAkJCQkgICAgICAgb2Zmc2V0LCBza2ItPmxlbik7CiAJCQkJZ290byBiYWQ7CiAJCQl9CmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvZW1fbWV0YS5jIGIvbmV0L3NjaGVkL2VtX21ldGEuYwppbmRleCBhNGRlNjdlLi40OTEzMGU4IDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvZW1fbWV0YS5jCisrKyBiL25ldC9zY2hlZC9lbV9tZXRhLmMKQEAgLTQ3LDcgKzQ3LDcgQEAKICAqIAlvbiB0aGUgbWV0YSB0eXBlLiBPYnZpb3VzbHksIHRoZSBsZW5ndGggb2YgdGhlIGRhdGEgbXVzdCBhbHNvCiAgKiAJYmUgcHJvdmlkZWQgZm9yIG5vbi1udW1lcmljIHR5cGVzLgogICoKLSAqIAlBZGRpdGlvbmFseSwgdHlwZSBkZXBlbmRhbnQgbW9kaWZpZXJzIHN1Y2ggYXMgc2hpZnQgb3BlcmF0b3JzCisgKiAJQWRkaXRpb25hbGx5LCB0eXBlIGRlcGVuZGVudCBtb2RpZmllcnMgc3VjaCBhcyBzaGlmdCBvcGVyYXRvcnMKICAqIAlvciBtYXNrIG1heSBiZSBhcHBsaWVkIHRvIGV4dGVuZCB0aGUgZnVuY3Rpb25hbGl5LiBBcyBvZiBub3csCiAgKiAJdGhlIHZhcmlhYmxlIGxlbmd0aCB0eXBlIHN1cHBvcnRzIHNoaWZ0aW5nIHRoZSBieXRlIHN0cmluZyB0bwogICogCXRoZSByaWdodCwgZWF0aW5nIHVwIGFueSBudW1iZXIgb2Ygb2N0ZXRzIGFuZCB0aHVzIHN1cHBvcnRpbmcKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfaHRiLmMgYi9uZXQvc2NoZWQvc2NoX2h0Yi5jCmluZGV4IGUxNDI5YTguLjI5Yjk0MmMgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfaHRiLmMKKysrIGIvbmV0L3NjaGVkL3NjaF9odGIuYwpAQCAtMTgzLDcgKzE4Myw3IEBACiAgKiBmaWx0ZXJzIGluIHFkaXNjIGFuZCBpbiBpbm5lciBub2RlcyAoaWYgaGlnaGVyIGZpbHRlciBwb2ludHMgdG8gdGhlIGlubmVyCiAgKiBub2RlKS4gSWYgd2UgZW5kIHVwIHdpdGggY2xhc3NpZCBNQUpPUjowIHdlIGVucXVldWUgdGhlIHNrYiBpbnRvIHNwZWNpYWwKICAqIGludGVybmFsIGZpZm8gKGRpcmVjdCkuIFRoZXNlIHBhY2tldHMgdGhlbiBnbyBkaXJlY3RseSB0aHJ1LiBJZiB3ZSBzdGlsbAotICogaGF2ZSBubyB2YWxpZCBsZWFmIHdlIHRyeSB0byB1c2UgTUFKT1I6ZGVmYXVsdCBsZWFmLiBJdCBzdGlsbCB1bnN1Y2Nlc3NmdWxsCisgKiBoYXZlIG5vIHZhbGlkIGxlYWYgd2UgdHJ5IHRvIHVzZSBNQUpPUjpkZWZhdWx0IGxlYWYuIEl0IHN0aWxsIHVuc3VjY2Vzc2Z1bAogICogdGhlbiBmaW5pc2ggYW5kIHJldHVybiBkaXJlY3QgcXVldWUuCiAgKi8KICNkZWZpbmUgSFRCX0RJUkVDVCAoKHN0cnVjdCBodGJfY2xhc3MgKiktMUwpCmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvc2NoX25ldGVtLmMgYi9uZXQvc2NoZWQvc2NoX25ldGVtLmMKaW5kZXggZWRiYmY3YS4uNjljMzVmNiAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF9uZXRlbS5jCisrKyBiL25ldC9zY2hlZC9zY2hfbmV0ZW0uYwpAQCAtMTYwLDcgKzE2MCw3IEBACiAJdTMyIHJuZCA9IG5ldF9yYW5kb20oKTsKIAogCS8qCi0JICogTWFrZXMgYSBjb21wYXJpc2lvbiBiZXR3ZWVuIHJuZCBhbmQgdGhlIHRyYW5zaXRpb24KKwkgKiBNYWtlcyBhIGNvbXBhcmlzb24gYmV0d2VlbiBybmQgYW5kIHRoZSB0cmFuc2l0aW9uCiAJICogcHJvYmFiaWxpdGllcyBvdXRnb2luZyBmcm9tIHRoZSBjdXJyZW50IHN0YXRlLCB0aGVuIGRlY2lkZXMgdGhlCiAJICogbmV4dCBzdGF0ZSBhbmQgaWYgdGhlIG5leHQgcGFja2V0IGhhcyB0byBiZSB0cmFuc21pdHRlZCBvciBsb3N0LgogCSAqIFRoZSBmb3VyIHN0YXRlcyBjb3JyZXNwb25kIHRvOgpAQCAtMjEyLDkgKzIxMiw5IEBACiAgKiBHZW5lcmF0ZXMgbG9zc2VzIGFjY29yZGluZyB0byB0aGUgR2lsYmVydC1FbGxpb3QgbG9zcyBtb2RlbCBvcgogICogaXRzIHNwZWNpYWwgY2FzZXMgIChHaWxiZXJ0IG9yIFNpbXBsZSBHaWxiZXJ0KQogICoKLSAqIE1ha2VzIGEgY29tcGFyaXNpb24gYmV0d2VlbiByYW5kb20gbnVtYmVyIGFuZCB0aGUgdHJhbnNpdGlvbgorICogTWFrZXMgYSBjb21wYXJpc29uIGJldHdlZW4gcmFuZG9tIG51bWJlciBhbmQgdGhlIHRyYW5zaXRpb24KICAqIHByb2JhYmlsaXRpZXMgb3V0Z29pbmcgZnJvbSB0aGUgY3VycmVudCBzdGF0ZSwgdGhlbiBkZWNpZGVzIHRoZQotICogbmV4dCBzdGF0ZS4gQSBzZWNvbmQgcmFuZG9tIG51bWJlciBpcyBleHRyYWN0ZWQgYW5kIHRoZSBjb21wYXJpc2lvbgorICogbmV4dCBzdGF0ZS4gQSBzZWNvbmQgcmFuZG9tIG51bWJlciBpcyBleHRyYWN0ZWQgYW5kIHRoZSBjb21wYXJpc29uCiAgKiB3aXRoIHRoZSBsb3NzIHByb2JhYmlsaXR5IG9mIHRoZSBjdXJyZW50IHN0YXRlIGRlY2lkZXMgaWYgdGhlIG5leHQKICAqIHBhY2tldCB3aWxsIGJlIHRyYW5zbWl0dGVkIG9yIGxvc3QuCiAgKi8KZGlmZiAtLWdpdCBhL25ldC9zY3RwL2Fzc29jaW9sYS5jIGIvbmV0L3NjdHAvYXNzb2Npb2xhLmMKaW5kZXggNmIwNDI4Ny4uMDY5OGNhZCAxMDA2NDQKLS0tIGEvbmV0L3NjdHAvYXNzb2Npb2xhLmMKKysrIGIvbmV0L3NjdHAvYXNzb2Npb2xhLmMKQEAgLTE1OTMsNyArMTU5Myw3IEBACiAJc3RydWN0IHNjdHBfY2h1bmsgKmFjazsKIAlzdHJ1Y3Qgc2N0cF9jaHVuayAqdG1wOwogCi0JLyogV2UgY2FuIHJlbW92ZSBhbGwgdGhlIGVudHJpZXMgZnJvbSB0aGUgcXVldWUgdXB0bworCS8qIFdlIGNhbiByZW1vdmUgYWxsIHRoZSBlbnRyaWVzIGZyb20gdGhlIHF1ZXVlIHVwIHRvCiAJICogdGhlICJQZWVyLVNlcXVlbmNlLU51bWJlciIuCiAJICovCiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGFjaywgdG1wLCAmYXNvYy0+YXNjb25mX2Fja19saXN0LApkaWZmIC0tZ2l0IGEvbmV0L3NjdHAvYXV0aC5jIGIvbmV0L3NjdHAvYXV0aC5jCmluZGV4IGRkYmJmN2MuLjg2NWU2OGYgMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL2F1dGguYworKysgYi9uZXQvc2N0cC9hdXRoLmMKQEAgLTExMyw3ICsxMTMsNyBAQAogCXJldHVybiBuZXc7CiB9CiAKLS8qIEZyZWUgdGhlIHNoYXJlZCBrZXkgc3R1Y3R1cmUgKi8KKy8qIEZyZWUgdGhlIHNoYXJlZCBrZXkgc3RydWN0dXJlICovCiBzdGF0aWMgdm9pZCBzY3RwX2F1dGhfc2hrZXlfZnJlZShzdHJ1Y3Qgc2N0cF9zaGFyZWRfa2V5ICpzaF9rZXkpCiB7CiAJQlVHX09OKCFsaXN0X2VtcHR5KCZzaF9rZXktPmtleV9saXN0KSk7CkBAIC0xMjIsNyArMTIyLDcgQEAKIAlrZnJlZShzaF9rZXkpOwogfQogCi0vKiBEZXN0b3J5IHRoZSBlbnRpcmUga2V5IGxpc3QuICBUaGlzIGlzIGRvbmUgZHVyaW5nIHRoZQorLyogRGVzdHJveSB0aGUgZW50aXJlIGtleSBsaXN0LiAgVGhpcyBpcyBkb25lIGR1cmluZyB0aGUKICAqIGFzc29jaW9uIGFuZCBlbmRwb2ludCBmcmVlIHByb2Nlc3MuCiAgKi8KIHZvaWQgc2N0cF9hdXRoX2Rlc3Ryb3lfa2V5cyhzdHJ1Y3QgbGlzdF9oZWFkICprZXlzKQpAQCAtMzI0LDcgKzMyNCw3IEBACiAJaWYgKCFwZWVyX2tleV92ZWN0b3IgfHwgIWxvY2FsX2tleV92ZWN0b3IpCiAJCWdvdG8gb3V0OwogCi0JLyogRmlndXJlIG91dCB0aGUgb3JkZXIgaW4gd2ljaCB0aGUga2V5X3ZlY3RvcnMgd2lsbCBiZQorCS8qIEZpZ3VyZSBvdXQgdGhlIG9yZGVyIGluIHdoaWNoIHRoZSBrZXlfdmVjdG9ycyB3aWxsIGJlCiAJICogYWRkZWQgdG8gdGhlIGVuZHBvaW50IHNoYXJlZCBrZXkuCiAJICogU0NUUC1BVVRILCBTZWN0aW9uIDYuMToKIAkgKiAgIFRoaXMgaXMgcGVyZm9ybWVkIGJ5IHNlbGVjdGluZyB0aGUgbnVtZXJpY2FsbHkgc21hbGxlciBrZXkKZGlmZiAtLWdpdCBhL25ldC9zY3RwL2lucHV0LmMgYi9uZXQvc2N0cC9pbnB1dC5jCmluZGV4IDgyNjY2MWIuLjU0MzZjNjkgMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL2lucHV0LmMKKysrIGIvbmV0L3NjdHAvaW5wdXQuYwpAQCAtMTAzNCw3ICsxMDM0LDcgQEAKICogICAgYXNzb2NpYXRpb24uCiAqCiAqIFRoaXMgbWVhbnMgdGhhdCBhbnkgY2h1bmtzIHRoYXQgY2FuIGhlbHAgdXMgaWRlbnRpZnkgdGhlIGFzc29jaWF0aW9uIG5lZWQKLSogdG8gYmUgbG9va2VkIGF0IHRvIGZpbmQgdGhpcyBhc3NvY2F0aW9uLgorKiB0byBiZSBsb29rZWQgYXQgdG8gZmluZCB0aGlzIGFzc29jaWF0aW9uLgogKi8KIHN0YXRpYyBzdHJ1Y3Qgc2N0cF9hc3NvY2lhdGlvbiAqX19zY3RwX3Jjdl93YWxrX2xvb2t1cChzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAogCQkJCSAgICAgIGNvbnN0IHVuaW9uIHNjdHBfYWRkciAqbGFkZHIsCmRpZmYgLS1naXQgYS9uZXQvc2N0cC9vdXRwdXQuYyBiL25ldC9zY3RwL291dHB1dC5jCmluZGV4IDYwNjAwZDMuLmI0ZjNjZjAgMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL291dHB1dC5jCisrKyBiL25ldC9zY3RwL291dHB1dC5jCkBAIC01MTAsNyArNTEwLDcgQEAKIAkJc2gtPmNoZWNrc3VtID0gc2N0cF9lbmRfY2tzdW0oY3JjMzIpOwogCX0gZWxzZSB7CiAJCWlmIChkc3QtPmRldi0+ZmVhdHVyZXMgJiBORVRJRl9GX1NDVFBfQ1NVTSkgewotCQkJLyogbm8gbmVlZCB0byBzZWVkIHBzdWVkbyBjaGVja3N1bSBmb3IgU0NUUCAqLworCQkJLyogbm8gbmVlZCB0byBzZWVkIHBzZXVkbyBjaGVja3N1bSBmb3IgU0NUUCAqLwogCQkJbnNrYi0+aXBfc3VtbWVkID0gQ0hFQ0tTVU1fUEFSVElBTDsKIAkJCW5za2ItPmNzdW1fc3RhcnQgPSAoc2tiX3RyYW5zcG9ydF9oZWFkZXIobnNrYikgLQogCQkJICAgICAgICAgICAgICAgICAgICBuc2tiLT5oZWFkKTsKZGlmZiAtLWdpdCBhL25ldC9zY3RwL291dHF1ZXVlLmMgYi9uZXQvc2N0cC9vdXRxdWV1ZS5jCmluZGV4IDI2ZGMwMDUuLmJmOTJhNWIgMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL291dHF1ZXVlLmMKKysrIGIvbmV0L3NjdHAvb3V0cXVldWUuYwpAQCAtMTc3LDEzICsxNzcsMTMgQEAKICAqIDMpIElmIHRoZSBtaXNzaW5nIHJlcG9ydCBjb3VudCBmb3IgVFNOIHQgaXMgdG8gYmUKICAqIGluY3JlbWVudGVkIGFjY29yZGluZyB0byBbUkZDMjk2MF0gYW5kCiAgKiBbU0NUUF9TVEVXQVJULTIwMDJdLCBhbmQgQ0hBTkdFT1ZFUl9BQ1RJVkUgaXMgc2V0LAotICogdGhlbiB0aGUgc2VuZGVyIE1VU1QgZnV0aGVyIGV4ZWN1dGUgc3RlcHMgMy4xIGFuZAorICogdGhlbiB0aGUgc2VuZGVyIE1VU1QgZnVydGhlciBleGVjdXRlIHN0ZXBzIDMuMSBhbmQKICAqIDMuMiB0byBkZXRlcm1pbmUgaWYgdGhlIG1pc3NpbmcgcmVwb3J0IGNvdW50IGZvcgogICogVFNOIHQgU0hPVUxEIE5PVCBiZSBpbmNyZW1lbnRlZC4KICAqCiAgKiAzLjMpIElmIDMuMSBhbmQgMy4yIGRvIG5vdCBkaWN0YXRlIHRoYXQgdGhlIG1pc3NpbmcKICAqIHJlcG9ydCBjb3VudCBmb3IgdCBzaG91bGQgbm90IGJlIGluY3JlbWVudGVkLCB0aGVuCi0gKiB0aGUgc2VuZGVyIFNPVUxEIGluY3JlbWVudCBtaXNzaW5nIHJlcG9ydCBjb3VudCBmb3IKKyAqIHRoZSBzZW5kZXIgU0hPVUxEIGluY3JlbWVudCBtaXNzaW5nIHJlcG9ydCBjb3VudCBmb3IKICAqIHQgKGFjY29yZGluZyB0byBbUkZDMjk2MF0gYW5kIFtTQ1RQX1NURVdBUlRfMjAwMl0pLgogICovCiBzdGF0aWMgaW5saW5lIGludCBzY3RwX2NhY2Nfc2tpcChzdHJ1Y3Qgc2N0cF90cmFuc3BvcnQgKnByaW1hcnksCkBAIC04NDMsNyArODQzLDcgQEAKIAkJY2FzZSBTQ1RQX0NJRF9FQ05fQ1dSOgogCQljYXNlIFNDVFBfQ0lEX0FTQ09ORl9BQ0s6CiAJCQlvbmVfcGFja2V0ID0gMTsKLQkJCS8qIEZhbGwgdGhyb3VnaHQgKi8KKwkJCS8qIEZhbGwgdGhyb3VnaCAqLwogCiAJCWNhc2UgU0NUUF9DSURfU0FDSzoKIAkJY2FzZSBTQ1RQX0NJRF9IRUFSVEJFQVQ6CmRpZmYgLS1naXQgYS9uZXQvc2N0cC9zbV9zaWRlZWZmZWN0LmMgYi9uZXQvc2N0cC9zbV9zaWRlZWZmZWN0LmMKaW5kZXggYjIxYjIxOC4uNWY4NmVlNCAxMDA2NDQKLS0tIGEvbmV0L3NjdHAvc21fc2lkZWVmZmVjdC5jCisrKyBiL25ldC9zY3RwL3NtX3NpZGVlZmZlY3QuYwpAQCAtNDgyLDcgKzQ4Miw3IEBACiAJICogSWYgdGhlIHRpbWVyIHdhcyBhIGhlYXJ0YmVhdCwgd2Ugb25seSBpbmNyZW1lbnQgZXJyb3IgY291bnRzCiAJICogd2hlbiB3ZSBhbHJlYWR5IGhhdmUgYW4gb3V0c3RhbmRpbmcgSEVBUlRCRUFUIHRoYXQgaGFzIG5vdAogCSAqIGJlZW4gYWNrbm93bGVkZ2VkLgotCSAqIEFkZGl0aW9uYWx5LCBzb21lIHRyYW5wb3J0IHN0YXRlcyBpbmhpYml0IGVycm9yIGluY3JlbWVudHMuCisJICogQWRkaXRpb25hbGx5LCBzb21lIHRyYW5wb3J0IHN0YXRlcyBpbmhpYml0IGVycm9yIGluY3JlbWVudHMuCiAJICovCiAJaWYgKCFpc19oYikgewogCQlhc29jLT5vdmVyYWxsX2Vycm9yX2NvdW50Kys7CmRpZmYgLS1naXQgYS9uZXQvc2N0cC9zbV9zdGF0ZWZ1bnMuYyBiL25ldC9zY3RwL3NtX3N0YXRlZnVucy5jCmluZGV4IDRiNGViN2MuLjc2NzkyMDggMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL3NtX3N0YXRlZnVucy5jCisrKyBiL25ldC9zY3RwL3NtX3N0YXRlZnVucy5jCkBAIC01NTEsNyArNTUxLDcgQEAKIAkJICoKIAkJICogVGhpcyBtZWFucyB0aGF0IGlmIHdlIG9ubHkgd2FudCB0byBhYm9ydCBhc3NvY2lhdGlvbnMKIAkJICogaW4gYW4gYXV0aGVudGljYXRlZCB3YXkgKGkuZSBBVVRIK0FCT1JUKSwgdGhlbiB3ZQotCQkgKiBjYW4ndCBkZXN0cm95IHRoaXMgYXNzb2NpYXRpb24ganVzdCBiZWN1YXNlIHRoZSBwYWNrZXQKKwkJICogY2FuJ3QgZGVzdHJveSB0aGlzIGFzc29jaWF0aW9uIGp1c3QgYmVjYXVzZSB0aGUgcGFja2V0CiAJCSAqIHdhcyBtYWxmb3JtZWQuCiAJCSAqLwogCQlpZiAoc2N0cF9hdXRoX3JlY3ZfY2lkKFNDVFBfQ0lEX0FCT1JULCBhc29jKSkKQEAgLTE1NDYsNyArMTU0Niw3IEBACiB9CiAKIC8qCi0gKiBIYW5kbGUgc2ltdWx0YW5vdXMgSU5JVC4KKyAqIEhhbmRsZSBzaW11bHRhbmVvdXMgSU5JVC4KICAqIFRoaXMgbWVhbnMgd2Ugc3RhcnRlZCBhbiBJTklUIGFuZCB0aGVuIHdlIGdvdCBhbiBJTklUIHJlcXVlc3QgZnJvbQogICogb3VyIHBlZXIuCiAgKgpAQCAtMjA3OSw3ICsyMDc5LDcgQEAKIAkgKiBSRkMgMjk2MCwgU2VjdGlvbiAzLjMuNwogCSAqICAgIElmIGFuIGVuZHBvaW50IHJlY2VpdmVzIGFuIEFCT1JUIHdpdGggYSBmb3JtYXQgZXJyb3Igb3IgZm9yIGFuCiAJICogICAgYXNzb2NpYXRpb24gdGhhdCBkb2Vzbid0IGV4aXN0LCBpdCBNVVNUIHNpbGVudGx5IGRpc2NhcmQgaXQuCi0JICogQmVjYXN1ZSB0aGUgbGVuZ3RoIGlzICJpbnZhbGlkIiwgd2UgY2FuJ3QgcmVhbGx5IGRpc2NhcmQganVzdAorCSAqIEJlY2F1c2UgdGhlIGxlbmd0aCBpcyAiaW52YWxpZCIsIHdlIGNhbid0IHJlYWxseSBkaXNjYXJkIGp1c3QKIAkgKiBhcyB3ZSBkbyBub3Qga25vdyBpdHMgdHJ1ZSBsZW5ndGguICBTbywgdG8gYmUgc2FmZSwgZGlzY2FyZCB0aGUKIAkgKiBwYWNrZXQuCiAJICovCkBAIC0yMTIwLDcgKzIxMjAsNyBAQAogCSAqIFJGQyAyOTYwLCBTZWN0aW9uIDMuMy43CiAJICogICAgSWYgYW4gZW5kcG9pbnQgcmVjZWl2ZXMgYW4gQUJPUlQgd2l0aCBhIGZvcm1hdCBlcnJvciBvciBmb3IgYW4KIAkgKiAgICBhc3NvY2lhdGlvbiB0aGF0IGRvZXNuJ3QgZXhpc3QsIGl0IE1VU1Qgc2lsZW50bHkgZGlzY2FyZCBpdC4KLQkgKiBCZWNhc3VlIHRoZSBsZW5ndGggaXMgImludmFsaWQiLCB3ZSBjYW4ndCByZWFsbHkgZGlzY2FyZCBqdXN0CisJICogQmVjYXVzZSB0aGUgbGVuZ3RoIGlzICJpbnZhbGlkIiwgd2UgY2FuJ3QgcmVhbGx5IGRpc2NhcmQganVzdAogCSAqIGFzIHdlIGRvIG5vdCBrbm93IGl0cyB0cnVlIGxlbmd0aC4gIFNvLCB0byBiZSBzYWZlLCBkaXNjYXJkIHRoZQogCSAqIHBhY2tldC4KIAkgKi8KQEAgLTIzODEsNyArMjM4MSw3IEBACiAJICogUkZDIDI5NjAsIFNlY3Rpb24gMy4zLjcKIAkgKiAgICBJZiBhbiBlbmRwb2ludCByZWNlaXZlcyBhbiBBQk9SVCB3aXRoIGEgZm9ybWF0IGVycm9yIG9yIGZvciBhbgogCSAqICAgIGFzc29jaWF0aW9uIHRoYXQgZG9lc24ndCBleGlzdCwgaXQgTVVTVCBzaWxlbnRseSBkaXNjYXJkIGl0LgotCSAqIEJlY2FzdWUgdGhlIGxlbmd0aCBpcyAiaW52YWxpZCIsIHdlIGNhbid0IHJlYWxseSBkaXNjYXJkIGp1c3QKKwkgKiBCZWNhdXNlIHRoZSBsZW5ndGggaXMgImludmFsaWQiLCB3ZSBjYW4ndCByZWFsbHkgZGlzY2FyZCBqdXN0CiAJICogYXMgd2UgZG8gbm90IGtub3cgaXRzIHRydWUgbGVuZ3RoLiAgU28sIHRvIGJlIHNhZmUsIGRpc2NhcmQgdGhlCiAJICogcGFja2V0LgogCSAqLwpAQCAtMjQ0OCw3ICsyNDQ4LDcgQEAKIAkgKiBSRkMgMjk2MCwgU2VjdGlvbiAzLjMuNwogCSAqICAgIElmIGFuIGVuZHBvaW50IHJlY2VpdmVzIGFuIEFCT1JUIHdpdGggYSBmb3JtYXQgZXJyb3Igb3IgZm9yIGFuCiAJICogICAgYXNzb2NpYXRpb24gdGhhdCBkb2Vzbid0IGV4aXN0LCBpdCBNVVNUIHNpbGVudGx5IGRpc2NhcmQgaXQuCi0JICogQmVjYXN1ZSB0aGUgbGVuZ3RoIGlzICJpbnZhbGlkIiwgd2UgY2FuJ3QgcmVhbGx5IGRpc2NhcmQganVzdAorCSAqIEJlY2F1c2UgdGhlIGxlbmd0aCBpcyAiaW52YWxpZCIsIHdlIGNhbid0IHJlYWxseSBkaXNjYXJkIGp1c3QKIAkgKiBhcyB3ZSBkbyBub3Qga25vdyBpdHMgdHJ1ZSBsZW5ndGguICBTbywgdG8gYmUgc2FmZSwgZGlzY2FyZCB0aGUKIAkgKiBwYWNrZXQuCiAJICovCkBAIC0zODU1LDcgKzM4NTUsNyBAQAogfQogCiAvKgotICogU0NUUC1BVVRIIFNlY3Rpb24gNi4zIFJlY2V2aW5nIGF1dGhlbnRpY2F0ZWQgY2h1a25zCisgKiBTQ1RQLUFVVEggU2VjdGlvbiA2LjMgUmVjZWl2aW5nIGF1dGhlbnRpY2F0ZWQgY2h1a25zCiAgKgogICogICAgVGhlIHJlY2VpdmVyIE1VU1QgdXNlIHRoZSBITUFDIGFsZ29yaXRobSBpbmRpY2F0ZWQgaW4gdGhlIEhNQUMKICAqICAgIElkZW50aWZpZXIgZmllbGQuICBJZiB0aGlzIGFsZ29yaXRobSB3YXMgbm90IHNwZWNpZmllZCBieSB0aGUKQEAgLTQyMzEsNyArNDIzMSw3IEBACiAJICoKIAkgKiBUaGlzIG1lYW5zIHRoYXQgaWYgd2Ugb25seSB3YW50IHRvIGFib3J0IGFzc29jaWF0aW9ucwogCSAqIGluIGFuIGF1dGhlbnRpY2F0ZWQgd2F5IChpLmUgQVVUSCtBQk9SVCksIHRoZW4gd2UKLQkgKiBjYW4ndCBkZXN0cm95IHRoaXMgYXNzb2NpYXRpb24ganVzdCBiZWN1YXNlIHRoZSBwYWNrZXQKKwkgKiBjYW4ndCBkZXN0cm95IHRoaXMgYXNzb2NpYXRpb24ganVzdCBiZWNhdXNlIHRoZSBwYWNrZXQKIAkgKiB3YXMgbWFsZm9ybWVkLgogCSAqLwogCWlmIChzY3RwX2F1dGhfcmVjdl9jaWQoU0NUUF9DSURfQUJPUlQsIGFzb2MpKQpAQCAtNDQwMiw5ICs0NDAyLDkgQEAKIH0KIAogLyogSGFuZGxlIHByb3RvY29sIHZpb2xhdGlvbiBvZiBhbiBpbnZhbGlkIGNodW5rIGJ1bmRsaW5nLiAgRm9yIGV4YW1wbGUsCi0gKiB3aGVuIHdlIGhhdmUgYW4gYXNzb2NpYXRpb24gYW5kIHdlIHJlY2lldmUgYnVuZGxlZCBJTklULUFDSywgb3IKKyAqIHdoZW4gd2UgaGF2ZSBhbiBhc3NvY2lhdGlvbiBhbmQgd2UgcmVjZWl2ZSBidW5kbGVkIElOSVQtQUNLLCBvcgogICogU0hVRE9XTi1DT01QTEVURSwgb3VyIHBlZXIgaXMgY2xlYXJseSB2aW9sYXRpb25nIHRoZSAiTVVTVCBOT1QgYnVuZGxlIgotICogc3RhdGVtZW50IGZyb20gdGhlIHNwZWNzLiAgQWRkaXRpbmFsbHksIHRoZXJlIG1pZ2h0IGJlIGFuIGF0dGFja2VyCisgKiBzdGF0ZW1lbnQgZnJvbSB0aGUgc3BlY3MuICBBZGRpdGlvbmFsbHksIHRoZXJlIG1pZ2h0IGJlIGFuIGF0dGFja2VyCiAgKiBvbiB0aGUgcGF0aCBhbmQgd2UgbWF5IG5vdCB3YW50IHRvIGNvbnRpbnVlIHRoaXMgY29tbXVuaWNhdGlvbi4KICAqLwogc3RhdGljIHNjdHBfZGlzcG9zaXRpb25fdCBzY3RwX3NmX3Zpb2xhdGlvbl9jaHVuaygKZGlmZiAtLWdpdCBhL25ldC9zY3RwL3NvY2tldC5jIGIvbmV0L3NjdHAvc29ja2V0LmMKaW5kZXggMzk1MWExMC4uZGViODJlMyAxMDA2NDQKLS0tIGEvbmV0L3NjdHAvc29ja2V0LmMKKysrIGIvbmV0L3NjdHAvc29ja2V0LmMKQEAgLTExOTMsNyArMTE5Myw3IEBACiAgKiBhbiBlbmRwb2ludCB0aGF0IGlzIG11bHRpLWhvbWVkLiAgTXVjaCBsaWtlIHNjdHBfYmluZHgoKSB0aGlzIGNhbGwKICAqIGFsbG93cyBhIGNhbGxlciB0byBzcGVjaWZ5IG11bHRpcGxlIGFkZHJlc3NlcyBhdCB3aGljaCBhIHBlZXIgY2FuIGJlCiAgKiByZWFjaGVkLiAgVGhlIHdheSB0aGUgU0NUUCBzdGFjayB1c2VzIHRoZSBsaXN0IG9mIGFkZHJlc3NlcyB0byBzZXQgdXAKLSAqIHRoZSBhc3NvY2lhdGlvbiBpcyBpbXBsZW1lbnRhdGlvbiBkZXBlbmRhbnQuICBUaGlzIGZ1bmN0aW9uIG9ubHkKKyAqIHRoZSBhc3NvY2lhdGlvbiBpcyBpbXBsZW1lbnRhdGlvbiBkZXBlbmRlbnQuICBUaGlzIGZ1bmN0aW9uIG9ubHkKICAqIHNwZWNpZmllcyB0aGF0IHRoZSBzdGFjayB3aWxsIHRyeSB0byBtYWtlIHVzZSBvZiBhbGwgdGhlIGFkZHJlc3NlcyBpbgogICogdGhlIGxpc3Qgd2hlbiBuZWVkZWQuCiAgKgpkaWZmIC0tZ2l0IGEvbmV0L3NjdHAvdWxwZXZlbnQuYyBiL25ldC9zY3RwL3VscGV2ZW50LmMKaW5kZXggYWE3MmU4OS4uZGZmMjdkNSAxMDA2NDQKLS0tIGEvbmV0L3NjdHAvdWxwZXZlbnQuYworKysgYi9uZXQvc2N0cC91bHBldmVudC5jCkBAIC01NTQsNyArNTU0LDcgQEAKIAltZW1jcHkoJnNzZi0+c3NmX2luZm8sICZjaHVuay0+c2luZm8sIHNpemVvZihzdHJ1Y3Qgc2N0cF9zbmRyY3ZpbmZvKSk7CiAKIAkvKiBQZXIgVFNWV0cgZGlzY3Vzc2lvbiB3aXRoIFJhbmR5LiBBbGxvdyB0aGUgYXBwbGljYXRpb24gdG8KLQkgKiByZXNzZW1ibGUgYSBmcmFnbWVudGVkIG1lc3NhZ2UuCisJICogcmVzZW1ibGUgYSBmcmFnbWVudGVkIG1lc3NhZ2UuCiAJICovCiAJc3NmLT5zc2ZfaW5mby5zaW5mb19mbGFncyA9IGNodW5rLT5jaHVua19oZHItPmZsYWdzOwogCmRpZmYgLS1naXQgYS9uZXQvc2N0cC91bHBxdWV1ZS5jIGIvbmV0L3NjdHAvdWxwcXVldWUuYwppbmRleCAxNzY3ODE4Li5mMmQxZGU3IDEwMDY0NAotLS0gYS9uZXQvc2N0cC91bHBxdWV1ZS5jCisrKyBiL25ldC9zY3RwL3VscHF1ZXVlLmMKQEAgLTI0MCw3ICsyNDAsNyBAQAogCQl9IGVsc2UgewogCQkJLyoKIAkJCSAqIElmIGZyYWdtZW50IGludGVybGVhdmUgaXMgZW5hYmxlZCwgd2UKLQkJCSAqIGNhbiBxdWV1ZSB0aGlzIHRvIHRoZSByZWNpZXZlIHF1ZXVlIGluc3RlYWQKKwkJCSAqIGNhbiBxdWV1ZSB0aGlzIHRvIHRoZSByZWNlaXZlIHF1ZXVlIGluc3RlYWQKIAkJCSAqIG9mIHRoZSBsb2JieS4KIAkJCSAqLwogCQkJaWYgKHNjdHBfc2soc2spLT5mcmFnX2ludGVybGVhdmUpCmRpZmYgLS1naXQgYS9uZXQvc29ja2V0LmMgYi9uZXQvc29ja2V0LmMKaW5kZXggNTIxMjQ0Ny4uMzEwZDE2YiAxMDA2NDQKLS0tIGEvbmV0L3NvY2tldC5jCisrKyBiL25ldC9zb2NrZXQuYwpAQCAtMjk4Niw3ICsyOTg2LDcgQEAKIAogLyogU2luY2Ugb2xkIHN0eWxlIGJyaWRnZSBpb2N0bCdzIGVuZHVwIHVzaW5nIFNJT0NERVZQUklWQVRFCiAgKiBmb3Igc29tZSBvcGVyYXRpb25zOyB0aGlzIGZvcmNlcyB1c2Ugb2YgdGhlIG5ld2VyIGJyaWRnZS11dGlscyB0aGF0Ci0gKiB1c2UgY29tcGF0aWFibGUgaW9jdGxzCisgKiB1c2UgY29tcGF0aWJsZSBpb2N0bHMKICAqLwogc3RhdGljIGludCBvbGRfYnJpZGdlX2lvY3RsKGNvbXBhdF91bG9uZ190IF9fdXNlciAqYXJncCkKIHsKZGlmZiAtLWdpdCBhL25ldC9zdW5ycGMvYXV0aF9nc3MvZ3NzX2tyYjVfbWVjaC5jIGIvbmV0L3N1bnJwYy9hdXRoX2dzcy9nc3Nfa3JiNV9tZWNoLmMKaW5kZXggOTAyMmYwYS4uMGE5YTJlYyAxMDA2NDQKLS0tIGEvbmV0L3N1bnJwYy9hdXRoX2dzcy9nc3Nfa3JiNV9tZWNoLmMKKysrIGIvbmV0L3N1bnJwYy9hdXRoX2dzcy9nc3Nfa3JiNV9tZWNoLmMKQEAgLTQyNyw3ICs0MjcsNyBAQAogY29udGV4dF9kZXJpdmVfa2V5c19yYzQoc3RydWN0IGtyYjVfY3R4ICpjdHgpCiB7CiAJc3RydWN0IGNyeXB0b19oYXNoICpobWFjOwotCXN0YXRpYyBjb25zdCBjaGFyIHNpZ2tleWNvbnN0YW50W10gPSAic2lnbmF0dXJla2V5IjsKKwljaGFyIHNpZ2tleWNvbnN0YW50W10gPSAic2lnbmF0dXJla2V5IjsKIAlpbnQgc2xlbiA9IHN0cmxlbihzaWdrZXljb25zdGFudCkgKyAxOwkvKiBpbmNsdWRlIG51bGwgdGVybWluYXRvciAqLwogCXN0cnVjdCBoYXNoX2Rlc2MgZGVzYzsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3Qgc2dbMV07CmRpZmYgLS1naXQgYS9uZXQvc3VucnBjL2F1dGhfZ3NzL3N2Y2F1dGhfZ3NzLmMgYi9uZXQvc3VucnBjL2F1dGhfZ3NzL3N2Y2F1dGhfZ3NzLmMKaW5kZXggYmNkYWU3OC4uOGQwZjdkMyAxMDA2NDQKLS0tIGEvbmV0L3N1bnJwYy9hdXRoX2dzcy9zdmNhdXRoX2dzcy5jCisrKyBiL25ldC9zdW5ycGMvYXV0aF9nc3Mvc3ZjYXV0aF9nc3MuYwpAQCAtMTEwMSw3ICsxMTAxLDcgQEAKIAogCS8qIGNyZWRlbnRpYWwgaXM6CiAJICogICB2ZXJzaW9uKD09MSksIHByb2MoMCwxLDIsMyksIHNlcSwgc2VydmljZSAoMSwyLDMpLCBoYW5kbGUKLQkgKiBhdCBsZWFzdCA1IHUzMnMsIGFuZCBpcyBwcmVjZWVkZWQgYnkgbGVuZ3RoLCBzbyB0aGF0IG1ha2VzIDYuCisJICogYXQgbGVhc3QgNSB1MzJzLCBhbmQgaXMgcHJlY2VkZWQgYnkgbGVuZ3RoLCBzbyB0aGF0IG1ha2VzIDYuCiAJICovCiAKIAlpZiAoYXJndi0+aW92X2xlbiA8IDUgKiA0KQpkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy94cHJ0c29jay5jIGIvbmV0L3N1bnJwYy94cHJ0c29jay5jCmluZGV4IDFlMzM2YTAuLmJmMDA1ZDMgMTAwNjQ0Ci0tLSBhL25ldC9zdW5ycGMveHBydHNvY2suYworKysgYi9uZXQvc3VucnBjL3hwcnRzb2NrLmMKQEAgLTUwNCw3ICs1MDQsNyBAQAogICogICBFQUdBSU46CVRoZSBzb2NrZXQgd2FzIGJsb2NrZWQsIHBsZWFzZSBjYWxsIGFnYWluIGxhdGVyIHRvCiAgKgkJY29tcGxldGUgdGhlIHJlcXVlc3QKICAqIEVOT1RDT05OOglDYWxsZXIgbmVlZHMgdG8gaW52b2tlIGNvbm5lY3QgbG9naWMgdGhlbiBjYWxsIGFnYWluCi0gKiAgICBvdGhlcjoJU29tZSBvdGhlciBlcnJvciBvY2N1cmVkLCB0aGUgcmVxdWVzdCB3YXMgbm90IHNlbnQKKyAqICAgIG90aGVyOglTb21lIG90aGVyIGVycm9yIG9jY3VycmVkLCB0aGUgcmVxdWVzdCB3YXMgbm90IHNlbnQKICAqLwogc3RhdGljIGludCB4c191ZHBfc2VuZF9yZXF1ZXN0KHN0cnVjdCBycGNfdGFzayAqdGFzaykKIHsKQEAgLTU5MCw3ICs1OTAsNyBAQAogICogICBFQUdBSU46CVRoZSBzb2NrZXQgd2FzIGJsb2NrZWQsIHBsZWFzZSBjYWxsIGFnYWluIGxhdGVyIHRvCiAgKgkJY29tcGxldGUgdGhlIHJlcXVlc3QKICAqIEVOT1RDT05OOglDYWxsZXIgbmVlZHMgdG8gaW52b2tlIGNvbm5lY3QgbG9naWMgdGhlbiBjYWxsIGFnYWluCi0gKiAgICBvdGhlcjoJU29tZSBvdGhlciBlcnJvciBvY2N1cmVkLCB0aGUgcmVxdWVzdCB3YXMgbm90IHNlbnQKKyAqICAgIG90aGVyOglTb21lIG90aGVyIGVycm9yIG9jY3VycmVkLCB0aGUgcmVxdWVzdCB3YXMgbm90IHNlbnQKICAqCiAgKiBYWFg6IEluIHRoZSBjYXNlIG9mIHNvZnQgdGltZW91dHMsIHNob3VsZCB3ZSBldmVudHVhbGx5IGdpdmUgdXAKICAqCWlmIHNlbmRtc2cgaXMgbm90IGFibGUgdG8gbWFrZSBwcm9ncmVzcz8KZGlmZiAtLWdpdCBhL25ldC90aXBjL2xpbmsuYyBiL25ldC90aXBjL2xpbmsuYwppbmRleCA0MzYzOWZmLi5lYmYzMzhmIDEwMDY0NAotLS0gYS9uZXQvdGlwYy9saW5rLmMKKysrIGIvbmV0L3RpcGMvbGluay5jCkBAIC0yNDcxLDcgKzI0NzEsNyBAQAogICogQSBwZW5kaW5nIG1lc3NhZ2UgYmVpbmcgcmUtYXNzZW1ibGVkIG11c3Qgc3RvcmUgY2VydGFpbiB2YWx1ZXMKICAqIHRvIGhhbmRsZSBzdWJzZXF1ZW50IGZyYWdtZW50cyBjb3JyZWN0bHkuIFRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zCiAgKiBoZWxwIHN0b3JpbmcgdGhlc2UgdmFsdWVzIGluIHVudXNlZCwgYXZhaWxhYmxlIGZpZWxkcyBpbiB0aGUKLSAqIHBlbmRpbmcgbWVzc2FnZS4gVGhpcyBtYWtlcyBkeW5hbWljIG1lbW9yeSBhbGxvY2F0aW9uIHVuZWNlc3NhcnkuCisgKiBwZW5kaW5nIG1lc3NhZ2UuIFRoaXMgbWFrZXMgZHluYW1pYyBtZW1vcnkgYWxsb2NhdGlvbiB1bm5lY2Vzc2FyeS4KICAqLwogCiBzdGF0aWMgdm9pZCBzZXRfbG9uZ19tc2dfc2Vxbm8oc3RydWN0IHNrX2J1ZmYgKmJ1ZiwgdTMyIHNlcW5vKQpkaWZmIC0tZ2l0IGEvbmV0L3RpcGMvbmFtZV9kaXN0ci5jIGIvbmV0L3RpcGMvbmFtZV9kaXN0ci5jCmluZGV4IGM5ZmE2ZGYuLjgwMDI1YTEgMTAwNjQ0Ci0tLSBhL25ldC90aXBjL25hbWVfZGlzdHIuYworKysgYi9uZXQvdGlwYy9uYW1lX2Rpc3RyLmMKQEAgLTE2MCw3ICsxNjAsNyBAQAogCiAJYnVmID0gbmFtZWRfcHJlcGFyZV9idWYoV0lUSERSQVdBTCwgSVRFTV9TSVpFLCAwKTsKIAlpZiAoIWJ1ZikgewotCQl3YXJuKCJXaXRoZHJhd2wgZGlzdHJpYnV0aW9uIGZhaWx1cmVcbiIpOworCQl3YXJuKCJXaXRoZHJhd2FsIGRpc3RyaWJ1dGlvbiBmYWlsdXJlXG4iKTsKIAkJcmV0dXJuOwogCX0KIApkaWZmIC0tZ2l0IGEvbmV0L3VuaXgvYWZfdW5peC5jIGIvbmV0L3VuaXgvYWZfdW5peC5jCmluZGV4IDE2NjNlMWEuLjNhNDNhODMgMTAwNjQ0Ci0tLSBhL25ldC91bml4L2FmX3VuaXguYworKysgYi9uZXQvdW5peC9hZl91bml4LmMKQEAgLTIwNyw3ICsyMDcsNyBAQAogCQkvKgogCQkgKiBUaGlzIG1heSBsb29rIGxpa2UgYW4gb2ZmIGJ5IG9uZSBlcnJvciBidXQgaXQgaXMgYSBiaXQgbW9yZQogCQkgKiBzdWJ0bGUuIDEwOCBpcyB0aGUgbG9uZ2VzdCB2YWxpZCBBRl9VTklYIHBhdGggZm9yIGEgYmluZGluZy4KLQkJICogc3VuX3BhdGhbMTA4XSBkb2VzbnQgYXMgc3VjaCBleGlzdC4gIEhvd2V2ZXIgaW4ga2VybmVsIHNwYWNlCisJCSAqIHN1bl9wYXRoWzEwOF0gZG9lc24ndCBhcyBzdWNoIGV4aXN0LiAgSG93ZXZlciBpbiBrZXJuZWwgc3BhY2UKIAkJICogd2UgYXJlIGd1YXJhbnRlZWQgdGhhdCBpdCBpcyBhIHZhbGlkIG1lbW9yeSBsb2NhdGlvbiBpbiBvdXIKIAkJICoga2VybmVsIGFkZHJlc3MgYnVmZmVyLgogCQkgKi8KZGlmZiAtLWdpdCBhL25ldC93YW5yb3V0ZXIvd2FucHJvYy5jIGIvbmV0L3dhbnJvdXRlci93YW5wcm9jLmMKaW5kZXggMTFmMjVjNy4uZjM0NjM5NSAxMDA2NDQKLS0tIGEvbmV0L3dhbnJvdXRlci93YW5wcm9jLmMKKysrIGIvbmV0L3dhbnJvdXRlci93YW5wcm9jLmMKQEAgLTUxLDcgKzUxLDcgQEAKIAogLyoKICAqCVN0cnVjdHVyZXMgZm9yIGludGVyZmFjaW5nIHdpdGggdGhlIC9wcm9jIGZpbGVzeXN0ZW0uCi0gKglSb3V0ZXIgY3JlYXRlcyBpdHMgb3duIGRpcmVjdG9yeSAvcHJvYy9uZXQvcm91dGVyIHdpdGggdGhlIGZvbG93aW5nCisgKglSb3V0ZXIgY3JlYXRlcyBpdHMgb3duIGRpcmVjdG9yeSAvcHJvYy9uZXQvcm91dGVyIHdpdGggdGhlIGZvbGxvd2luZwogICoJZW50cmllczoKICAqCWNvbmZpZwkJZGV2aWNlIGNvbmZpZ3VyYXRpb24KICAqCXN0YXR1cwkJZ2xvYmFsIGRldmljZSBzdGF0aXN0aWNzCmRpZmYgLS1naXQgYS9uZXQvd2lyZWxlc3MvcmVnLmMgYi9uZXQvd2lyZWxlc3MvcmVnLmMKaW5kZXggMzMzMmQ1Yi4uYWI4MDFhMSAxMDA2NDQKLS0tIGEvbmV0L3dpcmVsZXNzL3JlZy5jCisrKyBiL25ldC93aXJlbGVzcy9yZWcuYwpAQCAtODA5LDcgKzgwOSw3IEBACiAJaWYgKHIpIHsKIAkJLyoKIAkJICogV2Ugd2lsbCBkaXNhYmxlIGFsbCBjaGFubmVscyB0aGF0IGRvIG5vdCBtYXRjaCBvdXIKLQkJICogcmVjaWV2ZWQgcmVndWxhdG9yeSBydWxlIHVubGVzcyB0aGUgaGludCBpcyBjb21pbmcKKwkJICogcmVjZWl2ZWQgcmVndWxhdG9yeSBydWxlIHVubGVzcyB0aGUgaGludCBpcyBjb21pbmcKIAkJICogZnJvbSBhIENvdW50cnkgSUUgYW5kIHRoZSBDb3VudHJ5IElFIGhhZCBubyBpbmZvcm1hdGlvbgogCQkgKiBhYm91dCBhIGJhbmQuIFRoZSBJRUVFIDgwMi4xMSBzcGVjIGFsbG93cyBmb3IgYW4gQVAKIAkJICogdG8gc2VuZCBvbmx5IGEgc3Vic2V0IG9mIHRoZSByZWd1bGF0b3J5IHJ1bGVzIGFsbG93ZWQsCkBAIC04MzgsNyArODM4LDcgQEAKIAkgICAgcmVxdWVzdF93aXBoeSAmJiByZXF1ZXN0X3dpcGh5ID09IHdpcGh5ICYmCiAJICAgIHJlcXVlc3Rfd2lwaHktPmZsYWdzICYgV0lQSFlfRkxBR19TVFJJQ1RfUkVHVUxBVE9SWSkgewogCQkvKgotCQkgKiBUaGlzIGdhdXJhbnRlZXMgdGhlIGRyaXZlcidzIHJlcXVlc3RlZCByZWd1bGF0b3J5IGRvbWFpbgorCQkgKiBUaGlzIGd1YXJhbnRlZXMgdGhlIGRyaXZlcidzIHJlcXVlc3RlZCByZWd1bGF0b3J5IGRvbWFpbgogCQkgKiB3aWxsIGFsd2F5cyBiZSB1c2VkIGFzIGEgYmFzZSBmb3IgZnVydGhlciByZWd1bGF0b3J5CiAJCSAqIHNldHRpbmdzCiAJCSAqLwpkaWZmIC0tZ2l0IGEvbmV0L3gyNS94MjVfZmFjaWxpdGllcy5jIGIvbmV0L3gyNS94MjVfZmFjaWxpdGllcy5jCmluZGV4IDQwNjIwNzUuLmY3N2U0ZTcgMTAwNjQ0Ci0tLSBhL25ldC94MjUveDI1X2ZhY2lsaXRpZXMuYworKysgYi9uZXQveDI1L3gyNV9mYWNpbGl0aWVzLmMKQEAgLTMxLDcgKzMxLDcgQEAKICAqIHgyNV9wYXJzZV9mYWNpbGl0aWVzIC0gUGFyc2UgZmFjaWxpdGllcyBmcm9tIHNrYiBpbnRvIHRoZSBmYWNpbGl0aWVzIHN0cnVjdHMKICAqCiAgKiBAc2tiOiBza19idWZmIHRvIHBhcnNlCi0gKiBAZmFjaWxpdGllczogUmVndWxhciBmYWNpbGl0ZXMsIHVwZGF0ZWQgYXMgZmFjaWxpdGllcyBhcmUgZm91bmQKKyAqIEBmYWNpbGl0aWVzOiBSZWd1bGFyIGZhY2lsaXRpZXMsIHVwZGF0ZWQgYXMgZmFjaWxpdGllcyBhcmUgZm91bmQKICAqIEBkdGVfZmFjczogSVRVIERURSBmYWNpbGl0aWVzLCB1cGRhdGVkIGFzIERURSBmYWNpbGl0aWVzIGFyZSBmb3VuZAogICogQHZjX2ZhY19tYXNrOiBtYXNrIGlzIHVwZGF0ZWQgd2l0aCBhbGwgZmFjaWxpdGllcyBmb3VuZAogICoKZGlmZiAtLWdpdCBhL25ldC94MjUveDI1X2ZvcndhcmQuYyBiL25ldC94MjUveDI1X2ZvcndhcmQuYwppbmRleCAyNWE4MTA3Li5jNTQxYjYyIDEwMDY0NAotLS0gYS9uZXQveDI1L3gyNV9mb3J3YXJkLmMKKysrIGIvbmV0L3gyNS94MjVfZm9yd2FyZC5jCkBAIC0zMSw3ICszMSw3IEBACiAJCWdvdG8gb3V0X25vX3JvdXRlOwogCiAJaWYgKChuZWlnaF9uZXcgPSB4MjVfZ2V0X25laWdoKHJ0LT5kZXYpKSA9PSBOVUxMKSB7Ci0JCS8qIFRoaXMgc2hvdWxkbnQgaGFwcGVuLCBpZiBpdCBvY2N1cnMgc29tZWhvdworCQkvKiBUaGlzIHNob3VsZG4ndCBoYXBwZW4sIGlmIGl0IG9jY3VycyBzb21laG93CiAJCSAqIGRvIHNvbWV0aGluZyBzZW5zaWJsZQogCQkgKi8KIAkJZ290byBvdXRfcHV0X3JvdXRlOwpAQCAtNDUsNyArNDUsNyBAQAogCX0KIAogCS8qIFJlbW90ZSBlbmQgc2VuZGluZyBhIGNhbGwgcmVxdWVzdCBvbiBhbiBhbHJlYWR5Ci0JICogZXN0YWJsaXNoZWQgTENJPyBJdCBzaG91bGRudCBoYXBwZW4sIGp1c3QgaW4gY2FzZS4uCisJICogZXN0YWJsaXNoZWQgTENJPyBJdCBzaG91bGRuJ3QgaGFwcGVuLCBqdXN0IGluIGNhc2UuLgogCSAqLwogCXJlYWRfbG9ja19iaCgmeDI1X2ZvcndhcmRfbGlzdF9sb2NrKTsKIAlsaXN0X2Zvcl9lYWNoKGVudHJ5LCAmeDI1X2ZvcndhcmRfbGlzdCkgewpkaWZmIC0tZ2l0IGEvbmV0L3hmcm0veGZybV91c2VyLmMgYi9uZXQveGZybS94ZnJtX3VzZXIuYwppbmRleCAzZDE1ZDNlLi41ZDFkNjBkIDEwMDY0NAotLS0gYS9uZXQveGZybS94ZnJtX3VzZXIuYworKysgYi9uZXQveGZybS94ZnJtX3VzZXIuYwpAQCAtODk0LDcgKzg5NCw3IEBACiAJdTMyICpmOwogCiAJbmxoID0gbmxtc2dfcHV0KHNrYiwgcGlkLCBzZXEsIFhGUk1fTVNHX05FV1NQRElORk8sIHNpemVvZih1MzIpLCAwKTsKLQlpZiAobmxoID09IE5VTEwpIC8qIHNob3VsZG50IHJlYWxseSBoYXBwZW4gLi4uICovCisJaWYgKG5saCA9PSBOVUxMKSAvKiBzaG91bGRuJ3QgcmVhbGx5IGhhcHBlbiAuLi4gKi8KIAkJcmV0dXJuIC1FTVNHU0laRTsKIAogCWYgPSBubG1zZ19kYXRhKG5saCk7CkBAIC05NTQsNyArOTU0LDcgQEAKIAl1MzIgKmY7CiAKIAlubGggPSBubG1zZ19wdXQoc2tiLCBwaWQsIHNlcSwgWEZSTV9NU0dfTkVXU0FESU5GTywgc2l6ZW9mKHUzMiksIDApOwotCWlmIChubGggPT0gTlVMTCkgLyogc2hvdWxkbnQgcmVhbGx5IGhhcHBlbiAuLi4gKi8KKwlpZiAobmxoID09IE5VTEwpIC8qIHNob3VsZG4ndCByZWFsbHkgaGFwcGVuIC4uLiAqLwogCQlyZXR1cm4gLUVNU0dTSVpFOwogCiAJZiA9IG5sbXNnX2RhdGEobmxoKTsKQEAgLTEzNjEsNyArMTM2MSw3IEBACiAJaWYgKCF4cCkKIAkJcmV0dXJuIGVycjsKIAotCS8qIHNob3VsZG50IGV4Y2wgYmUgYmFzZWQgb24gbmxoIGZsYWdzPz8KKwkvKiBzaG91bGRuJ3QgZXhjbCBiZSBiYXNlZCBvbiBubGggZmxhZ3M/PwogCSAqIEFoYSEgdGhpcyBpcyBhbnRpLW5ldGxpbmsgcmVhbGx5IGkuZSAgbW9yZSBwZmtleSBkZXJpdmVkCiAJICogaW4gbmV0bGluayBleGNsIGlzIGEgZmxhZyBhbmQgeW91IHdvdWxkbnQgbmVlZAogCSAqIGEgdHlwZSBYRlJNX01TR19VUERQT0xJQ1kgLSBKSFMgKi8KZGlmZiAtLWdpdCBhL3NhbXBsZXMvS2NvbmZpZyBiL3NhbXBsZXMvS2NvbmZpZwppbmRleCBlMDNjZjBlLi40MTA2M2U3IDEwMDY0NAotLS0gYS9zYW1wbGVzL0tjb25maWcKKysrIGIvc2FtcGxlcy9LY29uZmlnCkBAIC01NSw3ICs1NSw3IEBACiAJICBJZiBpbiBkb3VidCwgc2F5ICJOIiBoZXJlLgogCiBjb25maWcgU0FNUExFX0tEQgotCXRyaXN0YXRlICJCdWlsZCBrZGIgY29tbWFuZCBleG1hcGxlIC0tIGxvYWRhYmxlIG1vZHVsZXMgb25seSIKKwl0cmlzdGF0ZSAiQnVpbGQga2RiIGNvbW1hbmQgZXhhbXBsZSAtLSBsb2FkYWJsZSBtb2R1bGVzIG9ubHkiCiAJZGVwZW5kcyBvbiBLR0RCX0tEQiAmJiBtCiAJaGVscAogCSAgQnVpbGQgYW4gZXhhbXBsZSBvZiBob3cgdG8gZHluYW1pY2FsbHkgYWRkIHRoZSBoZWxsbwpkaWZmIC0tZ2l0IGEvc2FtcGxlcy9od19icmVha3BvaW50L2RhdGFfYnJlYWtwb2ludC5jIGIvc2FtcGxlcy9od19icmVha3BvaW50L2RhdGFfYnJlYWtwb2ludC5jCmluZGV4IGJkMGYzMzcuLjA2MzY1MzkgMTAwNjQ0Ci0tLSBhL3NhbXBsZXMvaHdfYnJlYWtwb2ludC9kYXRhX2JyZWFrcG9pbnQuYworKysgYi9zYW1wbGVzL2h3X2JyZWFrcG9pbnQvZGF0YV9icmVha3BvaW50LmMKQEAgLTE5LDcgKzE5LDcgQEAKICAqCiAgKiBUaGlzIGZpbGUgaXMgYSBrZXJuZWwgbW9kdWxlIHRoYXQgcGxhY2VzIGEgYnJlYWtwb2ludCBvdmVyIGtzeW1fbmFtZSBrZXJuZWwKICAqIHZhcmlhYmxlIHVzaW5nIEhhcmR3YXJlIEJyZWFrcG9pbnQgcmVnaXN0ZXIuIFRoZSBjb3JyZXNwb25kaW5nIGhhbmRsZXIgd2hpY2gKLSAqIHByaW50cyBhIGJhY2t0cmFjZSBpcyBpbnZva2VkIGV2ZXJ5dGltZSBhIHdyaXRlIG9wZXJhdGlvbiBpcyBwZXJmb3JtZWQgb24KKyAqIHByaW50cyBhIGJhY2t0cmFjZSBpcyBpbnZva2VkIGV2ZXJ5IHRpbWUgYSB3cml0ZSBvcGVyYXRpb24gaXMgcGVyZm9ybWVkIG9uCiAgKiB0aGF0IHZhcmlhYmxlLgogICoKICAqIENvcHlyaWdodCAoQykgSUJNIENvcnBvcmF0aW9uLCAyMDA5CmRpZmYgLS1naXQgYS9zY3JpcHRzL01ha2VmaWxlLm1vZHBvc3QgYi9zY3JpcHRzL01ha2VmaWxlLm1vZHBvc3QKaW5kZXggN2QyMjA1Ni4uNTZkZmFmYyAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZS5tb2Rwb3N0CisrKyBiL3NjcmlwdHMvTWFrZWZpbGUubW9kcG9zdApAQCAtMzUsMTQgKzM1LDE0IEBACiAjIEtCVUlMRF9NT0RQT1NUX1dBUk4gY2FuIGJlIHNldCB0byBhdm9pZCBlcnJvciBvdXQgaW4gY2FzZSBvZiB1bmRlZmluZWQKICMgc3ltYm9scyBpbiB0aGUgZmluYWwgbW9kdWxlIGxpbmtpbmcgc3RhZ2UKICMgS0JVSUxEX01PRFBPU1RfTk9GSU5BTCBjYW4gYmUgc2V0IHRvIHNraXAgdGhlIGZpbmFsIGxpbmsgb2YgbW9kdWxlcy4KLSMgVGhpcyBpcyBzb2xlbHkgdXNlZnVsbCB0byBzcGVlZCB1cCB0ZXN0IGNvbXBpbGVzCisjIFRoaXMgaXMgc29sZWx5IHVzZWZ1bCB0byBzcGVlZCB1cCB0ZXN0IGNvbXBpbGVzCiBQSE9OWSA6PSBfbW9kcG9zdAogX21vZHBvc3Q6IF9fbW9kcG9zdAogCiBpbmNsdWRlIGluY2x1ZGUvY29uZmlnL2F1dG8uY29uZgogaW5jbHVkZSBzY3JpcHRzL0tidWlsZC5pbmNsdWRlCiAKLSMgV2hlbiBidWlsZGluZyBleHRlcm5hbCBtb2R1bGVzIGxvYWQgdGhlIEtidWlsZCBmaWxlIHRvIHJldHJlaXZlIEVYVFJBX1NZTUJPTFMgaW5mbworIyBXaGVuIGJ1aWxkaW5nIGV4dGVybmFsIG1vZHVsZXMgbG9hZCB0aGUgS2J1aWxkIGZpbGUgdG8gcmV0cmlldmUgRVhUUkFfU1lNQk9MUyBpbmZvCiBpZm5lcSAoJChLQlVJTERfRVhUTU9EKSwpCiAKICMgc2V0IHNyYyArIG9iaiAtIHRoZXkgbWF5IGJlIHVzZWQgd2hlbiBidWlsZGluZyB0aGUgLm1vZC5jIGZpbGUKZGlmZiAtLWdpdCBhL3NjcmlwdHMvY2hlY2twYXRjaC5wbCBiL3NjcmlwdHMvY2hlY2twYXRjaC5wbAppbmRleCA4ZjllMzk0Li5kODY3MDgxIDEwMDc1NQotLS0gYS9zY3JpcHRzL2NoZWNrcGF0Y2gucGwKKysrIGIvc2NyaXB0cy9jaGVja3BhdGNoLnBsCkBAIC0xOTQ2LDEzICsxOTQ2LDEzIEBACiAjIHByaW50ayBzaG91bGQgdXNlIEtFUk5fKiBsZXZlbHMuICBOb3RlIHRoYXQgZm9sbG93IG9uIHByaW50aydzIG9uIHRoZQogIyBzYW1lIGxpbmUgZG8gbm90IG5lZWQgYSBsZXZlbCwgc28gd2UgdXNlIHRoZSBjdXJyZW50IGJsb2NrIGNvbnRleHQKICMgdG8gdHJ5IGFuZCBmaW5kIGFuZCB2YWxpZGF0ZSB0aGUgY3VycmVudCBwcmludGsuICBJbiBzdW1tYXJ5IHRoZSBjdXJyZW50Ci0jIHByaW50ayBpbmNsdWRlcyBhbGwgcHJlY2VlZGluZyBwcmludGsncyB3aGljaCBoYXZlIG5vIG5ld2xpbmUgb24gdGhlIGVuZC4KKyMgcHJpbnRrIGluY2x1ZGVzIGFsbCBwcmVjZWRpbmcgcHJpbnRrJ3Mgd2hpY2ggaGF2ZSBubyBuZXdsaW5lIG9uIHRoZSBlbmQuCiAjIHdlIGFzc3VtZSB0aGUgZmlyc3QgYmFkIHByaW50ayBpcyB0aGUgb25lIHRvIHJlcG9ydC4KIAkJaWYgKCRsaW5lID1+IC9cYnByaW50a1woKD8hS0VSTl8pXHMqIi8pIHsKIAkJCW15ICRvayA9IDA7CiAJCQlmb3IgKG15ICRsbiA9ICRsaW5lbnIgLSAxOyAkbG4gPj0gJGZpcnN0X2xpbmU7ICRsbi0tKSB7CiAJCQkJI3ByaW50ICJDSEVDSzwkbGluZXNbJGxuIC0gMV1cbiI7Ci0JCQkJIyB3ZSBoYXZlIGEgcHJlY2VlZGluZyBwcmludGsgaWYgaXQgZW5kcworCQkJCSMgd2UgaGF2ZSBhIHByZWNlZGluZyBwcmludGsgaWYgaXQgZW5kcwogCQkJCSMgd2l0aCAiXG4iIGlnbm9yZSBpdCwgZWxzZSBpdCBpcyB0byBibGFtZQogCQkJCWlmICgkbGluZXNbJGxuIC0gMV0gPX4gbXtcYnByaW50a1wofSkgewogCQkJCQlpZiAoJHJhd2xpbmVzWyRsbiAtIDFdICF+IG17XFxuIn0pIHsKQEAgLTIwNDQsNyArMjA0NCw3IEBACiAJCQlmb3IgKG15ICRuID0gMDsgJG4gPCAkI2VsZW1lbnRzOyAkbiArPSAyKSB7CiAJCQkJJG9mZiArPSBsZW5ndGgoJGVsZW1lbnRzWyRuXSk7CiAKLQkJCQkjIFBpY2sgdXAgdGhlIHByZWNlZWRpbmcgYW5kIHN1Y2NlZWRpbmcgY2hhcmFjdGVycy4KKwkJCQkjIFBpY2sgdXAgdGhlIHByZWNlZGluZyBhbmQgc3VjY2VlZGluZyBjaGFyYWN0ZXJzLgogCQkJCW15ICRjYSA9IHN1YnN0cigkb3BsaW5lLCAwLCAkb2ZmKTsKIAkJCQlteSAkY2MgPSAnJzsKIAkJCQlpZiAobGVuZ3RoKCRvcGxpbmUpID49ICgkb2ZmICsgbGVuZ3RoKCRlbGVtZW50c1skbiArIDFdKSkpIHsKZGlmZiAtLWdpdCBhL3NjcmlwdHMvZHRjL2xpYmZkdC9saWJmZHQuaCBiL3NjcmlwdHMvZHRjL2xpYmZkdC9saWJmZHQuaAppbmRleCBjZTgwZTRmLi5mZjYyNDZmIDEwMDY0NAotLS0gYS9zY3JpcHRzL2R0Yy9saWJmZHQvbGliZmR0LmgKKysrIGIvc2NyaXB0cy9kdGMvbGliZmR0L2xpYmZkdC5oCkBAIC02MSw3ICs2MSw3IEBACiAjZGVmaW5lIEZEVF9FUlJfTk9URk9VTkQJMQogCS8qIEZEVF9FUlJfTk9URk9VTkQ6IFRoZSByZXF1ZXN0ZWQgbm9kZSBvciBwcm9wZXJ0eSBkb2VzIG5vdCBleGlzdCAqLwogI2RlZmluZSBGRFRfRVJSX0VYSVNUUwkJMgotCS8qIEZEVF9FUlJfRVhJU1RTOiBBdHRlbXBlZCB0byBjcmVhdGUgYSBub2RlIG9yIHByb3BlcnR5IHdoaWNoCisJLyogRkRUX0VSUl9FWElTVFM6IEF0dGVtcHRlZCB0byBjcmVhdGUgYSBub2RlIG9yIHByb3BlcnR5IHdoaWNoCiAJICogYWxyZWFkeSBleGlzdHMgKi8KICNkZWZpbmUgRkRUX0VSUl9OT1NQQUNFCQkzCiAJLyogRkRUX0VSUl9OT1NQQUNFOiBPcGVyYXRpb24gbmVlZGVkIHRvIGV4cGFuZCB0aGUgZGV2aWNlCmRpZmYgLS1naXQgYS9zY3JpcHRzL2R0Yy9saXZldHJlZS5jIGIvc2NyaXB0cy9kdGMvbGl2ZXRyZWUuYwppbmRleCBjOTIwOWQ1Li4yNmQwZTFlIDEwMDY0NAotLS0gYS9zY3JpcHRzL2R0Yy9saXZldHJlZS5jCisrKyBiL3NjcmlwdHMvZHRjL2xpdmV0cmVlLmMKQEAgLTE1NSw3ICsxNTUsNyBAQAogCQkJfQogCQl9CiAKLQkJLyogaWYgbm8gY29sbGlzaW9uIG9jY3VyZWQsIGFkZCBjaGlsZCB0byB0aGUgb2xkIG5vZGUuICovCisJCS8qIGlmIG5vIGNvbGxpc2lvbiBvY2N1cnJlZCwgYWRkIGNoaWxkIHRvIHRoZSBvbGQgbm9kZS4gKi8KIAkJaWYgKG5ld19jaGlsZCkKIAkJCWFkZF9jaGlsZChvbGRfbm9kZSwgbmV3X2NoaWxkKTsKIAl9CmRpZmYgLS1naXQgYS9zY3JpcHRzL2dlbl9pbml0cmFtZnNfbGlzdC5zaCBiL3NjcmlwdHMvZ2VuX2luaXRyYW1mc19saXN0LnNoCmluZGV4IDU1Y2FlY2QuLmUxMmIxYTcgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvZ2VuX2luaXRyYW1mc19saXN0LnNoCisrKyBiL3NjcmlwdHMvZ2VuX2luaXRyYW1mc19saXN0LnNoCkBAIC0yODQsNyArMjg0LDcgQEAKIGRvbmUKIAogIyBJZiBvdXRwdXRfZmlsZSBpcyBzZXQgd2Ugd2lsbCBnZW5lcmF0ZSBjcGlvIGFyY2hpdmUgYW5kIGNvbXByZXNzIGl0Ci0jIHdlIGFyZSBjYXJlZnVsbCB0byBkZWxldGUgdG1wIGZpbGVzCisjIHdlIGFyZSBjYXJlZnVsIHRvIGRlbGV0ZSB0bXAgZmlsZXMKIGlmIFsgISAteiAke291dHB1dF9maWxlfSBdOyB0aGVuCiAJaWYgWyAteiAke2NwaW9fZmlsZX0gXTsgdGhlbgogCQljcGlvX3RmaWxlPSIkKG1rdGVtcCAke1RNUERJUjotL3RtcH0vY3Bpb2ZpbGUuWFhYWFhYKSIKZGlmZiAtLWdpdCBhL3NjcmlwdHMva2VybmVsLWRvYyBiL3NjcmlwdHMva2VybmVsLWRvYwppbmRleCA5Zjg1MDEyLi5kNzkzMDAxIDEwMDc1NQotLS0gYS9zY3JpcHRzL2tlcm5lbC1kb2MKKysrIGIvc2NyaXB0cy9rZXJuZWwtZG9jCkBAIC0xNzA1LDcgKzE3MDUsNyBAQAogCiAJJHBhcmFtID0geG1sX2VzY2FwZSgkcGFyYW0pOwogCi0JIyBzdHJpcCBzcGFjZXMgZnJvbSAkcGFyYW0gc28gdGhhdCBpdCBpcyBvbmUgY29udGlub3VzIHN0cmluZworCSMgc3RyaXAgc3BhY2VzIGZyb20gJHBhcmFtIHNvIHRoYXQgaXQgaXMgb25lIGNvbnRpbnVvdXMgc3RyaW5nCiAJIyBvbiBAcGFyYW1ldGVybGlzdDsKIAkjIHRoaXMgZml4ZXMgYSBwcm9ibGVtIHdoZXJlIGNoZWNrX3NlY3Rpb25zKCkgY2Fubm90IGZpbmQKIAkjIGEgcGFyYW1ldGVyIGxpa2UgImFkZHJbNiArIDJdIiBiZWNhdXNlIGl0IGFjdHVhbGx5IGFwcGVhcnMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvcGFja2FnZS9idWlsZHRhciBiL3NjcmlwdHMvcGFja2FnZS9idWlsZHRhcgppbmRleCA4M2M5YzA0Li44YTdiMTU1IDEwMDY0NAotLS0gYS9zY3JpcHRzL3BhY2thZ2UvYnVpbGR0YXIKKysrIGIvc2NyaXB0cy9wYWNrYWdlL2J1aWxkdGFyCkBAIC05Miw3ICs5Miw3IEBACiAJCWVjaG8gIiIgPiYyCiAJCWVjaG8gJyoqICoqICoqICBXQVJOSU5HICAqKiAqKiAqKicgPiYyCiAJCWVjaG8gIiIgPiYyCi0JCWVjaG8gIllvdXIgYXJjaGl0ZWN0dXJlIGRpZCBub3QgZGVmaW5lIGFueSBhcmNoaXRlY3R1cmUtZGVwZW5kYW50IGZpbGVzIiA+JjIKKwkJZWNobyAiWW91ciBhcmNoaXRlY3R1cmUgZGlkIG5vdCBkZWZpbmUgYW55IGFyY2hpdGVjdHVyZS1kZXBlbmRlbnQgZmlsZXMiID4mMgogCQllY2hvICJ0byBiZSBwbGFjZWQgaW50byB0aGUgdGFyYmFsbC4gUGxlYXNlIGFkZCB0aG9zZSB0byAkezB9IC4uLiIgPiYyCiAJCWVjaG8gIiIgPiYyCiAJCXNsZWVwIDUKZGlmZiAtLWdpdCBhL3NjcmlwdHMvcnQtdGVzdGVyL3J0LXRlc3Rlci5weSBiL3NjcmlwdHMvcnQtdGVzdGVyL3J0LXRlc3Rlci5weQppbmRleCA4YzgxZDc2Li4zNDE4NmNhIDEwMDY0NAotLS0gYS9zY3JpcHRzL3J0LXRlc3Rlci9ydC10ZXN0ZXIucHkKKysrIGIvc2NyaXB0cy9ydC10ZXN0ZXIvcnQtdGVzdGVyLnB5CkBAIC0xODAsNyArMTgwLDcgQEAKICAgICAgICAgICAgICAgICBmb3IgcyBpbiBzdGF0OgogCQkgICAgcyA9IHMuc3RyaXAoKQogICAgICAgICAgICAgICAgICAgICBpZiBzLnN0YXJ0c3dpdGgodGVzdG9wWzBdKToKLSAgICAgICAgICAgICAgICAgICAgICAgICMgU2VwZXJhdGUgc3RhdHVzIHZhbHVlCisgICAgICAgICAgICAgICAgICAgICAgICAjIFNlcGFyYXRlIHN0YXR1cyB2YWx1ZQogICAgICAgICAgICAgICAgICAgICAgICAgdmFsID0gc1syOl0uc3RyaXAoKQogICAgICAgICAgICAgICAgICAgICAgICAgcXVlcnkgPSBhbmFseXNlKHZhbCwgdGVzdG9wLCBkYXQpCiAgICAgICAgICAgICAgICAgICAgICAgICBicmVhawpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvYXBwYXJtb3IvbWF0Y2guYyBiL3NlY3VyaXR5L2FwcGFybW9yL21hdGNoLmMKaW5kZXggNWNiNGRjMS4uMDZkNzY0YyAxMDA2NDQKLS0tIGEvc2VjdXJpdHkvYXBwYXJtb3IvbWF0Y2guYworKysgYi9zZWN1cml0eS9hcHBhcm1vci9tYXRjaC5jCkBAIC0xOTUsNyArMTk1LDcgQEAKICAqCiAgKiBVbnBhY2sgYSBkZmEgdGhhdCBoYXMgYmVlbiBzZXJpYWxpemVkLiAgVG8gZmluZCBpbmZvcm1hdGlvbiBvbiB0aGUgZGZhCiAgKiBmb3JtYXQgbG9vayBpbiBEb2N1bWVudGF0aW9uL2FwcGFybW9yLnR4dAotICogQXNzdW1lcyB0aGUgZGZhIEBibG9iIHN0cmVhbSBoYXMgYmVlbiBhbGlnbmVkIG9uIGEgOCBieXRlIGJvdW5kcnkKKyAqIEFzc3VtZXMgdGhlIGRmYSBAYmxvYiBzdHJlYW0gaGFzIGJlZW4gYWxpZ25lZCBvbiBhIDggYnl0ZSBib3VuZGFyeQogICoKICAqIFJldHVybnM6IGFuIHVucGFja2VkIGRmYSByZWFkeSBmb3IgbWF0Y2hpbmcgb3IgRVJSX1BUUiBvbiBmYWlsdXJlCiAgKi8KZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2FwcGFybW9yL3BvbGljeV91bnBhY2suYyBiL3NlY3VyaXR5L2FwcGFybW9yL3BvbGljeV91bnBhY2suYwppbmRleCBlYjM3MDBlLi5lMzNhYWY3IDEwMDY0NAotLS0gYS9zZWN1cml0eS9hcHBhcm1vci9wb2xpY3lfdW5wYWNrLmMKKysrIGIvc2VjdXJpdHkvYXBwYXJtb3IvcG9saWN5X3VucGFjay5jCkBAIC0zNTksNyArMzU5LDcgQEAKICAqIEBlOiBzZXJpYWxpemVkIGRhdGEgZXh0ZW50IGluZm9ybWF0aW9uICAoTk9UIE5VTEwpCiAgKiBAcHJvZmlsZTogcHJvZmlsZSB0byBhZGQgdGhlIGFjY2VwdCB0YWJsZSB0byAoTk9UIE5VTEwpCiAgKgotICogUmV0dXJuczogMSBpZiB0YWJsZSBzdWNjZXNmdWxseSB1bnBhY2tlZAorICogUmV0dXJuczogMSBpZiB0YWJsZSBzdWNjZXNzZnVsbHkgdW5wYWNrZWQKICAqLwogc3RhdGljIGJvb2wgdW5wYWNrX3RyYW5zX3RhYmxlKHN0cnVjdCBhYV9leHQgKmUsIHN0cnVjdCBhYV9wcm9maWxlICpwcm9maWxlKQogewpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvc2VsaW51eC9uZXRsYWJlbC5jIGIvc2VjdXJpdHkvc2VsaW51eC9uZXRsYWJlbC5jCmluZGV4IDFjMmZjNDYuLmMzYmYzZWQgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L3NlbGludXgvbmV0bGFiZWwuYworKysgYi9zZWN1cml0eS9zZWxpbnV4L25ldGxhYmVsLmMKQEAgLTE1MSw3ICsxNTEsNyBAQAogICoKICAqIERlc2NyaXB0aW9uOgogICogQ2FsbGVkIHdoZW4gdGhlIE5ldExhYmVsIHN0YXRlIG9mIGEgc2tfc2VjdXJpdHlfc3RydWN0IG5lZWRzIHRvIGJlIHJlc2V0LgotICogVGhlIGNhbGxlciBpcyByZXNwb25zaWJpbGUgZm9yIGFsbCB0aGUgTmV0TGFiZWwgc2tfc2VjdXJpdHlfc3RydWN0IGxvY2tpbmcuCisgKiBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmxlIGZvciBhbGwgdGhlIE5ldExhYmVsIHNrX3NlY3VyaXR5X3N0cnVjdCBsb2NraW5nLgogICoKICAqLwogdm9pZCBzZWxpbnV4X25ldGxibF9za19zZWN1cml0eV9yZXNldChzdHJ1Y3Qgc2tfc2VjdXJpdHlfc3RydWN0ICpza3NlYykKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L3NlbGludXgvc3Mvc2VydmljZXMuYyBiL3NlY3VyaXR5L3NlbGludXgvc3Mvc2VydmljZXMuYwppbmRleCBlYTdjMDFmLi42ZWY0YWY0IDEwMDY0NAotLS0gYS9zZWN1cml0eS9zZWxpbnV4L3NzL3NlcnZpY2VzLmMKKysrIGIvc2VjdXJpdHkvc2VsaW51eC9zcy9zZXJ2aWNlcy5jCkBAIC0yODA2LDcgKzI4MDYsNyBAQAogCWNhc2UgQVVESVRfU1VCSl9DTFI6CiAJY2FzZSBBVURJVF9PQkpfTEVWX0xPVzoKIAljYXNlIEFVRElUX09CSl9MRVZfSElHSDoKLQkJLyogd2UgZG8gbm90IGFsbG93IGEgcmFuZ2UsIGluZGljYXRlZCBieSB0aGUgcHJlc2Vuc2Ugb2YgJy0nICovCisJCS8qIHdlIGRvIG5vdCBhbGxvdyBhIHJhbmdlLCBpbmRpY2F0ZWQgYnkgdGhlIHByZXNlbmNlIG9mICctJyAqLwogCQlpZiAoc3RyY2hyKHJ1bGVzdHIsICctJykpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJYnJlYWs7CkBAIC0zMDc1LDcgKzMwNzUsNyBAQAogICogRGVzY3JpcHRpb246CiAgKiBDb252ZXJ0IHRoZSBnaXZlbiBOZXRMYWJlbCBzZWN1cml0eSBhdHRyaWJ1dGVzIGluIEBzZWNhdHRyIGludG8gYQogICogU0VMaW51eCBTSUQuICBJZiB0aGUgQHNlY2F0dHIgZmllbGQgZG9lcyBub3QgY29udGFpbiBhIGZ1bGwgU0VMaW51eAotICogU0lEL2NvbnRleHQgdGhlbiB1c2UgU0VDSU5JVFNJRF9ORVRNU0cgYXMgdGhlIGZvdW5kYXRpb24uICBJZiBwb3NzaWJpbGUgdGhlCisgKiBTSUQvY29udGV4dCB0aGVuIHVzZSBTRUNJTklUU0lEX05FVE1TRyBhcyB0aGUgZm91bmRhdGlvbi4gIElmIHBvc3NpYmxlIHRoZQogICogJ2NhY2hlJyBmaWVsZCBvZiBAc2VjYXR0ciBpcyBzZXQgYW5kIHRoZSBDQUNIRSBmbGFnIGlzIHNldDsgdGhpcyBpcyB0bwogICogYWxsb3cgdGhlIEBzZWNhdHRyIHRvIGJlIHVzZWQgYnkgTmV0TGFiZWwgdG8gY2FjaGUgdGhlIHNlY2F0dHIgdG8gU0lECiAgKiBjb252ZXJzaW9uIGZvciBmdXR1cmUgbG9va3Vwcy4gIFJldHVybnMgemVybyBvbiBzdWNjZXNzLCBuZWdhdGl2ZSB2YWx1ZXMgb24KZGlmZiAtLWdpdCBhL3NlY3VyaXR5L3NtYWNrL3NtYWNrX2FjY2Vzcy5jIGIvc2VjdXJpdHkvc21hY2svc21hY2tfYWNjZXNzLmMKaW5kZXggODY0NTNkYi4uOTYzN2UxMCAxMDA2NDQKLS0tIGEvc2VjdXJpdHkvc21hY2svc21hY2tfYWNjZXNzLmMKKysrIGIvc2VjdXJpdHkvc21hY2svc21hY2tfYWNjZXNzLmMKQEAgLTQzMSw3ICs0MzEsNyBAQAogICogc21hY2tfZnJvbV9zZWNpZCAtIGZpbmQgdGhlIFNtYWNrIGxhYmVsIGFzc29jaWF0ZWQgd2l0aCBhIHNlY2lkCiAgKiBAc2VjaWQ6IGFuIGludGVnZXIgdGhhdCBtaWdodCBiZSBhc3NvY2lhdGVkIHdpdGggYSBTbWFjayBsYWJlbAogICoKLSAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBhcHByb3ByYWl0ZSBTbWFjayBsYWJlbCBpZiB0aGVyZSBpcyBvbmUsCisgKiBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgYXBwcm9wcmlhdGUgU21hY2sgbGFiZWwgaWYgdGhlcmUgaXMgb25lLAogICogb3RoZXJ3aXNlIGEgcG9pbnRlciB0byB0aGUgaW52YWxpZCBTbWFjayBsYWJlbC4KICAqLwogY2hhciAqc21hY2tfZnJvbV9zZWNpZChjb25zdCB1MzIgc2VjaWQpCmRpZmYgLS1naXQgYS9zZWN1cml0eS9zbWFjay9zbWFja19sc20uYyBiL3NlY3VyaXR5L3NtYWNrL3NtYWNrX2xzbS5jCmluZGV4IDIzYzdhNmQuLmM2ZjhmY2EgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L3NtYWNrL3NtYWNrX2xzbS5jCisrKyBiL3NlY3VyaXR5L3NtYWNrL3NtYWNrX2xzbS5jCkBAIC0xNzk0LDcgKzE3OTQsNyBAQAogICogQ2FzZXkgc2F5cyB0aGF0IENJUFNPIGlzIGdvb2QgZW5vdWdoIGZvciBub3cuCiAgKiBJdCBjYW4gYmUgdXNlZCB0byBlZmZlY3QuCiAgKiBJdCBjYW4gYWxzbyBiZSBhYnVzZWQgdG8gZWZmZWN0IHdoZW4gbmVjZXNzYXJ5LgotICogQXBwb2xvZ2llcyB0byB0aGUgVFNJRyBncm91cCBpbiBnZW5lcmFsIGFuZCBHVyBpbiBwYXJ0aWN1bGFyLgorICogQXBvbG9naWVzIHRvIHRoZSBUU0lHIGdyb3VwIGluIGdlbmVyYWwgYW5kIEdXIGluIHBhcnRpY3VsYXIuCiAgKi8KIHN0YXRpYyB2b2lkIHNtYWNrX3RvX3NlY2F0dHIoY2hhciAqc21hY2ssIHN0cnVjdCBuZXRsYmxfbHNtX3NlY2F0dHIgKm5sc3ApCiB7CkBAIC0yNTMwLDcgKzI1MzAsNyBAQAogCXN3aXRjaCAoc2JwLT5zX21hZ2ljKSB7CiAJY2FzZSBTTUFDS19NQUdJQzoKIAkJLyoKLQkJICogQ2FzZXkgc2F5cyB0aGF0IGl0J3MgYSBsaXR0bGUgZW1iYXJhc3NpbmcKKwkJICogQ2FzZXkgc2F5cyB0aGF0IGl0J3MgYSBsaXR0bGUgZW1iYXJyYXNzaW5nCiAJCSAqIHRoYXQgdGhlIHNtYWNrIGZpbGUgc3lzdGVtIGRvZXNuJ3QgZG8KIAkJICogZXh0ZW5kZWQgYXR0cmlidXRlcy4KIAkJICovCkBAIC0zMDg0LDcgKzMwODQsNyBAQAogCS8qCiAJICogV2UgbmVlZCB0byBkZWNpZGUgaWYgd2Ugd2FudCB0byBsYWJlbCB0aGUgaW5jb21pbmcgY29ubmVjdGlvbiBoZXJlCiAJICogaWYgd2UgZG8gd2Ugb25seSBuZWVkIHRvIGxhYmVsIHRoZSByZXF1ZXN0X3NvY2sgYW5kIHRoZSBzdGFjayB3aWxsCi0JICogcHJvcG9nYXRlIHRoZSB3aXJlLWxhYmVsIHRvIHRoZSBzb2NrIHdoZW4gaXQgaXMgY3JlYXRlZC4KKwkgKiBwcm9wYWdhdGUgdGhlIHdpcmUtbGFiZWwgdG8gdGhlIHNvY2sgd2hlbiBpdCBpcyBjcmVhdGVkLgogCSAqLwogCWhkciA9IGlwX2hkcihza2IpOwogCWFkZHIuc2luX2FkZHIuc19hZGRyID0gaGRyLT5zYWRkcjsKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L3NtYWNrL3NtYWNrZnMuYyBiL3NlY3VyaXR5L3NtYWNrL3NtYWNrZnMuYwppbmRleCA5MGQxYmJhLi5mOTM0NjAxIDEwMDY0NAotLS0gYS9zZWN1cml0eS9zbWFjay9zbWFja2ZzLmMKKysrIGIvc2VjdXJpdHkvc21hY2svc21hY2tmcy5jCkBAIC0yMDgsNyArMjA4LDcgQEAKIAlpZiAoKnBwb3MgIT0gMCkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJLyoKLQkgKiBNaW5vciBoYWNrIGZvciBiYWNrd2FyZCBjb21wYXRhYmlsaXR5CisJICogTWlub3IgaGFjayBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eQogCSAqLwogCWlmIChjb3VudCA8IChTTUtfT0xPQURMRU4pIHx8IGNvdW50ID4gU01LX0xPQURMRU4pCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMjIzLDcgKzIyMyw3IEBACiAJfQogCiAJLyoKLQkgKiBNb3JlIG9uIHRoZSBtaW5vciBoYWNrIGZvciBiYWNrd2FyZCBjb21wYXRhYmlsaXR5CisJICogTW9yZSBvbiB0aGUgbWlub3IgaGFjayBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eQogCSAqLwogCWlmIChjb3VudCA9PSAoU01LX09MT0FETEVOKSkKIAkJZGF0YVtTTUtfT0xPQURMRU5dID0gJy0nOwpAQCAtOTI3LDcgKzkyNyw3IEBACiAJCX0KIAl9IGVsc2UgewogCQkvKiB3ZSBkZWxldGUgdGhlIHVubGFiZWxlZCBlbnRyeSwgb25seSBpZiB0aGUgcHJldmlvdXMgbGFiZWwKLQkJICogd2FzbnQgdGhlIHNwZWNpYWwgQ0lQU08gb3B0aW9uICovCisJCSAqIHdhc24ndCB0aGUgc3BlY2lhbCBDSVBTTyBvcHRpb24gKi8KIAkJaWYgKHNrcC0+c21rX2xhYmVsICE9IHNtYWNrX2NpcHNvX29wdGlvbikKIAkJCXJjID0gbmV0bGJsX2NmZ191bmxibF9zdGF0aWNfZGVsKCZpbml0X25ldCwgTlVMTCwKIAkJCQkJJnNrcC0+c21rX2hvc3Quc2luX2FkZHIsICZza3AtPnNta19tYXNrLApkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvdG9tb3lvL2xvYWRfcG9saWN5LmMgYi9zZWN1cml0eS90b21veW8vbG9hZF9wb2xpY3kuYwppbmRleCBiYmFkYTdjLi4zMzEyZTU2IDEwMDY0NAotLS0gYS9zZWN1cml0eS90b21veW8vbG9hZF9wb2xpY3kuYworKysgYi9zZWN1cml0eS90b21veW8vbG9hZF9wb2xpY3kuYwpAQCAtMjMsNyArMjMsNyBAQAogCSAqIElmIHRoZSBpbml0cmQgaW5jbHVkZXMgL3NiaW4vaW5pdCBidXQgcmVhbC1yb290LWRldiBoYXMgbm90CiAJICogbW91bnRlZCBvbiAvIHlldCwgYWN0aXZhdGluZyBNQUMgd2lsbCBibG9jayB0aGUgc3lzdGVtIHNpbmNlCiAJICogcG9saWNpZXMgYXJlIG5vdCBsb2FkZWQgeWV0LgotCSAqIFRodXMsIGxldCBkb19leGVjdmUoKSBjYWxsIHRoaXMgZnVuY3Rpb24gZXZlcnl0aW1lLgorCSAqIFRodXMsIGxldCBkb19leGVjdmUoKSBjYWxsIHRoaXMgZnVuY3Rpb24gZXZlcnkgdGltZS4KIAkgKi8KIAlzdHJ1Y3QgcGF0aCBwYXRoOwogCmRpZmYgLS1naXQgYS9zb3VuZC9hb2EvY29kZWNzL3Rhcy5jIGIvc291bmQvYW9hL2NvZGVjcy90YXMuYwppbmRleCBmZDIxODhjLi41ODgwNGM3IDEwMDY0NAotLS0gYS9zb3VuZC9hb2EvY29kZWNzL3Rhcy5jCisrKyBiL3NvdW5kL2FvYS9jb2RlY3MvdGFzLmMKQEAgLTE3MCw3ICsxNzAsNyBAQAogCS8qIGFuYWx5c2luZyB0aGUgdm9sdW1lIGFuZCBtaXhlciB0YWJsZXMgc2hvd3MKIAkgKiB0aGF0IHRoZXkgYXJlIHNpbWlsYXIgZW5vdWdoIHdoZW4gd2Ugc2hpZnQKIAkgKiB0aGUgbWl4ZXIgdGFibGUgZG93biBieSA0IGJpdHMuIFRoZSBlcnJvcgotCSAqIGlzIG1pbmlzY3VsZSwgaW4ganVzdCBvbmUgaXRlbSB0aGUgZXJyb3IKKwkgKiBpcyBtaW51c2N1bGUsIGluIGp1c3Qgb25lIGl0ZW0gdGhlIGVycm9yCiAJICogaXMgMSwgYXQgYSB2YWx1ZSBvZiAweDA3ZjE3YiAobWl4ZXIgdGFibGUKIAkgKiB2YWx1ZSBpcyAweDA3ZjE3YSkgKi8KIAl0bXAgPSB0YXNfZ2FpbnRhYmxlW2xlZnRdOwpkaWZmIC0tZ2l0IGEvc291bmQvYXJtL3B4YTJ4eC1wY20tbGliLmMgYi9zb3VuZC9hcm0vcHhhMnh4LXBjbS1saWIuYwppbmRleCA4ODA4YjgyLi43NmUwZDU2IDEwMDY0NAotLS0gYS9zb3VuZC9hcm0vcHhhMnh4LXBjbS1saWIuYworKysgYi9zb3VuZC9hcm0vcHhhMnh4LXBjbS1saWIuYwpAQCAtMTQwLDYgKzE0MCw5IEBACiAJaWYgKCFwcnRkIHx8ICFwcnRkLT5wYXJhbXMpCiAJCXJldHVybiAwOwogCisJaWYgKHBydGQtPmRtYV9jaCA9PSAtMSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKIAlEQ1NSKHBydGQtPmRtYV9jaCkgJj0gfkRDU1JfUlVOOwogCURDU1IocHJ0ZC0+ZG1hX2NoKSA9IDA7CiAJRENNRChwcnRkLT5kbWFfY2gpID0gMDsKZGlmZiAtLWdpdCBhL3NvdW5kL2NvcmUvcGNtX21lbW9yeS5jIGIvc291bmQvY29yZS9wY21fbWVtb3J5LmMKaW5kZXggOTE3ZTQwNS4uMTUwY2I3ZSAxMDA2NDQKLS0tIGEvc291bmQvY29yZS9wY21fbWVtb3J5LmMKKysrIGIvc291bmQvY29yZS9wY21fbWVtb3J5LmMKQEAgLTI1Myw3ICsyNTMsNyBAQAogICogc25kX3BjbV9saWJfcHJlYWxsb2NhdGVfcGFnZXMgLSBwcmUtYWxsb2NhdGlvbiBmb3IgdGhlIGdpdmVuIERNQSB0eXBlCiAgKiBAc3Vic3RyZWFtOiB0aGUgcGNtIHN1YnN0cmVhbSBpbnN0YW5jZQogICogQHR5cGU6IERNQSB0eXBlIChTTkRSVl9ETUFfVFlQRV8qKQotICogQGRhdGE6IERNQSB0eXBlIGRlcGVuZGFudCBkYXRhCisgKiBAZGF0YTogRE1BIHR5cGUgZGVwZW5kZW50IGRhdGEKICAqIEBzaXplOiB0aGUgcmVxdWVzdGVkIHByZS1hbGxvY2F0aW9uIHNpemUgaW4gYnl0ZXMKICAqIEBtYXg6IHRoZSBtYXguIGFsbG93ZWQgcHJlLWFsbG9jYXRpb24gc2l6ZQogICoKQEAgLTI3OCwxMCArMjc4LDEwIEBACiBFWFBPUlRfU1lNQk9MKHNuZF9wY21fbGliX3ByZWFsbG9jYXRlX3BhZ2VzKTsKIAogLyoqCi0gKiBzbmRfcGNtX2xpYl9wcmVhbGxvY2F0ZV9wYWdlc19mb3JfYWxsIC0gcHJlLWFsbG9jYXRpb24gZm9yIGNvbnRpbm91cyBtZW1vcnkgdHlwZSAoYWxsIHN1YnN0cmVhbXMpCisgKiBzbmRfcGNtX2xpYl9wcmVhbGxvY2F0ZV9wYWdlc19mb3JfYWxsIC0gcHJlLWFsbG9jYXRpb24gZm9yIGNvbnRpbnVvdXMgbWVtb3J5IHR5cGUgKGFsbCBzdWJzdHJlYW1zKQogICogQHBjbTogdGhlIHBjbSBpbnN0YW5jZQogICogQHR5cGU6IERNQSB0eXBlIChTTkRSVl9ETUFfVFlQRV8qKQotICogQGRhdGE6IERNQSB0eXBlIGRlcGVuZGFudCBkYXRhCisgKiBAZGF0YTogRE1BIHR5cGUgZGVwZW5kZW50IGRhdGEKICAqIEBzaXplOiB0aGUgcmVxdWVzdGVkIHByZS1hbGxvY2F0aW9uIHNpemUgaW4gYnl0ZXMKICAqIEBtYXg6IHRoZSBtYXguIGFsbG93ZWQgcHJlLWFsbG9jYXRpb24gc2l6ZQogICoKZGlmZiAtLWdpdCBhL3NvdW5kL2NvcmUvcGNtX25hdGl2ZS5jIGIvc291bmQvY29yZS9wY21fbmF0aXZlLmMKaW5kZXggZmU1YzgwMy4uMWEwNzc1MCAxMDA2NDQKLS0tIGEvc291bmQvY29yZS9wY21fbmF0aXZlLmMKKysrIGIvc291bmQvY29yZS9wY21fbmF0aXZlLmMKQEAgLTQ2MCw3ICs0NjAsNyBAQAogCQkJCSAgIFBNX1FPU19DUFVfRE1BX0xBVEVOQ1ksIHVzZWNzKTsKIAlyZXR1cm4gMDsKICBfZXJyb3I6Ci0JLyogaGFyZHdhcmUgbWlnaHQgYmUgdW51c2VhYmxlIGZyb20gdGhpcyB0aW1lLAorCS8qIGhhcmR3YXJlIG1pZ2h0IGJlIHVudXNhYmxlIGZyb20gdGhpcyB0aW1lLAogCSAgIHNvIHdlIGZvcmNlIGFwcGxpY2F0aW9uIHRvIHJldHJ5IHRvIHNldAogCSAgIHRoZSBjb3JyZWN0IGhhcmR3YXJlIHBhcmFtZXRlciBzZXR0aW5ncyAqLwogCXJ1bnRpbWUtPnN0YXR1cy0+c3RhdGUgPSBTTkRSVl9QQ01fU1RBVEVfT1BFTjsKZGlmZiAtLWdpdCBhL3NvdW5kL2NvcmUvc2VxL3NlcV9kdW1teS5jIGIvc291bmQvY29yZS9zZXEvc2VxX2R1bW15LmMKaW5kZXggZjNiZGM1NC4uMWQ3ZDkwYyAxMDA2NDQKLS0tIGEvc291bmQvY29yZS9zZXEvc2VxX2R1bW15LmMKKysrIGIvc291bmQvY29yZS9zZXEvc2VxX2R1bW15LmMKQEAgLTUwLDcgKzUwLDcgQEAKIAogCW9wdGlvbiBzbmQtc2VxLWR1bW15IHBvcnRzPTQKIAotICBUaGUgbW9kbGUgb3B0aW9uICJkdXBsZXg9MSIgZW5hYmxlcyBkdXBsZXggb3BlcmF0aW9uIHRvIHRoZSBwb3J0LgorICBUaGUgbW9kZWwgb3B0aW9uICJkdXBsZXg9MSIgZW5hYmxlcyBkdXBsZXggb3BlcmF0aW9uIHRvIHRoZSBwb3J0LgogICBJbiBkdXBsZXggbW9kZSwgYSBwYWlyIG9mIHBvcnRzIGFyZSBjcmVhdGVkIGluc3RlYWQgb2Ygc2luZ2xlIHBvcnQsCiAgIGFuZCBldmVudHMgYXJlIHR1bm5lbGVkIGJldHdlZW4gcGFpci1wb3J0cy4gIEZvciBleGFtcGxlLCBpbnB1dCB0bwogICBwb3J0IEEgaXMgc2VudCB0byBvdXRwdXQgcG9ydCBvZiBhbm90aGVyIHBvcnQgQiBhbmQgdmljZSB2ZXJzYS4KZGlmZiAtLWdpdCBhL3NvdW5kL2NvcmUvdm1hc3Rlci5jIGIvc291bmQvY29yZS92bWFzdGVyLmMKaW5kZXggYTg5OTQ4YS4uYTM5ZDNkOCAxMDA2NDQKLS0tIGEvc291bmQvY29yZS92bWFzdGVyLmMKKysrIGIvc291bmQvY29yZS92bWFzdGVyLmMKQEAgLTIzMyw3ICsyMzMsNyBAQAogICogQWRkIGEgc2xhdmUgY29udHJvbCB0byB0aGUgZ3JvdXAgd2l0aCB0aGUgZ2l2ZW4gbWFzdGVyIGNvbnRyb2wKICAqCiAgKiBBbGwgc2xhdmVzIG11c3QgYmUgdGhlIHNhbWUgdHlwZSAocmV0dXJuaW5nIHRoZSBzYW1lIGluZm9ybWF0aW9uCi0gKiB2aWEgaW5mbyBjYWxsYmFjaykuICBUaGUgZnVjbnRpb24gZG9lc24ndCBjaGVjayBpdCwgc28gaXQncyB5b3VyCisgKiB2aWEgaW5mbyBjYWxsYmFjaykuICBUaGUgZnVuY3Rpb24gZG9lc24ndCBjaGVjayBpdCwgc28gaXQncyB5b3VyCiAgKiByZXNwb25zaWJpbGl0eS4KICAqCiAgKiBBbHNvLCBzb21lIGFkZGl0aW9uYWwgbGltaXRhdGlvbnM6CmRpZmYgLS1naXQgYS9zb3VuZC9kcml2ZXJzL3BjbS1pbmRpcmVjdDIuYyBiL3NvdW5kL2RyaXZlcnMvcGNtLWluZGlyZWN0Mi5jCmluZGV4IDNjOTNjMjMuLmU3M2ZhZmQgMTAwNjQ0Ci0tLSBhL3NvdW5kL2RyaXZlcnMvcGNtLWluZGlyZWN0Mi5jCisrKyBiL3NvdW5kL2RyaXZlcnMvcGNtLWluZGlyZWN0Mi5jCkBAIC0yNjQsNyArMjY0LDcgQEAKIAkJaWYgKGRpZmYgPCAtKHNuZF9wY21fc2ZyYW1lc190KSAocnVudGltZS0+Ym91bmRhcnkgLyAyKSkKIAkJCWRpZmYgKz0gcnVudGltZS0+Ym91bmRhcnk7CiAJCS8qIG51bWJlciBvZiBieXRlcyAiYWRkZWQiIGJ5IEFMU0EgaW5jcmVhc2VzIHRoZSBudW1iZXIgb2YKLQkJICogYnl0ZXMgd2hpY2ggYXJlIHJlYWR5IHRvICJiZSB0cmFuc2ZlcmVkIHRvIEhXIi8icGxheWVkIgorCQkgKiBieXRlcyB3aGljaCBhcmUgcmVhZHkgdG8gImJlIHRyYW5zZmVycmVkIHRvIEhXIi8icGxheWVkIgogCQkgKiBUaGVuLCBzZXQgcmVjLT5hcHBsX3B0ciB0byBub3QgY291bnQgYnl0ZXMgdHdpY2UgbmV4dCB0aW1lLgogCQkgKi8KIAkJcmVjLT5zd19yZWFkeSArPSAoaW50KWZyYW1lc190b19ieXRlcyhydW50aW1lLCBkaWZmKTsKQEAgLTMzMCw3ICszMzAsNyBAQAogCQkvKiBjb3B5IGJ5dGVzIGZyb20gaW50ZXJtZWRpYXRlIGJ1ZmZlciBwb3NpdGlvbiBzd19kYXRhIHRvIHRoZQogCQkgKiBIVyBhbmQgcmV0dXJuIG51bWJlciBvZiBieXRlcyBhY3R1YWxseSB3cml0dGVuCiAJCSAqIEZ1cnRoZXJtb3JlLCBzZXQgaHdfcmVhZHkgdG8gMCwgaWYgdGhlIGZpZm8gaXNuJ3QgZW1wdHkKLQkJICogbm93ID0+IG1vcmUgY291bGQgYmUgdHJhbnNmZXJlZCB0byBmaWZvCisJCSAqIG5vdyA9PiBtb3JlIGNvdWxkIGJlIHRyYW5zZmVycmVkIHRvIGZpZm8KIAkJICovCiAJCWJ5dGVzID0gY29weShzdWJzdHJlYW0sIHJlYywgYnl0ZXMpOwogCQlyZWMtPmJ5dGVzMmh3ICs9IGJ5dGVzOwpkaWZmIC0tZ2l0IGEvc291bmQvZHJpdmVycy92eC92eF9wY20uYyBiL3NvdW5kL2RyaXZlcnMvdngvdnhfcGNtLmMKaW5kZXggMzVhMmY3MS4uNWU4OTdiMiAxMDA2NDQKLS0tIGEvc291bmQvZHJpdmVycy92eC92eF9wY20uYworKysgYi9zb3VuZC9kcml2ZXJzL3Z4L3Z4X3BjbS5jCkBAIC0xMTg5LDcgKzExODksNyBAQAogCiAKIC8qCi0gKiB2eF9pbml0X2F1ZGlvX2lvIC0gY2hlY2sgdGhlIGF2YWlsYWJlIGF1ZGlvIGkvbyBhbmQgYWxsb2NhdGUgcGlwZSBhcnJheXMKKyAqIHZ4X2luaXRfYXVkaW9faW8gLSBjaGVjayB0aGUgYXZhaWxhYmxlIGF1ZGlvIGkvbyBhbmQgYWxsb2NhdGUgcGlwZSBhcnJheXMKICAqLwogc3RhdGljIGludCB2eF9pbml0X2F1ZGlvX2lvKHN0cnVjdCB2eF9jb3JlICpjaGlwKQogewpkaWZmIC0tZ2l0IGEvc291bmQvaXNhL3NiL2VtdTgwMDAuYyBiL3NvdW5kL2lzYS9zYi9lbXU4MDAwLmMKaW5kZXggMGM0MDk1MS4uNWQ2MWY1YSAxMDA2NDQKLS0tIGEvc291bmQvaXNhL3NiL2VtdTgwMDAuYworKysgYi9zb3VuZC9pc2Evc2IvZW11ODAwMC5jCkBAIC0zNzAsNyArMzcwLDcgQEAKIAogLyoKICAqIFNpemUgdGhlIG9uYm9hcmQgbWVtb3J5LgotICogVGhpcyBpcyB3cml0dGVuIHNvIGFzIG5vdCB0byBuZWVkIGFyYml0YXJ5IGRlbGF5cyBhZnRlciB0aGUgd3JpdGUuIEl0CisgKiBUaGlzIGlzIHdyaXR0ZW4gc28gYXMgbm90IHRvIG5lZWQgYXJiaXRyYXJ5IGRlbGF5cyBhZnRlciB0aGUgd3JpdGUuIEl0CiAgKiBzZWVtcyB0aGF0IHRoZSBvbmx5IHdheSB0byBkbyB0aGlzIGlzIHRvIHVzZSB0aGUgb25lIGNoYW5uZWwgYW5kIGtlZXAKICAqIHJlYWxsb2NhdGluZyBiZXR3ZWVuIHJlYWQgYW5kIHdyaXRlLgogICovCmRpZmYgLS1naXQgYS9zb3VuZC9pc2Evd2F2ZWZyb250L3dhdmVmcm9udF9taWRpLmMgYi9zb3VuZC9pc2Evd2F2ZWZyb250L3dhdmVmcm9udF9taWRpLmMKaW5kZXggZjE0YTdjMC4uNjUzMjlmMyAxMDA2NDQKLS0tIGEvc291bmQvaXNhL3dhdmVmcm9udC93YXZlZnJvbnRfbWlkaS5jCisrKyBiL3NvdW5kL2lzYS93YXZlZnJvbnQvd2F2ZWZyb250X21pZGkuYwpAQCAtNTM3LDcgKzUzNyw3IEBACiAJfQogCiAJLyogVHVybiBvbiBWaXJ0dWFsIE1JREksIGJ1dCBmaXJzdCAqYWx3YXlzKiB0dXJuIGl0IG9mZiwKLQkgICBzaW5jZSBvdGhlcndpc2UgY29uc2VjdHV0aXZlIHJlbG9hZHMgb2YgdGhlIGRyaXZlciB3aWxsCisJICAgc2luY2Ugb3RoZXJ3aXNlIGNvbnNlY3V0aXZlIHJlbG9hZHMgb2YgdGhlIGRyaXZlciB3aWxsCiAJICAgbmV2ZXIgY2F1c2UgdGhlIGhhcmR3YXJlIHRvIGdlbmVyYXRlIHRoZSBpbml0aWFsICJpbnRlcm5hbCIgb3IgCiAJICAgImV4dGVybmFsIiBzb3VyY2UgYnl0ZXMgaW4gdGhlIE1JREkgZGF0YSBzdHJlYW0uIFRoaXMKIAkgICBpcyBwcmV0dHkgaW1wb3J0YW50LCBzaW5jZSB0aGUgaW50ZXJuYWwgaGFyZHdhcmUgZ2VuZXJhbGx5IHdpbGwKZGlmZiAtLWdpdCBhL3NvdW5kL2lzYS93c3Mvd3NzX2xpYi5jIGIvc291bmQvaXNhL3dzcy93c3NfbGliLmMKaW5kZXggOTE5MWIzMi4uMmE0MmNjMyAxMDA2NDQKLS0tIGEvc291bmQvaXNhL3dzcy93c3NfbGliLmMKKysrIGIvc291bmQvaXNhL3dzcy93c3NfbGliLmMKQEAgLTQyNCw3ICs0MjQsNyBAQAogCiAJLyoKIAkgKiBXYWl0IGZvciAocG9zc2libGUgLS0gZHVyaW5nIGluaXQgYXV0by1jYWxpYnJhdGlvbiBtYXkgbm90IGJlIHNldCkKLQkgKiBjYWxpYnJhdGlvbiBwcm9jZXNzIHRvIHN0YXJ0LiBOZWVkcyB1cHRvIDUgc2FtcGxlIHBlcmlvZHMgb24gQUQxODQ4CisJICogY2FsaWJyYXRpb24gcHJvY2VzcyB0byBzdGFydC4gTmVlZHMgdXAgdG8gNSBzYW1wbGUgcGVyaW9kcyBvbiBBRDE4NDgKIAkgKiB3aGljaCBhdCB0aGUgc2xvd2VzdCBwb3NzaWJsZSByYXRlIG9mIDUuNTEyNSBrSHogbWVhbnMgOTA3IHVzLgogCSAqLwogCW1zbGVlcCgxKTsKZGlmZiAtLWdpdCBhL3NvdW5kL29zcy9hYzk3X2NvZGVjLmMgYi9zb3VuZC9vc3MvYWM5N19jb2RlYy5jCmluZGV4IDg1NGMzMDMuLjBjZDIzZDkgMTAwNjQ0Ci0tLSBhL3NvdW5kL29zcy9hYzk3X2NvZGVjLmMKKysrIGIvc291bmQvb3NzL2FjOTdfY29kZWMuYwpAQCAtMjgsNyArMjgsNyBAQAogICoKICAqIEhpc3RvcnkKICAqIE1heSAwMiwgMjAwMyBMaWFtIEdpcmR3b29kIDxscmdAc2xpbWxvZ2ljLmNvLnVrPgotICoJUmVtb3ZlZCBub24gZXhpc3RhbnQgV005NzAwCisgKglSZW1vdmVkIG5vbiBleGlzdGVudCBXTTk3MDAKICAqCUFkZGVkIHN1cHBvcnQgZm9yIFdNOTcwNSwgV005NzA4LCBXTTk3MDksIFdNOTcxMCwgV005NzExCiAgKglXTTk3MTIgYW5kIFdNOTcxNwogICogTWFyIDI4LCAyMDAyIFJhbmRvbHBoIEJlbnRzb24gPGJlbnRzb25AaG9sbXNqb2VuLmNvbT4KQEAgLTQ0MSw3ICs0NDEsNyBAQAogfQogCiAvKiByZWFkIG9yIHdyaXRlIHRoZSByZWNtYXNrLCB0aGUgYWM5NyBjYW4gcmVhbGx5IGhhdmUgbGVmdCBhbmQgcmlnaHQgcmVjb3JkaW5nCi0gICBpbnB1dHMgaW5kZXBlbmRhbnRseSBzZXQsIGJ1dCBPU1MgZG9lc24ndCBzZWVtIHRvIHdhbnQgdXMgdG8gZXhwcmVzcyB0aGF0IHRvCisgICBpbnB1dHMgaW5kZXBlbmRlbnRseSBzZXQsIGJ1dCBPU1MgZG9lc24ndCBzZWVtIHRvIHdhbnQgdXMgdG8gZXhwcmVzcyB0aGF0IHRvCiAgICB0aGUgdXNlci4gdGhlIGNhbGxlciBndWFyYW50ZWVzIHRoYXQgd2UgaGF2ZSBhIHN1cHBvcnRlZCBiaXQgc2V0LCBhbmQgdGhleQogICAgbXVzdCBiZSBob2xkaW5nIHRoZSBjYXJkJ3Mgc3BpbmxvY2sgKi8KIHN0YXRpYyBpbnQgYWM5N19yZWNtYXNrX2lvKHN0cnVjdCBhYzk3X2NvZGVjICpjb2RlYywgaW50IHJ3LCBpbnQgbWFzaykgCkBAIC03NTQsNyArNzU0LDcgQEAKIAlpZigoY29kZWMtPmNvZGVjX29wcyA9PSAmbnVsbF9vcHMpICYmIChmICYgNCkpCiAJCWNvZGVjLT5jb2RlY19vcHMgPSAmZGVmYXVsdF9kaWdpdGFsX29wczsKIAkKLQkvKiBBIGRldmljZSB3aGljaCB0aGlua3MgaXRzIGEgbW9kZW0gYnV0IGlzbnQgKi8KKwkvKiBBIGRldmljZSB3aGljaCB0aGlua3MgaXRzIGEgbW9kZW0gYnV0IGlzbid0ICovCiAJaWYoY29kZWMtPmZsYWdzICYgQUM5N19ERUxVREVEX01PREVNKQogCQljb2RlYy0+bW9kZW0gPSAwOwogCQkKZGlmZiAtLWdpdCBhL3NvdW5kL29zcy9hdWRpby5jIGIvc291bmQvb3NzL2F1ZGlvLmMKaW5kZXggN2RmNDhhMi4uNGI5NThiMSAxMDA2NDQKLS0tIGEvc291bmQvb3NzL2F1ZGlvLmMKKysrIGIvc291bmQvb3NzL2F1ZGlvLmMKQEAgLTUxNCw3ICs1MTQsNyBAQAogCQkJCWNvdW50ICs9IGRtYXAtPmJ5dGVzX2luX3VzZTsJLyogUG9pbnRlciB3cmFwIG5vdCBoYW5kbGVkIHlldCAqLwogCQkJY291bnQgKz0gZG1hcC0+Ynl0ZV9jb3VudGVyOwogCQkKLQkJCS8qIFN1YnN0cmFjdCBjdXJyZW50IGNvdW50IGZyb20gdGhlIG51bWJlciBvZiBieXRlcyB3cml0dGVuIGJ5IGFwcCAqLworCQkJLyogU3VidHJhY3QgY3VycmVudCBjb3VudCBmcm9tIHRoZSBudW1iZXIgb2YgYnl0ZXMgd3JpdHRlbiBieSBhcHAgKi8KIAkJCWNvdW50ID0gZG1hcC0+dXNlcl9jb3VudGVyIC0gY291bnQ7CiAJCQlpZiAoY291bnQgPCAwKQogCQkJCWNvdW50ID0gMDsKQEAgLTkzMSw3ICs5MzEsNyBAQAogCQkJaWYgKGNvdW50IDwgZG1hcF9vdXQtPmZyYWdtZW50X3NpemUgJiYgZG1hcF9vdXQtPnFoZWFkICE9IDApCiAJCQkJY291bnQgKz0gZG1hcF9vdXQtPmJ5dGVzX2luX3VzZTsJLyogUG9pbnRlciB3cmFwIG5vdCBoYW5kbGVkIHlldCAqLwogCQkJY291bnQgKz0gZG1hcF9vdXQtPmJ5dGVfY291bnRlcjsKLQkJCS8qIFN1YnN0cmFjdCBjdXJyZW50IGNvdW50IGZyb20gdGhlIG51bWJlciBvZiBieXRlcyB3cml0dGVuIGJ5IGFwcCAqLworCQkJLyogU3VidHJhY3QgY3VycmVudCBjb3VudCBmcm9tIHRoZSBudW1iZXIgb2YgYnl0ZXMgd3JpdHRlbiBieSBhcHAgKi8KIAkJCWNvdW50ID0gZG1hcF9vdXQtPnVzZXJfY291bnRlciAtIGNvdW50OwogCQkJaWYgKGNvdW50IDwgMCkKIAkJCQljb3VudCA9IDA7CmRpZmYgLS1naXQgYS9zb3VuZC9vc3MvZG1hc291bmQvZG1hc291bmRfY29yZS5jIGIvc291bmQvb3NzL2RtYXNvdW5kL2RtYXNvdW5kX2NvcmUuYwppbmRleCA4N2UyYzcyLi5jOTE4MzEzIDEwMDY0NAotLS0gYS9zb3VuZC9vc3MvZG1hc291bmQvZG1hc291bmRfY29yZS5jCisrKyBiL3NvdW5kL29zcy9kbWFzb3VuZC9kbWFzb3VuZF9jb3JlLmMKQEAgLTEwMjEsNyArMTAyMSw3IEBACiAJY2FzZSBTTkRDVExfRFNQX1NZTkM6CiAJCS8qIFRoaXMgY2FsbCwgZWZmZWN0aXZlbHksIGhhcyB0aGUgc2FtZSBiZWhhdmlvdXIgYXMgU05EQ1RMX0RTUF9SRVNFVAogCQkgICBleGNlcHQgdGhhdCBpdCB3YWl0cyBmb3Igb3V0cHV0IHRvIGZpbmlzaCBiZWZvcmUgcmVzZXR0aW5nCi0JCSAgIGV2ZXJ5dGhpbmcgLSByZWFkLCBob3dldmVyLCBpcyBraWxsZWQgaW1lZGlhdGVseS4KKwkJICAgZXZlcnl0aGluZyAtIHJlYWQsIGhvd2V2ZXIsIGlzIGtpbGxlZCBpbW1lZGlhdGVseS4KIAkJKi8KIAkJcmVzdWx0ID0gMCA7CiAJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewpkaWZmIC0tZ2l0IGEvc291bmQvb3NzL21pZGlidWYuYyBiL3NvdW5kL29zcy9taWRpYnVmLmMKaW5kZXggY2VlZGIxZS4uOGNkYjJjZiAxMDA2NDQKLS0tIGEvc291bmQvb3NzL21pZGlidWYuYworKysgYi9zb3VuZC9vc3MvbWlkaWJ1Zi5jCkBAIC0yOTUsNyArMjk1LDcgQEAKIAogCQlmb3IgKGkgPSAwOyBpIDwgbjsgaSsrKQogCQl7Ci0JCQkvKiBCUk9LRSBCUk9LRSBCUk9LRSAtIENBTlQgRE8gVEhJUyBXSVRIIENMSSAhISAqLworCQkJLyogQlJPS0UgQlJPS0UgQlJPS0UgLSBDQU4nVCBETyBUSElTIFdJVEggQ0xJICEhICovCiAJCQkvKiB5ZXMsIHRoaW5rIHRoZSBzYW1lLCBzbyBJIHJlbW92ZWQgdGhlIGNsaSgpIGJyYWNrZXRzIAogCQkJCVFVRVVFX0JZVEUgaXMgcHJvdGVjdGVkIGFnYWluc3QgaW50ZXJydXB0cyAqLwogCQkJaWYgKGNvcHlfZnJvbV91c2VyKChjaGFyICopICZ0bXBfZGF0YSwgJihidWYpW2NdLCAxKSkgewpkaWZmIC0tZ2l0IGEvc291bmQvb3NzL3NiX2NhcmQuYyBiL3NvdW5kL29zcy9zYl9jYXJkLmMKaW5kZXggODRlZjRkMC4uZmI1ZDcyNSAxMDA2NDQKLS0tIGEvc291bmQvb3NzL3NiX2NhcmQuYworKysgYi9zb3VuZC9vc3Mvc2JfY2FyZC5jCkBAIC0xLDcgKzEsNyBAQAogLyoKICAqIHNvdW5kL29zcy9zYl9jYXJkLmMKICAqCi0gKiBEZXRlY3Rpb24gcm91dGluZSBmb3IgdGhlIElTQSBTb3VuZCBCbGFzdGVyIGFuZCBjb21wYXRhYmxlIHNvdW5kCisgKiBEZXRlY3Rpb24gcm91dGluZSBmb3IgdGhlIElTQSBTb3VuZCBCbGFzdGVyIGFuZCBjb21wYXRpYmxlIHNvdW5kCiAgKiBjYXJkcy4KICAqCiAgKiBUaGlzIGZpbGUgaXMgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIEdOVSBHRU5FUkFMIFBVQkxJQyBMSUNFTlNFIChHUEwpCmRpZmYgLS1naXQgYS9zb3VuZC9vc3Mvc2JfZXNzLmMgYi9zb3VuZC9vc3Mvc2JfZXNzLmMKaW5kZXggOTg5MGNmMi4uNWM3NzNkZiAxMDA2NDQKLS0tIGEvc291bmQvb3NzL3NiX2Vzcy5jCisrKyBiL3NvdW5kL29zcy9zYl9lc3MuYwpAQCAtMTY4LDcgKzE2OCw3IEBACiAgKiBjb3JyZXNwb25kaW5nIHBsYXliYWNrIGxldmVscywgdW5sZXNzIHJlY21hc2sgc2F5cyB0aGV5IGFyZW4ndCByZWNvcmRlZC4gSW4KICAqIHRoZSBsYXR0ZXIgY2FzZSB0aGUgcmVjb3JkaW5nIHZvbHVtZXMgYXJlIDAuCiAgKiBOb3cgcmVjb3JkaW5nIGxldmVscyBvZiBpbnB1dHMgY2FuIGJlIGNvbnRyb2xsZWQsIGJ5IGNoYW5naW5nIHRoZSBwbGF5YmFjawotICogbGV2ZWxzLiBGdXRoZXJtb3JlIHNldmVyYWwgZGV2aWNlcyBjYW4gYmUgcmVjb3JkZWQgdG9nZXRoZXIgKHdoaWNoIGlzIG5vdAorICogbGV2ZWxzLiBGdXJ0aGVybW9yZSBzZXZlcmFsIGRldmljZXMgY2FuIGJlIHJlY29yZGVkIHRvZ2V0aGVyICh3aGljaCBpcyBub3QKICAqIHBvc3NpYmxlIHdpdGggdGhlIEVTMTY4OCkuCiAgKiBCZXNpZGVzIHRoZSBzZXBhcmF0ZSByZWNvcmRpbmcgbGV2ZWwgY29udHJvbCBmb3IgZWFjaCBpbnB1dCwgdGhlIGNvbW1vbgogICogcmVjb3JkaW5nIGxldmVsIGNhbiBhbHNvIGJlIGNvbnRyb2xsZWQgYnkgUkVDTEVWIGFzIGRlc2NyaWJlZCBhYm92ZS4KZGlmZiAtLWdpdCBhL3NvdW5kL29zcy9zd2FybV9jczQyOTdhLmMgYi9zb3VuZC9vc3Mvc3dhcm1fY3M0Mjk3YS5jCmluZGV4IDQ0MzU3ZDguLjA5ZDQ2NDggMTAwNjQ0Ci0tLSBhL3NvdW5kL29zcy9zd2FybV9jczQyOTdhLmMKKysrIGIvc291bmQvb3NzL3N3YXJtX2NzNDI5N2EuYwpAQCAtODc1LDcgKzg3NSw3IEBACiAJCWlmIChzLT5wcm9wX2FkYy5mbXQgJiBBRk1UX1M4IHx8IHMtPnByb3BfYWRjLmZtdCAmIEFGTVRfVTgpIHsKIAkJCS8vIAogCQkJLy8gbm93IG9ubHkgdXNlIDE2IGJpdCBjYXB0dXJlLCBkdWUgdG8gdHJ1bmNhdGlvbiBpc3N1ZQotCQkJLy8gaW4gdGhlIGNoaXAsIG5vdGljYWJsZSBkaXN0b3J0aW9uIG9jY3Vycy4KKwkJCS8vIGluIHRoZSBjaGlwLCBub3RpY2VhYmxlIGRpc3RvcnRpb24gb2NjdXJzLgogCQkJLy8gYWxsb2NhdGUgYnVmZmVyIGFuZCB0aGVuIGNvbnZlcnQgZnJvbSAxNiBiaXQgdG8gCiAJCQkvLyA4IGJpdCBmb3IgdGhlIHVzZXIgYnVmZmVyLgogCQkJLy8KZGlmZiAtLWdpdCBhL3NvdW5kL29zcy92aWRjLmMgYi9zb3VuZC9vc3MvdmlkYy5jCmluZGV4IGYwZTBjYWEuLjEyYmEyOGUgMTAwNjQ0Ci0tLSBhL3NvdW5kL29zcy92aWRjLmMKKysrIGIvc291bmQvb3NzL3ZpZGMuYwpAQCAtMjI3LDcgKzIyNyw3IEBACiAJCX0gZWxzZSB7CiAJCQkvKnByaW50aygiVklEQzogaW50ZXJuYWwgJWQgJWQgJWRcbiIsIHJhdGUsIHJhdGVfaW50LCBod3JhdGUpOyovCiAJCQlod2N0cmw9MHgwMDAwMDAwMzsKLQkJCS8qIEFsbG93IHJvdWdseSAwLjQlIHRvbGVyYW5jZSAqLworCQkJLyogQWxsb3cgcm91Z2hseSAwLjQlIHRvbGVyYW5jZSAqLwogCQkJaWYgKGRpZmZfaW50ID4gKHJhdGUvMjU2KSkKIAkJCQlyYXRlPXJhdGVfaW50OwogCQl9CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvYWQxODg5LmMgYi9zb3VuZC9wY2kvYWQxODg5LmMKaW5kZXggNDM4MmQwZi4uZDhmNmZkNiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2FkMTg4OS5jCisrKyBiL3NvdW5kL3BjaS9hZDE4ODkuYwpAQCAtMjksNyArMjksNyBAQAogICoJUE0gc3VwcG9ydAogICoJTUlESSBzdXBwb3J0CiAgKglHYW1lIFBvcnQgc3VwcG9ydAotICoJU0cgRE1BIHN1cHBvcnQgKHRoaXMgd2lsbCBuZWVkICphbG90KiBvZiB3b3JrKQorICoJU0cgRE1BIHN1cHBvcnQgKHRoaXMgd2lsbCBuZWVkICphIGxvdCogb2Ygd29yaykKICAqLwogCiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2FzaWhwaS9hc2locGkuYyBiL3NvdW5kL3BjaS9hc2locGkvYXNpaHBpLmMKaW5kZXggZjUzYTMxZS4uZjhjY2M5NiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2FzaWhwaS9hc2locGkuYworKysgYi9zb3VuZC9wY2kvYXNpaHBpL2FzaWhwaS5jCkBAIC05NjMsNyArOTYzLDcgQEAKIAogCS8qPyBhbHNvIGNoZWNrIEFTSTUwMDAgc2FtcGxlcmF0ZSBzb3VyY2UKIAkgICAgSWYgZXh0ZXJuYWwsIG9ubHkgc3VwcG9ydCBleHRlcm5hbCByYXRlLgotCSAgICBJZiBpbnRlcm5hbCBhbmQgb3RoZXIgc3RyZWFtIHBsYXlpbmcsIGNhbnQgc3dpdGNoCisJICAgIElmIGludGVybmFsIGFuZCBvdGhlciBzdHJlYW0gcGxheWluZywgY2FuJ3Qgc3dpdGNoCiAJKi8KIAogCWluaXRfdGltZXIoJmRwY20tPnRpbWVyKTsKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9hc2locGkvaHBpLmggYi9zb3VuZC9wY2kvYXNpaHBpL2hwaS5oCmluZGV4IDZmYzAyNWMuLjI1NTQyOWMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9hc2locGkvaHBpLmgKKysrIGIvc291bmQvcGNpL2FzaWhwaS9ocGkuaApAQCAtNzI1LDcgKzcyNSw3IEBACiAjZGVmaW5lIEhQSV9QQURfVElUTEVfTEVOICAgICAgICAgICAgICAgNjQKIC8qKiBUaGUgdGV4dCBzdHJpbmcgY29udGFpbmluZyB0aGUgY29tbWVudC4gKi8KICNkZWZpbmUgSFBJX1BBRF9DT01NRU5UX0xFTiAgICAgICAgICAgICAyNTYKLS8qKiBUaGUgUFRZIHdoZW4gdGhlIHR1bmVyIGhhcyBub3QgcmVjaWV2ZWQgYW55IFBUWS4gKi8KKy8qKiBUaGUgUFRZIHdoZW4gdGhlIHR1bmVyIGhhcyBub3QgcmVjZWl2ZWQgYW55IFBUWS4gKi8KICNkZWZpbmUgSFBJX1BBRF9QUk9HUkFNX1RZUEVfSU5WQUxJRCAgICAweGZmZmYKIC8qKiBcfSAqLwogCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvYXNpaHBpL2hwaTYwMDAuYyBiL3NvdW5kL3BjaS9hc2locGkvaHBpNjAwMC5jCmluZGV4IDNlM2MyZWYuLjhjOGFhYzQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9hc2locGkvaHBpNjAwMC5jCisrKyBiL3NvdW5kL3BjaS9hc2locGkvaHBpNjAwMC5jCkBAIC00MjMsNyArNDIzLDcgQEAKIAogCWFvLnByaXYgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgaHBpX2h3X29iaiksIEdGUF9LRVJORUwpOwogCWlmICghYW8ucHJpdikgewotCQlIUElfREVCVUdfTE9HKEVSUk9SLCAiY2FudCBnZXQgbWVtIGZvciBhZGFwdGVyIG9iamVjdFxuIik7CisJCUhQSV9ERUJVR19MT0coRVJST1IsICJjYW4ndCBnZXQgbWVtIGZvciBhZGFwdGVyIG9iamVjdFxuIik7CiAJCXBoci0+ZXJyb3IgPSBIUElfRVJST1JfTUVNT1JZX0FMTE9DOwogCQlyZXR1cm47CiAJfQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2FzaWhwaS9ocGk2MjA1LmMgYi9zb3VuZC9wY2kvYXNpaHBpL2hwaTYyMDUuYwppbmRleCA2MjA1MjViLi4yMmU5ZjA4IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvYXNpaHBpL2hwaTYyMDUuYworKysgYi9zb3VuZC9wY2kvYXNpaHBpL2hwaTYyMDUuYwpAQCAtNDY2LDcgKzQ2Niw3IEBACiAKIAlhby5wcml2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGhwaV9od19vYmopLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWFvLnByaXYpIHsKLQkJSFBJX0RFQlVHX0xPRyhFUlJPUiwgImNhbnQgZ2V0IG1lbSBmb3IgYWRhcHRlciBvYmplY3RcbiIpOworCQlIUElfREVCVUdfTE9HKEVSUk9SLCAiY2FuJ3QgZ2V0IG1lbSBmb3IgYWRhcHRlciBvYmplY3RcbiIpOwogCQlwaHItPmVycm9yID0gSFBJX0VSUk9SX01FTU9SWV9BTExPQzsKIAkJcmV0dXJuOwogCX0KZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9hc2locGkvaHBpX2ludGVybmFsLmggYi9zb3VuZC9wY2kvYXNpaHBpL2hwaV9pbnRlcm5hbC5oCmluZGV4IGFmNjc4YmUuLjNiOWZkMTEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9hc2locGkvaHBpX2ludGVybmFsLmgKKysrIGIvc291bmQvcGNpL2FzaWhwaS9ocGlfaW50ZXJuYWwuaApAQCAtNjA3LDcgKzYwNyw3IEBACiAjZW5kaWYKIAogc3RydWN0IGhwaV9idWZmZXIgewotICAvKiogcGxhY2Vob2RlciBmb3IgYmFja3dhcmQgY29tcGF0YWJpbGl0eSAoc2VlIGR3QnVmZmVyU2l6ZSkgKi8KKyAgLyoqIHBsYWNlaG9kZXIgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgKHNlZSBkd0J1ZmZlclNpemUpICovCiAJc3RydWN0IGhwaV9tc2dfZm9ybWF0IHJlc2VydmVkOwogCXUzMiBjb21tYW5kOyAvKio8IEhQSV9CVUZGRVJfQ01EX3h4eCovCiAJdTMyIHBjaV9hZGRyZXNzOyAvKio8IFBDSSBwaHlzaWNhbCBhZGRyZXNzIG9mIGJ1ZmZlciBmb3IgRFNQIERNQSAqLwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2FzaWhwaS9ocGltc2d4LmMgYi9zb3VuZC9wY2kvYXNpaHBpL2hwaW1zZ3guYwppbmRleCBiY2JkZjMwLi4zNjAwMjhiIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvYXNpaHBpL2hwaW1zZ3guYworKysgYi9zb3VuZC9wY2kvYXNpaHBpL2hwaW1zZ3guYwpAQCAtNzIyLDcgKzcyMiw3IEBACiAJCXJldHVybiBwaHItPmVycm9yOwogCX0KIAlpZiAoaHIuZXJyb3IgPT0gMCkgewotCQkvKiB0aGUgYWRhcHRlciB3YXMgY3JlYXRlZCBzdWNjZXNmdWxseQorCQkvKiB0aGUgYWRhcHRlciB3YXMgY3JlYXRlZCBzdWNjZXNzZnVsbHkKIAkJICAgc2F2ZSB0aGUgbWFwcGluZyBmb3IgZnV0dXJlIHVzZSAqLwogCQlocGlfZW50cnlfcG9pbnRzW2hyLnUucy5hZGFwdGVyX2luZGV4XSA9IGVudHJ5X3BvaW50X2Z1bmM7CiAJCS8qIHByZXBhcmUgYWRhcHRlciAocHJlLW9wZW4gc3RyZWFtcyBldGMuKSAqLwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2F1ODh4MC9hdTg4eDAuaCBiL3NvdW5kL3BjaS9hdTg4eDAvYXU4OHgwLmgKaW5kZXggZWNiOGY0ZC4uMDJmNmUwOCAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2F1ODh4MC9hdTg4eDAuaAorKysgYi9zb3VuZC9wY2kvYXU4OHgwL2F1ODh4MC5oCkBAIC0xMDQsNyArMTA0LDcgQEAKICNkZWZpbmUgTUlYX1BMQVlCKHgpICh2b3J0ZXgtPm1peHBsYXliW3hdKQogI2RlZmluZSBNSVhfU1BESUYoeCkgKHZvcnRleC0+bWl4c3BkaWZbeF0pCiAKLSNkZWZpbmUgTlJfV1RQQiAweDIwCQkvKiBXVCBjaGFubmVscyBwZXIgZWFoYyBiYW5rLiAqLworI2RlZmluZSBOUl9XVFBCIDB4MjAJCS8qIFdUIGNoYW5uZWxzIHBlciBlYWNoIGJhbmsuICovCiAKIC8qIFN0cnVjdHMgKi8KIHR5cGVkZWYgc3RydWN0IHsKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9hdTg4eDAvYXU4OHgwX2EzZC5jIGIvc291bmQvcGNpL2F1ODh4MC9hdTg4eDBfYTNkLmMKaW5kZXggZjRhYThmZi4uOWFlOGIzYiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2F1ODh4MC9hdTg4eDBfYTNkLmMKKysrIGIvc291bmQvcGNpL2F1ODh4MC9hdTg4eDBfYTNkLmMKQEAgLTUzLDcgKzUzLDcgQEAKIH0KIAogI2VuZGlmCi0vKiBBdG1vc3BoZXJpYyBhYnNvcmJ0aW9uLiAqLworLyogQXRtb3NwaGVyaWMgYWJzb3JwdGlvbi4gKi8KIAogc3RhdGljIHZvaWQKIGEzZHNyY19TZXRBdG1vc1RhcmdldChhM2RzcmNfdCAqIGEsIHNob3J0IGFhLCBzaG9ydCBiLCBzaG9ydCBjLCBzaG9ydCBkLApAQCAtODM1LDcgKzgzNSw3IEBACiAJCXBhcmFtc1tpXSA9IHVjb250cm9sLT52YWx1ZS5pbnRlZ2VyLnZhbHVlW2ldOwogCS8qIFRyYW5zbGF0ZSBnZW5lcmljIGZpbHRlciBwYXJhbXMgdG8gYTNkIGZpbHRlciBwYXJhbXMuICovCiAJdm9ydGV4X2EzZF90cmFuc2xhdGVfZmlsdGVyKGEtPmZpbHRlciwgcGFyYW1zKTsKLQkvKiBBdG1vc3BoZXJpYyBhYnNvcmJ0aW9uIGFuZCBmaWx0ZXJpbmcuICovCisJLyogQXRtb3NwaGVyaWMgYWJzb3JwdGlvbiBhbmQgZmlsdGVyaW5nLiAqLwogCWEzZHNyY19TZXRBdG1vc1RhcmdldChhLCBhLT5maWx0ZXJbMF0sCiAJCQkgICAgICBhLT5maWx0ZXJbMV0sIGEtPmZpbHRlclsyXSwKIAkJCSAgICAgIGEtPmZpbHRlclszXSwgYS0+ZmlsdGVyWzRdKTsKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9hdTg4eDAvYXU4OHgwX3BjbS5jIGIvc291bmQvcGNpL2F1ODh4MC9hdTg4eDBfcGNtLmMKaW5kZXggNTQzOWQ2Ni4uMzNmMGJhNSAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2F1ODh4MC9hdTg4eDBfcGNtLmMKKysrIGIvc291bmQvcGNpL2F1ODh4MC9hdTg4eDBfcGNtLmMKQEAgLTUxNSw3ICs1MTUsNyBAQAogCQlyZXR1cm4gLUVOT0RFVjsKIAogCS8qIGlkeCBpbmRpY2F0ZXMgd2hpY2gga2luZCBvZiBQQ00gZGV2aWNlLiBBREIsIFNQRElGLCBJMlMgYW5kIEEzRCBzaGFyZSB0aGUgCi0JICogc2FtZSBkbWEgZW5naW5lLiBXVCB1c2VzIGl0IG93biBzZXBhcmF0ZSBkbWEgZW5naW5lIHdoY2loIGNhbnQgY2FwdHVyZS4gKi8KKwkgKiBzYW1lIGRtYSBlbmdpbmUuIFdUIHVzZXMgaXQgb3duIHNlcGFyYXRlIGRtYSBlbmdpbmUgd2hpY2ggY2FuJ3QgY2FwdHVyZS4gKi8KIAlpZiAoaWR4ID09IFZPUlRFWF9QQ01fQURCKQogCQlucl9jYXB0ID0gbnI7CiAJZWxzZQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2F6dDMzMjguYyBiL3NvdW5kL3BjaS9henQzMzI4LmMKaW5kZXggNTcxNWM0ZDAuLjliN2E2MzQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9henQzMzI4LmMKKysrIGIvc291bmQvcGNpL2F6dDMzMjguYwpAQCAtMTQwLDcgKzE0MCw3IEBACiAgKiAgUG9zc2libGUgcmVtZWRpZXM6CiAgKiAgLSB1c2Ugc3BlYWtlciAoYW1wbGlmaWVyKSBvdXRwdXQgaW5zdGVhZCBvZiBoZWFkcGhvbmUgb3V0cHV0CiAgKiAgICAoaW4gY2FzZSBjcmFja2xpbmcgaXMgZHVlIHRvIG92ZXJsb2FkZWQgb3V0cHV0IGNsaXBwaW5nKQotICogIC0gcGx1ZyBjYXJkIGludG8gYSBkaWZmZXJlbnQgUENJIHNsb3QsIHByZWZlcnJhYmx5IG9uZSB0aGF0IGlzbid0IHNoYXJlZAorICogIC0gcGx1ZyBjYXJkIGludG8gYSBkaWZmZXJlbnQgUENJIHNsb3QsIHByZWZlcmFibHkgb25lIHRoYXQgaXNuJ3Qgc2hhcmVkCiAgKiAgICB0b28gbXVjaCAodGhpcyBoZWxwcyBhIGxvdCwgYnV0IG5vdCBjb21wbGV0ZWx5ISkKICAqICAtIGdldCByaWQgb2YgUENJIFZHQSBjYXJkLCB1c2UgQUdQIGluc3RlYWQKICAqICAtIHVwZ3JhZGUgb3IgZG93bmdyYWRlIEJJT1MKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9jYTAxMDYvY2EwMTA2LmggYi9zb3VuZC9wY2kvY2EwMTA2L2NhMDEwNi5oCmluZGV4IGZjNTNiOWIuLmU4ZThjY2MgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9jYTAxMDYvY2EwMTA2LmgKKysrIGIvc291bmQvcGNpL2NhMDEwNi9jYTAxMDYuaApAQCAtNTEsNyArNTEsNyBAQAogICogICAgQWRkIHN1cHBvcnQgZm9yIG11dGUgY29udHJvbCBvbiBTQiBMaXZlIDI0Yml0IChjYXJkcyB3LyBTUEkgREFDKQogICoKICAqCi0gKiAgVGhpcyBjb2RlIHdhcyBpbml0YWxseSBiYXNlZCBvbiBjb2RlIGZyb20gQUxTQSdzIGVtdTEwazF4LmMgd2hpY2ggaXM6CisgKiAgVGhpcyBjb2RlIHdhcyBpbml0aWFsbHkgYmFzZWQgb24gY29kZSBmcm9tIEFMU0EncyBlbXUxMGsxeC5jIHdoaWNoIGlzOgogICogIENvcHlyaWdodCAoYykgYnkgRnJhbmNpc2NvIE1vcmFlcyA8Zm1vcmFlc0BuYy5yci5jb20+CiAgKgogICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpAQCAtMTc1LDcgKzE3NSw3IEBACiAvKiBDQTAxMDYgcG9pbnRlci1vZmZzZXQgcmVnaXN0ZXIgc2V0LCBhY2Nlc3NlZCB0aHJvdWdoIHRoZSBQVFIgYW5kIERBVEEgcmVnaXN0ZXJzICAgICAgICAgICAgICAgICAgICAgKi8KIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAotLyogSW5pdGFsbHkgYWxsIHJlZ2lzdGVycyBmcm9tIDB4MDAgdG8gMHgzZiBoYXZlIHplcm8gY29udGVudHMuICovCisvKiBJbml0aWFsbHkgYWxsIHJlZ2lzdGVycyBmcm9tIDB4MDAgdG8gMHgzZiBoYXZlIHplcm8gY29udGVudHMuICovCiAjZGVmaW5lIFBMQVlCQUNLX0xJU1RfQUREUgkweDAwCQkvKiBCYXNlIERNQSBhZGRyZXNzIG9mIGEgbGlzdCBvZiBwb2ludGVycyB0byBlYWNoIHBlcmlvZC9zaXplICovCiAJCQkJCQkvKiBPbmUgbGlzdCBlbnRyeTogNCBieXRlcyBmb3IgRE1BIGFkZHJlc3MsIAogCQkJCQkJICogNCBieXRlcyBmb3IgcGVyaW9kX3NpemUgPDwgMTYuCkBAIC0yMjMsNyArMjIzLDcgQEAKICAqIFRoZSBqYWNrIGhhcyA0IHBvbGVzLiBJIHdpbGwgY2FsbCAxIC0gVGlwLCAyIC0gTmV4dCB0byAxLCAzIC0gTmV4dCB0byAyLCA0IC0gTmV4dCB0byAzCiAgKiBGb3IgQW5hbG9ndWU6IDEgLT4gQ2VudGVyIFNwZWFrZXIsIDIgLT4gU3ViIFdvb2ZlciwgMyAtPiBHcm91bmQsIDQgLT4gR3JvdW5kCiAgKiBGb3IgRGlnaXRhbDogMSAtPiBGcm9udCBTUERJRiwgMiAtPiBSZWFyIFNQRElGLCAzIC0+IENlbnRlci9TdWJ3b29mZXIgU1BESUYsIDQgLT4gR3JvdW5kLgotICogU3RhbmRhcmQgNCBwb2xlIFZpZGVvIEEvViBjYWJsZSB3aXRoIFJDQSBvdXRwdXRzOiAxIC0+IFdoaXRlLCAyIC0+IFllbGxvdywgMyAtPiBTaGVpbGQgb24gYWxsIHRocmVlLCA0IC0+IFJlZC4KKyAqIFN0YW5kYXJkIDQgcG9sZSBWaWRlbyBBL1YgY2FibGUgd2l0aCBSQ0Egb3V0cHV0czogMSAtPiBXaGl0ZSwgMiAtPiBZZWxsb3csIDMgLT4gU2hpZWxkIG9uIGFsbCB0aHJlZSwgNCAtPiBSZWQuCiAgKiBTbywgZnJvbSB0aGlzIHlvdSBjYW4gc2VlIHRoYXQgeW91IGNhbm5vdCB1c2UgYSBTdGFuZGFyZCA0IHBvbGUgVmlkZW8gQS9WIGNhYmxlIHdpdGggdGhlIFNCIEF1ZGlneSBMUyBjYXJkLgogICovCiAvKiBUaGUgRnJvbnQgU1BESUYgUENNIGdldHMgbWl4ZWQgd2l0aCBzYW1wbGVzIGZyb20gdGhlIEFDOTcgY29kZWMsIHNvIGNhbiBvbmx5IHdvcmsgZm9yIFN0ZXJlbyBQQ00gYW5kIG5vdCBBQzMvRFRTCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvY2EwMTA2L2NhMDEwNl9tYWluLmMgYi9zb3VuZC9wY2kvY2EwMTA2L2NhMDEwNl9tYWluLmMKaW5kZXggMDFiNDkzOC4uNDM3NzU5MiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2NhMDEwNi9jYTAxMDZfbWFpbi5jCisrKyBiL3NvdW5kL3BjaS9jYTAxMDYvY2EwMTA2X21haW4uYwpAQCAtMTE3LDcgKzExNyw3IEBACiAgKiAgICBEQUM6IFVua25vd24KICAqICAgIFRyeWluZyB0byBoYW5kbGUgaXQgbGlrZSB0aGUgU0IwNDEwLgogICoKLSAqICBUaGlzIGNvZGUgd2FzIGluaXRhbGx5IGJhc2VkIG9uIGNvZGUgZnJvbSBBTFNBJ3MgZW11MTBrMXguYyB3aGljaCBpczoKKyAqICBUaGlzIGNvZGUgd2FzIGluaXRpYWxseSBiYXNlZCBvbiBjb2RlIGZyb20gQUxTQSdzIGVtdTEwazF4LmMgd2hpY2ggaXM6CiAgKiAgQ29weXJpZ2h0IChjKSBieSBGcmFuY2lzY28gTW9yYWVzIDxmbW9yYWVzQG5jLnJyLmNvbT4KICAqCiAgKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvY2EwMTA2L2NhMDEwNl9taXhlci5jIGIvc291bmQvcGNpL2NhMDEwNi9jYTAxMDZfbWl4ZXIuYwppbmRleCA2MzBhYTQ5Li44NGYzZjkyIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvY2EwMTA2L2NhMDEwNl9taXhlci5jCisrKyBiL3NvdW5kL3BjaS9jYTAxMDYvY2EwMTA2X21peGVyLmMKQEAgLTQyLDcgKzQyLDcgQEAKICAqICAwLjAuMTgKICAqICAgIEFkZCBzdXBwb3J0IGZvciBtdXRlIGNvbnRyb2wgb24gU0IgTGl2ZSAyNGJpdCAoY2FyZHMgdy8gU1BJIERBQykKICAqCi0gKiAgVGhpcyBjb2RlIHdhcyBpbml0YWxseSBiYXNlZCBvbiBjb2RlIGZyb20gQUxTQSdzIGVtdTEwazF4LmMgd2hpY2ggaXM6CisgKiAgVGhpcyBjb2RlIHdhcyBpbml0aWFsbHkgYmFzZWQgb24gY29kZSBmcm9tIEFMU0EncyBlbXUxMGsxeC5jIHdoaWNoIGlzOgogICogIENvcHlyaWdodCAoYykgYnkgRnJhbmNpc2NvIE1vcmFlcyA8Zm1vcmFlc0BuYy5yci5jb20+CiAgKgogICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2NhMDEwNi9jYTAxMDZfcHJvYy5jIGIvc291bmQvcGNpL2NhMDEwNi9jYTAxMDZfcHJvYy5jCmluZGV4IGJhOTY0MjguLmM2OTQ0NjQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9jYTAxMDYvY2EwMTA2X3Byb2MuYworKysgYi9zb3VuZC9wY2kvY2EwMTA2L2NhMDEwNl9wcm9jLmMKQEAgLTQyLDcgKzQyLDcgQEAKICAqICAwLjAuMTgKICAqICAgIEltcGxlbWVudCBzdXBwb3J0IGZvciBMaW5lLWluIGNhcHR1cmUgb24gU0IgTGl2ZSAyNGJpdC4KICAqCi0gKiAgVGhpcyBjb2RlIHdhcyBpbml0YWxseSBiYXNlZCBvbiBjb2RlIGZyb20gQUxTQSdzIGVtdTEwazF4LmMgd2hpY2ggaXM6CisgKiAgVGhpcyBjb2RlIHdhcyBpbml0aWFsbHkgYmFzZWQgb24gY29kZSBmcm9tIEFMU0EncyBlbXUxMGsxeC5jIHdoaWNoIGlzOgogICogIENvcHlyaWdodCAoYykgYnkgRnJhbmNpc2NvIE1vcmFlcyA8Zm1vcmFlc0BuYy5yci5jb20+CiAgKgogICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2NtaXBjaS5jIGIvc291bmQvcGNpL2NtaXBjaS5jCmluZGV4IGI1YmIwMzYuLmY0ZTU3MzUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9jbWlwY2kuYworKysgYi9zb3VuZC9wY2kvY21pcGNpLmMKQEAgLTczLDcgKzczLDcgQEAKIG1vZHVsZV9wYXJhbV9hcnJheShmbV9wb3J0LCBsb25nLCBOVUxMLCAwNDQ0KTsKIE1PRFVMRV9QQVJNX0RFU0MoZm1fcG9ydCwgIkZNIHBvcnQuIik7CiBtb2R1bGVfcGFyYW1fYXJyYXkoc29mdF9hYzMsIGJvb2wsIE5VTEwsIDA0NDQpOwotTU9EVUxFX1BBUk1fREVTQyhzb2Z0X2FjMywgIlNvZndhcmUtY29udmVyc2lvbiBvZiByYXcgU1BESUYgcGFja2V0cyAobW9kZWwgMDMzIG9ubHkpLiIpOworTU9EVUxFX1BBUk1fREVTQyhzb2Z0X2FjMywgIlNvZnR3YXJlLWNvbnZlcnNpb24gb2YgcmF3IFNQRElGIHBhY2tldHMgKG1vZGVsIDAzMyBvbmx5KS4iKTsKICNpZmRlZiBTVVBQT1JUX0pPWVNUSUNLCiBtb2R1bGVfcGFyYW1fYXJyYXkoam95c3RpY2tfcG9ydCwgaW50LCBOVUxMLCAwNDQ0KTsKIE1PRFVMRV9QQVJNX0RFU0Moam95c3RpY2tfcG9ydCwgIkpveXN0aWNrIHBvcnQgYWRkcmVzcy4iKTsKQEAgLTY1Niw4ICs2NTYsOCBAQAogfQogCiAvKgotICogUHJvZ3JhbSBwbGwgcmVnaXN0ZXIgYml0cywgSSBhc3N1bWUgdGhhdCB0aGUgOCByZWdpc3RlcnMgMHhmOCB1cHRvIDB4ZmYKLSAqIGFyZSBtYXBwZWQgb250byB0aGUgOCBBREMvREFDIHNhbXBsaW5nIGZyZXF1ZW5jeSB3aGljaCBjYW4gYmUgY2hvb3NlbgorICogUHJvZ3JhbSBwbGwgcmVnaXN0ZXIgYml0cywgSSBhc3N1bWUgdGhhdCB0aGUgOCByZWdpc3RlcnMgMHhmOCB1cCB0byAweGZmCisgKiBhcmUgbWFwcGVkIG9udG8gdGhlIDggQURDL0RBQyBzYW1wbGluZyBmcmVxdWVuY3kgd2hpY2ggY2FuIGJlIGNob3NlbgogICogYXQgdGhlIHJlZ2lzdGVyIENNX1JFR19GVU5DVFJMMSAoMHgwNCkuCiAgKiBQcm9ibGVtOiBvdGhlciB3YXlzIGFyZSBhbHNvIHBvc3NpYmxlIChhbnkgaW5mb3JtYXRpb24gYWJvdXQgdGhhdD8pCiAgKi8KQEAgLTY2Niw3ICs2NjYsNyBAQAogCXVuc2lnbmVkIGludCByZWcgPSBDTV9SRUdfUExMICsgc2xvdDsKIAkvKgogCSAqIEd1ZXNzIHRoYXQgdGhpcyBwcm9ncmFtcyBhdCByZWcuIDB4MDQgdGhlIHBvcyAxNToxMy8xMjoxMAotCSAqIGZvciBEU0ZDL0FTRkMgKDAwMCB1cHRvIDExMSkuCisJICogZm9yIERTRkMvQVNGQyAoMDAwIHVwIHRvIDExMSkuCiAJICovCiAKIAkvKiBGSVhNRTogSW5pdCAoRG8gd2UndmUgdG8gc2V0IGFuIG90aGVyIHJlZ2lzdGVyIGZpcnN0IGJlZm9yZSBwcm9ncmFtbWluZz8pICovCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvY3R4ZmkvY3RhdGMuYyBiL3NvdW5kL3BjaS9jdHhmaS9jdGF0Yy5jCmluZGV4IGI5MzIxNTQuLjEzZjMzYzAgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9jdHhmaS9jdGF0Yy5jCisrKyBiL3NvdW5kL3BjaS9jdHhmaS9jdGF0Yy5jCkBAIC0xNjI3LDcgKzE2MjcsNyBAQAogICogIENyZWF0ZXMgYW5kIGluaXRpYWxpemVzIGEgaGFyZHdhcmUgbWFuYWdlci4KICAqCiAgKiAgQ3JlYXRlcyBrbWFsbG9jYXRlZCBjdF9hdGMgc3RydWN0dXJlLiBJbml0aWFsaXplcyBoYXJkd2FyZS4KLSAqICBSZXR1cm5zIDAgaWYgc3VjZWVkcywgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBpZiBmYWlscy4KKyAqICBSZXR1cm5zIDAgaWYgc3VjY2VlZHMsIG9yIG5lZ2F0aXZlIGVycm9yIGNvZGUgaWYgZmFpbHMuCiAgKi8KIAogaW50IF9fZGV2aW5pdCBjdF9hdGNfY3JlYXRlKHN0cnVjdCBzbmRfY2FyZCAqY2FyZCwgc3RydWN0IHBjaV9kZXYgKnBjaSwKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9jdHhmaS9jdGh3MjBrMS5jIGIvc291bmQvcGNpL2N0eGZpL2N0aHcyMGsxLmMKaW5kZXggMGNmNDAwZi4uYTVjOTU3ZCAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2N0eGZpL2N0aHcyMGsxLmMKKysrIGIvc291bmQvcGNpL2N0eGZpL2N0aHcyMGsxLmMKQEAgLTEyODUsNyArMTI4NSw3IEBACiAJaHdfd3JpdGVfMjBreChodywgUFRQQUxYLCBwdHBfcGh5c19sb3cpOwogCWh3X3dyaXRlXzIwa3goaHcsIFBUUEFIWCwgcHRwX3BoeXNfaGlnaCk7CiAJaHdfd3JpdGVfMjBreChodywgVFJOQ1RMLCB0cm5jdGwpOwotCWh3X3dyaXRlXzIwa3goaHcsIFRSTklTLCAweDIwMGMwMSk7IC8qIHJlYWx5IG5lZWRlZD8gKi8KKwlod193cml0ZV8yMGt4KGh3LCBUUk5JUywgMHgyMDBjMDEpOyAvKiByZWFsbHkgbmVlZGVkPyAqLwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvZW11MTBrMS9tZW1vcnkuYyBiL3NvdW5kL3BjaS9lbXUxMGsxL21lbW9yeS5jCmluZGV4IDk1N2EzMTEuLmMyNTA2MTQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9lbXUxMGsxL21lbW9yeS5jCisrKyBiL3NvdW5kL3BjaS9lbXUxMGsxL21lbW9yeS5jCkBAIC0yNDgsNyArMjQ4LDcgQEAKIC8qCiAgKiBtYXAgdGhlIGdpdmVuIG1lbW9yeSBibG9jayBvbiBQVEIuCiAgKiBpZiB0aGUgYmxvY2sgaXMgYWxyZWFkeSBtYXBwZWQsIHVwZGF0ZSB0aGUgbGluayBvcmRlci4KLSAqIGlmIG5vIGVtcHR5IHBhZ2VzIGFyZSBmb3VuZCwgdHJpZXMgdG8gcmVsZWFzZSB1bnNlZCBtZW1vcnkgYmxvY2tzCisgKiBpZiBubyBlbXB0eSBwYWdlcyBhcmUgZm91bmQsIHRyaWVzIHRvIHJlbGVhc2UgdW51c2VkIG1lbW9yeSBibG9ja3MKICAqIGFuZCByZXRyeSB0aGUgbWFwcGluZy4KICAqLwogaW50IHNuZF9lbXUxMGsxX21lbWJsa19tYXAoc3RydWN0IHNuZF9lbXUxMGsxICplbXUsIHN0cnVjdCBzbmRfZW11MTBrMV9tZW1ibGsgKmJsaykKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9lbXUxMGsxL3AxNnYuYyBiL3NvdW5kL3BjaS9lbXUxMGsxL3AxNnYuYwppbmRleCA2MWI4YWIzLi5hODFkYzQ0IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvZW11MTBrMS9wMTZ2LmMKKysrIGIvc291bmQvcGNpL2VtdTEwazEvcDE2di5jCkBAIC02OSw3ICs2OSw3IEBACiAgKiAgICBBREM6IFBoaWxpcHMgMTM2MVQgKFN0ZXJlbyAyNGJpdCkKICAqICAgIERBQzogQ1M0MzgyLUsgKDgtY2hhbm5lbCwgMjRiaXQsIDE5MktoeikKICAqCi0gKiAgVGhpcyBjb2RlIHdhcyBpbml0YWxseSBiYXNlZCBvbiBjb2RlIGZyb20gQUxTQSdzIGVtdTEwazF4LmMgd2hpY2ggaXM6CisgKiAgVGhpcyBjb2RlIHdhcyBpbml0aWFsbHkgYmFzZWQgb24gY29kZSBmcm9tIEFMU0EncyBlbXUxMGsxeC5jIHdoaWNoIGlzOgogICogIENvcHlyaWdodCAoYykgYnkgRnJhbmNpc2NvIE1vcmFlcyA8Zm1vcmFlc0BuYy5yci5jb20+CiAgKgogICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2VtdTEwazEvcDE2di5oIGIvc291bmQvcGNpL2VtdTEwazEvcDE2di5oCmluZGV4IDAwZjQ4MTcuLjRlMGVlMWEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9lbXUxMGsxL3AxNnYuaAorKysgYi9zb3VuZC9wY2kvZW11MTBrMS9wMTZ2LmgKQEAgLTU5LDcgKzU5LDcgQEAKICAqICAgIEFEQzogUGhpbGlwcyAxMzYxVCAoU3RlcmVvIDI0Yml0KQogICogICAgREFDOiBDUzQzODItSyAoOC1jaGFubmVsLCAyNGJpdCwgMTkyS2h6KQogICoKLSAqICBUaGlzIGNvZGUgd2FzIGluaXRhbGx5IGJhc2VkIG9uIGNvZGUgZnJvbSBBTFNBJ3MgZW11MTBrMXguYyB3aGljaCBpczoKKyAqICBUaGlzIGNvZGUgd2FzIGluaXRpYWxseSBiYXNlZCBvbiBjb2RlIGZyb20gQUxTQSdzIGVtdTEwazF4LmMgd2hpY2ggaXM6CiAgKiAgQ29weXJpZ2h0IChjKSBieSBGcmFuY2lzY28gTW9yYWVzIDxmbW9yYWVzQG5jLnJyLmNvbT4KICAqCiAgKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CkBAIC04Niw3ICs4Niw3IEBACiAgKiBUaGUgc2FtcGxlIHJhdGUgaXMgYWxzbyBjb250cm9sbGVkIGJ5IHRoZSBzYW1lIHJlZ2lzdGVycyB0aGF0IGNvbnRyb2wgdGhlIHJhdGUgb2YgdGhlIEVNVTEwSzIgc2FtcGxlIHJhdGUgY29udmVydGVycy4KICAqLwogCi0vKiBJbml0YWxseSBhbGwgcmVnaXN0ZXJzIGZyb20gMHgwMCB0byAweDNmIGhhdmUgemVybyBjb250ZW50cy4gKi8KKy8qIEluaXRpYWxseSBhbGwgcmVnaXN0ZXJzIGZyb20gMHgwMCB0byAweDNmIGhhdmUgemVybyBjb250ZW50cy4gKi8KICNkZWZpbmUgUExBWUJBQ0tfTElTVF9BRERSCTB4MDAJCS8qIEJhc2UgRE1BIGFkZHJlc3Mgb2YgYSBsaXN0IG9mIHBvaW50ZXJzIHRvIGVhY2ggcGVyaW9kL3NpemUgKi8KIAkJCQkJCS8qIE9uZSBsaXN0IGVudHJ5OiA0IGJ5dGVzIGZvciBETUEgYWRkcmVzcywgCiAJCQkJCQkgKiA0IGJ5dGVzIGZvciBwZXJpb2Rfc2l6ZSA8PCAxNi4KZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvaGRhX2NvZGVjLmMgYi9zb3VuZC9wY2kvaGRhL2hkYV9jb2RlYy5jCmluZGV4IDJjNzllOTYuLjQzMGY0MWQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvaGRhX2NvZGVjLmMKKysrIGIvc291bmQvcGNpL2hkYS9oZGFfY29kZWMuYwpAQCAtMzY2MSw3ICszNjYxLDcgQEAKICAqIHdpdGggdGhlIHByb3BlciBwYXJhbWV0ZXJzIGZvciBzZXQgdXAuCiAgKiBvcHMuY2xlYW51cCBzaG91bGQgYmUgY2FsbGVkIGluIGh3X2ZyZWUgZm9yIGNsZWFuIHVwIG9mIHN0cmVhbXMuCiAgKgotICogVGhpcyBmdW5jdGlvbiByZXR1cm5zIDAgaWYgc3VjY2Vzc2Z1bGwsIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZS4KKyAqIFRoaXMgZnVuY3Rpb24gcmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWwsIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZS4KICAqLwogaW50IF9fZGV2aW5pdCBzbmRfaGRhX2J1aWxkX3BjbXMoc3RydWN0IGhkYV9idXMgKmJ1cykKIHsKQEAgLTQ4NTEsNyArNDg1MSw3IEBACiAgKgogICogUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWwuCiAgKgotICogVGhpcyBmdWNudGlvbiBpcyBkZWZpbmVkIG9ubHkgd2hlbiBQT1dFUl9TQVZFIGlzbid0IHNldC4KKyAqIFRoaXMgZnVuY3Rpb24gaXMgZGVmaW5lZCBvbmx5IHdoZW4gUE9XRVJfU0FWRSBpc24ndCBzZXQuCiAgKiBJbiB0aGUgcG93ZXItc2F2ZSBtb2RlLCB0aGUgY29kZWMgaXMgcmVzdW1lZCBkeW5hbWljYWxseS4KICAqLwogaW50IHNuZF9oZGFfcmVzdW1lKHN0cnVjdCBoZGFfYnVzICpidXMpCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL3BhdGNoX2NvbmV4YW50LmMgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX2NvbmV4YW50LmMKaW5kZXggNjllMzM4Ni4uYWQ5N2Q5MyAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9wYXRjaF9jb25leGFudC5jCisrKyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfY29uZXhhbnQuYwpAQCAtMzAzNSw2ICszMDM1LDcgQEAKIAlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMWM2LCAiVGhpbmtwYWQgRWRnZSAxMyIsIENYVDUwNjZfQVNVUyksCiAgCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDIxNWUsICJMZW5vdm8gVGhpbmtwYWQiLCBDWFQ1MDY2X1RISU5LUEFEKSwKIAlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMWRhLCAiTGVub3ZvIFgyMjAiLCBDWFQ1MDY2X1RISU5LUEFEKSwKKwlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMWRiLCAiTGVub3ZvIFgyMjAtdGFibGV0IiwgQ1hUNTA2Nl9USElOS1BBRCksCiAJU05EX1BDSV9RVUlSSygweDE3YWEsIDB4MzhhZiwgIkxlbm92byBHNTYwIiwgQ1hUNTA2Nl9BU1VTKSwKIAlTTkRfUENJX1FVSVJLX1ZFTkRPUigweDE3YWEsICJMZW5vdm8iLCBDWFQ1MDY2X0lERUFQQUQpLCAvKiBGYWxsYmFjayBmb3IgTGVub3ZvcyB3aXRob3V0IGRvY2sgbWljICovCiAJe30KZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfaGRtaS5jIGIvc291bmQvcGNpL2hkYS9wYXRjaF9oZG1pLmMKaW5kZXggMjUxNzczZS4uNzE1NjE1YSAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9wYXRjaF9oZG1pLmMKKysrIGIvc291bmQvcGNpL2hkYS9wYXRjaF9oZG1pLmMKQEAgLTEyODAsNiArMTI4MCwzOSBAQAogCQkJCQkgICAgIHN0cmVhbV90YWcsIGZvcm1hdCwgc3Vic3RyZWFtKTsKIH0KIAorc3RhdGljIHZvaWQgbnZoZG1pXzhjaF83eF9zZXRfaW5mb19mcmFtZV9wYXJhbWV0ZXJzKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLAorCQkJCQkJICAgIGludCBjaGFubmVscykKK3sKKwl1bnNpZ25lZCBpbnQgY2hhbm1hc2s7CisJaW50IGNoYW4gPSBjaGFubmVscyA/IChjaGFubmVscyAtIDEpIDogMTsKKworCXN3aXRjaCAoY2hhbm5lbHMpIHsKKwlkZWZhdWx0OgorCWNhc2UgMDoKKwljYXNlIDI6CisJCWNoYW5tYXNrID0gMHgwMDsKKwkJYnJlYWs7CisJY2FzZSA0OgorCQljaGFubWFzayA9IDB4MDg7CisJCWJyZWFrOworCWNhc2UgNjoKKwkJY2hhbm1hc2sgPSAweDBiOworCQlicmVhazsKKwljYXNlIDg6CisJCWNoYW5tYXNrID0gMHgxMzsKKwkJYnJlYWs7CisJfQorCisJLyogU2V0IHRoZSBhdWRpbyBpbmZvZnJhbWUgY2hhbm5lbCBhbGxvY2F0aW9uIGFuZCBjaGVja3N1bSBmaWVsZHMuICBUaGUKKwkgKiBjaGFubmVsIGNvdW50IGlzIGNvbXB1dGVkIGltcGxpY2l0bHkgYnkgdGhlIGhhcmR3YXJlLiAqLworCXNuZF9oZGFfY29kZWNfd3JpdGUoY29kZWMsIDB4MSwgMCwKKwkJCU52X1ZFUkJfU0VUX0NoYW5uZWxfQWxsb2NhdGlvbiwgY2hhbm1hc2spOworCisJc25kX2hkYV9jb2RlY193cml0ZShjb2RlYywgMHgxLCAwLAorCQkJTnZfVkVSQl9TRVRfSW5mb19GcmFtZV9DaGVja3N1bSwKKwkJCSgweDcxIC0gY2hhbiAtIGNoYW5tYXNrKSk7Cit9CisKIHN0YXRpYyBpbnQgbnZoZG1pXzhjaF83eF9wY21fY2xvc2Uoc3RydWN0IGhkYV9wY21fc3RyZWFtICpoaW5mbywKIAkJCQkgICBzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywKIAkJCQkgICBzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSkKQEAgLTEyOTgsNiArMTMzMSwxMCBAQAogCQkJCUFDX1ZFUkJfU0VUX1NUUkVBTV9GT1JNQVQsIDApOwogCX0KIAorCS8qIFRoZSBhdWRpbyBoYXJkd2FyZSBzZW5kcyBhIGNoYW5uZWwgY291bnQgb2YgMHg3ICg4Y2gpIHdoZW4gYWxsIHRoZQorCSAqIHN0cmVhbXMgYXJlIGRpc2FibGVkLiAqLworCW52aGRtaV84Y2hfN3hfc2V0X2luZm9fZnJhbWVfcGFyYW1ldGVycyhjb2RlYywgOCk7CisKIAlyZXR1cm4gc25kX2hkYV9tdWx0aV9vdXRfZGlnX2Nsb3NlKGNvZGVjLCAmc3BlYy0+bXVsdGlvdXQpOwogfQogCkBAIC0xMzA4LDM3ICsxMzQ1LDE2IEBACiAJCQkJICAgICBzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSkKIHsKIAlpbnQgY2hzOwotCXVuc2lnbmVkIGludCBkYXRhRENDMSwgZGF0YURDQzIsIGNoYW4sIGNoYW5tYXNrLCBjaGFubmVsX2lkOworCXVuc2lnbmVkIGludCBkYXRhRENDMSwgZGF0YURDQzIsIGNoYW5uZWxfaWQ7CiAJaW50IGk7CiAKIAltdXRleF9sb2NrKCZjb2RlYy0+c3BkaWZfbXV0ZXgpOwogCiAJY2hzID0gc3Vic3RyZWFtLT5ydW50aW1lLT5jaGFubmVsczsKLQljaGFuID0gY2hzID8gKGNocyAtIDEpIDogMTsKIAotCXN3aXRjaCAoY2hzKSB7Ci0JZGVmYXVsdDoKLQljYXNlIDA6Ci0JY2FzZSAyOgotCQljaGFubWFzayA9IDB4MDA7Ci0JCWJyZWFrOwotCWNhc2UgNDoKLQkJY2hhbm1hc2sgPSAweDA4OwotCQlicmVhazsKLQljYXNlIDY6Ci0JCWNoYW5tYXNrID0gMHgwYjsKLQkJYnJlYWs7Ci0JY2FzZSA4OgotCQljaGFubWFzayA9IDB4MTM7Ci0JCWJyZWFrOwotCX0KIAlkYXRhRENDMSA9IEFDX0RJRzFfRU5BQkxFIHwgQUNfRElHMV9DT1BZUklHSFQ7CiAJZGF0YURDQzIgPSAweDI7CiAKLQkvKiBzZXQgdGhlIEF1ZGlvIEluZm9yRnJhbWUgQ2hhbm5lbCBBbGxvY2F0aW9uICovCi0Jc25kX2hkYV9jb2RlY193cml0ZShjb2RlYywgMHgxLCAwLAotCQkJTnZfVkVSQl9TRVRfQ2hhbm5lbF9BbGxvY2F0aW9uLCBjaGFubWFzayk7Ci0KIAkvKiB0dXJuIG9mZiBTUERJRiBvbmNlOyBvdGhlcndpc2UgdGhlIElFQzk1OCBiaXRzIHdvbid0IGJlIHVwZGF0ZWQgKi8KIAlpZiAoY29kZWMtPnNwZGlmX3N0YXR1c19yZXNldCAmJiAoY29kZWMtPnNwZGlmX2N0bHMgJiBBQ19ESUcxX0VOQUJMRSkpCiAJCXNuZF9oZGFfY29kZWNfd3JpdGUoY29kZWMsCkBAIC0xNDEzLDEwICsxNDI5LDcgQEAKIAkJfQogCX0KIAotCS8qIHNldCB0aGUgQXVkaW8gSW5mbyBGcmFtZSBDaGVja3N1bSAqLwotCXNuZF9oZGFfY29kZWNfd3JpdGUoY29kZWMsIDB4MSwgMCwKLQkJCU52X1ZFUkJfU0VUX0luZm9fRnJhbWVfQ2hlY2tzdW0sCi0JCQkoMHg3MSAtIGNoYW4gLSBjaGFubWFzaykpOworCW52aGRtaV84Y2hfN3hfc2V0X2luZm9fZnJhbWVfcGFyYW1ldGVycyhjb2RlYywgY2hzKTsKIAogCW11dGV4X3VubG9jaygmY29kZWMtPnNwZGlmX211dGV4KTsKIAlyZXR1cm4gMDsKQEAgLTE1MTIsNiArMTUyNSwxMSBAQAogCXNwZWMtPm11bHRpb3V0Lm1heF9jaGFubmVscyA9IDg7CiAJc3BlYy0+cGNtX3BsYXliYWNrID0gJm52aGRtaV9wY21fcGxheWJhY2tfOGNoXzd4OwogCWNvZGVjLT5wYXRjaF9vcHMgPSBudmhkbWlfcGF0Y2hfb3BzXzhjaF83eDsKKworCS8qIEluaXRpYWxpemUgdGhlIGF1ZGlvIGluZm9mcmFtZSBjaGFubmVsIG1hc2sgYW5kIGNoZWNrc3VtIHRvIHNvbWV0aGluZworCSAqIHZhbGlkICovCisJbnZoZG1pXzhjaF83eF9zZXRfaW5mb19mcmFtZV9wYXJhbWV0ZXJzKGNvZGVjLCA4KTsKKwogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL3BhdGNoX3JlYWx0ZWsuYyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfcmVhbHRlay5jCmluZGV4IDEyYzZmNDUuLjUyOTI4ZDkgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfcmVhbHRlay5jCisrKyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfcmVhbHRlay5jCkBAIC01NDksNyArNTQ5LDcgQEAKIAogLyoKICAqIENvbnRyb2wgdGhlIG1vZGUgb2YgcGluIHdpZGdldCBzZXR0aW5ncyB2aWEgdGhlIG1peGVyLiAgInBjIiBpcyB1c2VkCi0gKiBpbnN0ZWFkIG9mICIlIiB0byBhdm9pZCBjb25zZXF1ZW5jZXMgb2YgYWNjaWRlbnRseSB0cmVhdGluZyB0aGUgJSBhcworICogaW5zdGVhZCBvZiAiJSIgdG8gYXZvaWQgY29uc2VxdWVuY2VzIG9mIGFjY2lkZW50YWxseSB0cmVhdGluZyB0aGUgJSBhcwogICogYmVpbmcgcGFydCBvZiBhIGZvcm1hdCBzcGVjaWZpZXIuICBNYXhpbXVtIGFsbG93ZWQgbGVuZ3RoIG9mIGEgdmFsdWUgaXMKICAqIDYzIGNoYXJhY3RlcnMgcGx1cyBOVUxMIHRlcm1pbmF0b3IuCiAgKgpAQCAtOTgzNiw3ICs5ODM2LDcgQEAKIAogCVNORF9QQ0lfUVVJUksoMHgxMDI4LCAweDAyMGQsICJEZWxsIEluc3Bpcm9uIDUzMCIsIEFMQzg4OF82U1RfREVMTCksCiAKLQlTTkRfUENJX1FVSVJLKDB4MTAzYywgMHgyYTNkLCAiSFAgUGF2aWxsaW9uIiwgQUxDODgzXzZTVF9ESUcpLAorCVNORF9QQ0lfUVVJUksoMHgxMDNjLCAweDJhM2QsICJIUCBQYXZpbGlvbiIsIEFMQzg4M182U1RfRElHKSwKIAlTTkRfUENJX1FVSVJLKDB4MTAzYywgMHgyYTRmLCAiSFAgU2FtYmEiLCBBTEM4ODhfM1NUX0hQKSwKIAlTTkRfUENJX1FVSVJLKDB4MTAzYywgMHgyYTYwLCAiSFAgTHVja25vdyIsIEFMQzg4OF8zU1RfSFApLAogCVNORF9QQ0lfUVVJUksoMHgxMDNjLCAweDJhNjEsICJIUCBOZXR0bGUiLCBBTEM4ODNfNlNUX0RJRyksCkBAIC0xNDEyNCw3ICsxNDEyNCw3IEBACiB9OwogCiBzdGF0aWMgaGRhX25pZF90IGFsYzI2OV9hZGNfY2FuZGlkYXRlc1tdID0gewotCTB4MDgsIDB4MDksIDB4MDcsCisJMHgwOCwgMHgwOSwgMHgwNywgMHgxMSwKIH07CiAKICNkZWZpbmUgYWxjMjY5X21vZGVzCQlhbGMyNjBfbW9kZXMKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfc2lnbWF0ZWwuYyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfc2lnbWF0ZWwuYwppbmRleCAwNWZjZDYwLi45NGQxOWMwIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaGRhL3BhdGNoX3NpZ21hdGVsLmMKKysrIGIvc291bmQvcGNpL2hkYS9wYXRjaF9zaWdtYXRlbC5jCkBAIC0yNDc1LDcgKzI0NzUsNyBAQAogIAogCXNwZWMtPmhwX3N3aXRjaCA9IHVjb250cm9sLT52YWx1ZS5pbnRlZ2VyLnZhbHVlWzBdID8gbmlkIDogMDsKIAotCS8qIGNoZWNrIHRvIGJlIHN1cmUgdGhhdCB0aGUgcG9ydHMgYXJlIHVwdG8gZGF0ZSB3aXRoCisJLyogY2hlY2sgdG8gYmUgc3VyZSB0aGF0IHRoZSBwb3J0cyBhcmUgdXAgdG8gZGF0ZSB3aXRoCiAJICogc3dpdGNoIGNoYW5nZXMKIAkgKi8KIAlzdGFjX2lzc3VlX3Vuc29sX2V2ZW50KGNvZGVjLCBuaWQpOwpAQCAtMzQwOCw2ICszNDA4LDkgQEAKIAloZGFfbmlkX3QgY29ubltIREFfTUFYX05VTV9JTlBVVFNdOwogCWludCBpLCBudW1zOwogCisJaWYgKCEoZ2V0X3djYXBzKGNvZGVjLCBtdXgpICYgQUNfV0NBUF9DT05OX0xJU1QpKQorCQlyZXR1cm4gLTE7CisKIAludW1zID0gc25kX2hkYV9nZXRfY29ubmVjdGlvbnMoY29kZWMsIG11eCwgY29ubiwgQVJSQVlfU0laRShjb25uKSk7CiAJZm9yIChpID0gMDsgaSA8IG51bXM7IGkrKykKIAkJaWYgKGNvbm5baV0gPT0gbmlkKQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2ljZTE3MTIvYXVyZW9uLmMgYi9zb3VuZC9wY2kvaWNlMTcxMi9hdXJlb24uYwppbmRleCAyZjYyNTIyLi4zZTRmOGMxIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaWNlMTcxMi9hdXJlb24uYworKysgYi9zb3VuZC9wY2kvaWNlMTcxMi9hdXJlb24uYwpAQCAtMTQ4LDcgKzE0OCw3IEBACiAJdWRlbGF5KDEwMCk7CiAJLyoKIAkgKiBzZW5kIGRldmljZSBhZGRyZXNzLCBjb21tYW5kIGFuZCB2YWx1ZSwKLQkgKiBza2lwcGluZyBhY2sgY3ljbGVzIGluYmV0d2VlbgorCSAqIHNraXBwaW5nIGFjayBjeWNsZXMgaW4gYmV0d2VlbgogCSAqLwogCWZvciAoaiA9IDA7IGogPCAzOyBqKyspIHsKIAkJc3dpdGNoIChqKSB7CkBAIC0yMTQzLDcgKzIxNDMsNyBAQAogCQlpY2UtPm51bV90b3RhbF9hZGNzID0gMjsKIAl9CiAKLQkvKiB0byByZW1lYmVyIHRoZSByZWdpc3RlciB2YWx1ZXMgb2YgQ1M4NDE1ICovCisJLyogdG8gcmVtZW1iZXIgdGhlIHJlZ2lzdGVyIHZhbHVlcyBvZiBDUzg0MTUgKi8KIAlpY2UtPmFrbSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzbmRfYWttNHh4eCksIEdGUF9LRVJORUwpOwogCWlmICghaWNlLT5ha20pCiAJCXJldHVybiAtRU5PTUVNOwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2ljZTE3MTIvaWNlMTcxMi5jIGIvc291bmQvcGNpL2ljZTE3MTIvaWNlMTcxMi5jCmluZGV4IDRmYzZkOGIuLmY0NTk0ZDcgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9pY2UxNzEyL2ljZTE3MTIuYworKysgYi9zb3VuZC9wY2kvaWNlMTcxMi9pY2UxNzEyLmMKQEAgLTI3NTUsNyArMjc1NSw3IEBACiAJCQlyZXR1cm4gZXJyOwogCQl9CiAJCWlmIChjLT5tcHU0MDFfMV9uYW1lKQotCQkJLyogIFByZWZlcmVkIG5hbWUgYXZhaWxhYmxlIGluIGNhcmRfaW5mbyAqLworCQkJLyogIFByZWZlcnJlZCBuYW1lIGF2YWlsYWJsZSBpbiBjYXJkX2luZm8gKi8KIAkJCXNucHJpbnRmKGljZS0+cm1pZGlbMF0tPm5hbWUsCiAJCQkJIHNpemVvZihpY2UtPnJtaWRpWzBdLT5uYW1lKSwKIAkJCQkgIiVzICVkIiwgYy0+bXB1NDAxXzFfbmFtZSwgY2FyZC0+bnVtYmVyKTsKQEAgLTI3NzIsNyArMjc3Miw3IEBACiAJCQkJcmV0dXJuIGVycjsKIAkJCX0KIAkJCWlmIChjLT5tcHU0MDFfMl9uYW1lKQotCQkJCS8qICBQcmVmZXJlZCBuYW1lIGF2YWlsYWJsZSBpbiBjYXJkX2luZm8gKi8KKwkJCQkvKiAgUHJlZmVycmVkIG5hbWUgYXZhaWxhYmxlIGluIGNhcmRfaW5mbyAqLwogCQkJCXNucHJpbnRmKGljZS0+cm1pZGlbMV0tPm5hbWUsCiAJCQkJCSBzaXplb2YoaWNlLT5ybWlkaVsxXS0+bmFtZSksCiAJCQkJCSAiJXMgJWQiLCBjLT5tcHU0MDFfMl9uYW1lLApkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2ljZTE3MTIvcG9udGlzLmMgYi9zb3VuZC9wY2kvaWNlMTcxMi9wb250aXMuYwppbmRleCBjZGI4NzNmLi45MmMxMTYwIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaWNlMTcxMi9wb250aXMuYworKysgYi9zb3VuZC9wY2kvaWNlMTcxMi9wb250aXMuYwpAQCAtNzY4LDcgKzc2OCw3IEBACiAJaWNlLT5udW1fdG90YWxfZGFjcyA9IDI7CiAJaWNlLT5udW1fdG90YWxfYWRjcyA9IDI7CiAKLQkvKiB0byByZW1lYmVyIHRoZSByZWdpc3RlciB2YWx1ZXMgKi8KKwkvKiB0byByZW1lbWJlciB0aGUgcmVnaXN0ZXIgdmFsdWVzICovCiAJaWNlLT5ha20gPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc25kX2FrbTR4eHgpLCBHRlBfS0VSTkVMKTsKIAlpZiAoISBpY2UtPmFrbSkKIAkJcmV0dXJuIC1FTk9NRU07CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaWNlMTcxMi9wcm9kaWd5X2hpZmkuYyBiL3NvdW5kL3BjaS9pY2UxNzEyL3Byb2RpZ3lfaGlmaS5jCmluZGV4IDZhOWZlZTMuLjc2NGNjOTMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9pY2UxNzEyL3Byb2RpZ3lfaGlmaS5jCisrKyBiL3NvdW5kL3BjaS9pY2UxNzEyL3Byb2RpZ3lfaGlmaS5jCkBAIC0xMDQ2LDcgKzEwNDYsNyBAQAogCSogZG9uJ3QgY2FsbCBzbmRfaWNlMTcxMl9ncGlvX2dldC9wdXQoKSwgb3RoZXJ3aXNlIGl0J3Mgb3ZlcndyaXR0ZW4KIAkqLwogCWljZS0+Z3Bpby5zYXZlZFswXSA9IDA7Ci0JLyogdG8gcmVtZWJlciB0aGUgcmVnaXN0ZXIgdmFsdWVzICovCisJLyogdG8gcmVtZW1iZXIgdGhlIHJlZ2lzdGVyIHZhbHVlcyAqLwogCiAJaWNlLT5ha20gPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc25kX2FrbTR4eHgpLCBHRlBfS0VSTkVMKTsKIAlpZiAoISBpY2UtPmFrbSkKQEAgLTExMjgsNyArMTEyOCw3IEBACiAJKiBkb24ndCBjYWxsIHNuZF9pY2UxNzEyX2dwaW9fZ2V0L3B1dCgpLCBvdGhlcndpc2UgaXQncyBvdmVyd3JpdHRlbgogCSovCiAJaWNlLT5ncGlvLnNhdmVkWzBdID0gMDsKLQkvKiB0byByZW1lYmVyIHRoZSByZWdpc3RlciB2YWx1ZXMgKi8KKwkvKiB0byByZW1lbWJlciB0aGUgcmVnaXN0ZXIgdmFsdWVzICovCiAKIAlpY2UtPmFrbSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzbmRfYWttNHh4eCksIEdGUF9LRVJORUwpOwogCWlmICghIGljZS0+YWttKQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2ludGVsOHgwLmMgYi9zb3VuZC9wY2kvaW50ZWw4eDAuYwppbmRleCA2MjlhNTQ5Li42Yzg5NmRiIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaW50ZWw4eDAuYworKysgYi9zb3VuZC9wY2kvaW50ZWw4eDAuYwpAQCAtNTM0LDcgKzUzNCw3IEBACiAJCXVkZWxheSgxMCk7CiAJfSB3aGlsZSAodGltZS0tKTsKIAotCS8qIGFjY2VzcyB0byBzb21lIGZvcmJpZGRlbiAobm9uIGV4aXN0YW50KSBhYzk3IHJlZ2lzdGVycyB3aWxsIG5vdAorCS8qIGFjY2VzcyB0byBzb21lIGZvcmJpZGRlbiAobm9uIGV4aXN0ZW50KSBhYzk3IHJlZ2lzdGVycyB3aWxsIG5vdAogCSAqIHJlc2V0IHRoZSBzZW1hcGhvcmUuIFNvIGV2ZW4gaWYgeW91IGRvbid0IGdldCB0aGUgc2VtYXBob3JlLCBzdGlsbAogCSAqIGNvbnRpbnVlIHRoZSBhY2Nlc3MuIFdlIGRvbid0IG5lZWQgdGhlIHNlbWFwaG9yZSBhbnl3YXkuICovCiAJc25kX3ByaW50ayhLRVJOX0VSUiAiY29kZWNfc2VtYXBob3JlOiBzZW1hcGhvcmUgaXMgbm90IHJlYWR5IFsweCV4XVsweCV4XVxuIiwKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9pbnRlbDh4MG0uYyBiL3NvdW5kL3BjaS9pbnRlbDh4MG0uYwppbmRleCAyYWU4ZDI5Li4yNzcwOWYwIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaW50ZWw4eDBtLmMKKysrIGIvc291bmQvcGNpL2ludGVsOHgwbS5jCkBAIC0zMzEsNyArMzMxLDcgQEAKIAkJdWRlbGF5KDEwKTsKIAl9IHdoaWxlICh0aW1lLS0pOwogCi0JLyogYWNjZXNzIHRvIHNvbWUgZm9yYmlkZGVuIChub24gZXhpc3RhbnQpIGFjOTcgcmVnaXN0ZXJzIHdpbGwgbm90CisJLyogYWNjZXNzIHRvIHNvbWUgZm9yYmlkZGVuIChub24gZXhpc3RlbnQpIGFjOTcgcmVnaXN0ZXJzIHdpbGwgbm90CiAJICogcmVzZXQgdGhlIHNlbWFwaG9yZS4gU28gZXZlbiBpZiB5b3UgZG9uJ3QgZ2V0IHRoZSBzZW1hcGhvcmUsIHN0aWxsCiAJICogY29udGludWUgdGhlIGFjY2Vzcy4gV2UgZG9uJ3QgbmVlZCB0aGUgc2VtYXBob3JlIGFueXdheS4gKi8KIAlzbmRfcHJpbnRrKEtFUk5fRVJSICJjb2RlY19zZW1hcGhvcmU6IHNlbWFwaG9yZSBpcyBub3QgcmVhZHkgWzB4JXhdWzB4JXhdXG4iLApkaWZmIC0tZ2l0IGEvc291bmQvcGNpL21peGFydC9taXhhcnRfY29yZS5jIGIvc291bmQvcGNpL21peGFydC9taXhhcnRfY29yZS5jCmluZGV4IGQzMzUwZjMuLjNkZjBmNTMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9taXhhcnQvbWl4YXJ0X2NvcmUuYworKysgYi9zb3VuZC9wY2kvbWl4YXJ0L21peGFydF9jb3JlLmMKQEAgLTI2NSw3ICsyNjUsNyBAQAogCWlmICghIHRpbWVvdXQpIHsKIAkJLyogZXJyb3IgLSBubyBhY2sgKi8KIAkJbXV0ZXhfdW5sb2NrKCZtZ3ItPm1zZ19tdXRleCk7Ci0JCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yOiBubyByZXBvbnNlIG9uIG1zZyAleFxuIiwgbXNnX2ZyYW1lKTsKKwkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3I6IG5vIHJlc3BvbnNlIG9uIG1zZyAleFxuIiwgbXNnX2ZyYW1lKTsKIAkJcmV0dXJuIC1FSU87CiAJfQogCkBAIC0yNzgsNyArMjc4LDcgQEAKIAllcnIgPSBnZXRfbXNnKG1nciwgJnJlc3AsIG1zZ19mcmFtZSk7CiAKIAlpZiggcmVxdWVzdC0+bWVzc2FnZV9pZCAhPSByZXNwLm1lc3NhZ2VfaWQgKQotCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJSRVBPTlNFIEVSUk9SIVxuIik7CisJCXNuZF9wcmludGsoS0VSTl9FUlIgIlJFU1BPTlNFIEVSUk9SIVxuIik7CiAKIAltdXRleF91bmxvY2soJm1nci0+bXNnX211dGV4KTsKIAlyZXR1cm4gZXJyOwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL3BjeGhyL3BjeGhyX2NvcmUuYyBiL3NvdW5kL3BjaS9wY3hoci9wY3hocl9jb3JlLmMKaW5kZXggODMzZTcxOC4uMzA0NDExYyAxMDA2NDQKLS0tIGEvc291bmQvcGNpL3BjeGhyL3BjeGhyX2NvcmUuYworKysgYi9zb3VuZC9wY2kvcGN4aHIvcGN4aHJfY29yZS5jCkBAIC0xMDQyLDExICsxMDQyLDExIEBACiAJaW50IGksIGo7CiAKIAlpZiAobWdyLT5zcmNfaXRfZHNwICYgUENYSFJfSVJRX0ZSRVFfQ0hBTkdFKQotCQlzbmRfcHJpbnRkZCgiVEFTS0xFVCA6IFBDWEhSX0lSUV9GUkVRX0NIQU5HRSBldmVudCBvY2N1cmVkXG4iKTsKKwkJc25kX3ByaW50ZGQoIlRBU0tMRVQgOiBQQ1hIUl9JUlFfRlJFUV9DSEFOR0UgZXZlbnQgb2NjdXJyZWRcbiIpOwogCWlmIChtZ3ItPnNyY19pdF9kc3AgJiBQQ1hIUl9JUlFfVElNRV9DT0RFKQotCQlzbmRfcHJpbnRkZCgiVEFTS0xFVCA6IFBDWEhSX0lSUV9USU1FX0NPREUgZXZlbnQgb2NjdXJlZFxuIik7CisJCXNuZF9wcmludGRkKCJUQVNLTEVUIDogUENYSFJfSVJRX1RJTUVfQ09ERSBldmVudCBvY2N1cnJlZFxuIik7CiAJaWYgKG1nci0+c3JjX2l0X2RzcCAmIFBDWEhSX0lSUV9OT1RJRlkpCi0JCXNuZF9wcmludGRkKCJUQVNLTEVUIDogUENYSFJfSVJRX05PVElGWSBldmVudCBvY2N1cmVkXG4iKTsKKwkJc25kX3ByaW50ZGQoIlRBU0tMRVQgOiBQQ1hIUl9JUlFfTk9USUZZIGV2ZW50IG9jY3VycmVkXG4iKTsKIAlpZiAobWdyLT5zcmNfaXRfZHNwICYgKFBDWEhSX0lSUV9GUkVRX0NIQU5HRSB8IFBDWEhSX0lSUV9USU1FX0NPREUpKSB7CiAJCS8qIGNsZWFyIGV2ZW50cyBGUkVRX0NIQU5HRSBhbmQgVElNRV9DT0RFICovCiAJCXBjeGhyX2luaXRfcm1oKHBybWgsIENNRF9URVNUX0lUKTsKQEAgLTEwNTUsNyArMTA1NSw3IEBACiAJCQkgICAgZXJyLCBwcm1oLT5zdGF0WzBdKTsKIAl9CiAJaWYgKG1nci0+c3JjX2l0X2RzcCAmIFBDWEhSX0lSUV9BU1lOQykgewotCQlzbmRfcHJpbnRkZCgiVEFTS0xFVCA6IFBDWEhSX0lSUV9BU1lOQyBldmVudCBvY2N1cmVkXG4iKTsKKwkJc25kX3ByaW50ZGQoIlRBU0tMRVQgOiBQQ1hIUl9JUlFfQVNZTkMgZXZlbnQgb2NjdXJyZWRcbiIpOwogCiAJCXBjeGhyX2luaXRfcm1oKHBybWgsIENNRF9BU1lOQyk7CiAJCXBybWgtPmNtZFswXSB8PSAxOwkvKiBhZGQgU0VMX0FTWU5DX0VWRU5UUyAqLwpAQCAtMTIzMyw3ICsxMjMzLDcgQEAKIAlyZWcgPSBQQ1hIUl9JTlBMKG1nciwgUENYSFJfUExYX0wyUENJREIpOwogCVBDWEhSX09VVFBMKG1nciwgUENYSFJfUExYX0wyUENJREIsIHJlZyk7CiAKLQkvKiB0aW1lciBpcnEgb2NjdXJlZCAqLworCS8qIHRpbWVyIGlycSBvY2N1cnJlZCAqLwogCWlmIChyZWcgJiBQQ1hIUl9JUlFfVElNRVIpIHsKIAkJaW50IHRpbWVyX3RvZ2dsZSA9IHJlZyAmIFBDWEhSX0lSUV9USU1FUjsKIAkJLyogaXMgYSAyNCBiaXQgY291bnRlciAqLwpAQCAtMTI4OCw3ICsxMjg4LDcgQEAKIAlpZiAocmVnICYgUENYSFJfSVJRX01BU0spIHsKIAkJaWYgKHJlZyAmIFBDWEhSX0lSUV9BU1lOQykgewogCQkJLyogYXMgd2UgZGlkbid0IHJlcXVlc3QgYW55IGFzeW5jIG5vdGlmaWNhdGlvbnMsCi0JCQkgKiBzb21lIGtpbmQgb2YgeHJ1biBlcnJvciB3aWxsIHByb2JhYmx5IG9jY3VyZWQKKwkJCSAqIHNvbWUga2luZCBvZiB4cnVuIGVycm9yIHdpbGwgcHJvYmFibHkgb2NjdXJyZWQKIAkJCSAqLwogCQkJLyogYmV0dGVyIHJlc3luY2hyb25pemUgYWxsIHN0cmVhbXMgbmV4dCBpbnRlcnJ1cHQgOiAqLwogCQkJbWdyLT5kc3BfdGltZV9sYXN0ID0gUENYSFJfRFNQX1RJTUVfSU5WQUxJRDsKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9ybWU5Ni5jIGIvc291bmQvcGNpL3JtZTk2LmMKaW5kZXggZDVmNWI0NC4uOWZmMjQ3ZiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL3JtZTk2LmMKKysrIGIvc291bmQvcGNpL3JtZTk2LmMKQEAgLTE1MCw3ICsxNTAsNyBAQAogI2RlZmluZSBSTUU5Nl9SQ1JfQklUUE9TX0YxIDI4CiAjZGVmaW5lIFJNRTk2X1JDUl9CSVRQT1NfRjIgMjkKIAotLyogQWRkaXRvbmFsIHJlZ2lzdGVyIGJpdHMgKi8KKy8qIEFkZGl0aW9uYWwgcmVnaXN0ZXIgYml0cyAqLwogI2RlZmluZSBSTUU5Nl9BUl9XU0VMICAgICAgICgxIDw8IDApCiAjZGVmaW5lIFJNRTk2X0FSX0FOQUxPRyAgICAgKDEgPDwgMSkKICNkZWZpbmUgUk1FOTZfQVJfRlJFUVBBRF8wICAoMSA8PCAyKQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL3JtZTk2NTIvaGRzcG0uYyBiL3NvdW5kL3BjaS9ybWU5NjUyL2hkc3BtLmMKaW5kZXggYTMyM2VhZi4uOTQ5NjkxYSAxMDA2NDQKLS0tIGEvc291bmQvcGNpL3JtZTk2NTIvaGRzcG0uYworKysgYi9zb3VuZC9wY2kvcm1lOTY1Mi9oZHNwbS5jCkBAIC0zOTEsNyArMzkxLDcgQEAKIAogLyogU3RhdHVzMiBSZWdpc3RlciBiaXRzICovIC8qIE1BREkgT05MWSAqLwogCi0jZGVmaW5lIEhEU1BNX3ZlcnNpb24wICgxPDwwKQkvKiBub3QgcmVhbHkgZGVmaW5lZCBidXQgSSBndWVzcyAqLworI2RlZmluZSBIRFNQTV92ZXJzaW9uMCAoMTw8MCkJLyogbm90IHJlYWxseSBkZWZpbmVkIGJ1dCBJIGd1ZXNzICovCiAjZGVmaW5lIEhEU1BNX3ZlcnNpb24xICgxPDwxKQkvKiBpbiBmb3JtZXIgY2FyZHMgaXQgd2FzID8/PyAqLwogI2RlZmluZSBIRFNQTV92ZXJzaW9uMiAoMTw8MikKIApAQCAtOTM2LDcgKzkzNiw3IEBACiAJc3RydWN0IHNuZF9rY29udHJvbCAqcGxheWJhY2tfbWl4ZXJfY3Rsc1tIRFNQTV9NQVhfQ0hBTk5FTFNdOwogCS8qIGJ1dCBpbnB1dCB0byBtdWNoLCBzbyBub3QgdXNlZCAqLwogCXN0cnVjdCBzbmRfa2NvbnRyb2wgKmlucHV0X21peGVyX2N0bHNbSERTUE1fTUFYX0NIQU5ORUxTXTsKLQkvKiBmdWxsIG1peGVyIGFjY2Vzc2FibGUgb3ZlciBtaXhlciBpb2N0bCBvciBod2RlcC1kZXZpY2UgKi8KKwkvKiBmdWxsIG1peGVyIGFjY2Vzc2libGUgb3ZlciBtaXhlciBpb2N0bCBvciBod2RlcC1kZXZpY2UgKi8KIAlzdHJ1Y3QgaGRzcG1fbWl4ZXIgKm1peGVyOwogCiAJc3RydWN0IGhkc3BtX3RjbyAqdGNvOyAgLyogTlVMTCBpZiBubyBUQ08gZGV0ZWN0ZWQgKi8KZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9zaXM3MDE5LmMgYi9zb3VuZC9wY2kvc2lzNzAxOS5jCmluZGV4IDFiOGY2NzQuLjJiNWM3YTk1IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvc2lzNzAxOS5jCisrKyBiL3NvdW5kL3BjaS9zaXM3MDE5LmMKQEAgLTMwOCw3ICszMDgsNyBAQAogCXUzMiBpbnRyLCBzdGF0dXM7CiAKIAkvKiBXZSBvbmx5IHVzZSB0aGUgRE1BIGludGVycnVwdHMsIGFuZCB3ZSBkb24ndCBlbmFibGUgYW55IG90aGVyCi0JICogc291cmNlIG9mIGludGVycnVwdHMuIEJ1dCwgaXQgaXMgcG9zc2libGUgdG8gc2VlIGFuIGludGVydXB0CisJICogc291cmNlIG9mIGludGVycnVwdHMuIEJ1dCwgaXQgaXMgcG9zc2libGUgdG8gc2VlIGFuIGludGVycnVwdAogCSAqIHN0YXR1cyB0aGF0IGRpZG4ndCBhY3R1YWxseSBpbnRlcnJ1cHQgdXMsIHNvIGVsaW1pbmF0ZSBhbnl0aGluZwogCSAqIHdlJ3JlIG5vdCBleHBlY3RpbmcgdG8gYXZvaWQgZmFsc2VseSBjbGFpbWluZyBhbiBJUlEsIGFuZCBhbgogCSAqIGVuc3VpbmcgZW5kbGVzcyBsb29wLgpAQCAtNzczLDcgKzc3Myw3IEBACiAJCXZwZXJpb2QgPSAwOwogCX0KIAotCS8qIFRoZSBpbnRlcnJ1cHQgaGFuZGxlciBpbXBsZW1lbnRzIHRoZSB0aW1pbmcgc3luY3Jvbml6YXRpb24sIHNvCisJLyogVGhlIGludGVycnVwdCBoYW5kbGVyIGltcGxlbWVudHMgdGhlIHRpbWluZyBzeW5jaHJvbml6YXRpb24sIHNvCiAJICogc2V0dXAgaXRzIHN0YXRlLgogCSAqLwogCXRpbWluZy0+ZmxhZ3MgfD0gVk9JQ0VfU1lOQ19USU1JTkc7CkBAIC0xMTM5LDcgKzExMzksNyBAQAogCSAqLwogCW91dGwoU0lTX0RNQV9DU1JfUENJX1NFVFRJTkdTLCBpbyArIFNJU19ETUFfQ1NSKTsKIAotCS8qIFJlc2V0IHRoZSBzeW5jcm9uaXphdGlvbiBncm91cHMgZm9yIGFsbCBvZiB0aGUgY2hhbm5lbHMKKwkvKiBSZXNldCB0aGUgc3luY2hyb25pemF0aW9uIGdyb3VwcyBmb3IgYWxsIG9mIHRoZSBjaGFubmVscwogCSAqIHRvIGJlIGFzeW5jcm9ub3VzLiBJZiB3ZSBzdGFydCBkb2luZyBTUERJRiBvciA1LjEgc291bmQsIGV0Yy4KIAkgKiB3ZSdsbCBuZWVkIHRvIGNoYW5nZSBob3cgd2UgaGFuZGxlIHRoZXNlLiBVbnRpbCB0aGVuLCB3ZSBqdXN0CiAJICogYXNzaWduIHN1Yi1taXhlciAwIHRvIGFsbCBwbGF5YmFjayBjaGFubmVscywgYW5kIGF2b2lkIGFueQpkaWZmIC0tZ2l0IGEvc291bmQvcHBjL3NuZF9wczMuYyBiL3NvdW5kL3BwYy9zbmRfcHMzLmMKaW5kZXggZWRjZThhMi4uYmM4MjNhNSAxMDA2NDQKLS0tIGEvc291bmQvcHBjL3NuZF9wczMuYworKysgYi9zb3VuZC9wcGMvc25kX3BzMy5jCkBAIC0zNTgsNyArMzU4LDcgQEAKIAkJICogZmlsbGluZyBkdW1teSBkYXRhLCBzZXJpYWwgYXV0b21hdGljYWxseSBzdGFydCB0bwogCQkgKiBjb25zdW1lIHRoZW0gYW5kIHRoZW4gd2lsbCBnZW5lcmF0ZSBub3JtYWwgYnVmZmVyCiAJCSAqIGVtcHR5IGludGVycnVwdHMuCi0JCSAqIElmIGJvdGggYnVmZmVyIHVuZGVyZmxvdyBhbmQgYnVmZmVyIGVtcHR5IGFyZSBvY2N1cmVkLAorCQkgKiBJZiBib3RoIGJ1ZmZlciB1bmRlcmZsb3cgYW5kIGJ1ZmZlciBlbXB0eSBhcmUgb2NjdXJyZWQsCiAJCSAqIGl0IGlzIGJldHRlciB0byBkbyBub21hbCBkYXRhIHRyYW5zZmVyIHRoYW4gZW1wdHkgb25lCiAJCSAqLwogCQlzbmRfcHMzX3Byb2dyYW1fZG1hKGNhcmQsCmRpZmYgLS1naXQgYS9zb3VuZC9wcGMvc25kX3BzM19yZWcuaCBiL3NvdW5kL3BwYy9zbmRfcHMzX3JlZy5oCmluZGV4IDAzZmRlZTQuLjJlNjMwMjAgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BwYy9zbmRfcHMzX3JlZy5oCisrKyBiL3NvdW5kL3BwYy9zbmRfcHMzX3JlZy5oCkBAIC0xMjUsNyArMTI1LDcgQEAKICAgIHRyYW5zZmVycy4gIEFueSBpbnRlcnJ1cHRzIGFzc29jaWF0ZWQgd2l0aCB0aGUgY2FuY2VsZWQgdHJhbnNmZXJzCiAgICB3aWxsIG9jY3VyIGFzIGlmIHRoZSB0cmFuc2ZlciBoYWQgZmluaXNoZWQuCiAgICBTaW5jZSB0aGlzIGJpdCBpcyBkZXNpZ25lZCB0byByZWNvdmVyIGZyb20gRE1BIHJlbGF0ZWQgaXNzdWVzCi0gICB3aGljaCBhcmUgY2F1c2VkIGJ5IHVucHJlZGljdGFibGUgc2l0dWF0aW9ucywgaXQgaXMgcHJlZmVyZWQgdG8gd2FpdAorICAgd2hpY2ggYXJlIGNhdXNlZCBieSB1bnByZWRpY3RhYmxlIHNpdHVhdGlvbnMsIGl0IGlzIHByZWZlcnJlZCB0byB3YWl0CiAgICBmb3Igbm9ybWFsIERNQSB0cmFuc2ZlciBlbmQgd2l0aG91dCB1c2luZyB0aGlzIGJpdC4KICovCiAjZGVmaW5lIFBTM19BVURJT19DT05GSUdfQ0xFQVIgICAgICAgICAgKDEgPDwgOCkgIC8qIFJXSVZGICovCkBAIC0zMTYsMTMgKzMxNiwxMyBAQAogCiAvKgogQXVkaW8gUG9ydCBJbnRlcnJ1cHQgU3RhdHVzIFJlZ2lzdGVyCi1JbmRpY2F0ZXMgSW50ZXJydXB0IHN0YXR1cywgd2hpY2ggaW50ZXJydXB0IGhhcyBvY2N1cmVkLCBhbmQgY2FuIGNsZWFyCitJbmRpY2F0ZXMgSW50ZXJydXB0IHN0YXR1cywgd2hpY2ggaW50ZXJydXB0IGhhcyBvY2N1cnJlZCwgYW5kIGNhbiBjbGVhcgogZWFjaCBpbnRlcnJ1cHQgaW4gdGhpcyByZWdpc3Rlci4KIFdyaXRpbmcgMWIgdG8gYSBmaWVsZCBjb250YWluaW5nIDFiIGNsZWFycyBmaWVsZCBhbmQgZGUtYXNzZXJ0cyBpbnRlcnJ1cHQuCiBXcml0aW5nIDBiIHRvIGEgZmllbGQgaGFzIG5vIGVmZmVjdC4KIEZpZWxkIHZhdWxlcyBhcmUgdGhlIGZvbGxvd2luZzoKLTAgLSBJbnRlcnJ1cHQgaGFzbid0IG9jY3VyZWQuCi0xIC0gSW50ZXJydXB0IGhhcyBvY2N1cmVkLgorMCAtIEludGVycnVwdCBoYXNuJ3Qgb2NjdXJyZWQuCisxIC0gSW50ZXJydXB0IGhhcyBvY2N1cnJlZC4KIAogCiAgMzEgICAgICAgICAgICAyNCAyMyAgICAgICAgICAgMTYgMTUgICAgICAgICAgICA4IDcgICAgICAgICAgICAgMApAQCAtNDczLDcgKzQ3Myw3IEBACiAvKgogU2FtcGxpbmcgUmF0ZQogU3BlY2lmaWVzIHRoZSBkaXZpZGUgcmF0aW8gb2YgdGhlIGJpdCBjbG9jayAoY2xvY2sgb3V0cHV0Ci1mcm9tIGJjbGtvKSB1c2VkIGJ5IHRoZSAzLXdpcmUgQXVkaW8gT3V0cHV0IENsb2NrLCB3aGNpaAorZnJvbSBiY2xrbykgdXNlZCBieSB0aGUgMy13aXJlIEF1ZGlvIE91dHB1dCBDbG9jaywgd2hpY2gKIGlzIGFwcGxpZWQgdG8gdGhlIG1hc3RlciBjbG9jayBzZWxlY3RlZCBieSBtY2tzZWwuCiBEYXRhIG91dHB1dCBpcyBzeW5jaHJvbml6ZWQgd2l0aCB0aGlzIGNsb2NrLgogKi8KQEAgLTc1Niw3ICs3NTYsNyBAQAogRE9ORSBpbmRpY2F0ZXMgdGhlIHByZXZpb3VzIHJlcXVlc3QgaGFzIGNvbXBsZXRlZC4KIEVWRU5UIGluZGljYXRlcyB0aGF0IHRoZSBETUEgZW5naW5lIGlzIHdhaXRpbmcgZm9yIHRoZSBFVkVOVCB0byBvY2N1ci4KIFBFTkRJTkcgaW5kaWNhdGVzIHRoYXQgdGhlIERNQSBlbmdpbmUgaGFzIG5vdCBzdGFydGVkIHByb2Nlc3NpbmcgdGhpcwotcmVxdWVzdCwgYnV0IHRoZSBFVkVOVCBoYXMgb2NjdXJlZC4KK3JlcXVlc3QsIGJ1dCB0aGUgRVZFTlQgaGFzIG9jY3VycmVkLgogRE1BIGluZGljYXRlcyB0aGF0IHRoZSBkYXRhIHRyYW5zZmVyIGlzIGluIHByb2dyZXNzLgogTk9USUZZIGluZGljYXRlcyB0aGF0IHRoZSBub3RpZmllciBzaWduYWxsaW5nIGVuZCBvZiB0cmFuc2ZlciBpcyBiZWluZyB3cml0dGVuLgogQ0xFQVIgaW5kaWNhdGVkIHRoYXQgdGhlIHByZXZpb3VzIHRyYW5zZmVyIHdhcyBjbGVhcmVkLgpAQCAtODI0LDcgKzgyNCw3IEBACiAKIC8qCiBQUzNfQVVESU9fRE1BU0laRSBzcGVjaWZpZXMgdGhlIG51bWJlciBvZiAxMjgtYnl0ZSBibG9ja3MgKyAxIHRvIHRyYW5zZmVyLgotU28gYSB2YWx1ZSBvZiAwIG1lYW5zIDEyOC1ieXRlcyB3aWxsIGdldCB0cmFuc2ZlcmVkLgorU28gYSB2YWx1ZSBvZiAwIG1lYW5zIDEyOC1ieXRlcyB3aWxsIGdldCB0cmFuc2ZlcnJlZC4KIAogCiAgMzEgICAgICAgICAgICAyNCAyMyAgICAgICAgICAgMTYgMTUgICAgICAgICAgICA4IDcgICAgICAgICAgICAgMApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2F0bWVsL2F0bWVsX3NzY19kYWkuYyBiL3NvdW5kL3NvYy9hdG1lbC9hdG1lbF9zc2NfZGFpLmMKaW5kZXggNWQyMzBjZS4uN2ZiZmEwNSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2F0bWVsL2F0bWVsX3NzY19kYWkuYworKysgYi9zb3VuZC9zb2MvYXRtZWwvYXRtZWxfc3NjX2RhaS5jCkBAIC02NzIsNyArNjcyLDcgQEAKIAkvKiByZS1lbmFibGUgaW50ZXJydXB0cyAqLwogCXNzY193cml0ZWwoc3NjX3AtPnNzYy0+cmVncywgSUVSLCBzc2NfcC0+c3NjX3N0YXRlLnNzY19pbXIpOwogCi0JLyogUmUtZW5hYmxlIHJlY2lldmUgYW5kIHRyYW5zbWl0IGFzIGFwcHJvcHJpYXRlICovCisJLyogUmUtZW5hYmxlIHJlY2VpdmUgYW5kIHRyYW5zbWl0IGFzIGFwcHJvcHJpYXRlICovCiAJY3IgPSAwOwogCWNyIHw9CiAJICAgIChzc2NfcC0+c3NjX3N0YXRlLnNzY19zciAmIFNTQ19CSVQoU1JfUlhFTikpID8gU1NDX0JJVChDUl9SWEVOKSA6IDA7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL2FsYzU2MjMuYyBiL3NvdW5kL3NvYy9jb2RlY3MvYWxjNTYyMy5jCmluZGV4IDRmMzc3YzkuLmVlY2ZmYjUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3MvYWxjNTYyMy5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvYWxjNTYyMy5jCkBAIC00ODEsNyArNDgxLDcgQEAKIH07CiAKIC8qIE5vdGUgOiBwbGwgY29kZSBmcm9tIG9yaWdpbmFsIGFsYzU2MjMgZHJpdmVyLiBOb3Qgc3VyZSBvZiBob3cgZ29vZCBpdCBpcyAqLwotLyogdXNlZnVsbCBvbmx5IGZvciBtYXN0ZXIgbW9kZSAqLworLyogdXNlZnVsIG9ubHkgZm9yIG1hc3RlciBtb2RlICovCiBzdGF0aWMgY29uc3Qgc3RydWN0IF9wbGxfZGl2IGNvZGVjX21hc3Rlcl9wbGxfZGl2W10gPSB7CiAKIAl7ICAyMDQ4MDAwLCAgODE5MjAwMCwJMHgwZWEwfSwKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3MvbG00ODU3LmMgYi9zb3VuZC9zb2MvY29kZWNzL2xtNDg1Ny5jCmluZGV4IDcyZGU0N2UuLjJjMmE2ODEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3MvbG00ODU3LmMKKysrIGIvc291bmQvc29jL2NvZGVjcy9sbTQ4NTcuYwpAQCAtMTYxLDcgKzE2MSw3IEBACiAJCWxtNDg1N19nZXRfbW9kZSwgbG00ODU3X3NldF9tb2RlKSwKIH07CiAKLS8qIFRoZXJlIGlzIGEgZGVtdXggaW5iZXR3ZWVuIHRoZSB0aGUgaW5wdXQgc2lnbmFsIGFuZCB0aGUgb3V0cHV0IHNpZ25hbHMuCisvKiBUaGVyZSBpcyBhIGRlbXV4IGJldHdlZW4gdGhlIGlucHV0IHNpZ25hbCBhbmQgdGhlIG91dHB1dCBzaWduYWxzLgogICogQ3VycmVudGx5IHRoZXJlIGlzIG5vIGVhc3kgd2F5IHRvIG1vZGVsIGl0IGluIEFTb0MgYW5kIHNpbmNlIGl0IGRvZXMgbm90IG1ha2UKICAqIG11Y2ggb2YgYSBkaWZmZXJlbmNlIGluIHByYWN0aWNlIHNpbXBseSBjb25uZWN0IHRoZSBpbnB1dCBkaXJlY2x0eSB0byB0aGUKICAqIG91dHB1dHMuICovCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3RsdjMyMGFpYzI2LmggYi9zb3VuZC9zb2MvY29kZWNzL3RsdjMyMGFpYzI2LmgKaW5kZXggNjJiMWYyMi4uNjdmMTljMyAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy90bHYzMjBhaWMyNi5oCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvdGx2MzIwYWljMjYuaApAQCAtMTQsMTQgKzE0LDE0IEBACiAjZGVmaW5lIEFJQzI2X1BBR0VfQUREUihwYWdlLCBvZmZzZXQpCSgocGFnZSA8PCA2KSB8IG9mZnNldCkKICNkZWZpbmUgQUlDMjZfTlVNX1JFR1MJCQlBSUMyNl9QQUdFX0FERFIoMywgMCkKIAotLyogUGFnZSAwOiBBdXhpbGxhcnkgZGF0YSByZWdpc3RlcnMgKi8KKy8qIFBhZ2UgMDogQXV4aWxpYXJ5IGRhdGEgcmVnaXN0ZXJzICovCiAjZGVmaW5lIEFJQzI2X1JFR19CQVQxCQkJQUlDMjZfUEFHRV9BRERSKDAsIDB4MDUpCiAjZGVmaW5lIEFJQzI2X1JFR19CQVQyCQkJQUlDMjZfUEFHRV9BRERSKDAsIDB4MDYpCiAjZGVmaW5lIEFJQzI2X1JFR19BVVgJCQlBSUMyNl9QQUdFX0FERFIoMCwgMHgwNykKICNkZWZpbmUgQUlDMjZfUkVHX1RFTVAxCQkJQUlDMjZfUEFHRV9BRERSKDAsIDB4MDkpCiAjZGVmaW5lIEFJQzI2X1JFR19URU1QMgkJCUFJQzI2X1BBR0VfQUREUigwLCAweDBBKQogCi0vKiBQYWdlIDE6IEF1eGlsbGFyeSBjb250cm9sIHJlZ2lzdGVycyAqLworLyogUGFnZSAxOiBBdXhpbGlhcnkgY29udHJvbCByZWdpc3RlcnMgKi8KICNkZWZpbmUgQUlDMjZfUkVHX0FVWF9BREMJCUFJQzI2X1BBR0VfQUREUigxLCAweDAwKQogI2RlZmluZSBBSUMyNl9SRUdfU1RBVFVTCQlBSUMyNl9QQUdFX0FERFIoMSwgMHgwMSkKICNkZWZpbmUgQUlDMjZfUkVHX1JFRkVSRU5DRQkJQUlDMjZfUEFHRV9BRERSKDEsIDB4MDMpCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3RsdjMyMGFpYzN4LmMgYi9zb3VuZC9zb2MvY29kZWNzL3RsdjMyMGFpYzN4LmMKaW5kZXggM2JlZGFiMi4uNmM0M2MxMyAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy90bHYzMjBhaWMzeC5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvdGx2MzIwYWljM3guYwpAQCAtODg0LDcgKzg4NCw3IEBACiAJaWYgKGJ5cGFzc19wbGwpCiAJCXJldHVybiAwOwogCi0JLyogVXNlIFBMTCwgY29tcHV0ZSBhcHJvcHJpYXRlIHNldHVwIGZvciBqLCBkLCByIGFuZCBwLCB0aGUgY2xvc2VzdAorCS8qIFVzZSBQTEwsIGNvbXB1dGUgYXBwcm9wcmlhdGUgc2V0dXAgZm9yIGosIGQsIHIgYW5kIHAsIHRoZSBjbG9zZXN0CiAJICogb25lIHdpbnMgdGhlIGdhbWUuIFRyeSB3aXRoIGQ9PTAgZmlyc3QsIG5leHQgd2l0aCBkIT0wLgogCSAqIENvbnN0cmFpbnRzIGZvciBqIGFyZSBhY2NvcmRpbmcgdG8gdGhlIGRhdGFzaGVldC4KIAkgKiBUaGUgc3lzY2xrIGlzIGRpdmlkZWQgYnkgMTAwMCB0byBwcmV2ZW50IGludGVnZXIgb3ZlcmZsb3dzLgpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy90bHYzMjBkYWMzMy5jIGIvc291bmQvc29jL2NvZGVjcy90bHYzMjBkYWMzMy5jCmluZGV4IGViMWEwYjQuLjA4MmU5ZDUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3MvdGx2MzIwZGFjMzMuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3RsdjMyMGRhYzMzLmMKQEAgLTEwMjcsNyArMTAyNyw3IEBACiAJCS8qCiAJCSAqIEZvciBGSUZPIGJ5cGFzcyBtb2RlOgogCQkgKiBFbmFibGUgdGhlIEZJRk8gYnlwYXNzIChEaXNhYmxlIHRoZSBGSUZPIHVzZSkKLQkJICogU2V0IHRoZSBCQ0xLIGFzIGNvbnRpbm91cworCQkgKiBTZXQgdGhlIEJDTEsgYXMgY29udGludW91cwogCQkgKi8KIAkJZmlmb2N0cmxfYSB8PSBEQUMzM19GQllQQVM7CiAJCWFpY3RybF9iIHw9IERBQzMzX0JDTEtPTjsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3MvdHdsNDAzMC5jIGIvc291bmQvc29jL2NvZGVjcy90d2w0MDMwLmMKaW5kZXggODUxMjgwMC4uNTc1MjM4ZCAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy90d2w0MDMwLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy90d2w0MDMwLmMKQEAgLTI4MSw3ICsyODEsNyBAQAogCQkJCSBpLCB2YWwsIHR3bDQwMzBfcmVnW2ldKTsKIAkJfQogCX0KLQlkZXZfZGJnKGNvZGVjLT5kZXYsICJGb3VuZCAlZCBub24gbWFjaGluZyByZWdpc3RlcnMuICVzXG4iLAorCWRldl9kYmcoY29kZWMtPmRldiwgIkZvdW5kICVkIG5vbi1tYXRjaGluZyByZWdpc3RlcnMuICVzXG4iLAogCQkgZGlmZmVyZW5jZSwgZGlmZmVyZW5jZSA/ICJOb3QgT0siIDogIk9LIik7CiB9CiAKQEAgLTIwMTgsNyArMjAxOCw3IEBACiAJdTggbW9kZTsKIAogCS8qIElmIHRoZSBzeXN0ZW0gbWFzdGVyIGNsb2NrIGlzIG5vdCAyNk1IeiwgdGhlIHZvaWNlIFBDTSBpbnRlcmZhY2UgaXMKLQkgKiBub3QgYXZpbGFibGUuCisJICogbm90IGF2YWlsYWJsZS4KIAkgKi8KIAlpZiAodHdsNDAzMC0+c3lzY2xrICE9IDI2MDAwKSB7CiAJCWRldl9lcnIoY29kZWMtPmRldiwgIlRoZSBib2FyZCBpcyBjb25maWd1cmVkIGZvciAldSBIeiwgd2hpbGUiCkBAIC0yMDI4LDcgKzIwMjgsNyBAQAogCX0KIAogCS8qIElmIHRoZSBjb2RlYyBtb2RlIGlzIG5vdCBvcHRpb24yLCB0aGUgdm9pY2UgUENNIGludGVyZmFjZSBpcyBub3QKLQkgKiBhdmlsYWJsZS4KKwkgKiBhdmFpbGFibGUuCiAJICovCiAJbW9kZSA9IHR3bDQwMzBfcmVhZF9yZWdfY2FjaGUoY29kZWMsIFRXTDQwMzBfUkVHX0NPREVDX01PREUpCiAJCSYgVFdMNDAzMF9PUFRfTU9ERTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd204NTgwLmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtODU4MC5jCmluZGV4IDhmNmI1ZWUuLjRiYmMwYTcgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd204NTgwLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTg1ODAuYwpAQCAtNzcyLDcgKzc3Miw3IEBACiAJCQlyZWcgJj0gfihXTTg1ODBfUFdSRE4xX1BXRE4gfCBXTTg1ODBfUFdSRE4xX0FMTERBQ1BEKTsKIAkJCXNuZF9zb2Nfd3JpdGUoY29kZWMsIFdNODU4MF9QV1JETjEsIHJlZyk7CiAKLQkJCS8qIE1ha2UgVk1JRCBoaWdoIGltcGVkZW5jZSAqLworCQkJLyogTWFrZSBWTUlEIGhpZ2ggaW1wZWRhbmNlICovCiAJCQlyZWcgPSBzbmRfc29jX3JlYWQoY29kZWMsICBXTTg1ODBfQURDX0NPTlRST0wxKTsKIAkJCXJlZyAmPSB+MHgxMDA7CiAJCQlzbmRfc29jX3dyaXRlKGNvZGVjLCBXTTg1ODBfQURDX0NPTlRST0wxLCByZWcpOwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg3NTMuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204NzUzLmMKaW5kZXggM2YwOWRlZS4uZmZhMmZmZSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg3NTMuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODc1My5jCkBAIC0xMzEyLDcgKzEzMTIsNyBAQAogCVNORFJWX1BDTV9GTVRCSVRfUzI0X0xFKQogCiAvKgotICogVGhlIFdNODc1MyBzdXBwb3J0cyB1cHRvIDQgZGlmZmVyZW50IGFuZCBtdXR1YWxseSBleGNsdXNpdmUgREFJCisgKiBUaGUgV004NzUzIHN1cHBvcnRzIHVwIHRvIDQgZGlmZmVyZW50IGFuZCBtdXR1YWxseSBleGNsdXNpdmUgREFJCiAgKiBjb25maWd1cmF0aW9ucy4gVGhpcyBnaXZlcyAyIFBDTSdzIGF2YWlsYWJsZSBmb3IgdXNlLCBoaWZpIGFuZCB2b2ljZS4KICAqIE5PVEU6IFRoZSBWb2ljZSBQQ00gY2Fubm90IHBsYXkgb3IgY2FwdHVyZSBhdWRpbyB0byB0aGUgQ1BVIGFzIGl0J3MgREFJCiAgKiBpcyBjb25uZWN0ZWQgYmV0d2VlbiB0aGUgd204NzUzIGFuZCBhIEJUIGNvZGVjIG9yIEdTTSBtb2RlbS4KZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTA0LmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtODkwNC5jCmluZGV4IDQ0M2FlNTguLjliM2JiYTQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTA0LmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTg5MDQuYwpAQCAtMTg5NSw3ICsxODk1LDcgQEAKIAogCXByX2RlYnVnKCJGdmNvPSVkSHpcbiIsIHRhcmdldCk7CiAKLQkvKiBGaW5kIGFuIGFwcHJvcHJhaXRlIEZMTF9GUkFUSU8gYW5kIGZhY3RvciBpdCBvdXQgb2YgdGhlIHRhcmdldCAqLworCS8qIEZpbmQgYW4gYXBwcm9wcmlhdGUgRkxMX0ZSQVRJTyBhbmQgZmFjdG9yIGl0IG91dCBvZiB0aGUgdGFyZ2V0ICovCiAJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoZmxsX2ZyYXRpb3MpOyBpKyspIHsKIAkJaWYgKGZsbF9mcmF0aW9zW2ldLm1pbiA8PSBGcmVmICYmIEZyZWYgPD0gZmxsX2ZyYXRpb3NbaV0ubWF4KSB7CiAJCQlmbGxfZGl2LT5mbGxfZnJhdGlvID0gZmxsX2ZyYXRpb3NbaV0uZmxsX2ZyYXRpbzsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTU1LmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk1NS5jCmluZGV4IDVlMDIxNGQuLjNjNzE5ODcgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTU1LmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTg5NTUuYwpAQCAtMTc2LDcgKzE3Niw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLS8qIExvb2t1cCB0YWJsZSBzcGVjaWZpeWluZyBTUkFURSAodGFibGUgMjUgaW4gZGF0YXNoZWV0KTsgc29tZSBvZiB0aGUKKy8qIExvb2t1cCB0YWJsZSBzcGVjaWZ5aW5nIFNSQVRFICh0YWJsZSAyNSBpbiBkYXRhc2hlZXQpOyBzb21lIG9mIHRoZQogICogb3V0cHV0IGZyZXF1ZW5jaWVzIGhhdmUgYmVlbiByb3VuZGVkIHRvIHRoZSBzdGFuZGFyZCBmcmVxdWVuY2llcwogICogdGhleSBhcmUgaW50ZW5kZWQgdG8gbWF0Y2ggd2hlcmUgdGhlIGVycm9yIGlzIHNsaWdodC4gKi8KIHN0YXRpYyBzdHJ1Y3QgewpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg5NjIuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTYyLmMKaW5kZXggM2I3MWRkNi4uNTAwMDExZSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg5NjIuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk2Mi5jCkBAIC0zMTM3LDcgKzMxMzcsNyBAQAogCiAJcHJfZGVidWcoIkZMTCBGdmNvPSVkSHpcbiIsIHRhcmdldCk7CiAKLQkvKiBGaW5kIGFuIGFwcHJvcHJhaXRlIEZMTF9GUkFUSU8gYW5kIGZhY3RvciBpdCBvdXQgb2YgdGhlIHRhcmdldCAqLworCS8qIEZpbmQgYW4gYXBwcm9wcmlhdGUgRkxMX0ZSQVRJTyBhbmQgZmFjdG9yIGl0IG91dCBvZiB0aGUgdGFyZ2V0ICovCiAJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoZmxsX2ZyYXRpb3MpOyBpKyspIHsKIAkJaWYgKGZsbF9mcmF0aW9zW2ldLm1pbiA8PSBGcmVmICYmIEZyZWYgPD0gZmxsX2ZyYXRpb3NbaV0ubWF4KSB7CiAJCQlmbGxfZGl2LT5mbGxfZnJhdGlvID0gZmxsX2ZyYXRpb3NbaV0uZmxsX2ZyYXRpbzsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTkxLmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk5MS5jCmluZGV4IDI4ZmRmZDYuLjNjMmVlMWIgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTkxLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTg5OTEuYwpAQCAtOTgxLDcgKzk4MSw3IEBACiAJCXJlZyA9IHNuZF9zb2NfcmVhZChjb2RlYywgV004OTkxX0NMT0NLSU5HXzIpOwogCQlzbmRfc29jX3dyaXRlKGNvZGVjLCBXTTg5OTFfQ0xPQ0tJTkdfMiwgcmVnIHwgV004OTkxX1NZU0NMS19TUkMpOwogCi0JCS8qIHNldCB1cCBOICwgZnJhY3Rpb25hbCBtb2RlIGFuZCBwcmUtZGl2aXNvciBpZiBuZWNjZXNzYXJ5ICovCisJCS8qIHNldCB1cCBOICwgZnJhY3Rpb25hbCBtb2RlIGFuZCBwcmUtZGl2aXNvciBpZiBuZWNlc3NhcnkgKi8KIAkJc25kX3NvY193cml0ZShjb2RlYywgV004OTkxX1BMTDEsIHBsbF9kaXYubiB8IFdNODk5MV9TRE0gfAogCQkJICAgICAgKHBsbF9kaXYuZGl2MiA/IFdNODk5MV9QUkVTQ0FMRSA6IDApKTsKIAkJc25kX3NvY193cml0ZShjb2RlYywgV004OTkxX1BMTDIsICh1OCkocGxsX2Rpdi5rPj44KSk7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3dtODk5My5jIGIvc291bmQvc29jL2NvZGVjcy93bTg5OTMuYwppbmRleCAzNzlmYTIyLi4wNTZhZWY5IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL3dtODk5My5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTkzLmMKQEAgLTMyNCw3ICszMjQsNyBAQAogCiAJcHJfZGVidWcoIkZ2Y289JWRIelxuIiwgdGFyZ2V0KTsKIAotCS8qIEZpbmQgYW4gYXBwcm9wcmFpdGUgRkxMX0ZSQVRJTyBhbmQgZmFjdG9yIGl0IG91dCBvZiB0aGUgdGFyZ2V0ICovCisJLyogRmluZCBhbiBhcHByb3ByaWF0ZSBGTExfRlJBVElPIGFuZCBmYWN0b3IgaXQgb3V0IG9mIHRoZSB0YXJnZXQgKi8KIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShmbGxfZnJhdGlvcyk7IGkrKykgewogCQlpZiAoZmxsX2ZyYXRpb3NbaV0ubWluIDw9IEZyZWYgJiYgRnJlZiA8PSBmbGxfZnJhdGlvc1tpXS5tYXgpIHsKIAkJCWZsbF9kaXYtPmZsbF9mcmF0aW8gPSBmbGxfZnJhdGlvc1tpXS5mbGxfZnJhdGlvOwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg5OTQuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTk0LmMKaW5kZXggM2RjNjRjOC4uMzI5MDMzMyAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg5OTQuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk5NC5jCkBAIC04MiwxOCArODIsMTggQEAKIAogCWludCBtYmNfZW5hWzNdOwogCi0JLyogUGxhdGZvcm0gZGVwZW5kYW50IERSQyBjb25maWd1cmF0aW9uICovCisJLyogUGxhdGZvcm0gZGVwZW5kZW50IERSQyBjb25maWd1cmF0aW9uICovCiAJY29uc3QgY2hhciAqKmRyY190ZXh0czsKIAlpbnQgZHJjX2NmZ1tXTTg5OTRfTlVNX0RSQ107CiAJc3RydWN0IHNvY19lbnVtIGRyY19lbnVtOwogCi0JLyogUGxhdGZvcm0gZGVwZW5kYW50IFJlVHVuZSBtb2JpbGUgY29uZmlndXJhdGlvbiAqLworCS8qIFBsYXRmb3JtIGRlcGVuZGVudCBSZVR1bmUgbW9iaWxlIGNvbmZpZ3VyYXRpb24gKi8KIAlpbnQgbnVtX3JldHVuZV9tb2JpbGVfdGV4dHM7CiAJY29uc3QgY2hhciAqKnJldHVuZV9tb2JpbGVfdGV4dHM7CiAJaW50IHJldHVuZV9tb2JpbGVfY2ZnW1dNODk5NF9OVU1fRVFdOwogCXN0cnVjdCBzb2NfZW51bSByZXR1bmVfbW9iaWxlX2VudW07CiAKLQkvKiBQbGF0Zm9ybSBkZXBlbmRhbnQgTUJDIGNvbmZpZ3VyYXRpb24gKi8KKwkvKiBQbGF0Zm9ybSBkZXBlbmRlbnQgTUJDIGNvbmZpZ3VyYXRpb24gKi8KIAlpbnQgbWJjX2NmZzsKIAljb25zdCBjaGFyICoqbWJjX3RleHRzOwogCXN0cnVjdCBzb2NfZW51bSBtYmNfZW51bTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd205MDgxLmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtOTA4MS5jCmluZGV4IDU1Y2RmMjkuLjkxYzZiMzkgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd205MDgxLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTkwODEuYwpAQCAtMzA1LDcgKzMwNSw3IEBACiAvKgogICogU3RvcCBhbnkgYXR0ZW1wdHMgdG8gY2hhbmdlIHNwZWFrZXIgbW9kZSB3aGlsZSB0aGUgc3BlYWtlciBpcyBlbmFibGVkLgogICoKLSAqIFdlIGFsc28gaGF2ZSBzb21lIHNwZWNpYWwgYW50aS1wb3AgY29udHJvbHMgZGVwZW5kYW50IG9uIHNwZWFrZXIKKyAqIFdlIGFsc28gaGF2ZSBzb21lIHNwZWNpYWwgYW50aS1wb3AgY29udHJvbHMgZGVwZW5kZW50IG9uIHNwZWFrZXIKICAqIG1vZGUgd2hpY2ggbXVzdCBiZSBjaGFuZ2VkIGFsb25nIHdpdGggdGhlIG1vZGUuCiAgKi8KIHN0YXRpYyBpbnQgc3BlYWtlcl9tb2RlX3B1dChzdHJ1Y3Qgc25kX2tjb250cm9sICprY29udHJvbCwKQEAgLTQ1Niw3ICs0NTYsNyBAQAogCiAJcHJfZGVidWcoIkZ2Y289JWRIelxuIiwgdGFyZ2V0KTsKIAotCS8qIEZpbmQgYW4gYXBwcm9wcmFpdGUgRkxMX0ZSQVRJTyBhbmQgZmFjdG9yIGl0IG91dCBvZiB0aGUgdGFyZ2V0ICovCisJLyogRmluZCBhbiBhcHByb3ByaWF0ZSBGTExfRlJBVElPIGFuZCBmYWN0b3IgaXQgb3V0IG9mIHRoZSB0YXJnZXQgKi8KIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShmbGxfZnJhdGlvcyk7IGkrKykgewogCQlpZiAoZmxsX2ZyYXRpb3NbaV0ubWluIDw9IEZyZWYgJiYgRnJlZiA8PSBmbGxfZnJhdGlvc1tpXS5tYXgpIHsKIAkJCWZsbF9kaXYtPmZsbF9mcmF0aW8gPSBmbGxfZnJhdGlvc1tpXS5mbGxfZnJhdGlvOwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2lteC9pbXgtc3NpLmMgYi9zb3VuZC9zb2MvaW14L2lteC1zc2kuYwppbmRleCBiYzkyZWM2Li5hYzJkZWQ5IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvaW14L2lteC1zc2kuYworKysgYi9zb3VuZC9zb2MvaW14L2lteC1zc2kuYwpAQCAtMTYsNyArMTYsNyBAQAogICogc2FuZSBwcm9jZXNzb3IgdmVuZG9ycyBoYXZlIGEgRklGTyBwZXIgQUM5NyBzbG90LCB0aGUgaS5NWCBoYXMgb25seQogICogb25lIEZJRk8gd2hpY2ggY29tYmluZXMgYWxsIHZhbGlkIHJlY2VpdmUgc2xvdHMuIFdlIGNhbm5vdCBldmVuIHNlbGVjdAogICogd2hpY2ggc2xvdHMgd2Ugd2FudCB0byByZWNlaXZlLiBUaGUgV005NzEyIHdpdGggd2hpY2ggdGhpcyBkcml2ZXIKLSAqIHdhcyBkZXZlbG9wcGVkIHdpdGggYWx3YXlzIHNlbmRzIEdQSU8gc3RhdHVzIGRhdGEgaW4gc2xvdCAxMiB3aGljaAorICogd2FzIGRldmVsb3BlZCB3aXRoIGFsd2F5cyBzZW5kcyBHUElPIHN0YXR1cyBkYXRhIGluIHNsb3QgMTIgd2hpY2gKICAqIHdlIHJlY2VpdmUgaW4gb3VyIChQQ00tKSBkYXRhIHN0cmVhbS4gVGhlIG9ubHkgY2hhbmNlIHdlIGhhdmUgaXMgdG8KICAqIG1hbnVhbGx5IHNraXAgdGhpcyBkYXRhIGluIHRoZSBGSVEgaGFuZGxlci4gV2l0aCBzYW1wbGluZyByYXRlcyBkaWZmZXJlbnQKICAqIGZyb20gNDgwMDBIeiBub3QgZXZlcnkgZnJhbWUgaGFzIHZhbGlkIHJlY2VpdmUgZGF0YSwgc28gdGhlIHJhdGlvCmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mva2lya3dvb2Qva2lya3dvb2QtZG1hLmMgYi9zb3VuZC9zb2Mva2lya3dvb2Qva2lya3dvb2QtZG1hLmMKaW5kZXggMGZkNmE2My4uZTEzYzZjZSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2tpcmt3b29kL2tpcmt3b29kLWRtYS5jCisrKyBiL3NvdW5kL3NvYy9raXJrd29vZC9raXJrd29vZC1kbWEuYwpAQCAtMTMyLDcgKzEzMiw3IEBACiAJcHJpdiA9IHNuZF9zb2NfZGFpX2dldF9kbWFfZGF0YShjcHVfZGFpLCBzdWJzdHJlYW0pOwogCXNuZF9zb2Nfc2V0X3J1bnRpbWVfaHdwYXJhbXMoc3Vic3RyZWFtLCAma2lya3dvb2RfZG1hX3NuZF9odyk7CiAKLQkvKiBFbnN1cmUgdGhhdCBhbGwgY29uc3RyYWludHMgbGlua2VkIHRvIGRtYSBidXJzdCBhcmUgZnVsbGZpbGxlZCAqLworCS8qIEVuc3VyZSB0aGF0IGFsbCBjb25zdHJhaW50cyBsaW5rZWQgdG8gZG1hIGJ1cnN0IGFyZSBmdWxmaWxsZWQgKi8KIAllcnIgPSBzbmRfcGNtX2h3X2NvbnN0cmFpbnRfbWlubWF4KHJ1bnRpbWUsCiAJCQlTTkRSVl9QQ01fSFdfUEFSQU1fQlVGRkVSX0JZVEVTLAogCQkJcHJpdi0+YnVyc3QgKiAyLApAQCAtMTcwLDcgKzE3MCw3IEBACiAKIAkJLyoKIAkJICogRW5hYmxlIEVycm9yIGludGVycnVwdHMuIFdlJ3JlIG9ubHkgYWNrJ2luZyB0aGVtIGJ1dAotCQkgKiBpdCdzIHVzZWZ1bGwgZm9yIGRpYWdub3N0aWNzCisJCSAqIGl0J3MgdXNlZnVsIGZvciBkaWFnbm9zdGljcwogCQkgKi8KIAkJd3JpdGVsKCh1bnNpZ25lZCBsb25nKS0xLCBwcml2LT5pbyArIEtJUktXT09EX0VSUl9NQVNLKTsKIAl9CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvbWlkLXg4Ni9zc3RfcGxhdGZvcm0uYyBiL3NvdW5kL3NvYy9taWQteDg2L3NzdF9wbGF0Zm9ybS5jCmluZGV4IGVlMmMyMjQuLmIyZTkxOTggMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9taWQteDg2L3NzdF9wbGF0Zm9ybS5jCisrKyBiL3NvdW5kL3NvYy9taWQteDg2L3NzdF9wbGF0Zm9ybS5jCkBAIC00NDAsNyArNDQwLDcgQEAKIAogCXNuZF9zb2NfdW5yZWdpc3Rlcl9kYWlzKCZwZGV2LT5kZXYsIEFSUkFZX1NJWkUoc3N0X3BsYXRmb3JtX2RhaSkpOwogCXNuZF9zb2NfdW5yZWdpc3Rlcl9wbGF0Zm9ybSgmcGRldi0+ZGV2KTsKLQlwcl9kZWJ1Zygic3N0X3BsYXRmb3JtX3JlbW92ZSBzdWNlc3NcbiIpOworCXByX2RlYnVnKCJzc3RfcGxhdGZvcm1fcmVtb3ZlIHN1Y2Nlc3NcbiIpOwogCXJldHVybiAwOwogfQogCkBAIC00NjMsNyArNDYzLDcgQEAKIHN0YXRpYyB2b2lkIF9fZXhpdCBzc3Rfc29jX3BsYXRmb3JtX2V4aXQodm9pZCkKIHsKIAlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3Rlcigmc3N0X3BsYXRmb3JtX2RyaXZlcik7Ci0JcHJfZGVidWcoInNzdF9zb2NfcGxhdGZvcm1fZXhpdCBzdWNlc3NcbiIpOworCXByX2RlYnVnKCJzc3Rfc29jX3BsYXRmb3JtX2V4aXQgc3VjY2Vzc1xuIik7CiB9CiBtb2R1bGVfZXhpdChzc3Rfc29jX3BsYXRmb3JtX2V4aXQpOwogCmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mvb21hcC9hbXMtZGVsdGEuYyBiL3NvdW5kL3NvYy9vbWFwL2Ftcy1kZWx0YS5jCmluZGV4IDMxNjdiZTYuLjQ2MmNiY2IgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9vbWFwL2Ftcy1kZWx0YS5jCisrKyBiL3NvdW5kL3NvYy9vbWFwL2Ftcy1kZWx0YS5jCkBAIC0yNDgsNyArMjQ4LDcgQEAKICAqLwogCiAvKiBUbyBhY3R1YWxseSBhcHBseSBhbnkgbW9kZW0gY29udHJvbGxlZCBjb25maWd1cmF0aW9uIGNoYW5nZXMgdG8gdGhlIGNvZGVjLAotICogd2UgbXVzdCBjb25uZWN0IGNvZGVjIERBSSBwaW5zIHRvIHRoZSBtb2RlbSBmb3IgYSBtb21lbnQuICBCZSBjYXJlZnVsbCBub3QKKyAqIHdlIG11c3QgY29ubmVjdCBjb2RlYyBEQUkgcGlucyB0byB0aGUgbW9kZW0gZm9yIGEgbW9tZW50LiAgQmUgY2FyZWZ1bCBub3QKICAqIHRvIGludGVyZmVyZSB3aXRoIG91ciBkaWdpdGFsIG11dGUgZnVuY3Rpb24gdGhhdCBzaGFyZXMgdGhlIHNhbWUgaGFyZHdhcmUuICovCiBzdGF0aWMgc3RydWN0IHRpbWVyX2xpc3QgY3g4MTgwMV90aW1lcjsKIHN0YXRpYyBib29sIGN4ODE4MDFfY21kX3BlbmRpbmc7CkBAIC00MDIsOSArNDAyLDkgQEAKIAogCiAvKgotICogRXZlbiBpZiBub3QgdmVyeSB1c2VmdWxsLCB0aGUgc291bmQgY2FyZCBjYW4gc3RpbGwgd29yayB3aXRob3V0IGFueSBvZiB0aGUKKyAqIEV2ZW4gaWYgbm90IHZlcnkgdXNlZnVsLCB0aGUgc291bmQgY2FyZCBjYW4gc3RpbGwgd29yayB3aXRob3V0IGFueSBvZiB0aGUKICAqIGFib3ZlIGZ1bmN0b25hbGl0eSBhY3RpdmF0ZWQuICBZb3UgY2FuIHN0aWxsIGNvbnRyb2wgaXRzIGF1ZGlvIGlucHV0L291dHB1dAotICogY29uc3RlbGxhdGlvbiBhbmQgc3BlYWtlcnBob25lIGdhaW4gZnJvbSB1c2Vyc3BhY2UgYnkgaXNzdWVpbmcgQVQgY29tbWFuZHMKKyAqIGNvbnN0ZWxsYXRpb24gYW5kIHNwZWFrZXJwaG9uZSBnYWluIGZyb20gdXNlcnNwYWNlIGJ5IGlzc3VpbmcgQVQgY29tbWFuZHMKICAqIG92ZXIgdGhlIG1vZGVtIHBvcnQuCiAgKi8KIApkaWZmIC0tZ2l0IGEvc291bmQvc29jL3B4YS9weGEyeHgtcGNtLmMgYi9zb3VuZC9zb2MvcHhhL3B4YTJ4eC1wY20uYwppbmRleCAwMmZiNjY0Li4yY2UwYjJkIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvcHhhL3B4YTJ4eC1wY20uYworKysgYi9zb3VuZC9zb2MvcHhhL3B4YTJ4eC1wY20uYwpAQCAtNjUsNiArNjUsNyBAQAogCWlmIChwcnRkLT5kbWFfY2ggPj0gMCkgewogCQlweGFfZnJlZV9kbWEocHJ0ZC0+ZG1hX2NoKTsKIAkJcHJ0ZC0+ZG1hX2NoID0gLTE7CisJCXBydGQtPnBhcmFtcyA9IE5VTEw7CiAJfQogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvcHhhL3p5bG9uaXRlLmMgYi9zb3VuZC9zb2MvcHhhL3p5bG9uaXRlLmMKaW5kZXggYWM1NzcyNi4uYjY0NDU3NSAxMDA2NDQKLS0tIGEvc291bmQvc29jL3B4YS96eWxvbml0ZS5jCisrKyBiL3NvdW5kL3NvYy9weGEvenlsb25pdGUuYwpAQCAtMTY3LDcgKzE2Nyw3IEBACiAJLmNvZGVjX25hbWUgPSAid205NzEzLWNvZGVjIiwKIAkucGxhdGZvcm1fbmFtZSA9ICJweGEtcGNtLWF1ZGlvIiwKIAkuY3B1X2RhaV9uYW1lID0gInB4YTJ4eC1hYzk3IiwKLQkuY29kZWNfbmFtZSA9ICJ3bTk3MTMtaGlmaSIsCisJLmNvZGVjX2RhaV9uYW1lID0gIndtOTcxMy1oaWZpIiwKIAkuaW5pdCA9IHp5bG9uaXRlX3dtOTcxM19pbml0LAogfSwKIHsKQEAgLTE3Niw3ICsxNzYsNyBAQAogCS5jb2RlY19uYW1lID0gIndtOTcxMy1jb2RlYyIsCiAJLnBsYXRmb3JtX25hbWUgPSAicHhhLXBjbS1hdWRpbyIsCiAJLmNwdV9kYWlfbmFtZSA9ICJweGEyeHgtYWM5Ny1hdXgiLAotCS5jb2RlY19uYW1lID0gIndtOTcxMy1hdXgiLAorCS5jb2RlY19kYWlfbmFtZSA9ICJ3bTk3MTMtYXV4IiwKIH0sCiB7CiAJLm5hbWUgPSAiV005NzEzIFZvaWNlIiwKQEAgLTE4NCw3ICsxODQsNyBAQAogCS5jb2RlY19uYW1lID0gIndtOTcxMy1jb2RlYyIsCiAJLnBsYXRmb3JtX25hbWUgPSAicHhhLXBjbS1hdWRpbyIsCiAJLmNwdV9kYWlfbmFtZSA9ICJweGEtc3NwLWRhaS4yIiwKLQkuY29kZWNfbmFtZSA9ICJ3bTk3MTMtdm9pY2UiLAorCS5jb2RlY19kYWlfbmFtZSA9ICJ3bTk3MTMtdm9pY2UiLAogCS5vcHMgPSAmenlsb25pdGVfdm9pY2Vfb3BzLAogfSwKIH07CmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mvc2Ftc3VuZy9uZW8xOTczX3dtODc1My5jIGIvc291bmQvc29jL3NhbXN1bmcvbmVvMTk3M193bTg3NTMuYwppbmRleCA3OGJmZGIzLi40NTIyMzA5IDEwMDY0NAotLS0gYS9zb3VuZC9zb2Mvc2Ftc3VuZy9uZW8xOTczX3dtODc1My5jCisrKyBiL3NvdW5kL3NvYy9zYW1zdW5nL25lbzE5NzNfd204NzUzLmMKQEAgLTIyOCw3ICsyMjgsNyBAQAogCVNPQ19EQVBNX1BJTl9TV0lUQ0goIkhhbmRzZXQgTWljIiksCiB9OwogCi0vKiBHVEEwMiBzcGVjaWZpYyByb3V0ZXMgYW5kIGNvbnRyb2xscyAqLworLyogR1RBMDIgc3BlY2lmaWMgcm91dGVzIGFuZCBjb250cm9scyAqLwogCiAjaWZkZWYgQ09ORklHX01BQ0hfTkVPMTk3M19HVEEwMgogCkBAIC0zNzIsNyArMzcyLDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotLyogR1RBMDEgc3BlY2lmaWMgY29udHJvbGxzICovCisvKiBHVEEwMSBzcGVjaWZpYyBjb250cm9scyAqLwogCiAjaWZkZWYgQ09ORklHX01BQ0hfTkVPMTk3M19HVEEwMQogCmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mvc29jLWNvcmUuYyBiL3NvdW5kL3NvYy9zb2MtY29yZS5jCmluZGV4IDRkZGE1ODkuLmI3NmI3NGQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9zb2MtY29yZS5jCisrKyBiL3NvdW5kL3NvYy9zb2MtY29yZS5jCkBAIC05Miw4ICs5Miw4IEBACiBzdGF0aWMgaW50IGZvcm1hdF9yZWdpc3Rlcl9zdHIoc3RydWN0IHNuZF9zb2NfY29kZWMgKmNvZGVjLAogCQkJICAgICAgIHVuc2lnbmVkIGludCByZWcsIGNoYXIgKmJ1Ziwgc2l6ZV90IGxlbikKIHsKLQlpbnQgd29yZHNpemUgPSBjb2RlYy0+ZHJpdmVyLT5yZWdfd29yZF9zaXplICogMjsKLQlpbnQgcmVnc2l6ZSA9IG1pbl9ieXRlc19uZWVkZWQoY29kZWMtPmRyaXZlci0+cmVnX2NhY2hlX3NpemUpICogMjsKKwlpbnQgd29yZHNpemUgPSBtaW5fYnl0ZXNfbmVlZGVkKGNvZGVjLT5kcml2ZXItPnJlZ19jYWNoZV9zaXplKSAqIDI7CisJaW50IHJlZ3NpemUgPSBjb2RlYy0+ZHJpdmVyLT5yZWdfd29yZF9zaXplICogMjsKIAlpbnQgcmV0OwogCWNoYXIgdG1wYnVmW2xlbiArIDFdOwogCWNoYXIgcmVnYnVmW3JlZ3NpemUgKyAxXTsKQEAgLTEzMiw4ICsxMzIsOCBAQAogCXNpemVfdCB0b3RhbCA9IDA7CiAJbG9mZl90IHAgPSAwOwogCi0Jd29yZHNpemUgPSBjb2RlYy0+ZHJpdmVyLT5yZWdfd29yZF9zaXplICogMjsKLQlyZWdzaXplID0gbWluX2J5dGVzX25lZWRlZChjb2RlYy0+ZHJpdmVyLT5yZWdfY2FjaGVfc2l6ZSkgKiAyOworCXdvcmRzaXplID0gbWluX2J5dGVzX25lZWRlZChjb2RlYy0+ZHJpdmVyLT5yZWdfY2FjaGVfc2l6ZSkgKiAyOworCXJlZ3NpemUgPSBjb2RlYy0+ZHJpdmVyLT5yZWdfd29yZF9zaXplICogMjsKIAogCWxlbiA9IHdvcmRzaXplICsgcmVnc2l6ZSArIDIgKyAxOwogCmRpZmYgLS1naXQgYS9zb3VuZC91c2IvNmZpcmUvZmlybXdhcmUuYyBiL3NvdW5kL3VzYi82ZmlyZS9maXJtd2FyZS5jCmluZGV4IDkwODFhNTQuLjg2YzFhMzEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3VzYi82ZmlyZS9maXJtd2FyZS5jCisrKyBiL3NvdW5kL3VzYi82ZmlyZS9maXJtd2FyZS5jCkBAIC03Niw3ICs3Niw3IEBACiAJdTE2IGFkZHJlc3M7CiAJdTggbGVuOwogCXU4IGRhdGFbMjU2XTsKLQljaGFyIGVycm9yOyAvKiB0cnVlIGlmIGFuIGVycm9yIG9jY3VyZWQgcGFyc2luZyB0aGlzIHJlY29yZCAqLworCWNoYXIgZXJyb3I7IC8qIHRydWUgaWYgYW4gZXJyb3Igb2NjdXJyZWQgcGFyc2luZyB0aGlzIHJlY29yZCAqLwogCiAJdTggbWF4X2xlbjsgLyogbWF4aW11bSByZWNvcmQgbGVuZ3RoIGluIHdob2xlIGloZXggKi8KIApAQCAtMTA3LDcgKzEwNyw3IEBACiAKIC8qCiAgKiByZXR1cm5zIHRydWUgaWYgcmVjb3JkIGlzIGF2YWlsYWJsZSwgZmFsc2Ugb3RoZXJ3aXNlLgotICogaWZmIGFuIGVycm9yIG9jY3VyZWQsIGZhbHNlIHdpbGwgYmUgcmV0dXJuZWQgYW5kIHJlY29yZC0+ZXJyb3Igd2lsbCBiZSB0cnVlLgorICogaWZmIGFuIGVycm9yIG9jY3VycmVkLCBmYWxzZSB3aWxsIGJlIHJldHVybmVkIGFuZCByZWNvcmQtPmVycm9yIHdpbGwgYmUgdHJ1ZS4KICAqLwogc3RhdGljIGJvb2wgdXNiNmZpcmVfZndfaWhleF9uZXh0X3JlY29yZChzdHJ1Y3QgaWhleF9yZWNvcmQgKnJlY29yZCkKIHsKZGlmZiAtLWdpdCBhL3NvdW5kL3VzYi9taWRpLmMgYi9zb3VuZC91c2IvbWlkaS5jCmluZGV4IGI0YjM5YzAuLmY5Mjg5MTAgMTAwNjQ0Ci0tLSBhL3NvdW5kL3VzYi9taWRpLmMKKysrIGIvc291bmQvdXNiL21pZGkuYwpAQCAtMTMwMSw2ICsxMzAxLDcgQEAKIAljYXNlIFVTQl9JRCgweDE1Y2EsIDB4MDEwMSk6IC8qIFRleHRlY2ggVVNCIE1pZGkgQ2FibGUgKi8KIAljYXNlIFVTQl9JRCgweDE1Y2EsIDB4MTgwNik6IC8qIFRleHRlY2ggVVNCIE1pZGkgQ2FibGUgKi8KIAljYXNlIFVTQl9JRCgweDFhODYsIDB4NzUyZCk6IC8qIFFpbkhlbmcgQ0gzNDUgIlVTQjIuMC1NSURJIiAqLworCWNhc2UgVVNCX0lEKDB4ZmMwOCwgMHgwMTAxKTogLyogVW5rbm93biB2ZW5kb3IgQ2FibGUgKi8KIAkJZXAtPm1heF90cmFuc2ZlciA9IDQ7CiAJCWJyZWFrOwogCQkvKgpkaWZmIC0tZ2l0IGEvc291bmQvdXNiL21peGVyLmMgYi9zb3VuZC91c2IvbWl4ZXIuYwppbmRleCA1ZTQ3NzU3Li42ZWMzM2I2IDEwMDY0NAotLS0gYS9zb3VuZC91c2IvbWl4ZXIuYworKysgYi9zb3VuZC91c2IvbWl4ZXIuYwpAQCAtMTE4Miw3ICsxMTgyLDcgQEAKIC8qCiAgKiBwYXJzZSBhIGZlYXR1cmUgdW5pdAogICoKLSAqIG1vc3Qgb2YgY29udHJvbGxzIGFyZSBkZWZpbmVkIGhlcmUuCisgKiBtb3N0IG9mIGNvbnRyb2xzIGFyZSBkZWZpbmVkIGhlcmUuCiAgKi8KIHN0YXRpYyBpbnQgcGFyc2VfYXVkaW9fZmVhdHVyZV91bml0KHN0cnVjdCBtaXhlcl9idWlsZCAqc3RhdGUsIGludCB1bml0aWQsIHZvaWQgKl9mdHIpCiB7CmRpZmYgLS1naXQgYS9zb3VuZC91c2IvcXVpcmtzLmMgYi9zb3VuZC91c2IvcXVpcmtzLmMKaW5kZXggMzU1NzU5Yi4uZWMwN2U2MiAxMDA2NDQKLS0tIGEvc291bmQvdXNiL3F1aXJrcy5jCisrKyBiL3NvdW5kL3VzYi9xdWlya3MuYwpAQCAtMjY2LDcgKzI2Niw3IEBACiAgKiBhdWRpby1pbnRlcmZhY2UgcXVpcmtzCiAgKgogICogcmV0dXJucyB6ZXJvIGlmIG5vIHN0YW5kYXJkIGF1ZGlvL01JREkgcGFyc2luZyBpcyBuZWVkZWQuCi0gKiByZXR1cm5zIGEgcG9zdGl2ZSB2YWx1ZSBpZiBzdGFuZGFyZCBhdWRpby9taWRpIGludGVyZmFjZXMgYXJlIHBhcnNlZAorICogcmV0dXJucyBhIHBvc2l0aXZlIHZhbHVlIGlmIHN0YW5kYXJkIGF1ZGlvL21pZGkgaW50ZXJmYWNlcyBhcmUgcGFyc2VkCiAgKiBhZnRlciB0aGlzLgogICogcmV0dXJucyBhIG5lZ2F0aXZlIHZhbHVlIGF0IGVycm9yLgogICovCmRpZmYgLS1naXQgYS9zb3VuZC91c2IvdXN4MnkvdXN4Mnlod2RlcHBjbS5jIGIvc291bmQvdXNiL3VzeDJ5L3VzeDJ5aHdkZXBwY20uYwppbmRleCAyODdlZjczLi5hNTEzNDBmIDEwMDY0NAotLS0gYS9zb3VuZC91c2IvdXN4MnkvdXN4Mnlod2RlcHBjbS5jCisrKyBiL3NvdW5kL3VzYi91c3gyeS91c3gyeWh3ZGVwcGNtLmMKQEAgLTIwLDcgKzIwLDcgQEAKICBhdCBzdGFuZGFyZCBzYW1wbGVyYXRlcywKICB3aGF0IGxlZCB0byB0aGlzIHBhcnQgb2YgdGhlIHVzeDJ5IG1vZHVsZTogCiAgSXQgcHJvdmlkZXMgdGhlIGFsc2Ega2VybmVsIGhhbGYgb2YgdGhlIHVzeDJ5LWFsc2EtamFjayBkcml2ZXIgcGFpci4KLSBUaGUgcGFpciB1c2VzIGEgaGFyZHdhcmUgZGVwZW5kYW50IGFsc2EtZGV2aWNlIGZvciBtbWFwZWQgcGNtIHRyYW5zcG9ydC4KKyBUaGUgcGFpciB1c2VzIGEgaGFyZHdhcmUgZGVwZW5kZW50IGFsc2EtZGV2aWNlIGZvciBtbWFwZWQgcGNtIHRyYW5zcG9ydC4KICBBZHZhbnRhZ2UgYWNoaWV2ZWQ6CiAgICAgICAgICBUaGUgdXNiX2hjIG1vdmVzIHBjbSBkYXRhIGZyb20vaW50byBtZW1vcnkgdmlhIERNQS4KICAgICAgICAgIFRoYXQgbWVtb3J5IGlzIG1tYXBlZCBieSBqYWNrJ3MgdXN4MnkgZHJpdmVyLgpAQCAtMzgsNyArMzgsNyBAQAogICAgICAgICAgMnBlcmlvZHMgd29ya3MgYnV0IGlzIHVzZWxlc3MgY2F1c2Ugb2YgY3JhY2tsaW5nKS4KIAogIFRoaXMgaXMgYSBmaXJzdCAicHJvb2Ygb2YgY29uY2VwdCIgaW1wbGVtZW50YXRpb24uCi0gTGF0ZXIsIGZ1bmN0aW9uYWxpdGllcyBzaG91bGQgbWlncmF0ZSB0byBtb3JlIGFwcm9wcmlhdGUgcGxhY2VzOgorIExhdGVyLCBmdW5jdGlvbmFsaXRpZXMgc2hvdWxkIG1pZ3JhdGUgdG8gbW9yZSBhcHByb3ByaWF0ZSBwbGFjZXM6CiAgVXNlcmxhbmQ6CiAgLSBUaGUgamFja2QgY291bGQgbW1hcCBpdHMgZmxvYXQtcGNtIGJ1ZmZlcnMgZGlyZWN0bHkgZnJvbSBhbHNhLWxpYi4KICAtIGFsc2EtbGliIGNvdWxkIHByb3ZpZGUgcG93ZXIgb2YgMiBwZXJpb2Qgc2l6ZWQgc2hhcGluZyBjb21iaW5lZCB3aXRoIGludC9mbG9hdApkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3Byb2JlLWV2ZW50LmMgYi90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYwppbmRleCA1ZGRlZTY2Li5mMDIyMzE2IDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYworKysgYi90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYwpAQCAtMjM0LDcgKzIzNCw2IEBACiAKIAkvKiBTZWFyY2hpbmcgdHJhY2UgZXZlbnRzIGNvcnJlc3BvbmRpbmcgdG8gcHJvYmUgZXZlbnQgKi8KIAludGV2cyA9IGZpbmRfcHJvYmVfdHJhY2VfZXZlbnRzKGZkLCBwZXYsIHRldnMsIG1heF90ZXZzKTsKLQljbG9zZShmZCk7CiAKIAlpZiAobnRldnMgPiAwKSB7CS8qIFN1Y2NlZWRlZCB0byBmaW5kIHRyYWNlIGV2ZW50cyAqLwogCQlwcl9kZWJ1ZygiZmluZCAlZCBwcm9iZV90cmFjZV9ldmVudHMuXG4iLCBudGV2cyk7CkBAIC0zODgsNyArMzg3LDYgQEAKIAl9CiAKIAlyZXQgPSBmaW5kX2xpbmVfcmFuZ2UoZmQsIGxyKTsKLQljbG9zZShmZCk7CiAJaWYgKHJldCA9PSAwKSB7CiAJCXByX3dhcm5pbmcoIlNwZWNpZmllZCBzb3VyY2UgbGluZSBpcyBub3QgZm91bmQuXG4iKTsKIAkJcmV0dXJuIC1FTk9FTlQ7CkBAIC01MTIsMTkgKzUxMCwxOCBAQAogCWlmIChyZXQgPCAwKQogCQlyZXR1cm4gcmV0OwogCi0JZmQgPSBvcGVuX3ZtbGludXgobW9kdWxlKTsKLQlpZiAoZmQgPCAwKSB7Ci0JCXByX3dhcm5pbmcoIkZhaWxlZCB0byBvcGVuIGRlYnVnIGluZm9ybWF0aW9uIGZpbGUuXG4iKTsKLQkJcmV0dXJuIGZkOwotCX0KLQogCXNldHVwX3BhZ2VyKCk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgbnBldnMgJiYgcmV0ID49IDA7IGkrKykKKwlmb3IgKGkgPSAwOyBpIDwgbnBldnMgJiYgcmV0ID49IDA7IGkrKykgeworCQlmZCA9IG9wZW5fdm1saW51eChtb2R1bGUpOworCQlpZiAoZmQgPCAwKSB7CisJCQlwcl93YXJuaW5nKCJGYWlsZWQgdG8gb3BlbiBkZWJ1ZyBpbmZvcm1hdGlvbiBmaWxlLlxuIik7CisJCQlyZXQgPSBmZDsKKwkJCWJyZWFrOworCQl9CiAJCXJldCA9IHNob3dfYXZhaWxhYmxlX3ZhcnNfYXQoZmQsICZwZXZzW2ldLCBtYXhfdmxzLCBfZmlsdGVyLAogCQkJCQkgICAgIGV4dGVybnMpOwotCi0JY2xvc2UoZmQpOworCX0KIAlyZXR1cm4gcmV0OwogfQogCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcHJvYmUtZmluZGVyLmMgYi90b29scy9wZXJmL3V0aWwvcHJvYmUtZmluZGVyLmMKaW5kZXggMTk0ZjllMi4uYjdjODVjZSAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3Byb2JlLWZpbmRlci5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1maW5kZXIuYwpAQCAtMjczLDYgKzI3MywyNSBAQAogCXJldHVybiBkd2FyZl9mb3Jtc3RyaW5nKCZhdHRyKTsKIH0KIAorLyogR2V0IGEgbGluZSBudW1iZXIgYW5kIGZpbGUgbmFtZSBmb3IgZ2l2ZW4gYWRkcmVzcyAqLworc3RhdGljIGludCBjdV9maW5kX2xpbmVpbmZvKER3YXJmX0RpZSAqY3VkaWUsIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCSAgICBjb25zdCBjaGFyICoqZm5hbWUsIGludCAqbGluZW5vKQoreworCUR3YXJmX0xpbmUgKmxpbmU7CisJRHdhcmZfQWRkciBsYWRkcjsKKworCWxpbmUgPSBkd2FyZl9nZXRzcmNfZGllKGN1ZGllLCAoRHdhcmZfQWRkcilhZGRyKTsKKwlpZiAobGluZSAmJiBkd2FyZl9saW5lYWRkcihsaW5lLCAmbGFkZHIpID09IDAgJiYKKwkgICAgYWRkciA9PSAodW5zaWduZWQgbG9uZylsYWRkciAmJiBkd2FyZl9saW5lbm8obGluZSwgbGluZW5vKSA9PSAwKSB7CisJCSpmbmFtZSA9IGR3YXJmX2xpbmVzcmMobGluZSwgTlVMTCwgTlVMTCk7CisJCWlmICghKmZuYW1lKQorCQkJLyogbGluZSBudW1iZXIgaXMgdXNlbGVzcyB3aXRob3V0IGZpbGVuYW1lICovCisJCQkqbGluZW5vID0gMDsKKwl9CisKKwlyZXR1cm4gKmxpbmVubyA/OiAtRU5PRU5UOworfQorCiAvKiBDb21wYXJlIGRpZW5hbWUgYW5kIHRuYW1lICovCiBzdGF0aWMgYm9vbCBkaWVfY29tcGFyZV9uYW1lKER3YXJmX0RpZSAqZHdfZGllLCBjb25zdCBjaGFyICp0bmFtZSkKIHsKQEAgLTQ5Nyw3ICs1MTYsMjAgQEAKIHN0YXRpYyBEd2FyZl9EaWUgKmRpZV9maW5kX2lubGluZWZ1bmMoRHdhcmZfRGllICpzcF9kaWUsIER3YXJmX0FkZHIgYWRkciwKIAkJCQkgICAgICBEd2FyZl9EaWUgKmRpZV9tZW0pCiB7Ci0JcmV0dXJuIGRpZV9maW5kX2NoaWxkKHNwX2RpZSwgX19kaWVfZmluZF9pbmxpbmVfY2IsICZhZGRyLCBkaWVfbWVtKTsKKwlEd2FyZl9EaWUgdG1wX2RpZTsKKworCXNwX2RpZSA9IGRpZV9maW5kX2NoaWxkKHNwX2RpZSwgX19kaWVfZmluZF9pbmxpbmVfY2IsICZhZGRyLCAmdG1wX2RpZSk7CisJaWYgKCFzcF9kaWUpCisJCXJldHVybiBOVUxMOworCisJLyogSW5saW5lZCBmdW5jdGlvbiBjb3VsZCBiZSByZWN1cnNpdmUuIFRyYWNlIGl0IHVudGlsIGZhaWwgKi8KKwl3aGlsZSAoc3BfZGllKSB7CisJCW1lbWNweShkaWVfbWVtLCBzcF9kaWUsIHNpemVvZihEd2FyZl9EaWUpKTsKKwkJc3BfZGllID0gZGllX2ZpbmRfY2hpbGQoc3BfZGllLCBfX2RpZV9maW5kX2lubGluZV9jYiwgJmFkZHIsCisJCQkJCSZ0bXBfZGllKTsKKwl9CisKKwlyZXR1cm4gZGllX21lbTsKIH0KIAogLyogV2Fsa2VyIG9uIGxpbmVzIChOb3RlOiBsaW5lIG51bWJlciB3aWxsIG5vdCBiZSBzb3J0ZWQpICovCkBAIC0xMzk1LDYgKzE0MjcsMTAgQEAKIAkgICAgIWRpZV9jb21wYXJlX25hbWUoc3BfZGllLCBwcC0+ZnVuY3Rpb24pKQogCQlyZXR1cm4gRFdBUkZfQ0JfT0s7CiAKKwkvKiBDaGVjayBkZWNsYXJlZCBmaWxlICovCisJaWYgKHBwLT5maWxlICYmIHN0cnRhaWxjbXAocHAtPmZpbGUsIGR3YXJmX2RlY2xfZmlsZShzcF9kaWUpKSkKKwkJcmV0dXJuIERXQVJGX0NCX09LOworCiAJcGYtPmZuYW1lID0gZHdhcmZfZGVjbF9maWxlKHNwX2RpZSk7CiAJaWYgKHBwLT5saW5lKSB7IC8qIEZ1bmN0aW9uIHJlbGF0aXZlIGxpbmUgKi8KIAkJZHdhcmZfZGVjbF9saW5lKHNwX2RpZSwgJnBmLT5sbm8pOwpAQCAtMTQ1MSw2ICsxNDg3LDcgQEAKIAlpZiAoIWRiZykgewogCQlwcl93YXJuaW5nKCJObyBkZWJ1ZyBpbmZvcm1hdGlvbiBmb3VuZCBpbiB0aGUgdm1saW51eCAtICIKIAkJCSJwbGVhc2UgcmVidWlsZCB3aXRoIENPTkZJR19ERUJVR19JTkZPPXkuXG4iKTsKKwkJY2xvc2UoZmQpOwkvKiBXaXRob3V0IGR3ZmxfZW5kKCksIGZkIGlzbid0IGNsb3NlZC4gKi8KIAkJcmV0dXJuIC1FQkFERjsKIAl9CiAKQEAgLTE2ODYsMTEgKzE3MjMsOSBAQAogCUR3YXJmX0RpZSBjdWRpZSwgc3BkaWUsIGluZGllOwogCUR3YXJmICpkYmcgPSBOVUxMOwogCUR3ZmwgKmR3ZmwgPSBOVUxMOwotCUR3YXJmX0xpbmUgKmxpbmU7Ci0JRHdhcmZfQWRkciBsYWRkciwgZWFkZHIsIGJpYXMgPSAwOwotCWNvbnN0IGNoYXIgKnRtcDsKLQlpbnQgbGluZW5vLCByZXQgPSAwOwotCWJvb2wgZm91bmQgPSBmYWxzZTsKKwlEd2FyZl9BZGRyIF9hZGRyLCBiYXNlYWRkciwgYmlhcyA9IDA7CisJY29uc3QgY2hhciAqZm5hbWUgPSBOVUxMLCAqZnVuYyA9IE5VTEwsICp0bXA7CisJaW50IGJhc2VsaW5lID0gMCwgbGluZW5vID0gMCwgcmV0ID0gMDsKIAogCS8qIE9wZW4gdGhlIGxpdmUgbGludXgga2VybmVsICovCiAJZGJnID0gZHdmbF9pbml0X2xpdmVfa2VybmVsX2R3YXJmKGFkZHIsICZkd2ZsLCAmYmlhcyk7CkBAIC0xNzExLDY4ICsxNzQ2LDc5IEBACiAJCWdvdG8gZW5kOwogCX0KIAotCS8qIEZpbmQgYSBjb3JyZXNwb25kaW5nIGxpbmUgKi8KLQlsaW5lID0gZHdhcmZfZ2V0c3JjX2RpZSgmY3VkaWUsIChEd2FyZl9BZGRyKWFkZHIpOwotCWlmIChsaW5lKSB7Ci0JCWlmIChkd2FyZl9saW5lYWRkcihsaW5lLCAmbGFkZHIpID09IDAgJiYKLQkJICAgIChEd2FyZl9BZGRyKWFkZHIgPT0gbGFkZHIgJiYKLQkJICAgIGR3YXJmX2xpbmVubyhsaW5lLCAmbGluZW5vKSA9PSAwKSB7Ci0JCQl0bXAgPSBkd2FyZl9saW5lc3JjKGxpbmUsIE5VTEwsIE5VTEwpOwotCQkJaWYgKHRtcCkgewotCQkJCXBwdC0+bGluZSA9IGxpbmVubzsKLQkJCQlwcHQtPmZpbGUgPSBzdHJkdXAodG1wKTsKLQkJCQlpZiAocHB0LT5maWxlID09IE5VTEwpIHsKLQkJCQkJcmV0ID0gLUVOT01FTTsKLQkJCQkJZ290byBlbmQ7Ci0JCQkJfQotCQkJCWZvdW5kID0gdHJ1ZTsKKwkvKiBGaW5kIGEgY29ycmVzcG9uZGluZyBsaW5lIChmaWxlbmFtZSBhbmQgbGluZW5vKSAqLworCWN1X2ZpbmRfbGluZWluZm8oJmN1ZGllLCBhZGRyLCAmZm5hbWUsICZsaW5lbm8pOworCS8qIERvbid0IGNhcmUgd2hldGhlciBpdCBmYWlsZWQgb3Igbm90ICovCisKKwkvKiBGaW5kIGEgY29ycmVzcG9uZGluZyBmdW5jdGlvbiAobmFtZSwgYmFzZWxpbmUgYW5kIGJhc2VhZGRyKSAqLworCWlmIChkaWVfZmluZF9yZWFsX3N1YnByb2dyYW0oJmN1ZGllLCAoRHdhcmZfQWRkcilhZGRyLCAmc3BkaWUpKSB7CisJCS8qIEdldCBmdW5jdGlvbiBlbnRyeSBpbmZvcm1hdGlvbiAqLworCQl0bXAgPSBkd2FyZl9kaWVuYW1lKCZzcGRpZSk7CisJCWlmICghdG1wIHx8CisJCSAgICBkd2FyZl9lbnRyeXBjKCZzcGRpZSwgJmJhc2VhZGRyKSAhPSAwIHx8CisJCSAgICBkd2FyZl9kZWNsX2xpbmUoJnNwZGllLCAmYmFzZWxpbmUpICE9IDApCisJCQlnb3RvIHBvc3Q7CisJCWZ1bmMgPSB0bXA7CisKKwkJaWYgKGFkZHIgPT0gKHVuc2lnbmVkIGxvbmcpYmFzZWFkZHIpCisJCQkvKiBGdW5jdGlvbiBlbnRyeSAtIFJlbGF0aXZlIGxpbmUgbnVtYmVyIGlzIDAgKi8KKwkJCWxpbmVubyA9IGJhc2VsaW5lOworCQllbHNlIGlmIChkaWVfZmluZF9pbmxpbmVmdW5jKCZzcGRpZSwgKER3YXJmX0FkZHIpYWRkciwKKwkJCQkJICAgICAmaW5kaWUpKSB7CisJCQlpZiAoZHdhcmZfZW50cnlwYygmaW5kaWUsICZfYWRkcikgPT0gMCAmJgorCQkJICAgIF9hZGRyID09IGFkZHIpCisJCQkJLyoKKwkJCQkgKiBhZGRyIGlzIGF0IGFuIGlubGluZSBmdW5jdGlvbiBlbnRyeS4KKwkJCQkgKiBJbiB0aGlzIGNhc2UsIGxpbmVubyBzaG91bGQgYmUgdGhlIGNhbGwtc2l0ZQorCQkJCSAqIGxpbmUgbnVtYmVyLgorCQkJCSAqLworCQkJCWxpbmVubyA9IGRpZV9nZXRfY2FsbF9saW5lbm8oJmluZGllKTsKKwkJCWVsc2UgeworCQkJCS8qCisJCQkJICogYWRkciBpcyBpbiBhbiBpbmxpbmUgZnVuY3Rpb24gYm9keS4KKwkJCQkgKiBTaW5jZSBsaW5lbm8gcG9pbnRzIG9uZSBvZiB0aGUgbGluZXMKKwkJCQkgKiBvZiB0aGUgaW5saW5lIGZ1bmN0aW9uLCBiYXNlbGluZSBzaG91bGQKKwkJCQkgKiBiZSB0aGUgZW50cnkgbGluZSBvZiB0aGUgaW5saW5lIGZ1bmN0aW9uLgorCQkJCSAqLworCQkJCXRtcCA9IGR3YXJmX2RpZW5hbWUoJmluZGllKTsKKwkJCQlpZiAodG1wICYmCisJCQkJICAgIGR3YXJmX2RlY2xfbGluZSgmc3BkaWUsICZiYXNlbGluZSkgPT0gMCkKKwkJCQkJZnVuYyA9IHRtcDsKIAkJCX0KIAkJfQogCX0KIAotCS8qIEZpbmQgYSBjb3JyZXNwb25kaW5nIGZ1bmN0aW9uICovCi0JaWYgKGRpZV9maW5kX3JlYWxfc3VicHJvZ3JhbSgmY3VkaWUsIChEd2FyZl9BZGRyKWFkZHIsICZzcGRpZSkpIHsKLQkJdG1wID0gZHdhcmZfZGllbmFtZSgmc3BkaWUpOwotCQlpZiAoIXRtcCB8fCBkd2FyZl9lbnRyeXBjKCZzcGRpZSwgJmVhZGRyKSAhPSAwKQotCQkJZ290byBlbmQ7Citwb3N0OgorCS8qIE1ha2UgYSByZWxhdGl2ZSBsaW5lIG51bWJlciBvciBhbiBvZmZzZXQgKi8KKwlpZiAobGluZW5vKQorCQlwcHQtPmxpbmUgPSBsaW5lbm8gLSBiYXNlbGluZTsKKwllbHNlIGlmIChmdW5jKQorCQlwcHQtPm9mZnNldCA9IGFkZHIgLSAodW5zaWduZWQgbG9uZyliYXNlYWRkcjsKIAotCQlpZiAocHB0LT5saW5lKSB7Ci0JCQlpZiAoZGllX2ZpbmRfaW5saW5lZnVuYygmc3BkaWUsIChEd2FyZl9BZGRyKWFkZHIsCi0JCQkJCQkmaW5kaWUpKSB7Ci0JCQkJLyogYWRkciBpbiBhbiBpbmxpbmUgZnVuY3Rpb24gKi8KLQkJCQl0bXAgPSBkd2FyZl9kaWVuYW1lKCZpbmRpZSk7Ci0JCQkJaWYgKCF0bXApCi0JCQkJCWdvdG8gZW5kOwotCQkJCXJldCA9IGR3YXJmX2RlY2xfbGluZSgmaW5kaWUsICZsaW5lbm8pOwotCQkJfSBlbHNlIHsKLQkJCQlpZiAoZWFkZHIgPT0gYWRkcikgewkvKiBGdW5jdGlvbiBlbnRyeSAqLwotCQkJCQlsaW5lbm8gPSBwcHQtPmxpbmU7Ci0JCQkJCXJldCA9IDA7Ci0JCQkJfSBlbHNlCi0JCQkJCXJldCA9IGR3YXJmX2RlY2xfbGluZSgmc3BkaWUsICZsaW5lbm8pOwotCQkJfQotCQkJaWYgKHJldCA9PSAwKSB7Ci0JCQkJLyogTWFrZSBhIHJlbGF0aXZlIGxpbmUgbnVtYmVyICovCi0JCQkJcHB0LT5saW5lIC09IGxpbmVubzsKLQkJCQlnb3RvIGZvdW5kOwotCQkJfQotCQl9Ci0JCS8qIFdlIGRvbid0IGhhdmUgYSBsaW5lIG51bWJlciwgbGV0J3MgdXNlIG9mZnNldCAqLwotCQlwcHQtPm9mZnNldCA9IGFkZHIgLSAodW5zaWduZWQgbG9uZyllYWRkcjsKLWZvdW5kOgotCQlwcHQtPmZ1bmN0aW9uID0gc3RyZHVwKHRtcCk7CisJLyogRHVwbGljYXRlIHN0cmluZ3MgKi8KKwlpZiAoZnVuYykgeworCQlwcHQtPmZ1bmN0aW9uID0gc3RyZHVwKGZ1bmMpOwogCQlpZiAocHB0LT5mdW5jdGlvbiA9PSBOVUxMKSB7CiAJCQlyZXQgPSAtRU5PTUVNOwogCQkJZ290byBlbmQ7CiAJCX0KLQkJZm91bmQgPSB0cnVlOwogCX0KLQorCWlmIChmbmFtZSkgeworCQlwcHQtPmZpbGUgPSBzdHJkdXAoZm5hbWUpOworCQlpZiAocHB0LT5maWxlID09IE5VTEwpIHsKKwkJCWlmIChwcHQtPmZ1bmN0aW9uKSB7CisJCQkJZnJlZShwcHQtPmZ1bmN0aW9uKTsKKwkJCQlwcHQtPmZ1bmN0aW9uID0gTlVMTDsKKwkJCX0KKwkJCXJldCA9IC1FTk9NRU07CisJCQlnb3RvIGVuZDsKKwkJfQorCX0KIGVuZDoKIAlpZiAoZHdmbCkKIAkJZHdmbF9lbmQoZHdmbCk7Ci0JaWYgKHJldCA+PSAwKQotCQlyZXQgPSBmb3VuZCA/IDEgOiAwOworCWlmIChyZXQgPT0gMCAmJiAoZm5hbWUgfHwgZnVuYykpCisJCXJldCA9IDE7CS8qIEZvdW5kIGEgcG9pbnQgKi8KIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xODQwLDYgKzE4ODYsMTAgQEAKIAlzdHJ1Y3QgbGluZV9maW5kZXIgKmxmID0gcGFyYW0tPmRhdGE7CiAJc3RydWN0IGxpbmVfcmFuZ2UgKmxyID0gbGYtPmxyOwogCisJLyogQ2hlY2sgZGVjbGFyZWQgZmlsZSAqLworCWlmIChsci0+ZmlsZSAmJiBzdHJ0YWlsY21wKGxyLT5maWxlLCBkd2FyZl9kZWNsX2ZpbGUoc3BfZGllKSkpCisJCXJldHVybiBEV0FSRl9DQl9PSzsKKwogCWlmIChkd2FyZl90YWcoc3BfZGllKSA9PSBEV19UQUdfc3VicHJvZ3JhbSAmJgogCSAgICBkaWVfY29tcGFyZV9uYW1lKHNwX2RpZSwgbHItPmZ1bmN0aW9uKSkgewogCQlsZi0+Zm5hbWUgPSBkd2FyZl9kZWNsX2ZpbGUoc3BfZGllKTsKQEAgLTE4OTIsNiArMTk0Miw3IEBACiAJaWYgKCFkYmcpIHsKIAkJcHJfd2FybmluZygiTm8gZGVidWcgaW5mb3JtYXRpb24gZm91bmQgaW4gdGhlIHZtbGludXggLSAiCiAJCQkicGxlYXNlIHJlYnVpbGQgd2l0aCBDT05GSUdfREVCVUdfSU5GTz15LlxuIik7CisJCWNsb3NlKGZkKTsJLyogV2l0aG91dCBkd2ZsX2VuZCgpLCBmZCBpc24ndCBjbG9zZWQuICovCiAJCXJldHVybiAtRUJBREY7CiAJfQogCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvc3RyaW5nLmMgYi90b29scy9wZXJmL3V0aWwvc3RyaW5nLmMKaW5kZXggOGZjMGJkMy4uYjlhOTg1ZCAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3N0cmluZy5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9zdHJpbmcuYwpAQCAtODUsNyArODUsNyBAQAogCiAvKgogICogSGVscGVyIGZ1bmN0aW9uIGZvciBzcGxpdHRpbmcgYSBzdHJpbmcgaW50byBhbiBhcmd2LWxpa2UgYXJyYXkuCi0gKiBvcmlnaW5hbHkgY29waWVkIGZyb20gbGliL2FyZ3Zfc3BsaXQuYworICogb3JpZ2luYWxseSBjb3BpZWQgZnJvbSBsaWIvYXJndl9zcGxpdC5jCiAgKi8KIHN0YXRpYyBjb25zdCBjaGFyICpza2lwX3NlcChjb25zdCBjaGFyICpjcCkKIHsKZGlmZiAtLWdpdCBhL3Rvb2xzL3Bvd2VyL3g4Ni94ODZfZW5lcmd5X3BlcmZfcG9saWN5L3g4Nl9lbmVyZ3lfcGVyZl9wb2xpY3kuYyBiL3Rvb2xzL3Bvd2VyL3g4Ni94ODZfZW5lcmd5X3BlcmZfcG9saWN5L3g4Nl9lbmVyZ3lfcGVyZl9wb2xpY3kuYwppbmRleCBkOTY3OGEzLi4yNjE4ZWYyIDEwMDY0NAotLS0gYS90b29scy9wb3dlci94ODYveDg2X2VuZXJneV9wZXJmX3BvbGljeS94ODZfZW5lcmd5X3BlcmZfcG9saWN5LmMKKysrIGIvdG9vbHMvcG93ZXIveDg2L3g4Nl9lbmVyZ3lfcGVyZl9wb2xpY3kveDg2X2VuZXJneV9wZXJmX3BvbGljeS5jCkBAIC00Niw3ICs0Niw3IEBACiAgKgogICogIHBlcmZvcm1hbmNlCiAgKglQZXJmb3JtYW5jZSBpcyBwYXJhbW91bnQuCi0gKglVbndpbGxpbmcgdG8gc2FjcmFmaWNlIGFueSBwZXJmb3JtYW5jZQorICoJVW53aWxsaW5nIHRvIHNhY3JpZmljZSBhbnkgcGVyZm9ybWFuY2UKICAqCWZvciB0aGUgc2FrZSBvZiBlbmVyZ3kgc2F2aW5nLiAoaGFyZHdhcmUgZGVmYXVsdCkKICAqCiAgKiAgbm9ybWFsCmRpZmYgLS1naXQgYS92aXJ0L2t2bS9ldmVudGZkLmMgYi92aXJ0L2t2bS9ldmVudGZkLmMKaW5kZXggMzY1Njg0OS4uNzMzNThkMiAxMDA2NDQKLS0tIGEvdmlydC9rdm0vZXZlbnRmZC5jCisrKyBiL3ZpcnQva3ZtL2V2ZW50ZmQuYwpAQCAtOTAsNyArOTAsNyBAQAogCSAqIFdlIGtub3cgbm8gbmV3IGV2ZW50cyB3aWxsIGJlIHNjaGVkdWxlZCBhdCB0aGlzIHBvaW50LCBzbyBibG9jawogCSAqIHVudGlsIGFsbCBwcmV2aW91c2x5IG91dHN0YW5kaW5nIGV2ZW50cyBoYXZlIGNvbXBsZXRlZAogCSAqLwotCWZsdXNoX3dvcmsoJmlycWZkLT5pbmplY3QpOworCWZsdXNoX3dvcmtfc3luYygmaXJxZmQtPmluamVjdCk7CiAKIAkvKgogCSAqIEl0IGlzIG5vdyBzYWZlIHRvIHJlbGVhc2UgdGhlIG9iamVjdCdzIHJlc291cmNlcwpAQCAtNTc4LDcgKzU3OCw3IEBACiAKIAltdXRleF9sb2NrKCZrdm0tPnNsb3RzX2xvY2spOwogCi0JLyogVmVyaWZ5IHRoYXQgdGhlcmUgaXNudCBhIG1hdGNoIGFscmVhZHkgKi8KKwkvKiBWZXJpZnkgdGhhdCB0aGVyZSBpc24ndCBhIG1hdGNoIGFscmVhZHkgKi8KIAlpZiAoaW9ldmVudGZkX2NoZWNrX2NvbGxpc2lvbihrdm0sIHApKSB7CiAJCXJldCA9IC1FRVhJU1Q7CiAJCWdvdG8gdW5sb2NrX2ZhaWw7CmRpZmYgLS1naXQgYS92aXJ0L2t2bS9rdm1fbWFpbi5jIGIvdmlydC9rdm0va3ZtX21haW4uYwppbmRleCA1NTZlM2VmLi42MzMwNjUzIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9rdm1fbWFpbi5jCisrKyBiL3ZpcnQva3ZtL2t2bV9tYWluLmMKQEAgLTEwMzcsNiArMTAzNywxNyBAQAogCXJldHVybiBmYXVsdF9wZm47CiB9CiAKK2ludCBnZXRfdXNlcl9wYWdlX25vd2FpdChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywgc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJdW5zaWduZWQgbG9uZyBzdGFydCwgaW50IHdyaXRlLCBzdHJ1Y3QgcGFnZSAqKnBhZ2UpCit7CisJaW50IGZsYWdzID0gRk9MTF9UT1VDSCB8IEZPTExfTk9XQUlUIHwgRk9MTF9IV1BPSVNPTiB8IEZPTExfR0VUOworCisJaWYgKHdyaXRlKQorCQlmbGFncyB8PSBGT0xMX1dSSVRFOworCisJcmV0dXJuIF9fZ2V0X3VzZXJfcGFnZXModHNrLCBtbSwgc3RhcnQsIDEsIGZsYWdzLCBwYWdlLCBOVUxMLCBOVUxMKTsKK30KKwogc3RhdGljIGlubGluZSBpbnQgY2hlY2tfdXNlcl9wYWdlX2h3cG9pc29uKHVuc2lnbmVkIGxvbmcgYWRkcikKIHsKIAlpbnQgcmMsIGZsYWdzID0gRk9MTF9UT1VDSCB8IEZPTExfSFdQT0lTT04gfCBGT0xMX1dSSVRFOwpAQCAtMTA3MCw3ICsxMDgxLDE0IEBACiAJCWlmICh3cml0YWJsZSkKIAkJCSp3cml0YWJsZSA9IHdyaXRlX2ZhdWx0OwogCi0JCW5wYWdlcyA9IGdldF91c2VyX3BhZ2VzX2Zhc3QoYWRkciwgMSwgd3JpdGVfZmF1bHQsIHBhZ2UpOworCQlpZiAoYXN5bmMpIHsKKwkJCWRvd25fcmVhZCgmY3VycmVudC0+bW0tPm1tYXBfc2VtKTsKKwkJCW5wYWdlcyA9IGdldF91c2VyX3BhZ2Vfbm93YWl0KGN1cnJlbnQsIGN1cnJlbnQtPm1tLAorCQkJCQkJICAgICBhZGRyLCB3cml0ZV9mYXVsdCwgcGFnZSk7CisJCQl1cF9yZWFkKCZjdXJyZW50LT5tbS0+bW1hcF9zZW0pOworCQl9IGVsc2UKKwkJCW5wYWdlcyA9IGdldF91c2VyX3BhZ2VzX2Zhc3QoYWRkciwgMSwgd3JpdGVfZmF1bHQsCisJCQkJCQkgICAgIHBhZ2UpOwogCiAJCS8qIG1hcCByZWFkIGZhdWx0IGFzIHdyaXRhYmxlIGlmIHBvc3NpYmxlICovCiAJCWlmICh1bmxpa2VseSghd3JpdGVfZmF1bHQpICYmIG5wYWdlcyA9PSAxKSB7CkBAIC0xMDkzLDcgKzExMTEsOCBAQAogCQkJcmV0dXJuIGdldF9mYXVsdF9wZm4oKTsKIAogCQlkb3duX3JlYWQoJmN1cnJlbnQtPm1tLT5tbWFwX3NlbSk7Ci0JCWlmIChjaGVja191c2VyX3BhZ2VfaHdwb2lzb24oYWRkcikpIHsKKwkJaWYgKG5wYWdlcyA9PSAtRUhXUE9JU09OIHx8CisJCQkoIWFzeW5jICYmIGNoZWNrX3VzZXJfcGFnZV9od3BvaXNvbihhZGRyKSkpIHsKIAkJCXVwX3JlYWQoJmN1cnJlbnQtPm1tLT5tbWFwX3NlbSk7CiAJCQlnZXRfcGFnZShod3BvaXNvbl9wYWdlKTsKIAkJCXJldHVybiBwYWdlX3RvX3Bmbihod3BvaXNvbl9wYWdlKTsK