         for (name, type) in parser.types {
             if case .function(let functionType) = type {
                 output.append("""
-                        private func \(name)Value(_ a: Function.A, in stack: [Runtime<Any>], symbols: Symbols, stepStack: IndexPath) -> \(name) {
+                        private func \(name)Value(_ a: Function.A, in stack: [Runtime<Any>], symbols: Symbols, callStack: IndexPath) -> \(name) {
                             let raw = value(a, in: stack)
                             if let function = raw as? Function {
                                 return { self.run(function: function, symbols: symbols, stack: stack + [Runtime(arguments: [

                        }
                    }
                    if runtime.returnType != .none {
                        let stepStack = stepStack.appending(function.steps.count)
                        guard function.hasReturnStep else { throw DecodeError(cause: .returnMissing, stack: stepStack) }
                        try check(function.returnStep, with: runtime.returnType, function: function, stack: stack, stepStack: stepStack)
                    } else if function.hasReturnStep { throw DecodeError(cause: .returnMismatch, stack: stepStack) }
                    releaseResults[stepStack] = Dictionary(grouping: runtime.releaseResult.enumerated()) { $0.element }.mapValues { $0.map { $0.offset } }
                }
                
                func typecheck(function: Function, arguments: [DeclarationType], returnType: DeclarationType) throws {
                    try typecheck(function: function, stack: [TypecheckRuntime(arguments: arguments, returnType: returnType, count: function.steps.count)], stepStack: [])
                }

                private func value(_ a: Function.A, in stack: [Runtime<Any>]) -> Any {

            }
            writeCommaSeparated(functionType.argumentTypes.enumerated(), to: &output) {
                if case .function? = parser.typesMap[$0.element] {
                    output.append("\($0.element)Value(a.o\($0.offset + 1), in: stack, symbols: symbols, callStack: callStack)")
                } else {
                    output.append("value(a.o\($0.offset + 1), in: stack) as! \(nativeType(for: $0.element))")
                }
