 				if (paramNames)
 					for (i = 0; i < paramNames.length; i++)
 						localSymbolTable[paramNames[i] as String] = i < arguments.length ? arguments[i] : paramDefaults[i];
-				
-				// initialize top-level function and push it onto the stack
-				call = recursiveCalls[recursion] as CompiledFunctionCall;
-				if (!call)
-					recursiveCalls[recursion] = call = (compiledObject as CompiledFunctionCall).clone();
-				recursion++;
 				
 				call.evalIndex = INDEX_METHOD;
 				stack.length = 1;

			// Each recursive call must use a clone of the CompiledFunctionCall,
			// so we keep track of recursion depth and re-use copies of the CompiledFunctionCall.
			var recursion:int = 0;
			var recursiveCalls:Array = [compiledObject];
			
			// this function avoids unnecessary function call overhead by keeping its own call stack rather than using recursion.
			var wrapperFunction:Function = function():*
			{
				const stack:Array = []; // used as a queue of function calls
				const localSymbolTable:Object = {};
				var call:CompiledFunctionCall;
				var subCall:CompiledFunctionCall;
				var compiledParams:Array;
				var method:Object;

				return function(...args):* { return value; };
			}
			
			const EVAL:* = this._eval as Function || undefined;
			
			// set up Array of symbol tables in the correct scope order: built-in, local, params, this, global
			const BUILT_IN_SYMBOL_TABLE_INDEX:int = 0;
			const LOCAL_SYMBOL_TABLE_INDEX:int = 1;
			var THIS_SYMBOL_TABLE_INDEX:int = LOCAL_SYMBOL_TABLE_INDEX + 1;
			if (symbolTable is Array)
			{
				symbolTable = (symbolTable as Array).concat();
				THIS_SYMBOL_TABLE_INDEX += symbolTable.length;
			}
			else
				THIS_SYMBOL_TABLE_INDEX += 1;
			
			// this flag is set to useThisScope when the compiledObject is a function definition
			var cascadeThisScope:Boolean = false;
