vec.refno = refl1;
            T264_predict_mv(t, 1, 0, 4, &vec); 
            copy_nvec(&vec, &vec_direct[1][0], 4, 4, 4);
        }

        // colZeroFlag
        T264_try_get_col_zero_mv(t, vec_direct, refl0, refl1);
		
		t->mb.mb_part = mb_part;	//restore
    }
    else
    {
        assert(0);
    }    
}

uint32_t
T264_mode_decision_inter_direct_16x16b(_RW T264_t* t, T264_vector_t predVec[2][4 * 4], uint8_t* pred, uint8_t* part)
{
    uint32_t sad;

	T264_get_direct_mv(t,predVec);
	T264_mb4x4_interb_mc(t,predVec,pred);
	sad = t->cmp[MB_16x16](pred,16,t->mb.src_y,t->stride);
	*part = B_DIRECT_16x16;

	return sad;
}

uint32_t
T264_mode_decision_inter_16x16b(_RW T264_t* t, T264_vector_t vec_best[2][2], uint8_t* pred, uint8_t* part)
{
    DECLARE_ALIGNED_MATRIX(pred_l1, 16, 16, uint8_t, CACHE_SIZE);
    DECLARE_ALIGNED_MATRIX(pred_bi, 16, 16, uint8_t, CACHE_SIZE);
    
    T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
    T264_search_context_t context;
    int32_t num;
    uint32_t sad_min, sad;
    uint8_t* pred_l0 = pred;
    uint8_t* p_min = pred_l0;
    T264_vector_t vec_median;
    int32_t i;
    uint8_t* p_buf = pred_l1;

    context.height = 16;
    context.width  = 16;
    context.limit_x= t->param.search_x;
    context.limit_y= t->param.search_y;
    context.vec    = vec;
    context.mb_part= MB_16x16;
    context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);

    // list 0
    vec[0].refno = 0;
    get_pmv(t, 0, vec, MB_16x16, 0, 4, &num);
    context.vec_num= num;
    context.list_index = 0;

    sad_min = t->search(t, &context);
    sad_min+= REFCOST(context.vec_best.refno);
    sad_min = T264_quarter_pixel_search(t, 0, t->mb.src_y, t->ref[0][context.vec_best.refno], context.offset, 
        &context.vec_best, &vec[0], sad_min, 16, 16, p_min, MB_16x16);
    for(i = 1 ; i < t->refl0_num ; i ++)
    {
        T264_vector_t vec_best_bak, vec_median_bak;
        
        vec_median_bak = vec[0];
        vec_best_bak = context.vec_best;
        
        vec[0].refno = i;
        get_pmv(t, 0, vec, MB_16x16, 0, 4, &num);
        context.vec_num= 1;
        sad = t->search(t, &context);
        sad+= REFCOST(context.vec_best.refno);
        sad = T264_quarter_pixel_search(t, 0, t->mb.src_y, t->ref[0][i], context.offset, 
            &context.vec_best, &vec[0], sad, 16, 16, p_buf, MB_16x16);
        if (sad < sad_min)
        {
            SWAP(uint8_t, p_buf, p_min);
            sad_min = sad;
        }
        else
        {
            vec[0] = vec_median_bak;
            context.vec_best = vec_best_bak;
        }
    }
    if (p_min != pred_l0)
    {
        memcpy(pred_l0, p_min, sizeof(uint8_t) * 16 * 16);
    }

    vec_best[0][0] = context.vec_best;
    vec_median = vec[0];
    *part = B_L0_16x16;

    // list 1
    vec_best[0][1].refno = -1;
    vec_best[0][1].x = 0;
    vec_best[0][1].y = 0;
    if (t->refl1_num > 0)
    {
        uint32_t sad_l1, sad_bi;

        vec[0].refno = 0;
        get_pmv(t, 1, vec, MB_16x16, 0, 4, &num);
        context.vec_num = num;
        context.list_index = 1;

        sad_l1 = t->search(t, &context);
        sad_l1+= REFCOST1(context.vec_best.refno);
        sad_l1 = T264_quarter_pixel_search(t, 1, t->mb.src_y, t->ref[1][context.vec_best.refno], context.offset, 
            &context.vec_best, &vec[0], sad_l1, 16, 16, pred_l1, MB_16x16);
        vec_best[0][1] = context.vec_best;

        t->pia[MB_16x16](pred_l0, pred_l1, 16, 16, pred_bi, 16);
        sad_bi = t->cmp[MB_16x16](t->mb.src_y, t->stride, pred_bi, 16) + t->mb.lambda *
            (eg_size_se(t->bs, vec_best[0][0].x - vec_median.x) +
             eg_size_se(t->bs, vec_best[0][0].y - vec_median.y) +
             eg_size_se(t->bs, vec_best[0][1].x - vec[0].x) +
             eg_size_se(t->bs, vec_best[0][1].y - vec[0].y)) +
             REFCOST(vec_best[0][0].refno);

        if (sad_bi < sad_min)
        {
            sad_min = sad_bi;
            *part = B_Bi_16x16;
            memcpy(pred_l0, pred_bi, 256 * sizeof(uint8_t));
        }
        if (sad_l1 < sad_min)
        {
            sad_min = sad_l1;
            *part = B_L1_16x16;
            memcpy(pred_l0, pred_l1, 256 * sizeof(uint8_t));

            vec_best[0][0].refno = -1;
            vec_best[0][0].x = 0;
            vec_best[0][0].y = 0;
        }
        if (*part == B_L0_16x16)
        {
            vec_best[0][1].refno = -1;
            vec_best[0][1].x = 0;
            vec_best[0][1].y = 0;
        }
    }
//    t->mb.is_copy = T264_detect_direct_16x16(t, vec_best[0]);

    return sad_min;
}

uint32_t
T264_mode_decision_inter_16x8b(_RW T264_t* t, T264_vector_t vec_best[2][2], uint8_t* pred, uint8_t* part)
{
    DECLARE_ALIGNED_MATRIX(pred_l1_m, 16, 16, uint8_t, CACHE_SIZE);
    DECLARE_ALIGNED_MATRIX(pred_bi_m, 16, 16, uint8_t, CACHE_SIZE);

    T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
    T264_search_context_t context;
    int32_t num;
    uint32_t sad_min;
    uint32_t sad_all = 0;
    uint8_t* pred_l0 = pred;
    uint8_t* pred_l1 = pred_l1_m;
    uint8_t* pred_bi = pred_bi_m;
    T264_vector_t vec_median;
    uint8_t old_part = t->mb.mb_part;
    int32_t i;
    uint8_t* src;

    t->mb.mb_part = MB_16x8;

    context.height = 8;
    context.width  = 16;
    context.limit_x= t->param.search_x;
    context.limit_y= t->param.search_y;
    context.vec    = vec;
    context.mb_part= MB_16x8;
    context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
    src = t->mb.src_y;

    for (i = 0 ; i < 2 ; i ++)
    {
        // list 0
        vec[0].refno = vec_best[0][0].refno;
        get_pmv(t, 0, vec, MB_16x8, luma_index[8 * i], 4, &num);
        context.vec_num= num;
        context.list_index = 0;

        sad_min = t->search(t, &context);
        sad_min+= REFCOST(context.vec_best.refno);
        sad_min = T264_quarter_pixel_search(t, 0, src, t->ref[0][context.vec_best.refno], context.offset, 
            &context.vec_best, &vec[0], sad_min, 16, 8, pred_l0, MB_16x8);
        vec_best[i][0] = context.vec_best;
        vec_median = vec[0];
        part[i] = B_L0_16x8;

        // list 1
        vec_best[i][1].refno = -1;
        vec_best[i][1].x = 0;
        vec_best[i][1].y = 0;
        if (t->refl1_num > 0)
        {
            uint32_t sad_l1, sad_bi;

            vec[0].refno = 0;
            get_pmv(t, 1, vec, MB_16x8, luma_index[8 * i], 4, &num);
            context.vec_num = num;
            context.list_index = 1;

            sad_l1 = t->search(t, &context);
            sad_l1+= REFCOST1(context.vec_best.refno);
            sad_l1 = T264_quarter_pixel_search(t, 1, src, t->ref[1][context.vec_best.refno], context.offset, 
                &context.vec_best, &vec[0], sad_l1, 16, 8, pred_l1, MB_16x8);
            vec_best[i][1] = context.vec_best;

            t->pia[MB_16x8](pred_l0, pred_l1, 16, 16, pred_bi, 16);
            sad_bi = t->cmp[MB_16x8](src, t->stride, pred_bi, 16) + t->mb.lambda *
                (eg_size_se(t->bs, vec_best[i][0].x - vec_median.x) +
                eg_size_se(t->bs, vec_best[i][0].y - vec_median.y) +
                eg_size_se(t->bs, vec_best[i][1].x - vec[0].x) +
                eg_size_se(t->bs, vec_best[i][1].y - vec[0].y)) +
                REFCOST(vec_best[i][0].refno);

            if (sad_bi < sad_min)
            {
                sad_min = sad_bi;
                part[i] = B_Bi_16x8;
                memcpy(pred_l0, pred_bi, sizeof(uint8_t) * 16 * 8);
            }
            if (sad_l1 < sad_min)
            {
                sad_min = sad_l1;
                part[i] = B_L1_16x8;
                memcpy(pred_l0, pred_l1, sizeof(uint8_t) * 16 * 8);

                vec_best[i][0].refno = -1;
                vec_best[i][0].x = 0;
                vec_best[i][0].y = 0;
            }
            if (part[i] == B_L0_16x8)
            {
                vec_best[i][1].refno = -1;
                vec_best[i][1].x = 0;
                vec_best[i][1].y = 0;
            }
        }

        pred_l0 += 16 * 8;
        pred_l1 += 16 * 8;
        pred_bi += 16 * 8;
        t->mb.vec_ref[VEC_LUMA + 8].vec[0] = vec_best[i][0];
        t->mb.vec_ref[VEC_LUMA + 8].vec[1] = vec_best[i][1];
        context.offset += 8 * t->edged_stride;
        src += 8 * t->stride;
        sad_all += sad_min;
    }
    t->mb.mb_part = old_part;

    return sad_all;
}

uint32_t
T264_mode_decision_inter_8x16b(_RW T264_t* t, T264_vector_t vec_best[2][2], uint8_t* pred, uint8_t* part)
{
    DECLARE_ALIGNED_MATRIX(pred_l1_m, 16, 16, uint8_t, CACHE_SIZE);
    DECLARE_ALIGNED_MATRIX(pred_bi_m, 16, 16, uint8_t, CACHE_SIZE);

    T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
    T264_search_context_t context;
    int32_t num;
    uint32_t sad_min;
    uint32_t sad_all = 0;
    uint8_t* pred_l0 = pred;
    uint8_t* pred_l1 = pred_l1_m;
    uint8_t* pred_bi = pred_bi_m;
    T264_vector_t vec_median;
    uint8_t old_part = t->mb.mb_part;
    int32_t i;
    uint8_t* src;

    t->mb.mb_part = MB_8x16;

    context.height = 16;
    context.width  = 8;
    context.limit_x= t->param.search_x;
    context.limit_y= t->param.search_y;
    context.vec    = vec;
    context.mb_part= MB_8x16;
    context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
    src = t->mb.src_y;

    for (i = 0 ; i < 2 ; i ++)
    {
        // list 0
        vec[0].refno = vec_best[0][0].refno;
        get_pmv(t, 0, vec, MB_8x16, luma_index[4 * i], 2, &num);
        context.vec_num= num;
        context.list_index = 0;

        sad_min = t->search(t, &context);
        sad_min+= REFCOST(context.vec_best.refno);
        sad_min = T264_quarter_pixel_search(t, 0, src, t->ref[0][context.vec_best.refno], context.offset, 
            &context.vec_best, &vec[0], sad_min, 8, 16, pred_l0, MB_8x16);
        vec_best[i][0] = context.vec_best;
        vec_median = vec[0];
        part[i] = B_L0_8x16;

        // list 1
        vec_best[i][1].refno = -1;
        vec_best[i][1].x = 0;
        vec_best[i][1].y = 0;
        if (t->refl1_num > 0)
        {
            uint32_t sad_l1, sad_bi;

            vec[0].refno = 0;
            get_pmv(t, 1, vec, MB_8x16, luma_index[4 * i], 2, &num);
            context.vec_num = num;
            context.list_index = 1;

            sad_l1 = t->search(t, &context);
            sad_l1+= REFCOST1(context.vec_best.refno);
            sad_l1 = T264_quarter_pixel_search(t, 1, src, t->ref[1][context.vec_best.refno], context.offset, 
                &context.vec_best, &vec[0], sad_l1, 8, 16, pred_l1, MB_8x16);
            vec_best[i][1] = context.vec_best;

            t->pia[MB_8x16](pred_l0, pred_l1, 16, 16, pred_bi, 16);
            sad_bi = t->cmp[MB_8x16](src, t->stride, pred_bi, 16) + t->mb.lambda *
                (eg_size_se(t->bs, vec_best[i][0].x - vec_median.x) +
                eg_size_se(t->bs, vec_best[i][0].y - vec_median.y) +
                eg_size_se(t->bs, vec_best[i][1].x - vec[0].x) +
                eg_size_se(t->bs, vec_best[i][1].y - vec[0].y)) +
                REFCOST(vec_best[i][0].refno);

            if (sad_bi < sad_min)
            {
                sad_min = sad_bi;
                part[i] = B_Bi_8x16;
                t->memcpy_stride_u(pred_bi, 8, 16, 16, pred_l0, 16);