Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static av_always_inline void FUNC_0(H264Context *h,\nH264SliceContext *sl,\nint mb_x, int mb_y,\nuint8_t *img_y,\nuint8_t *img_cb,\nuint8_t *img_cr,\nunsigned int linesize,\nunsigned int uvlinesize,\nint pixel_shift)\n{", "int VAR_0 = !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));", "int VAR_1 = CHROMA444(h);", "int VAR_2 = CHROMA422(h);", "int VAR_3 = h->VAR_3;", "int VAR_4 = sl->VAR_4[LTOP];", "int VAR_5 = sl->VAR_5;", "int VAR_6 = 6 * (h->sps.bit_depth_luma - 8);", "int VAR_7 = 52 + h->slice_alpha_c0_offset - VAR_6;", "int VAR_8 = 52 + h->slice_beta_offset - VAR_6;", "int VAR_9 = h->cur_pic.VAR_9[VAR_3];", "int VAR_10 = h->cur_pic.qscale_table[VAR_3];", "int VAR_11 = h->cur_pic.qscale_table[VAR_3 - 1];", "int VAR_12 = h->cur_pic.qscale_table[sl->top_mb_xy];", "int VAR_13 = get_chroma_qp( h, 0, VAR_10 );", "int VAR_14 = get_chroma_qp( h, 0, VAR_11 );", "int VAR_15 = get_chroma_qp( h, 0, VAR_12 );", "VAR_11 = (VAR_10 + VAR_11 + 1) >> 1;", "VAR_12 = (VAR_10 + VAR_12 + 1) >> 1;", "VAR_14 = (VAR_13 + VAR_14 + 1) >> 1;", "VAR_15 = (VAR_13 + VAR_15 + 1) >> 1;", "if( IS_INTRA(VAR_9) ) {", "static const int16_t VAR_16[4] = {4,4,4,4};", "static const int16_t VAR_17[4] = {3,3,3,3};", "const int16_t *VAR_18 = FIELD_PICTURE(h) ? VAR_17 : VAR_16;", "if(VAR_4)\nfilter_mb_edgev( &img_y[4*0<<pixel_shift], linesize, VAR_16, VAR_11, VAR_7, VAR_8, h, 1);", "if( IS_8x8DCT(VAR_9) ) {", "filter_mb_edgev( &img_y[4*2<<pixel_shift], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "if(VAR_5){", "filter_mb_edgeh( &img_y[4*0*linesize], linesize, VAR_18, VAR_12, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgeh( &img_y[4*2*linesize], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "} else {", "filter_mb_edgev( &img_y[4*1<<pixel_shift], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_y[4*2<<pixel_shift], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_y[4*3<<pixel_shift], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "if(VAR_5){", "filter_mb_edgeh( &img_y[4*0*linesize], linesize, VAR_18, VAR_12, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgeh( &img_y[4*1*linesize], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_y[4*2*linesize], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_y[4*3*linesize], linesize, VAR_17, VAR_10, VAR_7, VAR_8, h, 0);", "}", "if(VAR_0){", "if(VAR_1){", "if(VAR_4){", "filter_mb_edgev( &img_cb[4*0<<pixel_shift], linesize, VAR_16, VAR_14, VAR_7, VAR_8, h, 1);", "filter_mb_edgev( &img_cr[4*0<<pixel_shift], linesize, VAR_16, VAR_14, VAR_7, VAR_8, h, 1);", "}", "if( IS_8x8DCT(VAR_9) ) {", "filter_mb_edgev( &img_cb[4*2<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_cr[4*2<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "if(VAR_5){", "filter_mb_edgeh( &img_cb[4*0*linesize], linesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1 );", "filter_mb_edgeh( &img_cr[4*0*linesize], linesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1 );", "}", "filter_mb_edgeh( &img_cb[4*2*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_cr[4*2*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "} else {", "filter_mb_edgev( &img_cb[4*1<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_cr[4*1<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_cb[4*2<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_cr[4*2<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_cb[4*3<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgev( &img_cr[4*3<<pixel_shift], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "if(VAR_5){", "filter_mb_edgeh( &img_cb[4*0*linesize], linesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1);", "filter_mb_edgeh( &img_cr[4*0*linesize], linesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgeh( &img_cb[4*1*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_cr[4*1*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_cb[4*2*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_cr[4*2*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_cb[4*3*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgeh( &img_cr[4*3*linesize], linesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "}", "}else if(VAR_2){", "if(VAR_4){", "filter_mb_edgecv(&img_cb[2*0<<pixel_shift], uvlinesize, VAR_16, VAR_14, VAR_7, VAR_8, h, 1);", "filter_mb_edgecv(&img_cr[2*0<<pixel_shift], uvlinesize, VAR_16, VAR_14, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgecv(&img_cb[2*2<<pixel_shift], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgecv(&img_cr[2*2<<pixel_shift], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "if(VAR_5){", "filter_mb_edgech(&img_cb[4*0*uvlinesize], uvlinesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1);", "filter_mb_edgech(&img_cr[4*0*uvlinesize], uvlinesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgech(&img_cb[4*1*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgech(&img_cr[4*1*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgech(&img_cb[4*2*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgech(&img_cr[4*2*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgech(&img_cb[4*3*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgech(&img_cr[4*3*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "}else{", "if(VAR_4){", "filter_mb_edgecv( &img_cb[2*0<<pixel_shift], uvlinesize, VAR_16, VAR_14, VAR_7, VAR_8, h, 1);", "filter_mb_edgecv( &img_cr[2*0<<pixel_shift], uvlinesize, VAR_16, VAR_14, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgecv( &img_cb[2*2<<pixel_shift], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgecv( &img_cr[2*2<<pixel_shift], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "if(VAR_5){", "filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1);", "filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, VAR_18, VAR_15, VAR_7, VAR_8, h, 1);", "}", "filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, VAR_17, VAR_13, VAR_7, VAR_8, h, 0);", "}", "}", "return;", "} else {", "LOCAL_ALIGNED_8(int16_t, bS, [2], [4][4]);", "int VAR_19;", "if( IS_8x8DCT(VAR_9) && (sl->cbp&7) == 7 && !VAR_1 ) {", "VAR_19 = 4;", "AV_WN64A(bS[0][0], 0x0002000200020002ULL);", "AV_WN64A(bS[0][2], 0x0002000200020002ULL);", "AV_WN64A(bS[1][0], 0x0002000200020002ULL);", "AV_WN64A(bS[1][2], 0x0002000200020002ULL);", "} else {", "int VAR_20 = (3*(((5*VAR_9)>>5)&1)) | (VAR_9>>4);", "int VAR_21 = 3*((VAR_20>>1) & ((5*VAR_4)>>5)&1);", "int VAR_22 = 1+(VAR_9>>24);", "VAR_19 = 4 - 3*((VAR_9>>3) & !(sl->cbp & 15));", "h->h264dsp.h264_loop_filter_strength(bS, sl->non_zero_count_cache, sl->ref_cache, sl->mv_cache,\nsl->list_count==2, VAR_19, VAR_22, VAR_21, VAR_20, FIELD_PICTURE(h));", "}", "if( IS_INTRA(VAR_4) )\nAV_WN64A(bS[0][0], 0x0004000400040004ULL);", "if( IS_INTRA(VAR_5) )\nAV_WN64A(bS[1][0], FIELD_PICTURE(h) ? 0x0003000300030003ULL : 0x0004000400040004ULL);", "#define FILTER(hv,dir,edge,intra)\\\nif(AV_RN64A(bS[dir][edge])) { \\", "filter_mb_edge##hv( &img_y[4*edge*(dir?linesize:1<<pixel_shift)], linesize, bS[dir][edge], edge ? VAR_10 : VAR_10##dir, VAR_7, VAR_8, h, intra );\\", "if(VAR_0){\\", "if(VAR_1){\\", "filter_mb_edge##hv( &img_cb[4*edge*(dir?linesize:1<<pixel_shift)], linesize, bS[dir][edge], edge ? VAR_13 : VAR_13##dir, VAR_7, VAR_8, h, intra );\\", "filter_mb_edge##hv( &img_cr[4*edge*(dir?linesize:1<<pixel_shift)], linesize, bS[dir][edge], edge ? VAR_13 : VAR_13##dir, VAR_7, VAR_8, h, intra );\\", "} else if(!(edge&1)) {\\", "filter_mb_edgec##hv( &img_cb[2*edge*(dir?uvlinesize:1<<pixel_shift)], uvlinesize, bS[dir][edge], edge ? VAR_13 : VAR_13##dir, VAR_7, VAR_8, h, intra );\\", "filter_mb_edgec##hv( &img_cr[2*edge*(dir?uvlinesize:1<<pixel_shift)], uvlinesize, bS[dir][edge], edge ? VAR_13 : VAR_13##dir, VAR_7, VAR_8, h, intra );\\", "}\\", "}\\", "}", "if(VAR_4)\nFILTER(v,0,0,1);", "if( VAR_19 == 1 ) {", "if(VAR_5)\nFILTER(h,1,0,1);", "} else if( IS_8x8DCT(VAR_9) ) {", "FILTER(v,0,2,0);", "if(VAR_5)\nFILTER(h,1,0,1);", "FILTER(h,1,2,0);", "} else {", "FILTER(v,0,1,0);", "FILTER(v,0,2,0);", "FILTER(v,0,3,0);", "if(VAR_5)\nFILTER(h,1,0,1);", "FILTER(h,1,1,0);", "FILTER(h,1,2,0);", "FILTER(h,1,3,0);", "}", "#undef FILTER\n}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 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 ], [ 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 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275, 277 ], [ 279 ], [ 281, 283 ], [ 285, 287 ], [ 291, 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317, 319 ], [ 321 ], [ 323, 325 ], [ 327 ], [ 329 ], [ 331, 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345, 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357, 359 ], [ 361 ] ]

[ "static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)\n{", "if (!pci_bus_is_express(VAR_0->bus)) {", "error_setg(VAR_1, \"pxb-pcie devices cannot reside on a PCI bus\");", "return;", "}", "pxb_dev_realize_common(VAR_0, true, VAR_1);", "}" ]

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

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

[ "static int FUNC_0(int VAR_0, float64 VAR_1, float64 VAR_2 STATUS_PARAM)\n{", "if (float64_is_signaling_nan(VAR_1) ||\nfloat64_is_signaling_nan(VAR_2) ||\n(VAR_0 && (float64_is_nan(VAR_1) || float64_is_nan(VAR_2)))) {", "float_raise(float_flag_invalid, status);", "return 1;", "} else if (float64_is_nan(VAR_1) || float64_is_nan(VAR_2)) {", "return 1;", "} else {", "return 0;", "}", "}" ]

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

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

[ "static void FUNC_0(Visitor *VAR_0, const char *VAR_1, char **VAR_2,\nError **VAR_3)\n{", "QmpInputVisitor *qiv = to_qiv(VAR_0);", "QObject *qobj = qmp_input_get_object(qiv, VAR_1, true, VAR_3);", "QString *qstr;", "*VAR_2 = NULL;", "if (!qobj) {", "return;", "}", "qstr = qobject_to_qstring(qobj);", "if (!qstr) {", "error_setg(VAR_3, QERR_INVALID_PARAMETER_TYPE, VAR_1 ? VAR_1 : \"null\",\n\"string\");", "return;", "}", "*VAR_2 = g_strdup(qstring_get_str(qstr));", "}" ]

[ 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 ], [ 37 ], [ 39 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1, int VAR_2)\n{", "BDRVCURLState *s = VAR_0->opaque;", "CURLState *state = NULL;", "double VAR_3;", "#define RA_OPTSTR \":readahead=\"\nchar *VAR_4;", "char *VAR_5;", "const char *VAR_6;", "int VAR_7 = 0;", "static int VAR_8 = 0;", "VAR_4 = strdup(VAR_1);", "s->readahead_size = READ_AHEAD_SIZE;", "VAR_5 = VAR_4 + strlen(VAR_4) - 1;", "while (VAR_5 >= VAR_4) {", "if (VAR_7 == 0) {", "if (*VAR_5 == ':')\nVAR_7++;", "else\nbreak;", "} else if (VAR_7 == 1) {", "if (*VAR_5 > '9' || *VAR_5 < '0') {", "char *VAR_9 = VAR_5 - strlen(RA_OPTSTR) + 1;", "if (VAR_9 > VAR_4 &&\nstrncmp(VAR_9, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) {", "VAR_6 = VAR_5 + 1;", "VAR_5 -= strlen(RA_OPTSTR) - 1;", "*VAR_5 = '\\0';", "s->readahead_size = atoi(VAR_6);", "break;", "} else {", "break;", "}", "}", "}", "VAR_5--;", "}", "if ((s->readahead_size & 0x1ff) != 0) {", "fprintf(stderr, \"HTTP_READAHEAD_SIZE %Zd is not a multiple of 512\\n\",\ns->readahead_size);", "goto out_noclean;", "}", "if (!VAR_8) {", "curl_global_init(CURL_GLOBAL_ALL);", "VAR_8 = 1;", "}", "DPRINTF(\"CURL: Opening %s\\n\", VAR_4);", "s->url = VAR_4;", "state = curl_init_state(s);", "if (!state)\ngoto out_noclean;", "curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);", "curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_size_cb);", "if (curl_easy_perform(state->curl))\ngoto out;", "curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &VAR_3);", "curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);", "curl_easy_setopt(state->curl, CURLOPT_NOBODY, 0);", "if (VAR_3)\ns->len = (size_t)VAR_3;", "else if(!s->len)\ngoto out;", "DPRINTF(\"CURL: Size = %lld\\n\", (long long)s->len);", "curl_clean_state(state);", "curl_easy_cleanup(state->curl);", "state->curl = NULL;", "s->multi = curl_multi_init();", "curl_multi_setopt( s->multi, CURLMOPT_SOCKETDATA, s);", "curl_multi_setopt( s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb );", "curl_multi_do(s);", "return 0;", "out:\nfprintf(stderr, \"CURL: Error opening VAR_4: %s\\n\", state->errmsg);", "curl_easy_cleanup(state->curl);", "state->curl = NULL;", "out_noclean:\nqemu_free(VAR_4);", "return -EINVAL;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 29 ], [ 31 ], [ 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, 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115, 117 ], [ 125 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139, 141 ], [ 143, 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 187, 189 ], [ 191 ], [ 193 ] ]

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "TCGv t0;", "gen_set_access_type(VAR_0, ACCESS_RES);", "t0 = tcg_temp_local_new();", "gen_addr_reg_index(VAR_0, t0);", "gen_check_align(VAR_0, t0, 0x07);", "gen_qemu_ld64(VAR_0, cpu_gpr[rD(VAR_0->opcode)], t0);", "tcg_gen_mov_tl(cpu_reserve, t0);", "tcg_temp_free(t0);", "}" ]

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

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

[ "static void FUNC_0(VirtIODevice *VAR_0, VirtQueue *VAR_1)\n{", "VirtIOSCSI *s = (VirtIOSCSI *)VAR_0;", "VirtIOSCSIReq *req;", "while ((req = virtio_scsi_pop_req(s, VAR_1))) {", "int VAR_2;", "if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0,\n&VAR_2, sizeof(VAR_2)) < sizeof(VAR_2)) {", "virtio_scsi_bad_req();", "continue;", "}", "tswap32s(&req->req.tmf->VAR_2);", "if (req->req.tmf->VAR_2 == VIRTIO_SCSI_T_TMF) {", "if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlTMFReq),\nsizeof(VirtIOSCSICtrlTMFResp)) < 0) {", "virtio_scsi_bad_req();", "} else {", "virtio_scsi_do_tmf(s, req);", "}", "} else if (req->req.tmf->VAR_2 == VIRTIO_SCSI_T_AN_QUERY ||", "req->req.tmf->VAR_2 == VIRTIO_SCSI_T_AN_SUBSCRIBE) {", "if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlANReq),\nsizeof(VirtIOSCSICtrlANResp)) < 0) {", "virtio_scsi_bad_req();", "} else {", "req->resp.an->event_actual = 0;", "req->resp.an->response = VIRTIO_SCSI_S_OK;", "}", "}", "virtio_scsi_complete_req(req);", "}", "}" ]

[ 0, 0, 0, 0, 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 ], [ 17, 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ] ]

[ "void FUNC_0(ARMCPU *VAR_0)\n{", "CPUARMState *env = &VAR_0->env;", "if (arm_feature(env, ARM_FEATURE_V7)) {", "set_feature(env, ARM_FEATURE_VAPA);", "set_feature(env, ARM_FEATURE_THUMB2);", "set_feature(env, ARM_FEATURE_MPIDR);", "if (!arm_feature(env, ARM_FEATURE_M)) {", "set_feature(env, ARM_FEATURE_V6K);", "} else {", "set_feature(env, ARM_FEATURE_V6);", "if (arm_feature(env, ARM_FEATURE_V6K)) {", "set_feature(env, ARM_FEATURE_V6);", "set_feature(env, ARM_FEATURE_MVFR);", "if (arm_feature(env, ARM_FEATURE_V6)) {", "set_feature(env, ARM_FEATURE_V5);", "if (!arm_feature(env, ARM_FEATURE_M)) {", "set_feature(env, ARM_FEATURE_AUXCR);", "if (arm_feature(env, ARM_FEATURE_V5)) {", "set_feature(env, ARM_FEATURE_V4T);", "if (arm_feature(env, ARM_FEATURE_M)) {", "set_feature(env, ARM_FEATURE_THUMB_DIV);", "if (arm_feature(env, ARM_FEATURE_ARM_DIV)) {", "set_feature(env, ARM_FEATURE_THUMB_DIV);", "if (arm_feature(env, ARM_FEATURE_VFP4)) {", "set_feature(env, ARM_FEATURE_VFP3);", "if (arm_feature(env, ARM_FEATURE_VFP3)) {", "set_feature(env, ARM_FEATURE_VFP);", "register_cp_regs_for_features(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, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 46 ], [ 48 ], [ 50 ], [ 52 ], [ 56 ], [ 58 ], [ 61 ], [ 63 ], [ 66 ], [ 68 ], [ 71 ], [ 73 ], [ 76 ], [ 78 ], [ 86 ] ]

[ "static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "MPCContext *c = VAR_0->priv_data;", "GetBitContext gb;", "uint8_t *bits;", "int VAR_6, VAR_7;", "int VAR_8 = -1;", "Band *bands = c->bands;", "int VAR_9, VAR_10;", "int VAR_11, VAR_12;", "memset(bands, 0, sizeof(*bands) * (c->maxbands + 1));", "if(VAR_5 <= 4){", "av_log(VAR_0, AV_LOG_ERROR, \"Too small buffer passed (%VAR_6 bytes)\\n\", VAR_5);", "return AVERROR(EINVAL);", "}", "c->frame.nb_samples = VAR_4[1] ? c->lastframelen : MPC_FRAME_SIZE;", "if ((VAR_10 = VAR_0->get_buffer(VAR_0, &c->frame)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return VAR_10;", "}", "bits = av_malloc(((VAR_5 - 1) & ~3) + FF_INPUT_BUFFER_PADDING_SIZE);", "c->dsp.bswap_buf((uint32_t*)bits, (const uint32_t*)(VAR_4 + 4), (VAR_5 - 4) >> 2);", "init_get_bits(&gb, bits, (VAR_5 - 4)* 8);", "skip_bits_long(&gb, VAR_4[0]);", "for(VAR_6 = 0; VAR_6 <= c->maxbands; VAR_6++){", "for(VAR_7 = 0; VAR_7 < 2; VAR_7++){", "int t = 4;", "if(VAR_6) t = get_vlc2(&gb, hdr_vlc.table, MPC7_HDR_BITS, 1) - 5;", "if(t == 4) bands[VAR_6].res[VAR_7] = get_bits(&gb, 4);", "else bands[VAR_6].res[VAR_7] = bands[VAR_6-1].res[VAR_7] + t;", "}", "if(bands[VAR_6].res[0] || bands[VAR_6].res[1]){", "VAR_8 = VAR_6;", "if(c->MSS) bands[VAR_6].msf = get_bits1(&gb);", "}", "}", "for(VAR_6 = 0; VAR_6 <= VAR_8; VAR_6++)", "for(VAR_7 = 0; VAR_7 < 2; VAR_7++)", "if(bands[VAR_6].res[VAR_7]) bands[VAR_6].scfi[VAR_7] = get_vlc2(&gb, scfi_vlc.table, MPC7_SCFI_BITS, 1);", "for(VAR_6 = 0; VAR_6 <= VAR_8; VAR_6++){", "for(VAR_7 = 0; VAR_7 < 2; VAR_7++){", "if(bands[VAR_6].res[VAR_7]){", "bands[VAR_6].scf_idx[VAR_7][2] = c->oldDSCF[VAR_7][VAR_6];", "bands[VAR_6].scf_idx[VAR_7][0] = get_scale_idx(&gb, bands[VAR_6].scf_idx[VAR_7][2]);", "switch(bands[VAR_6].scfi[VAR_7]){", "case 0:\nbands[VAR_6].scf_idx[VAR_7][1] = get_scale_idx(&gb, bands[VAR_6].scf_idx[VAR_7][0]);", "bands[VAR_6].scf_idx[VAR_7][2] = get_scale_idx(&gb, bands[VAR_6].scf_idx[VAR_7][1]);", "break;", "case 1:\nbands[VAR_6].scf_idx[VAR_7][1] = get_scale_idx(&gb, bands[VAR_6].scf_idx[VAR_7][0]);", "bands[VAR_6].scf_idx[VAR_7][2] = bands[VAR_6].scf_idx[VAR_7][1];", "break;", "case 2:\nbands[VAR_6].scf_idx[VAR_7][1] = bands[VAR_6].scf_idx[VAR_7][0];", "bands[VAR_6].scf_idx[VAR_7][2] = get_scale_idx(&gb, bands[VAR_6].scf_idx[VAR_7][1]);", "break;", "case 3:\nbands[VAR_6].scf_idx[VAR_7][2] = bands[VAR_6].scf_idx[VAR_7][1] = bands[VAR_6].scf_idx[VAR_7][0];", "break;", "}", "c->oldDSCF[VAR_7][VAR_6] = bands[VAR_6].scf_idx[VAR_7][2];", "}", "}", "}", "memset(c->Q, 0, sizeof(c->Q));", "VAR_9 = 0;", "for(VAR_6 = 0; VAR_6 < BANDS; VAR_6++, VAR_9 += SAMPLES_PER_BAND)", "for(VAR_7 = 0; VAR_7 < 2; VAR_7++)", "idx_to_quant(c, &gb, bands[VAR_6].res[VAR_7], c->Q[VAR_7] + VAR_9);", "ff_mpc_dequantize_and_synth(c, VAR_8, c->frame.VAR_1[0], 2);", "av_free(bits);", "VAR_11 = get_bits_count(&gb);", "VAR_12 = (VAR_5 - 4) * 8;", "if(!VAR_4[1] && ((VAR_12 < VAR_11) || (VAR_11 + 32 <= VAR_12))){", "av_log(NULL,0, \"Error decoding frame: used %VAR_6 of %VAR_6 bits\\n\", VAR_11, VAR_12);", "return -1;", "}", "if(c->frames_to_skip){", "c->frames_to_skip--;", "*VAR_2 = 0;", "return VAR_5;", "}", "*VAR_2 = 1;", "*(AVFrame *)VAR_1 = c->frame;", "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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 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 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ], [ 209 ], [ 211 ] ]

[ "static void FUNC_0(ReplicationState *VAR_0, ReplicationMode VAR_1,\nError **VAR_2)\n{", "BlockDriverState *bs = VAR_0->opaque;", "BDRVReplicationState *s;", "BlockDriverState *top_bs;", "int64_t active_length, hidden_length, disk_length;", "AioContext *aio_context;", "Error *local_err = NULL;", "BlockJob *job;", "aio_context = bdrv_get_aio_context(bs);", "aio_context_acquire(aio_context);", "s = bs->opaque;", "if (s->stage != BLOCK_REPLICATION_NONE) {", "error_setg(VAR_2, \"Block replication is running or done\");", "aio_context_release(aio_context);", "return;", "}", "if (s->VAR_1 != VAR_1) {", "error_setg(VAR_2, \"The parameter VAR_1's value is invalid, needs %d,\"\n\" but got %d\", s->VAR_1, VAR_1);", "aio_context_release(aio_context);", "return;", "}", "switch (s->VAR_1) {", "case REPLICATION_MODE_PRIMARY:\nbreak;", "case REPLICATION_MODE_SECONDARY:\ns->active_disk = bs->file;", "if (!s->active_disk || !s->active_disk->bs ||\n!s->active_disk->bs->backing) {", "error_setg(VAR_2, \"Active disk doesn't have backing file\");", "aio_context_release(aio_context);", "return;", "}", "s->hidden_disk = s->active_disk->bs->backing;", "if (!s->hidden_disk->bs || !s->hidden_disk->bs->backing) {", "error_setg(VAR_2, \"Hidden disk doesn't have backing file\");", "aio_context_release(aio_context);", "return;", "}", "s->secondary_disk = s->hidden_disk->bs->backing;", "if (!s->secondary_disk->bs || !bdrv_has_blk(s->secondary_disk->bs)) {", "error_setg(VAR_2, \"The secondary disk doesn't have block backend\");", "aio_context_release(aio_context);", "return;", "}", "active_length = bdrv_getlength(s->active_disk->bs);", "hidden_length = bdrv_getlength(s->hidden_disk->bs);", "disk_length = bdrv_getlength(s->secondary_disk->bs);", "if (active_length < 0 || hidden_length < 0 || disk_length < 0 ||\nactive_length != hidden_length || hidden_length != disk_length) {", "error_setg(VAR_2, \"Active disk, hidden disk, secondary disk's length\"\n\" are not the same\");", "aio_context_release(aio_context);", "return;", "}", "if (!s->active_disk->bs->drv->bdrv_make_empty ||\n!s->hidden_disk->bs->drv->bdrv_make_empty) {", "error_setg(VAR_2,\n\"Active disk or hidden disk doesn't support make_empty\");", "aio_context_release(aio_context);", "return;", "}", "reopen_backing_file(bs, true, &local_err);", "if (local_err) {", "error_propagate(VAR_2, local_err);", "aio_context_release(aio_context);", "return;", "}", "error_setg(&s->blocker,\n\"Block device is in use by internal backup job\");", "top_bs = bdrv_lookup_bs(s->top_id, s->top_id, NULL);", "if (!top_bs || !bdrv_is_root_node(top_bs) ||\n!check_top_bs(top_bs, bs)) {", "error_setg(VAR_2, \"No top_bs or it is invalid\");", "reopen_backing_file(bs, false, NULL);", "aio_context_release(aio_context);", "return;", "}", "bdrv_op_block_all(top_bs, s->blocker);", "bdrv_op_unblock(top_bs, BLOCK_OP_TYPE_DATAPLANE, s->blocker);", "job = backup_job_create(NULL, s->secondary_disk->bs, s->hidden_disk->bs,\n0, MIRROR_SYNC_MODE_NONE, NULL, false,\nBLOCKDEV_ON_ERROR_REPORT,\nBLOCKDEV_ON_ERROR_REPORT, BLOCK_JOB_INTERNAL,\nbackup_job_completed, bs, NULL, &local_err);", "if (local_err) {", "error_propagate(VAR_2, local_err);", "backup_job_cleanup(bs);", "aio_context_release(aio_context);", "return;", "}", "block_job_start(job);", "break;", "default:\naio_context_release(aio_context);", "abort();", "}", "s->stage = BLOCK_REPLICATION_RUNNING;", "if (s->VAR_1 == REPLICATION_MODE_SECONDARY) {", "secondary_do_checkpoint(s, VAR_2);", "}", "s->error = 0;", "aio_context_release(aio_context);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 11 ], [ 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 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 49 ], [ 50 ], [ 51 ], [ 52, 53 ], [ 54, 55 ], [ 56 ], [ 57 ], [ 58 ], [ 59, 60 ], [ 61, 62 ], [ 63 ], [ 64 ], [ 65 ], [ 67 ], [ 68 ], [ 69 ], [ 70 ], [ 71 ], [ 72 ], [ 74, 75 ], [ 76 ], [ 77, 78 ], [ 79 ], [ 80 ], [ 81 ], [ 82 ], [ 83 ], [ 84 ], [ 85 ], [ 86, 87, 88, 89, 90 ], [ 91 ], [ 92 ], [ 93 ], [ 94 ], [ 95 ], [ 96 ], [ 97 ], [ 98 ], [ 99, 100 ], [ 101 ], [ 102 ], [ 103 ], [ 104 ], [ 105 ], [ 106 ], [ 107 ], [ 108 ], [ 109 ] ]

[ "uint8_t* FUNC_0(FFAMediaCodec* codec, size_t idx, size_t *out_size)\n{", "uint8_t *ret = NULL;", "JNIEnv *env = NULL;", "jobject buffer = NULL;", "JNI_GET_ENV_OR_RETURN(env, codec, NULL);", "if (codec->has_get_i_o_buffer) {", "buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_id, idx);", "if (ff_jni_exception_check(env, 1, codec) < 0) {", "goto fail;", "}", "} else {", "if (!codec->output_buffers) {", "codec->output_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffers_id);", "if (ff_jni_exception_check(env, 1, codec) < 0) {", "goto fail;", "}", "codec->output_buffers = (*env)->NewGlobalRef(env, codec->output_buffers);", "if (ff_jni_exception_check(env, 1, codec) < 0) {", "goto fail;", "}", "}", "buffer = (*env)->GetObjectArrayElement(env, codec->output_buffers, idx);", "if (ff_jni_exception_check(env, 1, codec) < 0) {", "goto fail;", "}", "}", "ret = (*env)->GetDirectBufferAddress(env, buffer);", "*out_size = (*env)->GetDirectBufferCapacity(env, buffer);", "fail:\nif (buffer) {", "(*env)->DeleteLocalRef(env, buffer);", "}", "return ret;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ] ]

[ "int FUNC_0(ArchDumpInfo *VAR_0,\nconst struct GuestPhysBlockList *VAR_1)\n{", "PowerPCCPU *cpu = POWERPC_CPU(first_cpu);", "PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);", "VAR_0->d_machine = EM_PPC64;", "VAR_0->d_class = ELFCLASS64;", "if ((*pcc->interrupts_big_endian)(cpu)) {", "VAR_0->d_endian = ELFDATA2MSB;", "} else {", "VAR_0->d_endian = ELFDATA2LSB;", "return 0;" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1, int VAR_2)\n{", "int VAR_3 = 0;", "int VAR_4 = 0;", "AVFrame *frame = NULL;", "int VAR_5 = VAR_0->VAR_5;", "if (!avcodec_is_open(VAR_0)) {", "const AVCodec *VAR_6 = avcodec_find_decoder(VAR_0->codec_id);", "VAR_3 = avcodec_open2(VAR_0, VAR_6, NULL);", "if (VAR_3 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Failed to open VAR_6\\n\");", "goto end;", "}", "}", "frame = av_frame_alloc();", "if (!frame) {", "av_log(NULL, AV_LOG_ERROR, \"Failed to allocate frame\\n\");", "goto end;", "}", "if (!VAR_2 && VAR_0->VAR_6->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM) {", "VAR_0->VAR_5 = AVDISCARD_ALL;", "}", "do {", "VAR_3 = avcodec_decode_video2(VAR_0, frame, &VAR_4, VAR_1);", "av_assert0(VAR_2 || (!VAR_2 && !VAR_4));", "if (VAR_3 < 0)\nbreak;", "VAR_1->data += VAR_3;", "VAR_1->size -= VAR_3;", "if (VAR_4) {", "break;", "}", "} while (VAR_1->size > 0);", "end:\nVAR_0->VAR_5 = VAR_5;", "av_frame_free(&frame);", "return VAR_3;", "}" ]

[ 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81, 83 ], [ 87 ], [ 89 ], [ 91 ] ]

[ "static int FUNC_0(TiffContext *VAR_0, AVFrame *VAR_1)\n{", "unsigned VAR_2, VAR_3, VAR_4, VAR_5, VAR_6 = 0, VAR_7 = 0;", "int VAR_8, VAR_9;", "int VAR_10;", "int VAR_11;", "double *VAR_12;", "VAR_11 = ff_tread_tag(&VAR_0->gb, VAR_0->le, &VAR_2, &VAR_3, &VAR_4, &VAR_9);", "if (VAR_11 < 0) {", "goto end;", "}", "VAR_5 = bytestream2_tell(&VAR_0->gb);", "if (VAR_4 == 1) {", "switch (VAR_3) {", "case TIFF_BYTE:\ncase TIFF_SHORT:\ncase TIFF_LONG:\nVAR_6 = ff_tget(&VAR_0->gb, VAR_3, VAR_0->le);", "break;", "case TIFF_RATIONAL:\nVAR_6 = ff_tget(&VAR_0->gb, TIFF_LONG, VAR_0->le);", "VAR_7 = ff_tget(&VAR_0->gb, TIFF_LONG, VAR_0->le);", "break;", "case TIFF_STRING:\nif (VAR_4 <= 4) {", "break;", "}", "default:\nVAR_6 = UINT_MAX;", "}", "}", "switch (VAR_2) {", "case TIFF_WIDTH:\nVAR_0->width = VAR_6;", "break;", "case TIFF_HEIGHT:\nVAR_0->height = VAR_6;", "break;", "case TIFF_BPP:\nVAR_0->bppcount = VAR_4;", "if (VAR_4 > 4) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"This format is not supported (bpp=%d, %d components)\\n\",\nVAR_0->bpp, VAR_4);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_4 == 1)\nVAR_0->bpp = VAR_6;", "else {", "switch (VAR_3) {", "case TIFF_BYTE:\ncase TIFF_SHORT:\ncase TIFF_LONG:\nVAR_0->bpp = 0;", "if (bytestream2_get_bytes_left(&VAR_0->gb) < type_sizes[VAR_3] * VAR_4)\nreturn AVERROR_INVALIDDATA;", "for (VAR_8 = 0; VAR_8 < VAR_4; VAR_8++)", "VAR_0->bpp += ff_tget(&VAR_0->gb, VAR_3, VAR_0->le);", "break;", "default:\nVAR_0->bpp = -1;", "}", "}", "break;", "case TIFF_SAMPLES_PER_PIXEL:\nif (VAR_4 != 1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Samples per pixel requires a single VAR_6, many provided\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_6 > 4U) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Samples per pixel %d is too large\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_0->bppcount == 1)\nVAR_0->bpp *= VAR_6;", "VAR_0->bppcount = VAR_6;", "break;", "case TIFF_COMPR:\nVAR_0->compr = VAR_6;", "VAR_0->predictor = 0;", "switch (VAR_0->compr) {", "case TIFF_RAW:\ncase TIFF_PACKBITS:\ncase TIFF_LZW:\ncase TIFF_CCITT_RLE:\nbreak;", "case TIFF_G3:\ncase TIFF_G4:\nVAR_0->fax_opts = 0;", "break;", "case TIFF_DEFLATE:\ncase TIFF_ADOBE_DEFLATE:\n#if CONFIG_ZLIB\nbreak;", "#else\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Deflate: ZLib not compiled in\\n\");", "return AVERROR(ENOSYS);", "#endif\ncase TIFF_JPEG:\ncase TIFF_NEWJPEG:\navpriv_report_missing_feature(VAR_0->avctx, \"JPEG compression\");", "return AVERROR_PATCHWELCOME;", "case TIFF_LZMA:\n#if CONFIG_LZMA\nbreak;", "#else\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"LZMA not compiled in\\n\");", "return AVERROR(ENOSYS);", "#endif\ndefault:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Unknown compression method %VAR_8\\n\",\nVAR_0->compr);", "return AVERROR_INVALIDDATA;", "}", "break;", "case TIFF_ROWSPERSTRIP:\nif (!VAR_6 || (VAR_3 == TIFF_LONG && VAR_6 == UINT_MAX))\nVAR_6 = VAR_0->height;", "VAR_0->rps = FFMIN(VAR_6, VAR_0->height);", "break;", "case TIFF_STRIP_OFFS:\nif (VAR_4 == 1) {", "VAR_0->strippos = 0;", "VAR_0->stripoff = VAR_6;", "} else", "VAR_0->strippos = VAR_5;", "VAR_0->strips = VAR_4;", "if (VAR_0->strips == 1)\nVAR_0->rps = VAR_0->height;", "VAR_0->sot = VAR_3;", "break;", "case TIFF_STRIP_SIZE:\nif (VAR_4 == 1) {", "VAR_0->stripsizesoff = 0;", "VAR_0->stripsize = VAR_6;", "VAR_0->strips = 1;", "} else {", "VAR_0->stripsizesoff = VAR_5;", "}", "VAR_0->strips = VAR_4;", "VAR_0->sstype = VAR_3;", "break;", "case TIFF_XRES:\ncase TIFF_YRES:\nset_sar(VAR_0, VAR_2, VAR_6, VAR_7);", "break;", "case TIFF_TILE_BYTE_COUNTS:\ncase TIFF_TILE_LENGTH:\ncase TIFF_TILE_OFFSETS:\ncase TIFF_TILE_WIDTH:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Tiled images are not supported\\n\");", "return AVERROR_PATCHWELCOME;", "break;", "case TIFF_PREDICTOR:\nVAR_0->predictor = VAR_6;", "break;", "case TIFF_PHOTOMETRIC:\nswitch (VAR_6) {", "case TIFF_PHOTOMETRIC_WHITE_IS_ZERO:\ncase TIFF_PHOTOMETRIC_BLACK_IS_ZERO:\ncase TIFF_PHOTOMETRIC_RGB:\ncase TIFF_PHOTOMETRIC_PALETTE:\ncase TIFF_PHOTOMETRIC_YCBCR:\nVAR_0->photometric = VAR_6;", "break;", "case TIFF_PHOTOMETRIC_ALPHA_MASK:\ncase TIFF_PHOTOMETRIC_SEPARATED:\ncase TIFF_PHOTOMETRIC_CIE_LAB:\ncase TIFF_PHOTOMETRIC_ICC_LAB:\ncase TIFF_PHOTOMETRIC_ITU_LAB:\ncase TIFF_PHOTOMETRIC_CFA:\ncase TIFF_PHOTOMETRIC_LOG_L:\ncase TIFF_PHOTOMETRIC_LOG_LUV:\ncase TIFF_PHOTOMETRIC_LINEAR_RAW:\navpriv_report_missing_feature(VAR_0->avctx,\n\"PhotometricInterpretation 0x%04X\",\nVAR_6);", "return AVERROR_PATCHWELCOME;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"PhotometricInterpretation %u is \"\n\"unknown\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "break;", "case TIFF_FILL_ORDER:\nif (VAR_6 < 1 || VAR_6 > 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Unknown FillOrder VAR_6 %d, trying default one\\n\", VAR_6);", "VAR_6 = 1;", "}", "VAR_0->fill_order = VAR_6 - 1;", "break;", "case TIFF_PAL: {", "GetByteContext pal_gb[3];", "VAR_5 = type_sizes[VAR_3];", "if (VAR_4 / 3 > 256 ||\nbytestream2_get_bytes_left(&VAR_0->gb) < VAR_4 / 3 * VAR_5 * 3)\nreturn AVERROR_INVALIDDATA;", "pal_gb[0] = pal_gb[1] = pal_gb[2] = VAR_0->gb;", "bytestream2_skip(&pal_gb[1], VAR_4 / 3 * VAR_5);", "bytestream2_skip(&pal_gb[2], VAR_4 / 3 * VAR_5 * 2);", "VAR_5 = (type_sizes[VAR_3] - 1) << 3;", "for (VAR_8 = 0; VAR_8 < VAR_4 / 3; VAR_8++) {", "uint32_t p = 0xFF000000;", "p |= (ff_tget(&pal_gb[0], VAR_3, VAR_0->le) >> VAR_5) << 16;", "p |= (ff_tget(&pal_gb[1], VAR_3, VAR_0->le) >> VAR_5) << 8;", "p |= ff_tget(&pal_gb[2], VAR_3, VAR_0->le) >> VAR_5;", "VAR_0->palette[VAR_8] = p;", "}", "VAR_0->palette_is_set = 1;", "break;", "}", "case TIFF_PLANAR:\nVAR_0->planar = VAR_6 == 2;", "break;", "case TIFF_YCBCR_SUBSAMPLING:\nif (VAR_4 != 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"subsample VAR_4 invalid\\n\");", "return AVERROR_INVALIDDATA;", "}", "for (VAR_8 = 0; VAR_8 < VAR_4; VAR_8++)", "VAR_0->subsampling[VAR_8] = ff_tget(&VAR_0->gb, VAR_3, VAR_0->le);", "break;", "case TIFF_T4OPTIONS:\nif (VAR_0->compr == TIFF_G3)\nVAR_0->fax_opts = VAR_6;", "break;", "case TIFF_T6OPTIONS:\nif (VAR_0->compr == TIFF_G4)\nVAR_0->fax_opts = VAR_6;", "break;", "#define ADD_METADATA(VAR_4, name, sep)\\\nif ((VAR_11 = add_metadata(VAR_4, VAR_3, name, sep, VAR_0, VAR_1)) < 0) {\\", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");\\", "goto end;\\", "}", "case TIFF_MODEL_PIXEL_SCALE:\nADD_METADATA(VAR_4, \"ModelPixelScaleTag\", NULL);", "break;", "case TIFF_MODEL_TRANSFORMATION:\nADD_METADATA(VAR_4, \"ModelTransformationTag\", NULL);", "break;", "case TIFF_MODEL_TIEPOINT:\nADD_METADATA(VAR_4, \"ModelTiepointTag\", NULL);", "break;", "case TIFF_GEO_KEY_DIRECTORY:\nADD_METADATA(1, \"GeoTIFF_Version\", NULL);", "ADD_METADATA(2, \"GeoTIFF_Key_Revision\", \".\");", "VAR_0->geotag_count = ff_tget_short(&VAR_0->gb, VAR_0->le);", "if (VAR_0->geotag_count > VAR_4 / 4 - 1) {", "VAR_0->geotag_count = VAR_4 / 4 - 1;", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"GeoTIFF key directory buffer shorter than specified\\n\");", "}", "if (bytestream2_get_bytes_left(&VAR_0->gb) < VAR_0->geotag_count * sizeof(int16_t) * 4) {", "VAR_0->geotag_count = 0;", "return -1;", "}", "VAR_0->geotags = av_mallocz_array(VAR_0->geotag_count, sizeof(TiffGeoTag));", "if (!VAR_0->geotags) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "VAR_0->geotag_count = 0;", "goto end;", "}", "for (VAR_8 = 0; VAR_8 < VAR_0->geotag_count; VAR_8++) {", "VAR_0->geotags[VAR_8].key = ff_tget_short(&VAR_0->gb, VAR_0->le);", "VAR_0->geotags[VAR_8].VAR_3 = ff_tget_short(&VAR_0->gb, VAR_0->le);", "VAR_0->geotags[VAR_8].VAR_4 = ff_tget_short(&VAR_0->gb, VAR_0->le);", "if (!VAR_0->geotags[VAR_8].VAR_3)\nVAR_0->geotags[VAR_8].val = get_geokey_val(VAR_0->geotags[VAR_8].key, ff_tget_short(&VAR_0->gb, VAR_0->le));", "else\nVAR_0->geotags[VAR_8].offset = ff_tget_short(&VAR_0->gb, VAR_0->le);", "}", "break;", "case TIFF_GEO_DOUBLE_PARAMS:\nif (VAR_4 >= INT_MAX / sizeof(int64_t))\nreturn AVERROR_INVALIDDATA;", "if (bytestream2_get_bytes_left(&VAR_0->gb) < VAR_4 * sizeof(int64_t))\nreturn AVERROR_INVALIDDATA;", "VAR_12 = av_malloc_array(VAR_4, sizeof(double));", "if (!VAR_12) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "goto end;", "}", "for (VAR_8 = 0; VAR_8 < VAR_4; VAR_8++)", "VAR_12[VAR_8] = ff_tget_double(&VAR_0->gb, VAR_0->le);", "for (VAR_8 = 0; VAR_8 < VAR_0->geotag_count; VAR_8++) {", "if (VAR_0->geotags[VAR_8].VAR_3 == TIFF_GEO_DOUBLE_PARAMS) {", "if (VAR_0->geotags[VAR_8].VAR_4 == 0\n|| VAR_0->geotags[VAR_8].offset + VAR_0->geotags[VAR_8].VAR_4 > VAR_4) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Invalid GeoTIFF key %d\\n\", VAR_0->geotags[VAR_8].key);", "} else {", "char *ap = doubles2str(&VAR_12[VAR_0->geotags[VAR_8].offset], VAR_0->geotags[VAR_8].VAR_4, \", \");", "if (!ap) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "av_freep(&VAR_12);", "return AVERROR(ENOMEM);", "}", "VAR_0->geotags[VAR_8].val = ap;", "}", "}", "}", "av_freep(&VAR_12);", "break;", "case TIFF_GEO_ASCII_PARAMS:\nVAR_10 = bytestream2_tell(&VAR_0->gb);", "for (VAR_8 = 0; VAR_8 < VAR_0->geotag_count; VAR_8++) {", "if (VAR_0->geotags[VAR_8].VAR_3 == TIFF_GEO_ASCII_PARAMS) {", "if (VAR_0->geotags[VAR_8].VAR_4 == 0\n|| VAR_0->geotags[VAR_8].offset + VAR_0->geotags[VAR_8].VAR_4 > VAR_4) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Invalid GeoTIFF key %d\\n\", VAR_0->geotags[VAR_8].key);", "} else {", "char *ap;", "bytestream2_seek(&VAR_0->gb, VAR_10 + VAR_0->geotags[VAR_8].offset, SEEK_SET);", "if (bytestream2_get_bytes_left(&VAR_0->gb) < VAR_0->geotags[VAR_8].VAR_4)\nreturn AVERROR_INVALIDDATA;", "ap = av_malloc(VAR_0->geotags[VAR_8].VAR_4);", "if (!ap) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "return AVERROR(ENOMEM);", "}", "bytestream2_get_bufferu(&VAR_0->gb, ap, VAR_0->geotags[VAR_8].VAR_4);", "ap[VAR_0->geotags[VAR_8].VAR_4 - 1] = '\\0';", "VAR_0->geotags[VAR_8].val = ap;", "}", "}", "}", "break;", "case TIFF_ARTIST:\nADD_METADATA(VAR_4, \"artist\", NULL);", "break;", "case TIFF_COPYRIGHT:\nADD_METADATA(VAR_4, \"copyright\", NULL);", "break;", "case TIFF_DATE:\nADD_METADATA(VAR_4, \"date\", NULL);", "break;", "case TIFF_DOCUMENT_NAME:\nADD_METADATA(VAR_4, \"document_name\", NULL);", "break;", "case TIFF_HOST_COMPUTER:\nADD_METADATA(VAR_4, \"computer\", NULL);", "break;", "case TIFF_IMAGE_DESCRIPTION:\nADD_METADATA(VAR_4, \"description\", NULL);", "break;", "case TIFF_MAKE:\nADD_METADATA(VAR_4, \"make\", NULL);", "break;", "case TIFF_MODEL:\nADD_METADATA(VAR_4, \"model\", NULL);", "break;", "case TIFF_PAGE_NAME:\nADD_METADATA(VAR_4, \"page_name\", NULL);", "break;", "case TIFF_PAGE_NUMBER:\nADD_METADATA(VAR_4, \"page_number\", \" / \");", "break;", "case TIFF_SOFTWARE_NAME:\nADD_METADATA(VAR_4, \"software\", NULL);", "break;", "default:\nif (VAR_0->avctx->err_recognition & AV_EF_EXPLODE) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Unknown or unsupported VAR_2 %d/0X%0X\\n\",\nVAR_2, VAR_2);", "return AVERROR_INVALIDDATA;", "}", "}", "end:\nbytestream2_seek(&VAR_0->gb, VAR_9, SEEK_SET);", "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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 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 ], [ 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, 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 ], [ 227, 229, 231, 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241, 243, 245 ], [ 247 ], [ 249 ], [ 251, 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265, 267 ], [ 269 ], [ 271 ], [ 273, 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295, 297, 299 ], [ 301 ], [ 303, 305, 307, 309, 311 ], [ 313 ], [ 315 ], [ 317, 319 ], [ 321 ], [ 323, 325 ], [ 327, 329, 331, 333, 335, 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 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401, 403, 405 ], [ 409 ], [ 411 ], [ 413 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439, 441 ], [ 443 ], [ 445, 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461, 463, 465 ], [ 467 ], [ 469, 471, 473 ], [ 475 ], [ 477, 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487, 489 ], [ 491 ], [ 493, 495 ], [ 497 ], [ 499, 501 ], [ 503 ], [ 505, 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539 ], [ 541 ], [ 543 ], [ 545 ], [ 547 ], [ 551, 553 ], [ 555, 557 ], [ 559 ], [ 561 ], [ 563, 565, 567 ], [ 569, 571 ], [ 573 ], [ 575 ], [ 577 ], [ 579 ], [ 581 ], [ 583 ], [ 585 ], [ 587 ], [ 589 ], [ 591, 593 ], [ 595 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 613 ], [ 615 ], [ 617 ], [ 619 ], [ 621 ], [ 623, 625 ], [ 627 ], [ 629 ], [ 631, 633 ], [ 635 ], [ 637 ], [ 639 ], [ 643 ], [ 645, 647 ], [ 649 ], [ 651 ], [ 653 ], [ 655 ], [ 657 ], [ 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667 ], [ 669 ], [ 671 ], [ 673, 675 ], [ 677 ], [ 679, 681 ], [ 683 ], [ 685, 687 ], [ 689 ], [ 691, 693 ], [ 695 ], [ 697, 699 ], [ 701 ], [ 703, 705 ], [ 707 ], [ 709, 711 ], [ 713 ], [ 715, 717 ], [ 719 ], [ 721, 723 ], [ 725 ], [ 727, 729 ], [ 731 ], [ 733, 735 ], [ 737 ], [ 739, 741 ], [ 743, 745, 747 ], [ 749 ], [ 751 ], [ 753 ], [ 755, 757 ], [ 759 ], [ 761 ] ]

[ "static int FUNC_0(void)\n{", "AVFilterBufferRef *picref;", "AVFrame *filtered_frame = NULL;", "int VAR_0;", "int64_t frame_pts;", "for (VAR_0 = 0; VAR_0 < nb_output_streams; VAR_0++) {", "OutputStream *ost = output_streams[VAR_0];", "OutputFile *of = output_files[ost->file_index];", "int ret = 0;", "if (!ost->filter)\ncontinue;", "if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {", "return AVERROR(ENOMEM);", "} else", "avcodec_get_frame_defaults(ost->filtered_frame);", "filtered_frame = ost->filtered_frame;", "while (1) {", "ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,\nAV_BUFFERSINK_FLAG_NO_REQUEST);", "if (ret < 0) {", "if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {", "char buf[256];", "av_strerror(ret, buf, sizeof(buf));", "av_log(NULL, AV_LOG_WARNING,\n\"Error in av_buffersink_get_buffer_ref(): %s\\n\", buf);", "frame_pts = AV_NOPTS_VALUE;", "if (picref->pts != AV_NOPTS_VALUE) {", "filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,\nost->filter->filter->inputs[0]->time_base,\nost->st->codec->time_base) -\nav_rescale_q(of->start_time,\nAV_TIME_BASE_Q,\nost->st->codec->time_base);", "if (of->start_time && filtered_frame->pts < 0) {", "avfilter_unref_buffer(picref);", "continue;", "switch (ost->filter->filter->inputs[0]->type) {", "case AVMEDIA_TYPE_VIDEO:\navfilter_copy_buf_props(filtered_frame, picref);", "filtered_frame->pts = frame_pts;", "if (!ost->frame_aspect_ratio)\nost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;", "do_video_out(of->ctx, ost, filtered_frame);", "case AVMEDIA_TYPE_AUDIO:\navfilter_copy_buf_props(filtered_frame, picref);", "filtered_frame->pts = frame_pts;", "do_audio_out(of->ctx, ost, filtered_frame);", "default:\nav_assert0(0);", "avfilter_unref_buffer(picref);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 66 ], [ 68 ], [ 70, 72, 74, 76, 78, 80 ], [ 84 ], [ 86 ], [ 88 ], [ 100 ], [ 102, 104 ], [ 106 ], [ 108, 110 ], [ 114 ], [ 117, 119 ], [ 121 ], [ 129 ], [ 132, 136 ], [ 141 ], [ 147 ] ]

[ "static av_always_inline void FUNC_0(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass,\nint pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)\n{", "MpegEncContext * const s = &h->s;", "void (*VAR_0)(uint8_t *VAR_5, DCTELEM *VAR_5, int VAR_5);", "void (*VAR_4)(uint8_t *VAR_5, DCTELEM *VAR_5, int VAR_5);", "int VAR_5;", "int VAR_6 = p == 0 ? s->VAR_6 : h->chroma_qp[p-1];", "block_offset += 16*p;", "if(IS_INTRA4x4(mb_type)){", "if(simple || !s->encoding){", "if(IS_8x8DCT(mb_type)){", "if(transform_bypass){", "VAR_4 =\nVAR_0 = s->dsp.add_pixels8;", "}else{", "VAR_4 = h->h264dsp.h264_idct8_dc_add;", "VAR_0 = h->h264dsp.h264_idct8_add;", "}", "for(VAR_5=0; VAR_5<16; VAR_5+=4){", "uint8_t * const ptr= dest_y + block_offset[VAR_5];", "const int VAR_9= h->intra4x4_pred_mode_cache[ scan8[VAR_5] ];", "if(transform_bypass && h->sps.profile_idc==244 && VAR_9<=1){", "h->hpc.pred8x8l_add[VAR_9](ptr, h->mb + (VAR_5*16+p*256 << pixel_shift), linesize);", "}else{", "const int VAR_9 = h->non_zero_count_cache[ scan8[VAR_5+p*16] ];", "h->hpc.pred8x8l[ VAR_9 ](ptr, (h->topleft_samples_available<<VAR_5)&0x8000,\n(h->topright_samples_available<<VAR_5)&0x4000, linesize);", "if(VAR_9){", "if(VAR_9 == 1 && dctcoef_get(h->mb, pixel_shift, VAR_5*16+p*256))\nVAR_4(ptr, h->mb + (VAR_5*16+p*256 << pixel_shift), linesize);", "else\nVAR_0 (ptr, h->mb + (VAR_5*16+p*256 << pixel_shift), linesize);", "}", "}", "}", "}else{", "if(transform_bypass){", "VAR_4 =\nVAR_0 = s->dsp.add_pixels4;", "}else{", "VAR_4 = h->h264dsp.h264_idct_dc_add;", "VAR_0 = h->h264dsp.h264_idct_add;", "}", "for(VAR_5=0; VAR_5<16; VAR_5++){", "uint8_t * const ptr= dest_y + block_offset[VAR_5];", "const int VAR_9= h->intra4x4_pred_mode_cache[ scan8[VAR_5] ];", "if(transform_bypass && h->sps.profile_idc==244 && VAR_9<=1){", "h->hpc.pred4x4_add[VAR_9](ptr, h->mb + (VAR_5*16+p*256 << pixel_shift), linesize);", "}else{", "uint8_t *topright;", "int VAR_9, VAR_9;", "uint64_t tr_high;", "if(VAR_9 == DIAG_DOWN_LEFT_PRED || VAR_9 == VERT_LEFT_PRED){", "const int VAR_10= (h->topright_samples_available<<VAR_5)&0x8000;", "assert(s->mb_y || linesize <= block_offset[VAR_5]);", "if(!VAR_10){", "if (pixel_shift) {", "tr_high= ((uint16_t*)ptr)[3 - linesize/2]*0x0001000100010001ULL;", "topright= (uint8_t*) &tr_high;", "} else {", "VAR_9= ptr[3 - linesize]*0x01010101;", "topright= (uint8_t*) &VAR_9;", "}", "}else", "topright= ptr + (4 << pixel_shift) - linesize;", "}else", "topright= NULL;", "h->hpc.pred4x4[ VAR_9 ](ptr, topright, linesize);", "VAR_9 = h->non_zero_count_cache[ scan8[VAR_5+p*16] ];", "if(VAR_9){", "if(is_h264){", "if(VAR_9 == 1 && dctcoef_get(h->mb, pixel_shift, VAR_5*16+p*256))\nVAR_4(ptr, h->mb + (VAR_5*16+p*256 << pixel_shift), linesize);", "else\nVAR_0 (ptr, h->mb + (VAR_5*16+p*256 << pixel_shift), linesize);", "}else", "ff_svq3_add_idct_c(ptr, h->mb + VAR_5*16+p*256, linesize, VAR_6, 0);", "}", "}", "}", "}", "}", "}else{", "h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);", "if(is_h264){", "if(h->non_zero_count_cache[ scan8[LUMA_DC_BLOCK_INDEX+p] ]){", "if(!transform_bypass)\nh->h264dsp.h264_luma_dc_dequant_idct(h->mb+(p*256 << pixel_shift), h->mb_luma_dc[p], h->dequant4_coeff[p][VAR_6][0]);", "else{", "static const uint8_t VAR_11[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,", "8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};", "for(VAR_5 = 0; VAR_5 < 16; VAR_5++)", "dctcoef_set(h->mb+p*256, pixel_shift, VAR_11[VAR_5], dctcoef_get(h->mb_luma_dc[p], pixel_shift, VAR_5));", "}", "}", "}else", "ff_svq3_luma_dc_dequant_idct_c(h->mb+p*256, h->mb_luma_dc[p], 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, 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 ]

[ [ 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 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 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 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "ADXDemuxerContext *c = VAR_0->priv_data;", "AVCodecContext *avctx = VAR_0->streams[0]->codec;", "int VAR_2, VAR_3;", "VAR_3 = BLOCK_SIZE * avctx->channels;", "VAR_1->pos = avio_tell(VAR_0->pb);", "VAR_1->stream_index = 0;", "VAR_2 = av_get_packet(VAR_0->pb, VAR_1, VAR_3);", "if (VAR_2 != VAR_3) {", "av_free_packet(VAR_1);", "return VAR_2 < 0 ? VAR_2 : AVERROR(EIO);", "if (AV_RB16(VAR_1->data) & 0x8000) {", "av_free_packet(VAR_1);", "return AVERROR_EOF;", "VAR_1->VAR_3 = VAR_3;", "VAR_1->duration = 1;", "VAR_1->pts = (VAR_1->pos - c->header_size) / VAR_3;", "return 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 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0,\nSCSIGenericReq *VAR_1, int VAR_2,\nBlockDriverCompletionFunc *VAR_3)\n{", "SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, VAR_1->req.dev);", "VAR_1->io_header.interface_id = 'S';", "VAR_1->io_header.dxfer_direction = VAR_2;", "VAR_1->io_header.dxferp = VAR_1->buf;", "VAR_1->io_header.dxfer_len = VAR_1->buflen;", "VAR_1->io_header.cmdp = VAR_1->req.cmd.buf;", "VAR_1->io_header.cmd_len = VAR_1->req.cmd.len;", "VAR_1->io_header.mx_sb_len = sizeof(s->sensebuf);", "VAR_1->io_header.sbp = s->sensebuf;", "VAR_1->io_header.timeout = MAX_UINT;", "VAR_1->io_header.usr_ptr = VAR_1;", "VAR_1->io_header.flags |= SG_FLAG_DIRECT_IO;", "VAR_1->req.aiocb = bdrv_aio_ioctl(VAR_0, SG_IO, &VAR_1->io_header, VAR_3, VAR_1);", "if (VAR_1->req.aiocb == NULL) {", "BADF(\"FUNC_0: read failed !\\n\");", "return -1;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)\n{", "int8_t *v = VAR_1;", "qemu_get_s8s(VAR_0, v);", "return 0;", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, unsigned int VAR_2,\nunsigned int VAR_3, unsigned int VAR_4,\nunsigned int VAR_5, unsigned int VAR_6, unsigned int VAR_7)\n{", "unsupported_encoding(VAR_0, VAR_1);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "qobject_decref(VAR_0->obj);", "VAR_0->obj = NULL;", "if (VAR_0->qiv) {", "visit_free(VAR_0->qiv);", "VAR_0->qiv = NULL;", "}", "}" ]

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

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

[ "int FUNC_0(target_ulong VAR_0,\ntarget_ulong VAR_1, int VAR_2)\n{", "int VAR_3;", "VAR_3 = find_hw_breakpoint(VAR_0, (VAR_2 == GDB_BREAKPOINT_HW) ? 1 : VAR_1, VAR_2);", "if (VAR_3 < 0)\nreturn -ENOENT;", "nb_hw_breakpoint--;", "hw_breakpoint[VAR_3] = hw_breakpoint[nb_hw_breakpoint];", "return 0;", "}" ]

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

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

[ "void FUNC_0(cas2l)(CPUM68KState *env, uint32_t regs, uint32_t a1, uint32_t a2)\n{", "uint32_t Dc1 = extract32(regs, 9, 3);", "uint32_t Dc2 = extract32(regs, 6, 3);", "uint32_t Du1 = extract32(regs, 3, 3);", "uint32_t Du2 = extract32(regs, 0, 3);", "uint32_t c1 = env->dregs[Dc1];", "uint32_t c2 = env->dregs[Dc2];", "uint32_t u1 = env->dregs[Du1];", "uint32_t u2 = env->dregs[Du2];", "uint32_t l1, l2;", "uintptr_t ra = GETPC();", "#if defined(CONFIG_ATOMIC64) && !defined(CONFIG_USER_ONLY)\nint mmu_idx = cpu_mmu_index(env, 0);", "TCGMemOpIdx oi;", "#endif\nif (parallel_cpus) {", "#ifdef CONFIG_ATOMIC64\nuint64_t c, u, l;", "if ((a1 & 7) == 0 && a2 == a1 + 4) {", "c = deposit64(c2, 32, 32, c1);", "u = deposit64(u2, 32, 32, u1);", "#ifdef CONFIG_USER_ONLY\nl = helper_atomic_cmpxchgq_be(env, a1, c, u);", "#else\noi = make_memop_idx(MO_BEQ, mmu_idx);", "l = helper_atomic_cmpxchgq_be_mmu(env, a1, c, u, oi, ra);", "#endif\nl1 = l >> 32;", "l2 = l;", "} else if ((a2 & 7) == 0 && a1 == a2 + 4) {", "c = deposit64(c1, 32, 32, c2);", "u = deposit64(u1, 32, 32, u2);", "#ifdef CONFIG_USER_ONLY\nl = helper_atomic_cmpxchgq_be(env, a2, c, u);", "#else\noi = make_memop_idx(MO_BEQ, mmu_idx);", "l = helper_atomic_cmpxchgq_be_mmu(env, a2, c, u, oi, ra);", "#endif\nl2 = l >> 32;", "l1 = l;", "} else", "#endif\n{", "cpu_loop_exit_atomic(ENV_GET_CPU(env), ra);", "}", "} else {", "l1 = cpu_ldl_data_ra(env, a1, ra);", "l2 = cpu_ldl_data_ra(env, a2, ra);", "if (l1 == c1 && l2 == c2) {", "cpu_stl_data_ra(env, a1, u1, ra);", "cpu_stl_data_ra(env, a2, u2, ra);", "}", "}", "if (c1 != l1) {", "env->cc_n = l1;", "env->cc_v = c1;", "} else {", "env->cc_n = l2;", "env->cc_v = c2;", "}", "env->cc_op = CC_OP_CMPL;", "env->dregs[Dc1] = l1;", "env->dregs[Dc2] = l2;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 35 ], [ 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 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ] ]

[ "static inline hwaddr FUNC_0(uint64_t size)\n{", "return (ffs(size >> 10) - 1) >> 1;", "}" ]

[ 0, 0, 0 ]

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

[ "FUNC_0(struct socket *VAR_0)\n{", "if ((VAR_0->so_state & SS_NOFDREF) == 0) {", "shutdown(VAR_0->s,0);", "if(global_writefds) {", "FD_CLR(VAR_0->s,global_writefds);", "}", "}", "VAR_0->so_state &= ~(SS_ISFCONNECTING);", "if (VAR_0->so_state & SS_FCANTSENDMORE) {", "VAR_0->so_state &= SS_PERSISTENT_MASK;", "VAR_0->so_state |= SS_NOFDREF;", "} else {", "VAR_0->so_state |= SS_FCANTRCVMORE;", "}", "}" ]

[ 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 ] ]

[ "void FUNC_0(CPUState *VAR_0, int VAR_1)\n{", "#if defined(TARGET_HAS_ICE)\nCPUBreakpoint *bp, *next;", "TAILQ_FOREACH_SAFE(bp, &VAR_0->breakpoints, entry, next) {", "if (bp->flags & VAR_1)\ncpu_breakpoint_remove_by_ref(VAR_0, bp);", "}", "#endif\n}" ]

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

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

[ "static void FUNC_0(SCSIDevice *VAR_0)\n{", "SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, VAR_0);", "SCSIGenericReq *r;", "while (!QTAILQ_EMPTY(&s->qdev.requests)) {", "r = DO_UPCAST(SCSIGenericReq, req, QTAILQ_FIRST(&s->qdev.requests));", "scsi_remove_request(r);", "}", "blockdev_mark_auto_del(s->qdev.conf.dinfo->bdrv);", "}" ]

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

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

[ "static inline void FUNC_0(SegmentCache *VAR_0,\nconst struct kqemu_segment_cache *VAR_1)\n{", "VAR_0->selector = VAR_1->selector;", "VAR_0->flags = VAR_1->flags;", "VAR_0->limit = VAR_1->limit;", "VAR_0->base = VAR_1->base;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "struct omap_mpu_timer_s *VAR_4 = (struct omap_mpu_timer_s *) VAR_0;", "if (VAR_3 != 4) {", "return omap_badwidth_write32(VAR_0, VAR_1, VAR_2);", "}", "switch (VAR_1) {", "case 0x00:\nomap_timer_sync(VAR_4);", "VAR_4->enable = (VAR_2 >> 5) & 1;", "VAR_4->ptv = (VAR_2 >> 2) & 7;", "VAR_4->ar = (VAR_2 >> 1) & 1;", "VAR_4->st = VAR_2 & 1;", "omap_timer_update(VAR_4);", "return;", "case 0x04:\nVAR_4->reset_val = VAR_2;", "return;", "case 0x08:\nOMAP_RO_REG(VAR_1);", "break;", "default:\nOMAP_BAD_REG(VAR_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 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41 ], [ 43 ], [ 47, 49 ], [ 51 ], [ 55, 57 ], [ 59 ], [ 61 ] ]

[ "bool FUNC_0(NetClientState *nc)\n{", "if (!nc->peer || !nc->peer->info->has_vnet_hdr) {", "return false;", "}", "return nc->peer->info->has_vnet_hdr(nc->peer);", "}" ]

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

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

[ "static void FUNC_0(NetClientState *VAR_0)\n{", "VMXNET3State *s = qemu_get_nic_opaque(VAR_0);", "s->nic = NULL;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "void FUNC_0(void)\n{", "if (!(env->CP0_Status & (1 << CP0St_CU1))) {", "CALL_FROM_TB2(do_raise_exception_err, EXCP_CpU, 1);", "}", "RETURN();", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, ByteIOContext *VAR_1, AVCodecContext *VAR_2)\n{", "if (VAR_2->extradata_size < FLAC_STREAMINFO_SIZE) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid FLAC extradata\\n\");", "return -1;", "} else if (VAR_2->extradata_size == FLAC_STREAMINFO_SIZE) {", "put_buffer(VAR_1, \"fLaC\", 4);", "put_byte(VAR_1, 0x80);", "put_be24(VAR_1, FLAC_STREAMINFO_SIZE);", "} else if(memcmp(\"fLaC\", VAR_2->extradata, 4)) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid FLAC extradata\\n\");", "return -1;", "}", "put_buffer(VAR_1, VAR_2->extradata, VAR_2->extradata_size);", "return 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ] ]

[ "static void FUNC_0(MemoryListener *VAR_0,\nMemoryRegionSection *VAR_1)\n{", "cpu_register_physical_memory_log(VAR_1, VAR_1->readonly);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(CPUState *VAR_0, target_phys_addr_t VAR_1)\n{", "struct kvm_x86_mce VAR_2 = {", ".bank = 9,\n.status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN\n| MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S\n| 0xc0,\n.mcg_status = MCG_STATUS_MCIP | MCG_STATUS_RIPV,\n.addr = VAR_1,\n.misc = (MCM_ADDR_PHYS << 6) | 0xc,\n};", "int VAR_3;", "VAR_3 = kvm_set_mce(VAR_0, &VAR_2);", "if (VAR_3 < 0) {", "fprintf(stderr, \"kvm_set_mce: %s\\n\", strerror(errno));", "abort();", "}", "kvm_mce_broadcast_rest(VAR_0);", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, AVCodec *VAR_1)\n{", "int VAR_2;", "if(VAR_0->VAR_1)\nreturn -1;", "VAR_0->VAR_1 = VAR_1;", "VAR_0->codec_id = VAR_1->id;", "VAR_0->frame_number = 0;", "if (VAR_1->priv_data_size > 0) {", "VAR_0->priv_data = av_mallocz(VAR_1->priv_data_size);", "if (!VAR_0->priv_data)\nreturn -ENOMEM;", "} else {", "VAR_0->priv_data = NULL;", "}", "if(VAR_0->coded_width && VAR_0->coded_height)\navcodec_set_dimensions(VAR_0, VAR_0->coded_width, VAR_0->coded_height);", "else if(VAR_0->width && VAR_0->height)\navcodec_set_dimensions(VAR_0, VAR_0->width, VAR_0->height);", "if((VAR_0->coded_width||VAR_0->coded_height) && avcodec_check_dimensions(VAR_0,VAR_0->coded_width,VAR_0->coded_height)){", "av_freep(&VAR_0->priv_data);", "return -1;", "}", "VAR_2 = VAR_0->VAR_1->init(VAR_0);", "if (VAR_2 < 0) {", "av_freep(&VAR_0->priv_data);", "return VAR_2;", "}", "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 ], [ 9, 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37, 39 ], [ 41, 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ] ]

[ "static inline void FUNC_0(yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,\nlong width, long height,\nlong lumStride, long chromStride, long dstStride)\n{", "FUNC_0(yuvPlanartouyvy)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(VP56RangeCoder *VAR_0, int16_t VAR_1[16],\nuint8_t VAR_2[16][3][NUM_DCT_TOKENS - 1],\nint VAR_3, uint8_t *VAR_4,\nint16_t VAR_5[2])\n{", "VP56RangeCoder c = *VAR_0;", "goto skip_eob;", "do {", "int VAR_6;", "if (!vp56_rac_get_prob_branchy(&c, VAR_4[0]))\nbreak;", "skip_eob:\nif (!vp56_rac_get_prob_branchy(&c, VAR_4[1])) {", "if (++VAR_3 == 16)\nbreak;", "VAR_4 = VAR_2[VAR_3][0];", "goto skip_eob;", "}", "if (!vp56_rac_get_prob_branchy(&c, VAR_4[2])) {", "VAR_6 = 1;", "VAR_4 = VAR_2[VAR_3 + 1][1];", "} else {", "if (!vp56_rac_get_prob_branchy(&c, VAR_4[3])) {", "VAR_6 = vp56_rac_get_prob_branchy(&c, VAR_4[4]);", "if (VAR_6)\nVAR_6 += vp56_rac_get_prob(&c, VAR_4[5]);", "VAR_6 += 2;", "} else {", "if (!vp56_rac_get_prob_branchy(&c, VAR_4[6])) {", "if (!vp56_rac_get_prob_branchy(&c, VAR_4[7])) {", "VAR_6 = 5 + vp56_rac_get_prob(&c, vp8_dct_cat1_prob[0]);", "} else {", "VAR_6 = 7;", "VAR_6 += vp56_rac_get_prob(&c, vp8_dct_cat2_prob[0]) << 1;", "VAR_6 += vp56_rac_get_prob(&c, vp8_dct_cat2_prob[1]);", "}", "} else {", "int VAR_7 = vp56_rac_get_prob(&c, VAR_4[8]);", "int VAR_8 = vp56_rac_get_prob(&c, VAR_4[9 + VAR_7]);", "int VAR_9 = (VAR_7 << 1) + VAR_8;", "VAR_6 = 3 + (8 << VAR_9);", "VAR_6 += vp8_rac_get_coeff(&c, ff_vp8_dct_cat_prob[VAR_9]);", "}", "}", "VAR_4 = VAR_2[VAR_3 + 1][2];", "}", "VAR_1[zigzag_scan[VAR_3]] = (vp8_rac_get(&c) ? -VAR_6 : VAR_6) * VAR_5[!!VAR_3];", "} while (++VAR_3 < 16);", "*VAR_0 = c;", "return VAR_3;", "}" ]

[ 1, 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, 1, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(int VAR_0, char **VAR_1)\n{", "int VAR_2, VAR_3;", "OutputFormat output_format = OFORMAT_HUMAN;", "const char *VAR_4, *VAR_5, *VAR_6, *VAR_7;", "BlockBackend *blk;", "BlockDriverState *bs;", "int VAR_8 = 0;", "int VAR_9 = BDRV_O_FLAGS | BDRV_O_CHECK;", "ImageCheck *check;", "bool quiet = false;", "VAR_5 = NULL;", "VAR_6 = NULL;", "VAR_7 = BDRV_DEFAULT_CACHE;", "for(;;) {", "int VAR_10 = 0;", "static const struct option VAR_11[] = {", "{\"help\", no_argument, 0, 'h'},", "{\"format\", required_argument, 0, 'f'},", "{\"repair\", required_argument, 0, 'r'},", "{\"VAR_6\", required_argument, 0, OPTION_OUTPUT},", "{0, 0, 0, 0}", "};", "VAR_2 = getopt_long(VAR_0, VAR_1, \"hf:r:T:q\",\nVAR_11, &VAR_10);", "if (VAR_2 == -1) {", "break;", "}", "switch(VAR_2) {", "case '?':\ncase 'h':\nhelp();", "break;", "case 'f':\nVAR_5 = optarg;", "break;", "case 'r':\nVAR_9 |= BDRV_O_RDWR;", "if (!strcmp(optarg, \"leaks\")) {", "VAR_8 = BDRV_FIX_LEAKS;", "} else if (!strcmp(optarg, \"all\")) {", "VAR_8 = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;", "} else {", "error_exit(\"Unknown option value for -r \"\n\"(expecting 'leaks' or 'all'): %s\", optarg);", "}", "break;", "case OPTION_OUTPUT:\nVAR_6 = optarg;", "break;", "case 'T':\nVAR_7 = optarg;", "break;", "case 'q':\nquiet = true;", "break;", "}", "}", "if (optind != VAR_0 - 1) {", "error_exit(\"Expecting one image file name\");", "}", "VAR_4 = VAR_1[optind++];", "if (VAR_6 && !strcmp(VAR_6, \"json\")) {", "output_format = OFORMAT_JSON;", "} else if (VAR_6 && !strcmp(VAR_6, \"human\")) {", "output_format = OFORMAT_HUMAN;", "} else if (VAR_6) {", "error_report(\"--VAR_6 must be used with human or json as argument.\");", "return 1;", "}", "VAR_3 = bdrv_parse_cache_flags(VAR_7, &VAR_9);", "if (VAR_3 < 0) {", "error_report(\"Invalid source VAR_7 option: %s\", VAR_7);", "return 1;", "}", "blk = img_open(\"image\", VAR_4, VAR_5, VAR_9, true, quiet);", "if (!blk) {", "return 1;", "}", "bs = blk_bs(blk);", "check = g_new0(ImageCheck, 1);", "VAR_3 = collect_image_check(bs, check, VAR_4, VAR_5, VAR_8);", "if (VAR_3 == -ENOTSUP) {", "error_report(\"This image format does not support checks\");", "VAR_3 = 63;", "goto fail;", "}", "if (check->VAR_12 || check->VAR_13) {", "int VAR_12, VAR_13;", "VAR_13 = check->VAR_13;", "VAR_12 = check->VAR_12;", "if (output_format == OFORMAT_HUMAN) {", "qprintf(quiet,\n\"The following inconsistencies were found and repaired:\\n\\n\"\n\" %\" PRId64 \" leaked clusters\\n\"\n\" %\" PRId64 \" corruptions\\n\\n\"\n\"Double checking the fixed image now...\\n\",\ncheck->VAR_13,\ncheck->VAR_12);", "}", "VAR_3 = collect_image_check(bs, check, VAR_4, VAR_5, 0);", "check->VAR_13 = VAR_13;", "check->VAR_12 = VAR_12;", "}", "switch (output_format) {", "case OFORMAT_HUMAN:\ndump_human_image_check(check, quiet);", "break;", "case OFORMAT_JSON:\ndump_json_image_check(check, quiet);", "break;", "}", "if (VAR_3 || check->check_errors) {", "VAR_3 = 1;", "goto fail;", "}", "if (check->corruptions) {", "VAR_3 = 2;", "} else if (check->leaks) {", "VAR_3 = 3;", "} else {", "VAR_3 = 0;", "}", "fail:\nqapi_free_ImageCheck(check);", "blk_unref(blk);", "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, 1, 1, 1, 1, 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 ], [ 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 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 203 ], [ 205, 207, 209, 211, 213, 215, 217 ], [ 219 ], [ 223 ], [ 227 ], [ 229 ], [ 231 ], [ 235 ], [ 237, 239 ], [ 241 ], [ 243, 245 ], [ 247 ], [ 249 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 279, 281 ], [ 283 ], [ 285 ], [ 287 ] ]

[ "static void FUNC_0(INTFLOAT *VAR_0, INTFLOAT *VAR_1)\n{", "INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;", "in0 = VAR_1[0*3];", "in1 = VAR_1[1*3] + VAR_1[0*3];", "in2 = VAR_1[2*3] + VAR_1[1*3];", "in3 = VAR_1[3*3] + VAR_1[2*3];", "in4 = VAR_1[4*3] + VAR_1[3*3];", "in5 = VAR_1[5*3] + VAR_1[4*3];", "in5 += in3;", "in3 += in1;", "in2 = MULH3(in2, C3, 2);", "in3 = MULH3(in3, C3, 4);", "t1 = in0 - in4;", "t2 = MULH3(in1 - in5, C4, 2);", "VAR_0[ 7] =\nVAR_0[10] = t1 + t2;", "VAR_0[ 1] =\nVAR_0[ 4] = t1 - t2;", "in0 += SHR(in4, 1);", "in4 = in0 + in2;", "in5 += 2*in1;", "in1 = MULH3(in5 + in3, C5, 1);", "VAR_0[ 8] =\nVAR_0[ 9] = in4 + in1;", "VAR_0[ 2] =\nVAR_0[ 3] = in4 - in1;", "in0 -= in2;", "in5 = MULH3(in5 - in3, C6, 2);", "VAR_0[ 0] =\nVAR_0[ 5] = in0 - in5;", "VAR_0[ 6] =\nVAR_0[11] = in0 + in5;", "}" ]

[ 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 ]

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

[ "int FUNC_0(BlockDriverState *VAR_0,\nconst char *VAR_1,\nconst char *VAR_2,\nError **VAR_3)\n{", "int VAR_4, VAR_5;", "BDRVQcowState *s = VAR_0->opaque;", "QCowSnapshot *sn;", "uint64_t *new_l1_table;", "int VAR_6;", "int VAR_7;", "assert(VAR_0->read_only);", "VAR_5 = find_snapshot_by_id_and_name(VAR_0, VAR_1, VAR_2);", "if (VAR_5 < 0) {", "error_setg(VAR_3,\n\"Can't find snapshot\");", "return -ENOENT;", "}", "sn = &s->snapshots[VAR_5];", "if (sn->l1_size > QCOW_MAX_L1_SIZE) {", "error_setg(VAR_3, \"Snapshot L1 table too large\");", "return -EFBIG;", "}", "VAR_6 = sn->l1_size * sizeof(uint64_t);", "new_l1_table = g_malloc0(align_offset(VAR_6, 512));", "VAR_7 = bdrv_pread(VAR_0->file, sn->l1_table_offset, new_l1_table, VAR_6);", "if (VAR_7 < 0) {", "error_setg(VAR_3, \"Failed to read l1 table for snapshot\");", "g_free(new_l1_table);", "return VAR_7;", "}", "g_free(s->l1_table);", "s->l1_size = sn->l1_size;", "s->l1_table_offset = sn->l1_table_offset;", "s->l1_table = new_l1_table;", "for(VAR_4 = 0;VAR_4 < s->l1_size; VAR_4++) {", "be64_to_cpus(&s->l1_table[VAR_4]);", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ] ]

[ "static int FUNC_0(const char *VAR_0, QEMUOptionParameter *VAR_1,\nError **VAR_2)\n{", "int VAR_3;", "int VAR_4 = 0;", "uint64_t bytes = 0;", "uint32_t blocks;", "size_t block_size = DEFAULT_CLUSTER_SIZE;", "uint32_t image_type = VDI_TYPE_DYNAMIC;", "VdiHeader header;", "size_t i;", "size_t bmap_size;", "logout(\"\\n\");", "while (VAR_1 && VAR_1->name) {", "if (!strcmp(VAR_1->name, BLOCK_OPT_SIZE)) {", "bytes = VAR_1->value.n;", "#if defined(CONFIG_VDI_BLOCK_SIZE)\n} else if (!strcmp(VAR_1->name, BLOCK_OPT_CLUSTER_SIZE)) {", "if (VAR_1->value.n) {", "block_size = VAR_1->value.n;", "}", "#endif\n#if defined(CONFIG_VDI_STATIC_IMAGE)\n} else if (!strcmp(VAR_1->name, BLOCK_OPT_STATIC)) {", "if (VAR_1->value.n) {", "image_type = VDI_TYPE_STATIC;", "}", "#endif\n}", "VAR_1++;", "}", "VAR_3 = qemu_open(VAR_0,\nO_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,\n0644);", "if (VAR_3 < 0) {", "return -errno;", "}", "blocks = (bytes + block_size - 1) / block_size;", "bmap_size = blocks * sizeof(uint32_t);", "bmap_size = ((bmap_size + SECTOR_SIZE - 1) & ~(SECTOR_SIZE -1));", "memset(&header, 0, sizeof(header));", "pstrcpy(header.text, sizeof(header.text), VDI_TEXT);", "header.signature = VDI_SIGNATURE;", "header.version = VDI_VERSION_1_1;", "header.header_size = 0x180;", "header.image_type = image_type;", "header.offset_bmap = 0x200;", "header.offset_data = 0x200 + bmap_size;", "header.sector_size = SECTOR_SIZE;", "header.disk_size = bytes;", "header.block_size = block_size;", "header.blocks_in_image = blocks;", "if (image_type == VDI_TYPE_STATIC) {", "header.blocks_allocated = blocks;", "}", "uuid_generate(header.uuid_image);", "uuid_generate(header.uuid_last_snap);", "#if defined(CONFIG_VDI_DEBUG)\nvdi_header_print(&header);", "#endif\nvdi_header_to_le(&header);", "if (write(VAR_3, &header, sizeof(header)) < 0) {", "VAR_4 = -errno;", "}", "if (bmap_size > 0) {", "uint32_t *bmap = g_malloc0(bmap_size);", "for (i = 0; i < blocks; i++) {", "if (image_type == VDI_TYPE_STATIC) {", "bmap[i] = i;", "} else {", "bmap[i] = VDI_UNALLOCATED;", "}", "}", "if (write(VAR_3, bmap, bmap_size) < 0) {", "VAR_4 = -errno;", "}", "g_free(bmap);", "}", "if (image_type == VDI_TYPE_STATIC) {", "if (ftruncate(VAR_3, sizeof(header) + bmap_size + blocks * block_size)) {", "VAR_4 = -errno;", "}", "}", "if (close(VAR_3) < 0) {", "VAR_4 = -errno;", "}", "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, 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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 33 ], [ 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51, 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 73, 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 91 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137, 139 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVFormatParameters *VAR_1)\n{", "AVIOContext *pb = VAR_0->pb;", "DXAContext *c = VAR_0->priv_data;", "AVStream *st, *ast;", "uint32_t tag;", "int32_t fps;", "int VAR_2, VAR_3;", "int VAR_4, VAR_5;", "int VAR_6;", "tag = avio_rl32(pb);", "if (tag != MKTAG('D', 'E', 'X', 'A'))\nreturn -1;", "VAR_6 = avio_r8(pb);", "c->frames = avio_rb16(pb);", "if(!c->frames){", "av_log(VAR_0, AV_LOG_ERROR, \"File contains no frames ???\\n\");", "return -1;", "}", "fps = avio_rb32(pb);", "if(fps > 0){", "VAR_5 = 1000;", "VAR_4 = fps;", "}else if (fps < 0){", "VAR_5 = 100000;", "VAR_4 = -fps;", "}else{", "VAR_5 = 10;", "VAR_4 = 1;", "}", "VAR_2 = avio_rb16(pb);", "VAR_3 = avio_rb16(pb);", "c->has_sound = 0;", "st = av_new_stream(VAR_0, 0);", "if (!st)\nreturn -1;", "if(avio_rl32(pb) == MKTAG('W', 'A', 'V', 'E')){", "uint32_t size, fsize;", "c->has_sound = 1;", "size = avio_rb32(pb);", "c->vidpos = avio_tell(pb) + size;", "avio_skip(pb, 16);", "fsize = avio_rl32(pb);", "ast = av_new_stream(VAR_0, 0);", "if (!ast)\nreturn -1;", "ff_get_wav_header(pb, ast->codec, fsize);", "while(avio_tell(pb) < c->vidpos && !pb->eof_reached){", "tag = avio_rl32(pb);", "fsize = avio_rl32(pb);", "if(tag == MKTAG('d', 'a', 't', 'a')) break;", "avio_skip(pb, fsize);", "}", "c->bpc = (fsize + c->frames - 1) / c->frames;", "if(ast->codec->block_align)\nc->bpc = ((c->bpc + ast->codec->block_align - 1) / ast->codec->block_align) * ast->codec->block_align;", "c->bytes_left = fsize;", "c->wavpos = avio_tell(pb);", "avio_seek(pb, c->vidpos, SEEK_SET);", "}", "st->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "st->codec->codec_id = CODEC_ID_DXA;", "st->codec->width = VAR_2;", "st->codec->height = VAR_3;", "av_reduce(&VAR_5, &VAR_4, VAR_5, VAR_4, (1UL<<31)-1);", "av_set_pts_info(st, 33, VAR_4, VAR_5);", "if(VAR_6 & 0xC0){", "st->codec->height >>= 1;", "}", "c->readvid = !c->has_sound;", "c->vidpos = avio_tell(pb);", "VAR_0->start_time = 0;", "VAR_0->duration = (int64_t)c->frames * AV_TIME_BASE * VAR_4 / VAR_5;", "av_log(VAR_0, AV_LOG_DEBUG, \"%d frame(VAR_0)\\n\",c->frames);", "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, 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 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nCFStringRef *VAR_1)\n{", "enum AVColorPrimaries VAR_2 = VAR_0->color_primaries;", "switch (VAR_2) {", "case AVCOL_PRI_UNSPECIFIED:\n*VAR_1 = NULL;", "break;", "case AVCOL_PRI_BT709:\n*VAR_1 = kCVImageBufferColorPrimaries_ITU_R_709_2;", "break;", "case AVCOL_PRI_BT2020:\n*VAR_1 = kCVImageBufferColorPrimaries_ITU_R_2020;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Color VAR_1 %s is not supported.\\n\", av_color_primaries_name(VAR_2));", "*VAR_1 = NULL;", "return -1;", "}", "return 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 ], [ 27, 29 ], [ 31 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ] ]

[ "static void FUNC_0(uint8_t *VAR_0,\nint32_t VAR_1,\nint32_t VAR_2,\nint32_t VAR_3,\nint32_t VAR_4,\nint32_t VAR_5)\n{", "uint8_t cnt;", "uint32_t data0, data1, data2, data3;", "v16u8 zero = { 0 };", "v16u8 src0, src1, src2, src3;", "v8u16 temp0, temp1, temp2, temp3;", "v8i16 wgt, denom, offset;", "VAR_5 <<= (VAR_3);", "if (VAR_3) {", "VAR_5 += (1 << (VAR_3 - 1));", "}", "wgt = __msa_fill_h(VAR_4);", "offset = __msa_fill_h(VAR_5);", "denom = __msa_fill_h(VAR_3);", "for (cnt = VAR_2 / 4; cnt--;) {", "LOAD_4WORDS_WITH_STRIDE(VAR_0, VAR_1, data0, data1, data2, data3);", "src0 = (v16u8) __msa_fill_w(data0);", "src1 = (v16u8) __msa_fill_w(data1);", "src2 = (v16u8) __msa_fill_w(data2);", "src3 = (v16u8) __msa_fill_w(data3);", "ILVR_B_4VECS_UH(src0, src1, src2, src3, zero, zero, zero, zero,\ntemp0, temp1, temp2, temp3);", "temp0 *= wgt;", "temp1 *= wgt;", "temp2 *= wgt;", "temp3 *= wgt;", "ADDS_S_H_4VECS_UH(temp0, offset, temp1, offset,\ntemp2, offset, temp3, offset,\ntemp0, temp1, temp2, temp3);", "MAXI_S_H_4VECS_UH(temp0, temp1, temp2, temp3, 0);", "SRL_H_4VECS_UH(temp0, temp1, temp2, temp3,\ntemp0, temp1, temp2, temp3, denom);", "SAT_U_H_4VECS_UH(temp0, temp1, temp2, temp3, 7);", "PCKEV_B_STORE_4_BYTES_4(temp0, temp1, temp2, temp3, VAR_0, VAR_1);", "VAR_0 += (4 * 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 ]

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

[ "static void FUNC_0(flac_decorrelate_indep_c)(uint8_t **out, int32_t **in,\nint channels, int len, int shift)\n{", "sample *samples = (sample *) OUT(out);", "int VAR_0, VAR_1;", "for (VAR_1 = 0; VAR_1 < len; VAR_1++)", "for (VAR_0 = 0; VAR_0 < channels; VAR_0++)", "S(samples, VAR_0, VAR_1) = in[VAR_0][VAR_1] << shift;", "}" ]

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

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

[ "VAR_6voidVAR_6 VAR_6object_property_add_linkVAR_6(VAR_6ObjectVAR_6 *VAR_6VAR_0VAR_6, VAR_6constVAR_6 VAR_6charVAR_6 *VAR_6VAR_1VAR_6,\nVAR_6constVAR_6 VAR_6charVAR_6 *VAR_6VAR_2VAR_6, VAR_6ObjectVAR_6 **VAR_6VAR_3VAR_6,\nVAR_6voidVAR_6 (*VAR_6VAR_4VAR_6)(VAR_6ObjectVAR_6 *, VAR_6constVAR_6 VAR_6charVAR_6 *,\nVAR_6ObjectVAR_6 *, VAR_6ErrorVAR_6 **),\nVAR_6ObjectPropertyLinkFlagsVAR_6 VAR_6flagsVAR_6,\nVAR_6ErrorVAR_6 **VAR_6errpVAR_6)\n{", "VAR_6ErrorVAR_6 *VAR_6local_errVAR_6 = VAR_6NULLVAR_6;", "VAR_6LinkPropertyVAR_6 *VAR_6propVAR_6 = VAR_6g_mallocVAR_6(VAR_6sizeofVAR_6(*VAR_6propVAR_6));", "VAR_6gcharVAR_6 *VAR_6full_typeVAR_6;", "VAR_6ObjectPropertyVAR_6 *VAR_6opVAR_6;", "VAR_6propVAR_6->VAR_6VAR_3VAR_6 = VAR_6VAR_3VAR_6;", "VAR_6propVAR_6->VAR_6VAR_4VAR_6 = VAR_6VAR_4VAR_6;", "VAR_6propVAR_6->VAR_6flagsVAR_6 = VAR_6flagsVAR_6;", "VAR_6full_typeVAR_6 = VAR_6g_strdup_printfVAR_6(\"VAR_6linkVAR_6<%VAR_6sVAR_6>\", VAR_6VAR_2VAR_6);", "VAR_6opVAR_6 = VAR_6object_property_addVAR_6(VAR_6VAR_0VAR_6, VAR_6VAR_1VAR_6, VAR_6full_typeVAR_6,\nVAR_6object_get_link_propertyVAR_6,\nVAR_6VAR_4VAR_6 ? VAR_6object_set_link_propertyVAR_6 : VAR_6NULLVAR_6,\nVAR_6object_release_link_propertyVAR_6,\nVAR_6propVAR_6,\n&VAR_6local_errVAR_6);", "VAR_6ifVAR_6 (VAR_6local_errVAR_6) {", "VAR_6error_propagateVAR_6(VAR_6errpVAR_6, VAR_6local_errVAR_6);", "VAR_6g_freeVAR_6(VAR_6propVAR_6);", "VAR_6gotoVAR_6 VAR_6outVAR_6;", "}", "VAR_6opVAR_6->VAR_6resolveVAR_6 = VAR_6object_resolve_link_propertyVAR_6;", "VAR_6outVAR_6:\nVAR_6g_freeVAR_6(VAR_6full_typeVAR_6);", "}" ]

[ 1, 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 ], [ 29 ], [ 33 ], [ 37, 39, 41, 43, 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65, 67 ], [ 69 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0,\nint64_t VAR_1, uint16_t **VAR_2)\n{", "BDRVQcowState *s = VAR_0->opaque;", "unsigned int VAR_3;", "int VAR_4;", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC);", "VAR_3 = VAR_1 >> (s->cluster_bits - REFCOUNT_SHIFT);", "if (VAR_3 < s->refcount_table_size) {", "uint64_t refcount_block_offset =\ns->refcount_table[VAR_3] & REFT_OFFSET_MASK;", "if (refcount_block_offset) {", "return load_refcount_block(VAR_0, refcount_block_offset,\n(void**) VAR_2);", "*VAR_2 = NULL;", "VAR_4 = qcow2_cache_flush(VAR_0, s->l2_table_cache);", "if (VAR_4 < 0) {", "return VAR_4;", "int64_t new_block = alloc_clusters_noref(VAR_0, s->cluster_size);", "if (new_block < 0) {", "return new_block;", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"qcow2: Allocate refcount block %d for %\" PRIx64\n\" at %\" PRIx64 \"\\n\",\nVAR_3, VAR_1 << s->cluster_bits, new_block);", "#endif\nif (in_same_refcount_block(s, new_block, VAR_1 << s->cluster_bits)) {", "VAR_4 = qcow2_cache_get_empty(VAR_0, s->refcount_block_cache, new_block,\n(void**) VAR_2);", "if (VAR_4 < 0) {", "goto fail_block;", "memset(*VAR_2, 0, s->cluster_size);", "int VAR_5 = (new_block >> s->cluster_bits) &\n((1 << (s->cluster_bits - REFCOUNT_SHIFT)) - 1);", "(*VAR_2)[VAR_5] = cpu_to_be16(1);", "} else {", "VAR_4 = update_refcount(VAR_0, new_block, s->cluster_size, 1,\nQCOW2_DISCARD_NEVER);", "if (VAR_4 < 0) {", "goto fail_block;", "VAR_4 = qcow2_cache_flush(VAR_0, s->refcount_block_cache);", "if (VAR_4 < 0) {", "goto fail_block;", "VAR_4 = qcow2_cache_get_empty(VAR_0, s->refcount_block_cache, new_block,\n(void**) VAR_2);", "if (VAR_4 < 0) {", "goto fail_block;", "memset(*VAR_2, 0, s->cluster_size);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_WRITE);", "qcow2_cache_entry_mark_dirty(s->refcount_block_cache, *VAR_2);", "VAR_4 = qcow2_cache_flush(VAR_0, s->refcount_block_cache);", "if (VAR_4 < 0) {", "goto fail_block;", "if (VAR_3 < s->refcount_table_size) {", "uint64_t data64 = cpu_to_be64(new_block);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file,\ns->refcount_table_offset + VAR_3 * sizeof(uint64_t),\n&data64, sizeof(data64));", "if (VAR_4 < 0) {", "goto fail_block;", "s->refcount_table[VAR_3] = new_block;", "return -EAGAIN;", "VAR_4 = qcow2_cache_put(VAR_0, s->refcount_block_cache, (void**) VAR_2);", "if (VAR_4 < 0) {", "goto fail_block;", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFTABLE_GROW);", "uint64_t refcount_block_clusters = 1 << (s->cluster_bits - REFCOUNT_SHIFT);", "uint64_t blocks_used = DIV_ROUND_UP(VAR_1, refcount_block_clusters);", "uint64_t table_size = next_refcount_table_size(s, blocks_used + 1);", "uint64_t last_table_size;", "uint64_t blocks_clusters;", "do {", "uint64_t table_clusters =\nsize_to_clusters(s, table_size * sizeof(uint64_t));", "blocks_clusters = 1 +\n((table_clusters + refcount_block_clusters - 1)\n/ refcount_block_clusters);", "uint64_t meta_clusters = table_clusters + blocks_clusters;", "last_table_size = table_size;", "table_size = next_refcount_table_size(s, blocks_used +\n((meta_clusters + refcount_block_clusters - 1)\n/ refcount_block_clusters));", "} while (last_table_size != table_size);", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"qcow2: Grow refcount table %\" PRId32 \" => %\" PRId64 \"\\n\",\ns->refcount_table_size, table_size);", "#endif\nuint64_t meta_offset = (blocks_used * refcount_block_clusters) *\ns->cluster_size;", "uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;", "uint16_t *new_blocks = g_malloc0(blocks_clusters * s->cluster_size);", "uint64_t *new_table = g_malloc0(table_size * sizeof(uint64_t));", "memcpy(new_table, s->refcount_table,\ns->refcount_table_size * sizeof(uint64_t));", "new_table[VAR_3] = new_block;", "int VAR_6;", "for (VAR_6 = 0; VAR_6 < blocks_clusters; VAR_6++) {", "new_table[blocks_used + VAR_6] = meta_offset + (VAR_6 * s->cluster_size);", "uint64_t table_clusters = size_to_clusters(s, table_size * sizeof(uint64_t));", "int block = 0;", "for (VAR_6 = 0; VAR_6 < table_clusters + blocks_clusters; VAR_6++) {", "new_blocks[block++] = cpu_to_be16(1);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file, meta_offset, new_blocks,\nblocks_clusters * s->cluster_size);", "g_free(new_blocks);", "if (VAR_4 < 0) {", "goto fail_table;", "for(VAR_6 = 0; VAR_6 < table_size; VAR_6++) {", "cpu_to_be64s(&new_table[VAR_6]);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file, table_offset, new_table,\ntable_size * sizeof(uint64_t));", "if (VAR_4 < 0) {", "goto fail_table;", "for(VAR_6 = 0; VAR_6 < table_size; VAR_6++) {", "be64_to_cpus(&new_table[VAR_6]);", "uint8_t data[12];", "cpu_to_be64w((uint64_t*)data, table_offset);", "cpu_to_be32w((uint32_t*)(data + 8), table_clusters);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file, offsetof(QCowHeader, refcount_table_offset),\ndata, sizeof(data));", "if (VAR_4 < 0) {", "goto fail_table;", "uint64_t old_table_offset = s->refcount_table_offset;", "uint64_t old_table_size = s->refcount_table_size;", "g_free(s->refcount_table);", "s->refcount_table = new_table;", "s->refcount_table_size = table_size;", "s->refcount_table_offset = table_offset;", "qcow2_free_clusters(VAR_0, old_table_offset, old_table_size * sizeof(uint64_t),\nQCOW2_DISCARD_OTHER);", "VAR_4 = load_refcount_block(VAR_0, new_block, (void**) VAR_2);", "if (VAR_4 < 0) {", "return VAR_4;", "return -EAGAIN;", "fail_table:\ng_free(new_table);", "fail_block:\nif (*VAR_2 != NULL) {", "qcow2_cache_put(VAR_0, s->refcount_block_cache, (void**) VAR_2);", "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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 14 ], [ 15, 16 ], [ 39 ], [ 41 ], [ 42 ], [ 43 ], [ 45 ], [ 46 ], [ 47 ], [ 48, 49, 50, 51 ], [ 52, 53 ], [ 55, 56 ], [ 57 ], [ 58 ], [ 59 ], [ 61, 62 ], [ 63 ], [ 64 ], [ 67, 68 ], [ 69 ], [ 70 ], [ 71 ], [ 72 ], [ 73 ], [ 76, 77 ], [ 78 ], [ 79 ], [ 80 ], [ 82 ], [ 83 ], [ 84 ], [ 85 ], [ 86 ], [ 88 ], [ 89 ], [ 90 ], [ 91, 92, 93 ], [ 94 ], [ 95 ], [ 96 ], [ 99 ], [ 100 ], [ 101 ], [ 102 ], [ 114 ], [ 116 ], [ 117 ], [ 119 ], [ 120 ], [ 121 ], [ 122 ], [ 123, 124 ], [ 125, 126, 127 ], [ 128 ], [ 129 ], [ 130, 131, 132 ], [ 133 ], [ 134, 135, 136 ], [ 137, 139, 140 ], [ 141 ], [ 142 ], [ 143 ], [ 145, 146 ], [ 147 ], [ 148 ], [ 149 ], [ 150 ], [ 152 ], [ 153 ], [ 154 ], [ 155 ], [ 157 ], [ 158, 159 ], [ 160 ], [ 161 ], [ 162 ], [ 164 ], [ 165 ], [ 166 ], [ 167, 168 ], [ 169 ], [ 170 ], [ 171 ], [ 172 ], [ 174 ], [ 175 ], [ 176 ], [ 177 ], [ 178, 179 ], [ 180 ], [ 181 ], [ 183 ], [ 184 ], [ 185 ], [ 186 ], [ 187 ], [ 188 ], [ 190, 191 ], [ 192 ], [ 193 ], [ 194 ], [ 198 ], [ 199, 200 ], [ 201, 202 ], [ 203 ], [ 204 ] ]

[ "FUNC_0(VAR_0)\n{", "T0 = (regs->ctr == 0);", "RETURN();", "}" ]

[ 1, 1, 1, 0 ]

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

[ "static void FUNC_0(USBNetState *VAR_0, USBPacket *VAR_1)\n{", "int VAR_2 = sizeof(VAR_0->out_buf) - VAR_0->out_ptr;", "struct rndis_packet_msg_type *VAR_3 =\n(struct rndis_packet_msg_type *) VAR_0->out_buf;", "uint32_t len;", "#ifdef TRAFFIC_DEBUG\nfprintf(stderr, \"usbnet: data out len %zu\\n\", VAR_1->iov.size);", "iov_hexdump(VAR_1->iov.iov, VAR_1->iov.niov, stderr, \"usbnet\", VAR_1->iov.size);", "#endif\nif (VAR_2 > VAR_1->iov.size) {", "VAR_2 = VAR_1->iov.size;", "}", "usb_packet_copy(VAR_1, &VAR_0->out_buf[VAR_0->out_ptr], VAR_2);", "VAR_0->out_ptr += VAR_2;", "if (!is_rndis(VAR_0)) {", "if (VAR_1->iov.size < 64) {", "qemu_send_packet(qemu_get_queue(VAR_0->nic), VAR_0->out_buf, VAR_0->out_ptr);", "VAR_0->out_ptr = 0;", "}", "return;", "}", "len = le32_to_cpu(VAR_3->MessageLength);", "if (VAR_0->out_ptr < 8 || VAR_0->out_ptr < len) {", "return;", "}", "if (le32_to_cpu(VAR_3->MessageType) == RNDIS_PACKET_MSG) {", "uint32_t offs = 8 + le32_to_cpu(VAR_3->DataOffset);", "uint32_t size = le32_to_cpu(VAR_3->DataLength);", "if (offs + size <= len)\nqemu_send_packet(qemu_get_queue(VAR_0->nic), VAR_0->out_buf + offs, size);", "}", "VAR_0->out_ptr -= len;", "memmove(VAR_0->out_buf, &VAR_0->out_buf[len], VAR_0->out_ptr);", "}" ]

[ 0, 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 ]

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "SCLPEventClass *k = SCLP_EVENT_CLASS(VAR_0);", "dc->reset = quiesce_reset;", "dc->vmsd = &vmstate_sclpquiesce;", "set_bit(DEVICE_CATEGORY_MISC, dc->categories);", "k->init = quiesce_init;", "k->get_send_mask = send_mask;", "k->get_receive_mask = receive_mask;", "k->can_handle_event = can_handle_event;", "k->read_event_data = read_event_data;", "k->write_event_data = NULL;", "}" ]

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

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

[ "static int FUNC_0(MOVContext *VAR_0, AVIOContext **VAR_1, const char *VAR_2, MOVDref *VAR_3,\nAVIOInterruptCB *VAR_4)\n{", "AVOpenCallback open_func = VAR_0->fc->open_cb;", "if (!open_func)\nopen_func = ffio_open2_wrapper;", "if (VAR_3->nlvl_to > 0 && VAR_3->nlvl_from > 0 && VAR_3->path[0] != '/') {", "char VAR_5[1025];", "const char *VAR_6;", "int VAR_7, VAR_8;", "VAR_6 = strrchr(VAR_2, '/');", "if (VAR_6)\nVAR_6++;", "else\nVAR_6 = VAR_2;", "for (VAR_7 = 0, VAR_8 = strlen(VAR_3->path) - 1; VAR_8 >= 0; VAR_8--)", "if (VAR_3->path[VAR_8] == '/') {", "if (VAR_7 == VAR_3->nlvl_to - 1)\nbreak;", "else\nVAR_7++;", "}", "if (VAR_7 == VAR_3->nlvl_to - 1 && VAR_6 - VAR_2 < sizeof(VAR_5)) {", "memcpy(VAR_5, VAR_2, VAR_6 - VAR_2);", "VAR_5[VAR_6 - VAR_2] = 0;", "for (VAR_7 = 1; VAR_7 < VAR_3->nlvl_from; VAR_7++)", "av_strlcat(VAR_5, \"../\", sizeof(VAR_5));", "av_strlcat(VAR_5, VAR_3->path + VAR_8 + 1, sizeof(VAR_5));", "if (!VAR_0->use_absolute_path && !VAR_0->fc->open_cb)\nif(strstr(VAR_3->path + VAR_8 + 1, \"..\") || VAR_3->nlvl_from > 1)\nreturn AVERROR(ENOENT);", "if (strlen(VAR_5) + 1 == sizeof(VAR_5))\nreturn AVERROR(ENOENT);", "if (!open_func(VAR_0->fc, VAR_1, VAR_5, AVIO_FLAG_READ, VAR_4, NULL))\nreturn 0;", "}", "} else if (VAR_0->use_absolute_path) {", "av_log(VAR_0->fc, AV_LOG_WARNING, \"Using absolute path on user request, \"\n\"this is a possible security issue\\n\");", "if (!open_func(VAR_0->fc, VAR_1, VAR_3->path, AVIO_FLAG_READ, VAR_4, NULL))\nreturn 0;", "} else if (VAR_0->fc->open_cb) {", "if (!open_func(VAR_0->fc, VAR_1, VAR_3->path, AVIO_FLAG_READ, VAR_4, NULL))\nreturn 0;", "} else {", "av_log(VAR_0->fc, AV_LOG_ERROR,\n\"Absolute path %s not tried for security reasons, \"\n\"set demuxer option use_absolute_path to allow absolute paths\\n\",\nVAR_3->path);", "}", "return AVERROR(ENOENT);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 35, 37 ], [ 39, 41 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 55, 57 ], [ 59 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 79 ], [ 81, 83, 85 ], [ 89, 91 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101, 103 ], [ 105, 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117, 119, 121, 123 ], [ 125 ], [ 129 ], [ 131 ] ]

[ "static void FUNC_0( H264Context *VAR_0, uint8_t *VAR_1, int VAR_2, int16_t VAR_3[4], int VAR_4 ) {", "int VAR_5, VAR_6;", "const int VAR_7 = VAR_4 + VAR_0->slice_alpha_c0_offset;", "const int VAR_8 = (alpha_table+52)[VAR_7];", "const int VAR_9 = (beta_table+52)[VAR_4 + VAR_0->slice_beta_offset];", "if( VAR_3[0] < 4 ) {", "int8_t tc[4];", "for(VAR_5=0; VAR_5<4; VAR_5++)", "tc[VAR_5] = VAR_3[VAR_5] ? (tc0_table+52)[VAR_7][VAR_3[VAR_5] - 1] : -1;", "VAR_0->s.dsp.h264_h_loop_filter_luma(VAR_1, VAR_2, VAR_8, VAR_9, tc);", "} else {", "VAR_0->s.dsp.h264_h_loop_filter_luma_intra(VAR_1, VAR_2, VAR_8, VAR_9);", "}", "}" ]

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

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

[ "int FUNC_0(QEMUFile *VAR_0)\n{", "if (VAR_0->ops->rate_limit)\nreturn VAR_0->ops->rate_limit(VAR_0->opaque);", "return 0;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "FUNC_0(QCryptoBlock *VAR_0,\nQCryptoBlockCreateOptions *VAR_1,\nconst char *VAR_2,\nQCryptoBlockInitFunc VAR_3,\nQCryptoBlockWriteFunc VAR_4,\nvoid *VAR_5,\nError **VAR_6)\n{", "QCryptoBlockLUKS *luks;", "QCryptoBlockCreateOptionsLUKS luks_opts;", "Error *local_err = NULL;", "uint8_t *masterkey = NULL;", "uint8_t *slotkey = NULL;", "uint8_t *splitkey = NULL;", "size_t splitkeylen = 0;", "size_t i;", "QCryptoCipher *cipher = NULL;", "QCryptoIVGen *ivgen = NULL;", "char *VAR_7;", "const char *VAR_8;", "const char *VAR_9;", "const char *VAR_10;", "const char *VAR_11 = NULL;", "const char *VAR_12;", "char *VAR_13 = NULL;", "QCryptoCipherAlgorithm ivcipheralg = 0;", "uint64_t iters;", "memcpy(&luks_opts, &VAR_1->u.luks, sizeof(luks_opts));", "if (!luks_opts.has_iter_time) {", "luks_opts.iter_time = 2000;", "}", "if (!luks_opts.has_cipher_alg) {", "luks_opts.VAR_8 = QCRYPTO_CIPHER_ALG_AES_256;", "}", "if (!luks_opts.has_cipher_mode) {", "luks_opts.VAR_9 = QCRYPTO_CIPHER_MODE_XTS;", "}", "if (!luks_opts.has_ivgen_alg) {", "luks_opts.VAR_10 = QCRYPTO_IVGEN_ALG_PLAIN64;", "}", "if (!luks_opts.has_hash_alg) {", "luks_opts.VAR_12 = QCRYPTO_HASH_ALG_SHA256;", "}", "if (luks_opts.VAR_10 == QCRYPTO_IVGEN_ALG_ESSIV) {", "if (!luks_opts.has_ivgen_hash_alg) {", "luks_opts.VAR_11 = QCRYPTO_HASH_ALG_SHA256;", "luks_opts.has_ivgen_hash_alg = true;", "}", "}", "if (!VAR_1->u.luks.key_secret) {", "error_setg(VAR_6, \"Parameter '%skey-secret' is required for cipher\",\nVAR_2 ? VAR_2 : \"\");", "return -1;", "}", "VAR_7 = qcrypto_secret_lookup_as_utf8(luks_opts.key_secret, VAR_6);", "if (!VAR_7) {", "return -1;", "}", "luks = g_new0(QCryptoBlockLUKS, 1);", "VAR_0->VAR_5 = luks;", "memcpy(luks->header.magic, qcrypto_block_luks_magic,\nQCRYPTO_BLOCK_LUKS_MAGIC_LEN);", "luks->header.version = QCRYPTO_BLOCK_LUKS_VERSION;", "qcrypto_block_luks_uuid_gen(luks->header.uuid);", "VAR_8 = qcrypto_block_luks_cipher_alg_lookup(luks_opts.VAR_8,\nVAR_6);", "if (!VAR_8) {", "goto error;", "}", "VAR_9 = QCryptoCipherMode_str(luks_opts.VAR_9);", "VAR_10 = QCryptoIVGenAlgorithm_str(luks_opts.VAR_10);", "if (luks_opts.has_ivgen_hash_alg) {", "VAR_11 = QCryptoHashAlgorithm_str(luks_opts.VAR_11);", "VAR_13 = g_strdup_printf(\"%s-%s:%s\", VAR_9, VAR_10,\nVAR_11);", "} else {", "VAR_13 = g_strdup_printf(\"%s-%s\", VAR_9, VAR_10);", "}", "VAR_12 = QCryptoHashAlgorithm_str(luks_opts.VAR_12);", "if (strlen(VAR_8) >= QCRYPTO_BLOCK_LUKS_CIPHER_NAME_LEN) {", "error_setg(VAR_6, \"Cipher name '%s' is too long for LUKS header\",\nVAR_8);", "goto error;", "}", "if (strlen(VAR_13) >= QCRYPTO_BLOCK_LUKS_CIPHER_MODE_LEN) {", "error_setg(VAR_6, \"Cipher mode '%s' is too long for LUKS header\",\nVAR_13);", "goto error;", "}", "if (strlen(VAR_12) >= QCRYPTO_BLOCK_LUKS_HASH_SPEC_LEN) {", "error_setg(VAR_6, \"Hash name '%s' is too long for LUKS header\",\nVAR_12);", "goto error;", "}", "if (luks_opts.VAR_10 == QCRYPTO_IVGEN_ALG_ESSIV) {", "ivcipheralg = qcrypto_block_luks_essiv_cipher(luks_opts.VAR_8,\nluks_opts.VAR_11,\n&local_err);", "if (local_err) {", "error_propagate(VAR_6, local_err);", "goto error;", "}", "} else {", "ivcipheralg = luks_opts.VAR_8;", "}", "strcpy(luks->header.cipher_name, VAR_8);", "strcpy(luks->header.VAR_9, VAR_13);", "strcpy(luks->header.hash_spec, VAR_12);", "luks->header.key_bytes = qcrypto_cipher_get_key_len(luks_opts.VAR_8);", "if (luks_opts.VAR_9 == QCRYPTO_CIPHER_MODE_XTS) {", "luks->header.key_bytes *= 2;", "}", "if (qcrypto_random_bytes(luks->header.master_key_salt,\nQCRYPTO_BLOCK_LUKS_SALT_LEN,\nVAR_6) < 0) {", "goto error;", "}", "masterkey = g_new0(uint8_t, luks->header.key_bytes);", "if (qcrypto_random_bytes(masterkey,\nluks->header.key_bytes, VAR_6) < 0) {", "goto error;", "}", "VAR_0->cipher = qcrypto_cipher_new(luks_opts.VAR_8,\nluks_opts.VAR_9,\nmasterkey, luks->header.key_bytes,\nVAR_6);", "if (!VAR_0->cipher) {", "goto error;", "}", "VAR_0->kdfhash = luks_opts.VAR_12;", "VAR_0->niv = qcrypto_cipher_get_iv_len(luks_opts.VAR_8,\nluks_opts.VAR_9);", "VAR_0->ivgen = qcrypto_ivgen_new(luks_opts.VAR_10,\nivcipheralg,\nluks_opts.VAR_11,\nmasterkey, luks->header.key_bytes,\nVAR_6);", "if (!VAR_0->ivgen) {", "goto error;", "}", "iters = qcrypto_pbkdf2_count_iters(luks_opts.VAR_12,\nmasterkey, luks->header.key_bytes,\nluks->header.master_key_salt,\nQCRYPTO_BLOCK_LUKS_SALT_LEN,\nQCRYPTO_BLOCK_LUKS_DIGEST_LEN,\n&local_err);", "if (local_err) {", "error_propagate(VAR_6, local_err);", "goto error;", "}", "if (iters > (ULLONG_MAX / luks_opts.iter_time)) {", "error_setg_errno(VAR_6, ERANGE,\n\"PBKDF iterations %llu too large to scale\",\n(unsigned long long)iters);", "goto error;", "}", "iters = iters * luks_opts.iter_time / 1000;", "iters /= 8;", "if (iters > UINT32_MAX) {", "error_setg_errno(VAR_6, ERANGE,\n\"PBKDF iterations %llu larger than %u\",\n(unsigned long long)iters, UINT32_MAX);", "goto error;", "}", "iters = MAX(iters, QCRYPTO_BLOCK_LUKS_MIN_MASTER_KEY_ITERS);", "luks->header.master_key_iterations = iters;", "if (qcrypto_pbkdf2(luks_opts.VAR_12,\nmasterkey, luks->header.key_bytes,\nluks->header.master_key_salt,\nQCRYPTO_BLOCK_LUKS_SALT_LEN,\nluks->header.master_key_iterations,\nluks->header.master_key_digest,\nQCRYPTO_BLOCK_LUKS_DIGEST_LEN,\nVAR_6) < 0) {", "goto error;", "}", "splitkeylen = luks->header.key_bytes * QCRYPTO_BLOCK_LUKS_STRIPES;", "for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {", "luks->header.key_slots[i].active = i == 0 ?\nQCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED :\nQCRYPTO_BLOCK_LUKS_KEY_SLOT_DISABLED;", "luks->header.key_slots[i].stripes = QCRYPTO_BLOCK_LUKS_STRIPES;", "luks->header.key_slots[i].key_offset =\n(QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET /\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE) +\n(ROUND_UP(DIV_ROUND_UP(splitkeylen, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE),\n(QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET /\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE)) * i);", "}", "if (qcrypto_random_bytes(luks->header.key_slots[0].salt,\nQCRYPTO_BLOCK_LUKS_SALT_LEN,\nVAR_6) < 0) {", "goto error;", "}", "iters = qcrypto_pbkdf2_count_iters(luks_opts.VAR_12,\n(uint8_t *)VAR_7, strlen(VAR_7),\nluks->header.key_slots[0].salt,\nQCRYPTO_BLOCK_LUKS_SALT_LEN,\nluks->header.key_bytes,\n&local_err);", "if (local_err) {", "error_propagate(VAR_6, local_err);", "goto error;", "}", "if (iters > (ULLONG_MAX / luks_opts.iter_time)) {", "error_setg_errno(VAR_6, ERANGE,\n\"PBKDF iterations %llu too large to scale\",\n(unsigned long long)iters);", "goto error;", "}", "iters = iters * luks_opts.iter_time / 1000;", "if (iters > UINT32_MAX) {", "error_setg_errno(VAR_6, ERANGE,\n\"PBKDF iterations %llu larger than %u\",\n(unsigned long long)iters, UINT32_MAX);", "goto error;", "}", "luks->header.key_slots[0].iterations =\nMAX(iters, QCRYPTO_BLOCK_LUKS_MIN_SLOT_KEY_ITERS);", "slotkey = g_new0(uint8_t, luks->header.key_bytes);", "if (qcrypto_pbkdf2(luks_opts.VAR_12,\n(uint8_t *)VAR_7, strlen(VAR_7),\nluks->header.key_slots[0].salt,\nQCRYPTO_BLOCK_LUKS_SALT_LEN,\nluks->header.key_slots[0].iterations,\nslotkey, luks->header.key_bytes,\nVAR_6) < 0) {", "goto error;", "}", "cipher = qcrypto_cipher_new(luks_opts.VAR_8,\nluks_opts.VAR_9,\nslotkey, luks->header.key_bytes,\nVAR_6);", "if (!cipher) {", "goto error;", "}", "ivgen = qcrypto_ivgen_new(luks_opts.VAR_10,\nivcipheralg,\nluks_opts.VAR_11,\nslotkey, luks->header.key_bytes,\nVAR_6);", "if (!ivgen) {", "goto error;", "}", "splitkey = g_new0(uint8_t, splitkeylen);", "if (qcrypto_afsplit_encode(luks_opts.VAR_12,\nluks->header.key_bytes,\nluks->header.key_slots[0].stripes,\nmasterkey,\nsplitkey,\nVAR_6) < 0) {", "goto error;", "}", "if (qcrypto_block_encrypt_helper(cipher, VAR_0->niv, ivgen,\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE,\n0,\nsplitkey,\nsplitkeylen,\nVAR_6) < 0) {", "goto error;", "}", "luks->header.payload_offset =\n(QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET /\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE) +\n(ROUND_UP(DIV_ROUND_UP(splitkeylen, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE),\n(QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET /\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE)) *\nQCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);", "VAR_0->payload_offset = luks->header.payload_offset *\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE;", "VAR_3(VAR_0, VAR_0->payload_offset, VAR_5, &local_err);", "if (local_err) {", "error_propagate(VAR_6, local_err);", "goto error;", "}", "cpu_to_be16s(&luks->header.version);", "cpu_to_be32s(&luks->header.payload_offset);", "cpu_to_be32s(&luks->header.key_bytes);", "cpu_to_be32s(&luks->header.master_key_iterations);", "for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {", "cpu_to_be32s(&luks->header.key_slots[i].active);", "cpu_to_be32s(&luks->header.key_slots[i].iterations);", "cpu_to_be32s(&luks->header.key_slots[i].key_offset);", "cpu_to_be32s(&luks->header.key_slots[i].stripes);", "}", "VAR_4(VAR_0, 0,\n(const uint8_t *)&luks->header,\nsizeof(luks->header),\nVAR_5,\n&local_err);", "be16_to_cpus(&luks->header.version);", "be32_to_cpus(&luks->header.payload_offset);", "be32_to_cpus(&luks->header.key_bytes);", "be32_to_cpus(&luks->header.master_key_iterations);", "for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {", "be32_to_cpus(&luks->header.key_slots[i].active);", "be32_to_cpus(&luks->header.key_slots[i].iterations);", "be32_to_cpus(&luks->header.key_slots[i].key_offset);", "be32_to_cpus(&luks->header.key_slots[i].stripes);", "}", "if (local_err) {", "error_propagate(VAR_6, local_err);", "goto error;", "}", "if (VAR_4(VAR_0,\nluks->header.key_slots[0].key_offset *\nQCRYPTO_BLOCK_LUKS_SECTOR_SIZE,\nsplitkey, splitkeylen,\nVAR_5,\nVAR_6) != splitkeylen) {", "goto error;", "}", "luks->VAR_8 = luks_opts.VAR_8;", "luks->VAR_9 = luks_opts.VAR_9;", "luks->VAR_10 = luks_opts.VAR_10;", "luks->VAR_11 = luks_opts.VAR_11;", "luks->VAR_12 = luks_opts.VAR_12;", "memset(masterkey, 0, luks->header.key_bytes);", "g_free(masterkey);", "memset(slotkey, 0, luks->header.key_bytes);", "g_free(slotkey);", "g_free(splitkey);", "g_free(VAR_7);", "g_free(VAR_13);", "qcrypto_ivgen_free(ivgen);", "qcrypto_cipher_free(cipher);", "return 0;", "error:\nif (masterkey) {", "memset(masterkey, 0, luks->header.key_bytes);", "}", "g_free(masterkey);", "if (slotkey) {", "memset(slotkey, 0, luks->header.key_bytes);", "}", "g_free(slotkey);", "g_free(splitkey);", "g_free(VAR_7);", "g_free(VAR_13);", "qcrypto_ivgen_free(ivgen);", "qcrypto_cipher_free(cipher);", "g_free(luks);", "return -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 ]

[ [ 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 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 135, 137 ], [ 149 ], [ 151 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 191 ], [ 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203, 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213, 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225, 227, 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247 ], [ 249 ], [ 251 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 271, 273, 275 ], [ 277 ], [ 279 ], [ 285 ], [ 287, 289 ], [ 291 ], [ 293 ], [ 301, 303, 305, 307 ], [ 309 ], [ 311 ], [ 313 ], [ 317 ], [ 319, 321 ], [ 323, 325, 327, 329, 331 ], [ 335 ], [ 337 ], [ 339 ], [ 351, 353, 355, 357, 359, 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 373 ], [ 375, 377, 379 ], [ 381 ], [ 383 ], [ 389 ], [ 401 ], [ 403 ], [ 405, 407, 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 431, 433, 435, 437, 439, 441, 443, 445 ], [ 447 ], [ 449 ], [ 459 ], [ 461 ], [ 463, 465, 467 ], [ 469 ], [ 479, 481, 483, 485, 487, 489 ], [ 491 ], [ 495, 497, 499 ], [ 501 ], [ 503 ], [ 513, 515, 517, 519, 521, 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 535 ], [ 537, 539, 541 ], [ 543 ], [ 545 ], [ 551 ], [ 555 ], [ 557, 559, 561 ], [ 563 ], [ 565 ], [ 569, 571 ], [ 583 ], [ 585, 587, 589, 591, 593, 595, 597 ], [ 599 ], [ 601 ], [ 613, 615, 617, 619 ], [ 621 ], [ 623 ], [ 625 ], [ 629, 631, 633, 635, 637 ], [ 639 ], [ 641 ], [ 643 ], [ 653 ], [ 657, 659, 661, 663, 665, 667 ], [ 669 ], [ 671 ], [ 679, 681, 683, 685, 687, 689 ], [ 691 ], [ 693 ], [ 707, 709, 711, 713, 715, 717, 719 ], [ 723, 725 ], [ 731 ], [ 733 ], [ 735 ], [ 737 ], [ 739 ], [ 747 ], [ 749 ], [ 751 ], [ 753 ], [ 757 ], [ 759 ], [ 761 ], [ 763 ], [ 765 ], [ 767 ], [ 775, 777, 779, 781, 783 ], [ 795 ], [ 797 ], [ 799 ], [ 801 ], [ 805 ], [ 807 ], [ 809 ], [ 811 ], [ 813 ], [ 815 ], [ 819 ], [ 821 ], [ 823 ], [ 825 ], [ 833, 835, 837, 839, 841, 843 ], [ 845 ], [ 847 ], [ 851 ], [ 853 ], [ 855 ], [ 857 ], [ 859 ], [ 863 ], [ 865 ], [ 867 ], [ 869 ], [ 871 ], [ 873 ], [ 875 ], [ 879 ], [ 881 ], [ 885 ], [ 889, 891 ], [ 893 ], [ 895 ], [ 897 ], [ 899 ], [ 901 ], [ 903 ], [ 905 ], [ 907 ], [ 909 ], [ 911 ], [ 915 ], [ 917 ], [ 921 ], [ 923 ], [ 925 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "pc_cmos_init_late_arg *arg = VAR_0;", "ISADevice *s = arg->rtc_state;", "int16_t cylinders;", "int8_t heads, sectors;", "int VAR_1;", "int VAR_2, VAR_3;", "Object *container;", "CheckFdcState state = { 0 };", "VAR_1 = 0;", "if (ide_get_geometry(arg->idebus[0], 0,\n&cylinders, &heads, &sectors) >= 0) {", "cmos_init_hd(s, 0x19, 0x1b, cylinders, heads, sectors);", "VAR_1 |= 0xf0;", "}", "if (ide_get_geometry(arg->idebus[0], 1,\n&cylinders, &heads, &sectors) >= 0) {", "cmos_init_hd(s, 0x1a, 0x24, cylinders, heads, sectors);", "VAR_1 |= 0x0f;", "}", "rtc_set_memory(s, 0x12, VAR_1);", "VAR_1 = 0;", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "if (ide_get_geometry(arg->idebus[VAR_2 / 2], VAR_2 % 2,\n&cylinders, &heads, &sectors) >= 0) {", "VAR_3 = ide_get_bios_chs_trans(arg->idebus[VAR_2 / 2], VAR_2 % 2) - 1;", "assert((VAR_3 & ~3) == 0);", "VAR_1 |= VAR_3 << (VAR_2 * 2);", "}", "}", "rtc_set_memory(s, 0x39, VAR_1);", "for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(fdc_container_path); VAR_2++) {", "container = container_get(qdev_get_machine(), fdc_container_path[VAR_2]);", "object_child_foreach(container, check_fdc, &state);", "}", "if (state.multiple) {", "error_report(\"warning: multiple floppy disk controllers with \"\n\"iobase=0x3f0 have been found;\\n\"", "\"the one being picked for CMOS setup might not reflect \"\n\"your intent\");", "}", "pc_cmos_init_floppy(s, state.floppy);", "qemu_unregister_reset(FUNC_0, 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, 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, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99, 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ] ]

[ "static void FUNC_0(CPUState *VAR_0)\n{", "CPUState *cenv;", "int VAR_1, VAR_2, VAR_3 = VAR_0->cpuid_version;", "VAR_1 = (VAR_3 >> 8) & 0xf;", "VAR_2 = ((VAR_3 >> 12) & 0xf0) + ((VAR_3 >> 4) & 0xf);", "if ((VAR_1 == 6 && VAR_2 >= 14) || VAR_1 > 6) {", "for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {", "if (cenv == VAR_0) {", "continue;", "}", "kvm_inject_x86_mce(cenv, 1, MCI_STATUS_VAL | MCI_STATUS_UC,\nMCG_STATUS_MCIP | MCG_STATUS_RIPV, 0, 0,\nABORT_ON_ERROR);", "}", "}", "}" ]

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

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

[ "static struct omap_lpg_s *FUNC_0(MemoryRegion *VAR_0,\ntarget_phys_addr_t VAR_1, omap_clk VAR_2)\n{", "struct omap_lpg_s *VAR_3 = (struct omap_lpg_s *)\ng_malloc0(sizeof(struct omap_lpg_s));", "VAR_3->tm = qemu_new_timer_ms(vm_clock, omap_lpg_tick, VAR_3);", "omap_lpg_reset(VAR_3);", "memory_region_init_io(&VAR_3->iomem, &omap_lpg_ops, VAR_3, \"omap-lpg\", 0x800);", "memory_region_add_subregion(VAR_0, VAR_1, &VAR_3->iomem);", "omap_clk_adduser(VAR_2, qemu_allocate_irqs(omap_lpg_clk_update, VAR_3, 1)[0]);", "return VAR_3;", "}" ]

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

[ [ 1, 3, 5 ], [ 7, 9 ], [ 13 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ] ]

[ "static int FUNC_0(VAPICROMState *VAR_0, CPUX86State *VAR_1)\n{", "int VAR_2 = get_kpcr_number(VAR_1);", "target_phys_addr_t vapic_paddr;", "static const uint8_t VAR_3 = 1;", "if (VAR_2 < 0) {", "return -1;", "}", "vapic_paddr = VAR_0->vapic_paddr +\n(((target_phys_addr_t)VAR_2) << VAPIC_CPU_SHIFT);", "cpu_physical_memory_rw(vapic_paddr + offsetof(VAPICState, VAR_3),\n(void *)&VAR_3, sizeof(VAR_3), 1);", "apic_enable_vapic(VAR_1->apic_state, vapic_paddr);", "VAR_0->state = VAPIC_ACTIVE;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "if (VAR_3 != 4) {", "return omap_badwidth_write32(VAR_0, VAR_1, VAR_2);", "}", "OMAP_BAD_REG(VAR_1);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "UnmapCBData *data = VAR_0;", "SCSIDiskReq *r = data->r;", "SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);", "uint64_t sector_num;", "uint32_t nb_sectors;", "r->req.aiocb = NULL;", "if (r->req.io_canceled) {", "scsi_req_cancel_complete(&r->req);", "goto done;", "}", "if (VAR_1 < 0) {", "if (scsi_handle_rw_error(r, -VAR_1)) {", "goto done;", "}", "}", "if (data->count > 0) {", "sector_num = ldq_be_p(&data->inbuf[0]);", "nb_sectors = ldl_be_p(&data->inbuf[8]) & 0xffffffffULL;", "if (!check_lba_range(s, sector_num, nb_sectors)) {", "scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));", "goto done;", "}", "r->req.aiocb = bdrv_aio_discard(s->qdev.conf.bs,\nsector_num * (s->qdev.blocksize / 512),\nnb_sectors * (s->qdev.blocksize / 512),\nFUNC_0, data);", "data->count--;", "data->inbuf += 16;", "return;", "}", "scsi_req_complete(&r->req, GOOD);", "done:\nscsi_req_unref(&r->req);", "g_free(data);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59, 61, 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 79, 81 ], [ 83 ], [ 85 ] ]

[ "static void FUNC_0(uint8_t *VAR_0[4], int VAR_1[4], int VAR_2, int VAR_3){", "enum PixelFormat VAR_4, VAR_5;", "int VAR_6, VAR_7, VAR_8, VAR_9;", "int VAR_10;", "for (VAR_4 = 0; VAR_4 < PIX_FMT_NB; VAR_4++) {", "for (VAR_5 = 0; VAR_5 < PIX_FMT_NB; VAR_5++) {", "printf(\"%s -> %s\\n\",\nsws_format_name(VAR_4),\nsws_format_name(VAR_5));", "fflush(stdout);", "VAR_6= VAR_2;", "VAR_7= VAR_3;", "for (VAR_8=VAR_2 - VAR_2/3; VAR_8<= 4*VAR_2/3; VAR_8+= VAR_2/3){", "for (VAR_9=VAR_3 - VAR_3/3; VAR_9<= 4*VAR_3/3; VAR_9+= VAR_3/3){", "for (VAR_10=1; VAR_10<33; VAR_10*=2) {", "int res;", "res = doTest(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5,\nVAR_6, VAR_7, VAR_8, VAR_9, VAR_10);", "if (res < 0) {", "VAR_8 = 4 * VAR_2 / 3;", "VAR_9 = 4 * VAR_3 / 3;", "VAR_10 = 33;", "}", "}", "}", "}", "}", "}", "}" ]

[ 0, 0, 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, 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ] ]

[ "int FUNC_0(const char *VAR_0, const char **VAR_1, int VAR_2,\nint64_t *VAR_3)\n{", "char *VAR_4;", "int VAR_5 = 0;", "if (!VAR_0) {", "if (VAR_1) {", "*VAR_1 = VAR_0;", "}", "VAR_5 = -EINVAL;", "} else {", "errno = 0;", "*VAR_3 = strtoll(VAR_0, &VAR_4, VAR_2);", "VAR_5 = check_strtox_error(VAR_0, VAR_4, VAR_1, errno);", "}", "return VAR_5;", "}" ]

[ 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ] ]

[ "static int FUNC_0(RDMAContext *VAR_0,\nRDMAControlHeader *VAR_1, int VAR_2, int VAR_3)\n{", "int VAR_4 = qemu_rdma_block_for_wrid(VAR_0, RDMA_WRID_RECV_CONTROL + VAR_3);", "if (VAR_4 < 0) {", "fprintf(stderr, \"VAR_0 migration: recv polling control error!\\n\");", "return VAR_4;", "}", "network_to_control((void *) VAR_0->wr_data[VAR_3].control);", "memcpy(VAR_1, VAR_0->wr_data[VAR_3].control, sizeof(RDMAControlHeader));", "DDDPRINTF(\"CONTROL: %s receiving...\\n\", control_desc[VAR_2]);", "if (VAR_2 == RDMA_CONTROL_NONE) {", "DDDPRINTF(\"Surprise: got %s (%d)\\n\",\ncontrol_desc[VAR_1->type], VAR_1->type);", "} else if (VAR_1->type != VAR_2 || VAR_1->type == RDMA_CONTROL_ERROR) {", "fprintf(stderr, \"Was VAR_2 a %s (%d) control message\"\n\", but got: %s (%d), length: %d\\n\",\ncontrol_desc[VAR_2], VAR_2,\ncontrol_desc[VAR_1->type], VAR_1->type, VAR_1->len);", "return -EIO;", "}", "if (VAR_1->len > RDMA_CONTROL_MAX_BUFFER - sizeof(*VAR_1)) {", "fprintf(stderr, \"too long length: %d\\n\", VAR_1->len);", "return -EINVAL;", "}", "return 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 ], [ 27 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39, 41, 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ] ]

[ "static void FUNC_0(MemoryRegion *VAR_0, target_phys_addr_t VAR_1,\nstruct omap_mpu_state_s *VAR_2)\n{", "memory_region_init_io(&VAR_2->tcmi_iomem, &omap_tcmi_ops, VAR_2,\n\"omap-tcmi\", 0x100);", "memory_region_add_subregion(VAR_0, VAR_1, &VAR_2->tcmi_iomem);", "omap_tcmi_reset(VAR_2);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(MachineClass *VAR_0)\n{", "sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(VAR_0);", "VAR_0->alias = \"pseries\";", "VAR_0->is_default = 1;", "smc->dr_lmb_enabled = true;", "}" ]

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

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

[ "static int FUNC_0(CPUState *VAR_0, DisasContext *VAR_1, uint16_t VAR_2)\n{", "uint32_t insn, imm, shift, offset;", "uint32_t rd, rn, rm, rs;", "TCGv tmp;", "TCGv tmp2;", "TCGv tmp3;", "TCGv addr;", "TCGv_i64 tmp64;", "int VAR_3;", "int VAR_4;", "int VAR_5;", "int VAR_6;", "if (!(arm_feature(VAR_0, ARM_FEATURE_THUMB2)\n|| arm_feature (VAR_0, ARM_FEATURE_M))) {", "insn = VAR_2;", "if ((insn & (1 << 12)) == 0) {", "offset = ((insn & 0x7ff) << 1);", "tmp = load_reg(VAR_1, 14);", "tcg_gen_addi_i32(tmp, tmp, offset);", "tcg_gen_andi_i32(tmp, tmp, 0xfffffffc);", "tmp2 = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp2, VAR_1->pc | 1);", "store_reg(VAR_1, 14, tmp2);", "gen_bx(VAR_1, tmp);", "return 0;", "}", "if (insn & (1 << 11)) {", "offset = ((insn & 0x7ff) << 1) | 1;", "tmp = load_reg(VAR_1, 14);", "tcg_gen_addi_i32(tmp, tmp, offset);", "tmp2 = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp2, VAR_1->pc | 1);", "store_reg(VAR_1, 14, tmp2);", "gen_bx(VAR_1, tmp);", "return 0;", "}", "if ((VAR_1->pc & ~TARGET_PAGE_MASK) == 0) {", "offset = ((int32_t)insn << 21) >> 9;", "tcg_gen_movi_i32(cpu_R[14], VAR_1->pc + 2 + offset);", "return 0;", "}", "}", "insn = lduw_code(VAR_1->pc);", "VAR_1->pc += 2;", "insn |= (uint32_t)VAR_2 << 16;", "if ((insn & 0xf800e800) != 0xf000e800) {", "ARCH(6T2);", "}", "rn = (insn >> 16) & 0xf;", "rs = (insn >> 12) & 0xf;", "rd = (insn >> 8) & 0xf;", "rm = insn & 0xf;", "switch ((insn >> 25) & 0xf) {", "case 0: case 1: case 2: case 3:\nabort();", "case 4:\nif (insn & (1 << 22)) {", "if (insn & 0x01200000) {", "if (rn == 15) {", "addr = tcg_temp_new_i32();", "tcg_gen_movi_i32(addr, VAR_1->pc & ~3);", "} else {", "addr = load_reg(VAR_1, rn);", "}", "offset = (insn & 0xff) * 4;", "if ((insn & (1 << 23)) == 0)\noffset = -offset;", "if (insn & (1 << 24)) {", "tcg_gen_addi_i32(addr, addr, offset);", "offset = 0;", "}", "if (insn & (1 << 20)) {", "tmp = gen_ld32(addr, IS_USER(VAR_1));", "store_reg(VAR_1, rs, tmp);", "tcg_gen_addi_i32(addr, addr, 4);", "tmp = gen_ld32(addr, IS_USER(VAR_1));", "store_reg(VAR_1, rd, tmp);", "} else {", "tmp = load_reg(VAR_1, rs);", "gen_st32(tmp, addr, IS_USER(VAR_1));", "tcg_gen_addi_i32(addr, addr, 4);", "tmp = load_reg(VAR_1, rd);", "gen_st32(tmp, addr, IS_USER(VAR_1));", "}", "if (insn & (1 << 21)) {", "if (rn == 15)\ngoto illegal_op;", "tcg_gen_addi_i32(addr, addr, offset - 4);", "store_reg(VAR_1, rn, addr);", "} else {", "tcg_temp_free_i32(addr);", "}", "} else if ((insn & (1 << 23)) == 0) {", "addr = tcg_temp_local_new();", "load_reg_var(VAR_1, addr, rn);", "tcg_gen_addi_i32(addr, addr, (insn & 0xff) << 2);", "if (insn & (1 << 20)) {", "gen_load_exclusive(VAR_1, rs, 15, addr, 2);", "} else {", "gen_store_exclusive(VAR_1, rd, rs, 15, addr, 2);", "}", "tcg_temp_free(addr);", "} else if ((insn & (1 << 6)) == 0) {", "if (rn == 15) {", "addr = tcg_temp_new_i32();", "tcg_gen_movi_i32(addr, VAR_1->pc);", "} else {", "addr = load_reg(VAR_1, rn);", "}", "tmp = load_reg(VAR_1, rm);", "tcg_gen_add_i32(addr, addr, tmp);", "if (insn & (1 << 4)) {", "tcg_gen_add_i32(addr, addr, tmp);", "tcg_temp_free_i32(tmp);", "tmp = gen_ld16u(addr, IS_USER(VAR_1));", "} else {", "tcg_temp_free_i32(tmp);", "tmp = gen_ld8u(addr, IS_USER(VAR_1));", "}", "tcg_temp_free_i32(addr);", "tcg_gen_shli_i32(tmp, tmp, 1);", "tcg_gen_addi_i32(tmp, tmp, VAR_1->pc);", "store_reg(VAR_1, 15, tmp);", "} else {", "ARCH(7);", "VAR_3 = (insn >> 4) & 0x3;", "if (VAR_3 == 2) {", "goto illegal_op;", "}", "addr = tcg_temp_local_new();", "load_reg_var(VAR_1, addr, rn);", "if (insn & (1 << 20)) {", "gen_load_exclusive(VAR_1, rs, rd, addr, VAR_3);", "} else {", "gen_store_exclusive(VAR_1, rm, rs, rd, addr, VAR_3);", "}", "tcg_temp_free(addr);", "}", "} else {", "if (((insn >> 23) & 1) == ((insn >> 24) & 1)) {", "if (IS_USER(VAR_1))\ngoto illegal_op;", "if (insn & (1 << 20)) {", "addr = load_reg(VAR_1, rn);", "if ((insn & (1 << 24)) == 0)\ntcg_gen_addi_i32(addr, addr, -8);", "tmp = gen_ld32(addr, 0);", "tcg_gen_addi_i32(addr, addr, 4);", "tmp2 = gen_ld32(addr, 0);", "if (insn & (1 << 21)) {", "if (insn & (1 << 24)) {", "tcg_gen_addi_i32(addr, addr, 4);", "} else {", "tcg_gen_addi_i32(addr, addr, -4);", "}", "store_reg(VAR_1, rn, addr);", "} else {", "tcg_temp_free_i32(addr);", "}", "gen_rfe(VAR_1, tmp, tmp2);", "} else {", "VAR_3 = (insn & 0x1f);", "addr = tcg_temp_new_i32();", "tmp = tcg_const_i32(VAR_3);", "gen_helper_get_r13_banked(addr, cpu_env, tmp);", "tcg_temp_free_i32(tmp);", "if ((insn & (1 << 24)) == 0) {", "tcg_gen_addi_i32(addr, addr, -8);", "}", "tmp = load_reg(VAR_1, 14);", "gen_st32(tmp, addr, 0);", "tcg_gen_addi_i32(addr, addr, 4);", "tmp = tcg_temp_new_i32();", "gen_helper_cpsr_read(tmp);", "gen_st32(tmp, addr, 0);", "if (insn & (1 << 21)) {", "if ((insn & (1 << 24)) == 0) {", "tcg_gen_addi_i32(addr, addr, -4);", "} else {", "tcg_gen_addi_i32(addr, addr, 4);", "}", "tmp = tcg_const_i32(VAR_3);", "gen_helper_set_r13_banked(cpu_env, tmp, addr);", "tcg_temp_free_i32(tmp);", "} else {", "tcg_temp_free_i32(addr);", "}", "}", "} else {", "int VAR_7;", "addr = load_reg(VAR_1, rn);", "offset = 0;", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++) {", "if (insn & (1 << VAR_7))\noffset += 4;", "}", "if (insn & (1 << 24)) {", "tcg_gen_addi_i32(addr, addr, -offset);", "}", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++) {", "if ((insn & (1 << VAR_7)) == 0)\ncontinue;", "if (insn & (1 << 20)) {", "tmp = gen_ld32(addr, IS_USER(VAR_1));", "if (VAR_7 == 15) {", "gen_bx(VAR_1, tmp);", "} else {", "store_reg(VAR_1, VAR_7, tmp);", "}", "} else {", "tmp = load_reg(VAR_1, VAR_7);", "gen_st32(tmp, addr, IS_USER(VAR_1));", "}", "tcg_gen_addi_i32(addr, addr, 4);", "}", "if (insn & (1 << 21)) {", "if (insn & (1 << 24)) {", "tcg_gen_addi_i32(addr, addr, -offset);", "}", "if (insn & (1 << rn))\ngoto illegal_op;", "store_reg(VAR_1, rn, addr);", "} else {", "tcg_temp_free_i32(addr);", "}", "}", "}", "break;", "case 5:\nVAR_3 = (insn >> 21) & 0xf;", "if (VAR_3 == 6) {", "tmp = load_reg(VAR_1, rn);", "tmp2 = load_reg(VAR_1, rm);", "shift = ((insn >> 10) & 0x1c) | ((insn >> 6) & 0x3);", "if (insn & (1 << 5)) {", "if (shift == 0)\nshift = 31;", "tcg_gen_sari_i32(tmp2, tmp2, shift);", "tcg_gen_andi_i32(tmp, tmp, 0xffff0000);", "tcg_gen_ext16u_i32(tmp2, tmp2);", "} else {", "if (shift)\ntcg_gen_shli_i32(tmp2, tmp2, shift);", "tcg_gen_ext16u_i32(tmp, tmp);", "tcg_gen_andi_i32(tmp2, tmp2, 0xffff0000);", "}", "tcg_gen_or_i32(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "store_reg(VAR_1, rd, tmp);", "} else {", "if (rn == 15) {", "tmp = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp, 0);", "} else {", "tmp = load_reg(VAR_1, rn);", "}", "tmp2 = load_reg(VAR_1, rm);", "VAR_4 = (insn >> 4) & 3;", "shift = ((insn >> 6) & 3) | ((insn >> 10) & 0x1c);", "VAR_5 = (insn & (1 << 20)) != 0;", "VAR_6 = (VAR_5 && thumb2_logic_op(VAR_3));", "gen_arm_shift_im(tmp2, VAR_4, shift, VAR_6);", "if (gen_thumb2_data_op(VAR_1, VAR_3, VAR_5, 0, tmp, tmp2))\ngoto illegal_op;", "tcg_temp_free_i32(tmp2);", "if (rd != 15) {", "store_reg(VAR_1, rd, tmp);", "} else {", "tcg_temp_free_i32(tmp);", "}", "}", "break;", "case 13:\nVAR_3 = ((insn >> 22) & 6) | ((insn >> 7) & 1);", "if (VAR_3 < 4 && (insn & 0xf000) != 0xf000)\ngoto illegal_op;", "switch (VAR_3) {", "case 0:\ntmp = load_reg(VAR_1, rn);", "tmp2 = load_reg(VAR_1, rm);", "if ((insn & 0x70) != 0)\ngoto illegal_op;", "VAR_3 = (insn >> 21) & 3;", "VAR_6 = (insn & (1 << 20)) != 0;", "gen_arm_shift_reg(tmp, VAR_3, tmp2, VAR_6);", "if (VAR_6)\ngen_logic_CC(tmp);", "store_reg_bx(VAR_0, VAR_1, rd, tmp);", "break;", "case 1:\ntmp = load_reg(VAR_1, rm);", "shift = (insn >> 4) & 3;", "if (shift != 0)\ntcg_gen_rotri_i32(tmp, tmp, shift * 8);", "VAR_3 = (insn >> 20) & 7;", "switch (VAR_3) {", "case 0: gen_sxth(tmp); break;", "case 1: gen_uxth(tmp); break;", "case 2: gen_sxtb16(tmp); break;", "case 3: gen_uxtb16(tmp); break;", "case 4: gen_sxtb(tmp); break;", "case 5: gen_uxtb(tmp); break;", "default: goto illegal_op;", "}", "if (rn != 15) {", "tmp2 = load_reg(VAR_1, rn);", "if ((VAR_3 >> 1) == 1) {", "gen_add16(tmp, tmp2);", "} else {", "tcg_gen_add_i32(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "}", "}", "store_reg(VAR_1, rd, tmp);", "break;", "case 2:\nVAR_3 = (insn >> 20) & 7;", "shift = (insn >> 4) & 7;", "if ((VAR_3 & 3) == 3 || (shift & 3) == 3)\ngoto illegal_op;", "tmp = load_reg(VAR_1, rn);", "tmp2 = load_reg(VAR_1, rm);", "gen_thumb2_parallel_addsub(VAR_3, shift, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "store_reg(VAR_1, rd, tmp);", "break;", "case 3:\nVAR_3 = ((insn >> 17) & 0x38) | ((insn >> 4) & 7);", "if (VAR_3 < 4) {", "tmp = load_reg(VAR_1, rn);", "tmp2 = load_reg(VAR_1, rm);", "if (VAR_3 & 1)\ngen_helper_double_saturate(tmp, tmp);", "if (VAR_3 & 2)\ngen_helper_sub_saturate(tmp, tmp2, tmp);", "else\ngen_helper_add_saturate(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "} else {", "tmp = load_reg(VAR_1, rn);", "switch (VAR_3) {", "case 0x0a:\ngen_helper_rbit(tmp, tmp);", "break;", "case 0x08:\ntcg_gen_bswap32_i32(tmp, tmp);", "break;", "case 0x09:\ngen_rev16(tmp);", "break;", "case 0x0b:\ngen_revsh(tmp);", "break;", "case 0x10:\ntmp2 = load_reg(VAR_1, rm);", "tmp3 = tcg_temp_new_i32();", "tcg_gen_ld_i32(tmp3, cpu_env, offsetof(CPUState, GE));", "gen_helper_sel_flags(tmp, tmp3, tmp, tmp2);", "tcg_temp_free_i32(tmp3);", "tcg_temp_free_i32(tmp2);", "break;", "case 0x18:\ngen_helper_clz(tmp, tmp);", "break;", "default:\ngoto illegal_op;", "}", "}", "store_reg(VAR_1, rd, tmp);", "break;", "case 4: case 5:\nVAR_3 = (insn >> 4) & 0xf;", "tmp = load_reg(VAR_1, rn);", "tmp2 = load_reg(VAR_1, rm);", "switch ((insn >> 20) & 7) {", "case 0:\ntcg_gen_mul_i32(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "if (rs != 15) {", "tmp2 = load_reg(VAR_1, rs);", "if (VAR_3)\ntcg_gen_sub_i32(tmp, tmp2, tmp);", "else\ntcg_gen_add_i32(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "}", "break;", "case 1:\ngen_mulxy(tmp, tmp2, VAR_3 & 2, VAR_3 & 1);", "tcg_temp_free_i32(tmp2);", "if (rs != 15) {", "tmp2 = load_reg(VAR_1, rs);", "gen_helper_add_setq(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "}", "break;", "case 2:\ncase 4:\nif (VAR_3)\ngen_swap_half(tmp2);", "gen_smul_dual(tmp, tmp2);", "if (insn & (1 << 22)) {", "tcg_gen_sub_i32(tmp, tmp, tmp2);", "} else {", "tcg_gen_add_i32(tmp, tmp, tmp2);", "}", "tcg_temp_free_i32(tmp2);", "if (rs != 15)\n{", "tmp2 = load_reg(VAR_1, rs);", "gen_helper_add_setq(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "}", "break;", "case 3:\nif (VAR_3)\ntcg_gen_sari_i32(tmp2, tmp2, 16);", "else\ngen_sxth(tmp2);", "tmp64 = gen_muls_i64_i32(tmp, tmp2);", "tcg_gen_shri_i64(tmp64, tmp64, 16);", "tmp = tcg_temp_new_i32();", "tcg_gen_trunc_i64_i32(tmp, tmp64);", "tcg_temp_free_i64(tmp64);", "if (rs != 15)\n{", "tmp2 = load_reg(VAR_1, rs);", "gen_helper_add_setq(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "}", "break;", "case 5: case 6:\ntmp64 = gen_muls_i64_i32(tmp, tmp2);", "if (rs != 15) {", "tmp = load_reg(VAR_1, rs);", "if (insn & (1 << 20)) {", "tmp64 = gen_addq_msw(tmp64, tmp);", "} else {", "tmp64 = gen_subq_msw(tmp64, tmp);", "}", "}", "if (insn & (1 << 4)) {", "tcg_gen_addi_i64(tmp64, tmp64, 0x80000000u);", "}", "tcg_gen_shri_i64(tmp64, tmp64, 32);", "tmp = tcg_temp_new_i32();", "tcg_gen_trunc_i64_i32(tmp, tmp64);", "tcg_temp_free_i64(tmp64);", "break;", "case 7:\ngen_helper_usad8(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "if (rs != 15) {", "tmp2 = load_reg(VAR_1, rs);", "tcg_gen_add_i32(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "}", "break;", "}", "store_reg(VAR_1, rd, tmp);", "break;", "case 6: case 7:\nVAR_3 = ((insn >> 4) & 0xf) | ((insn >> 16) & 0x70);", "tmp = load_reg(VAR_1, rn);", "tmp2 = load_reg(VAR_1, rm);", "if ((VAR_3 & 0x50) == 0x10) {", "if (!arm_feature(VAR_0, ARM_FEATURE_DIV))\ngoto illegal_op;", "if (VAR_3 & 0x20)\ngen_helper_udiv(tmp, tmp, tmp2);", "else\ngen_helper_sdiv(tmp, tmp, tmp2);", "tcg_temp_free_i32(tmp2);", "store_reg(VAR_1, rd, tmp);", "} else if ((VAR_3 & 0xe) == 0xc) {", "if (VAR_3 & 1)\ngen_swap_half(tmp2);", "gen_smul_dual(tmp, tmp2);", "if (VAR_3 & 0x10) {", "tcg_gen_sub_i32(tmp, tmp, tmp2);", "} else {", "tcg_gen_add_i32(tmp, tmp, tmp2);", "}", "tcg_temp_free_i32(tmp2);", "tmp64 = tcg_temp_new_i64();", "tcg_gen_ext_i32_i64(tmp64, tmp);", "tcg_temp_free_i32(tmp);", "gen_addq(VAR_1, tmp64, rs, rd);", "gen_storeq_reg(VAR_1, rs, rd, tmp64);", "tcg_temp_free_i64(tmp64);", "} else {", "if (VAR_3 & 0x20) {", "tmp64 = gen_mulu_i64_i32(tmp, tmp2);", "} else {", "if (VAR_3 & 8) {", "gen_mulxy(tmp, tmp2, VAR_3 & 2, VAR_3 & 1);", "tcg_temp_free_i32(tmp2);", "tmp64 = tcg_temp_new_i64();", "tcg_gen_ext_i32_i64(tmp64, tmp);", "tcg_temp_free_i32(tmp);", "} else {", "tmp64 = gen_muls_i64_i32(tmp, tmp2);", "}", "}", "if (VAR_3 & 4) {", "gen_addq_lo(VAR_1, tmp64, rs);", "gen_addq_lo(VAR_1, tmp64, rd);", "} else if (VAR_3 & 0x40) {", "gen_addq(VAR_1, tmp64, rs, rd);", "}", "gen_storeq_reg(VAR_1, rs, rd, tmp64);", "tcg_temp_free_i64(tmp64);", "}", "break;", "}", "break;", "case 6: case 7: case 14: case 15:\nif (((insn >> 24) & 3) == 3) {", "insn = (insn & 0xe2ffffff) | ((insn & (1 << 28)) >> 4) | (1 << 28);", "if (disas_neon_data_insn(VAR_0, VAR_1, insn))\ngoto illegal_op;", "} else {", "if (insn & (1 << 28))\ngoto illegal_op;", "if (disas_coproc_insn (VAR_0, VAR_1, insn))\ngoto illegal_op;", "}", "break;", "case 8: case 9: case 10: case 11:\nif (insn & (1 << 15)) {", "if (insn & 0x5000) {", "offset = ((int32_t)insn << 5) >> 9 & ~(int32_t)0xfff;", "offset |= (insn & 0x7ff) << 1;", "offset ^= ((~insn) & (1 << 13)) << 10;", "offset ^= ((~insn) & (1 << 11)) << 11;", "if (insn & (1 << 14)) {", "tcg_gen_movi_i32(cpu_R[14], VAR_1->pc | 1);", "}", "offset += VAR_1->pc;", "if (insn & (1 << 12)) {", "gen_jmp(VAR_1, offset);", "} else {", "offset &= ~(uint32_t)2;", "gen_bx_im(VAR_1, offset);", "}", "} else if (((insn >> 23) & 7) == 7) {", "if (insn & (1 << 13))\ngoto illegal_op;", "if (insn & (1 << 26)) {", "goto illegal_op;", "} else {", "VAR_3 = (insn >> 20) & 7;", "switch (VAR_3) {", "case 0:\nif (IS_M(VAR_0)) {", "tmp = load_reg(VAR_1, rn);", "addr = tcg_const_i32(insn & 0xff);", "gen_helper_v7m_msr(cpu_env, addr, tmp);", "tcg_temp_free_i32(addr);", "tcg_temp_free_i32(tmp);", "gen_lookup_tb(VAR_1);", "break;", "}", "case 1:\nif (IS_M(VAR_0))\ngoto illegal_op;", "tmp = load_reg(VAR_1, rn);", "if (gen_set_psr(VAR_1,\nmsr_mask(VAR_0, VAR_1, (insn >> 8) & 0xf, VAR_3 == 1),\nVAR_3 == 1, tmp))\ngoto illegal_op;", "break;", "case 2:\nif (((insn >> 8) & 7) == 0) {", "gen_nop_hint(VAR_1, insn & 0xff);", "}", "if (IS_USER(VAR_1))\nbreak;", "offset = 0;", "imm = 0;", "if (insn & (1 << 10)) {", "if (insn & (1 << 7))\noffset |= CPSR_A;", "if (insn & (1 << 6))\noffset |= CPSR_I;", "if (insn & (1 << 5))\noffset |= CPSR_F;", "if (insn & (1 << 9))\nimm = CPSR_A | CPSR_I | CPSR_F;", "}", "if (insn & (1 << 8)) {", "offset |= 0x1f;", "imm |= (insn & 0x1f);", "}", "if (offset) {", "gen_set_psr_im(VAR_1, offset, 0, imm);", "}", "break;", "case 3:\nARCH(7);", "VAR_3 = (insn >> 4) & 0xf;", "switch (VAR_3) {", "case 2:\ngen_clrex(VAR_1);", "break;", "case 4:\ncase 5:\ncase 6:\nbreak;", "default:\ngoto illegal_op;", "}", "break;", "case 4:\ntmp = load_reg(VAR_1, rn);", "gen_bx(VAR_1, tmp);", "break;", "case 5:\nif (IS_USER(VAR_1)) {", "goto illegal_op;", "}", "if (rn != 14 || rd != 15) {", "goto illegal_op;", "}", "tmp = load_reg(VAR_1, rn);", "tcg_gen_subi_i32(tmp, tmp, insn & 0xff);", "gen_exception_return(VAR_1, tmp);", "break;", "case 6:\ntmp = tcg_temp_new_i32();", "if (IS_M(VAR_0)) {", "addr = tcg_const_i32(insn & 0xff);", "gen_helper_v7m_mrs(tmp, cpu_env, addr);", "tcg_temp_free_i32(addr);", "} else {", "gen_helper_cpsr_read(tmp);", "}", "store_reg(VAR_1, rd, tmp);", "break;", "case 7:\nif (IS_USER(VAR_1) || IS_M(VAR_0))\ngoto illegal_op;", "tmp = load_cpu_field(spsr);", "store_reg(VAR_1, rd, tmp);", "break;", "}", "}", "} else {", "VAR_3 = (insn >> 22) & 0xf;", "VAR_1->condlabel = gen_new_label();", "gen_test_cc(VAR_3 ^ 1, VAR_1->condlabel);", "VAR_1->condjmp = 1;", "offset = (insn & 0x7ff) << 1;", "offset |= (insn & 0x003f0000) >> 4;", "offset |= ((int32_t)((insn << 5) & 0x80000000)) >> 11;", "offset |= (insn & (1 << 13)) << 5;", "offset |= (insn & (1 << 11)) << 8;", "gen_jmp(VAR_1, VAR_1->pc + offset);", "}", "} else {", "if (insn & (1 << 25)) {", "if (insn & (1 << 24)) {", "if (insn & (1 << 20))\ngoto illegal_op;", "VAR_3 = (insn >> 21) & 7;", "imm = insn & 0x1f;", "shift = ((insn >> 6) & 3) | ((insn >> 10) & 0x1c);", "if (rn == 15) {", "tmp = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp, 0);", "} else {", "tmp = load_reg(VAR_1, rn);", "}", "switch (VAR_3) {", "case 2:\nimm++;", "if (shift + imm > 32)\ngoto illegal_op;", "if (imm < 32)\ngen_sbfx(tmp, shift, imm);", "break;", "case 6:\nimm++;", "if (shift + imm > 32)\ngoto illegal_op;", "if (imm < 32)\ngen_ubfx(tmp, shift, (1u << imm) - 1);", "break;", "case 3:\nif (imm < shift)\ngoto illegal_op;", "imm = imm + 1 - shift;", "if (imm != 32) {", "tmp2 = load_reg(VAR_1, rd);", "gen_bfi(tmp, tmp2, tmp, shift, (1u << imm) - 1);", "tcg_temp_free_i32(tmp2);", "}", "break;", "case 7:\ngoto illegal_op;", "default:\nif (shift) {", "if (VAR_3 & 1)\ntcg_gen_sari_i32(tmp, tmp, shift);", "else\ntcg_gen_shli_i32(tmp, tmp, shift);", "}", "tmp2 = tcg_const_i32(imm);", "if (VAR_3 & 4) {", "if ((VAR_3 & 1) && shift == 0)\ngen_helper_usat16(tmp, tmp, tmp2);", "else\ngen_helper_usat(tmp, tmp, tmp2);", "} else {", "if ((VAR_3 & 1) && shift == 0)\ngen_helper_ssat16(tmp, tmp, tmp2);", "else\ngen_helper_ssat(tmp, tmp, tmp2);", "}", "tcg_temp_free_i32(tmp2);", "break;", "}", "store_reg(VAR_1, rd, tmp);", "} else {", "imm = ((insn & 0x04000000) >> 15)\n| ((insn & 0x7000) >> 4) | (insn & 0xff);", "if (insn & (1 << 22)) {", "imm |= (insn >> 4) & 0xf000;", "if (insn & (1 << 23)) {", "tmp = load_reg(VAR_1, rd);", "tcg_gen_ext16u_i32(tmp, tmp);", "tcg_gen_ori_i32(tmp, tmp, imm << 16);", "} else {", "tmp = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp, imm);", "}", "} else {", "if (rn == 15) {", "offset = VAR_1->pc & ~(uint32_t)3;", "if (insn & (1 << 23))\noffset -= imm;", "else\noffset += imm;", "tmp = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp, offset);", "} else {", "tmp = load_reg(VAR_1, rn);", "if (insn & (1 << 23))\ntcg_gen_subi_i32(tmp, tmp, imm);", "else\ntcg_gen_addi_i32(tmp, tmp, imm);", "}", "}", "store_reg(VAR_1, rd, tmp);", "}", "} else {", "int VAR_8 = 0;", "shift = ((insn & 0x04000000) >> 23) | ((insn & 0x7000) >> 12);", "imm = (insn & 0xff);", "switch (shift) {", "case 0:\nbreak;", "case 1:\nimm |= imm << 16;", "break;", "case 2:\nimm |= imm << 16;", "imm <<= 8;", "break;", "case 3:\nimm |= imm << 16;", "imm |= imm << 8;", "break;", "default:\nshift = (shift << 1) | (imm >> 7);", "imm |= 0x80;", "imm = imm << (32 - shift);", "VAR_8 = 1;", "break;", "}", "tmp2 = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp2, imm);", "rn = (insn >> 16) & 0xf;", "if (rn == 15) {", "tmp = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp, 0);", "} else {", "tmp = load_reg(VAR_1, rn);", "}", "VAR_3 = (insn >> 21) & 0xf;", "if (gen_thumb2_data_op(VAR_1, VAR_3, (insn & (1 << 20)) != 0,\nVAR_8, tmp, tmp2))\ngoto illegal_op;", "tcg_temp_free_i32(tmp2);", "rd = (insn >> 8) & 0xf;", "if (rd != 15) {", "store_reg(VAR_1, rd, tmp);", "} else {", "tcg_temp_free_i32(tmp);", "}", "}", "}", "break;", "case 12:\n{", "int VAR_9 = 0;", "int VAR_10 = 0;", "int VAR_11;", "if ((insn & 0x01100000) == 0x01000000) {", "if (disas_neon_ls_insn(VAR_0, VAR_1, insn))\ngoto illegal_op;", "break;", "}", "VAR_3 = ((insn >> 21) & 3) | ((insn >> 22) & 4);", "if (rs == 15) {", "if (!(insn & (1 << 20))) {", "goto illegal_op;", "}", "if (VAR_3 != 2) {", "int VAR_12 = (insn >> 23) & 3;", "int VAR_13 = (insn >> 6) & 0x3f;", "if (VAR_3 & 2) {", "goto illegal_op;", "}", "if (rn == 15) {", "return 0;", "}", "if (VAR_12 & 1) {", "return 0;", "}", "if ((VAR_13 == 0) || ((VAR_13 & 0x3c) == 0x30)) {", "return 0;", "}", "return 1;", "}", "}", "VAR_11 = IS_USER(VAR_1);", "if (rn == 15) {", "addr = tcg_temp_new_i32();", "imm = VAR_1->pc & 0xfffffffc;", "if (insn & (1 << 23))\nimm += insn & 0xfff;", "else\nimm -= insn & 0xfff;", "tcg_gen_movi_i32(addr, imm);", "} else {", "addr = load_reg(VAR_1, rn);", "if (insn & (1 << 23)) {", "imm = insn & 0xfff;", "tcg_gen_addi_i32(addr, addr, imm);", "} else {", "imm = insn & 0xff;", "switch ((insn >> 8) & 0xf) {", "case 0x0:\nshift = (insn >> 4) & 0xf;", "if (shift > 3) {", "tcg_temp_free_i32(addr);", "goto illegal_op;", "}", "tmp = load_reg(VAR_1, rm);", "if (shift)\ntcg_gen_shli_i32(tmp, tmp, shift);", "tcg_gen_add_i32(addr, addr, tmp);", "tcg_temp_free_i32(tmp);", "break;", "case 0xc:\ntcg_gen_addi_i32(addr, addr, -imm);", "break;", "case 0xe:\ntcg_gen_addi_i32(addr, addr, imm);", "VAR_11 = 1;", "break;", "case 0x9:\nimm = -imm;", "case 0xb:\nVAR_9 = 1;", "VAR_10 = 1;", "break;", "case 0xd:\nimm = -imm;", "case 0xf:\ntcg_gen_addi_i32(addr, addr, imm);", "VAR_10 = 1;", "break;", "default:\ntcg_temp_free_i32(addr);", "goto illegal_op;", "}", "}", "}", "if (insn & (1 << 20)) {", "switch (VAR_3) {", "case 0: tmp = gen_ld8u(addr, VAR_11); break;", "case 4: tmp = gen_ld8s(addr, VAR_11); break;", "case 1: tmp = gen_ld16u(addr, VAR_11); break;", "case 5: tmp = gen_ld16s(addr, VAR_11); break;", "case 2: tmp = gen_ld32(addr, VAR_11); break;", "default:\ntcg_temp_free_i32(addr);", "goto illegal_op;", "}", "if (rs == 15) {", "gen_bx(VAR_1, tmp);", "} else {", "store_reg(VAR_1, rs, tmp);", "}", "} else {", "tmp = load_reg(VAR_1, rs);", "switch (VAR_3) {", "case 0: gen_st8(tmp, addr, VAR_11); break;", "case 1: gen_st16(tmp, addr, VAR_11); break;", "case 2: gen_st32(tmp, addr, VAR_11); break;", "default:\ntcg_temp_free_i32(addr);", "goto illegal_op;", "}", "}", "if (VAR_9)\ntcg_gen_addi_i32(addr, addr, imm);", "if (VAR_10) {", "store_reg(VAR_1, rn, addr);", "} else {", "tcg_temp_free_i32(addr);", "}", "}", "break;", "default:\ngoto illegal_op;", "}", "return 0;", "illegal_op:\nreturn 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137, 141 ], [ 143, 145 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 213, 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 331 ], [ 335, 337 ], [ 339 ], [ 343 ], [ 345, 347 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 445 ], [ 447 ], [ 449 ], [ 451, 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 465 ], [ 467, 469 ], [ 471 ], [ 475 ], [ 477 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 491 ], [ 493 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 505 ], [ 507 ], [ 509 ], [ 513, 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531, 535 ], [ 537 ], [ 541 ], [ 543 ], [ 545 ], [ 547 ], [ 551, 553 ], [ 555 ], [ 557 ], [ 559 ], [ 561 ], [ 565, 567 ], [ 569 ], [ 571 ], [ 573 ], [ 575 ], [ 577 ], [ 579 ], [ 581 ], [ 585 ], [ 587 ], [ 589 ], [ 591 ], [ 593 ], [ 595 ], [ 597 ], [ 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 ], [ 681 ], [ 683 ], [ 685 ], [ 687 ], [ 689 ], [ 691 ], [ 693 ], [ 695 ], [ 697 ], [ 699 ], [ 701 ], [ 703 ], [ 705 ], [ 707 ], [ 709 ], [ 711 ], [ 713 ], [ 715 ], [ 717 ], [ 719 ], [ 721, 723 ], [ 725 ], [ 727, 729 ], [ 731 ], [ 733 ], [ 735 ], [ 737 ], [ 739 ], [ 741 ], [ 743, 745 ], [ 747 ], [ 751 ], [ 753 ], [ 755, 757 ], [ 759, 761 ], [ 763, 765 ], [ 767 ], [ 769 ], [ 771 ], [ 773 ], [ 775, 777 ], [ 779 ], [ 781, 783 ], [ 785 ], [ 787, 789 ], [ 791 ], [ 793, 795 ], [ 797 ], [ 799, 801 ], [ 803 ], [ 805 ], [ 807 ], [ 809 ], [ 811 ], [ 813 ], [ 815, 817 ], [ 819 ], [ 821, 823 ], [ 825 ], [ 827 ], [ 829 ], [ 831 ], [ 833, 835 ], [ 837 ], [ 839 ], [ 841 ], [ 843, 845 ], [ 847 ], [ 849 ], [ 851 ], [ 853, 855 ], [ 857, 859 ], [ 861 ], [ 863 ], [ 865 ], [ 867, 869 ], [ 871 ], [ 873 ], [ 875 ], [ 877 ], [ 879 ], [ 881 ], [ 883 ], [ 885, 887, 889, 891 ], [ 893 ], [ 897 ], [ 899 ], [ 901 ], [ 903 ], [ 905 ], [ 907 ], [ 909, 911 ], [ 913 ], [ 915 ], [ 917 ], [ 919 ], [ 921 ], [ 923, 925, 927 ], [ 929, 931 ], [ 933 ], [ 935 ], [ 937 ], [ 939 ], [ 941 ], [ 943, 945 ], [ 947 ], [ 949 ], [ 951 ], [ 953 ], [ 955 ], [ 957, 959 ], [ 961 ], [ 963 ], [ 965 ], [ 967 ], [ 969 ], [ 971 ], [ 973 ], [ 975 ], [ 977 ], [ 979 ], [ 981 ], [ 983 ], [ 985 ], [ 987 ], [ 989 ], [ 991 ], [ 993, 995 ], [ 997 ], [ 999 ], [ 1001 ], [ 1003 ], [ 1005 ], [ 1007 ], [ 1009 ], [ 1011 ], [ 1013 ], [ 1015 ], [ 1017, 1019 ], [ 1021 ], [ 1023 ], [ 1025 ], [ 1029, 1031 ], [ 1033, 1035 ], [ 1037, 1039 ], [ 1041 ], [ 1043 ], [ 1045 ], [ 1049, 1051 ], [ 1053 ], [ 1055 ], [ 1057 ], [ 1059 ], [ 1061 ], [ 1063 ], [ 1065 ], [ 1069 ], [ 1071 ], [ 1073 ], [ 1075 ], [ 1077 ], [ 1079 ], [ 1081 ], [ 1083 ], [ 1087 ], [ 1089 ], [ 1091 ], [ 1095 ], [ 1097 ], [ 1099 ], [ 1101 ], [ 1103 ], [ 1105 ], [ 1109 ], [ 1111 ], [ 1113 ], [ 1115 ], [ 1119 ], [ 1121 ], [ 1123 ], [ 1127 ], [ 1129 ], [ 1131 ], [ 1133 ], [ 1135 ], [ 1137 ], [ 1139 ], [ 1141 ], [ 1143, 1147 ], [ 1151 ], [ 1153, 1155 ], [ 1157 ], [ 1159, 1161 ], [ 1163, 1165 ], [ 1167 ], [ 1169 ], [ 1171, 1173 ], [ 1177 ], [ 1183 ], [ 1187 ], [ 1195 ], [ 1197 ], [ 1201 ], [ 1205 ], [ 1207 ], [ 1211 ], [ 1213 ], [ 1217 ], [ 1219 ], [ 1223 ], [ 1225 ], [ 1227 ], [ 1229 ], [ 1233, 1235 ], [ 1239 ], [ 1243 ], [ 1245 ], [ 1247 ], [ 1249 ], [ 1251, 1253 ], [ 1255 ], [ 1257 ], [ 1259 ], [ 1261 ], [ 1263 ], [ 1265 ], [ 1267 ], [ 1269 ], [ 1273, 1275, 1277 ], [ 1279 ], [ 1281, 1283, 1285, 1287 ], [ 1289 ], [ 1291, 1293 ], [ 1295 ], [ 1297 ], [ 1301, 1303 ], [ 1305 ], [ 1307 ], [ 1309 ], [ 1311, 1313 ], [ 1315, 1317 ], [ 1319, 1321 ], [ 1323, 1325 ], [ 1327 ], [ 1329 ], [ 1331 ], [ 1333 ], [ 1335 ], [ 1337 ], [ 1339 ], [ 1341 ], [ 1343 ], [ 1345, 1347 ], [ 1349 ], [ 1351 ], [ 1353, 1355 ], [ 1357 ], [ 1359, 1361, 1363, 1367 ], [ 1369, 1371 ], [ 1373 ], [ 1375 ], [ 1377, 1381 ], [ 1383 ], [ 1385 ], [ 1387, 1389 ], [ 1391 ], [ 1393 ], [ 1395 ], [ 1397 ], [ 1399 ], [ 1401 ], [ 1403 ], [ 1405 ], [ 1407 ], [ 1409, 1411 ], [ 1413 ], [ 1415 ], [ 1417 ], [ 1419 ], [ 1421 ], [ 1423 ], [ 1425 ], [ 1427 ], [ 1429 ], [ 1431, 1435, 1437 ], [ 1439 ], [ 1441 ], [ 1443 ], [ 1445 ], [ 1447 ], [ 1449 ], [ 1453 ], [ 1457 ], [ 1459 ], [ 1461 ], [ 1467 ], [ 1471 ], [ 1475 ], [ 1479 ], [ 1483 ], [ 1489 ], [ 1491 ], [ 1493 ], [ 1497 ], [ 1499 ], [ 1501, 1503 ], [ 1507 ], [ 1509 ], [ 1511 ], [ 1513 ], [ 1515 ], [ 1517 ], [ 1519 ], [ 1521 ], [ 1523 ], [ 1525 ], [ 1527, 1529 ], [ 1531, 1533 ], [ 1535, 1537 ], [ 1539 ], [ 1541, 1543 ], [ 1545, 1547 ], [ 1549, 1551 ], [ 1553 ], [ 1555, 1557, 1559 ], [ 1561 ], [ 1563 ], [ 1565 ], [ 1567 ], [ 1569 ], [ 1571 ], [ 1573 ], [ 1575, 1577 ], [ 1579, 1581 ], [ 1583, 1585 ], [ 1587, 1589 ], [ 1591 ], [ 1593 ], [ 1595 ], [ 1599, 1601 ], [ 1603, 1605 ], [ 1607 ], [ 1611, 1613 ], [ 1615, 1617 ], [ 1619 ], [ 1621 ], [ 1623 ], [ 1625 ], [ 1627 ], [ 1629 ], [ 1631, 1633 ], [ 1635 ], [ 1639 ], [ 1641 ], [ 1645 ], [ 1647 ], [ 1649 ], [ 1651 ], [ 1655 ], [ 1657 ], [ 1659 ], [ 1661 ], [ 1665 ], [ 1667 ], [ 1669, 1671 ], [ 1673, 1675 ], [ 1677 ], [ 1679 ], [ 1681 ], [ 1683 ], [ 1685, 1687 ], [ 1689, 1691 ], [ 1693 ], [ 1695 ], [ 1697 ], [ 1699 ], [ 1701 ], [ 1703 ], [ 1707 ], [ 1709 ], [ 1711 ], [ 1713, 1717 ], [ 1719, 1721 ], [ 1723 ], [ 1725, 1727 ], [ 1729 ], [ 1731 ], [ 1733, 1735 ], [ 1737 ], [ 1739 ], [ 1741, 1743 ], [ 1745 ], [ 1747 ], [ 1749 ], [ 1751 ], [ 1753 ], [ 1755 ], [ 1757 ], [ 1759 ], [ 1761 ], [ 1763 ], [ 1765 ], [ 1767 ], [ 1769 ], [ 1771 ], [ 1773 ], [ 1775, 1777, 1779 ], [ 1781 ], [ 1783 ], [ 1785 ], [ 1787 ], [ 1789 ], [ 1791 ], [ 1793 ], [ 1795 ], [ 1797 ], [ 1799 ], [ 1801, 1803 ], [ 1805 ], [ 1807 ], [ 1809 ], [ 1811 ], [ 1813, 1815 ], [ 1817 ], [ 1819 ], [ 1821 ], [ 1823 ], [ 1825 ], [ 1827 ], [ 1829 ], [ 1831 ], [ 1855 ], [ 1857 ], [ 1859 ], [ 1861 ], [ 1863 ], [ 1865 ], [ 1869 ], [ 1871 ], [ 1873 ], [ 1875 ], [ 1877 ], [ 1879 ], [ 1881 ], [ 1883 ], [ 1887 ], [ 1889 ], [ 1891 ], [ 1893 ], [ 1895 ], [ 1897 ], [ 1903 ], [ 1905, 1907 ], [ 1909, 1911 ], [ 1913 ], [ 1915 ], [ 1917 ], [ 1919 ], [ 1923 ], [ 1925 ], [ 1927 ], [ 1929 ], [ 1931 ], [ 1933, 1935 ], [ 1937 ], [ 1939 ], [ 1941 ], [ 1943 ], [ 1945 ], [ 1947, 1949 ], [ 1951 ], [ 1953 ], [ 1955 ], [ 1957, 1959 ], [ 1961 ], [ 1963, 1965 ], [ 1967 ], [ 1969 ], [ 1971, 1973 ], [ 1977, 1979 ], [ 1981 ], [ 1983 ], [ 1985, 1987 ], [ 1991, 1993 ], [ 1995 ], [ 1997 ], [ 1999, 2001 ], [ 2003 ], [ 2005 ], [ 2007 ], [ 2009 ], [ 2011 ], [ 2015 ], [ 2017 ], [ 2019 ], [ 2021 ], [ 2023 ], [ 2025 ], [ 2027, 2029 ], [ 2031 ], [ 2033 ], [ 2035 ], [ 2037 ], [ 2039 ], [ 2041 ], [ 2043 ], [ 2045 ], [ 2049 ], [ 2051 ], [ 2053 ], [ 2055 ], [ 2057 ], [ 2059, 2061 ], [ 2063 ], [ 2065 ], [ 2067 ], [ 2069, 2071 ], [ 2073 ], [ 2075 ], [ 2077 ], [ 2079 ], [ 2081 ], [ 2083 ], [ 2085 ], [ 2087, 2089 ], [ 2091 ], [ 2093 ], [ 2095, 2097 ], [ 2099 ] ]

[ "static void FUNC_0(target_phys_addr_t VAR_0, ram_addr_t VAR_1,\nram_addr_t VAR_2, bool VAR_3)\n{", "KVMState *s = kvm_state;", "ram_addr_t flags = VAR_2 & ~TARGET_PAGE_MASK;", "KVMSlot *mem, old;", "int VAR_4;", "void *VAR_5 = NULL;", "VAR_1 = TARGET_PAGE_ALIGN(VAR_1);", "VAR_0 = TARGET_PAGE_ALIGN(VAR_0);", "VAR_2 &= ~IO_MEM_ROM;", "if ((VAR_2 & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {", "VAR_5 = qemu_safe_ram_ptr(VAR_2);", "}", "while (1) {", "mem = kvm_lookup_overlapping_slot(s, VAR_0, VAR_0 + VAR_1);", "if (!mem) {", "break;", "}", "if (flags < IO_MEM_UNASSIGNED && VAR_0 >= mem->VAR_0 &&\n(VAR_0 + VAR_1 <= mem->VAR_0 + mem->memory_size) &&\n(VAR_5 - VAR_0 == mem->VAR_5 - mem->VAR_0)) {", "kvm_slot_dirty_pages_log_change(mem, VAR_3);", "return;", "}", "old = *mem;", "mem->memory_size = 0;", "VAR_4 = kvm_set_user_memory_region(s, mem);", "if (VAR_4) {", "fprintf(stderr, \"%s: error unregistering overlapping slot: %s\\n\",\n__func__, strerror(-VAR_4));", "abort();", "}", "if (s->broken_set_mem_region &&\nold.VAR_0 == VAR_0 && old.memory_size < VAR_1 &&\nflags < IO_MEM_UNASSIGNED) {", "mem = kvm_alloc_slot(s);", "mem->memory_size = old.memory_size;", "mem->VAR_0 = old.VAR_0;", "mem->VAR_5 = old.VAR_5;", "mem->flags = kvm_mem_flags(s, VAR_3);", "VAR_4 = kvm_set_user_memory_region(s, mem);", "if (VAR_4) {", "fprintf(stderr, \"%s: error updating slot: %s\\n\", __func__,\nstrerror(-VAR_4));", "abort();", "}", "VAR_0 += old.memory_size;", "VAR_2 += old.memory_size;", "VAR_5 += old.memory_size;", "VAR_1 -= old.memory_size;", "continue;", "}", "if (old.VAR_0 < VAR_0) {", "mem = kvm_alloc_slot(s);", "mem->memory_size = VAR_0 - old.VAR_0;", "mem->VAR_0 = old.VAR_0;", "mem->VAR_5 = old.VAR_5;", "mem->flags = kvm_mem_flags(s, VAR_3);", "VAR_4 = kvm_set_user_memory_region(s, mem);", "if (VAR_4) {", "fprintf(stderr, \"%s: error registering prefix slot: %s\\n\",\n__func__, strerror(-VAR_4));", "#ifdef TARGET_PPC\nfprintf(stderr, \"%s: This is probably because your kernel's \" \\\n\"PAGE_SIZE is too big. Please try to use 4k \" \\\n\"PAGE_SIZE!\\n\", __func__);", "#endif\nabort();", "}", "}", "if (old.VAR_0 + old.memory_size > VAR_0 + VAR_1) {", "ram_addr_t size_delta;", "mem = kvm_alloc_slot(s);", "mem->VAR_0 = VAR_0 + VAR_1;", "size_delta = mem->VAR_0 - old.VAR_0;", "mem->memory_size = old.memory_size - size_delta;", "mem->VAR_5 = old.VAR_5 + size_delta;", "mem->flags = kvm_mem_flags(s, VAR_3);", "VAR_4 = kvm_set_user_memory_region(s, mem);", "if (VAR_4) {", "fprintf(stderr, \"%s: error registering suffix slot: %s\\n\",\n__func__, strerror(-VAR_4));", "abort();", "}", "}", "}", "if (!VAR_1) {", "return;", "}", "if (flags >= IO_MEM_UNASSIGNED) {", "return;", "}", "mem = kvm_alloc_slot(s);", "mem->memory_size = VAR_1;", "mem->VAR_0 = VAR_0;", "mem->VAR_5 = VAR_5;", "mem->flags = kvm_mem_flags(s, VAR_3);", "VAR_4 = kvm_set_user_memory_region(s, mem);", "if (VAR_4) {", "fprintf(stderr, \"%s: error registering slot: %s\\n\", __func__,\nstrerror(-VAR_4));", "abort();", "}", "}" ]

[ 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 23 ], [ 25 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55, 57, 59 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89 ], [ 91 ], [ 111, 113, 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177, 179 ], [ 181, 183, 185, 187 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 241 ], [ 243 ], [ 245 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 267 ], [ 269 ], [ 271, 273 ], [ 275 ], [ 277 ], [ 279 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "int64_t size;", "V9fsString name;", "ssize_t err = 0;", "size_t offset = 7;", "int32_t fid, newfid;", "V9fsFidState *file_fidp;", "V9fsFidState *xattr_fidp = NULL;", "V9fsPDU *pdu = VAR_0;", "V9fsState *s = pdu->s;", "pdu_unmarshal(pdu, offset, \"dds\", &fid, &newfid, &name);", "file_fidp = get_fid(pdu, fid);", "if (file_fidp == NULL) {", "err = -ENOENT;", "goto out_nofid;", "}", "xattr_fidp = alloc_fid(s, newfid);", "if (xattr_fidp == NULL) {", "err = -EINVAL;", "goto out;", "}", "v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);", "if (name.data[0] == 0) {", "size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);", "if (size < 0) {", "err = size;", "clunk_fid(s, xattr_fidp->fid);", "goto out;", "}", "xattr_fidp->fs.xattr.len = size;", "xattr_fidp->fid_type = P9_FID_XATTR;", "xattr_fidp->fs.xattr.copied_len = -1;", "if (size) {", "xattr_fidp->fs.xattr.value = g_malloc(size);", "err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,\nxattr_fidp->fs.xattr.value,\nxattr_fidp->fs.xattr.len);", "if (err < 0) {", "clunk_fid(s, xattr_fidp->fid);", "goto out;", "}", "}", "offset += pdu_marshal(pdu, offset, \"q\", size);", "err = offset;", "} else {", "size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,\n&name, NULL, 0);", "if (size < 0) {", "err = size;", "clunk_fid(s, xattr_fidp->fid);", "goto out;", "}", "xattr_fidp->fs.xattr.len = size;", "xattr_fidp->fid_type = P9_FID_XATTR;", "xattr_fidp->fs.xattr.copied_len = -1;", "if (size) {", "xattr_fidp->fs.xattr.value = g_malloc(size);", "err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,\n&name, xattr_fidp->fs.xattr.value,\nxattr_fidp->fs.xattr.len);", "if (err < 0) {", "clunk_fid(s, xattr_fidp->fid);", "goto out;", "}", "}", "offset += pdu_marshal(pdu, offset, \"q\", size);", "err = offset;", "}", "out:\nput_fid(pdu, file_fidp);", "if (xattr_fidp) {", "put_fid(pdu, xattr_fidp);", "}", "out_nofid:\ntrace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);", "complete_pdu(s, pdu, err);", "v9fs_string_free(&name);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 28 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 37 ], [ 38 ], [ 39 ], [ 40 ], [ 41 ], [ 42, 43, 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52 ], [ 57, 58 ], [ 59 ], [ 60 ], [ 61 ], [ 62 ], [ 63 ], [ 67 ], [ 68 ], [ 69 ], [ 70 ], [ 71 ], [ 72, 73, 74 ], [ 75 ], [ 76 ], [ 77 ], [ 78 ], [ 79 ], [ 80 ], [ 81 ], [ 82 ], [ 83, 84 ], [ 85 ], [ 86 ], [ 87 ], [ 88, 89 ], [ 90 ], [ 91 ], [ 92 ] ]

[ "void FUNC_0(AC3DecodeContext *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3, VAR_4;", "uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];", "float VAR_5[SPX_MAX_BANDS];", "VAR_1 = VAR_0->spx_dst_start_freq;", "num_copy_sections = 0;", "for (VAR_2 = 0; VAR_2 < VAR_0->num_spx_bands; VAR_2++) {", "int copysize;", "int bandsize = VAR_0->spx_band_sizes[VAR_2];", "if (VAR_1 + bandsize > VAR_0->spx_src_start_freq) {", "copy_sizes[num_copy_sections++] = VAR_1 - VAR_0->spx_dst_start_freq;", "VAR_1 = VAR_0->spx_dst_start_freq;", "wrapflag[VAR_2] = 1;", "}", "for (VAR_4 = 0; VAR_4 < bandsize; VAR_4 += copysize) {", "if (VAR_1 == VAR_0->spx_src_start_freq) {", "copy_sizes[num_copy_sections++] = VAR_1 - VAR_0->spx_dst_start_freq;", "VAR_1 = VAR_0->spx_dst_start_freq;", "}", "copysize = FFMIN(bandsize - VAR_4, VAR_0->spx_src_start_freq - VAR_1);", "VAR_1 += copysize;", "}", "}", "copy_sizes[num_copy_sections++] = VAR_1 - VAR_0->spx_dst_start_freq;", "for (VAR_3 = 1; VAR_3 <= VAR_0->fbw_channels; VAR_3++) {", "if (!VAR_0->channel_uses_spx[VAR_3])\ncontinue;", "VAR_1 = VAR_0->spx_src_start_freq;", "for (VAR_4 = 0; VAR_4 < num_copy_sections; VAR_4++) {", "memcpy(&VAR_0->transform_coeffs[VAR_3][VAR_1],\n&VAR_0->transform_coeffs[VAR_3][VAR_0->spx_dst_start_freq],\ncopy_sizes[VAR_4]*sizeof(float));", "VAR_1 += copy_sizes[VAR_4];", "}", "VAR_1 = VAR_0->spx_src_start_freq;", "for (VAR_2 = 0; VAR_2 < VAR_0->num_spx_bands; VAR_2++) {", "int bandsize = VAR_0->spx_band_sizes[VAR_2];", "float accum = 0.0f;", "for (VAR_4 = 0; VAR_4 < bandsize; VAR_4++) {", "float coeff = VAR_0->transform_coeffs[VAR_3][VAR_1++];", "accum += coeff * coeff;", "}", "VAR_5[VAR_2] = sqrtf(accum / bandsize);", "}", "if (VAR_0->spx_atten_code[VAR_3] >= 0) {", "const float *atten_tab = ff_eac3_spx_atten_tab[VAR_0->spx_atten_code[VAR_3]];", "VAR_1 = VAR_0->spx_src_start_freq - 2;", "for (VAR_2 = 0; VAR_2 < VAR_0->num_spx_bands; VAR_2++) {", "if (wrapflag[VAR_2]) {", "float *coeffs = &VAR_0->transform_coeffs[VAR_3][VAR_1];", "coeffs[0] *= atten_tab[0];", "coeffs[1] *= atten_tab[1];", "coeffs[2] *= atten_tab[2];", "coeffs[3] *= atten_tab[1];", "coeffs[4] *= atten_tab[0];", "}", "VAR_1 += VAR_0->spx_band_sizes[VAR_2];", "}", "}", "VAR_1 = VAR_0->spx_src_start_freq;", "for (VAR_2 = 0; VAR_2 < VAR_0->num_spx_bands; VAR_2++) {", "float nscale = VAR_0->spx_noise_blend[VAR_3][VAR_2] * VAR_5[VAR_2] * (1.0f / INT32_MIN);", "float sscale = VAR_0->spx_signal_blend[VAR_3][VAR_2];", "for (VAR_4 = 0; VAR_4 < VAR_0->spx_band_sizes[VAR_2]; VAR_4++) {", "float noise = nscale * (int32_t)av_lfg_get(&VAR_0->dith_state);", "VAR_0->transform_coeffs[VAR_3][VAR_1] *= sscale;", "VAR_0->transform_coeffs[VAR_3][VAR_1++] += noise;", "}", "}", "}", "}" ]

[ 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, 1, 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 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61, 63 ], [ 69 ], [ 71 ], [ 73, 75, 77 ], [ 79 ], [ 81 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ] ]

[ "static int FUNC_0(uint32_t VAR_0, int64_t VAR_1)\n{", "if (size_of_array <= number_of_elements) {", "if (size_of_array == 0)\nsize_of_array = 10;", "size_of_array *= 2;", "crc_array = av_realloc(crc_array, size_of_array * sizeof(uint32_t));", "pts_array = av_realloc(pts_array, size_of_array * sizeof(int64_t));", "if ((crc_array == NULL) || (pts_array == NULL)) {", "av_log(NULL, AV_LOG_ERROR, \"Can't allocate array to store crcs\\n\");", "return AVERROR(ENOMEM);", "}", "}", "crc_array[number_of_elements] = VAR_0;", "pts_array[number_of_elements] = VAR_1;", "number_of_elements++;", "return 0;", "}" ]

[ 0, 0, 0, 0, 1, 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 ], [ 35 ] ]

[ "static void FUNC_0(MemoryListener *VAR_0,\nMemoryRegionSection *VAR_1)\n{", "VFIOContainer *container = container_of(VAR_0, VFIOContainer,\niommu_data.VAR_0);", "hwaddr iova, end;", "int VAR_2;", "if (vfio_listener_skipped_section(VAR_1)) {", "DPRINTF(\"SKIPPING region_del %\"HWADDR_PRIx\" - %\"PRIx64\"\\n\",\nVAR_1->offset_within_address_space,\nVAR_1->offset_within_address_space + VAR_1->size - 1);", "return;", "}", "if (unlikely((VAR_1->offset_within_address_space & ~TARGET_PAGE_MASK) !=\n(VAR_1->offset_within_region & ~TARGET_PAGE_MASK))) {", "error_report(\"%s received unaligned region\", __func__);", "return;", "}", "iova = TARGET_PAGE_ALIGN(VAR_1->offset_within_address_space);", "end = (VAR_1->offset_within_address_space + int128_get64(VAR_1->size)) &\nTARGET_PAGE_MASK;", "if (iova >= end) {", "return;", "}", "DPRINTF(\"region_del %\"HWADDR_PRIx\" - %\"HWADDR_PRIx\"\\n\",\niova, end - 1);", "VAR_2 = vfio_dma_unmap(container, iova, end - iova);", "memory_region_unref(VAR_1->mr);", "if (VAR_2) {", "error_report(\"vfio_dma_unmap(%p, 0x%\"HWADDR_PRIx\", \"\n\"0x%\"HWADDR_PRIx\") = %d (%m)\",\ncontainer, iova, end - iova, VAR_2);", "}", "}" ]

[ 0, 0, 0, 0, 0, 1, 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 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45, 47 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73, 75 ], [ 77 ], [ 79 ] ]

[ "static av_cold void FUNC_0(MpegEncContext *s)\n{", "int VAR_0;", "int VAR_1;", "for(VAR_0=1; VAR_0<=MAX_FCODE; VAR_0++){", "for(VAR_1=-MAX_MV; VAR_1<=MAX_MV; VAR_1++){", "int len;", "if(VAR_1==0) len= ff_mvtab[0][1];", "else{", "int val, bit_size, code;", "bit_size = VAR_0 - 1;", "val=VAR_1;", "if (val < 0)\nval = -val;", "val--;", "code = (val >> bit_size) + 1;", "if(code<33){", "len= ff_mvtab[code][1] + 1 + bit_size;", "}else{", "len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;", "}", "}", "mv_penalty[VAR_0][VAR_1+MAX_MV]= len;", "}", "}", "for(VAR_0=MAX_FCODE; VAR_0>0; VAR_0--){", "for(VAR_1=-(16<<VAR_0); VAR_1<(16<<VAR_0); VAR_1++){", "fcode_tab[VAR_1+MAX_MV]= VAR_0;", "}", "}", "for(VAR_1=0; VAR_1<MAX_MV*2+1; VAR_1++){", "umv_fcode_tab[VAR_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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ] ]

[ "static av_always_inline int FUNC_0(vorbis_context *vc,\nvorbis_residue *vr,\nuint8_t *do_not_decode,\nunsigned ch_used,\nint partition_count)\n{", "int VAR_0, VAR_1, VAR_2;", "unsigned VAR_3 = vc->codebooks[vr->classbook].dimensions;", "unsigned VAR_4 = ff_inverse[vr->classifications];", "unsigned VAR_5, VAR_6;", "for (VAR_0 = 0, VAR_1 = 0; VAR_1 < ch_used; ++VAR_1) {", "if (!do_not_decode[VAR_1]) {", "VAR_5 = get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,\nvc->codebooks[vr->classbook].nb_bits, 3);", "av_dlog(NULL, \"Classword: %u\\n\", VAR_5);", "assert(vr->classifications > 1 && VAR_5 <= 65536);", "for (VAR_2 = 0; VAR_2 < VAR_3; ++VAR_2) {", "VAR_6 = (((uint64_t)VAR_5) * VAR_4) >> 32;", "if (partition_count + VAR_3 - 1 - VAR_2 < vr->ptns_to_read)\nvr->classifs[VAR_0 + partition_count + VAR_3 - 1 - VAR_2] =\nVAR_5 - VAR_6 * vr->classifications;", "VAR_5 = VAR_6;", "}", "}", "VAR_0 += vr->ptns_to_read;", "}", "return 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 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43, 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ] ]

[ "static int FUNC_0(void *VAR_0)\n{", "struct qemu_laio_state *VAR_1 = VAR_0;", "struct qemu_laiocb *VAR_2, *VAR_3;", "int VAR_4 = 0;", "QLIST_FOREACH_SAFE (VAR_2, &VAR_1->completed_reqs, node, VAR_3) {", "if (VAR_2->async_context_id == get_async_context_id()) {", "qemu_laio_process_completion(VAR_1, VAR_2);", "QLIST_REMOVE(VAR_2, node);", "VAR_4 = 1;", "}", "}", "return VAR_4;", "}" ]

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

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

[ "static void FUNC_0(PowerPCCPU *VAR_0, sPAPRMachineState *VAR_1,\nuint32_t VAR_2, uint32_t VAR_3,\ntarget_ulong VAR_4,\nuint32_t VAR_5, target_ulong VAR_6)\n{", "uint32_t mask, buf, len, event_len;", "sPAPREventLogEntry *event;", "struct rtas_error_log *VAR_7;", "if (VAR_3 != 4 || VAR_5 != 1) {", "rtas_st(VAR_6, 0, RTAS_OUT_PARAM_ERROR);", "return;", "}", "mask = rtas_ld(VAR_4, 0);", "buf = rtas_ld(VAR_4, 2);", "len = rtas_ld(VAR_4, 3);", "event = rtas_event_log_dequeue(mask, false);", "if (!event) {", "goto out_no_events;", "}", "VAR_7 = event->data;", "event_len = be32_to_cpu(VAR_7->extended_length) + sizeof(*VAR_7);", "if (event_len < len) {", "len = event_len;", "}", "cpu_physical_memory_write(buf, event->data, len);", "rtas_st(VAR_6, 0, RTAS_OUT_SUCCESS);", "g_free(event->data);", "g_free(event);", "return;", "out_no_events:\nrtas_st(VAR_6, 0, RTAS_OUT_NO_ERRORS_FOUND);", "}" ]

[ 0, 0, 0, 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 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73, 75 ], [ 77 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned int VAR_3)\n{", "SysBusESPState *sysbus = VAR_0;", "uint32_t saddr;", "saddr = VAR_1 >> sysbus->it_shift;", "esp_reg_write(&sysbus->esp, saddr, VAR_2);", "}" ]

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

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

[ "static uint32_t FUNC_0(uint32_t adler, const uint8_t *buf, unsigned int len)\n{", "unsigned long VAR_0 = adler & 0xffff;", "unsigned long VAR_1 = (adler >> 16) & 0xffff;", "int VAR_2;", "if (buf == NULL) return 1L;", "while (len > 0) {", "VAR_2 = len < NMAX ? len : NMAX;", "len -= VAR_2;", "while (VAR_2 >= 16) {", "DO16(buf);", "VAR_2 -= 16;", "}", "if (VAR_2 != 0) do {", "DO1(buf);", "} while (--VAR_2);", "VAR_0 %= BASE;", "VAR_1 %= BASE;", "}", "return (VAR_1 << 16) | VAR_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 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ] ]

[ "static int FUNC_0(I2CSlave *VAR_0, uint8_t VAR_1)\n{", "WM8750State *s = WM8750(VAR_0);", "uint8_t cmd;", "uint16_t value;", "if (s->i2c_len >= 2) {", "#ifdef VERBOSE\nprintf(\"%s: long message (%i bytes)\\n\", __func__, s->i2c_len);", "#endif\nreturn 1;", "}", "s->i2c_data[s->i2c_len ++] = VAR_1;", "if (s->i2c_len != 2)\nreturn 0;", "cmd = s->i2c_data[0] >> 1;", "value = ((s->i2c_data[0] << 8) | s->i2c_data[1]) & 0x1ff;", "switch (cmd) {", "case WM8750_LADCIN:\ns->diff[0] = (((value >> 6) & 3) == 3);", "if (s->diff[0])\ns->in[0] = &s->adc_voice[0 + s->ds * 1];", "else\ns->in[0] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];", "break;", "case WM8750_RADCIN:\ns->diff[1] = (((value >> 6) & 3) == 3);", "if (s->diff[1])\ns->in[1] = &s->adc_voice[0 + s->ds * 1];", "else\ns->in[1] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];", "break;", "case WM8750_ADCIN:\ns->ds = (value >> 8) & 1;", "if (s->diff[0])\ns->in[0] = &s->adc_voice[0 + s->ds * 1];", "if (s->diff[1])\ns->in[1] = &s->adc_voice[0 + s->ds * 1];", "s->monomix[0] = (value >> 6) & 3;", "break;", "case WM8750_ADCTL1:\ns->monomix[1] = (value >> 1) & 1;", "break;", "case WM8750_PWR1:\ns->enable = ((value >> 6) & 7) == 3;", "wm8750_set_format(s);", "break;", "case WM8750_LINVOL:\ns->invol[0] = value & 0x3f;", "s->inmute[0] = (value >> 7) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_RINVOL:\ns->invol[1] = value & 0x3f;", "s->inmute[1] = (value >> 7) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_ADCDAC:\ns->pol = (value >> 5) & 3;", "s->mute = (value >> 3) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_ADCTL3:\nbreak;", "case WM8750_LADC:\ns->invol[2] = value & 0xff;", "wm8750_vol_update(s);", "break;", "case WM8750_RADC:\ns->invol[3] = value & 0xff;", "wm8750_vol_update(s);", "break;", "case WM8750_ALC1:\ns->alc = (value >> 7) & 3;", "break;", "case WM8750_NGATE:\ncase WM8750_3D:\nbreak;", "case WM8750_LDAC:\ns->outvol[0] = value & 0xff;", "wm8750_vol_update(s);", "break;", "case WM8750_RDAC:\ns->outvol[1] = value & 0xff;", "wm8750_vol_update(s);", "break;", "case WM8750_BASS:\nbreak;", "case WM8750_LOUTM1:\ns->path[0] = (value >> 8) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_LOUTM2:\ns->path[1] = (value >> 8) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_ROUTM1:\ns->path[2] = (value >> 8) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_ROUTM2:\ns->path[3] = (value >> 8) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_MOUTM1:\ns->mpath[0] = (value >> 8) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_MOUTM2:\ns->mpath[1] = (value >> 8) & 1;", "wm8750_vol_update(s);", "break;", "case WM8750_LOUT1V:\ns->outvol[2] = value & 0x7f;", "wm8750_vol_update(s);", "break;", "case WM8750_LOUT2V:\ns->outvol[4] = value & 0x7f;", "wm8750_vol_update(s);", "break;", "case WM8750_ROUT1V:\ns->outvol[3] = value & 0x7f;", "wm8750_vol_update(s);", "break;", "case WM8750_ROUT2V:\ns->outvol[5] = value & 0x7f;", "wm8750_vol_update(s);", "break;", "case WM8750_MOUTV:\ns->outvol[6] = value & 0x7f;", "wm8750_vol_update(s);", "break;", "case WM8750_ADCTL2:\nbreak;", "case WM8750_PWR2:\ns->power = value & 0x7e;", "wm8750_vol_update(s);", "break;", "case WM8750_IFACE:\ns->format = value;", "s->master = (value >> 6) & 1;", "wm8750_clk_update(s, s->master);", "break;", "case WM8750_SRATE:\ns->rate = &wm_rate_table[(value >> 1) & 0x1f];", "wm8750_clk_update(s, 0);", "break;", "case WM8750_RESET:\nwm8750_reset(I2C_SLAVE(s));", "break;", "#ifdef VERBOSE\ndefault:\nprintf(\"%s: unknown register %02x\\n\", __FUNCTION__, cmd);", "#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, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25 ], [ 27, 29 ], [ 33 ], [ 35 ], [ 39 ], [ 41, 43 ], [ 45, 47 ], [ 49, 51 ], [ 53 ], [ 57, 59 ], [ 61, 63 ], [ 65, 67 ], [ 69 ], [ 73, 75 ], [ 77, 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 91, 93 ], [ 95 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145, 147 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 171, 173 ], [ 175 ], [ 179, 181, 183 ], [ 187, 189 ], [ 191 ], [ 193 ], [ 197, 199 ], [ 201 ], [ 203 ], [ 207, 209 ], [ 213, 215 ], [ 219 ], [ 221 ], [ 225, 227 ], [ 231 ], [ 233 ], [ 237, 239 ], [ 243 ], [ 245 ], [ 249, 251 ], [ 255 ], [ 257 ], [ 261, 263 ], [ 267 ], [ 269 ], [ 273, 275 ], [ 279 ], [ 281 ], [ 285, 287 ], [ 289 ], [ 291 ], [ 295, 297 ], [ 299 ], [ 301 ], [ 305, 307 ], [ 309 ], [ 311 ], [ 315, 317 ], [ 319 ], [ 321 ], [ 325, 327 ], [ 329 ], [ 331 ], [ 335, 337 ], [ 341, 343 ], [ 347 ], [ 349 ], [ 353, 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365, 367 ], [ 369 ], [ 371 ], [ 375, 377 ], [ 379 ], [ 383, 385, 387 ], [ 389, 391 ], [ 395 ], [ 397 ] ]

[ "static int FUNC_0(VncState *VAR_0, uint8_t *VAR_1, size_t VAR_2)\n{", "int VAR_3;", "uint16_t limit;", "VncDisplay *vd = VAR_0->vd;", "if (VAR_1[0] > 3) {", "vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;", "if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval))\nqemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);", "}", "switch (VAR_1[0]) {", "case VNC_MSG_CLIENT_SET_PIXEL_FORMAT:\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 VNC_MSG_CLIENT_SET_ENCODINGS:\nif (VAR_2 == 1)\nreturn 4;", "if (VAR_2 == 4) {", "limit = read_u16(VAR_1, 2);", "if (limit > 0)\nreturn 4 + (limit * 4);", "} else", "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 VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST:\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 VNC_MSG_CLIENT_KEY_EVENT:\nif (VAR_2 == 1)\nreturn 8;", "key_event(VAR_0, read_u8(VAR_1, 1), read_u32(VAR_1, 4));", "break;", "case VNC_MSG_CLIENT_POINTER_EVENT:\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 VNC_MSG_CLIENT_CUT_TEXT:\nif (VAR_2 == 1)\nreturn 8;", "if (VAR_2 == 8) {", "uint32_t dlen = read_u32(VAR_1, 4);", "if (dlen > 0)\nreturn 8 + dlen;", "}", "client_cut_text(VAR_0, read_u32(VAR_1, 4), VAR_1 + 8);", "break;", "case VNC_MSG_CLIENT_QEMU:\nif (VAR_2 == 1)\nreturn 2;", "switch (read_u8(VAR_1, 1)) {", "case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT:\nif (VAR_2 == 2)\nreturn 12;", "ext_key_event(VAR_0, read_u16(VAR_1, 2),\nread_u32(VAR_1, 4), read_u32(VAR_1, 8));", "break;", "case VNC_MSG_CLIENT_QEMU_AUDIO:\nif (VAR_2 == 2)\nreturn 4;", "switch (read_u16 (VAR_1, 2)) {", "case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE:\naudio_add(VAR_0);", "break;", "case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE:\naudio_del(VAR_0);", "break;", "case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT:\nif (VAR_2 == 4)\nreturn 10;", "switch (read_u8(VAR_1, 4)) {", "case 0: VAR_0->as.fmt = AUD_FMT_U8; break;", "case 1: VAR_0->as.fmt = AUD_FMT_S8; break;", "case 2: VAR_0->as.fmt = AUD_FMT_U16; break;", "case 3: VAR_0->as.fmt = AUD_FMT_S16; break;", "case 4: VAR_0->as.fmt = AUD_FMT_U32; break;", "case 5: VAR_0->as.fmt = AUD_FMT_S32; break;", "default:\nprintf(\"Invalid audio format %d\\n\", read_u8(VAR_1, 4));", "vnc_client_error(VAR_0);", "break;", "}", "VAR_0->as.nchannels = read_u8(VAR_1, 5);", "if (VAR_0->as.nchannels != 1 && VAR_0->as.nchannels != 2) {", "printf(\"Invalid audio channel coount %d\\n\",\nread_u8(VAR_1, 5));", "vnc_client_error(VAR_0);", "break;", "}", "VAR_0->as.freq = read_u32(VAR_1, 6);", "break;", "default:\nprintf (\"Invalid audio message %d\\n\", read_u8(VAR_1, 4));", "vnc_client_error(VAR_0);", "break;", "}", "break;", "default:\nprintf(\"Msg: %d\\n\", read_u16(VAR_1, 0));", "vnc_client_error(VAR_0);", "break;", "}", "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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 35, 37, 39, 41, 43 ], [ 45 ], [ 47, 49, 51 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83, 85, 87 ], [ 91, 93, 95 ], [ 97 ], [ 99, 101, 103 ], [ 107 ], [ 109 ], [ 111, 113, 115 ], [ 119 ], [ 121 ], [ 123, 125, 127 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147, 149, 151 ], [ 155 ], [ 157, 159, 161 ], [ 165, 167 ], [ 169 ], [ 171, 173, 175 ], [ 179 ], [ 181, 183 ], [ 185 ], [ 187, 189 ], [ 191 ], [ 193, 195, 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 ], [ 255, 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267, 269 ], [ 271 ], [ 273 ], [ 275 ], [ 279 ], [ 281 ], [ 283 ] ]

[ "void FUNC_0 (FILE *VAR_2, int (*VAR_1)(FILE *VAR_2, const char *VAR_2, ...))\n{", "int VAR_3, VAR_4;", "VAR_4 = ARRAY_SIZE(ppc_defs);", "for (VAR_3 = 0; VAR_3 < VAR_4; VAR_3++) {", "(*VAR_1)(VAR_2, \"PowerPC %-16s PVR %08x\\n\",\nppc_defs[VAR_3].name, ppc_defs[VAR_3].pvr);", "}", "}" ]

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

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

[ "static void FUNC_0(gic_state *VAR_0)\n{", "int VAR_1;", "int VAR_2;", "int VAR_3;", "int VAR_4;", "int VAR_5;", "int VAR_6;", "for (VAR_5 = 0; VAR_5 < NUM_CPU(VAR_0); VAR_5++) {", "VAR_6 = 1 << VAR_5;", "VAR_0->current_pending[VAR_5] = 1023;", "if (!VAR_0->enabled || !VAR_0->cpu_enabled[VAR_5]) {", "qemu_irq_lower(VAR_0->parent_irq[VAR_5]);", "return;", "}", "VAR_2 = 0x100;", "VAR_1 = 1023;", "for (VAR_3 = 0; VAR_3 < GIC_NIRQ; VAR_3++) {", "if (GIC_TEST_ENABLED(VAR_3) && GIC_TEST_PENDING(VAR_3, VAR_6)) {", "if (GIC_GET_PRIORITY(VAR_3, VAR_5) < VAR_2) {", "VAR_2 = GIC_GET_PRIORITY(VAR_3, VAR_5);", "VAR_1 = VAR_3;", "}", "}", "}", "VAR_4 = 0;", "if (VAR_2 <= VAR_0->priority_mask[VAR_5]) {", "VAR_0->current_pending[VAR_5] = VAR_1;", "if (VAR_2 < VAR_0->running_priority[VAR_5]) {", "DPRINTF(\"Raised pending IRQ %d\\n\", VAR_1);", "VAR_4 = 1;", "}", "}", "qemu_set_irq(VAR_0->parent_irq[VAR_5], 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 ]

[ [ 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 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ] ]

[ "static void *FUNC_0(size_t VAR_0)\n{", "static int VAR_1 = -1;", "static int VAR_2 = 0;", "void *VAR_3;", "#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)\nint VAR_4 = MAP_ANON;", "#else\nint VAR_4 = 0;", "const char *VAR_5;", "char VAR_6[1024];", "#ifdef CONFIG_SOLARIS\nstruct statvfs VAR_7;", "#else\nstruct statfs VAR_7;", "#endif\nif (!VAR_0) {", "abort ();", "}", "if (VAR_1 < 0) {", "VAR_5 = getenv(\"QEMU_TMPDIR\");", "if (!VAR_5)\n#ifdef CONFIG_SOLARIS\nVAR_5 = \"/tmp\";", "if (statvfs(VAR_5, &VAR_7) == 0) {", "#else\nVAR_5 = \"/dev/shm\";", "if (statfs(VAR_5, &VAR_7) == 0) {", "#endif\nint64_t free_space;", "int VAR_8;", "free_space = (int64_t)VAR_7.f_bavail * VAR_7.f_bsize;", "if ((ram_size + 8192 * 1024) >= free_space) {", "VAR_8 = (ram_size / (1024 * 1024));", "fprintf(stderr,\n\"You do not have enough space in '%s' for the %d MB of QEMU virtual RAM.\\n\",\nVAR_5, VAR_8);", "if (strcmp(VAR_5, \"/dev/shm\") == 0) {", "fprintf(stderr, \"To have more space available provided you have enough RAM and swap, do as root:\\n\"\n\"mount -o remount,VAR_0=%dm /dev/shm\\n\",\nVAR_8 + 16);", "} else {", "fprintf(stderr,\n\"Use the '-m' option of QEMU to diminish the amount of virtual RAM or use the\\n\"\n\"QEMU_TMPDIR environment variable to set another directory where the QEMU\\n\"\n\"temporary RAM file will be opened.\\n\");", "}", "fprintf(stderr, \"Or disable the accelerator module with -no-kqemu\\n\");", "exit(1);", "}", "}", "snprintf(VAR_6, sizeof(VAR_6), \"%s/qemuXXXXXX\",\nVAR_5);", "VAR_1 = mkstemp(VAR_6);", "if (VAR_1 < 0) {", "fprintf(stderr,\n\"warning: could not create temporary file in '%s'.\\n\"\n\"Use QEMU_TMPDIR to select a directory in a tmpfs filesystem.\\n\"\n\"Using '/tmp' as fallback.\\n\",\nVAR_5);", "snprintf(VAR_6, sizeof(VAR_6), \"%s/qemuXXXXXX\",\n\"/tmp\");", "VAR_1 = mkstemp(VAR_6);", "if (VAR_1 < 0) {", "fprintf(stderr, \"Could not create temporary memory file '%s'\\n\",\nVAR_6);", "exit(1);", "}", "}", "unlink(VAR_6);", "}", "VAR_0 = (VAR_0 + 4095) & ~4095;", "ftruncate(VAR_1, VAR_2 + VAR_0);", "#endif\nVAR_3 = mmap(NULL,\nVAR_0,\nPROT_WRITE | PROT_READ, VAR_4 | MAP_SHARED,\nVAR_1, VAR_2);", "if (VAR_3 == MAP_FAILED) {", "fprintf(stderr, \"Could not map physical memory\\n\");", "exit(1);", "}", "VAR_2 += 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 15, 17 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 27, 29 ], [ 31, 33 ], [ 35, 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51, 53, 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 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 ], [ 177 ], [ 179 ] ]

[ "static uint32_t FUNC_0(VirtIODevice *vdev)\n{", "return 0;", "}" ]

[ 0, 0, 0 ]

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

[ "void FUNC_0(void)\n{", "SDL_Event event;", "double VAR_0, VAR_1, VAR_2;", "for(;;) {", "SDL_WaitEvent(&event);", "switch(event.type) {", "case SDL_KEYDOWN:\nswitch(event.key.keysym.sym) {", "case SDLK_ESCAPE:\ncase SDLK_q:\ndo_exit();", "break;", "case SDLK_f:\ntoggle_full_screen();", "break;", "case SDLK_p:\ncase SDLK_SPACE:\ntoggle_pause();", "break;", "case SDLK_s:\nstep_to_next_frame();", "break;", "case SDLK_a:\nif (cur_stream)\nstream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO);", "break;", "case SDLK_v:\nif (cur_stream)\nstream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);", "break;", "case SDLK_w:\ntoggle_audio_display();", "break;", "case SDLK_LEFT:\nVAR_0 = -10.0;", "goto do_seek;", "case SDLK_RIGHT:\nVAR_0 = 10.0;", "goto do_seek;", "case SDLK_UP:\nVAR_0 = 60.0;", "goto do_seek;", "case SDLK_DOWN:\nVAR_0 = -60.0;", "do_seek:\nif (cur_stream) {", "VAR_1 = get_master_clock(cur_stream);", "printf(\"%f %f %d %d %d %d\\n\", (float)VAR_1, (float)VAR_0, cur_stream->av_sync_type == AV_SYNC_VIDEO_MASTER,\ncur_stream->av_sync_type == AV_SYNC_AUDIO_MASTER, cur_stream->video_st, cur_stream->audio_st);", "VAR_1 += VAR_0;", "stream_seek(cur_stream, (int64_t)(VAR_1 * AV_TIME_BASE));", "}", "break;", "default:\nbreak;", "}", "break;", "case SDL_MOUSEBUTTONDOWN:\nif (cur_stream) {", "int VAR_3, VAR_4, VAR_5, VAR_6;", "int VAR_7, VAR_8, VAR_9, VAR_10;", "VAR_7 = cur_stream->ic->duration/1000000LL;", "VAR_8 = VAR_7/3600;", "VAR_9 = (VAR_7%3600)/60;", "VAR_10 = (VAR_7%60);", "VAR_2 = (double)event.button.x/(double)cur_stream->width;", "VAR_3 = VAR_2*VAR_7;", "VAR_4 = VAR_3/3600;", "VAR_5 = (VAR_3%3600)/60;", "VAR_6 = (VAR_3%60);", "fprintf(stderr, \"Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \\n\", VAR_2*100,\nVAR_4, VAR_5, VAR_6, VAR_8, VAR_9, VAR_10);", "stream_seek(cur_stream, (int64_t)(cur_stream->ic->start_time+VAR_2*cur_stream->ic->duration));", "}", "break;", "case SDL_VIDEORESIZE:\nif (cur_stream) {", "screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,\nSDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);", "cur_stream->width = event.resize.w;", "cur_stream->height = event.resize.h;", "}", "break;", "case SDL_QUIT:\ncase FF_QUIT_EVENT:\ndo_exit();", "break;", "case FF_ALLOC_EVENT:\nalloc_picture(event.user.data1);", "break;", "case FF_REFRESH_EVENT:\nvideo_refresh_timer(event.user.data1);", "break;", "default:\nbreak;", "}", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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 ], [ 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 ] ]

[ "static inline void FUNC_0(IRQQueue *VAR_0, int VAR_1)\n{", "set_bit(VAR_0->queue, VAR_1);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0 (void *VAR_0, Uint8 *VAR_1, int VAR_2)\n{", "SDLVoiceOut *sdl = VAR_0;", "SDLAudioState *s = &glob_sdl;", "HWVoiceOut *hw = &sdl->hw;", "int VAR_3 = VAR_2 >> hw->info.shift;", "if (s->exit) {", "return;", "}", "while (VAR_3) {", "int VAR_4, VAR_5;", "sdl_wait (s, \"FUNC_0\");", "if (s->exit) {", "return;", "}", "if (sdl_lock (s, \"FUNC_0\")) {", "return;", "}", "if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->VAR_3)) {", "dolog (\"sdl->live=%d hw->VAR_3=%d\\n\",\nsdl->live, hw->VAR_3);", "return;", "}", "if (!sdl->live) {", "goto again;", "}", "VAR_4 = audio_MIN (VAR_3, sdl->live);", "VAR_5 = VAR_4;", "while (VAR_4) {", "int VAR_6 = audio_MIN (VAR_4, hw->VAR_3 - hw->rpos);", "st_sample_t *src = hw->mix_buf + hw->rpos;", "hw->clip (VAR_1, src, VAR_6);", "sdl->rpos = (sdl->rpos + VAR_6) % hw->VAR_3;", "VAR_4 -= VAR_6;", "VAR_1 += VAR_6 << hw->info.shift;", "}", "VAR_3 -= VAR_5;", "sdl->live -= VAR_5;", "sdl->VAR_5 += VAR_5;", "again:\nif (sdl_unlock (s, \"FUNC_0\")) {", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ] ]

[ "static int FUNC_0(AVIOContext *VAR_0, MOVMuxContext *VAR_1,\nAVFormatContext *VAR_2)\n{", "int64_t pos = avio_tell(VAR_0);", "avio_wb32(VAR_0, 0);", "ffio_wfourcc(VAR_0, \"ilst\");", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251nam\", \"title\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251ART\", \"artist\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"aART\", \"album_artist\", 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251wrt\", \"composer\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251alb\", \"album\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251day\", \"date\" , 1);", "mov_write_string_tag(VAR_0, \"\\251too\", LIBAVFORMAT_IDENT, 0, 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251cmt\", \"comment\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251gen\", \"genre\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251cpy\", \"copyright\", 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251grp\", \"grouping\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"\\251lyr\", \"lyrics\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"desc\", \"description\",1);", "mov_write_string_metadata(VAR_2, VAR_0, \"ldes\", \"synopsis\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"tvsh\", \"show\" , 1);", "mov_write_string_metadata(VAR_2, VAR_0, \"tven\", \"episode_id\",1);", "mov_write_string_metadata(VAR_2, VAR_0, \"tvnn\", \"network\" , 1);", "mov_write_trkn_tag(VAR_0, VAR_1, VAR_2);", "return update_size(VAR_0, pos);", "}" ]

[ 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 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "GifState *s = VAR_0->priv_data;", "av_free(s->image_buf);", "return 0;", "}" ]

[ 1, 1, 1, 1, 0 ]

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

[ "void FUNC_0(QemuThread *VAR_0)\n{", "if (!VAR_0->VAR_0) {", "qemu_thread_init();", "TlsSetValue(qemu_thread_tls_index, VAR_0);", "VAR_0->VAR_0 = GetCurrentThread();", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ] ]

[ "static void VAR_0 qemu_co_mutex_lock_slowpath(CoMutex *mutex)\n{", "Coroutine *self = qemu_coroutine_self();", "CoWaitRecord w;", "unsigned old_handoff;", "trace_qemu_co_mutex_lock_entry(mutex, self);", "w.co = self;", "push_waiter(mutex, &w);", "old_handoff = atomic_mb_read(&mutex->handoff);", "if (old_handoff &&\nhas_waiters(mutex) &&\natomic_cmpxchg(&mutex->handoff, old_handoff, 0) == old_handoff) {", "CoWaitRecord *to_wake = pop_waiter(mutex);", "Coroutine *co = to_wake->co;", "if (co == self) {", "assert(to_wake == &w);", "return;", "}", "aio_co_wake(co);", "}", "qemu_coroutine_yield();", "trace_qemu_co_mutex_lock_return(mutex, self);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 27 ], [ 29, 31, 33 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "PNMContext * const s = VAR_0->priv_data;", "AVFrame * const p = VAR_1;", "int VAR_6, VAR_21, VAR_8, VAR_9, VAR_10, VAR_11 = 0, VAR_12 = 0;", "unsigned char *VAR_13;", "int VAR_14, VAR_15, VAR_16;", "unsigned int VAR_17 = 0;", "s->bytestream_start =\ns->bytestream = (uint8_t *)VAR_4;", "s->bytestream_end = (uint8_t *)VAR_4 + VAR_5;", "if ((VAR_16 = ff_pnm_decode_header(VAR_0, s)) < 0)\nreturn VAR_16;", "if ((VAR_16 = ff_get_buffer(VAR_0, p, 0)) < 0)\nreturn VAR_16;", "p->pict_type = AV_PICTURE_TYPE_I;", "p->key_frame = 1;", "switch (VAR_0->pix_fmt) {", "default:\nreturn AVERROR(EINVAL);", "case AV_PIX_FMT_RGBA64BE:\nVAR_8 = VAR_0->width * 8;", "VAR_14=4;", "VAR_15=16;", "goto do_read;", "case AV_PIX_FMT_RGB48BE:\nVAR_8 = VAR_0->width * 6;", "VAR_14=3;", "VAR_15=16;", "goto do_read;", "case AV_PIX_FMT_RGBA:\nVAR_8 = VAR_0->width * 4;", "VAR_14=4;", "VAR_15=8;", "goto do_read;", "case AV_PIX_FMT_RGB24:\nVAR_8 = VAR_0->width * 3;", "VAR_14=3;", "VAR_15=8;", "goto do_read;", "case AV_PIX_FMT_GRAY8:\nVAR_8 = VAR_0->width;", "VAR_14=1;", "VAR_15=8;", "if (s->maxval < 255) {", "VAR_11 = 1;", "VAR_17 = (2 << av_log2(s->maxval)) - 1;", "}", "goto do_read;", "case AV_PIX_FMT_GRAY8A:\nVAR_8 = VAR_0->width * 2;", "VAR_14=2;", "VAR_15=8;", "goto do_read;", "case AV_PIX_FMT_GRAY16BE:\ncase AV_PIX_FMT_GRAY16LE:\nVAR_8 = VAR_0->width * 2;", "VAR_14=1;", "VAR_15=16;", "if (s->maxval < 65535) {", "VAR_11 = 2;", "VAR_17 = (2 << av_log2(s->maxval)) - 1;", "}", "goto do_read;", "case AV_PIX_FMT_MONOWHITE:\ncase AV_PIX_FMT_MONOBLACK:\nVAR_8 = (VAR_0->width + 7) >> 3;", "VAR_14=1;", "VAR_15=1;", "VAR_12 = 1;", "do_read:\nVAR_13 = p->VAR_1[0];", "VAR_9 = p->VAR_9[0];", "if (s->bytestream + VAR_8 * VAR_0->height > s->bytestream_end)\nreturn AVERROR_INVALIDDATA;", "if(s->type < 4 || (VAR_12 && s->type==7)){", "for (VAR_6=0; VAR_6<VAR_0->height; VAR_6++) {", "PutBitContext pb;", "init_put_bits(&pb, VAR_13, VAR_9);", "for(VAR_21=0; VAR_21<VAR_0->width * VAR_14; VAR_21++){", "unsigned int c=0;", "int VAR_21=0;", "if(s->type < 4)\nwhile(s->bytestream < s->bytestream_end && (*s->bytestream < '0' || *s->bytestream > '9' ))\ns->bytestream++;", "if(s->bytestream >= s->bytestream_end)\nreturn AVERROR_INVALIDDATA;", "if (VAR_12) {", "VAR_21 = (*s->bytestream++)&1;", "} else {", "do {", "VAR_21 = 10*VAR_21 + c;", "c = (*s->bytestream++) - '0';", "} while (c <= 9);", "}", "put_bits(&pb, VAR_15, (((1<<VAR_15)-1)*VAR_21 + (s->maxval>>1))/s->maxval);", "}", "flush_put_bits(&pb);", "VAR_13+= VAR_9;", "}", "}else{", "for (VAR_6 = 0; VAR_6 < VAR_0->height; VAR_6++) {", "if (!VAR_11)\nmemcpy(VAR_13, s->bytestream, VAR_8);", "else if (VAR_11 == 1) {", "unsigned int VAR_21, VAR_20 = (255 * 128 + s->maxval / 2) / s->maxval;", "for (VAR_21 = 0; VAR_21 < VAR_8; VAR_21++)", "VAR_13[VAR_21] = ((s->bytestream[VAR_21] & VAR_17) * VAR_20 + 64) >> 7;", "} else if (VAR_11 == 2) {", "unsigned int VAR_21, VAR_21, VAR_20 = (65535 * 32768 + s->maxval / 2) / s->maxval;", "for (VAR_21 = 0; VAR_21 < VAR_8 / 2; VAR_21++) {", "VAR_21 = av_be2ne16(((uint16_t *)s->bytestream)[VAR_21]) & VAR_17;", "((uint16_t *)VAR_13)[VAR_21] = (VAR_21 * VAR_20 + 16384) >> 15;", "}", "}", "s->bytestream += VAR_8;", "VAR_13 += VAR_9;", "}", "}", "break;", "case AV_PIX_FMT_YUV420P:\ncase AV_PIX_FMT_YUV420P9BE:\ncase AV_PIX_FMT_YUV420P10BE:\n{", "unsigned char *VAR_18, *VAR_19;", "VAR_8 = VAR_0->width;", "VAR_13 = p->VAR_1[0];", "VAR_9 = p->VAR_9[0];", "if (s->maxval >= 256)\nVAR_8 *= 2;", "if (s->bytestream + VAR_8 * VAR_0->height * 3 / 2 > s->bytestream_end)\nreturn AVERROR_INVALIDDATA;", "for (VAR_6 = 0; VAR_6 < VAR_0->height; VAR_6++) {", "memcpy(VAR_13, s->bytestream, VAR_8);", "s->bytestream += VAR_8;", "VAR_13 += VAR_9;", "}", "VAR_18 = p->VAR_1[1];", "VAR_19 = p->VAR_1[2];", "VAR_8 >>= 1;", "VAR_10 = VAR_0->height >> 1;", "for (VAR_6 = 0; VAR_6 < VAR_10; VAR_6++) {", "memcpy(VAR_18, s->bytestream, VAR_8);", "s->bytestream += VAR_8;", "memcpy(VAR_19, s->bytestream, VAR_8);", "s->bytestream += VAR_8;", "VAR_18 += p->VAR_9[1];", "VAR_19 += p->VAR_9[2];", "}", "}", "break;", "case AV_PIX_FMT_YUV420P16:\n{", "uint16_t *VAR_18, *VAR_19;", "const int VAR_20 = (65535 * 32768 + s->maxval / 2) / s->maxval;", "unsigned int VAR_21, VAR_21;", "VAR_8 = VAR_0->width * 2;", "VAR_13 = p->VAR_1[0];", "VAR_9 = p->VAR_9[0];", "if (s->bytestream + VAR_8 * VAR_0->height * 3 / 2 > s->bytestream_end)\nreturn AVERROR_INVALIDDATA;", "for (VAR_6 = 0; VAR_6 < VAR_0->height; VAR_6++) {", "for (VAR_21 = 0; VAR_21 < VAR_8 / 2; VAR_21++) {", "VAR_21 = av_be2ne16(((uint16_t *)s->bytestream)[VAR_21]);", "((uint16_t *)VAR_13)[VAR_21] = (VAR_21 * VAR_20 + 16384) >> 15;", "}", "s->bytestream += VAR_8;", "VAR_13 += VAR_9;", "}", "VAR_18 = (uint16_t*)p->VAR_1[1];", "VAR_19 = (uint16_t*)p->VAR_1[2];", "VAR_8 >>= 1;", "VAR_10 = VAR_0->height >> 1;", "for (VAR_6 = 0; VAR_6 < VAR_10; VAR_6++) {", "for (VAR_21 = 0; VAR_21 < VAR_8 / 2; VAR_21++) {", "VAR_21 = av_be2ne16(((uint16_t *)s->bytestream)[VAR_21]);", "VAR_18[VAR_21] = (VAR_21 * VAR_20 + 16384) >> 15;", "}", "s->bytestream += VAR_8;", "for (VAR_21 = 0; VAR_21 < VAR_8 / 2; VAR_21++) {", "VAR_21 = av_be2ne16(((uint16_t *)s->bytestream)[VAR_21]);", "VAR_19[VAR_21] = (VAR_21 * VAR_20 + 16384) >> 15;", "}", "s->bytestream += VAR_8;", "VAR_18 += p->VAR_9[1] / 2;", "VAR_19 += p->VAR_9[2] / 2;", "}", "}", "break;", "}", "*VAR_2 = 1;", "return s->bytestream - s->bytestream_start;", "}" ]

[ 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, 1, 0, 1, 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, 1, 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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25, 27 ], [ 29 ], [ 33, 35 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 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 ], [ 177 ], [ 179, 181, 183 ], [ 185, 187 ], [ 189 ], [ 193 ], [ 195 ], [ 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 ], [ 255 ], [ 257 ], [ 259, 261, 263, 265 ], [ 267 ], [ 271 ], [ 273 ], [ 275 ], [ 277, 279 ], [ 281, 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323, 325 ], [ 327 ], [ 329 ], [ 331 ], [ 335 ], [ 337 ], [ 339 ], [ 341, 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 411 ], [ 413 ] ]

[ "static ssize_t FUNC_0(QCryptoBlock *block,\nvoid *opaque,\nsize_t offset,\nconst uint8_t *buf,\nsize_t buflen,\nError **errp)\n{", "struct BlockCryptoCreateData *VAR_0 = opaque;", "ssize_t ret;", "ret = blk_pwrite(VAR_0->blk, offset, buf, buflen, 0);", "if (ret < 0) {", "error_setg_errno(errp, -ret, \"Could not write encryption header\");", "return ret;", "}", "return ret;", "}" ]

[ 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 ] ]

[ "static int FUNC_0(void)\n{", "#ifndef CONFIG_IOTHREAD\nint VAR_0;", "if (!vm_running)\nVAR_0 = 5000;", "else if (tcg_has_work())\nVAR_0 = 0;", "else {", "int64_t add;", "int64_t delta;", "delta = qemu_icount_delta();", "if (delta > 0) {", "VAR_0 = (delta + 999999) / 1000000;", "} else {", "add = qemu_next_deadline();", "if (add > 10000000)\nadd = 10000000;", "delta += add;", "qemu_icount += qemu_icount_round (add);", "VAR_0 = delta / 1000000;", "if (VAR_0 < 0)\nVAR_0 = 0;", "}", "}", "return VAR_0;", "#else\nreturn 1000;", "#endif\n}" ]

[ 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 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 37 ], [ 39 ], [ 45 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75, 77 ], [ 79, 81 ] ]

[ "static int FUNC_0(CharDriverState *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "SpiceCharDriver *s = VAR_0->opaque;", "vmc_register_interface(s);", "assert(s->datalen == 0);", "if (s->bufsize < VAR_2) {", "s->bufsize = VAR_2;", "s->buffer = g_realloc(s->buffer, s->bufsize);", "}", "memcpy(s->buffer, VAR_1, VAR_2);", "s->datapos = s->buffer;", "s->datalen = VAR_2;", "spice_server_char_device_wakeup(&s->sin);", "return VAR_2;", "}" ]

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

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

[ "static int FUNC_0(NetClientState *VAR_0, const char *VAR_1,\nconst char *VAR_2, int VAR_3,\nconst char *VAR_4, const char *VAR_5,\nconst char *VAR_6, const char *VAR_7,\nconst char *VAR_8, const char *VAR_9,\nconst char *VAR_10, const char *VAR_11,\nconst char *VAR_12, const char **VAR_13)\n{", "struct in_addr VAR_14 = { .s_addr = htonl(0x0a000200) };", "struct in_addr VAR_15 = { .s_addr = htonl(0xffffff00) };", "struct in_addr VAR_16 = { .s_addr = htonl(0x0a000202) };", "struct in_addr VAR_17 = { .s_addr = htonl(0x0a00020f) };", "struct in_addr VAR_18 = { .s_addr = htonl(0x0a000203) };", "#ifndef _WIN32\nstruct in_addr VAR_19 = { .s_addr = 0 };", "#endif\nNetClientState *nc;", "SlirpState *s;", "char VAR_20[20];", "uint32_t addr;", "int VAR_21;", "char *VAR_22;", "struct slirp_config_str *VAR_23;", "if (!VAR_7) {", "VAR_7 = legacy_tftp_prefix;", "}", "if (!VAR_8) {", "VAR_8 = legacy_bootp_filename;", "}", "if (VAR_4) {", "if (get_str_sep(VAR_20, sizeof(VAR_20), &VAR_4, '/') < 0) {", "if (!inet_aton(VAR_4, &VAR_14)) {", "return -1;", "}", "addr = ntohl(VAR_14.s_addr);", "if (!(addr & 0x80000000)) {", "VAR_15.s_addr = htonl(0xff000000);", "} else if ((addr & 0xfff00000) == 0xac100000) {", "VAR_15.s_addr = htonl(0xfff00000);", "} else if ((addr & 0xc0000000) == 0x80000000) {", "VAR_15.s_addr = htonl(0xffff0000);", "} else if ((addr & 0xffff0000) == 0xc0a80000) {", "VAR_15.s_addr = htonl(0xffff0000);", "} else if ((addr & 0xffff0000) == 0xc6120000) {", "VAR_15.s_addr = htonl(0xfffe0000);", "} else if ((addr & 0xe0000000) == 0xe0000000) {", "VAR_15.s_addr = htonl(0xffffff00);", "} else {", "VAR_15.s_addr = htonl(0xfffffff0);", "}", "} else {", "if (!inet_aton(VAR_20, &VAR_14)) {", "return -1;", "}", "VAR_21 = strtol(VAR_4, &VAR_22, 10);", "if (*VAR_22 != '\\0') {", "if (!inet_aton(VAR_4, &VAR_15)) {", "return -1;", "}", "} else if (VAR_21 < 4 || VAR_21 > 32) {", "return -1;", "} else {", "VAR_15.s_addr = htonl(0xffffffff << (32 - VAR_21));", "}", "}", "VAR_14.s_addr &= VAR_15.s_addr;", "VAR_16.s_addr = VAR_14.s_addr | (htonl(0x0202) & ~VAR_15.s_addr);", "VAR_17.s_addr = VAR_14.s_addr | (htonl(0x020f) & ~VAR_15.s_addr);", "VAR_18.s_addr = VAR_14.s_addr | (htonl(0x0203) & ~VAR_15.s_addr);", "}", "if (VAR_5 && !inet_aton(VAR_5, &VAR_16)) {", "return -1;", "}", "if ((VAR_16.s_addr & VAR_15.s_addr) != VAR_14.s_addr) {", "return -1;", "}", "if (VAR_9 && !inet_aton(VAR_9, &VAR_17)) {", "return -1;", "}", "if ((VAR_17.s_addr & VAR_15.s_addr) != VAR_14.s_addr ||\nVAR_17.s_addr == VAR_16.s_addr || VAR_17.s_addr == VAR_18.s_addr) {", "return -1;", "}", "if (VAR_10 && !inet_aton(VAR_10, &VAR_18)) {", "return -1;", "}", "if ((VAR_18.s_addr & VAR_15.s_addr) != VAR_14.s_addr ||\nVAR_18.s_addr == VAR_16.s_addr) {", "return -1;", "}", "#ifndef _WIN32\nif (VAR_12 && !inet_aton(VAR_12, &VAR_19)) {", "return -1;", "}", "#endif\nnc = qemu_new_net_client(&net_slirp_info, VAR_0, VAR_1, VAR_2);", "snprintf(nc->info_str, sizeof(nc->info_str),\n\"VAR_14=%s,restrict=%s\", inet_ntoa(VAR_14),\nVAR_3 ? \"on\" : \"off\");", "s = DO_UPCAST(SlirpState, nc, nc);", "s->slirp = slirp_init(VAR_3, VAR_14, VAR_15, VAR_16, VAR_6,\nVAR_7, VAR_8, VAR_17, VAR_18, VAR_13, s);", "QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);", "for (VAR_23 = slirp_configs; VAR_23; VAR_23 = VAR_23->next) {", "if (VAR_23->flags & SLIRP_CFG_HOSTFWD) {", "if (slirp_hostfwd(s, VAR_23->str,\nVAR_23->flags & SLIRP_CFG_LEGACY) < 0)\ngoto error;", "} else {", "if (slirp_guestfwd(s, VAR_23->str,\nVAR_23->flags & SLIRP_CFG_LEGACY) < 0)\ngoto error;", "}", "}", "#ifndef _WIN32\nif (!VAR_11) {", "VAR_11 = legacy_smb_export;", "}", "if (VAR_11) {", "if (slirp_smb(s, VAR_11, VAR_19) < 0)\ngoto error;", "}", "#endif\nreturn 0;", "error:\nqemu_del_net_client(nc);", "return -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 ]

[ [ 1, 3, 5, 7, 9, 11, 13, 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 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 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203, 207 ], [ 211, 213, 215 ], [ 219 ], [ 223, 225 ], [ 227 ], [ 231 ], [ 233 ], [ 235, 237, 239 ], [ 241 ], [ 243, 245, 247 ], [ 249 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263, 265 ], [ 267 ], [ 269, 273 ], [ 277, 279 ], [ 281 ], [ 283 ] ]

[ "static int FUNC_0(CPUPPCState *VAR_0,\nPPCE500Params *VAR_1,\nhwaddr VAR_2,\nhwaddr VAR_3,\nhwaddr VAR_4)\n{", "int VAR_5 = -1;", "uint64_t mem_reg_property[] = { 0, cpu_to_be64(VAR_1->ram_size) };", "int VAR_6;", "void *VAR_7;", "uint8_t hypercall[16];", "uint32_t clock_freq = 400000000;", "uint32_t tb_freq = 400000000;", "int VAR_8;", "const char *VAR_9 = NULL;", "char VAR_10[] = \"fsl,mpc8544-immr\\0simple-bus\";", "char VAR_11[128];", "char VAR_12[128];", "uint32_t mpic_ph;", "uint32_t msi_ph;", "char VAR_13[128];", "char VAR_14[128];", "char VAR_15[128];", "uint32_t *pci_map = NULL;", "int VAR_16;", "uint32_t pci_ranges[14] =\n{", "0x2000000, 0x0, 0xc0000000,\n0x0, 0xc0000000,\n0x0, 0x20000000,\n0x1000000, 0x0, 0x0,\n0x0, 0xe1000000,\n0x0, 0x10000,\n};", "QemuOpts *machine_opts;", "const char *VAR_17 = NULL;", "machine_opts = qemu_opts_find(qemu_find_opts(\"machine\"), 0);", "if (machine_opts) {", "VAR_17 = qemu_opt_get(machine_opts, \"dtb\");", "VAR_9 = qemu_opt_get(machine_opts, \"dt_compatible\");", "}", "if (VAR_17) {", "char *VAR_18;", "VAR_18 = qemu_find_file(QEMU_FILE_TYPE_BIOS, VAR_17);", "if (!VAR_18) {", "goto out;", "}", "VAR_7 = load_device_tree(VAR_18, &VAR_6);", "if (!VAR_7) {", "goto out;", "}", "goto done;", "}", "VAR_7 = create_device_tree(&VAR_6);", "if (VAR_7 == NULL) {", "goto out;", "}", "qemu_devtree_setprop_cell(VAR_7, \"/\", \"#address-cells\", 2);", "qemu_devtree_setprop_cell(VAR_7, \"/\", \"#size-cells\", 2);", "qemu_devtree_add_subnode(VAR_7, \"/memory\");", "qemu_devtree_setprop_string(VAR_7, \"/memory\", \"device_type\", \"memory\");", "qemu_devtree_setprop(VAR_7, \"/memory\", \"reg\", mem_reg_property,\nsizeof(mem_reg_property));", "qemu_devtree_add_subnode(VAR_7, \"/chosen\");", "if (VAR_4) {", "VAR_5 = qemu_devtree_setprop_cell(VAR_7, \"/chosen\", \"linux,initrd-start\",\nVAR_3);", "if (VAR_5 < 0) {", "fprintf(stderr, \"couldn't set /chosen/linux,initrd-start\\n\");", "}", "VAR_5 = qemu_devtree_setprop_cell(VAR_7, \"/chosen\", \"linux,initrd-end\",\n(VAR_3 + VAR_4));", "if (VAR_5 < 0) {", "fprintf(stderr, \"couldn't set /chosen/linux,initrd-end\\n\");", "}", "}", "VAR_5 = qemu_devtree_setprop_string(VAR_7, \"/chosen\", \"bootargs\",\nVAR_1->kernel_cmdline);", "if (VAR_5 < 0)\nfprintf(stderr, \"couldn't set /chosen/bootargs\\n\");", "if (kvm_enabled()) {", "clock_freq = kvmppc_get_clockfreq();", "tb_freq = kvmppc_get_tbfreq();", "qemu_devtree_add_subnode(VAR_7, \"/hypervisor\");", "qemu_devtree_setprop_string(VAR_7, \"/hypervisor\", \"compatible\",\n\"linux,kvm\");", "kvmppc_get_hypercall(VAR_0, hypercall, sizeof(hypercall));", "qemu_devtree_setprop(VAR_7, \"/hypervisor\", \"hcall-instructions\",\nhypercall, sizeof(hypercall));", "}", "qemu_devtree_add_subnode(VAR_7, \"/cpus\");", "qemu_devtree_setprop_cell(VAR_7, \"/cpus\", \"#address-cells\", 1);", "qemu_devtree_setprop_cell(VAR_7, \"/cpus\", \"#size-cells\", 0);", "for (VAR_8 = smp_cpus - 1; VAR_8 >= 0; VAR_8--) {", "char VAR_19[128];", "uint64_t cpu_release_addr = MPC8544_SPIN_BASE + (VAR_8 * 0x20);", "for (VAR_0 = first_cpu; VAR_0 != NULL; VAR_0 = VAR_0->next_cpu) {", "if (VAR_0->cpu_index == VAR_8) {", "break;", "}", "}", "if (!VAR_0) {", "continue;", "}", "snprintf(VAR_19, sizeof(VAR_19), \"/cpus/PowerPC,8544@%x\", VAR_0->cpu_index);", "qemu_devtree_add_subnode(VAR_7, VAR_19);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"clock-frequency\", clock_freq);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"timebase-frequency\", tb_freq);", "qemu_devtree_setprop_string(VAR_7, VAR_19, \"device_type\", \"cpu\");", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"reg\", VAR_0->cpu_index);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"d-cache-line-size\",\nVAR_0->dcache_line_size);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"VAR_8-cache-line-size\",\nVAR_0->icache_line_size);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"d-cache-size\", 0x8000);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"VAR_8-cache-size\", 0x8000);", "qemu_devtree_setprop_cell(VAR_7, VAR_19, \"bus-frequency\", 0);", "if (VAR_0->cpu_index) {", "qemu_devtree_setprop_string(VAR_7, VAR_19, \"status\", \"disabled\");", "qemu_devtree_setprop_string(VAR_7, VAR_19, \"enable-method\", \"spin-table\");", "qemu_devtree_setprop_u64(VAR_7, VAR_19, \"cpu-release-VAR_2\",\ncpu_release_addr);", "} else {", "qemu_devtree_setprop_string(VAR_7, VAR_19, \"status\", \"okay\");", "}", "}", "qemu_devtree_add_subnode(VAR_7, \"/aliases\");", "snprintf(VAR_11, sizeof(VAR_11), \"/VAR_11@%llx\", MPC8544_CCSRBAR_BASE);", "qemu_devtree_add_subnode(VAR_7, VAR_11);", "qemu_devtree_setprop_string(VAR_7, VAR_11, \"device_type\", \"VAR_11\");", "qemu_devtree_setprop(VAR_7, VAR_11, \"compatible\", VAR_10,\nsizeof(VAR_10));", "qemu_devtree_setprop_cell(VAR_7, VAR_11, \"#address-cells\", 1);", "qemu_devtree_setprop_cell(VAR_7, VAR_11, \"#size-cells\", 1);", "qemu_devtree_setprop_cells(VAR_7, VAR_11, \"ranges\", 0x0,\nMPC8544_CCSRBAR_BASE >> 32, MPC8544_CCSRBAR_BASE,\nMPC8544_CCSRBAR_SIZE);", "qemu_devtree_setprop_cell(VAR_7, VAR_11, \"bus-frequency\", 0);", "snprintf(VAR_12, sizeof(VAR_12), \"%s/pic@%llx\", VAR_11, MPC8544_MPIC_REGS_OFFSET);", "qemu_devtree_add_subnode(VAR_7, VAR_12);", "qemu_devtree_setprop_string(VAR_7, VAR_12, \"device_type\", \"open-pic\");", "qemu_devtree_setprop_string(VAR_7, VAR_12, \"compatible\", \"chrp,open-pic\");", "qemu_devtree_setprop_cells(VAR_7, VAR_12, \"reg\", MPC8544_MPIC_REGS_OFFSET,\n0x40000);", "qemu_devtree_setprop_cell(VAR_7, VAR_12, \"#address-cells\", 0);", "qemu_devtree_setprop_cell(VAR_7, VAR_12, \"#interrupt-cells\", 2);", "mpic_ph = qemu_devtree_alloc_phandle(VAR_7);", "qemu_devtree_setprop_cell(VAR_7, VAR_12, \"phandle\", mpic_ph);", "qemu_devtree_setprop_cell(VAR_7, VAR_12, \"linux,phandle\", mpic_ph);", "qemu_devtree_setprop(VAR_7, VAR_12, \"interrupt-controller\", NULL, 0);", "dt_serial_create(VAR_7, MPC8544_SERIAL1_REGS_OFFSET,\nVAR_11, VAR_12, \"serial1\", 1, false);", "dt_serial_create(VAR_7, MPC8544_SERIAL0_REGS_OFFSET,\nVAR_11, VAR_12, \"serial0\", 0, true);", "snprintf(VAR_13, sizeof(VAR_13), \"%s/global-utilities@%llx\", VAR_11,\nMPC8544_UTIL_OFFSET);", "qemu_devtree_add_subnode(VAR_7, VAR_13);", "qemu_devtree_setprop_string(VAR_7, VAR_13, \"compatible\", \"fsl,mpc8544-guts\");", "qemu_devtree_setprop_cells(VAR_7, VAR_13, \"reg\", MPC8544_UTIL_OFFSET, 0x1000);", "qemu_devtree_setprop(VAR_7, VAR_13, \"fsl,has-rstcr\", NULL, 0);", "snprintf(VAR_15, sizeof(VAR_15), \"/%s/VAR_15@%llx\", VAR_11, MPC8544_MSI_REGS_OFFSET);", "qemu_devtree_add_subnode(VAR_7, VAR_15);", "qemu_devtree_setprop_string(VAR_7, VAR_15, \"compatible\", \"fsl,VAR_12-VAR_15\");", "qemu_devtree_setprop_cells(VAR_7, VAR_15, \"reg\", MPC8544_MSI_REGS_OFFSET, 0x200);", "msi_ph = qemu_devtree_alloc_phandle(VAR_7);", "qemu_devtree_setprop_cells(VAR_7, VAR_15, \"VAR_15-available-ranges\", 0x0, 0x100);", "qemu_devtree_setprop_phandle(VAR_7, VAR_15, \"interrupt-parent\", VAR_12);", "qemu_devtree_setprop_cells(VAR_7, VAR_15, \"interrupts\",\n0xe0, 0x0,\n0xe1, 0x0,\n0xe2, 0x0,\n0xe3, 0x0,\n0xe4, 0x0,\n0xe5, 0x0,\n0xe6, 0x0,\n0xe7, 0x0);", "qemu_devtree_setprop_cell(VAR_7, VAR_15, \"phandle\", msi_ph);", "qemu_devtree_setprop_cell(VAR_7, VAR_15, \"linux,phandle\", msi_ph);", "snprintf(VAR_14, sizeof(VAR_14), \"/VAR_14@%llx\", MPC8544_PCI_REGS_BASE);", "qemu_devtree_add_subnode(VAR_7, VAR_14);", "qemu_devtree_setprop_cell(VAR_7, VAR_14, \"cell-index\", 0);", "qemu_devtree_setprop_string(VAR_7, VAR_14, \"compatible\", \"fsl,mpc8540-VAR_14\");", "qemu_devtree_setprop_string(VAR_7, VAR_14, \"device_type\", \"VAR_14\");", "qemu_devtree_setprop_cells(VAR_7, VAR_14, \"interrupt-map-mask\", 0xf800, 0x0,\n0x0, 0x7);", "pci_map = pci_map_create(VAR_7, qemu_devtree_get_phandle(VAR_7, VAR_12),\n0x11, 2, &VAR_16);", "qemu_devtree_setprop(VAR_7, VAR_14, \"interrupt-map\", pci_map, VAR_16);", "qemu_devtree_setprop_phandle(VAR_7, VAR_14, \"interrupt-parent\", VAR_12);", "qemu_devtree_setprop_cells(VAR_7, VAR_14, \"interrupts\", 24, 2);", "qemu_devtree_setprop_cells(VAR_7, VAR_14, \"bus-range\", 0, 255);", "for (VAR_8 = 0; VAR_8 < 14; VAR_8++) {", "pci_ranges[VAR_8] = cpu_to_be32(pci_ranges[VAR_8]);", "}", "qemu_devtree_setprop_cell(VAR_7, VAR_14, \"fsl,VAR_15\", msi_ph);", "qemu_devtree_setprop(VAR_7, VAR_14, \"ranges\", pci_ranges, sizeof(pci_ranges));", "qemu_devtree_setprop_cells(VAR_7, VAR_14, \"reg\", MPC8544_PCI_REGS_BASE >> 32,\nMPC8544_PCI_REGS_BASE, 0, 0x1000);", "qemu_devtree_setprop_cell(VAR_7, VAR_14, \"clock-frequency\", 66666666);", "qemu_devtree_setprop_cell(VAR_7, VAR_14, \"#interrupt-cells\", 1);", "qemu_devtree_setprop_cell(VAR_7, VAR_14, \"#size-cells\", 2);", "qemu_devtree_setprop_cell(VAR_7, VAR_14, \"#address-cells\", 3);", "qemu_devtree_setprop_string(VAR_7, \"/aliases\", \"pci0\", VAR_14);", "VAR_1->fixup_devtree(VAR_1, VAR_7);", "if (VAR_9) {", "qemu_devtree_setprop(VAR_7, \"/\", \"compatible\", VAR_9,\nstrlen(VAR_9) + 1);", "}", "done:\nqemu_devtree_dumpdtb(VAR_7, VAR_6);", "VAR_5 = rom_add_blob_fixed(BINARY_DEVICE_TREE_FILE, VAR_7, VAR_6, VAR_2);", "if (VAR_5 < 0) {", "goto out;", "}", "g_free(VAR_7);", "VAR_5 = VAR_6;", "out:\ng_free(pci_map);", "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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 55, 57, 59, 63, 65, 67, 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139, 141 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 157 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175, 177 ], [ 179, 181 ], [ 185 ], [ 189 ], [ 191 ], [ 197 ], [ 199, 201 ], [ 203 ], [ 205, 207 ], [ 209 ], [ 215 ], [ 217 ], [ 219 ], [ 227 ], [ 229 ], [ 231 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247 ], [ 249 ], [ 251 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267, 269 ], [ 271, 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287, 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 301 ], [ 305 ], [ 307 ], [ 309 ], [ 311, 313 ], [ 315 ], [ 317 ], [ 319, 321, 323 ], [ 327 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339, 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 367, 369 ], [ 371, 373 ], [ 377, 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405, 407, 409, 411, 413, 415, 417, 419, 421 ], [ 423 ], [ 425 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439, 441 ], [ 443, 445 ], [ 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 463 ], [ 465, 467 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 481 ], [ 485 ], [ 487, 489 ], [ 491 ], [ 495, 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 513, 515 ], [ 519 ], [ 521 ] ]

[ "int FUNC_0(AudioMix *VAR_0, double *VAR_1, int VAR_2)\n{", "int VAR_3, VAR_4;", "if ( VAR_0->in_channels <= 0 || VAR_0->in_channels > AVRESAMPLE_MAX_CHANNELS ||\nVAR_0->out_channels <= 0 || VAR_0->out_channels > AVRESAMPLE_MAX_CHANNELS) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid channel counts\\n\");", "return AVERROR(EINVAL);", "}", "#define GET_MATRIX_CONVERT(suffix, scale) \\\nif (!VAR_0->matrix_ ## suffix[0]) { \\", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_1 is not set\\n\"); \\", "return AVERROR(EINVAL); \\", "} \\", "for (VAR_4 = 0; VAR_4 < VAR_0->out_channels; VAR_4++) \\", "for (VAR_3 = 0; VAR_3 < VAR_0->in_channels; VAR_3++) \\", "VAR_1[VAR_4 * VAR_2 + VAR_3] = VAR_0->matrix_ ## suffix[VAR_4][VAR_3] * (scale);", "switch (VAR_0->coeff_type) {", "case AV_MIX_COEFF_TYPE_Q8:\nGET_MATRIX_CONVERT(q8, 1.0 / 256.0);", "break;", "case AV_MIX_COEFF_TYPE_Q15:\nGET_MATRIX_CONVERT(q15, 1.0 / 32768.0);", "break;", "case AV_MIX_COEFF_TYPE_FLT:\nGET_MATRIX_CONVERT(flt, 1.0);", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Invalid mix coeff type\\n\");", "return AVERROR(EINVAL);", "}", "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 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ] ]

[ "DriveInfo *FUNC_0(BlockDriverState *bs)\n{", "return bs->blk ? blk_legacy_dinfo(bs->blk) : NULL;", "}" ]

[ 0, 0, 0 ]

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

[ "int FUNC_0(CPUState *VAR_0, int VAR_1)\n{", "int VAR_2;", "assert(cpu_is_stopped(VAR_0) || qemu_cpu_self(VAR_0));", "VAR_2 = kvm_getput_regs(VAR_0, 1);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_xsave(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_xcrs(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_sregs(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_msrs(VAR_0, VAR_1);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "if (VAR_1 >= KVM_PUT_RESET_STATE) {", "VAR_2 = kvm_put_mp_state(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "}", "VAR_2 = kvm_put_vcpu_events(VAR_0, VAR_1);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_debugregs(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_guest_debug_workarounds(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 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 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ] ]