Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static int FUNC_0(TAKDecContext *VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{", "GetBitContext *gb = &VAR_0->gb;", "int32_t *p1 = VAR_0->decoded[VAR_1] + 1;", "int32_t *p2 = VAR_0->decoded[VAR_2] + 1;", "int VAR_4;", "int VAR_5, VAR_6;", "switch (VAR_0->dmode) {", "case 1:\nfor (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {", "int32_t a = p1[VAR_4];", "int32_t b = p2[VAR_4];", "p2[VAR_4] = a + b;", "}", "break;", "case 2:\nfor (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {", "int32_t a = p1[VAR_4];", "int32_t b = p2[VAR_4];", "p1[VAR_4] = b - a;", "}", "break;", "case 3:\nfor (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {", "int32_t a = p1[VAR_4];", "int32_t b = p2[VAR_4];", "a -= b >> 1;", "p1[VAR_4] = a;", "p2[VAR_4] = a + b;", "}", "break;", "case 4:\nFFSWAP(int32_t*, p1, p2);", "case 5:\nVAR_5 = get_bits_esc4(gb);", "VAR_6 = get_sbits(gb, 10);", "for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {", "int32_t a = p1[VAR_4];", "int32_t b = p2[VAR_4];", "b = VAR_6 * (b >> VAR_5) + 128 >> 8 << VAR_5;", "p1[VAR_4] = b - a;", "}", "break;", "case 6:\nFFSWAP(int32_t*, p1, p2);", "case 7: {", "int VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;", "int VAR_12, VAR_13, VAR_14;", "if (VAR_3 < 256)\nreturn AVERROR_INVALIDDATA;", "VAR_5 = get_bits_esc4(gb);", "VAR_9 = 8 << get_bits1(gb);", "VAR_10 = get_bits1(gb);", "VAR_11 = get_bits1(gb);", "AV_ZERO128(VAR_0->filter + 8);", "for (VAR_4 = 0; VAR_4 < VAR_9; VAR_4++) {", "if (!(VAR_4 & 3))\nVAR_14 = 14 - get_bits(gb, 3);", "VAR_0->filter[VAR_4] = get_sbits(gb, VAR_14);", "}", "VAR_8 = VAR_9 / 2;", "VAR_7 = VAR_3 - (VAR_9 - 1);", "if (VAR_10) {", "for (VAR_4 = 0; VAR_4 < VAR_8; VAR_4++) {", "int32_t a = p1[VAR_4];", "int32_t b = p2[VAR_4];", "p1[VAR_4] = a + b;", "}", "}", "if (VAR_11) {", "for (VAR_4 = VAR_7 + VAR_8; VAR_4 < VAR_3; VAR_4++) {", "int32_t a = p1[VAR_4];", "int32_t b = p2[VAR_4];", "p1[VAR_4] = a + b;", "}", "}", "for (VAR_4 = 0; VAR_4 < VAR_9; VAR_4++)", "VAR_0->residues[VAR_4] = *p2++ >> VAR_5;", "p1 += VAR_8;", "VAR_13 = FF_ARRAY_ELEMS(VAR_0->residues) - VAR_9;", "for (; VAR_7 > 0; VAR_7 -= VAR_12) {", "VAR_12 = FFMIN(VAR_7, VAR_13);", "for (VAR_4 = 0; VAR_4 < VAR_12; VAR_4++)", "VAR_0->residues[VAR_9 + VAR_4] = *p2++ >> VAR_5;", "for (VAR_4 = 0; VAR_4 < VAR_12; VAR_4++) {", "int VAR_15 = 1 << 9;", "VAR_15 += VAR_0->adsp.scalarproduct_int16(&VAR_0->residues[VAR_4], VAR_0->filter, 16);", "VAR_15 = (av_clip_intp2(VAR_15 >> 10, 13) << VAR_5) - *p1;", "*p1++ = VAR_15;", "}", "memcpy(VAR_0->residues, &VAR_0->residues[VAR_12], 2 * VAR_9);", "}", "emms_c();", "break;", "}", "}", "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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

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

[ "static void *FUNC_0(void *VAR_0)\n{", "GMainContext *worker_context;", "GMainLoop *compare_loop;", "CompareState *s = VAR_0;", "GSource *timeout_source;", "worker_context = g_main_context_new();", "qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,\ncompare_pri_chr_in, NULL, s, worker_context, true);", "qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_can_read,\ncompare_sec_chr_in, NULL, s, worker_context, true);", "compare_loop = g_main_loop_new(worker_context, FALSE);", "timeout_source = g_timeout_source_new(REGULAR_PACKET_CHECK_MS);", "g_source_set_callback(timeout_source,\n(GSourceFunc)check_old_packet_regular, s, NULL);", "g_source_attach(timeout_source, worker_context);", "g_main_loop_run(compare_loop);", "g_source_unref(timeout_source);", "g_main_loop_unref(compare_loop);", "g_main_context_unref(worker_context);", "return NULL;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19, 21 ], [ 23, 25 ], [ 29 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "static void FUNC_0(WriterContext *VAR_0, AVFormatContext *VAR_1)\n{", "char VAR_2[128];", "int64_t size = VAR_1->pb ? avio_size(VAR_1->pb) : -1;", "print_section_header(\"format\");", "print_str(\"filename\", VAR_1->filename);", "print_int(\"nb_streams\", VAR_1->nb_streams);", "print_str(\"format_name\", VAR_1->iformat->name);", "print_str(\"format_long_name\", VAR_1->iformat->long_name);", "print_time(\"start_time\", VAR_1->start_time, &AV_TIME_BASE_Q);", "print_time(\"duration\", VAR_1->duration, &AV_TIME_BASE_Q);", "if (size >= 0) print_val (\"size\", size, unit_byte_str);", "else print_str_opt(\"size\", \"N/A\");", "if (VAR_1->bit_rate > 0) print_val (\"bit_rate\", VAR_1->bit_rate, unit_bit_per_second_str);", "else print_str_opt(\"bit_rate\", \"N/A\");", "show_tags(VAR_1->metadata);", "print_section_footer(\"format\");", "fflush(stdout);", "}" ]

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

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

[ "static SchroFrame *FUNC_0(AVCodecContext *avctx,\nconst AVFrame *frame)\n{", "SchroEncoderParams *p_schro_params = avctx->priv_data;", "SchroFrame *in_frame = ff_create_schro_frame(avctx,\np_schro_params->frame_format);", "if (in_frame) {", "if (av_frame_copy(in_frame->priv, frame) < 0) {", "av_log(avctx, AV_LOG_ERROR, \"Failed to copy input data\\n\");", "return NULL;", "}", "}", "return in_frame;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9, 11 ], [ 15 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ] ]

[ "static void FUNC_0(CPUState *VAR_0)\n{", "X86CPU *cpu = X86_CPU(VAR_0);", "X86CPUClass *xcc = X86_CPU_GET_CLASS(cpu);", "CPUX86State *env = &cpu->env;", "int VAR_1;", "xcc->parent_reset(VAR_0);", "memset(env, 0, offsetof(CPUX86State, breakpoints));", "tlb_flush(env, 1);", "env->old_exception = -1;", "#ifdef CONFIG_SOFTMMU\nenv->hflags |= HF_SOFTMMU_MASK;", "#endif\nenv->hflags2 |= HF2_GIF_MASK;", "cpu_x86_update_cr0(env, 0x60000010);", "env->a20_mask = ~0x0;", "env->smbase = 0x30000;", "env->idt.limit = 0xffff;", "env->gdt.limit = 0xffff;", "env->ldt.limit = 0xffff;", "env->ldt.flags = DESC_P_MASK | (2 << DESC_TYPE_SHIFT);", "env->tr.limit = 0xffff;", "env->tr.flags = DESC_P_MASK | (11 << DESC_TYPE_SHIFT);", "cpu_x86_load_seg_cache(env, R_CS, 0xf000, 0xffff0000, 0xffff,\nDESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |\nDESC_R_MASK | DESC_A_MASK);", "cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffff,\nDESC_P_MASK | DESC_S_MASK | DESC_W_MASK |\nDESC_A_MASK);", "cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffff,\nDESC_P_MASK | DESC_S_MASK | DESC_W_MASK |\nDESC_A_MASK);", "cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffff,\nDESC_P_MASK | DESC_S_MASK | DESC_W_MASK |\nDESC_A_MASK);", "cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffff,\nDESC_P_MASK | DESC_S_MASK | DESC_W_MASK |\nDESC_A_MASK);", "cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffff,\nDESC_P_MASK | DESC_S_MASK | DESC_W_MASK |\nDESC_A_MASK);", "env->eip = 0xfff0;", "env->regs[R_EDX] = env->cpuid_version;", "env->eflags = 0x2;", "for (VAR_1 = 0; VAR_1 < 8; VAR_1++) {", "env->fptags[VAR_1] = 1;", "}", "env->fpuc = 0x37f;", "env->mxcsr = 0x1f80;", "env->xstate_bv = XSTATE_FP | XSTATE_SSE;", "env->pat = 0x0007040600070406ULL;", "env->msr_ia32_misc_enable = MSR_IA32_MISC_ENABLE_DEFAULT;", "memset(env->dr, 0, sizeof(env->dr));", "env->dr[6] = DR6_FIXED_1;", "env->dr[7] = DR7_FIXED_1;", "cpu_breakpoint_remove_all(env, BP_CPU);", "cpu_watchpoint_remove_all(env, BP_CPU);", "#if !defined(CONFIG_USER_ONLY)\nif (VAR_0->cpu_index == 0) {", "apic_designate_bsp(env->apic_state);", "}", "VAR_0->halted = !cpu_is_bsp(cpu);", "#endif\n}" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 12, 13 ], [ 14, 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25, 26, 27 ], [ 28, 29, 30 ], [ 31, 32, 33 ], [ 34, 35, 36 ], [ 37, 38, 39 ], [ 40, 41, 42 ], [ 43 ], [ 44 ], [ 45 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52 ], [ 53 ], [ 54 ], [ 55 ], [ 56 ], [ 57 ], [ 58 ], [ 59 ], [ 60, 62 ], [ 63 ], [ 64 ], [ 65 ], [ 66, 67 ] ]

[ "FUNC_0(VAR_0)\n{", "qemu_assert(0, \"FRESTORE not implemented\");", "}" ]

[ 0, 1, 0 ]

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

[ "int FUNC_0(AVCodecContext *VAR_0,\nconst AVCodecContext *VAR_1)\n{", "H264Context *h = VAR_0->priv_data, *h1 = VAR_1->priv_data;", "int VAR_2 = h->context_initialized, VAR_3 = 0;", "int VAR_4 = 0;", "int VAR_5, VAR_6;", "if (VAR_0 == VAR_1)\nreturn 0;", "if (VAR_2 &&\n(h->width != h1->width ||\nh->height != h1->height ||\nh->mb_width != h1->mb_width ||\nh->mb_height != h1->mb_height ||\nh->sps.bit_depth_luma != h1->sps.bit_depth_luma ||\nh->sps.chroma_format_idc != h1->sps.chroma_format_idc ||\nh->sps.colorspace != h1->sps.colorspace)) {", "h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;", "h->width = h1->width;", "h->height = h1->height;", "h->mb_height = h1->mb_height;", "h->mb_width = h1->mb_width;", "h->mb_num = h1->mb_num;", "h->mb_stride = h1->mb_stride;", "h->b_stride = h1->b_stride;", "if ((VAR_6 = copy_parameter_set((void **)h->sps_buffers,\n(void **)h1->sps_buffers,\nMAX_SPS_COUNT, sizeof(SPS))) < 0)\nreturn VAR_6;", "h->sps = h1->sps;", "if ((VAR_6 = copy_parameter_set((void **)h->pps_buffers,\n(void **)h1->pps_buffers,\nMAX_PPS_COUNT, sizeof(PPS))) < 0)\nreturn VAR_6;", "h->pps = h1->pps;", "if ((VAR_3 = h264_slice_header_init(h, 1)) < 0) {", "av_log(h->avctx, AV_LOG_ERROR, \"h264_slice_header_init() failed\\n\");", "return VAR_3;", "}", "VAR_4 = 1;", "#if 0\nh264_set_parameter_from_sps(h);", "h->cur_chroma_format_idc = h1->cur_chroma_format_idc;", "#endif\n}", "memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));", "if (!VAR_2) {", "H264SliceContext *orig_slice_ctx = h->slice_ctx;", "for (VAR_5 = 0; VAR_5 < MAX_SPS_COUNT; VAR_5++)", "av_freep(h->sps_buffers + VAR_5);", "for (VAR_5 = 0; VAR_5 < MAX_PPS_COUNT; VAR_5++)", "av_freep(h->pps_buffers + VAR_5);", "ff_h264_unref_picture(h, &h->last_pic_for_ec);", "memcpy(h, h1, sizeof(H264Context));", "memset(h->sps_buffers, 0, sizeof(h->sps_buffers));", "memset(h->pps_buffers, 0, sizeof(h->pps_buffers));", "memset(&h->cur_pic, 0, sizeof(h->cur_pic));", "memset(&h->last_pic_for_ec, 0, sizeof(h->last_pic_for_ec));", "h->slice_ctx = orig_slice_ctx;", "memset(&h->slice_ctx[0].er, 0, sizeof(h->slice_ctx[0].er));", "memset(&h->slice_ctx[0].mb, 0, sizeof(h->slice_ctx[0].mb));", "memset(&h->slice_ctx[0].mb_luma_dc, 0, sizeof(h->slice_ctx[0].mb_luma_dc));", "memset(&h->slice_ctx[0].mb_padding, 0, sizeof(h->slice_ctx[0].mb_padding));", "h->avctx = VAR_0;", "h->DPB = NULL;", "h->qscale_table_pool = NULL;", "h->mb_type_pool = NULL;", "h->ref_index_pool = NULL;", "h->motion_val_pool = NULL;", "h->intra4x4_pred_mode= NULL;", "h->non_zero_count = NULL;", "h->slice_table_base = NULL;", "h->slice_table = NULL;", "h->cbp_table = NULL;", "h->chroma_pred_mode_table = NULL;", "memset(h->mvd_table, 0, sizeof(h->mvd_table));", "h->direct_table = NULL;", "h->list_counts = NULL;", "h->mb2b_xy = NULL;", "h->mb2br_xy = NULL;", "if (h1->context_initialized) {", "h->context_initialized = 0;", "memset(&h->cur_pic, 0, sizeof(h->cur_pic));", "av_frame_unref(&h->cur_pic.f);", "h->cur_pic.tf.f = &h->cur_pic.f;", "VAR_6 = ff_h264_alloc_tables(h);", "if (VAR_6 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Could not allocate memory\\n\");", "return VAR_6;", "}", "VAR_6 = ff_h264_slice_context_init(h, &h->slice_ctx[0]);", "if (VAR_6 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"context_init() failed.\\n\");", "return VAR_6;", "}", "}", "h->context_initialized = h1->context_initialized;", "}", "h->avctx->coded_height = h1->avctx->coded_height;", "h->avctx->coded_width = h1->avctx->coded_width;", "h->avctx->width = h1->avctx->width;", "h->avctx->height = h1->avctx->height;", "h->coded_picture_number = h1->coded_picture_number;", "h->first_field = h1->first_field;", "h->picture_structure = h1->picture_structure;", "h->droppable = h1->droppable;", "h->low_delay = h1->low_delay;", "for (VAR_5 = 0; h->DPB && VAR_5 < H264_MAX_PICTURE_COUNT; VAR_5++) {", "ff_h264_unref_picture(h, &h->DPB[VAR_5]);", "if (h1->DPB && h1->DPB[VAR_5].f.buf[0] &&\n(VAR_6 = ff_h264_ref_picture(h, &h->DPB[VAR_5], &h1->DPB[VAR_5])) < 0)\nreturn VAR_6;", "}", "h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);", "ff_h264_unref_picture(h, &h->cur_pic);", "if (h1->cur_pic.f.buf[0]) {", "VAR_6 = ff_h264_ref_picture(h, &h->cur_pic, &h1->cur_pic);", "if (VAR_6 < 0)\nreturn VAR_6;", "}", "h->workaround_bugs = h1->workaround_bugs;", "h->low_delay = h1->low_delay;", "h->droppable = h1->droppable;", "h->is_avc = h1->is_avc;", "if ((VAR_6 = copy_parameter_set((void **)h->sps_buffers,\n(void **)h1->sps_buffers,\nMAX_SPS_COUNT, sizeof(SPS))) < 0)\nreturn VAR_6;", "h->sps = h1->sps;", "if ((VAR_6 = copy_parameter_set((void **)h->pps_buffers,\n(void **)h1->pps_buffers,\nMAX_PPS_COUNT, sizeof(PPS))) < 0)\nreturn VAR_6;", "h->pps = h1->pps;", "copy_fields(h, h1, dequant4_buffer, dequant4_coeff);", "for (VAR_5 = 0; VAR_5 < 6; VAR_5++)", "h->dequant4_coeff[VAR_5] = h->dequant4_buffer[0] +\n(h1->dequant4_coeff[VAR_5] - h1->dequant4_buffer[0]);", "for (VAR_5 = 0; VAR_5 < 6; VAR_5++)", "h->dequant8_coeff[VAR_5] = h->dequant8_buffer[0] +\n(h1->dequant8_coeff[VAR_5] - h1->dequant8_buffer[0]);", "h->dequant_coeff_pps = h1->dequant_coeff_pps;", "copy_fields(h, h1, poc_lsb, default_ref_list);", "copy_fields(h, h1, short_ref, current_slice);", "copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);", "copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);", "copy_picture_range(h->delayed_pic, h1->delayed_pic,\nMAX_DELAYED_PIC_COUNT + 2, h, h1);", "h->frame_recovered = h1->frame_recovered;", "if (VAR_4)\nff_h264_set_parameter_from_sps(h);", "if (!h->cur_pic_ptr)\nreturn 0;", "if (!h->droppable) {", "VAR_3 = ff_h264_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;", "h->outputed_poc = h->next_outputed_poc;", "h->recovery_frame = h1->recovery_frame;", "return VAR_3;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17, 19 ], [ 23, 25, 27, 29, 31, 33, 35, 37 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67, 69, 71, 73 ], [ 75 ], [ 77, 79, 81, 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101, 103 ], [ 107 ], [ 109, 111 ], [ 117 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 213 ], [ 215 ], [ 217 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 271 ], [ 273 ], [ 275, 277, 279 ], [ 281 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293, 295 ], [ 297 ], [ 301 ], [ 303 ], [ 305 ], [ 311 ], [ 317, 319, 321, 323 ], [ 325 ], [ 327, 329, 331, 333 ], [ 335 ], [ 343 ], [ 347 ], [ 349, 351 ], [ 355 ], [ 357, 359 ], [ 363 ], [ 369 ], [ 375 ], [ 379 ], [ 381 ], [ 383, 385 ], [ 389 ], [ 393, 395 ], [ 399, 401 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 423 ], [ 427 ], [ 429 ] ]

[ "static inline abi_long FUNC_0(int semid, unsigned short **host_array,\nabi_ulong target_addr)\n{", "int VAR_0;", "unsigned short *VAR_1;", "union VAR_2 VAR_2;", "struct VAR_3 VAR_3;", "int VAR_4, VAR_5;", "VAR_2.buf = &VAR_3;", "VAR_5 = semctl(semid, 0, IPC_STAT, VAR_2);", "if (VAR_5 == -1)\nreturn get_errno(VAR_5);", "VAR_0 = VAR_3.sem_nsems;", "*host_array = malloc(VAR_0*sizeof(unsigned short));", "VAR_1 = lock_user(VERIFY_READ, target_addr,\nVAR_0*sizeof(unsigned short), 1);", "if (!VAR_1)\nreturn -TARGET_EFAULT;", "for(VAR_4=0; VAR_4<VAR_0; VAR_4++) {", "__get_user((*host_array)[VAR_4], &VAR_1[VAR_4]);", "}", "unlock_user(VAR_1, target_addr, 0);", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 35 ], [ 37, 39 ], [ 41, 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ] ]

[ "static void FUNC_0(VGAState *VAR_0, int VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "int VAR_11, VAR_12, VAR_13, VAR_14;", "uint32_t offset, fgcol, bgcol, v, cursor_offset;", "uint8_t *d1, *d, *src, *s1, *dest, *cursor_ptr;", "const uint8_t *VAR_15, *font_base[2];", "int VAR_16, VAR_17, VAR_18;", "uint32_t *palette;", "uint32_t *ch_attr_ptr;", "vga_draw_glyph8_func *vga_draw_glyph8;", "vga_draw_glyph9_func *vga_draw_glyph9;", "vga_dirty_log_stop(VAR_0);", "v = VAR_0->sr[3];", "offset = (((v >> 4) & 1) | ((v << 1) & 6)) * 8192 * 4 + 2;", "if (offset != VAR_0->font_offsets[0]) {", "VAR_0->font_offsets[0] = offset;", "VAR_1 = 1;", "}", "font_base[0] = VAR_0->vram_ptr + offset;", "offset = (((v >> 5) & 1) | ((v >> 1) & 6)) * 8192 * 4 + 2;", "font_base[1] = VAR_0->vram_ptr + offset;", "if (offset != VAR_0->font_offsets[1]) {", "VAR_0->font_offsets[1] = offset;", "VAR_1 = 1;", "}", "if (VAR_0->plane_updated & (1 << 2)) {", "VAR_0->plane_updated = 0;", "VAR_1 = 1;", "}", "VAR_1 |= update_basic_params(VAR_0);", "VAR_17 = VAR_0->VAR_17;", "s1 = VAR_0->vram_ptr + (VAR_0->start_addr * 4);", "vga_get_text_resolution(VAR_0, &VAR_9, &VAR_8, &VAR_5, &VAR_4);", "VAR_14 = VAR_5 * ((ds_get_bits_per_pixel(VAR_0->ds) + 7) >> 3);", "if ((VAR_8 * VAR_9) > CH_ATTR_SIZE) {", "return;", "}", "if (VAR_9 != VAR_0->last_width || VAR_8 != VAR_0->last_height ||\nVAR_5 != VAR_0->last_cw || VAR_4 != VAR_0->last_ch || VAR_0->last_depth) {", "VAR_0->last_scr_width = VAR_9 * VAR_5;", "VAR_0->last_scr_height = VAR_8 * VAR_4;", "qemu_console_resize(VAR_0->ds, VAR_0->last_scr_width, VAR_0->last_scr_height);", "VAR_0->last_depth = 0;", "VAR_0->last_width = VAR_9;", "VAR_0->last_height = VAR_8;", "VAR_0->last_ch = VAR_4;", "VAR_0->last_cw = VAR_5;", "VAR_1 = 1;", "}", "VAR_0->rgb_to_pixel =\nrgb_to_pixel_dup_table[get_depth_index(VAR_0->ds)];", "VAR_1 |= update_palette16(VAR_0);", "palette = VAR_0->last_palette;", "VAR_14 = VAR_5 * ((ds_get_bits_per_pixel(VAR_0->ds) + 7) >> 3);", "cursor_offset = ((VAR_0->cr[0x0e] << 8) | VAR_0->cr[0x0f]) - VAR_0->start_addr;", "if (cursor_offset != VAR_0->cursor_offset ||\nVAR_0->cr[0xa] != VAR_0->cursor_start ||\nVAR_0->cr[0xb] != VAR_0->cursor_end) {", "if (VAR_0->cursor_offset < CH_ATTR_SIZE)\nVAR_0->last_ch_attr[VAR_0->cursor_offset] = -1;", "if (cursor_offset < CH_ATTR_SIZE)\nVAR_0->last_ch_attr[cursor_offset] = -1;", "VAR_0->cursor_offset = cursor_offset;", "VAR_0->cursor_start = VAR_0->cr[0xa];", "VAR_0->cursor_end = VAR_0->cr[0xb];", "}", "cursor_ptr = VAR_0->vram_ptr + (VAR_0->start_addr + cursor_offset) * 4;", "VAR_18 = get_depth_index(VAR_0->ds);", "if (VAR_5 == 16)\nvga_draw_glyph8 = vga_draw_glyph16_table[VAR_18];", "else\nvga_draw_glyph8 = vga_draw_glyph8_table[VAR_18];", "vga_draw_glyph9 = vga_draw_glyph9_table[VAR_18];", "dest = ds_get_data(VAR_0->ds);", "VAR_13 = ds_get_linesize(VAR_0->ds);", "ch_attr_ptr = VAR_0->last_ch_attr;", "for(VAR_3 = 0; VAR_3 < VAR_8; VAR_3++) {", "d1 = dest;", "src = s1;", "VAR_11 = VAR_9;", "VAR_12 = -1;", "for(VAR_2 = 0; VAR_2 < VAR_9; VAR_2++) {", "VAR_10 = *(uint16_t *)src;", "if (VAR_1 || VAR_10 != *ch_attr_ptr) {", "if (VAR_2 < VAR_11)\nVAR_11 = VAR_2;", "if (VAR_2 > VAR_12)\nVAR_12 = VAR_2;", "*ch_attr_ptr = VAR_10;", "#ifdef WORDS_BIGENDIAN\nVAR_6 = VAR_10 >> 8;", "VAR_7 = VAR_10 & 0xff;", "#else\nVAR_6 = VAR_10 & 0xff;", "VAR_7 = VAR_10 >> 8;", "#endif\nVAR_15 = font_base[(VAR_7 >> 3) & 1];", "VAR_15 += 32 * 4 * VAR_6;", "bgcol = palette[VAR_7 >> 4];", "fgcol = palette[VAR_7 & 0x0f];", "if (VAR_5 != 9) {", "vga_draw_glyph8(d1, VAR_13,\nVAR_15, VAR_4, fgcol, bgcol);", "} else {", "VAR_16 = 0;", "if (VAR_6 >= 0xb0 && VAR_6 <= 0xdf && (VAR_0->ar[0x10] & 0x04))\nVAR_16 = 1;", "vga_draw_glyph9(d1, VAR_13,\nVAR_15, VAR_4, fgcol, bgcol, VAR_16);", "}", "if (src == cursor_ptr &&\n!(VAR_0->cr[0x0a] & 0x20)) {", "int VAR_19, VAR_20, VAR_21;", "VAR_19 = VAR_0->cr[0x0a] & 0x1f;", "VAR_20 = VAR_0->cr[0x0b] & 0x1f;", "if (VAR_20 > VAR_4 - 1)\nVAR_20 = VAR_4 - 1;", "if (VAR_20 >= VAR_19 && VAR_19 < VAR_4) {", "VAR_21 = VAR_20 - VAR_19 + 1;", "d = d1 + VAR_13 * VAR_19;", "if (VAR_5 != 9) {", "vga_draw_glyph8(d, VAR_13,\ncursor_glyph, VAR_21, fgcol, bgcol);", "} else {", "vga_draw_glyph9(d, VAR_13,\ncursor_glyph, VAR_21, fgcol, bgcol, 1);", "}", "}", "}", "}", "d1 += VAR_14;", "src += 4;", "ch_attr_ptr++;", "}", "if (VAR_12 != -1) {", "dpy_update(VAR_0->ds, VAR_11 * VAR_5, VAR_3 * VAR_4,\n(VAR_12 - VAR_11 + 1) * VAR_5, VAR_4);", "}", "dest += VAR_13 * VAR_4;", "s1 += VAR_17;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135, 137, 139 ], [ 145, 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167, 169 ], [ 171, 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201, 203 ], [ 205, 207 ], [ 209 ], [ 211, 213 ], [ 215 ], [ 217, 219 ], [ 221 ], [ 223, 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243, 245 ], [ 247, 249 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 261 ], [ 263 ], [ 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 ] ]

[ "static hwaddr FUNC_0(PowerPCCPU *cpu, hwaddr hash,\nuint32_t slb_pshift, bool secondary,\ntarget_ulong ptem, ppc_hash_pte64_t *pte)\n{", "CPUPPCState *env = &cpu->env;", "int VAR_0;", "uint64_t token;", "target_ulong pte0, pte1;", "target_ulong pte_index;", "pte_index = (hash & env->htab_mask) * HPTES_PER_GROUP;", "token = ppc_hash64_start_access(cpu, pte_index);", "if (!token) {", "return -1;", "}", "for (VAR_0 = 0; VAR_0 < HPTES_PER_GROUP; VAR_0++) {", "pte0 = ppc_hash64_load_hpte0(cpu, token, VAR_0);", "pte1 = ppc_hash64_load_hpte1(cpu, token, VAR_0);", "if ((pte0 & HPTE64_V_VALID)\n&& (secondary == !!(pte0 & HPTE64_V_SECONDARY))\n&& HPTE64_V_COMPARE(pte0, ptem)) {", "uint32_t pshift = ppc_hash64_pte_size_decode(pte1, slb_pshift);", "if (pshift == 0) {", "continue;", "}", "pte->pte0 = pte0;", "pte->pte1 = pte1;", "ppc_hash64_stop_access(cpu, token);", "return (pte_index + VAR_0) * HASH_PTE_SIZE_64;", "}", "}", "ppc_hash64_stop_access(cpu, token);", "return -1;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 79 ], [ 81 ] ]

[ "int FUNC_0(BDRVReopenState *VAR_0, BlockReopenQueue *VAR_1,\nError **VAR_2)\n{", "int VAR_3 = -1;", "Error *local_err = NULL;", "BlockDriver *drv;", "QemuOpts *opts;", "const char *VAR_4;", "bool read_only;", "assert(VAR_0 != NULL);", "assert(VAR_0->bs->drv != NULL);", "drv = VAR_0->bs->drv;", "opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);", "qemu_opts_absorb_qdict(opts, VAR_0->options, &local_err);", "if (local_err) {", "error_propagate(VAR_2, local_err);", "VAR_3 = -EINVAL;", "goto error;", "}", "update_flags_from_options(&VAR_0->flags, opts);", "VAR_4 = qemu_opt_get(opts, \"node-name\");", "if (VAR_4) {", "qdict_put_str(VAR_0->options, \"node-name\", VAR_4);", "}", "VAR_4 = qemu_opt_get(opts, \"driver\");", "if (VAR_4) {", "qdict_put_str(VAR_0->options, \"driver\", VAR_4);", "}", "read_only = !(VAR_0->flags & BDRV_O_RDWR);", "VAR_3 = bdrv_can_set_read_only(VAR_0->bs, read_only, true, &local_err);", "if (local_err) {", "error_propagate(VAR_2, local_err);", "goto error;", "}", "bdrv_reopen_perm(VAR_1, VAR_0->bs,\n&VAR_0->perm, &VAR_0->shared_perm);", "VAR_3 = bdrv_flush(VAR_0->bs);", "if (VAR_3) {", "error_setg_errno(VAR_2, -VAR_3, \"Error flushing drive\");", "goto error;", "}", "if (drv->FUNC_0) {", "VAR_3 = drv->FUNC_0(VAR_0, VAR_1, &local_err);", "if (VAR_3) {", "if (local_err != NULL) {", "error_propagate(VAR_2, local_err);", "} else {", "error_setg(VAR_2, \"failed while preparing to reopen image '%s'\",\nVAR_0->bs->filename);", "}", "goto error;", "}", "} else {", "error_setg(VAR_2, \"Block format '%s' used by node '%s' \"\n\"does not support reopening files\", drv->format_name,\nbdrv_get_device_or_node_name(VAR_0->bs));", "VAR_3 = -1;", "goto error;", "}", "if (qdict_size(VAR_0->options)) {", "const QDictEntry *VAR_5 = qdict_first(VAR_0->options);", "do {", "QString *new_obj = qobject_to_qstring(VAR_5->VAR_4);", "const char *VAR_6 = qstring_get_str(new_obj);", "const char *VAR_7 = qdict_get_try_str(VAR_0->bs->options,\nVAR_5->key);", "if (!VAR_7 || strcmp(VAR_6, VAR_7)) {", "error_setg(VAR_2, \"Cannot change the option '%s'\", VAR_5->key);", "VAR_3 = -EINVAL;", "goto error;", "}", "} while ((VAR_5 = qdict_next(VAR_0->options, VAR_5)));", "}", "VAR_3 = bdrv_check_perm(VAR_0->bs, VAR_1, VAR_0->perm,\nVAR_0->shared_perm, NULL, VAR_2);", "if (VAR_3 < 0) {", "goto error;", "}", "VAR_3 = 0;", "error:\nqemu_opts_del(opts);", "return VAR_3;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 97, 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 143, 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 189, 191 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 227, 229 ], [ 231 ], [ 233 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "G722Context *c = avctx->priv_data;", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < 2; VAR_0++) {", "av_freep(&c->paths[VAR_0]);", "av_freep(&c->node_buf[VAR_0]);", "av_freep(&c->nodep_buf[VAR_0]);", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "ASFContext *asf = VAR_0->priv_data;", "ByteIOContext *pb = &VAR_0->pb;", "uint32_t packet_length, padsize;", "int VAR_1 = 9;", "int VAR_2;", "VAR_2 = get_byte(pb);", "if (VAR_2 != 0x82) {", "if (!url_feof(pb))\nav_log(VAR_0, AV_LOG_ERROR, \"ff asf bad header %x at:%\"PRId64\"\\n\", VAR_2, url_ftell(pb));", "}", "if ((VAR_2 & 0x0f) == 2) {", "if (get_le16(pb) != 0) {", "if (!url_feof(pb))\nav_log(VAR_0, AV_LOG_ERROR, \"ff asf bad non zero\\n\");", "return AVERROR_IO;", "}", "VAR_1+=2;", "}", "asf->packet_flags = get_byte(pb);", "asf->packet_property = get_byte(pb);", "DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size);", "DO_2BITS(asf->packet_flags >> 1, padsize, 0);", "DO_2BITS(asf->packet_flags >> 3, padsize, 0);", "if(packet_length >= (1U<<29)){", "av_log(VAR_0, AV_LOG_ERROR, \"invalid packet_length %d at:%\"PRId64\"\\n\", packet_length, url_ftell(pb));", "return -1;", "}", "if(padsize >= (1U<<29)){", "av_log(VAR_0, AV_LOG_ERROR, \"invalid padsize %d at:%\"PRId64\"\\n\", padsize, url_ftell(pb));", "return -1;", "}", "asf->packet_timestamp = get_le32(pb);", "get_le16(pb);", "if (asf->packet_flags & 0x01) {", "asf->packet_segsizetype = get_byte(pb); VAR_1++;", "asf->packet_segments = asf->packet_segsizetype & 0x3f;", "} else {", "asf->packet_segments = 1;", "asf->packet_segsizetype = 0x80;", "}", "asf->packet_size_left = packet_length - padsize - VAR_1;", "if (packet_length < asf->hdr.min_pktsize)\npadsize += asf->hdr.min_pktsize - packet_length;", "asf->packet_padsize = padsize;", "#ifdef DEBUG\nprintf(\"packet: size=%d padsize=%d left=%d\\n\", asf->packet_size, asf->packet_padsize, asf->packet_size_left);", "#endif\nreturn 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 49 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117, 119 ], [ 121, 123 ], [ 125 ] ]

[ "static void FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{", "AVStream *st;", "OutputStream *ost;", "AVCodecContext *video_enc;", "enum CodecID VAR_2 = CODEC_ID_NONE;", "AVCodec *codec= NULL;", "if(!video_stream_copy){", "if (video_codec_name) {", "VAR_2 = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,\navcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);", "codec = avcodec_find_encoder_by_name(video_codec_name);", "} else {", "VAR_2 = av_guess_codec(VAR_0->oformat, NULL, VAR_0->filename, NULL, AVMEDIA_TYPE_VIDEO);", "codec = avcodec_find_encoder(VAR_2);", "}", "}", "ost = new_output_stream(VAR_0, VAR_1, codec);", "st = ost->st;", "if (!video_stream_copy) {", "ost->frame_aspect_ratio = frame_aspect_ratio;", "frame_aspect_ratio = 0;", "#if CONFIG_AVFILTER\nost->avfilter= vfilters;", "vfilters = NULL;", "#endif\n}", "ost->bitstream_filters = video_bitstream_filters;", "video_bitstream_filters= NULL;", "st->codec->thread_count= thread_count;", "video_enc = st->codec;", "if(video_codec_tag)\nvideo_enc->codec_tag= video_codec_tag;", "if(VAR_0->oformat->flags & AVFMT_GLOBALHEADER) {", "video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;", "}", "if (video_stream_copy) {", "st->stream_copy = 1;", "video_enc->codec_type = AVMEDIA_TYPE_VIDEO;", "video_enc->sample_aspect_ratio =\nst->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);", "} else {", "const char *VAR_3;", "int VAR_4;", "if (frame_rate.num)\nost->frame_rate = frame_rate;", "video_enc->VAR_2 = VAR_2;", "set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);", "video_enc->width = frame_width;", "video_enc->height = frame_height;", "video_enc->pix_fmt = frame_pix_fmt;", "st->sample_aspect_ratio = video_enc->sample_aspect_ratio;", "if (intra_only)\nvideo_enc->gop_size = 0;", "if (video_qscale || same_quality) {", "video_enc->flags |= CODEC_FLAG_QSCALE;", "video_enc->global_quality = FF_QP2LAMBDA * video_qscale;", "}", "if(intra_matrix)\nvideo_enc->intra_matrix = intra_matrix;", "if(inter_matrix)\nvideo_enc->inter_matrix = inter_matrix;", "VAR_3= video_rc_override_string;", "for(VAR_4=0; VAR_3; VAR_4++){", "int VAR_5, VAR_6, VAR_7;", "int VAR_8=sscanf(VAR_3, \"%d,%d,%d\", &VAR_5, &VAR_6, &VAR_7);", "if(VAR_8!=3){", "fprintf(stderr, \"error parsing rc_override\\n\");", "ffmpeg_exit(1);", "}", "video_enc->rc_override=\nav_realloc(video_enc->rc_override,\nsizeof(RcOverride)*(VAR_4+1));", "video_enc->rc_override[VAR_4].start_frame= VAR_5;", "video_enc->rc_override[VAR_4].end_frame = VAR_6;", "if(VAR_7>0){", "video_enc->rc_override[VAR_4].qscale= VAR_7;", "video_enc->rc_override[VAR_4].quality_factor= 1.0;", "}", "else{", "video_enc->rc_override[VAR_4].qscale= 0;", "video_enc->rc_override[VAR_4].quality_factor= -VAR_7/100.0;", "}", "VAR_3= strchr(VAR_3, '/');", "if(VAR_3) VAR_3++;", "}", "video_enc->rc_override_count=VAR_4;", "if (!video_enc->rc_initial_buffer_occupancy)\nvideo_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;", "video_enc->me_threshold= me_threshold;", "video_enc->intra_dc_precision= intra_dc_precision - 8;", "if (do_psnr)\nvideo_enc->flags|= CODEC_FLAG_PSNR;", "if (do_pass) {", "if (do_pass == 1) {", "video_enc->flags |= CODEC_FLAG_PASS1;", "} else {", "video_enc->flags |= CODEC_FLAG_PASS2;", "}", "}", "if (forced_key_frames)\nparse_forced_key_frames(forced_key_frames, ost, video_enc);", "}", "if (video_language) {", "av_dict_set(&st->metadata, \"language\", video_language, 0);", "av_freep(&video_language);", "}", "video_disable = 0;", "av_freep(&video_codec_name);", "av_freep(&forced_key_frames);", "video_stream_copy = 0;", "frame_pix_fmt = PIX_FMT_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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 67 ], [ 71 ], [ 75, 77 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141, 143 ], [ 145, 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201, 203 ], [ 205 ], [ 207 ], [ 211, 213 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ] ]

[ "static GSList *FUNC_0(GtkDisplayState *s, VirtualConsole *vc,\nCharDriverState *chr, int idx,\nGSList *group, GtkWidget *view_menu)\n{", "char VAR_0[32];", "GtkWidget *box;", "GtkWidget *scrollbar;", "GtkAdjustment *vadjustment;", "VirtualConsole *tmp_vc = chr->opaque;", "vc->s = s;", "vc->vte.echo = tmp_vc->vte.echo;", "vc->vte.chr = chr;", "chr->opaque = vc;", "g_free(tmp_vc);", "snprintf(VAR_0, sizeof(VAR_0), \"vc%d\", idx);", "vc->label = g_strdup_printf(\"%s\", vc->vte.chr->label\n? vc->vte.chr->label : VAR_0);", "group = gd_vc_menu_init(s, vc, idx, group, view_menu);", "vc->vte.terminal = vte_terminal_new();", "g_signal_connect(vc->vte.terminal, \"commit\", G_CALLBACK(gd_vc_in), vc);", "#if VTE_CHECK_VERSION(0, 40, 0)\nvte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), \"UTF-8\", NULL);", "#else\nvte_terminal_set_encoding(VTE_TERMINAL(vc->vte.terminal), \"UTF-8\");", "#endif\nvte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte.terminal), -1);", "vte_terminal_set_size(VTE_TERMINAL(vc->vte.terminal),\nVC_TERM_X_MIN, VC_TERM_Y_MIN);", "#if VTE_CHECK_VERSION(0, 28, 0) && GTK_CHECK_VERSION(3, 0, 0)\nvadjustment = gtk_scrollable_get_vadjustment\n(GTK_SCROLLABLE(vc->vte.terminal));", "#else\nvadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal));", "#endif\n#if GTK_CHECK_VERSION(3, 0, 0)\nbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);", "scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment);", "#else\nbox = gtk_hbox_new(false, 2);", "scrollbar = gtk_vscrollbar_new(vadjustment);", "#endif\ngtk_box_pack_start(GTK_BOX(box), vc->vte.terminal, TRUE, TRUE, 0);", "gtk_box_pack_start(GTK_BOX(box), scrollbar, FALSE, FALSE, 0);", "vc->vte.box = box;", "vc->vte.scrollbar = scrollbar;", "g_signal_connect(vadjustment, \"changed\",\nG_CALLBACK(gd_vc_adjustment_changed), vc);", "vc->type = GD_VC_VTE;", "vc->tab_item = box;", "vc->focus = vc->vte.terminal;", "gtk_notebook_append_page(GTK_NOTEBOOK(s->notebook), vc->tab_item,\ngtk_label_new(vc->label));", "qemu_chr_be_generic_open(vc->vte.chr);", "if (vc->vte.chr->init) {", "vc->vte.chr->init(vc->vte.chr);", "}", "return group;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 45 ], [ 47 ], [ 57, 59 ], [ 61, 63 ], [ 65, 69 ], [ 71, 73 ], [ 77, 79, 81 ], [ 83, 85 ], [ 87, 91, 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 103, 107 ], [ 109 ], [ 113 ], [ 115 ], [ 119, 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ] ]

[ "int FUNC_0(QemuOpts *VAR_0, qemu_opt_loopfunc VAR_1, void *VAR_2,\nint VAR_3)\n{", "QemuOpt *opt;", "int VAR_4 = 0;", "TAILQ_FOREACH(opt, &VAR_0->head, next) {", "VAR_4 = VAR_1(opt->name, opt->str, VAR_2);", "if (VAR_3 && VAR_4 != 0)\nbreak;", "}", "return VAR_4;", "}" ]

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

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

[ "static void FUNC_0(GArray *VAR_0, BIOSLinker *VAR_1,\nVirtMachineState *VAR_2, unsigned VAR_3)\n{", "AcpiFadtDescriptorRev5_1 *fadt = acpi_data_push(VAR_0, sizeof(*fadt));", "unsigned VAR_4 = (char *)&fadt->dsdt - VAR_0->data;", "uint16_t bootflags;", "switch (VAR_2->psci_conduit) {", "case QEMU_PSCI_CONDUIT_DISABLED:\nbootflags = 0;", "break;", "case QEMU_PSCI_CONDUIT_HVC:\nbootflags = ACPI_FADT_ARM_PSCI_COMPLIANT | ACPI_FADT_ARM_PSCI_USE_HVC;", "break;", "case QEMU_PSCI_CONDUIT_SMC:\nbootflags = ACPI_FADT_ARM_PSCI_COMPLIANT;", "break;", "default:\ng_assert_not_reached();", "}", "fadt->flags = cpu_to_le32(1 << ACPI_FADT_F_HW_REDUCED_ACPI);", "fadt->arm_boot_flags = cpu_to_le16(bootflags);", "fadt->minor_revision = 0x1;", "bios_linker_loader_add_pointer(VAR_1,\nACPI_BUILD_TABLE_FILE, VAR_4, sizeof(fadt->dsdt),\nACPI_BUILD_TABLE_FILE, VAR_3);", "build_header(VAR_1, VAR_0,\n(void *)fadt, \"FACP\", sizeof(*fadt), 5, NULL, NULL);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17, 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 45 ], [ 47 ], [ 53 ], [ 59, 61, 63 ], [ 67, 69 ], [ 71 ] ]

[ "static void FUNC_0(VFIOPCIDevice *VAR_0)\n{", "uint32_t orig, size = cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK);", "off_t offset = VAR_0->config_offset + PCI_ROM_ADDRESS;", "DeviceState *dev = DEVICE(VAR_0);", "char VAR_1[32];", "int VAR_2 = VAR_0->vbasedev.VAR_2;", "if (VAR_0->pdev.romfile || !VAR_0->pdev.rom_bar) {", "if (vfio_blacklist_opt_rom(VAR_0) && VAR_0->pdev.romfile) {", "error_printf(\"Warning : Device at %04x:%02x:%02x.%x \"\n\"is known to cause system instability issues during \"\n\"option rom execution. \"\n\"Proceeding anyway since user specified romfile\\n\",\nVAR_0->host.domain, VAR_0->host.bus, VAR_0->host.slot,\nVAR_0->host.function);", "}", "return;", "}", "if (pread(VAR_2, &orig, 4, offset) != 4 ||\npwrite(VAR_2, &size, 4, offset) != 4 ||\npread(VAR_2, &size, 4, offset) != 4 ||\npwrite(VAR_2, &orig, 4, offset) != 4) {", "error_report(\"%s(%04x:%02x:%02x.%x) failed: %m\",\n__func__, VAR_0->host.domain, VAR_0->host.bus,\nVAR_0->host.slot, VAR_0->host.function);", "return;", "}", "size = ~(le32_to_cpu(size) & PCI_ROM_ADDRESS_MASK) + 1;", "if (!size) {", "return;", "}", "if (vfio_blacklist_opt_rom(VAR_0)) {", "if (dev->opts && qemu_opt_get(dev->opts, \"rombar\")) {", "error_printf(\"Warning : Device at %04x:%02x:%02x.%x \"\n\"is known to cause system instability issues during \"\n\"option rom execution. \"\n\"Proceeding anyway since user specified non zero value for \"\n\"rombar\\n\",\nVAR_0->host.domain, VAR_0->host.bus, VAR_0->host.slot,\nVAR_0->host.function);", "} else {", "error_printf(\"Warning : Rom loading for device at \"\n\"%04x:%02x:%02x.%x has been disabled due to \"\n\"system instability issues. \"\n\"Specify rombar=1 or romfile to force\\n\",\nVAR_0->host.domain, VAR_0->host.bus, VAR_0->host.slot,\nVAR_0->host.function);", "return;", "}", "}", "trace_vfio_pci_size_rom(VAR_0->vbasedev.VAR_1, size);", "snprintf(VAR_1, sizeof(VAR_1), \"vfio[%04x:%02x:%02x.%x].rom\",\nVAR_0->host.domain, VAR_0->host.bus, VAR_0->host.slot,\nVAR_0->host.function);", "memory_region_init_io(&VAR_0->pdev.rom, OBJECT(VAR_0),\n&vfio_rom_ops, VAR_0, VAR_1, size);", "pci_register_bar(&VAR_0->pdev, PCI_ROM_SLOT,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &VAR_0->pdev.rom);", "VAR_0->pdev.has_rom = true;", "VAR_0->rom_read_failed = false;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 23, 25, 27, 29, 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 51, 53, 55, 57 ], [ 59, 61, 63 ], [ 65 ], [ 67 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87, 89, 91, 93, 95, 97, 99 ], [ 101 ], [ 103, 105, 107, 109, 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 127, 129, 131 ], [ 135, 137 ], [ 141, 143 ], [ 147 ], [ 149 ], [ 151 ] ]

[ "void FUNC_0(void){", "int VAR_0, VAR_1;", "for (VAR_0=0; VAR_0<FF_ARRAY_ELEMS(av_pix_fmt_descriptors); VAR_0++) {", "const AVPixFmtDescriptor *d = &av_pix_fmt_descriptors[VAR_0];", "if (!d->name && !d->nb_components && !d->log2_chroma_w && !d->log2_chroma_h && !d->flags)\ncontinue;", "av_assert0(d->log2_chroma_w <= 3);", "av_assert0(d->log2_chroma_h <= 3);", "av_assert0(d->nb_components <= 4);", "av_assert0(d->name && d->name[0]);", "av_assert0((d->nb_components==4 || d->nb_components==2) == !!(d->flags & PIX_FMT_ALPHA));", "av_assert2(av_get_pix_fmt(d->name) == VAR_0);", "for (VAR_1=0; VAR_1<FF_ARRAY_ELEMS(d->comp); VAR_1++) {", "const AVComponentDescriptor *c = &d->comp[VAR_1];", "if(VAR_1>=d->nb_components)\nav_assert0(!c->plane && !c->step_minus1 && !c->offset_plus1 && !c->shift && !c->depth_minus1);", "}", "}", "}" ]

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

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

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "uint8_t *pci_conf;", "uint8_t *wmask;", "int VAR_1;", "isa_bus_new(&VAR_0->qdev);", "pci_conf = VAR_0->config;", "pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_VIA);", "pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_VIA_ISA_BRIDGE);", "pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_ISA);", "pci_config_set_prog_interface(pci_conf, 0x0);", "pci_config_set_revision(pci_conf,0x40);", "wmask = VAR_0->wmask;", "for (VAR_1 = 0x00; VAR_1 < 0xff; VAR_1++) {", "if (VAR_1<=0x03 || (VAR_1>=0x08 && VAR_1<=0x3f)) {", "wmask[VAR_1] = 0x00;", "}", "}", "qemu_register_reset(vt82c686b_reset, VAR_0);", "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 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 49 ], [ 51 ] ]

[ "static int FUNC_0(S390CPU *VAR_0, struct kvm_run *VAR_1, uint32_t VAR_2)\n{", "int VAR_3 = 0;", "uint16_t func_code;", "func_code = decode_basedisp_rs(&VAR_0->env, VAR_2) & DIAG_KVM_CODE_MASK;", "switch (func_code) {", "case DIAG_IPL:\nkvm_handle_diag_308(VAR_0, VAR_1);", "break;", "case DIAG_KVM_HYPERCALL:\nVAR_3 = handle_hypercall(VAR_0, VAR_1);", "break;", "case DIAG_KVM_BREAKPOINT:\nVAR_3 = handle_sw_breakpoint(VAR_0, VAR_1);", "break;", "default:\nDPRINTF(\"KVM: unknown DIAG: 0x%x\\n\", func_code);", "VAR_3 = -1;", "break;", "}", "return VAR_3;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ] ]

[ "static bool FUNC_0(VirtIODevice *vdev, VirtQueue *vq)\n{", "uint16_t old, new;", "bool v;", "smp_mb();", "if (virtio_has_feature(vdev, VIRTIO_F_NOTIFY_ON_EMPTY) &&\n!vq->inuse && vring_avail_idx(vq) == vq->last_avail_idx) {", "return true;", "}", "if (!virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {", "return !(vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT);", "}", "v = vq->signalled_used_valid;", "vq->signalled_used_valid = true;", "old = vq->signalled_used;", "new = vq->signalled_used = vring_used_idx(vq);", "return !v || vring_need_event(vring_get_used_event(vq), new, old);", "}" ]

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

[ "static void FUNC_0(void *VAR_0)\n{", "struct kvm_x86_mce_data *VAR_1 = VAR_0;", "int VAR_2;", "if ((VAR_1->env->mcg_cap & MCG_SER_P) &&\n!(VAR_1->mce->status & MCI_STATUS_AR)) {", "VAR_2 = kvm_mce_in_exception(VAR_1->env);", "if (VAR_2 == -1) {", "fprintf(stderr, \"Failed to get MCE status\\n\");", "} else if (VAR_2) {", "return;", "}", "}", "VAR_2 = kvm_set_mce(VAR_1->env, VAR_1->mce);", "if (VAR_2 < 0) {", "perror(\"kvm_set_mce FAILED\");", "if (VAR_1->abort_on_error) {", "abort();", "}", "}", "}" ]

[ 0, 0, 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 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ] ]

[ "void FUNC_0 (ram_addr_t VAR_0, int VAR_1,\nconst char *VAR_2, DisplayState *VAR_3,\nconst char *VAR_4, const char *VAR_5,\nconst char *VAR_6, const char *VAR_7)\n{", "CPUState *env;", "struct etraxfs_pic *VAR_8;", "void *VAR_9;", "struct etraxfs_dma_client *VAR_10[2] = {NULL, NULL};", "int VAR_11;", "int VAR_12;", "ram_addr_t phys_ram;", "ram_addr_t phys_flash;", "ram_addr_t phys_intmem;", "if (VAR_7 == NULL) {", "VAR_7 = \"crisv32\";", "}", "env = cpu_init(VAR_7);", "qemu_register_reset(main_cpu_reset, env);", "phys_ram = qemu_ram_alloc(VAR_0);", "cpu_register_physical_memory(0x40000000, VAR_0, phys_ram | IO_MEM_RAM);", "phys_intmem = qemu_ram_alloc(INTMEM_SIZE);", "cpu_register_physical_memory(0x38000000, INTMEM_SIZE,\nphys_intmem | IO_MEM_RAM);", "phys_flash = qemu_ram_alloc(FLASH_SIZE);", "VAR_12 = drive_get_index(IF_PFLASH, 0, 0);", "pflash_cfi02_register(0x0, phys_flash,\nVAR_12 != -1 ? drives_table[VAR_12].bdrv : NULL, (64 * 1024),\nFLASH_SIZE >> 16,\n1, 2, 0x0000, 0x0000, 0x0000, 0x0000,\n0x555, 0x2aa);", "VAR_8 = etraxfs_pic_init(env, 0x3001c000);", "VAR_9 = etraxfs_dmac_init(env, 0x30000000, 10);", "for (VAR_12 = 0; VAR_12 < 10; VAR_12++) {", "etraxfs_dmac_connect(VAR_9, VAR_12, VAR_8->irq + 7 + VAR_12, VAR_12 & 1);", "}", "VAR_10[0] = etraxfs_eth_init(&nd_table[0], env, VAR_8->irq + 25, 0x30034000);", "if (nb_nics > 1)\nVAR_10[1] = etraxfs_eth_init(&nd_table[1], env, VAR_8->irq + 26, 0x30036000);", "etraxfs_dmac_connect_client(VAR_9, 0, VAR_10[0]);", "etraxfs_dmac_connect_client(VAR_9, 1, VAR_10[0] + 1);", "if (VAR_10[1]) {", "etraxfs_dmac_connect_client(VAR_9, 6, VAR_10[1]);", "etraxfs_dmac_connect_client(VAR_9, 7, VAR_10[1] + 1);", "}", "etraxfs_timer_init(env, VAR_8->irq + 0x1b, VAR_8->nmi + 1, 0x3001e000);", "etraxfs_timer_init(env, VAR_8->irq + 0x1b, VAR_8->nmi + 1, 0x3005e000);", "for (VAR_12 = 0; VAR_12 < 4; VAR_12++) {", "if (serial_hds[VAR_12]) {", "etraxfs_ser_init(env, VAR_8->irq + 0x14 + VAR_12,\nserial_hds[VAR_12], 0x30026000 + VAR_12 * 0x2000);", "}", "}", "if (VAR_4) {", "uint64_t entry, high;", "int VAR_13;", "VAR_11 = load_elf(VAR_4, -0x80000000LL,\n&entry, NULL, &high);", "bootstrap_pc = entry;", "if (VAR_11 < 0) {", "VAR_11 = load_image(VAR_4, phys_ram_base + 0x4000);", "bootstrap_pc = 0x40004000;", "env->regs[9] = 0x40004000 + VAR_11;", "}", "env->regs[8] = 0x56902387;", "if (VAR_5 && (VAR_13 = strlen(VAR_5))) {", "if (VAR_13 > 256) {", "fprintf(stderr, \"Too long CRIS kernel cmdline (max 256)\\n\");", "exit(1);", "}", "pstrcpy_targphys(high, 256, VAR_5);", "env->regs[10] = 0x87109563;", "env->regs[11] = high;", "}", "}", "env->pc = bootstrap_pc;", "printf (\"pc =%x\\n\", env->pc);", "printf (\"ram size =%ld\\n\", VAR_0);", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 47 ], [ 49 ], [ 57 ], [ 59, 61 ], [ 67 ], [ 69 ], [ 71, 73, 75, 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 97 ], [ 99, 101 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ], [ 207 ] ]

[ "static void FUNC_0(TCGContext *VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{", "TCGLabel *l = &VAR_0->labels[VAR_3];", "int VAR_4;", "if (l->has_value) {", "VAR_4 = INSN_OFF19(tcg_pcrel_diff(VAR_0, l->u.value_ptr));", "} else {", "VAR_4 = *VAR_0->code_ptr & INSN_OFF19(-1);", "tcg_out_reloc(VAR_0, VAR_0->code_ptr, R_SPARC_WDISP19, VAR_3, 0);", "}", "tcg_out_bpcc0(VAR_0, VAR_1, VAR_2, VAR_4);", "}" ]

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

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

[ "void FUNC_0 (CPUState *VAR_0, int VAR_1, const char *VAR_2,\nconst char *VAR_3,\nconst char *VAR_4)\n{", "int64_t entry = 0;", "long VAR_5, VAR_6;", "VAR_5 = load_elf(VAR_2, VIRT_TO_PHYS_ADDEND, &entry);", "if (VAR_5 >= 0) {", "if ((entry & ~0x7fffffffULL) == 0x80000000)\nentry = (int32_t)entry;", "VAR_0->PC = entry;", "} else {", "VAR_5 = load_image(VAR_2,\nphys_ram_base + KERNEL_LOAD_ADDR + VIRT_TO_PHYS_ADDEND);", "if (VAR_5 < 0) {", "fprintf(stderr, \"qemu: could not load kernel '%s'\\n\",\nVAR_2);", "exit(1);", "}", "VAR_0->PC = KERNEL_LOAD_ADDR;", "}", "VAR_6 = 0;", "if (VAR_4) {", "VAR_6 = load_image(VAR_4,\nphys_ram_base + INITRD_LOAD_ADDR + VIRT_TO_PHYS_ADDEND);", "if (VAR_6 == (target_ulong) -1) {", "fprintf(stderr, \"qemu: could not load initial ram disk '%s'\\n\",\nVAR_4);", "exit(1);", "}", "}", "if (VAR_6 > 0) {", "int VAR_7;", "VAR_7 = sprintf(phys_ram_base + (16 << 20) - 256,\n\"rd_start=0x\" TLSZ \" rd_size=%li \",\nINITRD_LOAD_ADDR,\nVAR_6);", "strcpy (phys_ram_base + (16 << 20) - 256 + VAR_7, VAR_3);", "}", "else {", "strcpy (phys_ram_base + (16 << 20) - 256, VAR_3);", "}", "*(int *)(phys_ram_base + (16 << 20) - 260) = tswap32 (0x12345678);", "*(int *)(phys_ram_base + (16 << 20) - 264) = tswap32 (VAR_1);", "}" ]

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

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

[ "static int FUNC_0(void)\n{", "struct sigaction VAR_0;", "PosixAioState *s;", "int VAR_1[2];", "struct qemu_paioinit VAR_2;", "if (posix_aio_state)\nreturn 0;", "s = qemu_malloc(sizeof(PosixAioState));", "sigfillset(&VAR_0.sa_mask);", "VAR_0.sa_flags = 0;", "VAR_0.sa_handler = aio_signal_handler;", "sigaction(SIGUSR2, &VAR_0, NULL);", "s->first_aio = NULL;", "if (pipe(VAR_1) == -1) {", "fprintf(stderr, \"failed to create pipe\\n\");", "return -errno;", "}", "s->rfd = VAR_1[0];", "s->wfd = VAR_1[1];", "fcntl(s->rfd, F_SETFL, O_NONBLOCK);", "fcntl(s->wfd, F_SETFL, O_NONBLOCK);", "qemu_aio_set_fd_handler(s->rfd, posix_aio_read, NULL, posix_aio_flush, s);", "memset(&VAR_2, 0, sizeof(VAR_2));", "VAR_2.aio_threads = 64;", "VAR_2.aio_num = 64;", "qemu_paio_init(&VAR_2);", "posix_aio_state = s;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 77 ], [ 79 ] ]

[ "FUNC_0(NetClientState *VAR_0, const uint8_t *VAR_1, size_t VAR_2)\n{", "E1000State *s = DO_UPCAST(NICState, VAR_0, VAR_0)->opaque;", "struct e1000_rx_desc VAR_3;", "dma_addr_t base;", "unsigned int VAR_4, VAR_5;", "uint32_t rdh_start;", "uint16_t vlan_special = 0;", "uint8_t vlan_status = 0, vlan_offset = 0;", "uint8_t min_buf[MIN_BUF_SIZE];", "size_t desc_offset;", "size_t desc_size;", "size_t total_size;", "if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))\nreturn -1;", "if (VAR_2 < sizeof(min_buf)) {", "memcpy(min_buf, VAR_1, VAR_2);", "memset(&min_buf[VAR_2], 0, sizeof(min_buf) - VAR_2);", "VAR_1 = min_buf;", "VAR_2 = sizeof(min_buf);", "}", "if (!receive_filter(s, VAR_1, VAR_2))\nreturn VAR_2;", "if (vlan_enabled(s) && is_vlan_packet(s, VAR_1)) {", "vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(VAR_1 + 14)));", "memmove((uint8_t *)VAR_1 + 4, VAR_1, 12);", "vlan_status = E1000_RXD_STAT_VP;", "vlan_offset = 4;", "VAR_2 -= 4;", "}", "rdh_start = s->mac_reg[RDH];", "desc_offset = 0;", "total_size = VAR_2 + fcs_len(s);", "if (!e1000_has_rxbufs(s, total_size)) {", "set_ics(s, 0, E1000_ICS_RXO);", "return -1;", "}", "do {", "desc_size = total_size - desc_offset;", "if (desc_size > s->rxbuf_size) {", "desc_size = s->rxbuf_size;", "}", "base = rx_desc_base(s) + sizeof(VAR_3) * s->mac_reg[RDH];", "pci_dma_read(&s->dev, base, &VAR_3, sizeof(VAR_3));", "VAR_3.special = vlan_special;", "VAR_3.status |= (vlan_status | E1000_RXD_STAT_DD);", "if (VAR_3.buffer_addr) {", "if (desc_offset < VAR_2) {", "size_t copy_size = VAR_2 - desc_offset;", "if (copy_size > s->rxbuf_size) {", "copy_size = s->rxbuf_size;", "}", "pci_dma_write(&s->dev, le64_to_cpu(VAR_3.buffer_addr),\nVAR_1 + desc_offset + vlan_offset, copy_size);", "}", "desc_offset += desc_size;", "VAR_3.length = cpu_to_le16(desc_size);", "if (desc_offset >= total_size) {", "VAR_3.status |= E1000_RXD_STAT_EOP | E1000_RXD_STAT_IXSM;", "} else {", "VAR_3.status &= ~E1000_RXD_STAT_EOP;", "}", "} else {", "DBGOUT(RX, \"Null RX descriptor!!\\VAR_4\");", "}", "pci_dma_write(&s->dev, base, &VAR_3, sizeof(VAR_3));", "if (++s->mac_reg[RDH] * sizeof(VAR_3) >= s->mac_reg[RDLEN])\ns->mac_reg[RDH] = 0;", "s->check_rxov = 1;", "if (s->mac_reg[RDH] == rdh_start) {", "DBGOUT(RXERR, \"RDH wraparound @%x, RDT %x, RDLEN %x\\VAR_4\",\nrdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);", "set_ics(s, 0, E1000_ICS_RXO);", "return -1;", "}", "} while (desc_offset < total_size);", "s->mac_reg[GPRC]++;", "s->mac_reg[TPR]++;", "VAR_4 = s->mac_reg[TORL] + VAR_2 + 4;", "if (VAR_4 < s->mac_reg[TORL])\ns->mac_reg[TORH]++;", "s->mac_reg[TORL] = VAR_4;", "VAR_4 = E1000_ICS_RXT0;", "if ((VAR_5 = s->mac_reg[RDT]) < s->mac_reg[RDH])\nVAR_5 += s->mac_reg[RDLEN] / sizeof(VAR_3);", "if (((VAR_5 - s->mac_reg[RDH]) * sizeof(VAR_3)) <= s->mac_reg[RDLEN] >>\ns->rxbuf_min_shift)\nVAR_4 |= E1000_ICS_RXDMT0;", "set_ics(s, 0, VAR_4);", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29, 31 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51, 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151, 153 ], [ 155 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 197 ], [ 199, 201 ], [ 203, 205, 207 ], [ 211 ], [ 215 ], [ 217 ] ]

[ "void FUNC_0(VirtQueue *VAR_0, unsigned int *VAR_1,\nunsigned int *VAR_2,\nunsigned VAR_3, unsigned VAR_4)\n{", "unsigned int VAR_5;", "unsigned int VAR_6, VAR_7, VAR_8;", "VAR_5 = VAR_0->last_avail_idx;", "VAR_6 = VAR_7 = VAR_8 = 0;", "while (virtqueue_num_heads(VAR_0, VAR_5)) {", "unsigned int VAR_9, VAR_10, VAR_11 = 0;", "hwaddr desc_pa;", "int VAR_12;", "VAR_9 = VAR_0->vring.num;", "VAR_10 = VAR_6;", "VAR_12 = virtqueue_get_head(VAR_0, VAR_5++);", "desc_pa = VAR_0->vring.desc;", "if (vring_desc_flags(desc_pa, VAR_12) & VRING_DESC_F_INDIRECT) {", "if (vring_desc_len(desc_pa, VAR_12) % sizeof(VRingDesc)) {", "error_report(\"Invalid size for VAR_11 buffer table\");", "exit(1);", "}", "if (VAR_10 >= VAR_9) {", "error_report(\"Looped descriptor\");", "exit(1);", "}", "VAR_11 = 1;", "VAR_9 = vring_desc_len(desc_pa, VAR_12) / sizeof(VRingDesc);", "VAR_10 = VAR_12 = 0;", "desc_pa = vring_desc_addr(desc_pa, VAR_12);", "}", "do {", "if (++VAR_10 > VAR_9) {", "error_report(\"Looped descriptor\");", "exit(1);", "}", "if (vring_desc_flags(desc_pa, VAR_12) & VRING_DESC_F_WRITE) {", "VAR_7 += vring_desc_len(desc_pa, VAR_12);", "} else {", "VAR_8 += vring_desc_len(desc_pa, VAR_12);", "}", "if (VAR_7 >= VAR_3 && VAR_8 >= VAR_4) {", "goto done;", "}", "} while ((VAR_12 = virtqueue_next_desc(desc_pa, VAR_12, VAR_9)) != VAR_9);", "if (!VAR_11)\nVAR_6 = VAR_10;", "else\nVAR_6++;", "}", "done:\nif (VAR_1) {", "*VAR_1 = VAR_7;", "}", "if (VAR_2) {", "*VAR_2 = VAR_8;", "}", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113, 115 ], [ 117, 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ] ]

[ "static void FUNC_0(ByteIOContext *VAR_0, const MXFDescriptorWriteTableEntry *VAR_1, AVStream *VAR_2)\n{", "const MXFCodecUL *VAR_3;", "put_buffer(VAR_0, VAR_1->key, 16);", "klv_encode_ber_length(VAR_0, 108);", "mxf_write_local_tag(VAR_0, 16, 0x3C0A);", "mxf_write_uuid(VAR_0, SubDescriptor, VAR_2->index);", "mxf_write_local_tag(VAR_0, 4, 0x3006);", "put_be32(VAR_0, VAR_2->index);", "mxf_write_local_tag(VAR_0, 8, 0x3001);", "put_be32(VAR_0, VAR_2->time_base.den);", "put_be32(VAR_0, VAR_2->time_base.num);", "VAR_3 = mxf_get_essence_container_ul(VAR_2->codec->codec_id);", "mxf_write_local_tag(VAR_0, 16, 0x3004);", "put_buffer(VAR_0, VAR_3->uid, 16);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ] ]

[ "static void FUNC_0(VirtIONet *VAR_0, int VAR_1, int VAR_2)\n{", "VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);", "int VAR_3, VAR_4 = VAR_1 ? VAR_0->max_queues : 1;", "VAR_0->VAR_1 = VAR_1;", "for (VAR_3 = 2; VAR_3 <= VAR_0->max_queues * 2 + 1; VAR_3++) {", "virtio_del_queue(vdev, VAR_3);", "}", "for (VAR_3 = 1; VAR_3 < VAR_4; VAR_3++) {", "VAR_0->vqs[VAR_3].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);", "if (VAR_0->vqs[VAR_3].tx_timer) {", "VAR_0->vqs[VAR_3].tx_vq =\nvirtio_add_queue(vdev, 256, virtio_net_handle_tx_timer);", "VAR_0->vqs[VAR_3].tx_timer = qemu_new_timer_ns(vm_clock,\nvirtio_net_tx_timer,\n&VAR_0->vqs[VAR_3]);", "} else {", "VAR_0->vqs[VAR_3].tx_vq =\nvirtio_add_queue(vdev, 256, virtio_net_handle_tx_bh);", "VAR_0->vqs[VAR_3].tx_bh = qemu_bh_new(virtio_net_tx_bh, &VAR_0->vqs[VAR_3]);", "}", "VAR_0->vqs[VAR_3].tx_waiting = 0;", "VAR_0->vqs[VAR_3].VAR_0 = VAR_0;", "}", "if (VAR_2) {", "VAR_0->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);", "}", "virtio_net_set_queues(VAR_0);", "}" ]

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

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

[ "int FUNC_0(const char *VAR_0,\nint VAR_1,\nint VAR_2,\nSaveLiveStateHandler *VAR_3,\nSaveStateHandler *VAR_4,\nLoadStateHandler *VAR_5,\nvoid *VAR_6)\n{", "SaveStateEntry *se;", "se = qemu_malloc(sizeof(SaveStateEntry));", "pstrcpy(se->VAR_0, sizeof(se->VAR_0), VAR_0);", "se->VAR_2 = VAR_2;", "se->section_id = global_section_id++;", "se->VAR_3 = VAR_3;", "se->VAR_4 = VAR_4;", "se->VAR_5 = VAR_5;", "se->VAR_6 = VAR_6;", "se->vmsd = NULL;", "if (VAR_1 == -1) {", "se->VAR_1 = calculate_new_instance_id(VAR_0);", "} else {", "se->VAR_1 = VAR_1;", "}", "TAILQ_INSERT_TAIL(&savevm_handlers, se, entry);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(const struct VAR_0 *VAR_0, int VAR_1,\nDisplayState *VAR_2, const char *VAR_3)\n{", "CPUState *env, *envs[MAX_CPUS];", "unsigned int VAR_4;", "void *VAR_5, *VAR_6, *VAR_7, *VAR_8;", "const sparc_def_t *VAR_9;", "qemu_irq *cpu_irqs[MAX_CPUS], *slavio_irq, *slavio_cpu_irq,\n*espdma_irq, *ledma_irq;", "sparc_find_by_name(VAR_3, &VAR_9);", "if (VAR_9 == NULL) {", "fprintf(stderr, \"Unable to find Sparc CPU definition\\n\");", "exit(1);", "}", "for(VAR_4 = 0; VAR_4 < smp_cpus; VAR_4++) {", "env = cpu_init();", "cpu_sparc_register(env, VAR_9);", "envs[VAR_4] = env;", "if (VAR_4 == 0) {", "qemu_register_reset(main_cpu_reset, env);", "} else {", "qemu_register_reset(secondary_cpu_reset, env);", "env->halted = 1;", "}", "register_savevm(\"cpu\", VAR_4, 3, cpu_save, cpu_load, env);", "cpu_irqs[VAR_4] = qemu_allocate_irqs(cpu_set_irq, envs[VAR_4], MAX_PILS);", "}", "for (VAR_4 = smp_cpus; VAR_4 < MAX_CPUS; VAR_4++)", "cpu_irqs[VAR_4] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS);", "cpu_register_physical_memory(0, VAR_1, 0);", "VAR_5 = iommu_init(VAR_0->iommu_base);", "slavio_intctl = slavio_intctl_init(VAR_0->intctl_base,\nVAR_0->intctl_base + 0x10000ULL,\n&VAR_0->intbit_to_level[0],\n&slavio_irq, &slavio_cpu_irq,\ncpu_irqs,\nVAR_0->clock_irq);", "VAR_6 = sparc32_dma_init(VAR_0->dma_base, slavio_irq[VAR_0->esp_irq],\nVAR_5, &espdma_irq);", "VAR_7 = sparc32_dma_init(VAR_0->dma_base + 16ULL,\nslavio_irq[VAR_0->le_irq], VAR_5, &ledma_irq);", "if (graphic_depth != 8 && graphic_depth != 24) {", "fprintf(stderr, \"qemu: Unsupported depth: %d\\n\", graphic_depth);", "exit (1);", "}", "tcx_init(VAR_2, VAR_0->tcx_base, phys_ram_base + VAR_1, VAR_1,\nVAR_0->vram_size, graphic_width, graphic_height, graphic_depth);", "if (nd_table[0].model == NULL\n|| strcmp(nd_table[0].model, \"lance\") == 0) {", "lance_init(&nd_table[0], VAR_0->le_base, VAR_7, *ledma_irq);", "} else if (strcmp(nd_table[0].model, \"?\") == 0) {", "fprintf(stderr, \"qemu: Supported NICs: lance\\n\");", "exit (1);", "} else {", "fprintf(stderr, \"qemu: Unsupported NIC: %s\\n\", nd_table[0].model);", "exit (1);", "}", "nvram = m48t59_init(slavio_irq[0], VAR_0->nvram_base, 0,\nVAR_0->nvram_size, 8);", "for (VAR_4 = 0; VAR_4 < MAX_CPUS; VAR_4++) {", "slavio_timer_init(VAR_0->counter_base +\n(target_phys_addr_t)(VAR_4 * TARGET_PAGE_SIZE),\nslavio_cpu_irq[VAR_4], 0);", "}", "slavio_timer_init(VAR_0->counter_base + 0x10000ULL,\nslavio_irq[VAR_0->clock1_irq], 2);", "slavio_serial_ms_kbd_init(VAR_0->ms_kb_base, slavio_irq[VAR_0->ms_kb_irq]);", "slavio_serial_init(VAR_0->serial_base, slavio_irq[VAR_0->ser_irq],\nserial_hds[1], serial_hds[0]);", "fdctrl_init(slavio_irq[VAR_0->fd_irq], 0, 1, VAR_0->fd_base, fd_table);", "VAR_8 = esp_init(bs_table, VAR_0->esp_base, VAR_6, *espdma_irq);", "for (VAR_4 = 0; VAR_4 < MAX_DISKS; VAR_4++) {", "if (bs_table[VAR_4]) {", "esp_scsi_attach(VAR_8, bs_table[VAR_4], VAR_4);", "}", "}", "slavio_misc = slavio_misc_init(VAR_0->slavio_base, VAR_0->power_base,\nslavio_irq[VAR_0->me_irq]);", "if (VAR_0->cs_base != (target_phys_addr_t)-1)\ncs_init(VAR_0->cs_base, VAR_0->cs_irq, slavio_intctl);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17, 19 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 73 ], [ 77 ], [ 79, 81, 83, 85, 87, 89 ], [ 93, 95 ], [ 97, 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 143 ], [ 145, 147, 149 ], [ 151 ], [ 153, 155 ], [ 157 ], [ 163, 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 185, 187 ], [ 189, 191 ], [ 193 ] ]

[ "static void FUNC_0(const char *VAR_0)\n{", "int VAR_1, VAR_2;", "int VAR_3;", "int VAR_4;", "char VAR_5[3 * W];", "FILE *fichier;", "fichier = fopen(VAR_0, \"rb\");", "if (!fichier) {", "perror(VAR_0);", "exit(1);", "}", "fread(VAR_5, 1, 15, fichier);", "for (VAR_1 = 0; VAR_1 < H; VAR_1++) {", "fread(VAR_5, 1, 3 * W, fichier);", "for (VAR_2 = 0; VAR_2 < W; VAR_2++) {", "tab_r[W * VAR_1 + VAR_2] = VAR_5[3 * VAR_2 ];", "tab_g[W * VAR_1 + VAR_2] = VAR_5[3 * VAR_2 + 1];", "tab_b[W * VAR_1 + VAR_2] = VAR_5[3 * VAR_2 + 2];", "}", "}", "fclose(fichier);", "for (VAR_1 = 0; VAR_1 < 360; VAR_1++) {", "VAR_4 = 2 * VAR_1 * MY_PI / 360;", "VAR_3 = 2 * FIXP + int_sin (VAR_4);", "h_cos[VAR_1] = VAR_3 * int_sin(VAR_4 + MY_PI / 2) / 2 / FIXP;", "h_sin[VAR_1] = VAR_3 * int_sin(VAR_4) / 2 / FIXP;", "}", "}" ]

[ 0, 0, 0, 0, 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 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1, int VAR_2)\n{", "InputStream *ist = VAR_0->opaque;", "QSVContext *qsv = ist->hwaccel_ctx;", "int VAR_3;", "for (VAR_3 = 0; VAR_3 < qsv->nb_surfaces; VAR_3++) {", "if (qsv->surface_used[VAR_3])\ncontinue;", "VAR_1->buf[0] = av_buffer_create((uint8_t*)qsv->surface_ptrs[VAR_3], sizeof(*qsv->surface_ptrs[VAR_3]),\nbuffer_release, &qsv->surface_used[VAR_3], 0);", "if (!VAR_1->buf[0])\nreturn AVERROR(ENOMEM);", "VAR_1->data[3] = (uint8_t*)qsv->surface_ptrs[VAR_3];", "qsv->surface_used[VAR_3] = 1;", "return 0;", "}", "return AVERROR(ENOMEM);", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0,\nAVPacket *VAR_1)\n{", "BVID_DemuxContext *vid = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "unsigned char VAR_2;", "int VAR_3;", "int VAR_4;", "if(vid->is_finished || pb->eof_reached)\nreturn AVERROR(EIO);", "VAR_2 = avio_r8(pb);", "switch(VAR_2){", "case PALETTE_BLOCK:\navio_seek(pb, -1, SEEK_CUR);", "VAR_4 = av_get_packet(pb, VAR_1, 3 * 256 + 1);", "if(VAR_4 != 3 * 256 + 1){", "av_free_packet(VAR_1);", "return AVERROR(EIO);", "}", "VAR_1->stream_index = 0;", "return VAR_4;", "case FIRST_AUDIO_BLOCK:\navio_rl16(pb);", "VAR_0->streams[1]->codec->sample_rate = 1000000 / (256 - avio_r8(pb));", "VAR_0->streams[1]->codec->bit_rate = VAR_0->streams[1]->codec->channels * VAR_0->streams[1]->codec->sample_rate * VAR_0->streams[1]->codec->bits_per_coded_sample;", "case AUDIO_BLOCK:\nVAR_3 = avio_rl16(pb);", "VAR_4 = av_get_packet(pb, VAR_1, VAR_3);", "VAR_1->stream_index = 1;", "return VAR_4 != VAR_3 ? AVERROR(EIO) : VAR_4;", "case VIDEO_P_FRAME:\ncase VIDEO_YOFF_P_FRAME:\ncase VIDEO_I_FRAME:\nreturn read_frame(vid, pb, VAR_1, VAR_2, VAR_0,\nVAR_0->streams[0]->codec->width * VAR_0->streams[0]->codec->height);", "case EOF_BLOCK:\nif(vid->nframes != 0)\nav_log(VAR_0, AV_LOG_VERBOSE, \"reached terminating character but not all frames read.\\n\");", "vid->is_finished = 1;", "return AVERROR(EIO);", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"unknown block (character = %c, decimal = %d, hex = %x)!!!\\n\",\nVAR_2, VAR_2, VAR_2); return -1;", "}", "}" ]

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

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

[ "void FUNC_0(LLSModel *VAR_0, double VAR_1, unsigned short VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "double (*VAR_6)[MAX_VARS_ALIGN] = (void *) &VAR_0->covariance[1][0];", "double (*VAR_7) [MAX_VARS_ALIGN] = (void *) &VAR_0->covariance[1][1];", "double *VAR_8 = VAR_0->covariance[0];", "int VAR_9 = VAR_0->indep_count;", "for (VAR_3 = 0; VAR_3 < VAR_9; VAR_3++) {", "for (VAR_4 = VAR_3; VAR_4 < VAR_9; VAR_4++) {", "double VAR_11 = VAR_7[VAR_3][VAR_4];", "for (VAR_5 = VAR_3 - 1; VAR_5 >= 0; VAR_5--)", "VAR_11 -= VAR_6[VAR_3][VAR_5] * VAR_6[VAR_4][VAR_5];", "if (VAR_3 == VAR_4) {", "if (VAR_11 < VAR_1)\nVAR_11 = 1.0;", "VAR_6[VAR_3][VAR_3] = sqrt(VAR_11);", "} else {", "VAR_6[VAR_4][VAR_3] = VAR_11 / VAR_6[VAR_3][VAR_3];", "}", "}", "}", "for (VAR_3 = 0; VAR_3 < VAR_9; VAR_3++) {", "double VAR_11 = VAR_8[VAR_3 + 1];", "for (VAR_5 = VAR_3 - 1; VAR_5 >= 0; VAR_5--)", "VAR_11 -= VAR_6[VAR_3][VAR_5] * VAR_0->coeff[0][VAR_5];", "VAR_0->coeff[0][VAR_3] = VAR_11 / VAR_6[VAR_3][VAR_3];", "}", "for (VAR_4 = VAR_9 - 1; VAR_4 >= VAR_2; VAR_4--) {", "for (VAR_3 = VAR_4; VAR_3 >= 0; VAR_3--) {", "double VAR_11 = VAR_0->coeff[0][VAR_3];", "for (VAR_5 = VAR_3 + 1; VAR_5 <= VAR_4; VAR_5++)", "VAR_11 -= VAR_6[VAR_5][VAR_3] * VAR_0->coeff[VAR_4][VAR_5];", "VAR_0->coeff[VAR_4][VAR_3] = VAR_11 / VAR_6[VAR_3][VAR_3];", "}", "VAR_0->variance[VAR_4] = VAR_8[0];", "for (VAR_3 = 0; VAR_3 <= VAR_4; VAR_3++) {", "double VAR_11 = VAR_0->coeff[VAR_4][VAR_3] * VAR_7[VAR_3][VAR_3] - 2 * VAR_8[VAR_3 + 1];", "for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++)", "VAR_11 += 2 * VAR_0->coeff[VAR_4][VAR_5] * VAR_7[VAR_5][VAR_3];", "VAR_0->variance[VAR_4] += VAR_0->coeff[VAR_4][VAR_3] * VAR_11;", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 89 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "HapContext *ctx = VAR_0->priv_data;", "int VAR_4 = hap_header_length(ctx);", "int VAR_5, VAR_6;", "int VAR_7 = FFMAX(ctx->tex_size, ctx->max_snappy * ctx->chunk_count) + VAR_4;", "VAR_6 = ff_alloc_packet2(VAR_0, VAR_1, VAR_7, VAR_4);", "if (VAR_6 < 0)\nreturn VAR_6;", "VAR_6 = compress_texture(VAR_0, ctx->tex_buf, ctx->tex_size, VAR_2);", "if (VAR_6 < 0)\nreturn VAR_6;", "VAR_5 = hap_compress_frame(VAR_0, VAR_1->data + VAR_4);", "if (VAR_5 < 0)\nreturn VAR_5;", "hap_write_frame_header(ctx, VAR_1->data, VAR_5 + VAR_4);", "av_shrink_packet(VAR_1, VAR_5 + VAR_4);", "VAR_1->flags |= AV_PKT_FLAG_KEY;", "*VAR_3 = 1;", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21, 23 ], [ 29 ], [ 31, 33 ], [ 39 ], [ 41, 43 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ] ]

[ "static void FUNC_0(MpegTSContext *VAR_0, unsigned int VAR_1, unsigned int VAR_2)\n{", "int VAR_3;", "struct Program *VAR_4 = NULL;", "for(VAR_3=0; VAR_3<VAR_0->nb_prg; VAR_3++) {", "if(VAR_0->prg[VAR_3].id == VAR_1) {", "VAR_4 = &VAR_0->prg[VAR_3];", "break;", "}", "}", "if(!VAR_4)\nreturn;", "if(VAR_4->nb_pids >= MAX_PIDS_PER_PROGRAM)\nreturn;", "VAR_4->pids[VAR_4->nb_pids++] = VAR_2;", "}" ]

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

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

[ "void FUNC_0(H261Context * VAR_0){", "MpegEncContext * const s = &VAR_0->s;", "int VAR_1;", "const int VAR_2 = s->VAR_2;", "const int VAR_3= s->VAR_3;", "uint8_t *dest_y = s->dest[0];", "uint8_t *dest_cb= s->dest[1];", "uint8_t *dest_cr= s->dest[2];", "uint8_t *src;", "CHECKED_ALLOCZ((src),sizeof(uint8_t) * 64 );", "for(VAR_1=0; VAR_1<8;VAR_1++)", "memcpy(src+VAR_1*8,dest_y+VAR_1*VAR_2,sizeof(uint8_t) * 8 );", "s->dsp.h261_v_loop_filter(dest_y, src, VAR_2);", "s->dsp.h261_h_loop_filter(dest_y, src, VAR_2);", "for(VAR_1=0; VAR_1<8;VAR_1++)", "memcpy(src+VAR_1*8,dest_y+VAR_1*VAR_2 + 8,sizeof(uint8_t) * 8 );", "s->dsp.h261_v_loop_filter(dest_y + 8, src, VAR_2);", "s->dsp.h261_h_loop_filter(dest_y + 8, src, VAR_2);", "for(VAR_1=0; VAR_1<8;VAR_1++)", "memcpy(src+VAR_1*8,dest_y+(VAR_1+8)*VAR_2,sizeof(uint8_t) * 8 );", "s->dsp.h261_v_loop_filter(dest_y + 8 * VAR_2, src, VAR_2);", "s->dsp.h261_h_loop_filter(dest_y + 8 * VAR_2, src, VAR_2);", "for(VAR_1=0; VAR_1<8;VAR_1++)", "memcpy(src+VAR_1*8,dest_y+(VAR_1+8)*VAR_2 + 8,sizeof(uint8_t) * 8 );", "s->dsp.h261_v_loop_filter(dest_y + 8 * VAR_2 + 8, src, VAR_2);", "s->dsp.h261_h_loop_filter(dest_y + 8 * VAR_2 + 8, src, VAR_2);", "for(VAR_1=0; VAR_1<8;VAR_1++)", "memcpy(src+VAR_1*8,dest_cb+VAR_1*VAR_3,sizeof(uint8_t) * 8 );", "s->dsp.h261_v_loop_filter(dest_cb, src, VAR_3);", "s->dsp.h261_h_loop_filter(dest_cb, src, VAR_3);", "for(VAR_1=0; VAR_1<8;VAR_1++)", "memcpy(src+VAR_1*8,dest_cr+VAR_1*VAR_3,sizeof(uint8_t) * 8 );", "s->dsp.h261_v_loop_filter(dest_cr, src, VAR_3);", "s->dsp.h261_h_loop_filter(dest_cr, src, VAR_3);", "fail:\nav_free(src);", "return;", "}" ]

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

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

[ "void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{", "avc_luma_midh_qrt_8w_msa(VAR_1 - (2 * VAR_2) - 2, VAR_2, VAR_0, VAR_2, 8, 1);", "}" ]

[ 0, 0, 0 ]

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

[ "FUNC_0(AVFormatContext *VAR_0, AVFormatParameters *VAR_1)\n{", "struct x11_grab *VAR_2 = VAR_0->priv_data;", "Display *dpy;", "AVStream *st = NULL;", "enum PixelFormat VAR_3;", "XImage *image;", "int VAR_4 = 0;", "int VAR_5 = 0;", "int VAR_6;", "char *VAR_7, *VAR_8;", "int VAR_9 = 0;", "AVRational framerate;", "VAR_7 = av_strdup(VAR_0->filename);", "VAR_8 = strchr(VAR_7, '+');", "if (VAR_8) {", "sscanf(VAR_8, \"%d,%d\", &VAR_4, &VAR_5);", "VAR_2->nomouse= strstr(VAR_8, \"nomouse\");", "*VAR_8= 0;", "}", "if ((VAR_9 = av_parse_video_size(&VAR_2->width, &VAR_2->height, VAR_2->video_size)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Couldn't parse video size.\\n\");", "goto out;", "}", "if ((VAR_9 = av_parse_video_rate(&framerate, VAR_2->framerate)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Could not parse framerate: %s.\\n\", VAR_2->framerate);", "goto out;", "}", "#if FF_API_FORMAT_PARAMETERS\nif (VAR_1->width > 0)\nVAR_2->width = VAR_1->width;", "if (VAR_1->height > 0)\nVAR_2->height = VAR_1->height;", "if (VAR_1->time_base.num)\nframerate = (AVRational){VAR_1->time_base.den, VAR_1->time_base.num};", "#endif\nav_log(VAR_0, AV_LOG_INFO, \"device: %s -> display: %s x: %d y: %d width: %d height: %d\\n\",\nVAR_0->filename, VAR_7, VAR_4, VAR_5, VAR_2->width, VAR_2->height);", "dpy = XOpenDisplay(VAR_7);", "if(!dpy) {", "av_log(VAR_0, AV_LOG_ERROR, \"Could not open X display.\\n\");", "VAR_9 = AVERROR(EIO);", "goto out;", "}", "st = av_new_stream(VAR_0, 0);", "if (!st) {", "VAR_9 = AVERROR(ENOMEM);", "goto out;", "}", "av_set_pts_info(st, 64, 1, 1000000);", "VAR_6 = XShmQueryExtension(dpy);", "av_log(VAR_0, AV_LOG_INFO, \"shared memory extension %s found\\n\", VAR_6 ? \"\" : \"not\");", "if(VAR_6) {", "int VAR_10 = XDefaultScreen(dpy);", "image = XShmCreateImage(dpy,\nDefaultVisual(dpy, VAR_10),\nDefaultDepth(dpy, VAR_10),\nZPixmap,\nNULL,\n&VAR_2->shminfo,\nVAR_2->width, VAR_2->height);", "VAR_2->shminfo.shmid = shmget(IPC_PRIVATE,\nimage->bytes_per_line * image->height,\nIPC_CREAT|0777);", "if (VAR_2->shminfo.shmid == -1) {", "av_log(VAR_0, AV_LOG_ERROR, \"Fatal: Can't get shared memory!\\n\");", "VAR_9 = AVERROR(ENOMEM);", "goto out;", "}", "VAR_2->shminfo.shmaddr = image->data = shmat(VAR_2->shminfo.shmid, 0, 0);", "VAR_2->shminfo.readOnly = False;", "if (!XShmAttach(dpy, &VAR_2->shminfo)) {", "av_log(VAR_0, AV_LOG_ERROR, \"Fatal: Failed to attach shared memory!\\n\");", "VAR_9 = AVERROR(EIO);", "goto out;", "}", "} else {", "image = XGetImage(dpy, RootWindow(dpy, DefaultScreen(dpy)),\nVAR_4,VAR_5,\nVAR_2->width, VAR_2->height,\nAllPlanes, ZPixmap);", "}", "switch (image->bits_per_pixel) {", "case 8:\nav_log (VAR_0, AV_LOG_DEBUG, \"8 bit palette\\n\");", "VAR_3 = PIX_FMT_PAL8;", "break;", "case 16:\nif ( image->red_mask == 0xf800 &&\nimage->green_mask == 0x07e0 &&\nimage->blue_mask == 0x001f ) {", "av_log (VAR_0, AV_LOG_DEBUG, \"16 bit RGB565\\n\");", "VAR_3 = PIX_FMT_RGB565;", "} else if (image->red_mask == 0x7c00 &&", "image->green_mask == 0x03e0 &&\nimage->blue_mask == 0x001f ) {", "av_log(VAR_0, AV_LOG_DEBUG, \"16 bit RGB555\\n\");", "VAR_3 = PIX_FMT_RGB555;", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"RGB ordering at image depth %i not supported ... aborting\\n\", image->bits_per_pixel);", "av_log(VAR_0, AV_LOG_ERROR, \"color masks: r 0x%.6lx g 0x%.6lx b 0x%.6lx\\n\", image->red_mask, image->green_mask, image->blue_mask);", "VAR_9 = AVERROR(EIO);", "goto out;", "}", "break;", "case 24:\nif ( image->red_mask == 0xff0000 &&\nimage->green_mask == 0x00ff00 &&\nimage->blue_mask == 0x0000ff ) {", "VAR_3 = PIX_FMT_BGR24;", "} else if ( image->red_mask == 0x0000ff &&", "image->green_mask == 0x00ff00 &&\nimage->blue_mask == 0xff0000 ) {", "VAR_3 = PIX_FMT_RGB24;", "} else {", "av_log(VAR_0, AV_LOG_ERROR,\"rgb ordering at image depth %i not supported ... aborting\\n\", image->bits_per_pixel);", "av_log(VAR_0, AV_LOG_ERROR, \"color masks: r 0x%.6lx g 0x%.6lx b 0x%.6lx\\n\", image->red_mask, image->green_mask, image->blue_mask);", "VAR_9 = AVERROR(EIO);", "goto out;", "}", "break;", "case 32:\nVAR_3 = PIX_FMT_RGB32;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"image depth %i not supported ... aborting\\n\", image->bits_per_pixel);", "VAR_9 = AVERROR(EINVAL);", "goto out;", "}", "VAR_2->frame_size = VAR_2->width * VAR_2->height * image->bits_per_pixel/8;", "VAR_2->dpy = dpy;", "VAR_2->time_base = (AVRational){framerate.den, framerate.num};", "VAR_2->time_frame = av_gettime() / av_q2d(VAR_2->time_base);", "VAR_2->VAR_4 = VAR_4;", "VAR_2->VAR_5 = VAR_5;", "VAR_2->image = image;", "VAR_2->VAR_6 = VAR_6;", "st->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "st->codec->codec_id = CODEC_ID_RAWVIDEO;", "st->codec->width = VAR_2->width;", "st->codec->height = VAR_2->height;", "st->codec->pix_fmt = VAR_3;", "st->codec->time_base = VAR_2->time_base;", "st->codec->bit_rate = VAR_2->frame_size * 1/av_q2d(VAR_2->time_base) * 8;", "out:\nreturn VAR_9;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63, 65 ], [ 67, 69 ], [ 71, 73 ], [ 75, 77, 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121, 123, 125, 127, 129, 131, 133 ], [ 135, 137, 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171, 173, 175, 177 ], [ 179 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193, 195, 197, 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 231, 233, 235 ], [ 237 ], [ 239 ], [ 241, 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267, 269 ], [ 271 ], [ 273 ], [ 275 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 313, 315 ], [ 317 ] ]

[ "static void FUNC_0(void)\n{", "int VAR_0;", "struct {", "const char *encoded;", "LiteralQObject decoded;", "} VAR_1[] = {", "{", ".encoded = \"[43,42]\",\n.decoded = QLIT_QLIST(((LiteralQObject[]){", "QLIT_QINT(43),\nQLIT_QINT(42),\n{ }", "})),", "},", "{", ".encoded = \"[43]\",\n.decoded = QLIT_QLIST(((LiteralQObject[]){", "QLIT_QINT(43),\n{ }", "})),", "},", "{", ".encoded = \"[]\",\n.decoded = QLIT_QLIST(((LiteralQObject[]){", "{ }", "})),", "},", "{", ".encoded = \"[{}]\",", ".decoded = QLIT_QLIST(((LiteralQObject[]){", "QLIT_QDICT(((LiteralQDictEntry[]){", "{},", "})),", "{},", "})),", "},", "{ }", "};", "for (VAR_0 = 0; VAR_1[VAR_0].encoded; VAR_0++) {", "QObject *obj;", "QString *str;", "obj = qobject_from_json(VAR_1[VAR_0].encoded, NULL);", "g_assert(compare_litqobj_to_qobj(&VAR_1[VAR_0].decoded, obj) == 1);", "str = qobject_to_json(obj);", "qobject_decref(obj);", "obj = qobject_from_json(qstring_get_str(str), NULL);", "g_assert(compare_litqobj_to_qobj(&VAR_1[VAR_0].decoded, obj) == 1);", "qobject_decref(obj);", "QDECREF(str);", "}", "}" ]

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

[ [ 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 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ] ]

[ "static inline void FUNC_0(yuv2yuyv422_1)(SwsContext *c, const uint16_t *buf0,\nconst uint16_t *ubuf0, const uint16_t *ubuf1,\nconst uint16_t *vbuf0, const uint16_t *vbuf1,\nconst uint16_t *abuf0, uint8_t *dest,\nint dstW, int uvalpha, enum PixelFormat dstFormat,\nint flags, int y)\n{", "x86_reg uv_off = c->uv_off << 1;", "const uint16_t *VAR_0= buf0;", "if (uvalpha < 2048) {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2PACKED1(%%REGBP, %5, %6)\nWRITEYUY2(%%REGb, 8280(%5), %%REGBP)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither), \"m\"(uv_off)\n);", "} else {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2PACKED1b(%%REGBP, %5, %6)\nWRITEYUY2(%%REGb, 8280(%5), %%REGBP)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither), \"m\"(uv_off)\n);", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "MigrationState *s = VAR_0;", "int VAR_1, VAR_2;", "socklen_t valsize = sizeof(VAR_1);", "DPRINTF(\"connect completed\\n\");", "do {", "VAR_2 = getsockopt(s->fd, SOL_SOCKET, SO_ERROR, (void *) &VAR_1, &valsize);", "} while (VAR_2 == -1 && (socket_error()) == EINTR);", "if (VAR_2 < 0) {", "migrate_fd_error(s);", "return;", "}", "qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);", "if (VAR_1 == 0)\nmigrate_fd_connect(s);", "else {", "DPRINTF(\"error connecting %d\\n\", VAR_1);", "migrate_fd_error(s);", "}", "}" ]

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

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

[ "static int FUNC_0(IpvideoContext *VAR_0)\n{", "int VAR_1, VAR_2;", "unsigned char VAR_3, VAR_4, VAR_5;", "CHECK_STREAM_PTR(1);", "VAR_3 = *VAR_0->stream_ptr++;", "VAR_4 = VAR_3 & 0x0F;", "VAR_5 = (VAR_3 >> 4) & 0x0F;", "VAR_1 = -8 + VAR_4;", "VAR_2 = -8 + VAR_5;", "debug_interplay (\" motion byte = %d, (VAR_1, VAR_2) = (%d, %d)\\n\", VAR_3, VAR_1, VAR_2);", "return copy_from(VAR_0, &VAR_0->last_frame, VAR_1, VAR_2);", "}" ]

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

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

[ "static int FUNC_0(HTTPContext *VAR_0, const char *VAR_1)\n{", "char VAR_2[128];", "char VAR_3[1024];", "AVFormatContext *s;", "int VAR_4, VAR_5, VAR_6;", "int64_t stream_pos;", "if (VAR_0->stream->feed) {", "strcpy(VAR_3, VAR_0->stream->feed->feed_filename);", "VAR_4 = FFM_PACKET_SIZE;", "if (find_info_tag(VAR_2, sizeof(VAR_2), \"date\", VAR_1)) {", "stream_pos = parse_date(VAR_2, 0);", "if (stream_pos == INT64_MIN)\nreturn -1;", "} else if (find_info_tag(VAR_2, sizeof(VAR_2), \"buffer\", VAR_1)) {", "int VAR_7 = strtol(VAR_2, 0, 10);", "stream_pos = av_gettime() - VAR_7 * (int64_t)1000000;", "} else", "stream_pos = av_gettime() - VAR_0->stream->VAR_7 * (int64_t)1000;", "} else {", "strcpy(VAR_3, VAR_0->stream->feed_filename);", "VAR_4 = 0;", "if (find_info_tag(VAR_2, sizeof(VAR_2), \"date\", VAR_1)) {", "stream_pos = parse_date(VAR_2, 1);", "if (stream_pos == INT64_MIN)\nreturn -1;", "} else", "stream_pos = 0;", "}", "if (VAR_3[0] == '\\0')\nreturn -1;", "#if 0\n{ time_t when = stream_pos / 1000000;", "http_log(\"Stream pos = %\"PRId64\", time=%s\", stream_pos, ctime(&when));", "}", "#endif\nif ((VAR_6 = av_open_input_file(&s, VAR_3, VAR_0->stream->ifmt,\nVAR_4, VAR_0->stream->ap_in)) < 0) {", "http_log(\"could not open %s: %d\\n\", VAR_3, VAR_6);", "return -1;", "}", "s->flags |= AVFMT_FLAG_GENPTS;", "VAR_0->fmt_in = s;", "av_find_stream_info(VAR_0->fmt_in);", "for(VAR_5=0;VAR_5<s->nb_streams;VAR_5++)", "open_parser(s, VAR_5);", "VAR_0->pts_stream_index = 0;", "for(VAR_5=0;VAR_5<VAR_0->stream->nb_streams;VAR_5++) {", "if (VAR_0->pts_stream_index == 0 &&\nVAR_0->stream->streams[VAR_5]->codec->codec_type == CODEC_TYPE_VIDEO) {", "VAR_0->pts_stream_index = VAR_5;", "}", "}", "#if 1\nif (VAR_0->fmt_in->iformat->read_seek)\nav_seek_frame(VAR_0->fmt_in, -1, stream_pos, 0);", "#endif\nVAR_0->start_time = cur_time;", "VAR_0->first_pts = AV_NOPTS_VALUE;", "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 ]

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

[ "static int FUNC_0(RTPDemuxContext *VAR_0, const unsigned char *VAR_1,\nint VAR_2)\n{", "int VAR_3;", "while (VAR_2 >= 4) {", "VAR_3 = FFMIN(VAR_2, (AV_RB16(VAR_1 + 2) + 1) * 4);", "switch (VAR_1[1]) {", "case RTCP_SR:\nif (VAR_3 < 20) {", "av_log(NULL, AV_LOG_ERROR,\n\"Invalid length for RTCP SR packet\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->last_rtcp_reception_time = av_gettime_relative();", "VAR_0->last_rtcp_ntp_time = AV_RB64(VAR_1 + 8);", "VAR_0->last_rtcp_timestamp = AV_RB32(VAR_1 + 16);", "if (VAR_0->first_rtcp_ntp_time == AV_NOPTS_VALUE) {", "VAR_0->first_rtcp_ntp_time = VAR_0->last_rtcp_ntp_time;", "if (!VAR_0->base_timestamp)\nVAR_0->base_timestamp = VAR_0->last_rtcp_timestamp;", "VAR_0->rtcp_ts_offset = VAR_0->last_rtcp_timestamp - VAR_0->base_timestamp;", "}", "break;", "case RTCP_BYE:\nreturn -RTCP_BYE;", "}", "VAR_1 += VAR_3;", "VAR_2 -= VAR_3;", "}", "return -1;", "}" ]

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

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

[ "void FUNC_0(uint8_t* VAR_0, int VAR_1, vector_s16_t* VAR_2)\n{", "POWERPC_TBL_DECLARE(altivec_idct_add_num, 1);", "#ifdef ALTIVEC_USE_REFERENCE_C_CODE\nPOWERPC_TBL_START_COUNT(altivec_idct_add_num, 1);", "void simple_idct_add(uint8_t *VAR_0, int line_size, int16_t *VAR_2);", "simple_idct_add(VAR_0, VAR_1, (int16_t*)VAR_2);", "POWERPC_TBL_STOP_COUNT(altivec_idct_add_num, 1);", "#else\nvector_u8_t tmp;", "vector_s16_t tmp2, tmp3;", "vector_u8_t perm0;", "vector_u8_t perm1;", "vector_u8_t p0, p1, p;", "POWERPC_TBL_START_COUNT(altivec_idct_add_num, 1);", "IDCT\np0 = vec_lvsl (0, VAR_0);", "p1 = vec_lvsl (VAR_1, VAR_0);", "p = vec_splat_u8 (-1);", "perm0 = vec_mergeh (p, p0);", "perm1 = vec_mergeh (p, p1);", "#define ADD(VAR_0,src,perm)\t\t\t\t\t\t\\\n\\\ntmp = vec_ld (0, VAR_0);\t\t\t\t\t\t\\", "tmp2 = (vector_s16_t)vec_perm (tmp, (vector_u8_t)zero, perm);\t\\", "tmp3 = vec_adds (tmp2, src);\t\t\t\t\t\\", "tmp = vec_packsu (tmp3, tmp3);\t\t\t\t\t\\", "vec_ste ((vector_u32_t)tmp, 0, (unsigned int *)VAR_0);\t\t\\", "vec_ste ((vector_u32_t)tmp, 4, (unsigned int *)VAR_0);", "ADD (VAR_0, vx0, perm0)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx1, perm1)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx2, perm0)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx3, perm1)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx4, perm0)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx5, perm1)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx6, perm0)\tVAR_0 += VAR_1;", "ADD (VAR_0, vx7, perm1)\nPOWERPC_TBL_STOP_COUNT(altivec_idct_add_num, 1);", "#endif\n}" ]

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

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

[ "AVBufferRef *FUNC_0(int size)\n{", "AVBufferRef *ret = NULL;", "uint8_t *data = NULL;", "data = av_malloc(size);", "if (!data)\nreturn NULL;", "if(CONFIG_MEMORY_POISONING)\nmemset(data, 0x2a, size);", "ret = av_buffer_create(data, size, av_buffer_default_free, NULL, 0);", "if (!ret)\nav_freep(&data);", "return ret;", "}" ]

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

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

[ "void FUNC_0(PCIDevice *VAR_0, unsigned VAR_1)\n{", "MSIMessage msg;", "if (VAR_1 >= VAR_0->msix_entries_nr || !VAR_0->msix_entry_used[VAR_1])\nreturn;", "if (msix_is_masked(VAR_0, VAR_1)) {", "msix_set_pending(VAR_0, VAR_1);", "return;", "}", "msg = msix_get_message(VAR_0, VAR_1);", "stl_le_phys(&address_space_memory, msg.address, msg.data);", "}" ]

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

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

[ "void FUNC_0(PCIDevice *VAR_0, uint32_t VAR_1, uint32_t VAR_2, int VAR_3)\n{", "uint16_t flags = pci_get_word(VAR_0->config + msi_flags_off(VAR_0));", "bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;", "bool msi_per_vector_mask = flags & PCI_MSI_FLAGS_MASKBIT;", "unsigned int VAR_4;", "uint8_t log_num_vecs;", "uint8_t log_max_vecs;", "unsigned int VAR_5;", "uint32_t pending;", "if (!ranges_overlap(VAR_1, VAR_3, VAR_0->msi_cap, msi_cap_sizeof(flags))) {", "return;", "}", "#ifdef MSI_DEBUG\nMSI_DEV_PRINTF(VAR_0, \"VAR_1 0x%\"PRIx32\" VAR_2 0x%\"PRIx32\" VAR_3 %d\\n\",\nVAR_1, VAR_2, VAR_3);", "MSI_DEV_PRINTF(VAR_0, \"ctrl: 0x%\"PRIx16\" address: 0x%\"PRIx32,\nflags,\npci_get_long(VAR_0->config + msi_address_lo_off(VAR_0)));", "if (msi64bit) {", "fprintf(stderr, \" address-hi: 0x%\"PRIx32,\npci_get_long(VAR_0->config + msi_address_hi_off(VAR_0)));", "}", "fprintf(stderr, \" data: 0x%\"PRIx16,\npci_get_word(VAR_0->config + msi_data_off(VAR_0, msi64bit)));", "if (flags & PCI_MSI_FLAGS_MASKBIT) {", "fprintf(stderr, \" mask 0x%\"PRIx32\" pending 0x%\"PRIx32,\npci_get_long(VAR_0->config + msi_mask_off(VAR_0, msi64bit)),\npci_get_long(VAR_0->config + msi_pending_off(VAR_0, msi64bit)));", "}", "fprintf(stderr, \"\\n\");", "#endif\nif (!(flags & PCI_MSI_FLAGS_ENABLE)) {", "return;", "}", "pci_device_deassert_intx(VAR_0);", "log_num_vecs =\n(flags & PCI_MSI_FLAGS_QSIZE) >> (ffs(PCI_MSI_FLAGS_QSIZE) - 1);", "log_max_vecs =\n(flags & PCI_MSI_FLAGS_QMASK) >> (ffs(PCI_MSI_FLAGS_QMASK) - 1);", "if (log_num_vecs > log_max_vecs) {", "flags &= ~PCI_MSI_FLAGS_QSIZE;", "flags |= log_max_vecs << (ffs(PCI_MSI_FLAGS_QSIZE) - 1);", "pci_set_word(VAR_0->config + msi_flags_off(VAR_0), flags);", "}", "if (!msi_per_vector_mask) {", "return;", "}", "VAR_4 = msi_nr_vectors(flags);", "pending = pci_get_long(VAR_0->config + msi_pending_off(VAR_0, msi64bit));", "pending &= 0xffffffff >> (PCI_MSI_VECTORS_MAX - VAR_4);", "pci_set_long(VAR_0->config + msi_pending_off(VAR_0, msi64bit), pending);", "for (VAR_5 = 0; VAR_5 < VAR_4; ++VAR_5) {", "if (msi_is_masked(VAR_0, VAR_5) || !(pending & (1U << VAR_5))) {", "continue;", "}", "pci_long_test_and_clear_mask(\nVAR_0->config + msi_pending_off(VAR_0, msi64bit), 1U << VAR_5);", "msi_notify(VAR_0, 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 31, 33, 35 ], [ 37, 39, 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57, 59, 61 ], [ 63 ], [ 65 ], [ 67, 71 ], [ 73 ], [ 75 ], [ 101 ], [ 115, 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 141 ], [ 143 ], [ 147 ], [ 153 ], [ 155 ], [ 157 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181 ] ]

[ "static bool FUNC_0(void)\n{", "PCMachineState *pcms = PC_MACHINE(qdev_get_machine());", "return pcms->nvdimm;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "void FUNC_0(IDEState *VAR_0)\n{", "if (VAR_0->bs == NULL) {", "ide_flush_cb(VAR_0, 0);", "return;", "}", "VAR_0->status |= BUSY_STAT;", "block_acct_start(bdrv_get_stats(VAR_0->bs), &VAR_0->acct, 0, BLOCK_ACCT_FLUSH);", "VAR_0->pio_aiocb = bdrv_aio_flush(VAR_0->bs, ide_flush_cb, VAR_0);", "}" ]

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

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

[ "FUNC_0(E1000State *VAR_0)\n{", "return (VAR_0->compat_flags & E1000_FLAG_AUTONEG) &&\n(VAR_0->phy_reg[PHY_CTRL] & MII_CR_AUTO_NEG_EN);", "}" ]

[ 0, 0, 0 ]

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

[ "qemu_irq *FUNC_0 (MemoryRegion *address_space, hwaddr base,\nint nb_cpus, qemu_irq **irqs, qemu_irq irq_out)\n{", "OpenPICState *mpp;", "int VAR_0;", "struct {", "const char *name;", "MemoryRegionOps const *ops;", "hwaddr start_addr;", "ram_addr_t size;", "} const VAR_1[] = {", "{\"glb\", &openpic_glb_ops_be, MPIC_GLB_REG_START, MPIC_GLB_REG_SIZE},", "{\"tmr\", &openpic_tmr_ops_be, MPIC_TMR_REG_START, MPIC_TMR_REG_SIZE},", "{\"src\", &openpic_src_ops_be, MPIC_SRC_REG_START, MPIC_SRC_REG_SIZE},", "{\"cpu\", &openpic_cpu_ops_be, MPIC_CPU_REG_START, MPIC_CPU_REG_SIZE},", "};", "mpp = g_malloc0(sizeof(OpenPICState));", "memory_region_init(&mpp->mem, \"mpic\", 0x40000);", "memory_region_add_subregion(address_space, base, &mpp->mem);", "for (VAR_0 = 0; VAR_0 < sizeof(VAR_1)/sizeof(VAR_1[0]); VAR_0++) {", "memory_region_init_io(&mpp->sub_io_mem[VAR_0], VAR_1[VAR_0].ops, mpp,\nVAR_1[VAR_0].name, VAR_1[VAR_0].size);", "memory_region_add_subregion(&mpp->mem, VAR_1[VAR_0].start_addr,\n&mpp->sub_io_mem[VAR_0]);", "}", "mpp->nb_cpus = nb_cpus;", "mpp->nb_irqs = 80;", "mpp->vid = VID_REVISION_1_2;", "mpp->veni = VENI_GENERIC;", "mpp->spve_mask = 0xFFFF;", "mpp->tifr_reset = 0x00000000;", "mpp->ipvp_reset = 0x80000000;", "mpp->ide_reset = 0x00000001;", "mpp->max_irq = MPIC_MAX_IRQ;", "mpp->irq_ipi0 = MPIC_IPI_IRQ;", "mpp->irq_tim0 = MPIC_TMR_IRQ;", "for (VAR_0 = 0; VAR_0 < nb_cpus; VAR_0++)", "mpp->dst[VAR_0].irqs = irqs[VAR_0];", "mpp->irq_out = irq_out;", "mpp->flags |= OPENPIC_FLAG_IDE_CRIT;", "register_savevm(NULL, \"mpic\", 0, 2, openpic_save, openpic_load, mpp);", "qemu_register_reset(openpic_reset, mpp);", "return qemu_allocate_irqs(openpic_set_irq, mpp, mpp->max_irq);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 45 ], [ 49, 51 ], [ 55, 57 ], [ 59 ], [ 63 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 101 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ] ]

[ "static void FUNC_0(Visitor *VAR_0, void **VAR_1)\n{", "QmpOutputVisitor *qov = to_qov(VAR_0);", "QObject *value = qmp_output_pop(qov, VAR_1);", "assert(qobject_type(value) == QTYPE_QLIST);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "void FUNC_0(BlockConf *VAR_0, int *VAR_1,\nunsigned VAR_2, unsigned VAR_3, unsigned VAR_4,\nError **VAR_5)\n{", "DriveInfo *dinfo;", "if (!VAR_0->cyls && !VAR_0->heads && !VAR_0->secs) {", "dinfo = drive_get_by_blockdev(VAR_0->bs);", "VAR_0->cyls = dinfo->cyls;", "VAR_0->heads = dinfo->heads;", "VAR_0->secs = dinfo->secs;", "if (VAR_1) {", "*VAR_1 = dinfo->trans;", "}", "}", "if (!VAR_0->cyls && !VAR_0->heads && !VAR_0->secs) {", "hd_geometry_guess(VAR_0->bs,\n&VAR_0->cyls, &VAR_0->heads, &VAR_0->secs,\nVAR_1);", "} else if (VAR_1 && *VAR_1 == BIOS_ATA_TRANSLATION_AUTO) {", "*VAR_1 = hd_bios_chs_auto_trans(VAR_0->cyls, VAR_0->heads, VAR_0->secs);", "}", "if (VAR_0->cyls || VAR_0->heads || VAR_0->secs) {", "if (VAR_0->cyls < 1 || VAR_0->cyls > VAR_2) {", "error_setg(VAR_5, \"cyls must be between 1 and %u\", VAR_2);", "return;", "}", "if (VAR_0->heads < 1 || VAR_0->heads > VAR_3) {", "error_setg(VAR_5, \"heads must be between 1 and %u\", VAR_3);", "return;", "}", "if (VAR_0->secs < 1 || VAR_0->secs > VAR_4) {", "error_setg(VAR_5, \"secs must be between 1 and %u\", VAR_4);", "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 ]

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

[ "static void FUNC_0(StrongARMPPCInfo *VAR_0)\n{", "uint32_t level, diff;", "int VAR_1;", "level = VAR_0->olevel & VAR_0->dir;", "for (diff = VAR_0->prev_level ^ level; diff; diff ^= 1 << VAR_1) {", "VAR_1 = ffs(diff) - 1;", "qemu_set_irq(VAR_0->handler[VAR_1], (level >> VAR_1) & 1);", "}", "VAR_0->prev_level = level;", "}" ]

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

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

[ "sPAPRTCETable *FUNC_0(DeviceState *owner, uint32_t liobn, size_t window_size)\n{", "sPAPRTCETable *tcet;", "if (spapr_tce_find_by_liobn(liobn)) {", "fprintf(stderr, \"Attempted to create TCE table with duplicate\"\n\" LIOBN 0x%x\\n\", liobn);", "return NULL;", "}", "if (!window_size) {", "return NULL;", "}", "tcet = g_malloc0(sizeof(*tcet));", "tcet->liobn = liobn;", "tcet->window_size = window_size;", "if (kvm_enabled()) {", "tcet->table = kvmppc_create_spapr_tce(liobn,\nwindow_size,\n&tcet->fd);", "}", "if (!tcet->table) {", "size_t table_size = (window_size >> SPAPR_TCE_PAGE_SHIFT)\n* sizeof(sPAPRTCE);", "tcet->table = g_malloc0(table_size);", "}", "#ifdef DEBUG_TCE\nfprintf(stderr, \"spapr_iommu: New TCE table @ %p, liobn=0x%x, \"\n\"table @ %p, fd=%d\\n\", tcet, liobn, tcet->table, tcet->fd);", "#endif\nmemory_region_init_iommu(&tcet->iommu, OBJECT(owner), &spapr_iommu_ops,\n\"iommu-spapr\", UINT64_MAX);", "QLIST_INSERT_HEAD(&spapr_tce_tables, tcet, list);", "return tcet;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39, 41, 43 ], [ 45 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 61, 63, 65 ], [ 67, 71, 73 ], [ 77 ], [ 81 ], [ 83 ] ]

[ "static void FUNC_0(MemoryListener *VAR_0,\nMemoryRegionSection *VAR_1,\nbool VAR_2)\n{", "struct vhost_dev *VAR_3 = container_of(VAR_0, struct vhost_dev,\nmemory_listener);", "hwaddr start_addr = VAR_1->offset_within_address_space;", "ram_addr_t size = int128_get64(VAR_1->size);", "bool log_dirty = memory_region_is_logging(VAR_1->mr);", "int VAR_4 = offsetof(struct vhost_memory, regions) +\n(VAR_3->mem->nregions + 1) * sizeof VAR_3->mem->regions[0];", "void *VAR_5;", "VAR_3->mem = g_realloc(VAR_3->mem, VAR_4);", "if (log_dirty) {", "VAR_2 = false;", "}", "assert(size);", "VAR_5 = memory_region_get_ram_ptr(VAR_1->mr) + VAR_1->offset_within_region;", "if (VAR_2) {", "if (!vhost_dev_cmp_memory(VAR_3, start_addr, size, (uintptr_t)VAR_5)) {", "return;", "}", "} else {", "if (!vhost_dev_find_reg(VAR_3, start_addr, size)) {", "return;", "}", "}", "vhost_dev_unassign_memory(VAR_3, start_addr, size);", "if (VAR_2) {", "vhost_dev_assign_memory(VAR_3, start_addr, size, (uintptr_t)VAR_5);", "} else {", "vhost_dev_unassign_memory(VAR_3, start_addr, size);", "}", "VAR_3->mem_changed_start_addr = MIN(VAR_3->mem_changed_start_addr, start_addr);", "VAR_3->mem_changed_end_addr = MAX(VAR_3->mem_changed_end_addr, start_addr + size - 1);", "VAR_3->memory_changed = true;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ] ]

[ "static void FUNC_0(int VAR_0, struct target_sigaction *VAR_1,\ntarget_siginfo_t *VAR_2,\ntarget_sigset_t *VAR_3, CPUS390XState *VAR_4)\n{", "int VAR_5;", "rt_sigframe *frame;", "abi_ulong frame_addr;", "frame_addr = get_sigframe(VAR_1, VAR_4, sizeof *frame);", "qemu_log(\"%s: frame_addr 0x%llx\\n\", __FUNCTION__,\n(unsigned long long)frame_addr);", "if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {", "goto give_sigsegv;", "}", "qemu_log(\"%s: 1\\n\", __FUNCTION__);", "if (copy_siginfo_to_user(&frame->VAR_2, VAR_2)) {", "goto give_sigsegv;", "}", "__put_user(0, &frame->uc.tuc_flags);", "__put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);", "__put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);", "__put_user(sas_ss_flags(get_sp_from_cpustate(VAR_4)),\n&frame->uc.tuc_stack.ss_flags);", "__put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);", "save_sigregs(VAR_4, &frame->uc.tuc_mcontext);", "for (VAR_5 = 0; VAR_5 < TARGET_NSIG_WORDS; VAR_5++) {", "__put_user((abi_ulong)VAR_3->VAR_0[VAR_5],\n(abi_ulong *)&frame->uc.tuc_sigmask.VAR_0[VAR_5]);", "}", "if (VAR_1->sa_flags & TARGET_SA_RESTORER) {", "VAR_4->regs[14] = (unsigned long) VAR_1->sa_restorer | PSW_ADDR_AMODE;", "} else {", "VAR_4->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;", "if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,\n(uint16_t *)(frame->retcode))) {", "goto give_sigsegv;", "}", "}", "if (__put_user(VAR_4->regs[15], (abi_ulong *) frame)) {", "goto give_sigsegv;", "}", "VAR_4->regs[15] = frame_addr;", "VAR_4->psw.addr = (target_ulong) VAR_1->_sa_handler | PSW_ADDR_AMODE;", "VAR_4->regs[2] = VAR_0;", "VAR_4->regs[3] = frame_addr + offsetof(typeof(*frame), VAR_2);", "VAR_4->regs[4] = frame_addr + offsetof(typeof(*frame), uc);", "return;", "give_sigsegv:\nqemu_log(\"%s: give_sigsegv\\n\", __FUNCTION__);", "unlock_user_struct(frame, frame_addr, 1);", "force_sig(TARGET_SIGSEGV);", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 93 ], [ 95 ], [ 97 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ] ]

[ "static int64_t FUNC_0(BlockDriverState *bs, int64_t size)\n{", "BDRVQcowState *s = bs->opaque;", "int VAR_0, VAR_1;", "VAR_1 = size_to_clusters(s, size);", "retry:\nfor(VAR_0 = 0; VAR_0 < VAR_1; VAR_0++) {", "int64_t VAR_0 = s->free_cluster_index++;", "if (get_refcount(bs, VAR_0) != 0)\ngoto retry;", "}", "#ifdef DEBUG_ALLOC2\nprintf(\"alloc_clusters: size=%\" PRId64 \" -> %\" PRId64 \"\\n\",\nsize,\n(s->free_cluster_index - VAR_1) << s->cluster_bits);", "#endif\nreturn (s->free_cluster_index - VAR_1) << s->cluster_bits;", "}" ]

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

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

[ "static inline int FUNC_0(uint32_t VAR_0, uint32_t *VAR_1, int VAR_2)\n{", "int VAR_3;", "for(VAR_3 = 0; VAR_3 < VAR_2; VAR_3++, VAR_1++, VAR_0 += sizeof(*VAR_1)) {", "cpu_physical_memory_rw(VAR_0,(uint8_t *)VAR_1, sizeof(*VAR_1), 0);", "*VAR_1 = le32_to_cpu(*VAR_1);", "}", "return 1;", "}" ]

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

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

[ "static long FUNC_0(unsigned long VAR_0, unsigned long VAR_1,\nunsigned long VAR_2)\n{", "register ulong VAR_3 asm(\"1\") = VAR_0;", "register ulong VAR_4 asm(\"2\") = VAR_1;", "register ulong VAR_5 asm(\"3\") = VAR_2;", "register long VAR_6 asm(\"2\");", "asm volatile (\"diag 2,4,0x500\"\n: \"=d\" (VAR_6)\n: \"d\" (VAR_3), \"0\" (VAR_4), \"r\"(VAR_5)\n: \"memory\", \"cc\");", "return VAR_6;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "int VAR_0;", "cpu_register_io_memory_fixed(IO_MEM_ROM, error_mem_read, unassigned_mem_write, NULL);", "cpu_register_io_memory_fixed(IO_MEM_UNASSIGNED, unassigned_mem_read, unassigned_mem_write, NULL);", "cpu_register_io_memory_fixed(IO_MEM_NOTDIRTY, error_mem_read, notdirty_mem_write, NULL);", "for (VAR_0=0; VAR_0<5; VAR_0++)", "io_mem_used[VAR_0] = 1;", "io_mem_watch = cpu_register_io_memory(watch_mem_read,\nwatch_mem_write, NULL);", "#ifdef CONFIG_KQEMU\nif (kqemu_phys_ram_base) {", "phys_ram_dirty = qemu_vmalloc(kqemu_phys_ram_size >> TARGET_PAGE_BITS);", "memset(phys_ram_dirty, 0xff, kqemu_phys_ram_size >> TARGET_PAGE_BITS);", "}", "#endif\n}" ]

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

[ "static size_t FUNC_0(QEMUFile *f, void *opaque,\nram_addr_t block_offset, ram_addr_t offset,\nsize_t size, int *bytes_sent)\n{", "QEMUFileRDMA *rfile = opaque;", "RDMAContext *rdma = rfile->rdma;", "int VAR_1;", "CHECK_ERROR_STATE();", "qemu_fflush(f);", "if (size > 0) {", "VAR_1 = qemu_rdma_write(f, rdma, block_offset, offset, size);", "if (VAR_1 < 0) {", "fprintf(stderr, \"rdma migration: write error! %d\\n\", VAR_1);", "goto err;", "}", "if (bytes_sent) {", "*bytes_sent = 1;", "}", "} else {", "uint64_t index, chunk;", "VAR_1 = qemu_rdma_search_ram_block(rdma, block_offset,\noffset, size, &index, &chunk);", "if (VAR_1) {", "fprintf(stderr, \"ram block search failed\\n\");", "goto err;", "}", "qemu_rdma_signal_unregister(rdma, index, chunk, 0);", "}", "while (1) {", "uint64_t wr_id, wr_id_in;", "int VAR_1 = qemu_rdma_poll(rdma, &wr_id_in);", "if (VAR_1 < 0) {", "fprintf(stderr, \"rdma migration: polling error! %d\\n\", VAR_1);", "goto err;", "}", "wr_id = wr_id_in & RDMA_WRID_TYPE_MASK;", "if (wr_id == RDMA_WRID_NONE) {", "break;", "}", "}", "return RAM_SAVE_CONTROL_DELAYED;", "err:\nrdma->error_state = VAR_1;", "return VAR_1;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 25 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 99, 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 135 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ] ]

[ "static unsigned FUNC_0(const uint8_t **VAR_0, int VAR_1, int VAR_2)\n{", "switch (VAR_1) {", "case TIFF_BYTE : return *(*VAR_0)++;", "case TIFF_SHORT: return tget_short(VAR_0, VAR_2);", "case TIFF_LONG : return tget_long(VAR_0, VAR_2);", "default : return UINT_MAX;", "}", "}" ]

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

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

[ "static void FUNC_0(int VAR_0)\n{", "TCGContext *s = &tcg_ctx;", "TCGTemp *ts;", "int VAR_1;", "#if defined(CONFIG_DEBUG_TCG)\ns->temps_in_use--;", "if (s->temps_in_use < 0) {", "fprintf(stderr, \"More temporaries freed than allocated!\\n\");", "}", "#endif\nassert(VAR_0 >= s->nb_globals && VAR_0 < s->nb_temps);", "ts = &s->temps[VAR_0];", "assert(ts->temp_allocated != 0);", "ts->temp_allocated = 0;", "VAR_1 = ts->base_type + (ts->temp_local ? TCG_TYPE_COUNT : 0);", "set_bit(VAR_0, s->free_temps[VAR_1].l);", "}" ]

[ 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, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ] ]

[ "static bool FUNC_0(target_ulong pte0, target_ulong pte1,\nbool secondary, target_ulong ptem)\n{", "return (pte0 & HPTE64_V_VALID)\n&& (secondary == !!(pte0 & HPTE64_V_SECONDARY))\n&& HPTE64_V_COMPARE(pte0, ptem);", "}" ]

[ 0, 0, 0 ]

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

[ "PCIBus *FUNC_0(CPUState *env, qemu_irq pci_irqs[4],\ntarget_phys_addr_t config_space,\ntarget_phys_addr_t int_ack,\ntarget_phys_addr_t special_cycle,\ntarget_phys_addr_t registers)\n{", "PPC4xxPCIState *controller;", "int VAR_0;", "static int VAR_1;", "uint8_t *pci_conf;", "controller = qemu_mallocz(sizeof(PPC4xxPCIState));", "controller->pci_state.bus = pci_register_bus(NULL, \"pci\",\nppc4xx_pci_set_irq,\nppc4xx_pci_map_irq,\npci_irqs, 0, 4);", "controller->pci_dev = pci_register_device(controller->pci_state.bus,\n\"host bridge\", sizeof(PCIDevice),\n0, NULL, NULL);", "pci_conf = controller->pci_dev->config;", "pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_IBM);", "pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_IBM_440GX);", "pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_OTHER);", "VAR_0 = cpu_register_io_memory(pci4xx_cfgaddr_read,\npci4xx_cfgaddr_write, controller);", "if (VAR_0 < 0)\ngoto free;", "cpu_register_physical_memory(config_space + PCIC0_CFGADDR, 4, VAR_0);", "VAR_0 = cpu_register_io_memory(pci4xx_cfgdata_read,\npci4xx_cfgdata_write,\n&controller->pci_state);", "if (VAR_0 < 0)\ngoto free;", "cpu_register_physical_memory(config_space + PCIC0_CFGDATA, 4, VAR_0);", "VAR_0 = cpu_register_io_memory(pci_reg_read, pci_reg_write, controller);", "if (VAR_0 < 0)\ngoto free;", "cpu_register_physical_memory(registers, PCI_REG_SIZE, VAR_0);", "qemu_register_reset(ppc4xx_pci_reset, controller);", "register_savevm(\"ppc4xx_pci\", VAR_1++, 1,\nppc4xx_pci_save, ppc4xx_pci_load, controller);", "return controller->pci_state.bus;", "free:\nprintf(\"%s error\\n\", __func__);", "qemu_free(controller);", "return 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 ]

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 27, 29, 31, 33 ], [ 37, 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 55, 57 ], [ 59, 61 ], [ 63 ], [ 69, 71, 73 ], [ 75, 77 ], [ 79 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 95 ], [ 101, 103 ], [ 107 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "check_watchpoint(VAR_1 & ~TARGET_PAGE_MASK, ~(VAR_3 - 1), BP_MEM_WRITE);", "switch (VAR_3) {", "case 1:\nstb_phys(VAR_1, VAR_2);", "break;", "case 2:\nstw_phys(VAR_1, VAR_2);", "break;", "case 4:\nstl_phys(VAR_1, VAR_2);", "break;", "default: abort();", "}", "}" ]

[ 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(QIOChannel *VAR_0,\nconst void *VAR_1, size_t VAR_2,\nint *VAR_3, size_t VAR_4)\n{", "size_t offset = 0;", "while (offset < VAR_2) {", "ssize_t ret = 0;", "struct iovec VAR_5 = { .iov_base = (char *)VAR_1 + offset,", ".iov_len = VAR_2 - offset };", "ret = qio_channel_writev_full(\nVAR_0, &VAR_5, 1,\nVAR_3, VAR_4, NULL);", "if (ret == QIO_CHANNEL_ERR_BLOCK) {", "errno = EAGAIN;", "return -1;", "} else if (ret < 0) {", "if (offset) {", "return offset;", "}", "errno = EINVAL;", "return -1;", "}", "offset += ret;", "}", "return offset;", "}" ]

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

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

[ "FUNC_0(Monitor *VAR_0, CPUState *VAR_1, int VAR_2, uint64_t VAR_3,\nuint64_t VAR_4, uint64_t VAR_5, uint64_t VAR_6,\nint VAR_7)\n{", "uint64_t mcg_cap = VAR_1->mcg_cap;", "uint64_t *banks = VAR_1->mce_banks + 4 * VAR_2;", "if (!(VAR_7 & MCE_INJECT_UNCOND_AO) && !(VAR_3 & MCI_STATUS_AR)\n&& (VAR_1->VAR_4 & MCG_STATUS_MCIP)) {", "return;", "}", "if (VAR_3 & MCI_STATUS_UC) {", "if ((mcg_cap & MCG_CTL_P) && VAR_1->mcg_ctl != ~(uint64_t)0) {", "monitor_printf(VAR_0,\n\"CPU %d: Uncorrected error reporting disabled\\n\",\nVAR_1->cpu_index);", "return;", "}", "if (banks[0] != ~(uint64_t)0) {", "monitor_printf(VAR_0, \"CPU %d: Uncorrected error reporting disabled \"\n\"for VAR_2 %d\\n\", VAR_1->cpu_index, VAR_2);", "return;", "}", "if ((VAR_1->VAR_4 & MCG_STATUS_MCIP) ||\n!(VAR_1->cr[4] & CR4_MCE_MASK)) {", "monitor_printf(VAR_0, \"CPU %d: Previous MCE still in progress, \"\n\"raising triple fault\\n\", VAR_1->cpu_index);", "qemu_log_mask(CPU_LOG_RESET, \"Triple fault\\n\");", "qemu_system_reset_request();", "return;", "}", "if (banks[1] & MCI_STATUS_VAL) {", "VAR_3 |= MCI_STATUS_OVER;", "}", "banks[2] = VAR_5;", "banks[3] = VAR_6;", "VAR_1->VAR_4 = VAR_4;", "banks[1] = VAR_3;", "cpu_interrupt(VAR_1, CPU_INTERRUPT_MCE);", "} else if (!(banks[1] & MCI_STATUS_VAL)", "|| !(banks[1] & MCI_STATUS_UC)) {", "if (banks[1] & MCI_STATUS_VAL) {", "VAR_3 |= MCI_STATUS_OVER;", "}", "banks[2] = VAR_5;", "banks[3] = VAR_6;", "banks[1] = VAR_3;", "} else {", "banks[1] |= MCI_STATUS_OVER;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 41 ], [ 43, 45, 47 ], [ 49 ], [ 51 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 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 ] ]

[ "static void FUNC_0(void)\n{", "test_pxe_one(\"-device e1000,netdev=\" NETNAME, false);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(MpegEncContext *VAR_0, DCTELEM VAR_1[6][64])\n{", "int VAR_2, VAR_3;", "const int VAR_4= VAR_0->mb_x + VAR_0->mb_y*VAR_0->mb_width;", "VAR_3= VAR_0->VAR_3[VAR_4];", "VAR_2 = VAR_0->cbp_table[VAR_4];", "if(VAR_0->current_picture.qscale_table[VAR_4] != VAR_0->qscale){", "VAR_0->qscale= VAR_0->current_picture.qscale_table[VAR_4];", "VAR_0->y_dc_scale= VAR_0->y_dc_scale_table[ VAR_0->qscale ];", "VAR_0->c_dc_scale= VAR_0->c_dc_scale_table[ VAR_0->qscale ];", "}", "if (VAR_0->pict_type == P_TYPE || VAR_0->pict_type==S_TYPE) {", "int VAR_6;", "for(VAR_6=0; VAR_6<4; VAR_6++){", "VAR_0->mv[0][VAR_6][0] = VAR_0->motion_val[ VAR_0->block_index[VAR_6] ][0];", "VAR_0->mv[0][VAR_6][1] = VAR_0->motion_val[ VAR_0->block_index[VAR_6] ][1];", "}", "VAR_0->mb_intra = VAR_3&MB_TYPE_INTRA;", "if (VAR_3&MB_TYPE_SKIPED) {", "for(VAR_6=0;VAR_6<6;VAR_6++)", "VAR_0->block_last_index[VAR_6] = -1;", "VAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mv_type = MV_TYPE_16X16;", "if(VAR_0->pict_type==S_TYPE && VAR_0->vol_sprite_usage==GMC_SPRITE){", "VAR_0->mcsel=1;", "VAR_0->mb_skiped = 0;", "}else{", "VAR_0->mcsel=0;", "VAR_0->mb_skiped = 1;", "}", "}else if(VAR_0->mb_intra){", "VAR_0->ac_pred = VAR_0->pred_dir_table[VAR_4]>>7;", "for (VAR_6 = 0; VAR_6 < 6; VAR_6++) {", "if(mpeg4_decode_block(VAR_0, VAR_1[VAR_6], VAR_6, VAR_2&32, 1) < 0){", "fprintf(stderr, \"texture corrupted at %d %d\\n\", VAR_0->mb_x, VAR_0->mb_y);", "return -1;", "}", "VAR_2+=VAR_2;", "}", "}else if(!VAR_0->mb_intra){", "VAR_0->mv_dir = MV_DIR_FORWARD;", "if (VAR_3&MB_TYPE_INTER4V) {", "VAR_0->mv_type = MV_TYPE_8X8;", "} else {", "VAR_0->mv_type = MV_TYPE_16X16;", "}", "for (VAR_6 = 0; VAR_6 < 6; VAR_6++) {", "if(mpeg4_decode_block(VAR_0, VAR_1[VAR_6], VAR_6, VAR_2&32, 0) < 0){", "fprintf(stderr, \"texture corrupted at %d %d (trying to continue with mc/dc only)\\n\", VAR_0->mb_x, VAR_0->mb_y);", "return -1;", "}", "VAR_2+=VAR_2;", "}", "}", "} else {", "int VAR_6;", "VAR_0->mb_intra = 1;", "VAR_0->ac_pred = VAR_0->pred_dir_table[VAR_4]>>7;", "for (VAR_6 = 0; VAR_6 < 6; VAR_6++) {", "if(mpeg4_decode_block(VAR_0, VAR_1[VAR_6], VAR_6, VAR_2&32, 1) < 0){", "fprintf(stderr, \"texture corrupted at %d %d (trying to continue with dc only)\\n\", VAR_0->mb_x, VAR_0->mb_y);", "return -1;", "}", "VAR_2+=VAR_2;", "}", "}", "VAR_0->error_status_table[VAR_4]&= ~AC_ERROR;", "if(--VAR_0->mb_num_left <= 0){", "if(mpeg4_is_resync(VAR_0))\nreturn SLICE_END;", "else\nreturn SLICE_NOEND;", "}else{", "if(VAR_0->cbp_table[VAR_4+1] && mpeg4_is_resync(VAR_0))\nreturn SLICE_END;", "else\nreturn SLICE_OK;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 167 ], [ 171, 173 ], [ 175, 177 ], [ 179 ], [ 181, 183 ], [ 185, 187 ], [ 189 ], [ 191 ] ]

[ "void FUNC_0(Visitor *VAR_0, uint8_t *VAR_1, const char *VAR_2, Error **VAR_3)\n{", "int64_t value;", "if (VAR_0->type_uint8) {", "VAR_0->type_uint8(VAR_0, VAR_1, VAR_2, VAR_3);", "} else {", "value = *VAR_1;", "VAR_0->type_int64(VAR_0, &value, VAR_2, VAR_3);", "if (value < 0 || value > UINT8_MAX) {", "error_setg(VAR_3, QERR_INVALID_PARAMETER_VALUE,\nVAR_2 ? VAR_2 : \"null\", \"uint8_t\");", "return;", "}", "*VAR_1 = value;", "}", "}" ]

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

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

[ "void FUNC_0(void *VAR_0, int VAR_1, int VAR_2)\n{", "pc_cmos_set_s3_resume(VAR_0, VAR_1, VAR_2);", "if (VAR_2) {", "xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3);", "}", "}" ]

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

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

[ "size_t FUNC_0(struct iovec *in_sg, int in_num, size_t offset,\nint bswap, const char *fmt, ...)\n{", "int VAR_0;", "va_list ap;", "size_t old_offset = offset;", "va_start(ap, fmt);", "for (VAR_0 = 0; fmt[VAR_0]; VAR_0++) {", "switch (fmt[VAR_0]) {", "case 'b': {", "uint8_t val = va_arg(ap, int);", "offset += v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));", "break;", "}", "case 'w': {", "uint16_t val;", "if (bswap) {", "cpu_to_le16w(&val, va_arg(ap, int));", "} else {", "val = va_arg(ap, int);", "}", "offset += v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));", "break;", "}", "case 'd': {", "uint32_t val;", "if (bswap) {", "cpu_to_le32w(&val, va_arg(ap, uint32_t));", "} else {", "val = va_arg(ap, uint32_t);", "}", "offset += v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));", "break;", "}", "case 'q': {", "uint64_t val;", "if (bswap) {", "cpu_to_le64w(&val, va_arg(ap, uint64_t));", "} else {", "val = va_arg(ap, uint64_t);", "}", "offset += v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));", "break;", "}", "case 's': {", "V9fsString *str = va_arg(ap, V9fsString *);", "offset += FUNC_0(in_sg, in_num, offset, bswap,\n\"w\", str->size);", "offset += v9fs_pack(in_sg, in_num, offset, str->data, str->size);", "break;", "}", "case 'Q': {", "V9fsQID *qidp = va_arg(ap, V9fsQID *);", "offset += FUNC_0(in_sg, in_num, offset, bswap, \"bdq\",\nqidp->type, qidp->version, qidp->path);", "break;", "}", "case 'S': {", "V9fsStat *statp = va_arg(ap, V9fsStat *);", "offset += FUNC_0(in_sg, in_num, offset, bswap,\n\"wwdQdddqsssssddd\",\nstatp->size, statp->type, statp->dev,\n&statp->qid, statp->mode, statp->atime,\nstatp->mtime, statp->length, &statp->name,\n&statp->uid, &statp->gid, &statp->muid,\n&statp->extension, statp->n_uid,\nstatp->n_gid, statp->n_muid);", "break;", "}", "case 'A': {", "V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);", "offset += FUNC_0(in_sg, in_num, offset, bswap,\n\"qQdddqqqqqqqqqqqqqqq\",\nstatp->st_result_mask,\n&statp->qid, statp->st_mode,\nstatp->st_uid, statp->st_gid,\nstatp->st_nlink, statp->st_rdev,\nstatp->st_size, statp->st_blksize,\nstatp->st_blocks, statp->st_atime_sec,\nstatp->st_atime_nsec, statp->st_mtime_sec,\nstatp->st_mtime_nsec, statp->st_ctime_sec,\nstatp->st_ctime_nsec, statp->st_btime_sec,\nstatp->st_btime_nsec, statp->st_gen,\nstatp->st_data_version);", "break;", "}", "default:\nbreak;", "}", "}", "va_end(ap);", "return offset - old_offset;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 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 ], [ 187 ], [ 189 ] ]

[ "void FUNC_0(MemoryRegion *VAR_0, Notifier *VAR_1,\nhwaddr VAR_2, bool VAR_3)\n{", "hwaddr addr;", "IOMMUTLBEntry iotlb;", "for (addr = 0; addr < memory_region_size(VAR_0); addr += VAR_2) {", "iotlb = VAR_0->iommu_ops->translate(VAR_0, addr, VAR_3);", "if (iotlb.perm != IOMMU_NONE) {", "VAR_1->notify(VAR_1, &iotlb);", "}", "if ((addr + VAR_2) < addr) {", "break;", "}", "}", "}" ]

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

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

[ "static void FUNC_0(MachineState *VAR_0)\n{", "MachineClass *mc = MACHINE_GET_CLASS(VAR_0);", "int VAR_1;", "if (tcg_enabled() && max_cpus > 1) {", "error_report(\"Number of SMP CPUs requested (%d) exceeds max CPUs \"\n\"supported by TCG (1) on s390x\", max_cpus);", "exit(1);", "}", "mc->possible_cpu_arch_ids(VAR_0);", "for (VAR_1 = 0; VAR_1 < smp_cpus; VAR_1++) {", "s390x_new_cpu(VAR_0->cpu_type, VAR_1, &error_fatal);", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "RoqContext *s = VAR_0->priv_data;", "s->VAR_0 = VAR_0;", "s->width = VAR_0->width;", "s->height = VAR_0->height;", "s->last_frame = &s->frames[0];", "s->current_frame = &s->frames[1];", "VAR_0->pix_fmt = PIX_FMT_YUV444P;", "dsputil_init(&s->dsp, VAR_0);", "return 0;", "}" ]

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

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

[ "static inline void FUNC_0(CPUX86State *VAR_0, int VAR_1,\nint VAR_2, int VAR_3)\n{", "uint32_t new_cs, new_eflags, new_ss;", "uint32_t new_es, new_ds, new_fs, new_gs;", "uint32_t e1, e2, ss_e1, ss_e2;", "int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;", "target_ulong ssp, sp, new_eip, new_esp, sp_mask;", "#ifdef TARGET_X86_64\nif (VAR_1 == 2) {", "sp_mask = -1;", "} else", "#endif\n{", "sp_mask = get_sp_mask(VAR_0->segs[R_SS].flags);", "}", "sp = VAR_0->regs[R_ESP];", "ssp = VAR_0->segs[R_SS].base;", "new_eflags = 0;", "#ifdef TARGET_X86_64\nif (VAR_1 == 2) {", "POPQ(sp, new_eip);", "POPQ(sp, new_cs);", "new_cs &= 0xffff;", "if (VAR_2) {", "POPQ(sp, new_eflags);", "}", "} else", "#endif\n{", "if (VAR_1 == 1) {", "POPL(ssp, sp, sp_mask, new_eip);", "POPL(ssp, sp, sp_mask, new_cs);", "new_cs &= 0xffff;", "if (VAR_2) {", "POPL(ssp, sp, sp_mask, new_eflags);", "if (new_eflags & VM_MASK) {", "goto return_to_vm86;", "}", "}", "} else {", "POPW(ssp, sp, sp_mask, new_eip);", "POPW(ssp, sp, sp_mask, new_cs);", "if (VAR_2) {", "POPW(ssp, sp, sp_mask, new_eflags);", "}", "}", "}", "LOG_PCALL(\"lret new %04x:\" TARGET_FMT_lx \" s=%d VAR_3=0x%x\\n\",\nnew_cs, new_eip, VAR_1, VAR_3);", "LOG_PCALL_STATE(CPU(x86_env_get_cpu(VAR_0)));", "if ((new_cs & 0xfffc) == 0) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_cs & 0xfffc);", "}", "if (load_segment(VAR_0, &e1, &e2, new_cs) != 0) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_cs & 0xfffc);", "}", "if (!(e2 & DESC_S_MASK) ||\n!(e2 & DESC_CS_MASK)) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_cs & 0xfffc);", "}", "VAR_4 = VAR_0->hflags & HF_CPL_MASK;", "VAR_6 = new_cs & 3;", "if (VAR_6 < VAR_4) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_cs & 0xfffc);", "}", "VAR_5 = (e2 >> DESC_DPL_SHIFT) & 3;", "if (e2 & DESC_C_MASK) {", "if (VAR_5 > VAR_6) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_cs & 0xfffc);", "}", "} else {", "if (VAR_5 != VAR_6) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_cs & 0xfffc);", "}", "}", "if (!(e2 & DESC_P_MASK)) {", "raise_exception_err(VAR_0, EXCP0B_NOSEG, new_cs & 0xfffc);", "}", "sp += VAR_3;", "if (VAR_6 == VAR_4 && (!(VAR_0->hflags & HF_CS64_MASK) ||\n((VAR_0->hflags & HF_CS64_MASK) && !VAR_2))) {", "cpu_x86_load_seg_cache(VAR_0, R_CS, new_cs,\nget_seg_base(e1, e2),\nget_seg_limit(e1, e2),\ne2);", "} else {", "#ifdef TARGET_X86_64\nif (VAR_1 == 2) {", "POPQ(sp, new_esp);", "POPQ(sp, new_ss);", "new_ss &= 0xffff;", "} else", "#endif\n{", "if (VAR_1 == 1) {", "POPL(ssp, sp, sp_mask, new_esp);", "POPL(ssp, sp, sp_mask, new_ss);", "new_ss &= 0xffff;", "} else {", "POPW(ssp, sp, sp_mask, new_esp);", "POPW(ssp, sp, sp_mask, new_ss);", "}", "}", "LOG_PCALL(\"new ss:esp=%04x:\" TARGET_FMT_lx \"\\n\",\nnew_ss, new_esp);", "if ((new_ss & 0xfffc) == 0) {", "#ifdef TARGET_X86_64\nif ((VAR_0->hflags & HF_LMA_MASK) && VAR_6 != 3) {", "cpu_x86_load_seg_cache(VAR_0, R_SS, new_ss,\n0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK | (VAR_6 << DESC_DPL_SHIFT) |\nDESC_W_MASK | DESC_A_MASK);", "ss_e2 = DESC_B_MASK;", "} else", "#endif\n{", "raise_exception_err(VAR_0, EXCP0D_GPF, 0);", "}", "} else {", "if ((new_ss & 3) != VAR_6) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_ss & 0xfffc);", "}", "if (load_segment(VAR_0, &ss_e1, &ss_e2, new_ss) != 0) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_ss & 0xfffc);", "}", "if (!(ss_e2 & DESC_S_MASK) ||\n(ss_e2 & DESC_CS_MASK) ||\n!(ss_e2 & DESC_W_MASK)) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_ss & 0xfffc);", "}", "VAR_5 = (ss_e2 >> DESC_DPL_SHIFT) & 3;", "if (VAR_5 != VAR_6) {", "raise_exception_err(VAR_0, EXCP0D_GPF, new_ss & 0xfffc);", "}", "if (!(ss_e2 & DESC_P_MASK)) {", "raise_exception_err(VAR_0, EXCP0B_NOSEG, new_ss & 0xfffc);", "}", "cpu_x86_load_seg_cache(VAR_0, R_SS, new_ss,\nget_seg_base(ss_e1, ss_e2),\nget_seg_limit(ss_e1, ss_e2),\nss_e2);", "}", "cpu_x86_load_seg_cache(VAR_0, R_CS, new_cs,\nget_seg_base(e1, e2),\nget_seg_limit(e1, e2),\ne2);", "cpu_x86_set_cpl(VAR_0, VAR_6);", "sp = new_esp;", "#ifdef TARGET_X86_64\nif (VAR_0->hflags & HF_CS64_MASK) {", "sp_mask = -1;", "} else", "#endif\n{", "sp_mask = get_sp_mask(ss_e2);", "}", "validate_seg(VAR_0, R_ES, VAR_6);", "validate_seg(VAR_0, R_DS, VAR_6);", "validate_seg(VAR_0, R_FS, VAR_6);", "validate_seg(VAR_0, R_GS, VAR_6);", "sp += VAR_3;", "}", "SET_ESP(sp, sp_mask);", "VAR_0->eip = new_eip;", "if (VAR_2) {", "VAR_7 = TF_MASK | AC_MASK | ID_MASK | RF_MASK | NT_MASK;", "if (VAR_4 == 0) {", "VAR_7 |= IOPL_MASK;", "}", "VAR_8 = (VAR_0->eflags >> IOPL_SHIFT) & 3;", "if (VAR_4 <= VAR_8) {", "VAR_7 |= IF_MASK;", "}", "if (VAR_1 == 0) {", "VAR_7 &= 0xffff;", "}", "cpu_load_eflags(VAR_0, new_eflags, VAR_7);", "}", "return;", "return_to_vm86:\nPOPL(ssp, sp, sp_mask, new_esp);", "POPL(ssp, sp, sp_mask, new_ss);", "POPL(ssp, sp, sp_mask, new_es);", "POPL(ssp, sp, sp_mask, new_ds);", "POPL(ssp, sp, sp_mask, new_fs);", "POPL(ssp, sp, sp_mask, new_gs);", "cpu_load_eflags(VAR_0, new_eflags, TF_MASK | AC_MASK | ID_MASK |\nIF_MASK | IOPL_MASK | VM_MASK | NT_MASK | VIF_MASK |\nVIP_MASK);", "load_seg_vm(VAR_0, R_CS, new_cs & 0xffff);", "cpu_x86_set_cpl(VAR_0, 3);", "load_seg_vm(VAR_0, R_SS, new_ss & 0xffff);", "load_seg_vm(VAR_0, R_ES, new_es & 0xffff);", "load_seg_vm(VAR_0, R_DS, new_ds & 0xffff);", "load_seg_vm(VAR_0, R_FS, new_fs & 0xffff);", "load_seg_vm(VAR_0, R_GS, new_gs & 0xffff);", "VAR_0->eip = new_eip & 0xffff;", "VAR_0->regs[R_ESP] = new_esp;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 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 ], [ 167 ], [ 169, 171 ], [ 175, 177, 179, 181 ], [ 183 ], [ 187, 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199, 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231, 237 ], [ 239, 241, 243, 245, 247 ], [ 249 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275, 277, 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299, 301, 303, 305 ], [ 307 ], [ 311, 313, 315, 317 ], [ 319 ], [ 321 ], [ 323, 325 ], [ 327 ], [ 329 ], [ 331, 333 ], [ 335 ], [ 337 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 395, 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 413, 415, 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 435 ], [ 437 ], [ 439 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, QEMUIOVector *VAR_1)\n{", "int VAR_2;", "for (VAR_2 = 0; VAR_2 < VAR_1->niov; VAR_2++) {", "if ((uintptr_t) VAR_1->iov[VAR_2].iov_base % VAR_0->buffer_alignment) {", "return 0;", "}", "}", "return 1;", "}" ]

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

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

[ "void *FUNC_0(size_t VAR_0)\n{", "void *VAR_1;", "VAR_1 = VirtualAlloc(NULL, VAR_0, MEM_COMMIT, PAGE_READWRITE);", "trace_qemu_anon_ram_alloc(VAR_0, VAR_1);", "return VAR_1;", "}" ]

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

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

[ "static bool VAR_0 do_perform_cow_encrypt(BlockDriverState *bs,\nuint64_t src_cluster_offset,\nunsigned offset_in_cluster,\nuint8_t *buffer,\nunsigned bytes)\n{", "if (bytes && bs->encrypted) {", "BDRVQcow2State *s = bs->opaque;", "int64_t sector = (src_cluster_offset + offset_in_cluster)\n>> BDRV_SECTOR_BITS;", "assert(s->cipher);", "assert((offset_in_cluster & ~BDRV_SECTOR_MASK) == 0);", "assert((bytes & ~BDRV_SECTOR_MASK) == 0);", "if (qcow2_encrypt_sectors(s, sector, buffer,\nbytes >> BDRV_SECTOR_BITS, true, NULL) < 0) {", "return false;", "}", "}", "return true;", "}" ]

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

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

[ "static uint32_t FUNC_0 (void *opaque, uint32_t addr)\n{", "PCIAC97LinkState *d = opaque;", "AC97LinkState *s = &d->ac97;", "dolog (\"U nam readl %#x\\n\", addr);", "s->cas = 0;", "return ~0U;", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, int VAR_1)\n{", "BDRVVPCState *s = VAR_0->opaque;", "int VAR_2;", "struct vhd_footer* VAR_3;", "struct vhd_dyndisk_header* VAR_4;", "uint8_t buf[HEADER_SIZE];", "uint32_t checksum;", "int VAR_5 = -1;", "int VAR_6 = VHD_DYNAMIC;", "if (bdrv_pread(VAR_0->file, 0, s->footer_buf, HEADER_SIZE) != HEADER_SIZE)\ngoto fail;", "VAR_3 = (struct vhd_footer*) s->footer_buf;", "if (strncmp(VAR_3->creator, \"conectix\", 8)) {", "int64_t offset = bdrv_getlength(VAR_0->file);", "if (offset < HEADER_SIZE) {", "goto fail;", "}", "if (bdrv_pread(VAR_0->file, offset-HEADER_SIZE, s->footer_buf, HEADER_SIZE)\n!= HEADER_SIZE) {", "goto fail;", "}", "if (strncmp(VAR_3->creator, \"conectix\", 8)) {", "goto fail;", "}", "VAR_6 = VHD_FIXED;", "}", "checksum = be32_to_cpu(VAR_3->checksum);", "VAR_3->checksum = 0;", "if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum)\nfprintf(stderr, \"block-vpc: The header checksum of '%s' is \"\n\"incorrect.\\n\", VAR_0->filename);", "VAR_3->checksum = be32_to_cpu(checksum);", "VAR_0->total_sectors = (int64_t)\nbe16_to_cpu(VAR_3->cyls) * VAR_3->heads * VAR_3->secs_per_cyl;", "if (VAR_0->total_sectors >= 65535 * 16 * 255) {", "VAR_5 = -EFBIG;", "goto fail;", "}", "if (VAR_6 == VHD_DYNAMIC) {", "if (bdrv_pread(VAR_0->file, be64_to_cpu(VAR_3->data_offset), buf,\nHEADER_SIZE) != HEADER_SIZE) {", "goto fail;", "}", "VAR_4 = (struct vhd_dyndisk_header *) buf;", "if (strncmp(VAR_4->magic, \"cxsparse\", 8)) {", "goto fail;", "}", "s->block_size = be32_to_cpu(VAR_4->block_size);", "s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;", "s->max_table_entries = be32_to_cpu(VAR_4->max_table_entries);", "s->pagetable = g_malloc(s->max_table_entries * 4);", "s->bat_offset = be64_to_cpu(VAR_4->table_offset);", "if (bdrv_pread(VAR_0->file, s->bat_offset, s->pagetable,\ns->max_table_entries * 4) != s->max_table_entries * 4) {", "goto fail;", "}", "s->free_data_block_offset =\n(s->bat_offset + (s->max_table_entries * 4) + 511) & ~511;", "for (VAR_2 = 0; VAR_2 < s->max_table_entries; VAR_2++) {", "be32_to_cpus(&s->pagetable[VAR_2]);", "if (s->pagetable[VAR_2] != 0xFFFFFFFF) {", "int64_t next = (512 * (int64_t) s->pagetable[VAR_2]) +\ns->bitmap_size + s->block_size;", "if (next > s->free_data_block_offset) {", "s->free_data_block_offset = next;", "}", "}", "}", "s->last_bitmap_offset = (int64_t) -1;", "#ifdef CACHE\ns->pageentry_u8 = g_malloc(512);", "s->pageentry_u32 = s->pageentry_u8;", "s->pageentry_u16 = s->pageentry_u8;", "s->last_pagetable = -1;", "#endif\n}", "qemu_co_mutex_init(&s->lock);", "error_set(&s->migration_blocker,\nQERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,\n\"vpc\", VAR_0->device_name, \"live migration\");", "migrate_add_blocker(s->migration_blocker);", "return 0;", "fail:\nreturn VAR_5;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67, 69, 71 ], [ 77 ], [ 87, 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 151, 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163, 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195, 197 ], [ 201 ], [ 207, 209, 211 ], [ 213 ], [ 217 ], [ 219, 221 ], [ 223 ] ]

[ "static void FUNC_0(void)\n{", "AHCIQState *ahci;", "ahci = ahci_boot_and_enable();", "ahci_test_identify(ahci);", "ahci_shutdown(ahci);", "}" ]

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

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

[ "static void FUNC_0(target_phys_addr_t VAR_0, uint32_t VAR_1)\n{", "uint8_t dest = (VAR_0 & MSI_ADDR_DEST_ID_MASK) >> MSI_ADDR_DEST_ID_SHIFT;", "uint8_t vector = (VAR_1 & MSI_DATA_VECTOR_MASK) >> MSI_DATA_VECTOR_SHIFT;", "uint8_t dest_mode = (VAR_0 >> MSI_ADDR_DEST_MODE_SHIFT) & 0x1;", "uint8_t trigger_mode = (VAR_1 >> MSI_DATA_TRIGGER_SHIFT) & 0x1;", "uint8_t delivery = (VAR_1 >> MSI_DATA_DELIVERY_MODE_SHIFT) & 0x7;", "apic_deliver_irq(dest, dest_mode, delivery, vector, trigger_mode);", "}" ]

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

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

[ "PCIHostState *FUNC_0(sPAPREnvironment *spapr, int index,\nconst char *busname)\n{", "DeviceState *dev;", "dev = qdev_create(NULL, TYPE_SPAPR_PCI_HOST_BRIDGE);", "qdev_prop_set_uint32(dev, \"index\", index);", "qdev_prop_set_string(dev, \"busname\", busname);", "qdev_init_nofail(dev);", "return PCI_HOST_BRIDGE(dev);", "}" ]

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

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

[ "static void FUNC_0(const char *VAR_0)\n{", "if (!strcmp(VAR_0, \"pgmyuv\")) {", "opt_image_format(VAR_0);", "VAR_0 = \"image\";", "}", "file_iformat = av_find_input_format(VAR_0);", "file_oformat = guess_format(VAR_0, NULL, NULL);", "if (!file_iformat && !file_oformat) {", "fprintf(stderr, \"Unknown input or output format: %s\\n\", VAR_0);", "exit(1);", "}", "}" ]

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

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

[ "void FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nunsigned VAR_2,\nbool VAR_3,\nuint64_t VAR_4,\nEventNotifier *VAR_5)\n{", "MemoryRegionIoeventfd mrfd = {", ".VAR_1.start = int128_make64(VAR_1),\n.VAR_1.VAR_2 = int128_make64(VAR_2),\n.VAR_3 = VAR_3,\n.VAR_4 = VAR_4,\n.VAR_5 = VAR_5,\n};", "unsigned VAR_6;", "if (VAR_2) {", "adjust_endianness(VAR_0, &mrfd.VAR_4, VAR_2);", "memory_region_transaction_begin();", "for (VAR_6 = 0; VAR_6 < VAR_0->ioeventfd_nb; ++VAR_6) {", "if (memory_region_ioeventfd_before(mrfd, VAR_0->ioeventfds[VAR_6])) {", "break;", "++VAR_0->ioeventfd_nb;", "VAR_0->ioeventfds = g_realloc(VAR_0->ioeventfds,\nsizeof(*VAR_0->ioeventfds) * VAR_0->ioeventfd_nb);", "memmove(&VAR_0->ioeventfds[VAR_6+1], &VAR_0->ioeventfds[VAR_6],\nsizeof(*VAR_0->ioeventfds) * (VAR_0->ioeventfd_nb-1 - VAR_6));", "VAR_0->ioeventfds[VAR_6] = mrfd;", "ioeventfd_update_pending |= VAR_0->enabled;", "memory_region_transaction_commit();" ]

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

[ "static int FUNC_0(V9fsPDU *VAR_0, size_t VAR_1, int VAR_2, struct iovec *VAR_3)\n{", "size_t pos = 0;", "int VAR_4, VAR_5;", "struct iovec *VAR_6;", "unsigned int VAR_7;", "if (VAR_2) {", "VAR_6 = VAR_0->elem.in_sg;", "VAR_7 = VAR_0->elem.in_num;", "} else {", "VAR_6 = VAR_0->elem.out_sg;", "VAR_7 = VAR_0->elem.out_num;", "}", "VAR_5 = 0;", "for (VAR_4 = 0; VAR_4 < VAR_7; VAR_4++) {", "if (VAR_1 <= pos) {", "VAR_3[VAR_5].iov_base = VAR_6[VAR_4].iov_base;", "VAR_3[VAR_5].iov_len = VAR_6[VAR_4].iov_len;", "VAR_5++;", "} else if (VAR_1 < (VAR_6[VAR_4].iov_len + pos)) {", "VAR_3[VAR_5].iov_base = VAR_6[VAR_4].iov_base;", "VAR_3[VAR_5].iov_len = VAR_6[VAR_4].iov_len;", "VAR_3[VAR_5].iov_base += (VAR_1 - pos);", "VAR_3[VAR_5].iov_len -= (VAR_1 - pos);", "VAR_5++;", "}", "pos += VAR_6[VAR_4].iov_len;", "}", "return VAR_5;", "}" ]

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

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

[ "void FUNC_0(RLTable *VAR_0)\n{", "int VAR_1, VAR_2;", "init_vlc(&VAR_0->vlc, 9, VAR_0->n + 1,\n&VAR_0->table_vlc[0][1], 4, 2,\n&VAR_0->table_vlc[0][0], 4, 2);", "for(VAR_2=0; VAR_2<32; VAR_2++){", "int VAR_3= VAR_2*2;", "int VAR_4= (VAR_2-1)|1;", "if(VAR_2==0){", "VAR_3=1;", "VAR_4=0;", "}", "VAR_0->rl_vlc[VAR_2]= av_malloc(VAR_0->vlc.table_size*sizeof(RL_VLC_ELEM));", "for(VAR_1=0; VAR_1<VAR_0->vlc.table_size; VAR_1++){", "int code= VAR_0->vlc.table[VAR_1][0];", "int len = VAR_0->vlc.table[VAR_1][1];", "int level, run;", "if(len==0){", "run= 66;", "level= MAX_LEVEL;", "}else if(len<0){", "run= 0;", "level= code;", "}else{", "if(code==VAR_0->n){", "run= 66;", "level= 0;", "}else{", "run= VAR_0->table_run [code] + 1;", "level= VAR_0->table_level[code] * VAR_3 + VAR_4;", "if(code >= VAR_0->last) run+=192;", "}", "}", "VAR_0->rl_vlc[VAR_2][VAR_1].len= len;", "VAR_0->rl_vlc[VAR_2][VAR_1].level= level;", "VAR_0->rl_vlc[VAR_2][VAR_1].run= run;", "}", "}", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "if (VAR_0->format == OP_FMT_RI) {", "LOG_DIS(\"sri r%d, r%d, %d\\n\", VAR_0->r1, VAR_0->r0, VAR_0->imm5);", "} else {", "LOG_DIS(\"sr r%d, r%d, r%d\\n\", VAR_0->r2, VAR_0->r0, VAR_0->r1);", "}", "if (!(VAR_0->env->features & LM32_FEATURE_SHIFT)) {", "if (VAR_0->format == OP_FMT_RI) {", "} else {", "if (VAR_0->imm5 != 1) {", "cpu_abort(VAR_0->env, \"hardware shifter is not available\\n\");", "}", "}", "}", "if (VAR_0->format == OP_FMT_RI) {", "tcg_gen_sari_tl(cpu_R[VAR_0->r1], cpu_R[VAR_0->r0], VAR_0->imm5);", "} else {", "TCGv t0 = tcg_temp_new();", "tcg_gen_andi_tl(t0, cpu_R[VAR_0->r1], 0x1f);", "tcg_gen_sar_tl(cpu_R[VAR_0->r2], cpu_R[VAR_0->r0], t0);", "tcg_temp_free(t0);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ] ]

[ "int FUNC_0(int VAR_0, void *VAR_1)\n{", "#ifdef KVM_CAP_MCE\nif ((first_cpu->mcg_cap & MCG_SER_P) && VAR_1 && VAR_0 == BUS_MCEERR_AO) {", "ram_addr_t ram_addr;", "target_phys_addr_t paddr;", "if (qemu_ram_addr_from_host(VAR_1, &ram_addr) ||\n!kvm_physical_memory_addr_from_ram(first_cpu->kvm_state, ram_addr,\n&paddr)) {", "fprintf(stderr, \"Hardware memory error for memory used by \"\n\"QEMU itself instead of guest system!: %p\\n\", VAR_1);", "return 0;", "}", "kvm_mce_inject(first_cpu, paddr, VAR_0);", "} else", "#endif\n{", "if (VAR_0 == BUS_MCEERR_AO) {", "return 0;", "} else if (VAR_0 == BUS_MCEERR_AR) {", "hardware_memory_error();", "} else {", "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 ]

[ [ 1, 3 ], [ 5, 7 ], [ 9 ], [ 11 ], [ 17, 19, 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 32 ], [ 34 ], [ 36, 38 ], [ 40 ], [ 42 ], [ 44 ], [ 46 ], [ 48 ], [ 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ] ]

[ "static int FUNC_0(MXFPackage *VAR_0, ByteIOContext *VAR_1, int VAR_2)\n{", "switch(VAR_2) {", "case 0x4403:\nVAR_0->tracks_count = get_be32(VAR_1);", "if (VAR_0->tracks_count >= UINT_MAX / sizeof(UID))\nreturn -1;", "VAR_0->tracks_refs = av_malloc(VAR_0->tracks_count * sizeof(UID));", "if (!VAR_0->tracks_refs)\nreturn -1;", "url_fskip(VAR_1, 4);", "get_buffer(VAR_1, (uint8_t *)VAR_0->tracks_refs, VAR_0->tracks_count * sizeof(UID));", "break;", "}", "return 0;", "}" ]

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

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "struct VAR_2 *VAR_2 = VAR_0;", "if (VAR_1 != 0) {", "xen_be_printf(&VAR_2->blkdev->xendev, 0, \"%s I/O error\\n\",\nVAR_2->req.operation == BLKIF_OP_READ ? \"read\" : \"write\");", "VAR_2->aio_errors++;", "}", "VAR_2->aio_inflight--;", "if (VAR_2->presync) {", "VAR_2->presync = 0;", "ioreq_runio_qemu_aio(VAR_2);", "return;", "}", "if (VAR_2->aio_inflight > 0) {", "return;", "}", "if (VAR_2->postsync) {", "VAR_2->postsync = 0;", "VAR_2->aio_inflight++;", "bdrv_aio_flush(VAR_2->blkdev->bs, FUNC_0, VAR_2);", "return;", "}", "VAR_2->status = VAR_2->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;", "ioreq_unmap(VAR_2);", "ioreq_finish(VAR_2);", "switch (VAR_2->req.operation) {", "case BLKIF_OP_WRITE:\ncase BLKIF_OP_FLUSH_DISKCACHE:\nif (!VAR_2->req.nr_segments) {", "break;", "}", "case BLKIF_OP_READ:\nblock_acct_done(bdrv_get_stats(VAR_2->blkdev->bs), &VAR_2->acct);", "break;", "case BLKIF_OP_DISCARD:\ndefault:\nbreak;", "}", "qemu_bh_schedule(VAR_2->blkdev->bh);", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, QSVEncContext *VAR_1)\n{", "const char *VAR_2;", "mfxU16 rc_mode;", "int VAR_3 = VAR_1->la_depth >= 0;", "int VAR_4 = !!(VAR_0->flags & AV_CODEC_FLAG_QSCALE);", "int VAR_5 = VAR_1->vcm;", "if (VAR_3 && !QSV_HAVE_LA) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Lookahead ratecontrol mode requested, but is not supported by this SDK version\\n\");", "return AVERROR(ENOSYS);", "}", "if (VAR_5 && !QSV_HAVE_VCM) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"VCM ratecontrol mode requested, but is not supported by this SDK version\\n\");", "return AVERROR(ENOSYS);", "}", "if (VAR_3 + VAR_4 + VAR_5 > 1) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"More than one of: { constant qscale, lookahead, VCM } requested, \"", "\"only one of them can be used at a time.\\n\");", "return AVERROR(EINVAL);", "}", "if (VAR_4) {", "rc_mode = MFX_RATECONTROL_CQP;", "VAR_2 = \"constant quantization parameter (CQP)\";", "}", "#if QSV_HAVE_VCM\nelse if (VAR_5) {", "rc_mode = MFX_RATECONTROL_VCM;", "VAR_2 = \"video conferencing mode (VCM)\";", "}", "#endif\n#if QSV_HAVE_LA\nelse if (VAR_3) {", "rc_mode = MFX_RATECONTROL_LA;", "VAR_2 = \"VBR with lookahead (LA)\";", "#if QSV_HAVE_ICQ\nif (VAR_0->global_quality > 0) {", "rc_mode = MFX_RATECONTROL_LA_ICQ;", "VAR_2 = \"intelligent constant quality with lookahead (LA_ICQ)\";", "}", "#endif\n}", "#endif\n#if QSV_HAVE_ICQ\nelse if (VAR_0->global_quality > 0) {", "rc_mode = MFX_RATECONTROL_ICQ;", "VAR_2 = \"intelligent constant quality (ICQ)\";", "}", "#endif\nelse if (VAR_0->rc_max_rate == VAR_0->bit_rate) {", "rc_mode = MFX_RATECONTROL_CBR;", "VAR_2 = \"constant bitrate (CBR)\";", "} else if (!VAR_0->rc_max_rate) {", "rc_mode = MFX_RATECONTROL_AVBR;", "VAR_2 = \"average variable bitrate (AVBR)\";", "} else {", "rc_mode = MFX_RATECONTROL_VBR;", "VAR_2 = \"variable bitrate (VBR)\";", "}", "VAR_1->param.mfx.RateControlMethod = rc_mode;", "av_log(VAR_0, AV_LOG_VERBOSE, \"Using the %s ratecontrol method\\n\", VAR_2);", "return 0;", "}" ]

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

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