yea

MOV A, #imm:	lda{imm}
MOV A, (X):		lda{(x)}
MOV A, (X)+:	lda{(x)+}
MOV A, dp:		lda{dp}
MOV A, dp+X:	lda{dp,X}
MOV A, !abs:	lda{abs}
MOV A, !abs+X:	lda{abs,X}
MOV A, !abs+Y:	lda{abs,Y}
MOV A, [dp+X]:	lda{(dp,X)}
MOV A, [dp]+Y:	lda{(dp),Y)}
MOV X, #imm:	ldx{imm}
MOV X, dp:		ldx{dp}
MOV X, dp+Y:	ldx{dp,Y}
MOV X, !abs:	ldx{abs}
MOV Y, #imm:	ldy{imm}
MOV Y, dp:		ldy{dp}
MOV Y, dp+X:	ldy{dp,X}
MOV Y, !abs:	ldy{abs}
MOV (X), A:		sta{(x)}
MOV (X)+, A:	sta{(x)+}
MOV dp, A:		sta{dp}
MOV dp+X, A:	sta{dp,X}
MOV !abs, A:	sta{abs}
MOV !abs+X, A:	sta{abs,X}
MOV !abs+Y, A:	sta{abs,Y}
MOV [dp+X], A:	sta{(dp,X)}
MOV [dp]+Y, A:	sta{(dp),Y}
MOV dp, X:		stx{dp}
MOV dp+Y, X:	stx{dp,Y}
MOV !abs, X:	stx{abs}
MOV dp, Y:		sty{dp}
MOV dp+X, Y:	sty{dp,X}
MOV !abs, Y:	sty{abs}
MOV A, X:		txa{imp}
MOV A, Y:		tya{imp}
MOV X, A:		tax{imp}
MOV Y, A:		tay{imp}
MOV X, SP:		tsx{imp}
MOV SP, X:		txs{imp}
MOV dp, dp:		mov{dp,dp}
MOV dp, #imm:	mov{dp,imm}
ADC A, #imm:	adc{imm}
ADC A, (X):		adc{(x)}
ADC A, dp:		adc{dp}
ADC A, dp+X:	adc{dp,X}
ADC A, !abs:	adc{abs}
ADC A, !abs+X:	adc{abs,X}
ADC A, !abs+Y:	adc{abs,Y}
ADC A, [dp+X]:	adc{(dp,X)}
ADC A, [dp]+Y:	adc{(dp),Y}
ADC (X), (Y):	ads{(x),(y)}
ADC dp, dp:		ads{dp,dp}
ADC dp, #imm:	ads{dp,imm}
SBC A, #imm:	sbc{imm}
SBC A, (X):		sbc{(x)}
SBC A, dp:		sbc{dp}
SBC A, dp+X:	sbc{dp,X}
SBC A, !abs:	sbc{abs}
SBC A, !abs+X:	sbc{abs,X}
SBC A, !abs+Y:	sbc{abs,Y}
SBC A, [dp+X]:	sbc{(dp,X)}
SBC A, [dp]+Y:	sbc{(dp),Y}
SBC (X), (Y):	sbs{(x),(y)}
SBC dp, dp:		sbs{dp,dp}
SBC dp, #imm:	sbs{dp,imm}
CMP A, #imm:	cmp{imm}
CMP A, (X):		cmp{(x)}
CMP A, dp:		cmp{dp}
CMP A, dp+X:	cmp{dp,X}
CMP A, !abs:	cmp{abs}
CMP A, !abs+X:	cmp{abs,X}
CMP A, !abs+Y:	cmp{abs,Y}
CMP A, [dp+X]:	cmp{(dp,X)}
CMP A, [dp]+Y:	cmp{(dp),Y}
CMP (X), (Y):	cps{(x),(y)}
CMP dp, dp:		cps{dp,dp}
CMP dp, #imm:	cps{dp,imm}
CMP X, #imm:	cpx{imm}
CMP X, dp:		cpx{dp}
CMP X, !abs:	cpx{abs}
CMP Y, #imm:	cpy{imm}
CMP Y, dp:		cpy{dp}
CMP Y, !abs:	cpy{abs}
AND A, #imm:	and{imm}
AND A, (X):		and{(x)}
AND A, dp:		and{dp}
AND A, dp+X:	and{dp,X}
AND A, !abs:	and{abs}
AND A, !abs+X:	and{abs,X}
AND A, !abs+Y:	and{abs,Y}
AND A, [dp+X]:	and{(dp,X)}
AND A, [dp]+Y:	and{(dp),Y}
AND (X), (Y):	ans{(x),(y)}
AND dp, dp:		ans{dp,dp}
AND dp, #imm:	ans{dp,imm}
EOR A, #imm:	eor{imm}
EOR A, (X):		eor{(x)}
EOR A, dp:		eor{dp}
EOR A, dp+X:	eor{dp,X}
EOR A, !abs:	eor{abs}
EOR A, !abs+X:	eor{abs,X}
EOR A, !abs+Y:	eor{abs,Y}
EOR A, [dp+X]:	eor{(dp,X)}
EOR A, [dp]+Y:	eor{(dp),Y}
EOR (X), (Y):	eos{(x),(y)}
EOR dp, dp:		eos{dp,dp}
EOR dp, #imm:	eos{dp,imm}
INC A:			inc{acc}
INC dp:			inc{dp}
INC dp+X:		inc{dp,X}
INC !abs:		inc{abs}
INC X:			inx{imp}
INC Y:			iny{imp}
DEC A:			dec{acc}
DEC dp:			dec{dp}
DEC dp+X:		dec{dp,X}
DEC !abs:		dec{abs}
DEC X:			dex{imp}
DEC Y:			dey{imp}
ASL A:			asl{acc}
ASL dp+X:		asl{dp,X}
LSR A:			lsr{acc}
LSR dp:			lsr{dp}
LSR dp+X:		lsr{dp,X}
LSR !abs:		lsr{abs}
ROL A:			rol{acc}
ROL dp:			rol{dp}
ROL dp+X:		rol{dp,X}
ROL !abs:		rol{abs}
ROR A:			ror{acc}
ROR dp:			ror{dp}
ROR dp+X:		ror{dp,X}
ROR !abs:		ror{abs}
XCN A:			xcn{acc}
MOVW YA, dp:	ldw{dp}
MOVW dp, YA:	stw{dp}
INCW dp:		inw{dp}
DECW dp:		dew{dp}
ADDW YA, dp:	adw{dp}
SUBW YA, dp:	sbw{dp}
CMPW YA, dp:	cpw{dp}
MUL YA:			mpw{imp}
DIV YA, X:		dvw{imp}
DAA A:			daa{acc}
DAS A:			das{acc}
BRA rel:		bra{rel}
BEQ rel:		beq{rel}
BNE rel:		bne{rel}
BCS rel:		bcs{rel}
BCC rel:		bcc{rel}
BVS rel:		bvs{rel}
BVC rel:		bvc{rel}
BMI rel:		bmi{rel}
BBS dp, bit, rel:	bbs 1,{dp,rel}
BBS dp, bit, rel:	bbs 2,{dp,rel}
BBS dp, bit, rel:	bbs 3,{dp,rel}
BBS dp, bit, rel:	bbs 4,{dp,rel}
BBS dp, bit, rel:	bbs 5,{dp,rel}
BBS dp, bit, rel:	bbs 6,{dp,rel}
BBS dp, bit, rel:	bbs 7,{dp,rel}
BBC dp, bit, rel:	bbc 1,{dp,rel}
BBC dp, bit, rel:	bbc 2,{dp,rel}
BBC dp, bit, rel:	bbc 3,{dp,rel}
BBC dp, bit, rel:	bbc 4,{dp,rel}
BBC dp, bit, rel:	bbc 5,{dp,rel}
BBC dp, bit, rel:	bbc 6,{dp,rel}
BBC dp, bit, rel:	bbc 7,{dp,rel}
CBNE dp, rel:	cbn{dp,rel}
CBNE dp+X, rel:	cbn{dp,X,rel}
DBNZ dp, rel:	dbn{dp,rel}
DBNZ Y, rel:	dbn{Y,rel}
JMP !abs:		jmp{abs}
JMP [!abs+X]:	jmp{(abs,X)}
CALL !abs:		jsr{abs}
PCALL up:		jdr{dp}
RET:			rts{imp}
RETI:			rti{imp}
PUSH A:			pha{imp}
PUSH X:			phx{imp}
PUSH Y:			phy{imp}
POP A:			pla{imp}
POP X:			plx{imp}
POP Y:			ply{imp}
POP PSW:		plp{imp}
SET1 dp, bit:	smb 1,{dp}
SET1 dp, bit:	smb 2,{dp}
SET1 dp, bit:	smb 3,{dp}
SET1 dp, bit:	smb 4,{dp}
SET1 dp, bit:	smb 5,{dp}
SET1 dp, bit:	smb 6,{dp}
SET1 dp, bit:	smb 7,{dp}
CLR1 dp, bit:	rmb 1,{dp}
CLR1 dp, bit:	rmb 2,{dp}
CLR1 dp, bit:	rmb 3,{dp}
CLR1 dp, bit:	rmb 4,{dp}
CLR1 dp, bit:	rmb 5,{dp}
CLR1 dp, bit:	rmb 6,{dp}
CLR1 dp, bit:	rmb 7,{dp}
TCLR1 !abs:		trb{abs}
AND1 C, abs, bit:	anc{bit,abs}
AND1 C, /abs, bit:	anc{bit,!abs}
OR1 C, /abs, bit:	orc{bit,!abs}
EOR1 C, abs, bit:	eor{bit,abs}
NOT1 abs, bit:	imb{bit,abs}
MOV1 C, abs, bit:	ldc{bit,abs}
MOV1 abs, bit, C:	stc{bit,abs}
CLRC:			clc{imp}
SETC:			sec{imp}
NOTC:			ivc{imp}
CLRV:			clv{imp}
CLRP:			clp{imp}
SETP:			sep{imp}
EI:				cli{imp}
DI:				sei{imp}
SLEEP:			wai{imp}
STOP:			stp{imp}

NOP:			nop{imp}
TCALL n:		jtr 0{imp}
SET1 dp, bit:	smb 0,{dp}
BBS dp, bit, rel:	bbs 0,{dp,rel}
OR A, dp:		ora{dp}
OR A, !abs:		ora{abs}
OR A, (X):		ora{(x)}
OR A, [dp+X]:	ora{(dp,X)}
OR A, #imm:		ora{imm}
OR dp, dp:		ors{dp,dp}
OR1 C, abs, bit:	orc{bit,abs}
ASL dp:			asl{dp}
ASL !abs:		asl{abs}
PUSH PSW:		php{imp}
TSET1 !abs:		tsb{abs}
BRK:			brk{imp}
BPL rel:		bpl{rel}
TCALL n:		jtr 1{imp}
CLR1 dp, bit:	rmb 0,{dp}
BBC dp, bit, rel:	bbc 0,{dp,rel}
OR A, dp+X:		ora{dp,X}
OR A, !abs+X:	ora{abs,X}
OR A, !abs+Y:	ora{abs,Y}
OR A, [dp]+Y:	ora{(dp),Y}
OR dp, #imm:	ors{dp,imm}
OR (X), (Y):	ors{(x),(y)}
TCALL n:		jtr 2{imp}
TCALL n:		jtr 3{imp}
TCALL n:		jtr 4{imp}
TCALL n:		jtr 5{imp}
TCALL n:		jtr 6{imp}
TCALL n:		jtr 7{imp}
TCALL n:		jtr 8{imp}
TCALL n:		jtr 9{imp}
TCALL n:		jtr A{imp}
TCALL n:		jtr B{imp}
TCALL n:		jtr C{imp}
TCALL n:		jtr D{imp}
TCALL n:		jtr E{imp}
TCALL n:		jtr F{imp}