U0 ParseVarInit(CCompCtrl *cc, U8 **_dst, CHashClass *tmpc, CArrayDim *tmpad,
				U8 *data_addr_rip, U8 **_base, Bool data_heap, I64 pass)
{
	U8					*dst = *_dst, *machine_code;
	I64					 i, j, r, old_flags, type, size;
	CMemberList			*tmpm;
	CIntermediateCode	*tmpi;
	CAOTCtrl			*aotc = cc->aotc;
	CAOTAbsAddr			*tmpa;
	CAOTImportExport	*tmpie;
	Bool				 is_str;

	tmpc = OptClassFwd(tmpc);
	if (tmpm = tmpc->member_list_and_root)
	{
		if (cc->token != '{')
			LexExcept(cc, "Expecting '{' at ");
		LexPopNoRestore(cc);
		LexPush(cc);
		Lex(cc);
		while (tmpm)
		{
			ParseVarInit2(cc, &dst, tmpm->member_class, &tmpm->dim, data_addr_rip, _base, data_heap, pass);
			if (cc->token == ',')
				Lex(cc);
			tmpm = tmpm->next;
		}
		LexPopNoRestore(cc);
		if (cc->token != '}')
			LexExcept(cc, "Missing '}' at ");
		Lex(cc);
	}
	else
	{
		if (tmpc->ptr_stars_count == 1 && ((tmpc - 1)->raw_type == RT_I8 || (tmpc - 1)->raw_type == RT_U8) && !tmpad &&
				cc->token == TK_STR)
			is_str = TRUE;
		else
			is_str = FALSE;
		if (cc->flags & CCF_AOT_COMPILE && is_str)
		{
			LexPopNoRestore(cc);
			machine_code = LexExtStr(cc, &i);
			if (pass == 2)
			{
				tmpa = CAlloc(sizeof(CAOTAbsAddr));
				tmpa->next = aotc->abss;
				tmpa->type = AAT_ADD_U64;
				aotc->abss = tmpa;
				tmpa->rip = data_addr_rip + dst - *_base;
				*dst(I64 *) = aotc->rip;
				for (j = 0; j < i; j++)
					AOTStoreCodeU8(cc, machine_code[j]);
			}
			Free(machine_code);
		}
		else
		{
			old_flags = cc->flags;
			cc->flags = CCF_NO_ABSS | cc->flags & ~(CCF_AOT_COMPILE | CCF_HAS_MISC_DATA | CCF_NOT_CONST);
			machine_code = LexExpression2Bin(cc, &type);
			if (old_flags & CCF_AOT_COMPILE && cc->flags & CCF_NOT_CONST && !Bt(&cc->opts, OPTf_GLOBALS_ON_DATA_HEAP))
			{
				cc->flags = cc->flags & ~CCF_NO_ABSS | CCF_AOT_COMPILE;
				Free(machine_code);
				if (pass == 2)
				{
					MemSet(dst, 0, tmpc->size);
					LexPopRestore(cc);
					Lex(cc);
					COCPush(cc);
					COCInit(cc);
					ICAdd(cc, IC_ABS_ADDR, data_addr_rip, tmpc + 1);
					ICAdd(cc, IC_IMM_I64, dst - *_base, tmpc + 1);
					ICAdd(cc, IC_ADD, 0, tmpc + 1);
					if (!ParseExpression(cc, NULL, TRUE))
						throw('Compiler');
					tmpi = cc->coc.coc_head.last;
					if (tmpi->ic_code == IC_END_EXP) {
						tmpi->ic_code = IC_NOP1;
						tmpi->ic_flags = 0;
					}
					ICAdd(cc, IC_ASSIGN, 0, tmpc);
					ICAdd(cc, IC_END_EXP, 0, tmpc, ICF_RES_NOT_USED);
					ICAdd(cc, IC_RET, 0, 0);
					if (machine_code = COCCompile(cc, &size, NULL, NULL))
					{
						tmpie = CAlloc(sizeof(CAOTImportExport));
						tmpie->type = IET_MAIN;
						tmpie->rip = cc->aotc->rip;
						QueueInsert(tmpie, cc->aot->last_ie);
						for (i = 0; i < size; i++)
							AOTStoreCodeU8(cc, machine_code[i]);
						Free(machine_code);
					}
					COCPop(cc);
				}
				else
					LexPopNoRestore(cc);
			}
			else
			{
				LexPopNoRestore(cc);
				if (!machine_code)
					throw('Compiler');
				r = Call(machine_code);
				if (!(cc->flags & CCF_HAS_MISC_DATA) || pass == 1)
					Free(machine_code);

				if (type == RT_F64 && tmpc->raw_type != RT_F64)
					r = r(F64);
				else if (type != RT_F64 && tmpc->raw_type == RT_F64)
					r(F64) = r;
				MemCopy(dst, &r, tmpc->size);
			}
		}
		dst += tmpc->size;
		cc->flags = cc->flags & ~CCF_NO_ABSS | old_flags & (CCF_HAS_MISC_DATA | CCF_AOT_COMPILE);
	}
	*_dst = dst;
}

class CVI2
{
	CVI2 *next, *last;
	U0	  base;
};

U0 ParseVarInit2(CCompCtrl *cc, U8 **_dst, CHashClass *tmpc, CArrayDim *tmpad,
				 U8 *data_addr_rip, U8 **_base, Bool data_heap, I64 pass)
{
	I64			 i, j, count;
	U8			*st, *_b;
	CVI2		 head, *tmpvi, *tmpvi1;
	CArrayDim	*tmpad1;

	tmpc = OptClassFwd(tmpc);
	if (tmpad1 = tmpad->next)
	{
		if (!tmpc->ptr_stars_count && (tmpc->raw_type == RT_I8 || tmpc->raw_type == RT_U8) && cc->token == TK_STR)
		{
			LexPopNoRestore(cc);
			st = LexExtStr(cc,&i);
			if (tmpad1->count < 0)
			{//[]
				tmpad1->count = i;
				tmpad->total_count = i * tmpad1->total_count;
				Free(*_base);
				if (data_heap)
					*_base = MAlloc(i);
				else
					*_base = MAlloc(i, Fs->code_heap);
				MemCopy(*_base, st, i);
				*_dst = *_base + i;
			}
			else
			{
				MemCopy(*_dst, st, tmpad1->count);
				*_dst += tmpad1->count;
			}
			Free(st);
			LexPush(cc);
		}
		else
		{
			if (cc->token == '{')
			{
				LexPopNoRestore(cc);
				LexPush(cc);
				Lex(cc);
			}
			if (tmpad1->count < 0)
			{//[]
				QueueInit(&head);
				count = 0;
				while (cc->token != '}')
				{
					tmpvi = MAlloc(offset(CVI2.base) + tmpad1->total_count * tmpc->size);
					_b = &tmpvi->base;
					ParseVarInit2(cc, &_b, tmpc, tmpad1, data_addr_rip, _base, data_heap, pass);
					QueueInsert(tmpvi, head.last);
					if (cc->token == ',')
						Lex(cc);
					count++;
				}
				Lex(cc); //skip '}'
				tmpad1->count = count;
				tmpad->total_count = count * tmpad1->total_count;
				j = tmpad1->total_count * tmpc->size;
				i = count * j;
				Free(*_base);
				if (data_heap)
					*_base = _b = MAlloc(i);
				else
					*_base = _b = MAlloc(i, Fs->code_heap);
				tmpvi = head.next;
				while (tmpvi != &head)
				{
					tmpvi1 = tmpvi->next;
					MemCopy(_b, &tmpvi->base, j);
					_b += j;
					Free(tmpvi);
					tmpvi = tmpvi1;
				}
				*_dst = _b;
			}
			else
			{
				for (i = 0; i < tmpad1->count; i++)
				{
					ParseVarInit2(cc, _dst, tmpc, tmpad1, data_addr_rip, _base, data_heap, pass);
					if (tmpad1->count > 1 && cc->token == ',')
						Lex(cc);
				}
				if (cc->token == '}')
					Lex(cc);
			}
		}
	}
	else
	{
		ParseVarInit(cc, _dst, tmpc, tmpad1, data_addr_rip, _base, data_heap, pass);
		LexPush(cc);
	}
}

U0 ParseGlobalInit(CCompCtrl *cc, CHashGlobalVar *tmpg, I64 pass)
{
	U8 *dst = tmpg->data_addr;

	ParseVarInit2(cc, &dst, tmpg->var_class, &tmpg->dim, tmpg->data_addr_rip, &tmpg->data_addr,
				  Bt(&cc->opts, OPTf_GLOBALS_ON_DATA_HEAP) || Bt(&cc->flags, CCf_AOT_COMPILE), pass);
}

U0 ParseStaticInit(CCompCtrl *cc, CMemberList *tmpm, I64 pass)
{
	U8					*machine_code, *dst = tmpm->static_data;
	CHashClass			*tmpc = tmpm->member_class;
	I64					 i, size;
	CAOTImportExport	*tmpie;

	if (cc->flags & CCF_AOT_COMPILE && pass == 2)
	{
		COCPush(cc);
		COCInit(cc);
	}
	ParseVarInit2(cc, &dst, tmpc, &tmpm->dim, tmpm->static_data_rip, &tmpm->static_data,
				  Bt(&cc->flags, CCf_AOT_COMPILE), pass);
	if (cc->flags & CCF_AOT_COMPILE && pass == 2)
	{
		if (cc->coc.coc_head.next != &cc->coc.coc_head)
		{
			ICAdd(cc, IC_RET, 0, 0);
			if (machine_code = COCCompile(cc, &size, NULL, NULL))
			{
				if (pass == 2)
				{
					tmpie = CAlloc(sizeof(CAOTImportExport));
					tmpie->type = IET_MAIN;
					tmpie->rip = cc->aotc->rip;
					QueueInsert(tmpie, cc->aot->last_ie);
					for (i = 0; i < size; i++)
						AOTStoreCodeU8(cc, machine_code[i]);
				}
				Free(machine_code);
			}
		} //TODO: else del misc?
		COCPop(cc);
	}
}

U0 ParseArrayDims(CCompCtrl *cc, I64 mode, CArrayDim *dim)
{//dim->next!=0 for array
	CArrayDim	*tmpad, *tmpad1;
	I64			 j;

	dim->next = NULL;
	dim->count = 0;
	dim->total_count = 1;
	tmpad1 = &dim->next;
	if (cc->token == '[')
	{
		if (mode.u8[1] == PRS1B_FUN_ARG)
			LexExcept(cc, "No arrays in fun args at ");
		do
		{
			if (Lex(cc) == ']' && !dim->next)
				j = 0;
			else
			{
				if ((j = LexExpressionI64(cc)) < 0)
					LexExcept(cc, "Invalid array size at ");
			}
			tmpad = MAlloc(sizeof(CArrayDim));
			tmpad->next = NULL;
			tmpad1 = &dim;
			do
			{
				tmpad1->total_count *= j;
				if (!tmpad1->next)
				{
					tmpad1->next = tmpad;
					break;
				}
				tmpad1 = tmpad1->next;
			}
			while (tmpad1);

			tmpad1 = tmpad;
			tmpad->count = j;
			tmpad->total_count = 1;
			if (cc->token != ']')
				LexExcept(cc, "Missing ']' at ");
		}
		while (Lex(cc) == '[');
	}
}

CHashClass *ParseType(CCompCtrl *cc, CHashClass **_tmpc1, I64 *_mode, CMemberList *tmpm, U8 **_ident, CHashFun **_fun_ptr,
					  CHashExport **_tmpex, CArrayDim *tmpad, I64 fsp_flags)
{
	I64			 k, ptr_stars_count, mode = *_mode;
	CHashClass	*tmpc1 = *_tmpc1, *tmpc2;
	CHashFun	*fun_ptr = NULL;
	CHashExport	*tmpex = NULL;

	pt_start:
	if (!tmpc1 || !(tmpc1->type & (HTT_CLASS | HTT_INTERNAL_TYPE)))
		LexExcept(cc, "Invalid class at ");

	ptr_stars_count = 0;
	while (cc->token == '*')
	{
		if (mode.u8[1])
		{
			LexPopNoRestore(cc);
			LexPush(cc);
		}
		Lex(cc);
		tmpc1++;
		if (++ptr_stars_count > PTR_STARS_NUM)
			LexExcept(cc, "Too many *'s at ");
	}

	k = ParseKeyWord(cc);
	if (k == KW_UNION || k == KW_CLASS)
	{
		Lex(cc);
		tmpc2 = ParseClass(cc, k, fsp_flags, mode & 255 == PRS0_EXTERN);
		tmpc2->fwd_class = tmpc1;
		tmpc1 = tmpc2;
		if (_tmpc1)
			*_tmpc1 = tmpc1;
		mode = PRS0_NULL|PRS1_NULL;
		goto pt_start;
	}

	if (cc->token == '(')
	{
		if (Lex(cc) != '*')
			LexExcept(cc, "Expecting '*' at ");
		ptr_stars_count = 1; //fun_ptr
		while (Lex(cc) == '*')
			ptr_stars_count++; //fun_ptr
		if (ptr_stars_count > PTR_STARS_NUM)
			LexExcept(cc, "Too many *'s at ");
	}
	else
		ptr_stars_count = -1; //fun_ptr

	if (_ident)
	{
		if (cc->token == TK_IDENT)
		{
			tmpex = cc->hash_entry;
			*_ident = cc->cur_str;
			cc->cur_str = NULL;
			Lex(cc);
		}
		else
		{
			if (!mode.u8[1])
				*_ident = NULL;
			else if (cc->token == ',' || cc->token == ';' || cc->token == ')')
			{
				tmpex = NULL;
				*_ident = StrNew("_anon_");
				tmpm->flags |= MLF_NO_UNUSED_WARN;
			}
			else
				LexExcept(cc, "Expecting identifier at ");
		}
	}

	if (ptr_stars_count >= 0)
	{ //fun_ptr
		if (cc->token != ')')
			LexExcept(cc, "Missing ')' at ");
		if (Lex(cc) != '(')
			LexExcept(cc, "Expecting '(' at ");
		fun_ptr = ParseFunJoin(cc, tmpc1, NULL, fsp_flags) + ptr_stars_count;
		tmpc1 = cmp.internal_types[RT_PTR] + ptr_stars_count;
	}
	ParseArrayDims(cc, mode, tmpad);

	tmpc2 = OptClassFwd(tmpc1);
	if (tmpc2->ptr_stars_count)
	{
		tmpc2 -= tmpc2->ptr_stars_count;
		if (tmpc2->type & HTT_INTERNAL_TYPE && !tmpc2->size)
			LexWarn(cc, "use \"U8 *\" instead of \"U0 *\" at ");
	}

	if (_mode)
		*_mode = mode;
	if (_fun_ptr)
		*_fun_ptr = fun_ptr;
	if (_tmpex)
		*_tmpex = tmpex;

	return tmpc1;
}

U0 ParseDotDotDot(CCompCtrl *cc, CHashFun *tmpf, I64 _reg)
{
	CMemberList	*tmpm;
	CArrayDim	*tmpad;

	Bts(&tmpf->flags, Ff_DOT_DOT_DOT);

	Lex(cc);
	tmpm = MemberListNew(_reg);
	tmpm->flags = MLF_DOT_DOT_DOT;
	tmpm->member_class = cmp.internal_types[RT_I64];
	tmpm->str = StrNew("argc");
	tmpm->offset = tmpf->size;
	tmpm->size = 8;
	tmpf->size += 8;
	MemberAdd(cc, tmpm, tmpf, PRS1B_FUN_ARG);

	tmpm = MemberListNew(_reg);
	tmpm->flags = MLF_DOT_DOT_DOT;
	tmpm->member_class = cmp.internal_types[RT_I64];
	tmpm->str = StrNew("argv");
	tmpm->dim.total_count = 127; //arbitrary
	tmpm->dim.next = tmpad = MAlloc(sizeof(CArrayDim));
	tmpad->next = NULL;
	tmpad->count = 127; //arbitrary
	tmpad->total_count = 1;
	tmpm->offset = tmpf->size;
	tmpm->size = 8; //Close enough
	tmpf->size += 8;//Close enough
	MemberAdd(cc, tmpm, tmpf, PRS1B_FUN_ARG);

	if (cc->token == ')')
		Lex(cc);
}

U0 ParseVarList(CCompCtrl *cc, CHashClass *tmpc, I64 mode, I64 union_base=0)
{
	I64				 i, k, old_flags = cc->flags, old_flags2, type, _reg;
	CHashClass		*tmpc1, *tmpc2;
	CHash			*tmph;
	CMemberList		*tmpm;
	CMemberListMeta	*tmp_meta;
	U8				*machine_code;
	Bool			 undef_array_size, first;

	cc->flags |= CCF_DONT_MAKE_RES;
	if (mode.u8[1] == PRS1B_CLASS)
		cc->flags |= CCF_CLASS_DOL_OFFSET;
	if ((mode.u8[1] != PRS1B_LOCAL_VAR && mode.u8[1] != PRS1B_STATIC_LOCAL_VAR || mode & PRSF_UNION) &&
			(cc->token == '(' || cc->token == '{'))
		Lex(cc);
	while (TRUE)
	{
		if (mode & PRSF_UNION)
			cc->class_dol_offset = union_base;
		else
			cc->class_dol_offset = tmpc->size;
		while (cc->token == ';')
			Lex(cc);
		while (cc->token == '$$') {
			if (Lex(cc) != '=') //skip $$
				LexExcept(cc, "Expecting '=' at ");
			Lex(cc); //skip =
			cc->class_dol_offset = LexExpression(cc);
			if (-cc->class_dol_offset > tmpc->neg_offset)
				tmpc->neg_offset = -cc->class_dol_offset;
			if (mode & PRSF_UNION)
				union_base = cc->class_dol_offset;
			else
				tmpc->size = cc->class_dol_offset;
			if (cc->token != ';')
				LexExcept(cc, "Missing ';' at");
			Lex(cc); //skip ;
		}
		if (cc->token == ')' || cc->token == '}')
		{
			Lex(cc);
			goto pvl_done;
		}
		_reg = REG_UNDEF;
pvl_restart1:
		switch (ParseKeyWord(cc))
		{
			case KW_REG:
				_reg = REG_ALLOC;
				if (Lex(cc) == TK_IDENT)
				{
					k = DefineMatch(cc->cur_str, "ST_U64_REGS");
					if (k >= 0)
					{
						_reg = k;
						Lex(cc);
					}
				}
				goto pvl_restart1;

			case KW_NOREG:
				_reg = REG_NONE;
				Lex(cc);
				goto pvl_restart1;
		}

		if (cc->token == TK_ELLIPSIS && mode.u8[1] == PRS1B_FUN_ARG)
		{
			ParseDotDotDot(cc, tmpc, _reg);
			goto pvl_done;
		}
		if (cc->token == TK_IDENT)
			tmph = cc->hash_entry;
		else
			tmph = NULL;
		if (!tmph)
			LexExcept(cc, "Expecting type at ");
		k = ParseKeyWord(cc);
		if (k == KW_UNION)
		{
			Lex(cc);
			ParseVarList(cc, tmpc, mode | PRSF_UNION, tmpc->size);
		}
		else
		{
			if (!(tmph->type & (HTT_CLASS | HTT_INTERNAL_TYPE)))
				LexExcept(cc, "Expecting type at ");
			first = TRUE;
pvl_restart2:
			tmpc1 = tmph;
			LexPush(cc);
			Lex(cc); //skip type or ','
			tmpm = MemberListNew(_reg);
			_reg = REG_UNDEF;
			if (mode.u8[1] == PRS1B_STATIC_LOCAL_VAR)
			{
				tmpm->flags |= MLF_STATIC;
				tmpm->reg = REG_NONE;
			}
			if (mode.u8[1] == PRS1B_FUN_ARG || mode.u8[1] == PRS1B_LOCAL_VAR)
			{
pvl_restart3:
				switch (ParseKeyWord(cc))
				{
					case KW_REG:
						tmpm->reg = REG_ALLOC;
						LexPopNoRestore(cc);
						LexPush(cc);
						if (Lex(cc) == TK_IDENT)
						{
							k = DefineMatch(cc->cur_str, "ST_U64_REGS");
							if (k >= 0)
							{
								tmpm->reg = k;
								LexPopNoRestore(cc);
								LexPush(cc);
								Lex(cc);
							}
						}
						goto pvl_restart3;

					case KW_NOREG:
						tmpm->reg = REG_NONE;
						LexPopNoRestore(cc);
						LexPush(cc);
						Lex(cc);
						goto pvl_restart3;
				}
			}
			tmpm->member_class = ParseType(cc, &tmpc1, &mode, tmpm, &tmpm->str, &tmpm->fun_ptr, NULL, &tmpm->dim, 0);
			if (tmpm->fun_ptr)
				tmpm->flags |= MLF_FUN;
			if (first)
				MemberAdd(cc, tmpm, tmpc, mode.u8[1]);
			else
				MemberAdd(cc, tmpm, tmpc, PRS1B_NULL);
			tmpc->member_count++;

			tmpc2 = tmpm->member_class;
			i = tmpc2->size * tmpm->dim.total_count;
			switch (mode.u8[1])
			{
				case PRS1B_STATIC_LOCAL_VAR:
					if (i < 0)
					{
						i = 0;
						undef_array_size = TRUE;
					}
					else
						undef_array_size = FALSE;
					if (mode & PRSF_UNION)
						LexExcept(cc, "Static unions are not implemented ");
					k = (i + 7) & ~7;
					if (cc->flags & CCF_AOT_COMPILE)
						tmpm->static_data = MAlloc(k);
					else
						tmpm->static_data = MAlloc(k, Fs->code_heap);
					if (cc->flags & CCF_AOT_COMPILE)
					{
						tmpm->static_data_rip = cc->aotc->rip;
						k >>= 3;
						while (k--)
							AOTStoreCodeU64(cc, 0);
					}
					else
						if (sys_var_init_flag)
							MemSet(tmpm->static_data, sys_var_init_val, k);
					LexPopNoRestore(cc);
					if (cc->token == '=')
					{
						cc->flags = cc->flags & ~CCF_DONT_MAKE_RES | old_flags & CCF_DONT_MAKE_RES;
						if (undef_array_size)
						{
							LexPush(cc);
							LexPush(cc);
							Lex(cc); //skip =
							ParseStaticInit(cc, tmpm, 1);
							LexPopNoRestore(cc);
							i = tmpc2->size * tmpm->dim.total_count;
							k = (i + 7) & ~7;
							if (cc->flags & CCF_AOT_COMPILE)
							{
								k >>= 3;
								while (k--)
									AOTStoreCodeU64(cc, 0);
							}
							else
								if (sys_var_init_flag)
									MemSet(tmpm->static_data, sys_var_init_val, k);
							LexPopRestore(cc);
						}
						LexPush(cc);
						Lex(cc); //skip =
						ParseStaticInit(cc, tmpm, 2);
						LexPopNoRestore(cc);
						if (cc->flags & CCF_AOT_COMPILE)
							for (k = 0; k < i; k++)
								AOTStoreCodeU8At(cc, tmpm->static_data_rip + k, tmpm->static_data[k]);
						tmpm->use_count = 0;
						cc->flags |= CCF_DONT_MAKE_RES;
					}
					if (cc->flags & CCF_AOT_COMPILE)
						Free(tmpm->static_data);
					break;

				case PRS1B_LOCAL_VAR:
					if (mode & PRSF_UNION)
					{
						if (union_base - tmpc->size<i)
							i = union_base - i - tmpc->size;
						else
							i = 0;
					}
					if (i >= 8)
						tmpc->size = (tmpc->size - i) & ~7;
					else if (i >= 4)
						tmpc->size = (tmpc->size - i) & ~3;
					else if (i >= 2)
						tmpc->size = (tmpc->size - i) & ~1;
					else
						tmpc->size -= i;
					tmpm->offset = tmpc->size;
					tmpm->size = i;
					if (cc->token == '=')
					{
						cc->flags = cc->flags & ~CCF_DONT_MAKE_RES | old_flags & CCF_DONT_MAKE_RES;
						LexPopRestore(cc);
						Lex(cc);
						if (!ParseExpression(cc, NULL, TRUE))
							throw('Compiler');
						tmpm->use_count = 0;
						cc->flags |= CCF_DONT_MAKE_RES;
					}
					else
						LexPopNoRestore(cc);
					break;

				case PRS1B_FUN_ARG:
					if (mode & PRSF_UNION)
					{
						tmpm->offset = union_base;
						if (tmpc->size - union_base < 8)
							tmpc->size = 8 + union_base;
					}
					else
					{
						tmpm->offset = tmpc->size;
						tmpc->size += 8;
					}
					tmpm->size = 8;
					if (cc->token == '=')
					{
						Lex(cc);
						if (ParseKeyWord(cc) == KW_LASTCLASS)
						{
							tmpm->flags |= MLF_LASTCLASS;
							Lex(cc);
						}
						else
						{
							old_flags2 = cc->flags;
							cc->flags &= ~CCF_HAS_MISC_DATA;
							machine_code = LexExpression2Bin(cc, &type);
							if (!machine_code)
								throw('Compiler');
							tmpm->default_val = Call(machine_code);
							tmpc2 = OptClassFwd(tmpc2);
							if (tmpc2->raw_type == RT_F64)
							{
								if (type != RT_F64)
									tmpm->default_val(F64) = tmpm->default_val;
							}
							else
							{
								if (type == RT_F64)
									tmpm->default_val = tmpm->default_val(F64);
							}
							if (cc->flags & CCF_HAS_MISC_DATA)
							{
								tmpm->default_val = StrNew(tmpm->default_val);
								tmpm->flags |= MLF_STR_DEFAULT_AVAILABLE;
							}
							Free(machine_code);
							cc->flags |= old_flags2 & CCF_HAS_MISC_DATA;
						}
						tmpm->flags |= MLF_DEFAULT_AVAILABLE;
					}
					LexPopNoRestore(cc);
					break;

				case PRS1B_CLASS:
					if (mode & PRSF_UNION)
					{
						tmpm->offset = union_base;
						if (tmpc->size - union_base < i)
							tmpc->size = i + union_base;
					}
					else
					{
						tmpm->offset = tmpc->size;
						tmpc->size += i;
					}
					tmpm->size = i;
					if (mode & PRSF_UNION)
						cc->class_dol_offset = union_base;
					else
						cc->class_dol_offset = tmpc->size;

					while (cc->token == TK_IDENT)
					{
						tmp_meta = MAlloc(sizeof(CMemberListMeta));
						tmp_meta->next = tmpm->meta;
						tmpm->meta = tmp_meta;
						tmp_meta->str = cc->cur_str;
						tmp_meta->flags = 0;
						cc->cur_str = NULL;
						if (Lex(cc) == TK_STR)
						{
							tmp_meta->user_data = LexExtStr(cc);
							tmp_meta->flags |= MLMF_IS_STR;
						}
						else
							tmp_meta->user_data = LexExpression(cc);
					}
					LexPopNoRestore(cc);
					break;
			}
			switch (cc->token)
			{
				case ',':
					if (mode.u8[1] == PRS1B_FUN_ARG && !(mode & PRSF_UNION))
						Lex(cc);
					else
					{
						first = FALSE;
						goto pvl_restart2;
					}
					break;

				case ')':
				case '}':
					Lex(cc);
					goto pvl_done;

				case ';':
					cc->flags = cc->flags & ~CCF_DONT_MAKE_RES | old_flags & CCF_DONT_MAKE_RES;
					Lex(cc);
					cc->flags |= CCF_DONT_MAKE_RES;
					if ((mode.u8[1] == PRS1B_LOCAL_VAR || mode.u8[1] == PRS1B_STATIC_LOCAL_VAR) && !(mode & PRSF_UNION))
						goto pvl_done;
					break;

				default:
					LexExcept(cc, "Missing ';' at");
			}
		}
	}
pvl_done:
	cc->flags = cc->flags &
				~(CCF_CLASS_DOL_OFFSET | CCF_DONT_MAKE_RES) | old_flags & (CCF_CLASS_DOL_OFFSET | CCF_DONT_MAKE_RES);
}
