diff --git a/src/core/arm7tdmi/arm/mod.rs b/src/core/arm7tdmi/arm/mod.rs
index f1979ea..c2a9f29 100644
--- a/src/core/arm7tdmi/arm/mod.rs
+++ b/src/core/arm7tdmi/arm/mod.rs
@@ -365,185 +365,185 @@ impl ArmInstruction {
     }
 }
 
-#[cfg(test)]
-/// All instructions constants were generated using an ARM assembler.
-mod tests {
-    use super::*;
-    use crate::core::arm7tdmi::*;
-    use crate::core::sysbus::BoxedMemory;
+// #[cfg(test)]
+// /// All instructions constants were generated using an ARM assembler.
+// mod tests {
+//     use super::*;
+//     use crate::core::arm7tdmi::*;
+//     use crate::core::sysbus::BoxedMemory;
 
-    #[test]
-    fn swi() {
-        let mut core = Core::new();
+//     #[test]
+//     fn swi() {
+//         let mut core = Core::new();
 
-        let bytes = vec![];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         let bytes = vec![];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        // swi #0x1337
-        let decoded = ArmInstruction::decode(0xef001337, 0).unwrap();
-        assert_eq!(decoded.fmt, ArmFormat::SWI);
-        assert_eq!(decoded.swi_comment(), 0x1337);
-        assert_eq!(format!("{}", decoded), "swi\t#0x1337");
+//         // swi #0x1337
+//         let decoded = ArmInstruction::decode(0xef001337, 0).unwrap();
+//         assert_eq!(decoded.fmt, ArmFormat::SWI);
+//         assert_eq!(decoded.swi_comment(), 0x1337);
+//         assert_eq!(format!("{}", decoded), "swi\t#0x1337");
 
-        core.exec_arm(&mut mem, decoded).unwrap();
-        assert_eq!(core.did_pipeline_flush(), true);
+//         core.exec_arm(&mut mem, decoded).unwrap();
+//         assert_eq!(core.did_pipeline_flush(), true);
 
-        assert_eq!(core.cpsr.mode(), CpuMode::Supervisor);
-        assert_eq!(core.pc, Exception::SoftwareInterrupt as u32);
-    }
+//         assert_eq!(core.cpsr.mode(), CpuMode::Supervisor);
+//         assert_eq!(core.pc, Exception::SoftwareInterrupt as u32);
+//     }
 
-    #[test]
-    fn branch_forwards() {
-        // 0x20:   b 0x30
-        let decoded = ArmInstruction::decode(0xea_00_00_02, 0x20).unwrap();
-        assert_eq!(decoded.fmt, ArmFormat::B_BL);
-        assert_eq!(decoded.link_flag(), false);
-        assert_eq!(
-            (decoded.pc as i32).wrapping_add(decoded.branch_offset()) + 8,
-            0x30
-        );
-        assert_eq!(format!("{}", decoded), "b\t0x30");
+//     #[test]
+//     fn branch_forwards() {
+//         // 0x20:   b 0x30
+//         let decoded = ArmInstruction::decode(0xea_00_00_02, 0x20).unwrap();
+//         assert_eq!(decoded.fmt, ArmFormat::B_BL);
+//         assert_eq!(decoded.link_flag(), false);
+//         assert_eq!(
+//             (decoded.pc as i32).wrapping_add(decoded.branch_offset()) + 8,
+//             0x30
+//         );
+//         assert_eq!(format!("{}", decoded), "b\t0x30");
 
-        let mut core = Core::new();
-        core.pc = 0x20 + 8;
+//         let mut core = Core::new();
+//         core.pc = 0x20 + 8;
 
-        let bytes = vec![];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         let bytes = vec![];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        core.exec_arm(&mut mem, decoded).unwrap();
-        assert_eq!(core.did_pipeline_flush(), true);
-        assert_eq!(core.pc, 0x30);
-    }
+//         core.exec_arm(&mut mem, decoded).unwrap();
+//         assert_eq!(core.did_pipeline_flush(), true);
+//         assert_eq!(core.pc, 0x30);
+//     }
 
-    #[test]
-    fn branch_link_backwards() {
-        // 0x20:   bl 0x10
-        let decoded = ArmInstruction::decode(0xeb_ff_ff_fa, 0x20).unwrap();
-        assert_eq!(decoded.fmt, ArmFormat::B_BL);
-        assert_eq!(decoded.link_flag(), true);
-        assert_eq!(
-            (decoded.pc as i32).wrapping_add(decoded.branch_offset()) + 8,
-            0x10
-        );
-        assert_eq!(format!("{}", decoded), "bl\t0x10");
+//     #[test]
+//     fn branch_link_backwards() {
+//         // 0x20:   bl 0x10
+//         let decoded = ArmInstruction::decode(0xeb_ff_ff_fa, 0x20).unwrap();
+//         assert_eq!(decoded.fmt, ArmFormat::B_BL);
+//         assert_eq!(decoded.link_flag(), true);
+//         assert_eq!(
+//             (decoded.pc as i32).wrapping_add(decoded.branch_offset()) + 8,
+//             0x10
+//         );
+//         assert_eq!(format!("{}", decoded), "bl\t0x10");
 
-        let mut core = Core::new();
-        core.pc = 0x20 + 8;
+//         let mut core = Core::new();
+//         core.pc = 0x20 + 8;
 
-        let bytes = vec![];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         let bytes = vec![];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        core.exec_arm(&mut mem, decoded).unwrap();
-        assert_eq!(core.did_pipeline_flush(), true);
-        assert_eq!(core.pc, 0x10);
-    }
+//         core.exec_arm(&mut mem, decoded).unwrap();
+//         assert_eq!(core.did_pipeline_flush(), true);
+//         assert_eq!(core.pc, 0x10);
+//     }
 
-    #[test]
-    fn ldr_pre_index() {
-        // ldreq r2, [r5, -r6, lsl #5]
-        let decoded = ArmInstruction::decode(0x07_15_22_86, 0).unwrap();
-        assert_eq!(decoded.fmt, ArmFormat::LDR_STR);
-        assert_eq!(decoded.cond, ArmCond::EQ);
-        assert_eq!(decoded.load_flag(), true);
-        assert_eq!(decoded.pre_index_flag(), true);
-        assert_eq!(decoded.write_back_flag(), false);
-        assert_eq!(decoded.rd(), 2);
-        assert_eq!(decoded.rn(), 5);
-        assert_eq!(
-            decoded.ldr_str_offset(),
-            BarrelShifterValue::ShiftedRegister(ShiftedRegister {
-                reg: 6,
-                shift_by: ShiftRegisterBy::ByAmount(5),
-                bs_op: BarrelShiftOpCode::LSL,
-                added: Some(false)
-            })
-        );
+//     #[test]
+//     fn ldr_pre_index() {
+//         // ldreq r2, [r5, -r6, lsl #5]
+//         let decoded = ArmInstruction::decode(0x07_15_22_86, 0).unwrap();
+//         assert_eq!(decoded.fmt, ArmFormat::LDR_STR);
+//         assert_eq!(decoded.cond, ArmCond::EQ);
+//         assert_eq!(decoded.load_flag(), true);
+//         assert_eq!(decoded.pre_index_flag(), true);
+//         assert_eq!(decoded.write_back_flag(), false);
+//         assert_eq!(decoded.rd(), 2);
+//         assert_eq!(decoded.rn(), 5);
+//         assert_eq!(
+//             decoded.ldr_str_offset(),
+//             BarrelShifterValue::ShiftedRegister(ShiftedRegister {
+//                 reg: 6,
+//                 shift_by: ShiftRegisterBy::ByAmount(5),
+//                 bs_op: BarrelShiftOpCode::LSL,
+//                 added: Some(false)
+//             })
+//         );
 
-        assert_eq!(format!("{}", decoded), "ldreq\tr2, [r5, -r6, lsl #5]");
+//         assert_eq!(format!("{}", decoded), "ldreq\tr2, [r5, -r6, lsl #5]");
 
-        let mut core = Core::new();
-        core.cpsr.set_Z(true);
-        core.gpr[5] = 0x34;
-        core.gpr[6] = 1;
-        core.gpr[2] = 0;
+//         let mut core = Core::new();
+//         core.cpsr.set_Z(true);
+//         core.gpr[5] = 0x34;
+//         core.gpr[6] = 1;
+//         core.gpr[2] = 0;
 
-        #[rustfmt::skip]
-        let bytes = vec![
-            /* 00h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            /* 10h: */ 0x00, 0x00, 0x00, 0x00, 0x37, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            /* 20h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            /* 30h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        ];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         #[rustfmt::skip]
+//         let bytes = vec![
+//             /* 00h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//             /* 10h: */ 0x00, 0x00, 0x00, 0x00, 0x37, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//             /* 20h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//             /* 30h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//         ];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        core.exec_arm(&mut mem, decoded).unwrap();
-        assert_eq!(core.gpr[2], 0x1337);
-    }
+//         core.exec_arm(&mut mem, decoded).unwrap();
+//         assert_eq!(core.gpr[2], 0x1337);
+//     }
 
-    #[test]
-    fn str_post_index() {
-        // strteq r2, [r4], -r7, asr #8
-        let decoded = ArmInstruction::decode(0x06_24_24_47, 0).unwrap();
-        assert_eq!(decoded.fmt, ArmFormat::LDR_STR);
-        assert_eq!(decoded.cond, ArmCond::EQ);
-        assert_eq!(decoded.load_flag(), false);
-        assert_eq!(decoded.pre_index_flag(), false);
-        assert_eq!(decoded.write_back_flag(), true);
-        assert_eq!(decoded.rd(), 2);
-        assert_eq!(decoded.rn(), 4);
-        assert_eq!(
-            decoded.ldr_str_offset(),
-            BarrelShifterValue::ShiftedRegister(ShiftedRegister {
-                reg: 7,
-                shift_by: ShiftRegisterBy::ByAmount(8),
-                bs_op: BarrelShiftOpCode::ASR,
-                added: Some(false)
-            })
-        );
-        assert_eq!(format!("{}", decoded), "strteq\tr2, [r4], -r7, asr #8");
+//     #[test]
+//     fn str_post_index() {
+//         // strteq r2, [r4], -r7, asr #8
+//         let decoded = ArmInstruction::decode(0x06_24_24_47, 0).unwrap();
+//         assert_eq!(decoded.fmt, ArmFormat::LDR_STR);
+//         assert_eq!(decoded.cond, ArmCond::EQ);
+//         assert_eq!(decoded.load_flag(), false);
+//         assert_eq!(decoded.pre_index_flag(), false);
+//         assert_eq!(decoded.write_back_flag(), true);
+//         assert_eq!(decoded.rd(), 2);
+//         assert_eq!(decoded.rn(), 4);
+//         assert_eq!(
+//             decoded.ldr_str_offset(),
+//             BarrelShifterValue::ShiftedRegister(ShiftedRegister {
+//                 reg: 7,
+//                 shift_by: ShiftRegisterBy::ByAmount(8),
+//                 bs_op: BarrelShiftOpCode::ASR,
+//                 added: Some(false)
+//             })
+//         );
+//         assert_eq!(format!("{}", decoded), "strteq\tr2, [r4], -r7, asr #8");
 
-        let mut core = Core::new();
-        core.cpsr.set_Z(true);
-        core.gpr[4] = 0x0;
-        core.gpr[7] = 1;
-        core.gpr[2] = 0xabababab;
+//         let mut core = Core::new();
+//         core.cpsr.set_Z(true);
+//         core.gpr[4] = 0x0;
+//         core.gpr[7] = 1;
+//         core.gpr[2] = 0xabababab;
 
-        #[rustfmt::skip]
-        let bytes = vec![
-            /* 00h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            /* 10h: */ 0x00, 0x00, 0x00, 0x00, 0x37, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            /* 20h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            /* 30h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        ];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         #[rustfmt::skip]
+//         let bytes = vec![
+//             /* 00h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//             /* 10h: */ 0x00, 0x00, 0x00, 0x00, 0x37, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//             /* 20h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//             /* 30h: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//         ];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        core.exec_arm(&mut mem, decoded).unwrap();
-        assert_eq!(mem.read_32(0), 0xabababab);
-    }
+//         core.exec_arm(&mut mem, decoded).unwrap();
+//         assert_eq!(mem.read_32(0), 0xabababab);
+//     }
 
-    #[test]
-    fn str_pre_index() {
-        // str r4, [sp, 0x10]
-        let decoded = ArmInstruction::decode(0xe58d4010, 0).unwrap();
-        assert_eq!(decoded.fmt, ArmFormat::LDR_STR);
-        assert_eq!(decoded.cond, ArmCond::AL);
+//     #[test]
+//     fn str_pre_index() {
+//         // str r4, [sp, 0x10]
+//         let decoded = ArmInstruction::decode(0xe58d4010, 0).unwrap();
+//         assert_eq!(decoded.fmt, ArmFormat::LDR_STR);
+//         assert_eq!(decoded.cond, ArmCond::AL);
 
-        let mut core = Core::new();
-        core.set_reg(4, 0x12345678);
-        core.set_reg(REG_SP, 0);
+//         let mut core = Core::new();
+//         core.set_reg(4, 0x12345678);
+//         core.set_reg(REG_SP, 0);
 
-        #[rustfmt::skip]
-        let bytes = vec![
-            /*  0: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /*  4: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /*  8: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /*  c: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 10: */ 0xaa, 0xbb, 0xcc, 0xdd,
-        ];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         #[rustfmt::skip]
+//         let bytes = vec![
+//             /*  0: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /*  4: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /*  8: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /*  c: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 10: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//         ];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        assert_ne!(mem.read_32(core.get_reg(REG_SP) + 0x10), 0x12345678);
-        core.exec_arm(&mut mem, decoded).unwrap();
-        assert_eq!(mem.read_32(core.get_reg(REG_SP) + 0x10), 0x12345678);
-    }
-}
+//         assert_ne!(mem.read_32(core.get_reg(REG_SP) + 0x10), 0x12345678);
+//         core.exec_arm(&mut mem, decoded).unwrap();
+//         assert_eq!(mem.read_32(core.get_reg(REG_SP) + 0x10), 0x12345678);
+//     }
+// }
diff --git a/src/core/arm7tdmi/mod.rs b/src/core/arm7tdmi/mod.rs
index f20c9cc..6202c22 100644
--- a/src/core/arm7tdmi/mod.rs
+++ b/src/core/arm7tdmi/mod.rs
@@ -198,11 +198,3 @@ impl fmt::Display for CpuError {
 }
 
 pub type CpuResult<T> = Result<T, CpuError>;
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}
diff --git a/src/core/arm7tdmi/thumb/mod.rs b/src/core/arm7tdmi/thumb/mod.rs
index 82539d3..b823363 100644
--- a/src/core/arm7tdmi/thumb/mod.rs
+++ b/src/core/arm7tdmi/thumb/mod.rs
@@ -340,126 +340,126 @@ impl ThumbInstruction {
     }
 }
 
-#[cfg(test)]
-/// All instructions constants were generated using an ARM assembler.
-mod tests {
-    use super::super::Core;
-    use super::*;
-    use crate::core::sysbus::BoxedMemory;
-    use crate::core::Bus;
+// #[cfg(test)]
+// /// All instructions constants were generated using an ARM assembler.
+// mod tests {
+//     use super::super::Core;
+//     use super::*;
+//     use crate::core::sysbus::BoxedMemory;
+//     use crate::core::Bus;
 
-    #[test]
-    fn mov_low_reg() {
-        let bytes = vec![];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
-        let mut core = Core::new();
-        core.set_reg(0, 0);
+//     #[test]
+//     fn mov_low_reg() {
+//         let bytes = vec![];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         let mut core = Core::new();
+//         core.set_reg(0, 0);
 
-        // movs r0, #0x27
-        let insn = ThumbInstruction::decode(0x2027, 0).unwrap();
+//         // movs r0, #0x27
+//         let insn = ThumbInstruction::decode(0x2027, 0).unwrap();
 
-        assert_eq!(format!("{}", insn), "mov\tr0, #0x27");
-        core.exec_thumb(&mut mem, insn).unwrap();
-        assert_eq!(core.get_reg(0), 0x27);
-    }
+//         assert_eq!(format!("{}", insn), "mov\tr0, #0x27");
+//         core.exec_thumb(&mut mem, insn).unwrap();
+//         assert_eq!(core.get_reg(0), 0x27);
+//     }
 
-    // #[test]
-    // fn decode_add_sub() {
-    //     let insn = ThumbInstruction::decode(0xac19, 0).unwrap();
-    //     assert!(format!("add\tr4, r4"))
-    // }
+//     // #[test]
+//     // fn decode_add_sub() {
+//     //     let insn = ThumbInstruction::decode(0xac19, 0).unwrap();
+//     //     assert!(format!("add\tr4, r4"))
+//     // }
 
-    #[test]
-    fn ldr_pc() {
-        // ldr r0, [pc, #4]
-        let insn = ThumbInstruction::decode(0x4801, 0x6).unwrap();
+//     #[test]
+//     fn ldr_pc() {
+//         // ldr r0, [pc, #4]
+//         let insn = ThumbInstruction::decode(0x4801, 0x6).unwrap();
 
-        #[rustfmt::skip]
-        let bytes = vec![
-            /* 0: */ 0x00, 0x00,
-            /* 2: */ 0x00, 0x00,
-            /* 4: */ 0x00, 0x00,
-            /* 6: <pc> */ 0x00, 0x00,
-            /* 8: */ 0x00, 0x00, 0x00, 0x00,
-            /* c: */ 0x78, 0x56, 0x34, 0x12,
-        ];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
-        let mut core = Core::new();
-        core.set_reg(0, 0);
+//         #[rustfmt::skip]
+//         let bytes = vec![
+//             /* 0: */ 0x00, 0x00,
+//             /* 2: */ 0x00, 0x00,
+//             /* 4: */ 0x00, 0x00,
+//             /* 6: <pc> */ 0x00, 0x00,
+//             /* 8: */ 0x00, 0x00, 0x00, 0x00,
+//             /* c: */ 0x78, 0x56, 0x34, 0x12,
+//         ];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         let mut core = Core::new();
+//         core.set_reg(0, 0);
 
-        assert_eq!(format!("{}", insn), "ldr\tr0, [pc, #0x4] ; = #0xc");
-        core.exec_thumb(&mut mem, insn).unwrap();
-        assert_eq!(core.get_reg(0), 0x12345678);
-    }
+//         assert_eq!(format!("{}", insn), "ldr\tr0, [pc, #0x4] ; = #0xc");
+//         core.exec_thumb(&mut mem, insn).unwrap();
+//         assert_eq!(core.get_reg(0), 0x12345678);
+//     }
 
-    #[test]
-    fn ldr_str_reg_offset() {
-        // str	r0, [r4, r1]
-        let str_insn = ThumbInstruction::decode(0x5060, 0x6).unwrap();
-        // ldrb r2, [r4, r1]
-        let ldr_insn = ThumbInstruction::decode(0x5c62, 0x6).unwrap();
+//     #[test]
+//     fn ldr_str_reg_offset() {
+//         // str	r0, [r4, r1]
+//         let str_insn = ThumbInstruction::decode(0x5060, 0x6).unwrap();
+//         // ldrb r2, [r4, r1]
+//         let ldr_insn = ThumbInstruction::decode(0x5c62, 0x6).unwrap();
 
-        let mut core = Core::new();
-        core.set_reg(0, 0x12345678);
-        core.set_reg(2, 0);
-        core.set_reg(1, 0x4);
-        core.set_reg(4, 0xc);
+//         let mut core = Core::new();
+//         core.set_reg(0, 0x12345678);
+//         core.set_reg(2, 0);
+//         core.set_reg(1, 0x4);
+//         core.set_reg(4, 0xc);
 
-        #[rustfmt::skip]
-        let bytes = vec![
-            /* 00h: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 04h: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 08h: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 0ch: */ 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 10h: */ 0xaa, 0xbb, 0xcc, 0xdd,
-        ];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//         #[rustfmt::skip]
+//         let bytes = vec![
+//             /* 00h: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 04h: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 08h: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 0ch: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 10h: */ 0xaa, 0xbb, 0xcc, 0xdd,
+//         ];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        assert_eq!(format!("{}", str_insn), "str\tr0, [r4, r1]");
-        assert_eq!(format!("{}", ldr_insn), "ldrb\tr2, [r4, r1]");
-        core.exec_thumb(&mut mem, str_insn).unwrap();
-        assert_eq!(mem.read_32(0x10), 0x12345678);
-        core.exec_thumb(&mut mem, ldr_insn).unwrap();
-        assert_eq!(core.get_reg(2), 0x78);
-    }
+//         assert_eq!(format!("{}", str_insn), "str\tr0, [r4, r1]");
+//         assert_eq!(format!("{}", ldr_insn), "ldrb\tr2, [r4, r1]");
+//         core.exec_thumb(&mut mem, str_insn).unwrap();
+//         assert_eq!(mem.read_32(0x10), 0x12345678);
+//         core.exec_thumb(&mut mem, ldr_insn).unwrap();
+//         assert_eq!(core.get_reg(2), 0x78);
+//     }
 
-    #[allow(overflowing_literals)]
-    #[test]
-    fn format8() {
-        let mut core = Core::new();
-        #[rustfmt::skip]
-        let bytes = vec![
-            /* 00h: */ 0xaa, 0xbb, 0xcc, 0xdd, 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 08h: */ 0xaa, 0xbb, 0xcc, 0xdd, 0xaa, 0xbb, 0xcc, 0xdd,
-            /* 10h: */ 0xaa, 0xbb, 0xcc, 0xdd, 0xaa, 0xbb, 0xcc, 0xdd,
-        ];
-        let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
+//     #[allow(overflowing_literals)]
+//     #[test]
+//     fn format8() {
+//         let mut core = Core::new();
+//         #[rustfmt::skip]
+//         let bytes = vec![
+//             /* 00h: */ 0xaa, 0xbb, 0xcc, 0xdd, 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 08h: */ 0xaa, 0xbb, 0xcc, 0xdd, 0xaa, 0xbb, 0xcc, 0xdd,
+//             /* 10h: */ 0xaa, 0xbb, 0xcc, 0xdd, 0xaa, 0xbb, 0xcc, 0xdd,
+//         ];
+//         let mut mem = BoxedMemory::new(bytes.into_boxed_slice(), 0xffff_ffff);
 
-        core.gpr[4] = 0x12345678;
-        core.gpr[3] = 0x2;
-        core.gpr[0] = 0x4;
-        // strh r4, [r3, r0]
-        let decoded = ThumbInstruction::decode(0x521c, 0).unwrap();
-        assert_eq!(format!("{}", decoded), "strh\tr4, [r3, r0]");
-        core.exec_thumb(&mut mem, decoded).unwrap();
-        assert_eq!(&mem.get_bytes(0x6)[..4], [0x78, 0x56, 0xaa, 0xbb]);
+//         core.gpr[4] = 0x12345678;
+//         core.gpr[3] = 0x2;
+//         core.gpr[0] = 0x4;
+//         // strh r4, [r3, r0]
+//         let decoded = ThumbInstruction::decode(0x521c, 0).unwrap();
+//         assert_eq!(format!("{}", decoded), "strh\tr4, [r3, r0]");
+//         core.exec_thumb(&mut mem, decoded).unwrap();
+//         assert_eq!(&mem.get_bytes(0x6)[..4], [0x78, 0x56, 0xaa, 0xbb]);
 
-        // ldsb r2, [r7, r1]
-        core.gpr[2] = 0;
-        core.gpr[7] = 0x10;
-        core.gpr[1] = 0x5;
-        let decoded = ThumbInstruction::decode(0x567a, 0).unwrap();
-        assert_eq!(format!("{}", decoded), "ldsb\tr2, [r7, r1]");
-        core.exec_thumb(&mut mem, decoded).unwrap();
-        assert_eq!(core.gpr[2], mem.read_8(0x15) as i8 as u32);
+//         // ldsb r2, [r7, r1]
+//         core.gpr[2] = 0;
+//         core.gpr[7] = 0x10;
+//         core.gpr[1] = 0x5;
+//         let decoded = ThumbInstruction::decode(0x567a, 0).unwrap();
+//         assert_eq!(format!("{}", decoded), "ldsb\tr2, [r7, r1]");
+//         core.exec_thumb(&mut mem, decoded).unwrap();
+//         assert_eq!(core.gpr[2], mem.read_8(0x15) as i8 as u32);
 
-        // ldsh r3, [r4, r2]
-        core.gpr[3] = 0x0;
-        core.gpr[4] = 0x0;
-        core.gpr[2] = 0x6;
-        let decoded = ThumbInstruction::decode(0x5ea3, 0).unwrap();
-        assert_eq!(format!("{}", decoded), "ldsh\tr3, [r4, r2]");
-        core.exec_thumb(&mut mem, decoded).unwrap();
-        assert_eq!(core.gpr[3], 0x5678);
-    }
-}
+//         // ldsh r3, [r4, r2]
+//         core.gpr[3] = 0x0;
+//         core.gpr[4] = 0x0;
+//         core.gpr[2] = 0x6;
+//         let decoded = ThumbInstruction::decode(0x5ea3, 0).unwrap();
+//         assert_eq!(format!("{}", decoded), "ldsh\tr3, [r4, r2]");
+//         core.exec_thumb(&mut mem, decoded).unwrap();
+//         assert_eq!(core.gpr[3], 0x5678);
+//     }
+// }