             }
 
             private class DecoderRuntime {
-                private class Runtime<T> {
-                    var results = [Int: T]()
-                    let arguments: [T]
-                    init(arguments: [T]) {
+                private struct Runtime {
+                    var results = [Int: Any]()
+                    let arguments: [Any]
+                    init(arguments: [Any]) {
                         self.arguments = arguments
                     }
                 }
 
-                private class TypecheckRuntime: Runtime<DeclarationType> {
+                private class TypecheckRuntime {
+                    var results = [Int: DeclarationType]()
+                    let arguments: [DeclarationType]
                     let function: Function
                     let returnType: DeclarationType
                     var releaseResult: [Int]
                     init(function: Function, arguments: [DeclarationType], returnType: DeclarationType) {
                         self.function = function
+                        self.arguments = arguments
                         self.returnType = returnType
                         releaseResult = Array(0..<function.steps.count)
-                        super.init(arguments: arguments)
                     }
                 }
 

        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, codePath: IndexPath) -> \(name) {
                            let raw = value(a, in: stack)
                            if let function = raw as? Function {
                                let codePath = DecoderRuntime.codePath(for: a, in: codePath)

        }
        output.append("""
                        }
                        releaseResult[i]?.forEach { stack[last].results[$0] = nil }
                    }
                    if !function.hasReturnStep { return nil }
                    let returnValue = value(function.returnStep, in: stack)
