                             default:
                                 throw DecodeError(cause: .stepMismatch, stack: stepStack)
                             }
+                            runtime.releaseResult[Int(a.step)] = stepStack[Int(a.level)]
                         }
                     } else {
                         guard a.level < stack.count else { throw DecodeError(cause: .argumentMissing, stack: stepStack) }

                        let runtime = stack[Int(a.level)]
                        if let t = runtime.results[Int(a.step)] {
                            if t != type { throw DecodeError(cause: .stepMismatch, stack: stepStack) }
                        } else {
                            guard a.step < function.steps.count, case .functionRaw(let f)? = function.steps[Int(a.step)].producer else { throw DecodeError(cause: .stepMissing, stack: stepStack) }
                            switch type {\n

        }
        output.append("""
                        }
                        releaseResult[i]?.forEach { runtime.results[$0] = nil }
                    }
                    if !function.hasReturnStep { return nil }
                    let returnValue = value(function.returnStep, in: stack)
                    if let returnFunction = returnValue as? Function {
                        return { self.run(function: returnFunction, symbols: symbols, stack: stack + [Runtime(arguments: $0)], stepStack: stepStack + [function.steps.count]) }
                    } else {
                        return returnValue
                    }
