exec (CallProc pName args) execModel@(funModel, program) state =
  let

    calledProcedure :: ProcedureDeclaration
    calledProcedure = getProc pName program

    -- | Params matched with Expresions
    paredParamsAndArgs :: [(Parameter, Expr)]
    paredParamsAndArgs = zip (procParams calledProcedure) args

    -- | Params matched with Expresions, filtered out "Out" modes
    filteredOutParamsExpr :: [(Parameter, Expr)]
    filteredOutParamsExpr =
       (filter (\pa -> not $ isOutMode pa) paredParamsAndArgs)
       where
        isOutMode :: (Parameter, Expr) -> Bool
        isOutMode ((mode,_ ), _) = mode == Out

    -- | Params matched with Expresions, filtered out "Obs" modes
    filteredObsParamsExpr :: [(Parameter, Expr)]
    filteredObsParamsExpr =
       (filter (\pa -> not $ isObsMode pa) paredParamsAndArgs)
       where
        isObsMode :: (Parameter, Expr) -> Bool
        isObsMode ((mode,_ ), _) = mode == Obs

    preparedValues :: [Value]
    preparedValues = map (\expr -> eval (snd expr) funModel state) filteredOutParamsExpr

    preparedState :: State
    preparedState = addCallStateInputs (procParams calledProcedure) preparedValues $ S.clearEnvironment state

    performedState :: State
    performedState = performP calledProcedure execModel preparedState

    performP :: ProcedureDeclaration -> ExecutionModel -> State -> State
    performP (Proc _ params locals body) prog state =
      let
        oldStackFrame = S.getStackFrame state
        stateWithLocals = addUninitVars (map varName locals) state
        stateAfterExec = exec body prog stateWithLocals
        stateAfterCleanup = S.setStackFrame oldStackFrame stateAfterExec
        stateAfterAdd = addResults
        addResults ::  State
        addResults =
          let
            outputVars :: [Var]
            outputVars = getParamNames $ filter isOutputParameter $ params
            isOutputParameter (mode, _) = mode /= Obs
            getParamNames :: [Parameter] -> [Var]
            getParamNames = map (varName . paramVar)
            values :: [Value]
            values = map (\varName -> S.getValue varName stateAfterExec) outputVars
            varExpWithValue :: [(Expr, Value)]
            varExpWithValue = zip (map snd filteredObsParamsExpr) values

            addResult :: State -> ( Expr, Value) -> State
            addResult st ((VarExp ve), v) = S.addVariable ve v st
          in foldl addResult stateAfterCleanup varExpWithValue
      in stateAfterAdd
  in performedState