first commit

1 files changed, 1056 insertions, 0 deletions

diff --git a/execute.py b/execute.py
new file mode 100644
index 0000000..40b9042
--- /dev/null
+++ b/execute.py
@@ -0,0 +1,1056 @@
+from opcodes import *
+from utils import Colors, ror, rol
+import numpy as np
+import math
+
+
+class Label():
+    def __init__(self, arity, name):
+        self.arity = arity
+        self.name = name
+
+
+class Frame():
+    def __init__(self, arity, local_indices, self_ref):
+        self.arity = arity
+        self.local_indices = local_indices
+        self.self_ref = self_ref
+
+
+# takes the machinestate, opcode and operand to run. updates the machinestate
+class Execute(): # pragma: no cover
+    def __init__(self, machinestate):
+        self.machinestate = machinestate
+        self.opcodeint = ''
+        self.immediates = []
+        self.op_gas = int()
+        self.stack_top = []
+
+    def getOPGas(self):
+        return self.op_gas
+
+    def chargeGasMem(self, mem_size_page):
+        factor = 64
+        self.op_gas += 64 * mem_size_page
+
+    def chargeGas(self, opcodeint):
+        if opcodeint != 64:
+            self.op_gas += 1
+        else:
+            chargeGasMem()
+            pass
+
+    def getInstruction(self, opcodeint, immediates):
+        self.opcodeint = opcodeint
+        dummy = []
+        #FIXME-why is it being cast to int?
+        for i in immediates:
+            dummy.append(int(i))
+        self.immediates = dummy
+
+    def callExecuteMethod(self):
+        runmethod = self.instructionUnwinder(self.opcodeint, self.immediates, self.machinestate)
+        #print (repr(hex(self.opcodeint)) + ' ' + repr(self.immediates))
+        try:
+            runmethod(self.opcodeint, self.immediates)
+        except IndexError:
+            # trap
+            print(Colors.red + 'bad stack access.' + Colors.ENDC)
+            val2 = self.machinestate.Stack_Omni.pop()
+
+
+    def instructionUnwinder(self, opcodeint, immediates, machinestate):
+        self.chargeGas(opcodeint)
+
+        if opcodeint == 0:
+            return(self.run_unreachable)
+        elif opcodeint == 1:
+            return(self.run_nop)
+        elif opcodeint == 2:
+            return(self.run_block)
+        elif opcodeint == 3:
+            return(self.run_loop)
+        elif opcodeint == 4:
+            return(self.run_if)
+        elif opcodeint == 5:
+            return(self.run_else)
+        elif opcodeint == 11:
+            return(self.run_end)
+        elif opcodeint == 12:
+            return(self.run_br)
+        elif opcodeint == 13:
+            return(self.run_br_if)
+        elif opcodeint == 14:
+            return(self.run_br_table)
+        elif opcodeint == 15:
+            return(self.run_return)
+        elif opcodeint == 16:
+            return(self.run_call)
+        elif opcodeint == 17:
+            return(self.run_call_indirect)
+        elif opcodeint == 26:
+            return(self.run_drop)
+        elif opcodeint == 27:
+            return(self.run_select)
+        elif opcodeint == 32:
+            return(self.run_getlocal)
+        elif opcodeint == 33:
+            return(self.run_setlocal)
+        elif opcodeint == 34:
+            return(self.run_teelocal)
+        elif opcodeint == 35:
+            return(self.run_getglobal)
+        elif opcodeint == 36:
+            return(self.run_setglobal)
+        elif opcodeint >= 40 and opcodeint <= 53:
+            return(self.run_load)
+        elif opcodeint >= 54 and opcodeint <= 62:
+            return(self.run_store)
+        elif opcodeint == 63:
+            return(self.run_current_memory)
+        elif opcodeint == 64:
+            self.chargeGasMem(immediates[0])
+            return(self.run_grow_memory)
+        elif opcodeint >= 65 and opcodeint <= 68:
+            return(self.run_const)
+        elif opcodeint == 69 or opcodeint == 80:
+            return(self.run_eqz)
+        elif opcodeint == 70 or opcodeint == 81 or opcodeint == 91 or opcodeint == 97:
+            return(self.run_eq)
+        elif opcodeint == 71 or opcodeint == 82 or opcodeint == 92 or opcodeint == 98:
+            return(self.run_ne)
+        elif opcodeint == 72 or opcodeint == 83:
+            return(self.run_lt_s)
+        elif opcodeint == 73 or opcodeint == 84:
+            return(self.run_lt_u)
+        elif opcodeint == 74 or opcodeint == 85:
+            return(self.run_gt_s)
+        elif opcodeint == 75 or opcodeint == 86:
+            return(self.run_gt_u)
+        elif opcodeint == 76 or opcodeint == 87:
+            return(self.run_le_s)
+        elif opcodeint == 77 or opcodeint == 88:
+            return(self.run_le_u)
+        elif opcodeint == 78 or opcodeint == 89:
+            return(self.run_ge_s)
+        elif opcodeint == 79 or opcodeint == 90:
+            return(self.run_ge_u)
+        elif opcodeint == 93 or opcodeint == 99:
+            return(self.run_lt)
+        elif opcodeint == 94 or opcodeint == 100:
+            return(self.run_gt)
+        elif opcodeint == 95 or opcodeint == 101:
+            return(self.run_le)
+        elif opcodeint == 96 or opcodeint == 102:
+            return(self.run_ge)
+        elif opcodeint == 103 or opcodeint == 121:
+            return(self.run_clz)
+        elif opcodeint == 104 or opcodeint == 122:
+            return(self.run_ctz)
+        elif opcodeint == 105 or opcodeint == 123:
+            return(self.run_popcnt)
+        elif opcodeint == 106 or opcodeint == 124 or opcodeint == 146 or opcodeint == 160:
+            return(self.run_add)
+        elif opcodeint == 107 or opcodeint == 125 or opcodeint == 147 or opcodeint == 161:
+            return(self.run_sub)
+        elif opcodeint == 108 or opcodeint == 126 or opcodeint == 148 or opcodeint == 162:
+            return(self.run_mul)
+        elif opcodeint == 109 or opcodeint == 127:
+            return(self.run_div_s)
+        elif opcodeint == 110 or opcodeint == 128:
+            return(self.run_div_u)
+        elif opcodeint == 111 or opcodeint == 129:
+            return(self.run_rem_s)
+        elif opcodeint == 112 or opcodeint == 130:
+            return(self.run_rem_u)
+        elif opcodeint == 113 or opcodeint == 131:
+            return(self.run_and)
+        elif opcodeint == 114 or opcodeint == 132:
+            return(self.run_or)
+        elif opcodeint == 115 or opcodeint == 133:
+            return(self.run_xor)
+        elif opcodeint == 116 or opcodeint == 134:
+            return(self.run_shl)
+        elif opcodeint == 117 or opcodeint == 135:
+            return(self.run_shr_s)
+        elif opcodeint == 118 or opcodeint == 136:
+            return(self.run_shr_u)
+        elif opcodeint == 119 or opcodeint == 137:
+            return(self.run_rotl)
+        elif opcodeint == 120 or opcodeint == 138:
+            return(self.run_rotr)
+        elif opcodeint == 139 or opcodeint == 153:
+            return(self.run_abs)
+        elif opcodeint == 140 or opcodeint == 154:
+            return(self.run_neg)
+        elif opcodeint == 141 or opcodeint == 155:
+            return(self.run_ceil)
+        elif opcodeint == 142 or opcodeint == 156:
+            return(self.run_floor)
+        elif opcodeint == 143 or opcodeint == 157:
+            return(self.run_trunc)
+        elif opcodeint == 144 or opcodeint == 158:
+            return(self.run_nearest)
+        elif opcodeint == 145 or opcodeint == 159:
+            return(self.run_sqrt)
+        elif opcodeint == 149 or opcodeint == 163:
+            return(self.run_div)
+        elif opcodeint == 150 or opcodeint == 164:
+            return(self.run_min)
+        elif opcodeint == 151 or opcodeint == 165:
+            return(self.run_max)
+        elif opcodeint == 152 or opcodeint == 166:
+            return(self.run_copysign)
+        elif opcodeint == 167:
+            return(self.run_i32wrapi64)
+        elif opcodeint == 168:
+            return(self.run_i32trunc_sf32)
+        elif opcodeint == 169:
+            return(self.run_i32trunc_uf32)
+        elif opcodeint == 170:
+            return(self.run_i32trunc_sf64)
+        elif opcodeint == 171:
+            return(self.run_i32trunc_uf64)
+        elif opcodeint == 172:
+            return(self.run_i64extend_si32)
+        elif opcodeint == 173:
+            return(self.run_i64extend_ui3o)
+        elif opcodeint == 174:
+            return(self.run_i64trunc_sf32)
+        elif opcodeint == 175:
+            return(self.run_i64trunc_uf32)
+        elif opcodeint == 176:
+            return(self.run_i64trunc_sf64)
+        elif opcodeint == 177:
+            return(self.run_i64trunc_uf64)
+        elif opcodeint == 178:
+            return(self.run_f32convert_si32)
+        elif opcodeint == 179:
+            return(self.run_f32convert_ui32)
+        elif opcodeint == 180:
+            return(self.run_f32convert_si64)
+        elif opcodeint == 181:
+            return(self.run_f32convert_ui64)
+        elif opcodeint == 182:
+            return(self.run_f32demotef64)
+        elif opcodeint == 183:
+            return(self.run_f64convert_si32)
+        elif opcodeint == 184:
+            return(self.run_f64convert_ui32)
+        elif opcodeint == 185:
+            return(self.run_f64convert_si64)
+        elif opcodeint == 186:
+            return(self.run_f64convert_ui64)
+        elif opcodeint == 187:
+            return(self.run_f64promotef32)
+        elif opcodeint == 188:
+            return(self.run_i32reinterpretf32)
+        elif opcodeint == 189:
+            return(self.run_i64reinterpretf64)
+        elif opcodeint == 190:
+            return(self.run_f32reinterpreti32)
+        elif opcodeint == 191:
+            return(self.run_f64reinterpreti64)
+        else:
+            raise Exception(Colors.red + 'unknown opcode' + Colors.ENDC)
+
+    def run_unreachable(self, opcodeint, immediates):
+        # trap
+        raise Exception(Colors.red + "trapped." + Colors.ENDC)
+
+    def run_nop(self, opcodeint, immediates):
+        # literally do nothing
+        pass
+
+    def run_block(self, opcodeint, immediates):
+        self.machinestate.Stack_Label.append(self.machinestate.Stack_Label_Height)
+        self.machinestate.Stack_Label_Height += 1
+
+    def run_loop(self, opcodeint, immediates):
+        # assertion
+        if not self.machinestate.Stack_Omni:
+            print(Colors.red + "entered a loop. stack is empty." + Colors.ENDC)
+            # exit 1
+        self.machinestate.Stack_Label.append(self.machinestate.Stack_Label_Height)
+        self.machinestate.Stack_Label_Height += 1
+        val = self.machinestate.Stack_Omni.pop()
+        if val != 0:
+            pass
+        else:
+            pass
+
+    def run_if(self, opcodeint, immediates):
+        pass
+
+    def run_else(self, opcodeint, immediates):
+        pass
+
+    def run_end(self, opcodeint, immediates):
+        #self.machinestate.Stack_Label.pop()
+        pass
+
+    def run_br(self, opcodeint, immediates):
+        if self.machinestate.Stack_Label_Height >= immediates[0] + 1:
+            print(Colors.red + "label stack does not have enough labels." + Colors.ENDC)
+            # exit 1
+        if len(self.machinestate.Stack_Omni) < 1:
+            print(Colors.red + "the value stack does not have enough values." + Colors.ENDC)
+            # exit 1
+        val = self.machinestate.Stack_Omni.pop()
+        label = self.machinestate.Stack_Label.pop()
+
+    def run_br_if(self, opcodeint, immediates):
+        val = self.machinestate.Stack_Omni.pop()
+        if val:
+            pass
+        else:
+            self.run_br(dummy, immediates[0])
+
+    def run_br_table(self, opcodeint, immediates):
+        pass
+
+    def run_return(self, opcodeint, immediates):
+        pass
+
+    def run_call(self, opcodeint, immediates):
+        pass
+
+    def run_call_indirect(self, opcodeint, immediates):
+        pass
+
+    def run_drop(self, opcodeint, immediates):
+        self.machinestate.Stack_Omni.pop()
+
+    def run_select(self, opcodeint, immediates):
+        pass
+
+    def run_getlocal(self, opcodeint, immediates):
+        local = self.machinestate.Index_Space_Locals[int(immediates[0])]
+        self.machinestate.Stack_Omni.append(local)
+
+    def run_setlocal(self, opcodeint, immediates):
+        self.machinestate.Index_Space_Locals[int(immediates[0])] = self.machinestate.Stack_Omni.pop()
+
+    def run_teelocal(self, dummy, immediates):
+        # @DEVI-we dont pop and push
+        self.machinestate.Index_Space_Locals[int(immediates[0])] = self.machinestate.Stack_Omni[-1]
+
+    def run_getglobal(self, opcodeint, immediates):
+        val = self.machinestate.Index_Space_Global[immediates[0]]
+        self.machinestate.Stack_Omni.append(val)
+
+    def run_setglobal(self, opcodeint, immediates):
+        val = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Index_Space_Global = val
+
+    # currently only one linear memory is allowed so thats the default.
+    def run_load(self, opcodeint, immediates):
+        if opcodeint == 40:
+            bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 4]
+            self.machinestate.Stack_Omni.append(np.int32(bytes))
+        elif opcodeint == 41:
+            bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 8]
+            self.machinestate.Stack_Omni.append(np.int64(bytes))
+        elif opcodeint == 42:
+            bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 4]
+            self.machinestate.Stack_Omni.append(np.float32(bytes))
+        elif opcodeint == 43:
+            bytes = self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates) + 8]
+            self.machinestate.Stack_Omni.append(np.float64(bytes))
+        elif opcodeint == 44:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])])
+            temp2 = (temp & 0x0000007f) | ((temp & 0x80) << 24)
+            self.machinestate.append(np.int32(tmep2))
+        elif opcodeint == 45:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])])
+            temp2 = temp & 0x000000ff
+            self.machinestate.append(np.uint32(tmep2))
+        elif opcodeint == 46:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
+            temp2 = (temp & 0x00007fff) | ((temp & 0x8000) << 16)
+            self.machinestate.append(np.int32(tmep2))
+        elif opcodeint == 47:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
+            temp2 = temp & 0x0000ffff
+            self.machinestate.append(np.uint32(tmep2))
+        elif opcodeint == 48:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])])
+            temp2 = (temp & 0x000000000000007f) | ((temp & 0x80) << 56)
+            self.machinestate.append(np.int64(tmep2))
+        elif opcodeint == 49:
+            temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1])])
+            self.machinestate.append(np.uint64(tmep))
+        elif opcodeint == 50:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
+            temp2 = (temp & 0x0000000000007fff) | ((temp & 0x8000) << 48)
+            self.machinestate.append(np.int64(tmep2))
+        elif opcodeint == 51:
+            temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
+            self.machinestate.append(np.uint64(tmep))
+        elif opcodeint == 52:
+            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 4)])
+            temp2 = (temp & 0x000000007fffffff) | ((temp & 0x80000000) << 32)
+            self.machinestate.append(np.int64(tmep2))
+        elif opcodeint == 53:
+            temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 4)])
+            self.machinestate.append(np.uint64(tmep))
+        else:
+            raise Exception(Colors.red + 'invalid load instruction.' + Colors.ENDC)
+
+    # currently only one linear memory is allowed so thats the default.
+    def run_store(self, opcodeint, immediates):
+        if opcodeint == 54:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = val & 0x000000ff
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = val & 0x0000ff00 >> 8
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = val & 0x00ff0000 >> 16
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = val & 0xff000000 >> 24
+        elif opcodeint == 55:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = val & 0x00000000000000ff
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = val & 0x000000000000ff00 >> 8
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = val & 0x0000000000ff0000 >> 16
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = val & 0x00000000ff000000 >> 24
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 4] = val & 0x000000ff00000000 >> 32
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 5] = val & 0x0000ff0000000000 >> 40
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 6] = val & 0x00ff000000000000 >> 48
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 7] = val & 0xff00000000000000 >> 56
+        # @DEVI-FIXME-needs reinterpret cast
+        elif opcodeint == 56:
+            pass
+        # @DEVI-FIXME-needs reinterpret cast
+        elif opcodeint == 57:
+            pass
+        elif opcodeint == 58:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8(val & 0x000000ff)
+        elif opcodeint == 59:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = np.in8(val & 0x000000ff)
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = np.in8(val & 0x0000ff00 >> 8)
+        elif opcodeint == 60:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8(val & 0x00000000000000ff)
+        elif opcodeint == 61:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = np.in8(val & 0x00000000000000ff)
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = np.in8(val & 0x000000000000ff00 >> 8)
+        elif opcodeint == 62:
+            val = self.machinestate.Stack_Omni.pop()
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 0] = np.in8(val & 0x00000000000000ff)
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 1] = np.in8(val & 0x000000000000ff00 >> 8)
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 2] = np.in8(val & 0x0000000000ff0000 >> 16)
+            self.machinestate.Linear_Memory[0][int(immediates[1]) + 3] = np.in8(val & 0x00000000ff000000 >> 24)
+        else:
+            raise Exception(Colors.red + 'invalid store instruction' + Colors.ENDC)
+
+    def run_current_memory(self, opcodeint, immediates):
+        pass
+
+    def run_grow_memory(self, opcodeint, immediates):
+        pass
+
+    def run_const(self, opcodeint, immediates):
+        if opcodeint == 65:
+            self.machinestate.Stack_Omni.append(immediates[0])
+        elif opcodeint == 66:
+            self.machinestate.Stack_Omni.append(immediates[0])
+        elif opcodeint == 67:
+            self.machinestate.Stack_Omni.append(immediates[0])
+        elif opcodeint == 68:
+            self.machinestate.Stack_Omni.append(immediates[0])
+        else:
+            raise Exception(Colors.red + 'invalid const instruction' + Colors.ENDC)
+
+    def run_eqz(self, opcodeint, immediates):
+        if opcodeint == 69 or opcodeint == 80:
+            val = self.machinestate.Stack_Omni.pop()
+            if val == 0:
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid eqz instruction' + Colors.ENDC)
+
+    def run_eq(self, opcodeint, immediates):
+        if opcodeint == 70 or opcodeint == 81 or opcodeint == 91 or opcodeint == 97:
+            val2 = self.machinestate.Stack_Omni.pop()
+            val1 = self.machinestate.Stack_Omni.pop()
+            if val1 == val2:
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid eq instruction' + Colors.ENDC)
+
+    def run_ne(self, opcodeint, immediates):
+        if opcodeint == 71 or opcodeint == 82 or opcodeint == 92 or opcodeint == 98:
+            val2 = self.machinestate.Stack_Omni.pop()
+            val1 = self.machinestate.Stack_Omni.pop()
+            if val1 != val2:
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid ne instruction' + Colors.ENDC)
+
+    def run_lt_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 72:
+            if np.int32(val1) < np.int32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 83:
+            if np.int64(val1) < np.int64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid lt_s instruction' + Colors.ENDC)
+
+    def run_lt_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 73:
+            if np.uint32(val1) < np.uint32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 84:
+            if np.uint64(val1) < np.uint64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid lt_u instruction' + Colors.ENDC)
+
+    def run_gt_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 74:
+            if np.int32(val1) > np.int32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 85:
+            if np.int64(val1) > np.int64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid gt_s instruction' + Colors.ENDC)
+
+    def run_gt_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 75:
+            if np.uint32(val1) > np.uint32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 86:
+            if np.uint64(val1) > np.uint64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid gt_u instruction' + Colors.ENDC)
+
+    def run_le_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 76:
+            if np.int32(val1) <= np.int32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 87:
+            if np.int64(val1) <= np.int64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid le_s instruction' + Colors.ENDC)
+
+    def run_le_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 77:
+            if np.uint32(val1) <= np.uint32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 88:
+            if np.uint64(val1) <= np.uint64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid le_u instruction' + Colors.ENDC)
+
+    def run_ge_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 78:
+            if np.int32(val1) >= np.int32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 89:
+            if np.int64(val1) >= np.int64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid ge_s instruction' + Colors.ENDC)
+
+    def run_ge_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 79:
+            if np.uint32(val1) >= np.uint32(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 90:
+            if np.uint64(val1) >= np.uint64(val2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid ge_u instruction' + Colors.ENDC)
+
+    def run_lt(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 93:
+            if np.float32(v1) < np.float32(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 99:
+            if np.float64(v1) < np.float64(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid lt instruction' + Colors.ENDC)
+
+    def run_gt(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 94:
+            if np.float32(v1) > np.float32(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 100:
+            if np.float64(v1) > np.float64(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid gt instruction' + Colors.ENDC)
+
+    def run_le(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 95:
+            if np.float32(v1) <= np.float32(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 101:
+            if np.float64(v1) <= np.float64(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid le instruction' + Colors.ENDC)
+
+    def run_ge(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 96:
+            if np.float32(v1) >= np.float32(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        elif opcodeint == 102:
+            if np.float64(v1) >= np.float64(v2):
+                self.machinestate.Stack_Omni.append(1)
+            else:
+                self.machinestate.Stack_Omni.append(0)
+        else:
+            raise Exception(Colors.red + 'invalid ge instruction' + Colors.ENDC)
+
+    def run_clz(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 103:
+            self.machinestate.Stack_Omni.append(clz(val, 'uint32'))
+        elif opcodeint == 121:
+            self.machinestate.Stack_Omni.append(clz(val, 'uint64'))
+        else:
+            raise Exception(Colors.red + 'invalid clz instruction' + Colors.ENDC)
+
+    def run_ctz(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 104:
+            self.machinestate.Stack_Omni.append(ctz(val, 'uint32'))
+        elif opcodeint == 122:
+            self.machinestate.Stack_Omni.append(ctz(val, 'uint64'))
+        else:
+            raise Exception(Colors.red + 'invalid ctz instruction' + Colors.ENDC)
+
+    def run_popcnt(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 105:
+            self.machinestate.Stack_Omni.append(pop_cnt(val, 'uint32'))
+        elif opcodeint == 123:
+            self.machinestate.Stack_Omni.append(pop_cnt(val, 'uint64'))
+        else:
+            raise Exception(Colors.red + 'invalid popcnt instruction' + Colors.ENDC)
+
+    def run_add(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 106:
+            self.machinestate.Stack_Omni.append(np.uint32(val1 + val2))
+        elif opcodeint == 124:
+            self.machinestate.Stack_Omni.append(np.uint64(val1 + val2))
+        elif opcodeint == 146:
+            self.machinestate.Stack_Omni.append(np.float32(val1 + val2))
+        elif opcodeint == 160:
+            self.machinestate.Stack_Omni.append(np.float64(val1 + val2))
+        else:
+            raise Exception(Colors.red + 'invalid add instruction' + Colors.ENDC)
+
+    def run_sub(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 107:
+            self.machinestate.Stack_Omni.append(np.uint32(val1 - val2))
+        elif opcodeint == 125:
+            self.machinestate.Stack_Omni.append(np.uint64(val1 - val2))
+        elif opcodeint == 147:
+            self.machinestate.Stack_Omni.append(np.float32(val1 - val2))
+        elif opcodeint == 161:
+            self.machinestate.Stack_Omni.append(np.float64(val1 - val2))
+        else:
+            raise Exception(Colors.red + 'invalid sub instruction' + Colors.ENDC)
+
+    def run_mul(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 108:
+            self.machinestate.Stack_Omni.append(np.uint32(val1 * val2))
+        elif opcodeint == 126:
+            self.machinestate.Stack_Omni.append(np.uint64(val1 * val2))
+        elif opcodeint == 148:
+            self.machinestate.Stack_Omni.append(np.float32(val1 * val2))
+        elif opcodeint == 162:
+            self.machinestate.Stack_Omni.append(np.float64(val1 * val2))
+        else:
+            raise Exception(Colors.red + 'invalid mul instruction' + Colors.ENDC)
+
+    def run_div_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 109:
+            self.machinestate.Stack_Omni.append(np.int32(np.int32(val1) / np.int32(val2)))
+        elif opcodeint == 127:
+            self.machinestate.Stack_Omni.append(np.int64(np.int64(val1) / np.int64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid div_s instruction' + Colors.ENDC)
+
+    def run_div_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 110:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) / np.uint32(val2)))
+        elif opcodeint == 128:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) / np.uint64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid div_u instruction' + Colors.ENDC)
+
+    def run_rem_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 111:
+            self.machinestate.Stack_Omni.append(np.int32(np.int32(val1) % np.int32(val2)))
+        elif opcodeint == 129:
+            self.machinestate.Stack_Omni.append(np.int64(np.int64(val1) % np.int64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid rem_s instruction' + Colors.ENDC)
+
+    def run_rem_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 112:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) % np.uint32(val2)))
+        elif opcodeint == 130:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) % np.uint64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid rem_u instruction' + Colors.ENDC)
+
+    def run_and(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 113:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) & np.uint32(val2)))
+        elif opcodeint == 131:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) & np.uint64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid and instruction' + Colors.ENDC)
+
+    def run_or(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 114:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) | np.uint32(val2)))
+        elif opcodeint == 132:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) | np.uint64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid or instruction' + Colors.ENDC)
+
+    def run_xor(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 115:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) ^ np.uint32(val2)))
+        elif opcodeint == 133:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) ^ np.uint64(val2)))
+        else:
+            raise Exception(Colors.red + 'invalid xor instruction' + Colors.ENDC)
+
+    def run_shl(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 116:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) << (np.uint32(val2))))
+        elif opcodeint == 134:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) << (np.uint64(val2))))
+        else:
+            raise Exception(Colors.red + 'invalid shl instruction' + Colors.ENDC)
+
+    def run_shr_s(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 117:
+            self.machinestate.Stack_Omni.append(np.int32(np.int32(val1) >> (np.int32(val2))))
+        elif opcodeint == 135:
+            self.machinestate.Stack_Omni.append(np.int64(np.int64(val1) >> (np.int64(val2))))
+        else:
+            raise Exception(Colors.red + 'invalid shr_s instruction' + Colors.ENDC)
+
+    def run_shr_u(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 118:
+            self.machinestate.Stack_Omni.append(np.uint32(np.uint32(val1) >> (np.uint32(val2))))
+        elif opcodeint == 136:
+            self.machinestate.Stack_Omni.append(np.uint64(np.uint64(val1) >> (np.uint64(val2))))
+        else:
+            raise Exception(Colors.red + 'invalid shr_u instruction' + Colors.ENDC)
+
+    def run_rotl(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 119:
+            self.machinestate.Stack_Omni.append(rol(val1, 32, val2))
+        elif opcodeint == 137:
+            self.machinestate.Stack_Omni.append(rol(val1, 64, val2))
+        else:
+            raise Exception(Colors.red + 'invalid rotl instruction' + Colors.ENDC)
+
+    def run_rotr(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 120:
+            self.machinestate.Stack_Omni.append(ror(val1, 32, val2))
+        elif opcodeint == 138:
+            self.machinestate.Stack_Omni.append(ror(val1, 32, val2))
+        else:
+            raise Exception(Colors.red + 'invalid rotl instruction' + Colors.ENDC)
+
+    def run_abs(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 139 or opcodeint == 153:
+            self.machinestate.Stack_Omni.append(abs(val1))
+        else:
+            raise Exception(Colors.red + 'invalid abs instruction' + Colors.ENDC)
+
+    def run_neg(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 140 or opcodeint == 154:
+            self.machinestate.Stack_Omni.append(-val1)
+        else:
+            raise Exception(Colors.red + 'invalid neg instruction' + Colors.ENDC)
+
+    def run_ceil(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 141 or opcodeint == 155:
+            self.machinestate.Stack_Omni.append(math.ceil(val1))
+        else:
+            raise Exception(Colors.red + 'invalid ceil instruction' + Colors.ENDC)
+
+    def run_floor(self, opcodeint, immediates):
+        if opcodeint == 142 or opcodeint == 156:
+            self.machinestate.Stack_Omni.append(math.floor(val1))
+        else:
+            raise Exception(Colors.red + 'invalid floor instruction' + Colors.ENDC)
+
+    def run_trunc(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 143 or opcodeint == 157:
+            self.machinestate.Stack_Omni.append(math.trunc(val1))
+        else:
+            raise Exception(Colors.red + 'invalid trunc instruction' + Colors.ENDC)
+
+    def run_nearest(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 144 or opcodeint == 158:
+            self.machinestate.Stack_Omni.append(round(val1))
+        else:
+            raise Exception(Colors.red + 'invalid nearest instruction' + Colors.ENDC)
+
+    def run_sqrt(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 145 or opcodeint == 159:
+            self.machinestate.Stack_Omni.append(math.sqrt(val1))
+        else:
+            raise Exception(Colors.red + 'invalid sqrt instruction' + Colors.ENDC)
+
+    def run_div(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 149:
+            self.machinestate.Stack_Omni.append(v1 / v2)
+        else:
+            raise Exception(Colors.red + 'invalid float div instruction' + Colors.ENDC)
+
+    def run_min(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 150 or opcodeint == 164:
+            self.machinestate.Stack_Omni.append(min(val1, val2))
+        else:
+            raise Exception(Colors.red + 'invalid min instruction' + Colors.ENDC)
+
+    def run_max(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 151 or opcodeint == 165:
+            self.machinestate.Stack_Omni.append(max(val1, val2))
+        else:
+            raise Exception(Colors.red + 'invalid max instruction' + Colors.ENDC)
+
+    def run_copysign(self, opcodeint, immediates):
+        val2 = self.machinestate.Stack_Omni.pop()
+        val1 = self.machinestate.Stack_Omni.pop()
+        if opcodeint == 152 or opcodeint == 166:
+            self.machinestate.Stack_Omni.append(math.copysign(val1, val2))
+        else:
+            raise Exception(Colors.red + 'invalid max instruction' + Colors.ENDC)
+
+    def run_i32wrapi64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.int32(np.float64(val1)))
+
+    def run_i32trunc_sf32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.int32(np.float32(val1)))
+
+    def run_i32trunc_uf32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.uint32(np.float32(val1)))
+
+    def run_i32trunc_sf64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.int32(np.float64(val1)))
+
+    def run_i32trunc_uf64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.int32(np.float64(val1)))
+
+    def run_i64extend_si32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.int32(val1)))
+
+    def run_i64extend_ui32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.uint32(val1)))
+
+    def run_i64trunc_sf32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.int64(np.float32(val1)))
+
+    def run_i64trunc_uf32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.uint64(np.float32(val1)))
+
+    def run_i64trunc_sf64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.int64(np.float64(val1)))
+
+    def run_i64trunc_uf64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.uint64(np.float64(val1)))
+
+    def run_f32convert_si32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float32(np.uint32(val1)))
+
+    def run_f32convert_ui32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float32(np.int32(val1)))
+
+    def run_f32convert_si64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float32(np.int64(val1)))
+
+    def run_f32convert_ui64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float32(np.uint64(val1)))
+
+    def run_f32demotef64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float32(np.float64(val1)))
+
+    def run_f64convert_si32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.int32(val1)))
+
+    def run_f64convert_ui32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.uint32(val1)))
+
+    def run_f64convert_si64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.int64(val1)))
+
+    def run_f64convert_ui64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.uint64(val1)))
+
+    def run_f64promotef32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        self.machinestate.Stack_Omni.append(np.float64(np.float32(val1)))
+
+    def run_i32reinterpretf32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        sel.machinestate.Stack_Omni.append(reinterpretf32toi32(val1))
+
+    def run_i64reinterpretf64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        sel.machinestate.Stack_Omni.append(reinterpretf64toi64(val1))
+
+    def run_f32reinterpreti32(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        sel.machinestate.Stack_Omni.append(reinterpreti32tof32(val1))
+
+    def run_f64reinterpreti64(self, opcodeint, immediates):
+        val1 = self.machinestate.Stack_Omni.pop()
+        sel.machinestate.Stack_Omni.append(reinterpreti64tof64(val1))