just style fixesHEADmaster

1 files changed, 508 insertions, 238 deletions

diff --git a/execute.py b/execute.py
index 0633629..97434e9 100644
--- a/execute.py
+++ b/execute.py
@@ -4,13 +4,13 @@ import numpy as np
 import math
 
 
-class Label():
+class Label:
     def __init__(self, arity, name):
         self.arity = arity
         self.name = name
 
 
-class Frame():
+class Frame:
     def __init__(self, arity, local_indices, self_ref):
         self.arity = arity
         self.local_indices = local_indices
@@ -18,10 +18,10 @@ class Frame():
 
 
 # takes the machinestate, opcode and operand to run. updates the machinestate
-class Execute(): # pragma: no cover
+class Execute:  # pragma: no cover
     def __init__(self, machinestate):
         self.machinestate = machinestate
-        self.opcodeint = ''
+        self.opcodeint = ""
         self.immediates = []
         self.op_gas = int()
         self.stack_top = []
@@ -30,7 +30,7 @@ class Execute(): # pragma: no cover
         return self.op_gas
 
     def chargeGasMem(self, mem_size_page):
-        #factor = 64
+        # factor = 64
         self.op_gas += 64 * mem_size_page
 
     def chargeGas(self, opcodeint):
@@ -42,216 +42,242 @@ class Execute(): # pragma: no cover
     def getInstruction(self, opcodeint, immediates):
         self.opcodeint = opcodeint
         dummy = []
-        #FIXME-why is it being cast to int?
+        # 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))
+        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()
-
+            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)
+            return self.run_unreachable
         elif opcodeint == 1:
-            return(self.run_nop)
+            return self.run_nop
         elif opcodeint == 2:
-            return(self.run_block)
+            return self.run_block
         elif opcodeint == 3:
-            return(self.run_loop)
+            return self.run_loop
         elif opcodeint == 4:
-            return(self.run_if)
+            return self.run_if
         elif opcodeint == 5:
-            return(self.run_else)
+            return self.run_else
         elif opcodeint == 11:
-            return(self.run_end)
+            return self.run_end
         elif opcodeint == 12:
-            return(self.run_br)
+            return self.run_br
         elif opcodeint == 13:
-            return(self.run_br_if)
+            return self.run_br_if
         elif opcodeint == 14:
-            return(self.run_br_table)
+            return self.run_br_table
         elif opcodeint == 15:
-            return(self.run_return)
+            return self.run_return
         elif opcodeint == 16:
-            return(self.run_call)
+            return self.run_call
         elif opcodeint == 17:
-            return(self.run_call_indirect)
+            return self.run_call_indirect
         elif opcodeint == 26:
-            return(self.run_drop)
+            return self.run_drop
         elif opcodeint == 27:
-            return(self.run_select)
+            return self.run_select
         elif opcodeint == 32:
-            return(self.run_getlocal)
+            return self.run_getlocal
         elif opcodeint == 33:
-            return(self.run_setlocal)
+            return self.run_setlocal
         elif opcodeint == 34:
-            return(self.run_teelocal)
+            return self.run_teelocal
         elif opcodeint == 35:
-            return(self.run_getglobal)
+            return self.run_getglobal
         elif opcodeint == 36:
-            return(self.run_setglobal)
+            return self.run_setglobal
         elif opcodeint >= 40 and opcodeint <= 53:
-            return(self.run_load)
+            return self.run_load
         elif opcodeint >= 54 and opcodeint <= 62:
-            return(self.run_store)
+            return self.run_store
         elif opcodeint == 63:
-            return(self.run_current_memory)
+            return self.run_current_memory
         elif opcodeint == 64:
             self.chargeGasMem(immediates[0])
-            return(self.run_grow_memory)
+            return self.run_grow_memory
         elif opcodeint >= 65 and opcodeint <= 68:
-            return(self.run_const)
+            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)
+            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)
+            return self.run_lt_s
         elif opcodeint == 73 or opcodeint == 84:
-            return(self.run_lt_u)
+            return self.run_lt_u
         elif opcodeint == 74 or opcodeint == 85:
-            return(self.run_gt_s)
+            return self.run_gt_s
         elif opcodeint == 75 or opcodeint == 86:
-            return(self.run_gt_u)
+            return self.run_gt_u
         elif opcodeint == 76 or opcodeint == 87:
-            return(self.run_le_s)
+            return self.run_le_s
         elif opcodeint == 77 or opcodeint == 88:
-            return(self.run_le_u)
+            return self.run_le_u
         elif opcodeint == 78 or opcodeint == 89:
-            return(self.run_ge_s)
+            return self.run_ge_s
         elif opcodeint == 79 or opcodeint == 90:
-            return(self.run_ge_u)
+            return self.run_ge_u
         elif opcodeint == 93 or opcodeint == 99:
-            return(self.run_lt)
+            return self.run_lt
         elif opcodeint == 94 or opcodeint == 100:
-            return(self.run_gt)
+            return self.run_gt
         elif opcodeint == 95 or opcodeint == 101:
-            return(self.run_le)
+            return self.run_le
         elif opcodeint == 96 or opcodeint == 102:
-            return(self.run_ge)
+            return self.run_ge
         elif opcodeint == 103 or opcodeint == 121:
-            return(self.run_clz)
+            return self.run_clz
         elif opcodeint == 104 or opcodeint == 122:
-            return(self.run_ctz)
+            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)
+            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)
+            return self.run_div_s
         elif opcodeint == 110 or opcodeint == 128:
-            return(self.run_div_u)
+            return self.run_div_u
         elif opcodeint == 111 or opcodeint == 129:
-            return(self.run_rem_s)
+            return self.run_rem_s
         elif opcodeint == 112 or opcodeint == 130:
-            return(self.run_rem_u)
+            return self.run_rem_u
         elif opcodeint == 113 or opcodeint == 131:
-            return(self.run_and)
+            return self.run_and
         elif opcodeint == 114 or opcodeint == 132:
-            return(self.run_or)
+            return self.run_or
         elif opcodeint == 115 or opcodeint == 133:
-            return(self.run_xor)
+            return self.run_xor
         elif opcodeint == 116 or opcodeint == 134:
-            return(self.run_shl)
+            return self.run_shl
         elif opcodeint == 117 or opcodeint == 135:
-            return(self.run_shr_s)
+            return self.run_shr_s
         elif opcodeint == 118 or opcodeint == 136:
-            return(self.run_shr_u)
+            return self.run_shr_u
         elif opcodeint == 119 or opcodeint == 137:
-            return(self.run_rotl)
+            return self.run_rotl
         elif opcodeint == 120 or opcodeint == 138:
-            return(self.run_rotr)
+            return self.run_rotr
         elif opcodeint == 139 or opcodeint == 153:
-            return(self.run_abs)
+            return self.run_abs
         elif opcodeint == 140 or opcodeint == 154:
-            return(self.run_neg)
+            return self.run_neg
         elif opcodeint == 141 or opcodeint == 155:
-            return(self.run_ceil)
+            return self.run_ceil
         elif opcodeint == 142 or opcodeint == 156:
-            return(self.run_floor)
+            return self.run_floor
         elif opcodeint == 143 or opcodeint == 157:
-            return(self.run_trunc)
+            return self.run_trunc
         elif opcodeint == 144 or opcodeint == 158:
-            return(self.run_nearest)
+            return self.run_nearest
         elif opcodeint == 145 or opcodeint == 159:
-            return(self.run_sqrt)
+            return self.run_sqrt
         elif opcodeint == 149 or opcodeint == 163:
-            return(self.run_div)
+            return self.run_div
         elif opcodeint == 150 or opcodeint == 164:
-            return(self.run_min)
+            return self.run_min
         elif opcodeint == 151 or opcodeint == 165:
-            return(self.run_max)
+            return self.run_max
         elif opcodeint == 152 or opcodeint == 166:
-            return(self.run_copysign)
+            return self.run_copysign
         elif opcodeint == 167:
-            return(self.run_i32wrapi64)
+            return self.run_i32wrapi64
         elif opcodeint == 168:
-            return(self.run_i32trunc_sf32)
+            return self.run_i32trunc_sf32
         elif opcodeint == 169:
-            return(self.run_i32trunc_uf32)
+            return self.run_i32trunc_uf32
         elif opcodeint == 170:
-            return(self.run_i32trunc_sf64)
+            return self.run_i32trunc_sf64
         elif opcodeint == 171:
-            return(self.run_i32trunc_uf64)
+            return self.run_i32trunc_uf64
         elif opcodeint == 172:
-            return(self.run_i64extend_si32)
+            return self.run_i64extend_si32
         elif opcodeint == 173:
-            return(self.run_i64extend_ui3o)
+            return self.run_i64extend_ui3o
         elif opcodeint == 174:
-            return(self.run_i64trunc_sf32)
+            return self.run_i64trunc_sf32
         elif opcodeint == 175:
-            return(self.run_i64trunc_uf32)
+            return self.run_i64trunc_uf32
         elif opcodeint == 176:
-            return(self.run_i64trunc_sf64)
+            return self.run_i64trunc_sf64
         elif opcodeint == 177:
-            return(self.run_i64trunc_uf64)
+            return self.run_i64trunc_uf64
         elif opcodeint == 178:
-            return(self.run_f32convert_si32)
+            return self.run_f32convert_si32
         elif opcodeint == 179:
-            return(self.run_f32convert_ui32)
+            return self.run_f32convert_ui32
         elif opcodeint == 180:
-            return(self.run_f32convert_si64)
+            return self.run_f32convert_si64
         elif opcodeint == 181:
-            return(self.run_f32convert_ui64)
+            return self.run_f32convert_ui64
         elif opcodeint == 182:
-            return(self.run_f32demotef64)
+            return self.run_f32demotef64
         elif opcodeint == 183:
-            return(self.run_f64convert_si32)
+            return self.run_f64convert_si32
         elif opcodeint == 184:
-            return(self.run_f64convert_ui32)
+            return self.run_f64convert_ui32
         elif opcodeint == 185:
-            return(self.run_f64convert_si64)
+            return self.run_f64convert_si64
         elif opcodeint == 186:
-            return(self.run_f64convert_ui64)
+            return self.run_f64convert_ui64
         elif opcodeint == 187:
-            return(self.run_f64promotef32)
+            return self.run_f64promotef32
         elif opcodeint == 188:
-            return(self.run_i32reinterpretf32)
+            return self.run_i32reinterpretf32
         elif opcodeint == 189:
-            return(self.run_i64reinterpretf64)
+            return self.run_i64reinterpretf64
         elif opcodeint == 190:
-            return(self.run_f32reinterpreti32)
+            return self.run_f32reinterpreti32
         elif opcodeint == 191:
-            return(self.run_f64reinterpreti64)
+            return self.run_f64reinterpreti64
         else:
-            raise Exception(Colors.red + 'unknown opcode' + Colors.ENDC)
+            raise Exception(Colors.red + "unknown opcode" + Colors.ENDC)
 
     def run_unreachable(self, opcodeint, immediates):
         # trap
@@ -262,7 +288,9 @@ class Execute(): # pragma: no cover
         pass
 
     def run_block(self, opcodeint, immediates):
-        self.machinestate.Stack_Label.append(self.machinestate.Stack_Label_Height)
+        self.machinestate.Stack_Label.append(
+            self.machinestate.Stack_Label_Height
+        )
         self.machinestate.Stack_Label_Height += 1
 
     def run_loop(self, opcodeint, immediates):
@@ -270,7 +298,9 @@ class Execute(): # pragma: no cover
         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.append(
+            self.machinestate.Stack_Label_Height
+        )
         self.machinestate.Stack_Label_Height += 1
         val = self.machinestate.Stack_Omni.pop()
         if val != 0:
@@ -285,18 +315,26 @@ class Execute(): # pragma: no cover
         pass
 
     def run_end(self, opcodeint, immediates):
-        #self.machinestate.Stack_Label.pop()
+        # 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)
+            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)
+            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()
+        # 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()
@@ -328,11 +366,15 @@ class Execute(): # pragma: no cover
         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()
+        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]
+        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]]
@@ -345,75 +387,141 @@ class Execute(): # pragma: no cover
     # 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]
+            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]
+            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]
+            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]
+            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)
+            temp = np.int8(
+                self.machinestate.Linear_Memory[0][int(immediates[1])]
+            )
+            temp2 = (temp & 0x0000007F) | ((temp & 0x80) << 24)
             self.machinestate.append(np.int32(temp2))
         elif opcodeint == 45:
-            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])])
-            temp2 = temp & 0x000000ff
+            temp = np.int8(
+                self.machinestate.Linear_Memory[0][int(immediates[1])]
+            )
+            temp2 = temp & 0x000000FF
             self.machinestate.append(np.uint32(temp2))
         elif opcodeint == 46:
-            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
-            temp2 = (temp & 0x00007fff) | ((temp & 0x8000) << 16)
+            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(temp2))
         elif opcodeint == 47:
-            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
-            temp2 = temp & 0x0000ffff
+            temp = np.int8(
+                self.machinestate.Linear_Memory[0][
+                    int(immediates[1]) : int(immediates[1] + 2)
+                ]
+            )
+            temp2 = temp & 0x0000FFFF
             self.machinestate.append(np.uint32(temp2))
         elif opcodeint == 48:
-            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1])])
-            temp2 = (temp & 0x000000000000007f) | ((temp & 0x80) << 56)
+            temp = np.int8(
+                self.machinestate.Linear_Memory[0][int(immediates[1])]
+            )
+            temp2 = (temp & 0x000000000000007F) | ((temp & 0x80) << 56)
             self.machinestate.append(np.int64(temp2))
         elif opcodeint == 49:
-            temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1])])
+            temp = np.uint8(
+                self.machinestate.Linear_Memory[0][int(immediates[1])]
+            )
             self.machinestate.append(np.uint64(temp))
         elif opcodeint == 50:
-            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
-            temp2 = (temp & 0x0000000000007fff) | ((temp & 0x8000) << 48)
+            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(temp2))
         elif opcodeint == 51:
-            temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 2)])
+            temp = np.uint8(
+                self.machinestate.Linear_Memory[0][
+                    int(immediates[1]) : int(immediates[1] + 2)
+                ]
+            )
             self.machinestate.append(np.uint64(temp))
         elif opcodeint == 52:
-            temp = np.int8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 4)])
-            temp2 = (temp & 0x000000007fffffff) | ((temp & 0x80000000) << 32)
+            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(temp2))
         elif opcodeint == 53:
-            temp = np.uint8(self.machinestate.Linear_Memory[0][int(immediates[1]):int(immediates[1] + 4)])
+            temp = np.uint8(
+                self.machinestate.Linear_Memory[0][
+                    int(immediates[1]) : int(immediates[1] + 4)
+                ]
+            )
             self.machinestate.append(np.uint64(temp))
         else:
-            raise Exception(Colors.red + 'invalid load instruction.' + Colors.ENDC)
+            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
+            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
+            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
@@ -422,26 +530,48 @@ class Execute(): # pragma: no cover
             pass
         elif opcodeint == 58:
             val = self.machinestate.Stack_Omni.pop()
-            self.machinestate.Linear_Memory[0][int(immediates[1])] = np.in8(val & 0x000000ff)
+            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)
+            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)
+            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)
+            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)
+            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)
+            raise Exception(
+                Colors.red + "invalid store instruction" + Colors.ENDC
+            )
 
     def run_current_memory(self, opcodeint, immediates):
         pass
@@ -459,7 +589,9 @@ class Execute(): # pragma: no cover
         elif opcodeint == 68:
             self.machinestate.Stack_Omni.append(immediates[0])
         else:
-            raise Exception(Colors.red + 'invalid const instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid const instruction" + Colors.ENDC
+            )
 
     def run_eqz(self, opcodeint, immediates):
         if opcodeint == 69 or opcodeint == 80:
@@ -469,10 +601,17 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid eqz instruction' + Colors.ENDC)
+            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:
+        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:
@@ -480,10 +619,17 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid eq instruction' + Colors.ENDC)
+            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:
+        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:
@@ -491,7 +637,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid ne instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid ne instruction" + Colors.ENDC
+            )
 
     def run_lt_s(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -507,7 +655,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid lt_s instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid lt_s instruction" + Colors.ENDC
+            )
 
     def run_lt_u(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -523,7 +673,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid lt_u instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid lt_u instruction" + Colors.ENDC
+            )
 
     def run_gt_s(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -539,7 +691,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid gt_s instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid gt_s instruction" + Colors.ENDC
+            )
 
     def run_gt_u(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -555,7 +709,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid gt_u instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid gt_u instruction" + Colors.ENDC
+            )
 
     def run_le_s(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -571,7 +727,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid le_s instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid le_s instruction" + Colors.ENDC
+            )
 
     def run_le_u(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -587,7 +745,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid le_u instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid le_u instruction" + Colors.ENDC
+            )
 
     def run_ge_s(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -603,7 +763,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid ge_s instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid ge_s instruction" + Colors.ENDC
+            )
 
     def run_ge_u(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -619,7 +781,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid ge_u instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid ge_u instruction" + Colors.ENDC
+            )
 
     def run_lt(self, opcodeint, immediates):
         v2 = self.machinestate.Stack_Omni.pop()
@@ -635,7 +799,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid lt instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid lt instruction" + Colors.ENDC
+            )
 
     def run_gt(self, opcodeint, immediates):
         v2 = self.machinestate.Stack_Omni.pop()
@@ -651,7 +817,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid gt instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid gt instruction" + Colors.ENDC
+            )
 
     def run_le(self, opcodeint, immediates):
         v2 = self.machinestate.Stack_Omni.pop()
@@ -667,7 +835,9 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid le instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid le instruction" + Colors.ENDC
+            )
 
     def run_ge(self, opcodeint, immediates):
         v2 = self.machinestate.Stack_Omni.pop()
@@ -683,34 +853,42 @@ class Execute(): # pragma: no cover
             else:
                 self.machinestate.Stack_Omni.append(0)
         else:
-            raise Exception(Colors.red + 'invalid ge instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid ge instruction" + Colors.ENDC
+            )
 
     def run_clz(self, opcodeint, immediates):
         val = self.machinestate.Stack_Omni.pop()
         if opcodeint == 103:
-            self.machinestate.Stack_Omni.append(clz(val, 'uint32'))
+            self.machinestate.Stack_Omni.append(clz(val, "uint32"))
         elif opcodeint == 121:
-            self.machinestate.Stack_Omni.append(clz(val, 'uint64'))
+            self.machinestate.Stack_Omni.append(clz(val, "uint64"))
         else:
-            raise Exception(Colors.red + 'invalid clz instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid clz instruction" + Colors.ENDC
+            )
 
     def run_ctz(self, opcodeint, immediates):
         val = self.machinestate.Stack_Omni.pop()
         if opcodeint == 104:
-            self.machinestate.Stack_Omni.append(ctz(val, 'uint32'))
+            self.machinestate.Stack_Omni.append(ctz(val, "uint32"))
         elif opcodeint == 122:
-            self.machinestate.Stack_Omni.append(ctz(val, 'uint64'))
+            self.machinestate.Stack_Omni.append(ctz(val, "uint64"))
         else:
-            raise Exception(Colors.red + 'invalid ctz instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid ctz instruction" + Colors.ENDC
+            )
 
     def run_popcnt(self, opcodeint, immediates):
         val = self.machinestate.Stack_Omni.pop()
         if opcodeint == 105:
-            self.machinestate.Stack_Omni.append(pop_cnt(val, 'uint32'))
+            self.machinestate.Stack_Omni.append(pop_cnt(val, "uint32"))
         elif opcodeint == 123:
-            self.machinestate.Stack_Omni.append(pop_cnt(val, 'uint64'))
+            self.machinestate.Stack_Omni.append(pop_cnt(val, "uint64"))
         else:
-            raise Exception(Colors.red + 'invalid popcnt instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid popcnt instruction" + Colors.ENDC
+            )
 
     def run_add(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -724,7 +902,9 @@ class Execute(): # pragma: no cover
         elif opcodeint == 160:
             self.machinestate.Stack_Omni.append(np.float64(val1 + val2))
         else:
-            raise Exception(Colors.red + 'invalid add instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid add instruction" + Colors.ENDC
+            )
 
     def run_sub(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -738,7 +918,9 @@ class Execute(): # pragma: no cover
         elif opcodeint == 161:
             self.machinestate.Stack_Omni.append(np.float64(val1 - val2))
         else:
-            raise Exception(Colors.red + 'invalid sub instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid sub instruction" + Colors.ENDC
+            )
 
     def run_mul(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -752,107 +934,169 @@ class Execute(): # pragma: no cover
         elif opcodeint == 162:
             self.machinestate.Stack_Omni.append(np.float64(val1 * val2))
         else:
-            raise Exception(Colors.red + 'invalid mul instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.int64(np.int64(val1) / np.int64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid div_s instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) / np.uint64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid div_u instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.int64(np.int64(val1) % np.int64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid rem_s instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) % np.uint64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid rem_u instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) & np.uint64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid and instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) | np.uint64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid or instruction' + Colors.ENDC)
+            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)))
+            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)))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) ^ np.uint64(val2))
+            )
         else:
-            raise Exception(Colors.red + 'invalid xor instruction' + Colors.ENDC)
+            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))))
+            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))))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) << (np.uint64(val2)))
+            )
         else:
-            raise Exception(Colors.red + 'invalid shl instruction' + Colors.ENDC)
+            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))))
+            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))))
+            self.machinestate.Stack_Omni.append(
+                np.int64(np.int64(val1) >> (np.int64(val2)))
+            )
         else:
-            raise Exception(Colors.red + 'invalid shr_s instruction' + Colors.ENDC)
+            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))))
+            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))))
+            self.machinestate.Stack_Omni.append(
+                np.uint64(np.uint64(val1) >> (np.uint64(val2)))
+            )
         else:
-            raise Exception(Colors.red + 'invalid shr_u instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid shr_u instruction" + Colors.ENDC
+            )
 
     def run_rotl(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -862,7 +1106,9 @@ class Execute(): # pragma: no cover
         elif opcodeint == 137:
             self.machinestate.Stack_Omni.append(rol(val1, 64, val2))
         else:
-            raise Exception(Colors.red + 'invalid rotl instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid rotl instruction" + Colors.ENDC
+            )
 
     def run_rotr(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -872,55 +1118,71 @@ class Execute(): # pragma: no cover
         elif opcodeint == 138:
             self.machinestate.Stack_Omni.append(ror(val1, 32, val2))
         else:
-            raise Exception(Colors.red + 'invalid rotl instruction' + Colors.ENDC)
+            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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            raise Exception(
+                Colors.red + "invalid sqrt instruction" + Colors.ENDC
+            )
 
     def run_div(self, opcodeint, immediates):
         v2 = self.machinestate.Stack_Omni.pop()
@@ -928,7 +1190,9 @@ class Execute(): # pragma: no cover
         if opcodeint == 149:
             self.machinestate.Stack_Omni.append(v1 / v2)
         else:
-            raise Exception(Colors.red + 'invalid float div instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid float div instruction" + Colors.ENDC
+            )
 
     def run_min(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -936,7 +1200,9 @@ class Execute(): # pragma: no cover
         if opcodeint == 150 or opcodeint == 164:
             self.machinestate.Stack_Omni.append(min(val1, val2))
         else:
-            raise Exception(Colors.red + 'invalid min instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid min instruction" + Colors.ENDC
+            )
 
     def run_max(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -944,7 +1210,9 @@ class Execute(): # pragma: no cover
         if opcodeint == 151 or opcodeint == 165:
             self.machinestate.Stack_Omni.append(max(val1, val2))
         else:
-            raise Exception(Colors.red + 'invalid max instruction' + Colors.ENDC)
+            raise Exception(
+                Colors.red + "invalid max instruction" + Colors.ENDC
+            )
 
     def run_copysign(self, opcodeint, immediates):
         val2 = self.machinestate.Stack_Omni.pop()
@@ -952,7 +1220,9 @@ class Execute(): # pragma: no cover
         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)
+            raise Exception(
+                Colors.red + "invalid max instruction" + Colors.ENDC
+            )
 
     def run_i32wrapi64(self, opcodeint, immediates):
         val1 = self.machinestate.Stack_Omni.pop()