bootstrap.js

// Generated by Hexa 2023.7.2 https://hexalang.github.io
// Project: The Hexa Compiler
// LICENSE LGPL-3.0-only
;(() => {
	"use strict"
	const $global = typeof(window) === "undefined"? global : window
	if (typeof($global.require) === "undefined") { $global.require = () => {} };
	const selfVersion="2023.7.2";
	const $toIterator = (v) => typeof(v) === "number"? Array(Math.max(v, 0)).keys() : v;
	const Fs = require("fs")
	const Path = require("path")
	const ProcessModule = require("process")
	var Token = {
		stringify: (token, param = null) => { {
		const temp = token;
		switch (temp) {
		case 70: {
			return '@'
		} break;
		
		case 83: {
			return '$'
		} break;
		
		case 78: {
			return '#'
		} break;
		
		case 71: {
			return ']'
		} break;
		
		case 72: {
			return '['
		} break;
		
		case 73: {
			return '}'
		} break;
		
		case 74: {
			return '{'
		} break;
		
		case 76: {
			return ':'
		} break;
		
		case 75: {
			return ','
		} break;
		
		case 123: {
			return '<!--empty-->'
		} break;
		
		case 77: {
			return '.'
		} break;
		
		case 0: {
			return '<!--end-->'
		} break;
		
		case 98: {
			return '...'
		} break;
		
		case 58: {
			return 'as'
		} break;
		
		case 3: {
			return 'break'
		} break;
		
		case 4: {
			return 'case'
		} break;
		
		case 6: {
			return 'catch'
		} break;
		
		case 7: {
			return 'class'
		} break;
		
		case 8: {
			return 'continue'
		} break;
		
		case 9: {
			return 'do'
		} break;
		
		case 10: {
			return 'else'
		} break;
		
		case 11: {
			return 'enum'
		} break;
		
		case 12: {
			return 'extends'
		} break;
		
		case 13: {
			return 'declare'
		} break;
		
		case 14: {
			return 'false'
		} break;
		
		case 15: {
			return 'for'
		} break;
		
		case 21: {
			return 'fun'
		} break;
		
		case 17: {
			return 'if'
		} break;
		
		case 18: {
			return 'implements'
		} break;
		
		case 2: {
			return 'import'
		} break;
		
		case 20: {
			return 'in'
		} break;
		
		case 22: {
			return 'interface'
		} break;
		
		case 23: {
			return 'let'
		} break;
		
		case 25: {
			return 'new'
		} break;
		
		case 26: {
			return 'null'
		} break;
		
		case 29: {
			return 'private'
		} break;
		
		case 31: {
			return 'return'
		} break;
		
		case 32: {
			return 'static'
		} break;
		
		case 59: {
			return 'super'
		} break;
		
		case 33: {
			return 'switch'
		} break;
		
		case 34: {
			return 'this'
		} break;
		
		case 35: {
			return 'throw'
		} break;
		
		case 36: {
			return 'true'
		} break;
		
		case 37: {
			return 'try'
		} break;
		
		case 40: {
			return 'var'
		} break;
		
		case 41: {
			return 'while'
		} break;
		
		case 111: {
			return '+'
		} break;
		
		case 112: {
			return '&'
		} break;
		
		case 90: {
			return '=>'
		} break;
		
		case 91: {
			return '='
		} break;
		
		case 92: {
			return '&&'
		} break;
		
		case 93: {
			return '||'
		} break;
		
		case 86: {
			return '--'
		} break;
		
		case 94: {
			return '/'
		} break;
		
		case 95: {
			return '=='
		} break;
		
		case 96: {
			return '>'
		} break;
		
		case 97: {
			return '>='
		} break;
		
		case 87: {
			return '++'
		} break;
		
		case 110: {
			return '\\'
		} break;
		
		case 99: {
			return '<'
		} break;
		
		case 100: {
			return '<='
		} break;
		
		case 101: {
			return '%'
		} break;
		
		case 102: {
			return '*'
		} break;
		
		case 88: {
			return '~'
		} break;
		
		case 89: {
			return '!'
		} break;
		
		case 103: {
			return '!='
		} break;
		
		case 104: {
			return '|'
		} break;
		
		case 105: {
			return '<<'
		} break;
		
		case 106: {
			return '>>'
		} break;
		
		case 107: {
			return '-'
		} break;
		
		case 108: {
			return '>>>'
		} break;
		
		case 109: {
			return '^'
		} break;
		
		case 113: {
			return '?.'
		} break;
		
		case 79: {
			return ')'
		} break;
		
		case 80: {
			return '('
		} break;
		
		case 81: {
			return '?'
		} break;
		
		case 82: {
			return ';'
		} break;
		
		case 1: {
			return '_'
		} break;
		
		case 61: {
			return (((param == null))? ('TitleCase') : param)
		} break;
		
		case 64: {
			return (((param == null))? ('string') : ('\'' + (param) + '\''))
		} break;
		
		case 66: {
			return (((param == null))? ('backtick') : ('`' + (param) + '`'))
		} break;
		
		case 62: {
			return (((param == null))? ('identifier') : param)
		} break;
		
		case 63: {
			return (((param == null))? ('integer') : param)
		} break;
		
		case 60: {
			return (((param == null))? ('float') : param)
		} break;
		
		case 65: {
			return ('///' + (param) + '')
		} break;
		
		case 57: {
			return 'is'
		} break;
		};
	} },
	}
	var Meta = {
		stringify: (kind) => { {
		const temp_6640 = kind;
		switch (temp_6640) {
		case 0: {
			return 'Default'
		} break;
		
		case 1: {
			return 'BigInt'
		} break;
		
		case 2: {
			return 'Int32'
		} break;
		
		case 3: {
			return 'Int64'
		} break;
		
		case 4: {
			return 'Int16'
		} break;
		
		case 5: {
			return 'Int8'
		} break;
		
		case 6: {
			return 'UInt32'
		} break;
		
		case 7: {
			return 'UInt64'
		} break;
		
		case 8: {
			return 'UInt16'
		} break;
		
		case 9: {
			return 'UInt8'
		} break;
		
		case 10: {
			return 'Float32'
		} break;
		};
	} },
	}
	var Statement = {
	}
	var Expression = {
	}
	var NiceType = {
	}
	var ImportNode = {
	}
	var NodeType = {
		stringify: (nodeType) => { {
		{
			const temp = nodeType;
			switch (temp&&temp[0]) {
			case 0: {
				const type_6721 = temp[1];
				return NodeType.stringify(type_6721) + '?'
			} break;
			
			case 5: {
				const names_6722 = temp[1];
				const types_6723 = temp[2];
				{
					if (names_6722.length == 0) { return '{}' };
					return '{ ' + (() => {
						const result = [];
						const value_6724 = names_6722.length;
						for (const i of $toIterator(value_6724)) result.push(names_6722[i] + ': ' + NodeType.stringify(types_6723[i]));
						return result;
					})().join(', ') + ' }';
				}
			} break;
			
			case 3: {
				const args_6725 = temp[1];
				const ret_6726 = temp[2];
				return '(' + args_6725.map((arg) => (NodeType.stringify(arg))).join(', ') + ') => ' + NodeType.stringify(ret_6726)
			} break;
			};
		};
		return DataHelper.extractTypeName(nodeType);
	} },
		clone: (nodeType_6727) => { {
		{
			const temp_6728 = nodeType_6727;
			switch (temp_6728&&temp_6728[0]) {
			case 1: {
				const name_6729 = temp_6728[1];
				const path_6730 = temp_6728[2];
				return /*Type*/[1,name_6729,path_6730,".Type"]
			} break;
			
			case 2: {
				const name_6731 = temp_6728[1];
				const params_6732 = temp_6728[2];
				const path_6733 = temp_6728[3];
				return /*ParametricType*/[2,name_6731,params_6732.map((param) => (NodeType.clone(param))),path_6733,".ParametricType"]
			} break;
			};
		};
		console.error('Cannot clone node type', nodeType_6727);
		return nodeType_6727;
	} },
	}
	var Node = {
		stringify: (node) => { {
		const temp = node;
		switch (temp&&temp[0]) {
		case 0: {
			const s = temp[1];
			return ('\'' + (s) + '\'')
		} break;
		
		case 1: {
			const name_6779 = temp[1];
			return name_6779
		} break;
		
		case 2: {
			const b = temp[1];
			return ((b)? ('true') : 'false')
		} break;
		
		case 5: {
			const s_6780 = temp[1];
			return s_6780.toString(10)
		} break;
		
		case 7: {
			const s_6781 = temp[1];
			return s_6781.toString(10)
		} break;
		
		case 8: {
			return 'null'
		} break;
		
		case 3: {
			return 'this'
		} break;
		
		case 15: {
			const expr_6782 = temp[1];
			return '(' + Node.stringify(expr_6782) + ')'
		} break;
		
		case 33: {
			const expr_6783 = temp[1];
			const index_6784 = temp[2];
			return Node.stringify(expr_6783) + '[' + Node.stringify(index_6784) + ']'
		} break;
		
		case 28: {
			const expr_6785 = temp[1];
			const name_6786 = temp[2];
			return Node.stringify(expr_6785) + '.' + name_6786
		} break;
		
		case 29: {
			const expr_6787 = temp[1];
			const name_6788 = temp[2];
			return Node.stringify(expr_6787) + '.' + name_6788
		} break;
		
		case 13: {
			const e_6789 = temp[1];
			const args_6790 = temp[2];
			const argNames_6791 = temp[3];
			{
				const arg = [];
				{
					let i = 0;
					let it = 0;
					let at = args_6790.length;
					while (it < at) {
						i = it;
						it++;
						{
							let step = 0;
							const name_6792 = argNames_6791[i];
							if (step == 0 && name_6792 != null) { step = 1 };
							if (step == 1) { arg.push(name_6792 + ': ' + Node.stringify(args_6790[i])) } else {
								arg.push(Node.stringify(args_6790[i]));
							};
						};
					};
				};
				return Node.stringify(e_6789) + '(' + arg.join(', ') + ')';
			}
		} break;
		
		case 31: {
			const elements_6793 = temp[1];
			return '[' + (() => {
				const result = [];
				const value_6794 = elements_6793;
				for (const el of $toIterator(value_6794)) result.push(Node.stringify(el));
				return result;
			})().join(', ') + ']'
		} break;
		
		case 10: {
			const a = temp[1];
			const op_6795 = temp[2];
			const b_6796 = temp[3];
			return Node.stringify(a) + ' ' + Token.stringify(op_6795) + ' ' + Node.stringify(b_6796)
		} break;
		
		case 38: {
			const names_6797 = temp[1];
			const el_6798 = temp[2];
			return '{' + (() => {
				const result_6799 = [];
				const value_6800 = el_6798.length;
				for (const i of $toIterator(value_6800)) result_6799.push(names_6797[i] + ': ' + Node.stringify(el_6798[i]));
				return result_6799;
			})().join(', ') + '}'
		} break;
		
		case 51: {
			const t_6801 = temp[1];
			return DataHelper.extractTypeName(t_6801)
		} break;
		
		case 47: {
			const f = temp[1];
			return 'static ' + Node.stringify(f)
		} break;
		
		default: 
		{
			console.error('stringify', node);
			return '...';
		}
		};
	} },
		clone: (project, node_6802) => { {
		const p = project;
		{
			const temp_6803 = node_6802;
			switch (temp_6803&&temp_6803[0]) {
			case 0: {
				const s_6804 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*String*/[0,s_6804,".String"])
			} break;
			
			case 1: {
				const name_6805 = temp_6803[1];
				const params_6806 = temp_6803[2];
				{
					{
						let step_6807 = 0;
						const params_6808 = params_6806;
						if (step_6807 == 0 && params_6808 != null) { step_6807 = 1 };
						if (step_6807 == 1) { return Node.cloneData(p, node_6802, /*Ident*/[1,name_6805,params_6808.map((param) => (NodeType.clone(param))),".Ident"]) };
					};
					return Node.cloneData(p, node_6802, /*Ident*/[1,name_6805,null,".Ident"]);
				}
			} break;
			
			case 2: {
				const b_6809 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*Bool*/[2,b_6809,".Bool"])
			} break;
			
			case 5: {
				const s_6810 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*Int*/[5,s_6810,".Int"])
			} break;
			
			case 6: {
				const number_6811 = temp_6803[1];
				const meta_6812 = temp_6803[2];
				return Node.cloneData(p, node_6802, /*MetaInt*/[6,number_6811,meta_6812,".MetaInt"])
			} break;
			
			case 7: {
				const s_6813 = temp_6803[1];
				const meta_6814 = temp_6803[2];
				return Node.cloneData(p, node_6802, /*Float*/[7,s_6813,meta_6814,".Float"])
			} break;
			
			case 8: {
				return Node.cloneData(p, node_6802, /*Null*/[8,".Null"])
			} break;
			
			case 3: {
				return Node.cloneData(p, node_6802, /*This*/[3,".This"])
			} break;
			
			case 15: {
				const expr_6815 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*Parenthesis*/[15,Node.cloneData(p, expr_6815, Node.clone(p, expr_6815)),".Parenthesis"])
			} break;
			
			case 33: {
				const expr_6816 = temp_6803[1];
				const index_6817 = temp_6803[2];
				return Node.cloneData(p, node_6802, /*Index*/[33,Node.cloneData(p, expr_6816, Node.clone(p, expr_6816)),Node.cloneData(p, index_6817, Node.clone(p, index_6817)),".Index"])
			} break;
			
			case 28: {
				const expr_6818 = temp_6803[1];
				const name_6819 = temp_6803[2];
				return Node.cloneData(p, node_6802, /*Dot*/[28,Node.cloneData(p, expr_6818, Node.clone(p, expr_6818)),name_6819,".Dot"])
			} break;
			
			case 29: {
				const expr_6820 = temp_6803[1];
				const name_6821 = temp_6803[2];
				return Node.cloneData(p, node_6802, /*DotUpper*/[29,Node.cloneData(p, expr_6820, Node.clone(p, expr_6820)),name_6821,".DotUpper"])
			} break;
			
			case 13: {
				const e_6822 = temp_6803[1];
				const args_6823 = temp_6803[2];
				const argNames_6824 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*Call*/[13,Node.cloneData(p, e_6822, Node.clone(p, e_6822)),args_6823.map((arg_6825) => (Node.cloneData(p, arg_6825, Node.clone(p, arg_6825)))),argNames_6824,".Call"])
			} break;
			
			case 31: {
				const elements_6826 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*Array*/[31,elements_6826.map((arg_6827) => (Node.cloneData(p, arg_6827, Node.clone(p, arg_6827)))),".Array"])
			} break;
			
			case 10: {
				const a_6828 = temp_6803[1];
				const op_6829 = temp_6803[2];
				const b_6830 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*Binop*/[10,Node.cloneData(p, a_6828, Node.clone(p, a_6828)),op_6829,Node.cloneData(p, b_6830, Node.clone(p, b_6830)),".Binop"])
			} break;
			
			case 11: {
				const storage_6831 = temp_6803[1];
				const op_6832 = temp_6803[2];
				const value_6833 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*AssignOp*/[11,Node.cloneData(p, storage_6831, Node.clone(p, storage_6831)),op_6832,Node.cloneData(p, value_6833, Node.clone(p, value_6833)),".AssignOp"])
			} break;
			
			case 49: {
				const name_6834 = temp_6803[1];
				const over_6835 = temp_6803[2];
				const by_6836 = temp_6803[3];
				const range_6837 = temp_6803[4];
				return Node.cloneData(p, node_6802, /*For*/[49,name_6834,Node.cloneData(p, over_6835, Node.clone(p, over_6835)),Node.cloneData(p, by_6836, Node.clone(p, by_6836)),Node.cloneData(p, range_6837, Node.clone(p, range_6837)),".For"])
			} break;
			
			case 21: {
				const reason_6838 = temp_6803[1];
				const e_6839 = temp_6803[2];
				const pre_6840 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*While*/[21,Node.cloneData(p, reason_6838, Node.clone(p, reason_6838)),Node.cloneData(p, e_6839, Node.clone(p, e_6839)),pre_6840,".While"])
			} break;
			
			case 34: {
				const exprs_6841 = temp_6803[1];
				const conds_6842 = temp_6803[2];
				const guards_6843 = temp_6803[3];
				const cases_6844 = temp_6803[4];
				return Node.cloneData(p, node_6802, /*Switch*/[34,exprs_6841.map((arg_6845) => (Node.cloneData(p, arg_6845, Node.clone(p, arg_6845)))),conds_6842.map((arg_6846) => (Node.cloneData(p, arg_6846, Node.clone(p, arg_6846)))),guards_6843.map((arg_6847) => (Node.cloneData(p, arg_6847, Node.clone(p, arg_6847)))),cases_6844.map((arg_6848) => (Node.cloneData(p, arg_6848, Node.clone(p, arg_6848)))),".Switch"])
			} break;
			
			case 38: {
				const names_6849 = temp_6803[1];
				const el_6850 = temp_6803[2];
				return Node.cloneData(p, node_6802, /*Object*/[38,names_6849,el_6850.map((arg_6851) => (Node.cloneData(p, arg_6851, Node.clone(p, arg_6851)))),".Object"])
			} break;
			
			case 51: {
				const t_6852 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*NodeTypeValue*/[51,t_6852,".NodeTypeValue"])
			} break;
			
			case 44: {
				const expr_6853 = temp_6803[1];
				const kind_6854 = temp_6803[2];
				const toType_6855 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*As*/[44,Node.cloneData(p, expr_6853, Node.clone(p, expr_6853)),kind_6854,NodeType.clone(toType_6855),".As"])
			} break;
			
			case 30: {
				const path_6856 = temp_6803[1];
				const t_6857 = temp_6803[2];
				const args_6858 = temp_6803[3];
				const fields_6859 = temp_6803[4];
				const el_6860 = temp_6803[5];
				const argNames_6861 = temp_6803[6];
				return Node.cloneData(p, node_6802, /*New*/[30,path_6856,t_6857,args_6858.map((arg_6862) => (Node.cloneData(p, arg_6862, Node.clone(p, arg_6862)))),fields_6859,el_6860.map((arg_6863) => (Node.cloneData(p, arg_6863, Node.clone(p, arg_6863)))),argNames_6861,".New"])
			} break;
			
			case 20: {
				const op_6864 = temp_6803[1];
				const postfix_6865 = temp_6803[2];
				const e_6866 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*Unop*/[20,op_6864,postfix_6865,Node.cloneData(p, e_6866, Node.clone(p, e_6866)),".Unop"])
			} break;
			
			case 23: {
				const expr_6867 = temp_6803[1];
				const vars_6868 = temp_6803[2];
				const retType_6869 = temp_6803[3];
				return Node.cloneData(p, node_6802, /*Arrow*/[23,Node.cloneData(p, expr_6867, Node.clone(p, expr_6867)),vars_6868.map((arg_6870) => (Node.cloneData(p, arg_6870, Node.clone(p, arg_6870)))),retType_6869,".Arrow"])
			} break;
			
			case 47: {
				const f_6871 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*Static*/[47,Node.cloneData(p, f_6871, Node.clone(p, f_6871)),".Static"])
			} break;
			
			case 16: {
				const e_6872 = temp_6803[1];
				{
					{
						let step_6873 = 0;
						const e_6874 = e_6872;
						if (step_6873 == 0 && e_6874 != null) { step_6873 = 1 };
						if (step_6873 == 1) { return Node.cloneData(p, node_6802, /*Return*/[16,Node.cloneData(p, e_6874, Node.clone(p, e_6874)),".Return"]) };
					};
					return Node.cloneData(p, node_6802, /*Return*/[16,null,".Return"]);
				}
			} break;
			
			case 12: {
				const el_6875 = temp_6803[1];
				return Node.cloneData(p, node_6802, /*Block*/[12,el_6875.map((arg_6876) => (Node.cloneData(p, arg_6876, Node.clone(p, arg_6876)))),".Block"])
			} break;
			
			case 14: {
				const econd_6877 = temp_6803[1];
				const eif_6878 = temp_6803[2];
				const eelse_6879 = temp_6803[3];
				const ternary_6880 = temp_6803[4];
				return Node.cloneData(p, node_6802, /*If*/[14,econd_6877.map((arg_6881) => (Node.cloneData(p, arg_6881, Node.clone(p, arg_6881)))),Node.cloneData(p, eif_6878, Node.clone(p, eif_6878)),((eelse_6879 != null)? (Node.cloneData(p, eelse_6879, Node.clone(p, eelse_6879))) : null),ternary_6880,".If"])
			} break;
			
			case 24: {
				const name_6882 = temp_6803[1];
				const t_6883 = temp_6803[2];
				const expr_6884 = temp_6803[3];
				const const_6885 = temp_6803[4];
				const external_6886 = temp_6803[5];
				return Node.cloneData(p, node_6802, /*Var*/[24,name_6882,t_6883,Node.cloneData(p, expr_6884, Node.clone(p, expr_6884)),const_6885,external_6886,".Var"])
			} break;
			
			case 22: {
				const name_6887 = temp_6803[1];
				const body_6888 = temp_6803[2];
				const vars_6889 = temp_6803[3];
				const retType_6890 = temp_6803[4];
				const external_6891 = temp_6803[5];
				const variadic_6892 = temp_6803[6];
				return Node.cloneData(p, node_6802, /*Function*/[22,name_6887,Node.cloneData(p, body_6888, Node.clone(p, body_6888)),vars_6889.map((arg_6893) => (Node.cloneData(p, arg_6893, Node.clone(p, arg_6893)))),retType_6890,external_6891,variadic_6892,".Function"])
			} break;
			
			case 25: {
				const t_6894 = temp_6803[1];
				const extend_6895 = temp_6803[2];
				const implement_6896 = temp_6803[3];
				const fields_6897 = temp_6803[4];
				const external_6898 = temp_6803[5];
				const kind_6899 = temp_6803[6];
				{
					for (const field of $toIterator(fields_6897)) {
						if ((project.data.get(field) == null) && (Node.fails < 15)) { Node.fails++ };
					};
					return Node.cloneData(p, node_6802, /*Class*/[25,t_6894,extend_6895,implement_6896,fields_6897.map((arg_6900) => (Node.cloneData(p, arg_6900, Node.clone(p, arg_6900)))),external_6898,kind_6899,".Class"]);
				}
			} break;
			
			case 45: {
				return Node.cloneData(p, node_6802, /*Underscore*/[45,".Underscore"])
			} break;
			
			case 18: {
				return Node.cloneData(p, node_6802, /*Break*/[18,".Break"])
			} break;
			
			case 19: {
				return Node.cloneData(p, node_6802, /*Continue*/[19,".Continue"])
			} break;
			
			case null: case undefined: {
				return null
			} break;
			
			default: 
			{
			}
			};
		};
		console.log('Cannot clone', node_6802);
		return node_6802;
	} },
		cloneData: (project_6901, from, to) => { {
		if (from == null) { return to };
		const project_6902 = (project_6901);
		if ((project_6902.data.get(from) == null) && (Node.fails < 10)) { Node.fails++ };
		project_6902.mapDecorators.set(to, project_6902.mapDecorators.get(from));
		project_6902.data.set(to, project_6902.data.get(from));
		return to;
	} },
	}
	Node.fails = 0
	var Type = {
		stringify: (type_6940) => { {
		const temp = type_6940;
		switch (temp&&temp[0]) {
		case 6: {
			const type_6941 = temp[1];
			const generic_6942 = temp[2];
			{
				{
					let step = 0;
					const gen = generic_6942;
					if (step == 0 && gen != null) { step = 1 };
					if (step == 1) { return DataHelper.nameOf(type_6941.parent) + '<' + (() => {
						const result = [];
						const value_6943 = gen;
						for (const g of $toIterator(value_6943)) result.push(Type.stringify(g));
						return result;
					})().join(', ') + '>' };
				};
				return DataHelper.nameOf(type_6941.parent);
			}
		} break;
		
		case 1: {
			const index_6944 = temp[1];
			const name_6945 = temp[2];
			return '<' + name_6945 + ' at ' + index_6944 + '>'
		} break;
		
		case 5: {
			const type_6946 = temp[1];
			return DataHelper.nameOf(type_6946.parent)
		} break;
		
		case 12: {
			const args_6947 = temp[1];
			const returns_6948 = temp[2];
			return '(' + (() => {
				const result_6949 = [];
				const value_6950 = args_6947;
				for (const arg of $toIterator(value_6950)) result_6949.push(Type.stringify(arg.type));
				return result_6949;
			})().join(', ') + ') => ' + Type.stringify(returns_6948)
		} break;
		
		case 3: {
			const handle_6951 = temp[1];
			{
				{
					let step_6952 = 0;
					const value_6953 = handle_6951.value;
					if (step_6952 == 0 && value_6953 != null) { step_6952 = 1 };
					if (step_6952 == 1) { return Type.stringify(value_6953) + '?' };
				};
				return 'Unknown?';
			}
		} break;
		
		case 4: {
			const type_6954 = temp[1];
			return Type.stringify(type_6954) + '?'
		} break;
		
		case 8: {
			const type_6955 = temp[1];
			return DataHelper.nameOf(type_6955.parent)
		} break;
		
		case 9: {
			const type_6956 = temp[1];
			const tag_6957 = temp[2];
			{
				const tagName = type_6956.fieldNames[tag_6957];
				return DataHelper.nameOf(type_6956.parent) + '.' + tagName;
			}
		} break;
		
		case 2: {
			const handle_6958 = temp[1];
			{
				{
					let step_6959 = 0;
					const value_6960 = handle_6958.value;
					if (step_6959 == 0 && value_6960 != null) { step_6959 = 1 };
					if (step_6959 == 1) { return Type.stringify(value_6960) };
				};
				return 'Unknown';
			}
		} break;
		
		case 11: {
			const alias_6961 = temp[1];
			return NodeType.stringify(alias_6961.value)
		} break;
		
		case 0: {
			const value_6962 = temp[1];
			return value_6962
		} break;
		
		case 13: {
			const names_6963 = temp[1];
			const types_6964 = temp[2];
			return '{ ' + (() => {
				const result_6965 = [];
				const value_6966 = names_6963.length;
				for (const i of $toIterator(value_6966)) result_6965.push(names_6963[i] + Type.stringify(types_6964[i]));
				return result_6965;
			})().join(', ') + ' }'
		} break;
		
		case null: case undefined: {
			return 'could not infer type, try to set type manually'
		} break;
		
		default: 
		return '~?' + type_6940 + '?~'
		};
	} },
		primaryName: (type_6967) => { {
		const temp_6968 = type_6967;
		switch (temp_6968&&temp_6968[0]) {
		case 5: {
			const type_6969 = temp_6968[1];
			return type_6969.name
		} break;
		
		case 6: {
			const type_6970 = temp_6968[1];
			return type_6970.name
		} break;
		
		default: 
		return '~?' + type_6967 + '?~'
		};
	} },
		unwrapNullable: (t) => { {
		{
			const temp_6971 = t;
			switch (temp_6971&&temp_6971[0]) {
			case 3: {
				const handle_6972 = temp_6971[1];
				return handle_6972.value
			} break;
			
			case 4: {
				const t_6973 = temp_6971[1];
				return t_6973
			} break;
			};
		};
		return t;
	} },
	}
	var ParsedArguments = {
	}
	var process_3671 = $global.process
	var console_290 = $global.console
	var Map_284 = $global.Map
	var Map_277 = $global.Map
	var Map_270 = $global.Map
	var Map_263 = $global.Map
	var Map_256 = $global.Map
	var Map_249 = $global.Map
	var Map_242 = $global.Map
	var Map_235 = $global.Map
	var Map_228 = $global.Map
	var Map_221 = $global.Map
	var Map_214 = $global.Map
	var Map_207 = $global.Map
	var Map_200 = $global.Map
	var Map_193 = $global.Map
	var Map_186 = $global.Map
	var Map_179 = $global.Map
	var Map_172 = $global.Map
	var Map_165 = $global.Map
	var Map_158 = $global.Map
	var Map_151 = $global.Map
	var Map_144 = $global.Map
	var Map_137 = $global.Map
	var Map_130 = $global.Map
	var Map_123 = $global.Map
	var Map_116 = $global.Map
	var Map_109 = $global.Map
	var Map_102 = $global.Map
	var Map_95 = $global.Map
	var Map_88 = $global.Map
	var Map_81 = $global.Map
	var Map_74 = $global.Map
	var Map_67 = $global.Map
	var Decorator = class {
		constructor(name, values) { 
		{
		this.name = name;
		this.values = values;
	} };
	}
	Decorator.getDecorator = (decorators, name_3687) => {
		if (decorators != null && decorators.length > 0) { for (const att of $toIterator(decorators)) {
			if (att.name == name_3687) { return att };
		} };
		return null;
	};
	var Normalizer = class {
		constructor(project) { 
			this.niceProject = new NiceProject()
			this.keywords = []
			this.reservedGlobals = []
			this.collected = []
			this.nativeEnums = false
			this.globalAccessor = '<!--global-->'
			this.thisType = null
			this.inline = new Map()
			this.nonInlineRead = new Map()
			this.neverReassignedLocal = new Map()
			this.neverReassignedLocalParent = new Map()
			this.scopes = [new Map()]
			this.globals = []
			this.id = Math.round(Math.random() * 123)
			this.parentNames = new Map()
		this.project = project };
		normalize() {
		for (const global of $toIterator(this.reservedGlobals)) {
			this.addToScope(global);
		};
		for (const file of $toIterator(this.project.moduleInfo)) {
			for (const e of $toIterator(file.nodes)) {
				const temp = e;
				switch (temp&&temp[0]) {
				case 25: {
					const t = temp[1];
					const ext = temp[2];
					const impl = temp[3];
					const fields = temp[4];
					const external = temp[5];
					this.renameClassFields(fields, getRenamingStrategy(this.project.mapDecorators.get(e)))
				} break;
				
				case 39: {
					const t_3689 = temp[1];
					const fields_3690 = temp[2];
					const valuesType = temp[3];
					this.renameClassFields(fields_3690, getRenamingStrategy(this.project.mapDecorators.get(e)))
				} break;
				
				case 24: {
					const name = temp[1];
					const t_3691 = temp[2];
					const expr = temp[3];
					const const_3692 = temp[4];
					const external_3693 = temp[5];
					{
						const atts = this.project.mapDecorators.get(e);
						{
							let step = 0;
							const native = Decorator.getDecorator(atts, 'rename');
							if (step == 0 && native != null) { step = 1 };
							if (step == 1) {
								const temp_3694 = native.values[0];
								switch (temp_3694&&temp_3694[0]) {
								case 0: {
									const s = temp_3694[1];
									this.uniqueNative(s, e)
								} break;
								
								default: 
								throw '@rename takes string as argument'
								};
							} else {
								this.unique(name, e);
							};
						};
					}
				} break;
				
				case 22: {
					const name_3695 = temp[1];
					const expr_3696 = temp[2];
					const vars = temp[3];
					const rettype = temp[4];
					const external_3697 = temp[5];
					if (this.parentNames.get(e) == null) {
						let step_3698 = 0;
						const name_3699 = this.getNative(e);
						if (step_3698 == 0 && name_3699 != null) { step_3698 = 1 };
						if (step_3698 == 1) { this.uniqueNative(name_3699, e) } else {
							let step_3700 = 0;
							const name_3701 = name_3695;
							if (step_3700 == 0 && name_3701 != null) { step_3700 = 1 };
							if (step_3700 == 1) { this.unique(name_3701, e) };
						};
					}
				} break;
				};
			};
		};
		const init_3702 = [];
		for (const file of $toIterator(this.project.moduleInfo)) {
			const initial = [];
			this.pushScope();
			for (const e of $toIterator(file.nodes)) {
				const decorators = this.project.mapDecorators.get(e);
				{
					const temp_3703 = e;
					switch (temp_3703&&temp_3703[0]) {
					case 22: {
						const name_3704 = temp_3703[1];
						{
							let step_3705 = 0;
							const s_3706 = this.nodeToStatement(e);
							if (step_3705 == 0 && s_3706 != null) { step_3705 = 1 };
							if (step_3705 == 1) {
								const link = new NiceLink();
								{
									let step_3707 = 0;
									const dec = Decorator.getDecorator(decorators, 'linkName');
									if (step_3707 == 0 && dec != null) { step_3707 = 1 };
									if (step_3707 == 1) {
										const temp_3708 = dec.values[0];
										switch (temp_3708&&temp_3708[0]) {
										case 0: {
											const s_3709 = temp_3708[1];
											link.linkName = s_3709
										} break;
										};
									};
								};
								{
									let step_3710 = 0;
									const dec_3711 = Decorator.getDecorator(decorators, 'rename');
									if (step_3710 == 0 && dec_3711 != null) { step_3710 = 1 };
									if (step_3710 == 1) {
										const temp_3712 = dec_3711.values[0];
										switch (temp_3712&&temp_3712[0]) {
										case 0: {
											const s_3713 = temp_3712[1];
											link.rename = s_3713
										} break;
										};
									};
								};
								{
									let step_3714 = 0;
									const dec_3715 = Decorator.getDecorator(decorators, 'linkAsIs');
									if (step_3714 == 0 && dec_3715 != null) { step_3714 = 1 };
									if (step_3714 == 1) { link.linkName = name_3704 };
								};
								{
									let step_3716 = 0;
									const dec_3717 = Decorator.getDecorator(decorators, 'customHeader');
									if (step_3716 == 0 && dec_3717 != null) { step_3716 = 1 };
									if (step_3716 == 1) {
										const temp_3718 = dec_3717.values[0];
										switch (temp_3718&&temp_3718[0]) {
										case 0: {
											const s_3719 = temp_3718[1];
											link.customHeader = s_3719
										} break;
										};
									};
								};
								{
									let step_3720 = 0;
									const dec_3721 = Decorator.getDecorator(decorators, 'convention');
									if (step_3720 == 0 && dec_3721 != null) { step_3720 = 1 };
									if (step_3720 == 1) {
										const temp_3722 = dec_3721.values[0];
										switch (temp_3722&&temp_3722[0]) {
										case 0: {
											const s_3723 = temp_3722[1];
											{
												const temp_3724 = s_3723;
												switch (temp_3724) {
												case 'fastcall': {
													link.convention = 1
												} break;
												};
											}
										} break;
										};
									};
								};
								{
									let step_3725 = 0;
									const dec_3726 = Decorator.getDecorator(decorators, 'dllExport');
									if (step_3725 == 0 && dec_3726 != null) { step_3725 = 1 };
									if (step_3725 == 1) {
										{
											const temp_3727 = dec_3726.values[0];
											switch (temp_3727&&temp_3727[0]) {
											case 0: {
												const s_3728 = temp_3727[1];
												link.linkName = s_3728
											} break;
											};
										};
										link.dllExport = true;
									};
								};
								{
									let step_3729 = 0;
									const dec_3730 = Decorator.getDecorator(decorators, 'dllImport');
									if (step_3729 == 0 && dec_3730 != null) { step_3729 = 1 };
									if (step_3729 == 1) {
										{
											const temp_3731 = dec_3730.values[0];
											switch (temp_3731&&temp_3731[0]) {
											case 0: {
												const s_3732 = temp_3731[1];
												link.linkName = s_3732
											} break;
											};
										};
										link.dllImport = true;
									};
								};
								{
									let step_3733 = 0;
									const dec_3734 = Decorator.getDecorator(decorators, 'emitHeader');
									if (step_3733 == 0 && dec_3734 != null) { step_3733 = 1 };
									if (step_3733 == 1) { link.emitHeader = true };
								};
								this.niceProject.globalLink.set(s_3706, link);
								this.niceProject.globalFuncs.push(s_3706);
							};
						}
					} break;
					
					case 24: {
						{
							let step_3735 = 0;
							const s_3736 = this.nodeToStatement(e);
							if (step_3735 == 0 && s_3736 != null) { step_3735 = 1 };
							if (step_3735 == 1) { this.niceProject.globalVars.push(s_3736) };
						}
					} break;
					
					case 39: {
						this.fillStatement(e)
					} break;
					
					case 25: {
						this.fillStatement(e)
					} break;
					
					default: 
					{
						const statement = this.fillStatement(e);
						{
							const temp_3737 = statement;
							switch (temp_3737&&temp_3737[0]) {
							case null: case undefined: {
								{
								}
							} break;
							
							case 1: {
								const el = temp_3737[1];
								if (el.length > 0) { initial.push(statement) }
							} break;
							
							default: 
							initial.push(statement)
							};
						};
					}
					};
				};
			};
			this.popScope();
			if (initial.length > 0) { init_3702.push(/*Block*/[1,initial,".Block"]) };
		};
		this.niceProject.init.push(/*Block*/[1,init_3702,".Block"]);
		if (this.niceProject.init.length > 1) { throw 'too many inits' };
		this.niceProject.package = this.package;
		this.niceProject.typer = this.typer;
		if (this.project.defines.bit64 == true) { this.niceProject.memory = 64 } else {
			this.niceProject.memory = 32;
		};
		this.niceProject.mapDecorators = this.project.mapDecorators;
		this.niceProject.classes.sort((a, b) => {
			if (a.external == true) { return (-1) };
			if (a.extend == null) { return 0 };
			return 1;
		});
		this.niceProject.classes.sort((a_3738, b_3739) => {
			if (a_3738.usedByValueDepth > b_3739.usedByValueDepth) { return (-1) };
			if (a_3738.usedByValueDepth == b_3739.usedByValueDepth) { return 0 };
			return 1;
		});
		return this.niceProject;
	};
		nodeToExpression(e) {
		const result = this.nodeToExpressionWithoutPosition(e);
		if (result != null) {
			this.niceProject.expressionPosition.set(result, this.project.data.get(e));
			if (this.niceProject.expressionType.get(result) == null) { this.niceProject.expressionType.set(result, this.typer.types.get(e)) };
		};
		return result;
	};
		nodeToExpressionWithoutPosition(e_3740) {
		if (e_3740 == null) { return null };
		{
			const temp_3741 = e_3740;
			switch (temp_3741&&temp_3741[0]) {
			case 0: {
				const v = temp_3741[1];
				{
					if (Decorator.getDecorator(this.project.mapDecorators.get(e_3740), 'acpiHeaderSignature') != null) {
						const byteswap = (x) => { return ((x >> 24n) & 255n) | ((x >> 8n) & 65280n) | ((x << 8n) & 16711680n) | ((x << 24n) & 4278190080n) };
						const v_3742 = v.split('');
						v_3742.reverse();
						const v_3743 = v_3742.join('');
						const num32 = BigInt((v_3743.charCodeAt(0))) + BigInt((v_3743.charCodeAt(1))) * 256n + BigInt((v_3743.charCodeAt(2))) * 256n * 256n + BigInt((v_3743.charCodeAt(3))) * 256n * 256n * 256n;
						const result_3744 = '0x' + byteswap(num32).toString(16);
						console.log(v_3743 + ' == ' + num32);
						return /*MetaInt*/[2,BigInt(result_3744),6,this.typer.typeUInt32,".MetaInt"];
					};
					return /*String*/[0,v,".String"];
				}
			} break;
			
			case 5: {
				const v_3745 = temp_3741[1];
				return /*Int*/[1,v_3745,".Int"]
			} break;
			
			case 6: {
				const v_3746 = temp_3741[1];
				const meta = temp_3741[2];
				return /*MetaInt*/[2,v_3746,meta,this.typer.types.get(e_3740),".MetaInt"]
			} break;
			
			case 7: {
				const v_3747 = temp_3741[1];
				return /*Float*/[3,v_3747,".Float"]
			} break;
			
			case 2: {
				const v_3748 = temp_3741[1];
				{
					if (v_3748) { return /*True*/[4,".True"] };
					return /*False*/[5,".False"];
				}
			} break;
			
			case 8: {
				return /*Null*/[7,this.typer.types.get(e_3740),".Null"]
			} break;
			
			case 51: {
				const t_3749 = temp_3741[1];
				{
					const temp_3750 = t_3749;
					switch (temp_3750&&temp_3750[0]) {
					case 1: {
						const name_3751 = temp_3750[1];
						return /*Ident*/[6,(() => {
							const result_3752 = this.parentNames.get(this.typer.parents.get(e_3740));
							if (result_3752 != null) { return result_3752 };
							return name_3751;
						})(),null,".Ident"]
					} break;
					};
				}
			} break;
			
			case 1: {
				const name_3753 = temp_3741[1];
				{
					const source = this.typer.parents.get(e_3740);
					{
						let step_3754 = 0;
						const value = this.inline.get(source);
						if (step_3754 == 0 && value != null) { step_3754 = 1 };
						if (step_3754 == 1) { return value };
					};
					this.nonInlineRead.set(source, true);
					{
						const temp_3755 = source;
						switch (temp_3755&&temp_3755[0]) {
						case null: case undefined: {
							throw ('Unmapped `' + (e_3740) + '` of name `' + (name_3753) + '` ') + JSON.stringify(this.project.data.get(e_3740))
						} break;
						
						case 24: {
							const name_3756 = temp_3755[1];
							{
								const staticSource = this.typer.parents.get(source);
								{
									let step_3757 = 0;
									const map = this.typer.parents.get(source);
									if (step_3757 == 0 && map != null) { step_3757 = 1 };
									if (step_3757 == 1) {
										const temp_3758 = (map);
										switch (temp_3758&&temp_3758[0]) {
										case 35: {
											{
												const name_3759 = (() => {
													const result_3760 = this.parentNames.get(source);
													if (result_3760 != null) { return result_3760 };
													return name_3756;
												})();
												const result_3761 = /*Ident*/[6,this.globalAccessor + name_3759,this.typer.types.get(source),".Ident"];
												{
													let step_3762 = 0;
													const name_3763 = this.getNative(source);
													if (step_3762 == 0 && name_3763 != null) { step_3762 = 1 };
													if (step_3762 == 1) { this.niceProject.native.set(result_3761, true) };
												};
												return result_3761;
											}
										} break;
										
										default: 
										{
											const type = this.typer.types.get(this.typer.parents.get(source));
											return /*Dot*/[9,/*This*/[8,this.thisType,".This"],this.getClassDotField(staticSource, name_3756),this.typer.types.get(e_3740),".Dot"];
										}
										};
									};
								};
							}
						} break;
						
						case 22: {
							const name_3764 = temp_3755[1];
							{
								let step_3765 = 0;
								const map_3766 = this.typer.parents.get(source);
								if (step_3765 == 0 && map_3766 != null) { step_3765 = 1 };
								if (step_3765 == 1) {
									const temp_3767 = (map_3766);
									switch (temp_3767&&temp_3767[0]) {
									case 35: {
										{
											const result_3768 = /*Ident*/[6,this.globalAccessor + ((() => {
												const result_3769 = this.parentNames.get(source);
												if (result_3769 != null) { return result_3769 };
												return name_3764;
											})()),null,".Ident"];
											{
												let step_3770 = 0;
												const name_3771 = this.getNative(source);
												if (step_3770 == 0 && name_3771 != null) { step_3770 = 1 };
												if (step_3770 == 1) { this.niceProject.native.set(result_3768, true) };
											};
											return result_3768;
										}
									} break;
									
									default: 
									{
										const type_3772 = this.typer.types.get(this.typer.parents.get(source));
										return /*Dot*/[9,/*This*/[8,this.thisType,".This"],(() => {
											const result_3773 = this.parentNames.get(source);
											if (result_3773 != null) { return result_3773 };
											return name_3764;
										})(),this.typer.types.get(e_3740),".Dot"];
									}
									};
								};
							}
						} break;
						
						case 47: {
							const f = temp_3755[1];
							{
								const staticSource_3774 = this.typer.parents.get(source);
								{
									const temp_3775 = staticSource_3774;
									switch (temp_3775&&temp_3775[0]) {
									case 25: {
										const t_3776 = temp_3775[1];
										return /*Dot*/[9,/*Ident*/[6,DataHelper.extractTypeName(t_3776),null,".Ident"],this.getClassDotField(staticSource_3774, name_3753),this.typer.types.get(e_3740),".Dot"]
									} break;
									
									case 39: {
										const t_3777 = temp_3775[1];
										return /*Dot*/[9,/*Ident*/[6,DataHelper.extractTypeName(t_3777),null,".Ident"],this.getClassDotField(staticSource_3774, name_3753),this.typer.types.get(e_3740),".Dot"]
									} break;
									
									default: 
									throw ('staticSource is ' + (staticSource_3774) + ' for ' + (name_3753) + '')
									};
								};
							}
						} break;
						};
					};
					const result_3778 = /*Ident*/[6,(() => {
						const result_3779 = this.parentNames.get(source);
						if (result_3779 != null) { return result_3779 };
						return name_3753;
					})(),this.typer.types.get(e_3740),".Ident"];
					{
						let step_3780 = 0;
						const name_3781 = this.getNative(source);
						if (step_3780 == 0 && name_3781 != null) { step_3780 = 1 };
						if (step_3780 == 1) { this.niceProject.native.set(result_3778, true) };
					};
					return result_3778;
				}
			} break;
			
			case 28: {
				const expr_3782 = temp_3741[1];
				const name_3783 = temp_3741[2];
				{
					const parent = this.typer.parents.get(expr_3782);
					{
						const temp_3784 = parent;
						switch (temp_3784&&temp_3784[0]) {
						case 39: {
							const t_3785 = temp_3784[1];
							const fields_3786 = temp_3784[2];
							const valuesType_3787 = temp_3784[3];
							{
								{
									let step_3788 = 0;
									const temp_3789 = (!this.nativeEnums);
									let vt = null;
									if (step_3788 == 0 && temp_3789 != false) {
										vt = valuesType_3787;
										step_3788 = 1;
									};
									let tag = null;
									if (step_3788 == 1 && vt != null) {
										tag = this.getTag(parent, name_3783);
										step_3788 = 2;
									};
									if (step_3788 == 2 && tag != null) { step_3788 = 3 };
									if (step_3788 == 3) { return tag };
								};
								return /*Dot*/[9,this.nodeToExpression(expr_3782),(() => {
									const result_3790 = this.getClassDotField(parent, name_3783);
									if (result_3790 != null) { return result_3790 };
									return name_3783;
								})(),this.typer.types.get(e_3740),".Dot"];
							}
						} break;
						
						case 25: {
							return /*Dot*/[9,this.nodeToExpression(expr_3782),(() => {
								const result_3791 = this.getClassDotField(parent, name_3783);
								if (result_3791 != null) { return result_3791 };
								return name_3783;
							})(),this.typer.types.get(e_3740),".Dot"]
						} break;
						};
					};
					{
						let step_3792 = 0;
						const type_3793 = this.typer.types.get(expr_3782);
						if (step_3792 == 0 && type_3793 != null) { step_3792 = 1 };
						if (step_3792 == 1) {
							const temp_3794 = (type_3793);
							switch (temp_3794&&temp_3794[0]) {
							case 6: {
								const type_3795 = temp_3794[1];
								{
									const renamed = type_3795.fieldRenames[type_3795.fieldNames.indexOf(name_3783, 0)];
									{
										let step_3796 = 0;
										const rename = renamed;
										if (step_3796 == 0 && rename != null) { step_3796 = 1 };
										if (step_3796 == 1) { return /*Dot*/[9,this.nodeToExpression(expr_3782),rename,this.typer.types.get(e_3740),".Dot"] };
									};
								}
							} break;
							};
						};
					};
					const value_3797 = this.nodeToExpression(expr_3782);
					if (name_3783 == 'length') {
						const temp_3798 = value_3797;
						switch (temp_3798&&temp_3798[0]) {
						case 0: {
							const s_3799 = temp_3798[1];
							return /*Int*/[1,s_3799.length,".Int"]
						} break;
						};
					};
					return /*Dot*/[9,value_3797,name_3783,this.typer.types.get(e_3740),".Dot"];
				}
			} break;
			
			case 29: {
				const expr_3800 = temp_3741[1];
				const name_3801 = temp_3741[2];
				{
					const parent_3802 = this.typer.parents.get(expr_3800);
					{
						const temp_3803 = parent_3802;
						switch (temp_3803&&temp_3803[0]) {
						case 39: {
							const t_3804 = temp_3803[1];
							const fields_3805 = temp_3803[2];
							const valuesType_3806 = temp_3803[3];
							{
								{
									let step_3807 = 0;
									const temp_3808 = (!this.nativeEnums);
									let vt_3809 = null;
									if (step_3807 == 0 && temp_3808 != false) {
										vt_3809 = valuesType_3806;
										step_3807 = 1;
									};
									let tag_3810 = null;
									if (step_3807 == 1 && vt_3809 != null) {
										tag_3810 = this.getTag(parent_3802, name_3801);
										step_3807 = 2;
									};
									if (step_3807 == 2 && tag_3810 != null) { step_3807 = 3 };
									if (step_3807 == 3) { return tag_3810 };
								};
								{
									let step_3811 = 0;
									const temp_3812 = (!this.nativeEnums);
									let temp_3813 = null;
									if (step_3811 == 0 && temp_3812 != false) {
										temp_3813 = valuesType_3806 == null;
										step_3811 = 1;
									};
									let tag_3814 = null;
									if (step_3811 == 1 && temp_3813 != false) {
										tag_3814 = this.getTag(parent_3802, name_3801);
										step_3811 = 2;
									};
									if (step_3811 == 2 && tag_3814 != null) { step_3811 = 3 };
									if (step_3811 == 3) { return /*Enum*/[28,DataHelper.extractTypeName(t_3804),name_3801,tag_3814,[],".Enum"] };
								};
								return /*Dot*/[9,this.nodeToExpression(expr_3800),(() => {
									const result_3815 = this.getClassDotField(parent_3802, name_3801);
									if (result_3815 != null) { return result_3815 };
									return name_3801;
								})(),this.typer.types.get(e_3740),".Dot"];
							}
						} break;
						
						case 25: {
							return /*Dot*/[9,this.nodeToExpression(expr_3800),(() => {
								const result_3816 = this.getClassDotField(parent_3802, name_3801);
								if (result_3816 != null) { return result_3816 };
								return name_3801;
							})(),this.typer.types.get(e_3740),".Dot"]
						} break;
						};
					};
					return /*Dot*/[9,this.nodeToExpression(expr_3800),name_3801,this.typer.types.get(e_3740),".Dot"];
				}
			} break;
			
			case 13: {
				const expr_3817 = temp_3741[1];
				const args = temp_3741[2];
				const argNames = temp_3741[3];
				{
					if (args.length == 1) {
						const temp_3818 = expr_3817;
						switch (temp_3818&&temp_3818[0]) {
						case 28: {
							const expr_3819 = temp_3818[1];
							const name_3820 = temp_3818[2];
							if (name_3820 == 'charCodeAt') {
								const temp_3821 = expr_3819;
								switch (temp_3821&&temp_3821[0]) {
								case 0: {
									const s_3822 = temp_3821[1];
									if (s_3822.indexOf('\\', 0) == (-1)) {
										const temp_3823 = args[0];
										switch (temp_3823&&temp_3823[0]) {
										case 5: {
											const v_3824 = temp_3823[1];
											{
												const i = v_3824;
												if ((i < s_3822.length) && (i > (-1))) {
													const value_3825 = s_3822.charCodeAt(i);
													const result_3826 = (((!Number.isNaN(value_3825)))? (/*Int*/[1,value_3825,".Int"]) : /*Int*/[1,0,".Int"]);
													this.niceProject.expressionType.set(result_3826, this.typer.typeInt);
													return result_3826;
												};
											}
										} break;
										};
									}
								} break;
								};
							}
						} break;
						};
					};
					let kind = 11;
					{
						const temp_3827 = expr_3817;
						switch (temp_3827&&temp_3827[0]) {
						case 28: {
							const expr_3828 = temp_3827[1];
							const name_3829 = temp_3827[2];
							{
								const temp_3830 = (this.typer.types.get(expr_3828));
								switch (temp_3830&&temp_3830[0]) {
								case 6: {
									const c = temp_3830[1];
									if (c.fields.get(name_3829) == 0) { kind = 12 }
								} break;
								
								case 5: {
									kind = 10
								} break;
								};
							}
						} break;
						};
					};
					const a_3831 = [];
					for (const arg of $toIterator(args)) {
						a_3831.push(this.nodeToExpression(arg));
					};
					{
						const temp_3832 = (this.typer.parents.get(expr_3817));
						switch (temp_3832&&temp_3832[0]) {
						case 22: {
							const vars_3833 = temp_3832[3];
							if (vars_3833.length > a_3831.length) {
								let i_3834 = 0;
								let it = 0;
								let at = vars_3833.length;
								while (it < at) {
									i_3834 = it;
									it++;
									{
										if (i_3834 < a_3831.length) { continue };
										{
											const temp_3835 = (vars_3833[i_3834]);
											switch (temp_3835&&temp_3835[0]) {
											case 24: {
												const value_3836 = temp_3835[3];
												{
													let step_3837 = 0;
													const value_3838 = value_3836;
													if (step_3837 == 0 && value_3838 != null) { step_3837 = 1 };
													if (step_3837 == 1) { a_3831.push(this.nodeToExpression(value_3838)) };
												}
											} break;
											};
										};
									};
								};
							}
						} break;
						};
					};
					if ((!this.nativeEnums)) {
						const temp_3839 = expr_3817;
						switch (temp_3839&&temp_3839[0]) {
						case 29: {
							const expr_3840 = temp_3839[1];
							const name_3841 = temp_3839[2];
							{
								const parent_3842 = this.typer.parents.get(expr_3840);
								{
									const temp_3843 = parent_3842;
									switch (temp_3843&&temp_3843[0]) {
									case 39: {
										const t_3844 = temp_3843[1];
										const fields_3845 = temp_3843[2];
										const valuesType_3846 = temp_3843[3];
										{
											let step_3847 = 0;
											const tag_3848 = this.getTag(parent_3842, name_3841);
											if (step_3847 == 0 && tag_3848 != null) { step_3847 = 1 };
											if (step_3847 == 1) { return /*Enum*/[28,DataHelper.extractTypeName(t_3844),name_3841,tag_3848,a_3831,".Enum"] };
										}
									} break;
									};
								};
							}
						} break;
						};
					};
					const atts_3849 = this.project.mapDecorators.get(this.typer.parents.get(expr_3817));
					{
						let step_3850 = 0;
						const infix = Decorator.getDecorator(atts_3849, 'infix');
						if (step_3850 == 0 && infix != null) { step_3850 = 1 };
						if (step_3850 == 1) {
							const temp_3851 = infix.values[0];
							switch (temp_3851&&temp_3851[0]) {
							case 0: {
								const s_3852 = temp_3851[1];
								{
									const temp_3853 = expr_3817;
									switch (temp_3853&&temp_3853[0]) {
									case 1: {
										const params = temp_3853[2];
										{
											{
												let step_3854 = 0;
												const parames = params;
												if (step_3854 == 0 && parames != null) { step_3854 = 1 };
												if (step_3854 == 1) { return /*NativeOperator*/[26,0,a_3831,s_3852,params.map((param) => (this.typer.types.get(param))),this.typer.types.get(e_3740),".NativeOperator"] };
											};
											return /*NativeOperator*/[26,0,a_3831,s_3852,null,this.typer.types.get(e_3740),".NativeOperator"];
										}
									} break;
									};
								}
							} break;
							
							default: 
							throw '@infix takes string as argument'
							};
						};
					};
					{
						let step_3855 = 0;
						const operator = Decorator.getDecorator(atts_3849, 'operator');
						if (step_3855 == 0 && operator != null) { step_3855 = 1 };
						if (step_3855 == 1) {
							const temp_3856 = operator.values[0];
							switch (temp_3856&&temp_3856[0]) {
							case 0: {
								const s_3857 = temp_3856[1];
								{
									const temp_3858 = expr_3817;
									switch (temp_3858&&temp_3858[0]) {
									case 1: {
										const params_3859 = temp_3858[2];
										{
											{
												let step_3860 = 0;
												const parames_3861 = params_3859;
												if (step_3860 == 0 && parames_3861 != null) { step_3860 = 1 };
												if (step_3860 == 1) { return /*NativeOperator*/[26,1,a_3831,s_3857,params_3859.map((param_3862) => (this.typer.types.get(param_3862))),this.typer.types.get(e_3740),".NativeOperator"] };
											};
											return /*NativeOperator*/[26,1,a_3831,s_3857,null,this.typer.types.get(e_3740),".NativeOperator"];
										}
									} break;
									};
								}
							} break;
							
							default: 
							throw '@operator takes string as argument'
							};
						};
					};
					const v_3863 = this.nodeToExpression(expr_3817);
					{
						const temp_3864 = v_3863;
						switch (temp_3864&&temp_3864[0]) {
						case 9: {
							const expr_3865 = temp_3864[1];
							{
								const temp_3866 = expr_3865;
								switch (temp_3866&&temp_3866[0]) {
								case 8: {
									kind = 12
								} break;
								};
							}
						} break;
						};
					};
					return /*Call*/[10,v_3863,a_3831,this.typer.types.get(e_3740),kind,".Call"];
				}
			} break;
			
			case 10: {
				const a_3867 = temp_3741[1];
				const op = temp_3741[2];
				const b_3868 = temp_3741[3];
				{
					const ea = this.nodeToExpression(a_3867);
					const eb = this.nodeToExpression(b_3868);
					if (op == 111) {
						const temp_3869 = ea;
						switch (temp_3869&&temp_3869[0]) {
						case 0: {
							const sa = temp_3869[1];
							{
								const temp_3870 = eb;
								switch (temp_3870&&temp_3870[0]) {
								case 0: {
									const sb = temp_3870[1];
									return /*String*/[0,sa + sb,".String"]
								} break;
								
								case 1: {
									const sb_3871 = temp_3870[1];
									return /*String*/[0,sa + sb_3871,".String"]
								} break;
								
								case 3: {
									const sb_3872 = temp_3870[1];
									return /*String*/[0,sa + sb_3872,".String"]
								} break;
								
								case 4: {
									return /*String*/[0,sa + 'true',".String"]
								} break;
								
								case 5: {
									return /*String*/[0,sa + 'false',".String"]
								} break;
								};
							}
						} break;
						
						case 1: {
							const sa_3873 = temp_3869[1];
							{
								const temp_3874 = eb;
								switch (temp_3874&&temp_3874[0]) {
								case 1: {
									const sb_3875 = temp_3874[1];
									return /*Int*/[1,sa_3873 + sb_3875,".Int"]
								} break;
								
								case 3: {
									const sb_3876 = temp_3874[1];
									return /*Float*/[3,sa_3873 + sb_3876,".Float"]
								} break;
								
								case 0: {
									const sb_3877 = temp_3874[1];
									return /*String*/[0,sa_3873 + sb_3877,".String"]
								} break;
								};
							}
						} break;
						
						case 3: {
							const sa_3878 = temp_3869[1];
							{
								const temp_3879 = eb;
								switch (temp_3879&&temp_3879[0]) {
								case 1: {
									const sb_3880 = temp_3879[1];
									return /*Float*/[3,sa_3878 + sb_3880,".Float"]
								} break;
								
								case 3: {
									const sb_3881 = temp_3879[1];
									return /*Float*/[3,sa_3878 + sb_3881,".Float"]
								} break;
								
								case 0: {
									const sb_3882 = temp_3879[1];
									return /*String*/[0,sa_3878 + sb_3882,".String"]
								} break;
								};
							}
						} break;
						};
					};
					if (op == 93) {
						const temp_3883 = ea;
						switch (temp_3883&&temp_3883[0]) {
						case 4: {
							{
								const temp_3884 = eb;
								switch (temp_3884&&temp_3884[0]) {
								case 5: {
									return /*True*/[4,".True"]
								} break;
								
								case 4: {
									return /*True*/[4,".True"]
								} break;
								};
							}
						} break;
						
						case 5: {
							{
								const temp_3885 = eb;
								switch (temp_3885&&temp_3885[0]) {
								case 5: {
									return /*False*/[5,".False"]
								} break;
								
								case 4: {
									return /*True*/[4,".True"]
								} break;
								};
							}
						} break;
						};
					};
					if (op == 92) {
						const temp_3886 = ea;
						switch (temp_3886&&temp_3886[0]) {
						case 4: {
							{
								const temp_3887 = eb;
								switch (temp_3887&&temp_3887[0]) {
								case 5: {
									return /*False*/[5,".False"]
								} break;
								
								case 4: {
									return /*True*/[4,".True"]
								} break;
								};
							}
						} break;
						
						case 5: {
							{
								const temp_3888 = eb;
								switch (temp_3888&&temp_3888[0]) {
								case 5: {
									return /*False*/[5,".False"]
								} break;
								
								case 4: {
									return /*False*/[5,".False"]
								} break;
								};
							}
						} break;
						};
					};
					if (op == 95) {
						const temp_3889 = ea;
						switch (temp_3889&&temp_3889[0]) {
						case 4: {
							{
								const temp_3890 = eb;
								switch (temp_3890&&temp_3890[0]) {
								case 5: {
									return /*False*/[5,".False"]
								} break;
								
								case 4: {
									return /*True*/[4,".True"]
								} break;
								};
							}
						} break;
						
						case 5: {
							{
								const temp_3891 = eb;
								switch (temp_3891&&temp_3891[0]) {
								case 5: {
									return /*True*/[4,".True"]
								} break;
								
								case 4: {
									return /*False*/[5,".False"]
								} break;
								};
							}
						} break;
						
						case 0: {
							const sa_3892 = temp_3889[1];
							{
								const temp_3893 = eb;
								switch (temp_3893&&temp_3893[0]) {
								case 0: {
									const sb_3894 = temp_3893[1];
									{
										if (sa_3892 == sb_3894) { return /*True*/[4,".True"] };
										return /*False*/[5,".False"];
									}
								} break;
								};
							}
						} break;
						
						case 1: {
							const sa_3895 = temp_3889[1];
							{
								const temp_3896 = eb;
								switch (temp_3896&&temp_3896[0]) {
								case 1: {
									const sb_3897 = temp_3896[1];
									{
										if (sa_3895 == sb_3897) { return /*True*/[4,".True"] };
										return /*False*/[5,".False"];
									}
								} break;
								};
							}
						} break;
						
						case 7: {
							{
								const temp_3898 = eb;
								switch (temp_3898&&temp_3898[0]) {
								case 4: {
									return /*False*/[5,".False"]
								} break;
								
								case 5: {
									return /*False*/[5,".False"]
								} break;
								
								case 0: {
									return /*False*/[5,".False"]
								} break;
								
								case 1: {
									return /*False*/[5,".False"]
								} break;
								
								case 6: {
									const type_3899 = temp_3898[2];
									{
										const temp_3900 = type_3899;
										switch (temp_3900&&temp_3900[0]) {
										case 4: {
											{
											}
										} break;
										
										case 3: {
											{
											}
										} break;
										
										case 2: {
											{
											}
										} break;
										
										default: 
										return /*False*/[5,".False"]
										};
									}
								} break;
								};
							}
						} break;
						};
					};
					if (op == 103) {
						const temp_3901 = ea;
						switch (temp_3901&&temp_3901[0]) {
						case 4: {
							{
								const temp_3902 = eb;
								switch (temp_3902&&temp_3902[0]) {
								case 5: {
									return /*True*/[4,".True"]
								} break;
								
								case 4: {
									return /*False*/[5,".False"]
								} break;
								};
							}
						} break;
						
						case 5: {
							{
								const temp_3903 = eb;
								switch (temp_3903&&temp_3903[0]) {
								case 5: {
									return /*False*/[5,".False"]
								} break;
								
								case 4: {
									return /*True*/[4,".True"]
								} break;
								};
							}
						} break;
						
						case 0: {
							const sa_3904 = temp_3901[1];
							{
								const temp_3905 = eb;
								switch (temp_3905&&temp_3905[0]) {
								case 0: {
									const sb_3906 = temp_3905[1];
									{
										if (sa_3904 != sb_3906) { return /*True*/[4,".True"] };
										return /*False*/[5,".False"];
									}
								} break;
								};
							}
						} break;
						
						case 1: {
							const sa_3907 = temp_3901[1];
							{
								const temp_3908 = eb;
								switch (temp_3908&&temp_3908[0]) {
								case 1: {
									const sb_3909 = temp_3908[1];
									{
										if (sa_3907 != sb_3909) { return /*True*/[4,".True"] };
										return /*False*/[5,".False"];
									}
								} break;
								};
							}
						} break;
						};
					};
					return /*Binop*/[12,ea,op,eb,this.typer.types.get(e_3740),".Binop"];
				}
			} break;
			
			case 30: {
				const path = temp_3741[1];
				const t_3910 = temp_3741[2];
				const args_3911 = temp_3741[3];
				const fields_3912 = temp_3741[4];
				const el_3913 = temp_3741[5];
				{
					const v_3914 = /*Ident*/[6,(() => {
						const result_3915 = this.parentNames.get(this.typer.parents.get(e_3740));
						if (result_3915 != null) { return result_3915 };
						return DataHelper.extractTypeName(t_3910);
					})(),null,".Ident"];
					const a_3916 = [];
					for (const arg of $toIterator(args_3911)) {
						a_3916.push(this.nodeToExpression(arg));
					};
					return /*New*/[11,v_3914,a_3916,this.typer.types.get(e_3740),".New"];
				}
			} break;
			
			case 22: {
				const name_3917 = temp_3741[1];
				const expr_3918 = temp_3741[2];
				const vars_3919 = temp_3741[3];
				const rettype_3920 = temp_3741[4];
				const external_3921 = temp_3741[5];
				{
					const a_3922 = [];
					const defaults = [];
					const types = [];
					for (const arg of $toIterator(vars_3919)) {
						const temp_3923 = arg;
						switch (temp_3923&&temp_3923[0]) {
						case 24: {
							const name_3924 = temp_3923[1];
							const t_3925 = temp_3923[2];
							const expr_3926 = temp_3923[3];
							const const_3927 = temp_3923[4];
							{
								a_3922.push(this.unique(name_3924, arg));
								types.push(t_3925);
								if (expr_3926 != null) { defaults.push(this.nodeToExpression(expr_3926)) } else {
									defaults.push(null);
								};
							}
						} break;
						};
					};
					return /*Function*/[13,((name_3917 != null)? (this.unique(name_3917, e_3740)) : (null)),this.nodeToStatement(expr_3918),a_3922,defaults,this.typer.types.get(e_3740),".Function"];
				}
			} break;
			
			case 23: {
				const expr_3928 = temp_3741[1];
				const vars_3929 = temp_3741[2];
				const rettype_3930 = temp_3741[3];
				{
					const a_3931 = [];
					const defaults_3932 = [];
					const types_3933 = [];
					for (const arg of $toIterator(vars_3929)) {
						const temp_3934 = arg;
						switch (temp_3934&&temp_3934[0]) {
						case 24: {
							const name_3935 = temp_3934[1];
							const t_3936 = temp_3934[2];
							const expr_3937 = temp_3934[3];
							const const_3938 = temp_3934[4];
							{
								a_3931.push(this.unique(name_3935, arg));
								types_3933.push(t_3936);
								if (expr_3937 != null) { defaults_3932.push(this.nodeToExpression(expr_3937)) } else {
									defaults_3932.push(null);
								};
							}
						} break;
						};
					};
					return /*Arrow*/[14,this.nodeToExpression(expr_3928),a_3931,defaults_3932,types_3933,rettype_3930,this.typer.types.get(e_3740),".Arrow"];
				}
			} break;
			
			case 12: {
				const el_3939 = temp_3741[1];
				{
					if (el_3939.length == 0) { return /*Object*/[16,[],[],[],".Object"] };
					if (el_3939.length == 1) { return this.nodeToExpression(el_3939[0]) };
					const block = [];
					let i_3940 = 0;
					while (i_3940 < el_3939.length - 1) {
						{
							let step_3941 = 0;
							const s_3942 = this.nodeToStatement(el_3939[i_3940]);
							if (step_3941 == 0 && s_3942 != null) { step_3941 = 1 };
							if (step_3941 == 1) { block.push(s_3942) };
						};
						i_3940++;
					};
					const result_3943 = el_3939[el_3939.length - 1];
					block.push(/*Return*/[6,this.nodeToExpression(result_3943),".Return"]);
					return /*Call*/[10,/*Parenthesis*/[15,/*Function*/[13,null,/*Block*/[1,block,".Block"],[],[],null,".Function"],".Parenthesis"],[],this.typer.types.get(result_3943),11,".Call"];
				}
			} break;
			
			case 38: {
				const names = temp_3741[1];
				const el_3944 = temp_3741[2];
				{
					const els = [];
					const types_3945 = [];
					for (const e of $toIterator(el_3944)) {
						els.push(this.nodeToExpression(e));
						types_3945.push(this.typer.types.get(e));
					};
					return /*Object*/[16,names,els,types_3945,".Object"];
				}
			} break;
			
			case 15: {
				const inner = temp_3741[1];
				{
					const value_3946 = this.nodeToExpression(this.unwrapParens(inner));
					{
						const temp_3947 = value_3946;
						switch (temp_3947&&temp_3947[0]) {
						case 1: {
							return value_3946
						} break;
						
						case 0: {
							return value_3946
						} break;
						
						case 3: {
							return value_3946
						} break;
						
						case 4: {
							return value_3946
						} break;
						
						case 5: {
							return value_3946
						} break;
						
						case 7: {
							return value_3946
						} break;
						};
					};
					return /*Parenthesis*/[15,value_3946,".Parenthesis"];
				}
			} break;
			
			case 31: {
				const el_3948 = temp_3741[1];
				{
					if (el_3948.length == 1) {
						const temp_3949 = el_3948[0];
						switch (temp_3949&&temp_3949[0]) {
						case 49: {
							const name_3950 = temp_3949[1];
							const over = temp_3949[2];
							const by = temp_3949[3];
							const range = temp_3949[4];
							{
								const block_3951 = [];
								const result_3952 = this.unique('result', null);
								const resultType = this.typer.types.get(e_3740);
								block_3951.push(/*Const*/[4,result_3952,/*Array*/[17,[],this.typer.types.get(e_3740),".Array"],this.typer.types.get(e_3740),".Const"]);
								const value_3953 = this.unique('value', null);
								const valueType = this.typer.types.get(el_3948[0]);
								block_3951.push(/*Const*/[4,value_3953,this.nodeToExpression(over),valueType,".Const"]);
								const push = /*Call*/[2,/*Dot*/[9,/*Ident*/[6,result_3952,this.typer.types.get(e_3740),".Ident"],'push',null,".Dot"],[this.nodeToExpression(by)],[],12,".Call"];
								const fillLoop = () => {
									{
										const temp_3954 = over;
										switch (temp_3954&&temp_3954[0]) {
										case 5: {
											const s_3955 = temp_3954[1];
											{
												const i_3956 = name_3950;
												block_3951.push(/*Const*/[4,i_3956,/*Int*/[1,(-1),".Int"],this.typer.typeInt,".Const"]);
												block_3951.push(/*While*/[13,/*Binop*/[12,/*Parenthesis*/[15,/*Binop*/[12,/*Ident*/[6,i_3956,this.typer.typeInt,".Ident"],111,/*Int*/[1,1,".Int"],this.typer.typeInt,".Binop"],".Parenthesis"],99,/*Ident*/[6,value_3953,valueType,".Ident"],this.typer.typeBool,".Binop"],/*Block*/[1,[/*Increment*/[14,/*Ident*/[6,i_3956,this.typer.typeInt,".Ident"],".Increment"], push],".Block"],true,".While"]);
												return;
											}
										} break;
										};
									};
									block_3951.push(/*For*/[12,name_3950,/*Ident*/[6,value_3953,valueType,".Ident"],push,".For"]);
								};
								fillLoop();
								block_3951.push(/*Return*/[6,/*Ident*/[6,result_3952,resultType,".Ident"],".Return"]);
								return /*Call*/[10,/*Parenthesis*/[15,/*Function*/[13,null,/*Block*/[1,block_3951,".Block"],[],[],/*Function*/[12,[],this.typer.types.get(e_3740),false,".Function"],".Function"],".Parenthesis"],[],this.typer.types.get(e_3740),11,".Call"];
							}
						} break;
						};
					};
					const els_3957 = [];
					const types_3958 = [];
					for (const e of $toIterator(el_3948)) {
						els_3957.push(this.nodeToExpression(e));
						types_3958.push(this.typer.types.get(e));
					};
					return /*Array*/[17,els_3957,this.typer.types.get(e_3740),".Array"];
				}
			} break;
			
			case 50: {
				const nullable = temp_3741[1];
				const otherwise = temp_3741[2];
				{
					const result_3959 = this.unique('result', null);
					const resultType_3960 = this.typer.types.get(nullable);
					return /*Call*/[10,/*Parenthesis*/[15,/*Function*/[13,null,/*Block*/[1,[/*Const*/[4,result_3959,this.nodeToExpression(nullable),resultType_3960,".Const"], /*If*/[7,/*Binop*/[12,/*Ident*/[6,result_3959,resultType_3960,".Ident"],103,/*Null*/[7,resultType_3960,".Null"],this.typer.typeBool,".Binop"],/*Return*/[6,/*Ident*/[6,result_3959,resultType_3960,".Ident"],".Return"],null,".If"], /*Return*/[6,this.nodeToExpression(otherwise),".Return"]],".Block"],[],[],/*Function*/[12,[],this.typer.types.get(otherwise),false,".Function"],".Function"],".Parenthesis"],[],this.typer.types.get(otherwise),11,".Call"];
				}
			} break;
			
			case 20: {
				const op_3961 = temp_3741[1];
				const postfix = temp_3741[2];
				const e_3962 = temp_3741[3];
				{
					{
						const temp_3963 = op_3961;
						switch (temp_3963) {
						case 87: case 86: {
							{
								const source_3964 = this.typer.parents.get(e_3962);
								{
									let step_3965 = 0;
									const source_3966 = source_3964;
									if (step_3965 == 0 && source_3966 != null) { step_3965 = 1 };
									if (step_3965 == 1) {
										const temp_3967 = source_3966;
										switch (temp_3967&&temp_3967[0]) {
										case 24: {
											const name_3968 = temp_3967[1];
											this.neverReassignedLocal.set(source_3966, false)
										} break;
										};
									};
								};
							}
						} break;
						};
					};
					const expression = this.nodeToExpression(e_3962);
					{
						const temp_3969 = op_3961;
						switch (temp_3969) {
						case 89: {
							{
								const temp_3970 = expression;
								switch (temp_3970&&temp_3970[0]) {
								case 4: {
									return /*False*/[5,".False"]
								} break;
								
								case 5: {
									return /*True*/[4,".True"]
								} break;
								};
							}
						} break;
						};
					};
					return /*Unop*/[19,op_3961,postfix,expression,".Unop"];
				}
			} break;
			
			case 3: {
				return /*This*/[8,this.typer.types.get(e_3740),".This"]
			} break;
			
			case 32: {
				const keys = temp_3741[1];
				const values = temp_3741[2];
				{
					const k = [];
					const v_3971 = [];
					for (const key of $toIterator(keys)) {
						k.push(this.nodeToExpression(key));
					};
					for (const value of $toIterator(values)) {
						v_3971.push(this.nodeToExpression(value));
					};
					return /*Map*/[18,k,v_3971,this.typer.types.get(keys[0]),this.typer.types.get(values[0]),this.typer.types.get(e_3740),".Map"];
				}
			} break;
			
			case 11: {
				const a_3972 = temp_3741[1];
				const op_3973 = temp_3741[2];
				const b_3974 = temp_3741[3];
				{
					const source_3975 = this.typer.parents.get(a_3972);
					{
						let step_3976 = 0;
						const source_3977 = source_3975;
						if (step_3976 == 0 && source_3977 != null) { step_3976 = 1 };
						if (step_3976 == 1) {
							const temp_3978 = source_3977;
							switch (temp_3978&&temp_3978[0]) {
							case 24: {
								const name_3979 = temp_3978[1];
								this.neverReassignedLocal.set(source_3977, false)
							} break;
							};
						};
					};
					return /*Assignop*/[25,this.nodeToExpression(a_3972),op_3973,this.nodeToExpression(b_3974),".Assignop"];
				}
			} break;
			
			case 14: {
				const econd = temp_3741[1];
				const eif = temp_3741[2];
				const eelse = temp_3741[3];
				{
					let binds = false;
					for (const cond of $toIterator(econd)) {
						const temp_3980 = cond;
						switch (temp_3980&&temp_3980[0]) {
						case 24: {
							binds = true
						} break;
						};
					};
					if (((!binds)) && (econd.length == 1)) { return /*If*/[21,this.nodeToExpression(econd[0]),this.nodeToExpression(eif),this.nodeToExpression(eelse),".If"] };
					if ((!binds)) {
						let parens = /*Parenthesis*/[15,this.nodeToExpression(econd[0]),".Parenthesis"];
						let i_3981 = 1;
						while (i_3981 < econd.length) {
							parens = /*Binop*/[12,parens,92,/*Parenthesis*/[15,this.nodeToExpression(econd[i_3981]),".Parenthesis"],this.typer.typeBool,".Binop"];
							i_3981++;
						};
						return /*If*/[21,parens,this.nodeToExpression(eif),this.nodeToExpression(eelse),".If"];
					};
					return /*If*/[21,this.nodeToExpression(econd[0]),this.nodeToExpression(eif),this.nodeToExpression(eelse),".If"];
				}
			} break;
			
			case 33: {
				const expr_3982 = temp_3741[1];
				const index = temp_3741[2];
				return /*Index*/[22,this.nodeToExpression(expr_3982),this.nodeToExpression(index),this.typer.types.get(e_3740),".Index"]
			} break;
			
			case 44: {
				const e_3983 = temp_3741[1];
				const kind_3984 = temp_3741[2];
				const t_3985 = temp_3741[3];
				{
					const temp_3986 = kind_3984;
					switch (temp_3986) {
					case 81: {
						console.log('`as?` is not yet supported by normalizer, only `as!`')
					} break;
					
					case 89: {
						return /*UnsafeBitCast*/[23,this.nodeToExpression(e_3983),this.typer.types.get(t_3985),".UnsafeBitCast"]
					} break;
					
					default: 
					console.log('`as` is not yet supported by normalizer, only `as!`')
					};
				}
			} break;
			
			case 43: {
				const e_3987 = temp_3741[1];
				const t_3988 = temp_3741[2];
				return /*Is*/[24,this.nodeToExpression(e_3987),this.typer.types.get(t_3988),".Is"]
			} break;
			
			case 34: {
				const exprs = temp_3741[1];
				const conds = temp_3741[2];
				const guards = temp_3741[3];
				const cases = temp_3741[4];
				{
					const block_3989 = [];
					const caseRet = [];
					let funcType = this.typer.typeVoid;
					let resultType_3990 = this.typer.typeVoid;
					for (const c of $toIterator(cases)) {
						resultType_3990 = this.typer.types.get(c);
						funcType = /*Function*/[12,[],resultType_3990,false,".Function"];
						caseRet.push(/*Return*/[16,c,".Return"]);
					};
					block_3989.push(this.nodeToStatement(/*Switch*/[34,exprs,conds,guards,caseRet,".Switch"]));
					return /*Call*/[10,/*Parenthesis*/[15,/*Function*/[13,null,/*Block*/[1,block_3989,".Block"],[],[],funcType,".Function"],".Parenthesis"],[],resultType_3990,11,".Call"];
				}
			} break;
			
			case 35: {
				{
				}
			} break;
			
			case 37: {
				{
				}
			} break;
			
			case 9: {
				{
				}
			} break;
			
			default: 
			console.error('(internal warning) Unknown node type for expression:', e_3740, this.project.data.get(e_3740))
			};
		};
		return null;
	};
		nodeToStatement(e_3991) {
		const result_3992 = this.nodeToStatementWithoutPosition(e_3991);
		if (result_3992 != null) { this.niceProject.statementPosition.set(result_3992, this.project.data.get(e_3991)) };
		return result_3992;
	};
		nodeToStatementWithoutPosition(e_3993) {
		if (e_3993 == null) { return null };
		{
			const temp_3994 = e_3993;
			switch (temp_3994&&temp_3994[0]) {
			case 12: {
				const el_3995 = temp_3994[1];
				{
					const els_3996 = [];
					let ignore = false;
					for (const e of $toIterator(el_3995)) {
						const statement_3997 = this.unwrapNestingBlocks(this.nodeToStatement(e));
						if (ignore) { continue };
						{
							const temp_3998 = statement_3997;
							switch (temp_3998&&temp_3998[0]) {
							case null: case undefined: {
								{
								}
							} break;
							
							case 1: {
								const sub = temp_3998[1];
								{
									const temp_3999 = sub.length;
									switch (temp_3999) {
									case 0: {
										{
										}
									} break;
									
									case 1: {
										els_3996.push(sub[0])
									} break;
									
									default: 
									els_3996.push(statement_3997)
									};
								}
							} break;
							
							case 18: {
								{
									els_3996.push(statement_3997);
									ignore = true;
								}
							} break;
							
							case 17: {
								{
									els_3996.push(statement_3997);
									ignore = true;
								}
							} break;
							
							case 6: {
								{
									els_3996.push(statement_3997);
									ignore = true;
								}
							} break;
							
							case 9: {
								{
									els_3996.push(statement_3997);
									ignore = true;
								}
							} break;
							
							default: 
							els_3996.push(statement_3997)
							};
						};
					};
					{
						let i_4000 = 0;
						let it_4001 = 0;
						let at_4002 = els_3996.length;
						while (it_4001 < at_4002) {
							i_4000 = it_4001;
							it_4001++;
							{
								const element = els_3996[i_4000];
								{
									const temp_4003 = element;
									switch (temp_4003&&temp_4003[0]) {
									case 3: {
										const name_4004 = temp_4003[1];
										const expr_4005 = temp_4003[2];
										const type_4006 = temp_4003[3];
										{
											let step_4007 = 0;
											const parent_4008 = this.neverReassignedLocalParent.get(element);
											let temp_4009 = null;
											if (step_4007 == 0 && parent_4008 != null) {
												temp_4009 = this.neverReassignedLocal.get(parent_4008) == true;
												step_4007 = 1;
											};
											if (step_4007 == 1 && temp_4009 != false) { step_4007 = 2 };
											if (step_4007 == 2) { els_3996[i_4000] = /*Const*/[4,name_4004,expr_4005,type_4006,".Const"] };
										}
									} break;
									};
								};
							};
						};
					};
					if (els_3996.length == 1) {
						const temp_4010 = els_3996[0];
						switch (temp_4010&&temp_4010[0]) {
						case 1: {
							return els_3996[0]
						} break;
						};
					};
					return /*Block*/[1,els_3996,".Block"];
				}
			} break;
			
			case 39: {
				const t_4011 = temp_3994[1];
				const fields_4012 = temp_3994[2];
				const valuesType_4013 = temp_3994[3];
				{
					this.renameClassFields(fields_4012, getRenamingStrategy(this.project.mapDecorators.get(e_3993)));
					const isComplexEnum = valuesType_4013 == null;
					if (isComplexEnum) {
						const type_4014 = new NiceComplexEnum();
						type_4014.name = this.unique(DataHelper.extractTypeName(t_4011), e_3993);
						const atts_4015 = this.project.mapDecorators.get(e_3993);
						type_4014.expose = false;
						{
							let step_4016 = 0;
							const expose = Decorator.getDecorator(atts_4015, 'expose');
							if (step_4016 == 0 && expose != null) { step_4016 = 1 };
							if (step_4016 == 1) {
								if (expose.values.length != 0) { throw '@expose takes zero arguments' };
								type_4014.expose = true;
							};
						};
						this.globals.push(type_4014.name);
						const names_4017 = [];
						const constructors = [];
						const constructorsTypes = [];
						const types_4018 = [];
						for (const f of $toIterator(fields_4012)) {
							const temp_4019 = f;
							switch (temp_4019&&temp_4019[0]) {
							case 51: {
								const t_4020 = temp_4019[1];
								{
									const temp_4021 = t_4020;
									switch (temp_4021&&temp_4021[0]) {
									case 1: {
										const name_4022 = temp_4021[1];
										{
											names_4017.push(name_4022);
											constructors.push(null);
											constructorsTypes.push(null);
											types_4018.push(null);
										}
									} break;
									};
								}
							} break;
							
							case 13: {
								const e_4023 = temp_4019[1];
								const args_4024 = temp_4019[2];
								const argNames_4025 = temp_4019[3];
								{
									{
										const temp_4026 = e_4023;
										switch (temp_4026&&temp_4026[0]) {
										case 51: {
											const t_4027 = temp_4026[1];
											{
												const temp_4028 = t_4027;
												switch (temp_4028&&temp_4028[0]) {
												case 1: {
													const name_4029 = temp_4028[1];
													names_4017.push(name_4029)
												} break;
												};
											}
										} break;
										};
									};
									constructors.push((() => {
										const result_4030 = [];
										const value_4031 = argNames_4025;
										for (const arg of $toIterator(value_4031)) result_4030.push(this.unique((arg), null));
										return result_4030;
									})());
									constructorsTypes.push((() => {
										const result_4032 = [];
										const value_4033 = args_4024;
										for (const arg of $toIterator(value_4033)) result_4032.push(this.typer.toType(Typer.nodeToNodeType(arg), arg));
										return result_4032;
									})());
									types_4018.push((() => {
										const result_4034 = [];
										const value_4035 = args_4024;
										for (const arg of $toIterator(value_4035)) result_4034.push(this.unique((arg), null));
										return result_4034;
									})());
								}
							} break;
							
							case 47: {
								const field = temp_4019[1];
								{
									const temp_4036 = field;
									switch (temp_4036&&temp_4036[0]) {
									case 24: {
										const name_4037 = temp_4036[1];
										const t_4038 = temp_4036[2];
										const expr_4039 = temp_4036[3];
										const const_4040 = temp_4036[4];
										{
											const uname = (() => {
												const result_4041 = this.parentNames.get(field);
												if (result_4041 != null) { return result_4041 };
												return this.unique(name_4037, field);
											})();
											if (const_4040) {
												const value_4042 = this.nodeToExpression(expr_4039);
												this.saveInlineIfViable(f, value_4042);
												type_4014.staticVars.push(/*Const*/[4,uname,value_4042,this.typer.types.get(field),".Const"]);
											} else {
												type_4014.staticVars.push(/*Var*/[3,uname,this.nodeToExpression(expr_4039),this.typer.types.get(field),".Var"]);
											};
										}
									} break;
									
									case 22: {
										const name_4043 = temp_4036[1];
										const expr_4044 = temp_4036[2];
										const vars_4045 = temp_4036[3];
										const rettype_4046 = temp_4036[4];
										const external_4047 = temp_4036[5];
										{
											const uname_4048 = (() => {
												const result_4049 = this.parentNames.get(field);
												if (result_4049 != null) { return result_4049 };
												return this.unique(name_4043, field);
											})();
											const a_4050 = [];
											const defaults_4051 = [];
											const types_4052 = [];
											for (const arg of $toIterator(vars_4045)) {
												const temp_4053 = arg;
												switch (temp_4053&&temp_4053[0]) {
												case 24: {
													const name_4054 = temp_4053[1];
													const t_4055 = temp_4053[2];
													const expr_4056 = temp_4053[3];
													const const_4057 = temp_4053[4];
													{
														a_4050.push(this.unique(name_4054, arg));
														types_4052.push(t_4055);
														if (expr_4056 != null) { defaults_4051.push(this.nodeToExpression(expr_4056)) } else {
															defaults_4051.push(null);
														};
													}
												} break;
												};
											};
											type_4014.staticMethods.push(/*Function*/[5,uname_4048,this.unwrapNestingBlocks(this.nodeToStatement(expr_4044)),a_4050,defaults_4051,this.typer.types.get(field),10,".Function"]);
										}
									} break;
									
									default: 
									console.error('(internal warning) Unknown complex enum static field kind:', field)
									};
								}
							} break;
							
							default: 
							console.error('(internal warning) Unknown complex enum field kind:', f)
							};
						};
						type_4014.names = names_4017;
						type_4014.constructors = constructors;
						type_4014.constructorsTypes = constructorsTypes;
						type_4014.types = types_4018;
						this.niceProject.enumsComplex.push(type_4014);
						return null;
					} else {
						const type_4058 = new NiceSimpleEnum();
						type_4058.name = DataHelper.extractTypeName(t_4011);
						const names_4059 = [];
						const values_4060 = [];
						for (const f of $toIterator(fields_4012)) {
							const temp_4061 = f;
							switch (temp_4061&&temp_4061[0]) {
							case 10: {
								const a_4062 = temp_4061[1];
								const op_4063 = temp_4061[2];
								const b_4064 = temp_4061[3];
								{
									{
										const temp_4065 = a_4062;
										switch (temp_4065&&temp_4065[0]) {
										case 51: {
											const t_4066 = temp_4065[1];
											{
												const temp_4067 = t_4066;
												switch (temp_4067&&temp_4067[0]) {
												case 1: {
													const name_4068 = temp_4067[1];
													names_4059.push(name_4068)
												} break;
												};
											}
										} break;
										};
									};
									{
										const temp_4069 = b_4064;
										switch (temp_4069&&temp_4069[0]) {
										case 0: {
											const s_4070 = temp_4069[1];
											values_4060.push(/*String*/[0,s_4070,".String"])
										} break;
										
										case 5: {
											const s_4071 = temp_4069[1];
											values_4060.push(/*Int*/[1,s_4071,".Int"])
										} break;
										
										case 6: {
											const v_4072 = temp_4069[1];
											const meta_4073 = temp_4069[2];
											values_4060.push(/*MetaInt*/[2,v_4072,meta_4073,this.typer.types.get(e_3993),".MetaInt"])
										} break;
										
										case 51: {
											const type_4074 = temp_4069[1];
											{
												const temp_4075 = type_4074;
												switch (temp_4075&&temp_4075[0]) {
												case 1: {
													const name_4076 = temp_4075[1];
													const path_4077 = temp_4075[2];
													values_4060.push(values_4060[names_4059.indexOf(name_4076, 0)])
												} break;
												
												default: 
												console.error('(internal warning) Unknown node alias value kind:', b_4064)
												};
											}
										} break;
										
										default: 
										console.error('(internal warning) Unknown node field value kind:', b_4064)
										};
									};
								}
							} break;
							
							case 51: {
								const t_4078 = temp_4061[1];
								{
									const temp_4079 = t_4078;
									switch (temp_4079&&temp_4079[0]) {
									case 1: {
										const name_4080 = temp_4079[1];
										names_4059.push(name_4080)
									} break;
									};
								}
							} break;
							
							case 47: {
								const field_4081 = temp_4061[1];
								{
									const temp_4082 = field_4081;
									switch (temp_4082&&temp_4082[0]) {
									case 24: {
										const name_4083 = temp_4082[1];
										const t_4084 = temp_4082[2];
										const expr_4085 = temp_4082[3];
										const const_4086 = temp_4082[4];
										{
											const uname_4087 = (() => {
												const result_4088 = this.parentNames.get(field_4081);
												if (result_4088 != null) { return result_4088 };
												return this.unique(name_4083, field_4081);
											})();
											if (const_4086) {
												const value_4089 = this.nodeToExpression(expr_4085);
												this.saveInlineIfViable(f, value_4089);
												type_4058.staticVars.push(/*Const*/[4,uname_4087,value_4089,this.typer.types.get(field_4081),".Const"]);
											} else {
												type_4058.staticVars.push(/*Var*/[3,uname_4087,this.nodeToExpression(expr_4085),this.typer.types.get(field_4081),".Var"]);
											};
										}
									} break;
									
									case 22: {
										const name_4090 = temp_4082[1];
										const expr_4091 = temp_4082[2];
										const vars_4092 = temp_4082[3];
										const rettype_4093 = temp_4082[4];
										const external_4094 = temp_4082[5];
										{
											const uname_4095 = (() => {
												const result_4096 = this.parentNames.get(field_4081);
												if (result_4096 != null) { return result_4096 };
												return this.unique(name_4090, field_4081);
											})();
											const a_4097 = [];
											const defaults_4098 = [];
											const types_4099 = [];
											for (const arg of $toIterator(vars_4092)) {
												const temp_4100 = arg;
												switch (temp_4100&&temp_4100[0]) {
												case 24: {
													const name_4101 = temp_4100[1];
													const t_4102 = temp_4100[2];
													const expr_4103 = temp_4100[3];
													const const_4104 = temp_4100[4];
													{
														a_4097.push(this.unique(name_4101, arg));
														types_4099.push(t_4102);
														if (expr_4103 != null) { defaults_4098.push(this.nodeToExpression(expr_4103)) } else {
															defaults_4098.push(null);
														};
													}
												} break;
												};
											};
											type_4058.staticMethods.push(/*Function*/[5,uname_4095,this.unwrapNestingBlocks(this.nodeToStatement(expr_4091)),a_4097,defaults_4098,this.typer.types.get(field_4081),10,".Function"]);
										}
									} break;
									
									default: 
									console.error('(internal warning) Unknown simple enum static field kind:', field_4081)
									};
								}
							} break;
							
							default: 
							console.error('(internal warning) Unknown simple enum field kind:', f)
							};
						};
						type_4058.names = names_4059;
						type_4058.values = values_4060;
						this.niceProject.enumsSimple.push(type_4058);
						return null;
					};
				}
			} break;
			
			case 25: {
				const t_4105 = temp_3994[1];
				const ext_4106 = temp_3994[2];
				const impl_4107 = temp_3994[3];
				const fields_4108 = temp_3994[4];
				const external_4109 = temp_3994[5];
				{
					const atts_4110 = this.project.mapDecorators.get(e_3993);
					this.renameClassFields(fields_4108, getRenamingStrategy(atts_4110));
					const type_4111 = new NiceClass();
					type_4111.external = external_4109;
					type_4111.extend = DataHelper.extractTypeName(ext_4106);
					type_4111.type = this.typer.types.get(e_3993);
					this.thisType = type_4111.type;
					{
						const temp_4112 = type_4111.type;
						switch (temp_4112&&temp_4112[0]) {
						case 5: {
							const c_4113 = temp_4112[1];
							{
								{
									let step_4114 = 0;
									const instanceParams = c_4113.instanceParams;
									if (step_4114 == 0 && instanceParams != null) { step_4114 = 1 };
									if (step_4114 == 1) {
										type_4111.type = c_4113.instantiateGeneric(instanceParams);
										this.thisType = type_4111.type;
									};
								};
								type_4111.template = c_4113.instances != null && c_4113.instances.length > 0;
								type_4111.usedByValueDepth = c_4113.usedByValueDepth;
							}
						} break;
						};
					};
					for (const implement of $toIterator(impl_4107)) {
						const temp_4115 = implement;
						switch (temp_4115&&temp_4115[0]) {
						case 1: {
							const name_4116 = temp_4115[1];
							type_4111.implement = name_4116
						} break;
						
						case 2: {
							const name_4117 = temp_4115[1];
							const params_4118 = temp_4115[2];
							{
								type_4111.implement = name_4117;
								type_4111.implementParams = (() => {
									const result_4119 = [];
									const value_4120 = params_4118;
									for (const param of $toIterator(value_4120)) result_4119.push(DataHelper.extractTypeName(param));
									return result_4119;
								})();
							}
						} break;
						};
					};
					{
						const temp_4121 = t_4105;
						switch (temp_4121&&temp_4121[0]) {
						case 1: {
							const name_4122 = temp_4121[1];
							{
							}
						} break;
						
						case 2: {
							const name_4123 = temp_4121[1];
							const params_4124 = temp_4121[2];
							type_4111.genericParams = (() => {
								const result_4125 = [];
								const value_4126 = params_4124;
								for (const param of $toIterator(value_4126)) result_4125.push(DataHelper.extractTypeName(param));
								return result_4125;
							})()
						} break;
						};
					};
					{
						let step_4127 = 0;
						const require_4128 = Decorator.getDecorator(atts_4110, 'require');
						if (step_4127 == 0 && require_4128 != null) { step_4127 = 1 };
						if (step_4127 == 1) {
							const temp_4129 = require_4128.values[0];
							switch (temp_4129&&temp_4129[0]) {
							case 0: {
								const s_4130 = temp_4129[1];
								type_4111.jsRequire = s_4130
							} break;
							
							default: 
							throw '@require takes string as argument'
							};
						};
					};
					type_4111.api = 10;
					{
						let step_4131 = 0;
						const struct = Decorator.getDecorator(atts_4110, 'struct');
						if (step_4131 == 0 && struct != null) { step_4131 = 1 };
						if (step_4131 == 1) {
							const temp_4132 = struct.values[0];
							switch (temp_4132&&temp_4132[0]) {
							case null: case undefined: {
								{
								}
							} break;
							
							default: 
							throw '@struct takes no arguments'
							};
						};
					};
					{
						let step_4133 = 0;
						const native_4134 = Decorator.getDecorator(atts_4110, 'rename');
						if (step_4133 == 0 && native_4134 != null) { step_4133 = 1 };
						if (step_4133 == 1) {
							const temp_4135 = native_4134.values[0];
							switch (temp_4135&&temp_4135[0]) {
							case 0: {
								const s_4136 = temp_4135[1];
								{
									type_4111.jsNative = s_4136;
									type_4111.name = this.unique(s_4136, e_3993);
								}
							} break;
							
							default: 
							throw '@rename takes string as argument'
							};
						} else {
							const temp_4137 = (this.typer.types.get(e_3993));
							switch (temp_4137&&temp_4137[0]) {
							case 5: {
								const the = temp_4137[1];
								type_4111.name = this.unique(the.name, e_3993)
							} break;
							
							default: 
							type_4111.name = this.unique(DataHelper.extractTypeName(t_4105), e_3993)
							};
						};
					};
					this.globals.push(type_4111.name);
					for (const f of $toIterator(fields_4108)) {
						const temp_4138 = f;
						switch (temp_4138&&temp_4138[0]) {
						case 24: {
							const name_4139 = temp_4138[1];
							const t_4140 = temp_4138[2];
							const expr_4141 = temp_4138[3];
							const const_4142 = temp_4138[4];
							{
								const uname_4143 = (() => {
									const result_4144 = this.getClassDotField(e_3993, name_4139);
									if (result_4144 != null) { return result_4144 };
									return (() => {
										const result_4145 = this.parentNames.get(f);
										if (result_4145 != null) { return result_4145 };
										return this.unique(name_4139, f);
									})();
								})();
								if (const_4142) {
									const value_4146 = this.nodeToExpression(expr_4141);
									this.saveInlineIfViable(f, value_4146);
									type_4111.vars.push(/*Const*/[4,uname_4143,value_4146,this.typer.types.get(f),".Const"]);
								} else {
									type_4111.vars.push(/*Var*/[3,uname_4143,this.nodeToExpression(expr_4141),this.typer.types.get(f),".Var"]);
									const atts_4147 = this.project.mapDecorators.get(f);
									{
										let step_4148 = 0;
										const native_4149 = Decorator.getDecorator(atts_4147, 'bits');
										if (step_4148 == 0 && native_4149 != null) { step_4148 = 1 };
										if (step_4148 == 1) {
											const temp_4150 = native_4149.values[0];
											switch (temp_4150&&temp_4150[0]) {
											case 5: {
												const v_4151 = temp_4150[1];
												type_4111.varBits[type_4111.vars.length - 1] = v_4151
											} break;
											};
										};
									};
								};
							}
						} break;
						
						case 26: {
							const field_4152 = temp_4138[1];
							{
								const temp_4153 = field_4152;
								switch (temp_4153&&temp_4153[0]) {
								case 24: {
									const name_4154 = temp_4153[1];
									const t_4155 = temp_4153[2];
									const expr_4156 = temp_4153[3];
									const const_4157 = temp_4153[4];
									{
										const uname_4158 = (() => {
											const result_4159 = this.parentNames.get(f);
											if (result_4159 != null) { return result_4159 };
											return this.unique(name_4154, f);
										})();
										if (const_4157) { type_4111.vars.push(/*Const*/[4,uname_4158,this.nodeToExpression(expr_4156),this.typer.types.get(field_4152),".Const"]) } else {
											type_4111.vars.push(/*Var*/[3,uname_4158,this.nodeToExpression(expr_4156),this.typer.types.get(field_4152),".Var"]);
										};
										type_4111.property.push(uname_4158);
									}
								} break;
								};
							}
						} break;
						
						case 22: {
							const name_4160 = temp_4138[1];
							const expr_4161 = temp_4138[2];
							const vars_4162 = temp_4138[3];
							const rettype_4163 = temp_4138[4];
							const external_4164 = temp_4138[5];
							{
								const uname_4165 = (((name_4160 == 'new'))? ('new') : ((() => {
									const result_4166 = this.parentNames.get(f);
									if (result_4166 != null) { return result_4166 };
									return this.unique(name_4160, f);
								})()));
								const a_4167 = [];
								const defaults_4168 = [];
								const types_4169 = [];
								for (const arg of $toIterator(vars_4162)) {
									const temp_4170 = arg;
									switch (temp_4170&&temp_4170[0]) {
									case 24: {
										const name_4171 = temp_4170[1];
										const t_4172 = temp_4170[2];
										const expr_4173 = temp_4170[3];
										const const_4174 = temp_4170[4];
										{
											a_4167.push(this.unique(name_4171, arg));
											types_4169.push(t_4172);
											if (expr_4173 != null) { defaults_4168.push(this.nodeToExpression(expr_4173)) } else {
												defaults_4168.push(null);
											};
										}
									} break;
									};
								};
								type_4111.methods.push(/*Function*/[5,uname_4165,this.unwrapNestingBlocks(this.nodeToStatement(expr_4161)),a_4167,defaults_4168,this.typer.types.get(f),10,".Function"]);
							}
						} break;
						
						case 47: {
							const field_4175 = temp_4138[1];
							{
								const temp_4176 = field_4175;
								switch (temp_4176&&temp_4176[0]) {
								case 24: {
									const name_4177 = temp_4176[1];
									const t_4178 = temp_4176[2];
									const expr_4179 = temp_4176[3];
									const const_4180 = temp_4176[4];
									{
										const uname_4181 = (() => {
											const result_4182 = this.parentNames.get(field_4175);
											if (result_4182 != null) { return result_4182 };
											return this.unique(name_4177, field_4175);
										})();
										if (const_4180) {
											const value_4183 = this.nodeToExpression(expr_4179);
											this.saveInlineIfViable(f, value_4183);
											type_4111.staticVars.push(/*Const*/[4,uname_4181,value_4183,this.typer.types.get(field_4175),".Const"]);
										} else {
											type_4111.staticVars.push(/*Var*/[3,uname_4181,this.nodeToExpression(expr_4179),this.typer.types.get(field_4175),".Var"]);
										};
									}
								} break;
								
								case 22: {
									const name_4184 = temp_4176[1];
									const expr_4185 = temp_4176[2];
									const vars_4186 = temp_4176[3];
									const rettype_4187 = temp_4176[4];
									{
										const uname_4188 = (() => {
											const result_4189 = this.parentNames.get(field_4175);
											if (result_4189 != null) { return result_4189 };
											return this.unique(name_4184, field_4175);
										})();
										const a_4190 = [];
										const defaults_4191 = [];
										const types_4192 = [];
										for (const arg of $toIterator(vars_4186)) {
											const temp_4193 = arg;
											switch (temp_4193&&temp_4193[0]) {
											case 24: {
												const name_4194 = temp_4193[1];
												const t_4195 = temp_4193[2];
												const expr_4196 = temp_4193[3];
												const const_4197 = temp_4193[4];
												{
													a_4190.push(this.unique(name_4194, arg));
													types_4192.push(t_4195);
													if (expr_4196 != null) { defaults_4191.push(this.nodeToExpression(expr_4196)) } else {
														defaults_4191.push(null);
													};
												}
											} break;
											};
										};
										type_4111.staticMethods.push(/*Function*/[5,uname_4188,this.unwrapNestingBlocks(this.nodeToStatement(expr_4185)),a_4190,defaults_4191,this.typer.types.get(field_4175),10,".Function"]);
									}
								} break;
								
								default: 
								console.error('(internal warning) Unknown class static field kind:', field_4175)
								};
							}
						} break;
						
						default: 
						console.error('(internal warning) Unknown class field kind:', f)
						};
					};
					this.niceProject.classes.push(type_4111);
					{
						const temp_4198 = (this.typer.types.get(e_3993));
						switch (temp_4198&&temp_4198[0]) {
						case 5: {
							const the_4199 = temp_4198[1];
							{
								type_4111.useless = the_4199.useless;
								const fillSignature = (signature, type_4200) => {
									const temp_4201 = type_4200;
									switch (temp_4201&&temp_4201[0]) {
									case 6: {
										const type_4202 = temp_4201[1];
										const generic = temp_4201[2];
										{
											{
												let step_4203 = 0;
												const native_4204 = this.getNative(type_4202.parent);
												if (step_4203 == 0 && native_4204 != null) { step_4203 = 1 };
												if (step_4203 == 1) { signature.push(native_4204) } else {
													signature.push(type_4202.name);
												};
											};
											const generic_4205 = (() => {
												const result_4206 = generic;
												if (result_4206 != null) { return result_4206 };
												return [];
											})();
											for (const param of $toIterator(generic_4205)) {
												fillSignature(signature, param);
											};
										}
									} break;
									
									case 9: {
										const type_4207 = temp_4201[1];
										signature.push(type_4207.name)
									} break;
									
									case 5: {
										const type_4208 = temp_4201[1];
										signature.push(type_4208.name)
									} break;
									
									case 8: {
										const type_4209 = temp_4201[1];
										signature.push(type_4209.name)
									} break;
									
									case 4: {
										const handle = temp_4201[1];
										{
											signature.push('Null');
											fillSignature(signature, handle);
										}
									} break;
									
									case 2: {
										const handle_4210 = temp_4201[1];
										{
											let step_4211 = 0;
											const type_4212 = handle_4210.value;
											if (step_4211 == 0 && type_4212 != null) { step_4211 = 1 };
											if (step_4211 == 1) { fillSignature(signature, type_4212) } else {
												signature.push('Unknown');
											};
										}
									} break;
									
									case 3: {
										const handle_4213 = temp_4201[1];
										{
											signature.push('Null');
											{
												let step_4214 = 0;
												const type_4215 = handle_4213.value;
												if (step_4214 == 0 && type_4215 != null) { step_4214 = 1 };
												if (step_4214 == 1) { fillSignature(signature, type_4215) } else {
													signature.push('Unknown');
												};
											};
										}
									} break;
									
									case 12: {
										const value_4216 = temp_4201[1];
										signature.push('fun')
									} break;
									
									case 0: {
										const value_4217 = temp_4201[1];
										signature.push('const')
									} break;
									
									case 13: {
										const value_4218 = temp_4201[1];
										signature.push('struct')
									} break;
									
									default: 
									throw type_4200
									};
								};
								for (const instance of $toIterator(the_4199.instances)) {
									const signature_4219 = ['_'];
									{
										let step_4220 = 0;
										const instanceParams_4221 = instance.instanceParams;
										if (step_4220 == 0 && instanceParams_4221 != null) { step_4220 = 1 };
										if (step_4220 == 1) { for (const param of $toIterator(instanceParams_4221)) {
											fillSignature(signature_4219, param);
										} };
									};
									instance.useless = the_4199.useless;
									this.nodeToStatement(instance.parent);
								};
							}
						} break;
						};
					};
					return null;
				}
			} break;
			
			case 9: {
				{
				}
			} break;
			
			case 30: {
				const path_4222 = temp_3994[1];
				const t_4223 = temp_3994[2];
				const args_4224 = temp_3994[3];
				const fields_4225 = temp_3994[4];
				const values_4226 = temp_3994[5];
				return /*Const*/[4,this.unique('temp', null),this.nodeToExpression(e_3993),this.typer.types.get(e_3993),".Const"]
			} break;
			
			case 13: {
				const e_4227 = temp_3994[1];
				const args_4228 = temp_3994[2];
				const argNames_4229 = temp_3994[3];
				{
					let kind_4230 = 11;
					{
						const temp_4231 = e_4227;
						switch (temp_4231&&temp_4231[0]) {
						case 4: {
							{
								const a_4232 = [];
								for (const arg of $toIterator(args_4228)) {
									a_4232.push(this.nodeToExpression(arg));
								};
								return /*SuperConstructor*/[19,a_4232,".SuperConstructor"];
							}
						} break;
						
						case 28: {
							const expr_4233 = temp_4231[1];
							const name_4234 = temp_4231[2];
							{
								const temp_4235 = (this.typer.types.get(expr_4233));
								switch (temp_4235&&temp_4235[0]) {
								case 6: {
									const c_4236 = temp_4235[1];
									if (c_4236.fields.get(name_4234) == 0) { kind_4230 = 12 }
								} break;
								
								case 5: {
									kind_4230 = 10
								} break;
								};
							}
						} break;
						};
					};
					const v_4237 = this.nodeToExpression(e_4227);
					const a_4238 = [];
					for (const arg of $toIterator(args_4228)) {
						a_4238.push(this.nodeToExpression(arg));
					};
					{
						const temp_4239 = (this.typer.parents.get(e_4227));
						switch (temp_4239&&temp_4239[0]) {
						case 22: {
							const vars_4240 = temp_4239[3];
							if (vars_4240.length > a_4238.length) {
								let i_4241 = 0;
								let it_4242 = 0;
								let at_4243 = vars_4240.length;
								while (it_4242 < at_4243) {
									i_4241 = it_4242;
									it_4242++;
									{
										if (i_4241 < a_4238.length) { continue };
										{
											const temp_4244 = (vars_4240[i_4241]);
											switch (temp_4244&&temp_4244[0]) {
											case 24: {
												const value_4245 = temp_4244[3];
												{
													let step_4246 = 0;
													const value_4247 = value_4245;
													if (step_4246 == 0 && value_4247 != null) { step_4246 = 1 };
													if (step_4246 == 1) { a_4238.push(this.nodeToExpression(value_4247)) };
												}
											} break;
											};
										};
									};
								};
							}
						} break;
						};
					};
					const expects = [];
					let expects_4248 = [];
					{
						const temp_4249 = (this.typer.types.get(e_4227));
						switch (temp_4249&&temp_4249[0]) {
						case 12: {
							const args_4250 = temp_4249[1];
							expects_4248 = args_4250.map((arg) => (arg.type))
						} break;
						};
					};
					{
						const temp_4251 = v_4237;
						switch (temp_4251&&temp_4251[0]) {
						case 9: {
							const expr_4252 = temp_4251[1];
							{
								const temp_4253 = expr_4252;
								switch (temp_4253&&temp_4253[0]) {
								case 8: {
									kind_4230 = 12
								} break;
								};
							}
						} break;
						};
					};
					return /*Call*/[2,v_4237,a_4238,expects_4248,kind_4230,".Call"];
				}
			} break;
			
			case 24: {
				const name_4254 = temp_3994[1];
				const t_4255 = temp_3994[2];
				const expr_4256 = temp_3994[3];
				const const_4257 = temp_3994[4];
				const external_4258 = temp_3994[5];
				{
					const uname_4259 = (() => {
						const result_4260 = this.parentNames.get(e_3993);
						if (result_4260 != null) { return result_4260 };
						return this.unique(name_4254, e_3993);
					})();
					if (external_4258) { return null };
					if (const_4257) {
						const value_4261 = this.nodeToExpression(expr_4256);
						this.saveInlineIfViable(e_3993, value_4261);
						return /*Const*/[4,uname_4259,value_4261,this.typer.types.get(e_3993),".Const"];
					};
					const result_4262 = /*Var*/[3,uname_4259,this.nodeToExpression(expr_4256),this.typer.types.get(e_3993),".Var"];
					this.neverReassignedLocal.set(e_3993, true);
					this.neverReassignedLocalParent.set(result_4262, e_3993);
					return result_4262;
				}
			} break;
			
			case 22: {
				const name_4263 = temp_3994[1];
				const expr_4264 = temp_3994[2];
				const vars_4265 = temp_3994[3];
				const rettype_4266 = temp_3994[4];
				const external_4267 = temp_3994[5];
				const variadic = temp_3994[6];
				{
					let uname_4268 = null;
					const atts_4269 = this.project.mapDecorators.get(e_3993);
					{
						let step_4270 = 0;
						const native_4271 = Decorator.getDecorator(atts_4269, 'rename');
						if (step_4270 == 0 && native_4271 != null) { step_4270 = 1 };
						if (step_4270 == 1) {
							const temp_4272 = native_4271.values[0];
							switch (temp_4272&&temp_4272[0]) {
							case 0: {
								const s_4273 = temp_4272[1];
								{
									if (this.parentNames.get(e_3993) == null) { this.uniqueNative(s_4273, e_3993) };
									uname_4268 = this.parentNames.get(e_3993);
								}
							} break;
							
							default: 
							throw '@rename takes string as argument'
							};
						} else {
							uname_4268 = (((name_4263 != null))? (((() => {
								const result_4274 = this.parentNames.get(e_3993);
								if (result_4274 != null) { return result_4274 };
								return this.unique(name_4263, e_3993);
							})())) : (null));
						};
					};
					const rettype_4275 = rettype_4266;
					const a_4276 = [];
					const defaults_4277 = [];
					const types_4278 = [];
					for (const arg of $toIterator(vars_4265)) {
						const temp_4279 = arg;
						switch (temp_4279&&temp_4279[0]) {
						case 24: {
							const name_4280 = temp_4279[1];
							const t_4281 = temp_4279[2];
							const expr_4282 = temp_4279[3];
							const const_4283 = temp_4279[4];
							{
								a_4276.push(this.unique(name_4280, arg));
								types_4278.push(t_4281);
								if (expr_4282 != null) { defaults_4277.push(this.nodeToExpression(expr_4282)) } else {
									defaults_4277.push(null);
								};
							}
						} break;
						};
					};
					const variadic_4284 = ((variadic)? (11) : 10);
					if (external_4267) { return /*Function*/[5,uname_4268,null,a_4276,defaults_4277,this.typer.types.get(e_3993),variadic_4284,".Function"] };
					if (name_4263 == 'new') { return /*Function*/[5,null,this.unwrapNestingBlocks(this.nodeToStatement(expr_4264)),a_4276,defaults_4277,this.typer.types.get(e_3993),variadic_4284,".Function"] };
					return /*Function*/[5,uname_4268,this.unwrapNestingBlocks(this.nodeToStatement(expr_4264)),a_4276,defaults_4277,this.typer.types.get(e_3993),variadic_4284,".Function"];
				}
			} break;
			
			case 49: {
				const name_4285 = temp_3994[1];
				const over_4286 = temp_3994[2];
				const by_4287 = temp_3994[3];
				const range_4288 = temp_3994[4];
				{
					if (range_4288 == null) {
						const temp_4289 = over_4286;
						switch (temp_4289&&temp_4289[0]) {
						case 5: {
							const s_4290 = temp_4289[1];
							{
								const i_4291 = this.unique(name_4285, e_3993);
								const it_4292 = this.unique('it', null);
								return /*Block*/[1,[/*Var*/[3,i_4291,/*Int*/[1,0,".Int"],this.typer.typeInt,".Var"], /*Var*/[3,it_4292,/*Int*/[1,0,".Int"],this.typer.typeInt,".Var"], /*While*/[13,/*Binop*/[12,/*Ident*/[6,it_4292,this.typer.typeInt,".Ident"],99,/*Int*/[1,s_4290,".Int"],this.typer.typeBool,".Binop"],/*Block*/[1,[/*Assign*/[10,/*Ident*/[6,i_4291,this.typer.typeInt,".Ident"],/*Ident*/[6,it_4292,this.typer.typeInt,".Ident"],null,".Assign"], /*Increment*/[14,/*Ident*/[6,it_4292,this.typer.typeInt,".Ident"],".Increment"], this.nodeToStatement(by_4287)],".Block"],true,".While"]],".Block"];
							}
						} break;
						
						default: 
						{
							const overType = this.typer.types.get(over_4286);
							const iteratorOverInt = overType == this.typer.typeInt || overType == this.typer.typeInt32 || overType == this.typer.typeUInt32 || overType == this.typer.typeInt8 || overType == this.typer.typeUInt8 || overType == this.typer.typeInt16 || overType == this.typer.typeUInt16 || overType == this.typer.typeInt64 || overType == this.typer.typeUInt64;
							if (iteratorOverInt) {
								const i_4293 = this.unique(name_4285, e_3993);
								const it_4294 = this.unique('it', null);
								const finish = this.unique('at', null);
								return /*Block*/[1,[/*Var*/[3,i_4293,/*Int*/[1,0,".Int"],overType,".Var"], /*Var*/[3,it_4294,/*Int*/[1,0,".Int"],overType,".Var"], /*Var*/[3,finish,this.nodeToExpression(over_4286),overType,".Var"], /*While*/[13,/*Binop*/[12,/*Ident*/[6,it_4294,overType,".Ident"],99,/*Ident*/[6,finish,overType,".Ident"],this.typer.typeBool,".Binop"],/*Block*/[1,[/*Assign*/[10,/*Ident*/[6,i_4293,overType,".Ident"],/*Ident*/[6,it_4294,overType,".Ident"],null,".Assign"], /*Increment*/[14,/*Ident*/[6,it_4294,overType,".Ident"],".Increment"], this.nodeToStatement(by_4287)],".Block"],true,".While"]],".Block"];
							};
						}
						};
					};
					{
						let step_4295 = 0;
						const range_4296 = range_4288;
						if (step_4295 == 0 && range_4296 != null) { step_4295 = 1 };
						if (step_4295 == 1) {
							const i_4297 = this.unique(name_4285, e_3993);
							const it_4298 = this.unique('it', null);
							const finish_4299 = this.unique('at', null);
							return /*Block*/[1,[/*Var*/[3,i_4297,/*Int*/[1,0,".Int"],this.typer.typeInt,".Var"], /*Var*/[3,it_4298,this.nodeToExpression(over_4286),this.typer.typeInt,".Var"], /*Var*/[3,finish_4299,this.nodeToExpression(range_4296),this.typer.typeInt,".Var"], /*While*/[13,/*Binop*/[12,/*Ident*/[6,it_4298,this.typer.typeInt,".Ident"],99,/*Ident*/[6,finish_4299,this.typer.typeInt,".Ident"],this.typer.typeBool,".Binop"],/*Block*/[1,[/*Assign*/[10,/*Ident*/[6,i_4297,this.typer.typeInt,".Ident"],/*Ident*/[6,it_4298,this.typer.typeInt,".Ident"],null,".Assign"], /*Increment*/[14,/*Ident*/[6,it_4298,this.typer.typeInt,".Ident"],".Increment"], this.nodeToStatement(by_4287)],".Block"],true,".While"]],".Block"];
						};
					};
					return /*For*/[12,name_4285,this.nodeToExpression(over_4286),this.nodeToStatement(by_4287),".For"];
				}
			} break;
			
			case 16: {
				const e_4300 = temp_3994[1];
				{
					if (e_4300 == null) { return /*Return*/[6,null,".Return"] };
					return /*Return*/[6,this.nodeToExpression(e_4300),".Return"];
				}
			} break;
			
			case 28: {
				const expr_4301 = temp_3994[1];
				const name_4302 = temp_3994[2];
				return /*Const*/[4,this.unique('temp', null),this.nodeToExpression(e_3993),this.typer.types.get(e_3993),".Const"]
			} break;
			
			case 29: {
				const expr_4303 = temp_3994[1];
				const name_4304 = temp_3994[2];
				return /*Const*/[4,this.unique('temp', null),this.nodeToExpression(e_3993),this.typer.types.get(e_3993),".Const"]
			} break;
			
			case 14: {
				const econd_4305 = temp_3994[1];
				const eif_4306 = temp_3994[2];
				const eelse_4307 = temp_3994[3];
				{
					let binds_4308 = false;
					for (const cond of $toIterator(econd_4305)) {
						const temp_4309 = cond;
						switch (temp_4309&&temp_4309[0]) {
						case 24: {
							binds_4308 = true
						} break;
						};
					};
					if (((!binds_4308)) && (econd_4305.length == 1)) {
						const value_4310 = this.nodeToExpression(this.unwrapParens(econd_4305[0]));
						const ei = this.nodeToStatement(eif_4306);
						const ee = this.nodeToStatement(eelse_4307);
						{
							const temp_4311 = value_4310;
							switch (temp_4311&&temp_4311[0]) {
							case 4: {
								return ei
							} break;
							
							case 5: {
								return ee
							} break;
							};
						};
						return /*If*/[7,value_4310,ei,ee,".If"];
					};
					if ((!binds_4308)) {
						let parens_4312 = /*Parenthesis*/[15,this.nodeToExpression(econd_4305[0]),".Parenthesis"];
						let i_4313 = 1;
						while (i_4313 < econd_4305.length) {
							parens_4312 = /*Binop*/[12,parens_4312,92,/*Parenthesis*/[15,this.nodeToExpression(econd_4305[i_4313]),".Parenthesis"],this.typer.typeBool,".Binop"];
							i_4313++;
						};
						return /*If*/[7,parens_4312,this.nodeToStatement(eif_4306),this.nodeToStatement(eelse_4307),".If"];
					};
					const block_4314 = [];
					let current = 0;
					const step_4315 = this.unique('step', null);
					block_4314.push(/*Var*/[3,step_4315,/*Int*/[1,0,".Int"],this.typer.typeInt,".Var"]);
					let nullable_4316 = false;
					let last = '';
					const lastType = this.typer.types.get(econd_4305[0]);
					{
						const temp_4317 = econd_4305[0];
						switch (temp_4317&&temp_4317[0]) {
						case 24: {
							const name_4318 = temp_4317[1];
							const t_4319 = temp_4317[2];
							const expr_4320 = temp_4317[3];
							const const_4321 = temp_4317[4];
							{
								last = this.unique(name_4318, econd_4305[0]);
								nullable_4316 = true;
								block_4314.push(/*Const*/[4,last,this.nodeToExpression(expr_4320),this.typer.types.get(econd_4305[0]),".Const"]);
							}
						} break;
						
						default: 
						{
							last = this.unique('temp', null);
							block_4314.push(/*Const*/[4,last,this.nodeToExpression(econd_4305[0]),this.typer.types.get(econd_4305[0]),".Const"]);
						}
						};
					};
					while (current < econd_4305.length - 1) {
						const temp_4322 = econd_4305[current + 1];
						switch (temp_4322&&temp_4322[0]) {
						case 24: {
							const vname = temp_4322[1];
							const t_4323 = temp_4322[2];
							const expr_4324 = temp_4322[3];
							const const_4325 = temp_4322[4];
							{
								const name_4326 = this.unique(vname, econd_4305[current + 1]);
								block_4314.push(/*Var*/[3,name_4326,/*Null*/[7,this.typer.types.get(expr_4324),".Null"],this.typer.types.get(expr_4324),".Var"]);
								block_4314.push(/*If*/[7,/*Binop*/[12,/*Binop*/[12,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],95,/*Int*/[1,current + 0,".Int"],this.typer.typeBool,".Binop"],92,/*Binop*/[12,/*Ident*/[6,last,lastType,".Ident"],103,((nullable_4316)? (/*Null*/[7,lastType,".Null"]) : /*False*/[5,".False"]),this.typer.typeBool,".Binop"],this.typer.typeBool,".Binop"],/*Block*/[1,[/*Assign*/[10,/*Ident*/[6,name_4326,this.typer.types.get(expr_4324),".Ident"],this.nodeToExpression(expr_4324),null,".Assign"], /*Assign*/[10,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],/*Int*/[1,current + 1,".Int"],null,".Assign"]],".Block"],null,".If"]);
								current++;
								last = name_4326;
								nullable_4316 = true;
							}
						} break;
						
						default: 
						{
							const next = this.unique('temp', null);
							const nextType = this.typer.types.get(econd_4305[current + 1]);
							block_4314.push(/*Var*/[3,next,/*Null*/[7,nextType,".Null"],nextType,".Var"]);
							block_4314.push(/*If*/[7,/*Binop*/[12,/*Binop*/[12,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],95,/*Int*/[1,current + 0,".Int"],this.typer.typeBool,".Binop"],92,/*Binop*/[12,/*Ident*/[6,last,lastType,".Ident"],103,((nullable_4316)? (/*Null*/[7,lastType,".Null"]) : /*False*/[5,".False"]),this.typer.typeBool,".Binop"],this.typer.typeBool,".Binop"],/*Block*/[1,[/*Assign*/[10,/*Ident*/[6,next,nextType,".Ident"],this.nodeToExpression(econd_4305[current + 1]),null,".Assign"], /*Assign*/[10,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],/*Int*/[1,current + 1,".Int"],null,".Assign"]],".Block"],null,".If"]);
							current++;
							last = next;
							nullable_4316 = false;
						}
						};
					};
					block_4314.push(/*If*/[7,/*Binop*/[12,/*Binop*/[12,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],95,/*Int*/[1,econd_4305.length - 1,".Int"],this.typer.typeBool,".Binop"],92,/*Binop*/[12,/*Ident*/[6,last,lastType,".Ident"],103,((nullable_4316)? (/*Null*/[7,lastType,".Null"]) : /*False*/[5,".False"]),this.typer.typeBool,".Binop"],this.typer.typeBool,".Binop"],/*Assign*/[10,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],/*Int*/[1,econd_4305.length,".Int"],null,".Assign"],null,".If"]);
					block_4314.push(/*If*/[7,/*Binop*/[12,/*Ident*/[6,step_4315,this.typer.typeInt,".Ident"],95,/*Int*/[1,econd_4305.length,".Int"],this.typer.typeBool,".Binop"],this.nodeToStatement(eif_4306),this.nodeToStatement(eelse_4307),".If"]);
					return /*Block*/[1,block_4314,".Block"];
				}
			} break;
			
			case 27: {
				const expr_4327 = temp_3994[1];
				const t_4328 = temp_3994[2];
				const v_4329 = temp_3994[3];
				const catches = temp_3994[4];
				{
					const temp_4330 = this.unique('temp', null);
					const tt = [];
					const vv = [];
					for (const c of $toIterator(v_4329)) {
						vv.push(DataHelper.nameOf(c));
					};
					const cc = [];
					for (const c of $toIterator(catches)) {
						cc.push(this.nodeToStatement(c));
					};
					for (const c of $toIterator(t_4328)) {
						tt.push(this.typer.types.get(c));
					};
					return /*Try*/[8,this.nodeToStatement(expr_4327),tt,vv,cc,temp_4330,".Try"];
				}
			} break;
			
			case 17: {
				const value_4331 = temp_3994[1];
				return /*Throw*/[9,this.nodeToExpression(value_4331),".Throw"]
			} break;
			
			case 11: {
				const a_4332 = temp_3994[1];
				const op_4333 = temp_3994[2];
				const b_4334 = temp_3994[3];
				{
					const source_4335 = this.typer.parents.get(a_4332);
					{
						let step_4336 = 0;
						const source_4337 = source_4335;
						if (step_4336 == 0 && source_4337 != null) { step_4336 = 1 };
						if (step_4336 == 1) {
							const temp_4338 = source_4337;
							switch (temp_4338&&temp_4338[0]) {
							case 24: {
								const name_4339 = temp_4338[1];
								this.neverReassignedLocal.set(source_4337, false)
							} break;
							};
						};
					};
					return /*Assignop*/[11,this.nodeToExpression(a_4332),op_4333,this.nodeToExpression(b_4334),".Assignop"];
				}
			} break;
			
			case 10: {
				const a_4340 = temp_3994[1];
				const op_4341 = temp_3994[2];
				const b_4342 = temp_3994[3];
				{
					const temp_4343 = op_4341;
					switch (temp_4343) {
					case 91: {
						{
							const source_4344 = this.typer.parents.get(a_4340);
							{
								let step_4345 = 0;
								const source_4346 = source_4344;
								if (step_4345 == 0 && source_4346 != null) { step_4345 = 1 };
								if (step_4345 == 1) {
									const temp_4347 = source_4346;
									switch (temp_4347&&temp_4347[0]) {
									case 24: {
										const name_4348 = temp_4347[1];
										this.neverReassignedLocal.set(source_4346, false)
									} break;
									};
								};
							};
							return /*Assign*/[10,this.nodeToExpression(a_4340),this.nodeToExpression(b_4342),null,".Assign"];
						}
					} break;
					
					default: 
					{
						const sa_4349 = this.nodeToStatement(a_4340);
						const sb_4350 = this.nodeToStatement(b_4342);
						if ((sa_4349 == null) && (sb_4350 == null)) { return null };
						if ((sa_4349 == null) || (sb_4350 == null)) { return (() => {
							const result_4351 = sa_4349;
							if (result_4351 != null) { return result_4351 };
							return sb_4350;
						})() };
						return /*Statements*/[0,[sa_4349, sb_4350],".Statements"];
					}
					};
				}
			} break;
			
			case 19: {
				return /*Continue*/[17,".Continue"]
			} break;
			
			case 18: {
				return /*Break*/[18,".Break"]
			} break;
			
			case 21: {
				const econd_4352 = temp_3994[1];
				const e_4353 = temp_3994[2];
				const pre = temp_3994[3];
				return /*While*/[13,this.nodeToExpression(econd_4352),this.nodeToStatement(e_4353),pre,".While"]
			} break;
			
			case 20: {
				const op_4354 = temp_3994[1];
				const postfix_4355 = temp_3994[2];
				const e_4356 = temp_3994[3];
				{
					{
						const temp_4357 = op_4354;
						switch (temp_4357) {
						case 87: case 86: {
							{
								const source_4358 = this.typer.parents.get(e_4356);
								{
									let step_4359 = 0;
									const source_4360 = source_4358;
									if (step_4359 == 0 && source_4360 != null) { step_4359 = 1 };
									if (step_4359 == 1) {
										const temp_4361 = source_4360;
										switch (temp_4361&&temp_4361[0]) {
										case 24: {
											const name_4362 = temp_4361[1];
											this.neverReassignedLocal.set(source_4360, false)
										} break;
										};
									};
								};
							}
						} break;
						};
					};
					{
						const temp_4363 = op_4354;
						switch (temp_4363) {
						case 87: {
							return /*Increment*/[14,this.nodeToExpression(e_4356),".Increment"]
						} break;
						
						case 86: {
							return /*Decrement*/[15,this.nodeToExpression(e_4356),".Decrement"]
						} break;
						
						default: 
						{
						}
						};
					};
				}
			} break;
			
			case 15: {
				const inner_4364 = temp_3994[1];
				return this.nodeToStatement(this.unwrapParens(inner_4364))
			} break;
			
			case 34: {
				const exprs_4365 = temp_3994[1];
				const conds_4366 = temp_3994[2];
				const guards_4367 = temp_3994[3];
				const cases_4368 = temp_3994[4];
				{
					if (exprs_4365.length > 1) { console.error('Multiple switch values not yet supported:', e_3993, this.project.data.get(e_3993)) };
					const s_4369 = [];
					const c_4370 = [];
					if (this.nativeEnums) {
						const index_4371 = this.nodeToExpression(exprs_4365[0]);
						{
							let i_4372 = 0;
							let it_4373 = 0;
							let at_4374 = cases_4368.length;
							while (it_4373 < at_4374) {
								i_4372 = it_4373;
								it_4373++;
								{
									const toCase = (co) => {
										const temp_4375 = co;
										switch (temp_4375&&temp_4375[0]) {
										case 8: {
											return /*Null*/[7,this.typer.typeAny,".Null"]
										} break;
										
										case 45: {
											return /*Underscore*/[30,".Underscore"]
										} break;
										
										case 0: {
											const v_4376 = temp_4375[1];
											return /*String*/[0,v_4376,".String"]
										} break;
										
										case 5: {
											const v_4377 = temp_4375[1];
											return /*Int*/[1,v_4377,".Int"]
										} break;
										
										case 7: {
											const v_4378 = temp_4375[1];
											return /*Float*/[3,v_4378,".Float"]
										} break;
										
										case 2: {
											const v_4379 = temp_4375[1];
											{
												if (v_4379) { return /*True*/[4,".True"] };
												return /*False*/[5,".False"];
											}
										} break;
										
										case 28: {
											const expr_4380 = temp_4375[1];
											const name_4381 = temp_4375[2];
											return /*Dot*/[9,this.nodeToExpression(expr_4380),name_4381,null,".Dot"]
										} break;
										
										case 29: {
											const expr_4382 = temp_4375[1];
											const name_4383 = temp_4375[2];
											return /*Dot*/[9,this.nodeToExpression(expr_4382),name_4383,null,".Dot"]
										} break;
										
										case 10: {
											const a_4384 = temp_4375[1];
											const op_4385 = temp_4375[2];
											const b_4386 = temp_4375[3];
											{
												const temp_4387 = op_4385;
												switch (temp_4387) {
												case 104: {
													return /*Binop*/[12,toCase(a_4384),104,toCase(b_4386),null,".Binop"]
												} break;
												
												default: 
												console.error('(internal warning) Unknown native case binop kind:', e_3993, this.typer.parents.get(e_3993))
												};
											}
										} break;
										
										case 13: {
											const e_4388 = temp_4375[1];
											const args_4389 = temp_4375[2];
											const argNames_4390 = temp_4375[3];
											{
												const temp_4391 = e_4388;
												switch (temp_4391&&temp_4391[0]) {
												case 29: {
													const expr_4392 = temp_4391[1];
													const name_4393 = temp_4391[2];
													{
														const a_4394 = [];
														{
															let arg_4395 = 0;
															let it_4396 = 0;
															let at_4397 = args_4389.length;
															while (it_4396 < at_4397) {
																arg_4395 = it_4396;
																it_4396++;
																{
																	const temp_4398 = args_4389[arg_4395];
																	switch (temp_4398&&temp_4398[0]) {
																	case 1: {
																		const name_4399 = temp_4398[1];
																		a_4394.push(/*Ident*/[6,this.unique(name_4399, args_4389[arg_4395]),null,".Ident"])
																	} break;
																	
																	case 45: {
																		a_4394.push(/*Underscore*/[30,".Underscore"])
																	} break;
																	
																	default: 
																	console.log('(internal warning) Unknown native case extract value kind:', args_4389[arg_4395])
																	};
																};
															};
														};
														return /*Call*/[10,this.nodeToExpression(e_4388),a_4394,null,11,".Call"];
													}
												} break;
												
												default: 
												console.error('(internal warning) Unknown case extract kind:', e_4388, this.typer.parents.get(e_4388))
												};
											}
										} break;
										
										default: 
										console.error('(internal warning) Unknown native enum case kind:', co, this.project.data.get(co))
										};
									};
									c_4370.push([toCase(conds_4366[i_4372])]);
									s_4369.push(this.nodeToStatement(cases_4368[i_4372]));
								};
							};
						};
						return /*Switch*/[16,index_4371,c_4370,s_4369,[],[],".Switch"];
					};
					const temp_4400 = this.unique('temp', null);
					const value_4401 = this.nodeToExpression(exprs_4365[0]);
					let index_4402 = /*Ident*/[6,temp_4400,this.typer.types.get(exprs_4365[0]),".Ident"];
					let promoted = false;
					let enumType = null;
					{
						const temp_4403 = Type.unwrapNullable(this.typer.types.get(exprs_4365[0]));
						switch (temp_4403&&temp_4403[0]) {
						case 8: {
							const type_4404 = temp_4403[1];
							{
								if (type_4404.fieldsTypeSimple == null) {
									index_4402 = /*EnumTag*/[27,index_4402,".EnumTag"];
									promoted = true;
								};
								enumType = type_4404;
							}
						} break;
						
						case 9: {
							const type_4405 = temp_4403[1];
							{
								if (type_4405.fieldsTypeSimple == null) {
									index_4402 = /*EnumTag*/[27,index_4402,".EnumTag"];
									promoted = true;
								};
								enumType = type_4405;
							}
						} break;
						};
					};
					let i_4406 = 0;
					const guardians = [];
					const binds_4407 = [];
					for (const ec of $toIterator(cases_4368)) {
						const block_4408 = [];
						const co_4409 = conds_4366[i_4406];
						const cx = [];
						const binders = [];
						binds_4407.push(binders);
						const addTag = (co_4410) => {
							const temp_4411 = co_4410;
							switch (temp_4411&&temp_4411[0]) {
							case 8: {
								cx.push(/*Null*/[7,".Null"])
							} break;
							
							case 45: {
								{
								}
							} break;
							
							case 0: {
								const v_4412 = temp_4411[1];
								cx.push(/*String*/[0,v_4412,".String"])
							} break;
							
							case 5: {
								const v_4413 = temp_4411[1];
								cx.push(/*Int*/[1,v_4413,".Int"])
							} break;
							
							case 7: {
								const v_4414 = temp_4411[1];
								cx.push(/*Float*/[3,v_4414,".Float"])
							} break;
							
							case 2: {
								const v_4415 = temp_4411[1];
								if (v_4415) { cx.push(/*True*/[4,".True"]) } else {
									cx.push(/*False*/[5,".False"]);
								}
							} break;
							
							case 13: {
								const e_4416 = temp_4411[1];
								const args_4417 = temp_4411[2];
								const argNames_4418 = temp_4411[3];
								{
									{
										const temp_4419 = e_4416;
										switch (temp_4419&&temp_4419[0]) {
										case 29: {
											const expr_4420 = temp_4419[1];
											const name_4421 = temp_4419[2];
											{
												const parent_4422 = this.typer.parents.get(expr_4420);
												const tag_4423 = this.getTag(parent_4422, name_4421);
												cx.push(tag_4423);
											}
										} break;
										
										case 51: {
											const t_4424 = temp_4419[1];
											{
												const temp_4425 = t_4424;
												switch (temp_4425&&temp_4425[0]) {
												case 1: {
													const name_4426 = temp_4425[1];
													{
														let step_4427 = 0;
														const enumType_4428 = enumType;
														if (step_4427 == 0 && enumType_4428 != null) { step_4427 = 1 };
														if (step_4427 == 1) { cx.push(this.getTag(enumType_4428.parent, name_4426)) };
													}
												} break;
												};
											}
										} break;
										
										default: 
										console.error('(internal warning) Unknown case extract kind:', e_4416, this.typer.parents.get(e_4416))
										};
									};
									if ((!promoted)) { index_4402 = /*EnumTag*/[27,index_4402,".EnumTag"] };
									promoted = true;
									{
										let arg_4429 = 0;
										let it_4430 = 0;
										let at_4431 = args_4417.length;
										while (it_4430 < at_4431) {
											arg_4429 = it_4430;
											it_4430++;
											{
												const temp_4432 = args_4417[arg_4429];
												switch (temp_4432&&temp_4432[0]) {
												case 1: {
													const name_4433 = temp_4432[1];
													binders.push(/*Const*/[4,this.unique(name_4433, args_4417[arg_4429]),/*EnumParameter*/[29,/*Ident*/[6,temp_4400,this.typer.types.get(args_4417[arg_4429]),".Ident"],arg_4429,".EnumParameter"],this.typer.types.get(args_4417[arg_4429]),".Const"])
												} break;
												
												case 45: {
													{
													}
												} break;
												
												case 46: {
													{
													}
												} break;
												
												default: 
												console.log('(internal warning) Unknown case extract value kind:', arg_4429)
												};
											};
										};
									};
								}
							} break;
							
							case 29: {
								const expr_4434 = temp_4411[1];
								const name_4435 = temp_4411[2];
								cx.push(this.getTag(this.typer.parents.get(expr_4434), name_4435))
							} break;
							
							case 10: {
								const a_4436 = temp_4411[1];
								const op_4437 = temp_4411[2];
								const b_4438 = temp_4411[3];
								{
									const temp_4439 = op_4437;
									switch (temp_4439) {
									case 104: {
										{
											addTag(a_4436);
											addTag(b_4438);
										}
									} break;
									
									default: 
									console.error('(internal warning) Unknown case binop kind:', e_3993, this.typer.parents.get(e_3993))
									};
								}
							} break;
							
							case 51: {
								const t_4440 = temp_4411[1];
								{
									const temp_4441 = t_4440;
									switch (temp_4441&&temp_4441[0]) {
									case 1: {
										const name_4442 = temp_4441[1];
										{
											{
												let step_4443 = 0;
												const enumType_4444 = enumType;
												if (step_4443 == 0 && enumType_4444 != null) { step_4443 = 1 };
												if (step_4443 == 1) {
													const tag_4445 = this.getTag(enumType_4444.parent, name_4442);
													cx.push(tag_4445);
												};
											};
											if (enumType == null) { console.log('null enumType for ' + name_4442) };
										}
									} break;
									};
								}
							} break;
							
							default: 
							console.error('(internal warning) Unknown case kind:', co_4410, this.project.data.get(co_4410))
							};
						};
						addTag(co_4409);
						c_4370.push(cx);
						block_4408.push(this.unwrapNestingBlocks(this.nodeToStatement(ec)));
						s_4369.push(this.unwrapNestingBlocks(/*Block*/[1,block_4408,".Block"]));
						{
							let step_4446 = 0;
							const guard = guards_4367[i_4406];
							if (step_4446 == 0 && guard != null) { step_4446 = 1 };
							if (step_4446 == 1) { guardians.push(this.nodeToExpression(guard)) } else {
								guardians.push(null);
							};
						};
						i_4406++;
					};
					if (this.typer.types.get(exprs_4365[0]) == null) { console.error(exprs_4365[0]) };
					return /*Block*/[1,[/*Const*/[4,temp_4400,value_4401,this.typer.types.get(exprs_4365[0]),".Const"], /*Switch*/[16,index_4402,c_4370,s_4369,guardians,binds_4407,".Switch"]],".Block"];
				}
			} break;
			
			case 33: {
				const v_4447 = temp_3994[1];
				const index_4448 = temp_3994[2];
				{
					this.project.hints.push(new Hint(10, ('Unused value of index `' + (Node.stringify(e_3993)) + '`'), this.project.data.get(e_3993)));
					{
						const temp_4449 = index_4448;
						switch (temp_4449&&temp_4449[0]) {
						case 0: {
							return this.nodeToStatement(v_4447)
						} break;
						
						case 5: {
							return this.nodeToStatement(v_4447)
						} break;
						
						case 2: {
							return this.nodeToStatement(v_4447)
						} break;
						
						case 7: {
							return this.nodeToStatement(v_4447)
						} break;
						};
					};
					return /*Statements*/[0,[this.nodeToStatement(v_4447), this.nodeToStatement(index_4448)],".Statements"];
				}
			} break;
			
			case 1: {
				const name_4450 = temp_3994[1];
				this.project.hints.push(new Hint(10, ('Unused value `' + (name_4450) + '`'), this.project.data.get(e_3993)))
			} break;
			
			case 23: {
				this.project.hints.push(new Hint(10, 'Unused arrow => function', this.project.data.get(e_3993)))
			} break;
			
			case 0: {
				const v_4451 = temp_3994[1];
				this.project.hints.push(new Hint(10, ('Unused string `\"' + (v_4451) + '\"`'), this.project.data.get(e_3993)))
			} break;
			
			case 2: {
				const v_4452 = temp_3994[1];
				this.project.hints.push(new Hint(10, ('Unused boolean `' + (v_4452) + '`'), this.project.data.get(e_3993)))
			} break;
			
			case 5: {
				const v_4453 = temp_3994[1];
				this.project.hints.push(new Hint(10, ('Unused number `' + (v_4453) + '`'), this.project.data.get(e_3993)))
			} break;
			
			case 7: {
				const v_4454 = temp_3994[1];
				this.project.hints.push(new Hint(10, ('Unused float `' + (v_4454) + '`'), this.project.data.get(e_3993)))
			} break;
			
			case 8: {
				this.project.hints.push(new Hint(10, 'Unused `null`', this.project.data.get(e_3993)))
			} break;
			
			case 35: {
				{
				}
			} break;
			
			case null: case undefined: {
				console.log('(internal warning) seems like null node passed to normalizer')
			} break;
			
			default: 
			return /*Const*/[4,this.unique('temp', null),this.nodeToExpression(e_3993),this.typer.types.get(e_3993),".Const"]
			};
		};
		return null;
	};
		getTag(enumNode, name_4455) {
		const temp_4456 = enumNode;
		switch (temp_4456&&temp_4456[0]) {
		case 39: {
			const t_4457 = temp_4456[1];
			const fields_4458 = temp_4456[2];
			const valuesType_4459 = temp_4456[3];
			{
				let typed = (null);
				{
					const temp_4460 = (this.typer.types.get(enumNode));
					switch (temp_4460&&temp_4460[0]) {
					case 8: {
						const type_4461 = temp_4460[1];
						typed = type_4461
					} break;
					};
				};
				let i_4462 = 0;
				for (const f of $toIterator(fields_4458)) {
					{
						const temp_4463 = f;
						switch (temp_4463&&temp_4463[0]) {
						case 51: {
							const t_4464 = temp_4463[1];
							{
								const temp_4465 = t_4464;
								switch (temp_4465&&temp_4465[0]) {
								case 1: {
									const n = temp_4465[1];
									{
										if (n == name_4455) { if (typed.fieldsTypeSimple == this.typer.typeString) { return /*String*/[0,n,".String"] } };
										if (n == name_4455) {
											const atts_4466 = this.project.mapDecorators.get(enumNode);
											{
												let step_4467 = 0;
												const rename_4468 = Decorator.getDecorator(atts_4466, 'castTo');
												if (step_4467 == 0 && rename_4468 != null) { step_4467 = 1 };
												if (step_4467 == 1) { return /*UnsafeBitCast*/[23,/*Int*/[1,i_4462,".Int"],this.typer.types.get(enumNode),".UnsafeBitCast"] };
											};
											return /*Int*/[1,i_4462,".Int"];
										};
									}
								} break;
								};
							}
						} break;
						
						case 13: {
							const e_4469 = temp_4463[1];
							{
								const temp_4470 = e_4469;
								switch (temp_4470&&temp_4470[0]) {
								case 51: {
									const t_4471 = temp_4470[1];
									{
										const temp_4472 = t_4471;
										switch (temp_4472&&temp_4472[0]) {
										case 1: {
											const n_4473 = temp_4472[1];
											if (n_4473 == name_4455) { return /*Int*/[1,i_4462,".Int"] }
										} break;
										};
									}
								} break;
								};
							}
						} break;
						
						case 10: {
							const a_4474 = temp_4463[1];
							const op_4475 = temp_4463[2];
							const b_4476 = temp_4463[3];
							{
								const temp_4477 = a_4474;
								switch (temp_4477&&temp_4477[0]) {
								case 51: {
									const t_4478 = temp_4477[1];
									{
										const temp_4479 = t_4478;
										switch (temp_4479&&temp_4479[0]) {
										case 1: {
											const n_4480 = temp_4479[1];
											if (n_4480 == name_4455) { return this.nodeToExpression(b_4476) }
										} break;
										};
									}
								} break;
								};
							}
						} break;
						
						case 47: {
							return null
						} break;
						
						default: 
						console.error('(internal warning) Unknown enum tag kind:', f)
						};
					};
					i_4462++;
				};
				throw ('Enum has no tag or field `' + (name_4455) + '` ') + t_4457;
			}
		} break;
		};
	};
		getNative(e_4481) {
		const atts_4482 = this.project.mapDecorators.get(e_4481);
		{
			let step_4483 = 0;
			const native_4484 = Decorator.getDecorator(atts_4482, 'rename');
			if (step_4483 == 0 && native_4484 != null) { step_4483 = 1 };
			if (step_4483 == 1) {
				const temp_4485 = native_4484.values[0];
				switch (temp_4485&&temp_4485[0]) {
				case 0: {
					const s_4486 = temp_4485[1];
					return s_4486
				} break;
				
				default: 
				throw '@rename takes string as argument'
				};
			};
		};
		return null;
	};
		pushScope() { this.scopes.push((new Map())) };
		popScope() { this.scopes.pop() };
		hasInScope(name_4487) {
		for (const scope of $toIterator(this.scopes)) {
			if (scope.get(name_4487) != null) { return true };
		};
		return false;
	};
		addToScope(name_4488) { this.scopes[this.scopes.length - 1].set(name_4488, true) };
		unique(name_4489, node) {
		let uname_4490 = name_4489;
		while (this.hasInScope(uname_4490) || (this.keywords.indexOf(uname_4490, 0) != (-1)) || (this.globals.indexOf(uname_4490, 0) != (-1))) {
			uname_4490 = (name_4489 + '_') + ((++this.id));
		};
		this.addToScope(uname_4490);
		if (node != null) { this.parentNames.set(node, uname_4490) };
		return uname_4490;
	};
		uniqueNative(name_4491, node_4492) {
		this.addToScope(name_4491);
		this.parentNames.set(node_4492, name_4491);
	};
		fillStatement(e_4493) { return this.nodeToStatement(e_4493) };
		renameClassFields(fields_4494, renaming) {
		this.pushScope();
		for (const f of $toIterator(fields_4494)) {
			const temp_4495 = f;
			switch (temp_4495&&temp_4495[0]) {
			case 24: {
				const name_4496 = temp_4495[1];
				const t_4497 = temp_4495[2];
				const expr_4498 = temp_4495[3];
				const const_4499 = temp_4495[4];
				{
					const atts_4500 = this.project.mapDecorators.get(f);
					const renamingStrategy = (() => {
						const result_4501 = getRenamingStrategy(atts_4500);
						if (result_4501 != null) { return result_4501 };
						return renaming;
					})();
					if (name_4496 == 'key') {};
					{
						let step_4502 = 0;
						const native_4503 = Decorator.getDecorator(atts_4500, 'rename');
						if (step_4502 == 0 && native_4503 != null) { step_4502 = 1 };
						if (step_4502 == 1) {
							const temp_4504 = native_4503.values[0];
							switch (temp_4504&&temp_4504[0]) {
							case 0: {
								const s_4505 = temp_4504[1];
								if (this.parentNames.get(f) == null) { this.unique(s_4505, f) }
							} break;
							
							default: 
							throw '@rename takes string as argument'
							};
						} else {
							if (this.parentNames.get(f) == null) {
								const temp_4506 = renamingStrategy;
								switch (temp_4506) {
								case 0: {
									this.unique(Hint.toTitleCase(name_4496), f)
								} break;
								
								case 1: {
									this.unique(name_4496, f)
								} break;
								
								case null: case undefined: {
									this.unique(name_4496, f)
								} break;
								};
							};
						};
					};
				}
			} break;
			
			case 22: {
				const name_4507 = temp_4495[1];
				const expr_4508 = temp_4495[2];
				const vars_4509 = temp_4495[3];
				const rettype_4510 = temp_4495[4];
				if (name_4507 == 'new') { this.parentNames.set(f, 'new') } else {
					const atts_4511 = this.project.mapDecorators.get(f);
					{
						let step_4512 = 0;
						const native_4513 = Decorator.getDecorator(atts_4511, 'rename');
						if (step_4512 == 0 && native_4513 != null) { step_4512 = 1 };
						if (step_4512 == 1) {
							const temp_4514 = native_4513.values[0];
							switch (temp_4514&&temp_4514[0]) {
							case 0: {
								const s_4515 = temp_4514[1];
								if (this.parentNames.get(f) == null) { this.unique(s_4515, f) }
							} break;
							
							default: 
							throw '@rename takes string as argument'
							};
						} else if (this.parentNames.get(f) == null) { this.unique(name_4507, f) };
					};
				}
			} break;
			
			case 47: {
				const field_4516 = temp_4495[1];
				{
					const temp_4517 = field_4516;
					switch (temp_4517&&temp_4517[0]) {
					case 24: {
						const name_4518 = temp_4517[1];
						const t_4519 = temp_4517[2];
						const expr_4520 = temp_4517[3];
						const const_4521 = temp_4517[4];
						{
							const atts_4522 = this.project.mapDecorators.get(f);
							{
								let step_4523 = 0;
								const native_4524 = Decorator.getDecorator(atts_4522, 'rename');
								if (step_4523 == 0 && native_4524 != null) { step_4523 = 1 };
								if (step_4523 == 1) {
									const temp_4525 = native_4524.values[0];
									switch (temp_4525&&temp_4525[0]) {
									case 0: {
										const s_4526 = temp_4525[1];
										if (this.parentNames.get(field_4516) == null) { this.unique(s_4526, field_4516) }
									} break;
									
									default: 
									throw '@rename takes string as argument'
									};
								} else if (this.parentNames.get(field_4516) == null) { this.unique(name_4518, field_4516) };
							};
						}
					} break;
					
					case 22: {
						const name_4527 = temp_4517[1];
						const expr_4528 = temp_4517[2];
						const vars_4529 = temp_4517[3];
						const rettype_4530 = temp_4517[4];
						{
							const atts_4531 = this.project.mapDecorators.get(f);
							{
								let step_4532 = 0;
								const native_4533 = Decorator.getDecorator(atts_4531, 'rename');
								if (step_4532 == 0 && native_4533 != null) { step_4532 = 1 };
								if (step_4532 == 1) {
									const temp_4534 = native_4533.values[0];
									switch (temp_4534&&temp_4534[0]) {
									case 0: {
										const s_4535 = temp_4534[1];
										if (this.parentNames.get(field_4516) == null) { this.unique(s_4535, field_4516) }
									} break;
									
									default: 
									throw '@rename takes string as argument'
									};
								} else if (this.parentNames.get(field_4516) == null) { this.unique(name_4527, field_4516) };
							};
						}
					} break;
					};
				}
			} break;
			};
		};
		this.popScope();
	};
		getClassDotField(expr_4536, name_4537) {
		{
			let step_4538 = 0;
			const type_4539 = this.typer.types.get(expr_4536);
			if (step_4538 == 0 && type_4539 != null) { step_4538 = 1 };
			if (step_4538 == 1) {
				const temp_4540 = (type_4539);
				switch (temp_4540&&temp_4540[0]) {
				case 5: {
					const type_4541 = temp_4540[1];
					{
						const renamed_4542 = type_4541.fieldRenames[type_4541.fieldNames.indexOf(name_4537, 0)];
						{
							let step_4543 = 0;
							const rename_4544 = renamed_4542;
							if (step_4543 == 0 && rename_4544 != null) { step_4543 = 1 };
							if (step_4543 == 1) { return rename_4544 };
						};
					}
				} break;
				
				default: 
				{
				}
				};
			};
		};
		{
			const temp_4545 = expr_4536;
			switch (temp_4545&&temp_4545[0]) {
			case 25: {
				const t_4546 = temp_4545[1];
				const ext_4547 = temp_4545[2];
				const impl_4548 = temp_4545[3];
				const fields_4549 = temp_4545[4];
				const external_4550 = temp_4545[5];
				for (const f of $toIterator(fields_4549)) {
					const temp_4551 = f;
					switch (temp_4551&&temp_4551[0]) {
					case 47: {
						const sf = temp_4551[1];
						if (DataHelper.nameOf(sf) == name_4537) { return (() => {
							const result_4552 = this.parentNames.get(sf);
							if (result_4552 != null) { return result_4552 };
							return name_4537;
						})() }
					} break;
					
					case 24: {
						const n_4553 = temp_4551[1];
						if (n_4553 == name_4537) { return ((() => {
							const result_4554 = this.parentNames.get(f);
							if (result_4554 != null) { return result_4554 };
							return name_4537;
						})()) }
					} break;
					};
				}
			} break;
			
			case 39: {
				const t_4555 = temp_4545[1];
				const fields_4556 = temp_4545[2];
				const valuesType_4557 = temp_4545[3];
				for (const f of $toIterator(fields_4556)) {
					const temp_4558 = f;
					switch (temp_4558&&temp_4558[0]) {
					case 47: {
						const sf_4559 = temp_4558[1];
						if (DataHelper.nameOf(sf_4559) == name_4537) { return (() => {
							const result_4560 = this.parentNames.get(sf_4559);
							if (result_4560 != null) { return result_4560 };
							return name_4537;
						})() }
					} break;
					};
				}
			} break;
			};
		};
		return null;
	};
		unwrapNestingBlocks(block_4561) {
		const temp_4562 = block_4561;
		switch (temp_4562&&temp_4562[0]) {
		case 1: {
			const el_4563 = temp_4562[1];
			{
				if (el_4563.length == 1) { return this.unwrapNestingBlocks(el_4563[0]) };
				return block_4561;
			}
		} break;
		
		default: 
		return block_4561
		};
	};
		saveInlineIfViable(e_4564, value_4565) {
		const temp_4566 = value_4565;
		switch (temp_4566&&temp_4566[0]) {
		case 1: {
			this.inline.set(e_4564, value_4565)
		} break;
		
		case 2: {
			this.inline.set(e_4564, value_4565)
		} break;
		
		case 0: {
			this.inline.set(e_4564, value_4565)
		} break;
		
		case 3: {
			this.inline.set(e_4564, value_4565)
		} break;
		
		case 4: {
			this.inline.set(e_4564, value_4565)
		} break;
		
		case 5: {
			this.inline.set(e_4564, value_4565)
		} break;
		
		case 7: {
			this.inline.set(e_4564, value_4565)
		} break;
		};
	};
		unwrapParens(inner_4567) {
		const temp_4568 = inner_4567;
		switch (temp_4568&&temp_4568[0]) {
		case 15: {
			const i_4569 = temp_4568[1];
			return this.unwrapParens(i_4569)
		} break;
		
		default: 
		return inner_4567
		};
	};
	}
	var Typer = class {
		constructor(project) { 
			this.onlyTypeCheck = false
			this.expectedArrowType = new Map()
			this.failures = []
			this.currentModule = new Module()
			this.scopes = [new Map()]
			this.scopeTypes = [new Map()]
			this.parents = new Map()
			this.types = new Map()
			this.typeString = null
			this.typeIntClass = new ClassType()
			this.typeInt = this.typeIntClass.instantiate()
			this.typeBool = null
			this.typeArray = new ClassType()
			this.typeMap = (null)
			this.typeAnyClass = new ClassType()
			this.typeAny = this.typeAnyClass.instantiate()
			this.nodeAny = null
			this.typeVoid = null
			this.namespaces = new Map()
			this.currentlyInstantiating = null
			this.currentlyInstantiatingParams = null
			this.typeBigInt = null
			this.typeInt32 = null
			this.typeInt64 = null
			this.typeInt16 = null
			this.typeInt8 = null
			this.typeUInt32 = null
			this.typeUInt64 = null
			this.typeNullUInt64 = null
			this.typeUInt16 = null
			this.typeUInt8 = null
			this.typeFloat = null
			this.typeNullFloat = null
			this.typeFloat32 = null
			this.typeNullFloat32 = null
			this.functionAllowedToThrow = false
			this.functionThrows = false
			this.insideTry = false
			this.insideFunction = false
			this.allowBreakAndContinue = false
			this.functionReturnsAType = null
			this.functionActuallyReturns = false
			this.insideClassMethod = false
			this.allowSuper = false
			this.thisType = (null)
			this.thisNode = (null)
			this.nullables = new Map()
		this.project = project };
		fillModules() {
		const checkOverrides = (info, name, e) => {
			if (info.exported.has(name)) { this.fail(('Module `' + (info.path) + '` already exports name `' + (name) + '`'), e) };
			if (info.imported.has(name)) { this.fail(('Module `' + (info.path) + '` already imports name `' + (name) + '`'), e) };
		};
		for (const info of $toIterator(this.project.moduleInfo)) {
			const nodes = info.nodes;
			for (const e of $toIterator(nodes)) {
				let named = true;
				{
					const temp = e;
					switch (temp&&temp[0]) {
					case 24: {
						{
						}
					} break;
					
					case 39: {
						{
						}
					} break;
					
					case 22: {
						{
						}
					} break;
					
					case 25: {
						{
						}
					} break;
					
					case 9: {
						{
						}
					} break;
					
					default: 
					named = false
					};
				};
				if (named) {
					const name_4570 = DataHelper.nameOf(e);
					checkOverrides(info, name_4570, e);
					info.exported.set(name_4570, e);
					this.project.mapModules.set(e, info);
				};
			};
		};
		for (const info of $toIterator(this.project.moduleInfo)) {
			const nodes_4571 = info.nodes;
			this.pushScope();
			let doneImports = false;
			for (const e of $toIterator(nodes_4571)) {
				const named_4572 = true;
				let lastOne = nodes_4571[0];
				{
					const temp_4573 = e;
					switch (temp_4573&&temp_4573[0]) {
					case 37: {
						const els = temp_4573[1];
						const path = temp_4573[2];
						{
							if (doneImports) { this.fail('Imports should follow before expressions\n' + this.positionOf(lastOne) + 'Expression is here', e) };
							const index = this.project.mapModules.get(e);
							if (index == null) { this.fail('Cannot import ' + path, e) };
							const importAs = (name_4574, to) => {
								let step = 0;
								const target = index;
								if (step == 0 && target != null) { step = 1 };
								if (step == 1) { if (name_4574 == '*') { info.imported.set(to, /*ModuleExports*/[36,target,".ModuleExports"]) } else {
									let step_4575 = 0;
									const what = target.exported.get(name_4574);
									if (step_4575 == 0 && what != null) { step_4575 = 1 };
									if (step_4575 == 1) {
										checkOverrides(info, to, e);
										info.imported.set(to, what);
									} else {
										let has = (() => {
											const result = [];
											const value = target.exported.keys();
											for (const key of $toIterator(value)) result.push(key);
											return result;
										})().join(', ');
										if (has == '') { has = 'module is empty' };
										this.fail(('Module `' + (path) + '` does not export `' + (name_4574) + '`\nAvailable exports: ' + (has) + ''), e);
									};
								} };
							};
							if (els.length == 0) {
								let step_4576 = 0;
								const target_4577 = index;
								if (step_4576 == 0 && target_4577 != null) { step_4576 = 1 };
								if (step_4576 == 1) { for (const key of $toIterator(target_4577.exported.keys())) {
									info.imported.set(key, target_4577.exported.get(key));
								} };
							};
							for (const el of $toIterator(els)) {
								const temp_4578 = el;
								switch (temp_4578&&temp_4578[0]) {
								case 0: {
									const name_4579 = temp_4578[1];
									importAs(name_4579, name_4579)
								} break;
								
								case 1: {
									const name_4580 = temp_4578[1];
									importAs(name_4580, name_4580)
								} break;
								
								case 3: {
									const left = temp_4578[1];
									const right = temp_4578[2];
									{
										let lhs = '';
										{
											const temp_4581 = left;
											switch (temp_4581&&temp_4581[0]) {
											case 0: {
												const name_4582 = temp_4581[1];
												lhs = name_4582
											} break;
											
											case 1: {
												const name_4583 = temp_4581[1];
												lhs = name_4583
											} break;
											
											case 2: {
												lhs = '*'
											} break;
											
											default: 
											this.fail('This `import ??? as` kind not implemented yet or syntax is incorrect', e)
											};
										};
										{
											const temp_4584 = right;
											switch (temp_4584&&temp_4584[0]) {
											case 0: {
												const name_4585 = temp_4584[1];
												importAs(lhs, name_4585)
											} break;
											
											case 1: {
												const name_4586 = temp_4584[1];
												importAs(lhs, name_4586)
											} break;
											
											default: 
											this.fail(('This `import ' + (lhs) + ' as ???` kind not implemented yet or syntax is incorrect'), e)
											};
										};
									}
								} break;
								
								default: 
								this.fail('This import kind not implemented yet', e)
								};
							};
						}
					} break;
					
					default: 
					{
						lastOne = e;
						doneImports = true;
						const node = e;
						if (this.currentModule != info) {};
						this.currentModule = info;
						{
							const temp_4587 = node;
							switch (temp_4587&&temp_4587[0]) {
							case 25: {
								{
									this.parents.set(node, e);
									this.fillModuleTypes(node, null, null);
								}
							} break;
							
							case 39: {
								{
									this.parents.set(node, e);
									this.fillModuleTypes(node, null, null);
								}
							} break;
							
							case 9: {
								{
									this.parents.set(node, e);
									this.fillModuleTypes(node, null, null);
								}
							} break;
							
							case 22: {
								const name_4588 = temp_4587[1];
								const expr = temp_4587[2];
								const vars = temp_4587[3];
								const rettype = temp_4587[4];
								const variadic = temp_4587[6];
								{
									let step_4589 = 0;
									const rettype_4590 = rettype;
									if (step_4589 == 0 && rettype_4590 != null) { step_4589 = 1 };
									if (step_4589 == 1) {
										this.pushFuncParamsIfRequired(node);
										this.types.set(node, /*Function*/[12,this.varTypes(vars),this.toType(rettype_4590, node),variadic,".Function"]);
										this.popFuncParamsIfRequired(node);
									};
								}
							} break;
							
							case 24: {
								const name_4591 = temp_4587[1];
								const t = temp_4587[2];
								const e_4592 = temp_4587[3];
								const const_4593 = temp_4587[4];
								{
									let step_4594 = 0;
									const t_4595 = t;
									if (step_4594 == 0 && t_4595 != null) { step_4594 = 1 };
									if (step_4594 == 1) { this.types.set(node, this.toType(t_4595, node)) };
								}
							} break;
							
							default: 
							{
							}
							};
						};
					}
					};
				};
			};
		};
		const doNotInstantiate = ['ConstArrayPointer', 'ArrayPointer', 'ArrayByValue'];
		for (const info of $toIterator(this.project.moduleInfo)) {
			const nodes_4596 = info.nodes;
			const self = /*Module*/[35,info.path,info.nodes,".Module"];
			this.pushScope();
			this.currentModule = info;
			for (const node of $toIterator(nodes_4596)) {
				const temp_4597 = node;
				switch (temp_4597&&temp_4597[0]) {
				case 37: {
					{
					}
				} break;
				
				case 25: {
					{
					}
				} break;
				
				case 9: {
					{
					}
				} break;
				
				case 39: {
					{
					}
				} break;
				
				default: 
				{
					{
						const temp_4598 = node;
						switch (temp_4598&&temp_4598[0]) {
						case 22: {
							const name_4599 = temp_4598[1];
							{
							}
						} break;
						};
					};
					this.parents.set(node, self);
					this.fill(node);
				}
				};
			};
			this.popScope();
		};
		for (const info of $toIterator(this.project.moduleInfo)) {
			const nodes_4600 = info.nodes;
			const self_4601 = /*Module*/[35,info.path,info.nodes,".Module"];
			this.pushScope();
			this.currentModule = info;
			for (const node of $toIterator(nodes_4600)) {
				const temp_4602 = node;
				switch (temp_4602&&temp_4602[0]) {
				case 37: {
					{
					}
				} break;
				
				case 25: {
					{
						const temp_4603 = (this.types.get(node));
						switch (temp_4603&&temp_4603[0]) {
						case 5: {
							const classType = temp_4603[1];
							if (classType.genericCache.length > 0) {
								const nullables = new Map();
								const unwrap = (type) => {
									{
										const temp_4604 = (type);
										switch (temp_4604&&temp_4604[0]) {
										case 2: {
											const handle = temp_4604[1];
											return unwrap(handle.value)
										} break;
										
										case 3: {
											const handle_4605 = temp_4604[1];
											return unwrap(this.asNullable(handle_4605.value))
										} break;
										
										case 4: {
											const t_4606 = temp_4604[1];
											{
												const type_4607 = unwrap(t_4606);
												if (type_4607 == null) { return null };
												{
													let step_4608 = 0;
													const nullable = nullables.get(type_4607);
													if (step_4608 == 0 && nullable != null) { step_4608 = 1 };
													if (step_4608 == 1) { return nullable };
												};
												const rewrapped = this.asNullable(this.unwrapUnknownAndNullable(type_4607));
												nullables.set(type_4607, rewrapped);
												return rewrapped;
											}
										} break;
										
										case 1: {
											return null
										} break;
										
										default: 
										{
										}
										};
									};
									return type;
								};
								const indexOf = (type_4609, types) => {
									{
										let i = 0;
										let it = 0;
										let at = types.length;
										while (it < at) {
											i = it;
											it++;
											{
												let found = 0;
												{
													let t_4610 = 0;
													let it_4611 = 0;
													let at_4612 = types[i].length;
													while (it_4611 < at_4612) {
														t_4610 = it_4611;
														it_4611++;
														{
															if (types[i][t_4610] == type_4609[t_4610]) { found++ };
														};
													};
												};
												if (found == types[i].length) { return i };
											};
										};
									};
									return (-1);
								};
								const genericCache = classType.genericCache.map((knownParams) => {
									const known_4614 = knownParams.slice(0, 1073741824);
									known_4614.shift();
									return known_4614.map(unwrap);
								}).filter((known) => ((!((known)).includes(null)))).filter((item, pos, self_4613) => (indexOf(item, self_4613) == pos));
								for (const knownParams of $toIterator(genericCache)) {
									const known_4615 = knownParams;
									const cloned = Node.clone(this.project, node);
									let type_4616 = (null);
									{
										const temp_4617 = (known_4615[0]);
										switch (temp_4617&&temp_4617[0]) {
										case 2: {
											const handle_4618 = temp_4617[1];
											type_4616 = handle_4618.value
										} break;
										
										case 3: {
											const handle_4619 = temp_4617[1];
											type_4616 = handle_4619.value
										} break;
										
										case 1: {
											{
											}
										} break;
										
										default: 
										type_4616 = known_4615[0]
										};
									};
									if (type_4616 == null) {} else {
										this.parents.set(cloned, cloned);
										if (known_4615[0] == null) {
											console.log('bad', known_4615);
											throw known_4615;
										};
										this.currentlyInstantiatingParams = known_4615;
										this.currentlyInstantiating = cloned;
										const delayed = (node_4620, known_4621, classType_4622) => {
											const cloned_4623 = Node.clone(this.project, node_4620);
											this.parents.set(cloned_4623, cloned_4623);
											const _currentlyInstantiatingParams = this.currentlyInstantiatingParams;
											const _currentlyInstantiating = this.currentlyInstantiating;
											this.currentlyInstantiatingParams = known_4621;
											this.currentlyInstantiating = cloned_4623;
											let type_4624 = (null);
											{
												const temp_4625 = (known_4621[0]);
												switch (temp_4625&&temp_4625[0]) {
												case 2: {
													const handle_4626 = temp_4625[1];
													type_4624 = handle_4626.value
												} break;
												
												case 3: {
													const handle_4627 = temp_4625[1];
													type_4624 = handle_4627.value
												} break;
												
												case 1: {
													{
													}
												} break;
												
												default: 
												type_4624 = known_4621[0]
												};
											};
											if (type_4624 != null) {
												this.fillModuleTypes(cloned_4623, known_4621, classType_4622);
												if (classType_4622.parent == null) { throw classType_4622.name };
											} else {
											};
											this.currentlyInstantiatingParams = _currentlyInstantiatingParams;
											this.currentlyInstantiating = _currentlyInstantiating;
										};
										if ((!this.onlyTypeCheck)) {
											Typer.delayedInstance = delayed;
											this.fillModuleTypes(cloned, known_4615, classType);
										} else {
											Typer.delayedInstance = null;
										};
									};
								};
							}
						} break;
						};
					}
				} break;
				
				case 9: {
					{
					}
				} break;
				
				case 39: {
					{
					}
				} break;
				
				default: 
				{
				}
				};
			};
			this.popScope();
		};
		if (this.failures.length > 0) {
			const errors = this.failures.slice(0, 1073741824);
			this.failures = [];
			throw new CompilerErrors(errors);
		};
	};
		find(name_4628) {
		let subj = null;
		{
			let i_4629 = 0;
			let it_4630 = 0;
			let at_4631 = this.scopes.length;
			while (it_4630 < at_4631) {
				i_4629 = it_4630;
				it_4630++;
				{
					subj = this.scopes[this.scopes.length - i_4629 - 1].get(name_4628);
					if (subj != null) { break };
				};
			};
		};
		if (subj == null) { subj = this.findInNamespaceRoots(name_4628) };
		return subj;
	};
		proposeSimilar(names, subject, what_4632, similarTo) {
		if (names.length == 0) { return ('No ' + (what_4632) + ' available for access') };
		{
			let step_4633 = 0;
			const similarTo_4634 = similarTo;
			if (step_4633 == 0 && similarTo_4634 != null) { step_4633 = 1 };
			if (step_4633 == 1) {
				const firstLetter = similarTo_4634.charAt(0);
				names.sort((left_4635, right_4636) => (((left_4635.startsWith(firstLetter) || left_4635.includes(similarTo_4634))? ((-1)) : 0)));
			};
		};
		const ten = ((names.length > 11)? (names.slice(0, 10).join(', ') + ' and ' + (names.length - 10) + ' more ' + what_4632) : names.join(', '));
		const available = ('Available ' + (what_4632) + ' are: ') + ten;
		const subject_4637 = subject.toLowerCase();
		const charSubj = subject_4637.split('');
		let bestValue = 0;
		let bestName = '';
		for (const name of $toIterator(names)) {
			const named_4638 = name.toLowerCase();
			if (named_4638.startsWith(subject_4637) || subject_4637.startsWith(named_4638) || named_4638.endsWith(subject_4637)) { return ('Did you mean `' + (name) + '`?\n\n') + available };
			let index_4639 = 0;
			let thisValue = 0;
			for (const char of $toIterator(named_4638.split(''))) {
				if (char == charSubj[index_4639]) { thisValue++ };
				index_4639++;
			};
			if (thisValue > bestValue) {
				bestValue = thisValue;
				bestName = name;
			};
		};
		if (bestValue > 2) { return ('Did you mean `' + (bestName) + '`?\n\n') + available };
		return available;
	};
		registerClassType(node_4640, callback, params, instanceOf) {
		const mod = this.currentModule;
		this.currentModule = (() => {
			const result_4641 = this.project.mapModules.get(node_4640);
			if (result_4641 != null) { return result_4641 };
			return mod;
		})();
		const registered = this.registerClassTypeWrapped(node_4640, callback, params, instanceOf);
		this.currentModule = mod;
		return registered;
	};
		registerClassTypeWrapped(node_4642, callback_4643, knownParams_4644, instanceOf_4645) {
		let step_4646 = 0;
		const type_4647 = this.types.get(node_4642);
		if (step_4646 == 0 && type_4647 != null) { step_4646 = 1 };
		if (step_4646 == 1) {
			const temp_4648 = (type_4647);
			switch (temp_4648&&temp_4648[0]) {
			case 5: {
				const t_4649 = temp_4648[1];
				{
					{
						let step_4650 = 0;
						const setup = callback_4643;
						if (step_4650 == 0 && setup != null) { step_4650 = 1 };
						if (step_4650 == 1) { setup(t_4649) };
					};
					return t_4649;
				}
			} break;
			};
		} else {
			const typeName = DataHelper.nameOf(node_4642);
			const type_4651 = (() => {
				const temp_4652 = typeName;
				switch (temp_4652) {
				case 'Int': {
					return this.typeIntClass
				} break;
				
				case 'Array': {
					return ((knownParams_4644 != null)? (new ClassType()) : this.typeArray)
				} break;
				
				case 'Any': {
					return this.typeAnyClass
				} break;
				
				default: 
				return new ClassType()
				};
			})();
			const _thisType = this.thisType;
			const _thisNode = this.thisNode;
			this.thisType = ((knownParams_4644 != null)? (type_4651.instantiateGeneric(knownParams_4644)) : type_4651.instantiate());
			this.thisNode = node_4642;
			type_4651.parent = node_4642;
			type_4651.name = typeName;
			{
				let step_4653 = 0;
				const instanceOf_4654 = instanceOf_4645;
				let temp_4655 = null;
				if (step_4653 == 0 && instanceOf_4654 != null) {
					temp_4655 = knownParams_4644 != null;
					step_4653 = 1;
				};
				if (step_4653 == 1 && temp_4655 != false) { step_4653 = 2 };
				if (step_4653 == 2) {
					type_4651.instanceOf = instanceOf_4654;
					type_4651.instanceParams = knownParams_4644;
					instanceOf_4654.instances.push(type_4651);
				};
			};
			this.types.set(node_4642, /*Class*/[5,type_4651,".Class"]);
			{
				let step_4656 = 0;
				const setup_4657 = callback_4643;
				if (step_4656 == 0 && setup_4657 != null) { step_4656 = 1 };
				if (step_4656 == 1) { setup_4657(type_4651) };
			};
			{
				const temp_4658 = type_4651.name;
				switch (temp_4658) {
				case 'Int': {
					{
					}
				} break;
				
				case 'Bool': {
					this.typeBool = type_4651.instantiate()
				} break;
				
				case 'Float': {
					{
						this.typeFloat = type_4651.instantiate();
						this.typeNullFloat = this.asNullable(this.typeFloat);
					}
				} break;
				
				case 'Float32': {
					{
						this.typeFloat32 = type_4651.instantiate();
						this.typeNullFloat32 = this.asNullable(this.typeFloat32);
					}
				} break;
				
				case 'String': {
					this.typeString = type_4651.instantiate()
				} break;
				
				case 'Array': {
					if (knownParams_4644 == null) { this.typeArray = type_4651 }
				} break;
				
				case 'Map': {
					if (knownParams_4644 == null) { this.typeMap = type_4651 }
				} break;
				
				case 'Any': {
					this.nodeAny = node_4642
				} break;
				
				case 'Void': {
					this.typeVoid = type_4651.instantiate()
				} break;
				
				case 'UInt8': {
					this.typeUInt8 = type_4651.instantiate()
				} break;
				
				case 'UInt16': {
					this.typeUInt16 = type_4651.instantiate()
				} break;
				
				case 'UInt32': {
					this.typeUInt32 = type_4651.instantiate()
				} break;
				
				case 'UInt64': {
					{
						this.typeUInt64 = type_4651.instantiate();
						this.typeNullUInt64 = this.asNullable(this.typeUInt64);
					}
				} break;
				
				case 'Int8': {
					this.typeInt8 = type_4651.instantiate()
				} break;
				
				case 'Int16': {
					this.typeInt16 = type_4651.instantiate()
				} break;
				
				case 'Int32': {
					this.typeInt32 = type_4651.instantiate()
				} break;
				
				case 'Int64': {
					this.typeInt64 = type_4651.instantiate()
				} break;
				
				case 'BigInt': {
					this.typeBigInt = type_4651.instantiate()
				} break;
				};
			};
			const classDecorators = this.project.mapDecorators.get(node_4642);
			const getRename = (f, name_4659, globalDecorators) => {
				const atts = this.project.mapDecorators.get(f);
				const renamingStrategy = (() => {
					const result_4660 = getRenamingStrategy(atts);
					if (result_4660 != null) { return result_4660 };
					return getRenamingStrategy(globalDecorators);
				})();
				{
					let step_4661 = 0;
					const native = DataHelper.getDecorator(atts, 'rename');
					if (step_4661 == 0 && native != null) { step_4661 = 1 };
					if (step_4661 == 1) {
						if (native.values.length != 1) { throw '@rename takes one string argument' };
						if (native != null) {
							const temp_4662 = native.values[0];
							switch (temp_4662&&temp_4662[0]) {
							case 0: {
								const s = temp_4662[1];
								return s
							} break;
							
							default: 
							throw '@rename takes string as argument'
							};
						};
					} else {
						const temp_4663 = renamingStrategy;
						switch (temp_4663) {
						case 0: {
							return Hint.toTitleCase(name_4659)
						} break;
						
						case 1: {
							return name_4659
						} break;
						
						case null: case undefined: {
							{
							}
						} break;
						};
					};
				};
				return null;
			};
			{
				const temp_4664 = node_4642;
				switch (temp_4664&&temp_4664[0]) {
				case 25: {
					const t_4665 = temp_4664[1];
					const extend = temp_4664[2];
					const implement = temp_4664[3];
					const f_4666 = temp_4664[4];
					const external = temp_4664[5];
					const kind = temp_4664[6];
					{
						type_4651.kind = kind;
						type_4651.external = external;
						{
							const temp_4667 = t_4665;
							switch (temp_4667&&temp_4667[0]) {
							case 2: {
								const name_4668 = temp_4667[1];
								const params_4669 = temp_4667[2];
								{
									type_4651.genericParams.push(DataHelper.extractTypeName(params_4669[0]));
									const names_4670 = type_4651.genericParams;
									{
										let i_4671 = 0;
										let it_4672 = 1;
										let at_4673 = params_4669.length;
										while (it_4672 < at_4673) {
											i_4671 = it_4672;
											it_4672++;
											{
												const name_4674 = DataHelper.extractTypeName(params_4669[i_4671]);
												if (names_4670.includes(name_4674)) { this.fail(('Parameter `' + (name_4674) + '` already exists in `<T, ...>`'), node_4642) };
												names_4670.push(name_4674);
											};
										};
									};
								}
							} break;
							};
						};
						{
							let step_4675 = 0;
							const ext = extend;
							if (step_4675 == 0 && ext != null) { step_4675 = 1 };
							if (step_4675 == 1) { type_4651.extend = this.toType(ext, node_4642) };
						};
						for (const impl of $toIterator(implement)) {
							type_4651.implement.push(this.toType(impl, node_4642));
						};
						this.pushScope();
						let genericParamIndex = 0;
						const genericStubs = [];
						for (const genericParam of $toIterator(type_4651.genericParams)) {
							this.addScopeType(genericParam, this.typeAny);
							{
								let step_4676 = 0;
								const knownParams_4677 = knownParams_4644;
								if (step_4676 == 0 && knownParams_4677 != null) { step_4676 = 1 };
								if (step_4676 == 1) { this.addScopeType(genericParam, knownParams_4677[genericParamIndex]) } else {
									const stub = /*Generic*/[1,genericParamIndex,genericParam,".Generic"];
									genericStubs.push(stub);
									this.addScopeType(genericParam, stub);
								};
							};
							genericParamIndex++;
						};
						if ((knownParams_4644 == null) && (type_4651.genericParams.length > 0)) {};
						for (const field of $toIterator(f_4666)) {
							{
								const temp_4678 = field;
								switch (temp_4678&&temp_4678[0]) {
								case 22: {
									const name_4679 = temp_4678[1];
									{
										if (type_4651.fieldNames.includes(name_4679)) { this.fail(('Field `' + (name_4679) + '` already exists'), field) };
										type_4651.fieldNames.push(name_4679);
										if (name_4679 == 'new') { type_4651.constructor = type_4651.fieldNames.length - 1 } else {
											type_4651.fieldRenames[type_4651.fieldNames.length - 1] = getRename(field, name_4679, classDecorators);
										};
										type_4651.fields.set(name_4679, 0);
										this.addScope(name_4679, field);
									}
								} break;
								
								case 24: {
									const name_4680 = temp_4678[1];
									const t_4681 = temp_4678[2];
									const e_4682 = temp_4678[3];
									{
										if (type_4651.fieldNames.includes(name_4680)) { this.fail(('Field `' + (name_4680) + '` already exists'), field) };
										type_4651.fieldNames.push(name_4680);
										type_4651.fieldInitialized[type_4651.fieldNames.length - 1] = false;
										type_4651.fieldRenames[type_4651.fieldNames.length - 1] = getRename(field, name_4680, classDecorators);
										this.addScope(name_4680, field);
									}
								} break;
								
								case 26: {
									const field = temp_4678[1];
									{
										const temp_4683 = field;
										switch (temp_4683&&temp_4683[0]) {
										case 24: {
											const name_4684 = temp_4683[1];
											{
												if (type_4651.fieldNames.includes(name_4684)) { this.fail(('Field `' + (name_4684) + '` already exists'), field) };
												type_4651.fieldNames.push(name_4684);
												this.addScope(name_4684, field);
											}
										} break;
										};
									}
								} break;
								
								case 47: {
									const f_4685 = temp_4678[1];
									{
										const temp_4686 = f_4685;
										switch (temp_4686&&temp_4686[0]) {
										case 22: {
											const name_4687 = temp_4686[1];
											{
												if (type_4651.fieldNames.includes(name_4687)) { this.fail(('Field `' + (name_4687) + '` already exists'), field) };
												type_4651.fieldNames.push(name_4687);
												type_4651.fieldStatic[type_4651.fieldNames.length - 1] = true;
												this.addScope(name_4687, field);
											}
										} break;
										
										case 24: {
											const name_4688 = temp_4686[1];
											{
												if (type_4651.fieldNames.includes(name_4688)) { this.fail(('Field `' + (name_4688) + '` already exists'), field) };
												type_4651.fieldNames.push(name_4688);
												type_4651.fieldStatic[type_4651.fieldNames.length - 1] = true;
												this.addScope(name_4688, field);
											}
										} break;
										};
									}
								} break;
								
								default: 
								this.fail('Wrong class field format', field)
								};
							};
							this.parents.set(field, node_4642);
						};
						for (const field of $toIterator(f_4666)) {
							const temp_4689 = field;
							switch (temp_4689&&temp_4689[0]) {
							case 24: {
								const name_4690 = temp_4689[1];
								const t_4691 = temp_4689[2];
								const e_4692 = temp_4689[3];
								const const_4693 = temp_4689[4];
								{
									let step_4694 = 0;
									const t_4695 = t_4691;
									if (step_4694 == 0 && t_4695 != null) { step_4694 = 1 };
									if (step_4694 == 1) { this.types.set(field, this.toType(t_4695, field)) };
								}
							} break;
							
							case 22: {
								const name_4696 = temp_4689[1];
								const expr_4697 = temp_4689[2];
								const vars_4698 = temp_4689[3];
								const rettype_4699 = temp_4689[4];
								const variadic_4700 = temp_4689[6];
								{
									{
										let step_4701 = 0;
										const rettype_4702 = rettype_4699;
										if (step_4701 == 0 && rettype_4702 != null) { step_4701 = 1 };
										if (step_4701 == 1) { this.types.set(field, /*Function*/[12,this.varTypes(vars_4698),this.toType(rettype_4702, field),variadic_4700,".Function"]) };
									};
									if (name_4696 == 'slice') {};
								}
							} break;
							
							case 47: {
								const f_4703 = temp_4689[1];
								{
									const temp_4704 = f_4703;
									switch (temp_4704&&temp_4704[0]) {
									case 22: {
										const name_4705 = temp_4704[1];
										const expr_4706 = temp_4704[2];
										const vars_4707 = temp_4704[3];
										const rettype_4708 = temp_4704[4];
										const variadic_4709 = temp_4704[6];
										{
											let step_4710 = 0;
											const rettype_4711 = rettype_4708;
											if (step_4710 == 0 && rettype_4711 != null) { step_4710 = 1 };
											if (step_4710 == 1) {
												this.types.set(f_4703, /*Function*/[12,this.varTypes(vars_4707),this.toType(rettype_4711, f_4703),variadic_4709,".Function"]);
												this.types.set(field, this.types.get(f_4703));
											};
										}
									} break;
									
									case 24: {
										const name_4712 = temp_4704[1];
										const t_4713 = temp_4704[2];
										const e_4714 = temp_4704[3];
										const const_4715 = temp_4704[4];
										{
											let step_4716 = 0;
											const t_4717 = t_4713;
											if (step_4716 == 0 && t_4717 != null) { step_4716 = 1 };
											if (step_4716 == 1) {
												this.types.set(f_4703, this.toType(t_4717, f_4703));
												this.types.set(field, this.types.get(f_4703));
											};
										}
									} break;
									};
								}
							} break;
							};
						};
						for (const field of $toIterator(f_4666)) {
							const temp_4718 = field;
							switch (temp_4718&&temp_4718[0]) {
							case 22: {
								const name_4719 = temp_4718[1];
								const expr_4720 = temp_4718[2];
								const vars_4721 = temp_4718[3];
								const rettype_4722 = temp_4718[4];
								const variadic_4723 = temp_4718[6];
								{
									if (name_4719 == 'new') { type_4651.constructor = type_4651.fieldNames.length - 1 };
									if ((external) && (expr_4720 != null)) { if (name_4719 == 'new') { this.fail('External class constructor `new()` cannot have a body `{}`', field) } else {
										this.fail(('External class method `function ' + (name_4719) + '` cannot have a body `{}`'), field);
									} };
									const _insideClassMethod = this.insideClassMethod;
									const _allowSuper = this.allowSuper;
									this.insideClassMethod = true;
									this.allowSuper = (extend != null);
									if ((!external)) { this.fillFunction(field, expr_4720, vars_4721, rettype_4722, false) };
									if ((external) && (this.types.get(field) == null)) {
										this.types.set(field, /*Function*/[12,this.varTypes(vars_4721),((rettype_4722 != null)? (this.toType(rettype_4722, field)) : this.typeVoid),variadic_4723,".Function"]);
										if (name_4719 == 'slice') {};
									};
									this.insideClassMethod = _insideClassMethod;
									this.allowSuper = _allowSuper;
								}
							} break;
							
							case 24: {
								const name_4724 = temp_4718[1];
								const t_4725 = temp_4718[2];
								const e_4726 = temp_4718[3];
								const const_4727 = temp_4718[4];
								{
									if ((external) && (e_4726 != null)) { this.fail(('External class field `var ' + (name_4724) + '` cannot have `= value`'), field) };
									const _insideClassMethod_4728 = this.insideClassMethod;
									this.insideClassMethod = true;
									if (e_4726 != null) { this.fillExpression(e_4726) };
									this.insideClassMethod = _insideClassMethod_4728;
									this.mixVarTypes(t_4725, e_4726, field);
									type_4651.fieldInitialized[type_4651.fieldNames.indexOf(name_4724, 0)] = true;
									if (this.types.get(field) == null) { this.fail(('Field `var ' + (name_4724) + '` initialized, but got no type ') + e_4726, field) };
								}
							} break;
							
							case 26: {
								const f_4729 = temp_4718[1];
								{
									const temp_4730 = f_4729;
									switch (temp_4730&&temp_4730[0]) {
									case 24: {
										const name_4731 = temp_4730[1];
										const t_4732 = temp_4730[2];
										const e_4733 = temp_4730[3];
										const const_4734 = temp_4730[4];
										{
											if ((external) && (e_4733 != null)) { this.fail(('External class field `var ' + (name_4731) + '` cannot have expression'), field) };
											const _insideClassMethod_4735 = this.insideClassMethod;
											this.insideClassMethod = true;
											if (e_4733 != null) { this.fillExpression(e_4733) };
											this.insideClassMethod = _insideClassMethod_4735;
											this.mixVarTypes(t_4732, e_4733, f_4729);
											type_4651.fieldInitialized[type_4651.fieldNames.indexOf(name_4731, 0)] = true;
											if (this.types.get(f_4729) == null) { this.fail(('Property `' + (name_4731) + '` initialized, but got no type ') + e_4733, field) };
											this.types.set(field, this.types.get(f_4729));
										}
									} break;
									};
								}
							} break;
							
							case 47: {
								const f_4736 = temp_4718[1];
								{
									const temp_4737 = f_4736;
									switch (temp_4737&&temp_4737[0]) {
									case 22: {
										const name_4738 = temp_4737[1];
										const expr_4739 = temp_4737[2];
										const vars_4740 = temp_4737[3];
										const rettype_4741 = temp_4737[4];
										const variadic_4742 = temp_4737[6];
										{
											if ((external) && (expr_4739 != null)) { this.fail(('External class field `static fun ' + (name_4738) + '` cannot have a body'), field) };
											const _insideClassMethod_4743 = this.insideClassMethod;
											this.insideClassMethod = false;
											if ((!external)) { this.fillFunction(f_4736, expr_4739, vars_4740, rettype_4741, false) };
											if (external) { this.types.set(f_4736, /*Function*/[12,this.varTypes(vars_4740),((rettype_4741 != null)? (this.toType(rettype_4741, f_4736)) : this.typeVoid),variadic_4742,".Function"]) };
											this.insideClassMethod = _insideClassMethod_4743;
											if (this.types.get(f_4736) == null) { this.fail('Function get no type: class ' + DataHelper.nameOf(node_4642) + ' static ' + name_4738, f_4736) };
											this.types.set(field, this.types.get(f_4736));
										}
									} break;
									
									case 24: {
										const name_4744 = temp_4737[1];
										const t_4745 = temp_4737[2];
										const e_4746 = temp_4737[3];
										const const_4747 = temp_4737[4];
										{
											if ((external) && (e_4746 != null)) { this.fail(('External class field `static var ' + (name_4744) + '` cannot have expression'), field) };
											if (e_4746 != null) { this.fillExpression(e_4746) };
											this.mixVarTypes(t_4745, e_4746, f_4736);
											this.types.set(field, this.types.get(f_4736));
										}
									} break;
									};
								}
							} break;
							
							default: 
							this.fail('Wrong class field format', node_4642)
							};
						};
						this.popScope();
					}
				} break;
				
				default: 
				this.fail('ClassType expects (declare) class node, but got ' + node_4642, node_4642)
				};
			};
			this.thisType = _thisType;
			this.thisNode = _thisNode;
			return type_4651;
		};
	};
		registerEnumType(node_4748) {
		let step_4749 = 0;
		const type_4750 = this.types.get(node_4748);
		if (step_4749 == 0 && type_4750 != null) { step_4749 = 1 };
		if (step_4749 == 1) {
			const temp_4751 = (type_4750);
			switch (temp_4751&&temp_4751[0]) {
			case 8: {
				const t_4752 = temp_4751[1];
				return t_4752
			} break;
			};
		} else {
			const type_4753 = new EnumType();
			type_4753.parent = node_4748;
			type_4753.name = DataHelper.nameOf(node_4748);
			this.types.set(node_4748, /*Enum*/[8,type_4753,".Enum"]);
			{
				const temp_4754 = node_4748;
				switch (temp_4754&&temp_4754[0]) {
				case 39: {
					const t_4755 = temp_4754[1];
					const f_4756 = temp_4754[2];
					const valuesType = temp_4754[3];
					const extend_4757 = temp_4754[4];
					{
						this.pushScope();
						{
							let step_4758 = 0;
							const valuesType_4759 = valuesType;
							if (step_4758 == 0 && valuesType_4759 != null) { step_4758 = 1 };
							if (step_4758 == 1) { type_4753.fieldsTypeSimple = this.toType(valuesType_4759, node_4748) };
						};
						if ((type_4753.fieldsTypeSimple != null) && (type_4753.fieldsTypeSimple != this.typeString) && (type_4753.fieldsTypeSimple != this.typeInt) && (type_4753.fieldsTypeSimple != this.typeInt8) && (type_4753.fieldsTypeSimple != this.typeInt16) && (type_4753.fieldsTypeSimple != this.typeInt32) && (type_4753.fieldsTypeSimple != this.typeInt64) && (type_4753.fieldsTypeSimple != this.typeUInt8) && (type_4753.fieldsTypeSimple != this.typeUInt16) && (type_4753.fieldsTypeSimple != this.typeUInt32) && (type_4753.fieldsTypeSimple != this.typeUInt64)) { this.fail('Simple enums may be only of integer and string types', node_4748) };
						if ((f_4756.length == 0) && (extend_4757 == null)) { this.fail(('Enum `' + (type_4753.name) + '` must have at least one value `enum ' + (type_4753.name) + ' { Value }`'), node_4748) };
						const numbers = [];
						const strings = [];
						const names_4760 = [];
						for (const field of $toIterator(f_4756)) {
							{
								const temp_4761 = field;
								switch (temp_4761&&temp_4761[0]) {
								case 51: {
									const t_4762 = temp_4761[1];
									{
										const temp_4763 = t_4762;
										switch (temp_4763&&temp_4763[0]) {
										case 1: {
											const name_4764 = temp_4763[1];
											{
												if (type_4753.fieldNames.includes(name_4764)) { throw this.fail(('Field `' + (name_4764) + '` already exists'), node_4748) };
												type_4753.fieldNames.push(name_4764);
												type_4753.fieldEnumConstructor[type_4753.fieldNames.length - 1] = true;
												type_4753.tagBindVars[type_4753.fieldNames.length - 1] = [];
												type_4753.tagBindVarsNames[type_4753.fieldNames.length - 1] = [];
												type_4753.tagBindVarsTypes[type_4753.fieldNames.length - 1] = [];
												type_4753.fieldType[type_4753.fieldNames.length - 1] = /*EnumInstance*/[9,type_4753,type_4753.fieldNames.length - 1,".EnumInstance"];
											}
										} break;
										
										default: 
										this.fail('Wrong enum constructor format, should be `Name`', node_4748)
										};
									}
								} break;
								
								case 13: {
									const e_4765 = temp_4761[1];
									const args = temp_4761[2];
									const argNames = temp_4761[3];
									{
										if (valuesType != null) { throw this.fail('Cannot use `Value(args)` format for simple enum', node_4748) };
										{
											const temp_4766 = e_4765;
											switch (temp_4766&&temp_4766[0]) {
											case 51: {
												const t_4767 = temp_4766[1];
												{
													const temp_4768 = t_4767;
													switch (temp_4768&&temp_4768[0]) {
													case 1: {
														const name_4769 = temp_4768[1];
														{
															if (type_4753.fieldNames.includes(name_4769)) { throw this.fail(('Field `' + (name_4769) + '` already exists'), e_4765) };
															type_4753.fieldNames.push(name_4769);
															type_4753.fieldEnumConstructor[type_4753.fieldNames.length - 1] = true;
															type_4753.fieldType[type_4753.fieldNames.length - 1] = /*EnumConstructor*/[10,type_4753,type_4753.fieldNames.length - 1,".EnumConstructor"];
															const tagBindVars = [];
															type_4753.tagBindVars[type_4753.fieldNames.length - 1] = tagBindVars;
															const tagBindVarsTypes = [];
															type_4753.tagBindVarsTypes[type_4753.fieldNames.length - 1] = tagBindVarsTypes;
															const tagBindVarsNames = [];
															type_4753.tagBindVarsNames[type_4753.fieldNames.length - 1] = tagBindVarsNames;
															type_4753.tagBindVarsNodes[type_4753.fieldNames.length - 1] = args;
															if (args.length == 0) { this.fail('Enum constructor expects more than zero arguments `(value: Type)`', e_4765) };
															{
																let i_4770 = 0;
																let it_4771 = 0;
																let at_4772 = args.length;
																while (it_4771 < at_4772) {
																	i_4770 = it_4771;
																	it_4771++;
																	{
																		if (argNames[i_4770] == null) { this.fail('Enum constructor arguments should have names `E(name1: T, name2: T)', args[i_4770]) };
																		const nodeType = Typer.nodeToNodeType(args[i_4770]);
																		tagBindVars[i_4770] = nodeType;
																		if (tagBindVarsNames.includes(argNames[i_4770])) { this.fail(('Enum constructor argument `' + (argNames[i_4770]) + '` already exists'), args[i_4770]) };
																		tagBindVarsNames[i_4770] = argNames[i_4770];
																	};
																};
															};
														}
													} break;
													
													default: 
													this.fail('Wrong enum constructor format, should be `Name(value: T)`', e_4765)
													};
												}
											} break;
											};
										};
									}
								} break;
								
								case 10: {
									const a = temp_4761[1];
									const op = temp_4761[2];
									const b = temp_4761[3];
									{
										if (op != 91) { this.fail(('Should use `Value = value` not `Value ' + (Token.stringify(op)) + ' value` format for enum tag value'), node_4748) };
										if (valuesType == null) { this.fail('Cannot use `Value = value` format for complex enum', node_4748) };
										const numberable = [this.typeInt, this.typeInt32, this.typeInt16, this.typeInt8, this.typeInt64, this.typeUInt32, this.typeUInt16, this.typeUInt8, this.typeUInt64];
										{
											const temp_4773 = a;
											switch (temp_4773&&temp_4773[0]) {
											case 51: {
												const t_4774 = temp_4773[1];
												{
													const temp_4775 = t_4774;
													switch (temp_4775&&temp_4775[0]) {
													case 1: {
														const name_4776 = temp_4775[1];
														{
															if (type_4753.fieldNames.includes(name_4776)) { this.fail(('Field `' + (name_4776) + '` already exists'), a) };
															type_4753.fieldNames.push(name_4776);
															type_4753.fieldEnumConstructor[type_4753.fieldNames.length - 1] = true;
															{
																const temp_4777 = b;
																switch (temp_4777&&temp_4777[0]) {
																case 51: {
																	const t_4778 = temp_4777[1];
																	{
																		const temp_4779 = t_4778;
																		switch (temp_4779&&temp_4779[0]) {
																		case 1: {
																			const name_4780 = temp_4779[1];
																			{
																				const at_4781 = names_4760.indexOf(name_4780, 0);
																				if (at_4781 == (-1)) { this.fail(('Value with name `' + (name_4780) + '` not found above current value'), b) };
																			}
																		} break;
																		
																		default: 
																		this.fail('Wrong enum constructor format, should be `Name = value`', b)
																		};
																	}
																} break;
																
																case 6: {
																	const number = temp_4777[1];
																	const meta = temp_4777[2];
																	{
																		if ((!numberable.includes(type_4753.fieldsTypeSimple))) { this.fail(('`' + (name_4776) + ' = value` expects constant value of type `' + (Type.stringify(type_4753.fieldsTypeSimple)) + '`'), b) };
																		{
																			let step_4782 = 0;
																			const at_4783 = strings.indexOf('' + number, 0);
																			let temp_4784 = null;
																			if (step_4782 == 0 && at_4783 != null) {
																				temp_4784 = at_4783 != (-1);
																				step_4782 = 1;
																			};
																			if (step_4782 == 1 && temp_4784 != false) { step_4782 = 2 };
																			if (step_4782 == 2) {
																				const named_4785 = names_4760[at_4783];
																				this.fail(('Combination `' + (name_4776) + ' = ' + (number) + '` already defined as `' + (named_4785) + ' = ' + (number) + '`, try to assign same value as `' + (name_4776) + ' = ' + (named_4785) + '` or set new unique value'), b);
																			};
																		};
																		strings.push('' + number);
																		names_4760.push(name_4776);
																	}
																} break;
																
																case 5: {
																	const number_4786 = temp_4777[1];
																	{
																		if ((!numberable.includes(type_4753.fieldsTypeSimple))) { this.fail(('`' + (name_4776) + ' = value` expects constant value of type `' + (Type.stringify(type_4753.fieldsTypeSimple)) + '`'), b) };
																		{
																			let step_4787 = 0;
																			const at_4788 = numbers.indexOf(number_4786, 0);
																			let temp_4789 = null;
																			if (step_4787 == 0 && at_4788 != null) {
																				temp_4789 = at_4788 != (-1);
																				step_4787 = 1;
																			};
																			if (step_4787 == 1 && temp_4789 != false) { step_4787 = 2 };
																			if (step_4787 == 2) {
																				const named_4790 = names_4760[at_4788];
																				this.fail(('Combination `' + (name_4776) + ' = ' + (number_4786) + '` already defined as `' + (named_4790) + ' = ' + (number_4786) + '`, try to assign same value as `' + (name_4776) + ' = ' + (named_4790) + '` or set new unique value'), b);
																			};
																		};
																		numbers.push(number_4786);
																		names_4760.push(name_4776);
																	}
																} break;
																
																case 0: {
																	const string = temp_4777[1];
																	{
																		if (type_4753.fieldsTypeSimple != this.typeString) { this.fail(('`' + (name_4776) + ' = value` expects constant value of type `' + (Type.stringify(type_4753.fieldsTypeSimple)) + '`'), b) };
																		{
																			let step_4791 = 0;
																			const at_4792 = strings.indexOf(string, 0);
																			let temp_4793 = null;
																			if (step_4791 == 0 && at_4792 != null) {
																				temp_4793 = at_4792 != (-1);
																				step_4791 = 1;
																			};
																			if (step_4791 == 1 && temp_4793 != false) { step_4791 = 2 };
																			if (step_4791 == 2) {
																				const named_4794 = names_4760[at_4792];
																				this.fail(('Combination `' + (name_4776) + ' = ' + (string) + '` already defined as `' + (named_4794) + ' = ' + (string) + '`, try to assign same value as `' + (name_4776) + ' = ' + (named_4794) + '` or set new unique value'), b);
																			};
																		};
																		strings.push(string);
																		names_4760.push(name_4776);
																	}
																} break;
																
																default: 
																this.fail('Wrong enum constructor format, should be `Name = value`', b)
																};
															};
															type_4753.fieldType[type_4753.fieldNames.length - 1] = /*EnumInstance*/[9,type_4753,type_4753.fieldNames.length - 1,".EnumInstance"];
														}
													} break;
													};
												}
											} break;
											};
										};
									}
								} break;
								
								case 1: {
									const name_4795 = temp_4761[1];
									this.fail(('Cannot use lowercase `' + (name_4795) + '` format for enum values'), node_4748)
								} break;
								
								case 47: {
									const f_4796 = temp_4761[1];
									{
										const temp_4797 = f_4796;
										switch (temp_4797&&temp_4797[0]) {
										case 22: {
											const name_4798 = temp_4797[1];
											{
												if (type_4753.fieldNames.includes(name_4798)) { this.fail(('Field `' + (name_4798) + '` already exists'), node_4748) };
												type_4753.fieldNames.push(name_4798);
												type_4753.fieldStatic[type_4753.fieldNames.length - 1] = true;
												this.addScope(name_4798, field);
											}
										} break;
										
										case 24: {
											const name_4799 = temp_4797[1];
											{
												if (type_4753.fieldNames.includes(name_4799)) { this.fail(('Field `' + (name_4799) + '` already exists'), node_4748) };
												type_4753.fieldNames.push(name_4799);
												type_4753.fieldStatic[type_4753.fieldNames.length - 1] = true;
												this.addScope(name_4799, field);
											}
										} break;
										};
									}
								} break;
								
								case 22: {
									const name_4800 = temp_4761[1];
									const expr_4801 = temp_4761[2];
									const vars_4802 = temp_4761[3];
									const rettype_4803 = temp_4761[4];
									this.fail('Enum fields cannot be functions', field)
								} break;
								
								default: 
								this.fail('Wrong enum field format', field)
								};
							};
							this.parents.set(field, node_4748);
						};
						for (const field of $toIterator(f_4756)) {
							const temp_4804 = field;
							switch (temp_4804&&temp_4804[0]) {
							case 22: {
								const name_4805 = temp_4804[1];
								const expr_4806 = temp_4804[2];
								const vars_4807 = temp_4804[3];
								const rettype_4808 = temp_4804[4];
								const variadic_4809 = temp_4804[6];
								this.fillFunction(field, expr_4806, vars_4807, rettype_4808, false)
							} break;
							
							case 24: {
								const name_4810 = temp_4804[1];
								{
								}
							} break;
							
							case 47: {
								const f_4811 = temp_4804[1];
								{
									const temp_4812 = f_4811;
									switch (temp_4812&&temp_4812[0]) {
									case 22: {
										const name_4813 = temp_4812[1];
										const expr_4814 = temp_4812[2];
										const vars_4815 = temp_4812[3];
										const rettype_4816 = temp_4812[4];
										const variadic_4817 = temp_4812[6];
										{
											const _insideClassMethod_4818 = this.insideClassMethod;
											this.insideClassMethod = false;
											{
												let step_4819 = 0;
												const rettype_4820 = rettype_4816;
												if (step_4819 == 0 && rettype_4820 != null) { step_4819 = 1 };
												if (step_4819 == 1) { this.types.set(f_4811, /*Function*/[12,this.varTypes(vars_4815),this.toType(rettype_4820, f_4811),variadic_4817,".Function"]) } else {
													this.types.set(f_4811, /*Function*/[12,this.varTypes(vars_4815),this.typeVoid,variadic_4817,".Function"]);
												};
											};
											this.types.set(field, this.types.get(f_4811));
											this.fillFunction(f_4811, expr_4814, vars_4815, rettype_4816, false);
											this.insideClassMethod = _insideClassMethod_4818;
											if (this.types.get(f_4811) == null) { this.fail('Function get no type: enum ' + DataHelper.nameOf(node_4748) + ' static ' + name_4813, f_4811) };
											this.types.set(field, this.types.get(f_4811));
										}
									} break;
									
									case 24: {
										const name_4821 = temp_4812[1];
										const t_4822 = temp_4812[2];
										const e_4823 = temp_4812[3];
										const const_4824 = temp_4812[4];
										{
											if (e_4823 != null) { this.fillExpression(e_4823) };
											this.mixVarTypes(t_4822, e_4823, f_4811);
											this.types.set(field, this.types.get(f_4811));
										}
									} break;
									};
								}
							} break;
							
							case 51: {
								{
								}
							} break;
							
							case 13: {
								{
								}
							} break;
							
							case 10: {
								{
								}
							} break;
							
							default: 
							this.fail('Unknown enum field format', field)
							};
						};
						this.popScope();
					}
				} break;
				
				default: 
				this.fail('EnumType expects (declare) enum node, but got ' + node_4748, node_4748)
				};
			};
			return type_4753;
		};
	};
		fail(msg, node_4825) {
		this.failNonFatal(msg, node_4825);
		{
			let step_4826 = 0;
			const currentlyInstantiating = this.currentlyInstantiating;
			let currentlyInstantiatingParams = null;
			if (step_4826 == 0 && currentlyInstantiating != null) {
				currentlyInstantiatingParams = this.currentlyInstantiatingParams;
				step_4826 = 1;
			};
			if (step_4826 == 1 && currentlyInstantiatingParams != null) { step_4826 = 2 };
			if (step_4826 == 2) {
				const name_4827 = DataHelper.nameOf(currentlyInstantiating);
				const msg_4828 = 'While instantiating `' + name_4827 + '<' + currentlyInstantiatingParams.map((param) => (Type.stringify(param))).join(', ') + '>`';
				this.failNonFatal(msg_4828, node_4825);
				this.failNonFatal(('Type `' + (name_4827) + '` is defined here'), currentlyInstantiating);
			};
		};
		const errors_4829 = this.failures.slice(0, 1073741824);
		this.failures = [];
		throw new CompilerErrors(errors_4829);
	};
		failNonFatal(msg_4830, node_4831) {
		const t_4832 = this.project.data.get;
		const data = this.project.data.get(node_4831);
		{
			let step_4833 = 0;
			const data_4834 = data;
			if (step_4833 == 0 && data_4834 != null) { step_4833 = 1 };
			if (step_4833 == 1) { this.failures.push(new CompilerError(3, msg_4830, data_4834.line, data_4834.column, data_4834.fileName)) } else {
				this.failures.push(new CompilerError(3, msg_4830, 1, 1, 'unknown.hexa'));
			};
		};
	};
		positionOf(node_4835) {
		const data_4836 = (this.project.data.get(node_4835));
		if (data_4836 == null) { return '[Unknown]: ' };
		return '[' + data_4836.fileName + ':' + data_4836.line + ':' + data_4836.column + ']: ';
	};
		nameOfModuleItem(node_4845) {
		const temp_4846 = node_4845;
		switch (temp_4846&&temp_4846[0]) {
		case 24: {
			const name_4847 = temp_4846[1];
			return name_4847
		} break;
		
		case 22: {
			const name_4848 = temp_4846[1];
			{
				let step_4849 = 0;
				const named_4850 = name_4848;
				if (step_4849 == 0 && named_4850 != null) { step_4849 = 1 };
				if (step_4849 == 1) { return named_4850 } else {
					throw 'Module function should have a name';
				};
			}
		} break;
		
		case 48: {
			const node_4851 = temp_4846[1];
			{
				const temp_4852 = node_4851;
				switch (temp_4852&&temp_4852[0]) {
				case 25: {
					const t_4853 = temp_4852[1];
					{
						const temp_4854 = t_4853;
						switch (temp_4854&&temp_4854[0]) {
						case 1: {
							const name_4855 = temp_4854[1];
							return name_4855
						} break;
						
						case 2: {
							const name_4856 = temp_4854[1];
							return name_4856
						} break;
						};
					}
				} break;
				};
			}
		} break;
		
		case 25: {
			const t_4857 = temp_4846[1];
			{
				const temp_4858 = t_4857;
				switch (temp_4858&&temp_4858[0]) {
				case 1: {
					const name_4859 = temp_4858[1];
					return name_4859
				} break;
				
				case 2: {
					const name_4860 = temp_4858[1];
					return name_4860
				} break;
				};
			}
		} break;
		
		case 39: {
			const t_4861 = temp_4846[1];
			{
				const temp_4862 = t_4861;
				switch (temp_4862&&temp_4862[0]) {
				case 1: {
					const name_4863 = temp_4862[1];
					return name_4863
				} break;
				
				case 2: {
					const name_4864 = temp_4862[1];
					return name_4864
				} break;
				};
			}
		} break;
		
		case 9: {
			const t_4865 = temp_4846[1];
			{
				const temp_4866 = t_4865;
				switch (temp_4866&&temp_4866[0]) {
				case 1: {
					const name_4867 = temp_4866[1];
					return name_4867
				} break;
				
				case 2: {
					const name_4868 = temp_4866[1];
					return name_4868
				} break;
				};
			}
		} break;
		
		default: 
		this.fail('Improper module item format, wrap expressions as `{ expressions }`', node_4845)
		};
	};
		findInNamespaceRoots(name_4869) {
		{
			let step_4870 = 0;
			const node_4871 = this.currentModule.imported.get(name_4869);
			if (step_4870 == 0 && node_4871 != null) { step_4870 = 1 };
			if (step_4870 == 1) { return node_4871 };
		};
		{
			let step_4872 = 0;
			const node_4873 = this.currentModule.exported.get(name_4869);
			if (step_4872 == 0 && node_4873 != null) { step_4872 = 1 };
			if (step_4872 == 1) { return node_4873 };
		};
		{
			let step_4874 = 0;
			const node_4875 = this.project.globals.get(name_4869);
			if (step_4874 == 0 && node_4875 != null) { step_4874 = 1 };
			if (step_4874 == 1) { return node_4875 };
		};
		return null;
	};
		pushScope() {
		this.scopes.push(new Map());
		this.scopeTypes.push(new Map());
	};
		popScope() {
		this.scopes.pop();
		this.scopeTypes.pop();
	};
		addScope(name_4876, node_4877) { this.scopes[this.scopes.length - 1].set(name_4876, node_4877) };
		addScopeType(name_4878, type_4879) { this.scopeTypes[this.scopeTypes.length - 1].set(name_4878, type_4879) };
		unify(to_4880, fromValue, node_4881) {
		if (to_4880 == fromValue) { return to_4880 };
		if (to_4880 == this.typeAny) { return to_4880 };
		if (fromValue == this.typeVoid) { this.fail(('Incompatible types `' + (Type.stringify(to_4880)) + '` and non-value type `Void`'), node_4881) };
		if ((to_4880 == this.typeFloat) && (fromValue == this.typeInt)) { return this.typeFloat };
		const isNullable = (t_4882) => {
			{
				const temp_4883 = t_4882;
				switch (temp_4883&&temp_4883[0]) {
				case 3: {
					return true
				} break;
				
				case 4: {
					return true
				} break;
				};
			};
			return false;
		};
		const instanceOfClass = (t_4884) => {
			{
				const temp_4885 = Type.unwrapNullable(t_4884);
				switch (temp_4885&&temp_4885[0]) {
				case 6: {
					const t_4886 = temp_4885[1];
					return t_4886
				} break;
				
				case 5: {
					const t_4887 = temp_4885[1];
					this.fail(('Cannot take classes `class ' + (t_4887.name) + '` as values'), node_4881)
				} break;
				};
			};
			return null;
		};
		const instanceOfEnum = (t_4888) => {
			{
				const temp_4889 = Type.unwrapNullable(t_4888);
				switch (temp_4889&&temp_4889[0]) {
				case 9: {
					const t_4890 = temp_4889[1];
					return t_4890
				} break;
				
				case 8: {
					const t_4891 = temp_4889[1];
					return t_4891
				} break;
				};
			};
			return null;
		};
		{
			const temp_4892 = to_4880;
			switch (temp_4892&&temp_4892[0]) {
			case 3: {
				const handle_4893 = temp_4892[1];
				if (handle_4893.value == null) { handle_4893.value = (() => {
					const temp_4894 = fromValue;
					switch (temp_4894&&temp_4894[0]) {
					case 3: {
						const handle_4895 = temp_4894[1];
						return handle_4895.value
					} break;
					
					case 4: {
						const t_4896 = temp_4894[1];
						return t_4896
					} break;
					
					default: 
					return fromValue
					};
				})() }
			} break;
			};
		};
		const toNullable = isNullable(to_4880);
		const fromNullable = isNullable(fromValue);
		const toInstance = instanceOfClass(to_4880);
		const fromInstance = instanceOfClass(fromValue);
		const toEnumInstance = instanceOfEnum(to_4880);
		const fromEnumInstance = instanceOfEnum(fromValue);
		if ((toInstance == null && toEnumInstance == null) || (fromInstance == null && fromEnumInstance == null)) { return (() => {
			const result_4897 = to_4880;
			if (result_4897 != null) { return result_4897 };
			return fromValue;
		})() };
		if ((toInstance != fromInstance) && (Type.unwrapNullable(to_4880) != this.typeAny) && (Type.unwrapNullable(fromValue) != this.typeAny)) {
			if ((to_4880 == this.typeFloat) && ([this.typeUInt32, this.typeUInt16, this.typeUInt8, this.typeInt32, this.typeInt16, this.typeInt8, this.typeFloat32, this.typeInt].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeFloat32) && ([this.typeUInt16, this.typeUInt8, this.typeInt16, this.typeInt8].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeUInt16) && ([this.typeUInt8].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeInt16) && ([this.typeUInt8, this.typeInt8].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeUInt64) && ([this.typeUInt8, this.typeUInt16, this.typeUInt32].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeInt64) && (fromValue == this.typeInt)) { return to_4880 };
			if ((to_4880 == this.typeInt64) && (fromValue == this.typeInt32)) { return to_4880 };
			if ((to_4880 == this.typeInt64) && (fromValue == this.typeUInt32)) { return to_4880 };
			if ((to_4880 == this.typeInt64) && ([this.typeInt8, this.typeInt16, this.typeInt32, this.typeUInt8, this.typeUInt16, this.typeUInt32].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeUInt64) && (fromValue == this.typeUInt32)) { return to_4880 };
			if ((to_4880 == this.typeUInt32) && (fromValue == this.typeUInt8)) { return to_4880 };
			if ((to_4880 == this.typeUInt32) && (fromValue == this.typeUInt16)) { return to_4880 };
			if ((to_4880 == this.typeInt32 || to_4880 == this.typeInt) && ([this.typeUInt8, this.typeInt8, this.typeUInt16, this.typeInt16, this.typeInt].includes(fromValue))) { return to_4880 };
			if ((to_4880 == this.typeInt32) && (fromValue == this.typeUInt16)) { return to_4880 };
			if ((to_4880 == this.typeInt32 && fromValue == this.typeInt) || (to_4880 == this.typeInt && fromValue == this.typeInt32)) { return this.typeInt32 };
			{
				const temp_4898 = node_4881;
				switch (temp_4898&&temp_4898[0]) {
				case 5: {
					const value_4899 = temp_4898[1];
					{
						if (value_4899 == 0 && [this.typeInt64, this.typeInt32, this.typeInt16, this.typeInt8, this.typeUInt64, this.typeUInt32, this.typeUInt16, this.typeUInt8, this.typeInt].includes(fromValue)) { return to_4880 };
						if ((to_4880 == this.typeUInt8) && (value_4899 >= 0) && (value_4899 < 256)) { return to_4880 };
						if ((to_4880 == this.typeUInt16) && (value_4899 >= 0) && (value_4899 < 65536)) { return to_4880 };
						if ((to_4880 == this.typeUInt32) && (value_4899 >= 0) && (value_4899 < 4294967296n)) { return to_4880 };
						if ((to_4880 == this.typeUInt64) && (value_4899 >= 0) && (value_4899 < 18446744073709551616n)) { return to_4880 };
					}
				} break;
				};
			};
			const toName = Type.primaryName(to_4880);
			const fromName = Type.primaryName(fromValue);
			if ((toName == 'ArrayByValue') && ((fromName == 'Array' || fromName == 'String'))) { return to_4880 };
			if ((toName == 'ConstPointer') && (fromName == 'Pointer')) { return to_4880 };
			{
				const temp_4900 = node_4881;
				switch (temp_4900&&temp_4900[0]) {
				case 5: {
					const value_4901 = temp_4900[1];
					{
						if (to_4880 == this.typeUInt64) {};
						if ((value_4901 >= 0) && (value_4901 < 18446744073709551616n)) {};
					}
				} break;
				};
			};
			{
				const temp_4902 = fromValue;
				switch (temp_4902&&temp_4902[0]) {
				case 6: {
					const type_4903 = temp_4902[1];
					const generic = temp_4902[2];
					{
						{
							const temp_4904 = to_4880;
							switch (temp_4904&&temp_4904[0]) {
							case 6: {
								const typeTo = temp_4904[1];
								const genericTo = temp_4904[2];
								{
									if (typeTo.kind == 1) { if (type_4903.implement.includes(to_4880)) { return to_4880 } };
									if (type_4903.name == typeTo.name) {
										const a_4905 = [null];
										const a_4906 = new Array();
										const a_4907 = [(null)];
										{
											const temp_4908 = generic[0];
											switch (temp_4908&&temp_4908[0]) {
											case 2: {
												const handle_4909 = temp_4908[1];
												return to_4880
											} break;
											
											case 3: {
												const handle_4910 = temp_4908[1];
												return to_4880
											} break;
											
											default: 
											{
												{
													let step_4911 = 0;
													const instanceOf_4912 = type_4903.instanceOf;
													if (step_4911 == 0 && instanceOf_4912 != null) { step_4911 = 1 };
													if (step_4911 == 1) { return instanceOf_4912.instantiateGeneric(genericTo) };
												};
												{
													let step_4913 = 0;
													const instanceOf_4914 = typeTo.instanceOf;
													if (step_4913 == 0 && instanceOf_4914 != null) { step_4913 = 1 };
													if (step_4913 == 1) { return instanceOf_4914.instantiateGeneric(genericTo) };
												};
											}
											};
										};
									};
								}
							} break;
							};
						};
						let extended = type_4903.extend;
						let depth = 0;
						while (true) {
							depth++;
							if (depth > 100) {
								this.fail('Inheritance depth is too large', node_4881);
								break;
							};
							{
								let step_4915 = 0;
								const extend_4916 = extended;
								if (step_4915 == 0 && extend_4916 != null) { step_4915 = 1 };
								if (step_4915 == 1) {
									if (extend_4916 == to_4880) { return to_4880 };
									{
										const temp_4917 = extend_4916;
										switch (temp_4917&&temp_4917[0]) {
										case 6: {
											const type_4918 = temp_4917[1];
											const generic_4919 = temp_4917[2];
											extended = type_4918.extend
										} break;
										
										case 5: {
											const type_4920 = temp_4917[1];
											extended = type_4920.extend
										} break;
										
										default: 
										extended = null
										};
									};
								} else {
									break;
								};
							};
						};
					}
				} break;
				};
			};
			this.fail(('Incompatible types `' + (Type.stringify(to_4880)) + '` and value of `' + (Type.stringify(fromValue)) + '`'), node_4881);
		};
		if ((toEnumInstance != fromEnumInstance) && (Type.unwrapNullable(to_4880) != this.typeAny) && (Type.unwrapNullable(fromValue) != this.typeAny)) {};
		return (() => {
			const result_4921 = to_4880;
			if (result_4921 != null) { return result_4921 };
			return fromValue;
		})();
	};
		findType(name_4922) {
		{
			let i_4923 = 0;
			let it_4924 = 0;
			let at_4925 = this.scopes.length;
			while (it_4924 < at_4925) {
				i_4923 = it_4924;
				it_4924++;
				{
					let step_4926 = 0;
					const subj_4927 = this.scopes[this.scopes.length - i_4923 - 1].get(name_4922);
					if (step_4926 == 0 && subj_4927 != null) { step_4926 = 1 };
					if (step_4926 == 1) { return subj_4927 };
				};
			};
		};
		const rooted = this.findInNamespaceRoots(name_4922);
		if (rooted == null) {};
		return rooted;
	};
		findActualType(name_4928) {
		{
			let i_4929 = 0;
			let it_4930 = 0;
			let at_4931 = this.scopeTypes.length;
			while (it_4930 < at_4931) {
				i_4929 = it_4930;
				it_4930++;
				{
					let step_4932 = 0;
					const subj_4933 = this.scopeTypes[this.scopeTypes.length - i_4929 - 1].get(name_4928);
					if (step_4932 == 0 && subj_4933 != null) { step_4932 = 1 };
					if (step_4932 == 1) { return subj_4933 };
				};
			};
		};
		return null;
	};
		toType(t_4934, node_4935) {
		const temp_4936 = t_4934;
		switch (temp_4936&&temp_4936[0]) {
		case 1: {
			const name_4937 = temp_4936[1];
			const path_4938 = temp_4936[2];
			{
				let nodeType_4939 = null;
				{
					let step_4940 = 0;
					const path_4941 = path_4938;
					if (step_4940 == 0 && path_4941 != null) { step_4940 = 1 };
					if (step_4940 == 1) {
						const temp_4942 = (this.currentModule.imported.get(path_4941));
						switch (temp_4942&&temp_4942[0]) {
						case 36: {
							const handle_4943 = temp_4942[1];
							{
								nodeType_4939 = handle_4943.exported.get(name_4937);
								if (nodeType_4939 == null) {
									const file = handle_4943.file;
									this.fail(('Namespace `' + (path_4941) + '` does not export type `' + (name_4937) + '` (aliased module is `' + (file) + '`)'), node_4935);
								};
							}
						} break;
						
						default: 
						this.fail(('Cannot find supposedly imported namespace `' + (path_4941) + '` of type `' + (name_4937) + '`'), node_4935)
						};
					} else {
						nodeType_4939 = (() => {
							const result_4944 = this.findType(name_4937);
							if (result_4944 != null) { return result_4944 };
							return (() => {
								const result_4945 = this.currentModule.exported.get(name_4937);
								if (result_4945 != null) { return result_4945 };
								return this.currentModule.imported.get(name_4937);
							})();
						})();
					};
				};
				if (this.types.get(nodeType_4939) == null) {
					const temp_4946 = nodeType_4939;
					switch (temp_4946&&temp_4946[0]) {
					case 25: {
						{
							const mod_4947 = this.currentModule;
							this.registerClassType(nodeType_4939, null, null, null);
							this.currentModule = mod_4947;
						}
					} break;
					
					case 39: {
						this.registerEnumType(nodeType_4939)
					} break;
					
					case null: case undefined: {
						{
						}
					} break;
					
					default: 
					{
					}
					};
				};
				const type_4948 = (() => {
					const result_4949 = this.findActualType(name_4937);
					if (result_4949 != null) { return result_4949 };
					return this.types.get(nodeType_4939);
				})();
				{
					const temp_4950 = type_4948;
					switch (temp_4950&&temp_4950[0]) {
					case 5: {
						const type_4951 = temp_4950[1];
						{
							if (type_4951.genericParams.length > 0) { this.fail(('The type `' + (type_4951.name) + '` requires `<' + (type_4951.genericParams) + '>` generic parameters'), node_4935) };
							return type_4951.instantiate();
						}
					} break;
					
					case 8: {
						const type_4952 = temp_4950[1];
						return this.types.get(nodeType_4939)
					} break;
					
					case 6: {
						return type_4948
					} break;
					
					case 9: {
						return type_4948
					} break;
					
					case 4: {
						return type_4948
					} break;
					
					case null: case undefined: {
						{
							const available_4953 = [];
							for (const name of $toIterator(this.currentModule.imported.keys())) {
								available_4953.push(name);
							};
							for (const name of $toIterator(this.currentModule.exported.keys())) {
								available_4953.push(name);
							};
							for (const name of $toIterator(this.project.globals.keys())) {
								available_4953.push(name);
							};
							this.fail(('Cannot find type `' + (name_4937) + '`\n') + this.proposeSimilar(available_4953.filter((named_4954) => (DataHelper.isTitleCase(named_4954))), name_4937, 'types', name_4937), node_4935);
						}
					} break;
					
					case 11: {
						const alias = temp_4950[1];
						return this.toType(alias.value, node_4935)
					} break;
					
					default: 
					{
						if (type_4948 == this.typeAny) { return this.typeAny };
						{
							const temp_4955 = type_4948;
							switch (temp_4955&&temp_4955[0]) {
							case 1: {
								return type_4948
							} break;
							};
						};
						return type_4948;
					}
					};
				};
			}
		} break;
		
		case 2: {
			const name_4956 = temp_4936[1];
			const params_4957 = temp_4936[2];
			const path_4958 = temp_4936[3];
			{
				const nodeType_4959 = (() => {
					const result_4960 = this.findType(name_4956);
					if (result_4960 != null) { return result_4960 };
					return (() => {
						const result_4961 = this.currentModule.exported.get(name_4956);
						if (result_4961 != null) { return result_4961 };
						return this.currentModule.imported.get(name_4956);
					})();
				})();
				if (this.types.get(nodeType_4959) == null) {
					const temp_4962 = nodeType_4959;
					switch (temp_4962&&temp_4962[0]) {
					case 25: {
						{
							const mod_4963 = this.currentModule;
							this.registerClassType(nodeType_4959, null, null, null);
							this.currentModule = mod_4963;
						}
					} break;
					
					case 39: {
						this.registerEnumType(nodeType_4959)
					} break;
					};
				};
				const type_4964 = (() => {
					const result_4965 = this.findActualType(name_4956);
					if (result_4965 != null) { return result_4965 };
					return this.types.get(nodeType_4959);
				})();
				{
					const temp_4966 = type_4964;
					switch (temp_4966&&temp_4966[0]) {
					case 5: {
						const type_4967 = temp_4966[1];
						{
							if (type_4967.genericParams.length == 0) { this.fail(('The type `' + (type_4967.name) + '` requires zero generic parameters'), node_4935) };
							if (type_4967.genericParams.length != params_4957.length) { this.fail(('The type `' + (type_4967.name) + '` requires `<' + (type_4967.genericParams) + '>` generic parameters'), node_4935) };
							const instanceParams = (() => {
								const result_4968 = [];
								const value_4969 = params_4957;
								for (const p of $toIterator(value_4969)) result_4968.push(this.toType(p, node_4935));
								return result_4968;
							})();
							if (name_4956 == 'ByValue') {
								const temp_4970 = instanceParams[0];
								switch (temp_4970&&temp_4970[0]) {
								case 6: {
									const type_4971 = temp_4970[1];
									type_4971.usedByValueDepth = 1
								} break;
								};
							};
							return type_4967.instantiateGeneric(instanceParams);
						}
					} break;
					
					case null: case undefined: {
						this.fail(('Cannot find type `' + (name_4956) + '`'), node_4935)
					} break;
					
					default: 
					{
						if (type_4964 == this.typeAny) { return this.typeAny };
						{
							const temp_4972 = type_4964;
							switch (temp_4972&&temp_4972[0]) {
							case 1: {
								return this.typeAny
							} break;
							};
						};
						this.fail(('Unsupported type `' + (name_4956) + '`'), node_4935);
					}
					};
				};
			}
		} break;
		
		case 0: {
			const t_4973 = temp_4936[1];
			return this.asNullable(this.toType(t_4973, node_4935))
		} break;
		
		case 3: {
			const args_4974 = temp_4936[1];
			const ret = temp_4936[2];
			{
				const variadic_4975 = false;
				return /*Function*/[12,(() => {
					const result_4976 = [];
					const value_4977 = args_4974;
					for (const arg of $toIterator(value_4977)) result_4976.push(new FunctionArgument(this.toType(arg, node_4935)));
					return result_4976;
				})(),this.toType(ret, node_4935),false,".Function"];
			}
		} break;
		
		case 5: {
			const names_4978 = temp_4936[1];
			const el_4979 = temp_4936[2];
			{
				const els_4980 = (() => {
					const result_4981 = [];
					const value_4982 = el_4979;
					for (const e of $toIterator(value_4982)) result_4981.push(this.toType(e, node_4935));
					return result_4981;
				})();
				return /*Struct*/[13,names_4978,els_4980,".Struct"];
			}
		} break;
		
		case 7: {
			const value_4983 = temp_4936[1];
			return /*Constant*/[0,'' + value_4983,".Constant"]
		} break;
		
		case 6: {
			const value_4984 = temp_4936[1];
			return /*Constant*/[0,'' + value_4984,".Constant"]
		} break;
		
		default: 
		this.fail('Unsupported node type ' + t_4934 + '. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.', node_4935)
		};
	};
		inferEmptyArray(t_4985, e_4986) {
		const temp_4987 = e_4986;
		switch (temp_4987&&temp_4987[0]) {
		case 31: {
			const el_4988 = temp_4987[1];
			if (el_4988.length == 0 && t_4985 != null) {
				this.types.set(e_4986, t_4985)
			break; } }
		
		case null: case undefined: {
			{
			}
		} break;
		
		default: 
		{
		}
		};
	};
		mixVarTypes(t_4989, e_4990, node_4991) {
		if ((t_4989 != null) && (e_4990 != null)) {
			const tType = this.toType(t_4989, node_4991);
			this.inferEmptyArray(tType, e_4990);
			this.types.set(node_4991, this.unify(tType, this.types.get(e_4990), e_4990));
		};
		if ((t_4989 == null) && (e_4990 != null)) { this.types.set(node_4991, this.types.get(e_4990)) };
		if ((t_4989 == null) && (e_4990 == null)) { this.types.set(node_4991, /*UnknownNullable*/[3,{value:null},".UnknownNullable"]) };
		if ((t_4989 != null) && (e_4990 == null)) { this.types.set(node_4991, this.toType(t_4989, node_4991)) };
	};
		areCovariant(left_4992, right_4993, strictNull) {
		if (left_4992 == right_4993) { return true };
		let left_4994 = left_4992;
		let right_4995 = right_4993;
		let leftNullable = false;
		let rightNullable = false;
		{
			const temp_4996 = left_4994;
			switch (temp_4996&&temp_4996[0]) {
			case null: case undefined: {
				return true
			} break;
			
			case 4: {
				const t_4997 = temp_4996[1];
				{
					left_4994 = t_4997;
					leftNullable = true;
				}
			} break;
			};
		};
		{
			const temp_4998 = right_4995;
			switch (temp_4998&&temp_4998[0]) {
			case null: case undefined: {
				return true
			} break;
			
			case 4: {
				const t_4999 = temp_4998[1];
				{
					right_4995 = t_4999;
					rightNullable = true;
				}
			} break;
			};
		};
		if ((rightNullable) && ((!leftNullable)) && (strictNull)) { return false };
		if (left_4994 == this.typeAny || right_4995 == this.typeAny) { return true };
		if (left_4994 == right_4995) { return true };
		{
			const temp_5000 = left_4994;
			switch (temp_5000&&temp_5000[0]) {
			case 8: {
				const lt = temp_5000[1];
				{
					const temp_5001 = right_4995;
					switch (temp_5001&&temp_5001[0]) {
					case 9: {
						const rt = temp_5001[1];
						if (lt == rt) { return true }
					} break;
					
					case 8: {
						const rt_5002 = temp_5001[1];
						if (lt == rt_5002) { return true }
					} break;
					};
				}
			} break;
			
			case 9: {
				const lt_5003 = temp_5000[1];
				{
					const temp_5004 = right_4995;
					switch (temp_5004&&temp_5004[0]) {
					case 9: {
						const rt_5005 = temp_5004[1];
						if (lt_5003 == rt_5005) { return true }
					} break;
					
					case 8: {
						const rt_5006 = temp_5004[1];
						if (lt_5003 == rt_5006) { return true }
					} break;
					};
				}
			} break;
			};
		};
		return false;
	};
		areComparable(left_5007, right_5008) {
		if (left_5007 == this.typeAny || right_5008 == this.typeAny) { return true };
		{
			const temp_5009 = left_5007;
			switch (temp_5009&&temp_5009[0]) {
			case 1: {
				return true
			} break;
			};
		};
		{
			const temp_5010 = right_5008;
			switch (temp_5010&&temp_5010[0]) {
			case 1: {
				return true
			} break;
			};
		};
		const numerical = [this.typeInt, this.typeFloat, this.typeFloat32, this.typeBigInt, this.typeUInt64, this.typeUInt32, this.typeUInt16, this.typeUInt8, this.typeInt64, this.typeInt32, this.typeInt16, this.typeInt8];
		return numerical.includes(left_5007) && numerical.includes(right_5008);
	};
		pushFuncParamsIfRequired(func) {
		let step_5011 = 0;
		const params_5012 = (this.project.mapFuncParams.get(func));
		let temp_5013 = null;
		if (step_5011 == 0 && params_5012 != null) {
			temp_5013 = params_5012.length > 0;
			step_5011 = 1;
		};
		if (step_5011 == 1 && temp_5013 != false) { step_5011 = 2 };
		if (step_5011 == 2) {
			this.pushScope();
			for (const genericParam of $toIterator(params_5012)) {
				const name_5014 = DataHelper.extractTypeName(genericParam);
				this.addScopeType(name_5014, this.typeAny);
			};
		};
	};
		popFuncParamsIfRequired(func_5015) {
		let step_5016 = 0;
		const params_5017 = (this.project.mapFuncParams.get(func_5015));
		let temp_5018 = null;
		if (step_5016 == 0 && params_5017 != null) {
			temp_5018 = params_5017.length > 0;
			step_5016 = 1;
		};
		if (step_5016 == 1 && temp_5018 != false) { step_5016 = 2 };
		if (step_5016 == 2) { this.popScope() };
	};
		varTypes(vars_5019) {
		const varTypes = [];
		for (const v of $toIterator(vars_5019)) {
			const temp_5020 = v;
			switch (temp_5020&&temp_5020[0]) {
			case 24: {
				const name_5021 = temp_5020[1];
				const t_5022 = temp_5020[2];
				const expr_5023 = temp_5020[3];
				{
					let step_5024 = 0;
					const t_5025 = t_5022;
					if (step_5024 == 0 && t_5025 != null) { step_5024 = 1 };
					if (step_5024 == 1) {
						const arg = new FunctionArgument((() => {
							const result_5026 = this.types.get(v);
							if (result_5026 != null) { return result_5026 };
							return this.toType(t_5025, v);
						})());
						arg.optional = expr_5023 != null;
						arg.name = name_5021;
						varTypes.push(arg);
					} else {
						varTypes.push(new FunctionArgument((() => {
							const result_5027 = this.types.get(v);
							if (result_5027 != null) { return result_5027 };
							return /*Unknown*/[2,{value:null},".Unknown"];
						})()));
					};
				}
			} break;
			};
		};
		return varTypes;
	};
		booleanable(type_5028) { return (type_5028 == this.typeBool) || (type_5028 == this.typeAny) };
		fillFunction(node_5029, expr_5030, vars_5031, rettype_5032, arrow) {
		const argNames_5033 = [];
		let expectedArrow = [];
		{
			let step_5034 = 0;
			const expectedArrowSignature = this.expectedArrowType.get(node_5029);
			if (step_5034 == 0 && expectedArrowSignature != null) { step_5034 = 1 };
			if (step_5034 == 1) {
				const temp_5035 = expectedArrowSignature;
				switch (temp_5035&&temp_5035[0]) {
				case 12: {
					const args_5036 = temp_5035[1];
					const rets = temp_5035[2];
					expectedArrow = args_5036.map((arg_5037) => (arg_5037.type))
				} break;
				};
			};
		};
		this.pushScope();
		const _insideFunction = this.insideFunction;
		const _functionAllowedToThrow = this.functionAllowedToThrow;
		const _functionThrows = this.functionThrows;
		const _functionReturnsAType = this.functionReturnsAType;
		const _functionActuallyReturns = this.functionActuallyReturns;
		const _insideTry = this.insideTry;
		{
			let i_5038 = 0;
			let it_5039 = 0;
			let at_5040 = vars_5031.length;
			while (it_5039 < at_5040) {
				i_5038 = it_5039;
				it_5039++;
				{
					const v = vars_5031[i_5038];
					{
						const temp_5041 = v;
						switch (temp_5041&&temp_5041[0]) {
						case 24: {
							const vname = temp_5041[1];
							const t_5042 = temp_5041[2];
							const e_5043 = temp_5041[3];
							const const_5044 = temp_5041[4];
							{
								if (argNames_5033.includes(vname)) { this.fail(('Argument `' + (vname) + '` defined multiple times'), v) };
								argNames_5033.push(vname);
								if ((t_5042 != null) && (this.toType(t_5042, v) == this.typeVoid)) { this.fail('Argument cannot be of type `Void`', v) };
								if (t_5042 != null) { this.types.set(v, this.toType(t_5042, v)) } else {
									this.types.set(v, expectedArrow[i_5038]);
								};
								if (e_5043 != null) {
									this.fillExpression(e_5043);
									{
										let step_5045 = 0;
										const t_5046 = this.types.get(v);
										if (step_5045 == 0 && t_5046 != null) { step_5045 = 1 };
										if (step_5045 == 1) { this.unify(t_5046, this.types.get(e_5043), e_5043) };
									};
								};
								this.addScope(vname, v);
							}
						} break;
						};
					};
				};
			};
		};
		let variadic_5047 = false;
		{
			const temp_5048 = node_5029;
			switch (temp_5048&&temp_5048[0]) {
			case 22: {
				const isVariadic = temp_5048[6];
				{
					variadic_5047 = isVariadic;
					{
						let step_5049 = 0;
						const params_5050 = (this.project.mapFuncParams.get(node_5029));
						if (step_5049 == 0 && params_5050 != null) { step_5049 = 1 };
						if (step_5049 == 1) { for (const genericParam of $toIterator(params_5050)) {
							const name_5051 = DataHelper.extractTypeName(genericParam);
							this.addScopeType(name_5051, this.typeAny);
						} };
					};
				}
			} break;
			};
		};
		let ret_5052 = null;
		{
			let step_5053 = 0;
			const rt_5054 = rettype_5032;
			if (step_5053 == 0 && rt_5054 != null) { step_5053 = 1 };
			if (step_5053 == 1) { ret_5052 = this.toType(rt_5054, node_5029) };
		};
		this.functionReturnsAType = ret_5052;
		this.functionActuallyReturns = false;
		const atts_5055 = this.project.mapDecorators.get(node_5029);
		{
			let step_5056 = 0;
			const noThrow = DataHelper.getDecorator(atts_5055, 'noThrow');
			if (step_5056 == 0 && noThrow != null) { step_5056 = 1 };
			if (step_5056 == 1) {
				if (noThrow.values.length > 0) { this.fail('Decorator `@noThrow` should have no parameters', node_5029) };
				this.functionAllowedToThrow = false;
			} else {
				this.functionAllowedToThrow = true;
			};
		};
		{
			let step_5057 = 0;
			const throws = DataHelper.getDecorator(atts_5055, 'throws');
			if (step_5057 == 0 && throws != null) { step_5057 = 1 };
			if (step_5057 == 1) {
				if (this.functionAllowedToThrow == false) { this.fail('Decorator `@noThrow` cannot be used with `@throws`', node_5029) };
				this.functionThrows = true;
			} else {
				this.functionThrows = false;
			};
		};
		this.insideFunction = true;
		this.insideTry = false;
		if ((arrow) && (expr_5030 != null)) { this.fillExpression(expr_5030) };
		if (((!arrow)) && (expr_5030 != null)) { this.fill(expr_5030) };
		this.popScope();
		ret_5052 = this.functionReturnsAType;
		if (arrow) { if ((arrow) && (ret_5052 == null) && (expr_5030 != null)) { ret_5052 = this.types.get(expr_5030) } else {
			this.unify(this.types.get(expr_5030), ret_5052, expr_5030);
		} } else {
			if (ret_5052 == null) { ret_5052 = this.typeVoid };
			if ((ret_5052 != this.typeVoid) && (expr_5030 != null) && (this.functionActuallyReturns == false)) { this.fail(('Function expects result of `' + (Type.stringify(ret_5052)) + '` but never does `return value`'), node_5029) };
		};
		this.insideFunction = _insideFunction;
		this.functionReturnsAType = _functionReturnsAType;
		this.functionActuallyReturns = _functionActuallyReturns;
		this.types.set(node_5029, /*Function*/[12,this.varTypes(vars_5031),ret_5052,variadic_5047,".Function"]);
	};
		fillModuleTypes(node_5058, params_5059, instanceOf_5060) {
		const temp_5061 = node_5058;
		switch (temp_5061&&temp_5061[0]) {
		case 25: {
			const t_5062 = temp_5061[1];
			const extend_5063 = temp_5061[2];
			const implement_5064 = temp_5061[3];
			const f_5065 = temp_5061[4];
			const external_5066 = temp_5061[5];
			{
				this.addScope(DataHelper.extractTypeName(t_5062), node_5058);
				const mod_5067 = this.currentModule;
				if (params_5059 != null) {};
				this.registerClassType(node_5058, null, params_5059, instanceOf_5060);
				this.currentModule = mod_5067;
			}
		} break;
		
		case 39: {
			const t_5068 = temp_5061[1];
			const f_5069 = temp_5061[2];
			const valuesType_5070 = temp_5061[3];
			{
				this.addScope(DataHelper.extractTypeName(t_5068), node_5058);
				const mod_5071 = this.currentModule;
				this.registerEnumType(node_5058);
				this.currentModule = mod_5071;
			}
		} break;
		
		case 9: {
			const alias_5072 = temp_5061[1];
			const value_5073 = temp_5061[2];
			{
				const type_5074 = new AliasType(value_5073);
				this.types.set(node_5058, /*Alias*/[11,type_5074,".Alias"]);
				this.addScope(this.nameOfModuleItem(node_5058), node_5058);
			}
		} break;
		
		default: 
		console.log('fillModuleTypes', node_5058)
		};
	};
		fill(node_5075) {
		const temp_5076 = node_5075;
		switch (temp_5076&&temp_5076[0]) {
		case 25: {
			this.fail('Defining classes within blocks not allowed', node_5075)
		} break;
		
		case 39: {
			this.fail('Defining enums within blocks not allowed', node_5075)
		} break;
		
		case 9: {
			const t_5077 = temp_5076[2];
			{
				this.fail('Defining alias within blocks not allowed', node_5075);
				const name_5078 = (() => {
					const temp_5079 = t_5077;
					switch (temp_5079&&temp_5079[0]) {
					case 1: {
						const name_5080 = temp_5079[1];
						return name_5080
					} break;
					
					case 2: {
						const name_5081 = temp_5079[1];
						return name_5081
					} break;
					
					case null: case undefined: {
						return (() => {
							this.fail('Type has no name: ' + NodeType.stringify(t_5077), node_5075);
							return '';
						})()
					} break;
					
					default: 
					return (() => {
						this.fail('Wrong alias format: ' + NodeType.stringify(t_5077), node_5075);
						return '';
					})()
					};
				})();
				const type_5082 = this.findActualType(name_5078);
				const alias_5083 = new AliasType(type_5082);
				this.types.set(node_5075, /*Alias*/[11,alias_5083,".Alias"]);
				this.addScope(this.nameOfModuleItem(node_5075), node_5075);
			}
		} break;
		
		case 12: {
			const el_5084 = temp_5076[1];
			{
				this.pushScope();
				for (const e of $toIterator(el_5084)) {
					{
						const temp_5085 = e;
						switch (temp_5085&&temp_5085[0]) {
						case 1: {
							const name_5086 = temp_5085[1];
							{
							}
						} break;
						};
					};
					this.fill(e);
				};
				this.popScope();
			}
		} break;
		
		case 24: {
			const name_5087 = temp_5076[1];
			const t_5088 = temp_5076[2];
			const e_5089 = temp_5076[3];
			const const_5090 = temp_5076[4];
			const external_5091 = temp_5076[5];
			{
				if ((e_5089 == null) && (const_5090) && ((!external_5091))) { this.fail(('Constant should have a value `let ' + (name_5087) + ' = value`'), node_5075) };
				if ((e_5089 == null) && ((!external_5091))) { this.fail(('Variable should have a value `var ' + (name_5087) + ' = value` or type set to nullable with a value of null `var ' + (name_5087) + ' T? = null`'), node_5075) };
				if ((e_5089 != null) && (external_5091)) { this.fail(('External variable should not have a value `declare let ' + (name_5087) + '`'), node_5075) };
				if ((t_5088 == null) && (external_5091)) { this.fail(('External variable should have a type `declare let ' + (name_5087) + ': T`'), node_5075) };
				if (e_5089 != null) {
					this.pushScope();
					{
						const temp_5092 = e_5089;
						switch (temp_5092&&temp_5092[0]) {
						case 31: {
							const el_5093 = temp_5092[1];
							if (el_5093.length == 0 && t_5088 != null) {
								{
								}
							break; } }
						
						default: 
						this.fillExpression(e_5089)
						};
					};
					this.popScope();
				};
				if (name_5087 == 'aazz') { console.log('before', t_5088 != null, e_5089 != null, node_5075 != null) };
				this.mixVarTypes(t_5088, e_5089, node_5075);
				if (name_5087 == 'aazz') { console.log('after') };
				this.addScope(name_5087, node_5075);
			}
		} break;
		
		case 10: {
			const a_5094 = temp_5076[1];
			const op_5095 = temp_5076[2];
			const b_5096 = temp_5076[3];
			{
				this.fillExpression(node_5075);
				const parent = this.parents.get(a_5094);
				if (op_5095 == 91) {
					const temp_5097 = parent;
					switch (temp_5097&&temp_5097[0]) {
					case null: case undefined: {
						{
							{
								const temp_5098 = a_5094;
								switch (temp_5098&&temp_5098[0]) {
								case 1: {
									{
									}
								} break;
								
								case 28: {
									{
									}
								} break;
								
								case 33: {
									{
										const typeA = this.types.get(a_5094);
										const typeB = this.types.get(b_5096);
										this.inferNullType(typeB, typeA, null);
									}
								} break;
								
								default: 
								this.fail(('Cannot reassign `' + (Node.stringify(a_5094)) + '`'), a_5094)
								};
							};
							this.inferEmptyArray(this.types.get(a_5094), b_5096);
						}
					} break;
					
					case 24: {
						const name_5099 = temp_5097[1];
						const const_5100 = temp_5097[4];
						{
							if (const_5100) { this.fail(('Cannot reassign a constant `let ' + (name_5099) + '`, redefine it as `var ' + (name_5099) + '` to allow reassignment\n') + this.positionOf(parent) + ('`let ' + (name_5099) + '` is defined here'), node_5075) };
							const typeA_5101 = this.types.get(a_5094);
							const typeB_5102 = this.types.get(b_5096);
							this.inferNullType(typeB_5102, typeA_5101, null);
							this.inferEmptyArray(typeA_5101, b_5096);
							const newType = this.unify(typeA_5101, typeB_5102, b_5096);
							this.types.set(node_5075, newType);
							const parentType = this.types.get(parent);
							{
								const temp_5103 = parentType;
								switch (temp_5103&&temp_5103[0]) {
								case null: case undefined: {
									this.types.set(parent, newType)
								} break;
								
								case 3: {
									const handle_5104 = temp_5103[1];
									if (handle_5104.value == null) { handle_5104.value = newType }
								} break;
								};
							};
						}
					} break;
					
					case 1: {
						const name_5105 = temp_5097[1];
						this.fail(('Cannot reassign case parameter `' + (name_5105) + '`'), node_5075)
					} break;
					
					case 22: {
						const name_5106 = temp_5097[1];
						this.fail(('Cannot reassign a function `' + (name_5106) + '`'), node_5075)
					} break;
					
					case 25: {
						this.fail('Cannot reassign class', node_5075)
					} break;
					
					case 39: {
						this.fail('Cannot reassign enum', node_5075)
					} break;
					
					case 49: {
						const name_5107 = temp_5097[1];
						this.fail(('Cannot reassign iterator value `' + (name_5107) + '` of for loop\n') + this.positionOf(parent) + ('`for ' + (name_5107) + ' in ...` is defined here'), node_5075)
					} break;
					
					case 47: {
						{
						}
					} break;
					
					case 4: {
						this.fail('Cannot reassign `super`', node_5075)
					} break;
					
					default: 
					this.fail('`=` not implemented for: ' + parent, node_5075)
					};
				};
			}
		} break;
		
		case 18: {
			if ((!this.allowBreakAndContinue)) { this.fail('Cannot use `break` outside of loop', node_5075) }
		} break;
		
		case 49: {
			const name_5108 = temp_5076[1];
			const over = temp_5076[2];
			const by = temp_5076[3];
			const range = temp_5076[4];
			{
				const iterableIntegers = [this.typeInt, this.typeUInt64, this.typeUInt32, this.typeUInt16, this.typeUInt8, this.typeInt64, this.typeInt32, this.typeInt16, this.typeInt8];
				this.pushScope();
				this.fillExpression(over);
				const overType = this.types.get(over);
				{
					const temp_5109 = overType;
					switch (temp_5109&&temp_5109[0]) {
					case 6: {
						const type_5110 = temp_5109[1];
						const generic_5111 = temp_5109[2];
						if ((generic_5111 != null) && (generic_5111.length == 1)) { this.types.set(node_5075, generic_5111[0]) } else if (iterableIntegers.includes(overType)) { this.types.set(node_5075, overType) } else {
							this.fail('Type of iterable is neither integer nor `Array`, but `' + Type.stringify(overType) + '`', over);
						}
					} break;
					
					case 4: {
						this.fail('Type of iterable should not be nullable', over)
					} break;
					
					case 3: {
						this.fail('Type of iterable should not be nullable', over)
					} break;
					
					case null: case undefined: {
						{
						}
					} break;
					
					default: 
					this.fail('Type of iterable is neither integer nor `Array`', over)
					};
				};
				{
					let step_5112 = 0;
					const range_5113 = range;
					if (step_5112 == 0 && range_5113 != null) { step_5112 = 1 };
					if (step_5112 == 1) {
						this.fillExpression(range_5113);
						const endType = this.types.get(range_5113);
						if ((!iterableIntegers.includes(endType))) { this.fail('Range end must be of integer type', range_5113) };
						if ((!iterableIntegers.includes(overType))) { this.fail('Range start must be of integer type', over) };
						if (endType != overType) { this.fail('Range start and end must be of the same type, but got `' + Type.stringify(overType) + '...' + Type.stringify(endType) + '`', over) };
						this.types.set(node_5075, overType);
					};
				};
				this.addScope(name_5108, node_5075);
				const _allowBreakAndContinue = this.allowBreakAndContinue;
				this.allowBreakAndContinue = true;
				{
					const temp_5114 = by;
					switch (temp_5114&&temp_5114[0]) {
					case 12: {
						{
						}
					} break;
					
					default: 
					this.fail('Loop body must be a `{` block `}`', by)
					};
				};
				this.fill(by);
				this.allowBreakAndContinue = _allowBreakAndContinue;
				this.popScope();
			}
		} break;
		
		case 22: {
			const name_5115 = temp_5076[1];
			const expr_5116 = temp_5076[2];
			const vars_5117 = temp_5076[3];
			const rettype_5118 = temp_5076[4];
			const external_5119 = temp_5076[5];
			{
				if (((!external_5119)) && (expr_5116 == null)) { this.fail(('Non-external function `' + (name_5115) + '` should have a body'), node_5075) };
				if ((external_5119) && (rettype_5118 == null)) { this.fail(('External function `' + (name_5115) + '` should have a returning type'), node_5075) };
				this.addScope(name_5115, node_5075);
				this.pushFuncParamsIfRequired(node_5075);
				this.fillFunction(node_5075, expr_5116, vars_5117, rettype_5118, false);
			}
		} break;
		
		case 14: {
			const econd = temp_5076[1];
			const eif = temp_5076[2];
			const eelse = temp_5076[3];
			{
				let depth_5121 = 0;
				for (const e of $toIterator(econd)) {
					const temp_5122 = e;
					switch (temp_5122&&temp_5122[0]) {
					case 24: {
						const name_5123 = temp_5122[1];
						const t_5124 = temp_5122[2];
						const expr_5125 = temp_5122[3];
						const const_5126 = temp_5122[4];
						{
							if ((!const_5126)) { this.fail('Only `if let` bindings supported, not `if var`', node_5075) };
							if (t_5124 != null) { this.fail('Do not specify a type `: T` in `if let` bindings', node_5075) };
							if (expr_5125 == null) { this.fail(('`if let` binding should have a value `' + (name_5123) + ' = value'), node_5075) };
							depth_5121++;
							this.pushScope();
							this.pushScope();
							this.fillExpression(expr_5125);
							this.popScope();
							{
								const temp_5127 = (this.types.get(expr_5125));
								switch (temp_5127&&temp_5127[0]) {
								case 4: {
									const t_5128 = temp_5127[1];
									this.types.set(e, t_5128)
								} break;
								
								case 3: {
									const handle_5129 = temp_5127[1];
									{
										let step_5130 = 0;
										const t_5131 = handle_5129.value;
										if (step_5130 == 0 && t_5131 != null) { step_5130 = 1 };
										if (step_5130 == 1) { this.types.set(e, t_5131) } else {
											this.fail('`if let` cannot bind not fully known nullable type', node_5075);
										};
									}
								} break;
								
								default: 
								this.types.set(e, this.types.get(expr_5125))
								};
							};
							this.addScope(name_5123, e);
						}
					} break;
					
					default: 
					{
						this.fillExpression(e);
						const type_5132 = this.types.get(e);
						if ((type_5132 != this.typeBool) && (type_5132 != this.typeAny) && (type_5132 != null)) {
							if (type_5132 == this.typeInt) { this.fail('Use `if ' + Node.stringify(e) + ' != 0` syntax to compare `Int` values with zero', e) };
							{
								const temp_5133 = e;
								switch (temp_5133&&temp_5133[0]) {
								case 10: {
									const a_5134 = temp_5133[1];
									const op_5135 = temp_5133[2];
									const b_5136 = temp_5133[3];
									if (op_5135 == 91) { this.fail('Probably change `=` to `==` here. `if value` expects `value` only of type `Bool`, but got `' + Type.stringify(type_5132) + '`', e) }
								} break;
								};
							};
							this.fail('`if value` expects `value` only of type `Bool`, but got `' + Type.stringify(type_5132) + '`', e);
						};
					}
					};
				};
				this.fill(eif);
				while (depth_5121 > 0) {
					depth_5121--;
					this.popScope();
				};
				if (eelse != null) { this.fill(eelse) };
			}
		} break;
		
		case 34: {
			const exprs = temp_5076[1];
			const conds = temp_5076[2];
			const guards = temp_5076[3];
			const cases = temp_5076[4];
			this.fillSwitch(node_5075, false)
		} break;
		
		case 27: {
			const e_5137 = temp_5076[1];
			const t_5138 = temp_5076[2];
			const v_5139 = temp_5076[3];
			const ca = temp_5076[4];
			{
				const _insideTry_5140 = this.insideTry;
				this.insideTry = true;
				{
					const temp_5141 = e_5137;
					switch (temp_5141&&temp_5141[0]) {
					case 12: {
						{
						}
					} break;
					
					default: 
					this.fail('Try body must be a `{ block }`', e_5137)
					};
				};
				this.fill(e_5137);
				this.insideTry = _insideTry_5140;
				{
					let i_5142 = 0;
					let it_5143 = 0;
					let at_5144 = ca.length;
					while (it_5143 < at_5144) {
						i_5142 = it_5143;
						it_5143++;
						{
							const type_5145 = this.toType(t_5138[i_5142], ca[i_5142]);
							{
								const temp_5146 = type_5145;
								switch (temp_5146&&temp_5146[0]) {
								case 13: {
									this.fail('Catch type must be a specific class, not `{}`', ca[i_5142])
								} break;
								
								case 12: {
									this.fail('Catch type must be a specific class, not function', ca[i_5142])
								} break;
								};
							};
							this.types.set(t_5138[i_5142], type_5145);
							this.pushScope();
							this.scopes[this.scopes.length - 1].set(DataHelper.varName(v_5139[i_5142]), v_5139[i_5142]);
							{
								const temp_5147 = ca[i_5142];
								switch (temp_5147&&temp_5147[0]) {
								case 12: {
									{
									}
								} break;
								
								default: 
								this.fail('Catch body must be a `{ block }`', ca[i_5142])
								};
							};
							this.fill(ca[i_5142]);
							this.popScope();
						};
					};
				};
			}
		} break;
		
		case 21: {
			const econd_5148 = temp_5076[1];
			const e_5149 = temp_5076[2];
			const pre = temp_5076[3];
			{
				if (pre == true) { this.fillExpression(econd_5148) };
				const _allowBreakAndContinue_5150 = this.allowBreakAndContinue;
				this.allowBreakAndContinue = true;
				{
					const temp_5151 = e_5149;
					switch (temp_5151&&temp_5151[0]) {
					case 12: {
						{
						}
					} break;
					
					default: 
					this.fail('`while` statements must be wrapped with a `{` block `}`', e_5149)
					};
				};
				this.fill(e_5149);
				this.allowBreakAndContinue = _allowBreakAndContinue_5150;
				if (pre == false) { this.fillExpression(econd_5148) };
				this.types.set(node_5075, this.typeVoid);
			}
		} break;
		
		case 19: {
			{
				this.types.set(node_5075, this.typeVoid);
				if ((!this.allowBreakAndContinue)) { this.fail('Cannot use `continue` outside of loop', node_5075) };
			}
		} break;
		
		default: 
		this.fillExpression(node_5075)
		};
	};
		fillExpression(node_5152) {
		const temp_5153 = node_5152;
		switch (temp_5153&&temp_5153[0]) {
		case 1: {
			const name_5154 = temp_5153[1];
			const params_5155 = temp_5153[2];
			{
				let subj_5156 = null;
				{
					let i_5157 = 0;
					let it_5158 = 0;
					let at_5159 = this.scopes.length;
					while (it_5158 < at_5159) {
						i_5157 = it_5158;
						it_5158++;
						{
							subj_5156 = this.scopes[this.scopes.length - i_5157 - 1].get(name_5154);
							if (subj_5156 != null) { break };
						};
					};
				};
				if (subj_5156 == null) { subj_5156 = this.findInNamespaceRoots(name_5154) };
				if ((subj_5156 == null) && (name_5154 == 'const')) { this.fail('No variable named `const` found. Are you trying to use `const` as a keyword? Use `let varname` syntax instead.', node_5152) };
				if (subj_5156 == null) { this.fail(('Cannot find variable with name `' + (name_5154) + '`'), node_5152) };
				if ((this.parents.get(node_5152) != null) && (this.parents.get(node_5152) != subj_5156)) { this.fail(('Parent overwritten from ' + (this.parents.get(node_5152)) + ' to ' + (subj_5156) + ' for node ' + (node_5152) + '') + '. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.', node_5152) };
				this.parents.set(node_5152, subj_5156);
				{
					let step_5160 = 0;
					const type_5161 = this.types.get(subj_5156);
					if (step_5160 == 0 && type_5161 != null) { step_5160 = 1 };
					if (step_5160 == 1) { this.types.set(node_5152, type_5161) };
				};
				{
					let step_5162 = 0;
					const params_5163 = params_5155;
					if (step_5162 == 0 && params_5163 != null) { step_5162 = 1 };
					if (step_5162 == 1) { for (const param of $toIterator(params_5163)) {
						this.types.set(param, this.toType(param, node_5152));
					} };
				};
			}
		} break;
		
		case 23: {
			const expr_5164 = temp_5153[1];
			const vars_5165 = temp_5153[2];
			const rettype_5166 = temp_5153[3];
			this.fillFunction(node_5152, expr_5164, vars_5165, rettype_5166, true)
		} break;
		
		case 22: {
			const name_5168 = temp_5153[1];
			const expr_5169 = temp_5153[2];
			const vars_5170 = temp_5153[3];
			const rettype_5171 = temp_5153[4];
			const external_5172 = temp_5153[5];
			{
				if (external_5172) { this.fail(('External function `declare fun ' + (name_5168) + '` cannot be taken as a value'), node_5152) };
				this.fillFunction(node_5152, expr_5169, vars_5170, rettype_5171, false);
			}
		} break;
		
		case 31: {
			const el_5174 = temp_5153[1];
			{
				const temp_5175 = el_5174[0];
				switch (temp_5175&&temp_5175[0]) {
				case 49: {
					const name_5176 = temp_5175[1];
					const over_5177 = temp_5175[2];
					const by_5178 = temp_5175[3];
					const range_5179 = temp_5175[4];
					{
						if (el_5174.length > 1) { this.fail('Cannot use loop `for` within array of more than one element `[for, ...]`', el_5174[1]) };
						if (range_5179 != null) { this.fail('Ranges `...range` are not supported here yet', range_5179) };
						this.pushScope();
						this.fillExpression(over_5177);
						const overType_5180 = this.types.get(over_5177);
						{
							const temp_5181 = overType_5180;
							switch (temp_5181&&temp_5181[0]) {
							case 6: {
								const type_5182 = temp_5181[1];
								const generic_5183 = temp_5181[2];
								if ((generic_5183 != null) && (generic_5183.length == 1)) { this.types.set(el_5174[0], generic_5183[0]) } else if (overType_5180 == this.typeInt) { this.types.set(el_5174[0], this.typeInt) } else if ((overType_5180 == this.typeUInt32) || (overType_5180 == this.typeUInt64)) { this.types.set(el_5174[0], overType_5180) } else {
									this.fail('Type of iterable is neither `Int` nor `Array`, but `' + Type.stringify(overType_5180) + '`', over_5177);
								}
							} break;
							
							case 4: {
								this.fail('Type of iterable should not be nullable', over_5177)
							} break;
							
							case 3: {
								this.fail('Type of iterable should not be nullable', over_5177)
							} break;
							
							case null: case undefined: {
								{
								}
							} break;
							
							default: 
							this.fail('Type of iterable is neiter Int nor Array', over_5177)
							};
						};
						this.addScope(name_5176, el_5174[0]);
						const _allowBreakAndContinue_5184 = this.allowBreakAndContinue;
						this.allowBreakAndContinue = false;
						this.fillExpression(by_5178);
						this.allowBreakAndContinue = _allowBreakAndContinue_5184;
						this.popScope();
						this.types.set(node_5152, this.typeArray.instantiateGeneric([this.types.get(by_5178)]));
					}
				} break;
				
				default: 
				{
					{
						let i_5185 = 0;
						let it_5186 = 0;
						let at_5187 = el_5174.length;
						while (it_5186 < at_5187) {
							i_5185 = it_5186;
							it_5186++;
							{
								const e_5188 = el_5174[i_5185];
								this.fillExpression(e_5188);
								{
									let step_5189 = 0;
									const elementsType = this.types.get(el_5174[0]);
									let temp_5190 = null;
									if (step_5189 == 0 && elementsType != null) {
										temp_5190 = i_5185 != 0;
										step_5189 = 1;
									};
									if (step_5189 == 1 && temp_5190 != false) { step_5189 = 2 };
									if (step_5189 == 2) { this.unify(elementsType, this.types.get(e_5188), e_5188) };
								};
							};
						};
					};
					this.types.set(node_5152, this.typeArray.instantiateGeneric([(((el_5174.length > 0))? (this.types.get(el_5174[0])) : /*Unknown*/[2,{value:null},".Unknown"])]));
				}
				};
			}
		} break;
		
		case 32: {
			const keys = temp_5153[1];
			const values = temp_5153[2];
			{
				if (keys.length == 0) {
					this.types.set(node_5152, this.typeMap.instantiateGeneric([/*Unknown*/[2,{value:null},".Unknown"], /*Unknown*/[2,{value:null},".Unknown"]]));
					return;
				};
				{
					let i_5191 = 0;
					let it_5192 = 0;
					let at_5193 = keys.length;
					while (it_5192 < at_5193) {
						i_5191 = it_5192;
						it_5192++;
						{
							this.fillExpression(keys[i_5191]);
							this.fillExpression(values[i_5191]);
						};
					};
				};
				this.types.set(node_5152, this.typeMap.instantiateGeneric([this.types.get(keys[0]), this.types.get(values[0])]));
			}
		} break;
		
		case 44: {
			const e_5194 = temp_5153[1];
			const kind_5195 = temp_5153[2];
			const t_5196 = temp_5153[3];
			{
				const type_5197 = this.toType(t_5196, node_5152);
				if (type_5197 == this.typeVoid) { this.fail('Conversion `as Void` makes no sense', e_5194) };
				this.fillExpression(e_5194);
				if (this.types.get(e_5194) == this.typeVoid) { this.fail(('Conversion of `value as ' + (Type.stringify(t_5196)) + '` where `value` is of type `Void` makes no sense'), e_5194) };
				this.types.set(t_5196, type_5197);
				this.types.set(node_5152, type_5197);
			}
		} break;
		
		case 43: {
			const e_5198 = temp_5153[1];
			const t_5199 = temp_5153[2];
			{
				const type_5200 = this.toType(t_5199, node_5152);
				if (type_5200 == this.typeAny) { this.fail('Comparing `is Any` makes no sense, always true', e_5198) };
				if (type_5200 == this.typeVoid) { this.fail('Comparing `is Void` makes no sense', e_5198) };
				this.fillExpression(e_5198);
				this.types.set(t_5199, type_5200);
				this.types.set(node_5152, this.typeBool);
			}
		} break;
		
		case 12: {
			const el_5201 = temp_5153[1];
			if (el_5201.length == 0) { this.types.set(node_5152, /*Struct*/[13,[],[],".Struct"]) } else {
				this.pushScope();
				{
					let i_5202 = 0;
					let it_5203 = 0;
					let at_5204 = el_5201.length;
					while (it_5203 < at_5204) {
						i_5202 = it_5203;
						it_5203++;
						{
							if (i_5202 < el_5201.length - 1) { this.fill(el_5201[i_5202]) };
						};
					};
				};
				const latest = el_5201[el_5201.length - 1];
				this.fillExpression(latest);
				this.types.set(node_5152, this.types.get(latest));
				this.popScope();
			}
		} break;
		
		case 28: {
			const e_5205 = temp_5153[1];
			const n = temp_5153[2];
			{
				{
					const temp_5206 = e_5205;
					switch (temp_5206&&temp_5206[0]) {
					case 4: {
						if ((!this.allowSuper)) { this.fail('Cannot access `super` here', node_5152) }
					} break;
					
					default: 
					this.fillExpression(e_5205)
					};
				};
				{
					let step_5207 = 0;
					const etype = (this.types.get(e_5205));
					if (step_5207 == 0 && etype != null) { step_5207 = 1 };
					if (step_5207 == 1) {
						const temp_5208 = etype;
						switch (temp_5208&&temp_5208[0]) {
						case 6: {
							const type_5209 = temp_5208[1];
							const generic_5210 = temp_5208[2];
							{
								type_5209.useless = false;
								if (etype == this.typeAny) {
									this.types.set(node_5152, this.typeAny);
									return;
								};
								const index_5211 = type_5209.fieldNames.indexOf(n, 0);
								const named_5212 = this.nameOfModuleItem(type_5209.parent);
								if (index_5211 < 0) {
									this.failNonFatal(('Type `' + (type_5209.name) + '` is defined here'), type_5209.parent);
									this.fail(('Class `' + (named_5212) + '` has no field `.' + (n) + '`\n') + this.proposeSimilar(type_5209.fieldNames, n, 'fields', null), (() => {
										const result_5213 = e_5205;
										if (result_5213 != null) { return result_5213 };
										return node_5152;
									})());
								};
								if (type_5209.fieldStatic[index_5211] == true) {
									this.failNonFatal(('Type `' + (type_5209.name) + '` is defined here'), type_5209.parent);
									this.fail(('Class `' + (named_5212) + '` field `.' + (n) + '` is static'), node_5152);
								};
								{
									const temp_5214 = type_5209.parent;
									switch (temp_5214&&temp_5214[0]) {
									case 25: {
										const t_5215 = temp_5214[1];
										const extend_5216 = temp_5214[2];
										const implement_5217 = temp_5214[3];
										const fields = temp_5214[4];
										const external_5218 = temp_5214[5];
										{
											const mod_5219 = this.currentModule;
											this.registerClassType(type_5209.parent, null, null, null);
											this.currentModule = mod_5219;
											for (const field of $toIterator(fields)) {
												if (DataHelper.nameOf(field) == n) {
													const genericFixup = (ofType, generic_5220) => {
														{
															const temp_5221 = ofType;
															switch (temp_5221&&temp_5221[0]) {
															case 1: {
																const genericParamIndex_5222 = temp_5221[1];
																const genericParam = temp_5221[2];
																{
																	if (generic_5220 == null) { return this.typeAny };
																	return generic_5220[genericParamIndex_5222];
																}
															} break;
															
															case 6: {
																const type_5223 = temp_5221[1];
																const generics = temp_5221[2];
																{
																	let step_5224 = 0;
																	const general = generics;
																	if (step_5224 == 0 && general != null) { step_5224 = 1 };
																	if (step_5224 == 1) { return type_5223.instantiateGeneric((() => {
																		const result_5225 = [];
																		const value_5226 = general;
																		for (const item of $toIterator(value_5226)) result_5225.push(genericFixup(item, generic_5220));
																		return result_5225;
																	})()) } else {
																		return ofType;
																	};
																}
															} break;
															
															case 4: {
																const type_5227 = temp_5221[1];
																return this.asNullable(genericFixup(type_5227, generic_5220))
															} break;
															
															case 12: {
																const args_5228 = temp_5221[1];
																const returns = temp_5221[2];
																const variadic_5229 = temp_5221[3];
																{
																	let returns_5230 = returns;
																	let changed = false;
																	const fixedReturns = genericFixup(returns_5230, generic_5220);
																	changed = fixedReturns != returns_5230;
																	returns_5230 = fixedReturns;
																	const reArgs = [];
																	for (const arg of $toIterator(args_5228)) {
																		const fixedArg = genericFixup(arg.type, generic_5220);
																		changed = changed || (fixedArg != arg.type);
																		const reArg = new FunctionArgument(fixedArg);
																		reArg.optional = arg.optional;
																		reArg.name = arg.name;
																		reArgs.push(reArg);
																	};
																	if (changed) { return /*Function*/[12,reArgs,returns_5230,variadic_5229,".Function"] };
																}
															} break;
															
															default: 
															{
															}
															};
														};
														return ofType;
													};
													const extractedType = (() => {
														const result_5231 = this.types.get(field);
														if (result_5231 != null) { return result_5231 };
														return (() => {
															const temp_5232 = field;
															switch (temp_5232&&temp_5232[0]) {
															case 24: {
																const name_5233 = temp_5232[1];
																const t_5234 = temp_5232[2];
																const e_5235 = temp_5232[3];
																const const_5236 = temp_5232[4];
																return ((t_5234 != null)? (this.toType(t_5234, field)) : null)
															} break;
															};
														})();
													})();
													this.types.set(node_5152, genericFixup(extractedType, generic_5210));
													this.parents.set(node_5152, field);
													if (extractedType == null) {
														console.log(this.positionOf(node_5152) + ('Note: field fieldInitialized[' + (n) + '] ='), type_5209.fieldInitialized[type_5209.fieldNames.indexOf(n, 0)]);
														this.fail('Type for this field cannot be inferred, try to specify types manually: `' + n + '`', field);
													};
												};
											};
										}
									} break;
									
									default: 
									this.fail('type.parent not a class, internal error', type_5209.parent)
									};
								};
							}
						} break;
						
						case 5: {
							const type_5237 = temp_5208[1];
							{
								type_5237.useless = false;
								const index_5238 = type_5237.fieldNames.indexOf(n, 0);
								if (index_5238 < 0) { this.fail(('Class `' + (this.nameOfModuleItem(type_5237.parent)) + '` has no static field `.' + (n) + '`\nAvailable fields are: ') + type_5237.fieldNames.join(', '), node_5152) };
								if (type_5237.fieldStatic[index_5238] != true) { this.fail(('Class `' + (this.nameOfModuleItem(type_5237.parent)) + '` field `.' + (n) + '` is not static'), node_5152) };
								{
									const temp_5239 = type_5237.parent;
									switch (temp_5239&&temp_5239[0]) {
									case 25: {
										const t_5240 = temp_5239[1];
										const extend_5241 = temp_5239[2];
										const implement_5242 = temp_5239[3];
										const fields_5243 = temp_5239[4];
										const external_5244 = temp_5239[5];
										for (const field of $toIterator(fields_5243)) {
											if (DataHelper.nameOf(field) == n) {
												this.types.set(node_5152, this.types.get(field));
												this.parents.set(node_5152, field);
											};
										}
									} break;
									
									default: 
									this.fail('type.parent not a class, internal error', type_5237.parent)
									};
								};
							}
						} break;
						
						case 8: {
							const type_5245 = temp_5208[1];
							{
								const index_5246 = type_5245.fieldNames.indexOf(n, 0);
								if (index_5246 < 0) { this.fail(('Enum `' + (type_5245.name) + '` has no field `.' + (n) + '`'), node_5152) };
								if ((!type_5245.fieldStatic[index_5246])) { this.fail(('Enum field `.' + (n) + '` is not static'), node_5152) };
								{
									const temp_5247 = type_5245.parent;
									switch (temp_5247&&temp_5247[0]) {
									case 39: {
										const t_5248 = temp_5247[1];
										const fields_5249 = temp_5247[2];
										const valuesType_5250 = temp_5247[3];
										for (const field of $toIterator(fields_5249)) {
											const temp_5251 = field;
											switch (temp_5251&&temp_5251[0]) {
											case 13: {
												{
												}
											} break;
											
											case 51: {
												{
												}
											} break;
											
											case 10: {
												{
												}
											} break;
											
											default: 
											if (DataHelper.nameOf(field) == n) {
												this.types.set(node_5152, this.types.get(field));
												this.parents.set(node_5152, field);
											}
											};
										}
									} break;
									
									default: 
									this.fail('type.parent not an enum, internal error', type_5245.parent)
									};
								};
							}
						} break;
						
						case 13: {
							const names_5252 = temp_5208[1];
							const els_5253 = temp_5208[2];
							{
								const index_5254 = names_5252.indexOf(n, 0);
								if (index_5254 < 0) {
									let object = '';
									{
										const temp_5255 = e_5205;
										switch (temp_5255&&temp_5255[0]) {
										case 1: {
											const name_5256 = temp_5255[1];
											object = (' `' + (name_5256) + '`')
										} break;
										
										default: 
										{
										}
										};
									};
									if (names_5252.length == 0) { this.fail(('Object' + (object) + ' is empty `{}` and has no fields. Create object with all fields defined upfront, like this: `obj = { ' + (n) + ': value }`'), node_5152) };
									if (names_5252.length != 0) { this.fail(('Object' + (object) + ' has no field `.' + (n) + '`\nAvailable fields are: ') + names_5252.join(', '), node_5152) };
								};
								this.types.set(node_5152, els_5253[index_5254]);
							}
						} break;
						
						case 3: {
							const handle_5257 = temp_5208[1];
							{
								this.failNonFatal(('Cannot access `.' + (n) + '` of nullable type `' + (Type.stringify(etype)) + '`, try to unwrap it with `if let`'), node_5152);
								this.types.set(node_5152, this.typeAny);
							}
						} break;
						
						case 4: {
							const type_5258 = temp_5208[1];
							{
								this.failNonFatal(('Cannot access `.' + (n) + '` of nullable type `' + (Type.stringify(etype)) + '`, try to unwrap it with `if let`'), node_5152);
								this.types.set(node_5152, this.typeAny);
							}
						} break;
						
						case 2: {
							const handle_5259 = temp_5208[1];
							{
								let step_5260 = 0;
								const type_5261 = handle_5259.value;
								if (step_5260 == 0 && type_5261 != null) { step_5260 = 1 };
								if (step_5260 == 1) { this.types.set(node_5152, type_5261) } else {
									{
										const temp_5262 = e_5205;
										switch (temp_5262&&temp_5262[0]) {
										case 13: {
											const what_5263 = temp_5262[1];
											{
												const temp_5264 = what_5263;
												switch (temp_5264&&temp_5264[0]) {
												case 1: {
													const name_5265 = temp_5264[1];
													this.failNonFatal(('Cannot access `.' + (n) + '` due to return type of `' + (name_5265) + '(...)` being unknown, try to specify a proper type (set full type `[T]` if this value coming from array)'), node_5152)
												} break;
												
												default: 
												this.failNonFatal(('Cannot access `.' + (n) + '` due to type of value being unknown, try to specify a proper type (set full type `[T]` if this value coming from array)'), node_5152)
												};
											}
										} break;
										
										case 1: {
											const name_5266 = temp_5262[1];
											{
											}
										} break;
										
										default: 
										this.failNonFatal(('Cannot access `.' + (n) + '` due to type of value being unknown, try to specify a proper type (set full type `[T]` if this value coming from array)'), node_5152)
										};
									};
									this.types.set(node_5152, this.typeAny);
								};
							}
						} break;
						
						case 1: {
							this.types.set(node_5152, this.typeAny)
						} break;
						
						case null: case undefined: {
							this.fail(('Cannot access `.' + (n) + '` due to type being `null`, seems to be internal compiler error'), node_5152)
						} break;
						
						case 12: {
							this.fail(('Cannot access `.' + (n) + '` of function type `' + (Type.stringify(etype)) + '`'), node_5152)
						} break;
						
						default: 
						this.fail(('Cannot access `.' + (n) + '` due to type being unhandled `' + (Type.stringify(etype)) + '`, seems to be internal compiler error'), node_5152)
						};
					} else {
						this.types.set(node_5152, this.typeAny);
					};
				};
			}
		} break;
		
		case 29: {
			const e_5267 = temp_5153[1];
			const n_5268 = temp_5153[2];
			{
				{
					const temp_5269 = e_5267;
					switch (temp_5269&&temp_5269[0]) {
					case 4: {
						this.fail('Cannot access `super` here', node_5152)
					} break;
					};
				};
				this.fillExpression(e_5267);
				{
					const temp_5270 = (this.types.get(e_5267));
					switch (temp_5270&&temp_5270[0]) {
					case 9: {
						const type_5271 = temp_5270[1];
						{
							this.failNonFatal(('Type `' + (type_5271.name) + '` is defined here'), type_5271.parent);
							this.fail(('Enum `' + (type_5271.name) + '` instance has no field `.' + (n_5268) + '`'), node_5152);
						}
					} break;
					
					case 6: {
						const type_5272 = temp_5270[1];
						{
							this.failNonFatal(('Type `' + (type_5272.name) + '` is defined here'), type_5272.parent);
							this.fail(('Class `' + (type_5272.name) + '` has no field `.' + (n_5268) + '`\n\nNote that you are trying to access plain `class` instance and not `enum`'), node_5152);
						}
					} break;
					
					case 5: {
						const type_5273 = temp_5270[1];
						{
							this.failNonFatal(('Type `' + (type_5273.name) + '` is defined here'), type_5273.parent);
							this.fail(('Class `' + (type_5273.name) + '` has no field `.' + (n_5268) + '`\n\nNote that you are trying to access `class` and not `enum`'), node_5152);
						}
					} break;
					
					case 8: {
						const type_5274 = temp_5270[1];
						{
							const index_5275 = type_5274.fieldNames.indexOf(n_5268, 0);
							if (index_5275 < 0) {
								this.failNonFatal(('Type `' + (type_5274.name) + '` is defined here'), type_5274.parent);
								this.fail(('Enum `' + (type_5274.name) + '` has no value constructor `.' + (n_5268) + '`\n') + this.proposeSimilar(type_5274.fieldNames.filter((element, index_5276) => (type_5274.fieldEnumConstructor[index_5276])), n_5268, 'constructors', null), node_5152);
							};
							if (type_5274.fieldEnumConstructor[index_5275] != true) { this.fail(('Enum `' + (type_5274.name) + '` field `.' + (n_5268) + '` is not a value constructor'), node_5152) };
							{
								let step_5277 = 0;
								const fieldType = type_5274.fieldType[index_5275];
								if (step_5277 == 0 && fieldType != null) { step_5277 = 1 };
								if (step_5277 == 1) { this.types.set(node_5152, fieldType) } else {
									this.fail(('Enum `' + (type_5274.name) + '` field type is null for `' + (Node.stringify(node_5152)) + '`'), node_5152);
								};
							};
						}
					} break;
					
					case null: case undefined: {
						this.fail(('Accessing non-existing field `.' + (n_5268) + '` of `' + (Node.stringify(e_5267)) + '`'), node_5152)
					} break;
					
					default: 
					{
					}
					};
				};
			}
		} break;
		
		case 51: {
			const t_5278 = temp_5153[1];
			{
				const temp_5279 = t_5278;
				switch (temp_5279&&temp_5279[0]) {
				case 1: {
					const name_5280 = temp_5279[1];
					{
						const subj_5281 = this.find(name_5280);
						if (subj_5281 == null) { this.fail(('Cannot find type with name `' + (name_5280) + '`'), node_5152) };
						if ((this.parents.get(node_5152) != null) && (this.parents.get(node_5152) != subj_5281)) { this.fail(('Parent overwitten from ' + (this.parents.get(node_5152)) + ' to ' + (subj_5281) + ' for node ' + (node_5152) + '') + '. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.', node_5152) };
						this.parents.set(node_5152, subj_5281);
						{
							let step_5282 = 0;
							const type_5283 = this.types.get(subj_5281);
							if (step_5282 == 0 && type_5283 != null) { step_5282 = 1 };
							if (step_5282 == 1) { this.types.set(node_5152, type_5283) } else {
								{
									const temp_5284 = subj_5281;
									switch (temp_5284&&temp_5284[0]) {
									case 25: {
										{
											const mod_5285 = this.currentModule;
											this.registerClassType(subj_5281, null, null, null);
											this.currentModule = mod_5285;
										}
									} break;
									
									case 39: {
										this.registerEnumType(subj_5281)
									} break;
									};
								};
								{
									let step_5286 = 0;
									const type_5287 = this.types.get(subj_5281);
									if (step_5286 == 0 && type_5287 != null) { step_5286 = 1 };
									if (step_5286 == 1) { this.types.set(node_5152, type_5287) } else {
										console.log(this.positionOf(subj_5281) + ('' + (name_5280) + ' is here'));
										this.fail(('Cannot find type for `' + (name_5280) + '` even after late build') + '. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.', node_5152);
									};
								};
							};
						};
					}
				} break;
				
				case 2: {
					const name_5288 = temp_5279[1];
					this.fail(('Cannot use generic type `' + (name_5288) + '` as a value'), node_5152)
				} break;
				
				default: 
				this.fail('Cannot use this type as a value', node_5152)
				};
			}
		} break;
		
		case 30: {
			const path_5289 = temp_5153[1];
			const t_5290 = temp_5153[2];
			const el_5291 = temp_5153[3];
			const names_5292 = temp_5153[4];
			const values_5293 = temp_5153[5];
			{
				const type_5294 = this.toType(t_5290, node_5152);
				const subj_5295 = this.find(DataHelper.extractTypeName(t_5290));
				this.parents.set(node_5152, subj_5295);
				for (const e of $toIterator(el_5291)) {
					this.fillExpression(e);
				};
				{
					const temp_5296 = type_5294;
					switch (temp_5296&&temp_5296[0]) {
					case 6: {
						const type_5297 = temp_5296[1];
						{
							if (type_5297.constructor == (-1)) { this.fail('Cannot construct class without `new () {}` constructor', node_5152) };
							type_5297.useless = false;
						}
					} break;
					
					default: 
					this.fail('Constructor `new` may instantiate only classes', node_5152)
					};
				};
				this.types.set(node_5152, type_5294);
			}
		} break;
		
		case 38: {
			const names_5298 = temp_5153[1];
			const el_5299 = temp_5153[2];
			{
				{
					let name_5300 = 0;
					let it_5301 = 0;
					let at_5302 = names_5298.length;
					while (it_5301 < at_5302) {
						name_5300 = it_5301;
						it_5301++;
						{
							if (names_5298.indexOf(names_5298[name_5300], 0) != name_5300) { this.fail(('Field `' + (names_5298[name_5300]) + '` already exists'), node_5152) };
						};
					};
				};
				for (const e of $toIterator(el_5299)) {
					this.fillExpression(e);
				};
				const els_5303 = (() => {
					const result_5304 = [];
					const value_5305 = el_5299;
					for (const e of $toIterator(value_5305)) result_5304.push(this.types.get(e));
					return result_5304;
				})();
				this.types.set(node_5152, /*Struct*/[13,names_5298,els_5303,".Struct"]);
			}
		} break;
		
		case 27: {
			const e_5306 = temp_5153[1];
			const t_5307 = temp_5153[2];
			const v_5308 = temp_5153[3];
			const ca_5309 = temp_5153[4];
			{
				const _insideTry_5310 = this.insideTry;
				this.insideTry = true;
				this.fillExpression(e_5306);
				this.insideTry = _insideTry_5310;
				{
					let i_5311 = 0;
					let it_5312 = 0;
					let at_5313 = ca_5309.length;
					while (it_5312 < at_5313) {
						i_5311 = it_5312;
						it_5312++;
						{
							this.pushScope();
							this.scopes[this.scopes.length - 1].set(DataHelper.varName(v_5308[i_5311]), v_5308[i_5311]);
							this.fill(ca_5309[i_5311]);
							this.popScope();
						};
					};
				};
				this.types.set(node_5152, this.types.get(e_5306));
			}
		} break;
		
		case 14: {
			const econd_5314 = temp_5153[1];
			const eif_5315 = temp_5153[2];
			const eelse_5316 = temp_5153[3];
			const ternary = temp_5153[4];
			{
				if (econd_5314.length > 1) { this.fail('More than one condition is not yet supported', econd_5314[1]) };
				{
					const temp_5317 = econd_5314[0];
					switch (temp_5317&&temp_5317[0]) {
					case 24: {
						this.fail('Variable bindings in ternary conditions are not yet supported', econd_5314[0])
					} break;
					};
				};
				if (eelse_5316 == null) { this.fail('Expression `if` should have an `else` clause', eif_5315) };
				this.fillExpression(econd_5314[0]);
				if (ternary == false) {
					{
						const temp_5318 = eif_5315;
						switch (temp_5318&&temp_5318[0]) {
						case 12: {
							{
							}
						} break;
						
						default: 
						this.fail('Ternary `if` should have a `{ block }` as a body', eif_5315)
						};
					};
					{
						const temp_5319 = eelse_5316;
						switch (temp_5319&&temp_5319[0]) {
						case 12: {
							{
							}
						} break;
						
						default: 
						this.fail('Ternary `else` should have a `{ block }` as a body', eelse_5316)
						};
					};
				};
				this.fillExpression(eif_5315);
				this.fillExpression(eelse_5316);
				this.types.set(node_5152, this.unify(this.types.get(eif_5315), this.types.get(eelse_5316), eelse_5316));
			}
		} break;
		
		case 8: {
			this.types.set(node_5152, /*UnknownNullable*/[3,{value:null},".UnknownNullable"])
		} break;
		
		case 0: {
			this.types.set(node_5152, this.typeString)
		} break;
		
		case 2: {
			this.types.set(node_5152, this.typeBool)
		} break;
		
		case 5: {
			this.types.set(node_5152, this.typeInt)
		} break;
		
		case 6: {
			const meta_5320 = temp_5153[2];
			{
				{
					const temp_5321 = meta_5320;
					switch (temp_5321) {
					case 1: {
						this.types.set(node_5152, this.typeBigInt)
					} break;
					
					case 2: {
						this.types.set(node_5152, this.typeInt32)
					} break;
					
					case 3: {
						this.types.set(node_5152, this.typeInt64)
					} break;
					
					case 4: {
						this.types.set(node_5152, this.typeInt16)
					} break;
					
					case 5: {
						this.types.set(node_5152, this.typeInt8)
					} break;
					
					case 6: {
						this.types.set(node_5152, this.typeUInt32)
					} break;
					
					case 7: {
						this.types.set(node_5152, this.typeUInt64)
					} break;
					
					case 8: {
						this.types.set(node_5152, this.typeUInt16)
					} break;
					
					case 9: {
						this.types.set(node_5152, this.typeUInt8)
					} break;
					
					case 10: {
						this.types.set(node_5152, this.typeFloat32)
					} break;
					
					default: 
					this.fail('Unhandled meta type of number', node_5152)
					};
				};
				if (this.types.get(node_5152) == null) {
					const name_5322 = Meta.stringify(meta_5320);
					this.fail(('Number literal of type `' + (name_5322) + '` fail, probably standard library of the current target does not define `class ' + (name_5322) + '` type'), node_5152);
				};
			}
		} break;
		
		case 7: {
			const v_5323 = temp_5153[1];
			const meta_5324 = temp_5153[2];
			if (meta_5324 == 10) { this.types.set(node_5152, this.typeFloat32) } else {
				this.types.set(node_5152, this.typeFloat);
			}
		} break;
		
		case 15: {
			const e_5325 = temp_5153[1];
			{
				this.fillExpression(e_5325);
				this.types.set(node_5152, this.types.get(e_5325));
			}
		} break;
		
		case 50: {
			const a_5326 = temp_5153[1];
			const b_5327 = temp_5153[2];
			{
				this.fillExpression(a_5326);
				this.fillExpression(b_5327);
				this.unify(this.types.get(a_5326), this.types.get(b_5327), b_5327);
				this.types.set(node_5152, this.types.get(b_5327));
			}
		} break;
		
		case 13: {
			const e_5328 = temp_5153[1];
			const el_5329 = temp_5153[2];
			const elNames = temp_5153[3];
			{
				{
					const temp_5330 = e_5328;
					switch (temp_5330&&temp_5330[0]) {
					case 4: {
						if ((!this.allowSuper)) { this.fail('Cannot access `super` here', node_5152) }
					} break;
					
					default: 
					this.fillExpression(e_5328)
					};
				};
				const evaluateArguments = (el_5331, expected) => {
					let arg_5332 = expected[0];
					{
						let i_5333 = 0;
						let it_5334 = 0;
						let at_5335 = el_5331.length;
						while (it_5334 < at_5335) {
							i_5333 = it_5334;
							it_5334++;
							{
								const e_5336 = el_5331[i_5333];
								{
									const temp_5337 = e_5336;
									switch (temp_5337&&temp_5337[0]) {
									case 23: {
										this.expectedArrowType.set(e_5336, arg_5332)
									} break;
									};
								};
								this.fillExpression(e_5336);
								const argumentValueType = this.types.get(el_5331[i_5333]);
								const expectedType = arg_5332;
								this.inferNullType(argumentValueType, expectedType, el_5331[i_5333]);
								this.unify(expectedType, argumentValueType, el_5331[i_5333]);
								arg_5332 = (() => {
									const result_5338 = expected[i_5333 + 1];
									if (result_5338 != null) { return result_5338 };
									return arg_5332;
								})();
							};
						};
					};
				};
				const obviousTyping = (node_5339) => {
					{
						const temp_5340 = node_5339;
						switch (temp_5340&&temp_5340[0]) {
						case 22: {
							const name_5341 = temp_5340[1];
							const expr_5342 = temp_5340[2];
							const vars_5343 = temp_5340[3];
							const rettype_5344 = temp_5340[4];
							const variadic_5345 = temp_5340[6];
							{
								this.pushFuncParamsIfRequired(node_5339);
								{
									let step_5346 = 0;
									const rettype_5347 = rettype_5344;
									if (step_5346 == 0 && rettype_5347 != null) { step_5346 = 1 };
									if (step_5346 == 1) { this.types.set(node_5339, /*Function*/[12,this.varTypes(vars_5343),this.toType(rettype_5347, node_5339),variadic_5345,".Function"]) } else {
										this.types.set(node_5339, /*Function*/[12,this.varTypes(vars_5343),/*Unknown*/[2,{handle:null},".Unknown"],variadic_5345,".Function"]);
									};
								};
								this.popFuncParamsIfRequired(node_5339);
							}
						} break;
						};
					};
					return this.types.get(node_5339);
				};
				const eType = (() => {
					const result_5348 = this.types.get(e_5328);
					if (result_5348 != null) { return result_5348 };
					return obviousTyping((() => {
						const result_5349 = this.parents.get(e_5328);
						if (result_5349 != null) { return result_5349 };
						return e_5328;
					})());
				})();
				{
					const temp_5350 = eType;
					switch (temp_5350&&temp_5350[0]) {
					case 12: {
						const args_5351 = temp_5350[1];
						const returns_5352 = temp_5350[2];
						const variadic_5353 = temp_5350[3];
						{
							const provided = el_5329.length;
							let expectedAtMax = args_5351.length;
							let expectedAtLeast = 0;
							const variadicLimit = 255;
							for (const arg of $toIterator(args_5351)) {
								expectedAtLeast++;
								if (arg.optional) { expectedAtLeast-- };
							};
							if (variadic_5353) {
								expectedAtMax = 255;
								expectedAtLeast--;
							};
							if (provided < expectedAtLeast) { this.fail(('Not enough function arguments, required ' + (expectedAtLeast) + ' but got only ' + (provided) + ''), node_5152) };
							if (provided > expectedAtMax) { this.fail(('Too many function arguments, expected only ' + (expectedAtMax) + ' but got ' + (provided) + ''), node_5152) };
							evaluateArguments(el_5329, args_5351.map((arg_5354) => (arg_5354.type)));
							this.types.set(node_5152, returns_5352);
						}
					} break;
					
					case 10: {
						const type_5355 = temp_5350[1];
						const tag = temp_5350[2];
						{
							const name_5356 = type_5355.fieldNames[tag];
							if (el_5329.length < type_5355.tagBindVars[tag].length) { this.fail(('Not enough enum parameters, required `' + (name_5356) + '` parameters are: `') + type_5355.tagBindVarsNames[tag].join('`, `') + '`', node_5152) };
							if (el_5329.length > type_5355.tagBindVars[tag].length) { this.fail(('Too many enum parameters, required `' + (name_5356) + '` parameters are: `') + type_5355.tagBindVarsNames[tag].join('`, `') + '`', node_5152) };
							if (el_5329.length == 0) { this.fail('Use syntax without empty `()`', node_5152) };
							evaluateArguments(el_5329, this.typesOfTagArguments(type_5355, tag));
							this.types.set(node_5152, /*EnumInstance*/[9,type_5355,tag,".EnumInstance"]);
						}
					} break;
					
					case null: case undefined: {
						evaluateArguments(el_5329, [])
					} break;
					
					default: 
					{
						evaluateArguments(el_5329, []);
						if (this.types.get(e_5328) == this.typeAny) { this.types.set(node_5152, this.typeAny) } else {
							this.fail('Calling *not* a function, type is `' + Type.stringify(this.types.get(e_5328)) + '`', e_5328);
						};
					}
					};
				};
			}
		} break;
		
		case 10: {
			const a_5357 = temp_5153[1];
			const op_5358 = temp_5153[2];
			const b_5359 = temp_5153[3];
			{
				this.fillExpression(a_5357);
				this.fillExpression(b_5359);
				const typeA_5360 = this.types.get(a_5357);
				const typeB_5361 = this.types.get(b_5359);
				this.inferNullType(typeA_5360, typeB_5361, a_5357);
				this.inferNullType(typeB_5361, typeA_5360, b_5359);
				if ((op_5358 == 111) && (typeA_5360 == this.typeString)) { this.types.set(node_5152, this.typeString) } else if (op_5358 == 92 || op_5358 == 93) {
					const token = ((op_5358 == 92)? ('and') : 'or');
					if ((!this.booleanable(typeA_5360))) { this.fail(('Operator `a ' + (token) + ' b` takes `a` of type `Bool` only, but got `' + (Type.stringify(typeA_5360)) + '`'), a_5357) };
					if ((!this.booleanable(typeB_5361))) { this.fail(('Operator `a ' + (token) + ' b` takes `b` of type `Bool` only, but got `' + (Type.stringify(typeB_5361)) + '`'), b_5359) };
					this.types.set(node_5152, this.typeBool);
				} else if ((typeA_5360 == typeB_5361) && (typeA_5360 == this.typeString) && ((op_5358 == 97) || (op_5358 == 96) || (op_5358 == 100) || (op_5358 == 99))) { this.types.set(node_5152, this.typeBool) } else if (op_5358 == 95 || op_5358 == 103) {
					const booleans = (typeA_5360 == typeB_5361) && (typeA_5360 == this.typeBool);
					const comparable = this.areComparable(typeA_5360, typeB_5361);
					const covariant = this.areCovariant(typeA_5360, typeB_5361, false);
					const nullableA = this.unwrapUnknownAndNullable(typeA_5360);
					const nullableB = this.unwrapUnknownAndNullable(typeB_5361);
					const nullable_5362 = nullableA == nullableB;
					this.inferNullType(typeA_5360, typeB_5361, null);
					this.inferNullType(typeB_5361, typeA_5360, null);
					if (((!comparable)) && ((!booleans)) && ((!covariant)) && ((!nullable_5362))) {
						const tokenString = Token.stringify(op_5358);
						const leftString = (() => {
							const temp_5363 = a_5357;
							switch (temp_5363&&temp_5363[0]) {
							case 8: {
								return 'null'
							} break;
							
							default: 
							return Type.stringify(typeA_5360)
							};
						})();
						const rightString = (() => {
							const temp_5364 = b_5359;
							switch (temp_5364&&temp_5364[0]) {
							case 8: {
								return 'null'
							} break;
							
							default: 
							return Type.stringify(typeB_5361)
							};
						})();
						if ((leftString != 'null') && (rightString != 'null')) { this.fail(('Operator `a ' + (tokenString) + ' b` requires `a` and `b` of comparable types, but got `' + (leftString) + '` and `' + (rightString) + '`'), b_5359) };
					};
					this.types.set(node_5152, this.typeBool);
				} else if ((op_5358 == 97) || (op_5358 == 96) || (op_5358 == 100) || (op_5358 == 99) || (op_5358 == 95) || (op_5358 == 103)) {
					const comparable_5365 = this.areComparable(typeA_5360, typeB_5361);
					if ((!comparable_5365)) {
						const tokenString_5366 = Token.stringify(op_5358);
						const leftString_5367 = (() => {
							const temp_5368 = a_5357;
							switch (temp_5368&&temp_5368[0]) {
							case 8: {
								return 'null'
							} break;
							
							default: 
							return Type.stringify(typeA_5360)
							};
						})();
						const rightString_5369 = (() => {
							const temp_5370 = b_5359;
							switch (temp_5370&&temp_5370[0]) {
							case 8: {
								return 'null'
							} break;
							
							default: 
							return Type.stringify(typeB_5361)
							};
						})();
						this.fail(('Operator `a ' + (tokenString_5366) + ' b` requires `a` and `b` of comparable non-nullable types, but got `' + (leftString_5367) + '` and `' + (rightString_5369) + '`'), b_5359);
					};
					this.types.set(node_5152, this.typeBool);
				} else {
					const typeLeft = (() => {
						const result_5371 = this.types.get(a_5357);
						if (result_5371 != null) { return result_5371 };
						return this.types.get(b_5359);
					})();
					let typeRight = (() => {
						const result_5372 = this.types.get(b_5359);
						if (result_5372 != null) { return result_5372 };
						return this.types.get(a_5357);
					})();
					if ((typeLeft == this.typeUInt32) && (typeRight == this.typeInt)) { typeRight = this.typeUInt32 };
					if ((typeLeft == this.typeUInt64) && (typeRight == this.typeInt)) { typeRight = this.typeUInt64 };
					if ((typeLeft == this.typeUInt16) && (typeRight == this.typeInt)) { typeRight = this.typeUInt16 };
					this.types.set(node_5152, typeRight);
				};
			}
		} break;
		
		case 20: {
			const op_5373 = temp_5153[1];
			const postfix = temp_5153[2];
			const e_5374 = temp_5153[3];
			{
				this.fillExpression(e_5374);
				if ((op_5373 == 89) && ((!postfix))) {
					const type_5375 = this.types.get(e_5374);
					if ((!this.booleanable(type_5375))) { this.fail(('Operator `not value` takes `value` of type `Bool` only, but got `' + (Type.stringify(this.types.get(e_5374))) + '`'), e_5374) };
					this.types.set(node_5152, this.typeBool);
					return;
				};
				this.types.set(node_5152, this.types.get(e_5374));
				const mutates = op_5373 == 87 || op_5373 == 86;
				if ((!mutates)) { return };
				const parent_5376 = this.parents.get(e_5374);
				{
					const temp_5377 = parent_5376;
					switch (temp_5377&&temp_5377[0]) {
					case 24: {
						const name_5378 = temp_5377[1];
						const const_5379 = temp_5377[4];
						if (const_5379) { this.fail(('Cannot change a constant `let ' + (name_5378) + '`, redefine it as `var ' + (name_5378) + '` to allow value changes\n') + this.positionOf(parent_5376) + ('`let ' + (name_5378) + '` is defined here'), node_5152) }
					} break;
					
					case 22: {
						const name_5380 = temp_5377[1];
						this.fail(('Cannot `' + (Token.stringify(op_5373)) + '` a function `' + (name_5380) + '`'), node_5152)
					} break;
					
					case 49: {
						const name_5381 = temp_5377[1];
						this.fail(('Cannot change iterator value `' + (name_5381) + '` of for loop\n') + this.positionOf(parent_5376) + ('`for ' + (name_5381) + ' in ...` is defined here'), node_5152)
					} break;
					
					case 47: {
						const f_5382 = temp_5377[1];
						{
							const temp_5383 = f_5382;
							switch (temp_5383&&temp_5383[0]) {
							case 22: {
								const name_5384 = temp_5383[1];
								this.fail(('Cannot `' + (Token.stringify(op_5373)) + '` a `static fun ' + (name_5384) + '`'), node_5152)
							} break;
							
							case 24: {
								const name_5385 = temp_5383[1];
								const const_5386 = temp_5383[4];
								if (const_5386) { this.fail(('Cannot change a constant `static let ' + (name_5385) + '`, redefine it as `static var ' + (name_5385) + '` to allow value changes\n') + this.positionOf(parent_5376) + ('`static let ' + (name_5385) + '` is defined here'), node_5152) }
							} break;
							};
						}
					} break;
					
					default: 
					{
						const temp_5387 = e_5374;
						switch (temp_5387&&temp_5387[0]) {
						case 33: {
							{
							}
						} break;
						
						default: 
						{
							const ops = ((87)? ('increment `++`') : 'decrement `--`');
							this.fail(('You can ' + (ops) + ' only a variable, .field or array element'), node_5152);
						}
						};
					}
					};
				};
				const hha = 1;
			}
		} break;
		
		case 33: {
			const e_5388 = temp_5153[1];
			const i_5389 = temp_5153[2];
			{
				this.fillExpression(e_5388);
				this.fillExpression(i_5389);
				const eType_5390 = (this.types.get(e_5388));
				const iType = (this.types.get(i_5389));
				let indexableIsAny = false;
				let indexableIsMap = false;
				let mapKey = null;
				{
					const temp_5391 = eType_5390;
					switch (temp_5391&&temp_5391[0]) {
					case 6: {
						const type_5392 = temp_5391[1];
						const generic_5393 = temp_5391[2];
						{
							if (type_5392.name == 'Any') { indexableIsAny = true };
							if (type_5392.name == 'Map') {
								indexableIsMap = true;
								mapKey = generic_5393[0];
							};
						}
					} break;
					
					case 4: {
						this.fail(('Cannot index `' + (Node.stringify(e_5388)) + '` because `' + (Type.stringify(eType_5390)) + '` can be null, try to extract its value with `if let value = ' + (Node.stringify(e_5388)) + '`'), e_5388)
					} break;
					
					case 3: {
						const handle_5394 = temp_5391[1];
						this.fail(('Cannot index `' + (Node.stringify(e_5388)) + '` because `' + (Type.stringify(eType_5390)) + '` can be null, try to extract its value with `if let value = ' + (Node.stringify(e_5388)) + '`'), e_5388)
					} break;
					};
				};
				if ((!indexableIsAny)) {
					const temp_5395 = iType;
					switch (temp_5395&&temp_5395[0]) {
					case 1: {
						{
						}
					} break;
					
					case 6: {
						const type_5396 = temp_5395[1];
						{
							if (((!indexableIsMap)) && (type_5396.name != 'Int') && (type_5396.name != 'UInt64') && (type_5396.name != 'UInt32') && (type_5396.name != 'UInt16') && (type_5396.name != 'UInt8') && (type_5396.name != 'Int64') && (type_5396.name != 'Int32') && (type_5396.name != 'Int16') && (type_5396.name != 'Int8') && (type_5396.name != 'Any') && (type_5396.name != 'UInt64')) { this.fail('`value[index]` expects `index` only of type `Int` or similar, but got `' + Type.stringify(iType) + '`', e_5388) };
							if ((indexableIsMap) && (iType != mapKey)) { this.fail(('`map[key]` expects `key` only of type `' + (Type.stringify(mapKey)) + '`, but got `') + Type.stringify(iType) + '`', e_5388) };
						}
					} break;
					
					case null: case undefined: {
						{
						}
					} break;
					
					default: 
					this.fail('`value[i]` expects `i` only of type `Int` or similar, but got `' + Type.stringify(iType) + '`', e_5388)
					};
				};
				{
					const temp_5397 = eType_5390;
					switch (temp_5397&&temp_5397[0]) {
					case 6: {
						const type_5398 = temp_5397[1];
						const generic_5399 = temp_5397[2];
						if ((generic_5399 != null) && (generic_5399.length >= 1)) { if (type_5398.name == 'Map') { this.types.set(node_5152, generic_5399[1]) } else {
							this.types.set(node_5152, generic_5399[0]);
						} } else if (['Buffer', 'Uint8Array', 'Uint32Array'].includes(type_5398.name)) { this.types.set(node_5152, this.toType(/*Type*/[1,'Int',null,".Type"], node_5152)) } else if (['Any'].includes(type_5398.name)) { this.types.set(node_5152, this.toType(/*Type*/[1,'Any',null,".Type"], node_5152)) } else {
							this.fail(('Cannot index `' + (Node.stringify(e_5388)) + '` because `' + (Type.stringify(eType_5390)) + '` is not indexable'), e_5388);
						}
					} break;
					
					case null: case undefined: {
						{
						}
					} break;
					
					default: 
					{
					}
					};
				};
			}
		} break;
		
		case 11: {
			const a_5400 = temp_5153[1];
			const op_5401 = temp_5153[2];
			const b_5402 = temp_5153[3];
			{
				if (op_5401 == 95) { this.fail('`===` not supported, use `strictEqual`', node_5152) };
				if (op_5401 == 95) { this.fail('`!==` not supported, use `strictNotEqual`', node_5152) };
				this.fillExpression(a_5400);
				const parent_5403 = this.parents.get(a_5400);
				{
					const temp_5404 = parent_5403;
					switch (temp_5404&&temp_5404[0]) {
					case 24: {
						const name_5405 = temp_5404[1];
						const const_5406 = temp_5404[4];
						if (const_5406) { this.fail(('Cannot change a constant `let ' + (name_5405) + '`, redefine it as `var ' + (name_5405) + '` to allow value changes\n') + this.positionOf(parent_5403) + ('`let ' + (name_5405) + '` is defined here'), node_5152) }
					} break;
					
					case 22: {
						const name_5407 = temp_5404[1];
						this.fail(('Cannot reassign a function `' + (name_5407) + '`'), node_5152)
					} break;
					
					case 49: {
						const name_5408 = temp_5404[1];
						this.fail(('Cannot change iterator value `' + (name_5408) + '` of for loop\n') + this.positionOf(parent_5403) + ('`for ' + (name_5408) + ' in ...` is defined here'), node_5152)
					} break;
					
					default: 
					{
					}
					};
				};
				this.fillExpression(b_5402);
				this.types.set(node_5152, this.unify(this.types.get(a_5400), this.types.get(b_5402), b_5402));
			}
		} break;
		
		case 17: {
			const e_5409 = temp_5153[1];
			{
				if (((!this.insideFunction)) && ((!this.insideTry))) { this.fail('Cannot throw outside of `function` or `try`', node_5152) };
				if ((this.insideFunction) && ((!this.functionAllowedToThrow))) { this.fail('Cannot throw in a @noThrow function', node_5152) };
				if (this.insideFunction) { this.functionThrows = true };
				this.fillExpression(e_5409);
			}
		} break;
		
		case 3: {
			{
				if ((!this.insideClassMethod)) { this.fail('Cannot access `this` outside of class method', node_5152) };
				if (this.thisType == null) { this.fail('Cannot access `this` in class method', node_5152) };
				this.types.set(node_5152, this.thisType);
				this.parents.set(node_5152, this.thisNode);
			}
		} break;
		
		case 4: {
			this.fail('Cannot use `super` as value', node_5152)
		} break;
		
		case 16: {
			const e_5410 = temp_5153[1];
			{
				{
					const temp_5411 = e_5410;
					switch (temp_5411&&temp_5411[0]) {
					case 24: {
						const name_5412 = temp_5411[1];
						const const_5413 = temp_5411[4];
						{
							const prefix = ((const_5413)? ('let') : 'var');
							this.fail(('This `return` tries to return a variable `' + (prefix) + ' ' + (name_5412) + '`. Try to wrap it into braces like this `{ return } ' + (prefix) + ' ' + (name_5412) + '`'), node_5152);
						}
					} break;
					
					case 16: {
						this.fail('Cannot return another return. Try to wrap first `{ return } return 2` into braces', node_5152)
					} break;
					};
				};
				if ((!this.insideFunction)) { this.fail('Cannot use `return` outside of function', node_5152) };
				if (e_5410 != null) {
					if (this.functionReturnsAType == this.typeVoid) { this.fail('Function returns `Void`, cannot return a value here', e_5410) };
					this.fillExpression(e_5410);
					const ret_5414 = this.types.get(e_5410);
					if (ret_5414 == this.typeVoid) { this.fail('Cannot `return` a `Void` non-value', node_5152) };
					this.inferNullType(ret_5414, this.functionReturnsAType, null);
					this.functionReturnsAType = this.unify(this.functionReturnsAType, ret_5414, e_5410);
					this.functionActuallyReturns = true;
				} else {
					let step_5415 = 0;
					const ret_5416 = this.functionReturnsAType;
					if (step_5415 == 0 && ret_5416 != null) { step_5415 = 1 };
					if (step_5415 == 1) { if (ret_5416 != this.typeVoid) { this.fail(('Expected `return value` of type `' + (Type.stringify(ret_5416)) + '`'), node_5152) } } else {
						this.functionReturnsAType = this.typeVoid;
					};
				};
			}
		} break;
		
		case 45: {
			this.fail('Cannot use underscore `_` outside of case pattern', node_5152)
		} break;
		
		case 47: {
			this.fail('Cannot use `static` here: only applicable to class fields', node_5152)
		} break;
		
		case 48: {
			this.fail('Cannot use `private` here: only applicable to class fields and module declarations', node_5152)
		} break;
		
		case 35: {
			{
			}
		} break;
		
		case 18: {
			this.fail('Cannot use `break` as a value', node_5152)
		} break;
		
		case 19: {
			this.fail('Cannot use `continue` as a value', node_5152)
		} break;
		
		case 25: {
			this.fail('Cannot use `class` as a value', node_5152)
		} break;
		
		case 39: {
			this.fail('Cannot use `enum` as a value', node_5152)
		} break;
		
		case 9: {
			this.fail('Cannot use `declare` as a value', node_5152)
		} break;
		
		case 37: {
			this.fail('Cannot use `import` as a value', node_5152)
		} break;
		
		case 24: {
			const name_5417 = temp_5153[1];
			const const_5418 = temp_5153[4];
			{
				const prefix_5419 = ((const_5418)? ('let') : 'var');
				this.fail(('Cannot use `' + (prefix_5419) + ' ' + (name_5417) + '` as a value'), node_5152);
			}
		} break;
		
		case 34: {
			this.fillSwitch(node_5152, true)
		} break;
		
		case 21: {
			this.fail('Cannot use `while` as a value', node_5152)
		} break;
		
		case 49: {
			this.fail('Cannot use `for` as a value. To build array from loop, surround with `[for]` brackets.', node_5152)
		} break;
		
		case null: case undefined: {
			this.fail('Got null node. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.', node_5152)
		} break;
		
		default: 
		this.fail('Unknown node expression kind to type ' + node_5152 + '. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.', node_5152)
		};
	};
		asNullable(type_5420) {
		{
			let step_5421 = 0;
			const has_5422 = this.nullables.get(type_5420);
			if (step_5421 == 0 && has_5422 != null) { step_5421 = 1 };
			if (step_5421 == 1) { return has_5422 };
		};
		const spawned = /*Nullable*/[4,type_5420,".Nullable"];
		this.nullables.set(type_5420, spawned);
		return spawned;
	};
		inferNullType(to_5423, fromValue_5424, node_5425) {
		const temp_5426 = to_5423;
		switch (temp_5426&&temp_5426[0]) {
		case 3: {
			const handle_5427 = temp_5426[1];
			if (handle_5427.value == null) {
				handle_5427.value = this.unwrapUnknownAndNullable(fromValue_5424);
				{
					let step_5428 = 0;
					const node_5429 = node_5425;
					if (step_5428 == 0 && node_5429 != null) { step_5428 = 1 };
					if (step_5428 == 1) { this.types.set(node_5429, this.asNullable(this.unwrapUnknownAndNullable(fromValue_5424))) };
				};
			}
		} break;
		};
	};
		isNullable(type_5430) {
		{
			const temp_5431 = type_5430;
			switch (temp_5431&&temp_5431[0]) {
			case 4: {
				return true
			} break;
			
			case 3: {
				return true
			} break;
			};
		};
		return false;
	};
		unwrapUnknownAndNullable(type_5432) {
		{
			const temp_5433 = type_5432;
			switch (temp_5433&&temp_5433[0]) {
			case null: case undefined: {
				return null
			} break;
			
			case 4: {
				const type_5434 = temp_5433[1];
				return this.unwrapUnknownAndNullable(type_5434)
			} break;
			
			case 2: {
				const type_5435 = temp_5433[1];
				return this.unwrapUnknownAndNullable(type_5435.value)
			} break;
			
			case 3: {
				const type_5436 = temp_5433[1];
				return this.unwrapUnknownAndNullable(type_5436.value)
			} break;
			};
		};
		return type_5432;
	};
		fillSwitch(node_5437, value_5438) {
		const temp_5439 = node_5437;
		switch (temp_5439&&temp_5439[0]) {
		case 34: {
			const exprs_5440 = temp_5439[1];
			const conds_5441 = temp_5439[2];
			const guards_5442 = temp_5439[3];
			const cases_5443 = temp_5439[4];
			{
				for (const e of $toIterator(exprs_5440)) {
					this.pushScope();
					this.fillExpression(e);
					this.popScope();
				};
				{
					let step_5444 = 0;
					const expr_5445 = exprs_5440[1];
					if (step_5444 == 0 && expr_5445 != null) { step_5444 = 1 };
					if (step_5444 == 1) { this.fail('Multiple switch values are not yet supported', expr_5445) };
				};
				const etype_5446 = this.unwrapUnknownAndNullable(this.types.get(exprs_5440[0]));
				if (etype_5446 == null) { this.fail(('Value of switch `' + (Node.stringify(exprs_5440[0])) + '` must have a known type at this postition'), exprs_5440[0]) };
				let enumType = null;
				let shortHandSyntax = false;
				const switchable = [this.typeBool, this.typeInt, this.typeUInt64, this.typeUInt32, this.typeUInt16, this.typeUInt8, this.typeInt64, this.typeInt32, this.typeInt16, this.typeInt8, this.typeString];
				if (switchable.includes(etype_5446)) {} else if (etype_5446 == this.typeFloat) { this.fail('Due to imprecise nature of `Float` type, switching over it is not allowed', exprs_5440[0]) } else {
					const temp_5447 = etype_5446;
					switch (temp_5447&&temp_5447[0]) {
					case 8: {
						const type_5448 = temp_5447[1];
						enumType = type_5448
					} break;
					
					case 9: {
						const type_5449 = temp_5447[1];
						enumType = type_5449
					} break;
					
					default: 
					this.fail(('Cannot switch over `' + (Type.stringify(etype_5446)) + '` type'), exprs_5440[0])
					};
				};
				const tags = [];
				let i_5450 = 0;
				const tagCheck = (currentTag, e_5451) => { if (tags.includes(currentTag)) { this.fail(('Tag `' + (currentTag) + '` already matched'), e_5451) } else {
					tags.push(currentTag);
				} };
				while (i_5450 < cases_5443.length) {
					this.pushScope();
					const e_5452 = conds_5441[i_5450];
					let currentType = null;
					let currentTag_5453 = null;
					let currentTagBind = 0;
					let interval = false;
					const follow = (e_5454) => {
						const temp_5455 = e_5454;
						switch (temp_5455&&temp_5455[0]) {
						case 29: {
							const ex = temp_5455[1];
							const name_5456 = temp_5455[2];
							{
								this.fillExpression(e_5454);
								{
									const temp_5457 = (this.types.get(ex));
									switch (temp_5457&&temp_5457[0]) {
									case 8: {
										const type_5458 = temp_5457[1];
										{
											currentType = type_5458;
											currentTag_5453 = name_5456;
											this.fail(('Use `case ' + (currentTag_5453) + '` instead of `case ' + (type_5458.name) + '.' + (currentTag_5453) + '`'), e_5454);
											if (tags.includes(currentTag_5453)) { this.fail(('Tag `' + (currentTag_5453) + '` already matched'), e_5454) } else {
												tags.push(currentTag_5453);
											};
										}
									} break;
									};
								};
							}
						} break;
						
						case 15: {
							const e_5459 = temp_5455[1];
							this.fill(e_5459)
						} break;
						
						case 45: {
							{
							}
						} break;
						
						case 8: {
							{
							}
						} break;
						
						case 2: {
							const val = temp_5455[1];
							{
								tagCheck('' + val, e_5454);
								if (etype_5446 != this.typeBool) { this.fail('Cannot switch over boolean here', e_5454) };
							}
						} break;
						
						case 5: {
							const val_5460 = temp_5455[1];
							{
								tagCheck('' + val_5460, e_5454);
								const validNumberTypes = [this.typeInt32, this.typeInt64, this.typeInt16, this.typeInt8, this.typeUInt32, this.typeUInt64, this.typeUInt16, this.typeUInt8, this.typeInt];
								if ((!validNumberTypes.includes(etype_5446))) { this.fail('Cannot switch over number here', e_5454) };
							}
						} break;
						
						case 0: {
							const val_5461 = temp_5455[1];
							{
								tagCheck(val_5461, e_5454);
								if (etype_5446 != this.typeString) { this.fail('Cannot switch over string here', e_5454) };
							}
						} break;
						
						case 13: {
							const ex_5462 = temp_5455[1];
							const args_5463 = temp_5455[2];
							const argNames_5464 = temp_5455[3];
							{
								follow(ex_5462);
								currentTagBind = 0;
								if (args_5463.length == 0) { this.fail(('Do not use `()` empty pattern, use `' + (currentTag_5453) + '(...)` syntax to ignore all bindings'), e_5454) };
								{
									let step_5465 = 0;
									const enumType_5466 = enumType;
									let temp_5467 = null;
									if (step_5465 == 0 && enumType_5466 != null) {
										temp_5467 = enumType_5466.fieldsTypeSimple != null;
										step_5465 = 1;
									};
									if (step_5465 == 1 && temp_5467 != false) { step_5465 = 2 };
									if (step_5465 == 2) { this.fail(('The `' + (enumType_5466.name) + '` is simple enum and has no `()` bindings'), e_5454) };
								};
								{
									let step_5468 = 0;
									const enumType_5469 = enumType;
									let temp_5470 = null;
									if (step_5468 == 0 && enumType_5469 != null) {
										temp_5470 = shortHandSyntax == true;
										step_5468 = 1;
									};
									let i_5471 = null;
									if (step_5468 == 1 && temp_5470 != false) {
										i_5471 = enumType_5469.fieldNames.indexOf(currentTag_5453, 0);
										step_5468 = 2;
									};
									let binds = null;
									if (step_5468 == 2 && i_5471 != null) {
										binds = enumType_5469.tagBindVarsNames[i_5471];
										step_5468 = 3;
									};
									let temp_5472 = null;
									if (step_5468 == 3 && binds != null) {
										temp_5472 = binds.length == 0;
										step_5468 = 4;
									};
									if (step_5468 == 4 && temp_5472 != false) { step_5468 = 5 };
									if (step_5468 == 5) {
										const temp_5473 = args_5463[0];
										switch (temp_5473&&temp_5473[0]) {
										case 46: {
											{
											}
										} break;
										
										default: 
										this.fail(('The `' + (currentTag_5453) + '` has no `()` bindings, use `' + (currentTag_5453) + '(...)` syntax to ignore all future bindings added'), e_5454)
										};
									};
								};
								for (const ee of $toIterator(args_5463)) {
									if (interval) { this.fail('Do not match any patterns after `...` interval', ee) };
									{
										const temp_5474 = ee;
										switch (temp_5474&&temp_5474[0]) {
										case 46: {
											interval = true
										} break;
										
										case 1: {
											const name_5475 = temp_5474[1];
											{
												follow(ee);
												currentTagBind++;
											}
										} break;
										
										case 45: {
											{
												{
													let step_5476 = 0;
													const enumType_5477 = enumType;
													let temp_5478 = null;
													if (step_5476 == 0 && enumType_5477 != null) {
														temp_5478 = shortHandSyntax == true;
														step_5476 = 1;
													};
													let i_5479 = null;
													if (step_5476 == 1 && temp_5478 != false) {
														i_5479 = enumType_5477.fieldNames.indexOf(currentTag_5453, 0);
														step_5476 = 2;
													};
													let binds_5480 = null;
													if (step_5476 == 2 && i_5479 != null) {
														binds_5480 = enumType_5477.tagBindVarsNames[i_5479];
														step_5476 = 3;
													};
													let temp_5481 = null;
													if (step_5476 == 3 && binds_5480 != null) {
														temp_5481 = binds_5480.length <= currentTagBind;
														step_5476 = 4;
													};
													if (step_5476 == 4 && temp_5481 != false) { step_5476 = 5 };
													if (step_5476 == 5) { this.fail('Too many bindings ignored with `_` for `F` tag, use `...` syntax to ignore all future bindings', e_5454) };
												};
												currentTagBind++;
											}
										} break;
										
										default: 
										this.fail('This case pattern is not supported', e_5454)
										};
									};
								};
							}
						} break;
						
						case 51: {
							const t_5482 = temp_5455[1];
							{
								shortHandSyntax = true;
								{
									const temp_5483 = t_5482;
									switch (temp_5483&&temp_5483[0]) {
									case 1: {
										const name_5484 = temp_5483[1];
										{
											let step_5485 = 0;
											const enumType_5486 = enumType;
											if (step_5485 == 0 && enumType_5486 != null) { step_5485 = 1 };
											if (step_5485 == 1) {
												let step_5487 = 0;
												const i_5488 = enumType_5486.fieldNames.indexOf(name_5484, 0);
												let temp_5489 = null;
												if (step_5487 == 0 && i_5488 != null) {
													temp_5489 = enumType_5486.fieldEnumConstructor[i_5488] == true;
													step_5487 = 1;
												};
												if (step_5487 == 1 && temp_5489 != false) { step_5487 = 2 };
												if (step_5487 == 2) {
													currentType = enumType_5486;
													currentTag_5453 = name_5484;
													if (tags.includes(currentTag_5453)) { this.fail(('Tag `' + (currentTag_5453) + '` already matched'), e_5454) } else {
														tags.push(currentTag_5453);
													};
												} else {
													this.fail(('The `' + (name_5484) + '` is not an enum constructor of `' + (enumType_5486.name) + '`'), e_5454);
												};
											} else {
												this.fail('This case pattern is not supported over non-enum types', e_5454);
											};
										}
									} break;
									
									default: 
									this.fail('This case pattern is not supported', e_5454)
									};
								};
							}
						} break;
						
						case 1: {
							const name_5490 = temp_5455[1];
							if (name_5490.charAt(0) == name_5490.charAt(0).toUpperCase()) { this.fill(e_5454) } else {
								this.addScope(name_5490, e_5454);
								{
									let step_5491 = 0;
									const currentType_5492 = currentType;
									if (step_5491 == 0 && currentType_5492 != null) { step_5491 = 1 };
									if (step_5491 == 1) {
										const indexOf_5493 = currentType_5492.fieldNames.indexOf(currentTag_5453, 0);
										if (indexOf_5493 == (-1)) { this.fail('currentType.fieldNames.indexOf == -1', e_5454) };
										const type_5494 = (() => {
											const result_5495 = currentType_5492.tagBindVarsTypes[indexOf_5493][currentTagBind];
											if (result_5495 != null) { return result_5495 };
											return this.typesOfTagArguments(currentType_5492, indexOf_5493)[currentTagBind];
										})();
										const name_5496 = currentType_5492.tagBindVarsNames[indexOf_5493][currentTagBind];
										if (name_5496 == null) {
											const available_5497 = currentType_5492.tagBindVarsNames[indexOf_5493].join(', ');
											if (available_5497.length == 0) { this.fail('No bindings available for `.' + currentTag_5453 + '`', e_5454) };
											this.fail(('Too many bindings requested for `' + (currentTag_5453) + '`, available are: ') + available_5497, e_5454);
										};
										if (type_5494 != null) { this.types.set(e_5454, type_5494) } else {
											this.fail('Internal error: tagBindVars has no type for ' + name_5496, e_5454);
										};
									} else {
										this.fail('No currentType for ' + name_5490, e_5454);
									};
								};
							}
						} break;
						
						case 10: {
							const a_5498 = temp_5455[1];
							const op_5499 = temp_5455[2];
							const b_5500 = temp_5455[3];
							if (op_5499 == 104) {
								follow(a_5498);
								follow(b_5500);
							} else {
								this.fail('This case pattern is not supported', e_5454);
							}
						} break;
						
						case 14: {
							const econd_5501 = temp_5455[1];
							{
								this.pushScope();
								this.fill(econd_5501[0]);
								this.popScope();
							}
						} break;
						
						default: 
						this.fail('This case pattern is not supported', e_5454)
						};
					};
					follow(e_5452);
					const e_5502 = cases_5443[i_5450];
					this.pushScope();
					{
						let step_5503 = 0;
						const guard = guards_5442[i_5450];
						if (step_5503 == 0 && guard != null) { step_5503 = 1 };
						if (step_5503 == 1) {
							this.fillExpression(guard);
							if (this.types.get(guard) != this.typeBool) { this.fail('Case guard must be a simple boolean expression', guard) };
						};
					};
					if (value_5438 == false) { this.fill(e_5502) };
					if (value_5438 == true) {
						this.fillExpression(e_5502);
						if (this.types.get(node_5437) == null) { this.types.set(node_5437, this.types.get(e_5502)) } else {
							this.types.set(node_5437, this.unify(this.types.get(node_5437), this.types.get(e_5502), e_5502));
						};
					};
					this.popScope();
					this.popScope();
					i_5450++;
				};
			}
		} break;
		};
	};
		typesOfTagArguments(type_5504, tag_5505) {
		let types_5506 = type_5504.tagBindVarsTypes[tag_5505];
		const nodeTypes = type_5504.tagBindVars[tag_5505];
		const nodes_5507 = type_5504.tagBindVarsNodes[tag_5505];
		if (types_5506.length == nodeTypes.length) { return types_5506 };
		types_5506 = nodeTypes.map((nodeType_5508, i_5509) => (this.toType(nodeType_5508, nodes_5507[i_5509])));
		type_5504.tagBindVarsTypes[tag_5505] = types_5506;
		return types_5506;
	};
	}
	Typer.never = '. This should never happen. Probably incomplete feature was used. Ping a compiler developer with a code sample.'
	Typer.delayedInstance = null
	Typer.nodeToNodeType = (node_4837) => {
		const temp_4838 = node_4837;
		switch (temp_4838&&temp_4838[0]) {
		case 31: {
			const el = temp_4838[1];
			{
				if (el.length > 1) { this.fail('Array type `[T]` cannot have more than 1 parameter `T`', el[1]) };
				return /*ParametricType*/[2,'Array',[Typer.nodeToNodeType(el[0])],null,".ParametricType"];
			}
		} break;
		
		case 51: {
			const t_4839 = temp_4838[1];
			return t_4839
		} break;
		
		case 38: {
			const names_4840 = temp_4838[1];
			const el_4841 = temp_4838[2];
			{
				const types_4842 = (() => {
					const result_4843 = [];
					const value_4844 = el_4841;
					for (const e of $toIterator(value_4844)) result_4843.push(Typer.nodeToNodeType(e));
					return result_4843;
				})();
				return /*Object*/[5,names_4840,types_4842,".Object"];
			}
		} break;
		
		default: 
		this.fail('Cannot nodeToNodeType of ' + Node.stringify(node_4837), node_4837)
		};
	};
	var Tokens = class {
		constructor(tokens, length, values, lines, columns, fileName, meta) { 
		{
		this.token = tokens;
		this.length = length;
		this.value = values;
		this.line = lines;
		this.column = columns;
		this.fileName = fileName;
		this.meta = meta;
	} };
	}
	var Lexer = class {
	}
	Lexer.isident = Buffer.alloc(256)
	Lexer.isUpper = Buffer.alloc(256)
	Lexer.ops8a = Buffer.alloc(256)
	Lexer.op16token = Buffer.alloc(768)
	Lexer.kwd
	Lexer.tokenize = (bytes, fileName_5510) => {
		let position = 0;
		const len = bytes.length;
		let to = 0;
		let s = '';
		let p = 0;
		let line = 1;
		let columnBase = 0;
		const params = [];
		const meta_5511 = [];
		const tokens_5512 = Buffer.alloc(len + 1);
		const lines_5513 = [];
		const columns_5514 = [];
		const add = (t) => {
			tokens_5512[(to++)] = t;
			lines_5513.push(line);
			columns_5514.push(position - columnBase - 1);
		};
		const addn = (t_5515, p_5516) => {
			params[to] = p_5516;
			add(t_5515);
		};
		const addm = (t_5517, p_5518, m) => {
			params[to] = p_5518;
			meta_5511[to] = m;
			add(t_5517);
		};
		const curPos = () => { return position - columnBase - 1 };
		const get_8 = (pos) => { return bytes[pos] };
		const not_eof = () => { return position < len };
		const new_line = () => {
			line++;
			columnBase = position;
		};
		const fail = (message, erline = null, column = null, filename = null) => {
			const erline_5519 = ((erline != null)? (erline) : line);
			const column_5520 = ((column != null)? (column) : curPos());
			const filename_5521 = ((filename != null)? (filename) : fileName_5510);
			return new CompilerErrors([new CompilerError(2, message, erline_5519, column_5520, filename_5521)]);
		};
		if ((len > 2) && (get_8(0) == 239) && (get_8(1) == 187) && (get_8(2) == 191)) { position += 3 };
		if ((len > 2) && (get_8(0) == 35) && (get_8(1) == 33)) { while (position < len && get_8(position) != 10) {
			position++;
		} };
		while (position < len) {
			let _8 = 0;
			do {{
				_8 = get_8(position);
				if (_8 == 10) { new_line() };
			}} while (_8 <= 32 && ((++position) < len));
			if ((!not_eof())) { break };
			let _16 = (((len - position) > 1)? (_8 | (get_8(position + 1) << 8)) : _8);
			if (_8 == 47) {
				if (_16 == 12079) {
					const pos_5522 = position + 2;
					while (get_8(position) != 10 && not_eof()) {
						position++;
					};
					continue;
				};
				if (_16 == 10799 && get_8(position + 2) == 42) {
					position += 3;
					p = position;
					while (not_eof()) {
						const _32 = (((len - position) > 3)? (bytes.readUInt32LE(position)) : get_8(position));
						if ((_32 & 255) == 10) { new_line() } else if ((_32 & 16777215) == 3090986) { break };
						position++;
					};
					if ((!not_eof())) { throw fail('Unclosed doc-comment', null, null, null) };
					addn(65, bytes.toString('utf8', p, position));
					position += 3;
					continue;
				};
				if (_16 == 10799) {
					const pos_5523 = position + 2;
					p = 0;
					position += 2;
					while (not_eof()) {
						_16 = (((len - position) > 1)? (bytes.readUInt16LE(position)) : get_8(position));
						if ((_16 & 255) == 10) { new_line() } else if (_16 == 12074 && p > 0) { p-- } else if (_16 == 10799) { p++ } else if (_16 == 12074 && p == 0) { break };
						position++;
					};
					position += 2;
					continue;
				};
			};
			if (((_8 & 95) >= 65 && (_8 & 95) <= 90) || (_8 == 95)) {
				const titlechar = _8;
				p = position + 1;
				_8 = get_8(p);
				while (p < len && Lexer.isident[_8] != 0) {
					_8 = get_8((++p));
				};
				s = bytes.toString('ascii', position, p);
				const t_5524 = ((((_16 & 255) <= 90))? (null) : Lexer.kwd.get(s));
				{
					let step = 0;
					const t_5525 = t_5524;
					if (step == 0 && t_5525 != null) { step = 1 };
					if (step == 1) { add(t_5525) } else {
						if (titlechar >= 65 && titlechar <= 90) { addn(61, s) } else {
							addn(62, s);
						};
					};
				};
				position = p;
				continue;
			};
			if (_8 == 96) {
				position++;
				const pos_5526 = position;
				while (not_eof()) {
					if ((get_8(position) == 96) && (get_8(position + 1) == 96)) {
						position++;
						position++;
						continue;
					};
					if (get_8(position) == 96) { break };
					if (get_8(position) == 10) { new_line() };
					position++;
				};
				let result = bytes.toString('utf8', pos_5526, position);
				if (result.indexOf('``', 0) != (-1)) { result = result.split('``').join('') };
				addn(66, result.replaceAll('\r\n', '\n'));
				position++;
				continue;
			};
			if (_16 == 11822 && (get_8(position + 2) == 46)) {
				add(98);
				position += 3;
				continue;
			};
			if (_16 == 15934 && (get_8(position + 2) == 62)) {
				add(108);
				position += 3;
				continue;
			};
			const hash = Lexer.simplehash(_16);
			if (_16 == Lexer.op16token.readUInt16LE(hash * 2)) {
				add((Lexer.op16token[hash + 512]));
				position += 2;
				continue;
			};
			const found = (Lexer.ops8a[_8]);
			if (found != 0) {
				add(found);
				position++;
				continue;
			};
			if (_8 < 40) {
				p = _8;
				position++;
				const pos_5527 = position;
				while (get_8(position) != p && not_eof()) {
					if (get_8(position) == 10) { new_line() };
					if (get_8(position) == '\\'.charCodeAt(0)) {
						position += 2;
						continue;
					};
					_16 = (((len - position) > 1)? (bytes.readUInt16LE(position)) : get_8(position));
					position++;
				};
				let result_5528 = bytes.toString('utf8', pos_5527, position);
				if (result_5528.indexOf('\r\n', 0) != (-1)) { result_5528 = result_5528.replaceAll('\r\n', '\n') };
				addn(64, result_5528);
				position++;
				continue;
			};
			if (_16 == 25136) {
				p = position;
				p += 2;
				_8 = get_8(position);
				while (_8 == 48 || _8 == 49) {
					_8 = get_8((++p));
				};
				if (p - position == 2) { throw fail('Integer `0b` not allowed!', null, null, null) };
				let m_5529 = 0;
				let offset = 0;
				if (get_8(p) == 110) {
					m_5529 = 1;
					offset = 1;
				} else if (get_8(p) == 105) {
					const header = bytes.readUInt16LE(p + 1);
					if (get_8(p + 1) == 56) {
						m_5529 = 5;
						offset = 2;
					} else if (header == 51 + 50 * 256) {
						m_5529 = 2;
						offset = 3;
					} else if (header == 54 + 52 * 256) {
						m_5529 = 3;
						offset = 3;
					} else if (header == 49 + 54 * 256) {
						m_5529 = 4;
						offset = 3;
					};
				} else if (get_8(p) == 117) {
					const header_5530 = bytes.readUInt16LE(p + 1);
					if (get_8(p + 1) == 56) {
						m_5529 = 9;
						offset = 2;
					} else if (header_5530 == 51 + 50 * 256) {
						m_5529 = 6;
						offset = 3;
					} else if (header_5530 == 54 + 52 * 256) {
						m_5529 = 7;
						offset = 3;
					} else if (header_5530 == 49 + 54 * 256) {
						m_5529 = 8;
						offset = 3;
					};
				};
				const string = parseInt(bytes.toString('ascii', position + 2, p), 2).toString(10);
				addm(63, string, m_5529);
				position = p + offset;
				continue;
			};
			if (_16 == 30768) {
				p = position;
				p += 2;
				_8 = get_8(position);
				while ((_8 >= 65 && _8 <= 70) || (_8 >= 48 && _8 <= 57) || (_8 >= 97 && _8 <= 102)) {
					_8 = get_8((++p));
				};
				if (p - position == 2) { throw fail('Integer `0x` not allowed!', null, null, null) };
				let m_5531 = 0;
				let offset_5532 = 0;
				if (get_8(p) == 110) {
					m_5531 = 1;
					offset_5532 = 1;
				} else if (get_8(p) == 105) {
					const header_5533 = bytes.readUInt16LE(p + 1);
					if (get_8(p + 1) == 56) {
						m_5531 = 5;
						offset_5532 = 2;
					} else if (header_5533 == 51 + 50 * 256) {
						m_5531 = 2;
						offset_5532 = 3;
					} else if (header_5533 == 54 + 52 * 256) {
						m_5531 = 3;
						offset_5532 = 3;
					} else if (header_5533 == 49 + 54 * 256) {
						m_5531 = 4;
						offset_5532 = 3;
					};
				} else if (get_8(p) == 117) {
					const header_5534 = bytes.readUInt16LE(p + 1);
					if (get_8(p + 1) == 56) {
						m_5531 = 9;
						offset_5532 = 2;
					} else if (header_5534 == 51 + 50 * 256) {
						m_5531 = 6;
						offset_5532 = 3;
					} else if (header_5534 == 54 + 52 * 256) {
						m_5531 = 7;
						offset_5532 = 3;
					} else if (header_5534 == 49 + 54 * 256) {
						m_5531 = 8;
						offset_5532 = 3;
					};
				};
				addm(63, bytes.toString('utf8', position, p), m_5531);
				position = p + offset_5532;
				continue;
			};
			if (_8 < 58) {
				p = position;
				_8 = get_8(p);
				let found_5535 = 63;
				while (_8 >= 48 && _8 <= 57) {
					_8 = get_8((++p));
				};
				if (_8 == 46 && get_8(p + 1) != 46) {
					_8 = get_8((++p));
					while (_8 >= 48 && _8 <= 57) {
						_8 = get_8((++p));
					};
					found_5535 = 60;
				};
				if (_8 == 101 || _8 == 69) {
					_8 = get_8((++p));
					if (_8 == 43 || _8 == 45) { _8 = get_8((++p)) };
					while (_8 >= 48 && _8 <= 57) {
						_8 = get_8((++p));
					};
					found_5535 = 60;
				};
				let m_5536 = 0;
				let offset_5537 = 0;
				if (get_8(p) == 110) {
					m_5536 = 1;
					offset_5537 = 1;
				} else if (get_8(p) == 105) {
					const header_5538 = bytes.readUInt16LE(p + 1);
					if (get_8(p + 1) == 56) {
						m_5536 = 5;
						offset_5537 = 2;
					} else if (header_5538 == 51 + 50 * 256) {
						m_5536 = 2;
						offset_5537 = 3;
					} else if (header_5538 == 54 + 52 * 256) {
						m_5536 = 3;
						offset_5537 = 3;
					} else if (header_5538 == 49 + 54 * 256) {
						m_5536 = 4;
						offset_5537 = 3;
					};
				} else if (get_8(p) == 117) {
					const header_5539 = bytes.readUInt16LE(p + 1);
					if (get_8(p + 1) == 56) {
						m_5536 = 9;
						offset_5537 = 2;
					} else if (header_5539 == 51 + 50 * 256) {
						m_5536 = 6;
						offset_5537 = 3;
					} else if (header_5539 == 54 + 52 * 256) {
						m_5536 = 7;
						offset_5537 = 3;
					} else if (header_5539 == 49 + 54 * 256) {
						m_5536 = 8;
						offset_5537 = 3;
					};
				} else if (get_8(p) == 102) {
					const header_5540 = bytes.readUInt16LE(p + 1);
					if (header_5540 == 51 + 50 * 256) {
						m_5536 = 10;
						offset_5537 = 3;
					};
				};
				addm(found_5535, bytes.toString('ascii', position, p), m_5536);
				position = p + offset_5537;
				continue;
			};
			if (position >= len) { break };
			throw fail('Unexpected character ' + String.fromCharCode(_8), null, null, null);
		};
		add(0);
		return new Tokens(tokens_5512, to, params, lines_5513, columns_5514, fileName_5510, meta_5511);
	};
	Lexer.init = () => {
		{
			let _8_5541 = 0;
			let it = 0;
			while (it < 256) {
				_8_5541 = it;
				it++;
				{
					Lexer.isident[_8_5541] = ((((_8_5541 >= 65 && _8_5541 <= 90) || (_8_5541 >= 48 && _8_5541 <= 57) || (_8_5541 >= 97 && _8_5541 <= 122) || _8_5541 == 95))? (128) : 0);
				};
			};
		};
		{
			let _8_5542 = 0;
			let it_5543 = 0;
			while (it_5543 < 256) {
				_8_5542 = it_5543;
				it_5543++;
				{
					Lexer.isident[_8_5542] = ((((_8_5542 >= 65 && _8_5542 <= 90) || (_8_5542 >= 48 && _8_5542 <= 57) || (_8_5542 >= 97 && _8_5542 <= 122) || _8_5542 == 95))? (128) : 0);
				};
			};
		};
		Lexer.kwd = new Map([['_', 1], ['as', 58], ['break', 3], ['case', 4], ['catch', 6], ['class', 7], ['continue', 8], ['do', 9], ['else', 10], ['enum', 11], ['extends', 12], ['declare', 13], ['false', 14], ['for', 15], ['fun', 21], ['if', 17], ['implements', 18], ['import', 2], ['in', 20], ['interface', 22], ['let', 23], ['new', 25], ['null', 26], ['private', 29], ['return', 31], ['static', 32], ['super', 59], ['switch', 33], ['this', 34], ['throw', 35], ['true', 36], ['try', 37], ['var', 40], ['while', 41], ['and', 92], ['or', 93], ['not', 89], ['is', 57]]);
		const ops8 = new Map([[64, 70], [36, 83], [35, 78], [33, 89], [37, 101], [38, 112], [40, 80], [41, 79], [42, 102], [43, 111], [44, 75], [45, 107], [46, 77], [47, 94], [58, 76], [59, 82], [60, 99], [61, 91], [62, 96], [63, 81], [91, 72], ['\\'.charCodeAt(0), 110], [93, 71], [94, 109], [123, 74], [124, 104], [125, 73], [126, 88]]);
		for (const key of $toIterator(ops8.keys())) {
			Lexer.ops8a[key] = ops8.get(key);
		};
		const ops16 = new Map([[11051, 87], [11565, 86], [15420, 105], [15649, 103], [15676, 100], [15677, 95], [15678, 97], [15934, 106], [31868, 93], [9766, 92], [15933, 90], [11839, 113]]);
		for (const key1 of $toIterator(ops16.keys())) {
			for (const key2 of $toIterator(ops16.keys())) {
				if (key1 != key2 && Lexer.simplehash(key1) == Lexer.simplehash(key2)) { throw new CompilerError(2, '2-byte op hash collision: ' + key1 + ' ' + key2, 0, 0, 'INTERNAL') };
			};
		};
		for (const key of $toIterator(ops16.keys())) {
			const hash_5544 = Lexer.simplehash(key);
			Lexer.op16token.writeUInt16LE(key, hash_5544 * 2);
			Lexer.op16token[hash_5544 + 512] = ops16.get(key);
		};
		return;
	};
	Lexer.simplehash = (val) => { return ((val & 255) + (((val >> (8 * 1)) & 255) << 3)) & 239 };
	var Preprocessor = class {
	}
	Preprocessor.process_6 = (tokens, project) => {
		let i = 0;
		let token = (tokens.token[0]);
		while (i < tokens.length && token != 0) {
			if (token == 78) { return Preprocessor.processTokens(tokens, 0, project) };
			i++;
			token = (tokens.token[i]);
		};
		return tokens;
	};
	Preprocessor.fail = (lex, i_5545, message) => {
		const line = lex.line[i_5545];
		const column = lex.column[i_5545];
		const filename = lex.fileName;
		throw new CompilerErrors([new CompilerError(0, message, line, column, filename)]);
	};
	Preprocessor.processTokens = (tokens_5546, i_5547, project_5548) => {
		let i_5549 = i_5547;
		let token_5550 = (tokens_5546.token[0]);
		const bytes = tokens_5546.token.slice(0);
		const params = tokens_5546.value.slice(0, 1073741824);
		const lines = tokens_5546.line.slice(0, 1073741824);
		const columns = tokens_5546.column.slice(0, 1073741824);
		const meta = tokens_5546.meta.slice(0, 1073741824);
		let to = i_5549;
		const states = [0];
		let state = 0;
		const evaluateCondition = () => {
			project_5548.defines['false'] = false;
			project_5548.defines['true'] = true;
			let defName = tokens_5546.value[i_5549];
			const token_5551 = (tokens_5546.token[i_5549]);
			{
				const temp = token_5551;
				switch (temp) {
				case 62: {
					{
					}
				} break;
				
				case 14: {
					defName = 'false'
				} break;
				
				case 36: {
					defName = 'true'
				} break;
				
				default: 
				Preprocessor.fail(tokens_5546, i_5549, 'Incorrect `#if` syntax')
				};
			};
			const def = project_5548.defines[defName];
			if (def == null) { Preprocessor.fail(tokens_5546, i_5549, '`#if` looks for the `' + defName + '` parameter which is *not* defined in project file.' + (' Add `\"define\": { \"' + (defName) + '\": false }` to `hexa.json` or `--define ' + (defName) + '=false` to suppress this message.')) };
			i_5549++;
			if (def == true) { return true };
			return false;
		};
		while (i_5549 < tokens_5546.length && token_5550 != 0) {
			if (token_5550 == 78) {
				i_5549++;
				token_5550 = (tokens_5546.token[i_5549]);
				if (token_5550 == 17) {
					i_5549++;
					if (evaluateCondition()) { states.push(1) } else {
						states.push(4);
					};
					state = states[states.length - 1];
				} else if ((token_5550 == 62) && (tokens_5546.value[i_5549] == 'end')) {
					i_5549++;
					{
						const temp_5552 = state;
						switch (temp_5552) {
						case 1: {
							{
							}
						} break;
						
						case 2: {
							{
							}
						} break;
						
						case 3: {
							{
							}
						} break;
						
						case 4: {
							{
							}
						} break;
						
						default: 
						Preprocessor.fail(tokens_5546, i_5549 - 1, 'Unexpected `#end`')
						};
					};
					states.pop();
					state = states[states.length - 1];
				} else if (token_5550 == 10) {
					i_5549++;
					{
						const temp_5553 = state;
						switch (temp_5553) {
						case 1: {
							state = 3
						} break;
						
						case 4: {
							state = 2
						} break;
						
						default: 
						Preprocessor.fail(tokens_5546, i_5549 - 1, 'Unexpected `#else`')
						};
					};
					states[states.length - 1] = state;
				} else if ((token_5550 == 62) && (tokens_5546.value[i_5549] == 'error')) {
					i_5549++;
					const message_5554 = tokens_5546.value[i_5549];
					i_5549++;
					{
						const temp_5555 = state;
						switch (temp_5555) {
						case 4: case 3: {
							{
							}
						} break;
						
						default: 
						Preprocessor.fail(tokens_5546, i_5549, '#error ' + message_5554)
						};
					};
				} else {
					Preprocessor.fail(tokens_5546, i_5549, 'Incorrect `#` syntax');
				};
			} else {
				{
					const temp_5556 = state;
					switch (temp_5556) {
					case 0: case 1: case 2: {
						{
							bytes[to] = tokens_5546.token[i_5549];
							params[to] = tokens_5546.value[i_5549];
							lines[to] = tokens_5546.line[i_5549];
							columns[to] = tokens_5546.column[i_5549];
							meta[to] = tokens_5546.meta[i_5549];
							i_5549++;
							to++;
						}
					} break;
					
					default: 
					i_5549++
					};
				};
				{
					const temp_5557 = state;
					switch (temp_5557) {
					case 4: case 3: case 1: case 2: {
						{
							const token_5558 = (tokens_5546.token[i_5549]);
							if (token_5558 == 0) { Preprocessor.fail(tokens_5546, i_5549, 'Unexpected end, you have unclosed `#if` or `#else`. Place `#end` to close condition.') };
						}
					} break;
					};
				};
			};
			token_5550 = (tokens_5546.token[i_5549]);
		};
		return new Tokens(bytes, to, params, lines, columns, tokens_5546.fileName, meta);
	};
	var Parser = class {
		constructor(lexe_5559, project_5560, lint_5561) { 
			this.i = 0
			this.endif = 0
			this.lasttok = (-1)
			this.lasttokchecks = 10
			this.lint = false
			this.hints = []
			this.classExternal = false
			this.parametricTypeNesting = 0
			this.parametricTypeNestingToken = 0
		{
		this.lex = Preprocessor.process_6(lexe_5559, project_5560);
		this.lint = lint_5561;
		this.project = project_5560;
		this.nodes = [];
		while (this.i < this.lex.length && this.tok() != 0) {
			this.nodes.push(this.parseExpr());
		};
	} };
		parseFields() {
		const fields = [];
		while (this.tok() != 73) {
			const atts = [];
			while (this.tok() == 70) {
				atts.push(this.parseDecorator());
			};
			const pos = {line:this.lex.line[this.i], column:this.lex.column[this.i]};
			const pos_5562 = new NodeData(pos.line, pos.column, this.lex.fileName);
			let _static = false;
			if (this.tok() == 32) {
				_static = true;
				this.i++;
			};
			{
				const temp = this.tok();
				switch (temp) {
				case 29: {
					this.i++
				} break;
				
				case 40: {
					{
						let f = this.parseExpr();
						this.project.data.set(f, pos_5562);
						if (_static) {
							f = /*Static*/[47,f,".Static"];
							this.project.data.set(f, pos_5562);
						};
						this.project.mapDecorators.set(f, atts);
						fields.push(f);
					}
				} break;
				
				case 21: {
					{
						let f_5563 = this.parseExpr();
						if (this.project.data.get(f_5563) == null) { console.log('GO NO POS', f_5563) };
						this.project.data.set(f_5563, pos_5562);
						if (_static) {
							f_5563 = /*Static*/[47,f_5563,".Static"];
							this.project.data.set(f_5563, pos_5562);
						};
						{
							const temp_5564 = f_5563;
							switch (temp_5564&&temp_5564[0]) {
							case 22: {
								const name = temp_5564[1];
								if (name == 'concat') {}
							} break;
							};
						};
						this.project.mapDecorators.set(f_5563, atts);
						fields.push(f_5563);
					}
				} break;
				
				case 23: {
					{
						let f_5565 = this.parseExpr();
						this.project.data.set(f_5565, pos_5562);
						if (_static) {
							f_5565 = /*Static*/[47,f_5565,".Static"];
							this.project.data.set(f_5565, pos_5562);
						};
						this.project.mapDecorators.set(f_5565, atts);
						fields.push(f_5565);
					}
				} break;
				
				case 25: {
					{
						this.i++;
						let expr = null;
						const positions = [];
						const vars = [];
						const types = [];
						const values = [];
						this.step(80);
						if (this.tok() != 79) { while (true) {
							positions.push(new NodeData(this.lex.line[this.i], this.lex.column[this.i], this.lex.fileName));
							vars.push(this.getgo(62));
							let expr_5566 = null;
							let t = null;
							if (this.tok() == 76) {
								this.i++;
								t = this.parseType();
							} else {
								const token = this.tok();
								if (token == 72 || token == 74 || token == 61 || token == 80) { t = this.parseType() };
							};
							if (this.tok() == 91) {
								this.i++;
								expr_5566 = this.parseExpr();
							};
							types.push(t);
							values.push(expr_5566);
							if (this.tok() == 75) { this.i++ } else {
								break;
							};
						} };
						this.step(79);
						const tmp = this.i;
						while (this.tok() == 70) {
							this.parseDecorator();
						};
						if ((this.tok() != 73) && (this.tok() != 21)) {
							this.i = tmp;
							expr = this.parseExpr();
						} else {
							this.i = tmp;
						};
						const v = [];
						{
							let i = 0;
							let it = 0;
							let at = vars.length;
							while (it < at) {
								i = it;
								it++;
								{
									const argument = /*Var*/[24,vars[i],types[i],values[i],true,false,".Var"];
									this.project.data.set(argument, positions[i]);
									v.push(argument);
								};
							};
						};
						{
							const temp_5567 = expr;
							switch (temp_5567&&temp_5567[0]) {
							case null: case undefined: {
								{
								}
							} break;
							
							case 12: {
								{
								}
							} break;
							
							default: 
							{
								this.i--;
								this.fail('Constructor `new` should have a `{ block }` as a body', null, null, null);
							}
							};
						};
						const field = /*Function*/[22,'new',expr,v,null,false,false,".Function"];
						this.project.data.set(field, pos_5562);
						fields.push(field);
					}
				} break;
				
				case 62: {
					{
						const name_5568 = this.getgo(62);
						if ((name_5568 == 'get') && (this.tok() == 62)) {
							const field_5569 = this.getgo(62);
							this.fail(('Use property `var ' + (field_5569) + ' { get { return value } }` instead of `get ' + (field_5569) + '()`'), null, null, null);
						};
						if ((name_5568 == 'set') && (this.tok() == 62)) {
							const field_5570 = this.getgo(62);
							this.step(80);
							const value = this.getgo(62);
							this.fail(('Use property `var ' + (field_5570) + ' { set(' + (value) + ') { ... } }` instead of `set ' + (field_5570) + '(' + (value) + ')`'), null, null, null);
						};
						if (this.tok() == 80) {
							if (name_5568 == 'constructor') { this.fail('Use `new()` syntax instead of `constructor()`', null, null, null) };
							if (_static) { this.fail('Use `static fun ' + name_5568 + '()` syntax for static methods', null, null, null) } else {
								this.fail('Use `function ' + name_5568 + '()` syntax for methods', null, null, null);
							};
						};
						this.fail('Fields should start with `var ' + name_5568 + '` or `let ' + name_5568 + '`', null, null, null);
					}
				} break;
				
				case 61: {
					this.fail('Fields cannot start with uppercase character `' + this.print() + '` -> `' + this.print().toLowerCase() + '`', null, null, null)
				} break;
				
				case 74: {
					{
						const pos_5571 = {line:this.lex.line[this.i], column:this.lex.column[this.i]};
						const field_5572 = fields.pop();
						let v_5573 = null;
						let t_5574 = null;
						let n = null;
						let onlyGet = false;
						{
							const temp_5575 = field_5572;
							switch (temp_5575&&temp_5575[0]) {
							case 24: {
								const name_5576 = temp_5575[1];
								const type = temp_5575[2];
								const expr_5577 = temp_5575[3];
								const const_5578 = temp_5575[4];
								{
									if (expr_5577 != null) { this.fail('Property should not have a `= value`', null, null, null) };
									v_5573 = field_5572;
									t_5574 = type;
									n = name_5576;
									onlyGet = const_5578;
								}
							} break;
							
							default: 
							this.fail('Only `var` and `let` fields may have a getter `let v: T { get() ... }`', null, null, null)
							};
						};
						this.i++;
						if (this.print() == 'set') { this.fail('Expected `get` before `set`', null, null, null) };
						if (this.print() != 'get') { this.fail('Expected `get`', null, null, null) };
						const kind = this.print();
						let getterExpr = null;
						if (kind == 'get') {
							this.i++;
							getterExpr = this.parseExpr();
						};
						const kind_5579 = this.print();
						let setterExpr = null;
						let setterVar = null;
						if ((kind_5579 == 'set') && (onlyGet)) { this.fail('Constants `let` may have only getter `get`', null, null, null) };
						if (kind_5579 == 'set') {
							this.i++;
							this.step(80);
							setterVar = this.getgo(62);
							this.step(79);
							setterExpr = this.parseExpr();
						};
						if ((setterExpr == null) && ((!onlyGet))) { this.fail('Variables `var` should have both getter `get` and setter `set`', null, null, null) };
						this.step(73);
						const getter = (((getterExpr == null))? (null) : /*Function*/[22,'get_' + n,getterExpr,[],t_5574,false,false,".Function"]);
						const setter = (((setterExpr == null))? (null) : /*Function*/[22,'set_' + n,setterExpr,[/*Var*/[24,setterVar,t_5574,null,true,false,".Var"]],null,false,false,".Function"]);
						const property = /*Property*/[26,field_5572,getter,setter,".Property"];
						this.project.data.set(property, new NodeData(pos_5571.line, pos_5571.column, this.lex.fileName));
						this.project.data.set(getter, new NodeData(pos_5571.line, pos_5571.column, this.lex.fileName));
						this.project.data.set(setter, new NodeData(pos_5571.line, pos_5571.column, this.lex.fileName));
						fields.push(property);
						{
							let step = 0;
							const getter_5580 = getter;
							if (step == 0 && getter_5580 != null) { step = 1 };
							if (step == 1) { fields.push(getter_5580) };
						};
						{
							let step_5581 = 0;
							const setter_5582 = setter;
							if (step_5581 == 0 && setter_5582 != null) { step_5581 = 1 };
							if (step_5581 == 1) { fields.push(setter_5582) };
						};
					}
				} break;
				
				default: 
				this.fail('Fields cannot start with `' + this.print() + '`', null, null, null)
				};
			};
		};
		return fields;
	};
		tok() { return (this.lex.token[this.i]) };
		print() { return Token.stringify((this.lex.token[this.i]), this.lex.value[this.i]) };
		expect(t_5583) { if (t_5583 != this.tok()) { this.expected(Token.stringify(t_5583)) } };
		fail(message, line, column, filename) {
		const line_5584 = ((line != null)? (line) : this.lex.line[this.i]);
		const column_5585 = ((column != null)? (column) : this.lex.column[this.i]);
		const filename_5586 = ((filename != null)? (filename) : this.lex.fileName);
		this.hints.push(new CompilerError(0, message, line_5584, column_5585, filename_5586));
		throw new CompilerErrors(this.hints);
	};
		failHint(message_5587, line_5588, column_5589, filename_5590) {
		const line_5591 = ((line_5588 != null)? (line_5588) : this.lex.line[this.i]);
		const column_5592 = ((column_5589 != null)? (column_5589) : this.lex.column[this.i]);
		const filename_5593 = ((filename_5590 != null)? (filename_5590) : this.lex.fileName);
		this.hints.push(new CompilerError(0, message_5587, line_5591, column_5592, filename_5593));
	};
		getgo(t_5594) {
		this.expect(t_5594);
		return this.lex.value[(this.i++)];
	};
		step(t_5595) {
		this.expect(t_5595);
		this.i++;
	};
		next() { this.i++ };
		offset(v_5596) { return (this.lex.token[this.i + v_5596]) };
		unexpected() {
		const token_5597 = Token.stringify((this.lex.token[this.i]), this.lex.value[this.i]);
		let error = ('Unexpected `' + (token_5597) + '`');
		if (this.tok() == 82) { error += ' semicolon. Note: Hexa has no semicolons!' };
		if (this.print() == 'public') { error += '. Note: Hexa has no `public` keyword!' };
		this.fail(error, null, null, null);
	};
		expected(str) {
		const token_5598 = Token.stringify((this.lex.token[this.i]), this.lex.value[this.i]);
		this.fail(('Expected `' + (str) + '` before `' + (token_5598) + '`'), null, null, null);
	};
		parseExpr() {
		let atts_5599 = [];
		while (this.tok() == 70) {
			atts_5599.push(this.parseDecorator());
		};
		const node = this.tok();
		const nodePosition = {line:this.lex.line[this.i], column:this.lex.column[this.i]};
		let result = null;
		{
			const temp_5600 = node;
			switch (temp_5600) {
			case 13: {
				{
					this.i++;
					{
						const temp_5601 = this.tok();
						switch (temp_5601) {
						case 21: {
							result = this.parseFunction(false, true)
						} break;
						
						case 40: case 23: {
							{
								const parsed = this.parseVar(true);
								if (parsed.length > 1) {} else {
									result = parsed[0];
								};
							}
						} break;
						
						case 7: case 22: {
							result = this.parseClass(true)
						} break;
						
						case 61: {
							{
								const alias = this.parseType();
								this.step(91);
								const value_5602 = this.parseType();
								result = /*TypeAlias*/[9,alias,value_5602,".TypeAlias"];
							}
						} break;
						
						default: 
						this.fail(('Wrong `declare` format, got `' + (Token.stringify(this.tok())) + '`'), null, null, null)
						};
					};
				}
			} break;
			
			case 74: {
				{
					const startsAt = this.i;
					this.i++;
					if (this.tok() == 73) {
						this.i++;
						result = /*Block*/[12,[],".Block"];
					} else if (this.tok() == 62 && this.offset(1) == 76) {
						const names = [];
						const el = [];
						while (true) {
							names.push(this.getgo(62));
							this.step(76);
							el.push(this.parseExpr());
							if (this.tok() == 75) {
								this.i++;
								if (this.tok() == 73) { this.fail('Unexpected `}`, remove trailing `,` comma', null, null, null) };
								continue;
							} else {
								break;
							};
						};
						if (this.tok() != 73) { this.fail(('Expected `}` or `,` before `' + (this.print()) + '`'), null, null, null) };
						this.step(73);
						result = /*Object*/[38,names,el,".Object"];
					} else {
						const el_5603 = [];
						while (this.tok() != 73) {
							if (this.tok() == 0) {
								this.i = startsAt;
								this.fail('The block `{` has got unclosed to the end of the file', null, null, null);
							};
							el_5603.push(this.parseExpr());
						};
						this.step(73);
						result = /*Block*/[12,el_5603,".Block"];
					};
				}
			} break;
			
			case 17: {
				{
					this.i++;
					const econd = [this.parseExpr()];
					while (this.tok() == 75) {
						this.next();
						econd.push(this.parseExpr());
					};
					let eif = null;
					const eifAt = this.i;
					if (this.tok() != 76) { eif = this.parseExpr() };
					let eelse = null;
					const eelseAt = this.i;
					if (this.tok() == 10) {
						this.i++;
						{
							const temp_5604 = this.tok();
							switch (temp_5604) {
							case 17: {
								eelse = this.parseExpr()
							} break;
							
							default: 
							eelse = this.parseBlock()
							};
						};
					};
					if (eif != null) {
						const temp_5605 = eif;
						switch (temp_5605&&temp_5605[0]) {
						case 12: {
							{
							}
						} break;
						
						default: 
						{
							const temp_5606 = this.i;
							this.i = eifAt;
							this.failHint('`if` body must be a `{` block `}`', null, null, null);
							this.i = temp_5606;
						}
						};
					};
					if (eelse != null) {
						const temp_5607 = eelse;
						switch (temp_5607&&temp_5607[0]) {
						case 12: {
							{
							}
						} break;
						
						case 14: {
							{
							}
						} break;
						
						default: 
						{
							const temp_5608 = this.i;
							this.i = eelseAt;
							this.failHint('`else` body must be a `{` block `}`', null, null, null);
							this.i = temp_5608;
						}
						};
					};
					result = /*If*/[14,econd,eif,eelse,false,".If"];
				}
			} break;
			
			case 41: {
				{
					this.i++;
					const econd_5609 = this.parseExpr();
					const eAt = this.i;
					const e = this.parseExpr();
					{
						const temp_5610 = e;
						switch (temp_5610&&temp_5610[0]) {
						case 12: {
							{
							}
						} break;
						
						default: 
						{
							const temp_5611 = this.i;
							this.i = eAt;
							this.failHint('`while` body must be a `{` block `}`', null, null, null);
							this.i = temp_5611;
						}
						};
					};
					result = /*While*/[21,econd_5609,e,true,".While"];
				}
			} break;
			
			case 9: {
				{
					this.i++;
					const eAt_5612 = this.i;
					const e_5613 = this.parseExpr();
					{
						const temp_5614 = e_5613;
						switch (temp_5614&&temp_5614[0]) {
						case 12: {
							{
							}
						} break;
						
						default: 
						{
							const temp_5615 = this.i;
							this.i = eAt_5612;
							this.failHint('`do` body must be a `{` block `}`', null, null, null);
							this.i = temp_5615;
						}
						};
					};
					this.step(41);
					const econd_5616 = this.parseExpr();
					result = /*While*/[21,econd_5616,e_5613,false,".While"];
				}
			} break;
			
			case 80: {
				{
					const startsAt_5617 = this.i;
					this.next();
					if ((this.tok() == 79 && this.offset(1) == 90) || (this.tok() == 62 && this.offset(1) == 75) || (this.tok() == 62 && this.offset(1) == 76) || (this.tok() == 62 && this.offset(1) == 61) || (this.tok() == 62 && this.offset(1) == 79 && this.offset(2) == 90)) {
						const vars_5618 = [];
						const types_5619 = [];
						const values_5620 = [];
						while (this.tok() != 79) {
							vars_5618.push(this.getgo(62));
							if (this.tok() == 76) {
								this.i++;
								types_5619.push(this.parseType());
							};
							if (this.tok() == 61) { types_5619.push(this.parseType()) };
							if (this.tok() == 91) {
								this.i++;
								values_5620.push(this.parseExpr());
							};
							if (this.tok() == 75) { this.i++ };
						};
						this.step(79);
						this.step(90);
						const v_5621 = [];
						{
							let i_5622 = 0;
							let it_5623 = 0;
							let at_5624 = vars_5618.length;
							while (it_5623 < at_5624) {
								i_5622 = it_5623;
								it_5623++;
								{
									v_5621.push(/*Var*/[24,vars_5618[i_5622],types_5619[i_5622],values_5620[i_5622],true,false,".Var"]);
								};
							};
						};
						result = /*Arrow*/[23,this.parseExpr(),v_5621,null,".Arrow"];
					} else {
						if (this.tok() == 0) {
							this.i = startsAt_5617;
							this.fail('The parenthesis `(` has got unclosed to the end of the file', null, null, null);
						};
						const expr_5625 = this.parseExpr();
						if (this.tok() == 0) {
							this.i = startsAt_5617;
							this.fail('The parenthesis `(` has got unclosed to the end of the file', null, null, null);
						};
						this.step(79);
						result = /*Parenthesis*/[15,expr_5625,".Parenthesis"];
					};
				}
			} break;
			
			case 31: {
				{
					this.i++;
					{
						const temp_5626 = this.tok();
						switch (temp_5626) {
						case 73: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						case 40: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						case 23: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						case 4: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						case 3: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						case 8: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						case 31: {
							result = /*Return*/[16,null,".Return"]
						} break;
						
						default: 
						result = /*Return*/[16,this.parseExpr(),".Return"]
						};
					};
				}
			} break;
			
			case 35: {
				{
					this.i++;
					result = /*Throw*/[17,this.parseExpr(),".Throw"];
				}
			} break;
			
			case 8: {
				{
					this.i++;
					result = /*Continue*/[19,".Continue"];
				}
			} break;
			
			case 3: {
				{
					this.i++;
					result = /*Break*/[18,".Break"];
				}
			} break;
			
			case 1: {
				{
					this.i++;
					result = /*Underscore*/[45,".Underscore"];
				}
			} break;
			
			case 98: {
				{
					this.i++;
					result = /*Interval*/[46,".Interval"];
				}
			} break;
			
			case 87: case 86: case 89: case 88: case 107: {
				{
					const id = (this.lex.token[this.i]);
					this.i++;
					const value_5627 = this.parseExpr();
					const fix = (value_5628) => {
						const temp_5629 = value_5628;
						switch (temp_5629&&temp_5629[0]) {
						case 10: {
							const aa = temp_5629[1];
							const op = temp_5629[2];
							const bb = temp_5629[3];
							{
								const out = /*Binop*/[10,fix(aa),op,bb,".Binop"];
								this.project.data.set(out, this.project.data.get(value_5628));
								return out;
							}
						} break;
						
						default: 
						return /*Unop*/[20,id,false,value_5628,".Unop"]
						};
					};
					result = fix(value_5627);
				}
			} break;
			
			case 60: {
				{
					const meta = this.lex.meta[this.i];
					result = /*Float*/[7,parseFloat(this.getgo(60)),meta,".Float"];
				}
			} break;
			
			case 63: {
				{
					const meta_5630 = this.lex.meta[this.i];
					const value_5631 = this.getgo(63);
					{
						const temp_5632 = meta_5630;
						switch (temp_5632) {
						case 0: {
							{
								const at_5633 = this.i;
								const v_5634 = parseInt(value_5631, null);
								if (v_5634 > 2147483647 || v_5634 < (-2147483647)) {
									this.i = at_5633 - 1;
									this.fail(('Integer `' + (value_5631) + '` is too large for *signed* 32 bit, use `' + (value_5631) + 'u32` or `' + (value_5631) + 'n`'), null, null, null);
								};
								result = /*Int*/[5,v_5634,".Int"];
							}
						} break;
						
						case 9: {
							{
								const at_5635 = this.i;
								const v_5636 = BigInt(value_5631);
								if (v_5636 >= 256n || v_5636 < 0n) {
									this.i = at_5635 - 1;
									this.fail(('Integer `' + (value_5631) + '` is negative or too large for *unsigned* 8 bit, use `' + (value_5631) + 'u16` or `' + (value_5631) + 'n`'), null, null, null);
								};
								result = /*MetaInt*/[6,v_5636,meta_5630,".MetaInt"];
							}
						} break;
						
						case 8: {
							{
								const at_5637 = this.i;
								const v_5638 = BigInt(value_5631);
								if (v_5638 >= 65536n || v_5638 < 0n) {
									this.i = at_5637 - 1;
									this.fail(('Integer `' + (value_5631) + '` is negative or too large for *unsigned* 16 bit, use `' + (value_5631) + 'u32` or `' + (value_5631) + 'n`'), null, null, null);
								};
								result = /*MetaInt*/[6,v_5638,meta_5630,".MetaInt"];
							}
						} break;
						
						case 6: {
							{
								const at_5639 = this.i;
								const v_5640 = BigInt(value_5631);
								if (v_5640 >= 4294967296n || v_5640 < 0n) {
									this.i = at_5639 - 1;
									this.fail(('Integer `' + (value_5631) + '` is negative or too large for *unsigned* 32 bit, use `' + (value_5631) + 'u64` or `' + (value_5631) + 'n`'), null, null, null);
								};
								result = /*MetaInt*/[6,v_5640,meta_5630,".MetaInt"];
							}
						} break;
						
						default: 
						result = /*MetaInt*/[6,BigInt(value_5631),meta_5630,".MetaInt"]
						};
					};
				}
			} break;
			
			case 61: {
				if (this.offset(1) == 99) {
					const res = this.parseType();
					result = /*NodeTypeValue*/[51,res,".NodeTypeValue"];
				} else if (this.offset(1) == 81) {
					const name_5641 = this.getgo(61);
					this.i++;
					result = /*NodeTypeValue*/[51,/*Optional*/[0,/*Type*/[1,name_5641,null,".Type"],".Optional"],".NodeTypeValue"];
				} else {
					const name_5642 = this.getgo(61);
					result = /*NodeTypeValue*/[51,/*Type*/[1,name_5642,null,".Type"],".NodeTypeValue"];
				}
			} break;
			
			case 62: {
				{
					const pos_5643 = this.lex.column[this.i];
					const name_5644 = this.getgo(62);
					if (this.tok() == 90) {
						this.next();
						result = /*Arrow*/[23,this.parseExpr(),[/*Var*/[24,name_5644,null,null,true,false,".Var"]],null,".Arrow"];
					} else if ((this.tok() == 99) && (this.lex.column[this.i] == pos_5643 + name_5644.length)) {
						this.i++;
						const params = [this.parseType()];
						while (this.tok() == 75) {
							this.i++;
							params.push(this.parseType());
						};
						this.step(96);
						result = /*Ident*/[1,name_5644,params,".Ident"];
					} else {
						result = /*Ident*/[1,name_5644,null,".Ident"];
					};
				}
			} break;
			
			case 66: {
				result = /*String*/[0,this.getgo(66),".String"]
			} break;
			
			case 64: {
				{
					const str_5645 = this.getgo(64);
					if (this.hasInterpolation(str_5645)) { result = /*Parenthesis*/[15,this.parseInterpolations(str_5645),".Parenthesis"] } else {
						result = /*String*/[0,str_5645,".String"];
					};
				}
			} break;
			
			case 36: {
				{
					this.i++;
					result = /*Bool*/[2,true,".Bool"];
				}
			} break;
			
			case 14: {
				{
					this.i++;
					result = /*Bool*/[2,false,".Bool"];
				}
			} break;
			
			case 34: {
				{
					this.i++;
					result = /*This*/[3,".This"];
				}
			} break;
			
			case 26: {
				{
					this.i++;
					result = /*Null*/[8,".Null"];
				}
			} break;
			
			case 59: {
				{
					this.i++;
					result = /*Super*/[4,".Super"];
				}
			} break;
			
			case 40: {
				{
					const parsed_5646 = this.parseVar(false);
					if (parsed_5646.length > 1) {} else {
						result = parsed_5646[0];
					};
				}
			} break;
			
			case 23: {
				{
					const parsed_5647 = this.parseVar(false);
					if (parsed_5647.length > 1) {} else {
						result = parsed_5647[0];
					};
				}
			} break;
			
			case 37: {
				{
					this.i++;
					const exprAt = this.i;
					const expr_5648 = this.parseExpr();
					{
						const temp_5649 = expr_5648;
						switch (temp_5649&&temp_5649[0]) {
						case 12: {
							{
							}
						} break;
						
						default: 
						{
							const temp_5650 = this.i;
							this.i = exprAt;
							this.failHint('`try` body must be a `{` block `}`', null, null, null);
							this.i = temp_5650;
						}
						};
					};
					const vars_5651 = [];
					const t_5652 = [];
					const v_5653 = [];
					const catches = [];
					while (this.tok() == 6) {
						this.step(6);
						const name_5654 = this.getgo(62);
						vars_5651.push(name_5654);
						this.step(76);
						const type_5655 = this.parseType();
						t_5652.push(type_5655);
						v_5653.push(/*Var*/[24,name_5654,type_5655,null,true,false,".Var"]);
						const exprAt_5656 = this.i;
						const expr_5657 = this.parseExpr();
						{
							const temp_5658 = expr_5657;
							switch (temp_5658&&temp_5658[0]) {
							case 12: {
								{
								}
							} break;
							
							default: 
							{
								const temp_5659 = this.i;
								this.i = exprAt_5656;
								this.failHint('`catch` body must be a `{` block `}`', null, null, null);
								this.i = temp_5659;
							}
							};
						};
						catches.push(expr_5657);
					};
					if (catches.length == 0) { this.failHint('`try` must have at least one `catch` block', null, null, null) };
					result = /*Try*/[27,expr_5648,t_5652,v_5653,catches,".Try"];
				}
			} break;
			
			case 2: {
				{
					this.i++;
					if (this.tok() == 64) {
						result = /*Import*/[37,[],this.getgo(64),".Import"];
						this.project.data.set(result, new NodeData(nodePosition.line, nodePosition.column, this.lex.fileName));
						return result;
					};
					const el_5660 = [];
					while (true) {
						if (this.tok() == 62) { el_5660.push(/*Lower*/[0,this.getgo(62),".Lower"]) } else if (this.tok() == 61) { el_5660.push(/*Upper*/[1,this.getgo(61),".Upper"]) } else if (this.tok() == 102) {
							this.i++;
							this.step(58);
							el_5660.push(/*As*/[3,/*AllTheThings*/[2,".AllTheThings"],/*Lower*/[0,this.getgo(62),".Lower"],".As"]);
						} else {
							this.fail('Incorrect `import` syntax', null, null, null);
						};
						if (this.tok() == 58) {
							this.i++;
							if (this.tok() == 62) { el_5660.push(/*As*/[3,el_5660.pop(),/*Lower*/[0,this.getgo(62),".Lower"],".As"]) } else if (this.tok() == 61) { el_5660.push(/*As*/[3,el_5660.pop(),/*Upper*/[1,this.getgo(61),".Upper"],".As"]) } else {
								this.fail('Incorrect `import x as y` syntax', null, null, null);
							};
						};
						if (this.tok() == 75) { this.i++ } else {
							break;
						};
					};
					this.step(20);
					result = /*Import*/[37,el_5660,this.getgo(64),".Import"];
					this.project.data.set(result, new NodeData(nodePosition.line, nodePosition.column, this.lex.fileName));
					return result;
				}
			} break;
			
			case 11: {
				{
					const att = atts_5599;
					atts_5599 = [];
					this.i++;
					const t_5661 = this.parseType();
					let valuesType = null;
					if (this.tok() == 76) {
						this.i++;
						valuesType = this.parseType();
					};
					let extend = null;
					if (this.tok() == 12) {
						this.i++;
						extend = this.parseType();
					};
					this.step(74);
					const names_5662 = [];
					while (this.tok() != 73) {
						while (this.tok() == 70) {
							atts_5599.push(this.parseDecorator());
						};
						atts_5599 = [];
						{
							const temp_5663 = this.tok();
							switch (temp_5663) {
							case 61: {
								{
									const pos_5664 = new NodeData(this.lex.line[this.i], this.lex.column[this.i], this.lex.fileName);
									let tag = /*NodeTypeValue*/[51,/*Type*/[1,this.getgo(61),null,".Type"],".NodeTypeValue"];
									if (this.tok() == 80) {
										this.i++;
										const args = [];
										const argNames = [];
										while (true) {
											argNames.push(this.getgo(62));
											if (this.tok() == 76) { this.i++ };
											args.push(/*NodeTypeValue*/[51,this.parseType(),".NodeTypeValue"]);
											if (this.tok() == 75) { this.i++ } else {
												break;
											};
										};
										this.step(79);
										this.project.data.set(tag, pos_5664);
										tag = /*Call*/[13,tag,args,argNames,".Call"];
									} else if (this.tok() == 91) {
										this.i++;
										this.project.data.set(tag, pos_5664);
										tag = /*Binop*/[10,tag,91,this.parseExpr(),".Binop"];
									};
									this.project.data.set(tag, pos_5664);
									names_5662.push(tag);
								}
							} break;
							
							default: 
							names_5662.push(this.parseExpr())
							};
						};
					};
					this.step(73);
					result = /*Enum*/[39,t_5661,names_5662,valuesType,extend,".Enum"];
					this.project.mapDecorators.set(result, att);
				}
			} break;
			
			case 7: case 22: {
				{
					const att_5665 = atts_5599;
					atts_5599 = [];
					const me = this.parseClass(false);
					this.project.mapDecorators.set(me, att_5665);
					result = me;
				}
			} break;
			
			case 21: {
				{
					result = this.parseFunction(true, false);
					if (this.project.data.get(result) == null) {};
				}
			} break;
			
			case 72: {
				{
					this.i++;
					const el_5666 = [];
					const values_5667 = [];
					let isMap = false;
					if (this.tok() != 71) { while (true) {
						if (this.tok() == 76) {
							isMap = true;
							this.next();
							break;
						};
						el_5666.push(this.parseExpr());
						if (this.tok() == 76) {
							this.i++;
							values_5667.push(this.parseExpr());
							isMap = true;
						};
						if (this.tok() == 75) {
							this.i++;
							if (this.tok() == 71) { this.fail('Unexpected `]`, remove trailing comma `,` before `]` or add a value after `,` if required', null, null, null) };
						} else {
							break;
						};
					} };
					this.step(71);
					if (isMap) { result = /*Map*/[32,el_5666,values_5667,".Map"] } else {
						result = /*Array*/[31,el_5666,".Array"];
					};
				}
			} break;
			
			case 25: {
				{
					this.i++;
					const t_5668 = this.parseType();
					const names_5669 = [];
					const values_5670 = [];
					if (this.tok() == 74) {
						this.i++;
						if (this.tok() == 73) { this.step(73) } else if (this.tok() == 62 && this.offset(1) == 76) {
							while (this.tok() != 73) {
								names_5669.push(this.getgo(62));
								this.step(76);
								values_5670.push(this.parseExpr());
								if (this.tok() == 75) { this.i++ };
							};
							this.step(73);
						};
					};
					this.step(80);
					const args_5671 = [];
					const argNames_5672 = [];
					if (this.tok() != 79) { while (true) {
						{
							const temp_5673 = this.tok();
							switch (temp_5673) {
							case 79: {
								this.fail('Unexpected `)`, remove trailing `,` comma', null, null, null)
							} break;
							
							case 61: {
								{
									argNames_5672.push(null);
									args_5671.push(this.parseExpr());
									if (this.tok() == 76) {
										this.step(76);
										this.parseType();
									};
								}
							} break;
							
							default: 
							{
								if (this.offset(1) == 76) {
									argNames_5672.push(this.getgo(62));
									this.step(76);
								} else {
									argNames_5672.push(null);
								};
								args_5671.push(this.parseExpr());
							}
							};
						};
						if (this.tok() == 75) { this.i++ } else {
							break;
						};
					} };
					this.step(79);
					result = /*New*/[30,[],t_5668,args_5671,names_5669,values_5670,argNames_5672,".New"];
				}
			} break;
			
			case 33: {
				{
					this.i++;
					const exprs = [this.parseExpr()];
					while (this.tok() == 75) {
						this.i++;
						exprs.push(this.parseExpr());
					};
					this.step(74);
					const cases = [];
					const conds = [];
					const guards = [];
					while (this.tok() != 73) {
						this.step(4);
						if (this.tok() == 1) {
							conds.push(/*Underscore*/[45,".Underscore"]);
							this.i++;
						} else {
							conds.push(this.parseExpr());
						};
						if (this.tok() == 17) {
							this.i++;
							guards.push(this.parseExpr());
						} else {
							guards.push(null);
						};
						this.step(76);
						const exs = [];
						while (this.tok() != 4 && this.tok() != 73) {
							exs.push(this.parseExpr());
						};
						if (exs.length != 1) { cases.push(/*Block*/[12,exs,".Block"]) } else {
							cases.push(exs[0]);
						};
					};
					this.step(73);
					result = /*Switch*/[34,exprs,conds,guards,cases,".Switch"];
				}
			} break;
			
			case 15: {
				{
					this.i++;
					if (this.tok() == 23 || this.tok() == 40) {
						this.i++;
						const name_5674 = this.getgo(62);
						if (this.print() == 'of' || this.print() == 'in') {
							this.i++;
							let values_5675 = this.print();
							this.i++;
							while (this.tok() != 79 && this.tok() != 0) {
								if (this.tok() == 107 || this.tok() == 111) { values_5675 += ' ' + this.print() + ' ' } else {
									values_5675 += this.print();
								};
								this.i++;
							};
							this.fail(('This loop should be replaced to `for ' + (name_5674) + ' in ' + (values_5675) + '`'), null, null, null);
						};
						let classic = true;
						if (this.tok() == 91) { this.i++ } else {
							classic = false;
						};
						let specialCase = '';
						if ((this.tok() == 63) && (this.lex.value[this.i] == '0')) { this.i++ } else {
							while (this.tok() == 62 || this.tok() == 61 || this.tok() == 80 || this.tok() == 79 || this.tok() == 111 || this.tok() == 107 || this.tok() == 63 || this.tok() == 102 || this.tok() == 77) {
								if (this.tok() == 107 || this.tok() == 111) { specialCase += ' ' + this.print() + ' ' } else {
									specialCase += this.print();
								};
								this.i++;
							};
						};
						if (this.tok() == 82) { this.i++ } else {
							classic = false;
						};
						if ((this.tok() == 62) && (this.lex.value[this.i] == name_5674)) { this.i++ } else {
							classic = false;
						};
						let lesserOrEqual = false;
						if (this.tok() == 99) { this.i++ } else if (this.tok() == 100) {
							this.i++;
							lesserOrEqual = true;
						} else {
							classic = false;
						};
						let values_5676 = this.print();
						this.i++;
						while (this.tok() == 62 || this.tok() == 61 || this.tok() == 80 || this.tok() == 79 || this.tok() == 111 || this.tok() == 107 || this.tok() == 63 || this.tok() == 102 || this.tok() == 77) {
							if (this.tok() == 107 || this.tok() == 111) { values_5676 += ' ' + this.print() + ' ' } else {
								values_5676 += this.print();
							};
							this.i++;
						};
						if (lesserOrEqual) { values_5676 += ' + 1' };
						if (this.tok() == 82) { this.i++ } else {
							classic = false;
						};
						if ((this.tok() == 62) && (this.lex.value[this.i] == name_5674)) {
							this.i++;
							if (this.tok() == 87) { this.i++ } else {
								classic = false;
							};
						} else if (this.tok() == 87) {
							this.i++;
							if ((this.tok() == 62) && (this.lex.value[this.i] == name_5674)) { this.i++ } else {
								classic = false;
							};
						} else {
							classic = false;
						};
						if (this.tok() == 79) {} else {
							classic = false;
						};
						if ((classic) && (specialCase == '')) { this.fail(('This loop should be replaced to `for ' + (name_5674) + ' in ' + (values_5676) + '`'), null, null, null) };
						if (classic) { this.fail(('This loop should be replaced to `for ' + (name_5674) + ' in ' + (specialCase) + ' ... ' + (values_5676) + '`'), null, null, null) };
						this.fail(('Hexa has only `for ' + (name_5674) + ' in values` syntax'), null, null, null);
					};
					const name_5677 = this.getgo(62);
					this.step(20);
					const values_5678 = this.parseExpr();
					let range = null;
					if (this.tok() == 98) {
						this.i++;
						range = this.parseExpr();
					};
					const expression = this.parseExpr();
					result = /*For*/[49,name_5677,values_5678,expression,range,".For"];
				}
			} break;
			
			case 32: {
				{
					this.next();
					const fieldExpr = this.parseExpr();
					result = /*Static*/[47,fieldExpr,".Static"];
					this.project.data.set(result, this.project.data.get(fieldExpr));
				}
			} break;
			
			case 29: {
				{
					this.next();
					const fieldExpr_5679 = this.parseExpr();
					result = /*Private*/[48,fieldExpr_5679,".Private"];
					this.project.data.set(result, this.project.data.get(fieldExpr_5679));
				}
			} break;
			
			default: 
			this.unexpected()
			};
		};
		if (result == null) {
			process_3671.stdout.write('\n');
			this.fail('Expression is incomplete, current token is: ' + Token.stringify(this.tok()), null, null, null);
		};
		this.project.data.set(result, new NodeData(nodePosition.line, nodePosition.column, this.lex.fileName));
		if (atts_5599.length > 0) {
			this.project.mapDecorators.set(result, atts_5599);
			atts_5599 = [];
		};
		let done = this.i >= this.lex.length;
		while ((!done)) {
			this.project.data.set(result, new NodeData(this.lex.line[this.i], this.lex.column[this.i], this.lex.fileName));
			{
				const temp_5680 = this.tok();
				switch (temp_5680) {
				case 0: {
					done = true
				} break;
				
				case 72: {
					{
						this.i++;
						const index = this.parseExpr();
						if (this.tok() == 75) { this.fail('Expected `]` instead of `,` comma. Hexa supports only one `[index]` value.\n' + ('Note, you are indexing this expression: `' + (Node.stringify(result)) + '[' + (Node.stringify(index)) + ']`\n') + ('To create array here, wrap it with `{` as `{[' + (Node.stringify(index)) + ', ...]}` so it doesn\'t index previous expression.'), null, null, null) };
						this.step(71);
						result = /*Index*/[33,result,index,".Index"];
					}
				} break;
				
				case 57: {
					{
						this.i++;
						{
							const temp_5681 = this.tok();
							switch (temp_5681) {
							case 61: {
								result = /*Is*/[43,result,this.parseType(),".Is"]
							} break;
							
							default: 
							this.fail('Cannot parse type `' + Token.stringify(this.tok()) + '`', null, null, null)
							};
						};
					}
				} break;
				
				case 58: {
					{
						this.i++;
						let kind_5682 = this.tok();
						if (this.tok() == 89) { this.i++ } else if (this.tok() == 81) { this.i++ } else {
							kind_5682 = 123;
						};
						result = /*As*/[44,result,kind_5682,this.parseType(),".As"];
					}
				} break;
				
				case 80: {
					{
						const args_5683 = [];
						const argNames_5684 = [];
						this.i++;
						if (this.tok() != 79) { while (true) {
							{
								const temp_5685 = this.tok();
								switch (temp_5685) {
								case 79: {
									this.fail('Unexpected `)`, remove trailing `,` comma', null, null, null)
								} break;
								
								case 61: {
									{
										argNames_5684.push(null);
										args_5683.push(this.parseExpr());
										if (this.tok() == 76) {
											this.step(76);
											this.parseType();
										};
									}
								} break;
								
								default: 
								{
									if ((this.tok() == 62) && (this.offset(1) == 76)) {
										argNames_5684.push(this.getgo(62));
										this.step(76);
									} else {
										argNames_5684.push(null);
									};
									args_5683.push(this.parseExpr());
								}
								};
							};
							if (this.tok() == 75) { this.i++ } else {
								break;
							};
						} };
						this.step(79);
						result = /*Call*/[13,result,args_5683,argNames_5684,".Call"];
					}
				} break;
				
				case 90: {
					{
						this.next();
						result = /*Arrow*/[23,this.parseExpr(),[result],null,".Arrow"];
					}
				} break;
				
				case 87: {
					{
						{
							const temp_5686 = result;
							switch (temp_5686&&temp_5686[0]) {
							case 20: {
								return result
							} break;
							};
						};
						this.i++;
						result = /*Unop*/[20,87,true,result,".Unop"];
					}
				} break;
				
				case 86: {
					{
						{
							const temp_5687 = result;
							switch (temp_5687&&temp_5687[0]) {
							case 20: {
								return result
							} break;
							};
						};
						this.i++;
						result = /*Unop*/[20,86,true,result,".Unop"];
					}
				} break;
				
				case 77: {
					{
						this.i++;
						{
							const temp_5688 = this.tok();
							switch (temp_5688) {
							case 61: {
								result = /*DotUpper*/[29,result,this.getgo(61),".DotUpper"]
							} break;
							
							default: 
							result = /*Dot*/[28,result,this.getgo(62),".Dot"]
							};
						};
					}
				} break;
				
				case 81: {
					{
						this.i++;
						if (this.tok() == 77) {
							const name_5689 = this.getgo(62);
							result = /*Dot*/[28,result,name_5689,".Dot"];
						} else if (this.tok() == 81) {
							this.i++;
							result = /*Elvis*/[50,result,this.parseExpr(),".Elvis"];
						} else {
							const eif_5690 = this.parseExpr();
							this.step(76);
							const eelse_5691 = this.parseExpr();
							result = /*If*/[14,[result],eif_5690,eelse_5691,true,".If"];
						};
					}
				} break;
				
				case 113: {
					{
						this.i++;
						result = this.parseExpr();
					}
				} break;
				
				default: 
				{
					const failAt = this.i;
					const t_5692 = this.tok();
					if (Parser.isBinop(t_5692) && this.offset(1) == 91) {
						const op_5693 = this.tok();
						this.i++;
						this.i++;
						const b = this.parseExpr();
						{
							const temp_5694 = result;
							switch (temp_5694&&temp_5694[0]) {
							case 1: {
								{
								}
							} break;
							
							case 28: {
								{
								}
							} break;
							
							case 33: {
								{
								}
							} break;
							
							default: 
							{
								const temp_5695 = this.i;
								this.i = failAt;
								this.failHint(('Cannot reassign `=` expression `' + (Node.stringify(result)) + '`'), null, null, null);
								this.i = temp_5695;
							}
							};
						};
						result = /*AssignOp*/[11,result,op_5693,b,".AssignOp"];
					} else if (Parser.isBinop(t_5692)) {
						this.i++;
						const b_5696 = this.parseExpr();
						const a = result;
						{
							const temp_5697 = b_5696;
							switch (temp_5697&&temp_5697[0]) {
							case 10: {
								const aa_5698 = temp_5697[1];
								const op_5699 = temp_5697[2];
								const bb_5700 = temp_5697[3];
								{
									let tp = Parser.precedence(t_5692);
									const tLeft = tp > 99;
									tp = tp % 100;
									let bp = Parser.precedence(op_5699);
									const bLeft = bp > 99;
									bp = bp % 100;
									if (bp > tp) {
										const eb = /*Binop*/[10,result,t_5692,aa_5698,".Binop"];
										this.project.data.set(eb, (() => {
											const result_5701 = this.project.data.get(result);
											if (result_5701 != null) { return result_5701 };
											return (() => {
												const result_5702 = this.project.data.get(b_5696);
												if (result_5702 != null) { return result_5702 };
												return this.project.data.get(aa_5698);
											})();
										})());
										result = /*Binop*/[10,eb,op_5699,bb_5700,".Binop"];
									} else {
										result = /*Binop*/[10,result,t_5692,b_5696,".Binop"];
									};
								}
							} break;
							
							case 14: {
								const econd_5703 = temp_5697[1];
								const eif_5704 = temp_5697[2];
								const eelse_5705 = temp_5697[3];
								const ternary = temp_5697[4];
								if (ternary == true && t_5692 != 91) { result = /*If*/[14,[/*Binop*/[10,result,t_5692,econd_5703[0],".Binop"]],eif_5704,eelse_5705,true,".If"] } else {
									result = /*Binop*/[10,result,t_5692,b_5696,".Binop"];
								}
							} break;
							
							default: 
							result = /*Binop*/[10,result,t_5692,b_5696,".Binop"]
							};
						};
					} else {
						done = true;
					};
				}
				};
			};
		};
		if (result == null) {
			process_3671.stdout.write('\n');
			this.fail('Expression postfix is incomplete', null, null, null);
		};
		if (atts_5599.length > 0) {
			this.project.mapDecorators.set(result, atts_5599);
			atts_5599 = [];
		};
		this.project.data.set(result, new NodeData(nodePosition.line, nodePosition.column, this.lex.fileName));
		return result;
	};
		parseBlock() {
		this.step(74);
		if (this.tok() == 73) {
			this.i++;
			return /*Block*/[12,[],".Block"];
		} else if (this.tok() == 62 && this.offset(1) == 76) {
			const names_5706 = [];
			const el_5707 = [];
			while (true) {
				names_5706.push(this.getgo(62));
				this.step(76);
				el_5707.push(this.parseExpr());
				if (this.tok() == 75) {
					this.i++;
					if (this.tok() == 73) { this.fail('Unexpected `}`, remove trailing `,` comma', null, null, null) };
					continue;
				} else {
					break;
				};
			};
			if (this.tok() != 73) { this.fail(('Expected `}` or `,` before `' + (this.print()) + '`'), null, null, null) };
			this.step(73);
			return /*Object*/[38,names_5706,el_5707,".Object"];
		} else {
			const el_5708 = [];
			while (this.tok() != 73) {
				el_5708.push(this.parseExpr());
			};
			this.step(73);
			return /*Block*/[12,el_5708,".Block"];
		};
		return /*Block*/[12,[],".Block"];
	};
		parseVar(external) {
		const const_5709 = this.tok() == 23;
		this.i++;
		const vars_5710 = [];
		if (this.tok() == 83) {
			this.i++;
			const name_5711 = ((this.tok() == 62)? (this.print()) : 'name');
			const prefix = ((const_5709)? ('let') : 'var');
			this.fail(('Hexa doesn\'t support PHP-style variables, replace it to `' + (prefix) + ' ' + (name_5711) + '`'), null, null, null);
		};
		const parseSingleVar = () => {
			const varName = this.getgo(62);
			if (varName.endsWith('___')) { this.fail('Variables can\'t end with `___`, it is reserved.', null, null, null) };
			let type_5712 = null;
			if (this.tok() == 76) { this.i++ };
			const token_5713 = this.tok();
			if (token_5713 == 70) {
				this.i++;
				const name_5714 = this.print();
				this.i--;
				this.fail(('Decorators should be placed at variable\'s declaration like `@' + (name_5714) + ' var ' + (varName) + '` instead of their type.'), null, null, null);
			};
			if (token_5713 == 72 || token_5713 == 74 || token_5713 == 61 || token_5713 == 80) { type_5712 = this.parseType() };
			let expr_5715 = null;
			if (this.tok() == 91) {
				this.i++;
				expr_5715 = this.parseExpr();
			};
			return /*Var*/[24,varName,type_5712,expr_5715,const_5709,(() => {
				const result_5716 = external;
				if (result_5716 != null) { return result_5716 };
				return false;
			})(),".Var"];
		};
		const parseSingleBinding = () => {
			const path = [];
			while (this.tok() == 62 && this.offset(1) == 77) {
				path.push(this.getgo(62));
				this.i++;
			};
			path.push(this.getgo(61));
			this.step(77);
			path.push(this.getgo(61));
			if (this.tok() == 80 && this.offset(1) == 79) { this.fail('Don\'t use empty parenthesis for `let ' + path.join('.') + '()` bindings', null, null, null) };
			const bind = [];
			if (this.tok() == 80) {
				do {{
					this.i++;
					if (this.tok() == 1) {
						this.i++;
						bind.push(null);
					} else {
						bind.push(/*Var*/[24,this.getgo(62),null,null,const_5709,false,".Var"]);
					};
				}} while (this.tok() == 75);
				this.step(79);
			};
			this.step(91);
			const expr_5717 = this.parseExpr();
			return /*EnumExtract*/[40,path,bind,expr_5717,".EnumExtract"];
		};
		vars_5710.push(parseSingleVar());
		return vars_5710;
	};
		parseFunction(parseBody, external_5727) {
		const parseBody_5728 = (((parseBody != null))? (parseBody) : true);
		this.i++;
		let expr_5729 = null;
		let name_5730 = null;
		const vars_5731 = [];
		const atts_5732 = [];
		const types_5733 = [];
		const values_5734 = [];
		const pos_5735 = [];
		const params_5736 = null;
		let params_5737 = null;
		{
			const temp_5738 = this.tok();
			switch (temp_5738) {
			case 62: {
				{
					name_5730 = this.getgo(62);
					if (this.tok() == 99) {
						this.i++;
						const param = [this.parseType()];
						while (this.tok() == 75) {
							this.i++;
							param.push(this.parseType());
						};
						this.step(96);
						params_5737 = param;
					};
				}
			} break;
			
			case 61: {
				this.fail(('Function names can\'t start with uppercase `' + (this.print()) + '` -> `' + (Hint.toCamelCase(this.print())) + '`'), null, null, null)
			} break;
			
			default: 
			{
			}
			};
		};
		if ((name_5730 == null) && (external_5727)) { this.fail('Unnamed functions cannot be marked as `declare fun`', null, null, null) };
		if (name_5730 == 'concat') {};
		let variadic = false;
		this.step(80);
		{
			if (this.tok() != 79) { while (true) {
				const decorators = [];
				while (this.tok() == 70) {
					decorators.push(this.parseDecorator());
				};
				let expr_5739 = null;
				let t_5740 = null;
				if (this.tok() == 98) {
					variadic = true;
					this.i++;
				};
				pos_5735.push({line:this.lex.line[this.i], column:this.lex.column[this.i]});
				const name_5741 = this.getgo(62);
				if (this.tok() == 76) { this.i++ };
				if (this.tok() == 70) {
					this.i++;
					const decName = this.print();
					this.i--;
					this.fail(('Decorators should be placed at argument\'s declaration like `@' + (decName) + ' ' + (name_5741) + '` instead of their type.'), null, null, null);
				};
				const token_5742 = this.tok();
				if (token_5742 == 72 || token_5742 == 74 || token_5742 == 61 || token_5742 == 80) { t_5740 = this.parseType() };
				if (this.tok() == 91) {
					this.i++;
					expr_5739 = this.parseExpr();
				};
				vars_5731.push(name_5741);
				atts_5732.push(decorators);
				types_5733.push(t_5740);
				values_5734.push(expr_5739);
				if (this.tok() == 75) {
					this.i++;
					if (variadic) { this.fail(('Variadic `...' + (name_5741) + '` argument must be the last argument'), null, null, null) };
				} else {
					break;
				};
			} };
			this.step(79);
		};
		let rettype = null;
		if (this.tok() == 76) {
			this.i++;
			rettype = this.parseType();
		} else {
			const token_5743 = this.tok();
			if (token_5743 == 72 || token_5743 == 61 || token_5743 == 80) { rettype = this.parseType() };
		};
		if (parseBody_5728) {
			const temp_5744 = this.tok();
			switch (temp_5744) {
			case 25: {
				if (this.offset(1) == 80) {} else {
					expr_5729 = this.parseExpr();
				}
			} break;
			
			case 73: {
				{
				}
			} break;
			
			case 32: {
				{
				}
			} break;
			
			case 29: {
				{
				}
			} break;
			
			case 21: {
				{
				}
			} break;
			
			case 40: {
				{
				}
			} break;
			
			case 23: {
				{
				}
			} break;
			
			case 70: {
				{
					const tmp_5745 = this.i;
					while (this.tok() == 70) {
						this.parseDecorator();
					};
					if (this.tok() != 73 && this.tok() != 32 && this.tok() != 29 && this.tok() != 21) {
						this.i = tmp_5745;
						expr_5729 = this.parseExpr();
					} else {
						this.i = tmp_5745;
					};
				}
			} break;
			
			case 0: {
				{
					let step_5746 = 0;
					const name_5747 = name_5730;
					if (step_5746 == 0 && name_5747 != null) { step_5746 = 1 };
					if (step_5746 == 1) { this.fail(('Function `fun ' + (name_5747) + '` should have a `{ block }` as a body or must be marked as `declare fun ' + (name_5747) + '`'), null, null, null) } else {
						this.fail('Unnamed functions should have a `{ block }` as a body', null, null, null);
					};
				}
			} break;
			
			default: 
			expr_5729 = this.parseBlock()
			};
		};
		const v_5748 = [];
		{
			let i_5749 = 0;
			let it_5750 = 0;
			let at_5751 = vars_5731.length;
			while (it_5750 < at_5751) {
				i_5749 = it_5750;
				it_5750++;
				{
					const n_5752 = /*Var*/[24,vars_5731[i_5749],types_5733[i_5749],values_5734[i_5749],true,false,".Var"];
					this.project.data.set(n_5752, new NodeData(pos_5735[i_5749].line, pos_5735[i_5749].column, this.lex.fileName));
					{
						let step_5753 = 0;
						const decorators_5754 = atts_5732[i_5749];
						if (step_5753 == 0 && decorators_5754 != null) { step_5753 = 1 };
						if (step_5753 == 1) { this.project.mapDecorators.set(n_5752, decorators_5754) };
					};
					v_5748.push(n_5752);
				};
			};
		};
		{
			const temp_5755 = expr_5729;
			switch (temp_5755&&temp_5755[0]) {
			case null: case undefined: {
				{
				}
			} break;
			
			case 12: {
				{
				}
			} break;
			
			default: 
			{
				const named = (() => {
					const result_5756 = name_5730;
					if (result_5756 != null) { return result_5756 };
					return 'fun';
				})();
				this.i--;
				this.fail(('Function `' + (named) + '` should have a `{ block }` as a body'), null, null, null);
			}
			};
		};
		const result_5757 = /*Function*/[22,name_5730,expr_5729,v_5748,rettype,external_5727,variadic,".Function"];
		{
			let step_5758 = 0;
			const params_5759 = params_5737;
			if (step_5758 == 0 && params_5759 != null) { step_5758 = 1 };
			if (step_5758 == 1) { this.project.mapFuncParams.set(result_5757, params_5759) };
		};
		if (name_5730 == 'concat') {};
		return result_5757;
	};
		backtickOr(prefix_5760, value_5761, placeholder) {
		{
			let step_5762 = 0;
			const value_5763 = value_5761;
			if (step_5762 == 0 && value_5763 != null) { step_5762 = 1 };
			if (step_5762 == 1) { return prefix_5760 + '`' + value_5763 + '`' };
		};
		return placeholder;
	};
		parseClass(external_5764) {
		const _classExternal = this.classExternal;
		this.classExternal = external_5764;
		const isInterface = ((this.tok() == 22)? (1) : 0);
		this.i++;
		const t_5765 = this.parseType();
		{
			const temp_5766 = t_5765;
			switch (temp_5766&&temp_5766[0]) {
			case 1: {
				{
				}
			} break;
			
			case 2: {
				{
				}
			} break;
			
			case 6: {
				const name_5767 = temp_5766[1];
				{
					if (name_5767.startsWith('_')) { this.fail('Class name cannot start with `_` underscore', null, null, null) };
					this.fail(('Class name cannot start with lowercase and should be formatted as `class ' + (Hint.toTitleCase(name_5767)) + '`'), null, null, null);
				}
			} break;
			
			default: 
			this.fail('Class name should be formatted as `class TitleCase`', null, null, null)
			};
		};
		const ext = (((this.tok() == 12))? ((() => {
			this.i++;
			return this.parseType();
		})()) : (null));
		const impl = [];
		while (this.tok() == 18) {
			this.i++;
			impl.push(this.parseType());
		};
		this.step(74);
		const fields_5768 = this.parseFields();
		for (const f of $toIterator(fields_5768)) {
			if (this.project.data.get(f) == null) {
				console.log('FEAF NO POS', f);
				throw 'dead';
			};
		};
		this.step(73);
		const me_5769 = /*Class*/[25,t_5765,ext,impl,fields_5768,(() => {
			const result_5770 = external_5764;
			if (result_5770 != null) { return result_5770 };
			return false;
		})(),isInterface,".Class"];
		this.classExternal = _classExternal;
		return me_5769;
	};
		hasInterpolation(str_5771) {
		const chars = str_5771.split('');
		let i_5772 = 0;
		while (i_5772 < chars.length) {
			if (chars[i_5772] == '\\') { if (i_5772 + 1 < chars.length) { if (chars[i_5772 + 1] == '\\') { i_5772++ } else if (chars[i_5772 + 1] == '(') { return true } } };
			i_5772++;
		};
		return false;
	};
		parseInterpolations(str_5773) {
		const interpolate = (s) => {
			const out_5774 = ['"'];
			if (s.length < 2) { return s };
			let i_5775 = 0;
			const s_5776 = s.split('"').join('\\"');
			const pushInterpolator = () => {
				i_5775++;
				i_5775++;
				const pushParen = () => {
					i_5775++;
					while (i_5775 < s_5776.length) {
						out_5774.push(s_5776.charAt(i_5775));
						if (s_5776.charAt(i_5775) == '(') {
							pushParen();
							continue;
						};
						if (s_5776.charAt(i_5775) == ')') {
							i_5775++;
							return;
						};
						i_5775++;
					};
					throw 'String interpolation error: unclosed inner parenthesis';
				};
				while (i_5775 < s_5776.length) {
					out_5774.push(s_5776.charAt(i_5775));
					if (s_5776.charAt(i_5775) == '(') {
						pushParen();
						continue;
					};
					if (s_5776.charAt(i_5775) == ')') {
						i_5775++;
						return;
					};
					i_5775++;
				};
				throw 'String interpolation error: unclosed parenthesis';
			};
			const result_5777 = ['"'];
			while (i_5775 < s_5776.length) {
				if (s_5776.charAt(i_5775) == '\\' && s_5776.charAt(i_5775 + 1) == '(') {
					result_5777.push('" + ');
					out_5774.push('" + (');
					const ii = i_5775 + 1;
					pushInterpolator();
					result_5777.push(s_5776.substring(ii, i_5775 + 1));
					result_5777.push(' + "');
					out_5774.push(' + "');
				} else {
					out_5774.push(s_5776.charAt(i_5775));
					result_5777.push(s_5776.charAt(i_5775));
					i_5775++;
				};
			};
			result_5777.push('"');
			out_5774.push('"');
			return out_5774.join('');
		};
		const resStr = interpolate(str_5773);
		const tokens = Lexer.tokenize(Buffer.from(resStr), this.lex.fileName);
		try {
			const parsed_5779 = Parser.toNode(Parser.parseNodes(tokens, this.project));
			{
				const temp_5780 = parsed_5779;
				switch (temp_5780&&temp_5780[0]) {
				case 12: {
					throw 'String interpolation error: got a block'
				} break;
				
				default: 
				return parsed_5779
				};
			};
		} catch (temp_5778) {
			if (true) { 
			const e = temp_5778
			{
				this.fail('String interpolation error\n' + e, null, null, null);
			} } else
			
			throw temp_5778;
		};
	};
		parseDecorator() {
		this.i++;
		const name_5781 = this.getgo(62);
		const values_5782 = [];
		if (this.tok() == 80) {
			this.i++;
			if (this.tok() != 79) { while (true) {
				values_5782.push(this.parseExpr());
				if (this.tok() == 75) { this.i++ } else {
					break;
				};
			} };
			this.step(79);
		};
		return new Decorator(name_5781, values_5782);
	};
		parseType() {
		if (this.tok() == 70) {
			const decorators_5783 = [];
			while (this.tok() == 70) {
				decorators_5783.push(this.parseDecorator());
			};
			const type_5784 = this.parseUndecoratedType();
			this.project.typeDecorators.set(type_5784, decorators_5783);
			return type_5784;
		};
		return this.parseUndecoratedType();
	};
		parseUndecoratedType() {
		if (this.tok() == 62) { return /*Ident*/[6,this.getgo(62),".Ident"] };
		if (this.tok() == 63) { return /*Int*/[7,parseInt(this.getgo(63), null),".Int"] };
		if (this.tok() == 60) { return /*Float*/[8,parseFloat(this.getgo(60)),".Float"] };
		if (this.tok() == 64) { return /*String*/[9,this.getgo(64),".String"] };
		if (this.tok() == 62 && this.offset(1) == 80) {
			const name_5785 = this.getgo(62);
			this.i++;
			const argNames_5786 = [];
			const values_5787 = [];
			while (this.tok() != 79) {
				if (this.tok() == 62) {
					argNames_5786.push(this.getgo(62));
					this.step(76);
				} else {
					argNames_5786.push(null);
				};
				values_5787.push(this.parseType());
				if (this.tok() == 79) { break } else {
					this.step(75);
				};
			};
			this.step(79);
			return /*Call*/[10,name_5785,argNames_5786,values_5787,".Call"];
		};
		const path_5788 = (((this.tok() == 62 && this.offset(1) == 77))? ((() => {
			const result_5789 = this.getgo(62);
			this.i++;
			return result_5789;
		})()) : null);
		let result_5790 = null;
		{
			const temp_5791 = this.tok();
			switch (temp_5791) {
			case 61: {
				{
					const name_5792 = this.getgo(61);
					while (this.tok() == 77) {
						this.i++;
						this.getgo(61);
					};
					let sresult = ((this.tok() == 99)? ((() => {
						this.i++;
						this.parametricTypeNesting++;
						let params_5793 = [this.parseType()];
						while (this.tok() == 75) {
							this.i++;
							params_5793.push(this.parseType());
						};
						if (this.parametricTypeNestingToken == 0) { this.parametricTypeNestingToken = this.tok() };
						{
							const temp_5794 = this.parametricTypeNestingToken;
							switch (temp_5794) {
							case 96: {
								{
									this.parametricTypeNesting -= 1;
									this.parametricTypeNestingToken = 0;
									this.i++;
								}
							} break;
							
							case 106: {
								{
									this.parametricTypeNesting -= 1;
									this.parametricTypeNestingToken = 96;
								}
							} break;
							
							case 108: {
								{
									this.parametricTypeNesting -= 1;
									this.parametricTypeNestingToken = 108;
								}
							} break;
							
							default: 
							this.unexpected()
							};
						};
						if (this.parametricTypeNesting < 0) { this.fail('parametricTypeNesting < 0', null, null, null) };
						return /*ParametricType*/[2,name_5792,params_5793,path_5788,".ParametricType"];
					})()) : /*Type*/[1,name_5792,path_5788,".Type"]);
					if (this.tok() == 90) {
						this.i++;
						sresult = /*Function*/[3,[sresult],this.parseType(),".Function"];
					};
					result_5790 = sresult;
				}
			} break;
			
			case 72: {
				{
					if (path_5788 != null) { this.fail('This path syntax is incorrect', null, null, null) };
					this.i++;
					let res_5795 = null;
					{
						const temp_5796 = this.tok();
						switch (temp_5796) {
						case 71: {
							{
								this.i++;
								res_5795 = /*ParametricType*/[2,'Array',[/*Object*/[5,[],[],".Object"]],path_5788,".ParametricType"];
							}
						} break;
						
						case 76: {
							{
								this.i++;
								if (this.tok() == 71) {
									this.i++;
									res_5795 = /*ParametricType*/[2,'Map',[/*Object*/[5,[],[],".Object"], /*Object*/[5,[],[],".Object"]],path_5788,".ParametricType"];
								} else {
									res_5795 = /*ParametricType*/[2,'Map',[/*Object*/[5,[],[],".Object"], this.parseType()],path_5788,".ParametricType"];
								};
							}
						} break;
						
						default: 
						{
							const key = this.parseType();
							let innerRes = (((this.tok() == 76))? ((() => {
								this.i++;
								return /*ParametricType*/[2,'Map',[key, this.parseType()],path_5788,".ParametricType"];
							})()) : /*ParametricType*/[2,'Array',[key],path_5788,".ParametricType"]);
							this.step(71);
							if (this.tok() == 90) {
								this.i++;
								innerRes = /*Function*/[3,[res_5795],this.parseType(),".Function"];
							};
							res_5795 = innerRes;
						}
						};
					};
					result_5790 = res_5795;
				}
			} break;
			
			case 74: {
				{
					if (path_5788 != null) { this.fail('This path syntax is incorrect', null, null, null) };
					this.i++;
					let sresult_5797 = (((this.tok() == 73))? (/*Object*/[5,[],[],".Object"]) : (() => {
						let names_5798 = [];
						let types_5799 = [];
						while (this.tok() != 73) {
							names_5798.push(this.getgo(62));
							if (this.tok() == 76) {
								this.i++;
								types_5799.push(this.parseType());
							};
							if (this.tok() == 75) { this.i++ };
						};
						return /*Object*/[5,names_5798,types_5799,".Object"];
					})());
					this.step(73);
					if (this.tok() == 90) {
						this.i++;
						sresult_5797 = /*Function*/[3,[sresult_5797],this.parseType(),".Function"];
					};
					result_5790 = sresult_5797;
				}
			} break;
			
			case 80: {
				{
					if (path_5788 != null) { this.fail('This path syntax is incorrect', null, null, null) };
					this.i++;
					const args_5800 = [];
					while (this.tok() != 79) {
						if (this.tok() == 62) {
							this.step(62);
							if (this.tok() == 76) { this.i++ };
						};
						args_5800.push(this.parseType());
						if (this.tok() == 75) { this.i++ };
					};
					this.step(79);
					this.step(90);
					result_5790 = /*Function*/[3,args_5800,this.parseType(),".Function"];
				}
			} break;
			
			case 62: {
				{
					let res_5801 = null;
					{
						const temp_5802 = this.offset(1);
						switch (temp_5802) {
						case 76: {
							{
								const argName = this.getgo(this.tok());
								this.step(76);
								const argType = this.parseType();
								res_5801 = /*FunctionArg*/[4,argName,argType,null,".FunctionArg"];
							}
						} break;
						
						default: 
						this.fail(('Type name `' + (this.print()) + '` cannot start with lowercase'), null, null, null)
						};
					};
					result_5790 = res_5801;
				}
			} break;
			
			default: 
			this.fail('Expected type, parsed `' + Token.stringify(this.tok()) + '`', null, null, null)
			};
		};
		if (this.tok() == 81) { result_5790 = /*Optional*/[0,result_5790,".Optional"] };
		while (this.tok() == 81) {
			this.i++;
		};
		if (this.tok() == 90) {
			this.i++;
			result_5790 = /*Function*/[3,[result_5790],this.parseType(),".Function"];
		};
		return result_5790;
	};
	}
	Parser.toNode = (nodes) => {
		if (nodes.length == 0) { return null };
		if (nodes.length > 1) { return /*Block*/[12,nodes,".Block"] };
		return nodes[0];
	};
	Parser.parseNodes = (lexe, project, lint = false) => {
		const parser = new Parser(lexe, project, lint);
		if (parser.hints.length > 0) { throw new CompilerErrors(parser.hints) };
		return parser.nodes;
	};
	Parser.precedence = (op_5803) => {
		const left_5804 = 100;
		const right = 0;
		{
			const temp_5805 = op_5803;
			switch (temp_5805) {
			case 101: {
				return 100
			} break;
			
			case 102: {
				return 101
			} break;
			
			case 94: {
				return 101
			} break;
			
			case 110: {
				return 101
			} break;
			
			case 111: {
				return 102
			} break;
			
			case 107: {
				return 102
			} break;
			
			case 105: {
				return 103
			} break;
			
			case 106: {
				return 103
			} break;
			
			case 108: {
				return 103
			} break;
			
			case 104: {
				return 104
			} break;
			
			case 112: {
				return 104
			} break;
			
			case 109: {
				return 104
			} break;
			
			case 95: {
				return 105
			} break;
			
			case 103: {
				return 105
			} break;
			
			case 96: {
				return 105
			} break;
			
			case 99: {
				return 105
			} break;
			
			case 97: {
				return 105
			} break;
			
			case 100: {
				return 105
			} break;
			
			case 92: {
				return 107
			} break;
			
			case 93: {
				return 108
			} break;
			
			case 91: {
				return 10
			} break;
			
			default: 
			this.fail('No precedence for ' + Token.stringify(op_5803), null, null, null)
			};
		};
	};
	Parser.isBinop = (t_5806) => {
		const temp_5807 = t_5806;
		switch (temp_5807) {
		case 111: {
			return true
		} break;
		
		case 102: {
			return true
		} break;
		
		case 94: {
			return true
		} break;
		
		case 110: {
			return true
		} break;
		
		case 107: {
			return true
		} break;
		
		case 91: {
			return true
		} break;
		
		case 95: {
			return true
		} break;
		
		case 103: {
			return true
		} break;
		
		case 96: {
			return true
		} break;
		
		case 97: {
			return true
		} break;
		
		case 99: {
			return true
		} break;
		
		case 100: {
			return true
		} break;
		
		case 112: {
			return true
		} break;
		
		case 104: {
			return true
		} break;
		
		case 109: {
			return true
		} break;
		
		case 92: {
			return true
		} break;
		
		case 93: {
			return true
		} break;
		
		case 105: {
			return true
		} break;
		
		case 106: {
			return true
		} break;
		
		case 108: {
			return true
		} break;
		
		case 101: {
			return true
		} break;
		
		default: 
		return false
		};
	};
	var TestParser = class {
	}
	TestParser.passed = 0
	TestParser.overall = 0
	TestParser.test = () => {
		console.log('TestParser begin');
		TestParser.shouldAllEqual(new Map([['', '<!--null-->'], ['  ', '<!--null-->'], ['	', '<!--null-->'], ['   	', '<!--null-->'], ['\n', '<!--null-->'], ['\n\n', '<!--null-->'], ['\r\r\n\r\n\r\t', '<!--null-->'], ['{}', 'Block([])'], ['{{}}', 'Block([Block([])])'], ['{ 0 0 0 }', 'Block([Int(0),Int(0),Int(0)])'], ['0', 'Int(0)'], [' 0 ', 'Int(0)'], ['123', 'Int(123)'], ['12', 'Int(12)'], ['0x1', 'Int(1)'], ['0x0', 'Int(0)'], ['0xF', 'Int(15)'], ['0xFA', 'Int(250)'], ['0xFABCDEF', 'Int(262917615)'], ['0.0', 'Float(0)'], ['0.123', 'Float(0.123)'], ['\'s\'', 'String(s)'], ['\"s\"', 'String(s)']]));
		TestParser.shouldAllEqual(new Map([['i ++ ++ i', 'Block([Unop(++,true,Ident(i)),Unop(++,false,Ident(i))])'], ['a + b', 'Binop(Ident(a),+,Ident(b))'], ['a += b', 'AssignOp(Ident(a),+,Ident(b))']]));
		TestParser.shouldAllEqual(new Map([['"\\\\(v)"', 'String(\\\\(v))']]));
		TestParser.shouldAllEqualWithoutTrim([]);
		TestParser.shouldAllEqual(new Map([['import "test"', 'Import([],test)'], ['import xxx in "test"', 'Import([Lower(xxx)],test)'], ['import xxx as yyy in "test"', 'Import([Lower(xxx){as}Lower(yyy)],test)'], ['import XXX as YYY in "test"', 'Import([Upper(XXX){as}Upper(YYY)],test)'], ['import * as mmm in "test"', 'Import([*{as}Lower(mmm)],test)'], ['import XXX, YYY as ZZZ, www in "test"', 'Import([Upper(XXX),Upper(YYY){as}Upper(ZZZ),Lower(www)],test)']]));
		TestParser.shouldAllError(['import', 'import hehe', 'import _ as B in "test"', 'import * in "test"', 'import * as B in "test"']);
		TestParser.shouldAllEqual(new Map([['var a = new Array<A>()', 'Var(a,null,New([],ParametricType(Array,[Type(A)]),[],[],[],[]),false,false)'], ['a = Array<A>.staticField()', 'Binop(Ident(a),=,Call(Dot(NodeTypeValue(ParametricType(Array,[Type(A)])),staticField),[]))'], ['a = EnumTest.EnumField', 'Binop(Ident(a),=,DotUpper(NodeTypeValue(Type(EnumTest)),EnumField))'], ['a = EnumTest.EnumField(arg)', 'Binop(Ident(a),=,Call(DotUpper(NodeTypeValue(Type(EnumTest)),EnumField),[Ident(arg)]))'], ['a = EnumTest.EnumField(argName: argValue, arg2, arg3: arg3)', 'Binop(Ident(a),=,Call(DotUpper(NodeTypeValue(Type(EnumTest)),EnumField),[argName:Ident(argValue),Ident(arg2),arg3:Ident(arg3)]))'], ['a = EnumTest<A,B>.EnumField', 'Binop(Ident(a),=,DotUpper(NodeTypeValue(ParametricType(EnumTest,[Type(A),Type(B)])),EnumField))'], ['var a = b as B var c = d as! B var e = f as? B', 'Block([Var(a,null,As(Ident(b),<!--empty-->,Type(B)),false,false),Var(c,null,As(Ident(d),!,Type(B)),false,false),Var(e,null,As(Ident(f),?,Type(B)),false,false)])'], ['var a = b is B var c = d is B var e = f is B', 'Block([Var(a,null,As(Ident(b),Type(B)),false,false),Var(c,null,As(Ident(d),Type(B)),false,false),Var(e,null,As(Ident(f),Type(B)),false,false)])']]));
		TestParser.shouldAllEqual(new Map([['var x:[Array<T>]', 'Var(x,ParametricType(Array,[ParametricType(Array,[Type(T)])]),null,false,false)'], ['var x:[Map<K,V> : Array<T>]', 'Var(x,ParametricType(Map,[ParametricType(Map,[Type(K),Type(V)]),ParametricType(Array,[Type(T)])]),null,false,false)'], ['var x:{} var y:[] var z:[:] var w:()=>{}', 'Block([Var(x,Object([],[]),null,false,false),Var(y,ParametricType(Array,[Object([],[])]),null,false,false),Var(z,ParametricType(Map,[Object([],[]),Object([],[])]),null,false,false),Var(w,Function([],Object([],[])),null,false,false)])'], ['let x:()=>()=>()=>()=>Void', 'Var(x,Function([],Function([],Function([],Function([],Type(Void))))),null,true,false)']]));
		TestParser.shouldAllEqual(new Map([['enum A {}', 'Enum(Type(A),[])'], ['enum A { A B C }', 'Enum(Type(A),[NodeTypeValue(Type(A)),NodeTypeValue(Type(B)),NodeTypeValue(Type(C))])'], ['enum A { A(v:Int) B C(v:[K:V], a:Array<T>) }', 'Enum(Type(A),[\n					Call(NodeTypeValue(Type(A)),[v:NodeTypeValue(Type(Int))]),\n					NodeTypeValue(Type(B)),\n					Call(NodeTypeValue(Type(C)),[v:NodeTypeValue(ParametricType(Map,[Type(K),Type(V)])),a:NodeTypeValue(ParametricType(Array,[Type(T)]))])\n					])'], ['enum A { E(v: T<T>?) }', 'Enum(Type(A),[Call(NodeTypeValue(Type(E)),[v:NodeTypeValue(Optional(ParametricType(T,[Type(T)])))])])'], ['enum A { E(v: T<T?>) }', 'Enum(Type(A),[Call(NodeTypeValue(Type(E)),[v:NodeTypeValue(ParametricType(T,[Optional(Type(T))]))])])'], ['enum A { E(v: T?) }', 'Enum(Type(A),[Call(NodeTypeValue(Type(E)),[v:NodeTypeValue(Optional(Type(T)))])])']]));
		TestParser.shouldAllEqual(new Map([['new A(a: 1, b: 2)', 'New([],Type(A),[Int(1),Int(2)],[],[],[a,b])'], ['class A {} var a = new A { } ()', 'Block([Class(Type(A),null,[],[],false),Var(a,null,New([],Type(A),[],[],[],[]),false,false)])'], ['class A { var field: String } var a = new A { field: "Value" } ()', 'Block([Class(Type(A),null,[],[Var(field,Type(String),null,false,false)],false),Var(a,null,New([],Type(A),[],[field],[String(Value)],[]),false,false)])'], ['class A { var field: String var otherfield: Int } var a = new A { field: "Value", otherfield: 25 } ()', 'Block([Class(Type(A),null,[],[Var(field,Type(String),null,false,false),Var(otherfield,Type(Int),null,false,false)],false),Var(a,null,New([],Type(A),[],[field,otherfield],[String(Value),Int(25)],[]),false,false)])']]));
		TestParser.shouldAllError(['class A { new(a b) {} }', 'class A { new(a, b,) {} }', 'class A { new(,) {} }', 'fun f(a b c) {}', 'fun f(a b) {}', 'fun f(a, b,) {}', 'fun f(a,) {}', 'fun f(,) {}']);
		TestParser.shouldAllError(['class A { var i: Int { set (value) {} } }', 'class A { var i: Int { get {} set () {} } }', 'class A { var i: Int { get {} set {} } }', 'class A { let i: Int { get {} set (value) {} } }', 'class A { let i: Int { get {} set (value, val) {} } }', 'class A { var i: Int { get {} set (Value) {} } }', 'class A { var i: Int { get (value) {} set (value) {} } }', 'class A { var i: Int {} }']);
		TestParser.shouldAllError(['if (,) {}', 'if (a,) {}', 'switch (,) {}', 'switch (a,) {}', '@att(,) x', '@att(a,) x', '@att(a,b,) x', '@att(a b,) x', '@att(a b) x', 'new T(,)', 'new T(a b,)', 'new T(a,b,)', 'new T(a b)', 'call(1 2)', 'call(1 2,)', 'call(1,2,)', 'call(1,)', 'call(a:1,)', 'call(1:1,)', 'call(a:,)', 'call(a:)', 'call(,)', '[1 2]', '[,]', '[1,]', '[1,2,]', '[1:1 2:2]', '[1:1,2:2,]', '{a:1 b:2}', '{,}', '{a:1,}', '{a:1,b:2,}']);
		TestParser.shouldAllError(['=', '= 1']);
		TestParser.shouldAllEqual(new Map([['if this { this }', 'If([This],Block([This]),<!--null-->)'], ['if this, this { this } else { break }', 'If([This,This],Block([This]),Block([Break]))'], ['if this, let a = this { this } else { break }', 'If([This,Var(a,null,This,true,false)],Block([This]),Block([Break]))'], ['if let a = this, let b = this, this { this }', 'If([Var(a,null,This,true,false),Var(b,null,This,true,false),This],Block([This]),<!--null-->)']]));
		TestParser.shouldAllEqual(new Map([['declare var a: T', 'Var(a,Type(T),null,false,true)'], ['declare let a: T', 'Var(a,Type(T),null,true,true)'], ['declare fun name()', 'Function(name,null,[],null,true)'], ['declare fun name() hi()', 'Block([Function(name,null,[],null,true),Call(Ident(hi),[])])'], ['declare fun name() {}', 'Block([Function(name,null,[],null,true),Block([])])'], ['declare class A {}', 'Class(Type(A),null,[],[],true)'], ['declare A = B', 'TypeAlias(Type(A),Type(B))']]));
		TestParser.shouldAllError(['declare var a, b, c', 'declare anything']);
		TestParser.shouldAllEqual(new Map([['push([:])', 'Call(Ident(push),[Map([],[])])'], ['push([])', 'Call(Ident(push),[Array([])])'], ['[].length', 'Dot(Array([]),length)'], ['[:].length', 'Dot(Map([],[]),length)'], ['[[:]]', 'Array([Map([],[])])']]));
		console.log(('TestParser done ' + (Math.round((TestParser.passed / TestParser.overall) * 100)) + '% (' + (TestParser.passed) + '/' + (TestParser.overall) + ')'));
	};
	TestParser.shouldEqual = (input, test) => {
		const test_5809 = TestParser.deepTrim(test);
		TestParser.shouldEqualWithoutTrim(input, test_5809);
	};
	TestParser.shouldEqualWithoutTrim = (input_5810, test_5811) => {
		TestParser.overall++;
		const lexe = Lexer.tokenize(Buffer.from(input_5810), 'TEST');
		try {
			const parsed = Parser.toNode(Parser.parseNodes(lexe, new Project()));
			const res = TestParser.stringify(parsed);
			if (test_5811 != res) { throw ('TestParser test fail: `' + (input_5810) + '`\n\nExpect: `' + (test_5811) + '`\n\nParsed: `' + (res) + '`\n\nRaw: `' + (parsed) + '`') };
		} catch (temp) {
			if (true) { 
			const e = temp
			{
				console.log(e.toString());
				throw ('TestParser test fail: `' + (input_5810) + '` failed to parse');
			} } else
			
			throw temp;
		};
		TestParser.passed++;
	};
	TestParser.shouldAllEqual = (map) => { for (const input of $toIterator(map.keys())) {
		const test_5812 = map.get(input);
		TestParser.shouldEqual(input, test_5812);
	} };
	TestParser.shouldAllEqualWithoutTrim = (map_5813) => { for (const input of $toIterator(map_5813.keys())) {
		const test_5814 = map_5813.get(input);
		TestParser.shouldEqualWithoutTrim(input, test_5814);
	} };
	TestParser.shouldError = (input_5815) => {
		TestParser.overall++;
		try {
			const lexe_5817 = Lexer.tokenize(Buffer.from(input_5815), 'TEST');
			const parser = Parser.toNode(Parser.parseNodes(lexe_5817, new Project()));
		} catch (temp_5816) {
			if (true) { 
			const e = temp_5816
			{
				TestParser.passed++;
				return;
			} } else
			
			throw temp_5816;
		};
		throw ('TestParser test fail: `' + (input_5815) + '` did not throw exception.');
	};
	TestParser.shouldAllError = (input_5818) => { for (const str of $toIterator(input_5818)) {
		TestParser.shouldError(str);
	} };
	TestParser.deepTrim = (s) => { return s.split('\n').join('').split('\r').join('').split('\t').join('').split(' ').join('') };
	TestParser.stringify = (node) => {
		const temp_5819 = node;
		switch (temp_5819&&temp_5819[0]) {
		case null: case undefined: {
			return '<!--null-->'
		} break;
		
		case 0: {
			const s_5820 = temp_5819[1];
			return ('String(' + (s_5820) + ')')
		} break;
		
		case 1: {
			const s_5821 = temp_5819[1];
			return ('Ident(' + (s_5821) + ')')
		} break;
		
		case 2: {
			const b = temp_5819[1];
			return ('Bool(' + (b) + ')')
		} break;
		
		case 3: {
			return 'This'
		} break;
		
		case 4: {
			return 'Super'
		} break;
		
		case 5: {
			const s_5822 = temp_5819[1];
			return ('Int(' + (s_5822) + ')')
		} break;
		
		case 7: {
			const s_5823 = temp_5819[1];
			return ('Float(' + (s_5823) + ')')
		} break;
		
		case 8: {
			return 'Null'
		} break;
		
		case 18: {
			return 'Break'
		} break;
		
		case 19: {
			return 'Continue'
		} break;
		
		case 43: {
			const expr = temp_5819[1];
			const type = temp_5819[2];
			return 'As(' + TestParser.stringify(expr) + ',' + TestParser.stringifyType(type) + ')'
		} break;
		
		case 44: {
			const expr_5824 = temp_5819[1];
			const kind = temp_5819[2];
			const type_5825 = temp_5819[3];
			return 'As(' + TestParser.stringify(expr_5824) + ',' + Token.stringify(kind) + ',' + TestParser.stringifyType(type_5825) + ')'
		} break;
		
		case 10: {
			const a = temp_5819[1];
			const op = temp_5819[2];
			const b_5826 = temp_5819[3];
			return 'Binop(' + TestParser.stringify(a) + ',' + Token.stringify(op) + ',' + TestParser.stringify(b_5826) + ')'
		} break;
		
		case 11: {
			const a_5827 = temp_5819[1];
			const op_5828 = temp_5819[2];
			const b_5829 = temp_5819[3];
			return 'AssignOp(' + TestParser.stringify(a_5827) + ',' + Token.stringify(op_5828) + ',' + TestParser.stringify(b_5829) + ')'
		} break;
		
		case 12: {
			const els = temp_5819[1];
			return 'Block(' + TestParser.stringifyNodeArray(els) + ')'
		} break;
		
		case 24: {
			const name = temp_5819[1];
			const t = temp_5819[2];
			const expr_5830 = temp_5819[3];
			const const_5831 = temp_5819[4];
			const external = temp_5819[5];
			return ('Var(' + (name) + ',') + ((((t != null))? (TestParser.stringifyType(t)) : 'null')) + ',' + ((((expr_5830 != null))? (TestParser.stringify(expr_5830)) : 'null')) + (',' + (const_5831) + ',' + (external) + ')')
		} break;
		
		case 22: {
			const name_5832 = temp_5819[1];
			const expr_5833 = temp_5819[2];
			const vars = temp_5819[3];
			const rettype = temp_5819[4];
			const external_5834 = temp_5819[5];
			return ('Function(' + (name_5832) + ',') + (((expr_5833 == null)? ('null') : TestParser.stringify(expr_5833))) + ',' + TestParser.stringifyNodeArray(vars) + ',' + ((((rettype != null))? (TestParser.stringifyType(rettype)) : 'null')) + (',' + (external_5834) + ')')
		} break;
		
		case 23: {
			const expr_5835 = temp_5819[1];
			const vars_5836 = temp_5819[2];
			const rettype_5837 = temp_5819[3];
			return 'Arrow(' + (((expr_5835 == null)? ('null') : TestParser.stringify(expr_5835))) + ',' + TestParser.stringifyNodeArray(vars_5836) + ',' + ((((rettype_5837 != null))? (TestParser.stringifyType(rettype_5837)) : 'null')) + ')'
		} break;
		
		case 13: {
			const e = temp_5819[1];
			const el = temp_5819[2];
			const argNames = temp_5819[3];
			{
				let res_5838 = 'Call(' + TestParser.stringify(e) + ',[';
				{
					let i = 0;
					let it = 0;
					let at = el.length;
					while (it < at) {
						i = it;
						it++;
						{
							res_5838 += (((argNames[i] == null))? ('') : argNames[i] + ':');
							res_5838 += TestParser.stringify(el[i]) + ((((i != el.length - 1))? (',') : ''));
						};
					};
				};
				return res_5838 + '])';
			}
		} break;
		
		case 15: {
			const e_5839 = temp_5819[1];
			return 'Parenthesis(' + TestParser.stringify(e_5839) + ')'
		} break;
		
		case 16: {
			const e_5840 = temp_5819[1];
			return 'Return(' + TestParser.stringify(e_5840) + ')'
		} break;
		
		case 17: {
			const e_5841 = temp_5819[1];
			return 'Throw(' + TestParser.stringify(e_5841) + ')'
		} break;
		
		case 39: {
			const t_5842 = temp_5819[1];
			const els_5843 = temp_5819[2];
			return 'Enum(' + TestParser.stringifyType(t_5842) + ',' + TestParser.stringifyNodeArray(els_5843) + ')'
		} break;
		
		case 35: {
			const path = temp_5819[1];
			const els_5844 = temp_5819[2];
			return 'Module(' + path + ',' + TestParser.stringifyNodeArray(els_5844) + ')'
		} break;
		
		case 37: {
			const els_5845 = temp_5819[1];
			const path_5846 = temp_5819[2];
			{
				const stringifyImportNode = (node_5847) => {
					const temp_5848 = node_5847;
					switch (temp_5848&&temp_5848[0]) {
					case 0: {
						const name_5849 = temp_5848[1];
						return ('Lower(' + (name_5849) + ')')
					} break;
					
					case 1: {
						const name_5850 = temp_5848[1];
						return ('Upper(' + (name_5850) + ')')
					} break;
					
					case 2: {
						return '*'
					} break;
					
					case 3: {
						const left = temp_5848[1];
						const right = temp_5848[2];
						return stringifyImportNode(left) + '{as}' + stringifyImportNode(right)
					} break;
					};
				};
				return 'Import([' + (() => {
					const result = [];
					const value = els_5845;
					for (const p of $toIterator(value)) result.push(stringifyImportNode(p));
					return result;
				})().join(',') + '],' + path_5846 + ')';
			}
		} break;
		
		case 32: {
			const k = temp_5819[1];
			const v = temp_5819[2];
			return 'Map([' + TestParser.stringifyArray(k) + '],[' + TestParser.stringifyArray(v) + '])'
		} break;
		
		case 25: {
			const type_5851 = temp_5819[1];
			const extend = temp_5819[2];
			const implement = temp_5819[3];
			const fields = temp_5819[4];
			const external_5852 = temp_5819[5];
			{
				let res_5853 = 'Class(' + TestParser.stringifyType(type_5851) + ',';
				res_5853 += (((extend != null))? (TestParser.stringifyType(extend)) : 'null,');
				res_5853 += TestParser.stringifyNodeTypeArray(implement) + ',';
				res_5853 += TestParser.stringifyNodeArray(fields) + ',';
				res_5853 += external_5852 + ')';
				return res_5853;
			}
		} break;
		
		case 30: {
			const path_5854 = temp_5819[1];
			const t_5855 = temp_5819[2];
			const args = temp_5819[3];
			const names = temp_5819[4];
			const values = temp_5819[5];
			const argNames_5856 = temp_5819[6];
			return 'New([' + path_5854.join('.') + '],' + TestParser.stringifyType(t_5855) + ',' + TestParser.stringifyNodeArray(args) + ',[' + names.join(',') + '],' + TestParser.stringifyNodeArray(values) + ',[' + argNames_5856.join(',') + '])'
		} break;
		
		case 51: {
			const type_5857 = temp_5819[1];
			return 'NodeTypeValue(' + TestParser.stringifyType(type_5857) + ')'
		} break;
		
		case 9: {
			const alias = temp_5819[1];
			const value_5858 = temp_5819[2];
			return 'TypeAlias(' + TestParser.stringifyType(alias) + ',' + TestParser.stringifyType(value_5858) + ')'
		} break;
		
		case 28: {
			const l = temp_5819[1];
			const r = temp_5819[2];
			return 'Dot(' + TestParser.stringify(l) + ',' + r + ')'
		} break;
		
		case 29: {
			const l_5859 = temp_5819[1];
			const r_5860 = temp_5819[2];
			return 'DotUpper(' + TestParser.stringify(l_5859) + ',' + r_5860 + ')'
		} break;
		
		case 48: {
			const expr_5861 = temp_5819[1];
			return 'Private(' + TestParser.stringify(expr_5861) + ')'
		} break;
		
		case 14: {
			const econd = temp_5819[1];
			const eif = temp_5819[2];
			const eelse = temp_5819[3];
			return 'If(' + TestParser.stringifyNodeArray(econd) + ',' + TestParser.stringify(eif) + ',' + TestParser.stringify(eelse) + ')'
		} break;
		
		case 31: {
			const el_5862 = temp_5819[1];
			return 'Array(' + TestParser.stringifyNodeArray(el_5862) + ')'
		} break;
		
		case 20: {
			const op_5863 = temp_5819[1];
			const postfix = temp_5819[2];
			const e_5864 = temp_5819[3];
			return 'Unop(' + Token.stringify(op_5863) + ',' + postfix + ',' + TestParser.stringify(e_5864) + ')'
		} break;
		
		default: 
		throw '<!--' + node + '-->'
		};
	};
	TestParser.stringifyArray = (nodes) => { return (() => {
		const result_5865 = [];
		const value_5866 = nodes;
		for (const node of $toIterator(value_5866)) result_5865.push(TestParser.stringify(node));
		return result_5865;
	})().join(',') };
	TestParser.stringifyNodeArray = (arr) => { return '[' + TestParser.stringifyArray(arr) + ']' };
	TestParser.stringifyNodeTypeArray = (arr_5867) => { return '[' + (() => {
		const result_5868 = [];
		const value_5869 = arr_5867;
		for (const e of $toIterator(value_5869)) result_5868.push(TestParser.stringifyType(e));
		return result_5868;
	})().join(',') + ']' };
	TestParser.stringifyType = (node_5870) => {
		const temp_5871 = node_5870;
		switch (temp_5871&&temp_5871[0]) {
		case 1: {
			const s_5872 = temp_5871[1];
			return ('Type(' + (s_5872) + ')')
		} break;
		
		case 2: {
			const name_5873 = temp_5871[1];
			const params = temp_5871[2];
			return ('ParametricType(' + (name_5873) + ',[') + (() => {
				const result_5874 = [];
				const value_5875 = params;
				for (const p of $toIterator(value_5875)) result_5874.push(TestParser.stringifyType(p));
				return result_5874;
			})().join(',') + '])'
		} break;
		
		case 3: {
			const args_5876 = temp_5871[1];
			const rettype_5877 = temp_5871[2];
			return 'Function([' + (() => {
				const result_5878 = [];
				const value_5879 = args_5876;
				for (const e of $toIterator(value_5879)) result_5878.push(TestParser.stringifyType(e));
				return result_5878;
			})().join(',') + '],' + TestParser.stringifyType(rettype_5877) + ')'
		} break;
		
		case 5: {
			const names_5880 = temp_5871[1];
			const types = temp_5871[2];
			return 'Object([' + names_5880.join(',') + '],[' + (() => {
				const result_5881 = [];
				const value_5882 = types;
				for (const e of $toIterator(value_5882)) result_5881.push(TestParser.stringifyType(e));
				return result_5881;
			})().join(',') + '])'
		} break;
		
		case 0: {
			const type_5883 = temp_5871[1];
			return 'Optional(' + TestParser.stringifyType(type_5883) + ')'
		} break;
		
		default: 
		throw '<!--' + node_5870 + '-->'
		};
	};
	var GenJs = class {
		constructor() { 
			this.extension = '.js'
			this.nativeEnums = false
			this.toIterator = false
			this.tabs = '\t'
			this.globalAccessor = ''
			this.reserved = ['with', 'const', 'instanceof', 'typeof', 'delete', 'undefined', 'package_TODO', 'async', 'await', 'arguments']
			this.bi = 0
		{
	} };
		perform(normalizer) {
		this.project = normalizer;
		return this.stringify();
	};
		stringify() {
		const out = [('// Generated by Hexa ' + (version) + ' https://hexalang.github.io\n')];
		if (this.project.package.addLicenseNoticeToOutput) {
			out.push(('// Project: ' + (this.project.package.name) + '\n'));
			out.push(('// LICENSE ' + (this.project.package.license) + '\n'));
		} else {
			out.push('// The generated code is subject to the original license\n');
		};
		out.push(';(() => {\n\t"use strict"\n\tconst $global = typeof(window) === "undefined"? global : window');
		out.push('\n\tif (typeof($global.require) === "undefined") { $global.require = () => {} };');
		out.push(('\n\tconst selfVersion=\"' + (this.project.package.version) + '\";'));
		const constantsIndex = out.length;
		const constants = [];
		out.push('');
		for (const e of $toIterator(this.project.enumsSimple)) {
			if (e.staticVars.length + e.staticMethods.length == 0) { continue };
			out.push('\n\tvar ' + e.name + ' = {');
			for (const v of $toIterator(e.staticMethods)) {
				const temp = v;
				switch (temp&&temp[0]) {
				case 5: {
					const name = temp[1];
					const expr = temp[2];
					const args = temp[3];
					const defaults = temp[4];
					{
						out.push('\n\t\t' + name + ': ');
						out.push(this.printFunctionArguments(args, defaults) + ' => { ' + this.printStatement(expr) + ' }');
						out.push(',');
					}
				} break;
				};
			};
			out.push('\n\t}');
			for (const v of $toIterator(e.staticVars)) {
				const temp_5899 = v;
				switch (temp_5899&&temp_5899[0]) {
				case 3: {
					const name_5900 = temp_5899[1];
					const expr_5901 = temp_5899[2];
					{
						out.push('\n\t' + e.name + '.' + name_5900);
						if (expr_5901 != null) { out.push(' = ' + this.printExpression(expr_5901)) };
					}
				} break;
				
				case 4: {
					const name_5902 = temp_5899[1];
					const expr_5903 = temp_5899[2];
					{
						out.push('\n\t' + e.name + '.' + name_5902);
						out.push(' = ' + this.printExpression(expr_5903));
					}
				} break;
				};
			};
		};
		for (const e of $toIterator(this.project.enumsComplex)) {
			if ((e.staticMethods.length == 0) && (e.names.length == 0)) { out.push('\n\tvar ' + e.name + ' = {}') } else {
				out.push('\n\tvar ' + e.name + ' = {');
				for (const v of $toIterator(e.staticMethods)) {
					const temp_5904 = v;
					switch (temp_5904&&temp_5904[0]) {
					case 5: {
						const name_5905 = temp_5904[1];
						const expr_5906 = temp_5904[2];
						const args_5907 = temp_5904[3];
						const defaults_5908 = temp_5904[4];
						{
							out.push('\n\t\t' + name_5905 + ': ');
							out.push(this.printFunctionArguments(args_5907, defaults_5908) + ' => { ' + this.printStatement(expr_5906) + ' }');
							out.push(',');
						}
					} break;
					};
				};
				let i = 0;
				for (const name of $toIterator(e.names)) {
					if ((!e.expose)) { break };
					if (e.constructors[i] != null) {
						out.push('\n\t\t' + name + ': ');
						out.push('(' + e.constructors[i].join(',') + ')=>[');
						out.push('' + i + ',' + e.constructors[i].join(','));
						out.push('],');
					};
					i++;
				};
				out.push('\n\t}');
			};
			let i_5909 = 0;
			for (const name of $toIterator(e.names)) {
				if ((!e.expose)) { break };
				if (e.constructors[i_5909] != null) {} else {
					out.push('\n\tObject.defineProperty(' + e.name + ', "' + name + '", { get: () => { return [' + i_5909 + '] }})');
				};
				i_5909++;
			};
			for (const v of $toIterator(e.staticVars)) {
				const temp_5910 = v;
				switch (temp_5910&&temp_5910[0]) {
				case 3: {
					const name_5911 = temp_5910[1];
					const expr_5912 = temp_5910[2];
					{
						out.push('\n\t' + e.name + '.' + name_5911);
						if (expr_5912 != null) { out.push(' = ' + this.printExpression(expr_5912)) };
					}
				} break;
				
				case 4: {
					const name_5913 = temp_5910[1];
					const expr_5914 = temp_5910[2];
					{
						out.push('\n\t' + e.name + '.' + name_5913);
						out.push(' = ' + this.printExpression(expr_5914));
					}
				} break;
				};
			};
		};
		for (const i of $toIterator(this.project.interfaces)) {
			throw i;
		};
		for (const c of $toIterator(this.project.classes)) {
			if (c.useless || c.template) { continue };
			if (c.external) {
				if (c.jsRequire != null) {
					constants.push('\n\t' + 'const ' + c.name + ' = require("' + c.jsRequire + '")');
					continue;
				};
				{
					let step = 0;
					const jsNative = c.jsNative;
					let temp_5915 = null;
					if (step == 0 && jsNative != null) {
						temp_5915 = jsNative != c.name;
						step = 1;
					};
					if (step == 1 && temp_5915 != false) { step = 2 };
					if (step == 2) { out.push('\n\t' + 'var ' + c.name + ' = $global.' + jsNative) };
				};
				continue;
			};
			out.push('\n\t' + 'var ' + c.name + ' = class');
			{
				let step_5916 = 0;
				const extend = c.extend;
				if (step_5916 == 0 && extend != null) { step_5916 = 1 };
				if (step_5916 == 1) { out.push(' extends ' + extend) };
			};
			out.push(' {');
			for (const v of $toIterator(c.methods)) {
				const temp_5917 = v;
				switch (temp_5917&&temp_5917[0]) {
				case 5: {
					const name_5918 = temp_5917[1];
					const expr_5919 = temp_5917[2];
					const args_5920 = temp_5917[3];
					{
						if (name_5918 == null || name_5918 == 'new') { out.push('\n\t\tconstructor') } else {
							out.push('\n\t\t' + name_5918);
						};
						out.push('(' + args_5920.join(', ') + ') ');
						if ((name_5918 == null || name_5918 == 'new') && (c.vars.length > 0)) {
							out.push('{ ');
							for (const v of $toIterator(c.vars)) {
								const temp_5921 = v;
								switch (temp_5921&&temp_5921[0]) {
								case 3: {
									const name_5922 = temp_5921[1];
									const expr_5923 = temp_5921[2];
									if (expr_5923 != null) { out.push('\n\t\t\tthis.' + name_5922 + ' = ' + this.printExpression(expr_5923) + '') }
								} break;
								
								case 4: {
									const name_5924 = temp_5921[1];
									const expr_5925 = temp_5921[2];
									if (expr_5925 != null) { out.push('\n\t\t\tthis.' + name_5924 + ' = ' + this.printExpression(expr_5925) + '') }
								} break;
								};
							};
							out.push('\n\t\t');
							out.push(this.printStatement(expr_5919) + ' };');
						} else {
							out.push(this.printBlock(expr_5919) + ';');
						};
					}
				} break;
				};
			};
			for (const name of $toIterator(c.property)) {
				out.push('\n\t\tget ' + name + ('() { return this.get_' + (name) + '(); };'));
				out.push('\n\t\tset ' + name + ('(value) { return this.set_' + (name) + '(value); };'));
			};
			out.push('\n\t}');
			for (const v of $toIterator(c.staticVars)) {
				const temp_5926 = v;
				switch (temp_5926&&temp_5926[0]) {
				case 3: {
					const name_5927 = temp_5926[1];
					const expr_5928 = temp_5926[2];
					{
						out.push('\n\t' + c.name + '.' + name_5927);
						if (expr_5928 != null) { out.push(' = ' + this.printExpression(expr_5928)) };
					}
				} break;
				
				case 4: {
					const name_5929 = temp_5926[1];
					const expr_5930 = temp_5926[2];
					{
						out.push('\n\t' + c.name + '.' + name_5929);
						out.push(' = ' + this.printExpression(expr_5930));
					}
				} break;
				};
			};
			for (const v of $toIterator(c.staticMethods)) {
				const temp_5931 = v;
				switch (temp_5931&&temp_5931[0]) {
				case 5: {
					const name_5932 = temp_5931[1];
					const expr_5933 = temp_5931[2];
					const args_5934 = temp_5931[3];
					const defaults_5935 = temp_5931[4];
					{
						out.push('\n\t' + c.name + '.' + name_5932 + ' = ');
						out.push(this.printFunctionArguments(args_5934, defaults_5935) + ' => ' + this.printBlock(expr_5933) + ';');
					}
				} break;
				};
			};
		};
		for (const g of $toIterator(this.project.globalFuncs)) {
			const temp_5936 = g;
			switch (temp_5936&&temp_5936[0]) {
			case 5: {
				const name_5937 = temp_5936[1];
				const expr_5938 = temp_5936[2];
				const args_5939 = temp_5936[3];
				const defaults_5940 = temp_5936[4];
				if (expr_5938 != null) {
					{
						out.push('\n\tfunction ' + name_5937);
						out.push(this.printFunctionArguments(args_5939, defaults_5940) + ' ' + this.printBlock(expr_5938) + ';');
					}
				break; } }
			};
		};
		for (const g of $toIterator(this.project.globalVars)) {
			const temp_5941 = g;
			switch (temp_5941&&temp_5941[0]) {
			case 3: {
				const name_5942 = temp_5941[1];
				const expr_5943 = temp_5941[2];
				{
					out.push('\n\tvar ' + name_5942);
					if (expr_5943 != null) { out.push(' = ' + this.printExpression(expr_5943)) } else {
						out.push(' = null');
					};
				}
			} break;
			
			case 4: {
				const name_5944 = temp_5941[1];
				const expr_5945 = temp_5941[2];
				out.push('\n\tvar ' + name_5944 + ' = ' + this.printExpression(expr_5945))
			} break;
			};
		};
		this.tabs = '\t\t';
		for (const init of $toIterator(this.project.init)) {
			out.push('\n\t{\n\t\t');
			out.push(this.printStatement(init));
			out.push('\n\t}');
		};
		if (this.toIterator) { constants.unshift('\n\tconst $toIterator = (v) => typeof(v) === "number"? Array(Math.max(v, 0)).keys() : v;') };
		out[constantsIndex] = constants.join('');
		out.push('\n})();\n');
		return out.join('');
	};
		pushTab() { this.tabs += '\t' };
		popTab() { this.tabs = this.tabs.substring(0, this.tabs.length - 1) };
		printBlock(s) {
		const temp_5946 = s;
		switch (temp_5946&&temp_5946[0]) {
		case 1: {
			const el = temp_5946[1];
			{
				if (el.length == 1) {
					const temp_5947 = el[0];
					switch (temp_5947&&temp_5947[0]) {
					case 1: {
						return this.printStatement(el[0])
					} break;
					};
				};
				if (el.length == 1) { return '{ ' + this.printStatement(el[0]) + ' }' };
				if (el.length == 0) { return '{}' };
				return this.printStatement(s);
			}
		} break;
		
		default: 
		return '{ ' + this.printStatement(s) + ' }'
		};
	};
		printStatement(s_5948) {
		{
			const temp_5949 = s_5948;
			switch (temp_5949&&temp_5949[0]) {
			case 0: {
				const els = temp_5949[1];
				{
					let r = '';
					for (const s of $toIterator(els)) {
						if (s != null) { r += '\n' + this.tabs + this.printStatement(s) + ';' };
					};
					return r;
				}
			} break;
			
			case 18: {
				return 'break'
			} break;
			
			case 17: {
				return 'continue'
			} break;
			
			case 1: {
				const el_5950 = temp_5949[1];
				{
					if (el_5950.length == 1) {
						const temp_5951 = el_5950[0];
						switch (temp_5951&&temp_5951[0]) {
						case 1: {
							return this.printStatement(el_5950[0])
						} break;
						};
					};
					this.pushTab();
					let r_5952 = '{';
					for (const e of $toIterator(el_5950)) {
						const temp_5953 = e;
						switch (temp_5953&&temp_5953[0]) {
						case null: case undefined: {
							{
							}
						} break;
						
						case 0: {
							const els_5954 = temp_5953[1];
							for (const s of $toIterator(els_5954)) {
								if (s != null) { r_5952 += '\n' + this.tabs + this.printStatement(s) + ';' };
							}
						} break;
						
						default: 
						r_5952 += '\n' + this.tabs + this.printStatement(e) + ';'
						};
					};
					this.popTab();
					return r_5952 + '\n' + this.tabs + '}';
				}
			} break;
			
			case 4: {
				const name_5955 = temp_5949[1];
				const expr_5956 = temp_5949[2];
				return 'const ' + name_5955 + (((expr_5956 == null)? (' = null') : ' = ' + this.printExpression(expr_5956)))
			} break;
			
			case 3: {
				const name_5957 = temp_5949[1];
				const expr_5958 = temp_5949[2];
				return 'let ' + name_5957 + (((expr_5958 == null)? ('') : ' = ' + this.printExpression(expr_5958)))
			} break;
			
			case 5: {
				const name_5959 = temp_5949[1];
				const expr_5960 = temp_5949[2];
				const args_5961 = temp_5949[3];
				const defaults_5962 = temp_5949[4];
				return 'const ' + name_5959 + ' = ' + this.printFunctionArguments(args_5961, defaults_5962) + ' => ' + this.printBlock(expr_5960)
			} break;
			
			case 6: {
				const e = temp_5949[1];
				{
					if (e == null) { return 'return' };
					return 'return ' + this.printExpression(e);
				}
			} break;
			
			case 7: {
				const econd = temp_5949[1];
				const eif = temp_5949[2];
				const eelse = temp_5949[3];
				{
					let r_5963 = 'if (' + this.printExpression(econd) + ') ' + this.printBlock(eif);
					if (eelse != null) { r_5963 += ' else ' + this.printStatement(eelse) };
					return r_5963;
				}
			} break;
			
			case 2: {
				const e_5964 = temp_5949[1];
				const args_5965 = temp_5949[2];
				return this.printExpression(e_5964) + this.printCallArguments(args_5965)
			} break;
			
			case 19: {
				const args_5966 = temp_5949[1];
				return 'super' + this.printCallArguments(args_5966)
			} break;
			
			case 8: {
				const expr_5967 = temp_5949[1];
				const t = temp_5949[2];
				const v = temp_5949[3];
				const catches = temp_5949[4];
				const temp_5968 = temp_5949[5];
				{
					let r_5969 = 'try ';
					r_5969 += this.printBlock(expr_5967);
					r_5969 += (' catch (' + (temp_5968) + ') {\n') + this.tabs + '\t';
					this.pushTab();
					{
						let i_5970 = 0;
						let it = 0;
						let at = catches.length;
						while (it < at) {
							i_5970 = it;
							it++;
							{
								let typeof_5971 = 'T';
								{
									const temp_5972 = t[i_5970];
									switch (temp_5972&&temp_5972[0]) {
									case 6: {
										const type = temp_5972[1];
										typeof_5971 = type.name
									} break;
									
									default: 
									throw '' + t[i_5970]
									};
								};
								{
									const temp_5973 = typeof_5971;
									switch (temp_5973) {
									case 'Any': {
										r_5969 += 'if (true) { '
									} break;
									
									case 'String': {
										r_5969 += ('if (typeof(' + (temp_5968) + ') == \"string\") { ')
									} break;
									
									case 'Int': {
										r_5969 += ('if (typeof(' + (temp_5968) + ') == \"number\") { ')
									} break;
									
									case 'Float': {
										r_5969 += ('if (typeof(' + (temp_5968) + ') == \"number\") { ')
									} break;
									
									case 'Bool': {
										r_5969 += ('if (typeof(' + (temp_5968) + ') == \"boolean\") { ')
									} break;
									
									default: 
									r_5969 += ('if (' + (temp_5968) + ' instanceof ' + (typeof_5971) + ') { ')
									};
								};
								r_5969 += '\n' + this.tabs;
								r_5969 += ('const ' + (v[i_5970]) + ' = ' + (temp_5968) + '');
								r_5969 += '\n' + this.tabs;
								r_5969 += this.printStatement(catches[i_5970]);
								r_5969 += ' }';
								r_5969 += ' else';
								r_5969 += '\n' + this.tabs;
							};
						};
					};
					r_5969 += '\n' + this.tabs + ('throw ' + (temp_5968) + ';');
					this.popTab();
					return r_5969 + '\n' + this.tabs + '}';
				}
			} break;
			
			case 10: {
				const a = temp_5949[1];
				const v_5974 = temp_5949[2];
				return this.printExpression(a) + ' = ' + this.printExpression(v_5974)
			} break;
			
			case 9: {
				const e_5975 = temp_5949[1];
				return 'throw ' + this.printExpression(e_5975)
			} break;
			
			case 12: {
				const name_5976 = temp_5949[1];
				const over = temp_5949[2];
				const by = temp_5949[3];
				{
					{
						const temp_5977 = over;
						switch (temp_5977&&temp_5977[0]) {
						case 17: {
							return 'for (const ' + name_5976 + ' of ' + this.printExpression(over) + ') ' + this.printStatement(by)
						} break;
						};
					};
					this.toIterator = true;
					return 'for (const ' + name_5976 + ' of $toIterator(' + this.printExpression(over) + ')) ' + this.printStatement(by);
				}
			} break;
			
			case 14: {
				const e_5978 = temp_5949[1];
				return this.printExpression(e_5978) + '++'
			} break;
			
			case 15: {
				const e_5979 = temp_5949[1];
				return this.printExpression(e_5979) + '--'
			} break;
			
			case 13: {
				const econd_5980 = temp_5949[1];
				const e_5981 = temp_5949[2];
				const pre = temp_5949[3];
				{
					if (pre) { return 'while (' + this.printExpression(econd_5980) + ') ' + this.printStatement(e_5981) };
					return 'do {' + this.printStatement(e_5981) + '} while (' + this.printExpression(econd_5980) + ')';
				}
			} break;
			
			case 11: {
				const a_5982 = temp_5949[1];
				const op = temp_5949[2];
				const value = temp_5949[3];
				return this.printExpression(a_5982) + ' ' + Token.stringify(op) + '= ' + this.printExpression(value)
			} break;
			
			case 16: {
				const expr_5983 = temp_5949[1];
				const cases = temp_5949[2];
				const statements = temp_5949[3];
				const guards = temp_5949[4];
				const binds = temp_5949[5];
				{
					let r_5984 = 'switch (' + this.printExpression(expr_5983) + ') {';
					{
						let i_5985 = 0;
						let it_5986 = 0;
						let at_5987 = cases.length;
						while (it_5986 < at_5987) {
							i_5985 = it_5986;
							it_5986++;
							{
								if (cases[i_5985].length > 0) {
									r_5984 += '\n' + this.tabs;
									for (const cc of $toIterator(cases[i_5985])) {
										const temp_5988 = cc;
										switch (temp_5988&&temp_5988[0]) {
										case 7: {
											r_5984 += 'case null: case undefined: '
										} break;
										
										default: 
										r_5984 += 'case ' + this.printExpression(cc) + ': '
										};
									};
									this.pushTab();
									r_5984 += '{\n' + this.tabs;
									{
										let step_5989 = 0;
										const binders = binds[i_5985];
										if (step_5989 == 0 && binders != null) { step_5989 = 1 };
										if (step_5989 == 1) { for (const bind of $toIterator(binders)) {
											r_5984 += this.printStatement(bind) + ';\n' + this.tabs;
										} };
									};
									{
										let step_5990 = 0;
										const guard = guards[i_5985];
										if (step_5990 == 0 && guard != null) { step_5990 = 1 };
										if (step_5990 == 1) {
											this.pushTab();
											r_5984 += 'if (' + this.printExpression(guard) + ') {\n' + this.tabs;
										};
									};
									r_5984 += this.printStatement(statements[i_5985]);
									this.popTab();
									{
										let step_5991 = 0;
										const guard_5992 = guards[i_5985];
										if (step_5991 == 0 && guard_5992 != null) { step_5991 = 1 };
										if (step_5991 == 1) {
											this.popTab();
											r_5984 += '\n\t' + this.tabs + 'break; } }\n' + this.tabs;
										} else {
											r_5984 += '\n' + this.tabs + '} break;\n' + this.tabs;
										};
									};
								};
							};
						};
					};
					{
						let i_5993 = 0;
						let it_5994 = 0;
						let at_5995 = cases.length;
						while (it_5994 < at_5995) {
							i_5993 = it_5994;
							it_5994++;
							{
								if (cases[i_5993].length == 0) {
									r_5984 += '\n' + this.tabs + 'default: ';
									r_5984 += '\n' + this.tabs;
									r_5984 += this.printStatement(statements[i_5993]);
									r_5984 += '\n' + this.tabs;
								};
							};
						};
					};
					return r_5984 + '}';
				}
			} break;
			
			case null: case undefined: {
				console.error('Got null statement kind in JavaScript generator, probably unsupported feature was used, ignoring')
			} break;
			
			default: 
			console.error('Unknown statement kind:', s_5948)
			};
		};
		return '{/* undefined */}';
	};
		printCallArguments(args_5996) { return '(' + (() => {
		const result = [];
		const value_5997 = args_5996;
		for (const a of $toIterator(value_5997)) result.push(this.printExpression(a));
		return result;
	})().join(', ') + ')' };
		printFunctionArguments(args_5998, defaults_5999) { return '(' + (() => {
		const result_6000 = [];
		const value_6001 = args_5998.length;
		for (const a of $toIterator(value_6001)) result_6000.push(args_5998[a] + ((((defaults_5999 != null && defaults_5999[a] != null))? (' = ' + this.printExpression(defaults_5999[a])) : '')));
		return result_6000;
	})().join(', ') + ')' };
		printExpression(e_6002) {
		{
			const temp_6003 = e_6002;
			switch (temp_6003&&temp_6003[0]) {
			case 7: {
				return 'null'
			} break;
			
			case 8: {
				return 'this'
			} break;
			
			case 6: {
				const name_6004 = temp_6003[1];
				return name_6004
			} break;
			
			case 1: {
				const v_6005 = temp_6003[1];
				return '' + v_6005
			} break;
			
			case 2: {
				const v_6006 = temp_6003[1];
				const meta = temp_6003[2];
				const type_6007 = temp_6003[3];
				return '' + v_6006 + 'n'
			} break;
			
			case 3: {
				const v_6008 = temp_6003[1];
				return '' + v_6008
			} break;
			
			case 0: {
				const s_6009 = temp_6003[1];
				{
					const s_6010 = s_6009.split('');
					const charsOut = [];
					while (s_6010.length > 0) {
						const temp_6011 = s_6010[0];
						switch (temp_6011) {
						case '\'': {
							{
								charsOut.push('\\');
								charsOut.push('\'');
								s_6010.shift();
							}
						} break;
						
						case '\n': {
							{
								charsOut.push('\\n');
								s_6010.shift();
							}
						} break;
						
						case '\r': {
							{
								charsOut.push('\\r');
								s_6010.shift();
							}
						} break;
						
						case '\\': {
							{
								s_6010.shift();
								if (s_6010[0] == '\'') {
									charsOut.push('\\\'');
									s_6010.shift();
								} else if (s_6010[0] == '"') {
									charsOut.push('\\"');
									s_6010.shift();
								} else if (s_6010[0] == '\\') {
									charsOut.push('\\\\');
									s_6010.shift();
								} else {
									charsOut.push('\\');
								};
							}
						} break;
						
						default: 
						{
							charsOut.push(s_6010[0]);
							s_6010.shift();
						}
						};
					};
					return '\'' + charsOut.join('') + '\'';
				}
			} break;
			
			case 4: {
				return 'true'
			} break;
			
			case 5: {
				return 'false'
			} break;
			
			case 9: {
				const expr_6012 = temp_6003[1];
				const name_6013 = temp_6003[2];
				{
					{
						const temp_6014 = expr_6012;
						switch (temp_6014&&temp_6014[0]) {
						case 1: {
							return '(' + this.printExpression(expr_6012) + ').' + name_6013
						} break;
						
						case 3: {
							return '(' + this.printExpression(expr_6012) + ').' + name_6013
						} break;
						};
					};
					return this.printExpression(expr_6012) + '.' + name_6013;
				}
			} break;
			
			case 10: {
				const e_6015 = temp_6003[1];
				const args_6016 = temp_6003[2];
				return this.printExpression(e_6015) + this.printCallArguments(args_6016)
			} break;
			
			case 13: {
				const name_6017 = temp_6003[1];
				const expr_6018 = temp_6003[2];
				const args_6019 = temp_6003[3];
				const defaults_6020 = temp_6003[4];
				{
					if (name_6017 == null) { return this.printFunctionArguments(args_6019, defaults_6020) + ' => ' + this.printBlock(expr_6018) };
					return '((() => { const ' + name_6017 + ' = ' + this.printFunctionArguments(args_6019, defaults_6020) + ' => ' + this.printBlock(expr_6018) + '; return ' + name_6017 + ' })())';
				}
			} break;
			
			case 14: {
				const expr_6021 = temp_6003[1];
				const args_6022 = temp_6003[2];
				const defaults_6023 = temp_6003[3];
				return this.printFunctionArguments(args_6022, defaults_6023) + ' => (' + this.printExpression(expr_6021) + ')'
			} break;
			
			case 11: {
				const e_6024 = temp_6003[1];
				const args_6025 = temp_6003[2];
				return 'new ' + this.printExpression(e_6024) + this.printCallArguments(args_6025)
			} break;
			
			case 17: {
				const el_6026 = temp_6003[1];
				return '[' + (() => {
					const result_6027 = [];
					const value_6028 = el_6026;
					for (const a of $toIterator(value_6028)) result_6027.push(this.printExpression(a));
					return result_6027;
				})().join(', ') + ']'
			} break;
			
			case 19: {
				const op_6029 = temp_6003[1];
				const postfix = temp_6003[2];
				const e_6030 = temp_6003[3];
				{
					if (postfix) { return '(' + this.printExpression(e_6030) + Token.stringify(op_6029) + ')' };
					return '(' + Token.stringify(op_6029) + this.printExpression(e_6030) + ')';
				}
			} break;
			
			case 20: {
				const nullable = temp_6003[1];
				const othewise = temp_6003[2];
				return '((' + this.printExpression(nullable) + ') || (' + this.printExpression(othewise) + '))'
			} break;
			
			case 15: {
				const e_6031 = temp_6003[1];
				return '(' + this.printExpression(e_6031) + ')'
			} break;
			
			case 12: {
				const a_6032 = temp_6003[1];
				const op_6033 = temp_6003[2];
				const b = temp_6003[3];
				{
					const bn = (this.bi++);
					return '' + this.printExpression(a_6032) + ' ' + Token.stringify(op_6033) + ' ' + this.printExpression(b) + '';
				}
			} break;
			
			case 22: {
				const expr_6034 = temp_6003[1];
				const index = temp_6003[2];
				return this.printExpression(expr_6034) + '[' + this.printExpression(index) + ']'
			} break;
			
			case 21: {
				const econd_6035 = temp_6003[1];
				const eif_6036 = temp_6003[2];
				const eelse_6037 = temp_6003[3];
				{
					let r_6038 = '';
					try {
						r_6038 += '((' + this.printExpression(econd_6035) + ')?';
						r_6038 += ' (' + this.printExpression(eif_6036) + ')';
						r_6038 += ' : ' + this.printExpression(eelse_6037);
						return r_6038 + ')';
					} catch (temp_6039) {
						if (true) { 
						const error = temp_6039
						{
							console.log('If =>', e_6002, error);
							return r_6038 + '<!--If => error-->';
						} } else
						
						throw temp_6039;
					};
				}
			} break;
			
			case 27: {
				const expr_6040 = temp_6003[1];
				{
					const e_6041 = this.printExpression(expr_6040);
					return e_6041 + '&&' + e_6041 + '[0]';
				}
			} break;
			
			case 16: {
				const names = temp_6003[1];
				const el_6042 = temp_6003[2];
				return '{' + (() => {
					const result_6043 = [];
					const value_6044 = el_6042.length;
					for (const i of $toIterator(value_6044)) result_6043.push(((names[i]) + ':' + this.printExpression(el_6042[i])));
					return result_6043;
				})().join(', ') + '}'
			} break;
			
			case 18: {
				const keys = temp_6003[1];
				const values = temp_6003[2];
				{
					if (keys.length == 0) { return 'new Map()' };
					return 'new Map([' + (() => {
						const result_6045 = [];
						const value_6046 = keys.length;
						for (const i of $toIterator(value_6046)) result_6045.push('[' + this.printExpression(keys[i]) + ', ' + this.printExpression(values[i]) + ']');
						return result_6045;
					})().join(', ') + '])';
				}
			} break;
			
			case 25: {
				const a_6047 = temp_6003[1];
				const op_6048 = temp_6003[2];
				const value_6049 = temp_6003[3];
				return this.printExpression(a_6047) + ' ' + Token.stringify(op_6048) + '= ' + this.printExpression(value_6049)
			} break;
			
			case 26: {
				const kind = temp_6003[1];
				const args_6050 = temp_6003[2];
				const s_6051 = temp_6003[3];
				{
					const temp_6052 = kind;
					switch (temp_6052) {
					case 0: {
						return '((' + this.printExpression(args_6050[0]) + ') ' + s_6051 + ' (' + this.printExpression(args_6050[1]) + '))'
					} break;
					
					case 1: {
						return s_6051 + this.printCallArguments(args_6050)
					} break;
					
					case 2: {
						return '(' + s_6051 + '(' + this.printExpression(args_6050[0]) + '))'
					} break;
					
					case 3: {
						return '((' + this.printExpression(args_6050[1]) + ')' + s_6051 + ')'
					} break;
					};
				}
			} break;
			
			case 23: {
				const e_6053 = temp_6003[1];
				const t_6054 = temp_6003[2];
				return '(' + this.printExpression(e_6053) + ')'
			} break;
			
			case 24: {
				const e_6055 = temp_6003[1];
				const t_6056 = temp_6003[2];
				return '((' + this.printExpression(e_6055) + ') instanceof ' + Type.stringify(t_6056) + ')'
			} break;
			
			case 28: {
				const type_6057 = temp_6003[1];
				const tagName = temp_6003[2];
				const tag = temp_6003[3];
				const args_6058 = temp_6003[4];
				{
					if (args_6058.length == 0) { return ('/*' + (tagName) + '*/[') + this.printExpression(tag) + ',".' + tagName + '"]' };
					const i_6059 = 1;
					return (('/*' + (tagName) + '*/[') + this.printExpression(tag) + ',' + (() => {
						const result_6060 = [];
						const value_6061 = args_6058;
						for (const a of $toIterator(value_6061)) result_6060.push(this.printExpression(a));
						return result_6060;
					})().join(',') + ',".' + tagName + '"]');
				}
			} break;
			
			case 29: {
				const expr_6062 = temp_6003[1];
				const index_6063 = temp_6003[2];
				return this.printExpression(expr_6062) + '[' + (1 + index_6063) + ']'
			} break;
			
			case null: case undefined: {
				console.error('Got null expression kind in JavaScript generator, probably unsupported feature was used, ignoring')
			} break;
			
			default: 
			console.error('Unknown expression kind:', e_6002)
			};
		};
		return '{/* undefined */}';
	};
	}
	GenJs.spawn = () => { return new GenJs() };
	var GenCxx = class {
		constructor() { 
			this.defaultCallingConvention = '__conventionName '
			this.memory64 = true
			this.globalAccessor = ''
			this.declarationsOfFunctions = []
			this.declarationsOfOpaqueTypes = []
			this.declarationsOfFullTypes = []
			this.declarationsOfStringsMap = new Map()
			this.declarationsOfStrings = []
			this.forwardFunctions = []
			this.typedefFunctions = []
			this.globalVariables = []
			this.globalFunctions = []
			this.types = []
			this.dllExports = []
			this.tabs = ''
			this.reserved = []
			this.currentReturnType = null
			this.metaBlock = []
			this.tempId = 0
			this.last = ('')
			this.thisArgument = null
			this.customThis = null
		{
	} };
		perform(normalizer, target) {
		this.project = normalizer;
		return this.stringify(target);
	};
		stringify(target_6064) {
		if (this.project.memory == 64) { this.defaultCallingConvention = '' } else {
			this.defaultCallingConvention = '__stdcall ';
			this.memory64 = false;
		};
		const header = [('// Generated by Hexa ' + (version) + ' https://hexalang.github.io')];
		if (this.project.package.addLicenseNoticeToOutput) {
			header.push(('// Project: ' + (this.project.package.name) + ''));
			header.push(('// LICENSE ' + (this.project.package.license) + ''));
		} else {
			header.push('// The generated code is subject to the original license');
		};
		header.push(Fs.readFileSync(__dirname + '/library/cxx/hexa.c').toString('utf8', 0, 1073741824).split('\r\n').join('\n'));
		header.push('#ifdef __cplusplus');
		header.push('extern "C" {');
		header.push('#endif');
		const out = [];
		const forward = [];
		this.registerString('');
		this.declarationsOfStringsMap.set('', 0);
		this.registerString('null');
		this.declarationsOfStringsMap.set('null', 1);
		for (const e of $toIterator(this.project.enumsSimple)) {
			forward.push('struct ' + e.name + '_;');
			if (e.staticVars.length + e.staticMethods.length == 0) { continue };
			this.types.push(e.name + '_ {\n\t');
			for (const v of $toIterator(e.staticVars)) {
				const temp = v;
				switch (temp&&temp[0]) {
				case 3: {
					const name = temp[1];
					const expr = temp[2];
					const type = temp[3];
					this.globalVariables.push(('' + (this.stringifyType(type, false)) + ' ') + e.name + '_$' + name + '_;\n')
				} break;
				
				case 4: {
					const name_6065 = temp[1];
					const expr_6066 = temp[2];
					const type_6067 = temp[3];
					this.globalVariables.push(('' + (this.stringifyType(type_6067, false)) + ' ') + e.name + '_$' + name_6065 + '_;\n')
				} break;
				};
			};
			this.types.push('\n};\n');
			for (const v of $toIterator(e.staticMethods)) {
				const temp_6068 = v;
				switch (temp_6068&&temp_6068[0]) {
				case 5: {
					const name_6069 = temp_6068[1];
					const expr_6070 = temp_6068[2];
					const args = temp_6068[3];
					const defaults = temp_6068[4];
					const funcType = temp_6068[5];
					{
						this.forwardFunctions.push(this.printFunctionReturnType(funcType));
						this.forwardFunctions.push(' ' + e.name + '_$' + name_6069 + '_');
						this.forwardFunctions.push(this.printFunctionArguments(args, funcType, 10));
						this.forwardFunctions.push(';\n');
						out.push(this.printFunctionReturnType(funcType));
						out.push(' ' + e.name + '_$' + name_6069 + '_');
						out.push(this.printFunctionArguments(args, funcType, 10));
						const _currentReturnType = this.currentReturnType;
						this.currentReturnType = this.getFunctionReturnType(funcType);
						out.push(' ' + this.printBlock(expr_6070) + ';\n\n');
						this.currentReturnType = _currentReturnType;
					}
				} break;
				};
			};
		};
		for (const e of $toIterator(this.project.enumsComplex)) {
			forward.push('struct ' + e.name + '_;');
			this.types.push(e.name + '_ : Unknown_ {\n\t');
			this.types.push('\n\tAny_** enum_;');
			this.types.push('\n\tuint16_t is_;');
			this.types.push('\n\tuint8_t length_;');
			let i = 0;
			for (const name of $toIterator(e.names)) {
				if (e.constructors[i] != null) {
					out.push(e.name + '_* ' + e.name + '_$' + name + '_(');
					out.push((() => {
						const result = [];
						const value = e.constructors[i].length;
						for (const c of $toIterator(value)) result.push(this.stringifyType(e.constructorsTypes[i][c], false) + ' ' + e.constructors[i][c] + '_');
						return result;
					})().join(', '));
					out.push(') {\n');
					out.push('\t' + e.name + '_* _ = (' + e.name + '_*)(HEXA_NEW(sizeof(' + e.name + '_)));\n');
					out.push(('\t_->length_ = ' + (e.constructors[i].length) + ';\n'));
					out.push(('\t_->enum_ = (Any_**)(HEXA_NEW(sizeof(Any_*) * ' + (e.constructors[i].length) + '));\n'));
					out.push(('\t_->is_ = ' + (i) + ';\n'));
					{
						let c = 0;
						let it = 0;
						let at = e.constructors[i].length;
						while (it < at) {
							c = it;
							it++;
							{
								out.push(('\t_->enum_[' + (c) + '] = '));
								out.push(this.printToAnyConverter(e.constructors[i][c] + '_', e.constructorsTypes[i][c]));
								out.push(';\n');
							};
						};
					};
					out.push('\treturn _;\n');
					out.push('};\n');
				} else {
					out.push(e.name + '_* ' + e.name + '_$' + name + '_() {\n');
					out.push('\t' + e.name + '_* _ = (' + e.name + '_*)(HEXA_NEW(sizeof(' + e.name + '_)));\n');
					out.push('\t_->length_ = 0;\n');
					out.push(('\t_->is_ = ' + (i) + ';\n'));
					out.push('\treturn _;\n');
					out.push('};\n');
				};
				i++;
			};
			for (const v of $toIterator(e.staticVars)) {
				const temp_6071 = v;
				switch (temp_6071&&temp_6071[0]) {
				case 3: {
					const name_6072 = temp_6071[1];
					const expr_6073 = temp_6071[2];
					const type_6074 = temp_6071[3];
					this.globalVariables.push(('' + (this.stringifyType(type_6074, false)) + ' ') + e.name + '_$' + name_6072 + '_;\n')
				} break;
				
				case 4: {
					const name_6075 = temp_6071[1];
					const expr_6076 = temp_6071[2];
					const type_6077 = temp_6071[3];
					this.globalVariables.push(('' + (this.stringifyType(type_6077, false)) + ' ') + e.name + '_$' + name_6075 + '_;\n')
				} break;
				};
			};
			for (const v of $toIterator(e.staticMethods)) {
				const temp_6078 = v;
				switch (temp_6078&&temp_6078[0]) {
				case 5: {
					const name_6079 = temp_6078[1];
					const expr_6080 = temp_6078[2];
					const args_6081 = temp_6078[3];
					const defaults_6082 = temp_6078[4];
					const funcType_6083 = temp_6078[5];
					{
						this.forwardFunctions.push(this.printFunctionReturnType(funcType_6083));
						this.forwardFunctions.push(' ' + e.name + '_$' + name_6079 + '_');
						this.forwardFunctions.push(this.printFunctionArguments(args_6081, funcType_6083, 10));
						this.forwardFunctions.push(';\n');
						out.push(this.printFunctionReturnType(funcType_6083));
						out.push(' ' + e.name + '_$' + name_6079 + '_');
						out.push(this.printFunctionArguments(args_6081, funcType_6083, 10));
						const _currentReturnType_6084 = this.currentReturnType;
						this.currentReturnType = this.getFunctionReturnType(funcType_6083);
						out.push(' ' + this.printBlock(expr_6080) + ';\n\n');
						this.currentReturnType = _currentReturnType_6084;
					}
				} break;
				};
			};
			this.types.push('\n};\n');
		};
		const duplicates = [];
		for (const c of $toIterator(this.project.classes)) {
			if (c.external) {
				if (c.jsRequire != null) { forward.push(c.jsRequire) };
				{
					let step = 0;
					const jsNative = c.jsNative;
					let temp_6085 = null;
					if (step == 0 && jsNative != null) {
						temp_6085 = jsNative != c.name;
						step = 1;
					};
					if (step == 1 && temp_6085 != false) { step = 2 };
					if (step == 2) { forward.push('#define ' + c.name + ' ' + jsNative) };
				};
				continue;
			};
			if (c.name == 'Any') { continue };
			if (c.name == 'Bool') { continue };
			if (c.useless) {};
			if (c.template) { continue };
			const n = c.name + '_*';
			if (n != this.stringifyType(c.type, false)) {};
			c.name = this.stringifyType(c.type, false).replace('_*', '');
			if (c.name == 'Array') {};
			if (c.name.startsWith('IMAGE_THUNK_DATA')) {};
			if (c.name.startsWith('IMAGE_IMPORT_BY_NAME')) {};
			let isStruct = false;
			let isUnion = false;
			let isPacked = false;
			{
				const temp_6086 = c.type;
				switch (temp_6086&&temp_6086[0]) {
				case 5: {
					const type_6087 = temp_6086[1];
					{
						const atts = this.project.mapDecorators.get(type_6087.parent);
						isStruct = Decorator.getDecorator(atts, 'struct') != null;
						isUnion = Decorator.getDecorator(atts, 'union') != null;
						isPacked = Decorator.getDecorator(atts, 'packed') != null;
					}
				} break;
				
				case 6: {
					const type_6088 = temp_6086[1];
					{
						const atts_6089 = this.project.mapDecorators.get(type_6088.parent);
						isStruct = Decorator.getDecorator(atts_6089, 'struct') != null;
						isUnion = Decorator.getDecorator(atts_6089, 'union') != null;
						isPacked = Decorator.getDecorator(atts_6089, 'packed') != null;
					}
				} break;
				};
			};
			const nativeKind = ((isUnion)? ('union ') : 'struct ');
			const forwardedAs = nativeKind + c.name + '_;';
			if (duplicates.includes(forwardedAs)) { continue };
			duplicates.push(forwardedAs);
			forward.push(forwardedAs);
			forward.push(('typedef ' + (nativeKind) + '' + (c.name) + '_ ' + (c.name) + '_;'));
			if (isPacked) { this.types.push('#pragma pack(1)\n') };
			this.types.push(nativeKind + c.name + '_ {\n\t');
			const vtable = ['struct ' + c.name + '__ {\n\t'];
			if (isStruct || c.api == 20) {} else {
				this.types.push('\n\tconst struct ' + c.name + '__ * const _;');
			};
			const vtableValue = ['const struct ' + c.name + '__ ' + c.name + '__$ = {\n\t'];
			const vtableBind = [];
			let vi = (-1);
			for (const v of $toIterator(c.vars)) {
				vi++;
				{
					const temp_6090 = v;
					switch (temp_6090&&temp_6090[0]) {
					case 3: {
						const name_6091 = temp_6090[1];
						const expr_6092 = temp_6090[2];
						const type_6093 = temp_6090[3];
						{
							{
								let step_6094 = 0;
								const bits = c.varBits[vi];
								if (step_6094 == 0 && bits != null) { step_6094 = 1 };
								if (step_6094 == 1) {
									this.types.push(('\n\t' + (this.stringifyType(type_6093, false)) + ' ') + name_6091 + '_');
									this.types.push(' : ' + bits);
									this.types.push(';');
								} else {
									this.types.push(('\n\t' + (this.stringifyType(type_6093, false)) + ' ') + name_6091 + '_;');
								};
							};
							{
								const temp_6095 = type_6093;
								switch (temp_6095&&temp_6095[0]) {
								case 6: {
									const type_6096 = temp_6095[1];
									const generics = temp_6095[2];
									if (type_6096.name == 'ArrayByValue') {
										let arraySize = '';
										{
											let step_6097 = 0;
											const count = generics[1];
											if (step_6097 == 0 && count != null) { step_6097 = 1 };
											if (step_6097 == 1) { arraySize = '[' + Type.stringify(count) + ']' } else {
												arraySize = '[]';
											};
										};
										this.types.pop();
										this.types.push(('\n\t' + (this.stringifyType(generics[0], false)) + ' ') + name_6091 + '_' + arraySize + ';');
									}
								} break;
								};
							};
						}
					} break;
					
					case 4: {
						const name_6098 = temp_6090[1];
						const expr_6099 = temp_6090[2];
						const type_6100 = temp_6090[3];
						this.types.push(('\n\t' + (this.stringifyType(type_6100, false)) + ' ') + name_6098 + '_;')
					} break;
					};
				};
			};
			let nonEmptyTable = false;
			let hasToString = false;
			for (const v of $toIterator(c.methods)) {
				const temp_6101 = v;
				switch (temp_6101&&temp_6101[0]) {
				case 5: {
					const name_6102 = temp_6101[1];
					const expr_6103 = temp_6101[2];
					const args_6104 = temp_6101[3];
					const defaults_6105 = temp_6101[4];
					const funcType_6106 = temp_6101[5];
					{
						hasToString = hasToString || name_6102 == 'toString';
						if (name_6102 == null || name_6102 == 'new') {
							this.forwardFunctions.push(c.name + '_* ' + c.name + '_$new_');
							this.forwardFunctions.push(this.printFunctionArguments(args_6104, funcType_6106, 10));
							this.forwardFunctions.push(';\n');
							out.push(c.name + '_* ' + c.name + '_$this_');
							this.thisArgument = c.name + '_* $this';
							out.push(this.printFunctionArguments(args_6104, funcType_6106, 10));
							this.thisArgument = null;
							out.push(' {\n');
							this.customThis = '$this';
							for (const v of $toIterator(c.vars)) {
								const temp_6107 = v;
								switch (temp_6107&&temp_6107[0]) {
								case 3: {
									const name_6108 = temp_6107[1];
									const expr_6109 = temp_6107[2];
									const type_6110 = temp_6107[3];
									if (expr_6109 != null) {
										let isArrayByValue = false;
										{
											const temp_6111 = type_6110;
											switch (temp_6111&&temp_6111[0]) {
											case 6: {
												const c_6112 = temp_6111[1];
												if (c_6112.name == 'ArrayByValue') { isArrayByValue = true }
											} break;
											};
										};
										if ((!isArrayByValue)) { out.push('\t$this->' + name_6108 + '_ = ' + this.printInitializer(type_6110, expr_6109) + ';\n') } else {
										};
									}
								} break;
								
								case 4: {
									const name_6113 = temp_6107[1];
									const expr_6114 = temp_6107[2];
									const type_6115 = temp_6107[3];
									if (expr_6114 != null) { out.push('\t$this->' + name_6113 + '_ = ' + this.printInitializer(type_6115, expr_6114) + ';\n') }
								} break;
								};
							};
							this.pushTab();
							{
								const temp_6116 = expr_6103;
								switch (temp_6116&&temp_6116[0]) {
								case 1: {
									const el = temp_6116[1];
									if (el.length > 0) { out.push('\t' + this.printBlock(expr_6103) + ';\n') }
								} break;
								
								default: 
								out.push('\t' + this.printBlock(expr_6103) + ';\n')
								};
							};
							this.popTab();
							this.customThis = null;
							out.push('\n\treturn $this;\n');
							out.push('};\n\n');
							out.push(c.name + '_* ' + c.name + '_$new_');
							out.push(this.printFunctionArguments(args_6104, funcType_6106, 10));
							out.push(' {\n');
							out.push('\tvoid** $_ = (void**)(HEXA_NEW(sizeof(' + c.name + '_)));\n');
							if (c.api == 20) {} else {
								out.push('\t$_[0] = (void *)&' + c.name + '__$;\n');
							};
							out.push('\t' + c.name + '_* _ = (' + c.name + '_*)($_);\n');
							out.push('\t' + c.name + '_$this_(');
							const arg = (() => {
								const result_6117 = [];
								const value_6118 = args_6104;
								for (const a of $toIterator(value_6118)) result_6117.push(a + '_');
								return result_6117;
							})();
							arg.unshift('_');
							out.push(arg.join(', '));
							out.push(');\n');
							out.push('\treturn _;\n');
							out.push('};\n\n');
						} else {
							this.thisArgument = c.name + '_* $this';
							vtable.push('\n\t');
							vtable.push(this.printFunctionReturnType(funcType_6106));
							vtable.push(' (*const ' + name_6102 + '_) ');
							vtable.push(this.printFunctionArguments(args_6104, funcType_6106, 10));
							vtable.push(';');
							nonEmptyTable = true;
							this.forwardFunctions.push(this.printFunctionReturnType(funcType_6106));
							this.forwardFunctions.push(' ' + c.name + '_$' + name_6102 + '_');
							this.forwardFunctions.push(this.printFunctionArguments(args_6104, funcType_6106, 10));
							this.forwardFunctions.push(';\n');
							const vbind = '&' + c.name + '_$' + name_6102 + '_';
							vtableBind.push(vbind);
							out.push(this.printFunctionReturnType(funcType_6106));
							out.push(' ' + c.name + '_$' + name_6102 + '_');
							out.push(this.printFunctionArguments(args_6104, funcType_6106, 10));
							const _currentReturnType_6119 = this.currentReturnType;
							this.currentReturnType = this.getFunctionReturnType(funcType_6106);
							this.customThis = '$this';
							this.thisArgument = null;
							{
								let step_6120 = 0;
								const expr_6121 = expr_6103;
								if (step_6120 == 0 && expr_6121 != null) { step_6120 = 1 };
								if (step_6120 == 1) { out.push(' ' + this.printBlock(expr_6121) + ';\n\n') } else {
									const temp_6122 = (this.tempId++);
									out.push((' {\n\tHEXA_UNREACHABLE(' + (temp_6122) + ');\n\treturn nullptr;\n};\n\n'));
								};
							};
							this.customThis = null;
							this.currentReturnType = _currentReturnType_6119;
							this.currentReturnType = _currentReturnType_6119;
						};
					}
				} break;
				};
			};
			if (nonEmptyTable == false) { vtable.push('uint8_t padding_;') };
			if ((!hasToString)) {
				out.push('String_* ' + c.name + ('_$toString_(' + (c.name) + '_* this_) { return '));
				out.push(this.printExpression(/*String*/[0,'[object Object]',".String"]));
				out.push('; };\n\n');
			};
			for (const v of $toIterator(c.staticVars)) {
				const temp_6127 = v;
				switch (temp_6127&&temp_6127[0]) {
				case 3: {
					const name_6128 = temp_6127[1];
					const expr_6129 = temp_6127[2];
					const type_6130 = temp_6127[3];
					this.globalVariables.push(('' + (this.stringifyType(type_6130, false)) + ' ') + c.name + '_$' + name_6128 + '_;\n')
				} break;
				
				case 4: {
					const name_6131 = temp_6127[1];
					const expr_6132 = temp_6127[2];
					const type_6133 = temp_6127[3];
					this.globalVariables.push(('' + (this.stringifyType(type_6133, false)) + ' ') + c.name + '_$' + name_6131 + '_;\n')
				} break;
				};
			};
			this.types.push('\n};\n');
			if (isPacked) { this.types.push('#pragma pack()\n') };
			vtable.push('\n};\n');
			vtableValue.push(vtableBind.join(',\n\t'));
			vtable.push(vtableValue.join('') + '\n};\n');
			this.types.unshift(vtable.join(''));
			for (const v of $toIterator(c.staticMethods)) {
				const temp_6134 = v;
				switch (temp_6134&&temp_6134[0]) {
				case 5: {
					const name_6135 = temp_6134[1];
					const expr_6136 = temp_6134[2];
					const args_6137 = temp_6134[3];
					const defaults_6138 = temp_6134[4];
					const funcType_6139 = temp_6134[5];
					{
						this.forwardFunctions.push(this.printFunctionReturnType(funcType_6139));
						this.forwardFunctions.push(' ' + c.name + '_$' + name_6135 + '_');
						this.forwardFunctions.push(this.printFunctionArguments(args_6137, funcType_6139, 10));
						this.forwardFunctions.push(';\n');
						out.push(this.printFunctionReturnType(funcType_6139));
						out.push(' ' + c.name + '_$' + name_6135 + '_');
						out.push(this.printFunctionArguments(args_6137, funcType_6139, 10));
						const _currentReturnType_6140 = this.currentReturnType;
						this.currentReturnType = this.getFunctionReturnType(funcType_6139);
						out.push(' ' + this.printBlock(expr_6136) + ';\n\n');
						this.currentReturnType = _currentReturnType_6140;
					}
				} break;
				};
			};
		};
		for (const g of $toIterator(this.project.globalFuncs)) {
			const temp_6141 = g;
			switch (temp_6141&&temp_6141[0]) {
			case 5: {
				const name_6142 = temp_6141[1];
				const expr_6143 = temp_6141[2];
				const args_6144 = temp_6141[3];
				const defaults_6145 = temp_6141[4];
				const funcType_6146 = temp_6141[5];
				const variadic = temp_6141[6];
				{
					const link = this.project.globalLink.get(g);
					let shouldEmitHeader = false;
					let customHeader = null;
					let spec = '';
					let name_6147 = name_6142 + '_';
					{
						let step_6148 = 0;
						const link_6149 = link;
						if (step_6148 == 0 && link_6149 != null) { step_6148 = 1 };
						if (step_6148 == 1) {
							{
								const temp_6150 = link_6149.convention;
								switch (temp_6150) {
								case 1: {
									spec += '__attribute__((fastcall)) '
								} break;
								
								case 0: {
									spec += this.defaultCallingConvention
								} break;
								
								default: 
								{
								}
								};
							};
							if (link_6149.dllImport) {
								spec += '__declspec(dllimport) ';
								shouldEmitHeader = true;
							};
							if (link_6149.emitHeader) { shouldEmitHeader = true };
							if (link_6149.customHeader != null) { customHeader = link_6149.customHeader };
							{
								let step_6151 = 0;
								const rename = link_6149.rename;
								if (step_6151 == 0 && rename != null) { step_6151 = 1 };
								if (step_6151 == 1) { name_6147 = rename };
							};
							if (link_6149.dllExport) {
								spec += '__declspec(dllexport) ';
								this.dllExports.push((() => {
									const result_6152 = link_6149.linkName;
									if (result_6152 != null) { return result_6152 };
									return name_6147;
								})());
							};
						} else {
							spec += this.defaultCallingConvention;
						};
					};
					{
						let step_6153 = 0;
						const customHeader_6154 = customHeader;
						if (step_6153 == 0 && customHeader_6154 != null) { step_6153 = 1 };
						if (step_6153 == 1) {
							this.types.push(customHeader_6154);
							this.types.push('\n');
						} else if (expr_6143 != null || shouldEmitHeader) {
							this.types.push(spec);
							this.types.push(this.printFunctionReturnType(funcType_6146));
							this.types.push(' ' + name_6147);
							this.types.push(this.printFunctionArguments(args_6144, funcType_6146, variadic));
							{
								let step_6155 = 0;
								const link_6156 = link;
								let linkName = null;
								if (step_6155 == 0 && link_6156 != null) {
									linkName = link_6156.linkName;
									step_6155 = 1;
								};
								if (step_6155 == 1 && linkName != null) { step_6155 = 2 };
								if (step_6155 == 2) { this.types.push(' HEXA_LINK("' + linkName + '")') };
							};
							this.types.push(';\n');
						};
					};
					{
						let step_6157 = 0;
						const expr_6158 = expr_6143;
						if (step_6157 == 0 && expr_6158 != null) { step_6157 = 1 };
						if (step_6157 == 1) {
							out.push(this.printFunctionReturnType(funcType_6146));
							out.push(' ' + name_6147);
							out.push(this.printFunctionArguments(args_6144, funcType_6146, variadic));
							const _currentReturnType_6159 = this.currentReturnType;
							this.currentReturnType = this.getFunctionReturnType(funcType_6146);
							out.push(' ' + this.printBlock(expr_6158) + ';\n\n');
							this.currentReturnType = _currentReturnType_6159;
						};
					};
				}
			} break;
			};
		};
		out.push('int HEXA_MAIN(int argc, char **argv) {\n');
		out.push('%%%HEXA_STRINGS@@@\n');
		this.pushTab();
		for (const e of $toIterator(this.project.enumsSimple)) {
			for (const v of $toIterator(e.staticVars)) {
				const temp_6160 = v;
				switch (temp_6160&&temp_6160[0]) {
				case 3: {
					const name_6161 = temp_6160[1];
					const expr_6162 = temp_6160[2];
					const type_6163 = temp_6160[3];
					if (expr_6162 != null) { out.push('\t' + e.name + '_$' + name_6161 + '_ = ' + this.printExpression(expr_6162) + ';\n') }
				} break;
				
				case 4: {
					const name_6164 = temp_6160[1];
					const expr_6165 = temp_6160[2];
					const type_6166 = temp_6160[3];
					if (expr_6165 != null) { out.push('\t' + e.name + '_$' + name_6164 + '_ = ' + this.printExpression(expr_6165) + ';\n') }
				} break;
				};
			};
		};
		for (const e of $toIterator(this.project.enumsComplex)) {
			for (const v of $toIterator(e.staticVars)) {
				const temp_6167 = v;
				switch (temp_6167&&temp_6167[0]) {
				case 3: {
					const name_6168 = temp_6167[1];
					const expr_6169 = temp_6167[2];
					const type_6170 = temp_6167[3];
					if (expr_6169 != null) { out.push('\t' + e.name + '_$' + name_6168 + '_ = ' + this.printExpression(expr_6169) + ';\n') }
				} break;
				
				case 4: {
					const name_6171 = temp_6167[1];
					const expr_6172 = temp_6167[2];
					const type_6173 = temp_6167[3];
					if (expr_6172 != null) { out.push('\t' + e.name + '_$' + name_6171 + '_ = ' + this.printExpression(expr_6172) + ';\n') }
				} break;
				};
			};
		};
		for (const e of $toIterator(this.project.classes)) {
			for (const v of $toIterator(e.staticVars)) {
				const temp_6174 = v;
				switch (temp_6174&&temp_6174[0]) {
				case 3: {
					const name_6175 = temp_6174[1];
					const expr_6176 = temp_6174[2];
					const type_6177 = temp_6174[3];
					if (expr_6176 != null) { out.push('\t' + e.name + '_$' + name_6175 + '_ = ' + this.printExpression(expr_6176) + ';\n') }
				} break;
				
				case 4: {
					const name_6178 = temp_6174[1];
					const expr_6179 = temp_6174[2];
					const type_6180 = temp_6174[3];
					if (expr_6179 != null) { out.push('\t' + e.name + '_$' + name_6178 + '_ = ' + this.printExpression(expr_6179) + ';\n') }
				} break;
				};
			};
		};
		for (const g of $toIterator(this.project.globalVars)) {
			let defaults_6181 = true;
			{
				const temp_6182 = g;
				switch (temp_6182&&temp_6182[0]) {
				case 3: {
					const name_6183 = temp_6182[1];
					const expr_6184 = temp_6182[2];
					const type_6185 = temp_6182[3];
					{
						{
							const temp_6186 = type_6185;
							switch (temp_6186&&temp_6186[0]) {
							case 6: {
								const type_6187 = temp_6186[1];
								const generics_6188 = temp_6186[2];
								if (type_6187.name == 'ArrayByValue') {
									let arraySize_6189 = '';
									{
										let step_6190 = 0;
										const count_6191 = generics_6188[1];
										if (step_6190 == 0 && count_6191 != null) { step_6190 = 1 };
										if (step_6190 == 1) { arraySize_6189 = '[' + Type.stringify(count_6191) + ']' } else {
											arraySize_6189 = '[]';
										};
									};
									this.globalVariables.push(('' + (this.stringifyType(generics_6188[0], false)) + ' ') + name_6183 + '_' + arraySize_6189);
									{
										let step_6192 = 0;
										const expr_6193 = expr_6184;
										if (step_6192 == 0 && expr_6193 != null) { step_6192 = 1 };
										if (step_6192 == 1) {
											const temp_6194 = expr_6193;
											switch (temp_6194&&temp_6194[0]) {
											case 17: {
												const el_6195 = temp_6194[1];
												{
													const valueType = generics_6188[0];
													this.globalVariables.push(' = {' + (() => {
														const result_6196 = [];
														const value_6197 = el_6195;
														for (const a of $toIterator(value_6197)) result_6196.push(this.printTypeConverter(this.printExpression(a), this.getType(a), valueType));
														return result_6196;
													})().join(', ') + '}');
												}
											} break;
											
											default: 
											this.globalVariables.push(' = {0}')
											};
										};
									};
									this.globalVariables.push(';\n');
									defaults_6181 = false;
								}
							} break;
							};
						};
						if (defaults_6181) {
							this.globalVariables.push(this.stringifyType(type_6185, false));
							this.globalVariables.push(' ' + name_6183 + '_;\n');
							if (expr_6184 != null) { out.push('\t' + name_6183 + '_ = ' + this.printExpression(expr_6184) + ';\n') };
						};
					}
				} break;
				
				case 4: {
					const name_6198 = temp_6182[1];
					const expr_6199 = temp_6182[2];
					const type_6200 = temp_6182[3];
					{
						this.globalVariables.push(this.stringifyType(type_6200, false));
						this.globalVariables.push(' ' + name_6198 + '_;\n');
						if (expr_6199 != null) { out.push('\t' + name_6198 + '_ = ' + this.printExpression(expr_6199) + ';\n') };
					}
				} break;
				};
			};
		};
		if (this.project.init.length > 1) { throw 'project.init.length > 1' };
		const init_6201 = this.printStatement(this.project.init[0]);
		const strings = ['\tString_$root_ = String_$new_();\n'];
		{
			let id = 0;
			let it_6202 = 0;
			let at_6203 = this.declarationsOfStrings.length;
			while (it_6202 < at_6203) {
				id = it_6202;
				it_6202++;
				{
					strings.push(('\tString_' + (id) + ' = String_$fromUTF16z_((const uint16_t*)String_' + (id) + '_);\n'));
					forward.push(('String_* String_' + (id) + '; static const wchar_t *String_' + (id) + '_ = L\"' + (this.declarationsOfStrings[id]) + '\";'));
				};
			};
		};
		out.push('\t');
		out.push(init_6201);
		this.popTab();
		out.push('\tfflush(stdout);\n');
		out.push('\treturn 0;\n}\n');
		out.push('#ifdef __cplusplus\n');
		out.push('}\n');
		out.push('#endif\n');
		if (this.dllExports.length > 0) { Fs.writeFileSync(target_6064 + '.dllExport.txt', this.dllExports.join(' ')) };
		return (header.join('\n') + '\n// Forward\n' + forward.join('\n') + '\n// Typedef functions\n' + this.typedefFunctions.join('') + '\n// Forward functions\n' + this.forwardFunctions.join('') + '\n// Types\n' + this.types.join('') + '\n// Global variables\n' + this.globalVariables.join('') + '\n// Global functions\n' + this.globalFunctions.join('') + '\n// Defaults\n' + Fs.readFileSync(__dirname + '/library/c/hexa.c').toString('utf8', 0, 1073741824).split('\r\n').join('\n') + '// Statements\n' + out.join('').split('%%%HEXA_STRINGS@@@').join(strings.join(''))).split('\n').join('\r\n');
	};
		pushTab() { this.tabs += '\t' };
		popTab() { this.tabs = this.tabs.substring(0, this.tabs.length - 1) };
		printBlock(s) {
		const temp_6237 = s;
		switch (temp_6237&&temp_6237[0]) {
		case 1: {
			const el_6238 = temp_6237[1];
			return this.printStatement(s)
		} break;
		
		default: 
		return this.printStatement(/*Block*/[1,[s],".Block"])
		};
	};
		printStatement(s_6240) {
		this.last = (() => {
			const result_6241 = s_6240;
			if (result_6241 != null) { return result_6241 };
			return this.last;
		})();
		{
			const temp_6242 = s_6240;
			switch (temp_6242&&temp_6242[0]) {
			case 0: {
				const els = temp_6242[1];
				{
					let r = '';
					for (const s of $toIterator(els)) {
						if (s != null) { r += '\n' + this.tabs + this.printStatement(s) + ';' };
					};
					return r;
				}
			} break;
			
			case 18: {
				return 'break'
			} break;
			
			case 17: {
				return 'continue'
			} break;
			
			case 1: {
				const el_6243 = temp_6242[1];
				{
					if (el_6243.length == 0) { return '{}' };
					this.pushTab();
					const printMetaBlock = (e) => {
						const meta = this.metaBlock;
						this.metaBlock = [];
						const ss = this.printStatement(e);
						const r_6244 = [];
						for (const line of $toIterator(this.metaBlock)) {
							r_6244.push(line);
						};
						r_6244.push(ss);
						this.metaBlock = meta;
						return r_6244.join(';\n' + this.tabs);
					};
					let r_6245 = '{';
					for (const e of $toIterator(el_6243)) {
						const temp_6246 = e;
						switch (temp_6246&&temp_6246[0]) {
						case null: case undefined: {
							{
							}
						} break;
						
						case 0: {
							const els_6247 = temp_6246[1];
							for (const s of $toIterator(els_6247)) {
								if (s != null) { r_6245 += '\n' + this.tabs + printMetaBlock(s) + ';' };
							}
						} break;
						
						default: 
						r_6245 += '\n' + this.tabs + printMetaBlock(e) + ';'
						};
					};
					this.popTab();
					return r_6245 + '\n' + this.tabs + '}';
				}
			} break;
			
			case 4: {
				const name_6248 = temp_6242[1];
				const expr_6249 = temp_6242[2];
				const type_6250 = temp_6242[3];
				return this.printStatement(/*Var*/[3,name_6248,expr_6249,type_6250,".Var"])
			} break;
			
			case 3: {
				const name_6251 = temp_6242[1];
				const expr_6252 = temp_6242[2];
				const type_6253 = temp_6242[3];
				{
					{
						const temp_6254 = type_6253;
						switch (temp_6254&&temp_6254[0]) {
						case 6: {
							const typeClass = temp_6254[1];
							const generics_6255 = temp_6254[2];
							{
								let arraySize_6256 = '';
								let arrayLength = 2147483647;
								if (typeClass.name == 'ArrayByValue') {
									{
										let step_6257 = 0;
										const count_6258 = generics_6255[1];
										if (step_6257 == 0 && count_6258 != null) { step_6257 = 1 };
										if (step_6257 == 1) {
											arraySize_6256 = '[' + Type.stringify(count_6258) + ']';
											{
												const temp_6259 = count_6258;
												switch (temp_6259&&temp_6259[0]) {
												case 0: {
													const value_6260 = temp_6259[1];
													arrayLength = parseInt(value_6260, null)
												} break;
												};
											};
										} else {
											arraySize_6256 = '[]';
										};
									};
									{
										const temp_6261 = expr_6252;
										switch (temp_6261&&temp_6261[0]) {
										case 17: {
											const el_6262 = temp_6261[1];
											{
												const valueType_6263 = generics_6255[0];
												return this.stringifyType(valueType_6263, false) + ' ' + name_6251 + '_' + arraySize_6256 + ' = {' + (() => {
													const result_6264 = [];
													const value_6265 = el_6262;
													for (const a of $toIterator(value_6265)) result_6264.push(this.printTypeConverter(this.printExpression(a), this.getType(a), valueType_6263));
													return result_6264;
												})().join(', ') + '}';
											}
										} break;
										
										case 0: {
											const string = temp_6261[1];
											{
												if (arrayLength <= string.length) { throw ('String initializer is of length `' + (string.length + 1) + '` including null terminator') };
												const valueType_6266 = generics_6255[0];
												if (generics_6255[0] == this.project.typer.typeUInt8) { return this.stringifyType(valueType_6266, false) + ' ' + name_6251 + '_' + arraySize_6256 + ' = "' + string + '"' };
												throw 'String initializer is incompatible';
											}
										} break;
										
										case null: case undefined: {
											throw 'Array initializer required ' + name_6251
										} break;
										};
									};
								} else if (typeClass.name == 'ByValue') {
									const temp_6267 = expr_6252;
									switch (temp_6267&&temp_6267[0]) {
									case null: case undefined: {
										{
										}
									} break;
									
									case 11: {
										const e_6268 = temp_6267[1];
										const args_6269 = temp_6267[2];
										const result_6270 = temp_6267[3];
										return this.stringifyType(type_6253, false) + ' ' + name_6251 + '_; '
									} break;
									};
								};
							}
						} break;
						};
					};
					return this.stringifyType(type_6253, false) + ' ' + name_6251 + '_' + (((expr_6252 == null)? ('') : ' = ' + this.printTypeConverter(this.printExpression(expr_6252), this.getType(expr_6252), type_6253)));
				}
			} break;
			
			case 5: {
				const name_6271 = temp_6242[1];
				const expr_6272 = temp_6242[2];
				const args_6273 = temp_6242[3];
				const defaults_6274 = temp_6242[4];
				const funcType_6275 = temp_6242[5];
				{
					const _currentReturnType_6276 = this.currentReturnType;
					this.currentReturnType = this.getFunctionReturnType(funcType_6275);
					const temp_6277 = (this.tempId++);
					const rt = this.printFunctionReturnType(funcType_6275);
					this.forwardFunctions.push(rt);
					this.forwardFunctions.push((' _$' + (temp_6277) + ''));
					this.forwardFunctions.push(this.printFunctionArguments(args_6273, funcType_6275, 10));
					this.forwardFunctions.push(';\n');
					const tab = this.tabs;
					this.tabs = '';
					this.globalFunctions.push(rt);
					this.globalFunctions.push((' _$' + (temp_6277) + ''));
					this.globalFunctions.push(this.printFunctionArguments(args_6273, funcType_6275, 10));
					this.globalFunctions.push(' ');
					this.globalFunctions.push(this.printBlock(expr_6272));
					this.tabs = tab;
					this.currentReturnType = _currentReturnType_6276;
					return this.stringifyType(funcType_6275, false) + (' ' + (name_6271) + '_ = _$' + (temp_6277) + '');
				}
			} break;
			
			case 6: {
				const e_6278 = temp_6242[1];
				{
					if (e_6278 == null) { return 'return' };
					return 'return ' + this.printTypeConverter(this.printExpression(e_6278), this.getType(e_6278), this.currentReturnType);
				}
			} break;
			
			case 7: {
				const econd = temp_6242[1];
				const eif = temp_6242[2];
				const eelse = temp_6242[3];
				{
					let r_6279 = ('\n' + (this.tabs) + 'if (') + this.printExpression(econd) + ') ' + this.printBlock(eif);
					if (eelse != null) { r_6279 += ' else ' + this.printStatement(eelse) };
					return r_6279;
				}
			} break;
			
			case 2: {
				const e_6280 = temp_6242[1];
				const args_6281 = temp_6242[2];
				const expects = temp_6242[3];
				const kind = temp_6242[4];
				{
					{
						const temp_6282 = kind;
						switch (temp_6282) {
						case 12: {
							{
								const temp_6283 = e_6280;
								switch (temp_6283&&temp_6283[0]) {
								case 9: {
									const expr_6284 = temp_6283[1];
									const name_6285 = temp_6283[2];
									const result_6286 = temp_6283[3];
									{
										const temp_6287 = (this.tempId++);
										const exprType = this.getType(expr_6284);
										const typeString = this.stringifyType(exprType, false);
										const meta_6288 = typeString + (' _$' + (temp_6287) + ' = ') + this.printExpression(expr_6284);
										let isStruct_6289 = false;
										{
											const temp_6290 = exprType;
											switch (temp_6290&&temp_6290[0]) {
											case 6: {
												const type_6291 = temp_6290[1];
												const params = temp_6290[2];
												{
													const atts_6292 = this.project.mapDecorators.get(type_6291.parent);
													isStruct_6289 = Decorator.getDecorator(atts_6292, 'struct') != null;
												}
											} break;
											};
										};
										this.metaBlock.push(typeString + (' _$' + (temp_6287) + ' = ') + this.printExpression(expr_6284));
										if (isStruct_6289) { return this.omitPointer(typeString) + '$' + name_6285 + '_' + this.printCallArgumentsVirtual(('_$' + (temp_6287) + ''), args_6281, expects) };
										return ('_$' + (temp_6287) + '->_->') + name_6285 + '_' + this.printCallArgumentsVirtual(('_$' + (temp_6287) + ''), args_6281, expects);
									}
								} break;
								};
							}
						} break;
						};
					};
					return this.printExpression(e_6280) + this.printCallArguments(args_6281, expects);
				}
			} break;
			
			case 8: {
				const expr_6293 = temp_6242[1];
				const t_6294 = temp_6242[2];
				const v = temp_6242[3];
				const catches = temp_6242[4];
				{
					this.pushTab();
					let r_6295 = '_try {\n' + this.tabs;
					r_6295 += 'struct Any_* $try = (struct Any_*)0;' + '\n' + this.tabs;
					r_6295 += this.printStatement(expr_6293);
					this.popTab();
					r_6295 += '\n' + this.tabs + '$catch: ; } _catch(' + this.printType(t_6294[0]) + ' _x' + v[0] + ') {\n' + this.tabs + ' ';
					this.pushTab();
					r_6295 += this.printStatement(catches[0]);
					this.popTab();
					return r_6295 + '\n' + this.tabs + '}';
				}
			} break;
			
			case 10: {
				const a = temp_6242[1];
				const v_6296 = temp_6242[2];
				{
					{
						const temp_6297 = a;
						switch (temp_6297&&temp_6297[0]) {
						case 9: {
							const expr_6298 = temp_6297[1];
							const name_6299 = temp_6297[2];
							{
								const type_6300 = this.getType(expr_6298);
								if ((type_6300 == this.project.typer.typeAny) || (type_6300 == null)) {
									{
										const temp_6301 = expr_6298;
										switch (temp_6301&&temp_6301[0]) {
										case 6: {
											const named = temp_6301[1];
											if (DataHelper.isTitleCase(named)) { return this.printExpression(expr_6298) + '$' + name_6299 + '_ = ' + this.printInitializer(this.getType(a), v_6296) }
										} break;
										};
									};
									return this.printExpression(expr_6298) + '->$set(String_$fromUTF16z_(L"' + name_6299 + '"), ' + this.printToAnyConverter(this.printExpression(v_6296), this.getType(v_6296)) + ')';
								};
							}
						} break;
						
						case 22: {
							const expr_6302 = temp_6297[1];
							const index = temp_6297[2];
							{
								const temp_6303 = this.getType(expr_6302);
								switch (temp_6303&&temp_6303[0]) {
								case 6: {
									const type_6304 = temp_6303[1];
									const generic = temp_6303[2];
									{
										if (type_6304.name != 'Array') { return this.printExpression(expr_6302) + '[' + this.printTypeConverter(this.printExpression(index), this.getType(index), this.project.typer.typeInt) + ']' + ' = ' + this.printExpression(v_6296) };
										return this.printExpression(/*Call*/[10,/*Dot*/[9,expr_6302,'set',null,".Dot"],[index, v_6296],this.project.typer.typeVoid,12,".Call"]);
									}
								} break;
								};
							}
						} break;
						};
					};
					return this.printExpression(a) + ' = ' + this.printInitializer(this.getType(a), v_6296);
				}
			} break;
			
			case 9: {
				const e_6305 = temp_6242[1];
				return '_throw(' + this.printExpression(e_6305) + ')'
			} break;
			
			case 12: {
				const name_6306 = temp_6242[1];
				const over = temp_6242[2];
				const by = temp_6242[3];
				return 'for (FIXME TODO struct Any_* ' + name_6306 + '_; ' + this.printExpression(over) + ';) ' + this.printStatement(by)
			} break;
			
			case 14: {
				const e_6307 = temp_6242[1];
				return this.printExpression(e_6307) + '++'
			} break;
			
			case 15: {
				const e_6308 = temp_6242[1];
				return this.printExpression(e_6308) + '--'
			} break;
			
			case 13: {
				const econd_6309 = temp_6242[1];
				const e_6310 = temp_6242[2];
				const pre = temp_6242[3];
				{
					if (pre) { return ('\n' + (this.tabs) + 'while (') + this.printExpression(econd_6309) + ') ' + this.printStatement(e_6310) };
					return ('\n' + (this.tabs) + 'do {') + this.printStatement(e_6310) + '} while (' + this.printExpression(econd_6309) + ')';
				}
			} break;
			
			case 11: {
				const a_6311 = temp_6242[1];
				const op = temp_6242[2];
				const value_6312 = temp_6242[3];
				{
					if ((this.getType(a_6311) == this.project.typer.typeString) && (op == 111)) {
						{
							const temp_6313 = a_6311;
							switch (temp_6313&&temp_6313[0]) {
							case 22: {
								const expr_6314 = temp_6313[1];
								const index_6315 = temp_6313[2];
								{
									const tempIndex = (this.tempId++);
									{
										const indexType = this.getType(index_6315);
										const indexString = this.stringifyType(indexType, false);
										const metaIndex = indexString + (' _$' + (tempIndex) + ' = ') + this.printExpression(index_6315);
										this.metaBlock.push(metaIndex);
									};
									const tempStorage = (this.tempId++);
									{
										const indexType_6316 = this.getType(expr_6314);
										const indexString_6317 = this.stringifyType(indexType_6316, false);
										const metaIndex_6318 = indexString_6317 + (' _$' + (tempStorage) + ' = ') + this.printExpression(expr_6314);
										this.metaBlock.push(metaIndex_6318);
									};
									return ('_$' + (tempStorage) + '->_->set_(_$' + (tempStorage) + ', _$' + (tempIndex) + ', String_$combine_(_$' + (tempStorage) + '->_->get_(_$' + (tempStorage) + ', _$' + (tempIndex) + '), ') + this.printTypeConverter(this.printExpression(value_6312), this.getType(value_6312), this.project.typer.typeString) + '))';
								}
							} break;
							};
						};
						return this.printExpression(a_6311) + ' = String_$combine_(' + this.printExpression(a_6311) + ', ' + this.printTypeConverter(this.printExpression(value_6312), this.getType(value_6312), this.project.typer.typeString) + ')';
					};
					return this.printExpression(a_6311) + ' ' + Token.stringify(op) + '= ' + this.printExpression(value_6312);
				}
			} break;
			
			case 16: {
				const expr_6319 = temp_6242[1];
				const cases = temp_6242[2];
				const statements = temp_6242[3];
				{
					const value_6320 = this.printExpression(expr_6319);
					const valueType_6321 = this.stringifyType(this.getType(expr_6319), false);
					let r_6322 = ('{ ' + (valueType_6321) + ' switch_ = ') + value_6320 + ';';
					let else_ = false;
					{
						let i_6323 = 0;
						let it_6324 = 0;
						let at_6325 = cases.length;
						while (it_6324 < at_6325) {
							i_6323 = it_6324;
							it_6324++;
							{
								if (cases[i_6323].length > 1) {
									if (else_) { r_6322 += ' else' };
									r_6322 += '\n' + this.tabs + 'if ((';
									const conds = [];
									for (const cc of $toIterator(cases[i_6323])) {
										const temp_6326 = cc;
										switch (temp_6326&&temp_6326[0]) {
										case 7: {
											conds.push('switch_ == -1')
										} break;
										
										default: 
										conds.push('switch_ == ' + this.printExpression(cc))
										};
									};
									r_6322 += conds.join(') || (') + ')) ';
									this.pushTab();
									r_6322 += this.printBlock(statements[i_6323]);
									this.popTab();
									else_ = true;
								} else {
									let step_6327 = 0;
									const cc = cases[i_6323][0];
									if (step_6327 == 0 && cc != null) { step_6327 = 1 };
									if (step_6327 == 1) {
										if (else_) { r_6322 += ' else' };
										r_6322 += '\n' + this.tabs + 'if (';
										{
											const temp_6328 = cc;
											switch (temp_6328&&temp_6328[0]) {
											case 7: {
												r_6322 += 'switch_ == -1) '
											} break;
											
											default: 
											r_6322 += 'switch_ == ' + this.printExpression(cc) + ') '
											};
										};
										this.pushTab();
										r_6322 += this.printBlock(statements[i_6323]);
										this.popTab();
										else_ = true;
									};
								};
							};
						};
					};
					{
						let i_6329 = 0;
						let it_6330 = 0;
						let at_6331 = cases.length;
						while (it_6330 < at_6331) {
							i_6329 = it_6330;
							it_6330++;
							{
								if (cases[i_6329].length == 0) {
									if (else_) { r_6322 += ' else' };
									r_6322 += '\n' + this.tabs;
									r_6322 += this.printBlock(statements[i_6329]);
								};
							};
						};
					};
					r_6322 += ';\n' + this.tabs;
					return r_6322 + '}';
				}
			} break;
			
			default: 
			{
				console.error('Unknown statement kind (GenCxx):', s_6240);
				console.trace('Here I am!');
			}
			};
		};
	};
		printCallArguments(args_6339, expects_6340) {
		{
			let step_6341 = 0;
			const exp = expects_6340;
			if (step_6341 == 0 && exp != null) { step_6341 = 1 };
			if (step_6341 == 1) { return '(' + (() => {
				const result_6342 = [];
				const value_6343 = args_6339.length;
				for (const i of $toIterator(value_6343)) result_6342.push(this.printTypeConverter(this.printExpression(args_6339[i]), this.getType(args_6339[i]), exp[i]));
				return result_6342;
			})().join(', ') + ')' };
		};
		return '(' + (() => {
			const result_6344 = [];
			const value_6345 = args_6339;
			for (const a of $toIterator(value_6345)) result_6344.push(this.printExpression(a));
			return result_6344;
		})().join(', ') + ')';
	};
		printCallArgumentsVirtual(me, args_6346, expects_6347) {
		if (args_6346.length == 0) { return '(' + me + ')' };
		{
			let step_6348 = 0;
			const exp_6349 = expects_6347;
			if (step_6348 == 0 && exp_6349 != null) { step_6348 = 1 };
			if (step_6348 == 1) { return '(' + me + ', ' + (() => {
				const result_6350 = [];
				const value_6351 = args_6346.length;
				for (const i of $toIterator(value_6351)) result_6350.push(this.printTypeConverter(this.printExpression(args_6346[i]), this.getType(args_6346[i]), exp_6349[i]));
				return result_6350;
			})().join(', ') + ')' };
		};
		return '(' + me + ', ' + (() => {
			const result_6352 = [];
			const value_6353 = args_6346;
			for (const a of $toIterator(value_6353)) result_6352.push(this.printExpression(a));
			return result_6352;
		})().join(', ') + ')';
	};
		getFunctionReturnType(funcType_6354) {
		const temp_6355 = funcType_6354;
		switch (temp_6355&&temp_6355[0]) {
		case 12: {
			const args_6356 = temp_6355[1];
			const returns_6357 = temp_6355[2];
			return returns_6357
		} break;
		
		default: 
		return null
		};
	};
		printFunctionReturnType(funcType_6358) {
		const temp_6359 = funcType_6358;
		switch (temp_6359&&temp_6359[0]) {
		case 12: {
			const args_6360 = temp_6359[1];
			const returns_6361 = temp_6359[2];
			return this.stringifyType(returns_6361, false)
		} break;
		
		default: 
		return 'void'
		};
	};
		printToAnyConverter(string_6362, type_6363) {
		if (type_6363 == this.project.typer.typeAny) { return string_6362 };
		if (type_6363 == this.project.typer.typeBool) { return 'Any_fromBool(' + string_6362 + ')' };
		if (type_6363 == this.project.typer.typeInt) { return 'Any_fromInt(' + string_6362 + ')' };
		return '(struct Any_*)(' + string_6362 + ')';
	};
		printValueToNullableConverter(string_6364, fromValue, to) { return '%printValueToNullableConverter%' };
		printNullableToValueConverter(string_6365, fromValue_6366, to_6367) { return '%printNullableToValueConverter%' };
		printTypeConverter(string_6368, fromValue_6369, to_6370) {
		if (fromValue_6369 == to_6370) { return string_6368 };
		if ((fromValue_6369 == this.project.typer.typeUInt16) && (to_6370 == this.project.typer.typeInt)) { return '(int32_t/*!*/)(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeBool) && (to_6370 == this.project.typer.typeAny)) { return 'Any_fromBool(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeAny) && (to_6370 == this.project.typer.typeBool)) { return '(' + string_6368 + ')->_toBool()' };
		if ((fromValue_6369 == this.project.typer.typeAny) && (to_6370 == this.project.typer.typeInt)) { return '(' + string_6368 + ')->_toInt()' };
		if ((fromValue_6369 == this.project.typer.typeAny) && (to_6370 == this.project.typer.typeFloat)) { return '(' + string_6368 + ')->_toFloat()' };
		if ((fromValue_6369 == this.project.typer.typeInt) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromInt32_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeInt8) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromInt32_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeUInt8) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromInt32_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeInt16) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromInt32_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeUInt16) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromInt32_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeUInt32) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromUInt64_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeInt64) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromInt64_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeUInt64) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromUInt64_(' + string_6368 + ')' };
		if ((fromValue_6369 == this.project.typer.typeBool) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromBool_(' + string_6368 + ')' };
		if (fromValue_6369 == this.project.typer.typeString) {
			const temp_6371 = to_6370;
			switch (temp_6371&&temp_6371[0]) {
			case 6: {
				const type_6372 = temp_6371[1];
				if (type_6372.name == 'ConstCharPointer') {
					console.log(type_6372);
					return '(' + string_6368 + ')->bytes_';
				}
			} break;
			};
		};
		{
			const temp_6373 = fromValue_6369;
			switch (temp_6373&&temp_6373[0]) {
			case 4: {
				{
				}
			} break;
			
			case 3: {
				{
				}
			} break;
			
			default: 
			if (to_6370 == this.project.typer.typeString) {
				const type_6374 = this.omitPointer(this.stringifyType(fromValue_6369, false));
				if (type_6374 != 'Any_') { return type_6374 + '$toString_(' + string_6368 + ')' };
			}
			};
		};
		if (to_6370 == this.project.typer.typeAny) { return this.printToAnyConverter(string_6368, fromValue_6369) };
		if (fromValue_6369 != to_6370) {
			const temp_6375 = to_6370;
			switch (temp_6375&&temp_6375[0]) {
			case 4: {
				const toNull = temp_6375[1];
				{
					const temp_6376 = fromValue_6369;
					switch (temp_6376&&temp_6376[0]) {
					case 4: {
						const fromNull = temp_6376[1];
						{
							if (toNull == fromNull) { return string_6368 };
							if (to_6370 == this.project.typer.typeNullUInt64) { return 'toNull$UInt64((uint64_t)(' + string_6368 + '))' };
							return '(/*A? = B?*/' + this.stringifyType(to_6370, false) + ')(' + string_6368 + ')';
						}
					} break;
					
					default: 
					{
						if (toNull == fromValue_6369) {
							if (toNull == this.project.typer.typeInt) { return '((int32_t$)(' + string_6368 + '))' };
							if (toNull == this.project.typer.typeUInt64) { return '(Null$UInt64){' + string_6368 + ', 1}' };
							if (toNull == this.project.typer.typeInt64) { return '(Null$Int64){' + string_6368 + ', 1}' };
							if (toNull == this.project.typer.typeFloat) { return '(Null$Float){' + string_6368 + ', 1}' };
							if (toNull == this.project.typer.typeFloat32) { return '(Null$Float32){' + string_6368 + ', 1}' };
							return string_6368;
						};
						{
							const temp_6377 = fromValue_6369;
							switch (temp_6377&&temp_6377[0]) {
							case 3: {
								const value_6378 = temp_6377[1];
								if (value_6378.value == null) {
									if (toNull == this.project.typer.typeInt || toNull == this.project.typer.typeInt32) { return 'int32_t$null' };
									if (toNull == this.project.typer.typeUInt32) { return 'uint32_t$null' };
									if (toNull == this.project.typer.typeInt16) { return 'int16_t$null' };
									if (toNull == this.project.typer.typeUInt16) { return 'uint16_t$null' };
									if (toNull == this.project.typer.typeInt8) { return 'int8_t$null' };
									if (toNull == this.project.typer.typeUInt8) { return 'uint8_t$null' };
									if (toNull == this.project.typer.typeUInt64) { return '(Null$UInt64){0, 0}' };
									if (toNull == this.project.typer.typeInt64) { return '(Null$Int64){0, 0}' };
									if (toNull == this.project.typer.typeFloat) { return '(Null$Float64){0.0, 0}' };
									if (toNull == this.project.typer.typeFloat32) { return '(Null$Float32){0.0f, 0}' };
									if (toNull == this.project.typer.typeBool) { return '(uint8_t)2' };
									{
										const temp_6379 = toNull;
										switch (temp_6379&&temp_6379[0]) {
										case 6: {
											const type_6380 = temp_6379[1];
											if (type_6380.name == 'ClangWideChar') { return '(wchar_t)0' }
										} break;
										};
									};
									if (toNull == null) { return string_6368 };
									return '/*%T? = null%*/(' + string_6368 + ')';
								}
							} break;
							};
						};
						return '(/*A? = B*/' + this.stringifyType(to_6370, false) + ')(' + string_6368 + ')';
					}
					};
				}
			} break;
			
			default: 
			{
				const temp_6381 = fromValue_6369;
				switch (temp_6381&&temp_6381[0]) {
				case 4: {
					const fromNull_6382 = temp_6381[1];
					{
						if (to_6370 == fromNull_6382) {
							if (fromNull_6382 == this.project.typer.typeInt) { return '(int32_t)(' + string_6368 + ')' };
							if ((fromValue_6369 == this.project.typer.typeNullUInt64 && to_6370 == this.project.typer.typeUInt64) || (fromValue_6369 == this.project.typer.typeNullFloat && to_6370 == this.project.typer.typeFloat) || (fromValue_6369 == this.project.typer.typeNullFloat32 && to_6370 == this.project.typer.typeFloat32)) { return string_6368 + '.value_' };
							return string_6368 + '/*T = T?*/';
						};
						if ((fromNull_6382 == this.project.typer.typeInt) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromNullableInt32_(' + string_6368 + ')' };
						if ((fromNull_6382 == this.project.typer.typeBool) && (to_6370 == this.project.typer.typeString)) { return 'String_$fromBool_(' + string_6368 + ')' };
						return ('(/*A = B? ' + (this.stringifyType(fromNull_6382, false)) + ' */') + this.stringifyType(to_6370, false) + ')(' + string_6368 + ')';
					}
				} break;
				
				default: 
				{
					if (to_6370 == fromValue_6369) { return string_6368 };
					{
						const temp_6383 = fromValue_6369;
						switch (temp_6383&&temp_6383[0]) {
						case 3: {
							const value_6384 = temp_6383[1];
							if (value_6384.value == null) {
								if (to_6370 == this.project.typer.typeInt || to_6370 == this.project.typer.typeInt32) { return 'int32_t$null' };
								if (to_6370 == this.project.typer.typeUInt32) { return 'uint32_t$null' };
								if (to_6370 == this.project.typer.typeInt16) { return 'int16_t$null' };
								if (to_6370 == this.project.typer.typeUInt16) { return 'uint16_t$null' };
								if (to_6370 == this.project.typer.typeInt8) { return 'int8_t$null' };
								if (to_6370 == this.project.typer.typeUInt8) { return 'uint8_t$null' };
								if (to_6370 == this.project.typer.typeInt) { return '(int32_t)0' };
								if (to_6370 == null) { return string_6368 };
								return '(/*T = null*/' + this.stringifyType(to_6370, false) + ')(' + string_6368 + ')';
							}
						} break;
						};
					};
					const tot = JSON.stringify('' + to_6370);
					if (to_6370 == null) { return string_6368 };
					let fromStructByValue = false;
					let fromBasicType = false;
					{
						const temp_6385 = fromValue_6369;
						switch (temp_6385&&temp_6385[0]) {
						case 6: {
							const type_6386 = temp_6385[1];
							{
								const atts_6387 = this.project.mapDecorators.get(type_6386.parent);
								fromBasicType = Decorator.getDecorator(atts_6387, 'nativeBasicType') != null;
								fromStructByValue = Decorator.getDecorator(atts_6387, 'byValue') != null;
								fromStructByValue = fromStructByValue || type_6386.name == 'ByValue';
							}
						} break;
						};
					};
					let toStructByPointer = false;
					let toStructByValue = false;
					{
						const temp_6388 = to_6370;
						switch (temp_6388&&temp_6388[0]) {
						case 6: {
							const type_6389 = temp_6388[1];
							{
								const atts_6390 = this.project.mapDecorators.get(type_6389.parent);
								toStructByPointer = Decorator.getDecorator(atts_6390, 'struct') != null;
								toStructByValue = Decorator.getDecorator(atts_6390, 'byValue') != null;
								toStructByValue = toStructByValue || type_6389.name == 'ByValue';
							}
						} break;
						};
					};
					if ((fromStructByValue && toStructByPointer) && ((!fromBasicType))) { return '(/*struct to pointer*/' + this.stringifyType(to_6370, false) + ')&(' + string_6368 + ')' };
					if (fromStructByValue && toStructByValue) { return '*((/*struct to struct*/' + this.omitPointer(this.stringifyType(to_6370, false)) + '*)&(' + string_6368 + '))' };
					return '(' + this.stringifyType(to_6370, false) + ')(' + string_6368 + ')';
				}
				};
			}
			};
		};
		return string_6368 + '/*TO*/';
	};
		printFunctionArguments(args_6391, funcType_6392, variadic_6393) {
		if ((args_6391.length == 0) && (this.thisArgument != null)) { return '(' + this.thisArgument + ')' };
		if (args_6391.length == 0) { return '(void)' };
		{
			const temp_6394 = funcType_6392;
			switch (temp_6394&&temp_6394[0]) {
			case 12: {
				const types_6395 = temp_6394[1];
				{
					const results = [];
					{
						let step_6396 = 0;
						const thisArgument = this.thisArgument;
						if (step_6396 == 0 && thisArgument != null) { step_6396 = 1 };
						if (step_6396 == 1) { results.push(thisArgument) };
					};
					{
						let a_6397 = 0;
						let it_6398 = 0;
						let at_6399 = args_6391.length;
						while (it_6398 < at_6399) {
							a_6397 = it_6398;
							it_6398++;
							{
								const result_6400 = this.stringifyType(types_6395[a_6397].type, false) + ' ' + args_6391[a_6397] + '_';
								results.push(result_6400);
							};
						};
					};
					if (variadic_6393 == 11) {
						results.pop();
						results.push('...');
					};
					return '(' + results.join(', ') + ')';
				}
			} break;
			};
		};
		return '(' + (() => {
			const result_6401 = [];
			const value_6402 = args_6391.length;
			for (const a of $toIterator(value_6402)) result_6401.push('Any_* ' + args_6391[a] + '_');
			return result_6401;
		})().join(', ') + ')';
	};
		stringType(t_6403, prefix) {
		if (t_6403 == null) { return 'void*' };
		{
			const temp_6404 = t_6403;
			switch (temp_6404&&temp_6404[0]) {
			case 2: {
				const name_6405 = temp_6404[1];
				const params_6406 = temp_6404[2];
				return '_x' + name_6405
			} break;
			
			case 1: {
				const name_6407 = temp_6404[1];
				return '_x' + name_6407
			} break;
			
			case 5: {
				{
				}
			} break;
			
			case 0: {
				const t_6408 = temp_6404[1];
				return this.stringType(t_6408, '')
			} break;
			};
		};
		return prefix + 'void*';
	};
		printType(t_6409) {
		const type_6410 = this.stringType(t_6409, '');
		return type_6410;
	};
		stringifyType(t_6411, prefixNull) {
		const temp_6412 = t_6411;
		switch (temp_6412&&temp_6412[0]) {
		case 1: {
			const index_6413 = temp_6412[1];
			const name_6414 = temp_6412[2];
			return 'Any_*'
		} break;
		
		case 4: {
			const t_6415 = temp_6412[1];
			{
				const name_6416 = this.stringifyType(t_6415, false);
				if (name_6416 == 'int32_t') { return 'int32_t$' };
				if (name_6416 == 'int16_t') { return 'int16_t$' };
				if (name_6416 == 'int8_t') { return 'int8_t$' };
				if (name_6416 == 'Bool') { return 'Bool_' };
				if (name_6416 == 'double') { return 'Null$Float64' };
				if (name_6416 == 'float') { return 'Null$Float32' };
				if (name_6416 == 'uint64_t') { return 'Null$UInt64' };
				if (name_6416 == 'int64_t') { return 'Null$Int64' };
				if (prefixNull == true) { return 'Null$' + name_6416 };
				return name_6416;
			}
		} break;
		
		case 2: {
			const handle = temp_6412[1];
			return this.stringifyType(handle.value, prefixNull)
		} break;
		
		case 3: {
			const handle_6417 = temp_6412[1];
			return this.stringifyType(handle_6417.value, prefixNull)
		} break;
		
		case 6: {
			const type_6418 = temp_6412[1];
			const generics_6419 = temp_6412[2];
			{
				if (type_6418.name == 'ByValue') { return this.omitPointer(this.stringifyType(generics_6419[0], prefixNull)) };
				if (type_6418.name == 'Int') { return 'int32_t' };
				if (type_6418.name == 'Int8') { return 'int8_t' };
				if (type_6418.name == 'Int16') { return 'int16_t' };
				if (type_6418.name == 'Int32') { return 'int32_t' };
				if (type_6418.name == 'Int64') { return 'int64_t' };
				if (type_6418.name == 'UInt8') { return 'uint8_t' };
				if (type_6418.name == 'UInt16') { return 'uint16_t' };
				if (type_6418.name == 'UInt32') { return 'uint32_t' };
				if (type_6418.name == 'UInt64') { return 'uint64_t' };
				if (type_6418.name == 'ArrayByValue') { return this.stringifyType(generics_6419[0], false) + '[' + this.stringifyType(generics_6419[1], false) + ']' };
				const atts_6420 = this.project.mapDecorators.get(type_6418.parent);
				let renamed_6421 = '';
				{
					let step_6422 = 0;
					const rename_6423 = Decorator.getDecorator(atts_6420, 'rename');
					if (step_6422 == 0 && rename_6423 != null) { step_6422 = 1 };
					if (step_6422 == 1) { renamed_6421 = DataHelper.asStringAttValue(rename_6423, 0) };
				};
				{
					let step_6424 = 0;
					const generic_6425 = generics_6419;
					let temp_6426 = null;
					if (step_6424 == 0 && generic_6425 != null) {
						temp_6426 = renamed_6421 == 'ConstArrayPointer';
						step_6424 = 1;
					};
					if (step_6424 == 1 && temp_6426 != false) { step_6424 = 2 };
					if (step_6424 == 2) { return 'const ' + this.stringifyType(generic_6425[0], false) + '*' };
				};
				{
					let step_6427 = 0;
					const generic_6428 = generics_6419;
					let temp_6429 = null;
					if (step_6427 == 0 && generic_6428 != null) {
						temp_6429 = renamed_6421 == 'ArrayPointer';
						step_6427 = 1;
					};
					if (step_6427 == 1 && temp_6429 != false) { step_6427 = 2 };
					if (step_6427 == 2) { return this.stringifyType(generic_6428[0], false) + '*' };
				};
				{
					let step_6430 = 0;
					const generic_6431 = generics_6419;
					let temp_6432 = null;
					if (step_6430 == 0 && generic_6431 != null) {
						temp_6432 = renamed_6421 == 'ArrayByValue';
						step_6430 = 1;
					};
					if (step_6430 == 1 && temp_6432 != false) { step_6430 = 2 };
					if (step_6430 == 2) { return this.stringifyType(generic_6431[0], false) };
				};
				if (type_6418.name == 'Bool') { return 'Bool_' };
				if (type_6418.name == 'Bool32') { return 'int32_t' };
				if (type_6418.name == 'Bool8') { return 'uint8_t' };
				if (type_6418.name == 'Void') { return 'void' };
				if (type_6418.name == 'Float') { return 'double' };
				const atts_6433 = this.project.mapDecorators.get(type_6418.parent);
				const struct = Decorator.getDecorator(atts_6433, 'struct') != null;
				const byValue = Decorator.getDecorator(atts_6433, 'byValue') != null;
				if (byValue && (!struct)) { throw 'Must be @struct to be @byValue' };
				const native = Decorator.getDecorator(atts_6433, 'rename');
				{
					let step_6434 = 0;
					const native_6435 = native;
					if (step_6434 == 0 && native_6435 != null) { step_6434 = 1 };
					if (step_6434 == 1) {
						const temp_6436 = (native_6435.values[0]);
						switch (temp_6436&&temp_6436[0]) {
						case 0: {
							const s_6437 = temp_6436[1];
							{
								if (struct && byValue) { return s_6437 };
								if (struct) { return s_6437 + '*' };
								return s_6437;
							}
						} break;
						};
					};
				};
				{
					let step_6438 = 0;
					const generic_6439 = generics_6419;
					let temp_6440 = null;
					if (step_6438 == 0 && generic_6439 != null) {
						temp_6440 = generic_6439.length > 0;
						step_6438 = 1;
					};
					if (step_6438 == 1 && temp_6440 != false) { step_6438 = 2 };
					if (step_6438 == 2) {
						let name_6441 = type_6418.name;
						{
							let step_6442 = 0;
							const instanceOf = type_6418.instanceOf;
							if (step_6442 == 0 && instanceOf != null) { step_6442 = 1 };
							if (step_6442 == 1) { name_6441 = instanceOf.name };
						};
						name_6441 += '_$' + (() => {
							const result_6443 = [];
							const value_6444 = generic_6439;
							for (const param of $toIterator(value_6444)) result_6443.push(this.omitPointer(this.stringifyType(param, true)));
							return result_6443;
						})().join('$');
						if (name_6441.endsWith('_')) { return name_6441 + '*' };
						return name_6441 + '_*';
					};
				};
				return type_6418.name + '_*';
			}
		} break;
		
		case 5: {
			const type_6445 = temp_6412[1];
			return type_6445.name + '_*'
		} break;
		
		case 8: {
			const type_6446 = temp_6412[1];
			{
				{
					let step_6447 = 0;
					const sub = type_6446.fieldsTypeSimple;
					if (step_6447 == 0 && sub != null) { step_6447 = 1 };
					if (step_6447 == 1) {
						const atts_6448 = this.project.mapDecorators.get(type_6446.parent);
						{
							let step_6449 = 0;
							const rename_6450 = Decorator.getDecorator(atts_6448, 'castTo');
							if (step_6449 == 0 && rename_6450 != null) { step_6449 = 1 };
							if (step_6449 == 1) { return DataHelper.asStringAttValue(rename_6450, 0) };
						};
						return this.stringifyType(sub, false);
					};
				};
				return type_6446.name + '_*';
			}
		} break;
		
		case 9: {
			const type_6451 = temp_6412[1];
			return this.stringifyType(/*Enum*/[8,type_6451,".Enum"], false)
		} break;
		
		case 13: {
			return 'Any_*/*Struct*/'
		} break;
		
		case 12: {
			const args_6452 = temp_6412[1];
			const returns_6453 = temp_6412[2];
			{
				const temp_6454 = (this.tempId++);
				this.typedefFunctions.push('typedef ');
				this.typedefFunctions.push(this.stringifyType(returns_6453, false));
				this.typedefFunctions.push(' (');
				this.typedefFunctions.push(this.defaultCallingConvention);
				this.typedefFunctions.push('*_$');
				this.typedefFunctions.push('' + temp_6454);
				this.typedefFunctions.push(')(');
				const a_6455 = [];
				for (const arg of $toIterator(args_6452)) {
					a_6455.push(this.stringifyType(arg.type, false));
				};
				this.typedefFunctions.push(a_6455.join(', '));
				this.typedefFunctions.push(');\n');
				return ('_$' + (temp_6454) + '');
			}
		} break;
		
		case 0: {
			const value_6456 = temp_6412[1];
			return value_6456
		} break;
		
		case null: case undefined: {
			return 'Any_*'
		} break;
		
		default: 
		{
			console.log(t_6411);
			throw 'stringifyType ' + t_6411;
		}
		};
	};
		getType(e_6457) {
		const temp_6458 = e_6457;
		switch (temp_6458&&temp_6458[0]) {
		case 1: {
			return this.project.typer.typeInt
		} break;
		
		case 2: {
			const kind_6459 = temp_6458[2];
			{
				const temp_6460 = kind_6459;
				switch (temp_6460) {
				case 5: {
					return this.project.typer.typeInt8
				} break;
				
				case 4: {
					return this.project.typer.typeInt16
				} break;
				
				case 2: {
					return this.project.typer.typeInt32
				} break;
				
				case 3: {
					return this.project.typer.typeInt64
				} break;
				
				case 9: {
					return this.project.typer.typeUInt8
				} break;
				
				case 8: {
					return this.project.typer.typeUInt16
				} break;
				
				case 6: {
					return this.project.typer.typeUInt32
				} break;
				
				case 7: {
					return this.project.typer.typeUInt64
				} break;
				};
			}
		} break;
		
		case 3: {
			return this.project.typer.typeFloat
		} break;
		
		case 0: {
			return this.project.typer.typeString
		} break;
		
		case 4: {
			return this.project.typer.typeBool
		} break;
		
		case 5: {
			return this.project.typer.typeBool
		} break;
		
		case 6: {
			const type_6461 = temp_6458[2];
			return type_6461
		} break;
		
		case 15: {
			const expr_6462 = temp_6458[1];
			return this.getType(expr_6462)
		} break;
		
		case 10: {
			const type_6463 = temp_6458[3];
			return type_6463
		} break;
		
		case 12: {
			const type_6464 = temp_6458[4];
			return type_6464
		} break;
		
		case 26: {
			const type_6465 = temp_6458[5];
			return type_6465
		} break;
		
		case 9: {
			const type_6466 = temp_6458[3];
			return type_6466
		} break;
		
		case 8: {
			const type_6467 = temp_6458[1];
			return type_6467
		} break;
		
		case 7: {
			return /*UnknownNullable*/[3,{value:null},".UnknownNullable"]
		} break;
		
		case 23: {
			const to_6468 = temp_6458[2];
			return to_6468
		} break;
		
		case 22: {
			const result_6469 = temp_6458[3];
			return result_6469
		} break;
		
		case 11: {
			const result_6470 = temp_6458[3];
			return result_6470
		} break;
		
		case 17: {
			const result_6471 = temp_6458[2];
			return result_6471
		} break;
		
		case 18: {
			const keys = temp_6458[1];
			const values = temp_6458[2];
			const keyType = temp_6458[3];
			const valueType_6472 = temp_6458[4];
			const mapType = temp_6458[5];
			return mapType
		} break;
		
		case 19: {
			const op_6473 = temp_6458[1];
			const postfix = temp_6458[2];
			const e_6474 = temp_6458[3];
			return this.getType(e_6474)
		} break;
		
		case 21: {
			const econd_6475 = temp_6458[1];
			const eif_6476 = temp_6458[2];
			const eelse_6477 = temp_6458[3];
			return this.getType(eif_6476)
		} break;
		
		case 28: {
			const type_6478 = temp_6458[1];
			const tagName = temp_6458[2];
			const tag = temp_6458[3];
			const args_6479 = temp_6458[4];
			return this.project.typer.typeAny
		} break;
		
		case 27: {
			const expr_6480 = temp_6458[1];
			return this.project.typer.typeAny
		} break;
		
		case 13: {
			return this.project.typer.typeAny
		} break;
		
		case 14: {
			return this.project.typer.typeAny
		} break;
		
		case 16: {
			return this.project.typer.typeAny
		} break;
		
		default: 
		throw 'getType ' + e_6457
		};
	};
		omitPointer(type_6481) {
		if (type_6481.endsWith('*')) { return type_6481.substr(0, type_6481.length - 1) };
		return type_6481;
	};
		registerString(string_6482) {
		this.declarationsOfStrings.push(string_6482);
		return this.declarationsOfStrings.length - 1;
	};
		printInitializer(ofType, v_6483) {
		{
			const temp_6484 = ofType;
			switch (temp_6484&&temp_6484[0]) {
			case 6: {
				const c_6485 = temp_6484[1];
				if (c_6485.name == 'ArrayByValue') {
					const temp_6486 = v_6483;
					switch (temp_6486&&temp_6486[0]) {
					case 17: {
						const el_6487 = temp_6486[1];
						if (el_6487.length == 1) {
							{
								const temp_6488 = el_6487[0];
								switch (temp_6488&&temp_6488[0]) {
								case 1: {
									const val = temp_6488[1];
									if (val == 0) { return '{0}' }
								} break;
								};
							}
						break; } }
					};
				}
			} break;
			};
		};
		return this.printExpression(v_6483);
	};
		printExpression(e_6489) {
		const temp_6490 = e_6489;
		switch (temp_6490&&temp_6490[0]) {
		case 8: {
			return (() => {
				const result_6491 = this.customThis;
				if (result_6491 != null) { return result_6491 };
				return 'this';
			})()
		} break;
		
		case 6: {
			const name_6492 = temp_6490[1];
			{
				if (this.project.native.get(e_6489) == true) { return name_6492 };
				return '' + name_6492 + '_';
			}
		} break;
		
		case 7: {
			const type_6493 = temp_6490[1];
			{
				let type_6494 = type_6493;
				{
					const temp_6495 = type_6494;
					switch (temp_6495&&temp_6495[0]) {
					case 3: {
						const handle_6496 = temp_6495[1];
						{
							let step_6497 = 0;
							const of = handle_6496.value;
							if (step_6497 == 0 && of != null) { step_6497 = 1 };
							if (step_6497 == 1) { type_6494 = of };
						}
					} break;
					
					case 4: {
						const of_6498 = temp_6495[1];
						type_6494 = of_6498
					} break;
					};
				};
				if (type_6494 == this.project.typer.typeInt) { return 'int32_t$null' };
				if (type_6494 == this.project.typer.typeUInt32) { return 'uint32_t$null' };
				if (type_6494 == this.project.typer.typeInt16) { return 'int16_t$null' };
				if (type_6494 == this.project.typer.typeUInt16) { return 'uint16_t$null' };
				if (type_6494 == this.project.typer.typeInt8) { return 'int8_t$null' };
				if (type_6494 == this.project.typer.typeUInt8) { return 'uint8_t$null' };
				if (type_6494 == this.project.typer.typeBool) { return '(uint8_t)2' };
				return 'nullptr';
			}
		} break;
		
		case 1: {
			const v_6499 = temp_6490[1];
			return '(int32_t)' + v_6499
		} break;
		
		case 2: {
			const v_6500 = temp_6490[1];
			const meta_6501 = temp_6490[2];
			const type_6502 = temp_6490[3];
			{
				const temp_6503 = meta_6501;
				switch (temp_6503) {
				case 2: {
					return '(int32_t)' + v_6500
				} break;
				
				case 3: {
					return '(int64_t)' + v_6500
				} break;
				
				case 4: {
					return '(int16_t)' + v_6500
				} break;
				
				case 5: {
					return '(int8_t)' + v_6500
				} break;
				
				case 6: {
					return '(uint32_t)' + v_6500
				} break;
				
				case 7: {
					return '(uint64_t)' + v_6500
				} break;
				
				case 8: {
					return '(uint16_t)' + v_6500
				} break;
				
				case 9: {
					return '(uint8_t)' + v_6500
				} break;
				};
			}
		} break;
		
		case 3: {
			const v_6504 = temp_6490[1];
			{
				const v_6505 = '' + v_6504;
				if (v_6505.indexOf('.', 0) == (-1)) { return '(double)' + v_6505 + '.0' };
				return '(double)' + v_6505;
			}
		} break;
		
		case 0: {
			const string_6506 = temp_6490[1];
			{
				{
					let step_6507 = 0;
					const id_6508 = this.declarationsOfStringsMap.get(string_6506);
					if (step_6507 == 0 && id_6508 != null) { step_6507 = 1 };
					if (step_6507 == 1) { return ('String_' + (id_6508) + '') };
				};
				const s_6509 = string_6506.split('');
				const charsOut = [];
				while (s_6509.length > 0) {
					const temp_6510 = s_6509[0];
					switch (temp_6510) {
					case '\'': {
						{
							charsOut.push('\\\'');
							s_6509.shift();
						}
					} break;
					
					case '"': {
						{
							charsOut.push('\\"');
							s_6509.shift();
						}
					} break;
					
					case '\n': {
						{
							charsOut.push('\\n');
							s_6509.shift();
						}
					} break;
					
					case '\r': {
						{
							charsOut.push('\\r');
							s_6509.shift();
						}
					} break;
					
					case '\\': {
						{
							s_6509.shift();
							if (s_6509[0] == '\'') {
								charsOut.push('\\\'');
								s_6509.shift();
							} else if (s_6509[0] == '"') {
								charsOut.push('\\"');
								s_6509.shift();
							} else if (s_6509[0] == '\\') {
								charsOut.push('\\\\');
								s_6509.shift();
							} else {
								charsOut.push('\\');
							};
						}
					} break;
					
					default: 
					{
						charsOut.push(s_6509[0]);
						s_6509.shift();
					}
					};
				};
				const id_6511 = this.registerString(charsOut.join(''));
				this.declarationsOfStringsMap.set(string_6506, id_6511);
				return ('String_' + (id_6511) + '');
			}
		} break;
		
		case 4: {
			return 'true_'
		} break;
		
		case 5: {
			return 'false_'
		} break;
		
		case 9: {
			const expr_6512 = temp_6490[1];
			const name_6513 = temp_6490[2];
			{
				if (name_6513 == 'toZeroOrOne') {
					const type_6514 = this.getType(expr_6512);
					if (type_6514 == this.project.typer.typeBool) { return this.printExpression(expr_6512) };
				};
				if (name_6513 == 'ref' || name_6513 == 'address') {
					const type_6515 = this.getType(expr_6512);
					{
						const temp_6516 = type_6515;
						switch (temp_6516&&temp_6516[0]) {
						case 6: {
							const c_6517 = temp_6516[1];
							{
								if ((c_6517.name == 'ByValue') && (name_6513 == 'ref')) { return '(&' + this.printExpression(expr_6512) + ')' };
								if ((c_6517.name == 'ArrayByValue') && (name_6513 == 'ref')) { return '(&' + this.printExpression(expr_6512) + '[0])' };
								if (c_6517.name == 'ArrayByValue' && name_6513 == 'address') { return '(uint64_t)&(' + this.printExpression(expr_6512) + ')' };
							}
						} break;
						};
					};
				};
				{
					const temp_6518 = expr_6512;
					switch (temp_6518&&temp_6518[0]) {
					case 8: {
						return ((() => {
							const result_6519 = this.customThis;
							if (result_6519 != null) { return result_6519 };
							return 'this';
						})()) + '->' + name_6513 + '_'
					} break;
					
					case 6: {
						const id_6520 = temp_6518[1];
						const typed = temp_6518[2];
						{
							if ((id_6520.charAt(0) == id_6520.charAt(0).toUpperCase()) && ((!id_6520.startsWith('_')))) { return id_6520 + '_$' + name_6513 + '_' };
							const type_6521 = this.getType(expr_6512);
							if ((type_6521 == this.project.typer.typeAny) || (type_6521 == null)) { return this.printExpression(expr_6512) + '->let_(String_$fromUTF16z_(L"' + name_6513 + '"))' };
							{
								const temp_6522 = typed;
								switch (temp_6522&&temp_6522[0]) {
								case 6: {
									const c_6523 = temp_6522[1];
									if (c_6523.fieldRenames.includes(name_6513)) { return this.printExpression(expr_6512) + '->' + name_6513 }
								} break;
								};
							};
							return this.printExpression(expr_6512) + '->' + name_6513 + '_';
						}
					} break;
					
					default: 
					{
						{
							const temp_6524 = this.getType(expr_6512);
							switch (temp_6524&&temp_6524[0]) {
							case 6: {
								const c_6525 = temp_6524[1];
								if (c_6525.fieldRenames.includes(name_6513)) { return this.printExpression(expr_6512) + '->' + name_6513 }
							} break;
							};
						};
						return this.printExpression(expr_6512) + '->' + name_6513 + '_';
					}
					};
				};
			}
		} break;
		
		case 10: {
			const e_6526 = temp_6490[1];
			const args_6527 = temp_6490[2];
			const type_6528 = temp_6490[3];
			const kind_6529 = temp_6490[4];
			{
				{
					const temp_6530 = kind_6529;
					switch (temp_6530) {
					case 10: {
						return this.printExpression(e_6526) + this.printCallArguments(args_6527, null)
					} break;
					
					case 12: {
						{
							const temp_6531 = e_6526;
							switch (temp_6531&&temp_6531[0]) {
							case 9: {
								const expr_6532 = temp_6531[1];
								const name_6533 = temp_6531[2];
								const result_6534 = temp_6531[3];
								{
									const temp_6535 = (this.tempId++);
									const temp1 = (this.tempId++);
									const mb = this.metaBlock;
									this.metaBlock = [];
									const exprType_6536 = this.getType(expr_6532);
									const typeString_6537 = this.stringifyType(exprType_6536, false);
									const meta_6538 = typeString_6537 + (' _$' + (temp_6535) + ' = ') + this.printExpression(expr_6532);
									let isStruct_6539 = false;
									{
										const temp_6540 = exprType_6536;
										switch (temp_6540&&temp_6540[0]) {
										case 6: {
											const type_6541 = temp_6540[1];
											const params_6542 = temp_6540[2];
											{
												const atts_6543 = this.project.mapDecorators.get(type_6541.parent);
												isStruct_6539 = Decorator.getDecorator(atts_6543, 'struct') != null;
											}
										} break;
										
										case 5: {
											const type_6544 = temp_6540[1];
											{
												const atts_6545 = this.project.mapDecorators.get(type_6544.parent);
												isStruct_6539 = Decorator.getDecorator(atts_6545, 'struct') != null;
											}
										} break;
										
										default: 
										{
										}
										};
									};
									const result_6546 = ((isStruct_6539)? (this.omitPointer(typeString_6537) + '$' + name_6533 + '_' + this.printCallArgumentsVirtual(('_$' + (temp_6535) + ''), args_6527, null)) : ('_$' + (temp_6535) + '->_->') + name_6533 + '_' + this.printCallArgumentsVirtual(('_$' + (temp_6535) + ''), args_6527, null));
									for (const b of $toIterator(this.metaBlock)) {
										mb.push(b);
									};
									mb.push(meta_6538);
									this.metaBlock = mb;
									return result_6546;
								}
							} break;
							};
						}
					} break;
					};
				};
				return this.printExpression(e_6526) + this.printCallArguments(args_6527, null);
			}
		} break;
		
		case 14: {
			const expr_6547 = temp_6490[1];
			const args_6548 = temp_6490[2];
			const defaults_6549 = temp_6490[3];
			const types_6550 = temp_6490[4];
			const returns_6551 = temp_6490[5];
			const funcType_6552 = temp_6490[6];
			return this.printExpression(/*Function*/[13,null,/*Return*/[6,expr_6547,".Return"],args_6548,defaults_6549,funcType_6552,".Function"])
		} break;
		
		case 13: {
			const name_6553 = temp_6490[1];
			const expr_6554 = temp_6490[2];
			const args_6555 = temp_6490[3];
			const defaults_6556 = temp_6490[4];
			const funcType_6557 = temp_6490[5];
			{
				const _currentReturnType_6558 = this.currentReturnType;
				this.currentReturnType = this.getFunctionReturnType(funcType_6557);
				const temp_6559 = (this.tempId++);
				const rt_6560 = this.printFunctionReturnType(funcType_6557);
				this.forwardFunctions.push(rt_6560);
				this.forwardFunctions.push((' _$' + (temp_6559) + ''));
				this.forwardFunctions.push(this.printFunctionArguments(args_6555, funcType_6557, 10));
				this.forwardFunctions.push(';\n');
				const tab_6561 = this.tabs;
				this.tabs = '';
				this.globalFunctions.push(rt_6560);
				this.globalFunctions.push((' _$' + (temp_6559) + ''));
				this.globalFunctions.push(this.printFunctionArguments(args_6555, funcType_6557, 10));
				this.globalFunctions.push(' ');
				this.globalFunctions.push(this.printBlock(expr_6554));
				this.globalFunctions.push('\n\n');
				this.tabs = tab_6561;
				this.currentReturnType = _currentReturnType_6558;
				return ('_$' + (temp_6559) + '');
			}
		} break;
		
		case 11: {
			const e_6562 = temp_6490[1];
			const args_6563 = temp_6490[2];
			const result_6564 = temp_6490[3];
			{
				const name_6565 = this.omitPointer(this.stringifyType(result_6564, false));
				{
					const temp_6566 = result_6564;
					switch (temp_6566&&temp_6566[0]) {
					case 6: {
						const type_6567 = temp_6566[1];
						const params_6568 = temp_6566[2];
						{
							const atts_6569 = this.project.mapDecorators.get(type_6567.parent);
							const isStruct_6570 = Decorator.getDecorator(atts_6569, 'struct') != null;
							if (isStruct_6570) {
								const shouldInit = (!type_6567.external);
								if (shouldInit) {
									if (args_6563.length > 0) { return name_6565 + ('$this_((' + (name_6565) + '*)HEXA_NEW(sizeof(' + (name_6565) + ')), ') + this.printCallArguments(args_6563, null) + ')' };
									return name_6565 + ('$this_((' + (name_6565) + '*)HEXA_NEW(sizeof(' + (name_6565) + ')))');
								};
								return ('(' + (name_6565) + '*)HEXA_NEW(sizeof(' + (name_6565) + '))');
							};
						}
					} break;
					};
				};
				return name_6565 + '$new_' + this.printCallArguments(args_6563, null);
			}
		} break;
		
		case 17: {
			const el_6571 = temp_6490[1];
			const arrayType = temp_6490[2];
			{
				const type_6572 = this.stringifyType(arrayType, false);
				if (el_6571.length == 0) { return ('' + (this.omitPointer(type_6572)) + '$new_(0)') };
				{
					const temp_6573 = arrayType;
					switch (temp_6573&&temp_6573[0]) {
					case 6: {
						const generic_6574 = temp_6573[2];
						{
							const elType = this.stringifyType(generic_6574[0], false);
							return ('' + (this.omitPointer(type_6572)) + '$from_(' + (this.omitPointer(type_6572)) + '$new_(' + (el_6571.length) + '), (' + (elType) + '[]){') + (() => {
								const result_6575 = [];
								const value_6576 = el_6571;
								for (const a of $toIterator(value_6576)) result_6575.push(this.printExpression(a));
								return result_6575;
							})().join(', ') + '})';
						}
					} break;
					};
				};
				return ('' + (this.omitPointer(type_6572)) + '$from_(' + (this.omitPointer(type_6572)) + '$new_(' + (el_6571.length) + '), {') + (() => {
					const result_6577 = [];
					const value_6578 = el_6571;
					for (const a of $toIterator(value_6578)) result_6577.push(this.printExpression(a));
					return result_6577;
				})().join(', ') + '})';
			}
		} break;
		
		case 19: {
			const op_6579 = temp_6490[1];
			const postfix_6580 = temp_6490[2];
			const e_6581 = temp_6490[3];
			{
				if (postfix_6580) { return this.printExpression(e_6581) + Token.stringify(op_6579) };
				return Token.stringify(op_6579) + this.printExpression(e_6581);
			}
		} break;
		
		case 20: {
			const nullable = temp_6490[1];
			const othewise = temp_6490[2];
			return '((' + this.printExpression(nullable) + ')||(' + this.printExpression(othewise) + '))'
		} break;
		
		case 15: {
			const e_6582 = temp_6490[1];
			return '(' + this.printExpression(e_6582) + ')'
		} break;
		
		case 12: {
			const a_6583 = temp_6490[1];
			const op_6584 = temp_6490[2];
			const b = temp_6490[3];
			{
				if (op_6584 == 95 || op_6584 == 103) {
					{
						let step_6585 = 0;
						const aType = this.getType(a_6583);
						let temp_6586 = null;
						if (step_6585 == 0 && aType != null) {
							temp_6586 = aType == this.project.typer.typeNullUInt64;
							step_6585 = 1;
						};
						if (step_6585 == 1 && temp_6586 != false) { step_6585 = 2 };
						if (step_6585 == 2) { return (((op_6584 == 103)? ('!') : '')) + 'equalNull$UInt64(' + this.printExpression(a_6583) + ', ' + this.printTypeConverter(this.printExpression(b), this.getType(b), aType) + ')' };
					};
					{
						let step_6587 = 0;
						const aType_6588 = this.getType(a_6583);
						let temp_6589 = null;
						if (step_6587 == 0 && aType_6588 != null) {
							temp_6589 = aType_6588 == this.project.typer.typeNullFloat32;
							step_6587 = 1;
						};
						if (step_6587 == 1 && temp_6589 != false) { step_6587 = 2 };
						if (step_6587 == 2) { return (((op_6584 == 103)? ('!') : '')) + 'equalNull$Float32(' + this.printExpression(a_6583) + ', ' + this.printTypeConverter(this.printExpression(b), this.getType(b), aType_6588) + ')' };
					};
				};
				if (op_6584 == 111) {
					if (this.getType(a_6583) == this.project.typer.typeString) { return 'String_$combine_(' + this.printExpression(a_6583) + ', ' + this.printTypeConverter(this.printExpression(b), this.getType(b), this.project.typer.typeString) + ')' };
					if (this.getType(b) == this.project.typer.typeString) { return 'String_$combine_(' + this.printTypeConverter(this.printExpression(a_6583), this.getType(a_6583), this.project.typer.typeString) + ', ' + this.printExpression(b) + ')' };
				};
				const token = ((op_6584 == 110)? ('/') : Token.stringify(op_6584));
				return this.printExpression(a_6583) + ' ' + token + ' ' + this.printExpression(b);
			}
		} break;
		
		case 22: {
			const expr_6590 = temp_6490[1];
			const index_6591 = temp_6490[2];
			{
				{
					const temp_6592 = this.getType(expr_6590);
					switch (temp_6592&&temp_6592[0]) {
					case 6: {
						const type_6593 = temp_6592[1];
						const generic_6594 = temp_6592[2];
						if (type_6593.name != 'Array') { return this.printExpression(expr_6590) + '[' + this.printTypeConverter(this.printExpression(index_6591), this.getType(index_6591), this.project.typer.typeInt) + ']' }
					} break;
					};
				};
				return this.printExpression(/*Call*/[10,/*Dot*/[9,expr_6590,'get',null,".Dot"],[index_6591],this.project.typer.typeAny,12,".Call"]);
			}
		} break;
		
		case 21: {
			const econd_6595 = temp_6490[1];
			const eif_6596 = temp_6490[2];
			const eelse_6597 = temp_6490[3];
			{
				let r_6598 = '';
				try {
					r_6598 += '(' + this.printExpression(econd_6595) + ')?';
					r_6598 += '(' + this.printExpression(eif_6596) + ')';
					r_6598 += ':' + this.printExpression(eelse_6597);
					return r_6598;
				} catch (temp_6599) {
					if (true) { 
					const error = temp_6599
					{
						console.log('If =>', e_6489, error);
						return r_6598 + '<!--If => error-->';
					} } else
					
					throw temp_6599;
				};
			}
		} break;
		
		case 27: {
			const expr_6600 = temp_6490[1];
			{
				const e_6601 = this.printExpression(expr_6600);
				return '(' + e_6601 + ' == ((Unknown_ *)0)? -1 : ' + e_6601 + '->is_)';
			}
		} break;
		
		case 16: {
			const names = temp_6490[1];
			const el_6602 = temp_6490[2];
			return 'Object_from(' + (() => {
				const result_6603 = [];
				const value_6604 = el_6602.length;
				for (const i of $toIterator(value_6604)) result_6603.push(((names[i]) + ', ' + this.printExpression(el_6602[i])));
				return result_6603;
			})().join(', ') + ')'
		} break;
		
		case 18: {
			const keys_6605 = temp_6490[1];
			const values_6606 = temp_6490[2];
			const keyType_6607 = temp_6490[3];
			const valueType_6608 = temp_6490[4];
			const mapType_6609 = temp_6490[5];
			{
				const type_6610 = this.omitPointer(this.stringifyType(mapType_6609, false));
				if (keys_6605.length == 0) { return ('' + (type_6610) + '$new_()') };
				const kType = this.stringifyType(keyType_6607, false);
				const vType = this.stringifyType(valueType_6608, false);
				return ('' + (type_6610) + '$from_(' + (type_6610) + '$new_(), ' + (keys_6605.length) + ', (' + (kType) + '[]){') + (() => {
					const result_6611 = [];
					const value_6612 = keys_6605;
					for (const el of $toIterator(value_6612)) result_6611.push(this.printExpression(el));
					return result_6611;
				})().join(', ') + ('}, (' + (vType) + '[]){') + (() => {
					const result_6613 = [];
					const value_6614 = values_6606;
					for (const el of $toIterator(value_6614)) result_6613.push(this.printExpression(el));
					return result_6613;
				})().join(', ') + '})';
			}
		} break;
		
		case 25: {
			const a_6615 = temp_6490[1];
			const op_6616 = temp_6490[2];
			const value_6617 = temp_6490[3];
			return this.printExpression(a_6615) + ' ' + Token.stringify(op_6616) + '= ' + this.printExpression(value_6617)
		} break;
		
		case 26: {
			const kind_6618 = temp_6490[1];
			const args_6619 = temp_6490[2];
			const s_6620 = temp_6490[3];
			const params_6621 = temp_6490[4];
			const result_6622 = temp_6490[5];
			{
				const temp_6623 = kind_6618;
				switch (temp_6623) {
				case 0: {
					return '((' + this.printExpression(args_6619[0]) + ')' + s_6620 + '(' + this.printExpression(args_6619[1]) + '))'
				} break;
				
				case 1: {
					{
						{
							let step_6624 = 0;
							const params_6625 = params_6621;
							let temp_6626 = null;
							if (step_6624 == 0 && params_6625 != null) {
								temp_6626 = s_6620 == '*sizeof';
								step_6624 = 1;
							};
							if (step_6624 == 1 && temp_6626 != false) { step_6624 = 2 };
							if (step_6624 == 2) { return 'sizeof(' + this.omitPointer(this.stringifyType(params_6625[0], false)) + ')' };
						};
						{
							let step_6627 = 0;
							const params_6628 = params_6621;
							let temp_6629 = null;
							if (step_6627 == 0 && params_6628 != null) {
								temp_6629 = s_6620 == '&sizeof';
								step_6627 = 1;
							};
							if (step_6627 == 1 && temp_6629 != false) { step_6627 = 2 };
							if (step_6627 == 2) { return 'sizeof(' + this.stringifyType(params_6628[0], false) + ')' };
						};
						return s_6620 + this.printCallArguments(args_6619, null);
					}
				} break;
				
				case 2: {
					return '(' + s_6620 + '(' + this.printExpression(args_6619[0]) + '))'
				} break;
				
				case 3: {
					return '((' + this.printExpression(args_6619[1]) + ')' + s_6620 + ')'
				} break;
				};
			}
		} break;
		
		case 23: {
			const e_6630 = temp_6490[1];
			const to_6631 = temp_6490[2];
			return this.printTypeConverter(this.printExpression(e_6630), this.getType(e_6630), to_6631)
		} break;
		
		case 28: {
			const typeName = temp_6490[1];
			const tagName_6632 = temp_6490[2];
			const tag_6633 = temp_6490[3];
			const args_6634 = temp_6490[4];
			return '' + typeName + '_$' + tagName_6632 + '_(' + (() => {
				const result_6635 = [];
				const value_6636 = args_6634;
				for (const a of $toIterator(value_6636)) result_6635.push(this.printExpression(a));
				return result_6635;
			})().join(', ') + ')'
		} break;
		
		case 29: {
			const expr_6637 = temp_6490[1];
			const index_6638 = temp_6490[2];
			return this.printExpression(expr_6637) + '->enum_[' + index_6638 + ']'
		} break;
		
		default: 
		{
			console.error('Unknown expression kind:', e_6489);
			return '<!--' + ((() => {
				const result_6639 = ((e_6489));
				if (result_6639 != null) { return result_6639 };
				return [];
			})())[0] + '-->';
		}
		};
	};
	}
	GenCxx.spawn = () => { return new GenCxx() };
	var NiceLink = class {
		constructor() { 
			this.dllExport = false
			this.dllImport = false
			this.emitHeader = false
			this.customHeader = null
			this.convention = 0
		{
	} };
	}
	var NiceProject = class {
		constructor() { 
			this.interfaces = []
			this.classes = []
			this.enumsSimple = []
			this.enumsComplex = []
			this.globalLink = new Map()
			this.globalVars = []
			this.globalFuncs = []
			this.init = []
			this.expressionType = new Map()
			this.expressionPosition = new Map()
			this.statementPosition = new Map()
			this.native = new Map()
			this.mapDecorators = new Map()
			this.memory = 64
		{
	} };
	}
	var NiceClass = class {
		constructor() { 
			this.usedByValueDepth = 0
			this.template = false
			this.staticMethods = []
			this.staticVars = []
			this.methods = []
			this.vars = []
			this.varBits = []
			this.property = []
			this.jsRequire = null
			this.jsNative = null
		{
	} };
	}
	var NiceSimpleEnum = class {
		constructor() { 
			this.staticMethods = []
			this.staticVars = []
		{
	} };
	}
	var NiceComplexEnum = class {
		constructor() { 
			this.staticMethods = []
			this.staticVars = []
		{
	} };
	}
	var NodeData = class {
		constructor(atLine, atColumn, atFile) { 
		{
		this.line = atLine;
		this.column = atColumn;
		this.fileName = atFile;
	} };
	}
	var DataHelper = class {
	}
	DataHelper.varName = (v) => {
		const temp = v;
		switch (temp&&temp[0]) {
		case 24: {
			const name = temp[1];
			return name
		} break;
		
		default: 
		throw ('varName got not a Var, but `' + (v) + '`')
		};
	};
	DataHelper.nameOf = (v_6903) => {
		const temp_6904 = v_6903;
		switch (temp_6904&&temp_6904[0]) {
		case 48: {
			const node = temp_6904[1];
			return DataHelper.nameOf(node)
		} break;
		
		case 26: {
			const node_6905 = temp_6904[1];
			return DataHelper.nameOf(node_6905)
		} break;
		
		case 24: {
			const name_6906 = temp_6904[1];
			return name_6906
		} break;
		
		case 39: {
			const t = temp_6904[1];
			{
				{
					const temp_6907 = t;
					switch (temp_6907&&temp_6907[0]) {
					case 1: {
						const name_6908 = temp_6907[1];
						return name_6908
					} break;
					
					case 2: {
						const name_6909 = temp_6907[1];
						return name_6909
					} break;
					};
				};
				throw 'unreachable #1';
			}
		} break;
		
		case 22: {
			const name_6910 = temp_6904[1];
			return name_6910
		} break;
		
		case 25: {
			const t_6911 = temp_6904[1];
			{
				{
					const temp_6912 = t_6911;
					switch (temp_6912&&temp_6912[0]) {
					case 1: {
						const name_6913 = temp_6912[1];
						return name_6913
					} break;
					
					case 2: {
						const name_6914 = temp_6912[1];
						return name_6914
					} break;
					};
				};
				throw 'unreachable #2';
			}
		} break;
		
		case 9: {
			const t_6915 = temp_6904[1];
			{
				const temp_6916 = t_6915;
				switch (temp_6916&&temp_6916[0]) {
				case 1: {
					const name_6917 = temp_6916[1];
					return name_6917
				} break;
				
				case 2: {
					const name_6918 = temp_6916[1];
					return name_6918
				} break;
				};
			}
		} break;
		
		case 47: {
			const field = temp_6904[1];
			return DataHelper.nameOf(field)
		} break;
		
		default: 
		throw ('nameOf expected named node, but got `' + (v_6903) + '`')
		};
	};
	DataHelper.asStringAttValue = (a, index) => {
		const temp_6919 = (a.values[index]);
		switch (temp_6919&&temp_6919[0]) {
		case null: case undefined: {
			throw 'Got null, not a string'
		} break;
		
		case 0: {
			const s = temp_6919[1];
			return s
		} break;
		
		default: 
		throw ('Got `' + (a.values[index]) + '`, not a string')
		};
	};
	DataHelper.getLastOfBlock = (block) => {
		const temp_6920 = block;
		switch (temp_6920&&temp_6920[0]) {
		case null: case undefined: {
			throw 'Got null, not a block'
		} break;
		
		case 12: {
			const el = temp_6920[1];
			return el[el.length - 1]
		} break;
		
		default: 
		throw ('Got `' + (block) + '`, not a block')
		};
	};
	DataHelper.isVoidValue = (block_6921) => {
		{
			const temp_6922 = block_6921;
			switch (temp_6922&&temp_6922[0]) {
			case null: case undefined: {
				return true
			} break;
			
			case 16: {
				return true
			} break;
			
			case 18: {
				return true
			} break;
			
			case 19: {
				return true
			} break;
			
			case 24: {
				return true
			} break;
			
			case 14: {
				const eelse = temp_6922[3];
				if (eelse == null) { return true }
			} break;
			
			case 39: {
				return true
			} break;
			
			case 25: {
				return true
			} break;
			
			case 34: {
				return true
			} break;
			
			case 12: {
				const el_6923 = temp_6922[1];
				{
					if (el_6923.length == 0) { return true };
					return DataHelper.isVoidValue(el_6923[el_6923.length - 1]);
				}
			} break;
			
			default: 
			return false
			};
		};
		return false;
	};
	DataHelper.extractTypeName = (t_6924) => {
		const temp_6925 = t_6924;
		switch (temp_6925&&temp_6925[0]) {
		case 1: {
			const name_6926 = temp_6925[1];
			return name_6926
		} break;
		
		case 6: {
			const name_6927 = temp_6925[1];
			return name_6927
		} break;
		
		case 2: {
			const name_6928 = temp_6925[1];
			return name_6928
		} break;
		
		case null: case undefined: {
			return null
		} break;
		
		default: 
		return null
		};
	};
	DataHelper.getDecorator = (atts, name_6929) => {
		{
			let step = 0;
			const atts_6930 = atts;
			let temp_6931 = null;
			if (step == 0 && atts_6930 != null) {
				temp_6931 = atts_6930.length > 0;
				step = 1;
			};
			if (step == 1 && temp_6931 != false) { step = 2 };
			if (step == 2) { for (const att of $toIterator(atts_6930)) {
				if (att.name == name_6929) { return att };
			} };
		};
		return null;
	};
	DataHelper.isTitleCase = (string) => { return string.charAt(0) == string.charAt(0).toUpperCase() };
	var ClassType = class {
		constructor() { 
			this.owner = null
			this.fieldNames = []
			this.fieldRenames = []
			this.fieldStatic = []
			this.fieldInitialized = []
			this.protected = []
			this.immutable = []
			this.constructor = (-1)
			this.indexKeyType = null
			this.indexValueType = null
			this.fields = new Map()
			this.genericParams = []
			this.useless = true
			this.external = false
			this.extend = null
			this.implement = []
			this.usedByValueDepth = 0
			this.instanceOf = null
			this.instanceParams = null
			this.instances = []
			this.instanceCache = /*ClassInstance*/[6,this,null,".ClassInstance"]
			this.genericCache = []
		{
	} };
		instantiate() { return this.instanceCache };
		instantiateGeneric(params) {
		for (const cached of $toIterator(this.genericCache)) {
			if (cached.length != (params.length + 1)) { continue };
			let found = true;
			{
				let i = 0;
				let it = 0;
				let at = cached.length - 1;
				while (it < at) {
					i = it;
					it++;
					{
						if (params[i] != cached[i + 1]) {
							found = false;
							break;
						};
					};
				};
			};
			if (found) {
				const result_6974 = cached[0];
				return result_6974;
			};
		};
		const result_6975 = /*ClassInstance*/[6,this,params,".ClassInstance"];
		const cache = [result_6975];
		for (const param of $toIterator(params)) {
			cache.push(param);
		};
		this.genericCache.push(cache);
		if (this.parent != null) {
			let step_6976 = 0;
			const delayedInstance = Typer.delayedInstance;
			if (step_6976 == 0 && delayedInstance != null) { step_6976 = 1 };
			if (step_6976 == 1) { delayedInstance(this.parent, params, this) };
		};
		return result_6975;
	};
	}
	var EnumType = class {
		constructor() { 
			this.fieldNames = []
			this.tagBindVars = []
			this.tagBindVarsNames = []
			this.tagBindVarsTypes = []
			this.tagBindVarsNodes = []
			this.fieldStatic = []
			this.fieldEnumConstructor = []
			this.fieldType = []
			this.fieldsTypeSimple = null
		{
	} };
	}
	var AliasType = class {
		constructor(value_6977) { 
		this.value = value_6977 };
	}
	var FunctionArgument = class {
		constructor(withType) { 
			this.name = null
			this.optional = false
		this.type = withType };
	}
	var Module = class {
		constructor() { 
			this.file = '.hexa'
			this.path = 'module'
			this.nodes = []
			this.exported = new Map()
			this.imported = new Map()
		{
	} };
	}
	var Project = class {
		constructor() { 
			this.mapDecorators = new Map()
			this.typeDecorators = new Map()
			this.mapNames = new Map()
			this.mapModules = new Map()
			this.data = new Map()
			this.hints = []
			this.defines = {}
			this.name = 'Hexa Project'
			this.json = 'hexa.json'
			this.roots = []
			this.globals = new Map()
			this.moduleName = []
			this.moduleInfo = []
			this.mapFuncParams = new Map()
		{
	} };
	}
	var CompilerError = class {
		constructor(except, details, line, column, filename) { 
		{
		this.exception = except;
		this.details = (((details == null))? ('') : details);
		this.line = (((line == null))? (0) : line);
		this.column = (((column == null))? (0) : column);
		this.fileName = (((filename == null))? ('') : filename);
	} };
		toString() {
		if (alternativeErrorFormat) { return '' + this.fileName + ':' + this.line + ':' + this.column + ': ' + this.details };
		return '[' + this.fileName + ':' + this.line + ':' + this.column + ']: ' + this.details;
	};
	}
	var CompilerErrors = class {
		constructor(errors) { 
		this.errors = errors };
		toString() {
		{
			let step = 0;
			const error = this.errors[0];
			let temp = null;
			if (step == 0 && error != null) {
				temp = this.errors.length == 1;
				step = 1;
			};
			if (step == 1 && temp != false) { step = 2 };
			if (step == 2) { return error.toString() };
		};
		return (() => {
			const result = [];
			const value = this.errors;
			for (const error of $toIterator(value)) result.push(error.toString());
			return result;
		})().join('\n') + '\nFound ' + this.errors.length + ' errors.';
	};
	}
	var Hint = class {
		constructor(code, details, position) { 
		{
		this.code = code;
		this.details = details;
		this.at = position;
	} };
		toString() { return '[' + this.at.fileName + ':' + this.at.line + ':' + this.at.column + ']: Hint#' + this.code + ': ' + this.details };
	}
	Hint.toTitleCase = (text) => {
		if (text.length == 0) { return text.toUpperCase() };
		return text.substr(0, 1).toUpperCase() + text.substr(1, 1073741824);
	};
	Hint.toCamelCase = (text_6978) => {
		if (text_6978.length == 0) { return text_6978.toLowerCase() };
		return text_6978.substr(0, 1).toLowerCase() + text_6978.substr(1, 1073741824);
	};
	var ArgumentsParsingEngine = class {
	}
	ArgumentsParsingEngine.cleanupArgv = () => { if (process.argv[0].endsWith('node.exe') || process.argv[0].endsWith('node')) {
		process.argv.shift();
		process.argv.shift();
	} else if (process.argv[0].endsWith('.exe')) {
		process.argv.shift();
		if ((process.argv[0] != null) && (process.argv[0].endsWith('.js'))) { process.argv.shift() };
	} };
	ArgumentsParsingEngine.engage = () => {
		ArgumentsParsingEngine.cleanupArgv();
		return /*Help*/[0,".Help"];
	};
	var Main = class {
		processFile(target, project) {
		const content = Fs.readFileSync(target);
		const tokens = Lexer.tokenize(content, target);
		if (tokens.length > 0) { this.lines += tokens.line[tokens.length - 1] };
		const parsed = Parser.parseNodes(tokens, project);
		return parsed;
	};
		simplyCompileToJs(buffer, path) {
		process.argv[0] = __dirname + '/repl.json';
		const resolved = Path.resolve(__dirname + '/repl.hexa');
		fileContents.set(resolved, buffer);
		return new Main().perform(true);
	};
		repl() {
		console.log('\x1b[35m' + ('Hexa ' + (version) + ' on node.js ') + process_3671.versions.node + '\x1b[0m');
		console.log('\x1b[33mTo print something onto screen use `console.log(value)`\x1b[0m');
		console.log('\x1b[33mTo clear REPL memory use `.clear`\x1b[0m');
		console.log('\x1b[33mTo close REPL use `.exit`\x1b[0m');
		let linesAll = [];
		let linesLatest = [];
		while (true) {
			const line = question('\x1b[32m> \x1b[0m').trim();
			if (line == '.clear') {
				linesAll = [];
				linesLatest = [];
				continue;
			};
			if (line == '.exit') { return };
			if (line.length == 0) { continue };
			linesLatest.push(line);
			try {
				let code = '"use strict"\r\n';
				try {
					const content_6990 = linesAll.join('\n') + '\n' + linesLatest.join('\n');
					const compiled = this.simplyCompileToJs(Buffer.from(content_6990), 'REPL');
					if (compiled == null) {
						linesLatest.pop();
						continue;
					};
					{
						let step = 0;
						const compiled_6991 = compiled;
						if (step == 0 && compiled_6991 != null) { step = 1 };
						if (step == 1) { code = compiled_6991 };
					};
				} catch (temp_6989) {
					if (true) { 
					const e = temp_6989
					{
						const error = '' + e;
						if (error.indexOf('<!--end-->', 0) == (-1)) {
							linesLatest = [];
							console.error('\x1b[31mCompilation Error: ' + e, '\x1b[0m');
						} else {
							process_3671.stdout.write('\x1b[32m>\x1b[0m');
						};
						continue;
					} } else
					
					throw temp_6989;
				};
				for (const line of $toIterator(linesLatest)) {
					linesAll.push(line);
				};
				linesLatest = [];
				const result = eval(code);
			} catch (temp) {
				if (true) { 
				const e = temp
				{
					console.error('Error: ' + e);
				} } else
				
				throw temp;
			};
		};
	};
		processFiles(targets, relativePath, loaded, project_7021) {
		const res = [];
		const imports = [];
		for (const target of $toIterator(targets)) {
			if ((!Fs.existsSync(target))) {
				console.log(('No such source file on disk `' + (target) + '`'));
				continue;
			};
			try {
				const parsed_7023 = this.processFile(target, project_7021);
				res.push(parsed_7023);
				for (const e of $toIterator(parsed_7023)) {
					const temp_7024 = e;
					switch (temp_7024&&temp_7024[0]) {
					case 37: {
						const el = temp_7024[1];
						const path_7025 = temp_7024[2];
						{
							const resolved_7026 = Path.resolve(relativePath + path_7025 + '.hexa');
							console.log('processFiles! ' + resolved_7026);
							if (loaded.get(resolved_7026) == true) { console.log('loaded! ' + resolved_7026) };
							if (loaded.get(resolved_7026) != true) {
								loaded.set(resolved_7026, true);
								imports.push(resolved_7026);
							};
						}
					} break;
					};
				};
			} catch (temp_7022) {
				if (true) { 
				const e = temp_7022
				{
					console.log(quote('\x1b[31m' + e.toString() + '\x1b[0m'));
				} } else
				
				throw temp_7022;
			};
		};
		if (targets.length != res.length) {
			console.log('[Stopped on errors]');
			process_3671.exit(1);
		};
		if (imports.length > 0) { for (const file of $toIterator(this.processFiles(imports, relativePath, loaded, project_7021))) {
			res.unshift(file);
		} };
		return res;
	};
		incorrect(what, project_7027) {
		const msg_7028 = ('Incorrect package file! Field `' + (what) + '` does not exists');
		throw new CompilerErrors([new CompilerError(5, msg_7028, 1, 1, project_7027.json)]);
	};
		readPackage(filename) { try {
		const pack = JSON.parse(Fs.readFileSync(Path.resolve(filename)).toString('utf8', 0, 1073741824).split('\r\n').join('\n'));
		return pack;
	} catch (temp_7029) {
		if (true) { 
		const e = temp_7029
		{
			const msg_7030 = 'Cannot open ' + filename;
			throw new CompilerErrors([new CompilerError(5, msg_7030, 1, 1, 'hexa.json')]);
		} } else
		
		throw temp_7029;
	} };
		loadPackage(filename_7031, target_7032, project_7033) {
		const pack_7034 = this.readPackage(filename_7031);
		project_7033.json = filename_7031;
		{
			let step_7035 = 0;
			const name_7036 = pack_7034.name;
			if (step_7035 == 0 && name_7036 != null) { step_7035 = 1 };
			if (step_7035 == 1) { project_7033.name = name_7036 } else {
				this.incorrect('name', project_7033);
			};
		};
		if (pack_7034.targets == null) { this.incorrect('targets', project_7033) };
		{
			let step_7037 = 0;
			const entry = pack_7034.entry;
			if (step_7037 == 0 && entry != null) { step_7037 = 1 };
			if (step_7037 == 1) { if ((!entry.startsWith('/'))) { pack_7034.entry = '/' + entry } } else {
				this.incorrect('entry', project_7033);
			};
		};
		{
			let step_7038 = 0;
			const define = pack_7034.define;
			if (step_7038 == 0 && define != null) { step_7038 = 1 };
			if (step_7038 == 1) { for (const key of $toIterator(Reflect.ownKeys(define))) {
				if ((!Reflect.has(project_7033.defines, key))) { Reflect.set(project_7033.defines, key, Reflect.get(define, key)) };
			} };
		};
		const t = (() => {
			{
				let t_7039 = 0;
				let it = 0;
				let at = pack_7034.targets.length;
				while (it < at) {
					t_7039 = it;
					it++;
					{
						if (pack_7034.targets[t_7039].name == target_7032) {
							this.targetIndex = t_7039;
							return pack_7034.targets[t_7039];
						};
					};
				};
			};
			const msg_7040 = ('Cannot find `' + (target_7032) + '` target in package file\n');
			throw new CompilerErrors([new CompilerError(5, msg_7040, 1, 1, project_7033.json)]);
		})();
		const generator = availableGenerators(t.generator);
		if (generator == null) {
			const msg_7041 = ('Generator `' + (t.generator) + '` not available or not supported by this compiler version\n');
			throw new CompilerErrors([new CompilerError(5, msg_7041, 1, 1, project_7033.json)]);
		};
		project_7033.roots.push(Path.resolve(__dirname + '/library/'));
		const dir = Path.dirname(filename_7031);
		{
			let step_7042 = 0;
			const roots_7043 = pack_7034.roots;
			if (step_7042 == 0 && roots_7043 != null) { step_7042 = 1 };
			if (step_7042 == 1) { for (const root of $toIterator(roots_7043)) {
				project_7033.roots.push(Path.resolve(dir + '/' + root));
			} } else {
				project_7033.roots.push(Path.resolve(dir));
			};
		};
		if (pack_7034.files == null) { pack_7034.files = [] };
		pack_7034.global = (() => {
			const result_7044 = pack_7034.global;
			if (result_7044 != null) { return result_7044 };
			return [];
		})();
		{
			let i = 0;
			let it_7045 = 0;
			let at_7046 = pack_7034.global.length;
			while (it_7045 < at_7046) {
				i = it_7045;
				it_7045++;
				{
					let step_7047 = 0;
					const file_7048 = pack_7034.global[i];
					let temp_7049 = null;
					if (step_7047 == 0 && file_7048 != null) {
						temp_7049 = (!file_7048.startsWith('/'));
						step_7047 = 1;
					};
					if (step_7047 == 1 && temp_7049 != false) { step_7047 = 2 };
					if (step_7047 == 2) { pack_7034.global[i] = '/' + file_7048 };
				};
			};
		};
		const global_7050 = pack_7034.global;
		global_7050.forEach((item, index_7051) => { if (global_7050.indexOf(item, 0) != index_7051) {
			const msg_7052 = ('Package `' + (item) + '` included multiple times in the `global` section of `hexa.json`\n');
			throw new CompilerErrors([new CompilerError(5, msg_7052, 1, 1, project_7033.json)]);
		} });
		if (pack_7034.noLib == true) {} else {
			const libraries = setLibrary(generator, t.options, project_7033.defines);
			for (const file of $toIterator(libraries)) {
				pack_7034.global.unshift(file);
			};
		};
		if (pack_7034.addLicenseNoticeToOutput == null) { pack_7034.addLicenseNoticeToOutput = true };
		return pack_7034;
	};
		constructor() { 
			this.lines = 0
			this.targetName = 'default'
			this.targetIndex = 0
			this.outputFolder = null
			this.typecheckProject = new Project()
		{
	} };
		loadModules(project_7053, input) {
		const moduleErrors = [];
		{
			let step_7054 = 0;
			const global_7055 = input.global;
			if (step_7054 == 0 && global_7055 != null) { step_7054 = 1 };
			if (step_7054 == 1) { for (const path of $toIterator(global_7055)) {
				try { this.lines += Main.processModule(project_7053, path, true) } catch (temp_7056) {
					if (temp_7056 instanceof CompilerErrors) { 
					const e = temp_7056
					{
						const errors = e.errors;
						for (const error of $toIterator(errors)) {
							moduleErrors.push(error);
						};
					} } else
					
					throw temp_7056;
				};
			} };
		};
		try { Main.processModule(project_7053, input.entry, false) } catch (temp_7057) {
			if (temp_7057 instanceof CompilerErrors) { 
			const e = temp_7057
			{
				const errors_7058 = e.errors;
				for (const error of $toIterator(errors_7058)) {
					moduleErrors.push(error);
				};
			} } else
			
			throw temp_7057;
		};
		if (moduleErrors.length > 0) { throw new CompilerErrors(moduleErrors) };
	};
		parseArguments() {};
		perform(noWrite) {
		const begin = Date.now();
		Lexer.init();
		if (process_3671.argv[0] == '--alt-error-format') {
			alternativeErrorFormat = true;
			process_3671.argv.shift();
		};
		if (process_3671.argv[0] == '--output-folder') {
			process_3671.argv.shift();
			this.outputFolder = process_3671.argv.shift();
		};
		const defines = {};
		while (process_3671.argv[0] == '--define') {
			if (process_3671.argv.length < 2) {
				console.log('Usage: `--define name=value`');
				process_3671.exit(1);
			};
			process_3671.argv.shift();
			const kv = ((() => {
				const result_7059 = process_3671.argv.shift();
				if (result_7059 != null) { return result_7059 };
				return '';
			})()).split('=');
			if (kv.length < 2) {
				console.log('Usage: `--define name=value`');
				process_3671.exit(1);
			};
			const k = kv[0];
			const v = JSON.parse(kv[1]);
			defines[k] = v;
		};
		const project_7060 = new Project();
		project_7060.defines = defines;
		if (process_3671.argv[0] == 'syntax-linter') {
			if (process_3671.argv.length < 2) { console.log('Usage: `hexa syntax-linter file.hexa`') } else {
				const file_7061 = process_3671.argv[1];
				try {
					const content_7063 = Fs.readFileSync(file_7061);
					try {
						const tokens_7065 = Lexer.tokenize(content_7063, file_7061);
						try { const parser = Parser.parseNodes(tokens_7065, project_7060, true) } catch (temp_7066) {
							if (true) { 
							const e = temp_7066
							{
								console.log(('' + (e) + ''));
							} } else
							
							throw temp_7066;
						};
					} catch (temp_7064) {
						if (true) { 
						const e = temp_7064
						{
							console.log(('' + (e) + ''));
						} } else
						
						throw temp_7064;
					};
				} catch (temp_7062) {
					if (true) { 
					const e = temp_7062
					{
						console.log(('ERROR: Unable to open file ' + (file_7061) + ''));
					} } else
					
					throw temp_7062;
				};
			};
			process_3671.exit(0);
		};
		const ignoreArguments = (fromIndex) => {
			if (fromIndex == process_3671.argv.length) { return };
			const args = [];
			const count = process_3671.argv.length - fromIndex;
			let i_7067 = 0;
			while (i_7067 < count) {
				args.push(process_3671.argv[(i_7067++) + fromIndex]);
			};
			console.log('Argument' + (((args.length > 1)? ('s') : '')) + ' `' + args.join('`, `') + '` ignored');
		};
		if (process_3671.argv[0] == null) {
			this.repl();
			process_3671.exit(0);
		} else if (process_3671.argv[0] == 'init') {
			init();
			ignoreArguments(3);
			process_3671.exit(0);
		} else if (process_3671.argv[0] == 'symlink') {
			symlink();
			process_3671.exit(0);
		};
		const currentFile = Path.resolve(process_3671.argv[0]);
		const currentParsedFile = Path.parse(currentFile);
		let input_7068 = (null);
		let packageFolder = currentParsedFile.dir;
		if (currentParsedFile.ext == '.json') {
			process.argv.shift();
			if (process.argv[0] == 'targets') {
				const pack_7069 = this.readPackage(currentFile);
				if (pack_7069.name == null) { this.incorrect('name', project_7060) };
				if (pack_7069.targets == null) { this.incorrect('targets', project_7060) };
				const targets_7070 = [];
				for (const target of $toIterator(pack_7069.targets)) {
					targets_7070.push(target.name);
				};
				console.log(quote(('The project `' + (pack_7069.name) + '` has following targets: ') + targets_7070.join(', ')));
				return null;
			};
			if (process.argv[0] == '--target') {
				process.argv.shift();
				this.targetName = (() => {
					const result_7071 = process.argv[0];
					if (result_7071 != null) { return result_7071 };
					return 'default';
				})();
				process.argv.shift();
			};
			input_7068 = this.loadPackage(currentFile, this.targetName, project_7060);
			ignoreArguments(0);
			if ((!noWrite)) {
				if (this.targetName != 'default') { console.log(('[Building ' + (input_7068.name) + ' - ' + (this.targetName) + ']')) } else {
					console.log(('[Building ' + (input_7068.name) + ']'));
				};
				console.log(('[Using 1 of ' + (require('os').cpus().length) + ' CPU cores]'));
			};
		} else if ((Fs.existsSync(currentFile)) && (Fs.lstatSync(currentFile).isDirectory())) {
			ignoreArguments(3);
			input_7068 = this.loadPackage(currentFile + Path.sep + 'hexa.json', this.targetName, project_7060);
			packageFolder = currentFile;
		} else if (currentParsedFile.ext == '.hexa') {
			try { eval(this.simplyCompileToJs(Fs.readFileSync(currentFile), currentFile)) } catch (temp_7072) {
				if (true) { 
				const e = temp_7072
				{
					console.error('' + e);
				} } else
				
				throw temp_7072;
			};
			process_3671.exit(0);
			return null;
		} else {
			console.error(('Unknown command: ' + (process_3671.argv[0]) + ''));
			console.error(quote('Try `hexa help`'));
			printVersion();
			process_3671.exit(1);
			return null;
		};
		let files = [];
		if ((false) && (input_7068.files != null)) {
			const relativePath_7073 = packageFolder + Path.sep;
			const loaded_7074 = new Map();
			const fileList = input_7068.files.map((file_7075) => {
				if (file_7075.startsWith('/') || file_7075.charAt(1) == ':') { return Path.resolve(file_7075) };
				const resolved_7076 = Path.resolve(relativePath_7073 + file_7075);
				loaded_7074.set(resolved_7076, true);
				return resolved_7076;
			});
			files = this.processFiles(fileList, relativePath_7073 + '/' + input_7068.root + '/', loaded_7074, project_7060);
		};
		try { this.loadModules(project_7060, input_7068) } catch (temp_7077) {
			if (true) { 
			const e = temp_7077
			{
				console.error(e.toString());
				process_3671.exit(500);
			} } else
			
			throw temp_7077;
		};
		const typer = new Typer(project_7060);
		try { typer.fillModules() } catch (temp_7078) {
			if (true) { 
			const e = temp_7078
			{
				console.log(quote('\x1b[31m' + e.toString() + '\x1b[0m'));
				if (noWrite) { return null };
				process_3671.exit(1);
			} } else
			
			throw temp_7078;
		};
		const normalizer = new Normalizer(project_7060);
		const generators = new Map();
		const registerTarget = (name_7079, generator_7080) => {
			{
				let step_7081 = 0;
				const generator_7082 = generators.get(name_7079);
				if (step_7081 == 0 && generator_7082 != null) { step_7081 = 1 };
				if (step_7081 == 1) { console.log(('Note: generator `' + (name_7079) + '` was ov\"\"erridden\"')) };
			};
			generators.set(name_7079, generator_7080);
		};
		registerTarget('js', GenJs.spawn);
		registerTarget('c', GenCxx.spawn);
		{
			let step_7083 = 0;
			const generatorName = input_7068.targets[this.targetIndex].generator;
			if (step_7083 == 0 && generatorName != null) { step_7083 = 1 };
			if (step_7083 == 1) {
				let step_7084 = 0;
				const generatorSpawner = generators.get(generatorName);
				if (step_7084 == 0 && generatorSpawner != null) { step_7084 = 1 };
				if (step_7084 == 1) {
					const generator_7085 = generatorSpawner();
					const target_7086 = packageFolder + Path.sep + Path.parse(input_7068.targets[this.targetIndex].output).name + generator_7085.extension;
					let target_7087 = Path.join(packageFolder, input_7068.targets[this.targetIndex].output);
					{
						let step_7088 = 0;
						const outputFolder = this.outputFolder;
						if (step_7088 == 0 && outputFolder != null) { step_7088 = 1 };
						if (step_7088 == 1) {
							if (Path.isAbsolute(outputFolder)) { target_7087 = outputFolder } else {
								target_7087 = Path.join(packageFolder, outputFolder);
							};
							target_7087 = Path.join(target_7087, input_7068.targets[this.targetIndex].output);
						};
					};
					normalizer.keywords = generator_7085.reserved;
					normalizer.collected = files;
					normalizer.nativeEnums = generator_7085.nativeEnums;
					normalizer.reservedGlobals = (() => {
						const result_7089 = generator_7085.reservedGlobals;
						if (result_7089 != null) { return result_7089 };
						return normalizer.reservedGlobals;
					})();
					normalizer.package = input_7068;
					{
						let step_7090 = 0;
						const randomSeed = input_7068.randomSeed;
						if (step_7090 == 0 && randomSeed != null) { step_7090 = 1 };
						if (step_7090 == 1) { normalizer.id = randomSeed };
					};
					{
						let step_7091 = 0;
						const globalAccessor = generator_7085.globalAccessor;
						if (step_7091 == 0 && globalAccessor != null) { step_7091 = 1 };
						if (step_7091 == 1) { normalizer.globalAccessor = globalAccessor };
					};
					normalizer.typer = typer;
					const normal = normalizer.normalize();
					for (const hint of $toIterator(project_7060.hints)) {
						console.log(quote(hint.toString()));
					};
					const outs = generator_7085.perform(normal, target_7087);
					if (noWrite) { return outs };
					Fs.writeFileSync(target_7087, outs);
				} else {
					console.log(('Generator for `' + (generatorName) + '` is not registered.'));
					process_3671.exit(1);
				};
			} else {
				console.log('Generator is not defined or unknown. Is there `target.generator` field in `hexa.json`?');
				process_3671.exit(1);
			};
		};
		const delta = Date.now() - begin;
		const lps = Math.round(this.lines / (delta / 1000));
		console.log(('[Finished in ' + (delta) + ' ms, ' + (this.lines) + ' lines, ' + (lps) + ' lines per second]'));
		process_3671.stdout.once('drain', () => { process_3671.exit(0) });
		process_3671.stdout.write('');
		return null;
	};
		typecheck(dir_7092) {
		try {
			const project_7094 = new Project();
			this.typecheckProject = project_7094;
			const defines_7095 = {};
			project_7094.defines = defines_7095;
			const input_7096 = this.loadPackage(dir_7092 + Path.sep + 'hexa.json', this.targetName, project_7094);
			try { this.loadModules(project_7094, input_7096) } catch (temp_7097) {
				if (true) { 
				const e = temp_7097
				{
					return e;
				} } else
				
				throw temp_7097;
			};
			const typer_7098 = new Typer(project_7094);
			typer_7098.onlyTypeCheck = true;
			try { typer_7098.fillModules() } catch (temp_7099) {
				if (true) { 
				const e = temp_7099
				{
					return e;
				} } else
				
				throw temp_7099;
			};
		} catch (temp_7093) {
			if (true) { 
			const e = temp_7093
			{
				return e;
			} } else
			
			throw temp_7093;
		};
		return new CompilerErrors([]);
	};
	}
	Main.processGlobals = (project_6992, path_6993, fullPath) => {
		const index = project_6992.moduleName.indexOf((() => {
			const result_6994 = fullPath;
			if (result_6994 != null) { return result_6994 };
			return path_6993;
		})(), 0);
		{
			let step_6995 = 0;
			const info = project_6992.moduleInfo[index];
			if (step_6995 == 0 && info != null) { step_6995 = 1 };
			if (step_6995 == 1) {
				const nodes = info.nodes;
				for (const e of $toIterator(nodes)) {
					let named = true;
					{
						const temp_6996 = e;
						switch (temp_6996&&temp_6996[0]) {
						case 24: {
							{
							}
						} break;
						
						case 39: {
							{
							}
						} break;
						
						case 22: {
							{
							}
						} break;
						
						case 25: {
							{
							}
						} break;
						
						default: 
						named = false
						};
					};
					if (named) {
						const name = DataHelper.nameOf(e);
						if (project_6992.globals.has(name)) {
							const data = (project_6992.data.get(e));
							const already = (project_6992.data.get(project_6992.globals.get(name)));
							const msg = ('Global node `' + (name) + '` declared in `' + (path_6993) + '` already defined at `' + (already.fileName) + '` line `' + (already.line) + '`');
							throw new CompilerErrors([new CompilerError(5, msg, data.line, data.column, data.fileName)]);
						} else {
							project_6992.globals.set(name, e);
						};
					};
				};
			};
		};
	};
	Main.processModule = (project_6997, path_6998, global, relative = null, node = null) => {
		let lines = 0;
		const tryInRoot = (root, fullPath_6999) => {
			const file = Path.join(root, path_6998 + '.hexa');
			if (Fs.existsSync(file)) { try {
				const resolved_7001 = Path.resolve(file);
				let cachedBuffer = Buffer.from('');
				{
					let step_7002 = 0;
					const cached = fileContents.get(resolved_7001);
					if (step_7002 == 0 && cached != null) { step_7002 = 1 };
					if (step_7002 == 1) { cachedBuffer = cached } else {
						cachedBuffer = Fs.readFileSync(file);
					};
				};
				const content_7003 = cachedBuffer;
				const tokens_7004 = Lexer.tokenize(content_7003, file);
				if (tokens_7004.length > 0) { lines += tokens_7004.line[tokens_7004.length - 1] };
				const parsed_7005 = Parser.parseNodes(tokens_7004, project_6997);
				project_6997.moduleName.push(fullPath_6999);
				const info_7006 = new Module();
				info_7006.nodes = parsed_7005;
				info_7006.file = file;
				info_7006.path = fullPath_6999;
				project_6997.moduleInfo.push(info_7006);
				project_6997.mapModules.set(node, info_7006);
				for (const e of $toIterator(parsed_7005)) {
					const temp_7007 = e;
					switch (temp_7007&&temp_7007[0]) {
					case 37: {
						const path_7008 = temp_7007[2];
						Main.processModule(project_6997, path_7008, false, info_7006, e)
					} break;
					};
				};
				if (global == true) { Main.processGlobals(project_6997, path_6998, fullPath_6999) };
				return lines;
			} catch (temp_7000) {
				if (true) { 
				const e = temp_7000
				{
					throw e;
				} } else
				
				throw temp_7000;
			} };
			return (-1);
		};
		let roots = project_6997.roots;
		{
			let step_7009 = 0;
			const relative_7010 = relative;
			let temp_7011 = null;
			if (step_7009 == 0 && relative_7010 != null) {
				temp_7011 = (!path_6998.startsWith('/'));
				step_7009 = 1;
			};
			if (step_7009 == 1 && temp_7011 != false) { step_7009 = 2 };
			if (step_7009 == 2) {
				const root_7012 = Path.dirname(relative_7010.file);
				roots = [root_7012];
			};
		};
		for (const root of $toIterator(roots)) {
			const file_7013 = Path.join(root, path_6998 + '.hexa');
			let fullPath_7014 = '';
			if (Fs.existsSync(file_7013)) { fullPath_7014 = Path.relative(Path.dirname(project_6997.json), file_7013).slice(0, (-5)).split('\\').join('/') };
			const index_7015 = project_6997.moduleName.indexOf(fullPath_7014, 0);
			if (index_7015 > (-1)) {
				if (global == true) { Main.processGlobals(project_6997, path_6998, fullPath_7014) };
				project_6997.mapModules.set(node, project_6997.moduleInfo[index_7015]);
				return lines;
			};
			const lines_7016 = tryInRoot(root, fullPath_7014);
			if (lines_7016 > (-1)) { return lines_7016 };
		};
		let msg_7017 = ('Cannot find file `' + (path_6998) + '` in any of the roots.\n');
		if (path_6998.endsWith('.hexa')) { msg_7017 += ('Do not write `.hexa` extension in imports, just use `import ... in \'' + (path_6998.replace('.hexa', '')) + '\'`.\n') };
		for (const root of $toIterator(roots)) {
			const file_7018 = Path.join(root, path_6998 + '.hexa');
			msg_7017 += ('Checked here: `' + (file_7018) + '`\n');
		};
		{
			let step_7019 = 0;
			const data_7020 = project_6997.data.get(node);
			if (step_7019 == 0 && data_7020 != null) { step_7019 = 1 };
			if (step_7019 == 1) { throw new CompilerErrors([new CompilerError(3, msg_7017, data_7020.line, data_7020.column, data_7020.fileName)]) };
		};
		throw new CompilerErrors([new CompilerError(5, msg_7017, 1, 1, project_6997.json)]);
	};
	var Server = class {
		constructor(port) { 
		{
		this.port = ((port == null)? (3978) : parseInt(port, null));
		const port_7108 = this.port;
		console.log('Requested language server at localhost:' + port_7108);
		Lexer.init();
		const http = require('http');
		const fs = require('fs');
		const path = require('path');
		const url = require('url');
		const project_7109 = new Project();
		const empty = '[]';
		const handleRequest = (project_7110, req, res) => {
			const chunks = [];
			req.on('data', (chunk) => (chunks.push(chunk)));
			req.on('end', () => {
				const start = Date.now();
				const data = Buffer.concat(chunks);
				const text = data.toString('utf8', 0, 1073741824).trim();
				if (text.length > 0) {
					const json = JSON.parse(data.toString('utf8', 0, 1073741824));
					const commands = json;
					if (commands.length == 0) {
						res.writeHead(404, {});
						res.write('[]');
						res.end();
					} else {
						const responseToAll = [];
						console.log(commands.map((c) => (c.kind)));
						for (const command of $toIterator(commands)) {
							const response = [];
							{
								const temp_7111 = command.kind;
								switch (temp_7111) {
								case 'GetWholeFileSyntaxErrors': {
									{
										const file_7112 = 'hexa.hexa';
										const content_7113 = Buffer.from(command.payload);
										const errors_7114 = syntaxCheckOnly('hexa.hexa', content_7113);
										for (const error of $toIterator(errors_7114)) {
											response.push(error);
										};
									}
								} break;
								
								case 'HoverProvider': {
									{
										const fsPath_7115 = Path.resolve(command.payload.fsPath);
										const line = command.payload.line + 1;
										const character = command.payload.character;
										const project_7116 = findProjectFile(fsPath_7115);
										if (project_7116.found == true) { try {
											const main = new Main();
											main.typecheck(project_7116.dir);
											const typecheckProject = main.typecheckProject;
											for (const mod of $toIterator(typecheckProject.moduleInfo)) {
												if (mod.file != fsPath_7115) { continue };
												const poss = [];
												let nearest = null;
												for (const node of $toIterator(mod.nodes)) {
													const data_7118 = typecheckProject.data.get(node);
													{
														let step = 0;
														const data_7119 = data_7118;
														if (step == 0 && data_7119 != null) { step = 1 };
														if (step == 1) {
															poss.push(DataHelper.nameOf(node) + ' ' + JSON.stringify(data_7119));
															const offset = 0;
															let width = 0;
															{
																const temp_7120 = node;
																switch (temp_7120&&temp_7120[0]) {
																case 25: {
																	const t = temp_7120[1];
																	width = 6 + NodeType.stringify(t).length
																} break;
																};
															};
															if ((line == data_7119.line) && (character >= data_7119.column + offset) && (character < data_7119.column + offset + width)) {
																nearest = node;
																break;
															};
														};
													};
												};
												{
													let step_7121 = 0;
													const nearest_7122 = nearest;
													if (step_7121 == 0 && nearest_7122 != null) { step_7121 = 1 };
													if (step_7121 == 1) {
														let code = '';
														const doc = '';
														{
															const temp_7123 = nearest_7122;
															switch (temp_7123&&temp_7123[0]) {
															case 25: {
																const t_7124 = temp_7123[1];
																{
																	const name = NodeType.stringify(t_7124);
																	code = 'class ' + name;
																}
															} break;
															
															case 39: {
																const t_7125 = temp_7123[1];
																{
																	const name_7126 = NodeType.stringify(t_7125);
																	code = 'enum ' + name_7126;
																}
															} break;
															};
														};
														response.push({code:code, markdown:doc + '\n\n' + line + ':!:' + character + ' = ' + '\n' + poss.join('\n') + '\n\n\n' + Node.stringify(nearest_7122)});
													};
												};
											};
											response.push({markdown:'Hover information not available for ' + fsPath_7115});
										} catch (temp_7117) {
											if (true) { 
											const e = temp_7117
											{
												response.push({markdown:'Fix errors in code to see type hints'});
											} } else
											
											throw temp_7117;
										} } else {
											response.push({markdown:'Hover information does not work with files not attached to any projects'});
										};
									}
								} break;
								
								case 'DocumentSymbolProvider': {
									{
										const fsPath_7127 = Path.resolve(command.payload.fsPath);
										const content_7128 = fileContents.get(fsPath_7127);
										const project_7129 = new Project();
										{
											let step_7130 = 0;
											const buffer = content_7128;
											let nodes = null;
											if (step_7130 == 0 && buffer != null) {
												nodes = parseOnly(fsPath_7127, content_7128, project_7129);
												step_7130 = 1;
											};
											if (step_7130 == 1 && nodes != null) { step_7130 = 2 };
											if (step_7130 == 2) {
												let lastPos = {line:1, start:1, end:1};
												const posToRange = (node, length) => {
													const data_7131 = project_7129.data.get(node);
													{
														let step_7132 = 0;
														const data_7133 = data_7131;
														if (step_7132 == 0 && data_7133 != null) { step_7132 = 1 };
														if (step_7132 == 1) { lastPos = {line:data_7133.line - 1, start:data_7133.column, end:data_7133.column + length} };
													};
													return lastPos;
												};
												const inferTypeFromExpr = (node_7134) => {
													{
														const temp_7135 = node_7134;
														switch (temp_7135&&temp_7135[0]) {
														case null: case undefined: {
															return null
														} break;
														
														case 0: {
															return 'String'
														} break;
														
														case 31: {
															return 'Array'
														} break;
														
														case 32: {
															return 'Map'
														} break;
														
														case 5: {
															return 'Int'
														} break;
														
														case 7: {
															return 'Float'
														} break;
														
														case 2: {
															return 'Bool'
														} break;
														};
													};
													return null;
												};
												const fieldToSymbol = (node_7136, isStatic) => {
													{
														const temp_7137 = node_7136;
														switch (temp_7137&&temp_7137[0]) {
														case 24: {
															const name_7138 = temp_7137[1];
															const t_7139 = temp_7137[2];
															const expr = temp_7137[3];
															const const_7140 = temp_7137[4];
															return {name:name_7138, detail:(((isStatic)? ('static ') : '')) + ((() => {
																const result = NodeType.stringify(t_7139);
																if (result != null) { return result };
																return (() => {
																	const result_7141 = inferTypeFromExpr(expr);
																	if (result_7141 != null) { return result_7141 };
																	return (((const_7140)? ('let') : 'var'));
																})();
															})()), kind:((const_7140)? (13) : 12), range:posToRange(node_7136, name_7138.length), children:[]}
														} break;
														
														case 22: {
															const name_7142 = temp_7137[1];
															const external = temp_7137[5];
															{
																const name_7143 = (() => {
																	const result_7144 = name_7142;
																	if (result_7144 != null) { return result_7144 };
																	return 'new';
																})();
																return {name:name_7143, detail:((external)? ('declare fun') : (((isStatic)? ('static fun') : (((name_7143 == 'new')? ('constructor') : 'fun'))))), kind:11, range:posToRange(node_7136, name_7143.length), children:[]};
															}
														} break;
														
														case 47: {
															const field = temp_7137[1];
															return fieldToSymbol(field, true)
														} break;
														
														case 51: {
															const type = temp_7137[1];
															{
																const name_7145 = NodeType.stringify(type);
																return {name:name_7145, detail:'', kind:21, range:posToRange(node_7136, name_7145.length), children:[]};
															}
														} break;
														
														case 10: {
															const a = temp_7137[1];
															const op = temp_7137[2];
															const b = temp_7137[3];
															{
																const name_7146 = Node.stringify(a);
																return {name:name_7146, detail:'= ' + Node.stringify(b), kind:21, range:posToRange(node_7136, name_7146.length), children:[]};
															}
														} break;
														
														case 13: {
															const e = temp_7137[1];
															const args = temp_7137[2];
															const argNames = temp_7137[3];
															{
																const name_7147 = Node.stringify(e);
																return {name:name_7147, detail:argNames.join(', '), kind:21, range:posToRange(node_7136, name_7147.length), children:[]};
															}
														} break;
														};
													};
													return null;
												};
												const fieldsToSymbols = (fields) => { return fields.map((field_7148) => (fieldToSymbol(field_7148, false))).filter((f) => (f != null)) };
												for (const node of $toIterator(nodes)) {
													const temp_7149 = node;
													switch (temp_7149&&temp_7149[0]) {
													case 24: {
														response.push(fieldToSymbol(node, false))
													} break;
													
													case 22: {
														response.push(fieldToSymbol(node, false))
													} break;
													
													case 25: {
														const t_7150 = temp_7149[1];
														const extend = temp_7149[2];
														const implement = temp_7149[3];
														const fields_7151 = temp_7149[4];
														{
															let detail = 'class';
															{
																let step_7152 = 0;
																const extend_7153 = extend;
																if (step_7152 == 0 && extend_7153 != null) { step_7152 = 1 };
																if (step_7152 == 1) { detail = 'extends ' + NodeType.stringify(extend_7153) };
															};
															const name_7154 = NodeType.stringify(t_7150);
															response.push({name:name_7154, detail:detail, kind:4, range:posToRange(node, name_7154.length), children:fieldsToSymbols(fields_7151)});
														}
													} break;
													
													case 39: {
														const t_7155 = temp_7149[1];
														const fields_7156 = temp_7149[2];
														const valuesType = temp_7149[3];
														{
															let detail_7157 = 'enum';
															{
																let step_7158 = 0;
																const valuesType_7159 = valuesType;
																if (step_7158 == 0 && valuesType_7159 != null) { step_7158 = 1 };
																if (step_7158 == 1) { detail_7157 = ': ' + NodeType.stringify(valuesType_7159) };
															};
															const name_7160 = NodeType.stringify(t_7155);
															response.push({name:name_7160, detail:detail_7157, kind:9, range:posToRange(node, name_7160.length), children:fieldsToSymbols(fields_7156)});
														}
													} break;
													};
												};
												fileOutline.set(fsPath_7127, response);
											} else {
												let step_7161 = 0;
												const cache = (fileOutline.get(fsPath_7127));
												if (step_7161 == 0 && cache != null) { step_7161 = 1 };
												if (step_7161 == 1) {
													console.log('from cache: ' + fsPath_7127 + ' ' + cache.length);
													for (const item of $toIterator(cache)) {
														response.push(item);
													};
												} else {
													console.log('notInCache: ' + fsPath_7127);
													response.push({fail:'notInCache', fsPath:fsPath_7127});
												};
											};
										};
									}
								} break;
								
								case 'SyncFileContents': {
									{
										const fsPath_7162 = command.payload.fsPath;
										const content_7163 = command.payload.content;
										fileContents.set(Path.resolve(fsPath_7162), Buffer.from(content_7163));
									}
								} break;
								
								case 'DiscardFileContents': {
									{
										const fsPath_7164 = command.payload.fsPath;
										fileContents.delete(Path.resolve(fsPath_7164));
									}
								} break;
								
								case 'AutocheckProject': {
									{
										const fsPath_7165 = command.payload.fsPath;
										console.log('AutocheckProject', fsPath_7165);
										const project_7166 = findProjectFile(fsPath_7165);
										if (project_7166.found == true) { try {
											const e_7168 = new Main().typecheck(project_7166.dir);
											const errors_7169 = e_7168.errors;
											if (errors_7169 == null) { console.log('e -->', e_7168) };
											for (const error of $toIterator(errors_7169)) {
												response.push(error);
											};
											if (errors_7169.length == 0 || errors_7169.length == null) { console.log('no errors', e_7168) } else {
												console.log('errors:', e_7168);
											};
										} catch (temp_7167) {
											if (true) { 
											const e = temp_7167
											{
												console.log('Compiler stopped with exception', e);
												response.push(new CompilerError(6, 'Compiler stopped with exception: ' + JSON.stringify(e.message), 0, 0, project_7166.dir + Path.sep + 'hexa.json'));
											} } else
											
											throw temp_7167;
										} } else {
											const resolved = Path.resolve(fsPath_7165);
											{
												let step_7170 = 0;
												const content_7171 = fileContents.get(resolved);
												if (step_7170 == 0 && content_7171 != null) { step_7170 = 1 };
												if (step_7170 == 1) {
													const errors_7172 = syntaxCheckOnly(resolved, content_7171);
													for (const error of $toIterator(errors_7172)) {
														response.push(error);
													};
												};
											};
											console.log('Not found project for', fsPath_7165);
										};
									}
								} break;
								
								case 'FindProjectFile': {
									{
										const fsPath_7173 = command.payload;
										response.push(findProjectFile(fsPath_7173));
									}
								} break;
								
								case 'CompletionItemProvider': {
									{
										const fsPath_7174 = Path.resolve(command.payload.fsPath);
										const project_7175 = findProjectFile(fsPath_7174);
										if (project_7175.found == true) { try {
											const main_7177 = new Main();
											const e_7178 = main_7177.typecheck(project_7175.dir);
											const completes = [];
											const errors_7179 = e_7178.errors;
											const typecheckProject_7180 = main_7177.typecheckProject;
											for (const mod of $toIterator(typecheckProject_7180.moduleInfo)) {
												if (mod.file != fsPath_7174) { continue };
												console.log('mod.file', mod.file, mod.path, Path.relative(project_7175.dir, mod.file));
												const available = [];
												for (const name of $toIterator(mod.imported.keys())) {
													available.push(name);
												};
												for (const name of $toIterator(mod.exported.keys())) {
													available.push(name);
												};
												for (const name of $toIterator(typecheckProject_7180.globals.keys())) {
													if ((!available.includes(name))) { available.push(name) };
												};
												for (const name of $toIterator(available)) {
													let node_7181 = mod.exported.get(name);
													let imported = '';
													let file_7182 = '';
													if (node_7181 == null) {
														node_7181 = mod.imported.get(name);
														{
															let step_7183 = 0;
															const temp_7184 = node_7181 != null;
															let mod = null;
															if (step_7183 == 0 && temp_7184 != false) {
																mod = typecheckProject_7180.mapModules.get(node_7181);
																step_7183 = 1;
															};
															if (step_7183 == 1 && mod != null) { step_7183 = 2 };
															if (step_7183 == 2) {
																imported = mod.path;
																file_7182 = mod.file;
															};
														};
													};
													if (node_7181 == null) {
														imported = '*';
														node_7181 = typecheckProject_7180.globals.get(name);
													};
													const complete = {imported:imported, file:file_7182, name:name, detail:name, kind:0};
													{
														const temp_7185 = node_7181;
														switch (temp_7185&&temp_7185[0]) {
														case 25: {
															const t_7186 = temp_7185[1];
															{
																complete.detail = 'class ' + NodeType.stringify(t_7186) + ' { … }';
																complete.kind = 6;
															}
														} break;
														
														case 39: {
															const t_7187 = temp_7185[1];
															const valuesType_7188 = temp_7185[3];
															{
																{
																	let step_7189 = 0;
																	const valuesType_7190 = valuesType_7188;
																	if (step_7189 == 0 && valuesType_7190 != null) { step_7189 = 1 };
																	if (step_7189 == 1) { complete.detail = 'enum ' + NodeType.stringify(t_7187) + ' : ' + NodeType.stringify(valuesType_7190) + ' { … }' } else {
																		complete.detail = 'enum ' + NodeType.stringify(t_7187) + ' { … }';
																	};
																};
																complete.kind = 12;
															}
														} break;
														
														case 24: {
															const const_7191 = temp_7185[4];
															{
																complete.detail = (((const_7191)? ('let ') : 'var ')) + name;
																complete.kind = 5;
															}
														} break;
														
														case 22: {
															{
																complete.detail = 'fun ' + name + '() { … }';
																complete.kind = 2;
															}
														} break;
														};
													};
													completes.push(complete);
												};
												break;
											};
											response.push(completes);
										} catch (temp_7176) {
											if (true) { 
											const e = temp_7176
											{
											} } else
											
											throw temp_7176;
										} } else {
											response.push([]);
										};
									}
								} break;
								
								default: 
								console.log('Unknown command kind', command.kind, command)
								};
							};
							responseToAll.push(response);
						};
						res.writeHead(200, {});
						res.write(JSON.stringify(responseToAll));
						const end = Date.now();
						const heapUsed = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
						console.log(('[Response finished in ' + (end - start) + ' ms, uses ' + (heapUsed) + ' MB]'));
						res.end();
					};
				} else {
					res.writeHead(400, {});
					res.write('[]');
					res.end();
				};
			});
		};
		const server = http.createServer((req_7192, res_7193) => (handleRequest(project_7109, req_7192, res_7193)));
		server.listen(port_7108, () => ((() => {
			console.log('Compiler version:', version);
			return console.log('Ready to Hexa!');
		})()));
	} };
	}
	function hasOwnProperty(object, name) { return object.hasOwnProperty(name) };
	function btoa(text_3686) { return Buffer.from(text_3686, 'binary').toString('base64', 0, 1073741824) };
	function atob(base64) { return Buffer.from(base64, 'base64').toString('binary', 0, 1073741824) };
	function getRenamingStrategy(decorators) {
		let strategy = null;
		{
			let step = 0;
			const asTitleCase = Decorator.getDecorator(decorators, 'asTitleCase');
			if (step == 0 && asTitleCase != null) { step = 1 };
			if (step == 1) { strategy = 0 };
		};
		{
			let step_3688 = 0;
			const asIs = Decorator.getDecorator(decorators, 'asIs');
			if (step_3688 == 0 && asIs != null) { step_3688 = 1 };
			if (step_3688 == 1) {
				if (strategy != null) { throw 'Renaming strategy is already chosen: ' + strategy };
				strategy = 1;
			};
		};
		return strategy;
	};
	function availableGenerators(name) {
		const temp = name;
		switch (temp) {
		case 'js': {
			return 'JavaScript'
		} break;
		
		case 'native': {
			return 'Native'
		} break;
		
		case 'c': {
			return 'Native'
		} break;
		
		default: 
		return null
		};
	};
	function setLibrary(target, options, defines) {
		const files = [];
		defines.native = (() => {
			const result = defines.native;
			if (result != null) { return result };
			return false;
		})();
		defines.js = (() => {
			const result_6979 = defines.js;
			if (result_6979 != null) { return result_6979 };
			return false;
		})();
		{
			const temp_6980 = target;
			switch (temp_6980) {
			case 'JavaScript': {
				{
					defines.js = (() => {
						const result_6981 = defines.js;
						if (result_6981 != null) { return result_6981 };
						return true;
					})();
					files.push('/js/js');
					if (options.includes('nodejs')) { files.unshift('/nodejs/nodejs') };
					if (options.includes('browser')) { files.unshift('/browser/html') };
				}
			} break;
			
			case 'Native': {
				{
					defines.native = (() => {
						const result_6982 = defines.native;
						if (result_6982 != null) { return result_6982 };
						return true;
					})();
					const is64 = (((defines.bit64 == null))? (true) : (defines.bit64 == true));
					defines.bit64 = ((is64)? (true) : false);
					defines.bit32 = ((is64)? (false) : true);
					defines.native = (() => {
						const result_6983 = defines.native;
						if (result_6983 != null) { return result_6983 };
						return true;
					})();
					defines.bundledRuntime = (() => {
						const result_6984 = defines.bundledRuntime;
						if (result_6984 != null) { return result_6984 };
						return true;
					})();
					files.push('/c/c');
					files.push('/c/array');
					files.push('/c/string');
					files.push('/c/map');
					files.push('/c/runtime');
					for (const option of $toIterator(options)) {
						const temp_6985 = option;
						switch (temp_6985) {
						default: 
						console.log(('Option `' + (option) + '` ignored for target `' + (target) + '`'))
						};
					};
				}
			} break;
			};
		};
		return files;
	};
	function indigo(text) { return '\x1b[35m' + text + '\x1b[0m' };
	function blue(text_6986) { return '\x1b[34m' + text_6986 + '\x1b[0m' };
	function ocean(text_6987) { return '\x1b[36m' + text_6987 + '\x1b[0m' };
	function ignoreRestArguments() { if (process.argv.length > 0) {
		const args = process.argv;
		console.log('Argument' + (((args.length > 1)? ('s') : '')) + ' \x1b[36m`' + args.join('`\x1b[0m, \x1b[36m`') + '`\x1b[0m ignored');
	} };
	function quote(text_6988) {
		const result = [];
		let even = false;
		let current = '\x1b[0m';
		if (text_6988.startsWith('\x1b[')) { current = text_6988.substr(0, 5) };
		for (const string of $toIterator(text_6988.split('`'))) {
			if (even == false) { result.push(string) } else {
				result.push('\x1b[33m');
				result.push('`');
				result.push(string);
				result.push('`');
				result.push(current);
			};
			even = (!even);
		};
		return result.join('');
	};
	function printVersion() {
		console.log(indigo(('Hexa ' + (version) + ' on node.js ') + process_3671.versions.node));
		process.argv.shift();
		ignoreRestArguments();
		process.exit(0);
	};
	function printHelp() {
		console.log(indigo(('Hexa ' + (version) + ' on node.js ') + process_3671.versions.node));
		console.log(ocean('Use `hexa hexa.json` to simply build `default` target'));
		console.log(quote('`hexa init` creates new project by asking some questions'));
		console.log(quote('`hexa hexa.json targets` show available targets for the project'));
		console.log(quote('`hexa help` shows this help'));
		console.log(quote('`hexa version` shows compiler version'));
		console.log(quote('`hexa listen` or `hexa listen 3978` starts language server on the selected port'));
		process.argv.shift();
		ignoreRestArguments();
		process.exit(0);
	};
	function question(query) {
		process_3671.stdout.write(query);
		const bufsize = 256;
		const buf = Buffer.alloc(bufsize);
		let bytesRead = 0;
		const stdin = (((process.platform == 'win32'))? (process_3671.stdin.fd) : Fs.openSync('/dev/stdin', 'rs'));
		try { bytesRead = Fs.readSync(stdin, buf, 0, bufsize) } catch (temp) {
			if (true) { 
			const e = temp
			{
				const e = e;
				if (e.code == 'EAGAIN') { return 'ERROR: interactive stdin input not supported.' };
				if (e.code == 'EOF') { return '' };
				throw e;
			} } else
			
			throw temp;
		};
		if (bytesRead == 0) { return '' };
		const answer = buf.toString('utf8', 0, bytesRead).trim();
		return answer;
	};
	function symlink() {
		const temp = (process.platform);
		switch (temp) {
		case 'linux': case 'mac???TODO': {
			{
				Fs.renameSync('./hexa', '/usr/bin/hexa');
				console.log('Symlinked successfully!');
			}
		} break;
		
		case 'win32???TODO': {
			{
			}
		} break;
		
		default: 
		{
			console.log(('Cannot symlink on ' + (process.platform) + '. You must add hexa to your PATH manually.'));
			process_3671.exit(1);
		}
		};
	};
	function init() {
		if (Fs.existsSync('hexa.json')) {
			const create = question('Hexa package \'hexa.json\' already exists here. Create new? (no): ');
			if (create == '' || (!isYes(create))) { process_3671.exit(1) };
		};
		const currentDirTmp = process.cwd().split(Path.sep);
		const packageFileName = process.cwd() + Path.sep + 'hexa.json';
		const currentDir = currentDirTmp[currentDirTmp.length - 1];
		let name = question(('Enter package name (' + (currentDir) + '): '));
		if (name == '') { name = currentDir };
		let version_7100 = question('Enter package version (1.0.0): ');
		if (version_7100 == '') { version_7100 = '1.0.0' };
		const description = question('Enter package description: ');
		let main = question('Enter main file (main.hexa): ');
		if (main == '') { main = 'main.hexa' };
		const target = {name:'default', generator:'js', output:name, options:[]};
		const generator = question('Enter target (Node.js/JavaScript):\n1. Node.js/JavaScript\n2. Web/JavaScript\n3. Raw/JavaScript\n> ').trim();
		if (generator == '2') {
			target.options.push('browser');
			target.output += '.js';
		} else if (generator == '3') { target.output += '.js' } else {
			target.options.push('nodejs');
			target.output += '.js';
		};
		while ((!main.endsWith('.hexa'))) {
			process_3671.stdout.write('Wrong file name. Must end with \'.hexa\'.\n');
			main = question('Enter main file (main.hexa): ');
		};
		const user = (() => {
			const result = require('os').userInfo().username;
			if (result != null) { return result };
			return process.env['USERNAME'];
		})();
		let author = question(('Enter package author name (' + (user) + '): '));
		if (author == '') { author = user };
		let license = question('Enter license (LGPL-3.0-only): ');
		if (license == '') { license = 'LGPL-3.0-only' };
		const pack = {name:name, version:version_7100, description:description, author:author, license:license, targets:[target], entry:main.split('.')[0]};
		const extras = [];
		let addGit = false;
		if (Fs.existsSync('.git')) { if ((!Fs.existsSync('.gitignore')) || (!Fs.existsSync('.gitattributes'))) {
			const confirm = question('Create additional git files(.gitignore, .gitattributes)? (yes): ').toLowerCase().trim();
			if (isYes(confirm)) {
				if ((!Fs.existsSync('.gitignore'))) { extras.push('.gitignore') };
				if ((!Fs.existsSync('.gitattributes'))) { extras.push('.gitattributes') };
				addGit = true;
			};
		} };
		const addMain = Fs.existsSync(main) == false;
		if (addMain) { extras.push(main) };
		const packageStr = JSON.stringify(pack, null, '\t').split('\r\n').join('\n').split('\n').join('\r\n');
		const extrasStr = ((extras.length > 0)? ('\nAnd \'' + extras.join('\', \'') + '\'') : '');
		const answ = question(('About to write to: ' + (packageFileName) + ':\n' + (packageStr) + '' + (extrasStr) + '\nIs this ok? (yes): '));
		if ((!isYes(answ))) {
			console.log('Exiting without changes');
			process_3671.exit(1);
		};
		Fs.writeFileSync('hexa.json', packageStr + '\r\n');
		if ((addMain) && ((!Fs.existsSync(main)))) { Fs.writeFileSync(main, 'console.log("Thank you for choosing Hexa")\r\n') };
		if ((addGit) && ((!Fs.existsSync('.gitattributes')))) { Fs.writeFileSync('.gitattributes', ['# Auto detect text files and perform LF normalization', '* text=auto', ''].join('\r\n')) };
		if ((addGit) && ((!Fs.existsSync('.gitignore')))) { Fs.writeFileSync('.gitignore', ['# Mac & Win', '*~', '._*', '*DS_Store*', '.DS_Store', '.DS_Store?', '.Spotlight-V100', '.Trashes', 'ehthumbs.db', 'Thumbs.db', '*Thumbs.db', '__MACOSX', '', '# Custom', '*.map', target.output, 'node_modules', ''].join('\r\n')) };
		process_3671.stdout.write('Hexa package initialized!');
	};
	function isYes(answer) { return ['y', 'yes', ''].includes(answer.toLowerCase().trim()) };
	function findProjectFile(fsPath) {
		let lastPath = '*';
		let dir = Path.dirname(fsPath);
		let found = false;
		while (lastPath != dir) {
			if (Fs.existsSync(Path.join(dir, 'hexa.json'))) {
				found = true;
				break;
			};
			lastPath = dir;
			dir = Path.dirname(dir);
		};
		return {found:found, dir:dir};
	};
	function syntaxCheckOnly(file, content) {
		try {
			const tokens = Lexer.tokenize(content, file);
			try { const parser = Parser.parseNodes(tokens, new Project(), true) } catch (temp_7101) {
				if (temp_7101 instanceof CompilerErrors) { 
				const e = temp_7101
				{
					const errors_7102 = e.errors;
					return errors_7102;
				} } else
				
				throw temp_7101;
			};
		} catch (temp) {
			if (temp instanceof CompilerErrors) { 
			const e = temp
			{
				const errors = e.errors;
				return errors;
			} } else
			
			throw temp;
		};
		return [];
	};
	function parseOnly(file_7103, content_7104, project) {
		try {
			const tokens_7106 = Lexer.tokenize(content_7104, file_7103);
			try { return Parser.parseNodes(tokens_7106, project, true) } catch (temp_7107) {
				if (temp_7107 instanceof CompilerErrors) { 
				const e = temp_7107
				{
					return null;
				} } else
				
				throw temp_7107;
			};
		} catch (temp_7105) {
			if (temp_7105 instanceof CompilerErrors) { 
			const e = temp_7105
			{
				return null;
			} } else
			
			throw temp_7105;
		};
		return null;
	};
	var alternativeErrorFormat = false
	var colorIndigo = '\x1b[35m'
	var colorBlue = '\x1b[34m'
	var colorYellow = '\x1b[33m'
	var colorOcean = '\x1b[36m'
	var colorDefault = '\x1b[0m'
	var version = selfVersion
	var fileContentsu = new Map()
	var fileContents = new Map()
	var fileOutline = new Map()
	var asss = 13
	{
		{
			const args = ArgumentsParsingEngine.engage();
			{
				const temp = args;
				switch (temp&&temp[0]) {};
			};
			{
				const temp_7194 = process.argv[0];
				switch (temp_7194) {
				case 'listen': {
					const temp_7195 = new Server(process.argv[1])
				} break;
				
				case 'stop': {
					{
					}
				} break;
				
				case 'help': {
					printHelp()
				} break;
				
				case 'version': {
					printVersion()
				} break;
				
				case 'symlink': {
					symlink()
				} break;
				
				case 'init': {
					init()
				} break;
				
				default: 
				new Main().perform(false)
				};
			};
		}
	}
})();