def run(self, logical_sectors, track_num):
offset = find.wild(concat_track(logical_sectors),
b'\xA0\x00\x84\x26\x84\x27\xBD\x8C\xC0')
if offset == -1: return []
return [
Patch(track_num, offset // 256, offset % 256, b'\x18\x60',
"microfun")
]
def run(self, logical_sectors, track_num):
patches = []
for a, x, v in ((8, 0x83, b'\xD5'), (8, 0x8D, b'\xAA'),
(8, 0x98, b'\x96'), (8, 0x15, b'\xD5'),
(8, 0x1F, b'\xAA'), (8, 0x2A, b'\xAD')):
if logical_sectors[a][x] != v[0]:
patches.append(Patch(0, a, x, v))
return patches
def run(self, logical_sectors, track_num):
patches = []
for a, x, v in ((0x0A, 0xE8, b'\xD5'), (0x0A, 0xF2, b'\xAA'),
(0x0A, 0xFD, b'\x96'), (0x0B, 0x6F, b'\xD5'),
(0x0B, 0x79, b'\xAA'), (0x0B, 0x83, b'\xAD')):
if logical_sectors[a][x] != v[0]:
patches.append(Patch(0, a, x, v))
return patches
def run(self, logical_sectors, track_num):
patches = []
for sector_num in logical_sectors:
if find.at(0x00, logical_sectors[sector_num], self.e7sector):
patches.append(
Patch(track_num, sector_num, 0xA3,
b'\x64\xB4\x44\x80\x2C\xDC\x18\xB4\x44\x80\x44\xB4',
"e7"))
return patches
def run(self, logical_sectors, track_num):
offset = find.wild(concat_track(logical_sectors),
b'\x07'
b'\xE6\x02'
b'\xD0\x03'
b'\x4C\xA5\x00'
b'\xC9\xA5')
if offset == -1: return []
return [Patch(track_num, offset // 256, 8 + (offset % 256), b'\xD0\x7B', "a5count")]
def run(self, logical_sectors, track_num):
if not find.at(0x40, logical_sectors[3], b'\xD0'): return []
if not find.at(0x9C, logical_sectors[3], b'\xF0'): return []
if not find.at(
0x69, logical_sectors[4],
bytes.fromhex("48"
"A5 2A"
"4A"
"A8"
"B9 29 BA"
"8D 6A B9"
"8D 84 BC"
"B9 34 BA"
"8D FC B8"
"8D 5D B8"
"C0 11"
"D0 03"
"A9 02"
"AC"
"A9 0E"
"8D C0 BF"
"68"
"69 00"
"48"
"AD 78 04"
"90 2B")):
return []
if not find.at(0x69, logical_sectors[6],
bytes.fromhex("4C B8 B6"
"EA"
"EA"
"EA")):
return []
if not find.at(0x8C, logical_sectors[8], bytes.fromhex("69 BA")):
return []
return [
Patch(0, 3, 0x40, bytes.fromhex("F0")),
Patch(0, 3, 0x9C, bytes.fromhex("D0")),
Patch(0, 6, 0x69, bytes.fromhex("20 C3 BC 20 C3 BC")),
Patch(0, 8, 0x8C, bytes.fromhex("A0 B9")),
Patch(0, 4, 0xC0,
bytes.fromhex("C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA"))
]
def run(self, logical_sectors, track_num):
buffy = concat_track(logical_sectors)
offset = find.wild(buffy,
b'\x85' + find.WILDCARD + find.WILDCARD + \
b'\x74\x45\x09'
b'\xD9\x32'
b'\x0C\x30')
if offset == -1: return []
return [
Patch(track_num, offset // 256, offset % 256, b'\xD1\x59\xA7',
"advint")
]
def run(self, logical_sectors, track_num):
if not find.at(
0x4F, logical_sectors[3], b'\xBD\x8C\xC0'
b'\x10\xFB'
b'\xC9\xD5'
b'\xD0\xF0'
b'\xEA'
b'\xBD\x8C\xC0'
b'\xC9\xD5'
b'\xF0\x12'):
return []
return [Patch(0, 3, 0x58, b'\xF0\x06')]
def run(self, logical_sectors, track_num):
if not find.at(
0x5A, logical_sectors[8], b'\xC9\x23'
b'\xB0\xEB'
b'\x0A'
b'\x20\x6C\xBF'
b'\xEA'
b'\xEA'):
return []
return [
Patch(0, 8, 0x5A, b'\x48\xA0\x01\xB1\x3C\x6A\x68\x90\x08\x0A',
"border")
]
def run(self, logical_sectors, track_num):
buffy = concat_track(logical_sectors)
if -1 == find.wild(buffy,
b'\x8E\xC0'
b'\x18'
b'\xA5' + find.WILDCARD + \
b'\x69\x8C'
b'\x8D'):
return []
offset = find.wild(buffy, b'\xBD\x89\xC0')
if offset == -1: return []
return [
Patch(track_num, offset // 256, offset % 256, b'\x18\x60', "bbf9")
]
def run(self, logical_sectors, track_num):
buffy = concat_track(logical_sectors)
if -1 == find.wild(buffy, b'\xBD\x8C\xC0'
b'\x10\xFB'
b'\xC9\xA6'
b'\xD0\xED'):
return False
if -1 == find.wild(buffy, b'\xBD\x8C\xC0' b'\x10\xFB' b'\xC9\xBC'):
return False
if -1 == find.wild(buffy, b'\xBD\x8C\xC0' b'\x10\xFB' b'\xC9\x95'):
return False
offset = find.wild(buffy, b'\xAE\xF8\x01' b'\xA9\x0A' b'\x8D\xFE\x01')
if offset == -1: return []
return [
Patch(track_num, offset // 256, offset % 256, b'\x60', "a6bc95")
]
def run(self, logical_sectors, track_num):
if not find.wild_at(0x00, logical_sectors[0],
b'\xAD\xF3\x03'
b'\x8D\xF4\x03'
b'\x20\x2F\xFB'
b'\x20\x93\xFE'
b'\x20\x89\xFE'
b'\x20\x58\xFC'
b'\xA9\x0A'
b'\x85\x25'
b'\x2C' + find.WILDCARD + find.WILDCARD + \
b'\xCE\x17\x18'
b'\xD0\x05'
b'\xA9\x80'
b'\x8D\x18\x18'):
return []
return [Patch(1, 0, 0x00, b'\x4C\x03\x1B', "bootcounter")]
return patches
def run(self, logical_sectors, track_num):
offset = find.wild(concat_track(logical_sectors),
b'\xBD\x8C\xC0'
b'\x10\xFB'
b'\x48'
b'\x68'
b'\xC9\xD5'
b'\xD0\xF5'
b'\xA0\x00' + \
b'\x8C' + find.WILDCARD + find.WILDCARD + \
b'\xBD\x8C\xC0'
b'\x10\xFB'
b'\xC9\xD5'
b'\xF0\x0F'
b'\xC9\xF7'
b'\xD0\x01'
b'\xC8'
b'\x18'
b'\x6D')
if offset == -1: return []
return [Patch(track_num, offset // 256, offset % 256, b'\x60', "d5d5f7")]
def run(self, logical_sectors, track_num):
patches = []
lda_bpl = b'\xBD\x8C\xC0\x10\xFB'
lda_bpl_cmp = lda_bpl + b'\xC9' + find.WILDCARD
lda_bpl_eor = lda_bpl + b'\x49' + find.WILDCARD
lda_jsr = b'\xA9' + find.WILDCARD + b'\x20'
lda_jsr_d5 = lda_jsr + b'\xD5'
lda_jsr_b8 = lda_jsr + b'\xB8'
for a, b, c, d, e in (
# address prologue byte 1 (read)
(0x55, 3, b'\xD5', 0x4F, lda_bpl_cmp + b'\xD0\xF0\xEA'),
# address prologue byte 2 (read)
(0x5F, 3, b'\xAA', 0x59, lda_bpl_cmp + b'\xD0\xF2\xA0\x03'),
# address prologue byte 3 (read)
(0x6A, 3, b'\x96', 0x64, lda_bpl_cmp + b'\xD0\xE7'),
# address epilogue byte 1 (read)
(0x91, 3, b'\xDE', 0x8B, lda_bpl_cmp + b'\xD0\xAE'),
# address epilogue byte 2 (read)
(0x9B, 3, b'\xAA', 0x95, lda_bpl_cmp + b'\xD0\xA4\x18'),
# data prologue byte 1 (read)
(0xE7, 2, b'\xD5', 0xE1, lda_bpl_eor + b'\xD0\xF4\xEA'),
# data prologue byte 2 (read)
(0xF1, 2, b'\xAA', 0xEB, lda_bpl_cmp + b'\xD0\xF2\xA0\x56'),
# data prologue byte 3 (read)
(0xFC, 2, b'\xAD', 0xF6, lda_bpl_cmp + b'\xD0\xE7'),
# data epilogue byte 1 (read)
(0x35, 3, b'\xDE', 0x2F, lda_bpl_cmp + b'\xD0\x0A\xEA'),
# data epilogue byte 2 (read)
(0x3F, 3, b'\xAA', 0x39, lda_bpl_cmp + b'\xF0\x5C\x38'),
# address prologue byte 1 (write)
(0x7A, 6, b'\xD5', 0x79, lda_jsr_d5),
# address prologue byte 2 (write)
(0x7F, 6, b'\xAA', 0x7E, lda_jsr_d5),
# address prologue byte 3 (write)
(0x84, 6, b'\x96', 0x83, lda_jsr_d5),
# address epilogue byte 1 (write)
(0xAE, 6, b'\xDE', 0xAD, lda_jsr_d5),
# address epilogue byte 2 (write)
(0xB3, 6, b'\xAA', 0xB2, lda_jsr_d5),
# address epilogue byte 3 (write)
(0xB8, 6, b'\xEB', 0xB7, lda_jsr_d5),
# data prologue byte 1 (write)
(0x53, 2, b'\xD5', 0x52, lda_jsr_b8),
# data prologue byte 2 (write)
(0x58, 2, b'\xAA', 0x57, lda_jsr_b8),
# data prologue byte 3 (write)
(0x5D, 2, b'\xAD', 0x5C, lda_jsr_b8),
# data epilogue byte 1 (write)
(0x9E, 2, b'\xDE', 0x9D, lda_jsr_b8),
# data epilogue byte 2 (write)
(0xA3, 2, b'\xAA', 0xA2, lda_jsr_b8),
# data epilogue byte 3 (write)
(0xA8, 2, b'\xEB', 0xA7, lda_jsr_b8),
# data epilogue byte 4 (write)
# needed by some Sunburst disks
(0xAD, 2, b'\xFF', 0xAC, lda_jsr_b8),
):
if not find.at(a, logical_sectors[b], c) and \
find.wild_at(d, logical_sectors[b], e):
patches.append(Patch(0, b, a, c))
return patches