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