diff --git a/2019/day7/day7.hs b/2019/day7/day7.hs
index 248c380..7403ac1 100644
--- a/2019/day7/day7.hs
+++ b/2019/day7/day7.hs
@@ -2,7 +2,6 @@ import Data.List.Split
 import qualified Data.List as L
 import Data.Vector as V
 import Data.Char
-import System.Exit
 
 main = do
     content <- readFile "input"
@@ -10,8 +9,16 @@ main = do
     print $ find_max tape [0..4]
     print $ find_max tape [5..9]
 
+data OutAction = Continue | Output | Halt deriving (Enum, Eq, Show)
+type Tape = Vector Int
+type TapeSection = Vector Int
+type TuringMachine = (Tape,Int)
+
+run_amps_feedback :: Tape -> [Int] -> Int
 run_amps_feedback tape intseq = L.head $ run_amps_feedback' tms intseq [0]
     where tms = L.replicate 5 (tape,0)
+
+run_amps_feedback' :: [TuringMachine] -> [Int] -> [Int] -> [Int]
 run_amps_feedback' ((t,p):tms) intseq prev =
     if halt == Halt then prev else
         run_amps_feedback' (tms L.++ [tm_new]) tailseq tm_out
@@ -19,8 +26,10 @@ run_amps_feedback' ((t,p):tms) intseq prev =
           tailseq = if L.null intseq then [] else L.tail intseq
           xprev = if L.null intseq then prev else (L.head intseq):prev
 
+find_max :: Tape -> [Int] -> Int
 find_max tape range = L.maximum [run_amps_feedback tape xs | xs <- L.permutations range]
 
+opl :: Int -> Int
 opl x
     | n`L.elem`"1278"=4
     | n`L.elem`"56"=3
@@ -32,39 +41,43 @@ parsemodes :: String -> [Bool]
 parsemodes m = L.replicate (3 - L.length l) False L.++ l
     where l = L.map (toEnum . digitToInt) m
 
+paramch :: [Bool] -> TapeSection -> Tape -> TapeSection
 paramch m opvec t = imap f (V.tail opvec)
     where f i a = if (L.reverse m) !! i then a else t ! a
 
+getopmodes :: TapeSection -> (String, [Bool])
 getopmodes opvec = (op_dedup,parsed_modes)
     where (op,modes) = L.splitAt 2 $ L.reverse $ show $ opvec ! 0
           parsed_modes = parsemodes $ L.reverse modes
           op_dedup = if L.last op == '0' then [L.head op] else op
 
-data OutAction = Continue | Output | Halt deriving (Enum, Eq, Show)
 
-step :: Vector Int -> (Vector Int, Int, [Int], [Int]) -> (Vector Int, Int, OutAction, [Int], [Int])
-step opvec (t,p,input,val)
-        | op=="1" = ((t // [((V.last opvec), (params ! 0) + (params ! 1))]),p,Continue,input,val)
-        | op=="2" = ((t // [((V.last opvec), (params ! 0) * (params ! 1))]),p,Continue,input,val)
-        | op=="3" = ((t // [((V.last opvec), L.head input)]),p,Continue,L.tail input,val)
-        | op=="4" = (t,p,Output,input,(V.last $ params):val)
-        | op=="5" = (t, if (params ! 0)/=0 then (params ! 1) else p,Continue,input,val)
-        | op=="6" = (t, if (params ! 0)==0 then (params ! 1) else p,Continue,input,val)
-        | op=="7" = ((t // [((V.last opvec), if (params ! 0)<(params ! 1)
-                        then 1 else 0)]),p,Continue,input,val)
-        | op=="8" = ((t // [((V.last opvec), if (params ! 0)==(params ! 1)
-                        then 1 else 0)]),p,Continue,input,val)
-        | op=="99" = (t,p,Halt,input,val)
+step :: TapeSection -> (TuringMachine, [Int], [Int]) -> (TuringMachine, OutAction, [Int], [Int])
+step opvec ((t,p),input,val)
+        | op=="1" = (tm_binop (+),Continue,input,val)
+        | op=="2" = (tm_binop (*),Continue,input,val)
+        | op=="3" = (new_tm t (L.head input),Continue,L.tail input,val)
+        | op=="4" = ((t,p),Output,input,(V.last $ params):val)
+        | op=="5" = ((t, if (params ! 0)/=0 then (params ! 1) else p),Continue,input,val)
+        | op=="6" = ((t, if (params ! 0)==0 then (params ! 1) else p),Continue,input,val)
+        | op=="7" = (new_tm t (if (params ! 0)<(params ! 1)
+                    then 1 else 0),Continue,input,val)
+        | op=="8" = (new_tm t (if (params ! 0)==(params ! 1)
+                    then 1 else 0),Continue,input,val)
+        | op=="99" = ((t,p),Halt,input,val)
         where (op,m) = getopmodes opvec
               params = paramch m opvec t
+              tm_binop x = new_tm t ((params ! 0) `x` (params ! 1))
+              new_tm t x = ((t // [((V.last opvec), x)]),p)
 
-exec_steps :: ((Vector Int, Int), [Int], [Int], OutAction) -> ((Vector Int, Int), [Int], [Int], OutAction)
-exec_steps ((t,p),input,val,halt) =
+
+exec_steps :: (TuringMachine, [Int], [Int], OutAction) -> (TuringMachine, [Int], [Int], OutAction)
+exec_steps ((t,p),input,output,halt) =
     let command_length = opl $ t ! p
         opvec = slice p command_length t
-        (t_new,p_new,cond,input_new,val_new) =
-            step opvec (t,p+command_length,input,val) in
-    if cond == Output || cond == Halt then ((t_new,p_new),input_new,val_new,cond)
-        else exec_steps ((t_new,p_new),input_new,val_new,cond)
+        ((t_new,p_new),cond,input_new,output_new) =
+            step opvec ((t,p+command_length),input,output) in
+    if cond `L.elem` [Output, Halt] then ((t_new,p_new),input_new,output_new,cond)
+        else exec_steps ((t_new,p_new),input_new,output_new,cond)