aba  Add Accumulator B to Accumulator A Adds the contents of accumulator B to the contents of accumulator A and places the result in accumulator A. Accumulator B is not changed. This instruction affects the H condition code bit so it is suitable for use in BCD arithmetic operations (see DAA instruction for additional information).
abx  Add Accumulator B to Index Register X Adds the 8-bit unsigned contents of accumulator B to the contents of index register X (IX) considering the possible carry out of the low-order byte of the index register X; places the result in index register X (IX). Accumulator B is not changed. There is no equivalent instruction to add accumulator A to an index register.
aby  Add Accumulator B to Index Register Y Adds the 8-bit unsigned contents of accumulator B to the contents of index register Y (IY) considering the possible carry out of the low-order byte of the index register Y; places the result in index register Y (IY). Accumulator B is not changed. There is no equivalent instruction to add accumulator A to an index register.
adca  Add with Carry A Adds the contents of the C bit to the sum of the contents of ACCX and M and places the result in ACCX. This instruction affects the H condition code bit so it is suitable for use in BCD arithmetic operations (see DAA instruction for additional information).
adcb  Add with Carry B Adds the contents of the C bit to the sum of the contents of ACCX and M and places the result in ACCX. This instruction affects the H condition code bit so it is suitable for use in BCD arithmetic operations (see DAA instruction for additional information).
adda  Add without Carry A Adds the contents of M to the contents of ACCX and places the result in ACCX. This instruction affects the H condition code bit so it is suitable for use in BCD arithmetic operations (see DAA instruction for additional information).
addb  Add without Carry B Adds the contents of M to the contents of ACCX and places the result in ACCX. This instruction affects the H condition code bit so it is suitable for use in BCD arithmetic operations (see DAA instruction for additional information).
addd  Add Double Accumulator Adds the contents of M concatenated with M + 1 to the contents of ACCD and places the result in ACCD. Accumulator A corresponds to the high-order half of the 16-bit double accumulator D.
anda  Logical AND A Performs the logical AND between the contents of ACCX and the contents of M and places the result in ACCX. (Each bit of ACCX after the operation will be the logical AND of the corresponding bits of M and of ACCX before the operation.)
andb  Logical AND B Performs the logical AND between the contents of ACCX and the contents of M and places the result in ACCX. (Each bit of ACCX after the operation will be the logical AND of the corresponding bits of M and of ACCX before the operation.)
asl  Arithmetic Shift Left (Same as LSL) Shifts all bits of the ACCX or M one place to the left. Bit 0 is loaded with a zero. The C bit in the CCR is loaded from the most significant bit of ACCX or M.
asla  Arithmetic Shift Left A (Same as LSLA) Shifts all bits of the ACCX or M one place to the left. Bit 0 is loaded with a zero. The C bit in the CCR is loaded from the most significant bit of ACCX or M.
aslb  Arithmetic Shift Left B (Same as LSLB) Shifts all bits of the ACCX or M one place to the left. Bit 0 is loaded with a zero. The C bit in the CCR is loaded from the most significant bit of ACCX or M.
asld  Arithmetic Shift Left Double Accumulator (Same as LSLD) Shifts all bits of ACCD one place to the left. Bit 0 is loaded with a zero. The C bit in the CCR is loaded from the most significant bit of ACCD.
asr  Arithmetic Shift Right
asra  Arithmetic Shift Right A
asrb  Arithmetic Shift Right B
bcc  Branch if Carry Clear (CY=0)
bclr  Clear Bit(s) in Memory
bcs  Branch if Carry Set (CY=1)
beq  Branch if Equal (ZR=1)
bge  Branch if Greater than or Equal to Zero (N||V=0)
bgt  Branch if Greater than Zero (ZR=0 + N=0)
bhi  Branch if Higher (CY+ZR=0)
bhs  Branch if Higher or Same (Same as BCC) (CY=0)
bita  Bit Test A
bitb  Bit Test B
ble  Branch if Less than or Equal to Zero (ZR=1 or N =1)
blo  Branch if Lower (Same as BCS) (CY=1)
bls  Branch if Lower or Same (CY=1 or ZR=1)
blt  Branch if Less than Zero (N||V=1)
bmi  Branch if Minus (N=1)
bne  Branch if Not Equal to Zero (ZR=0)
bpl  Branch if Plus (N=0)
bra  Branch Always
brclr  Branch if Bit(s) Clear
brn  Branch Never
brset  Branch if Bit(s) Set
bset  Set Bit(s) in Memory
bsr  Branch to Subroutine
bvc  Branch if Overflow Clear
bvs  Branch if Overflow Set
clc  Clear Carry
cli  Clear Interrupt Mask
clr  Clear
clra  Clear A
clrb  Clear B
clv  Clear Twos-Complement Overflow Bit
cmpa  Compare A
cmpb  Compare B
com  Complement
coma  Complement A
comb  Complement B
cpd  Compare Double Accumulator
cpx  Compare Index Register X
cpy  Compare Index Register Y
daa  Decimal Adjust ACCA
deca  Decrement A
decb  Decrement B
des  Decrement Stack Pointer
dex  Decrement Index Register X
dey  Decrement Index Register Y
eora  Exclusive-OR A
eorb  Exclusive-OR B
fdiv  Fractional Divide (D/IX; IX=Quoteint; D=Remainder)
idiv  Integer Divide (D/IX; IX=Quoteint; D=Remainder)
inc  Increment
inca  Increment A
incb  Increment B
ins  Increment Stack Pointer
inx  Increment Index Register X
iny  Increment Index Register Y
jmp  Jump
jsr  Jump to Subroutine The program counter is incremented by three or by two, depending on the addressing mode, and is then pushed onto the stack, eight bits at a time, least significant byte first. The stack pointer points to the next empty location in the stack. A jump occurs to the instruction stored at the effective address. The effective address is obtained according to the rules for EXTended, DIRect, or INDexed addressing.
ldaa  Load Accumulator A
ldab  Load Accumulator B
ldd  Load Double Accumulator
lds  Load Stack Pointer
ldx  Load Index Register X
ldy  Load Index Register Y
lsl  Logical Shift Left (Same as ASL)
lsla  Logical Shift Left A (Same as ASLA)
lslb  Logical Shift Left B (Same as ASLB)
lsld  Logical Shift Left Double (Same as ASLD)
lsr  Logical Shift Right
lsra  Logical Shift Right A
lsrb  Logical Shift Right B
lsrd  Logical Shift Right Double Accumulator
mul  Multiply Unsigned (D=A*B)
neg  Negate
nega  Negate A
negb  Negate B
nop  No Operation
oraa  Inclusive-OR A
orab  Inclusive-OR B
psha  Push Data onto Stack A
pshb  Push Data onto Stack B
pshx  Push Index Register X onto Stack
pshy  Push Index Register Y onto Stack
pula  Pull Data from Stack A
pulb  Pull Data from Stack B
pulx  Pull Index Register X from Stack
puly  Pull Index Register Y from Stack
rol  Rotate Left
rola  Rotate Left A
rolb  Rotate Left B
ror  Rotate Right
rora  Rotate Right A
rorb  Rotate Right B
rti  Return from Interrupt
rts  Return from Subroutine
sba  Subtract Accumulators (A=A-B)
sbca  Subtract with Carry A
sbcb  Subtract with Carry B
sec  Set Carry
sei  Set Interrupt Mask
sev  Set Twos Complement Overflow Bit
staa  Store Accumulator A
stab  Store Accumulator B
std  Store Double Accumulator
stop  Stop Processing
sts  Store Stack Pointer
stx  Store Index Register X
sty  Store Index Register Y
suba  Subtract A
subb  Subtract B
subd  Subtract Double Accumulator
swi  Software Interrupt
tab  Transfer from Accumulator A to Accumulator B
tap  Transfer from Accumulator A to Condition Code Register
tba  Transfer from Accumulator B to Accumulator A
tpa  Transfer from Condition Code Register to Accumulator A
tst  Test
tsta  Test A
tstb  Test B
tsx  Transfer from Stack Pointer to Index Register X
tsy  Transfer from Stack Pointer to Index Register Y
txs  Transfer from Index Register X to Stack Pointer
tys  Transfer from Index Register Y to Stack Pointer
wai  Wait for Interrupt
xgdx  Exchange Double Accumulator and Index Register X
xgdy  Exchange Double Accumulator and Index Register Y