import Data.List.Split

main = do
    let state = [3,0,4,0,99]
    let input = [83]
    let output = operation state state 0 input []  
    mapM putStrLn (map show output)

getList :: String -> [Int]
getList = map read . splitOn ","

changeInput :: [Int] -> Int -> Int -> [Int]
changeInput (begin:_:_:input) input1 input2= [begin] ++ [input1] ++ [input2] ++ input

func :: [Int] -> Int -> Int -> Int
func xs x y = do
	let input = changeInput xs x y
        head (compute input input 0 [] [] )	

compute :: [Int] -> [Int] -> Int -> [Int] -> [Int] -> [Int]
compute (99:_) state index input output = output
compute (op:x:y:z:_) state index input output= 
        compute (drop newindex state) newstate newindex input output 
        where
	    sum = if op == 1 then
                  (state !! x) + (state !! y)
	          else 
                 (state !! x) * (state !! y)
            split = splitAt z state
            newstate = (fst split) ++ [sum] ++ (drop 1 (snd split))
            newindex = index + 4

operation :: [Int] -> [Int] -> Int -> [Int] -> [Int] -> [Int]
operation (99:_) state index input output = 
	output 
operation (1:x:y:z:_) state index input output = 
	operation (drop newindex state) newstate newindex input output
	where
		sum = (state !! x) + (state !! y)
                split = splitAt z state
                newstate = (fst split) ++ [sum] ++ (drop 1(snd split))
                newindex = index + 4
operation (2:x:y:z:_) state index input output = 
	operation (drop newindex state) newstate newindex input output
        where 
		 sum = (state !! x) * (state !! y)
		 split = splitAt z state
                 newstate = (fst split) ++ [sum] ++ (drop 1 (snd split))
                 newindex = index + 4 
operation (3:z:_) state index input output= 
	operation (drop newindex state) newstate newindex newinput output
	where
	        split = splitAt z state
	        newstate = insert state (head input) z
                newinput = drop 1 input
	        newindex = index + 2
operation (4:z:_) state index input output= 
	operation (drop newindex state) state newindex input newoutput
        where
		newoutput = output ++ [(state !! z)]
                newindex = index + 2

insert ::  [Int] -> Int -> Int -> [Int]
insert xs value index = do
                let split = splitAt index xs
                (fst split)++ [value] ++ (drop 1 (snd split))