diff --git a/src/interpreter/computer.rs b/src/interpreter/computer.rs
index 91a2bdf..28af901 100644
--- a/src/interpreter/computer.rs
+++ b/src/interpreter/computer.rs
@@ -6,7 +6,7 @@ use super::{flags::Flags, interpreter::InterpreterError, memory::Memory, registe
 
 /// Wrapper for easier argument passing of polymorph arithmetic operations.
 #[derive(Debug, Clone)]
-pub enum Operand {
+pub enum ArithmeticOperand {
     Immediate(crate::operands::ImmediateOperand),
     ModRmTarget(ModRmTarget),
 }
@@ -61,7 +61,7 @@ impl Computer {
     }
 
     /// Perform binary `dest` = `dest` + `src`. Sets flags.
-    pub fn add(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn add(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
             flags.cf = result < rhs;
@@ -74,7 +74,7 @@ impl Computer {
     }
 
     /// Perform binary `dest` = `dest` - `src`. Sets flags.
-    pub fn sub(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn sub(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
             flags.cf = lhs < rhs;
@@ -87,7 +87,7 @@ impl Computer {
     }
 
     /// Perform binary `dest` = `dest` | `src`. Sets flags.
-    pub fn or(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn or(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs | rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
             flags.cf = false;
@@ -100,7 +100,7 @@ impl Computer {
     }
 
     /// Perform binary `dest` = `dest` & `src`. Sets flags.
-    pub fn and(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn and(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs & rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _rhs| {
             flags.cf = false;
@@ -113,7 +113,7 @@ impl Computer {
     }
 
     /// Perform binary `dest` = `dest` ^ `src`. Sets flags.
-    pub fn xor(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn xor(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs ^ rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
             flags.cf = false;
@@ -127,7 +127,7 @@ impl Computer {
 
     /// Perform compare operation, which acts like [`Self::sub()`], but without
     /// saving the result and only setting [`Self::flags`].
-    pub fn cmp(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn cmp(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
             flags.cf = lhs < rhs;
@@ -141,7 +141,7 @@ impl Computer {
 
     /// Perform test operation, which acts like [`Self::and()`], but without
     /// saving the result and only setting [`Self::flags`].
-    pub fn test(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn test(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs & rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, _, _| {
             flags.cf = false;
@@ -154,15 +154,19 @@ impl Computer {
     }
 
     /// Perform `dest` = `dest` + `src` + CF. Sets flags.
-    pub fn adc(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn adc(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let cf = self.flags.cf as u8;
         // cheating, by flattening into immediates, but this allows to easily add the opt. carry
         let src_with_carry = match src {
-            Operand::Immediate(immediate_operand) => Operand::Immediate(immediate_operand + cf),
-            Operand::ModRmTarget(mod_rm_target) => Operand::Immediate(match mod_rm_target {
-                ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
-                ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
-            }),
+            ArithmeticOperand::Immediate(immediate_operand) => {
+                ArithmeticOperand::Immediate(immediate_operand + cf)
+            }
+            ArithmeticOperand::ModRmTarget(mod_rm_target) => {
+                ArithmeticOperand::Immediate(match mod_rm_target {
+                    ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
+                    ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
+                })
+            }
         };
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs + rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
@@ -176,15 +180,19 @@ impl Computer {
     }
 
     /// Perform `dest` = `dest` - (`src` + CF). Sets flags.
-    pub fn sbb(&mut self, dest: ModRmTarget, src: Operand) {
+    pub fn sbb(&mut self, dest: ModRmTarget, src: ArithmeticOperand) {
         let cf = self.flags.cf as u8;
         // cheating, by flattening into immediates, but this allows to easily add the opt. carry
         let src_with_carry = match src {
-            Operand::Immediate(immediate_operand) => Operand::Immediate(immediate_operand + cf),
-            Operand::ModRmTarget(mod_rm_target) => Operand::Immediate(match mod_rm_target {
-                ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
-                ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
-            }),
+            ArithmeticOperand::Immediate(immediate_operand) => {
+                ArithmeticOperand::Immediate(immediate_operand + cf)
+            }
+            ArithmeticOperand::ModRmTarget(mod_rm_target) => {
+                ArithmeticOperand::Immediate(match mod_rm_target {
+                    ModRmTarget::Memory(idx) => self.memory.read(&self.regs, idx) + cf,
+                    ModRmTarget::Register(reg) => self.regs.read(reg) + cf,
+                })
+            }
         };
         let op: fn(Lhs, Rhs) -> ArithmeticResult = |lhs, rhs| lhs - rhs;
         let flag_set: fn(&mut Flags, ArithmeticResult, Lhs, Rhs) = |flags, result, lhs, rhs| {
@@ -201,15 +209,21 @@ impl Computer {
     /// it to `dest`, if `write` is set, and sets flags, according to [`F`].
     /// A result can never be saved to an immediate Operand, so `dest` can only
     /// be a [`ModRmTarget`].
-    fn op<O, F>(&mut self, op: O, flag_set: F, write: bool, dest: ModRmTarget, src: Operand)
-    where
+    fn op<O, F>(
+        &mut self,
+        op: O,
+        flag_set: F,
+        write: bool,
+        dest: ModRmTarget,
+        src: ArithmeticOperand,
+    ) where
         O: Fn(Lhs, Rhs) -> ArithmeticResult,
         F: Fn(&mut Flags, ArithmeticResult, Lhs, Rhs),
     {
         let lhs = self.read_modrm(dest);
         let rhs = match src {
-            Operand::Immediate(imm) => imm,
-            Operand::ModRmTarget(target) => self.read_modrm(target),
+            ArithmeticOperand::Immediate(imm) => imm,
+            ArithmeticOperand::ModRmTarget(target) => self.read_modrm(target),
         };
         let result = op(lhs, rhs);
         if write {
diff --git a/src/interpreter/interpreter.rs b/src/interpreter/interpreter.rs
index e5242a2..077a634 100644
--- a/src/interpreter/interpreter.rs
+++ b/src/interpreter/interpreter.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 
 use super::{
-    computer::{Computer, Operand},
+    computer::{ArithmeticOperand, Computer},
     interrupt::InterruptMessage,
 };
 
@@ -78,25 +78,29 @@ impl Interpreter {
                 /*
                  * ADD
                  */
-                Mnemonic::ADD_FromReg(dest, src) => self
-                    .computer
-                    .add(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::ADD_ToReg(src, dest) => self
-                    .computer
-                    .add(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::ADD_Ib(dest, src) => self
-                    .computer
-                    .add(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::ADD_Iv(dest, src) => self
-                    .computer
-                    .add(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::ADD_FromReg(dest, src) => self.computer.add(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::ADD_ToReg(src, dest) => self.computer.add(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::ADD_Ib(dest, src) => self.computer.add(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::ADD_Iv(dest, src) => self.computer.add(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::ADD_ALIb(src_byte) => self.computer.add(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::ADD_AXIv(src_word) => self.computer.add(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
                 /*
                  * PUSH
@@ -117,97 +121,113 @@ impl Interpreter {
                 /*
                  * OR
                  */
-                Mnemonic::OR_FromReg(dest, src) => self
-                    .computer
-                    .or(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::OR_ToReg(src, dest) => self
-                    .computer
-                    .or(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::OR_Ib(dest, src) => self
-                    .computer
-                    .or(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::OR_Iv(dest, src) => self
-                    .computer
-                    .or(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::OR_FromReg(dest, src) => self.computer.or(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::OR_ToReg(src, dest) => self.computer.or(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::OR_Ib(dest, src) => self.computer.or(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::OR_Iv(dest, src) => self.computer.or(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::OR_ALIb(src_byte) => self.computer.or(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::OR_AXIv(src_word) => self.computer.or(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*
                  * ADC - add with carry
                  */
-                Mnemonic::ADC_FromReg(dest, src) => self
-                    .computer
-                    .adc(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::ADC_ToReg(src, dest) => self
-                    .computer
-                    .adc(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::ADC_Ib(dest, src) => self
-                    .computer
-                    .adc(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::ADC_Iv(dest, src) => self
-                    .computer
-                    .adc(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::ADC_FromReg(dest, src) => self.computer.adc(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::ADC_ToReg(src, dest) => self.computer.adc(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::ADC_Ib(dest, src) => self.computer.adc(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::ADC_Iv(dest, src) => self.computer.adc(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::ADC_ALIb(src_byte) => self.computer.adc(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::ADC_AXIv(src_word) => self.computer.adc(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*
                  * SBB - subtract with borrow
                  */
-                Mnemonic::SBB_FromReg(dest, src) => self
-                    .computer
-                    .sbb(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::SBB_ToReg(src, dest) => self
-                    .computer
-                    .sbb(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::SBB_Ib(dest, src) => self
-                    .computer
-                    .sbb(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::SBB_Iv(dest, src) => self
-                    .computer
-                    .sbb(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::SBB_FromReg(dest, src) => self.computer.sbb(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::SBB_ToReg(src, dest) => self.computer.sbb(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::SBB_Ib(dest, src) => self.computer.sbb(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::SBB_Iv(dest, src) => self.computer.sbb(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::SBB_ALIb(src_byte) => self.computer.sbb(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::SBB_AXIv(src_word) => self.computer.sbb(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*
                  * AND
                  */
-                Mnemonic::AND_FromReg(dest, src) => self
-                    .computer
-                    .and(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::AND_ToReg(src, dest) => self
-                    .computer
-                    .and(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::AND_Ib(dest, src) => self
-                    .computer
-                    .and(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::AND_Iv(dest, src) => self
-                    .computer
-                    .and(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::AND_FromReg(dest, src) => self.computer.and(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::AND_ToReg(src, dest) => self.computer.and(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::AND_Ib(dest, src) => self.computer.and(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::AND_Iv(dest, src) => self.computer.and(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::AND_ALIb(src_byte) => self.computer.and(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::AND_AXIv(src_word) => self.computer.and(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
                 /*
                  * Override
@@ -220,73 +240,85 @@ impl Interpreter {
                 /*
                  * SUB
                  */
-                Mnemonic::SUB_FromReg(dest, src) => self
-                    .computer
-                    .sub(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::SUB_ToReg(src, dest) => self
-                    .computer
-                    .sub(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::SUB_Ib(dest, src) => self
-                    .computer
-                    .sub(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::SUB_Iv(dest, src) => self
-                    .computer
-                    .sub(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::SUB_FromReg(dest, src) => self.computer.sub(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::SUB_ToReg(src, dest) => self.computer.sub(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::SUB_Ib(dest, src) => self.computer.sub(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::SUB_Iv(dest, src) => self.computer.sub(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::SUB_ALIb(src_byte) => self.computer.sub(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::SUB_AXIv(src_word) => self.computer.sub(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*
                  * XOR
                  */
-                Mnemonic::XOR_FromReg(dest, src) => self
-                    .computer
-                    .xor(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::XOR_ToReg(src, dest) => self
-                    .computer
-                    .xor(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::XOR_Ib(dest, src) => self
-                    .computer
-                    .xor(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::XOR_Iv(dest, src) => self
-                    .computer
-                    .xor(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::XOR_FromReg(dest, src) => self.computer.xor(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::XOR_ToReg(src, dest) => self.computer.xor(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::XOR_Ib(dest, src) => self.computer.xor(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::XOR_Iv(dest, src) => self.computer.xor(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::XOR_ALIb(src_byte) => self.computer.xor(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::XOR_AXIv(src_word) => self.computer.xor(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*
                  * CMP
                  */
-                Mnemonic::CMP_FromReg(dest, src) => self
-                    .computer
-                    .cmp(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::CMP_ToReg(src, dest) => self
-                    .computer
-                    .cmp(ModRmTarget::Register(dest), Operand::ModRmTarget(src)),
-                Mnemonic::CMP_Ib(dest, src) => self
-                    .computer
-                    .cmp(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::CMP_Iv(dest, src) => self
-                    .computer
-                    .cmp(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::CMP_FromReg(dest, src) => self.computer.cmp(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::CMP_ToReg(src, dest) => self.computer.cmp(
+                    ModRmTarget::Register(dest),
+                    ArithmeticOperand::ModRmTarget(src),
+                ),
+                Mnemonic::CMP_Ib(dest, src) => self.computer.cmp(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::CMP_Iv(dest, src) => self.computer.cmp(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::CMP_ALIb(src_byte) => self.computer.cmp(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::CMP_AXIv(src_word) => self.computer.cmp(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*
@@ -385,22 +417,25 @@ impl Interpreter {
                 /*
                  * Test
                  */
-                Mnemonic::TEST(dest, src) => self
-                    .computer
-                    .test(dest, Operand::ModRmTarget(ModRmTarget::Register(src))),
-                Mnemonic::TEST_Ib(dest, src) => self
-                    .computer
-                    .test(dest, Operand::Immediate(ImmediateOperand::Byte(src))),
-                Mnemonic::TEST_Iv(dest, src) => self
-                    .computer
-                    .test(dest, Operand::Immediate(ImmediateOperand::Word(src))),
+                Mnemonic::TEST(dest, src) => self.computer.test(
+                    dest,
+                    ArithmeticOperand::ModRmTarget(ModRmTarget::Register(src)),
+                ),
+                Mnemonic::TEST_Ib(dest, src) => self.computer.test(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src)),
+                ),
+                Mnemonic::TEST_Iv(dest, src) => self.computer.test(
+                    dest,
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src)),
+                ),
                 Mnemonic::TEST_ALIb(src_byte) => self.computer.test(
                     ModRmTarget::Register(crate::register::Register::AL),
-                    Operand::Immediate(ImmediateOperand::Byte(src_byte)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Byte(src_byte)),
                 ),
                 Mnemonic::TEST_AXIv(src_word) => self.computer.test(
                     ModRmTarget::Register(crate::register::Register::AX),
-                    Operand::Immediate(ImmediateOperand::Word(src_word)),
+                    ArithmeticOperand::Immediate(ImmediateOperand::Word(src_word)),
                 ),
 
                 /*