package io.jawk.backend;
   
   /*-
    * ╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲
    * Jawk
    * ჻჻჻჻჻჻
    * Copyright (C) 2006 - 2026 MetricsHub
    * ჻჻჻჻჻჻
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Lesser Public License for more details.
   *
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * ╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱
   */
  
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.PrintStream;
  import java.util.AbstractSet;
  import java.util.Iterator;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.LinkedHashSet;
  import java.util.Objects;
  import java.util.ArrayDeque;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Deque;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.IdentityHashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.function.BiConsumer;
  import java.util.regex.Pattern;
  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  import io.jawk.AwkExpression;
  import io.jawk.AwkProgram;
  import io.jawk.AwkSandboxException;
  import io.jawk.ExitException;
  import io.jawk.ext.AbstractExtension;
  import io.jawk.ext.ExtensionFunction;
  import io.jawk.ext.ForInKeyOrder;
  import io.jawk.ext.JawkExtension;
  import io.jawk.intermediate.Address;
  import io.jawk.intermediate.BuiltinFunction;
  import io.jawk.intermediate.Opcode;
  import io.jawk.intermediate.PositionTracker;
  import io.jawk.intermediate.Tuple;
  import io.jawk.intermediate.Tuple.BooleanTuple;
  import io.jawk.intermediate.Tuple.CallFunctionTuple;
  import io.jawk.intermediate.Tuple.ClassTuple;
  import io.jawk.intermediate.Tuple.CountAndAppendTuple;
  import io.jawk.intermediate.Tuple.CountTuple;
  import io.jawk.intermediate.Tuple.DereferenceTuple;
  import io.jawk.intermediate.Tuple.ExtensionTuple;
  import io.jawk.intermediate.Tuple.IndirectCallTuple;
  import io.jawk.intermediate.Tuple.IndirectFunctionTarget;
  import io.jawk.intermediate.Tuple.InputFieldTuple;
  import io.jawk.intermediate.Tuple.LongTuple;
  import io.jawk.intermediate.Tuple.PushDoubleTuple;
  import io.jawk.intermediate.Tuple.PushLongTuple;
  import io.jawk.intermediate.Tuple.PushStringTuple;
  import io.jawk.intermediate.Tuple.RegexTuple;
  import io.jawk.intermediate.Tuple.ScalarPopTuple;
  import io.jawk.intermediate.Tuple.SubstitutionVariableTuple;
  import io.jawk.intermediate.Tuple.VariableTuple;
  import io.jawk.intermediate.UninitializedObject;
  import io.jawk.intermediate.UntypedObject;
  import io.jawk.jrt.AssocArray;
  import io.jawk.jrt.AwkRuntimeException;
  import io.jawk.jrt.AwkSink;
  import io.jawk.jrt.ConditionPair;
  import io.jawk.jrt.InputSource;
  import io.jawk.jrt.JRT;
  import io.jawk.jrt.VariableManager;
  import io.jawk.util.AwkSettings;
  import io.jawk.jrt.BSDRandom;
  
  /**
   * The Jawk interpreter.
   * <p>
   * It takes tuples constructed by the intermediate step
   * and executes each tuple in accordance to their instruction semantics.
   * The tuples correspond to the Awk script compiled by the parser.
   * The interpreter consists of an instruction processor (interpreter),
   * a runtime stack, and machinery to support the instruction set
  * contained within the tuples.
  * <p>
  * The interpreter runs completely independent of the frontend/intermediate step.
  * In fact, an intermediate file produced by Jawk is sufficient to
  * execute on this interpreter. The binding data-structure is
  * the {@link AwkSettings}, which can contain options pertinent to
  * the interpreter. For example, the interpreter must know about
  * the -v command line argument values, as well as the file/variable list
  * parameter values (ARGC/ARGV) after the script on the command line.
  * However, if programmatic access to the AVM is required, meaningful
  * {@link AwkSettings} are not required.
  * <p>
  * Semantic analysis has occurred prior to execution of the interpreter.
  * Therefore, the interpreter throws AwkRuntimeExceptions upon most
  * errors/conditions. It can also throw a <code>java.lang.Error</code> if an
  * interpreter error is encountered.
  * <p>
  * AVM instances are reusable, but they are not thread-safe. Reuse the same
  * interpreter only sequentially, or create one AVM per concurrent execution.
  * When AVM is used directly, callers own its lifecycle and must
  * {@link #close()} it when done.
  *
  * @author Danny Daglas
  */
 public class AVM implements VariableManager, Closeable {
 
 	private RuntimeStack runtimeStack = new RuntimeStack();
 
 	// operand stack: a flat Object[] with an explicit top index so push/pop
 	// stay single array accesses; depth is bounded by expression nesting, so
 	// the array stays small and rarely grows
 	private Object[] operandStack = new Object[INITIAL_OPERAND_STACK_CAPACITY];
 	private int operandStackSize;
 	// Untyped array elements currently passed as user-function arguments, in
 	// call order. Each reference lives exactly as long as the call frame that
 	// received it, so this stack stays empty unless an untyped element
 	// argument is in flight.
 	private final Deque<IndirectArrayArgumentReference> elementArgumentReferences = new ArrayDeque<IndirectArrayArgumentReference>();
 	private List<String> arguments;
 	private boolean sortedArrayKeys;
 	private final Map<String, Object> baseInitialVariables;
 	private final Map<String, Object> baseSpecialVariables;
 	private Map<String, Object> executionInitialVariables;
 	private Map<String, Object> executionSpecialVariables;
 	private JRT jrt;
 	private Map<String, JawkExtension> extensionInstances;
 
 	private static final int INITIAL_OPERAND_STACK_CAPACITY = 64;
 
 	// stack methods
 	private Object pop() {
 		Object value = operandStack[--operandStackSize];
 		operandStack[operandStackSize] = null;
 		return value;
 	}
 
 	private void push(Object o) {
 		if (operandStackSize == operandStack.length) {
 			operandStack = Arrays.copyOf(operandStack, operandStack.length * 2);
 		}
 		operandStack[operandStackSize++] = o;
 	}
 
 	private void clearOperandStack() {
 		Arrays.fill(operandStack, 0, operandStackSize, null);
 		operandStackSize = 0;
 	}
 
 	private final AwkSettings settings;
 	private final boolean profiling;
 	private final Map<Opcode, ProfilingReport.Accumulator> tupleProfilingStats;
 	private final Map<String, ProfilingReport.Accumulator> functionProfilingStats;
 	private final Deque<ActiveFunction> activeProfilingFunctions;
 	private InputSource resolvedInputSource;
 	private AwkExpression installedEvalExpression;
 	private boolean mergedGlobalLayoutActive;
 
 	/** Optional extension-provided ordering for {@code for (index in array)} traversal. */
 	private ForInKeyOrder forInKeyOrder;
 
 	/** Description of the primary script source, for runtime diagnostics. */
 	private String sourceDescription;
 
 	/** Script line of the extension call currently being dispatched. */
 	private int currentLineNumber;
 
 	/** Whether the extension beforeStart hooks already ran for this AVM. */
 	private boolean beforeStartHooksExecuted;
 
 	/** Offset of a materialized SYMTAB array, for live operand-assignment updates. */
 	private long symtabOffset = NULL_OFFSET;
 
 	/**
 	 * Construct the interpreter.
 	 * <p>
 	 * Provided to allow programmatic construction of the interpreter
 	 * outside of the framework which is used by Jawk.
 	 */
 	public AVM() {
 		this(null, Collections.<String, JawkExtension>emptyMap());
 	}
 
 	/**
 	 * Construct the interpreter, accepting parameters which may have been
 	 * set on the command-line arguments to the JVM.
 	 *
 	 * @param parameters The parameters affecting the behavior of the
 	 *        interpreter.
 	 * @param extensionInstances Map of the extensions to load
 	 */
 	public AVM(final AwkSettings parameters,
 			final Map<String, JawkExtension> extensionInstances) {
 		this(parameters, extensionInstances, false);
 	}
 
 	/**
 	 * Construct the interpreter, optionally enabling runtime profiling.
 	 *
 	 * @param parameters The parameters affecting the behavior of the
 	 *        interpreter.
 	 * @param extensionInstances Map of the extensions to load
 	 * @param profilingEnabled Whether to collect profiling statistics
 	 */
 	public AVM(
 			final AwkSettings parameters,
 			final Map<String, JawkExtension> extensionInstances,
 			final boolean profilingEnabled) {
 		this.settings = parameters != null ? parameters : AwkSettings.DEFAULT_SETTINGS;
 		this.extensionInstances = extensionInstances == null ?
 				Collections.<String, JawkExtension>emptyMap() : extensionInstances;
 		this.profiling = profilingEnabled;
 		if (profilingEnabled) {
 			this.tupleProfilingStats = new java.util.EnumMap<Opcode, ProfilingReport.Accumulator>(Opcode.class);
 			this.functionProfilingStats = new LinkedHashMap<String, ProfilingReport.Accumulator>();
 			this.activeProfilingFunctions = new ArrayDeque<ActiveFunction>();
 		} else {
 			this.tupleProfilingStats = null;
 			this.functionProfilingStats = null;
 			this.activeProfilingFunctions = null;
 		}
 
 		arguments = Collections.emptyList();
 		sortedArrayKeys = this.settings.isUseSortedArrayKeys();
 		baseInitialVariables = new HashMap<String, Object>(this.settings.getVariables());
 		baseSpecialVariables = JRT.copySpecialVariables(baseInitialVariables);
 		executionInitialVariables = baseInitialVariables;
 		executionSpecialVariables = baseSpecialVariables;
 
 		jrt = createJrt();
 		initExtensions();
 	}
 
 	/**
 	 * Creates the runtime this interpreter drives.
 	 * <p>
 	 * Called once from the constructor, so that a subclass can install its own
 	 * runtime — {@link SandboxedAVM} returns a
 	 * {@link io.jawk.jrt.SandboxedJRT} this way. It runs before the subclass
 	 * constructor body, so an override must not depend on the subclass's own
 	 * fields.
 	 * </p>
 	 *
 	 * @return the runtime bound to this interpreter, never {@code null}
 	 */
 	protected JRT createJrt() {
 		return new JRT(this, this.settings.getLocale(), AwkSink.NOP_SINK, null);
 	}
 
 	/**
 	 * Returns the runtime settings associated with this interpreter.
 	 *
 	 * @return the settings, never {@code null}
 	 */
 	protected AwkSettings getSettings() {
 		return settings;
 	}
 
 	/**
 	 * Returns the JRT (Jawk Runtime) instance associated with this interpreter.
 	 *
 	 * @return the JRT instance, never {@code null}
 	 */
 	@SuppressFBWarnings("EI_EXPOSE_REP")
 	public JRT getJrt() {
 		return jrt;
 	}
 
 	/**
 	 * Sets the sink used by default {@code print} and {@code printf}
 	 * operations on this runtime.
 	 *
 	 * @param sink sink to use
 	 */
 	public void setAwkSink(AwkSink sink) {
 		jrt.setAwkSink(Objects.requireNonNull(sink, "sink"));
 	}
 
 	/**
 	 * Sets the stream used for the stderr output of spawned processes
 	 * (e.g.&nbsp;{@code system("...")}).
 	 *
 	 * @param errorStream stream to receive process stderr
 	 */
 	public void setErrorStream(PrintStream errorStream) {
 		jrt.setErrorStream(errorStream);
 	}
 
 	/**
 	 * Sets the stream that receives runtime warning messages (gawk-style
 	 * diagnostics). Warnings default to {@link System#err}.
 	 *
 	 * @param warningStream stream to receive runtime warnings
 	 */
 	public void setWarningStream(PrintStream warningStream) {
 		jrt.setWarningStream(warningStream);
 	}
 
 	/**
 	 * Registers the hook that decides the key traversal order of
 	 * {@code for (index in array)} statements.
 	 * <p>
 	 * When no hook is registered, iteration uses the array's natural key order.
 	 * Extensions typically register a hook from their {@code beforeStart}
 	 * method; the last registration wins.
 	 * </p>
 	 *
 	 * @param keyOrder traversal-order provider, or {@code null} to restore the
 	 *        natural key order
 	 */
 	public void setForInKeyOrder(ForInKeyOrder keyOrder) {
 		forInKeyOrder = keyOrder;
 	}
 
 	/**
 	 * Returns the default sink used by this runtime.
 	 *
 	 * @return the current AWK sink
 	 */
 	public AwkSink getAwkSink() {
 		return jrt.getAwkSink();
 	}
 
 	/**
 	 * Returns the locale configured for this runtime.
 	 *
 	 * @return runtime locale
 	 */
 	protected Locale getLocale() {
 		return jrt.getLocale();
 	}
 
 	/**
 	 * Evaluates a compiled expression against the AVM state exactly as it
 	 * currently stands.
 	 *
 	 * @param expression compiled expression to evaluate
 	 * @return the resulting value
 	 * @throws IOException if evaluation fails
 	 */
 	public Object eval(AwkExpression expression) throws IOException {
 		AwkExpression compiledExpression = Objects.requireNonNull(expression, "expression");
 		installExpressionMetadata(compiledExpression);
 
 		try {
 			executeTuples(compiledExpression.top());
 		} catch (ExitException e) {
 			// Expression tuples must never contain EXIT opcodes. If callers pass an
 			// invalid compiled expression, fail fast without poisoning later evals.
 			throwExitException = false;
 			exitCode = 0;
 			throw new IllegalStateException("eval(AwkExpression) cannot execute EXIT opcodes.", e);
 		}
 		return operandStackSize == 0 ? null : JRT.toJavaScalar(pop());
 	}
 
 	/**
 	 * Evaluates a compiled expression against the supplied input source.
 	 *
 	 * @param expression compiled expression to evaluate
 	 * @param inputSource input source providing the current record
 	 * @return the resulting value
 	 * @throws IOException if evaluation fails
 	 */
 	public Object eval(AwkExpression expression, InputSource inputSource) throws IOException {
 		return eval(expression, inputSource, null);
 	}
 
 	/**
 	 * Evaluates a compiled expression against the supplied input source with
 	 * per-call variable overrides.
 	 *
 	 * @param expression compiled expression to evaluate
 	 * @param inputSource input source providing the current record
 	 * @param variableOverrides additional variable assignments applied on top of
 	 *        the settings-level variables (may be {@code null})
 	 * @return the resulting value
 	 * @throws IOException if evaluation fails
 	 */
 	public Object eval(
 			AwkExpression expression,
 			InputSource inputSource,
 			Map<String, Object> variableOverrides)
 			throws IOException {
 		prepareForEval(inputSource, Collections.<String>emptyList(), variableOverrides);
 		return eval(expression);
 	}
 
 	/**
 	 * Executes a compiled AWK program with the current runtime defaults.
 	 *
 	 * @param program compiled program to execute
 	 * @param inputSource input source providing records
 	 * @throws ExitException when the program terminates via {@code exit}
 	 * @throws IOException if execution fails
 	 */
 	public void execute(AwkProgram program, InputSource inputSource) throws ExitException, IOException {
 		execute(program, inputSource, Collections.<String>emptyList(), null);
 	}
 
 	/**
 	 * Executes a compiled AWK program with explicit runtime arguments.
 	 *
 	 * @param program compiled program to execute
 	 * @param inputSource input source providing records
 	 * @param runtimeArguments name=value or filename entries from the command line
 	 * @throws ExitException when the program terminates via {@code exit}
 	 * @throws IOException if execution fails
 	 */
 	public void execute(AwkProgram program, InputSource inputSource, List<String> runtimeArguments)
 			throws ExitException,
 			IOException {
 		execute(program, inputSource, runtimeArguments, null);
 	}
 
 	/**
 	 * Executes a compiled AWK program with explicit runtime arguments and
 	 * variable overrides.
 	 *
 	 * @param program compiled program to execute
 	 * @param inputSource input source providing records
 	 * @param runtimeArguments name=value or filename entries from the command line
 	 * @param variableOverrides additional variable assignments applied on top of
 	 *        the settings-level variables (may be {@code null})
 	 * @throws ExitException when the program terminates via {@code exit}
 	 * @throws IOException if execution fails
 	 */
 	public void execute(
 			AwkProgram program,
 			InputSource inputSource,
 			List<String> runtimeArguments,
 			Map<String, Object> variableOverrides)
 			throws ExitException,
 			IOException {
 		AwkProgram compiledProgram = Objects.requireNonNull(program, "program");
 		InputSource resolvedSource = Objects.requireNonNull(inputSource, "inputSource");
 		resetRuntimeState(runtimeArguments, variableOverrides);
 		installProgramMetadata(compiledProgram);
 
 		jrt.prepareForExecution(settings.getFieldSeparator(), settings.getDefaultRS());
 		if (!executionSpecialVariables.isEmpty()) {
 			jrt.applySpecialVariables(executionSpecialVariables);
 		}
 		rebindResolvedInputSource(resolvedSource);
 		executeTuples(compiledProgram.top());
 	}
 
 	/**
 	 * Executes a compiled AWK program while persisting user-defined global
 	 * variables across repeated executions on this AVM instance.
 	 * <p>
 	 * Before the new program starts, this method imports any user-defined
 	 * globals currently materialized in the AVM and remaps them onto the
 	 * incoming program's compiled global slots.
 	 *
 	 * @param program compiled program to execute
 	 * @param inputSource input source providing records
 	 * @throws ExitException when the program terminates via {@code exit}
 	 * @throws IOException if execution fails
 	 */
 	public void executePersistingGlobals(AwkProgram program, InputSource inputSource)
 			throws ExitException,
 			IOException {
 		executePersistingGlobals(program, inputSource, Collections.<String>emptyList(), null);
 	}
 
 	/**
 	 * Executes a compiled AWK program while persisting user-defined global
 	 * variables across repeated executions on this AVM instance.
 	 * <p>
 	 * Before the new program starts, this method imports any user-defined
 	 * globals currently materialized in the AVM and remaps them onto the
 	 * incoming program's compiled global slots.
 	 *
 	 * @param program compiled program to execute
 	 * @param inputSource input source providing records
 	 * @param runtimeArguments name=value or filename entries from the command line
 	 * @throws ExitException when the program terminates via {@code exit}
 	 * @throws IOException if execution fails
 	 */
 	public void executePersistingGlobals(
 			AwkProgram program,
 			InputSource inputSource,
 			List<String> runtimeArguments)
 			throws ExitException,
 			IOException {
 		executePersistingGlobals(program, inputSource, runtimeArguments, null);
 	}
 
 	/**
 	 * Executes a compiled AWK program while persisting user-defined global
 	 * variables across repeated executions on this AVM instance.
 	 * <p>
 	 * Before the new program starts, this method imports any user-defined
 	 * globals currently materialized in the AVM and remaps them onto the
 	 * incoming program's compiled global slots.
 	 *
 	 * @param program compiled program to execute
 	 * @param inputSource input source providing records
 	 * @param runtimeArguments name=value or filename entries from the command line
 	 * @param variableOverrides additional variable assignments applied on top of
 	 *        the settings-level variables (may be {@code null})
 	 * @throws ExitException when the program terminates via {@code exit}
 	 * @throws IOException if execution fails
 	 */
 	public void executePersistingGlobals(
 			AwkProgram program,
 			InputSource inputSource,
 			List<String> runtimeArguments,
 			Map<String, Object> variableOverrides)
 			throws ExitException,
 			IOException {
 		AwkProgram compiledProgram = Objects.requireNonNull(program, "program");
 		InputSource resolvedSource = Objects.requireNonNull(inputSource, "inputSource");
 		mergeRuntimeState(runtimeArguments, variableOverrides, compiledProgram);
 
 		jrt.prepareForExecution(settings.getFieldSeparator(), settings.getDefaultRS());
 		if (!executionSpecialVariables.isEmpty()) {
 			jrt.applySpecialVariables(executionSpecialVariables);
 		}
 		rebindResolvedInputSource(resolvedSource);
 		executeTuples(compiledProgram.top());
 	}
 
 	/**
 	 * Clears the user-defined globals retained in the current runtime stack.
 	 * <p>
 	 * The next {@link #executePersistingGlobals(AwkProgram, InputSource, List, Map)}
 	 * call will therefore start from an empty persistent global bank.
 	 */
 	public void clearPersistentGlobals() {
 		runtimeStack.clearGlobals();
 		mergedGlobalLayoutActive = false;
 	}
 
 	/**
 	 * Captures the user-defined globals currently retained by this AVM for
 	 * persistent execution.
 	 * <p>
 	 * The returned snapshot is serializable and can later be fed back into
 	 * {@link #restorePersistentMemory(Map)} on this or another AVM instance.
 	 *
 	 * @return serializable snapshot of the persistent user-global bank
 	 */
 	public Map<String, Object> snapshotPersistentMemory() {
 		return new LinkedHashMap<>(collectPersistentGlobalValues());
 	}
 
 	/**
 	 * Restores the user-defined globals retained by this AVM from a previously
 	 * captured persistent-memory snapshot.
 	 * <p>
 	 * Restoring a snapshot replaces the current retained global bank. The next
 	 * {@link #executePersistingGlobals(AwkProgram, InputSource, List, Map)} call
 	 * will merge these globals into the compiled layout of the incoming program.
 	 *
 	 * @param snapshot snapshot to restore
 	 */
 	public void restorePersistentMemory(Map<String, Object> snapshot) {
 		Map<String, Object> restoredSnapshot = Objects.requireNonNull(snapshot, "snapshot");
 		Map<String, Object> restoredGlobals = filterToPersistentEligible(restoredSnapshot);
 		runtimeStack.clearGlobals();
 		if (!restoredGlobals.isEmpty()) {
 			runtimeStack.rebindGlobals(new ArrayList<>(restoredGlobals.keySet()));
 			applyGlobalsToStack(restoredGlobals);
 		}
 		mergedGlobalLayoutActive = false;
 	}
 
 	private void initExtensions() {
 		if (extensionInstances.isEmpty()) {
 			return;
 		}
 		Set<JawkExtension> initialized = new LinkedHashSet<JawkExtension>();
 		for (JawkExtension extension : extensionInstances.values()) {
 			if (initialized.add(extension)) {
 				extension.init(this, jrt, settings); // this = VariableManager
 			}
 		}
 	}
 
 	// Offsets for globals that remain runtime-managed by the tuple stream.
 	// ARGC is always materialized; ENVIRON and ARGV are emitted on demand.
 	private long environOffset = NULL_OFFSET;
 	private long argcOffset = NULL_OFFSET;
 	private long argvOffset = NULL_OFFSET;
 
 	private static final Integer ZERO = Integer.valueOf(0);
 	private static final Integer ONE = Integer.valueOf(1);
 
 	/** Random number generator used for rand() */
 	private final BSDRandom randomNumberGenerator = new BSDRandom(1);
 
 	/**
 	 * Address of the END blocks section, read from the compiled program;
 	 * {@code null} for expression streams.
 	 */
 	private Address exitAddress = null;
 
 	/**
 	 * Address of the ENDFILE section, read from the compiled program when it
 	 * has BEGINFILE/ENDFILE rules; {@code null} otherwise.
 	 */
 	private Address endFileAddress = null;
 
 	/**
 	 * Address of the NEXT_FILE tuple that opens each input file, read from
 	 * the compiled program when it requires per-file input stepping
 	 * (BEGINFILE/ENDFILE rules or a {@code nextfile} statement);
 	 * {@code null} otherwise.
 	 */
 	private Address nextFileAddress = null;
 
 	/**
 	 * Address of the main input loop's next-record entry point, read from the
 	 * compiled program when it consumes input, where a {@code next} statement
 	 * executed from a user-defined function resumes; {@code null} otherwise.
 	 */
 	private Address nextAddress = null;
 
 	/**
 	 * <code>true</code> if execution position is within a BEGINFILE rule;
 	 * <code>false</code> otherwise.
 	 */
 	private boolean withinBeginFileBlocks = false;
 
 	/**
 	 * <code>true</code> if execution position is within an ENDFILE rule;
 	 * <code>false</code> otherwise.
 	 */
 	private boolean withinEndFileBlocks = false;
 
 	/**
 	 * <code>true</code> once the per-file main input loop has advanced to its
 	 * first input file; <code>false</code> while still in the BEGIN blocks.
 	 */
 	private boolean inputFileLoopStarted = false;
 
 	/**
 	 * <code>true</code> once the main input loop has started consuming input
 	 * records; <code>false</code> while still in the BEGIN blocks (and, for
 	 * per-file programs, while the first BEGINFILE rules run).
 	 */
 	private boolean mainInputLoopStarted = false;
 
 	/**
 	 * <code>true</code> if execution position is within an END block;
 	 * <code>false</code> otherwise.
 	 */
 	private boolean withinEndBlocks = false;
 
 	/**
 	 * Exit code set by the <code>exit NN</code> command (0 by default)
 	 */
 	private int exitCode = 0;
 
 	/**
 	 * Whether <code>exit</code> has been called and we should throw ExitException
 	 */
 	private boolean throwExitException = false;
 
 	/**
 	 * Maps global variable names to their global array offsets.
 	 * It is useful when passing variable assignments from the file-list
 	 * portion of the command-line arguments.
 	 */
 	private Map<String, Integer> globalVariableOffsets;
 	/**
 	 * Indicates whether the variable, by name, is a scalar
 	 * or not. If not, then it is an Associative Array.
 	 */
 	private Map<String, Boolean> globalVariableArrays;
 	private Set<String> functionNames = Collections.emptySet();
 	private Map<String, Integer> initializedEvalGlobalVariableOffsets;
 	private Map<String, Boolean> initializedEvalGlobalVariableArrays;
 
 	/**
 	 * Resets the interpreter to a fresh eval state and binds one text record as
 	 * the current input.
 	 *
 	 * @param input text record to expose as {@code $0}
 	 * @return {@code true} when a record was prepared, {@code false} when the
 	 *         provided text represents no input
 	 * @throws IOException if binding the input fails
 	 */
 	public boolean prepareForEval(String input) throws IOException {
 		return prepareForEval(new SingleRecordInputSource(input), Collections.<String>emptyList(), null);
 	}
 
 	/**
 	 * Resets the interpreter to a fresh eval state and binds at most one record
 	 * from the provided input source as the current input. Calling this method
 	 * again on the same source advances to the next available record.
 	 *
 	 * @param inputSource source providing the record to bind
 	 * @return {@code true} when a record was prepared, {@code false} when the
 	 *         source is exhausted
 	 * @throws IOException if reading the input fails
 	 */
 	public boolean prepareForEval(InputSource inputSource) throws IOException {
 		return prepareForEval(inputSource, Collections.<String>emptyList(), null);
 	}
 
 	private boolean prepareForEval(
 			InputSource inputSource,
 			List<String> runtimeArguments,
 			Map<String, Object> variableOverrides)
 			throws IOException {
 		InputSource resolvedSource = Objects.requireNonNull(inputSource, "inputSource");
 		resetRuntimeState(runtimeArguments, variableOverrides);
 		rebindResolvedInputSource(resolvedSource);
 
 		jrt.jrtCloseAll();
 		jrt.prepareForExecution(settings.getFieldSeparator(), settings.getDefaultRS());
 		if (!executionSpecialVariables.isEmpty()) {
 			jrt.applySpecialVariables(executionSpecialVariables);
 		}
 		return jrt.consumeInputForEval(resolvedInputSource);
 	}
 
 	private void resetRuntimeState(List<String> runtimeArguments, Map<String, Object> variableOverrides) {
 		resetTransientRuntimeState(runtimeArguments, variableOverrides);
 		runtimeStack.clearGlobals();
 	}
 
 	private void resetTransientRuntimeState(List<String> runtimeArguments, Map<String, Object> variableOverrides) {
 		// Reset the AVM-owned state that must not leak across executions.
 		clearOperandStack();
 		elementArgumentReferences.clear();
 		environOffset = NULL_OFFSET;
 		argcOffset = NULL_OFFSET;
 		argvOffset = NULL_OFFSET;
 		symtabOffset = NULL_OFFSET;
 		exitAddress = null;
 		endFileAddress = null;
 		nextFileAddress = null;
 		nextAddress = null;
 		withinBeginFileBlocks = false;
 		withinEndFileBlocks = false;
 		inputFileLoopStarted = false;
 		mainInputLoopStarted = false;
 		withinEndBlocks = false;
 		exitCode = 0;
 		throwExitException = false;
 		globalVariableOffsets = null;
 		globalVariableArrays = null;
 		functionNames = Collections.emptySet();
 		initializedEvalGlobalVariableOffsets = null;
 		initializedEvalGlobalVariableArrays = null;
 		installedEvalExpression = null;
 		mergedGlobalLayoutActive = false;
 		runtimeStack.resetTransientState();
 		randomNumberGenerator.setSeed(1);
 
 		prepareExecutionInputs(runtimeArguments, variableOverrides);
 	}
 
 	private void installExpressionMetadata(AwkExpression compiledExpression) {
 		if (installedEvalExpression == compiledExpression) {
 			return;
 		}
 		globalVariableOffsets = compiledExpression.getGlobalVariableOffsetMap();
 		globalVariableArrays = compiledExpression.getGlobalVariableAarrayMap();
 		functionNames = compiledExpression.getFunctionNameSet();
 		installedEvalExpression = compiledExpression;
 	}
 
 	private void installProgramMetadata(AwkProgram compiledProgram) {
 		globalVariableOffsets = compiledProgram.getGlobalVariableOffsetMap();
 		globalVariableArrays = compiledProgram.getGlobalVariableAarrayMap();
 		functionNames = compiledProgram.getFunctionNameSet();
 		sourceDescription = compiledProgram.getSourceDescription();
 		exitAddress = compiledProgram.getExitAddress();
 		endFileAddress = compiledProgram.getEndFileAddress();
 		nextFileAddress = compiledProgram.getNextFileAddress();
 		nextAddress = compiledProgram.getNextAddress();
 	}
 
 	private void rebindResolvedInputSource(InputSource resolvedSource) {
 		InputSource previousResolvedSource = resolvedInputSource;
 		if (previousResolvedSource != null && previousResolvedSource != resolvedSource) {
 			closeInputSource(previousResolvedSource);
 		}
 		resolvedInputSource = resolvedSource;
 		// The /dev/stdin special filename follows the source bound to the run, so
 		// that a reused AVM never reads the stream of a previous execution.
 		jrt.bindStandardInput(resolvedSource);
 	}
 
 	private boolean hasCompatibleEvalGlobalLayout(long numGlobals) {
 		Object[] globals = runtimeStack.getNumGlobals();
 		return globals != null
 				&& globals.length == numGlobals
 				&& Objects.equals(initializedEvalGlobalVariableOffsets, globalVariableOffsets)
 				&& Objects.equals(initializedEvalGlobalVariableArrays, globalVariableArrays);
 	}
 
 	/**
 	 * Resets transient execution state, installs the new program metadata, and
 	 * merges the previously retained user globals into the new compiled global
 	 * layout.
 	 *
 	 * @param runtimeArguments name=value or filename entries for this execution
 	 * @param variableOverrides per-call variable overrides for this execution
 	 * @param compiledProgram program whose global layout should become active
 	 */
 	private void mergeRuntimeState(
 			List<String> runtimeArguments,
 			Map<String, Object> variableOverrides,
 			AwkProgram compiledProgram) {
 		Map<String, Object> carriedGlobals = collectPersistentGlobalValues();
 		resetTransientRuntimeState(runtimeArguments, variableOverrides);
 		installProgramMetadata(compiledProgram);
 
 		Map<String, Object> basePersistentSeeds = collectBasePersistentGlobalSeeds();
 		Map<String, Object> executionUserSeeds = collectExecutionUserGlobalSeeds(variableOverrides);
 		List<String> mergedGlobalNamesByOffset = buildMergedGlobalNamesByOffset(
 				carriedGlobals,
 				basePersistentSeeds,
 				executionUserSeeds);
 
 		runtimeStack.rebindGlobals(mergedGlobalNamesByOffset);
 		applyGlobalsToStack(carriedGlobals);
 		applyGlobalsToStack(basePersistentSeeds);
 		applyGlobalsToStack(executionUserSeeds);
 		mergedGlobalLayoutActive = true;
 	}
 
 	/**
 	 * Returns whether the current runtime stack already contains a merged global
 	 * layout for the compiled program about to execute.
 	 * <p>
 	 * Persistent execution may append previously retained globals after the
 	 * compiled globals of the incoming program. The tuple stream only dereferences
 	 * the prefix defined by {@code SET_NUM_GLOBALS}, so appended globals are valid
 	 * as long as the compiled prefix still matches name-for-name and offset-for-offset.
 	 *
 	 * @param numGlobals number of globals compiled into the active program
 	 * @return {@code true} when the merged layout is compatible with the active
 	 *         program
 	 */
 	private boolean hasCompatiblePersistentGlobalLayout(long numGlobals) {
 		Object[] globals = runtimeStack.getNumGlobals();
 		if (!mergedGlobalLayoutActive
 				|| globals == null
 				|| globalVariableOffsets == null
 				|| globals.length < numGlobals) {
 			return false;
 		}
 		for (Map.Entry<String, Integer> entry : globalVariableOffsets.entrySet()) {
 			int offset = entry.getValue().intValue();
 			if (offset < 0 || offset >= globals.length || !entry.getKey().equals(runtimeStack.getGlobalName(offset))) {
 				return false;
 			}
 		}
 		return true;
 	}
 
 	/**
 	 * Applies execution-level initial variables to stack-managed globals.
 	 * <p>
 	 * Plain {@link #execute(AwkProgram, InputSource, List, Map)} calls apply all
 	 * compatible globals here. Persistent executions only reapply non-persistent
 	 * globals so carried user globals are not overwritten unless they were
 	 * explicitly supplied for the current run.
 	 *
 	 * @param skipPersistentEligibleGlobals whether persistent user globals should
 	 *        be skipped by this application pass
 	 */
 	private void applyExecutionInitialVariablesToGlobalSlots(boolean skipPersistentEligibleGlobals) {
 		for (Map.Entry<String, Object> entry : executionInitialVariables.entrySet()) {
 			String key = entry.getKey();
 			if (skipPersistentEligibleGlobals && isPersistentEligibleGlobal(key)) {
 				continue;
 			}
 			if (functionNames.contains(key)) {
 				throw new IllegalArgumentException("Cannot assign a scalar to a function name (" + key + ").");
 			}
 			Integer offsetObj = globalVariableOffsets.get(key);
 			Boolean arrayObj = globalVariableArrays.get(key);
 			if (offsetObj != null) {
 				Object obj = normalizeExternalVariableValue(entry.getValue());
 				if (arrayObj.booleanValue()) {
 					if (obj instanceof Map) {
 						runtimeStack.setFilelistVariable(offsetObj.intValue(), obj);
 					} else {
 						throw new IllegalArgumentException(
 								"Cannot assign a scalar to a non-scalar variable (" + key + ").");
 					}
 				} else {
 					runtimeStack.setFilelistVariable(offsetObj.intValue(), obj);
 				}
 			}
 		}
 	}
 
 	/**
 	 * Prepares the per-execution runtime arguments and variable overrides.
 	 * <p>
 	 * Base settings-level variables remain the default source. Per-call overrides
 	 * are layered on top without mutating the base snapshot held by this AVM.
 	 *
 	 * @param runtimeArguments name=value or filename entries for this execution
 	 * @param variableOverrides per-call variable overrides for this execution
 	 */
 	private void prepareExecutionInputs(
 			List<String> runtimeArguments,
 			Map<String, Object> variableOverrides) {
 		this.arguments = runtimeArguments != null ? new ArrayList<>(runtimeArguments) : Collections.<String>emptyList();
 
 		if (variableOverrides == null || variableOverrides.isEmpty()) {
 			executionInitialVariables = baseInitialVariables;
 			executionSpecialVariables = baseSpecialVariables;
 		} else {
 			executionInitialVariables = new HashMap<>(baseInitialVariables);
 			executionInitialVariables.putAll(variableOverrides);
 
 			Map<String, Object> specialOverrides = JRT.copySpecialVariables(variableOverrides);
 			if (specialOverrides.isEmpty()) {
 				executionSpecialVariables = baseSpecialVariables;
 			} else {
 				executionSpecialVariables = new HashMap<>(baseSpecialVariables);
 				executionSpecialVariables.putAll(specialOverrides);
 			}
 		}
 	}
 
 	/**
 	 * Filters the given map to retain only entries whose keys are
 	 * persistent-eligible globals.
 	 *
 	 * @param source source map to filter
 	 * @return insertion-ordered map containing only persistent-eligible entries
 	 */
 	private Map<String, Object> filterToPersistentEligible(Map<String, Object> source) {
 		Map<String, Object> result = new LinkedHashMap<>();
 		for (Map.Entry<String, Object> entry : source.entrySet()) {
 			if (isPersistentEligibleGlobal(entry.getKey())) {
 				result.put(entry.getKey(), entry.getValue());
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * Collects the current user-defined globals retained in the runtime stack.
 	 *
 	 * @return retained user globals keyed by name, in current runtime order
 	 */
 	private Map<String, Object> collectPersistentGlobalValues() {
 		return filterToPersistentEligible(runtimeStack.snapshotGlobalVariables());
 	}
 
 	/**
 	 * Collects the AVM-wide baseline variables that should be reapplied before
 	 * each persistent execution.
 	 *
 	 * @return baseline user globals keyed by name
 	 */
 	private Map<String, Object> collectBasePersistentGlobalSeeds() {
 		Map<String, Object> basePersistentSeeds = new LinkedHashMap<>();
 		for (Map.Entry<String, Object> entry : baseInitialVariables.entrySet()) {
 			String name = entry.getKey();
 			if (isPersistentEligibleGlobal(name)) {
 				validateSeededGlobalName(name);
 				Object value = normalizeExternalVariableValue(entry.getValue());
 				validateSeededGlobalValue(name, value);
 				basePersistentSeeds.put(name, value);
 			}
 		}
 		return basePersistentSeeds;
 	}
 
 	/**
 	 * Collects the user-defined variables that should override the retained
 	 * global bank for the current persistent execution.
 	 * <p>
 	 * Only user globals are included here. JRT-managed special variables still
 	 * flow through the normal execution setup.
 	 *
 	 * @param variableOverrides per-call variable overrides for this execution
 	 * @return insertion-ordered overriding seed values keyed by variable name
 	 */
 	private Map<String, Object> collectExecutionUserGlobalSeeds(Map<String, Object> variableOverrides) {
 		Map<String, Object> executionUserSeeds = new LinkedHashMap<>();
 		if (variableOverrides != null) {
 			for (Map.Entry<String, Object> entry : variableOverrides.entrySet()) {
 				String name = entry.getKey();
 				if (isPersistentEligibleGlobal(name)) {
 					validateSeededGlobalName(name);
 					Object value = normalizeExternalVariableValue(entry.getValue());
 					validateSeededGlobalValue(name, value);
 					executionUserSeeds.put(name, value);
 				}
 			}
 		}
 		return executionUserSeeds;
 	}
 
 	/**
 	 * Builds the slot order for the next persistent execution.
 	 * <p>
 	 * The compiled globals are always installed first in their compiled offset
 	 * order. Retained globals and seeded user globals that are not compiled by
 	 * the incoming program are appended afterwards so future runs can still reuse
 	 * them without changing the current program's compiled offsets.
 	 *
 	 * @param carriedGlobals retained user globals from the previous execution
 	 * @param basePersistentSeeds baseline user globals coming from the AVM settings
 	 * @param executionUserSeeds per-call user overrides for this execution
 	 * @return merged slot-to-name layout for the next persistent run
 	 */
 	private List<String> buildMergedGlobalNamesByOffset(
 			Map<String, Object> carriedGlobals,
 			Map<String, Object> basePersistentSeeds,
 			Map<String, Object> executionUserSeeds) {
 		LinkedHashSet<String> orderedNames = new LinkedHashSet<>();
 		List<Map.Entry<String, Integer>> compiledGlobals = new ArrayList<>(globalVariableOffsets.entrySet());
 		compiledGlobals.sort(java.util.Comparator.comparingInt(Map.Entry::getValue));
 		for (Map.Entry<String, Integer> entry : compiledGlobals) {
 			orderedNames.add(entry.getKey());
 		}
 		orderedNames.addAll(carriedGlobals.keySet());
 		orderedNames.addAll(basePersistentSeeds.keySet());
 		orderedNames.addAll(executionUserSeeds.keySet());
 		return new ArrayList<>(orderedNames);
 	}
 
 	/**
 	 * Writes each entry from {@code globals} into the corresponding named slot in
 	 * the runtime stack.
 	 *
 	 * @param globals map of variable name to value to apply
 	 */
 	private void applyGlobalsToStack(Map<String, Object> globals) {
 		for (Map.Entry<String, Object> entry : globals.entrySet()) {
 			runtimeStack.setGlobalVariable(entry.getKey(), entry.getValue());
 		}
 	}
 
 	/**
 	 * Returns whether the given global name should participate in persistent
 	 * memory.
 	 *
 	 * @param name global variable name
 	 * @return {@code true} when the variable should persist across runs
 	 */
 	private boolean isPersistentEligibleGlobal(String name) {
 		return name != null
 				&& !isManagedSpecialVariable(name)
 				&& !NON_PERSISTENT_GLOBALS.contains(name);
 	}
 
 	/**
 	 * Returns whether the named variable is a JRT-managed special variable in
 	 * the current execution mode. Most special variables (NR, FS, FILENAME,
 	 * ...) always are. The gawk-only ERRNO and ARGIND are special outside
 	 * POSIX mode only: with {@code --posix} they are ordinary global
 	 * variables, exactly like {@code gawk --posix} treats them.
 	 *
 	 * @param name variable name to inspect
 	 * @return {@code true} when reads and writes of the variable go through
 	 *         the JRT instead of a global slot
 	 */
 	private boolean isManagedSpecialVariable(String name) {
 		if (!JRT.isJrtManagedSpecialVariable(name)) {
 			return false;
 		}
 		if (JRT.isGawkOnlySpecialVariable(name)) {
 			return !settings.isPosix();
 		}
 		return true;
 	}
 
 	/**
 	 * Validates that a seeded global name is compatible with the compiled
 	 * metadata of the current program before any value normalization can mutate a
 	 * caller-provided object graph.
 	 *
 	 * @param name variable name to validate
 	 */
 	private void validateSeededGlobalName(String name) {
 		if (functionNames.contains(name)) {
 			throw new IllegalArgumentException("Cannot assign a value to a function name (" + name + ").");
 		}
 	}
 
 	/**
 	 * Validates that a normalized seeded global value is compatible with the
 	 * compiled metadata of the current program.
 	 *
 	 * @param name variable name to validate
 	 * @param value proposed seeded value after normalization
 	 */
 	private void validateSeededGlobalValue(String name, Object value) {
 		Boolean arrayObj = globalVariableArrays.get(name);
 		if (Boolean.TRUE.equals(arrayObj) && !(value instanceof Map)) {
 			throw new IllegalArgumentException("Cannot assign a scalar to a non-scalar variable (" + name + ").");
 		}
 	}
 
 	/**
 	 * Executes the tuple stream after the runtime has been fully prepared.
 	 *
 	 * @param position current position in the tuple stream
 	 * @throws ExitException when the AWK program executes {@code exit}
 	 * @throws IOException when runtime input operations fail
 	 */
 	private void executeTuples(PositionTracker position)
 			throws ExitException,
 			IOException {
 		Map<Long, ConditionPair> conditionPairs = null;
 		Opcode opcode = null;
 		long tupleStartNanos = 0L;
 		try {
 			while (!position.isEOF()) {
 				// System_out.println("--> "+position);
 				Tuple tuple = position.current();
 				opcode = tuple.getOpcode();
 				if (profiling) {
 					tupleStartNanos = beforeProfiledTuple(tuple, opcode);
 				}
 				// switch on OPCODE
 				switch (opcode) {
 				case PRINT: {
 					execPrint((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case PRINT_TO_FILE: {
 					execPrintToFile((CountAndAppendTuple) tuple);
 					position.next();
 					break;
 				}
 				case PRINT_TO_PIPE: {
 					execPrintToPipe((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case PRINTF: {
 					execPrintf((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case PRINTF_TO_FILE: {
 					execPrintfToFile((CountAndAppendTuple) tuple);
 					position.next();
 					break;
 				}
 				case PRINTF_TO_PIPE: {
 					execPrintfToPipe((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case SPRINTF: {
 					// arg[0] = # of sprintf arguments
 					// stack[0] = arg1 (format string)
 					// stack[1] = arg2
 					// etc.
 					CountTuple countTuple = (CountTuple) tuple;
 					long numArgs = countTuple.getCount();
 					push(sprintfFunction(numArgs));
 					position.next();
 					break;
 				}
 				case LENGTH: {
 					execLength((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case PUSH_LONG: {
 					// arg[0] = long constant to push onto the stack
 					PushLongTuple pushTuple = (PushLongTuple) tuple;
 					push(pushTuple.getValue());
 					position.next();
 					break;
 				}
 				case PUSH_DOUBLE: {
 					// arg[0] = double constant to push onto the stack
 					PushDoubleTuple pushTuple = (PushDoubleTuple) tuple;
 					push(pushTuple.getValue());
 					position.next();
 					break;
 				}
 				case PUSH_STRING: {
 					// arg[0] = string constant to push onto the stack
 					PushStringTuple pushTuple = (PushStringTuple) tuple;
 					push(pushTuple.getValue());
 					position.next();
 					break;
 				}
 				case POP: {
 					// stack[0] = item to pop from the stack
 					Object discarded = pop();
 					if (tuple instanceof ScalarPopTuple) {
 						checkScalar(discarded);
 					}
 					position.next();
 					break;
 				}
 				case IFFALSE: {
 					// arg[0] = address to jump to if top of stack is false
 					// stack[0] = item to check
 
 					// if int, then check for 0
 					// if double, then check for 0
 					// if String, then check for "" or double value of "0"
 					boolean jump = !jrt.toBoolean(pop());
 					if (jump) {
 						position.jump(tuple.getAddress());
 					} else {
 						position.next();
 					}
 					break;
 				}
 				case TO_NUMBER: {
 					// stack[0] = item to convert to a number
 
 					// if int, then check for 0
 					// if double, then check for 0
 					// if String, then check for "" or double value of "0"
 					boolean val = jrt.toBoolean(pop());
 					push(val ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case IFTRUE: {
 					// arg[0] = address to jump to if top of stack is true
 					// stack[0] = item to check
 
 					// if int, then check for 0
 					// if double, then check for 0
 					// if String, then check for "" or double value of "0"
 					boolean jump = jrt.toBoolean(pop());
 					if (jump) {
 						position.jump(tuple.getAddress());
 					} else {
 						position.next();
 					}
 					break;
 				}
 				case NOT: {
 					// stack[0] = item to logically negate
 
 					Object o = pop();
 
 					boolean result = jrt.toBoolean(o);
 
 					if (result) {
 						push(0);
 					} else {
 						push(1);
 					}
 					position.next();
 					break;
 				}
 				case NEGATE: {
 					// stack[0] = item to numerically negate
 
 					push(JRT.negate(pop()));
 					position.next();
 					break;
 				}
 				case UNARY_PLUS: {
 					// stack[0] = item to convert to a number
 					// A numeric scalar is already a number: pushing it back
 					// unchanged avoids both re-boxing and precision loss.
 					push(numericValueOf(pop()));
 					position.next();
 					break;
 				}
 				case GOTO: {
 					// arg[0] = address
 
 					position.jump(tuple.getAddress());
 					break;
 				}
 				case NOP: {
 					// do nothing, just advance the position
 					position.next();
 					break;
 				}
 				case CONCAT: {
 					// stack[0] = string1
 					// stack[1] = string2
 					String s2 = jrt.toAwkString(pop());
 					String s1 = jrt.toAwkString(pop());
 					String resultString = s1 + s2;
 					push(resultString);
 					position.next();
 					break;
 				}
 				case MULTI_CONCAT: {
 					// arg[0] = number of stack items to concatenate
 					// stack[0] = last concatenation operand
 					CountTuple countTuple = (CountTuple) tuple;
 					int count = (int) countTuple.getCount();
 					// Store String references so appends run left-to-right. Converting
 					// operands to char[] would copy them once before StringBuilder
 					// copies them again, and front-inserting would shift existing
 					// content on each operand.
 					String[] values = new String[count];
 					int resultLength = 0;
 					for (int i = count - 1; i >= 0; i--) {
 						values[i] = jrt.toAwkString(pop());
 						resultLength += values[i].length();
 					}
 					StringBuilder resultString = new StringBuilder(resultLength);
 					for (String value : values) {
 						resultString.append(value);
 					}
 					push(resultString.toString());
 					position.next();
 					break;
 				}
 				case ASSIGN:
 				case ASSIGN_NOPUSH: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					// stack[0] = value
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					Object value = pop();
 					assign(
 							variableTuple.getVariableOffset(),
 							value,
 							variableTuple.isGlobal(),
 							position,
 							opcode == Opcode.ASSIGN);
 					position.next();
 					break;
 				}
 				case ASSIGN_ARRAY: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					// stack[0] = array index
 					// stack[1] = value
 					Object arrIdx = pop();
 					Object rhs = pop();
 					if (rhs == null) {
 						rhs = BLANK;
 					}
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					long offset = variableTuple.getVariableOffset();
 					boolean isGlobal = variableTuple.isGlobal();
 					assignArray(offset, arrIdx, rhs, isGlobal);
 					position.next();
 					break;
 				}
 				case ASSIGN_MAP_ELEMENT: {
 					// stack[0] = array index
 					// stack[1] = associative array
 					// stack[2] = value
 					Object arrIdx = pop();
 					Map<Object, Object> array = toMap(pop());
 					Object rhs = pop();
 					if (rhs == null) {
 						rhs = BLANK;
 					}
 					assignMapElement(array, arrIdx, rhs);
 					position.next();
 					break;
 				}
 				case PLUS_EQ_ARRAY:
 				case MINUS_EQ_ARRAY:
 				case MULT_EQ_ARRAY:
 				case DIV_EQ_ARRAY:
 				case MOD_EQ_ARRAY:
 				case POW_EQ_ARRAY: {
 					execCompoundAssignArray(opcode, (VariableTuple) tuple);
 					position.next();
 					break;
 				}
 				case PLUS_EQ_MAP_ELEMENT:
 				case MINUS_EQ_MAP_ELEMENT:
 				case MULT_EQ_MAP_ELEMENT:
 				case DIV_EQ_MAP_ELEMENT:
 				case MOD_EQ_MAP_ELEMENT:
 				case POW_EQ_MAP_ELEMENT: {
 					execCompoundAssignMapElement(opcode);
 					position.next();
 					break;
 				}
 
 				case ASSIGN_AS_INPUT: {
 					// stack[0] = value
 					jrt.setInputLine(pop());
 					push(jrt.getInputLine());
 					position.next();
 					break;
 				}
 
 				case ASSIGN_AS_INPUT_FIELD: {
 					// stack[0] = field number
 					// stack[1] = value
 					Object fieldNumObj = pop();
 					long fieldNum = JRT.parseFieldNumber(fieldNumObj);
 					Object value = pop();
 					push(value); // leave the result on the stack
 					if (fieldNum == 0) {
 						jrt.setInputLine(value);
 						jrt.jrtParseFields();
 					} else {
 						jrt.jrtSetInputField(value, fieldNum);
 					}
 					position.next();
 					break;
 				}
 				case PLUS_EQ:
 				case MINUS_EQ:
 				case MULT_EQ:
 				case DIV_EQ:
 				case MOD_EQ:
 				case POW_EQ: {
 					execCompoundAssignVariable(opcode, (VariableTuple) tuple);
 					position.next();
 					break;
 				}
 				case PLUS_EQ_INPUT_FIELD:
 				case MINUS_EQ_INPUT_FIELD:
 				case MULT_EQ_INPUT_FIELD:
 				case DIV_EQ_INPUT_FIELD:
 				case MOD_EQ_INPUT_FIELD:
 				case POW_EQ_INPUT_FIELD: {
 					execCompoundAssignInputField(opcode);
 					position.next();
 					break;
 				}
 				case INC: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					inc(variableTuple.getVariableOffset(), variableTuple.isGlobal());
 					position.next();
 					break;
 				}
 				case DEC: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					dec(variableTuple.getVariableOffset(), variableTuple.isGlobal());
 					position.next();
 					break;
 				}
 				case POSTINC: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					pop();
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					push(inc(variableTuple.getVariableOffset(), variableTuple.isGlobal()));
 					position.next();
 					break;
 				}
 				case POSTDEC: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					pop();
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					push(dec(variableTuple.getVariableOffset(), variableTuple.isGlobal()));
 					position.next();
 					break;
 				}
 				case INC_ARRAY_REF: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					// stack[0] = array index
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					boolean isGlobal = variableTuple.isGlobal();
 					Map<Object, Object> aa = ensureMapVariable(variableTuple.getVariableOffset(), isGlobal);
 					Object key = pop();
 					checkScalar(key);
 					Object o = aa.get(key);
 					aa.put(key, JRT.inc(blankToZero(o)));
 					position.next();
 					break;
 				}
 				case DEC_ARRAY_REF: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					// stack[0] = array index
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					boolean isGlobal = variableTuple.isGlobal();
 					Map<Object, Object> aa = ensureMapVariable(variableTuple.getVariableOffset(), isGlobal);
 					Object key = pop();
 					checkScalar(key);
 					Object o = aa.get(key);
 					aa.put(key, JRT.dec(blankToZero(o)));
 					position.next();
 					break;
 				}
 				case INC_MAP_REF: {
 					// stack[0] = array index
 					// stack[1] = associative array
 					Object key = pop();
 					checkScalar(key);
 					Map<Object, Object> aa = toMap(pop());
 					Object o = aa.get(key);
 					aa.put(key, JRT.inc(blankToZero(o)));
 					position.next();
 					break;
 				}
 				case DEC_MAP_REF: {
 					// stack[0] = array index
 					// stack[1] = associative array
 					Object key = pop();
 					checkScalar(key);
 					Map<Object, Object> aa = toMap(pop());
 					Object o = aa.get(key);
 					aa.put(key, JRT.dec(blankToZero(o)));
 					position.next();
 					break;
 				}
 				case INC_DOLLAR_REF: {
 					// stack[0] = dollar index (field number)
 					long fieldnum = JRT.parseFieldNumber(pop());
 
 					Object numObj = blankToZero(jrt.jrtGetInputField(fieldnum));
 					Object original = numericValueOf(numObj);
 					setNumOnJRT(fieldnum, JRT.inc(original));
 
 					push(original);
 
 					position.next();
 					break;
 				}
 				case DEC_DOLLAR_REF: {
 					// stack[0] = dollar index (field number)
 					// same code as GET_INPUT_FIELD:
 					long fieldnum = JRT.parseFieldNumber(pop());
 
 					Object numObj = blankToZero(jrt.jrtGetInputField(fieldnum));
 					Object original = numericValueOf(numObj);
 					setNumOnJRT(fieldnum, JRT.dec(original));
 
 					push(original);
 
 					position.next();
 					break;
 				}
 				case DEREFERENCE: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					DereferenceTuple dereferenceTuple = (DereferenceTuple) tuple;
 					boolean isGlobal = dereferenceTuple.isGlobal();
 					long offset = dereferenceTuple.getVariableOffset();
 					push(resolveVariable(offset, isGlobal, dereferenceTuple.isArray()));
 					position.next();
 					break;
 				}
 				case PEEK_DEREFERENCE: {
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					Object value = runtimeStack
 							.getVariable(variableTuple.getVariableOffset(), variableTuple.isGlobal());
 					push(
 							value instanceof ArgumentReference ?
 									resolveRawArgumentReference((ArgumentReference) value) : value);
 					position.next();
 					break;
 				}
 				case PUSH_INDIRECT_ARGUMENT: {
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					Object scalarValue = runtimeStack
 							.getVariable(variableTuple.getVariableOffset(), variableTuple.isGlobal());
 					// Typed values are passed as plain values; only untyped
 					// variables need a live link back to the caller's slot.
 					if (scalarValue instanceof ArgumentReference) {
 						push(resolveUserFunctionArgument(scalarValue));
 					} else if (isUntyped(scalarValue)) {
 						push(
 								new IndirectArgumentReference(
 										runtimeStack.getVariableFrame(variableTuple.isGlobal()),
 										variableTuple.getVariableOffset(),
 										scalarValue));
 					} else {
 						push(scalarValue);
 					}
 					position.next();
 					break;
 				}
 				case PUSH_INDIRECT_ARRAY_ARGUMENT: {
 					Object idx = pop();
 					checkScalar(idx);
 					Map<Object, Object> map = toMap(pop());
 					Object scalarValue = JRT.getAssocArrayValue(map, idx);
 					// Typed elements are passed as plain values; only untyped
 					// elements need a live link back to their containing array.
 					push(
 							isUntyped(scalarValue) ?
 									new IndirectArrayArgumentReference(map, idx, scalarValue) : scalarValue);
 					position.next();
 					break;
 				}
 				case DEREF_ARRAY: {
 					// stack[0] = array index
 					Object idx = pop(); // idx
 					checkScalar(idx);
 					Map<Object, Object> map = toMap(pop());
 					Object o = JRT.getAssocArrayValue(map, idx);
 					push(o);
 					position.next();
 					break;
 				}
 				case ENSURE_ARRAY_ELEMENT: {
 					// stack[0] = array index
 					// stack[1] = associative array
 					Object idx = pop();
 					Map<Object, Object> map = toMap(pop());
 					push(ensureArrayInArray(map, idx));
 					position.next();
 					break;
 				}
 				case PEEK_ARRAY_ELEMENT: {
 					// stack[0] = array index
 					Object idx = pop();
 					checkScalar(idx);
 					Map<Object, Object> map = toMap(pop());
 					if (map instanceof AssocArray && !JRT.containsAwkKey(map, idx)) {
 						push(AssocArray.UNTYPED);
 					} else {
 						Object value = map.get(idx);
 						push(value != null ? value : AssocArray.UNTYPED);
 					}
 					position.next();
 					break;
 				}
 				case SRAND: {
 					// arg[0] = numArgs (where 0 = no args, anything else = one argument)
 					// stack[0] = seed (only if numArgs != 0)
 					CountTuple countTuple = (CountTuple) tuple;
 					long numArgs = countTuple.getCount();
 					int seed;
 					if (numArgs == 0) {
 						// use the time of day for the seed
 						seed = JRT.timeSeed();
 					} else {
 						seed = (int) JRT.toDouble(pop());
 					}
 					int previousSeed = randomNumberGenerator.getSeed();
 					randomNumberGenerator.setSeed(seed);
 					push(previousSeed);
 					position.next();
 					break;
 				}
 				case RAND: {
 					push(randomNumberGenerator.nextDouble());
 					position.next();
 					break;
 				}
 				case INTFUNC: {
 					// stack[0] = arg to int() function
 					push(JRT.truncateToScalar(JRT.toDouble(pop())));
 					position.next();
 					break;
 				}
 				case SQRT: {
 					// stack[0] = arg to sqrt() function
 					push(Math.sqrt(JRT.toDouble(pop())));
 					position.next();
 					break;
 				}
 				case LOG: {
 					// stack[0] = arg to log() function
 					push(Math.log(JRT.toDouble(pop())));
 					position.next();
 					break;
 				}
 				case EXP: {
 					// stack[0] = arg to exp() function
 					push(Math.exp(JRT.toDouble(pop())));
 					position.next();
 					break;
 				}
 				case SIN: {
 					// stack[0] = arg to sin() function
 					push(Math.sin(JRT.toDouble(pop())));
 					position.next();
 					break;
 				}
 				case COS: {
 					// stack[0] = arg to cos() function
 					push(Math.cos(JRT.toDouble(pop())));
 					position.next();
 					break;
 				}
 				case ATAN2: {
 					// stack[0] = 2nd arg to atan2() function
 					// stack[1] = 1st arg to atan2() function
 					double d2 = JRT.toDouble(pop());
 					double d1 = JRT.toDouble(pop());
 					push(Math.atan2(d1, d2));
 					position.next();
 					break;
 				}
 				case MATCH: {
 					execMatch();
 					position.next();
 					break;
 				}
 				case INDEX: {
 					// stack[0] = 2nd arg to index() function
 					// stack[1] = 1st arg to index() function
 					String s2 = jrt.toAwkString(pop());
 					String s1 = jrt.toAwkString(pop());
 					push(jrt.index(s1, s2));
 					position.next();
 					break;
 				}
 				case SUB_FOR_DOLLAR_0: {
 					execSubForDollar0((BooleanTuple) tuple);
 					position.next();
 					break;
 				}
 				case SUB_FOR_DOLLAR_REFERENCE: {
 					execSubForDollarReference((BooleanTuple) tuple);
 					position.next();
 					break;
 				}
 				case SUB_FOR_VARIABLE: {
 					execSubForVariable((SubstitutionVariableTuple) tuple, position);
 					position.next();
 					break;
 				}
 				case SUB_FOR_ARRAY_REFERENCE: {
 					execSubForArrayReference((SubstitutionVariableTuple) tuple);
 					position.next();
 					break;
 				}
 				case SUB_FOR_MAP_REFERENCE: {
 					execSubForMapReference((BooleanTuple) tuple);
 					position.next();
 					break;
 				}
 				case SPLIT: {
 					execSplit((CountTuple) tuple, position);
 					position.next();
 					break;
 				}
 				case SUBSTR: {
 					execSubstr((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case TOLOWER: {
 					// stack[0] = string
 					push(jrt.toAwkString(pop()).toLowerCase());
 					position.next();
 					break;
 				}
 				case TOUPPER: {
 					// stack[0] = string
 					push(jrt.toAwkString(pop()).toUpperCase());
 					position.next();
 					break;
 				}
 				case SYSTEM: {
 					// stack[0] = command string
 					String s = jrt.toAwkString(pop());
 					push(jrt.jrtSystem(s));
 					position.next();
 					break;
 				}
 				case SWAP: {
 					// stack[0] = item1
 					// stack[1] = item2
 					Object o1 = pop();
 					Object o2 = pop();
 					push(o1);
 					push(o2);
 					position.next();
 					break;
 				}
 				case CMP_EQ: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(jrt.compare(o1, o2, 0) ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case CMP_LT: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(jrt.compare(o1, o2, -1) ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case CMP_GT: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(jrt.compare(o1, o2, 1) ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case MATCHES: {
 					// stack[0] = regexp (precompiled or dynamic)
 					// stack[1] = text
 					Object o2 = pop();
 					Object o1 = pop();
 					// The text operand must be converted with the AWK number-to-string rule, not with
 					// Object.toString(): a Double would otherwise be matched as "291.0" instead of "291".
 					push(jrt.matches(jrt.toAwkString(o1), o2) ? 1 : 0);
 					position.next();
 					break;
 				}
 				case ADD: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(JRT.add(o1, o2));
 					position.next();
 					break;
 				}
 				case SUBTRACT: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(JRT.subtract(o1, o2));
 					position.next();
 					break;
 				}
 				case MULTIPLY: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(JRT.multiply(o1, o2));
 					position.next();
 					break;
 				}
 				case DIVIDE: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(JRT.divide(o1, o2));
 					position.next();
 					break;
 				}
 				case MOD: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(JRT.mod(o1, o2));
 					position.next();
 					break;
 				}
 				case POW: {
 					// stack[0] = item2
 					// stack[1] = item1
 					Object o2 = pop();
 					Object o1 = pop();
 					push(JRT.pow(o1, o2));
 					position.next();
 					break;
 				}
 				case DUP: {
 					// stack[0] = top of stack item
 					Object o = pop();
 					push(o);
 					push(o);
 					position.next();
 					break;
 				}
 				case KEYLIST: {
 					Object o = pop();
 					if (isUntyped(o)) {
 						push(new ArrayDeque<>());
 						position.next();
 						break;
 					}
 					if (!(o instanceof Map)) {
 						throw new AwkRuntimeException("Attempting to use a scalar as an array.");
 					}
 					@SuppressWarnings("unchecked")
 					Map<Object, Object> map = (Map<Object, Object>) o;
 					push(new ArrayDeque<>(forInKeyOrder == null ? map.keySet() : forInKeyOrder.order(map)));
 					position.next();
 					break;
 				}
 				case IS_EMPTY_KEYLIST: {
 					// arg[0] = address
 					// stack[0] = Deque
 					Object o = pop();
 					if (o == null || !(o instanceof Deque)) {
 						throw new AwkRuntimeException(
 								position.lineNumber(),
 								"Cannot get a key list (via 'in') of a non associative array. arg = " + o.getClass() + ", " + o);
 					}
 					Deque<?> keylist = (Deque<?>) o;
 					if (keylist.isEmpty()) {
 						position.jump(tuple.getAddress());
 					} else {
 						position.next();
 					}
 					break;
 				}
 				case GET_FIRST_AND_REMOVE_FROM_KEYLIST: {
 					// stack[0] = Deque
 					Object o = pop();
 					if (o == null || !(o instanceof Deque)) {
 						throw new AwkRuntimeException(
 								position.lineNumber(),
 								"Cannot get a key list (via 'in') of a non associative array. arg = " + o.getClass() + ", " + o);
 					}
 					// pop off and return the head of the key set
 					Deque<?> keylist = (Deque<?>) o;
 					push(keylist.removeFirst());
 					position.next();
 					break;
 				}
 				case CHECK_CLASS: {
 					// arg[0] = class object
 					// stack[0] = item to check
 					ClassTuple checkTuple = (ClassTuple) tuple;
 					Object o = pop();
 					if (!checkTuple.getType().isInstance(o)) {
 						throw new AwkRuntimeException(
 								position.lineNumber(),
 								"Verification failed. Top-of-stack = " + o.getClass() + " isn't an instance of "
 										+ checkTuple.getType());
 					}
 					push(o);
 					position.next();
 					break;
 				}
 				case CONSUME_INPUT: {
 					// arg[0] = address
 					// store the next record into $0, $1, ...
 					mainInputLoopStarted = true;
 					if (jrt.consumeInput(resolvedInputSource)) {
 						position.next();
 					} else {
 						position.jump(tuple.getAddress());
 					}
 					break;
 				}
 				case CONSUME_FILE_INPUT: {
 					// arg[0] = address of the ENDFILE section
 					// store the next record of the current file into $0, $1, ...
 					mainInputLoopStarted = true;
 					withinBeginFileBlocks = false;
 					if (jrt.consumeCurrentFileInput(resolvedInputSource)) {
 						position.next();
 					} else {
 						withinEndFileBlocks = true;
 						position.jump(tuple.getAddress());
 					}
 					break;
 				}
 				case NEXT_FILE: {
 					// arg[0] = address to jump to when no input file remains
 					inputFileLoopStarted = true;
 					withinEndFileBlocks = false;
 					if (jrt.advanceToNextFile(resolvedInputSource)) {
 						withinBeginFileBlocks = true;
 						position.next();
 					} else {
 						position.jump(tuple.getAddress());
 					}
 					break;
 				}
 				case EXEC_NEXTFILE: {
 					executeNextfile(position);
 					break;
 				}
 				case EXEC_NEXT: {
 					executeNext(position);
 					break;
 				}
 
 				case GETLINE_INPUT: {
 					checkGetlineAllowed(position);
 					boolean consumed = isMainInputFileBounded() ?
 							jrt.consumeCurrentFileInput(resolvedInputSource) : jrt.consumeInput(resolvedInputSource);
 					push(consumed ? 1 : 0);
 					position.next();
 					break;
 				}
 				case GETLINE_INPUT_TO_TARGET: {
 					// arg[0] = address to jump to when no record was read
 					checkGetlineAllowed(position);
 					Object input = isMainInputFileBounded() ?
 							jrt.consumeCurrentFileInputToTarget(resolvedInputSource) : jrt.consumeInputToTarget(resolvedInputSource);
 					if (input != null) {
 						push(1);
 						push(input);
 						position.next();
 					} else {
 						push(0);
 						position.jump(tuple.getAddress());
 					}
 					break;
 				}
 				case USE_AS_FILE_INPUT: {
 					// stack[0] = filename
 					// arg[0] = address to jump to when no record was read
 					String s = jrt.toAwkString(pop());
 					Integer retcode = jrt.jrtConsumeFileInputForGetline(s);
 					push(retcode);
 					if (retcode.intValue() == 1) {
 						push(jrt.toInputScalar(jrt.jrtGetInputString()));
 						position.next();
 					} else {
 						position.jump(tuple.getAddress());
 					}
 					break;
 				}
 				case USE_AS_COMMAND_INPUT: {
 					// stack[0] = command line
 					// arg[0] = address to jump to when no record was read
 					String s = jrt.toAwkString(pop());
 					Integer retcode = jrt.jrtConsumeCommandInputForGetline(s);
 					push(retcode);
 					if (retcode.intValue() == 1) {
 						push(jrt.toInputScalar(jrt.jrtGetInputString()));
 						position.next();
 					} else {
 						position.jump(tuple.getAddress());
 					}
 					break;
 				}
 				case ENVIRON_OFFSET: {
 					// arg[0] = offset; already populated from SET_NUM_GLOBALS so
 					// beforeStart hooks observe the real value
 					populateEnviron(((LongTuple) tuple).getValue());
 					position.next();
 					break;
 				}
 				case ARGC_OFFSET: {
 					// arg[0] = offset; already populated from SET_NUM_GLOBALS
 					populateArgc(((LongTuple) tuple).getValue());
 					position.next();
 					break;
 				}
 				case ARGV_OFFSET: {
 					// arg[0] = offset; already populated from SET_NUM_GLOBALS
 					populateArgv(((LongTuple) tuple).getValue());
 					position.next();
 					break;
 				}
 				case GET_INPUT_FIELD: {
 					// stack[0] = field number
 					Object fieldNumber = pop();
 					push(jrt.jrtGetInputField(fieldNumber));
 					position.next();
 					break;
 				}
 				case GET_INPUT_FIELD_CONST: {
 					InputFieldTuple inputFieldTuple = (InputFieldTuple) tuple;
 					long fieldnum = inputFieldTuple.getFieldIndex();
 					push(jrt.jrtGetInputField(fieldnum));
 					position.next();
 					break;
 				}
 				case APPLY_RS: {
 					jrt.applyRS(jrt.getRSVar());
 					position.next();
 					break;
 				}
 				case CALL_FUNCTION: {
 					// arg[0] = function address
 					// arg[1] = function name
 					// arg[2] = # of formal parameters
 					// arg[3] = # of actual parameters
 					// stack[0] = last actual parameter
 					// stack[1] = before-last actual parameter
 					// ...
 					// stack[n-1] = first actual parameter
 					// etc.
 					CallFunctionTuple callTuple = (CallFunctionTuple) tuple;
 					Address funcAddr = callTuple.getAddress();
 					long numFormalParams = callTuple.getNumFormalParams();
 					long numActualParams = callTuple.getNumActualParams();
 					runtimeStack.pushFrame(numFormalParams, position.currentIndex());
 					// Arguments are stacked, so first in the stack is the last for the function
 					for (long i = numActualParams - 1; i >= 0; i--) {
 						Object argument = pop();
 						adoptElementArgumentReference(argument);
 						runtimeStack.setVariable(i, argument, false); // false = local
 					}
 					position.jump(funcAddr);
 					// position.next();
 					break;
 				}
 				case INDIRECT_CALL: {
 					execIndirectCall((IndirectCallTuple) tuple, position, tupleStartNanos);
 					break;
 				}
 				case FUNCTION: {
 					// important for compilation,
 					// not needed for interpretation
 					// arg[0] = function name
 					// arg[1] = # of formal parameters
 					position.next();
 					break;
 				}
 				case WARNING: {
 					jrt.printWarning(((Tuple.WarningTuple) tuple).getMessage());
 					position.next();
 					break;
 				}
 				case SET_RETURN_RESULT: {
 					// stack[0] = return result
 					runtimeStack.setReturnValue(pop());
 					position.next();
 					break;
 				}
 				case RETURN_FROM_FUNCTION: {
 					releaseElementArgumentReferences();
 					position.jump(runtimeStack.popFrame());
 					push(runtimeStack.getReturnValue());
 					position.next();
 					break;
 				}
 				case SET_NUM_GLOBALS: {
 					execSetNumGlobals((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case BEFORE_START_HOOKS: {
 					runBeforeStartHooks();
 					position.next();
 					break;
 				}
 				case UPDATE_SYMTAB: {
 					execUpdateSymtab(((LongTuple) tuple).getValue());
 					position.next();
 					break;
 				}
 				case UPDATE_FUNCTAB: {
 					execUpdateFunctab(((LongTuple) tuple).getValue());
 					position.next();
 					break;
 				}
 				case CLOSE: {
 					// stack[0] = file or command line to close
 					String s = jrt.toAwkString(pop());
 					push(jrt.jrtClose(s));
 					position.next();
 					break;
 				}
 				case APPLY_SUBSEP: {
 					execApplySubsep((CountTuple) tuple);
 					position.next();
 					break;
 				}
 				case APPLY_SUBSEP_UNDER_TOP: {
 					// stack[0] = value to keep on top (the "in" array operand)
 					// stack[1..count] = array indices to convert
 					Object top = pop();
 					execApplySubsep((CountTuple) tuple);
 					push(top);
 					position.next();
 					break;
 				}
 				case DELETE_ARRAY_ELEMENT: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					// stack[0] = array index
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					long offset = variableTuple.getVariableOffset();
 					boolean isGlobal = variableTuple.isGlobal();
 					Map<Object, Object> aa = getMapVariable(offset, isGlobal);
 					Object key = pop();
 					checkScalar(key);
 					if (aa != null) {
 						aa.remove(key);
 						detachMissingArrayArgumentReferences(aa);
 					}
 					position.next();
 					break;
 				}
 				case DELETE_MAP_ELEMENT: {
 					// stack[0] = array index
 					// stack[1] = associative array
 					Object key = pop();
 					checkScalar(key);
 					Map<Object, Object> aa = toMap(pop());
 					aa.remove(key);
 					detachMissingArrayArgumentReferences(aa);
 					position.next();
 					break;
 				}
 				case DELETE_ARRAY: {
 					// arg[0] = offset
 					// arg[1] = isGlobal
 					// (nothing on the stack)
 					VariableTuple variableTuple = (VariableTuple) tuple;
 					long offset = variableTuple.getVariableOffset();
 					boolean isGlobal = variableTuple.isGlobal();
 					Map<Object, Object> array = getMapVariable(offset, isGlobal);
 					if (array != null) {
 						array.clear();
 						detachMissingArrayArgumentReferences(array);
 					}
 					position.next();
 					break;
 				}
 				case SET_WITHIN_END_BLOCKS: {
 					// arg[0] = whether within the END blocks section
 					BooleanTuple endBlocksTuple = (BooleanTuple) tuple;
 					withinEndBlocks = endBlocksTuple.getValue();
 					position.next();
 					break;
 				}
 				case EXIT_WITHOUT_CODE:
 				case EXIT_WITH_CODE: {
 					if (opcode == Opcode.EXIT_WITH_CODE) {
 						// stack[0] = exit code
 						exitCode = (int) JRT.toDouble(pop());
 					}
 					throwExitException = true;
 					withinBeginFileBlocks = false;
 					withinEndFileBlocks = false;
 
 					// If in BEGIN or in a rule, jump to the END section
 					if (!withinEndBlocks && exitAddress != null) {
 						resetCallState();
 						position.jump(exitAddress);
 					} else {
 						// Exit immediately with ExitException
 						// clear operand stack
 						clearOperandStack();
 						throw new ExitException(exitCode, "The AWK script requested an exit");
 						// position.next();
 					}
 					break;
 				}
 				case REGEXP: {
 					// Literal regex tuples must provide a precompiled Pattern as arg[1]
 					RegexTuple regexTuple = (RegexTuple) tuple;
 					Pattern pattern = regexTuple.getPattern();
 					push(pattern);
 					position.next();
 					break;
 				}
 				case CONDITION_PAIR: {
 					// Legacy opcode kept for precompiled tuple streams
 					// stack[0] = End condition
 					// stack[1] = Start condition
 					if (conditionPairs == null) {
 						conditionPairs = new HashMap<Long, ConditionPair>();
 					}
 					long currentIndex = position.currentIndex();
 					ConditionPair cp = conditionPairs.get(currentIndex);
 					if (cp == null) {
 						cp = new ConditionPair();
 						conditionPairs.put(currentIndex, cp);
 					}
 					boolean end = jrt.toBoolean(pop());
 					boolean start = jrt.toBoolean(pop());
 					push(cp.update(start, end) ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case CONDITION_PAIR_IN_RANGE: {
 					// arg[0] = unique identifier of the range pattern
 					if (conditionPairs == null) {
 						conditionPairs = new HashMap<Long, ConditionPair>();
 					}
 					long id = ((LongTuple) tuple).getValue();
 					ConditionPair cp = conditionPairs.get(id);
 					if (cp == null) {
 						cp = new ConditionPair();
 						conditionPairs.put(id, cp);
 					}
 					push(cp.isWithin() ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case CONDITION_PAIR_ENTER: {
 					// arg[0] = unique identifier of the range pattern
 					// A CONDITION_PAIR_IN_RANGE tuple for the same identifier always
 					// executes first, so the pair is already registered
 					conditionPairs.get(((LongTuple) tuple).getValue()).enter();
 					position.next();
 					break;
 				}
 				case CONDITION_PAIR_LEAVE: {
 					// arg[0] = unique identifier of the range pattern
 					conditionPairs.get(((LongTuple) tuple).getValue()).leave();
 					position.next();
 					break;
 				}
 				case IS_IN: {
 					// stack[1] = key to check
 					Object arr = pop();
 					Object arg = pop();
 					checkScalar(arg);
 					if (isUntyped(arr)) {
 						push(ZERO);
 						position.next();
 						break;
 					}
 					if (!(arr instanceof Map)) {
 						throw new AwkRuntimeException("Attempting to use a scalar as an array.");
 					}
 					@SuppressWarnings("unchecked")
 					Map<Object, Object> aa = (Map<Object, Object>) arr;
 					boolean result = JRT.containsAwkKey(aa, arg);
 					push(result ? ONE : ZERO);
 					position.next();
 					break;
 				}
 				case THIS: {
 					// this is in preparation for a function
 					// call for the JVM-COMPILED script, only
 					// therefore, do NOTHING for the interpreted
 					// version
 					position.next();
 					break;
 				}
 				case EXTENSION: {
 					// arg[0] = extension function metadata
 					// arg[1] = # of args on the stack
 					// stack[0] = first actual parameter
 					// stack[1] = second actual parameter
 					// etc.
 					ExtensionTuple extensionTuple = (ExtensionTuple) tuple;
 					ExtensionFunction function = extensionTuple.getFunction();
 					long numArgs = extensionTuple.getArgCount();
 					push(
 							invokeExtension(
 									function,
 									popArguments(numArgs),
 									position.lineNumber()));
 
 					position.next();
 					break;
 				}
 				case ASSIGN_NF: {
 					Object v = pop();
 					jrt.setNF(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_NF: {
 					push(jrt.getNF());
 					position.next();
 					break;
 				}
 				case ASSIGN_NR: {
 					Object v = pop();
 					jrt.setNR(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_NR: {
 					push(jrt.getNR());
 					position.next();
 					break;
 				}
 				case ASSIGN_FNR: {
 					Object v = pop();
 					jrt.setFNR(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_FNR: {
 					push(jrt.getFNR());
 					position.next();
 					break;
 				}
 				case ASSIGN_FS: {
 					Object v = pop();
 					jrt.setFS(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case ASSIGN_IGNORECASE: {
 					Object v = pop();
 					jrt.setIGNORECASE(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_IGNORECASE: {
 					push(jrt.getIGNORECASEVar());
 					position.next();
 					break;
 				}
 				case PUSH_FS: {
 					push(jrt.getFSVar());
 					position.next();
 					break;
 				}
 				case ASSIGN_RS: {
 					Object v = pop();
 					jrt.setRS(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_RS: {
 					push(jrt.getRSVar());
 					position.next();
 					break;
 				}
 				case ASSIGN_OFS: {
 					Object v = pop();
 					jrt.setOFS(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_OFS: {
 					push(jrt.getOFSVar());
 					position.next();
 					break;
 				}
 				case ASSIGN_ORS: {
 					Object v = pop();
 					jrt.setORS(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_ORS: {
 					push(jrt.getORSVar());
 					position.next();
 					break;
 				}
 				case ASSIGN_RSTART: {
 					Object v = pop();
 					jrt.setRSTART(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_RSTART: {
 					push(jrt.getRSTART());
 					position.next();
 					break;
 				}
 				case ASSIGN_RLENGTH: {
 					Object v = pop();
 					jrt.setRLENGTH(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_RLENGTH: {
 					push(jrt.getRLENGTH());
 					position.next();
 					break;
 				}
 				case ASSIGN_FILENAME: {
 					Object v = pop();
 					jrt.setFILENAMEViaJrt(v);
 					push(v == null ? "" : v);
 					position.next();
 					break;
 				}
 				case PUSH_FILENAME: {
 					push(jrt.getFILENAME());
 					position.next();
 					break;
 				}
 				case ASSIGN_ERRNO: {
 					Object v = pop();
 					jrt.setERRNO(v);
 					push(v == null ? "" : v);
 					position.next();
 					break;
 				}
 				case PUSH_ERRNO: {
 					push(jrt.getERRNO());
 					position.next();
 					break;
 				}
 				case ASSIGN_ARGIND: {
 					Object v = pop();
 					jrt.setARGIND(v);
 					push(v == null ? ZERO : v);
 					position.next();
 					break;
 				}
 				case PUSH_ARGIND: {
 					push(jrt.getARGIND());
 					position.next();
 					break;
 				}
 				case ASSIGN_SUBSEP: {
 					Object v = pop();
 					jrt.setSUBSEP(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_SUBSEP: {
 					push(jrt.getSUBSEPVar());
 					position.next();
 					break;
 				}
 				case ASSIGN_CONVFMT: {
 					Object v = pop();
 					jrt.setCONVFMT(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_CONVFMT: {
 					push(jrt.getCONVFMTVar());
 					position.next();
 					break;
 				}
 				case ASSIGN_OFMT: {
 					Object v = pop();
 					jrt.setOFMT(v);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_OFMT: {
 					push(getOFMT());
 					position.next();
 					break;
 				}
 				case ASSIGN_ARGC: {
 					Object v = pop();
 					if (argcOffset == NULL_OFFSET) {
 						throw new AwkRuntimeException("ARGC is read-only (not materialized).");
 					}
 					runtimeStack.setVariable(argcOffset, v, true);
 					push(v);
 					position.next();
 					break;
 				}
 				case PUSH_ARGC: {
 					if (argcOffset == NULL_OFFSET) {
 						push(getARGC());
 					} else {
 						push(runtimeStack.getVariable(argcOffset, true));
 					}
 					position.next();
 					break;
 				}
 				default:
 					throw new Error("invalid opcode: " + position.opcode());
 				}
 				if (profiling) {
 					afterProfiledTuple(opcode, tupleStartNanos);
 				}
 			}
 
 		} catch (ExitException ee) {
 			if (profiling && (opcode == Opcode.EXIT_WITH_CODE || opcode == Opcode.EXIT_WITHOUT_CODE)) {
 				afterProfiledTuple(opcode, tupleStartNanos);
 			}
 			throw ee;
 		} catch (IOException ioe) {
 			resetCallState();
 			throw ioe;
 		} catch (RuntimeException re) {
 			resetCallState();
 			if (re instanceof AwkSandboxException) {
 				throw re;
 			}
 			throw new AwkRuntimeException(position.lineNumber(), re.getMessage(), re);
 		} catch (AssertionError ae) {
 			resetCallState();
 			throw ae;
 		}
 
 		// If <code>exit</code> was called, throw an ExitException
 		if (throwExitException) {
 			throw new ExitException(exitCode, "The AWK script requested an exit");
 		}
 	}
 
 	/**
 	 * Clears all collected profiling statistics.
 	 */
 	public void resetProfiling() {
 		if (!profiling) {
 			return;
 		}
 		tupleProfilingStats.clear();
 		functionProfilingStats.clear();
 		activeProfilingFunctions.clear();
 	}
 
 	/**
 	 * Returns an immutable snapshot of the collected profiling statistics.
 	 *
 	 * @return profiling report snapshot
 	 */
 	public ProfilingReport getProfilingReport() {
 		if (!profiling) {
 			return ProfilingReport.empty();
 		}
 		return new ProfilingReport(tupleProfilingStats, functionProfilingStats);
 	}
 
 	// The exec* helpers below are extracted from executeTuples on purpose:
 	// that method must stay well under HotSpot's HugeMethodLimit (8000
 	// bytecodes) or the JIT never compiles the interpreter loop (see #562).
 
 	private void execCompoundAssignVariable(Opcode opcode, VariableTuple variableTuple) {
 		// arg[0] = offset
 		// arg[1] = isGlobal
 		// stack[0] = value
 		long offset = variableTuple.getVariableOffset();
 		boolean isGlobal = variableTuple.isGlobal();
 		Object o1 = blankToZero(resolveVariable(offset, isGlobal, false));
 		Object o2 = pop();
 		Object ans;
 		switch (opcode) {
 		case PLUS_EQ:
 			ans = JRT.add(o1, o2);
 			break;
 		case MINUS_EQ:
 			ans = JRT.subtract(o1, o2);
 			break;
 		case MULT_EQ:
 			ans = JRT.multiply(o1, o2);
 			break;
 		case DIV_EQ:
 			ans = JRT.divide(o1, o2);
 			break;
 		case MOD_EQ:
 			ans = JRT.mod(o1, o2);
 			break;
 		case POW_EQ:
 			ans = JRT.pow(o1, o2);
 			break;
 		default:
 			throw new Error("Invalid opcode here: " + opcode);
 		}
 		push(ans);
 		runtimeStack.setVariable(offset, ans, isGlobal);
 	}
 
 	private void execCompoundAssignArray(Opcode opcode, VariableTuple variableTuple) {
 		// arg[0] = offset
 		// arg[1] = isGlobal
 		// stack[0] = array index
 		// stack[1] = value
 		Object arrIdx = pop();
 		Object rhs = pop();
 		if (rhs == null) {
 			rhs = BLANK;
 		}
 		long offset = variableTuple.getVariableOffset();
 		boolean isGlobal = variableTuple.isGlobal();
 
 		Map<Object, Object> array = ensureMapVariable(offset, isGlobal);
 		checkScalar(arrIdx);
 		Object o = blankToZero(array.get(arrIdx));
 
 		Object newVal;
 
 		switch (opcode) {
 		case PLUS_EQ_ARRAY:
 			newVal = JRT.add(o, rhs);
 			break;
 		case MINUS_EQ_ARRAY:
 			newVal = JRT.subtract(o, rhs);
 			break;
 		case MULT_EQ_ARRAY:
 			newVal = JRT.multiply(o, rhs);
 			break;
 		case DIV_EQ_ARRAY:
 			newVal = JRT.divide(o, rhs);
 			break;
 		case MOD_EQ_ARRAY:
 			newVal = JRT.mod(o, rhs);
 			break;
 		case POW_EQ_ARRAY:
 			newVal = JRT.pow(o, rhs);
 			break;
 		default:
 			throw new Error("Invalid op code here: " + opcode);
 		}
 
 		assignArray(offset, arrIdx, newVal, isGlobal);
 	}
 
 	private void execCompoundAssignMapElement(Opcode opcode) {
 		// stack[0] = array index
 		// stack[1] = associative array
 		// stack[2] = value
 		Object arrIdx = pop();
 		Map<Object, Object> array = toMap(pop());
 		Object rhs = pop();
 		if (rhs == null) {
 			rhs = BLANK;
 		}
 
 		checkScalar(arrIdx);
 		Object o = blankToZero(array.get(arrIdx));
 		Object newVal;
 
 		switch (opcode) {
 		case PLUS_EQ_MAP_ELEMENT:
 			newVal = JRT.add(o, rhs);
 			break;
 		case MINUS_EQ_MAP_ELEMENT:
 			newVal = JRT.subtract(o, rhs);
 			break;
 		case MULT_EQ_MAP_ELEMENT:
 			newVal = JRT.multiply(o, rhs);
 			break;
 		case DIV_EQ_MAP_ELEMENT:
 			newVal = JRT.divide(o, rhs);
 			break;
 		case MOD_EQ_MAP_ELEMENT:
 			newVal = JRT.mod(o, rhs);
 			break;
 		case POW_EQ_MAP_ELEMENT:
 			newVal = JRT.pow(o, rhs);
 			break;
 		default:
 			throw new Error("Invalid op code here: " + opcode);
 		}
 
 		assignMapElement(array, arrIdx, newVal);
 	}
 
 	private void execCompoundAssignInputField(Opcode opcode) {
 		// stack[0] = dollar_fieldNumber
 		// stack[1] = inc value
 
 		// same code as GET_INPUT_FIELD:
 		long fieldnum = JRT.parseFieldNumber(pop());
 		Object incval = pop();
 
 		// except here, get the number, and add the incvalue
 		Object numObj = blankToZero(jrt.jrtGetInputField(fieldnum));
 		Object num;
 		switch (opcode) {
 		case PLUS_EQ_INPUT_FIELD:
 			num = JRT.add(numObj, incval);
 			break;
 		case MINUS_EQ_INPUT_FIELD:
 			num = JRT.subtract(numObj, incval);
 			break;
 		case MULT_EQ_INPUT_FIELD:
 			num = JRT.multiply(numObj, incval);
 			break;
 		case DIV_EQ_INPUT_FIELD:
 			num = JRT.divide(numObj, incval);
 			break;
 		case MOD_EQ_INPUT_FIELD:
 			num = JRT.mod(numObj, incval);
 			break;
 		case POW_EQ_INPUT_FIELD:
 			num = JRT.pow(numObj, incval);
 			break;
 		default:
 			throw new Error("Invalid opcode here: " + opcode);
 		}
 		setNumOnJRT(fieldnum, num);
 
 		// put the result value on the stack
 		push(num);
 	}
 
 	private void execIndirectCall(IndirectCallTuple callTuple, PositionTracker position, long tupleStartNanos) {
 		Object[] actualArguments = popArguments(callTuple.getNumActualParams());
 		String requestedName = jrt.toAwkString(pop());
 		String qualifiedName = normalizeIndirectFunctionName(requestedName);
 		IndirectFunctionTarget target = callTuple.getUserFunctions().get(qualifiedName);
 		if (target != null) {
 			long formalCount = target.getNumFormalParams();
 			if (actualArguments.length > formalCount) {
 				jrt
 						.printWarning(
 								"gawk: "
 										+ callTuple.getSourceName()
 										+ ":"
 										+ callTuple.getSourceLine()
 										+ ": warning: function `"
 										+ qualifiedName
 										+ "' called with more arguments than declared");
 			}
 			if (profiling) {
 				activeProfilingFunctions.push(new ActiveFunction(qualifiedName, tupleStartNanos));
 			}
 			runtimeStack.pushFrame(formalCount, position.currentIndex());
 			adoptElementArgumentReferences(actualArguments);
 			int copiedArgumentCount = Math.min(actualArguments.length, (int) formalCount);
 			for (int i = 0; i < copiedArgumentCount; i++) {
 				runtimeStack.setVariable(i, actualArguments[i], false);
 			}
 			position.jump(target.getAddress());
 			return;
 		}
 
 		String awkName = requestedName.startsWith("awk::") ?
 				requestedName.substring("awk::".length()) : requestedName;
 		BuiltinFunction builtin = BuiltinFunction.of(awkName);
 		if (builtin != null) {
 			resolveIndirectArguments(actualArguments, builtin);
 			push(invokeIndirectBuiltin(builtin, actualArguments, position.lineNumber()));
 			position.next();
 			return;
 		}
 		ExtensionFunction extensionFunction = callTuple.getExtensionFunctions().get(awkName);
 		if (extensionFunction != null) {
 			resolveIndirectArguments(actualArguments, extensionFunction);
 			if (profiling) {
 				activeProfilingFunctions.push(new ActiveFunction(awkName, tupleStartNanos));
 			}
 			try {
 				push(
 						invokeExtension(
 								extensionFunction,
 								actualArguments,
 								position.lineNumber()));
 			} finally {
 				if (profiling) {
 					recordFunctionExit(System.nanoTime());
 				}
 			}
 			position.next();
 			return;
 		}
 		throw new AwkRuntimeException(
 				position.lineNumber(),
 				"function `" + qualifiedName + "' is not defined");
 	}
 
 	private void execPrint(CountTuple tuple) throws IOException {
 		long numArgs = tuple.getCount();
 		jrt.printDefault(numArgs == 0 ? new Object[] { jrt.jrtGetInputField(0) } : popArguments(numArgs));
 	}
 
 	private void execPrintToFile(CountAndAppendTuple tuple) throws IOException {
 		String key = jrt.toAwkString(pop());
 		long numArgs = tuple.getCount();
 		jrt
 				.printToFile(
 						key,
 						tuple.isAppend(),
 						numArgs == 0 ? new Object[]
 						{ jrt.jrtGetInputField(0) } : popArguments(numArgs));
 	}
 
 	private void execPrintToPipe(CountTuple tuple) throws IOException {
 		String cmd = jrt.toAwkString(pop());
 		long numArgs = tuple.getCount();
 		jrt.printToProcess(cmd, numArgs == 0 ? new Object[] { jrt.jrtGetInputField(0) } : popArguments(numArgs));
 	}
 
 	private void execPrintf(CountTuple tuple) throws IOException {
 		long numArgs = tuple.getCount();
 		Object[] values = popArguments(numArgs - 1);
 		String format = jrt.toAwkString(pop());
 		jrt.printfDefault(format, values);
 	}
 
 	private void execPrintfToFile(CountAndAppendTuple tuple) throws IOException {
 		String key = jrt.toAwkString(pop());
 		long numArgs = tuple.getCount();
 		Object[] values = popArguments(numArgs - 1);
 		String format = jrt.toAwkString(pop());
 		jrt.printfToFile(key, tuple.isAppend(), format, values);
 	}
 
 	private void execPrintfToPipe(CountTuple tuple) throws IOException {
 		String cmd = jrt.toAwkString(pop());
 		long numArgs = tuple.getCount();
 		Object[] values = popArguments(numArgs - 1);
 		String format = jrt.toAwkString(pop());
 		jrt.printfToProcess(cmd, format, values);
 	}
 
 	private void execLength(CountTuple tuple) {
 		long num = tuple.getCount();
 		if (num == 0) {
 			push(jrt.jrtGetInputField(0).toString().length());
 			return;
 		}
 		Object value = pop();
 		if (value instanceof ArgumentReference) {
 			value = resolveLengthArgumentReference((ArgumentReference) value);
 		}
 		push(lengthOf(value));
 	}
 
 	private Object lengthOf(Object value) {
 		return value instanceof Map ?
 				Long.valueOf(((Map<?, ?>) value).size()) : Integer.valueOf(jrt.toAwkString(value).length());
 	}
 
 	private String normalizeIndirectFunctionName(String functionName) {
 		return functionName.startsWith("awk::") ? functionName.substring("awk::".length()) : functionName;
 	}
 
 	/**
 	 * Unwinds every call frame and clears the per-call runtime state, after an
 	 * {@code exit} or {@code nextfile} statement or an abandoned execution.
 	 * When profiling, the abandoned function calls are recorded as exited at
 	 * this point, so the timing report stays accurate and the active-function
 	 * stack does not leak entries (see #557).
 	 */
 	private void resetCallState() {
 		if (profiling) {
 			recordAllFunctionExits(System.nanoTime());
 		}
 		runtimeStack.popAllFrames();
 		elementArgumentReferences.clear();
 		clearOperandStack();
 	}
 
 	/**
 	 * Registers the untyped element references received by the call frame that
 	 * was just pushed, so array mutations occurring during the call can detach
 	 * them. References forwarded from an enclosing call keep their original
 	 * owner.
 	 */
 	private void adoptElementArgumentReferences(Object[] actualArguments) {
 		for (Object argument : actualArguments) {
 			adoptElementArgumentReference(argument);
 		}
 	}
 
 	private void adoptElementArgumentReference(Object argument) {
 		if (argument instanceof IndirectArrayArgumentReference) {
 			IndirectArrayArgumentReference reference = (IndirectArrayArgumentReference) argument;
 			if (reference.ownerFrame < 0) {
 				reference.ownerFrame = runtimeStack.frameCount();
 				elementArgumentReferences.push(reference);
 			}
 		}
 	}
 
 	/**
 	 * Drops the element references owned by the call frame that is about to be
 	 * popped. Frames are strictly nested, so the owned references always sit on
 	 * top of the tracking stack.
 	 */
 	private void releaseElementArgumentReferences() {
 		int depth = runtimeStack.frameCount();
 		while (!elementArgumentReferences.isEmpty()
 				&& elementArgumentReferences.peek().ownerFrame == depth) {
 			elementArgumentReferences.pop();
 		}
 	}
 
 	private Object resolveUserFunctionArgument(Object argument) {
 		if (!(argument instanceof ArgumentReference)) {
 			return argument;
 		}
 		ArgumentReference reference = (ArgumentReference) argument;
 		Object snapshot = reference.snapshot();
 		if (snapshot instanceof ArgumentReference) {
 			return resolveUserFunctionArgument(snapshot);
 		}
 		return isUntyped(snapshot) ? reference : snapshot;
 	}
 
 	private void resolveIndirectArguments(
 			Object[] actualArgumentsParam,
 			BuiltinFunction builtin) {
 		for (int index = 0; index < actualArgumentsParam.length; index++) {
 			boolean arrayArgument = builtin == BuiltinFunction.SPLIT && index == 1;
 			actualArgumentsParam[index] = resolveIndirectArgument(
 					actualArgumentsParam[index],
 					arrayArgument,
 					false);
 		}
 	}
 
 	private void resolveIndirectArguments(
 			Object[] actualArgumentsParam,
 			ExtensionFunction function) {
 		boolean[] arrayArguments = new boolean[actualArgumentsParam.length];
 		boolean[] rawValueArguments = new boolean[actualArgumentsParam.length];
 		for (int index : function.collectAssocArrayIndexes(actualArgumentsParam.length)) {
 			arrayArguments[index] = true;
 		}
 		for (int index : function.collectRawValueIndexes(actualArgumentsParam.length)) {
 			rawValueArguments[index] = true;
 		}
 		for (int index = 0; index < actualArgumentsParam.length; index++) {
 			actualArgumentsParam[index] = resolveIndirectArgument(
 					actualArgumentsParam[index],
 					arrayArguments[index],
 					rawValueArguments[index]);
 		}
 	}
 
 	private Object resolveIndirectArgument(
 			Object argument,
 			boolean arrayArgument,
 			boolean rawValueArgument) {
 		if (!(argument instanceof ArgumentReference)) {
 			return argument;
 		}
 		ArgumentReference reference = (ArgumentReference) argument;
 		if (rawValueArgument) {
 			return resolveRawArgumentReference(reference);
 		}
 		return resolveArgumentReference(reference, arrayArgument);
 	}
 
 	private Object invokeIndirectBuiltin(
 			BuiltinFunction builtin,
 			Object[] args,
 			int lineNumber) {
 		switch (builtin) {
 		case ATAN2:
 			requireIndirectArgumentCount(builtin, args, 2, 2, lineNumber);
 			return Math.atan2(JRT.toDouble(args[0]), JRT.toDouble(args[1]));
 		case CLOSE:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return jrt.jrtClose(jrt.toAwkString(args[0]));
 		case COS:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return Math.cos(JRT.toDouble(args[0]));
 		case EXP:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return Math.exp(JRT.toDouble(args[0]));
 		case GSUB:
 		case SUB:
 			requireIndirectArgumentCount(builtin, args, 2, 2, lineNumber);
 			return substituteInputLine(
 					builtin == BuiltinFunction.GSUB,
 					args[0],
 					args[1]);
 		case INDEX:
 			requireIndirectArgumentCount(builtin, args, 2, 2, lineNumber);
 			return jrt.index(jrt.toAwkString(args[0]), jrt.toAwkString(args[1]));
 		case INT:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return JRT.truncateToScalar(JRT.toDouble(args[0]));
 		case LENGTH:
 			requireIndirectArgumentCount(builtin, args, 0, 1, lineNumber);
 			return args.length == 0 ? Integer.valueOf(jrt.jrtGetInputField(0).toString().length()) : lengthOf(args[0]);
 		case LOG:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return Math.log(JRT.toDouble(args[0]));
 		case MATCH:
 			requireIndirectArgumentCount(builtin, args, 2, 2, lineNumber);
 			return jrt.matchPosition(jrt.toAwkString(args[0]), jrt.toAwkString(args[1]));
 		case RAND:
 			requireIndirectArgumentCount(builtin, args, 0, 0, lineNumber);
 			return randomNumberGenerator.nextDouble();
 		case SIN:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return Math.sin(JRT.toDouble(args[0]));
 		case SPLIT:
 			requireIndirectArgumentCount(builtin, args, 2, 3, lineNumber);
 			return splitIntoArray(
 					args[0],
 					args[1],
 					args.length == 3 ? args[2] : jrt.getFSVar(),
 					lineNumber);
 		case SPRINTF:
 			requireIndirectArgumentCount(builtin, args, 1, Integer.MAX_VALUE, lineNumber);
 			return jrt
 					.sprintf(
 							jrt.toAwkString(args[0]),
 							Arrays.copyOfRange(args, 1, args.length));
 		case SQRT:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return Math.sqrt(JRT.toDouble(args[0]));
 		case SRAND:
 			requireIndirectArgumentCount(builtin, args, 0, 1, lineNumber);
 			int seed = args.length == 0 ? JRT.timeSeed() : (int) JRT.toDouble(args[0]);
 			int previousSeed = randomNumberGenerator.getSeed();
 			randomNumberGenerator.setSeed(seed);
 			return Integer.valueOf(previousSeed);
 		case SUBSTR:
 			requireIndirectArgumentCount(builtin, args, 2, 3, lineNumber);
 			return substring(
 					args[0],
 					args[1],
 					args.length == 3 ? args[2] : null);
 		case SYSTEM:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return jrt.jrtSystem(jrt.toAwkString(args[0]));
 		case TOLOWER:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return jrt.toAwkString(args[0]).toLowerCase();
 		case TOUPPER:
 			requireIndirectArgumentCount(builtin, args, 1, 1, lineNumber);
 			return jrt.toAwkString(args[0]).toUpperCase();
 		default:
 			throw new AwkRuntimeException(
 					lineNumber,
 					"indirect calls are not implemented for builtin `" + builtin.getAwkName() + "'");
 		}
 	}
 
 	private void requireIndirectArgumentCount(
 			BuiltinFunction builtin,
 			Object[] args,
 			int minimum,
 			int maximum,
 			int lineNumber) {
 		if (args.length < minimum || args.length > maximum) {
 			String expected = minimum == maximum ? Integer.toString(minimum) : minimum + " to " + maximum;
 			throw new AwkRuntimeException(
 					lineNumber,
 					builtin.getAwkName() + " requires " + expected + " argument(s), not " + args.length);
 		}
 	}
 
 	private Object invokeExtension(
 			ExtensionFunction function,
 			Object[] args,
 			int lineNumber) {
 		// Let extensions report diagnostics at the call location.
 		currentLineNumber = lineNumber;
 		String extensionClassName = function.getExtensionClassName();
 		JawkExtension extension = extensionInstances.get(extensionClassName);
 		if (extension == null) {
 			throw new AwkRuntimeException(
 					lineNumber,
 					"Extension instance for class '" + extensionClassName + "' is not registered");
 		}
 		if (!(extension instanceof AbstractExtension)) {
 			throw new AwkRuntimeException(
 					lineNumber,
 					"Extension instance for class '" + extensionClassName
 							+ "' does not extend "
 							+ AbstractExtension.class.getName());
 		}
 		Map<IndirectArrayArgumentReference, Object> attachedValues = captureAttachedArrayArgumentValues();
 		Object result;
 		try {
 			result = function.invoke((AbstractExtension) extension, args);
 		} finally {
 			detachReplacedArrayArgumentReferences(attachedValues);
 		}
 		if (result == null) {
 			return "";
 		}
 		if (result instanceof Number
 				|| result instanceof String
 				|| result instanceof Map) {
 			return result;
 		}
 		return jrt.toAwkString(result);
 	}
 
 	private void execMatch() {
 		String ere = jrt.toAwkString(pop());
 		String s = jrt.toAwkString(pop());
 		push(jrt.matchPosition(s, ere));
 	}
 
 	private void execSubForDollar0(BooleanTuple tuple) {
 		Object replacement = pop();
 		Object ere = pop();
 		push(substituteInputLine(tuple.getValue(), ere, replacement));
 	}
 
 	private Object substituteInputLine(boolean global, Object ere, Object replacement) {
 		String orig = jrt.toAwkString(jrt.jrtGetInputField(0));
 		Object replacements = global ?
 				jrt.replaceAll(orig, jrt.toAwkString(replacement), jrt.toAwkString(ere)) :
 				jrt.replaceFirst(orig, jrt.toAwkString(replacement), jrt.toAwkString(ere));
 		jrt.setInputLine(jrt.getReplaceResult());
 		jrt.jrtParseFields();
 		return replacements;
 	}
 
 	private void execSubForDollarReference(BooleanTuple tuple) {
 		boolean isGsub = tuple.getValue();
 		long fieldNum = JRT.parseFieldNumber(pop());
 		String orig = jrt.toAwkString(pop());
 		String repl = jrt.toAwkString(pop());
 		String ere = jrt.toAwkString(pop());
 		push(isGsub ? jrt.replaceAll(orig, repl, ere) : jrt.replaceFirst(orig, repl, ere));
 		String newstring = jrt.getReplaceResult();
 		if (fieldNum == 0) {
 			jrt.setInputLine(newstring);
 			jrt.jrtParseFields();
 		} else {
 			jrt.jrtSetInputField(newstring, fieldNum);
 		}
 	}
 
 	private void execSubForVariable(SubstitutionVariableTuple tuple, PositionTracker position) {
 		String newString = execSubOrGSub(tuple.isGlobalSubstitution());
 		assign(tuple.getVariableOffset(), newString, tuple.isGlobal(), position, false);
 	}
 
 	private void execSubForArrayReference(SubstitutionVariableTuple tuple) {
 		Object arrIdx = pop();
 		String newString = execSubOrGSub(tuple.isGlobalSubstitution());
 		assignArray(tuple.getVariableOffset(), arrIdx, newString, tuple.isGlobal());
 		pop();
 	}
 
 	private void execSubForMapReference(BooleanTuple tuple) {
 		Object arrIdx = pop();
 		Map<Object, Object> array = toMap(pop());
 		String newString = execSubOrGSub(tuple.getValue());
 		assignMapElement(array, arrIdx, newString);
 		pop();
 	}
 
 	private void execSplit(CountTuple tuple, PositionTracker position) {
 		long numArgs = tuple.getCount();
 		Object fs;
 		if (numArgs == 2) {
 			fs = jrt.getFSVar();
 		} else if (numArgs == 3) {
 			// a regexp literal arrives precompiled and stays that way, so the
 			// tokenizer can honor IGNORECASE through the pattern-twin cache
 			fs = pop();
 		} else {
 			throw new Error("Invalid # of args. split() requires 2 or 3. Got: " + numArgs);
 		}
 		Object target = pop();
 		Object source = pop();
 		push(splitIntoArray(source, target, fs, position.lineNumber()));
 	}
 
 	private Object splitIntoArray(Object source, Object target, Object separator, int lineNumber) {
 		if (!(target instanceof Map)) {
 			throw new AwkRuntimeException(lineNumber, target + " is not an array.");
 		}
 		Enumeration<Object> tokenizer = jrt.splitTokenizer(jrt.toAwkString(source), separator);
 		@SuppressWarnings("unchecked")
 		Map<Object, Object> assocArray = (Map<Object, Object>) target;
 		assocArray.clear();
 		detachMissingArrayArgumentReferences(assocArray);
 		long cnt = 0;
 		while (tokenizer.hasMoreElements()) {
 			Object value = tokenizer.nextElement();
 			assocArray.put(++cnt, jrt.toInputScalar(value));
 		}
 		return Long.valueOf(cnt);
 	}
 
 	private void execSubstr(CountTuple tuple) {
 		long numArgs = tuple.getCount();
 		Object length = null;
 		if (numArgs == 3) {
 			length = pop();
 		} else if (numArgs != 2) {
 			throw new Error("numArgs for SUBSTR must be 2 or 3. It is " + numArgs);
 		}
 		Object start = pop();
 		Object value = pop();
 		push(substring(value, start, length));
 	}
 
 	private Object substring(Object value, Object start, Object requestedLength) {
 		String s = jrt.toAwkString(value);
 		int startPos = (int) JRT.toDouble(start);
 		if (startPos <= 0) {
 			startPos = 1;
 		}
 		if (startPos > s.length()) {
 			return BLANK;
 		}
 		int available = s.length() - startPos + 1;
 		// The requested length is kept as a long and clamped to what the string
 		// can supply: a length beyond the int range would otherwise wrap around
 		// and turn "the rest of the string" into an empty result.
 		long length = requestedLength == null ? available : JRT.toLong(requestedLength);
 		if (length <= 0) {
 			return BLANK;
 		}
 		if (length > available) {
 			length = available;
 		}
 		return s.substring(startPos - 1, startPos - 1 + (int) length);
 	}
 
 	private void execSetNumGlobals(CountTuple tuple) {
 		long numGlobals = tuple.getCount();
 		Object[] globals = runtimeStack.getNumGlobals();
 		if (mergedGlobalLayoutActive) {
 			if (!hasCompatiblePersistentGlobalLayout(numGlobals)) {
 				throw new IllegalStateException(
 						"AVM globals are already initialized for an incompatible persistent layout.");
 			}
 			applyExecutionInitialVariablesToGlobalSlots(true);
 		} else if (globals == null) {
 			runtimeStack.setNumGlobals(numGlobals, globalVariableOffsets);
 			initializedEvalGlobalVariableOffsets = globalVariableOffsets;
 			initializedEvalGlobalVariableArrays = globalVariableArrays;
 			applyExecutionInitialVariablesToGlobalSlots(false);
 		} else if (!hasCompatibleEvalGlobalLayout(numGlobals)) {
 			throw new IllegalStateException(
 					"AVM globals are already initialized for a different eval layout. Call prepareForEval(...) first.");
 		}
 	}
 
 	private void populateEnviron(long offset) {
 		environOffset = offset;
 		for (Map.Entry<String, String> var : System.getenv().entrySet()) {
 			assignArray(environOffset, var.getKey(), jrt.toInputScalar(var.getValue()), true);
 			pop(); // clean up the stack after the assignment
 		}
 	}
 
 	private void populateArgc(long offset) {
 		argcOffset = offset;
 		// +1 to include the "jawk" program name (ARGV[0])
 		runtimeStack.setVariable(argcOffset, Integer.valueOf(arguments.size() + 1), true);
 	}
 
 	private void populateArgv(long offset) {
 		argvOffset = offset;
 		// A host-supplied ARGV takes precedence over the operand list: leave
 		// it untouched instead of overwriting its entries.
 		Object existing = runtimeStack.getVariable(argvOffset, true);
 		if (existing instanceof Map && !((Map<?, ?>) existing).isEmpty()) {
 			return;
 		}
 		forEachArgvEntry((index, value) -> {
 			assignArray(argvOffset, index, value, true);
 			pop(); // clean up the stack after the assignment
 		});
 	}
 
 	/**
 	 * Supplies the ARGV entries to the given consumer, in index order:
 	 * ARGV[0] is the program name, ARGV[1..n] the command-line arguments.
 	 * Indexes are supplied as {@code Long}, the canonical AWK array key
 	 * form. The count comes straight from the argument list because ARGC
 	 * may not be materialized when the script does not reference it.
 	 *
 	 * @param consumer receives each (index, value) ARGV entry
 	 */
 	private void forEachArgvEntry(BiConsumer<Long, Object> consumer) {
 		consumer.accept(Long.valueOf(0L), "jawk");
 		for (int i = 1; i <= arguments.size(); i++) {
 			consumer.accept(Long.valueOf(i), jrt.toInputScalar(arguments.get(i - 1)));
 		}
 	}
 
 	/*
 	 * Extension initialization can be heavy, so the hooks run at most once per
 	 * AVM instance: a reused AVM (repeated executions, expression evaluations)
 	 * does not reinitialize its extensions.
 	 */
 	private void runBeforeStartHooks() {
 		if (beforeStartHooksExecuted || extensionInstances.isEmpty()) {
 			return;
 		}
 		beforeStartHooksExecuted = true;
 		Set<JawkExtension> started = new LinkedHashSet<JawkExtension>();
 		for (JawkExtension extension : extensionInstances.values()) {
 			if (started.add(extension)) {
 				extension.beforeStart(this, jrt);
 			}
 		}
 	}
 
 	/*
 	 * SYMTAB is a gawk extension mirroring the symbol table: the script's
 	 * globals, the JRT-managed specials, and host-supplied variables that have
 	 * no compiled slot. The parser emits UPDATE_SYMTAB only when the script
 	 * references SYMTAB outside POSIX mode. Declared globals and managed special
 	 * variables remain linked to their runtime values.
 	 */
 	private void execUpdateSymtab(long offset) {
 		symtabOffset = offset;
 		if (runtimeStack.getVariable(offset, true) != null) {
 			// a host-supplied SYMTAB value wins
 			return;
 		}
 		SymtabArray symtab = new SymtabArray();
 		for (String name : executionInitialVariables.keySet()) {
 			symtab.put(name, getVariable(name));
 		}
 		for (String name : getGlobalVariableNames()) {
 			// gawk keeps the meta tables out of the symbol table snapshot
 			if ("SYMTAB".equals(name) || "FUNCTAB".equals(name)) {
 				continue;
 			}
 			symtab.put(name, getVariable(name));
 		}
 		// specials last: their accessors are authoritative even when the name
 		// also has a (possibly not yet materialized) global slot
 		for (String name : getSpecialVariableNames()) {
 			symtab.put(name, getVariable(name));
 		}
 		symtab.activate();
 		runtimeStack.setVariable(offset, symtab, true);
 	}
 
 	private final class SymtabArray extends java.util.AbstractMap<Object, Object> implements AssocArray {
 		private final Map<Object, Object> entries = newAwkArray();
 		private final Set<String> assignableNames = new HashSet<String>();
 		private boolean active;
 
 		private void activate() {
 			active = true;
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Object get(Object key) {
 			String name = key == null ? "" : key.toString();
 			if (active && !isMetaTableName(name) && isLiveSpecialVariable(name)) {
 				return getVariable(name);
 			}
 			Integer offset = globalVariableOffsets == null ? null : globalVariableOffsets.get(name);
 			if (active && !isMetaTableName(name) && offset != null) {
 				return runtimeStack.getVariable(offset.intValue(), true);
 			}
 			return entries.get(key);
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public boolean containsKey(Object key) {
 			String name = key == null ? "" : key.toString();
 			return active
 					&& !isMetaTableName(name)
 					&& (isLiveSpecialVariable(name)
 							|| (globalVariableOffsets != null && globalVariableOffsets.containsKey(name)))
 					|| entries.containsKey(key);
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Object put(Object key, Object value) {
 			String name = key == null ? "" : key.toString();
 			if (!active) {
 				if (key != null) {
 					assignableNames.add(name);
 				}
 				return entries.put(key, value);
 			}
 			if (!assignableNames.contains(name)) {
 				throw new AwkRuntimeException("Cannot assign to an arbitrary element of SYMTAB.");
 			}
 			validateGlobalType(name, value);
 			Object previous = entries.put(key, value);
 			if (isMetaTableName(name)) {
 				return previous;
 			}
 			if (applyLiveSpecialVariable(name, value)) {
 				return previous;
 			}
 			Integer offset = globalVariableOffsets == null ? null : globalVariableOffsets.get(name);
 			if (offset != null) {
 				runtimeStack.setVariable(offset.intValue(), value, true);
 			}
 			return previous;
 		}
 
 		private Object putRuntimeVariable(String name, Object value) {
 			assignableNames.add(name);
 			return put(name, value);
 		}
 
 		private boolean applyLiveSpecialVariable(String name, Object value) {
 			if ("ARGC".equals(name)) {
 				if (argcOffset == NULL_OFFSET) {
 					throw new AwkRuntimeException("ARGC is read-only (not materialized).");
 				}
 				runtimeStack.setVariable(argcOffset, value, true);
 				return true;
 			}
 			if ("RSTART".equals(name)) {
 				jrt.setRSTART(value);
 				return true;
 			}
 			if ("RLENGTH".equals(name)) {
 				jrt.setRLENGTH(value);
 				return true;
 			}
 			return isManagedSpecialVariable(name) && jrt.applySpecialVariable(name, value);
 		}
 
 		private boolean isLiveSpecialVariable(String name) {
 			return isManagedSpecialVariable(name)
 					|| "RSTART".equals(name)
 					|| "RLENGTH".equals(name);
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Object remove(Object key) {
 			if (active) {
 				throw new AwkRuntimeException("Cannot delete an element from SYMTAB.");
 			}
 			return entries.remove(key);
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public void clear() {
 			if (active) {
 				throw new AwkRuntimeException("Cannot delete SYMTAB.");
 			}
 			entries.clear();
 		}
 
 		private void validateGlobalType(String name, Object value) {
 			Boolean array = globalVariableArrays == null ? null : globalVariableArrays.get(name);
 			if (Boolean.TRUE.equals(array) && !(value instanceof Map)) {
 				throw new AwkRuntimeException(
 						"Attempting to use array `" + name + "' in a scalar context.");
 			}
 			if (Boolean.FALSE.equals(array) && value instanceof Map) {
 				throw new AwkRuntimeException(
 						"Attempting to use scalar `" + name + "' as an array.");
 			}
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Set<Map.Entry<Object, Object>> entrySet() {
 			return new AbstractSet<Map.Entry<Object, Object>>() {
 
 				@Override
 				public Iterator<Map.Entry<Object, Object>> iterator() {
 					final Iterator<Map.Entry<Object, Object>> iterator = entries.entrySet().iterator();
 					return new Iterator<Map.Entry<Object, Object>>() {
 
 						@Override
 						public boolean hasNext() {
 							return iterator.hasNext();
 						}
 
 						@Override
 						public Map.Entry<Object, Object> next() {
 							return new LiveSymtabEntry(iterator.next().getKey());
 						}
 
 						@Override
 						public void remove() {
 							if (active) {
 								throw new AwkRuntimeException("Cannot delete an element from SYMTAB.");
 							}
 							iterator.remove();
 						}
 					};
 				}
 
 				@Override
 				public int size() {
 					return entries.size();
 				}
 			};
 		}
 
 		private boolean isMetaTableName(String name) {
 			return "SYMTAB".equals(name) || "FUNCTAB".equals(name);
 		}
 
 		private final class LiveSymtabEntry implements Map.Entry<Object, Object> {
 
 			private final Object key;
 
 			private LiveSymtabEntry(Object key) {
 				this.key = key;
 			}
 
 			@Override
 			public Object getKey() {
 				return key;
 			}
 
 			@Override
 			public Object getValue() {
 				return SymtabArray.this.get(key);
 			}
 
 			@Override
 			public Object setValue(Object value) {
 				return SymtabArray.this.put(key, value);
 			}
 
 			@Override
 			public boolean equals(Object obj) {
 				if (!(obj instanceof Map.Entry)) {
 					return false;
 				}
 				Map.Entry<?, ?> other = (Map.Entry<?, ?>) obj;
 				return Objects.equals(key, other.getKey()) && Objects.equals(getValue(), other.getValue());
 			}
 
 			@Override
 			public int hashCode() {
 				return Objects.hashCode(key) ^ Objects.hashCode(getValue());
 			}
 		}
 	}
 
 	/*
 	 * FUNCTAB is a gawk extension listing the names of the standard built-in
 	 * functions, the program's user-defined functions, and the loaded
 	 * extensions' function keywords. The parser emits UPDATE_FUNCTAB only when
 	 * the script references FUNCTAB outside POSIX mode.
 	 */
 	private void execUpdateFunctab(long offset) {
 		if (runtimeStack.getVariable(offset, true) != null) {
 			return;
 		}
 		Map<Object, Object> functab = newAwkArray();
 		for (String name : BuiltinFunction.names()) {
 			functab.put(name, name);
 		}
 		for (String name : functionNames) {
 			functab.put(name, name);
 		}
 		Set<JawkExtension> seen = new LinkedHashSet<JawkExtension>();
 		for (JawkExtension extension : extensionInstances.values()) {
 			if (seen.add(extension)) {
 				for (String keyword : extension.getExtensionFunctions().keySet()) {
 					functab.put(keyword, keyword);
 				}
 			}
 		}
 		runtimeStack.setVariable(offset, new ReadOnlyArray("FUNCTAB", functab), true);
 	}
 
 	private static final class ReadOnlyArray extends java.util.AbstractMap<Object, Object> implements AssocArray {
 		private final String name;
 		private final Map<Object, Object> entries;
 
 		private ReadOnlyArray(String nameParam, Map<Object, Object> entriesParam) {
 			name = nameParam;
 			entries = entriesParam;
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Object get(Object key) {
 			return JRT.containsAwkKey(entries, key) ? entries.get(key) : BLANK;
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public boolean containsKey(Object key) {
 			return JRT.containsAwkKey(entries, key);
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Set<Map.Entry<Object, Object>> entrySet() {
 			return Collections.unmodifiableMap(entries).entrySet();
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Object put(Object key, Object value) {
 			throw readOnlyError();
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public Object remove(Object key) {
 			throw readOnlyError();
 		}
 
 		/** {@inheritDoc} */
 		@Override
 		public void clear() {
 			throw readOnlyError();
 		}
 
 		private AwkRuntimeException readOnlyError() {
 			return new AwkRuntimeException(name + " is read-only.");
 		}
 	}
 
 	/** Reflects a command-line variable assignment into a materialized SYMTAB. */
 	private void updateSymtabEntry(String name, Object value) {
 		if (symtabOffset == NULL_OFFSET) {
 			return;
 		}
 		Object symtab = runtimeStack.getVariable(symtabOffset, true);
 		if (symtab instanceof SymtabArray) {
 			((SymtabArray) symtab).putRuntimeVariable(name, value);
 		} else if (symtab instanceof Map) {
 			@SuppressWarnings("unchecked")
 			Map<Object, Object> symtabMap = (Map<Object, Object>) symtab;
 			symtabMap.put(name, value);
 		}
 	}
 
 	private void execApplySubsep(CountTuple tuple) {
 		long count = tuple.getCount();
 		if (count == 1) {
 			Object value = pop();
 			checkScalar(value);
 			// An integral number is already in the form the array
 			// implementations canonicalize to a Long key, so it skips the
 			// CONVFMT string round-trip; every other scalar converts to a
 			// string with the CONVFMT currently in effect, fixing the key
 			// from that point on.
 			push(AssocArray.isIntegralNumberKey(value) ? value : jrt.toAwkString(value));
 			return;
 		}
 		StringBuilder sb = new StringBuilder();
 		Object value = pop();
 		checkScalar(value);
 		sb.append(jrt.toAwkString(value));
 		String subsep = jrt.toAwkString(jrt.getSUBSEPVar());
 		for (int i = 1; i < count; i++) {
 			sb.insert(0, subsep);
 			value = pop();
 			checkScalar(value);
 			sb.insert(0, jrt.toAwkString(value));
 		}
 		push(sb.toString());
 	}
 
 	private long beforeProfiledTuple(Tuple tuple, Opcode opcode) {
 		long now = System.nanoTime();
 		if (opcode == Opcode.CALL_FUNCTION) {
 			CallFunctionTuple callTuple = (CallFunctionTuple) tuple;
 			activeProfilingFunctions.push(new ActiveFunction(callTuple.getFunctionName(), now));
 		} else if (opcode == Opcode.EXTENSION) {
 			ExtensionTuple extensionTuple = (ExtensionTuple) tuple;
 			ExtensionFunction function = extensionTuple.getFunction();
 			activeProfilingFunctions.push(new ActiveFunction(function.getKeyword(), now));
 		}
 		return now;
 	}
 
 	private void afterProfiledTuple(Opcode opcode, long tupleStartNanos) {
 		long now = System.nanoTime();
 		statisticsFor(tupleProfilingStats, opcode).add(now - tupleStartNanos);
 		if (opcode == Opcode.EXIT_WITH_CODE || opcode == Opcode.EXIT_WITHOUT_CODE) {
 			recordAllFunctionExits(now);
 		} else if (opcode == Opcode.EXTENSION || opcode == Opcode.RETURN_FROM_FUNCTION) {
 			recordFunctionExit(now);
 		}
 	}
 
 	private static <K> ProfilingReport.Accumulator statisticsFor(
 			Map<K, ProfilingReport.Accumulator> stats,
 			K key) {
 		ProfilingReport.Accumulator accumulator = stats.get(key);
 		if (accumulator == null) {
 			accumulator = new ProfilingReport.Accumulator();
 			stats.put(key, accumulator);
 		}
 		return accumulator;
 	}
 
 	private void recordFunctionExit(long now) {
 		if (activeProfilingFunctions.isEmpty()) {
 			return;
 		}
 		ActiveFunction function = activeProfilingFunctions.pop();
 		statisticsFor(functionProfilingStats, function.name).add(now - function.startNanos);
 	}
 
 	private void recordAllFunctionExits(long now) {
 		while (!activeProfilingFunctions.isEmpty()) {
 			recordFunctionExit(now);
 		}
 	}
 
 	private static final class ActiveFunction {
 		private final String name;
 		private final long startNanos;
 
 		private ActiveFunction(String name, long startNanos) {
 			this.name = name;
 			this.startNanos = startNanos;
 		}
 	}
 
 	/**
 	 * Releases any prepared input source and runtime I/O resources owned by this
 	 * AVM.
 	 * <p>
 	 * Call this when you are done with an AVM obtained through expert-level
 	 * integration, or after direct {@link #eval(AwkExpression, InputSource)} /
 	 * {@link #execute(AwkProgram, InputSource)} usage.
 	 * The AVM may be prepared again afterwards, but callers should treat a closed
 	 * instance as end-of-use unless they intentionally reinitialize it.
 	 * </p>
 	 */
 	@Override
 	public void close() throws IOException {
 		jrt.jrtCloseAll();
 		closeResolvedInputSource();
 		resolvedInputSource = null;
 	}
 
 	/**
 	 * Close the resolved {@link InputSource} if it implements {@link Closeable}.
 	 * This is used by {@link #close()} and by explicit rebind operations such as
 	 * {@link #prepareForEval(InputSource)} when the AVM switches to a different
 	 * source instance.
 	 */
 	private void closeResolvedInputSource() {
 		closeInputSource(resolvedInputSource);
 	}
 
 	private void closeInputSource(InputSource inputSource) {
 		if (!(inputSource instanceof Closeable)) {
 			return;
 		}
 		try {
 			((Closeable) inputSource).close();
 		} catch (IOException ignored) {
 			// Best-effort close.
 		}
 	}
 
 	private Object[] popArguments(long numArgs) {
 		int count = (int) numArgs;
 		Object[] args = new Object[count];
 		operandStackSize -= count;
 		System.arraycopy(operandStack, operandStackSize, args, 0, count);
 		Arrays.fill(operandStack, operandStackSize, operandStackSize + count, null);
 		return args;
 	}
 
 	/**
 	 * sprintf() functionality
 	 */
 	private String sprintfFunction(long numArgs) {
 		Object[] argArray = popArguments(numArgs - 1);
 		String fmt = jrt.toAwkString(pop());
 		return jrt.sprintf(fmt, argArray);
 	}
 
 	private void setNumOnJRT(long fieldNum, Object num) {
 		// same code as ASSIGN_AS_INPUT_FIELD: a field retains the numeric
 		// scalar itself (so an exact integer survives repeated arithmetic),
 		// while $0 is record text and converts with CONVFMT immediately
 		if (fieldNum == 0) {
 			jrt.setInputLine(jrt.toAwkString(num));
 			jrt.jrtParseFields();
 		} else {
 			jrt.jrtSetInputField(num, fieldNum);
 		}
 	}
 
 	private String execSubOrGSub(boolean isGsub) {
 		String newString;
 
 		// stack[0] = original field value
 		// stack[1] = replacement string
 		// stack[2] = ere
 		String orig = jrt.toAwkString(pop());
 		String repl = jrt.toAwkString(pop());
 		String ere = jrt.toAwkString(pop());
 		push(isGsub ? jrt.replaceAll(orig, repl, ere) : jrt.replaceFirst(orig, repl, ere));
 		newString = jrt.getReplaceResult();
 
 		return newString;
 	}
 
 	/**
 	 * Awk variable assignment functionality.
 	 */
 	private void assign(long l, Object value, boolean isGlobal, PositionTracker position, boolean push) {
 		value = JRT.untypedToBlank(value);
 		checkScalar(value);
 		// check if curr value already refers to an array
 		if (resolveVariable(l, isGlobal, false) instanceof Map) {
 			throw new AwkRuntimeException(position.lineNumber(), "Attempting to use an array in a scalar context.");
 		}
 		if (push) {
 			push(value);
 		}
 		runtimeStack.setVariable(l, value, isGlobal);
 		// When specials are compiled correctly, they use ASSIGN_* and skip this path.
 	}
 
 	/**
 	 * Awk array element assignment functionality.
 	 */
 	private void assignArray(long offset, Object arrIdx, Object rhs, boolean isGlobal) {
 		assignMapElement(ensureMapVariable(offset, isGlobal), arrIdx, rhs);
 	}
 
 	private void assignMapElement(Map<Object, Object> array, Object arrIdx, Object rhs) {
 		checkScalar(arrIdx);
 		rhs = JRT.untypedToBlank(rhs);
 		checkScalar(rhs);
 		if (JRT.containsAwkKey(array, arrIdx)
 				&& JRT.getAssocArrayValue(array, arrIdx) instanceof Map) {
 			throw new AwkRuntimeException("Attempting to use an array in a scalar context.");
 		}
 		array.put(arrIdx, rhs);
 		push(rhs);
 	}
 
 	/**
 	 * Numerically increases an Awk variable by one; the result
 	 * is placed back into that variable.
 	 */
 	/**
 	 * Replaces a missing or uninitialized array element by numeric zero, so
 	 * that {@code ++}/{@code --} on it starts from an exact integer, the same
 	 * way {@link #inc(long, boolean)} treats an uninitialized variable.
 	 */
 	private static Object blankToZero(Object o) {
 		return o == null || o instanceof UninitializedObject ? ZERO : o;
 	}
 
 	/**
 	 * Coerces a scalar to its numeric value, keeping an already numeric
 	 * scalar unchanged so an exact integer is not rounded through a double.
 	 */
 	private static Object numericValueOf(Object o) {
 		if (o instanceof Long || o instanceof Integer || o instanceof Double) {
 			return o;
 		}
 		return JRT.toDouble(o);
 	}
 
 	private Object inc(long l, boolean isGlobal) {
 		Object o = resolveVariable(l, isGlobal, false);
 		if (o instanceof UninitializedObject) {
 			o = ZERO;
 			runtimeStack.setVariable(l, o, isGlobal);
 		}
 		Object updated = JRT.inc(o);
 		runtimeStack.setVariable(l, updated, isGlobal);
 		return o;
 	}
 
 	/**
 	 * Numerically decreases an Awk variable by one; the result
 	 * is placed back into that variable.
 	 */
 	private Object dec(long l, boolean isGlobal) {
 		Object o = resolveVariable(l, isGlobal, false);
 		if (o instanceof UninitializedObject) {
 			o = ZERO;
 			runtimeStack.setVariable(l, o, isGlobal);
 		}
 		Object updated = JRT.dec(o);
 		runtimeStack.setVariable(l, updated, isGlobal);
 		return o;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public final Object getRS() {
 		return jrt.getRSVar();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public final Object getOFS() {
 		return jrt.getOFSVar();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public final Object getORS() {
 		return jrt.getORSVar();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public final Object getSUBSEP() {
 		return jrt.getSUBSEPVar();
 	}
 
 	/**
 	 * Returns the names of the global variables declared by the compiled
 	 * program.
 	 *
 	 * @return unmodifiable set of global variable names, empty when no program
 	 *         metadata is installed
 	 */
 	public Set<String> getGlobalVariableNames() {
 		return globalVariableOffsets == null ?
 				Collections.<String>emptySet() : Collections.unmodifiableSet(globalVariableOffsets.keySet());
 	}
 
 	/**
 	 * Returns the names of the user-defined functions of the compiled program.
 	 *
 	 * @return unmodifiable set of function names, empty when no program metadata
 	 *         is installed
 	 */
 	public Set<String> getFunctionNames() {
 		return functionNames == null ? Collections.<String>emptySet() : Collections.unmodifiableSet(functionNames);
 	}
 
 	/**
 	 * The names of the special variables the interpreter answers by name.
 	 * Must stay in sync with the switch in {@link #getVariable(String)}; a
 	 * unit test verifies that every listed name is answered.
 	 */
 	private static final Set<String> SPECIAL_VARIABLE_NAMES = Collections
 			.unmodifiableSet(
 					new LinkedHashSet<String>(
 							Arrays
 									.asList(
 											"FS",
 											"RS",
 											"OFS",
 											"ORS",
 											"FILENAME",
 											"SUBSEP",
 											"CONVFMT",
 											"OFMT",
 											"NF",
 											"NR",
 											"FNR",
 											"RSTART",
 											"RLENGTH",
 											"IGNORECASE",
 											"ERRNO",
 											"ARGIND",
 											"ARGC",
 											"ARGV")));
 
 	/**
 	 * Returns the names of the special variables that
 	 * {@link #getVariable(String)} answers directly.
 	 *
 	 * @return unmodifiable set of special variable names
 	 */
 	public Set<String> getSpecialVariableNames() {
 		return SPECIAL_VARIABLE_NAMES;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public final Object getVariable(String name) {
 		if (name == null) {
 			return null;
 		}
 		switch (name) {
 		case "FS":
 			return getFS();
 		case "RS":
 			return getRS();
 		case "OFS":
 			return getOFS();
 		case "ORS":
 			return getORS();
 		case "FILENAME":
 			return jrt.getFILENAME();
 		case "SUBSEP":
 			return getSUBSEP();
 		case "CONVFMT":
 			return getCONVFMT();
 		case "OFMT":
 			return jrt.getOFMTString();
 		case "NF":
 			return jrt.getNF();
 		case "NR":
 			return jrt.getNR();
 		case "FNR":
 			return jrt.getFNR();
 		case "RSTART":
 			return jrt.getRSTART();
 		case "RLENGTH":
 			return jrt.getRLENGTH();
 		case "IGNORECASE":
 			return jrt.getIGNORECASEVar();
 		case "ERRNO":
 			if (isManagedSpecialVariable(name)) {
 				return jrt.getERRNO();
 			}
 			// POSIX mode: ordinary global, answered by the slot lookup below
 			break;
 		case "ARGIND":
 			if (isManagedSpecialVariable(name)) {
 				return jrt.getARGIND();
 			}
 			// POSIX mode: ordinary global, answered by the slot lookup below
 			break;
 		// lazily-materialized globals answered through their synthetic accessors
 		case "ARGC":
 			return getARGC();
 		case "ARGV":
 			return getARGV();
 		default:
 			break;
 		}
 		if (globalVariableOffsets == null) {
 			return executionInitialVariables.get(name);
 		}
 		Integer offsetObj = globalVariableOffsets.get(name);
 		if (offsetObj != null) {
 			return runtimeStack.getVariable(offsetObj.intValue(), true);
 		}
 		// Variables supplied through -v or the Java API but never referenced in
 		// the script have no compiled offset; they are still observable (e.g.
 		// IGNORECASE read by the gawk extension).
 		return executionInitialVariables == null ? null : executionInitialVariables.get(name);
 	}
 
 	/**
 	 * Returns the description of the primary script source (typically its file
 	 * name), for extension-emitted diagnostics.
 	 *
 	 * @return script source description, or {@code null} when unknown
 	 */
 	public String getSourceDescription() {
 		return sourceDescription;
 	}
 
 	/**
 	 * Returns the script line of the extension call currently being dispatched,
 	 * for extension-emitted diagnostics.
 	 *
 	 * @return current script line number
 	 */
 	public int getCurrentLineNumber() {
 		return currentLineNumber;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public final void assignVariable(String name, Object obj) {
 		// When offsets are not available yet, treat the assignment as part of this
 		// AVM's baseline initial-variable snapshot.
 		if (globalVariableOffsets == null || globalVariableArrays == null) {
 			Object normalized = normalizeExternalVariableValue(obj);
 			baseInitialVariables.put(name, normalized);
 			if (isManagedSpecialVariable(name)) {
 				baseSpecialVariables.put(name, normalized);
 			}
 			return;
 		}
 
 		// make sure we're not receiving funcname=value assignments
 		if (functionNames.contains(name)) {
 			throw new IllegalArgumentException("Cannot assign a scalar to a function name (" + name + ").");
 		}
 
 		Object normalized = normalizeExternalVariableValue(obj);
 		// Runtime assignments to JRT-managed specials (e.g. IGNORECASE=1 or
 		// FS=: between input files) must reach the JRT, not a global slot.
 		// ARGC is excluded: JRT.setARGC delegates back to this method, and its
 		// authoritative storage is the compiled slot below.
 		if (!"ARGC".equals(name) && isManagedSpecialVariable(name)) {
 			jrt.applySpecialVariable(name, normalized);
 			updateSymtabEntry(name, normalized);
 			return;
 		}
 
 		Integer offsetObj = globalVariableOffsets.get(name);
 		Boolean arrayObj = globalVariableArrays.get(name);
 
 		if (offsetObj != null) {
 			if (arrayObj.booleanValue() && !(normalized instanceof Map)) {
 				throw new IllegalArgumentException(
 						"Cannot assign a scalar to a non-scalar variable (" + name + ").");
 			}
 			runtimeStack.setFilelistVariable(offsetObj.intValue(), normalized);
 		} else if (runtimeStack.hasGlobalVariable(name)) {
 			runtimeStack.setGlobalVariable(name, normalized);
 		}
 		// names without a compiled slot are still symbols: keep SYMTAB current
 		updateSymtabEntry(name, normalized);
 	}
 
 	/**
 	 * Executes the {@code nextfile} statement: abandons the current input file
 	 * and resumes the per-file input loop at the appropriate point. The
 	 * runtime and operand stacks are cleared, so {@code nextfile} unwinds
 	 * user-defined function calls, mirroring {@code exit}.
 	 * <p>
 	 * A {@code nextfile} written directly inside a BEGIN, END, or ENDFILE
 	 * rule is already rejected at compile time by the parser. The checks
 	 * below cover the uses reached through user-defined functions, where the
 	 * calling rule cannot be known statically (the same function may be
 	 * called from both an ordinary rule and an END rule); gawk performs the
 	 * same checks at runtime.
 	 * </p>
 	 *
 	 * @param position the tuple position tracker to redirect
 	 */
 	private void executeNextfile(PositionTracker position) {
 		if (nextFileAddress == null || !inputFileLoopStarted) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`nextfile' cannot be called from a BEGIN rule");
 		}
 		if (withinEndBlocks) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`nextfile' cannot be called from an END rule");
 		}
 		if (withinEndFileBlocks) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`nextfile' cannot be called from an ENDFILE rule");
 		}
 		// nextfile can be invoked from user-defined functions: unwind them.
 		resetCallState();
 		if (endFileAddress == null
 				|| withinBeginFileBlocks && jrt.hasPendingInputFileError(resolvedInputSource)) {
 			// No ENDFILE rules to run, or the file could not be opened: skip
 			// the ENDFILE section (gawk BEGINFILE error handling) and go
 			// straight to the next file.
 			withinBeginFileBlocks = false;
 			position.jump(nextFileAddress);
 		} else {
 			withinBeginFileBlocks = false;
 			withinEndFileBlocks = true;
 			position.jump(endFileAddress);
 		}
 	}
 
 	/**
 	 * Executes the {@code next} statement when it is reached through a
 	 * user-defined function call: abandons the current input record and
 	 * resumes the main input loop. The runtime and operand stacks are
 	 * cleared, so {@code next} unwinds user-defined function calls, mirroring
 	 * {@code nextfile}.
 	 * <p>
 	 * A {@code next} written directly inside an input rule compiles to a
 	 * plain jump, and direct uses inside BEGIN, END, BEGINFILE, or ENDFILE
 	 * rules are rejected at compile time by the parser. The checks below
 	 * cover the uses reached through user-defined functions, where the
 	 * calling rule cannot be known statically (the same function may be
 	 * called from both an input rule and a special rule); gawk performs the
 	 * same checks at runtime.
 	 * </p>
 	 *
 	 * @param position the tuple position tracker to redirect
 	 */
 	private void executeNext(PositionTracker position) {
 		if (withinEndBlocks) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`next' cannot be called from a `END' rule");
 		}
 		if (withinBeginFileBlocks) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`next' cannot be called from a `BEGINFILE' rule");
 		}
 		if (withinEndFileBlocks) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`next' cannot be called from a `ENDFILE' rule");
 		}
 		if (nextAddress == null || !mainInputLoopStarted) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"`next' cannot be called from a `BEGIN' rule");
 		}
 		// next can be invoked from user-defined functions: unwind them.
 		resetCallState();
 		position.jump(nextAddress);
 	}
 
 	/**
 	 * Returns whether a non-redirected {@code getline} must be confined to
 	 * the current input file. While the per-file main input loop of a program
 	 * with BEGINFILE/ENDFILE rules is running, only the loop itself may cross
 	 * file boundaries, so that no file's hooks are ever skipped; a
 	 * {@code getline} in an action therefore reports end-of-input at the end
 	 * of the current file. In BEGIN and END rules — before the loop starts or
 	 * after it ends — {@code getline} keeps streaming across the remaining
 	 * input.
 	 *
 	 * @return {@code true} when getline must not advance to the next file
 	 */
 	private boolean isMainInputFileBounded() {
 		return endFileAddress != null && inputFileLoopStarted && !withinEndBlocks;
 	}
 
 	/**
 	 * Raises the gawk-compatible fatal error when a non-redirected
 	 * {@code getline} executes inside a BEGINFILE or ENDFILE rule.
 	 * <p>
 	 * A non-redirected {@code getline} written directly inside a
 	 * BEGINFILE/ENDFILE rule is already rejected at compile time by the
 	 * parser. This runtime check covers the uses reached through
 	 * user-defined functions, where the calling rule cannot be known
 	 * statically; it lives here rather than in {@link JRT} because the
 	 * current-rule flags are interpreter execution state.
 	 * </p>
 	 *
 	 * @param position the tuple position tracker, for error reporting
 	 */
 	private void checkGetlineAllowed(PositionTracker position) {
 		if (withinBeginFileBlocks || withinEndFileBlocks) {
 			throw new AwkRuntimeException(
 					position.lineNumber(),
 					"non-redirected `getline' invalid inside `"
 							+ (withinBeginFileBlocks ? "BEGINFILE" : "ENDFILE")
 							+ "' rule");
 		}
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public Object getFS() {
 		return jrt.getFSVar();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public Object getCONVFMT() {
 		return jrt.getCONVFMTString();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void resetFNR() {
 		jrt.setFNR(0);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void incFNR() {
 		long v = jrt.getFNR();
 		jrt.setFNR(v + 1);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void incNR() {
 		long v = jrt.getNR();
 		jrt.setNR(v + 1);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void setNF(Integer newNf) {
 		jrt.setNF(newNf);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void setFILENAME(String filename) {
 		jrt.setFILENAMEViaJrt(jrt.toInputScalar(filename));
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public Object getARGV() {
 		if (argvOffset == NULL_OFFSET) {
 			Map<Object, Object> argv = newAwkArray();
 			forEachArgvEntry(argv::put);
 			return argv;
 		}
 		return runtimeStack.getVariable(argvOffset, true);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public Object getARGC() {
 		if (argcOffset == NULL_OFFSET) {
 			return Long.valueOf(arguments.size() + 1);
 		}
 		return runtimeStack.getVariable(argcOffset, true);
 	}
 
 	private String getOFMT() {
 		return jrt.getOFMTString();
 	}
 
 	private Map<Object, Object> newAwkArray() {
 		return JRT.createAwkMap(sortedArrayKeys);
 	}
 
 	private Map<Object, Object> ensureMapVariable(long offset, boolean isGlobal) {
 		return toMap(resolveVariable(offset, isGlobal, true));
 	}
 
 	private Map<Object, Object> getMapVariable(long offset, boolean isGlobal) {
 		return toMap(resolveVariable(offset, isGlobal, true));
 	}
 
 	private Object resolveVariable(long offset, boolean isGlobal, boolean arrayContext) {
 		Object value = runtimeStack.getVariable(offset, isGlobal);
 		// Argument references are only ever stored in local parameter slots,
 		// so global reads skip the reference check entirely.
 		if (!isGlobal && value instanceof ArgumentReference) {
 			value = resolveArgumentReference((ArgumentReference) value, arrayContext);
 			runtimeStack.setVariable(offset, value, isGlobal);
 			return value;
 		}
 		if (!isUntyped(value)) {
 			return value;
 		}
 		value = arrayContext ? newAwkArray() : BLANK;
 		runtimeStack.setVariable(offset, value, isGlobal);
 		return value;
 	}
 
 	private Object resolveRawArgumentReference(ArgumentReference reference) {
 		Object currentValue = readCurrentArgumentValue(reference);
 		if (currentValue instanceof Map
 				|| currentValue instanceof UninitializedObject
 						&& !(currentValue instanceof UntypedObject)) {
 			return currentValue;
 		}
 		Object value = reference.snapshot();
 		return value instanceof ArgumentReference ?
 				resolveRawArgumentReference((ArgumentReference) value) : value;
 	}
 
 	private Object readCurrentArgumentValue(ArgumentReference reference) {
 		Object value = reference.currentValue();
 		return value instanceof ArgumentReference ?
 				readCurrentArgumentValue((ArgumentReference) value) : value;
 	}
 
 	private Object resolveArgumentReference(ArgumentReference reference, boolean arrayContext) {
 		if (!arrayContext) {
 			checkScalar(readCurrentArgumentValue(reference));
 		}
 		Object value = arrayContext ? reference.currentValue() : reference.snapshot();
 		if (value instanceof ArgumentReference) {
 			value = resolveArgumentReference((ArgumentReference) value, arrayContext);
 			if (arrayContext) {
 				reference.setValue(value);
 			} else {
 				reference.setScalarValue(value);
 			}
 			return value;
 		}
 		if (!isUntyped(value)) {
 			return value;
 		}
 		value = arrayContext ? newAwkArray() : BLANK;
 		if (arrayContext) {
 			reference.setValue(value);
 		} else {
 			reference.setScalarValue(value);
 		}
 		return value;
 	}
 
 	private Object resolveLengthArgumentReference(ArgumentReference reference) {
 		Object currentValue = readCurrentArgumentValue(reference);
 		return currentValue instanceof Map ? currentValue : resolveArgumentReference(reference, false);
 	}
 
 	private Map<IndirectArrayArgumentReference, Object> captureAttachedArrayArgumentValues() {
 		if (elementArgumentReferences.isEmpty()) {
 			return Collections.emptyMap();
 		}
 		Map<IndirectArrayArgumentReference, Object> values = new IdentityHashMap<IndirectArrayArgumentReference, Object>();
 		for (IndirectArrayArgumentReference reference : elementArgumentReferences) {
 			if (reference.isAttached()) {
 				values.put(reference, reference.currentValue());
 			}
 		}
 		return values;
 	}
 
 	private void detachReplacedArrayArgumentReferences(
 			Map<IndirectArrayArgumentReference, Object> attachedValues) {
 		for (Map.Entry<IndirectArrayArgumentReference, Object> entry : attachedValues.entrySet()) {
 			entry.getKey().detachIfReplaced(entry.getValue());
 		}
 	}
 
 	private void detachMissingArrayArgumentReferences(Map<Object, Object> map) {
 		if (elementArgumentReferences.isEmpty()) {
 			return;
 		}
 		for (IndirectArrayArgumentReference reference : elementArgumentReferences) {
 			reference.detachIfMissing(map);
 		}
 	}
 
 	private static boolean isUntyped(Object value) {
 		return value == null || value instanceof UntypedObject;
 	}
 
 	/**
 	 * Casts an AWK value to an associative array.
 	 *
 	 * @param value value to validate
 	 * @return the associative array value
 	 * @throws AwkRuntimeException when {@code value} is scalar
 	 */
 	private Map<Object, Object> toMap(Object value) {
 		if (!(value instanceof Map)) {
 			throw new AwkRuntimeException("Attempting to use a scalar as an array.");
 		}
 		@SuppressWarnings("unchecked")
 		Map<Object, Object> map = (Map<Object, Object>) value;
 		return map;
 	}
 
 	/**
 	 * Ensures a value is scalar before using it in a scalar-only context such as
 	 * a subscript component.
 	 *
 	 * @param value value to validate
 	 * @throws AwkRuntimeException when {@code value} is an array
 	 */
 	private void checkScalar(Object value) {
 		if (value instanceof Map) {
 			throw new AwkRuntimeException("Attempting to use an array in a scalar context.");
 		}
 	}
 
 	/**
 	 * Returns the nested associative array stored in {@code map[key]}, creating it
 	 * when the key is undefined.
 	 *
 	 * @param map containing array
 	 * @param key nested-array key
 	 * @return the nested associative array stored at {@code key}
 	 * @throws AwkRuntimeException when {@code key} is scalar-incompatible or when
 	 *         the existing slot contains a scalar
 	 */
 	private Map<Object, Object> ensureArrayInArray(Map<Object, Object> map, Object key) {
 		checkScalar(key);
 		boolean existingKey = JRT.containsAwkKey(map, key);
 		Object value = JRT.getAssocArrayValue(map, key);
 		if (!existingKey || value == null || value instanceof UntypedObject) {
 			Map<Object, Object> nested = newAwkArray();
 			map.put(key, nested);
 			return nested;
 		}
 		if (!(value instanceof Map)) {
 			throw new AwkRuntimeException("Attempting to use a scalar as an array.");
 		}
 		@SuppressWarnings("unchecked")
 		Map<Object, Object> nested = (Map<Object, Object>) value;
 		return nested;
 	}
 
 	private Object normalizeExternalVariableValue(Object value) {
 		if (value instanceof String) {
 			return jrt.toInputScalar(value);
 		}
 		if (!(value instanceof Map) && !(value instanceof List)) {
 			return value;
 		}
 		return AssocArray.normalizeValue(value, sortedArrayKeys);
 	}
 
 	private static final UninitializedObject BLANK = new UninitializedObject();
 
 	private interface ArgumentReference {
 
 		Object snapshot();
 
 		Object currentValue();
 
 		void setValue(Object value);
 
 		void setScalarValue(Object value);
 	}
 
 	private static final class IndirectArgumentReference implements ArgumentReference {
 		private final Object[] frame;
 		private final long offset;
 		private final Object scalarValue;
 
 		private IndirectArgumentReference(Object[] frameParam, long offsetParam, Object scalarValueParam) {
 			frame = frameParam;
 			offset = offsetParam;
 			scalarValue = scalarValueParam;
 		}
 
 		@Override
 		public Object snapshot() {
 			return scalarValue;
 		}
 
 		@Override
 		public Object currentValue() {
 			return frame[(int) offset];
 		}
 
 		@Override
 		public void setValue(Object value) {
 			frame[(int) offset] = value;
 		}
 
 		@Override
 		public void setScalarValue(Object value) {
 			if (isUntyped(currentValue())) {
 				setValue(value);
 			}
 		}
 	}
 
 	private static final class IndirectArrayArgumentReference implements ArgumentReference {
 		private final Map<Object, Object> map;
 		private final Object key;
 		private Object detachedValue;
 		private boolean detached;
 		// Depth of the call frame that received this reference as an
 		// argument; negative until the call is entered.
 		private int ownerFrame = -1;
 
 		private IndirectArrayArgumentReference(
 				Map<Object, Object> mapParam,
 				Object keyParam,
 				Object scalarValueParam) {
 			map = mapParam;
 			key = keyParam;
 			detachedValue = scalarValueParam;
 			detached = !JRT.containsAwkKey(map, key);
 		}
 
 		@Override
 		public Object snapshot() {
 			return detachedValue;
 		}
 
 		@Override
 		public Object currentValue() {
 			return !detached && JRT.containsAwkKey(map, key) ?
 					JRT.getAssocArrayValue(map, key) : detachedValue;
 		}
 
 		@Override
 		public void setValue(Object value) {
 			if (!detached && JRT.containsAwkKey(map, key)) {
 				map.put(key, value);
 			} else {
 				detachedValue = value;
 			}
 		}
 
 		@Override
 		public void setScalarValue(Object value) {
 			if (detached || !JRT.containsAwkKey(map, key)) {
 				detachedValue = value;
 			} else if (isUntyped(JRT.getAssocArrayValue(map, key))) {
 				map.put(key, value);
 			}
 		}
 
 		private void detachIfMissing(Map<Object, Object> candidateMap) {
 			if (!detached && map == candidateMap && !JRT.containsAwkKey(map, key)) {
 				detached = true;
 			}
 		}
 
 		private boolean isAttached() {
 			return !detached && JRT.containsAwkKey(map, key);
 		}
 
 		private void detachIfReplaced(Object previousValue) {
 			if (!detached
 					&& (!JRT.containsAwkKey(map, key)
 							|| JRT.getAssocArrayValue(map, key) != previousValue)) {
 				detached = true;
 			}
 		}
 	}
 
 	/**
 	 * Global names that must not participate in persistent memory even though they
 	 * are technically user-visible variables.
 	 */
 	private static final Set<String> NON_PERSISTENT_GLOBALS = new HashSet<>(
 			Arrays
 					.asList(
 							"ARGV",
 							"ARGC",
 							"ENVIRON",
 							"RSTART",
 							"RLENGTH",
 							"IGNORECASE",
 							"SYMTAB",
 							"FUNCTAB"));
 
 	private static final class SingleRecordInputSource implements InputSource {
 
 		private final String record;
 		private boolean consumed;
 
 		private SingleRecordInputSource(String record) {
 			this.record = record;
 		}
 
 		@Override
 		public boolean nextRecord() {
 			if (consumed || record == null) {
 				return false;
 			}
 			consumed = true;
 			return true;
 		}
 
 		@Override
 		public String getRecordText() {
 			return consumed ? record : null;
 		}
 
 		@Override
 		public List<String> getFields() {
 			return null;
 		}
 
 		@Override
 		public boolean isFromFilenameList() {
 			return false;
 		}
 	}
 
 	/**
 	 * The value of an address which is not yet assigned a tuple index.
 	 */
 	public static final int NULL_OFFSET = -1;
 
 }