diff --git a/z80.cpp b/z80.cpp
index 394a3e2..1965af9 100644
--- a/z80.cpp
+++ b/z80.cpp
@@ -82,7 +82,7 @@ void z80::run(unsigned clocks) {
 	while (clocks--) {
 		if (_irq_pending)
 			_handle_interrupt();
-		step();
+		op(_fetch_op());
 		if (_halted)
 			break;
 	}
@@ -875,330 +875,6 @@ z80::z80(Memory &m, PortDevice<z80> &ports): CPU(m)
 {
 	_ports = &ports;
 
-	OP *p = _ops;
-
-	// 0x00
-	*p++ = &z80::nop; *p++ = &z80::ldbcpc;
-	*p++ = &z80::ldBCa; *p++ = &z80::incbc;
-	*p++ = &z80::incb; *p++ = &z80::decb;
-	*p++ = &z80::ldb; *p++ = &z80::rlca;
-	*p++ = &z80::exaf; *p++ = &z80::addhlbc;
-	*p++ = &z80::ldaBC; *p++ = &z80::decbc;
-	*p++ = &z80::incc; *p++ = &z80::decc;
-	*p++ = &z80::ldc; *p++ = &z80::rrca;
-
-	// 0x10
-	*p++ = &z80::djnz; *p++ = &z80::lddepc;
-	*p++ = &z80::ldDEa; *p++ = &z80::incde;
-	*p++ = &z80::incd; *p++ = &z80::decd;
-	*p++ = &z80::ldd; *p++ = &z80::rla;
-	*p++ = &z80::jr; *p++ = &z80::addhlde;
-	*p++ = &z80::ldaDE; *p++ = &z80::decde;
-	*p++ = &z80::ince; *p++ = &z80::dece;
-	*p++ = &z80::lde; *p++ = &z80::rra;
-
-	// 0x20
-	*p++ = &z80::jrnz; *p++ = &z80::ldhlpc;
-	*p++ = &z80::ldPChl; *p++ = &z80::inchl;
-	*p++ = &z80::inch; *p++ = &z80::dech;
-	*p++ = &z80::ldh; *p++ = &z80::daa;
-	*p++ = &z80::jrz; *p++ = &z80::addhlhl;
-	*p++ = &z80::ldhlPC; *p++ = &z80::dechl;
-	*p++ = &z80::incl; *p++ = &z80::decl;
-	*p++ = &z80::ldl; *p++ = &z80::cpl;
-
-	// 0x30
-	*p++ = &z80::jrnc; *p++ = &z80::ldsppc;
-	*p++ = &z80::ldPCa; *p++ = &z80::incsp;
-	*p++ = &z80::incHL; *p++ = &z80::decHL;
-	*p++ = &z80::ldHL; *p++ = &z80::scf;
-	*p++ = &z80::jrc; *p++ = &z80::addhlsp;
-	*p++ = &z80::ldaPC; *p++ = &z80::decsp;
-	*p++ = &z80::inca; *p++ = &z80::deca;
-	*p++ = &z80::lda; *p++ = &z80::ccf;
-
-	// 0x40
-	*p++ = &z80::ldbb; *p++ = &z80::ldbc;
-	*p++ = &z80::ldbd; *p++ = &z80::ldbe;
-	*p++ = &z80::ldbh; *p++ = &z80::ldbl;
-	*p++ = &z80::ldbHL; *p++ = &z80::ldba;
-	*p++ = &z80::ldcb; *p++ = &z80::ldcc;
-	*p++ = &z80::ldcd; *p++ = &z80::ldce;
-	*p++ = &z80::ldch; *p++ = &z80::ldcl;
-	*p++ = &z80::ldcHL; *p++ = &z80::ldca;
-
-	// 0x50
-	*p++ = &z80::lddb; *p++ = &z80::lddc;
-	*p++ = &z80::lddd; *p++ = &z80::ldde;
-	*p++ = &z80::lddh; *p++ = &z80::lddl;
-	*p++ = &z80::lddHL; *p++ = &z80::ldda;
-	*p++ = &z80::ldeb; *p++ = &z80::ldec;
-	*p++ = &z80::lded; *p++ = &z80::ldee;
-	*p++ = &z80::ldeh; *p++ = &z80::ldel;
-	*p++ = &z80::ldeHL; *p++ = &z80::ldea;
-
-	// 0x60
-	*p++ = &z80::ldhb; *p++ = &z80::ldhc;
-	*p++ = &z80::ldhd; *p++ = &z80::ldhe;
-	*p++ = &z80::ldhh; *p++ = &z80::ldhl;
-	*p++ = &z80::ldhHL; *p++ = &z80::ldha;
-	*p++ = &z80::ldlb; *p++ = &z80::ldlc;
-	*p++ = &z80::ldld; *p++ = &z80::ldle;
-	*p++ = &z80::ldlh; *p++ = &z80::ldll;
-	*p++ = &z80::ldlHL; *p++ = &z80::ldla;
-
-	// 0x70
-	*p++ = &z80::ldHLb; *p++ = &z80::ldHLc;
-	*p++ = &z80::ldHLd; *p++ = &z80::ldHLe;
-	*p++ = &z80::ldHLh; *p++ = &z80::ldHLl;
-	*p++ = &z80::halt; *p++ = &z80::ldHLa;
-	*p++ = &z80::ldab; *p++ = &z80::ldac;
-	*p++ = &z80::ldad; *p++ = &z80::ldae;
-	*p++ = &z80::ldah; *p++ = &z80::ldal;
-	*p++ = &z80::ldaHL; *p++ = &z80::ldaa;
-
-	// 0x80
-	*p++ = &z80::addab; *p++ = &z80::addac;
-	*p++ = &z80::addad; *p++ = &z80::addae;
-	*p++ = &z80::addah; *p++ = &z80::addal;
-	*p++ = &z80::addaHL; *p++ = &z80::addaa;
-	*p++ = &z80::adcab; *p++ = &z80::adcac;
-	*p++ = &z80::adcad; *p++ = &z80::adcae;
-	*p++ = &z80::adcah; *p++ = &z80::adcal;
-	*p++ = &z80::adcaHL; *p++ = &z80::adcaa;
-
-	// 0x90
-	*p++ = &z80::subab; *p++ = &z80::subac;
-	*p++ = &z80::subad; *p++ = &z80::subae;
-	*p++ = &z80::subah; *p++ = &z80::subal;
-	*p++ = &z80::subaHL; *p++ = &z80::subaa;
-	*p++ = &z80::sbcab; *p++ = &z80::sbcac;
-	*p++ = &z80::sbcad; *p++ = &z80::sbcae;
-	*p++ = &z80::sbcah; *p++ = &z80::sbcal;
-	*p++ = &z80::sbcaHL; *p++ = &z80::sbcaa;
-
-	// 0xa0
-	*p++ = &z80::andb; *p++ = &z80::andc;
-	*p++ = &z80::andd; *p++ = &z80::ande;
-	*p++ = &z80::andh; *p++ = &z80::andl;
-	*p++ = &z80::andHL; *p++ = &z80::anda;
-	*p++ = &z80::xorb; *p++ = &z80::xorc;
-	*p++ = &z80::xord; *p++ = &z80::xore;
-	*p++ = &z80::xorh; *p++ = &z80::xorl;
-	*p++ = &z80::xorHL; *p++ = &z80::xora;
-
-	// 0xb0
-	*p++ = &z80::orb; *p++ = &z80::orc;
-	*p++ = &z80::ord; *p++ = &z80::ore;
-	*p++ = &z80::orh; *p++ = &z80::orl;
-	*p++ = &z80::orHL; *p++ = &z80::ora;
-	*p++ = &z80::cpb; *p++ = &z80::cpc;
-	*p++ = &z80::cpd; *p++ = &z80::cpe;
-	*p++ = &z80::cph; *p++ = &z80::cpL;
-	*p++ = &z80::cpHL; *p++ = &z80::cpa;
-
-	// 0xc0
-	*p++ = &z80::retnz; *p++ = &z80::popbc;
-	*p++ = &z80::jpnz; *p++ = &z80::jp;
-	*p++ = &z80::callnz; *p++ = &z80::pushbc;
-	*p++ = &z80::adda; *p++ = &z80::rst00;
-	*p++ = &z80::retz; *p++ = &z80::ret;
-	*p++ = &z80::jpz; *p++ = &z80::cb;
-	*p++ = &z80::callz; *p++ = &z80::call;
-	*p++ = &z80::adca; *p++ = &z80::rst08;
-
-	// 0xd0
-	*p++ = &z80::retnc; *p++ = &z80::popde;
-	*p++ = &z80::jpnc; *p++ = &z80::outa;
-	*p++ = &z80::callnc; *p++ = &z80::pushde;
-	*p++ = &z80::suba; *p++ = &z80::rst10;
-	*p++ = &z80::retc; *p++ = &z80::exx;
-	*p++ = &z80::jpc; *p++ = &z80::ina;
-	*p++ = &z80::callc; *p++ = &z80::dd;
-	*p++ = &z80::sbca; *p++ = &z80::rst18;
-
-	// 0xe0
-	*p++ = &z80::retpo; *p++ = &z80::pophl;
-	*p++ = &z80::jppo; *p++ = &z80::exSPhl;
-	*p++ = &z80::callpo; *p++ = &z80::pushhl;
-	*p++ = &z80::and_; *p++ = &z80::rst20;
-	*p++ = &z80::retpe; *p++ = &z80::jphl;
-	*p++ = &z80::jppe; *p++ = &z80::exdehl;
-	*p++ = &z80::callpe; *p++ = &z80::ed;
-	*p++ = &z80::xor_; *p++ = &z80::rst28;
-
-	// 0xf0
-	*p++ = &z80::retp; *p++ = &z80::popaf;
-	*p++ = &z80::jpp; *p++ = &z80::di;
-	*p++ = &z80::callp; *p++ = &z80::pushaf;
-	*p++ = &z80::or_; *p++ = &z80::rst30;
-	*p++ = &z80::retm; *p++ = &z80::ldsphl;
-	*p++ = &z80::jpm; *p++ = &z80::ei;
-	*p++ = &z80::callm; *p++ = &z80::fd;
-	*p++ = &z80::cp; *p++ = &z80::rst38;
-
-	OP *c = _cb;
-
-	// 0x00
-	*c++ = &z80::rlcB; *c++ = &z80::rlcC;
-	*c++ = &z80::rlcD; *c++ = &z80::rlcE;
-	*c++ = &z80::rlcH; *c++ = &z80::rlcL;
-	*c++ = &z80::rlcHL; *c++ = &z80::rlcA;
-	*c++ = &z80::rrcB; *c++ = &z80::rrcC;
-	*c++ = &z80::rrcD; *c++ = &z80::rrcE;
-	*c++ = &z80::rrcH; *c++ = &z80::rrcL;
-	*c++ = &z80::rrcHL; *c++ = &z80::rrcA;
-
-	// 0x10
-	*c++ = &z80::rlB; *c++ = &z80::rlC;
-	*c++ = &z80::rlD; *c++ = &z80::rlE;
-	*c++ = &z80::rlH; *c++ = &z80::rlL;
-	*c++ = &z80::rlHL; *c++ = &z80::rlA;
-	*c++ = &z80::rrB; *c++ = &z80::rrC;
-	*c++ = &z80::rrD; *c++ = &z80::rrE;
-	*c++ = &z80::rrH; *c++ = &z80::rrL;
-	*c++ = &z80::rrHL; *c++ = &z80::rrA;
-
-	// 0x20
-	*c++ = &z80::slab; *c++ = &z80::slac;
-	*c++ = &z80::slad; *c++ = &z80::slae;
-	*c++ = &z80::slah; *c++ = &z80::slal;
-	*c++ = &z80::slaHL; *c++ = &z80::slaa;
-	*c++ = &z80::srab; *c++ = &z80::srac;
-	*c++ = &z80::srad; *c++ = &z80::srae;
-	*c++ = &z80::srah; *c++ = &z80::sral;
-	*c++ = &z80::sraHL; *c++ = &z80::sraa;
-
-	// 0x30
-	*c++ = &z80::sllb; *c++ = &z80::sllc;
-	*c++ = &z80::slld; *c++ = &z80::slle;
-	*c++ = &z80::sllh; *c++ = &z80::slll;
-	*c++ = &z80::sllHL; *c++ = &z80::slla;
-	*c++ = &z80::srlb; *c++ = &z80::srlc;
-	*c++ = &z80::srld; *c++ = &z80::srle;
-	*c++ = &z80::srlh; *c++ = &z80::srll;
-	*c++ = &z80::srlHL; *c++ = &z80::srla;
-
-	// 0x40
-	*c++ = &z80::bit0b; *c++ = &z80::bit0c;
-	*c++ = &z80::bit0d; *c++ = &z80::bit0e;
-	*c++ = &z80::bit0h; *c++ = &z80::bit0l;
-	*c++ = &z80::bit0HL; *c++ = &z80::bit0a;
-	*c++ = &z80::bit1b; *c++ = &z80::bit1c;
-	*c++ = &z80::bit1d; *c++ = &z80::bit1e;
-	*c++ = &z80::bit1h; *c++ = &z80::bit1l;
-	*c++ = &z80::bit1HL; *c++ = &z80::bit1a;
-
-	// 0x50
-	*c++ = &z80::bit2b; *c++ = &z80::bit2c;
-	*c++ = &z80::bit2d; *c++ = &z80::bit2e;
-	*c++ = &z80::bit2h; *c++ = &z80::bit2l;
-	*c++ = &z80::bit2HL; *c++ = &z80::bit2a;
-	*c++ = &z80::bit3b; *c++ = &z80::bit3c;
-	*c++ = &z80::bit3d; *c++ = &z80::bit3e;
-	*c++ = &z80::bit3h; *c++ = &z80::bit3l;
-	*c++ = &z80::bit3HL; *c++ = &z80::bit3a;
-
-	// 0x60
-	*c++ = &z80::bit4b; *c++ = &z80::bit4c;
-	*c++ = &z80::bit4d; *c++ = &z80::bit4e;
-	*c++ = &z80::bit4h; *c++ = &z80::bit4l;
-	*c++ = &z80::bit4HL; *c++ = &z80::bit4a;
-	*c++ = &z80::bit5b; *c++ = &z80::bit5c;
-	*c++ = &z80::bit5d; *c++ = &z80::bit5e;
-	*c++ = &z80::bit5h; *c++ = &z80::bit5l;
-	*c++ = &z80::bit5HL; *c++ = &z80::bit5a;
-
-	// 0x70
-	*c++ = &z80::bit6b; *c++ = &z80::bit6c;
-	*c++ = &z80::bit6d; *c++ = &z80::bit6e;
-	*c++ = &z80::bit6h; *c++ = &z80::bit6l;
-	*c++ = &z80::bit6HL; *c++ = &z80::bit6a;
-	*c++ = &z80::bit7b; *c++ = &z80::bit7c;
-	*c++ = &z80::bit7d; *c++ = &z80::bit7e;
-	*c++ = &z80::bit7h; *c++ = &z80::bit7l;
-	*c++ = &z80::bit7HL; *c++ = &z80::bit7a;
-
-	// 0x80
-	*c++ = &z80::res0b; *c++ = &z80::res0c;
-	*c++ = &z80::res0d; *c++ = &z80::res0e;
-	*c++ = &z80::res0h; *c++ = &z80::res0l;
-	*c++ = &z80::res0HL; *c++ = &z80::res0a;
-	*c++ = &z80::res1b; *c++ = &z80::res1c;
-	*c++ = &z80::res1d; *c++ = &z80::res1e;
-	*c++ = &z80::res1h; *c++ = &z80::res1l;
-	*c++ = &z80::res1HL; *c++ = &z80::res1a;
-
-	// 0x90
-	*c++ = &z80::res2b; *c++ = &z80::res2c;
-	*c++ = &z80::res2d; *c++ = &z80::res2e;
-	*c++ = &z80::res2h; *c++ = &z80::res2l;
-	*c++ = &z80::res2HL; *c++ = &z80::res2a;
-	*c++ = &z80::res3b; *c++ = &z80::res3c;
-	*c++ = &z80::res3d; *c++ = &z80::res3e;
-	*c++ = &z80::res3h; *c++ = &z80::res3l;
-	*c++ = &z80::res3HL; *c++ = &z80::res3a;
-
-	// 0xa0
-	*c++ = &z80::res4b; *c++ = &z80::res4c;
-	*c++ = &z80::res4d; *c++ = &z80::res4e;
-	*c++ = &z80::res4h; *c++ = &z80::res4l;
-	*c++ = &z80::res4HL; *c++ = &z80::res4a;
-	*c++ = &z80::res5b; *c++ = &z80::res5c;
-	*c++ = &z80::res5d; *c++ = &z80::res5e;
-	*c++ = &z80::res5h; *c++ = &z80::res5l;
-	*c++ = &z80::res5HL; *c++ = &z80::res5a;
-
-	// 0xb0
-	*c++ = &z80::res6b; *c++ = &z80::res6c;
-	*c++ = &z80::res6d; *c++ = &z80::res6e;
-	*c++ = &z80::res6h; *c++ = &z80::res6l;
-	*c++ = &z80::res6HL; *c++ = &z80::res6a;
-	*c++ = &z80::res7b; *c++ = &z80::res7c;
-	*c++ = &z80::res7d; *c++ = &z80::res7e;
-	*c++ = &z80::res7h; *c++ = &z80::res7l;
-	*c++ = &z80::res7HL; *c++ = &z80::res7a;
-
-	// 0xc0
-	*c++ = &z80::set0b; *c++ = &z80::set0c;
-	*c++ = &z80::set0d; *c++ = &z80::set0e;
-	*c++ = &z80::set0h; *c++ = &z80::set0l;
-	*c++ = &z80::set0HL; *c++ = &z80::set0a;
-	*c++ = &z80::set1b; *c++ = &z80::set1c;
-	*c++ = &z80::set1d; *c++ = &z80::set1e;
-	*c++ = &z80::set1h; *c++ = &z80::set1l;
-	*c++ = &z80::set1HL; *c++ = &z80::set1a;
-
-	// 0xd0
-	*c++ = &z80::set2b; *c++ = &z80::set2c;
-	*c++ = &z80::set2d; *c++ = &z80::set2e;
-	*c++ = &z80::set2h; *c++ = &z80::set2l;
-	*c++ = &z80::set2HL; *c++ = &z80::set2a;
-	*c++ = &z80::set3b; *c++ = &z80::set3c;
-	*c++ = &z80::set3d; *c++ = &z80::set3e;
-	*c++ = &z80::set3h; *c++ = &z80::set3l;
-	*c++ = &z80::set3HL; *c++ = &z80::set3a;
-
-	// 0xe0
-	*c++ = &z80::set4b; *c++ = &z80::set4c;
-	*c++ = &z80::set4d; *c++ = &z80::set4e;
-	*c++ = &z80::set4h; *c++ = &z80::set4l;
-	*c++ = &z80::set4HL; *c++ = &z80::set4a;
-	*c++ = &z80::set5b; *c++ = &z80::set5c;
-	*c++ = &z80::set5d; *c++ = &z80::set5e;
-	*c++ = &z80::set5h; *c++ = &z80::set5l;
-	*c++ = &z80::set5HL; *c++ = &z80::set5a;
-
-	// 0xf0
-	*c++ = &z80::set6b; *c++ = &z80::set6c;
-	*c++ = &z80::set6d; *c++ = &z80::set6e;
-	*c++ = &z80::set6h; *c++ = &z80::set6l;
-	*c++ = &z80::set6HL; *c++ = &z80::set6a;
-	*c++ = &z80::set7b; *c++ = &z80::set7c;
-	*c++ = &z80::set7d; *c++ = &z80::set7e;
-	*c++ = &z80::set7h; *c++ = &z80::set7l;
-	*c++ = &z80::set7HL; *c++ = &z80::set7a;
-
 	OP_IDX *d = _ddcb;
 
 	// 0x00
@@ -1523,3 +1199,300 @@ z80::z80(Memory &m, PortDevice<z80> &ports): CPU(m)
 	*d++ = &z80::set7IYH; *d++ = &z80::set7IYL;
 	*d++ = &z80::set7IY; *d++ = &z80::set7IYA;
 }
+
+void z80::cb() {
+
+	switch(_fetch_op()) {
+	O(0x00, rlcB);		O(0x01, rlcC);
+	O(0x02, rlcD);		O(0x03, rlcE);
+	O(0x04, rlcH);		O(0x05, rlcL);
+	O(0x06, rlcHL);		O(0x07, rlcA);
+	O(0x08, rrcB);		O(0x09, rrcC);
+	O(0x0a, rrcD);		O(0x0b, rrcE);
+	O(0x0c, rrcH);		O(0x0d, rrcL);
+	O(0x0e, rrcHL);		O(0x0f, rrcA);
+
+	O(0x10, rlB);		O(0x11, rlC);
+	O(0x12, rlD);		O(0x13, rlE);
+	O(0x14, rlH);		O(0x15, rlL);
+	O(0x16, rlHL);		O(0x17, rlA);
+	O(0x18, rrB);		O(0x19, rrC);
+	O(0x1a, rrD);		O(0x1b, rrE);
+	O(0x1c, rrH);		O(0x1d, rrL);
+	O(0x1e, rrHL);		O(0x1f, rrA);
+
+	O(0x20, slab);		O(0x21, slac);
+	O(0x22, slad);		O(0x23, slae);
+	O(0x24, slah);		O(0x25, slal);
+	O(0x26, slaHL);		O(0x27, slaa);
+	O(0x28, srab);		O(0x29, srac);
+	O(0x2a, srad);		O(0x2b, srae);
+	O(0x2c, srah);		O(0x2d, sral);
+	O(0x2e, sraHL);		O(0x2f, sraa);
+
+	O(0x30, sllb);		O(0x31, sllc);
+	O(0x32, slld);		O(0x33, slle);
+	O(0x34, sllh);		O(0x35, slll);
+	O(0x36, sllHL);		O(0x37, slla);
+	O(0x38, srlb);		O(0x39, srlc);
+	O(0x3a, srld);		O(0x3b, srle);
+	O(0x3c, srlh);		O(0x3d, srll);
+	O(0x3e, srlHL);		O(0x3f, srla);
+
+	O(0x40, bit0b);		O(0x41, bit0c);
+	O(0x42, bit0d);		O(0x43, bit0e);
+	O(0x44, bit0h);		O(0x45, bit0l);
+	O(0x46, bit0HL);	O(0x47, bit0a);
+	O(0x48, bit1b);		O(0x49, bit1c);
+	O(0x4a, bit1d);		O(0x4b, bit1e);
+	O(0x4c, bit1h);		O(0x4d, bit1l);
+	O(0x4e, bit1HL);	O(0x4f, bit1a);
+
+	O(0x50, bit2b);		O(0x51, bit2c);
+	O(0x52, bit2d);		O(0x53, bit2e);
+	O(0x54, bit2h);		O(0x55, bit2l);
+	O(0x56, bit2HL);	O(0x57, bit2a);
+	O(0x58, bit3b);		O(0x59, bit3c);
+	O(0x5a, bit3d);		O(0x5b, bit3e);
+	O(0x5c, bit3h);		O(0x5d, bit3l);
+	O(0x5e, bit3HL);	O(0x5f, bit3a);
+
+	O(0x60, bit4b);		O(0x61, bit4c);
+	O(0x62, bit4d);		O(0x63, bit4e);
+	O(0x64, bit4h);		O(0x65, bit4l);
+	O(0x66, bit4HL);	O(0x67, bit4a);
+	O(0x68, bit5b);		O(0x69, bit5c);
+	O(0x6a, bit5d);		O(0x6b, bit5e);
+	O(0x6c, bit5h);		O(0x6d, bit5l);
+	O(0x6e, bit5HL);	O(0x6f, bit5a);
+
+	O(0x70, bit6b);		O(0x71, bit6c);
+	O(0x72, bit6d);		O(0x73, bit6e);
+	O(0x74, bit6h);		O(0x75, bit6l);
+	O(0x76, bit6HL);	O(0x77, bit6a);
+	O(0x78, bit7b);		O(0x79, bit7c);
+	O(0x7a, bit7d);		O(0x7b, bit7e);
+	O(0x7c, bit7h);		O(0x7d, bit7l);
+	O(0x7e, bit7HL);	O(0x7f, bit7a);
+
+	O(0x80, res0b);		O(0x81, res0c);
+	O(0x82, res0d);		O(0x83, res0e);
+	O(0x84, res0h);		O(0x85, res0l);
+	O(0x86, res0HL);	O(0x87, res0a);
+	O(0x88, res1b);		O(0x89, res1c);
+	O(0x8a, res1d);		O(0x8b, res1e);
+	O(0x8c, res1h);		O(0x8d, res1l);
+	O(0x8e, res1HL);	O(0x8f, res1a);
+
+	O(0x90, res2b);		O(0x91, res2c);
+	O(0x92, res2d);		O(0x93, res2e);
+	O(0x94, res2h);		O(0x95, res2l);
+	O(0x96, res2HL);	O(0x97, res2a);
+	O(0x98, res3b);		O(0x99, res3c);
+	O(0x9a, res3d);		O(0x9b, res3e);
+	O(0x9c, res3h);		O(0x9d, res3l);
+	O(0x9e, res3HL);	O(0x9f, res3a);
+
+	O(0xa0, res4b);		O(0xa1, res4c);
+	O(0xa2, res4d);		O(0xa3, res4e);
+	O(0xa4, res4h);		O(0xa5, res4l);
+	O(0xa6, res4HL);	O(0xa7, res4a);
+	O(0xa8, res5b);		O(0xa9, res5c);
+	O(0xaa, res5d);		O(0xab, res5e);
+	O(0xac, res5h);		O(0xad, res5l);
+	O(0xae, res5HL);	O(0xaf, res5a);
+
+	O(0xb0, res6b);		O(0xb1, res6c);
+	O(0xb2, res6d);		O(0xb3, res6e);
+	O(0xb4, res6h);		O(0xb5, res6l);
+	O(0xb6, res6HL);	O(0xb7, res6a);
+	O(0xb8, res7b);		O(0xb9, res7c);
+	O(0xba, res7d);		O(0xbb, res7e);
+	O(0xbc, res7h);		O(0xbd, res7l);
+	O(0xbe, res7HL);	O(0xbf, res7a);
+
+	O(0xc0, set0b);		O(0xc1, set0c);
+	O(0xc2, set0d);		O(0xc3, set0e);
+	O(0xc4, set0h);		O(0xc5, set0l);
+	O(0xc6, set0HL);	O(0xc7, set0a);
+	O(0xc8, set1b);		O(0xc9, set1c);
+	O(0xca, set1d);		O(0xcb, set1e);
+	O(0xcc, set1h);		O(0xcd, set1l);
+	O(0xce, set1HL);	O(0xcf, set1a);
+
+	O(0xd0, set2b);		O(0xd1, set2c);
+	O(0xd2, set2d);		O(0xd3, set2e);
+	O(0xd4, set2h);		O(0xd5, set2l);
+	O(0xd6, set2HL);	O(0xd7, set2a);
+	O(0xd8, set3b);		O(0xd9, set3c);
+	O(0xda, set3d);		O(0xdb, set3e);
+	O(0xdc, set3h);		O(0xdd, set3l);
+	O(0xde, set3HL);	O(0xdf, set3a);
+
+	O(0xe0, set4b);		O(0xe1, set4c);
+	O(0xe2, set4d);		O(0xe3, set4e);
+	O(0xe4, set4h);		O(0xe5, set4l);
+	O(0xe6, set4HL);	O(0xe7, set4a);
+	O(0xe8, set5b);		O(0xe9, set5c);
+	O(0xea, set5d);		O(0xeb, set5e);
+	O(0xec, set5h);		O(0xed, set5l);
+	O(0xee, set5HL);	O(0xef, set5a);
+
+	O(0xf0, set6b);		O(0xf1, set6c);
+	O(0xf2, set6d);		O(0xf3, set6e);
+	O(0xf4, set6h);		O(0xf5, set6l);
+	O(0xf6, set6HL);	O(0xf7, set6a);
+	O(0xf8, set7b);		O(0xf9, set7c);
+	O(0xfa, set7d);		O(0xfb, set7e);
+	O(0xfc, set7h);		O(0xfd, set7l);
+	O(0xfe, set7HL);	O(0xff, set7a);
+	}
+}
+
+void z80::op(uint8_t op) {
+	switch (op) {
+	O(0x00, nop);		O(0x01, ldbcpc);
+	O(0x02, ldBCa);		O(0x03, incbc);
+	O(0x04, incb);		O(0x05, decb);
+	O(0x06, ldb);		O(0x07, rlca);
+	O(0x08, exaf);		O(0x09, addhlbc);
+	O(0x0a, ldaBC);		O(0x0b, decbc);
+	O(0x0c, incc);		O(0x0d, decc);
+	O(0x0e, ldc);		O(0x0f, rrca);
+
+	O(0x10, djnz);		O(0x11, lddepc);
+	O(0x12, ldDEa);		O(0x13, incde);
+	O(0x14, incd);		O(0x15, decd);
+	O(0x16, ldd);		O(0x17, rla);
+	O(0x18, jr);		O(0x19, addhlde);
+	O(0x1a, ldaDE);		O(0x1b, decde);
+	O(0x1c, ince);		O(0x1d, dece);
+	O(0x1e, lde);		O(0x1f, rra);
+
+	O(0x20, jrnz);		O(0x21, ldhlpc);
+	O(0x22, ldPChl);	O(0x23, inchl);
+	O(0x24, inch);		O(0x25, dech);
+	O(0x26, ldh);		O(0x27, daa);
+	O(0x28, jrz);		O(0x29, addhlhl);
+	O(0x2a, ldhlPC);	O(0x2b, dechl);
+	O(0x2c, incl);		O(0x2d, decl);
+	O(0x2e, ldl);		O(0x2f, cpl);
+
+	O(0x30, jrnc);		O(0x31, ldsppc);
+	O(0x32, ldPCa);		O(0x33, incsp);
+	O(0x34, incHL);		O(0x35, decHL);
+	O(0x36, ldHL);		O(0x37, scf);
+	O(0x38, jrc);		O(0x39, addhlsp);
+	O(0x3a, ldaPC);		O(0x3b, decsp);
+	O(0x3c, inca);		O(0x3d, deca);
+	O(0x3e, lda);		O(0x3f, ccf);
+
+	O(0x40, ldbb);		O(0x41, ldbc);
+	O(0x42, ldbd);		O(0x43, ldbe);
+	O(0x44, ldbh);		O(0x45, ldbl);
+	O(0x46, ldbHL);		O(0x47, ldba);
+	O(0x48, ldcb);		O(0x49, ldcc);
+	O(0x4a, ldcd);		O(0x4b, ldce);
+	O(0x4c, ldch);		O(0x4d, ldcl);
+	O(0x4e, ldcHL);		O(0x4f, ldca);
+
+	O(0x50, lddb);		O(0x51, lddc);
+	O(0x52, lddd);		O(0x53, ldde);
+	O(0x54, lddh);		O(0x55, lddl);
+	O(0x56, lddHL);		O(0x57, ldda);
+	O(0x58, ldeb);		O(0x59, ldec);
+	O(0x5a, lded);		O(0x5b, ldee);
+	O(0x5c, ldeh);		O(0x5d, ldel);
+	O(0x5e, ldeHL);		O(0x5f, ldea);
+
+	O(0x60, ldhb);		O(0x61, ldhc);
+	O(0x62, ldhd);		O(0x63, ldhe);
+	O(0x64, ldhh);		O(0x65, ldhl);
+	O(0x66, ldhHL);		O(0x67, ldha);
+	O(0x68, ldlb);		O(0x69, ldlc);
+	O(0x6a, ldld);		O(0x6b, ldle);
+	O(0x6c, ldlh);		O(0x6d, ldll);
+	O(0x6e, ldlHL);		O(0x6f, ldla);
+
+	O(0x70, ldHLb);		O(0x71, ldHLc);
+	O(0x72, ldHLd);		O(0x73, ldHLe);
+	O(0x74, ldHLh);		O(0x75, ldHLl);
+	O(0x76, halt);		O(0x77, ldHLa);
+	O(0x78, ldab);		O(0x79, ldac);
+	O(0x7a, ldad);		O(0x7b, ldae);
+	O(0x7c, ldah);		O(0x7d, ldal);
+	O(0x7e, ldaHL);		O(0x7f, ldaa);
+
+	O(0x80, addab);		O(0x81, addac);
+	O(0x82, addad);		O(0x83, addae);
+	O(0x84, addah);		O(0x85, addal);
+	O(0x86, addaHL);	O(0x87, addaa);
+	O(0x88, adcab);		O(0x89, adcac);
+	O(0x8a, adcad);		O(0x8b, adcae);
+	O(0x8c, adcah);		O(0x8d, adcal);
+	O(0x8e, adcaHL);	O(0x8f, adcaa);
+
+	O(0x90, subab);		O(0x91, subac);
+	O(0x92, subad);		O(0x93, subae);
+	O(0x94, subah);		O(0x95, subal);
+	O(0x96, subaHL);	O(0x97, subaa);
+	O(0x98, sbcab);		O(0x99, sbcac);
+	O(0x9a, sbcad);		O(0x9b, sbcae);
+	O(0x9c, sbcah);		O(0x9d, sbcal);
+	O(0x9e, sbcaHL);	O(0x9f, sbcaa);
+
+	O(0xa0, andb);		O(0xa1, andc);
+	O(0xa2, andd);		O(0xa3, ande);
+	O(0xa4, andh);		O(0xa5, andl);
+	O(0xa6, andHL);		O(0xa7, anda);
+	O(0xa8, xorb);		O(0xa9, xorc);
+	O(0xaa, xord);		O(0xab, xore);
+	O(0xac, xorh);		O(0xad, xorl);
+	O(0xae, xorHL);		O(0xaf, xora);
+
+	O(0xb0, orb);		O(0xb1, orc);
+	O(0xb2, ord);		O(0xb3, ore);
+	O(0xb4, orh);		O(0xb5, orl);
+	O(0xb6, orHL);		O(0xb7, ora);
+	O(0xb8, cpb);		O(0xb9, cpc);
+	O(0xba, cpd);		O(0xbb, cpe);
+	O(0xbc, cph);		O(0xbd, cpL);
+	O(0xbe, cpHL);		O(0xbf, cpa);
+
+	O(0xc0, retnz);		O(0xc1, popbc);
+	O(0xc2, jpnz);		O(0xc3, jp);
+	O(0xc4, callnz);	O(0xc5, pushbc);
+	O(0xc6, adda);		O(0xc7, rst00);
+	O(0xc8, retz);		O(0xc9, ret);
+	O(0xca, jpz);		O(0xcb, cb);
+	O(0xcc, callz);		O(0xcd, call);
+	O(0xce, adca);		O(0xcf, rst08);
+
+	O(0xd0, retnc);		O(0xd1, popde);
+	O(0xd2, jpnc);		O(0xd3, outa);
+	O(0xd4, callnc);	O(0xd5, pushde);
+	O(0xd6, suba);		O(0xd7, rst10);
+	O(0xd8, retc);		O(0xd9, exx);
+	O(0xda, jpc);		O(0xdb, ina);
+	O(0xdc, callc);		O(0xdd, dd);
+	O(0xde, sbca);		O(0xdf, rst18);
+
+	O(0xe0, retpo);		O(0xe1, pophl);
+	O(0xe2, jppo);		O(0xe3, exSPhl);
+	O(0xe4, callpo);	O(0xe5, pushhl);
+	O(0xe6, and_);		O(0xe7, rst20);
+	O(0xe8, retpe);		O(0xe9, jphl);
+	O(0xea, jppe);		O(0xeb, exdehl);
+	O(0xec, callpe);	O(0xed, ed);
+	O(0xee, xor_);		O(0xef, rst28);
+
+	O(0xf0, retp);		O(0xf1, popaf);
+	O(0xf2, jpp);		O(0xf3, di);
+	O(0xf4, callp);		O(0xf5, pushaf);
+	O(0xf6, or_);		O(0xf7, rst30);
+	O(0xf8, retm);		O(0xf9, ldsphl);
+	O(0xfa, jpm);		O(0xfb, ei);
+	O(0xfc, callm);		O(0xfd, fd);
+	O(0xfe, cp);		O(0xff, rst38);
+	}
+}
diff --git a/z80.h b/z80.h
index c3316aa..ed95f7a 100644
--- a/z80.h
+++ b/z80.h
@@ -69,13 +69,10 @@ public:
 private:
 	void _handle_interrupt();
 
-	typedef void (z80::*OP)();
-	void _step(OP ops[]);
+	void op(uint8_t);
 
 	uint8_t _fetch_op();
 
-	inline void step() { (this->*_ops[_fetch_op()])(); }
-
 	typedef void (z80::*OP_IDX)(uint8_t);
 	void _step_idx(OP_IDX ops[]);
 
@@ -141,7 +138,6 @@ private:
 	int _irq_pending;
 	PortDevice<z80> *_ports;
 
-	OP _ops[256], _cb[256];
 	OP_IDX _ddcb[256], _fdcb[256];
 
 	uint8_t parity_table(uint8_t);
@@ -372,7 +368,11 @@ private:
 		_mc(SP, 1); _mc(SP, 1);
 	}
 
-	inline void _exch(uint16_t &a, uint16_t &b) { uint16_t t = b; b = a; a = t; }
+	inline void _exch(uint16_t &a, uint16_t &b) { 
+		uint16_t t = b; 
+		b = a; 
+		a = t; 
+	}
 
 	inline uint16_t _pop() { uint16_t w = _rw(SP); SP += 2; return w; }
 	inline void _push(uint16_t w) { SP -= 2; _sw(SP, w); }
@@ -383,24 +383,24 @@ private:
 	inline void _jr(uint8_t c) { if (c) jr(); else { _mc(PC, 3); PC++; } }
 
 	// 0x00
-	void nop() {}
-	void ldbcpc() { BC = _rwpc(); }
-	void ldBCa() { _sb(BC, A); }
-	void incbc() { BC++; _mc(IR, 1); _mc(IR, 1); }
-	void incb() { _inc(B); }
-	void decb() { _dec(B); }
-	void ldb() { B = _rb(PC++); }
-	void rlca() { flags.C = ((A & 0x80) >> 7); A = (A << 1) | flags.C; }
+	inline void nop() {}
+	inline void ldbcpc() { BC = _rwpc(); }
+	inline void ldBCa() { _sb(BC, A); }
+	inline void incbc() { BC++; _mc(IR, 1); _mc(IR, 1); }
+	inline void incb() { _inc(B); }
+	inline void decb() { _dec(B); }
+	inline void ldb() { B = _rb(PC++); }
+	inline void rlca() { flags.C = ((A & 0x80) >> 7); A = (A << 1) | flags.C; }
 
 	// 0x08
-	void exaf() { _exch(AF, AF_); }
-	void addhlbc() { _add16(HL, BC); }
-	void ldaBC() { A = _rb(BC); }
-	void decbc() { BC--; _mc(IR, 1); _mc(IR, 1); }
-	void incc() { _inc(C); }
-	void decc() { _dec(C); }
-	void ldc() { C = _rb(PC++); }
-	void rrca() {
+	inline void exaf() { _exch(AF, AF_); }
+	inline void addhlbc() { _add16(HL, BC); }
+	inline void ldaBC() { A = _rb(BC); }
+	inline void decbc() { BC--; _mc(IR, 1); _mc(IR, 1); }
+	inline void incc() { _inc(C); }
+	inline void decc() { _dec(C); }
+	inline void ldc() { C = _rb(PC++); }
+	inline void rrca() {
 		flags.H = flags.N = 0;
 		flags.C = (A & 0x01);
 		A = (A >> 1) | (flags.C << 7);
@@ -408,196 +408,196 @@ private:
 	}
 
 	// 0x10
-	void djnz() { _mc(IR, 1); _jr(--B); }
-	void lddepc() { DE = _rwpc(); }
-	void ldDEa() { _sb(DE, A); }
-	void incde() { DE++; _mc(IR, 1); _mc(IR, 1); }
-	void incd() { _inc(D); }
-	void decd() { _dec(D); }
-	void ldd() { D = _rb(PC++); }
-	void rla() {
+	inline void djnz() { _mc(IR, 1); _jr(--B); }
+	inline void lddepc() { DE = _rwpc(); }
+	inline void ldDEa() { _sb(DE, A); }
+	inline void incde() { DE++; _mc(IR, 1); _mc(IR, 1); }
+	inline void incd() { _inc(D); }
+	inline void decd() { _dec(D); }
+	inline void ldd() { D = _rb(PC++); }
+	inline void rla() {
 		uint8_t b = (A << 1) | flags.C;
 		flags.C = (A & 0x80) >> 7;
 		A = b;
 	}
 
 	// 0x18
-	void jr() {
+	inline void jr() {
 		uint8_t b = _rb(PC);
 		_mc(PC, 1); _mc(PC, 1); _mc(PC, 1); _mc(PC, 1); _mc(PC, 1);
 		PC = _ads(PC, b+1);
 	}
-	void addhlde() { _add16(HL, DE); }
-	void ldaDE() { A = _rb(DE); }
-	void decde() { DE--; _mc(IR, 1); _mc(IR, 1); }
-	void ince() { _inc(E); }
-	void dece() { _dec(E); }
-	void lde() { E = _rb(PC++); }
-	void rra() {
+	inline void addhlde() { _add16(HL, DE); }
+	inline void ldaDE() { A = _rb(DE); }
+	inline void decde() { DE--; _mc(IR, 1); _mc(IR, 1); }
+	inline void ince() { _inc(E); }
+	inline void dece() { _dec(E); }
+	inline void lde() { E = _rb(PC++); }
+	inline void rra() {
 		uint8_t b = (A >> 1) | (flags.C << 7);
 		flags.C = (A & 1);
 		A = b;
 	}
 
 	// 0x20
-	void jrnz() { _jr(!flags.Z); }
-	void ldhlpc() { HL = _rwpc(); }
-	void ldPChl() { _swPC(HL); }
-	void inchl() { HL++; _mc(IR, 1); _mc(IR, 1); }
-	void inch() { _inc(H); }
-	void dech() { _dec(H); }
-	void ldh() { H = _rb(PC++); }
-	void daa();
+	inline void jrnz() { _jr(!flags.Z); }
+	inline void ldhlpc() { HL = _rwpc(); }
+	inline void ldPChl() { _swPC(HL); }
+	inline void inchl() { HL++; _mc(IR, 1); _mc(IR, 1); }
+	inline void inch() { _inc(H); }
+	inline void dech() { _dec(H); }
+	inline void ldh() { H = _rb(PC++); }
+	inline void daa();
 
 	// 0x28
-	void jrz() { _jr(flags.Z); }
-	void addhlhl() { _add16(HL, HL); }
-	void ldhlPC() { HL = _rwPC(); }
-	void dechl() { HL--; _mc(IR, 1); _mc(IR, 1); }
-	void incl() { _inc(L); }
-	void decl() { _dec(L); }
-	void ldl() { L = _rb(PC++); }
-	void cpl() { A = ~A; flags.H = flags.N = 1; _35(A); }
+	inline void jrz() { _jr(flags.Z); }
+	inline void addhlhl() { _add16(HL, HL); }
+	inline void ldhlPC() { HL = _rwPC(); }
+	inline void dechl() { HL--; _mc(IR, 1); _mc(IR, 1); }
+	inline void incl() { _inc(L); }
+	inline void decl() { _dec(L); }
+	inline void ldl() { L = _rb(PC++); }
+	inline void cpl() { A = ~A; flags.H = flags.N = 1; _35(A); }
 
 	// 0x30
-	void jrnc() { _jr(!flags.C); }
-	void ldsppc() { SP = _rwpc(); }
-	void ldPCa() { _sb(_rw(PC), A); PC += 2; }
-	void incsp() { SP++; _mc(IR, 1); _mc(IR, 1); }
-	void incHL() { uint8_t b = _rb(HL); _mc(HL, 1); _inc(b); _sb(HL, b); }
-	void decHL() { uint8_t b = _rb(HL); _mc(HL, 1); _dec(b); _sb(HL, b); }
-	void ldHL() { _sb(HL, _rb(PC++)); }
-	void scf() { flags.C = 1; flags.N = flags.H = 0; _35(A); }
+	inline void jrnc() { _jr(!flags.C); }
+	inline void ldsppc() { SP = _rwpc(); }
+	inline void ldPCa() { _sb(_rw(PC), A); PC += 2; }
+	inline void incsp() { SP++; _mc(IR, 1); _mc(IR, 1); }
+	inline void incHL() { uint8_t b = _rb(HL); _mc(HL, 1); _inc(b); _sb(HL, b); }
+	inline void decHL() { uint8_t b = _rb(HL); _mc(HL, 1); _dec(b); _sb(HL, b); }
+	inline void ldHL() { _sb(HL, _rb(PC++)); }
+	inline void scf() { flags.C = 1; flags.N = flags.H = 0; _35(A); }
 
 	// 0x38
-	void jrc() { _jr(flags.C); }
-	void addhlsp() { _add16(HL, SP); }
-	void ldaPC() { A = _rb(_rw(PC)); PC += 2; }
-	void decsp() { SP--; _mc(IR, 1); _mc(IR, 1); }
-	void inca() { _inc(A); }
-	void deca() { _dec(A); }
-	void lda() { A = _rb(PC++); }
-	void ccf() { flags.C = !flags.C; flags.N = 0; _35(A); }
+	inline void jrc() { _jr(flags.C); }
+	inline void addhlsp() { _add16(HL, SP); }
+	inline void ldaPC() { A = _rb(_rw(PC)); PC += 2; }
+	inline void decsp() { SP--; _mc(IR, 1); _mc(IR, 1); }
+	inline void inca() { _inc(A); }
+	inline void deca() { _dec(A); }
+	inline void lda() { A = _rb(PC++); }
+	inline void ccf() { flags.C = !flags.C; flags.N = 0; _35(A); }
 
 	// 0x40
-	void ldbb() {}
-	void ldbc() { B = C; }
-	void ldbd() { B = D; }
-	void ldbe() { B = E; }
-	void ldbh() { B = H; }
-	void ldbl() { B = L; }
-	void ldbHL() { B = _rb(HL); }
-	void ldba() { B = A; }
+	inline void ldbb() {}
+	inline void ldbc() { B = C; }
+	inline void ldbd() { B = D; }
+	inline void ldbe() { B = E; }
+	inline void ldbh() { B = H; }
+	inline void ldbl() { B = L; }
+	inline void ldbHL() { B = _rb(HL); }
+	inline void ldba() { B = A; }
 
 	// 0x48
-	void ldcb() { C = B; }
-	void ldcc() {}
-	void ldcd() { C = D; }
-	void ldce() { C = E; }
-	void ldch() { C = H; }
-	void ldcl() { C = L; }
-	void ldcHL() { C = _rb(HL); }
-	void ldca() { C = A; }
+	inline void ldcb() { C = B; }
+	inline void ldcc() {}
+	inline void ldcd() { C = D; }
+	inline void ldce() { C = E; }
+	inline void ldch() { C = H; }
+	inline void ldcl() { C = L; }
+	inline void ldcHL() { C = _rb(HL); }
+	inline void ldca() { C = A; }
 
 	// 0x50
-	void lddb() { D = B; }
-	void lddc() { D = C; }
-	void lddd() {}
-	void ldde() { D = E; }
-	void lddh() { D = H; }
-	void lddl() { D = L; }
-	void lddHL() { D = _rb(HL); }
-	void ldda() { D = A; }
+	inline void lddb() { D = B; }
+	inline void lddc() { D = C; }
+	inline void lddd() {}
+	inline void ldde() { D = E; }
+	inline void lddh() { D = H; }
+	inline void lddl() { D = L; }
+	inline void lddHL() { D = _rb(HL); }
+	inline void ldda() { D = A; }
 
 	// 0x58
-	void ldeb() { E = B; }
-	void ldec() { E = C; }
-	void lded() { E = D; }
-	void ldee() {}
-	void ldeh() { E = H; }
-	void ldel() { E = L; }
-	void ldeHL() { E = _rb(HL); }
-	void ldea() { E = A; }
+	inline void ldeb() { E = B; }
+	inline void ldec() { E = C; }
+	inline void lded() { E = D; }
+	inline void ldee() {}
+	inline void ldeh() { E = H; }
+	inline void ldel() { E = L; }
+	inline void ldeHL() { E = _rb(HL); }
+	inline void ldea() { E = A; }
 
 	// 0x60
-	void ldhb() { H = B; }
-	void ldhc() { H = C; }
-	void ldhd() { H = D; }
-	void ldhe() { H = E; }
-	void ldhh() {}
-	void ldhl() { H = L; }
-	void ldhHL() { H = _rb(HL); }
-	void ldha() { H = A; }
+	inline void ldhb() { H = B; }
+	inline void ldhc() { H = C; }
+	inline void ldhd() { H = D; }
+	inline void ldhe() { H = E; }
+	inline void ldhh() {}
+	inline void ldhl() { H = L; }
+	inline void ldhHL() { H = _rb(HL); }
+	inline void ldha() { H = A; }
 
 	// 0x68
-	void ldlb() { L = B; }
-	void ldlc() { L = C; }
-	void ldld() { L = D; }
-	void ldle() { L = E; }
-	void ldlh() { L = H; }
-	void ldll() {}
-	void ldlHL() { L = _rb(HL); }
-	void ldla() { L = A; }
+	inline void ldlb() { L = B; }
+	inline void ldlc() { L = C; }
+	inline void ldld() { L = D; }
+	inline void ldle() { L = E; }
+	inline void ldlh() { L = H; }
+	inline void ldll() {}
+	inline void ldlHL() { L = _rb(HL); }
+	inline void ldla() { L = A; }
 
 	// 0x70
-	void ldHLb() { _sb(HL, B); }
-	void ldHLc() { _sb(HL, C); }
-	void ldHLd() { _sb(HL, D); }
-	void ldHLe() { _sb(HL, E); }
-	void ldHLh() { _sb(HL, H); }
-	void ldHLl() { _sb(HL, L); }
-	void halt() { _halted = true; PC--; }
-	void ldHLa() { _sb(HL, A); }
+	inline void ldHLb() { _sb(HL, B); }
+	inline void ldHLc() { _sb(HL, C); }
+	inline void ldHLd() { _sb(HL, D); }
+	inline void ldHLe() { _sb(HL, E); }
+	inline void ldHLh() { _sb(HL, H); }
+	inline void ldHLl() { _sb(HL, L); }
+	inline void halt() { _halted = true; PC--; }
+	inline void ldHLa() { _sb(HL, A); }
 
 	// 0x78
-	void ldab() { A = B; }
-	void ldac() { A = C; }
-	void ldad() { A = D; }
-	void ldae() { A = E; }
-	void ldah() { A = H; }
-	void ldal() { A = L; }
-	void ldaHL() { A = _rb(HL); }
-	void ldaa() {}
+	inline void ldab() { A = B; }
+	inline void ldac() { A = C; }
+	inline void ldad() { A = D; }
+	inline void ldae() { A = E; }
+	inline void ldah() { A = H; }
+	inline void ldal() { A = L; }
+	inline void ldaHL() { A = _rb(HL); }
+	inline void ldaa() {}
 
 	// 0x80
-	void addab() { _add(B); }
-	void addac() { _add(C); }
-	void addad() { _add(D); }
-	void addae() { _add(E); }
-	void addah() { _add(H); }
-	void addal() { _add(L); }
-	void addaHL() { _add(_rb(HL)); }
-	void addaa() { _add(A); }
+	inline void addab() { _add(B); }
+	inline void addac() { _add(C); }
+	inline void addad() { _add(D); }
+	inline void addae() { _add(E); }
+	inline void addah() { _add(H); }
+	inline void addal() { _add(L); }
+	inline void addaHL() { _add(_rb(HL)); }
+	inline void addaa() { _add(A); }
 
 	// 0x88
-	void adcab() { _adc(B); }
-	void adcac() { _adc(C); }
-	void adcad() { _adc(D); }
-	void adcae() { _adc(E); }
-	void adcah() { _adc(H); }
-	void adcal() { _adc(L); }
-	void adcaHL() { _adc(_rb(HL)); }
-	void adcaa() { _adc(A); }
+	inline void adcab() { _adc(B); }
+	inline void adcac() { _adc(C); }
+	inline void adcad() { _adc(D); }
+	inline void adcae() { _adc(E); }
+	inline void adcah() { _adc(H); }
+	inline void adcal() { _adc(L); }
+	inline void adcaHL() { _adc(_rb(HL)); }
+	inline void adcaa() { _adc(A); }
 
 	// 0x90
-	void subab() { _sub(B); }
-	void subac() { _sub(C); }
-	void subad() { _sub(D); }
-	void subae() { _sub(E); }
-	void subah() { _sub(H); }
-	void subal() { _sub(L); }
-	void subaHL() { _sub(_rb(HL)); }
-	void subaa() { _sub(A); }
+	inline void subab() { _sub(B); }
+	inline void subac() { _sub(C); }
+	inline void subad() { _sub(D); }
+	inline void subae() { _sub(E); }
+	inline void subah() { _sub(H); }
+	inline void subal() { _sub(L); }
+	inline void subaHL() { _sub(_rb(HL)); }
+	inline void subaa() { _sub(A); }
 
 	// 0x98
-	void sbcab() { _sbc(B); }
-	void sbcac() { _sbc(C); }
-	void sbcad() { _sbc(D); }
-	void sbcae() { _sbc(E); }
-	void sbcah() { _sbc(H); }
-	void sbcal() { _sbc(L); }
-	void sbcaHL() { _sbc(_rb(HL)); }
-	void sbcaa() { _sbc(A); }
+	inline void sbcab() { _sbc(B); }
+	inline void sbcac() { _sbc(C); }
+	inline void sbcad() { _sbc(D); }
+	inline void sbcae() { _sbc(E); }
+	inline void sbcah() { _sbc(H); }
+	inline void sbcal() { _sbc(L); }
+	inline void sbcaHL() { _sbc(_rb(HL)); }
+	inline void sbcaa() { _sbc(A); }
 
 	// 0xa0
 	inline void _and(uint8_t b) {
@@ -606,14 +606,14 @@ private:
 		flags.C = flags.N = 0;
 		flags.H = 1;
 	}
-	void andb() { _and(B); }
-	void andc() { _and(C); }
-	void andd() { _and(D); }
-	void ande() { _and(E); }
-	void andh() { _and(H); }
-	void andl() { _and(L); }
-	void andHL() { _and(_rb(HL)); }
-	void anda() { _and(A); }
+	inline void andb() { _and(B); }
+	inline void andc() { _and(C); }
+	inline void andd() { _and(D); }
+	inline void ande() { _and(E); }
+	inline void andh() { _and(H); }
+	inline void andl() { _and(L); }
+	inline void andHL() { _and(_rb(HL)); }
+	inline void anda() { _and(A); }
 
 	// 0xa8
 	inline void _xor(uint8_t b) {
@@ -621,14 +621,14 @@ private:
 		_szp35(A);
 		flags.C = flags.N = flags.H = 0;
 	}
-	void xorb() { _xor(B); }
-	void xorc() { _xor(C); }
-	void xord() { _xor(D); }
-	void xore() { _xor(E); }
-	void xorh() { _xor(H); }
-	void xorl() { _xor(L); }
-	void xorHL() { _xor(_rb(HL)); }
-	void xora() { _xor(A); }
+	inline void xorb() { _xor(B); }
+	inline void xorc() { _xor(C); }
+	inline void xord() { _xor(D); }
+	inline void xore() { _xor(E); }
+	inline void xorh() { _xor(H); }
+	inline void xorl() { _xor(L); }
+	inline void xorHL() { _xor(_rb(HL)); }
+	inline void xora() { _xor(A); }
 
 	// 0xb0
 	inline void _or(uint8_t b) {
@@ -636,14 +636,14 @@ private:
 		_szp35(A);
 		flags.C = flags.N = flags.H = 0;
 	}
-	void orb() { _or(B); }
-	void orc() { _or(C); }
-	void ord() { _or(D); }
-	void ore() { _or(E); }
-	void orh() { _or(H); }
-	void orl() { _or(L); }
-	void orHL() { _or(_rb(HL)); }
-	void ora() { _or(A); }
+	inline void orb() { _or(B); }
+	inline void orc() { _or(C); }
+	inline void ord() { _or(D); }
+	inline void ore() { _or(E); }
+	inline void orh() { _or(H); }
+	inline void orl() { _or(L); }
+	inline void orHL() { _or(_rb(HL)); }
+	inline void ora() { _or(A); }
 
 	// 0xb8
 	inline void _cmp(uint8_t b) {
@@ -652,70 +652,70 @@ private:
 		_35(b);
 		A = a;
 	}
-	void cpb() { _cmp(B); }
-	void cpc() { _cmp(C); }
-	void cpd() { _cmp(D); }
-	void cpe() { _cmp(E); }
-	void cph() { _cmp(H); }
-	void cpL() { _cmp(L); }
-	void cpHL() { _cmp(_rb(HL)); }
-	void cpa() { _cmp(A); }
+	inline void cpb() { _cmp(B); }
+	inline void cpc() { _cmp(C); }
+	inline void cpd() { _cmp(D); }
+	inline void cpe() { _cmp(E); }
+	inline void cph() { _cmp(H); }
+	inline void cpL() { _cmp(L); }
+	inline void cpHL() { _cmp(_rb(HL)); }
+	inline void cpa() { _cmp(A); }
 
 	// 0xc0
-	void retnz() { _ret(!flags.Z); }
-	void popbc() { BC = _pop(); }
-	void jpnz() { _jmp(!flags.Z); }
-	void jp() { PC = _rw(PC); }
-	void callnz() { _call(!flags.Z); }
-	void pushbc() { _mc(IR, 1); _push(BC); }
-	void adda() { _add(_rb(PC++)); }
-	void rst00() { _mc(IR, 11); _push(PC); PC = 0x00; }
+	inline void retnz() { _ret(!flags.Z); }
+	inline void popbc() { BC = _pop(); }
+	inline void jpnz() { _jmp(!flags.Z); }
+	inline void jp() { PC = _rw(PC); }
+	inline void callnz() { _call(!flags.Z); }
+	inline void pushbc() { _mc(IR, 1); _push(BC); }
+	inline void adda() { _add(_rb(PC++)); }
+	inline void rst00() { _mc(IR, 11); _push(PC); PC = 0x00; }
 
 	// 0xc8
-	void retz() { _ret(flags.Z); }
-	void ret() { PC = _pop(); }
-	void jpz() { _jmp(flags.Z); }
-	void cb() { (this->*_cb[_fetch_op()])(); }
-	void callz() { _call(flags.Z); }
-	void call() { uint16_t pc = _rw(PC); _mc(PC+1, 1); _push(PC+2); PC = pc; }
-	void adca() { _adc(_rb(PC++)); }
-	void rst08() { _mc(IR, 11); _push(PC); PC = 0x08; }
+	inline void retz() { _ret(flags.Z); }
+	inline void ret() { PC = _pop(); }
+	inline void jpz() { _jmp(flags.Z); }
+	inline void cb();
+	inline void callz() { _call(flags.Z); }
+	inline void call() { uint16_t pc = _rw(PC); _mc(PC+1, 1); _push(PC+2); PC = pc; }
+	inline void adca() { _adc(_rb(PC++)); }
+	inline void rst08() { _mc(IR, 11); _push(PC); PC = 0x08; }
 
 	// 0xd0
-	void retnc() { _ret(!flags.C); }
-	void popde() { DE = _pop(); }
-	void jpnc() { _jmp(!flags.C); }
-	void outa() {
+	inline void retnc() { _ret(!flags.C); }
+	inline void popde() { DE = _pop(); }
+	inline void jpnc() { _jmp(!flags.C); }
+	inline void outa() {
 		uint16_t p = _rb(PC++) + (A << 8);
 		_ports->out(p, A, this);
 	}
-	void callnc() { _call(!flags.C); }
-	void pushde() { _mc(IR, 1); _push(DE); }
-	void suba() { _sub(_rb(PC++)); }
-	void rst10() { _mc(IR, 11); _push(PC); PC = 0x10; }
+	inline void callnc() { _call(!flags.C); }
+	inline void pushde() { _mc(IR, 1); _push(DE); }
+	inline void suba() { _sub(_rb(PC++)); }
+	inline void rst10() { _mc(IR, 11); _push(PC); PC = 0x10; }
 
 	// 0xd8
-	void retc() { _ret(flags.C); }
-	void exx() { _exch(BC, BC_); _exch(DE, DE_); _exch(HL, HL_); }
-	void jpc() { _jmp(flags.C); }
-	void ina() {
+	inline void retc() { _ret(flags.C); }
+	inline void exx() { _exch(BC, BC_); _exch(DE, DE_); _exch(HL, HL_); }
+	inline void jpc() { _jmp(flags.C); }
+	inline void ina() {
 		uint16_t p = _rb(PC++) + (A << 8);
 		A = _ports->in(p, this);
 	}
-	void callc() { _call(flags.C); }
-	void dd() { _ddfd(IX, IXL, IXH, _ddcb); }
-	void sbca() { _sbc(_rb(PC++)); }
-	void rst18() { _mc(IR, 11); _push(PC); PC = 0x18; }
+	inline void callc() { _call(flags.C); }
+	inline void dd() { _ddfd(IX, IXL, IXH, _ddcb); }
+	inline void sbca() { _sbc(_rb(PC++)); }
+	inline void rst18() { _mc(IR, 11); _push(PC); PC = 0x18; }
 
 	// 0xe0
-	void retpo() { _ret(!flags.P); }
-	void pophl() { HL = _pop(); }
-	void jppo() { _jmp(!flags.P); }
-	void exSPhl() { _exSP(HL); }
-	void callpo() { _call(!flags.P); }
-	void pushhl() { _mc(IR, 1); _push(HL); }
-	void and_() { _and(_rb(PC++)); }
-	void rst20() { _mc(IR, 11); _push(PC); PC = 0x20; }
+	inline void retpo() { _ret(!flags.P); }
+	inline void pophl() { HL = _pop(); }
+	inline void jppo() { _jmp(!flags.P); }
+	inline void exSPhl() { _exSP(HL); }
+	inline void callpo() { _call(!flags.P); }
+	inline void pushhl() { _mc(IR, 1); _push(HL); }
+	inline void and_() { _and(_rb(PC++)); }
+	inline void rst20() { _mc(IR, 11); _push(PC); PC = 0x20; }
 
 	// 0xe8
 	inline uint8_t _inr(uint16_t p) {
@@ -728,34 +728,34 @@ private:
 		_ports->out(p, b, this);
 	}
 
-	void retpe() { _ret(flags.P); }
-	void jphl() { PC = HL; }
-	void jppe() { _jmp(flags.P); }
-	void exdehl() { _exch(DE, HL); }
-	void callpe() { _call(flags.P); }
-	void ed();
-	void xor_() { _xor(_rb(PC++)); }
-	void rst28() { _mc(IR, 11); _push(PC); PC = 0x28; }
+	inline void retpe() { _ret(flags.P); }
+	inline void jphl() { PC = HL; }
+	inline void jppe() { _jmp(flags.P); }
+	inline void exdehl() { _exch(DE, HL); }
+	inline void callpe() { _call(flags.P); }
+	inline void ed();
+	inline void xor_() { _xor(_rb(PC++)); }
+	inline void rst28() { _mc(IR, 11); _push(PC); PC = 0x28; }
 
 	// 0xf0
-	void retp() { _ret(!flags.S); }
-	void popaf() { AF = _pop(); }
-	void jpp() { _jmp(!flags.S); }
-	void di() { _iff1 = _iff2 = false; }
-	void callp() { _call(!flags.S); }
-	void pushaf() { _mc(IR, 1); _push(AF); }
-	void or_() { _or(_rb(PC++)); }
-	void rst30() { _mc(IR, 11); _push(PC); PC = 0x30; }
+	inline void retp() { _ret(!flags.S); }
+	inline void popaf() { AF = _pop(); }
+	inline void jpp() { _jmp(!flags.S); }
+	inline void di() { _iff1 = _iff2 = false; }
+	inline void callp() { _call(!flags.S); }
+	inline void pushaf() { _mc(IR, 1); _push(AF); }
+	inline void or_() { _or(_rb(PC++)); }
+	inline void rst30() { _mc(IR, 11); _push(PC); PC = 0x30; }
 
 	// 0xf8
-	void retm() { _ret(flags.S); }
-	void ldsphl() { _mc(IR, 1); _mc(IR, 1); SP = HL; }
-	void jpm() { _jmp(flags.S); }
-	void ei() { _iff1 = _iff2 = true; }
-	void callm() { _call(flags.S); }
-	void fd() { _ddfd(IY, IYL, IYH, _fdcb); }
-	void cp() { _cmp(_rb(PC++)); }
-	void rst38() { _mc(IR, 11); _push(PC); PC = 0x38; }
+	inline void retm() { _ret(flags.S); }
+	inline void ldsphl() { _mc(IR, 1); _mc(IR, 1); SP = HL; }
+	inline void jpm() { _jmp(flags.S); }
+	inline void ei() { _iff1 = _iff2 = true; }
+	inline void callm() { _call(flags.S); }
+	inline void fd() { _ddfd(IY, IYL, IYH, _fdcb); }
+	inline void cp() { _cmp(_rb(PC++)); }
+	inline void rst38() { _mc(IR, 11); _push(PC); PC = 0x38; }
 
 	// 0xCB extended instructions
 
@@ -767,14 +767,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void rlcB() { _rlc(B); }
-	void rlcC() { _rlc(C); }
-	void rlcD() { _rlc(D); }
-	void rlcE() { _rlc(E); }
-	void rlcH() { _rlc(H); }
-	void rlcL() { _rlc(L); }
-	void rlcHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rlc(b); _sb(HL, b); }
-	void rlcA() { _rlc(A); }
+	inline void rlcB() { _rlc(B); }
+	inline void rlcC() { _rlc(C); }
+	inline void rlcD() { _rlc(D); }
+	inline void rlcE() { _rlc(E); }
+	inline void rlcH() { _rlc(H); }
+	inline void rlcL() { _rlc(L); }
+	inline void rlcHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rlc(b); _sb(HL, b); }
+	inline void rlcA() { _rlc(A); }
 
 	// 0x08
 	inline void _rrc(uint8_t &b) {
@@ -784,14 +784,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void rrcB() { _rrc(B); }
-	void rrcC() { _rrc(C); }
-	void rrcD() { _rrc(D); }
-	void rrcE() { _rrc(E); }
-	void rrcH() { _rrc(H); }
-	void rrcL() { _rrc(L); }
-	void rrcHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rrc(b); _sb(HL, b); }
-	void rrcA() { _rrc(A); }
+	inline void rrcB() { _rrc(B); }
+	inline void rrcC() { _rrc(C); }
+	inline void rrcD() { _rrc(D); }
+	inline void rrcE() { _rrc(E); }
+	inline void rrcH() { _rrc(H); }
+	inline void rrcL() { _rrc(L); }
+	inline void rrcHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rrc(b); _sb(HL, b); }
+	inline void rrcA() { _rrc(A); }
 
 	// 0x10
 	inline void _rl(uint8_t &b) {
@@ -802,14 +802,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void rlB() { _rl(B); }
-	void rlC() { _rl(C); }
-	void rlD() { _rl(D); }
-	void rlE() { _rl(E); }
-	void rlH() { _rl(H); }
-	void rlL() { _rl(L); }
-	void rlHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rl(b); _sb(HL, b); }
-	void rlA() { _rl(A); }
+	inline void rlB() { _rl(B); }
+	inline void rlC() { _rl(C); }
+	inline void rlD() { _rl(D); }
+	inline void rlE() { _rl(E); }
+	inline void rlH() { _rl(H); }
+	inline void rlL() { _rl(L); }
+	inline void rlHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rl(b); _sb(HL, b); }
+	inline void rlA() { _rl(A); }
 
 	// 0x18
 	inline void _rr(uint8_t &b) {
@@ -821,14 +821,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void rrB() { _rr(B); }
-	void rrC() { _rr(C); }
-	void rrD() { _rr(D); }
-	void rrE() { _rr(E); }
-	void rrH() { _rr(H); }
-	void rrL() { _rr(L); }
-	void rrHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rr(b); _sb(HL, b); }
-	void rrA() { _rr(A); }
+	inline void rrB() { _rr(B); }
+	inline void rrC() { _rr(C); }
+	inline void rrD() { _rr(D); }
+	inline void rrE() { _rr(E); }
+	inline void rrH() { _rr(H); }
+	inline void rrL() { _rr(L); }
+	inline void rrHL() { uint8_t b = _rb(HL); _mc(HL, 1); _rr(b); _sb(HL, b); }
+	inline void rrA() { _rr(A); }
 
 	// 0x20
 	inline void _sla(uint8_t &b) {
@@ -838,14 +838,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void slab() { _sla(B); }
-	void slac() { _sla(C); }
-	void slad() { _sla(D); }
-	void slae() { _sla(E); }
-	void slah() { _sla(H); }
-	void slal() { _sla(L); }
-	void slaHL() { uint8_t b = _rb(HL); _mc(HL, 1); _sla(b); _sb(HL, b); }
-	void slaa() { _sla(A); }
+	inline void slab() { _sla(B); }
+	inline void slac() { _sla(C); }
+	inline void slad() { _sla(D); }
+	inline void slae() { _sla(E); }
+	inline void slah() { _sla(H); }
+	inline void slal() { _sla(L); }
+	inline void slaHL() { uint8_t b = _rb(HL); _mc(HL, 1); _sla(b); _sb(HL, b); }
+	inline void slaa() { _sla(A); }
 
 	// 0x28
 	inline void _sra(uint8_t &b) {
@@ -855,14 +855,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void srab() { _sra(B); }
-	void srac() { _sra(C); }
-	void srad() { _sra(D); }
-	void srae() { _sra(E); }
-	void srah() { _sra(H); }
-	void sral() { _sra(L); }
-	void sraHL() { uint8_t b = _rb(HL); _mc(HL, 1); _sra(b); _sb(HL, b); }
-	void sraa() { _sra(A); }
+	inline void srab() { _sra(B); }
+	inline void srac() { _sra(C); }
+	inline void srad() { _sra(D); }
+	inline void srae() { _sra(E); }
+	inline void srah() { _sra(H); }
+	inline void sral() { _sra(L); }
+	inline void sraHL() { uint8_t b = _rb(HL); _mc(HL, 1); _sra(b); _sb(HL, b); }
+	inline void sraa() { _sra(A); }
 
 	// 0x30
 	inline void _sll(uint8_t &b) {
@@ -872,14 +872,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void sllb() { _sll(B); }
-	void sllc() { _sll(C); }
-	void slld() { _sll(D); }
-	void slle() { _sll(E); }
-	void sllh() { _sll(H); }
-	void slll() { _sll(L); }
-	void sllHL() { uint8_t b = _rb(HL); _mc(HL, 1); _sll(b); _sb(HL, b); }
-	void slla() { _sll(A); }
+	inline void sllb() { _sll(B); }
+	inline void sllc() { _sll(C); }
+	inline void slld() { _sll(D); }
+	inline void slle() { _sll(E); }
+	inline void sllh() { _sll(H); }
+	inline void slll() { _sll(L); }
+	inline void sllHL() { uint8_t b = _rb(HL); _mc(HL, 1); _sll(b); _sb(HL, b); }
+	inline void slla() { _sll(A); }
 
 	// 0x38
 	inline void _srl(uint8_t &b) {
@@ -889,14 +889,14 @@ private:
 		flags.N = flags.H = 0;
 	}
 
-	void srlb() { _srl(B); }
-	void srlc() { _srl(C); }
-	void srld() { _srl(D); }
-	void srle() { _srl(E); }
-	void srlh() { _srl(H); }
-	void srll() { _srl(L); }
-	void srlHL() { uint8_t b = _rb(HL); _mc(HL, 1); _srl(b); _sb(HL, b); }
-	void srla() { _srl(A); }
+	inline void srlb() { _srl(B); }
+	inline void srlc() { _srl(C); }
+	inline void srld() { _srl(D); }
+	inline void srle() { _srl(E); }
+	inline void srlh() { _srl(H); }
+	inline void srll() { _srl(L); }
+	inline void srlHL() { uint8_t b = _rb(HL); _mc(HL, 1); _srl(b); _sb(HL, b); }
+	inline void srla() { _srl(A); }
 
 	// 0x40
 	inline void _bit(int i, uint8_t b) {
@@ -911,84 +911,84 @@ private:
 		uint8_t b = _rb(HL); _mc(HL, 1); _bit(i, b);
 	}
 
-	void bit0b() { _bit(0, B); }
-	void bit0c() { _bit(0, C); }
-	void bit0d() { _bit(0, D); }
-	void bit0e() { _bit(0, E); }
-	void bit0h() { _bit(0, H); }
-	void bit0l() { _bit(0, L); }
-	void bit0HL() { _bitHL(0); }
-	void bit0a() { _bit(0, A); }
+	inline void bit0b() { _bit(0, B); }
+	inline void bit0c() { _bit(0, C); }
+	inline void bit0d() { _bit(0, D); }
+	inline void bit0e() { _bit(0, E); }
+	inline void bit0h() { _bit(0, H); }
+	inline void bit0l() { _bit(0, L); }
+	inline void bit0HL() { _bitHL(0); }
+	inline void bit0a() { _bit(0, A); }
 
 	// 0x48
-	void bit1b() { _bit(1, B); }
-	void bit1c() { _bit(1, C); }
-	void bit1d() { _bit(1, D); }
-	void bit1e() { _bit(1, E); }
-	void bit1h() { _bit(1, H); }
-	void bit1l() { _bit(1, L); }
-	void bit1HL() { _bitHL(1); }
-	void bit1a() { _bit(1, A); }
+	inline void bit1b() { _bit(1, B); }
+	inline void bit1c() { _bit(1, C); }
+	inline void bit1d() { _bit(1, D); }
+	inline void bit1e() { _bit(1, E); }
+	inline void bit1h() { _bit(1, H); }
+	inline void bit1l() { _bit(1, L); }
+	inline void bit1HL() { _bitHL(1); }
+	inline void bit1a() { _bit(1, A); }
 
 	// 0x50
-	void bit2b() { _bit(2, B); }
-	void bit2c() { _bit(2, C); }
-	void bit2d() { _bit(2, D); }
-	void bit2e() { _bit(2, E); }
-	void bit2h() { _bit(2, H); }
-	void bit2l() { _bit(2, L); }
-	void bit2HL() { _bitHL(2); }
-	void bit2a() { _bit(2, A); }
+	inline void bit2b() { _bit(2, B); }
+	inline void bit2c() { _bit(2, C); }
+	inline void bit2d() { _bit(2, D); }
+	inline void bit2e() { _bit(2, E); }
+	inline void bit2h() { _bit(2, H); }
+	inline void bit2l() { _bit(2, L); }
+	inline void bit2HL() { _bitHL(2); }
+	inline void bit2a() { _bit(2, A); }
 
 	// 0x58
-	void bit3b() { _bit(3, B); }
-	void bit3c() { _bit(3, C); }
-	void bit3d() { _bit(3, D); }
-	void bit3e() { _bit(3, E); }
-	void bit3h() { _bit(3, H); }
-	void bit3l() { _bit(3, L); }
-	void bit3HL() { _bitHL(3); }
-	void bit3a() { _bit(3, A); }
+	inline void bit3b() { _bit(3, B); }
+	inline void bit3c() { _bit(3, C); }
+	inline void bit3d() { _bit(3, D); }
+	inline void bit3e() { _bit(3, E); }
+	inline void bit3h() { _bit(3, H); }
+	inline void bit3l() { _bit(3, L); }
+	inline void bit3HL() { _bitHL(3); }
+	inline void bit3a() { _bit(3, A); }
 
 	// 0x60
-	void bit4b() { _bit(4, B); }
-	void bit4c() { _bit(4, C); }
-	void bit4d() { _bit(4, D); }
-	void bit4e() { _bit(4, E); }
-	void bit4h() { _bit(4, H); }
-	void bit4l() { _bit(4, L); }
-	void bit4HL() { _bitHL(4); }
-	void bit4a() { _bit(4, A); }
+	inline void bit4b() { _bit(4, B); }
+	inline void bit4c() { _bit(4, C); }
+	inline void bit4d() { _bit(4, D); }
+	inline void bit4e() { _bit(4, E); }
+	inline void bit4h() { _bit(4, H); }
+	inline void bit4l() { _bit(4, L); }
+	inline void bit4HL() { _bitHL(4); }
+	inline void bit4a() { _bit(4, A); }
 
 	// 0x68
-	void bit5b() { _bit(5, B); }
-	void bit5c() { _bit(5, C); }
-	void bit5d() { _bit(5, D); }
-	void bit5e() { _bit(5, E); }
-	void bit5h() { _bit(5, H); }
-	void bit5l() { _bit(5, L); }
-	void bit5HL() { _bitHL(5); }
-	void bit5a() { _bit(5, A); }
+	inline void bit5b() { _bit(5, B); }
+	inline void bit5c() { _bit(5, C); }
+	inline void bit5d() { _bit(5, D); }
+	inline void bit5e() { _bit(5, E); }
+	inline void bit5h() { _bit(5, H); }
+	inline void bit5l() { _bit(5, L); }
+	inline void bit5HL() { _bitHL(5); }
+	inline void bit5a() { _bit(5, A); }
 
 	// 0x70
-	void bit6b() { _bit(6, B); }
-	void bit6c() { _bit(6, C); }
-	void bit6d() { _bit(6, D); }
-	void bit6e() { _bit(6, E); }
-	void bit6h() { _bit(6, H); }
-	void bit6l() { _bit(6, L); }
-	void bit6HL() { _bitHL(6); }
-	void bit6a() { _bit(6, A); }
+	inline void bit6b() { _bit(6, B); }
+	inline void bit6c() { _bit(6, C); }
+	inline void bit6d() { _bit(6, D); }
+	inline void bit6e() { _bit(6, E); }
+	inline void bit6h() { _bit(6, H); }
+	inline void bit6l() { _bit(6, L); }
+	inline void bit6HL() { _bitHL(6); }
+	inline void bit6a() { _bit(6, A); }
 
 	// 0x78
-	void bit7b() { _bit(7, B); }
-	void bit7c() { _bit(7, C); }
-	void bit7d() { _bit(7, D); }
-	void bit7e() { _bit(7, E); }
-	void bit7h() { _bit(7, H); }
-	void bit7l() { _bit(7, L); }
-	void bit7HL() { _bitHL(7); }
-	void bit7a() { _bit(7, A); }
+	inline void bit7b() { _bit(7, B); }
+	inline void bit7c() { _bit(7, C); }
+	inline void bit7d() { _bit(7, D); }
+	inline void bit7e() { _bit(7, E); }
+	inline void bit7h() { _bit(7, H); }
+	inline void bit7l() { _bit(7, L); }
+	inline void bit7HL() { _bitHL(7); }
+	inline void bit7a() { _bit(7, A); }
 
 	// 0x80
 	inline void _resHL(uint8_t m) {
@@ -997,84 +997,84 @@ private:
 		_sb(HL, b & m);
 	}
 	
-	void res0b() { B &= 0xfe; }
-	void res0c() { C &= 0xfe; }
-	void res0d() { D &= 0xfe; }
-	void res0e() { E &= 0xfe; }
-	void res0h() { H &= 0xfe; }
-	void res0l() { L &= 0xfe; }
-	void res0HL() { _resHL(0xfe); }
-	void res0a() { A &= 0xfe; }
+	inline void res0b() { B &= 0xfe; }
+	inline void res0c() { C &= 0xfe; }
+	inline void res0d() { D &= 0xfe; }
+	inline void res0e() { E &= 0xfe; }
+	inline void res0h() { H &= 0xfe; }
+	inline void res0l() { L &= 0xfe; }
+	inline void res0HL() { _resHL(0xfe); }
+	inline void res0a() { A &= 0xfe; }
 
 	// 0x88
-	void res1b() { B &= 0xfd; }
-	void res1c() { C &= 0xfd; }
-	void res1d() { D &= 0xfd; }
-	void res1e() { E &= 0xfd; }
-	void res1h() { H &= 0xfd; }
-	void res1l() { L &= 0xfd; }
-	void res1HL() { _resHL(0xfd); }
-	void res1a() { A &= 0xfd; }
+	inline void res1b() { B &= 0xfd; }
+	inline void res1c() { C &= 0xfd; }
+	inline void res1d() { D &= 0xfd; }
+	inline void res1e() { E &= 0xfd; }
+	inline void res1h() { H &= 0xfd; }
+	inline void res1l() { L &= 0xfd; }
+	inline void res1HL() { _resHL(0xfd); }
+	inline void res1a() { A &= 0xfd; }
 
 	// 0x90
-	void res2b() { B &= 0xfb; }
-	void res2c() { C &= 0xfb; }
-	void res2d() { D &= 0xfb; }
-	void res2e() { E &= 0xfb; }
-	void res2h() { H &= 0xfb; }
-	void res2l() { L &= 0xfb; }
-	void res2HL() { _resHL(0xfb); }
-	void res2a() { A &= 0xfb; }
+	inline void res2b() { B &= 0xfb; }
+	inline void res2c() { C &= 0xfb; }
+	inline void res2d() { D &= 0xfb; }
+	inline void res2e() { E &= 0xfb; }
+	inline void res2h() { H &= 0xfb; }
+	inline void res2l() { L &= 0xfb; }
+	inline void res2HL() { _resHL(0xfb); }
+	inline void res2a() { A &= 0xfb; }
 
 	// 0x98
-	void res3b() { B &= 0xf7; }
-	void res3c() { C &= 0xf7; }
-	void res3d() { D &= 0xf7; }
-	void res3e() { E &= 0xf7; }
-	void res3h() { H &= 0xf7; }
-	void res3l() { L &= 0xf7; }
-	void res3HL() { _resHL(0xf7); }
-	void res3a() { A &= 0xf7; }
+	inline void res3b() { B &= 0xf7; }
+	inline void res3c() { C &= 0xf7; }
+	inline void res3d() { D &= 0xf7; }
+	inline void res3e() { E &= 0xf7; }
+	inline void res3h() { H &= 0xf7; }
+	inline void res3l() { L &= 0xf7; }
+	inline void res3HL() { _resHL(0xf7); }
+	inline void res3a() { A &= 0xf7; }
 
 	// 0xa0
-	void res4b() { B &= 0xef; }
-	void res4c() { C &= 0xef; }
-	void res4d() { D &= 0xef; }
-	void res4e() { E &= 0xef; }
-	void res4h() { H &= 0xef; }
-	void res4l() { L &= 0xef; }
-	void res4HL() { _resHL(0xef); }
-	void res4a() { A &= 0xef; }
+	inline void res4b() { B &= 0xef; }
+	inline void res4c() { C &= 0xef; }
+	inline void res4d() { D &= 0xef; }
+	inline void res4e() { E &= 0xef; }
+	inline void res4h() { H &= 0xef; }
+	inline void res4l() { L &= 0xef; }
+	inline void res4HL() { _resHL(0xef); }
+	inline void res4a() { A &= 0xef; }
 
 	// 0xa8
-	void res5b() { B &= 0xdf; }
-	void res5c() { C &= 0xdf; }
-	void res5d() { D &= 0xdf; }
-	void res5e() { E &= 0xdf; }
-	void res5h() { H &= 0xdf; }
-	void res5l() { L &= 0xdf; }
-	void res5HL() { _resHL(0xdf); }
-	void res5a() { A &= 0xdf; }
+	inline void res5b() { B &= 0xdf; }
+	inline void res5c() { C &= 0xdf; }
+	inline void res5d() { D &= 0xdf; }
+	inline void res5e() { E &= 0xdf; }
+	inline void res5h() { H &= 0xdf; }
+	inline void res5l() { L &= 0xdf; }
+	inline void res5HL() { _resHL(0xdf); }
+	inline void res5a() { A &= 0xdf; }
 
 	// 0xb0
-	void res6b() { B &= 0xbf; }
-	void res6c() { C &= 0xbf; }
-	void res6d() { D &= 0xbf; }
-	void res6e() { E &= 0xbf; }
-	void res6h() { H &= 0xbf; }
-	void res6l() { L &= 0xbf; }
-	void res6HL() { _resHL(0xbf); }
-	void res6a() { A &= 0xbf; }
+	inline void res6b() { B &= 0xbf; }
+	inline void res6c() { C &= 0xbf; }
+	inline void res6d() { D &= 0xbf; }
+	inline void res6e() { E &= 0xbf; }
+	inline void res6h() { H &= 0xbf; }
+	inline void res6l() { L &= 0xbf; }
+	inline void res6HL() { _resHL(0xbf); }
+	inline void res6a() { A &= 0xbf; }
 
 	// 0xb8
-	void res7b() { B &= 0x7f; }
-	void res7c() { C &= 0x7f; }
-	void res7d() { D &= 0x7f; }
-	void res7e() { E &= 0x7f; }
-	void res7h() { H &= 0x7f; }
-	void res7l() { L &= 0x7f; }
-	void res7HL() { _resHL(0x7f); }
-	void res7a() { A &= 0x7f; }
+	inline void res7b() { B &= 0x7f; }
+	inline void res7c() { C &= 0x7f; }
+	inline void res7d() { D &= 0x7f; }
+	inline void res7e() { E &= 0x7f; }
+	inline void res7h() { H &= 0x7f; }
+	inline void res7l() { L &= 0x7f; }
+	inline void res7HL() { _resHL(0x7f); }
+	inline void res7a() { A &= 0x7f; }
 
 	// 0xc0
 	inline void _setHL(uint8_t m) {
@@ -1083,84 +1083,84 @@ private:
 		_sb(HL, b | m);
 	}
 
-	void set0b() { B |= 0x01; }
-	void set0c() { C |= 0x01; }
-	void set0d() { D |= 0x01; }
-	void set0e() { E |= 0x01; }
-	void set0h() { H |= 0x01; }
-	void set0l() { L |= 0x01; }
-	void set0HL() { _setHL(0x01); }
-	void set0a() { A |= 0x01; }
+	inline void set0b() { B |= 0x01; }
+	inline void set0c() { C |= 0x01; }
+	inline void set0d() { D |= 0x01; }
+	inline void set0e() { E |= 0x01; }
+	inline void set0h() { H |= 0x01; }
+	inline void set0l() { L |= 0x01; }
+	inline void set0HL() { _setHL(0x01); }
+	inline void set0a() { A |= 0x01; }
 
 	// 0xc8
-	void set1b() { B |= 0x02; }
-	void set1c() { C |= 0x02; }
-	void set1d() { D |= 0x02; }
-	void set1e() { E |= 0x02; }
-	void set1h() { H |= 0x02; }
-	void set1l() { L |= 0x02; }
-	void set1HL() { _setHL(0x02); }
-	void set1a() { A |= 0x02; }
+	inline void set1b() { B |= 0x02; }
+	inline void set1c() { C |= 0x02; }
+	inline void set1d() { D |= 0x02; }
+	inline void set1e() { E |= 0x02; }
+	inline void set1h() { H |= 0x02; }
+	inline void set1l() { L |= 0x02; }
+	inline void set1HL() { _setHL(0x02); }
+	inline void set1a() { A |= 0x02; }
 
 	// 0xd0
-	void set2b() { B |= 0x04; }
-	void set2c() { C |= 0x04; }
-	void set2d() { D |= 0x04; }
-	void set2e() { E |= 0x04; }
-	void set2h() { H |= 0x04; }
-	void set2l() { L |= 0x04; }
-	void set2HL() { _setHL(0x04); }
-	void set2a() { A |= 0x04; }
+	inline void set2b() { B |= 0x04; }
+	inline void set2c() { C |= 0x04; }
+	inline void set2d() { D |= 0x04; }
+	inline void set2e() { E |= 0x04; }
+	inline void set2h() { H |= 0x04; }
+	inline void set2l() { L |= 0x04; }
+	inline void set2HL() { _setHL(0x04); }
+	inline void set2a() { A |= 0x04; }
 
 	// 0xd8
-	void set3b() { B |= 0x08; }
-	void set3c() { C |= 0x08; }
-	void set3d() { D |= 0x08; }
-	void set3e() { E |= 0x08; }
-	void set3h() { H |= 0x08; }
-	void set3l() { L |= 0x08; }
-	void set3HL() { _setHL(0x08); }
-	void set3a() { A |= 0x08; }
+	inline void set3b() { B |= 0x08; }
+	inline void set3c() { C |= 0x08; }
+	inline void set3d() { D |= 0x08; }
+	inline void set3e() { E |= 0x08; }
+	inline void set3h() { H |= 0x08; }
+	inline void set3l() { L |= 0x08; }
+	inline void set3HL() { _setHL(0x08); }
+	inline void set3a() { A |= 0x08; }
 
 	// 0xe0
-	void set4b() { B |= 0x10; }
-	void set4c() { C |= 0x10; }
-	void set4d() { D |= 0x10; }
-	void set4e() { E |= 0x10; }
-	void set4h() { H |= 0x10; }
-	void set4l() { L |= 0x10; }
-	void set4HL() { _setHL(0x10); }
-	void set4a() { A |= 0x10; }
+	inline void set4b() { B |= 0x10; }
+	inline void set4c() { C |= 0x10; }
+	inline void set4d() { D |= 0x10; }
+	inline void set4e() { E |= 0x10; }
+	inline void set4h() { H |= 0x10; }
+	inline void set4l() { L |= 0x10; }
+	inline void set4HL() { _setHL(0x10); }
+	inline void set4a() { A |= 0x10; }
 
 	// 0xe8
-	void set5b() { B |= 0x20; }
-	void set5c() { C |= 0x20; }
-	void set5d() { D |= 0x20; }
-	void set5e() { E |= 0x20; }
-	void set5h() { H |= 0x20; }
-	void set5l() { L |= 0x20; }
-	void set5HL() { _setHL(0x20); }
-	void set5a() { A |= 0x20; }
+	inline void set5b() { B |= 0x20; }
+	inline void set5c() { C |= 0x20; }
+	inline void set5d() { D |= 0x20; }
+	inline void set5e() { E |= 0x20; }
+	inline void set5h() { H |= 0x20; }
+	inline void set5l() { L |= 0x20; }
+	inline void set5HL() { _setHL(0x20); }
+	inline void set5a() { A |= 0x20; }
 
 	// 0xf0
-	void set6b() { B |= 0x40; }
-	void set6c() { C |= 0x40; }
-	void set6d() { D |= 0x40; }
-	void set6e() { E |= 0x40; }
-	void set6h() { H |= 0x40; }
-	void set6l() { L |= 0x40; }
-	void set6HL() { _setHL(0x40); }
-	void set6a() { A |= 0x40; }
+	inline void set6b() { B |= 0x40; }
+	inline void set6c() { C |= 0x40; }
+	inline void set6d() { D |= 0x40; }
+	inline void set6e() { E |= 0x40; }
+	inline void set6h() { H |= 0x40; }
+	inline void set6l() { L |= 0x40; }
+	inline void set6HL() { _setHL(0x40); }
+	inline void set6a() { A |= 0x40; }
 
 	// 0xf8
-	void set7b() { B |= 0x80; }
-	void set7c() { C |= 0x80; }
-	void set7d() { D |= 0x80; }
-	void set7e() { E |= 0x80; }
-	void set7h() { H |= 0x80; }
-	void set7l() { L |= 0x80; }
-	void set7HL() { _setHL(0x80); }
-	void set7a() { A |= 0x80; }
+	inline void set7b() { B |= 0x80; }
+	inline void set7c() { C |= 0x80; }
+	inline void set7d() { D |= 0x80; }
+	inline void set7e() { E |= 0x80; }
+	inline void set7h() { H |= 0x80; }
+	inline void set7l() { L |= 0x80; }
+	inline void set7HL() { _setHL(0x80); }
+	inline void set7a() { A |= 0x80; }
 
 	inline void _bitI(int i, uint16_t a) {
 		uint8_t b = _rb(a);