I64 OptPass789A(CCompCtrl *cc, COptReg *reg_offsets, U8 *buf, CDebugInfo **_debug)
{/*
cc->pass == 7 is first time
cc->pass == 8 is second time
cc->pass == 9 is third time
cc->pass == 9 is fourth time and repeated until size stops shrinking
size is now known
cc->pass == 10 is final pass, code is placed into buf.
*/
	CIntermediateCode	*tmpi, *tmpi_next;
	I64					 i, count,num_lines = cc->max_line + 1 - cc->min_line, rip = 0,rip2;
	U8					*ptr, saved_arg1_arg2_r[3 * sizeof(CICArg)];
	CCodeMisc			*lb;
	CAOT				*tmpaot;
	CAOTAbsAddr			*tmpa;
	CAOTImportExport	*tmpie;
	CAOTHeapGlobal		*tmphg;
	CAOTHeapGlobalRef	*tmphgr;
	CDebugInfo			*debug_info;
	CAOTCtrl			*aotc = cc->aotc;
	Bool				short_jmp;
	CHashClass			*tmpc;
	CHashFun			*tmpf;
	CHashGlobalVar		*tmpg;
	CExternUsage		*tmpeu;

	if (_debug)
	{
		*_debug = debug_info = CAlloc(offset(CDebugInfo.body) + sizeof(U32) * (num_lines + 1));
		debug_info->min_line = cc->min_line;
		debug_info->max_line = cc->max_line;
		if (cc->flags & CCF_AOT_COMPILE)
			debug_info->body[0] = aotc->rip;
		else
			debug_info->body[0] = buf;
	}
	else
		debug_info = NULL;

	if (Bt(&cc->flags, CCf_PASS_TRACE_PRESENT) && Bt(&cc->saved_pass_trace, cc->pass))
		"$$BK,1$$$$LTRED$$$$IV,1$$This code gets merged together and patched.\n"
		"$$FG$$$$IV,0$$$$BK,0$$";

	cc->last_float_op_ic = NULL;
	tmpi = &cc->coc.coc_head;
	tmpi->ic_last_start = -1;
	tmpi->ic_count = 0;
	tmpi = tmpi->next;
	while (tmpi->ic_code)
	{
		tmpi_next = tmpi->next;
		if (tmpi->ic_flags & ICF_PASS_TRACE && Bt(&cc->saved_pass_trace, cc->pass))
			ICPut(cc, tmpi);
		rip2 = rip;
		if (cc->flags & CCF_AOT_COMPILE)
			rip2 += aotc->rip;
		else
			rip2 += buf;
		cc->cur_ic_float_op_num = 0;
		if (!(tmpi->ic_flags & ICF_CODE_FINAL))
		{
			tmpi->ic_flags = tmpi->ic_flags & ~(ICF_PREV_DELETED | ICF_DONT_RESTORE) | ICF_CODE_FINAL;
			if (cc->pass == 7)
				cc->dont_push_float = Btr(&tmpi->ic_flags, ICf_DONT_PUSH_FLOAT0);
			MemCopy(saved_arg1_arg2_r, &tmpi->arg1, 3 * sizeof(CICArg));
			tmpi->ic_count = 0;
			tmpi->ic_last_start = -1;
			if (tmpi->arg2.type.mode)
			{
				if (tmpi->ic_flags & ICF_ARG2_TO_F64)
				{
					ICFConvert(cc, tmpi, REG_RAX, tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, FALSE, CN_A2, rip2);
					tmpi->arg2.type = MDF_REG + RT_I64;
					tmpi->arg2.reg = REG_RAX;
					tmpi->arg2.disp = 0;
				}
				else if (tmpi->ic_flags & ICF_ARG2_TO_INT)
				{
					ICFConvert(cc, tmpi, REG_RAX, tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, TRUE, CN_A2, rip2);
					tmpi->arg2.type = MDF_REG + RT_I64;
					tmpi->arg2.reg = REG_RAX;
					tmpi->arg2.disp = 0;
				}
			}
			if (tmpi->arg1.type.mode)
			{
				if (tmpi->ic_flags & ICF_ARG1_TO_F64)
				{
					ICFConvert(cc, tmpi, REG_RDX, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, FALSE, CN_A1, rip2);
					tmpi->arg1.type = MDF_REG + RT_I64;
					tmpi->arg1.reg = REG_RDX;
					tmpi->arg1.disp = 0;
				}
				else if (tmpi->ic_flags & ICF_ARG1_TO_INT)
				{
					ICFConvert(cc,tmpi, REG_RDX, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, TRUE, CN_A1, rip2);
					tmpi->arg1.type = MDF_REG+RT_I64;
					tmpi->arg1.reg = REG_RDX;
					tmpi->arg1.disp = 0;
				}
			}

			switch [tmpi->ic_code]
			{
				start:
					start:
						case IC_ABS_ADDR:
							ICU16(tmpi, 0xB848);
							ICU64(tmpi, tmpi->ic_data);
							if (buf && cc->flags & CCF_AOT_COMPILE && !(cc->flags & (CCF_NO_ABSS | CCF_ASM_EXPRESSIONS)))
							{
								tmpa = CAlloc(sizeof(CAOTAbsAddr));
								tmpa->next = aotc->abss;
								tmpa->type = AAT_ADD_U64;
								aotc->abss = tmpa;
								tmpa->rip = rip2 + tmpi->ic_count - 8;
							}
							break;

						case IC_HEAP_GLOBAL:
							ICU16(tmpi, 0xB848);
							ICU64(tmpi, 0);
							tmphg = tmpi->ic_data;
							if (buf && cc->flags & CCF_AOT_COMPILE && !(cc->flags & (CCF_NO_ABSS | CCF_ASM_EXPRESSIONS)))
							{//TODO:is this necessary--flags?
								tmphgr = CAlloc(sizeof(CAOTHeapGlobalRef));
								tmphgr->next = tmphg->references;
								tmphg->references = tmphgr;
								tmphgr->rip = rip2 + tmpi->ic_count - 8;
							}
							break;

						case IC_ADDR_IMPORT:
							ICU8(tmpi, 0xB8);
							ICU32(tmpi, 0);
							if (buf && !(cc->flags & CCF_NO_ABSS))
							{
								tmpg = tmpi->ic_data;
								tmpie = CAlloc(sizeof(CAOTImportExport));
								tmpie->type = IET_IMM_U32;
								tmpie->rip = rip2 + tmpi->ic_count - 4;
								tmpie->next = tmpg->ie_list;
								tmpg->ie_list = tmpie;
							}
							ICU24(tmpi, 0xC06348);
							break;

						case IC_RIP:
							ICU16(tmpi, 0xB848);
							ICU64(tmpi, rip2 + tmpi->ic_count - 2);
							if (cc->flags & CCF_AOT_COMPILE && buf &&!(cc->flags & CCF_NO_ABSS))
							{
								tmpa = CAlloc(sizeof(CAOTAbsAddr));
								tmpa->next = aotc->abss;
								tmpa->type = AAT_ADD_U64;
								aotc->abss = tmpa;
								tmpa->rip = rip2 + tmpi->ic_count - 8;
							}
							break;
					end:
						ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, MDF_REG + RT_I64, REG_RAX, 0, rip2);
						break;

					case IC_BR_CARRY:
						ICFlagBranch(tmpi, rip, 0x72820F, buf);
						break;

					case IC_BR_NOT_CARRY:
						ICFlagBranch(tmpi, rip, 0x73830F, buf);
						break;

					case IC_BR_ZERO:
						ICTestAndBranch(tmpi, rip, 0x74840F, buf, rip2);
						break;

					case IC_BR_NOT_ZERO:
						ICTestAndBranch(tmpi, rip, 0x75850F, buf, rip2);
						break;

					case IC_BR_MM_ZERO:
						ICPreIncDec(tmpi, SLASH_OP_DEC, rip2);
						ICFlagBranch(tmpi, rip, 0x74840F, buf);
						break;

					case IC_BR_MM_NOT_ZERO:
						ICPreIncDec(tmpi, SLASH_OP_DEC, rip2);
						ICFlagBranch(tmpi, rip, 0x75850F, buf);
						break;

					case IC_BR_EQU_EQU:
						ICCompAndBranch(tmpi, FALSE, rip, 0x74840F, 0x74840F, 0x74840F, 0x74840F, buf, rip2);
						break;

					case IC_BR_EQU_EQU2:
						ICCompAndBranch(tmpi, TRUE, rip, 0x74840F, 0x74840F, 0x74840F, 0x74840F, buf, rip2);
						break;

					case IC_BR_NOT_EQU:
						ICCompAndBranch(tmpi, FALSE, rip, 0x75850F, 0x75850F, 0x75850F, 0x75850F, buf, rip2);
						break;

					case IC_BR_NOT_EQU2:
						ICCompAndBranch(tmpi, TRUE, rip, 0x75850F, 0x75850F, 0x75850F, 0x75850F, buf, rip2);
						break;

					case IC_BR_LESS:
						if (tmpi->ic_flags & ICF_USE_F64)
							ICFCmpAndBranch(cc, tmpi, rip, 0x72820F, 0x77870F, buf, rip2);
						else
							ICCompAndBranch(tmpi, FALSE, rip, 0x72820F, 0x7C8C0F, 0x77870F, 0x7F8F0F, buf, rip2);
						break;

					case IC_BR_LESS2:
						ICCompAndBranch(tmpi, TRUE, rip, 0x72820F, 0x7C8C0F, 0x77870F, 0x7F8F0F, buf, rip2);
						break;

					case IC_BR_GREATER_EQU:
						if (tmpi->ic_flags & ICF_USE_F64)
							ICFCmpAndBranch(cc, tmpi, rip, 0x73830F, 0x76860F, buf, rip2);
						else
							ICCompAndBranch(tmpi, FALSE, rip, 0x73830F, 0x7D8D0F, 0x76860F, 0x7E8E0F, buf, rip2);
						break;

					case IC_BR_GREATER_EQU2:
						ICCompAndBranch(tmpi, TRUE, rip, 0x73830F, 0x7D8D0F, 0x76860F, 0x7E8E0F, buf, rip2);
						break;

					case IC_BR_GREATER:
						if (tmpi->ic_flags & ICF_USE_F64)
							ICFCmpAndBranch(cc, tmpi, rip, 0x77870F, 0x72820F, buf, rip2);
						else
							ICCompAndBranch(tmpi, FALSE, rip, 0x77870F, 0x7F8F0F, 0x72820F, 0x7C8C0F, buf, rip2);
						break;

					case IC_BR_GREATER2:
						ICCompAndBranch(tmpi, TRUE, rip, 0x77870F, 0x7F8F0F, 0x72820F, 0x7C8C0F, buf, rip2);
						break;

					case IC_BR_LESS_EQU:
						if (tmpi->ic_flags & ICF_USE_F64)
							ICFCmpAndBranch(cc, tmpi, rip, 0x76860F, 0x73830F, buf, rip2);
						else
							ICCompAndBranch(tmpi, FALSE, rip, 0x76860F, 0x7E8E0F, 0x73830F, 0x7D8D0F, buf, rip2);
						break;

					case IC_BR_LESS_EQU2:
						ICCompAndBranch(tmpi, TRUE, rip, 0x76860F, 0x7E8E0F, 0x73830F, 0x7D8D0F, buf, rip2);
						break;

					case IC_BR_BT:
						ICBrBitOps(tmpi, rip, 0xA30F, 0x20BA0F, 0x72820F, buf, rip2);
						break;

					case IC_BR_BTS:
						ICBrBitOps(tmpi, rip, 0xAB0F, 0x28BA0F, 0x72820F, buf, rip2);
						break;

					case IC_BR_BTR:
						ICBrBitOps(tmpi, rip, 0xB30F, 0x30BA0F, 0x72820F, buf, rip2);
						break;

					case IC_BR_BTC:
						ICBrBitOps(tmpi, rip, 0xBB0F, 0x38BA0F, 0x72820F, buf, rip2);
						break;

					case IC_BR_NOT_BT:
						ICBrBitOps(tmpi, rip, 0xA30F, 0x20BA0F, 0x73830F, buf, rip2);
						break;

					case IC_BR_NOT_BTS:
						ICBrBitOps(tmpi, rip, 0xAB0F, 0x28BA0F, 0x73830F, buf, rip2);
						break;

					case IC_BR_NOT_BTR:
						ICBrBitOps(tmpi, rip, 0xB30F, 0x30BA0F, 0x73830F, buf, rip2);
						break;

					case IC_BR_NOT_BTC:
						ICBrBitOps(tmpi, rip, 0xBB0F, 0x38BA0F, 0x73830F, buf, rip2);
						break;

					case IC_BR_AND_ZERO:
						ICAndBranch(tmpi, rip, 0x74840F, buf, rip2);
						break;

					case IC_BR_AND_NOT_ZERO:
						ICAndBranch(tmpi, rip, 0x75850F, buf, rip2);
						break;

					case IC_SUB_CALL:
						lb = OptLabelFwd(tmpi->ic_data);
						ICU8(tmpi, 0xE8);
						ICU32(tmpi, lb->addr - (rip + 5));
						break;

					case IC_JMP:
						lb = OptLabelFwd(tmpi->ic_data);
						short_jmp = ToBool(tmpi->ic_flags & ICF_SHORT_JMP);
						if (!buf && lb->addr != INVALID_PTR && I8_MIN + 5 < lb->addr - rip < I8_MAX - 5)
							short_jmp = TRUE;
						if (short_jmp)
						{
							tmpi->ic_flags |= ICF_SHORT_JMP;
							i = lb->addr - (rip + 2);
							if (buf || i)
								ICU16(tmpi, i << 8 + 0xEB);
							else
								tmpi->ic_code = IC_NOP1;
						}
						else
						{
							i = lb->addr - (rip + 5);
							ICU8(tmpi, 0xE9);
							ICU32(tmpi, i);
						}
						break;

					case IC_LABEL:
						lb = tmpi->ic_data;
						lb->addr = rip;
						if (lb->flags & CMF_POP_CMP)
						{
							ICAddRSP(tmpi, -8, FALSE);
							ICAddRSP(tmpi, 8, FALSE);
						}
						if (lb->type == CMT_ASM_LABEL)
							lb->addr += lb->rip;
						break;

					case IC_STR_CONST:
					case IC_GET_LABEL:
						lb = tmpi->ic_data;
						if (cc->flags & CCF_AOT_COMPILE)
							i = lb->addr + aotc->rip;
						else
							i = lb->addr + buf;
						ICLea(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
							  MDF_RIP_DISP32 + RT_PTR, 0, i, cc, buf, rip2);
						break;

					case IC_ASM:
						tmpaot = tmpi->ic_data;
						tmpi->ic_count += tmpaot->aot_U8s;
						if (buf)
						{
							MemCopy(buf + rip,tmpaot->buf, tmpaot->aot_U8s);
							Free(tmpaot->buf);
							tmpaot->buf = buf;
							tmpaot->rip = rip;
							tmpaot->rip2 = rip2;
							if (cc->flags & CCF_AOT_COMPILE)
								CompFixUpAOTAsm(cc, tmpaot);
							else
								CompFixUpJITAsm(cc, tmpaot);
							count = tmpi->ic_count;
							goto op789A_skip_copy;
						}
						break;

					case IC_CALL:
						i = tmpi->ic_data - (rip2 + 5);
						if (!(I32_MIN <= i <= I32_MAX) && !(cc->flags & CCF_AOT_COMPILE))
						{
							ICU16(tmpi, 0xBB48);
							ICU64(tmpi, tmpi->ic_data);
							ICU16(tmpi, 0xD3FF);
						}
						else
						{
							ICU8(tmpi, 0xE8);
							ICU32(tmpi, i);
						}
						break;

					case IC_CALL_EXTERN: //Only for static modules
						ICU8(tmpi, 0xE8);
						ICU32(tmpi, 0);
						if (buf)
						{
							tmpf = tmpi->ic_data;
							tmpeu = CAlloc(sizeof(CExternUsage));
							tmpeu->next = tmpf->ext_list;
							tmpf->ext_list = tmpeu;
							tmpeu->rip = rip2 + 1;
						}
						break;

					case IC_CALL_INDIRECT2:
						ICU16(tmpi, 0xBB48);
						if (cc->flags & CCF_AOT_COMPILE)
							i = rip2 + tmpi->ic_count;
						ICU64(tmpi, tmpi->ic_data);
						ICU16(tmpi, 0x13FF);
						if (buf && cc->flags & CCF_AOT_COMPILE && !(cc->flags & CCF_NO_ABSS))
						{
							tmpa = CAlloc(sizeof(CAOTAbsAddr));
							tmpa->next = aotc->abss;
							tmpa->type = AAT_ADD_U64;
							aotc->abss = tmpa;
							tmpa->rip = i;
						}
						break;

					case IC_CALL_IMPORT:
						if (OptionGet(OPTf_USE_IMM64))
						{
							ICU16(tmpi, 0xBB48);
							ICU64(tmpi, 0);
							if (buf)
							{
								tmpf = tmpi->ic_data;
								tmpie = CAlloc(sizeof(CAOTImportExport));
								tmpie->type = IET_IMM_I64;
								tmpie->rip = rip2+tmpi->ic_count - 8;
								tmpie->next = tmpf->ie_list;
								tmpf->ie_list = tmpie;
							}
							ICU16(tmpi, 0xD3FF);
						}
						else
						{
							ICU8(tmpi, 0xE8);
							ICU32(tmpi, 0);
							if (buf)
							{
								tmpf = tmpi->ic_data;
								tmpie = CAlloc(sizeof(CAOTImportExport));
								tmpie->type = IET_REL_I32;
								tmpie->rip = rip2 + tmpi->ic_count - 4;
								tmpie->next = tmpf->ie_list;
								tmpf->ie_list = tmpie;
							}
						}
						break;
				end:
					tmpi->ic_flags &= ~ICF_CODE_FINAL;
					break;

				case IC_LEAVE:
					if (cc->htc.fun)
					{
						if (Bt(&cc->htc.fun->flags,Ff_INTERRUPT))
							ICPopRegs(tmpi, REGG_CLOBBERED | cc->htc.fun->used_reg_mask &
									  (REGG_LOCAL_VARS | REGG_LOCAL_NON_PTR_VARS | REGG_STACK_TMP));
						else
							ICPopRegs(tmpi, cc->htc.fun->used_reg_mask & (REGG_LOCAL_VARS | REGG_LOCAL_NON_PTR_VARS));
					}
					if (tmpi->ic_data <= I16_MAX)
					{
						if (tmpi->ic_data)
							ICU8(tmpi, 0xC9); //LEAVE
						else
							ICU8(tmpi, 0x5D); //POP RBP
					}
					else
					{
						ICAddRSP(tmpi, tmpi->ic_data);
						ICU8(tmpi, 0x5D); //POP RBP
					}
					if (cc->htc.fun && Bt(&cc->htc.fun->flags, Ff_INTERRUPT))
					{
						if (Bt(&cc->htc.fun->flags, Ff_HASERRCODE))
							ICAddRSP(tmpi, 8);
						ICU16(tmpi, 0xCF48);
					}
					else if (cc->htc.fun && cc->htc.fun->arg_count &&
							(Bt(&cc->htc.fun->flags, Ff_RET1) || Bt(&cc->htc.fun->flags, Ff_ARGPOP)) &&
							!Bt(&cc->htc.fun->flags, Ff_NOARGPOP))
					{
						ICU8(tmpi, 0xC2);
						ICU16(tmpi, cc->htc.fun->arg_count << 3);
					}
					else
						ICU8(tmpi, 0xC3);
					break;

				case IC_RET:
					ICU8(tmpi, 0xC3);
					break;

				case IC_FS:
					ICZero(tmpi, REG_RAX);
					ICU32(tmpi, 0x8B4864);
					break;

				case IC_GS:
					ICZero(tmpi, REG_RAX);
					ICU32(tmpi, 0x8B4865);
					break;

				case IC_MOV_FS:
					ICZero(tmpi, REG_RAX);
					ICU8(tmpi, 0x64);
					//It's ugly to use ic_class here
					ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, MDF_DISP + CompRawType(tmpi->ic_class),
						  REG_RAX, tmpi->ic_data, rip2);
					break;

				case IC_MOV_GS:
					ICZero(tmpi, REG_RAX);
					ICU8(tmpi, 0x65);
					//It's ugly to use ic_class here
					ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, MDF_DISP + CompRawType(tmpi->ic_class),
						  REG_RAX, tmpi->ic_data, rip2);
					break;

				case IC_HOLYC_TYPECAST:
					ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					break;

				case IC_COM:
					ICUnaries(tmpi, SLASH_OP_NOT,rip2);
					break;

				case IC_NOT:
					ICNot(tmpi, rip2);
					break;

				case IC_UNARY_MINUS:
					if (tmpi->res.type.raw_type == RT_F64)
						ICFUnaryMinus(cc, tmpi, buf, rip2);
					else
						ICUnaries(tmpi, SLASH_OP_NEG, rip2);
					break;

				case IC_ADDR:
				case IC_MOV:
					ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					break;

				case IC_DEREF:
					ICDeref(tmpi, rip2);
					break;

				case IC_DEREF_PP:
					ICDerefPostIncDec(tmpi, SLASH_OP_INC, rip2);
					break;

				case IC_DEREF_MM:
					ICDerefPostIncDec(tmpi, SLASH_OP_DEC, rip2);
					break;

				case IC__PP:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICPostIncDec(tmpi, SLASH_OP_INC, rip2);
					else
						ICFPostIncDec(cc, tmpi, CMP_TEMPLATE_INC, rip2);
					break;

				case IC__MM:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICPostIncDec(tmpi, SLASH_OP_DEC, rip2);
					else
						ICFPostIncDec(cc, tmpi, CMP_TEMPLATE_DEC, rip2);
					break;

				case IC_PP_:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICPreIncDec(tmpi, SLASH_OP_INC, rip2);
					else
						ICFPreIncDec(cc, tmpi, CMP_TEMPLATE_INC, rip2);
					break;

				case IC_MM_:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICPreIncDec(tmpi, SLASH_OP_DEC, rip2);
					else
						ICFPreIncDec(cc, tmpi, CMP_TEMPLATE_DEC, rip2);
					break;

				case IC_LEA:
					ICLea(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, cc, buf, rip2);
					break;

				case IC_POWER:
					ICFPow(cc, tmpi, buf, rip2);
					break;

				case IC_SHL:
					ICShift(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp,
								0xE0D1E0D3E0C1, 0xE0D1E0D3E0C1, rip2);
					break;

				case IC_SHR:
					ICShift(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp,
								0xE8D1E8D3E8C1, 0xF8D1F8D3F8C1, rip2);
					break;

				case IC_MUL:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICMul(tmpi, rip2);
					else
						ICFMul(cc, tmpi, buf, rip2);
					break;

				case IC_DIV:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICDiv(tmpi, rip2);
					else
						ICFDiv(cc, tmpi, buf, rip2);
					break;

				case IC_MOD:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICMod(tmpi, rip2);
					else
						ICFMod(cc, tmpi, rip2);
					break;

				case IC_AND:
					ICAddEct(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								  tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								  tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, 0x23, rip2);
					break;

				case IC_OR:
					ICAddEct(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								  tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								  tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, 0x0B, rip2);
					break;

				case IC_XOR:
					ICAddEct(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								  tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								  tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, 0x33, rip2);
					break;

				case IC_ADD:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICAddEct(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
									  tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
									  tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, 0x03, rip2);
					else
						ICFAdd(cc, tmpi, buf, rip2);
					break;

				case IC_SUB:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICSub(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
									tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
									tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, rip2);
					else
						ICFSub(cc, tmpi, buf, rip2);
					break;

				case IC_EQU_EQU:
					ICComp(tmpi, 0x75, 0x75, rip2);
					break;

				case IC_NOT_EQU:
					ICComp(tmpi, 0x74, 0x74, rip2);
					break;

				case IC_LESS:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICComp(tmpi, 0x73, 0x7D, rip2);
					else
						ICFCmp(cc, tmpi, CMP_TEMPLATE_LESS, rip2);
					break;

				case IC_GREATER_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICComp(tmpi, 0x72, 0x7C, rip2);
					else
						ICFCmp(cc, tmpi, CMP_TEMPLATE_GREATER_EQU, rip2);
					break;

				case IC_GREATER:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICComp(tmpi, 0x76, 0x7E, rip2);
					else
						ICFCmp(cc, tmpi, CMP_TEMPLATE_GREATER, rip2);
					break;

				case IC_LESS_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICComp(tmpi, 0x77, 0x7F, rip2);
					else
						ICFCmp(cc, tmpi, CMP_TEMPLATE_LESS_EQU, rip2);
					break;

				case IC_AND_AND:
					ICAndAnd(tmpi, rip2);
					break;

				case IC_OR_OR:
					ICOrOr(tmpi, rip2);
					break;

				case IC_XOR_XOR:
					ICXorXor(tmpi, rip2);
					break;

				case IC_ASSIGN:
					ICAssign(tmpi, rip2);
					break;

				case IC_ASSIGN_PP:
					ICAssignPostIncDec(tmpi, SLASH_OP_INC, rip2);
					break;

				case IC_ASSIGN_MM:
					ICAssignPostIncDec(tmpi, SLASH_OP_DEC, rip2);
					break;

				case IC_SHL_EQU:
					ICShiftEqu(tmpi, tmpi->arg1_type_pointed_to,
								tmpi->res.type,  tmpi->res.reg,  tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp,
								0xE0D1E0D3E0C1, 0xE0D1E0D3E0C1, rip2);
					break;

				case IC_SHR_EQU:
					ICShiftEqu(tmpi, tmpi->arg1_type_pointed_to,
								tmpi->res.type,  tmpi->res.reg,  tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp,
								0xE8D1E8D3E8C1, 0xF8D1F8D3F8C1, rip2);
					break;

				case IC_MUL_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICMulEqu(tmpi, rip2);
					else
						ICFOpEqu(cc, tmpi, SLASH_OP_FMUL, buf, rip2);
					break;

				case IC_DIV_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICDivEqu(tmpi, FALSE, rip2);
					else
						ICFOpEqu(cc, tmpi, SLASH_OP_FDIV, buf, rip2);
					break;

				case IC_MOD_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICDivEqu(tmpi, TRUE, rip2);
					else
						ICFModEqu(cc, tmpi, rip2);
					break;

				case IC_AND_EQU:
					ICAndEqu(tmpi, rip2);
					break;

				case IC_OR_EQU:
					ICOrEqu(tmpi, rip2);
					break;

				case IC_XOR_EQU:
					ICXorEqu(tmpi, rip2);
					break;

				case IC_ADD_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICAddSubEctEqu(tmpi, tmpi->arg1_type_pointed_to,
									tmpi->res.type,  tmpi->res.reg,  tmpi->res.disp,
									tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
									tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp,
									0x010000000003, rip2);
					else
						ICFOpEqu(cc, tmpi, SLASH_OP_FADD, buf, rip2);
					break;

				case IC_SUB_EQU:
					if (tmpi->ic_flags & ICF_USE_INT)
						ICAddSubEctEqu(tmpi, tmpi->arg1_type_pointed_to,
									tmpi->res.type,  tmpi->res.reg,  tmpi->res.disp,
									tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
									tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp,
									0x29000000052B, rip2);
					else
						ICFOpEqu(cc, tmpi, SLASH_OP_FSUB, buf, rip2);
					break;

				case IC_SHL_CONST:
					ICShift(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								MDF_IMM + RT_I64, 0, tmpi->ic_data, 0xE0D1E0D3E0C1, 0xE0D1E0D3E0C1, rip2);
					break;

				case IC_SHR_CONST:
					ICShift(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
								tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp,
								MDF_IMM + RT_I64, 0, tmpi->ic_data, 0xE8D1E8D3E8C1, 0xF8D1F8D3F8C1, rip2);
					break;

				case IC_ADD_CONST:
					ICAddSubEctImm(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
										tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, tmpi->ic_data, 0x0003, rip2);
					break;

				case IC_SUB_CONST:
					ICAddSubEctImm(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp,
										tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, tmpi->ic_data, 0x052B, rip2);
					break;

				case IC_ENTER:
					ICU32(tmpi, 0xEC8B4855);
					if (tmpi->ic_data)
						ICAddRSP(tmpi, -tmpi->ic_data, FALSE);
					if (cc->htc.fun)
					{
						if (Bt(&cc->htc.fun->flags, Ff_INTERRUPT))
							ICPushRegs(tmpi, REGG_CLOBBERED | cc->htc.fun->used_reg_mask &
									   (REGG_LOCAL_VARS | REGG_LOCAL_NON_PTR_VARS | REGG_STACK_TMP));
						else
						{
							if (sys_var_init_flag && i)
								ICLocalVarInit(tmpi);
							ICPushRegs(tmpi, cc->htc.fun->used_reg_mask & (REGG_LOCAL_VARS | REGG_LOCAL_NON_PTR_VARS));
						}
						for (i = 0; i < REG_REGS_NUM; i++)
							if (reg_offsets[i] > 0 && reg_offsets[i].offset != I64_MAX)
							{
								tmpc = OptClassFwd(reg_offsets[i].m->member_class);
								ICMov(tmpi, MDF_REG + RT_I64, i, 0, MDF_DISP + tmpc->raw_type,
									  REG_RBP, reg_offsets[i].offset, rip2);
							}
					}
					break;

				case IC_ADD_RSP:
					ICAddRSP(tmpi, tmpi->ic_data);
					break;

				case IC_CALL_INDIRECT:
					if (I8_MIN <= tmpi->ic_data <= I8_MAX)
					{
						ICU24(tmpi, 0x2454FF);  //CALL disp[RSP]
						ICU8(tmpi, tmpi->ic_data);
					}
					else
					{
						ICU24(tmpi, 0x2494FF);  //CALL disp[RSP]
						ICU32(tmpi, tmpi->ic_data);
					}
					break;

				case IC_PUSH:
					ICPush(tmpi, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					break;

				case IC_POP:
					ICU8(tmpi, 0x58);
					break;

				case IC_INVLPG:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU24(tmpi, 0x38010F);
					break;

				case IC_CLFLUSH:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU24(tmpi, 0x38AE0F);
					break;

				case IC_RFLAGS_GET:
					ICU8(tmpi, 0x9C);
					ICPop(tmpi, MDF_REG + RT_I64, REG_RAX, 0, rip2);
					break;

				case IC_CARRY:
					ICU24(tmpi, 0xC0920F); //SETC AL
					ICU24(tmpi, 0x01E083); //AND EAX,1
					break;

				case IC_RDTSC:
					ICCopyTemplate(cc, tmpi, CMP_TEMPLATE_RDTSC, TRUE, FALSE, FALSE, CN_INST);
					break;

				case IC_RFLAGS_SET:
					ICPush(tmpi, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU8(tmpi, 0x9D);
					break;

				case IC_RBP_GET:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, MDF_REG + RT_I64, REG_RBP, 0, rip2);
					break;

				case IC_RBP_SET:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RBP, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					break;

				case IC_RSP_GET:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, MDF_REG + RT_I64, REG_RSP, 0, rip2);
					break;

				case IC_RSP_SET:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RSP, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					break;

				case IC_RETURN_VAL:
				case IC_RAX_SET:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					break;

				case IC_RETURN_VAL2:
				case IC_RAX_GET:
					break;

				case IC_BT:
					ICBitOps(tmpi, &tmpi->arg1, &tmpi->arg2, tmpi->next, 0xA30F, 0x20BA0F, rip2);
					break;

				case IC_BTS:
				case IC_LBTS:
					ICBitOps(tmpi, &tmpi->arg1, &tmpi->arg2, tmpi->next, 0xAB0F, 0x28BA0F, rip2);
					break;

				case IC_BTR:
				case IC_LBTR:
					ICBitOps(tmpi, &tmpi->arg1, &tmpi->arg2, tmpi->next, 0xB30F, 0x30BA0F, rip2);
					break;

				case IC_BTC:
				case IC_LBTC:
					ICBitOps(tmpi, &tmpi->arg1, &tmpi->arg2, tmpi->next, 0xBB0F, 0x38BA0F, rip2);
					break;

				case IC_BSF:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU32(tmpi, 0xC0BC0F48);
					ICU16(tmpi, 0x0375);
					ICU24(tmpi, 0xD0F748);
					break;

				case IC_BSR:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU32(tmpi, 0xC0BD0F48);
					ICU16(tmpi, 0x0375);
					ICU24(tmpi, 0xD0F748);
					break;

				case IC_POPCNT:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU16(tmpi, 0xF348);
					ICU32(tmpi, 0xC0B80F48);
					break;

				case IC_SIGN_I64:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICCopyTemplate(cc, tmpi, CMP_TEMPLATE_SIGN_I64, TRUE, FALSE, FALSE, CN_INST);
					break;

				case IC_TOUPPER:
					ICToUpper(tmpi, rip2);
					break;

				case IC_TO_I64:
					ICToI64(cc, tmpi, rip2);
					break;

				case IC_TO_F64:
					ICToF64(cc, tmpi, rip2);
					break;

				case IC_TO_BOOL:
					ICToBool(cc, tmpi, rip2);
					break;

				case IC_SQR:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_SQR, rip2);
					break;

				case IC_ABS:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_ABS, rip2);
					break;

				case IC_SQRT:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_SQRT, rip2);
					break;

				case IC_SIN:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_SIN, rip2);
					break;

				case IC_COS:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_COS, rip2);
					break;

				case IC_TAN:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_TAN, rip2);
					break;

				case IC_ATAN:
					ICFTemplateFun(cc, tmpi, CMP_TEMPLATE_ATAN, rip2);
					break;

				case IC_ABS_I64:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICU24(tmpi, 0xC08548);
					ICU16(tmpi, 0x0379);
					ICU24(tmpi, 0xD8F748);
					break;

				case IC_MIN_I64:
					ICMinMax(tmpi, 0x4F, rip2);
					break;

				case IC_MAX_I64:
					ICMinMax(tmpi, 0x4C, rip2);
					break;

				case IC_MIN_U64:
					ICMinMax(tmpi, 0x47, rip2);
					break;

				case IC_MAX_U64:
					ICMinMax(tmpi, 0x42, rip2);
					break;

				case IC_MOD_U64:
					ICModU64(tmpi, rip2);
					break;

				case IC_SQR_I64:
					ICSqr(tmpi, SLASH_OP_IMUL, rip2);
					break;

				case IC_SQR_U64:
					ICSqr(tmpi, SLASH_OP_MUL, rip2);
					break;

				case IC_SWAP_U8:
				case IC_SWAP_U16:
				case IC_SWAP_U32:
				case IC_SWAP_I64:
					ICSwap(tmpi, rip2);
					break;

				case IC_QUEUE_INIT:
					ICQueueInit(tmpi, rip2);
					break;

				case IC_QUEUE_INSERT:
					ICQueueInsert(tmpi, rip2);
					break;

				case IC_QUEUE_INSERT_REV:
					ICQueueInsertRev(tmpi, rip2);
					break;

				case IC_QUEUE_REMOVE:
					ICQueueRemove(tmpi, rip2);
					break;

				case IC_STRLEN:
					ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
					ICCopyTemplate(cc, tmpi, CMP_TEMPLATE_STRLEN, TRUE, FALSE, FALSE, CN_INST);
					break;

				case IC_IN_U32:
					if (tmpi->arg1.type & MDF_IMM)
					{
						ICU16(tmpi, 0xC033);
						if (tmpi->arg1.disp <= U8_MAX)
							ICU16(tmpi, 0xE5 + tmpi->arg1.disp << 8);
						else
						{
							ICU32(tmpi, 0xBA00 + OC_OP_SIZE_PREFIX + tmpi->arg1.disp << 16);
							ICU8(tmpi, 0xED);
						}
					}
					else
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RDX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						ICU16(tmpi, 0xC033);
						ICU8(tmpi, 0xED);
					}
					break;

				case IC_IN_U16:
					if (tmpi->arg1.type & MDF_IMM)
					{
						ICU16(tmpi, 0xC033);
						if (tmpi->arg1.disp <= U8_MAX)
							ICU24(tmpi, 0xE500 + OC_OP_SIZE_PREFIX + tmpi->arg1.disp << 16);
						else
						{
							ICU32(tmpi, 0xBA00 + OC_OP_SIZE_PREFIX + tmpi->arg1.disp << 16);
							ICU16(tmpi, 0xED00 + OC_OP_SIZE_PREFIX);
						}
					}
					else
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RDX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						ICU16(tmpi, 0xC033);
						ICU16(tmpi, 0xED00 + OC_OP_SIZE_PREFIX);
					}
					break;

				case IC_IN_U8:
					if (tmpi->arg1.type & MDF_IMM)
					{
						ICU16(tmpi, 0xC033);
						if (tmpi->arg1.disp <= U8_MAX)
							ICU16(tmpi, 0xE4 + tmpi->arg1.disp << 8);
						else
						{
							ICU32(tmpi, 0xBA00 + OC_OP_SIZE_PREFIX + tmpi->arg1.disp << 16);
							ICU8(tmpi, 0xEC);
						}
					}
					else
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RDX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						ICU16(tmpi, 0xC033);
						ICU8(tmpi, 0xEC);
					}
					break;

				case IC_OUT_U32:
					if (tmpi->arg2.type & MDF_IMM)
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						if (tmpi->arg2.disp <= U8_MAX)
							ICU16(tmpi, 0xE7 + tmpi->arg2.disp << 8);
						else
						{
							ICU32(tmpi, 0xBA00 + OC_OP_SIZE_PREFIX + tmpi->arg2.disp << 16);
							ICU8(tmpi, 0xEF);
						}
					}
					else
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RDX, 0, tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, rip2);
						ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						ICU8(tmpi, 0xEF);
					}
					break;

				case IC_OUT_U16:
					if (tmpi->arg2.type & MDF_IMM)
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						if (tmpi->arg2.disp <= U8_MAX)
							ICU24(tmpi, 0xE700 + OC_OP_SIZE_PREFIX + tmpi->arg2.disp << 16);
						else
						{
							ICU32(tmpi, 0xBA00 + OC_OP_SIZE_PREFIX + tmpi->arg2.disp << 16);
							ICU16(tmpi, 0xEF00 + OC_OP_SIZE_PREFIX);
						}
					}
					else
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RDX, 0, tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, rip2);
						ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						ICU16(tmpi, 0xEF00 + OC_OP_SIZE_PREFIX);
					}
					break;

				case IC_OUT_U8:
					if (tmpi->arg2.type & MDF_IMM)
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						if (tmpi->arg2.disp <= U8_MAX)
							ICU16(tmpi, 0xE6 + tmpi->arg2.disp << 8);
						else
						{
							ICU32(tmpi, 0xBA00 + OC_OP_SIZE_PREFIX + tmpi->arg2.disp << 16);
							ICU8(tmpi, 0xEE);
						}
					}
					else
					{
						ICMov(tmpi, MDF_REG + RT_I64, REG_RDX, 0, tmpi->arg2.type, tmpi->arg2.reg, tmpi->arg2.disp, rip2);
						ICMov(tmpi, MDF_REG + RT_I64, REG_RAX, 0, tmpi->arg1.type, tmpi->arg1.reg, tmpi->arg1.disp, rip2);
						ICU8(tmpi, 0xEE);
					}
					break;

				case IC_NOBOUND_SWITCH:
					ICSwitch(tmpi, rip, TRUE, cc, buf, rip2);
					break;

				case IC_SWITCH:
					ICSwitch(tmpi, rip, FALSE, cc, buf, rip2);
					break;

				case IC_NOP1:
				case IC_NOP2:
					OptFree(tmpi);
					goto op789A_next;

				case IC_CALL_START:
				case IC_PUSH_REGS:
					ICPushRegs(tmpi, tmpi->ic_data);
					break;

				case IC_CALL_END:
					ICPopRegs(tmpi, tmpi->ic_data);
					if (tmpi->res.type.mode)
						ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, MDF_REG + RT_I64, REG_RAX, 0, rip2);
					break;

				case IC_POP_REGS:
					ICPopRegs(tmpi, tmpi->ic_data);
					break;

				case IC_PUSH_CMP:
				case IC_CALL_END2:
				case IC_END:
				case IC_ADD_RSP1:
					break;

				default:
					"Pass:%d Missing IC handler\n", cc->pass;
					ICPut(cc, tmpi);
					LexExcept(cc, "Compiler Optimization Error at ");
			}
			if (tmpi->res.type.mode)
			{
				if (tmpi->ic_flags & ICF_RES_TO_F64)
				{
					if (tmpi->ic_code == IC_PUSH_CMP)
					{
						ICU24(tmpi, 0x242CDF); //FILD U64 [RSP]
						ICU24(tmpi, 0x241CDD); //FSTP U64 [RSP]
					}
					else
					{
						ICFConvert(cc, tmpi, REG_RAX, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, FALSE, CN_RES, rip2);
						if (!Bt(&tmpi->ic_flags, ICf_DONT_POP_FLOAT0 + cc->cur_ic_float_op_num - 1))
							ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, MDF_REG + RT_I64, REG_RAX, 0, rip2);
					}
				}
				else if (tmpi->ic_flags & ICF_RES_TO_INT)
				{
					ICFConvert(cc, tmpi, REG_RAX, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, TRUE, CN_RES, rip2);
					ICMov(tmpi, tmpi->res.type, tmpi->res.reg, tmpi->res.disp, MDF_REG + RT_I64, REG_RAX, 0, rip2);
				}
			}
		}
		count = tmpi->ic_count;
		if (tmpi->ic_flags & ICF_DEL_PREV_INS)
		{
			if (cc->pass > 8)
				count = tmpi->ic_last_start;
			tmpi->ic_flags &= ~ICF_DEL_PREV_INS;
		}
		if (count && buf)
			MemCopy(buf + rip, tmpi->ic_body, count);
op789A_skip_copy:
		if (debug_info && cc->min_line <= tmpi->ic_line <= cc->max_line)
		{
			i = tmpi->ic_line-cc->min_line;
			if (!debug_info->body[i])
				debug_info->body[i] = rip2;
		}
		if (tmpi->ic_flags & ICF_PASS_TRACE && Bt(&cc->saved_pass_trace, cc->pass) && count)
		{
			"$$RED$$";
			if (buf)
				Un(buf + rip,count, 64);
			else
				Un(tmpi->ic_body, count, 64);
			"$$FG$$";
		}
		if (!(tmpi->ic_flags & (ICF_CODE_FINAL | ICF_DONT_RESTORE)))
			MemCopy(&tmpi->arg1, saved_arg1_arg2_r, 3 * sizeof(CICArg));
		rip += count;
		if (tmpi->ic_count >= IC_BODY_SIZE && tmpi->ic_code != IC_ASM)
			throw('Compiler');
op789A_next:
		tmpi = tmpi_next;
	}

	lb = cc->coc.coc_next_misc;
	while (lb != &cc->coc.coc_next_misc)
	{
		switch (lb->type)
		{
			case CMT_STR_CONST:
				lb->addr = rip;
				if (buf)
					MemCopy(buf + rip, lb->str, lb->st_len);
				rip += lb->st_len;
				break;
			case CMT_JMP_TABLE:
				lb->addr = rip;
				ptr = buf + lb->addr;
				if (lb->flags & (CMF_I8_JMP_TABLE | CMF_U8_JMP_TABLE))
				{
					if (buf)
						for (i = 0; i < lb->range; i++)
							*ptr++ = lb->jmp_table[i]->addr - lb->begin->addr;
					rip += lb->range;
				}
				else if (lb->flags & (CMF_I16_JMP_TABLE | CMF_U16_JMP_TABLE))
				{
					if (buf)
						for (i = 0; i < lb->range; i++)
							*ptr(U16 *)++ = lb->jmp_table[i]->addr - lb->begin->addr;
					rip += lb->range << 1;
				}
				else
				{
					if (buf)
						for (i = 0; i < lb->range; i++)
						{
							if (cc->flags & CCF_AOT_COMPILE && !(cc->flags & CCF_NO_ABSS))
							{
								tmpa = CAlloc(sizeof(CAOTAbsAddr));
								tmpa->next = aotc->abss;
								tmpa->type = AAT_ADD_U32;
								aotc->abss = tmpa;
								tmpa->rip = aotc->rip + lb->addr + i << 2;
								*ptr(U32 *)++ = lb->jmp_table[i]->addr + aotc->rip;
							}
							else
								*ptr(U32 *)++ = lb->jmp_table[i]->addr + buf;
						}
					rip += lb->range << 2;
				}
				break;
			case CMT_FLOAT_CONSTS:
				lb->addr = rip;
				if (buf)
					MemCopy(buf + lb->addr, lb->float_consts, lb->num_consts * sizeof(F64));
				rip += lb->num_consts * sizeof(F64);
				break;
		}
		lb = lb->next;
	}
	if (debug_info)
	{
		if (cc->flags & CCF_AOT_COMPILE)
			debug_info->body[num_lines] = rip + aotc->rip;
		else
			debug_info->body[num_lines] = rip + buf;
	}

	return rip;
}
