static void pred_temp_direct_motion(const H264Context *const h, H264SliceContext *sl,

                                    int *mb_type)

{

    int b8_stride = 2;

    int b4_stride = h->b_stride;

    int mb_xy = sl->mb_xy, mb_y = sl->mb_y;

    int mb_type_col[2];

    const int16_t (*l1mv0)[2], (*l1mv1)[2];

    const int8_t *l1ref0, *l1ref1;

    const int is_b8x8 = IS_8X8(*mb_type);

    unsigned int sub_mb_type;

    int i8, i4;



    assert(sl->ref_list[1][0].reference & 3);



    await_reference_mb_row(h, sl->ref_list[1][0].parent,

                           sl->mb_y + !!IS_INTERLACED(*mb_type));



    if (IS_INTERLACED(sl->ref_list[1][0].parent->mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL

        if (!IS_INTERLACED(*mb_type)) {                    //     AFR/FR    -> AFL/FL

            mb_y  = (sl->mb_y & ~1) + sl->col_parity;

            mb_xy = sl->mb_x +

                    ((sl->mb_y & ~1) + sl->col_parity) * h->mb_stride;

            b8_stride = 0;

        } else {

            mb_y  += sl->col_fieldoff;

            mb_xy += h->mb_stride * sl->col_fieldoff; // non-zero for FL -> FL & differ parity

        }

        goto single_col;

    } else {                                        // AFL/AFR/FR/FL -> AFR/FR

        if (IS_INTERLACED(*mb_type)) {              // AFL       /FL -> AFR/FR

            mb_y           = sl->mb_y & ~1;

            mb_xy          = sl->mb_x + (sl->mb_y & ~1) * h->mb_stride;

            mb_type_col[0] = sl->ref_list[1][0].parent->mb_type[mb_xy];

            mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy + h->mb_stride];

            b8_stride      = 2 + 4 * h->mb_stride;

            b4_stride     *= 6;

            if (IS_INTERLACED(mb_type_col[0]) !=

                IS_INTERLACED(mb_type_col[1])) {

                mb_type_col[0] &= ~MB_TYPE_INTERLACED;

                mb_type_col[1] &= ~MB_TYPE_INTERLACED;

            }



            sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                          MB_TYPE_DIRECT2;                  /* B_SUB_8x8 */



            if ((mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) &&

                (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) &&

                !is_b8x8) {

                *mb_type |= MB_TYPE_16x8 | MB_TYPE_L0L1 |

                            MB_TYPE_DIRECT2;                /* B_16x8 */

            } else {

                *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;

            }

        } else {                                    //     AFR/FR    -> AFR/FR

single_col:

            mb_type_col[0]     =

                mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy];



            sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                          MB_TYPE_DIRECT2;                  /* B_SUB_8x8 */

            if (!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)) {

                *mb_type |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                            MB_TYPE_DIRECT2;                /* B_16x16 */

            } else if (!is_b8x8 &&

                       (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {

                *mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |

                            (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));

            } else {

                if (!h->ps.sps->direct_8x8_inference_flag) {

                    /* FIXME: save sub mb types from previous frames (or derive

                     * from MVs) so we know exactly what block size to use */

                    sub_mb_type = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                                  MB_TYPE_DIRECT2;          /* B_SUB_4x4 */

                }

                *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;

            }

        }

    }



    await_reference_mb_row(h, sl->ref_list[1][0].parent, mb_y);



    l1mv0  = &sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];

    l1mv1  = &sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];

    l1ref0 = &sl->ref_list[1][0].parent->ref_index[0][4 * mb_xy];

    l1ref1 = &sl->ref_list[1][0].parent->ref_index[1][4 * mb_xy];

    if (!b8_stride) {

        if (sl->mb_y & 1) {

            l1ref0 += 2;

            l1ref1 += 2;

            l1mv0  += 2 * b4_stride;

            l1mv1  += 2 * b4_stride;

        }

    }



    {

        const int *map_col_to_list0[2] = { sl->map_col_to_list0[0],

                                           sl->map_col_to_list0[1] };

        const int *dist_scale_factor = sl->dist_scale_factor;

        int ref_offset;



        if (FRAME_MBAFF(h) && IS_INTERLACED(*mb_type)) {

            map_col_to_list0[0] = sl->map_col_to_list0_field[sl->mb_y & 1][0];

            map_col_to_list0[1] = sl->map_col_to_list0_field[sl->mb_y & 1][1];

            dist_scale_factor   = sl->dist_scale_factor_field[sl->mb_y & 1];

        }

        ref_offset = (sl->ref_list[1][0].parent->mbaff << 4) & (mb_type_col[0] >> 3);



        if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {

            int y_shift = 2 * !IS_INTERLACED(*mb_type);

            assert(h->ps.sps->direct_8x8_inference_flag);



            for (i8 = 0; i8 < 4; i8++) {

                const int x8 = i8 & 1;

                const int y8 = i8 >> 1;

                int ref0, scale;

                const int16_t (*l1mv)[2] = l1mv0;



                if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))

                    continue;

                sl->sub_mb_type[i8] = sub_mb_type;



                fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                if (IS_INTRA(mb_type_col[y8])) {

                    fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    continue;

                }



                ref0 = l1ref0[x8 + y8 * b8_stride];

                if (ref0 >= 0)

                    ref0 = map_col_to_list0[0][ref0 + ref_offset];

                else {

                    ref0 = map_col_to_list0[1][l1ref1[x8 + y8 * b8_stride] +

                                               ref_offset];

                    l1mv = l1mv1;

                }

                scale = dist_scale_factor[ref0];

                fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,

                               ref0, 1);



                {

                    const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];

                    int my_col            = (mv_col[1] << y_shift) / 2;

                    int mx                = (scale * mv_col[0] + 128) >> 8;

                    int my                = (scale * my_col    + 128) >> 8;

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx, my), 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx - mv_col[0], my - my_col), 4);

                }

            }

            return;

        }



        /* one-to-one mv scaling */



        if (IS_16X16(*mb_type)) {

            int ref, mv0, mv1;



            fill_rectangle(&sl->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);

            if (IS_INTRA(mb_type_col[0])) {

                ref = mv0 = mv1 = 0;

            } else {

                const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]

                                                : map_col_to_list0[1][l1ref1[0] + ref_offset];

                const int scale = dist_scale_factor[ref0];

                const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];

                int mv_l0[2];

                mv_l0[0] = (scale * mv_col[0] + 128) >> 8;

                mv_l0[1] = (scale * mv_col[1] + 128) >> 8;

                ref      = ref0;

                mv0      = pack16to32(mv_l0[0], mv_l0[1]);

                mv1      = pack16to32(mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1]);

            }

            fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);

            fill_rectangle(&sl->mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);

            fill_rectangle(&sl->mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);

        } else {

            for (i8 = 0; i8 < 4; i8++) {

                const int x8 = i8 & 1;

                const int y8 = i8 >> 1;

                int ref0, scale;

                const int16_t (*l1mv)[2] = l1mv0;



                if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))

                    continue;

                sl->sub_mb_type[i8] = sub_mb_type;

                fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                if (IS_INTRA(mb_type_col[0])) {

                    fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    continue;

                }



                assert(b8_stride == 2);

                ref0 = l1ref0[i8];

                if (ref0 >= 0)

                    ref0 = map_col_to_list0[0][ref0 + ref_offset];

                else {

                    ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset];

                    l1mv = l1mv1;

                }

                scale = dist_scale_factor[ref0];



                fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,

                               ref0, 1);

                if (IS_SUB_8X8(sub_mb_type)) {

                    const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];

                    int mx                = (scale * mv_col[0] + 128) >> 8;

                    int my                = (scale * mv_col[1] + 128) >> 8;

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx, my), 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx - mv_col[0], my - mv_col[1]), 4);

                } else {

                    for (i4 = 0; i4 < 4; i4++) {

                        const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +

                                                     (y8 * 2 + (i4 >> 1)) * b4_stride];

                        int16_t *mv_l0 = sl->mv_cache[0][scan8[i8 * 4 + i4]];

                        mv_l0[0] = (scale * mv_col[0] + 128) >> 8;

                        mv_l0[1] = (scale * mv_col[1] + 128) >> 8;

                        AV_WN32A(sl->mv_cache[1][scan8[i8 * 4 + i4]],

                                 pack16to32(mv_l0[0] - mv_col[0],

                                            mv_l0[1] - mv_col[1]));

                    }

                }

            }

        }

    }

}

static void pred_temp_direct_motion(const H264Context *const h, H264SliceContext *sl,

                                    int *mb_type)

{

    int b8_stride = 2;

    int b4_stride = h->b_stride;

    int mb_xy = sl->mb_xy, mb_y = sl->mb_y;

    int mb_type_col[2];

    const int16_t (*l1mv0)[2], (*l1mv1)[2];

    const int8_t *l1ref0, *l1ref1;

    const int is_b8x8 = IS_8X8(*mb_type);

    unsigned int sub_mb_type;

    int i8, i4;



    assert(sl->ref_list[1][0].reference & 3);



    await_reference_mb_row(h, sl->ref_list[1][0].parent,

                           sl->mb_y + !!IS_INTERLACED(*mb_type));



    if (IS_INTERLACED(sl->ref_list[1][0].parent->mb_type[mb_xy])) { 

        if (!IS_INTERLACED(*mb_type)) {                    

            mb_y  = (sl->mb_y & ~1) + sl->col_parity;

            mb_xy = sl->mb_x +

                    ((sl->mb_y & ~1) + sl->col_parity) * h->mb_stride;

            b8_stride = 0;

        } else {

            mb_y  += sl->col_fieldoff;

            mb_xy += h->mb_stride * sl->col_fieldoff; 

        }

        goto single_col;

    } else {                                        

        if (IS_INTERLACED(*mb_type)) {              

            mb_y           = sl->mb_y & ~1;

            mb_xy          = sl->mb_x + (sl->mb_y & ~1) * h->mb_stride;

            mb_type_col[0] = sl->ref_list[1][0].parent->mb_type[mb_xy];

            mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy + h->mb_stride];

            b8_stride      = 2 + 4 * h->mb_stride;

            b4_stride     *= 6;

            if (IS_INTERLACED(mb_type_col[0]) !=

                IS_INTERLACED(mb_type_col[1])) {

                mb_type_col[0] &= ~MB_TYPE_INTERLACED;

                mb_type_col[1] &= ~MB_TYPE_INTERLACED;

            }



            sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                          MB_TYPE_DIRECT2;                  



            if ((mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) &&

                (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) &&

                !is_b8x8) {

                *mb_type |= MB_TYPE_16x8 | MB_TYPE_L0L1 |

                            MB_TYPE_DIRECT2;                

            } else {

                *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;

            }

        } else {                                    

single_col:

            mb_type_col[0]     =

                mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy];



            sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                          MB_TYPE_DIRECT2;                  

            if (!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)) {

                *mb_type |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                            MB_TYPE_DIRECT2;                

            } else if (!is_b8x8 &&

                       (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {

                *mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |

                            (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));

            } else {

                if (!h->ps.sps->direct_8x8_inference_flag) {

                    



                    sub_mb_type = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                                  MB_TYPE_DIRECT2;          

                }

                *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;

            }

        }

    }



    await_reference_mb_row(h, sl->ref_list[1][0].parent, mb_y);



    l1mv0  = &sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];

    l1mv1  = &sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];

    l1ref0 = &sl->ref_list[1][0].parent->ref_index[0][4 * mb_xy];

    l1ref1 = &sl->ref_list[1][0].parent->ref_index[1][4 * mb_xy];

    if (!b8_stride) {

        if (sl->mb_y & 1) {

            l1ref0 += 2;

            l1ref1 += 2;

            l1mv0  += 2 * b4_stride;

            l1mv1  += 2 * b4_stride;

        }

    }



    {

        const int *map_col_to_list0[2] = { sl->map_col_to_list0[0],

                                           sl->map_col_to_list0[1] };

        const int *dist_scale_factor = sl->dist_scale_factor;

        int ref_offset;



        if (FRAME_MBAFF(h) && IS_INTERLACED(*mb_type)) {

            map_col_to_list0[0] = sl->map_col_to_list0_field[sl->mb_y & 1][0];

            map_col_to_list0[1] = sl->map_col_to_list0_field[sl->mb_y & 1][1];

            dist_scale_factor   = sl->dist_scale_factor_field[sl->mb_y & 1];

        }

        ref_offset = (sl->ref_list[1][0].parent->mbaff << 4) & (mb_type_col[0] >> 3);



        if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {

            int y_shift = 2 * !IS_INTERLACED(*mb_type);

            assert(h->ps.sps->direct_8x8_inference_flag);



            for (i8 = 0; i8 < 4; i8++) {

                const int x8 = i8 & 1;

                const int y8 = i8 >> 1;

                int ref0, scale;

                const int16_t (*l1mv)[2] = l1mv0;



                if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))

                    continue;

                sl->sub_mb_type[i8] = sub_mb_type;



                fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                if (IS_INTRA(mb_type_col[y8])) {

                    fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    continue;

                }



                ref0 = l1ref0[x8 + y8 * b8_stride];

                if (ref0 >= 0)

                    ref0 = map_col_to_list0[0][ref0 + ref_offset];

                else {

                    ref0 = map_col_to_list0[1][l1ref1[x8 + y8 * b8_stride] +

                                               ref_offset];

                    l1mv = l1mv1;

                }

                scale = dist_scale_factor[ref0];

                fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,

                               ref0, 1);



                {

                    const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];

                    int my_col            = (mv_col[1] << y_shift) / 2;

                    int mx                = (scale * mv_col[0] + 128) >> 8;

                    int my                = (scale * my_col    + 128) >> 8;

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx, my), 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx - mv_col[0], my - my_col), 4);

                }

            }

            return;

        }



        



        if (IS_16X16(*mb_type)) {

            int ref, mv0, mv1;



            fill_rectangle(&sl->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);

            if (IS_INTRA(mb_type_col[0])) {

                ref = mv0 = mv1 = 0;

            } else {

                const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]

                                                : map_col_to_list0[1][l1ref1[0] + ref_offset];

                const int scale = dist_scale_factor[ref0];

                const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];

                int mv_l0[2];

                mv_l0[0] = (scale * mv_col[0] + 128) >> 8;

                mv_l0[1] = (scale * mv_col[1] + 128) >> 8;

                ref      = ref0;

                mv0      = pack16to32(mv_l0[0], mv_l0[1]);

                mv1      = pack16to32(mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1]);

            }

            fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);

            fill_rectangle(&sl->mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);

            fill_rectangle(&sl->mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);

        } else {

            for (i8 = 0; i8 < 4; i8++) {

                const int x8 = i8 & 1;

                const int y8 = i8 >> 1;

                int ref0, scale;

                const int16_t (*l1mv)[2] = l1mv0;



                if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))

                    continue;

                sl->sub_mb_type[i8] = sub_mb_type;

                fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                if (IS_INTRA(mb_type_col[0])) {

                    fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);

                    continue;

                }



                assert(b8_stride == 2);

                ref0 = l1ref0[i8];

                if (ref0 >= 0)

                    ref0 = map_col_to_list0[0][ref0 + ref_offset];

                else {

                    ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset];

                    l1mv = l1mv1;

                }

                scale = dist_scale_factor[ref0];



                fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,

                               ref0, 1);

                if (IS_SUB_8X8(sub_mb_type)) {

                    const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];

                    int mx                = (scale * mv_col[0] + 128) >> 8;

                    int my                = (scale * mv_col[1] + 128) >> 8;

                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx, my), 4);

                    fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,

                                   pack16to32(mx - mv_col[0], my - mv_col[1]), 4);

                } else {

                    for (i4 = 0; i4 < 4; i4++) {

                        const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +

                                                     (y8 * 2 + (i4 >> 1)) * b4_stride];

                        int16_t *mv_l0 = sl->mv_cache[0][scan8[i8 * 4 + i4]];

                        mv_l0[0] = (scale * mv_col[0] + 128) >> 8;

                        mv_l0[1] = (scale * mv_col[1] + 128) >> 8;

                        AV_WN32A(sl->mv_cache[1][scan8[i8 * 4 + i4]],

                                 pack16to32(mv_l0[0] - mv_col[0],

                                            mv_l0[1] - mv_col[1]));

                    }

                }

            }

        }

    }

}

    await_reference_mb_row(h, sl->ref_list[1][0].parent,     await_reference_mb_row(h, sl->ref_list[1][0].parent, mb_y);     await_reference_mb_row(h, sl->ref_list[1][0].parent,     await_reference_mb_row(h, sl->ref_list[1][0].parent, mb_y);
static void FUNC_0(const H264Context *const VAR_0, H264SliceContext *VAR_1,

                                    int *VAR_2)

{

    int VAR_3 = 2;

    int VAR_4 = VAR_0->b_stride;

    int VAR_5 = VAR_1->VAR_5, VAR_6 = VAR_1->VAR_6;

    int VAR_7[2];

    const FUNC_2 (*l1mv0)[2], (*l1mv1)[2];

    const int8_t *VAR_8, *l1ref1;

    const int VAR_9 = IS_8X8(*VAR_2);

    unsigned int VAR_10;

    int VAR_11, VAR_12;



    assert(VAR_1->ref_list[1][0].reference & 3);



    await_reference_mb_row(VAR_0, VAR_1->ref_list[1][0].parent,

                           VAR_1->VAR_6 + !!IS_INTERLACED(*VAR_2));



    if (IS_INTERLACED(VAR_1->ref_list[1][0].parent->VAR_2[VAR_5])) { 

        if (!IS_INTERLACED(*VAR_2)) {                    

            VAR_6  = (VAR_1->VAR_6 & ~1) + VAR_1->col_parity;

            VAR_5 = VAR_1->mb_x +

                    ((VAR_1->VAR_6 & ~1) + VAR_1->col_parity) * VAR_0->mb_stride;

            VAR_3 = 0;

        } else {

            VAR_6  += VAR_1->col_fieldoff;

            VAR_5 += VAR_0->mb_stride * VAR_1->col_fieldoff; 

        }

        goto single_col;

    } else {                                        

        if (IS_INTERLACED(*VAR_2)) {              

            VAR_6           = VAR_1->VAR_6 & ~1;

            VAR_5          = VAR_1->mb_x + (VAR_1->VAR_6 & ~1) * VAR_0->mb_stride;

            VAR_7[0] = VAR_1->ref_list[1][0].parent->VAR_2[VAR_5];

            VAR_7[1] = VAR_1->ref_list[1][0].parent->VAR_2[VAR_5 + VAR_0->mb_stride];

            VAR_3      = 2 + 4 * VAR_0->mb_stride;

            VAR_4     *= 6;

            if (IS_INTERLACED(VAR_7[0]) !=

                IS_INTERLACED(VAR_7[1])) {

                VAR_7[0] &= ~MB_TYPE_INTERLACED;

                VAR_7[1] &= ~MB_TYPE_INTERLACED;

            }



            VAR_10 = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                          MB_TYPE_DIRECT2;                  



            if ((VAR_7[0] & MB_TYPE_16x16_OR_INTRA) &&

                (VAR_7[1] & MB_TYPE_16x16_OR_INTRA) &&

                !VAR_9) {

                *VAR_2 |= MB_TYPE_16x8 | MB_TYPE_L0L1 |

                            MB_TYPE_DIRECT2;                

            } else {

                *VAR_2 |= MB_TYPE_8x8 | MB_TYPE_L0L1;

            }

        } else {                                    

single_col:

            VAR_7[0]     =

                VAR_7[1] = VAR_1->ref_list[1][0].parent->VAR_2[VAR_5];



            VAR_10 = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                          MB_TYPE_DIRECT2;                  

            if (!VAR_9 && (VAR_7[0] & MB_TYPE_16x16_OR_INTRA)) {

                *VAR_2 |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                            MB_TYPE_DIRECT2;                

            } else if (!VAR_9 &&

                       (VAR_7[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {

                *VAR_2 |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |

                            (VAR_7[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));

            } else {

                if (!VAR_0->ps.sps->direct_8x8_inference_flag) {

                    



                    VAR_10 = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |

                                  MB_TYPE_DIRECT2;          

                }

                *VAR_2 |= MB_TYPE_8x8 | MB_TYPE_L0L1;

            }

        }

    }



    await_reference_mb_row(VAR_0, VAR_1->ref_list[1][0].parent, VAR_6);



    l1mv0  = &VAR_1->ref_list[1][0].parent->motion_val[0][VAR_0->mb2b_xy[VAR_5]];

    l1mv1  = &VAR_1->ref_list[1][0].parent->motion_val[1][VAR_0->mb2b_xy[VAR_5]];

    VAR_8 = &VAR_1->ref_list[1][0].parent->ref_index[0][4 * VAR_5];

    l1ref1 = &VAR_1->ref_list[1][0].parent->ref_index[1][4 * VAR_5];

    if (!VAR_3) {

        if (VAR_1->VAR_6 & 1) {

            VAR_8 += 2;

            l1ref1 += 2;

            l1mv0  += 2 * VAR_4;

            l1mv1  += 2 * VAR_4;

        }

    }



    {

        const int *VAR_13[2] = { VAR_1->VAR_13[0],

                                           VAR_1->VAR_13[1] };

        const int *VAR_14 = VAR_1->VAR_14;

        int VAR_15;



        if (FRAME_MBAFF(VAR_0) && IS_INTERLACED(*VAR_2)) {

            VAR_13[0] = VAR_1->map_col_to_list0_field[VAR_1->VAR_6 & 1][0];

            VAR_13[1] = VAR_1->map_col_to_list0_field[VAR_1->VAR_6 & 1][1];

            VAR_14   = VAR_1->dist_scale_factor_field[VAR_1->VAR_6 & 1];

        }

        VAR_15 = (VAR_1->ref_list[1][0].parent->mbaff << 4) & (VAR_7[0] >> 3);



        if (IS_INTERLACED(*VAR_2) != IS_INTERLACED(VAR_7[0])) {

            int VAR_16 = 2 * !IS_INTERLACED(*VAR_2);

            assert(VAR_0->ps.sps->direct_8x8_inference_flag);



            for (VAR_11 = 0; VAR_11 < 4; VAR_11++) {

                const int VAR_29 = VAR_11 & 1;

                const int VAR_29 = VAR_11 >> 1;

                int VAR_29, VAR_29;

                const FUNC_2 (*l1mv)[2] = l1mv0;



                if (VAR_9 && !IS_DIRECT(VAR_1->VAR_10[VAR_11]))

                    continue;

                VAR_1->VAR_10[VAR_11] = VAR_10;



                fill_rectangle(&VAR_1->ref_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1);

                if (IS_INTRA(VAR_7[VAR_29])) {

                    fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1);

                    fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4);

                    fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4);

                    continue;

                }



                VAR_29 = VAR_8[VAR_29 + VAR_29 * VAR_3];

                if (VAR_29 >= 0)

                    VAR_29 = VAR_13[0][VAR_29 + VAR_15];

                else {

                    VAR_29 = VAR_13[1][l1ref1[VAR_29 + VAR_29 * VAR_3] +

                                               VAR_15];

                    l1mv = l1mv1;

                }

                VAR_29 = VAR_14[VAR_29];

                fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,

                               VAR_29, 1);



                {

                    const FUNC_2 *VAR_29 = l1mv[VAR_29 * 3 + VAR_29 * VAR_4];

                    int VAR_22            = (VAR_29[1] << VAR_16) / 2;

                    int VAR_29                = (VAR_29 * VAR_29[0] + 128) >> 8;

                    int VAR_29                = (VAR_29 * VAR_22    + 128) >> 8;

                    fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,

                                   pack16to32(VAR_29, VAR_29), 4);

                    fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8,

                                   pack16to32(VAR_29 - VAR_29[0], VAR_29 - VAR_22), 4);

                }

            }

            return;

        }



        



        if (IS_16X16(*VAR_2)) {

            int VAR_25, VAR_26, VAR_27;



            fill_rectangle(&VAR_1->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);

            if (IS_INTRA(VAR_7[0])) {

                VAR_25 = VAR_26 = VAR_27 = 0;

            } else {

                const int VAR_29 = VAR_8[0] >= 0 ? VAR_13[0][VAR_8[0] + VAR_15]

                                                : VAR_13[1][l1ref1[0] + VAR_15];

                const int VAR_29 = VAR_14[VAR_29];

                const FUNC_2 *VAR_29 = VAR_8[0] >= 0 ? l1mv0[0] : l1mv1[0];

                int VAR_28[2];

                VAR_28[0] = (VAR_29 * VAR_29[0] + 128) >> 8;

                VAR_28[1] = (VAR_29 * VAR_29[1] + 128) >> 8;

                VAR_25      = VAR_29;

                VAR_26      = pack16to32(VAR_28[0], VAR_28[1]);

                VAR_27      = pack16to32(VAR_28[0] - VAR_29[0], VAR_28[1] - VAR_29[1]);

            }

            fill_rectangle(&VAR_1->ref_cache[0][scan8[0]], 4, 4, 8, VAR_25, 1);

            fill_rectangle(&VAR_1->mv_cache[0][scan8[0]], 4, 4, 8, VAR_26, 4);

            fill_rectangle(&VAR_1->mv_cache[1][scan8[0]], 4, 4, 8, VAR_27, 4);

        } else {

            for (VAR_11 = 0; VAR_11 < 4; VAR_11++) {

                const int VAR_29 = VAR_11 & 1;

                const int VAR_29 = VAR_11 >> 1;

                int VAR_29, VAR_29;

                const FUNC_2 (*l1mv)[2] = l1mv0;



                if (VAR_9 && !IS_DIRECT(VAR_1->VAR_10[VAR_11]))

                    continue;

                VAR_1->VAR_10[VAR_11] = VAR_10;

                fill_rectangle(&VAR_1->ref_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1);

                if (IS_INTRA(VAR_7[0])) {

                    fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1);

                    fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4);

                    fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4);

                    continue;

                }



                assert(VAR_3 == 2);

                VAR_29 = VAR_8[VAR_11];

                if (VAR_29 >= 0)

                    VAR_29 = VAR_13[0][VAR_29 + VAR_15];

                else {

                    VAR_29 = VAR_13[1][l1ref1[VAR_11] + VAR_15];

                    l1mv = l1mv1;

                }

                VAR_29 = VAR_14[VAR_29];



                fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,

                               VAR_29, 1);

                if (IS_SUB_8X8(VAR_10)) {

                    const FUNC_2 *VAR_29 = l1mv[VAR_29 * 3 + VAR_29 * 3 * VAR_4];

                    int VAR_29                = (VAR_29 * VAR_29[0] + 128) >> 8;

                    int VAR_29                = (VAR_29 * VAR_29[1] + 128) >> 8;

                    fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,

                                   pack16to32(VAR_29, VAR_29), 4);

                    fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8,

                                   pack16to32(VAR_29 - VAR_29[0], VAR_29 - VAR_29[1]), 4);

                } else {

                    for (VAR_12 = 0; VAR_12 < 4; VAR_12++) {

                        const FUNC_2 *VAR_29 = l1mv[VAR_29 * 2 + (VAR_12 & 1) +

                                                     (VAR_29 * 2 + (VAR_12 >> 1)) * VAR_4];

                        FUNC_2 *VAR_28 = VAR_1->mv_cache[0][scan8[VAR_11 * 4 + VAR_12]];

                        VAR_28[0] = (VAR_29 * VAR_29[0] + 128) >> 8;

                        VAR_28[1] = (VAR_29 * VAR_29[1] + 128) >> 8;

                        AV_WN32A(VAR_1->mv_cache[1][scan8[VAR_11 * 4 + VAR_12]],

                                 pack16to32(VAR_28[0] - VAR_29[0],

                                            VAR_28[1] - VAR_29[1]));

                    }

                }

            }

        }

    }

}

static void FUNC_0(const H264Context *const VAR_0, H264SliceContext *VAR_1,
int *VAR_2)
{ int VAR_3 = 2; int VAR_4 = VAR_0->b_stride; int VAR_5 = VAR_1->VAR_5, VAR_6 = VAR_1->VAR_6; int VAR_7[2]; const FUNC_2 (*l1mv0)[2], (*l1mv1)[2]; const int8_t *VAR_8, *l1ref1; const int VAR_9 = IS_8X8(*VAR_2); unsigned int VAR_10; int VAR_11, VAR_12; assert(VAR_1->ref_list[1][0].reference & 3); await_reference_mb_row(VAR_0, VAR_1->ref_list[1][0].parent,
VAR_1->VAR_6 + !!IS_INTERLACED(*VAR_2)); if (IS_INTERLACED(VAR_1->ref_list[1][0].parent->VAR_2[VAR_5])) { if (!IS_INTERLACED(*VAR_2)) { VAR_6  = (VAR_1->VAR_6 & ~1) + VAR_1->col_parity; VAR_5 = VAR_1->mb_x +
((VAR_1->VAR_6 & ~1) + VAR_1->col_parity) * VAR_0->mb_stride; VAR_3 = 0; } else { VAR_6  += VAR_1->col_fieldoff; VAR_5 += VAR_0->mb_stride * VAR_1->col_fieldoff; } goto single_col; } else { if (IS_INTERLACED(*VAR_2)) { VAR_6           = VAR_1->VAR_6 & ~1; VAR_5          = VAR_1->mb_x + (VAR_1->VAR_6 & ~1) * VAR_0->mb_stride; VAR_7[0] = VAR_1->ref_list[1][0].parent->VAR_2[VAR_5]; VAR_7[1] = VAR_1->ref_list[1][0].parent->VAR_2[VAR_5 + VAR_0->mb_stride]; VAR_3      = 2 + 4 * VAR_0->mb_stride; VAR_4     *= 6; if (IS_INTERLACED(VAR_7[0]) !=
IS_INTERLACED(VAR_7[1])) { VAR_7[0] &= ~MB_TYPE_INTERLACED; VAR_7[1] &= ~MB_TYPE_INTERLACED; } VAR_10 = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
MB_TYPE_DIRECT2; if ((VAR_7[0] & MB_TYPE_16x16_OR_INTRA) &&
(VAR_7[1] & MB_TYPE_16x16_OR_INTRA) &&
!VAR_9) { *VAR_2 |= MB_TYPE_16x8 | MB_TYPE_L0L1 |
MB_TYPE_DIRECT2; } else { *VAR_2 |= MB_TYPE_8x8 | MB_TYPE_L0L1; } } else { single_col:
VAR_7[0]     =
VAR_7[1] = VAR_1->ref_list[1][0].parent->VAR_2[VAR_5]; VAR_10 = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
MB_TYPE_DIRECT2; if (!VAR_9 && (VAR_7[0] & MB_TYPE_16x16_OR_INTRA)) { *VAR_2 |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
MB_TYPE_DIRECT2; } else if (!VAR_9 && (VAR_7[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) { *VAR_2 |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |
(VAR_7[0] & (MB_TYPE_16x8 | MB_TYPE_8x16)); } else { if (!VAR_0->ps.sps->direct_8x8_inference_flag) { VAR_10 = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
MB_TYPE_DIRECT2; } *VAR_2 |= MB_TYPE_8x8 | MB_TYPE_L0L1; } } } await_reference_mb_row(VAR_0, VAR_1->ref_list[1][0].parent, VAR_6); l1mv0  = &VAR_1->ref_list[1][0].parent->motion_val[0][VAR_0->mb2b_xy[VAR_5]]; l1mv1  = &VAR_1->ref_list[1][0].parent->motion_val[1][VAR_0->mb2b_xy[VAR_5]]; VAR_8 = &VAR_1->ref_list[1][0].parent->ref_index[0][4 * VAR_5]; l1ref1 = &VAR_1->ref_list[1][0].parent->ref_index[1][4 * VAR_5]; if (!VAR_3) { if (VAR_1->VAR_6 & 1) { VAR_8 += 2; l1ref1 += 2; l1mv0  += 2 * VAR_4; l1mv1  += 2 * VAR_4; } } { const int *VAR_13[2] = { VAR_1->VAR_13[0], VAR_1->VAR_13[1] }; const int *VAR_14 = VAR_1->VAR_14; int VAR_15; if (FRAME_MBAFF(VAR_0) && IS_INTERLACED(*VAR_2)) { VAR_13[0] = VAR_1->map_col_to_list0_field[VAR_1->VAR_6 & 1][0]; VAR_13[1] = VAR_1->map_col_to_list0_field[VAR_1->VAR_6 & 1][1]; VAR_14   = VAR_1->dist_scale_factor_field[VAR_1->VAR_6 & 1]; } VAR_15 = (VAR_1->ref_list[1][0].parent->mbaff << 4) & (VAR_7[0] >> 3); if (IS_INTERLACED(*VAR_2) != IS_INTERLACED(VAR_7[0])) { int VAR_16 = 2 * !IS_INTERLACED(*VAR_2); assert(VAR_0->ps.sps->direct_8x8_inference_flag); for (VAR_11 = 0; VAR_11 < 4; VAR_11++) { const int VAR_29 = VAR_11 & 1; const int VAR_29 = VAR_11 >> 1; int VAR_29, VAR_29; const FUNC_2 (*l1mv)[2] = l1mv0; if (VAR_9 && !IS_DIRECT(VAR_1->VAR_10[VAR_11]))
continue; VAR_1->VAR_10[VAR_11] = VAR_10; fill_rectangle(&VAR_1->ref_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1); if (IS_INTRA(VAR_7[VAR_29])) { fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1); fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4); fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4); continue; } VAR_29 = VAR_8[VAR_29 + VAR_29 * VAR_3]; if (VAR_29 >= 0)
VAR_29 = VAR_13[0][VAR_29 + VAR_15]; else { VAR_29 = VAR_13[1][l1ref1[VAR_29 + VAR_29 * VAR_3] +
VAR_15]; l1mv = l1mv1; } VAR_29 = VAR_14[VAR_29]; fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,
VAR_29, 1); { const FUNC_2 *VAR_29 = l1mv[VAR_29 * 3 + VAR_29 * VAR_4]; int VAR_22            = (VAR_29[1] << VAR_16) / 2; int VAR_29                = (VAR_29 * VAR_29[0] + 128) >> 8; int VAR_29                = (VAR_29 * VAR_22    + 128) >> 8; fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,
pack16to32(VAR_29, VAR_29), 4); fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8,
pack16to32(VAR_29 - VAR_29[0], VAR_29 - VAR_22), 4); } } return; } if (IS_16X16(*VAR_2)) { int VAR_25, VAR_26, VAR_27; fill_rectangle(&VAR_1->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); if (IS_INTRA(VAR_7[0])) { VAR_25 = VAR_26 = VAR_27 = 0; } else { const int VAR_29 = VAR_8[0] >= 0 ? VAR_13[0][VAR_8[0] + VAR_15]
: VAR_13[1][l1ref1[0] + VAR_15]; const int VAR_29 = VAR_14[VAR_29]; const FUNC_2 *VAR_29 = VAR_8[0] >= 0 ? l1mv0[0] : l1mv1[0]; int VAR_28[2]; VAR_28[0] = (VAR_29 * VAR_29[0] + 128) >> 8; VAR_28[1] = (VAR_29 * VAR_29[1] + 128) >> 8; VAR_25      = VAR_29; VAR_26      = pack16to32(VAR_28[0], VAR_28[1]); VAR_27      = pack16to32(VAR_28[0] - VAR_29[0], VAR_28[1] - VAR_29[1]); } fill_rectangle(&VAR_1->ref_cache[0][scan8[0]], 4, 4, 8, VAR_25, 1); fill_rectangle(&VAR_1->mv_cache[0][scan8[0]], 4, 4, 8, VAR_26, 4); fill_rectangle(&VAR_1->mv_cache[1][scan8[0]], 4, 4, 8, VAR_27, 4); } else { for (VAR_11 = 0; VAR_11 < 4; VAR_11++) { const int VAR_29 = VAR_11 & 1; const int VAR_29 = VAR_11 >> 1; int VAR_29, VAR_29; const FUNC_2 (*l1mv)[2] = l1mv0; if (VAR_9 && !IS_DIRECT(VAR_1->VAR_10[VAR_11]))
continue; VAR_1->VAR_10[VAR_11] = VAR_10; fill_rectangle(&VAR_1->ref_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1); if (IS_INTRA(VAR_7[0])) { fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 1); fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4); fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8, 0, 4); continue; } assert(VAR_3 == 2); VAR_29 = VAR_8[VAR_11]; if (VAR_29 >= 0)
VAR_29 = VAR_13[0][VAR_29 + VAR_15]; else { VAR_29 = VAR_13[1][l1ref1[VAR_11] + VAR_15]; l1mv = l1mv1; } VAR_29 = VAR_14[VAR_29]; fill_rectangle(&VAR_1->ref_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,
VAR_29, 1); if (IS_SUB_8X8(VAR_10)) { const FUNC_2 *VAR_29 = l1mv[VAR_29 * 3 + VAR_29 * 3 * VAR_4]; int VAR_29                = (VAR_29 * VAR_29[0] + 128) >> 8; int VAR_29                = (VAR_29 * VAR_29[1] + 128) >> 8; fill_rectangle(&VAR_1->mv_cache[0][scan8[VAR_11 * 4]], 2, 2, 8,
pack16to32(VAR_29, VAR_29), 4); fill_rectangle(&VAR_1->mv_cache[1][scan8[VAR_11 * 4]], 2, 2, 8,
pack16to32(VAR_29 - VAR_29[0], VAR_29 - VAR_29[1]), 4); } else { for (VAR_12 = 0; VAR_12 < 4; VAR_12++) { const FUNC_2 *VAR_29 = l1mv[VAR_29 * 2 + (VAR_12 & 1) +
(VAR_29 * 2 + (VAR_12 >> 1)) * VAR_4]; FUNC_2 *VAR_28 = VAR_1->mv_cache[0][scan8[VAR_11 * 4 + VAR_12]]; VAR_28[0] = (VAR_29 * VAR_29[0] + 128) >> 8; VAR_28[1] = (VAR_29 * VAR_29[1] + 128) >> 8; AV_WN32A(VAR_1->mv_cache[1][scan8[VAR_11 * 4 + VAR_12]],
pack16to32(VAR_28[0] - VAR_29[0],
VAR_28[1] - VAR_29[1])); } } } } } }