diff --git a/src/instructions/numeric.rs b/src/instructions/numeric.rs
index 913f864..66c4ed3 100644
--- a/src/instructions/numeric.rs
+++ b/src/instructions/numeric.rs
@@ -15,40 +15,34 @@ use super::utils::{CastingTrait, NumericTrait};
 /// Adds two values together.
 fn _add<T>(a: T, b: T) -> Option<T>
 where
-    T: Add<Output = T> + Copy,
+    T: Add<Output = T>,
 {
     Some(b + a)
 }
 
 /// Subtracts two values from each other.
-fn _sub<T>(vals: Vec<T>) -> Option<T>
+fn _sub<T>(a: T, b: T) -> Option<T>
 where
-    T: Sub<Output = T> + Copy,
+    T: Sub<Output = T>,
 {
-    Some(vals[1] - vals[0])
+    Some(b - a)
 }
-make_instruction!(int, int, _sub, i128, 2);
-make_instruction!(float, float, _sub, Decimal, 2);
 
 /// Multiplies two values with each other.
-fn _mult<T>(vals: Vec<T>) -> Option<T>
+fn _mult<T>(a: T, b: T) -> Option<T>
 where
     T: Mul<Output = T> + Copy,
 {
-    Some(vals[1] * vals[0])
+    Some(b * a)
 }
-make_instruction!(int, int, _mult, i128, 2);
-make_instruction!(float, float, _mult, Decimal, 2);
 
 /// Divides two values from each other.
-fn _div<T>(vals: Vec<T>) -> Option<T>
+fn _div<T>(a: T, b: T) -> Option<T>
 where
-    T: Div<Output = T> + Copy + NumericTrait,
+    T: Div<Output = T> + NumericTrait,
 {
-    vals[1].checked_div(vals[0])
+    b.checked_div(a)
 }
-make_instruction!(int, int, _div, i128, 2);
-make_instruction!(float, float, _div, Decimal, 2);
 
 /// Takes the remainder of two values
 fn _rem<T>(vals: Vec<T>) -> Option<T>
@@ -305,6 +299,9 @@ macro_rules! make_instructions {
     ($stack:ident) => {
         paste::item! {
             make_instruction_new!(_add, $stack, $stack, $stack, $stack);
+            make_instruction_new!(_sub, $stack, $stack, $stack, $stack);
+            make_instruction_new!(_mult, $stack, $stack, $stack, $stack);
+            make_instruction_new!(_div, $stack, $stack, $stack, $stack);
         }
     };
 }
@@ -328,37 +325,24 @@ mod tests {
     /// Tests the _sub function.
     #[test]
     fn sub_test() {
-        let vals: Vec<i64> = vec![1, 2];
-        assert_eq!(Some(1), _sub(vals));
-
-        let vals: Vec<Decimal> = vec![dec!(1.1), dec!(2.2)];
-        assert_eq!(Some(dec!(1.1)), _sub(vals));
+        assert_eq!(Some(1), _sub(1, 2));
+        assert_eq!(Some(dec!(1.1)), _sub(dec!(1.1), dec!(2.2)));
     }
 
     /// Tests the _mult function.
     #[test]
     fn mult_test() {
-        let vals: Vec<i128> = vec![4, 5];
-        assert_eq!(Some(20), _mult(vals));
-
-        let vals: Vec<Decimal> = vec![dec!(1.1), dec!(2.2)];
-        assert_eq!(Some(dec!(2.42)), _mult(vals));
+        assert_eq!(Some(20), _mult(5, 4));
+        assert_eq!(Some(dec!(2.42)), _mult(dec!(2.2), dec!(1.1)));
     }
 
     /// Tests the _div function
     #[test]
     fn div_test() {
-        let vals: Vec<i128> = vec![4, 20];
-        assert_eq!(Some(5), _div(vals));
-
-        let vals: Vec<i128> = vec![3, 20];
-        assert_eq!(Some(6), _div(vals));
-
-        let vals: Vec<Decimal> = vec![dec!(1.6), dec!(2.2)];
-        assert_eq!(Some(dec!(1.375)), _div(vals));
-
-        let vals: Vec<i128> = vec![0, 1];
-        assert_eq!(None, _div(vals));
+        assert_eq!(Some(5), _div(4, 20));
+        assert_eq!(Some(6), _div(3, 20));
+        assert_eq!(Some(dec!(1.375)), _div(dec!(1.6), dec!(2.2)));
+        assert_eq!(None, _div(0, 1));
     }
 
     /// Tests the _rem function
@@ -545,7 +529,6 @@ mod tests {
         assert_eq!(vec![2, 0], test_state.int);
 
         test_state.int = vec![6, 3];
-
         int_div(&mut test_state);
         assert_eq!(vec![2], test_state.int);