diff --git a/main.py b/main.py
index 61f0b71..6a60527 100644
--- a/main.py
+++ b/main.py
@@ -3,86 +3,79 @@
 
 #0-255 is internal registers and flags and etc
 # program execcution starts at 256
-#stack starts at 65535 FILO
-
-#0  IP      #Instruction Pointer
-#1	EAX
-#2	EBX
-#3	ECX
-#4	EDX
-#5	ESI
-#6	EDI
-#7	ESP     #stack pointer
-#8	EBP
-#9  FLAG    #Read-Only contains the flags
+#stack starts at end of memory FILO
 
 
-#list of opcodes
-#0 interrupt
-#1 reset
-#2 debug info (nop)
-#3 mov
-#4 push (onto stack)
-#5 pop  (off of stack into address)
-
-
-import math
 import numpy as np
 import opcodes as ops
+from registers import Registers
 np.set_printoptions(threshold=np.inf)
 
 
 
-class Zomcpu:
+class ZombieCPU:
+    _regs = Registers()
     def __init__(self, memorysize=None, debug=None):
-        print('Processor Init')
         self._memorysize = memorysize
         self._memory = np.zeros(memorysize)
         self._debug = debug
         
+        
     def reset(self):
-        print('Processor Resetting')
+        if self._debug:
+            print('Processor Reseting')
         self._memory = np.zeros(self._memorysize) #clear memory
         
-        self._memory[7] = self._memorysize - 1 #set stackpointer
-        self._memory[0] = 256 #set instructiojn pointer
+        self._regs.esp = self._memorysize - 1 #set stackpointer
+        self._regs.eip = 256 #set instructiojn pointer #fuck you thomas
         
     def exec(self):
         Halted = False
         while not Halted: #change this to if not halt
             #fetch
-            opcode = self._memory[int(self._memory[0])]
-            address = self._memory[int(self._memory[0] + 1)]
-            value = self._memory[int(self._memory[0] + 2)]
+            
+            opcode = self._memory[int(self._regs.eip)]
+            address = self._memory[int(self._regs.eip + 1)]
+            value = self._memory[int(self._regs.eip + 2)]
             
             if self._debug:
-                print(f'Opcode: {opcode}\nAddress: {address}\nValue: {value}\nIP: {self._memory[0]}')
+                print(f'Opcode: {opcode}\nAddress: {address}\nValue: {value}\nIP: {self._regs.eip}')
             
             if opcode == ops.NOP:
                 pass
             
             elif opcode == ops.HLT:
                 Halted = True
-                print('Processor Halted')
+                if self._debug:
+                	print('Processor Halted')
 
             elif opcode == ops.RST: #reset
                 self.reset()
             
-            elif opcode == ops.DBG: #debug enable
+            elif opcode == ops.DBG: #debug toggle
                 self._debug = value
                 
             elif opcode == ops.LDI: #mov but actually load immediate
                 self.write_memory(address, value)
+                if value == 0:
+                    self._regs.flags = self._regs.flags | 0b00000001
                 
             elif opcode == ops.PUSH: #push
-                self.write_memory(self._memory[7], value) #put value onto stack
-                self.write_memory(7, self._memory[7] - 1) #dec stackpointer
+                self.write_memory(self._regs.esp, value) #put value onto stack
+                self._regs.esp -= 1 #dec stackpointer
                 
             elif opcode == ops.POP: #pop
-                self.write_memory(address, self.read_memory_address(self._memory[7] + 1)) #read the last value and put it into address (not the empty space)
-                self.write_memory(7, self._memory[7] + 1) #inc stackpointer
+                self.write_memory(address, self.read_memory_address(self._regs.esp + 1)) #read the last value and put it into address (not the empty space)
+                self._regs.esp += 1 #inc stackpointer
+            
+            elif opcode == ops.JMP:
+                self._regs.eip = address - 3
                 
-            self._memory[0] += 3 #increment instruction pointer
+            elif opcode == ops.JZ:
+                if self._regs.flags & 0b00000001:
+                    self._regs.eip = address - 3
+                
+            self._regs.eip += 3 #increment instruction pointer
             
     
     def set_memory(self, memory):
@@ -95,7 +88,7 @@ class Zomcpu:
         return self._memory[int(address)]
         
 if __name__ == "__main__":
-    cpu = Zomcpu(65536, True)
+    cpu = ZombieCPU(65536, False)
     cpu.reset()
     
     #hard coded opcodes
@@ -108,15 +101,11 @@ if __name__ == "__main__":
     cpu.write_memory(262, ops.POP)    #pop
     cpu.write_memory(263, 100)  #into 100
     cpu.write_memory(264, 0)    #unused in this op
-    cpu.write_memory(265, 1)    #halt
-                     
-    
+    cpu.write_memory(265, ops.HLT)    #jmp
     
 
     cpu.exec()
-    print(cpu.read_memory_address(100))
-    print(cpu.read_memory_address(264))
-    print(cpu.read_memory_address(7))
+
 
     #c = Console(cpu.read_memory()) ima finish this later
     #c.draw()
diff --git a/opcodes.py b/opcodes.py
index e2cdff1..e8697fa 100644
--- a/opcodes.py
+++ b/opcodes.py
@@ -1,7 +1,9 @@
-NOP  = 0  # No operation
-HLT  = 1  # Halt
-RST  = 2  # Reset
-DBG  = 3  # Enables Debug
-LDI  = 4  # Load Immediate
-PUSH = 5  # Push
-POP  = 6  # Pop 
+NOP     = 0 # No operation
+HLT     = 1 # Halt
+RST     = 2 # Reset
+DBG     = 3 # Enables Debug
+LDI     = 4 # Load Immediate
+PUSH    = 5 # Push
+POP     = 6 # Pop 
+JMP     = 7 # Jump to address
+JNZ     = 8 # Jump to address if not zero
diff --git a/registers.py b/registers.py
new file mode 100644
index 0000000..6291151
--- /dev/null
+++ b/registers.py
@@ -0,0 +1,11 @@
+class Registers:
+    eip = 0 # instruction pointer
+    eax = 0
+    ebx = 0
+    ecx = 0
+    edx = 0
+    esi = 0 # source
+    edi = 0 # destination
+    esp = 0 # stack pointer
+    ebp = 0
+    flags = 0b00000000	#flags ob