/src/moddable/xs/sources/xsRun.c

Source
/*
 * Copyright (c) 2016-2025  Moddable Tech, Inc.
 *
 *   This file is part of the Moddable SDK Runtime.
 * 
 *   The Moddable SDK Runtime 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.
 * 
 *   The Moddable SDK Runtime 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 Lesser General Public License for more details.
 * 
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
 *
 * This file incorporates work covered by the following copyright and  
 * permission notice:  
 *
 *       Copyright (C) 2010-2016 Marvell International Ltd.
 *       Copyright (C) 2002-2010 Kinoma, Inc.
 *
 *       Licensed under the Apache License, Version 2.0 (the "License");
 *       you may not use this file except in compliance with the License.
 *       You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *       Unless required by applicable law or agreed to in writing, software
 *       distributed under the License is distributed on an "AS IS" BASIS,
 *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *       See the License for the specific language governing permissions and
 *       limitations under the License.
 */

#include "xsAll.h"

//#define mxTrace 1
//#define mxTraceCall 1

#define c_iszero(NUMBER) (C_FP_ZERO == c_fpclassify(NUMBER))

static void fxRunArguments(txMachine* the, txIndex offset);
static void fxRunBase(txMachine* the);
static void fxRunConstructor(txMachine* the);
static txBoolean fxRunDefine(txMachine* the, txSlot* instance, txSlot* check, txID id, txIndex index, txSlot* slot, txFlag mask);
static txBoolean fxRunDelete(txMachine* the, txSlot* instance, txID id, txIndex index);
static void fxRunDerived(txMachine* the);
static void fxRunExtends(txMachine* the);
static void fxRunForOf(txMachine* the);
static txBoolean fxRunHas(txMachine* the, txSlot* instance, txID id, txIndex index);
static void fxRunIn(txMachine* the);
static void fxRunInstantiate(txMachine* the);
static void fxRunProxy(txMachine* the, txSlot* instance);
static void fxRunInstanceOf(txMachine* the);
static void fxRunUsed(txMachine* the, txSlot* selector);
static void fxRunUsing(txMachine* the);
static void fxRunUsingAsync(txMachine* the);
static txBoolean fxIsScopableSlot(txMachine* the, txSlot* instance, txID id);
static txBoolean fxToNumericInteger(txMachine* the, txSlot* theSlot);
static txBoolean fxToNumericIntegerUnary(txMachine* the, txSlot* theSlot, txBigIntUnary op);
static txBoolean fxToNumericIntegerBinary(txMachine* the, txSlot* a, txSlot* b, txBigIntBinary op);
static txBoolean fxToNumericNumber(txMachine* the, txSlot* theSlot);
static txBoolean fxToNumericNumberUnary(txMachine* the, txSlot* theSlot, txBigIntUnary op);
static txBoolean fxToNumericNumberBinary(txMachine* the, txSlot* a, txSlot* b, txBigIntBinary op);

#if defined(__GNUC__) && defined(__OPTIMIZE__)
  #if defined(mxFrequency)
    #define mxBreak \
      the->frequencies[byte]++; \
      goto *bytes[byte]
  #elif defined(mxTrace)
    #define mxBreak \
      if (gxDoTrace) fxTraceCode(the, stack, byte); \
      goto *bytes[byte]
  #elif defined(mxMetering)
    #define mxBreak \
      the->meterIndex += XS_CODE_METERING; \
      goto *bytes[byte]
  #else
    #define mxBreak \
      goto *bytes[byte]
  #endif
  #define mxCase(OPCODE) OPCODE:
  #define mxSwitch(OPCODE) mxBreak;
#else
  #define mxBreak \
    break
  #define mxCase(OPCODE) \
    case OPCODE:
  #if defined(mxFrequency)
    #define mxSwitch(OPCODE) \
      the->frequencies[OPCODE]++; \
      switch(OPCODE)
  #else
    #define mxSwitch(OPCODE) \
      switch(OPCODE)
  #endif
#endif

#define mxCode code
#define mxFrame frame
#define mxEnvironment environment
#define mxScope scope
#define mxStack stack

#define mxFrameEnd (mxFrame + ((mxFrame->flag & XS_TARGET_FLAG) ? 5 : 4))
#define mxFrameThis (mxFrame + 3)
#define mxFrameFunction (mxFrame + 2)
#define mxFrameResult (mxFrame + 1)
#define mxFrameTarget (mxFrame + 4)
#define mxFrameHasTarget (mxFrame->flag & XS_TARGET_FLAG)
#define mxFrameArgc ((txInteger)(mxFrame->ID))
#define mxFrameArgv(THE_INDEX) (mxFrame - 1 - (THE_INDEX))

#define mxRestoreState { \
  mxStack = the->stack; \
  mxScope = the->scope; \
  mxFrame = the->frame; \
  mxEnvironment = mxFrameToEnvironment(mxFrame); \
  mxCode = the->code; \
}
#define mxRestoreStateKeepStack { \
  mxScope = the->scope; \
  mxFrame = the->frame; \
  mxEnvironment = mxFrameToEnvironment(mxFrame); \
  mxCode = the->code; \
}
#if defined(mxFrequency)
  #define mxSaveState { \
    the->exits[byte]++; \
    the->stack = mxStack; \
    the->scope = mxScope; \
    the->frame = mxFrame; \
    the->code = mxCode; \
  }
  #define mxSaveStateKeepStack { \
    the->exits[byte]++; \
    the->scope = mxScope; \
    the->frame = mxFrame; \
    the->code = mxCode; \
  }
#else
  #define mxSaveState { \
    the->stack = mxStack; \
    the->scope = mxScope; \
    the->frame = mxFrame; \
    the->code = mxCode; \
  }
  #define mxSaveStateKeepStack { \
    the->scope = mxScope; \
    the->frame = mxFrame; \
    the->code = mxCode; \
  }
#endif

#if mxBoundsCheck
#define mxAllocStack(_COUNT) \
  if ((mxStack - _COUNT) < the->stackBottom) \
    goto STACK_OVERFLOW; \
  mxStack -= _COUNT
#else
#define mxAllocStack(_COUNT) \
  mxStack -= _COUNT
#endif

#define mxPushKind(_KIND) { \
  mxAllocStack(1); \
  mxStack->next = C_NULL;  \
  mxInitSlotKind(mxStack, _KIND); \
}

#define mxRunDebug(_ERROR, ...) { \
  mxSaveState; \
  fxThrowMessage(the, NULL, 0, _ERROR, __VA_ARGS__); \
}

#define mxRunDebugID(_ERROR, _MESSAGE, _ID) { \
  mxSaveState; \
  fxIDToString(the, _ID, the->nameBuffer, sizeof(the->nameBuffer)); \
  fxThrowMessage(the, NULL, 0, _ERROR, _MESSAGE, the->nameBuffer); \
}

#define mxToBoolean(SLOT) \
  if (XS_BOOLEAN_KIND != (SLOT)->kind) { \
    if (XS_SYMBOL_KIND <= (SLOT)->kind) { \
      mxSaveState; \
      fxToBoolean(the, SLOT); \
      mxRestoreState; \
    } \
    else \
      fxToBoolean(the, SLOT); \
  }

#define mxToInteger(SLOT) \
  if (XS_INTEGER_KIND != (SLOT)->kind) { \
    if (XS_STRING_KIND <= (SLOT)->kind) { \
      mxSaveState; \
      fxToInteger(the, SLOT); \
      mxRestoreState; \
    } \
    else \
      fxToInteger(the, SLOT); \
  }
  
#define mxToNumber(SLOT) \
  if (XS_NUMBER_KIND != (SLOT)->kind) { \
    if (XS_STRING_KIND <= (SLOT)->kind) { \
      mxSaveState; \
      fxToNumber(the, SLOT); \
      mxRestoreState; \
    } \
    else \
      fxToNumber(the, SLOT); \
  }
  
#define mxToString(SLOT) \
  if ((XS_STRING_KIND != (SLOT)->kind) && (XS_STRING_X_KIND != (SLOT)->kind)) { \
    mxSaveState; \
    fxToString(the, SLOT); \
    mxRestoreState; \
  }
  
#define mxToInstance(SLOT) \
  if (XS_REFERENCE_KIND != (SLOT)->kind) { \
    mxSaveState; \
    variable = fxToInstance(the, SLOT); \
    mxRestoreState; \
    primitive = 1; \
  } \
  else { \
    variable = (SLOT)->value.reference; \
    primitive = 0; \
  }

#ifndef mxUnalignedAccess
  #define mxUnalignedAccess 1
#endif

#define mxRunS1(OFFSET) ((txS1*)mxCode)[OFFSET]
#define mxRunU1(OFFSET) ((txU1*)mxCode)[OFFSET]
#if mxBigEndian
  #define mxRunS2(OFFSET) (((txS1*)mxCode)[OFFSET+0] << 8) | ((txU1*)mxCode)[OFFSET+1]
  #define mxRunS4(OFFSET) (((txS1*)mxCode)[OFFSET+0] << 24) | (((txU1*)mxCode)[OFFSET+1] << 16) | (((txU1*)mxCode)[OFFSET+2] << 8) | ((txU1*)mxCode)[OFFSET+3]
  #define mxRunU2(OFFSET) (((txU1*)mxCode)[OFFSET+0] << 8) | ((txU1*)mxCode)[OFFSET+1]
#else
  #if mxUnalignedAccess
    #define mxRunS2(OFFSET) *((txS2*)(mxCode + OFFSET))
    #define mxRunS4(OFFSET) *((txS4*)(mxCode + OFFSET))
    #define mxRunU2(OFFSET) *((txU2*)(mxCode + OFFSET))
  #else 
    #define mxRunS2(OFFSET) (((txS1*)mxCode)[OFFSET+1] << 8) | ((txU1*)mxCode)[OFFSET+0]
    #define mxRunS4(OFFSET) (((txS1*)mxCode)[OFFSET+3] << 24) | (((txU1*)mxCode)[OFFSET+2] << 16) | (((txU1*)mxCode)[OFFSET+1] << 8) | ((txU1*)mxCode)[OFFSET+0]
    #define mxRunU2(OFFSET) (((txU1*)mxCode)[OFFSET+1] << 8) | ((txU1*)mxCode)[OFFSET+0]
  #endif
#endif
#ifdef mx32bitID
  #define mxRunID(OFFSET) mxRunS4(OFFSET)
#else
  #define mxRunID(OFFSET) mxRunS2(OFFSET)
#endif

#define mxNextCode(OFFSET) { \
  mxCode += OFFSET; \
  byte = *((txU1*)mxCode); \
}
#define mxSkipCode(OFFSET) { \
  mxCode += OFFSET; \
}

#ifdef mxMetering
  #define mxCheckMeter() \
    if (the->meterInterval && (the->meterIndex > the->meterCount)) { \
      mxSaveState; \
      fxCheckMetering(the); \
      mxRestoreState; \
    }
  #define mxBranch(INDEX, OFFSET) \
    if ((OFFSET) < 0) { \
      mxCheckMeter(); \
    } \
    mxNextCode((txS4)INDEX + OFFSET)
  #define mxBranchElse(TEST, INDEX, OFFSET) \
    if (TEST) { \
      mxNextCode((txS4)INDEX); \
    } \
    else { \
      mxBranch(INDEX, OFFSET); \
    }
  #define mxBranchIf(TEST, INDEX, OFFSET) \
    if (TEST) { \
      mxBranch(INDEX, OFFSET); \
    } \
    else { \
      mxNextCode((txS4)index); \
    }
  #define mxFirstCode() \
    mxCheckMeter(); \
    byte = *((txU1*)mxCode)
#else
  #define mxBranch(INDEX, OFFSET) \
    mxNextCode((txS4)INDEX + OFFSET)
  #define mxBranchElse(TEST, INDEX, OFFSET) \
    mxNextCode((TEST) ? (txS4)INDEX : (txS4)INDEX + OFFSET)
  #define mxBranchIf(TEST, INDEX, OFFSET) \
    mxNextCode((TEST) ? (txS4)INDEX + OFFSET : (txS4)INDEX)
  #define mxFirstCode() \
    byte = *((txU1*)mxCode)
#endif

#ifdef mxTrace
short gxDoTrace = 1;

#ifdef mxMetering
static void fxTraceCode(txMachine* the, txSlot* stack, txU1 theCode) 
{
  if (((XS_NO_CODE < theCode) && (theCode < XS_CODE_COUNT)))
    fprintf(stderr, "\n%u %ld: %s", the->meterIndex, the->stackTop - stack, gxCodeNames[theCode]);
  else
    fprintf(stderr, "\n%u %ld: ?", the->meterIndex, the->stackTop - stack);
}
#else
static void fxTraceCode(txMachine* the, txSlot* stack, txU1 theCode) 
{
  if (((XS_NO_CODE < theCode) && (theCode < XS_CODE_COUNT)))
    fprintf(stderr, "\n%ld: %s", (long int)(the->stackTop - stack), gxCodeNames[theCode]);
  else
    fprintf(stderr, "\n%ld: ?", (long int)(the->stackTop - stack));
}
#endif

static void fxTraceID(txMachine* the, txID id, txIndex index) 
{
  if (id) {
    char* key = fxGetKeyName(the, id);
    if (key)
      fprintf(stderr, " [%s]", key);
    else
      fprintf(stderr, " [?]");
  }
  else
    fprintf(stderr, " [%d]", (int)index);
}

static void fxTraceIndex(txMachine* the, txU2 theIndex) 
{
  fprintf(stderr, " %d", theIndex);
}

static void fxTraceInteger(txMachine* the, txInteger theInteger) 
{
  fprintf(stderr, " %ld", (long)theInteger);
}

static void fxTraceNumber(txMachine* the, txNumber theNumber) 
{
  fprintf(stderr, " %lf", theNumber);
}

static void fxTraceReturn(txMachine* the) 
{
  fprintf(stderr, "\n");
}

static void fxTraceString(txMachine* the, txString theString) 
{
  fprintf(stderr, " \"%s\"", theString);
}
#endif

#ifdef mxTraceCall
int gxTraceCall = 0;
static int depth = 0;
static void fxTraceCallBegin(txMachine* the, txSlot* function)
{
  if (gxTraceCall) {
    txSlot* slot = mxBehaviorGetProperty(the, function->value.reference, mxID(_name), 0, XS_ANY);
    int i;
    for (i = 0; i < depth; i++)
      fprintf(stderr, "\t");
    if (slot && ((slot->kind == XS_STRING_KIND) ||  (slot->kind == XS_STRING_X_KIND)))
      fprintf(stderr, " [%s]\n", slot->value.string);
    else
      fprintf(stderr, " [?]\n");
    depth++;
  }
}
static void fxTraceCallEnd(txMachine* the, txSlot* function)
{
  if (gxTraceCall) {
    depth--;
    if (depth < 0)
      depth = 0;
  }
}
#endif

#if defined(mxInstrument) && !defined(mxDebug)
static void fxTraceException(txMachine *the)
{
#ifndef mxNoConsole
  if (XS_REFERENCE_KIND == mxException.kind) {
    txSlot* internal = mxException.value.reference->next;
    if (internal && (internal->kind == XS_ERROR_KIND)) {
      txSlot* msg = internal->next;
      if (msg && ((msg->kind == XS_STRING_KIND) || (msg->kind == XS_STRING_X_KIND)))
        c_printf("Exception %s: %s\n", gxErrorNames[internal->value.error.which], msg->value.string);
      else
        c_printf("Exception %s\n", gxErrorNames[internal->value.error.which]);
    }
  }
  else
    c_printf("Exception\n");
#endif
}
#endif

void fxRunID(txMachine* the, txSlot* generator, txInteger count)
{
  register txSlot* stack = the->stack;
  register txSlot* scope = the->scope;
  register txSlot* frame = the->frame;
  register txSlot* environment;
  register txByte* code = the->code;
  register txSlot* variable;
  register txSlot* slot;
  register txU1 byte = 0;
  register txU4 index;
  register txS4 offset;
  txU1 primitive = 0;
  txU1 ignore = 0;
#if defined(__GNUC__) && defined(__OPTIMIZE__)
  static void *const
  #if !defined(__ets__) || ESP32
    ICACHE_RAM_ATTR
  #endif
    gxBytes[] = {
    &&XS_NO_CODE,
    &&XS_CODE_ADD,
    &&XS_CODE_ARGUMENT,
    &&XS_CODE_ARGUMENTS,
    &&XS_CODE_ARGUMENTS_SLOPPY,
    &&XS_CODE_ARGUMENTS_STRICT,
    &&XS_CODE_ARRAY,
    &&XS_CODE_ASYNC_FUNCTION,
    &&XS_CODE_ASYNC_GENERATOR_FUNCTION,
    &&XS_CODE_AT,
    &&XS_CODE_AWAIT,
    &&XS_CODE_BEGIN_SLOPPY,
    &&XS_CODE_BEGIN_STRICT,
    &&XS_CODE_BEGIN_STRICT_BASE,
    &&XS_CODE_BEGIN_STRICT_DERIVED,
    &&XS_CODE_BEGIN_STRICT_FIELD,
    &&XS_CODE_BIGINT_1,
    &&XS_CODE_BIGINT_2,
    &&XS_CODE_BIT_AND,
    &&XS_CODE_BIT_NOT,
    &&XS_CODE_BIT_OR,
    &&XS_CODE_BIT_XOR,
    &&XS_CODE_BRANCH_1,
    &&XS_CODE_BRANCH_2,
    &&XS_CODE_BRANCH_4,
    &&XS_CODE_BRANCH_CHAIN_1,
    &&XS_CODE_BRANCH_CHAIN_2,
    &&XS_CODE_BRANCH_CHAIN_4,
    &&XS_CODE_BRANCH_COALESCE_1,
    &&XS_CODE_BRANCH_COALESCE_2,
    &&XS_CODE_BRANCH_COALESCE_4,
    &&XS_CODE_BRANCH_ELSE_1,
    &&XS_CODE_BRANCH_ELSE_2,
    &&XS_CODE_BRANCH_ELSE_4,
    &&XS_CODE_BRANCH_IF_1,
    &&XS_CODE_BRANCH_IF_2,
    &&XS_CODE_BRANCH_IF_4,
    &&XS_CODE_BRANCH_STATUS_1,
    &&XS_CODE_BRANCH_STATUS_2,
    &&XS_CODE_BRANCH_STATUS_4,
    &&XS_CODE_CALL,
    &&XS_CODE_CATCH_1,
    &&XS_CODE_CATCH_2,
    &&XS_CODE_CATCH_4,
    &&XS_CODE_CHECK_INSTANCE,
    &&XS_CODE_CLASS,
    &&XS_CODE_CODE_1,
    &&XS_CODE_CODE_2,
    &&XS_CODE_CODE_4,
    &&XS_CODE_CODE_ARCHIVE_1,
    &&XS_CODE_CODE_ARCHIVE_2,
    &&XS_CODE_CODE_ARCHIVE_4,
    &&XS_CODE_CONST_CLOSURE_1,
    &&XS_CODE_CONST_CLOSURE_2,
    &&XS_CODE_CONST_LOCAL_1,
    &&XS_CODE_CONST_LOCAL_2,
    &&XS_CODE_CONSTRUCTOR_FUNCTION,
    &&XS_CODE_COPY_OBJECT,
    &&XS_CODE_CURRENT,
    &&XS_CODE_DEBUGGER,
    &&XS_CODE_DECREMENT,
    &&XS_CODE_DELETE_PROPERTY,
    &&XS_CODE_DELETE_PROPERTY_AT,
    &&XS_CODE_DELETE_SUPER,
    &&XS_CODE_DELETE_SUPER_AT,
    &&XS_CODE_DIVIDE,
    &&XS_CODE_DUB,
    &&XS_CODE_DUB_AT,
    &&XS_CODE_END,
    &&XS_CODE_END_ARROW,
    &&XS_CODE_END_BASE,
    &&XS_CODE_END_DERIVED,
    &&XS_CODE_ENVIRONMENT,
    &&XS_CODE_EQUAL,
    &&XS_CODE_EVAL,
    &&XS_CODE_EVAL_ENVIRONMENT,
    &&XS_CODE_EVAL_PRIVATE,
    &&XS_CODE_EVAL_REFERENCE,
    &&XS_CODE_EVAL_TAIL,
    &&XS_CODE_EXCEPTION,
    &&XS_CODE_EXPONENTIATION,
    &&XS_CODE_EXTEND,
    &&XS_CODE_FALSE,
    &&XS_CODE_FILE,
    &&XS_CODE_FOR_AWAIT_OF,
    &&XS_CODE_FOR_IN,
    &&XS_CODE_FOR_OF,
    &&XS_CODE_FUNCTION,
    &&XS_CODE_FUNCTION_ENVIRONMENT,
    &&XS_CODE_GENERATOR_FUNCTION,
    &&XS_CODE_GET_CLOSURE_1,
    &&XS_CODE_GET_CLOSURE_2,
    &&XS_CODE_GET_LOCAL_1,
    &&XS_CODE_GET_LOCAL_2,
    &&XS_CODE_GET_PRIVATE_1,
    &&XS_CODE_GET_PRIVATE_2,
    &&XS_CODE_GET_PROPERTY,
    &&XS_CODE_GET_PROPERTY_AT,
    &&XS_CODE_GET_RESULT,
    &&XS_CODE_GET_SUPER,
    &&XS_CODE_GET_SUPER_AT,
    &&XS_CODE_GET_THIS,
    &&XS_CODE_GET_VARIABLE,
    &&XS_CODE_GET_THIS_VARIABLE,
    &&XS_CODE_GLOBAL,
    &&XS_CODE_HAS_PRIVATE_1,
    &&XS_CODE_HAS_PRIVATE_2,
    &&XS_CODE_HOST,
    &&XS_CODE_IMPORT,
    &&XS_CODE_IMPORT_META,
    &&XS_CODE_IN,
    &&XS_CODE_INCREMENT,
    &&XS_CODE_INSTANCEOF,
    &&XS_CODE_INSTANTIATE,
    &&XS_CODE_INTEGER_1,
    &&XS_CODE_INTEGER_2,
    &&XS_CODE_INTEGER_4,
    &&XS_CODE_LEFT_SHIFT,
    &&XS_CODE_LESS,
    &&XS_CODE_LESS_EQUAL,
    &&XS_CODE_LET_CLOSURE_1,
    &&XS_CODE_LET_CLOSURE_2,
    &&XS_CODE_LET_LOCAL_1,
    &&XS_CODE_LET_LOCAL_2,
    &&XS_CODE_LINE,
    &&XS_CODE_MINUS,
    &&XS_CODE_MODULE,
    &&XS_CODE_MODULO,
    &&XS_CODE_MORE,
    &&XS_CODE_MORE_EQUAL,
    &&XS_CODE_MULTIPLY,
    &&XS_CODE_NAME,
    &&XS_CODE_NEW,
    &&XS_CODE_NEW_CLOSURE,
    &&XS_CODE_NEW_LOCAL,
    &&XS_CODE_NEW_PRIVATE_1,
    &&XS_CODE_NEW_PRIVATE_2,
    &&XS_CODE_NEW_PROPERTY,
    &&XS_CODE_NEW_PROPERTY_AT,
    &&XS_CODE_NEW_TEMPORARY,
    &&XS_CODE_NOT,
    &&XS_CODE_NOT_EQUAL,
    &&XS_CODE_NULL,
    &&XS_CODE_NUMBER,
    &&XS_CODE_OBJECT,
    &&XS_CODE_PLUS,
    &&XS_CODE_POP,
    &&XS_CODE_PROGRAM_ENVIRONMENT,
    &&XS_CODE_PROGRAM_REFERENCE,
    &&XS_CODE_PULL_CLOSURE_1,
    &&XS_CODE_PULL_CLOSURE_2,
    &&XS_CODE_PULL_LOCAL_1,
    &&XS_CODE_PULL_LOCAL_2,
    &&XS_CODE_REFRESH_CLOSURE_1,
    &&XS_CODE_REFRESH_CLOSURE_2,
    &&XS_CODE_REFRESH_LOCAL_1,
    &&XS_CODE_REFRESH_LOCAL_2,
    &&XS_CODE_REGEXP,
    &&XS_CODE_RESERVE_1,
    &&XS_CODE_RESERVE_2,
    &&XS_CODE_RESET_CLOSURE_1,
    &&XS_CODE_RESET_CLOSURE_2,
    &&XS_CODE_RESET_LOCAL_1,
    &&XS_CODE_RESET_LOCAL_2,
    &&XS_CODE_RETHROW,
    &&XS_CODE_RETRIEVE_1,
    &&XS_CODE_RETRIEVE_2,
    &&XS_CODE_RETRIEVE_TARGET,
    &&XS_CODE_RETRIEVE_THIS,
    &&XS_CODE_RETURN,
    &&XS_CODE_RUN,
    &&XS_CODE_RUN_1,
    &&XS_CODE_RUN_2,
    &&XS_CODE_RUN_4,
    &&XS_CODE_RUN_TAIL,
    &&XS_CODE_RUN_TAIL_1,
    &&XS_CODE_RUN_TAIL_2,
    &&XS_CODE_RUN_TAIL_4,
    &&XS_CODE_SET_CLOSURE_1,
    &&XS_CODE_SET_CLOSURE_2,
    &&XS_CODE_SET_HOME,
    &&XS_CODE_SET_LOCAL_1,
    &&XS_CODE_SET_LOCAL_2,
    &&XS_CODE_SET_PRIVATE_1,
    &&XS_CODE_SET_PRIVATE_2,
    &&XS_CODE_SET_PROPERTY,
    &&XS_CODE_SET_PROPERTY_AT,
    &&XS_CODE_SET_RESULT,
    &&XS_CODE_SET_SUPER,
    &&XS_CODE_SET_SUPER_AT,
    &&XS_CODE_SET_THIS,
    &&XS_CODE_SET_VARIABLE,
    &&XS_CODE_SIGNED_RIGHT_SHIFT,
    &&XS_CODE_START_ASYNC,
    &&XS_CODE_START_ASYNC_GENERATOR,
    &&XS_CODE_START_GENERATOR,
    &&XS_CODE_STORE_1,
    &&XS_CODE_STORE_2,
    &&XS_CODE_STORE_ARROW,
    &&XS_CODE_STRICT_EQUAL,
    &&XS_CODE_STRICT_NOT_EQUAL,
    &&XS_CODE_STRING_1,
    &&XS_CODE_STRING_2,
    &&XS_CODE_STRING_4,
    &&XS_CODE_STRING_ARCHIVE_1,
    &&XS_CODE_STRING_ARCHIVE_2,
    &&XS_CODE_STRING_ARCHIVE_4,
    &&XS_CODE_SUBTRACT,
    &&XS_CODE_SUPER,
    &&XS_CODE_SWAP,
    &&XS_CODE_SYMBOL,
    &&XS_CODE_TARGET,
    &&XS_CODE_TEMPLATE,
    &&XS_CODE_TEMPLATE_CACHE,
    &&XS_CODE_THIS,
    &&XS_CODE_THROW,
    &&XS_CODE_THROW_STATUS,
    &&XS_CODE_TO_INSTANCE,
    &&XS_CODE_TO_NUMERIC,
    &&XS_CODE_TO_STRING,
    &&XS_CODE_TRANSFER,
    &&XS_CODE_TRUE,
    &&XS_CODE_TYPEOF,
    &&XS_CODE_UNCATCH,
    &&XS_CODE_UNDEFINED,
    &&XS_CODE_UNSIGNED_RIGHT_SHIFT,
    &&XS_CODE_UNWIND_1,
    &&XS_CODE_UNWIND_2,
    &&XS_CODE_VAR_CLOSURE_1,
    &&XS_CODE_VAR_CLOSURE_2,
    &&XS_CODE_VAR_LOCAL_1,
    &&XS_CODE_VAR_LOCAL_2,
    &&XS_CODE_VOID,
    &&XS_CODE_WITH,
    &&XS_CODE_WITHOUT,
    &&XS_CODE_YIELD,
    &&XS_CODE_PROFILE,
    &&XS_CODE_YIELD_STAR,
    &&XS_CODE_USED_1,
    &&XS_CODE_USED_2,
    &&XS_CODE_USING,
    &&XS_CODE_USING_ASYNC,
    &&XS_CODE_AT_2,
    &&XS_CODE_SUPER_AT,
    &&XS_CODE_SUPER_AT_2,
    &&XS_CODE_TRANSFER_JSON,
  };
  register void * const *bytes = gxBytes;
#endif
  txJump* jump = C_NULL;
  txSlot scratch;
  txSlot** address;
  txJump* yieldJump = the->firstJump;

  mxCheckCStack();
  if (generator) {
    slot = mxStack;
    variable = generator->next;
    offset = variable->value.stack.length;
    mxAllocStack(offset);
    c_memcpy(mxStack, variable->value.stack.address, offset * sizeof(txSlot));
    mxCode = (mxStack++)->value.reference->next->value.code.address;
    offset = (mxStack++)->value.integer;
    while (offset) {
      jump = c_malloc(sizeof(txJump));
      if (jump) {
        jump->nextJump = the->firstJump;
        jump->stack = slot - (mxStack++)->value.integer;
        jump->frame = slot - (mxStack++)->value.integer;
        jump->scope = slot - (mxStack++)->value.integer;
        jump->code = mxCode + (mxStack++)->value.integer;
        jump->flag = 1;
                the->firstJump = jump;
        if (c_setjmp(jump->buffer) == 1) {
          jump = the->firstJump;
                    the->firstJump = jump->nextJump;
          mxStack = jump->stack;
          mxScope = jump->scope;
          mxFrame = jump->frame;
          mxEnvironment = mxFrameToEnvironment(mxFrame);
          mxCode = jump->code;
          c_free(jump);
          goto XS_CODE_JUMP;
        }
      }
      else {
        mxSaveState;
        fxAbort(the, XS_NOT_ENOUGH_MEMORY_EXIT);
      }
      offset--;
    }
    variable = slot - (mxStack++)->value.integer;
    variable->next = mxFrame;
    variable->value.frame.code = the->code;
    variable->value.frame.scope = mxScope;
    mxFrame = variable;
    mxEnvironment = mxFrameToEnvironment(mxFrame);
    mxScope = slot - (mxStack++)->value.integer;
    mxCode = mxCode + (mxStack++)->value.integer;
    mxStack->kind = the->scratch.kind;
    mxStack->value = the->scratch.value;
#ifdef mxTraceCall
    fxTraceCallBegin(the, mxFrameFunction);
#endif
XS_CODE_JUMP:
    mxFirstCode();
  }
  else {
    offset = count;
    goto XS_CODE_RUN_ALL;
  }
  for (;;) {

#ifdef mxTrace
    if (gxDoTrace) fxTraceCode(the, stack, byte);
#endif
#ifdef mxMetering
    the->meterIndex += XS_CODE_METERING;
#endif
    
    mxSwitch(byte) {
    mxCase(XS_NO_CODE)
      mxBreak;

    mxCase(XS_CODE_RUN_TAIL)
      mxSkipCode(1);
      offset = mxStack->value.integer;
      mxStack++;
      goto XS_CODE_RUN_TAIL_ALL;
    mxCase(XS_CODE_RUN_TAIL_4)
      offset = mxRunS4(1);
      mxSkipCode(5);
      goto XS_CODE_RUN_TAIL_ALL;
    mxCase(XS_CODE_RUN_TAIL_2)
      offset = mxRunS2(1);
      mxSkipCode(3);
      goto XS_CODE_RUN_TAIL_ALL;
    mxCase(XS_CODE_RUN_TAIL_1)
      offset = mxRunS1(1);
      mxSkipCode(2);
    XS_CODE_RUN_TAIL_ALL:
      if (mxFrameHasTarget)
        goto XS_CODE_RUN_ALL;
#ifdef mxDebug
      slot = mxStack + offset + 2;
      if (!fxIsCallable(the, slot))
        goto XS_CODE_RUN_ALL;
#endif
      variable = mxFrameEnd - 4 - offset;
      mxScope = mxFrame->value.frame.scope;
      mxCode = mxFrame->value.frame.code;
      mxFrame = mxFrame->next;
      c_memmove(variable, mxStack, (4 + offset) * sizeof(txSlot));
      mxStack = variable;
      goto XS_CODE_RUN_ALL;

    mxCase(XS_CODE_RUN)
      mxSkipCode(1);
      offset = mxStack->value.integer;
      mxStack++;
      goto XS_CODE_RUN_ALL;
    mxCase(XS_CODE_RUN_4)
      offset = mxRunS4(1);
      mxSkipCode(5);
      goto XS_CODE_RUN_ALL;
    mxCase(XS_CODE_RUN_2)
      offset = mxRunS2(1);
      mxSkipCode(3);
      goto XS_CODE_RUN_ALL;
    mxCase(XS_CODE_RUN_1)
      offset = mxRunS1(1);
      mxSkipCode(2);
    XS_CODE_RUN_ALL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, offset);
#endif
      slot = mxStack + offset;
      // FRAME
      slot->kind = XS_FRAME_KIND;
      slot->next = mxFrame;
      slot->flag = slot->flag & XS_TARGET_FLAG;
      slot->ID = (txID)offset; // COUNT
#ifdef mxDebug
      if (mxFrame && (mxFrame->flag & XS_STEP_INTO_FLAG))
        slot->flag |= XS_STEP_INTO_FLAG | XS_STEP_OVER_FLAG;
#endif
      slot->value.frame.code = mxCode;
      slot->value.frame.scope = mxScope;
      slot++;
      // RESULT
      slot++;
      // FUNCTION
      byte = ((slot + 1)->kind == XS_UNINITIALIZED_KIND) ? 1 : 0;
      if (byte)
        (mxStack + offset)->flag |= XS_TARGET_FLAG;
      if (slot->kind == XS_REFERENCE_KIND) {
        variable = slot->value.reference;
        slot = variable->next;
        if (slot && (slot->flag & XS_INTERNAL_FLAG)) {
          if ((slot->kind == XS_CODE_KIND) || (slot->kind == XS_CODE_X_KIND)) {
            if (byte && !mxIsConstructor(variable))
              mxRunDebug(XS_TYPE_ERROR, "new: not a constructor");
            variable = slot->value.code.closures;
            if (variable) {
              mxPushKind(XS_REFERENCE_KIND);
              mxStack->value.environment.variable.reference = variable;
            }
            else {
              mxPushKind(XS_NULL_KIND);
              mxStack->value.environment.variable.reference = C_NULL;
            }
      #ifdef mxDebug
            mxStack->ID = XS_NO_ID;
            mxStack->value.environment.line = 0;
      #endif
            mxFrame = mxStack + 1 + offset;
            mxEnvironment = mxStack;
            mxScope = mxStack;
            mxCode = slot->value.code.address;
      #ifdef mxTraceCall
            fxTraceCallBegin(the, mxFrameFunction);
      #endif
            mxFirstCode();
            mxBreak;
          }
          if ((slot->kind == XS_CALLBACK_KIND) || (slot->kind == XS_CALLBACK_X_KIND)) {
            if (byte && !mxIsConstructor(variable))
              mxRunDebug(XS_TYPE_ERROR, "new: not a constructor");
            mxPushKind(XS_VAR_KIND);
            mxStack->value.environment.variable.count = 0;
      #ifdef mxDebug
            mxStack->ID = XS_NO_ID;
            mxStack->value.environment.line = 0;
      #endif
            mxFrame = mxStack + 1 + offset;
            mxFrame->flag |= XS_C_FLAG;
            mxScope = mxStack;
            mxCode = C_NULL;
            byte = XS_CODE_CALL;
      #ifdef mxTraceCall
            fxTraceCallBegin(the, mxFrameFunction);
      #endif
            mxSaveState;
      #ifdef mxLink
            if ((txU1*)slot->value.callback.address - (txU1*)the->fakeCallback < 0)
              mxRunDebug(XS_TYPE_ERROR, "link: unavailable function");
      #endif
            if (slot->flag & XS_BASE_FLAG)
              fxRunBase(the);
            else if (slot->flag & XS_DERIVED_FLAG)
              fxRunDerived(the);
            (*(slot->value.callback.address))(the);
            mxRestoreState;
            if (mxCode) {
              byte = *mxCode;
              mxBreak;
            }
      #if defined(mxInstrument) || defined(mxProfile)
            fxCheckProfiler(the, mxFrame);
      #endif
            if (slot->flag & XS_BASE_FLAG)
              goto XS_CODE_END_BASE_ALL;
            if (slot->flag & XS_DERIVED_FLAG)
              goto XS_CODE_END_DERIVED_ALL;
            slot = mxFrameResult;
            goto XS_CODE_END_ALL;
          }
          if (slot->kind == XS_PROXY_KIND) {
            mxPushKind(XS_VAR_KIND);
            mxStack->value.environment.variable.count = 0;
      #ifdef mxDebug
            mxStack->ID = XS_NO_ID;
            mxStack->value.environment.line = 0;
      #endif
            mxFrame = mxStack + 1 + offset;
            mxFrame->flag |= XS_C_FLAG;
            mxScope = mxStack;
            mxCode = C_NULL;
            byte = XS_CODE_CALL;
      #ifdef mxTraceCall
            fxTraceCallBegin(the, mxFrameFunction);
      #endif
            mxSaveState;
            fxRunProxy(the, variable);
            mxRestoreState;
            slot = mxFrameResult;
            goto XS_CODE_END_ALL;
          }
        }
      }
#if mxHostFunctionPrimitive
      else if (slot->kind == XS_HOST_FUNCTION_KIND) {
        if (byte)
          mxRunDebug(XS_TYPE_ERROR, "new: not a constructor");
        mxPushKind(XS_VAR_KIND);
        mxStack->value.environment.variable.count = 0;
#ifdef mxDebug
        mxStack->ID = XS_NO_ID;
        mxStack->value.environment.line = 0;
#endif
        mxFrame = mxStack + 1 + offset;
        mxFrame->flag |= XS_C_FLAG;
        mxScope = mxStack;
        mxCode = C_NULL;
        byte = XS_CODE_CALL;
#ifdef mxTraceCall
        fxTraceCallBegin(the, mxFrameFunction);
#endif
        mxSaveState;
#ifdef mxLink
        if ((txU1*)slot->value.hostFunction.builder->callback - (txU1*)the->fakeCallback < 0)
          mxRunDebug(XS_TYPE_ERROR, "link: unavailable function");
#endif
        (*(slot->value.hostFunction.builder->callback))(the);
        mxRestoreState;
        if (mxCode) {
          byte = *mxCode;
          mxBreak;
        }
        slot = mxFrameResult;
        goto XS_CODE_END_ALL;
      }
#endif
      if (byte) {
        mxRunDebug(XS_TYPE_ERROR, "new: not a constructor");
      }
      else {
        mxRunDebug(XS_TYPE_ERROR, "call: not a function");
      }
      mxBreak;
      
    mxCase(XS_CODE_BEGIN_SLOPPY)
            if (mxFrameHasTarget && (mxFrameFunction->value.reference->flag & XS_CAN_CONSTRUCT_FLAG)) {
        mxSaveState;
        fxRunConstructor(the);
        mxRestoreState;
      }
      else {
        index = mxFrameThis->kind;
        if (index < XS_REFERENCE_KIND) {
          if ((index == XS_UNDEFINED_KIND) || (index == XS_NULL_KIND)) {
            mxFrameThis->kind = XS_REFERENCE_KIND;
            variable = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
            variable = mxModuleInstanceInternal(variable)->value.module.realm;
            if (!variable) variable = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
            mxFrameThis->value.reference = mxRealmGlobal(variable)->value.reference;
          }
          else {
            mxSaveState;
            fxToInstance(the, mxFrameThis);
            mxRestoreState;
          }
        }
      }
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_BEGIN_STRICT)
      mxFrame->flag |= XS_STRICT_FLAG;
            if (mxFrameHasTarget && (mxFrameFunction->value.reference->flag & XS_CAN_CONSTRUCT_FLAG)) {
        mxSaveState;
        fxRunConstructor(the);
        mxRestoreState;
      }
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_BEGIN_STRICT_BASE)
      mxFrame->flag |= XS_STRICT_FLAG;
      mxSaveState;
      fxRunBase(the);
      mxRestoreState;
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_BEGIN_STRICT_DERIVED)
      mxFrame->flag |= XS_STRICT_FLAG;
      mxSaveState;
      fxRunDerived(the);
      mxRestoreState;
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_BEGIN_STRICT_FIELD)
      mxFrame->flag |= XS_STRICT_FLAG | XS_FIELD_FLAG;
            if (mxFrameHasTarget) {
        mxSaveState;
        fxRunConstructor(the);
        mxRestoreState;
      }
      mxNextCode(2);
      mxBreak;
          
    mxCase(XS_CODE_END_ARROW)
      slot = mxFrameResult;
      goto XS_CODE_END_ALL;
    mxCase(XS_CODE_END_BASE)
    XS_CODE_END_BASE_ALL:
      slot = mxFrameResult;
      if (slot->kind != XS_REFERENCE_KIND)
        slot = mxFrameThis;
      goto XS_CODE_END_ALL;
    mxCase(XS_CODE_END_DERIVED)
    XS_CODE_END_DERIVED_ALL:
      slot = mxFrameResult;
      if (slot->kind != XS_REFERENCE_KIND) {
        if ((slot->kind != XS_UNDEFINED_KIND) && (slot->kind != XS_CLOSURE_KIND))
          mxRunDebug(XS_TYPE_ERROR, "result: invalid constructor");
        slot = mxFrameThis->value.closure;
        if (slot->kind < 0)
          mxRunDebug(XS_REFERENCE_ERROR, "this: not initialized");
      }
      goto XS_CODE_END_ALL;
    mxCase(XS_CODE_END)
      slot = mxFrameResult;
      if (mxFrameHasTarget) {
        if (slot->kind != XS_REFERENCE_KIND)
          slot = mxFrameThis;
      }
    XS_CODE_END_ALL:
#ifdef mxTraceCall
      fxTraceCallEnd(the, mxFrameFunction);
#endif
#ifdef mxInstrument
      if (the->stackPeak > mxStack)
        the->stackPeak = mxStack;
#endif
      mxStack = mxFrameEnd;
      mxScope = mxFrame->value.frame.scope;
      mxCode = mxFrame->value.frame.code;
      mxAllocStack(1);
      *mxStack = *slot;
      mxFrame = mxFrame->next;
      if (!mxFrame || (mxFrame->flag & XS_C_FLAG)) {
#ifdef mxTrace
        if (gxDoTrace) fxTraceReturn(the);
#endif
        byte = XS_CODE_END;
        mxSaveState;
        return; 
      }
      mxEnvironment = mxFrameToEnvironment(mxFrame);
      mxFirstCode();
      mxBreak;
    mxCase(XS_CODE_RETURN)
      mxStack = mxFrameEnd;
      mxScope = mxFrame->value.frame.scope;
      mxCode = mxFrame->value.frame.code;
      mxAllocStack(1);
      *mxStack = *mxFrameResult;
      mxFrame = mxFrame->next;
#ifdef mxTrace
      if (gxDoTrace)
        if (gxDoTrace) fxTraceReturn(the);
#endif
      mxSaveState;
      return;
      
    mxCase(XS_CODE_START_ASYNC)
      mxSkipCode(1);
      mxSaveState;
      variable = gxDefaults.newAsyncInstance(the);
      mxRestoreState;
      slot = mxFrameEnd;
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(mxCode - mxFrameFunction->value.reference->next->value.code.address);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxScope);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxFrame);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = 0;
      mxPushKind(mxFrameFunction->kind);
      mxStack->value = mxFrameFunction->value;
      index = mxPtrDiff(slot - mxStack);
      slot = variable->next;
      variable = slot->value.stack.address;
      if (slot->value.stack.length < index) {
        mxSaveState;
        if (variable)
          variable = (txSlot *)fxRenewChunk(the, variable, index * sizeof(txSlot));
        if (!variable)
          variable = (txSlot *)fxNewChunk(the, index * sizeof(txSlot));
        mxRestoreState;
        slot->value.stack.address = variable;
      }
      slot->value.stack.length = index;
      c_memcpy(variable, mxStack, index * sizeof(txSlot));
      mxStack += 5;
      mxSaveState;
      gxDefaults.runAsync(the, mxStack->value.reference);
      mxRestoreState;
      slot = mxFrameResult;
      goto XS_CODE_END_ALL;
      
    mxCase(XS_CODE_START_ASYNC_GENERATOR)
      mxSkipCode(1);
            if (mxFrameHasTarget)
        mxRunDebug(XS_TYPE_ERROR, "new: async generator");
      slot = mxBehaviorGetProperty(the, mxFrameFunction->value.reference, mxID(_prototype), 0, XS_ANY);
      mxPushKind(slot->kind);
      mxStack->value = slot->value;
      mxSaveState;
      variable = gxDefaults.newAsyncGeneratorInstance(the);
      mxRestoreState;
      mxFrameResult->kind = XS_UNINITIALIZED_KIND;
      slot = mxFrameEnd;
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(mxCode - mxFrameFunction->value.reference->next->value.code.address);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxScope);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxFrame);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = 0;
      mxPushKind(mxFrameFunction->kind);
      mxStack->value = mxFrameFunction->value;
      index = mxPtrDiff(slot - mxStack);
      slot = variable->next;
      variable = slot->value.stack.address;
      if (slot->value.stack.length < index) {
        mxSaveState;
        if (variable)
          variable = (txSlot *)fxRenewChunk(the, variable, index * sizeof(txSlot));
        if (!variable)
          variable = (txSlot *)fxNewChunk(the, index * sizeof(txSlot));
        mxRestoreState;
        slot->value.stack.address = variable;
      }
      slot->value.stack.length = index;
      c_memcpy(variable, mxStack, index * sizeof(txSlot));
      mxStack += 5;
      *mxFrameResult = *(mxStack++);
      slot = mxFrameResult;
      goto XS_CODE_END_ALL;
    
    mxCase(XS_CODE_START_GENERATOR)
      mxSkipCode(1);
            if (mxFrameHasTarget)
        mxRunDebug(XS_TYPE_ERROR, "new: generator");
      slot = mxBehaviorGetProperty(the, mxFrameFunction->value.reference, mxID(_prototype), 0, XS_ANY);
      mxPushKind(slot->kind);
      mxStack->value = slot->value;
      mxSaveState;
      variable = gxDefaults.newGeneratorInstance(the);
      mxRestoreState;
      slot = mxFrameEnd;
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(mxCode - mxFrameFunction->value.reference->next->value.code.address);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxScope);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxFrame);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = 0;
      mxPushKind(mxFrameFunction->kind);
      mxStack->value = mxFrameFunction->value;
      index = mxPtrDiff(slot - mxStack);
      slot = variable->next;
      variable = slot->value.stack.address;
      if (slot->value.stack.length < index) {
        mxSaveState;
        if (variable)
          variable = (txSlot *)fxRenewChunk(the, variable, index * sizeof(txSlot));
        if (!variable)
          variable = (txSlot *)fxNewChunk(the, index * sizeof(txSlot));
        mxRestoreState;
        slot->value.stack.address = variable;
      }
      slot->value.stack.length = index;
      c_memcpy(variable, mxStack, index * sizeof(txSlot));
      mxStack += 5;
      *mxFrameResult = *(mxStack++);
      slot = mxFrameResult;
      goto XS_CODE_END_ALL;
      
    mxCase(XS_CODE_AWAIT)
    mxCase(XS_CODE_YIELD)
    mxCase(XS_CODE_YIELD_STAR)
      generator->next->next->value.integer = byte;
      mxSkipCode(1);
      slot = mxFrameEnd;
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(mxCode - mxFrameFunction->value.reference->next->value.code.address);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxScope);
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxPtrDiff(slot - mxFrame);
      jump = the->firstJump;
      offset = 0;
      while (jump != yieldJump) {
        txJump* nextJump = jump->nextJump;
        mxPushKind(XS_INTEGER_KIND);
        mxStack->value.integer = mxPtrDiff(jump->code - mxFrameFunction->value.reference->next->value.code.address);
        mxPushKind(XS_INTEGER_KIND);
        mxStack->value.integer = mxPtrDiff(slot - jump->scope);
        mxPushKind(XS_INTEGER_KIND);
        mxStack->value.integer = mxPtrDiff(slot - jump->frame);
        mxPushKind(XS_INTEGER_KIND);
        mxStack->value.integer = mxPtrDiff(slot - jump->stack);
        c_free(jump);
        jump = nextJump;
        offset++;
      }
      the->firstJump = yieldJump;
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = offset;
      mxPushKind(mxFrameFunction->kind);
      mxStack->value = mxFrameFunction->value;
      index = mxPtrDiff(slot - mxStack);
      slot = generator->next;
      variable = slot->value.stack.address;
      if (slot->value.stack.length < index) {
        mxSaveState;
        if (variable)
          variable = (txSlot *)fxRenewChunk(the, variable, index * sizeof(txSlot));
        if (!variable)
          variable = (txSlot *)fxNewChunk(the, index * sizeof(txSlot));
        mxRestoreState;
        slot->value.stack.address = variable;
      }
      slot->value.stack.length = index;
      c_memcpy(variable, mxStack, index * sizeof(txSlot));
      mxStack += 5 + (offset * 4);
      *mxFrameResult = *(mxStack++);
      slot = mxFrameResult;
      goto XS_CODE_END_ALL;
      
  /* FRAMES */    
    mxCase(XS_CODE_ARGUMENT)
      offset = mxRunU1(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, offset);
#endif
      if (offset < mxFrameArgc) {
        slot = mxFrameArgv(offset);
        mxPushKind(slot->kind);
        mxStack->value = slot->value;
      }
      else {
        mxPushKind(XS_UNDEFINED_KIND);
      }
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_ARGUMENTS)
      offset = mxRunU1(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, offset);
#endif
      mxSaveState;
      fxRunArguments(the, offset);
      mxRestoreState;
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_ARGUMENTS_SLOPPY)
      offset = mxRunU1(1);
      mxAllocStack(1);
      *mxStack = mxArgumentsSloppyPrototype;
      mxSaveState;
      gxDefaults.newArgumentsSloppyInstance(the, offset);
      mxRestoreState;
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_ARGUMENTS_STRICT)
      offset = mxRunU1(1);
      mxAllocStack(1);
      *mxStack = mxArgumentsStrictPrototype;
      mxSaveState;
      gxDefaults.newArgumentsStrictInstance(the, offset);
      mxRestoreState;
      mxNextCode(2);
      mxBreak;
    mxCase(XS_CODE_CURRENT)
      mxAllocStack(1);
      *mxStack = *mxFrameFunction;
      if (!(mxFrame->flag & XS_STRICT_FLAG))
        ignore = 1;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_GET_RESULT)
      mxAllocStack(1);
      *mxStack = *mxFrameResult;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_SET_RESULT)
      *mxFrameResult = *(mxStack++);
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_TARGET)
      mxAllocStack(1);
      if (mxFrameHasTarget)
        *mxStack = *mxFrameTarget;
      else {
        mxInitSlotKind(mxStack, XS_UNDEFINED_KIND);
        mxStack->next = C_NULL;
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_THIS)
      mxAllocStack(1);
      *mxStack = *mxFrameThis;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_GET_THIS)
      slot = mxFrameThis;
      variable = slot->value.closure;
      if (variable->kind < 0)
        mxRunDebug(XS_REFERENCE_ERROR, "this: not initialized yet");
      mxPushKind(variable->kind);
      mxStack->value = variable->value;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_SET_THIS)
      slot = mxFrameThis;
      variable = slot->value.closure;
      if (variable->kind >= 0)
        mxRunDebug(XS_REFERENCE_ERROR, "this: already initialized");
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxNextCode(1);
      mxBreak;
    
  /* EXCEPTIONS */  
    mxCase(XS_CODE_EXCEPTION)
      mxAllocStack(1);
      *mxStack = mxException;
      mxException = mxUndefined;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_CATCH_4)
      offset = mxRunS4(1);
      mxNextCode(5);
      goto XS_CODE_CATCH;
    mxCase(XS_CODE_CATCH_2)
      offset = mxRunS2(1);
      mxNextCode(3);
      goto XS_CODE_CATCH;
    mxCase(XS_CODE_CATCH_1)
      offset = mxRunS1(1);
      mxNextCode(2);
    XS_CODE_CATCH:
      jump = c_malloc(sizeof(txJump));
      if (jump) {
        jump->nextJump = the->firstJump;
        jump->stack = mxStack;
        jump->scope = mxScope;
        jump->frame = mxFrame;
        jump->environment = mxEnvironment->value.reference;
        jump->code = mxCode + offset;
        jump->flag = 1;
                the->firstJump = jump;
        if (c_setjmp(jump->buffer) != 0) {
          jump = the->firstJump;
                    the->firstJump = jump->nextJump;
          mxStack = jump->stack;
          mxScope = jump->scope;
          mxFrame = jump->frame;
          mxEnvironment = mxFrameToEnvironment(mxFrame);
          mxEnvironment->value.reference = jump->environment;
          mxCode = jump->code;
          c_free(jump);
          mxFirstCode();
        }
      }
      else {
        mxSaveState;
        fxAbort(the, XS_NOT_ENOUGH_MEMORY_EXIT);
      }
      mxBreak;
    mxCase(XS_CODE_RETHROW)
      mxSaveState;
      fxJump(the);
      mxBreak;
    mxCase(XS_CODE_THROW)
      mxException = *mxStack;
    #ifdef mxDebug
      mxSaveState;
      fxDebugThrow(the, C_NULL, 0, "throw");
      mxRestoreState;
    #elif mxInstrument
      mxSaveState;
      fxTraceException(the);
      mxRestoreState;
    #endif
      mxSaveState;
      fxJump(the);
      mxBreak;
    mxCase(XS_CODE_THROW_STATUS)
      if (the->status & XS_THROW_STATUS) {
        mxException = *mxStack;
      #ifdef mxDebug
        mxSaveState;
        fxDebugThrow(the, C_NULL, 0, "throw");
        mxRestoreState;
      #elif mxInstrument
        mxSaveState;
        fxTraceException(the);
        mxRestoreState;
      #endif
        mxSaveState;
        fxJump(the);
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_UNCATCH)
      jump = the->firstJump;
      the->firstJump = jump->nextJump;
      c_free(jump);
      mxNextCode(1);
      mxBreak;
      
  /* BRANCHES */  
    mxCase(XS_CODE_BRANCH_1)
      offset = mxRunS1(1);
      mxBranch(2, offset);
      mxBreak;
    mxCase(XS_CODE_BRANCH_2)
      offset = mxRunS2(1);
      mxBranch(3, offset);
      mxBreak;
    mxCase(XS_CODE_BRANCH_4)
      offset = mxRunS4(1);
      mxBranch(5, offset);
      mxBreak;
    mxCase(XS_CODE_BRANCH_CHAIN_4)
      offset = mxRunS4(1);
      index = 5;
      goto XS_CODE_BRANCH_CHAIN;
    mxCase(XS_CODE_BRANCH_CHAIN_2)
      offset = mxRunS2(1);
      index = 3;
      goto XS_CODE_BRANCH_CHAIN;
    mxCase(XS_CODE_BRANCH_CHAIN_1)
      offset = mxRunS1(1);
      index = 2;
    XS_CODE_BRANCH_CHAIN:
      byte = mxStack->kind;
      if ((XS_UNDEFINED_KIND == byte) || (XS_NULL_KIND == byte)) {
        mxStack->kind = XS_UNDEFINED_KIND;
        mxBranch(index, offset);
      }
      else
        mxNextCode((txS4)index);
      mxBreak;
    mxCase(XS_CODE_BRANCH_COALESCE_4)
      offset = mxRunS4(1);
      index = 5;
      goto XS_CODE_BRANCH_COALESCE;
    mxCase(XS_CODE_BRANCH_COALESCE_2)
      offset = mxRunS2(1);
      index = 3;
      goto XS_CODE_BRANCH_COALESCE;
    mxCase(XS_CODE_BRANCH_COALESCE_1)
      offset = mxRunS1(1);
      index = 2;
    XS_CODE_BRANCH_COALESCE:
      byte = mxStack->kind;
      if ((XS_UNDEFINED_KIND == byte) || (XS_NULL_KIND == byte)) {
        mxStack++;
        mxNextCode((txS4)index);
      }
      else {
        mxBranch(index, offset);
      }
      mxBreak;
    mxCase(XS_CODE_BRANCH_ELSE_4)
      offset = mxRunS4(1);
      index = 5;
      goto XS_CODE_BRANCH_ELSE;
    mxCase(XS_CODE_BRANCH_ELSE_2)
      offset = mxRunS2(1);
      index = 3;
      goto XS_CODE_BRANCH_ELSE;
    mxCase(XS_CODE_BRANCH_ELSE_1)
      offset = mxRunS1(1);
      index = 2;
    XS_CODE_BRANCH_ELSE:
      byte = mxStack->kind;
      if (XS_BOOLEAN_KIND == byte) {
        mxBranchElse(mxStack->value.boolean, index, offset);
      }
      else if (XS_INTEGER_KIND == byte) {
        mxBranchElse(mxStack->value.integer, index, offset);
      }
      else if (XS_NUMBER_KIND == byte) {
        mxBranchIf((c_isnan(mxStack->value.number) || c_iszero(mxStack->value.number)), index, offset);
        mxFloatingPointOp("else");
      }
      else if ((XS_BIGINT_KIND == byte) || (XS_BIGINT_X_KIND == byte)) {
        mxBranchIf(((mxStack->value.bigint.size == 1) && (mxStack->value.bigint.data[0] == 0)), index, offset);
      }
      else if ((XS_STRING_KIND == byte) || (XS_STRING_X_KIND == byte)) {
        mxBranchIf(c_isEmpty(mxStack->value.string), index, offset);
      }
      else {
        mxBranchIf((XS_UNDEFINED_KIND == byte) || (XS_NULL_KIND == byte), index, offset);
      }
      mxStack++;
      mxBreak;
    mxCase(XS_CODE_BRANCH_IF_4)
      offset = mxRunS4(1);
      index = 5;
      goto XS_CODE_BRANCH_IF;
    mxCase(XS_CODE_BRANCH_IF_2)
      offset = mxRunS2(1);
      index = 3;
      goto XS_CODE_BRANCH_IF;
    mxCase(XS_CODE_BRANCH_IF_1)
      offset = mxRunS1(1);
      index = 2;
    XS_CODE_BRANCH_IF:
      byte = mxStack->kind;
      if (XS_BOOLEAN_KIND == byte) {
        mxBranchIf(mxStack->value.boolean, index, offset);
      }
      else if (XS_INTEGER_KIND == byte) {
        mxBranchIf(mxStack->value.integer, index, offset);
      }
      else if (XS_NUMBER_KIND == byte) {
        mxBranchElse(c_isnan(mxStack->value.number) || c_iszero(mxStack->value.number), index, offset);
        mxFloatingPointOp("if");
      }
      else if ((XS_BIGINT_KIND == byte) || (XS_BIGINT_X_KIND == byte)) {
        mxBranchElse((mxStack->value.bigint.size == 1) && (mxStack->value.bigint.data[0] == 0), index, offset);
      }
      else if ((XS_STRING_KIND == byte) || (XS_STRING_X_KIND == byte)) {
        mxBranchElse(c_isEmpty(mxStack->value.string), index, offset);
      }
      else {
        mxBranchElse((XS_UNDEFINED_KIND == byte) || (XS_NULL_KIND == byte), index, offset);
      }
      mxStack++;
      mxBreak;
    mxCase(XS_CODE_BRANCH_STATUS_4)
      offset = mxRunS4(1);
      index = 5;
      goto XS_CODE_BRANCH_STATUS;
    mxCase(XS_CODE_BRANCH_STATUS_2)
      offset = mxRunS2(1);
      index = 3;
      goto XS_CODE_BRANCH_STATUS;
    mxCase(XS_CODE_BRANCH_STATUS_1)
      offset = mxRunS1(1);
      index = 2;
    XS_CODE_BRANCH_STATUS:
      if (the->status & XS_THROW_STATUS) {
        mxException = *mxStack;
      #ifdef mxDebug
        mxSaveState;
        fxDebugThrow(the, C_NULL, 0, "throw");
        mxRestoreState;
      #elif mxInstrument
        mxSaveState;
        fxTraceException(the);
        mxRestoreState;
      #endif
        mxSaveState;
        fxJump(the);
      }
      mxNextCode((the->status & XS_RETURN_STATUS) ? index : index + offset);
      mxBreak;
      
  /* STACK */  
    mxCase(XS_CODE_DUB)
      mxAllocStack(1);
      *mxStack = *(mxStack + 1);
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_DUB_AT)
      mxAllocStack(2);
      *(mxStack + 1) = *(mxStack + 3);
      *mxStack = *(mxStack + 2);
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_POP)
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_SWAP)
      scratch = *(mxStack);
      *(mxStack) = *(mxStack + 1);
      *(mxStack + 1) = scratch;
      mxNextCode(1);
      mxBreak;

  /* SCOPE */    
    mxCase(XS_CODE_CONST_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_CONST_CLOSURE;
    mxCase(XS_CODE_CONST_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_CONST_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = mxEnvironment - index;
      variable = slot->value.closure;
      if (variable->kind >= 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: already initialized", slot->ID);
//      slot->flag |= XS_DONT_SET_FLAG; //@@
      variable->flag |= XS_DONT_SET_FLAG;
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      if (!(mxFrame->flag & XS_STRICT_FLAG) && ignore) {
        ignore = 0;
        variable->flag |= XS_DONT_ENUM_FLAG;
      }
      mxBreak;
    mxCase(XS_CODE_CONST_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_CONST_LOCAL;
    mxCase(XS_CODE_CONST_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_CONST_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      if (variable->kind >= 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: already initialized", variable->ID);
      variable->flag |= XS_DONT_SET_FLAG;
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      if (!(mxFrame->flag & XS_STRICT_FLAG) && ignore) {
        ignore = 0;
        variable->flag |= XS_DONT_ENUM_FLAG;
      }
      mxBreak;
            
    mxCase(XS_CODE_GET_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_GET_CLOSURE;
    mxCase(XS_CODE_GET_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_GET_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = mxEnvironment - index;
      #ifdef mxDebug
        offset = slot->ID;
      #endif
      variable = slot->value.closure;
      if (variable->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "get %s: not initialized yet", slot->ID);
#if mxAliasInstance
      offset = variable->ID;
      if (offset) {
        slot = the->aliasArray[offset];
        if (slot)
          variable = slot;
      } 
#endif
      mxPushKind(variable->kind);
      mxStack->value = variable->value;
      mxBreak;
    mxCase(XS_CODE_GET_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_GET_LOCAL;
    mxCase(XS_CODE_GET_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_GET_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      #ifdef mxDebug
        offset = variable->ID;
      #endif
      if (variable->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "get %s: not initialized yet", variable->ID);
      mxPushKind(variable->kind);
      mxStack->value = variable->value;
      mxBreak;
      
    mxCase(XS_CODE_LET_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_LET_CLOSURE;
    mxCase(XS_CODE_LET_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_LET_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = mxEnvironment - index;
      variable = slot->value.closure;
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxBreak;
    mxCase(XS_CODE_LET_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_LET_LOCAL;
    mxCase(XS_CODE_LET_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_LET_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxBreak;
      
    mxCase(XS_CODE_NEW_CLOSURE)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxNextCode(1 + sizeof(txID));
      slot = --mxScope;
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, mxEnvironment - mxScope - 1);
#endif
      mxSaveState;
      variable = fxNewSlot(the);
      mxRestoreState;
      slot->flag = XS_DONT_DELETE_FLAG;
      slot->ID = (txID)offset;
      slot->kind = XS_CLOSURE_KIND;
      slot->value.closure = variable;
      variable->kind = XS_UNINITIALIZED_KIND;
      mxBreak;
    mxCase(XS_CODE_NEW_LOCAL)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxNextCode(1 + sizeof(txID));
      variable = --mxScope;
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, mxEnvironment - mxScope - 1);
#endif
      variable->flag = XS_DONT_DELETE_FLAG;
      variable->ID = (txID)offset;
      variable->kind = XS_UNINITIALIZED_KIND;
      mxBreak;
    mxCase(XS_CODE_NEW_TEMPORARY)
      variable = --mxScope;
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, mxEnvironment - mxScope - 1);
#endif
      mxInitSlotKind(variable, XS_UNDEFINED_KIND);
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_PULL_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_PULL_CLOSURE;
    mxCase(XS_CODE_PULL_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_PULL_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = mxEnvironment - index;
      if (slot->flag & XS_DONT_SET_FLAG) // import
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", slot->ID);
      variable = slot->value.closure;
      if (variable->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: not initialized yet", slot->ID);
      if (variable->flag & XS_DONT_SET_FLAG) {
        if (variable->flag & XS_DONT_ENUM_FLAG) {
          mxStack++;
          mxBreak;
        }
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", slot->ID);
      }
#if mxAliasInstance
      offset = variable->ID;
      if (offset) {
        variable = the->aliasArray[offset];
        if (!variable) {
          mxSaveState;
          variable = fxNewSlot(the);
          mxRestoreState;
          the->aliasArray[offset] = variable;
        }
      } 
#endif
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxStack++;
      mxBreak;
    mxCase(XS_CODE_PULL_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_PULL_LOCAL;
    mxCase(XS_CODE_PULL_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_PULL_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      if (variable->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: not initialized yet", variable->ID);
      if (variable->flag & XS_DONT_SET_FLAG) {
        if (variable->flag & XS_DONT_ENUM_FLAG) {
          mxStack++;
          mxBreak;
        }
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", variable->ID);
      }
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxStack++;
      mxBreak;
      
    mxCase(XS_CODE_REFRESH_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_REFRESH_CLOSURE;
    mxCase(XS_CODE_REFRESH_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_REFRESH_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      mxSaveState;
      slot = fxNewSlot(the);
      mxRestoreState;
      slot->flag = variable->value.closure->flag;
      slot->kind = variable->value.closure->kind;
      slot->value = variable->value.closure->value;
      variable->value.closure = slot;
      mxBreak;
    mxCase(XS_CODE_REFRESH_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_REFRESH_LOCAL;
    mxCase(XS_CODE_REFRESH_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_REFRESH_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      mxBreak;
      
    mxCase(XS_CODE_RESERVE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_RESERVE;
    mxCase(XS_CODE_RESERVE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_RESERVE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index);
#endif
      mxAllocStack(index);    
      c_memset(mxStack, 0, index * sizeof(txSlot));
      mxBreak;
      
    mxCase(XS_CODE_RESET_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_RESET_CLOSURE;
    mxCase(XS_CODE_RESET_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_RESET_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index);
#endif
      slot = mxEnvironment - index;
      mxSaveState;
      variable = fxNewSlot(the);
      mxRestoreState;
      variable->kind = XS_UNINITIALIZED_KIND;
      slot->value.closure = variable;
      mxBreak;
    mxCase(XS_CODE_RESET_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_RESET_LOCAL;
    mxCase(XS_CODE_RESET_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_RESET_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index);
#endif
      variable = mxEnvironment - index;
      variable->flag = XS_NO_FLAG;
      variable->kind = XS_UNINITIALIZED_KIND;
      mxBreak;
      
    mxCase(XS_CODE_SET_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_SET_CLOSURE;
    mxCase(XS_CODE_SET_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_SET_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = mxEnvironment - index;
      if (slot->flag & XS_DONT_SET_FLAG) // import
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", slot->ID);
      variable = slot->value.closure;
      if (variable->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: not initialized yet", slot->ID);
      if (variable->flag & XS_DONT_SET_FLAG) {
        if (variable->flag & XS_DONT_ENUM_FLAG)
          mxBreak;
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", slot->ID);
      }
#if mxAliasInstance
      offset = variable->ID;
      if (offset > 0) {
        variable = the->aliasArray[offset];
        if (!variable) {
          mxSaveState;
          variable = fxNewSlot(the);
          mxRestoreState;
          the->aliasArray[offset] = variable;
        }
      } 
#endif
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxBreak;
    mxCase(XS_CODE_SET_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_SET_LOCAL;
    mxCase(XS_CODE_SET_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_SET_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      if (variable->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: not initialized yet", variable->ID);
      if (variable->flag & XS_DONT_SET_FLAG) {
        if (variable->flag & XS_DONT_ENUM_FLAG)
          mxBreak;
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", variable->ID);
      }
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxBreak;

    mxCase(XS_CODE_VAR_CLOSURE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_VAR_CLOSURE;
    mxCase(XS_CODE_VAR_CLOSURE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_VAR_CLOSURE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = (mxEnvironment - index)->value.closure;
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxBreak;
    mxCase(XS_CODE_VAR_LOCAL_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_VAR_LOCAL;
    mxCase(XS_CODE_VAR_LOCAL_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_VAR_LOCAL:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      variable = mxEnvironment - index;
      variable->kind = mxStack->kind;
      variable->value = mxStack->value;
      mxBreak;
      
    mxCase(XS_CODE_UNWIND_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_UNWIND;
    mxCase(XS_CODE_UNWIND_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_UNWIND:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index);
#endif
      slot = mxScope;
      mxScope += index;
      while (slot < mxScope)
        (slot++)->kind = XS_UNDEFINED_KIND;
      mxBreak;
      
    mxCase(XS_CODE_RETRIEVE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_RETRIEVE;
    mxCase(XS_CODE_RETRIEVE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_RETRIEVE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index);
#endif
      slot = mxEnvironment->value.reference->next->next;
      variable = mxScope;
      while (index) {
        --variable;
        offset = variable->ID = slot->ID;
                variable->flag = slot->flag;
                variable->kind = slot->kind;
        variable->value = slot->value;
#ifdef mxTrace
        if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
        index--;
        slot = slot->next;
      }
      mxScope = variable;
      mxBreak;
    mxCase(XS_CODE_RETRIEVE_TARGET)
      if (mxID(_new_target) == slot->ID) {
        if (!mxFrameHasTarget) {
          mxAllocStack(1);
          c_memmove(mxStack, mxStack + 1, (mxFrame + 3 - mxStack) * sizeof(txSlot));
          mxScope--;
          mxEnvironment--;
          mxFrame--;
          mxFrame->flag |= XS_TARGET_FLAG;
        }
        variable = mxFrameTarget;
        variable->kind = slot->kind;
        variable->value = slot->value;

        slot = slot->next;
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_RETRIEVE_THIS)
      variable = mxFrameThis;
      variable->kind = slot->kind;
      variable->value = slot->value;
      slot = slot->next;
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_ENVIRONMENT) 
      mxPushKind(XS_UNDEFINED_KIND);
      mxSaveState;
      slot = fxNewEnvironmentInstance(the, C_NULL);
      mxRestoreState;
      variable = mxFunctionInstanceCode((mxStack + 1)->value.reference);
      variable->value.code.closures = slot;
      mxNextCode(1);
      mxBreak;

    mxCase(XS_CODE_STORE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_STORE;
    mxCase(XS_CODE_STORE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_STORE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      address = &(mxStack->value.reference->next);
      while ((slot = *address)) {
        address = &slot->next;
      }
      mxSaveState;
      *address = slot = fxNewSlot(the);
      mxRestoreState;
      variable = mxEnvironment - index;
      offset = slot->ID = variable->ID;
            slot->flag = variable->flag;
            slot->kind = variable->kind;
      slot->value = variable->value;
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxBreak;
    mxCase(XS_CODE_STORE_ARROW)
      // super
      variable = mxFunctionInstanceHome(mxFrameFunction->value.reference);
      slot = mxFunctionInstanceHome((mxStack + 1)->value.reference);
      slot->value.home.object = variable->value.home.object;
      // target
      address = &(mxStack->value.reference->next);
      while ((slot = *address)) {
        address = &slot->next;
      }
      if (mxFrameHasTarget) {
        mxSaveState;
        *address = slot = fxNewSlot(the);
        mxRestoreState;
        slot->ID = mxID(_new_target);
        variable = mxFrameTarget;
        slot->kind = variable->kind;
        slot->value = variable->value;
        address = &slot->next;
      }
      // this
      mxSaveState;
      *address = slot = fxNewSlot(the);
      mxRestoreState;
      variable = mxFrameThis;
      slot->ID = mxID(_this);
      slot->kind = variable->kind;
      slot->value = variable->value;
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_USED_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_USED;
    mxCase(XS_CODE_USED_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_USED:
      slot = mxEnvironment - index;
      mxSaveState;
      fxRunUsed(the, slot);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_USING)
      mxNextCode(1);
      mxSaveState;
      fxRunUsing(the);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_USING_ASYNC)
      mxNextCode(1);
      mxSaveState;
      fxRunUsingAsync(the);
      mxRestoreState;
      mxBreak;
        
  /* PROPERTIES */  
    mxCase(XS_CODE_CHECK_INSTANCE)
      if (mxStack->kind != XS_REFERENCE_KIND)
        mxRunDebug(XS_TYPE_ERROR, "iterator result: not an object");
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_TO_INSTANCE)
      mxToInstance(mxStack);
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_SUPER_AT_2)
      slot = mxStack + 2;
      goto XS_CODE_SUPER_AT_ALL;
    mxCase(XS_CODE_SUPER_AT)
      slot = mxStack + 1;
      /* continue */
    XS_CODE_SUPER_AT_ALL:
      mxToInstance(slot);
      slot->value.super.reference = variable;
      variable = mxFunctionInstanceHome(mxFrameFunction->value.reference);
      if (!variable->value.home.object) 
        mxRunDebugID(XS_TYPE_ERROR, "super.%s: no home", (txID)offset);
      variable = fxGetPrototype(the, variable->value.home.object);
      if (!variable)
        mxRunDebugID(XS_TYPE_ERROR, "super.%s: no prototype", (txID)offset);
      slot->value.super.prototype = variable;
      slot--;
      goto XS_CODE_AT_ALL;
    mxCase(XS_CODE_AT_2)
      mxToInstance(mxStack + 2);
      slot = mxStack + 1;
      goto XS_CODE_AT_ALL;
    mxCase(XS_CODE_AT)
      mxToInstance(mxStack + 1);
      slot = mxStack;
      /* continue */
    XS_CODE_AT_ALL:
      if (slot->kind == XS_REFERENCE_KIND) {
        mxSaveState;
        fxToPrimitive(the, slot, XS_STRING_HINT);
        mxRestoreState;
      }
      if ((slot->kind == XS_INTEGER_KIND) && fxIntegerToIndex(the, slot->value.integer, &(scratch.value.at.index))) {
        slot->kind = XS_AT_KIND;
        slot->value.at.id = XS_NO_ID;
        slot->value.at.index = scratch.value.at.index;
      }
      else if ((slot->kind == XS_NUMBER_KIND) && fxNumberToIndex(the, slot->value.number, &(scratch.value.at.index))) {
        slot->kind = XS_AT_KIND;
        slot->value.at.id = XS_NO_ID;
        slot->value.at.index = scratch.value.at.index;
      }
      else if (slot->kind == XS_SYMBOL_KIND) {
        slot->kind = XS_AT_KIND;
        slot->value.at.id = slot->value.symbol;
        slot->value.at.index = 0;
      }
      else {
        txFlag flag;

        mxToString(slot);
        mxSaveState;
        flag = fxStringToIndex(the, slot->value.string, &(scratch.value.at.index));
        mxRestoreState;
        if (flag) {
#ifdef mxMetering
          the->meterIndex += 2 * XS_CODE_METERING;
#endif
          slot->kind = XS_AT_KIND;
          slot->value.at.id = XS_NO_ID;
          slot->value.at.index = scratch.value.at.index;
        }
        else {
          txID id;
          mxSaveState;
          if (slot->kind == XS_STRING_X_KIND)
            id = fxNewNameX(the, slot->value.string);
          else
            id = fxNewName(the, slot);
          mxRestoreState;
          slot->kind = XS_AT_KIND;
          slot->value.at.id = id;
          slot->value.at.index = 0;
        }
      }
      mxNextCode(1);
      mxBreak;

    mxCase(XS_CODE_DELETE_SUPER_AT)
      variable = (mxStack + 1)->value.reference;
      offset = XS_NO_ID;
      index = 0;
      mxStack++;
      mxNextCode(1);
      goto XS_CODE_DELETE_SUPER_ALL;
    mxCase(XS_CODE_DELETE_SUPER)
      mxToInstance(mxStack);
      offset = mxRunID(1);
      index = 0;
      mxNextCode(1 + sizeof(txID));
      /* continue */
    XS_CODE_DELETE_SUPER_ALL: 
      mxRunDebugID(XS_REFERENCE_ERROR, "delete super.%s", (txID)offset);
      mxBreak;

    mxCase(XS_CODE_DELETE_PROPERTY_AT)
      variable = (mxStack + 1)->value.reference;
      offset = mxStack->value.at.id;
      index = mxStack->value.at.index;
      the->stack = mxStack;
      mxStack++;
      mxNextCode(1);
      goto XS_CODE_DELETE_PROPERTY_ALL;
    mxCase(XS_CODE_DELETE_PROPERTY)
      mxToInstance(mxStack);
      offset = mxRunID(1);
      index = 0;
      the->stack = mxStack;
      mxNextCode(1 + sizeof(txID));
      /* continue */
    XS_CODE_DELETE_PROPERTY_ALL:  
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, index);
#endif
      mxSaveStateKeepStack;
      index = (txU4)fxRunDelete(the, variable, (txID)offset, index);
      mxRestoreStateKeepStack;
      if (!index && (mxFrame->flag & XS_STRICT_FLAG))
        mxRunDebugID(XS_TYPE_ERROR, "delete %s: no permission (strict mode)", (txID)offset);
      mxStack->kind = XS_BOOLEAN_KIND;
      mxStack->value.boolean = index;
      mxBreak;
      
    mxCase(XS_CODE_GET_THIS_VARIABLE)
    mxCase(XS_CODE_GET_VARIABLE)
      mxToInstance(mxStack);
      offset = mxRunID(1);
      index = 0;
      mxNextCode(1 + sizeof(txID));
    #ifdef mxWithHasGetSequence
      if (variable->next && ((variable->next->ID == XS_ENVIRONMENT_BEHAVIOR) || (variable->next->ID == XS_GLOBAL_BEHAVIOR))) {
      }
      else {
              mxSaveState;
              index = fxRunHas(the, variable, (txID)offset, index);
              mxRestoreState;
        if (index == 0) {
          if (the->frame->flag & XS_STRICT_FLAG)
            mxRunDebugID(XS_REFERENCE_ERROR, "get %s: undefined property", (txID)offset);
          mxStack->kind = XS_UNDEFINED_KIND;
          mxBreak;
        }
        else 
          index = 0;
      }
    #endif
      slot = mxBehaviorGetProperty(the, variable, (txID)offset, index, XS_ANY);
      if (slot) {
        if (slot->kind < 0)
          mxRunDebugID(XS_REFERENCE_ERROR, "get %s: not initialized yet", (txID)offset);
      }
      else {
        if (byte != XS_CODE_TYPEOF)
          mxRunDebugID(XS_REFERENCE_ERROR, "get %s: undefined variable", (txID)offset);
      }
      goto XS_CODE_GET_ALL;
    mxCase(XS_CODE_GET_SUPER_AT)
      variable = (mxStack + 1)->value.super.reference;
      slot = (mxStack + 1)->value.super.prototype;
      offset = mxStack->value.at.id;
      index = mxStack->value.at.index;
      mxStack++;
      mxNextCode(1);
      goto XS_CODE_GET_SUPER_ALL;
    mxCase(XS_CODE_GET_SUPER)
      mxToInstance(mxStack);
      offset = mxRunID(1);
      index = 0;
      mxNextCode(1 + sizeof(txID));
      slot = mxFunctionInstanceHome(mxFrameFunction->value.reference);
      if (!slot->value.home.object)
        mxRunDebugID(XS_TYPE_ERROR, "get super.%s: no home", (txID)offset);
      slot = fxGetPrototype(the, slot->value.home.object);
      if (!slot)
        mxRunDebugID(XS_TYPE_ERROR, "get super.%s: no prototype", (txID)offset);
      /* continue */
    XS_CODE_GET_SUPER_ALL:  
      slot = mxBehaviorGetProperty(the, slot, (txID)offset, index, XS_ANY);
      goto XS_CODE_GET_ALL;
    mxCase(XS_CODE_GET_PRIVATE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_GET_PRIVATE;
    mxCase(XS_CODE_GET_PRIVATE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_GET_PRIVATE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = (mxEnvironment - index);
      mxToInstance(mxStack);
      offset = slot->ID;
      index = 0;
      if (slot->value.closure->kind < 0)
        mxRunDebugID(XS_TYPE_ERROR, "get %s: undefined private property", (txID)offset);
      slot = gxDefaults.getPrivateProperty(the, variable, slot->value.closure->value.reference, (txID)offset);
      if (!slot)
        mxRunDebugID(XS_TYPE_ERROR, "get %s: undefined private property", (txID)offset);
      goto XS_CODE_GET_ALL;
    mxCase(XS_CODE_GET_PROPERTY_AT)
      variable = (mxStack + 1)->value.reference;
      offset = mxStack->value.at.id;
      index = mxStack->value.at.index;
      mxStack++;
      mxNextCode(1);
      goto XS_CODE_GET_PROPERTY_ALL;
    mxCase(XS_CODE_GET_PROPERTY)
      mxToInstance(mxStack);
      offset = mxRunID(1);
      index = 0;
      mxNextCode(1 + sizeof(txID));
      /* continue */
    XS_CODE_GET_PROPERTY_ALL: 
      slot = mxBehaviorGetProperty(the, variable, (txID)offset, index, XS_ANY);
    XS_CODE_GET_ALL:  
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, index);
#endif
      if (!slot) {
        mxStack->kind = XS_UNDEFINED_KIND;
        mxBreak;
      }
      if (slot->kind == XS_ACCESSOR_KIND) {
        variable = slot->value.accessor.getter;
        if (!mxIsFunction(variable)) {
          mxStack->kind = XS_UNDEFINED_KIND;
          mxBreak;
        }
        mxAllocStack(3);
        slot = mxStack;
        mxInitSlotKind(slot++, XS_UNINITIALIZED_KIND);
        mxInitSlotKind(slot++, XS_UNDEFINED_KIND);
        slot->value.reference = variable;
        mxInitSlotKind(slot++, XS_REFERENCE_KIND);
        if (primitive) {
          variable = slot->value.reference->next;
          slot->value = variable->value;
          mxInitSlotKind(slot, variable->kind);
        }
        offset = 0;
        goto XS_CODE_RUN_ALL;
      }
      mxStack->kind = slot->kind;
      mxStack->value = slot->value;
      mxBreak;
      
    mxCase(XS_CODE_NEW_PRIVATE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_NEW_PRIVATE;
    mxCase(XS_CODE_NEW_PRIVATE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_NEW_PRIVATE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = (mxEnvironment - index);
      mxToInstance(mxStack + 1);
      offset = slot->ID;
      index = 0;
      slot = slot->value.closure->value.reference;
      the->stack = mxStack;
      goto XS_CODE_NEW_PROPERTY_ALL;
    mxCase(XS_CODE_NEW_PROPERTY_AT)
      mxToInstance(mxStack + 2);
      offset = (mxStack + 1)->value.at.id;
      index = (mxStack + 1)->value.at.index;
      slot = C_NULL;
      the->stack = mxStack;
      mxStack++;
      scratch = *(the->stack);
      *(the->stack) = *mxStack;
      *mxStack = scratch;
      mxNextCode(1);
      goto XS_CODE_NEW_PROPERTY_ALL;
    mxCase(XS_CODE_NEW_PROPERTY)
      mxToInstance(mxStack + 1);
      offset = mxRunID(1);
      index = 0;
      slot = C_NULL;
      the->stack = mxStack;
      mxNextCode(1 + sizeof(txID));
    XS_CODE_NEW_PROPERTY_ALL:
      byte = mxRunU1(1);
      mxSaveStateKeepStack;
      if (byte & XS_GETTER_FLAG) {
        mxStack->value.accessor.getter = fxToInstance(the, mxStack);
        mxStack->value.accessor.setter = C_NULL;
        mxStack->kind = XS_ACCESSOR_KIND;
      }
      else if (byte & XS_SETTER_FLAG) {
        mxStack->value.accessor.setter = fxToInstance(the, mxStack);
        mxStack->value.accessor.getter = C_NULL;
        mxStack->kind = XS_ACCESSOR_KIND;
      }
      mxStack->flag = byte & XS_GET_ONLY;
      index = fxRunDefine(the, variable, slot, (txID)offset, index, mxStack, byte | XS_GET_ONLY);
      mxRestoreStateKeepStack;
      mxStack += 2;
      if (!index)
        mxRunDebugID(XS_TYPE_ERROR, "set %s: const", (txID)offset);
      mxNextCode(2);
      mxBreak;
      
    mxCase(XS_CODE_SET_VARIABLE)
      mxToInstance(mxStack + 1);
      offset = mxRunID(1);
      index = 0;
      mxNextCode(1 + sizeof(txID));
      if (variable->next && (variable->next->ID == XS_ENVIRONMENT_BEHAVIOR)) {
        // nop
      }
      else {
              mxSaveState;
              index = fxRunHas(the, variable, (txID)offset, index);
              mxRestoreState;
        if (index == 0) {
          if (the->frame->flag & XS_STRICT_FLAG)
            mxRunDebugID(XS_REFERENCE_ERROR, "set %s: undefined property", (txID)offset);
        }
        else 
          index = 0;
      }
            mxSaveState;
      slot = mxBehaviorSetProperty(the, variable, (txID)offset, index, XS_ANY);
      mxRestoreState;
      if (slot && (slot->kind < 0))
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: not initialized yet", (txID)offset);
      goto XS_CODE_SET_ALL;
    mxCase(XS_CODE_SET_SUPER_AT)
      variable = (mxStack + 2)->value.super.reference;
      slot = (mxStack + 2)->value.super.prototype;
      offset = (mxStack + 1)->value.at.id;
      index = (mxStack + 1)->value.at.index;
      the->stack = mxStack;
      mxStack++;
      scratch = *(the->stack);
      *(the->stack) = *mxStack;
      *mxStack = scratch;
      mxNextCode(1);
      goto XS_CODE_SET_SUPER_ALL;
    mxCase(XS_CODE_SET_SUPER)
      mxToInstance(mxStack + 1);
      offset = mxRunID(1);
      index = 0;
      the->stack = mxStack;
      mxNextCode(1 + sizeof(txID));
      slot = mxFunctionInstanceHome(mxFrameFunction->value.reference);
      if (!slot->value.home.object)
        mxRunDebugID(XS_TYPE_ERROR, "set super.%s: no home", (txID)offset);
      slot = fxGetPrototype(the, slot->value.home.object);
      if (!slot)
        mxRunDebugID(XS_TYPE_ERROR, "set super.%s: no prototype", (txID)offset);
      /* continue */
    XS_CODE_SET_SUPER_ALL:
      slot = mxBehaviorGetProperty(the, slot, (txID)offset, index, XS_ANY);
      if (!slot || (slot->kind != XS_ACCESSOR_KIND)) {
        mxSaveStateKeepStack;
        slot = mxBehaviorSetProperty(the, variable, (txID)offset, index, XS_OWN);
        mxRestoreStateKeepStack;
      }
      goto XS_CODE_SET_ALL;
    mxCase(XS_CODE_SET_PRIVATE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_SET_PRIVATE;
    mxCase(XS_CODE_SET_PRIVATE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_SET_PRIVATE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = (mxEnvironment - index);
      mxToInstance(mxStack + 1);
      offset = slot->ID;
      index = 0;
      if (slot->value.closure->kind < 0)
        mxRunDebugID(XS_REFERENCE_ERROR, "set %s: undefined private property", (txID)offset);
      slot = gxDefaults.setPrivateProperty(the, variable, slot->value.closure->value.reference, (txID)offset);
      if (!slot)
        mxRunDebugID(XS_TYPE_ERROR, "set %s: undefined private property", (txID)offset);
      goto XS_CODE_SET_ALL;
    mxCase(XS_CODE_SET_PROPERTY_AT)
      variable = (mxStack + 2)->value.reference;
      offset = (mxStack + 1)->value.at.id;
      index = (mxStack + 1)->value.at.index;
      the->stack = mxStack;
      mxStack++;
      scratch = *(the->stack);
      *(the->stack) = *mxStack;
      *mxStack = scratch;
      mxNextCode(1);
      goto XS_CODE_SET_PROPERTY_ALL;
    mxCase(XS_CODE_SET_PROPERTY)
      mxToInstance(mxStack + 1);
      offset = mxRunID(1);
      index = 0;
      the->stack = mxStack;
      mxNextCode(1 + sizeof(txID));
      /* continue */
    XS_CODE_SET_PROPERTY_ALL: 
      mxSaveStateKeepStack;
      slot = mxBehaviorSetProperty(the, variable, (txID)offset, index, XS_ANY);
      mxRestoreStateKeepStack;
    XS_CODE_SET_ALL:  
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, index);
#endif
      if (!slot) {
        if (mxFrame->flag & XS_STRICT_FLAG) {
          mxRunDebugID(XS_TYPE_ERROR, "set %s: not extensible", (txID)offset);
        }
        goto XS_CODE_SET_SKIP;
      }
      if (slot->kind == XS_ACCESSOR_KIND) {
        variable = slot->value.accessor.setter;
        if (!mxIsFunction(variable)) {
          if (mxFrame->flag & XS_STRICT_FLAG) {
            mxRunDebugID(XS_TYPE_ERROR, "set %s: no setter", (txID)offset);
          }
          goto XS_CODE_SET_SKIP;
        }
        slot = mxStack;
        mxAllocStack(3);
        mxStack->value = slot->value;
        mxInitSlotKind(mxStack, slot->kind);
        slot = mxStack + 1;
        mxInitSlotKind(slot++, XS_UNINITIALIZED_KIND);
        slot->value = mxStack->value;
        mxInitSlotKind(slot++, mxStack->kind);
        slot->value.reference = variable;
        mxInitSlotKind(slot++, XS_REFERENCE_KIND);
        offset = 1;
        goto XS_CODE_RUN_ALL;
      }
      if (slot->flag & (XS_DONT_SET_FLAG | XS_MARK_FLAG)) {
        if (mxFrame->flag & XS_STRICT_FLAG) {
          mxRunDebugID(XS_TYPE_ERROR, "set %s: not writable", (txID)offset);
        }
        goto XS_CODE_SET_SKIP;
      }
      slot->kind = mxStack->kind;
      slot->value = mxStack->value;
    XS_CODE_SET_SKIP:
      *(mxStack + 1) = *mxStack;
      mxStack++;
      mxBreak;
      
    mxCase(XS_CODE_HAS_PRIVATE_2)
      index = mxRunU2(1);
      mxNextCode(3);
      goto XS_CODE_HAS_PRIVATE;
    mxCase(XS_CODE_HAS_PRIVATE_1)
      index = mxRunU1(1);
      mxNextCode(2);
    XS_CODE_HAS_PRIVATE:
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index - 1);
#endif
      slot = (mxEnvironment - index);
      if (mxStack->kind == XS_REFERENCE_KIND)
        variable = mxStack->value.reference; 
      else
        mxRunDebug(XS_TYPE_ERROR, "in: not an object");
      offset = slot->ID;
      index = 0;
      if (slot->value.closure->kind < 0)
        mxRunDebugID(XS_TYPE_ERROR, "get %s: undefined private property", (txID)offset);
      slot = gxDefaults.getPrivateProperty(the, variable, slot->value.closure->value.reference, (txID)offset);
      mxStack->kind = XS_BOOLEAN_KIND;
      mxStack->value.boolean = (slot) ? 1 : 0;
      mxBreak;
            
  /* INSTANCES */  
    mxCase(XS_CODE_ARRAY)
//      mxAllocStack(1);
      mxSaveState;
      fxNewArray(the, 0);
      mxRestoreState;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_CLASS)
      variable = fxToInstance(the, mxStack);
      slot = mxStack + 2;
      variable->flag |= XS_CAN_CONSTRUCT_FLAG;
      if (slot->kind == XS_NULL_KIND)
        variable->next->flag |= XS_BASE_FLAG;
      else {
        variable->next->flag |= XS_DERIVED_FLAG;
        variable->value.instance.prototype = slot->value.reference;
      }
      slot = mxStack + 1;
      mxFunctionInstanceHome(variable)->value.home.object = slot->value.reference;
      mxSaveState;
      slot->flag = XS_GET_ONLY;
      fxRunDefine(the, variable, C_NULL, mxID(_prototype), 0, slot, XS_GET_ONLY);
      slot = mxBehaviorSetProperty(the, slot->value.reference, mxID(_constructor), 0, XS_OWN);
      mxRestoreState;
      slot->flag |= XS_DONT_ENUM_FLAG;
      slot->kind = mxStack->kind;
      slot->value = mxStack->value;
      mxStack += 3;
            mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_COPY_OBJECT)
      mxNextCode(1);
      mxAllocStack(1);
      *mxStack = mxCopyObjectFunction;
      mxBreak;
    mxCase(XS_CODE_EXTEND)
      if (mxStack->kind == XS_NULL_KIND) {
        mxSaveState;
        fxNewInstance(the);
        mxRestoreState;
      }
      else {
        mxSaveState;
        fxRunExtends(the);
        mxRestoreState;
      }
            mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_GLOBAL)
      mxPushKind(XS_REFERENCE_KIND);
      variable = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
      variable = mxModuleInstanceInternal(variable)->value.module.realm;
      if (!variable) variable = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
      mxStack->value.reference = mxRealmGlobal(variable)->value.reference;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_HOST)
      index = mxRunU2(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceIndex(the, index);
#endif
      mxAllocStack(1);
      variable = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
      variable = mxModuleInstanceHosts(variable);
      *mxStack = *variable;
      slot = mxBehaviorGetProperty(the, mxStack->value.reference, 0, index, XS_OWN);
      mxStack->kind = slot->kind;
      mxStack->value = slot->value;
      mxNextCode(3);
      mxBreak;
    mxCase(XS_CODE_INSTANTIATE)
      mxSaveState;
      fxRunInstantiate(the);
      mxRestoreState;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_CALL)
      mxNextCode(1);
      mxAllocStack(2);
      slot = mxStack;
      mxInitSlotKind(slot++, XS_UNINITIALIZED_KIND);
      mxInitSlotKind(slot, XS_UNDEFINED_KIND);
      mxBreak;
    mxCase(XS_CODE_NEW)
      mxNextCode(1);
      variable = mxStack;
      mxAllocStack(4);
      slot = mxStack;
      mxInitSlotKind(slot++, XS_UNINITIALIZED_KIND);
      mxInitSlotKind(slot++, XS_UNDEFINED_KIND);
      slot->value = variable->value;
      mxInitSlotKind(slot++, variable->kind);
      mxInitSlotKind(slot, XS_UNINITIALIZED_KIND);
      mxBreak;
    mxCase(XS_CODE_OBJECT)
//      mxAllocStack(1);
      mxSaveState;
      fxNewObject(the);
      mxRestoreState;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_REGEXP)
      mxNextCode(1);
      mxAllocStack(1);
      *mxStack = mxRegExpConstructor;
      mxBreak;
    mxCase(XS_CODE_SUPER)
      mxNextCode(1);
      variable = mxFrameFunction->value.reference;
            if (mxIsConstructor(variable))
        variable = fxGetPrototype(the, variable);
      else {
        variable = mxFunctionInstanceHome(variable);
        variable = mxBehaviorGetProperty(the, variable->value.home.object, mxID(_constructor), 0, XS_ANY);
        variable = fxGetPrototype(the, variable->value.reference);
      }
            if (!mxIsConstructor(variable))
        mxRunDebug(XS_TYPE_ERROR, "super: not a constructor");
      mxAllocStack(5);
      slot = mxStack;
      mxInitSlotKind(slot++, XS_UNINITIALIZED_KIND);
      mxInitSlotKind(slot++, XS_UNDEFINED_KIND);
      slot->value.reference = variable;
      mxInitSlotKind(slot++, XS_REFERENCE_KIND);
      mxInitSlotKind(slot++, XS_UNINITIALIZED_KIND);
      if (mxFrameHasTarget) {
        slot->value = mxFrameTarget->value;
        mxInitSlotKind(slot, mxFrameTarget->kind);
      }
      else
        mxInitSlotKind(slot, XS_UNDEFINED_KIND);
      mxBreak;
    mxCase(XS_CODE_TEMPLATE)
      mxNextCode(1);
      variable = mxStack->value.reference;
      slot = mxBehaviorGetProperty(the, variable, mxID(_raw), 0, XS_OWN);
            if (!slot)
        mxRunDebug(XS_TYPE_ERROR, "template: no raw");
      variable->flag |= XS_DONT_PATCH_FLAG;
      variable->next->flag |= XS_DONT_SET_FLAG;
      slot->flag |= XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG;
      variable = slot->value.reference;
      variable->flag |= XS_DONT_PATCH_FLAG;
      variable->next->flag |= XS_DONT_SET_FLAG;
      mxBreak;
    mxCase(XS_CODE_TEMPLATE_CACHE)
      mxNextCode(1);
            variable = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
            variable = mxModuleInstanceInternal(variable)->value.module.realm;
            if (!variable) variable = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
            slot = mxRealmTemplateCache(variable);
      mxPushKind(XS_REFERENCE_KIND);
      mxStack->value.reference = slot->value.reference;
      mxBreak;
      
  /* FUNCTIONS */    
    mxCase(XS_CODE_ASYNC_FUNCTION)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxAllocStack(1);
      *mxStack = mxAsyncFunctionPrototype;
      mxSaveState;
      fxNewFunctionInstance(the, (txID)offset);
      mxRestoreState;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_ASYNC_GENERATOR_FUNCTION)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxAllocStack(1);
      *mxStack = mxAsyncGeneratorFunctionPrototype;
      mxSaveState;
      gxDefaults.newAsyncGeneratorFunctionInstance(the,(txID) offset);
      mxRestoreState;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_CONSTRUCTOR_FUNCTION)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxAllocStack(1);
      *mxStack = mxFunctionPrototype;
      mxSaveState;
      fxNewFunctionInstance(the, (txID)offset);
      fxDefaultFunctionPrototype(the);
      mxRestoreState;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_FUNCTION)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxAllocStack(1);
      *mxStack = mxFunctionPrototype;
      mxSaveState;
      fxNewFunctionInstance(the, (txID)offset);
      mxRestoreState;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_GENERATOR_FUNCTION)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxAllocStack(1);
      *mxStack = mxGeneratorFunctionPrototype;
      mxSaveState;
      gxDefaults.newGeneratorFunctionInstance(the,(txID) offset);
      mxRestoreState;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_PROFILE)
      offset = mxRunID(1);
      variable = mxFunctionInstanceHome(mxStack->value.reference);
      variable->ID = offset;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_NAME)
      offset = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
#endif
      mxSaveState;
      fxRenameFunction(the, mxStack->value.reference, (txID)offset, 0, XS_NO_ID, C_NULL);
      mxRestoreState;
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_SET_HOME)
      slot = mxFunctionInstanceHome((mxStack + 1)->value.reference);
      slot->value.home.object = mxStack->value.reference;
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_CODE_4)
      offset = mxRunS4(1);
      mxSkipCode(5);
      goto XS_CODE_CODE;
    mxCase(XS_CODE_CODE_2)
      offset = mxRunS2(1);
      mxSkipCode(3);
      goto XS_CODE_CODE;
    mxCase(XS_CODE_CODE_1)
      offset = mxRunS1(1);
      mxSkipCode(2);
    XS_CODE_CODE:
      mxSaveState;
      scratch.value.code.address = (txByte*)fxNewChunk(the, (txSize)offset);
      mxRestoreState;
      c_memcpy(scratch.value.code.address, mxCode, offset);
      variable = mxStack->value.reference;
      slot = mxFunctionInstanceCode(variable);
      slot->kind = XS_CODE_KIND;
      slot->value.code.address = scratch.value.code.address;
      if (gxDefaults.newFunctionLength) {
        gxDefaults.newFunctionLength(the, variable, *(((txU1*)scratch.value.code.address + 1)));
      }
      mxNextCode(offset);
      mxBreak;
    mxCase(XS_CODE_CODE_ARCHIVE_4)
      offset = mxRunS4(1);
      mxSkipCode(5);
      goto XS_CODE_CODE_ARCHIVE;
    mxCase(XS_CODE_CODE_ARCHIVE_2)
      offset = mxRunS2(1);
      mxSkipCode(3);
      goto XS_CODE_CODE_ARCHIVE;
    mxCase(XS_CODE_CODE_ARCHIVE_1)
      offset = mxRunS1(1);
      mxSkipCode(2);
    XS_CODE_CODE_ARCHIVE:
      variable = mxStack->value.reference;
      slot = mxFunctionInstanceCode(variable);
      slot->kind = XS_CODE_X_KIND;
      slot->value.code.address = mxCode;
      if (gxDefaults.newFunctionLength) {
        gxDefaults.newFunctionLength(the, variable, mxRunU1(1));
      }
      mxNextCode(offset);
      mxBreak;

  /* VALUES */    
    mxCase(XS_CODE_UNDEFINED)
      mxPushKind(XS_UNDEFINED_KIND);
      mxNextCode(1);
      mxBreak; 
    mxCase(XS_CODE_NULL)
      mxPushKind(XS_NULL_KIND);
      mxNextCode(1);
      mxBreak; 
    mxCase(XS_CODE_FALSE)
      mxPushKind(XS_BOOLEAN_KIND);
      mxStack->value.boolean = 0;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_TRUE)
      mxPushKind(XS_BOOLEAN_KIND);
      mxStack->value.boolean = 1;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_INTEGER_1)
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxRunS1(1);
      mxNextCode(2);
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, mxStack->value.integer);
#endif
      mxBreak;
    mxCase(XS_CODE_INTEGER_2)
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxRunS2(1);
      mxNextCode(3);
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, mxStack->value.integer);
#endif
      mxBreak;
    mxCase(XS_CODE_INTEGER_4)
      mxPushKind(XS_INTEGER_KIND);
      mxStack->value.integer = mxRunS4(1);
      mxNextCode(5);
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, mxStack->value.integer);
#endif
      mxBreak;
    mxCase(XS_CODE_NUMBER)
      mxPushKind(XS_NUMBER_KIND);
      {
        txByte* number = (txByte*)&(mxStack->value.number);
      #if mxBigEndian
        number[7] = mxCode[1];
        number[6] = mxCode[2];
        number[5] = mxCode[3];
        number[4] = mxCode[4];
        number[3] = mxCode[5];
        number[2] = mxCode[6];
        number[1] = mxCode[7];
        number[0] = mxCode[8];
      #else
        number[0] = mxCode[1];
        number[1] = mxCode[2];
        number[2] = mxCode[3];
        number[3] = mxCode[4];
        number[4] = mxCode[5];
        number[5] = mxCode[6];
        number[6] = mxCode[7];
        number[7] = mxCode[8];
      #endif
      }
      mxNextCode(9);
#ifdef mxTrace
      if (gxDoTrace) fxTraceNumber(the, mxStack->value.number);
#endif
      mxBreak;
      
    mxCase(XS_CODE_STRING_4)
      index = mxRunS4(1);
      mxSkipCode(5);
      goto XS_CODE_STRING;
    mxCase(XS_CODE_STRING_2)
      index = mxRunU2(1);
      mxSkipCode(3);
      goto XS_CODE_STRING;
    mxCase(XS_CODE_STRING_1)
      index = mxRunU1(1);
      mxSkipCode(2);
    XS_CODE_STRING:
      mxSaveState;
      scratch.value.string = (txString)fxNewChunk(the, index);
      mxRestoreState;
      c_memcpy(scratch.value.string, mxCode, index);
      mxPushKind(XS_STRING_KIND);
      mxStack->value.string = scratch.value.string;
      mxNextCode(index);
#ifdef mxTrace
      if (gxDoTrace) fxTraceString(the, mxStack->value.string);
#endif
      mxBreak;
    mxCase(XS_CODE_STRING_ARCHIVE_4)
      index = mxRunS4(1);
      mxSkipCode(5);
      goto XS_CODE_STRING_ARCHIVE;
    mxCase(XS_CODE_STRING_ARCHIVE_2)
      index = mxRunU2(1);
      mxSkipCode(3);
      goto XS_CODE_STRING_ARCHIVE;
    mxCase(XS_CODE_STRING_ARCHIVE_1)
      index = mxRunU1(1);
      mxSkipCode(2);
    XS_CODE_STRING_ARCHIVE:
      mxPushKind(XS_STRING_X_KIND);
      mxStack->value.string = (txString)mxCode;
      mxNextCode(index);
#ifdef mxTrace
      if (gxDoTrace) fxTraceString(the, mxStack->value.string);
#endif
      mxBreak;
    mxCase(XS_CODE_TO_STRING)
      mxToString(mxStack);
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_SYMBOL)
      mxPushKind(XS_SYMBOL_KIND);
      mxStack->value.symbol = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, mxStack->value.symbol, 0);
#endif
      mxNextCode(1 + sizeof(txID));
      mxBreak;
      
    mxCase(XS_CODE_BIGINT_2)
      index = mxRunU2(1);
      mxSkipCode(3);
      goto XS_CODE_BIGINT;
    mxCase(XS_CODE_BIGINT_1)
      index = mxRunU1(1);
      mxSkipCode(2);
    XS_CODE_BIGINT:
      mxSaveState;
      gxTypeBigInt.decode(the, index);
      mxRestoreState;
      mxNextCode(index);
      mxBreak;

  /* EXPRESSIONS */ 
    mxCase(XS_CODE_BIT_NOT)
      if (mxStack->kind == XS_INTEGER_KIND)
        mxStack->value.integer = ~mxStack->value.integer;
      else if (mxStack->kind == XS_NUMBER_KIND) {
        mxStack->kind = XS_INTEGER_KIND;
        mxStack->value.integer = ~fxNumberToInteger(mxStack->value.number);
        mxFloatingPointOp("not");
      }
      else {
        mxSaveState;
        if (fxToNumericIntegerUnary(the, mxStack, gxTypeBigInt._not))
          mxStack->value.integer = ~mxStack->value.integer;
        mxRestoreState;
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_BIT_AND)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.integer &= mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.integer &= fxNumberToInteger(mxStack->value.number);
          mxFloatingPointOp("and");
        }
        else
          goto XS_CODE_BIT_AND_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) & mxStack->value.integer;
          mxFloatingPointOp("and");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) & fxNumberToInteger(mxStack->value.number);
          mxFloatingPointOp("and");
        }
        else
          goto XS_CODE_BIT_AND_GENERAL;
      }
      else {
    XS_CODE_BIT_AND_GENERAL:
        mxSaveState;
        if (fxToNumericIntegerBinary(the, slot, mxStack, gxTypeBigInt._and))
          slot->value.integer &= mxStack->value.integer;
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_BIT_OR)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.integer |= mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.integer |= fxNumberToInteger(mxStack->value.number);
          mxFloatingPointOp("or");
        }
        else
          goto XS_CODE_BIT_OR_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) | mxStack->value.integer;
          mxFloatingPointOp("or");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) | fxNumberToInteger(mxStack->value.number);
          mxFloatingPointOp("or");
        }
        else
          goto XS_CODE_BIT_OR_GENERAL;
      }
      else {
    XS_CODE_BIT_OR_GENERAL:
        mxSaveState;
        if (fxToNumericIntegerBinary(the, slot, mxStack, gxTypeBigInt._or))
          slot->value.integer |= mxStack->value.integer;
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_BIT_XOR)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.integer ^= mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.integer ^= fxNumberToInteger(mxStack->value.number);
          mxFloatingPointOp("xor");
        }
        else
          goto XS_CODE_BIT_XOR_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) ^ mxStack->value.integer;
          mxFloatingPointOp("xor");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) ^ fxNumberToInteger(mxStack->value.number);
          mxFloatingPointOp("xor");
        }
        else
          goto XS_CODE_BIT_XOR_GENERAL;
      }
      else {
    XS_CODE_BIT_XOR_GENERAL:
        mxSaveState;
        if (fxToNumericIntegerBinary(the, slot, mxStack, gxTypeBigInt._xor))
          slot->value.integer ^= mxStack->value.integer;
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_LEFT_SHIFT)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.integer = (txInteger)(((txUnsigned)slot->value.integer) << (mxStack->value.integer & 0x1f));
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.integer = (txInteger)(((txUnsigned)slot->value.integer) << (fxNumberToInteger(mxStack->value.number) & 0x1f));
          mxFloatingPointOp("left shift");
        }
        else
          goto XS_CODE_LEFT_SHIFT_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = (txInteger)(((txUnsigned)fxNumberToInteger(slot->value.number)) << (mxStack->value.integer & 0x1f));
          mxFloatingPointOp("left shift");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = (txInteger)(((txUnsigned)fxNumberToInteger(slot->value.number)) << (fxNumberToInteger(mxStack->value.number) & 0x1f));
          mxFloatingPointOp("left shift");
        }
        else
          goto XS_CODE_LEFT_SHIFT_GENERAL;
      }
      else {
    XS_CODE_LEFT_SHIFT_GENERAL:
        mxSaveState;
        if (fxToNumericIntegerBinary(the, slot, mxStack, gxTypeBigInt._lsl))
          slot->value.integer = (txInteger)(((txUnsigned)slot->value.integer) << (mxStack->value.integer & 0x1f));
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_SIGNED_RIGHT_SHIFT)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.integer >>= mxStack->value.integer & 0x1f;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.integer >>= fxNumberToInteger(mxStack->value.number) & 0x1f;
          mxFloatingPointOp("signed right shift");
        }
        else
          goto XS_CODE_SIGNED_RIGHT_SHIFT_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) >> (mxStack->value.integer & 0x1f);
          mxFloatingPointOp("signed right shift");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_INTEGER_KIND;
          slot->value.integer = fxNumberToInteger(slot->value.number) >> (fxNumberToInteger(mxStack->value.number) & 0x1f);
          mxFloatingPointOp("signed right shift");
        }
        else
          goto XS_CODE_SIGNED_RIGHT_SHIFT_GENERAL;
      }
      else {
    XS_CODE_SIGNED_RIGHT_SHIFT_GENERAL:
        mxSaveState;
        if (fxToNumericIntegerBinary(the, slot, mxStack, gxTypeBigInt._lsr))
          slot->value.integer >>= mxStack->value.integer & 0x1f;
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_UNSIGNED_RIGHT_SHIFT)
      slot = mxStack + 1;
      if (((slot->kind == XS_INTEGER_KIND) || (slot->kind == XS_NUMBER_KIND)) && ((mxStack->kind == XS_INTEGER_KIND) || (mxStack->kind == XS_NUMBER_KIND))) {
        fxUnsigned(the, slot, fxToUnsigned(the, slot) >> (fxToUnsigned(the, mxStack) & 0x1F));
      }
      else {
        mxSaveState;
        if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._nop))
          fxUnsigned(the, slot, fxToUnsigned(the, slot) >> (fxToUnsigned(the, mxStack) & 0x1F));
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
        
    mxCase(XS_CODE_MINUS)
      if (mxStack->kind == XS_INTEGER_KIND) {
        if (mxStack->value.integer & 0x7FFFFFFF)
          mxStack->value.integer = -mxStack->value.integer;
        else {
          mxStack->kind = XS_NUMBER_KIND;
          mxStack->value.number = -((txNumber)(mxStack->value.integer));
          mxFloatingPointOp("minus");
        }
      }
      else if (mxStack->kind == XS_NUMBER_KIND) {
        mxStack->value.number = -mxStack->value.number;
        mxFloatingPointOp("minus");
      }
      else {
        mxSaveState;
        if (fxToNumericNumberUnary(the, mxStack, gxTypeBigInt._neg)) {
          mxStack->value.number = -mxStack->value.number;
          mxFloatingPointOp("minus");
        }
        mxRestoreState;
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_PLUS)
      if (mxStack->kind != XS_INTEGER_KIND) {
        mxToNumber(mxStack);
      }
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_TO_NUMERIC)
      if ((mxStack->kind != XS_INTEGER_KIND) && (mxStack->kind != XS_NUMBER_KIND)) {
        mxSaveState;
        fxToNumericNumber(the, mxStack);
        mxRestoreState;
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_DECREMENT)
      if (mxStack->kind == XS_INTEGER_KIND) {
        if (mxStack->value.integer != -2147483647)
          mxStack->value.integer--;
        else {
          mxStack->kind = XS_NUMBER_KIND;
          mxStack->value.number = mxStack->value.integer;
          mxStack->value.number--;
          mxFloatingPointOp("decrement");
        }
      }
      else if (mxStack->kind == XS_NUMBER_KIND) {
        mxStack->value.number--;
        mxFloatingPointOp("decrement");
      }
      else {
        mxSaveState;
        if (fxToNumericNumberUnary(the, mxStack, gxTypeBigInt._dec)) {
          mxStack->value.number--;
          mxFloatingPointOp("decrement");
        }
        mxRestoreState;
      }
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_INCREMENT)
      if (mxStack->kind == XS_INTEGER_KIND) {
        if (mxStack->value.integer != 2147483647)
          mxStack->value.integer++;
        else {
          mxStack->kind = XS_NUMBER_KIND;
          mxStack->value.number = mxStack->value.integer;
          mxStack->value.number++;
          mxFloatingPointOp("increment");
        }
      }
      else if (mxStack->kind == XS_NUMBER_KIND) {
        mxStack->value.number++;
        mxFloatingPointOp("increment");
      }
      else {
        mxSaveState;
        if (fxToNumericNumberUnary(the, mxStack, gxTypeBigInt._inc)) {
          mxStack->value.number++;
          mxFloatingPointOp("increment");
        }
        mxRestoreState;
      }
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_ADD)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          #if __has_builtin(__builtin_add_overflow)
            if (__builtin_add_overflow(slot->value.integer, mxStack->value.integer, &scratch.value.integer)) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = (txNumber)(slot->value.integer) + (txNumber)(mxStack->value.integer);
              mxFloatingPointOp("add");
            }
            else
              slot->value.integer = scratch.value.integer;
          #else
            txInteger a = slot->value.integer;
            txInteger b = mxStack->value.integer;
            txInteger c = a + b;
            if (((a ^ c) & (b ^ c)) < 0) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = (txNumber)(slot->value.integer) + (txNumber)(mxStack->value.integer);
              mxFloatingPointOp("add");
            }
            else
              slot->value.integer = c;
          #endif
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = (txNumber)(slot->value.integer) + mxStack->value.number;
          mxFloatingPointOp("add");
        }
        else
          goto XS_CODE_ADD_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->value.number += (txNumber)(mxStack->value.integer);
          mxFloatingPointOp("add");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.number += mxStack->value.number;
          mxFloatingPointOp("add");
        }
        else
          goto XS_CODE_ADD_GENERAL;
      }
      else {
    XS_CODE_ADD_GENERAL:
        mxSaveState;
        fxToPrimitive(the, slot, XS_NO_HINT);
        fxToPrimitive(the, mxStack, XS_NO_HINT);
        if ((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND) || (mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND)) {
          fxToString(the, slot);
          fxToString(the, mxStack);
          fxConcatString(the, slot, mxStack);
        }
        else {
          if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._add)) {
            slot->value.number += mxStack->value.number;
            mxFloatingPointOp("add");
          }
        }
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_SUBTRACT)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          #if __has_builtin(__builtin_sub_overflow)
            if (__builtin_sub_overflow(slot->value.integer, mxStack->value.integer, &scratch.value.integer)) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = (txNumber)(slot->value.integer) - (txNumber)(mxStack->value.integer);
              mxFloatingPointOp("subtract");
            }
            else
              slot->value.integer = scratch.value.integer;
          #else
            txInteger a = slot->value.integer;
            txInteger b = -mxStack->value.integer;
            txInteger c = a + b;
            if (((a ^ c) & (b ^ c)) < 0) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = (txNumber)(slot->value.integer) - (txNumber)(mxStack->value.integer);
              mxFloatingPointOp("subtract");
            }
            else
              slot->value.integer = c;
          #endif
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = (txNumber)(slot->value.integer) - mxStack->value.number;
          mxFloatingPointOp("subtract");
        }
        else
          goto XS_CODE_SUBTRACT_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->value.number -= (txNumber)(mxStack->value.integer);
          mxFloatingPointOp("subtract");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.number -= mxStack->value.number;
          mxFloatingPointOp("subtract");
        }
        else
          goto XS_CODE_SUBTRACT_GENERAL;
      }
      else {
    XS_CODE_SUBTRACT_GENERAL:
        mxSaveState;
        if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._sub)) {
          slot->value.number -= mxStack->value.number;
          mxFloatingPointOp("subtract");
        }
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_DIVIDE)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = (txNumber)(slot->value.integer) / (txNumber)(mxStack->value.integer);
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = (txNumber)(slot->value.integer) / mxStack->value.number;
        }
        else
          goto XS_CODE_DIVIDE_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.number /= (txNumber)(mxStack->value.integer);
        else if (mxStack->kind == XS_NUMBER_KIND)
          slot->value.number /= mxStack->value.number;
        else
          goto XS_CODE_DIVIDE_GENERAL;
      }
      else {
    XS_CODE_DIVIDE_GENERAL:
        mxSaveState;
        if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._div))
          slot->value.number /= mxStack->value.number;
        mxRestoreState;
      }
      mxFloatingPointOp("divide");
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_EXPONENTIATION)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = fx_pow((txNumber)(slot->value.integer), (txNumber)(mxStack->value.integer));
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = fx_pow((txNumber)(slot->value.integer), mxStack->value.number);
        }
        else
          goto XS_CODE_EXPONENTIATION_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          slot->value.number = fx_pow(slot->value.number, (txNumber)(mxStack->value.integer));
        else if (mxStack->kind == XS_NUMBER_KIND)
          slot->value.number = fx_pow(slot->value.number, mxStack->value.number);
        else
          goto XS_CODE_EXPONENTIATION_GENERAL;
      }
      else {
    XS_CODE_EXPONENTIATION_GENERAL:
        mxSaveState;
        if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._exp))
          slot->value.number = fx_pow(slot->value.number, mxStack->value.number);
        mxRestoreState;
      }
      mxFloatingPointOp("exponent");
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_MULTIPLY)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
        #ifdef mxMinusZero
          if (slot->value.integer == 0) {
            if (mxStack->value.integer < 0) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = -0.0;
            }
          }
          else if (mxStack->value.integer == 0) {
            if (slot->value.integer < 0) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = -0.0;
            }
            else
              slot->value.integer = 0;
          }
          else {
        #endif
          #if __has_builtin(__builtin_mul_overflow)
            if (__builtin_mul_overflow(slot->value.integer, mxStack->value.integer, &scratch.value.integer)) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = (txNumber)(slot->value.integer) * (txNumber)(mxStack->value.integer);
              mxFloatingPointOp("multiply");
            }
            else
              slot->value.integer = scratch.value.integer;
          #else
            slot->kind = XS_NUMBER_KIND;
            slot->value.number = (txNumber)(slot->value.integer) * (txNumber)(mxStack->value.integer);
            mxFloatingPointOp("multiply");
          #endif
        #ifdef mxMinusZero
          }
        #endif
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = (txNumber)(slot->value.integer) * mxStack->value.number;
          mxFloatingPointOp("multiply");
        }
        else
          goto XS_CODE_MULTIPLY_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->value.number *= (txNumber)(mxStack->value.integer);
          mxFloatingPointOp("multiply");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.number *= mxStack->value.number;
          mxFloatingPointOp("multiply");
        }
        else
          goto XS_CODE_MULTIPLY_GENERAL;
      }
      else {
    XS_CODE_MULTIPLY_GENERAL:
        mxSaveState;
        if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._mul))
          slot->value.number *= mxStack->value.number;
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_MODULO)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          if (mxStack->value.integer == 0) {
            slot->kind = XS_NUMBER_KIND;
            slot->value.number = C_NAN;
          }
        #if mxIntegerDivideOverflowException
          else if ((-1 == mxStack->value.integer) && ((txInteger)0x80000000 == slot->value.integer)) {
            slot->kind = XS_NUMBER_KIND;
            slot->value.number = -0.0;
          }
        #endif 
        #ifdef mxMinusZero
          else if (slot->value.integer < 0) {
            slot->value.integer %= mxStack->value.integer;
            if (slot->value.integer == 0) {
              slot->kind = XS_NUMBER_KIND;
              slot->value.number = -0.0;
            }
          }
        #endif
          else
            slot->value.integer %= mxStack->value.integer;
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->kind = XS_NUMBER_KIND;
          slot->value.number = c_fmod((txNumber)(slot->value.integer), mxStack->value.number);
          mxFloatingPointOp("modulo");
        }
        else
          goto XS_CODE_MODULO_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          slot->value.number = c_fmod(slot->value.number, (txNumber)(mxStack->value.integer));
          mxFloatingPointOp("modulo");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          slot->value.number = c_fmod(slot->value.number, mxStack->value.number);
          mxFloatingPointOp("modulo");
        }
        else
          goto XS_CODE_MODULO_GENERAL;
      }
      else {
    XS_CODE_MODULO_GENERAL:
        mxSaveState;
        if (fxToNumericNumberBinary(the, slot, mxStack, gxTypeBigInt._rem)) {
          slot->value.number = c_fmod(slot->value.number, mxStack->value.number);
          mxFloatingPointOp("modulo");
        }
        mxRestoreState;
      }
      mxStack++;
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_NOT)
      mxToBoolean(mxStack);
      mxStack->value.boolean = !mxStack->value.boolean;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_LESS)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          offset = slot->value.integer < mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND)  {
          offset = (!c_isnan(mxStack->value.number)) && ((txNumber)(slot->value.integer) < mxStack->value.number);
          mxFloatingPointOp("less");
        }
        else
          goto XS_CODE_LESS_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (slot->value.number < (txNumber)(mxStack->value.integer));
          mxFloatingPointOp("less");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number < mxStack->value.number);
          mxFloatingPointOp("less");
        }
        else
          goto XS_CODE_LESS_GENERAL;
      }
      else {
    XS_CODE_LESS_GENERAL:
        mxSaveState; 
        fxToPrimitive(the, slot, XS_NUMBER_HINT); 
        fxToPrimitive(the, mxStack, XS_NUMBER_HINT); 
        if (((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND)))
          offset = fxUTF8Compare(slot->value.string, mxStack->value.string) < 0;
        else if ((slot->kind == XS_BIGINT_KIND) || (slot->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 1, 0, 0, slot, mxStack);
        else if ((mxStack->kind == XS_BIGINT_KIND) || (mxStack->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 0, 0, 1, mxStack, slot);
        else {
          fxToNumber(the, slot);
          fxToNumber(the, mxStack);
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number < mxStack->value.number);
          mxFloatingPointOp("less");
        }
        mxRestoreState;
      }
      slot->kind = XS_BOOLEAN_KIND;
      slot->value.boolean = offset;
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_LESS_EQUAL)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          offset = slot->value.integer <= mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(mxStack->value.number)) && ((txNumber)(slot->value.integer) <= mxStack->value.number);
          mxFloatingPointOp("less or equal");
        }
        else
          goto XS_CODE_LESS_EQUAL_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (slot->value.number <= (txNumber)(mxStack->value.integer));
          mxFloatingPointOp("less or equal");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number <= mxStack->value.number);
          mxFloatingPointOp("less or equal");
        }
        else
          goto XS_CODE_LESS_EQUAL_GENERAL;
      }
      else {
    XS_CODE_LESS_EQUAL_GENERAL:
        mxSaveState; 
        fxToPrimitive(the, slot, XS_NUMBER_HINT); 
        fxToPrimitive(the, mxStack, XS_NUMBER_HINT); 
        if (((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND)))
          offset = fxUTF8Compare(slot->value.string, mxStack->value.string) <= 0;
        else if ((slot->kind == XS_BIGINT_KIND) || (slot->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 1, 1, 0, slot, mxStack);
        else if ((mxStack->kind == XS_BIGINT_KIND) || (mxStack->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 0, 1, 1, mxStack, slot);
        else {
          fxToNumber(the, slot);
          fxToNumber(the, mxStack);
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number <= mxStack->value.number);
          mxFloatingPointOp("less or equal");
        }
        mxRestoreState;
      }
      slot->kind = XS_BOOLEAN_KIND;
      slot->value.boolean = offset;
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_MORE)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          offset = slot->value.integer > mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(mxStack->value.number)) && ((txNumber)(slot->value.integer) > mxStack->value.number);
          mxFloatingPointOp("more");
        }
        else
          goto XS_CODE_MORE_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (slot->value.number > (txNumber)(mxStack->value.integer));
          mxFloatingPointOp("more");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number > mxStack->value.number);
          mxFloatingPointOp("more");
        }
        else
          goto XS_CODE_MORE_GENERAL;
      }
      else {
    XS_CODE_MORE_GENERAL:
        mxSaveState; 
        fxToPrimitive(the, slot, XS_NUMBER_HINT); 
        fxToPrimitive(the, mxStack, XS_NUMBER_HINT); 
        if (((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND)))
          offset = fxUTF8Compare(slot->value.string, mxStack->value.string) > 0;
        else if ((slot->kind == XS_BIGINT_KIND) || (slot->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 0, 0, 1, slot, mxStack);
        else if ((mxStack->kind == XS_BIGINT_KIND) || (mxStack->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 1, 0, 0, mxStack, slot);
        else {
          fxToNumber(the, slot);
          fxToNumber(the, mxStack);
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number > mxStack->value.number);
          mxFloatingPointOp("more");
        }
        mxRestoreState;
      }
      slot->kind = XS_BOOLEAN_KIND;
      slot->value.boolean = offset;
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_MORE_EQUAL)
      slot = mxStack + 1;
      if (slot->kind == XS_INTEGER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND)
          offset = slot->value.integer >= mxStack->value.integer;
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(mxStack->value.number)) && ((txNumber)(slot->value.integer) >= mxStack->value.number);
          mxFloatingPointOp("more or equal");
        }
        else
          goto XS_CODE_MORE_EQUAL_GENERAL;
      }
      else if (slot->kind == XS_NUMBER_KIND) {
        if (mxStack->kind == XS_INTEGER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (slot->value.number >= (txNumber)(mxStack->value.integer));
          mxFloatingPointOp("more or equal");
        }
        else if (mxStack->kind == XS_NUMBER_KIND) {
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number >= mxStack->value.number);
          mxFloatingPointOp("more or equal");
        }
        else
          goto XS_CODE_MORE_EQUAL_GENERAL;
      }
      else {
    XS_CODE_MORE_EQUAL_GENERAL:
        mxSaveState; 
        fxToPrimitive(the, slot, XS_NUMBER_HINT); 
        fxToPrimitive(the, mxStack, XS_NUMBER_HINT); 
        if (((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND)))
          offset = fxUTF8Compare(slot->value.string, mxStack->value.string) >= 0;
        else if ((slot->kind == XS_BIGINT_KIND) || (slot->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 0, 1, 1, slot, mxStack);
        else if ((mxStack->kind == XS_BIGINT_KIND) || (mxStack->kind == XS_BIGINT_X_KIND))
          offset = gxTypeBigInt.compare(the, 1, 1, 0, mxStack, slot);
        else {
          fxToNumber(the, slot);
          fxToNumber(the, mxStack);
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number >= mxStack->value.number);
          mxFloatingPointOp("more or equal");
        }
        mxRestoreState;
      }
      slot->kind = XS_BOOLEAN_KIND;
      slot->value.boolean = offset;
      mxStack++;
      mxNextCode(1);
      mxBreak;

    mxCase(XS_CODE_EQUAL)
    mxCase(XS_CODE_STRICT_EQUAL)
      slot = mxStack + 1;
    XS_CODE_EQUAL_AGAIN:
      if (slot->kind == mxStack->kind) {
        if ((XS_UNDEFINED_KIND == slot->kind) || (XS_NULL_KIND == slot->kind))
          offset = 1;
        else if (XS_BOOLEAN_KIND == slot->kind)
          offset = slot->value.boolean == stack->value.boolean;
        else if (XS_INTEGER_KIND == slot->kind)
          offset = slot->value.integer == stack->value.integer;
        else if (XS_NUMBER_KIND == slot->kind) {
          offset = (!c_isnan(slot->value.number)) && (!c_isnan(mxStack->value.number)) && (slot->value.number == mxStack->value.number);
          mxFloatingPointOp("equal");
        }
        else if ((XS_STRING_KIND == slot->kind) || (XS_STRING_X_KIND == slot->kind))
          offset = c_strcmp(slot->value.string, mxStack->value.string) == 0;
        else if (XS_SYMBOL_KIND == slot->kind)
          offset = slot->value.symbol == mxStack->value.symbol;
        else if (XS_REFERENCE_KIND == slot->kind)
          offset = fxIsSameReference(the, slot, mxStack);
      #if mxHostFunctionPrimitive
        else if (XS_HOST_FUNCTION_KIND == slot->kind)
          offset = slot->value.hostFunction.builder == mxStack->value.hostFunction.builder;
      #endif
        else if ((XS_BIGINT_KIND == slot->kind) || (XS_BIGINT_X_KIND == slot->kind))
          offset = gxTypeBigInt.compare(the, 0, 1, 0, slot, mxStack);
        else
                    offset = 0;
      }
      else if ((XS_INTEGER_KIND == slot->kind) && (XS_NUMBER_KIND == mxStack->kind)) {
        offset = (!c_isnan(mxStack->value.number)) && ((txNumber)(slot->value.integer) == stack->value.number);
        mxFloatingPointOp("equal");
      }
      else if ((XS_NUMBER_KIND == slot->kind) && (XS_INTEGER_KIND == mxStack->kind)) {
        offset = (!c_isnan(slot->value.number)) && (slot->value.number == (txNumber)(mxStack->value.integer));
        mxFloatingPointOp("equal");
      }
      else if ((XS_STRING_KIND == slot->kind) && (XS_STRING_X_KIND == mxStack->kind))
        offset = c_strcmp(slot->value.string, mxStack->value.string) == 0;
      else if ((XS_STRING_X_KIND == slot->kind) && (XS_STRING_KIND == mxStack->kind))
        offset = c_strcmp(slot->value.string, mxStack->value.string) == 0;
      else if (XS_CODE_EQUAL == byte) {
        if ((slot->kind == XS_UNDEFINED_KIND) && (mxStack->kind == XS_NULL_KIND))
          offset = 1;
        else if ((slot->kind == XS_NULL_KIND) && (mxStack->kind == XS_UNDEFINED_KIND))
          offset = 1;
        else if (((XS_INTEGER_KIND == slot->kind) || (XS_NUMBER_KIND == slot->kind)) && ((mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND))) {
          mxToNumber(mxStack); 
          goto XS_CODE_EQUAL_AGAIN;
        }
        else if (((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((XS_INTEGER_KIND == mxStack->kind) || (XS_NUMBER_KIND == mxStack->kind))) {
          mxToNumber(slot);
          goto XS_CODE_EQUAL_AGAIN;
        }
        else if (XS_BOOLEAN_KIND == slot->kind) {
          mxToNumber(slot);
          goto XS_CODE_EQUAL_AGAIN;
        }
        else if (XS_BOOLEAN_KIND == mxStack->kind) {
          mxToNumber(mxStack);
          goto XS_CODE_EQUAL_AGAIN;
        }
        else if (((slot->kind == XS_INTEGER_KIND) || (slot->kind == XS_NUMBER_KIND) || (slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND) || (slot->kind == XS_SYMBOL_KIND) || (slot->kind == XS_BIGINT_KIND) || (slot->kind == XS_BIGINT_X_KIND)) && mxIsReference(mxStack)) {
          mxSaveState;
          fxToPrimitive(the, mxStack, XS_NO_HINT);
          mxRestoreState;
          goto XS_CODE_EQUAL_AGAIN;
        }
        else if (mxIsReference(slot) && ((mxStack->kind == XS_INTEGER_KIND) || (mxStack->kind == XS_NUMBER_KIND) || (mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND) || (mxStack->kind == XS_SYMBOL_KIND) || (mxStack->kind == XS_BIGINT_KIND) || (mxStack->kind == XS_BIGINT_X_KIND))) {
          mxSaveState;
          fxToPrimitive(the, slot, XS_NO_HINT);
          mxRestoreState;
          goto XS_CODE_EQUAL_AGAIN;
        }
        else if (((XS_BIGINT_KIND == slot->kind) || (XS_BIGINT_X_KIND == slot->kind)) && ((mxStack->kind == XS_INTEGER_KIND) || (mxStack->kind == XS_NUMBER_KIND) || (mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND))) {
          mxSaveState;
          offset = gxTypeBigInt.compare(the, 0, 1, 0, slot, mxStack);
          mxRestoreState;
        }
        else if (((slot->kind == XS_INTEGER_KIND) || (slot->kind == XS_NUMBER_KIND) || (slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((XS_BIGINT_KIND == mxStack->kind) || (XS_BIGINT_X_KIND == mxStack->kind))) {
          mxSaveState;
          offset = gxTypeBigInt.compare(the, 0, 1, 0, mxStack, slot);
          mxRestoreState;
        }
                else
                    offset = 0;
      }
      else 
        offset = 0;
      slot->kind = XS_BOOLEAN_KIND;
      slot->value.boolean = offset;
      mxStack++;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_NOT_EQUAL)
    mxCase(XS_CODE_STRICT_NOT_EQUAL)
      slot = mxStack + 1;
    XS_CODE_NOT_EQUAL_AGAIN:
      if (slot->kind == mxStack->kind) {
        if ((XS_UNDEFINED_KIND == slot->kind) || (XS_NULL_KIND == slot->kind))
          offset = 0;
        else if (XS_BOOLEAN_KIND == slot->kind)
          offset = slot->value.boolean != stack->value.boolean;
        else if (XS_INTEGER_KIND == slot->kind)
          offset = slot->value.integer != stack->value.integer;
        else if (XS_NUMBER_KIND == slot->kind) {
          offset = (c_isnan(slot->value.number)) || (c_isnan(mxStack->value.number)) || (slot->value.number != mxStack->value.number);
          mxFloatingPointOp("not equal");
        }
        else if ((XS_STRING_KIND == slot->kind) || (XS_STRING_X_KIND == slot->kind))
          offset = c_strcmp(slot->value.string, mxStack->value.string) != 0;
        else if (XS_SYMBOL_KIND == slot->kind)
          offset = slot->value.symbol != mxStack->value.symbol;
        else if (XS_REFERENCE_KIND == slot->kind)
          offset = !fxIsSameReference(the, slot, mxStack);
      #if mxHostFunctionPrimitive
        else if (XS_HOST_FUNCTION_KIND == slot->kind)
          offset = slot->value.hostFunction.builder != mxStack->value.hostFunction.builder;
      #endif
        else if ((XS_BIGINT_KIND == slot->kind) || (XS_BIGINT_X_KIND == slot->kind))
          offset = gxTypeBigInt.compare(the, 1, 0, 1, slot, mxStack);
                else
                  offset = 1;
      }
      else if ((XS_INTEGER_KIND == slot->kind) && (XS_NUMBER_KIND == mxStack->kind)) {
        offset = (c_isnan(mxStack->value.number)) || ((txNumber)(slot->value.integer) != stack->value.number);
        mxFloatingPointOp("not equal");
      }
      else if ((XS_NUMBER_KIND == slot->kind) && (XS_INTEGER_KIND == mxStack->kind)) {
        offset = (c_isnan(slot->value.number)) || (slot->value.number != (txNumber)(mxStack->value.integer));
        mxFloatingPointOp("not equal");
      }
      else if ((XS_STRING_KIND == slot->kind) && (XS_STRING_X_KIND == mxStack->kind))
        offset = c_strcmp(slot->value.string, mxStack->value.string) != 0;
      else if ((XS_STRING_X_KIND == slot->kind) && (XS_STRING_KIND == mxStack->kind))
        offset = c_strcmp(slot->value.string, mxStack->value.string) != 0;
      else if (XS_CODE_NOT_EQUAL == byte) {
        if ((slot->kind == XS_UNDEFINED_KIND) && (mxStack->kind == XS_NULL_KIND))
          offset = 0;
        else if ((slot->kind == XS_NULL_KIND) && (mxStack->kind == XS_UNDEFINED_KIND))
          offset = 0;
        else if (((slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((XS_INTEGER_KIND == mxStack->kind) || (XS_NUMBER_KIND == mxStack->kind))) {
          mxToNumber(slot);
          goto XS_CODE_NOT_EQUAL_AGAIN;
        }
        else if (((mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND)) && ((XS_INTEGER_KIND == slot->kind) || (XS_NUMBER_KIND == slot->kind))) {
          mxToNumber(mxStack); 
          goto XS_CODE_NOT_EQUAL_AGAIN;
        }
        else if (XS_BOOLEAN_KIND == slot->kind) {
          mxToNumber(slot);
          goto XS_CODE_NOT_EQUAL_AGAIN;
        }
        else if (XS_BOOLEAN_KIND == mxStack->kind) {
          mxToNumber(mxStack);
          goto XS_CODE_NOT_EQUAL_AGAIN;
        }
        else if (((slot->kind == XS_INTEGER_KIND) || (slot->kind == XS_NUMBER_KIND) || (slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND) || (slot->kind == XS_SYMBOL_KIND) || (slot->kind == XS_BIGINT_KIND) || (slot->kind == XS_BIGINT_X_KIND)) && mxIsReference(mxStack)) {
          mxSaveState;
          fxToPrimitive(the, mxStack, XS_NO_HINT);
          mxRestoreState;
          goto XS_CODE_NOT_EQUAL_AGAIN;
        }
        else if (mxIsReference(slot) && ((mxStack->kind == XS_INTEGER_KIND) || (mxStack->kind == XS_NUMBER_KIND) || (mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND) || (mxStack->kind == XS_SYMBOL_KIND) || (mxStack->kind == XS_BIGINT_KIND) || (mxStack->kind == XS_BIGINT_X_KIND))) {
          mxSaveState;
          fxToPrimitive(the, slot, XS_NO_HINT);
          mxRestoreState;
          goto XS_CODE_NOT_EQUAL_AGAIN;
        }
        else if (((XS_BIGINT_KIND == slot->kind) || (XS_BIGINT_X_KIND == slot->kind)) && ((mxStack->kind == XS_INTEGER_KIND) || (mxStack->kind == XS_NUMBER_KIND) || (mxStack->kind == XS_STRING_KIND) || (mxStack->kind == XS_STRING_X_KIND))) {
          mxSaveState;
          offset = gxTypeBigInt.compare(the, 1, 0, 1, slot, mxStack);
          mxRestoreState;
        }
        else if (((slot->kind == XS_INTEGER_KIND) || (slot->kind == XS_NUMBER_KIND) || (slot->kind == XS_STRING_KIND) || (slot->kind == XS_STRING_X_KIND)) && ((XS_BIGINT_KIND == mxStack->kind) || (XS_BIGINT_X_KIND == mxStack->kind))) {
          mxSaveState;
          offset = gxTypeBigInt.compare(the, 1, 0, 1, mxStack, slot);
          mxRestoreState;
        }
                else
                offset = 1;
      }
      else 
        offset = 1;
      slot->kind = XS_BOOLEAN_KIND;
      slot->value.boolean = offset;
      mxStack++;
      mxNextCode(1);
      mxBreak;
      
    mxCase(XS_CODE_FOR_AWAIT_OF)
      mxNextCode(1);
      mxSaveState;
      gxDefaults.runForAwaitOf(the);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_FOR_IN)
      mxSkipCode(1);
      /* FUNCTION */
      mxAllocStack(1);
      *mxStack = mxEnumeratorFunction;
      slot = fxGetInstance(the, mxStack);
      /* RESULT */
      mxPushKind(XS_UNDEFINED_KIND);
      mxPushKind(XS_UNDEFINED_KIND);
      offset = 0;
      goto XS_CODE_RUN_ALL;

    mxCase(XS_CODE_FOR_OF)
      mxNextCode(1);
      mxSaveState;
      fxRunForOf(the);
      mxRestoreState;
      mxBreak;
      
    mxCase(XS_CODE_IN)
      mxNextCode(1);
      if (!mxIsReference(mxStack))
        mxRunDebug(XS_TYPE_ERROR, "in: not an object");
      mxSaveState;
      fxRunIn(the);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_INSTANCEOF)
      mxNextCode(1);
      mxSaveState;
      fxRunInstanceOf(the);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_TYPEOF)
      byte = mxStack->kind;
      if (XS_UNDEFINED_KIND == byte)
        *mxStack = mxUndefinedString;
      else if (XS_NULL_KIND == byte)
        *mxStack = mxObjectString;
      else if (XS_BOOLEAN_KIND == byte)
        *mxStack = mxBooleanString;
      else if ((XS_INTEGER_KIND == byte) || (XS_NUMBER_KIND == byte))
        *mxStack = mxNumberString;
      else if ((XS_STRING_KIND == byte) || (XS_STRING_X_KIND == byte))
        *mxStack = mxStringString;
      else if (XS_SYMBOL_KIND == byte)
        *mxStack = mxSymbolString;
      else if ((XS_BIGINT_KIND == byte) || (XS_BIGINT_X_KIND == byte))
        *mxStack = mxBigIntString;
      else if (XS_REFERENCE_KIND == byte) {
        slot = fxGetInstance(the, mxStack);
        if (slot->flag & XS_CAN_CALL_FLAG)
          *mxStack = mxFunctionString;
        else
          *mxStack = mxObjectString;
      }
    #if mxHostFunctionPrimitive
      else if (XS_HOST_FUNCTION_KIND == byte)
        *mxStack = mxFunctionString;
    #endif
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_VOID)
      mxNextCode(1);
      mxStack->kind = XS_UNDEFINED_KIND;
      mxBreak;

  /* DEBUG */    
    mxCase(XS_CODE_DEBUGGER)
      mxNextCode(1);
    #ifdef mxDebug
      if (!the->debugEval) {
        mxSaveState;
        fxDebugLoop(the, C_NULL, 0, "debugger");
        mxRestoreState;
      }
    #endif
      mxBreak;
    mxCase(XS_CODE_FILE)
    #ifdef mxDebug
      count = mxRunID(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, count, 0);
#endif
      mxEnvironment->ID = count;
      mxEnvironment->value.environment.line = 0;
    #endif
      mxNextCode(1 + sizeof(txID));
      mxBreak;
    mxCase(XS_CODE_LINE)
    #ifdef mxDebug
      count = mxRunS2(1);
#ifdef mxTrace
      if (gxDoTrace) fxTraceInteger(the, count);
#endif
      if (count == 0) {
        count = mxFunctionInstanceCode(mxFrameFunction->value.reference)->ID;
        if ((mxEnvironment->ID != XS_NO_ID) && (count != XS_NO_ID) && mxBreakpoints.value.list.first) {
          mxSaveState;
          fxDebugLine(the, mxEnvironment->ID, mxEnvironment->value.environment.line, count);
          mxRestoreState;
        }
      }
      else {
        mxEnvironment->value.environment.line = count;
        if (fxIsReadable(the)) {
          mxSaveState;
          fxDebugCommand(the);
          mxRestoreState;
        }
        if ((mxEnvironment->ID != XS_NO_ID) && ((mxFrame->flag & XS_STEP_OVER_FLAG) || mxBreakpoints.value.list.first)) {
          mxSaveState;
          fxDebugLine(the, mxEnvironment->ID, mxEnvironment->value.environment.line, XS_NO_ID);
          mxRestoreState;
        }
      }
    #endif
    #if defined(mxInstrument) || defined(mxProfile)
      fxCheckProfiler(the, mxFrame);
    #endif
      mxNextCode(3);
      mxBreak;

  /* MODULE */    
    mxCase(XS_CODE_IMPORT)
      slot = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
      variable = mxModuleInstanceInternal(slot);
      variable = variable->value.module.realm;
      if (!variable) variable = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
      mxSaveState;
      gxDefaults.runImport(the, variable, slot);
      mxRestoreState;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_IMPORT_META)
      slot = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
      mxSaveState;
      fxRunImportMeta(the, slot);
      mxRestoreState;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_TRANSFER)
      mxSaveState;
      fxPrepareTransfer(the, XS_NO_FLAG);
      mxRestoreState;
            mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_TRANSFER_JSON)
      mxSaveState;
      fxPrepareTransfer(the, XS_JSON_MODULE_FLAG);
      mxRestoreState;
            mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_MODULE)
      byte = mxRunU1(1);
      mxSaveState;
      fxPrepareModule(the, byte);
      mxRestoreState;
            mxNextCode(2);
      mxBreak;
      
  /* EVAL, PROGRAM & WITH */
    mxCase(XS_CODE_EVAL)
      offset = mxStack->value.integer;
      slot = mxStack + 1 + offset + 2;
      if (mxIsReference(slot) && mxIsFunction(slot->value.reference) && (mxFunctionInstanceCode(slot->value.reference)->value.callback.address == mxFunctionInstanceCode(mxEvalFunction.value.reference)->value.callback.address)) {
        mxSaveState;
        gxDefaults.runEval(the);
        mxRestoreState;
        mxNextCode(1);
        mxBreak;
      }
      mxSkipCode(1);
      mxStack++;
      goto XS_CODE_RUN_ALL;
    mxCase(XS_CODE_EVAL_TAIL)
      offset = mxStack->value.integer;
      slot = mxStack + 1 + offset + 2;
      if (mxIsReference(slot) && mxIsFunction(slot->value.reference) && (mxFunctionInstanceCode(slot->value.reference)->value.callback.address == mxFunctionInstanceCode(mxEvalFunction.value.reference)->value.callback.address)) {
        mxSaveState;
        gxDefaults.runEval(the);
        mxRestoreState;
        mxNextCode(1);
        mxBreak;
      }
      mxSkipCode(1);
      mxStack++;
      goto XS_CODE_RUN_TAIL_ALL;
    mxCase(XS_CODE_EVAL_ENVIRONMENT)
      mxNextCode(1);
      mxSaveState;
      gxDefaults.runEvalEnvironment(the);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_EVAL_PRIVATE)
      offset = mxRunID(1);
    #ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
    #endif
      mxNextCode(1 + sizeof(txID));
      variable = mxEnvironment;
      if (variable->kind == XS_REFERENCE_KIND) {
        variable = variable->value.reference;
    XS_CODE_EVAL_PRIVATE_AGAIN:
        if (variable) {
          slot = mxBehaviorGetProperty(the, variable, (txID)offset, 0, XS_OWN);
          if (slot) {
            mxPushKind(slot->kind);
            mxStack->value = slot->value;
            mxBreak;
          }
          variable = variable->value.instance.prototype;
          goto XS_CODE_EVAL_PRIVATE_AGAIN;
        }
      }
      mxRunDebugID(XS_SYNTAX_ERROR, "eval %s: undefined private property", (txID)offset);
      mxBreak;
    mxCase(XS_CODE_EVAL_REFERENCE)
      offset = mxRunID(1);
    #ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
    #endif
      mxNextCode(1 + sizeof(txID));
      variable = mxEnvironment;
      if (variable->kind == XS_REFERENCE_KIND) {
        variable = variable->value.reference;
    XS_CODE_EVAL_REFERENCE_AGAIN:
        if (variable->value.instance.prototype) {
          slot = variable->next;
          if (slot->kind == XS_REFERENCE_KIND) {
            slot = slot->value.reference;
            mxSaveState;
            index = fxIsScopableSlot(the, slot, (txID)offset);
            mxRestoreState;
            if (index) {
//              if (fxRunHas(the, slot, (txID)offset, 0)) {
                if (XS_CODE_GET_THIS_VARIABLE == byte) {
                  mxStack->kind = XS_REFERENCE_KIND;
                  mxStack->value.reference = slot;
                }
                mxPushKind(XS_REFERENCE_KIND);
                mxStack->value.reference = slot;
                mxBreak;
//              }
            }
          }
          else if (mxBehaviorHasProperty(the, variable, (txID)offset, 0)) {
            mxPushKind(XS_REFERENCE_KIND);
            mxStack->value.reference = variable;
            mxBreak;
          }
          variable = variable->value.instance.prototype;
          goto XS_CODE_EVAL_REFERENCE_AGAIN;
        }
        if (mxBehaviorHasProperty(the, variable, (txID)offset, 0)) {
          mxPushKind(XS_REFERENCE_KIND);
          mxStack->value.reference = variable;
          mxBreak;
        }
      }
      mxPushKind(XS_REFERENCE_KIND);
      variable = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
      variable = mxModuleInstanceInternal(variable)->value.module.realm;
      if (!variable) variable = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
      mxStack->value.reference = mxRealmGlobal(variable)->value.reference;
      mxBreak;
    mxCase(XS_CODE_FUNCTION_ENVIRONMENT)  
      variable = mxEnvironment;
      mxPushKind(XS_UNDEFINED_KIND);
      mxSaveState;
      slot = fxNewEnvironmentInstance(the, variable);
      mxRestoreState;
      variable = mxFunctionInstanceCode((mxStack + 1)->value.reference);
      variable->value.code.closures = slot;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_PROGRAM_ENVIRONMENT)
      mxNextCode(1);
      mxSaveState;
      gxDefaults.runProgramEnvironment(the);
      mxRestoreState;
      mxBreak;
    mxCase(XS_CODE_PROGRAM_REFERENCE)
      offset = mxRunID(1);
    #ifdef mxTrace
      if (gxDoTrace) fxTraceID(the, (txID)offset, 0);
    #endif
      mxNextCode(1 + sizeof(txID));
            variable = mxFunctionInstanceHome(mxFrameFunction->value.reference)->value.home.module;
            variable = mxModuleInstanceInternal(variable)->value.module.realm;
            if (!variable) variable = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
            slot = mxRealmClosures(variable)->value.reference;
            if (mxBehaviorHasProperty(the, slot, (txID)offset, 0)) {
                mxPushKind(XS_REFERENCE_KIND);
                mxStack->value.reference = slot;
                mxBreak;
            }
      mxPushKind(XS_REFERENCE_KIND);
      mxStack->value.reference = mxRealmGlobal(variable)->value.reference;
      mxBreak;
    mxCase(XS_CODE_WITH)
      variable = mxEnvironment;
      mxSaveState;
      slot = fxNewEnvironmentInstance(the, variable);
      mxRestoreState;
      variable->kind = XS_REFERENCE_KIND;
      variable->value.reference = slot;
      mxNextCode(1);
      mxBreak;
    mxCase(XS_CODE_WITHOUT)
      variable = mxEnvironment;
      slot = variable->value.reference->value.instance.prototype;
      if (slot) {
        variable->kind = XS_REFERENCE_KIND;
        variable->value.reference = slot;
      }
      else
        variable->kind = XS_NULL_KIND;
      mxNextCode(1);
      mxBreak;
    }
  }

STACK_OVERFLOW:
  mxSaveState;
  fxAbort(the, XS_JAVASCRIPT_STACK_OVERFLOW_EXIT);
}

#ifdef mxMetering

void fxBeginMetering(txMachine* the, txBoolean (*callback)(txMachine*, txU8), txU8 interval)
{
  the->meterCallback = callback;
  the->meterCount = ((txU8)interval) << 16;
  the->meterIndex = 0;
  the->meterInterval = ((txU8)interval) << 16;
}

void fxEndMetering(txMachine* the)
{
  the->meterCallback = C_NULL;
  the->meterIndex = 0;
  the->meterInterval = 0;
  the->meterCount = 0;
}

void fxCheckMetering(txMachine* the)
{
  txU8 interval = the->meterInterval;
  the->meterInterval = 0;
  if ((*the->meterCallback)(the, the->meterIndex >> 16)) {
    the->meterCount = the->meterIndex + interval;
    if (the->meterCount < the->meterIndex) {
      the->meterIndex = 0;
      the->meterCount = interval;
    }
    the->meterInterval = interval;
  }
  else {
    fxAbort(the, XS_TOO_MUCH_COMPUTATION_EXIT);
  }
}
#endif

void fxRunArguments(txMachine* the, txIndex offset)
{
  txSlot* array;
  txIndex length = (txIndex)mxArgc;
  txIndex index;
  txSlot* address;
  mxPush(mxArrayPrototype);
  array = fxNewArrayInstance(the)->next;
  if (offset < length) {
    length -= offset;
    fxSetIndexSize(the, array, length, XS_CHUNK);
    index = 0;
    address = array->value.array.address;
    while (index < length) {
      txSlot* property = mxArgv(offset + index);
      *((txIndex*)address) = index;
      address->ID = XS_NO_ID;
      address->kind = property->kind;
      address->value = property->value;
      index++;
      address++;
    }
  }
}

void fxRunBase(txMachine* the)
{
  if (!mxHasTarget)
    mxTypeError("call: class");
  fxRunConstructor(the);
}

void fxRunConstructor(txMachine* the)
{
  txSlot* target;
  txSlot* prototype;
  target = mxTarget;
  mxPushUndefined();
  prototype = the->stack;
  fxBeginHost(the);
  mxPushSlot(target);
  fxGetPrototypeFromConstructor(the, &mxObjectPrototype);
  *prototype = *the->stack;
  fxEndHost(the);
  fxNewHostInstance(the);
  mxPullSlot(mxThis);
}

txBoolean fxRunDefine(txMachine* the, txSlot* instance, txSlot* check, txID id, txIndex index, txSlot* slot, txFlag mask) 
{
  txBoolean result;
  if (check) {
    result = gxDefaults.definePrivateProperty(the, instance, check, id, slot, mask);
  }
  else {
    fxBeginHost(the);
    mxCheck(the, instance->kind == XS_INSTANCE_KIND);
    result = mxBehaviorDefineOwnProperty(the, instance, id, index, slot, mask);
    fxEndHost(the);
  }
  return result;
}


txBoolean fxRunDelete(txMachine* the, txSlot* instance, txID id, txIndex index) 
{
  txBoolean result;
  fxBeginHost(the);
  mxCheck(the, instance->kind == XS_INSTANCE_KIND);
  result = mxBehaviorDeleteProperty(the, instance, id, index);
  fxEndHost(the);
  return result;
}

void fxRunDerived(txMachine* the)
{
  txSlot* slot;
  if (!mxHasTarget)
    mxTypeError("call: class");
  slot = fxNewSlot(the);
  slot->kind = XS_UNINITIALIZED_KIND;
  mxPushClosure(slot);
  mxPullSlot(mxThis);
}

void fxRunExtends(txMachine* the)
{
  txSlot* constructor;
  txSlot* prototype;
  
  constructor = fxGetInstance(the, the->stack);
  if (!mxIsConstructor(constructor))
    mxTypeError("extends: class is not a constructor");
  mxPushUndefined();
  prototype = the->stack;
  fxBeginHost(the);
  mxPushReference(constructor);
  mxGetID(mxID(_prototype));
  *prototype = *the->stack;
  fxEndHost(the);
  if (the->stack->kind == XS_NULL_KIND) {
    mxPop();
    fxNewInstance(the);
  }
  else if (the->stack->kind == XS_REFERENCE_KIND) {
    if (the->stack->value.reference->value.instance.prototype == mxGeneratorPrototype.value.reference)
      mxTypeError("extends: class is a generator");
    fxNewHostInstance(the);
  }
  else
    mxTypeError("extends: class prototype is not an object");
}

void fxRunEval(txMachine* the)
{ 
  txStringStream aStream;
  txUnsigned flags;
  txSlot* function;
  txSlot* home;
  txSlot* closures;
  if (the->stack->value.integer == 0)
    the->stack->kind = XS_UNDEFINED_KIND;
  else
    the->stack += the->stack->value.integer;
  the->stack[4] = the->stack[0];
  the->stack += 4;
  if ((the->stack->kind == XS_STRING_KIND) || (the->stack->kind == XS_STRING_X_KIND)) {
    aStream.slot = the->stack;
    aStream.offset = 0;
    aStream.size = mxStringLength(fxToString(the, aStream.slot));
    flags = mxProgramFlag | mxEvalFlag;
    if (the->frame->flag & XS_STRICT_FLAG)
      flags |= mxStrictFlag;
    if (the->frame->flag & XS_FIELD_FLAG)
      flags |= mxFieldFlag;
    function = mxFunction->value.reference;
    if (function->flag & XS_CAN_CONSTRUCT_FLAG)
      flags |= mxTargetFlag;
    home = mxFunctionInstanceHome(function);
    if (home->value.home.object)
      flags |= mxSuperFlag;
    closures = mxFrameToEnvironment(the->frame);
    if (closures->kind == XS_REFERENCE_KIND)
      closures = closures->value.reference;
    else
      closures = C_NULL;
    fxRunScript(the, fxParseScript(the, &aStream, fxStringGetter, flags), mxThis, mxHasTarget ? mxTarget : C_NULL, closures, home->value.home.object, home->value.home.module);
    aStream.slot->kind = the->stack->kind;
    aStream.slot->value = the->stack->value;
    mxPop();
  }
}

void fxRunForAwaitOf(txMachine* the)
{
  txSlot* slot = the->stack;
  fxBeginHost(the);
  mxPushSlot(slot);
  mxDub();
  mxGetID(mxID(_Symbol_asyncIterator));
  if (mxIsUndefined(the->stack) || mxIsNull(the->stack)) {
    mxPop();
    mxPop();
    fxGetIterator(the, slot, the->stack, C_NULL, 0);
    fxNewAsyncFromSyncIteratorInstance(the);
  }
  else {
    mxCall();
    mxRunCount(0);
  }
  mxPullSlot(slot);
  fxEndHost(the);
}

void fxRunForOf(txMachine* the)
{
  txSlot* slot = the->stack;
  fxBeginHost(the);
  fxGetIterator(the, slot, slot, C_NULL, 0);
  fxEndHost(the);
}

txBoolean fxRunHas(txMachine* the, txSlot* instance, txID id, txIndex index)
{
  txBoolean result;
  fxBeginHost(the);
  result = mxBehaviorHasProperty(the, instance, id, index);
  fxEndHost(the);
  return result;
}

void fxRunIn(txMachine* the)
{
  txSlot* left = the->stack + 1;
  txSlot* right = the->stack;
  fxBeginHost(the);
  mxPushSlot(right);
  mxPushSlot(left);
  left->value.boolean = fxHasAt(the);
  left->kind = XS_BOOLEAN_KIND;
  fxEndHost(the);
  mxPop();
}

void fxRunInstanceOf(txMachine* the)
{
  txSlot* left = the->stack + 1;
  txSlot* right = the->stack;
  fxBeginHost(the);
  mxPushSlot(right);
  mxDub();
  mxGetID(mxID(_Symbol_hasInstance));
  mxCall();
  mxPushSlot(left);
  mxRunCount(1);
  fxToBoolean(the, the->stack);
  mxPullSlot(left);
  fxEndHost(the);
  mxPop();
}

void fxRunInstantiate(txMachine* the)
{
  if (the->stack->kind == XS_NULL_KIND) {
    mxPop();
    fxNewInstance(the);
  }
  else if (the->stack->kind == XS_REFERENCE_KIND) {
    fxNewHostInstance(the);
  }
  else {
    mxPop();
    mxPush(mxObjectPrototype);
    fxNewObjectInstance(the);
  }
}

void fxRunProxy(txMachine* the, txSlot* instance)
{
  txSlot* array;
  txIndex length = (txIndex)mxArgc;
  txIndex index;
  txSlot* address;
  mxPush(mxArrayPrototype);
  array = fxNewArrayInstance(the)->next;
  fxSetIndexSize(the, array, length, XS_CHUNK);
  index = 0;
  address = array->value.array.address;
  while (index < length) {
    txSlot* property = mxArgv(index);
    *((txIndex*)address) = index;
    address->ID = XS_NO_ID;
    address->kind = property->kind;
    address->value = property->value;
    index++;
    address++;
  }
  if (!mxHasTarget)
    mxBehaviorCall(the, instance, mxThis, the->stack);
  else if (instance->flag & XS_CAN_CONSTRUCT_FLAG)
    mxBehaviorConstruct(the, instance, the->stack, mxTarget);
  else
    mxTypeError("new: proxy is not a constructor");
  mxPop();
}

txBoolean fxIsSameReference(txMachine* the, txSlot* a, txSlot* b)
{ 
  a = a->value.reference;
  b = b->value.reference;
  if (a == b)
    return 1;
#if mxAliasInstance
  if (a->ID) {
    txSlot* alias = the->aliasArray[a->ID];
    if (alias) {
      a = alias;
      if (a == b)
        return 1;
    }
  }
  if (b->ID) {
    txSlot* alias = the->aliasArray[b->ID];
    if (alias) {
      b = alias;
      if (a == b)
        return 1;
    }
  }
#endif
  return 0;
}

txBoolean fxIsSameSlot(txMachine* the, txSlot* a, txSlot* b)
{ 
  txBoolean result = 0;
  if (a->kind == b->kind) {
    if ((XS_UNDEFINED_KIND == a->kind) || (XS_NULL_KIND == a->kind))
      result = 1;
    else if (XS_BOOLEAN_KIND == a->kind)
      result = a->value.boolean == b->value.boolean;
    else if (XS_INTEGER_KIND == a->kind)
      result = a->value.integer == b->value.integer;
        else if (XS_NUMBER_KIND == a->kind) {
      result = (!c_isnan(a->value.number)) && (!c_isnan(b->value.number)) && (a->value.number == b->value.number);
      mxFloatingPointOp("same slot");
    }
    else if ((XS_STRING_KIND == a->kind) || (XS_STRING_X_KIND == a->kind))
      result = c_strcmp(a->value.string, b->value.string) == 0;
    else if (XS_SYMBOL_KIND == a->kind)
      result = a->value.symbol == b->value.symbol;
    else if ((XS_BIGINT_KIND == a->kind) || (XS_BIGINT_X_KIND == a->kind))
      result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
    else if (XS_REFERENCE_KIND == a->kind)
      result = fxIsSameReference(the, a, b);
  }
  else if ((XS_INTEGER_KIND == a->kind) && (XS_NUMBER_KIND == b->kind)) {
    result = (!c_isnan(b->value.number)) && ((txNumber)(a->value.integer) == b->value.number);
    mxFloatingPointOp("same slot");
  }
  else if ((XS_NUMBER_KIND == a->kind) && (XS_INTEGER_KIND == b->kind)) {
    result = (!c_isnan(a->value.number)) && (a->value.number == (txNumber)(b->value.integer));
    mxFloatingPointOp("same slot");
  }
  else if ((XS_STRING_KIND == a->kind) && (XS_STRING_X_KIND == b->kind))
    result = c_strcmp(a->value.string, b->value.string) == 0;
  else if ((XS_STRING_X_KIND == a->kind) && (XS_STRING_KIND == b->kind))
    result = c_strcmp(a->value.string, b->value.string) == 0;
  else if ((XS_BIGINT_KIND == a->kind) && (XS_BIGINT_X_KIND == b->kind))
    result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
  else if ((XS_BIGINT_X_KIND == a->kind) && (XS_BIGINT_KIND == b->kind))
    result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
  return result;
}

txBoolean fxIsSameValue(txMachine* the, txSlot* a, txSlot* b, txBoolean zero)
{
  txBoolean result = 0;
  if (a->kind == b->kind) {
    if ((XS_UNDEFINED_KIND == a->kind) || (XS_NULL_KIND == a->kind))
      result = 1;
    else if (XS_BOOLEAN_KIND == a->kind)
      result = a->value.boolean == b->value.boolean;
    else if (XS_INTEGER_KIND == a->kind)
      result = a->value.integer == b->value.integer;
        else if (XS_NUMBER_KIND == a->kind) {
      result = ((c_isnan(a->value.number) && c_isnan(b->value.number)) || ((a->value.number == b->value.number) && (zero || (c_signbit(a->value.number) == c_signbit(b->value.number)))));
      mxFloatingPointOp("same value");
    }
    else if ((XS_STRING_KIND == a->kind) || (XS_STRING_X_KIND == a->kind))
      result = c_strcmp(a->value.string, b->value.string) == 0;
    else if (XS_SYMBOL_KIND == a->kind)
      result = a->value.symbol == b->value.symbol;
    else if ((XS_BIGINT_KIND == a->kind) || (XS_BIGINT_X_KIND == a->kind))
      result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
    else if (XS_REFERENCE_KIND == a->kind)
      result = fxIsSameReference(the, a, b);
  }
  else if ((XS_INTEGER_KIND == a->kind) && (XS_NUMBER_KIND == b->kind)) {
    txNumber aNumber = a->value.integer;
    result = (aNumber == b->value.number) && (zero || (signbit(aNumber) == signbit(b->value.number)));
    mxFloatingPointOp("same value");
  }
  else if ((XS_NUMBER_KIND == a->kind) && (XS_INTEGER_KIND == b->kind)) {
    txNumber bNumber = b->value.integer;
    result = (a->value.number == bNumber) && (zero || (signbit(a->value.number) == signbit(bNumber)));
    mxFloatingPointOp("same value");
  }
  else if ((XS_STRING_KIND == a->kind) && (XS_STRING_X_KIND == b->kind))
    result = c_strcmp(a->value.string, b->value.string) == 0;
  else if ((XS_STRING_X_KIND == a->kind) && (XS_STRING_KIND == b->kind))
    result = c_strcmp(a->value.string, b->value.string) == 0;
  else if ((XS_BIGINT_KIND == a->kind) && (XS_BIGINT_X_KIND == b->kind))
    result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
  else if ((XS_BIGINT_X_KIND == a->kind) && (XS_BIGINT_KIND == b->kind))
    result = gxTypeBigInt.compare(the, 0, 1, 0, a, b);
  return result;
}

txBoolean fxIsScopableSlot(txMachine* the, txSlot* instance, txID id)
{ 
  txBoolean result;
  fxBeginHost(the);
  mxPushReference(instance);
  result = mxHasID(id);
  if (result) {
    mxPushReference(instance);
    mxGetID(mxID(_Symbol_unscopables));
    if (mxIsReference(the->stack)) {
      mxGetID(id);
      result = fxToBoolean(the, the->stack) ? 0 : 1;
    }
    mxPop();
  }
  fxEndHost(the);
  return result;
}

void fxRemapIDs(txMachine* the, txByte* codeBuffer, txSize codeSize, txID* theIDs)
{
  register const txS1* bytes = gxCodeSizes;
  register txByte* p = codeBuffer;
  register txByte* q = codeBuffer + codeSize;
  register txS1 offset;
  txID id;
  while (p < q) {
    //fprintf(stderr, "%s", gxCodeNames[*((txU1*)p)]);
    offset = (txS1)c_read8(bytes + c_read8(p));
    if (0 < offset)
      p += offset;
    else if (0 == offset) {
      p++;
      mxDecodeID(p, id);
      if (id != XS_NO_ID) {
        id = theIDs[id];
        p -= sizeof(txID);
        mxEncodeID(p, id);
      }
    }
    else if (-1 == offset) {
      txU1 index;
      p++;
      index = *((txU1*)p);
      p += 1 + index;
    }
        else if (-2 == offset) {
      txU2 index;
            p++;
            mxDecode2(p, index);
            p += index;
        }
        else if (-4 == offset) {
      txS4 index;
            p++;
            mxDecode4(p, index);
            p += index;
        }
    //fprintf(stderr, "\n");
  }
}

void fxRemapScript(txMachine* the, txScript* script)
{
  mxPushUndefined();
  if (script->symbolsBuffer) {
    txByte* p = script->symbolsBuffer;
    txID c, i;
    mxDecodeID(p, c);
    the->stack->value.callback.address = C_NULL;
    the->stack->value.IDs = (txID*)fxNewChunk(the, c * sizeof(txID));
    the->stack->kind = XS_IDS_KIND;
    the->stack->value.IDs[0] = XS_NO_ID;
    for (i = 1; i < c; i++) {
      txID id = fxNewNameC(the, (txString)p);
      the->stack->value.IDs[i] = id;
      p += mxStringLength((char*)p) + 1;
    }
    fxRemapIDs(the, script->codeBuffer, script->codeSize, the->stack->value.IDs);
    the->stack->value.IDs = C_NULL;
  }  
  else {
    the->stack->value.IDs = C_NULL;
    the->stack->kind = XS_IDS_KIND;
  }
}

txBoolean fxToNumericInteger(txMachine* the, txSlot* theSlot)
{
  if (theSlot->kind == XS_REFERENCE_KIND)
    fxToPrimitive(the, theSlot, XS_NUMBER_HINT);
  if ((theSlot->kind == XS_BIGINT_KIND) || (theSlot->kind == XS_BIGINT_X_KIND))
    return 0;
  fxToInteger(the, theSlot);
  return 1;
}

txBoolean fxToNumericIntegerUnary(txMachine* the, txSlot* a, txBigIntUnary op)
{
  if (fxToNumericInteger(the, a))
    return 1;
  a->value.bigint = *(*op)(the, C_NULL, &a->value.bigint);
  a->kind = XS_BIGINT_KIND;
  the->stack = a;
  return 0;   
}

txBoolean fxToNumericIntegerBinary(txMachine* the, txSlot* a, txSlot* b, txBigIntBinary op)
{
  txBoolean ra = fxToNumericInteger(the, a);
  txBoolean rb = fxToNumericInteger(the, b);
  if (ra) {
    if (rb)
      return 1;
    mxTypeError("cannot coerce left operand to bigint");
  }
  else if (rb)
    mxTypeError("cannot coerce right operand to bigint");
  a->value.bigint = *(*op)(the, C_NULL, &a->value.bigint, &b->value.bigint);
  a->kind = XS_BIGINT_KIND;
  the->stack = b;
  return 0;   
}

txBoolean fxToNumericNumber(txMachine* the, txSlot* theSlot)
{
  if (theSlot->kind == XS_REFERENCE_KIND)
    fxToPrimitive(the, theSlot, XS_NUMBER_HINT);
  if ((theSlot->kind == XS_BIGINT_KIND) || (theSlot->kind == XS_BIGINT_X_KIND))
    return 0;
  fxToNumber(the, theSlot);
  return 1;
}

txBoolean fxToNumericNumberUnary(txMachine* the, txSlot* a, txBigIntUnary op)
{
  if (fxToNumericNumber(the, a))
    return 1;
  a->value.bigint = *(*op)(the, C_NULL, &a->value.bigint);
  a->kind = XS_BIGINT_KIND;
  the->stack = a;
  return 0;   
}

txBoolean fxToNumericNumberBinary(txMachine* the, txSlot* a, txSlot* b, txBigIntBinary op)
{
  txBoolean ra = fxToNumericNumber(the, a);
  txBoolean rb = fxToNumericNumber(the, b);
  if (ra) {
    if (rb)
      return 1;
    mxTypeError("cannot coerce left operand to bigint");
  }
  else if (rb)
    mxTypeError("cannot coerce right operand to bigint");
  a->value.bigint = *(*op)(the, C_NULL, &a->value.bigint, &b->value.bigint);
  a->kind = XS_BIGINT_KIND;
  the->stack = b;
  return 0;   
}

void fxRunScript(txMachine* the, txScript* script, txSlot* _this, txSlot* _target, txSlot* closures, txSlot* object, txSlot* module)
{
  if (script) {
    mxTry(the) {
      txSlot* instance;
      txSlot* property;
      __JUMP__.code = C_NULL;
      fxRemapScript(the, script);
      if (script->callback) {
        property = the->stack;
        /* THIS */
        if (_this)
          mxPushSlot(_this);
        else
          mxPushUndefined();
        the->stack->ID = XS_NO_ID;
        /* FUNCTION */
        mxPush(mxFunctionPrototype);
        instance = fxNewFunctionInstance(the, closures ? mxID(_eval) : XS_NO_ID);
        instance->next->kind = XS_CALLBACK_KIND;
        instance->next->value.callback.address = script->callback;
        instance->next->value.callback.closures = C_NULL;
        property = mxFunctionInstanceHome(instance);
        property->value.home.object = object;
        property->value.home.module = module;
        /* RESULT */
        mxPushUndefined();
        /* FRAME */
        mxPushUninitialized();
        mxRunCount(0);
      }
      else {
        mxPushUndefined();
      }
      mxPull(mxHosts);
      mxPop();

      /* TARGET */
      if (_target)
        mxPushSlot(_target);
      /* THIS */
      if (_this)
        mxPushSlot(_this);
      else
        mxPushUndefined();
      the->stack->ID = XS_NO_ID;
      /* FUNCTION */
      mxPush(mxFunctionPrototype);
      instance = fxNewFunctionInstance(the, XS_NO_ID);
      instance->next->kind = XS_CODE_X_KIND;
      instance->next->value.code.address = script->codeBuffer;
      instance->next->value.code.closures = closures;
      property = mxFunctionInstanceHome(instance);
      property->ID = fxGenerateProfileID(the);
      property->value.home.object = object;
      property->value.home.module = module;
      /* RESULT */
            mxPushUndefined();
      /* FRAME */
      mxPushUninitialized();
      if (_target)
        the->stack->flag |= XS_TARGET_FLAG;
      mxRunCount(0);

      mxPushUndefined();
      mxPull(mxHosts);
      if (script->symbolsBuffer)
        fxDeleteScript(script);
    }
    mxCatch(the) {
      if (script->symbolsBuffer)
        fxDeleteScript(script);
      fxJump(the);
    }
  }
  else {
    mxSyntaxError("invalid script");
  }
}

void fxRunUsed(txMachine* the, txSlot* selector)
{
#if mxExplicitResourceManagement
  txSlot* exception = selector + 1;
  fxBeginHost(the);
  {
    if (selector->value.integer == 0) {
      mxPush(mxSuppressedErrorConstructor);
      mxNew();
      mxPush(mxException);
      mxPushSlot(exception);
      mxRunCount(2);
      mxPullSlot(exception);
    }
    else {
      *exception = mxException;
      selector->value.integer = 0;
    }
    mxException = mxUndefined;
  }
  fxEndHost(the);
#else
  mxTypeError("using: unavailable feature");
#endif
}

void fxRunUsing(txMachine* the)
{
#if mxExplicitResourceManagement
  txSlot* resource = the->stack;
  fxBeginHost(the);
  mxPushSlot(resource);
  if (!mxIsNull(resource) && !mxIsUndefined(resource)) {
    mxGetID(mxID(_Symbol_dispose));
    if (!fxIsCallable(the, the->stack))
      mxTypeError("using: [Symbol.dispose] is not a function");
  }
  else
    the->stack->kind = XS_NULL_KIND;
  mxPullSlot(resource);
  fxEndHost(the);
#else
  mxTypeError("using: unavailable feature");
#endif
}

void fxRunUsingAsync(txMachine* the)
{
#if mxExplicitResourceManagement
  txSlot* resource = the->stack;
  fxBeginHost(the);
  mxPushSlot(resource);
  if (!mxIsNull(resource) && !mxIsUndefined(resource)) {
    mxGetID(mxID(_Symbol_asyncDispose));
    if (!fxIsCallable(the, the->stack)) {
      mxPop();
      mxPushSlot(resource);
      mxGetID(mxID(_Symbol_dispose));
    }
    if (!fxIsCallable(the, the->stack))
      mxTypeError("using: neither [Symbol.asyncDispose] nor [Symbol.dispose] are function");
  }
  else
    the->stack->kind = XS_NULL_KIND;
  mxPullSlot(resource);
  fxEndHost(the);
#else
  mxTypeError("using: unavailable feature");
#endif
}

#ifdef mxMetering
void fxCheckMeter(void* console)
{
  txMachine* the = console;
  if (the->meterInterval && (the->meterIndex > the->meterCount)) {
    fxCheckMetering(the);
  }
}
void fxMeterSome(void* console, txU4 count)
{
  txMachine* the = console;
  the->meterIndex += count * XS_PARSE_CODE_METERING;
}
#endif









Coverage Report

Created: 2026-08-13 06:36