diff --git a/projects/reloaded-hooks-portable/src/optimize/decompose_push_pop_operations.rs b/projects/reloaded-hooks-portable/src/optimize/decompose_push_pop_operations.rs
index 3529929..f3ee793 100644
--- a/projects/reloaded-hooks-portable/src/optimize/decompose_push_pop_operations.rs
+++ b/projects/reloaded-hooks-portable/src/optimize/decompose_push_pop_operations.rs
@@ -206,7 +206,7 @@ pub(crate) fn decompose_pop_operations_ex<TRegister: Copy + Clone + RegisterInfo
 
 fn do_decompose_pops<TRegister: Clone + Copy>(
     operations: &mut Vec<Operation<TRegister>>,
-    mut ops: &mut SmallVec<[Operation<TRegister>; 16]>,
+    ops: &mut SmallVec<[Operation<TRegister>; 16]>,
     stack_size: &mut isize,
     last_stackalloc_val: i32,
     last_stackalloc_idx: usize,
@@ -214,7 +214,7 @@ fn do_decompose_pops<TRegister: Clone + Copy>(
 ) {
     let is_stackalloc = last_stackalloc_idx == first_pop_idx - 1;
     let stackalloc_offset = is_stackalloc as i32 * last_stackalloc_val;
-    update_mov_from_stack_offsets(&mut ops, last_stackalloc_val, is_stackalloc);
+    update_mov_from_stack_offsets(ops, last_stackalloc_val, is_stackalloc);
 
     // Emit stackalloc for the writes we just made.
     let stackalloc_ofs = -*stack_size as i32 + stackalloc_offset;
diff --git a/projects/reloaded-hooks-x86-sys/src/common/jit_common.rs b/projects/reloaded-hooks-x86-sys/src/common/jit_common.rs
index 756b56c..a239742 100644
--- a/projects/reloaded-hooks-x86-sys/src/common/jit_common.rs
+++ b/projects/reloaded-hooks-x86-sys/src/common/jit_common.rs
@@ -1,7 +1,5 @@
 extern crate alloc;
-
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::alloc::string::ToString;
 use crate::instructions::{
     call_absolute::encode_call_absolute, call_relative::encode_call_relative,
     jump_absolute::encode_jump_absolute, jump_absolute_indirect::encode_jump_absolute_indirect,
@@ -10,6 +8,7 @@ use crate::instructions::{
     push_const::encode_push_constant, push_stack::encode_push_stack, ret::encode_return,
     stack_alloc::encode_stack_alloc, xchg::encode_xchg,
 };
+use alloc::string::ToString;
 
 #[cfg(target_feature = "multipushpop")]
 use crate::instructions::multi_pop::encode_multi_pop;
@@ -34,29 +33,29 @@ pub(crate) fn encode_instruction(
     address: usize,
 ) -> Result<(), JitError<AllRegisters>> {
     match operation {
-        Operation::Mov(x) => encode_mov(assembler, x),
-        Operation::MovFromStack(x) => encode_mov_from_stack(assembler, x),
-        Operation::Push(x) => encode_push(assembler, x),
-        Operation::PushStack(x) => encode_push_stack(assembler, x),
-        Operation::StackAlloc(x) => encode_stack_alloc(assembler, x),
-        Operation::Pop(x) => encode_pop(assembler, x),
-        Operation::Xchg(x) => encode_xchg(assembler, x),
-        Operation::CallRelative(x) => encode_call_relative(assembler, x),
-        Operation::CallAbsolute(x) => encode_call_absolute(assembler, x),
-        Operation::JumpRelative(x) => encode_jump_relative(assembler, x),
-        Operation::JumpAbsolute(x) => encode_jump_absolute(assembler, x),
-        Operation::JumpAbsoluteIndirect(x) => encode_jump_absolute_indirect(assembler, x),
-        Operation::MovToStack(x) => encode_mov_to_stack(assembler, x),
+        Operation::Mov(x) => Ok(encode_mov(assembler, x)?),
+        Operation::MovFromStack(x) => Ok(encode_mov_from_stack(assembler, x)?),
+        Operation::Push(x) => Ok(encode_push(assembler, x)?),
+        Operation::PushStack(x) => Ok(encode_push_stack(assembler, x)?),
+        Operation::StackAlloc(x) => Ok(encode_stack_alloc(assembler, x)?),
+        Operation::Pop(x) => Ok(encode_pop(assembler, x)?),
+        Operation::Xchg(x) => Ok(encode_xchg(assembler, x)?),
+        Operation::CallRelative(x) => Ok(encode_call_relative(assembler, x)?),
+        Operation::CallAbsolute(x) => Ok(encode_call_absolute(assembler, x)?),
+        Operation::JumpRelative(x) => Ok(encode_jump_relative(assembler, x)?),
+        Operation::JumpAbsolute(x) => Ok(encode_jump_absolute(assembler, x)?),
+        Operation::JumpAbsoluteIndirect(x) => Ok(encode_jump_absolute_indirect(assembler, x)?),
+        Operation::MovToStack(x) => Ok(encode_mov_to_stack(assembler, x)?),
 
         // x64 only
         #[cfg(feature = "x64")]
-        Operation::CallIpRelative(x) => encode_call_ip_relative(assembler, x, address),
+        Operation::CallIpRelative(x) => Ok(encode_call_ip_relative(assembler, x, address)?),
         #[cfg(feature = "x64")]
-        Operation::JumpIpRelative(x) => encode_jump_ip_relative(assembler, x, address),
+        Operation::JumpIpRelative(x) => Ok(encode_jump_ip_relative(assembler, x, address)?),
 
         // Optimised Functions
-        Operation::PushConst(x) => encode_push_constant(assembler, x),
-        Operation::Return(x) => encode_return(assembler, x),
+        Operation::PushConst(x) => Ok(encode_push_constant(assembler, x)?),
+        Operation::Return(x) => Ok(encode_return(assembler, x)?),
 
         // Deprecated
         #[cfg(target_feature = "multipushpop")]
@@ -68,6 +67,28 @@ pub(crate) fn encode_instruction(
     }
 }
 
-pub(crate) fn convert_error(e: IcedError) -> JitError<AllRegisters> {
-    JitError::ThirdPartyAssemblerError(e.to_string())
+pub enum X86jitError<T> {
+    IcedError(IcedError),
+    JitError(JitError<T>),
+}
+
+impl<T> From<IcedError> for X86jitError<T> {
+    fn from(e: IcedError) -> Self {
+        Self::IcedError(e)
+    }
+}
+
+impl<T> From<JitError<T>> for X86jitError<T> {
+    fn from(e: JitError<T>) -> Self {
+        Self::JitError(e)
+    }
+}
+
+impl<T> From<X86jitError<T>> for JitError<T> {
+    fn from(val: X86jitError<T>) -> Self {
+        match val {
+            X86jitError::JitError(e) => e,
+            X86jitError::IcedError(e) => JitError::ThirdPartyAssemblerError(e.to_string()),
+        }
+    }
 }
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/call_absolute.rs b/projects/reloaded-hooks-x86-sys/src/instructions/call_absolute.rs
index a94a2b3..69f231f 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/call_absolute.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/call_absolute.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::{X86jitError, ARCH_NOT_SUPPORTED};
 use alloc::string::ToString;
 use iced_x86::code_asm::CodeAssembler;
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::CallAbs};
@@ -9,24 +9,20 @@ use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::C
 pub(crate) fn encode_call_absolute(
     a: &mut CodeAssembler,
     x: &CallAbs<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if a.bitness() == 64 && cfg!(feature = "x64") {
         #[cfg(feature = "x64")]
         {
             let target_reg = x.scratch_register.as_iced_64()?;
-            a.mov(target_reg, x.target_address as u64)
-                .map_err(convert_error)?;
-            a.call(target_reg).map_err(convert_error)?;
+            a.mov(target_reg, x.target_address as u64)?;
+            a.call(target_reg)?;
         }
     } else if a.bitness() == 32 && cfg!(feature = "x86") {
         let target_reg = x.scratch_register.as_iced_32()?;
-        a.mov(target_reg, x.target_address as u32)
-            .map_err(convert_error)?;
-        a.call(target_reg).map_err(convert_error)?;
+        a.mov(target_reg, x.target_address as u32)?;
+        a.call(target_reg)?;
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/call_ip_relative.rs b/projects/reloaded-hooks-x86-sys/src/instructions/call_ip_relative.rs
index 1755f7a..41bd9d7 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/call_ip_relative.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/call_ip_relative.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::common::jit_common::X86jitError;
 use alloc::string::ToString;
 use iced_x86::code_asm::{qword_ptr, CodeAssembler};
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::CallIpRel};
@@ -11,11 +11,12 @@ pub(crate) fn encode_call_ip_relative(
     a: &mut CodeAssembler,
     x: &CallIpRel<AllRegisters>,
     address: usize,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if a.bitness() == 32 {
         return Err(JitError::ThirdPartyAssemblerError(
             "Call IP Relative is only Supported on 64-bit!".to_string(),
-        ));
+        )
+        .into());
     }
 
     let isns = a.instructions();
@@ -26,8 +27,7 @@ pub(crate) fn encode_call_ip_relative(
     };
 
     let relative_offset = x.target_address.wrapping_sub(current_ip as usize);
-    a.call(qword_ptr(iced_x86::Register::RIP) + relative_offset as i32)
-        .map_err(convert_error)?;
+    a.call(qword_ptr(iced_x86::Register::RIP) + relative_offset as i32)?;
     Ok(())
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/call_relative.rs b/projects/reloaded-hooks-x86-sys/src/instructions/call_relative.rs
index 6e16be2..ef6c71a 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/call_relative.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/call_relative.rs
@@ -1,13 +1,12 @@
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use iced_x86::code_asm::CodeAssembler;
-use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::CallRel};
+use reloaded_hooks_portable::api::jit::operation_aliases::CallRel;
 
 pub(crate) fn encode_call_relative(
     a: &mut CodeAssembler,
     x: &CallRel,
-) -> Result<(), JitError<AllRegisters>> {
-    a.call(x.target_address as u64).map_err(convert_error)?;
+) -> Result<(), X86jitError<AllRegisters>> {
+    a.call(x.target_address as u64)?;
     Ok(())
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute.rs b/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute.rs
index 7fd3fd6..f6161c7 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::ARCH_NOT_SUPPORTED;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use alloc::string::ToString;
 use iced_x86::code_asm::CodeAssembler;
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::JumpAbs};
@@ -9,24 +9,20 @@ use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::J
 pub(crate) fn encode_jump_absolute(
     a: &mut CodeAssembler,
     x: &JumpAbs<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if a.bitness() == 64 && cfg!(feature = "x64") {
         #[cfg(feature = "x64")]
         {
             let target_reg = x.scratch_register.as_iced_64()?;
-            a.mov(target_reg, x.target_address as u64)
-                .map_err(convert_error)?;
-            a.jmp(target_reg).map_err(convert_error)?;
+            a.mov(target_reg, x.target_address as u64)?;
+            a.jmp(target_reg)?;
         }
     } else if a.bitness() == 32 && cfg!(feature = "x86") {
         let target_reg = x.scratch_register.as_iced_32()?;
-        a.mov(target_reg, x.target_address as u32)
-            .map_err(convert_error)?;
-        a.jmp(target_reg).map_err(convert_error)?;
+        a.mov(target_reg, x.target_address as u32)?;
+        a.jmp(target_reg)?;
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute_indirect.rs b/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute_indirect.rs
index 3717f14..c289dcb 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute_indirect.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/jump_absolute_indirect.rs
@@ -1,7 +1,6 @@
 extern crate alloc;
 
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use alloc::string::ToString;
 use iced_x86::code_asm::{dword_ptr, qword_ptr, CodeAssembler};
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::JumpAbsInd};
@@ -9,7 +8,7 @@ use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::J
 pub(crate) fn encode_jump_absolute_indirect(
     a: &mut CodeAssembler,
     x: &JumpAbsInd<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     let mem_op = if a.bitness() == 64 && cfg!(feature = "x64") {
         qword_ptr(x.pointer_address)
     } else if cfg!(feature = "x86") {
@@ -17,10 +16,11 @@ pub(crate) fn encode_jump_absolute_indirect(
     } else {
         return Err(JitError::ThirdPartyAssemblerError(
             "Please use 'x86' or 'x64' library feature".to_string(),
-        ));
+        )
+        .into());
     };
 
-    a.jmp(mem_op).map_err(convert_error)?;
+    a.jmp(mem_op)?;
     Ok(())
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/jump_ip_relative.rs b/projects/reloaded-hooks-x86-sys/src/instructions/jump_ip_relative.rs
index 97f4ec7..f1903cf 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/jump_ip_relative.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/jump_ip_relative.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::common::jit_common::X86jitError;
 use alloc::string::ToString;
 use iced_x86::code_asm::{qword_ptr, CodeAssembler};
 use reloaded_hooks_portable::api::jit::compiler::JitError;
@@ -12,11 +12,12 @@ pub(crate) fn encode_jump_ip_relative(
     a: &mut CodeAssembler,
     x: &JumpIpRel<AllRegisters>,
     address: usize,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if a.bitness() == 32 {
         return Err(JitError::ThirdPartyAssemblerError(
             "Jump IP Relative is only Supported on 64-bit!".to_string(),
-        ));
+        )
+        .into());
     }
 
     let isns = a.instructions();
@@ -27,8 +28,7 @@ pub(crate) fn encode_jump_ip_relative(
     };
 
     let relative_offset = x.target_address.wrapping_sub(current_ip as usize);
-    a.jmp(qword_ptr(iced_x86::Register::RIP) + relative_offset as i32)
-        .map_err(convert_error)?;
+    a.jmp(qword_ptr(iced_x86::Register::RIP) + relative_offset as i32)?;
     Ok(())
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/jump_relative.rs b/projects/reloaded-hooks-x86-sys/src/instructions/jump_relative.rs
index fd03171..7e2dd75 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/jump_relative.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/jump_relative.rs
@@ -1,13 +1,12 @@
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use iced_x86::code_asm::CodeAssembler;
-use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::JumpRel};
+use reloaded_hooks_portable::api::jit::operation_aliases::JumpRel;
 
 pub(crate) fn encode_jump_relative(
     a: &mut CodeAssembler,
     x: &JumpRel<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
-    a.jmp(x.target_address as u64).map_err(convert_error)?;
+) -> Result<(), X86jitError<AllRegisters>> {
+    a.jmp(x.target_address as u64)?;
     Ok(())
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/macros.rs b/projects/reloaded-hooks-x86-sys/src/instructions/macros.rs
index 1e6c61a..a1cecd0 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/macros.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/macros.rs
@@ -8,21 +8,20 @@ macro_rules! mov_item_to_stack {
                 $a.$op(
                     iced_x86::code_asm::dword_ptr(iced_x86::code_asm::registers::esp) + $offset,
                     $reg.$convert_method()?,
-                )
-                .map_err($crate::common::jit_common::convert_error)?;
+                )?;
             }
             #[cfg(feature = "x64")]
             64 => {
                 $a.$op(
                     iced_x86::code_asm::qword_ptr(iced_x86::code_asm::registers::rsp) + $offset,
                     $reg.$convert_method()?,
-                )
-                .map_err($crate::common::jit_common::convert_error)?;
+                )?;
             }
             _ => {
                 return Err(JitError::ThirdPartyAssemblerError(
                     $crate::common::jit_common::ARCH_NOT_SUPPORTED.to_string(),
-                ));
+                )
+                .into());
             }
         }
     };
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/mov.rs b/projects/reloaded-hooks-x86-sys/src/instructions/mov.rs
index 47a9917..0a9fe5b 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/mov.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/mov.rs
@@ -1,12 +1,11 @@
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use iced_x86::code_asm::CodeAssembler;
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::Mov};
 
 pub(crate) fn encode_mov(
     a: &mut CodeAssembler,
     mov: &Mov<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if mov.target.is_32() && mov.source.is_32() {
         a.mov(mov.target.as_iced_32()?, mov.source.as_iced_32()?)
     } else if mov.target.is_64() && mov.source.is_64() && cfg!(feature = "x64") {
@@ -25,9 +24,8 @@ pub(crate) fn encode_mov(
     } else if mov.target.is_zmm() && mov.source.is_zmm() {
         a.vmovaps(mov.target.as_iced_zmm()?, mov.source.as_iced_zmm()?)
     } else {
-        return Err(JitError::InvalidRegisterCombination(mov.source, mov.target));
-    }
-    .map_err(convert_error)?;
+        return Err(JitError::InvalidRegisterCombination(mov.source, mov.target).into());
+    }?;
 
     Ok(())
 }
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/mov_from_stack.rs b/projects/reloaded-hooks-x86-sys/src/instructions/mov_from_stack.rs
index b02f0db..313319f 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/mov_from_stack.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/mov_from_stack.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::{X86jitError, ARCH_NOT_SUPPORTED};
 use alloc::string::ToString;
 use iced_x86::code_asm::{dword_ptr, qword_ptr, CodeAssembler};
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::MovFromStack};
@@ -9,7 +9,7 @@ use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::M
 pub(crate) fn encode_mov_from_stack(
     a: &mut CodeAssembler,
     x: &MovFromStack<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     let base_ptr = if a.bitness() == 64 && cfg!(feature = "x64") {
         qword_ptr(iced_x86::Register::RSP) + x.stack_offset
     } else if cfg!(feature = "x86") {
@@ -17,7 +17,8 @@ pub(crate) fn encode_mov_from_stack(
     } else {
         return Err(JitError::ThirdPartyAssemblerError(
             "Please use 'x86' or 'x64' library feature".to_string(),
-        ));
+        )
+        .into());
     };
 
     if x.target.is_32() {
@@ -38,11 +39,8 @@ pub(crate) fn encode_mov_from_stack(
     } else if x.target.is_zmm() {
         a.vmovups(x.target.as_iced_zmm()?, base_ptr)
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
-    }
-    .map_err(convert_error)?;
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
+    }?;
 
     Ok(())
 }
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/mov_to_stack.rs b/projects/reloaded-hooks-x86-sys/src/instructions/mov_to_stack.rs
index 1ef5ce6..d11413d 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/mov_to_stack.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/mov_to_stack.rs
@@ -1,5 +1,6 @@
 extern crate alloc;
 use crate::all_registers::AllRegisters;
+use crate::common::jit_common::X86jitError;
 use crate::mov_item_to_stack;
 use iced_x86::code_asm::CodeAssembler;
 use reloaded_hooks_portable::api::jit::compiler::JitError;
@@ -8,7 +9,7 @@ use reloaded_hooks_portable::api::jit::mov_to_stack_operation::MovToStackOperati
 pub(crate) fn encode_mov_to_stack(
     a: &mut CodeAssembler,
     x: &MovToStackOperation<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if x.register.is_32() {
         mov_item_to_stack!(a, x.register, x.stack_offset, as_iced_32, mov);
     } else if x.register.is_64() && cfg!(feature = "x64") {
@@ -21,7 +22,7 @@ pub(crate) fn encode_mov_to_stack(
     } else if x.register.is_zmm() {
         mov_item_to_stack!(a, x.register, x.stack_offset, as_iced_zmm, vmovdqu8);
     } else {
-        return Err(JitError::InvalidRegister(x.register));
+        return Err(JitError::InvalidRegister(x.register).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/multi_pop.rs b/projects/reloaded-hooks-x86-sys/src/instructions/multi_pop.rs
index 099b1d1..07fd3f6 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/multi_pop.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/multi_pop.rs
@@ -31,7 +31,7 @@ macro_rules! multi_pop_item {
 pub(crate) fn encode_multi_pop(
     a: &mut CodeAssembler,
     ops: &[Pop<AllRegisters>],
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     // Note: It is important that we do MOV in ascending address order, to help CPU caching :wink:
 
     // Start from the top of the reserved space.
@@ -49,7 +49,7 @@ pub(crate) fn encode_multi_pop(
         } else if x.register.is_zmm() {
             multi_pop_item!(a, x.register, current_offset, as_iced_zmm, vmovdqu8);
         } else {
-            return Err(JitError::InvalidRegister(x.register));
+            return Err(JitError::InvalidRegister(x.register).into());
         }
 
         // Move to the next offset.
@@ -59,15 +59,11 @@ pub(crate) fn encode_multi_pop(
     // Release the space.
     let total_space = ops.iter().map(|x| x.register.size()).sum::<usize>();
     if a.bitness() == 32 && cfg!(feature = "x86") {
-        a.add(iced_regs::esp, total_space as i32)
-            .map_err(convert_error)?;
+        a.add(iced_regs::esp, total_space as i32)?;
     } else if a.bitness() == 64 && cfg!(feature = "x64") {
-        a.add(iced_regs::rsp, total_space as i32)
-            .map_err(convert_error)?;
+        a.add(iced_regs::rsp, total_space as i32)?;
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/multi_push.rs b/projects/reloaded-hooks-x86-sys/src/instructions/multi_push.rs
index 28e6eed..19a9f93 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/multi_push.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/multi_push.rs
@@ -11,7 +11,7 @@ use reloaded_hooks_portable::api::jit::operation_aliases::Push;
 pub(crate) fn encode_multi_push(
     a: &mut CodeAssembler,
     ops: &[Push<AllRegisters>],
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     // Calculate space to reserve.
     let mut space_needed = 0;
 
@@ -21,15 +21,11 @@ pub(crate) fn encode_multi_push(
 
     // Reserve the space.
     if a.bitness() == 64 && cfg!(feature = "x64") {
-        a.sub(iced_regs::rsp, space_needed as i32)
-            .map_err(convert_error)?;
+        a.sub(iced_regs::rsp, space_needed as i32)?;
     } else if a.bitness() == 32 && cfg!(feature = "x86") {
-        a.sub(iced_regs::esp, space_needed as i32)
-            .map_err(convert_error)?;
+        a.sub(iced_regs::esp, space_needed as i32)?;
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
     }
 
     // Push the items.
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/pop.rs b/projects/reloaded-hooks-x86-sys/src/instructions/pop.rs
index 556e004..3d40bcc 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/pop.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/pop.rs
@@ -1,7 +1,8 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::X86jitError;
+use crate::common::jit_common::ARCH_NOT_SUPPORTED;
 use alloc::string::ToString;
 use iced_x86::code_asm::{dword_ptr, qword_ptr, registers as iced_regs, CodeAssembler};
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::Pop};
@@ -9,19 +10,13 @@ use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::P
 macro_rules! encode_xmm_pop {
     ($a:expr, $reg:expr, $reg_type:ident, $op:ident) => {
         if $a.bitness() == 32 && cfg!(feature = "x86") {
-            $a.$op($reg.$reg_type()?, dword_ptr(iced_regs::esp))
-                .map_err(convert_error)?;
-            $a.add(iced_regs::esp, $reg.size() as i32)
-                .map_err(convert_error)?;
+            $a.$op($reg.$reg_type()?, dword_ptr(iced_regs::esp))?;
+            $a.add(iced_regs::esp, $reg.size() as i32)?;
         } else if $a.bitness() == 64 && cfg!(feature = "x64") {
-            $a.$op($reg.$reg_type()?, qword_ptr(iced_regs::rsp))
-                .map_err(convert_error)?;
-            $a.add(iced_regs::rsp, $reg.size() as i32)
-                .map_err(convert_error)?;
+            $a.$op($reg.$reg_type()?, qword_ptr(iced_regs::rsp))?;
+            $a.add(iced_regs::rsp, $reg.size() as i32)?;
         } else {
-            return Err(JitError::ThirdPartyAssemblerError(
-                ARCH_NOT_SUPPORTED.to_string(),
-            ));
+            return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
         }
     };
 }
@@ -29,12 +24,12 @@ macro_rules! encode_xmm_pop {
 pub(crate) fn encode_pop(
     a: &mut CodeAssembler,
     pop: &Pop<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if pop.register.is_32() {
-        a.pop(pop.register.as_iced_32()?).map_err(convert_error)?;
+        a.pop(pop.register.as_iced_32()?)?;
     } else if pop.register.is_64() && cfg!(feature = "x64") {
         #[cfg(feature = "x64")]
-        a.pop(pop.register.as_iced_64()?).map_err(convert_error)?;
+        a.pop(pop.register.as_iced_64()?)?;
     } else if pop.register.is_xmm() {
         encode_xmm_pop!(a, pop.register, as_iced_xmm, movdqu);
     } else if pop.register.is_ymm() {
@@ -42,7 +37,7 @@ pub(crate) fn encode_pop(
     } else if pop.register.is_zmm() {
         encode_xmm_pop!(a, pop.register, as_iced_zmm, vmovdqu8);
     } else {
-        return Err(JitError::InvalidRegister(pop.register));
+        return Err(JitError::InvalidRegister(pop.register).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/push.rs b/projects/reloaded-hooks-x86-sys/src/instructions/push.rs
index e602717..9446a71 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/push.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/push.rs
@@ -1,7 +1,6 @@
 extern crate alloc;
-
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::{X86jitError, ARCH_NOT_SUPPORTED};
 use alloc::string::ToString;
 use iced_x86::code_asm::{dword_ptr, qword_ptr, registers as iced_regs, CodeAssembler};
 use reloaded_hooks_portable::api::jit::compiler::JitError;
@@ -10,19 +9,13 @@ use reloaded_hooks_portable::api::jit::operation_aliases::Push;
 macro_rules! encode_xmm_push {
     ($a:expr, $reg:expr, $reg_type:ident, $op:ident) => {
         if $a.bitness() == 32 && cfg!(feature = "x86") {
-            $a.sub(iced_regs::esp, $reg.size() as i32)
-                .map_err(convert_error)?;
-            $a.$op(dword_ptr(iced_regs::esp), $reg.$reg_type()?)
-                .map_err(convert_error)?;
+            $a.sub(iced_regs::esp, $reg.size() as i32)?;
+            $a.$op(dword_ptr(iced_regs::esp), $reg.$reg_type()?)?;
         } else if $a.bitness() == 64 && cfg!(feature = "x64") {
-            $a.sub(iced_regs::rsp, $reg.size() as i32)
-                .map_err(convert_error)?;
-            $a.$op(qword_ptr(iced_regs::rsp), $reg.$reg_type()?)
-                .map_err(convert_error)?;
+            $a.sub(iced_regs::rsp, $reg.size() as i32)?;
+            $a.$op(qword_ptr(iced_regs::rsp), $reg.$reg_type()?)?;
         } else {
-            return Err(JitError::ThirdPartyAssemblerError(
-                ARCH_NOT_SUPPORTED.to_string(),
-            ));
+            return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
         }
     };
 }
@@ -30,12 +23,12 @@ macro_rules! encode_xmm_push {
 pub(crate) fn encode_push(
     a: &mut CodeAssembler,
     push: &Push<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if push.register.is_32() {
-        a.push(push.register.as_iced_32()?).map_err(convert_error)?;
+        a.push(push.register.as_iced_32()?)?;
     } else if push.register.is_64() && cfg!(feature = "x64") {
         #[cfg(feature = "x64")]
-        a.push(push.register.as_iced_64()?).map_err(convert_error)?;
+        a.push(push.register.as_iced_64()?)?;
     } else if push.register.is_xmm() {
         encode_xmm_push!(a, push.register, as_iced_xmm, movdqu);
     } else if push.register.is_ymm() {
@@ -43,7 +36,7 @@ pub(crate) fn encode_push(
     } else if push.register.is_zmm() {
         encode_xmm_push!(a, push.register, as_iced_zmm, vmovdqu8);
     } else {
-        return Err(JitError::InvalidRegister(push.register));
+        return Err(JitError::InvalidRegister(push.register).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/push_const.rs b/projects/reloaded-hooks-x86-sys/src/instructions/push_const.rs
index 21045d3..888a3cb 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/push_const.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/push_const.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::{X86jitError, ARCH_NOT_SUPPORTED};
 use alloc::string::ToString;
 use iced_x86::code_asm::CodeAssembler;
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::PushConst};
@@ -9,17 +9,16 @@ use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::P
 pub(crate) fn encode_push_constant(
     a: &mut CodeAssembler,
     x: &PushConst<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if a.bitness() == 32 && cfg!(feature = "x86") {
-        a.push(x.value as i32).map_err(convert_error)
+        a.push(x.value as i32)?;
+        Ok(())
     } else if a.bitness() == 64 && cfg!(feature = "x64") {
-        a.push(((x.value as u64 >> 32) & 0xFFFFFFFF) as i32)
-            .map_err(convert_error)?;
-        a.push((x.value & 0xFFFFFFFF) as i32).map_err(convert_error)
+        a.push(((x.value as u64 >> 32) & 0xFFFFFFFF) as i32)?;
+        a.push((x.value & 0xFFFFFFFF) as i32)?;
+        Ok(())
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
     }
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/push_stack.rs b/projects/reloaded-hooks-x86-sys/src/instructions/push_stack.rs
index c092980..f0ca359 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/push_stack.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/push_stack.rs
@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::{convert_error, ARCH_NOT_SUPPORTED};
+use crate::common::jit_common::{X86jitError, ARCH_NOT_SUPPORTED};
 use alloc::string::ToString;
 use iced_x86::code_asm::{dword_ptr, qword_ptr, CodeAssembler};
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::PushStack};
@@ -11,17 +11,17 @@ macro_rules! encode_push_stack_impl {
         if $push.item_size != $size {
             // Need to do some custom shenanigans to re-push larger values.
             if $push.item_size % $size != 0 {
-                return Err(JitError::ThirdPartyAssemblerError($error_msg.to_string()));
+                return Err(JitError::ThirdPartyAssemblerError($error_msg.to_string()).into());
             } else {
                 let num_operations = $push.item_size / $size;
                 for op_idx in 0..num_operations {
                     let ptr = $ptr_type($reg) + $push.offset as i32 + (op_idx * $size * 2);
-                    $a.push(ptr).map_err(convert_error)?;
+                    $a.push(ptr)?;
                 }
             }
         } else {
             let ptr = $ptr_type($reg) + $push.offset as i32;
-            $a.push(ptr).map_err(convert_error)?;
+            $a.push(ptr)?;
         }
     };
 }
@@ -29,7 +29,7 @@ macro_rules! encode_push_stack_impl {
 pub(crate) fn encode_push_stack(
     a: &mut CodeAssembler,
     push: &PushStack<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     match a.bitness() {
         #[cfg(feature = "x86")]
         32 => {
@@ -46,9 +46,7 @@ pub(crate) fn encode_push_stack(
             encode_push_stack_impl!(a, push, iced_x86::Register::RSP, 8, qword_ptr, error_msg);
         }
         _ => {
-            return Err(JitError::ThirdPartyAssemblerError(
-                ARCH_NOT_SUPPORTED.to_string(),
-            ));
+            return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
         }
     }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/ret.rs b/projects/reloaded-hooks-x86-sys/src/instructions/ret.rs
index 3398da8..2bce0b4 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/ret.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/ret.rs
@@ -1,16 +1,17 @@
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use iced_x86::code_asm::CodeAssembler;
-use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::Return};
+use reloaded_hooks_portable::api::jit::operation_aliases::Return;
 
 pub(crate) fn encode_return(
     a: &mut CodeAssembler,
     x: &Return,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if x.offset == 0 {
-        a.ret().map_err(convert_error)
+        a.ret()?;
+        Ok(())
     } else {
-        a.ret_1(x.offset as i32).map_err(convert_error)
+        a.ret_1(x.offset as i32)?;
+        Ok(())
     }
 }
 
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/stack_alloc.rs b/projects/reloaded-hooks-x86-sys/src/instructions/stack_alloc.rs
index dfebf53..ab43085 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/stack_alloc.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/stack_alloc.rs
@@ -1,6 +1,6 @@
 extern crate alloc;
 use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
+use crate::common::jit_common::X86jitError;
 use crate::common::jit_common::ARCH_NOT_SUPPORTED;
 use alloc::string::ToString;
 use iced_x86::code_asm::registers as iced_regs;
@@ -11,15 +11,13 @@ use reloaded_hooks_portable::api::jit::operation_aliases::StackAlloc;
 pub(crate) fn encode_stack_alloc(
     a: &mut CodeAssembler,
     sub: &StackAlloc,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if a.bitness() == 32 && cfg!(feature = "x86") {
-        a.sub(iced_regs::esp, sub.operand).map_err(convert_error)?;
+        a.sub(iced_regs::esp, sub.operand)?;
     } else if a.bitness() == 64 && cfg!(feature = "x64") {
-        a.sub(iced_regs::rsp, sub.operand).map_err(convert_error)?;
+        a.sub(iced_regs::rsp, sub.operand)?;
     } else {
-        return Err(JitError::ThirdPartyAssemblerError(
-            ARCH_NOT_SUPPORTED.to_string(),
-        ));
+        return Err(JitError::ThirdPartyAssemblerError(ARCH_NOT_SUPPORTED.to_string()).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/src/instructions/xchg.rs b/projects/reloaded-hooks-x86-sys/src/instructions/xchg.rs
index 86e40d0..b3e0b63 100644
--- a/projects/reloaded-hooks-x86-sys/src/instructions/xchg.rs
+++ b/projects/reloaded-hooks-x86-sys/src/instructions/xchg.rs
@@ -1,25 +1,20 @@
 extern crate alloc;
+use crate::{all_registers::AllRegisters, common::jit_common::X86jitError};
 use alloc::string::ToString;
 use iced_x86::code_asm::CodeAssembler;
 use reloaded_hooks_portable::api::jit::{compiler::JitError, operation_aliases::XChg};
 
-use crate::all_registers::AllRegisters;
-use crate::common::jit_common::convert_error;
-
 macro_rules! encode_xchg_vector {
     ($fn_name:ident, $reg_type:ident, $mov_instr:ident) => {
         fn $fn_name(
             a: &mut CodeAssembler,
             xchg: &XChg<AllRegisters>,
-        ) -> Result<(), JitError<AllRegisters>> {
+        ) -> Result<(), X86jitError<AllRegisters>> {
             let scratch = get_scratch(xchg.scratch)?;
 
-            a.$mov_instr(scratch.$reg_type()?, xchg.register1.$reg_type()?)
-                .map_err(convert_error)?;
-            a.$mov_instr(xchg.register1.$reg_type()?, xchg.register2.$reg_type()?)
-                .map_err(convert_error)?;
-            a.$mov_instr(xchg.register2.$reg_type()?, scratch.$reg_type()?)
-                .map_err(convert_error)?;
+            a.$mov_instr(scratch.$reg_type()?, xchg.register1.$reg_type()?)?;
+            a.$mov_instr(xchg.register1.$reg_type()?, xchg.register2.$reg_type()?)?;
+            a.$mov_instr(xchg.register2.$reg_type()?, scratch.$reg_type()?)?;
             Ok(())
         }
     };
@@ -32,14 +27,12 @@ encode_xchg_vector!(encode_xchg_zmm, as_iced_zmm, vmovaps);
 pub(crate) fn encode_xchg(
     a: &mut CodeAssembler,
     xchg: &XChg<AllRegisters>,
-) -> Result<(), JitError<AllRegisters>> {
+) -> Result<(), X86jitError<AllRegisters>> {
     if xchg.register1.is_32() && xchg.register2.is_32() {
-        a.xchg(xchg.register1.as_iced_32()?, xchg.register2.as_iced_32()?)
-            .map_err(convert_error)?
+        a.xchg(xchg.register1.as_iced_32()?, xchg.register2.as_iced_32()?)?
     } else if xchg.register1.is_64() && xchg.register2.is_64() && cfg!(feature = "x64") {
         #[cfg(feature = "x64")]
-        a.xchg(xchg.register1.as_iced_64()?, xchg.register2.as_iced_64()?)
-            .map_err(convert_error)?
+        a.xchg(xchg.register1.as_iced_64()?, xchg.register2.as_iced_64()?)?
     } else if xchg.register1.is_xmm() && xchg.register2.is_xmm() {
         encode_xchg_xmm(a, xchg)?
     } else if xchg.register1.is_ymm() && xchg.register2.is_ymm() {
@@ -47,10 +40,7 @@ pub(crate) fn encode_xchg(
     } else if xchg.register1.is_zmm() && xchg.register2.is_zmm() {
         encode_xchg_zmm(a, xchg)?
     } else {
-        return Err(JitError::InvalidRegisterCombination(
-            xchg.register1,
-            xchg.register2,
-        ));
+        return Err(JitError::InvalidRegisterCombination(xchg.register1, xchg.register2).into());
     }
 
     Ok(())
diff --git a/projects/reloaded-hooks-x86-sys/tests/wrapper_instruction_generator_32.rs b/projects/reloaded-hooks-x86-sys/tests/wrapper_instruction_generator_32.rs
index 562a3d0..88cf1e9 100644
--- a/projects/reloaded-hooks-x86-sys/tests/wrapper_instruction_generator_32.rs
+++ b/projects/reloaded-hooks-x86-sys/tests/wrapper_instruction_generator_32.rs
@@ -9,7 +9,6 @@ pub mod tests {
     use reloaded_hooks_portable::api::function_info::{BasicFunctionInfo, ParameterType};
     use reloaded_hooks_portable::api::jit::compiler::Jit;
     use reloaded_hooks_portable::api::jit::operation::Operation;
-    use reloaded_hooks_portable::api::jit::operation::Operation::MultiPush;
     use reloaded_hooks_portable::api::jit::operation_aliases::*;
     use reloaded_hooks_portable::api::wrapper_instruction_generator::{
         generate_wrapper_instructions, WrapperInstructionGeneratorOptions,
@@ -17,7 +16,6 @@ pub mod tests {
     use reloaded_hooks_x86_sys::x86::calling_convention::CallingConvention;
     use reloaded_hooks_x86_sys::x86::jit::JitX86;
     use reloaded_hooks_x86_sys::x86::Register::{self, *};
-    use smallvec::smallvec;
 
     // EXTRA TESTS //
 
@@ -138,7 +136,6 @@ pub mod tests {
 
     #[test]
     fn ms_cdecl_to_fastcall_optimized() {
-        let nint = size_of::<u32>() as isize;
         let result = two_parameters(
             CallingConvention::cdecl(),
             CallingConvention::fastcall(),