LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQovKioqKioqKioqKioqKioqKioqKioqKioqKiBGaWxlIERlc2NyaXB0aW9uICoqKioqKioqKioqKioqKioqKioqKioqKi8NCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KLyogRmlsZSBOYW1lOgkJJFdvcmtmaWxlOiAgIGhteF91cHJhZGVfc3lzdGVtLmMgICQNCiAqIFZlcnNpb246CQkJJFJldmlzaW9uOiAgIDEuMCAgJA0KICogT3JpZ2luYWwgQXV0aG9yOgkJWWFuZyBIeXVuIFVrICQNCiAqIEN1cnJlbnQgQXV0aG9yOgkkQXV0aG9yOiBodXlhbmdAaHVtYXhkaWdpdGFsLmNvbSAkDQogKiBEYXRlOgkJCSREYXRlOiAyMDExLjA5LjMwDQogKiBGaWxlIERlc2NyaXB0aW9uOglIdW1heCBVcGdyYWRlIEFQSXMNCiAqIE1vZHVsZToNCiAqIFJlbWFya3M6DQogKi8NCg0KLyoqDQogKiBAZGVmZ3JvdXAgVVBHUkFERV9TWVNURU0gU3lzdGVtIEFQSXMgZm9yIFVwZ3JhZGUgTW9kdWxlDQogKiBAaW5ncm91cCBVUEdSQURFDQogKi8NCg0KLyoqDQogKiBAYXV0aG9yIEh5dW51ayBZYW5nKGh1eWFuZ0BodW1heGRpZ2l0YWwuY29tKQ0KICogQGRhdGUgMzAgU2VwdCAyMDExDQogKi8NCg0KLyoqDQogKiBAbm90ZQ0KICogQ29weXJpZ2h0IChDKSAyMDExIEh1bWF4IENvcnBvcmF0aW9uLiBBbGwgUmlnaHRzIFJlc2VydmVkLiA8YnI+DQogKiBUaGlzIHNvZnR3YXJlIGlzIHRoZSBjb25maWRlbnRpYWwgYW5kIHByb3ByaWV0YXJ5IGluZm9ybWF0aW9uDQogKiBvZiBIdW1heCBDb3Jwb3JhdGlvbi4gWW91IG1heSBub3QgdXNlIG9yIGRpc3RyaWJ1dGUgdGhpcyBzb2Z0d2FyZQ0KICogZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgYW55IGFwcGxpY2FibGUgbGljZW5zZQ0KICogYWdyZWVtZW50IGluIHdyaXRpbmcgYmV0d2VlbiBIdW1heCBDb3Jwb3JhdGlvbiBhbmQgeW91Lg0KICovDQoNCiAvKkB7Ki8NCg0KLyoqDQogKiBAZmlsZSBobXhfdXBncmFkZV9zeXN0ZW0uYw0KICovDQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKiogSGVhZGVyIEZpbGVzICoqKioqKioqKioqKioqKioqKioqKioqKiovDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCi8qIFN0YXJ0IEluY2x1ZGluZyBIZWFkZXIgRmlsZXMgKi8NCiNpbmNsdWRlICJobXhfdXBncmFkZV9zeXN0ZW0uaCINCi8qIEVuZCBJbmNsdWRpbmcgSGVhZGVycyAqLw0KDQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiBkZWZpbmUgKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCg0KI2lmZGVmIFRBU0tfREVCVUcNCiNkZWZpbmUgUHJpbnREZWJ1ZyhmbXQsIC4uLikgCQlwcmludGYgKGZtdCwgIyMgX19WQV9BUkdTX18pDQojZGVmaW5lIFByaW50RXJyb3IoZm10LCAuLi4pICAgIAlwcmludGYgKGZtdCwgIyMgX19WQV9BUkdTX18pDQojZGVmaW5lIFByaW50RW50ZXIoLi4uKQkJCXByaW50ZigiKCspJXNcbiIsIF9fRlVOQ1RJT05fXykNCiNkZWZpbmUgUHJpbnRFeGl0KC4uLikJCQkJcHJpbnRmKCIoLSklc1xuIiwgX19GVU5DVElPTl9fKQ0KI2Vsc2UNCiNkZWZpbmUgUHJpbnREZWJ1ZyhmbXQsIC4uLikgICAgCXdoaWxlICgwKSAoKGludCAoKikoY2hhciAqLCAuLi4pKSAwKQ0KI2RlZmluZSBQcmludEVycm9yKGZtdCwgLi4uKQkJcHJpbnRmIChmbXQsICMjIF9fVkFfQVJHU19fKQ0KI2RlZmluZSBQcmludEVudGVyKC4uLikgCQkJd2hpbGUgKDApICgoaW50ICgqKShjaGFyICosIC4uLikpIDApDQojZGVmaW5lIFByaW50RXhpdCguLi4pCQkJCXdoaWxlICgwKSAoKGludCAoKikoY2hhciAqLCAuLi4pKSAwKQ0KI2VuZGlmDQoNCg0KI2RlZmluZSBsaXN0X3NpemUobGlzdCkgKChsaXN0KS0+Y3Vycl9tc2dfY291bnRfKQ0KDQojZGVmaW5lIGxpc3RfYml0bWFwX3NpemUobGlzdCwgaSkgKChsaXN0KS0+Yml0bWFwX2NvdW50WyhpKV0pDQoNCiNkZWZpbmUgbGlzdF9oZWFkKGxpc3QsIGkpICgobGlzdCktPmhlYWRbaV0pDQoNCiNkZWZpbmUgbGlzdF90YWlsKGxpc3QsIGkpICgobGlzdCktPnRhaWxbaV0pDQoNCiNkZWZpbmUgbGlzdF9pc19oZWFkKGxpc3QsIGVsZW1lbnQpICgoZWxlbWVudCkgPT0gKGxpc3QpLT5oZWFkID8gMSA6IDApDQoNCiNkZWZpbmUgbGlzdF9pc190YWlsKGVsZW1lbnQpICgoZWxlbWVudCktPm5leHQgPT0gTlVMTCA/IDEgOiAwKQ0KDQojZGVmaW5lIGxpc3RfZGF0YShlbGVtZW50KSAoKGVsZW1lbnQpLT5kYXRhKQ0KDQojZGVmaW5lIGxpc3RfbmV4dChlbGVtZW50KSAoKGVsZW1lbnQpLT5uZXh0KQ0KDQojZGVmaW5lIEhBUFBZKGEpICh2b2lkKShhKQ0KDQovKiBFbmQgI2RlZmluZSAqLw0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKiogdHlwZWRlZiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQovKiBTdGFydCB0eXBlZGVmICovDQovKiBFbmQgdHlwZWRlZiAqLw0KDQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KLyoqKioqKioqKioqKioqKioqKioqKioqKiBnbG9iYWwgdmFyaWFibGVzICoqKioqKioqKioqKioqKioqKioqKioqKiovDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCi8qIFN0YXJ0IGdsb2JhbCB2YXJpYWJsZSAqLw0KDQovKiBFbmQgZ2xvYmFsIHZhcmlhYmxlICovDQoNCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQovKioqKioqKioqKioqKioqKioqKioqKioqIHN0YXRpYyB2YXJpYWJsZXMgKioqKioqKioqKioqKioqKioqKioqKioqKi8NCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KLyogU3RhcnQgc3RhdGljIHZhcmlhYmxlICovDQovKiBFbmQgc3RhdGljIHZhcmlhYmxlICovDQoNCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQovKioqKioqKioqKioqKioqKioqKioqKioqIHN0YXRpYyBmdW50aW9ucyAqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KDQpzdGF0aWMgaW50IFBfTVNHX0NoZWNrKHN0cnVjdCBITVhfTVNHX3F1ZXVlICpxLCB1bnNpZ25lZCBsb25nIHFfaWQpOw0KDQoNCi8qDQogICAgbGlzdF9maW5kX2hpZ2hlc3RfcHJpb3JpdHlfYml0bWFwDQogICAgYml0bWFwv6G8rSCwocDlILP0wLogv+y8sbz4wKe4piDDo7TCtNkuDQoqLw0KdW5zaWduZWQgbG9uZyBsaXN0X2ZpbmRfaGlnaGVzdF9wcmlvcml0eV9iaXRtYXAoc3RydWN0IEhNWF9NU0dfcXVldWUgKmxpc3QpDQp7DQogICAgaW50IGk7DQoNCiAgICBmb3IoaT1NU0dfUFJJT1JJVFlfTUFYLTE7IGk+PTA7IGktLSkNCiAgICB7DQogICAgICAgIGlmKGxpc3QtPmJpdG1hcFtpXSA9PSAxKQ0KICAgICAgICAgICAgcmV0dXJuIGk7DQogICAgfQ0KDQogICAgcmV0dXJuIDA7DQp9DQoNCg0KDQovKg0KICAgIHByaW50X2xpc3QNCiAgICBITVhfTVNHX3F1ZXVlILG4wbbDvCDA/MO8uKYgUHJpbnTH0bTZLg0KKi8NCnZvaWQgcHJpbnRfbGlzdChjb25zdCBzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqbGlzdCkNCnsNCiAgICBzdHJ1Y3QgSE1YX01TR19lbGVtZW50ICAgICAgICAgICAqZWxlbWVudDsNCiAgICBpbnQgICAgICAgICAgICAgICAgKmRhdGEsIGksIGNvdW50Ow0KDQogICAgZnByaW50ZihzdGRvdXQsICJNc2cgUXVldWUgQ3VycmVudCB0b3RhbCBzaXplIGlzICVsZFxuIiwgbGlzdF9zaXplKGxpc3QpKTsNCg0KICAgIGZvcihjb3VudD0wOyBjb3VudDxNU0dfUFJJT1JJVFlfTUFYOyBjb3VudCsrKQ0KICAgIHsNCiAgICAgICAgaSA9IDA7DQoNCiAgICAgICAgaWYoIGxpc3QtPmJpdG1hcFtjb3VudF0gIT0gMCkNCiAgICAgICAgew0KICAgICAgICAgICAgZWxlbWVudCA9IGxpc3RfaGVhZChsaXN0LCBjb3VudCk7DQoNCiAgICAgICAgICAgIHdoaWxlICgxKQ0KICAgICAgICAgICAgew0KICAgICAgICAgICAgICAgZGF0YSA9IGxpc3RfZGF0YShlbGVtZW50KTsNCiAgICAgICAgICAgICAgIGZwcmludGYoc3Rkb3V0LCAicHJpb3JpdHlbJWRdIDogcWxpc3RbJTAzZF09JTAzZFxuIiwgY291bnQsIGksICpkYXRhKTsNCg0KICAgICAgICAgICAgICAgaSsrOw0KDQogICAgICAgICAgICAgICBpZiAobGlzdF9pc190YWlsKGVsZW1lbnQpKQ0KICAgICAgICAgICAgICAgICAgYnJlYWs7DQogICAgICAgICAgICAgICBlbHNlDQogICAgICAgICAgICAgICAgICBlbGVtZW50ID0gbGlzdF9uZXh0KGVsZW1lbnQpOw0KICAgICAgICAgICAgfQ0KICAgICAgICB9DQogICAgfQ0KfQ0KDQoNCg0KLyoNCiAgICBsaXN0X3NldF9iaXRtYXANCiAgICC/7LyxvPjAp7+hIMfYtOfHz7TCILrxxq64ysC7IHNldCDH0bTZLg0KKi8NCnZvaWQgbGlzdF9zZXRfYml0bWFwKHN0cnVjdCBITVhfTVNHX3F1ZXVlICpsaXN0LCB1bnNpZ25lZCBsb25nIHByaW8pDQp7DQogICAgbGlzdC0+Yml0bWFwW3ByaW9dID0gMTsNCn0NCg0KDQoNCi8qDQogICAgbGlzdF9jbGVhcl9iaXRtYXANCiAgICC/7LyxvPjAp7+hIMfYtOfHz7TCILrxxq64ysC7IGNsZWFyIMfRtNkuDQoqLw0Kdm9pZCBsaXN0X2NsZWFyX2JpdG1hcChzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqbGlzdCwgdW5zaWduZWQgbG9uZyBwcmlvKQ0Kew0KICAgIGxpc3QtPmJpdG1hcFtwcmlvXSA9IDA7DQp9DQoNCg0KDQoNCg0KDQoNCi8qDQogICAgbGlzdF9iaXRtYXBfY291bnRfaW5jcmVhc2UNCiAgICDH2LTnx8+0wiC/7LyxvPjAp8DHIGJpdG1hcCBDb3VudLimIMH1sKEgvcPFsrTZLg0KKi8NCnZvaWQgbGlzdF9iaXRtYXBfY291bnRfaW5jcmVhc2Uoc3RydWN0IEhNWF9NU0dfcXVldWUgKmxpc3QsIHVuc2lnbmVkIGxvbmcgcHJpbykNCnsNCiAgICBsaXN0LT5iaXRtYXBfY291bnRbcHJpb10rKzsNCn0NCg0KDQoNCi8qDQogICAgbGlzdF9iaXRtYXBfY291bnRfZGVjcmVhc2UNCiAgICDH2LTnx8+0wiC/7LyxvPjAp8DHIGJpdG1hcCBDb3VudLimILCovNIgvcPFsrTZLg0KKi8NCnZvaWQgbGlzdF9iaXRtYXBfY291bnRfZGVjcmVhc2Uoc3RydWN0IEhNWF9NU0dfcXVldWUgKmxpc3QsIHVuc2lnbmVkIGxvbmcgcHJpbykNCnsNCiAgICBsaXN0LT5iaXRtYXBfY291bnRbcHJpb10tLTsNCn0NCg0KDQovKg0KICAgIGxpc3RfbWFwcGluZ190YXNrX3ByaW9yaXR5X3RvX21zZ3ENCiAgICDFwr26xakgv+y8sbz4wKe4piCx4sHYwLi3ziC43ry8wfbFpSC/7LyxvPjAp7imILDhwaTH0bTZLg0KKi8NCmludCBsaXN0X2ZpbmRfbXNnX3FfcHJpb3JpdHlfZnJvbV90YXNrX3ByaW9yaXR5KHVuc2lnbmVkIGxvbmcgKnByaW8pDQp7DQogICAgc3RydWN0IHNjaGVkX3BhcmFtCXBhcmFtOw0KICAgIGludCBwb2xpY3kgPSAwOw0KICAgIGludCByYzsNCg0KICAgIHJjID0gcHRocmVhZF9nZXRzY2hlZHBhcmFtKCBwdGhyZWFkX3NlbGYoKSwgJnBvbGljeSwgJnBhcmFtKTsNCiAgICBpZihyYyAhPSBITVhfT0spDQogICAgew0KCQkqcHJpbyA9IE1TR19QUklPUklUWTA7DQoJCXJldHVybiBITVhfT0s7DQogICAgfQ0KICAgIFByaW50RGVidWcoInBvbGljeSA9ICVkXG4iLCBwb2xpY3kpOw0KICAgIFByaW50RGVidWcoInBhcmFtLnNjaGVkX3ByaW9yaXR5ID0gJWRcbiIsIHBhcmFtLnNjaGVkX3ByaW9yaXR5KTsNCg0KICAgIHN3aXRjaChwYXJhbS5zY2hlZF9wcmlvcml0eSkNCiAgICB7DQogICAgICAgIGNhc2UgVVNFUl9QUklPUklUWTA6DQogICAgICAgICAgICAqcHJpbyA9IE1TR19QUklPUklUWTA7DQogICAgICAgICAgICBicmVhazsNCiAgICAgICAgY2FzZSBVU0VSX1BSSU9SSVRZMToNCiAgICAgICAgICAgICpwcmlvID0gTVNHX1BSSU9SSVRZMTsNCiAgICAgICAgICAgIGJyZWFrOw0KICAgICAgICBjYXNlIFVTRVJfUFJJT1JJVFkyOg0KICAgICAgICAgICAgKnByaW8gPSBNU0dfUFJJT1JJVFkyOw0KICAgICAgICAgICAgYnJlYWs7DQogICAgICAgIGNhc2UgVVNFUl9QUklPUklUWTM6DQogICAgICAgICAgICAqcHJpbyA9IE1TR19QUklPUklUWTM7DQogICAgICAgICAgICBicmVhazsNCiAgICAgICAgY2FzZSBVU0VSX1BSSU9SSVRZNDoNCiAgICAgICAgICAgICpwcmlvID0gTVNHX1BSSU9SSVRZNDsNCiAgICAgICAgICAgIGJyZWFrOw0KICAgICAgICBjYXNlIFVTRVJfUFJJT1JJVFk1Og0KICAgICAgICAgICAgKnByaW8gPSBNU0dfUFJJT1JJVFk1Ow0KICAgICAgICAgICAgYnJlYWs7DQogICAgICAgIGNhc2UgVVNFUl9QUklPUklUWTY6DQogICAgICAgICAgICAqcHJpbyA9IE1TR19QUklPUklUWTY7DQogICAgICAgICAgICBicmVhazsNCiAgICAgICAgY2FzZSBVU0VSX1BSSU9SSVRZNzoNCiAgICAgICAgICAgICpwcmlvID0gTVNHX1BSSU9SSVRZNzsNCiAgICAgICAgICAgIGJyZWFrOw0KICAgICAgICBjYXNlIFVTRVJfUFJJT1JJVFk4Og0KICAgICAgICAgICAgKnByaW8gPSBNU0dfUFJJT1JJVFk4Ow0KICAgICAgICAgICAgYnJlYWs7DQogICAgICAgIGNhc2UgVVNFUl9QUklPUklUWTk6DQogICAgICAgICAgICAqcHJpbyA9IE1TR19QUklPUklUWTk7DQogICAgICAgICAgICBicmVhazsNCiAgICAgICAgY2FzZSBVU0VSX1BSSU9SSVRZMTA6DQogICAgICAgICAgICAqcHJpbyA9IE1TR19QUklPUklUWTEwOw0KICAgICAgICAgICAgYnJlYWs7DQogICAgICAgIGNhc2UgVVNFUl9QUklPUklUWTExOg0KICAgICAgICAgICAgKnByaW8gPSBNU0dfUFJJT1JJVFkxMTsNCiAgICAgICAgICAgIGJyZWFrOw0KICAgICAgICBjYXNlIFVTRVJfUFJJT1JJVFkxMjoNCiAgICAgICAgICAgICpwcmlvID0gTVNHX1BSSU9SSVRZMTI7DQogICAgICAgICAgICBicmVhazsNCiAgICAgICAgY2FzZSBVU0VSX1BSSU9SSVRZMTM6DQogICAgICAgICAgICAqcHJpbyA9IE1TR19QUklPUklUWTEzOw0KICAgICAgICAgICAgYnJlYWs7DQogICAgICAgIGNhc2UgVVNFUl9QUklPUklUWTE0Og0KICAgICAgICAgICAgKnByaW8gPSBNU0dfUFJJT1JJVFkxNDsNCiAgICAgICAgICAgIGJyZWFrOw0KICAgICAgICBjYXNlIFVTRVJfUFJJT1JJVFkxNToNCiAgICAgICAgICAgICpwcmlvID0gTVNHX1BSSU9SSVRZMTU7DQogICAgICAgICAgICBicmVhazsNCiAgICAgICAgZGVmYXVsdDoNCiAgICAgICAgICAgICpwcmlvID0gTVNHX1BSSU9SSVRZMTU7DQogICAgICAgICAgICBicmVhazsNCiAgICB9DQoNCiAgICByZXR1cm4gSE1YX09LOw0KfQ0KDQoNCi8qDQoJcV9pbnNlcnRfdGVtcF90YWlsX2VsZW1lbnQNCgl0ZW1wIFFldWW/oSBlbGVtZW50uKYgv6yw4SDH0bTZLg0KKi8NCnZvaWQgcV9pbnNlcnRfdGVtcF90YWlsX2VsZW1lbnQoc3RydWN0IEhNWF9NU0dfcXVldWUgKnEsIHN0cnVjdCBITVhfTVNHX2VsZW1lbnQgKmVsZW1lbnQpDQp7DQoJaWYocS0+dGVtcF90YWlsID09IE5VTEwpDQoJew0KCQlxLT50ZW1wX2hlYWQgPSBlbGVtZW50Ow0KCQllbGVtZW50LT5uZXh0ID0gTlVMTDsNCgkJZWxlbWVudC0+cHJldiA9IE5VTEw7DQoJCXEtPnRlbXBfdGFpbCA9IGVsZW1lbnQ7DQoJfQ0KCWVsc2UNCgl7DQoJCXEtPnRlbXBfdGFpbC0+bmV4dCA9IGVsZW1lbnQ7DQoJCWVsZW1lbnQtPm5leHQgPSBOVUxMOw0KCQllbGVtZW50LT5wcmV2ID0gcS0+dGVtcF90YWlsOw0KCQlxLT50ZW1wX3RhaWwgPSBlbGVtZW50Ow0KCX0NCn0NCg0KLyoNCglxX3JlbW92ZV90ZW1wX3RhaWxfZWxlbWVudA0KCXRlbXAgUWV1Zb+hvK0guLbB9ri3IGVsZW1lbnS4piDBprDFx8+/qSCz0bDcwdi02S4NCiovDQp2b2lkIHFfcmVtb3ZlX3RlbXBfdGFpbF9lbGVtZW50KHN0cnVjdCBITVhfTVNHX3F1ZXVlICpxLCAJc3RydWN0IEhNWF9NU0dfZWxlbWVudCAqKmVsZW1lbnQpDQp7DQoJUHJpbnRFbnRlcigpOw0KDQogICAgICAJKmVsZW1lbnQgPSBxLT50ZW1wX3RhaWw7DQoNCglpZihxLT50ZW1wX2hlYWQtPm5leHQgPT0gTlVMTCkgLy9lbGVtZW50IDGwsyCzssC6ILDmv+wuDQoJew0KCQlxLT50ZW1wX2hlYWQgPSBOVUxMOw0KCQlxLT50ZW1wX3RhaWwgPSBOVUxMOw0KCX0NCgllbHNlDQoJew0KCQlxLT50ZW1wX3RhaWwtPnByZXYtPm5leHQgPSBOVUxMOw0KCQlxLT50ZW1wX3RhaWwgPSBxLT50ZW1wX3RhaWwtPnByZXY7DQoJfQ0KCVByaW50RXhpdCgpOw0KfQ0KDQovKg0KCXFfZGVzdG9yeV90ZW1wX3RhaWwNCgl0ZW1wIFFldWXAxyBlbGVtZW50IG1lbW9yebimILzSuOq9w8WytNkuDQoqLw0Kdm9pZCBxX2Rlc3RvcnlfdGVtcF90YWlsKHN0cnVjdCBITVhfTVNHX3F1ZXVlICpxKQ0Kew0KCXN0cnVjdCBITVhfTVNHX2VsZW1lbnQgKnFfZWxlbWVudDsNCg0KCVByaW50RW50ZXIoKTsNCg0KCWRvDQoJew0KCQlxX2VsZW1lbnQgPSBxLT50ZW1wX3RhaWw7DQoJCXEtPnRlbXBfdGFpbCA9IHEtPnRlbXBfdGFpbC0+cHJldjsNCg0KDQoJfSB3aGlsZShxLT50ZW1wX3RhaWwgIT0gTlVMTCk7DQoJaWYgKHEtPnBQb29sKQ0KCXsNCgkJZnJlZShxLT5wUG9vbCk7DQoJCXEtPnBQb29sID0gTlVMTDsNCgl9DQoJaWYgKHEtPnBEYXRhUG9vbCkNCgl7DQoJCWZyZWUocS0+cERhdGFQb29sKTsNCgkJcS0+cERhdGFQb29sID0gTlVMTDsNCgl9DQoNCglQcmludEV4aXQoKTsNCn0NCg0KDQovKg0KICAgIGxpc3RfcmVtX25leHQNCiAgICBlbGVtZW50v6G8rSBkYXRhuKYgu+jBpsfRtNkuDQoqLw0KaW50IGxpc3RfcmVtX25leHQoc3RydWN0IEhNWF9NU0dfcXVldWUgKmxpc3QsIHZvaWQgKmRhdGEsIHVuc2lnbmVkIGxvbmcgc2l6ZSwgdW5zaWduZWQgY2hhciB0aW1lb3V0ZmxhZywgc3RydWN0IHRpbWVzcGVjICp0aW1lbykNCnsNCglzdHJ1Y3QgSE1YX01TR19lbGVtZW50ICAgICAgICAgICAqb2xkX2VsZW1lbnQ7DQoJdW5zaWduZWQgbG9uZyBwcmlvOw0KCWludCByYyA9IDA7DQoNCglQcmludEVudGVyKCk7DQoNCglsaXN0LT5yZWFkZXJfY291bnRfKys7DQoNCglpZiAoKGxpc3Rfc2l6ZShsaXN0KSA9PSAwIHx8IGxpc3QtPnJlYWRlcl9jb3VudF8gPiAxKSAmJiAwID09IHJjKQ0KCXsNCgkJaWYoVFJVRSA9PSB0aW1lb3V0ZmxhZykNCgkJew0KCQkJcmMgPSBwdGhyZWFkX2NvbmRfdGltZWR3YWl0KCZsaXN0LT5xX25vdF9lbXB0eV8sICZsaXN0LT5xX2xvY2tfLCB0aW1lbyk7DQoJCX0NCgkJZWxzZQ0KCQl7DQoJCQlyYyA9IHB0aHJlYWRfY29uZF93YWl0KCZsaXN0LT5xX25vdF9lbXB0eV8sICZsaXN0LT5xX2xvY2tfKTsNCgkJfQ0KCX0NCg0KCWxpc3QtPnJlYWRlcl9jb3VudF8tLTsNCg0KCWlmKHJjICE9IDApDQoJew0KCQlQcmludERlYnVnKCIlcyA6IHJjWyVkXSAhIVxuIiwgX19GVU5DVElPTl9fLCByYyk7DQoJCXJldHVybiByYzsNCgl9DQoNCglwcmlvID0gbGlzdF9maW5kX2hpZ2hlc3RfcHJpb3JpdHlfYml0bWFwKGxpc3QpOw0KCVByaW50RGVidWcoImxpc3RfZmluZF9oaWdoZXN0X3ByaW9yaXR5X2JpdG1hcCA6IHByaW8gPSAlZFxuIiwgcHJpbyk7DQoNCgltZW1jcHkoZGF0YSwgbGlzdC0+aGVhZFtwcmlvXS0+ZGF0YSwgc2l6ZSk7DQoJb2xkX2VsZW1lbnQgPSBsaXN0LT5oZWFkW3ByaW9dOw0KCWlmKE5VTEwgPT0gbGlzdC0+aGVhZFtwcmlvXS0+bmV4dCkNCgl7DQoJCWxpc3QtPmhlYWRbcHJpb10gPSBOVUxMOw0KCQlsaXN0LT50YWlsW3ByaW9dID0gTlVMTDsNCgl9DQoJZWxzZQ0KCXsNCgkJbGlzdC0+aGVhZFtwcmlvXSA9IGxpc3QtPmhlYWRbcHJpb10tPm5leHQ7DQoJfQ0KDQoJcV9pbnNlcnRfdGVtcF90YWlsX2VsZW1lbnQobGlzdCwgb2xkX2VsZW1lbnQpOw0KCWxpc3QtPmN1cnJfbXNnX2NvdW50Xy0tOw0KCWxpc3RfYml0bWFwX2NvdW50X2RlY3JlYXNlKGxpc3QsIHByaW8pOw0KDQoJaWYobGlzdC0+Yml0bWFwX2NvdW50W3ByaW9dID09IDApDQoJICAgIGxpc3RfY2xlYXJfYml0bWFwKGxpc3QsIHByaW8pOw0KDQoJaWYgKGxpc3QtPndyaXRlcl9jb3VudF8gPiAwKQ0KCSAgICBwdGhyZWFkX2NvbmRfc2lnbmFsKCZsaXN0LT5xX25vdF9mdWxsXyk7DQoNCglQcmludEV4aXQoKTsNCg0KCXJldHVybiByYzsNCn0NCg0KDQpzdGF0aWMgdm9pZCAqdGhyZWFkX2Z1bmNfKHZvaWQgKmFyZykNCnsNCglzdHJ1Y3QgSE1YX1RBU0tfYXJnICpwID0gKHN0cnVjdCBITVhfVEFTS19hcmcgKilhcmc7DQoJaW50IHJjID0gMDsNCg0KI2lmIGRlZmluZWQoQ09ORklHX0RFQlVHKQ0KCXAtPnBpZCA9IGdldHBpZCgpOw0KCXAtPnRpZCA9IChsb25nIGludClzeXNjYWxsKDQyMjIpOw0KI2VuZGlmDQoNCglwdGhyZWFkX211dGV4X2xvY2soJnAtPmxvY2tfKTsNCg0KCXdoaWxlIChwLT5zdGFydCA9PSAwICYmIDAgPT0gcmMpIC8vd2FpdCBzaWduYWwNCgkJcmMgPSBwdGhyZWFkX2NvbmRfd2FpdCgmcC0+Y29uZF8sICZwLT5sb2NrXyk7DQoNCglwdGhyZWFkX211dGV4X3VubG9jaygmcC0+bG9ja18pOw0KDQojaWYgZGVmaW5lZChDT05GSUdfREVCVUcpDQoNCglwLT50aHJlYWRfaWQgPSBwdGhyZWFkX3NlbGYoKTsNCglQcmludERlYnVnKCJbJXNdIHRhc2sgc3RhcnRlZC4uLlxuIiwgcC0+bmFtZSk7DQojZW5kaWYNCg0KCSgqcC0+c3RhcnRfZnVuY18pKHAtPmFyZ18pOw0KDQoJcmV0dXJuIE5VTEw7DQp9DQoNCg0KLyoNCiAgICBITVhfVEFTS19DcmVhdGUNCiAgICDFwr26xam4piC7/by6x9G02S4NCiovDQppbnQgSE1YX1RBU0tfQ3JlYXRlKHZvaWQgKCpzdGFydF9mdW5jKSh2b2lkICopLCB1bnNpZ25lZCBsb25nIHByaW8sdW5zaWduZWQgbG9uZyBzdGFja19zaXplLCBjb25zdCBjaGFyICpuYW1lLCB2b2lkICphcmcsIHVuc2lnbmVkIGxvbmcgKnRhc2tJZCwgaW50IElzSm9pbmFibGUpDQp7DQogICAgaW50IHJjOw0KICAgIHN0cnVjdCBITVhfVEFTSyAqdGFzazsNCiAgICBwdGhyZWFkX2F0dHJfdCB0aHJlYWRfYXR0cjsNCiAgICBzdHJ1Y3Qgc2NoZWRfcGFyYW0Jc2NoUGFyYW07DQogICAgdW5zaWduZWQgY2hhciAqcHVjRHN0U3RhY2tBZGRyID0gTlVMTDsNCgl1bnNpZ25lZCBjaGFyICpwdWNUYXNrU3RhY2s7DQoNCiAgICByYyA9IHB0aHJlYWRfYXR0cl9pbml0ICgmdGhyZWFkX2F0dHIpOw0KICAgIGlmIChyYykgew0KICAgICAgICByZXR1cm4gSE1YX0VSUk9SOw0KICAgIH0NCg0KCXJjID0gcHRocmVhZF9hdHRyX3NldHNjaGVkcG9saWN5ICgmdGhyZWFkX2F0dHIsIEhNWF9UQVNLX1BUSFJFQURfREVGQVVMVF9QUklPKTsNCglpZiAocmMpIHsNCgkJcmV0dXJuIEhNWF9FUlJPUjsNCgl9DQoNCglwdGhyZWFkX2F0dHJfZ2V0c2NoZWRwYXJhbSgmdGhyZWFkX2F0dHIsICZzY2hQYXJhbSk7DQoJc2NoUGFyYW0uc2NoZWRfcHJpb3JpdHkgPSBwcmlvOw0KCXJjID0gcHRocmVhZF9hdHRyX3NldHNjaGVkcGFyYW0gKCZ0aHJlYWRfYXR0ciwgJnNjaFBhcmFtKTsNCglpZiAocmMpIHsNCgkJcmV0dXJuIEhNWF9FUlJPUjsNCgl9DQoNCiAgICBpZiAoc3RhY2tfc2l6ZSA8IEhNWF9UQVNLX1BUSFJFQURfU1RBQ0tfTUlOKQ0KICAgICAgICBzdGFja19zaXplID0gSE1YX1RBU0tfUFRIUkVBRF9TVEFDS19NSU47DQoNCglwdWNUYXNrU3RhY2sgPSBtYWxsb2Moc3RhY2tfc2l6ZStITVhfVEFTS19TVEFDS19PVkVSSEVBRF9TSVpFK0hNWF9UQVNLX0dVQVJEX1NJWkUpOw0KCWlmIChwdWNUYXNrU3RhY2sgPT0gTlVMTCkNCgkJcmV0dXJuIEhNWF9FUlJPUjsNCiAgICBtZW1zZXQocHVjVGFza1N0YWNrLCAweEE1LCBzdGFja19zaXplK0hNWF9UQVNLX1NUQUNLX09WRVJIRUFEX1NJWkUrSE1YX1RBU0tfR1VBUkRfU0laRSApOw0KDQogICAgUHJpbnREZWJ1ZygiJXMoJWQpIDogcHVjVGFza1N0YWNrID0gJXAsIHN0YWNrX3NpemU9ICVkXG4iLCBfX0ZVTkNUSU9OX18sIF9fTElORV9fLCBwdWNUYXNrU3RhY2ssIHN0YWNrX3NpemUpOw0KICAgIHJjID0gcHRocmVhZF9hdHRyX3NldHN0YWNrKCZ0aHJlYWRfYXR0ciwgKHZvaWQgKilwdWNUYXNrU3RhY2ssIHN0YWNrX3NpemUgKTsNCiAgICBpZiAocmMpIHsNCiAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICB9DQoNCiAgICByYyA9IHB0aHJlYWRfYXR0cl9nZXRzdGFjaygmdGhyZWFkX2F0dHIsKHZvaWQgKikmcHVjRHN0U3RhY2tBZGRyLCAoc2l6ZV90ICopJnN0YWNrX3NpemUgKTsNCiAgICBpZiAocmMpIHsNCiAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICB9DQogICAgUHJpbnREZWJ1ZygiJXMoJWQpIDogcHVjRHN0U3RhY2tBZGRyID0gJXAsIHN0YWNrX3NpemU9ICVkXG4iLCBfX0ZVTkNUSU9OX18sIF9fTElORV9fLCBwdWNEc3RTdGFja0FkZHIsIHN0YWNrX3NpemUpOw0KDQogICAgaWYgKElzSm9pbmFibGUgPT0gVFJVRSkNCiAgICB7DQogICAgICAgIHJjID0gcHRocmVhZF9hdHRyX3NldGRldGFjaHN0YXRlKCZ0aHJlYWRfYXR0ciwgUFRIUkVBRF9DUkVBVEVfSk9JTkFCTEUpOw0KICAgIH0NCiAgICBlbHNlIGlmKElzSm9pbmFibGUgPT0gRkFMU0UpDQogICAgew0KICAgICAgICByYyA9IHB0aHJlYWRfYXR0cl9zZXRkZXRhY2hzdGF0ZSgmdGhyZWFkX2F0dHIsIFBUSFJFQURfQ1JFQVRFX0RFVEFDSEVEKTsNCiAgICB9DQogICAgZWxzZQ0KICAgIHsNCiAgICAgICAgUHJpbnRFcnJvcigiJXMoJXMpIDogSXNKb2luYWJsZSBQYXJhbWV0ZXIgRXJyb3IhIVxuIiwgX19mdW5jX18sIF9fTElORV9fKTsNCiAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICB9DQoNCiAgICBpZiAocmMpIHsNCiAgICAgICAgUHJpbnRFcnJvciAoIiVzKCVkKSA6IEZhaWxlZCB0byBJc0pvaW5hYmxlICVzXG4iLCBfX0ZVTkNUSU9OX18sIF9fTElORV9fLCBzdHJlcnJvciAocmMpKTsNCiAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICB9DQoNCiAgICBpZiAodGFzayA9IChzdHJ1Y3QgSE1YX1RBU0sgKiltYWxsb2Moc2l6ZW9mKHN0cnVjdCBITVhfVEFTSykpLCBOVUxMID09IHRhc2spIHsNCiAgICAgICAgKnRhc2tJZCA9IDA7DQogICAgICAgIGZyZWUocHVjVGFza1N0YWNrKTsNCiAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICB9DQoNCiAgICB0YXNrLT50YXJnXy5zdGFydF9mdW5jXwk9IHN0YXJ0X2Z1bmM7DQogICAgdGFzay0+dGFyZ18uYXJnXyAJCT0gYXJnOw0KICAgIHRhc2stPnRhcmdfLnByaW9yaXR5Xwk9IHByaW87DQogICAgdGFzay0+dGFyZ18uc3RhY2tTaXplXwk9IHN0YWNrX3NpemU7DQogICAgdGFzay0+dGFyZ18uSXNKb2luYWJsZQk9IElzSm9pbmFibGU7DQogICAgdGFzay0+dGFyZ18ucHVjVGFza1N0YWNrID0gKHVuc2lnbmVkIGxvbmcgKilwdWNUYXNrU3RhY2s7DQogICAgdGFzay0+dGFyZ18ucHVsU3RhY2tTdGFydEFkZHJlc3MgPSAodW5zaWduZWQgbG9uZyAqKXB1Y0RzdFN0YWNrQWRkcjsNCg0KICAgIHB0aHJlYWRfbXV0ZXhfaW5pdCgmdGFzay0+dGFyZ18ubG9ja18sIE5VTEwpOw0KICAgIHB0aHJlYWRfY29uZF9pbml0KCZ0YXNrLT50YXJnXy5jb25kXywgTlVMTCk7DQogICAgdGFzay0+dGFyZ18uc3RhcnQgPSAwOw0KDQogICAgc3RybmNweSh0YXNrLT50YXJnXy5uYW1lLCBuYW1lLCBzaXplb2YodGFzay0+dGFyZ18ubmFtZSktMSk7DQoNCiAgICByYyA9IHB0aHJlYWRfY3JlYXRlKCZ0YXNrLT50YXNrXywgJnRocmVhZF9hdHRyLCB0aHJlYWRfZnVuY18sICZ0YXNrLT50YXJnXyk7DQogICAgaWYgKHJjKSB7DQogICAgICAgIGZyZWUocHVjVGFza1N0YWNrKTsNCiAgICAgICAgZnJlZSh0YXNrKTsNCiAgICAgICAgKnRhc2tJZCA9IDA7DQogICAgICAgIHJldHVybiBITVhfRVJST1I7DQogICAgfQ0KDQogICAgKnRhc2tJZCA9ICh1bnNpZ25lZCBsb25nKXRhc2s7DQoNCiNpZiBkZWZpbmVkKENPTkZJR19UQVNLX1BSSU9SSVRZKQ0KCXB0aHJlYWRfc2V0c2NoZWRwYXJhbSh0YXNrLT50YXNrXywgSE1YX1RBU0tfUFRIUkVBRF9ERUZBVUxUX1BSSU8sICZzY2hQYXJhbSk7DQojZW5kaWYNCg0KICAgIHB0aHJlYWRfYXR0cl9kZXN0cm95KCZ0aHJlYWRfYXR0cik7DQogICAgUHJpbnREZWJ1ZygiJXMoJWQpIDogc191Y1Rhc2tDb3VudCA9ICVkXG4iLCBfX2Z1bmNfXywgX19MSU5FX18sIHNfdWNUYXNrQ291bnQpOw0KICAgIHJldHVybiBITVhfT0s7DQp9DQoNCmludCBITVhfVEFTS19TdGFydCh1bnNpZ25lZCBsb25nIHRhc2tJZCkNCnsNCiAgICBzdHJ1Y3QgSE1YX1RBU0sgKnRhc2sgPSAoc3RydWN0IEhNWF9UQVNLICopdGFza0lkOw0KICAgIFByaW50RW50ZXIoKTsNCg0KICAgIGlmKE5VTEwgPT0gdGFzaykNCiAgICB7DQogICAgICAgIFByaW50RXJyb3IoIiVzKCVkKSA6IHRhc2sgaXMgTlVMTCEhXG4iLCBfX2Z1bmNfXywgX19MSU5FX18pOw0KICAgICAgICByZXR1cm4gSE1YX0VSUk9SOw0KICAgIH0NCg0KICAgIHB0aHJlYWRfbXV0ZXhfbG9jaygmdGFzay0+dGFyZ18ubG9ja18pOw0KICAgIGlmICh0YXNrLT50YXJnXy5zdGFydCA9PSAwKSB7DQogICAgCXRhc2stPnRhcmdfLnN0YXJ0ID0gMTsNCiAgICAJcHRocmVhZF9jb25kX3NpZ25hbCgmdGFzay0+dGFyZ18uY29uZF8pOw0KICAgIH0NCiAgICBwdGhyZWFkX211dGV4X3VubG9jaygmdGFzay0+dGFyZ18ubG9ja18pOw0KICAgIFByaW50RXhpdCgpOw0KICAgIHJldHVybiBITVhfT0s7DQp9DQoNCi8qDQogICAgSE1YX1RBU0tfU3RvcA0KICAgIFRhc2u4piC89sfgtcggwMzIxL+hIMDMIMfUvPa4piDIo8Pix9i1tSBTVE9QwLogtcfB9iC+yrTCtNkuDQogICAgtNzB9iBjb3VudLi4IDDAuLfOILi4tee02S4NCiovDQppbnQgSE1YX1RBU0tfU3RvcCh1bnNpZ25lZCBsb25nIHRhc2tJZCkNCnsNCiAgICBzdHJ1Y3QgSE1YX1RBU0sgKnRhc2sgPSAoc3RydWN0IEhNWF9UQVNLICopdGFza0lkOw0KDQogICAgUHJpbnRFbnRlcigpOw0KDQogICAgaWYgKHRhc2sgPT0gTlVMTCkgew0KICAgICAgICByZXR1cm4gSE1YX09LOw0KICAgIH0NCg0KICAgIHB0aHJlYWRfbXV0ZXhfbG9jaygmdGFzay0+dGFyZ18ubG9ja18pOw0KICAgIGlmICh0YXNrLT50YXJnXy5zdGFydCAhPSAwKQ0KICAgICAgICB0YXNrLT50YXJnXy5zdGFydCA9IDA7DQogICAgcHRocmVhZF9tdXRleF91bmxvY2soJnRhc2stPnRhcmdfLmxvY2tfKTsNCg0KICAgIHJldHVybiBITVhfT0s7DQp9DQoNCi8qDQogICAgc2xlZXANCiAgICDFwr26xam4piDA4cDnv+602S4NCiovDQppbnQgSE1YX1NsZWVwKHVuc2lnbmVkIGxvbmcgdWx0aW1lKQ0Kew0KCXN0cnVjdCB0aW1lc3BlYyBkZWxheTsNCglzdHJ1Y3QgdGltZXNwZWMgcmVtOw0KCWludCByYzsNCg0KCWlmICh1bHRpbWUgIT0gMCkNCgl7DQoJCUhNWF9UQVNLX0NoZWNrQ2FsbGJhY2soKTsNCgl9DQoJZGVsYXkudHZfc2VjID0gdWx0aW1lIC8gMTAwMDsNCglkZWxheS50dl9uc2VjID0gKHVsdGltZSAlIDEwMDApICogMTAwMDAwMDsNCg0KCWZvciAoOzspIHsNCgkJcmMgPSBuYW5vc2xlZXAoJmRlbGF5LCAmcmVtKTsNCgkJaWYgKDAgIT0gcmMpIHsNCgkJCWlmIChFSU5UUiA9PSBlcnJubykgew0KCQkJCWRlbGF5ID0gcmVtOw0KCQkJCWNvbnRpbnVlOw0KCQkJfQ0KCQkJcmV0dXJuIEhNWF9FUlJPUjsNCgkJfQ0KCQlicmVhazsNCgl9DQoNCglyZXR1cm4gSE1YX09LOw0KfQ0KDQovKg0KICAgIEhNWF9UQVNLX0Rlc3Ryb3kNCiAgICDFwr26xam4piC80rjqx9G02S4NCiovDQppbnQgSE1YX1RBU0tfRGVzdHJveSh1bnNpZ25lZCBsb25nIHRhc2tJZCkNCnsNCiAgICBpbnQgcmM7DQogICAgc3RydWN0IEhNWF9UQVNLICp0YXNrID0gKHN0cnVjdCBITVhfVEFTSyAqKXRhc2tJZDsNCg0KICAgIGlmKCB0YXNrSWQgPT0gKHVuc2lnbmVkIGxvbmcpTlVMTCApDQogICAgew0KICAgICAgICBQcmludERlYnVnKCIlcyglZCkgdGFza0lkID09IE5VTExcbiIsIF9fRlVOQ1RJT05fXywgX19MSU5FX18pOw0KICAgICAgICByZXR1cm4gSE1YX0VSUk9SOw0KICAgIH0NCiAgICBlbHNlDQogICAgew0KCQlwdGhyZWFkX211dGV4X2xvY2soJnRhc2stPnRhcmdfLmxvY2tfKTsNCgkJaWYgKHRhc2stPnRhcmdfLnN0YXJ0ID09IDEpDQoJCXsNCgkJCXRhc2stPnRhcmdfLnN0YXJ0ID0gMDsNCgkJfQ0KCQlyYyA9IHB0aHJlYWRfY2FuY2VsKHRhc2stPnRhc2tfKTsNCgkJaWYgKHJjKQ0KCQl7DQoJCQlQcmludEVycm9yKCJbSE1YX1RBU0tfRGVzdHJveV0gd2FybmluZyA6IHRoZXJlIGlzIG5vIHRocmVhZCBpbiBwdGhyZWFkIHRhc2tJZCglMDhYKSBwdGhyZWFkSWQoJTA4WClcbiIsIHRhc2tJZCwgdGFzay0+dGFza18pOw0KCQl9DQoJCUhNWF9TbGVlcCgxKTsNCiNpZiBkZWZpbmVkKENPTkZJR19USFJFQURfSk9JTl9URU1QT1JBUlkpDQojZWxzZQ0KCQlpZiAodGFzay0+dGFyZ18uSXNKb2luYWJsZSkNCiNlbmRpZg0KCQkJcHRocmVhZF9qb2luKHRhc2stPnRhc2tfLCBOVUxMKTsNCg0KCQlmcmVlKHRhc2stPnRhcmdfLnB1Y1Rhc2tTdGFjayk7DQoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZ0YXNrLT50YXJnXy5sb2NrXyk7DQogICAgfQ0KDQogICAgZnJlZSh0YXNrKTsNCg0KICAgIHJldHVybiBITVhfT0s7DQp9DQoNCi8qDQogICAgSE1YX1RBU0tfU2V0Q3VycmVudFByaW9yaXR5DQogICAgu/W3zr/uIL/svLG8+MCnuKYgvLzGw8fRtNkuDQoqLw0KaW50IEhNWF9UQVNLX1NldEN1cnJlbnRQcmlvcml0eSh1bnNpZ25lZCBsb25nIHRhc2tJZCwgdW5zaWduZWQgbG9uZyBuZXdwcmlvcml0eSkNCnsNCglpbnQgcmM7DQoJaW50IHBvbGljeTsNCglzdHJ1Y3QgSE1YX1RBU0sgKnRhc2sgPSAoc3RydWN0IEhNWF9UQVNLICopdGFza0lkOw0KCXN0cnVjdCBzY2hlZF9wYXJhbQlzY2hQYXJhbTsNCg0KCWlmICh0YXNrID09IE5VTEwpDQoJew0KCQlyZXR1cm4gSE1YX0VSUk9SOw0KCX0NCg0KCXJjID0gcHRocmVhZF9nZXRzY2hlZHBhcmFtKHRhc2stPnRhc2tfLCAmcG9saWN5LCAmc2NoUGFyYW0pOw0KCWlmIChzY2hQYXJhbS5zY2hlZF9wcmlvcml0eSA9PSAoaW50KW5ld3ByaW9yaXR5KQ0KCXsNCgkJcmV0dXJuIEhNWF9PSzsNCgl9DQoNCglzY2hQYXJhbS5zY2hlZF9wcmlvcml0eSAJPSBuZXdwcmlvcml0eTsNCg0KCXB0aHJlYWRfbXV0ZXhfbG9jaygmdGFzay0+dGFyZ18ubG9ja18pOw0KCXJjID0gcHRocmVhZF9zZXRzY2hlZHBhcmFtKHRhc2stPnRhc2tfLCBwb2xpY3ksICZzY2hQYXJhbSk7DQoJcHRocmVhZF9tdXRleF91bmxvY2soJnRhc2stPnRhcmdfLmxvY2tfKTsNCg0KCWlmIChyYykgew0KCQlyZXR1cm4gSE1YX0VSUk9SOw0KCX0NCg0KCXJldHVybiBITVhfT0s7DQp9DQoNCg0KDQovKg0KICAgIGxpc3RfaW5pdA0KICAgIEhNWF9NU0dfcXVldWUgsbjBtsO8uKYgw8qx4sitIMfRtNkuDQoqLw0Kdm9pZCBsaXN0X2luaXQoc3RydWN0IEhNWF9NU0dfcXVldWUgKmxpc3QsIHVuc2lnbmVkIGxvbmcgdWxTaXplLCB1bnNpZ25lZCBsb25nIHVsQ291bnQsIHVuc2lnbmVkIGNoYXIgdWNTdXNwZW5kVHlwZSkNCnsNCiAgICBpbnQgaTsNCg0KICAgIGxpc3QtPmN1cnJfbXNnX2NvdW50XyA9IDA7DQogICAgbGlzdC0+bXNnX3NpemVfID0gdWxTaXplOw0KICAgIGxpc3QtPm1zZ19jb3VudF8gPSB1bENvdW50Ow0KICAgIGxpc3QtPndyaXRlcl9jb3VudF8gPSAwOw0KICAgIGxpc3QtPnJlYWRlcl9jb3VudF8gPSAwOw0KICAgIGxpc3QtPnN1c3BlbmRfdHlwZV8gPSB1Y1N1c3BlbmRUeXBlOw0KICAgIHB0aHJlYWRfbXV0ZXhfaW5pdCgmbGlzdC0+cV9sb2NrXywgTlVMTCk7DQogICAgcHRocmVhZF9jb25kX2luaXQoJmxpc3QtPnFfbm90X2VtcHR5XywgTlVMTCk7DQogICAgcHRocmVhZF9jb25kX2luaXQoJmxpc3QtPnFfbm90X2Z1bGxfLCBOVUxMKTsNCg0KICAgIGxpc3QtPnRlbXBfaGVhZCA9IE5VTEw7DQogICAgbGlzdC0+dGVtcF90YWlsID0gTlVMTDsNCg0KICAgIGZvcihpPTA7IGk8TVNHX1BSSU9SSVRZX01BWDsgaSsrKQ0KICAgIHsNCiAgICAgICAgbGlzdC0+aGVhZFtpXSA9IE5VTEw7DQogICAgICAgIGxpc3QtPnRhaWxbaV0gPSBOVUxMOw0KICAgICAgICBsaXN0LT5iaXRtYXBfY291bnRbaV0gPSAwOw0KICAgICAgICBsaXN0LT5iaXRtYXBbaV0gPSAwOw0KICAgIH0NCg0KI2lmZGVmIEhNWF9NU0dfREVCVUcNCiAgICBsaXN0LT5zZW5kVGljayA9IDA7DQogICAgbGlzdC0+cmVjZWl2ZVRpY2sgPSAwOw0KICAgIGxpc3QtPmxhc3RTZW5kVGljayA9IDA7DQogICAgbGlzdC0+bGFzdFJlY2VpdmVUaWNrID0gMDsNCiNlbmRpZg0KICAgIHJldHVybjsNCn0NCg0KDQoNCi8qDQogICAgbGlzdF9kZXN0cm95DQogICAgSE1YX01TR19xdWV1ZSCxuMG2w7y4piC80rjqvcPFsrTZLg0KKi8NCnZvaWQgbGlzdF9kZXN0cm95KHN0cnVjdCBITVhfTVNHX3F1ZXVlICpsaXN0KQ0Kew0KCXZvaWQgICAgICAgICAgICAgICAqZGF0YTsNCg0KCWRhdGEgPSAoY2hhciAqKW1hbGxvYyhsaXN0LT5tc2dfc2l6ZV8pOw0KDQoJd2hpbGUgKGxpc3Rfc2l6ZShsaXN0KSA+IDApDQoJew0KCQlpZiAoIGxpc3RfcmVtX25leHQobGlzdCwgKHZvaWQgKilkYXRhLCBsaXN0LT5tc2dfc2l6ZV8sIEZBTFNFLCBGQUxTRSkgIT0gMCApDQoJCXsNCgkJCVByaW50RXJyb3IoIiVzIDogbGlzdF9yZW1fbmV4dCBFcnJvciEhXG4iLCBfX2Z1bmNfXyk7DQoJCX0NCgl9DQoNCglmcmVlKGRhdGEpOw0KCXJldHVybjsNCn0NCg0KDQoNCi8qDQogICAgbGlzdF9pbnNfbmV4dA0KICAgIGVsZW1lbnS/oSBkYXRhuKYgw9+wocfRtNkuDQoqLw0KaW50IGxpc3RfaW5zX25leHQoc3RydWN0IEhNWF9NU0dfcXVldWUgKmxpc3QsIHVuc2lnbmVkIGxvbmcgcHJpbywgY29uc3Qgdm9pZCAqZGF0YSwgdW5zaWduZWQgbG9uZyBzaXplLCB1bnNpZ25lZCBjaGFyIHRpbWVvdXRmbGFnLCBzdHJ1Y3QgdGltZXNwZWMgKnRpbWVvKQ0Kew0KCXN0cnVjdCBITVhfTVNHX2VsZW1lbnQgICAgICAgICAgICpuZXdfZWxlbWVudDsNCglpbnQgcmMgPSAwOw0KDQoJUHJpbnRFbnRlcigpOw0KDQoJbGlzdC0+d3JpdGVyX2NvdW50XysrOw0KDQoJd2hpbGUgKGxpc3QtPm1zZ19jb3VudF8gPT0gbGlzdC0+Y3Vycl9tc2dfY291bnRfICYmIDAgPT0gcmMpDQoJew0KCSAgICBpZihUUlVFID09IHRpbWVvdXRmbGFnKQ0KCSAgICB7DQoJICAgICAgICByYyA9IHB0aHJlYWRfY29uZF90aW1lZHdhaXQoJmxpc3QtPnFfbm90X2Z1bGxfLCAmbGlzdC0+cV9sb2NrXywgdGltZW8pOw0KCSAgICB9DQoJICAgIGVsc2UNCgkgICAgew0KCSAgICAgICAgcmMgPSBwdGhyZWFkX2NvbmRfd2FpdCgmbGlzdC0+cV9ub3RfZnVsbF8sICZsaXN0LT5xX2xvY2tfKTsNCgkgICAgfQ0KCX0NCg0KCWxpc3QtPndyaXRlcl9jb3VudF8tLTsNCg0KCWlmKHJjICE9IDApDQoJew0KCSAgICBQcmludERlYnVnKCIlcyA6IHJjWyVkXSAhIVxuIiwgX19GVU5DVElPTl9fLCByYyk7DQoJICAgIHJldHVybiByYzsNCgl9DQoNCglxX3JlbW92ZV90ZW1wX3RhaWxfZWxlbWVudChsaXN0LCAmbmV3X2VsZW1lbnQpOw0KDQoJbWVtY3B5KG5ld19lbGVtZW50LT5kYXRhLCBkYXRhLCBzaXplKTsNCg0KCWlmKGxpc3QtPnRhaWxbcHJpb10gPT0gTlVMTCkNCgl7DQoJCWxpc3QtPmhlYWRbcHJpb10gPSBuZXdfZWxlbWVudDsNCgkJbmV3X2VsZW1lbnQtPm5leHQgPSBOVUxMOw0KCQluZXdfZWxlbWVudC0+cHJldiA9IE5VTEw7DQoJCWxpc3QtPnRhaWxbcHJpb10gPSBuZXdfZWxlbWVudDsNCgl9DQoJZWxzZQ0KCXsNCgkJbGlzdC0+dGFpbFtwcmlvXS0+bmV4dCA9IG5ld19lbGVtZW50Ow0KCQluZXdfZWxlbWVudC0+bmV4dCA9IE5VTEw7DQoJCW5ld19lbGVtZW50LT5wcmV2ID0gbGlzdC0+dGFpbFtwcmlvXTsNCgkJbGlzdC0+dGFpbFtwcmlvXSA9IG5ld19lbGVtZW50Ow0KCX0NCg0KCWxpc3QtPmN1cnJfbXNnX2NvdW50XysrOw0KCWxpc3RfYml0bWFwX2NvdW50X2luY3JlYXNlKGxpc3QsIHByaW8pOw0KCWxpc3Rfc2V0X2JpdG1hcChsaXN0LCBwcmlvKTsNCg0KCWlmIChsaXN0LT5yZWFkZXJfY291bnRfID4gMCkNCgkJcHRocmVhZF9jb25kX3NpZ25hbCgmbGlzdC0+cV9ub3RfZW1wdHlfKTsNCg0KCVByaW50RXhpdCgpOw0KCXJldHVybiBITVhfT0s7DQp9DQoNCg0KDQoNCi8qDQogICAgSE1YX01TR19Jbml0DQogICAguN68vMH2IMWluKYgw8qx4sitIMfRtNkuDQoqLw0KaW50IEhNWF9NU0dfSW5pdCh2b2lkKQ0Kew0KI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykNCglUQUlMUV9JTklUKCZtc2dfcV9saXN0X2hlYWQpOw0KI2VuZGlmDQogICAgcmV0dXJuIEhNWF9PSzsNCn0NCg0KDQovKg0KICAgIEhNWF9NU0dfQ3JlYXRlDQogICAguN68vMH2IMWluKYgu/28usfRtNkuDQoqLw0KaW50IEhNWF9NU0dfQ3JlYXRlKHVuc2lnbmVkIGxvbmcgcV9jb3VudCwgdW5zaWduZWQgbG9uZyBtc2dfc2l6ZSwNCgljb25zdCBjaGFyICpxX25hbWUsIHVuc2lnbmVkIGxvbmcgKnFfaWQsIEhNWF9TVVNQRU5EVFlQRSBzdXNwZW5kVHlwZSkNCnsNCiAgICBzdHJ1Y3QgSE1YX01TR19xdWV1ZSAgICAgICAgICAgICAgICpxOw0KICAgIHN0cnVjdCBITVhfTVNHX2VsZW1lbnQgICAgICAgICAgICpxX2VsZW1lbnQ7DQogICAgdW5zaWduZWQgbG9uZwkJCQkJaTsNCiAgICBzdHJ1Y3QgSE1YX01TR19lbGVtZW50ICAgICAgICAgICAqcV9lbGVtZW50X3Bvb2w7DQoJdW5zaWduZWQgY2hhcgkJCQkJKmRhdGFfcG9vbDsNCglIQVBQWShxX25hbWUpOw0KDQogICAgUHJpbnRFbnRlcigpOw0KDQogICAgaWYoc3VzcGVuZFR5cGUgPj0gSE1YX1NVU1BFTkRUWVBFX01BWCkNCiAgICB7DQogICAgICAgIFByaW50RXJyb3IoIiVzWyVkXSA6IHVsU3VzcGVuZFR5cGUgJWQgRXJyb3JcbiIsIF9fRlVOQ1RJT05fXywgX19MSU5FX18sICBzdXNwZW5kVHlwZSk7DQogICAgICAgIHJldHVybiBITVhfRVJST1I7DQogICAgfQ0KDQogICAgaWYoKHEgPSAoc3RydWN0IEhNWF9NU0dfcXVldWUgKiltYWxsb2Moc2l6ZW9mKHN0cnVjdCBITVhfTVNHX3F1ZXVlKSkpID09IE5VTEwpDQogICAgew0KICAgICAgICBQcmludEVycm9yKCIlc1slZF0gOiBtYWxsb2MgRXJyb3JcbiIsIF9fRlVOQ1RJT05fXywgX19MSU5FX18pOw0KICAgICAgICByZXR1cm4gSE1YX0VSUk9SOw0KICAgIH0NCg0KCW1lbXNldChxLCAwLCBzaXplb2Yoc3RydWN0IEhNWF9NU0dfcXVldWUpKTsNCg0KICAgIGxpc3RfaW5pdChxLCBtc2dfc2l6ZSwgcV9jb3VudCwgc3VzcGVuZFR5cGUpOw0KCXFfZWxlbWVudF9wb29sID0gKHN0cnVjdCBITVhfTVNHX2VsZW1lbnQgKiltYWxsb2Moc2l6ZW9mKHN0cnVjdCBITVhfTVNHX2VsZW1lbnQpKnFfY291bnQpOw0KCWRhdGFfcG9vbCA9ICh1bnNpZ25lZCBjaGFyICopbWFsbG9jKG1zZ19zaXplKnFfY291bnQpOw0KICAgIGZvcihpPTA7IGk8cV9jb3VudDsgaSsrKQ0KICAgIHsNCgkJcV9lbGVtZW50ID0gJnFfZWxlbWVudF9wb29sW2ldOw0KCQlxX2VsZW1lbnQtPmRhdGEgPSAmZGF0YV9wb29sW2kqbXNnX3NpemVdOw0KICAgICAgICBxX2luc2VydF90ZW1wX3RhaWxfZWxlbWVudChxLCBxX2VsZW1lbnQpOw0KICAgIH0NCglxLT5wRGF0YVBvb2wgPSBkYXRhX3Bvb2w7DQoJcS0+cFBvb2wgPSBxX2VsZW1lbnRfcG9vbDsNCg0KICAgICpxX2lkID0gKHVuc2lnbmVkIGxvbmcpcTsNCg0KI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykNCglUQUlMUV9JTlNFUlRfVEFJTCgmbXNnX3FfbGlzdF9oZWFkLCBxLCBlbnRyaWVzKTsNCiNlbmRpZg0KI2lmIGRlZmluZWQoQ09ORklHX0RFQlVHKQ0KCWlmIChxX25hbWUpDQoJCXN0cm5jcHkocS0+bmFtZSwgcV9uYW1lLCBzaXplb2YocS0+bmFtZSktMSk7DQoJZWxzZQ0KCQlxLT5uYW1lWzBdID0gMDsNCiNlbmRpZg0KCVByaW50RXhpdCgpOw0KDQogICAgcmV0dXJuIEhNWF9PSzsNCn0NCg0KDQovKg0KICAgIEhNWF9NU0dfRGVzdHJveQ0KICAgILjevLzB9sWluKYgvNK46r3DxbK02S4NCiovDQppbnQgSE1YX01TR19EZXN0cm95KHVuc2lnbmVkIGxvbmcgcV9pZCkNCnsNCglzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqcTsNCg0KCVByaW50RW50ZXIoKTsNCg0KCXEgPSAoc3RydWN0IEhNWF9NU0dfcXVldWUgKilxX2lkOw0KDQoJaWYocSA9PSBOVUxMKQ0KCXsNCgkJcmV0dXJuIEhNWF9FUlJPUjsNCgl9DQoNCglwdGhyZWFkX2NvbmRfZGVzdHJveSgmcS0+cV9ub3RfZnVsbF8pOw0KCXB0aHJlYWRfY29uZF9kZXN0cm95KCZxLT5xX25vdF9lbXB0eV8pOw0KCXB0aHJlYWRfbXV0ZXhfZGVzdHJveSgmcS0+cV9sb2NrXyk7DQoNCglsaXN0X2Rlc3Ryb3kocSk7DQoJcV9kZXN0b3J5X3RlbXBfdGFpbChxKTsNCg0KI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykNCglUQUlMUV9SRU1PVkUoJm1zZ19xX2xpc3RfaGVhZCwgcSwgZW50cmllcyk7DQojZW5kaWYNCg0KCWlmKHEgIT0gTlVMTCkNCgl7DQoJCWZyZWUocSk7DQoJfQ0KDQoJUHJpbnRFeGl0KCk7DQoNCglyZXR1cm4gSE1YX09LOw0KfQ0KDQppbnQgSE1YX01TR19DbGVhcih1bnNpZ25lZCBsb25nIHFfaWQpDQp7DQoJc3RydWN0IEhNWF9NU0dfcXVldWUgCQkJICAqcTsNCglpbnQgcmMgPSBITVhfT0s7DQoJLy8JICBzdHJ1Y3QgdGltZXNwZWMgY3VyX3RpbWU7DQoJbG9uZyBsb25nIGV4cF9uc2VjOw0KCXN0cnVjdCB0aW1lc3BlYyB0aW1lbywgY3VyX3RpbWU7DQoJdW5zaWduZWQgbG9uZyBzaXplOw0KCXZvaWQJCQkqcEJ1ZjsNCg0KDQoJUHJpbnRFbnRlcigpOw0KDQoJcSA9IChzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqKXFfaWQ7DQoNCglzaXplID0gcS0+bXNnX3NpemVfOw0KCXBCdWYgPSBtYWxsb2Moc2l6ZSk7DQoJaWYgKHBCdWYgPT0gTlVMTCkNCgkJcmV0dXJuIEhNWF9FUlJPUjsNCg0KCSh2b2lkKXB0aHJlYWRfbXV0ZXhfbG9jaygmcS0+cV9sb2NrXyk7DQoJZG8NCgl7DQoNCgkJY2xvY2tfZ2V0dGltZShDTE9DS19SRUFMVElNRSwgJmN1cl90aW1lKTsNCgkJZXhwX25zZWMgPSAobG9uZyBsb25nKWN1cl90aW1lLnR2X3NlYyAqIChsb25nIGxvbmcpMTAwMCAqIChsb25nIGxvbmcpMTAwMCAqIChsb25nIGxvbmcpMTAwMCArIChsb25nIGxvbmcpY3VyX3RpbWUudHZfbnNlYzsNCgkJdGltZW8udHZfc2VjID0gZXhwX25zZWMgLyAoMTAwMCAqIDEwMDAgKiAxMDAwKTsNCgkJdGltZW8udHZfbnNlYyA9IGV4cF9uc2VjICUgKDEwMDAgKiAxMDAwICogMTAwMCk7DQoNCgkJcmMgPSBsaXN0X3JlbV9uZXh0KHEsIHBCdWYsIHNpemUsIFRSVUUsICZ0aW1lbyk7DQoJCWlmKEhNWF9PSyAhPSByYykNCgkJew0KCQkJaWYoRVRJTUVET1VUID09IHJjKQ0KCQkJew0KCQkJCSh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCgkJCQlmcmVlKHBCdWYpOw0KCQkJCXJldHVybiBITVhfT0s7DQoJCQl9DQoJCX0NCgl9d2hpbGUgKDEpOw0KI2lmZGVmIERFQlVHX01TR19MSVNUX1BSSU5UDQoJcHJpbnRfbGlzdChxKTsNCiNlbmRpZg0KDQoJKHZvaWQpcHRocmVhZF9tdXRleF91bmxvY2soJnEtPnFfbG9ja18pOw0KDQoJZnJlZShwQnVmKTsNCglQcmludEV4aXQoKTsNCglyZXR1cm4gSE1YX09LOw0KfQ0KDQoNCi8qDQogICAgSE1YX01TR19TZW5kDQogICAguN68vMH2uKYgurizvbTZLg0KKi8NCmludCBITVhfTVNHX1NlbmQodW5zaWduZWQgbG9uZyBxX2lkLCBjb25zdCB2b2lkICptc2csIHVuc2lnbmVkIGxvbmcgc2l6ZSkNCnsNCiAgICBzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqcTsNCiAgICBpbnQgcmMgPSBITVhfT0s7DQogICAgdW5zaWduZWQgbG9uZyBwcmlvOw0KDQogICAgUHJpbnRFbnRlcigpOw0KDQogICAgcSA9IChzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqKXFfaWQ7DQoNCiAgICBpZihzaXplID4gcS0+bXNnX3NpemVfKQ0KICAgIHsNCiAgICAgICAgUHJpbnRFcnJvcigiJXNbJWRdIDogc2l6ZSAlbGQgRXJyb3JcbiIsIF9fRlVOQ1RJT05fXywgX19MSU5FX18sIHNpemUpOw0KICAgICAgICByZXR1cm4gSE1YX0VSUk9SOw0KICAgIH0NCg0KCUhNWF9UQVNLX0NoZWNrQ2FsbGJhY2soKTsNCg0KCXJjID0gUF9NU0dfQ2hlY2socSwgcV9pZCk7DQoJaWYgKEhNWF9PSyAhPSByYykNCgl7DQojaWYgZGVmaW5lZChDT05GSUdfREVCVUcpDQoJCVByaW50RXJyb3IoIiVzKCVkKSA6IFBfTVNHX0NoZWNrIDogSE1YX01TR19GVUxMISEgcXVldWUgbmFtZSAoJXMpXG4iLCBfX2Z1bmNfXywgX19MSU5FX18sIHEtPm5hbWUpOw0KI2VuZGlmDQoJCXJldHVybiByYzsNCgl9DQoNCiAgICBpZihITVhfU1VTUEVORFRZUEVfUFJJT1JJVFkgPT0gcS0+c3VzcGVuZF90eXBlXykNCiAgICB7DQogICAgICAgIHJjID0gbGlzdF9maW5kX21zZ19xX3ByaW9yaXR5X2Zyb21fdGFza19wcmlvcml0eSgmcHJpbyk7DQogICAgICAgIGlmKHJjICE9IEhNWF9PSykNCiAgICAgICAgew0KCQkJcHJpbyA9IE1TR19QUklPUklUWTA7DQogICAgICAgIH0NCiAgICB9DQogICAgZWxzZQ0KICAgIHsNCiAgICAgICAgcHJpbyA9IE1TR19QUklPUklUWTA7DQogICAgfQ0KDQogICAgKHZvaWQpcHRocmVhZF9tdXRleF9sb2NrKCZxLT5xX2xvY2tfKTsNCg0KICAgIHJjID0gbGlzdF9pbnNfbmV4dChxLCBwcmlvLCBtc2csIHNpemUsIEZBTFNFLCBOVUxMKTsNCg0KICAgIGlmKEhNWF9PSyAhPSByYykNCiAgICB7DQogICAgICAgIFByaW50RXJyb3IoIiVzIDogbGlzdF9pbnNfbmV4dCgpIHJjWyVkXSBFcnJvciEhXG4iLCBfX0ZVTkNUSU9OX18sIHJjKTsNCiAgICAgICAgKHZvaWQpcHRocmVhZF9tdXRleF91bmxvY2soJnEtPnFfbG9ja18pOw0KICAgICAgICByZXR1cm4gcmM7DQogICAgfQ0KDQojaWZkZWYgREVCVUdfTVNHX0xJU1RfUFJJTlQNCiAgICBwcmludF9saXN0KHEpOw0KI2VuZGlmDQoNCiAgICAodm9pZClwdGhyZWFkX211dGV4X3VubG9jaygmcS0+cV9sb2NrXyk7DQoNCiNpZmRlZiBITVhfTVNHX0RFQlVHDQogICAgcS0+bGFzdFNlbmRUaWNrID0gVktfVElNRVJfR2V0U3lzdGVtVGljaygpOw0KI2VuZGlmDQoNCiAgICBQcmludEV4aXQoKTsNCg0KICAgIHJldHVybiBITVhfT0s7DQp9DQoNCg0KDQovKg0KICAgIEhNWF9NU0dfU2VuZFRpbWVvdXQNCiAgICC43ry8wfa4piBUaW1lb3V0s7u/oSC6uLO9tNkuDQoqLw0KaW50IEhNWF9NU0dfU2VuZFRpbWVvdXQodW5zaWduZWQgbG9uZyBxX2lkLCBjb25zdCB2b2lkICptc2csIHVuc2lnbmVkIGxvbmcgc2l6ZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KQ0Kew0KCXN0cnVjdCBITVhfTVNHX3F1ZXVlICpxOw0KCWludCByYyA9IEhNWF9PSzsNCgl1bnNpZ25lZCBsb25nIHByaW8gPSAwOw0KCXN0cnVjdCB0aW1lc3BlYyB0aW1lbzsNCglzdHJ1Y3QgdGltZXNwZWMgY3VyX3RpbWU7DQoJbG9uZyBsb25nIGV4cF9uc2VjOw0KDQoJUHJpbnRFbnRlcigpOw0KDQoJaWYgKHRpbWVvdXQgIT0gMCkNCgl7DQovLwkJSE1YX1RBU0tfQ2hlY2tDYWxsYmFjaygpOw0KCX0NCglpZiAodGltZW91dCA9PSAweEZGRkZGRkZGKQ0KCXsNCgkJcmV0dXJuIEhNWF9NU0dfU2VuZChxX2lkLCBtc2csIHNpemUpOw0KCX0NCg0KCXEgPSAoc3RydWN0IEhNWF9NU0dfcXVldWUgKilxX2lkOw0KDQoJaWYoc2l6ZSA+IHEtPm1zZ19zaXplXykNCgl7DQoJCVByaW50RXJyb3IoIiVzWyVkXSA6IHNpemUgJWxkIEVycm9yXG4iLCBfX0ZVTkNUSU9OX18sIF9fTElORV9fLCBzaXplKTsNCgkJcmV0dXJuIEhNWF9FUlJPUjsNCgl9DQoNCglyYyA9IFBfTVNHX0NoZWNrKHEsIHFfaWQpOw0KCWlmIChITVhfT0sgIT0gcmMpDQoJew0KI2lmIGRlZmluZWQoQ09ORklHX0RFQlVHKQ0KCQlQcmludEVycm9yKCIlcyglZCkgOiBQX01TR19DaGVjayA6IEhNWF9NU0dfRlVMTCEhIHF1ZXVlIG5hbWUgOiAlc1xuIiwgX19mdW5jX18sIF9fTElORV9fLCBxLT5uYW1lKTsNCiNlbmRpZg0KCQlyZXR1cm4gcmM7DQoJfQ0KDQoJaWYoSE1YX1NVU1BFTkRUWVBFX1BSSU9SSVRZID09IHEtPnN1c3BlbmRfdHlwZV8pDQoJew0KCQlyYyA9IGxpc3RfZmluZF9tc2dfcV9wcmlvcml0eV9mcm9tX3Rhc2tfcHJpb3JpdHkoJnByaW8pOw0KCQlpZihyYyAhPSBITVhfT0spDQoJCXsNCgkJCXByaW8gPSBNU0dfUFJJT1JJVFkwOw0KCQl9DQoJfQ0KCWVsc2UNCgl7DQoJCXByaW8gPSBNU0dfUFJJT1JJVFkwOw0KCX0NCg0KCWNsb2NrX2dldHRpbWUoQ0xPQ0tfUkVBTFRJTUUsICZjdXJfdGltZSk7DQoJZXhwX25zZWMgPSAobG9uZyBsb25nKWN1cl90aW1lLnR2X3NlYyAqIDEwMDAgKiAxMDAwICogMTAwMCArIGN1cl90aW1lLnR2X25zZWM7DQoJaWYgKHRpbWVvdXQgIT0gMCkNCgkJZXhwX25zZWMgKz0gKHRpbWVvdXQgKiAxMDAwIC0gOTk5KSAqIDEwMDA7DQoJdGltZW8udHZfc2VjID0gZXhwX25zZWMgLyAoMTAwMCAqIDEwMDAgKiAxMDAwKTsNCgl0aW1lby50dl9uc2VjID0gZXhwX25zZWMgJSAoMTAwMCAqIDEwMDAgKiAxMDAwKTsNCg0KCSh2b2lkKXB0aHJlYWRfbXV0ZXhfbG9jaygmcS0+cV9sb2NrXyk7DQoNCglyYyA9IGxpc3RfaW5zX25leHQocSwgcHJpbywgbXNnLCBzaXplLCBUUlVFLCAmdGltZW8pOw0KCWlmKEhNWF9PSyAhPSByYykNCgl7DQoJICAgICh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCg0KCSAgICBpZihFVElNRURPVVQgPT0gcmMpDQoJICAgIHsNCgkgICAgICAgIFByaW50RGVidWcoIiVzIDogbGlzdF9pbnNfbmV4dCgpIHJjWyVkXSBITVhfVElNRU9VVCEhXG4iLCBfX0ZVTkNUSU9OX18sIHJjKTsNCgkgICAgICAgIHJldHVybiBITVhfVElNRU9VVDsNCgkgICAgfQ0KCSAgICBlbHNlDQoJICAgIHsNCgkgICAgICAgIFByaW50RXJyb3IoIiVzIDogbGlzdF9pbnNfbmV4dCgpIHJjWyVkXSBFcnJvciEhXG4iLCBfX0ZVTkNUSU9OX18sIHJjKTsNCgkgICAgICAgIHJldHVybiBITVhfRVJST1I7DQoJICAgIH0NCgl9DQoNCiNpZmRlZiBERUJVR19NU0dfTElTVF9QUklOVA0KCXByaW50X2xpc3QocSk7DQojZW5kaWYNCg0KCSh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCg0KCVByaW50RXhpdCgpOw0KDQoJcmV0dXJuIEhNWF9PSzsNCn0NCg0KDQovKg0KICAgIEhNWF9NU0dfU2VuZFVyZ2VudA0KICAgILHksd4guN68vMH2uKYgurizvbTZLg0KKi8NCmludCBITVhfTVNHX1NlbmRVcmdlbnQodW5zaWduZWQgbG9uZyBxX2lkLCBjb25zdCB2b2lkICptc2csIHVuc2lnbmVkIGxvbmcgc2l6ZSkNCnsNCiAgICBzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqcTsNCiAgICBpbnQgcmMgPSBITVhfT0s7DQogICAgdW5zaWduZWQgbG9uZyBwcmlvOw0KDQogICAgUHJpbnRFbnRlcigpOw0KDQogICAgcSA9IChzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqKXFfaWQ7DQoNCiAgICBpZihzaXplID4gcS0+bXNnX3NpemVfKQ0KICAgIHsNCiAgICAgICAgUHJpbnRFcnJvcigiJXNbJWRdIDogc2l6ZSAlbGQgRXJyb3JcbiIsIF9fRlVOQ1RJT05fXywgX19MSU5FX18sIHNpemUpOw0KICAgICAgICByZXR1cm4gSE1YX0VSUk9SOw0KICAgIH0NCg0KCXJjID0gUF9NU0dfQ2hlY2socSwgcV9pZCk7DQoJaWYgKEhNWF9PSyAhPSByYykNCgl7DQojaWYgZGVmaW5lZChDT05GSUdfREVCVUcpDQoJCVByaW50RXJyb3IoIiVzKCVkKSA6IFBfTVNHX0NoZWNrIDogSE1YX01TR19GVUxMISEgcXVldWUgbmFtZSAoJXMpXG4iLCBfX2Z1bmNfXywgX19MSU5FX18sIHEtPm5hbWUpOw0KI2VuZGlmDQoJCXJldHVybiByYzsNCgl9DQoNCiAgICBpZihITVhfU1VTUEVORFRZUEVfUFJJT1JJVFkgPT0gcS0+c3VzcGVuZF90eXBlXykNCiAgICB7DQogICAgICAgIHByaW8gPSBNU0dfUFJJT1JJVFlfTUFYLTE7IC8vsKHA5SCz9MC6IL/svLG8+MCnt84gurizvbTZLg0KICAgIH0NCiAgICBlbHNlDQogICAgew0KICAgICAgICBwcmlvID0gTVNHX1BSSU9SSVRZMDsNCiAgICB9DQoNCiAgICAodm9pZClwdGhyZWFkX211dGV4X2xvY2soJnEtPnFfbG9ja18pOw0KDQogICAgcmMgPSBsaXN0X2luc19uZXh0KHEsIHByaW8sIG1zZywgc2l6ZSwgRkFMU0UsIEZBTFNFKTsNCiAgICBpZihITVhfT0sgIT0gcmMpDQogICAgew0KICAgICAgICBQcmludEVycm9yKCIlcyA6IGxpc3RfaW5zX25leHQoKSByY1slZF0gRXJyb3IhIVxuIiwgX19GVU5DVElPTl9fLCByYyk7DQogICAgICAgICh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCiAgICAgICAgcmV0dXJuIHJjOw0KICAgIH0NCg0KI2lmZGVmIERFQlVHX01TR19MSVNUX1BSSU5UDQogICAgcHJpbnRfbGlzdChxKTsNCiNlbmRpZg0KDQogICAgKHZvaWQpcHRocmVhZF9tdXRleF91bmxvY2soJnEtPnFfbG9ja18pOw0KDQojaWZkZWYgSE1YX01TR19ERUJVRw0KICAgIHEtPmxhc3RTZW5kVGljayA9IFZLX1RJTUVSX0dldFN5c3RlbVRpY2soKTsNCiNlbmRpZg0KDQogICAgUHJpbnRFeGl0KCk7DQoNCiAgICByZXR1cm4gSE1YX09LOw0KfQ0KDQoNCi8qDQogICAgSE1YX01TR19TZW5kVXJnZW50VGltZW91dA0KICAgILHksd4guN68vMH2uKYgVGltZW91dCCzu7+hILq4s7202S4NCiovDQppbnQgSE1YX01TR19TZW5kVXJnZW50VGltZW91dCh1bnNpZ25lZCBsb25nIHFfaWQsIGNvbnN0IHZvaWQgKm1zZywgdW5zaWduZWQgbG9uZyBzaXplLCB1bnNpZ25lZCBsb25nIHRpbWVvdXQpDQp7DQoJc3RydWN0IEhNWF9NU0dfcXVldWUgKnE7DQoJaW50IHJjID0gSE1YX09LOw0KCXVuc2lnbmVkIGxvbmcgcHJpbyA9IDA7DQoJc3RydWN0IHRpbWVzcGVjIHRpbWVvOw0KCXN0cnVjdCB0aW1lc3BlYyBjdXJfdGltZTsNCglsb25nIGxvbmcgZXhwX25zZWM7DQoNCglQcmludEVudGVyKCk7DQoNCglpZiAodGltZW91dCA9PSAweEZGRkZGRkZGKQ0KCXsNCgkJcmV0dXJuIEhNWF9NU0dfU2VuZFVyZ2VudChxX2lkLCBtc2csIHNpemUpOw0KCX0NCg0KCXEgPSAoc3RydWN0IEhNWF9NU0dfcXVldWUgKilxX2lkOw0KDQoJaWYoc2l6ZSA+IHEtPm1zZ19zaXplXykNCgl7DQoJICAgIFByaW50RXJyb3IoIiVzWyVkXSA6IHNpemUgJWxkIEVycm9yXG4iLCBfX0ZVTkNUSU9OX18sIF9fTElORV9fLCBzaXplKTsNCgkgICAgcmV0dXJuIEhNWF9FUlJPUjsNCgl9DQoNCglyYyA9IFBfTVNHX0NoZWNrKHEsIHFfaWQpOw0KCWlmIChITVhfT0sgIT0gcmMpDQoJew0KI2lmIGRlZmluZWQoQ09ORklHX0RFQlVHKQ0KCQlQcmludEVycm9yKCIlcyglZCkgOiBQX01TR19DaGVjayA6IEhNWF9NU0dfRlVMTCEhIHF1ZXVlIG5hbWUoJXMpXG4iLCBfX2Z1bmNfXywgX19MSU5FX18sIHEtPm5hbWUpOw0KI2VuZGlmDQoJCXJldHVybiByYzsNCgl9DQoNCglpZihITVhfU1VTUEVORFRZUEVfUFJJT1JJVFkgPT0gcS0+c3VzcGVuZF90eXBlXykNCgl7DQoJICAgIHByaW8gPSBNU0dfUFJJT1JJVFlfTUFYLTE7IC8vsKHA5SCz9MC6IL/svLG8+MCnt84gurizvbTZLg0KCX0NCgllbHNlDQoJew0KCSAgICBwcmlvID0gTVNHX1BSSU9SSVRZMDsNCgl9DQoNCgljbG9ja19nZXR0aW1lKENMT0NLX1JFQUxUSU1FLCAmY3VyX3RpbWUpOw0KCWV4cF9uc2VjID0gKGxvbmcgbG9uZyljdXJfdGltZS50dl9zZWMgKiAxMDAwICogMTAwMCAqIDEwMDAgKyBjdXJfdGltZS50dl9uc2VjOw0KCWlmICh0aW1lb3V0ICE9IDApDQoJCWV4cF9uc2VjICs9ICh0aW1lb3V0ICogMTAwMCAtIDk5OSkgKiAxMDAwOw0KCXRpbWVvLnR2X3NlYyA9IGV4cF9uc2VjIC8gKDEwMDAgKiAxMDAwICogMTAwMCk7DQoJdGltZW8udHZfbnNlYyA9IGV4cF9uc2VjICUgKDEwMDAgKiAxMDAwICogMTAwMCk7DQoNCgkodm9pZClwdGhyZWFkX211dGV4X2xvY2soJnEtPnFfbG9ja18pOw0KDQoJcmMgPSBsaXN0X2luc19uZXh0KHEsIHByaW8sIG1zZywgc2l6ZSwgVFJVRSwgJnRpbWVvKTsNCg0KCWlmKEhNWF9PSyAhPSByYykNCgl7DQoJICAgICh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCg0KCSAgICBpZihFVElNRURPVVQgPT0gcmMpDQoJICAgIHsNCgkgICAgICAgIFByaW50RGVidWcoIiVzIDogbGlzdF9pbnNfbmV4dCgpIHJjWyVkXSBITVhfVElNRU9VVCEhXG4iLCBfX0ZVTkNUSU9OX18sIHJjKTsNCgkgICAgICAgIHJldHVybiBITVhfVElNRU9VVDsNCgkgICAgfQ0KCSAgICBlbHNlDQoJICAgIHsNCgkgICAgICAgIFByaW50RXJyb3IoIiVzIDogbGlzdF9pbnNfbmV4dCgpIHJjWyVkXSBFcnJvciEhXG4iLCBfX0ZVTkNUSU9OX18sIHJjKTsNCgkgICAgICAgIHJldHVybiBITVhfRVJST1I7DQoJICAgIH0NCgl9DQoNCiNpZmRlZiBERUJVR19NU0dfTElTVF9QUklOVA0KCXByaW50X2xpc3QocSk7DQojZW5kaWYNCg0KCSh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCg0KCVByaW50RXhpdCgpOw0KDQoJcmV0dXJuIEhNWF9PSzsNCn0NCg0KI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykgJiYgZGVmaW5lZChWS19UQVNLX0RFQlVHKQ0KI2RlZmluZSBITVhfTVNHX0NSSVRJQ0FMX0RFTEFZX1RJQ0sJMjANCiNkZWZpbmUgSE1YX01TR19OT1JNQUxfREVMQVlfVElDSwkyMDANCiNlbmRpZg0KLyoNCiAgICBITVhfTVNHX1JlY2VpdmUNCiAgICC43ry8wfa4piC53rTCtNkuDQoqLw0KaW50IEhNWF9NU0dfUmVjZWl2ZSh1bnNpZ25lZCBsb25nIHFfaWQsIHZvaWQgKm1zZywgdW5zaWduZWQgbG9uZyBzaXplKQ0Kew0KICAgIHN0cnVjdCBITVhfTVNHX3F1ZXVlICAgICAgICAgICAgICAgKnE7DQovLyAgdW5zaWduZWQgbG9uZyBwcmlvOw0KICAgIGludCByYyA9IEhNWF9PSzsNCg0KICAgIFByaW50RW50ZXIoKTsNCg0KCUhNWF9UQVNLX0NoZWNrQ2FsbGJhY2soKTsNCg0KICAgIHEgPSAoc3RydWN0IEhNWF9NU0dfcXVldWUgKilxX2lkOw0KDQogICAgaWYoc2l6ZSA+IHEtPm1zZ19zaXplXykNCiAgICB7DQogICAgICAgIFByaW50RXJyb3IoIiVzIDogc2l6ZSAlbGQgRXJyb3IhIVxuIiwgX19GVU5DVElPTl9fLCBzaXplKTsNCiAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICB9DQoNCiAgICAodm9pZClwdGhyZWFkX211dGV4X2xvY2soJnEtPnFfbG9ja18pOw0KDQojaWYgZGVmaW5lZChITVhfTVNHX0RFQlVHKSAmJiBkZWZpbmVkKFZLX1RBU0tfREVCVUcpDQoJcS0+cmVjZWl2ZVRpY2sgPSBWS19USU1FUl9HZXRTeXN0ZW1UaWNrKCk7DQoJaWYgKHEtPmxhc3RSZWNlaXZlVGljayAhPSAwICYmIChxLT5yZWNlaXZlVGljayAtIHEtPmxhc3RSZWNlaXZlVGljayA+IEhNWF9NU0dfTk9STUFMX0RFTEFZX1RJQ0spKQ0KCXsNCgkJaWYgKChxLT5yZWNlaXZlVGljayAtIHRpY2tGb3JWa0RlYnVnKSA+IEhNWF9NU0dfQ1JJVElDQUxfREVMQVlfVElDSykNCgkJew0KCQkJUHJpbnRFcnJvcigiSE1YX01TR19SZWNlaXZlIDogSXQgaGFzIGV4Y3V0ZWQgdG9vIGxvbmcgdGltZSAoJWQpIHF1ZXVlKCVzKVxuIiwgcS0+cmVjZWl2ZVRpY2sgLSBxLT5sYXN0UmVjZWl2ZVRpY2ssIHEtPm5hbWUpOw0KCQl9DQoJfQ0KI2VuZGlmDQogICAgcmMgPSBsaXN0X3JlbV9uZXh0KHEsIG1zZywgc2l6ZSwgRkFMU0UsIE5VTEwpOw0KI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykgJiYgZGVmaW5lZChWS19UQVNLX0RFQlVHKQ0KCXEtPmxhc3RSZWNlaXZlVGljayA9IHRpY2tGb3JWa0RlYnVnID0gVktfVElNRVJfR2V0U3lzdGVtVGljaygpOw0KI2VuZGlmDQogICAgaWYoSE1YX09LICE9IHJjKQ0KICAgIHsNCiAgICAgICAgUHJpbnRFcnJvcigiJXMgOiBsaXN0X3JlbV9uZXh0KCkgcmNbJWRdIEVycm9yISFcbiIsIF9fRlVOQ1RJT05fXywgcmMpOw0KICAgICAgICAodm9pZClwdGhyZWFkX211dGV4X3VubG9jaygmcS0+cV9sb2NrXyk7DQogICAgICAgIHJldHVybiByYzsNCiAgICB9DQoNCiNpZmRlZiBERUJVR19NU0dfTElTVF9QUklOVA0KICAgIHByaW50X2xpc3QocSk7DQojZW5kaWYNCiAgICAodm9pZClwdGhyZWFkX211dGV4X3VubG9jaygmcS0+cV9sb2NrXyk7DQoNCiAgICBQcmludEV4aXQoKTsNCiAgICByZXR1cm4gSE1YX09LOw0KfQ0KDQovKg0KICAgIEhNWF9NU0dfUmVjZWl2ZVRpbWVvdXQNCiAgICC43ry8wfa4piBUaW1lb3V0s7u/oSC53rTCtNkuDQoqLw0KaW50IEhNWF9NU0dfUmVjZWl2ZVRpbWVvdXQodW5zaWduZWQgbG9uZyBxX2lkLCB2b2lkICptc2csIHVuc2lnbmVkIGxvbmcgc2l6ZSwgdW5zaWduZWQgbG9uZyB0aW1lb3V0KQ0Kew0KCXN0cnVjdCBITVhfTVNHX3F1ZXVlICAgICAgICAgICAgICAgKnE7DQoJaW50IHJjID0gSE1YX09LOw0KCS8vICAgIHN0cnVjdCB0aW1lc3BlYyBjdXJfdGltZTsNCglsb25nIGxvbmcgZXhwX25zZWM7DQoJc3RydWN0IHRpbWVzcGVjIHRpbWVvLCBjdXJfdGltZTsNCg0KCVByaW50RW50ZXIoKTsNCglpZiAodGltZW91dCAhPSAwKQ0KCXsNCgkJSE1YX1RBU0tfQ2hlY2tDYWxsYmFjaygpOw0KCX0NCg0KCWlmICh0aW1lb3V0ID09IDB4RkZGRkZGRkYpDQoJew0KCQlyZXR1cm4gSE1YX01TR19SZWNlaXZlKHFfaWQsIG1zZywgc2l6ZSk7DQoJfQ0KDQoJcSA9IChzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqKXFfaWQ7DQoNCglpZihzaXplID4gcS0+bXNnX3NpemVfKQ0KCXsNCgkJUHJpbnRFcnJvcigiJXMgOiBzaXplICVsZCBFcnJvciEhXG4iLCBfX0ZVTkNUSU9OX18sIHNpemUpOw0KCQlyZXR1cm4gSE1YX0VSUk9SOw0KCX0NCg0KCWNsb2NrX2dldHRpbWUoQ0xPQ0tfUkVBTFRJTUUsICZjdXJfdGltZSk7DQoJZXhwX25zZWMgPSAobG9uZyBsb25nKWN1cl90aW1lLnR2X3NlYyAqIChsb25nIGxvbmcpMTAwMCAqIChsb25nIGxvbmcpMTAwMCAqIChsb25nIGxvbmcpMTAwMCArIChsb25nIGxvbmcpY3VyX3RpbWUudHZfbnNlYzsNCglpZiAodGltZW91dCAhPSAwKQ0KCQlleHBfbnNlYyArPSAobG9uZyBsb25nKSh0aW1lb3V0ICogKGxvbmcgbG9uZykxMDAwIC0gOTk5KSAqIChsb25nIGxvbmcpMTAwMDsNCgl0aW1lby50dl9zZWMgPSBleHBfbnNlYyAvICgxMDAwICogMTAwMCAqIDEwMDApOw0KCXRpbWVvLnR2X25zZWMgPSBleHBfbnNlYyAlICgxMDAwICogMTAwMCAqIDEwMDApOw0KDQoJKHZvaWQpcHRocmVhZF9tdXRleF9sb2NrKCZxLT5xX2xvY2tfKTsNCiNpZiBkZWZpbmVkKEhNWF9NU0dfREVCVUcpICYmIGRlZmluZWQoVktfVEFTS19ERUJVRykNCglxLT5yZWNlaXZlVGljayA9IFZLX1RJTUVSX0dldFN5c3RlbVRpY2soKTsNCglpZiAocS0+bGFzdFJlY2VpdmVUaWNrICE9IDAgJiYgKHEtPnJlY2VpdmVUaWNrIC0gcS0+bGFzdFJlY2VpdmVUaWNrID4gSE1YX01TR19OT1JNQUxfREVMQVlfVElDSykpDQoJew0KCQlpZiAoKHEtPnJlY2VpdmVUaWNrIC0gdGlja0ZvclZrRGVidWcpID4gSE1YX01TR19DUklUSUNBTF9ERUxBWV9USUNLKQ0KCQl7DQoJCQlQcmludEVycm9yKCJITVhfTVNHX1JlY2VpdmVUaW1lb3V0IDogSXQgaGFzIGV4Y3V0ZWQgdG9vIGxvbmcgdGltZSAoJWQpIHF1ZXVlKCVzKVxuIiwgcS0+cmVjZWl2ZVRpY2sgLSBxLT5sYXN0UmVjZWl2ZVRpY2ssIHEtPm5hbWUpOw0KCQl9DQoJfQ0KI2VuZGlmDQoNCglyYyA9IGxpc3RfcmVtX25leHQocSwgbXNnLCBzaXplLCBUUlVFLCAmdGltZW8pOw0KI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykgJiYgZGVmaW5lZChWS19UQVNLX0RFQlVHKQ0KCXEtPmxhc3RSZWNlaXZlVGljayA9IHRpY2tGb3JWa0RlYnVnID0gVktfVElNRVJfR2V0U3lzdGVtVGljaygpOw0KI2VuZGlmDQoJaWYoSE1YX09LICE9IHJjKQ0KCXsNCiAgICAgICAgKHZvaWQpcHRocmVhZF9tdXRleF91bmxvY2soJnEtPnFfbG9ja18pOw0KDQogICAgICAgIGlmKEVUSU1FRE9VVCA9PSByYykNCiAgICAgICAgew0KICAgICAgICAgICAgUHJpbnREZWJ1ZygiJXMgOiBsaXN0X3JlbV9uZXh0KCkgcmNbJWRdIEhNWF9USU1FT1VUISFcbiIsIF9fRlVOQ1RJT05fXywgcmMpOw0KICAgICAgICAgICAgcmV0dXJuIEhNWF9USU1FT1VUOw0KICAgICAgICB9DQogICAgICAgIGVsc2UNCiAgICAgICAgew0KICAgICAgICAgICAgUHJpbnRFcnJvcigiJXMgOiBsaXN0X3JlbV9uZXh0KCkgcmNbJWRdIEVycm9yISFcbiIsIF9fRlVOQ1RJT05fXywgcmMpOw0KICAgICAgICAgICAgcmV0dXJuIEhNWF9FUlJPUjsNCiAgICAgICAgfQ0KCX0NCg0KI2lmZGVmIERFQlVHX01TR19MSVNUX1BSSU5UDQoJcHJpbnRfbGlzdChxKTsNCiNlbmRpZg0KDQoJKHZvaWQpcHRocmVhZF9tdXRleF91bmxvY2soJnEtPnFfbG9ja18pOw0KDQoJUHJpbnRFeGl0KCk7DQoJcmV0dXJuIEhNWF9PSzsNCn0NCg0KaW50CUhNWF9NU0dfR2V0TWVzc2FnZUNvdW50KHVuc2lnbmVkIGxvbmcgcV9pZCwgdW5zaWduZWQgbG9uZyAqcHVsTXNnQ291bnQsIHVuc2lnbmVkIGxvbmcgKnB1bE1heE1zZ0NvdW50KQ0Kew0KICAgIHN0cnVjdCBITVhfTVNHX3F1ZXVlICpxOw0KDQogICAgUHJpbnRFbnRlcigpOw0KDQogICAgcSA9IChzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqKXFfaWQ7DQoNCgkodm9pZClwdGhyZWFkX211dGV4X2xvY2soJnEtPnFfbG9ja18pOw0KCSpwdWxNc2dDb3VudCA9IHEtPmN1cnJfbXNnX2NvdW50XzsNCgkqcHVsTWF4TXNnQ291bnQgPSBxLT5tc2dfY291bnRfOw0KCSh2b2lkKXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZxLT5xX2xvY2tfKTsNCg0KCVByaW50RXhpdCgpOw0KCXJldHVybiBITVhfT0s7DQp9DQoNCnN0YXRpYyBpbnQgUF9NU0dfQ2hlY2soc3RydWN0IEhNWF9NU0dfcXVldWUgKnEsIHVuc2lnbmVkIGxvbmcgcV9pZCkNCnsNCgl1bnNpZ25lZCBsb25nIHVsTmVhcmx5RnVsbENvdW50Ow0KI2lmICFkZWZpbmVkKENPTkZJR19ERUJVRykNCglVTlVTRUQocV9pZCk7DQojZW5kaWYNCg0KCXVsTmVhcmx5RnVsbENvdW50ID0gKHEtPm1zZ19jb3VudF8gKiAzKTsNCgl1bE5lYXJseUZ1bGxDb3VudCA9IHVsTmVhcmx5RnVsbENvdW50LzQ7DQoNCglpZihxLT5tc2dfY291bnRfID09IHEtPmN1cnJfbXNnX2NvdW50XykNCgl7DQojaWYgZGVmaW5lZChDT05GSUdfREVCVUcpDQoJCWlmIChWS19USU1FUl9HZXRTeXN0ZW1UaWNrKCkgLSB0aWNrRm9yVmtEZWJ1ZyA+IDUwMDApDQoJCXsNCgkJCXRpY2tGb3JWa0RlYnVnID0gVktfVElNRVJfR2V0U3lzdGVtVGljaygpOw0KCQkJLy8gcXVldWUgaXMgZnVsbC4NCiNpZiBkZWZpbmVkKENPTkZJR19ERUJVRykNCgkJCVByaW50RXJyb3IoIlxuISFcbiEhISAlcygpOiBXQVJOSU5HOiBxdWV1ZV9pZCAweCVYLCBuYW1lOiVzIGZ1bGwgISEhJWNcbiEhIVxuIiwgX19GVU5DVElPTl9fLCBxX2lkLCBxLT5uYW1lLCA3KTsNCgkjaWYgZGVmaW5lZChWS19UQVNLX0RFQlVHKQ0KCQkJVktfVEFTS19QcmludFRhc2tMaXN0KCk7DQoJI2VuZGlmDQoJI2lmIGRlZmluZWQoSE1YX01TR19ERUJVRykNCgkJCUhNWF9NU0dfUHJpbnRNc2dRTGlzdCgpOw0KCSNlbmRpZg0KCSNpZiBkZWZpbmVkKFZLX1NFTV9ERUJVRykNCgkJCVZLX1NFTV9QcmludFNlbUxpc3QoKTsNCgkjZW5kaWYNCiNlbHNlDQoJCQlQcmludEVycm9yKCJcbiEhXG4hISEgJXMoKTogV0FSTklORzogcXVldWVfaWQgMHglWCwgZnVsbCAhISElY1xuISEhXG4iLCBfX0ZVTkNUSU9OX18sIHFfaWQsIDcpOw0KI2VuZGlmDQoJCX0NCiNlbmRpZg0KCQlyZXR1cm4gSE1YX01TR19GVUxMOw0KCX0NCgllbHNlIGlmKCBxLT5jdXJyX21zZ19jb3VudF8gPiB1bE5lYXJseUZ1bGxDb3VudCApDQoJew0KI2lmIGRlZmluZWQoQ09ORklHX0RFQlVHKQ0KCQlQcmludEVycm9yKCJbSE1YX01TR19TZW5kXSBNc2dRdWUgaXMgbmVhcmx5IGZ1bGwgLSBTZW5kVGFzazolZCwgUXVlSWQ6MHglWCwgKCVsZCwgJWxkKSwgbmFtZTolc1xyXG4iLA0KCQkJCXB0aHJlYWRfc2VsZigpLCBxX2lkLCBxLT5tc2dfY291bnRfLCBxLT5jdXJyX21zZ19jb3VudF8sIHEtPm5hbWUpOw0KI2VuZGlmDQoJfQ0KDQoJcmV0dXJuIEhNWF9PSzsNCn0NCg0KDQovKg0KICAgIEhNWF9NU0dfUHJpbnRNc2dRTGlzdA0KICAgILjevLzB9sWlIMGkuri4piDD4rfCx9G02S4NCiovDQojaWYgZGVmaW5lZChITVhfTVNHX0RFQlVHKQ0Kdm9pZCBITVhfTVNHX1ByaW50TXNnUUxpc3Qodm9pZCkNCnsNCglISU5UMzIJdWxDbnQ9MDsNCglzdHJ1Y3QgSE1YX01TR19xdWV1ZSAqcE1zZ1E7DQoNCiAgICBQcmludERlYnVnKCIqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqXG4iKTsNCiAgICBQcmludERlYnVnKCIgICAgICAgICAgICAgICAgTmFtZSBRaWQgICAgICAgIFNpemUgQ291bnQgQ3VyX0NvdW50IFR5cGVcbiIpOw0KICAgIGZvciAocE1zZ1EgPSBtc2dfcV9saXN0X2hlYWQudHFoX2ZpcnN0OyBwTXNnUSAhPSBOVUxMOyBwTXNnUSA9IHBNc2dRLT5lbnRyaWVzLnRxZV9uZXh0KQ0KICAgIHsNCiAgICAgICAgUHJpbnREZWJ1ZygiWyUwM2RdJTIwcyAweCUwOFggJTA0ZCAlMDVkICUwOWQgJTA0ZFxuIix1bENudCwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcE1zZ1EtPm5hbWUsICh1bnNpZ25lZCBsb25nKXBNc2dRLCBwTXNnUS0+bXNnX3NpemVfLCBwTXNnUS0+bXNnX2NvdW50XywgcE1zZ1EtPmN1cnJfbXNnX2NvdW50XywgcE1zZ1EtPnN1c3BlbmRfdHlwZV8pOw0KICAgICAgICB1bENudCsrOw0KICAgIH0NCiAgICBQcmludERlYnVnKCIqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqXG4iKTsNCn0NCiNlbmRpZg0KDQoNCi8qQH0qLw0K