The 6507 instruction set — 151 opcodes in 56 mnemonics

name   mode     opcode  bytes  cycles  what it does
LDA    #        $A9     2      2       load the accumulator
       zp       $A5     2      3       
       zp,X     $B5     2      4       
       abs      $AD     3      4       
       abs,X    $BD     3      4+      
       abs,Y    $B9     3      4+      
       (zp,X)   $A1     2      6       
       (zp),Y   $B1     2      5+      
LDX    #        $A2     2      2       load X
       zp       $A6     2      3       
       zp,Y     $B6     2      4       
       abs      $AE     3      4       
       abs,Y    $BE     3      4+      
LDY    #        $A0     2      2       load Y
       zp       $A4     2      3       
       zp,X     $B4     2      4       
       abs      $AC     3      4       
       abs,X    $BC     3      4+      
STA    zp       $85     2      3       store the accumulator
       zp,X     $95     2      4       
       abs      $8D     3      4       
       abs,X    $9D     3      5       
       abs,Y    $99     3      5       
       (zp,X)   $81     2      6       
       (zp),Y   $91     2      6       
STX    zp       $86     2      3       store X
       zp,Y     $96     2      4       
       abs      $8E     3      4       
STY    zp       $84     2      3       store Y
       zp,X     $94     2      4       
       abs      $8C     3      4       
TAX    implied  $AA     1      2       copy A to X
TAY    implied  $A8     1      2       copy A to Y
TXA    implied  $8A     1      2       copy X to A
TYA    implied  $98     1      2       copy Y to A
TSX    implied  $BA     1      2       copy the stack pointer to X
TXS    implied  $9A     1      2       copy X to the stack pointer
PHA    implied  $48     1      3       push the accumulator
PHP    implied  $08     1      3       push the flags
PLA    implied  $68     1      4       pull the accumulator
PLP    implied  $28     1      4       pull the flags
ADC    #        $69     2      2       add with carry
       zp       $65     2      3       
       zp,X     $75     2      4       
       abs      $6D     3      4       
       abs,X    $7D     3      4+      
       abs,Y    $79     3      4+      
       (zp,X)   $61     2      6       
       (zp),Y   $71     2      5+      
SBC    #        $E9     2      2       subtract with borrow
       zp       $E5     2      3       
       zp,X     $F5     2      4       
       abs      $ED     3      4       
       abs,X    $FD     3      4+      
       abs,Y    $F9     3      4+      
       (zp,X)   $E1     2      6       
       (zp),Y   $F1     2      5+      
INC    zp       $E6     2      5       add one to memory
       zp,X     $F6     2      6       
       abs      $EE     3      6       
       abs,X    $FE     3      7       
DEC    zp       $C6     2      5       take one from memory
       zp,X     $D6     2      6       
       abs      $CE     3      6       
       abs,X    $DE     3      7       
INX    implied  $E8     1      2       add one to X
INY    implied  $C8     1      2       add one to Y
DEX    implied  $CA     1      2       take one from X
DEY    implied  $88     1      2       take one from Y
AND    #        $29     2      2       and with the accumulator
       zp       $25     2      3       
       zp,X     $35     2      4       
       abs      $2D     3      4       
       abs,X    $3D     3      4+      
       abs,Y    $39     3      4+      
       (zp,X)   $21     2      6       
       (zp),Y   $31     2      5+      
ORA    #        $09     2      2       or with the accumulator
       zp       $05     2      3       
       zp,X     $15     2      4       
       abs      $0D     3      4       
       abs,X    $1D     3      4+      
       abs,Y    $19     3      4+      
       (zp,X)   $01     2      6       
       (zp),Y   $11     2      5+      
EOR    #        $49     2      2       exclusive-or with the accumulator
       zp       $45     2      3       
       zp,X     $55     2      4       
       abs      $4D     3      4       
       abs,X    $5D     3      4+      
       abs,Y    $59     3      4+      
       (zp,X)   $41     2      6       
       (zp),Y   $51     2      5+      
BIT    zp       $24     2      3       test bits 7 and 6 without keeping the result
       abs      $2C     3      4       
ASL    A        $0A     1      2       shift left, bit 7 into carry
       zp       $06     2      5       
       zp,X     $16     2      6       
       abs      $0E     3      6       
       abs,X    $1E     3      7       
LSR    A        $4A     1      2       shift right, bit 0 into carry
       zp       $46     2      5       
       zp,X     $56     2      6       
       abs      $4E     3      6       
       abs,X    $5E     3      7       
ROL    A        $2A     1      2       rotate left through carry
       zp       $26     2      5       
       zp,X     $36     2      6       
       abs      $2E     3      6       
       abs,X    $3E     3      7       
ROR    A        $6A     1      2       rotate right through carry
       zp       $66     2      5       
       zp,X     $76     2      6       
       abs      $6E     3      6       
       abs,X    $7E     3      7       
CMP    #        $C9     2      2       compare with the accumulator
       zp       $C5     2      3       
       zp,X     $D5     2      4       
       abs      $CD     3      4       
       abs,X    $DD     3      4+      
       abs,Y    $D9     3      4+      
       (zp,X)   $C1     2      6       
       (zp),Y   $D1     2      5+      
CPX    #        $E0     2      2       compare with X
       zp       $E4     2      3       
       abs      $EC     3      4       
CPY    #        $C0     2      2       compare with Y
       zp       $C4     2      3       
       abs      $CC     3      4       
BCC    rel      $90     2      2**     branch if the carry is clear
BCS    rel      $B0     2      2**     branch if the carry is set
BEQ    rel      $F0     2      2**     branch if equal — the zero flag is set
BNE    rel      $D0     2      2**     branch if not equal
BMI    rel      $30     2      2**     branch if minus — bit 7 is set
BPL    rel      $10     2      2**     branch if plus
BVC    rel      $50     2      2**     branch if overflow is clear
BVS    rel      $70     2      2**     branch if overflow is set
JMP    abs      $4C     3      3       jump
       (abs)    $6C     3      5       
JSR    abs      $20     3      6       jump to a subroutine
RTS    implied  $60     1      6       return from a subroutine
BRK    implied  $00     1      7       software interrupt
RTI    implied  $40     1      6       return from an interrupt
CLC    implied  $18     1      2       clear the carry
SEC    implied  $38     1      2       set the carry
CLD    implied  $D8     1      2       clear decimal mode
SED    implied  $F8     1      2       set decimal mode
CLI    implied  $58     1      2       clear the interrupt disable
SEI    implied  $78     1      2       set the interrupt disable
CLV    implied  $B8     1      2       clear the overflow
NOP    implied  $EA     1      2       do nothing for two cycles

Undocumented, and assembled by DASM

LAX    zp       $A7     2      3       load A and X with the same byte
       zp,Y     $B7     2      4       
       abs      $AF     3      4       
       abs,Y    $BF     3      4+      
       (zp,X)   $A3     2      6       
       (zp),Y   $B3     2      5+      
SAX    zp       $87     2      3       store A and X anded together
       zp,Y     $97     2      4       
       abs      $8F     3      4       
       (zp,X)   $83     2      6       
DCP    zp       $C7     2      5       take one from memory, then compare with A
       zp,X     $D7     2      6       
       abs      $CF     3      6       
       abs,X    $DF     3      7       
       abs,Y    $DB     3      7       
       (zp,X)   $C3     2      8       
       (zp),Y   $D3     2      8       
SLO    zp       $07     2      5       shift memory left, then or into A
       zp,X     $17     2      6       
       abs      $0F     3      6       
       abs,X    $1F     3      7       
       abs,Y    $1B     3      7       
       (zp,X)   $03     2      8       
       (zp),Y   $13     2      8       
ANC    #        $0B     2      2       and with A, then copy bit 7 into the carry
ARR    #        $6B     2      2       and with A, then rotate right
