@agoric/xsnap 0.14.3-u14.0 → 0.14.3-u16.0

package/moddable/xs/sources/xsCode.c

@@ -0,0 +1,4493 @@
+/*
+ * Copyright (c) 2016-2017  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 "xsScript.h"
+
+//#define mxCodePrint 1
+
+#define mxByteCodePart\
+	txByteCode* nextCode;\
+	txInteger id;\
+	txInteger stackLevel
+	
+struct sxByteCode {
+	mxByteCodePart;
+};
+	
+struct sxBigIntCode {
+	mxByteCodePart;
+	txBigInt bigint;
+};
+	
+struct sxBranchCode {
+	mxByteCodePart;
+	txTargetCode* target;
+};
+	
+struct sxIndexCode {
+	mxByteCodePart;
+	txInteger index;
+};
+	
+struct sxIntegerCode {
+	mxByteCodePart;
+	txInteger integer;
+};
+	
+struct sxNumberCode {
+	mxByteCodePart;
+	txNumber number;
+};
+	
+struct sxStringCode {
+	mxByteCodePart;
+	txInteger length;
+	txString string;
+};
+	
+struct sxSymbolCode {
+	mxByteCodePart;
+	txSymbol* symbol;
+};
+
+struct sxTargetCode {
+	mxByteCodePart;
+	txInteger index;
+	txLabelNode* label;
+	txTargetCode* nextTarget;
+	txInteger environmentLevel;
+	txInteger scopeLevel;
+	txInteger offset;
+	txTargetCode* original;
+};
+	
+struct sxVariableCode {
+	mxByteCodePart;
+	txSymbol* symbol;
+	txInteger index;
+};
+
+struct sxCoder {
+	txParser* parser;
+	txByteCode* firstCode;
+	txByteCode* lastCode;
+	txTargetCode* firstBreakTarget;
+	txTargetCode* firstContinueTarget;
+	txTargetCode* returnTarget;
+	txInteger environmentLevel;
+	txInteger scopeLevel;
+	txInteger stackLevel;
+	txInteger targetIndex;
+	txSymbol* path;
+	txInteger line;
+	txBoolean programFlag;
+	txBoolean evalFlag;
+	txBoolean importFlag;
+	txBoolean importMetaFlag;
+	txClassNode* classNode;
+	txTargetCode* chainTarget;
+};
+
+typedef void (*txCompound)(void* it, void* param, txByte step);
+
+static void fxCoderAdd(txCoder* self, txInteger delta, void* it);
+static void fxCoderAddBigInt(txCoder* self, txInteger delta, txInteger id, txBigInt* bigint);
+static void fxCoderAddBranch(txCoder* self, txInteger delta, txInteger id, txTargetCode* target);
+static void fxCoderAddByte(txCoder* self, txInteger delta, txInteger id);
+static void fxCoderAddIndex(txCoder* self, txInteger delta, txInteger id, txInteger index);
+static void fxCoderAddInteger(txCoder* self, txInteger delta, txInteger id, txInteger integer);
+static void fxCoderAddLine(txCoder* self, txInteger delta, txInteger id, txNode* node);
+static void fxCoderAddNumber(txCoder* self, txInteger delta, txInteger id, txNumber number);
+static void fxCoderAddString(txCoder* self, txInteger delta, txInteger id, txInteger length, txString string);
+static void fxCoderAddSymbol(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol);
+static void fxCoderAddVariable(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol, txInteger index);
+static void fxCoderAdjustEnvironment(txCoder* self, txTargetCode* target);
+static void fxCoderAdjustScope(txCoder* self, txTargetCode* target);
+static txTargetCode* fxCoderAliasTargets(txCoder* self, txTargetCode* target);
+static txInteger fxCoderCountParameters(txCoder* self, txNode* it);
+static txTargetCode* fxCoderCreateTarget(txCoder* self);
+static txTargetCode* fxCoderFinalizeTargets(txCoder* self, txTargetCode* alias, txInteger selector, txInteger* address, txTargetCode* finallyTarget);
+static void fxCoderJumpTargets(txCoder* self, txTargetCode* target, txInteger selector, txInteger* address);
+static void fxCoderOptimize(txCoder* self);
+static txInteger fxCoderUseTemporaryVariable(txCoder* self);
+static void fxCoderUnuseTemporaryVariables(txCoder* self, txInteger count);
+
+static void fxScopeCoded(txScope* self, txCoder* coder);
+static void fxScopeCodedBody(txScope* self, txCoder* coder);
+static void fxScopeCodingBlock(txScope* self, txCoder* coder);
+static void fxScopeCodingBody(txScope* self, txCoder* coder);
+static void fxScopeCodingParams(txScope* self, txCoder* coder);
+static void fxScopeCodingProgram(txScope* self, txCoder* coder);
+static void fxScopeCodeDefineNodes(txScope* self, txCoder* coder);
+static void fxScopeCodeRefresh(txScope* self, txCoder* coder);
+static void fxScopeCodeReset(txScope* self, txCoder* coder);
+static void fxScopeCodeRetrieve(txScope* self, txCoder* coder);
+static void fxScopeCodeStore(txScope* self, txCoder* coder);
+static void fxScopeCodeStoreAll(txScope* self, txCoder* coder);
+
+static void fxNodeDispatchCode(void* it, void* param);
+static void fxNodeDispatchCodeAssign(void* it, void* param, txFlag flag);
+static void fxNodeDispatchCodeDelete(void* it, void* param);
+static void fxNodeDispatchCodeReference(void* it, void* param);
+static txFlag fxNodeDispatchCodeThis(void* it, void* param, txFlag flag);
+
+static txFlag fxNodeCodeName(txNode* value);
+static void fxCompoundExpressionNodeCodeName(void* it, void* param);
+static void fxSpreadNodeCode(void* it, void* param, txInteger counter);
+
+txScript* fxParserCode(txParser* parser)
+{
+	txCoder coder;
+	txByteCode* code;
+	txScript* script;
+	txSize size, delta, offset;
+	txSymbol* symbol;
+	txSymbol** address;
+	txSize c, i;
+	txID id, count;
+	txSize total;
+	txByte* p;
+	txHostNode* node;
+
+    c_memset(&coder, 0, sizeof(txCoder));
+	coder.parser = parser;
+	if (parser->errorCount == 0) {
+		mxTryParser(parser) {
+			txNode* self = parser->root;
+			(*self->description->dispatch->code)(parser->root, &coder);
+		}
+		mxCatchParser(parser) {
+		}
+	}
+	if (parser->errorCount) {
+		if (parser->console) {
+			coder.firstCode = NULL;
+			coder.lastCode = NULL;
+			fxCoderAddByte(&coder, 1, XS_CODE_GLOBAL);
+			fxCoderAddSymbol(&coder, 0, XS_CODE_GET_VARIABLE, parser->errorSymbol);
+			fxCoderAddByte(&coder, 2, XS_CODE_NEW);
+			fxCoderAddString(&coder, 1, XS_CODE_STRING_1, mxStringLength(parser->errorMessage), parser->errorMessage);
+			fxCoderAddInteger(&coder, -3, XS_CODE_RUN_1, 1);
+			fxCoderAddByte(&coder, -1, XS_CODE_THROW);
+		}
+		else
+			return C_NULL;
+	}
+	
+	fxCoderOptimize(&coder);
+	
+	script = c_malloc(sizeof(txScript));
+	if (!script) goto bail;
+	c_memset(script, 0, sizeof(txScript));
+	
+	code = coder.firstCode;
+	size = 0;
+	delta = 0;
+	while (code) {
+		txInteger value;
+		switch (code->id) {
+		case XS_NO_CODE:
+			((txTargetCode*)code)->offset = size;
+			break;
+		case XS_CODE_BRANCH_1:
+		case XS_CODE_BRANCH_CHAIN_1:
+		case XS_CODE_BRANCH_COALESCE_1:
+		case XS_CODE_BRANCH_ELSE_1:
+		case XS_CODE_BRANCH_IF_1:
+		case XS_CODE_BRANCH_STATUS_1:
+		case XS_CODE_CATCH_1:
+		case XS_CODE_CODE_1:
+			size += 2;
+			delta += 3;
+			break;
+			
+		case XS_CODE_ARGUMENT:
+		case XS_CODE_ARGUMENTS:
+		case XS_CODE_ARGUMENTS_SLOPPY:
+		case XS_CODE_ARGUMENTS_STRICT:
+		case XS_CODE_BEGIN_SLOPPY:
+		case XS_CODE_BEGIN_STRICT:
+		case XS_CODE_BEGIN_STRICT_BASE:
+		case XS_CODE_BEGIN_STRICT_DERIVED:
+		case XS_CODE_BEGIN_STRICT_FIELD:
+		case XS_CODE_MODULE:
+			size += 2;
+			break;
+
+		case XS_CODE_LINE:
+			size += 3;
+			break;
+		case XS_CODE_ASYNC_FUNCTION:
+		case XS_CODE_ASYNC_GENERATOR_FUNCTION:
+		case XS_CODE_CONSTRUCTOR_FUNCTION:
+		case XS_CODE_DELETE_PROPERTY:
+		case XS_CODE_DELETE_SUPER:
+		case XS_CODE_FILE:
+		case XS_CODE_FUNCTION:
+		case XS_CODE_GENERATOR_FUNCTION:
+		case XS_CODE_GET_PROPERTY:
+		case XS_CODE_GET_SUPER:
+		case XS_CODE_GET_THIS_VARIABLE:
+		case XS_CODE_GET_VARIABLE:
+		case XS_CODE_EVAL_PRIVATE:
+		case XS_CODE_EVAL_REFERENCE:
+		case XS_CODE_NAME:
+		case XS_CODE_NEW_CLOSURE:
+		case XS_CODE_NEW_LOCAL:
+		case XS_CODE_NEW_PROPERTY:
+		case XS_CODE_PROGRAM_REFERENCE:
+		case XS_CODE_SET_PROPERTY:
+		case XS_CODE_SET_SUPER:
+		case XS_CODE_SET_VARIABLE:
+		case XS_CODE_SYMBOL:
+		case XS_CODE_PROFILE:
+			size += 1 + sizeof(txID);
+			break;
+			
+		case XS_CODE_STRING_1:
+			size += ((txStringCode*)code)->length;
+			// continue
+		case XS_CODE_RESERVE_1:
+		case XS_CODE_RETRIEVE_1:
+		case XS_CODE_UNWIND_1:
+			value = ((txIndexCode*)code)->index;
+			if (value > 65535) {
+				code->id += 2;
+				size += 5;
+			}
+			else if (value > 255) {
+				code->id += 1;
+				size += 3;
+			}
+			else
+				size += 2;
+			break;
+		case XS_CODE_BIGINT_1:
+			value = fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
+			if (value > 255) {
+				code->id += 1;
+				size += 3;
+			}
+			else
+				size += 2;
+			size += value;
+			break;
+			
+		case XS_CODE_CONST_CLOSURE_1:
+		case XS_CODE_CONST_LOCAL_1:
+		case XS_CODE_GET_CLOSURE_1:
+		case XS_CODE_GET_LOCAL_1:
+		case XS_CODE_GET_PRIVATE_1:
+		case XS_CODE_HAS_PRIVATE_1:
+		case XS_CODE_LET_CLOSURE_1:
+		case XS_CODE_LET_LOCAL_1:
+		case XS_CODE_NEW_PRIVATE_1:
+		case XS_CODE_PULL_CLOSURE_1:
+		case XS_CODE_PULL_LOCAL_1:
+		case XS_CODE_REFRESH_CLOSURE_1:
+		case XS_CODE_REFRESH_LOCAL_1:
+		case XS_CODE_RESET_CLOSURE_1:
+		case XS_CODE_RESET_LOCAL_1:
+		case XS_CODE_SET_CLOSURE_1:
+		case XS_CODE_SET_LOCAL_1:
+		case XS_CODE_SET_PRIVATE_1:
+		case XS_CODE_STORE_1:
+		case XS_CODE_VAR_CLOSURE_1:
+		case XS_CODE_VAR_LOCAL_1:
+			value = ((txIndexCode*)code)->index + 1;
+			if (value > 65535) {
+				code->id += 2;
+				size += 5;
+			}
+			else if (value > 255) {
+				code->id += 1;
+				size += 3;
+			}
+			else
+				size += 2;
+			break;
+			
+		case XS_CODE_INTEGER_1: 
+		case XS_CODE_RUN_1: 
+		case XS_CODE_RUN_TAIL_1: 
+			value = ((txIntegerCode*)code)->integer;
+			if ((value < -32768) || (value > 32767)) {
+				code->id += 2;
+				size += 5;
+			}
+			else if ((value < -128) || (value > 127)) {
+				code->id += 1;
+				size += 3;
+			}
+			else
+				size += 2;
+			break;
+		case XS_CODE_NUMBER:
+			size += 9;
+			break;
+			
+		case XS_CODE_HOST:
+			size += 3;
+			break;
+			
+		default:
+			size++;
+			break;
+		}
+		code = code->nextCode;
+	}	
+	
+	code = coder.firstCode;
+	size = 0;
+	while (code) {
+		switch (code->id) {
+		case XS_NO_CODE:
+			((txTargetCode*)code)->offset = size;
+			break;
+		case XS_CODE_BRANCH_1:
+		case XS_CODE_BRANCH_CHAIN_1:
+		case XS_CODE_BRANCH_COALESCE_1:
+		case XS_CODE_BRANCH_ELSE_1:
+		case XS_CODE_BRANCH_IF_1:
+		case XS_CODE_BRANCH_STATUS_1:
+		case XS_CODE_CATCH_1:
+		case XS_CODE_CODE_1:
+			offset = ((txBranchCode*)code)->target->offset - (size + 5);
+			if ((offset < -32768) || (offset + delta > 32767)) {
+				code->id += 2;
+				size += 5;
+			}
+			else if ((offset < -128) || (offset + delta > 127)) {
+				code->id += 1;
+				delta -= 2;
+				size += 3;
+			}
+			else {
+				delta -= 3;
+				size += 2;
+			}
+			break;
+			
+		case XS_CODE_ARGUMENT:
+		case XS_CODE_ARGUMENTS:
+		case XS_CODE_ARGUMENTS_SLOPPY:
+		case XS_CODE_ARGUMENTS_STRICT:
+		case XS_CODE_BEGIN_SLOPPY:
+		case XS_CODE_BEGIN_STRICT:
+		case XS_CODE_BEGIN_STRICT_BASE:
+		case XS_CODE_BEGIN_STRICT_DERIVED:
+		case XS_CODE_BEGIN_STRICT_FIELD:
+		case XS_CODE_MODULE:
+			size += 2;
+			break;
+		case XS_CODE_LINE:
+			size += 3;
+			break;
+		case XS_CODE_ASYNC_FUNCTION:
+		case XS_CODE_ASYNC_GENERATOR_FUNCTION:
+		case XS_CODE_CONSTRUCTOR_FUNCTION:
+		case XS_CODE_DELETE_PROPERTY:
+		case XS_CODE_DELETE_SUPER:
+		case XS_CODE_FILE:
+		case XS_CODE_FUNCTION:
+		case XS_CODE_GENERATOR_FUNCTION:
+		case XS_CODE_GET_PROPERTY:
+		case XS_CODE_GET_SUPER:
+		case XS_CODE_GET_THIS_VARIABLE:
+		case XS_CODE_GET_VARIABLE:
+		case XS_CODE_EVAL_PRIVATE:
+		case XS_CODE_EVAL_REFERENCE:
+		case XS_CODE_NAME:
+		case XS_CODE_NEW_CLOSURE:
+		case XS_CODE_NEW_LOCAL:
+		case XS_CODE_NEW_PROPERTY:
+		case XS_CODE_PROGRAM_REFERENCE:
+		case XS_CODE_SET_PROPERTY:
+		case XS_CODE_SET_SUPER:
+		case XS_CODE_SET_VARIABLE:
+		case XS_CODE_SYMBOL:
+			symbol = ((txSymbolCode*)code)->symbol;
+			if (symbol && symbol->string)
+				symbol->usage++;
+			size += 1 + sizeof(txID);
+			break;
+		case XS_CODE_PROFILE:
+			size += 1 + sizeof(txID);
+			break;
+			
+		case XS_CODE_CONST_CLOSURE_1:
+		case XS_CODE_CONST_LOCAL_1:
+		case XS_CODE_GET_CLOSURE_1:
+		case XS_CODE_GET_LOCAL_1:
+		case XS_CODE_GET_PRIVATE_1:
+		case XS_CODE_HAS_PRIVATE_1:
+		case XS_CODE_LET_CLOSURE_1:
+		case XS_CODE_LET_LOCAL_1:
+		case XS_CODE_NEW_PRIVATE_1:
+		case XS_CODE_PULL_CLOSURE_1:
+		case XS_CODE_PULL_LOCAL_1:
+		case XS_CODE_REFRESH_CLOSURE_1:
+		case XS_CODE_REFRESH_LOCAL_1:
+		case XS_CODE_RESERVE_1:
+		case XS_CODE_RESET_CLOSURE_1:
+		case XS_CODE_RESET_LOCAL_1:
+		case XS_CODE_RETRIEVE_1:
+		case XS_CODE_SET_CLOSURE_1:
+		case XS_CODE_SET_LOCAL_1:
+		case XS_CODE_SET_PRIVATE_1:
+		case XS_CODE_STORE_1:
+		case XS_CODE_VAR_CLOSURE_1:
+		case XS_CODE_VAR_LOCAL_1:
+		case XS_CODE_UNWIND_1:
+			size += 2;
+			break;
+		case XS_CODE_CONST_CLOSURE_2:
+		case XS_CODE_CONST_LOCAL_2:
+		case XS_CODE_GET_CLOSURE_2:
+		case XS_CODE_GET_LOCAL_2:
+		case XS_CODE_GET_PRIVATE_2:
+		case XS_CODE_HAS_PRIVATE_2:
+		case XS_CODE_LET_CLOSURE_2:
+		case XS_CODE_LET_LOCAL_2:
+		case XS_CODE_NEW_PRIVATE_2:
+		case XS_CODE_PULL_CLOSURE_2:
+		case XS_CODE_PULL_LOCAL_2:
+		case XS_CODE_REFRESH_CLOSURE_2:
+		case XS_CODE_REFRESH_LOCAL_2:
+		case XS_CODE_RESERVE_2:
+		case XS_CODE_RESET_CLOSURE_2:
+		case XS_CODE_RESET_LOCAL_2:
+		case XS_CODE_RETRIEVE_2:
+		case XS_CODE_SET_CLOSURE_2:
+		case XS_CODE_SET_LOCAL_2:
+		case XS_CODE_SET_PRIVATE_2:
+		case XS_CODE_STORE_2:
+		case XS_CODE_VAR_CLOSURE_2:
+		case XS_CODE_VAR_LOCAL_2:
+		case XS_CODE_UNWIND_2:
+			size += 3;
+			break;
+		
+		case XS_CODE_INTEGER_1: 
+		case XS_CODE_RUN_1: 
+		case XS_CODE_RUN_TAIL_1: 
+			size += 2;
+			break;
+		case XS_CODE_INTEGER_2: 
+		case XS_CODE_RUN_2: 
+		case XS_CODE_RUN_TAIL_2: 
+			size += 3;
+			break;
+		case XS_CODE_INTEGER_4: 
+		case XS_CODE_RUN_4: 
+		case XS_CODE_RUN_TAIL_4: 
+			size += 5;
+			break;
+		case XS_CODE_NUMBER:
+			size += 9;
+			break;
+		case XS_CODE_STRING_1:
+			size += 2 + ((txStringCode*)code)->length;
+			break;
+		case XS_CODE_STRING_2:
+			size += 3 + ((txStringCode*)code)->length;
+			break;
+		case XS_CODE_STRING_4:
+			size += 5 + ((txStringCode*)code)->length;
+			break;
+		case XS_CODE_BIGINT_1:
+			size += 2 + fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
+			break;
+		case XS_CODE_BIGINT_2:
+			size += 3 + fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
+			break;
+			
+		case XS_CODE_HOST:
+			size += 3;
+			break;
+		
+		default:
+			size++;
+			break;
+		}
+		code = code->nextCode;
+	}	
+	
+	node = parser->firstHostNode;
+	while (node) {
+		if (node->symbol)
+			node->symbol->usage++;
+		node = node->nextHostNode;
+	}
+	
+	address = parser->symbolTable;
+	c = parser->symbolModulo;
+	id = 1;
+	total = sizeof(txID);
+	for (i = 0; i < c; i++) {
+		txSymbol* symbol = *address;
+		while (symbol) {
+			if (symbol->usage) {
+				symbol->ID = id;
+				id++;
+				total += symbol->length;
+			}
+			symbol = symbol->next;
+		}
+		address++;
+	}
+	count = id;
+		
+	script->codeBuffer = c_malloc(size);
+	if (!script->codeBuffer) goto bail;
+	script->codeSize = size;
+	
+	code = coder.firstCode;
+	p = script->codeBuffer;
+	while (code) {
+		txS1 s1; txS2 s2; txS4 s4; 
+		txU1 u1; txU2 u2;
+		txNumber n;
+		if (code->id)
+			*p++ = (txS1)(code->id);
+		switch (code->id) {
+		case XS_CODE_BRANCH_1:
+		case XS_CODE_BRANCH_CHAIN_1:
+		case XS_CODE_BRANCH_COALESCE_1:
+		case XS_CODE_BRANCH_ELSE_1:
+		case XS_CODE_BRANCH_IF_1:
+		case XS_CODE_BRANCH_STATUS_1:
+		case XS_CODE_CATCH_1:
+		case XS_CODE_CODE_1:
+			offset = mxPtrDiff(p + 1 - script->codeBuffer);
+			s1 = (txS1)(((txBranchCode*)code)->target->offset - offset);
+			*p++ = s1;
+			break;
+		case XS_CODE_BRANCH_2:
+		case XS_CODE_BRANCH_CHAIN_2:
+		case XS_CODE_BRANCH_COALESCE_2:
+		case XS_CODE_BRANCH_ELSE_2:
+		case XS_CODE_BRANCH_IF_2:
+		case XS_CODE_BRANCH_STATUS_2:
+		case XS_CODE_CATCH_2:
+		case XS_CODE_CODE_2:
+			offset = mxPtrDiff(p + 2 - script->codeBuffer);
+			s2 = (txS2)(((txBranchCode*)code)->target->offset - offset);
+			mxEncode2(p, s2);
+			break;
+		case XS_CODE_BRANCH_4:
+		case XS_CODE_BRANCH_CHAIN_4:
+		case XS_CODE_BRANCH_COALESCE_4:
+		case XS_CODE_BRANCH_ELSE_4:
+		case XS_CODE_BRANCH_IF_4:
+		case XS_CODE_BRANCH_STATUS_4:
+		case XS_CODE_CATCH_4:
+		case XS_CODE_CODE_4:
+			offset = mxPtrDiff(p + 4 - script->codeBuffer);
+			s4 = (txS4)(((txBranchCode*)code)->target->offset  - offset);
+			mxEncode4(p, s4);
+			break;
+			
+		case XS_CODE_ASYNC_FUNCTION:
+		case XS_CODE_ASYNC_GENERATOR_FUNCTION:
+		case XS_CODE_CONSTRUCTOR_FUNCTION:
+		case XS_CODE_DELETE_PROPERTY:
+		case XS_CODE_DELETE_SUPER:
+		case XS_CODE_FILE:
+		case XS_CODE_FUNCTION:
+		case XS_CODE_GENERATOR_FUNCTION:
+		case XS_CODE_GET_PROPERTY:
+		case XS_CODE_GET_SUPER:
+		case XS_CODE_GET_THIS_VARIABLE:
+		case XS_CODE_GET_VARIABLE:
+		case XS_CODE_EVAL_PRIVATE:
+		case XS_CODE_EVAL_REFERENCE:
+		case XS_CODE_NAME:
+		case XS_CODE_NEW_CLOSURE:
+		case XS_CODE_NEW_LOCAL:
+		case XS_CODE_NEW_PROPERTY:
+		case XS_CODE_PROGRAM_REFERENCE:
+		case XS_CODE_SET_PROPERTY:
+		case XS_CODE_SET_SUPER:
+		case XS_CODE_SET_VARIABLE:
+		case XS_CODE_SYMBOL:
+			symbol = ((txSymbolCode*)code)->symbol;
+			if (symbol && symbol->string)
+				id = symbol->ID;
+			else
+				id = XS_NO_ID;
+			mxEncodeID(p, id);
+			break;
+		case XS_CODE_PROFILE:
+			id = fxGenerateProfileID(parser->console);
+			mxEncodeID(p, id);
+			break;
+			
+		case XS_CODE_ARGUMENT:
+		case XS_CODE_ARGUMENTS:
+		case XS_CODE_ARGUMENTS_SLOPPY:
+		case XS_CODE_ARGUMENTS_STRICT:
+		case XS_CODE_BEGIN_SLOPPY:
+		case XS_CODE_BEGIN_STRICT:
+		case XS_CODE_BEGIN_STRICT_BASE:
+		case XS_CODE_BEGIN_STRICT_DERIVED:
+		case XS_CODE_BEGIN_STRICT_FIELD:
+		case XS_CODE_MODULE:
+		case XS_CODE_RESERVE_1:
+		case XS_CODE_RETRIEVE_1:
+		case XS_CODE_UNWIND_1:
+			u1 = (txU1)(((txIndexCode*)code)->index);
+			*((txU1*)p++) = u1;
+			break;
+		case XS_CODE_LINE:
+		case XS_CODE_RESERVE_2:
+		case XS_CODE_RETRIEVE_2:
+		case XS_CODE_UNWIND_2:
+			u2 = (txU2)(((txIndexCode*)code)->index);
+			mxEncode2(p, u2);
+			break;
+
+		case XS_CODE_CONST_CLOSURE_1:
+		case XS_CODE_CONST_LOCAL_1:
+		case XS_CODE_GET_CLOSURE_1:
+		case XS_CODE_GET_LOCAL_1:
+		case XS_CODE_GET_PRIVATE_1:
+		case XS_CODE_HAS_PRIVATE_1:
+		case XS_CODE_LET_CLOSURE_1:
+		case XS_CODE_LET_LOCAL_1:
+		case XS_CODE_NEW_PRIVATE_1:
+		case XS_CODE_PULL_CLOSURE_1:
+		case XS_CODE_PULL_LOCAL_1:
+		case XS_CODE_REFRESH_CLOSURE_1:
+		case XS_CODE_REFRESH_LOCAL_1:
+		case XS_CODE_RESET_CLOSURE_1:
+		case XS_CODE_RESET_LOCAL_1:
+		case XS_CODE_SET_CLOSURE_1:
+		case XS_CODE_SET_LOCAL_1:
+		case XS_CODE_SET_PRIVATE_1:
+		case XS_CODE_STORE_1:
+		case XS_CODE_VAR_CLOSURE_1:
+		case XS_CODE_VAR_LOCAL_1:
+			u1 = (txU1)(((txIndexCode*)code)->index + 1);
+			*((txU1*)p++) = u1;
+			break;
+
+		case XS_CODE_CONST_CLOSURE_2:
+		case XS_CODE_CONST_LOCAL_2:
+		case XS_CODE_GET_CLOSURE_2:
+		case XS_CODE_GET_LOCAL_2:
+		case XS_CODE_GET_PRIVATE_2:
+		case XS_CODE_HAS_PRIVATE_2:
+		case XS_CODE_LET_CLOSURE_2:
+		case XS_CODE_LET_LOCAL_2:
+		case XS_CODE_NEW_PRIVATE_2:
+		case XS_CODE_PULL_CLOSURE_2:
+		case XS_CODE_PULL_LOCAL_2:
+		case XS_CODE_REFRESH_CLOSURE_2:
+		case XS_CODE_REFRESH_LOCAL_2:
+		case XS_CODE_RESET_CLOSURE_2:
+		case XS_CODE_RESET_LOCAL_2:
+		case XS_CODE_SET_CLOSURE_2:
+		case XS_CODE_SET_LOCAL_2:
+		case XS_CODE_SET_PRIVATE_2:
+		case XS_CODE_STORE_2:
+		case XS_CODE_VAR_CLOSURE_2:
+		case XS_CODE_VAR_LOCAL_2:
+			u2 = (txU2)(((txIndexCode*)code)->index + 1);
+			mxEncode2(p, u2);
+			break;
+	
+		case XS_CODE_INTEGER_1: 
+		case XS_CODE_RUN_1: 
+		case XS_CODE_RUN_TAIL_1: 
+			s1 = (txS1)(((txIntegerCode*)code)->integer);
+			*p++ = s1;
+			break;
+		case XS_CODE_INTEGER_2: 
+		case XS_CODE_RUN_2: 
+		case XS_CODE_RUN_TAIL_2: 
+			s2 = (txS2)(((txIntegerCode*)code)->integer);
+			mxEncode2(p, s2);
+			break;
+		case XS_CODE_INTEGER_4: 
+		case XS_CODE_RUN_4: 
+		case XS_CODE_RUN_TAIL_4: 
+			s4 = (txS4)(((txIntegerCode*)code)->integer);
+			mxEncode4(p, s4);
+			break;
+		case XS_CODE_NUMBER:
+			n = ((txNumberCode*)code)->number;
+			mxEncode8(p, n);
+			break;
+		case XS_CODE_STRING_1:
+			u1 = (txU1)(((txStringCode*)code)->length);
+			*((txU1*)p++) = u1;
+			c_memcpy(p, ((txStringCode*)code)->string, u1);
+			p += u1;
+			break;
+		case XS_CODE_STRING_2:
+			u2 = (txU2)(((txStringCode*)code)->length);
+			mxEncode2(p, u2);
+			c_memcpy(p, ((txStringCode*)code)->string, u2);
+			p += u2;
+			break;
+		case XS_CODE_STRING_4:
+			s4 = (txS4)(((txStringCode*)code)->length);
+			mxEncode4(p, s4);
+			c_memcpy(p, ((txStringCode*)code)->string, s4);
+			p += s4;
+			break;
+		case XS_CODE_BIGINT_1:
+			u1 = (txU1)fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
+			*((txU1*)p++) = u1;
+			fxBigIntEncode(p, &((txBigIntCode*)code)->bigint, u1);
+			p += u1;
+			break;
+		case XS_CODE_BIGINT_2:
+			u2 = (txU2)fxBigIntMeasure(&((txBigIntCode*)code)->bigint);
+            mxEncode2(p, u2);
+			fxBigIntEncode(p, &((txBigIntCode*)code)->bigint, u2);
+			p += u2;
+			break;
+			
+		case XS_CODE_HOST:
+			u2 = (txU2)(((txIndexCode*)code)->index);
+			mxEncode2(p, u2);
+			break;
+		}
+		code = code->nextCode;
+	}	
+	
+#ifdef mxCodePrint
+	fprintf(stderr, "\n");
+	code = coder.firstCode;
+	while (code) {
+		txInteger tab;
+		for (tab = 0; tab < code->stackLevel; tab++)
+			fprintf(stderr, "\t");
+		switch (code->id) {
+		case XS_NO_CODE:
+			fprintf(stderr, "_%d\n", ((txTargetCode*)code)->index);
+			break;
+		
+		case XS_CODE_BRANCH_1:
+		case XS_CODE_BRANCH_2:
+		case XS_CODE_BRANCH_4:
+		case XS_CODE_BRANCH_CHAIN_1:
+		case XS_CODE_BRANCH_CHAIN_2:
+		case XS_CODE_BRANCH_CHAIN_4:
+		case XS_CODE_BRANCH_COALESCE_1:
+		case XS_CODE_BRANCH_COALESCE_2:
+		case XS_CODE_BRANCH_COALESCE_4:
+		case XS_CODE_BRANCH_ELSE_1:
+		case XS_CODE_BRANCH_ELSE_2:
+		case XS_CODE_BRANCH_ELSE_4:
+		case XS_CODE_BRANCH_IF_1:
+		case XS_CODE_BRANCH_IF_2:
+		case XS_CODE_BRANCH_IF_4:
+		case XS_CODE_BRANCH_STATUS_1:
+		case XS_CODE_BRANCH_STATUS_2:
+		case XS_CODE_BRANCH_STATUS_4:
+		case XS_CODE_CATCH_1:
+		case XS_CODE_CATCH_2:
+		case XS_CODE_CATCH_4:
+		case XS_CODE_CODE_1:
+		case XS_CODE_CODE_2:
+		case XS_CODE_CODE_4:
+			fprintf(stderr, "%s _%d\n", gxCodeNames[code->id], ((txBranchCode*)code)->target->index);
+			break;
+		
+		case XS_CODE_ARGUMENT:
+		case XS_CODE_ARGUMENTS:
+		case XS_CODE_ARGUMENTS_SLOPPY:
+		case XS_CODE_ARGUMENTS_STRICT:
+		case XS_CODE_BEGIN_SLOPPY:
+		case XS_CODE_BEGIN_STRICT:
+		case XS_CODE_BEGIN_STRICT_BASE:
+		case XS_CODE_BEGIN_STRICT_DERIVED:
+		case XS_CODE_BEGIN_STRICT_FIELD:
+		case XS_CODE_LINE:
+		case XS_CODE_MODULE:
+			fprintf(stderr, "%s %d\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
+			break;
+			
+		case XS_CODE_ASYNC_FUNCTION:
+		case XS_CODE_ASYNC_GENERATOR_FUNCTION:
+		case XS_CODE_CONSTRUCTOR_FUNCTION:
+		case XS_CODE_DELETE_PROPERTY:
+		case XS_CODE_DELETE_SUPER:
+		case XS_CODE_FILE:
+		case XS_CODE_FUNCTION:
+		case XS_CODE_GENERATOR_FUNCTION:
+		case XS_CODE_GET_PROPERTY:
+		case XS_CODE_GET_SUPER:
+		case XS_CODE_GET_THIS_VARIABLE:
+		case XS_CODE_GET_VARIABLE:
+		case XS_CODE_EVAL_PRIVATE:
+		case XS_CODE_EVAL_REFERENCE:
+		case XS_CODE_NAME:
+		case XS_CODE_NEW_PROPERTY:
+		case XS_CODE_PROGRAM_REFERENCE:
+		case XS_CODE_SET_PROPERTY:
+		case XS_CODE_SET_SUPER:
+		case XS_CODE_SET_VARIABLE:
+		case XS_CODE_SYMBOL:
+			symbol = ((txSymbolCode*)code)->symbol;
+			if (symbol && symbol->string)
+				fprintf(stderr, "%s %s\n", gxCodeNames[code->id], symbol->string);
+			else
+				fprintf(stderr, "%s ?\n", gxCodeNames[code->id]);
+			break;
+		
+		case XS_CODE_CONST_CLOSURE_1:
+		case XS_CODE_CONST_CLOSURE_2:
+		case XS_CODE_CONST_LOCAL_1:
+		case XS_CODE_CONST_LOCAL_2:
+		case XS_CODE_GET_CLOSURE_1:
+		case XS_CODE_GET_CLOSURE_2:
+		case XS_CODE_GET_LOCAL_1:
+		case XS_CODE_GET_LOCAL_2:
+		case XS_CODE_GET_PRIVATE_1:
+		case XS_CODE_GET_PRIVATE_2:
+		case XS_CODE_HAS_PRIVATE_1:
+		case XS_CODE_HAS_PRIVATE_2:
+		case XS_CODE_LET_CLOSURE_1:
+		case XS_CODE_LET_CLOSURE_2:
+		case XS_CODE_LET_LOCAL_1:
+		case XS_CODE_LET_LOCAL_2:
+		case XS_CODE_NEW_PRIVATE_1:
+		case XS_CODE_NEW_PRIVATE_2:
+		case XS_CODE_PULL_CLOSURE_1:
+		case XS_CODE_PULL_CLOSURE_2:
+		case XS_CODE_PULL_LOCAL_1:
+		case XS_CODE_PULL_LOCAL_2:
+		case XS_CODE_REFRESH_CLOSURE_1:
+		case XS_CODE_REFRESH_CLOSURE_2:
+		case XS_CODE_REFRESH_LOCAL_1:
+		case XS_CODE_REFRESH_LOCAL_2:
+		case XS_CODE_RESET_CLOSURE_1:
+		case XS_CODE_RESET_CLOSURE_2:
+		case XS_CODE_RESET_LOCAL_1:
+		case XS_CODE_RESET_LOCAL_2:
+		case XS_CODE_SET_CLOSURE_1:
+		case XS_CODE_SET_CLOSURE_2:
+		case XS_CODE_SET_LOCAL_1:
+		case XS_CODE_SET_LOCAL_2:
+		case XS_CODE_SET_PRIVATE_1:
+		case XS_CODE_SET_PRIVATE_2:
+		case XS_CODE_STORE_1:
+		case XS_CODE_STORE_2:
+		case XS_CODE_VAR_CLOSURE_1:
+		case XS_CODE_VAR_CLOSURE_2:
+		case XS_CODE_VAR_LOCAL_1:
+		case XS_CODE_VAR_LOCAL_2:
+			fprintf(stderr, "%s [%d]\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
+			break;
+		
+		case XS_CODE_RESERVE_1:
+		case XS_CODE_RESERVE_2:
+		case XS_CODE_UNWIND_1:
+		case XS_CODE_UNWIND_2:
+			fprintf(stderr, "%s #%d\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
+			break;
+		case XS_CODE_NEW_CLOSURE:
+		case XS_CODE_NEW_LOCAL:
+			fprintf(stderr, "[%d] %s %s\n", ((txVariableCode*)code)->index, gxCodeNames[code->id], ((txSymbolCode*)code)->symbol->string);
+			break;
+		case XS_CODE_NEW_TEMPORARY:
+			fprintf(stderr, "[%d] %s\n", ((txIndexCode*)code)->index, gxCodeNames[code->id]);
+			break;
+		case XS_CODE_RETRIEVE_1:
+		case XS_CODE_RETRIEVE_2:
+			{
+				txInteger i, c = ((txIndexCode*)code)->index;
+				fprintf(stderr, "[0");
+				for (i = 1; i < c; i++)
+					fprintf(stderr, ",%d", i);
+				fprintf(stderr, "] %s\n", gxCodeNames[code->id]);
+			}
+			break;
+		
+		case XS_CODE_INTEGER_1: 
+		case XS_CODE_INTEGER_2: 
+		case XS_CODE_INTEGER_4: 
+		case XS_CODE_RUN_1: 
+		case XS_CODE_RUN_2: 
+		case XS_CODE_RUN_4: 
+		case XS_CODE_RUN_TAIL_1: 
+		case XS_CODE_RUN_TAIL_2: 
+		case XS_CODE_RUN_TAIL_4: 
+			fprintf(stderr, "%s %d\n", gxCodeNames[code->id], ((txIntegerCode*)code)->integer);
+			break;
+		case XS_CODE_NUMBER:
+			fprintf(stderr, "%s %lf\n", gxCodeNames[code->id], ((txNumberCode*)code)->number);
+			break;
+		case XS_CODE_STRING_1:
+		case XS_CODE_STRING_2:
+		case XS_CODE_STRING_4:
+			fprintf(stderr, "%s %d \"%s\"\n", gxCodeNames[code->id], ((txStringCode*)code)->length, ((txStringCode*)code)->string);
+			break;
+		case XS_CODE_BIGINT_1:
+		case XS_CODE_BIGINT_2:
+			fprintf(stderr, "%s %d\n", gxCodeNames[code->id], fxBigIntMeasure(&((txBigIntCode*)code)->bigint));
+			break;
+			
+		case XS_CODE_HOST:
+			fprintf(stderr, "%s %d\n", gxCodeNames[code->id], ((txIndexCode*)code)->index);
+			break;
+	
+		default:
+			fprintf(stderr, "%s\n", gxCodeNames[code->id]);
+			break;
+		}
+		code = code->nextCode;
+	}
+#endif
+	script->symbolsBuffer = c_malloc(total);
+	if (!script->symbolsBuffer) goto bail;
+	script->symbolsSize = total;
+	
+	p = script->symbolsBuffer;
+	mxEncodeID(p, count);
+	
+	address = parser->symbolTable;
+	c = parser->symbolModulo;
+	for (i = 0; i < c; i++) {
+		txSymbol* symbol = *address;
+		while (symbol) {
+			if (symbol->usage) {
+				c_memcpy(p, symbol->string, symbol->length);
+				p += symbol->length;
+			}
+			symbol = symbol->next;
+		}
+		address++;
+	}
+	
+	c = (txS2)(parser->hostNodeIndex);
+	if (c) {
+		size = sizeof(txID);
+		node = parser->firstHostNode;
+		while (node) {
+			size += 1 + sizeof(txID) + node->at->length + 1;
+			node = node->nextHostNode;
+		}
+	
+		script->hostsBuffer = c_malloc(size);
+		if (!script->hostsBuffer) goto bail;
+		script->hostsSize = size;
+	
+		p = script->hostsBuffer;
+		mxEncodeID(p, c);
+		node = parser->firstHostNode;
+		while (node) {
+			*p++ = (txS1)(node->paramsCount);
+			if (node->symbol)
+				c = node->symbol->ID;
+			else
+				c = XS_NO_ID;
+			mxEncodeID(p, c);
+			c_memcpy(p, node->at->value, node->at->length);
+			p += node->at->length;
+			*p++ = 0;
+			node = node->nextHostNode;
+		}
+	}
+
+	return script;
+bail:
+	fxDeleteScript(script);
+	return C_NULL;
+}
+
+void fxCoderAdd(txCoder* self, txInteger delta, void* it)
+{
+	txByteCode* code = it;
+	if (self->lastCode)
+		self->lastCode->nextCode = code;
+	else
+		self->firstCode = code;
+	self->lastCode = code;
+	self->stackLevel += delta;
+	code->stackLevel = self->stackLevel;
+	if (self->stackLevel < 0)
+		c_fprintf(stderr, "# oops %d\n", code->id);		//@@
+}
+
+void fxCoderAddBigInt(txCoder* self, txInteger delta, txInteger id, txBigInt* bigint)
+{
+	txBigIntCode* code = fxNewParserChunkClear(self->parser, sizeof(txBigIntCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->bigint = *bigint;
+}
+
+void fxCoderAddBranch(txCoder* self, txInteger delta, txInteger id, txTargetCode* target)
+{
+	txBranchCode* code = fxNewParserChunkClear(self->parser, sizeof(txBranchCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->target = target;
+}
+
+void fxCoderAddByte(txCoder* self, txInteger delta, txInteger id)
+{
+	txByteCode* code = fxNewParserChunkClear(self->parser, sizeof(txByteCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+}
+
+void fxCoderAddIndex(txCoder* self, txInteger delta, txInteger id, txInteger index)
+{
+	txIndexCode* code = fxNewParserChunkClear(self->parser, sizeof(txIndexCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->index = index;
+}
+
+void fxCoderAddInteger(txCoder* self, txInteger delta, txInteger id, txInteger integer)
+{
+	txIntegerCode* code = fxNewParserChunkClear(self->parser, sizeof(txIntegerCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->integer = integer;
+}
+
+void fxCoderAddLine(txCoder* self, txInteger delta, txInteger id, txNode* node)
+{
+	if (self->parser->flags & mxDebugFlag) {
+		if (self->parser->lines) {
+			if (node->path != self->parser->path) {
+				node->path = self->parser->path;
+				node->line = self->parser->lines[node->line];
+			}
+		}
+		else if (self->parser->source) {
+			node->path = self->parser->source;
+		}
+		if (self->path != node->path) {
+			if (node->path) {
+				fxCoderAddSymbol(self, 0, XS_CODE_FILE, node->path);
+				fxCoderAddIndex(self, 0, id, node->line);
+			}
+			self->path = node->path;
+			self->line = node->line;
+		}
+		else if (self->line != node->line) {
+			if (self->path) {
+				txIndexCode* code = (txIndexCode*)self->lastCode;
+				if (code && (code->id == id))
+					code->index = node->line;
+				else
+					fxCoderAddIndex(self, 0, id, node->line);
+			}
+			self->line = node->line;
+		}
+	}
+}
+
+void fxCoderAddNumber(txCoder* self, txInteger delta, txInteger id, txNumber number)
+{
+	txNumberCode* code = fxNewParserChunkClear(self->parser, sizeof(txNumberCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->number = number;
+}
+
+void fxCoderAddString(txCoder* self, txInteger delta, txInteger id, txInteger length, txString string)
+{
+	txStringCode* code = fxNewParserChunkClear(self->parser, sizeof(txStringCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->length = length + 1;
+	code->string = string;
+}
+
+void fxCoderAddSymbol(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol)
+{
+	txSymbolCode* code = fxNewParserChunkClear(self->parser, sizeof(txSymbolCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->symbol = symbol;
+}
+
+void fxCoderAddVariable(txCoder* self, txInteger delta, txInteger id, txSymbol* symbol, txInteger index)
+{
+	txVariableCode* code = fxNewParserChunkClear(self->parser, sizeof(txVariableCode));
+	fxCoderAdd(self, delta, code);
+	code->id = id;
+	code->symbol = symbol;
+	code->index = index;
+}
+
+void fxCoderAdjustEnvironment(txCoder* self, txTargetCode* target)
+{
+	txInteger count = self->environmentLevel - target->environmentLevel;
+	while (count) {
+		fxCoderAddByte(self, 0, XS_CODE_WITHOUT);
+		count--;
+	}
+}
+
+void fxCoderAdjustScope(txCoder* self, txTargetCode* target)
+{
+	txInteger count = self->scopeLevel - target->scopeLevel;
+	if (count)
+		fxCoderAddIndex(self, 0, XS_CODE_UNWIND_1, count);
+}
+
+txTargetCode* fxCoderAliasTargets(txCoder* self, txTargetCode* target)
+{
+	txTargetCode* result = NULL;
+	if (target) {
+		txTargetCode* alias = result = fxNewParserChunkClear(self->parser, sizeof(txTargetCode));
+		alias->index = self->targetIndex++;
+		alias->label = target->label;
+		alias->environmentLevel = self->environmentLevel;
+		alias->scopeLevel = self->scopeLevel;
+		alias->stackLevel = self->stackLevel;
+		alias->original = target;
+		target = target->nextTarget;
+		while (target) {
+			alias = alias->nextTarget = fxNewParserChunkClear(self->parser, sizeof(txTargetCode));
+			alias->index = self->targetIndex++;
+			alias->label = target->label;
+			alias->environmentLevel = self->environmentLevel;
+			alias->scopeLevel = self->scopeLevel;
+			alias->stackLevel = self->stackLevel;
+			alias->original = target;
+			target = target->nextTarget;
+		}
+	}
+	return result;
+}
+
+txInteger fxCoderCountParameters(txCoder* self, txNode* params)
+{
+	txNode* item = ((txParamsBindingNode*)params)->items->first;
+	txInteger count = 0;
+	while (item) {
+		if (item->description->token == XS_TOKEN_REST_BINDING)
+			break;
+		if ((item->description->token != XS_TOKEN_ARG) && (item->description->token != XS_TOKEN_ARRAY_BINDING) && (item->description->token != XS_TOKEN_OBJECT_BINDING))
+			break;
+		count++;
+		item = item->next;
+	}
+	return count;
+}
+
+txTargetCode* fxCoderCreateTarget(txCoder* self)
+{
+	txTargetCode* result = fxNewParserChunkClear(self->parser, sizeof(txTargetCode));
+	result->index = self->targetIndex++;
+	result->environmentLevel = self->environmentLevel;
+	result->scopeLevel = self->scopeLevel;
+	result->stackLevel = self->stackLevel;
+	return result;
+}
+
+txTargetCode* fxCoderFinalizeTargets(txCoder* self, txTargetCode* alias, txInteger selector, txInteger* address, txTargetCode* finallyTarget)
+{
+	txTargetCode* result = NULL;
+	txInteger selection = *address;
+	if (alias) {
+		result = alias->original;
+		while (alias) {
+			fxCoderAdd(self, 0, alias);
+			fxCoderAddInteger(self, 1, XS_CODE_INTEGER_1, selection);
+			fxCoderAddIndex(self, 0, XS_CODE_SET_LOCAL_1, selector);
+			fxCoderAddByte(self, -1, XS_CODE_POP);
+			fxCoderAddBranch(self, 0, XS_CODE_BRANCH_1, finallyTarget);
+			alias = alias->nextTarget;
+			selection++;
+		}
+	}
+	*address = selection;
+	return result;
+}
+
+void fxCoderJumpTargets(txCoder* self, txTargetCode* target, txInteger selector, txInteger* address)
+{
+	txInteger selection = *address;
+	while (target) {
+		txTargetCode* elseTarget = fxCoderCreateTarget(self);
+		fxCoderAddInteger(self, 1, XS_CODE_INTEGER_1, selection);
+		fxCoderAddIndex(self, 1, XS_CODE_GET_LOCAL_1, selector);
+		fxCoderAddByte(self, -1, XS_CODE_STRICT_EQUAL);
+		fxCoderAddBranch(self, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
+		fxCoderAdjustEnvironment(self, target);
+		fxCoderAdjustScope(self, target);
+		fxCoderAddBranch(self, 0, XS_CODE_BRANCH_1, target);
+		fxCoderAdd(self, 0, elseTarget);
+		target = target->nextTarget;
+		selection++;
+	}
+	*address = selection;
+}
+
+void fxCoderOptimize(txCoder* self)
+{
+	txByteCode** address;
+	txByteCode* code;
+	
+	// branch to (target | unwind)* end => end
+	address = &self->firstCode;
+	while ((code = *address)) {
+		if (code->id == XS_CODE_BRANCH_1) {
+			txByteCode* nextCode = ((txBranchCode*)code)->target->nextCode;
+			while ((nextCode->id == XS_NO_CODE) || (nextCode->id == XS_CODE_UNWIND_1))
+				nextCode = nextCode->nextCode;
+			if ((XS_CODE_END <= nextCode->id) && (nextCode->id <= XS_CODE_END_DERIVED)) {
+				txByteCode* end = fxNewParserChunkClear(self->parser, sizeof(txByteCode));
+				end->nextCode = code->nextCode;
+				end->id = nextCode->id;
+				end->stackLevel = code->stackLevel;
+				*address = end;
+			}
+			else
+				address = &code->nextCode;
+		}
+		else
+			address = &code->nextCode;
+	}
+	// unwind (target | unwind)* end => (target | unwind)* end
+	address = &self->firstCode;
+	while ((code = *address)) {
+		if (code->id == XS_CODE_UNWIND_1) {
+			txByteCode* nextCode = code->nextCode;
+			while ((nextCode->id == XS_NO_CODE) || (nextCode->id == XS_CODE_UNWIND_1))
+				nextCode = nextCode->nextCode;
+			if ((XS_CODE_END <= nextCode->id) && (nextCode->id <= XS_CODE_END_DERIVED))
+				*address = code->nextCode;
+			else
+				address = &code->nextCode;
+		}
+		else
+			address = &code->nextCode;
+	}
+	// end target* end => target* end
+	address = &self->firstCode;
+	while ((code = *address)) {
+		if ((XS_CODE_END <= code->id) && (code->id <= XS_CODE_END_DERIVED)) {
+			txByteCode* nextCode = code->nextCode;
+			if (!nextCode)
+				break;
+			while (nextCode->id == XS_NO_CODE)
+				nextCode = nextCode->nextCode;
+			if (nextCode->id == code->id)
+				*address = code->nextCode;
+			else
+				address = &code->nextCode;
+		}
+		else
+			address = &code->nextCode;
+	}
+	// branch to next =>
+	address = &self->firstCode;
+	while ((code = *address)) {
+		if (code->id == XS_CODE_BRANCH_1) {
+			if (code->nextCode == (txByteCode*)(((txBranchCode*)code)->target))
+				*address = code->nextCode;
+			else
+				address = &code->nextCode;
+		}
+		else
+			address = &code->nextCode;
+	}
+}
+
+txInteger fxCoderUseTemporaryVariable(txCoder* self)
+{
+	txInteger result = self->scopeLevel++;
+	fxCoderAddIndex(self, 0, XS_CODE_NEW_TEMPORARY, result);
+	return result;
+}
+
+void fxCoderUnuseTemporaryVariables(txCoder* self, txInteger count)
+{
+	fxCoderAddIndex(self, 0, XS_CODE_UNWIND_1, count);
+	self->scopeLevel -= count;
+}
+
+void fxScopeCoded(txScope* self, txCoder* coder) 
+{
+	if (self->declareNodeCount) {
+		if (self->flags & mxEvalFlag) {
+			coder->environmentLevel--;
+			fxCoderAddByte(coder, 0, XS_CODE_WITHOUT);
+		}
+		fxCoderAddIndex(coder, 0, XS_CODE_UNWIND_1, self->declareNodeCount);
+		coder->scopeLevel -= self->declareNodeCount;
+	}
+}
+
+void fxScopeCodedBody(txScope* self, txCoder* coder) 
+{
+	txScope* functionScope = self->scope;
+	if ((functionScope->node->flags & mxEvalFlag) && !(functionScope->node->flags & mxStrictFlag)) {
+		coder->environmentLevel--;
+		fxCoderAddByte(coder, 0, XS_CODE_WITHOUT);
+		coder->environmentLevel--;
+		fxCoderAddByte(coder, 0, XS_CODE_WITHOUT);
+		fxCoderAddIndex(coder, 0, XS_CODE_UNWIND_1, self->declareNodeCount);
+		coder->scopeLevel -= self->declareNodeCount;
+	}
+	else 
+		fxScopeCoded(self, coder);
+}
+
+void fxScopeCodingBlock(txScope* self, txCoder* coder) 
+{
+	if (self->declareNodeCount) {
+		txDeclareNode* node = self->firstDeclareNode;
+		while (node) {
+			if (node->flags & mxDeclareNodeClosureFlag) {
+				if (!(node->flags & mxDeclareNodeUseClosureFlag)) {
+					node->index = coder->scopeLevel++;
+					fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+					if (node->description->token == XS_TOKEN_VAR) {
+						fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+						fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, node->index);
+						fxCoderAddByte(coder, -1, XS_CODE_POP);
+					}
+				}
+			}
+			else {
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+				if (node->description->token == XS_TOKEN_VAR) {
+					fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+					fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
+					fxCoderAddByte(coder, -1, XS_CODE_POP);
+				}
+			}
+			node = node->nextDeclareNode;
+		}
+		if (self->flags & mxEvalFlag) {
+			fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+			fxCoderAddByte(coder, 0, XS_CODE_WITH);
+			node = self->firstDeclareNode;
+			while (node) {
+				fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
+				node = node->nextDeclareNode;
+			}
+			fxCoderAddByte(coder, -1, XS_CODE_POP);
+			coder->environmentLevel++;
+		}
+	}
+}
+
+void fxScopeCodingBody(txScope* self, txCoder* coder) 
+{
+	if ((self->node->flags & mxEvalFlag) && !(self->node->flags & mxStrictFlag)) {
+		txDeclareNode* node = self->firstDeclareNode;
+		while (node) {
+			if (node->description->token == XS_TOKEN_DEFINE) {
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+				fxCoderAddByte(coder, 1, XS_CODE_NULL);
+				fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, node->index);
+				fxCoderAddByte(coder, -1, XS_CODE_POP);
+			}
+			else if (node->description->token == XS_TOKEN_VAR) {
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+				fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+				fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, node->index);
+				fxCoderAddByte(coder, -1, XS_CODE_POP);
+			}
+			node = node->nextDeclareNode;
+		}
+		fxCoderAddByte(coder, 1, XS_CODE_NULL);
+		fxCoderAddByte(coder, 0, XS_CODE_WITH);
+		node = self->firstDeclareNode;
+		while (node) {
+			if ((node->description->token == XS_TOKEN_DEFINE) || (node->description->token == XS_TOKEN_VAR))
+				fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
+			node = node->nextDeclareNode;
+		}
+		fxCoderAddByte(coder, -1, XS_CODE_POP);
+		coder->environmentLevel++;
+		node = self->firstDeclareNode;
+		while (node) {
+			if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+			}
+			node = node->nextDeclareNode;
+		}
+		fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(coder, 0, XS_CODE_WITH);
+		node = self->firstDeclareNode;
+		while (node) {
+			if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR))
+				fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
+			node = node->nextDeclareNode;
+		}
+		fxCoderAddByte(coder, -1, XS_CODE_POP);
+		coder->environmentLevel++;
+	}
+	else 
+		fxScopeCodingBlock(self, coder);
+}
+
+void fxScopeCodingEval(txScope* self, txCoder* coder) 
+{
+	txProgramNode* programNode = (txProgramNode*)self->node;
+	txDeclareNode* node;
+	if (self->flags & mxStrictFlag) {
+		if (programNode->scopeCount) {
+			fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->scopeCount);
+			fxScopeCodingBlock(self, coder);
+			node = self->firstDeclareNode;
+			while (node) {
+				if (node->description->token == XS_TOKEN_PRIVATE) {
+					fxCoderAddSymbol(coder, 1, XS_CODE_EVAL_PRIVATE, node->symbol);
+					fxCoderAddIndex(coder, 0, XS_CODE_CONST_CLOSURE_1, node->index);
+					fxCoderAddByte(coder, -1, XS_CODE_POP);
+				}
+				node = node->nextDeclareNode;
+			}
+		}
+	}
+	else {
+		txInteger count = 0;
+		node = self->firstDeclareNode;
+		while (node) {
+			if ((node->description->token == XS_TOKEN_DEFINE) || (node->description->token == XS_TOKEN_VAR))
+				count++;
+			node = node->nextDeclareNode;
+		}
+		if (count) {
+			fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, count);
+			node = self->firstDeclareNode;
+			while (node) {
+				if (node->description->token == XS_TOKEN_DEFINE) {
+					node->index = coder->scopeLevel++;
+					fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+					fxCoderAddByte(coder, 1, XS_CODE_NULL);
+					fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
+					fxCoderAddByte(coder, -1, XS_CODE_POP);
+				}
+				else if (node->description->token == XS_TOKEN_VAR) {
+					node->index = coder->scopeLevel++;
+					fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+					fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+					fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
+					fxCoderAddByte(coder, -1, XS_CODE_POP);
+				}
+				node = node->nextDeclareNode;
+			}
+		}
+		fxCoderAddByte(coder, 0, XS_CODE_EVAL_ENVIRONMENT);
+		coder->scopeLevel = 0;
+		if (programNode->scopeCount) {
+			fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->scopeCount);
+			if (self->declareNodeCount) {
+				node = self->firstDeclareNode;
+				while (node) {
+					if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
+						node->index = coder->scopeLevel++;
+						if (node->flags & mxDeclareNodeClosureFlag) {
+							fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+						}
+						else {
+							fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+						}
+					}
+					node = node->nextDeclareNode;
+				}
+				if (self->flags & mxEvalFlag) {
+					fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+					fxCoderAddByte(coder, 0, XS_CODE_WITH);
+					node = self->firstDeclareNode;
+					while (node) {
+						if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR))
+							fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
+						node = node->nextDeclareNode;
+					}
+					fxCoderAddByte(coder, -1, XS_CODE_POP);
+					coder->environmentLevel++;
+				}
+			}
+		}
+	}
+}
+
+void fxScopeCodingParams(txScope* self, txCoder* coder) 
+{
+	txDeclareNode* node = self->firstDeclareNode;
+	while (node) {
+		txToken token = node->description->token;
+		if ((token == XS_TOKEN_ARG) || (token == XS_TOKEN_VAR) || (token == XS_TOKEN_CONST)) {
+			if (node->flags & mxDeclareNodeClosureFlag) {
+				if (node->flags & mxDeclareNodeUseClosureFlag) {
+					fxReportParserError(self->parser, node->line, "argument %s use closure", node->symbol->string);
+				}
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+			}
+			else {
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+			}
+		}
+		node = node->nextDeclareNode;
+	}
+	if (self->flags & mxEvalFlag) {
+		if (!(self->node->flags & mxStrictFlag)) {	
+			fxCoderAddByte(coder, 1, XS_CODE_NULL);
+			fxCoderAddByte(coder, 0, XS_CODE_WITH);
+			fxCoderAddByte(coder, -1, XS_CODE_POP);
+			coder->environmentLevel++;
+		}
+		fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(coder, 0, XS_CODE_WITH);
+		node = self->firstDeclareNode;
+		while (node) {
+			txToken token = node->description->token;
+			if ((token == XS_TOKEN_ARG) || (token == XS_TOKEN_VAR) || (token == XS_TOKEN_CONST))
+				fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->index);
+			node = node->nextDeclareNode;
+		}
+		fxCoderAddByte(coder, -1, XS_CODE_POP);
+		coder->environmentLevel++;
+	}
+}
+
+void fxScopeCodingProgram(txScope* self, txCoder* coder) 
+{
+	txProgramNode* programNode = (txProgramNode*)self->node;
+	txDeclareNode* node;
+	txInteger count = 0;
+	if (programNode->variableCount) {
+		fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->variableCount);
+		node = self->firstDeclareNode;
+		while (node) {
+			if ((node->description->token != XS_TOKEN_DEFINE) && (node->description->token != XS_TOKEN_VAR)) {
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_CLOSURE, node->symbol, node->index);
+			}
+			node = node->nextDeclareNode;
+		}
+		count = coder->scopeLevel;
+		node = self->firstDeclareNode;
+		while (node) {
+			if (node->description->token == XS_TOKEN_DEFINE) {
+				// closure -> global property
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+				fxCoderAddByte(coder, 1, XS_CODE_NULL);
+				fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
+				fxCoderAddByte(coder, -1, XS_CODE_POP);
+			}
+			else if (node->description->token == XS_TOKEN_VAR) {
+				// closure -> global property
+				node->index = coder->scopeLevel++;
+				fxCoderAddVariable(coder, 0, XS_CODE_NEW_LOCAL, node->symbol, node->index);
+				fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+				fxCoderAddIndex(coder, 0, XS_CODE_VAR_LOCAL_1, node->index);
+				fxCoderAddByte(coder, -1, XS_CODE_POP);
+			}
+			node = node->nextDeclareNode;
+		}
+		fxCoderAddByte(coder, 0, XS_CODE_PROGRAM_ENVIRONMENT);
+		coder->scopeLevel = count;
+	}
+	if (programNode->scopeCount > count)
+		fxCoderAddIndex(coder, 0, XS_CODE_RESERVE_1, programNode->scopeCount - count);
+}
+
+void fxScopeCodeDefineNodes(txScope* self, txCoder* coder) 
+{
+	txDefineNode* node = self->firstDefineNode;
+	while (node) {
+		fxDefineNodeCode(node, coder);
+		node = node->nextDefineNode;
+	}
+}
+
+txInteger fxScopeCodeSpecifierNodes(txScope* self, txCoder* coder) 
+{
+	txDeclareNode* node = self->firstDeclareNode;
+	txInteger count = 0;
+	while (node) {
+		if (node->flags & mxDeclareNodeUseClosureFlag) {
+			txSpecifierNode* specifier = node->importSpecifier;
+			txInteger index = 3;
+			if (node->symbol)
+				fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, node->symbol);
+			else
+				fxCoderAddByte(coder, 1, XS_CODE_NULL);
+			if (specifier) {
+				if (coder->parser->flags & mxDebugFlag) {
+					fxCoderAddLine(coder, 0, XS_CODE_LINE, (txNode*)specifier);
+				}
+				fxStringNodeCode(specifier->from, coder);
+				if (specifier->symbol)
+					fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, specifier->symbol);
+				else
+					fxCoderAddByte(coder, 1, XS_CODE_NULL);
+			}
+			else {
+				fxCoderAddByte(coder, 1, XS_CODE_NULL);
+				fxCoderAddByte(coder, 1, XS_CODE_NULL);
+			}
+			specifier = node->firstExportSpecifier;
+			while (specifier) {
+				if (specifier->asSymbol) {
+					fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, specifier->asSymbol);
+					index++;
+				}
+				else if (specifier->symbol) {
+					fxCoderAddSymbol(coder, 1, XS_CODE_SYMBOL, specifier->symbol);
+					index++;
+				}
+				specifier = specifier->nextSpecifier;
+			}
+			fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, index);
+			fxCoderAddByte(coder, 0 - index, XS_CODE_TRANSFER);
+			count++;
+		}
+		node = node->nextDeclareNode;
+	}
+	return count;
+}
+
+void fxScopeCodeRefresh(txScope* self, txCoder* coder) 
+{
+	txDeclareNode* node = self->firstDeclareNode;
+	while (node) {
+		if (node->flags & mxDeclareNodeClosureFlag)
+			fxCoderAddIndex(coder, 0, XS_CODE_REFRESH_CLOSURE_1, node->index);
+		else
+			fxCoderAddIndex(coder, 0, XS_CODE_REFRESH_LOCAL_1, node->index);
+		node = node->nextDeclareNode;
+	}
+}
+
+void fxScopeCodeReset(txScope* self, txCoder* coder) 
+{
+	txDeclareNode* node = self->firstDeclareNode;
+	while (node) {
+		if (node->flags & mxDeclareNodeClosureFlag)
+			fxCoderAddIndex(coder, 0, XS_CODE_RESET_CLOSURE_1, node->index);
+		else
+			fxCoderAddIndex(coder, 0, XS_CODE_RESET_LOCAL_1, node->index);
+		node = node->nextDeclareNode;
+	}
+}
+
+void fxScopeCodeRetrieve(txScope* self, txCoder* coder) 
+{
+	txDeclareNode* node;
+	txInteger count = 0;
+	node = self->firstDeclareNode;
+	while (node) {
+		if ((node->flags & mxDeclareNodeUseClosureFlag) && node->symbol) {
+			node->index = coder->scopeLevel++;
+			count++;
+		}
+		node = node->nextDeclareNode;
+	}
+	if (self->node->flags & mxArrowFlag) {
+		fxCoderAddIndex(coder, 0, XS_CODE_RETRIEVE_1, count);
+		fxCoderAddByte(coder, 0, XS_CODE_RETRIEVE_TARGET);
+		fxCoderAddByte(coder, 0, XS_CODE_RETRIEVE_THIS);
+	}
+	else if (count)
+		fxCoderAddIndex(coder, 0, XS_CODE_RETRIEVE_1, count);
+	self->closureNodeCount = count;
+}
+
+void fxScopeCodeStore(txScope* self, txCoder* coder) 
+{
+	txDeclareNode* node = self->firstDeclareNode;
+	txUnsigned flags = self->flags & mxEvalFlag;
+	while (node) {
+		if (node->flags & mxDeclareNodeUseClosureFlag) {
+			fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->declaration->index);
+			node->declaration->flags |= flags;
+		}
+		node = node->nextDeclareNode;
+	}
+	if (self->node->flags & mxArrowFlag)
+		fxCoderAddByte(coder, 0, XS_CODE_STORE_ARROW);
+	if (self->flags & mxEvalFlag)
+		fxScopeCodeStoreAll(self->scope, coder);
+}
+
+void fxScopeCodeStoreAll(txScope* self, txCoder* coder) 
+{
+	txScope* scope = self;
+	while (scope) {
+		txDeclareNode* node;
+		if (scope->token == XS_TOKEN_WITH)
+			break;
+		node = scope->firstDeclareNode;
+		while (node) {
+			if (node->flags & mxEvalFlag)
+				node->flags &= ~mxEvalFlag;
+			else if ((!(node->flags & mxDeclareNodeUseClosureFlag)) && node->declaration)
+				fxCoderAddIndex(coder, 0, XS_CODE_STORE_1, node->declaration->index);
+			node = node->nextDeclareNode;
+		}
+		if ((scope->token == XS_TOKEN_FUNCTION) || (scope->token == XS_TOKEN_MODULE))
+			break;
+		scope = scope->scope;
+	}
+}
+
+void fxNodeDispatchCode(void* it, void* param)
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxCheckParserStack(coder->parser, self->line);
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
+	(*self->description->dispatch->code)(it, param);
+}
+
+void fxNodeDispatchCodeAssign(void* it, void* param, txFlag flag)
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxCheckParserStack(coder->parser, self->line);
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
+	(*self->description->dispatch->codeAssign)(self, param, flag);
+}
+
+void fxNodeDispatchCodeDelete(void* it, void* param)
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxCheckParserStack(coder->parser, self->line);
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
+	(*self->description->dispatch->codeDelete)(self, param);
+}
+
+void fxNodeDispatchCodeReference(void* it, void* param)
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxCheckParserStack(coder->parser, self->line);
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
+	(*self->description->dispatch->codeReference)(self, param);
+}
+
+txFlag fxNodeDispatchCodeThis(void* it, void* param, txFlag flag) 
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxCheckParserStack(coder->parser, self->line);
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, self); 
+	return (*self->description->dispatch->codeThis)(self, param, flag);
+}
+
+void fxNodeCode(void* it, void* param) 
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxReportParserError(coder->parser, self->line, "no value");
+	fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+}
+
+void fxNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	fxReportParserError(coder->parser, self->line, "no reference");
+}
+
+void fxNodeCodeDelete(void* it, void* param) 
+{
+	fxNodeDispatchCode(it, param);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAddByte(param, 1, XS_CODE_TRUE);
+}
+
+void fxNodeCodeReference(void* it, void* param) 
+{
+}
+
+txFlag fxNodeCodeName(txNode* value)
+{
+	txToken token = value->description->token;
+	if (token == XS_TOKEN_EXPRESSIONS) {
+		value = ((txExpressionsNode*)value)->items->first;
+		if (value->next)
+			return 0;
+		token = value->description->token;
+	}
+	if (token == XS_TOKEN_CLASS) {
+		txClassNode* node = (txClassNode*)value;
+		if (node->symbol)
+			return 0;
+	}
+	else if ((token == XS_TOKEN_FUNCTION) || (token == XS_TOKEN_GENERATOR) || (token == XS_TOKEN_HOST)) {
+		txFunctionNode* node = (txFunctionNode*)value;
+		if (node->symbol)
+			return 0;
+	}
+	else
+		return 0;
+	return 1;
+}
+
+txFlag fxNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+	fxNodeDispatchCode(it, param);
+	return 1;
+}
+
+void fxAccessNodeCode(void* it, void* param) 
+{
+	txAccessNode* self = it;
+	txDeclareNode* declaration = self->declaration;
+	if (!declaration) {
+		fxAccessNodeCodeReference(it, param);
+		fxCoderAddSymbol(param, 0, XS_CODE_GET_VARIABLE, self->symbol);
+	}
+	else
+		fxCoderAddIndex(param, 1, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_GET_CLOSURE_1 : XS_CODE_GET_LOCAL_1, declaration->index);
+}
+
+void fxAccessNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txAccessNode* self = it;
+	txDeclareNode* declaration = self->declaration;
+	if (!declaration)
+		fxCoderAddSymbol(param, -1, XS_CODE_SET_VARIABLE, self->symbol);
+	else
+		fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_SET_CLOSURE_1 : XS_CODE_SET_LOCAL_1, declaration->index);
+}
+
+void fxAccessNodeCodeDelete(void* it, void* param) 
+{
+	txAccessNode* self = it;
+	txCoder* coder = param;
+	txDeclareNode* declaration = self->declaration;
+	if (self->flags & mxStrictFlag)
+		fxReportParserError(coder->parser, self->line, "delete identifier (strict code)");
+	if (!declaration) {
+		fxAccessNodeCodeReference(it, param);
+		fxCoderAddSymbol(param, 0, XS_CODE_DELETE_PROPERTY, self->symbol);
+	}
+	else
+		fxCoderAddByte(param, 1, XS_CODE_FALSE);
+}
+
+void fxAccessNodeCodeReference(void* it, void* param) 
+{
+	txAccessNode* self = it;
+	txCoder* coder = param;
+	txDeclareNode* declaration = self->declaration;
+	if (!declaration) {
+		if (coder->evalFlag)
+			fxCoderAddSymbol(param, 1, XS_CODE_EVAL_REFERENCE, self->symbol);
+		else
+			fxCoderAddSymbol(param, 1, XS_CODE_PROGRAM_REFERENCE, self->symbol);
+	}
+}
+
+txFlag fxAccessNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	txAccessNode* self = it;
+	txDeclareNode* declaration = self->declaration;
+	if (!flag)
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+	if (!declaration) {
+		fxAccessNodeCodeReference(it, param);
+		if (flag)
+			fxCoderAddByte(param, 1, XS_CODE_DUB);
+		fxCoderAddSymbol(param, 0, XS_CODE_GET_THIS_VARIABLE, self->symbol);
+	}
+	else {
+		fxCoderAddIndex(param, 1, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_GET_CLOSURE_1 : XS_CODE_GET_LOCAL_1, declaration->index);
+		flag = 0;
+	}
+	return flag;
+}
+
+void fxAndExpressionNodeCode(void* it, void* param) 
+{
+	txBinaryExpressionNode* self = it;
+	txTargetCode* endTarget = fxCoderCreateTarget(param);
+	self->right->flags |= (self->flags & mxTailRecursionFlag);
+	fxNodeDispatchCode(self->left, param);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, endTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAdd(param, 0, endTarget);
+}
+
+void fxArgumentsNodeCode(void* it, void* param) 
+{
+	fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS, 0);
+}
+
+void fxArrayNodeCode(void* it, void* param) 
+{
+	txArrayNode* self = it;
+	txCoder* coder = param;
+	txInteger array = fxCoderUseTemporaryVariable(param);
+	fxCoderAddByte(param, 1, XS_CODE_ARRAY);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, array);
+	if (self->items) {
+		txNode* item = self->items->first;
+		if (self->flags & mxSpreadFlag) {
+			txInteger counter = fxCoderUseTemporaryVariable(param);
+			fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
+			fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, counter);
+			while (item) {
+				if (item->description->token == XS_TOKEN_SPREAD) {
+					txInteger iterator = fxCoderUseTemporaryVariable(param);
+					txInteger result = fxCoderUseTemporaryVariable(param);
+					txTargetCode* nextTarget = fxCoderCreateTarget(param);
+					txTargetCode* doneTarget = fxCoderCreateTarget(param);
+					fxNodeDispatchCode(((txSpreadNode*)item)->expression, param);
+					fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
+					fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
+					fxCoderAddByte(param, -1, XS_CODE_POP);
+					fxCoderAdd(param, 0, nextTarget);
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+					fxCoderAddByte(param, 1, XS_CODE_DUB);
+					fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+					fxCoderAddByte(param, 1, XS_CODE_CALL);
+					fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+					fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+					fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+					fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+					fxCoderAddByte(param, 0, XS_CODE_AT);
+					fxCoderAddIndex(param, 0, XS_CODE_GET_LOCAL_1, result);
+					fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+					fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
+					fxCoderAddByte(param, -1, XS_CODE_POP);
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+					fxCoderAddByte(param, 0, XS_CODE_INCREMENT);
+					fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, counter);
+					fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
+					fxCoderAdd(param, 1, doneTarget);
+					fxCoderUnuseTemporaryVariables(param, 2);
+				}
+				else {
+					if (item->description->token != XS_TOKEN_ELISION) {
+						fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
+						fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+						fxCoderAddByte(param, 0, XS_CODE_AT);
+						fxNodeDispatchCode(item, param);
+						fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
+						fxCoderAddByte(param, -1, XS_CODE_POP);
+						fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+						fxCoderAddByte(param, 0, XS_CODE_INCREMENT);
+						fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, counter);
+					}
+					else {
+						fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
+						fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+						fxCoderAddByte(param, 0, XS_CODE_INCREMENT);
+						fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
+						fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
+						fxCoderAddByte(param, -1, XS_CODE_POP);
+					}
+				}
+				item = item->next;
+			}
+			fxCoderUnuseTemporaryVariables(param, 1);
+		}
+		else {
+			txInteger index = 0;
+			txInteger count = self->items->length;
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
+			fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, count);
+			fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
+			fxCoderAddByte(param, -1, XS_CODE_POP);
+			while (item) {
+				if (item->description->token == XS_TOKEN_ELISION)
+					break;
+				item = item->next;
+			}
+			if (!item) {
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
+				fxCoderAddByte(param, 1, XS_CODE_DUB);
+				fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->fillSymbol);
+				fxCoderAddByte(param, 1, XS_CODE_CALL);
+				fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+			}
+			item = self->items->first;
+			while (item) {
+				if (item->description->token != XS_TOKEN_ELISION) {
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, array);
+					fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, index);
+					fxCoderAddByte(param, 0, XS_CODE_AT);
+					fxNodeDispatchCode(item, param);
+					fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
+					fxCoderAddByte(param, -1, XS_CODE_POP);
+				}
+				item = item->next;
+				index++;
+			}
+		}
+	}
+	fxCoderUnuseTemporaryVariables(param, 1);
+}
+
+void fxArrayBindingNodeCode(void* it, void* param)
+{
+	txArrayBindingNode* self = it;
+	txCoder* coder = param;
+	fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+	fxArrayBindingNodeCodeAssign(self, param, 0);
+}
+
+void fxArrayBindingNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txArrayBindingNode* self = it;
+	txCoder* coder = param;
+	txNode* item = self->items->first;
+	txInteger iterator;
+	txInteger done;
+	txInteger rest;
+	txInteger result;
+	txInteger selector;
+	txInteger selection;
+	txTargetCode* catchTarget;
+	txTargetCode* normalTarget;
+	txTargetCode* finallyTarget;
+	
+	txTargetCode* returnTarget;
+	txTargetCode* stepTarget;
+	txTargetCode* doneTarget;
+	txTargetCode* nextTarget;
+	
+	iterator = fxCoderUseTemporaryVariable(param);
+	done = fxCoderUseTemporaryVariable(param);
+	selector = fxCoderUseTemporaryVariable(param);
+	rest = fxCoderUseTemporaryVariable(param);
+	result = fxCoderUseTemporaryVariable(param);
+	
+	coder->returnTarget = fxCoderAliasTargets(param, coder->returnTarget);
+	catchTarget = fxCoderCreateTarget(param);
+	normalTarget = fxCoderCreateTarget(param);
+	finallyTarget = fxCoderCreateTarget(param);
+	
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, iterator);
+	fxCoderAddByte(param, 1, XS_CODE_FALSE);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, selector);
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	
+	if (item) {
+		while (item && (item->description->token != XS_TOKEN_REST_BINDING)) {
+			stepTarget = fxCoderCreateTarget(param);
+			
+			if (item->description->token == XS_TOKEN_SKIP_BINDING) {
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
+				fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, stepTarget);
+				fxCoderAddByte(param, 1, XS_CODE_TRUE);
+				fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+				fxCoderAddByte(param, 1, XS_CODE_DUB);
+				fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+				fxCoderAddByte(param, 1, XS_CODE_CALL);
+				fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+				fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+				fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+				fxCoderAddIndex(param, 0, XS_CODE_PULL_LOCAL_1, done);
+				fxCoderAdd(param, 1, stepTarget);
+			}
+			else {
+				doneTarget = fxCoderCreateTarget(param);
+				nextTarget = fxCoderCreateTarget(param);
+				fxNodeDispatchCodeReference(item, param);
+				
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
+				fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, stepTarget);
+				fxCoderAddByte(param, 1, XS_CODE_TRUE);
+				fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+				fxCoderAddByte(param, 1, XS_CODE_DUB);
+				fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+				fxCoderAddByte(param, 1, XS_CODE_CALL);
+				fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+				fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+				fxCoderAddByte(param, 1, XS_CODE_DUB);
+				fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+				fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, done);
+				fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+				fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+				fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
+				fxCoderAdd(param, 1, doneTarget);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+				fxCoderAdd(param, 1, stepTarget);
+				fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+				fxCoderAdd(param, 1, nextTarget);
+				fxNodeDispatchCodeAssign(item, param, 0);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+			}
+			item = item->next;
+		}
+		if (item) {
+			nextTarget = fxCoderCreateTarget(param);
+			doneTarget = fxCoderCreateTarget(param);
+		
+			fxNodeDispatchCodeReference(((txRestBindingNode*)item)->binding, param);
+			fxCoderAddByte(param, 1, XS_CODE_ARRAY);
+			fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, rest);
+			
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
+			fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+
+			fxCoderAdd(param, 0, nextTarget);
+			fxCoderAddByte(param, 1, XS_CODE_TRUE);
+			fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+			fxCoderAddByte(param, 1, XS_CODE_DUB);
+			fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+			fxCoderAddByte(param, 1, XS_CODE_CALL);
+			fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+			fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+			fxCoderAddIndex(param, 1, XS_CODE_SET_LOCAL_1, result);
+			fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+			fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, done);
+			
+			fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+		
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, rest);
+			fxCoderAddByte(param, 1, XS_CODE_DUB);
+			fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->lengthSymbol);
+			fxCoderAddByte(param, 0, XS_CODE_AT);
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+			fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+			fxCoderAddByte(param, -2, XS_CODE_SET_PROPERTY_AT);
+			fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+			fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
+			fxCoderAdd(param, 1, doneTarget);
+		
+			fxCoderAddIndex(param, 0, XS_CODE_GET_LOCAL_1, rest);
+			fxNodeDispatchCodeAssign(((txRestBindingNode*)item)->binding, param, 0);
+			fxCoderAddByte(param, -1, XS_CODE_POP);
+		}
+	
+	}
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, normalTarget);
+	
+	selection = 1;
+	coder->returnTarget = fxCoderFinalizeTargets(param, coder->returnTarget, selector, &selection, finallyTarget);
+	fxCoderAdd(param, 0, normalTarget);
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, selection);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAdd(param, 0, finallyTarget);
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	fxCoderAdd(param, 0, catchTarget);
+	
+	nextTarget = fxCoderCreateTarget(param);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, nextTarget);
+	fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	catchTarget = fxCoderCreateTarget(param);
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	fxCoderAdd(param, 0, nextTarget);
+	
+	doneTarget = fxCoderCreateTarget(param);
+	returnTarget = fxCoderCreateTarget(param);
+ 	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
+ 	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, returnTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddByte(param, 0, XS_CODE_SWAP);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAdd(param, 0, returnTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAdd(param, 0, doneTarget);
+	
+	nextTarget = fxCoderCreateTarget(param);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, nextTarget);
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	fxCoderAdd(param, 0, catchTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+	fxCoderAddByte(param, -1, XS_CODE_THROW);
+	fxCoderAdd(param, 0, nextTarget);
+
+	selection = 1;
+	fxCoderJumpTargets(param, coder->returnTarget, selector, &selection);
+
+	fxCoderUnuseTemporaryVariables(param, 5);
+}
+
+void fxAssignNodeCode(void* it, void* param) 
+{
+	txAssignNode* self = it;
+	fxNodeDispatchCodeReference(self->reference, param);
+	fxNodeDispatchCode(self->value, param);
+	fxNodeDispatchCodeAssign(self->reference, param, 0);
+}
+
+void fxAwaitNodeCode(void* it, void* param)
+{
+	txStatementNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* target = fxCoderCreateTarget(coder);
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+	fxCoderAddBranch(coder, 1, XS_CODE_BRANCH_STATUS_1, target);
+	fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	fxCoderAdjustEnvironment(coder, coder->returnTarget);
+	fxCoderAdjustScope(coder, coder->returnTarget);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->returnTarget);
+	fxCoderAdd(coder, 0, target);
+}
+
+void fxBigIntNodeCode(void* it, void* param) 
+{
+	txBigIntNode* self = it;
+	fxCoderAddBigInt(param, 1, XS_CODE_BIGINT_1, &self->value);
+}
+
+void fxBinaryExpressionNodeCode(void* it, void* param) 
+{
+	txBinaryExpressionNode* self = it;
+	fxNodeDispatchCode(self->left, param);
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAddByte(param, -1, self->description->code);
+}
+
+void fxBindingNodeCode(void* it, void* param) 
+{
+	txBindingNode* self = it;
+	txCoder* coder = param;
+	
+	if (self->target->description->token == XS_TOKEN_ACCESS) {
+		fxReportParserError(coder->parser, self->line, "invalid initializer");
+		fxNodeDispatchCode(self->initializer, param);
+		return;
+	}
+	
+	fxNodeDispatchCodeReference(self->target, param);
+	fxNodeDispatchCode(self->initializer, param);
+	fxNodeDispatchCodeAssign(self->target, param, 0);
+	fxCoderAddByte(coder, -1, XS_CODE_POP);
+}
+
+void fxBindingNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txBindingNode* self = it;
+	txTargetCode* target = fxCoderCreateTarget(param);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+	fxCoderAddByte(param, -1, XS_CODE_STRICT_NOT_EQUAL);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, target);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxNodeDispatchCode(self->initializer, param);
+	fxCoderAdd(param, 0, target);
+	fxNodeDispatchCodeAssign(self->target, param, flag);
+}
+
+void fxBindingNodeCodeReference(void* it, void* param) 
+{
+	txBindingNode* self = it;
+	fxNodeDispatchCodeReference(self->target, param);
+}
+
+void fxBlockNodeCode(void* it, void* param) 
+{
+	txBlockNode* self = it;
+	fxScopeCodingBlock(self->scope, param);
+	fxScopeCodeDefineNodes(self->scope, param);
+	fxNodeDispatchCode(self->statement, param);
+	fxScopeCoded(self->scope, param);
+}
+
+void fxBodyNodeCode(void* it, void* param) 
+{
+	txBlockNode* self = it;
+	txCoder* coder = param;
+	txBoolean evalFlag = coder->evalFlag;
+	if ((self->flags & mxEvalFlag) && !(self->flags & mxStrictFlag))
+		coder->evalFlag = 1;
+	fxScopeCodingBody(self->scope, param);
+	fxScopeCodeDefineNodes(self->scope, param);
+	fxNodeDispatchCode(self->statement, param);
+	fxScopeCodedBody(self->scope, param);
+	if ((self->flags & mxEvalFlag) && !(self->flags & mxStrictFlag))
+		coder->evalFlag = evalFlag;
+}
+
+void fxBreakContinueNodeCode(void* it, void* param) 
+{
+	txBreakContinueNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* target = (self->description->token == XS_TOKEN_BREAK) ? coder->firstBreakTarget : coder->firstContinueTarget;
+	while (target) {
+		txLabelNode* label = target->label;
+		while (label) {
+			if (label->symbol == self->symbol) {
+				fxCoderAdjustEnvironment(coder, target);
+				fxCoderAdjustScope(coder, target);
+				fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, target);
+				return;
+			}
+			label = label->nextLabel;
+		}
+		target = target->nextTarget;
+	}
+	if (self->description->token == XS_TOKEN_BREAK)
+		fxReportParserError(coder->parser, self->line, "invalid break");
+	else
+		fxReportParserError(coder->parser, self->line, "invalid continue");
+}
+
+void fxCallNodeCode(void* it, void* param) 
+{
+	txCallNewNode* self = it;
+	fxNodeDispatchCodeThis(self->reference, param, 0);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	self->params->flags |= self->flags & mxTailRecursionFlag;
+	fxNodeDispatchCode(self->params, param);
+}
+
+void fxCatchNodeCode(void* it, void* param) 
+{
+	txCatchNode* self = it;
+	if (self->parameter) {
+		fxScopeCodingBlock(self->scope, param);
+		fxNodeDispatchCodeReference(self->parameter, param);
+		fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
+		fxNodeDispatchCodeAssign(self->parameter, param, 0);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		fxScopeCodingBlock(self->statementScope, param);
+		fxScopeCodeDefineNodes(self->statementScope, param);
+		fxNodeDispatchCode(self->statement, param);
+		fxScopeCoded(self->statementScope, param);
+		fxScopeCoded(self->scope, param);
+	}
+	else {
+		fxScopeCodingBlock(self->statementScope, param);
+		fxScopeCodeDefineNodes(self->statementScope, param);
+		fxNodeDispatchCode(self->statement, param);
+		fxScopeCoded(self->statementScope, param);
+	}
+}
+
+void fxChainNodeCode(void* it, void* param)
+{
+	txUnaryExpressionNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* chainTarget = coder->chainTarget;
+	coder->chainTarget = fxCoderCreateTarget(param);
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAdd(param, 0, coder->chainTarget);
+	coder->chainTarget = chainTarget;
+}
+
+txFlag fxChainNodeCodeThis(void* it, void* param, txFlag flag)
+{
+	txUnaryExpressionNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* chainTarget = coder->chainTarget;
+	coder->chainTarget = fxCoderCreateTarget(param);
+	flag = fxNodeDispatchCodeThis(self->right, param, flag);
+    fxCoderAdd(param, 0, coder->chainTarget);
+	coder->chainTarget = chainTarget;
+	return flag;
+}
+
+void fxClassNodeCode(void* it, void* param) 
+{
+	txClassNode* self = it;
+	txCoder* coder = param;
+	txClassNode* former = coder->classNode;
+	txFlag flag;
+	txInteger prototype = fxCoderUseTemporaryVariable(coder);
+	txInteger constructor = fxCoderUseTemporaryVariable(coder);
+	txDeclareNode* declaration = self->scope->firstDeclareNode;
+	txNode* item = self->items->first;
+	if (self->symbol)
+		fxScopeCodingBlock(self->symbolScope, param);
+	if (self->heritage) {
+		if (self->heritage->description->token == XS_TOKEN_HOST) {
+			fxCoderAddByte(param, 1, XS_CODE_NULL);
+			fxNodeDispatchCode(self->heritage, param);
+		}
+		else {
+			fxNodeDispatchCode(self->heritage, param);
+			fxCoderAddByte(param, 1, XS_CODE_EXTEND);
+		}
+	}
+	else {
+		fxCoderAddByte(param, 1, XS_CODE_NULL);
+		fxCoderAddByte(param, 1, XS_CODE_OBJECT);
+	}
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, prototype);
+	fxScopeCodingBlock(self->scope, param);
+	
+	coder->classNode = self;
+	fxNodeDispatchCode(self->constructor, param);
+	
+	fxCoderAddByte(param, 0, XS_CODE_TO_INSTANCE);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, constructor);
+	fxCoderAddByte(param, -3, XS_CODE_CLASS);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, constructor);
+	if (self->symbol)
+		fxCoderAddSymbol(param, 0, XS_CODE_NAME, self->symbol);
+		
+	while (item) {
+		if (item->description->token == XS_TOKEN_PROPERTY) {
+			txPropertyNode* property = (txPropertyNode*)item;
+			if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
+				if (item->flags & mxStaticFlag)
+					fxCoderAddByte(param, 1, XS_CODE_DUB);
+				else
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, prototype);
+				fxNodeDispatchCode(property->value, param);
+				fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, property->symbol);
+				flag = XS_DONT_ENUM_FLAG;
+				if (item->flags & mxMethodFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG;
+				else if (item->flags & mxGetterFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG;
+				else if (item->flags & mxSetterFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG;
+				fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
+			}
+		}
+		else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
+			txPropertyAtNode* property = (txPropertyAtNode*)item;
+			if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
+				if (item->flags & mxStaticFlag)
+					fxCoderAddByte(param, 1, XS_CODE_DUB);
+				else
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, prototype);
+				fxNodeDispatchCode(property->at, param);
+				fxCoderAddByte(param, 0, XS_CODE_AT);
+				fxNodeDispatchCode(property->value, param);
+				fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
+				flag = XS_DONT_ENUM_FLAG;
+				if (item->flags & mxMethodFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG;
+				else if (item->flags & mxGetterFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG;
+				else if (item->flags & mxSetterFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG;
+				fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
+			}
+			else {
+				fxNodeDispatchCode(property->at, param);
+				fxCoderAddByte(param, 0, XS_CODE_AT);
+				fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+				declaration = declaration->nextDeclareNode;
+			}
+		}
+		else  {
+			txPrivatePropertyNode* property = (txPrivatePropertyNode*)item;
+			fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
+			declaration = declaration->nextDeclareNode;
+			if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
+				fxNodeDispatchCode(property->value, param);
+				fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+				declaration = declaration->nextDeclareNode;
+			}
+		}
+		item = item->next;
+	}
+	if (self->symbol)
+		fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, self->symbolScope->firstDeclareNode->index);
+	if (self->constructorInit) {
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, constructor);
+		fxNodeDispatchCode(self->constructorInit, param);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, constructor);
+		fxCoderAddByte(param, -1, XS_CODE_SET_HOME);
+		fxCoderAddByte(param, 1, XS_CODE_CALL);
+		fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+	if (self->instanceInit) {
+		fxNodeDispatchCode(self->instanceInit, param);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, prototype);
+		fxCoderAddByte(param, -1, XS_CODE_SET_HOME);
+		fxCoderAddIndex(param, 0, XS_CODE_CONST_CLOSURE_1, declaration->index);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+	coder->classNode = former;
+	fxScopeCoded(self->scope, param);
+	if (self->symbol)
+		fxScopeCoded(self->symbolScope, param);
+	fxCoderUnuseTemporaryVariables(coder, 2);
+}
+
+void fxCoalesceExpressionNodeCode(void* it, void* param) 
+{
+	txBinaryExpressionNode* self = it;
+	txTargetCode* endTarget = fxCoderCreateTarget(param);
+	self->right->flags |= (self->flags & mxTailRecursionFlag);
+	fxNodeDispatchCode(self->left, param);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_COALESCE_1, endTarget);
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAdd(param, 0, endTarget);
+}
+
+void fxCompoundExpressionNodeCode(void* it, void* param) 
+{
+	txAssignNode* self = it;
+	txCoder* coder = param;
+	txToken token = self->description->token;
+	txFlag shortcut = ((token == XS_TOKEN_AND_ASSIGN) || (token == XS_TOKEN_COALESCE_ASSIGN) || (token == XS_TOKEN_OR_ASSIGN)) ? 1 : 0;
+	txTargetCode* elseTarget = (shortcut) ? fxCoderCreateTarget(param) : C_NULL;
+	txTargetCode* endTarget = (shortcut) ? fxCoderCreateTarget(param) : C_NULL;
+	txInteger stackLevel;
+	txFlag swap = fxNodeDispatchCodeThis(self->reference, param, 1);
+	switch (self->description->token) {
+	case XS_TOKEN_AND_ASSIGN:
+		fxCoderAddByte(param, 1, XS_CODE_DUB);
+		fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		fxNodeDispatchCode(self->value, param);
+		fxCompoundExpressionNodeCodeName(it, param);
+		stackLevel = coder->stackLevel;
+		break;
+	case XS_TOKEN_COALESCE_ASSIGN:
+		fxCoderAddBranch(param, -1, XS_CODE_BRANCH_COALESCE_1, elseTarget);
+		fxNodeDispatchCode(self->value, param);
+		fxCompoundExpressionNodeCodeName(it, param);
+		stackLevel = coder->stackLevel;
+		break;
+	case XS_TOKEN_OR_ASSIGN:
+		fxCoderAddByte(param, 1, XS_CODE_DUB);
+		fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, elseTarget);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		fxNodeDispatchCode(self->value, param);
+		fxCompoundExpressionNodeCodeName(it, param);
+		stackLevel = coder->stackLevel;
+		break;
+	default:
+		fxNodeDispatchCode(self->value, param);
+		fxCoderAddByte(param, -1, self->description->code);
+		break;
+	}
+	fxNodeDispatchCodeAssign(self->reference, param, 1);
+	if (shortcut) {
+		fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
+		coder->stackLevel = stackLevel;
+		fxCoderAdd(param, 0, elseTarget);
+		while (swap > 0) {
+			if (!(self->flags & mxExpressionNoValue))
+				fxCoderAddByte(param, 0, XS_CODE_SWAP);
+			fxCoderAddByte(param, -1, XS_CODE_POP);
+			swap--;
+		}
+		fxCoderAdd(param, 0, endTarget);
+	}
+}
+
+void fxCompoundExpressionNodeCodeName(void* it, void* param) 
+{
+	txAssignNode* self = it;
+	txAccessNode* reference = (txAccessNode*)(self->reference);
+	txToken token = reference->description->token;
+	txNode* value = self->value;
+	if (token != XS_TOKEN_ACCESS)
+		return;
+	if (fxNodeCodeName(value))
+		fxCoderAddSymbol(param, 0, XS_CODE_NAME, reference->symbol);
+}
+
+void fxDebuggerNodeCode(void* it, void* param) 
+{
+	fxCoderAddByte(param, 0, XS_CODE_DEBUGGER);
+}
+
+void fxDeclareNodeCode(void* it, void* param) 
+{
+	txDeclareNode* self = it;
+	txCoder* coder = param;
+	if (self->description->token == XS_TOKEN_CONST)
+		fxReportParserError(coder->parser, self->line, "invalid const");
+	else if (self->description->token == XS_TOKEN_LET) {
+		fxNodeDispatchCodeReference(self, param);
+		fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+		fxNodeDispatchCodeAssign(self, param, 0);
+		fxCoderAddByte(coder, -1, XS_CODE_POP);
+	}
+}
+
+void fxDeclareNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txDeclareNode* self = it;
+	txDeclareNode* declaration = self->declaration;
+	if (!declaration)
+		fxCoderAddSymbol(param, -1, XS_CODE_SET_VARIABLE, self->symbol);
+	else {
+		if (self->description->token == XS_TOKEN_CONST)
+			fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_CONST_CLOSURE_1: XS_CODE_CONST_LOCAL_1, declaration->index);
+		else if (self->description->token == XS_TOKEN_LET)
+			fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_LET_CLOSURE_1: XS_CODE_LET_LOCAL_1, declaration->index);
+		else
+			fxCoderAddIndex(param, 0, (declaration->flags & mxDeclareNodeClosureFlag) ? XS_CODE_VAR_CLOSURE_1 : XS_CODE_VAR_LOCAL_1, declaration->index);
+	}
+}
+
+void fxDeclareNodeCodeReference(void* it, void* param) 
+{
+	txAccessNode* self = it;
+	txCoder* coder = param;
+	txDeclareNode* declaration = self->declaration;
+	if (!declaration) {
+		if (coder->evalFlag)
+			fxCoderAddSymbol(param, 1, XS_CODE_EVAL_REFERENCE, self->symbol);
+		else
+			fxCoderAddSymbol(param, 1, XS_CODE_PROGRAM_REFERENCE, self->symbol);
+	}
+}
+
+void fxDefineNodeCode(void* it, void* param) 
+{
+	txDefineNode* self = it;
+	txCoder* coder = param;
+	if (self->flags & mxDefineNodeCodedFlag)
+		return;
+	self->flags |= mxDefineNodeCodedFlag;
+	fxDeclareNodeCodeReference(it, param);
+	fxNodeDispatchCode(self->initializer, coder);
+    self->initializer = C_NULL;
+	fxDeclareNodeCodeAssign(it, param, 0);
+	fxCoderAddByte(coder, -1, XS_CODE_POP);
+}
+
+void fxDelegateNodeCode(void* it, void* param)
+{
+	txStatementNode* self = it;
+	txBoolean async = (self->flags & mxAsyncFlag) ? 1 : 0;
+	txCoder* coder = param;
+	txInteger iterator;
+	txInteger method;
+	txInteger next;
+	txInteger result;
+
+	txTargetCode* nextTarget = fxCoderCreateTarget(param);
+	txTargetCode* catchTarget = fxCoderCreateTarget(param);
+	txTargetCode* rethrowTarget = fxCoderCreateTarget(param);
+	txTargetCode* returnTarget = fxCoderCreateTarget(param);
+	txTargetCode* normalTarget = fxCoderCreateTarget(param);
+	txTargetCode* doneTarget = fxCoderCreateTarget(param);
+	
+	iterator = fxCoderUseTemporaryVariable(param);
+	method = fxCoderUseTemporaryVariable(param);
+	next = fxCoderUseTemporaryVariable(param);
+	result = fxCoderUseTemporaryVariable(param);
+	
+	fxNodeDispatchCode(self->expression, param);
+	if (async)
+		fxCoderAddByte(param, 0, XS_CODE_FOR_AWAIT_OF);
+	else
+		fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, next);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+	fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, normalTarget);
+	
+// LOOP	
+	fxCoderAdd(param, 0, nextTarget);
+	if (async)
+		fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+	fxCoderAddByte(coder, 0, XS_CODE_YIELD);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	fxCoderAddBranch(coder, 1, XS_CODE_BRANCH_STATUS_1, normalTarget);
+	
+// RETURN	
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	if (async) {
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+		fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	}	
+	
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, returnTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddByte(param, 0, XS_CODE_SWAP);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+	fxCoderAddInteger(param, -3, XS_CODE_RUN_1, 1);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+	}
+	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, nextTarget);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+	fxCoderAdd(coder, 0, returnTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+	}	
+	fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	fxCoderAdjustEnvironment(coder, coder->returnTarget);
+	fxCoderAdjustScope(coder, coder->returnTarget);
+	fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, coder->returnTarget);
+	
+// THROW	
+	fxCoderAdd(coder, 0, catchTarget);
+
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->throwSymbol);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, method);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_COALESCE_1, doneTarget);
+	
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_CHAIN_1, rethrowTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddByte(param, 0, XS_CODE_SWAP);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+	}
+	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAdd(coder, 0, rethrowTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+	fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+// NORMAL	
+	fxCoderAdd(coder, 0, normalTarget);
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, method);
+	fxCoderAdd(param, 1, doneTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, method);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+	fxCoderAddInteger(param, -3, XS_CODE_RUN_1, 1);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+	}
+	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, nextTarget);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+
+	fxCoderUnuseTemporaryVariables(param, 4);
+}
+
+void fxDeleteNodeCode(void* it, void* param) 
+{
+	txDeleteNode* self = it;
+	fxNodeDispatchCodeDelete(self->reference, param);
+}
+
+void fxDoNodeCode(void* it, void* param) 
+{
+	txDoNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* loopTarget = fxCoderCreateTarget(param);
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxCoderAdd(param, 0, loopTarget);
+	fxNodeDispatchCode(self->statement, param);
+	fxCoderAdd(param, 0, coder->firstContinueTarget);
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, loopTarget);
+}
+
+void fxExportNodeCode(void* it, void* param) 
+{
+}
+
+void fxExpressionsNodeCode(void* it, void* param) 
+{
+	txExpressionsNode* self = it;
+	if (self->items) {
+		txNode* item = self->items->first;
+		txNode* previous = NULL;
+		txNode* next;
+		while (item) {
+			next = item->next;
+			if (previous)
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+			if (!next)
+				item->flags |= (self->flags & mxTailRecursionFlag);
+			fxNodeDispatchCode(item, param);
+			previous = item;
+			item = next;
+		}
+	}
+}
+
+txFlag fxExpressionsNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	txExpressionsNode* self = it;
+ 	if (self->items) {
+ 		txNode* item = self->items->first;
+ 		if (item->next == C_NULL) {
+ 			return fxNodeDispatchCodeThis(item, param, flag);
+ 		}
+ 	}
+	return fxNodeCodeThis(it, param, flag);
+}
+
+void fxExpressionsNodeCodeDelete(void* it, void* param) 
+ {
+ 	txExpressionsNode* self = it;
+ 	if (self->items) {
+ 		txNode* item = self->items->first;
+ 		if (item->next == C_NULL) {
+			fxNodeDispatchCodeDelete(item, param);
+ 			return;
+ 		}
+ 	}
+	fxNodeCodeDelete(it, param);
+ }
+
+void fxFieldNodeCode(void* it, void* param) 
+{
+	txFieldNode* self = it;
+	txNode* item = self->item;
+	fxCoderAddByte(param, 1, XS_CODE_THIS);
+	if (item->description->token == XS_TOKEN_PROPERTY) {
+		fxNodeDispatchCode(self->value, param);
+		fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, ((txPropertyNode*)item)->symbol);
+		fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, fxNodeCodeName(self->value) ? XS_NAME_FLAG : 0);
+	}
+	else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
+		fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, ((txPropertyAtNode*)item)->atAccess->declaration->index);
+		fxNodeDispatchCode(self->value, param);
+		fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
+		fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, fxNodeCodeName(self->value) ? XS_NAME_FLAG : 0);
+	}
+	else {
+		if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag))
+			fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, ((txPrivatePropertyNode*)item)->valueAccess->declaration->index);
+		else
+			fxNodeDispatchCode(self->value, param);
+		fxCoderAddIndex(param, -2, XS_CODE_NEW_PRIVATE_1, ((txPrivatePropertyNode*)item)->symbolAccess->declaration->index);
+		if (item->flags & mxMethodFlag)
+			fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_NAME_FLAG | XS_METHOD_FLAG);
+		else if (item->flags & mxGetterFlag)
+			fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG);
+		else if (item->flags & mxSetterFlag)
+			fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG);
+		else
+			fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, fxNodeCodeName(self->value) ? XS_NAME_FLAG : 0);
+	}
+}
+
+void fxForNodeCode(void* it, void* param) 
+{
+	txForNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* nextTarget;
+	txTargetCode* doneTarget;
+	fxScopeCodingBlock(self->scope, param);
+	fxScopeCodeDefineNodes(self->scope, param);
+	nextTarget = fxCoderCreateTarget(param);
+	doneTarget = fxCoderCreateTarget(param);
+	if (self->initialization)
+		fxNodeDispatchCode(self->initialization, param);
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxScopeCodeRefresh(self->scope, param);
+	fxCoderAdd(param, 0, nextTarget);
+	if (self->expression) {
+		fxNodeDispatchCode(self->expression, param);
+		fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, doneTarget);
+	}
+	coder->firstContinueTarget->environmentLevel = coder->environmentLevel;
+	coder->firstContinueTarget->scopeLevel = coder->scopeLevel;
+	fxNodeDispatchCode(self->statement, param);
+	fxCoderAdd(param, 0, coder->firstContinueTarget);
+	if (self->iteration) {
+		fxScopeCodeRefresh(self->scope, param);
+		self->iteration->flags |= mxExpressionNoValue;
+		fxNodeDispatchCode(self->iteration, param);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
+	fxCoderAdd(param, 0, doneTarget);
+	fxScopeCoded(self->scope, param);
+}
+
+void fxForInForOfNodeCode(void* it, void* param) 
+{
+	txForInForOfNode* self = it;
+	txCoder* coder = param;
+	txBoolean async = (self->description->code == XS_CODE_FOR_AWAIT_OF) ? 1 : 0;
+	txInteger iterator;
+	txInteger next;
+	txInteger done;
+	txInteger result;
+	txInteger selector;
+	txInteger selection;
+	txTargetCode* nextTarget;
+	txTargetCode* returnTarget;
+	txTargetCode* doneTarget;
+	txTargetCode* catchTarget;
+	txTargetCode* normalTarget;
+	txTargetCode* finallyTarget;
+	
+	iterator = fxCoderUseTemporaryVariable(param);
+	next = fxCoderUseTemporaryVariable(param);
+	done = fxCoderUseTemporaryVariable(param);
+	result = fxCoderUseTemporaryVariable(param);
+	selector = fxCoderUseTemporaryVariable(coder);
+	fxScopeCodingBlock(self->scope, param);
+
+	fxScopeCodeDefineNodes(self->scope, param);
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddByte(param, 0, self->description->code);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, next);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+	coder->firstBreakTarget = fxCoderAliasTargets(param, coder->firstBreakTarget);
+	coder->firstContinueTarget->nextTarget = fxCoderAliasTargets(param, coder->firstContinueTarget->nextTarget);
+	coder->returnTarget = fxCoderAliasTargets(param, coder->returnTarget);
+	catchTarget = fxCoderCreateTarget(param);
+	normalTarget = fxCoderCreateTarget(param);
+	finallyTarget = fxCoderCreateTarget(param);
+	nextTarget = fxCoderCreateTarget(param);
+	
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, selector);
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	
+	fxCoderAdd(param, 0, nextTarget);
+	fxCoderAddByte(param, 1, XS_CODE_TRUE);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, next);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+	}
+	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, done);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, normalTarget);
+	
+	fxScopeCodeReset(self->scope, param);
+	fxNodeDispatchCodeReference(self->reference, param);
+	fxCoderAddByte(param, 1, XS_CODE_TRUE);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+	fxCoderAddByte(param, 1, XS_CODE_FALSE);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, done);
+	fxNodeDispatchCodeAssign(self->reference, param, 0);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+
+	coder->firstContinueTarget->environmentLevel = coder->environmentLevel;
+	coder->firstContinueTarget->scopeLevel = coder->scopeLevel;
+	fxNodeDispatchCode(self->statement, param);
+	
+	fxCoderAdd(param, 0, coder->firstContinueTarget);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
+
+	selection = 1;
+	coder->firstBreakTarget = fxCoderFinalizeTargets(param, coder->firstBreakTarget, selector, &selection, finallyTarget);
+	coder->firstContinueTarget->nextTarget = fxCoderFinalizeTargets(param, coder->firstContinueTarget->nextTarget, selector, &selection, finallyTarget);
+	coder->returnTarget = fxCoderFinalizeTargets(param, coder->returnTarget, selector, &selection, finallyTarget);
+	fxCoderAdd(param, 0, normalTarget);
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, selection);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAdd(param, 0, finallyTarget);
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	fxCoderAdd(param, 0, catchTarget);
+	
+	nextTarget = fxCoderCreateTarget(param);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, nextTarget);
+	fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, result);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	catchTarget = fxCoderCreateTarget(param);
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	fxCoderAdd(param, 0, nextTarget);
+	
+	doneTarget = fxCoderCreateTarget(param);
+	returnTarget = fxCoderCreateTarget(param);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, done);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->returnSymbol);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, returnTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddByte(param, 0, XS_CODE_SWAP);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(param, 0, XS_CODE_THROW_STATUS);
+	}
+ 	fxCoderAddByte(param, 0, XS_CODE_CHECK_INSTANCE);
+	fxCoderAdd(param, 0, returnTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAdd(param, 0, doneTarget);
+
+	nextTarget = fxCoderCreateTarget(param);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, nextTarget);
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	fxCoderAdd(param, 0, catchTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+	fxCoderAddByte(param, -1, XS_CODE_THROW);
+	fxCoderAdd(param, 0, nextTarget);
+	
+	selection = 1;
+	fxCoderJumpTargets(param, coder->firstBreakTarget, selector, &selection);
+	fxCoderJumpTargets(param, coder->firstContinueTarget->nextTarget, selector, &selection);
+	fxCoderJumpTargets(param, coder->returnTarget, selector, &selection);
+	
+	fxScopeCoded(self->scope, param);
+	fxCoderUnuseTemporaryVariables(param, 5);
+}
+
+void fxFunctionNodeCode(void* it, void* param) 
+{
+	txFunctionNode* self = it;
+	txCoder* coder = param;
+	txInteger environmentLevel = coder->environmentLevel;
+	txBoolean evalFlag = coder->evalFlag;
+	txInteger line = coder->line;
+	txBoolean programFlag = coder->programFlag;
+	txInteger scopeLevel = coder->scopeLevel;
+	txTargetCode* firstBreakTarget = coder->firstBreakTarget;
+	txTargetCode* firstContinueTarget = coder->firstContinueTarget;
+	txTargetCode* returnTarget = coder->returnTarget;
+	txSymbol* name = self->symbol;
+	txTargetCode* target = fxCoderCreateTarget(param);
+	
+	if ((self->flags & mxEvalFlag) && !(self->flags & mxStrictFlag))
+		coder->evalFlag = 1;
+	coder->line = -1;
+	coder->programFlag = 0;
+	coder->scopeLevel = 0;
+	coder->firstBreakTarget = NULL;
+	coder->firstContinueTarget = NULL;
+
+    if (name) {
+        if (self->flags & mxGetterFlag) {
+            txString buffer = coder->parser->buffer;
+            c_strcpy(buffer, "get ");
+            c_strcat(buffer, name->string);
+            name = fxNewParserSymbol(coder->parser, buffer);
+        }
+        else if (self->flags & mxSetterFlag) {
+            txString buffer = coder->parser->buffer;
+            c_strcpy(buffer, "set ");
+            c_strcat(buffer, name->string);
+            name = fxNewParserSymbol(coder->parser, buffer);
+        }
+    }
+    
+	if (self->flags & mxAsyncFlag) {
+		if (self->flags & mxGeneratorFlag)
+			fxCoderAddSymbol(param, 1, XS_CODE_ASYNC_GENERATOR_FUNCTION, name);
+		else
+			fxCoderAddSymbol(param, 1, XS_CODE_ASYNC_FUNCTION, name);
+	}
+	else if (self->flags & mxGeneratorFlag)
+		fxCoderAddSymbol(param, 1, XS_CODE_GENERATOR_FUNCTION, name);
+	else if (self->flags & (mxArrowFlag | mxMethodFlag | mxGetterFlag | mxSetterFlag))
+		fxCoderAddSymbol(param, 1, XS_CODE_FUNCTION, name);
+	else
+		fxCoderAddSymbol(param, 1, XS_CODE_CONSTRUCTOR_FUNCTION, name);
+	if (coder->parser->flags & mxDebugFlag)
+		fxCoderAddByte(param, 0, XS_CODE_PROFILE);
+	fxCoderAddBranch(param, 0, XS_CODE_CODE_1, target);
+	if (self->flags & mxFieldFlag)
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT_FIELD, fxCoderCountParameters(coder, self->params));
+	else if (self->flags & mxDerivedFlag)
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT_DERIVED, fxCoderCountParameters(coder, self->params));
+	else if (self->flags & mxBaseFlag)
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT_BASE, fxCoderCountParameters(coder, self->params));
+	else if (self->flags & mxStrictFlag)
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, fxCoderCountParameters(coder, self->params));
+	else
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_SLOPPY, fxCoderCountParameters(coder, self->params));
+	coder->path = C_NULL;
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
+	if (self->scopeCount)
+		fxCoderAddIndex(param, 0, XS_CODE_RESERVE_1, self->scopeCount);
+	fxScopeCodeRetrieve(self->scope, param);
+	fxScopeCodingParams(self->scope, param);
+	if (self->flags & mxBaseFlag) {
+		if (coder->classNode->instanceInitAccess) {
+			fxCoderAddByte(param, 1, XS_CODE_THIS);
+			fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, coder->classNode->instanceInitAccess->declaration->index);
+			fxCoderAddByte(param, 1, XS_CODE_CALL);
+			fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+			fxCoderAddByte(param, -1, XS_CODE_POP);
+		}
+	}
+	if ((self->flags & mxAsyncFlag) && !(self->flags & mxGeneratorFlag))
+		fxCoderAddByte(param, 0, XS_CODE_START_ASYNC);
+	fxNodeDispatchCode(self->params, param);
+	fxScopeCodeDefineNodes(self->scope, param);
+	coder->returnTarget = fxCoderCreateTarget(param);
+	if (self->flags & mxGeneratorFlag) {
+		if (self->flags & mxAsyncFlag)
+			fxCoderAddByte(param, 0, XS_CODE_START_ASYNC_GENERATOR);
+		else
+			fxCoderAddByte(param, 0, XS_CODE_START_GENERATOR);
+	}
+	fxNodeDispatchCode(self->body, param);
+	fxCoderAdd(param, 0, coder->returnTarget);
+	if (self->flags & mxArrowFlag)
+		fxCoderAddByte(param, 0, XS_CODE_END_ARROW);
+	else if (self->flags & mxBaseFlag)
+		fxCoderAddByte(param, 0, XS_CODE_END_BASE);
+	else if (self->flags & mxDerivedFlag)
+		fxCoderAddByte(param, 0, XS_CODE_END_DERIVED);
+	else
+		fxCoderAddByte(param, 0, XS_CODE_END);
+	fxCoderAdd(param, 0, target);
+	
+	if ((self->scope->flags & mxEvalFlag) || coder->evalFlag) {
+		fxCoderAddByte(coder, 1, XS_CODE_FUNCTION_ENVIRONMENT);
+		fxScopeCodeStore(self->scope, param);
+		fxCoderAddByte(coder, -1, XS_CODE_POP);
+	}
+	else if (self->scope->closureNodeCount || (self->flags & mxArrowFlag)) {
+		fxCoderAddByte(coder, 1, XS_CODE_ENVIRONMENT);
+		fxScopeCodeStore(self->scope, param);
+		fxCoderAddByte(coder, -1, XS_CODE_POP);
+	}
+	if ((self->flags & (mxArrowFlag | mxBaseFlag | mxDerivedFlag | mxGeneratorFlag | mxStrictFlag | mxMethodFlag)) == 0) {
+		fxCoderAddByte(param, 1, XS_CODE_DUB);
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, coder->parser->callerSymbol);
+		fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, XS_DONT_ENUM_FLAG);
+	}
+	
+	coder->returnTarget = returnTarget;
+	coder->firstContinueTarget = firstContinueTarget;
+	coder->firstBreakTarget = firstBreakTarget;
+	coder->scopeLevel = scopeLevel;
+	coder->programFlag = programFlag;
+	coder->line = line;
+	coder->evalFlag = evalFlag;
+	coder->environmentLevel = environmentLevel;
+}
+
+void fxHostNodeCode(void* it, void* param) 
+{
+	txHostNode* self = it;
+	txCoder* coder = param;
+	txParser* parser = coder->parser;
+    if (self->symbol) {
+        if (self->flags & mxGetterFlag) {
+            txString buffer = coder->parser->buffer;
+            c_strcpy(buffer, "get ");
+            c_strcat(buffer, self->symbol->string);
+            self->symbol = fxNewParserSymbol(coder->parser, buffer);
+        }
+        else if (self->flags & mxSetterFlag) {
+            txString buffer = coder->parser->buffer;
+            c_strcpy(buffer, "set ");
+            c_strcat(buffer, self->symbol->string);
+            self->symbol = fxNewParserSymbol(coder->parser, buffer);
+        }
+    }
+	if (self->params)
+		self->paramsCount = fxCoderCountParameters(coder, self->params);
+	else
+		self->paramsCount = -1;	
+	if (parser->firstHostNode)
+		parser->lastHostNode->nextHostNode = self;
+	else
+		parser->firstHostNode = self;
+	parser->lastHostNode = self;
+	fxCoderAddIndex(param, 1, XS_CODE_HOST, parser->hostNodeIndex);
+	parser->hostNodeIndex++;
+}
+
+void fxIfNodeCode(void* it, void* param) 
+{
+	txIfNode* self = it;
+	txCoder* coder = param;
+	fxNodeDispatchCode(self->expression, param);
+	if (coder->programFlag) {
+		txTargetCode* elseTarget = fxCoderCreateTarget(param);
+		txTargetCode* endTarget = fxCoderCreateTarget(param);
+		fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+		fxNodeDispatchCode(self->thenStatement, param);
+		fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
+		fxCoderAdd(param, 0, elseTarget);
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+		if (self->elseStatement)
+			fxNodeDispatchCode(self->elseStatement, param);
+		fxCoderAdd(param, 0, endTarget);
+	}
+	else {
+		if (self->elseStatement) {
+			txTargetCode* elseTarget = fxCoderCreateTarget(param);
+			txTargetCode* endTarget = fxCoderCreateTarget(param);
+			fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
+			fxNodeDispatchCode(self->thenStatement, param);
+			fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
+			fxCoderAdd(param, 0, elseTarget);
+			fxNodeDispatchCode(self->elseStatement, param);
+			fxCoderAdd(param, 0, endTarget);
+		}
+		else {
+			txTargetCode* endTarget = fxCoderCreateTarget(param);
+			fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, endTarget);
+			fxNodeDispatchCode(self->thenStatement, param);
+			fxCoderAdd(param, 0, endTarget);
+		}
+	}
+}
+
+void fxImportNodeCode(void* it, void* param) 
+{
+}
+
+void fxImportCallNodeCode(void* it, void* param)
+{
+	txCoder* coder = param;
+	txStatementNode* self = it;
+	fxNodeDispatchCode(self->expression, param);
+	coder->importFlag = 1;
+	fxCoderAddByte(param, 0, XS_CODE_IMPORT);
+}
+
+void fxImportMetaNodeCode(void* it, void* param)
+{
+	txCoder* coder = param;
+	coder->importMetaFlag = 1;
+	fxCoderAddByte(param, 1, XS_CODE_IMPORT_META);
+}
+
+void fxIncludeNodeCode(void* it, void* param) 
+{
+	txIncludeNode* self = it;
+	fxNodeDispatchCode(self->body, param);
+}
+
+void fxIntegerNodeCode(void* it, void* param) 
+{
+	txIntegerNode* self = it;
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, self->value);
+}
+
+void fxLabelNodeCode(void* it, void* param) 
+{
+	txLabelNode* self = it;
+	txCoder* coder = param;
+	txNode* statement = self->statement;
+	txTargetCode* breakTarget;
+	while (statement->description->token == XS_TOKEN_LABEL) {
+		txLabelNode* former = (txLabelNode*)statement;
+		txLabelNode* current = self;
+		while (current) {
+			if (former->symbol && current->symbol && (former->symbol == current->symbol)) {
+				fxReportParserError(coder->parser, current->line, "duplicate label %s", current->symbol->string);
+			}
+			current = current->nextLabel;
+		}
+		former->nextLabel = self;
+		self = former;
+		statement = self->statement;
+	}
+	breakTarget = coder->firstBreakTarget;
+	while (breakTarget) {
+		txLabelNode* former = breakTarget->label;
+		if (former) {
+			txLabelNode* current = self;
+			while (current) {
+				if (former->symbol && current->symbol && (former->symbol == current->symbol)) {
+					fxReportParserError(coder->parser, current->line, "duplicate label %s", current->symbol->string);
+				}
+				current = current->nextLabel;
+			}
+		}
+		breakTarget = breakTarget->nextTarget;
+	}
+	breakTarget = fxCoderCreateTarget(coder);
+	breakTarget->nextTarget = coder->firstBreakTarget;
+	coder->firstBreakTarget = breakTarget;
+	breakTarget->label = self;
+	if (self->symbol)
+		fxNodeDispatchCode(statement, param);
+	else {
+		txTargetCode* continueTarget = fxCoderCreateTarget(coder);
+		continueTarget->nextTarget = coder->firstContinueTarget;
+		coder->firstContinueTarget = continueTarget;
+		continueTarget->label = self;
+		fxNodeDispatchCode(statement, param);
+		coder->firstContinueTarget = continueTarget->nextTarget;
+	}
+	fxCoderAdd(param, 0, coder->firstBreakTarget);
+	coder->firstBreakTarget = breakTarget->nextTarget;
+}
+
+void fxMemberNodeCode(void* it, void* param) 
+{
+	txMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddSymbol(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER : XS_CODE_GET_PROPERTY, self->symbol);
+}
+
+void fxMemberNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txMemberNode* self = it;
+	fxCoderAddSymbol(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_SET_SUPER : XS_CODE_SET_PROPERTY, self->symbol);
+}
+
+void fxMemberNodeCodeDelete(void* it, void* param) 
+{
+	txMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddSymbol(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_DELETE_SUPER : XS_CODE_DELETE_PROPERTY, self->symbol);
+}
+
+void fxMemberNodeCodeReference(void* it, void* param) 
+{
+	txMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+}
+
+txFlag fxMemberNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	txMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddSymbol(param, 0, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER : XS_CODE_GET_PROPERTY, self->symbol);
+	return 1;
+}
+
+void fxMemberAtNodeCode(void* it, void* param) 
+{
+	txMemberAtNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxNodeDispatchCode(self->at, param);
+	fxCoderAddByte(param, 0, XS_CODE_AT);
+	fxCoderAddByte(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER_AT : XS_CODE_GET_PROPERTY_AT);
+}
+
+void fxMemberAtNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txMemberAtNode* self = it;
+	fxCoderAddByte(param, -2, (self->reference->flags & mxSuperFlag) ? XS_CODE_SET_SUPER_AT : XS_CODE_SET_PROPERTY_AT);
+}
+
+void fxMemberAtNodeCodeDelete(void* it, void* param) 
+{
+	txMemberAtNode* self = it;
+	fxMemberAtNodeCodeReference(it, param);
+	fxCoderAddByte(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_DELETE_SUPER_AT : XS_CODE_DELETE_PROPERTY_AT);
+}
+
+void fxMemberAtNodeCodeReference(void* it, void* param) 
+{
+	txMemberAtNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxNodeDispatchCode(self->at, param);
+	fxCoderAddByte(param, 0, XS_CODE_AT);
+}
+
+txFlag fxMemberAtNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	txMemberAtNode* self = it;
+	if (flag) {
+		fxMemberAtNodeCodeReference(it, param);
+		fxCoderAddByte(param, 2, XS_CODE_DUB_AT);
+		flag = 2;
+	}
+	else {
+		fxNodeDispatchCode(self->reference, param);
+		fxCoderAddByte(param, 1, XS_CODE_DUB);
+		fxNodeDispatchCode(self->at, param);
+		fxCoderAddByte(param, 0, XS_CODE_AT);
+	}
+	fxCoderAddByte(param, -1, (self->reference->flags & mxSuperFlag) ? XS_CODE_GET_SUPER_AT : XS_CODE_GET_PROPERTY_AT);
+	return flag;
+}
+
+void fxModuleNodeCode(void* it, void* param) 
+{
+	txModuleNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* target = fxCoderCreateTarget(param);
+	txDeclareNode* declaration;
+	txInteger count;
+	txSymbol* name = /*(coder->parser->flags & mxDebugFlag) ? self->path :*/ C_NULL;
+	txFlag flag = 0;
+	
+	coder->line = -1;
+	coder->programFlag = 0;
+	coder->scopeLevel = 0;
+	coder->firstBreakTarget = NULL;
+	coder->firstContinueTarget = NULL;
+
+	count = 0;
+	declaration = self->scope->firstDeclareNode;
+	while (declaration) {
+		if ((declaration->description->token == XS_TOKEN_DEFINE) || (declaration->description->token == XS_TOKEN_VAR))
+			count++;
+		declaration = declaration->nextDeclareNode;
+	}
+	if (count) {
+		fxCoderAddSymbol(param, 1, XS_CODE_FUNCTION, name);
+		if (coder->parser->flags & mxDebugFlag)
+			fxCoderAddByte(param, 0, XS_CODE_PROFILE);
+		fxCoderAddBranch(param, 0, XS_CODE_CODE_1, target);
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, 0);
+		coder->path = C_NULL;
+		if (self->line >= 0)
+			fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
+		if (self->scopeCount)
+			fxCoderAddIndex(param, 0, XS_CODE_RESERVE_1, self->scopeCount);
+		fxScopeCodeRetrieve(self->scope, param);
+		declaration = self->scope->firstDeclareNode;
+		while (declaration) {
+			if (declaration->description->token == XS_TOKEN_VAR) {
+				fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+				fxCoderAddIndex(coder, 0, XS_CODE_VAR_CLOSURE_1, declaration->index);
+				fxCoderAddByte(coder, -1, XS_CODE_POP);
+			}
+			declaration = declaration->nextDeclareNode;
+		}
+		fxScopeCodeDefineNodes(self->scope, param);
+		fxCoderAddByte(param, 0, XS_CODE_END);
+		fxCoderAdd(param, 0, target);
+		fxCoderAddByte(param, 1, XS_CODE_ENVIRONMENT);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+		target = fxCoderCreateTarget(param);
+		coder->line = -1;
+		coder->programFlag = 0;
+		coder->scopeLevel = 0;
+		coder->firstBreakTarget = NULL;
+		coder->firstContinueTarget = NULL;
+	}
+	else {
+		fxCoderAddByte(coder, 1, XS_CODE_NULL);
+	}
+	
+	if (self->flags & mxAwaitingFlag)
+		fxCoderAddSymbol(param, 1, XS_CODE_ASYNC_FUNCTION, name);
+	else
+		fxCoderAddSymbol(param, 1, XS_CODE_FUNCTION, name);
+	if (coder->parser->flags & mxDebugFlag)
+		fxCoderAddByte(param, 0, XS_CODE_PROFILE);
+	fxCoderAddBranch(param, 0, XS_CODE_CODE_1, target);
+	fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, 0);
+	coder->path = C_NULL;
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
+	if (self->scopeCount)
+		fxCoderAddIndex(param, 0, XS_CODE_RESERVE_1, self->scopeCount);
+	fxScopeCodeRetrieve(self->scope, param);
+	
+	if (self->flags & mxAwaitingFlag)
+		fxCoderAddByte(param, 0, XS_CODE_START_ASYNC);
+
+	coder->returnTarget = fxCoderCreateTarget(param);
+	
+	fxNodeDispatchCode(self->body, param);
+	
+	fxCoderAdd(param, 0, coder->returnTarget);
+	fxCoderAddByte(param, 0, XS_CODE_END);
+	fxCoderAdd(param, 0, target);
+	
+	fxCoderAddByte(param, 1, XS_CODE_ENVIRONMENT);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	
+	count = 2 + fxScopeCodeSpecifierNodes(self->scope, coder);
+	fxCoderAddInteger(coder, 1, XS_CODE_INTEGER_1, count);
+	if (coder->importFlag)
+		flag |= XS_IMPORT_FLAG;
+	if (coder->importMetaFlag)
+		flag |= XS_IMPORT_META_FLAG;
+	fxCoderAddIndex(coder, 0 - count, XS_CODE_MODULE, flag);
+	fxCoderAddByte(coder, -1, XS_CODE_SET_RESULT);
+	fxCoderAddByte(coder, 0, XS_CODE_END);
+}
+
+void fxNewNodeCode(void* it, void* param) 
+{
+	txCallNewNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddByte(param, 2, XS_CODE_NEW);
+	fxNodeDispatchCode(self->params, param);
+}
+
+void fxNumberNodeCode(void* it, void* param) 
+{
+	txNumberNode* self = it;
+	fxCoderAddNumber(param, 1, XS_CODE_NUMBER, self->value);
+}
+
+void fxObjectNodeCode(void* it, void* param) 
+{
+	txObjectNode* self = it;
+	txCoder* coder = param;
+	txInteger object = fxCoderUseTemporaryVariable(param);
+	txNode* item;
+	txFlag flag = 0;
+	if (self->items) {
+		item = self->items->first;
+		while (item) {
+			if (item->description->token == XS_TOKEN_PROPERTY) {
+				if (!(item->flags & mxShorthandFlag) && (((txPropertyNode*)item)->symbol == coder->parser->__proto__Symbol)) {
+					if (flag)
+						fxReportParserError(coder->parser, item->line, "invalid __proto__");
+					flag = 1;
+					fxNodeDispatchCode(((txPropertyNode*)item)->value, param);
+					fxCoderAddByte(param, 0, XS_CODE_INSTANTIATE);
+				}
+			}
+			item = item->next;
+		}
+	}
+	if (!flag)
+		fxCoderAddByte(param, 1, XS_CODE_OBJECT);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, object);
+	if (self->items) {
+		item = self->items->first;
+		while (item) {
+			if (item->description->token == XS_TOKEN_SPREAD) {
+				fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+				fxCoderAddByte(param, 1, XS_CODE_COPY_OBJECT);
+				fxCoderAddByte(param, 1, XS_CODE_CALL);
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+				fxNodeDispatchCode(((txSpreadNode*)item)->expression, param);
+				fxCoderAddInteger(param, -4, XS_CODE_RUN_1, 2);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+			}
+			else {
+				txNode* value;
+				if (item->description->token == XS_TOKEN_PROPERTY) {
+					if (!(item->flags & mxShorthandFlag) && (((txPropertyNode*)item)->symbol == coder->parser->__proto__Symbol)) {
+						item = item->next;
+						continue;
+					}
+					value = ((txPropertyNode*)item)->value;
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+					fxNodeDispatchCode(value, param);
+					fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, ((txPropertyNode*)item)->symbol);
+				}
+				else {
+					value = ((txPropertyAtNode*)item)->value;
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+					fxNodeDispatchCode(((txPropertyAtNode*)item)->at, param);
+					fxCoderAddByte(param, 0, XS_CODE_AT);
+					fxNodeDispatchCode(value, param);
+					fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
+				}
+				flag = 0;
+				if (item->flags & mxMethodFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG;
+				else if (item->flags & mxGetterFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_GETTER_FLAG;
+				else if (item->flags & mxSetterFlag)
+					flag |= XS_NAME_FLAG | XS_METHOD_FLAG | XS_SETTER_FLAG;
+				else if (fxNodeCodeName(value))
+					flag |= XS_NAME_FLAG;
+				fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
+			}
+			item = item->next;
+		}
+	}
+	fxCoderUnuseTemporaryVariables(param, 1);
+}
+
+void fxObjectBindingNodeCode(void* it, void* param)
+{
+	txObjectBindingNode* self = it;
+	txCoder* coder = param;
+	fxCoderAddByte(coder, 1, XS_CODE_UNDEFINED);
+	fxObjectBindingNodeCodeAssign(self, param, 0);
+}
+
+void fxObjectBindingNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txObjectBindingNode* self = it;
+	txNode* item = self->items->first;
+	txInteger object;
+	txInteger at;
+	txInteger c = 0;
+	object = fxCoderUseTemporaryVariable(param);
+	at = fxCoderUseTemporaryVariable(param);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddByte(param, 0, XS_CODE_TO_INSTANCE);
+	fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, object);
+	if (self->flags & mxSpreadFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, 1, XS_CODE_COPY_OBJECT);
+		fxCoderAddByte(param, 1, XS_CODE_CALL);
+		fxCoderAddByte(param, 1, XS_CODE_OBJECT);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+		c = 2;
+	}
+	while (item && (item->description->token != XS_TOKEN_REST_BINDING)) {
+		if (item->description->token == XS_TOKEN_PROPERTY_BINDING) {
+			if (self->flags & mxSpreadFlag) {
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+				fxCoderAddSymbol(param, 1, XS_CODE_SYMBOL, ((txPropertyBindingNode*)item)->symbol);
+				fxCoderAddByte(param, 0, XS_CODE_AT);
+				fxCoderAddByte(param, 0, XS_CODE_SWAP);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+				c++;
+			}
+			fxNodeDispatchCodeReference(((txPropertyBindingNode*)item)->binding, param);
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+			fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, ((txPropertyBindingNode*)item)->symbol);
+			fxNodeDispatchCodeAssign(((txPropertyBindingNode*)item)->binding, param, 0);
+		}
+		else {
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+			fxNodeDispatchCode(((txPropertyBindingAtNode*)item)->at, param);
+			fxCoderAddByte(param, 0, XS_CODE_AT);
+			if (self->flags & mxSpreadFlag) {
+				fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, at);
+				fxCoderAddByte(param, 0, XS_CODE_SWAP);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+				c++;
+			}
+			else {
+				fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, at);
+				fxCoderAddByte(param, -1, XS_CODE_POP);
+			}
+			fxNodeDispatchCodeReference(((txPropertyBindingAtNode*)item)->binding, param);
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, at);
+			fxCoderAddByte(param, -1, XS_CODE_GET_PROPERTY_AT);
+			fxNodeDispatchCodeAssign(((txPropertyBindingAtNode*)item)->binding, param, 0);
+		}
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		item = item->next;
+	}
+	if (self->flags & mxSpreadFlag) {
+		fxCoderAddInteger(param, -2 - c, XS_CODE_RUN_1, c);
+		fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, object);
+		fxNodeDispatchCodeReference(((txRestBindingNode*)item)->binding, param);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, object);
+		fxNodeDispatchCodeAssign(((txRestBindingNode*)item)->binding, param, 0);
+        fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+	fxCoderUnuseTemporaryVariables(param, 2);
+}
+
+void fxOptionNodeCode(void* it, void* param) 
+{
+	txUnaryExpressionNode* self = it;
+	txCoder* coder = param;
+	self->right->flags |= (self->flags & mxTailRecursionFlag);
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, coder->chainTarget);
+}
+
+txFlag fxOptionNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	txUnaryExpressionNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* swapTarget = fxCoderCreateTarget(param);
+	txTargetCode* skipTarget = fxCoderCreateTarget(param);
+	self->right->flags |= (self->flags & mxTailRecursionFlag);
+	flag = fxNodeDispatchCodeThis(self->right, param, flag);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_CHAIN_1, swapTarget);
+	fxCoderAddBranch(param, 1, XS_CODE_BRANCH_1, skipTarget);
+	fxCoderAdd(param, 0, swapTarget);
+	fxCoderAddByte(param, 0, XS_CODE_SWAP);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->chainTarget);
+	fxCoderAdd(param, 0, skipTarget);
+	return flag;
+}
+
+void fxOrExpressionNodeCode(void* it, void* param) 
+{
+	txBinaryExpressionNode* self = it;
+	txTargetCode* endTarget = fxCoderCreateTarget(param);
+	self->right->flags |= (self->flags & mxTailRecursionFlag);
+	fxNodeDispatchCode(self->left, param);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, endTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAdd(param, 0, endTarget);
+}
+
+void fxParamsNodeCode(void* it, void* param) 
+{
+	txParamsNode* self = it;
+	txInteger c = 0;
+	if (self->flags & mxSpreadFlag) {
+		txInteger counter = fxCoderUseTemporaryVariable(param);
+		fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
+		fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		if (self->items) {
+			txNode* item = self->items->first;
+			while (item) {
+				if (item->description->token == XS_TOKEN_SPREAD) {
+					fxSpreadNodeCode(item, param, counter);
+				}
+				else {
+					c++;
+					fxNodeDispatchCode(item, param);
+					fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+					fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 1);
+					fxCoderAddByte(param, -1, XS_CODE_ADD);
+					fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
+					fxCoderAddByte(param, -1, XS_CODE_POP);
+				}
+				item = item->next;
+			}
+		}
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+		if (self->flags & mxEvalParametersFlag)
+			fxCoderAddByte(param, -3 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_EVAL_TAIL : XS_CODE_EVAL);
+		else
+			fxCoderAddByte(param, -3 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_RUN_TAIL : XS_CODE_RUN);
+		fxCoderUnuseTemporaryVariables(param, 1);
+	}
+	else {
+		if (self->items) {
+			txNode* item = self->items->first;
+			while (item) {
+				fxNodeDispatchCode(item, param);
+				c++;
+				item = item->next;
+			}
+			if (self->flags & mxEvalParametersFlag) {
+				fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, c);
+				fxCoderAddByte(param, -3 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_EVAL_TAIL : XS_CODE_EVAL);
+			}
+			else
+				fxCoderAddInteger(param, -2 - c, (self->flags & mxTailRecursionFlag) ? XS_CODE_RUN_TAIL_1 : XS_CODE_RUN_1, c);
+		}
+	}
+}
+
+void fxParamsBindingNodeCode(void* it, void* param) 
+{
+	txParamsBindingNode* self = it;
+	txNode* item = self->items->first;
+	txInteger index = 0;
+	if (self->declaration) {
+		if (self->mapped)
+			fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS_SLOPPY, self->items->length);
+		else
+			fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS_STRICT, self->items->length);
+		if (self->declaration->flags & mxDeclareNodeClosureFlag)
+			fxCoderAddIndex(param, 0, XS_CODE_VAR_CLOSURE_1, self->declaration->index);
+		else 
+			fxCoderAddIndex(param, 0, XS_CODE_VAR_LOCAL_1, self->declaration->index);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+	while (item) {
+		if (item->description->token == XS_TOKEN_REST_BINDING) {
+			fxNodeDispatchCodeReference(((txRestBindingNode*)item)->binding, param);
+			fxCoderAddIndex(param, 1, XS_CODE_ARGUMENTS, index);
+			fxNodeDispatchCodeAssign(((txRestBindingNode*)item)->binding, param, 0);
+		}
+		else {
+			fxNodeDispatchCodeReference(item, param);
+			fxCoderAddIndex(param, 1, XS_CODE_ARGUMENT, index);
+			fxNodeDispatchCodeAssign(item, param, 0);
+		}
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		item = item->next;
+		index++;
+	}
+}
+
+void fxPostfixExpressionNodeCode(void* it, void* param) 
+{
+	txPostfixExpressionNode* self = it;
+	txInteger value;
+	fxNodeDispatchCodeThis(self->left, param, 1);
+	if (!(self->flags & mxExpressionNoValue)) {
+		value = fxCoderUseTemporaryVariable(param);
+		fxCoderAddByte(param, 0, XS_CODE_TO_NUMERIC);
+		fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, value);
+	}
+	fxCoderAddByte(param, 0, self->description->code);
+	fxNodeDispatchCodeAssign(self->left, param, 1);
+	if (!(self->flags & mxExpressionNoValue)) {
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, value);
+		fxCoderUnuseTemporaryVariables(param, 1);
+	}
+}
+
+void fxPrivateIdentifierNodeCode(void* it, void* param) 
+{
+	txPrivateMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddIndex(param, 0,  XS_CODE_HAS_PRIVATE_1, self->declaration->index);
+}
+
+void fxPrivateMemberNodeCode(void* it, void* param) 
+{
+	txPrivateMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddIndex(param, 0,  XS_CODE_GET_PRIVATE_1, self->declaration->index);
+}
+
+void fxPrivateMemberNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txPrivateMemberNode* self = it;
+	fxCoderAddIndex(param, -1, XS_CODE_SET_PRIVATE_1, self->declaration->index);
+}
+
+void fxPrivateMemberNodeCodeDelete(void* it, void* param) 
+{
+	txPrivateMemberNode* self = it;
+	txCoder* coder = param;
+	fxNodeDispatchCode(self->reference, param);
+	fxReportParserError(coder->parser, self->line, "delete private property");
+}
+
+void fxPrivateMemberNodeCodeReference(void* it, void* param) 
+{
+	txPrivateMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+}
+
+txFlag fxPrivateMemberNodeCodeThis(void* it, void* param, txFlag flag) 
+{
+	txPrivateMemberNode* self = it;
+	fxNodeDispatchCode(self->reference, param);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddIndex(param, 0, XS_CODE_GET_PRIVATE_1, self->declaration->index);
+	return 1;
+}
+
+void fxProgramNodeCode(void* it, void* param) 
+{
+	txProgramNode* self = it;
+	txCoder* coder = param;
+	
+	coder->line = -1;
+	coder->programFlag = 1;
+	coder->scopeLevel = 0;
+	coder->firstBreakTarget = NULL;
+	coder->firstContinueTarget = NULL;
+	
+	if (self->flags & mxStrictFlag)
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_STRICT, 0);
+	else
+		fxCoderAddIndex(param, 0, XS_CODE_BEGIN_SLOPPY, 0);
+	coder->path = C_NULL;
+	if (self->line >= 0)
+		fxCoderAddLine(coder, 0, XS_CODE_LINE, it); 
+	if (coder->parser->flags & mxEvalFlag) {
+		coder->evalFlag = 1;
+		fxScopeCodingEval(self->scope, param);
+	}
+	else
+		fxScopeCodingProgram(self->scope, param);
+	coder->returnTarget = fxCoderCreateTarget(param);
+	fxScopeCodeDefineNodes(self->scope, param);
+	fxNodeDispatchCode(self->body, param);
+	fxCoderAdd(param, 0, coder->returnTarget);
+	fxCoderAddByte(param, 0, XS_CODE_RETURN);
+}
+
+void fxQuestionMarkNodeCode(void* it, void* param) 
+{
+	txQuestionMarkNode* self = it;
+	txTargetCode* elseTarget = fxCoderCreateTarget(param);
+	txTargetCode* endTarget = fxCoderCreateTarget(param);
+	self->thenExpression->flags |= (self->flags & mxTailRecursionFlag);
+	self->elseExpression->flags |= (self->flags & mxTailRecursionFlag);
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, elseTarget);
+	fxNodeDispatchCode(self->thenExpression, param);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, endTarget);
+	fxCoderAdd(param, -1, elseTarget);
+	fxNodeDispatchCode(self->elseExpression, param);
+	fxCoderAdd(param, 0, endTarget);
+}
+
+void fxRegexpNodeCode(void* it, void* param) 
+{
+	txRegexpNode* self = it;
+	fxCoderAddByte(param, 1, XS_CODE_REGEXP);
+	fxCoderAddByte(param, 2, XS_CODE_NEW);
+	fxNodeDispatchCode(self->modifier, param);
+	fxNodeDispatchCode(self->value, param);
+	fxCoderAddInteger(param, -4, XS_CODE_RUN_1, 2);
+}
+
+void fxReturnNodeCode(void* it, void* param) 
+{
+	txStatementNode* self = it;
+	txCoder* coder = param;
+	if (coder->programFlag)
+		fxReportParserError(coder->parser, self->line, "invalid return");
+	if (self->expression) {	
+		if (((self->flags & (mxStrictFlag | mxGeneratorFlag)) == mxStrictFlag) && (coder->returnTarget->original == NULL))
+			self->expression->flags |= mxTailRecursionFlag;
+		fxNodeDispatchCode(self->expression, param);
+		if ((self->flags & (mxAsyncFlag | mxGeneratorFlag)) == (mxAsyncFlag | mxGeneratorFlag)) {
+			fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+			fxCoderAddByte(coder, 0, XS_CODE_THROW_STATUS);
+		}
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	else if ((self->flags & (mxAsyncFlag | mxGeneratorFlag)) != (mxAsyncFlag | mxGeneratorFlag)) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxCoderAdjustEnvironment(coder, coder->returnTarget);
+	fxCoderAdjustScope(coder, coder->returnTarget);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->returnTarget);
+}
+
+void fxSpreadNodeCode(void* it, void* param, txInteger counter) 
+{
+	txSpreadNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* nextTarget = fxCoderCreateTarget(param);
+	txTargetCode* doneTarget = fxCoderCreateTarget(param);
+	txInteger iterator;
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddByte(param, 0, XS_CODE_FOR_OF);
+	iterator = fxCoderUseTemporaryVariable(param);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, iterator);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAdd(param, 0, nextTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, iterator);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->nextSymbol);
+	fxCoderAddByte(param, 1, XS_CODE_CALL);
+	fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+	fxCoderAddByte(param, 1, XS_CODE_DUB);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->doneSymbol);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, doneTarget);
+	fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, coder->parser->valueSymbol);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, counter);
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 1);
+	fxCoderAddByte(param, -1, XS_CODE_ADD);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, counter);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, nextTarget);
+	fxCoderAdd(param, 1, doneTarget);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderUnuseTemporaryVariables(param, 1);
+}
+
+void fxStatementNodeCode(void* it, void* param) 
+{
+	txStatementNode* self = it;
+	txCoder* coder = param;
+	if (coder->programFlag) {
+		fxNodeDispatchCode(self->expression, param);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	else {
+		self->expression->flags |= mxExpressionNoValue;
+		fxNodeDispatchCode(self->expression, param);
+		if (coder->lastCode->id == XS_CODE_SET_CLOSURE_1) {
+			coder->lastCode->id = XS_CODE_PULL_CLOSURE_1;
+			coder->stackLevel--;
+			coder->lastCode->stackLevel = coder->stackLevel;
+		}
+		else if (coder->lastCode->id == XS_CODE_SET_LOCAL_1) {
+			coder->lastCode->id = XS_CODE_PULL_LOCAL_1;
+			coder->stackLevel--;
+			coder->lastCode->stackLevel = coder->stackLevel;
+		}
+		else
+			fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+}
+
+void fxStatementsNodeCode(void* it, void* param) 
+{
+	txStatementsNode* self = it;
+	txNode* item = self->items->first;
+	while (item) {
+		fxNodeDispatchCode(item, param);
+		item = item->next;
+	}
+}
+
+void fxStringNodeCode(void* it, void* param) 
+{
+	txStringNode* self = it;
+	txCoder* coder = param;
+	txParser* parser = coder->parser;
+	if (self->flags & mxStringErrorFlag)
+		fxReportParserError(parser, self->line, "invalid escape sequence");
+	fxCoderAddString(param, 1, XS_CODE_STRING_1, self->length, self->value);
+}
+
+void fxSuperNodeCode(void* it, void* param)
+{
+	txSuperNode* self = it;
+	txCoder* coder = param;
+	fxCoderAddByte(param, 3, XS_CODE_SUPER);
+	fxNodeDispatchCode(self->params, param);
+	fxCoderAddByte(param, 0, XS_CODE_SET_THIS);
+	if (coder->classNode->instanceInitAccess) {
+		fxCoderAddByte(param, 1, XS_CODE_GET_THIS);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_CLOSURE_1, coder->classNode->instanceInitAccess->declaration->index);
+		fxCoderAddByte(param, 1, XS_CODE_CALL);
+		fxCoderAddInteger(param, -2, XS_CODE_RUN_1, 0);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+	}
+}
+
+void fxSwitchNodeCode(void* it, void* param) 
+{
+	txSwitchNode* self = it;
+	txCoder* coder = param;
+	txTargetCode* breakTarget;
+	txCaseNode* caseNode;
+	txCaseNode* defaultNode = NULL;
+	fxNodeDispatchCode(self->expression, param);
+	fxScopeCodingBlock(self->scope, param);
+	breakTarget = fxCoderCreateTarget(coder);
+	breakTarget->label = fxNewParserChunkClear(coder->parser, sizeof(txLabelNode));
+	breakTarget->nextTarget = coder->firstBreakTarget;
+	coder->firstBreakTarget = breakTarget;
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	caseNode = (txCaseNode*)self->items->first;
+	while (caseNode) {
+		caseNode->target = fxCoderCreateTarget(param);
+		if (caseNode->expression) {
+			fxCoderAddByte(param, 1, XS_CODE_DUB);
+			fxNodeDispatchCode(caseNode->expression, param);
+			fxCoderAddByte(param, -1, XS_CODE_STRICT_EQUAL);
+			fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, caseNode->target);
+		}
+		else
+			defaultNode = caseNode;
+		caseNode = (txCaseNode*)caseNode->next;
+	}
+	if (defaultNode)
+		fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, defaultNode->target);
+	else
+		fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->firstBreakTarget);
+	caseNode = (txCaseNode*)self->items->first;
+	while (caseNode) {
+		fxCoderAdd(param, 0, caseNode->target);
+		if (caseNode->statement)
+			fxNodeDispatchCode(caseNode->statement, param);
+		caseNode = (txCaseNode*)caseNode->next;
+	}
+	fxCoderAdd(param, 0, coder->firstBreakTarget);
+	coder->firstBreakTarget = breakTarget->nextTarget;
+	fxScopeCoded(self->scope, param);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+}
+
+void fxTemplateNodeCode(void* it, void* param) 
+{
+	txTemplateNode* self = it;
+	txCoder* coder = param;
+	txParser* parser = coder->parser;
+	txNode* item = self->items->first;
+	
+	if (self->reference) {
+		txSymbol* symbol;
+		txTargetCode* cacheTarget = fxCoderCreateTarget(param);
+		txInteger i = (self->items->length / 2) + 1;
+		txInteger raws = fxCoderUseTemporaryVariable(param);
+		txInteger strings = fxCoderUseTemporaryVariable(param);
+		txFlag flag = XS_DONT_DELETE_FLAG | XS_DONT_SET_FLAG;
+
+		fxNodeDispatchCodeThis(self->reference, param, 0);
+		fxCoderAddByte(param, 1, XS_CODE_CALL);
+
+		fxGenerateTag(parser->console, parser->buffer, parser->bufferSize, (parser->path) ? parser->path->string : C_NULL);
+		symbol = fxNewParserSymbol(parser, parser->buffer);
+		fxCoderAddByte(param, 1, XS_CODE_TEMPLATE_CACHE);
+		fxCoderAddSymbol(param, 0, XS_CODE_GET_PROPERTY, symbol);
+		fxCoderAddBranch(param, 0, XS_CODE_BRANCH_COALESCE_1, cacheTarget);
+		fxCoderAddByte(param, 1, XS_CODE_TEMPLATE_CACHE);
+
+		fxCoderAddByte(param, 1, XS_CODE_ARRAY);
+		fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, strings);
+		fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
+		fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		fxCoderAddByte(param, 1, XS_CODE_ARRAY);
+		fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, raws);
+		fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
+		fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, coder->parser->lengthSymbol);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		i = 0;
+		while (item) {
+			if (item->description->token == XS_TOKEN_TEMPLATE_MIDDLE) {
+		
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, strings);
+				fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
+				fxCoderAddByte(param, 0, XS_CODE_AT);
+				if (((txTemplateItemNode*)item)->string->flags & mxStringErrorFlag)
+					fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+				else
+					fxNodeDispatchCode(((txTemplateItemNode*)item)->string, param);
+				fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
+				fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
+			
+				fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, raws);
+				fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, i);
+				fxCoderAddByte(param, 0, XS_CODE_AT);
+				fxNodeDispatchCode(((txTemplateItemNode*)item)->raw, param);
+				fxCoderAddByte(param, -3, XS_CODE_NEW_PROPERTY_AT);
+				fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, flag);
+			
+				i++;
+			}
+			item = item->next;
+		}
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, strings);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, raws);
+		fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, parser->rawSymbol);
+		fxCoderAddByte(param, -1, XS_CODE_POP);
+		fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, strings);
+		fxCoderAddByte(param, 0, XS_CODE_TEMPLATE);
+		
+		fxCoderAddSymbol(param, -1, XS_CODE_SET_PROPERTY, symbol);
+		
+		fxCoderAdd(param, 0, cacheTarget);
+		
+		i = 1;
+		item = self->items->first;
+		while (item) {
+			if (item->description->token != XS_TOKEN_TEMPLATE_MIDDLE) {
+				fxNodeDispatchCode(item, param);
+				i++;
+			}
+			item = item->next;
+		}
+		fxCoderAddInteger(param, -2 - i, (self->flags & mxTailRecursionFlag) ? XS_CODE_RUN_TAIL_1 : XS_CODE_RUN_1, i);
+		fxCoderUnuseTemporaryVariables(coder, 2);
+	}
+	else {
+		fxNodeDispatchCode(((txTemplateItemNode*)item)->string, param);
+		item = item->next;
+		while (item) {
+			if (item->description->token == XS_TOKEN_TEMPLATE_MIDDLE) {
+				fxNodeDispatchCode(((txTemplateItemNode*)item)->string, param);
+			}
+			else {
+				fxNodeDispatchCode(item, param);
+				fxCoderAddByte(param, 1, XS_CODE_TO_STRING);
+			}
+			fxCoderAddByte(param, -1, XS_CODE_ADD);
+			item = item->next;
+		}
+	}
+}
+
+void fxThisNodeCode(void* it, void* param) 
+{
+	txNode* self = it;
+	if (self->flags & mxDerivedFlag)
+		fxCoderAddByte(param, 1, XS_CODE_GET_THIS);
+	else
+		fxCoderAddByte(param, 1, self->description->code);
+}
+
+void fxThrowNodeCode(void* it, void* param) 
+{
+	txStatementNode* self = it;
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddByte(param, -1, XS_CODE_THROW);
+}
+
+void fxTryNodeCode(void* it, void* param) 
+{
+	txTryNode* self = it;
+	txCoder* coder = param;
+	txInteger exception;
+	txInteger selector;
+	txInteger result;
+	txInteger selection;
+	txTargetCode* catchTarget;
+	txTargetCode* normalTarget;
+	txTargetCode* finallyTarget;
+
+	exception = fxCoderUseTemporaryVariable(coder);
+	selector = fxCoderUseTemporaryVariable(coder);
+	result = fxCoderUseTemporaryVariable(coder);
+
+	coder->firstBreakTarget = fxCoderAliasTargets(param, coder->firstBreakTarget);
+	coder->firstContinueTarget = fxCoderAliasTargets(param, coder->firstContinueTarget);
+	coder->returnTarget = fxCoderAliasTargets(param, coder->returnTarget);
+	catchTarget = fxCoderCreateTarget(param);
+	normalTarget = fxCoderCreateTarget(param);
+	finallyTarget = fxCoderCreateTarget(param);
+
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, 0);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+
+	fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxNodeDispatchCode(self->tryBlock, param);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, normalTarget);
+	if (self->catchBlock) {
+		fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+		fxCoderAdd(param, 0, catchTarget);
+		catchTarget = fxCoderCreateTarget(param);
+		fxCoderAddBranch(param, 0, XS_CODE_CATCH_1, catchTarget);
+		if (coder->programFlag) {
+			fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+			fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+		}
+		fxNodeDispatchCode(self->catchBlock, param);
+		fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, normalTarget);
+	}
+	
+	selection = 1;
+	coder->firstBreakTarget = fxCoderFinalizeTargets(param, coder->firstBreakTarget, selector, &selection, finallyTarget);
+	coder->firstContinueTarget = fxCoderFinalizeTargets(param, coder->firstContinueTarget, selector, &selection, finallyTarget);
+	coder->returnTarget = fxCoderFinalizeTargets(param, coder->returnTarget, selector, &selection, finallyTarget);
+	fxCoderAdd(param, 0, normalTarget);
+	fxCoderAddInteger(param, 1, XS_CODE_INTEGER_1, selection);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, selector);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	fxCoderAdd(param, 0, finallyTarget);
+	fxCoderAddByte(param, 0, XS_CODE_UNCATCH);
+	fxCoderAdd(param, 0, catchTarget);
+	fxCoderAddByte(param, 1, XS_CODE_EXCEPTION);
+	fxCoderAddIndex(param, 0, XS_CODE_SET_LOCAL_1, exception);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	if (self->finallyBlock) {
+		if (coder->programFlag) {
+			fxCoderAddByte(param, 1, XS_CODE_GET_RESULT);
+			fxCoderAddIndex(param, -1, XS_CODE_PULL_LOCAL_1, result);
+			fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+			fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+		}
+		fxNodeDispatchCode(self->finallyBlock, param);
+		if (coder->programFlag) {
+			fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, result);
+			fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+		}		
+	}
+	catchTarget = fxCoderCreateTarget(param);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, selector);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_IF_1, catchTarget);
+	fxCoderAddIndex(param, 1, XS_CODE_GET_LOCAL_1, exception);
+	fxCoderAddByte(param, -1, XS_CODE_THROW);
+	fxCoderAdd(param, 0, catchTarget);
+	selection = 1;
+	fxCoderJumpTargets(param, coder->firstBreakTarget, selector, &selection);
+	fxCoderJumpTargets(param, coder->firstContinueTarget, selector, &selection);
+	fxCoderJumpTargets(param, coder->returnTarget, selector, &selection);
+	fxCoderUnuseTemporaryVariables(coder, 3);
+}
+
+void fxUnaryExpressionNodeCode(void* it, void* param) 
+{
+	txUnaryExpressionNode* self = it;
+	fxNodeDispatchCode(self->right, param);
+	fxCoderAddByte(param, 0, self->description->code);
+}
+
+void fxUndefinedNodeCodeAssign(void* it, void* param, txFlag flag) 
+{
+	txCoder* coder = param;
+	fxCoderAddSymbol(param, -1, XS_CODE_SET_VARIABLE, coder->parser->undefinedSymbol);
+}
+
+void fxUndefinedNodeCodeDelete(void* it, void* param) 
+{
+	txNode* self = it;
+	txCoder* coder = param;
+	if (self->flags & mxStrictFlag)
+		fxReportParserError(coder->parser, self->line, "delete identifier (strict code)");
+	fxCoderAddByte(param, 1, XS_CODE_FALSE);
+}
+
+void fxUndefinedNodeCodeReference(void* it, void* param) 
+{
+	txCoder* coder = param;
+	if (coder->evalFlag)
+		fxCoderAddSymbol(param, 1, XS_CODE_EVAL_REFERENCE, coder->parser->undefinedSymbol);
+	else
+		fxCoderAddSymbol(param, 1, XS_CODE_PROGRAM_REFERENCE, coder->parser->undefinedSymbol);
+}
+
+void fxValueNodeCode(void* it, void* param) 
+{
+	txNode* self = it;
+	fxCoderAddByte(param, 1, self->description->code);
+}
+
+void fxWhileNodeCode(void* it, void* param) 
+{
+	txWhileNode* self = it;
+	txCoder* coder = param;
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxCoderAdd(param, 0, coder->firstContinueTarget);
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddBranch(param, -1, XS_CODE_BRANCH_ELSE_1, coder->firstBreakTarget);
+	fxNodeDispatchCode(self->statement, param);
+	fxCoderAddBranch(param, 0, XS_CODE_BRANCH_1, coder->firstContinueTarget);
+}
+
+void fxWithNodeCode(void* it, void* param)
+{
+	txWithNode* self = it;
+	txCoder* coder = param;
+	txBoolean evalFlag;
+	fxNodeDispatchCode(self->expression, param);
+	fxCoderAddByte(param, 0, XS_CODE_TO_INSTANCE);
+	fxCoderAddByte(param, 0, XS_CODE_WITH);
+	fxCoderAddByte(param, -1, XS_CODE_POP);
+	evalFlag = coder->evalFlag;
+	coder->environmentLevel++;
+	coder->evalFlag = 1;
+	if (coder->programFlag) {
+		fxCoderAddByte(param, 1, XS_CODE_UNDEFINED);
+		fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	}
+	fxNodeDispatchCode(self->statement, param);
+	coder->evalFlag = evalFlag;
+	coder->environmentLevel--;
+	fxCoderAddByte(param, 0, XS_CODE_WITHOUT);
+}
+
+void fxYieldNodeCode(void* it, void* param) 
+{
+	txStatementNode* self = it;
+	txBoolean async = (self->flags & mxAsyncFlag) ? 1 : 0;
+	txCoder* coder = param;
+	txTargetCode* target = fxCoderCreateTarget(coder);
+	
+	if (!async) {
+		fxCoderAddByte(param, 1, XS_CODE_OBJECT);
+		fxCoderAddByte(param, 1, XS_CODE_DUB);
+	}
+	fxNodeDispatchCode(self->expression, param);
+	if (!async) {
+		fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, coder->parser->valueSymbol);
+		fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, 0);
+		fxCoderAddByte(param, 1, XS_CODE_DUB);
+		fxCoderAddByte(param, 1, XS_CODE_FALSE);
+		fxCoderAddSymbol(param, -2, XS_CODE_NEW_PROPERTY, coder->parser->doneSymbol);
+		fxCoderAddInteger(param, 0, XS_CODE_INTEGER_1, 0);
+	}
+	fxCoderAddByte(coder, 0, XS_CODE_YIELD);
+	fxCoderAddBranch(coder, 1, XS_CODE_BRANCH_STATUS_1, target);
+	if (async) {
+		fxCoderAddByte(param, 0, XS_CODE_AWAIT);
+		fxCoderAddByte(coder, 0, XS_CODE_THROW_STATUS);
+	}
+	fxCoderAddByte(param, -1, XS_CODE_SET_RESULT);
+	fxCoderAdjustEnvironment(coder, coder->returnTarget);
+	fxCoderAdjustScope(coder, coder->returnTarget);
+	fxCoderAddBranch(coder, 0, XS_CODE_BRANCH_1, coder->returnTarget);
+	fxCoderAdd(coder, 0, target);
+}
+