text: class AddressModes(object):
      Illegal                 = 0     # .byte 0x04      04
      Immediate               = 1     # ADC #$A5        69 A5
      Accumulator             = 2     # ROL A           2A
      ZeroPage                = 3     # ADC $40         65 40
      ZeroPageX               = 4     # ADC $5E,X       75 5E
      ZeroPageY               = 5     # LDX $62,Y       B6 62
      Absolute                = 6     # ADC $AD12       6D 12 AD
      AbsoluteX               = 7     # ADC $AD12,X     7D 12 AD
      AbsoluteY               = 8     # ADC $AD12,Y     79 12 AD
      Implied                 = 9     # CLC             18
      Relative                = 10    # BCC *-12        90 F2
      IndirectX               = 11    # ADC ($1E,X)     61 1E
      IndirectY               = 12    # ADC ($1E),Y     71 1E
      IndirectAbsolute        = 13    # JMP ($1400)     6C 00 14
      ZeroPageIndirect        = 14    # JMP ($45)       B2 45
      SpecialPage             = 15    # JMP \$FFC0      22 C0
      ZeroPageBit             = 16    # CLB 5,$44       BF 44
      AccumulatorBit          = 17    # CLB 5,A         BB
      AccumulatorBitRelative  = 18    # BC 5,A,*-12     B3 F2
      ZeroPageBitRelative     = 19    # BBC 5,$04,*-12  B7 04 F1
      ZeroPageImmediate       = 20    # LDM #0xaa,0xbb  3C AA BB
  
  InstructionLengths = {
      AddressModes.Illegal:                 1,
      AddressModes.Immediate:               2,
      AddressModes.Accumulator:             1,
      AddressModes.ZeroPage:                2,
      AddressModes.ZeroPageX:               2,
      AddressModes.ZeroPageY:               2,
      AddressModes.Absolute:                3,
      AddressModes.AbsoluteX:               3,
      AddressModes.AbsoluteY:               3,
      AddressModes.Implied:                 1,
      AddressModes.Relative:                2,
      AddressModes.IndirectX:               2,
      AddressModes.IndirectY:               2,
      AddressModes.IndirectAbsolute:        3,
      AddressModes.ZeroPageIndirect:        2,
      AddressModes.SpecialPage:             2,
      AddressModes.ZeroPageBit:             2,
      AddressModes.AccumulatorBit:          1,
      AddressModes.AccumulatorBitRelative:  2,
      AddressModes.ZeroPageBitRelative:     3,
      AddressModes.ZeroPageImmediate:       3,
  }
  
  class FlowTypes(object):
      Continue = 0
      Stop = 1
      UnconditionalJump = 2
      IndirectUnconditionalJump = 3
      IndirectSubroutineCall = 4
      ConditionalJump = 5
      SubroutineCall = 6
      SubroutineReturn = 7
  
  class Opcode(object):
      def __init__(self, **kwargs):
          for k, v in kwargs.items():
              setattr(self, k, v)
  
  Opcodes = (
      # brk                 ;00         Implied
      Opcode(number=0x00,
             disasm_template="brk",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Stop,
            ),
      # ora [0x1E,x]        ;01 1e      Indirect X
      Opcode(number=0x01,
             disasm_template="ora [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # jsr [0x45]          ;02 45      Zero Page Indirect
      Opcode(number=0x02,
             disasm_template="jsr [{zp}]",
             addr_mode=AddressModes.ZeroPageIndirect,
             flow_type=FlowTypes.IndirectSubroutineCall,
            ),
      # bbs 0,a,label4      ;03 fe      Accumulator Bit Relative
      Opcode(number=0x03,
             disasm_template="bbs 0,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0x04          ;04         Illegal
      Opcode(number=0x04,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # ora 0x45            ;05 45      Zero Page
      Opcode(number=0x05,
             disasm_template="ora {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # asl 0x45            ;06 45      Zero Page
      Opcode(number=0x06,
             disasm_template="asl {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 0,0xaa,label5   ;07 aa fd   Zero Page Bit Relative
      Opcode(number=0x07,
             disasm_template="bbs 0,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # php                 ;08         Implied
      Opcode(number=0x08,
             disasm_template="php",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # ora #0xaa           ;09 aa      Immediate
      Opcode(number=0x09,
             disasm_template="ora #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # asl a               ;0a         Implied
      Opcode(number=0x0a,
             disasm_template="asl a",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 0,a             ;0b         Accumulator Bit
      Opcode(number=0x0b,
             disasm_template="seb 0,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x0c          ;0c         Illegal
      Opcode(number=0x0c,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # ora 0xaabb          ;0d bb aa   Absolute
      Opcode(number=0x0d,
             disasm_template="ora {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # asl 0xaabb          ;0e bb aa   Absolute
      Opcode(number=0x0e,
             disasm_template="asl {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 0,0xaa          ;0f aa      Zero Page Bit
      Opcode(number=0x0f,
             disasm_template="seb 0,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bpl label6          ;10 fe      Relative
      Opcode(number=0x10,
             disasm_template="bpl {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # ora [0xaa],y        ;11 aa      Indirect Y
      Opcode(number=0x11,
             disasm_template="ora [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # clt                 ;12         Implied
      Opcode(number=0x12,
             disasm_template="clt",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 0,a,label7      ;13 fe      Accumulator Bit Relative
      Opcode(number=0x13,
             disasm_template="bbc 0,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0x14          ;14         Illegal
      Opcode(number=0x14,
             disasm_template=".byte 0x14",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # ora 0xaa,x          ;15 aa      Zero Page X
      Opcode(number=0x15,
             disasm_template="ora {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # asl 0xaa,x          ;16 aa      Zero Page X
      Opcode(number=0x16,
             disasm_template="asl {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 0,0xaa,label8   ;17 aa fd   Zero Page Bit Relative
      Opcode(number=0x17,
             disasm_template="bbc 0,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # clc                 ;18         Implied
      Opcode(number=0x18,
             disasm_template="clc",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # ora 0xaabb,y        ;19 bb aa   Absolute Y
      Opcode(number=0x19,
             disasm_template="ora {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # dec a               ;1a         Implied
      Opcode(number=0x1a,
             disasm_template="dec a",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # clb 0,a             ;1b         Accumulator Bit
      Opcode(number=0x1b,
             disasm_template="clb 0,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x1c          ;1c         Illegal
      Opcode(number=0x1c,
             disasm_template=".byte 0x1c",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # ora 0xaabb,x        ;1d bb aa   Absolute X
      Opcode(number=0x1d,
             disasm_template="ora {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # asl 0xaabb,x        ;1e bb aa   Absolute X
      Opcode(number=0x1e,
             disasm_template="asl {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # clb 0,0xaa          ;1f aa      Zero Page Bit
      Opcode(number=0x1f,
             disasm_template="clb 0,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # jsr 0xaabb          ;20 bb aa   Absolute
      Opcode(number=0x20,
             disasm_template="jsr {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.SubroutineCall,
            ),
      # and [0xaa,x]        ;21 aa      Indirect X
      Opcode(number=0x21,
             disasm_template="and [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # jsr \0xffaa         ;22         Special Page
      Opcode(number=0x22,
             disasm_template="jsr \\{sp}",
             addr_mode=AddressModes.SpecialPage,
             flow_type=FlowTypes.SubroutineCall,
            ),
      # bbs 1,a,label9      ;23 fe      Accumulator Bit Relative
      Opcode(number=0x23,
             disasm_template="bbs 1,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # bit 0xaa            ;24 aa      Zero Page
      Opcode(number=0x24,
             disasm_template="bit {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # and 0xaa            ;25 aa      Zero Page
      Opcode(number=0x25,
             disasm_template="and {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # rol 0xaa            ;26 aa      Zero Page
      Opcode(number=0x26,
             disasm_template="rol {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 1,0xaa,label10  ;27 aa fd   Zero Page Bit Relative
      Opcode(number=0x27,
             disasm_template="bbs 1,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # plp                 ;28         Implied
      Opcode(number=0x28,
             disasm_template="plp",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # and #0xaa           ;29 aa      Immediate
      Opcode(number=0x29,
             disasm_template="and #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # rol a               ;2a         Implied
      Opcode(number=0x2a,
             disasm_template="rol a",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 1,a             ;2b         Accumulator Bit
      Opcode(number=0x2b,
             disasm_template="seb 1,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # bit 0xaabb          ;2c bb aa   Absolute
      Opcode(number=0x2c,
             disasm_template="bit {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # and 0xaabb          ;2d bb aa   Absolute
      Opcode(number=0x2d,
             disasm_template="and {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # rol 0xaabb          ;2e bb aa   Absolute
      Opcode(number=0x2e,
             disasm_template="rol {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 1,0xaa          ;2f aa      Zero Page Bit
      Opcode(number=0x2f,
             disasm_template="seb 1,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bmi label11         ;30 fe      Relative
      Opcode(number=0x30,
             disasm_template="bmi {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # and [0xaa],y        ;31 aa      Indirect Y
      Opcode(number=0x31,
             disasm_template="and [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # set                 ;32         Implied
      Opcode(number=0x32,
             disasm_template="set",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 1,a,label12     ;33 fe      Accumulator Bit Relative
      Opcode(number=0x33,
             disasm_template="bbc 1,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0x34          ;34 00      Illegal
      Opcode(number=0x34,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # and 0xaa,x          ;35 aa      Zero Page X
      Opcode(number=0x35,
             disasm_template="and {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # rol 0xaa,x          ;36 aa      Zero Page X
      Opcode(number=0x36,
             disasm_template="rol {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 1,0xaa,label13  ;37 aa fd   Zero Page Bit Relative
      Opcode(number=0x37,
             disasm_template="bbc 1,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sec                 ;38         Implied
      Opcode(number=0x38,
             disasm_template="sec",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # and 0xaabb,y        ;39 bb aa   Absolute Y
      Opcode(number=0x39,
             disasm_template="and {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # inc a               ;3a         Implied
      Opcode(number=0x3a,
             disasm_template="inc a",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # clb 1,a             ;3b         Accumulator Bit
      Opcode(number=0x3b,
             disasm_template="clb 1,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # ldm #0xaa,0xbb      ;3c aa bb   Zero Page Immediate
      Opcode(number=0x3c,
             disasm_template="ldm #{imm},{zp}",
             addr_mode=AddressModes.ZeroPageImmediate,
             flow_type=FlowTypes.Continue,
            ),
      # and 0xaabb,x        ;3d bb aa   Absolute X
      Opcode(number=0x3d,
             disasm_template="and {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # rol 0xaabb,x        ;3e bb aa   Absolute X
      Opcode(number=0x3e,
             disasm_template="rol {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # clb 1,0xaa          ;3f aa      Zero Page Bit
      Opcode(number=0x3f,
             disasm_template="clb 1,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # rti                 ;40         Implied
      Opcode(number=0x40,
             disasm_template="rti",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.SubroutineReturn,
            ),
      # eor [0xaa,x]        ;41 aa      Indirect X
      Opcode(number=0x41,
             disasm_template="eor [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # stp                 ;42         Implied
      Opcode(number=0x42,
             disasm_template="stp",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Stop,
            ),
      # bbs 2,a,label14     ;43 fe      Accumulator Bit Relative
      Opcode(number=0x43,
             disasm_template="bbs 2,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # com 0xaa            ;44 aa      Zero Page
      Opcode(number=0x44,
             disasm_template="com {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # eor 0xaa            ;45 aa      Zero Page
      Opcode(number=0x45,
             disasm_template="eor {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # lsr 0xaa            ;46 aa      Zero Page
      Opcode(number=0x46,
             disasm_template="lsr {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 2,0xaa,label15  ;47 aa fd   Zero Page Bit Relative
      Opcode(number=0x47,
             disasm_template="bbs 2,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # pha                 ;48         Implied
      Opcode(number=0x48,
             disasm_template="pha",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # eor #0xaa           ;49 aa      Immediate
      Opcode(number=0x49,
             disasm_template="eor #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # lsr a               ;4a         Implied
      Opcode(number=0x4a,
             disasm_template="lsr a",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 2,a             ;4b         Accumulator Bit
      Opcode(number=0x4b,
             disasm_template="seb 2,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # jmp 0xaabb          ;4c bb aa   Absolute
      Opcode(number=0x4c,
             disasm_template="jmp {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.UnconditionalJump,
            ),
      # eor 0xaabb          ;4d bb aa   Absolute
      Opcode(number=0x4d,
             disasm_template="eor {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # lsr 0xaabb          ;4e bb aa   Absolute
      Opcode(number=0x4e,
             disasm_template="lsr {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 2,0xaa          ;4f aa      Zero Page Bit
      Opcode(number=0x4f,
             disasm_template="seb 2,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bvc label16         ;50 fe      Relative
      Opcode(number=0x50,
             disasm_template="bvc {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # eor [0xaa],y        ;51 aa      Indirect Y
      Opcode(number=0x51,
             disasm_template="eor [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x52          ;52         Illegal
      Opcode(number=0x52,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # bbc 2,a,label17     ;53 fe      Accumulator Bit Relative
      Opcode(number=0x53,
             disasm_template="bbc 2,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0x54          ;54         Illegal
      Opcode(number=0x54,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # eor 0xaa,x          ;55 aa      Zero Page X
      Opcode(number=0x55,
             disasm_template="eor {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # lsr 0xaa,x          ;56 aa      Zero Page X
      Opcode(number=0x56,
             disasm_template="lsr {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 2,0xaa,label18  ;57 aa fd   Zero Page Bit Relative
      Opcode(number=0x57,
             disasm_template="bbc 2,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # cli                 ;58         Implied
      Opcode(number=0x58,
             disasm_template="cli",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # eor 0xaabb,y        ;59 bb aa   Absolute Y
      Opcode(number=0x59,
             disasm_template="eor {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x5a          ;5a         Illegal
      Opcode(number=0x5a,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # clb 2,a             ;5b         Accumulator Bit
      Opcode(number=0x5b,
             disasm_template="clb 2,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x5c          ;5c         Illegal
      Opcode(number=0x5c,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # eor 0xaabb,x        ;5d bb aa   Absolute X
      Opcode(number=0x5d,
             disasm_template="eor {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # lsr 0xaabb,x        ;5e bb aa   Absolute X
      Opcode(number=0x5e,
             disasm_template="lsr {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # clb 2,0xaa          ;5f aa      Zero Page Bit
      Opcode(number=0x5f,
             disasm_template="clb 2,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # rts                 ;60         Implied
      Opcode(number=0x60,
             disasm_template="rts",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.SubroutineReturn,
            ),
      # adc [0xaa,x]        ;61 aa      Indirect X
      Opcode(number=0x61,
             disasm_template="adc [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # mul 0xaa,x          ;62 aa      Zero Page X
      Opcode(number=0x62,
             disasm_template="mul {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 3,a,label19     ;63 fe      Accumulator Bit Relative
      Opcode(number=0x63,
             disasm_template="bbs 3,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # tst 0xaa            ;64 aa      Zero Page
      Opcode(number=0x64,
             disasm_template="tst {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # adc 0xaa            ;65 aa      Zero Page
      Opcode(number=0x65,
             disasm_template="adc {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # ror 0xaa            ;66 aa      Zero Page
      Opcode(number=0x66,
             disasm_template="ror {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 3,0xaa,label20  ;67 aa fd   Zero Page Bit Relative
      Opcode(number=0x67,
             disasm_template="bbs 3,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # pla                 ;68         Implied
      Opcode(number=0x68,
             disasm_template="pla",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # adc #0xaa           ;69 aa      Immediate
      Opcode(number=0x69,
             disasm_template="adc #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # ror a               ;6a         Implied
      Opcode(number=0x6a,
             disasm_template="ror a",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 3,a             ;6b         Accumulator Bit
      Opcode(number=0x6b,
             disasm_template="seb 3,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # jmp [0xaabb]        ;6c bb aa   Indirect Absolute
      Opcode(number=0x6c,
             disasm_template="jmp [{abs}]",
             addr_mode=AddressModes.IndirectAbsolute,
             flow_type=FlowTypes.IndirectUnconditionalJump,
            ),
      # adc 0xaabb          ;6d bb aa   Absolute
      Opcode(number=0x6d,
             disasm_template="adc {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # ror 0xaabb          ;6e bb aa   Absolute
      Opcode(number=0x6e,
             disasm_template="ror {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 3,0xaa          ;6f aa      Zero Page Bit
      Opcode(number=0x6f,
             disasm_template="seb 3,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bvs label21         ;70 fe      Relative
      Opcode(number=0x70,
             disasm_template="bvs {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # adc [0xaa],y        ;71 aa      Indirect Y
      Opcode(number=0x71,
             disasm_template="adc [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x72          ;72         Illegal
      Opcode(number=0x72,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # bbc 3,a,label22     ;73 fe      Accumulator Bit Relative
      Opcode(number=0x73,
             disasm_template="bbc 3,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0x74          ;74         Illegal
      Opcode(number=0x74,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # adc 0xaa,x          ;75 aa      Zero Page X
      Opcode(number=0x75,
             disasm_template="adc {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # ror 0xaa,x          ;76 aa      Zero Page X
      Opcode(number=0x76,
             disasm_template="ror {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 3,0xaa,label23  ;77 aa fd   Zero Page Bit Relative
      Opcode(number=0x77,
             disasm_template="bbc 3,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sei                 ;78         Implied
      Opcode(number=0x78,
             disasm_template="sei",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # adc 0xaabb,y        ;79 bb aa   Absolute Y
      Opcode(number=0x79,
             disasm_template="adc {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x7a          ;7a         Illegal
      Opcode(number=0x7a,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # clb 3,a             ;7b         Accumulator Bit
      Opcode(number=0x7b,
             disasm_template="clb 3,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x7c          ;7c         Illegal
      Opcode(number=0x7c,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # adc 0xaabb,x        ;7d bb aa   Absolute X
      Opcode(number=0x7d,
             disasm_template="adc {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # ror 0xaabb,x        ;7e bb aa   Absolute X
      Opcode(number=0x7e,
             disasm_template="ror {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # clb 3,0xaa          ;7f aa      Zero Page Bit
      Opcode(number=0x7f,
             disasm_template="clb 3,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bra label24         ;80 fe      Relative
      Opcode(number=0x80,
             disasm_template="bra {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.UnconditionalJump,
            ),
      # sta [0xaa,x]        ;81 aa      Indirect X
      Opcode(number=0x81,
             disasm_template="sta [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # rrf 0xaa            ;82 aa      Zero Page
      Opcode(number=0x82,
             disasm_template="rrf {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 4,a,label25     ;83 fe      Accumulator Bit Relative
      Opcode(number=0x83,
             disasm_template="bbs 4,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sty 0xaa            ;84 aa      Zero Page
      Opcode(number=0x84,
             disasm_template="sty {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # sta 0xaa            ;85 aa      Zero Page
      Opcode(number=0x85,
             disasm_template="sta {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # stx 0xaa            ;86 aa      Zero Page
      Opcode(number=0x86,
             disasm_template="stx {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 4,0xaa,label26  ;87 aa fd   Zero Page Bit Relative
      Opcode(number=0x87,
             disasm_template="bbs 4,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # dey                 ;88         Implied
      Opcode(number=0x88,
             disasm_template="dey",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x89          ;89         Illegal
      Opcode(number=0x89,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # txa                 ;8a         Implied
      Opcode(number=0x8a,
             disasm_template="txa",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 4,a             ;8b         Accumulator Bit
      Opcode(number=0x8b,
             disasm_template="seb 4,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # sty 0xaabb          ;8c bb aa   Absolute
      Opcode(number=0x8c,
             disasm_template="sty {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # sta 0xaabb          ;8d bb aa   Absolute
      Opcode(number=0x8d,
             disasm_template="sta {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # stx 0xaabb          ;8e bb aa   Absolute
      Opcode(number=0x8e,
             disasm_template="stx {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 4,0xaa          ;8f aa      Zero Page Bit
      Opcode(number=0x8f,
             disasm_template="seb 4,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bcc label27         ;90 fe      Relative
      Opcode(number=0x90,
             disasm_template="bcc {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sta [0xaa],y        ;91 aa      Indirect Y
      Opcode(number=0x91,
             disasm_template="sta [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x92          ;92         Illegal
      Opcode(number=0x92,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # bbc 4,a,label28     ;93 fe      Accumulator Bit Relative
      Opcode(number=0x93,
             disasm_template="bbc 4,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sty 0xaa,x          ;94 aa      Zero Page X
      Opcode(number=0x94,
             disasm_template="sty {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # sta 0xaa,x          ;95 aa      Zero Page X
      Opcode(number=0x95,
             disasm_template="sta {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # stx 0xaa,y          ;96 aa      Zero Page Y
      Opcode(number=0x96,
             disasm_template="stx {zp},y",
             addr_mode=AddressModes.ZeroPageY,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 4,0xaa,label29  ;97 aa fd   Zero Page Bit Relative
      Opcode(number=0x97,
             disasm_template="bbc 4,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # tya                 ;98         Implied
      Opcode(number=0x98,
             disasm_template="tya",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # sta 0xaabb,y        ;99 bb aa   Absolute Y
      Opcode(number=0x99,
             disasm_template="sta {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # txs                 ;9a         Implied
      Opcode(number=0x9a,
             disasm_template="txs",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # clb 4,a             ;9b         Accumulator Bit
      Opcode(number=0x9b,
             disasm_template="clb 4,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x9c          ;9c         Illegal
      Opcode(number=0x9c,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # sta 0xaabb,x        ;9d bb aa   Absolute X
      Opcode(number=0x9d,
             disasm_template="sta {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0x9e          ;9e         Illegal
      Opcode(number=0x9e,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # clb 4,0xaa          ;9f aa      Zero Page Bit
      Opcode(number=0x9f,
             disasm_template="clb 4,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # ldy #0xaa           ;a0 aa      Immediate
      Opcode(number=0xa0,
             disasm_template="ldy #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # lda [0xaa,x]        ;a1 aa      Indirect X
      Opcode(number=0xa1,
             disasm_template="lda [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # ldx #0xaa           ;a2 aa      Immediate
      Opcode(number=0xa2,
             disasm_template="ldx #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 5,a,label30     ;a3 fe      Accumulator Bit Relative
      Opcode(number=0xa3,
             disasm_template="bbs 5,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # ldy 0xaa            ;a4 aa      Zero Page
      Opcode(number=0xa4,
             disasm_template="ldy {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # lda 0xaa            ;a5 aa      Zero Page
      Opcode(number=0xa5,
             disasm_template="lda {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # ldx 0xaa            ;a6 aa      Zero Page
      Opcode(number=0xa6,
             disasm_template="ldx {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 5,0xaa,label31  ;a7 aa fd   Zero Page Bit Relative
      Opcode(number=0xa7,
             disasm_template="bbs 5,{zp},{rel}",
             addr_mode=AddressModes. ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # tay                 ;a8         Implied
      Opcode(number=0xa8,
             disasm_template="tay",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # lda #0xaa           ;a9 aa      Immediate
      Opcode(number=0xa9,
             disasm_template="lda #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # tax                 ;aa         Implied
      Opcode(number=0xaa,
             disasm_template="tax",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 5,a             ;ab         Accumulator Bit
      Opcode(number=0xab,
             disasm_template="seb 5,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # ldy 0xaabb          ;ac bb aa   Absolute
      Opcode(number=0xac,
             disasm_template="ldy {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # lda 0xaabb          ;ad bb aa   Absolute
      Opcode(number=0xad,
             disasm_template="lda {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # ldx 0xaabb          ;ae bb aa   Absolute
      Opcode(number=0xae,
             disasm_template="ldx {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 5,0xaa          ;af aa      Zero Page Bit
      Opcode(number=0xaf,
             disasm_template="seb 5,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bcs label32         ;b0 fe      Relative
      Opcode(number=0xb0,
             disasm_template="bcs {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # lda [0xaa],y        ;b1 aa      Indirect Y
      Opcode(number=0xb1,
             disasm_template="lda [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # jmp [0xaa]          ;b2 aa      Zero Page Indirect
      Opcode(number=0xb2,
             disasm_template="jmp [{zp}]",
             addr_mode=AddressModes.ZeroPageIndirect,
             flow_type=FlowTypes.IndirectUnconditionalJump,
            ),
      # bbc 5,a,label33     ;b3 fe      Accumulator Bit Relative
      Opcode(number=0xb3,
             disasm_template="bbc 5,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # ldy 0xaa,x          ;b4 aa      Zero Page X
      Opcode(number=0xb4,
             disasm_template="ldy {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # lda 0xaa,x          ;b5 aa      Zero Page X
      Opcode(number=0xb5,
             disasm_template="lda {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # ldx 0xaa,y          ;b6 aa      Zero Page Y
      Opcode(number=0xb6,
             disasm_template="ldx {zp},y",
             addr_mode=AddressModes.ZeroPageY,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 5,0xaa,label34  ;b7 aa fd   Zero Page Bit Relative
      Opcode(number=0xb7,
             disasm_template="bbc 5,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # clv                 ;b8         Implied
      Opcode(number=0xb8,
             disasm_template="clv",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # lda 0xaabb,y        ;b9 bb aa   Absolute Y
      Opcode(number=0xb9,
             disasm_template="lda {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # tsx                 ;ba         Implied
      Opcode(number=0xba,
             disasm_template="tsx",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # clb 5,a             ;bb         Accumulator Bit
      Opcode(number=0xbb,
             disasm_template="clb 5,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # ldy 0xaabb,x        ;bc bb aa   Absolute X
      Opcode(number=0xbc,
             disasm_template="ldy {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # lda 0xaabb,x        ;bd bb aa   Absolute X
      Opcode(number=0xbd,
             disasm_template="lda {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # ldx 0xaabb,y        ;be bb aa   Absolute Y
      Opcode(number=0xbe,
             disasm_template="ldx {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # clb 5,0xaa          ;bf aa      Zero Page Bit
      Opcode(number=0xbf,
             disasm_template="clb 5,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # cpy #0xaa           ;c0 aa      Immediate
      Opcode(number=0xc0,
             disasm_template="cpy #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # cmp [0xaa,x]        ;c1 aa      Indirect X
      Opcode(number=0xc1,
             disasm_template="cmp [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # wit                 ;c2         Implied
      Opcode(number=0xc2,
             disasm_template="wit",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 6,a,label35     ;c3 fe      Accumulator Bit Relative
      Opcode(number=0xc3,
             disasm_template="bbs 6,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # cpy 0xaa            ;c4 aa      Zero Page
      Opcode(number=0xc4,
             disasm_template="cpy {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # cmp 0xaa            ;c5 aa      Zero Page
      Opcode(number=0xc5,
             disasm_template="cmp {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # dec 0xaa            ;c6 aa      Zero Page
      Opcode(number=0xc6,
             disasm_template="dec {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 6,0xaa,label36  ;c7 aa fd   Zero Page Bit Relative
      Opcode(number=0xc7,
             disasm_template="bbs 6,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # iny                 ;c8         Implied
      Opcode(number=0xc8,
             disasm_template="iny",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # cmp #0xaa           ;c9 aa      Immediate
      Opcode(number=0xc9,
             disasm_template="cmp #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # dex                 ;ca         Implied
      Opcode(number=0xca,
             disasm_template="dex",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 6,a             ;cb         Accumulator Bit
      Opcode(number=0xcb,
             disasm_template="seb 6,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # cpy 0xaabb          ;cc bb aa   Absolute
      Opcode(number=0xcc,
             disasm_template="cpy {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # cmp 0xaabb          ;cd bb aa   Absolute
      Opcode(number=0xcd,
             disasm_template="cmp {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # dec 0xaabb          ;ce bb aa   Absolute
      Opcode(number=0xce,
             disasm_template="dec {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 6,0xaa          ;cf aa      Zero Page Bit
      Opcode(number=0xcf,
             disasm_template="seb 6,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # bne label37         ;d0 fe      Relative
      Opcode(number=0xd0,
             disasm_template="bne {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # cmp [0xaa],y        ;d1 aa      Indirect Y
      Opcode(number=0xd1,
             disasm_template="cmp [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0xd2          ;d2         Illegal
      Opcode(number=0xd2,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # bbc 6,a,label38     ;d3 fe      Accumulator Bit Relative
      Opcode(number=0xd3,
             disasm_template="bbc 6,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0xd4          ;d4         Illegal
      Opcode(number=0xd4,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # cmp 0xaa,x          ;d5 aa      Zero Page X
      Opcode(number=0xd5,
             disasm_template="cmp {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # dec 0xaa,x          ;d6 aa      Zero Page X
      Opcode(number=0xd6,
             disasm_template="dec {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 6,0xaa,label39  ;d7 aa fd   Zero Page Bit Relative
      Opcode(number=0xd7,
             disasm_template="bbc 6,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # cld                 ;d8         Implied
      Opcode(number=0xd8,
             disasm_template="cld",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # cmp 0xaabb,y        ;d9 bb aa   Absolute Y
      Opcode(number=0xd9,
             disasm_template="cmp {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0xda          ;da         Illegal
      Opcode(number=0xda,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # clb 6,a             ;db         Accumulator Bit
      Opcode(number=0xdb,
             disasm_template="clb 6,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0xdc          ;dc         Illegal
      Opcode(number=0xdc,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # cmp 0xaabb,x        ;dd bb aa   Absolute X
      Opcode(number=0xdd,
             disasm_template="cmp {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # dec 0xaabb,x        ;de bb aa   Absolute X
      Opcode(number=0xde,
             disasm_template="dec {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # clb 6,0xaa          ;df aa      Zero Page Bit
      Opcode(number=0xdf,
             disasm_template="clb 6,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # cpx #0xaa           ;e0 aa      Immediate
      Opcode(number=0xe0,
             disasm_template="cpx #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # sbc [0xaa,x]        ;e1 aa      Indirect X
      Opcode(number=0xe1,
             disasm_template="sbc [{zp},x]",
             addr_mode=AddressModes.IndirectX,
             flow_type=FlowTypes.Continue,
            ),
      # div 0xaa,x          ;e2 aa      Zero Page X
      Opcode(number=0xe2,
             disasm_template="div {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 7,a,label40     ;e3 fe      Accumulator Bit Relative
      Opcode(number=0xe3,
             disasm_template="bbs 7,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # cpx 0xaa            ;e4 aa      Zero Page
      Opcode(number=0xe4,
             disasm_template="cpx {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # sbc 0xaa            ;e5 aa      Zero Page
      Opcode(number=0xe5,
             disasm_template="sbc {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # inc 0xaa            ;e6 aa      Zero Page
      Opcode(number=0xe6,
             disasm_template="inc {zp}",
             addr_mode=AddressModes.ZeroPage,
             flow_type=FlowTypes.Continue,
            ),
      # bbs 7,0xaa,label41  ;e7 aa fd   Zero Page Bit Relative
      Opcode(number=0xe7,
             disasm_template="bbs 7,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # inx                 ;e8         Implied
      Opcode(number=0xe8,
             disasm_template="inx",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # sbc #0xaa           ;e9 aa      Immediate
      Opcode(number=0xe9,
             disasm_template="sbc #{imm}",
             addr_mode=AddressModes.Immediate,
             flow_type=FlowTypes.Continue,
            ),
      # nop                 ;ea         Implied
      Opcode(number=0xea,
             disasm_template="nop",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # seb 7,a             ;eb         Accumulator Bit
      Opcode(number=0xeb,
             disasm_template="seb 7,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # cpx 0xaabb          ;ec bb aa   Absolute
      Opcode(number=0xec,
             disasm_template="cpx {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # sbc 0xaabb          ;ed bb aa   Absolute
      Opcode(number=0xed,
             disasm_template="sbc {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # inc 0xaabb          ;ee bb aa   Absolute
      Opcode(number=0xee,
             disasm_template="inc {abs}",
             addr_mode=AddressModes.Absolute,
             flow_type=FlowTypes.Continue,
            ),
      # seb 7,0xaa          ;ef aa      Zero Page Bit
      Opcode(number=0xef,
             disasm_template="seb 7,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
      # beq label42         ;f0 fe      Relative
      Opcode(number=0xf0,
             disasm_template="beq {rel}",
             addr_mode=AddressModes.Relative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sbc [0xaa],y        ;f1 aa      Indirect Y
      Opcode(number=0xf1,
             disasm_template="sbc [{zp}],y",
             addr_mode=AddressModes.IndirectY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0xf2          ;f2         Illegal
      Opcode(number=0xf2,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # bbc 7,a,label43     ;f3 fe      Accumulator Bit Relative
      Opcode(number=0xf3,
             disasm_template="bbc 7,a,{rel}",
             addr_mode=AddressModes.AccumulatorBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # .byte 0xf4          ;f4         Illegal
      Opcode(number=0xf4,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # sbc 0xaa,x          ;f5 aa      Zero Page X
      Opcode(number=0xf5,
             disasm_template="sbc {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # inc 0xaa,x          ;f6 aa      Zero Page X
      Opcode(number=0xf6,
             disasm_template="inc {zp},x",
             addr_mode=AddressModes.ZeroPageX,
             flow_type=FlowTypes.Continue,
            ),
      # bbc 7,0xaa,label44  ;f7 aa fd   Zero Page Bit Relative
      Opcode(number=0xf7,
             disasm_template="bbc 7,{zp},{rel}",
             addr_mode=AddressModes.ZeroPageBitRelative,
             flow_type=FlowTypes.ConditionalJump,
            ),
      # sed                 ;f8         Implied
      Opcode(number=0xf8,
             disasm_template="sed",
             addr_mode=AddressModes.Implied,
             flow_type=FlowTypes.Continue,
            ),
      # sbc 0xaabb,y        ;f9 bb aa   Absolute Y
      Opcode(number=0xf9,
             disasm_template="sbc {abs},y",
             addr_mode=AddressModes.AbsoluteY,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0xfa          ;fa         Illegal
      Opcode(number=0xfa,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # clb 7,a             ;fb         Accumulator Bit
      Opcode(number=0xfb,
             disasm_template="clb 7,a",
             addr_mode=AddressModes.AccumulatorBit,
             flow_type=FlowTypes.Continue,
            ),
      # .byte 0xfc          ;fc         Illegal
      Opcode(number=0xfc,
             disasm_template=".byte {opc}",
             addr_mode=AddressModes.Illegal,
             flow_type=FlowTypes.Stop,
            ),
      # sbc 0xaabb,x        ;fd bb aa   Absolute X
      Opcode(number=0xfd,
             disasm_template="sbc {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # inc 0xaabb,x        ;fe bb aa   Absolute X
      Opcode(number=0xfe,
             disasm_template="inc {abs},x",
             addr_mode=AddressModes.AbsoluteX,
             flow_type=FlowTypes.Continue,
            ),
      # clb 7,0xaa          ;ff aa      Zero Page Bit
      Opcode(number=0xff,
             disasm_template="clb 7,{zp}",
             addr_mode=AddressModes.ZeroPageBit,
             flow_type=FlowTypes.Continue,
            ),
  )
  