Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static void FUNC_0 (CPUPPCState *VAR_0)\n{", "spr_register(VAR_0, SPR_620_PMR0, \"PMR0\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR1, \"PMR1\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR2, \"PMR2\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR3, \"PMR3\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR4, \"PMR4\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR5, \"PMR5\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR6, \"PMR6\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR7, \"PMR7\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR8, \"PMR8\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMR9, \"PMR9\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMRA, \"PMR10\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMRB, \"PMR11\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMRC, \"PMR12\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMRD, \"PMR13\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMRE, \"PMR14\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_PMRF, \"PMR15\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_HID8, \"HID8\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_620_HID9, \"HID9\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "}" ]

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

[ [ 1, 3 ], [ 7, 9, 11, 13 ], [ 17, 19, 21, 23 ], [ 27, 29, 31, 33 ], [ 37, 39, 41, 43 ], [ 47, 49, 51, 53 ], [ 57, 59, 61, 63 ], [ 67, 69, 71, 73 ], [ 77, 79, 81, 83 ], [ 87, 89, 91, 93 ], [ 97, 99, 101, 103 ], [ 107, 109, 111, 113 ], [ 117, 119, 121, 123 ], [ 127, 129, 131, 133 ], [ 137, 139, 141, 143 ], [ 147, 149, 151, 153 ], [ 157, 159, 161, 163 ], [ 167, 169, 171, 173 ], [ 177, 179, 181, 183 ], [ 185 ] ]

[ "static struct dpll_ctl_s *FUNC_0(MemoryRegion *VAR_0,\ntarget_phys_addr_t VAR_1, omap_clk VAR_2)\n{", "struct dpll_ctl_s *VAR_3 = g_malloc0(sizeof(*VAR_3));", "memory_region_init_io(&VAR_3->iomem, &omap_dpll_ops, VAR_3, \"omap-dpll\", 0x100);", "VAR_3->dpll = VAR_2;", "omap_dpll_reset(VAR_3);", "memory_region_add_subregion(VAR_0, VAR_1, &VAR_3->iomem);", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(BlockDriverState *VAR_0)\n{", "BDRVQcow2State *s = VAR_0->opaque;", "qemu_vfree(s->l1_table);", "s->l1_table = NULL;", "if (!(s->flags & BDRV_O_INACTIVE)) {", "qcow2_inactivate(VAR_0);", "}", "cache_clean_timer_del(VAR_0);", "qcow2_cache_destroy(VAR_0, s->l2_table_cache);", "qcow2_cache_destroy(VAR_0, s->refcount_block_cache);", "qcrypto_cipher_free(s->cipher);", "s->cipher = NULL;", "g_free(s->unknown_header_fields);", "cleanup_unknown_header_ext(VAR_0);", "g_free(s->image_backing_file);", "g_free(s->image_backing_format);", "g_free(s->cluster_cache);", "qemu_vfree(s->cluster_data);", "qcow2_refcount_close(VAR_0);", "qcow2_free_snapshots(VAR_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 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "static int FUNC_0(const char *VAR_0, const char *VAR_1)\n{", "AVFormatContext *oc;", "int VAR_2, VAR_4;", "AVOutputFormat *file_oformat;", "OutputStream *ost;", "InputStream *ist;", "if (!strcmp(VAR_1, \"-\"))\nVAR_1 = \"pipe:\";", "VAR_4 = avformat_alloc_output_context2(&oc, NULL, last_asked_format, VAR_1);", "last_asked_format = NULL;", "if (!oc) {", "print_error(VAR_1, VAR_4);", "exit_program(1);", "}", "file_oformat= oc->oformat;", "if (!strcmp(file_oformat->name, \"ffm\") &&\nav_strstart(VAR_1, \"http:\", NULL)) {", "int VAR_4 = read_ffserver_streams(oc, VAR_1);", "if (VAR_4 < 0) {", "print_error(VAR_1, VAR_4);", "exit_program(1);", "}", "} else if (!nb_stream_maps) {", "#define NEW_STREAM(type, index)\\\nif (index >= 0) {\\", "ost = new_ ## type ## _stream(oc);\\", "ost->source_index = index;\\", "ost->sync_ist = &input_streams[index];\\", "input_streams[index].discard = 0;\\", "}", "if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {", "int VAR_4 = 0, VAR_7 = -1;", "for (VAR_2 = 0; VAR_2 < nb_input_streams; VAR_2++) {", "ist = &input_streams[VAR_2];", "if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&\nist->st->codec->width * ist->st->codec->height > VAR_4) {", "VAR_4 = ist->st->codec->width * ist->st->codec->height;", "VAR_7 = VAR_2;", "}", "}", "NEW_STREAM(video, VAR_7);", "}", "if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {", "int VAR_6 = 0, VAR_7 = -1;", "for (VAR_2 = 0; VAR_2 < nb_input_streams; VAR_2++) {", "ist = &input_streams[VAR_2];", "if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&\nist->st->codec->VAR_6 > VAR_6) {", "VAR_6 = ist->st->codec->VAR_6;", "VAR_7 = VAR_2;", "}", "}", "NEW_STREAM(audio, VAR_7);", "}", "if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {", "for (VAR_2 = 0; VAR_2 < nb_input_streams; VAR_2++)", "if (input_streams[VAR_2].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {", "NEW_STREAM(subtitle, VAR_2);", "break;", "}", "}", "} else {", "for (VAR_2 = 0; VAR_2 < nb_stream_maps; VAR_2++) {", "StreamMap *map = &stream_maps[VAR_2];", "if (map->disabled)\ncontinue;", "ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];", "switch (ist->st->codec->codec_type) {", "case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;", "case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;", "case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;", "case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;", "default:\nav_log(NULL, AV_LOG_ERROR, \"Cannot map stream #%d.%d - unsupported type.\\n\",\nmap->file_index, map->stream_index);", "exit_program(1);", "}", "ost->source_index = input_files[map->file_index].ist_index + map->stream_index;", "ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +\nmap->sync_stream_index];", "ist->discard = 0;", "}", "}", "av_dict_copy(&oc->metadata, metadata, 0);", "av_dict_free(&metadata);", "if (nb_output_files == MAX_FILES)\nexit_program(1);", "output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);", "output_files[nb_output_files - 1].ctx = oc;", "output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;", "av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);", "if (oc->oformat->flags & AVFMT_NEEDNUMBER) {", "if (!av_filename_number_test(oc->VAR_1)) {", "print_error(oc->VAR_1, AVERROR(EINVAL));", "exit_program(1);", "}", "}", "if (!(oc->oformat->flags & AVFMT_NOFILE)) {", "if (!file_overwrite &&\n(strchr(VAR_1, ':') == NULL ||\nVAR_1[1] == ':' ||\nav_strstart(VAR_1, \"file:\", NULL))) {", "if (avio_check(VAR_1, 0) == 0) {", "if (!using_stdin) {", "fprintf(stderr,\"File '%s' already exists. Overwrite ? [y/N] \", VAR_1);", "fflush(stderr);", "if (!read_yesno()) {", "fprintf(stderr, \"Not overwriting - exiting\\n\");", "exit_program(1);", "}", "}", "else {", "fprintf(stderr,\"File '%s' already exists. Exiting.\\n\", VAR_1);", "exit_program(1);", "}", "}", "}", "if ((VAR_4 = avio_open(&oc->pb, VAR_1, AVIO_FLAG_WRITE)) < 0) {", "print_error(VAR_1, VAR_4);", "exit_program(1);", "}", "}", "oc->preload= (int)(mux_preload*AV_TIME_BASE);", "oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);", "if (loop_output >= 0) {", "av_log(NULL, AV_LOG_WARNING, \"-loop_output is deprecated, use -loop\\n\");", "oc->loop_output = loop_output;", "}", "if (chapters_input_file >= nb_input_files) {", "if (chapters_input_file == INT_MAX) {", "chapters_input_file = -1;", "for (VAR_2 = 0; VAR_2 < nb_input_files; VAR_2++)", "if (input_files[VAR_2].ctx->nb_chapters) {", "chapters_input_file = VAR_2;", "break;", "}", "} else {", "av_log(NULL, AV_LOG_ERROR, \"Invalid input file index %d in chapter mapping.\\n\",\nchapters_input_file);", "exit_program(1);", "}", "}", "if (chapters_input_file >= 0)\ncopy_chapters(chapters_input_file, nb_output_files - 1);", "for (VAR_2 = 0; VAR_2 < nb_meta_data_maps; VAR_2++) {", "AVFormatContext *files[2];", "AVDictionary **meta[2];", "int j;", "#define METADATA_CHECK_INDEX(index, nb_elems, desc)\\\nif ((index) < 0 || (index) >= (nb_elems)) {\\", "av_log(NULL, AV_LOG_ERROR, \"Invalid %s index %d while processing metadata maps\\n\",\\\n(desc), (index));\\", "exit_program(1);\\", "}", "int in_file_index = meta_data_maps[VAR_2][1].file;", "if (in_file_index < 0)\ncontinue;", "METADATA_CHECK_INDEX(in_file_index, nb_input_files, \"input file\")\nfiles[0] = oc;", "files[1] = input_files[in_file_index].ctx;", "for (j = 0; j < 2; j++) {", "MetadataMap *map = &meta_data_maps[VAR_2][j];", "switch (map->type) {", "case 'g':\nmeta[j] = &files[j]->metadata;", "break;", "case 's':\nMETADATA_CHECK_INDEX(map->index, files[j]->nb_streams, \"stream\")\nmeta[j] = &files[j]->streams[map->index]->metadata;", "break;", "case 'c':\nMETADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, \"chapter\")\nmeta[j] = &files[j]->chapters[map->index]->metadata;", "break;", "case 'p':\nMETADATA_CHECK_INDEX(map->index, files[j]->nb_programs, \"program\")\nmeta[j] = &files[j]->programs[map->index]->metadata;", "break;", "}", "}", "av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);", "}", "if (metadata_global_autocopy && nb_input_files)\nav_dict_copy(&oc->metadata, input_files[0].ctx->metadata,\nAV_DICT_DONT_OVERWRITE);", "if (metadata_streams_autocopy)\nfor (VAR_2 = output_files[nb_output_files - 1].ost_index; VAR_2 < nb_output_streams; VAR_2++) {", "InputStream *ist = &input_streams[output_streams[VAR_2].source_index];", "av_dict_copy(&output_streams[VAR_2].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);", "}", "frame_rate = (AVRational){0, 0};", "frame_width = 0;", "frame_height = 0;", "audio_sample_rate = 0;", "audio_channels = 0;", "audio_sample_fmt = AV_SAMPLE_FMT_NONE;", "chapters_input_file = INT_MAX;", "av_freep(&meta_data_maps);", "nb_meta_data_maps = 0;", "metadata_global_autocopy = 1;", "metadata_streams_autocopy = 1;", "metadata_chapters_autocopy = 1;", "av_freep(&stream_maps);", "nb_stream_maps = 0;", "av_dict_free(&codec_names);", "av_freep(&forced_key_frames);", "uninit_opts();", "init_opts();", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17, 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 159, 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177, 179, 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191, 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 241 ], [ 245, 247, 249, 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 299 ], [ 301 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 317 ], [ 319 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337, 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347, 349 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365, 367 ], [ 369, 371 ], [ 373 ], [ 375 ], [ 379 ], [ 381, 383 ], [ 385, 389 ], [ 391 ], [ 395 ], [ 397 ], [ 401 ], [ 403, 405 ], [ 407 ], [ 409, 411, 413 ], [ 415 ], [ 417, 419, 421 ], [ 423 ], [ 425, 427, 429 ], [ 431 ], [ 433 ], [ 435 ], [ 439 ], [ 441 ], [ 447, 449, 451 ], [ 453, 455 ], [ 457 ], [ 459 ], [ 461 ], [ 465 ], [ 467 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 497 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ] ]

[ "static int FUNC_0(mmu_ctx_t *VAR_0, target_ulong VAR_1,\ntarget_ulong VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{", "target_ulong ptem, mmask;", "int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "VAR_7 = -1;", "VAR_9 = pte64_is_valid(VAR_1);", "VAR_8 = (VAR_1 >> 1) & 1;", "if (VAR_9 && VAR_3 == VAR_8) {", "ptem = VAR_1 & PTE64_PTEM_MASK;", "mmask = PTE64_CHECK_MASK;", "VAR_10 = (VAR_2 & 0x00000003) | ((VAR_2 >> 61) & 0x00000004);", "VAR_0->nx = (VAR_2 >> 2) & 1;", "VAR_0->nx |= (VAR_2 >> 3) & 1;", "if (ptem == VAR_0->ptem) {", "if (VAR_0->raddr != (hwaddr)-1ULL) {", "if ((VAR_0->raddr & mmask) != (VAR_2 & mmask)) {", "qemu_log(\"Bad RPN/WIMG/PP\\n\");", "return -3;", "}", "}", "VAR_6 = pp_check(VAR_0->key, VAR_10, VAR_0->nx);", "VAR_0->raddr = VAR_2;", "VAR_0->prot = VAR_6;", "VAR_7 = check_prot(VAR_0->prot, VAR_4, VAR_5);", "if (VAR_7 == 0) {", "LOG_MMU(\"PTE VAR_6 granted !\\n\");", "} else {", "LOG_MMU(\"PTE VAR_6 rejected\\n\");", "}", "}", "}", "return VAR_7;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ] ]

[ "static void FUNC_0(struct PCIDevice *VAR_0, Error **VAR_1)\n{", "int VAR_2, VAR_3;", "Error *err = NULL;", "XHCIState *xhci = XHCI(VAR_0);", "VAR_0->config[PCI_CLASS_PROG] = 0x30;", "VAR_0->config[PCI_INTERRUPT_PIN] = 0x01;", "VAR_0->config[PCI_CACHE_LINE_SIZE] = 0x10;", "VAR_0->config[0x60] = 0x30;", "if (strcmp(object_get_typename(OBJECT(VAR_0)), TYPE_NEC_XHCI) == 0) {", "xhci->nec_quirks = true;", "}", "if (xhci->numintrs > MAXINTRS) {", "xhci->numintrs = MAXINTRS;", "}", "while (xhci->numintrs & (xhci->numintrs - 1)) {", "xhci->numintrs++;", "}", "if (xhci->numintrs < 1) {", "xhci->numintrs = 1;", "}", "if (xhci->numslots > MAXSLOTS) {", "xhci->numslots = MAXSLOTS;", "}", "if (xhci->numslots < 1) {", "xhci->numslots = 1;", "}", "if (xhci_get_flag(xhci, XHCI_FLAG_ENABLE_STREAMS)) {", "xhci->max_pstreams_mask = 7;", "} else {", "xhci->max_pstreams_mask = 0;", "}", "if (xhci->msi != ON_OFF_AUTO_OFF) {", "VAR_3 = msi_init(VAR_0, 0x70, xhci->numintrs, true, false, &err);", "assert(!VAR_3 || VAR_3 == -ENOTSUP);", "if (VAR_3 && xhci->msi == ON_OFF_AUTO_ON) {", "error_append_hint(&err, \"You have to use msi=auto (default) or \"\n\"msi=off with this machine type.\\n\");", "error_propagate(VAR_1, err);", "return;", "}", "assert(!err || xhci->msi == ON_OFF_AUTO_AUTO);", "error_free(err);", "}", "usb_xhci_init(xhci);", "xhci->mfwrap_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, xhci_mfwrap_timer, xhci);", "memory_region_init(&xhci->mem, OBJECT(xhci), \"xhci\", LEN_REGS);", "memory_region_init_io(&xhci->mem_cap, OBJECT(xhci), &xhci_cap_ops, xhci,\n\"capabilities\", LEN_CAP);", "memory_region_init_io(&xhci->mem_oper, OBJECT(xhci), &xhci_oper_ops, xhci,\n\"operational\", 0x400);", "memory_region_init_io(&xhci->mem_runtime, OBJECT(xhci), &xhci_runtime_ops, xhci,\n\"runtime\", LEN_RUNTIME);", "memory_region_init_io(&xhci->mem_doorbell, OBJECT(xhci), &xhci_doorbell_ops, xhci,\n\"doorbell\", LEN_DOORBELL);", "memory_region_add_subregion(&xhci->mem, 0, &xhci->mem_cap);", "memory_region_add_subregion(&xhci->mem, OFF_OPER, &xhci->mem_oper);", "memory_region_add_subregion(&xhci->mem, OFF_RUNTIME, &xhci->mem_runtime);", "memory_region_add_subregion(&xhci->mem, OFF_DOORBELL, &xhci->mem_doorbell);", "for (VAR_2 = 0; VAR_2 < xhci->numports; VAR_2++) {", "XHCIPort *port = &xhci->ports[VAR_2];", "uint32_t offset = OFF_OPER + 0x400 + 0x10 * VAR_2;", "port->xhci = xhci;", "memory_region_init_io(&port->mem, OBJECT(xhci), &xhci_port_ops, port,\nport->name, 0x10);", "memory_region_add_subregion(&xhci->mem, offset, &port->mem);", "}", "pci_register_bar(VAR_0, 0,\nPCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64,\n&xhci->mem);", "if (pci_bus_is_express(VAR_0->bus) ||\nxhci_get_flag(xhci, XHCI_FLAG_FORCE_PCIE_ENDCAP)) {", "VAR_3 = pcie_endpoint_cap_init(VAR_0, 0xa0);", "assert(VAR_3 > 0);", "}", "if (xhci->msix != ON_OFF_AUTO_OFF) {", "msix_init(VAR_0, xhci->numintrs,\n&xhci->mem, 0, OFF_MSIX_TABLE,\n&xhci->mem, 0, OFF_MSIX_PBA,\n0x90, NULL);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 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 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 113 ], [ 115, 117 ], [ 119, 121 ], [ 123, 125 ], [ 127, 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 161, 163, 165 ], [ 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 185, 187, 189, 191 ], [ 193 ], [ 195 ] ]

[ "void FUNC_0(AcpiPciHpState *VAR_0, PCIBus *VAR_1,\nMemoryRegion *VAR_2)\n{", "VAR_0->root= VAR_1;", "memory_region_init_io(&VAR_0->io, NULL, &acpi_pcihp_io_ops, VAR_0,\n\"acpi-pci-hotplug\",\nPCI_HOTPLUG_SIZE);", "memory_region_add_subregion(VAR_2, PCI_HOTPLUG_ADDR, &VAR_0->io);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(Visitor *VAR_0, void *VAR_1)\n{", "QmpOutputVisitor *qov = to_qov(VAR_0);", "assert(qov->root && QSLIST_EMPTY(&qov->stack));", "assert(VAR_1 == qov->result);", "qobject_incref(qov->root);", "*qov->result = qov->root;", "qov->result = NULL;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ] ]

[ "static SocketAddress *FUNC_0(QDict *options, Error **errp)\n{", "QDict *server = NULL;", "QObject *crumpled_server = NULL;", "Visitor *iv = NULL;", "SocketAddressFlat *saddr_flat = NULL;", "SocketAddress *saddr = NULL;", "Error *local_err = NULL;", "qdict_extract_subqdict(options, &server, \"server.\");", "crumpled_server = qdict_crumple(server, errp);", "if (!crumpled_server) {", "goto done;", "}", "iv = qobject_input_visitor_new(crumpled_server);", "visit_type_SocketAddressFlat(iv, NULL, &saddr_flat, &local_err);", "if (local_err) {", "error_propagate(errp, local_err);", "goto done;", "}", "saddr = socket_address_crumple(saddr_flat);", "done:\nqapi_free_SocketAddressFlat(saddr_flat);", "visit_free(iv);", "qobject_decref(crumpled_server);", "QDECREF(server);", "return saddr;", "}" ]

[ 0, 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 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ] ]

[ "FUNC_0(Object *VAR_0, const char *VAR_1, Error **VAR_2)\n{", "MirrorState *s = FILTER_MIRROR(VAR_0);", "g_free(s->outdev);", "s->outdev = g_strdup(VAR_1);", "if (!s->outdev) {", "error_setg(VAR_2, \"filter filter mirror needs 'outdev' \"\n\"property set\");", "return;", "}", "}" ]

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

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

[ "int FUNC_0(BlockDriverState *VAR_0)\n{", "BlockDriver *drv = VAR_0->drv;", "int VAR_1;", "if (!drv)\nreturn 0;", "if (!drv->FUNC_0)\nreturn !VAR_0->tray_open;", "VAR_1 = drv->FUNC_0(VAR_0);", "return VAR_1;", "}" ]

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

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

[ "static void FUNC_0(VirtIODevice *VAR_0, uint8_t *VAR_1)\n{", "VirtIOBlock *s = to_virtio_blk(VAR_0);", "struct virtio_blk_config VAR_2;", "uint64_t capacity;", "int VAR_3, VAR_4, VAR_5;", "bdrv_get_geometry(s->bs, &capacity);", "bdrv_get_geometry_hint(s->bs, &VAR_3, &VAR_4, &VAR_5);", "stq_raw(&VAR_2.capacity, capacity);", "stl_raw(&VAR_2.seg_max, 128 - 2);", "stw_raw(&VAR_2.VAR_3, VAR_3);", "VAR_2.VAR_4 = VAR_4;", "VAR_2.sectors = VAR_5;", "memcpy(VAR_1, &VAR_2, sizeof(VAR_2));", "}" ]

[ 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 ], [ 30 ], [ 32 ] ]

[ "static int FUNC_0(const char *VAR_0, QEMUOptionParameter *VAR_1)\n{", "uint8_t buf[1024];", "struct vhd_footer* VAR_2 = (struct vhd_footer*) buf;", "struct vhd_dyndisk_header* VAR_3 =\n(struct vhd_dyndisk_header*) buf;", "int VAR_4, VAR_5;", "uint16_t cyls;", "uint8_t heads;", "uint8_t secs_per_cyl;", "size_t block_size, num_bat_entries;", "int64_t total_sectors = 0;", "while (VAR_1 && VAR_1->name) {", "if (!strcmp(VAR_1->name, \"size\")) {", "total_sectors = VAR_1->value.n / 512;", "}", "VAR_1++;", "}", "VAR_4 = open(VAR_0, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);", "if (VAR_4 < 0)\nreturn -EIO;", "if (calculate_geometry(total_sectors, &cyls, &heads, &secs_per_cyl))\nreturn -EFBIG;", "total_sectors = (int64_t) cyls * heads * secs_per_cyl;", "memset(buf, 0, 1024);", "memcpy(VAR_2->creator, \"conectix\", 8);", "memcpy(VAR_2->creator_app, \"qemu\", 4);", "memcpy(VAR_2->creator_os, \"Wi2k\", 4);", "VAR_2->features = be32_to_cpu(0x02);", "VAR_2->version = be32_to_cpu(0x00010000);", "VAR_2->data_offset = be64_to_cpu(HEADER_SIZE);", "VAR_2->timestamp = be32_to_cpu(time(NULL) - VHD_TIMESTAMP_BASE);", "VAR_2->major = be16_to_cpu(0x0005);", "VAR_2->minor =be16_to_cpu(0x0003);", "VAR_2->orig_size = be64_to_cpu(total_sectors * 512);", "VAR_2->size = be64_to_cpu(total_sectors * 512);", "VAR_2->cyls = be16_to_cpu(cyls);", "VAR_2->heads = heads;", "VAR_2->secs_per_cyl = secs_per_cyl;", "VAR_2->type = be32_to_cpu(VHD_DYNAMIC);", "VAR_2->checksum = be32_to_cpu(vpc_checksum(buf, HEADER_SIZE));", "block_size = 0x200000;", "num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512);", "if (write(VAR_4, buf, HEADER_SIZE) != HEADER_SIZE)\nreturn -EIO;", "if (lseek(VAR_4, 1536 + ((num_bat_entries * 4 + 511) & ~511), SEEK_SET) < 0)\nreturn -EIO;", "if (write(VAR_4, buf, HEADER_SIZE) != HEADER_SIZE)\nreturn -EIO;", "if (lseek(VAR_4, 3 * 512, SEEK_SET) < 0)\nreturn -EIO;", "memset(buf, 0xFF, 512);", "for (VAR_5 = 0; VAR_5 < (num_bat_entries * 4 + 511) / 512; VAR_5++)", "if (write(VAR_4, buf, 512) != 512)\nreturn -EIO;", "memset(buf, 0, 1024);", "memcpy(VAR_3->magic, \"cxsparse\", 8);", "VAR_3->data_offset = be64_to_cpu(0xFFFFFFFF);", "VAR_3->table_offset = be64_to_cpu(3 * 512);", "VAR_3->version = be32_to_cpu(0x00010000);", "VAR_3->block_size = be32_to_cpu(block_size);", "VAR_3->max_table_entries = be32_to_cpu(num_bat_entries);", "VAR_3->checksum = be32_to_cpu(vpc_checksum(buf, 1024));", "if (lseek(VAR_4, 512, SEEK_SET) < 0)\nreturn -EIO;", "if (write(VAR_4, buf, 1024) != 1024)\nreturn -EIO;", "close(VAR_4);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 45 ], [ 47, 49 ], [ 55, 57 ], [ 59 ], [ 65 ], [ 69 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 119 ], [ 125 ], [ 127 ], [ 131, 133 ], [ 137, 139 ], [ 141, 143 ], [ 149, 151 ], [ 155 ], [ 157 ], [ 159, 161 ], [ 169 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 195, 197 ], [ 199, 201 ], [ 205 ], [ 207 ], [ 209 ] ]

[ "FUNC_0 (AVFormatContext *VAR_0, AVIOContext *VAR_1,\nAVStream *VAR_2, RMStream *VAR_3, AVPacket *VAR_4)\n{", "RMDemuxContext *rm = VAR_0->priv_data;", "assert (rm->audio_pkt_cnt > 0);", "if (VAR_2->codec->codec_id == CODEC_ID_AAC)\nav_get_packet(VAR_1, VAR_4, VAR_3->sub_packet_lengths[VAR_3->sub_packet_cnt - rm->audio_pkt_cnt]);", "else {", "av_new_packet(VAR_4, VAR_2->codec->block_align);", "memcpy(VAR_4->data, VAR_3->VAR_4.data + VAR_2->codec->block_align *\n(VAR_3->sub_packet_h * VAR_3->audio_framesize / VAR_2->codec->block_align - rm->audio_pkt_cnt),\nVAR_2->codec->block_align);", "}", "rm->audio_pkt_cnt--;", "if ((VAR_4->pts = VAR_3->audiotimestamp) != AV_NOPTS_VALUE) {", "VAR_3->audiotimestamp = AV_NOPTS_VALUE;", "VAR_4->flags = AV_PKT_FLAG_KEY;", "} else", "VAR_4->flags = 0;", "VAR_4->stream_index = VAR_2->index;", "return rm->audio_pkt_cnt;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "VirtIOPCIProxy *proxy = VAR_0;", "virtio_reset(proxy->vdev);", "msix_reset(&proxy->pci_dev);", "}" ]

[ 1, 1, 0, 0, 0 ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nconst uint8_t *VAR_2, int VAR_3)\n{", "int VAR_4;", "BlockDriverAIOCB *acb;", "VAR_4 = NOT_DONE;", "qemu_aio_wait_start();", "acb = bdrv_aio_write(VAR_0, VAR_1, VAR_2, VAR_3,\nbdrv_rw_em_cb, &VAR_4);", "if (acb == NULL) {", "qemu_aio_wait_end();", "return -1;", "}", "while (VAR_4 == NOT_DONE) {", "qemu_aio_wait();", "}", "qemu_aio_wait_end();", "return VAR_4;", "}" ]

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

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "IOAPICCommonClass *k = IOAPIC_COMMON_CLASS(VAR_0);", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "k->realize = ioapic_realize;", "* If APIC is in kernel, we need to update the kernel cache after\n* migration, otherwise first 24 gsi routes will be invalid.\nk->post_load = ioapic_update_kvm_routes;", "dc->reset = ioapic_reset_common;", "dc->props = ioapic_properties;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 14, 16, 19 ], [ 21 ], [ 23 ], [ 30 ] ]

[ "static inline void FUNC_0(int VAR_0, TCGv VAR_1)\n{", "tcg_gen_st_i32(VAR_1, cpu_env, offsetof(CPUState, iwmmxt.cregs[VAR_0]));", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 8 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{", "H264Context *h = VAR_0->priv_data;", "MpegEncContext *s = &h->s;", "AVFrame *pict = VAR_1;", "int VAR_5;", "s->flags= VAR_0->flags;", "s->flags2= VAR_0->flags2;", "if(s->flags&CODEC_FLAG_TRUNCATED){", "const int VAR_6= ff_h264_find_frame_end(h, VAR_3, VAR_4);", "assert((VAR_4 > 0) || (VAR_6 == END_NOT_FOUND));", "if( ff_combine_frame(&s->parse_context, VAR_6, &VAR_3, &VAR_4) < 0 )\nreturn VAR_4;", "}", "if (VAR_4 == 0) {", "Picture *out;", "int VAR_12, VAR_15;", "out = h->delayed_pic[0];", "VAR_15 = 0;", "for(VAR_12=1; h->delayed_pic[VAR_12] && !h->delayed_pic[VAR_12]->key_frame && h->delayed_pic[VAR_12]->poc; VAR_12++)", "if(h->delayed_pic[VAR_12]->poc < out->poc){", "out = h->delayed_pic[VAR_12];", "VAR_15 = VAR_12;", "}", "for(VAR_12=VAR_15; h->delayed_pic[VAR_12]; VAR_12++)", "h->delayed_pic[VAR_12] = h->delayed_pic[VAR_12+1];", "if(out){", "*VAR_2 = sizeof(AVFrame);", "*pict= *(AVFrame*)out;", "}", "return 0;", "}", "if(h->is_avc && !h->got_avcC) {", "int VAR_12, VAR_9, VAR_10;", "unsigned char *VAR_11 = VAR_0->extradata;", "if(VAR_0->extradata_size < 7) {", "av_log(VAR_0, AV_LOG_ERROR, \"avcC too short\\n\");", "return -1;", "}", "if(*VAR_11 != 1) {", "av_log(VAR_0, AV_LOG_ERROR, \"Unknown avcC version %d\\n\", *VAR_11);", "return -1;", "}", "h->nal_length_size = 2;", "VAR_9 = *(VAR_11+5) & 0x1f;", "VAR_11 += 6;", "for (VAR_12 = 0; VAR_12 < VAR_9; VAR_12++) {", "VAR_10 = AV_RB16(VAR_11) + 2;", "if(decode_nal_units(h, VAR_11, VAR_10) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Decoding sps %d from avcC failed\\n\", VAR_12);", "return -1;", "}", "VAR_11 += VAR_10;", "}", "VAR_9 = *(VAR_11++);", "for (VAR_12 = 0; VAR_12 < VAR_9; VAR_12++) {", "VAR_10 = AV_RB16(VAR_11) + 2;", "if(decode_nal_units(h, VAR_11, VAR_10) != VAR_10) {", "av_log(VAR_0, AV_LOG_ERROR, \"Decoding pps %d from avcC failed\\n\", VAR_12);", "return -1;", "}", "VAR_11 += VAR_10;", "}", "h->nal_length_size = ((*(((char*)(VAR_0->extradata))+4))&0x03)+1;", "h->got_avcC = 1;", "}", "if(VAR_0->frame_number==0 && !h->is_avc && s->VAR_0->extradata_size){", "if(decode_nal_units(h, s->VAR_0->extradata, s->VAR_0->extradata_size) < 0)\nreturn -1;", "}", "VAR_5=decode_nal_units(h, VAR_3, VAR_4);", "if(VAR_5 < 0)\nreturn -1;", "if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){", "if (VAR_0->skip_frame >= AVDISCARD_NONREF || s->hurry_up) return 0;", "av_log(VAR_0, AV_LOG_ERROR, \"no frame!\\n\");", "return -1;", "}", "if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){", "Picture *out = s->current_picture_ptr;", "Picture *cur = s->current_picture_ptr;", "int VAR_12, VAR_12, VAR_13, VAR_14, VAR_15;", "s->mb_y= 0;", "s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;", "s->current_picture_ptr->pict_type= s->pict_type;", "if(!s->dropable) {", "execute_ref_pic_marking(h, h->mmco, h->mmco_index);", "h->prev_poc_msb= h->poc_msb;", "h->prev_poc_lsb= h->poc_lsb;", "}", "h->prev_frame_num_offset= h->frame_num_offset;", "h->prev_frame_num= h->frame_num;", "if (!FIELD_PICTURE)\nff_er_frame_end(s);", "MPV_frame_end(s);", "if (s->first_field) {", "*VAR_2 = 0;", "} else {", "cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;", "cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];", "if(h->sps.bitstream_restriction_flag\n&& s->VAR_0->has_b_frames < h->sps.num_reorder_frames){", "s->VAR_0->has_b_frames = h->sps.num_reorder_frames;", "s->low_delay = 0;", "}", "if( s->VAR_0->strict_std_compliance >= FF_COMPLIANCE_STRICT\n&& !h->sps.bitstream_restriction_flag){", "s->VAR_0->has_b_frames= MAX_DELAYED_PIC_COUNT;", "s->low_delay= 0;", "}", "VAR_12 = 0;", "while(h->delayed_pic[VAR_12]) VAR_12++;", "assert(VAR_12 <= MAX_DELAYED_PIC_COUNT);", "h->delayed_pic[VAR_12++] = cur;", "if(cur->reference == 0)\ncur->reference = DELAYED_PIC_REF;", "VAR_13 = 0;", "for(VAR_12=0; h->delayed_pic[VAR_12]; VAR_12++)", "if(h->delayed_pic[VAR_12]->key_frame || h->delayed_pic[VAR_12]->poc==0)\nVAR_13 = 1;", "out = h->delayed_pic[0];", "VAR_15 = 0;", "for(VAR_12=1; h->delayed_pic[VAR_12] && !h->delayed_pic[VAR_12]->key_frame && h->delayed_pic[VAR_12]->poc; VAR_12++)", "if(h->delayed_pic[VAR_12]->poc < out->poc){", "out = h->delayed_pic[VAR_12];", "VAR_15 = VAR_12;", "}", "VAR_14 = !VAR_13 && out->poc < h->outputed_poc;", "if(h->sps.bitstream_restriction_flag && s->VAR_0->has_b_frames >= h->sps.num_reorder_frames)\n{ }", "else if((VAR_14 && VAR_12-1 == s->VAR_0->has_b_frames && s->VAR_0->has_b_frames < MAX_DELAYED_PIC_COUNT)\n|| (s->low_delay &&\n((!VAR_13 && out->poc > h->outputed_poc + 2)\n|| cur->pict_type == FF_B_TYPE)))\n{", "s->low_delay = 0;", "s->VAR_0->has_b_frames++;", "}", "if(VAR_14 || VAR_12 > s->VAR_0->has_b_frames){", "out->reference &= ~DELAYED_PIC_REF;", "for(VAR_12=VAR_15; h->delayed_pic[VAR_12]; VAR_12++)", "h->delayed_pic[VAR_12] = h->delayed_pic[VAR_12+1];", "}", "if(!VAR_14 && VAR_12 > s->VAR_0->has_b_frames){", "*VAR_2 = sizeof(AVFrame);", "h->outputed_poc = out->poc;", "*pict= *(AVFrame*)out;", "}else{", "av_log(VAR_0, AV_LOG_DEBUG, \"no picture\\n\");", "}", "}", "}", "assert(pict->VAR_1[0] || !*VAR_2);", "ff_print_debug_info(s, pict);", "#if 0\nVAR_0->frame_number = s->picture_number - 1;", "#endif\nreturn get_consumed_bytes(s, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 33, 35 ], [ 39 ], [ 45 ], [ 47 ], [ 49 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 169 ], [ 171 ], [ 175 ], [ 177, 179 ], [ 181 ], [ 185 ], [ 187, 189 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 215 ], [ 219 ], [ 221 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 265, 267 ], [ 271 ], [ 275 ], [ 279 ], [ 283 ], [ 285 ], [ 289 ], [ 301, 303 ], [ 305 ], [ 307 ], [ 309 ], [ 313, 315 ], [ 317 ], [ 319 ], [ 321 ], [ 325 ], [ 327 ], [ 331 ], [ 335 ], [ 337, 339 ], [ 343 ], [ 345 ], [ 347, 349 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 369 ], [ 373, 375 ], [ 377, 379, 381, 383, 385 ], [ 387 ], [ 389 ], [ 391 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 427 ], [ 429 ], [ 433, 441 ], [ 443, 445 ], [ 447 ] ]

[ "static AVFrame *FUNC_0(AVFilterLink *inlink, int w, int h)\n{", "PadContext *s = inlink->dst->priv;", "AVFrame *frame = ff_get_video_buffer(inlink->dst->outputs[0],\nw + (s->w - s->in_w),\nh + (s->h - s->in_h));", "int VAR_0;", "if (!frame)\nreturn NULL;", "frame->width = w;", "frame->height = h;", "for (VAR_0 = 0; VAR_0 < 4 && frame->data[VAR_0]; VAR_0++) {", "int hsub = s->draw.hsub[VAR_0];", "int vsub = s->draw.vsub[VAR_0];", "frame->data[VAR_0] += (s->x >> hsub) * s->draw.pixelstep[VAR_0] +\n(s->y >> vsub) * frame->linesize[VAR_0];", "}", "return frame;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9, 11, 13 ], [ 15 ], [ 19, 21 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 45 ], [ 47 ] ]

[ "int64_t FUNC_0(AVIOContext *pb, const char *tag)\n{", "ffio_wfourcc(pb, tag);", "avio_wl32(pb, 0);", "return avio_tell(pb);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(H264Context *VAR_0, unsigned int VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;", "int VAR_8 = 0;", "uint32_t vlc;", "int8_t *top, *left;", "MpegEncContext *const s = (MpegEncContext *) VAR_0;", "const int VAR_9 = VAR_0->VAR_9;", "const int VAR_10 = 4*s->mb_x + 4*s->mb_y*VAR_0->b_stride;", "VAR_0->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;", "VAR_0->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;", "VAR_0->topright_samples_available = 0xFFFF;", "if (VAR_1 == 0) {", "if (s->pict_type == FF_P_TYPE || s->next_picture.VAR_1[VAR_9] == -1) {", "svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);", "if (s->pict_type == FF_B_TYPE) {", "svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);", "}", "VAR_1 = MB_TYPE_SKIP;", "} else {", "VAR_1 = FFMIN(s->next_picture.VAR_1[VAR_9], 6);", "if (svq3_mc_dir(VAR_0, VAR_1, PREDICT_MODE, 0, 0) < 0)\nreturn -1;", "if (svq3_mc_dir(VAR_0, VAR_1, PREDICT_MODE, 1, 1) < 0)\nreturn -1;", "VAR_1 = MB_TYPE_16x16;", "}", "} else if (VAR_1 < 8) {", "if (VAR_0->thirdpel_flag && VAR_0->halfpel_flag == !get_bits1 (&s->gb)) {", "VAR_7 = THIRDPEL_MODE;", "} else if (VAR_0->halfpel_flag && VAR_0->thirdpel_flag == !get_bits1 (&s->gb)) {", "VAR_7 = HALFPEL_MODE;", "} else {", "VAR_7 = FULLPEL_MODE;", "}", "for (VAR_5 = 0; VAR_5 < 2; VAR_5++) {", "if (s->mb_x > 0 && VAR_0->intra4x4_pred_mode[VAR_9 - 1][0] != -1) {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "*(uint32_t *) VAR_0->mv_cache[VAR_5][scan8[0] - 1 + VAR_2*8] = *(uint32_t *) s->current_picture.motion_val[VAR_5][VAR_10 - 1 + VAR_2*VAR_0->b_stride];", "}", "} else {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "*(uint32_t *) VAR_0->mv_cache[VAR_5][scan8[0] - 1 + VAR_2*8] = 0;", "}", "}", "if (s->mb_y > 0) {", "memcpy(VAR_0->mv_cache[VAR_5][scan8[0] - 1*8], s->current_picture.motion_val[VAR_5][VAR_10 - VAR_0->b_stride], 4*2*sizeof(int16_t));", "memset(&VAR_0->ref_cache[VAR_5][scan8[0] - 1*8], (VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);", "if (s->mb_x < (s->mb_width - 1)) {", "*(uint32_t *) VAR_0->mv_cache[VAR_5][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[VAR_5][VAR_10 - VAR_0->b_stride + 4];", "VAR_0->ref_cache[VAR_5][scan8[0] + 4 - 1*8] =\n(VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride + 1][0] == -1 ||\nVAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride ][4] == -1) ? PART_NOT_AVAILABLE : 1;", "}else", "VAR_0->ref_cache[VAR_5][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;", "if (s->mb_x > 0) {", "*(uint32_t *) VAR_0->mv_cache[VAR_5][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[VAR_5][VAR_10 - VAR_0->b_stride - 1];", "VAR_0->ref_cache[VAR_5][scan8[0] - 1 - 1*8] = (VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;", "}else", "VAR_0->ref_cache[VAR_5][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;", "}else", "memset(&VAR_0->ref_cache[VAR_5][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);", "if (s->pict_type != FF_B_TYPE)\nbreak;", "}", "if (s->pict_type == FF_P_TYPE) {", "if (svq3_mc_dir(VAR_0, (VAR_1 - 1), VAR_7, 0, 0) < 0)\nreturn -1;", "} else {", "if (VAR_1 != 2) {", "if (svq3_mc_dir(VAR_0, 0, VAR_7, 0, 0) < 0)\nreturn -1;", "} else {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "memset(s->current_picture.motion_val[0][VAR_10 + VAR_2*VAR_0->b_stride], 0, 4*2*sizeof(int16_t));", "}", "}", "if (VAR_1 != 1) {", "if (svq3_mc_dir(VAR_0, 0, VAR_7, 1, (VAR_1 == 3)) < 0)\nreturn -1;", "} else {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "memset(s->current_picture.motion_val[1][VAR_10 + VAR_2*VAR_0->b_stride], 0, 4*2*sizeof(int16_t));", "}", "}", "}", "VAR_1 = MB_TYPE_16x16;", "} else if (VAR_1 == 8 || VAR_1 == 33) {", "memset(VAR_0->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));", "if (VAR_1 == 8) {", "if (s->mb_x > 0) {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "VAR_0->intra4x4_pred_mode_cache[scan8[0] - 1 + VAR_2*8] = VAR_0->intra4x4_pred_mode[VAR_9 - 1][VAR_2];", "}", "if (VAR_0->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {", "VAR_0->left_samples_available = 0x5F5F;", "}", "}", "if (s->mb_y > 0) {", "VAR_0->intra4x4_pred_mode_cache[4+8*0] = VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride][4];", "VAR_0->intra4x4_pred_mode_cache[5+8*0] = VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride][5];", "VAR_0->intra4x4_pred_mode_cache[6+8*0] = VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride][6];", "VAR_0->intra4x4_pred_mode_cache[7+8*0] = VAR_0->intra4x4_pred_mode[VAR_9 - s->mb_stride][3];", "if (VAR_0->intra4x4_pred_mode_cache[4+8*0] == -1) {", "VAR_0->top_samples_available = 0x33FF;", "}", "}", "for (VAR_2 = 0; VAR_2 < 16; VAR_2+=2) {", "vlc = svq3_get_ue_golomb(&s->gb);", "if (vlc >= 25){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"luma prediction:%d\\n\", vlc);", "return -1;", "}", "left = &VAR_0->intra4x4_pred_mode_cache[scan8[VAR_2] - 1];", "top = &VAR_0->intra4x4_pred_mode_cache[scan8[VAR_2] - 8];", "left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];", "left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];", "if (left[1] == -1 || left[2] == -1){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"weird prediction\\n\");", "return -1;", "}", "}", "} else {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "memset(&VAR_0->intra4x4_pred_mode_cache[scan8[0] + 8*VAR_2], DC_PRED, 4);", "}", "}", "ff_h264_write_back_intra_pred_mode(VAR_0);", "if (VAR_1 == 8) {", "ff_h264_check_intra4x4_pred_mode(VAR_0);", "VAR_0->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;", "VAR_0->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;", "} else {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "memset(&VAR_0->intra4x4_pred_mode_cache[scan8[0] + 8*VAR_2], DC_128_PRED, 4);", "}", "VAR_0->top_samples_available = 0x33FF;", "VAR_0->left_samples_available = 0x5F5F;", "}", "VAR_1 = MB_TYPE_INTRA4x4;", "} else {", "VAR_6 = i_mb_type_info[VAR_1 - 8].pred_mode;", "VAR_6 = (VAR_6 >> 1) ^ 3*(VAR_6 & 1) ^ 1;", "if ((VAR_0->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(VAR_0, VAR_6)) == -1){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"check_intra_pred_mode = -1\\n\");", "return -1;", "}", "VAR_8 = i_mb_type_info[VAR_1 - 8].VAR_8;", "VAR_1 = MB_TYPE_INTRA16x16;", "}", "if (!IS_INTER(VAR_1) && s->pict_type != FF_I_TYPE) {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "memset(s->current_picture.motion_val[0][VAR_10 + VAR_2*VAR_0->b_stride], 0, 4*2*sizeof(int16_t));", "}", "if (s->pict_type == FF_B_TYPE) {", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "memset(s->current_picture.motion_val[1][VAR_10 + VAR_2*VAR_0->b_stride], 0, 4*2*sizeof(int16_t));", "}", "}", "}", "if (!IS_INTRA4x4(VAR_1)) {", "memset(VAR_0->intra4x4_pred_mode[VAR_9], DC_PRED, 8);", "}", "if (!IS_SKIP(VAR_1) || s->pict_type == FF_B_TYPE) {", "memset(VAR_0->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));", "s->dsp.clear_blocks(VAR_0->mb);", "}", "if (!IS_INTRA16x16(VAR_1) && (!IS_SKIP(VAR_1) || s->pict_type == FF_B_TYPE)) {", "if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"cbp_vlc=%d\\n\", vlc);", "return -1;", "}", "VAR_8 = IS_INTRA(VAR_1) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];", "}", "if (IS_INTRA16x16(VAR_1) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && VAR_8)) {", "s->qscale += svq3_get_se_golomb(&s->gb);", "if (s->qscale > 31){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"qscale:%d\\n\", s->qscale);", "return -1;", "}", "}", "if (IS_INTRA16x16(VAR_1)) {", "if (svq3_decode_block(&s->gb, VAR_0->mb, 0, 0)){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"error while decoding intra luma dc\\n\");", "return -1;", "}", "}", "if (VAR_8) {", "const int VAR_11 = IS_INTRA16x16(VAR_1) ? 1 : 0;", "const int VAR_12 = ((s->qscale < 24 && IS_INTRA4x4(VAR_1)) ? 2 : 1);", "for (VAR_2 = 0; VAR_2 < 4; VAR_2++) {", "if ((VAR_8 & (1 << VAR_2))) {", "for (VAR_3 = 0; VAR_3 < 4; VAR_3++) {", "VAR_4 = VAR_11 ? ((VAR_3&1) + 2*(VAR_2&1) + 2*(VAR_3&2) + 4*(VAR_2&2)) : (4*VAR_2 + VAR_3);", "VAR_0->non_zero_count_cache[ scan8[VAR_4] ] = 1;", "if (svq3_decode_block(&s->gb, &VAR_0->mb[16*VAR_4], VAR_11, VAR_12)){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"error while decoding block\\n\");", "return -1;", "}", "}", "}", "}", "if ((VAR_8 & 0x30)) {", "for (VAR_2 = 0; VAR_2 < 2; ++VAR_2) {", "if (svq3_decode_block(&s->gb, &VAR_0->mb[16*(16 + 4*VAR_2)], 0, 3)){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"error while decoding chroma dc block\\n\");", "return -1;", "}", "}", "if ((VAR_8 & 0x20)) {", "for (VAR_2 = 0; VAR_2 < 8; VAR_2++) {", "VAR_0->non_zero_count_cache[ scan8[16+VAR_2] ] = 1;", "if (svq3_decode_block(&s->gb, &VAR_0->mb[16*(16 + VAR_2)], 1, 1)){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"error while decoding chroma ac block\\n\");", "return -1;", "}", "}", "}", "}", "}", "VAR_0->VAR_8= VAR_8;", "s->current_picture.VAR_1[VAR_9] = VAR_1;", "if (IS_INTRA(VAR_1)) {", "VAR_0->chroma_pred_mode = ff_h264_check_intra_pred_mode(VAR_0, DC_PRED8x8);", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133, 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159, 161 ], [ 163 ], [ 169 ], [ 171, 173 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 213 ], [ 215 ], [ 217 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 263 ], [ 265 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 279 ], [ 281 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 313 ], [ 317 ], [ 319 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 337 ], [ 339 ], [ 341 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365 ], [ 367 ], [ 369 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451 ], [ 455 ], [ 457 ], [ 459 ], [ 463 ], [ 465 ], [ 467 ], [ 469 ], [ 471 ], [ 475 ], [ 477 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 491 ], [ 493 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 507 ], [ 509 ], [ 511 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 533 ], [ 535 ], [ 539 ], [ 541 ], [ 543 ], [ 547 ], [ 549 ] ]

[ "AVCodecContext *FUNC_0(const AVCodec *codec)\n{", "AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));", "if(avctx==NULL) return NULL;", "if(avcodec_get_context_defaults3(avctx, codec) < 0){", "av_free(avctx);", "return NULL;", "}", "return avctx;", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0)\n{", "Exynos4210fimdState *s = EXYNOS4210_FIMD(VAR_0);", "unsigned VAR_1;", "DPRINT_TRACE(\"Display controller reset\\n\");", "memset(&s->vidcon, 0, (uint8_t *)&s->window - (uint8_t *)&s->vidcon);", "for (VAR_1 = 0; VAR_1 < NUM_OF_WINDOWS; VAR_1++) {", "memset(&s->window[VAR_1], 0, sizeof(Exynos4210fimdWindow));", "s->window[VAR_1].blendeq = 0xC2;", "exynos4210_fimd_update_win_bppmode(s, VAR_1);", "exynos4210_fimd_trace_bppmode(s, VAR_1, 0xFFFFFFFF);", "fimd_update_get_alpha(s, VAR_1);", "}", "if (s->ifb != NULL) {", "g_free(s->ifb);", "}", "s->ifb = NULL;", "exynos4210_fimd_invalidate(s);", "exynos4210_fimd_enable(s, false);", "s->winchmap = 0x7D517D51;", "s->colorgaincon = 0x10040100;", "s->huecoef_cr[0] = s->huecoef_cr[3] = 0x01000100;", "s->huecoef_cb[0] = s->huecoef_cb[3] = 0x01000100;", "s->hueoffset = 0x01800080;", "}" ]

[ 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 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ] ]

[ "void FUNC_0(CPUPPCState *VAR_0, target_ulong VAR_1)\n{", "PowerPCCPU *cpu = ppc_env_get_cpu(VAR_0);", "ppc_slb_t *slb;", "slb = slb_lookup(cpu, VAR_1);", "if (!slb) {", "return;", "}", "if (slb->esid & SLB_ESID_V) {", "slb->esid &= ~SLB_ESID_V;", "VAR_0->tlb_need_flush |= TLB_NEED_LOCAL_FLUSH;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 35 ], [ 37 ], [ 39 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0,\nSCSIRequest *VAR_1, int VAR_2,\nBlockDriverCompletionFunc *VAR_3)\n{", "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->cmd;", "VAR_1->io_header.cmd_len = VAR_1->cmdlen;", "VAR_1->io_header.mx_sb_len = sizeof(VAR_1->dev->sensebuf);", "VAR_1->io_header.sbp = VAR_1->dev->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;", "if (bdrv_pwrite(VAR_0, -1, &VAR_1->io_header, sizeof(VAR_1->io_header)) == -1) {", "BADF(\"FUNC_0: write failed ! (%d)\\n\", errno);", "return -1;", "}", "if (VAR_3 == NULL) {", "int VAR_4;", "VAR_1->aiocb = NULL;", "while ((VAR_4 = bdrv_pread(VAR_0, -1, &VAR_1->io_header,\nsizeof(VAR_1->io_header))) == -1 &&\nerrno == EINTR);", "if (VAR_4 == -1) {", "BADF(\"FUNC_0: read failed !\\n\");", "return -1;", "}", "return 0;", "}", "VAR_1->aiocb = bdrv_aio_read(VAR_0, 0, (uint8_t*)&VAR_1->io_header,\n-(int64_t)sizeof(VAR_1->io_header), VAR_3, VAR_1);", "if (VAR_1->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, 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 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ] ]

[ "static void FUNC_0(QemuOpts *VAR_0, const InetSocketAddress *VAR_1)\n{", "bool ipv4 = VAR_1->ipv4 || !VAR_1->has_ipv4;", "bool ipv6 = VAR_1->ipv6 || !VAR_1->has_ipv6;", "if (!ipv4 || !ipv6) {", "qemu_opt_set_bool(VAR_0, \"ipv4\", ipv4, &error_abort);", "qemu_opt_set_bool(VAR_0, \"ipv6\", ipv6, &error_abort);", "}", "if (VAR_1->has_to) {", "qemu_opt_set_number(VAR_0, \"to\", VAR_1->to, &error_abort);", "}", "qemu_opt_set(VAR_0, \"host\", VAR_1->host, &error_abort);", "qemu_opt_set(VAR_0, \"port\", VAR_1->port, &error_abort);", "}" ]

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

[ "static int FUNC_0(FsContext *VAR_0, const char *VAR_1, struct stat *VAR_2)\n{", "return lstat(rpath(VAR_0, VAR_1), VAR_2);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(void)\n{", "printf(\"qemu-img version \" QEMU_VERSION \", Copyright (c) 2004-2008 Fabrice Bellard\\n\"\n\"usage: qemu-img command [command options]\\n\"\n\"QEMU disk image utility\\n\"\n\"\\n\"\n\"Command syntax:\\n\"\n\" check [-f fmt] filename\\n\"\n\" create [-F fmt] [-b base_image] [-f fmt] [-o options] filename [size]\\n\"\n\" commit [-f fmt] filename\\n\"\n\" convert [-c] [-f fmt] [-O output_fmt] [-o options] [-B output_base_image] filename [filename2 [...]] output_filename\\n\"\n\" info [-f fmt] filename\\n\"\n\" snapshot [-l | -a snapshot | -c snapshot | -d snapshot] filename\\n\"\n\"\\n\"\n\"Command parameters:\\n\"\n\" 'filename' is a disk image filename\\n\"\n\" 'base_image' is the read-only disk image which is used as base for a copy on\\n\"\n\" write image; the copy on write image only stores the modified data\\n\"", "\" 'output_base_image' forces the output image to be created as a copy on write\\n\"\n\" image of the specified base image; 'output_base_image' should have the same\\n\"", "\" content as the input's base image, however the path, image format, etc may\\n\"\n\" differ\\n\"\n\" 'fmt' is the disk image format. It is guessed automatically in most cases\\n\"\n\" 'size' is the disk image size in kilobytes. Optional suffixes\\n\"\n\" 'M' (megabyte, 1024 * 1024) and 'G' (gigabyte, 1024 * 1024 * 1024) are\\n\"\n\" supported any 'k' or 'K' is ignored\\n\"\n\" 'output_filename' is the destination disk image filename\\n\"\n\" 'output_fmt' is the destination format\\n\"\n\" 'options' is a comma separated list of format specific options in a\\n\"\n\" name=value format. Use -o ? for an overview of the options supported by the\\n\"\n\" used format\\n\"\n\" '-c' indicates that target image must be compressed (qcow format only)\\n\"\n\" '-h' with or without a command shows this FUNC_0 and lists the supported formats\\n\"\n\"\\n\"\n\"Parameters to snapshot subcommand:\\n\"\n\" 'snapshot' is the name of the snapshot to create, apply or delete\\n\"\n\" '-a' applies a snapshot (revert disk to saved state)\\n\"\n\" '-c' creates a snapshot\\n\"\n\" '-d' deletes a snapshot\\n\"\n\" '-l' lists all snapshots in the given image\\n\"\n);", "printf(\"\\nSupported formats:\");", "bdrv_iterate_format(format_print, NULL);", "printf(\"\\n\");", "exit(1);", "}" ]

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

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

[ "ReadLineState *FUNC_0(Monitor *mon,\nReadLineCompletionFunc *completion_finder)\n{", "ReadLineState *rs = g_malloc0(sizeof(*rs));", "rs->hist_entry = -1;", "rs->mon = mon;", "rs->completion_finder = completion_finder;", "return rs;", "}" ]

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

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

[ "BlockDriverAIOCB *FUNC_0(ThreadPoolFunc *func, void *arg,\nBlockDriverCompletionFunc *cb, void *opaque)\n{", "ThreadPool *pool = &global_pool;", "ThreadPoolElement *req;", "req = qemu_aio_get(&thread_pool_aiocb_info, NULL, cb, opaque);", "req->func = func;", "req->arg = arg;", "req->state = THREAD_QUEUED;", "req->pool = pool;", "QLIST_INSERT_HEAD(&pool->head, req, all);", "trace_thread_pool_submit(pool, req, arg);", "qemu_mutex_lock(&pool->lock);", "if (pool->idle_threads == 0 && pool->cur_threads < pool->max_threads) {", "spawn_thread(pool);", "}", "QTAILQ_INSERT_TAIL(&pool->request_list, req, reqs);", "qemu_mutex_unlock(&pool->lock);", "qemu_sem_post(&pool->sem);", "return &req->common;", "}" ]

[ 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 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ] ]

[ "int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "AVStream *st;", "for (;;) {", "AVPacketList *pktl = VAR_0->internal->raw_packet_buffer;", "if (pktl) {", "*VAR_1 = pktl->VAR_1;", "st = VAR_0->streams[VAR_1->stream_index];", "if (VAR_0->internal->raw_packet_buffer_remaining_size <= 0)\nif ((VAR_4 = probe_codec(VAR_0, st, NULL)) < 0)\nreturn VAR_4;", "if (st->request_probe <= 0) {", "VAR_0->internal->raw_packet_buffer = pktl->next;", "VAR_0->internal->raw_packet_buffer_remaining_size += VAR_1->size;", "av_free(pktl);", "return 0;", "}", "}", "VAR_1->data = NULL;", "VAR_1->size = 0;", "av_init_packet(VAR_1);", "VAR_2 = VAR_0->iformat->read_packet(VAR_0, VAR_1);", "if (VAR_2 < 0) {", "if (VAR_2 == FFERROR_REDO)\ncontinue;", "if (!pktl || VAR_2 == AVERROR(EAGAIN))\nreturn VAR_2;", "for (VAR_3 = 0; VAR_3 < VAR_0->nb_streams; VAR_3++) {", "st = VAR_0->streams[VAR_3];", "if (st->probe_packets)\nif ((VAR_4 = probe_codec(VAR_0, st, NULL)) < 0)\nreturn VAR_4;", "av_assert0(st->request_probe <= 0);", "}", "continue;", "}", "if (!VAR_1->buf) {", "AVPacket tmp = { 0 };", "VAR_2 = av_packet_ref(&tmp, VAR_1);", "if (VAR_2 < 0)\nreturn VAR_2;", "*VAR_1 = tmp;", "}", "if ((VAR_0->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&\n(VAR_1->flags & AV_PKT_FLAG_CORRUPT)) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"Dropped corrupted packet (stream = %d)\\n\",\nVAR_1->stream_index);", "av_packet_unref(VAR_1);", "continue;", "}", "if (VAR_1->stream_index >= (unsigned)VAR_0->nb_streams) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid stream index %d\\n\", VAR_1->stream_index);", "continue;", "}", "st = VAR_0->streams[VAR_1->stream_index];", "if (update_wrap_reference(VAR_0, st, VAR_1->stream_index, VAR_1) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {", "if (!is_relative(st->first_dts))\nst->first_dts = wrap_timestamp(st, st->first_dts);", "if (!is_relative(st->start_time))\nst->start_time = wrap_timestamp(st, st->start_time);", "if (!is_relative(st->cur_dts))\nst->cur_dts = wrap_timestamp(st, st->cur_dts);", "}", "VAR_1->dts = wrap_timestamp(st, VAR_1->dts);", "VAR_1->pts = wrap_timestamp(st, VAR_1->pts);", "force_codec_ids(VAR_0, st);", "if (VAR_0->use_wallclock_as_timestamps)\nVAR_1->dts = VAR_1->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);", "if (!pktl && st->request_probe <= 0)\nreturn VAR_2;", "VAR_4 = add_to_pktbuf(&VAR_0->internal->raw_packet_buffer, VAR_1,\n&VAR_0->internal->raw_packet_buffer_end, 0);", "if (VAR_4)\nreturn VAR_4;", "VAR_0->internal->raw_packet_buffer_remaining_size -= VAR_1->size;", "if ((VAR_4 = probe_codec(VAR_0, st, VAR_1)) < 0)\nreturn 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23, 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 61, 63 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 73, 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 105, 107 ], [ 109, 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 137 ], [ 141, 143 ], [ 145, 147 ], [ 149, 151 ], [ 153 ], [ 157 ], [ 159 ], [ 163 ], [ 169, 171 ], [ 175, 177 ], [ 181, 183 ], [ 185, 187 ], [ 189 ], [ 193, 195 ], [ 197 ], [ 199 ] ]

[ "int FUNC_0(CPUState *VAR_0, struct kvm_run *VAR_1)\n{", "return 0;", "}" ]

[ 0, 0, 0 ]

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

[ "int FUNC_0(BdrvChild *VAR_0, uint64_t VAR_1, uint64_t VAR_2,\nError **VAR_3)\n{", "int VAR_4;", "VAR_4 = bdrv_child_check_perm(VAR_0, VAR_1, VAR_2, VAR_3);", "if (VAR_4 < 0) {", "bdrv_child_abort_perm_update(VAR_0);", "return VAR_4;", "}", "bdrv_child_set_perm(VAR_0, VAR_1, VAR_2);", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 29 ] ]

[ "static gboolean FUNC_0(QIOChannel *ioc, GIOCondition cond, gpointer opaque)\n{", "QIOChannelSocket *cioc;", "cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),\nNULL);", "if (!cioc) {", "return TRUE;", "}", "if (state >= TERMINATE) {", "object_unref(OBJECT(cioc));", "return TRUE;", "}", "nb_fds++;", "nbd_update_server_watch();", "nbd_client_new(newproto ? NULL : exp, cioc,\nNULL, NULL, nbd_client_closed);", "object_unref(OBJECT(cioc));", "return TRUE;", "}" ]

[ 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 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 43 ], [ 45 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "int VAR_4, VAR_5;", "uint32_t vid = 0;", "BDRVSheepdogState *s = VAR_0->opaque;", "char VAR_6[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];", "uint32_t snapid;", "char *VAR_7 = NULL;", "QemuOpts *opts;", "Error *local_err = NULL;", "const char *VAR_8;", "s->VAR_0 = VAR_0;", "s->aio_context = bdrv_get_aio_context(VAR_0);", "opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);", "qemu_opts_absorb_qdict(opts, VAR_1, &local_err);", "if (local_err) {", "error_propagate(VAR_3, local_err);", "VAR_4 = -EINVAL;", "goto out;", "}", "VAR_8 = qemu_opt_get(opts, \"VAR_8\");", "QLIST_INIT(&s->inflight_aio_head);", "QLIST_INIT(&s->failed_aio_head);", "QLIST_INIT(&s->inflight_aiocb_head);", "s->VAR_5 = -1;", "memset(VAR_6, 0, sizeof(VAR_6));", "memset(tag, 0, sizeof(tag));", "if (strstr(VAR_8, \":\nVAR_4 = sd_parse_uri(s, VAR_8, VAR_6, &snapid, tag);", "} else {", "VAR_4 = parse_vdiname(s, VAR_8, VAR_6, &snapid, tag);", "}", "if (VAR_4 < 0) {", "error_setg(VAR_3, \"Can't parse VAR_8\");", "goto out;", "}", "s->VAR_5 = get_sheep_fd(s, VAR_3);", "if (s->VAR_5 < 0) {", "VAR_4 = s->VAR_5;", "goto out;", "}", "VAR_4 = find_vdi_name(s, VAR_6, snapid, tag, &vid, true, VAR_3);", "if (VAR_4) {", "goto out;", "}", "s->cache_flags = SD_FLAG_CMD_CACHE;", "if (VAR_2 & BDRV_O_NOCACHE) {", "s->cache_flags = SD_FLAG_CMD_DIRECT;", "}", "s->discard_supported = true;", "if (snapid || tag[0] != '\\0') {", "DPRINTF(\"%\" PRIx32 \" snapshot inode was open.\\n\", vid);", "s->is_snapshot = true;", "}", "VAR_5 = connect_to_sdog(s, VAR_3);", "if (VAR_5 < 0) {", "VAR_4 = VAR_5;", "goto out;", "}", "VAR_7 = g_malloc(SD_INODE_SIZE);", "VAR_4 = read_object(VAR_5, s->aio_context, VAR_7, vid_to_vdi_oid(vid),\n0, SD_INODE_SIZE, 0, s->cache_flags);", "closesocket(VAR_5);", "if (VAR_4) {", "error_setg(VAR_3, \"Can't read snapshot inode\");", "goto out;", "}", "memcpy(&s->inode, VAR_7, sizeof(s->inode));", "s->min_dirty_data_idx = UINT32_MAX;", "s->max_dirty_data_idx = 0;", "VAR_0->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;", "pstrcpy(s->name, sizeof(s->name), VAR_6);", "qemu_co_mutex_init(&s->lock);", "qemu_co_queue_init(&s->overwrapping_queue);", "qemu_opts_del(opts);", "g_free(VAR_7);", "return 0;", "out:\naio_set_fd_handler(bdrv_get_aio_context(VAR_0), s->VAR_5, NULL, NULL, NULL);", "if (s->VAR_5 >= 0) {", "closesocket(s->VAR_5);", "}", "qemu_opts_del(opts);", "g_free(VAR_7);", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153, 155 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ] ]

[ "static void FUNC_0 (DisasContext *VAR_0, uint32_t VAR_1, int VAR_2, int VAR_3)\n{", "const char *VAR_4 = \"cp1 move\";", "TCGv t0 = tcg_temp_new();", "switch (VAR_1) {", "case OPC_MFC1:\n{", "TCGv_i32 fp0 = tcg_temp_new_i32();", "gen_load_fpr32(fp0, VAR_3);", "tcg_gen_ext_i32_tl(t0, fp0);", "tcg_temp_free_i32(fp0);", "}", "gen_store_gpr(t0, VAR_2);", "VAR_4 = \"mfc1\";", "break;", "case OPC_MTC1:\ngen_load_gpr(t0, VAR_2);", "{", "TCGv_i32 fp0 = tcg_temp_new_i32();", "tcg_gen_trunc_tl_i32(fp0, t0);", "gen_store_fpr32(fp0, VAR_3);", "tcg_temp_free_i32(fp0);", "}", "VAR_4 = \"mtc1\";", "break;", "case OPC_CFC1:\ngen_helper_1e0i(cfc1, t0, VAR_3);", "gen_store_gpr(t0, VAR_2);", "VAR_4 = \"cfc1\";", "break;", "case OPC_CTC1:\ngen_load_gpr(t0, VAR_2);", "{", "TCGv_i32 fs_tmp = tcg_const_i32(VAR_3);", "gen_helper_0e2i(ctc1, t0, fs_tmp, VAR_2);", "tcg_temp_free_i32(fs_tmp);", "}", "VAR_4 = \"ctc1\";", "break;", "#if defined(TARGET_MIPS64)\ncase OPC_DMFC1:\ngen_load_fpr64(VAR_0, t0, VAR_3);", "gen_store_gpr(t0, VAR_2);", "VAR_4 = \"dmfc1\";", "break;", "case OPC_DMTC1:\ngen_load_gpr(t0, VAR_2);", "gen_store_fpr64(VAR_0, t0, VAR_3);", "VAR_4 = \"dmtc1\";", "break;", "#endif\ncase OPC_MFHC1:\n{", "TCGv_i32 fp0 = tcg_temp_new_i32();", "gen_load_fpr32h(fp0, VAR_3);", "tcg_gen_ext_i32_tl(t0, fp0);", "tcg_temp_free_i32(fp0);", "}", "gen_store_gpr(t0, VAR_2);", "VAR_4 = \"mfhc1\";", "break;", "case OPC_MTHC1:\ngen_load_gpr(t0, VAR_2);", "{", "TCGv_i32 fp0 = tcg_temp_new_i32();", "tcg_gen_trunc_tl_i32(fp0, t0);", "gen_store_fpr32h(fp0, VAR_3);", "tcg_temp_free_i32(fp0);", "}", "VAR_4 = \"mthc1\";", "break;", "default:\nMIPS_INVAL(VAR_4);", "generate_exception (VAR_0, EXCP_RI);", "goto out;", "}", "(void)VAR_4;", "MIPS_DEBUG(\"%s %s %s\", VAR_4, regnames[VAR_2], fregnames[VAR_3]);", "out:\ntcg_temp_free(t0);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "int VAR_4;", "HPETState *s = VAR_0;", "uint64_t old_val, new_val, val, index;", "DPRINTF(\"qemu: Enter hpet_ram_writel at %\" PRIx64 \" = %#x\\n\", VAR_1, VAR_2);", "index = VAR_1;", "old_val = hpet_ram_read(VAR_0, VAR_1, 4);", "new_val = VAR_2;", "if (index >= 0x100 && index <= 0x3ff) {", "uint8_t timer_id = (VAR_1 - 0x100) / 0x20;", "HPETTimer *timer = &s->timer[timer_id];", "DPRINTF(\"qemu: hpet_ram_writel timer_id = %#x\\n\", timer_id);", "if (timer_id > s->num_timers) {", "DPRINTF(\"qemu: timer id out of range\\n\");", "return;", "}", "switch ((VAR_1 - 0x100) % 0x20) {", "case HPET_TN_CFG:\nDPRINTF(\"qemu: hpet_ram_writel HPET_TN_CFG\\n\");", "if (activating_bit(old_val, new_val, HPET_TN_FSB_ENABLE)) {", "update_irq(timer, 0);", "}", "val = hpet_fixup_reg(new_val, old_val, HPET_TN_CFG_WRITE_MASK);", "timer->config = (timer->config & 0xffffffff00000000ULL) | val;", "if (new_val & HPET_TN_32BIT) {", "timer->cmp = (uint32_t)timer->cmp;", "timer->period = (uint32_t)timer->period;", "}", "if (activating_bit(old_val, new_val, HPET_TN_ENABLE)) {", "hpet_set_timer(timer);", "} else if (deactivating_bit(old_val, new_val, HPET_TN_ENABLE)) {", "hpet_del_timer(timer);", "}", "break;", "case HPET_TN_CFG + 4:\nDPRINTF(\"qemu: invalid HPET_TN_CFG+4 write\\n\");", "break;", "case HPET_TN_CMP:\nDPRINTF(\"qemu: hpet_ram_writel HPET_TN_CMP\\n\");", "if (timer->config & HPET_TN_32BIT) {", "new_val = (uint32_t)new_val;", "}", "if (!timer_is_periodic(timer)\n|| (timer->config & HPET_TN_SETVAL)) {", "timer->cmp = (timer->cmp & 0xffffffff00000000ULL) | new_val;", "}", "if (timer_is_periodic(timer)) {", "new_val &= (timer->config & HPET_TN_32BIT ? ~0u : ~0ull) >> 1;", "timer->period =\n(timer->period & 0xffffffff00000000ULL) | new_val;", "}", "timer->config &= ~HPET_TN_SETVAL;", "if (hpet_enabled(s)) {", "hpet_set_timer(timer);", "}", "break;", "case HPET_TN_CMP + 4: high order\nDPRINTF(\"qemu: hpet_ram_writel HPET_TN_CMP + 4\\n\");", "if (!timer_is_periodic(timer)\n|| (timer->config & HPET_TN_SETVAL)) {", "timer->cmp = (timer->cmp & 0xffffffffULL) | new_val << 32;", "} else {", "new_val &= (timer->config & HPET_TN_32BIT ? ~0u : ~0ull) >> 1;", "timer->period =\n(timer->period & 0xffffffffULL) | new_val << 32;", "}", "timer->config &= ~HPET_TN_SETVAL;", "if (hpet_enabled(s)) {", "hpet_set_timer(timer);", "}", "break;", "case HPET_TN_ROUTE:\ntimer->fsb = (timer->fsb & 0xffffffff00000000ULL) | new_val;", "break;", "case HPET_TN_ROUTE + 4:\ntimer->fsb = (new_val << 32) | (timer->fsb & 0xffffffff);", "break;", "default:\nDPRINTF(\"qemu: invalid hpet_ram_writel\\n\");", "break;", "}", "return;", "} else {", "switch (index) {", "case HPET_ID:\nreturn;", "case HPET_CFG:\nval = hpet_fixup_reg(new_val, old_val, HPET_CFG_WRITE_MASK);", "s->config = (s->config & 0xffffffff00000000ULL) | val;", "if (activating_bit(old_val, new_val, HPET_CFG_ENABLE)) {", "s->hpet_offset =\nticks_to_ns(s->hpet_counter) - qemu_get_clock_ns(vm_clock);", "for (VAR_4 = 0; VAR_4 < s->num_timers; VAR_4++) {", "if ((&s->timer[VAR_4])->cmp != ~0ULL) {", "hpet_set_timer(&s->timer[VAR_4]);", "}", "}", "} else if (deactivating_bit(old_val, new_val, HPET_CFG_ENABLE)) {", "s->hpet_counter = hpet_get_ticks(s);", "for (VAR_4 = 0; VAR_4 < s->num_timers; VAR_4++) {", "hpet_del_timer(&s->timer[VAR_4]);", "}", "}", "if (activating_bit(old_val, new_val, HPET_CFG_LEGACY)) {", "qemu_set_irq(s->pit_enabled, 0);", "qemu_irq_lower(s->irqs[0]);", "qemu_irq_lower(s->irqs[RTC_ISA_IRQ]);", "} else if (deactivating_bit(old_val, new_val, HPET_CFG_LEGACY)) {", "qemu_irq_lower(s->irqs[0]);", "qemu_set_irq(s->pit_enabled, 1);", "qemu_set_irq(s->irqs[RTC_ISA_IRQ], s->rtc_irq_level);", "}", "break;", "case HPET_CFG + 4:\nDPRINTF(\"qemu: invalid HPET_CFG+4 write\\n\");", "break;", "case HPET_STATUS:\nval = new_val & s->isr;", "for (VAR_4 = 0; VAR_4 < s->num_timers; VAR_4++) {", "if (val & (1 << VAR_4)) {", "update_irq(&s->timer[VAR_4], 0);", "}", "}", "break;", "case HPET_COUNTER:\nif (hpet_enabled(s)) {", "DPRINTF(\"qemu: Writing counter while HPET enabled!\\n\");", "}", "s->hpet_counter =\n(s->hpet_counter & 0xffffffff00000000ULL) | VAR_2;", "DPRINTF(\"qemu: HPET counter written. ctr = %#x -> %\" PRIx64 \"\\n\",\nVAR_2, s->hpet_counter);", "break;", "case HPET_COUNTER + 4:\nif (hpet_enabled(s)) {", "DPRINTF(\"qemu: Writing counter while HPET enabled!\\n\");", "}", "s->hpet_counter =\n(s->hpet_counter & 0xffffffffULL) | (((uint64_t)VAR_2) << 32);", "DPRINTF(\"qemu: HPET counter + 4 written. ctr = %#x -> %\" PRIx64 \"\\n\",\nVAR_2, s->hpet_counter);", "break;", "default:\nDPRINTF(\"qemu: invalid hpet_ram_writel\\n\");", "break;", "}", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 27 ], [ 29 ], [ 31 ], [ 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 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133, 135 ], [ 137, 139 ], [ 141 ], [ 143 ], [ 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 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 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 ] ]

[ "static void FUNC_0 (CPUPPCState *VAR_0)\n{", "gen_spr_ne_601(VAR_0);", "gen_spr_601(VAR_0);", "spr_register(VAR_0, SPR_HID0, \"HID0\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_hid0_601,\n0x80010080);", "spr_register(VAR_0, SPR_HID1, \"HID1\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_601_HID2, \"HID2\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_601_HID5, \"HID5\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "spr_register(VAR_0, SPR_601_HID15, \"HID15\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "#if !defined(CONFIG_USER_ONLY)\nVAR_0->nb_tlb = 64;", "VAR_0->nb_ways = 2;", "VAR_0->id_tlbs = 0;", "#endif\ninit_excp_601(VAR_0);", "VAR_0->dcache_line_size = 64;", "VAR_0->icache_line_size = 64;", "ppc6xx_irq_init(VAR_0);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13, 15, 17, 19 ], [ 23, 25, 27, 29 ], [ 33, 35, 37, 39 ], [ 43, 45, 47, 49 ], [ 53, 55, 57, 59 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ] ]

[ "static inline void FUNC_0(DisasContext *VAR_0, int VAR_1)\n{", "gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);", "gen_string_movl_A0_EDI(VAR_0);", "gen_op_st_T0_A0(VAR_1 + VAR_0->mem_index);", "gen_op_movl_T0_Dshift[VAR_1]();", "#ifdef TARGET_X86_64\nif (VAR_0->aflag == 2) {", "gen_op_addq_EDI_T0();", "} else", "#endif\nif (VAR_0->aflag) {", "gen_op_addl_EDI_T0();", "} else {", "gen_op_addw_EDI_T0();", "}", "}" ]

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

[ "static int FUNC_0(int VAR_0, char *VAR_1, uint64_t VAR_2, int VAR_3,\nunsigned int VAR_4, uint64_t VAR_5, bool VAR_6)\n{", "return read_write_object(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, false,\nfalse, VAR_6);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0, GetBitContext *VAR_1,\nunsigned int VAR_2, int *VAR_3, const int *VAR_4, const int *VAR_5)\n{", "int VAR_6 = 0, VAR_7 = 0, VAR_8;", "int VAR_9 = *VAR_5++;", "unsigned int VAR_10=0, VAR_11= 0;", "VAR_4--;", "while(VAR_10 < VAR_2){", "int VAR_12 = get_vlc2(VAR_1, ccitt_group3_2d_vlc.table, 9, 1);", "if(VAR_12 == -1){", "av_log(VAR_0, AV_LOG_ERROR, \"Incorrect VAR_6 VLC\\n\");", "return -1;", "}", "if(!VAR_12){", "VAR_9 += *VAR_5++;", "VAR_11 = VAR_9 - VAR_10;", "VAR_10= VAR_9;", "VAR_9 += *VAR_5++;", "if(VAR_10 > VAR_2){", "av_log(VAR_0, AV_LOG_ERROR, \"Run went out of bounds\\n\");", "return -1;", "}", "VAR_7 += VAR_11;", "}else if(VAR_12 == 1){", "int VAR_13;", "for(VAR_13 = 0; VAR_13 < 2; VAR_13++){", "VAR_11 = 0;", "for(;;){", "VAR_8 = get_vlc2(VAR_1, ccitt_vlc[VAR_6].table, 9, 2);", "if(VAR_8 == -1){", "av_log(VAR_0, AV_LOG_ERROR, \"Incorrect code\\n\");", "return -1;", "}", "VAR_11 += VAR_8;", "if(VAR_8 < 64)\nbreak;", "}", "*VAR_3++ = VAR_11 + VAR_7;", "if(VAR_3 >= VAR_4){", "av_log(VAR_0, AV_LOG_ERROR, \"Run overrun\\n\");", "return -1;", "}", "VAR_7 = 0;", "VAR_10 += VAR_11;", "if(VAR_10 > VAR_2 || VAR_11 > VAR_2){", "av_log(VAR_0, AV_LOG_ERROR, \"Run went out of bounds\\n\");", "return -1;", "}", "VAR_6 = !VAR_6;", "}", "}else if(VAR_12 == 9 || VAR_12 == 10){", "av_log(VAR_0, AV_LOG_ERROR, \"Special modes are not supported (yet)\\n\");", "return -1;", "}else{", "VAR_11 = VAR_9 - VAR_10 + (VAR_12 - 5);", "VAR_9 -= *--VAR_5;", "VAR_10 += VAR_11;", "if(VAR_10 > VAR_2 || VAR_11 > VAR_2){", "av_log(VAR_0, AV_LOG_ERROR, \"Run went out of bounds\\n\");", "return -1;", "}", "*VAR_3++ = VAR_11 + VAR_7;", "if(VAR_3 >= VAR_4){", "av_log(VAR_0, AV_LOG_ERROR, \"Run overrun\\n\");", "return -1;", "}", "VAR_7 = 0;", "VAR_6 = !VAR_6;", "}", "while(VAR_9 <= VAR_10){", "VAR_9 += *VAR_5++;", "VAR_9 += *VAR_5++;", "}", "}", "*VAR_3++ = VAR_7;", "*VAR_3++ = 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 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 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ] ]

[ "static int VAR_0 bdrv_aligned_preadv(BlockDriverState *bs,\nint64_t offset, unsigned int bytes, QEMUIOVector *qiov, int flags)\n{", "BlockDriver *drv = bs->drv;", "BdrvTrackedRequest req;", "int ret;", "int64_t sector_num = offset >> BDRV_SECTOR_BITS;", "unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;", "assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);", "assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);", "if (flags & BDRV_REQ_COPY_ON_READ) {", "bs->copy_on_read_in_flight++;", "}", "if (bs->copy_on_read_in_flight) {", "wait_for_overlapping_requests(bs, offset, bytes);", "}", "tracked_request_begin(&req, bs, offset, bytes, false);", "if (flags & BDRV_REQ_COPY_ON_READ) {", "int pnum;", "ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);", "if (ret < 0) {", "goto out;", "}", "if (!ret || pnum != nb_sectors) {", "ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);", "goto out;", "}", "}", "if (!(bs->zero_beyond_eof && bs->growable)) {", "ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);", "} else {", "int64_t len, total_sectors, max_nb_sectors;", "len = bdrv_getlength(bs);", "if (len < 0) {", "ret = len;", "goto out;", "}", "total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);", "max_nb_sectors = MAX(0, total_sectors - sector_num);", "if (max_nb_sectors > 0) {", "ret = drv->bdrv_co_readv(bs, sector_num,\nMIN(nb_sectors, max_nb_sectors), qiov);", "} else {", "ret = 0;", "}", "if (ret == 0 && total_sectors < sector_num + nb_sectors) {", "uint64_t offset = MAX(0, total_sectors - sector_num);", "uint64_t bytes = (sector_num + nb_sectors - offset) *\nBDRV_SECTOR_SIZE;", "qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);", "}", "}", "out:\ntracked_request_end(&req);", "if (flags & BDRV_REQ_COPY_ON_READ) {", "bs->copy_on_read_in_flight--;", "}", "return ret;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ] ]

[ "void FUNC_0(VirtQueue *VAR_0)\n{", "if (VAR_0->vring.desc) {", "VirtIODevice *vdev = VAR_0->vdev;", "trace_virtio_queue_notify(vdev, VAR_0 - vdev->VAR_0, VAR_0);", "VAR_0->handle_output(vdev, VAR_0);", "}", "}" ]

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

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

[ "target_ulong FUNC_0(CPUMIPSState *env)\n{", "check_hwrena(env, 4);", "return env->CP0_Performance0;", "}" ]

[ 0, 1, 0, 0 ]

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

[ "static void FUNC_0(DeviceState *VAR_0)\n{", "OpenPICState *opp = FROM_SYSBUS(typeof (*opp), sysbus_from_qdev(VAR_0));", "int VAR_1;", "opp->glbc = GLBC_RESET;", "opp->frep = ((opp->nb_irqs - 1) << FREP_NIRQ_SHIFT) |\n((opp->nb_cpus - 1) << FREP_NCPU_SHIFT) |\n(opp->vid << FREP_VID_SHIFT);", "opp->pint = 0;", "opp->spve = -1 & opp->vector_mask;", "opp->tifr = opp->tifr_reset;", "for (VAR_1 = 0; VAR_1 < opp->max_irq; VAR_1++) {", "opp->src[VAR_1].ipvp = opp->ipvp_reset;", "opp->src[VAR_1].ide = opp->ide_reset;", "}", "for (VAR_1 = 0; VAR_1 < MAX_CPU; VAR_1++) {", "opp->dst[VAR_1].pctp = 15;", "memset(&opp->dst[VAR_1].raised, 0, sizeof(IRQ_queue_t));", "opp->dst[VAR_1].raised.next = -1;", "memset(&opp->dst[VAR_1].servicing, 0, sizeof(IRQ_queue_t));", "opp->dst[VAR_1].servicing.next = -1;", "}", "for (VAR_1 = 0; VAR_1 < MAX_TMR; VAR_1++) {", "opp->timers[VAR_1].ticc = 0;", "opp->timers[VAR_1].tibc = TIBC_CI;", "}", "opp->glbc = 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15, 17, 19 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ] ]

[ "static uint64_t FUNC_0(BlockDriverState *bs,\nuint64_t offset, int allocate)\n{", "BDRVVmdkState *s = bs->opaque;", "unsigned int VAR_0, VAR_1, VAR_2;", "int VAR_3, VAR_4, VAR_5;", "uint32_t min_count, *l2_table, tmp;", "uint64_t cluster_offset;", "VAR_0 = (offset >> 9) / s->l1_entry_sectors;", "if (VAR_0 >= s->l1_size)\nreturn 0;", "VAR_1 = s->l1_table[VAR_0];", "if (!VAR_1)\nreturn 0;", "for(VAR_4 = 0; VAR_4 < L2_CACHE_SIZE; VAR_4++) {", "if (VAR_1 == s->l2_cache_offsets[VAR_4]) {", "if (++s->l2_cache_counts[VAR_4] == 0xffffffff) {", "for(VAR_5 = 0; VAR_5 < L2_CACHE_SIZE; VAR_5++) {", "s->l2_cache_counts[VAR_5] >>= 1;", "}", "}", "l2_table = s->l2_cache + (VAR_4 * s->l2_size);", "goto found;", "}", "}", "VAR_3 = 0;", "min_count = 0xffffffff;", "for(VAR_4 = 0; VAR_4 < L2_CACHE_SIZE; VAR_4++) {", "if (s->l2_cache_counts[VAR_4] < min_count) {", "min_count = s->l2_cache_counts[VAR_4];", "VAR_3 = VAR_4;", "}", "}", "l2_table = s->l2_cache + (VAR_3 * s->l2_size);", "if (bdrv_pread(s->hd, (int64_t)VAR_1 * 512, l2_table, s->l2_size * sizeof(uint32_t)) !=\ns->l2_size * sizeof(uint32_t))\nreturn 0;", "s->l2_cache_offsets[VAR_3] = VAR_1;", "s->l2_cache_counts[VAR_3] = 1;", "found:\nVAR_2 = ((offset >> 9) / s->cluster_sectors) % s->l2_size;", "cluster_offset = le32_to_cpu(l2_table[VAR_2]);", "if (!cluster_offset) {", "struct stat VAR_6;", "if (!allocate)\nreturn 0;", "stat(s->hd->filename, &VAR_6);", "cluster_offset = VAR_6.st_size;", "bdrv_truncate(s->hd, cluster_offset + (s->cluster_sectors << 9));", "cluster_offset >>= 9;", "tmp = cpu_to_le32(cluster_offset);", "l2_table[VAR_2] = tmp;", "if (bdrv_pwrite(s->hd, ((int64_t)VAR_1 * 512) + (VAR_2 * sizeof(tmp)),\n&tmp, sizeof(tmp)) != sizeof(tmp))\nreturn 0;", "if (s->l1_backup_table_offset != 0) {", "VAR_1 = s->l1_backup_table[VAR_0];", "if (bdrv_pwrite(s->hd, ((int64_t)VAR_1 * 512) + (VAR_2 * sizeof(tmp)),\n&tmp, sizeof(tmp)) != sizeof(tmp))\nreturn 0;", "}", "if (get_whole_cluster(bs, cluster_offset, offset, allocate) == -1)\nreturn 0;", "}", "cluster_offset <<= 9;", "return cluster_offset;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "RBDAIOCB *acb = VAR_0;", "if (acb->cmd == RBD_AIO_READ) {", "qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);", "}", "qemu_vfree(acb->bounce);", "acb->common.cb(acb->common.VAR_0, (acb->ret > 0 ? 0 : acb->ret));", "qemu_bh_delete(acb->bh);", "acb->bh = NULL;", "qemu_aio_release(acb);", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "TestData td;", "const uint16_t VAR_0 = TCO_SECS_TO_TICKS(128);", "QDict *ad;", "td.args = \"-watchdog-action shutdown\";", "td.noreboot = false;", "test_init(&td);", "stop_tco(&td);", "clear_tco_status(&td);", "reset_on_second_timeout(true);", "set_tco_timeout(&td, VAR_0);", "load_tco(&td);", "start_tco(&td);", "clock_step(VAR_0 * TCO_TICK_NSEC * 2);", "ad = get_watchdog_action();", "g_assert(!strcmp(qdict_get_str(ad, \"action\"), \"shutdown\"));", "QDECREF(ad);", "stop_tco(&td);", "qtest_end();", "}" ]

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

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

[ "static void FUNC_0(uint8_t VAR_0)\n{", "uint8_t *ppolicy = g_malloc(1);", "char *VAR_1 = g_malloc0(256);", "*ppolicy = VAR_0;", "if (VAR_0 == PTIMER_POLICY_DEFAULT) {", "g_sprintf(VAR_1, \"default\");", "}", "if (VAR_0 & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {", "g_strlcat(VAR_1, \"wrap_after_one_period,\", 256);", "}", "if (VAR_0 & PTIMER_POLICY_CONTINUOUS_TRIGGER) {", "g_strlcat(VAR_1, \"continuous_trigger,\", 256);", "}", "if (VAR_0 & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER) {", "g_strlcat(VAR_1, \"no_immediate_trigger,\", 256);", "}", "if (VAR_0 & PTIMER_POLICY_NO_IMMEDIATE_RELOAD) {", "g_strlcat(VAR_1, \"no_immediate_reload,\", 256);", "}", "if (VAR_0 & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {", "g_strlcat(VAR_1, \"no_counter_rounddown,\", 256);", "}", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/set_count VAR_0=%s\", VAR_1),\nppolicy, check_set_count);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/set_limit VAR_0=%s\", VAR_1),\nppolicy, check_set_limit);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/oneshot VAR_0=%s\", VAR_1),\nppolicy, check_oneshot);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/periodic VAR_0=%s\", VAR_1),\nppolicy, check_periodic);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/on_the_fly_mode_change VAR_0=%s\", VAR_1),\nppolicy, check_on_the_fly_mode_change);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/on_the_fly_period_change VAR_0=%s\", VAR_1),\nppolicy, check_on_the_fly_period_change);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/on_the_fly_freq_change VAR_0=%s\", VAR_1),\nppolicy, check_on_the_fly_freq_change);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/run_with_period_0 VAR_0=%s\", VAR_1),\nppolicy, check_run_with_period_0);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/run_with_delta_0 VAR_0=%s\", VAR_1),\nppolicy, check_run_with_delta_0);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/periodic_with_load_0 VAR_0=%s\", VAR_1),\nppolicy, check_periodic_with_load_0);", "g_test_add_data_func(\ng_strdup_printf(\"/ptimer/oneshot_with_load_0 VAR_0=%s\", VAR_1),\nppolicy, check_oneshot_with_load_0);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63, 65, 67 ], [ 71, 73, 75 ], [ 79, 81, 83 ], [ 87, 89, 91 ], [ 95, 97, 99 ], [ 103, 105, 107 ], [ 111, 113, 115 ], [ 119, 121, 123 ], [ 127, 129, 131 ], [ 135, 137, 139 ], [ 143, 145, 147 ], [ 149 ] ]

[ "void FUNC_0(entry)(CPUXtensaState *env, uint32_t pc, uint32_t s, uint32_t imm)\n{", "int VAR_0 = (env->sregs[PS] & PS_CALLINC) >> PS_CALLINC_SHIFT;", "if (s > 3 || ((env->sregs[PS] & (PS_WOE | PS_EXCM)) ^ PS_WOE) != 0) {", "qemu_log(\"Illegal entry instruction(pc = %08x), PS = %08x\\n\",\npc, env->sregs[PS]);", "FUNC_0(exception_cause)(env, pc, ILLEGAL_INSTRUCTION_CAUSE);", "} else {", "env->regs[(VAR_0 << 2) | (s & 3)] = env->regs[s] - (imm << 3);", "rotate_window(env, VAR_0);", "env->sregs[WINDOW_START] |=\nwindowstart_bit(env->sregs[WINDOW_BASE], env);" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5, 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11, 12 ] ]

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "MacIONVRAMState *s = VAR_0;", "VAR_1 = (VAR_1 >> s->it_shift) & (s->VAR_3 - 1);", "s->data[VAR_1] = VAR_2;", "NVR_DPRINTF(\"writeb VAR_1 %04\" PHYS_PRIx \" val %\" PRIx64 \"\\n\", VAR_1, VAR_2);", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "BDRVQcow2State *s = VAR_0->opaque;", "unsigned int VAR_4, VAR_5;", "int VAR_6 = 0;", "QCowHeader header;", "Error *local_err = NULL;", "uint64_t ext_end;", "uint64_t l1_vm_state_index;", "bool update_header = false;", "VAR_6 = bdrv_pread(VAR_0->file, 0, &header, sizeof(header));", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not read qcow2 header\");", "be32_to_cpus(&header.magic);", "be32_to_cpus(&header.version);", "be64_to_cpus(&header.backing_file_offset);", "be32_to_cpus(&header.backing_file_size);", "be64_to_cpus(&header.size);", "be32_to_cpus(&header.cluster_bits);", "be32_to_cpus(&header.crypt_method);", "be64_to_cpus(&header.l1_table_offset);", "be32_to_cpus(&header.l1_size);", "be64_to_cpus(&header.refcount_table_offset);", "be32_to_cpus(&header.refcount_table_clusters);", "be64_to_cpus(&header.snapshots_offset);", "be32_to_cpus(&header.nb_snapshots);", "if (header.magic != QCOW_MAGIC) {", "error_setg(VAR_3, \"Image is not in qcow2 format\");", "if (header.version < 2 || header.version > 3) {", "error_setg(VAR_3, \"Unsupported qcow2 version %\" PRIu32, header.version);", "VAR_6 = -ENOTSUP;", "s->qcow_version = header.version;", "if (header.cluster_bits < MIN_CLUSTER_BITS ||\nheader.cluster_bits > MAX_CLUSTER_BITS) {", "error_setg(VAR_3, \"Unsupported cluster size: 2^%\" PRIu32,\nheader.cluster_bits);", "s->cluster_bits = header.cluster_bits;", "s->cluster_size = 1 << s->cluster_bits;", "s->cluster_sectors = 1 << (s->cluster_bits - BDRV_SECTOR_BITS);", "if (header.version == 2) {", "header.incompatible_features = 0;", "header.compatible_features = 0;", "header.autoclear_features = 0;", "header.refcount_order = 4;", "header.header_length = 72;", "} else {", "be64_to_cpus(&header.incompatible_features);", "be64_to_cpus(&header.compatible_features);", "be64_to_cpus(&header.autoclear_features);", "be32_to_cpus(&header.refcount_order);", "be32_to_cpus(&header.header_length);", "if (header.header_length < 104) {", "error_setg(VAR_3, \"qcow2 header too short\");", "if (header.header_length > s->cluster_size) {", "error_setg(VAR_3, \"qcow2 header exceeds cluster size\");", "if (header.header_length > sizeof(header)) {", "s->unknown_header_fields_size = header.header_length - sizeof(header);", "s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);", "VAR_6 = bdrv_pread(VAR_0->file, sizeof(header), s->unknown_header_fields,\ns->unknown_header_fields_size);", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not read unknown qcow2 header \"\n\"fields\");", "if (header.backing_file_offset > s->cluster_size) {", "error_setg(VAR_3, \"Invalid backing file offset\");", "if (header.backing_file_offset) {", "ext_end = header.backing_file_offset;", "} else {", "ext_end = 1 << header.cluster_bits;", "s->incompatible_features = header.incompatible_features;", "s->compatible_features = header.compatible_features;", "s->autoclear_features = header.autoclear_features;", "if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {", "void *VAR_7 = NULL;", "qcow2_read_extensions(VAR_0, header.header_length, ext_end,\n&VAR_7, VAR_2, NULL, NULL);", "report_unsupported_feature(VAR_3, VAR_7,\ns->incompatible_features &\n~QCOW2_INCOMPAT_MASK);", "VAR_6 = -ENOTSUP;", "g_free(VAR_7);", "if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {", "if ((VAR_2 & BDRV_O_RDWR) && !(VAR_2 & BDRV_O_CHECK)) {", "error_setg(VAR_3, \"qcow2: Image is corrupt; cannot be opened \"", "\"read/write\");", "VAR_6 = -EACCES;", "if (header.refcount_order > 6) {", "error_setg(VAR_3, \"Reference count entry width too large; may not \"", "\"exceed 64 bits\");", "s->refcount_order = header.refcount_order;", "s->refcount_bits = 1 << s->refcount_order;", "s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);", "s->refcount_max += s->refcount_max - 1;", "s->crypt_method_header = header.crypt_method;", "if (s->crypt_method_header) {", "if (bdrv_uses_whitelist() &&\ns->crypt_method_header == QCOW_CRYPT_AES) {", "error_setg(VAR_3,\n\"Use of AES-CBC encrypted qcow2 images is no longer \"\n\"supported in system emulators\");", "error_append_hint(VAR_3,\n\"You can use 'qemu-img convert' to convert your \"\n\"image to an alternative supported format, such \"\n\"as unencrypted qcow2, or raw with the LUKS \"\n\"format instead.\\n\");", "VAR_6 = -ENOSYS;", "if (s->crypt_method_header == QCOW_CRYPT_AES) {", "s->crypt_physical_offset = false;", "} else {", "s->crypt_physical_offset = true;", "VAR_0->encrypted = true;", "s->l2_bits = s->cluster_bits - 3;", "s->l2_size = 1 << s->l2_bits;", "s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);", "s->refcount_block_size = 1 << s->refcount_block_bits;", "VAR_0->total_sectors = header.size / 512;", "s->csize_shift = (62 - (s->cluster_bits - 8));", "s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;", "s->cluster_offset_mask = (1LL << s->csize_shift) - 1;", "s->refcount_table_offset = header.refcount_table_offset;", "s->refcount_table_size =\nheader.refcount_table_clusters << (s->cluster_bits - 3);", "if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) {", "error_setg(VAR_3, \"Reference count table too large\");", "VAR_6 = validate_table_offset(VAR_0, s->refcount_table_offset,\ns->refcount_table_size, sizeof(uint64_t));", "if (VAR_6 < 0) {", "error_setg(VAR_3, \"Invalid reference count table offset\");", "if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) {", "error_setg(VAR_3, \"Too many snapshots\");", "VAR_6 = validate_table_offset(VAR_0, header.snapshots_offset,\nheader.nb_snapshots,\nsizeof(QCowSnapshotHeader));", "if (VAR_6 < 0) {", "error_setg(VAR_3, \"Invalid snapshot table offset\");", "if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {", "error_setg(VAR_3, \"Active L1 table too large\");", "VAR_6 = -EFBIG;", "s->l1_size = header.l1_size;", "l1_vm_state_index = size_to_l1(s, header.size);", "if (l1_vm_state_index > INT_MAX) {", "error_setg(VAR_3, \"Image is too big\");", "VAR_6 = -EFBIG;", "s->l1_vm_state_index = l1_vm_state_index;", "if (s->l1_size < s->l1_vm_state_index) {", "error_setg(VAR_3, \"L1 table is too small\");", "VAR_6 = validate_table_offset(VAR_0, header.l1_table_offset,\nheader.l1_size, sizeof(uint64_t));", "if (VAR_6 < 0) {", "error_setg(VAR_3, \"Invalid L1 table offset\");", "s->l1_table_offset = header.l1_table_offset;", "if (s->l1_size > 0) {", "s->l1_table = qemu_try_blockalign(VAR_0->file->VAR_0,\nalign_offset(s->l1_size * sizeof(uint64_t), 512));", "if (s->l1_table == NULL) {", "error_setg(VAR_3, \"Could not allocate L1 table\");", "VAR_6 = -ENOMEM;", "VAR_6 = bdrv_pread(VAR_0->file, s->l1_table_offset, s->l1_table,\ns->l1_size * sizeof(uint64_t));", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not read L1 table\");", "for(VAR_5 = 0;VAR_5 < s->l1_size; VAR_5++) {", "be64_to_cpus(&s->l1_table[VAR_5]);", "VAR_6 = qcow2_update_options(VAR_0, VAR_1, VAR_2, VAR_3);", "if (VAR_6 < 0) {", "s->cluster_cache_offset = -1;", "s->VAR_2 = VAR_2;", "VAR_6 = qcow2_refcount_init(VAR_0);", "if (VAR_6 != 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not initialize refcount handling\");", "QLIST_INIT(&s->cluster_allocs);", "QTAILQ_INIT(&s->discards);", "if (qcow2_read_extensions(VAR_0, header.header_length, ext_end, NULL,\nVAR_2, &update_header, &local_err)) {", "error_propagate(VAR_3, local_err);", "if (s->crypt_method_header && !s->crypto) {", "if (s->crypt_method_header == QCOW_CRYPT_AES) {", "unsigned int cflags = 0;", "if (VAR_2 & BDRV_O_NO_IO) {", "cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;", "s->crypto = qcrypto_block_open(s->crypto_opts, \"encrypt.\",\nNULL, NULL, cflags, VAR_3);", "if (!s->crypto) {", "} else if (!(VAR_2 & BDRV_O_NO_IO)) {", "error_setg(VAR_3, \"Missing CRYPTO header for crypt method %d\",\ns->crypt_method_header);", "if (header.backing_file_offset != 0) {", "VAR_4 = header.backing_file_size;", "if (VAR_4 > MIN(1023, s->cluster_size - header.backing_file_offset) ||\nVAR_4 >= sizeof(VAR_0->backing_file)) {", "error_setg(VAR_3, \"Backing file name too long\");", "VAR_6 = bdrv_pread(VAR_0->file, header.backing_file_offset,\nVAR_0->backing_file, VAR_4);", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not read backing file name\");", "VAR_0->backing_file[VAR_4] = '\\0';", "s->image_backing_file = g_strdup(VAR_0->backing_file);", "s->snapshots_offset = header.snapshots_offset;", "s->nb_snapshots = header.nb_snapshots;", "VAR_6 = qcow2_read_snapshots(VAR_0);", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not read snapshots\");", "update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK;", "update_header =\nupdate_header && !VAR_0->read_only && !(VAR_2 & BDRV_O_INACTIVE);", "if (update_header) {", "s->autoclear_features &= QCOW2_AUTOCLEAR_MASK;", "if (qcow2_load_autoloading_dirty_bitmaps(VAR_0, &local_err)) {", "update_header = false;", "if (local_err != NULL) {", "error_propagate(VAR_3, local_err);", "if (update_header) {", "VAR_6 = qcow2_update_header(VAR_0);", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not update qcow2 header\");", "qemu_co_mutex_init(&s->lock);", "VAR_0->supported_zero_flags = BDRV_REQ_MAY_UNMAP;", "if (!(VAR_2 & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !VAR_0->read_only &&\n(s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {", "BdrvCheckResult result = {0};", "VAR_6 = qcow2_check(VAR_0, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);", "if (VAR_6 < 0) {", "error_setg_errno(VAR_3, -VAR_6, \"Could not repair dirty image\");", "#ifdef DEBUG_ALLOC\n{", "BdrvCheckResult result = {0};", "qcow2_check_refcounts(VAR_0, &result, 0);", "#endif\nreturn VAR_6;", "fail:\ng_free(s->unknown_header_fields);", "cleanup_unknown_header_ext(VAR_0);", "qcow2_free_snapshots(VAR_0);", "qcow2_refcount_close(VAR_0);", "qemu_vfree(s->l1_table);", "s->l1_table = NULL;", "cache_clean_timer_del(VAR_0);", "if (s->l2_table_cache) {", "qcow2_cache_destroy(VAR_0, s->l2_table_cache);", "if (s->refcount_block_cache) {", "qcow2_cache_destroy(VAR_0, s->refcount_block_cache);", "qcrypto_block_free(s->crypto);", "qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);", "return VAR_6;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 35, 36 ], [ 37, 38 ], [ 39 ], [ 40 ], [ 41 ], [ 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52 ], [ 53 ], [ 54 ], [ 55 ], [ 56 ], [ 57 ], [ 58 ], [ 59 ], [ 60 ], [ 61 ], [ 62, 63 ], [ 64 ], [ 65, 66 ], [ 67 ], [ 68 ], [ 69 ], [ 70 ], [ 71 ], [ 72 ], [ 74 ], [ 75 ], [ 76 ], [ 77 ], [ 78 ], [ 79, 80 ], [ 81, 82, 83 ], [ 84 ], [ 85 ], [ 86 ], [ 89 ], [ 90 ], [ 91 ], [ 92 ], [ 94 ], [ 95 ], [ 96 ], [ 97 ], [ 98 ], [ 99 ], [ 100 ], [ 101 ], [ 102 ], [ 103, 104 ], [ 105, 106, 107 ], [ 108, 109, 110, 111, 112 ], [ 113 ], [ 114 ], [ 115 ], [ 116 ], [ 120 ], [ 121 ], [ 122 ], [ 123 ], [ 125 ], [ 126 ], [ 127 ], [ 128 ], [ 129 ], [ 130 ], [ 131 ], [ 132, 133 ], [ 134 ], [ 135 ], [ 136, 137 ], [ 138 ], [ 139 ], [ 141 ], [ 142 ], [ 143, 144, 145 ], [ 146 ], [ 147 ], [ 149 ], [ 150 ], [ 151 ], [ 152 ], [ 153 ], [ 154 ], [ 155 ], [ 156 ], [ 157 ], [ 160 ], [ 161 ], [ 162, 163 ], [ 164 ], [ 165 ], [ 166 ], [ 167 ], [ 168, 169 ], [ 170 ], [ 171 ], [ 172 ], [ 173, 174 ], [ 175 ], [ 176 ], [ 177 ], [ 178 ], [ 180 ], [ 181 ], [ 182 ], [ 183 ], [ 184 ], [ 185 ], [ 186 ], [ 187 ], [ 188 ], [ 190, 191 ], [ 192 ], [ 197 ], [ 198 ], [ 199 ], [ 200 ], [ 201 ], [ 202, 203 ], [ 204 ], [ 205 ], [ 206, 207 ], [ 209 ], [ 210 ], [ 211, 212 ], [ 213 ], [ 214, 215 ], [ 216 ], [ 217 ], [ 218 ], [ 219 ], [ 221 ], [ 222 ], [ 223 ], [ 224 ], [ 225 ], [ 227 ], [ 228, 229 ], [ 230 ], [ 231 ], [ 232 ], [ 233 ], [ 234 ], [ 235 ], [ 236 ], [ 237 ], [ 238 ], [ 239 ], [ 241 ], [ 242 ], [ 244, 245 ], [ 246 ], [ 247 ], [ 248 ], [ 249 ], [ 250, 251 ], [ 252 ], [ 253 ], [ 254, 255 ], [ 256, 257 ], [ 258 ], [ 259 ], [ 260 ], [ 261 ], [ 263 ], [ 264 ], [ 265 ], [ 266 ], [ 267 ], [ 268 ], [ 269 ], [ 270 ], [ 271 ] ]

[ "static void FUNC_0(CPUState *VAR_0)\n{", "int VAR_1;", "sigset_t set;", "struct sigaction VAR_2;", "memset(&VAR_2, 0, sizeof(VAR_2));", "VAR_2.sa_handler = dummy_signal;", "sigaction(SIG_IPI, &VAR_2, NULL);", "#ifdef CONFIG_IOTHREAD\npthread_sigmask(SIG_BLOCK, NULL, &set);", "sigdelset(&set, SIG_IPI);", "sigdelset(&set, SIGBUS);", "VAR_1 = kvm_set_signal_mask(VAR_0, &set);", "if (VAR_1) {", "fprintf(stderr, \"kvm_set_signal_mask: %s\\n\", strerror(-VAR_1));", "exit(1);", "}", "#else\nsigemptyset(&set);", "sigaddset(&set, SIG_IPI);", "sigaddset(&set, SIGIO);", "sigaddset(&set, SIGALRM);", "pthread_sigmask(SIG_BLOCK, &set, NULL);", "pthread_sigmask(SIG_BLOCK, NULL, &set);", "sigdelset(&set, SIGIO);", "sigdelset(&set, SIGALRM);", "#endif\nsigdelset(&set, SIG_IPI);", "sigdelset(&set, SIGBUS);", "VAR_1 = kvm_set_signal_mask(VAR_0, &set);", "if (VAR_1) {", "fprintf(stderr, \"kvm_set_signal_mask: %s\\n\", strerror(-VAR_1));", "exit(1);", "}", "}" ]

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

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

[ "static inline void FUNC_0(Vmxnet3Ring *VAR_0, void *VAR_1)\n{", "vmw_shmem_write(vmxnet3_ring_curr_cell_pa(VAR_0), VAR_1, VAR_0->cell_size);", "}" ]

[ 1, 1, 0 ]

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

[ "static uint16_t FUNC_0(int64_t f){", "int VAR_0= (f + (1<<15))>>16;", "if(VAR_0<-0x7FFF) return 0x8000;", "else if(VAR_0> 0x7FFF) return 0x7FFF;", "else return VAR_0;", "}" ]

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

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

[ "static int FUNC_0(IVI4DecContext *VAR_0, IVIBandDesc *VAR_1,\nAVCodecContext *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;", "int VAR_8;", "int VAR_9;", "VAR_3 = get_bits(&VAR_0->gb, 2);", "VAR_4 = get_bits(&VAR_0->gb, 4);", "if (VAR_1->VAR_3 != VAR_3 || VAR_1->VAR_4 != VAR_4) {", "av_log(VAR_2, AV_LOG_ERROR, \"Invalid VAR_1 header sequence!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_1->is_empty = get_bits1(&VAR_0->gb);", "if (!VAR_1->is_empty) {", "if (get_bits1(&VAR_0->gb))\nskip_bits(&VAR_0->gb, 16);", "VAR_1->is_halfpel = get_bits(&VAR_0->gb, 2);", "if (VAR_1->is_halfpel >= 2) {", "av_log(VAR_2, AV_LOG_ERROR, \"Invalid/unsupported mv resolution: %d!\\n\",\nVAR_1->is_halfpel);", "return AVERROR_INVALIDDATA;", "}", "#if IVI4_STREAM_ANALYSER\nif (!VAR_1->is_halfpel)\nVAR_0->uses_fullpel = 1;", "#endif\nVAR_1->checksum_present = get_bits1(&VAR_0->gb);", "if (VAR_1->checksum_present)\nVAR_1->checksum = get_bits(&VAR_0->gb, 16);", "VAR_5 = get_bits(&VAR_0->gb, 2);", "if (VAR_5 == 3) {", "av_log(VAR_2, AV_LOG_ERROR, \"Invalid block size!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_1->mb_size = 16 >> VAR_5;", "VAR_1->blk_size = 8 >> (VAR_5 >> 1);", "VAR_1->inherit_mv = get_bits1(&VAR_0->gb);", "VAR_1->inherit_qdelta = get_bits1(&VAR_0->gb);", "VAR_1->glob_quant = get_bits(&VAR_0->gb, 5);", "if (!get_bits1(&VAR_0->gb) || VAR_0->frame_type == FRAMETYPE_INTRA) {", "VAR_6 = get_bits(&VAR_0->gb, 5);", "if (VAR_6 >= FF_ARRAY_ELEMS(transforms) ||\n!transforms[VAR_6].inv_trans) {", "av_log_ask_for_sample(VAR_2, \"Unimplemented transform: %d!\\n\", VAR_6);", "return AVERROR_PATCHWELCOME;", "}", "if ((VAR_6 >= 7 && VAR_6 <= 9) ||\nVAR_6 == 17) {", "av_log_ask_for_sample(VAR_2, \"DCT transform not supported yet!\\n\");", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_6 < 10 && VAR_1->blk_size < 8) {", "av_log(VAR_2, AV_LOG_ERROR, \"wrong transform size!\\n\");", "return AVERROR_INVALIDDATA;", "}", "#if IVI4_STREAM_ANALYSER\nif ((VAR_6 >= 0 && VAR_6 <= 2) || VAR_6 == 10)\nVAR_0->uses_haar = 1;", "#endif\nVAR_1->inv_transform = transforms[VAR_6].inv_trans;", "VAR_1->dc_transform = transforms[VAR_6].dc_trans;", "VAR_1->is_2d_trans = transforms[VAR_6].is_2d_trans;", "VAR_1->transform_size= (VAR_6 < 10) ? 8 : 4;", "VAR_7 = get_bits(&VAR_0->gb, 4);", "if ((VAR_7>4 && VAR_7<10) != (VAR_1->blk_size==4)) {", "av_log(VAR_2, AV_LOG_ERROR, \"mismatching scan table!\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_7 == 15) {", "av_log(VAR_2, AV_LOG_ERROR, \"Custom scan pattern encountered!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_1->scan = scan_index_to_tab[VAR_7];", "VAR_9 = get_bits(&VAR_0->gb, 5);", "if (VAR_9 == 31) {", "av_log(VAR_2, AV_LOG_ERROR, \"Custom quant matrix encountered!\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_9 > 21) {", "av_log(VAR_2, AV_LOG_ERROR, \"Invalid quant matrix encountered!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_1->VAR_9 = VAR_9;", "}", "if (ff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_BLK_HUFF,\n&VAR_1->blk_vlc, VAR_2))\nreturn AVERROR_INVALIDDATA;", "VAR_1->rvmap_sel = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 8;", "VAR_1->num_corr = 0;", "if (get_bits1(&VAR_0->gb)) {", "VAR_1->num_corr = get_bits(&VAR_0->gb, 8);", "if (VAR_1->num_corr > 61) {", "av_log(VAR_2, AV_LOG_ERROR, \"Too many corrections: %d\\n\",\nVAR_1->num_corr);", "return AVERROR_INVALIDDATA;", "}", "for (VAR_8 = 0; VAR_8 < VAR_1->num_corr * 2; VAR_8++)", "VAR_1->corr[VAR_8] = get_bits(&VAR_0->gb, 8);", "}", "}", "if (VAR_1->blk_size == 8) {", "VAR_1->intra_base = &ivi4_quant_8x8_intra[quant_index_to_tab[VAR_1->VAR_9]][0];", "VAR_1->inter_base = &ivi4_quant_8x8_inter[quant_index_to_tab[VAR_1->VAR_9]][0];", "} else {", "VAR_1->intra_base = &ivi4_quant_4x4_intra[quant_index_to_tab[VAR_1->VAR_9]][0];", "VAR_1->inter_base = &ivi4_quant_4x4_inter[quant_index_to_tab[VAR_1->VAR_9]][0];", "}", "VAR_1->intra_scale = NULL;", "VAR_1->inter_scale = NULL;", "align_get_bits(&VAR_0->gb);", "if (!VAR_1->scan) {", "av_log(VAR_2, AV_LOG_ERROR, \"VAR_1->scan not set\\n\");", "return AVERROR_INVALIDDATA;", "}", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 37, 39 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55, 57, 59 ], [ 61, 65 ], [ 67, 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 95 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133, 135, 137 ], [ 139, 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 201, 203, 205 ], [ 211 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 265 ], [ 267 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 285 ], [ 287 ] ]

[ "static void FUNC_0(AC3EncodeContext *VAR_0)\n{", "return;", "}" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 9 ], [ 11 ] ]

[ "static int FUNC_0(uint8_t *VAR_0, int VAR_1, int VAR_2,\nconst uint8_t *VAR_3, const uint8_t *VAR_4)\n{", "const uint8_t *VAR_5 = VAR_0;", "const uint8_t *VAR_6 = VAR_0 + VAR_1 * VAR_2;", "int VAR_7 = 0x10000, VAR_8 = 0;", "int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13;", "VAR_13 = bytestream_get_le16(&VAR_3);", "while (VAR_13--) {", "if (VAR_7 == 0x10000) {", "if (VAR_3 >= VAR_4)\nreturn -1;", "VAR_8 = bytestream_get_le16(&VAR_3);", "VAR_7 = 1;", "}", "if (VAR_4 - VAR_3 < 2 || VAR_6 - VAR_0 < 2)\nreturn -1;", "if (VAR_8 & VAR_7) {", "VAR_10 = bytestream_get_le16(&VAR_3);", "VAR_11 = (VAR_10 & 0x1FFF) << 2;", "VAR_12 = ((VAR_10 >> 13) + 2) << 1;", "if (VAR_0 - VAR_5 < VAR_11 || VAR_6 - VAR_0 < VAR_12*2 + VAR_1)\nreturn -1;", "for (VAR_9 = 0; VAR_9 < VAR_12; VAR_9++) {", "VAR_0[0] = VAR_0[1] =\nVAR_0[VAR_1] = VAR_0[VAR_1 + 1] = VAR_0[-VAR_11];", "VAR_0 += 2;", "}", "} else if (VAR_8 & (VAR_7 << 1)) {", "VAR_0 += bytestream_get_le16(&VAR_3) * 2;", "} else {", "VAR_0[0] = VAR_0[1] =\nVAR_0[VAR_1] = VAR_0[VAR_1 + 1] = *VAR_3++;", "VAR_0 += 2;", "VAR_0[0] = VAR_0[1] =\nVAR_0[VAR_1] = VAR_0[VAR_1 + 1] = *VAR_3++;", "VAR_0 += 2;", "}", "VAR_7 <<= 2;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(int VAR_0, int VAR_1)\n{", "TCGv tmp;", "TCGv tmp2;", "int VAR_2;", "switch (VAR_0) {", "case 0:\ntmp = load_cpu_field(ZF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_1);", "break;", "case 1:\ntmp = load_cpu_field(ZF);", "tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, VAR_1);", "break;", "case 2:\ntmp = load_cpu_field(CF);", "tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, VAR_1);", "break;", "case 3:\ntmp = load_cpu_field(CF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_1);", "break;", "case 4:\ntmp = load_cpu_field(NF);", "tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, VAR_1);", "break;", "case 5:\ntmp = load_cpu_field(NF);", "tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, VAR_1);", "break;", "case 6:\ntmp = load_cpu_field(VF);", "tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, VAR_1);", "break;", "case 7:\ntmp = load_cpu_field(VF);", "tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, VAR_1);", "break;", "case 8:\nVAR_2 = gen_new_label();", "tmp = load_cpu_field(CF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_2);", "dead_tmp(tmp);", "tmp = load_cpu_field(ZF);", "tcg_gen_brcondi_i32(TCG_COND_NE, tmp, 0, VAR_1);", "gen_set_label(VAR_2);", "break;", "case 9:\ntmp = load_cpu_field(CF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_1);", "dead_tmp(tmp);", "tmp = load_cpu_field(ZF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_1);", "break;", "case 10:\ntmp = load_cpu_field(VF);", "tmp2 = load_cpu_field(NF);", "tcg_gen_xor_i32(tmp, tmp, tmp2);", "dead_tmp(tmp2);", "tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, VAR_1);", "break;", "case 11:\ntmp = load_cpu_field(VF);", "tmp2 = load_cpu_field(NF);", "tcg_gen_xor_i32(tmp, tmp, tmp2);", "dead_tmp(tmp2);", "tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, VAR_1);", "break;", "case 12:\nVAR_2 = gen_new_label();", "tmp = load_cpu_field(ZF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_2);", "dead_tmp(tmp);", "tmp = load_cpu_field(VF);", "tmp2 = load_cpu_field(NF);", "tcg_gen_xor_i32(tmp, tmp, tmp2);", "dead_tmp(tmp2);", "tcg_gen_brcondi_i32(TCG_COND_GE, tmp, 0, VAR_1);", "gen_set_label(VAR_2);", "break;", "case 13:\ntmp = load_cpu_field(ZF);", "tcg_gen_brcondi_i32(TCG_COND_EQ, tmp, 0, VAR_1);", "dead_tmp(tmp);", "tmp = load_cpu_field(VF);", "tmp2 = load_cpu_field(NF);", "tcg_gen_xor_i32(tmp, tmp, tmp2);", "dead_tmp(tmp2);", "tcg_gen_brcondi_i32(TCG_COND_LT, tmp, 0, VAR_1);", "break;", "default:\nfprintf(stderr, \"Bad condition code 0x%x\\n\", VAR_0);", "abort();", "}", "dead_tmp(tmp);", "}" ]

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

[ "static int FUNC_0(void)\n{", "int VAR_0, VAR_1;", "if (nb_input_files == 1)\nreturn 0;", "for (VAR_0 = 0; VAR_0 < nb_input_files; VAR_0++) {", "InputFile *f = input_files[VAR_0];", "if (f->ctx->pb ? !f->ctx->pb->seekable :\nstrcmp(f->ctx->iformat->name, \"lavfi\"))\nf->non_blocking = 1;", "VAR_1 = av_thread_message_queue_alloc(&f->in_thread_queue,\n8, sizeof(AVPacket));", "if (VAR_1 < 0)\nreturn VAR_1;", "if ((VAR_1 = pthread_create(&f->thread, NULL, input_thread, f)))\nreturn AVERROR(VAR_1);", "}", "return 0;", "}" ]

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

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

[ "static const MXFCodecUL *FUNC_0(enum CodecID type)\n{", "const MXFCodecUL *VAR_0 = ff_mxf_essence_container_uls;", "while (VAR_0->id != CODEC_ID_NONE) {", "if (VAR_0->id == type)\nbreak;", "VAR_0++;", "}", "return VAR_0;", "}" ]

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

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

[ "static int FUNC_0(AVFilterLink *VAR_0)\n{", "MovieContext *movie = VAR_0->src->priv;", "int VAR_1;", "if (movie->is_done)\nreturn AVERROR_EOF;", "do {", "if ((VAR_1 = amovie_get_samples(VAR_0)) < 0)\nreturn VAR_1;", "} while (!movie->samplesref);", "ff_filter_samples(VAR_0, avfilter_ref_buffer(movie->samplesref, ~0));", "avfilter_unref_buffer(movie->samplesref);", "movie->samplesref = NULL;", "return 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 ], [ 33 ], [ 35 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "PCMDecode *s = avctx->priv_data;", "int VAR_0;", "if (avctx->channels <= 0) {", "av_log(avctx, AV_LOG_ERROR, \"PCM channels out of bounds\\n\");", "return AVERROR(EINVAL);", "}", "switch (avctx->codec->id) {", "case AV_CODEC_ID_PCM_ALAW:\nfor (VAR_0 = 0; VAR_0 < 256; VAR_0++)", "s->table[VAR_0] = alaw2linear(VAR_0);", "break;", "case AV_CODEC_ID_PCM_MULAW:\nfor (VAR_0 = 0; VAR_0 < 256; VAR_0++)", "s->table[VAR_0] = ulaw2linear(VAR_0);", "break;", "default:\nbreak;", "}", "avctx->sample_fmt = avctx->codec->sample_fmts[0];", "if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)\navctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec->id);", "avcodec_get_frame_defaults(&s->frame);", "avctx->coded_frame = &s->frame;", "return 0;", "}" ]

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

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

[ "static av_cold int FUNC_0(AVCodecContext * avctx)\n{", "TTAContext *s = avctx->priv_data;", "int VAR_0;", "s->avctx = avctx;", "if (avctx->extradata_size < 22)\nreturn AVERROR_INVALIDDATA;", "init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);", "if (show_bits_long(&s->gb, 32) == AV_RL32(\"TTA1\"))\n{", "if (avctx->err_recognition & AV_EF_CRCCHECK) {", "s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);", "tta_check_crc(s, avctx->extradata, 18);", "}", "skip_bits_long(&s->gb, 32);", "s->format = get_bits(&s->gb, 16);", "if (s->format > 2) {", "av_log(avctx, AV_LOG_ERROR, \"Invalid format\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (s->format == FORMAT_ENCRYPTED) {", "if (!s->pass) {", "av_log(avctx, AV_LOG_ERROR, \"Missing password for encrypted stream. Please use the -password option\\n\");", "return AVERROR(EINVAL);", "}", "AV_WL64(s->crc_pass, tta_check_crc64(s->pass));", "}", "avctx->channels = s->channels = get_bits(&s->gb, 16);", "if (s->channels > 1 && s->channels < 9)\navctx->channel_layout = tta_channel_layouts[s->channels-2];", "avctx->bits_per_raw_sample = get_bits(&s->gb, 16);", "s->bps = (avctx->bits_per_raw_sample + 7) / 8;", "avctx->sample_rate = get_bits_long(&s->gb, 32);", "s->data_length = get_bits_long(&s->gb, 32);", "skip_bits_long(&s->gb, 32);", "if (s->channels == 0) {", "av_log(avctx, AV_LOG_ERROR, \"Invalid number of channels\\n\");", "return AVERROR_INVALIDDATA;", "} else if (avctx->sample_rate == 0) {", "av_log(avctx, AV_LOG_ERROR, \"Invalid samplerate\\n\");", "return AVERROR_INVALIDDATA;", "}", "switch(s->bps) {", "case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;", "case 2:\navctx->sample_fmt = AV_SAMPLE_FMT_S16;", "break;", "case 3:\navctx->sample_fmt = AV_SAMPLE_FMT_S32;", "break;", "default:\nav_log(avctx, AV_LOG_ERROR, \"Invalid/unsupported sample format.\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (avctx->sample_rate > 0x7FFFFFu) {", "av_log(avctx, AV_LOG_ERROR, \"sample_rate too large\\n\");", "return AVERROR(EINVAL);", "}", "s->frame_length = 256 * avctx->sample_rate / 245;", "s->last_frame_length = s->data_length % s->frame_length;", "VAR_0 = s->data_length / s->frame_length +\n(s->last_frame_length ? 1 : 0);", "av_log(avctx, AV_LOG_DEBUG, \"format: %d chans: %d bps: %d rate: %d block: %d\\n\",\ns->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,\navctx->block_align);", "av_log(avctx, AV_LOG_DEBUG, \"data_length: %d frame_length: %d last: %d total: %d\\n\",\ns->data_length, s->frame_length, s->last_frame_length, VAR_0);", "if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){", "av_log(avctx, AV_LOG_ERROR, \"frame_length too large\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (s->bps < 3) {", "s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);", "if (!s->decode_buffer)\nreturn AVERROR(ENOMEM);", "} else", "s->decode_buffer = NULL;", "s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));", "if (!s->ch_ctx) {", "av_freep(&s->decode_buffer);", "return AVERROR(ENOMEM);", "}", "} else {", "av_log(avctx, AV_LOG_ERROR, \"Wrong extradata present\\n\");", "return AVERROR_INVALIDDATA;", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 17, 19 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 41 ], [ 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 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145 ], [ 147, 149 ], [ 153, 155, 157 ], [ 159, 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ] ]

[ "static void FUNC_0(AVCodecContext *VAR_0)\n{", "VDAContext *vda = VAR_0->internal->priv_data;", "av_freep(&vda->bitstream);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "int FUNC_0(struct vhost_dev *VAR_0, void *VAR_1,\nVhostBackendType VAR_2, uint32_t VAR_3)\n{", "uint64_t features;", "int VAR_4, VAR_5;", "VAR_0->migration_blocker = NULL;", "VAR_5 = vhost_set_backend_type(VAR_0, VAR_2);", "assert(VAR_5 >= 0);", "VAR_5 = VAR_0->vhost_ops->vhost_backend_init(VAR_0, VAR_1);", "if (VAR_5 < 0) {", "goto fail;", "}", "if (used_memslots > VAR_0->vhost_ops->vhost_backend_memslots_limit(VAR_0)) {", "fprintf(stderr, \"vhost backend memory slots limit is less\"\n\" than current number of present memory slots\\n\");", "VAR_5 = -1;", "goto fail;", "}", "QLIST_INSERT_HEAD(&vhost_devices, VAR_0, entry);", "VAR_5 = VAR_0->vhost_ops->vhost_set_owner(VAR_0);", "if (VAR_5 < 0) {", "goto fail;", "}", "VAR_5 = VAR_0->vhost_ops->vhost_get_features(VAR_0, &features);", "if (VAR_5 < 0) {", "goto fail;", "}", "for (VAR_4 = 0; VAR_4 < VAR_0->nvqs; ++VAR_4) {", "VAR_5 = vhost_virtqueue_init(VAR_0, VAR_0->vqs + VAR_4, VAR_0->vq_index + VAR_4);", "if (VAR_5 < 0) {", "goto fail_vq;", "}", "}", "if (VAR_3) {", "for (VAR_4 = 0; VAR_4 < VAR_0->nvqs; ++VAR_4) {", "VAR_5 = vhost_virtqueue_set_busyloop_timeout(VAR_0, VAR_0->vq_index + VAR_4,\nVAR_3);", "if (VAR_5 < 0) {", "goto fail_busyloop;", "}", "}", "}", "VAR_0->features = features;", "VAR_0->memory_listener = (MemoryListener) {", ".begin = vhost_begin,\n.commit = vhost_commit,\n.region_add = vhost_region_add,\n.region_del = vhost_region_del,\n.region_nop = vhost_region_nop,\n.log_start = vhost_log_start,\n.log_stop = vhost_log_stop,\n.log_sync = vhost_log_sync,\n.log_global_start = vhost_log_global_start,\n.log_global_stop = vhost_log_global_stop,\n.eventfd_add = vhost_eventfd_add,\n.eventfd_del = vhost_eventfd_del,\n.priority = 10\n};", "if (VAR_0->migration_blocker == NULL) {", "if (!(VAR_0->features & (0x1ULL << VHOST_F_LOG_ALL))) {", "error_setg(&VAR_0->migration_blocker,\n\"Migration disabled: vhost lacks VHOST_F_LOG_ALL feature.\");", "} else if (!qemu_memfd_check()) {", "error_setg(&VAR_0->migration_blocker,\n\"Migration disabled: failed to allocate shared memory\");", "}", "}", "if (VAR_0->migration_blocker != NULL) {", "migrate_add_blocker(VAR_0->migration_blocker);", "}", "VAR_0->mem = g_malloc0(offsetof(struct vhost_memory, regions));", "VAR_0->n_mem_sections = 0;", "VAR_0->mem_sections = NULL;", "VAR_0->log = NULL;", "VAR_0->log_size = 0;", "VAR_0->log_enabled = false;", "VAR_0->started = false;", "VAR_0->memory_changed = false;", "memory_listener_register(&VAR_0->memory_listener, &address_space_memory);", "return 0;", "fail_busyloop:\nwhile (--VAR_4 >= 0) {", "vhost_virtqueue_set_busyloop_timeout(VAR_0, VAR_0->vq_index + VAR_4, 0);", "}", "VAR_4 = VAR_0->nvqs;", "fail_vq:\nwhile (--VAR_4 >= 0) {", "vhost_virtqueue_cleanup(VAR_0->vqs + VAR_4);", "}", "fail:\nVAR_5 = -errno;", "VAR_0->vhost_ops->vhost_backend_cleanup(VAR_0);", "QLIST_REMOVE(VAR_0, entry);", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 107 ], [ 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135 ], [ 139 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 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 ] ]

[ "static void FUNC_0(CmvContext *VAR_0, const uint8_t *VAR_1, const uint8_t *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "if(VAR_1+16>=VAR_2) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"truncated header\\n\");", "return;", "}", "VAR_0->width = AV_RL16(&VAR_1[4]);", "VAR_0->height = AV_RL16(&VAR_1[6]);", "if (VAR_0->avctx->width!=VAR_0->width || VAR_0->avctx->height!=VAR_0->height)\navcodec_set_dimensions(VAR_0->avctx, VAR_0->width, VAR_0->height);", "VAR_0->avctx->time_base.num = 1;", "VAR_0->avctx->time_base.den = AV_RL16(&VAR_1[10]);", "VAR_3 = AV_RL16(&VAR_1[12]);", "VAR_4 = AV_RL16(&VAR_1[14]);", "VAR_1 += 16;", "for (VAR_5=VAR_3; VAR_5<VAR_3+VAR_4 && VAR_5<AVPALETTE_COUNT && VAR_1+2<VAR_2; VAR_5++) {", "VAR_0->palette[VAR_5] = AV_RB24(VAR_1);", "VAR_1 += 3;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ] ]

[ "static int FUNC_0(USBDevice *VAR_0)\n{", "USBSerialState *s = DO_UPCAST(USBSerialState, VAR_0, VAR_0);", "s->VAR_0.speed = USB_SPEED_FULL;", "qemu_chr_add_handlers(s->cs, usb_serial_can_read, usb_serial_read,\nusb_serial_event, s);", "usb_serial_handle_reset(VAR_0);", "return 0;" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5, 6 ], [ 7 ], [ 8 ] ]

[ "static ssize_t FUNC_0(gnutls_session_t *session,\nconst uint8_t *data,\nsize_t datalen)\n{", "ssize_t ret = gnutls_write(*session, data, datalen);", "if (ret < 0) {", "if (ret == GNUTLS_E_AGAIN) {", "errno = EAGAIN;", "} else {", "errno = EIO;", "}", "ret = -1;", "}", "return ret;", "}" ]

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

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

[ "FUNC_0(IvshmemClient *VAR_0)\n{", "IvshmemClientPeer *peer;", "long VAR_1;", "int VAR_2, VAR_3;", "VAR_2 = ivshmem_client_read_one_msg(VAR_0, &VAR_1, &VAR_3);", "if (VAR_2 < 0) {", "peer = ivshmem_client_search_peer(VAR_0, VAR_1);", "if (VAR_3 == -1) {", "if (peer == NULL || peer == &VAR_0->local) {", "IVSHMEM_CLIENT_DEBUG(VAR_0, \"receive delete for invalid \"\n\"peer %ld\\n\", VAR_1);", "IVSHMEM_CLIENT_DEBUG(VAR_0, \"delete peer id = %ld\\n\", VAR_1);", "ivshmem_client_free_peer(VAR_0, peer);", "return 0;", "if (peer == NULL) {", "peer = g_malloc0(sizeof(*peer));", "peer->id = VAR_1;", "peer->vectors_count = 0;", "QTAILQ_INSERT_TAIL(&VAR_0->peer_list, peer, next);", "IVSHMEM_CLIENT_DEBUG(VAR_0, \"new peer id = %ld\\n\", VAR_1);", "IVSHMEM_CLIENT_DEBUG(VAR_0, \" new vector %d (VAR_3=%d) for peer id %ld\\n\",\npeer->vectors_count, VAR_3, peer->id);", "peer->vectors[peer->vectors_count] = VAR_3;", "peer->vectors_count++;", "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 ]

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 9 ], [ 11 ], [ 12 ], [ 13, 14 ], [ 15 ], [ 16 ], [ 17 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 26, 27 ], [ 28 ], [ 29 ], [ 30 ] ]

[ "FUNC_0(SwsContext *VAR_0, const int16_t *VAR_1[2],\nconst int16_t *VAR_2[2], const int16_t *VAR_3[2],\nconst int16_t *VAR_4[2], uint8_t *VAR_5, int VAR_6,\nint VAR_7, int VAR_8, int VAR_9,\nenum PixelFormat VAR_10)\n{", "const int16_t *VAR_11 = VAR_1[0], *buf1 = VAR_1[1],\n*ubuf0 = VAR_2[0], *ubuf1 = VAR_2[1],\n*vbuf0 = VAR_3[0], *vbuf1 = VAR_3[1];", "int VAR_12 = 4095 - VAR_7;", "int VAR_13 = 4095 - VAR_8;", "int VAR_14;", "for (VAR_14 = 0; VAR_14 < (VAR_6 >> 1); VAR_14++) {", "int VAR_15 = (VAR_11[VAR_14 * 2] * VAR_12 + buf1[VAR_14 * 2] * VAR_7) >> 19;", "int VAR_16 = (VAR_11[VAR_14 * 2 + 1] * VAR_12 + buf1[VAR_14 * 2 + 1] * VAR_7) >> 19;", "int VAR_17 = (ubuf0[VAR_14] * VAR_13 + ubuf1[VAR_14] * VAR_8) >> 19;", "int VAR_18 = (vbuf0[VAR_14] * VAR_13 + vbuf1[VAR_14] * VAR_8) >> 19;", "output_pixels(VAR_14 * 4, VAR_15, VAR_17, VAR_16, VAR_18);", "}", "}" ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "MpegDemuxContext *vobsub = VAR_0->priv_data;", "FFDemuxSubtitlesQueue *q;", "AVIOContext *pb = vobsub->sub_ctx->pb;", "int VAR_2, VAR_3, VAR_4 = 0, VAR_5;", "AVPacket idx_pkt;", "int64_t min_ts = INT64_MAX;", "int VAR_6 = 0;", "for (VAR_5 = 0; VAR_5 < VAR_0->nb_streams; VAR_5++) {", "FFDemuxSubtitlesQueue *tmpq = &vobsub->q[VAR_5];", "int64_t ts = tmpq->subs[tmpq->current_sub_idx].pts;", "if (ts < min_ts) {", "min_ts = ts;", "VAR_6 = VAR_5;", "}", "}", "q = &vobsub->q[VAR_6];", "VAR_2 = ff_subtitles_queue_read_packet(q, &idx_pkt);", "if (VAR_2 < 0)\nreturn VAR_2;", "if (q->current_sub_idx < q->nb_subs) {", "VAR_3 = q->subs[q->current_sub_idx].pos - idx_pkt.pos;", "} else {", "int64_t fsize = avio_size(pb);", "VAR_3 = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;", "}", "avio_seek(pb, idx_pkt.pos, SEEK_SET);", "av_init_packet(VAR_1);", "VAR_1->size = 0;", "VAR_1->data = NULL;", "do {", "int VAR_7, VAR_8, VAR_9;", "int64_t pts, dts;", "int64_t old_pos = avio_tell(pb), new_pos;", "int VAR_10;", "VAR_2 = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &VAR_9, &pts, &dts);", "if (VAR_2 < 0) {", "if (VAR_1->size)\nbreak;", "goto fail;", "}", "VAR_8 = VAR_2 & 0xffff;", "new_pos = avio_tell(pb);", "VAR_10 = VAR_2 + (new_pos - old_pos);", "if (VAR_4 + VAR_10 > VAR_3)\nbreak;", "VAR_4 += VAR_10;", "if ((VAR_9 & 0x1f) != idx_pkt.stream_index)\nbreak;", "VAR_2 = av_grow_packet(VAR_1, VAR_8);", "if (VAR_2 < 0)\ngoto fail;", "VAR_7 = avio_read(pb, VAR_1->data + (VAR_1->size - VAR_8), VAR_8);", "if (VAR_7 < VAR_8)\nVAR_1->size -= VAR_8 - VAR_7;", "} while (VAR_4 < VAR_3);", "VAR_1->pts = VAR_1->dts = idx_pkt.pts;", "VAR_1->pos = idx_pkt.pos;", "VAR_1->stream_index = idx_pkt.stream_index;", "av_free_packet(&idx_pkt);", "return 0;", "fail:\nav_free_packet(VAR_1);", "av_free_packet(&idx_pkt);", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 111, 113 ], [ 115 ], [ 121, 123 ], [ 127 ], [ 129, 131 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 159, 161 ], [ 163 ], [ 165 ], [ 167 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1,\nconst uint8_t *VAR_2, int VAR_3)\n{", "int VAR_4, VAR_5;", "uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;", "int VAR_6;", "if (VAR_3 < VAR_0->width * VAR_0->height * 9L / 8) {", "av_log(VAR_0, AV_LOG_ERROR, \"packet too small\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->pix_fmt = AV_PIX_FMT_YUV410P;", "if ((VAR_6 = ff_get_buffer(VAR_0, VAR_1, 0)) < 0)\nreturn VAR_6;", "Y1 = VAR_1->data[0];", "Y2 = VAR_1->data[0] + VAR_1->linesize[0];", "Y3 = VAR_1->data[0] + VAR_1->linesize[0] * 2;", "Y4 = VAR_1->data[0] + VAR_1->linesize[0] * 3;", "U = VAR_1->data[1];", "V = VAR_1->data[2];", "for (VAR_4 = 0; VAR_4 < VAR_0->height; VAR_4 += 4) {", "for (VAR_5 = 0; VAR_5 < VAR_0->width; VAR_5 += 4) {", "AV_COPY32(Y1 + VAR_5, VAR_2);", "AV_COPY32(Y2 + VAR_5, VAR_2 + 4);", "AV_COPY32(Y3 + VAR_5, VAR_2 + 8);", "AV_COPY32(Y4 + VAR_5, VAR_2 + 12);", "U[VAR_5 >> 2] = VAR_2[16] + 0x80;", "V[VAR_5 >> 2] = VAR_2[17] + 0x80;", "VAR_2 += 18;", "}", "Y1 += VAR_1->linesize[0] << 2;", "Y2 += VAR_1->linesize[0] << 2;", "Y3 += VAR_1->linesize[0] << 2;", "Y4 += VAR_1->linesize[0] << 2;", "U += VAR_1->linesize[1];", "V += VAR_1->linesize[2];", "}", "return 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 ]

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

[ "static void FUNC_0(DNXHDContext *VAR_0, DCTELEM *VAR_1, int VAR_2, int VAR_3)\n{", "int VAR_4, VAR_5, VAR_6, VAR_7;", "int VAR_8, VAR_9, VAR_10;", "const uint8_t *VAR_11;", "if (VAR_2&2) {", "VAR_9 = 1 + (VAR_2&1);", "VAR_11 = VAR_0->cid_table->chroma_weigth;", "} else {", "VAR_9 = 0;", "VAR_11 = VAR_0->cid_table->luma_weigth;", "}", "VAR_0->last_dc[VAR_9] += dnxhd_decode_dc(VAR_0);", "VAR_1[0] = VAR_0->last_dc[VAR_9];", "for (VAR_4 = 1; ; VAR_4++) {", "VAR_6 = get_vlc2(&VAR_0->gb, VAR_0->ac_vlc.table, DNXHD_VLC_BITS, 2);", "VAR_8 = VAR_0->cid_table->ac_level[VAR_6];", "if (!VAR_8) {", "return;", "}", "VAR_10 = get_sbits(&VAR_0->gb, 1);", "if (VAR_0->cid_table->ac_index_flag[VAR_6]) {", "VAR_8 += get_bits(&VAR_0->gb, VAR_0->cid_table->index_bits)<<6;", "}", "if (VAR_0->cid_table->ac_run_flag[VAR_6]) {", "VAR_7 = get_vlc2(&VAR_0->gb, VAR_0->run_vlc.table, DNXHD_VLC_BITS, 2);", "VAR_4 += VAR_0->cid_table->run[VAR_7];", "}", "VAR_5 = VAR_0->scantable.permutated[VAR_4];", "VAR_8 = (2*VAR_8+1) * VAR_3 * VAR_11[VAR_4];", "if (VAR_11[VAR_4] != 32)\nVAR_8 += 32;", "VAR_8 >>= 6;", "VAR_8 = (VAR_8^VAR_10) - VAR_10;", "if (VAR_4 > 63) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"ac tex damaged %d, %d\\VAR_2\", VAR_2, VAR_4);", "return;", "}", "VAR_1[VAR_5] = VAR_8;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 103 ], [ 105 ], [ 107 ] ]

[ "const char *FUNC_0(void)\n{", "return FFMPEG_CONFIGURATION;", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "dc->realize = i8042_realizefn;", "dc->no_user = 1;", "dc->vmsd = &vmstate_kbd_isa;", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3, int VAR_4)\n{", "VP8Context *s = VAR_0->priv_data;", "int VAR_5, VAR_6, VAR_7, VAR_8;", "enum AVDiscard VAR_9;", "VP8Frame *av_uninit(curframe), *prev_frame;", "if (VAR_4)\nVAR_5 = vp7_decode_frame_header(s, VAR_3->VAR_1, VAR_3->size);", "else\nVAR_5 = vp8_decode_frame_header(s, VAR_3->VAR_1, VAR_3->size);", "if (VAR_5 < 0)\ngoto err;", "prev_frame = s->framep[VP56_FRAME_CURRENT];", "VAR_7 = s->update_last || s->update_golden == VP56_FRAME_CURRENT ||\ns->update_altref == VP56_FRAME_CURRENT;", "VAR_9 = !VAR_7 ? AVDISCARD_NONREF\n: !s->keyframe ? AVDISCARD_NONKEY\n: AVDISCARD_ALL;", "if (VAR_0->skip_frame >= VAR_9) {", "s->invisible = 1;", "memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);", "goto skip_decode;", "}", "s->deblock_filter = s->filter.level && VAR_0->skip_loop_filter < VAR_9;", "for (VAR_6 = 0; VAR_6 < 5; VAR_6++)", "if (s->frames[VAR_6].tf.f->VAR_1[0] &&\n&s->frames[VAR_6] != prev_frame &&\n&s->frames[VAR_6] != s->framep[VP56_FRAME_PREVIOUS] &&\n&s->frames[VAR_6] != s->framep[VP56_FRAME_GOLDEN] &&\n&s->frames[VAR_6] != s->framep[VP56_FRAME_GOLDEN2])\nvp8_release_frame(s, &s->frames[VAR_6]);", "curframe = s->framep[VP56_FRAME_CURRENT] = vp8_find_free_buffer(s);", "if (!s->colorspace)\nVAR_0->colorspace = AVCOL_SPC_BT470BG;", "if (s->fullrange)\nVAR_0->color_range = AVCOL_RANGE_JPEG;", "else\nVAR_0->color_range = AVCOL_RANGE_MPEG;", "if (!s->keyframe && (!s->framep[VP56_FRAME_PREVIOUS] ||\n!s->framep[VP56_FRAME_GOLDEN] ||\n!s->framep[VP56_FRAME_GOLDEN2])) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"Discarding interframe without a prior keyframe!\\n\");", "VAR_5 = AVERROR_INVALIDDATA;", "goto err;", "}", "curframe->tf.f->key_frame = s->keyframe;", "curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I\n: AV_PICTURE_TYPE_P;", "if ((VAR_5 = vp8_alloc_frame(s, curframe, VAR_7)) < 0)\ngoto err;", "if (s->update_altref != VP56_FRAME_NONE)\ns->next_framep[VP56_FRAME_GOLDEN2] = s->framep[s->update_altref];", "else\ns->next_framep[VP56_FRAME_GOLDEN2] = s->framep[VP56_FRAME_GOLDEN2];", "if (s->update_golden != VP56_FRAME_NONE)\ns->next_framep[VP56_FRAME_GOLDEN] = s->framep[s->update_golden];", "else\ns->next_framep[VP56_FRAME_GOLDEN] = s->framep[VP56_FRAME_GOLDEN];", "if (s->update_last)\ns->next_framep[VP56_FRAME_PREVIOUS] = curframe;", "else\ns->next_framep[VP56_FRAME_PREVIOUS] = s->framep[VP56_FRAME_PREVIOUS];", "s->next_framep[VP56_FRAME_CURRENT] = curframe;", "if (VAR_0->codec->update_thread_context)\nff_thread_finish_setup(VAR_0);", "s->linesize = curframe->tf.f->linesize[0];", "s->uvlinesize = curframe->tf.f->linesize[1];", "memset(s->top_nnz, 0, s->mb_width * sizeof(*s->top_nnz));", "if (!s->mb_layout)\nmemset(s->macroblocks + s->mb_height * 2 - 1, 0,\n(s->mb_width + 1) * sizeof(*s->macroblocks));", "if (!s->mb_layout && s->keyframe)\nmemset(s->intra4x4_pred_mode_top, DC_PRED, s->mb_width * 4);", "memset(s->ref_count, 0, sizeof(s->ref_count));", "if (s->mb_layout == 1) {", "if (prev_frame && s->segmentation.enabled &&\n!s->segmentation.update_map)\nff_thread_await_progress(&prev_frame->tf, 1, 0);", "if (VAR_4)\nvp7_decode_mv_mb_modes(VAR_0, curframe, prev_frame);", "else\nvp8_decode_mv_mb_modes(VAR_0, curframe, prev_frame);", "}", "if (VAR_0->active_thread_type == FF_THREAD_FRAME)\nVAR_8 = 1;", "else\nVAR_8 = FFMIN(s->num_coeff_partitions, VAR_0->thread_count);", "s->VAR_8 = VAR_8;", "s->curframe = curframe;", "s->prev_frame = prev_frame;", "s->mv_min.y = -MARGIN;", "s->mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;", "for (VAR_6 = 0; VAR_6 < MAX_THREADS; VAR_6++) {", "VP8ThreadData *td = &s->thread_data[VAR_6];", "atomic_init(&td->thread_mb_pos, 0);", "atomic_init(&td->wait_mb_pos, INT_MAX);", "}", "if (VAR_4)\nVAR_0->execute2(VAR_0, vp7_decode_mb_row_sliced, s->thread_data, NULL,\nVAR_8);", "else\nVAR_0->execute2(VAR_0, vp8_decode_mb_row_sliced, s->thread_data, NULL,\nVAR_8);", "ff_thread_report_progress(&curframe->tf, INT_MAX, 0);", "memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);", "skip_decode:\nif (!s->update_probabilities)\ns->prob[0] = s->prob[1];", "if (!s->invisible) {", "if ((VAR_5 = av_frame_ref(VAR_1, curframe->tf.f)) < 0)\nreturn VAR_5;", "*VAR_2 = 1;", "}", "return VAR_3->size;", "err:\nmemcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);", "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, 1, 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 ], [ 27, 29 ], [ 33 ], [ 37, 39 ], [ 43, 45, 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 67 ], [ 69, 71, 73, 75, 77, 79 ], [ 83 ], [ 87, 89 ], [ 91, 93 ], [ 95, 97 ], [ 109, 111, 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129, 131 ], [ 133, 135 ], [ 141, 143 ], [ 145, 147 ], [ 151, 153 ], [ 155, 157 ], [ 161, 163 ], [ 165, 167 ], [ 171 ], [ 175, 177 ], [ 181 ], [ 183 ], [ 187 ], [ 193, 195, 197 ], [ 199, 201 ], [ 205 ], [ 209 ], [ 215, 217, 219 ], [ 221, 223 ], [ 225, 227 ], [ 229 ], [ 233, 235 ], [ 237, 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261, 263, 265 ], [ 267, 269, 271 ], [ 275 ], [ 277 ], [ 281, 287, 289 ], [ 293 ], [ 295, 297 ], [ 299 ], [ 301 ], [ 305 ], [ 307, 309 ], [ 311 ], [ 313 ] ]

[ "void FUNC_0(uint8_t *VAR_0, int VAR_1, DCTELEM *VAR_2)\n{", "int VAR_3;", "DCTELEM temp[64];", "for (VAR_3 = 0; VAR_3 < 8; VAR_3++)", "bink_idct_col(&temp[VAR_3], &VAR_2[VAR_3]);", "for (VAR_3 = 0; VAR_3 < 8; VAR_3++) {", "IDCT_ROW( (&VAR_0[VAR_3*VAR_1]), (&temp[8*VAR_3]) );", "}", "}" ]

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

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

[ "static void FUNC_0(RDMAContext *VAR_0, uint64_t VAR_1,\nuint64_t VAR_2, uint64_t VAR_3)\n{", "if (VAR_0->unregistrations[VAR_0->unregister_next] != 0) {", "fprintf(stderr, \"VAR_0 migration: queue is full!\\n\");", "} else {", "RDMALocalBlock *block = &(VAR_0->local_ram_blocks.block[VAR_1]);", "if (!test_and_set_bit(VAR_2, block->unregister_bitmap)) {", "DDPRINTF(\"Appending unregister VAR_2 %\" PRIu64\n\" at position %d\\n\", VAR_2, VAR_0->unregister_next);", "VAR_0->unregistrations[VAR_0->unregister_next++] =\nqemu_rdma_make_wrid(VAR_3, VAR_1, VAR_2);", "if (VAR_0->unregister_next == RDMA_SIGNALED_SEND_MAX) {", "VAR_0->unregister_next = 0;", "}", "} else {", "DDPRINTF(\"Unregister VAR_2 %\" PRIu64 \" already in queue.\\n\",\nVAR_2);", "}", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "int VAR_1 = 0;", "V9fsString name;", "int32_t dfid, flags;", "size_t offset = 7;", "V9fsPath path;", "V9fsFidState *dfidp;", "V9fsPDU *pdu = VAR_0;", "v9fs_string_init(&name);", "VAR_1 = pdu_unmarshal(pdu, offset, \"dsd\", &dfid, &name, &flags);", "if (VAR_1 < 0) {", "dfidp = get_fid(pdu, dfid);", "if (dfidp == NULL) {", "VAR_1 = -EINVAL;", "v9fs_path_init(&path);", "VAR_1 = v9fs_co_name_to_path(pdu, &dfidp->path, name.data, &path);", "if (VAR_1 < 0) {", "goto out_err;", "VAR_1 = v9fs_mark_fids_unreclaim(pdu, &path);", "if (VAR_1 < 0) {", "goto out_err;", "VAR_1 = v9fs_co_unlinkat(pdu, &dfidp->path, &name, flags);", "if (!VAR_1) {", "VAR_1 = offset;", "out_err:\nput_fid(pdu, dfidp);", "v9fs_path_free(&path);", "out_nofid:\npdu_complete(pdu, VAR_1);", "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 ]

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30, 31 ], [ 32 ], [ 33, 34 ], [ 35 ] ]

[ "static int FUNC_0(DeviceState *VAR_0, Property *VAR_1, const char *VAR_2)\n{", "uint32_t *ptr = qdev_get_prop_ptr(VAR_0, VAR_1);", "unsigned int VAR_3, VAR_4, VAR_5;", "if (sscanf(VAR_2, \"%x.%x%VAR_5\", &VAR_3, &VAR_4, &VAR_5) != 2) {", "VAR_4 = 0;", "if (sscanf(VAR_2, \"%x%VAR_5\", &VAR_3, &VAR_5) != 1) {", "return -EINVAL;", "}", "}", "if (VAR_2[VAR_5] != '\\0')\nreturn -EINVAL;", "if (VAR_4 > 7)\nreturn -EINVAL;", "if (VAR_3 > 31)\nreturn -EINVAL;", "*ptr = VAR_3 << 3 | VAR_4;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "NSVContext *nsv = VAR_0->priv_data;", "int VAR_1, VAR_2;", "av_dlog(VAR_0, \"%VAR_0()\\n\", __FUNCTION__);", "av_dlog(VAR_0, \"filename '%VAR_0'\\n\", VAR_0->filename);", "nsv->state = NSV_UNSYNC;", "nsv->ahead[0].data = nsv->ahead[1].data = NULL;", "for (VAR_1 = 0; VAR_1 < NSV_MAX_RESYNC_TRIES; VAR_1++) {", "if (nsv_resync(VAR_0) < 0)\nreturn -1;", "if (nsv->state == NSV_FOUND_NSVF)\nVAR_2 = nsv_parse_NSVf_header(VAR_0);", "if (nsv->state == NSV_FOUND_NSVS) {", "VAR_2 = nsv_parse_NSVs_header(VAR_0);", "break;", "}", "}", "if (VAR_0->nb_streams < 1)\nreturn -1;", "VAR_2 = nsv_read_chunk(VAR_0, 1);", "av_dlog(VAR_0, \"parsed header\\n\");", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 23 ], [ 25, 27 ], [ 29, 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ] ]

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "IDEState *s = VAR_0;", "block_acct_done(blk_get_stats(s->blk), &s->acct);", "#ifdef DEBUG_IDE_ATAPI\nprintf(\"FUNC_0: lba=%d VAR_1=%d\\n\", s->lba, VAR_1);", "#endif\nif (VAR_1 < 0) {", "ide_atapi_io_error(s, VAR_1);", "return;", "}", "if (s->cd_sector_size == 2352) {", "cd_data_to_raw(s->io_buffer, s->lba);", "}", "s->lba++;", "s->io_buffer_index = 0;", "s->status &= ~BUSY_STAT;", "ide_atapi_cmd_reply_end(s);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 13, 15 ], [ 17, 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ] ]

[ "static void FUNC_0(QIOTask *VAR_0,\ngpointer VAR_1)\n{", "VncState *vs = VAR_1;", "Error *err = NULL;", "if (qio_task_propagate_error(VAR_0, &err)) {", "VNC_DEBUG(\"Handshake failed %s\\n\",\nerror_get_pretty(err));", "vnc_client_error(vs);", "error_free(err);", "} else {", "vs->ioc_tag = qio_channel_add_watch(\nvs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL);", "start_auth_vencrypt_subauth(vs);", "}", "}" ]

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

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

[ "static int FUNC_0(FLACParseContext* VAR_0, const uint8_t **VAR_1,\nint *VAR_2)\n{", "FLACHeaderMarker *header = VAR_0->best_header;", "FLACHeaderMarker *child = header->best_child;", "if (!child) {", "*VAR_2 = av_fifo_size(VAR_0->fifo_buf) - header->offset;", "} else {", "*VAR_2 = child->offset - header->offset;", "check_header_mismatch(VAR_0, header, child, 0);", "}", "if (header->fi.channels != VAR_0->avctx->channels ||\n(!VAR_0->avctx->channel_layout && header->fi.channels <= 6)) {", "VAR_0->avctx->channels = header->fi.channels;", "ff_flac_set_channel_layout(VAR_0->avctx);", "}", "VAR_0->avctx->sample_rate = header->fi.samplerate;", "VAR_0->pc->duration = header->fi.blocksize;", "*VAR_1 = flac_fifo_read_wrap(VAR_0, header->offset, *VAR_2,\n&VAR_0->wrap_buf,\n&VAR_0->wrap_buf_allocated_size);", "VAR_0->best_header_valid = 0;", "if (child)\nreturn child->offset - av_fifo_size(VAR_0->fifo_buf);", "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 ], [ 23 ], [ 25 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43, 45, 47 ], [ 51 ], [ 57, 59 ], [ 61 ], [ 63 ] ]

[ "static int FUNC_0(int *VAR_0, int VAR_1)\n{", "int VAR_2 = 0;", "int VAR_3 = pkt.size;", "*VAR_0 = 0;", "if (pkt.stream_index == video_stream_idx) {", "VAR_2 = avcodec_decode_video2(video_dec_ctx, frame, VAR_0, &pkt);", "if (VAR_2 < 0) {", "fprintf(stderr, \"Error decoding video frame (%s)\\n\", av_err2str(VAR_2));", "return VAR_2;", "}", "if (video_dec_ctx->width != width || video_dec_ctx->height != height ||\nvideo_dec_ctx->pix_fmt != pix_fmt) {", "fprintf(stderr, \"Error: Width, height and pixel format have to be \"\n\"constant in a rawvideo file, but the width, height or \"\n\"pixel format of the input video changed:\\n\"\n\"old: width = %d, height = %d, format = %s\\n\"\n\"new: width = %d, height = %d, format = %s\\n\",\nwidth, height, av_get_pix_fmt_name(pix_fmt),\nvideo_dec_ctx->width, video_dec_ctx->height,\nav_get_pix_fmt_name(video_dec_ctx->pix_fmt));", "return -1;", "}", "if (*VAR_0) {", "printf(\"video_frame%s n:%d coded_n:%d pts:%s\\n\",\nVAR_1 ? \"(VAR_1)\" : \"\",\nvideo_frame_count++, frame->coded_picture_number,\nav_ts2timestr(frame->pts, &video_dec_ctx->time_base));", "av_image_copy(video_dst_data, video_dst_linesize,\n(const uint8_t **)(frame->data), frame->linesize,\npix_fmt, width, height);", "fwrite(video_dst_data[0], 1, video_dst_bufsize, video_dst_file);", "}", "} else if (pkt.stream_index == audio_stream_idx) {", "VAR_2 = avcodec_decode_audio4(audio_dec_ctx, frame, VAR_0, &pkt);", "if (VAR_2 < 0) {", "fprintf(stderr, \"Error decoding audio frame (%s)\\n\", av_err2str(VAR_2));", "return VAR_2;", "}", "VAR_3 = FFMIN(VAR_2, pkt.size);", "if (*VAR_0) {", "size_t unpadded_linesize = frame->nb_samples * av_get_bytes_per_sample(frame->format);", "printf(\"audio_frame%s n:%d nb_samples:%d pts:%s\\n\",\nVAR_1 ? \"(VAR_1)\" : \"\",\naudio_frame_count++, frame->nb_samples,\nav_ts2timestr(frame->pts, &audio_dec_ctx->time_base));", "fwrite(frame->extended_data[0], 1, unpadded_linesize, audio_dst_file);", "}", "}", "if (*VAR_0 && api_mode == API_MODE_NEW_API_REF_COUNT)\nav_frame_unref(frame);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 37, 39, 41, 43, 45, 47, 49, 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61, 63, 65, 67 ], [ 75, 77, 79 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 111 ], [ 115 ], [ 117 ], [ 119, 121, 123, 125 ], [ 145 ], [ 147 ], [ 149 ], [ 157, 159 ], [ 163 ], [ 165 ] ]

[ "void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{", "avg_width16_msa(VAR_1, VAR_2, VAR_0, VAR_2, 16);", "}" ]

[ 0, 0, 0 ]

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

[ "static inline int FUNC_0(MDCT15Context *VAR_0)\n{", "int VAR_1, VAR_2;", "const int VAR_3 = VAR_0->ptwo_fft.nbits;", "const int VAR_4 = 1 << VAR_3;", "const int VAR_5 = VAR_4 << ((4 - VAR_3) & 3);", "const int VAR_6 = 0xeeeeeeef & ((1U << VAR_3) - 1);", "VAR_0->pfa_prereindex = av_malloc(15 * VAR_4 * sizeof(*VAR_0->pfa_prereindex));", "if (!VAR_0->pfa_prereindex)\nreturn 1;", "VAR_0->pfa_postreindex = av_malloc(15 * VAR_4 * sizeof(*VAR_0->pfa_postreindex));", "if (!VAR_0->pfa_postreindex)\nreturn 1;", "for (VAR_1 = 0; VAR_1 < VAR_4; VAR_1++) {", "for (VAR_2 = 0; VAR_2 < 15; VAR_2++) {", "const int VAR_7 = ((VAR_4 * VAR_2)/15 + VAR_1) >> VAR_3;", "const int VAR_8 = (((VAR_2*VAR_5)/15) + (VAR_1*VAR_6)) >> VAR_3;", "const int VAR_9 = 15*VAR_1 + ((VAR_2 - VAR_7*15) << VAR_3);", "const int VAR_10 = VAR_1*VAR_6*15 + VAR_2*VAR_5 - 15*VAR_8*VAR_4;", "VAR_0->pfa_prereindex[VAR_1*15 + VAR_2] = VAR_9;", "VAR_0->pfa_postreindex[VAR_10] = VAR_4*VAR_2 + VAR_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 ]

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

[ "static void FUNC_0(AVFormatContext *VAR_0)\n{", "MXFContext *mxf = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "const char *VAR_1 = \"Libav\";", "const char *VAR_2 = \"OP1a Muxer\";", "const char *VAR_3;", "int VAR_4;", "mxf_write_metadata_key(pb, 0x013000);", "PRINT_KEY(VAR_0, \"identification key\", pb->buf_ptr - 16);", "VAR_3 = VAR_0->streams[0]->codec->flags & CODEC_FLAG_BITEXACT ?\n\"0.0.0\" : AV_STRINGIFY(LIBAVFORMAT_VERSION);", "VAR_4 = 84 + (strlen(VAR_1)+strlen(VAR_2)+strlen(VAR_3))*2;", "klv_encode_ber_length(pb, VAR_4);", "mxf_write_local_tag(pb, 16, 0x3C0A);", "mxf_write_uuid(pb, Identification, 0);", "PRINT_KEY(VAR_0, \"identification uid\", pb->buf_ptr - 16);", "mxf_write_local_tag(pb, 16, 0x3C09);", "mxf_write_uuid(pb, Identification, 1);", "mxf_write_local_tag_utf16(pb, 0x3C01, VAR_1);", "mxf_write_local_tag_utf16(pb, 0x3C02, VAR_2);", "mxf_write_local_tag_utf16(pb, 0x3C04, VAR_3);", "mxf_write_local_tag(pb, 16, 0x3C05);", "mxf_write_uuid(pb, Identification, 2);", "mxf_write_local_tag(pb, 8, 0x3C06);", "avio_wb64(pb, mxf->timestamp);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 37 ], [ 39 ], [ 41 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 71 ], [ 73 ], [ 75 ] ]

[ "static void FUNC_0(TestOutputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "test_native_list(VAR_0, VAR_1, USER_DEF_NATIVE_LIST_UNION_KIND_U32);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(AHCIQState *VAR_0)\n{", "RegD2HFIS *d2h = g_malloc0(0x20);", "RegD2HFIS *pio = g_malloc0(0x20);", "RegH2DFIS fis;", "AHCICommandHeader cmd;", "PRD prd;", "uint32_t reg, data_ptr;", "uint16_t buff[256];", "unsigned VAR_1;", "int VAR_2;", "uint8_t cx;", "uint64_t table;", "g_assert(VAR_0 != NULL);", "VAR_1 = ahci_port_select(VAR_0);", "g_test_message(\"Selected port %u for test\", VAR_1);", "ahci_port_clear(VAR_0, VAR_1);", "table = ahci_alloc(VAR_0, CMD_TBL_SIZ(1));", "g_assert(table);", "ASSERT_BIT_CLEAR(table, 0x7F);", "data_ptr = ahci_alloc(VAR_0, 512);", "g_assert(data_ptr);", "cx = ahci_pick_cmd(VAR_0, VAR_1);", "memset(&cmd, 0x00, sizeof(cmd));", "cmd.flags = 5;", "cmd.flags |= 0x400;", "cmd.prdtl = 1;", "cmd.prdbc = 0;", "cmd.ctba = table;", "prd.dba = cpu_to_le64(data_ptr);", "prd.res = 0;", "prd.dbc = cpu_to_le32(511 | 0x80000000);", "memset(&fis, 0x00, sizeof(fis));", "fis.fis_type = 0x27;", "fis.command = 0xEC;", "fis.device = 0;", "fis.flags = 0x80;", "g_assert_cmphex(ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_IS), ==, 0);", "memwrite(table, &fis, sizeof(fis));", "memwrite(table + 0x80, &prd, sizeof(prd));", "ahci_set_command_header(VAR_0, VAR_1, cx, &cmd);", "g_assert_cmphex(ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_IS), ==, 0);", "ahci_px_wreg(VAR_0, VAR_1, AHCI_PX_CI, (1 << cx));", "while (BITSET(ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_TFD), AHCI_PX_TFD_STS_BSY)) {", "usleep(50);", "}", "reg = ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_IS);", "ASSERT_BIT_SET(reg, AHCI_PX_IS_DHRS);", "ASSERT_BIT_SET(reg, AHCI_PX_IS_PSS);", "ASSERT_BIT_CLEAR(reg, AHCI_PX_IS_DPS);", "ahci_px_wreg(VAR_0, VAR_1, AHCI_PX_IS,\nAHCI_PX_IS_DHRS | AHCI_PX_IS_PSS | AHCI_PX_IS_DPS);", "g_assert_cmphex(ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_IS), ==, 0);", "reg = ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_SERR);", "g_assert_cmphex(reg, ==, 0);", "reg = ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_TFD);", "ASSERT_BIT_CLEAR(reg, AHCI_PX_TFD_STS_ERR);", "ASSERT_BIT_CLEAR(reg, AHCI_PX_TFD_ERR);", "ahci_get_command_header(VAR_0, VAR_1, cx, &cmd);", "g_assert_cmphex(512, ==, cmd.prdbc);", "memread(VAR_0->port[VAR_1].fb + 0x20, pio, 0x20);", "memread(VAR_0->port[VAR_1].fb + 0x40, d2h, 0x20);", "g_assert_cmphex(pio->fis_type, ==, 0x5f);", "g_assert_cmphex(d2h->fis_type, ==, 0x34);", "g_assert_cmphex(pio->flags, ==, d2h->flags);", "g_assert_cmphex(pio->status, ==, d2h->status);", "g_assert_cmphex(pio->error, ==, d2h->error);", "reg = ahci_px_rreg(VAR_0, VAR_1, AHCI_PX_TFD);", "g_assert_cmphex((reg & AHCI_PX_TFD_ERR), ==, pio->error);", "g_assert_cmphex((reg & AHCI_PX_TFD_STS), ==, pio->status);", "g_assert_cmphex(le16_to_cpu(pio->res4), ==, cmd.prdbc);", "memread(data_ptr, &buff, 512);", "string_bswap16(&buff[10], 20);", "VAR_2 = memcmp(&buff[10], \"testdisk \", 20);", "g_assert_cmphex(VAR_2, ==, 0);", "string_bswap16(&buff[23], 8);", "VAR_2 = memcmp(&buff[23], \"version \", 8);", "g_assert_cmphex(VAR_2, ==, 0);", "g_free(d2h);", "g_free(pio);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 63 ], [ 65 ], [ 71 ], [ 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91 ], [ 97 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 119 ], [ 121 ], [ 125 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 145 ], [ 151 ], [ 157 ], [ 163 ], [ 171 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 203, 205 ], [ 207 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 227 ], [ 229 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 263 ], [ 269 ], [ 283 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 295 ], [ 299 ], [ 301 ], [ 303 ] ]

[ "void FUNC_0(const char *VAR_0)\n{", "AVStream *st;", "AVFormatContext *oc;", "int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5;", "int VAR_6;", "if (!strcmp(VAR_0, \"-\"))\nVAR_0 = \"pipe:\";", "oc = av_mallocz(sizeof(AVFormatContext));", "if (!file_format) {", "file_format = guess_format(NULL, VAR_0, NULL);", "if (!file_format)\nfile_format = &mpeg_mux_format;", "}", "oc->format = file_format;", "if (!strcmp(file_format->name, \"ffm\") &&\nstrstart(VAR_0, \"http:\", NULL)) {", "if (read_ffserver_streams(oc, VAR_0) < 0) {", "fprintf(stderr, \"Could not read stream parameters from '%s'\\n\", VAR_0);", "exit(1);", "}", "} else {", "VAR_1 = file_format->video_codec != CODEC_ID_NONE;", "VAR_2 = file_format->audio_codec != CODEC_ID_NONE;", "check_audio_video_inputs(&VAR_4, &VAR_5);", "if (!VAR_4)\nVAR_1 = 0;", "if (!VAR_5)\nVAR_2 = 0;", "if (audio_disable) {", "VAR_2 = 0;", "}", "if (video_disable) {", "VAR_1 = 0;", "}", "VAR_3 = 0;", "if (VAR_1) {", "AVCodecContext *video_enc;", "st = av_mallocz(sizeof(AVStream));", "if (!st) {", "fprintf(stderr, \"Could not alloc stream\\n\");", "exit(1);", "}", "video_enc = &st->codec;", "VAR_6 = file_format->video_codec;", "if (video_codec_id != CODEC_ID_NONE)\nVAR_6 = video_codec_id;", "video_enc->VAR_6 = VAR_6;", "video_enc->codec_type = CODEC_TYPE_VIDEO;", "video_enc->bit_rate = video_bit_rate;", "video_enc->frame_rate = frame_rate;", "video_enc->width = frame_width;", "video_enc->height = frame_height;", "if (!intra_only)\nvideo_enc->gop_size = gop_size;", "else\nvideo_enc->gop_size = 0;", "if (video_qscale || same_quality) {", "video_enc->flags |= CODEC_FLAG_QSCALE;", "video_enc->quality = video_qscale;", "}", "if (oc->format == &ppm_format ||\noc->format == &ppmpipe_format) {", "video_enc->pix_fmt = PIX_FMT_RGB24;", "}", "oc->streams[VAR_3] = st;", "VAR_3++;", "}", "if (VAR_2) {", "AVCodecContext *audio_enc;", "st = av_mallocz(sizeof(AVStream));", "if (!st) {", "fprintf(stderr, \"Could not alloc stream\\n\");", "exit(1);", "}", "audio_enc = &st->codec;", "VAR_6 = file_format->audio_codec;", "if (audio_codec_id != CODEC_ID_NONE)\nVAR_6 = audio_codec_id;", "audio_enc->VAR_6 = VAR_6;", "audio_enc->codec_type = CODEC_TYPE_AUDIO;", "audio_enc->bit_rate = audio_bit_rate;", "audio_enc->sample_rate = audio_sample_rate;", "audio_enc->channels = audio_channels;", "oc->streams[VAR_3] = st;", "VAR_3++;", "}", "oc->VAR_3 = VAR_3;", "if (!VAR_3) {", "fprintf(stderr, \"No audio or video streams available\\n\");", "exit(1);", "}", "if (str_title)\nnstrcpy(oc->title, sizeof(oc->title), str_title);", "if (str_author)\nnstrcpy(oc->author, sizeof(oc->author), str_author);", "if (str_copyright)\nnstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);", "if (str_comment)\nnstrcpy(oc->comment, sizeof(oc->comment), str_comment);", "}", "output_files[nb_output_files] = oc;", "dump_format(oc, nb_output_files, VAR_0, 1);", "nb_output_files++;", "strcpy(oc->VAR_0, VAR_0);", "if (oc->format->flags & AVFMT_NEEDNUMBER) {", "if (filename_number_test(oc->VAR_0) < 0)\nexit(1);", "}", "if (!(oc->format->flags & AVFMT_NOFILE)) {", "if (!file_overwrite &&\n(strchr(VAR_0, ':') == NULL ||\nstrstart(VAR_0, \"file:\", NULL))) {", "if (url_exist(VAR_0)) {", "int VAR_7;", "printf(\"File '%s' already exists. Overwrite ? [y/N] \", VAR_0);", "fflush(stdout);", "VAR_7 = getchar();", "if (toupper(VAR_7) != 'Y') {", "fprintf(stderr, \"Not overwriting - exiting\\n\");", "exit(1);", "}", "}", "}", "if (url_fopen(&oc->pb, VAR_0, URL_WRONLY) < 0) {", "fprintf(stderr, \"Could not open '%s'\\n\", VAR_0);", "exit(1);", "}", "}", "file_format = NULL;", "audio_disable = 0;", "video_disable = 0;", "audio_codec_id = CODEC_ID_NONE;", "video_codec_id = CODEC_ID_NONE;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 37 ], [ 41, 43 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 67 ], [ 69, 71 ], [ 73, 75 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119, 121 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141, 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159, 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197, 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 221 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 235, 237 ], [ 239, 241 ], [ 243, 245 ], [ 247, 249 ], [ 251 ], [ 255 ], [ 259 ], [ 261 ], [ 265 ], [ 271 ], [ 273, 275 ], [ 277 ], [ 281 ], [ 285, 287, 289 ], [ 291 ], [ 293 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ] ]

[ "int FUNC_0(void)\n{", "int VAR_0, VAR_1;", "unsigned long VAR_2;", "XenIOState *state;", "state = g_malloc0(sizeof (XenIOState));", "state->xce_handle = xen_xc_evtchn_open(NULL, 0);", "if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {", "perror(\"xen: event channel open\");", "return -errno;", "}", "state->xenstore = xs_daemon_open();", "if (state->xenstore == NULL) {", "perror(\"xen: xenstore open\");", "return -errno;", "}", "state->exit.notify = xen_exit_notifier;", "qemu_add_exit_notifier(&state->exit);", "state->suspend.notify = xen_suspend_notifier;", "qemu_register_suspend_notifier(&state->suspend);", "xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &VAR_2);", "DPRINTF(\"shared page at pfn %lx\\n\", VAR_2);", "state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,\nPROT_READ|PROT_WRITE, VAR_2);", "if (state->shared_page == NULL) {", "hw_error(\"map shared IO page returned error %d handle=\" XC_INTERFACE_FMT,\nerrno, xen_xc);", "}", "xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &VAR_2);", "DPRINTF(\"buffered io page at pfn %lx\\n\", VAR_2);", "state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,\nPROT_READ|PROT_WRITE, VAR_2);", "if (state->buffered_io_page == NULL) {", "hw_error(\"map buffered IO page returned error %d\", errno);", "}", "state->ioreq_local_port = g_malloc0(smp_cpus * sizeof (evtchn_port_t));", "for (VAR_0 = 0; VAR_0 < smp_cpus; VAR_0++) {", "VAR_1 = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,\nxen_vcpu_eport(state->shared_page, VAR_0));", "if (VAR_1 == -1) {", "fprintf(stderr, \"bind interdomain ioctl error %d\\n\", errno);", "return -1;", "}", "state->ioreq_local_port[VAR_0] = VAR_1;", "}", "xen_map_cache_init();", "xen_ram_init(ram_size);", "qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);", "state->memory_listener = xen_memory_listener;", "QLIST_INIT(&state->physmap);", "memory_listener_register(&state->memory_listener);", "state->log_for_dirtybit = NULL;", "if (xen_be_init() != 0) {", "fprintf(stderr, \"%s: xen backend core setup failed\\n\", __FUNCTION__);", "exit(1);", "}", "xen_be_register(\"console\", &xen_console_ops);", "xen_be_register(\"vkbd\", &xen_kbdmouse_ops);", "xen_be_register(\"qdisk\", &xen_blkdev_ops);", "xen_read_physmap(state);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 115 ], [ 117 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 157 ] ]

[ "static void FUNC_0(void *VAR_0, const uint8_t * VAR_1, size_t VAR_2)\n{", "EEPRO100State *s = VAR_0;", "uint16_t rfd_status = 0xa000;", "static const uint8_t VAR_3[6] =\n{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };", "assert(!(s->configuration[20] & BIT(6)));", "if (s->configuration[8] & 0x80) {", "logout(\"%p received while CSMA is disabled\\n\", s);", "return;", "} else if (VAR_2 < 64 && (s->configuration[7] & 1)) {", "logout(\"%p received short frame (%d byte)\\n\", s, VAR_2);", "s->statistics.rx_short_frame_errors++;", "} else if ((VAR_2 > MAX_ETH_FRAME_SIZE + 4) && !(s->configuration[18] & 8)) {", "logout(\"%p received long frame (%d byte), ignored\\n\", s, VAR_2);", "return;", "} else if (memcmp(VAR_1, s->macaddr, 6) == 0) {", "logout(\"%p received frame for me, len=%d\\n\", s, VAR_2);", "} else if (memcmp(VAR_1, VAR_3, 6) == 0) {", "logout(\"%p received broadcast, len=%d\\n\", s, VAR_2);", "rfd_status |= 0x0002;", "} else if (VAR_1[0] & 0x01) {", "logout(\"%p received multicast, len=%d\\n\", s, VAR_2);", "assert(!(s->configuration[21] & BIT(3)));", "int VAR_4 = compute_mcast_idx(VAR_1);", "if (!(s->mult[VAR_4 >> 3] & (1 << (VAR_4 & 7)))) {", "return;", "}", "rfd_status |= 0x0002;", "} else if (s->configuration[15] & 1) {", "logout(\"%p received frame in promiscuous mode, len=%d\\n\", s, VAR_2);", "rfd_status |= 0x0004;", "} else {", "logout(\"%p received frame, ignored, len=%d,%s\\n\", s, VAR_2,\nnic_dump(VAR_1, VAR_2));", "return;", "}", "if (get_ru_state(s) != ru_ready) {", "logout(\"no ressources, state=%u\\n\", get_ru_state(s));", "s->statistics.rx_resource_errors++;", "return;", "}", "eepro100_rx_t rx;", "cpu_physical_memory_read(s->ru_base + s->ru_offset, (uint8_t *) & rx,\noffsetof(eepro100_rx_t, packet));", "uint16_t rfd_command = le16_to_cpu(rx.command);", "uint16_t rfd_size = le16_to_cpu(rx.VAR_2);", "assert(VAR_2 <= rfd_size);", "if (VAR_2 < 64) {", "rfd_status |= 0x0080;", "}", "logout(\"command 0x%04x, link 0x%08x, addr 0x%08x, VAR_2 %u\\n\", rfd_command,\nrx.link, rx.rx_buf_addr, rfd_size);", "stw_phys(s->ru_base + s->ru_offset + offsetof(eepro100_rx_t, status),\nrfd_status);", "stw_phys(s->ru_base + s->ru_offset + offsetof(eepro100_rx_t, count), VAR_2);", "assert(!(s->configuration[18] & 4));", "cpu_physical_memory_write(s->ru_base + s->ru_offset +\noffsetof(eepro100_rx_t, packet), VAR_1, VAR_2);", "s->statistics.rx_good_frames++;", "eepro100_fr_interrupt(s);", "s->ru_offset = le32_to_cpu(rx.link);", "if (rfd_command & 0x8000) {", "assert(0);", "}", "if (rfd_command & 0x4000) {", "set_ru_state(s, ru_suspended);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 13 ], [ 15 ], [ 17, 19 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 43 ], [ 45 ], [ 49 ], [ 55 ], [ 57 ], [ 59 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155, 157 ], [ 159 ], [ 167 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ] ]

[ "static inline void FUNC_0(TCGContext *VAR_0, TCGCond VAR_1, TCGReg VAR_2,\nTCGReg VAR_3, int VAR_4, int VAR_5)\n{", "TCGLabel *l = &VAR_0->labels[VAR_4];", "uint64_t imm;", "if (l->has_value) {", "imm = l->u.value_ptr - VAR_0->code_ptr;", "} else {", "imm = get_reloc_pcrel21b_slot2(VAR_0->code_ptr);", "tcg_out_reloc(VAR_0, VAR_0->code_ptr, R_IA64_PCREL21B, VAR_4, 0);", "}", "tcg_out_bundle(VAR_0, miB,\nINSN_NOP_M,\ntcg_opc_cmp_a(TCG_REG_P0, VAR_1, VAR_2, VAR_3, VAR_5),\ntcg_opc_b1(TCG_REG_P6, OPC_BR_DPTK_FEW_B1, imm));", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33, 35, 37, 39 ], [ 41 ] ]

[ "static int FUNC_0(XenIOState *VAR_0)\n{", "buffered_iopage_t *buf_page = VAR_0->buffered_io_page;", "buf_ioreq_t *buf_req = NULL;", "ioreq_t req;", "int VAR_1;", "if (!buf_page) {", "return 0;", "}", "memset(&req, 0x00, sizeof(req));", "for (;;) {", "uint32_t rdptr = buf_page->read_pointer, wrptr;", "xen_rmb();", "wrptr = buf_page->write_pointer;", "xen_rmb();", "if (rdptr != buf_page->read_pointer) {", "continue;", "}", "if (rdptr == wrptr) {", "break;", "}", "buf_req = &buf_page->buf_ioreq[rdptr % IOREQ_BUFFER_SLOT_NUM];", "req.size = 1UL << buf_req->size;", "req.count = 1;", "req.addr = buf_req->addr;", "req.data = buf_req->data;", "req.VAR_0 = STATE_IOREQ_READY;", "req.dir = buf_req->dir;", "req.df = 1;", "req.type = buf_req->type;", "req.data_is_ptr = 0;", "xen_rmb();", "VAR_1 = (req.size == 8);", "if (VAR_1) {", "if (rdptr + 1 == wrptr) {", "hw_error(\"Incomplete quad word buffered ioreq\");", "}", "buf_req = &buf_page->buf_ioreq[(rdptr + 1) %\nIOREQ_BUFFER_SLOT_NUM];", "req.data |= ((uint64_t)buf_req->data) << 32;", "xen_rmb();", "}", "handle_ioreq(VAR_0, &req);", "atomic_add(&buf_page->read_pointer, VAR_1 + 1);", "}", "return req.count;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ] ]

[ "void FUNC_0(VirtIODevice *VAR_0, Error **VAR_1)\n{", "DeviceState *qdev = DEVICE(VAR_0);", "BusState *qbus = BUS(qdev_get_parent_bus(qdev));", "VirtioBusState *bus = VIRTIO_BUS(qbus);", "VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus);", "VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(VAR_0);", "DPRINTF(\"%s: plug device.\\n\", qbus->name);", "if (klass->device_plugged != NULL) {", "klass->device_plugged(qbus->parent, VAR_1);", "}", "assert(vdc->get_features != NULL);", "VAR_0->host_features = vdc->get_features(VAR_0, VAR_0->host_features,\nVAR_1);", "if (klass->post_plugged != NULL) {", "klass->post_plugged(qbus->parent, VAR_1);", "}", "}" ]

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

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

[ "GSource *FUNC_0(AioContext *ctx)\n{", "g_source_ref(&ctx->source);", "return &ctx->source;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(AVCodecContext * VAR_0,\nvoid *VAR_1, int *VAR_2,\nconst uint8_t * VAR_3, int VAR_4)\n{", "MP3On4DecodeContext *s = VAR_0->priv_data;", "MPADecodeContext *m;", "int VAR_5, VAR_6 = 0;", "uint32_t header;", "OUT_INT *out_samples = VAR_1;", "OUT_INT decoded_buf[MPA_FRAME_SIZE * MPA_MAX_CHANNELS];", "OUT_INT *outptr, *bp;", "int VAR_7;", "int VAR_8, VAR_9, VAR_10, VAR_11;", "VAR_5 = VAR_4;", "*VAR_2 = 0;", "if (VAR_4 < HEADER_SIZE)\nreturn -1;", "outptr = s->frames == 1 ? out_samples : decoded_buf;", "for (VAR_8 = 0; VAR_8 < s->frames; VAR_8++) {", "VAR_7 = AV_RB16(VAR_3) >> 4;", "VAR_7 = FFMIN3(VAR_7, VAR_5, MPA_MAX_CODED_FRAME_SIZE);", "m = s->mp3decctx[VAR_8];", "assert (m != NULL);", "header = (AV_RB32(VAR_3) & 0x000fffff) | s->syncword;", "if (ff_mpa_check_header(header) < 0) {", "*VAR_2 = 0;", "return VAR_4;", "}", "ff_mpegaudio_decode_header(m, header);", "VAR_6 += mp_decode_frame(m, outptr, VAR_3, VAR_7);", "VAR_3 += VAR_7;", "VAR_5 -= VAR_7;", "if(s->frames > 1) {", "VAR_11 = m->VAR_0->frame_size*m->nb_channels;", "bp = out_samples + s->coff[VAR_8];", "if(m->nb_channels == 1) {", "for(VAR_10 = 0; VAR_10 < VAR_11; VAR_10++) {", "*bp = decoded_buf[VAR_10];", "bp += VAR_0->channels;", "}", "} else {", "for(VAR_10 = 0; VAR_10 < VAR_11; VAR_10++) {", "bp[0] = decoded_buf[VAR_10++];", "bp[1] = decoded_buf[VAR_10];", "bp += VAR_0->channels;", "}", "}", "}", "}", "VAR_0->sample_rate = s->mp3decctx[0]->sample_rate;", "VAR_0->bit_rate = 0;", "for (VAR_9 = 0; VAR_9 < s->frames; VAR_9++)", "VAR_0->bit_rate += s->mp3decctx[VAR_9]->bit_rate;", "*VAR_2 = VAR_6;", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 37, 39 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ] ]