diff --git a/cpu/ppc/poweropcodes.cpp b/cpu/ppc/poweropcodes.cpp
index 44b2135..6e2b3c1 100644
--- a/cpu/ppc/poweropcodes.cpp
+++ b/cpu/ppc/poweropcodes.cpp
@@ -42,7 +42,7 @@ inline void power_setsoov(uint32_t a, uint32_t b, uint32_t d) {
     }
 }
 
-void power_abs() {
+void dppc_interpreter::power_abs() {
     ppc_grab_regsda();
     if (ppc_result_a == 0x80000000) {
         ppc_result_d = ppc_result_a;
@@ -59,7 +59,7 @@ void power_abs() {
     ppc_store_result_regd();
 }
 
-void power_clcs() {
+void dppc_interpreter::power_clcs() {
     ppc_grab_regsda();
     switch (reg_a) {
     case 12:
@@ -80,7 +80,7 @@ void power_clcs() {
     ppc_store_result_regd();
 }
 
-void power_div() {
+void dppc_interpreter::power_div() {
     ppc_grab_regsdab();
     ppc_result_d           = (ppc_result_a | ppc_state.spr[SPR::MQ]) / ppc_result_b;
     ppc_state.spr[SPR::MQ] = (ppc_result_a | ppc_state.spr[SPR::MQ]) % ppc_result_b;
@@ -93,7 +93,7 @@ void power_div() {
     ppc_store_result_regd();
 }
 
-void power_divs() {
+void dppc_interpreter::power_divs() {
     ppc_grab_regsdab();
     ppc_result_d           = ppc_result_a / ppc_result_b;
     ppc_state.spr[SPR::MQ] = (ppc_result_a % ppc_result_b);
@@ -106,7 +106,7 @@ void power_divs() {
     ppc_store_result_regd();
 }
 
-void power_doz() {
+void dppc_interpreter::power_doz() {
     ppc_grab_regsdab();
     if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) {
         ppc_result_d = 0;
@@ -120,7 +120,7 @@ void power_doz() {
     ppc_store_result_rega();
 }
 
-void power_dozi() {
+void dppc_interpreter::power_dozi() {
     ppc_grab_regsdab();
     if (((int32_t)ppc_result_a) > simm) {
         ppc_result_d = 0;
@@ -130,7 +130,7 @@ void power_dozi() {
     ppc_store_result_rega();
 }
 
-void power_lscbx() {
+void dppc_interpreter::power_lscbx() {
     ppc_grab_regsdab();
     uint32_t bytes_copied = 0;
     bool match_found      = false;
@@ -191,7 +191,7 @@ void power_lscbx() {
     ppc_store_result_regd();
 }
 
-void power_maskg() {
+void dppc_interpreter::power_maskg() {
     ppc_grab_regssab();
     uint32_t mask_start  = ppc_result_d & 31;
     uint32_t mask_end    = ppc_result_b & 31;
@@ -218,7 +218,7 @@ void power_maskg() {
     ppc_store_result_rega();
 }
 
-void power_maskir() {
+void dppc_interpreter::power_maskir() {
     ppc_grab_regssab();
     uint32_t mask_insert = ppc_result_a;
     uint32_t insert_rot  = 0x80000000;
@@ -238,7 +238,7 @@ void power_maskir() {
     ppc_store_result_rega();
 }
 
-void power_mul() {
+void dppc_interpreter::power_mul() {
     ppc_grab_regsdab();
     uint64_t product;
 
@@ -252,7 +252,7 @@ void power_mul() {
     ppc_store_result_regd();
 }
 
-void power_nabs() {
+void dppc_interpreter::power_nabs() {
     ppc_grab_regsda();
     ppc_result_d = (0x80000000 | ppc_result_a);
 
@@ -262,7 +262,7 @@ void power_nabs() {
     ppc_store_result_regd();
 }
 
-void power_rlmi() {
+void dppc_interpreter::power_rlmi() {
     ppc_grab_regssab();
     unsigned rot_mb      = (ppc_cur_instruction >> 6) & 31;
     unsigned rot_me      = (ppc_cur_instruction >> 1) & 31;
@@ -287,7 +287,7 @@ void power_rlmi() {
     ppc_store_result_rega();
 }
 
-void power_rrib() {
+void dppc_interpreter::power_rrib() {
     ppc_grab_regssab();
 
     if (ppc_result_d & 0x80000000) {
@@ -302,7 +302,7 @@ void power_rrib() {
     ppc_store_result_rega();
 }
 
-void power_sle() {
+void dppc_interpreter::power_sle() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     uint32_t rot_amt     = ppc_result_b & 31;
@@ -319,7 +319,7 @@ void power_sle() {
     ppc_store_result_rega();
 }
 
-void power_sleq() {
+void dppc_interpreter::power_sleq() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     uint32_t rot_amt     = ppc_result_b & 31;
@@ -345,7 +345,7 @@ void power_sleq() {
     ppc_store_result_rega();
 }
 
-void power_sliq() {
+void dppc_interpreter::power_sliq() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     unsigned rot_sh      = (ppc_cur_instruction >> 11) & 31;
@@ -371,7 +371,7 @@ void power_sliq() {
     ppc_store_result_rega();
 }
 
-void power_slliq() {
+void dppc_interpreter::power_slliq() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     unsigned rot_sh      = (ppc_cur_instruction >> 11) & 31;
@@ -397,23 +397,23 @@ void power_slliq() {
     ppc_store_result_rega();
 }
 
-void power_sllq() {
+void dppc_interpreter::power_sllq() {
     LOG_F(WARNING, "OOPS! Placeholder for sllq!!! \n");
 }
 
-void power_slq() {
+void dppc_interpreter::power_slq() {
     LOG_F(WARNING, "OOPS! Placeholder for slq!!! \n");
 }
 
-void power_sraiq() {
+void dppc_interpreter::power_sraiq() {
     LOG_F(WARNING, "OOPS! Placeholder for sraiq!!! \n");
 }
 
-void power_sraq() {
+void dppc_interpreter::power_sraq() {
     LOG_F(WARNING, "OOPS! Placeholder for sraq!!! \n");
 }
 
-void power_sre() {
+void dppc_interpreter::power_sre() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     uint32_t rot_amt     = ppc_result_b & 31;
@@ -428,11 +428,11 @@ void power_sre() {
     ppc_store_result_rega();
 }
 
-void power_srea() {
+void dppc_interpreter::power_srea() {
     LOG_F(WARNING, "OOPS! Placeholder for srea!!! \n");
 }
 
-void power_sreq() {
+void dppc_interpreter::power_sreq() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     unsigned rot_sh      = ppc_result_b & 31;
@@ -458,7 +458,7 @@ void power_sreq() {
     ppc_store_result_rega();
 }
 
-void power_sriq() {
+void dppc_interpreter::power_sriq() {
     ppc_grab_regssa();
     uint32_t insert_mask = 0;
     unsigned rot_sh      = (ppc_cur_instruction >> 11) & 31;
@@ -484,14 +484,14 @@ void power_sriq() {
     ppc_store_result_rega();
 }
 
-void power_srliq() {
+void dppc_interpreter::power_srliq() {
     LOG_F(WARNING, "OOPS! Placeholder for slriq!!! \n");
 }
 
-void power_srlq() {
+void dppc_interpreter::power_srlq() {
     LOG_F(WARNING, "OOPS! Placeholder for slrq!!! \n");
 }
 
-void power_srq() {
+void dppc_interpreter::power_srq() {
     LOG_F(WARNING, "OOPS! Placeholder for srq!!! \n");
 }
\ No newline at end of file
diff --git a/cpu/ppc/ppcemu.h b/cpu/ppc/ppcemu.h
index 64de5bd..628e164 100644
--- a/cpu/ppc/ppcemu.h
+++ b/cpu/ppc/ppcemu.h
@@ -303,6 +303,7 @@ void ppc_fp_changecrf1();
 extern MemCtrlBase* mem_ctrl_instance;
 
 // The functions used by the PowerPC processor
+namespace dppc_interpreter {
 extern void ppc_bcctr();
 extern void ppc_bcctrl();
 extern void ppc_bclr();
@@ -541,12 +542,7 @@ extern void power_sriq();
 extern void power_srliq();
 extern void power_srlq();
 extern void power_srq();
-
-// Gekko instructions
-extern void ppc_psq_l();
-extern void ppc_psq_lu();
-extern void ppc_psq_st();
-extern void ppc_psq_stu();
+}    // namespace dppc_interpreter
 
 // AltiVec instructions
 
diff --git a/cpu/ppc/ppcexec.cpp b/cpu/ppc/ppcexec.cpp
index 582d202..807bc01 100644
--- a/cpu/ppc/ppcexec.cpp
+++ b/cpu/ppc/ppcexec.cpp
@@ -35,6 +35,7 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 #define NEW_TBR_UPDATE_ALGO
 
 using namespace std;
+using namespace dppc_interpreter;
 
 MemCtrlBase* mem_ctrl_instance = 0;
 
@@ -72,17 +73,17 @@ uint8_t  tbr_factor;        /* cycles_count to TBR freq ratio in 2^x units */
 
 /** Primary opcode (bits 0...5) lookup table. */
 static PPCOpcode OpcodeGrabber[] = {
-    ppc_illegalop, ppc_illegalop, ppc_illegalop, ppc_twi,     ppc_opcode4,   ppc_illegalop,
-    ppc_illegalop, ppc_mulli,     ppc_subfic,    power_dozi,  ppc_cmpli,     ppc_cmpi,
-    ppc_addic,     ppc_addicdot,  ppc_addi,      ppc_addis,   ppc_opcode16,  ppc_sc,
-    ppc_opcode18,  ppc_opcode19,  ppc_rlwimi,    ppc_rlwinm,  power_rlmi,    ppc_rlwnm,
-    ppc_ori,       ppc_oris,      ppc_xori,      ppc_xoris,   ppc_andidot,   ppc_andisdot,
-    ppc_illegalop, ppc_opcode31,  ppc_lwz,       ppc_lwzu,    ppc_lbz,       ppc_lbzu,
-    ppc_stw,       ppc_stwu,      ppc_stb,       ppc_stbu,    ppc_lhz,       ppc_lhzu,
-    ppc_lha,       ppc_lhau,      ppc_sth,       ppc_sthu,    ppc_lmw,       ppc_stmw,
-    ppc_lfs,       ppc_lfsu,      ppc_lfd,       ppc_lfdu,    ppc_stfs,      ppc_stfsu,
-    ppc_stfd,      ppc_stfdu,     ppc_psq_l,     ppc_psq_lu,  ppc_illegalop, ppc_illegalop,
-    ppc_psq_st,    ppc_psq_stu,   ppc_illegalop, ppc_opcode63};
+    ppc_illegalop, ppc_illegalop, ppc_illegalop, ppc_twi,       ppc_opcode4,   ppc_illegalop,
+    ppc_illegalop, ppc_mulli,     ppc_subfic,    power_dozi,    ppc_cmpli,     ppc_cmpi,
+    ppc_addic,     ppc_addicdot,  ppc_addi,      ppc_addis,     ppc_opcode16,  ppc_sc,
+    ppc_opcode18,  ppc_opcode19,  ppc_rlwimi,    ppc_rlwinm,    power_rlmi,    ppc_rlwnm,
+    ppc_ori,       ppc_oris,      ppc_xori,      ppc_xoris,     ppc_andidot,   ppc_andisdot,
+    ppc_illegalop, ppc_opcode31,  ppc_lwz,       ppc_lwzu,      ppc_lbz,       ppc_lbzu,
+    ppc_stw,       ppc_stwu,      ppc_stb,       ppc_stbu,      ppc_lhz,       ppc_lhzu,
+    ppc_lha,       ppc_lhau,      ppc_sth,       ppc_sthu,      ppc_lmw,       ppc_stmw,
+    ppc_lfs,       ppc_lfsu,      ppc_lfd,       ppc_lfdu,      ppc_stfs,      ppc_stfsu,
+    ppc_stfd,      ppc_stfdu,     ppc_illegalop, ppc_illegalop, ppc_illegalop, ppc_illegalop,
+    ppc_illegalop, ppc_illegalop, ppc_illegalop, ppc_opcode63};
 
 /** Lookup tables for branch instructions. */
 static PPCOpcode SubOpcode16Grabber[] = {ppc_bc, ppc_bcl, ppc_bca, ppc_bcla};
@@ -577,29 +578,29 @@ void initialize_ppc_opcode_tables() {
     SubOpcode31Grabber[978]  = ppc_tlbld;
     SubOpcode31Grabber[1010] = ppc_tlbli;
 
-    SubOpcode63Grabber[18] = ppc_fdivs;
-    SubOpcode63Grabber[20] = ppc_fsubs;
-    SubOpcode63Grabber[22] = ppc_fsqrts;
-    SubOpcode63Grabber[24] = ppc_fres;
+    SubOpcode59Grabber[18] = ppc_fdivs;
+    SubOpcode59Grabber[20] = ppc_fsubs;
+    SubOpcode59Grabber[22] = ppc_fsqrts;
+    SubOpcode59Grabber[24] = ppc_fres;
 
     for (int i = 25; i < 1024; i += 32) {
-        SubOpcode63Grabber[i] = ppc_fmults;
+        SubOpcode59Grabber[i] = ppc_fmults;
     }
 
     for (int i = 28; i < 1024; i += 32) {
-        SubOpcode63Grabber[i] = ppc_fmsubs;
+        SubOpcode59Grabber[i] = ppc_fmsubs;
     }
 
     for (int i = 29; i < 1024; i += 32) {
-        SubOpcode63Grabber[i] = ppc_fmadds;
+        SubOpcode59Grabber[i] = ppc_fmadds;
     }
 
     for (int i = 30; i < 1024; i += 32) {
-        SubOpcode63Grabber[i] = ppc_fnmsubs;
+        SubOpcode59Grabber[i] = ppc_fnmsubs;
     }
 
     for (int i = 31; i < 1024; i += 32) {
-        SubOpcode63Grabber[i] = ppc_fnmadds;
+        SubOpcode59Grabber[i] = ppc_fnmadds;
     }
 
     SubOpcode63Grabber[0]   = ppc_fcmpu;
diff --git a/cpu/ppc/ppcfpopcodes.cpp b/cpu/ppc/ppcfpopcodes.cpp
index b0bfa3b..b3eb088 100644
--- a/cpu/ppc/ppcfpopcodes.cpp
+++ b/cpu/ppc/ppcfpopcodes.cpp
@@ -371,7 +371,7 @@ void ppc_changecrf1() {
 }
 
 // Floating Point Arithmetic
-void ppc_fadd() {
+void dppc_interpreter::ppc_fadd() {
     ppc_grab_regsfpdab(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, false, 58)) {
@@ -383,7 +383,7 @@ void ppc_fadd() {
         ppc_changecrf1();
 }
 
-void ppc_fsub() {
+void dppc_interpreter::ppc_fsub() {
     ppc_grab_regsfpdab(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, false, 56)) {
@@ -395,7 +395,7 @@ void ppc_fsub() {
         ppc_changecrf1();
 }
 
-void ppc_fdiv() {
+void dppc_interpreter::ppc_fdiv() {
     ppc_grab_regsfpdab(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, false, 36)) {
@@ -407,7 +407,7 @@ void ppc_fdiv() {
         ppc_changecrf1();
 }
 
-void ppc_fmult() {
+void dppc_interpreter::ppc_fmult() {
     ppc_grab_regsfpdac(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, false, 50)) {
@@ -419,7 +419,7 @@ void ppc_fmult() {
         ppc_changecrf1();
 }
 
-void ppc_fmadd() {
+void dppc_interpreter::ppc_fmadd() {
     ppc_grab_regsfpdabc(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_c, false, 50)) {
@@ -435,7 +435,7 @@ void ppc_fmadd() {
         ppc_changecrf1();
 }
 
-void ppc_fmsub() {
+void dppc_interpreter::ppc_fmsub() {
     ppc_grab_regsfpdabc(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_c, false, 50)) {
@@ -451,7 +451,7 @@ void ppc_fmsub() {
         ppc_changecrf1();
 }
 
-void ppc_fnmadd() {
+void dppc_interpreter::ppc_fnmadd() {
     ppc_grab_regsfpdabc(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_c, false, 50)) {
@@ -468,7 +468,7 @@ void ppc_fnmadd() {
         ppc_changecrf1();
 }
 
-void ppc_fnmsub() {
+void dppc_interpreter::ppc_fnmsub() {
     ppc_grab_regsfpdabc(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_c, false, 50)) {
@@ -485,7 +485,7 @@ void ppc_fnmsub() {
         ppc_changecrf1();
 }
 
-void ppc_fadds() {
+void dppc_interpreter::ppc_fadds() {
     ppc_grab_regsfpdab(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, true, 58)) {
@@ -498,7 +498,7 @@ void ppc_fadds() {
         ppc_changecrf1();
 }
 
-void ppc_fsubs() {
+void dppc_interpreter::ppc_fsubs() {
     ppc_grab_regsfpdab(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, true, 56)) {
@@ -511,7 +511,7 @@ void ppc_fsubs() {
         ppc_changecrf1();
 }
 
-void ppc_fmults() {
+void dppc_interpreter::ppc_fmults() {
     ppc_grab_regsfpdac(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, true, 50)) {
@@ -524,7 +524,7 @@ void ppc_fmults() {
         ppc_changecrf1();
 }
 
-void ppc_fdivs() {
+void dppc_interpreter::ppc_fdivs() {
     ppc_grab_regsfpdab(false);
 
     if (!ppc_confirm_inf_nan(reg_a, reg_b, true, 36)) {
@@ -537,7 +537,7 @@ void ppc_fdivs() {
         ppc_changecrf1();
 }
 
-void ppc_fmadds() {
+void dppc_interpreter::ppc_fmadds() {
     ppc_grab_regsfpdabc(false);
 
     float intermediate;
@@ -556,7 +556,7 @@ void ppc_fmadds() {
         ppc_changecrf1();
 }
 
-void ppc_fmsubs() {
+void dppc_interpreter::ppc_fmsubs() {
     ppc_grab_regsfpdabc(false);
 
     float intermediate;
@@ -575,7 +575,7 @@ void ppc_fmsubs() {
         ppc_changecrf1();
 }
 
-void ppc_fnmadds() {
+void dppc_interpreter::ppc_fnmadds() {
     ppc_grab_regsfpdabc(false);
 
     float intermediate;
@@ -596,7 +596,7 @@ void ppc_fnmadds() {
         ppc_changecrf1();
 }
 
-void ppc_fnmsubs() {
+void dppc_interpreter::ppc_fnmsubs() {
     ppc_grab_regsfpdabc(false);
 
     float intermediate;
@@ -617,7 +617,7 @@ void ppc_fnmsubs() {
         ppc_changecrf1();
 }
 
-void ppc_fabs() {
+void dppc_interpreter::ppc_fabs() {
     ppc_grab_regsfpdb(false);
 
     ppc_dblresult64_d = abs(ppc_dblresult64_b);
@@ -628,7 +628,7 @@ void ppc_fabs() {
         ppc_changecrf1();
 }
 
-void ppc_fnabs() {
+void dppc_interpreter::ppc_fnabs() {
     ppc_grab_regsfpdb(false);
 
     ppc_dblresult64_d = abs(ppc_dblresult64_b);
@@ -640,7 +640,7 @@ void ppc_fnabs() {
         ppc_changecrf1();
 }
 
-void ppc_fneg() {
+void dppc_interpreter::ppc_fneg() {
     ppc_grab_regsfpdb(false);
 
     ppc_dblresult64_d = -ppc_dblresult64_d;
@@ -651,7 +651,7 @@ void ppc_fneg() {
         ppc_changecrf1();
 }
 
-void ppc_fsel() {
+void dppc_interpreter::ppc_fsel() {
     ppc_grab_regsfpdabc(false);
 
     if (ppc_dblresult64_a >= 0.0) {
@@ -666,7 +666,7 @@ void ppc_fsel() {
         ppc_changecrf1();
 }
 
-void ppc_fsqrt() {
+void dppc_interpreter::ppc_fsqrt() {
     ppc_grab_regsfpdb(false);
     ppc_dblresult64_d = std::sqrt(ppc_dblresult64_b);
     ppc_store_dfpresult(false);
@@ -675,7 +675,7 @@ void ppc_fsqrt() {
         ppc_changecrf1();
 }
 
-void ppc_fsqrts() {
+void dppc_interpreter::ppc_fsqrts() {
     ppc_grab_regsfpdb(true);
     uint32_t test = (uint32_t)ppc_result64_b;
     test += 127 << 23;
@@ -688,7 +688,7 @@ void ppc_fsqrts() {
         ppc_changecrf1();
 }
 
-void ppc_frsqrte() {
+void dppc_interpreter::ppc_frsqrte() {
     ppc_grab_regsfpdb(false);
     double testd2 = (double)ppc_result64_b;
     for (int i = 0; i < 10; i++) {
@@ -702,7 +702,7 @@ void ppc_frsqrte() {
         ppc_changecrf1();
 }
 
-void ppc_frsp() {
+void dppc_interpreter::ppc_frsp() {
     ppc_grab_regsfpdb(false);
     double testd2     = (double)ppc_result64_b;
     float testf2      = (float)testd2;
@@ -713,7 +713,7 @@ void ppc_frsp() {
         ppc_changecrf1();
 }
 
-void ppc_fres() {
+void dppc_interpreter::ppc_fres() {
     ppc_grab_regsfpdb(false);
     float testf2      = (float)ppc_dblresult64_b;
     testf2            = 1 / testf2;
@@ -724,7 +724,7 @@ void ppc_fres() {
         ppc_changecrf1();
 }
 
-void ppc_fctiw() {
+void dppc_interpreter::ppc_fctiw() {
     ppc_grab_regsfpdb(false);
 
     switch (ppc_state.fpscr & 0x3) {
@@ -744,7 +744,7 @@ void ppc_fctiw() {
         ppc_changecrf1();
 }
 
-void ppc_fctiwz() {
+void dppc_interpreter::ppc_fctiwz() {
     ppc_grab_regsfpdb(false);
     ppc_result64_d = round_to_zero(ppc_dblresult64_b);
 
@@ -756,7 +756,7 @@ void ppc_fctiwz() {
 
 // Floating Point Store and Load
 
-void ppc_lfs() {
+void dppc_interpreter::ppc_lfs() {
     ppc_grab_regsfpdia(true);
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -765,7 +765,7 @@ void ppc_lfs() {
 }
 
 
-void ppc_lfsu() {
+void dppc_interpreter::ppc_lfsu() {
     ppc_grab_regsfpdia(true);
     if (reg_a == 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -779,14 +779,14 @@ void ppc_lfsu() {
     }
 }
 
-void ppc_lfsx() {
+void dppc_interpreter::ppc_lfsx() {
     ppc_grab_regsfpdiab(true);
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b;
     ppc_result64_d        = mem_grab_dword(ppc_effective_address);
     ppc_store_dfpresult(true);
 }
 
-void ppc_lfsux() {
+void dppc_interpreter::ppc_lfsux() {
     ppc_grab_regsfpdiab(true);
     if (reg_a == 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -799,7 +799,7 @@ void ppc_lfsux() {
     }
 }
 
-void ppc_lfd() {
+void dppc_interpreter::ppc_lfd() {
     ppc_grab_regsfpdia(true);
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -807,7 +807,7 @@ void ppc_lfd() {
     ppc_store_dfpresult(true);
 }
 
-void ppc_lfdu() {
+void dppc_interpreter::ppc_lfdu() {
     ppc_grab_regsfpdia(true);
     if (reg_a == 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -821,14 +821,14 @@ void ppc_lfdu() {
     }
 }
 
-void ppc_lfdx() {
+void dppc_interpreter::ppc_lfdx() {
     ppc_grab_regsfpdia(true);
     ppc_effective_address += (reg_a > 0) ? ppc_result_a + ppc_result_b : ppc_result_b;
     ppc_result64_d = mem_grab_qword(ppc_effective_address);
     ppc_store_dfpresult(true);
 }
 
-void ppc_lfdux() {
+void dppc_interpreter::ppc_lfdux() {
     ppc_grab_regsfpdiab(true);
     if (reg_a == 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -841,14 +841,14 @@ void ppc_lfdux() {
     }
 }
 
-void ppc_stfs() {
+void dppc_interpreter::ppc_stfs() {
     ppc_grab_regsfpsia(true);
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
     mem_write_dword(ppc_effective_address, uint32_t(ppc_state.fpr[reg_s].int64_r));
 }
 
-void ppc_stfsu() {
+void dppc_interpreter::ppc_stfsu() {
     ppc_grab_regsfpsia(true);
     if (reg_a == 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -861,13 +861,13 @@ void ppc_stfsu() {
     }
 }
 
-void ppc_stfsx() {
+void dppc_interpreter::ppc_stfsx() {
     ppc_grab_regsfpsiab(true);
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b;
     mem_write_dword(ppc_effective_address, uint32_t(ppc_state.fpr[reg_s].int64_r));
 }
 
-void ppc_stfsux() {
+void dppc_interpreter::ppc_stfsux() {
     ppc_grab_regsfpsiab(true);
     if (reg_a == 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -879,14 +879,14 @@ void ppc_stfsux() {
     }
 }
 
-void ppc_stfd() {
+void dppc_interpreter::ppc_stfd() {
     ppc_grab_regsfpsia(true);
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
     mem_write_qword(ppc_effective_address, ppc_state.fpr[reg_s].int64_r);
 }
 
-void ppc_stfdu() {
+void dppc_interpreter::ppc_stfdu() {
     ppc_grab_regsfpsia(true);
     if (reg_a == 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -899,13 +899,13 @@ void ppc_stfdu() {
     }
 }
 
-void ppc_stfdx() {
+void dppc_interpreter::ppc_stfdx() {
     ppc_grab_regsfpsiab(true);
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b;
     mem_write_qword(ppc_effective_address, ppc_state.fpr[reg_s].int64_r);
 }
 
-void ppc_stfdux() {
+void dppc_interpreter::ppc_stfdux() {
     ppc_grab_regsfpsiab(true);
     if (reg_a == 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -917,7 +917,7 @@ void ppc_stfdux() {
     }
 }
 
-void ppc_stfiwx() {
+void dppc_interpreter::ppc_stfiwx() {
     ppc_grab_regsfpsiab(true);
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b;
     mem_write_dword(ppc_effective_address, (uint32_t)(ppc_state.fpr[reg_s].int64_r));
@@ -925,14 +925,14 @@ void ppc_stfiwx() {
 
 // Floating Point Register Transfer
 
-void ppc_fmr() {
+void dppc_interpreter::ppc_fmr() {
     ppc_grab_regsfpdb(true);
     ppc_state.fpr[reg_d] = ppc_state.fpr[reg_b];
     ppc_store_dfpresult(true);
 }
 
 
-void ppc_mffs() {
+void dppc_interpreter::ppc_mffs() {
     ppc_grab_regsda();
     uint64_t fpstore1 = ppc_state.fpr[reg_d].int64_r & 0xFFFFFFFF00000000;
     uint64_t fpstore2 = ppc_state.fpscr & 0x00000000FFFFFFFF;
@@ -940,7 +940,7 @@ void ppc_mffs() {
     fp_save_uint64(fpstore1);
 }
 
-void ppc_mffsdot() {
+void dppc_interpreter::ppc_mffsdot() {
     ppc_grab_regsda();
     uint64_t fpstore1 = ppc_state.fpr[reg_d].int64_r & 0xFFFFFFFF00000000;
     uint64_t fpstore2 = ppc_state.fpscr & 0x00000000FFFFFFFF;
@@ -949,7 +949,7 @@ void ppc_mffsdot() {
     ppc_fp_changecrf1();
 }
 
-void ppc_mtfsf() {
+void dppc_interpreter::ppc_mtfsf() {
     reg_b            = (ppc_cur_instruction >> 11) & 31;
     uint32_t fm_mask = (ppc_cur_instruction >> 17) & 255;
     crm += ((fm_mask & 1) == 1) ? 0xF0000000 : 0x00000000;
@@ -964,7 +964,7 @@ void ppc_mtfsf() {
     ppc_state.fpscr      = (quickfprval & crm) | (quickfprval & ~(crm));
 }
 
-void ppc_mtfsfdot() {
+void dppc_interpreter::ppc_mtfsfdot() {
     reg_b            = (ppc_cur_instruction >> 11) & 31;
     uint32_t fm_mask = (ppc_cur_instruction >> 17) & 255;
     crm += ((fm_mask & 1) == 1) ? 0xF0000000 : 0x00000000;
@@ -980,7 +980,7 @@ void ppc_mtfsfdot() {
     ppc_fp_changecrf1();
 }
 
-void ppc_mtfsfi() {
+void dppc_interpreter::ppc_mtfsfi() {
     ppc_result_b    = (ppc_cur_instruction >> 11) & 15;
     crf_d           = (ppc_cur_instruction >> 23) & 7;
     crf_d           = crf_d << 2;
@@ -988,7 +988,7 @@ void ppc_mtfsfi() {
         ((ppc_state.spr[SPR::XER] & 0xF0000000UL) >> crf_d);
 }
 
-void ppc_mtfsfidot() {
+void dppc_interpreter::ppc_mtfsfidot() {
     ppc_result_b    = (ppc_cur_instruction >> 11) & 15;
     crf_d           = (ppc_cur_instruction >> 23) & 7;
     crf_d           = crf_d << 2;
@@ -997,14 +997,14 @@ void ppc_mtfsfidot() {
     ppc_fp_changecrf1();
 }
 
-void ppc_mtfsb0() {
+void dppc_interpreter::ppc_mtfsb0() {
     crf_d = (ppc_cur_instruction >> 21) & 0x31;
     if ((crf_d == 0) || (crf_d > 2)) {
         ppc_state.fpscr &= ~(1 << (31 - crf_d));
     }
 }
 
-void ppc_mtfsb0dot() {
+void dppc_interpreter::ppc_mtfsb0dot() {
     crf_d = (ppc_cur_instruction >> 21) & 0x31;
     if ((crf_d == 0) || (crf_d > 2)) {
         ppc_state.fpscr &= ~(1 << crf_d);
@@ -1012,14 +1012,14 @@ void ppc_mtfsb0dot() {
     ppc_fp_changecrf1();
 }
 
-void ppc_mtfsb1() {
+void dppc_interpreter::ppc_mtfsb1() {
     crf_d = (ppc_cur_instruction >> 21) & 0x31;
     if ((crf_d == 0) || (crf_d > 2)) {
         ppc_state.fpscr |= (1 << crf_d);
     }
 }
 
-void ppc_mtfsb1dot() {
+void dppc_interpreter::ppc_mtfsb1dot() {
     crf_d = ~(ppc_cur_instruction >> 21) & 0x31;
     if ((crf_d == 0) || (crf_d > 2)) {
         ppc_state.fpscr |= (1 << crf_d);
@@ -1027,7 +1027,7 @@ void ppc_mtfsb1dot() {
     ppc_fp_changecrf1();
 }
 
-void ppc_mcrfs() {
+void dppc_interpreter::ppc_mcrfs() {
     crf_d        = (ppc_cur_instruction >> 23) & 7;
     crf_d        = crf_d << 2;
     crf_s        = (ppc_cur_instruction >> 18) & 7;
@@ -1038,7 +1038,7 @@ void ppc_mcrfs() {
 
 // Floating Point Comparisons
 
-void ppc_fcmpo() {
+void dppc_interpreter::ppc_fcmpo() {
     ppc_grab_regsfpsab(true);
 
     crf_d = (ppc_cur_instruction >> 23) & 7;
@@ -1072,7 +1072,7 @@ void ppc_fcmpo() {
     }
 }
 
-void ppc_fcmpu() {
+void dppc_interpreter::ppc_fcmpu() {
     ppc_grab_regsfpsab(true);
 
     crf_d = (ppc_cur_instruction >> 23) & 7;
diff --git a/cpu/ppc/ppcgekkoopcodes.cpp b/cpu/ppc/ppcgekkoopcodes.cpp
deleted file mode 100644
index a5d9e1e..0000000
--- a/cpu/ppc/ppcgekkoopcodes.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-DingusPPC - The Experimental PowerPC Macintosh emulator
-Copyright (C) 2018-20 divingkatae and maximum
-                      (theweirdo)     spatium
-
-(Contact divingkatae#1017 or powermax#2286 on Discord for more info)
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-// The uniquely Gekko opcodes for the processor - ppcgekkoopcodes.cpp
-
-#include "ppcemu.h"
-#include <iostream>
-#include <stdio.h>
-
-void ppc_psq_l() {
-    printf("Hello. There's no GameCube emulation...yet. Goodbye.");
-    exit(0);
-}
-
-void ppc_psq_lu() {
-    printf("Hello. There's no GameCube emulation...yet. Goodbye.");
-    exit(0);
-}
-
-void ppc_psq_st() {
-    printf("Hello. There's no GameCube emulation...yet. Goodbye.");
-    exit(0);
-}
-
-void ppc_psq_stu() {
-    printf("Hello. There's no GameCube emulation...yet. Goodbye.");
-    exit(0);
-}
diff --git a/cpu/ppc/ppcopcodes.cpp b/cpu/ppc/ppcopcodes.cpp
index cd3bab1..e1cf3b4 100644
--- a/cpu/ppc/ppcopcodes.cpp
+++ b/cpu/ppc/ppcopcodes.cpp
@@ -197,20 +197,20 @@ comparisons needed. This means loads of functions, but less CPU cycles needed to
 function (theoretically).
 **/
 
-void ppc_addi() {
+void dppc_interpreter::ppc_addi() {
     ppc_grab_regsdasimm();
     ppc_result_d = (reg_a == 0) ? simm : (ppc_result_a + simm);
     ppc_store_result_regd();
 }
 
-void ppc_addic() {
+void dppc_interpreter::ppc_addic() {
     ppc_grab_regsdasimm();
     ppc_result_d = (ppc_result_a + simm);
     ppc_carry(ppc_result_a, ppc_result_d);
     ppc_store_result_regd();
 }
 
-void ppc_addicdot() {
+void dppc_interpreter::ppc_addicdot() {
     ppc_grab_regsdasimm();
     ppc_result_d = (ppc_result_a + simm);
     ppc_changecrf0(ppc_result_d);
@@ -218,13 +218,13 @@ void ppc_addicdot() {
     ppc_store_result_regd();
 }
 
-void ppc_addis() {
+void dppc_interpreter::ppc_addis() {
     ppc_grab_regsdasimm();
     ppc_result_d = (reg_a == 0) ? (simm << 16) : (ppc_result_a + (simm << 16));
     ppc_store_result_regd();
 }
 
-void ppc_add() {
+void dppc_interpreter::ppc_add() {
     ppc_grab_regsdab();
     ppc_result_d = ppc_result_a + ppc_result_b;
     if (oe_flag)
@@ -234,7 +234,7 @@ void ppc_add() {
     ppc_store_result_regd();
 }
 
-void ppc_addc() {
+void dppc_interpreter::ppc_addc() {
     ppc_grab_regsdab();
     ppc_result_d = ppc_result_a + ppc_result_b;
     ppc_carry(ppc_result_a, ppc_result_d);
@@ -247,7 +247,7 @@ void ppc_addc() {
     ppc_store_result_regd();
 }
 
-void ppc_adde() {
+void dppc_interpreter::ppc_adde() {
     ppc_grab_regsdab();
     uint32_t xer_ca = !!(ppc_state.spr[SPR::XER] & 0x20000000);
     ppc_result_d    = ppc_result_a + ppc_result_b + xer_ca;
@@ -266,7 +266,7 @@ void ppc_adde() {
     ppc_store_result_regd();
 }
 
-void ppc_addme() {
+void dppc_interpreter::ppc_addme() {
     ppc_grab_regsda();
     uint32_t xer_ca = !!(ppc_state.spr[SPR::XER] & 0x20000000);
     ppc_result_d    = ppc_result_a + xer_ca - 1;
@@ -285,7 +285,7 @@ void ppc_addme() {
     ppc_store_result_regd();
 }
 
-void ppc_addze() {
+void dppc_interpreter::ppc_addze() {
     ppc_grab_regsda();
     uint32_t grab_xer = !!(ppc_state.spr[SPR::XER] & 0x20000000);
     ppc_result_d      = ppc_result_a + grab_xer;
@@ -304,7 +304,7 @@ void ppc_addze() {
     ppc_store_result_regd();
 }
 
-void ppc_subf() {
+void dppc_interpreter::ppc_subf() {
     ppc_grab_regsdab();
     ppc_result_d = ppc_result_b - ppc_result_a;
 
@@ -316,7 +316,7 @@ void ppc_subf() {
     ppc_store_result_regd();
 }
 
-void ppc_subfc() {
+void dppc_interpreter::ppc_subfc() {
     ppc_grab_regsdab();
     ppc_result_d = ppc_result_b - ppc_result_a;
     ppc_carry_sub(ppc_result_a, ppc_result_b);
@@ -329,14 +329,14 @@ void ppc_subfc() {
     ppc_store_result_regd();
 }
 
-void ppc_subfic() {
+void dppc_interpreter::ppc_subfic() {
     ppc_grab_regsdasimm();
     ppc_result_d = simm - ppc_result_a;
     ppc_carry(~ppc_result_a, ppc_result_d);
     ppc_store_result_regd();
 }
 
-void ppc_subfe() {
+void dppc_interpreter::ppc_subfe() {
     ppc_grab_regsdab();
     uint32_t grab_xer = !!(ppc_state.spr[SPR::XER] & 0x20000000);
     ppc_result_d      = ~ppc_result_a + ppc_result_b + grab_xer;
@@ -350,7 +350,7 @@ void ppc_subfe() {
     ppc_store_result_regd();
 }
 
-void ppc_subfme() {
+void dppc_interpreter::ppc_subfme() {
     ppc_grab_regsda();
     uint32_t grab_xer = !!(ppc_state.spr[SPR::XER] & 0x20000000);
     ppc_result_d      = ~ppc_result_a + grab_xer - 1;
@@ -364,7 +364,7 @@ void ppc_subfme() {
     ppc_store_result_regd();
 }
 
-void ppc_subfze() {
+void dppc_interpreter::ppc_subfze() {
     ppc_grab_regsda();
     ppc_result_d = ~ppc_result_a + (ppc_state.spr[SPR::XER] & 0x20000000);
     ppc_carry(~ppc_result_a, ppc_result_d);
@@ -378,7 +378,7 @@ void ppc_subfze() {
 }
 
 
-void ppc_and() {
+void dppc_interpreter::ppc_and() {
     ppc_grab_regssab();
     ppc_result_a = ppc_result_d & ppc_result_b;
 
@@ -388,7 +388,7 @@ void ppc_and() {
     ppc_store_result_rega();
 }
 
-void ppc_andc() {
+void dppc_interpreter::ppc_andc() {
     ppc_grab_regssab();
     ppc_result_a = ppc_result_d & ~(ppc_result_b);
 
@@ -398,21 +398,21 @@ void ppc_andc() {
     ppc_store_result_rega();
 }
 
-void ppc_andidot() {
+void dppc_interpreter::ppc_andidot() {
     ppc_grab_regssauimm();
     ppc_result_a = ppc_result_d & uimm;
     ppc_changecrf0(ppc_result_a);
     ppc_store_result_rega();
 }
 
-void ppc_andisdot() {
+void dppc_interpreter::ppc_andisdot() {
     ppc_grab_regssauimm();
     ppc_result_a = ppc_result_d & (uimm << 16);
     ppc_changecrf0(ppc_result_a);
     ppc_store_result_rega();
 }
 
-void ppc_nand() {
+void dppc_interpreter::ppc_nand() {
     ppc_grab_regssab();
     ppc_result_a = ~(ppc_result_d & ppc_result_b);
 
@@ -422,7 +422,7 @@ void ppc_nand() {
     ppc_store_result_rega();
 }
 
-void ppc_or() {
+void dppc_interpreter::ppc_or() {
     ppc_grab_regssab();
     ppc_result_a = ppc_result_d | ppc_result_b;
 
@@ -432,7 +432,7 @@ void ppc_or() {
     ppc_store_result_rega();
 }
 
-void ppc_orc() {
+void dppc_interpreter::ppc_orc() {
     ppc_grab_regssab();
     ppc_result_a = ppc_result_d | ~(ppc_result_b);
 
@@ -442,19 +442,19 @@ void ppc_orc() {
     ppc_store_result_rega();
 }
 
-void ppc_ori() {
+void dppc_interpreter::ppc_ori() {
     ppc_grab_regssauimm();
     ppc_result_a = ppc_result_d | uimm;
     ppc_store_result_rega();
 }
 
-void ppc_oris() {
+void dppc_interpreter::ppc_oris() {
     ppc_grab_regssauimm();
     ppc_result_a = (uimm << 16) | ppc_result_d;
     ppc_store_result_rega();
 }
 
-void ppc_eqv() {
+void dppc_interpreter::ppc_eqv() {
     ppc_grab_regssab();
     ppc_result_a = ~(ppc_result_d ^ ppc_result_b);
 
@@ -464,7 +464,7 @@ void ppc_eqv() {
     ppc_store_result_rega();
 }
 
-void ppc_nor() {
+void dppc_interpreter::ppc_nor() {
     ppc_grab_regssab();
     ppc_result_a = ~(ppc_result_d | ppc_result_b);
 
@@ -474,7 +474,7 @@ void ppc_nor() {
     ppc_store_result_rega();
 }
 
-void ppc_xor() {
+void dppc_interpreter::ppc_xor() {
     ppc_grab_regssab();
     ppc_result_a = ppc_result_d ^ ppc_result_b;
 
@@ -484,19 +484,19 @@ void ppc_xor() {
     ppc_store_result_rega();
 }
 
-void ppc_xori() {
+void dppc_interpreter::ppc_xori() {
     ppc_grab_regssauimm();
     ppc_result_a = ppc_result_d ^ uimm;
     ppc_store_result_rega();
 }
 
-void ppc_xoris() {
+void dppc_interpreter::ppc_xoris() {
     ppc_grab_regssauimm();
     ppc_result_a = ppc_result_d ^ (uimm << 16);
     ppc_store_result_rega();
 }
 
-void ppc_neg() {
+void dppc_interpreter::ppc_neg() {
     ppc_grab_regsda();
     ppc_result_d = ~(ppc_result_a) + 1;
 
@@ -513,7 +513,7 @@ void ppc_neg() {
     ppc_store_result_regd();
 }
 
-void ppc_cntlzw() {
+void dppc_interpreter::ppc_cntlzw() {
     ppc_grab_regssa();
 
     uint32_t lead      = 0;
@@ -538,7 +538,7 @@ void ppc_cntlzw() {
     ppc_store_result_rega();
 }
 
-void ppc_mulhwu() {
+void dppc_interpreter::ppc_mulhwu() {
     ppc_grab_regsdab();
     uint64_t product = (uint64_t)ppc_result_a * (uint64_t)ppc_result_b;
     ppc_result_d     = (uint32_t)(product >> 32);
@@ -549,7 +549,7 @@ void ppc_mulhwu() {
     ppc_store_result_regd();
 }
 
-void ppc_mulhw() {
+void dppc_interpreter::ppc_mulhw() {
     ppc_grab_regsdab();
     int64_t product = (int64_t)(int32_t)ppc_result_a * (int64_t)(int32_t)ppc_result_b;
     ppc_result_d    = product >> 32;
@@ -560,7 +560,7 @@ void ppc_mulhw() {
     ppc_store_result_regd();
 }
 
-void ppc_mullw() {
+void dppc_interpreter::ppc_mullw() {
     ppc_grab_regsdab();
     int64_t product = (int64_t)(int32_t)ppc_result_a * (int64_t)(int32_t)ppc_result_b;
 
@@ -580,14 +580,14 @@ void ppc_mullw() {
     ppc_store_result_regd();
 }
 
-void ppc_mulli() {
+void dppc_interpreter::ppc_mulli() {
     ppc_grab_regsdasimm();
     int64_t product = (int64_t)(int32_t)ppc_result_a * (int64_t)(int32_t)simm;
     ppc_result_d    = (uint32_t)product;
     ppc_store_result_regd();
 }
 
-void ppc_divw() {
+void dppc_interpreter::ppc_divw() {
     ppc_grab_regsdab();
 
     if (!ppc_result_b) {                                     /* handle the "anything / 0" case */
@@ -616,7 +616,7 @@ void ppc_divw() {
     ppc_store_result_regd();
 }
 
-void ppc_divwu() {
+void dppc_interpreter::ppc_divwu() {
     ppc_grab_regsdab();
 
     if (!ppc_result_b) { /* division by zero */
@@ -642,7 +642,7 @@ void ppc_divwu() {
 
 // Value shifting
 
-void ppc_slw() {
+void dppc_interpreter::ppc_slw() {
     ppc_grab_regssab();
     if (ppc_result_b & 0x20) {
         ppc_result_a = 0;
@@ -656,7 +656,7 @@ void ppc_slw() {
     ppc_store_result_rega();
 }
 
-void ppc_srw() {
+void dppc_interpreter::ppc_srw() {
     ppc_grab_regssab();
     if (ppc_result_b & 0x20) {
         ppc_result_a = 0;
@@ -670,7 +670,7 @@ void ppc_srw() {
     ppc_store_result_rega();
 }
 
-void ppc_sraw() {
+void dppc_interpreter::ppc_sraw() {
     ppc_grab_regssab();
     if (ppc_result_b & 0x20) {
         ppc_result_a = (int32_t)ppc_result_d >> 31;
@@ -692,7 +692,7 @@ void ppc_sraw() {
     ppc_store_result_rega();
 }
 
-void ppc_srawi() {
+void dppc_interpreter::ppc_srawi() {
     ppc_grab_regssa();
     unsigned shift = (ppc_cur_instruction >> 11) & 0x1F;
     uint32_t mask  = (1 << shift) - 1;
@@ -716,7 +716,7 @@ static inline uint32_t rot_mask(unsigned rot_mb, unsigned rot_me) {
     return ((rot_mb <= rot_me) ? m2 & m1 : m1 | m2);
 }
 
-void ppc_rlwimi() {
+void dppc_interpreter::ppc_rlwimi() {
     ppc_grab_regssa();
     unsigned rot_sh = (ppc_cur_instruction >> 11) & 31;
     unsigned rot_mb = (ppc_cur_instruction >> 6) & 31;
@@ -730,7 +730,7 @@ void ppc_rlwimi() {
     ppc_store_result_rega();
 }
 
-void ppc_rlwinm() {
+void dppc_interpreter::ppc_rlwinm() {
     ppc_grab_regssa();
     unsigned rot_sh = (ppc_cur_instruction >> 11) & 31;
     unsigned rot_mb = (ppc_cur_instruction >> 6) & 31;
@@ -744,7 +744,7 @@ void ppc_rlwinm() {
     ppc_store_result_rega();
 }
 
-void ppc_rlwnm() {
+void dppc_interpreter::ppc_rlwnm() {
     ppc_grab_regssab();
     unsigned rot_mb = (ppc_cur_instruction >> 6) & 31;
     unsigned rot_me = (ppc_cur_instruction >> 1) & 31;
@@ -757,12 +757,12 @@ void ppc_rlwnm() {
     ppc_store_result_rega();
 }
 
-void ppc_mfcr() {
+void dppc_interpreter::ppc_mfcr() {
     reg_d                = (ppc_cur_instruction >> 21) & 31;
     ppc_state.gpr[reg_d] = ppc_state.cr;
 }
 
-void ppc_mtsr() {
+void dppc_interpreter::ppc_mtsr() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -773,7 +773,7 @@ void ppc_mtsr() {
     }
 }
 
-void ppc_mtsrin() {
+void dppc_interpreter::ppc_mtsrin() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -784,7 +784,7 @@ void ppc_mtsrin() {
     }
 }
 
-void ppc_mfsr() {
+void dppc_interpreter::ppc_mfsr() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -795,7 +795,7 @@ void ppc_mfsr() {
     }
 }
 
-void ppc_mfsrin() {
+void dppc_interpreter::ppc_mfsrin() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -806,7 +806,7 @@ void ppc_mfsrin() {
     }
 }
 
-void ppc_mfmsr() {
+void dppc_interpreter::ppc_mfmsr() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -817,7 +817,7 @@ void ppc_mfmsr() {
     ppc_state.gpr[reg_d] = ppc_state.msr;
 }
 
-void ppc_mtmsr() {
+void dppc_interpreter::ppc_mtmsr() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -828,7 +828,7 @@ void ppc_mtmsr() {
     ppc_state.msr = ppc_state.gpr[reg_s];
 }
 
-void ppc_mfspr() {
+void dppc_interpreter::ppc_mfspr() {
     uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31);
 
 #ifdef PROFILER
@@ -840,7 +840,7 @@ void ppc_mfspr() {
     ppc_state.gpr[reg_d] = ppc_state.spr[ref_spr];
 }
 
-void ppc_mtspr() {
+void dppc_interpreter::ppc_mtspr() {
     uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31);
     reg_s            = (ppc_cur_instruction >> 21) & 31;
 
@@ -885,7 +885,7 @@ void ppc_mtspr() {
     }
 }
 
-void ppc_mftb() {
+void dppc_interpreter::ppc_mftb() {
     uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31);
     reg_d            = (ppc_cur_instruction >> 21) & 31;
     switch (ref_spr) {
@@ -900,7 +900,7 @@ void ppc_mftb() {
     }
 }
 
-void ppc_mtcrf() {
+void dppc_interpreter::ppc_mtcrf() {
     uint32_t cr_mask = 0;
     ppc_grab_regssa();
     crm = ((ppc_cur_instruction >> 12) & 255);
@@ -916,7 +916,7 @@ void ppc_mtcrf() {
     ppc_state.cr = (ppc_result_d & cr_mask) | (ppc_state.cr & ~(cr_mask));
 }
 
-void ppc_mcrxr() {
+void dppc_interpreter::ppc_mcrxr() {
     crf_d        = (ppc_cur_instruction >> 23) & 7;
     crf_d        = crf_d << 2;
     ppc_state.cr = (ppc_state.cr & ~(0xF0000000UL >> crf_d)) |
@@ -924,7 +924,7 @@ void ppc_mcrxr() {
     ppc_state.spr[SPR::XER] &= 0x0FFFFFFF;
 }
 
-void ppc_extsb() {
+void dppc_interpreter::ppc_extsb() {
     ppc_grab_regssa();
     ppc_result_d = ppc_result_d & 0xFF;
     ppc_result_a = (ppc_result_d < 0x80) ? (ppc_result_d & 0x000000FF)
@@ -936,7 +936,7 @@ void ppc_extsb() {
     ppc_store_result_rega();
 }
 
-void ppc_extsh() {
+void dppc_interpreter::ppc_extsh() {
     ppc_grab_regssa();
     ppc_result_d = ppc_result_d & 0xFFFF;
     ppc_result_a = (ppc_result_d < 0x8000) ? (ppc_result_d & 0x0000FFFF)
@@ -953,14 +953,14 @@ void ppc_extsh() {
 // The middle 24 bytes are the 24-bit address to use for branching to.
 
 
-void ppc_b() {
+void dppc_interpreter::ppc_b() {
     uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
     adr_li              = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test);
     ppc_next_instruction_address = (uint32_t)(ppc_state.pc + adr_li);
     bb_kind = BB_end_kind::BB_BRANCH;
 }
 
-void ppc_bl() {
+void dppc_interpreter::ppc_bl() {
     uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
     adr_li              = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test);
     ppc_next_instruction_address = (uint32_t)(ppc_state.pc + adr_li);
@@ -968,14 +968,14 @@ void ppc_bl() {
     bb_kind = BB_end_kind::BB_BRANCH;
 }
 
-void ppc_ba() {
+void dppc_interpreter::ppc_ba() {
     uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
     adr_li              = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test);
     ppc_next_instruction_address = adr_li;
     bb_kind = BB_end_kind::BB_BRANCH;
 }
 
-void ppc_bla() {
+void dppc_interpreter::ppc_bla() {
     uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
     adr_li              = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test);
     ppc_next_instruction_address = adr_li;
@@ -983,7 +983,7 @@ void ppc_bla() {
     bb_kind = BB_end_kind::BB_BRANCH;
 }
 
-void ppc_bc() {
+void dppc_interpreter::ppc_bc() {
     uint32_t ctr_ok;
     uint32_t cnd_ok;
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
@@ -1002,7 +1002,7 @@ void ppc_bc() {
     }
 }
 
-void ppc_bca() {
+void dppc_interpreter::ppc_bca() {
     uint32_t ctr_ok;
     uint32_t cnd_ok;
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
@@ -1021,7 +1021,7 @@ void ppc_bca() {
     }
 }
 
-void ppc_bcl() {
+void dppc_interpreter::ppc_bcl() {
     uint32_t ctr_ok;
     uint32_t cnd_ok;
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
@@ -1041,7 +1041,7 @@ void ppc_bcl() {
     ppc_state.spr[SPR::LR] = ppc_state.pc + 4;
 }
 
-void ppc_bcla() {
+void dppc_interpreter::ppc_bcla() {
     uint32_t ctr_ok;
     uint32_t cnd_ok;
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
@@ -1061,7 +1061,7 @@ void ppc_bcla() {
     ppc_state.spr[SPR::LR] = ppc_state.pc + 4;
 }
 
-void ppc_bcctr() {
+void dppc_interpreter::ppc_bcctr() {
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
     uint32_t br_bi = (ppc_cur_instruction >> 16) & 31;
 
@@ -1074,7 +1074,7 @@ void ppc_bcctr() {
     }
 }
 
-void ppc_bcctrl() {
+void dppc_interpreter::ppc_bcctrl() {
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
     uint32_t br_bi = (ppc_cur_instruction >> 16) & 31;
 
@@ -1088,7 +1088,7 @@ void ppc_bcctrl() {
     ppc_state.spr[SPR::LR] = ppc_state.pc + 4;
 }
 
-void ppc_bclr() {
+void dppc_interpreter::ppc_bclr() {
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
     uint32_t br_bi = (ppc_cur_instruction >> 16) & 31;
     uint32_t ctr_ok;
@@ -1106,7 +1106,7 @@ void ppc_bclr() {
     }
 }
 
-void ppc_bclrl() {
+void dppc_interpreter::ppc_bclrl() {
     uint32_t br_bo = (ppc_cur_instruction >> 21) & 31;
     uint32_t br_bi = (ppc_cur_instruction >> 16) & 31;
     uint32_t ctr_ok;
@@ -1126,7 +1126,7 @@ void ppc_bclrl() {
 }
 // Compare Instructions
 
-void ppc_cmp() {
+void dppc_interpreter::ppc_cmp() {
 #ifdef CHECK_INVALID
     if (ppc_cur_instruction & 0x200000) {
         LOG_F(WARNING, "Invalid CMP instruction form (L=1)!\n");
@@ -1144,7 +1144,7 @@ void ppc_cmp() {
     ppc_state.cr = ((ppc_state.cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
 }
 
-void ppc_cmpi() {
+void dppc_interpreter::ppc_cmpi() {
 #ifdef CHECK_INVALID
     if (ppc_cur_instruction & 0x200000) {
         LOG_F(WARNING, "Invalid CMPI instruction form (L=1)!\n");
@@ -1162,7 +1162,7 @@ void ppc_cmpi() {
     ppc_state.cr = ((ppc_state.cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
 }
 
-void ppc_cmpl() {
+void dppc_interpreter::ppc_cmpl() {
 #ifdef CHECK_INVALID
     if (ppc_cur_instruction & 0x200000) {
         LOG_F(WARNING, "Invalid CMPL instruction form (L=1)!\n");
@@ -1180,7 +1180,7 @@ void ppc_cmpl() {
     ppc_state.cr = ((ppc_state.cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
 }
 
-void ppc_cmpli() {
+void dppc_interpreter::ppc_cmpli() {
 #ifdef CHECK_INVALID
     if (ppc_cur_instruction & 0x200000) {
         LOG_F(WARNING, "Invalid CMPLI instruction form (L=1)!\n");
@@ -1199,7 +1199,7 @@ void ppc_cmpli() {
 
 // Condition Register Changes
 
-void ppc_crand() {
+void dppc_interpreter::ppc_crand() {
     ppc_grab_regsdab();
     if ((ppc_state.cr & (0x80000000UL >> reg_a)) && (ppc_state.cr & (0x80000000UL >> reg_b))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1207,7 +1207,7 @@ void ppc_crand() {
         ppc_state.cr &= ~(0x80000000UL >> reg_d);
     }
 }
-void ppc_crandc() {
+void dppc_interpreter::ppc_crandc() {
     ppc_grab_regsdab();
     if ((ppc_state.cr & (0x80000000UL >> reg_a)) && !(ppc_state.cr & (0x80000000UL >> reg_b))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1215,7 +1215,7 @@ void ppc_crandc() {
         ppc_state.cr &= ~(0x80000000UL >> reg_d);
     }
 }
-void ppc_creqv() {
+void dppc_interpreter::ppc_creqv() {
     ppc_grab_regsdab();
     if (!((ppc_state.cr & (0x80000000UL >> reg_a)) ^ (ppc_state.cr & (0x80000000UL >> reg_b)))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1223,7 +1223,7 @@ void ppc_creqv() {
         ppc_state.cr &= ~(0x80000000UL >> reg_d);
     }
 }
-void ppc_crnand() {
+void dppc_interpreter::ppc_crnand() {
     ppc_grab_regsdab();
     if (!((ppc_state.cr & (0x80000000UL >> reg_a)) && (ppc_state.cr & (0x80000000UL >> reg_b)))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1231,7 +1231,7 @@ void ppc_crnand() {
         ppc_state.cr &= ~(0x80000000UL >> reg_d);
     }
 }
-void ppc_crnor() {
+void dppc_interpreter::ppc_crnor() {
     ppc_grab_regsdab();
     if (!((ppc_state.cr & (0x80000000UL >> reg_a)) || (ppc_state.cr & (0x80000000UL >> reg_b)))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1240,7 +1240,7 @@ void ppc_crnor() {
     }
 }
 
-void ppc_cror() {
+void dppc_interpreter::ppc_cror() {
     ppc_grab_regsdab();
     if ((ppc_state.cr & (0x80000000UL >> reg_a)) || (ppc_state.cr & (0x80000000UL >> reg_b))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1248,7 +1248,7 @@ void ppc_cror() {
         ppc_state.cr &= ~(0x80000000UL >> reg_d);
     }
 }
-void ppc_crorc() {
+void dppc_interpreter::ppc_crorc() {
     ppc_grab_regsdab();
     if ((ppc_state.cr & (0x80000000UL >> reg_a)) || !(ppc_state.cr & (0x80000000UL >> reg_b))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1256,7 +1256,7 @@ void ppc_crorc() {
         ppc_state.cr &= ~(0x80000000UL >> reg_d);
     }
 }
-void ppc_crxor() {
+void dppc_interpreter::ppc_crxor() {
     ppc_grab_regsdab();
     if ((ppc_state.cr & (0x80000000UL >> reg_a)) ^ (ppc_state.cr & (0x80000000UL >> reg_b))) {
         ppc_state.cr |= (0x80000000UL >> reg_d);
@@ -1267,7 +1267,7 @@ void ppc_crxor() {
 
 // Processor MGMT Fns.
 
-void ppc_rfi() {
+void dppc_interpreter::ppc_rfi() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
@@ -1280,11 +1280,11 @@ void ppc_rfi() {
     bb_kind     = BB_end_kind::BB_RFI;
 }
 
-void ppc_sc() {
+void dppc_interpreter::ppc_sc() {
     ppc_exception_handler(Except_Type::EXC_SYSCALL, 0x20000);
 }
 
-void ppc_tw() {
+void dppc_interpreter::ppc_tw() {
     reg_a  = (ppc_cur_instruction >> 11) & 31;
     reg_b  = (ppc_cur_instruction >> 16) & 31;
     ppc_to = (ppc_cur_instruction >> 21) & 31;
@@ -1297,7 +1297,7 @@ void ppc_tw() {
     }
 }
 
-void ppc_twi() {
+void dppc_interpreter::ppc_twi() {
     simm   = (int32_t)((int16_t)((ppc_cur_instruction)&0xFFFF));
     reg_a  = (ppc_cur_instruction >> 16) & 0x1F;
     ppc_to = (ppc_cur_instruction >> 21) & 0x1F;
@@ -1310,48 +1310,48 @@ void ppc_twi() {
     }
 }
 
-void ppc_eieio() {
+void dppc_interpreter::ppc_eieio() {
     /* placeholder */
 }
 
-void ppc_isync() {
+void dppc_interpreter::ppc_isync() {
     /* placeholder */
 }
 
-void ppc_sync() {
+void dppc_interpreter::ppc_sync() {
     /* placeholder */
 }
 
-void ppc_icbi() {
+void dppc_interpreter::ppc_icbi() {
     /* placeholder */
 }
 
-void ppc_dcbf() {
+void dppc_interpreter::ppc_dcbf() {
     /* placeholder */
 }
 
-void ppc_dcbi() {
+void dppc_interpreter::ppc_dcbi() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
     /* placeholder */
 }
 
-void ppc_dcbst() {
+void dppc_interpreter::ppc_dcbst() {
     /* placeholder */
 }
 
-void ppc_dcbt() {
+void dppc_interpreter::ppc_dcbt() {
     // Not needed, the HDI reg is touched to no-op this instruction.
     return;
 }
 
-void ppc_dcbtst() {
+void dppc_interpreter::ppc_dcbtst() {
     // Not needed, the HDI reg is touched to no-op this instruction.
     return;
 }
 
-void ppc_dcbz() {
+void dppc_interpreter::ppc_dcbz() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     if (!(ppc_state.pc & 32) && (ppc_state.pc < 0xFFFFFFE0UL)) {
@@ -1369,20 +1369,20 @@ void ppc_dcbz() {
 
 // Integer Load and Store Functions
 
-void ppc_stb() {
+void dppc_interpreter::ppc_stb() {
     ppc_grab_regssa();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
     mem_write_byte(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_stbx() {
+void dppc_interpreter::ppc_stbx() {
     ppc_grab_regssab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     mem_write_byte(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_stbu() {
+void dppc_interpreter::ppc_stbu() {
     ppc_grab_regssa();
     if (reg_a != 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -1394,7 +1394,7 @@ void ppc_stbu() {
     }
 }
 
-void ppc_stbux() {
+void dppc_interpreter::ppc_stbux() {
     ppc_grab_regssab();
     if (reg_a != 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -1405,14 +1405,14 @@ void ppc_stbux() {
     }
 }
 
-void ppc_sth() {
+void dppc_interpreter::ppc_sth() {
     ppc_grab_regssa();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
     mem_write_word(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_sthu() {
+void dppc_interpreter::ppc_sthu() {
     ppc_grab_regssa();
     if (reg_a != 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -1424,7 +1424,7 @@ void ppc_sthu() {
     }
 }
 
-void ppc_sthux() {
+void dppc_interpreter::ppc_sthux() {
     ppc_grab_regssab();
     if (reg_a != 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -1435,32 +1435,32 @@ void ppc_sthux() {
     }
 }
 
-void ppc_sthx() {
+void dppc_interpreter::ppc_sthx() {
     ppc_grab_regssab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     mem_write_word(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_sthbrx() {
+void dppc_interpreter::ppc_sthbrx() {
     ppc_grab_regssab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = (uint32_t)(BYTESWAP_16((uint16_t)ppc_result_d));
     mem_write_word(ppc_effective_address, ppc_result_d);
 }
-void ppc_stw() {
+void dppc_interpreter::ppc_stw() {
     ppc_grab_regssa();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
     mem_write_dword(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_stwx() {
+void dppc_interpreter::ppc_stwx() {
     ppc_grab_regssab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     mem_write_dword(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_stwcx() {
+void dppc_interpreter::ppc_stwcx() {
     // PLACEHOLDER CODE FOR STWCX - We need to check for reserve memory
     if (rc_flag == 0) {
         ppc_illegalsubop31();
@@ -1477,7 +1477,7 @@ void ppc_stwcx() {
     }
 }
 
-void ppc_stwu() {
+void dppc_interpreter::ppc_stwu() {
     ppc_grab_regssa();
     if (reg_a != 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -1489,7 +1489,7 @@ void ppc_stwu() {
     }
 }
 
-void ppc_stwux() {
+void dppc_interpreter::ppc_stwux() {
     ppc_grab_regssab();
     if (reg_a != 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -1500,14 +1500,14 @@ void ppc_stwux() {
     }
 }
 
-void ppc_stwbrx() {
+void dppc_interpreter::ppc_stwbrx() {
     ppc_grab_regssab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = BYTESWAP_32(ppc_result_d);
     mem_write_dword(ppc_effective_address, ppc_result_d);
 }
 
-void ppc_stmw() {
+void dppc_interpreter::ppc_stmw() {
     ppc_grab_regssa();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -1523,7 +1523,7 @@ void ppc_stmw() {
     }
 }
 
-void ppc_lbz() {
+void dppc_interpreter::ppc_lbz() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -1531,7 +1531,7 @@ void ppc_lbz() {
     ppc_store_result_regd();
 }
 
-void ppc_lbzu() {
+void dppc_interpreter::ppc_lbzu() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     if ((reg_a != reg_d) || reg_a != 0) {
@@ -1545,14 +1545,14 @@ void ppc_lbzu() {
     }
 }
 
-void ppc_lbzx() {
+void dppc_interpreter::ppc_lbzx() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = mem_grab_byte(ppc_effective_address);
     ppc_store_result_regd();
 }
 
-void ppc_lbzux() {
+void dppc_interpreter::ppc_lbzux() {
     ppc_grab_regsdab();
     if ((reg_a != reg_d) || reg_a != 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -1566,7 +1566,7 @@ void ppc_lbzux() {
 }
 
 
-void ppc_lhz() {
+void dppc_interpreter::ppc_lhz() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -1574,7 +1574,7 @@ void ppc_lhz() {
     ppc_store_result_regd();
 }
 
-void ppc_lhzu() {
+void dppc_interpreter::ppc_lhzu() {
     ppc_grab_regsda();
     if ((reg_a != reg_d) || reg_a != 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -1588,14 +1588,14 @@ void ppc_lhzu() {
     }
 }
 
-void ppc_lhzx() {
+void dppc_interpreter::ppc_lhzx() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = mem_grab_word(ppc_effective_address);
     ppc_store_result_regd();
 }
 
-void ppc_lhzux() {
+void dppc_interpreter::ppc_lhzux() {
     ppc_grab_regsdab();
     if ((reg_a != reg_d) || reg_a != 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -1608,7 +1608,7 @@ void ppc_lhzux() {
     }
 }
 
-void ppc_lha() {
+void dppc_interpreter::ppc_lha() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -1621,7 +1621,7 @@ void ppc_lha() {
     ppc_store_result_regd();
 }
 
-void ppc_lhau() {
+void dppc_interpreter::ppc_lhau() {
     ppc_grab_regsda();
     if ((reg_a != reg_d) || reg_a != 0) {
         ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
@@ -1640,7 +1640,7 @@ void ppc_lhau() {
     }
 }
 
-void ppc_lhaux() {
+void dppc_interpreter::ppc_lhaux() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     uint16_t val          = mem_grab_word(ppc_effective_address);
@@ -1654,7 +1654,7 @@ void ppc_lhaux() {
     ppc_store_result_rega();
 }
 
-void ppc_lhax() {
+void dppc_interpreter::ppc_lhax() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     uint16_t val          = mem_grab_word(ppc_effective_address);
@@ -1666,14 +1666,14 @@ void ppc_lhax() {
     ppc_store_result_regd();
 }
 
-void ppc_lhbrx() {
+void dppc_interpreter::ppc_lhbrx() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = (uint32_t)(BYTESWAP_16(mem_grab_word(ppc_effective_address)));
     ppc_store_result_regd();
 }
 
-void ppc_lwz() {
+void dppc_interpreter::ppc_lwz() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -1681,14 +1681,14 @@ void ppc_lwz() {
     ppc_store_result_regd();
 }
 
-void ppc_lwbrx() {
+void dppc_interpreter::ppc_lwbrx() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = BYTESWAP_32(mem_grab_dword(ppc_effective_address));
     ppc_store_result_regd();
 }
 
-void ppc_lwzu() {
+void dppc_interpreter::ppc_lwzu() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     if ((reg_a != reg_d) || reg_a != 0) {
@@ -1702,14 +1702,14 @@ void ppc_lwzu() {
     }
 }
 
-void ppc_lwzx() {
+void dppc_interpreter::ppc_lwzx() {
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     ppc_result_d          = mem_grab_dword(ppc_effective_address);
     ppc_store_result_regd();
 }
 
-void ppc_lwzux() {
+void dppc_interpreter::ppc_lwzux() {
     ppc_grab_regsdab();
     if ((reg_a != reg_d) || reg_a != 0) {
         ppc_effective_address = ppc_result_a + ppc_result_b;
@@ -1722,7 +1722,7 @@ void ppc_lwzux() {
     ppc_store_result_rega();
 }
 
-void ppc_lwarx() {
+void dppc_interpreter::ppc_lwarx() {
     // Placeholder - Get the reservation of memory implemented!
     ppc_grab_regsdab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
@@ -1731,7 +1731,7 @@ void ppc_lwarx() {
     ppc_store_result_regd();
 }
 
-void ppc_lmw() {
+void dppc_interpreter::ppc_lmw() {
     ppc_grab_regsda();
     ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF));
     ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0;
@@ -1743,7 +1743,7 @@ void ppc_lmw() {
     } while (reg_d < 32);
 }
 
-void ppc_lswi() {
+void dppc_interpreter::ppc_lswi() {
     ppc_grab_regsda();
     ppc_effective_address = ppc_result_a;
     grab_inb              = (ppc_cur_instruction >> 11) & 31;
@@ -1786,7 +1786,7 @@ void ppc_lswi() {
     }
 }
 
-void ppc_lswx() {
+void dppc_interpreter::ppc_lswx() {
     ppc_grab_regsdab();
     // Invalid instruction forms
     if ((ppc_result_d == 0) && (ppc_result_a == 0)) {
@@ -1833,7 +1833,7 @@ void ppc_lswx() {
     }
 }
 
-void ppc_stswi() {
+void dppc_interpreter::ppc_stswi() {
     ppc_grab_regssa();
     ppc_effective_address = (reg_a == 0) ? 0 : ppc_result_a;
     grab_inb              = (ppc_cur_instruction >> 11) & 31;
@@ -1871,7 +1871,7 @@ void ppc_stswi() {
     }
 }
 
-void ppc_stswx() {
+void dppc_interpreter::ppc_stswx() {
     ppc_grab_regssab();
     ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
     grab_inb              = ppc_state.spr[SPR::XER] & 127;
@@ -1910,35 +1910,35 @@ void ppc_stswx() {
 
 // TLB Instructions
 
-void ppc_tlbie() {
+void dppc_interpreter::ppc_tlbie() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
     /* placeholder */
 }
 
-void ppc_tlbia() {
+void dppc_interpreter::ppc_tlbia() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
     /* placeholder */
 }
 
-void ppc_tlbld() {
+void dppc_interpreter::ppc_tlbld() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
     /* placeholder */
 }
 
-void ppc_tlbli() {
+void dppc_interpreter::ppc_tlbli() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
     /* placeholder */
 }
 
-void ppc_tlbsync() {
+void dppc_interpreter::ppc_tlbsync() {
 #ifdef PROFILER
     supervisor_inst_num++;
 #endif
diff --git a/execution/interpreter_loop.cpp b/execution/interpreter_loop.cpp
index d9cb245..8b70ed2 100644
--- a/execution/interpreter_loop.cpp
+++ b/execution/interpreter_loop.cpp
@@ -51,7 +51,7 @@ void round_robin_bench() {
     std::chrono::high_resolution_clock::time_point dummy = std::chrono::high_resolution_clock::now();
 
     for (int i = 0; i < 4096; i++) {
-        ppc_ori(); //execute NOPs as a basic test
+        dppc_interpreter::ppc_ori(); //execute NOPs as a basic test
     }
 
     std::chrono::high_resolution_clock::time_point dummy2 = std::chrono::high_resolution_clock::now();