Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "void FUNC_0(MqcState *VAR_0)\n{", "int VAR_1;", "memset(VAR_0->cx_states, 0, sizeof(VAR_0->cx_states));", "VAR_0->cx_states[MQC_CX_UNI] = 2 * 46;", "VAR_0->cx_states[MQC_CX_RL] = 2 * 3;", "VAR_0->cx_states[0] = 2 * 4;", "for (VAR_1 = 0; VAR_1 < 47; VAR_1++) {", "ff_mqc_qe[2 * VAR_1] =\nff_mqc_qe[2 * VAR_1 + 1] = cx_states[VAR_1].qe;", "ff_mqc_nlps[2 * VAR_1] = 2 * cx_states[VAR_1].nlps + cx_states[VAR_1].sw;", "ff_mqc_nlps[2 * VAR_1 + 1] = 2 * cx_states[VAR_1].nlps + 1 - cx_states[VAR_1].sw;", "ff_mqc_nmps[2 * VAR_1] = 2 * cx_states[VAR_1].nmps;", "ff_mqc_nmps[2 * VAR_1 + 1] = 2 * cx_states[VAR_1].nmps + 1;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19, 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0)\n{", "char VAR_1[256];", "int VAR_2;", "if (!bdrv_is_encrypted(VAR_0))\nreturn 0;", "term_printf(\"%s (%s) is encrypted.\\n\", bdrv_get_device_name(VAR_0),\nbdrv_get_encrypted_filename(VAR_0));", "for(VAR_2 = 0; VAR_2 < 3; VAR_2++) {", "monitor_readline(\"Password: \", 1, VAR_1, sizeof(VAR_1));", "if (bdrv_set_key(VAR_0, VAR_1) == 0)\nreturn 0;", "term_printf(\"invalid VAR_1\\n\");", "}", "return -EPERM;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11, 13 ], [ 17, 19 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, BdrvCheckResult *VAR_1)\n{", "if (VAR_0->drv->FUNC_0 == NULL) {", "return -ENOTSUP;", "}", "memset(VAR_1, 0, sizeof(*VAR_1));", "return VAR_0->drv->FUNC_0(VAR_0, VAR_1);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ] ]

[ "static void FUNC_0(SCSIRequest *VAR_0, uint32_t VAR_1)\n{", "VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(VAR_0->bus->qbus.parent);", "vscsi_req *req = VAR_0->hba_private;", "uint8_t *buf;", "int VAR_2 = 0;", "DPRINTF(\"VSCSI: SCSI xfer complete tag=0x%x VAR_1=0x%x, req=%p\\n\",\nVAR_0->tag, VAR_1, req);", "if (req == NULL) {", "fprintf(stderr, \"VSCSI: Can't find request for tag 0x%x\\n\", VAR_0->tag);", "return;", "}", "if (VAR_1) {", "buf = scsi_req_get_buf(VAR_0);", "VAR_2 = vscsi_srp_transfer_data(s, req, req->writing, buf, VAR_1);", "}", "if (VAR_2 < 0) {", "fprintf(stderr, \"VSCSI: RDMA error VAR_2=%d!\\n\", VAR_2);", "vscsi_makeup_sense(s, req, HARDWARE_ERROR, 0, 0);", "scsi_req_abort(req->VAR_0, CHECK_CONDITION);", "return;", "}", "req->data_len -= VAR_2;", "scsi_req_continue(VAR_0);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "static inline void FUNC_0(TCGv *VAR_0)\n{", "VAR_0[0] = tcg_temp_new(TCG_TYPE_TL);", "VAR_0[1] = tcg_temp_new(TCG_TYPE_TL);", "}" ]

[ 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ] ]

[ "static void FUNC_0 (CPUPPCState *VAR_0)\n{", "spr_register(VAR_0, SPR_40x_DCCR, \"DCCR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_DCWR, \"DCWR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_ICCR, \"ICCR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_BOOKE_ICBDR, \"ICBDR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, SPR_NOACCESS,\n0x00000000);", "spr_register(VAR_0, SPR_40x_SGR, \"SGR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0xFFFFFFFF);", "spr_register(VAR_0, SPR_40x_ZPR, \"ZPR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_PID, \"PID\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_DEAR, \"DEAR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_ESR, \"ESR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_EVPR, \"EVPR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_SRR2, \"SRR2\",\n&spr_read_generic, &spr_write_generic,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_SRR3, \"SRR3\",\n&spr_read_generic, &spr_write_generic,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_PIT, \"PIT\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_40x_pit, &spr_write_40x_pit,\n0x00000000);", "spr_register(VAR_0, SPR_40x_TCR, \"TCR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_booke_tcr,\n0x00000000);", "spr_register(VAR_0, SPR_40x_TSR, \"TSR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_booke_tsr,\n0x00000000);", "spr_register(VAR_0, SPR_40x_DAC1, \"DAC1\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_DAC2, \"DAC2\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_DBCR0, \"DBCR0\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_40x_dbcr0,\n0x00000000);", "spr_register(VAR_0, SPR_40x_DBSR, \"DBSR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_clear,\n0x00000300);", "spr_register(VAR_0, SPR_40x_IAC1, \"IAC1\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_40x_IAC2, \"IAC2\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 9, 11, 13, 15 ], [ 19, 21, 23, 25 ], [ 29, 31, 33, 35 ], [ 39, 41, 43, 45 ], [ 49, 51, 53, 55 ], [ 57, 59, 61, 63 ], [ 67, 69, 71, 73 ], [ 77, 79, 81, 83 ], [ 85, 87, 89, 91 ], [ 93, 95, 97, 99 ], [ 101, 103, 105, 107 ], [ 109, 111, 113, 115 ], [ 119, 121, 123, 125 ], [ 127, 129, 131, 133 ], [ 135, 137, 139, 141 ], [ 147, 149, 151, 153 ], [ 155, 157, 159, 161 ], [ 165, 167, 169, 171 ], [ 175, 177, 179, 183 ], [ 187, 189, 191, 193 ], [ 195, 197, 199, 201 ], [ 203 ] ]

[ "static av_always_inline void FUNC_0(H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int mb_xy, int mb_type, int mvy_limit, int first_vertical_edge_done, int dir) {", "MpegEncContext * const s = &h->s;", "int VAR_0;", "const int VAR_1 = dir == 0 ? mb_xy -1 : h->top_mb_xy;", "const int VAR_2 = dir == 0 ? h->left_type[0] : h->top_type;", "static const uint8_t VAR_3[2][8]={{0,3,3,3,1,1,1,1},", "{0,3,1,1,3,3,3,3}};", "const int VAR_4 = VAR_3[dir][(mb_type>>3)&7];", "const int VAR_5 = VAR_4== 3 && !(h->cbp&15) ? 1 : 4;", "const int VAR_6 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));", "if(VAR_2 && !first_vertical_edge_done){", "if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0)\n&& IS_INTERLACED(VAR_2&~mb_type)\n) {", "unsigned int VAR_7 = 2 * linesize;", "unsigned int VAR_8 = 2 * uvlinesize;", "int VAR_9 = mb_xy - 2 * s->mb_stride;", "int VAR_10;", "for(VAR_10=0; VAR_10<2; VAR_10++, VAR_9 += s->mb_stride){", "DECLARE_ALIGNED_8(int16_t, bS)[4];", "int VAR_20;", "if( IS_INTRA(mb_type|s->current_picture.mb_type[VAR_9]) ) {", "*(uint64_t*)bS= 0x0003000300030003ULL;", "} else {", "const uint8_t *VAR_12 = h->non_zero_count[VAR_9] + 4+3*8; FIXME 8x8dct?", "int VAR_20;", "for( VAR_20 = 0; VAR_20 < 4; VAR_20++ ) {", "bS[VAR_20] = 1 + !!(h->non_zero_count_cache[scan8[0]+VAR_20] | VAR_12[VAR_20]);", "}", "}", "Do not use s->qscale as luma quantizer because it has not the same\nvalue in IPCM macroblocks.\nVAR_20 = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[VAR_9] + 1 ) >> 1;", "tprintf(s->avctx, \"filter mb:%d/%d dir:%d VAR_0:%d, QPy:%d ls:%d uvls:%d\", mb_x, mb_y, dir, VAR_0, VAR_20, VAR_7, VAR_8);", "{ int VAR_20; for (VAR_20 = 0; VAR_20 < 4; VAR_20++) tprintf(s->avctx, \" bS[%d]:%d\", VAR_20, bS[VAR_20]); tprintf(s->avctx, \"\\n\"); }", "filter_mb_edgeh( &img_y[VAR_10*linesize], VAR_7, bS, VAR_20, h );", "filter_mb_edgech( &img_cb[VAR_10*uvlinesize], VAR_8, bS,\n( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[VAR_9] ) + 1 ) >> 1, h);", "filter_mb_edgech( &img_cr[VAR_10*uvlinesize], VAR_8, bS,\n( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[VAR_9] ) + 1 ) >> 1, h);", "}", "}else{", "DECLARE_ALIGNED_8(int16_t, bS)[4];", "int VAR_20;", "if( IS_INTRA(mb_type|VAR_2)) {", "*(uint64_t*)bS= 0x0003000300030003ULL;", "if ( (!IS_INTERLACED(mb_type|VAR_2))\n|| ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))\n)\n*(uint64_t*)bS= 0x0004000400040004ULL;", "} else {", "int VAR_20, VAR_20;", "int VAR_20;", "if( dir && FRAME_MBAFF && IS_INTERLACED(mb_type ^ VAR_2)) {", "*(uint64_t*)bS= 0x0001000100010001ULL;", "VAR_20 = 1;", "}", "else if( VAR_6 && ((VAR_2 & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {", "int VAR_20= 8 + 4;", "int VAR_20= VAR_20 - (dir ? 8:1);", "bS[0] = bS[1] = bS[2] = bS[3] = check_mv(h, 8 + 4, VAR_20, mvy_limit);", "VAR_20 = 1;", "}", "else\nVAR_20 = 0;", "for( VAR_20 = 0; VAR_20 < 4; VAR_20++ ) {", "int VAR_20 = dir == 0 ? 0 : VAR_20;", "int VAR_20 = dir == 0 ? VAR_20 : 0;", "int VAR_20= 8 + 4 + VAR_20 + 8*VAR_20;", "int VAR_20= VAR_20 - (dir ? 8:1);", "if( h->non_zero_count_cache[VAR_20] |\nh->non_zero_count_cache[VAR_20] ) {", "bS[VAR_20] = 2;", "}", "else if(!VAR_20)\n{", "bS[VAR_20] = check_mv(h, VAR_20, VAR_20, mvy_limit);", "}", "}", "}", "Do not use s->qscale as luma quantizer because it has not the same\nvalue in IPCM macroblocks.\nif(bS[0]+bS[1]+bS[2]+bS[3]){", "VAR_20 = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[VAR_1] + 1 ) >> 1;", "tprintf(s->avctx, \"filter mb:%d/%d dir:%d VAR_0:%d, QPy:%d, QPc:%d, QPcn:%d\\n\", mb_x, mb_y, dir, VAR_0, VAR_20, h->chroma_qp[0], s->current_picture.qscale_table[VAR_9]);", "tprintf(s->avctx, \"filter mb:%d/%d dir:%d VAR_0:%d, QPy:%d ls:%d uvls:%d\", mb_x, mb_y, dir, VAR_0, VAR_20, linesize, uvlinesize);", "{ int VAR_20; for (VAR_20 = 0; VAR_20 < 4; VAR_20++) tprintf(s->avctx, \" bS[%d]:%d\", VAR_20, bS[VAR_20]); tprintf(s->avctx, \"\\n\"); }", "if( dir == 0 ) {", "filter_mb_edgev( &img_y[0], linesize, bS, VAR_20, h );", "{", "int VAR_20= ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[VAR_1] ) + 1 ) >> 1;", "filter_mb_edgecv( &img_cb[0], uvlinesize, bS, VAR_20, h);", "if(h->pps.chroma_qp_diff)\nVAR_20= ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[VAR_1] ) + 1 ) >> 1;", "filter_mb_edgecv( &img_cr[0], uvlinesize, bS, VAR_20, h);", "}", "} else {", "filter_mb_edgeh( &img_y[0], linesize, bS, VAR_20, h );", "{", "int VAR_20= ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[VAR_1] ) + 1 ) >> 1;", "filter_mb_edgech( &img_cb[0], uvlinesize, bS, VAR_20, h);", "if(h->pps.chroma_qp_diff)\nVAR_20= ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[VAR_1] ) + 1 ) >> 1;", "filter_mb_edgech( &img_cr[0], uvlinesize, bS, VAR_20, h);", "}", "}", "}", "}", "}", "for( VAR_0 = 1; VAR_0 < VAR_5; VAR_0++ ) {", "DECLARE_ALIGNED_8(int16_t, bS)[4];", "int VAR_20;", "if( IS_8x8DCT(mb_type & (VAR_0<<24)) ) (VAR_0&1) && IS_8x8DCT(mb_type)\ncontinue;", "if( IS_INTRA(mb_type)) {", "*(uint64_t*)bS= 0x0003000300030003ULL;", "} else {", "int VAR_20, VAR_20;", "int VAR_20;", "if( VAR_0 & VAR_4 ) {", "*(uint64_t*)bS= 0;", "VAR_20 = 1;", "}", "else if( VAR_6 ) {", "int VAR_20= 8 + 4 + VAR_0 * (dir ? 8:1);", "int VAR_20= VAR_20 - (dir ? 8:1);", "bS[0] = bS[1] = bS[2] = bS[3] = check_mv(h, VAR_20, VAR_20, mvy_limit);", "VAR_20 = 1;", "}", "else\nVAR_20 = 0;", "for( VAR_20 = 0; VAR_20 < 4; VAR_20++ ) {", "int VAR_20 = dir == 0 ? VAR_0 : VAR_20;", "int VAR_20 = dir == 0 ? VAR_20 : VAR_0;", "int VAR_20= 8 + 4 + VAR_20 + 8*VAR_20;", "int VAR_20= VAR_20 - (dir ? 8:1);", "if( h->non_zero_count_cache[VAR_20] |\nh->non_zero_count_cache[VAR_20] ) {", "bS[VAR_20] = 2;", "}", "else if(!VAR_20)\n{", "bS[VAR_20] = check_mv(h, VAR_20, VAR_20, mvy_limit);", "}", "}", "if(bS[0]+bS[1]+bS[2]+bS[3] == 0)\ncontinue;", "}", "Do not use s->qscale as luma quantizer because it has not the same\nvalue in IPCM macroblocks.\nVAR_20 = s->current_picture.qscale_table[mb_xy];", "tprintf(s->avctx, \"filter mb:%d/%d dir:%d VAR_0:%d, QPy:%d, QPc:%d, QPcn:%d\\n\", mb_x, mb_y, dir, VAR_0, VAR_20, h->chroma_qp[0], s->current_picture.qscale_table[VAR_9]);", "tprintf(s->avctx, \"filter mb:%d/%d dir:%d VAR_0:%d, QPy:%d ls:%d uvls:%d\", mb_x, mb_y, dir, VAR_0, VAR_20, linesize, uvlinesize);", "{ int VAR_20; for (VAR_20 = 0; VAR_20 < 4; VAR_20++) tprintf(s->avctx, \" bS[%d]:%d\", VAR_20, bS[VAR_20]); tprintf(s->avctx, \"\\n\"); }", "if( dir == 0 ) {", "filter_mb_edgev( &img_y[4*VAR_0], linesize, bS, VAR_20, h );", "if( (VAR_0&1) == 0 ) {", "filter_mb_edgecv( &img_cb[2*VAR_0], uvlinesize, bS, h->chroma_qp[0], h);", "filter_mb_edgecv( &img_cr[2*VAR_0], uvlinesize, bS, h->chroma_qp[1], h);", "}", "} else {", "filter_mb_edgeh( &img_y[4*VAR_0*linesize], linesize, bS, VAR_20, h );", "if( (VAR_0&1) == 0 ) {", "filter_mb_edgech( &img_cb[2*VAR_0*uvlinesize], uvlinesize, bS, h->chroma_qp[0], h);", "filter_mb_edgech( &img_cr[2*VAR_0*uvlinesize], uvlinesize, bS, h->chroma_qp[1], h);", "}", "}", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 9 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 27 ], [ 31 ], [ 35, 37, 39 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117, 119, 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155, 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 197, 199, 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239, 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 259 ], [ 261 ], [ 263 ], [ 267, 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 301 ], [ 303 ], [ 305 ], [ 307, 309 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 325, 327 ], [ 329 ], [ 331 ], [ 333, 335 ], [ 337 ], [ 339 ], [ 341 ], [ 345, 347 ], [ 349 ], [ 355, 357, 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ] ]

[ "static void FUNC_0(Object *VAR_0)\n{", "Chardev *chr = CHARDEV(VAR_0);", "SocketChardev *s = SOCKET_CHARDEV(VAR_0);", "tcp_chr_free_connection(chr);", "if (s->reconnect_timer) {", "g_source_remove(s->reconnect_timer);", "s->reconnect_timer = 0;", "}", "qapi_free_SocketAddressLegacy(s->addr);", "if (s->listen_tag) {", "g_source_remove(s->listen_tag);", "s->listen_tag = 0;", "}", "if (s->listen_ioc) {", "object_unref(OBJECT(s->listen_ioc));", "}", "if (s->tls_creds) {", "object_unref(OBJECT(s->tls_creds));", "}", "qemu_chr_be_event(chr, CHR_EVENT_CLOSED);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ] ]

[ "int FUNC_0(CPUState *VAR_0)\n{", "return !TAILQ_EMPTY(&VAR_0->kvm_state->kvm_sw_breakpoints);", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ] ]

[ "static int FUNC_0(USBRedirDevice *VAR_0,\nint VAR_1, int VAR_2)\n{", "switch (VAR_1) {", "case usb_redir_success:\nreturn VAR_2;", "case usb_redir_stall:\nreturn USB_RET_STALL;", "case usb_redir_cancelled:\nWARNING(\"returning cancelled packet to HC?\\n\");", "return USB_RET_NAK;", "case usb_redir_inval:\nWARNING(\"got invalid param error from usb-host?\\n\");", "return USB_RET_NAK;", "case usb_redir_babble:\nreturn USB_RET_BABBLE;", "case usb_redir_ioerror:\ncase usb_redir_timeout:\ndefault:\nreturn USB_RET_IOERROR;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9, 11 ], [ 13, 15 ], [ 17, 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29, 31 ], [ 33, 35, 37, 39 ], [ 41 ], [ 43 ] ]

[ "void FUNC_0(PCIDevice *VAR_0, ICH9LPCPMRegs *VAR_1,\nqemu_irq VAR_2, qemu_irq VAR_3)\n{", "memory_region_init(&VAR_1->io, \"ich9-VAR_1\", ICH9_PMIO_SIZE);", "memory_region_set_enabled(&VAR_1->io, false);", "memory_region_add_subregion(pci_address_space_io(VAR_0),\n0, &VAR_1->io);", "acpi_pm_tmr_init(&VAR_1->acpi_regs, ich9_pm_update_sci_fn, &VAR_1->io);", "acpi_pm1_evt_init(&VAR_1->acpi_regs, ich9_pm_update_sci_fn, &VAR_1->io);", "acpi_pm1_cnt_init(&VAR_1->acpi_regs, &VAR_1->io);", "acpi_gpe_init(&VAR_1->acpi_regs, ICH9_PMIO_GPE0_LEN);", "memory_region_init_io(&VAR_1->io_gpe, &ich9_gpe_ops, VAR_1, \"apci-gpe0\",\nICH9_PMIO_GPE0_LEN);", "memory_region_add_subregion(&VAR_1->io, ICH9_PMIO_GPE0_STS, &VAR_1->io_gpe);", "memory_region_init_io(&VAR_1->io_smi, &ich9_smi_ops, VAR_1, \"apci-smi\",\n8);", "memory_region_add_subregion(&VAR_1->io, ICH9_PMIO_SMI_EN, &VAR_1->io_smi);", "VAR_1->irq = VAR_2;", "qemu_register_reset(pm_reset, VAR_1);", "VAR_1->powerdown_notifier.notify = pm_powerdown_req;", "qemu_register_powerdown_notifier(&VAR_1->powerdown_notifier);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11, 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 35, 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ] ]

[ "static int FUNC_0(XenPCIPassthroughState *VAR_0,\nXenPTReg *VAR_1, uint32_t *VAR_2,\nuint32_t VAR_3, uint32_t VAR_4)\n{", "XenPTRegInfo *reg = VAR_1->reg;", "XenPTRegion *base = NULL;", "PCIDevice *d = (PCIDevice *)&VAR_0->dev;", "uint32_t writable_mask = 0;", "uint32_t throughable_mask = get_throughable_mask(VAR_0, reg, VAR_4);", "pcibus_t r_size = 0;", "uint32_t bar_ro_mask = 0;", "r_size = d->io_regions[PCI_ROM_SLOT].size;", "base = &VAR_0->bases[PCI_ROM_SLOT];", "r_size = xen_pt_get_emul_size(base->bar_flag, r_size);", "bar_ro_mask = (reg->ro_mask | (r_size - 1)) & ~PCI_ROM_ADDRESS_ENABLE;", "writable_mask = ~bar_ro_mask & VAR_4;", "VAR_1->data = XEN_PT_MERGE_VALUE(*VAR_2, VAR_1->data, writable_mask);", "*VAR_2 = XEN_PT_MERGE_VALUE(*VAR_2, VAR_3, throughable_mask);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 31 ], [ 37 ], [ 43 ], [ 45 ], [ 51 ], [ 55 ], [ 57 ] ]

[ "static int FUNC_0(TCGType VAR_0, tcg_target_long VAR_1)\n{", "if ((s390_facilities & FACILITY_EXT_IMM) == 0) {", "return 0;", "}", "if (VAR_0 == TCG_TYPE_I32) {", "return 1;", "}", "if (VAR_1 < 0 && VAR_1 == (int32_t)VAR_1) {", "return 0;", "}", "return 1;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ] ]

[ "static int FUNC_0(QCryptoBlockFormat VAR_0,\nQemuOptsList *VAR_1,\nBlockDriverState *VAR_2,\nQDict *VAR_3,\nint VAR_4,\nError **VAR_5)\n{", "BlockCrypto *crypto = VAR_2->opaque;", "QemuOpts *opts = NULL;", "Error *local_err = NULL;", "int VAR_6 = -EINVAL;", "QCryptoBlockOpenOptions *open_opts = NULL;", "unsigned int VAR_7 = 0;", "VAR_2->file = bdrv_open_child(NULL, VAR_3, \"file\", VAR_2, &child_file,\nfalse, VAR_5);", "if (!VAR_2->file) {", "return -EINVAL;", "}", "opts = qemu_opts_create(VAR_1, NULL, 0, &error_abort);", "qemu_opts_absorb_qdict(opts, VAR_3, &local_err);", "if (local_err) {", "error_propagate(VAR_5, local_err);", "goto cleanup;", "}", "open_opts = block_crypto_open_opts_init(VAR_0, opts, VAR_5);", "if (!open_opts) {", "goto cleanup;", "}", "if (VAR_4 & BDRV_O_NO_IO) {", "VAR_7 |= QCRYPTO_BLOCK_OPEN_NO_IO;", "}", "crypto->block = qcrypto_block_open(open_opts,\nblock_crypto_read_func,\nVAR_2,\nVAR_7,\nVAR_5);", "if (!crypto->block) {", "VAR_6 = -EIO;", "goto cleanup;", "}", "VAR_2->encrypted = true;", "VAR_2->valid_key = true;", "VAR_6 = 0;", "cleanup:\nqapi_free_QCryptoBlockOpenOptions(open_opts);", "return VAR_6;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9, 11, 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73, 75, 77, 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 99 ], [ 101, 103 ], [ 105 ], [ 107 ] ]

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "int VAR_1;", "VAR_1 = pci_bridge_initfn(VAR_0);", "if (VAR_1 < 0) {", "return VAR_1;", "}", "pci_config_set_vendor_id(VAR_0->config, PCI_VENDOR_ID_DEC);", "pci_config_set_device_id(VAR_0->config, PCI_DEVICE_ID_DEC_21154);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ] ]

[ "FUNC_0 (uint8_t *VAR_0,\nuint32_t VAR_1,\nuint64_t *VAR_2)\n{", "int VAR_3 = 0x80, VAR_4 = 1, VAR_5 = 1, VAR_6 = 0;", "uint64_t total;", "if (VAR_1 <= 0)\nreturn AVERROR_INVALIDDATA;", "total = VAR_0[0];", "while (VAR_4 <= 8 && !(total & VAR_3)) {", "VAR_4++;", "VAR_3 >>= 1;", "}", "if (VAR_4 > 8)\nreturn AVERROR_INVALIDDATA;", "if ((total &= (VAR_3 - 1)) == VAR_3 - 1)\nVAR_6++;", "if (VAR_1 < VAR_4)\nreturn AVERROR_INVALIDDATA;", "while (VAR_5 < VAR_4) {", "if (VAR_0[VAR_5] == 0xff)\nVAR_6++;", "total = (total << 8) | VAR_0[VAR_5];", "VAR_5++;", "}", "if (!total)\nreturn AVERROR_INVALIDDATA;", "if (VAR_4 == VAR_6)\n*VAR_2 = (uint64_t)-1;", "else\n*VAR_2 = total;", "return VAR_4;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 37, 39 ], [ 41, 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 65, 67 ], [ 69, 71 ], [ 75 ], [ 77 ] ]

[ "static PayloadContext *FUNC_0(void)\n{", "return av_mallocz(sizeof(PayloadContext));", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ] ]

[ "static int FUNC_0(AVFilterLink *VAR_0, AVFrame *VAR_1)\n{", "AVFilterContext *ctx = VAR_0->dst;", "AVFilterLink *outlink = ctx->outputs[0];", "ShowSpectrumContext *s = ctx->priv;", "AVFrame *outpicref = s->outpicref;", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6 = s->orientation == VERTICAL ? s->h : s->w;", "clear_combine_buffer(s, VAR_6);", "ctx->internal->execute(ctx, plot_channel, NULL, NULL, s->nb_display_channels);", "for (VAR_5 = 0; VAR_5 < VAR_6 * 3; VAR_5++) {", "s->combine_buffer[VAR_5] += s->color_buffer[0][VAR_5];", "for (VAR_4 = 1; VAR_4 < s->nb_display_channels; VAR_4++) {", "s->combine_buffer[VAR_5] += s->color_buffer[VAR_4][VAR_5];", "}", "}", "av_frame_make_writable(s->outpicref);", "if (s->orientation == VERTICAL) {", "if (s->sliding == SCROLL) {", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "for (VAR_5 = 0; VAR_5 < s->h; VAR_5++) {", "uint8_t *p = outpicref->data[VAR_3] +\nVAR_5 * outpicref->linesize[VAR_3];", "memmove(p, p + 1, s->w - 1);", "}", "}", "s->xpos = s->w - 1;", "} else if (s->sliding == RSCROLL) {", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "for (VAR_5 = 0; VAR_5 < s->h; VAR_5++) {", "uint8_t *p = outpicref->data[VAR_3] +\nVAR_5 * outpicref->linesize[VAR_3];", "memmove(p + 1, p, s->w - 1);", "}", "}", "s->xpos = 0;", "}", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "uint8_t *p = outpicref->data[VAR_3] + s->start_x +\n(outlink->h - 1 - s->start_y) * outpicref->linesize[VAR_3] +\ns->xpos;", "for (VAR_5 = 0; VAR_5 < s->h; VAR_5++) {", "*p = lrintf(av_clipf(s->combine_buffer[3 * VAR_5 + VAR_3], 0, 255));", "p -= outpicref->linesize[VAR_3];", "}", "}", "} else {", "if (s->sliding == SCROLL) {", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "for (VAR_5 = 1; VAR_5 < s->h; VAR_5++) {", "memmove(outpicref->data[VAR_3] + (VAR_5-1) * outpicref->linesize[VAR_3],\noutpicref->data[VAR_3] + (VAR_5 ) * outpicref->linesize[VAR_3],\ns->w);", "}", "}", "s->xpos = s->h - 1;", "} else if (s->sliding == RSCROLL) {", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "for (VAR_5 = s->h - 1; VAR_5 >= 1; VAR_5--) {", "memmove(outpicref->data[VAR_3] + (VAR_5 ) * outpicref->linesize[VAR_3],\noutpicref->data[VAR_3] + (VAR_5-1) * outpicref->linesize[VAR_3],\ns->w);", "}", "}", "s->xpos = 0;", "}", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "uint8_t *p = outpicref->data[VAR_3] + s->start_x +\n(s->xpos + s->start_y) * outpicref->linesize[VAR_3];", "for (VAR_4 = 0; VAR_4 < s->w; VAR_4++) {", "*p = lrintf(av_clipf(s->combine_buffer[3 * VAR_4 + VAR_3], 0, 255));", "p++;", "}", "}", "}", "if (s->sliding != FULLFRAME || s->xpos == 0)\noutpicref->pts = VAR_1->pts;", "s->xpos++;", "if (s->orientation == VERTICAL && s->xpos >= s->w)\ns->xpos = 0;", "if (s->orientation == HORIZONTAL && s->xpos >= s->h)\ns->xpos = 0;", "if (!s->single_pic && (s->sliding != FULLFRAME || s->xpos == 0)) {", "VAR_2 = ff_filter_frame(outlink, av_frame_clone(s->outpicref));", "if (VAR_2 < 0)\nreturn VAR_2;", "}", "return s->win_size;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 91, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113, 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147, 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165, 167 ], [ 171 ], [ 173, 175 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 193 ], [ 195 ] ]

[ "FUNC_0 (struct disassemble_info *VAR_0)\n{", "const struct s390_opcode *VAR_1;", "const struct s390_opcode *VAR_2;", "memset (opc_index, 0, sizeof (opc_index));", "VAR_2 = s390_opcodes + s390_num_opcodes;", "for (VAR_1 = s390_opcodes; VAR_1 < VAR_2; VAR_1++)", "{", "opc_index[(int) VAR_1->VAR_1[0]] = VAR_1 - s390_opcodes;", "while ((VAR_1 < VAR_2) &&\n(VAR_1[1].VAR_1[0] == VAR_1->VAR_1[0]))\nVAR_1++;", "}", "#ifdef QEMU_DISABLE\nswitch (VAR_0->mach)\n{", "case bfd_mach_s390_31:\ncurrent_arch_mask = 1 << S390_OPCODE_ESA;", "break;", "case bfd_mach_s390_64:\ncurrent_arch_mask = 1 << S390_OPCODE_ZARCH;", "break;", "default:\nabort ();", "}", "#endif\ninit_flag = 1;", "}" ]

[ 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21, 23, 25 ], [ 27 ], [ 31, 33, 35 ], [ 37, 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55, 59 ], [ 61 ] ]

[ "int VAR_0 avcodec_open(AVCodecContext *avctx, AVCodec *codec)\n{", "int ret= -1;", "if (ff_lockmgr_cb) {", "if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))\nreturn -1;", "}", "entangled_thread_counter++;", "if(entangled_thread_counter != 1){", "av_log(avctx, AV_LOG_ERROR, \"insufficient thread locking around avcodec_open/close()\\n\");", "goto end;", "}", "if(avctx->codec || !codec)\ngoto end;", "if (codec->priv_data_size > 0) {", "avctx->priv_data = av_mallocz(codec->priv_data_size);", "if (!avctx->priv_data) {", "ret = AVERROR(ENOMEM);", "goto end;", "}", "} else {", "avctx->priv_data = NULL;", "}", "if(avctx->coded_width && avctx->coded_height)\navcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);", "else if(avctx->width && avctx->height)\navcodec_set_dimensions(avctx, avctx->width, avctx->height);", "#define SANE_NB_CHANNELS 128U\nif (((avctx->coded_width || avctx->coded_height)\n&& av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))\n|| avctx->channels > SANE_NB_CHANNELS) {", "ret = AVERROR(EINVAL);", "goto free_and_end;", "}", "avctx->codec = codec;", "if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&\navctx->codec_id == CODEC_ID_NONE) {", "avctx->codec_type = codec->type;", "avctx->codec_id = codec->id;", "}", "if(avctx->codec_id != codec->id || avctx->codec_type != codec->type){", "av_log(avctx, AV_LOG_ERROR, \"codec type or id mismatches\\n\");", "goto free_and_end;", "}", "avctx->frame_number = 0;", "if (avctx->codec->max_lowres < avctx->lowres) {", "av_log(avctx, AV_LOG_ERROR, \"The maximum value for lowres supported by the decoder is %d\\n\",\navctx->codec->max_lowres);", "goto free_and_end;", "}", "if(avctx->codec->init){", "ret = avctx->codec->init(avctx);", "if (ret < 0) {", "goto free_and_end;", "}", "}", "ret=0;", "end:\nentangled_thread_counter--;", "if (ff_lockmgr_cb) {", "(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);", "}", "return ret;", "free_and_end:\nav_freep(&avctx->priv_data);", "avctx->codec= NULL;", "goto end;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33, 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 63, 65 ], [ 69, 71, 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133, 135 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 157 ] ]

[ "static inline void FUNC_0(rgb15to24)(const uint8_t *src, uint8_t *dst, unsigned src_size)\n{", "const uint16_t *VAR_0;", "#ifdef HAVE_MMX\nconst uint16_t *mm_end;", "#endif\nuint8_t *d = (uint8_t *)dst;", "const uint16_t *VAR_1 = (uint16_t *)src;", "VAR_0 = VAR_1 + src_size/2;", "#ifdef HAVE_MMX\n__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*VAR_1):\"memory\");", "mm_end = VAR_0 - 7;", "while(VAR_1 < mm_end)\n{", "__asm __volatile(\nPREFETCH\" 32%1\\n\\t\"\n\"movq\t%1, %%mm0\\n\\t\"\n\"movq\t%1, %%mm1\\n\\t\"\n\"movq\t%1, %%mm2\\n\\t\"\n\"pand\t%2, %%mm0\\n\\t\"\n\"pand\t%3, %%mm1\\n\\t\"\n\"pand\t%4, %%mm2\\n\\t\"\n\"psllq\t$3, %%mm0\\n\\t\"\n\"psrlq\t$2, %%mm1\\n\\t\"\n\"psrlq\t$7, %%mm2\\n\\t\"\n\"movq\t%%mm0, %%mm3\\n\\t\"\n\"movq\t%%mm1, %%mm4\\n\\t\"\n\"movq\t%%mm2, %%mm5\\n\\t\"\n\"punpcklwd %5, %%mm0\\n\\t\"\n\"punpcklwd %5, %%mm1\\n\\t\"\n\"punpcklwd %5, %%mm2\\n\\t\"\n\"punpckhwd %5, %%mm3\\n\\t\"\n\"punpckhwd %5, %%mm4\\n\\t\"\n\"punpckhwd %5, %%mm5\\n\\t\"\n\"psllq\t$8, %%mm1\\n\\t\"\n\"psllq\t$16, %%mm2\\n\\t\"\n\"por\t%%mm1, %%mm0\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"psllq\t$8, %%mm4\\n\\t\"\n\"psllq\t$16, %%mm5\\n\\t\"\n\"por\t%%mm4, %%mm3\\n\\t\"\n\"por\t%%mm5, %%mm3\\n\\t\"\n\"movq\t%%mm0, %%mm6\\n\\t\"\n\"movq\t%%mm3, %%mm7\\n\\t\"\n\"movq\t8%1, %%mm0\\n\\t\"\n\"movq\t8%1, %%mm1\\n\\t\"\n\"movq\t8%1, %%mm2\\n\\t\"\n\"pand\t%2, %%mm0\\n\\t\"\n\"pand\t%3, %%mm1\\n\\t\"\n\"pand\t%4, %%mm2\\n\\t\"\n\"psllq\t$3, %%mm0\\n\\t\"\n\"psrlq\t$2, %%mm1\\n\\t\"\n\"psrlq\t$7, %%mm2\\n\\t\"\n\"movq\t%%mm0, %%mm3\\n\\t\"\n\"movq\t%%mm1, %%mm4\\n\\t\"\n\"movq\t%%mm2, %%mm5\\n\\t\"\n\"punpcklwd %5, %%mm0\\n\\t\"\n\"punpcklwd %5, %%mm1\\n\\t\"\n\"punpcklwd %5, %%mm2\\n\\t\"\n\"punpckhwd %5, %%mm3\\n\\t\"\n\"punpckhwd %5, %%mm4\\n\\t\"\n\"punpckhwd %5, %%mm5\\n\\t\"\n\"psllq\t$8, %%mm1\\n\\t\"\n\"psllq\t$16, %%mm2\\n\\t\"\n\"por\t%%mm1, %%mm0\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"psllq\t$8, %%mm4\\n\\t\"\n\"psllq\t$16, %%mm5\\n\\t\"\n\"por\t%%mm4, %%mm3\\n\\t\"\n\"por\t%%mm5, %%mm3\\n\\t\"\n:\"=m\"(*d)\n:\"m\"(*VAR_1),\"m\"(mask15b),\"m\"(mask15g),\"m\"(mask15r), \"m\"(mmx_null)\n:\"memory\");", "__asm __volatile(\n\"movq\t%%mm0, %%mm4\\n\\t\"\n\"movq\t%%mm3, %%mm5\\n\\t\"\n\"movq\t%%mm6, %%mm0\\n\\t\"\n\"movq\t%%mm7, %%mm1\\n\\t\"\n\"movq\t%%mm4, %%mm6\\n\\t\"\n\"movq\t%%mm5, %%mm7\\n\\t\"\n\"movq\t%%mm0, %%mm2\\n\\t\"\n\"movq\t%%mm1, %%mm3\\n\\t\"\n\"psrlq\t$8, %%mm2\\n\\t\"\n\"psrlq\t$8, %%mm3\\n\\t\"\n\"psrlq\t$8, %%mm6\\n\\t\"\n\"psrlq\t$8, %%mm7\\n\\t\"\n\"pand\t%2, %%mm0\\n\\t\"\n\"pand\t%2, %%mm1\\n\\t\"\n\"pand\t%2, %%mm4\\n\\t\"\n\"pand\t%2, %%mm5\\n\\t\"\n\"pand\t%3, %%mm2\\n\\t\"\n\"pand\t%3, %%mm3\\n\\t\"\n\"pand\t%3, %%mm6\\n\\t\"\n\"pand\t%3, %%mm7\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"por\t%%mm3, %%mm1\\n\\t\"\n\"por\t%%mm6, %%mm4\\n\\t\"\n\"por\t%%mm7, %%mm5\\n\\t\"\n\"movq\t%%mm1, %%mm2\\n\\t\"\n\"movq\t%%mm4, %%mm3\\n\\t\"\n\"psllq\t$48, %%mm2\\n\\t\"\n\"psllq\t$32, %%mm3\\n\\t\"\n\"pand\t%4, %%mm2\\n\\t\"\n\"pand\t%5, %%mm3\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"psrlq\t$16, %%mm1\\n\\t\"\n\"psrlq\t$32, %%mm4\\n\\t\"\n\"psllq\t$16, %%mm5\\n\\t\"\n\"por\t%%mm3, %%mm1\\n\\t\"\n\"pand\t%6, %%mm5\\n\\t\"\n\"por\t%%mm5, %%mm4\\n\\t\"\nMOVNTQ\"\t%%mm0, %0\\n\\t\"\nMOVNTQ\"\t%%mm1, 8%0\\n\\t\"\nMOVNTQ\"\t%%mm4, 16%0\"\n:\"=m\"(*d)\n:\"m\"(*VAR_1),\"m\"(mask24l),\"m\"(mask24h),\"m\"(mask24hh),\"m\"(mask24hhh),\"m\"(mask24hhhh)\n:\"memory\");", "d += 24;", "VAR_1 += 8;", "}", "__asm __volatile(SFENCE:::\"memory\");", "__asm __volatile(EMMS:::\"memory\");", "#endif\nwhile(VAR_1 < VAR_0)\n{", "register uint16_t VAR_2;", "VAR_2 = *VAR_1++;", "*d++ = (VAR_2&0x1F)<<3;", "*d++ = (VAR_2&0x3E0)>>2;", "*d++ = (VAR_2&0x7C00)>>7;", "}", "}" ]

[ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7, 9 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 25, 27 ], [ 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 87, 89, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 147, 149, 151 ], [ 155, 157, 159, 161, 163, 167, 169, 171, 173, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 239, 241, 243, 247, 249, 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263, 265, 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ] ]

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "VFIOQuirk *quirk = VAR_0;", "VFIOPCIDevice *vdev = quirk->vdev;", "switch (VAR_1) {", "case 4:\nif ((VAR_2 & 0x7fff0000) == 0x10000) {", "if (VAR_2 & 0x80000000U &&\nvdev->pdev.cap_present & QEMU_PCI_CAP_MSIX) {", "trace_vfio_rtl8168_window_quirk_write_table(\nmemory_region_name(&quirk->mem),\nvdev->vbasedev.name);", "memory_region_dispatch_write(&vdev->pdev.msix_table_mmio,\n(hwaddr)(VAR_2 & 0xfff),\n(uint64_t)quirk->VAR_2.address_mask,\nVAR_3, MEMTXATTRS_UNSPECIFIED);", "}", "quirk->VAR_2.flags = 1;", "quirk->VAR_2.address_match = VAR_2;", "return;", "}", "quirk->VAR_2.flags = 0;", "break;", "case 0:\nquirk->VAR_2.address_mask = VAR_2;", "break;", "}", "trace_vfio_rtl8168_window_quirk_write_direct(\nmemory_region_name(&quirk->mem),\nvdev->vbasedev.name);", "vfio_region_write(&vdev->bars[quirk->VAR_2.bar].region,\nVAR_1 + 0x70, VAR_2, VAR_3);", "}" ]

[ 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15, 17 ], [ 19, 21 ], [ 25, 27, 29 ], [ 33, 35, 37, 39 ], [ 41 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 69, 71, 73 ], [ 77, 79 ], [ 81 ] ]

[ "void FUNC_0(void *VAR_0)\n{", "Connection *conn = VAR_0;", "g_queue_foreach(&conn->primary_list, packet_destroy, NULL);", "g_queue_free(&conn->primary_list);", "g_queue_foreach(&conn->secondary_list, packet_destroy, NULL);", "g_queue_free(&conn->secondary_list);", "g_slice_free(Connection, conn);", "}" ]

[ 0, 0, 0, 1, 0, 1, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ] ]

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "Exynos4210UartState *s = (Exynos4210UartState *)VAR_0;", "uint8_t ch;", "PRINT_DEBUG_EXTEND(\"UART%d: <0x%04x> %s <- 0x%08llx\\n\", s->channel,\nVAR_1, exynos4210_uart_regname(VAR_1), (long long unsigned int)VAR_2);", "switch (VAR_1) {", "case ULCON:\ncase UBRDIV:\ncase UFRACVAL:\ns->reg[I_(VAR_1)] = VAR_2;", "exynos4210_uart_update_parameters(s);", "break;", "case UFCON:\ns->reg[I_(UFCON)] = VAR_2;", "if (VAR_2 & UFCON_Rx_FIFO_RESET) {", "fifo_reset(&s->rx);", "s->reg[I_(UFCON)] &= ~UFCON_Rx_FIFO_RESET;", "PRINT_DEBUG(\"UART%d: Rx FIFO Reset\\n\", s->channel);", "}", "if (VAR_2 & UFCON_Tx_FIFO_RESET) {", "fifo_reset(&s->tx);", "s->reg[I_(UFCON)] &= ~UFCON_Tx_FIFO_RESET;", "PRINT_DEBUG(\"UART%d: Tx FIFO Reset\\n\", s->channel);", "}", "break;", "case UTXH:\nif (s->chr) {", "s->reg[I_(UTRSTAT)] &= ~(UTRSTAT_TRANSMITTER_EMPTY |\nUTRSTAT_Tx_BUFFER_EMPTY);", "ch = (uint8_t)VAR_2;", "qemu_chr_fe_write(s->chr, &ch, 1);", "#if DEBUG_Tx_DATA\nfprintf(stderr, \"%c\", ch);", "#endif\ns->reg[I_(UTRSTAT)] |= UTRSTAT_TRANSMITTER_EMPTY |\nUTRSTAT_Tx_BUFFER_EMPTY;", "s->reg[I_(UINTSP)] |= UINTSP_TXD;", "exynos4210_uart_update_irq(s);", "}", "break;", "case UINTP:\ns->reg[I_(UINTP)] &= ~VAR_2;", "s->reg[I_(UINTSP)] &= ~VAR_2;", "PRINT_DEBUG(\"UART%d: UINTP [%04x] have been cleared: %08x\\n\",\ns->channel, VAR_1, s->reg[I_(UINTP)]);", "exynos4210_uart_update_irq(s);", "break;", "case UTRSTAT:\ncase UERSTAT:\ncase UFSTAT:\ncase UMSTAT:\ncase URXH:\nPRINT_DEBUG(\"UART%d: Trying to write into RO register: %s [%04x]\\n\",\ns->channel, exynos4210_uart_regname(VAR_1), VAR_1);", "break;", "case UINTSP:\ns->reg[I_(UINTSP)] &= ~VAR_2;", "break;", "case UINTM:\ns->reg[I_(UINTM)] = VAR_2;", "exynos4210_uart_update_irq(s);", "break;", "case UCON:\ncase UMCON:\ndefault:\ns->reg[I_(VAR_1)] = VAR_2;", "break;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13, 15 ], [ 19 ], [ 21, 23, 25, 27 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61, 63 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93, 95 ], [ 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107, 109, 111, 113, 115, 117, 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 137, 139, 141, 143 ], [ 145 ], [ 147 ], [ 149 ] ]

[ "static void FUNC_0(PXA2xxState *VAR_0)\n{", "I2CBus *bus = pxa2xx_i2c_bus(VAR_0->i2c[0]);", "DeviceState *wm;", "wm = i2c_create_slave(bus, \"wm8750\", 0);", "spitz_wm8750_addr(wm, 0, 0);", "qdev_connect_gpio_out(VAR_0->gpio, SPITZ_GPIO_WM,\nqemu_allocate_irqs(spitz_wm8750_addr, wm, 1)[0]);", "VAR_0->i2s->opaque = wm;", "VAR_0->i2s->codec_out = wm8750_dac_dat;", "VAR_0->i2s->codec_in = wm8750_adc_dat;", "wm8750_data_req_set(wm, VAR_0->i2s->data_req, VAR_0->i2s);", "}" ]

[ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 7 ], [ 11 ], [ 17 ], [ 21 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "m5206_mbar_state *s = (m5206_mbar_state *)VAR_0;", "int VAR_3;", "VAR_1 &= 0x3ff;", "if (VAR_1 > 0x200) {", "hw_error(\"Bad MBAR write VAR_1 0x%x\", (int)VAR_1);", "}", "VAR_3 = m5206_mbar_width[VAR_1 >> 2];", "if (VAR_3 < 4) {", "m5206_mbar_writew(VAR_0, VAR_1, VAR_2 >> 16);", "m5206_mbar_writew(VAR_0, VAR_1 + 2, VAR_2 & 0xffff);", "return;", "}", "m5206_mbar_write(s, VAR_1, VAR_2, 4);", "}" ]

[ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ] ]

[ "static int FUNC_0(ADXContext *VAR_0, int16_t *VAR_1, int VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{", "ADXChannelState *prev = &VAR_0->prev[VAR_4];", "GetBitContext gb;", "int VAR_5 = AV_RB16(VAR_3);", "int VAR_6;", "int VAR_7, VAR_8, VAR_9, VAR_10;", "if (VAR_5 & 0x8000)\nreturn -1;", "init_get_bits(&gb, VAR_3 + 2, (BLOCK_SIZE - 2) * 8);", "VAR_1 += VAR_2;", "VAR_8 = prev->VAR_8;", "VAR_9 = prev->VAR_9;", "for (VAR_6 = 0; VAR_6 < BLOCK_SAMPLES; VAR_6++) {", "VAR_10 = get_sbits(&gb, 4);", "VAR_7 = ((VAR_10 << COEFF_BITS) * VAR_5 + VAR_0->coeff[0] * VAR_8 + VAR_0->coeff[1] * VAR_9) >> COEFF_BITS;", "VAR_9 = VAR_8;", "VAR_8 = av_clip_int16(VAR_7);", "*VAR_1++ = VAR_8;", "}", "prev->VAR_8 = VAR_8;", "prev->VAR_9 = VAR_9;", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 21, 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1)\n{", "ASFContext *asf = VAR_0->priv_data;", "uint32_t packet_length, padsize;", "int VAR_2 = 8;", "int VAR_3, VAR_4, VAR_5, VAR_6;", "VAR_6= 32768;", "if (VAR_0->packet_size > 0)\nVAR_6= (avio_tell(VAR_1) - VAR_0->data_offset) % VAR_0->packet_size + 3;", "VAR_3=VAR_4=VAR_5=-1;", "while(VAR_6-- > 0){", "VAR_3=VAR_4; VAR_4=VAR_5;", "VAR_5= avio_r8(VAR_1);", "if(VAR_3 == 0x82 && !VAR_4 && !VAR_5)\nbreak;", "if (VAR_3 != 0x82) {", "if (VAR_1->error == AVERROR(EAGAIN))\nreturn AVERROR(EAGAIN);", "if (!VAR_1->eof_reached)\nav_log(VAR_0, AV_LOG_ERROR, \"ff asf bad header %x at:%\"PRId64\"\\n\", VAR_3, avio_tell(VAR_1));", "if ((VAR_3 & 0x8f) == 0x82) {", "if (VAR_4 || VAR_5) {", "if (!VAR_1->eof_reached)\nav_log(VAR_0, AV_LOG_ERROR, \"ff asf bad non zero\\n\");", "VAR_3= avio_r8(VAR_1);", "VAR_4= avio_r8(VAR_1);", "VAR_2+=3;", "}else{", "avio_seek(VAR_1, -1, SEEK_CUR);", "asf->packet_flags = VAR_3;", "asf->packet_property = VAR_4;", "DO_2BITS(asf->packet_flags >> 5, packet_length, VAR_0->packet_size);", "DO_2BITS(asf->packet_flags >> 1, padsize, 0);", "DO_2BITS(asf->packet_flags >> 3, padsize, 0);", "if(!packet_length || packet_length >= (1U<<29)){", "av_log(VAR_0, AV_LOG_ERROR, \"invalid packet_length %VAR_4 at:%\"PRId64\"\\n\", packet_length, avio_tell(VAR_1));", "if(padsize >= packet_length){", "av_log(VAR_0, AV_LOG_ERROR, \"invalid padsize %VAR_4 at:%\"PRId64\"\\n\", padsize, avio_tell(VAR_1));", "asf->packet_timestamp = avio_rl32(VAR_1);", "avio_rl16(VAR_1);", "if (asf->packet_flags & 0x01) {", "asf->packet_segsizetype = avio_r8(VAR_1); VAR_2++;", "asf->packet_segments = asf->packet_segsizetype & 0x3f;", "} else {", "asf->packet_segments = 1;", "asf->packet_segsizetype = 0x80;", "asf->packet_size_left = packet_length - padsize - VAR_2;", "if (packet_length < asf->hdr.min_pktsize)\npadsize += asf->hdr.min_pktsize - packet_length;", "asf->packet_padsize = padsize;", "av_dlog(VAR_0, \"packet: size=%VAR_4 padsize=%VAR_4 left=%VAR_4\\n\", VAR_0->packet_size, asf->packet_padsize, asf->packet_size_left);", "return 0;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 17 ], [ 19, 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 40 ], [ 54, 56 ], [ 58, 60 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 86 ], [ 88 ], [ 92 ], [ 94 ], [ 96 ], [ 102 ], [ 104 ], [ 108 ], [ 110 ], [ 116 ], [ 118 ], [ 124 ], [ 126 ], [ 128 ], [ 130 ], [ 132 ], [ 134 ], [ 144 ], [ 146, 148 ], [ 150 ], [ 152 ], [ 154 ] ]

[ "static bool FUNC_0(BlockDriverState *bs)\n{", "bool drained = false;", "bool enabled = bs->io_limits_enabled;", "int VAR_0;", "bs->io_limits_enabled = false;", "for (VAR_0 = 0; VAR_0 < 2; VAR_0++) {", "while (qemu_co_enter_next(&bs->throttled_reqs[VAR_0])) {", "drained = true;", "}", "}", "bs->io_limits_enabled = enabled;", "return drained;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0,\nNBDRequest *VAR_1,\nQEMUIOVector *VAR_2)\n{", "NBDClientSession *s = nbd_get_client_session(VAR_0);", "int VAR_3, VAR_4, VAR_5;", "qemu_co_mutex_lock(&s->send_mutex);", "while (s->in_flight == MAX_NBD_REQUESTS) {", "qemu_co_queue_wait(&s->free_sema, &s->send_mutex);", "}", "s->in_flight++;", "for (VAR_5 = 0; VAR_5 < MAX_NBD_REQUESTS; VAR_5++) {", "if (s->recv_coroutine[VAR_5] == NULL) {", "s->recv_coroutine[VAR_5] = qemu_coroutine_self();", "break;", "}", "}", "g_assert(qemu_in_coroutine());", "assert(VAR_5 < MAX_NBD_REQUESTS);", "VAR_1->handle = INDEX_TO_HANDLE(s, VAR_5);", "if (!s->ioc) {", "qemu_co_mutex_unlock(&s->send_mutex);", "return -EPIPE;", "}", "if (VAR_2) {", "qio_channel_set_cork(s->ioc, true);", "VAR_3 = nbd_send_request(s->ioc, VAR_1);", "if (VAR_3 >= 0) {", "VAR_4 = nbd_wr_syncv(s->ioc, VAR_2->iov, VAR_2->niov, VAR_1->len,\nfalse, NULL);", "if (VAR_4 != VAR_1->len) {", "VAR_3 = -EIO;", "}", "}", "qio_channel_set_cork(s->ioc, false);", "} else {", "VAR_3 = nbd_send_request(s->ioc, VAR_1);", "}", "qemu_co_mutex_unlock(&s->send_mutex);", "return VAR_3;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ] ]

[ "PCIBus *FUNC_0(PCII440FXState **pi440fx_state,\nint *piix3_devfn,\nISABus **isa_bus, qemu_irq *pic,\nMemoryRegion *address_space_mem,\nMemoryRegion *address_space_io,\nram_addr_t ram_size,\nhwaddr pci_hole_start,\nhwaddr pci_hole_size,\nram_addr_t above_4g_mem_size,\nMemoryRegion *pci_address_space,\nMemoryRegion *ram_memory)\n{", "DeviceState *dev;", "PCIBus *b;", "PCIDevice *d;", "PCIHostState *s;", "PIIX3State *piix3;", "PCII440FXState *f;", "unsigned VAR_0;", "I440FXState *i440fx;", "dev = qdev_create(NULL, TYPE_I440FX_PCI_HOST_BRIDGE);", "s = PCI_HOST_BRIDGE(dev);", "b = pci_bus_new(dev, NULL, pci_address_space,\naddress_space_io, 0, TYPE_PCI_BUS);", "s->bus = b;", "object_property_add_child(qdev_get_machine(), \"i440fx\", OBJECT(dev), NULL);", "qdev_init_nofail(dev);", "d = pci_create_simple(b, 0, TYPE_I440FX_PCI_DEVICE);", "*pi440fx_state = I440FX_PCI_DEVICE(d);", "f = *pi440fx_state;", "f->system_memory = address_space_mem;", "f->pci_address_space = pci_address_space;", "f->ram_memory = ram_memory;", "i440fx = I440FX_PCI_HOST_BRIDGE(dev);", "if (ram_size <= 0x80000000) {", "i440fx->pci_info.w32.begin = 0x80000000;", "} else if (ram_size <= 0xc0000000) {", "i440fx->pci_info.w32.begin = 0xc0000000;", "} else {", "i440fx->pci_info.w32.begin = 0xe0000000;", "}", "memory_region_init_alias(&f->pci_hole, OBJECT(d), \"pci-hole\", f->pci_address_space,\npci_hole_start, pci_hole_size);", "memory_region_add_subregion(f->system_memory, pci_hole_start, &f->pci_hole);", "pc_init_pci64_hole(&i440fx->pci_info, 0x100000000ULL + above_4g_mem_size,\ni440fx->pci_hole64_size);", "memory_region_init_alias(&f->pci_hole_64bit, OBJECT(d), \"pci-hole64\",\nf->pci_address_space,\ni440fx->pci_info.w64.begin,\ni440fx->pci_hole64_size);", "if (i440fx->pci_hole64_size) {", "memory_region_add_subregion(f->system_memory,\ni440fx->pci_info.w64.begin,\n&f->pci_hole_64bit);", "}", "memory_region_init_alias(&f->smram_region, OBJECT(d), \"smram-region\",\nf->pci_address_space, 0xa0000, 0x20000);", "memory_region_add_subregion_overlap(f->system_memory, 0xa0000,\n&f->smram_region, 1);", "memory_region_set_enabled(&f->smram_region, false);", "init_pam(dev, f->ram_memory, f->system_memory, f->pci_address_space,\n&f->pam_regions[0], PAM_BIOS_BASE, PAM_BIOS_SIZE);", "for (VAR_0 = 0; VAR_0 < 12; ++VAR_0) {", "init_pam(dev, f->ram_memory, f->system_memory, f->pci_address_space,\n&f->pam_regions[VAR_0+1], PAM_EXPAN_BASE + VAR_0 * PAM_EXPAN_SIZE,\nPAM_EXPAN_SIZE);", "}", "if (xen_enabled()) {", "piix3 = DO_UPCAST(PIIX3State, dev,\npci_create_simple_multifunction(b, -1, true, \"PIIX3-xen\"));", "pci_bus_irqs(b, xen_piix3_set_irq, xen_pci_slot_get_pirq,\npiix3, XEN_PIIX_NUM_PIRQS);", "} else {", "piix3 = DO_UPCAST(PIIX3State, dev,\npci_create_simple_multifunction(b, -1, true, \"PIIX3\"));", "pci_bus_irqs(b, piix3_set_irq, pci_slot_get_pirq, piix3,\nPIIX_NUM_PIRQS);", "pci_bus_set_route_irq_fn(b, piix3_route_intx_pin_to_irq);", "}", "piix3->pic = pic;", "*isa_bus = ISA_BUS(qdev_get_child_bus(DEVICE(piix3), \"isa.0\"));", "*piix3_devfn = piix3->dev.devfn;", "ram_size = ram_size / 8 / 1024 / 1024;", "if (ram_size > 255) {", "ram_size = 255;", "}", "d->config[0x57] = ram_size;", "i440fx_update_memory_mappings(f);", "return b;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95, 97 ], [ 99 ], [ 103, 105 ], [ 107, 109, 111, 113 ], [ 115 ], [ 117, 119, 121 ], [ 123 ], [ 125, 127 ], [ 129, 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141, 143, 145 ], [ 147 ], [ 159 ], [ 161, 163 ], [ 165, 167 ], [ 169 ], [ 171, 173 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 209 ], [ 211 ] ]

[ "static int FUNC_0(struct mmu_ctx_hash32 *VAR_0, target_ulong *VAR_1,\nint VAR_2, int VAR_3)\n{", "int VAR_4 = 0;", "if (!(*VAR_1 & HPTE32_R_R)) {", "*VAR_1 |= HPTE32_R_R;", "VAR_4 = 1;", "}", "if (!(*VAR_1 & HPTE32_R_C)) {", "if (VAR_3 == 1 && VAR_2 == 0) {", "*VAR_1 |= HPTE32_R_C;", "VAR_4 = 1;", "} else {", "VAR_0->prot &= ~PAGE_WRITE;", "}", "}", "return VAR_4;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ] ]

[ "static bool FUNC_0(IDEState *s, uint8_t cmd)\n{", "uint16_t *identify_data;", "if (!s->bs) {", "ide_abort_command(s);", "return true;", "}", "switch (s->feature) {", "case 0x02:\nbdrv_set_enable_write_cache(s->bs, true);", "identify_data = (uint16_t *)s->identify_data;", "put_le16(identify_data + 85, (1 << 14) | (1 << 5) | 1);", "return true;", "case 0x82:\nbdrv_set_enable_write_cache(s->bs, false);", "identify_data = (uint16_t *)s->identify_data;", "put_le16(identify_data + 85, (1 << 14) | 1);", "ide_flush_cache(s);", "return false;", "case 0xcc:\ncase 0x66:\ncase 0xaa:\ncase 0x55:\ncase 0x05:\ncase 0x85:\ncase 0x69:\ncase 0x67:\ncase 0x96:\ncase 0x9a:\ncase 0x42:\ncase 0xc2:\nreturn true;", "case 0x03:\n{", "uint8_t val = s->nsector & 0x07;", "identify_data = (uint16_t *)s->identify_data;", "switch (s->nsector >> 3) {", "case 0x00:\ncase 0x01:\nput_le16(identify_data + 62, 0x07);", "put_le16(identify_data + 63, 0x07);", "put_le16(identify_data + 88, 0x3f);", "break;", "case 0x02:\nput_le16(identify_data + 62, 0x07 | (1 << (val + 8)));", "put_le16(identify_data + 63, 0x07);", "put_le16(identify_data + 88, 0x3f);", "break;", "case 0x04:\nput_le16(identify_data + 62, 0x07);", "put_le16(identify_data + 63, 0x07 | (1 << (val + 8)));", "put_le16(identify_data + 88, 0x3f);", "break;", "case 0x08:\nput_le16(identify_data + 62, 0x07);", "put_le16(identify_data + 63, 0x07);", "put_le16(identify_data + 88, 0x3f | (1 << (val + 8)));", "break;", "default:\ngoto abort_cmd;", "}", "return true;", "}", "}", "abort_cmd:\nide_abort_command(s);", "return true;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83, 85, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 143 ], [ 145 ] ]

[ "static void FUNC_0(SCSIDevice *VAR_0, Error **VAR_1)\n{", "SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0);", "scsi_device_purge_requests(&s->qdev, SENSE_CODE(NO_SENSE));", "blockdev_mark_auto_del(s->qdev.conf.blk);", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ] ]

[ "uint32 FUNC_0( float64 a STATUS_PARAM )\n{", "int64_t v;", "uint32 res;", "v = float64_to_int64_round_to_zero(a STATUS_VAR);", "if (v < 0) {", "res = 0;", "float_raise( float_flag_invalid STATUS_VAR);", "} else if (v > 0xffffffff) {", "res = 0xffffffff;", "float_raise( float_flag_invalid STATUS_VAR);", "} else {", "res = v;", "}", "return res;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVDictionary *VAR_1, unsigned int VAR_2,\nunsigned int VAR_3, ebml_master *VAR_4)\n{", "MatroskaMuxContext *mkv = VAR_0->priv_data;", "ebml_master tag, targets;", "AVDictionaryEntry *t = NULL;", "int VAR_5;", "if (!VAR_4->pos) {", "VAR_5 = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(VAR_0->pb));", "if (VAR_5 < 0) return VAR_5;", "*VAR_4 = start_ebml_master(VAR_0->pb, MATROSKA_ID_TAGS, 0);", "}", "tag = start_ebml_master(VAR_0->pb, MATROSKA_ID_TAG, 0);", "targets = start_ebml_master(VAR_0->pb, MATROSKA_ID_TAGTARGETS, 0);", "if (VAR_2)\nput_ebml_uint(VAR_0->pb, VAR_2, VAR_3);", "end_ebml_master(VAR_0->pb, targets);", "while ((t = av_dict_get(VAR_1, \"\", t, AV_DICT_IGNORE_SUFFIX)))\nif (av_strcasecmp(t->key, \"title\") &&\nav_strcasecmp(t->key, \"encoding_tool\"))\nmkv_write_simpletag(VAR_0->pb, t);", "end_ebml_master(VAR_0->pb, tag);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 43, 45, 47, 49 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "static int FUNC_0(AACContext *VAR_0,\nAVCodecContext *VAR_1,\nMPEG4AudioConfig *VAR_2,\nconst uint8_t *VAR_3, int VAR_4,\nint VAR_5)\n{", "GetBitContext gb;", "int VAR_6, VAR_7;", "av_dlog(VAR_1, \"extradata size %d\\n\", VAR_1->extradata_size);", "for (VAR_6 = 0; VAR_6 < VAR_1->extradata_size; VAR_6++)", "av_dlog(VAR_1, \"%02x \", VAR_1->extradata[VAR_6]);", "av_dlog(VAR_1, \"\\n\");", "init_get_bits(&gb, VAR_3, VAR_4);", "if ((VAR_6 = avpriv_mpeg4audio_get_config(VAR_2, VAR_3, VAR_4,\nVAR_5)) < 0)\nreturn AVERROR_INVALIDDATA;", "if (VAR_2->sampling_index > 12) {", "av_log(VAR_1, AV_LOG_ERROR,\n\"invalid sampling rate index %d\\n\",\nVAR_2->sampling_index);", "return AVERROR_INVALIDDATA;", "}", "skip_bits_long(&gb, VAR_6);", "switch (VAR_2->object_type) {", "case AOT_AAC_MAIN:\ncase AOT_AAC_LC:\ncase AOT_AAC_LTP:\nif ((VAR_7 = decode_ga_specific_config(VAR_0, VAR_1, &gb,\nVAR_2, VAR_2->chan_config)) < 0)\nreturn VAR_7;", "break;", "default:\nav_log(VAR_1, AV_LOG_ERROR,\n\"Audio object type %s%d is not supported.\\n\",\nVAR_2->sbr == 1 ? \"SBR+\" : \"\",\nVAR_2->object_type);", "return AVERROR(ENOSYS);", "}", "av_dlog(VAR_1,\n\"AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\\n\",\nVAR_2->object_type, VAR_2->chan_config, VAR_2->sampling_index,\nVAR_2->sample_rate, VAR_2->sbr,\nVAR_2->ps);", "return get_bits_count(&gb);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33, 35, 37 ], [ 39 ], [ 41, 43, 45 ], [ 47 ], [ 49 ], [ 53 ], [ 57 ], [ 59, 61, 63, 65, 67, 69 ], [ 71 ], [ 73, 75, 77, 79, 81 ], [ 83 ], [ 85 ], [ 89, 91, 93, 95, 97 ], [ 101 ], [ 103 ] ]

[ "static int FUNC_0(RV34DecContext *VAR_0)\n{", "MpegEncContext *s = &VAR_0->s;", "int VAR_1 = 0, VAR_2, VAR_3;", "int VAR_4 = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;", "int16_t (*motion_val)[2] = s->current_picture_ptr->motion_val[0][VAR_4];", "if(s->pict_type == FF_I_TYPE)\nreturn 0;", "for(VAR_3 = 0; VAR_3 < 16; VAR_3 += 8){", "for(VAR_2 = 0; VAR_2 < 2; VAR_2++){", "if(is_mv_diff_gt_3(motion_val + VAR_2, 1))\nVAR_1 |= 0x11 << (VAR_3 + VAR_2*2);", "if(is_mv_diff_gt_3(motion_val + VAR_2, s->b8_stride))\nVAR_1 |= 0x03 << (VAR_3 + VAR_2*2);", "}", "motion_val += s->b8_stride;", "}", "return VAR_1;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 19 ], [ 21, 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ] ]

[ "static int FUNC_0(CPUPPCState *VAR_0, struct mmu_ctx_hash32 *VAR_1,\ntarget_ulong VAR_2, int VAR_3, int VAR_4)\n{", "target_ulong *BATlt, *BATut, *BATu, *BATl;", "target_ulong BEPIl, BEPIu, bl;", "int VAR_5, VAR_6, VAR_7;", "int VAR_8 = -1;", "LOG_BATS(\"%s: %cBAT v \" TARGET_FMT_lx \"\\n\", __func__,\nVAR_4 == ACCESS_CODE ? 'I' : 'D', VAR_2);", "switch (VAR_4) {", "case ACCESS_CODE:\nBATlt = VAR_0->IBAT[1];", "BATut = VAR_0->IBAT[0];", "break;", "default:\nBATlt = VAR_0->DBAT[1];", "BATut = VAR_0->DBAT[0];", "break;", "}", "for (VAR_5 = 0; VAR_5 < VAR_0->nb_BATs; VAR_5++) {", "BATu = &BATut[VAR_5];", "BATl = &BATlt[VAR_5];", "BEPIu = *BATu & BATU32_BEPIU;", "BEPIl = *BATu & BATU32_BEPIL;", "if (unlikely(VAR_0->mmu_model == POWERPC_MMU_601)) {", "hash32_bat_601_size_prot(VAR_0, &bl, &VAR_6, &VAR_7, BATu, BATl);", "} else {", "hash32_bat_size_prot(VAR_0, &bl, &VAR_6, &VAR_7, BATu, BATl);", "}", "LOG_BATS(\"%s: %cBAT%d v \" TARGET_FMT_lx \" BATu \" TARGET_FMT_lx\n\" BATl \" TARGET_FMT_lx \"\\n\", __func__,\nVAR_4 == ACCESS_CODE ? 'I' : 'D', VAR_5, VAR_2, *BATu, *BATl);", "if ((VAR_2 & BATU32_BEPIU) == BEPIu &&\n((VAR_2 & BATU32_BEPIL) & ~bl) == BEPIl) {", "if (VAR_6 != 0) {", "VAR_1->raddr = (*BATl & BATL32_BRPNU) |\n((VAR_2 & BATU32_BEPIL & bl) | (*BATl & BATL32_BRPNL)) |\n(VAR_2 & 0x0001F000);", "VAR_1->VAR_7 = VAR_7;", "VAR_8 = ppc_hash32_check_prot(VAR_1->VAR_7, VAR_3, VAR_4);", "if (VAR_8 == 0) {", "LOG_BATS(\"BAT %d match: r \" TARGET_FMT_plx \" VAR_7=%c%c\\n\",\nVAR_5, VAR_1->raddr, VAR_1->VAR_7 & PAGE_READ ? 'R' : '-',\nVAR_1->VAR_7 & PAGE_WRITE ? 'W' : '-');", "}", "break;", "}", "}", "}", "if (VAR_8 < 0) {", "#if defined(DEBUG_BATS)\nif (qemu_log_enabled()) {", "LOG_BATS(\"no BAT match for \" TARGET_FMT_lx \":\\n\", VAR_2);", "for (VAR_5 = 0; VAR_5 < 4; VAR_5++) {", "BATu = &BATut[VAR_5];", "BATl = &BATlt[VAR_5];", "BEPIu = *BATu & BATU32_BEPIU;", "BEPIl = *BATu & BATU32_BEPIL;", "bl = (*BATu & 0x00001FFC) << 15;", "LOG_BATS(\"%s: %cBAT%d v \" TARGET_FMT_lx \" BATu \" TARGET_FMT_lx\n\" BATl \" TARGET_FMT_lx \"\\n\\t\" TARGET_FMT_lx \" \"\nTARGET_FMT_lx \" \" TARGET_FMT_lx \"\\n\",\n__func__, VAR_4 == ACCESS_CODE ? 'I' : 'D', VAR_5, VAR_2,\n*BATu, *BATl, BEPIu, BEPIl, bl);", "}", "}", "#endif\n}", "return VAR_8;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17, 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63, 65 ], [ 67, 69 ], [ 73 ], [ 77, 79, 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91, 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127, 129, 131, 133, 135 ], [ 137 ], [ 139 ], [ 141, 143 ], [ 147 ], [ 149 ] ]

[ "static uint64_t FUNC_0(void *opaque, hwaddr offset,\nunsigned size)\n{", "pl050_state *s = (pl050_state *)opaque;", "if (offset >= 0xfe0 && offset < 0x1000)\nreturn pl050_id[(offset - 0xfe0) >> 2];", "switch (offset >> 2) {", "case 0:\nreturn s->cr;", "case 1:\n{", "uint8_t val;", "uint32_t stat;", "val = s->last;", "val = val ^ (val >> 4);", "val = val ^ (val >> 2);", "val = (val ^ (val >> 1)) & 1;", "stat = PL050_TXEMPTY;", "if (val)\nstat |= PL050_RXPARITY;", "if (s->pending)\nstat |= PL050_RXFULL;", "return stat;", "}", "case 2:\nif (s->pending)\ns->last = ps2_read_data(s->dev);", "return s->last;", "case 3:\nreturn s->clk;", "case 4:\nreturn s->pending | 2;", "default:\nhw_error(\"FUNC_0: Bad offset %x\\n\", (int)offset);", "return 0;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9, 11 ], [ 15 ], [ 17, 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43, 45 ], [ 47, 49 ], [ 53 ], [ 55 ], [ 57, 59, 61 ], [ 63 ], [ 65, 67 ], [ 69, 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ] ]

[ "BlockdevOnError FUNC_0(BlockDriverState *bs, bool is_read)\n{", "return is_read ? bs->on_read_error : bs->on_write_error;", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ] ]

[ "static int FUNC_0(char *VAR_0, int VAR_1, int VAR_2, QDict *VAR_3)\n{", "Error *local_err = NULL;", "if (qemuio_bs) {", "fprintf(stderr, \"file open already, try 'help close'\\n\");", "return 1;", "}", "if (VAR_2) {", "if (bdrv_open(&qemuio_bs, VAR_0, NULL, VAR_3, VAR_1 | BDRV_O_PROTOCOL,\nNULL, &local_err))\n{", "fprintf(stderr, \"%s: can't open device %s: %s\\n\", progname, VAR_0,\nerror_get_pretty(local_err));", "error_free(local_err);", "return 1;", "}", "} else {", "qemuio_bs = bdrv_new(\"hda\");", "if (bdrv_open(&qemuio_bs, VAR_0, NULL, VAR_3, VAR_1, NULL, &local_err)\n< 0)\n{", "fprintf(stderr, \"%s: can't open device %s: %s\\n\", progname, VAR_0,\nerror_get_pretty(local_err));", "error_free(local_err);", "bdrv_unref(qemuio_bs);", "qemuio_bs = NULL;", "return 1;", "}", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23, 25 ], [ 27, 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43, 45, 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ] ]

[ "static int FUNC_0(USBDevice *VAR_0, USBPacket *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, int VAR_5, uint8_t *VAR_6)\n{", "USBHIDState *us = DO_UPCAST(USBHIDState, VAR_0, VAR_0);", "HIDState *hs = &us->hid;", "int VAR_7;", "VAR_7 = usb_desc_handle_control(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6);", "if (VAR_7 >= 0) {", "return VAR_7;", "}", "VAR_7 = 0;", "switch (VAR_2) {", "case DeviceRequest | USB_REQ_GET_INTERFACE:\nVAR_6[0] = 0;", "VAR_7 = 1;", "break;", "case DeviceOutRequest | USB_REQ_SET_INTERFACE:\nVAR_7 = 0;", "break;", "case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:\nswitch (VAR_3 >> 8) {", "case 0x22:\nif (hs->kind == HID_MOUSE) {", "memcpy(VAR_6, qemu_mouse_hid_report_descriptor,\nsizeof(qemu_mouse_hid_report_descriptor));", "VAR_7 = sizeof(qemu_mouse_hid_report_descriptor);", "} else if (hs->kind == HID_TABLET) {", "memcpy(VAR_6, qemu_tablet_hid_report_descriptor,\nsizeof(qemu_tablet_hid_report_descriptor));", "VAR_7 = sizeof(qemu_tablet_hid_report_descriptor);", "} else if (hs->kind == HID_KEYBOARD) {", "memcpy(VAR_6, qemu_keyboard_hid_report_descriptor,\nsizeof(qemu_keyboard_hid_report_descriptor));", "VAR_7 = sizeof(qemu_keyboard_hid_report_descriptor);", "}", "break;", "default:\ngoto fail;", "}", "break;", "case GET_REPORT:\nif (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {", "VAR_7 = hid_pointer_poll(hs, VAR_6, VAR_5);", "} else if (hs->kind == HID_KEYBOARD) {", "VAR_7 = hid_keyboard_poll(hs, VAR_6, VAR_5);", "}", "us->changed = hs->n > 0;", "break;", "case SET_REPORT:\nif (hs->kind == HID_KEYBOARD) {", "VAR_7 = hid_keyboard_write(hs, VAR_6, VAR_5);", "} else {", "goto fail;", "}", "break;", "case GET_PROTOCOL:\nif (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) {", "goto fail;", "}", "VAR_7 = 1;", "VAR_6[0] = us->protocol;", "break;", "case SET_PROTOCOL:\nif (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) {", "goto fail;", "}", "VAR_7 = 0;", "us->protocol = VAR_3;", "break;", "case GET_IDLE:\nVAR_7 = 1;", "VAR_6[0] = us->idle;", "break;", "case SET_IDLE:\nus->idle = (uint8_t) (VAR_3 >> 8);", "usb_hid_set_next_idle(us, qemu_get_clock_ns(vm_clock));", "VAR_7 = 0;", "break;", "default:\nfail:\nVAR_7 = USB_RET_STALL;", "break;", "}", "return VAR_7;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 45, 47 ], [ 49, 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163, 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ] ]

[ "void FUNC_0(GICState *VAR_0, int VAR_1, int VAR_2, uint8_t VAR_3)\n{", "if (VAR_2 < GIC_INTERNAL) {", "VAR_0->priority1[VAR_2][VAR_1] = VAR_3;", "} else {", "VAR_0->priority2[(VAR_2) - GIC_INTERNAL] = VAR_3;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ] ]

[ "static void FUNC_0(void)\n{", "Coroutine *coroutine;", "coroutine = qemu_coroutine_create(verify_self);", "qemu_coroutine_enter(coroutine, coroutine);", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ] ]

[ "void FUNC_0(Object *VAR_0)\n{", "object_ref(VAR_0);", "if (VAR_0->parent) {", "object_property_del_child(VAR_0->parent, VAR_0, NULL);", "}", "if (VAR_0->class->unparent) {", "(VAR_0->class->unparent)(VAR_0);", "}", "object_unref(VAR_0);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ] ]

[ "static int FUNC_0(MPADecodeContext *VAR_0, UINT32 VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5;", "int VAR_6, VAR_7;", "if (VAR_1 & (1<<20)) {", "VAR_0->lsf = (VAR_1 & (1<<19)) ? 0 : 1;", "VAR_4 = 0;", "} else {", "VAR_0->lsf = 1;", "VAR_4 = 1;", "}", "VAR_0->layer = 4 - ((VAR_1 >> 17) & 3);", "VAR_6 = (VAR_1 >> 10) & 3;", "VAR_2 = mpa_freq_tab[VAR_6] >> (VAR_0->lsf + VAR_4);", "if (VAR_2 == 0)\nreturn 1;", "VAR_6 += 3 * (VAR_0->lsf + VAR_4);", "VAR_0->VAR_6 = VAR_6;", "VAR_0->error_protection = ((VAR_1 >> 16) & 1) ^ 1;", "VAR_7 = (VAR_1 >> 12) & 0xf;", "VAR_5 = (VAR_1 >> 9) & 1;", "VAR_0->mode = (VAR_1 >> 6) & 3;", "VAR_0->mode_ext = (VAR_1 >> 4) & 3;", "if (VAR_0->mode == MPA_MONO)\nVAR_0->nb_channels = 1;", "else\nVAR_0->nb_channels = 2;", "if (VAR_7 != 0) {", "VAR_3 = mpa_bitrate_tab[VAR_0->lsf][VAR_0->layer - 1][VAR_7];", "VAR_0->bit_rate = VAR_3 * 1000;", "switch(VAR_0->layer) {", "case 1:\nVAR_3 = (VAR_3 * 12000) / VAR_2;", "VAR_3 = (VAR_3 + VAR_5) * 4;", "break;", "case 2:\nVAR_3 = (VAR_3 * 144000) / VAR_2;", "VAR_3 += VAR_5;", "break;", "default:\ncase 3:\nVAR_3 = (VAR_3 * 144000) / (VAR_2 << VAR_0->lsf);", "VAR_3 += VAR_5;", "break;", "}", "VAR_0->VAR_3 = VAR_3;", "} else {", "if (!VAR_0->free_format_frame_size)\nreturn 1;", "VAR_0->VAR_3 = VAR_0->free_format_frame_size;", "switch(VAR_0->layer) {", "case 1:\nVAR_0->VAR_3 += VAR_5 * 4;", "VAR_0->bit_rate = (VAR_0->VAR_3 * VAR_2) / 48000;", "break;", "case 2:\nVAR_0->VAR_3 += VAR_5;", "VAR_0->bit_rate = (VAR_0->VAR_3 * VAR_2) / 144000;", "break;", "default:\ncase 3:\nVAR_0->VAR_3 += VAR_5;", "VAR_0->bit_rate = (VAR_0->VAR_3 * (VAR_2 << VAR_0->lsf)) / 144000;", "break;", "}", "}", "VAR_0->VAR_2 = VAR_2;", "#ifdef DEBUG\nprintf(\"layer%d, %d Hz, %d kbits/VAR_0, \",\nVAR_0->layer, VAR_0->VAR_2, VAR_0->bit_rate);", "if (VAR_0->nb_channels == 2) {", "if (VAR_0->layer == 3) {", "if (VAR_0->mode_ext & MODE_EXT_MS_STEREO)\nprintf(\"ms-\");", "if (VAR_0->mode_ext & MODE_EXT_I_STEREO)\nprintf(\"i-\");", "}", "printf(\"stereo\");", "} else {", "printf(\"mono\");", "}", "printf(\"\\n\");", "#endif\nreturn 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 63, 65 ], [ 67, 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 97, 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115, 117 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143, 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 161, 163, 165 ], [ 167 ], [ 169 ], [ 171, 173 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191, 193 ], [ 195 ] ]

[ "static gboolean FUNC_0(GtkWidget *widget,\nGdkEventCrossing *crossing, gpointer opaque)\n{", "VirtualConsole *vc = opaque;", "GtkDisplayState *s = vc->s;", "gtk_release_modifiers(s);", "return TRUE;", "}" ]

[ 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ] ]

[ "void FUNC_0(ISADevice *VAR_0, qemu_irq *VAR_1, int VAR_2)\n{", "assert(VAR_0->nirqs < ARRAY_SIZE(VAR_0->VAR_2));", "if (isabus->assigned & (1 << VAR_2)) {", "hw_error(\"isa irq %d already assigned\", VAR_2);", "}", "isabus->assigned |= (1 << VAR_2);", "VAR_0->VAR_2[VAR_0->nirqs] = VAR_2;", "*VAR_1 = isabus->irqs[VAR_2];", "VAR_0->nirqs++;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ] ]

[ "void FUNC_0(BlockDriverState *VAR_0, BlockDriverState *VAR_1)\n{", "BlockDriverState tmp;", "if (VAR_0->node_name[0] != '\\0') {", "QTAILQ_REMOVE(&graph_bdrv_states, VAR_0, node_list);", "}", "if (VAR_1->node_name[0] != '\\0') {", "QTAILQ_REMOVE(&graph_bdrv_states, VAR_1, node_list);", "}", "assert(VAR_0->device_name[0] == '\\0');", "assert(QLIST_EMPTY(&VAR_0->dirty_bitmaps));", "assert(VAR_0->job == NULL);", "assert(VAR_0->dev == NULL);", "assert(bdrv_op_blocker_is_empty(VAR_0));", "assert(VAR_0->io_limits_enabled == false);", "assert(!throttle_have_timer(&VAR_0->throttle_state));", "tmp = *VAR_0;", "*VAR_0 = *VAR_1;", "*VAR_1 = tmp;", "bdrv_move_feature_fields(&tmp, VAR_1);", "bdrv_move_feature_fields(VAR_1, VAR_0);", "bdrv_move_feature_fields(VAR_0, &tmp);", "assert(VAR_0->device_name[0] == '\\0');", "assert(VAR_0->dev == NULL);", "assert(VAR_0->job == NULL);", "assert(bdrv_op_blocker_is_empty(VAR_0));", "assert(VAR_0->io_limits_enabled == false);", "assert(!throttle_have_timer(&VAR_0->throttle_state));", "if (VAR_0->node_name[0] != '\\0') {", "QTAILQ_INSERT_TAIL(&graph_bdrv_states, VAR_0, node_list);", "}", "if (VAR_1->node_name[0] != '\\0') {", "QTAILQ_INSERT_TAIL(&graph_bdrv_states, VAR_1, node_list);", "}", "bdrv_rebind(VAR_0);", "bdrv_rebind(VAR_1);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 59 ], [ 61 ], [ 63 ], [ 69 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ] ]

[ "static int FUNC_0(S390CPU *VAR_0, uint32_t VAR_1,\nuint64_t *VAR_2)\n{", "CPUState *cur_cs;", "S390CPU *cur_cpu;", "bool all_stopped = true;", "CPU_FOREACH(cur_cs) {", "cur_cpu = S390_CPU(cur_cs);", "if (cur_cpu == VAR_0) {", "continue;", "}", "if (s390_cpu_get_state(cur_cpu) != CPU_STATE_STOPPED) {", "all_stopped = false;", "}", "}", "*VAR_2 &= 0xffffffff00000000ULL;", "*VAR_2 |= (all_stopped ? SIGP_STAT_INVALID_PARAMETER :\nSIGP_STAT_INCORRECT_STATE);", "return SIGP_CC_STATUS_STORED;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 43, 45 ], [ 47 ], [ 49 ] ]

[ "int FUNC_0(S390CPU *VAR_0)\n{", "kvm_s390_interrupt(VAR_0, KVM_S390_RESTART, 0);", "s390_add_running_cpu(VAR_0);", "qemu_cpu_kick(CPU(VAR_0));", "DPRINTF(\"DONE: KVM VAR_0 restart: %p\\n\", &VAR_0->env);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ] ]

[ "float64 FUNC_0( uint64 a STATUS_PARAM )\n{", "if ( a == 0 ) return 0;", "return normalizeRoundAndPackFloat64( 0, 0x43C, a STATUS_VAR );", "}" ]

[ 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ] ]

[ "void FUNC_0(void *VAR_0)\n{", "GT64120State *s = VAR_0;", "#ifdef TARGET_WORDS_BIGENDIAN\ns->regs[GT_CPU] = 0x00000000;", "#else\ns->regs[GT_CPU] = 0x00001000;", "#endif\ns->regs[GT_MULTI] = 0x00000000;", "s->regs[GT_PCI0IOLD] = 0x00000080;", "s->regs[GT_PCI0IOHD] = 0x0000000f;", "s->regs[GT_PCI0M0LD] = 0x00000090;", "s->regs[GT_PCI0M0HD] = 0x0000001f;", "s->regs[GT_PCI0M1LD] = 0x00000790;", "s->regs[GT_PCI0M1HD] = 0x0000001f;", "s->regs[GT_PCI1IOLD] = 0x00000100;", "s->regs[GT_PCI1IOHD] = 0x0000000f;", "s->regs[GT_PCI1M0LD] = 0x00000110;", "s->regs[GT_PCI1M0HD] = 0x0000001f;", "s->regs[GT_PCI1M1LD] = 0x00000120;", "s->regs[GT_PCI1M1HD] = 0x0000002f;", "s->regs[GT_PCI0IOREMAP] = 0x00000080;", "s->regs[GT_PCI0M0REMAP] = 0x00000090;", "s->regs[GT_PCI0M1REMAP] = 0x00000790;", "s->regs[GT_PCI1IOREMAP] = 0x00000100;", "s->regs[GT_PCI1M0REMAP] = 0x00000110;", "s->regs[GT_PCI1M1REMAP] = 0x00000120;", "s->regs[GT_CPUERR_ADDRLO] = 0x00000000;", "s->regs[GT_CPUERR_ADDRHI] = 0x00000000;", "s->regs[GT_CPUERR_DATALO] = 0xffffffff;", "s->regs[GT_CPUERR_DATAHI] = 0xffffffff;", "s->regs[GT_CPUERR_PARITY] = 0x000000ff;", "s->regs[GT_ECC_ERRDATALO] = 0x00000000;", "s->regs[GT_ECC_ERRDATAHI] = 0x00000000;", "s->regs[GT_ECC_MEM] = 0x00000000;", "s->regs[GT_ECC_CALC] = 0x00000000;", "s->regs[GT_ECC_ERRADDR] = 0x00000000;", "s->regs[GT_SDRAM_B0] = 0x00000005;", "s->regs[GT_SDRAM_B1] = 0x00000005;", "s->regs[GT_SDRAM_B2] = 0x00000005;", "s->regs[GT_SDRAM_B3] = 0x00000005;", "#ifdef TARGET_WORDS_BIGENDIAN\ns->regs[GT_PCI0_CMD] = 0x00000000;", "s->regs[GT_PCI1_CMD] = 0x00000000;", "#else\ns->regs[GT_PCI0_CMD] = 0x00010001;", "s->regs[GT_PCI1_CMD] = 0x00010001;", "#endif\ns->regs[GT_PCI0_IACK] = 0x00000000;", "s->regs[GT_PCI1_IACK] = 0x00000000;", "gt64120_pci_mapping(s);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 11, 13 ], [ 15, 17 ], [ 19, 21 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 107, 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 127 ], [ 129 ] ]

[ "uint64_t FUNC_0(CPUPPCState *env, uint64_t arg)\n{", "CPU_DoubleU farg;", "farg.ll = arg;", "if (unlikely(float64_is_signaling_nan(farg.d))) {", "farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN |\nPOWERPC_EXCP_FP_VXCVI);", "} else if (unlikely(float64_is_quiet_nan(farg.d) ||", "float64_is_infinity(farg.d))) {", "farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI);", "} else {", "farg.ll = float64_to_int32(farg.d, &env->fp_status);", "farg.ll |= 0xFFF80000ULL << 32;", "}", "return farg.ll;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 13 ], [ 17, 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ] ]

[ "static void FUNC_0(VFIOPCIDevice *VAR_0)\n{", "PCIDevice *pdev = &VAR_0->pdev;", "uint32_t header;", "uint16_t cap_id, next, size;", "uint8_t cap_ver;", "uint8_t *config;", "if (!pci_is_express(pdev) || !pci_bus_is_express(pdev->bus) ||\n!pci_get_long(pdev->config + PCI_CONFIG_SPACE_SIZE)) {", "return;", "}", "config = g_memdup(pdev->config, VAR_0->config_size);", "pci_set_long(pdev->config + PCI_CONFIG_SPACE_SIZE,\nPCI_EXT_CAP(0xFFFF, 0, 0));", "pci_set_long(pdev->wmask + PCI_CONFIG_SPACE_SIZE, 0);", "pci_set_long(VAR_0->emulated_config_bits + PCI_CONFIG_SPACE_SIZE, ~0);", "for (next = PCI_CONFIG_SPACE_SIZE; next;", "next = PCI_EXT_CAP_NEXT(pci_get_long(config + next))) {", "header = pci_get_long(config + next);", "cap_id = PCI_EXT_CAP_ID(header);", "cap_ver = PCI_EXT_CAP_VER(header);", "size = vfio_ext_cap_max_size(config, next);", "pci_long_test_and_set_mask(VAR_0->emulated_config_bits + next,\nPCI_EXT_CAP_NEXT_MASK);", "switch (cap_id) {", "case PCI_EXT_CAP_ID_SRIOV:\ncase PCI_EXT_CAP_ID_ARI:\ntrace_vfio_add_ext_cap_dropped(VAR_0->vbasedev.name, cap_id, next);", "break;", "default:\npcie_add_capability(pdev, cap_id, cap_ver, next, size);", "}", "}", "if (pci_get_word(pdev->config + PCI_CONFIG_SPACE_SIZE) == 0xFFFF) {", "pci_set_word(pdev->config + PCI_CONFIG_SPACE_SIZE, 0);", "}", "g_free(config);", "return;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 41 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 107 ], [ 113, 115 ], [ 119 ], [ 121, 123, 125 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 137 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ] ]

[ "bool FUNC_0(int ofs, int len)\n{", "return (facilities & FACILITY_GEN_INST_EXT) != 0;", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ] ]

[ "void FUNC_0(CPUS390XState *VAR_0, uint64_t VAR_1, uint64_t VAR_2)\n{", "uint64_t addr = VAR_0->regs[VAR_1];", "uint64_t subcode = VAR_0->regs[VAR_2];", "IplParameterBlock *iplb;", "if (VAR_0->psw.mask & PSW_MASK_PSTATE) {", "program_interrupt(VAR_0, PGM_PRIVILEGED, ILEN_LATER_INC);", "return;", "}", "if ((subcode & ~0x0ffffULL) || (subcode > 6)) {", "program_interrupt(VAR_0, PGM_SPECIFICATION, ILEN_LATER_INC);", "return;", "}", "switch (subcode) {", "case 0:\nmodified_clear_reset(s390_env_get_cpu(VAR_0));", "if (tcg_enabled()) {", "cpu_loop_exit(CPU(s390_env_get_cpu(VAR_0)));", "}", "break;", "case 1:\nload_normal_reset(s390_env_get_cpu(VAR_0));", "if (tcg_enabled()) {", "cpu_loop_exit(CPU(s390_env_get_cpu(VAR_0)));", "}", "break;", "case 3:\ns390_reipl_request();", "if (tcg_enabled()) {", "cpu_loop_exit(CPU(s390_env_get_cpu(VAR_0)));", "}", "break;", "case 5:\nif ((VAR_1 & 1) || (addr & 0x0fffULL)) {", "program_interrupt(VAR_0, PGM_SPECIFICATION, ILEN_LATER_INC);", "return;", "}", "if (!address_space_access_valid(&address_space_memory, addr,\nsizeof(IplParameterBlock), false)) {", "program_interrupt(VAR_0, PGM_ADDRESSING, ILEN_LATER_INC);", "return;", "}", "iplb = g_malloc0(sizeof(IplParameterBlock));", "cpu_physical_memory_read(addr, iplb, sizeof(iplb->len));", "if (!iplb_valid_len(iplb)) {", "VAR_0->regs[VAR_1 + 1] = DIAG_308_RC_INVALID;", "goto out;", "}", "cpu_physical_memory_read(addr, iplb, be32_to_cpu(iplb->len));", "if (!iplb_valid_ccw(iplb) && !iplb_valid_fcp(iplb)) {", "VAR_0->regs[VAR_1 + 1] = DIAG_308_RC_INVALID;", "goto out;", "}", "s390_ipl_update_diag308(iplb);", "VAR_0->regs[VAR_1 + 1] = DIAG_308_RC_OK;", "out:\ng_free(iplb);", "return;", "case 6:\nif ((VAR_1 & 1) || (addr & 0x0fffULL)) {", "program_interrupt(VAR_0, PGM_SPECIFICATION, ILEN_LATER_INC);", "return;", "}", "if (!address_space_access_valid(&address_space_memory, addr,\nsizeof(IplParameterBlock), true)) {", "program_interrupt(VAR_0, PGM_ADDRESSING, ILEN_LATER_INC);", "return;", "}", "iplb = s390_ipl_get_iplb();", "if (iplb) {", "cpu_physical_memory_write(addr, iplb, be32_to_cpu(iplb->len));", "VAR_0->regs[VAR_1 + 1] = DIAG_308_RC_OK;", "} else {", "VAR_0->regs[VAR_1 + 1] = DIAG_308_RC_NO_CONF;", "}", "return;", "default:\nhw_error(\"Unhandled diag308 subcode %\" PRIx64, subcode);", "break;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ] ]

[ "static int FUNC_0(int VAR_0)\n{", "int VAR_1;", "const PixFmtInfo *VAR_2;", "VAR_2 = &pix_fmt_info[VAR_0];", "if (VAR_2->is_packed) {", "switch(VAR_0) {", "case PIX_FMT_RGB24:\ncase PIX_FMT_BGR24:\nVAR_1 = 24;", "break;", "case PIX_FMT_RGBA32:\nVAR_1 = 32;", "break;", "case PIX_FMT_RGB565:\ncase PIX_FMT_RGB555:\nVAR_1 = 16;", "break;", "case PIX_FMT_PAL8:\nVAR_1 = 8;", "break;", "default:\nVAR_1 = 32;", "break;", "}", "} else {", "VAR_1 = VAR_2->depth;", "VAR_1 += (2 * VAR_2->depth >>\n(VAR_2->x_chroma_shift + VAR_2->x_chroma_shift));", "}", "return VAR_1;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17, 19, 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31, 33, 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ] ]

[ "static void FUNC_0(TCGContext *VAR_0, TCGType VAR_1, TCGCond VAR_2,\nTCGReg VAR_3, TCGArg VAR_4, int VAR_5, TCGLabel *VAR_6)\n{", "int VAR_7;", "if (facilities & FACILITY_GEN_INST_EXT) {", "bool is_unsigned = is_unsigned_cond(VAR_2);", "bool in_range;", "S390Opcode opc;", "VAR_7 = tcg_cond_to_s390_cond[VAR_2];", "if (!VAR_5) {", "opc = (VAR_1 == TCG_TYPE_I32\n? (is_unsigned ? RIE_CLRJ : RIE_CRJ)\n: (is_unsigned ? RIE_CLGRJ : RIE_CGRJ));", "tgen_compare_branch(VAR_0, opc, VAR_7, VAR_3, VAR_4, VAR_6);", "return;", "}", "if (VAR_1 == TCG_TYPE_I32) {", "if (is_unsigned) {", "opc = RIE_CLIJ;", "in_range = (uint32_t)VAR_4 == (uint8_t)VAR_4;", "} else {", "opc = RIE_CIJ;", "in_range = (int32_t)VAR_4 == (int8_t)VAR_4;", "}", "} else {", "if (is_unsigned) {", "opc = RIE_CLGIJ;", "in_range = (uint64_t)VAR_4 == (uint8_t)VAR_4;", "} else {", "opc = RIE_CGIJ;", "in_range = (int64_t)VAR_4 == (int8_t)VAR_4;", "}", "}", "if (in_range) {", "tgen_compare_imm_branch(VAR_0, opc, VAR_7, VAR_3, VAR_4, VAR_6);", "return;", "}", "}", "VAR_7 = tgen_cmp(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, false);", "tgen_branch(VAR_0, VAR_7, VAR_6);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27, 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ] ]

[ "static int FUNC_0(CPUState *VAR_0)\n{", "struct {", "struct kvm_msrs info;", "struct kvm_msr_entry entries[100];", "} VAR_1;", "struct kvm_msr_entry *VAR_2 = VAR_1.entries;", "int VAR_3, VAR_4, VAR_5;", "VAR_5 = 0;", "VAR_2[VAR_5++].index = MSR_IA32_SYSENTER_CS;", "VAR_2[VAR_5++].index = MSR_IA32_SYSENTER_ESP;", "VAR_2[VAR_5++].index = MSR_IA32_SYSENTER_EIP;", "if (kvm_has_msr_star(VAR_0)) {", "VAR_2[VAR_5++].index = MSR_STAR;", "}", "if (kvm_has_msr_hsave_pa(VAR_0)) {", "VAR_2[VAR_5++].index = MSR_VM_HSAVE_PA;", "}", "VAR_2[VAR_5++].index = MSR_IA32_TSC;", "#ifdef TARGET_X86_64\nif (lm_capable_kernel) {", "VAR_2[VAR_5++].index = MSR_CSTAR;", "VAR_2[VAR_5++].index = MSR_KERNELGSBASE;", "VAR_2[VAR_5++].index = MSR_FMASK;", "VAR_2[VAR_5++].index = MSR_LSTAR;", "}", "#endif\nVAR_2[VAR_5++].index = MSR_KVM_SYSTEM_TIME;", "VAR_2[VAR_5++].index = MSR_KVM_WALL_CLOCK;", "#ifdef KVM_CAP_ASYNC_PF\nVAR_2[VAR_5++].index = MSR_KVM_ASYNC_PF_EN;", "#endif\n#ifdef KVM_CAP_MCE\nif (VAR_0->mcg_cap) {", "VAR_2[VAR_5++].index = MSR_MCG_STATUS;", "VAR_2[VAR_5++].index = MSR_MCG_CTL;", "for (VAR_4 = 0; VAR_4 < (VAR_0->mcg_cap & 0xff) * 4; VAR_4++) {", "VAR_2[VAR_5++].index = MSR_MC0_CTL + VAR_4;", "}", "}", "#endif\nVAR_1.info.nmsrs = VAR_5;", "VAR_3 = kvm_vcpu_ioctl(VAR_0, KVM_GET_MSRS, &VAR_1);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {", "switch (VAR_2[VAR_4].index) {", "case MSR_IA32_SYSENTER_CS:\nVAR_0->sysenter_cs = VAR_2[VAR_4].data;", "break;", "case MSR_IA32_SYSENTER_ESP:\nVAR_0->sysenter_esp = VAR_2[VAR_4].data;", "break;", "case MSR_IA32_SYSENTER_EIP:\nVAR_0->sysenter_eip = VAR_2[VAR_4].data;", "break;", "case MSR_STAR:\nVAR_0->star = VAR_2[VAR_4].data;", "break;", "#ifdef TARGET_X86_64\ncase MSR_CSTAR:\nVAR_0->cstar = VAR_2[VAR_4].data;", "break;", "case MSR_KERNELGSBASE:\nVAR_0->kernelgsbase = VAR_2[VAR_4].data;", "break;", "case MSR_FMASK:\nVAR_0->fmask = VAR_2[VAR_4].data;", "break;", "case MSR_LSTAR:\nVAR_0->lstar = VAR_2[VAR_4].data;", "break;", "#endif\ncase MSR_IA32_TSC:\nVAR_0->tsc = VAR_2[VAR_4].data;", "break;", "case MSR_VM_HSAVE_PA:\nVAR_0->vm_hsave = VAR_2[VAR_4].data;", "break;", "case MSR_KVM_SYSTEM_TIME:\nVAR_0->system_time_msr = VAR_2[VAR_4].data;", "break;", "case MSR_KVM_WALL_CLOCK:\nVAR_0->wall_clock_msr = VAR_2[VAR_4].data;", "break;", "#ifdef KVM_CAP_MCE\ncase MSR_MCG_STATUS:\nVAR_0->mcg_status = VAR_2[VAR_4].data;", "break;", "case MSR_MCG_CTL:\nVAR_0->mcg_ctl = VAR_2[VAR_4].data;", "break;", "#endif\ndefault:\n#ifdef KVM_CAP_MCE\nif (VAR_2[VAR_4].index >= MSR_MC0_CTL &&\nVAR_2[VAR_4].index < MSR_MC0_CTL + (VAR_0->mcg_cap & 0xff) * 4) {", "VAR_0->mce_banks[VAR_2[VAR_4].index - MSR_MC0_CTL] = VAR_2[VAR_4].data;", "}", "#endif\nbreak;", "#ifdef KVM_CAP_ASYNC_PF\ncase MSR_KVM_ASYNC_PF_EN:\nVAR_0->async_pf_en_msr = VAR_2[VAR_4].data;", "break;", "#endif\n}", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61, 63 ], [ 65, 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129, 131, 133 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155, 157, 159 ], [ 161 ], [ 163, 165 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 181, 183, 185 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 195, 197, 199, 201, 203 ], [ 205 ], [ 207 ], [ 209, 211 ], [ 213, 215, 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 229 ], [ 231 ] ]

[ "static int FUNC_0(VncState *VAR_0, char *VAR_1, size_t VAR_2)\n{", "int VAR_3;", "uint16_t limit;", "switch (VAR_1[0]) {", "case 0:\nif (VAR_2 == 1)\nreturn 20;", "set_pixel_format(VAR_0, read_u8(VAR_1, 4), read_u8(VAR_1, 5),\nread_u8(VAR_1, 6), read_u8(VAR_1, 7),\nread_u16(VAR_1, 8), read_u16(VAR_1, 10),\nread_u16(VAR_1, 12), read_u8(VAR_1, 14),\nread_u8(VAR_1, 15), read_u8(VAR_1, 16));", "break;", "case 2:\nif (VAR_2 == 1)\nreturn 4;", "if (VAR_2 == 4)\nreturn 4 + (read_u16(VAR_1, 2) * 4);", "limit = read_u16(VAR_1, 2);", "for (VAR_3 = 0; VAR_3 < limit; VAR_3++) {", "int32_t val = read_s32(VAR_1, 4 + (VAR_3 * 4));", "memcpy(VAR_1 + 4 + (VAR_3 * 4), &val, sizeof(val));", "}", "set_encodings(VAR_0, (int32_t *)(VAR_1 + 4), limit);", "break;", "case 3:\nif (VAR_2 == 1)\nreturn 10;", "framebuffer_update_request(VAR_0,\nread_u8(VAR_1, 1), read_u16(VAR_1, 2), read_u16(VAR_1, 4),\nread_u16(VAR_1, 6), read_u16(VAR_1, 8));", "break;", "case 4:\nif (VAR_2 == 1)\nreturn 8;", "key_event(VAR_0, read_u8(VAR_1, 1), read_u32(VAR_1, 4));", "break;", "case 5:\nif (VAR_2 == 1)\nreturn 6;", "pointer_event(VAR_0, read_u8(VAR_1, 1), read_u16(VAR_1, 2), read_u16(VAR_1, 4));", "break;", "case 6:\nif (VAR_2 == 1)\nreturn 8;", "if (VAR_2 == 8)\nreturn 8 + read_u32(VAR_1, 4);", "client_cut_text(VAR_0, read_u32(VAR_1, 4), VAR_1 + 8);", "break;", "default:\nprintf(\"Msg: %d\\n\", VAR_1[0]);", "vnc_client_error(VAR_0);", "break;", "}", "vnc_read_when(VAR_0, FUNC_0, 1);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13, 15, 17 ], [ 21, 23, 25, 27, 29 ], [ 31 ], [ 33, 35, 37 ], [ 41, 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63, 65, 67 ], [ 71, 73, 75 ], [ 77 ], [ 79, 81, 83 ], [ 87 ], [ 89 ], [ 91, 93, 95 ], [ 99 ], [ 101 ], [ 103, 105, 107 ], [ 111, 113 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ] ]

[ "static void FUNC_0(MirrorBlockJob *VAR_0)\n{", "while (VAR_0->in_flight > 0) {", "mirror_wait_for_io(VAR_0);", "}", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ] ]

[ "static inline void FUNC_0(IDEState *VAR_0)\n{", "ide_transfer_stop(VAR_0);", "VAR_0->status = READY_STAT | ERR_STAT;", "VAR_0->error = ABRT_ERR;", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ] ]

[ "static inline void FUNC_0(int32_t VAR_0)\n{", "tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[R_ESP]));", "tcg_gen_addi_tl(cpu_tmp0, cpu_tmp0, VAR_0);", "tcg_gen_st16_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[R_ESP]) + REG_W_OFFSET);", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ] ]

[ "static void FUNC_0(const struct sun4m_hwdef *VAR_0,\nQEMUMachineInitArgs *VAR_1)\n{", "const char *VAR_2 = VAR_1->VAR_2;", "unsigned int VAR_3;", "void *VAR_4, *VAR_5, *VAR_6, *VAR_7;", "qemu_irq *cpu_irqs[MAX_CPUS], slavio_irq[32], slavio_cpu_irq[MAX_CPUS],\nespdma_irq, ledma_irq;", "qemu_irq esp_reset, dma_enable;", "qemu_irq fdc_tc;", "qemu_irq *cpu_halt;", "unsigned long VAR_8;", "DriveInfo *fd[MAX_FD];", "FWCfgState *fw_cfg;", "unsigned int VAR_9;", "if (!VAR_2)\nVAR_2 = VAR_0->default_cpu_model;", "for(VAR_3 = 0; VAR_3 < smp_cpus; VAR_3++) {", "cpu_devinit(VAR_2, VAR_3, VAR_0->slavio_base, &cpu_irqs[VAR_3]);", "}", "for (VAR_3 = smp_cpus; VAR_3 < MAX_CPUS; VAR_3++)", "cpu_irqs[VAR_3] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS);", "ram_init(0, VAR_1->ram_size, VAR_0->max_mem);", "if (!VAR_0->ecc_base) {", "empty_slot_init(VAR_1->ram_size, VAR_0->max_mem - VAR_1->ram_size);", "}", "prom_init(VAR_0->slavio_base, bios_name);", "slavio_intctl = slavio_intctl_init(VAR_0->intctl_base,\nVAR_0->intctl_base + 0x10000ULL,\ncpu_irqs);", "for (VAR_3 = 0; VAR_3 < 32; VAR_3++) {", "slavio_irq[VAR_3] = qdev_get_gpio_in(slavio_intctl, VAR_3);", "}", "for (VAR_3 = 0; VAR_3 < MAX_CPUS; VAR_3++) {", "slavio_cpu_irq[VAR_3] = qdev_get_gpio_in(slavio_intctl, 32 + VAR_3);", "}", "if (VAR_0->idreg_base) {", "idreg_init(VAR_0->idreg_base);", "}", "if (VAR_0->afx_base) {", "afx_init(VAR_0->afx_base);", "}", "VAR_4 = iommu_init(VAR_0->iommu_base, VAR_0->iommu_version,\nslavio_irq[30]);", "if (VAR_0->iommu_pad_base) {", "empty_slot_init(VAR_0->iommu_pad_base,VAR_0->iommu_pad_len);", "}", "VAR_5 = sparc32_dma_init(VAR_0->dma_base, slavio_irq[18],\nVAR_4, &espdma_irq, 0);", "VAR_6 = sparc32_dma_init(VAR_0->dma_base + 16ULL,\nslavio_irq[16], VAR_4, &ledma_irq, 1);", "if (graphic_depth != 8 && graphic_depth != 24) {", "fprintf(stderr, \"qemu: Unsupported depth: %d\\n\", graphic_depth);", "exit (1);", "}", "VAR_9 = 0;", "if (VAR_9 == 0) {", "tcx_init(VAR_0->tcx_base, 0x00100000, graphic_width, graphic_height,\ngraphic_depth);", "}", "for (VAR_3 = VAR_9; VAR_3 < MAX_VSIMMS; VAR_3++) {", "if (VAR_0->vsimm[VAR_3].reg_base) {", "empty_slot_init(VAR_0->vsimm[VAR_3].reg_base, 0x2000);", "}", "}", "if (VAR_0->sx_base) {", "empty_slot_init(VAR_0->sx_base, 0x2000);", "}", "lance_init(&nd_table[0], VAR_0->le_base, VAR_6, ledma_irq);", "VAR_7 = m48t59_init(slavio_irq[0], VAR_0->nvram_base, 0, 0x2000, 8);", "slavio_timer_init_all(VAR_0->counter_base, slavio_irq[19], slavio_cpu_irq, smp_cpus);", "slavio_serial_ms_kbd_init(VAR_0->ms_kb_base, slavio_irq[14],\ndisplay_type == DT_NOGRAPHIC, ESCC_CLOCK, 1);", "escc_init(VAR_0->serial_base, slavio_irq[15], slavio_irq[15],\nserial_hds[0], serial_hds[1], ESCC_CLOCK, 1);", "cpu_halt = qemu_allocate_irqs(cpu_halt_signal, NULL, 1);", "if (VAR_0->apc_base) {", "apc_init(VAR_0->apc_base, cpu_halt[0]);", "}", "if (VAR_0->fd_base) {", "memset(fd, 0, sizeof(fd));", "fd[0] = drive_get(IF_FLOPPY, 0, 0);", "sun4m_fdctrl_init(slavio_irq[22], VAR_0->fd_base, fd,\n&fdc_tc);", "} else {", "fdc_tc = *qemu_allocate_irqs(dummy_fdc_tc, NULL, 1);", "}", "slavio_misc_init(VAR_0->slavio_base, VAR_0->aux1_base, VAR_0->aux2_base,\nslavio_irq[30], fdc_tc);", "if (drive_get_max_bus(IF_SCSI) > 0) {", "fprintf(stderr, \"qemu: too many SCSI bus\\n\");", "exit(1);", "}", "esp_init(VAR_0->esp_base, 2,\nespdma_memory_read, espdma_memory_write,\nVAR_5, espdma_irq, &esp_reset, &dma_enable);", "qdev_connect_gpio_out(VAR_5, 0, esp_reset);", "qdev_connect_gpio_out(VAR_5, 1, dma_enable);", "if (VAR_0->cs_base) {", "sysbus_create_simple(\"SUNW,CS4231\", VAR_0->cs_base,\nslavio_irq[5]);", "}", "if (VAR_0->dbri_base) {", "empty_slot_init(VAR_0->dbri_base+0x1000, 0x30);", "empty_slot_init(VAR_0->dbri_base+0x10000, 0x100);", "}", "if (VAR_0->bpp_base) {", "empty_slot_init(VAR_0->bpp_base, 0x20);", "}", "VAR_8 = sun4m_load_kernel(VAR_1->kernel_filename,\nVAR_1->initrd_filename,\nVAR_1->ram_size);", "nvram_init(VAR_7, (uint8_t *)&nd_table[0].macaddr, VAR_1->kernel_cmdline,\nVAR_1->boot_device, VAR_1->ram_size, VAR_8, graphic_width,\ngraphic_height, graphic_depth, VAR_0->nvram_machine_id,\n\"Sun4m\");", "if (VAR_0->ecc_base)\necc_init(VAR_0->ecc_base, slavio_irq[28],\nVAR_0->ecc_version);", "fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);", "fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);", "fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);", "fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);", "fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, VAR_0->machine_id);", "fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_DEPTH, graphic_depth);", "fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_WIDTH, graphic_width);", "fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_HEIGHT, graphic_height);", "fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, KERNEL_LOAD_ADDR);", "fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, VAR_8);", "if (VAR_1->kernel_cmdline) {", "fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);", "pstrcpy_targphys(\"cmdline\", CMDLINE_ADDR, TARGET_PAGE_SIZE,\nVAR_1->kernel_cmdline);", "fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, VAR_1->kernel_cmdline);", "fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE,\nstrlen(VAR_1->kernel_cmdline) + 1);", "} else {", "fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);", "fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 0);", "}", "fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, INITRD_LOAD_ADDR);", "fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, 0);", "fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, VAR_1->boot_device[0]);", "qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 35, 37 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 75, 77, 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 113, 115 ], [ 119 ], [ 129 ], [ 131 ], [ 135, 137 ], [ 141, 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159, 161 ], [ 163 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 193 ], [ 197 ], [ 201, 203 ], [ 209, 211 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 225 ], [ 229 ], [ 231 ], [ 233, 235 ], [ 237 ], [ 239 ], [ 241 ], [ 245, 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 261, 263, 265 ], [ 269 ], [ 271 ], [ 275 ], [ 277, 279 ], [ 281 ], [ 285 ], [ 291 ], [ 295 ], [ 297 ], [ 301 ], [ 305 ], [ 307 ], [ 311, 313, 315 ], [ 319, 321, 323, 325 ], [ 329, 331, 333 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361, 363 ], [ 365 ], [ 367, 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ] ]

[ "static inline void FUNC_0(TCGv VAR_0, TCGv_i32 VAR_1)\n{", "gen_mov_reg_N(cpu_tmp0, VAR_1);", "gen_mov_reg_V(VAR_0, VAR_1);", "tcg_gen_xor_tl(VAR_0, VAR_0, cpu_tmp0);", "gen_mov_reg_Z(cpu_tmp0, VAR_1);", "tcg_gen_or_tl(VAR_0, VAR_0, cpu_tmp0);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ] ]

[ "static void FUNC_0(Object *VAR_0)\n{", "CompareState *s = COLO_COMPARE(VAR_0);", "qemu_chr_fe_deinit(&s->chr_pri_in, false);", "qemu_chr_fe_deinit(&s->chr_sec_in, false);", "qemu_chr_fe_deinit(&s->chr_out, false);", "g_main_loop_quit(s->compare_loop);", "qemu_thread_join(&s->thread);", "g_queue_foreach(&s->conn_list, colo_flush_packets, s);", "g_queue_clear(&s->conn_list);", "g_hash_table_destroy(s->connection_track_table);", "g_free(s->pri_indev);", "g_free(s->sec_indev);", "g_free(s->outdev);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ] ]

[ "static int FUNC_0(MigrationState *VAR_0)\n{", "int VAR_1 = 0;", "DPRINTF(\"FUNC_0\\n\");", "VAR_1 = qemu_fclose(VAR_0->opaque);", "VAR_0->opaque = NULL;", "VAR_0->fd = -1;", "if (VAR_1 >= 0 && !(WIFEXITED(VAR_1) && WEXITSTATUS(VAR_1) == 0)) {", "VAR_1 = -EIO;", "}", "return VAR_1;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ] ]

[ "static int FUNC_0(MegasasState *VAR_0, MegasasCmd *VAR_1)\n{", "uint64_t abort_ctx = le64_to_cpu(VAR_1->frame->abort.abort_context);", "target_phys_addr_t abort_addr, addr_hi, addr_lo;", "MegasasCmd *abort_cmd;", "addr_hi = le32_to_cpu(VAR_1->frame->abort.abort_mfi_addr_hi);", "addr_lo = le32_to_cpu(VAR_1->frame->abort.abort_mfi_addr_lo);", "abort_addr = ((uint64_t)addr_hi << 32) | addr_lo;", "abort_cmd = megasas_lookup_frame(VAR_0, abort_addr);", "if (!abort_cmd) {", "trace_megasas_abort_no_cmd(VAR_1->index, abort_ctx);", "VAR_0->event_count++;", "return MFI_STAT_OK;", "}", "if (!megasas_use_queue64(VAR_0)) {", "abort_ctx &= (uint64_t)0xFFFFFFFF;", "}", "if (abort_cmd->context != abort_ctx) {", "trace_megasas_abort_invalid_context(VAR_1->index, abort_cmd->index,\nabort_cmd->context);", "VAR_0->event_count++;", "return MFI_STAT_ABORT_NOT_POSSIBLE;", "}", "trace_megasas_abort_frame(VAR_1->index, abort_cmd->index);", "megasas_abort_command(abort_cmd);", "if (!VAR_0->event_cmd || abort_cmd != VAR_0->event_cmd) {", "VAR_0->event_cmd = NULL;", "}", "VAR_0->event_count++;", "return MFI_STAT_OK;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ] ]

[ "static bool FUNC_0(AioContext *ctx)\n{", "return !aio_external_disabled(ctx) && ctx->epoll_enabled;", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 7 ], [ 9 ] ]

[ "av_cold void FUNC_0(void){", "static int VAR_0 = 0;", "if (!VAR_0) {", "int VAR_1;", "int VAR_2;", "VAR_0 = 1;", "chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;", "chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;", "init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,\n&chroma_dc_coeff_token_len [0], 1, 1,\n&chroma_dc_coeff_token_bits[0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;", "chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;", "init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,\n&chroma422_dc_coeff_token_len [0], 1, 1,\n&chroma422_dc_coeff_token_bits[0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "VAR_2 = 0;", "for(VAR_1=0; VAR_1<4; VAR_1++){", "coeff_token_vlc[VAR_1].table = coeff_token_vlc_tables+VAR_2;", "coeff_token_vlc[VAR_1].table_allocated = coeff_token_vlc_tables_size[VAR_1];", "init_vlc(&coeff_token_vlc[VAR_1], COEFF_TOKEN_VLC_BITS, 4*17,\n&coeff_token_len [VAR_1][0], 1, 1,\n&coeff_token_bits[VAR_1][0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "VAR_2 += coeff_token_vlc_tables_size[VAR_1];", "}", "av_assert0(VAR_2 == FF_ARRAY_ELEMS(coeff_token_vlc_tables));", "for(VAR_1=0; VAR_1<3; VAR_1++){", "chroma_dc_total_zeros_vlc[VAR_1].table = chroma_dc_total_zeros_vlc_tables[VAR_1];", "chroma_dc_total_zeros_vlc[VAR_1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;", "init_vlc(&chroma_dc_total_zeros_vlc[VAR_1],\nCHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,\n&chroma_dc_total_zeros_len [VAR_1][0], 1, 1,\n&chroma_dc_total_zeros_bits[VAR_1][0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "}", "for(VAR_1=0; VAR_1<7; VAR_1++){", "chroma422_dc_total_zeros_vlc[VAR_1].table = chroma422_dc_total_zeros_vlc_tables[VAR_1];", "chroma422_dc_total_zeros_vlc[VAR_1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;", "init_vlc(&chroma422_dc_total_zeros_vlc[VAR_1],\nCHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,\n&chroma422_dc_total_zeros_len [VAR_1][0], 1, 1,\n&chroma422_dc_total_zeros_bits[VAR_1][0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "}", "for(VAR_1=0; VAR_1<15; VAR_1++){", "total_zeros_vlc[VAR_1].table = total_zeros_vlc_tables[VAR_1];", "total_zeros_vlc[VAR_1].table_allocated = total_zeros_vlc_tables_size;", "init_vlc(&total_zeros_vlc[VAR_1],\nTOTAL_ZEROS_VLC_BITS, 16,\n&total_zeros_len [VAR_1][0], 1, 1,\n&total_zeros_bits[VAR_1][0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "}", "for(VAR_1=0; VAR_1<6; VAR_1++){", "run_vlc[VAR_1].table = run_vlc_tables[VAR_1];", "run_vlc[VAR_1].table_allocated = run_vlc_tables_size;", "init_vlc(&run_vlc[VAR_1],\nRUN_VLC_BITS, 7,\n&run_len [VAR_1][0], 1, 1,\n&run_bits[VAR_1][0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "}", "run7_vlc.table = run7_vlc_table,\nrun7_vlc.table_allocated = run7_vlc_table_size;", "init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,\n&run_len [6][0], 1, 1,\n&run_bits[6][0], 1, 1,\nINIT_VLC_USE_NEW_STATIC);", "init_cavlc_level_tab();", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1 ], [ 3 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21, 23, 25, 27 ], [ 31 ], [ 33 ], [ 35, 37, 39, 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53, 55, 57, 59 ], [ 61 ], [ 63 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87, 89, 91, 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107, 109, 111, 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125, 127, 129, 131, 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145, 147, 149, 151, 153 ], [ 155 ], [ 157, 159 ], [ 161, 163, 165, 167 ], [ 171 ], [ 173 ], [ 175 ] ]

[ "static inline void FUNC_0(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,\nunsigned int width, unsigned int height,\nint lumStride, int chromStride, int dstStride, int vertLumPerChroma)\n{", "unsigned VAR_0;", "const unsigned VAR_1= width>>1;", "for(VAR_0=0; VAR_0<height; VAR_0++)", "{", "#ifdef HAVE_MMX\nasm volatile(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\".balign 16\t\t\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 32(%1, %%\"REG_a\", 2)\t\\n\\t\"\nPREFETCH\" 32(%2, %%\"REG_a\")\t\\n\\t\"\nPREFETCH\" 32(%3, %%\"REG_a\")\t\\n\\t\"\n\"movq (%2, %%\"REG_a\"), %%mm0\t\\n\\t\"\n\"movq %%mm0, %%mm2\t\t\\n\\t\"\n\"movq (%3, %%\"REG_a\"), %%mm1\t\\n\\t\"\n\"punpcklbw %%mm1, %%mm0\t\t\\n\\t\"\n\"punpckhbw %%mm1, %%mm2\t\t\\n\\t\"\n\"movq (%1, %%\"REG_a\",2), %%mm3\t\\n\\t\"\n\"movq 8(%1, %%\"REG_a\",2), %%mm5\t\\n\\t\"\n\"movq %%mm0, %%mm4\t\t\\n\\t\"\n\"movq %%mm2, %%mm6\t\t\\n\\t\"\n\"punpcklbw %%mm3, %%mm0\t\t\\n\\t\"\n\"punpckhbw %%mm3, %%mm4\t\t\\n\\t\"\n\"punpcklbw %%mm5, %%mm2\t\t\\n\\t\"\n\"punpckhbw %%mm5, %%mm6\t\t\\n\\t\"\nMOVNTQ\" %%mm0, (%0, %%\"REG_a\", 4)\\n\\t\"\nMOVNTQ\" %%mm4, 8(%0, %%\"REG_a\", 4)\\n\\t\"\nMOVNTQ\" %%mm2, 16(%0, %%\"REG_a\", 4)\\n\\t\"\nMOVNTQ\" %%mm6, 24(%0, %%\"REG_a\", 4)\\n\\t\"\n\"add $8, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %4, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n::\"r\"(dst), \"r\"(ysrc), \"r\"(usrc), \"r\"(vsrc), \"g\" ((long)VAR_1)\n: \"%\"REG_a\n);", "#else\n#if __WORDSIZE >= 64\nint i;", "uint64_t *ldst = (uint64_t *) dst;", "const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;", "for(i = 0; i < VAR_1; i += 2){", "uint64_t k, l;", "k = uc[0] + (yc[0] << 8) +\n(vc[0] << 16) + (yc[1] << 24);", "l = uc[1] + (yc[2] << 8) +\n(vc[1] << 16) + (yc[3] << 24);", "*ldst++ = k + (l << 32);", "yc += 4;", "uc += 2;", "vc += 2;", "}", "#else\nint i, *idst = (int32_t *) dst;", "const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;", "for(i = 0; i < VAR_1; i++){", "#ifdef WORDS_BIGENDIAN\n*idst++ = (uc[0] << 24)+ (yc[0] << 16) +\n(vc[0] << 8) + (yc[1] << 0);", "#else\n*idst++ = uc[0] + (yc[0] << 8) +\n(vc[0] << 16) + (yc[1] << 24);", "#endif\nyc += 2;", "uc++;", "vc++;", "}", "#endif\n#endif\nif((VAR_0&(vertLumPerChroma-1))==(vertLumPerChroma-1) )\n{", "usrc += chromStride;", "vsrc += chromStride;", "}", "ysrc += lumStride;", "dst += dstStride;", "}", "#ifdef HAVE_MMX\nasm( EMMS\" \\n\\t\"\nSFENCE\" \\n\\t\"\n:::\"memory\");", "#endif\n}" ]

[ 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 47, 49, 51, 53, 55, 57, 59, 61, 65, 67, 69, 71, 75, 77, 79, 81, 83, 85 ], [ 87, 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133, 135, 137 ], [ 139, 141, 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155, 157, 159, 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177, 179, 181 ], [ 183, 185 ] ]

[ "static inline int FUNC_0(H264Context *VAR_0, Picture *VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int VAR_5)\n{", "int VAR_6 = VAR_0->mv_cache[VAR_5][scan8[VAR_2]][1];", "int VAR_7 = (VAR_6 & 3) ? 2 : 0;", "int VAR_8 = (VAR_6 >> 2) + VAR_4;", "int VAR_9 = VAR_8 - VAR_7;", "int VAR_10 = VAR_8 + VAR_7 + VAR_3;", "return FFMAX(abs(VAR_9), VAR_10);", "}" ]

[ 0, 0, 1, 0, 1, 1, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ] ]

[ "int FUNC_0(DVDemuxContext *VAR_0, AVPacket *VAR_1,\nuint8_t* VAR_2, int VAR_3)\n{", "int VAR_4, VAR_5;", "uint8_t *ppcm[4] = {0};", "if (VAR_3 < DV_PROFILE_BYTES ||\n!(VAR_0->sys = avpriv_dv_frame_profile(VAR_0->sys, VAR_2, VAR_3)) ||\nVAR_3 < VAR_0->sys->frame_size) {", "return -1;", "}", "VAR_4 = dv_extract_audio_info(VAR_0, VAR_2);", "for (VAR_5 = 0; VAR_5 < VAR_0->ach; VAR_5++) {", "VAR_0->audio_pkt[VAR_5].VAR_4 = VAR_4;", "VAR_0->audio_pkt[VAR_5].pts = VAR_0->abytes * 30000*8 / VAR_0->ast[VAR_5]->codec->bit_rate;", "ppcm[VAR_5] = VAR_0->audio_buf[VAR_5];", "}", "dv_extract_audio(VAR_2, ppcm, VAR_0->sys);", "if (VAR_0->sys->height == 720) {", "if (VAR_2[1] & 0x0C) {", "VAR_0->audio_pkt[2].VAR_4 = VAR_0->audio_pkt[3].VAR_4 = 0;", "} else {", "VAR_0->audio_pkt[0].VAR_4 = VAR_0->audio_pkt[1].VAR_4 = 0;", "VAR_0->abytes += VAR_4;", "}", "} else {", "VAR_0->abytes += VAR_4;", "}", "VAR_4 = dv_extract_video_info(VAR_0, VAR_2);", "av_init_packet(VAR_1);", "VAR_1->data = VAR_2;", "VAR_1->VAR_4 = VAR_4;", "VAR_1->flags |= AV_PKT_FLAG_KEY;", "VAR_1->stream_index = VAR_0->vst->id;", "VAR_1->pts = VAR_0->frames;", "VAR_0->frames++;", "return VAR_4;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13, 15, 17 ], [ 19 ], [ 21 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 93 ], [ 95 ] ]

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "dc->realize = fw_cfg_io_realize;", "dc->props = fw_cfg_io_properties;", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 18 ] ]

[ "static int FUNC_0(VLANState *VAR_0,\nconst char *VAR_1,\nconst char *VAR_2,\nconst char *VAR_3)\n{", "NetSocketListenState *s;", "int VAR_4, VAR_5, VAR_6;", "struct sockaddr_in VAR_7;", "if (parse_host_port(&VAR_7, VAR_3) < 0)\nreturn -1;", "s = g_malloc0(sizeof(NetSocketListenState));", "VAR_4 = qemu_socket(PF_INET, SOCK_STREAM, 0);", "if (VAR_4 < 0) {", "perror(\"socket\");", "g_free(s);", "return -1;", "}", "socket_set_nonblock(VAR_4);", "VAR_5 = 1;", "setsockopt(VAR_4, SOL_SOCKET, SO_REUSEADDR, (const char *)&VAR_5, sizeof(VAR_5));", "VAR_6 = bind(VAR_4, (struct sockaddr *)&VAR_7, sizeof(VAR_7));", "if (VAR_6 < 0) {", "perror(\"bind\");", "g_free(s);", "return -1;", "}", "VAR_6 = listen(VAR_4, 0);", "if (VAR_6 < 0) {", "perror(\"listen\");", "g_free(s);", "return -1;", "}", "s->VAR_0 = VAR_0;", "s->VAR_1 = g_strdup(VAR_1);", "s->VAR_2 = VAR_2 ? g_strdup(VAR_2) : NULL;", "s->VAR_4 = VAR_4;", "qemu_set_fd_handler(VAR_4, net_socket_accept, NULL, s);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19, 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 62 ], [ 64 ], [ 66 ], [ 68 ], [ 70 ], [ 72 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ] ]

[ "static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)\n{", "static const uint16_t VAR_2 = 0x0C8;", "static const uint16_t VAR_3 = 0x0E0;", "static const uint16_t VAR_4 = 0x100;", "static const uint16_t VAR_5 = 0x140;", "E1000EState *s = E1000E(VAR_0);", "uint8_t *macaddr;", "int VAR_6;", "trace_e1000e_cb_pci_realize();", "VAR_0->config_write = e1000e_write_config;", "VAR_0->config[PCI_CACHE_LINE_SIZE] = 0x10;", "VAR_0->config[PCI_INTERRUPT_PIN] = 1;", "pci_set_word(VAR_0->config + PCI_SUBSYSTEM_VENDOR_ID, s->subsys_ven);", "pci_set_word(VAR_0->config + PCI_SUBSYSTEM_ID, s->subsys);", "s->subsys_ven_used = s->subsys_ven;", "s->subsys_used = s->subsys;", "memory_region_init_io(&s->mmio, OBJECT(s), &mmio_ops, s,\n\"e1000e-mmio\", E1000E_MMIO_SIZE);", "pci_register_bar(VAR_0, E1000E_MMIO_IDX,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio);", "memory_region_init(&s->flash, OBJECT(s),\n\"e1000e-flash\", E1000E_FLASH_SIZE);", "pci_register_bar(VAR_0, E1000E_FLASH_IDX,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &s->flash);", "memory_region_init_io(&s->io, OBJECT(s), &io_ops, s,\n\"e1000e-io\", E1000E_IO_SIZE);", "pci_register_bar(VAR_0, E1000E_IO_IDX,\nPCI_BASE_ADDRESS_SPACE_IO, &s->io);", "memory_region_init(&s->msix, OBJECT(s), \"e1000e-msix\",\nE1000E_MSIX_SIZE);", "pci_register_bar(VAR_0, E1000E_MSIX_IDX,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &s->msix);", "qemu_macaddr_default_if_unset(&s->conf.macaddr);", "macaddr = s->conf.macaddr.a;", "e1000e_init_msix(s);", "if (pcie_endpoint_cap_v1_init(VAR_0, VAR_3) < 0) {", "hw_error(\"Failed to initialize PCIe capability\");", "}", "VAR_6 = msi_init(PCI_DEVICE(s), 0xD0, 1, true, false, NULL);", "if (VAR_6) {", "trace_e1000e_msi_init_fail(VAR_6);", "}", "if (e1000e_add_pm_capability(VAR_0, VAR_2,\nPCI_PM_CAP_DSI) < 0) {", "hw_error(\"Failed to initialize PM capability\");", "}", "if (pcie_aer_init(VAR_0, VAR_4, PCI_ERR_SIZEOF) < 0) {", "hw_error(\"Failed to initialize AER capability\");", "}", "pcie_dev_ser_num_init(VAR_0, VAR_5,\ne1000e_gen_dsn(macaddr));", "e1000e_init_net_peer(s, VAR_0, macaddr);", "e1000e_core_realize(s);", "e1000e_core_pci_realize(&s->core,\ne1000e_eeprom_template,\nsizeof(e1000e_eeprom_template),\nmacaddr);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 49, 51 ], [ 53, 55 ], [ 67, 69 ], [ 71, 73 ], [ 77, 79 ], [ 81, 83 ], [ 87, 89 ], [ 91, 93 ], [ 99 ], [ 101 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141 ], [ 145, 147 ], [ 151 ], [ 157 ], [ 161, 163, 165, 167 ], [ 169 ] ]

[ "int FUNC_0(AC3BitAllocParameters *VAR_0, int16_t *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, int VAR_5,\nint VAR_6, int VAR_7, uint8_t *VAR_8,\nuint8_t *VAR_9, uint8_t *VAR_10,\nint16_t *VAR_11)\n{", "int16_t excite[AC3_CRITICAL_BANDS];", "int VAR_12;", "int VAR_13, VAR_14, VAR_15, VAR_16;", "int VAR_17, VAR_18, VAR_19;", "VAR_13 = ff_ac3_bin_to_band_tab[VAR_2];", "VAR_14 = ff_ac3_bin_to_band_tab[VAR_3-1] + 1;", "if (VAR_13 == 0) {", "VAR_17 = 0;", "VAR_17 = calc_lowcomp1(VAR_17, VAR_1[0], VAR_1[1], 384);", "excite[0] = VAR_1[0] - VAR_4 - VAR_17;", "VAR_17 = calc_lowcomp1(VAR_17, VAR_1[1], VAR_1[2], 384);", "excite[1] = VAR_1[1] - VAR_4 - VAR_17;", "VAR_15 = 7;", "for (VAR_12 = 2; VAR_12 < 7; VAR_12++) {", "if (!(VAR_5 && VAR_12 == 6))\nVAR_17 = calc_lowcomp1(VAR_17, VAR_1[VAR_12], VAR_1[VAR_12+1], 384);", "VAR_18 = VAR_1[VAR_12] - VAR_4;", "VAR_19 = VAR_1[VAR_12] - VAR_0->slow_gain;", "excite[VAR_12] = VAR_18 - VAR_17;", "if (!(VAR_5 && VAR_12 == 6)) {", "if (VAR_1[VAR_12] <= VAR_1[VAR_12+1]) {", "VAR_15 = VAR_12 + 1;", "break;", "}", "}", "}", "VAR_16 = FFMIN(VAR_14, 22);", "for (VAR_12 = VAR_15; VAR_12 < VAR_16; VAR_12++) {", "if (!(VAR_5 && VAR_12 == 6))\nVAR_17 = calc_lowcomp(VAR_17, VAR_1[VAR_12], VAR_1[VAR_12+1], VAR_12);", "VAR_18 = FFMAX(VAR_18 - VAR_0->fast_decay, VAR_1[VAR_12] - VAR_4);", "VAR_19 = FFMAX(VAR_19 - VAR_0->slow_decay, VAR_1[VAR_12] - VAR_0->slow_gain);", "excite[VAR_12] = FFMAX(VAR_18 - VAR_17, VAR_19);", "}", "VAR_15 = 22;", "} else {", "VAR_15 = VAR_13;", "VAR_18 = (VAR_0->cpl_fast_leak << 8) + 768;", "VAR_19 = (VAR_0->cpl_slow_leak << 8) + 768;", "}", "for (VAR_12 = VAR_15; VAR_12 < VAR_14; VAR_12++) {", "VAR_18 = FFMAX(VAR_18 - VAR_0->fast_decay, VAR_1[VAR_12] - VAR_4);", "VAR_19 = FFMAX(VAR_19 - VAR_0->slow_decay, VAR_1[VAR_12] - VAR_0->slow_gain);", "excite[VAR_12] = FFMAX(VAR_18, VAR_19);", "}", "for (VAR_12 = VAR_13; VAR_12 < VAR_14; VAR_12++) {", "int VAR_20 = VAR_0->db_per_bit - VAR_1[VAR_12];", "if (VAR_20 > 0) {", "excite[VAR_12] += VAR_20 >> 2;", "}", "VAR_11[VAR_12] = FFMAX(ff_ac3_hearing_threshold_tab[VAR_12 >> VAR_0->sr_shift][VAR_0->sr_code], excite[VAR_12]);", "}", "if (VAR_6 == DBA_REUSE || VAR_6 == DBA_NEW) {", "int VAR_21, VAR_22, VAR_23;", "if (VAR_7 > 8)\nreturn -1;", "VAR_12 = VAR_13;", "for (VAR_22 = 0; VAR_22 < VAR_7; VAR_22++) {", "VAR_12 += VAR_8[VAR_22];", "if (VAR_12 >= AC3_CRITICAL_BANDS || VAR_9[VAR_22] > AC3_CRITICAL_BANDS-VAR_12)\nreturn -1;", "if (VAR_10[VAR_22] >= 4) {", "VAR_23 = (VAR_10[VAR_22] - 3) * 128;", "} else {", "VAR_23 = (VAR_10[VAR_22] - 4) * 128;", "}", "for (VAR_21 = 0; VAR_21 < VAR_9[VAR_22]; VAR_21++) {", "VAR_11[VAR_12++] += VAR_23;", "}", "}", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 2, 3, 4, 5, 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22, 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36, 37 ], [ 38 ], [ 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52 ], [ 53 ], [ 55 ], [ 56 ], [ 57 ], [ 58 ], [ 59 ], [ 60 ], [ 61 ], [ 63 ], [ 64 ], [ 65, 66 ], [ 67 ], [ 68 ], [ 69 ], [ 70, 71 ], [ 72 ], [ 73 ], [ 74 ], [ 75 ], [ 76 ], [ 77 ], [ 78 ], [ 79 ], [ 80 ], [ 81 ], [ 82 ], [ 83 ] ]

[ "int FUNC_0(FsContext *VAR_0,\nconst char *VAR_1, const char *VAR_2)\n{", "XattrOperations *xops = get_xattr_operations(VAR_0->xops, VAR_2);", "if (xops) {", "return xops->removexattr(VAR_0, VAR_1, VAR_2);", "}", "errno = -EOPNOTSUPP;", "return -1;", "}" ]

[ 0, 0, 0, 0, 0, 1, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ] ]

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "#else\nif (unlikely(VAR_0->pr)) {", "gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "return;", "}", "gen_helper_rfsvc(cpu_env);", "gen_sync_exception(VAR_0);", "#endif\n}" ]

[ 0, 1, 1, 1, 0, 0, 0, 0, 1 ]

[ [ 1, 3 ], [ 5, 7 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23, 25 ] ]

[ "static void FUNC_0(QEMUMachineInitArgs *VAR_0,\nint VAR_1,\nint VAR_2)\n{", "MemoryRegion *system_memory = get_system_memory();", "MemoryRegion *system_io = get_system_io();", "int VAR_3;", "ram_addr_t below_4g_mem_size, above_4g_mem_size;", "PCIBus *pci_bus;", "ISABus *isa_bus;", "PCII440FXState *i440fx_state;", "int VAR_4 = -1;", "qemu_irq *cpu_irq;", "qemu_irq *gsi;", "qemu_irq *i8259;", "qemu_irq *smi_irq;", "GSIState *gsi_state;", "DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];", "BusState *idebus[MAX_IDE_BUS];", "ISADevice *rtc_state;", "ISADevice *floppy;", "MemoryRegion *ram_memory;", "MemoryRegion *pci_memory;", "MemoryRegion *rom_memory;", "DeviceState *icc_bridge;", "FWCfgState *fw_cfg = NULL;", "PcGuestInfo *guest_info;", "if (xen_enabled() && xen_hvm_init(&ram_memory) != 0) {", "fprintf(stderr, \"xen hardware virtual machine initialisation failed\\n\");", "exit(1);", "}", "icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE);", "object_property_add_child(qdev_get_machine(), \"icc-bridge\",\nOBJECT(icc_bridge), NULL);", "pc_cpus_init(VAR_0->cpu_model, icc_bridge);", "if (kvm_enabled() && VAR_2) {", "kvmclock_create();", "}", "if (VAR_0->ram_size >= 0xe0000000) {", "above_4g_mem_size = VAR_0->ram_size - 0xe0000000;", "below_4g_mem_size = 0xe0000000;", "} else {", "above_4g_mem_size = 0;", "below_4g_mem_size = VAR_0->ram_size;", "}", "if (VAR_1) {", "pci_memory = g_new(MemoryRegion, 1);", "memory_region_init(pci_memory, NULL, \"pci\", INT64_MAX);", "rom_memory = pci_memory;", "} else {", "pci_memory = NULL;", "rom_memory = system_memory;", "}", "guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size);", "guest_info->has_acpi_build = has_acpi_build;", "guest_info->has_pci_info = has_pci_info;", "guest_info->isapc_ram_fw = !VAR_1;", "if (!xen_enabled()) {", "fw_cfg = pc_memory_init(system_memory,\nVAR_0->kernel_filename, VAR_0->kernel_cmdline,\nVAR_0->initrd_filename,\nbelow_4g_mem_size, above_4g_mem_size,\nrom_memory, &ram_memory, guest_info);", "}", "gsi_state = g_malloc0(sizeof(*gsi_state));", "if (kvm_irqchip_in_kernel()) {", "kvm_pc_setup_irq_routing(VAR_1);", "gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,\nGSI_NUM_PINS);", "} else {", "gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);", "}", "if (VAR_1) {", "pci_bus = i440fx_init(&i440fx_state, &VAR_4, &isa_bus, gsi,\nsystem_memory, system_io, VAR_0->ram_size,\nbelow_4g_mem_size,\n0x100000000ULL - below_4g_mem_size,\nabove_4g_mem_size,\npci_memory, ram_memory);", "} else {", "pci_bus = NULL;", "i440fx_state = NULL;", "isa_bus = isa_bus_new(NULL, system_io);", "no_hpet = 1;", "}", "isa_bus_irqs(isa_bus, gsi);", "if (kvm_irqchip_in_kernel()) {", "i8259 = kvm_i8259_init(isa_bus);", "} else if (xen_enabled()) {", "i8259 = xen_interrupt_controller_init();", "} else {", "cpu_irq = pc_allocate_cpu_irq();", "i8259 = i8259_init(isa_bus, cpu_irq[0]);", "}", "for (VAR_3 = 0; VAR_3 < ISA_NUM_IRQS; VAR_3++) {", "gsi_state->i8259_irq[VAR_3] = i8259[VAR_3];", "}", "if (VAR_1) {", "ioapic_init_gsi(gsi_state, \"i440fx\");", "}", "qdev_init_nofail(icc_bridge);", "pc_register_ferr_irq(gsi[13]);", "pc_vga_init(isa_bus, VAR_1 ? pci_bus : NULL);", "pc_basic_device_init(isa_bus, gsi, &rtc_state, &floppy, xen_enabled());", "pc_nic_init(isa_bus, pci_bus);", "ide_drive_get(hd, MAX_IDE_BUS);", "if (VAR_1) {", "PCIDevice *dev;", "if (xen_enabled()) {", "dev = pci_piix3_xen_ide_init(pci_bus, hd, VAR_4 + 1);", "} else {", "dev = pci_piix3_ide_init(pci_bus, hd, VAR_4 + 1);", "}", "idebus[0] = qdev_get_child_bus(&dev->qdev, \"ide.0\");", "idebus[1] = qdev_get_child_bus(&dev->qdev, \"ide.1\");", "} else {", "for(VAR_3 = 0; VAR_3 < MAX_IDE_BUS; VAR_3++) {", "ISADevice *dev;", "dev = isa_ide_init(isa_bus, ide_iobase[VAR_3], ide_iobase2[VAR_3],\nide_irq[VAR_3],\nhd[MAX_IDE_DEVS * VAR_3], hd[MAX_IDE_DEVS * VAR_3 + 1]);", "idebus[VAR_3] = qdev_get_child_bus(DEVICE(dev), \"ide.0\");", "}", "}", "pc_cmos_init(below_4g_mem_size, above_4g_mem_size, VAR_0->boot_order,\nfloppy, idebus[0], idebus[1], rtc_state);", "if (VAR_1 && usb_enabled(false)) {", "pci_create_simple(pci_bus, VAR_4 + 2, \"piix3-usb-uhci\");", "}", "if (VAR_1 && acpi_enabled) {", "i2c_bus *smbus;", "smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);", "smbus = piix4_pm_init(pci_bus, VAR_4 + 3, 0xb100,\ngsi[9], *smi_irq,\nkvm_enabled(), fw_cfg);", "smbus_eeprom_init(smbus, 8, NULL, 0);", "}", "if (VAR_1) {", "pc_pci_device_init(pci_bus);", "}", "if (has_pvpanic) {", "pvpanic_init(isa_bus);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69, 71 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 125 ], [ 129 ], [ 131 ], [ 137 ], [ 139, 141, 143, 145, 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159, 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173, 175, 177, 179, 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 235 ], [ 239 ], [ 245 ], [ 249 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281, 283 ], [ 285 ], [ 287 ], [ 289 ], [ 293, 295 ], [ 299 ], [ 301 ], [ 303 ], [ 307 ], [ 309 ], [ 313 ], [ 317, 319, 321 ], [ 323 ], [ 325 ], [ 329 ], [ 331 ], [ 333 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "int32_t fid;", "size_t offset = 7;", "ssize_t retval = 0;", "struct stat VAR_1;", "V9fsFidState *fidp;", "uint64_t request_mask;", "V9fsStatDotl v9stat_dotl;", "V9fsPDU *pdu = VAR_0;", "V9fsState *s = pdu->s;", "pdu_unmarshal(pdu, offset, \"dq\", &fid, &request_mask);", "fidp = get_fid(pdu, fid);", "if (fidp == NULL) {", "retval = -ENOENT;", "goto out_nofid;", "}", "retval = v9fs_co_lstat(pdu, &fidp->path, &VAR_1);", "if (retval < 0) {", "goto out;", "}", "stat_to_v9stat_dotl(s, &VAR_1, &v9stat_dotl);", "if (request_mask & P9_STATS_GEN) {", "retval = v9fs_co_st_gen(pdu, &fidp->path, VAR_1.st_mode, &v9stat_dotl);", "if (retval < 0) {", "goto out;", "}", "v9stat_dotl.st_result_mask |= P9_STATS_GEN;", "}", "retval = offset;", "retval += pdu_marshal(pdu, offset, \"A\", &v9stat_dotl);", "out:\nput_fid(pdu, fidp);", "out_nofid:\ntrace_v9fs_getattr_return(pdu->tag, pdu->id, v9stat_dotl.st_result_mask,\nv9stat_dotl.st_mode, v9stat_dotl.st_uid,\nv9stat_dotl.st_gid);", "complete_pdu(s, pdu, retval);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 30 ], [ 32 ], [ 34 ], [ 36 ], [ 38 ], [ 48 ], [ 50 ], [ 52 ], [ 54 ], [ 56 ], [ 62 ], [ 64 ], [ 66 ], [ 68 ], [ 70 ], [ 72 ], [ 74 ], [ 76 ], [ 78 ], [ 80, 82 ], [ 84, 86, 88, 90 ], [ 94 ], [ 96 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1, const char *VAR_2, int VAR_3)\n{", "AVIOContext *pb = VAR_0->pb;", "if (!strcmp(VAR_2, \"__DIR_COUNT\")) {", "VAR_1->nb_frames = var_read_int(pb, VAR_3);", "} else if (!strcmp(VAR_2, \"AUDIO_FORMAT\")) {", "VAR_1->codec->codec_id = var_read_int(pb, VAR_3);", "} else if (!strcmp(VAR_2, \"COMPRESSION\")) {", "VAR_1->codec->codec_tag = var_read_int(pb, VAR_3);", "} else if (!strcmp(VAR_2, \"DEFAULT_VOL\")) {", "var_read_metadata(VAR_0, VAR_2, VAR_3);", "} else if (!strcmp(VAR_2, \"NUM_CHANNELS\")) {", "VAR_1->codec->channels = var_read_int(pb, VAR_3);", "VAR_1->codec->channel_layout = (VAR_1->codec->channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;", "} else if (!strcmp(VAR_2, \"SAMPLE_RATE\")) {", "VAR_1->codec->sample_rate = var_read_int(pb, VAR_3);", "avpriv_set_pts_info(VAR_1, 33, 1, VAR_1->codec->sample_rate);", "} else if (!strcmp(VAR_2, \"SAMPLE_WIDTH\")) {", "VAR_1->codec->bits_per_coded_sample = var_read_int(pb, VAR_3) * 8;", "} else", "return -1;", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ] ]

[ "static void FUNC_0(uint8_t *VAR_0, uint8_t *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, int VAR_5,\nint VAR_6, int VAR_7, int VAR_8, int VAR_9,\nint VAR_10, int VAR_11, int VAR_12, int VAR_13)\n{", "const int VAR_14 = 8;", "const int VAR_15 = VAR_4 >> (16 + VAR_10);", "const int VAR_16 = VAR_5 >> (16 + VAR_10);", "const int VAR_17 = VAR_4 >> 4;", "const int VAR_18 = VAR_5 >> 4;", "const int VAR_19 = VAR_6 >> 4;", "const int VAR_20 = VAR_7 >> 4;", "const int VAR_21 = VAR_8 >> 4;", "const int VAR_22 = VAR_9 >> 4;", "const uint16_t VAR_23[4] = { VAR_11, VAR_11, VAR_11, VAR_11 };", "const uint16_t VAR_24[4] = { VAR_20, VAR_20, VAR_20, VAR_20 };", "const uint16_t VAR_25[4] = { VAR_22, VAR_22, VAR_22, VAR_22 };", "const uint64_t VAR_26 = 2 * VAR_10;", "#define MAX_STRIDE 4096U\n#define MAX_H 8U\nuint8_t edge_buf[(MAX_H + 1) * MAX_STRIDE];", "int VAR_27, VAR_28;", "const int VAR_29 = (VAR_6 - (1 << (16 + VAR_10))) * (VAR_14 - 1);", "const int VAR_30 = (VAR_9 - (1 << (16 + VAR_10))) * (VAR_3 - 1);", "const int VAR_31 = VAR_7 * (VAR_3 - 1);", "const int VAR_32 = VAR_8 * (VAR_14 - 1);", "int VAR_33 = (unsigned) VAR_15 >= VAR_12 - VAR_14 ||\n(unsigned) VAR_16 >= VAR_13 - VAR_3;", "if (\n((VAR_4 ^ (VAR_4 + VAR_29)) | (VAR_4 ^ (VAR_4 + VAR_31)) | (VAR_4 ^ (VAR_4 + VAR_29 + VAR_31)) |\n(VAR_5 ^ (VAR_5 + VAR_32)) | (VAR_5 ^ (VAR_5 + VAR_30)) | (VAR_5 ^ (VAR_5 + VAR_32 + VAR_30))) >> (16 + VAR_10) ||\n(VAR_6 | VAR_7 | VAR_8 | VAR_9) & 15 ||\n(VAR_33 && (VAR_3 > MAX_H || VAR_2 > MAX_STRIDE))) {", "ff_gmc_c(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9,\nVAR_10, VAR_11, VAR_12, VAR_13);", "return;", "}", "VAR_1 += VAR_15 + VAR_16 * VAR_2;", "if (VAR_33) {", "ff_emulated_edge_mc_8(edge_buf, VAR_1, VAR_2, VAR_2, VAR_14 + 1, VAR_3 + 1, VAR_15, VAR_16, VAR_12, VAR_13);", "VAR_1 = edge_buf;", "}", "__asm__ volatile (\n\"movd %0, %%mm6 \\n\\t\"\n\"pxor %%mm7, %%mm7 \\n\\t\"\n\"punpcklwd %%mm6, %%mm6 \\n\\t\"\n\"punpcklwd %%mm6, %%mm6 \\n\\t\"\n:: \"VAR_11\" (1 << VAR_10));", "for (VAR_27 = 0; VAR_27 < VAR_14; VAR_27 += 4) {", "uint16_t dx4[4] = { VAR_17 - VAR_20 + VAR_19 * (VAR_27 + 0),", "VAR_17 - VAR_20 + VAR_19 * (VAR_27 + 1),\nVAR_17 - VAR_20 + VAR_19 * (VAR_27 + 2),\nVAR_17 - VAR_20 + VAR_19 * (VAR_27 + 3) };", "uint16_t dy4[4] = { VAR_18 - VAR_22 + VAR_21 * (VAR_27 + 0),", "VAR_18 - VAR_22 + VAR_21 * (VAR_27 + 1),\nVAR_18 - VAR_22 + VAR_21 * (VAR_27 + 2),\nVAR_18 - VAR_22 + VAR_21 * (VAR_27 + 3) };", "for (VAR_28 = 0; VAR_28 < VAR_3; VAR_28++) {", "__asm__ volatile (\n\"movq %0, %%mm4 \\n\\t\"\n\"movq %1, %%mm5 \\n\\t\"\n\"paddw %2, %%mm4 \\n\\t\"\n\"paddw %3, %%mm5 \\n\\t\"\n\"movq %%mm4, %0 \\n\\t\"\n\"movq %%mm5, %1 \\n\\t\"\n\"psrlw $12, %%mm4 \\n\\t\"\n\"psrlw $12, %%mm5 \\n\\t\"\n: \"+m\" (*dx4), \"+m\" (*dy4)\n: \"m\" (*VAR_24), \"m\" (*VAR_25));", "__asm__ volatile (\n\"movq %%mm6, %%mm2 \\n\\t\"\n\"movq %%mm6, %%mm1 \\n\\t\"\n\"psubw %%mm4, %%mm2 \\n\\t\"\n\"psubw %%mm5, %%mm1 \\n\\t\"\n\"movq %%mm2, %%mm0 \\n\\t\"\n\"movq %%mm4, %%mm3 \\n\\t\"\n\"pmullw %%mm1, %%mm0 \\n\\t\"\n\"pmullw %%mm5, %%mm3 \\n\\t\"\n\"pmullw %%mm5, %%mm2 \\n\\t\"\n\"pmullw %%mm4, %%mm1 \\n\\t\"\n\"movd %4, %%mm5 \\n\\t\"\n\"movd %3, %%mm4 \\n\\t\"\n\"punpcklbw %%mm7, %%mm5 \\n\\t\"\n\"punpcklbw %%mm7, %%mm4 \\n\\t\"\n\"pmullw %%mm5, %%mm3 \\n\\t\"\n\"pmullw %%mm4, %%mm2 \\n\\t\"\n\"movd %2, %%mm5 \\n\\t\"\n\"movd %1, %%mm4 \\n\\t\"\n\"punpcklbw %%mm7, %%mm5 \\n\\t\"\n\"punpcklbw %%mm7, %%mm4 \\n\\t\"\n\"pmullw %%mm5, %%mm1 \\n\\t\"\n\"pmullw %%mm4, %%mm0 \\n\\t\"\n\"paddw %5, %%mm1 \\n\\t\"\n\"paddw %%mm3, %%mm2 \\n\\t\"\n\"paddw %%mm1, %%mm0 \\n\\t\"\n\"paddw %%mm2, %%mm0 \\n\\t\"\n\"psrlw %6, %%mm0 \\n\\t\"\n\"packuswb %%mm0, %%mm0 \\n\\t\"\n\"movd %%mm0, %0 \\n\\t\"\n: \"=m\" (VAR_0[VAR_27 + VAR_28 * VAR_2])\n: \"m\" (VAR_1[0]), \"m\" (VAR_1[1]),\n\"m\" (VAR_1[VAR_2]), \"m\" (VAR_1[VAR_2 + 1]),\n\"m\" (*VAR_23), \"m\" (VAR_26));", "VAR_1 += VAR_2;", "}", "VAR_1 += 4 - VAR_3 * VAR_2;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39, 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 61, 63, 65, 69, 71 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97, 99, 101, 103, 105, 107 ], [ 111 ], [ 113 ], [ 115, 117, 119 ], [ 121 ], [ 123, 125, 127 ], [ 131 ], [ 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153 ], [ 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 181, 183, 185, 187, 189, 191, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 217, 219, 221, 225, 227, 229, 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ] ]

[ "static int FUNC_0(AACContext *VAR_0, enum BandType VAR_1[120],\nint VAR_2[120], GetBitContext *VAR_3,\nIndividualChannelStream *VAR_4)\n{", "int VAR_5, VAR_6 = 0;", "const int VAR_7 = (VAR_4->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;", "for (VAR_5 = 0; VAR_5 < VAR_4->num_window_groups; VAR_5++) {", "int k = 0;", "while (k < VAR_4->max_sfb) {", "uint8_t sect_end = k;", "int sect_len_incr;", "int sect_band_type = get_bits(VAR_3, 4);", "if (sect_band_type == 12) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"invalid band type\\n\");", "return -1;", "}", "do {", "sect_len_incr = get_bits(VAR_3, VAR_7);", "sect_end += sect_len_incr;", "if (get_bits_left(VAR_3) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, overread_err);", "return -1;", "}", "if (sect_end > VAR_4->max_sfb) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Number of bands (%d) exceeds limit (%d).\\n\",\nsect_end, VAR_4->max_sfb);", "return -1;", "}", "} while (sect_len_incr == (1 << VAR_7) - 1);", "for (; k < sect_end; k++) {", "VAR_1 [VAR_6] = sect_band_type;", "VAR_2[VAR_6++] = sect_end;", "}", "}", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ] ]

[ "target_ulong FUNC_0(CPUMIPSState *env, target_ulong arg1,\ntarget_ulong arg2, int mem_idx)\n{", "uint64_t tmp;", "tmp = do_lbu(env, arg2, mem_idx);", "arg1 = (arg1 & 0xFFFFFFFFFFFFFF00ULL) | tmp;", "if (GET_LMASK64(arg2) >= 1) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -1), mem_idx);", "arg1 = (arg1 & 0xFFFFFFFFFFFF00FFULL) | (tmp << 8);", "}", "if (GET_LMASK64(arg2) >= 2) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -2), mem_idx);", "arg1 = (arg1 & 0xFFFFFFFFFF00FFFFULL) | (tmp << 16);", "}", "if (GET_LMASK64(arg2) >= 3) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -3), mem_idx);", "arg1 = (arg1 & 0xFFFFFFFF00FFFFFFULL) | (tmp << 24);", "}", "if (GET_LMASK64(arg2) >= 4) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -4), mem_idx);", "arg1 = (arg1 & 0xFFFFFF00FFFFFFFFULL) | (tmp << 32);", "}", "if (GET_LMASK64(arg2) >= 5) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -5), mem_idx);", "arg1 = (arg1 & 0xFFFF00FFFFFFFFFFULL) | (tmp << 40);", "}", "if (GET_LMASK64(arg2) >= 6) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -6), mem_idx);", "arg1 = (arg1 & 0xFF00FFFFFFFFFFFFULL) | (tmp << 48);", "}", "if (GET_LMASK64(arg2) == 7) {", "tmp = do_lbu(env, GET_OFFSET(arg2, -7), mem_idx);", "arg1 = (arg1 & 0x00FFFFFFFFFFFFFFULL) | (tmp << 56);", "}", "return arg1;", "}" ]

[ 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ] ]

[ "int FUNC_0(HEVCContext *VAR_0)\n{", "const AVPixFmtDescriptor *VAR_1;", "GetBitContext *gb = &VAR_0->HEVClc->gb;", "int VAR_2 = 0;", "unsigned int VAR_3 = 0;", "int VAR_4;", "int VAR_5, VAR_6, VAR_7, VAR_8;", "int VAR_9;", "HEVCSPS *sps;", "AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));", "if (!sps_buf)\nreturn AVERROR(ENOMEM);", "sps = (HEVCSPS*)sps_buf->data;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"Decoding SPS\\n\");", "sps->vps_id = get_bits(gb, 4);", "if (sps->vps_id >= MAX_VPS_COUNT) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VPS id out of range: %d\\n\", sps->vps_id);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "if (!VAR_0->vps_list[sps->vps_id]) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VPS %d does not exist\\n\",\nsps->vps_id);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "sps->max_sub_layers = get_bits(gb, 3) + 1;", "if (sps->max_sub_layers > MAX_SUB_LAYERS) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"sps_max_sub_layers out of range: %d\\n\",\nsps->max_sub_layers);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "skip_bits1(gb);", "if (parse_ptl(VAR_0, &sps->ptl, sps->max_sub_layers) < 0)\ngoto err;", "VAR_3 = get_ue_golomb_long(gb);", "if (VAR_3 >= MAX_SPS_COUNT) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"SPS id out of range: %d\\n\", VAR_3);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "sps->chroma_format_idc = get_ue_golomb_long(gb);", "if (sps->chroma_format_idc == 3)\nsps->separate_colour_plane_flag = get_bits1(gb);", "if (sps->separate_colour_plane_flag)\nsps->chroma_format_idc = 0;", "sps->width = get_ue_golomb_long(gb);", "sps->height = get_ue_golomb_long(gb);", "if ((VAR_2 = av_image_check_size(sps->width,\nsps->height, 0, VAR_0->avctx)) < 0)\ngoto err;", "if (get_bits1(gb)) {", "sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * 2;", "sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * 2;", "sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * 2;", "sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * 2;", "if (VAR_0->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {", "av_log(VAR_0->avctx, AV_LOG_DEBUG,\n\"discarding sps conformance window, \"\n\"original values are l:%u r:%u t:%u b:%u\\n\",\nsps->pic_conf_win.left_offset,\nsps->pic_conf_win.right_offset,\nsps->pic_conf_win.top_offset,\nsps->pic_conf_win.bottom_offset);", "sps->pic_conf_win.left_offset =\nsps->pic_conf_win.right_offset =\nsps->pic_conf_win.top_offset =\nsps->pic_conf_win.bottom_offset = 0;", "}", "sps->output_window = sps->pic_conf_win;", "}", "sps->bit_depth = get_ue_golomb_long(gb) + 8;", "VAR_5 = get_ue_golomb_long(gb) + 8;", "if (sps->chroma_format_idc && VAR_5 != sps->bit_depth) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Luma bit depth (%d) is different from chroma bit depth (%d), \"\n\"this is unsupported.\\n\",\nsps->bit_depth, VAR_5);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "switch (sps->bit_depth) {", "case 8:\nif (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;", "if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;", "if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;", "if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;", "break;", "case 9:\nif (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;", "if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;", "if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;", "if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;", "break;", "case 10:\nif (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;", "if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;", "if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;", "if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;", "break;", "case 12:\nif (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;", "if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;", "if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;", "if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR,\n\"4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\\n\");", "VAR_2 = AVERROR_PATCHWELCOME;", "goto err;", "}", "VAR_1 = av_pix_fmt_desc_get(sps->pix_fmt);", "if (!VAR_1) {", "VAR_2 = AVERROR(EINVAL);", "goto err;", "}", "sps->hshift[0] = sps->vshift[0] = 0;", "sps->hshift[2] = sps->hshift[1] = VAR_1->log2_chroma_w;", "sps->vshift[2] = sps->vshift[1] = VAR_1->log2_chroma_h;", "sps->pixel_shift = sps->bit_depth > 8;", "sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;", "if (sps->log2_max_poc_lsb > 16) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"log2_max_pic_order_cnt_lsb_minus4 out range: %d\\n\",\nsps->log2_max_poc_lsb - 4);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "VAR_8 = get_bits1(gb);", "VAR_6 = VAR_8 ? 0 : sps->max_sub_layers - 1;", "for (VAR_9 = VAR_6; VAR_9 < sps->max_sub_layers; VAR_9++) {", "sps->temporal_layer[VAR_9].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;", "sps->temporal_layer[VAR_9].num_reorder_pics = get_ue_golomb_long(gb);", "sps->temporal_layer[VAR_9].max_latency_increase = get_ue_golomb_long(gb) - 1;", "if (sps->temporal_layer[VAR_9].max_dec_pic_buffering > MAX_DPB_SIZE) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"sps_max_dec_pic_buffering_minus1 out of range: %d\\n\",\nsps->temporal_layer[VAR_9].max_dec_pic_buffering - 1);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "if (sps->temporal_layer[VAR_9].num_reorder_pics > sps->temporal_layer[VAR_9].max_dec_pic_buffering - 1) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"sps_max_num_reorder_pics out of range: %d\\n\",\nsps->temporal_layer[VAR_9].num_reorder_pics);", "if (VAR_0->avctx->err_recognition & AV_EF_EXPLODE ||\nsps->temporal_layer[VAR_9].num_reorder_pics > MAX_DPB_SIZE - 1) {", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "sps->temporal_layer[VAR_9].max_dec_pic_buffering = sps->temporal_layer[VAR_9].num_reorder_pics + 1;", "}", "}", "if (!VAR_8) {", "for (VAR_9 = 0; VAR_9 < VAR_6; VAR_9++) {", "sps->temporal_layer[VAR_9].max_dec_pic_buffering = sps->temporal_layer[VAR_6].max_dec_pic_buffering;", "sps->temporal_layer[VAR_9].num_reorder_pics = sps->temporal_layer[VAR_6].num_reorder_pics;", "sps->temporal_layer[VAR_9].max_latency_increase = sps->temporal_layer[VAR_6].max_latency_increase;", "}", "}", "sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;", "sps->log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb);", "sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;", "VAR_4 = get_ue_golomb_long(gb);", "sps->log2_max_trafo_size = VAR_4 +\nsps->log2_min_tb_size;", "if (sps->log2_min_tb_size >= sps->log2_min_cb_size) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid value for log2_min_tb_size\");", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);", "sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);", "sps->scaling_list_enable_flag = get_bits1(gb);", "if (sps->scaling_list_enable_flag) {", "set_default_scaling_list_data(&sps->scaling_list);", "if (get_bits1(gb)) {", "VAR_2 = scaling_list_data(VAR_0, &sps->scaling_list, sps);", "if (VAR_2 < 0)\ngoto err;", "}", "}", "sps->amp_enabled_flag = get_bits1(gb);", "sps->sao_enabled = get_bits1(gb);", "sps->pcm_enabled_flag = get_bits1(gb);", "if (sps->pcm_enabled_flag) {", "sps->pcm.bit_depth = get_bits(gb, 4) + 1;", "sps->pcm.VAR_5 = get_bits(gb, 4) + 1;", "sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;", "sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +\nget_ue_golomb_long(gb);", "if (sps->pcm.bit_depth > sps->bit_depth) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"PCM bit depth (%d) is greater than normal bit depth (%d)\\n\",\nsps->pcm.bit_depth, sps->bit_depth);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "sps->pcm.loop_filter_disable_flag = get_bits1(gb);", "}", "sps->nb_st_rps = get_ue_golomb_long(gb);", "if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Too many short term RPS: %d.\\n\",\nsps->nb_st_rps);", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "for (VAR_9 = 0; VAR_9 < sps->nb_st_rps; VAR_9++) {", "if ((VAR_2 = ff_hevc_decode_short_term_rps(VAR_0, &sps->st_rps[VAR_9],\nsps, 0)) < 0)\ngoto err;", "}", "sps->long_term_ref_pics_present_flag = get_bits1(gb);", "if (sps->long_term_ref_pics_present_flag) {", "sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb);", "if (sps->num_long_term_ref_pics_sps > 31U) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"num_long_term_ref_pics_sps %d is out of range.\\n\",\nsps->num_long_term_ref_pics_sps);", "goto err;", "}", "for (VAR_9 = 0; VAR_9 < sps->num_long_term_ref_pics_sps; VAR_9++) {", "sps->lt_ref_pic_poc_lsb_sps[VAR_9] = get_bits(gb, sps->log2_max_poc_lsb);", "sps->used_by_curr_pic_lt_sps_flag[VAR_9] = get_bits1(gb);", "}", "}", "sps->sps_temporal_mvp_enabled_flag = get_bits1(gb);", "sps->sps_strong_intra_smoothing_enable_flag = get_bits1(gb);", "sps->vui.sar = (AVRational){0, 1};", "VAR_7 = get_bits1(gb);", "if (VAR_7)\ndecode_vui(VAR_0, sps);", "if (get_bits1(gb)) {", "int VAR_10[1];", "for (VAR_9 = 0; VAR_9 < 1; VAR_9++)", "VAR_10[VAR_9] = get_bits1(gb);", "skip_bits(gb, 7);", "if (VAR_10[0]) {", "int VAR_11;", "int VAR_12;", "int VAR_13;", "sps->transform_skip_rotation_enabled_flag = get_bits1(gb);", "sps->transform_skip_context_enabled_flag = get_bits1(gb);", "sps->implicit_rdpcm_enabled_flag = get_bits1(gb);", "sps->explicit_rdpcm_enabled_flag = get_bits1(gb);", "VAR_11 = get_bits1(gb);", "if (VAR_11)\nav_log(VAR_0->avctx, AV_LOG_WARNING,\n\"VAR_11 not yet implemented\\n\");", "sps->intra_smoothing_disabled_flag = get_bits1(gb);", "VAR_12 = get_bits1(gb);", "if (VAR_12)\nav_log(VAR_0->avctx, AV_LOG_WARNING,\n\"VAR_12 not yet implemented\\n\");", "sps->persistent_rice_adaptation_enabled_flag = get_bits1(gb);", "VAR_13 = get_bits1(gb);", "if (VAR_13)\nav_log(VAR_0->avctx, AV_LOG_WARNING,\n\"VAR_13 not yet implemented\\n\");", "}", "}", "if (VAR_0->apply_defdispwin) {", "sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;", "sps->output_window.right_offset += sps->vui.def_disp_win.right_offset;", "sps->output_window.top_offset += sps->vui.def_disp_win.top_offset;", "sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;", "}", "if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&\n!(VAR_0->avctx->flags & CODEC_FLAG_UNALIGNED)) {", "sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Reducing left output window to %d \"\n\"chroma samples to preserve alignment.\\n\",\nsps->output_window.left_offset);", "}", "sps->output_width = sps->width -\n(sps->output_window.left_offset + sps->output_window.right_offset);", "sps->output_height = sps->height -\n(sps->output_window.top_offset + sps->output_window.bottom_offset);", "if (sps->output_width <= 0 || sps->output_height <= 0) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Invalid visible frame dimensions: %dx%d.\\n\",\nsps->output_width, sps->output_height);", "if (VAR_0->avctx->err_recognition & AV_EF_EXPLODE) {", "VAR_2 = AVERROR_INVALIDDATA;", "goto err;", "}", "av_log(VAR_0->avctx, AV_LOG_WARNING,\n\"Displaying the whole video surface.\\n\");", "memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));", "memset(&sps->output_window, 0, sizeof(sps->output_window));", "sps->output_width = sps->width;", "sps->output_height = sps->height;", "}", "sps->log2_ctb_size = sps->log2_min_cb_size +\nsps->log2_diff_max_min_coding_block_size;", "sps->log2_min_pu_size = sps->log2_min_cb_size - 1;", "sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;", "sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;", "sps->ctb_size = sps->ctb_width * sps->ctb_height;", "sps->min_cb_width = sps->width >> sps->log2_min_cb_size;", "sps->min_cb_height = sps->height >> sps->log2_min_cb_size;", "sps->min_tb_width = sps->width >> sps->log2_min_tb_size;", "sps->min_tb_height = sps->height >> sps->log2_min_tb_size;", "sps->min_pu_width = sps->width >> sps->log2_min_pu_size;", "sps->min_pu_height = sps->height >> sps->log2_min_pu_size;", "sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;", "sps->qp_bd_offset = 6 * (sps->bit_depth - 8);", "if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||\nsps->height & ((1 << sps->log2_min_cb_size) - 1)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid coded frame dimensions.\\n\");", "goto err;", "}", "if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"CTB size out of range: 2^%d\\n\", sps->log2_ctb_size);", "goto err;", "}", "if (sps->max_transform_hierarchy_depth_inter > sps->log2_ctb_size - sps->log2_min_tb_size) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"max_transform_hierarchy_depth_inter out of range: %d\\n\",\nsps->max_transform_hierarchy_depth_inter);", "goto err;", "}", "if (sps->max_transform_hierarchy_depth_intra > sps->log2_ctb_size - sps->log2_min_tb_size) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"max_transform_hierarchy_depth_intra out of range: %d\\n\",\nsps->max_transform_hierarchy_depth_intra);", "goto err;", "}", "if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"max transform block size out of range: %d\\n\",\nsps->log2_max_trafo_size);", "goto err;", "}", "if (get_bits_left(gb) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Overread SPS by %d bits\\n\", -get_bits_left(gb));", "goto err;", "}", "if (VAR_0->avctx->debug & FF_DEBUG_BITSTREAM) {", "av_log(VAR_0->avctx, AV_LOG_DEBUG,\n\"Parsed SPS: id %d; coded wxh: %dx%d; \"", "\"cropped wxh: %dx%d; pix_fmt: %VAR_0.\\n\",", "VAR_3, sps->width, sps->height,\nsps->output_width, sps->output_height,\nav_get_pix_fmt_name(sps->pix_fmt));", "}", "if (VAR_0->sps_list[VAR_3] &&\n!memcmp(VAR_0->sps_list[VAR_3]->data, sps_buf->data, sps_buf->size)) {", "av_buffer_unref(&sps_buf);", "} else {", "for (VAR_9 = 0; VAR_9 < FF_ARRAY_ELEMS(VAR_0->pps_list); VAR_9++) {", "if (VAR_0->pps_list[VAR_9] && ((HEVCPPS*)VAR_0->pps_list[VAR_9]->data)->VAR_3 == VAR_3)\nav_buffer_unref(&VAR_0->pps_list[VAR_9]);", "}", "if (VAR_0->sps_list[VAR_3] && VAR_0->sps == (HEVCSPS*)VAR_0->sps_list[VAR_3]->data) {", "av_buffer_unref(&VAR_0->current_sps);", "VAR_0->current_sps = av_buffer_ref(VAR_0->sps_list[VAR_3]);", "if (!VAR_0->current_sps)\nVAR_0->sps = NULL;", "}", "av_buffer_unref(&VAR_0->sps_list[VAR_3]);", "VAR_0->sps_list[VAR_3] = sps_buf;", "}", "return 0;", "err:\nav_buffer_unref(&sps_buf);", "return VAR_2;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 31 ], [ 35 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 91, 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 115, 117 ], [ 121, 123 ], [ 127 ], [ 129 ], [ 131, 133, 135 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155, 157, 159, 161, 163, 165, 167 ], [ 171, 173, 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 193, 195, 197, 199 ], [ 201 ], [ 203 ], [ 205 ], [ 209 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223, 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247, 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259, 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 285 ], [ 287 ], [ 289 ], [ 293 ], [ 297 ], [ 299 ], [ 301, 303 ], [ 305 ], [ 307 ], [ 309 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327, 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339, 341 ], [ 343, 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385, 387 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 407 ], [ 409 ], [ 411 ], [ 415 ], [ 417 ], [ 419, 421 ], [ 423 ], [ 425 ], [ 429 ], [ 431 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445, 447 ], [ 449 ], [ 451, 453, 455 ], [ 457 ], [ 459 ], [ 461 ], [ 465 ], [ 467 ], [ 471 ], [ 473 ], [ 475, 477 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487, 489, 491 ], [ 493 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505, 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 533, 535 ], [ 539 ], [ 541 ], [ 543 ], [ 545 ], [ 547 ], [ 549 ], [ 551 ], [ 553 ], [ 555 ], [ 559 ], [ 561 ], [ 563 ], [ 567 ], [ 571 ], [ 573, 575, 577 ], [ 581 ], [ 583 ], [ 585, 587, 589 ], [ 593 ], [ 597 ], [ 599, 601, 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 613 ], [ 615 ], [ 617 ], [ 619 ], [ 621, 623 ], [ 625 ], [ 627, 629, 631 ], [ 633 ], [ 635, 637 ], [ 639, 641 ], [ 643 ], [ 645, 647 ], [ 649 ], [ 651 ], [ 653 ], [ 655 ], [ 657, 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667 ], [ 669 ], [ 675, 677 ], [ 679 ], [ 683 ], [ 685 ], [ 687 ], [ 691 ], [ 693 ], [ 695 ], [ 697 ], [ 699 ], [ 701 ], [ 703 ], [ 707 ], [ 711, 713 ], [ 715 ], [ 717 ], [ 719 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733, 735 ], [ 737 ], [ 739 ], [ 741 ], [ 743, 745 ], [ 747 ], [ 749 ], [ 751 ], [ 753, 755, 757 ], [ 759 ], [ 761 ], [ 765 ], [ 767, 769 ], [ 771 ], [ 773 ], [ 777 ], [ 779, 781 ], [ 783 ], [ 785, 787, 789 ], [ 791 ], [ 801, 803 ], [ 805 ], [ 807 ], [ 809 ], [ 811, 813 ], [ 815 ], [ 817 ], [ 819 ], [ 821 ], [ 823, 825 ], [ 827 ], [ 829 ], [ 831 ], [ 833 ], [ 837 ], [ 841, 843 ], [ 845 ], [ 847 ] ]

[ "static BlockDriverAIOCB *FUNC_0(BlockDriverState *bs,\nint64_t sector_num,\nQEMUIOVector *qiov,\nint nb_sectors,\nBlockDriverCompletionFunc *cb,\nvoid *opaque)\n{", "BDRVQuorumState *s = bs->opaque;", "QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num,\nnb_sectors, cb, opaque);", "int VAR_0;", "acb->is_read = true;", "for (VAR_0 = 0; VAR_0 < s->num_children; VAR_0++) {", "acb->qcrs[VAR_0].buf = qemu_blockalign(s->bs[VAR_0], qiov->size);", "qemu_iovec_init(&acb->qcrs[VAR_0].qiov, qiov->niov);", "qemu_iovec_clone(&acb->qcrs[VAR_0].qiov, qiov, acb->qcrs[VAR_0].buf);", "}", "for (VAR_0 = 0; VAR_0 < s->num_children; VAR_0++) {", "bdrv_aio_readv(s->bs[VAR_0], sector_num, &acb->qcrs[VAR_0].qiov, nb_sectors,\nquorum_aio_cb, &acb->qcrs[VAR_0]);", "}", "return &acb->common;", "}" ]

[ 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9, 11, 13 ], [ 15 ], [ 17, 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 51 ], [ 53 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "TgvContext *s = VAR_0->priv_data;", "const uint8_t *VAR_6 = VAR_4 + VAR_5;", "AVFrame *frame = VAR_1;", "int VAR_7, VAR_8;", "if (VAR_6 - VAR_4 < EA_PREAMBLE_SIZE)\nreturn AVERROR_INVALIDDATA;", "VAR_7 = AV_RL32(&VAR_4[0]);", "VAR_4 += EA_PREAMBLE_SIZE;", "if (VAR_7 == kVGT_TAG) {", "int VAR_9, VAR_10;", "if(VAR_6 - VAR_4 < 12) {", "av_log(VAR_0, AV_LOG_WARNING, \"truncated header\\n\");", "return AVERROR_INVALIDDATA;", "}", "s->width = AV_RL16(&VAR_4[0]);", "s->height = AV_RL16(&VAR_4[2]);", "if (s->VAR_0->width != s->width || s->VAR_0->height != s->height) {", "av_freep(&s->frame_buffer);", "av_frame_unref(s->last_frame);", "if ((VAR_8 = ff_set_dimensions(s->VAR_0, s->width, s->height)) < 0)\nreturn VAR_8;", "}", "VAR_9 = AV_RL16(&VAR_4[6]);", "VAR_4 += 12;", "for(VAR_10 = 0; VAR_10 < VAR_9 && VAR_10 < AVPALETTE_COUNT && VAR_6 - VAR_4 >= 3; VAR_10++) {", "s->palette[VAR_10] = 0xFFU << 24 | AV_RB24(VAR_4);", "VAR_4 += 3;", "}", "}", "if ((VAR_8 = ff_get_buffer(VAR_0, frame, AV_GET_BUFFER_FLAG_REF)) < 0)\nreturn VAR_8;", "memcpy(frame->VAR_1[1], s->palette, AVPALETTE_SIZE);", "if (VAR_7 == kVGT_TAG) {", "int VAR_11;", "frame->key_frame = 1;", "frame->pict_type = AV_PICTURE_TYPE_I;", "if (!s->frame_buffer &&\n!(s->frame_buffer = av_malloc(s->width * s->height)))\nreturn AVERROR(ENOMEM);", "if (unpack(VAR_4, VAR_6, s->frame_buffer, s->VAR_0->width, s->VAR_0->height) < 0) {", "av_log(VAR_0, AV_LOG_WARNING, \"truncated intra frame\\n\");", "return AVERROR_INVALIDDATA;", "}", "for (VAR_11 = 0; VAR_11 < s->height; VAR_11++)", "memcpy(frame->VAR_1[0] + VAR_11 * frame->linesize[0],\ns->frame_buffer + VAR_11 * s->width,\ns->width);", "} else {", "if (!s->last_frame->VAR_1[0]) {", "av_log(VAR_0, AV_LOG_WARNING, \"inter frame without corresponding intra frame\\n\");", "return VAR_5;", "}", "frame->key_frame = 0;", "frame->pict_type = AV_PICTURE_TYPE_P;", "if (tgv_decode_inter(s, frame, VAR_4, VAR_6) < 0) {", "av_log(VAR_0, AV_LOG_WARNING, \"truncated inter frame\\n\");", "return AVERROR_INVALIDDATA;", "}", "}", "av_frame_unref(s->last_frame);", "if ((VAR_8 = av_frame_ref(s->last_frame, frame)) < 0)\nreturn VAR_8;", "*VAR_2 = 1;", "return VAR_5;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83, 85 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103, 105, 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155, 157 ], [ 161 ], [ 165 ], [ 167 ] ]

[ "void FUNC_0(ove)(CPUOpenRISCState *env, target_ulong test)\n{", "if (unlikely(test)) {", "OpenRISCCPU *cpu = openrisc_env_get_cpu(env);", "CPUState *cs = CPU(cpu);", "cs->exception_index = EXCP_RANGE;", "cpu_loop_exit_restore(cs, GETPC());", "}", "}" ]

[ 1, 1, 1, 1, 1, 1, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ] ]

[ "void FUNC_0(const char *VAR_0)\n{", "struct in_addr VAR_1 = { .s_addr = 0 };", "if (legacy_smb_export) {", "fprintf(stderr, \"-smb given twice\\n\");", "exit(1);", "}", "legacy_smb_export = VAR_0;", "if (!QTAILQ_EMPTY(&slirp_stacks)) {", "slirp_smb(QTAILQ_FIRST(&slirp_stacks), NULL, VAR_0,\nVAR_1);", "}", "}" ]

[ 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "BDRVCloopState *s = VAR_0->opaque;", "uint32_t offsets_size, max_compressed_block_size = 1, i;", "int VAR_4;", "VAR_0->read_only = 1;", "VAR_4 = bdrv_pread(VAR_0->file, 128, &s->block_size, 4);", "if (VAR_4 < 0) {", "return VAR_4;", "s->block_size = be32_to_cpu(s->block_size);", "VAR_4 = bdrv_pread(VAR_0->file, 128 + 4, &s->n_blocks, 4);", "if (VAR_4 < 0) {", "return VAR_4;", "s->n_blocks = be32_to_cpu(s->n_blocks);", "offsets_size = s->n_blocks * sizeof(uint64_t);", "s->offsets = g_malloc(offsets_size);", "VAR_4 = bdrv_pread(VAR_0->file, 128 + 4 + 4, s->offsets, offsets_size);", "if (VAR_4 < 0) {", "goto fail;", "for(i=0;i<s->n_blocks;i++) {", "s->offsets[i] = be64_to_cpu(s->offsets[i]);", "if (i > 0) {", "uint32_t size = s->offsets[i] - s->offsets[i - 1];", "if (size > max_compressed_block_size) {", "max_compressed_block_size = size;", "s->compressed_block = g_malloc(max_compressed_block_size + 1);", "s->uncompressed_block = g_malloc(s->block_size);", "if (inflateInit(&s->zstream) != Z_OK) {", "VAR_4 = -EINVAL;", "goto fail;", "s->current_block = s->n_blocks;", "s->sectors_per_block = s->block_size/512;", "VAR_0->total_sectors = s->n_blocks * s->sectors_per_block;", "qemu_co_mutex_init(&s->lock);", "return 0;", "fail:\ng_free(s->offsets);", "g_free(s->compressed_block);", "g_free(s->uncompressed_block);", "return VAR_4;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36 ], [ 37 ], [ 38 ], [ 39 ], [ 40, 41 ], [ 42 ], [ 43 ], [ 44 ] ]

[ "void FUNC_0(CharDriverState *VAR_0, int VAR_1)\n{", "int VAR_2;", "if (is_first_init) {", "for (VAR_2 = 0; VAR_2 < MAX_MON; VAR_2++) {", "monitor_hd[VAR_2] = NULL;", "}", "is_first_init = 0;", "}", "for (VAR_2 = 0; VAR_2 < MAX_MON; VAR_2++) {", "if (monitor_hd[VAR_2] == NULL) {", "monitor_hd[VAR_2] = VAR_0;", "break;", "}", "}", "hide_banner = !VAR_1;", "qemu_chr_add_handlers(VAR_0, term_can_read, term_read, term_event, NULL);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ] ]

[ "int FUNC_0(H264Context *VAR_0, H264Context *VAR_1)\n{", "unsigned int VAR_2;", "unsigned int VAR_3;", "int VAR_4;", "unsigned int VAR_5, VAR_6, VAR_7, VAR_8;", "int VAR_9, VAR_10;", "int VAR_11;", "int VAR_12 = 0;", "int VAR_13, VAR_14;", "int VAR_15 = VAR_0 == VAR_1 && !VAR_1->current_slice;", "int VAR_16, VAR_17, VAR_18;", "PPS *pps;", "VAR_0->qpel_put = VAR_0->h264qpel.put_h264_qpel_pixels_tab;", "VAR_0->qpel_avg = VAR_0->h264qpel.avg_h264_qpel_pixels_tab;", "VAR_2 = get_ue_golomb_long(&VAR_0->gb);", "if (VAR_2 == 0) {", "if (VAR_1->current_slice && VAR_0->cur_pic_ptr && FIELD_PICTURE(VAR_0)) {", "ff_h264_field_end(VAR_0, 1);", "}", "VAR_1->current_slice = 0;", "if (!VAR_1->first_field) {", "if (VAR_0->cur_pic_ptr && !VAR_0->VAR_18) {", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,\nVAR_0->VAR_17 == PICT_BOTTOM_FIELD);", "}", "VAR_0->cur_pic_ptr = NULL;", "}", "}", "VAR_5 = get_ue_golomb_31(&VAR_0->gb);", "if (VAR_5 > 9) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"slice type %d too large at %d %d\\n\",\nVAR_5, VAR_0->mb_x, VAR_0->mb_y);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_5 > 4) {", "VAR_5 -= 5;", "VAR_0->slice_type_fixed = 1;", "} else", "VAR_0->slice_type_fixed = 0;", "VAR_5 = golomb_to_pict_type[VAR_5];", "VAR_0->VAR_5 = VAR_5;", "VAR_0->slice_type_nos = VAR_5 & 3;", "if (VAR_0->nal_unit_type == NAL_IDR_SLICE &&\nVAR_0->slice_type_nos != AV_PICTURE_TYPE_I) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"A non-intra slice in an IDR NAL unit.\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (\n(VAR_0->avctx->skip_frame >= AVDISCARD_NONREF && !VAR_0->nal_ref_idc) ||\n(VAR_0->avctx->skip_frame >= AVDISCARD_BIDIR && VAR_0->slice_type_nos == AV_PICTURE_TYPE_B) ||\n(VAR_0->avctx->skip_frame >= AVDISCARD_NONINTRA && VAR_0->slice_type_nos != AV_PICTURE_TYPE_I) ||\n(VAR_0->avctx->skip_frame >= AVDISCARD_NONKEY && VAR_0->nal_unit_type != NAL_IDR_SLICE) ||\nVAR_0->avctx->skip_frame >= AVDISCARD_ALL) {", "return SLICE_SKIPED;", "}", "VAR_0->pict_type = VAR_0->VAR_5;", "VAR_3 = get_ue_golomb(&VAR_0->gb);", "if (VAR_3 >= MAX_PPS_COUNT) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_3 %u out of range\\n\", VAR_3);", "return AVERROR_INVALIDDATA;", "}", "if (!VAR_1->pps_buffers[VAR_3]) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"non-existing PPS %u referenced\\n\",\nVAR_3);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_1->au_pps_id >= 0 && VAR_3 != VAR_1->au_pps_id) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"PPS change from %d to %d forbidden\\n\",\nVAR_1->au_pps_id, VAR_3);", "return AVERROR_INVALIDDATA;", "}", "pps = VAR_1->pps_buffers[VAR_3];", "if (!VAR_1->sps_buffers[pps->sps_id]) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"non-existing SPS %u referenced\\n\",\nVAR_0->pps.sps_id);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_15)\nVAR_0->pps = *VAR_1->pps_buffers[VAR_3];", "if (pps->sps_id != VAR_0->sps.sps_id ||\npps->sps_id != VAR_0->current_sps_id ||\nVAR_1->sps_buffers[pps->sps_id]->new) {", "if (!VAR_15) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"SPS changed in the middle of the frame\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->sps = *VAR_1->sps_buffers[VAR_0->pps.sps_id];", "if (VAR_0->mb_width != VAR_0->sps.mb_width ||\nVAR_0->mb_height != VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag) ||\nVAR_0->avctx->bits_per_raw_sample != VAR_0->sps.bit_depth_luma ||\nVAR_0->cur_chroma_format_idc != VAR_0->sps.chroma_format_idc\n)\nVAR_12 = 1;", "if (VAR_0->bit_depth_luma != VAR_0->sps.bit_depth_luma ||\nVAR_0->chroma_format_idc != VAR_0->sps.chroma_format_idc) {", "VAR_0->bit_depth_luma = VAR_0->sps.bit_depth_luma;", "VAR_0->chroma_format_idc = VAR_0->sps.chroma_format_idc;", "VAR_12 = 1;", "}", "if ((VAR_4 = ff_h264_set_parameter_from_sps(VAR_0)) < 0)\nreturn VAR_4;", "}", "VAR_0->avctx->profile = ff_h264_get_profile(&VAR_0->sps);", "VAR_0->avctx->level = VAR_0->sps.level_idc;", "VAR_0->avctx->refs = VAR_0->sps.ref_frame_count;", "VAR_11 = (VAR_0->context_initialized &&\n( 16*VAR_0->sps.mb_width != VAR_0->avctx->coded_width\n|| 16*VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag) != VAR_0->avctx->coded_height\n|| VAR_0->avctx->bits_per_raw_sample != VAR_0->sps.bit_depth_luma\n|| VAR_0->cur_chroma_format_idc != VAR_0->sps.chroma_format_idc\n|| VAR_0->mb_width != VAR_0->sps.mb_width\n|| VAR_0->mb_height != VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag)\n));", "if (non_j_pixfmt(VAR_1->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(VAR_1, 0)))\nVAR_11 = 1;", "if (VAR_15 && av_cmp_q(VAR_0->sps.sar, VAR_0->avctx->sample_aspect_ratio))\nVAR_11 = 1;", "VAR_0->mb_width = VAR_0->sps.mb_width;", "VAR_0->mb_height = VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag);", "VAR_0->mb_num = VAR_0->mb_width * VAR_0->mb_height;", "VAR_0->mb_stride = VAR_0->mb_width + 1;", "VAR_0->b_stride = VAR_0->mb_width * 4;", "VAR_0->chroma_y_shift = VAR_0->sps.chroma_format_idc <= 1;", "VAR_0->width = 16 * VAR_0->mb_width;", "VAR_0->height = 16 * VAR_0->mb_height;", "VAR_4 = init_dimensions(VAR_0);", "if (VAR_4 < 0)\nreturn VAR_4;", "if (VAR_0->sps.video_signal_type_present_flag) {", "VAR_0->avctx->color_range = VAR_0->sps.full_range>0 ? AVCOL_RANGE_JPEG\n: AVCOL_RANGE_MPEG;", "if (VAR_0->sps.colour_description_present_flag) {", "if (VAR_0->avctx->colorspace != VAR_0->sps.colorspace)\nVAR_12 = 1;", "VAR_0->avctx->color_primaries = VAR_0->sps.color_primaries;", "VAR_0->avctx->color_trc = VAR_0->sps.color_trc;", "VAR_0->avctx->colorspace = VAR_0->sps.colorspace;", "}", "}", "if (VAR_0->context_initialized &&\n(VAR_11 || VAR_12)) {", "if (VAR_0 != VAR_1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"changing width %d -> %d / height %d -> %d on \"\n\"slice %d\\n\",\nVAR_0->width, VAR_0->avctx->coded_width,\nVAR_0->height, VAR_0->avctx->coded_height,\nVAR_1->current_slice + 1);", "return AVERROR_INVALIDDATA;", "}", "av_assert1(VAR_15);", "ff_h264_flush_change(VAR_0);", "if ((VAR_4 = get_pixel_format(VAR_0, 1)) < 0)\nreturn VAR_4;", "VAR_0->avctx->pix_fmt = VAR_4;", "av_log(VAR_0->avctx, AV_LOG_INFO, \"Reinit context to %dx%d, \"\n\"pix_fmt: %s\\n\", VAR_0->width, VAR_0->height, av_get_pix_fmt_name(VAR_0->avctx->pix_fmt));", "if ((VAR_4 = h264_slice_header_init(VAR_0, 1)) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"h264_slice_header_init() failed\\n\");", "return VAR_4;", "}", "}", "if (!VAR_0->context_initialized) {", "if (VAR_0 != VAR_1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Cannot (re-)initialize context during parallel decoding.\\n\");", "return AVERROR_PATCHWELCOME;", "}", "if ((VAR_4 = get_pixel_format(VAR_0, 1)) < 0)\nreturn VAR_4;", "VAR_0->avctx->pix_fmt = VAR_4;", "if ((VAR_4 = h264_slice_header_init(VAR_0, 0)) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"h264_slice_header_init() failed\\n\");", "return VAR_4;", "}", "}", "if (VAR_0 == VAR_1 && VAR_0->dequant_coeff_pps != VAR_3) {", "VAR_0->dequant_coeff_pps = VAR_3;", "h264_init_dequant_tables(VAR_0);", "}", "VAR_16 = get_bits(&VAR_0->gb, VAR_0->sps.log2_max_frame_num);", "if (!VAR_15) {", "if (VAR_1->VAR_16 != VAR_16) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Frame num change from %d to %d\\n\",\nVAR_1->VAR_16, VAR_16);", "return AVERROR_INVALIDDATA;", "}", "}", "VAR_0->mb_mbaff = 0;", "VAR_0->mb_aff_frame = 0;", "VAR_9 = VAR_1->VAR_17;", "VAR_10 = VAR_1->VAR_18;", "VAR_18 = VAR_0->nal_ref_idc == 0;", "if (VAR_0->sps.frame_mbs_only_flag) {", "VAR_17 = PICT_FRAME;", "} else {", "if (!VAR_0->sps.direct_8x8_inference_flag && VAR_5 == AV_PICTURE_TYPE_B) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"This stream was generated by a broken encoder, invalid 8x8 inference\\n\");", "return -1;", "}", "VAR_13 = get_bits1(&VAR_0->gb);", "if (VAR_13) {", "VAR_14 = get_bits1(&VAR_0->gb);", "VAR_17 = PICT_TOP_FIELD + VAR_14;", "} else {", "VAR_17 = PICT_FRAME;", "VAR_0->mb_aff_frame = VAR_0->sps.mb_aff;", "}", "}", "if (VAR_1->current_slice) {", "if (VAR_9 != VAR_17 ||\nVAR_10 != VAR_18) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Changing field mode (%d -> %d) between slices is not allowed\\n\",\nVAR_9, VAR_0->VAR_17);", "return AVERROR_INVALIDDATA;", "} else if (!VAR_1->cur_pic_ptr) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"unset cur_pic_ptr on slice %d\\n\",\nVAR_1->current_slice + 1);", "return AVERROR_INVALIDDATA;", "}", "}", "VAR_0->VAR_17 = VAR_17;", "VAR_0->VAR_18 = VAR_18;", "VAR_0->VAR_16 = VAR_16;", "VAR_0->mb_field_decoding_flag = VAR_17 != PICT_FRAME;", "if (VAR_1->current_slice == 0) {", "if (VAR_0->VAR_16 != VAR_0->prev_frame_num) {", "int VAR_19 = VAR_0->prev_frame_num;", "int VAR_20 = 1 << VAR_0->sps.log2_max_frame_num;", "if (VAR_19 > VAR_0->VAR_16)\nVAR_19 -= VAR_20;", "if ((VAR_0->VAR_16 - VAR_19) > VAR_0->sps.ref_frame_count) {", "VAR_19 = (VAR_0->VAR_16 - VAR_0->sps.ref_frame_count) - 1;", "if (VAR_19 < 0)\nVAR_19 += VAR_20;", "VAR_0->prev_frame_num = VAR_19;", "}", "}", "if (VAR_1->first_field) {", "assert(VAR_1->cur_pic_ptr);", "assert(VAR_1->cur_pic_ptr->f.buf[0]);", "assert(VAR_1->cur_pic_ptr->reference != DELAYED_PIC_REF);", "if (VAR_1->cur_pic_ptr->tf.owner == VAR_1->avctx) {", "ff_thread_report_progress(&VAR_1->cur_pic_ptr->tf, INT_MAX,\nVAR_9 == PICT_BOTTOM_FIELD);", "}", "if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_9) {", "if (VAR_9 != PICT_FRAME) {", "ff_thread_report_progress(&VAR_1->cur_pic_ptr->tf, INT_MAX,\nVAR_9 == PICT_TOP_FIELD);", "}", "} else {", "if (VAR_1->cur_pic_ptr->VAR_16 != VAR_0->VAR_16) {", "if (VAR_9 != PICT_FRAME) {", "ff_thread_report_progress(&VAR_1->cur_pic_ptr->tf, INT_MAX,\nVAR_9 == PICT_TOP_FIELD);", "}", "} else {", "if (!((VAR_9 == PICT_TOP_FIELD &&\nVAR_0->VAR_17 == PICT_BOTTOM_FIELD) ||\n(VAR_9 == PICT_BOTTOM_FIELD &&\nVAR_0->VAR_17 == PICT_TOP_FIELD))) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Invalid field mode combination %d/%d\\n\",\nVAR_9, VAR_0->VAR_17);", "VAR_0->VAR_17 = VAR_9;", "VAR_0->VAR_18 = VAR_10;", "return AVERROR_INVALIDDATA;", "} else if (VAR_10 != VAR_0->VAR_18) {", "avpriv_request_sample(VAR_0->avctx,\n\"Found reference and non-reference fields in the same frame, which\");", "VAR_0->VAR_17 = VAR_9;", "VAR_0->VAR_18 = VAR_10;", "return AVERROR_PATCHWELCOME;", "}", "}", "}", "}", "while (VAR_0->VAR_16 != VAR_0->prev_frame_num && !VAR_1->first_field &&\nVAR_0->VAR_16 != (VAR_0->prev_frame_num + 1) % (1 << VAR_0->sps.log2_max_frame_num)) {", "H264Picture *prev = VAR_0->short_ref_count ? VAR_0->short_ref[0] : NULL;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"Frame num gap %d %d\\n\",\nVAR_0->VAR_16, VAR_0->prev_frame_num);", "if (!VAR_0->sps.gaps_in_frame_num_allowed_flag)\nfor(VAR_7=0; VAR_7<FF_ARRAY_ELEMS(VAR_0->last_pocs); VAR_7++)", "VAR_0->last_pocs[VAR_7] = INT_MIN;", "VAR_4 = h264_frame_start(VAR_0);", "if (VAR_4 < 0) {", "VAR_1->first_field = 0;", "return VAR_4;", "}", "VAR_0->prev_frame_num++;", "VAR_0->prev_frame_num %= 1 << VAR_0->sps.log2_max_frame_num;", "VAR_0->cur_pic_ptr->VAR_16 = VAR_0->prev_frame_num;", "VAR_0->cur_pic_ptr->invalid_gap = !VAR_0->sps.gaps_in_frame_num_allowed_flag;", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 0);", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 1);", "VAR_4 = ff_generate_sliding_window_mmcos(VAR_0, 1);", "if (VAR_4 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))\nreturn VAR_4;", "VAR_4 = ff_h264_execute_ref_pic_marking(VAR_0, VAR_0->mmco, VAR_0->mmco_index);", "if (VAR_4 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))\nreturn VAR_4;", "if (VAR_0->short_ref_count) {", "if (prev) {", "av_image_copy(VAR_0->short_ref[0]->f.data,\nVAR_0->short_ref[0]->f.linesize,\n(const uint8_t **)prev->f.data,\nprev->f.linesize,\nVAR_0->avctx->pix_fmt,\nVAR_0->mb_width * 16,\nVAR_0->mb_height * 16);", "VAR_0->short_ref[0]->poc = prev->poc + 2;", "}", "VAR_0->short_ref[0]->VAR_16 = VAR_0->prev_frame_num;", "}", "}", "if (VAR_1->first_field) {", "assert(VAR_1->cur_pic_ptr);", "assert(VAR_1->cur_pic_ptr->f.buf[0]);", "assert(VAR_1->cur_pic_ptr->reference != DELAYED_PIC_REF);", "if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_9) {", "VAR_1->missing_fields ++;", "VAR_1->cur_pic_ptr = NULL;", "VAR_1->first_field = FIELD_PICTURE(VAR_0);", "} else {", "VAR_1->missing_fields = 0;", "if (VAR_1->cur_pic_ptr->VAR_16 != VAR_0->VAR_16) {", "ff_thread_report_progress(&VAR_1->cur_pic_ptr->tf, INT_MAX,\nVAR_1->VAR_17==PICT_BOTTOM_FIELD);", "VAR_1->first_field = 1;", "VAR_1->cur_pic_ptr = NULL;", "} else {", "VAR_1->first_field = 0;", "}", "}", "} else {", "VAR_1->first_field = FIELD_PICTURE(VAR_0);", "}", "if (!FIELD_PICTURE(VAR_0) || VAR_1->first_field) {", "if (h264_frame_start(VAR_0) < 0) {", "VAR_1->first_field = 0;", "return AVERROR_INVALIDDATA;", "}", "} else {", "release_unused_pictures(VAR_0, 0);", "}", "if (FIELD_PICTURE(VAR_0)) {", "for(VAR_7 = (VAR_0->VAR_17 == PICT_BOTTOM_FIELD); VAR_7<VAR_0->mb_height; VAR_7++)", "memset(VAR_0->slice_table + VAR_7*VAR_0->mb_stride, -1, (VAR_0->mb_stride - (VAR_7+1==VAR_0->mb_height)) * sizeof(*VAR_0->slice_table));", "} else {", "memset(VAR_0->slice_table, -1,\n(VAR_0->mb_height * VAR_0->mb_stride - 1) * sizeof(*VAR_0->slice_table));", "}", "VAR_1->last_slice_type = -1;", "}", "if (VAR_0 != VAR_1 && (VAR_4 = clone_slice(VAR_0, VAR_1)) < 0)\nreturn VAR_4;", "for (VAR_7 = 0; VAR_7 < VAR_0->slice_context_count; VAR_7++)", "if (VAR_0->thread_context[VAR_7]) {", "VAR_4 = alloc_scratch_buffers(VAR_0->thread_context[VAR_7], VAR_0->linesize);", "if (VAR_4 < 0)\nreturn VAR_4;", "}", "VAR_0->cur_pic_ptr->VAR_16 = VAR_0->VAR_16;", "av_assert1(VAR_0->mb_num == VAR_0->mb_width * VAR_0->mb_height);", "if (VAR_2 << FIELD_OR_MBAFF_PICTURE(VAR_0) >= VAR_0->mb_num ||\nVAR_2 >= VAR_0->mb_num) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_2 overflow\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->resync_mb_x = VAR_0->mb_x = VAR_2 % VAR_0->mb_width;", "VAR_0->resync_mb_y = VAR_0->mb_y = (VAR_2 / VAR_0->mb_width) <<\nFIELD_OR_MBAFF_PICTURE(VAR_0);", "if (VAR_0->VAR_17 == PICT_BOTTOM_FIELD)\nVAR_0->resync_mb_y = VAR_0->mb_y = VAR_0->mb_y + 1;", "av_assert1(VAR_0->mb_y < VAR_0->mb_height);", "if (VAR_0->VAR_17 == PICT_FRAME) {", "VAR_0->curr_pic_num = VAR_0->VAR_16;", "VAR_0->max_pic_num = 1 << VAR_0->sps.log2_max_frame_num;", "} else {", "VAR_0->curr_pic_num = 2 * VAR_0->VAR_16 + 1;", "VAR_0->max_pic_num = 1 << (VAR_0->sps.log2_max_frame_num + 1);", "}", "if (VAR_0->nal_unit_type == NAL_IDR_SLICE)\nget_ue_golomb(&VAR_0->gb);", "if (VAR_0->sps.poc_type == 0) {", "VAR_0->poc_lsb = get_bits(&VAR_0->gb, VAR_0->sps.log2_max_poc_lsb);", "if (VAR_0->pps.pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME)\nVAR_0->delta_poc_bottom = get_se_golomb(&VAR_0->gb);", "}", "if (VAR_0->sps.poc_type == 1 && !VAR_0->sps.delta_pic_order_always_zero_flag) {", "VAR_0->delta_poc[0] = get_se_golomb(&VAR_0->gb);", "if (VAR_0->pps.pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME)\nVAR_0->delta_poc[1] = get_se_golomb(&VAR_0->gb);", "}", "ff_init_poc(VAR_0, VAR_0->cur_pic_ptr->field_poc, &VAR_0->cur_pic_ptr->poc);", "if (VAR_0->pps.redundant_pic_cnt_present)\nVAR_0->redundant_pic_count = get_ue_golomb(&VAR_0->gb);", "VAR_4 = ff_set_ref_count(VAR_0);", "if (VAR_4 < 0)\nreturn VAR_4;", "if (VAR_5 != AV_PICTURE_TYPE_I &&\n(VAR_1->current_slice == 0 ||\nVAR_5 != VAR_1->last_slice_type ||\nmemcmp(VAR_1->last_ref_count, VAR_1->ref_count, sizeof(VAR_1->ref_count)))) {", "ff_h264_fill_default_ref_list(VAR_0);", "}", "if (VAR_0->slice_type_nos != AV_PICTURE_TYPE_I) {", "VAR_4 = ff_h264_decode_ref_pic_list_reordering(VAR_0);", "if (VAR_4 < 0) {", "VAR_0->ref_count[1] = VAR_0->ref_count[0] = 0;", "return VAR_4;", "}", "}", "if ((VAR_0->pps.weighted_pred && VAR_0->slice_type_nos == AV_PICTURE_TYPE_P) ||\n(VAR_0->pps.weighted_bipred_idc == 1 &&\nVAR_0->slice_type_nos == AV_PICTURE_TYPE_B))\nff_pred_weight_table(VAR_0);", "else if (VAR_0->pps.weighted_bipred_idc == 2 &&\nVAR_0->slice_type_nos == AV_PICTURE_TYPE_B) {", "implicit_weight_table(VAR_0, -1);", "} else {", "VAR_0->use_weight = 0;", "for (VAR_7 = 0; VAR_7 < 2; VAR_7++) {", "VAR_0->luma_weight_flag[VAR_7] = 0;", "VAR_0->chroma_weight_flag[VAR_7] = 0;", "}", "}", "if (VAR_0->nal_ref_idc) {", "VAR_4 = ff_h264_decode_ref_pic_marking(VAR_1, &VAR_0->gb,\n!(VAR_0->avctx->active_thread_type & FF_THREAD_FRAME) ||\nVAR_1->current_slice == 0);", "if (VAR_4 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))\nreturn AVERROR_INVALIDDATA;", "}", "if (FRAME_MBAFF(VAR_0)) {", "ff_h264_fill_mbaff_ref_list(VAR_0);", "if (VAR_0->pps.weighted_bipred_idc == 2 && VAR_0->slice_type_nos == AV_PICTURE_TYPE_B) {", "implicit_weight_table(VAR_0, 0);", "implicit_weight_table(VAR_0, 1);", "}", "}", "if (VAR_0->slice_type_nos == AV_PICTURE_TYPE_B && !VAR_0->direct_spatial_mv_pred)\nff_h264_direct_dist_scale_factor(VAR_0);", "ff_h264_direct_ref_list_init(VAR_0);", "if (VAR_0->slice_type_nos != AV_PICTURE_TYPE_I && VAR_0->pps.cabac) {", "VAR_6 = get_ue_golomb_31(&VAR_0->gb);", "if (VAR_6 > 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"cabac_init_idc %u overflow\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "VAR_0->cabac_init_idc = VAR_6;", "}", "VAR_0->last_qscale_diff = 0;", "VAR_6 = VAR_0->pps.init_qp + get_se_golomb(&VAR_0->gb);", "if (VAR_6 > 51 + 6 * (VAR_0->sps.bit_depth_luma - 8)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"QP %u out of range\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "VAR_0->qscale = VAR_6;", "VAR_0->chroma_qp[0] = get_chroma_qp(VAR_0, 0, VAR_0->qscale);", "VAR_0->chroma_qp[1] = get_chroma_qp(VAR_0, 1, VAR_0->qscale);", "if (VAR_0->VAR_5 == AV_PICTURE_TYPE_SP)\nget_bits1(&VAR_0->gb);", "if (VAR_0->VAR_5 == AV_PICTURE_TYPE_SP ||\nVAR_0->VAR_5 == AV_PICTURE_TYPE_SI)\nget_se_golomb(&VAR_0->gb);", "VAR_0->deblocking_filter = 1;", "VAR_0->slice_alpha_c0_offset = 0;", "VAR_0->slice_beta_offset = 0;", "if (VAR_0->pps.deblocking_filter_parameters_present) {", "VAR_6 = get_ue_golomb_31(&VAR_0->gb);", "if (VAR_6 > 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"deblocking_filter_idc %u out of range\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "VAR_0->deblocking_filter = VAR_6;", "if (VAR_0->deblocking_filter < 2)\nVAR_0->deblocking_filter ^= 1;", "if (VAR_0->deblocking_filter) {", "VAR_0->slice_alpha_c0_offset = get_se_golomb(&VAR_0->gb) * 2;", "VAR_0->slice_beta_offset = get_se_golomb(&VAR_0->gb) * 2;", "if (VAR_0->slice_alpha_c0_offset > 12 ||\nVAR_0->slice_alpha_c0_offset < -12 ||\nVAR_0->slice_beta_offset > 12 ||\nVAR_0->slice_beta_offset < -12) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"deblocking filter parameters %d %d out of range\\n\",\nVAR_0->slice_alpha_c0_offset, VAR_0->slice_beta_offset);", "return AVERROR_INVALIDDATA;", "}", "}", "}", "if (VAR_0->avctx->skip_loop_filter >= AVDISCARD_ALL ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&\nVAR_0->nal_unit_type != NAL_IDR_SLICE) ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&\nVAR_0->slice_type_nos != AV_PICTURE_TYPE_I) ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_BIDIR &&\nVAR_0->slice_type_nos == AV_PICTURE_TYPE_B) ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_NONREF &&\nVAR_0->nal_ref_idc == 0))\nVAR_0->deblocking_filter = 0;", "if (VAR_0->deblocking_filter == 1 && VAR_1->max_contexts > 1) {", "if (VAR_0->avctx->flags2 & CODEC_FLAG2_FAST) {", "VAR_0->deblocking_filter = 2;", "} else {", "VAR_1->max_contexts = 1;", "if (!VAR_1->single_decode_warning) {", "av_log(VAR_0->avctx, AV_LOG_INFO,\n\"Cannot parallelize slice decoding with deblocking filter type 1, decoding such frames in sequential order\\n\"\n\"To parallelize slice decoding you need video encoded with disable_deblocking_filter_idc set to 2 (deblock only edges that do not cross slices).\\n\"\n\"Setting the flags2 libavcodec option to +fast (-flags2 +fast) will disable deblocking across slices and enable parallel slice decoding \"\n\"but will generate non-standard-compliant output.\\n\");", "VAR_1->single_decode_warning = 1;", "}", "if (VAR_0 != VAR_1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Deblocking switched inside frame.\\n\");", "return SLICE_SINGLETHREAD;", "}", "}", "}", "VAR_0->qp_thresh = 15 -\nFFMIN(VAR_0->slice_alpha_c0_offset, VAR_0->slice_beta_offset) -\nFFMAX3(0,\nVAR_0->pps.chroma_qp_index_offset[0],\nVAR_0->pps.chroma_qp_index_offset[1]) +\n6 * (VAR_0->sps.bit_depth_luma - 8);", "VAR_1->last_slice_type = VAR_5;", "memcpy(VAR_1->last_ref_count, VAR_1->ref_count, sizeof(VAR_1->last_ref_count));", "VAR_0->slice_num = ++VAR_1->current_slice;", "if (VAR_0->slice_num)\nVAR_1->slice_row[(VAR_0->slice_num-1)&(MAX_SLICES-1)]= VAR_0->resync_mb_y;", "if ( VAR_1->slice_row[VAR_0->slice_num&(MAX_SLICES-1)] + 3 >= VAR_0->resync_mb_y\n&& VAR_1->slice_row[VAR_0->slice_num&(MAX_SLICES-1)] <= VAR_0->resync_mb_y\n&& VAR_0->slice_num >= MAX_SLICES) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\\n\", VAR_0->slice_num, MAX_SLICES);", "}", "for (VAR_8 = 0; VAR_8 < 2; VAR_8++) {", "int VAR_21[16];", "int *VAR_22 = VAR_0->VAR_22[VAR_0->slice_num & (MAX_SLICES - 1)][VAR_8];", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++) {", "VAR_21[VAR_7] = 60;", "if (VAR_8 < VAR_0->list_count && VAR_7 < VAR_0->ref_count[VAR_8] &&\nVAR_0->ref_list[VAR_8][VAR_7].f.buf[0]) {", "int VAR_23;", "AVBuffer *buf = VAR_0->ref_list[VAR_8][VAR_7].f.buf[0]->buffer;", "for (VAR_23 = 0; VAR_23 < VAR_0->short_ref_count; VAR_23++)", "if (VAR_0->short_ref[VAR_23]->f.buf[0]->buffer == buf) {", "VAR_21[VAR_7] = VAR_23;", "break;", "}", "for (VAR_23 = 0; VAR_23 < VAR_0->long_ref_count; VAR_23++)", "if (VAR_0->long_ref[VAR_23] && VAR_0->long_ref[VAR_23]->f.buf[0]->buffer == buf) {", "VAR_21[VAR_7] = VAR_0->short_ref_count + VAR_23;", "break;", "}", "}", "}", "VAR_22[0] =\nVAR_22[1] = -1;", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++)", "VAR_22[VAR_7 + 2] = 4 * VAR_21[VAR_7] + (VAR_0->ref_list[VAR_8][VAR_7].reference & 3);", "VAR_22[18 + 0] =\nVAR_22[18 + 1] = -1;", "for (VAR_7 = 16; VAR_7 < 48; VAR_7++)", "VAR_22[VAR_7 + 4] = 4 * VAR_21[(VAR_7 - 16) >> 1] +\n(VAR_0->ref_list[VAR_8][VAR_7].reference & 3);", "}", "VAR_1->au_pps_id = VAR_3;", "VAR_0->sps.new =\nVAR_1->sps_buffers[VAR_0->pps.sps_id]->new = 0;", "VAR_0->current_sps_id = VAR_0->pps.sps_id;", "if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO) {", "av_log(VAR_0->avctx, AV_LOG_DEBUG,\n\"slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\\n\",\nVAR_0->slice_num,\n(VAR_0->VAR_17 == PICT_FRAME ? \"F\" : VAR_0->VAR_17 == PICT_TOP_FIELD ? \"T\" : \"B\"),\nVAR_2,\nav_get_picture_type_char(VAR_0->VAR_5),\nVAR_0->slice_type_fixed ? \" fix\" : \"\",\nVAR_0->nal_unit_type == NAL_IDR_SLICE ? \" IDR\" : \"\",\nVAR_3, VAR_0->VAR_16,\nVAR_0->cur_pic_ptr->field_poc[0],\nVAR_0->cur_pic_ptr->field_poc[1],\nVAR_0->ref_count[0], VAR_0->ref_count[1],\nVAR_0->qscale,\nVAR_0->deblocking_filter,\nVAR_0->slice_alpha_c0_offset, VAR_0->slice_beta_offset,\nVAR_0->use_weight,\nVAR_0->use_weight == 1 && VAR_0->use_weight_chroma ? \"c\" : \"\",\nVAR_0->VAR_5 == AV_PICTURE_TYPE_B ? (VAR_0->direct_spatial_mv_pred ? \"SPAT\" : \"TEMP\") : \"\");", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73, 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115, 117, 119, 121, 123, 125 ], [ 127 ], [ 129 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163, 165, 167 ], [ 169 ], [ 171 ], [ 175 ], [ 179 ], [ 181, 183, 185 ], [ 187 ], [ 189 ], [ 191, 193 ], [ 197, 199, 201 ], [ 205 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 217 ], [ 221, 223, 225, 227, 229, 231 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247, 249 ], [ 251 ], [ 255 ], [ 257 ], [ 259 ], [ 263, 265, 267, 269, 271, 273, 275, 277 ], [ 279, 281 ], [ 285, 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 301 ], [ 305 ], [ 309 ], [ 311 ], [ 315 ], [ 317, 319 ], [ 323 ], [ 325, 327 ], [ 329 ], [ 331, 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 347, 349 ], [ 351 ], [ 353, 355, 357, 359, 361, 363 ], [ 365 ], [ 367 ], [ 371 ], [ 375 ], [ 379, 381 ], [ 383 ], [ 387, 389 ], [ 393 ], [ 395, 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409, 411 ], [ 413 ], [ 415 ], [ 419, 421 ], [ 423 ], [ 427 ], [ 429, 431 ], [ 433 ], [ 435 ], [ 437 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 451 ], [ 453 ], [ 455 ], [ 457, 459 ], [ 461 ], [ 463 ], [ 465 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515, 517 ], [ 519, 521, 523 ], [ 525 ], [ 527 ], [ 529, 531, 533 ], [ 535 ], [ 537 ], [ 539 ], [ 543 ], [ 545 ], [ 547 ], [ 549 ], [ 553 ], [ 559 ], [ 561 ], [ 563 ], [ 567, 569 ], [ 573 ], [ 575 ], [ 577, 579 ], [ 583 ], [ 585 ], [ 587 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 613 ], [ 615, 617 ], [ 619 ], [ 625 ], [ 631 ], [ 633, 635 ], [ 637 ], [ 639 ], [ 641 ], [ 651 ], [ 653, 655 ], [ 657 ], [ 659 ], [ 663, 665, 667, 669 ], [ 671, 673, 675 ], [ 677 ], [ 679 ], [ 681 ], [ 683 ], [ 685, 687 ], [ 689 ], [ 691 ], [ 693 ], [ 695 ], [ 697 ], [ 699 ], [ 701 ], [ 705, 707 ], [ 709 ], [ 711, 713 ], [ 715, 717 ], [ 719 ], [ 721 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 733 ], [ 735 ], [ 737 ], [ 739 ], [ 741 ], [ 743 ], [ 745 ], [ 747, 749 ], [ 751 ], [ 753, 755 ], [ 771 ], [ 773 ], [ 775, 777, 779, 781, 783, 785, 787 ], [ 789 ], [ 791 ], [ 793 ], [ 795 ], [ 797 ], [ 807 ], [ 809 ], [ 811 ], [ 813 ], [ 819 ], [ 825 ], [ 827 ], [ 829 ], [ 831 ], [ 833 ], [ 835 ], [ 837, 839 ], [ 847 ], [ 849 ], [ 851 ], [ 855 ], [ 857 ], [ 859 ], [ 861 ], [ 865 ], [ 867 ], [ 871 ], [ 873 ], [ 875 ], [ 877 ], [ 879 ], [ 881 ], [ 883 ], [ 885 ], [ 891 ], [ 893 ], [ 895 ], [ 897 ], [ 899, 901 ], [ 903 ], [ 905 ], [ 907 ], [ 909, 911 ], [ 919 ], [ 921 ], [ 923 ], [ 925, 927 ], [ 929 ], [ 933 ], [ 937 ], [ 939, 941 ], [ 943 ], [ 945 ], [ 947 ], [ 949 ], [ 951, 953 ], [ 955, 957 ], [ 959 ], [ 963 ], [ 965 ], [ 967 ], [ 969 ], [ 971 ], [ 973 ], [ 975 ], [ 979, 981 ], [ 985 ], [ 987 ], [ 991, 993 ], [ 995 ], [ 999 ], [ 1001 ], [ 1005, 1007 ], [ 1009 ], [ 1013 ], [ 1017, 1019 ], [ 1023 ], [ 1025, 1027 ], [ 1031, 1033, 1035, 1037 ], [ 1041 ], [ 1043 ], [ 1047 ], [ 1049 ], [ 1051 ], [ 1053 ], [ 1055 ], [ 1057 ], [ 1059 ], [ 1063, 1065, 1067, 1069 ], [ 1071, 1073 ], [ 1075 ], [ 1077 ], [ 1079 ], [ 1081 ], [ 1083 ], [ 1085 ], [ 1087 ], [ 1089 ], [ 1103 ], [ 1105, 1107, 1109 ], [ 1111, 1113 ], [ 1115 ], [ 1119 ], [ 1121 ], [ 1125 ], [ 1127 ], [ 1129 ], [ 1131 ], [ 1133 ], [ 1137, 1139 ], [ 1141 ], [ 1145 ], [ 1147 ], [ 1149 ], [ 1151 ], [ 1153 ], [ 1155 ], [ 1157 ], [ 1159 ], [ 1163 ], [ 1165 ], [ 1167 ], [ 1169 ], [ 1171 ], [ 1173 ], [ 1175 ], [ 1177 ], [ 1179 ], [ 1183, 1185 ], [ 1187, 1189, 1191 ], [ 1195 ], [ 1197 ], [ 1199 ], [ 1201 ], [ 1203 ], [ 1205 ], [ 1207, 1209 ], [ 1211 ], [ 1213 ], [ 1215 ], [ 1217, 1219 ], [ 1223 ], [ 1225 ], [ 1227 ], [ 1229, 1231, 1233, 1235 ], [ 1237, 1239, 1241 ], [ 1243 ], [ 1245 ], [ 1247 ], [ 1249 ], [ 1253, 1255, 1257, 1259, 1261, 1263, 1265, 1267, 1269, 1271 ], [ 1275 ], [ 1277 ], [ 1283 ], [ 1285 ], [ 1287 ], [ 1289 ], [ 1291, 1293, 1295, 1297, 1299 ], [ 1301 ], [ 1303 ], [ 1305 ], [ 1307, 1309 ], [ 1311 ], [ 1313 ], [ 1315 ], [ 1317 ], [ 1319, 1321, 1323, 1325, 1327, 1329 ], [ 1333 ], [ 1335 ], [ 1337 ], [ 1341, 1343 ], [ 1345, 1347, 1349 ], [ 1353 ], [ 1355 ], [ 1359 ], [ 1361 ], [ 1363 ], [ 1365 ], [ 1367 ], [ 1369, 1371 ], [ 1373 ], [ 1375 ], [ 1377 ], [ 1379 ], [ 1381 ], [ 1383 ], [ 1385 ], [ 1387 ], [ 1389 ], [ 1391 ], [ 1393 ], [ 1395 ], [ 1397 ], [ 1399 ], [ 1403, 1405 ], [ 1407 ], [ 1409 ], [ 1411, 1413 ], [ 1415 ], [ 1417, 1419 ], [ 1421 ], [ 1425 ], [ 1427, 1429 ], [ 1431 ], [ 1435 ], [ 1437, 1439, 1441, 1443, 1445, 1447, 1449, 1451, 1453, 1455, 1457, 1459, 1461, 1463, 1465, 1467, 1469, 1471 ], [ 1473 ], [ 1477 ], [ 1479 ] ]

[ "static void FUNC_0(dwt_compose_t *VAR_0, slice_buffer * VAR_1, int VAR_2, int VAR_3, int VAR_4){", "int VAR_5= VAR_0->VAR_5;", "int VAR_6 = mirror(VAR_5-1, VAR_3-1);", "int VAR_7 = mirror(VAR_5 , VAR_3-1);", "int VAR_8 = mirror(VAR_5+1, VAR_3-1);", "int VAR_9 = mirror(VAR_5+2, VAR_3-1);", "DWTELEM *b0= VAR_0->b0;", "DWTELEM *b1= VAR_0->b1;", "DWTELEM *b2= slice_buffer_get_line(VAR_1, VAR_8 * VAR_4);", "DWTELEM *b3= slice_buffer_get_line(VAR_1, VAR_9 * VAR_4);", "{START_TIMER", "if(VAR_7 <= VAR_9) vertical_compose53iL0(b1, b2, b3, VAR_2);", "if(VAR_6 <= VAR_8) vertical_compose53iH0(b0, b1, b2, VAR_2);", "STOP_TIMER(\"vertical_compose53i*\")}", "{START_TIMER", "if(VAR_5-1 >= 0) horizontal_compose53i(b0, VAR_2);", "if(VAR_6 <= VAR_8) horizontal_compose53i(b1, VAR_2);", "STOP_TIMER(\"horizontal_compose53i\")}", "VAR_0->b0 = b2;", "VAR_0->b1 = b3;", "VAR_0->VAR_5 += 2;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0 ]

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ] ]

[ "void FUNC_0(VirtIOSCSI *VAR_0, VirtIOSCSIReq *VAR_1)\n{", "VirtIODevice *vdev = (VirtIODevice *)VAR_0;", "uint32_t type;", "int VAR_2 = 0;", "if (iov_to_buf(VAR_1->elem.out_sg, VAR_1->elem.out_num, 0,\n&type, sizeof(type)) < sizeof(type)) {", "virtio_scsi_bad_req();", "return;", "}", "virtio_tswap32s(vdev, &type);", "if (type == VIRTIO_SCSI_T_TMF) {", "if (virtio_scsi_parse_req(VAR_1, sizeof(VirtIOSCSICtrlTMFReq),\nsizeof(VirtIOSCSICtrlTMFResp)) < 0) {", "virtio_scsi_bad_req();", "} else {", "VAR_2 = virtio_scsi_do_tmf(VAR_0, VAR_1);", "}", "} else if (type == VIRTIO_SCSI_T_AN_QUERY ||", "type == VIRTIO_SCSI_T_AN_SUBSCRIBE) {", "if (virtio_scsi_parse_req(VAR_1, sizeof(VirtIOSCSICtrlANReq),\nsizeof(VirtIOSCSICtrlANResp)) < 0) {", "virtio_scsi_bad_req();", "} else {", "VAR_1->resp.an.event_actual = 0;", "VAR_1->resp.an.response = VIRTIO_SCSI_S_OK;", "}", "}", "if (VAR_2 == 0) {", "virtio_scsi_complete_req(VAR_1);", "} else {", "assert(VAR_2 == -EINPROGRESS);", "}", "}" ]

[ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13, 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ] ]

[ "inline static void FUNC_0(hcscale)(uint16_t *dst, int dstWidth, uint8_t *src1, uint8_t *src2,\nint srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,\nint16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode,\nint srcFormat, uint8_t *formatConvBuffer)\n{", "if(srcFormat==IMGFMT_YUY2)\n{", "FUNC_0(yuy2ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR32)\n{", "FUNC_0(bgr32ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR24)\n{", "FUNC_0(bgr24ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR16)\n{", "FUNC_0(bgr16ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR15)\n{", "FUNC_0(bgr15ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_RGB32)\n{", "FUNC_0(rgb32ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_RGB24)\n{", "FUNC_0(rgb24ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(isGray(srcFormat))\n{", "return;", "}", "#ifdef HAVE_MMX\nif(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))\n#else\nif(!(flags&SWS_FAST_BILINEAR))\n#endif\n{", "FUNC_0(hScale)(dst , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);", "FUNC_0(hScale)(dst+2048, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);", "}", "else\n{", "#ifdef ARCH_X86\n#ifdef HAVE_MMX2\nint VAR_0;", "if(canMMX2BeUsed)\n{", "asm volatile(\n\"pxor %%mm7, %%mm7\t\t\\n\\t\"\n\"pxor %%mm2, %%mm2\t\t\\n\\t\"\n\"movd %5, %%mm6\t\t\t\\n\\t\"\n\"punpcklwd %%mm6, %%mm6\t\t\\n\\t\"\n\"punpcklwd %%mm6, %%mm6\t\t\\n\\t\"\n\"movq %%mm6, %%mm2\t\t\\n\\t\"\n\"psllq $16, %%mm2\t\t\\n\\t\"\n\"paddw %%mm6, %%mm2\t\t\\n\\t\"\n\"psllq $16, %%mm2\t\t\\n\\t\"\n\"paddw %%mm6, %%mm2\t\t\\n\\t\"\n\"psllq $16, %%mm2\t\t\\n\\t\"\n\"movq %%mm2, %%mm4\t\t\\n\\t\"\n\"movd %4, %%mm6\t\t\t\\n\\t\"\n\"punpcklwd %%mm6, %%mm6\t\t\\n\\t\"\n\"punpcklwd %%mm6, %%mm6\t\t\\n\\t\"\n\"xorl %%eax, %%eax\t\t\\n\\t\"\n\"movl %0, %%esi\t\t\t\\n\\t\"\n\"movl %1, %%edi\t\t\t\\n\\t\"\n\"movl %3, %%edx\t\t\t\\n\\t\"\n\"xorl %%ecx, %%ecx\t\t\\n\\t\"\n\"xorl %%ebx, %%ebx\t\t\\n\\t\"\n\"movw %4, %%bx\t\t\t\\n\\t\"\n#define FUNNYUVCODE \\\nPREFETCH\" 1024(%%esi)\t\t\\n\\t\"\\\nPREFETCH\" 1056(%%esi)\t\t\\n\\t\"\\\nPREFETCH\" 1088(%%esi)\t\t\\n\\t\"\\\n\"call *%7\t\t\t\\n\\t\"\\\n\"movq %%mm4, %%mm2\t\\n\\t\"\\\n\"xorl %%ecx, %%ecx\t\t\\n\\t\"\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\n\"xorl %%eax, %%eax\t\t\\n\\t\"\n\"movl %6, %%esi\t\t\t\\n\\t\"\n\"movl %1, %%edi\t\t\t\\n\\t\"\n\"addl $4096, %%edi\t\t\\n\\t\"\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\nFUNNYUVCODE\n:: \"m\" (src1), \"m\" (dst), \"m\" (dstWidth), \"m\" ((xInc*4)>>16),\n\"m\" ((xInc*4)&0xFFFF), \"m\" (xInc&0xFFFF), \"m\" (src2), \"m\" (funnyUVCode)\n: \"%eax\", \"%ebx\", \"%ecx\", \"%edx\", \"%esi\", \"%edi\"\n);", "for(VAR_0=dstWidth-1; (VAR_0*xInc)>>16 >=srcW-1; VAR_0--)", "{", "dst[VAR_0] = src1[srcW-1]*128;", "dst[VAR_0+2048] = src2[srcW-1]*128;", "}", "}", "else\n{", "#endif\nasm volatile(\n\"xorl %%eax, %%eax\t\t\\n\\t\"\n\"xorl %%ebx, %%ebx\t\t\\n\\t\"\n\"xorl %%ecx, %%ecx\t\t\\n\\t\"\n\".balign 16\t\t\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\n\"movl %0, %%esi\t\t\t\\n\\t\"\n\"movzbl (%%esi, %%ebx), %%edi\t\\n\\t\"\n\"movzbl 1(%%esi, %%ebx), %%esi\t\\n\\t\"\n\"subl %%edi, %%esi\t\t\\n\\t\" - src[xx]\n\"imull %%ecx, %%esi\t\t\\n\\t\"\n\"shll $16, %%edi\t\t\\n\\t\"\n\"addl %%edi, %%esi\t\t\\n\\t\" *2*xalpha + src[xx]*(1-2*xalpha)\n\"movl %1, %%edi\t\t\t\\n\\t\"\n\"shrl $9, %%esi\t\t\t\\n\\t\"\n\"movw %%si, (%%edi, %%eax, 2)\t\\n\\t\"\n\"movzbl (%5, %%ebx), %%edi\t\\n\\t\"\n\"movzbl 1(%5, %%ebx), %%esi\t\\n\\t\"\n\"subl %%edi, %%esi\t\t\\n\\t\" - src[xx]\n\"imull %%ecx, %%esi\t\t\\n\\t\"\n\"shll $16, %%edi\t\t\\n\\t\"\n\"addl %%edi, %%esi\t\t\\n\\t\" *2*xalpha + src[xx]*(1-2*xalpha)\n\"movl %1, %%edi\t\t\t\\n\\t\"\n\"shrl $9, %%esi\t\t\t\\n\\t\"\n\"movw %%si, 4096(%%edi, %%eax, 2)\\n\\t\"\n\"addw %4, %%cx\t\t\t\\n\\t\"\n\"adcl %3, %%ebx\t\t\t\\n\\t\"\n\"addl $1, %%eax\t\t\t\\n\\t\"\n\"cmpl %2, %%eax\t\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n:: \"m\" (src1), \"m\" (dst), \"m\" (dstWidth), \"m\" (xInc>>16), \"m\" (xInc&0xFFFF),\n\"r\" (src2)\n: \"%eax\", \"%ebx\", \"%ecx\", \"%edi\", \"%esi\"\n);", "#ifdef HAVE_MMX2\n}", "#endif\n#else\nint VAR_0;", "unsigned int VAR_1=0;", "for(VAR_0=0;VAR_0<dstWidth;VAR_0++)", "{", "register unsigned int xx=VAR_1>>16;", "register unsigned int xalpha=(VAR_1&0xFFFF)>>9;", "dst[VAR_0]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);", "dst[VAR_0+2048]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);", "VAR_1+=xInc;", "}", "#endif\n}", "}" ]

[ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7, 9 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 105, 109, 111, 113, 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125, 127 ], [ 129, 131, 133 ], [ 135, 137 ], [ 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 187, 189, 191, 193, 195, 197, 199, 203, 205, 207, 209, 213, 215, 217, 219, 221, 223, 225, 227, 231, 233, 235, 237, 241, 243, 245, 247, 251, 253, 255, 257 ], [ 259 ], [ 261 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273, 275 ], [ 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, 305, 307, 309, 313, 315, 317, 319, 321, 323, 325, 327, 329, 333, 335, 337, 339, 341, 345, 347, 349, 351 ], [ 353, 355 ], [ 357, 359, 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 385 ], [ 387 ], [ 389, 391 ], [ 393 ] ]

[ "static uint64_t FUNC_0(uint8_t (*layout_map)[3], int tags)\n{", "int VAR_0, VAR_1, VAR_2;", "struct elem_to_channel VAR_3[MAX_ELEM_ID] = {{ 0 }};", "int VAR_4, VAR_5, VAR_6;", "uint64_t layout;", "VAR_0 = 0;", "VAR_4 =\ncount_paired_channels(layout_map, tags, AAC_CHANNEL_FRONT, &VAR_0);", "if (VAR_4 < 0)\nreturn 0;", "VAR_5 =\ncount_paired_channels(layout_map, tags, AAC_CHANNEL_SIDE, &VAR_0);", "if (VAR_5 < 0)\nreturn 0;", "VAR_6 =\ncount_paired_channels(layout_map, tags, AAC_CHANNEL_BACK, &VAR_0);", "if (VAR_6 < 0)\nreturn 0;", "VAR_0 = 0;", "if (VAR_4 & 1) {", "VAR_3[VAR_0] = (struct elem_to_channel) {", ".av_position = AV_CH_FRONT_CENTER, .syn_ele = TYPE_SCE,\n.elem_id = layout_map[VAR_0][1], .aac_position = AAC_CHANNEL_FRONT };", "VAR_0++;", "VAR_4--;", "}", "if (VAR_4 >= 4) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nAV_CH_FRONT_LEFT_OF_CENTER,\nAV_CH_FRONT_RIGHT_OF_CENTER,\nAAC_CHANNEL_FRONT);", "VAR_4 -= 2;", "}", "if (VAR_4 >= 2) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nAV_CH_FRONT_LEFT,\nAV_CH_FRONT_RIGHT,\nAAC_CHANNEL_FRONT);", "VAR_4 -= 2;", "}", "while (VAR_4 >= 2) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nUINT64_MAX,\nUINT64_MAX,\nAAC_CHANNEL_FRONT);", "VAR_4 -= 2;", "}", "if (VAR_5 >= 2) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nAV_CH_SIDE_LEFT,\nAV_CH_SIDE_RIGHT,\nAAC_CHANNEL_FRONT);", "VAR_5 -= 2;", "}", "while (VAR_5 >= 2) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nUINT64_MAX,\nUINT64_MAX,\nAAC_CHANNEL_SIDE);", "VAR_5 -= 2;", "}", "while (VAR_6 >= 4) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nUINT64_MAX,\nUINT64_MAX,\nAAC_CHANNEL_BACK);", "VAR_6 -= 2;", "}", "if (VAR_6 >= 2) {", "VAR_0 += assign_pair(VAR_3, layout_map, VAR_0, tags,\nAV_CH_BACK_LEFT,\nAV_CH_BACK_RIGHT,\nAAC_CHANNEL_BACK);", "VAR_6 -= 2;", "}", "if (VAR_6) {", "VAR_3[VAR_0] = (struct elem_to_channel) {", ".av_position = AV_CH_BACK_CENTER, .syn_ele = TYPE_SCE,\n.elem_id = layout_map[VAR_0][1], .aac_position = AAC_CHANNEL_BACK };", "VAR_0++;", "VAR_6--;", "}", "if (VAR_0 < tags && layout_map[VAR_0][2] == AAC_CHANNEL_LFE) {", "VAR_3[VAR_0] = (struct elem_to_channel) {", ".av_position = AV_CH_LOW_FREQUENCY, .syn_ele = TYPE_LFE,\n.elem_id = layout_map[VAR_0][1], .aac_position = AAC_CHANNEL_LFE };", "VAR_0++;", "}", "while (VAR_0 < tags && layout_map[VAR_0][2] == AAC_CHANNEL_LFE) {", "VAR_3[VAR_0] = (struct elem_to_channel) {", ".av_position = UINT64_MAX, .syn_ele = TYPE_LFE,\n.elem_id = layout_map[VAR_0][1], .aac_position = AAC_CHANNEL_LFE };", "VAR_0++;", "}", "VAR_2 = VAR_1 = VAR_0;", "do {", "int VAR_7 = 0;", "for (VAR_0 = 1; VAR_0 < VAR_1; VAR_0++) {", "if (VAR_3[VAR_0-1].av_position > VAR_3[VAR_0].av_position) {", "FFSWAP(struct elem_to_channel, VAR_3[VAR_0-1], VAR_3[VAR_0]);", "VAR_7 = VAR_0;", "}", "}", "VAR_1 = VAR_7;", "} while (VAR_1 > 0);", "layout = 0;", "for (VAR_0 = 0; VAR_0 < VAR_2; VAR_0++) {", "layout_map[VAR_0][0] = VAR_3[VAR_0].syn_ele;", "layout_map[VAR_0][1] = VAR_3[VAR_0].elem_id;", "layout_map[VAR_0][2] = VAR_3[VAR_0].aac_position;", "if (VAR_3[VAR_0].av_position != UINT64_MAX) {", "layout |= VAR_3[VAR_0].av_position;", "}", "}", "return layout;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17, 19 ], [ 21, 23 ], [ 25, 27 ], [ 29, 31 ], [ 33, 35 ], [ 37, 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63, 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75, 77, 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 91, 93, 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105, 107, 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119, 121, 123, 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135, 137, 139, 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149, 151, 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193, 195 ], [ 197 ], [ 199 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 249 ], [ 251 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "FilmDemuxContext *film = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "AVStream *st;", "unsigned char VAR_1[256];", "int VAR_2, VAR_3;", "unsigned int VAR_4;", "unsigned int VAR_5;", "film->sample_table = NULL;", "film->stereo_buffer = NULL;", "film->stereo_buffer_size = 0;", "if (avio_read(pb, VAR_1, 16) != 16)\nreturn AVERROR(EIO);", "VAR_4 = AV_RB32(&VAR_1[4]);", "film->version = AV_RB32(&VAR_1[8]);", "if (film->version == 0) {", "if (avio_read(pb, VAR_1, 20) != 20)\nreturn AVERROR(EIO);", "film->audio_type = AV_CODEC_ID_PCM_S8;", "film->audio_samplerate = 22050;", "film->audio_channels = 1;", "film->audio_bits = 8;", "} else {", "if (avio_read(pb, VAR_1, 32) != 32)\nreturn AVERROR(EIO);", "film->audio_samplerate = AV_RB16(&VAR_1[24]);", "film->audio_channels = VAR_1[21];", "if (!film->audio_channels || film->audio_channels > 2) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Invalid number of channels: %d\\n\", film->audio_channels);", "return AVERROR_INVALIDDATA;", "}", "film->audio_bits = VAR_1[22];", "if (VAR_1[23] == 2)\nfilm->audio_type = AV_CODEC_ID_ADPCM_ADX;", "else if (film->audio_channels > 0) {", "if (film->audio_bits == 8)\nfilm->audio_type = AV_CODEC_ID_PCM_S8;", "else if (film->audio_bits == 16)\nfilm->audio_type = AV_CODEC_ID_PCM_S16BE;", "else\nfilm->audio_type = AV_CODEC_ID_NONE;", "} else", "film->audio_type = AV_CODEC_ID_NONE;", "}", "if (AV_RB32(&VAR_1[0]) != FDSC_TAG)\nreturn AVERROR_INVALIDDATA;", "if (AV_RB32(&VAR_1[8]) == CVID_TAG) {", "film->video_type = AV_CODEC_ID_CINEPAK;", "} else if (AV_RB32(&VAR_1[8]) == RAW_TAG) {", "film->video_type = AV_CODEC_ID_RAWVIDEO;", "} else {", "film->video_type = AV_CODEC_ID_NONE;", "}", "if (film->video_type) {", "st = avformat_new_stream(VAR_0, NULL);", "if (!st)\nreturn AVERROR(ENOMEM);", "film->video_stream_index = st->index;", "st->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "st->codec->codec_id = film->video_type;", "st->codec->codec_tag = 0;", "st->codec->width = AV_RB32(&VAR_1[16]);", "st->codec->height = AV_RB32(&VAR_1[12]);", "if (film->video_type == AV_CODEC_ID_RAWVIDEO) {", "if (VAR_1[20] == 24) {", "st->codec->pix_fmt = AV_PIX_FMT_RGB24;", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"raw video is using unhandled %dbpp\\n\", VAR_1[20]);", "return -1;", "}", "}", "}", "if (film->audio_type) {", "st = avformat_new_stream(VAR_0, NULL);", "if (!st)\nreturn AVERROR(ENOMEM);", "film->audio_stream_index = st->index;", "st->codec->codec_type = AVMEDIA_TYPE_AUDIO;", "st->codec->codec_id = film->audio_type;", "st->codec->codec_tag = 1;", "st->codec->channels = film->audio_channels;", "st->codec->sample_rate = film->audio_samplerate;", "if (film->audio_type == AV_CODEC_ID_ADPCM_ADX) {", "st->codec->bits_per_coded_sample = 18 * 8 / 32;", "st->codec->block_align = st->codec->channels * 18;", "st->need_parsing = AVSTREAM_PARSE_FULL;", "} else {", "st->codec->bits_per_coded_sample = film->audio_bits;", "st->codec->block_align = st->codec->channels *\nst->codec->bits_per_coded_sample / 8;", "}", "st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *\nst->codec->bits_per_coded_sample;", "}", "if (avio_read(pb, VAR_1, 16) != 16)\nreturn AVERROR(EIO);", "if (AV_RB32(&VAR_1[0]) != STAB_TAG)\nreturn AVERROR_INVALIDDATA;", "film->base_clock = AV_RB32(&VAR_1[8]);", "film->sample_count = AV_RB32(&VAR_1[12]);", "if(film->sample_count >= UINT_MAX / sizeof(film_sample))\nreturn -1;", "film->sample_table = av_malloc(film->sample_count * sizeof(film_sample));", "if (!film->sample_table)\nreturn AVERROR(ENOMEM);", "for (VAR_2 = 0; VAR_2 < VAR_0->nb_streams; VAR_2++) {", "st = VAR_0->streams[VAR_2];", "if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)\navpriv_set_pts_info(st, 33, 1, film->base_clock);", "else\navpriv_set_pts_info(st, 64, 1, film->audio_samplerate);", "}", "VAR_5 = 0;", "for (VAR_2 = 0; VAR_2 < film->sample_count; VAR_2++) {", "if (avio_read(pb, VAR_1, 16) != 16) {", "VAR_3 = AVERROR(EIO);", "goto fail;", "}", "film->sample_table[VAR_2].sample_offset =\nVAR_4 + AV_RB32(&VAR_1[0]);", "film->sample_table[VAR_2].sample_size = AV_RB32(&VAR_1[4]);", "if (film->sample_table[VAR_2].sample_size > INT_MAX / 4) {", "VAR_3 = AVERROR_INVALIDDATA;", "goto fail;", "}", "if (AV_RB32(&VAR_1[8]) == 0xFFFFFFFF) {", "film->sample_table[VAR_2].stream = film->audio_stream_index;", "film->sample_table[VAR_2].pts = VAR_5;", "if (film->audio_type == AV_CODEC_ID_ADPCM_ADX)\nVAR_5 += (film->sample_table[VAR_2].sample_size * 32 /\n(18 * film->audio_channels));", "else if (film->audio_type != AV_CODEC_ID_NONE)\nVAR_5 += (film->sample_table[VAR_2].sample_size /\n(film->audio_channels * film->audio_bits / 8));", "} else {", "film->sample_table[VAR_2].stream = film->video_stream_index;", "film->sample_table[VAR_2].pts = AV_RB32(&VAR_1[8]) & 0x7FFFFFFF;", "film->sample_table[VAR_2].keyframe = (VAR_1[8] & 0x80) ? 0 : 1;", "}", "}", "film->current_sample = 0;", "return 0;", "fail:\nfilm_read_close(VAR_0);", "return VAR_3;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 43 ], [ 47, 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89 ], [ 91, 93 ], [ 95, 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111, 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 135 ], [ 137 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211, 213 ], [ 215 ], [ 219, 221 ], [ 223 ], [ 229, 231 ], [ 233, 235 ], [ 237 ], [ 239 ], [ 241, 243 ], [ 245 ], [ 247, 249 ], [ 253 ], [ 255 ], [ 257, 259 ], [ 261, 263 ], [ 265 ], [ 269 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283, 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 305, 307, 309 ], [ 311, 313, 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 331 ], [ 335 ], [ 337, 339 ], [ 341 ], [ 343 ] ]