1000000000000000 00000000 8000 W 00 BRA WRITE $00 -> $8000 0000000000000000 00000000 0000 W 00 BRA WRITE $00 -> $0000 0000000000000000 00000000 0000 W 00 WRITE $00 -> $0000 1111111100000000 11111111 ff00 r ff BBS7 ... fetch opcode 1111011111111111 11111111 f7ff r ff BBS7 $F7FF branch if bit 7 set 1111011111111111 11111111 f7ff r ff BBS7 $FF01 mem read = $FF 1111011111111111 11111111 f7ff r ff BBS7 $FF01 mem read = $FF 1111011111111111 11111111 f7ff r ff BBS7 $FF01 mem read = $FF 1111011111111111 11111111 f7ff r ff BBS7 ... fetch opcode 1111011111111111 11111111 f7ff r ff BBS7 $F7FF branch if bit 7 set 1111011111111111 11111111 f7ff r ff BBS7 $F800 mem read = $FF 0000000000000000 00111010 0000 r 3a BBS7 $F800 mem read = $3A 0000000100000000 00001011 0100 r 0b BBS7 $F800 mem read = $0B 0000000111111111 11000010 01ff r c2 ??? undefined opcode 0000000111111110 11001101 01fe r cd ??? ? mem read = $CD 1111111111111100 00000000 fffc r 00 .word $??00 reset vector low byte 1111111111111101 10000000 fffd r 80 .word $8000 reset -> jump to $8000 1000000000000000 10100010 8000 r a2 LDX ... fetch opcode 1000000000000001 11111111 8001 r ff LDX #$FF load X with #const 1000000000000010 10011010 8002 r 9a TXS SP = X 1000000000000011 01001000 8003 r 48 TXS mem read = $48 1000000000000011 01001000 8003 r 48 PHA push A 1000000000000100 01001000 8004 r 48 PHA mem read = $48 0000000111111111 00000000 01ff W 00 PHA WRITE $00 -> $01FF 1000000000000100 01001000 8004 r 48 PHA push A 1000000000000101 10101001 8005 r a9 PHA mem read = $A9 0000000111111110 00000000 01fe W 00 PHA WRITE $00 -> $01FE 1000000000000101 10101001 8005 r a9 LDA ... fetch opcode 1000000000000110 11111111 8006 r ff LDA #$FF load A with #const 1000000000000111 10001101 8007 r 8d STA ... fetch opcode 1000000000001000 00000010 8008 r 02 STA ... fetch operand 1000000000001001 01100000 8009 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000000001010 10101001 800a r a9 LDA ... fetch opcode 1000000000001011 11100000 800b r e0 LDA #$E0 load A with #const 1000000000001100 10001101 800c r 8d STA ... fetch opcode 1000000000001101 00000011 800d r 03 STA ... fetch operand 1000000000001110 01100000 800e r 60 STA $6003 store A to mem 0110000000000011 11100000 6003 W e0 STA WRITE $E0 -> $6003 1000000000001111 10101001 800f r a9 LDA ... fetch opcode 1000000000010000 00111000 8010 r 38 LDA #$38 load A with #const 1000000000010001 00100000 8011 r 20 JSR ... fetch opcode 1000000000010010 10011000 8012 r 98 JSR ... fetch operand 0000000111111101 00100100 01fd r 24 JSR $2498 call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00010011 01fc W 13 JSR WRITE $13 -> $01FC 1000000000010011 10000000 8013 r 80 JSR $2498 mem read = $80 1000000010011000 00100000 8098 r 20 JSR ... fetch opcode 1000000010011001 01110101 8099 r 75 JSR ... fetch operand 0000000111111011 01111111 01fb r 7f JSR $7F75 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10011010 01fa W 9a JSR WRITE $9A -> $01FA 1000000010011010 10000000 809a r 80 JSR $7F75 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00111000 01f9 W 38 PHA WRITE $38 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000000 6000 r 00 LDA $6000 mem read = $00 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00111000 01f9 r 38 PLA mem read = $38 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00111000 01f9 r 38 RTS mem read = $38 0000000111111010 10011010 01fa r 9a RTS mem read = $9A 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010011010 10000000 809a r 80 RTS mem read = $80 1000000010011011 10001101 809b r 8d STA ... fetch opcode 1000000010011100 00000000 809c r 00 STA ... fetch operand 1000000010011101 01100000 809d r 60 STA $6000 store A to mem 0110000000000000 00111000 6000 W 38 STA WRITE $38 -> $6000 1000000010011110 10101001 809e r a9 LDA ... fetch opcode 1000000010011111 00000000 809f r 00 LDA #$00 load A with #const 1000000010100000 10001101 80a0 r 8d STA ... fetch opcode 1000000010100001 00000001 80a1 r 01 STA ... fetch operand 1000000010100010 01100000 80a2 r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010100011 10101001 80a3 r a9 LDA ... fetch opcode 1000000010100100 10000000 80a4 r 80 LDA #$80 load A with #const 1000000010100101 10001101 80a5 r 8d STA ... fetch opcode 1000000010100110 00000001 80a6 r 01 STA ... fetch operand 1000000010100111 01100000 80a7 r 60 STA $6001 store A to mem 0110000000000001 10000000 6001 W 80 STA WRITE $80 -> $6001 1000000010101000 10101001 80a8 r a9 LDA ... fetch opcode 1000000010101001 00000000 80a9 r 00 LDA #$00 load A with #const 1000000010101010 10001101 80aa r 8d STA ... fetch opcode 1000000010101011 00000001 80ab r 01 STA ... fetch operand 1000000010101100 01100000 80ac r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010101101 01100000 80ad r 60 RTS return from subroutine 1000000010101110 00100000 80ae r 20 RTS mem read = $20 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00010011 01fc r 13 RTS mem read = $13 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000010011 10000000 8013 r 80 RTS mem read = $80 1000000000010100 10101001 8014 r a9 LDA ... fetch opcode 1000000000010101 00001110 8015 r 0e LDA #$0E load A with #const 1000000000010110 00100000 8016 r 20 JSR ... fetch opcode 1000000000010111 10011000 8017 r 98 JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $8098 call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00011000 01fc W 18 JSR WRITE $18 -> $01FC 1000000000011000 10000000 8018 r 80 JSR $8098 mem read = $80 1000000010011000 00100000 8098 r 20 JSR ... fetch opcode 1000000010011001 01110101 8099 r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10011010 01fa W 9a JSR WRITE $9A -> $01FA 1000000010011010 10000000 809a r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00001110 01f9 W 0e PHA WRITE $0E -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000000 6000 r 00 LDA $6000 mem read = $00 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00001110 01f9 r 0e PLA mem read = $0E 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00001110 01f9 r 0e RTS mem read = $0E 0000000111111010 10011010 01fa r 9a RTS mem read = $9A 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010011010 10000000 809a r 80 RTS mem read = $80 1000000010011011 10001101 809b r 8d STA ... fetch opcode 1000000010011100 00000000 809c r 00 STA ... fetch operand 1000000010011101 01100000 809d r 60 STA $6000 store A to mem 0110000000000000 00001110 6000 W 0e STA WRITE $0E -> $6000 1000000010011110 10101001 809e r a9 LDA ... fetch opcode 1000000010011111 00000000 809f r 00 LDA #$00 load A with #const 1000000010100000 10001101 80a0 r 8d STA ... fetch opcode 1000000010100001 00000001 80a1 r 01 STA ... fetch operand 1000000010100010 01100000 80a2 r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010100011 10101001 80a3 r a9 LDA ... fetch opcode 1000000010100100 10000000 80a4 r 80 LDA #$80 load A with #const 1000000010100101 10001101 80a5 r 8d STA ... fetch opcode 1000000010100110 00000001 80a6 r 01 STA ... fetch operand 1000000010100111 01100000 80a7 r 60 STA $6001 store A to mem 0110000000000001 10000000 6001 W 80 STA WRITE $80 -> $6001 1000000010101000 10101001 80a8 r a9 LDA ... fetch opcode 1000000010101001 00000000 80a9 r 00 LDA #$00 load A with #const 1000000010101010 10001101 80aa r 8d STA ... fetch opcode 1000000010101011 00000001 80ab r 01 STA ... fetch operand 1000000010101100 01100000 80ac r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010101101 01100000 80ad r 60 RTS return from subroutine 1000000010101110 00100000 80ae r 20 RTS mem read = $20 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00011000 01fc r 18 RTS mem read = $18 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000011000 10000000 8018 r 80 RTS mem read = $80 1000000000011001 10101001 8019 r a9 LDA ... fetch opcode 1000000000011010 00000110 801a r 06 LDA #$06 load A with #const 1000000000011011 00100000 801b r 20 JSR ... fetch opcode 1000000000011100 10011000 801c r 98 JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $8098 call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00011101 01fc W 1d JSR WRITE $1D -> $01FC 1000000000011101 10000000 801d r 80 JSR $8098 mem read = $80 1000000010011000 00100000 8098 r 20 JSR ... fetch opcode 1000000010011001 01110101 8099 r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10011010 01fa W 9a JSR WRITE $9A -> $01FA 1000000010011010 10000000 809a r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00000110 01f9 W 06 PHA WRITE $06 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000000 6000 r 00 LDA $6000 mem read = $00 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00000110 01f9 r 06 PLA mem read = $06 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00000110 01f9 r 06 RTS mem read = $06 0000000111111010 10011010 01fa r 9a RTS mem read = $9A 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010011010 10000000 809a r 80 RTS mem read = $80 1000000010011011 10001101 809b r 8d STA ... fetch opcode 1000000010011100 00000000 809c r 00 STA ... fetch operand 1000000010011101 01100000 809d r 60 STA $6000 store A to mem 0110000000000000 00000110 6000 W 06 STA WRITE $06 -> $6000 1000000010011110 10101001 809e r a9 LDA ... fetch opcode 1000000010011111 00000000 809f r 00 LDA #$00 load A with #const 1000000010100000 10001101 80a0 r 8d STA ... fetch opcode 1000000010100001 00000001 80a1 r 01 STA ... fetch operand 1000000010100010 01100000 80a2 r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010100011 10101001 80a3 r a9 LDA ... fetch opcode 1000000010100100 10000000 80a4 r 80 LDA #$80 load A with #const 1000000010100101 10001101 80a5 r 8d STA ... fetch opcode 1000000010100110 00000001 80a6 r 01 STA ... fetch operand 1000000010100111 01100000 80a7 r 60 STA $6001 store A to mem 0110000000000001 10000000 6001 W 80 STA WRITE $80 -> $6001 1000000010101000 10101001 80a8 r a9 LDA ... fetch opcode 1000000010101001 00000000 80a9 r 00 LDA #$00 load A with #const 1000000010101010 10001101 80aa r 8d STA ... fetch opcode 1000000010101011 00000001 80ab r 01 STA ... fetch operand 1000000010101100 01100000 80ac r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010101101 01100000 80ad r 60 RTS return from subroutine 1000000010101110 00100000 80ae r 20 RTS mem read = $20 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00011101 01fc r 1d RTS mem read = $1D 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000011101 10000000 801d r 80 RTS mem read = $80 1000000000011110 10101001 801e r a9 LDA ... fetch opcode 1000000000011111 00000001 801f r 01 LDA #$01 load A with #const 1000000000100000 00100000 8020 r 20 JSR ... fetch opcode 1000000000100001 10011000 8021 r 98 JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $8098 call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00100010 01fc W 22 JSR WRITE $22 -> $01FC 1000000000100010 10000000 8022 r 80 JSR $8098 mem read = $80 1000000010011000 00100000 8098 r 20 JSR ... fetch opcode 1000000010011001 01110101 8099 r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10011010 01fa W 9a JSR WRITE $9A -> $01FA 1000000010011010 10000000 809a r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00000001 01f9 W 01 PHA WRITE $01 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000000 6000 r 00 LDA $6000 mem read = $00 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00000001 01f9 r 01 PLA mem read = $01 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00000001 01f9 r 01 RTS mem read = $01 0000000111111010 10011010 01fa r 9a RTS mem read = $9A 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010011010 10000000 809a r 80 RTS mem read = $80 1000000010011011 10001101 809b r 8d STA ... fetch opcode 1000000010011100 00000000 809c r 00 STA ... fetch operand 1000000010011101 01100000 809d r 60 STA $6000 store A to mem 0110000000000000 00000001 6000 W 01 STA WRITE $01 -> $6000 1000000010011110 10101001 809e r a9 LDA ... fetch opcode 1000000010011111 00000000 809f r 00 LDA #$00 load A with #const 1000000010100000 10001101 80a0 r 8d STA ... fetch opcode 1000000010100001 00000001 80a1 r 01 STA ... fetch operand 1000000010100010 01100000 80a2 r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010100011 10101001 80a3 r a9 LDA ... fetch opcode 1000000010100100 10000000 80a4 r 80 LDA #$80 load A with #const 1000000010100101 10001101 80a5 r 8d STA ... fetch opcode 1000000010100110 00000001 80a6 r 01 STA ... fetch operand 1000000010100111 01100000 80a7 r 60 STA $6001 store A to mem 0110000000000001 10000000 6001 W 80 STA WRITE $80 -> $6001 1000000010101000 10101001 80a8 r a9 LDA ... fetch opcode 1000000010101001 00000000 80a9 r 00 LDA #$00 load A with #const 1000000010101010 10001101 80aa r 8d STA ... fetch opcode 1000000010101011 00000001 80ab r 01 STA ... fetch operand 1000000010101100 01100000 80ac r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010101101 01100000 80ad r 60 RTS return from subroutine 1000000010101110 00100000 80ae r 20 RTS mem read = $20 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00100010 01fc r 22 RTS mem read = $22 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000100010 10000000 8022 r 80 RTS mem read = $80 1000000000100011 00100000 8023 r 20 JSR ... fetch opcode 1000000000100100 01001000 8024 r 48 JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $8048 call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00100101 01fc W 25 JSR WRITE $25 -> $01FC 1000000000100101 10000000 8025 r 80 JSR $8048 mem read = $80 1000000001001000 10100010 8048 r a2 LDX ... fetch opcode 1000000001001001 00000000 8049 r 00 LDX #$00 load X with #const 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011011101 10101001 80dd r a9 LDA $80DD,X mem read = $A9 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000000000 10100000 0200 r a0 STA $0200,X mem read = $A0 0000001000000000 10101001 0200 W a9 STA WRITE $A9 -> $0200 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011011110 00000001 80de r 01 RTS mem read = $01 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000000001 10001000 0201 r 88 BRK mem read = $88 0000001000000001 00000001 0201 W 01 BRK WRITE $01 -> $0201 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011011111 00100000 80df r 20 LDA $80DD,X mem read = $20 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000000010 11101011 0202 r eb STA $0200,X mem read = $EB 0000001000000010 00100000 0202 W 20 STA WRITE $20 -> $0202 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011100000 10011000 80e0 r 98 RTS mem read = $98 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000000011 01110101 0203 r 75 BRK mem read = $75 0000001000000011 10011000 0203 W 98 BRK WRITE $98 -> $0203 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011100001 10000000 80e1 r 80 LDA $80DD,X mem read = $80 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000000100 01010111 0204 r 57 STA $0200,X mem read = $57 0000001000000100 10000000 0204 W 80 STA WRITE $80 -> $0204 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011100010 10100010 80e2 r a2 RTS mem read = $A2 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000000101 11011111 0205 r df BRK mem read = $DF 0000001000000101 10100010 0205 W a2 BRK WRITE $A2 -> $0205 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011100011 00000000 80e3 r 00 LDA $80DD,X mem read = $00 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000000110 01011110 0206 r 5e STA $0200,X mem read = $5E 0000001000000110 00000000 0206 W 00 STA WRITE $00 -> $0206 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011100100 10111101 80e4 r bd RTS mem read = $BD 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000000111 00000001 0207 r 01 BRK mem read = $01 0000001000000111 10111101 0207 W bd BRK WRITE $BD -> $0207 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011100101 00010110 80e5 r 16 LDA $80DD,X mem read = $16 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000001000 01111110 0208 r 7e STA $0200,X mem read = $7E 0000001000001000 00010110 0208 W 16 STA WRITE $16 -> $0208 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011100110 00000010 80e6 r 02 RTS mem read = $02 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000001001 11110110 0209 r f6 BRK mem read = $F6 0000001000001001 00000010 0209 W 02 BRK WRITE $02 -> $0209 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011100111 11110000 80e7 r f0 LDA $80DD,X mem read = $F0 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000001010 10110010 020a r b2 STA $0200,X mem read = $B2 0000001000001010 11110000 020a W f0 STA WRITE $F0 -> $020A 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011101000 00000111 80e8 r 07 RTS mem read = $07 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000001011 01111001 020b r 79 BRK mem read = $79 0000001000001011 00000111 020b W 07 BRK WRITE $07 -> $020B 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011101001 00100000 80e9 r 20 LDA $80DD,X mem read = $20 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000001100 11111110 020c r fe STA $0200,X mem read = $FE 0000001000001100 00100000 020c W 20 STA WRITE $20 -> $020C 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011101010 10101110 80ea r ae RTS mem read = $AE 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000001101 11010111 020d r d7 BRK mem read = $D7 0000001000001101 10101110 020d W ae BRK WRITE $AE -> $020D 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011101011 10000000 80eb r 80 LDA $80DD,X mem read = $80 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000001110 00111001 020e r 39 STA $0200,X mem read = $39 0000001000001110 10000000 020e W 80 STA WRITE $80 -> $020E 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011101100 11101000 80ec r e8 RTS mem read = $E8 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000001111 01010110 020f r 56 BRK mem read = $56 0000001000001111 11101000 020f W e8 BRK WRITE $E8 -> $020F 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011101101 01001100 80ed r 4c LDA $80DD,X mem read = $4C 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000010000 00001000 0210 r 08 STA $0200,X mem read = $08 0000001000010000 01001100 0210 W 4c STA WRITE $4C -> $0210 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011101110 00000111 80ee r 07 RTS mem read = $07 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000010001 00000010 0211 r 02 BRK mem read = $02 0000001000010001 00000111 0211 W 07 BRK WRITE $07 -> $0211 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011101111 00000010 80ef r 02 LDA $80DD,X mem read = $02 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000010010 11100100 0212 r e4 STA $0200,X mem read = $E4 0000001000010010 00000010 0212 W 02 STA WRITE $02 -> $0212 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011110000 01001100 80f0 r 4c RTS mem read = $4C 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000010011 11000110 0213 r c6 BRK mem read = $C6 0000001000010011 01001100 0213 W 4c BRK WRITE $4C -> $0213 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011110001 00010011 80f1 r 13 LDA $80DD,X mem read = $13 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000010100 10001000 0214 r 88 STA $0200,X mem read = $88 0000001000010100 00010011 0214 W 13 STA WRITE $13 -> $0214 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011110010 00000010 80f2 r 02 RTS mem read = $02 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000010101 11000000 0215 r c0 BRK mem read = $C0 0000001000010101 00000010 0215 W 02 BRK WRITE $02 -> $0215 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011110011 01010000 80f3 r 50 LDA $80DD,X mem read = $50 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000010110 10110001 0216 r b1 STA $0200,X mem read = $B1 0000001000010110 01010000 0216 W 50 STA WRITE $50 -> $0216 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011110100 01010111 80f4 r 57 RTS mem read = $57 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000010111 01010100 0217 r 54 BRK mem read = $54 0000001000010111 01010111 0217 W 57 BRK WRITE $57 -> $0217 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011110101 01001110 80f5 r 4e LDA $80DD,X mem read = $4E 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000011000 00001010 0218 r 0a STA $0200,X mem read = $0A 0000001000011000 01001110 0218 W 4e STA WRITE $4E -> $0218 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011110110 01000101 80f6 r 45 RTS mem read = $45 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000011001 00000000 0219 r 00 BRK mem read = $00 0000001000011001 01000101 0219 W 45 BRK WRITE $45 -> $0219 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011110111 01000100 80f7 r 44 LDA $80DD,X mem read = $44 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000011010 00001101 021a r 0d STA $0200,X mem read = $0D 0000001000011010 01000100 021a W 44 STA WRITE $44 -> $021A 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001001010 10111101 804a r bd RTS mem read = $BD 1000000001001011 11011101 804b r dd RTS mem read = $DD 1000000001001100 10000000 804c r 80 RTS mem read = $80 1000000011111000 00100001 80f8 r 21 RTS mem read = $21 1000000001001101 10011101 804d r 9d RTS mem read = $9D 1000000001001110 00000000 804e r 00 BRK soft interrupt / break 1000000001001111 00000010 804f r 02 BRK mem read = $02 0000001000011011 00001000 021b r 08 BRK mem read = $08 0000001000011011 00100001 021b W 21 BRK WRITE $21 -> $021B 1000000001010000 11101000 8050 r e8 BRK mem read = $E8 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010001 11100000 8051 r e0 BRK mem read = $E0 1000000001010010 00011101 8052 r 1d ORA ... fetch opcode 1000000001010011 11010000 8053 r d0 ORA ... fetch operand 1000000001010100 11110101 8054 r f5 ORA $F5D0,X A = A OR mem 1000000001010101 01100000 8055 r 60 ORA $F5D0,X mem read = $60 1000000001001010 10111101 804a r bd LDA ... fetch opcode 1000000001001011 11011101 804b r dd LDA ... fetch operand 1000000001001100 10000000 804c r 80 LDA $80DD,X load A from mem 1000000011111001 00000000 80f9 r 00 LDA $80DD,X mem read = $00 1000000001001101 10011101 804d r 9d STA ... fetch opcode 1000000001001110 00000000 804e r 00 STA ... fetch operand 1000000001001111 00000010 804f r 02 STA $0200,X store A to mem 0000001000011100 11000010 021c r c2 STA $0200,X mem read = $C2 0000001000011100 00000000 021c W 00 STA WRITE $00 -> $021C 1000000001010000 11101000 8050 r e8 INX X = X + 1 1000000001010001 11100000 8051 r e0 INX mem read = $E0 1000000001010001 11100000 8051 r e0 CPX ... fetch opcode 1000000001010010 00011101 8052 r 1d CPX #$1D compare X with #const 1000000001010011 11010000 8053 r d0 BNE ... fetch opcode 1000000001010100 11110101 8054 r f5 BNE $804A branch if Z=0 1000000001010101 01100000 8055 r 60 RTS return from subroutine 1000000001010110 10111010 8056 r ba RTS mem read = $BA 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00100101 01fc r 25 RTS mem read = $25 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000100101 10000000 8025 r 80 RTS mem read = $80 1000000000100110 10100010 8026 r a2 LDX ... fetch opcode 1000000000100111 00000000 8027 r 00 LDX #$00 load X with #const 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011000100 01001110 80c4 r 4e LDA $80C4,X mem read = $4E 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01001110 01f9 W 4e PHA WRITE $4E -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000000 6000 r 00 LDA $6000 mem read = $00 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 01001110 01f9 r 4e PLA mem read = $4E 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01001110 01f9 r 4e RTS mem read = $4E 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01001110 6000 W 4e STA WRITE $4E -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011000101 01101111 80c5 r 6f LDA $80C4,X mem read = $6F 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01101111 01f9 W 6f PHA WRITE $6F -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000001 6000 r 01 LDA $6000 mem read = $01 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 01101111 01f9 r 6f PLA mem read = $6F 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01101111 01f9 r 6f RTS mem read = $6F 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01101111 6000 W 6f STA WRITE $6F -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011000110 01110010 80c6 r 72 LDA $80C4,X mem read = $72 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01110010 01f9 W 72 PHA WRITE $72 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000010 6000 r 02 LDA $6000 mem read = $02 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 01110010 01f9 r 72 PLA mem read = $72 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01110010 01f9 r 72 RTS mem read = $72 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01110010 6000 W 72 STA WRITE $72 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011000111 01101101 80c7 r 6d LDA $80C4,X mem read = $6D 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01101101 01f9 W 6d PHA WRITE $6D -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000011 6000 r 03 LDA $6000 mem read = $03 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 01101101 01f9 r 6d PLA mem read = $6D 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01101101 01f9 r 6d RTS mem read = $6D 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01101101 6000 W 6d STA WRITE $6D -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011001000 01100001 80c8 r 61 LDA $80C4,X mem read = $61 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01100001 01f9 W 61 PHA WRITE $61 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000100 6000 r 04 LDA $6000 mem read = $04 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 01100001 01f9 r 61 PLA mem read = $61 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01100001 01f9 r 61 RTS mem read = $61 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01100001 6000 W 61 STA WRITE $61 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011001001 01101100 80c9 r 6c LDA $80C4,X mem read = $6C 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01101100 01f9 W 6c PHA WRITE $6C -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000101 6000 r 05 LDA $6000 mem read = $05 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 01101100 01f9 r 6c PLA mem read = $6C 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01101100 01f9 r 6c RTS mem read = $6C 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01101100 6000 W 6c STA WRITE $6C -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011001010 00101110 80ca r 2e LDA $80C4,X mem read = $2E 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00101110 01f9 W 2e PHA WRITE $2E -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000110 6000 r 06 LDA $6000 mem read = $06 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00101110 01f9 r 2e PLA mem read = $2E 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00101110 01f9 r 2e RTS mem read = $2E 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 00101110 6000 W 2e STA WRITE $2E -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011001011 00101110 80cb r 2e LDA $80C4,X mem read = $2E 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00101110 01f9 W 2e PHA WRITE $2E -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000111 6000 r 07 LDA $6000 mem read = $07 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00101110 01f9 r 2e PLA mem read = $2E 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00101110 01f9 r 2e RTS mem read = $2E 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 00101110 6000 W 2e STA WRITE $2E -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011001100 00101110 80cc r 2e LDA $80C4,X mem read = $2E 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000101110 10101110 802e r ae JSR ... fetch operand 0000000111111101 10000000 01fd r 80 JSR $80AE call subroutine 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00101111 01fc W 2f JSR WRITE $2F -> $01FC 1000000000101111 10000000 802f r 80 JSR $80AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00101110 01f9 W 2e PHA WRITE $2E -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00001000 6000 r 08 LDA $6000 mem read = $08 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 10101111 01f8 r af PLA mem read = $AF 0000000111111001 00101110 01f9 r 2e PLA mem read = $2E 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00101110 01f9 r 2e RTS mem read = $2E 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 00101110 6000 W 2e STA WRITE $2E -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00101111 01fc r 2f RTS mem read = $2F 0000000111111101 10000000 01fd r 80 RTS mem read = $80 1000000000101111 10000000 802f r 80 RTS mem read = $80 1000000000110000 11101000 8030 r e8 INX X = X + 1 1000000000110001 01001100 8031 r 4c INX mem read = $4C 1000000000110001 01001100 8031 r 4c JMP ... fetch opcode 1000000000110010 00101000 8032 r 28 JMP ... fetch operand 1000000000110011 10000000 8033 r 80 JMP $8028 jump absolute 1000000000101000 10111101 8028 r bd LDA ... fetch opcode 1000000000101001 11000100 8029 r c4 LDA ... fetch operand 1000000000101010 10000000 802a r 80 LDA $80C4,X load A from mem 1000000011001101 00000000 80cd r 00 LDA $80C4,X mem read = $00 1000000000101011 11110000 802b r f0 BEQ ... fetch opcode 1000000000101100 00000111 802c r 07 BEQ $8034 branch if Z=1 1000000000101101 00100000 802d r 20 JSR ... fetch opcode 1000000000110100 00100000 8034 r 20 JSR ... fetch operand 1000000000110101 01010110 8035 r 56 JSR $5620 call subroutine 0000000111111101 10000000 01fd r 80 JSR $5620 mem read = $80 0000000111111101 10000000 01fd W 80 JSR WRITE $80 -> $01FD 0000000111111100 00110110 01fc W 36 JSR WRITE $36 -> $01FC 1000000000110110 10000000 8036 r 80 BRA ... fetch opcode 1000000001010110 10111010 8056 r ba BRA $8011 branch always 1000000001010111 10001010 8057 r 8a BRA $7FF2 mem read = $8A 1000000001010111 10001010 8057 r 8a TXA A = X 1000000001011000 00111000 8058 r 38 TXA mem read = $38 1000000001011000 00111000 8058 r 38 SEC set carry 1000000001011001 11101001 8059 r e9 SEC mem read = $E9 1000000001011001 11101001 8059 r e9 SBC ... fetch opcode 1000000001011010 00001000 805a r 08 SBC #$08 A = A - #const - ~C 1000000001011011 10101010 805b r aa TAX X = A 1000000001011100 10011010 805c r 9a TAX mem read = $9A 1000000001011100 10011010 805c r 9a TXS SP = X 1000000001011101 10111010 805d r ba TXS mem read = $BA 1000000001011101 10111010 805d r ba TSX X = SP 1000000001011110 11101000 805e r e8 TSX mem read = $E8 1000000001011110 11101000 805e r e8 INX X = X + 1 1000000001011111 10100000 805f r a0 INX mem read = $A0 1000000001011111 10100000 805f r a0 LDY ... fetch opcode 1000000001100000 00000000 8060 r 00 LDY #$00 load Y with #const 1000000001100001 10111001 8061 r b9 LDA ... fetch opcode 1000000001100010 11010011 8062 r d3 LDA ... fetch operand 1000000001100011 10000000 8063 r 80 LDA $80D3,Y load A from mem 1000000011010011 01000001 80d3 r 41 LDA $80D3,Y mem read = $41 1000000001100100 10011101 8064 r 9d STA ... fetch opcode 1000000001100101 00000000 8065 r 00 STA ... fetch operand 1000000001100110 00000001 8066 r 01 STA $0100,X store A to mem 0000000111110100 11100010 01f4 r e2 STA $0100,X mem read = $E2 0000000111110100 01000001 01f4 W 41 STA WRITE $41 -> $01F4 1000000001100111 11101000 8067 r e8 INX X = X + 1 1000000001101000 11001000 8068 r c8 INX mem read = $C8 1000000001101000 11001000 8068 r c8 INY Y = Y + 1 1000000001101001 11000000 8069 r c0 INY mem read = $C0 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101010 00001010 806a r 0a CPY #$0A compare Y with #const 1000000001101011 11010000 806b r d0 BNE ... fetch opcode 1000000001101100 11110100 806c r f4 BNE $8061 branch if Z=0 1000000001101101 10111010 806d r ba TSX X = SP 1000000001100001 10111001 8061 r b9 TSX mem read = $B9 1000000001100010 11010011 8062 r d3 ??? undefined opcode 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011010100 01000010 80d4 r 42 BRA $8117 branch always 1000000001100100 10011101 8064 r 9d BRA $80A7 mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111110101 01110110 01f5 r 76 BRK mem read = $76 0000000111110101 01000010 01f5 W 42 BRK WRITE $42 -> $01F5 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011010101 01000011 80d5 r 43 BRA $8119 branch always 1000000001100100 10011101 8064 r 9d BRA $80A8 mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111110110 10100001 01f6 r a1 BRK mem read = $A1 0000000111110110 01000011 01f6 W 43 BRK WRITE $43 -> $01F6 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011010110 01000100 80d6 r 44 BRA $811B branch always 1000000001100100 10011101 8064 r 9d BRA $80A9 mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111110111 11111011 01f7 r fb BRK mem read = $FB 0000000111110111 01000100 01f7 W 44 BRK WRITE $44 -> $01F7 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011010111 01000101 80d7 r 45 BRA $811D branch always 1000000001100100 10011101 8064 r 9d BRA $80AA mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111111000 10101111 01f8 r af BRK mem read = $AF 0000000111111000 01000101 01f8 W 45 BRK WRITE $45 -> $01F8 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011011000 01000110 80d8 r 46 BRA $811F branch always 1000000001100100 10011101 8064 r 9d BRA $80AB mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111111001 00101110 01f9 r 2e BRK mem read = $2E 0000000111111001 01000110 01f9 W 46 BRK WRITE $46 -> $01F9 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011011001 01000111 80d9 r 47 BRA $8121 branch always 1000000001100100 10011101 8064 r 9d BRA $80AC mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111111010 10110000 01fa r b0 BRK mem read = $B0 0000000111111010 01000111 01fa W 47 BRK WRITE $47 -> $01FA 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011011010 01001000 80da r 48 BRA $8123 branch always 1000000001100100 10011101 8064 r 9d BRA $80AD mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111111011 10000000 01fb r 80 BRK mem read = $80 0000000111111011 01001000 01fb W 48 BRK WRITE $48 -> $01FB 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011011011 11111111 80db r ff BRA $80DB branch always 1000000001100100 10011101 8064 r 9d BRA $8064 mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111111100 00110110 01fc r 36 BRK mem read = $36 0000000111111100 11111111 01fc W ff BRK WRITE $FF -> $01FC 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001100001 10111001 8061 r b9 ??? ? mem read = $B9 1000000001100010 11010011 8062 r d3 ??? ? mem read = $D3 1000000001100011 10000000 8063 r 80 BRA ... fetch opcode 1000000011011100 00000001 80dc r 01 BRA $80DE branch always 1000000001100100 10011101 8064 r 9d BRA $8066 mem read = $9D 1000000001100101 00000000 8065 r 00 BRK soft interrupt / break 1000000001100110 00000001 8066 r 01 BRK mem read = $01 0000000111111101 10000000 01fd r 80 BRK mem read = $80 0000000111111101 00000001 01fd W 01 BRK WRITE $01 -> $01FD 1000000001100111 11101000 8067 r e8 BRK mem read = $E8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101000 11001000 8068 r c8 BRK mem read = $C8 1000000001101001 11000000 8069 r c0 CPY ... fetch opcode 1000000001101001 11000000 8069 r c0 CPY #$C0 compare Y with #const 1000000001101010 00001010 806a r 0a ASL A shift A left 1000000001101011 11010000 806b r d0 ASL mem read = $D0 1000000001101100 11110100 806c r f4 ??? undefined opcode 1000000001101101 10111010 806d r ba ??? ? mem read = $BA 1000000001101110 10001010 806e r 8a ??? ? mem read = $8A 1000000001101110 10001010 806e r 8a ??? ? mem read = $8A 1000000001101111 00011000 806f r 18 CLC clear carry 1000000001101111 00011000 806f r 18 CLC mem read = $18 1000000001110000 01101001 8070 r 69 ADC ... fetch opcode 1000000001110000 01101001 8070 r 69 ADC #$69 A = A + #const + C 1000000001110001 00001000 8071 r 08 PHP push processor status 1000000001110010 10101010 8072 r aa PHP mem read = $AA 1000000001110011 10011010 8073 r 9a PHP mem read = $9A 1000000001110011 10011010 8073 r 9a TXS SP = X 1000000001110100 01100000 8074 r 60 TXS mem read = $60 1000000001110100 01100000 8074 r 60 RTS return from subroutine 1000000001110101 01001000 8075 r 48 RTS mem read = $48 0000000111111011 01001000 01fb r 48 RTS mem read = $48 0000000111111100 11111111 01fc r ff RTS mem read = $FF 0000000111111111 00000000 01ff r 00 RTS mem read = $00 1111111111111111 11111111 ffff r ff RTS mem read = $FF 1111111111111111 11111111 ffff r ff BBS7 ... fetch opcode 0000001000000000 10101001 0200 r a9 BBS7 $01AA branch if bit 7 set 0000001000000001 00000001 0201 r 01 BBS7 $FFAA mem read = $01 0000001000000010 00100000 0202 r 20 BBS7 $FFAA mem read = $20 0000001000000011 10011000 0203 r 98 BBS7 $FFAA mem read = $98 0000000111111101 00000001 01fd r 01 ORA ... fetch opcode 0000000111111101 00000010 01fd W 02 ORA WRITE $02 -> $01FD 0000000111111100 00000100 01fc W 04 ORA WRITE $04 -> $01FC 0000001000000100 10000000 0204 r 80 ORA ($80,X) A = A OR mem 1000000010011000 00100000 8098 r 20 ORA ($80,X) mem read = $20 1000000010011001 01110101 8099 r 75 ORA ($80,X) mem read = $75 0000000111111011 01001000 01fb r 48 PHA push A 0000000111111011 10000000 01fb W 80 PHA WRITE $80 -> $01FB 0000000111111010 10011010 01fa W 9a PHA WRITE $9A -> $01FA 1000000010011010 10000000 809a r 80 BRA ... fetch opcode 1000000001110101 01001000 8075 r 48 BRA $80BE branch always 1000000001110110 10101001 8076 r a9 BRA $80E4 mem read = $A9 0000000111111001 00000001 01f9 W 01 WRITE $01 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00001001 6000 r 09 LDA $6000 mem read = $09 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 00000001 01f9 r 01 PLA mem read = $01 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00000001 01f9 r 01 RTS mem read = $01 0000000111111010 10011010 01fa r 9a RTS mem read = $9A 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010011010 10000000 809a r 80 RTS mem read = $80 1000000010011011 10001101 809b r 8d STA ... fetch opcode 1000000010011100 00000000 809c r 00 STA ... fetch operand 1000000010011101 01100000 809d r 60 STA $6000 store A to mem 0110000000000000 00000001 6000 W 01 STA WRITE $01 -> $6000 1000000010011110 10101001 809e r a9 LDA ... fetch opcode 1000000010011111 00000000 809f r 00 LDA #$00 load A with #const 1000000010100000 10001101 80a0 r 8d STA ... fetch opcode 1000000010100001 00000001 80a1 r 01 STA ... fetch operand 1000000010100010 01100000 80a2 r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010100011 10101001 80a3 r a9 LDA ... fetch opcode 1000000010100100 10000000 80a4 r 80 LDA #$80 load A with #const 1000000010100101 10001101 80a5 r 8d STA ... fetch opcode 1000000010100110 00000001 80a6 r 01 STA ... fetch operand 1000000010100111 01100000 80a7 r 60 STA $6001 store A to mem 0110000000000001 10000000 6001 W 80 STA WRITE $80 -> $6001 1000000010101000 10101001 80a8 r a9 LDA ... fetch opcode 1000000010101001 00000000 80a9 r 00 LDA #$00 load A with #const 1000000010101010 10001101 80aa r 8d STA ... fetch opcode 1000000010101011 00000001 80ab r 01 STA ... fetch operand 1000000010101100 01100000 80ac r 60 STA $6001 store A to mem 0110000000000001 00000000 6001 W 00 STA WRITE $00 -> $6001 1000000010101101 01100000 80ad r 60 RTS return from subroutine 1000000010101110 00100000 80ae r 20 RTS mem read = $20 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00000100 01fc r 04 RTS mem read = $04 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000000100 10000000 0204 r 80 RTS mem read = $80 0000001000000101 10100010 0205 r a2 LDX ... fetch opcode 0000001000000110 00000000 0206 r 00 LDX #$00 load X with #const 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000010110 01010000 0216 r 50 LDA $0216,X mem read = $50 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000001101 10101110 020d r ae JSR ... fetch operand 0000000111111101 00000010 01fd r 02 JSR $02AE call subroutine 0000000111111101 00000010 01fd W 02 JSR WRITE $02 -> $01FD 0000000111111100 00001110 01fc W 0e JSR WRITE $0E -> $01FC 0000001000001110 10000000 020e r 80 JSR $02AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01010000 01f9 W 50 PHA WRITE $50 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000000 6000 r 00 LDA $6000 mem read = $00 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 01010000 01f9 r 50 PLA mem read = $50 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01010000 01f9 r 50 RTS mem read = $50 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01010000 6000 W 50 STA WRITE $50 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00001110 01fc r 0e RTS mem read = $0E 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000001110 10000000 020e r 80 RTS mem read = $80 0000001000001111 11101000 020f r e8 INX X = X + 1 0000001000010000 01001100 0210 r 4c INX mem read = $4C 0000001000010000 01001100 0210 r 4c JMP ... fetch opcode 0000001000010001 00000111 0211 r 07 JMP ... fetch operand 0000001000010010 00000010 0212 r 02 JMP $0207 jump absolute 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000010111 01010111 0217 r 57 LDA $0216,X mem read = $57 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000001101 10101110 020d r ae JSR ... fetch operand 0000000111111101 00000010 01fd r 02 JSR $02AE call subroutine 0000000111111101 00000010 01fd W 02 JSR WRITE $02 -> $01FD 0000000111111100 00001110 01fc W 0e JSR WRITE $0E -> $01FC 0000001000001110 10000000 020e r 80 JSR $02AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01010111 01f9 W 57 PHA WRITE $57 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000001 6000 r 01 LDA $6000 mem read = $01 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 01010111 01f9 r 57 PLA mem read = $57 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01010111 01f9 r 57 RTS mem read = $57 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01010111 6000 W 57 STA WRITE $57 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00001110 01fc r 0e RTS mem read = $0E 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000001110 10000000 020e r 80 RTS mem read = $80 0000001000001111 11101000 020f r e8 INX X = X + 1 0000001000010000 01001100 0210 r 4c INX mem read = $4C 0000001000010000 01001100 0210 r 4c JMP ... fetch opcode 0000001000010001 00000111 0211 r 07 JMP ... fetch operand 0000001000010010 00000010 0212 r 02 JMP $0207 jump absolute 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000011000 01001110 0218 r 4e LDA $0216,X mem read = $4E 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000001101 10101110 020d r ae JSR ... fetch operand 0000000111111101 00000010 01fd r 02 JSR $02AE call subroutine 0000000111111101 00000010 01fd W 02 JSR WRITE $02 -> $01FD 0000000111111100 00001110 01fc W 0e JSR WRITE $0E -> $01FC 0000001000001110 10000000 020e r 80 JSR $02AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01001110 01f9 W 4e PHA WRITE $4E -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000010 6000 r 02 LDA $6000 mem read = $02 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 01001110 01f9 r 4e PLA mem read = $4E 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01001110 01f9 r 4e RTS mem read = $4E 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01001110 6000 W 4e STA WRITE $4E -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00001110 01fc r 0e RTS mem read = $0E 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000001110 10000000 020e r 80 RTS mem read = $80 0000001000001111 11101000 020f r e8 INX X = X + 1 0000001000010000 01001100 0210 r 4c INX mem read = $4C 0000001000010000 01001100 0210 r 4c JMP ... fetch opcode 0000001000010001 00000111 0211 r 07 JMP ... fetch operand 0000001000010010 00000010 0212 r 02 JMP $0207 jump absolute 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000011001 01000101 0219 r 45 LDA $0216,X mem read = $45 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000001101 10101110 020d r ae JSR ... fetch operand 0000000111111101 00000010 01fd r 02 JSR $02AE call subroutine 0000000111111101 00000010 01fd W 02 JSR WRITE $02 -> $01FD 0000000111111100 00001110 01fc W 0e JSR WRITE $0E -> $01FC 0000001000001110 10000000 020e r 80 JSR $02AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01000101 01f9 W 45 PHA WRITE $45 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000011 6000 r 03 LDA $6000 mem read = $03 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 01000101 01f9 r 45 PLA mem read = $45 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01000101 01f9 r 45 RTS mem read = $45 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01000101 6000 W 45 STA WRITE $45 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00001110 01fc r 0e RTS mem read = $0E 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000001110 10000000 020e r 80 RTS mem read = $80 0000001000001111 11101000 020f r e8 INX X = X + 1 0000001000010000 01001100 0210 r 4c INX mem read = $4C 0000001000010000 01001100 0210 r 4c JMP ... fetch opcode 0000001000010001 00000111 0211 r 07 JMP ... fetch operand 0000001000010010 00000010 0212 r 02 JMP $0207 jump absolute 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000011010 01000100 021a r 44 LDA $0216,X mem read = $44 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000001101 10101110 020d r ae JSR ... fetch operand 0000000111111101 00000010 01fd r 02 JSR $02AE call subroutine 0000000111111101 00000010 01fd W 02 JSR WRITE $02 -> $01FD 0000000111111100 00001110 01fc W 0e JSR WRITE $0E -> $01FC 0000001000001110 10000000 020e r 80 JSR $02AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 01000100 01f9 W 44 PHA WRITE $44 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000100 6000 r 04 LDA $6000 mem read = $04 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 01000100 01f9 r 44 PLA mem read = $44 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 01000100 01f9 r 44 RTS mem read = $44 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 01000100 6000 W 44 STA WRITE $44 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00001110 01fc r 0e RTS mem read = $0E 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000001110 10000000 020e r 80 RTS mem read = $80 0000001000001111 11101000 020f r e8 INX X = X + 1 0000001000010000 01001100 0210 r 4c INX mem read = $4C 0000001000010000 01001100 0210 r 4c JMP ... fetch opcode 0000001000010001 00000111 0211 r 07 JMP ... fetch operand 0000001000010010 00000010 0212 r 02 JMP $0207 jump absolute 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000011011 00100001 021b r 21 LDA $0216,X mem read = $21 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000001101 10101110 020d r ae JSR ... fetch operand 0000000111111101 00000010 01fd r 02 JSR $02AE call subroutine 0000000111111101 00000010 01fd W 02 JSR WRITE $02 -> $01FD 0000000111111100 00001110 01fc W 0e JSR WRITE $0E -> $01FC 0000001000001110 10000000 020e r 80 JSR $02AE mem read = $80 1000000010101110 00100000 80ae r 20 JSR ... fetch opcode 1000000010101111 01110101 80af r 75 JSR ... fetch operand 0000000111111011 10000000 01fb r 80 JSR $8075 call subroutine 0000000111111011 10000000 01fb W 80 JSR WRITE $80 -> $01FB 0000000111111010 10110000 01fa W b0 JSR WRITE $B0 -> $01FA 1000000010110000 10000000 80b0 r 80 JSR $8075 mem read = $80 1000000001110101 01001000 8075 r 48 PHA push A 1000000001110110 10101001 8076 r a9 PHA mem read = $A9 0000000111111001 00100001 01f9 W 21 PHA WRITE $21 -> $01F9 1000000001110110 10101001 8076 r a9 LDA ... fetch opcode 1000000001110111 00000000 8077 r 00 LDA #$00 load A with #const 1000000001111000 10001101 8078 r 8d STA ... fetch opcode 1000000001111001 00000010 8079 r 02 STA ... fetch operand 1000000001111010 01100000 807a r 60 STA $6002 store A to mem 0110000000000010 00000000 6002 W 00 STA WRITE $00 -> $6002 1000000001111011 10101001 807b r a9 LDA ... fetch opcode 1000000001111100 01000000 807c r 40 LDA #$40 load A with #const 1000000001111101 10001101 807d r 8d STA ... fetch opcode 1000000001111110 00000001 807e r 01 STA ... fetch operand 1000000001111111 01100000 807f r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010000000 10101001 8080 r a9 LDA ... fetch opcode 1000000010000001 11000000 8081 r c0 LDA #$C0 load A with #const 1000000010000010 10001101 8082 r 8d STA ... fetch opcode 1000000010000011 00000001 8083 r 01 STA ... fetch operand 1000000010000100 01100000 8084 r 60 STA $6001 store A to mem 0110000000000001 11000000 6001 W c0 STA WRITE $C0 -> $6001 1000000010000101 10101101 8085 r ad LDA ... fetch opcode 1000000010000110 00000000 8086 r 00 LDA ... fetch operand 1000000010000111 01100000 8087 r 60 LDA $6000 load A from mem 0110000000000000 00000101 6000 r 05 LDA $6000 mem read = $05 1000000010001000 00101001 8088 r 29 AND ... fetch opcode 1000000010001001 10000000 8089 r 80 AND #$80 A = A AND #const 1000000010001010 11010000 808a r d0 BNE ... fetch opcode 1000000010001011 11101111 808b r ef BNE $807B branch if Z=0 1000000010001100 10101001 808c r a9 LDA ... fetch opcode 1000000010001101 01000000 808d r 40 LDA #$40 load A with #const 1000000010001110 10001101 808e r 8d STA ... fetch opcode 1000000010001111 00000001 808f r 01 STA ... fetch operand 1000000010010000 01100000 8090 r 60 STA $6001 store A to mem 0110000000000001 01000000 6001 W 40 STA WRITE $40 -> $6001 1000000010010001 10101001 8091 r a9 LDA ... fetch opcode 1000000010010010 11111111 8092 r ff LDA #$FF load A with #const 1000000010010011 10001101 8093 r 8d STA ... fetch opcode 1000000010010100 00000010 8094 r 02 STA ... fetch operand 1000000010010101 01100000 8095 r 60 STA $6002 store A to mem 0110000000000010 11111111 6002 W ff STA WRITE $FF -> $6002 1000000010010110 01101000 8096 r 68 PLA pull A 1000000010010111 01100000 8097 r 60 PLA mem read = $60 0000000111111000 01000101 01f8 r 45 PLA mem read = $45 0000000111111001 00100001 01f9 r 21 PLA mem read = $21 1000000010010111 01100000 8097 r 60 RTS return from subroutine 1000000010011000 00100000 8098 r 20 RTS mem read = $20 0000000111111001 00100001 01f9 r 21 RTS mem read = $21 0000000111111010 10110000 01fa r b0 RTS mem read = $B0 0000000111111011 10000000 01fb r 80 RTS mem read = $80 1000000010110000 10000000 80b0 r 80 RTS mem read = $80 1000000010110001 10001101 80b1 r 8d STA ... fetch opcode 1000000010110010 00000000 80b2 r 00 STA ... fetch operand 1000000010110011 01100000 80b3 r 60 STA $6000 store A to mem 0110000000000000 00100001 6000 W 21 STA WRITE $21 -> $6000 1000000010110100 10101001 80b4 r a9 LDA ... fetch opcode 1000000010110101 00100000 80b5 r 20 LDA #$20 load A with #const 1000000010110110 10001101 80b6 r 8d STA ... fetch opcode 1000000010110111 00000001 80b7 r 01 STA ... fetch operand 1000000010111000 01100000 80b8 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000010111001 10101001 80b9 r a9 LDA ... fetch opcode 1000000010111010 10100000 80ba r a0 LDA #$A0 load A with #const 1000000010111011 10001101 80bb r 8d STA ... fetch opcode 1000000010111100 00000001 80bc r 01 STA ... fetch operand 1000000010111101 01100000 80bd r 60 STA $6001 store A to mem 0110000000000001 10100000 6001 W a0 STA WRITE $A0 -> $6001 1000000010111110 10101001 80be r a9 LDA ... fetch opcode 1000000010111111 00100000 80bf r 20 LDA #$20 load A with #const 1000000011000000 10001101 80c0 r 8d STA ... fetch opcode 1000000011000001 00000001 80c1 r 01 STA ... fetch operand 1000000011000010 01100000 80c2 r 60 STA $6001 store A to mem 0110000000000001 00100000 6001 W 20 STA WRITE $20 -> $6001 1000000011000011 01100000 80c3 r 60 RTS return from subroutine 1000000011000100 01001110 80c4 r 4e RTS mem read = $4E 0000000111111011 10000000 01fb r 80 RTS mem read = $80 0000000111111100 00001110 01fc r 0e RTS mem read = $0E 0000000111111101 00000010 01fd r 02 RTS mem read = $02 0000001000001110 10000000 020e r 80 RTS mem read = $80 0000001000001111 11101000 020f r e8 INX X = X + 1 0000001000010000 01001100 0210 r 4c INX mem read = $4C 0000001000010000 01001100 0210 r 4c JMP ... fetch opcode 0000001000010001 00000111 0211 r 07 JMP ... fetch operand 0000001000010010 00000010 0212 r 02 JMP $0207 jump absolute 0000001000000111 10111101 0207 r bd LDA ... fetch opcode 0000001000001000 00010110 0208 r 16 LDA ... fetch operand 0000001000001001 00000010 0209 r 02 LDA $0216,X load A from mem 0000001000011100 00000000 021c r 00 LDA $0216,X mem read = $00 0000001000001010 11110000 020a r f0 BEQ ... fetch opcode 0000001000001011 00000111 020b r 07 BEQ $0213 branch if Z=1 0000001000001100 00100000 020c r 20 JSR ... fetch opcode 0000001000010011 01001100 0213 r 4c JSR ... fetch operand 0000001000010100 00010011 0214 r 13 JSR $134C call subroutine 0000001000010101 00000010 0215 r 02 JSR $134C mem read = $02 0000001000010011 01001100 0213 r 4c JSR $134C mem read = $4C 0000001000010100 00010011 0214 r 13 JSR $134C mem read = $13 0000001000010101 00000010 0215 r 02 ??? undefined opcode 0000001000010011 01001100 0213 r 4c ??? ? mem read = $4C 0000001000010100 00010011 0214 r 13 ??? undefined opcode 0000001000010101 00000010 0215 r 02 ??? undefined opcode