LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCiAqIENvcHlyaWdodCAyMDA2IFR1bmdzdGVuIEdyYXBoaWNzLCBJbmMuLCBCaXNtYXJjaywgTkQuLCBVU0EuCiAqIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAqCiAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCiAqIGNvcHkgb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUKICogIlNvZnR3YXJlIiksIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZwogKiB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsCiAqIGRpc3RyaWJ1dGUsIHN1YiBsaWNlbnNlLCBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8KICogcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvCiAqIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKICoKICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGluZyB0aGUKICogbmV4dCBwYXJhZ3JhcGgpIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMKICogb2YgdGhlIFNvZnR3YXJlLgogKgogKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgogKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTi1JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMCiAqIFRIRSBDT1BZUklHSFQgSE9MREVSUywgQVVUSE9SUyBBTkQvT1IgSVRTIFNVUFBMSUVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwKICogREFNQUdFUyBPUiBPVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SCiAqIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUKICogVVNFIE9SIE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KICoKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoKICogQXV0aG9yczoKICogICAgVGhvbWFzIEhlbGxzdHL2bSA8dGhvbWFzLWF0LXR1bmdzdGVuZ3JhcGhpY3MtZG90LWNvbT4KICovCgojaW5jbHVkZSAiZHJtUC5oIgojaW5jbHVkZSAic2lzX2RybS5oIgojaW5jbHVkZSAic2lzX2Rydi5oIgoKI2luY2x1ZGUgPHZpZGVvL3Npc2ZiLmg+CgojZGVmaW5lIFZJREVPX1RZUEUgMAojZGVmaW5lIEFHUF9UWVBFIDEKCgojaWYgZGVmaW5lZChDT05GSUdfRkJfU0lTKQovKiBmYiBtYW5hZ2VtZW50IHZpYSBmYiBkZXZpY2UgKi8KCiNkZWZpbmUgU0lTX01NX0FMSUdOX1NISUZUIDAKI2RlZmluZSBTSVNfTU1fQUxJR05fTUFTSyAwCgpzdGF0aWMgdm9pZCAqc2lzX3NtYW5fbW1fYWxsb2NhdGUodm9pZCAqcHJpdmF0ZSwgdW5zaWduZWQgbG9uZyBzaXplLAoJCQkJICB1bnNpZ25lZCBhbGlnbm1lbnQpCnsKCXN0cnVjdCBzaXNfbWVtcmVxIHJlcTsKCglyZXEuc2l6ZSA9IHNpemU7CglzaXNfbWFsbG9jKCZyZXEpOwoJaWYgKHJlcS5zaXplID09IDApCgkJcmV0dXJuIE5VTEw7CgllbHNlCgkJcmV0dXJuICh2b2lkICopfnJlcS5vZmZzZXQ7Cn0KCnN0YXRpYyB2b2lkIHNpc19zbWFuX21tX2ZyZWUodm9pZCAqcHJpdmF0ZSwgdm9pZCAqcmVmKQp7CglzaXNfZnJlZSh+KCh1bnNpZ25lZCBsb25nKXJlZikpOwp9CgpzdGF0aWMgdm9pZCBzaXNfc21hbl9tbV9kZXN0cm95KHZvaWQgKnByaXZhdGUpCnsKCTsKfQoKc3RhdGljIHVuc2lnbmVkIGxvbmcgc2lzX3NtYW5fbW1fb2Zmc2V0KHZvaWQgKnByaXZhdGUsIHZvaWQgKnJlZikKewoJcmV0dXJuIH4oKHVuc2lnbmVkIGxvbmcpcmVmKTsKfQoKI2Vsc2UgLyogQ09ORklHX0ZCX1NJUyAqLwoKI2RlZmluZSBTSVNfTU1fQUxJR05fU0hJRlQgNAojZGVmaW5lIFNJU19NTV9BTElHTl9NQVNLICggKDEgPDwgU0lTX01NX0FMSUdOX1NISUZUKSAtIDEpCgojZW5kaWYgLyogQ09ORklHX0ZCX1NJUyAqLwoKc3RhdGljIGludCBzaXNfZmJfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLCBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdikKewoJZHJtX3Npc19wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9zaXNfZmJfdCAqZmIgPSBkYXRhOwoJaW50IHJldDsKCgltdXRleF9sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CiNpZiBkZWZpbmVkKENPTkZJR19GQl9TSVMpCgl7CgkJc3RydWN0IGRybV9zbWFuX21tIHNtYW5fbW07CgkJc21hbl9tbS5wcml2YXRlID0gKHZvaWQgKikweEZGRkZGRkZGOwoJCXNtYW5fbW0uYWxsb2NhdGUgPSBzaXNfc21hbl9tbV9hbGxvY2F0ZTsKCQlzbWFuX21tLmZyZWUgPSBzaXNfc21hbl9tbV9mcmVlOwoJCXNtYW5fbW0uZGVzdHJveSA9IHNpc19zbWFuX21tX2Rlc3Ryb3k7CgkJc21hbl9tbS5vZmZzZXQgPSBzaXNfc21hbl9tbV9vZmZzZXQ7CgkJcmV0ID0KCQkgICAgZHJtX3NtYW5fc2V0X21hbmFnZXIoJmRldl9wcml2LT5zbWFuLCBWSURFT19UWVBFLCAmc21hbl9tbSk7Cgl9CiNlbHNlCglyZXQgPSBkcm1fc21hbl9zZXRfcmFuZ2UoJmRldl9wcml2LT5zbWFuLCBWSURFT19UWVBFLCAwLAoJCQkJIGZiLT5zaXplID4+IFNJU19NTV9BTElHTl9TSElGVCk7CiNlbmRpZgoKCWlmIChyZXQpIHsKCQlEUk1fRVJST1IoIlZSQU0gbWVtb3J5IG1hbmFnZXIgaW5pdGlhbGlzYXRpb24gZXJyb3JcbiIpOwoJCW11dGV4X3VubG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwoJCXJldHVybiByZXQ7Cgl9CgoJZGV2X3ByaXYtPnZyYW1faW5pdGlhbGl6ZWQgPSAxOwoJZGV2X3ByaXYtPnZyYW1fb2Zmc2V0ID0gZmItPm9mZnNldDsKCgltdXRleF91bmxvY2soJmRldi0+c3RydWN0X211dGV4KTsKCURSTV9ERUJVRygib2Zmc2V0ID0gJXUsIHNpemUgPSAldSIsIGZiLT5vZmZzZXQsIGZiLT5zaXplKTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBzaXNfZHJtX2FsbG9jKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2LAoJCQkgdm9pZCAqZGF0YSwgaW50IHBvb2wpCnsKCWRybV9zaXNfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7Cglkcm1fc2lzX21lbV90ICptZW0gPSBkYXRhOwoJaW50IHJldHZhbCA9IDA7CglzdHJ1Y3QgZHJtX21lbWJsb2NrX2l0ZW0gKml0ZW07CgoJbXV0ZXhfbG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwoKCWlmICgwID09ICgocG9vbCA9PSAwKSA/IGRldl9wcml2LT52cmFtX2luaXRpYWxpemVkIDoKCQkgICAgICBkZXZfcHJpdi0+YWdwX2luaXRpYWxpemVkKSkgewoJCURSTV9FUlJPUgoJCSAgICAoIkF0dGVtcHQgdG8gYWxsb2NhdGUgZnJvbSB1bmluaXRpYWxpemVkIG1lbW9yeSBtYW5hZ2VyLlxuIik7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJbWVtLT5zaXplID0gKG1lbS0+c2l6ZSArIFNJU19NTV9BTElHTl9NQVNLKSA+PiBTSVNfTU1fQUxJR05fU0hJRlQ7CglpdGVtID0gZHJtX3NtYW5fYWxsb2MoJmRldl9wcml2LT5zbWFuLCBwb29sLCBtZW0tPnNpemUsIDAsCgkJCSAgICAgICh1bnNpZ25lZCBsb25nKWZpbGVfcHJpdik7CgoJbXV0ZXhfdW5sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CglpZiAoaXRlbSkgewoJCW1lbS0+b2Zmc2V0ID0gKChwb29sID09IDApID8KCQkJICAgICAgZGV2X3ByaXYtPnZyYW1fb2Zmc2V0IDogZGV2X3ByaXYtPmFncF9vZmZzZXQpICsKCQkgICAgKGl0ZW0tPm1tLT4KCQkgICAgIG9mZnNldChpdGVtLT5tbSwgaXRlbS0+bW1faW5mbykgPDwgU0lTX01NX0FMSUdOX1NISUZUKTsKCQltZW0tPmZyZWUgPSBpdGVtLT51c2VyX2hhc2gua2V5OwoJCW1lbS0+c2l6ZSA9IG1lbS0+c2l6ZSA8PCBTSVNfTU1fQUxJR05fU0hJRlQ7Cgl9IGVsc2UgewoJCW1lbS0+b2Zmc2V0ID0gMDsKCQltZW0tPnNpemUgPSAwOwoJCW1lbS0+ZnJlZSA9IDA7CgkJcmV0dmFsID0gLUVOT01FTTsKCX0KCglEUk1fREVCVUcoImFsbG9jICVkLCBzaXplID0gJWQsIG9mZnNldCA9ICVkXG4iLCBwb29sLCBtZW0tPnNpemUsCgkJICBtZW0tPm9mZnNldCk7CgoJcmV0dXJuIHJldHZhbDsKfQoKc3RhdGljIGludCBzaXNfZHJtX2ZyZWUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYpCnsKCWRybV9zaXNfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7Cglkcm1fc2lzX21lbV90ICptZW0gPSBkYXRhOwoJaW50IHJldDsKCgltdXRleF9sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CglyZXQgPSBkcm1fc21hbl9mcmVlX2tleSgmZGV2X3ByaXYtPnNtYW4sIG1lbS0+ZnJlZSk7CgltdXRleF91bmxvY2soJmRldi0+c3RydWN0X211dGV4KTsKCURSTV9ERUJVRygiZnJlZSA9IDB4JWx4XG4iLCBtZW0tPmZyZWUpOwoKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgc2lzX2ZiX2FsbG9jKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCgkJCXN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2KQp7CglyZXR1cm4gc2lzX2RybV9hbGxvYyhkZXYsIGZpbGVfcHJpdiwgZGF0YSwgVklERU9fVFlQRSk7Cn0KCnN0YXRpYyBpbnQgc2lzX2lvY3RsX2FncF9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCgkJCSAgICAgIHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2KQp7Cglkcm1fc2lzX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3Npc19hZ3BfdCAqYWdwID0gZGF0YTsKCWludCByZXQ7CglkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CgoJbXV0ZXhfbG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwoJcmV0ID0gZHJtX3NtYW5fc2V0X3JhbmdlKCZkZXZfcHJpdi0+c21hbiwgQUdQX1RZUEUsIDAsCgkJCQkgYWdwLT5zaXplID4+IFNJU19NTV9BTElHTl9TSElGVCk7CgoJaWYgKHJldCkgewoJCURSTV9FUlJPUigiQUdQIG1lbW9yeSBtYW5hZ2VyIGluaXRpYWxpc2F0aW9uIGVycm9yXG4iKTsKCQltdXRleF91bmxvY2soJmRldi0+c3RydWN0X211dGV4KTsKCQlyZXR1cm4gcmV0OwoJfQoKCWRldl9wcml2LT5hZ3BfaW5pdGlhbGl6ZWQgPSAxOwoJZGV2X3ByaXYtPmFncF9vZmZzZXQgPSBhZ3AtPm9mZnNldDsKCW11dGV4X3VubG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwoKCURSTV9ERUJVRygib2Zmc2V0ID0gJXUsIHNpemUgPSAldSIsIGFncC0+b2Zmc2V0LCBhZ3AtPnNpemUpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgc2lzX2lvY3RsX2FncF9hbGxvYyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAoJCQkgICAgICAgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYpCnsKCglyZXR1cm4gc2lzX2RybV9hbGxvYyhkZXYsIGZpbGVfcHJpdiwgZGF0YSwgQUdQX1RZUEUpOwp9CgpzdGF0aWMgZHJtX2xvY2FsX21hcF90ICpzaXNfcmVnX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKewoJc3RydWN0IGRybV9tYXBfbGlzdCAqZW50cnk7Cglkcm1fbG9jYWxfbWFwX3QgKm1hcDsKCglsaXN0X2Zvcl9lYWNoX2VudHJ5KGVudHJ5LCAmZGV2LT5tYXBsaXN0LCBoZWFkKSB7CgkJbWFwID0gZW50cnktPm1hcDsKCQlpZiAoIW1hcCkKCQkJY29udGludWU7CgkJaWYgKG1hcC0+dHlwZSA9PSBfRFJNX1JFR0lTVEVSUykgewoJCQlyZXR1cm4gbWFwOwoJCX0KCX0KCXJldHVybiBOVUxMOwp9CgppbnQgc2lzX2lkbGUoc3RydWN0IGRybV9kZXZpY2UgKmRldikKewoJZHJtX3Npc19wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCXVpbnQzMl90IGlkbGVfcmVnOwoJdW5zaWduZWQgbG9uZyBlbmQ7CglpbnQgaTsKCglpZiAoZGV2X3ByaXYtPmlkbGVfZmF1bHQpCgkJcmV0dXJuIDA7CgoJaWYgKGRldl9wcml2LT5tbWlvID09IE5VTEwpIHsKCQlkZXZfcHJpdi0+bW1pbyA9IHNpc19yZWdfaW5pdChkZXYpOwoJCWlmIChkZXZfcHJpdi0+bW1pbyA9PSBOVUxMKSB7CgkJCURSTV9FUlJPUigiQ291bGQgbm90IGZpbmQgcmVnaXN0ZXIgbWFwLlxuIik7CgkJCXJldHVybiAwOwoJCX0KCX0KCQoJLyoKCSAqIEltcGxlbWVudCBhIGRldmljZSBzd2l0Y2ggaGVyZSBpZiBuZWVkZWQKCSAqLwoKCWlmIChkZXZfcHJpdi0+Y2hpcHNldCAhPSBTSVNfQ0hJUF8zMTUpCgkJcmV0dXJuIDA7CgoJLyoKCSAqIFRpbWVvdXQgYWZ0ZXIgMyBzZWNvbmRzLiBXZSBjYW5ub3QgdXNlIERSTV9XQUlUX09OIGhlcmUKCSAqIGJlY2F1c2UgaXRzIHBvbGxpbmcgZnJlcXVlbmN5IGlzIHRvbyBsb3cuCgkgKi8KCgllbmQgPSBqaWZmaWVzICsgKERSTV9IWiAqIDMpOwoKCWZvciAoaT0wOyBpPDQ7ICsraSkgewoJCWRvIHsKCQkJaWRsZV9yZWcgPSBTSVNfUkVBRCgweDg1Y2MpOwoJCX0gd2hpbGUgKCAhdGltZV9hZnRlcl9lcShqaWZmaWVzLCBlbmQpICYmCgkJCSAgKChpZGxlX3JlZyAmIDB4ODAwMDAwMDApICE9IDB4ODAwMDAwMDApKTsKCX0KCglpZiAodGltZV9hZnRlcl9lcShqaWZmaWVzLCBlbmQpKSB7CgkJRFJNX0VSUk9SKCJHcmFwaGljcyBlbmdpbmUgaWRsZSB0aW1lb3V0LiAiCgkJCSAgIkRpc2FibGluZyBpZGxlIGNoZWNrXG4iKTsKCQlkZXZfcHJpdi0+aWRsZV9mYXVsdCA9IDE7Cgl9CgoJLyoKCSAqIFRoZSBjYWxsZXIgbmV2ZXIgc2VlcyBhbiBlcnJvciBjb2RlLiBJdCBnZXRzIHRyYXBwZWQKCSAqIGluIGxpYmRybS4KCSAqLwoKCXJldHVybiAwOwp9CgoKdm9pZCBzaXNfbGFzdGNsb3NlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCnsKCWRybV9zaXNfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CgoJaWYgKCFkZXZfcHJpdikKCQlyZXR1cm47CgoJbXV0ZXhfbG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwoJZHJtX3NtYW5fY2xlYW51cCgmZGV2X3ByaXYtPnNtYW4pOwoJZGV2X3ByaXYtPnZyYW1faW5pdGlhbGl6ZWQgPSAwOwoJZGV2X3ByaXYtPmFncF9pbml0aWFsaXplZCA9IDA7CglkZXZfcHJpdi0+bW1pbyA9IE5VTEw7CgltdXRleF91bmxvY2soJmRldi0+c3RydWN0X211dGV4KTsKfQoKdm9pZCBzaXNfcmVjbGFpbV9idWZmZXJzX2xvY2tlZChzdHJ1Y3QgZHJtX2RldmljZSAqIGRldiwKCQkJCXN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2KQp7Cglkcm1fc2lzX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoKCW11dGV4X2xvY2soJmRldi0+c3RydWN0X211dGV4KTsKCWlmIChkcm1fc21hbl9vd25lcl9jbGVhbigmZGV2X3ByaXYtPnNtYW4sICh1bnNpZ25lZCBsb25nKWZpbGVfcHJpdikpIHsKCQltdXRleF91bmxvY2soJmRldi0+c3RydWN0X211dGV4KTsKCQlyZXR1cm47Cgl9CgoJaWYgKGRldi0+ZHJpdmVyLT5kbWFfcXVpZXNjZW50KSB7CgkJZGV2LT5kcml2ZXItPmRtYV9xdWllc2NlbnQoZGV2KTsKCX0KCglkcm1fc21hbl9vd25lcl9jbGVhbnVwKCZkZXZfcHJpdi0+c21hbiwgKHVuc2lnbmVkIGxvbmcpZmlsZV9wcml2KTsKCW11dGV4X3VubG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwoJcmV0dXJuOwp9CgpzdHJ1Y3QgZHJtX2lvY3RsX2Rlc2Mgc2lzX2lvY3Rsc1tdID0gewoJRFJNX0lPQ1RMX0RFRihEUk1fU0lTX0ZCX0FMTE9DLCBzaXNfZmJfYWxsb2MsIERSTV9BVVRIKSwKCURSTV9JT0NUTF9ERUYoRFJNX1NJU19GQl9GUkVFLCBzaXNfZHJtX2ZyZWUsIERSTV9BVVRIKSwKCURSTV9JT0NUTF9ERUYoRFJNX1NJU19BR1BfSU5JVCwgc2lzX2lvY3RsX2FncF9pbml0LCBEUk1fQVVUSCB8IERSTV9NQVNURVIgfCBEUk1fUk9PVF9PTkxZKSwKCURSTV9JT0NUTF9ERUYoRFJNX1NJU19BR1BfQUxMT0MsIHNpc19pb2N0bF9hZ3BfYWxsb2MsIERSTV9BVVRIKSwKCURSTV9JT0NUTF9ERUYoRFJNX1NJU19BR1BfRlJFRSwgc2lzX2RybV9mcmVlLCBEUk1fQVVUSCksCglEUk1fSU9DVExfREVGKERSTV9TSVNfRkJfSU5JVCwgc2lzX2ZiX2luaXQsIERSTV9BVVRIIHwgRFJNX01BU1RFUiB8IERSTV9ST09UX09OTFkpLAp9OwoKaW50IHNpc19tYXhfaW9jdGwgPSBEUk1fQVJSQVlfU0laRShzaXNfaW9jdGxzKTsK