anchor.diff:                          | SimpleIdentifier id -> id
                           | _ -> failwith "Initialisation should only contain a simpleIdentifier as name"
                 let! (toStoreName, toStoreType, code) = internalCodeGen rhs
  -              let toUpdateName = sprintf "%%%s" sId
  +              let toUpdateName = sId
                 let! toUpdateType = findRegister toUpdateName
                 let! (_,_,storeCode) = genStore toStoreName toStoreType toUpdateName toUpdateType
                 let fullString = sprintf "%s\n%s" code storeCode
  
positive.code:               match id with
                | SimpleIdentifier str -> 
                  let! regName = freshReg
                  let toLoadName = (sprintf "%c%s" '%' str)
                  let! toLoadType = findRegister toLoadName
                  let! loadedValue = genLoad regName toLoadType toLoadName
                  //return (sprintf "%c%s" '%' str, "i32")
                  return loadedValue
            }
          | Function (funcName, arguments, types, body) -> 
  
negative.code:         | Receive (msgName, msgType, body) -> 
            // TODO: lige nu gør vi ikke det rigtige ved receive. Vi genererer bare for body. SKal vi ikke gøre mere?
            internalCodeGen body
          | ForIn (elem, list', body) -> 
            state {
                let! idxCounterRegName = freshReg
                let idxCounterLValue = {identity = SimpleIdentifier idxCounterRegName; isMutable = true; primitiveType = SimplePrimitive Int}
                let! (idxCounterVal, idxCounterType, idxCounterCode) = internalCodeGen (Initialisation (idxCounterLValue, Constant (SimplePrimitive Int, PrimitiveValue.Int 0)))
  
                let (elemType, listLength) = match list' with
                                                | ListRange (contents, ListPrimitive (ptype, n)) -> (ptype, n)
                                                | Identifier (_, ListPrimitive (ptype, n)) -> (ptype, n)
                
                let conditionAST = BinOperation (
                                     Identifier (SimpleIdentifier idxCounterRegName, SimplePrimitive Int), 
                                     NotEquals, 
                                     Constant (SimplePrimitive Int, PrimitiveValue.Int listLength)
                                   ) 
                let incrementCounter = BinOperation (
                                         Identifier (SimpleIdentifier idxCounterRegName, elemType),
                                         Plus,
                                         Constant (SimplePrimitive Int, PrimitiveValue.Int 1)
                                       )
  
                let reassCounter = Reassignment (
                                         SimpleIdentifier idxCounterRegName,
                                         incrementCounter
                                         )
  
                let! tempElemAssign = freshReg
                let! (_,_,allocatedTempElemAssign) = genAlloca tempElemAssign (genType elemType)
               
                // TODO: assign element til elem
                //let elemAssign = Reassignment (SimpleIdentifier elem, Identifier (SimpleIdentifier tempElemAssign, elemType)) // TODO
  
                let bodyAST = Body [ body; reassCounter]
                let whileCodeAST = While (conditionAST, bodyAST)
  
                let declElemCodeLValue = {identity = SimpleIdentifier elem; isMutable = true; primitiveType = elemType}
                let declElemDefaultVal = match elemType with
                                         | SimplePrimitive Int -> PrimitiveValue.Int 0
                let declElemCodeAST = Initialisation (declElemCodeLValue, Constant (elemType, declElemDefaultVal))
                let! (_,_, declElemCode) = internalCodeGen declElemCodeAST
                let! (_,_,whileCode) = internalCodeGen whileCodeAST
                let fullString = sprintf "%s\n%s\n%s\n" idxCounterCode declElemCode whileCode
                return ("","",fullString)
            }
          | ListRange (contents, pType) -> 
            state {
  