Add memory to accumulator with carry


Add memory to accumulator


And memory with accumulator


Arithmetic shift of accumulator or memory left


Arithmetic shift of accumulator or memory right


Bit test memory with accumulator


Clear accumulator or memory location


Compare memory from accumulator


Complement accumulator or memory location


Decimal adjust A accumulator


Decrement accumulator or memory location


Exclusive or memory with accumulator


Exchange R1 with R2 (R1, R2 = A, B, CC, DP)


Increment accumulator or memory location


Load accumulator from memory


Logical shift left accumulator or memory location


Logical shift right accumulator or memory location


Unsigned multiply (A x B — D)


Negate accumulator or memory


Or memory with accumulator


Rotate accumulator or memory left


Rotate accumulator or memory right


Subtract memory from accumulator with borrow


Store accumulator to memory


Subtract memory from accumulator


Test accumulator or memory location


Transfer R1 to R2 (R1, R2 = A, B, CC, DP)

NOTE; A, B, CC, or DP may be pushed to (pulled from) stack with either PSHS, PSHU (PULS,PULU) instructions.


Add memory to D accumulator


Compare memory from D accumulator


Exchange D with X, Y, S, U, or PC [/h1]


Load D accumulator from memory


Sign Extend B accumulator into A accumulator


Store D accumulator to memory


Subtract memory from D accumulator


Transfer D to X, Y, S, U, or PC


Transfer X, Y, S, U, or PC to D

NOTE: D may be pushed (pulled) to stack with either PSHS, PSHU (PULS, PULU) instructions.


Compare memory from stack pointer


Compare memory from index register


Exchange D, X, Y, X, U, or PC with D, X Y, S, U, or PC


Load effective address into stack pointer


Load effective address into index register


Load stack pointer from memory


Load index register from memory


Push A, B, CC, DP, D, X, Y, U, or PC onto hardware stack


Push A, B, CC, DP, D, X, Y, S, or PC onto user stack


Pull A, B, CC, DP, D, X, Y, U, or PC from hardware stack


Pull A, B, CC, DP, D, X, Y, S, or PC from hardware stack


Store stack pointer to memory


Store index register to memory


Transfer D, X, Y, S, U or PC to D. X, Y, S, U, or PC


Add B accumulator to X (unsigned!


Branch if equal


Branch if not equal


Branch if minus


Branch if plus


Branch if carry set.


Branch if carry clear


Branch if overflow set


Branch if overflow clear


Branch if greater (signed)


Branch if invalid 2s complement result


Branch if greater than or equal (signed)


Branch if equal


Branch if not equal


Branch if less than or equal (signed)


Branch if valid 2s complement result


Branch if less than (signed)


Branch if higher (unsigned)


Branch if higher or same (unsigned)


Branch if higher or same (unsigned)


Branch if equal


Branch if not equal


Branch if lower or same (unsigned)


Branch if lower (unsigned)


Branch if lower (unsigned)


Branch to subroutine


Branch always


Branch never


AND condition code register


AND condition code register, then wait for interrupt


No operation


OR condition code register


Jump


Jump to subroutine


Return from interrupt


Return from subroutine


Software interrupt (absolute indirect)


Synchronize with interrupt line