static inline int pred_non_zero_count(H264Context *h, int n){
    const int index8= scan8[n];
    const int left= h->non_zero_count_cache[index8 - 1];
    const int top = h->non_zero_count_cache[index8 - 8];
    int i= left + top;
    if(i<64) i= (i+1)>>1;
    tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
    return i&31;
}
['static int decode_mb_cavlc(H264Context *h){\n    MpegEncContext * const s = &h->s;\n    const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;\n    int partition_count;\n    unsigned int mb_type, cbp;\n    int dct8x8_allowed= h->pps.transform_8x8_mode;\n    s->dsp.clear_blocks(h->mb);\n    tprintf(s->avctx, "pic:%d mb:%d/%d\\n", h->frame_num, s->mb_x, s->mb_y);\n    cbp = 0;\n    if(h->slice_type != FF_I_TYPE && h->slice_type != FF_SI_TYPE){\n        if(s->mb_skip_run==-1)\n            s->mb_skip_run= get_ue_golomb(&s->gb);\n        if (s->mb_skip_run--) {\n            if(FRAME_MBAFF && (s->mb_y&1) == 0){\n                if(s->mb_skip_run==0)\n                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);\n                else\n                    predict_field_decoding_flag(h);\n            }\n            decode_mb_skip(h);\n            return 0;\n        }\n    }\n    if(FRAME_MBAFF){\n        if( (s->mb_y&1) == 0 )\n            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);\n    }else\n        h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);\n    h->prev_mb_skipped= 0;\n    mb_type= get_ue_golomb(&s->gb);\n    if(h->slice_type == FF_B_TYPE){\n        if(mb_type < 23){\n            partition_count= b_mb_type_info[mb_type].partition_count;\n            mb_type=         b_mb_type_info[mb_type].type;\n        }else{\n            mb_type -= 23;\n            goto decode_intra_mb;\n        }\n    }else if(h->slice_type == FF_P_TYPE  ){\n        if(mb_type < 5){\n            partition_count= p_mb_type_info[mb_type].partition_count;\n            mb_type=         p_mb_type_info[mb_type].type;\n        }else{\n            mb_type -= 5;\n            goto decode_intra_mb;\n        }\n    }else{\n       assert(h->slice_type == FF_I_TYPE);\ndecode_intra_mb:\n        if(mb_type > 25){\n            av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);\n            return -1;\n        }\n        partition_count=0;\n        cbp= i_mb_type_info[mb_type].cbp;\n        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;\n        mb_type= i_mb_type_info[mb_type].type;\n    }\n    if(MB_FIELD)\n        mb_type |= MB_TYPE_INTERLACED;\n    h->slice_table[ mb_xy ]= h->slice_num;\n    if(IS_INTRA_PCM(mb_type)){\n        unsigned int x, y;\n        align_get_bits(&s->gb);\n        for(y=0; y<16; y++){\n            const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);\n            for(x=0; x<16; x++){\n                tprintf(s->avctx, "LUMA ICPM LEVEL (%3d)\\n", show_bits(&s->gb, 8));\n                h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8);\n            }\n        }\n        for(y=0; y<8; y++){\n            const int index= 256 + 4*(y&3) + 32*(y>>2);\n            for(x=0; x<8; x++){\n                tprintf(s->avctx, "CHROMA U ICPM LEVEL (%3d)\\n", show_bits(&s->gb, 8));\n                h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);\n            }\n        }\n        for(y=0; y<8; y++){\n            const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);\n            for(x=0; x<8; x++){\n                tprintf(s->avctx, "CHROMA V ICPM LEVEL (%3d)\\n", show_bits(&s->gb, 8));\n                h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);\n            }\n        }\n        s->current_picture.qscale_table[mb_xy]= 0;\n        h->chroma_qp[0] = get_chroma_qp(h, 0, 0);\n        h->chroma_qp[1] = get_chroma_qp(h, 1, 0);\n        memset(h->non_zero_count[mb_xy], 16, 16);\n        s->current_picture.mb_type[mb_xy]= mb_type;\n        return 0;\n    }\n    if(MB_MBAFF){\n        h->ref_count[0] <<= 1;\n        h->ref_count[1] <<= 1;\n    }\n    fill_caches(h, mb_type, 0);\n    if(IS_INTRA(mb_type)){\n            int pred_mode;\n            if(IS_INTRA4x4(mb_type)){\n                int i;\n                int di = 1;\n                if(dct8x8_allowed && get_bits1(&s->gb)){\n                    mb_type |= MB_TYPE_8x8DCT;\n                    di = 4;\n                }\n                for(i=0; i<16; i+=di){\n                    int mode= pred_intra_mode(h, i);\n                    if(!get_bits1(&s->gb)){\n                        const int rem_mode= get_bits(&s->gb, 3);\n                        mode = rem_mode + (rem_mode >= mode);\n                    }\n                    if(di==4)\n                        fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );\n                    else\n                        h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;\n                }\n                write_back_intra_pred_mode(h);\n                if( check_intra4x4_pred_mode(h) < 0)\n                    return -1;\n            }else{\n                h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);\n                if(h->intra16x16_pred_mode < 0)\n                    return -1;\n            }\n            pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb));\n            if(pred_mode < 0)\n                return -1;\n            h->chroma_pred_mode= pred_mode;\n    }else if(partition_count==4){\n        int i, j, sub_partition_count[4], list, ref[2][4];\n        if(h->slice_type == FF_B_TYPE){\n            for(i=0; i<4; i++){\n                h->sub_mb_type[i]= get_ue_golomb(&s->gb);\n                if(h->sub_mb_type[i] >=13){\n                    av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\\n", h->sub_mb_type[i], s->mb_x, s->mb_y);\n                    return -1;\n                }\n                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;\n                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;\n            }\n            if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])\n               || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {\n                pred_direct_motion(h, &mb_type);\n                h->ref_cache[0][scan8[4]] =\n                h->ref_cache[1][scan8[4]] =\n                h->ref_cache[0][scan8[12]] =\n                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;\n            }\n        }else{\n            assert(h->slice_type == FF_P_TYPE || h->slice_type == FF_SP_TYPE);\n            for(i=0; i<4; i++){\n                h->sub_mb_type[i]= get_ue_golomb(&s->gb);\n                if(h->sub_mb_type[i] >=4){\n                    av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\\n", h->sub_mb_type[i], s->mb_x, s->mb_y);\n                    return -1;\n                }\n                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;\n                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;\n            }\n        }\n        for(list=0; list<h->list_count; list++){\n            int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];\n            for(i=0; i<4; i++){\n                if(IS_DIRECT(h->sub_mb_type[i])) continue;\n                if(IS_DIR(h->sub_mb_type[i], 0, list)){\n                    unsigned int tmp = get_te0_golomb(&s->gb, ref_count);\n                    if(tmp>=ref_count){\n                        av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", tmp);\n                        return -1;\n                    }\n                    ref[list][i]= tmp;\n                }else{\n                    ref[list][i] = -1;\n                }\n            }\n        }\n        if(dct8x8_allowed)\n            dct8x8_allowed = get_dct8x8_allowed(h);\n        for(list=0; list<h->list_count; list++){\n            for(i=0; i<4; i++){\n                if(IS_DIRECT(h->sub_mb_type[i])) {\n                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];\n                    continue;\n                }\n                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=\n                h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];\n                if(IS_DIR(h->sub_mb_type[i], 0, list)){\n                    const int sub_mb_type= h->sub_mb_type[i];\n                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;\n                    for(j=0; j<sub_partition_count[i]; j++){\n                        int mx, my;\n                        const int index= 4*i + block_width*j;\n                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];\n                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);\n                        mx += get_se_golomb(&s->gb);\n                        my += get_se_golomb(&s->gb);\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        if(IS_SUB_8X8(sub_mb_type)){\n                            mv_cache[ 1 ][0]=\n                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;\n                            mv_cache[ 1 ][1]=\n                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;\n                        }else if(IS_SUB_8X4(sub_mb_type)){\n                            mv_cache[ 1 ][0]= mx;\n                            mv_cache[ 1 ][1]= my;\n                        }else if(IS_SUB_4X8(sub_mb_type)){\n                            mv_cache[ 8 ][0]= mx;\n                            mv_cache[ 8 ][1]= my;\n                        }\n                        mv_cache[ 0 ][0]= mx;\n                        mv_cache[ 0 ][1]= my;\n                    }\n                }else{\n                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];\n                    p[0] = p[1]=\n                    p[8] = p[9]= 0;\n                }\n            }\n        }\n    }else if(IS_DIRECT(mb_type)){\n        pred_direct_motion(h, &mb_type);\n        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;\n    }else{\n        int list, mx, my, i;\n        if(IS_16X16(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, 0, list)){\n                        val= get_te0_golomb(&s->gb, h->ref_count[list]);\n                        if(val >= h->ref_count[list]){\n                            av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                            return -1;\n                        }\n                    }else\n                        val= LIST_NOT_USED&0xFF;\n                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);\n            }\n            for(list=0; list<h->list_count; list++){\n                unsigned int val;\n                if(IS_DIR(mb_type, 0, list)){\n                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);\n                    mx += get_se_golomb(&s->gb);\n                    my += get_se_golomb(&s->gb);\n                    tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                    val= pack16to32(mx,my);\n                }else\n                    val=0;\n                fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);\n            }\n        }\n        else if(IS_16X8(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        unsigned int val;\n                        if(IS_DIR(mb_type, i, list)){\n                            val= get_te0_golomb(&s->gb, h->ref_count[list]);\n                            if(val >= h->ref_count[list]){\n                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                return -1;\n                            }\n                        }else\n                            val= LIST_NOT_USED&0xFF;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);\n                        mx += get_se_golomb(&s->gb);\n                        my += get_se_golomb(&s->gb);\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        val= pack16to32(mx,my);\n                    }else\n                        val=0;\n                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);\n                }\n            }\n        }else{\n            assert(IS_8X16(mb_type));\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        unsigned int val;\n                        if(IS_DIR(mb_type, i, list)){\n                            val= get_te0_golomb(&s->gb, h->ref_count[list]);\n                            if(val >= h->ref_count[list]){\n                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                return -1;\n                            }\n                        }else\n                            val= LIST_NOT_USED&0xFF;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);\n                        mx += get_se_golomb(&s->gb);\n                        my += get_se_golomb(&s->gb);\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        val= pack16to32(mx,my);\n                    }else\n                        val=0;\n                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);\n                }\n            }\n        }\n    }\n    if(IS_INTER(mb_type))\n        write_back_motion(h, mb_type);\n    if(!IS_INTRA16x16(mb_type)){\n        cbp= get_ue_golomb(&s->gb);\n        if(cbp > 47){\n            av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\\n", cbp, s->mb_x, s->mb_y);\n            return -1;\n        }\n        if(IS_INTRA4x4(mb_type))\n            cbp= golomb_to_intra4x4_cbp[cbp];\n        else\n            cbp= golomb_to_inter_cbp[cbp];\n    }\n    h->cbp = cbp;\n    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){\n        if(get_bits1(&s->gb))\n            mb_type |= MB_TYPE_8x8DCT;\n    }\n    s->current_picture.mb_type[mb_xy]= mb_type;\n    if(cbp || IS_INTRA16x16(mb_type)){\n        int i8x8, i4x4, chroma_idx;\n        int dquant;\n        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;\n        const uint8_t *scan, *scan8x8, *dc_scan;\n        if(IS_INTERLACED(mb_type)){\n            scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;\n            scan= s->qscale ? h->field_scan : h->field_scan_q0;\n            dc_scan= luma_dc_field_scan;\n        }else{\n            scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;\n            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;\n            dc_scan= luma_dc_zigzag_scan;\n        }\n        dquant= get_se_golomb(&s->gb);\n        if( dquant > 25 || dquant < -26 ){\n            av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\\n", dquant, s->mb_x, s->mb_y);\n            return -1;\n        }\n        s->qscale += dquant;\n        if(((unsigned)s->qscale) > 51){\n            if(s->qscale<0) s->qscale+= 52;\n            else            s->qscale-= 52;\n        }\n        h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);\n        h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);\n        if(IS_INTRA16x16(mb_type)){\n            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){\n                return -1;\n            }\n            assert((cbp&15) == 0 || (cbp&15) == 15);\n            if(cbp&15){\n                for(i8x8=0; i8x8<4; i8x8++){\n                    for(i4x4=0; i4x4<4; i4x4++){\n                        const int index= i4x4 + 4*i8x8;\n                        if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){\n                            return -1;\n                        }\n                    }\n                }\n            }else{\n                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);\n            }\n        }else{\n            for(i8x8=0; i8x8<4; i8x8++){\n                if(cbp & (1<<i8x8)){\n                    if(IS_8x8DCT(mb_type)){\n                        DCTELEM *buf = &h->mb[64*i8x8];\n                        uint8_t *nnz;\n                        for(i4x4=0; i4x4<4; i4x4++){\n                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,\n                                                h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )\n                                return -1;\n                        }\n                        nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];\n                        nnz[0] += nnz[1] + nnz[8] + nnz[9];\n                    }else{\n                        for(i4x4=0; i4x4<4; i4x4++){\n                            const int index= i4x4 + 4*i8x8;\n                            if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){\n                                return -1;\n                            }\n                        }\n                    }\n                }else{\n                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];\n                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;\n                }\n            }\n        }\n        if(cbp&0x30){\n            for(chroma_idx=0; chroma_idx<2; chroma_idx++)\n                if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){\n                    return -1;\n                }\n        }\n        if(cbp&0x20){\n            for(chroma_idx=0; chroma_idx<2; chroma_idx++){\n                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];\n                for(i4x4=0; i4x4<4; i4x4++){\n                    const int index= 16 + 4*chroma_idx + i4x4;\n                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){\n                        return -1;\n                    }\n                }\n            }\n        }else{\n            uint8_t * const nnz= &h->non_zero_count_cache[0];\n            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\n            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;\n        }\n    }else{\n        uint8_t * const nnz= &h->non_zero_count_cache[0];\n        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);\n        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\n        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;\n    }\n    s->current_picture.qscale_table[mb_xy]= s->qscale;\n    write_back_non_zero_count(h);\n    if(MB_MBAFF){\n        h->ref_count[0] >>= 1;\n        h->ref_count[1] >>= 1;\n    }\n    return 0;\n}', 'static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){\n    MpegEncContext * const s = &h->s;\n    static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};\n    int level[16];\n    int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;\n    if(n == CHROMA_DC_BLOCK_INDEX){\n        coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);\n        total_coeff= coeff_token>>2;\n    }else{\n        if(n == LUMA_DC_BLOCK_INDEX){\n            total_coeff= pred_non_zero_count(h, 0);\n            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);\n            total_coeff= coeff_token>>2;\n        }else{\n            total_coeff= pred_non_zero_count(h, n);\n            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);\n            total_coeff= coeff_token>>2;\n            h->non_zero_count_cache[ scan8[n] ]= total_coeff;\n        }\n    }\n    if(total_coeff==0)\n        return 0;\n    if(total_coeff > (unsigned)max_coeff) {\n        av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\\n", s->mb_x, s->mb_y, total_coeff);\n        return -1;\n    }\n    trailing_ones= coeff_token&3;\n    tprintf(h->s.avctx, "trailing:%d, total:%d\\n", trailing_ones, total_coeff);\n    assert(total_coeff<=16);\n    for(i=0; i<trailing_ones; i++){\n        level[i]= 1 - 2*get_bits1(gb);\n    }\n    if(i<total_coeff) {\n        int level_code, mask;\n        int suffix_length = total_coeff > 10 && trailing_ones < 3;\n        int prefix= get_level_prefix(gb);\n        if(prefix<14){\n            if(suffix_length)\n                level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length);\n            else\n                level_code= (prefix<<suffix_length);\n        }else if(prefix==14){\n            if(suffix_length)\n                level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length);\n            else\n                level_code= prefix + get_bits(gb, 4);\n        }else if(prefix==15){\n            level_code= (prefix<<suffix_length) + get_bits(gb, 12);\n            if(suffix_length==0) level_code+=15;\n        }else{\n            av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\\n", s->mb_x, s->mb_y);\n            return -1;\n        }\n        if(trailing_ones < 3) level_code += 2;\n        suffix_length = 1;\n        if(level_code > 5)\n            suffix_length++;\n        mask= -(level_code&1);\n        level[i]= (((2+level_code)>>1) ^ mask) - mask;\n        i++;\n        for(;i<total_coeff;i++) {\n            static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };\n            prefix = get_level_prefix(gb);\n            if(prefix<15){\n                level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);\n            }else if(prefix==15){\n                level_code =  (prefix<<suffix_length) + get_bits(gb, 12);\n            }else{\n                av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\\n", s->mb_x, s->mb_y);\n                return -1;\n            }\n            mask= -(level_code&1);\n            level[i]= (((2+level_code)>>1) ^ mask) - mask;\n            if(level_code > suffix_limit[suffix_length])\n                suffix_length++;\n        }\n    }\n    if(total_coeff == max_coeff)\n        zeros_left=0;\n    else{\n        if(n == CHROMA_DC_BLOCK_INDEX)\n            zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);\n        else\n            zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);\n    }\n    coeff_num = zeros_left + total_coeff - 1;\n    j = scantable[coeff_num];\n    if(n > 24){\n        block[j] = level[0];\n        for(i=1;i<total_coeff;i++) {\n            if(zeros_left <= 0)\n                run_before = 0;\n            else if(zeros_left < 7){\n                run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);\n            }else{\n                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);\n            }\n            zeros_left -= run_before;\n            coeff_num -= 1 + run_before;\n            j= scantable[ coeff_num ];\n            block[j]= level[i];\n        }\n    }else{\n        block[j] = (level[0] * qmul[j] + 32)>>6;\n        for(i=1;i<total_coeff;i++) {\n            if(zeros_left <= 0)\n                run_before = 0;\n            else if(zeros_left < 7){\n                run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);\n            }else{\n                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);\n            }\n            zeros_left -= run_before;\n            coeff_num -= 1 + run_before;\n            j= scantable[ coeff_num ];\n            block[j]= (level[i] * qmul[j] + 32)>>6;\n        }\n    }\n    if(zeros_left<0){\n        av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\\n", s->mb_x, s->mb_y);\n        return -1;\n    }\n    return 0;\n}', 'static inline int pred_non_zero_count(H264Context *h, int n){\n    const int index8= scan8[n];\n    const int left= h->non_zero_count_cache[index8 - 1];\n    const int top = h->non_zero_count_cache[index8 - 8];\n    int i= left + top;\n    if(i<64) i= (i+1)>>1;\n    tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\\n", left, top, n, scan8[n], i&31);\n    return i&31;\n}']