diff --git a/cpu.h b/cpu.h
index ee5c0f9..40f52b7 100644
--- a/cpu.h
+++ b/cpu.h
@@ -20,8 +20,8 @@ public:
 	void debug() { _debug = !_debug; }
 
 protected:
-	CPU (Memory &m, jmp_buf *e, statfn s): _memory(m), _err(e), _status(s){}
-	Memory &_memory;
+	CPU (Memory &mem, jmp_buf *e, statfn s): _mem(mem), _err(e), _status(s){}
+	Memory &_mem;
 	jmp_buf *_err;
 	statfn _status;
 	bool _debug;
diff --git a/r6502.cpp b/r6502.cpp
index 20ab63a..5e31d84 100644
--- a/r6502.cpp
+++ b/r6502.cpp
@@ -10,7 +10,7 @@
 		 	P.bits.D,P.bits.I,P.bits.Z,P.bits.C,PC
 
 inline void r6502::step() {
-	byte op = _memory[PC];
+	byte op = _mem[PC];
 #ifdef CPU_DEBUG
 	if (_debug) {
 		flags();
diff --git a/r6502.h b/r6502.h
index 6b31391..722f59e 100644
--- a/r6502.h
+++ b/r6502.h
@@ -42,16 +42,16 @@ private:
 
 	/* stack */
 	inline void pusha (Memory::address ret) {
-		_memory[0x0100+S--] = ret >> 8;
-		_memory[0x0100+S--] = ret & 0xff;
+		_mem[0x0100+S--] = ret >> 8;
+		_mem[0x0100+S--] = ret & 0xff;
 	}
 
 	inline void pushb (byte b) {
-		_memory[0x0100+S--] = b;
+		_mem[0x0100+S--] = b;
 	}
 
 	inline byte popb () {
-		return _memory[++S+0x0100];
+		return _mem[++S+0x0100];
 	}
 
 	inline Memory::address popa () {
@@ -64,7 +64,7 @@ private:
 	static const Memory::address ibvec = 0xfffe;
 	
 	inline Memory::address vector(Memory::address v) {
-		return (_memory[v+1] << 8) | _memory[v];
+		return (_mem[v+1] << 8) | _mem[v];
 	}
 
 	/* operators */
@@ -80,19 +80,19 @@ private:
 
 	/* modes */
 	inline Memory::address _a () { 
-		Memory::address a = _memory[PC++];
-		return a | (_memory[PC++] << 8);
+		Memory::address a = _mem[PC++];
+		return a | (_mem[PC++] << 8);
 	}
 	inline Memory::address _ax () { return _a()+X; }
 	inline Memory::address _ay () { return _a()+Y; }
-	inline Memory::address _z () { return _memory[PC++]; }
+	inline Memory::address _z () { return _mem[PC++]; }
 	inline Memory::address _zx () { return (_z()+X) & 0xff; }
 	inline Memory::address _zy () { return (_z()+Y) & 0xff; }
 	inline Memory::address _i (Memory::address a) { 
-		return (_memory[a+1]<<8)|_memory[a]; 
+		return (_mem[a+1]<<8)|_mem[a]; 
 	}
 	inline Memory::address _ix () { return _i(_zx()); }
-	inline Memory::address _iy () { return _i(_memory[PC++])+Y; }
+	inline Memory::address _iy () { return _i(_mem[PC++])+Y; }
 
 	void _adc (byte a);
 	void _sbc (byte a) { if (P.bits.D) sbcd(a); else _adc(~a); }
@@ -102,31 +102,31 @@ private:
 		N=b>>1; if (C) N|=0x80; C=b&1; return Z=N;
 	}
 	inline void _ror (Memory::address a) {
-		_memory[a] = __ror(_memory[a]);
+		_mem[a] = __ror(_mem[a]);
 	}
 	inline byte __rol (byte b) {
 		N=b<<1; if (C) N|=1; C=(b&0x80)!=0; return Z=N;
 	}
 	inline void _rol (Memory::address a) {
-		_memory[a] = __rol(_memory[a]);
+		_mem[a] = __rol(_mem[a]);
 	}
 	inline byte __asl (byte b) { C=(b&0x80)!=0; return Z=N=b<<1; }
 	inline void _asl (Memory::address a) {
-		_memory[a] = __asl(_memory[a]);
+		_mem[a] = __asl(_mem[a]);
 	}
 	inline byte __lsr (byte b) { C=b&1; Z=b>>1; N=0; return Z; }
 	inline void _lsr (Memory::address a) {
-		_memory[a] = __lsr(_memory[a]);
+		_mem[a] = __lsr(_mem[a]);
 	}
 	inline void _inc (Memory::address a) {
-		Z=N=1+_memory[a]; _memory[a]=Z;
+		Z=N=1+_mem[a]; _mem[a]=Z;
 	}
 	inline void _dec (Memory::address a) {
-		Z=N=_memory[a]-1; _memory[a]=Z;
+		Z=N=_mem[a]-1; _mem[a]=Z;
 	}
 	inline void _bit (byte z) { V=((z & 0x40)!=0); N=(z & 0x80); Z=(A & z); }
 	inline void _bra() {
-		byte b = _memory[PC];
+		byte b = _mem[PC];
 		PC += b;
 		if (b > 127) PC -= 0x0100;
 	}
@@ -136,179 +136,179 @@ private:
 
 	/* operations */
 	void brk ();
-	void ora_ix () { _ora (_memory[_ix()]); }
+	void ora_ix () { _ora (_mem[_ix()]); }
 	void ill ();
 	void nop2 () { PC++; }
-	void ora_z () { _ora (_memory[_z()]); }
+	void ora_z () { _ora (_mem[_z()]); }
 	void asl_z () { _asl (_z()); }
 	void php ();
-	void ora_ () { _ora (_memory[PC++]); }
+	void ora_ () { _ora (_mem[PC++]); }
 	void asl () { C=(A&0x80)!=0; Z=N=A<<=1; }
 	void nop3 () { PC+=2; }
-	void ora_a () { _ora (_memory[_a()]); }
+	void ora_a () { _ora (_mem[_a()]); }
 	void asl_a () { _asl (_a()); }
 	// 10
 	void bpl () { if (!(N & 0x80)) _bra(); PC++; }
-	void ora_iy () { _ora (_memory[_iy()]); }
-	void ora_zx () { _ora (_memory[_zx()]); }
+	void ora_iy () { _ora (_mem[_iy()]); }
+	void ora_zx () { _ora (_mem[_zx()]); }
 	void asl_zx () { _asl (_zx()); }
 	void clc () { C=0; }
-	void ora_ay () { _ora (_memory[_ay()]); }
+	void ora_ay () { _ora (_mem[_ay()]); }
 	void nop () { }
-	void ora_ax () { _ora (_memory[_ax()]); }
+	void ora_ax () { _ora (_mem[_ax()]); }
 	void asl_ax () { _asl (_ax()); }
 	// 20
 	void jsr ();
-	void and_ix () { _and (_memory[_ix()]); }
-	void bit_z () { _bit (_memory[_z()]); }
-	void and_z () { _and (_memory[_z()]); }
+	void and_ix () { _and (_mem[_ix()]); }
+	void bit_z () { _bit (_mem[_z()]); }
+	void and_z () { _and (_mem[_z()]); }
 	void rol_z () { _rol (_z()); }
 	void plp ();
-	void and_ () { _and (_memory[PC++]); }
+	void and_ () { _and (_mem[PC++]); }
 	void rol () { A=__rol (A); }
-	void bit_a () { _bit (_memory[_a()]); }
-	void and_a () { _and (_memory[_a()]); }
+	void bit_a () { _bit (_mem[_a()]); }
+	void and_a () { _and (_mem[_a()]); }
 	void rol_a () { _rol (_a()); }
 	// 30
 	void bmi () { if (N & 0x80) _bra(); PC++; }
-	void and_iy () { _and (_memory[_iy()]); }
-	void and_zx () { _and (_memory[_zx()]); }
+	void and_iy () { _and (_mem[_iy()]); }
+	void and_zx () { _and (_mem[_zx()]); }
 	void rol_zx () { _rol (_zx()); }
 	void sec () { C=1; }
-	void and_ay () { _and (_memory[_ay()]); }
-	void and_ax () { _and (_memory[_ax()]); }
+	void and_ay () { _and (_mem[_ay()]); }
+	void and_ax () { _and (_mem[_ax()]); }
 	void rol_ax () { _rol (_ax()); }
 	// 40
 	void rti ();
-	void eor_ix () { _eor (_memory[_ix()]); }
-	void eor_z () { _eor (_memory[_z()]); }
+	void eor_ix () { _eor (_mem[_ix()]); }
+	void eor_z () { _eor (_mem[_z()]); }
 	void lsr_z () { _lsr (_z()); }
 	void pha () { pushb (A); }
-	void eor_ () { _eor (_memory[PC++]); }
+	void eor_ () { _eor (_mem[PC++]); }
 	void lsr_ () { A=__lsr(A); }
 	void jmp () { PC = _a (); }
-	void eor_a () { _eor (_memory[_a()]); }
+	void eor_a () { _eor (_mem[_a()]); }
 	void lsr_a () { _lsr (_a()); }
 	// 50
 	void bvc () { if (!V) _bra(); PC++; }
-	void eor_iy () { _eor (_memory[_iy()]); }
-	void eor_zx () { _eor (_memory[_zx()]); }
+	void eor_iy () { _eor (_mem[_iy()]); }
+	void eor_zx () { _eor (_mem[_zx()]); }
 	void lsr_zx () { _lsr (_zx()); }
 	void cli ();
-	void eor_ay () { _eor (_memory[_ay()]); }
-	void eor_ax () { _eor (_memory[_ax()]); }
+	void eor_ay () { _eor (_mem[_ay()]); }
+	void eor_ax () { _eor (_mem[_ax()]); }
 	void lsr_ax () { _lsr (_ax()); }
 	// 60
 	void rts ();
-	void adc_ix () { _adc (_memory[_ix()]); }
-	void adc_z () { _adc (_memory[_z()]); }
+	void adc_ix () { _adc (_mem[_ix()]); }
+	void adc_z () { _adc (_mem[_z()]); }
 	void ror_z () { _ror (_z()); }
 	void pla () { Z=N=A=popb (); }
-	void adc_ () { _adc (_memory[PC++]); }
+	void adc_ () { _adc (_mem[PC++]); }
 	void ror_ () { A=__ror (A); }
 	void jmp_i () { PC = _i(_a()); }
-	void adc_a () { _adc (_memory[_a()]); }
+	void adc_a () { _adc (_mem[_a()]); }
 	void ror_a () { _ror (_a()); }
 	// 70
 	void bvs () { if (V) _bra(); PC++; }
-	void adc_iy () { _adc (_memory[_iy()]); }
-	void adc_zx () { _adc (_memory[_zx()]); }
+	void adc_iy () { _adc (_mem[_iy()]); }
+	void adc_zx () { _adc (_mem[_zx()]); }
 	void ror_zx () { _ror (_zx ()); }
 	void sei () { P.bits.I = 1; }
-	void adc_ay () { _adc (_memory[_ay()]); }
-	void adc_ax () { _adc (_memory[_ax()]); }
+	void adc_ay () { _adc (_mem[_ay()]); }
+	void adc_ax () { _adc (_mem[_ax()]); }
 	void ror_ax () { _ror (_ax ()); }
 	// 80
-	void sta_ix () { _memory[_ix()] = A; }
-	void sty_z () { _memory[_z()] = Y; }
-	void sta_z () { _memory[_z()] = A; }
-	void stx_z () { _memory[_z()] = X; }
+	void sta_ix () { _mem[_ix()] = A; }
+	void sty_z () { _mem[_z()] = Y; }
+	void sta_z () { _mem[_z()] = A; }
+	void stx_z () { _mem[_z()] = X; }
 	void dey () { Z=N=--Y; }
 	void txa () { Z=N=A=X; }
-	void sty_a () { _memory[_a()] = Y; }
-	void sta_a () { _memory[_a()] = A; }
-	void stx_a () { _memory[_a()] = X; }
+	void sty_a () { _mem[_a()] = Y; }
+	void sta_a () { _mem[_a()] = A; }
+	void stx_a () { _mem[_a()] = X; }
 	// 90
 	void bcc () { if (!C) _bra(); PC++; }
-	void sta_iy () { _memory[_iy()] = A; }
-	void sty_zx () { _memory[_zx()] = Y; }
-	void sta_zx () { _memory[_zx()] = A; }
-	void stx_zy () { _memory[_zy()] = X; }
+	void sta_iy () { _mem[_iy()] = A; }
+	void sty_zx () { _mem[_zx()] = Y; }
+	void sta_zx () { _mem[_zx()] = A; }
+	void stx_zy () { _mem[_zy()] = X; }
 	void tya () { Z=N=A=Y; }
-	void sta_ay () { _memory[_ay()] = A; }
+	void sta_ay () { _mem[_ay()] = A; }
 	void txs () { S=X; }
-	void sta_ax () { _memory[_ax()] = A; }
+	void sta_ax () { _mem[_ax()] = A; }
 	// a0
-	void ldy_ () { _ldy (_memory[PC++]); }
-	void lda_ix () { _lda (_memory[_ix()]); }
-	void ldx_ () { _ldx (_memory[PC++]); }
+	void ldy_ () { _ldy (_mem[PC++]); }
+	void lda_ix () { _lda (_mem[_ix()]); }
+	void ldx_ () { _ldx (_mem[PC++]); }
 	void lax_ix () { lda_ix (); X=A; }
-	void ldy_z () { _ldy (_memory[_z()]); }
-	void lda_z () { _lda (_memory[_z()]); }
-	void ldx_z () { _ldx (_memory[_z()]); }
+	void ldy_z () { _ldy (_mem[_z()]); }
+	void lda_z () { _lda (_mem[_z()]); }
+	void ldx_z () { _ldx (_mem[_z()]); }
 	void lax_z () { lda_z (); X=A; }
 	void tay () { Z=N=Y=A; }
-	void lda_ () { _lda (_memory[PC++]); }
+	void lda_ () { _lda (_mem[PC++]); }
 	void tax () { Z=N=X=A; }
-	void ldy_a () { _ldy (_memory[_a()]); }
-	void lda_a () { _lda (_memory[_a()]); }
-	void ldx_a () { _ldx (_memory[_a()]); }
+	void ldy_a () { _ldy (_mem[_a()]); }
+	void lda_a () { _lda (_mem[_a()]); }
+	void ldx_a () { _ldx (_mem[_a()]); }
 	void lax_a () { lda_a (); X=A; }
 	// b0
 	void bcs () { if (C) _bra(); PC++; }
-	void lda_iy () { _lda (_memory[_iy()]); }
+	void lda_iy () { _lda (_mem[_iy()]); }
 	void lax_iy () { lda_iy (); X=A; }
-	void ldy_zx () { _ldy (_memory[_zx()]); }
-	void lda_zx () { _lda (_memory[_zx()]); }
-	void ldx_zy () { _ldx (_memory[_zy()]); }
+	void ldy_zx () { _ldy (_mem[_zx()]); }
+	void lda_zx () { _lda (_mem[_zx()]); }
+	void ldx_zy () { _ldx (_mem[_zy()]); }
 	void lax_zy () { ldx_zy (); A=X; }
 	void clv () { V=0; }
-	void lda_ay () { _lda (_memory[_ay()]); }
+	void lda_ay () { _lda (_mem[_ay()]); }
 	void tsx () { Z=N=X=S; }
-	void ldy_ax () { _ldy (_memory[_ax()]); }
-	void lda_ax () { _lda (_memory[_ax()]); }
-	void ldx_ay () { _ldx (_memory[_ay()]); }
+	void ldy_ax () { _ldy (_mem[_ax()]); }
+	void lda_ax () { _lda (_mem[_ax()]); }
+	void ldx_ay () { _ldx (_mem[_ay()]); }
 	void lax_ay () { ldx_ay (); A=X; }
 	// c0
-	void cpy_ () { _cpy (_memory[PC++]); }
-	void cmp_ix () { _cmp (_memory[_ix()]); }
-	void cpy_z () { _cpy (_memory[_z()]); }
-	void cmp_z () { _cmp (_memory[_z()]); }
+	void cpy_ () { _cpy (_mem[PC++]); }
+	void cmp_ix () { _cmp (_mem[_ix()]); }
+	void cpy_z () { _cpy (_mem[_z()]); }
+	void cmp_z () { _cmp (_mem[_z()]); }
 	void dec_z () { _dec (_z()); }
 	void iny () { Z=N=++Y; }
-	void cmp_ () { _cmp (_memory[PC++]); }
+	void cmp_ () { _cmp (_mem[PC++]); }
 	void dex () { Z=N=--X; }
-	void cpy_a () { _cpy (_memory[_a()]); }
-	void cmp_a () { _cmp (_memory[_a()]); }
+	void cpy_a () { _cpy (_mem[_a()]); }
+	void cmp_a () { _cmp (_mem[_a()]); }
 	void dec_a () { _dec (_a()); }
 	// d0
 	void bne () { if (Z) _bra(); PC++; }
-	void cmp_iy () { _cmp (_memory[_iy()]); }
-	void cmp_zx () { _cmp (_memory[_zx()]); }
+	void cmp_iy () { _cmp (_mem[_iy()]); }
+	void cmp_zx () { _cmp (_mem[_zx()]); }
 	void dec_zx () { _dec (_zx()); }
 	void cld () { P.bits.D = 0; }
-	void cmp_ay () { _cmp (_memory[_ay()]); }
-	void cmp_ax () { _cmp (_memory[_ax()]); }
+	void cmp_ay () { _cmp (_mem[_ay()]); }
+	void cmp_ax () { _cmp (_mem[_ax()]); }
 	void dec_ax () { _dec (_ax()); }
 	// e0
-	void cpx_ () { _cpx (_memory[PC++]); }
-	void sbc_ix () { _sbc (_memory[_ix()]); }
-	void cpx_z () { _cpx (_memory[_z()]); }
-	void sbc_z () { _sbc (_memory[_z()]); }
+	void cpx_ () { _cpx (_mem[PC++]); }
+	void sbc_ix () { _sbc (_mem[_ix()]); }
+	void cpx_z () { _cpx (_mem[_z()]); }
+	void sbc_z () { _sbc (_mem[_z()]); }
 	void inc_z () { _inc (_z()); }
 	void inx () { Z=N=++X; }
-	void sbc_ () { _sbc (_memory[PC++]); }
-	void cpx_a () { _cpx (_memory[_a()]); }
-	void sbc_a () { _sbc (_memory[_a()]); }
+	void sbc_ () { _sbc (_mem[PC++]); }
+	void cpx_a () { _cpx (_mem[_a()]); }
+	void sbc_a () { _sbc (_mem[_a()]); }
 	void inc_a () { _inc (_a()); }
 	// f0
 	void beq () { if (!Z) _bra(); PC++; }
-	void sbc_iy () { _sbc (_memory[_iy()]); }
-	void sbc_zx () { _sbc (_memory[_zx()]); }
+	void sbc_iy () { _sbc (_mem[_iy()]); }
+	void sbc_zx () { _sbc (_mem[_zx()]); }
 	void inc_zx () { _inc (_zx()); }
 	void sed () { P.bits.D = 1; }
-	void sbc_ay () { _sbc (_memory[_ay()]); }
-	void sbc_ax () { _sbc (_memory[_ax()]); }
+	void sbc_ay () { _sbc (_mem[_ay()]); }
+	void sbc_ax () { _sbc (_mem[_ax()]); }
 	void inc_ax () { _inc (_ax()); }
 };
 #endif