Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
alexbevi
GitHub Repository: alexbevi/BizHawk
 Path: blob/master/libsnes/bsnes/gameboy/cpu/core/disassembler.cpp
2 views
1
#ifdef CPU_CPP

2


3
string CPU::disassemble(uint16 pc) {

4
  char output[80];

5
  memset(output, ' ', sizeof output);

6
  output[79] = 0;

7


8
  string opcode = disassemble_opcode(pc);

9
  string registers = {

10
    " AF:", hex<4>(r[AF]),

11
    " BC:", hex<4>(r[BC]),

12
    " DE:", hex<4>(r[DE]),

13
    " HL:", hex<4>(r[HL]),

14
    " SP:", hex<4>(r[SP])

15
  };

16


17
  memcpy(output +   0, hex<4>(pc), 4);

18
  memcpy(output +   6, opcode, opcode.length());

19
  memcpy(output +  23, registers, registers.length());

20
  output[63] = 0;

21
  return output;

22
}

23


24
string CPU::disassemble_opcode(uint16 pc) {

25
  uint8 opcode = bus.read(pc);

26
  uint8 p0 = bus.read(pc + 1);

27
  uint8 p1 = bus.read(pc + 2);

28
  uint8 p2 = bus.read(pc + 3);

29


30
  switch(opcode) {

31
    case 0x00: return { "nop" };

32
    case 0x01: return { "ld   bc,$", hex<2>(p1), hex<2>(p0) };

33
    case 0x02: return { "ld   (bc),a" };

34
    case 0x03: return { "inc  bc" };

35
    case 0x04: return { "inc  b" };

36
    case 0x05: return { "dec  b" };

37
    case 0x06: return { "ld   b,$", hex<2>(p0) };

38
    case 0x07: return { "rlc  a" };

39
    case 0x08: return { "ld   ($", hex<2>(p1), hex<2>(p0), "),sp" };

40
    case 0x09: return { "add  hl,bc" };

41
    case 0x0a: return { "ld   a,(bc)" };

42
    case 0x0b: return { "dec  bc" };

43
    case 0x0c: return { "inc  c" };

44
    case 0x0d: return { "dec  c" };

45
    case 0x0e: return { "ld   c,$", hex<2>(p0) };

46
    case 0x0f: return { "rrc  a" };

47
    case 0x10: return { "stop" };

48
    case 0x11: return { "ld   de,$", hex<2>(p1), hex<2>(p0) };

49
    case 0x12: return { "ld   (de),a" };

50
    case 0x13: return { "inc  de" };

51
    case 0x14: return { "inc  d" };

52
    case 0x15: return { "dec  d" };

53
    case 0x16: return { "ld   d,$", hex<2>(p0) };

54
    case 0x17: return { "rl   a" };

55
    case 0x18: return { "jr   $", hex<4>(r[PC] + 2 + (int8)p0) };

56
    case 0x19: return { "add  hl,de" };

57
    case 0x1a: return { "ld   a,(de)" };

58
    case 0x1b: return { "dec  de" };

59
    case 0x1c: return { "inc  e" };

60
    case 0x1d: return { "dec  e" };

61
    case 0x1e: return { "ld   e,$", hex<2>(p0) };

62
    case 0x1f: return { "rr   a" };

63
    case 0x20: return { "jr   nz,$", hex<4>(r[PC] + 2 + (int8)p0) };

64
    case 0x21: return { "ld   hl,$", hex<2>(p1), hex<2>(p0) };

65
    case 0x22: return { "ldi  (hl),a" };

66
    case 0x23: return { "inc  hl" };

67
    case 0x24: return { "inc  h" };

68
    case 0x25: return { "dec  h" };

69
    case 0x26: return { "ld   h,$", hex<2>(p0) };

70
    case 0x27: return { "daa" };

71
    case 0x28: return { "jr   z,$", hex<4>(r[PC] + 2 + (int8)p0) };

72
    case 0x29: return { "add  hl,hl" };

73
    case 0x2a: return { "ldi  a,(hl)" };

74
    case 0x2b: return { "dec  hl" };

75
    case 0x2c: return { "inc  l" };

76
    case 0x2d: return { "dec  l" };

77
    case 0x2e: return { "ld   l,$", hex<2>(p0) };

78
    case 0x2f: return { "cpl" };

79
    case 0x30: return { "jr   nc,$", hex<4>(r[PC] + 2 + (int8)p0) };

80
    case 0x31: return { "ld   sp,$", hex<2>(p1), hex<2>(p0) };

81
    case 0x32: return { "ldd  (hl),a" };

82
    case 0x33: return { "inc  sp" };

83
    case 0x34: return { "inc  (hl)" };

84
    case 0x35: return { "dec  (hl)" };

85
    case 0x36: return { "ld   (hl),$", hex<2>(p0) };

86
    case 0x37: return { "scf" };

87
    case 0x38: return { "jr   c,$", hex<4>(r[PC] + 2 + (int8)p0) };

88
    case 0x39: return { "add  hl,sp" };

89
    case 0x3a: return { "ldd  a,(hl)" };

90
    case 0x3b: return { "dec  sp" };

91
    case 0x3c: return { "inc  a" };

92
    case 0x3d: return { "dec  a" };

93
    case 0x3e: return { "ld   a,$", hex<2>(p0) };

94
    case 0x3f: return { "ccf" };

95
    case 0x40: return { "ld   b,b" };

96
    case 0x41: return { "ld   b,c" };

97
    case 0x42: return { "ld   b,d" };

98
    case 0x43: return { "ld   b,e" };

99
    case 0x44: return { "ld   b,h" };

100
    case 0x45: return { "ld   b,l" };

101
    case 0x46: return { "ld   b,(hl)" };

102
    case 0x47: return { "ld   b,a" };

103
    case 0x48: return { "ld   c,b" };

104
    case 0x49: return { "ld   c,c" };

105
    case 0x4a: return { "ld   c,d" };

106
    case 0x4b: return { "ld   c,e" };

107
    case 0x4c: return { "ld   c,h" };

108
    case 0x4d: return { "ld   c,l" };

109
    case 0x4e: return { "ld   c,(hl)" };

110
    case 0x4f: return { "ld   c,a" };

111
    case 0x50: return { "ld   d,b" };

112
    case 0x51: return { "ld   d,c" };

113
    case 0x52: return { "ld   d,d" };

114
    case 0x53: return { "ld   d,e" };

115
    case 0x54: return { "ld   d,h" };

116
    case 0x55: return { "ld   d,l" };

117
    case 0x56: return { "ld   d,(hl)" };

118
    case 0x57: return { "ld   d,a" };

119
    case 0x58: return { "ld   e,b" };

120
    case 0x59: return { "ld   e,c" };

121
    case 0x5a: return { "ld   e,d" };

122
    case 0x5b: return { "ld   e,e" };

123
    case 0x5c: return { "ld   e,h" };

124
    case 0x5d: return { "ld   e,l" };

125
    case 0x5e: return { "ld   e,(hl)" };

126
    case 0x5f: return { "ld   e,a" };

127
    case 0x60: return { "ld   h,b" };

128
    case 0x61: return { "ld   h,c" };

129
    case 0x62: return { "ld   h,d" };

130
    case 0x63: return { "ld   h,e" };

131
    case 0x64: return { "ld   h,h" };

132
    case 0x65: return { "ld   h,l" };

133
    case 0x66: return { "ld   h,(hl)" };

134
    case 0x67: return { "ld   h,a" };

135
    case 0x68: return { "ld   l,b" };

136
    case 0x69: return { "ld   l,c" };

137
    case 0x6a: return { "ld   l,d" };

138
    case 0x6b: return { "ld   l,e" };

139
    case 0x6c: return { "ld   l,h" };

140
    case 0x6d: return { "ld   l,l" };

141
    case 0x6e: return { "ld   l,(hl)" };

142
    case 0x6f: return { "ld   l,a" };

143
    case 0x70: return { "ld   (hl),b" };

144
    case 0x71: return { "ld   (hl),c" };

145
    case 0x72: return { "ld   (hl),d" };

146
    case 0x73: return { "ld   (hl),e" };

147
    case 0x74: return { "ld   (hl),h" };

148
    case 0x75: return { "ld   (hl),l" };

149
    case 0x76: return { "halt" };

150
    case 0x77: return { "ld   (hl),a" };

151
    case 0x78: return { "ld   a,b" };

152
    case 0x79: return { "ld   a,c" };

153
    case 0x7a: return { "ld   a,d" };

154
    case 0x7b: return { "ld   a,e" };

155
    case 0x7c: return { "ld   a,h" };

156
    case 0x7d: return { "ld   a,l" };

157
    case 0x7e: return { "ld   a,(hl)" };

158
    case 0x7f: return { "ld   a,a" };

159
    case 0x80: return { "add  a,b" };

160
    case 0x81: return { "add  a,c" };

161
    case 0x82: return { "add  a,d" };

162
    case 0x83: return { "add  a,e" };

163
    case 0x84: return { "add  a,h" };

164
    case 0x85: return { "add  a,l" };

165
    case 0x86: return { "add  a,(hl)" };

166
    case 0x87: return { "add  a,a" };

167
    case 0x88: return { "adc  a,b" };

168
    case 0x89: return { "adc  a,c" };

169
    case 0x8a: return { "adc  a,d" };

170
    case 0x8b: return { "adc  a,e" };

171
    case 0x8c: return { "adc  a,h" };

172
    case 0x8d: return { "adc  a,l" };

173
    case 0x8e: return { "adc  a,(hl)" };

174
    case 0x8f: return { "adc  a,a" };

175
    case 0x90: return { "sub  a,b" };

176
    case 0x91: return { "sub  a,c" };

177
    case 0x92: return { "sub  a,d" };

178
    case 0x93: return { "sub  a,e" };

179
    case 0x94: return { "sub  a,h" };

180
    case 0x95: return { "sub  a,l" };

181
    case 0x96: return { "sub  a,(hl)" };

182
    case 0x97: return { "sub  a,a" };

183
    case 0x98: return { "sbc  a,b" };

184
    case 0x99: return { "sbc  a,c" };

185
    case 0x9a: return { "sbc  a,d" };

186
    case 0x9b: return { "sbc  a,e" };

187
    case 0x9c: return { "sbc  a,h" };

188
    case 0x9d: return { "sbc  a,l" };

189
    case 0x9e: return { "sbc  a,(hl)" };

190
    case 0x9f: return { "sbc  a,a" };

191
    case 0xa0: return { "and  a,b" };

192
    case 0xa1: return { "and  a,c" };

193
    case 0xa2: return { "and  a,d" };

194
    case 0xa3: return { "and  a,e" };

195
    case 0xa4: return { "and  a,h" };

196
    case 0xa5: return { "and  a,l" };

197
    case 0xa6: return { "and  a,(hl)" };

198
    case 0xa7: return { "and  a,a" };

199
    case 0xa8: return { "xor  a,b" };

200
    case 0xa9: return { "xor  a,c" };

201
    case 0xaa: return { "xor  a,d" };

202
    case 0xab: return { "xor  a,e" };

203
    case 0xac: return { "xor  a,h" };

204
    case 0xad: return { "xor  a,l" };

205
    case 0xae: return { "xor  a,(hl)" };

206
    case 0xaf: return { "xor  a,a" };

207
    case 0xb0: return { "or   a,b" };

208
    case 0xb1: return { "or   a,c" };

209
    case 0xb2: return { "or   a,d" };

210
    case 0xb3: return { "or   a,e" };

211
    case 0xb4: return { "or   a,h" };

212
    case 0xb5: return { "or   a,l" };

213
    case 0xb6: return { "or   a,(hl)" };

214
    case 0xb7: return { "or   a,a" };

215
    case 0xb8: return { "cp   a,b" };

216
    case 0xb9: return { "cp   a,c" };

217
    case 0xba: return { "cp   a,d" };

218
    case 0xbb: return { "cp   a,e" };

219
    case 0xbc: return { "cp   a,h" };

220
    case 0xbd: return { "cp   a,l" };

221
    case 0xbe: return { "cp   a,(hl)" };

222
    case 0xbf: return { "cp   a,a" };

223
    case 0xc0: return { "ret  nz" };

224
    case 0xc1: return { "pop  bc" };

225
    case 0xc2: return { "jp   nz,$", hex<2>(p1), hex<2>(p0) };

226
    case 0xc3: return { "jp   $", hex<2>(p1), hex<2>(p0) };

227
    case 0xc4: return { "call nz,$", hex<2>(p1), hex<2>(p0) };

228
    case 0xc5: return { "push bc" };

229
    case 0xc6: return { "add  a,$", hex<2>(p0) };

230
    case 0xc7: return { "rst  $0000" };

231
    case 0xc8: return { "ret  z" };

232
    case 0xc9: return { "ret" };

233
    case 0xca: return { "jp   z,$", hex<2>(p1), hex<2>(p0) };

234
    case 0xcb: return disassemble_opcode_cb(pc + 1);

235
    case 0xcc: return { "call z,$", hex<2>(p1), hex<2>(p0) };

236
    case 0xcd: return { "call $", hex<2>(p1), hex<2>(p0) };

237
    case 0xce: return { "adc  a,$", hex<2>(p0) };

238
    case 0xcf: return { "rst  $0008" };

239
    case 0xd0: return { "ret  nc" };

240
    case 0xd1: return { "pop  de" };

241
    case 0xd2: return { "jp   nc,$", hex<2>(p1), hex<2>(p0) };

242
    case 0xd3: return { "xx" };

243
    case 0xd4: return { "call nc,$", hex<2>(p1), hex<2>(p0) };

244
    case 0xd5: return { "push de" };

245
    case 0xd6: return { "sub  a,$", hex<2>(p0) };

246
    case 0xd7: return { "rst  $0010" };

247
    case 0xd8: return { "ret  c" };

248
    case 0xd9: return { "reti" };

249
    case 0xda: return { "jp   c,$", hex<2>(p1), hex<2>(p0) };

250
    case 0xdb: return { "xx" };

251
    case 0xdc: return { "call c,$", hex<2>(p1), hex<2>(p0) };

252
    case 0xdd: return { "xx" };

253
    case 0xde: return { "sbc  a,$", hex<2>(p0) };

254
    case 0xdf: return { "rst  $0018" };

255
    case 0xe0: return { "ld   ($ff", hex<2>(p0), "),a" };

256
    case 0xe1: return { "pop  hl" };

257
    case 0xe2: return { "ld   ($ff00+c),a" };

258
    case 0xe3: return { "xx" };

259
    case 0xe4: return { "xx" };

260
    case 0xe5: return { "push hl" };

261
    case 0xe6: return { "and  a,$", hex<2>(p0) };

262
    case 0xe7: return { "rst  $0020" };

263
    case 0xe8: return { "add  sp,$", hex<4>((int8)p0) };

264
    case 0xe9: return { "jp   hl" };

265
    case 0xea: return { "ld   ($", hex<2>(p1), hex<2>(p0), "),a" };

266
    case 0xeb: return { "xx" };

267
    case 0xec: return { "xx" };

268
    case 0xed: return { "xx" };

269
    case 0xee: return { "xor  a,$", hex<2>(p0) };

270
    case 0xef: return { "rst  $0028" };

271
    case 0xf0: return { "ld   a,($ff", hex<2>(p0), ")" };

272
    case 0xf1: return { "pop  af" };

273
    case 0xf2: return { "ld   a,($ff00+c)" };

274
    case 0xf3: return { "di" };

275
    case 0xf4: return { "xx" };

276
    case 0xf5: return { "push af" };

277
    case 0xf6: return { "or   a,$", hex<2>(p0) };

278
    case 0xf7: return { "rst  $0030" };

279
    case 0xf8: return { "ld   hl,sp+$", hex<4>((int8)p0) };

280
    case 0xf9: return { "ld   sp,hl" };

281
    case 0xfa: return { "ld   a,($", hex<2>(p1), hex<2>(p0), ")" };

282
    case 0xfb: return { "ei" };

283
    case 0xfc: return { "xx" };

284
    case 0xfd: return { "xx" };

285
    case 0xfe: return { "cp   a,$", hex<2>(p0) };

286
    case 0xff: return { "rst  $0038" };

287
  }

288


289
  return "";

290
}

291


292
string CPU::disassemble_opcode_cb(uint16 pc) {

293
  uint8 opcode = bus.read(pc);

294
  uint8 p0 = bus.read(pc + 1);

295
  uint8 p1 = bus.read(pc + 2);

296
  uint8 p2 = bus.read(pc + 3);

297


298
  switch(opcode) {

299
    case 0x00: return { "rlc  b" };

300
    case 0x01: return { "rlc  c" };

301
    case 0x02: return { "rlc  d" };

302
    case 0x03: return { "rlc  e" };

303
    case 0x04: return { "rlc  h" };

304
    case 0x05: return { "rlc  l" };

305
    case 0x06: return { "rlc  (hl)" };

306
    case 0x07: return { "rlc  a" };

307
    case 0x08: return { "rrc  b" };

308
    case 0x09: return { "rrc  c" };

309
    case 0x0a: return { "rrc  d" };

310
    case 0x0b: return { "rrc  e" };

311
    case 0x0c: return { "rrc  h" };

312
    case 0x0d: return { "rrc  l" };

313
    case 0x0e: return { "rrc  (hl)" };

314
    case 0x0f: return { "rrc  a" };

315
    case 0x10: return { "rl   b" };

316
    case 0x11: return { "rl   c" };

317
    case 0x12: return { "rl   d" };

318
    case 0x13: return { "rl   e" };

319
    case 0x14: return { "rl   h" };

320
    case 0x15: return { "rl   l" };

321
    case 0x16: return { "rl   (hl)" };

322
    case 0x17: return { "rl   a" };

323
    case 0x18: return { "rr   b" };

324
    case 0x19: return { "rr   c" };

325
    case 0x1a: return { "rr   d" };

326
    case 0x1b: return { "rr   e" };

327
    case 0x1c: return { "rr   h" };

328
    case 0x1d: return { "rr   l" };

329
    case 0x1e: return { "rr   (hl)" };

330
    case 0x1f: return { "rr   a" };

331
    case 0x20: return { "sla  b" };

332
    case 0x21: return { "sla  c" };

333
    case 0x22: return { "sla  d" };

334
    case 0x23: return { "sla  e" };

335
    case 0x24: return { "sla  h" };

336
    case 0x25: return { "sla  l" };

337
    case 0x26: return { "sla  (hl)" };

338
    case 0x27: return { "sla  a" };

339
    case 0x28: return { "sra  b" };

340
    case 0x29: return { "sra  c" };

341
    case 0x2a: return { "sra  d" };

342
    case 0x2b: return { "sra  e" };

343
    case 0x2c: return { "sra  h" };

344
    case 0x2d: return { "sra  l" };

345
    case 0x2e: return { "sra  (hl)" };

346
    case 0x2f: return { "sra  a" };

347
    case 0x30: return { "swap b" };

348
    case 0x31: return { "swap c" };

349
    case 0x32: return { "swap d" };

350
    case 0x33: return { "swap e" };

351
    case 0x34: return { "swap h" };

352
    case 0x35: return { "swap l" };

353
    case 0x36: return { "swap (hl)" };

354
    case 0x37: return { "swap a" };

355
    case 0x38: return { "srl  b" };

356
    case 0x39: return { "srl  c" };

357
    case 0x3a: return { "srl  d" };

358
    case 0x3b: return { "srl  e" };

359
    case 0x3c: return { "srl  h" };

360
    case 0x3d: return { "srl  l" };

361
    case 0x3e: return { "srl  (hl)" };

362
    case 0x3f: return { "srl  a" };

363
    case 0x40: return { "bit  0,b" };

364
    case 0x41: return { "bit  0,c" };

365
    case 0x42: return { "bit  0,d" };

366
    case 0x43: return { "bit  0,e" };

367
    case 0x44: return { "bit  0,h" };

368
    case 0x45: return { "bit  0,l" };

369
    case 0x46: return { "bit  0,(hl)" };

370
    case 0x47: return { "bit  0,a" };

371
    case 0x48: return { "bit  1,b" };

372
    case 0x49: return { "bit  1,c" };

373
    case 0x4a: return { "bit  1,d" };

374
    case 0x4b: return { "bit  1,e" };

375
    case 0x4c: return { "bit  1,h" };

376
    case 0x4d: return { "bit  1,l" };

377
    case 0x4e: return { "bit  1,(hl)" };

378
    case 0x4f: return { "bit  1,a" };

379
    case 0x50: return { "bit  2,b" };

380
    case 0x51: return { "bit  2,c" };

381
    case 0x52: return { "bit  2,d" };

382
    case 0x53: return { "bit  2,e" };

383
    case 0x54: return { "bit  2,h" };

384
    case 0x55: return { "bit  2,l" };

385
    case 0x56: return { "bit  2,(hl)" };

386
    case 0x57: return { "bit  2,a" };

387
    case 0x58: return { "bit  3,b" };

388
    case 0x59: return { "bit  3,c" };

389
    case 0x5a: return { "bit  3,d" };

390
    case 0x5b: return { "bit  3,e" };

391
    case 0x5c: return { "bit  3,h" };

392
    case 0x5d: return { "bit  3,l" };

393
    case 0x5e: return { "bit  3,(hl)" };

394
    case 0x5f: return { "bit  3,a" };

395
    case 0x60: return { "bit  4,b" };

396
    case 0x61: return { "bit  4,c" };

397
    case 0x62: return { "bit  4,d" };

398
    case 0x63: return { "bit  4,e" };

399
    case 0x64: return { "bit  4,h" };

400
    case 0x65: return { "bit  4,l" };

401
    case 0x66: return { "bit  4,(hl)" };

402
    case 0x67: return { "bit  4,a" };

403
    case 0x68: return { "bit  5,b" };

404
    case 0x69: return { "bit  5,c" };

405
    case 0x6a: return { "bit  5,d" };

406
    case 0x6b: return { "bit  5,e" };

407
    case 0x6c: return { "bit  5,h" };

408
    case 0x6d: return { "bit  5,l" };

409
    case 0x6e: return { "bit  5,(hl)" };

410
    case 0x6f: return { "bit  5,a" };

411
    case 0x70: return { "bit  6,b" };

412
    case 0x71: return { "bit  6,c" };

413
    case 0x72: return { "bit  6,d" };

414
    case 0x73: return { "bit  6,e" };

415
    case 0x74: return { "bit  6,h" };

416
    case 0x75: return { "bit  6,l" };

417
    case 0x76: return { "bit  6,(hl)" };

418
    case 0x77: return { "bit  6,a" };

419
    case 0x78: return { "bit  7,b" };

420
    case 0x79: return { "bit  7,c" };

421
    case 0x7a: return { "bit  7,d" };

422
    case 0x7b: return { "bit  7,e" };

423
    case 0x7c: return { "bit  7,h" };

424
    case 0x7d: return { "bit  7,l" };

425
    case 0x7e: return { "bit  7,(hl)" };

426
    case 0x7f: return { "bit  7,a" };

427
    case 0x80: return { "res  0,b" };

428
    case 0x81: return { "res  0,c" };

429
    case 0x82: return { "res  0,d" };

430
    case 0x83: return { "res  0,e" };

431
    case 0x84: return { "res  0,h" };

432
    case 0x85: return { "res  0,l" };

433
    case 0x86: return { "res  0,(hl)" };

434
    case 0x87: return { "res  0,a" };

435
    case 0x88: return { "res  1,b" };

436
    case 0x89: return { "res  1,c" };

437
    case 0x8a: return { "res  1,d" };

438
    case 0x8b: return { "res  1,e" };

439
    case 0x8c: return { "res  1,h" };

440
    case 0x8d: return { "res  1,l" };

441
    case 0x8e: return { "res  1,(hl)" };

442
    case 0x8f: return { "res  1,a" };

443
    case 0x90: return { "res  2,b" };

444
    case 0x91: return { "res  2,c" };

445
    case 0x92: return { "res  2,d" };

446
    case 0x93: return { "res  2,e" };

447
    case 0x94: return { "res  2,h" };

448
    case 0x95: return { "res  2,l" };

449
    case 0x96: return { "res  2,(hl)" };

450
    case 0x97: return { "res  2,a" };

451
    case 0x98: return { "res  3,b" };

452
    case 0x99: return { "res  3,c" };

453
    case 0x9a: return { "res  3,d" };

454
    case 0x9b: return { "res  3,e" };

455
    case 0x9c: return { "res  3,h" };

456
    case 0x9d: return { "res  3,l" };

457
    case 0x9e: return { "res  3,(hl)" };

458
    case 0x9f: return { "res  3,a" };

459
    case 0xa0: return { "res  4,b" };

460
    case 0xa1: return { "res  4,c" };

461
    case 0xa2: return { "res  4,d" };

462
    case 0xa3: return { "res  4,e" };

463
    case 0xa4: return { "res  4,h" };

464
    case 0xa5: return { "res  4,l" };

465
    case 0xa6: return { "res  4,(hl)" };

466
    case 0xa7: return { "res  4,a" };

467
    case 0xa8: return { "res  5,b" };

468
    case 0xa9: return { "res  5,c" };

469
    case 0xaa: return { "res  5,d" };

470
    case 0xab: return { "res  5,e" };

471
    case 0xac: return { "res  5,h" };

472
    case 0xad: return { "res  5,l" };

473
    case 0xae: return { "res  5,(hl)" };

474
    case 0xaf: return { "res  5,a" };

475
    case 0xb0: return { "res  6,b" };

476
    case 0xb1: return { "res  6,c" };

477
    case 0xb2: return { "res  6,d" };

478
    case 0xb3: return { "res  6,e" };

479
    case 0xb4: return { "res  6,h" };

480
    case 0xb5: return { "res  6,l" };

481
    case 0xb6: return { "res  6,(hl)" };

482
    case 0xb7: return { "res  6,a" };

483
    case 0xb8: return { "res  7,b" };

484
    case 0xb9: return { "res  7,c" };

485
    case 0xba: return { "res  7,d" };

486
    case 0xbb: return { "res  7,e" };

487
    case 0xbc: return { "res  7,h" };

488
    case 0xbd: return { "res  7,l" };

489
    case 0xbe: return { "res  7,(hl)" };

490
    case 0xbf: return { "res  7,a" };

491
    case 0xc0: return { "set  0,b" };

492
    case 0xc1: return { "set  0,c" };

493
    case 0xc2: return { "set  0,d" };

494
    case 0xc3: return { "set  0,e" };

495
    case 0xc4: return { "set  0,h" };

496
    case 0xc5: return { "set  0,l" };

497
    case 0xc6: return { "set  0,(hl)" };

498
    case 0xc7: return { "set  0,a" };

499
    case 0xc8: return { "set  1,b" };

500
    case 0xc9: return { "set  1,c" };

501
    case 0xca: return { "set  1,d" };

502
    case 0xcb: return { "set  1,e" };

503
    case 0xcc: return { "set  1,h" };

504
    case 0xcd: return { "set  1,l" };

505
    case 0xce: return { "set  1,(hl)" };

506
    case 0xcf: return { "set  1,a" };

507
    case 0xd0: return { "set  2,b" };

508
    case 0xd1: return { "set  2,c" };

509
    case 0xd2: return { "set  2,d" };

510
    case 0xd3: return { "set  2,e" };

511
    case 0xd4: return { "set  2,h" };

512
    case 0xd5: return { "set  2,l" };

513
    case 0xd6: return { "set  2,(hl)" };

514
    case 0xd7: return { "set  2,a" };

515
    case 0xd8: return { "set  3,b" };

516
    case 0xd9: return { "set  3,c" };

517
    case 0xda: return { "set  3,d" };

518
    case 0xdb: return { "set  3,e" };

519
    case 0xdc: return { "set  3,h" };

520
    case 0xdd: return { "set  3,l" };

521
    case 0xde: return { "set  3,(hl)" };

522
    case 0xdf: return { "set  3,a" };

523
    case 0xe0: return { "set  4,b" };

524
    case 0xe1: return { "set  4,c" };

525
    case 0xe2: return { "set  4,d" };

526
    case 0xe3: return { "set  4,e" };

527
    case 0xe4: return { "set  4,h" };

528
    case 0xe5: return { "set  4,l" };

529
    case 0xe6: return { "set  4,(hl)" };

530
    case 0xe7: return { "set  4,a" };

531
    case 0xe8: return { "set  5,b" };

532
    case 0xe9: return { "set  5,c" };

533
    case 0xea: return { "set  5,d" };

534
    case 0xeb: return { "set  5,e" };

535
    case 0xec: return { "set  5,h" };

536
    case 0xed: return { "set  5,l" };

537
    case 0xee: return { "set  5,(hl)" };

538
    case 0xef: return { "set  5,a" };

539
    case 0xf0: return { "set  6,b" };

540
    case 0xf1: return { "set  6,c" };

541
    case 0xf2: return { "set  6,d" };

542
    case 0xf3: return { "set  6,e" };

543
    case 0xf4: return { "set  6,h" };

544
    case 0xf5: return { "set  6,l" };

545
    case 0xf6: return { "set  6,(hl)" };

546
    case 0xf7: return { "set  6,a" };

547
    case 0xf8: return { "set  7,b" };

548
    case 0xf9: return { "set  7,c" };

549
    case 0xfa: return { "set  7,d" };

550
    case 0xfb: return { "set  7,e" };

551
    case 0xfc: return { "set  7,h" };

552
    case 0xfd: return { "set  7,l" };

553
    case 0xfe: return { "set  7,(hl)" };

554
    case 0xff: return { "set  7,a" };

555
  }

556


557
  return "";

558
}

559


560
#endif

561


562