CCodeMisc *OptLabelFwd(CCodeMisc *lb)
{
        CCodeMisc *lb1;

        while (lb1 = lb->forward)
                lb = lb1;

        return lb;
}

CHashClass *OptClassFwd(CHashClass *tmpc)
{//Class forwarding for unions and subclasses.
        CHashClass *tmpc1;

        while (tmpc1 = tmpc->fwd_class)
                tmpc = tmpc1;

        return tmpc;
}

U0 OptSetNOP1(CIntermediateCode *tmpi)
{
        tmpi->ic_code = IC_NOP1;
        tmpi->ic_flags = 0;
        tmpi->arg1.type = MDF_NULL + tmpi->arg1.type.raw_type;
        tmpi->res.type  = MDF_NULL + tmpi->res.type.raw_type;
}

U0 OptSetNOP2(CIntermediateCode *tmpi, I64 stack_delta=1)
{
        tmpi->ic_code = IC_NOP2;
        tmpi->ic_data = stack_delta;
        tmpi->arg1.type = MDF_NULL + tmpi->arg1.type.raw_type;
        tmpi->res.type  = MDF_NULL + tmpi->res.type.raw_type;
}

CIntermediateCode *OptFree(CIntermediateCode *tmpi)
{//We might access freed entries in CICTreeLinks
        QueueRemove(tmpi);
        Free(tmpi);

        return NULL;
}

CIntermediateCode *OptLag(CIntermediateCode *tmpi)
{
        do
        {
                if (!tmpi->ic_code)
                        return NULL;
                else
                        tmpi = tmpi->last;
        }
        while (tmpi->ic_code <= IC_END_EXP);

        return tmpi;
}

CIntermediateCode *OptLag1(CIntermediateCode *tmpi)
{
        do
        {
                if (!tmpi->ic_code)
                        return NULL;
                else
                        tmpi = tmpi->last;
        }
        while (tmpi->ic_code == IC_NOP1 || tmpi->ic_code == IC_NOP2);

        return tmpi;
}

CIntermediateCode *OptLag2(CIntermediateCode *tmpi)
{
        do
        {
                if (!tmpi->ic_code)
                        return NULL;
                else
                        tmpi = tmpi->last;
        }
        while (tmpi->ic_code < IC_END_EXP);

        return tmpi;
}

CIntermediateCode *OptLead1(CIntermediateCode *tmpi)
{
        do
        {
                tmpi = tmpi->next;
                if (!tmpi->ic_code)
                        return NULL;
        }
        while (tmpi->ic_code == IC_NOP1 || tmpi->ic_code == IC_NOP2);

        return tmpi;
}

I64 CompOffset2Reg(I64 offset, COptReg *reg_offsets)
{
        I64 i;

        for (i = 0; i < REG_REGS_NUM; i++)
                if (offset == reg_offsets[i].offset)
                        return i;

        return -1;
}

#define FBO1_NOT_CONST  0
#define FBO1_INT                1
#define FBO1_F64                2

Bool OptFixupBinaryOp1(CIntermediateCode *tmpi, CIntermediateCode *tmpi1, CIntermediateCode *tmpi2, Bool *is_unsigned)
{
        CIntermediateCode       *tmpii;
        CHashClass                      *tmpc = tmpi->ic_class, *tmpc1, *tmpc2;

        if (tmpi1->ic_flags & ICF_RES_TO_INT)
                tmpc1 = cmp.internal_types[RT_I64];
        else if (tmpi1->ic_flags & ICF_RES_TO_F64)
                tmpc1 = cmp.internal_types[RT_F64];
        else
        {
                tmpc1 = OptClassFwd(tmpi1->ic_class);
        }

        if (tmpi2->ic_flags & ICF_RES_TO_INT)
                tmpc2 = cmp.internal_types[RT_I64];
        else if (tmpi2->ic_flags & ICF_RES_TO_F64)
                tmpc2 = cmp.internal_types[RT_F64];
        else
        {
                tmpc2 = OptClassFwd(tmpi2->ic_class);
        }

        if (tmpc1->raw_type>tmpc2->raw_type)
                tmpc = tmpi->ic_class = tmpc1;
        else
                tmpc = tmpi->ic_class = tmpc2;

        if (tmpc->raw_type == RT_F64)
        {
                if (tmpi1->ic_code == IC_IMM_I64)
                {
                        tmpi1->ic_data(F64) = tmpi1->ic_data;
                        tmpi1->ic_class = cmp.internal_types[RT_F64];
                        tmpi1->ic_code = IC_IMM_F64;
                        tmpi1->ic_flags &= ~ICF_RES_TO_F64;
                }
                else
                        if (tmpc1->raw_type != RT_F64)
                                tmpi1->ic_flags |= ICF_RES_TO_F64;
                if (tmpi2->ic_code == IC_IMM_I64)
                {
                        tmpi2->ic_data(F64) = tmpi2->ic_data;
                        tmpi2->ic_class = cmp.internal_types[RT_F64];
                        tmpi2->ic_code = IC_IMM_F64;
                        tmpi2->ic_flags &= ~ICF_RES_TO_F64;
                }
                else
                        if (tmpc2->raw_type != RT_F64)
                                tmpi2->ic_flags |= ICF_RES_TO_F64;
                if (IC_LESS <= tmpi->ic_code <= IC_GREATER_EQU && (tmpii = OptLead1(tmpi)) &&
                        tmpii->ic_code != IC_PUSH_CMP && tmpii->ic_code != IC_AND_AND)
                {
//We are looking for float comparisons to zero to convert to int.
                        if (tmpi1->ic_code == IC_IMM_F64 && !tmpi1->ic_data &&
                                tmpi2->ic_code == IC_DEREF && tmpc2 == cmp.internal_types[RT_F64])
                        {
                                tmpi1->ic_code == IC_IMM_I64;
                                goto fb_here1;
                        }
                        else if (tmpi2->ic_code == IC_IMM_F64 && !tmpi2->ic_data &&
                                        tmpi1->ic_code == IC_DEREF && tmpc1 == cmp.internal_types[RT_F64])
                        {
                                tmpi2->ic_code == IC_IMM_I64;
fb_here1:
                                tmpi1->ic_flags &= ~ICF_RES_TO_F64;
                                tmpi->ic_class = tmpi1->ic_class = tmpi2->ic_class = cmp.internal_types[RT_I64];
                                *is_unsigned = FALSE;
                                return FBO1_NOT_CONST;
                        }
                        goto fb_here2;
                }
                else
                {
fb_here2:
                        if (tmpi1->ic_code == IC_IMM_F64 && tmpi2->ic_code == IC_IMM_F64 &&
                                !(tmpi->ic_flags & (ICF_PUSH_CMP | ICF_POP_CMP)))
                        {
                                tmpi->ic_flags |= tmpi1->ic_flags | tmpi2->ic_flags;
                                OptSetNOP1(tmpi1);
                                OptSetNOP1(tmpi2);
                                return FBO1_F64;
                        }
                        else
                                return FBO1_NOT_CONST;
                }
        }
        *is_unsigned = tmpc1->raw_type & RTF_UNSIGNED || tmpc2->raw_type & RTF_UNSIGNED;
        if (tmpi1->ic_code == IC_IMM_I64 && tmpi2->ic_code == IC_IMM_I64 && !(tmpi->ic_flags & (ICF_PUSH_CMP | ICF_POP_CMP)))
        {
                tmpi->ic_flags |= tmpi1->ic_flags | tmpi2->ic_flags;
                OptSetNOP1(tmpi1);
                OptSetNOP1(tmpi2);
                return FBO1_INT;
        }
        else
                return FBO1_NOT_CONST;
}

Bool OptFixupBinaryOp2(CIntermediateCode **tmpi1, CIntermediateCode **tmpi2)
{
        CIntermediateCode *tmpii1 = *tmpi1, *tmpii2 = *tmpi2;

        if (tmpii1->ic_code == IC_IMM_I64 && !(tmpii1->ic_flags & ICF_RES_TO_F64))
                return TRUE;
        if (tmpii2->ic_code == IC_IMM_I64 && !(tmpii2->ic_flags & ICF_RES_TO_F64))
        {
                *tmpi1 = tmpii2;
                *tmpi2 = tmpii1;
                return TRUE;
        }

        return FALSE;
}

Bool OptFixupUnaryOp(CIntermediateCode *tmpi, CIntermediateCode *tmpi1, Bool *is_unsigned)
{
        CHashClass *tmpc, *tmpc1;

        tmpc1 = OptClassFwd(tmpi1->ic_class);
        tmpi->ic_class = tmpc1;
        tmpc = tmpi->ic_class;
        if (tmpc->raw_type == RT_F64)
        {
                if (tmpi1->ic_code == IC_IMM_I64)
                {
                        tmpi1->ic_data(F64) = tmpi1->ic_data;
                        tmpi1->ic_class = cmp.internal_types[RT_F64];
                        tmpi1->ic_code = IC_IMM_F64;
                        tmpi1->ic_flags &= ~ICF_RES_TO_F64;
                }
                else
                        if (tmpc1->raw_type != RT_F64)
                                tmpi1->ic_flags |= ICF_RES_TO_F64;
                if (tmpi1->ic_code == IC_IMM_F64)
                {
                        tmpi->ic_flags |= tmpi1->ic_flags;
                        OptSetNOP1(tmpi1);
                        return FBO1_F64;
                }
                else
                        return FBO1_NOT_CONST;
        }
        *is_unsigned = tmpc1->raw_type & RTF_UNSIGNED;
        if (tmpi1->ic_code == IC_IMM_I64)
        {
                tmpi->ic_flags |= tmpi1->ic_flags;
                OptSetNOP1(tmpi1);
                return FBO1_INT;
        }
        else
                return FBO1_NOT_CONST;
}

extern CIntermediateCode *OptBrNotZero(CCompCtrl *cc, CIntermediateCode *tmpi);

CIntermediateCode *OptBrZero(CCompCtrl *cc, CIntermediateCode *tmpi)
{
        CCodeMisc                       *lb_true, *lb_false;
        CIntermediateCode       *tmpii = OptLag(tmpi), *tmpii2;

        switch (tmpii->ic_code)
        {
                case IC_NOT:
                        tmpi->ic_code = IC_BR_NOT_ZERO;
                        tmpi->ic_class = tmpii->ic_class;
                        tmpi->ic_flags |= tmpii->ic_flags;
                        tmpi->t.arg1_class = tmpii->t.arg1_class;
                        tmpi->t.arg1_tree = tmpii->t.arg1_tree;
                        OptFree(tmpii);
                        return OptBrNotZero(cc, tmpi);

                case IC_EQU_EQU...IC_LESS_EQU:
                        tmpi->ic_code = (tmpii->ic_code - IC_EQU_EQU) ^ 1 + IC_BR_EQU_EQU;
                        break;

                case IC_OR_OR:
                        tmpi->ic_code = IC_BR_OR_OR_ZERO;
                        break;

                case IC_AND_AND:
                        tmpi->ic_code = IC_BR_AND_AND_ZERO;
                        break;

                case IC_AND:
                        tmpi->ic_code = IC_BR_AND_ZERO;
                        break;

                case IC_MM_:
                        if (cc->pass == 2 && !(tmpii->ic_flags & ICF_RES_TO_F64) && tmpii->ic_class->raw_type != RT_F64)
                                tmpi->ic_code = IC_BR_MM_ZERO;
                        break;

                case IC_CALL_END:
                        tmpii2 = OptLag(tmpii);
                        switch (tmpii2->ic_code)
                        {
                                start:
                                        case IC_CARRY:
                                                tmpii2->ic_code = IC_BR_NOT_CARRY;
                                                break;

                                        case IC_BT:
                                                tmpii2->ic_code = IC_BR_NOT_BT;
                                                break;

                                        case IC_LBTS:
                                                tmpii2->ic_flags |= ICF_LOCK;
                                        case IC_BTS:
                                                tmpii2->ic_code = IC_BR_NOT_BTS;
                                                break;

                                        case IC_LBTR:
                                                tmpii2->ic_flags |= ICF_LOCK;
                                        case IC_BTR:
                                                tmpii2->ic_code = IC_BR_NOT_BTR;
                                                break;

                                        case IC_LBTC:
                                                tmpii2->ic_flags |= ICF_LOCK;
                                        case IC_BTC:
                                                tmpii2->ic_code = IC_BR_NOT_BTC;
                                                break;
                                end:
                                        tmpii2->ic_data = tmpi->ic_data;
                                        tmpii->ic_code = IC_CALL_END2;
                                        OptSetNOP1(tmpi);
                                        return tmpii;
                        }
                        break;
        }
        if (tmpi->ic_code != IC_BR_ZERO)
        {
                tmpi->ic_class = tmpii->ic_class;
                tmpi->ic_flags |= tmpii->ic_flags;
                tmpi->t.arg1_class = tmpii->t.arg1_class;
                tmpi->t.arg2_class = tmpii->t.arg2_class;
                tmpi->t.arg1_tree = tmpii->t.arg1_tree;
                tmpi->t.arg2_tree = tmpii->t.arg2_tree;
                OptFree(tmpii);

                if (tmpi->ic_flags & ICF_PUSH_CMP && IC_BR_NOT_EQU <= tmpi->ic_code <= IC_BR_LESS_EQU &&
                        !(tmpi->ic_flags & ICF_USE_F64))
                {
                        tmpi->ic_code += IC_BR_EQU_EQU2-IC_BR_EQU_EQU;
                        tmpi->ic_flags &= ~ICF_PUSH_CMP;
                        tmpii = tmpi->next; //IC_PUSH_CMP inst
                        while (tmpii->ic_code != IC_PUSH_CMP)
                                tmpii = tmpii->next;
                        tmpii->t.arg1_tree = tmpi;
                        OptSetNOP1(tmpii);
                }

                lb_true = tmpi->ic_data;
                if (tmpi->ic_code == IC_BR_AND_AND_ZERO)
                {
                        tmpii = tmpi->t.arg1_tree->next;
                        tmpii->ic_data = lb_true;
                        tmpii->t.arg1_tree = tmpi->t.arg1_tree;
                        tmpii->t.arg1_class = tmpi->t.arg1_class;
                        tmpii->ic_code = IC_BR_ZERO;
                        OptBrZero(cc, tmpii);
                        tmpii = tmpi->t.arg2_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg2_tree;
                        tmpii->t.arg1_class = tmpi->t.arg2_class;
                        tmpii->ic_data = lb_true;
                        tmpii->ic_code = IC_BR_ZERO;
                        tmpii=OptBrZero(cc, tmpii);
                        OptSetNOP1(tmpi);
                }
                else if (tmpi->ic_code == IC_BR_OR_OR_ZERO)
                {
                        lb_false = COCMiscNew(cc, CMT_LABEL);
                        tmpi->ic_code = IC_LABEL;
                        tmpi->ic_flags = 0;
                        tmpi->ic_data = lb_false;
                        tmpii = tmpi->t.arg1_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg1_tree;
                        tmpii->t.arg1_class = tmpi->t.arg1_class;
                        tmpii->ic_data = lb_false;
                        tmpii->ic_code = IC_BR_NOT_ZERO;
                        OptBrNotZero(cc, tmpii);
                        tmpii = tmpi->t.arg2_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg2_tree;
                        tmpii->t.arg1_class = tmpi->t.arg2_class;
                        tmpii->ic_data = lb_true;
                        tmpii->ic_code = IC_BR_ZERO;
                        tmpii = OptBrZero(cc, tmpii);
                }
                else
                        tmpii = tmpi;
                if (tmpi->ic_flags & ICF_POP_CMP && tmpi->t.arg1_tree->ic_code == IC_NOP1)
                {
                        tmpi->t.arg1_tree = tmpi->t.arg1_tree->t.arg1_tree;
                        tmpi->ic_flags &= ~ICF_POP_CMP;
                }
                return tmpii;
        }
        return tmpi;
}

CIntermediateCode *OptBrNotZero(CCompCtrl *cc, CIntermediateCode *tmpi)
{
        CCodeMisc                       *lb_true, *lb_false;
        CIntermediateCode       *tmpii = OptLag(tmpi), *tmpii2;

        switch (tmpii->ic_code)
        {
                case IC_NOT:
                        tmpi->ic_code = IC_BR_ZERO;
                        tmpi->ic_class = tmpii->ic_class;
                        tmpi->ic_flags |= tmpii->ic_flags;
                        tmpi->t.arg1_class = tmpii->t.arg1_class;
                        tmpi->t.arg1_tree = tmpii->t.arg1_tree;
                        OptFree(tmpii);
                        return OptBrZero(cc, tmpi);

                case IC_EQU_EQU...IC_LESS_EQU:
                        tmpi->ic_code = tmpii->ic_code + IC_BR_EQU_EQU - IC_EQU_EQU;
                        break;

                case IC_OR_OR:
                        tmpi->ic_code = IC_BR_OR_OR_NOT_ZERO;
                        break;

                case IC_AND_AND:
                        tmpi->ic_code = IC_BR_AND_AND_NOT_ZERO;
                        break;

                case IC_AND:
                        tmpi->ic_code = IC_BR_AND_NOT_ZERO;
                        break;

                case IC_MM_:
                        if (cc->pass == 2 && !(tmpii->ic_flags & ICF_RES_TO_F64) && tmpii->ic_class->raw_type != RT_F64)
                                tmpi->ic_code = IC_BR_MM_NOT_ZERO;
                        break;

                case IC_CALL_END:
                        tmpii2 = OptLag(tmpii);
                        switch (tmpii2->ic_code)
                        {
                                start:
                                        case IC_CARRY:
                                                tmpii2->ic_code = IC_BR_CARRY;
                                                break;

                                        case IC_BT:
                                                tmpii2->ic_code = IC_BR_BT;
                                                break;

                                        case IC_LBTS:
                                                tmpii2->ic_flags |= ICF_LOCK;
                                        case IC_BTS:
                                                tmpii2->ic_code = IC_BR_BTS;
                                                break;

                                        case IC_LBTR:
                                                tmpii2->ic_flags |= ICF_LOCK;
                                        case IC_BTR:
                                                tmpii2->ic_code = IC_BR_BTR;
                                                break;

                                        case IC_LBTC:
                                                tmpii2->ic_flags |= ICF_LOCK;
                                        case IC_BTC:
                                                tmpii2->ic_code = IC_BR_BTC;
                                                break;
                                end:
                                        tmpii2->ic_data = tmpi->ic_data;
                                        tmpii->ic_code = IC_CALL_END2;
                                        OptSetNOP1(tmpi);
                                        return tmpii;
                        }
                        break;
        }
        if (tmpi->ic_code != IC_BR_NOT_ZERO)
        {
                tmpi->ic_class = tmpii->ic_class;
                tmpi->ic_flags |= tmpii->ic_flags;
                tmpi->t.arg1_class = tmpii->t.arg1_class;
                tmpi->t.arg2_class = tmpii->t.arg2_class;
                tmpi->t.arg1_tree = tmpii->t.arg1_tree;
                tmpi->t.arg2_tree = tmpii->t.arg2_tree;
                OptFree(tmpii);

                if (tmpi->ic_flags & ICF_PUSH_CMP && IC_BR_NOT_EQU <= tmpi->ic_code <= IC_BR_LESS_EQU &&
                        !(tmpi->ic_flags & ICF_USE_F64))
                {
                        tmpi->ic_code += IC_BR_EQU_EQU2-IC_BR_EQU_EQU;
                        tmpi->ic_flags &= ~ICF_PUSH_CMP;
                        tmpii = tmpi->next; //IC_PUSH_CMP inst
                        while (tmpii->ic_code != IC_PUSH_CMP)
                                tmpii = tmpii->next;
                        tmpii->t.arg1_tree = tmpi;
                        OptSetNOP1(tmpii);
                }

                lb_true = tmpi->ic_data;
                if (tmpi->ic_code == IC_BR_OR_OR_NOT_ZERO)
                {
                        tmpii = tmpi->t.arg1_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg1_tree;
                        tmpii->t.arg1_class = tmpi->t.arg1_class;
                        tmpii->ic_data = lb_true;
                        tmpii->ic_code = IC_BR_NOT_ZERO;
                        OptBrNotZero(cc, tmpii);
                        tmpii = tmpi->t.arg2_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg2_tree;
                        tmpii->t.arg1_class = tmpi->t.arg2_class;
                        tmpii->ic_data = lb_true;
                        tmpii->ic_code = IC_BR_NOT_ZERO;
                        tmpii=OptBrNotZero(cc, tmpii);
                        OptSetNOP1(tmpi);
                }
                else if (tmpi->ic_code == IC_BR_AND_AND_NOT_ZERO)
                {
                        lb_false = COCMiscNew(cc, CMT_LABEL);
                        tmpi->ic_code = IC_LABEL;
                        tmpi->ic_flags = 0;
                        tmpi->ic_data = lb_false;
                        tmpii = tmpi->t.arg1_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg1_tree;
                        tmpii->t.arg1_class = tmpi->t.arg1_class;
                        tmpii->ic_data = lb_false;
                        tmpii->ic_code = IC_BR_ZERO;
                        OptBrZero(cc, tmpii);
                        tmpii = tmpi->t.arg2_tree->next;
                        tmpii->t.arg1_tree = tmpi->t.arg2_tree;
                        tmpii->t.arg1_class = tmpi->t.arg2_class;
                        tmpii->ic_data = lb_true;
                        tmpii->ic_code = IC_BR_NOT_ZERO;
                        tmpii=OptBrNotZero(cc, tmpii);
                }
                else
                        tmpii = tmpi;
                if (tmpi->ic_flags & ICF_POP_CMP && tmpi->t.arg1_tree->ic_code == IC_NOP1)
                {
                        tmpi->t.arg1_tree = tmpi->t.arg1_tree->t.arg1_tree;
                        tmpi->ic_flags &= ~ICF_POP_CMP;
                }
                return tmpii;
        }

        return tmpi;
}

U0 OptFixSizeOf(CIntermediateCode *tmpi1, CIntermediateCode *tmpi_push, CHashClass *tmpcc)
{
        if (tmpi1->ic_code == IC_MUL && tmpi1->t.arg2_tree->ic_code == IC_SIZEOF)
        {
                tmpi1->t.arg2_tree->ic_code = IC_IMM_I64;
                tmpi1->t.arg2_tree->ic_class = tmpcc;
                tmpi_push->ic_class = tmpcc;
                if (tmpcc->ptr_stars_count)
                {
                        tmpcc--;
                        if (tmpcc->size == 1)
                                goto here;
                        tmpi1->t.arg2_tree->ic_data = tmpcc->size;
                }
                else
                {
here:
                        if (tmpi_push == tmpi1)
                                tmpi1->t.arg2_tree->ic_data = 1;
                        else
                        {
                                OptSetNOP1(tmpi1->t.arg2_tree);
                                OptSetNOP1(tmpi1);
                        }
                }
        }
}

I64 CompRawType(CHashClass *tmpc)
{
        if (tmpc)
        {
                tmpc = OptClassFwd(tmpc);
                return tmpc->raw_type;
        }

        return 0;
}

I64 CompRawTypePointed(CHashClass *tmpc)
{
        if (tmpc)
        {
                if (tmpc->ptr_stars_count)
                        tmpc--;
                tmpc = OptClassFwd(tmpc);
                return tmpc->raw_type;
        }

        return 0;
}

U0 CompMinTypePointed(CIntermediateCode *tmpi, I64 pt1)
{
        I64 pt;

        if ((pt = tmpi->arg1_type_pointed_to) && pt != RT_F64 && 0 < pt1 < pt)
                tmpi->arg1_type_pointed_to = pt;
}

U0 CompF1PushPop(CIntermediateCode *tmpi, CIntermediateCode *tmpi2)
{
        if (intermediate_code_table[tmpi2->ic_code].fpop || tmpi2->ic_flags & ICF_RES_TO_F64)
                Bts(&tmpi->ic_flags, ICf_DONT_PUSH_FLOAT0);
}

U0 CompF2PushPop(CIntermediateCode *tmpi, CIntermediateCode *tmpi1, CIntermediateCode *tmpi2)
{
        if ((tmpi2->ic_code == IC_MOV || tmpi2->ic_code == IC_IMM_F64) && !(tmpi2->ic_flags & ICF_RES_TO_F64) &&
                        (intermediate_code_table[tmpi1->ic_code].fpop || tmpi1->ic_flags & ICF_RES_TO_F64))
                Bts(&tmpi->ic_flags, ICf_DONT_PUSH_FLOAT0);
        else if ((intermediate_code_table[tmpi2->ic_code].fpop || tmpi2->ic_flags & ICF_RES_TO_F64) &&
                        !(tmpi1->ic_flags & ICF_RES_TO_F64))
                Bts(&tmpi->ic_flags, ICf_DONT_PUSH_FLOAT0);
}

class COptMemberVar
{
        I64                      score, offset_start, offset_end, lea_balance;
        CMemberList     *m;
};

I64 OptMVCompare(COptMemberVar *mv1, COptMemberVar *mv2)
{
        return mv2->score-mv1->score;
}