Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "m5206_mbar_state *s = (m5206_mbar_state *)VAR_0;", "int VAR_3;", "VAR_1 &= 0x3ff;", "if (VAR_1 >= 0x200) {", "hw_error(\"Bad MBAR write VAR_1 0x%x\", (int)VAR_1);", "}", "VAR_3 = m5206_mbar_width[VAR_1 >> 2];", "if (VAR_3 > 1) {", "uint32_t tmp;", "tmp = m5206_mbar_readw(VAR_0, VAR_1 & ~1);", "if (VAR_1 & 1) {", "tmp = (tmp & 0xff00) | VAR_2;", "} else {", "tmp = (tmp & 0x00ff) | (VAR_2 << 8);", "}", "m5206_mbar_writew(VAR_0, VAR_1 & ~1, tmp);", "return;", "}", "m5206_mbar_write(s, VAR_1, VAR_2, 1);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "mv88w8618_pit_state *s = VAR_0;", "mv88w8618_timer_state *t;", "int VAR_3;", "switch (VAR_1) {", "case MP_PIT_TIMER1_LENGTH ... MP_PIT_TIMER4_LENGTH:\nt = &s->timer[VAR_1 >> 2];", "t->limit = VAR_2;", "ptimer_set_limit(t->ptimer, t->limit, 1);", "break;", "case MP_PIT_CONTROL:\nfor (VAR_3 = 0; VAR_3 < 4; VAR_3++) {", "if (VAR_2 & 0xf) {", "t = &s->timer[VAR_3];", "ptimer_set_limit(t->ptimer, t->limit, 0);", "ptimer_set_freq(t->ptimer, t->freq);", "ptimer_run(t->ptimer, 0);", "}", "VAR_2 >>= 4;", "}", "break;", "case MP_BOARD_RESET:\nif (VAR_2 == MP_BOARD_RESET_MAGIC) {", "qemu_system_reset_request();", "}", "break;", "}", "}" ]

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

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

[ "static void FUNC_0 (HWVoiceOut *VAR_0)\n{", "SWVoiceCap *sc = VAR_0->cap_head.lh_first;", "while (sc) {", "SWVoiceCap *sc1 = sc->entries.le_next;", "SWVoiceOut *sw = &sc->sw;", "CaptureVoiceOut *cap = sc->cap;", "int VAR_1 = sw->active;", "if (sw->rate) {", "st_rate_stop (sw->rate);", "sw->rate = NULL;", "}", "LIST_REMOVE (sw, entries);", "LIST_REMOVE (sc, entries);", "qemu_free (sc);", "if (VAR_1) {", "audio_recalc_and_notify_capture (cap);", "}", "sc = sc1;", "}", "}" ]

[ 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 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ] ]

[ "unsigned FUNC_0(S390CPU *VAR_0)\n{", "CPUState *cs = CPU(VAR_0);", "if (cs->halted == 0) {", "assert(s390_running_cpus >= 1);", "s390_running_cpus--;", "cs->halted = 1;", "cs->exception_index = EXCP_HLT;", "}", "return s390_running_cpus;", "}" ]

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

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

[ "static int FUNC_0(BDRVRawState *VAR_0)\n{", "int VAR_1;", "for (VAR_1 = 0; VAR_1 < RAW_FD_POOL_SIZE; VAR_1++) {", "if (VAR_0->fd_pool[VAR_1] != -1)\ncontinue;", "VAR_0->fd_pool[VAR_1] = dup(VAR_0->fd);", "if (VAR_0->fd_pool[VAR_1] != -1)\nreturn VAR_0->fd_pool[VAR_1];", "}", "return VAR_0->fd;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 13, 15 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 33 ], [ 35 ] ]

[ "static CharDriverState *FUNC_0(ChardevHostdev *opts)\n{", "const char *VAR_0 = opts->device;", "CharDriverState *chr;", "WinCharState *s;", "chr = g_malloc0(sizeof(CharDriverState));", "s = g_malloc0(sizeof(WinCharState));", "chr->opaque = s;", "chr->chr_write = win_chr_write;", "chr->chr_close = win_chr_close;", "if (win_chr_pipe_init(chr, VAR_0) < 0) {", "g_free(s);", "g_free(chr);", "return NULL;", "}", "return chr;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "CirrusVGAState *s = VAR_0;", "unsigned VAR_4;", "VAR_1 &= s->cirrus_addr_mask;", "if (((s->vga.sr[0x17] & 0x44) == 0x44) &&\n((VAR_1 & s->linear_mmio_mask) == s->linear_mmio_mask)) {", "cirrus_mmio_blt_write(s, VAR_1 & 0xff, VAR_2);", "} else if (s->cirrus_srcptr != s->cirrus_srcptr_end) {", "*s->cirrus_srcptr++ = (uint8_t) VAR_2;", "if (s->cirrus_srcptr >= s->cirrus_srcptr_end) {", "cirrus_bitblt_cputovideo_next(s);", "}", "} else {", "if ((s->vga.gr[0x0B] & 0x14) == 0x14) {", "VAR_1 <<= 4;", "} else if (s->vga.gr[0x0B] & 0x02) {", "VAR_1 <<= 3;", "}", "VAR_1 &= s->cirrus_addr_mask;", "VAR_4 = s->vga.gr[0x05] & 0x7;", "if (VAR_4 < 4 || VAR_4 > 5 || ((s->vga.gr[0x0B] & 0x4) == 0)) {", "*(s->vga.vram_ptr + VAR_1) = (uint8_t) VAR_2;", "memory_region_set_dirty(&s->vga.vram, VAR_1, 1);", "} else {", "if ((s->vga.gr[0x0B] & 0x14) != 0x14) {", "cirrus_mem_writeb_mode4and5_8bpp(s, VAR_4, VAR_1, VAR_2);", "} else {", "cirrus_mem_writeb_mode4and5_16bpp(s, VAR_4, VAR_1, 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 ]

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

[ "static void FUNC_0(void *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "GDBState *s = VAR_0;", "int VAR_3;", "for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {", "gdb_read_byte(s, VAR_1[VAR_3]);", "}", "}" ]

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

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

[ "FUNC_0(int *VAR_0, int *VAR_1, Display *VAR_2, AVFormatContext *VAR_3)\n{", "Window mrootwindow, childwindow;", "int VAR_4;", "mrootwindow = DefaultRootWindow(VAR_2);", "if (XQueryPointer(VAR_2, mrootwindow, &mrootwindow, &childwindow,\nVAR_0, VAR_1, &VAR_4, &VAR_4, (unsigned int*)&VAR_4)) {", "} else {", "av_log(VAR_3, AV_LOG_INFO, \"couldn't find mouse pointer\\n\");", "*VAR_0 = -1;", "*VAR_1 = -1;", "}", "}" ]

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

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

[ "uint64_t FUNC_0(uint64_t t0, uint64_t t1)\n{", "uint64_t ret;", "if (t1 == env->lock) {", "stq_raw(t1, t0);", "ret = 0;", "} else", "ret = 1;", "env->lock = 1;", "return ret;", "}" ]

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

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

[ "av_cold void FUNC_0(PixblockDSPContext *c, AVCodecContext *avctx)\n{", "const unsigned VAR_0 = avctx->bits_per_raw_sample > 8;", "c->diff_pixels = diff_pixels_c;", "switch (avctx->bits_per_raw_sample) {", "case 9:\ncase 10:\ncase 12:\ncase 14:\nc->get_pixels = get_pixels_16_c;", "break;", "default:\nif (avctx->bits_per_raw_sample<=8 || avctx->codec_type != AVMEDIA_TYPE_VIDEO) {", "c->get_pixels = get_pixels_8_c;", "}", "break;", "}", "if (ARCH_ALPHA)\nff_pixblockdsp_init_alpha(c, avctx, VAR_0);", "if (ARCH_ARM)\nff_pixblockdsp_init_arm(c, avctx, VAR_0);", "if (ARCH_PPC)\nff_pixblockdsp_init_ppc(c, avctx, VAR_0);", "if (ARCH_X86)\nff_pixblockdsp_init_x86(c, avctx, VAR_0);", "if (ARCH_MIPS)\nff_pixblockdsp_init_mips(c, avctx, VAR_0);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 10 ], [ 14 ], [ 16, 18, 20, 22, 24 ], [ 26 ], [ 28, 30 ], [ 32 ], [ 34 ], [ 36 ], [ 38 ], [ 42, 44 ], [ 46, 48 ], [ 50, 52 ], [ 54, 56 ], [ 58, 60 ], [ 62 ] ]

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "int VAR_1;", "gen_op_movl_A0_reg(R_ESP);", "gen_op_addl_A0_im(-8 << VAR_0->dflag);", "if (!VAR_0->ss32)\ntcg_gen_ext16u_tl(cpu_A0, cpu_A0);", "tcg_gen_mov_tl(cpu_T[1], cpu_A0);", "if (VAR_0->addseg)\ngen_op_addl_A0_seg(VAR_0, R_SS);", "for(VAR_1 = 0;VAR_1 < 8; VAR_1++) {", "gen_op_mov_v_reg(MO_32, cpu_T[0], 7 - VAR_1);", "gen_op_st_v(VAR_0, VAR_0->dflag, cpu_T[0], cpu_A0);", "gen_op_addl_A0_im(1 << VAR_0->dflag);", "}", "gen_op_mov_reg_v(MO_16 + VAR_0->ss32, R_ESP, cpu_T[1]);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, uint64_t VAR_1,\nstruct usb_redir_buffered_bulk_packet_header *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{", "USBRedirDevice *dev = VAR_0;", "uint8_t status, ep = VAR_2->endpoint;", "void *VAR_5;", "int VAR_6, VAR_7;", "DPRINTF(\"buffered-bulk-in status %d ep %02X VAR_7 %d VAR_1 %\"PRIu64\"\\n\",\nVAR_2->status, ep, VAR_4, VAR_1);", "if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_BULK) {", "ERROR(\"received buffered-bulk packet for non bulk ep %02X\\n\", ep);", "free(VAR_3);", "return;", "}", "if (dev->endpoint[EP2I(ep)].bulk_receiving_started == 0) {", "DPRINTF(\"received buffered-bulk packet on not started ep %02X\\n\", ep);", "free(VAR_3);", "return;", "}", "VAR_7 = dev->endpoint[EP2I(ep)].max_packet_size;", "status = usb_redir_success;", "VAR_5 = NULL;", "for (VAR_6 = 0; VAR_6 < VAR_4; VAR_6 += VAR_7) {", "if (VAR_7 >= (VAR_4 - VAR_6)) {", "VAR_7 = VAR_4 - VAR_6;", "status = VAR_2->status;", "VAR_5 = VAR_3;", "}", "bufp_alloc(dev, VAR_3 + VAR_6, VAR_7, status, ep, VAR_5);", "}", "if (dev->endpoint[EP2I(ep)].pending_async_packet) {", "USBPacket *p = dev->endpoint[EP2I(ep)].pending_async_packet;", "dev->endpoint[EP2I(ep)].pending_async_packet = NULL;", "usbredir_buffered_bulk_in_complete(dev, p, ep);", "usb_packet_complete(&dev->dev, p);", "}", "}" ]

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

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

[ "static int FUNC_0(AVFilterLink *VAR_0)\n{", "AVFilterContext *s = VAR_0->src;", "OverlayContext *over = s->priv;", "int VAR_1 = avfilter_poll_frame(s->inputs[OVERLAY]);", "if (VAR_1 == AVERROR_EOF)\nVAR_1 = !!over->overpicref;", "return VAR_1 && avfilter_poll_frame(s->inputs[MAIN]);", "}" ]

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

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

[ "static void FUNC_0(DSPContext *VAR_0, FFTContext *VAR_1,\nfloat *VAR_2, float VAR_3[2][38][64],\nfloat VAR_4[2][64],\nfloat *VAR_5, int *VAR_6, const unsigned int VAR_7)\n{", "int VAR_8, VAR_9;", "const float *VAR_10 = VAR_7 ? sbr_qmf_window_ds : sbr_qmf_window_us;", "float *VAR_11;", "for (VAR_8 = 0; VAR_8 < 32; VAR_8++) {", "if (*VAR_6 == 0) {", "int VAR_12 = (1280 - 128) >> VAR_7;", "memcpy(&VAR_5[SBR_SYNTHESIS_BUF_SIZE - VAR_12], VAR_5, VAR_12 * sizeof(float));", "*VAR_6 = SBR_SYNTHESIS_BUF_SIZE - VAR_12 - (128 >> VAR_7);", "} else {", "*VAR_6 -= 128 >> VAR_7;", "}", "VAR_11 = VAR_5 + *VAR_6;", "if (VAR_7) {", "for (VAR_9 = 0; VAR_9 < 32; VAR_9++) {", "VAR_3[0][VAR_8][ VAR_9] = -VAR_3[0][VAR_8][VAR_9];", "VAR_3[0][VAR_8][32+VAR_9] = VAR_3[1][VAR_8][31-VAR_9];", "}", "VAR_1->imdct_half(VAR_1, VAR_4[0], VAR_3[0][VAR_8]);", "for (VAR_9 = 0; VAR_9 < 32; VAR_9++) {", "VAR_11[ VAR_9] = VAR_4[0][63 - 2*VAR_9];", "VAR_11[63 - VAR_9] = -VAR_4[0][62 - 2*VAR_9];", "}", "} else {", "for (VAR_9 = 1; VAR_9 < 64; VAR_9+=2) {", "VAR_3[1][VAR_8][VAR_9] = -VAR_3[1][VAR_8][VAR_9];", "}", "VAR_1->imdct_half(VAR_1, VAR_4[0], VAR_3[0][VAR_8]);", "VAR_1->imdct_half(VAR_1, VAR_4[1], VAR_3[1][VAR_8]);", "for (VAR_9 = 0; VAR_9 < 64; VAR_9++) {", "VAR_11[ VAR_9] = -VAR_4[0][63 - VAR_9] + VAR_4[1][ VAR_9 ];", "VAR_11[127 - VAR_9] = VAR_4[0][63 - VAR_9] + VAR_4[1][ VAR_9 ];", "}", "}", "VAR_0->vector_fmul_add(VAR_2, VAR_11 , VAR_10 , zero64, 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 192 >> VAR_7), VAR_10 + ( 64 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 256 >> VAR_7), VAR_10 + (128 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 448 >> VAR_7), VAR_10 + (192 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 512 >> VAR_7), VAR_10 + (256 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 704 >> VAR_7), VAR_10 + (320 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 768 >> VAR_7), VAR_10 + (384 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + ( 960 >> VAR_7), VAR_10 + (448 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + (1024 >> VAR_7), VAR_10 + (512 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_0->vector_fmul_add(VAR_2, VAR_11 + (1216 >> VAR_7), VAR_10 + (576 >> VAR_7), VAR_2 , 64 >> VAR_7);", "VAR_2 += 64 >> VAR_7;", "}", "}" ]

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

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

[ "void FUNC_0(VirtIODevice *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{", "VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(VAR_0);", "uint8_t val = VAR_2;", "if (VAR_1 > (VAR_0->config_len - sizeof(val)))\nreturn;", "stb_p(VAR_0->config + VAR_1, val);", "if (k->set_config) {", "k->set_config(VAR_0, VAR_0->config);", "}", "}" ]

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

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

[ "static int FUNC_0(J2kDecoderContext *VAR_0, int VAR_1, J2kQuantStyle *VAR_2)\n{", "int VAR_3, VAR_4;", "if (VAR_0->buf_end - VAR_0->buf < 1)\nreturn AVERROR(EINVAL);", "VAR_4 = bytestream_get_byte(&VAR_0->buf);", "VAR_2->nguardbits = VAR_4 >> 5;", "VAR_2->quantsty = VAR_4 & 0x1f;", "if (VAR_2->quantsty == J2K_QSTY_NONE){", "VAR_1 -= 3;", "if (VAR_0->buf_end - VAR_0->buf < VAR_1)\nreturn AVERROR(EINVAL);", "for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++)", "VAR_2->expn[VAR_3] = bytestream_get_byte(&VAR_0->buf) >> 3;", "} else if (VAR_2->quantsty == J2K_QSTY_SI){", "if (VAR_0->buf_end - VAR_0->buf < 2)\nreturn AVERROR(EINVAL);", "VAR_4 = bytestream_get_be16(&VAR_0->buf);", "VAR_2->expn[0] = VAR_4 >> 11;", "VAR_2->mant[0] = VAR_4 & 0x7ff;", "for (VAR_3 = 1; VAR_3 < 32 * 3; VAR_3++){", "int VAR_5 = FFMAX(0, VAR_2->expn[0] - (VAR_3-1)/3);", "VAR_2->expn[VAR_3] = VAR_5;", "VAR_2->mant[VAR_3] = VAR_2->mant[0];", "}", "} else{", "VAR_1 = (VAR_1 - 3) >> 1;", "if (VAR_0->buf_end - VAR_0->buf < VAR_1)\nreturn AVERROR(EINVAL);", "for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++){", "VAR_4 = bytestream_get_be16(&VAR_0->buf);", "VAR_2->expn[VAR_3] = VAR_4 >> 11;", "VAR_2->mant[VAR_3] = VAR_4 & 0x7ff;", "}", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(ByteIOContext *VAR_0, MOVTrack* VAR_1)\n{", "int VAR_2 = url_ftell(VAR_0);", "char VAR_3[32];", "int VAR_4;", "put_be32(VAR_0, 0);", "VAR_4 = VAR_1->enc->codec_tag;", "if (!VAR_4)\nVAR_4 = codec_get_tag(codec_movvideo_tags, VAR_1->enc->codec_id);", "if (!VAR_4)\nVAR_4 = codec_get_tag(codec_bmp_tags, VAR_1->enc->codec_id);", "put_le32(VAR_0, VAR_4);", "put_be32(VAR_0, 0);", "put_be16(VAR_0, 0);", "put_be16(VAR_0, 1);", "put_be16(VAR_0, 0);", "put_be16(VAR_0, 0);", "put_tag(VAR_0, \"FFMP\");", "if(VAR_1->enc->codec_id == CODEC_ID_RAWVIDEO) {", "put_be32(VAR_0, 0);", "put_be32(VAR_0, 0x400);", "} else {", "put_be32(VAR_0, 0x200);", "put_be32(VAR_0, 0x200);", "}", "put_be16(VAR_0, VAR_1->enc->width);", "put_be16(VAR_0, VAR_1->enc->height);", "put_be32(VAR_0, 0x00480000);", "put_be32(VAR_0, 0x00480000);", "put_be32(VAR_0, 0);", "put_be16(VAR_0, 1);", "memset(VAR_3,0,32);", "if (VAR_1->enc->codec->name)\nstrncpy(VAR_3,VAR_1->enc->codec->name,31);", "put_byte(VAR_0, FFMAX(strlen(VAR_3),32) );", "put_buffer(VAR_0, VAR_3, 31);", "put_be16(VAR_0, 0x18);", "put_be16(VAR_0, 0xffff);", "if(VAR_1->enc->codec_id == CODEC_ID_MPEG4)\nmov_write_esds_tag(VAR_0, VAR_1);", "else if(VAR_1->enc->codec_id == CODEC_ID_H263)\nmov_write_d263_tag(VAR_0);", "else if(VAR_1->enc->codec_id == CODEC_ID_SVQ3)\nmov_write_svq3_tag(VAR_0);", "return updateSize (VAR_0, 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, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ]

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

[ "FUNC_0(const int32_t *VAR_0, uint16_t *VAR_1, int VAR_2,\nint VAR_3, int VAR_4)\n{", "int VAR_5;", "int VAR_6 = 19 - VAR_4;", "for (VAR_5 = 0; VAR_5 < VAR_2; VAR_5++) {", "int VAR_7 = VAR_0[VAR_5] + (1 << (VAR_6 - 1));", "output_pixel(&VAR_1[VAR_5], VAR_7, 0, uint);", "}", "}" ]

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

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

[ "void FUNC_0(MpegEncContext *VAR_0, MpegEncContext *VAR_1)\n{", "MpegEncContext bak;", "int VAR_2;", "backup_duplicate_context(&bak, VAR_0);", "memcpy(VAR_0, VAR_1, sizeof(MpegEncContext));", "backup_duplicate_context(VAR_0, &bak);", "for (VAR_2 = 0; VAR_2 < 12; VAR_2++) {", "VAR_0->pblocks[VAR_2] = &VAR_0->block[VAR_2];", "}", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0,\nAVFormatParameters *VAR_1)\n{", "MpegDemuxContext *m;", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;", "int VAR_10, VAR_11, VAR_12, VAR_13;", "AVStream *st;", "m = av_mallocz(sizeof(MpegDemuxContext));", "if (!m)\nreturn -ENOMEM;", "VAR_0->priv_data = m;", "m->header_state = 0xff;", "VAR_2 = MAX_SYNC_SIZE;", "for(;;) {", "while (VAR_2 > 0) {", "VAR_3 = find_start_code(&VAR_0->pb, &VAR_2, &m->header_state);", "if (VAR_3 == PACK_START_CODE)\ngoto found;", "}", "return -ENODATA;", "found:\nget_byte(&VAR_0->pb);", "get_be16(&VAR_0->pb);", "get_be16(&VAR_0->pb);", "VAR_8 = get_byte(&VAR_0->pb) << 16;", "VAR_8 |= get_byte(&VAR_0->pb) << 8;", "VAR_8 |= get_byte(&VAR_0->pb);", "VAR_8 &= (1 << 22) - 1;", "m->VAR_8 = VAR_8;", "VAR_3 = find_start_code(&VAR_0->pb, &VAR_2, &m->header_state);", "if (VAR_3 == SYSTEM_HEADER_START_CODE)\nbreak;", "}", "VAR_2 = get_be16(&VAR_0->pb);", "VAR_5 = get_byte(&VAR_0->pb) << 16;", "VAR_5 |= get_byte(&VAR_0->pb) << 8;", "VAR_5 |= get_byte(&VAR_0->pb);", "VAR_5 = (VAR_5 >> 1) & ((1 << 22) - 1);", "VAR_6 = get_byte(&VAR_0->pb) >> 2;", "VAR_7 = get_byte(&VAR_0->pb) & 0x1f;", "get_byte(&VAR_0->pb);", "#if 0\nprintf(\"VAR_8=%d kbit/VAR_0\\VAR_11\", (m->VAR_8 * 50 * 8) / 1000);", "printf(\"VAR_5=%d\\VAR_11\", VAR_5);", "printf(\"VAR_6=%d\\VAR_11\", VAR_6);", "printf(\"VAR_7=%d\\VAR_11\", VAR_7);", "#endif\nVAR_2 -= 6;", "VAR_0->nb_streams = 0;", "while (VAR_2 > 0) {", "VAR_4 = get_byte(&VAR_0->pb);", "VAR_2--;", "if ((VAR_4 & 0x80) == 0)\nbreak;", "VAR_9 = get_be16(&VAR_0->pb);", "VAR_2 -= 2;", "if (VAR_4 >= 0xc0 && VAR_4 <= 0xdf) {", "VAR_13 = CODEC_TYPE_AUDIO;", "VAR_10 = CODEC_ID_MP2;", "VAR_11 = 1;", "VAR_4 = VAR_4 | 0x100;", "} else if (VAR_4 >= 0xe0 && VAR_4 <= 0xef) {", "VAR_13 = CODEC_TYPE_VIDEO;", "VAR_10 = CODEC_ID_MPEG1VIDEO;", "VAR_11 = 1;", "VAR_4 = VAR_4 | 0x100;", "} else if (VAR_4 == 0xb8) {", "VAR_13 = CODEC_TYPE_AUDIO;", "VAR_10 = CODEC_ID_AC3;", "VAR_11 = VAR_6;", "VAR_4 = 0x80;", "} else if (VAR_4 == 0xb9) {", "VAR_13 = CODEC_TYPE_VIDEO;", "VAR_10 = CODEC_ID_MPEG1VIDEO;", "VAR_11 = VAR_7;", "VAR_4 = 0x1e0;", "} else {", "VAR_13 = 0;", "VAR_10 = 0;", "VAR_11 = 0;", "}", "for(VAR_12=0;VAR_12<VAR_11;VAR_12++) {", "st = av_mallocz(sizeof(AVStream));", "if (!st)\nreturn -ENOMEM;", "VAR_0->streams[VAR_0->nb_streams++] = st;", "st->id = VAR_4 + VAR_12;", "st->codec.codec_type = VAR_13;", "st->codec.VAR_10 = VAR_10;", "}", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47, 53 ], [ 55 ], [ 57 ], [ 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 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 211 ], [ 213 ] ]

[ "static bool FUNC_0(CPUArchState *env, size_t mmu_idx, size_t index,\nsize_t elt_ofs, target_ulong page)\n{", "size_t vidx;", "for (vidx = 0; vidx < CPU_VTLB_SIZE; ++vidx) {", "CPUTLBEntry *vtlb = &env->tlb_v_table[mmu_idx][vidx];", "target_ulong cmp = *(target_ulong *)((uintptr_t)vtlb + elt_ofs);", "if (cmp == page) {", "CPUTLBEntry tmptlb, *tlb = &env->tlb_table[mmu_idx][index];", "CPUIOTLBEntry tmpio, *io = &env->iotlb[mmu_idx][index];", "CPUIOTLBEntry *vio = &env->iotlb_v[mmu_idx][vidx];", "tmptlb = *tlb; *tlb = *vtlb; *vtlb = tmptlb;", "tmpio = *io; *io = *vio; *vio = tmpio;", "return true;", "}", "}", "return false;", "}" ]

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

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

[ "static inline unsigned FUNC_0(IVState *VAR_0, enum Reg VAR_1)\n{", "const char *VAR_2 = reg2str(VAR_1);", "QTestState *qtest = global_qtest;", "unsigned VAR_3;", "global_qtest = VAR_0->qtest;", "VAR_3 = qpci_io_readl(VAR_0->dev, VAR_0->reg_base + VAR_1);", "g_test_message(\"*%VAR_0 -> %x\\n\", VAR_2, VAR_3);", "global_qtest = qtest;", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0)\n{", "FWCfgState *s = FW_CFG(VAR_0);", "MachineState *machine = MACHINE(qdev_get_machine());", "uint32_t version = FW_CFG_VERSION;", "assert(!object_resolve_path(FW_CFG_PATH, NULL));", "object_property_add_child(OBJECT(machine), FW_CFG_NAME, OBJECT(s), NULL);", "qdev_init_nofail(VAR_0);", "fw_cfg_add_bytes(s, FW_CFG_SIGNATURE, (char *)\"QEMU\", 4);", "fw_cfg_add_bytes(s, FW_CFG_UUID, &qemu_uuid, 16);", "fw_cfg_add_i16(s, FW_CFG_NOGRAPHIC, (uint16_t)!machine->enable_graphics);", "fw_cfg_add_i16(s, FW_CFG_BOOT_MENU, (uint16_t)boot_menu);", "fw_cfg_bootsplash(s);", "fw_cfg_reboot(s);", "if (s->dma_enabled) {", "version |= FW_CFG_VERSION_DMA;", "}", "fw_cfg_add_i32(s, FW_CFG_ID, version);", "s->machine_ready.notify = fw_cfg_machine_ready;", "qemu_add_machine_init_done_notifier(&s->machine_ready);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ] ]

[ "static void FUNC_0(PCIDevice *VAR_0, int VAR_1,\npcibus_t VAR_2, pcibus_t VAR_3, int VAR_4)\n{", "PCIIDEState *d = DO_UPCAST(PCIIDEState, dev, VAR_0);", "int VAR_5;", "for(VAR_5 = 0;VAR_5 < 2; VAR_5++) {", "BMDMAState *bm = &d->bmdma[VAR_5];", "d->bus[VAR_5].bmdma = bm;", "bm->bus = d->bus+VAR_5;", "qemu_add_vm_change_state_handler(ide_dma_restart_cb, bm);", "register_ioport_write(VAR_2, 1, 1, bmdma_cmd_writeb, bm);", "register_ioport_write(VAR_2 + 1, 3, 1, bmdma_writeb, bm);", "register_ioport_read(VAR_2, 4, 1, bmdma_readb, bm);", "register_ioport_write(VAR_2 + 4, 4, 1, bmdma_addr_writeb, bm);", "register_ioport_read(VAR_2 + 4, 4, 1, bmdma_addr_readb, bm);", "register_ioport_write(VAR_2 + 4, 4, 2, bmdma_addr_writew, bm);", "register_ioport_read(VAR_2 + 4, 4, 2, bmdma_addr_readw, bm);", "register_ioport_write(VAR_2 + 4, 4, 4, bmdma_addr_writel, bm);", "register_ioport_read(VAR_2 + 4, 4, 4, bmdma_addr_readl, bm);", "VAR_2 += 8;", "}", "}" ]

[ 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 ], [ 22 ], [ 26 ], [ 30 ], [ 32 ], [ 36 ], [ 38 ], [ 40 ], [ 42 ], [ 44 ], [ 46 ], [ 48 ], [ 50 ], [ 52 ] ]

[ "static uint32_t FUNC_0(uint32_t x, uint64_t mantissa)\n{", "uint64_t l = x * (mantissa & 0xffffffff);", "uint64_t h = x * (mantissa >> 32);", "h += l >> 32;", "l &= 0xffffffff;", "l += 1 << av_log2(h >> 21);", "h += l >> 32;", "return h >> 20;", "}" ]

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

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

[ "static void FUNC_0(GetBitContext *VAR_0, BlockInfo *VAR_1, DCTELEM *VAR_2)\n{", "int VAR_3 = VAR_0->size_in_bits;", "const uint8_t *VAR_4 = VAR_1->VAR_4;", "const uint32_t *VAR_5 = VAR_1->VAR_5;", "int VAR_6 = VAR_1->VAR_6;", "int VAR_7 = VAR_1->VAR_7;", "int VAR_8, VAR_9, VAR_10, VAR_11;", "OPEN_READER(re, VAR_0);", "UPDATE_CACHE(re, VAR_0);", "if (VAR_7 > 0) {", "re_cache = ((unsigned)re_cache >> VAR_7) |\n(VAR_1->partial_bit_buffer << (sizeof(re_cache) * 8 - VAR_7));", "re_index -= VAR_7;", "VAR_1->VAR_7 = 0;", "}", "for (;;) {", "av_dlog(NULL, \"%2d: bits=%04x VAR_11=%d\\n\", VAR_6, SHOW_UBITS(re, VAR_0, 16),\nre_index);", "VAR_11 = NEG_USR32(re_cache, TEX_VLC_BITS);", "VAR_10 = dv_rl_vlc[VAR_11].len;", "if (VAR_10 < 0) {", "VAR_11 = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -VAR_10) + dv_rl_vlc[VAR_11].VAR_8;", "VAR_10 = TEX_VLC_BITS - VAR_10;", "}", "VAR_8 = dv_rl_vlc[VAR_11].VAR_8;", "VAR_9 = dv_rl_vlc[VAR_11].VAR_9;", "if (re_index + VAR_10 > VAR_3) {", "VAR_1->VAR_7 = VAR_3 - re_index;", "VAR_1->partial_bit_buffer = NEG_USR32(re_cache, VAR_1->VAR_7);", "re_index = VAR_3;", "break;", "}", "re_index += VAR_10;", "av_dlog(NULL, \"VAR_9=%d VAR_8=%d\\n\", VAR_9, VAR_8);", "VAR_6 += VAR_9;", "if (VAR_6 >= 64)\nbreak;", "VAR_8 = (VAR_8 * VAR_5[VAR_6] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;", "VAR_2[VAR_4[VAR_6]] = VAR_8;", "UPDATE_CACHE(re, VAR_0);", "}", "CLOSE_READER(re, VAR_0);", "VAR_1->VAR_6 = VAR_6;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 43 ], [ 45, 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ] ]

[ "void FUNC_0(HotplugHandler *VAR_0, DeviceState *VAR_1,\nError **VAR_2)\n{", "sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(OBJECT(VAR_0));", "sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(VAR_0));", "sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(VAR_1));", "CPUCore *cc = CPU_CORE(VAR_1);", "CPUState *cs = CPU(core->threads);", "sPAPRDRConnector *drc;", "sPAPRDRConnectorClass *drck;", "Error *local_err = NULL;", "void *VAR_3 = NULL;", "int VAR_4 = 0;", "int VAR_5 = cc->core_id / smp_threads;", "int VAR_6 = kvmppc_smt_threads();", "g_assert(smc->dr_cpu_enabled);", "drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, VAR_5 * VAR_6);", "spapr->cores[VAR_5] = OBJECT(VAR_1);", "g_assert(drc);", "if (VAR_1->hotplugged) {", "VAR_3 = spapr_populate_hotplug_cpu_dt(cs, &VAR_4, spapr);", "}", "drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);", "drck->attach(drc, VAR_1, VAR_3, VAR_4, !VAR_1->hotplugged, &local_err);", "if (local_err) {", "g_free(VAR_3);", "spapr->cores[VAR_5] = NULL;", "error_propagate(VAR_2, local_err);", "return;", "}", "if (VAR_1->hotplugged) {", "spapr_hotplug_req_add_by_index(drc);", "} else {", "drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE);", "drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED);", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 43 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 91 ], [ 93 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ] ]

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

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "AVFrame *frame = VAR_1;", "CNGContext *p = VAR_0->priv_data;", "int VAR_4 = VAR_3->size;", "int VAR_5, VAR_6;", "int16_t *buf_out;", "float VAR_7 = 1.0;", "float VAR_8;", "if (VAR_3->size) {", "int VAR_9 = -VAR_3->VAR_1[0];", "p->target_energy = 1081109975 * ff_exp10(VAR_9 / 10.0) * 0.75;", "memset(p->target_refl_coef, 0, p->order * sizeof(*p->target_refl_coef));", "for (VAR_6 = 0; VAR_6 < FFMIN(VAR_3->size - 1, p->order); VAR_6++) {", "p->target_refl_coef[VAR_6] = (VAR_3->VAR_1[1 + VAR_6] - 127) / 128.0;", "}", "}", "if (VAR_0->internal->skip_samples > 10 * VAR_0->frame_size) {", "VAR_0->internal->skip_samples = 0;", "return AVERROR_INVALIDDATA;", "}", "if (p->inited) {", "p->energy = p->energy / 2 + p->target_energy / 2;", "for (VAR_6 = 0; VAR_6 < p->order; VAR_6++)", "p->refl_coef[VAR_6] = 0.6 *p->refl_coef[VAR_6] + 0.4 * p->target_refl_coef[VAR_6];", "} else {", "p->energy = p->target_energy;", "memcpy(p->refl_coef, p->target_refl_coef, p->order * sizeof(*p->refl_coef));", "p->inited = 1;", "}", "make_lpc_coefs(p->lpc_coef, p->refl_coef, p->order);", "for (VAR_6 = 0; VAR_6 < p->order; VAR_6++)", "VAR_7 *= 1.0 - p->refl_coef[VAR_6]*p->refl_coef[VAR_6];", "VAR_8 = sqrt(VAR_7 * p->energy / 1081109975);", "for (VAR_6 = 0; VAR_6 < VAR_0->frame_size; VAR_6++) {", "int r = (av_lfg_get(&p->lfg) & 0xffff) - 0x8000;", "p->excitation[VAR_6] = VAR_8 * r;", "}", "ff_celp_lp_synthesis_filterf(p->filter_out + p->order, p->lpc_coef,\np->excitation, VAR_0->frame_size, p->order);", "frame->nb_samples = VAR_0->frame_size;", "if ((VAR_5 = ff_get_buffer(VAR_0, frame, 0)) < 0)\nreturn VAR_5;", "buf_out = (int16_t *)frame->VAR_1[0];", "for (VAR_6 = 0; VAR_6 < VAR_0->frame_size; VAR_6++)", "buf_out[VAR_6] = p->filter_out[VAR_6 + p->order];", "memcpy(p->filter_out, p->filter_out + VAR_0->frame_size,\np->order * sizeof(*p->filter_out));", "*VAR_2 = 1;", "return VAR_4;", "}" ]

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

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "VDADecoderContext *ctx = avctx->priv_data;", "struct vda_context *VAR_0 = &ctx->VAR_0;", "OSStatus status;", "int VAR_1;", "ctx->h264_initialized = 0;", "if (!ff_h264_vda_decoder.pix_fmts) {", "if (kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber10_7)\nff_h264_vda_decoder.pix_fmts = vda_pixfmts_prior_10_7;", "else\nff_h264_vda_decoder.pix_fmts = vda_pixfmts;", "memset(VAR_0, 0, sizeof(struct vda_context));", "VAR_0->width = avctx->width;", "VAR_0->height = avctx->height;", "VAR_0->format = 'avc1';", "VAR_0->use_sync_decoding = 1;", "VAR_0->use_ref_buffer = 1;", "ctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);", "switch (ctx->pix_fmt) {", "case AV_PIX_FMT_UYVY422:\nVAR_0->cv_pix_fmt_type = '2vuy';", "break;", "case AV_PIX_FMT_YUYV422:\nVAR_0->cv_pix_fmt_type = 'yuvs';", "break;", "case AV_PIX_FMT_NV12:\nVAR_0->cv_pix_fmt_type = '420v';", "break;", "case AV_PIX_FMT_YUV420P:\nVAR_0->cv_pix_fmt_type = 'y420';", "break;", "default:\nav_log(avctx, AV_LOG_ERROR, \"Unsupported pixel format: %d\\n\", avctx->pix_fmt);", "status = ff_vda_create_decoder(VAR_0,\navctx->extradata, avctx->extradata_size);", "if (status != kVDADecoderNoErr) {", "av_log(avctx, AV_LOG_ERROR,\n\"Failed to init VDA decoder: %d.\\n\", status);", "set_context(avctx);", "VAR_1 = ff_h264_decoder.init(avctx);", "restore_context(avctx);", "if (VAR_1 < 0) {", "av_log(avctx, AV_LOG_ERROR, \"Failed to open H.264 decoder.\\n\");", "ctx->h264_initialized = 1;", "return 0;", "failed:\nvdadec_close(avctx);", "return -1;" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 9 ], [ 10, 11 ], [ 12, 13 ], [ 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 ], [ 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50, 51 ], [ 52 ] ]

[ "static void FUNC_0(const uint8_t *VAR_0, const long VAR_1, uint8_t * * VAR_2, int VAR_3, long VAR_4,\nint VAR_5, int VAR_6, long VAR_7, slice_buffer * VAR_8, int VAR_9, uint8_t * VAR_10){", "snow_inner_add_yblock_mmx_header\nsnow_inner_add_yblock_mmx_start(\"mm1\", \"mm5\", \"3\", \"0\", \"0\")\nsnow_inner_add_yblock_mmx_accum(\"2\", \"16\", \"0\")\nsnow_inner_add_yblock_mmx_accum(\"1\", \"512\", \"0\")\nsnow_inner_add_yblock_mmx_accum(\"0\", \"528\", \"0\")\nsnow_inner_add_yblock_mmx_mix(\"0\", \"0\")\nsnow_inner_add_yblock_mmx_start(\"mm1\", \"mm5\", \"3\", \"8\", \"8\")\nsnow_inner_add_yblock_mmx_accum(\"2\", \"24\", \"8\")\nsnow_inner_add_yblock_mmx_accum(\"1\", \"520\", \"8\")\nsnow_inner_add_yblock_mmx_accum(\"0\", \"536\", \"8\")\nsnow_inner_add_yblock_mmx_mix(\"32\", \"8\")\nsnow_inner_add_yblock_mmx_end(\"32\")\n}" ]

[ 0, 1 ]

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

[ "static void FUNC_0(VAR_0)\n{", "int VAR_1, VAR_2;", "uint16_t *dstw = (uint16_t *)dst;", "uint16_t *src1w = (uint16_t *)src1;", "uint16_t *src2w = (uint16_t *)src2;", "width /= 2;", "src1_linesize /= 2;", "src2_linesize /= 2;", "dst_linesize /= 2;", "for (VAR_1 = 0; VAR_1 < height; VAR_1++) {", "for (VAR_2 = 0; VAR_2 < width; VAR_2++)", "dstw[VAR_2] = ((src1w[VAR_2] * factor1) + (src2w[VAR_2] * factor2) + half) >> shift;", "src1w += src1_linesize;", "src2w += src2_linesize;", "dstw += dst_linesize;", "}", "}" ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0, unsigned char *VAR_1, int VAR_2, void *VAR_3)\n{", "CinepakEncContext *s = VAR_0->priv_data;", "AVFrame *frame = VAR_3;", "int VAR_4;", "s->lambda = frame->quality ? frame->quality - 1 : 2 * FF_LAMBDA_SCALE;", "frame->key_frame = s->curframe == 0;", "frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;", "VAR_4 = rd_frame(s, frame, VAR_1, VAR_2);", "FFSWAP(AVFrame, s->last_frame, s->best_frame);", "if (++s->curframe >= s->keyint)\ns->curframe = 0;", "return VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 31, 33 ], [ 37 ], [ 39 ] ]

[ "void FUNC_0(QEMUBH *VAR_0)\n{", "if (VAR_0->scheduled)\nreturn;", "VAR_0->idle = 1;", "smp_wmb();", "VAR_0->scheduled = 1;", "}" ]

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

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

[ "static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)\n{", "AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];", "MOVStreamContext *sc = st->priv_data;", "int VAR_3 = get_byte(VAR_1);", "int VAR_4;", "if (VAR_3 > 1)\nreturn -1;", "get_be24(VAR_1);", "if (VAR_3 == 1) {", "get_be64(VAR_1);", "get_be64(VAR_1);", "} else {", "get_be32(VAR_1);", "get_be32(VAR_1);", "}", "sc->time_scale = get_be32(VAR_1);", "st->duration = (VAR_3 == 1) ? get_be64(VAR_1) : get_be32(VAR_1);", "VAR_4 = get_be16(VAR_1);", "ff_mov_lang_to_iso639(VAR_4, st->language);", "get_be16(VAR_1);", "return 0;", "}" ]

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

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

[ "void FUNC_0(Error **VAR_0, ErrorClass VAR_1, const char *VAR_2, ...)\n{", "va_list ap;", "va_start(ap, VAR_2);", "error_setv(VAR_0, VAR_1, VAR_2, ap);", "va_end(ap);", "}" ]

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

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

[ "void FUNC_0(AUXSlave *VAR_0, MemoryRegion *VAR_1)\n{", "assert(!VAR_0->VAR_1);", "VAR_0->VAR_1 = VAR_1;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(VAR_0);", "k->init = s390_virtio_bridge_init;", "dc->no_user = 1;", "}" ]

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

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

[ "static void FUNC_0(VncState *VAR_0)\n{", "switch (VAR_0->subauth) {", "case VNC_AUTH_VENCRYPT_TLSNONE:\ncase VNC_AUTH_VENCRYPT_X509NONE:\nVNC_DEBUG(\"Accept TLS auth none\\n\");", "vnc_write_u32(VAR_0, 0);", "start_client_init(VAR_0);", "break;", "case VNC_AUTH_VENCRYPT_TLSVNC:\ncase VNC_AUTH_VENCRYPT_X509VNC:\nVNC_DEBUG(\"Start TLS auth VNC\\n\");", "start_auth_vnc(VAR_0);", "break;", "#ifdef CONFIG_VNC_SASL\ncase VNC_AUTH_VENCRYPT_TLSSASL:\ncase VNC_AUTH_VENCRYPT_X509SASL:\nVNC_DEBUG(\"Start TLS auth SASL\\n\");", "start_auth_sasl(VAR_0);", "break;", "#endif\ndefault:\nVNC_DEBUG(\"Reject subauth %d server bug\\n\", VAR_0->auth);", "vnc_write_u8(VAR_0, 1);", "if (VAR_0->minor >= 8) {", "static const char VAR_1[] = \"Unsupported authentication type\";", "vnc_write_u32(VAR_0, sizeof(VAR_1));", "vnc_write(VAR_0, VAR_1, sizeof(VAR_1));", "}", "vnc_client_error(VAR_0);", "}", "}" ]

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

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

[ "static void FUNC_0(const uint8_t *VAR_0, uint8_t *VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int VAR_5)\n{", "int VAR_6;", "int VAR_7;", "int VAR_8, VAR_9;", "int VAR_10, VAR_11;", "int VAR_12 = 0;", "int VAR_13;", "VAR_13 = VAR_5;", "VAR_5--;", "VAR_1 = VAR_1 + VAR_5 * VAR_3;", "while((VAR_2 > 0) && (VAR_13 > 0)) {", "VAR_7 = *VAR_0++;", "VAR_2--;", "VAR_10 = VAR_11 = 0;", "if(VAR_7 == 0xFC)\nbreak;", "if(VAR_7 >= 0xF8) {", "VAR_8 = *VAR_0++;", "VAR_9 = *VAR_0++;", "VAR_2 -= 2;", "VAR_10 = ((VAR_7 & 0x7) << 16) + (VAR_8 << 8) + VAR_9 + 2;", "} else if (VAR_7 >= 0xF0) {", "VAR_8 = *VAR_0++;", "VAR_2--;", "VAR_10 = ((VAR_7 & 0xF) << 8) + VAR_8 + 2;", "} else if (VAR_7 >= 0xE0) {", "VAR_10 = (VAR_7 & 0x1F) + 2;", "} else if (VAR_7 >= 0xC0) {", "VAR_8 = *VAR_0++;", "VAR_9 = *VAR_0++;", "VAR_2 -= 2;", "VAR_11 = ((VAR_7 & 0x3F) << 16) + (VAR_8 << 8) + VAR_9 + 1;", "} else if (VAR_7 >= 0x80) {", "VAR_8 = *VAR_0++;", "VAR_2--;", "VAR_11 = ((VAR_7 & 0x7F) << 8) + VAR_8 + 1;", "} else {", "VAR_11 = VAR_7 + 1;", "}", "if(VAR_10) {", "int VAR_14;", "VAR_14 = *VAR_0++;", "VAR_2--;", "for(VAR_6 = 0; VAR_6 < VAR_10; VAR_6++) {", "VAR_1[VAR_12++] = VAR_14;", "if (VAR_12 >= VAR_4) {", "VAR_12 = 0;", "VAR_1 -= VAR_3;", "VAR_13--;", "if(VAR_13 <= 0)\nbreak;", "}", "}", "} else {", "VAR_2 -= VAR_11;", "for(VAR_6 = 0; VAR_6 < VAR_11; VAR_6++) {", "VAR_1[VAR_12++] = *VAR_0++;", "if (VAR_12 >= VAR_4) {", "VAR_12 = 0;", "VAR_1 -= VAR_3;", "VAR_13--;", "if(VAR_13 <= 0)\nbreak;", "}", "}", "}", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 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 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ] ]

[ "static void FUNC_0(DeviceState *VAR_0, const char *VAR_1, void **VAR_2,\nconst char *VAR_3, Error **VAR_4)\n{", "BlockBackend *blk;", "blk = blk_by_name(VAR_1);", "if (!blk) {", "error_setg(VAR_4, \"Property '%s.%s' can't find value '%s'\",\nobject_get_typename(OBJECT(VAR_0)), VAR_3, VAR_1);", "return;", "}", "if (blk_attach_dev(blk, VAR_0) < 0) {", "DriveInfo *dinfo = blk_legacy_dinfo(blk);", "if (dinfo && dinfo->type != IF_NONE) {", "error_setg(VAR_4, \"Drive '%s' is already in use because \"\n\"it has been automatically connected to another \"\n\"device (did you need 'if=none' in the drive options?)\",\nVAR_1);", "} else {", "error_setg(VAR_4, \"Drive '%s' is already in use by another device\",\nVAR_1);", "}", "return;", "}", "*VAR_2 = blk;", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "VP56Context *s = VAR_0->priv_data;", "AVFrame *const p = s->frames[VP56_FRAME_CURRENT];", "int VAR_5 = VAR_3->size;", "int FUNC_1(alpha_offset);", "int VAR_6, VAR_7;", "int VAR_8;", "if (s->has_alpha) {", "if (VAR_5 < 3)\nreturn AVERROR_INVALIDDATA;", "alpha_offset = bytestream_get_be24(&VAR_4);", "VAR_5 -= 3;", "if (VAR_5 < alpha_offset)\nreturn AVERROR_INVALIDDATA;", "}", "VAR_7 = s->parse_header(s, VAR_4, VAR_5);", "if (VAR_7 < 0)\nreturn VAR_7;", "if (VAR_7 == VP56_SIZE_CHANGE) {", "for (VAR_6 = 0; VAR_6 < 4; VAR_6++) {", "av_frame_unref(s->frames[VAR_6]);", "if (s->alpha_context)\nav_frame_unref(s->alpha_context->frames[VAR_6]);", "}", "}", "VAR_8 = ff_get_buffer(VAR_0, p, AV_GET_BUFFER_FLAG_REF);", "if (VAR_8 < 0)\nreturn VAR_8;", "if (VAR_0->pix_fmt == AV_PIX_FMT_YUVA420P) {", "av_frame_unref(s->alpha_context->frames[VP56_FRAME_CURRENT]);", "if ((VAR_8 = av_frame_ref(s->alpha_context->frames[VP56_FRAME_CURRENT], p)) < 0) {", "av_frame_unref(p);", "return VAR_8;", "}", "}", "if (VAR_7 == VP56_SIZE_CHANGE) {", "if (vp56_size_changed(s)) {", "av_frame_unref(p);", "return AVERROR_INVALIDDATA;", "}", "}", "if (VAR_0->pix_fmt == AV_PIX_FMT_YUVA420P) {", "int VAR_9 = VAR_0->width;", "int VAR_10 = VAR_0->height;", "int VAR_11 = VAR_0->coded_width;", "int VAR_12 = VAR_0->coded_height;", "VAR_4 += alpha_offset;", "VAR_5 -= alpha_offset;", "VAR_7 = s->alpha_context->parse_header(s->alpha_context, VAR_4, VAR_5);", "if (VAR_7 != 0) {", "if(VAR_7==VP56_SIZE_CHANGE) {", "av_log(VAR_0, AV_LOG_ERROR, \"Alpha reconfiguration\\n\");", "VAR_0->width = VAR_9;", "VAR_0->height = VAR_10;", "VAR_0->coded_width = VAR_11;", "VAR_0->coded_height = VAR_12;", "}", "av_frame_unref(p);", "return AVERROR_INVALIDDATA;", "}", "}", "VAR_0->execute2(VAR_0, ff_vp56_decode_mbs, 0, 0, (VAR_0->pix_fmt == AV_PIX_FMT_YUVA420P) + 1);", "if ((VAR_7 = av_frame_ref(VAR_1, p)) < 0)\nreturn VAR_7;", "*VAR_2 = 1;", "return VAR_3->size;", "}" ]

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

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

[ "static int FUNC_0(const uint8_t *VAR_0, int VAR_1, int VAR_2, int *VAR_3)\n{", "int VAR_4[TS_MAX_PACKET_SIZE];", "int VAR_5;", "int VAR_6 = 0;", "int VAR_7 = 0;", "memset(VAR_4, 0, VAR_2 * sizeof(int));", "for (VAR_6 = VAR_5 = 0; VAR_5 < VAR_1 - 3; VAR_5++) {", "if (VAR_0[VAR_5] == 0x47 && !(VAR_0[VAR_5 + 1] & 0x80) && (VAR_0[VAR_5 + 3] & 0x30)) {", "VAR_4[VAR_6]++;", "if (VAR_4[VAR_6] > VAR_7) {", "VAR_7 = VAR_4[VAR_6];", "if (VAR_3)\n*VAR_3 = VAR_6;", "}", "}", "VAR_6++;", "if (VAR_6 == VAR_2)\nVAR_6 = 0;", "}", "return VAR_7;", "}" ]

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

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

[ "static int VAR_0 qcow2_co_is_allocated(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors, int *pnum)\n{", "BDRVQcowState *s = bs->opaque;", "uint64_t cluster_offset;", "int ret;", "*pnum = nb_sectors;", "qemu_co_mutex_lock(&s->lock);", "ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);", "qemu_co_mutex_unlock(&s->lock);", "if (ret < 0) {", "*pnum = 0;", "}", "return (cluster_offset != 0) || (ret == QCOW2_CLUSTER_ZERO);", "}" ]

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

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

[ "static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "UNINState *s = VAR_0;", "s->config_reg = VAR_2;", "}" ]

[ 0, 0, 1, 0 ]

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

[ "static int FUNC_0(MpegEncContext *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "AVCodecContext *avctx = VAR_0->avctx;", "Mpeg1Context *s1 = (Mpeg1Context *) VAR_0;", "if (VAR_0->first_field || VAR_0->picture_structure == PICT_FRAME) {", "AVFrameSideData *pan_scan;", "if (ff_MPV_frame_start(VAR_0, avctx) < 0)\nreturn -1;", "ff_mpeg_er_frame_start(VAR_0);", "VAR_0->current_picture_ptr->f.repeat_pict = 0;", "if (VAR_0->repeat_first_field) {", "if (VAR_0->progressive_sequence) {", "if (VAR_0->top_field_first)\nVAR_0->current_picture_ptr->f.repeat_pict = 4;", "else\nVAR_0->current_picture_ptr->f.repeat_pict = 2;", "} else if (VAR_0->progressive_frame) {", "VAR_0->current_picture_ptr->f.repeat_pict = 1;", "}", "}", "pan_scan = av_frame_new_side_data(&VAR_0->current_picture_ptr->f,\nAV_FRAME_DATA_PANSCAN,\nsizeof(s1->pan_scan));", "if (!pan_scan)\nreturn AVERROR(ENOMEM);", "memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));", "if (s1->a53_caption) {", "AVFrameSideData *sd = av_frame_new_side_data(\n&VAR_0->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,\ns1->a53_caption_size);", "if (sd)\nmemcpy(sd->data, s1->a53_caption, s1->a53_caption_size);", "av_freep(&s1->a53_caption);", "}", "if (s1->has_stereo3d) {", "AVStereo3D *stereo = av_stereo3d_create_side_data(&VAR_0->current_picture_ptr->f);", "if (!stereo)\nreturn AVERROR(ENOMEM);", "*stereo = s1->stereo3d;", "s1->has_stereo3d = 0;", "}", "if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))\nff_thread_finish_setup(avctx);", "} else {", "int VAR_3;", "if (!VAR_0->current_picture_ptr) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"first field missing\\n\");", "return -1;", "}", "if (VAR_0->avctx->hwaccel &&\n(VAR_0->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {", "if (VAR_0->avctx->hwaccel->end_frame(VAR_0->avctx) < 0)\nav_log(avctx, AV_LOG_ERROR,\n\"hardware accelerator failed to decode first field\\n\");", "}", "for (VAR_3 = 0; VAR_3 < 4; VAR_3++) {", "VAR_0->current_picture.f.data[VAR_3] = VAR_0->current_picture_ptr->f.data[VAR_3];", "if (VAR_0->picture_structure == PICT_BOTTOM_FIELD)\nVAR_0->current_picture.f.data[VAR_3] +=\nVAR_0->current_picture_ptr->f.linesize[VAR_3];", "}", "}", "if (avctx->hwaccel) {", "if (avctx->hwaccel->start_frame(avctx, VAR_1, VAR_2) < 0)\nreturn -1;", "}", "#if FF_API_XVMC\nFF_DISABLE_DEPRECATION_WARNINGS\nif (CONFIG_MPEG_XVMC_DECODER && VAR_0->avctx->xvmc_acceleration)\nif (ff_xvmc_field_start(VAR_0, avctx) < 0)\nreturn -1;", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\nreturn 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13 ], [ 15 ], [ 19, 21 ], [ 25 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55, 57, 59 ], [ 61, 63 ], [ 65 ], [ 69 ], [ 71, 73, 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91, 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123, 125 ], [ 127, 129, 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141, 143, 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155, 157 ], [ 159 ], [ 163, 165, 171, 173, 175 ], [ 177, 179, 183 ], [ 185 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, ByteIOContext *VAR_1,\nRMDemuxContext *VAR_2, RMStream *VAR_3,\nAVPacket *VAR_4, int VAR_5)\n{", "int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "int VAR_11;", "VAR_6 = get_byte(VAR_1); VAR_5--;", "VAR_11 = VAR_6 >> 6;", "if(VAR_11 != 3){", "VAR_7 = get_byte(VAR_1); VAR_5--;", "}", "if(VAR_11 != 1){", "VAR_9 = get_num(VAR_1, &VAR_5);", "VAR_10 = get_num(VAR_1, &VAR_5);", "VAR_8 = get_byte(VAR_1); VAR_5--;", "}", "if(VAR_5<0)\nreturn -1;", "VAR_2->remaining_len = VAR_5;", "if(VAR_11&1){", "if(VAR_11 == 3)\nVAR_5= VAR_9;", "if(VAR_2->remaining_len < VAR_5)\nreturn -1;", "VAR_2->remaining_len -= VAR_5;", "if(av_new_packet(VAR_4, VAR_5 + 9) < 0)\nreturn AVERROR(EIO);", "VAR_4->data[0] = 0;", "AV_WL32(VAR_4->data + 1, 1);", "AV_WL32(VAR_4->data + 5, 0);", "get_buffer(VAR_1, VAR_4->data + 9, VAR_5);", "return 0;", "}", "if((VAR_7 & 0x7F) == 1 || VAR_3->curpic_num != VAR_8){", "VAR_3->slices = ((VAR_6 & 0x3F) << 1) + 1;", "VAR_3->videobufsize = VAR_9 + 8*VAR_3->slices + 1;", "av_free_packet(&VAR_3->VAR_4);", "if(av_new_packet(&VAR_3->VAR_4, VAR_3->videobufsize) < 0)\nreturn AVERROR(ENOMEM);", "VAR_3->videobufpos = 8*VAR_3->slices + 1;", "VAR_3->cur_slice = 0;", "VAR_3->curpic_num = VAR_8;", "VAR_3->pktpos = url_ftell(VAR_1);", "}", "if(VAR_11 == 2)\nVAR_5 = FFMIN(VAR_5, VAR_10);", "if(++VAR_3->cur_slice > VAR_3->slices)\nreturn 1;", "AV_WL32(VAR_3->VAR_4.data - 7 + 8*VAR_3->cur_slice, 1);", "AV_WL32(VAR_3->VAR_4.data - 3 + 8*VAR_3->cur_slice, VAR_3->videobufpos - 8*VAR_3->slices - 1);", "if(VAR_3->videobufpos + VAR_5 > VAR_3->videobufsize)\nreturn 1;", "if (get_buffer(VAR_1, VAR_3->VAR_4.data + VAR_3->videobufpos, VAR_5) != VAR_5)\nreturn AVERROR(EIO);", "VAR_3->videobufpos += VAR_5;", "VAR_2->remaining_len-= VAR_5;", "if(VAR_11 == 2 || (VAR_3->videobufpos) == VAR_3->videobufsize){", "VAR_3->VAR_4.data[0] = VAR_3->cur_slice-1;", "*VAR_4= VAR_3->VAR_4;", "VAR_3->VAR_4.data=\nVAR_3->VAR_4.size= 0;", "if(VAR_3->slices != VAR_3->cur_slice)\nmemmove(VAR_4->data + 1 + 8*VAR_3->cur_slice, VAR_4->data + 1 + 8*VAR_3->slices,\nVAR_3->videobufpos - 1 - 8*VAR_3->slices);", "VAR_4->size += 8*(VAR_3->cur_slice - VAR_3->slices);", "VAR_4->pts = AV_NOPTS_VALUE;", "VAR_4->VAR_10 = VAR_3->pktpos;", "return 0;", "}", "return 1;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 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 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 135, 137, 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ] ]

[ "static ExitStatus FUNC_0(DisasContext *ctx, int palcode)\n{", "if (palcode >= 0x80 && palcode < 0xC0) {", "switch (palcode) {", "case 0x86:\nbreak;", "case 0x9E:\ntcg_gen_mov_i64(cpu_ir[IR_V0], cpu_unique);", "break;", "case 0x9F:\ntcg_gen_mov_i64(cpu_unique, cpu_ir[IR_A0]);", "break;", "default:\npalcode &= 0xbf;", "goto do_call_pal;", "}", "return NO_EXIT;", "}", "#ifndef CONFIG_USER_ONLY\nif (palcode < 0x40 && (ctx->tb->flags & TB_FLAGS_USER_MODE) == 0) {", "switch (palcode) {", "case 0x01:\nbreak;", "case 0x02:\nbreak;", "case 0x2D:\ntcg_gen_st_i64(cpu_ir[IR_A0], cpu_env, offsetof(CPUAlphaState, vptptr));", "break;", "case 0x31:\ntcg_gen_mov_i64(cpu_sysval, cpu_ir[IR_A0]);", "break;", "case 0x32:\ntcg_gen_mov_i64(cpu_ir[IR_V0], cpu_sysval);", "break;", "case 0x35: {", "TCGv tmp;", "tcg_gen_ld8u_i64(cpu_ir[IR_V0], cpu_env, offsetof(CPUAlphaState, ps));", "tmp = tcg_temp_new();", "tcg_gen_andi_i64(tmp, cpu_ir[IR_A0], PS_INT_MASK);", "tcg_gen_st8_i64(tmp, cpu_env, offsetof(CPUAlphaState, ps));", "tcg_temp_free(tmp);", "break;", "}", "case 0x36:\ntcg_gen_ld8u_i64(cpu_ir[IR_V0], cpu_env, offsetof(CPUAlphaState, ps));", "break;", "case 0x38:\ntcg_gen_mov_i64(cpu_usp, cpu_ir[IR_A0]);", "break;", "case 0x3A:\ntcg_gen_mov_i64(cpu_ir[IR_V0], cpu_usp);", "break;", "case 0x3C:\ntcg_gen_ld32s_i64(cpu_ir[IR_V0], cpu_env,\n-offsetof(AlphaCPU, env) + offsetof(CPUState, cpu_index));", "break;", "default:\npalcode &= 0x3f;", "goto do_call_pal;", "}", "return NO_EXIT;", "}", "#endif\nreturn gen_invalid(ctx);", "do_call_pal:\n#ifdef CONFIG_USER_ONLY\nreturn gen_excp(ctx, EXCP_CALL_PAL, palcode);", "#else\n{", "TCGv pc = tcg_const_i64(ctx->pc);", "TCGv entry = tcg_const_i64(palcode & 0x80\n? 0x2000 + (palcode - 0x80) * 64\n: 0x1000 + palcode * 64);", "gen_helper_call_pal(cpu_env, pc, entry);", "tcg_temp_free(entry);", "tcg_temp_free(pc);", "if (!ctx->singlestep_enabled && !(ctx->tb->cflags & CF_LAST_IO)) {", "tcg_gen_goto_tb(0);", "tcg_gen_exit_tb((uintptr_t)ctx->tb);", "return EXIT_GOTO_TB;", "}", "return EXIT_PC_UPDATED;", "}", "#endif\n}" ]

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

[ [ 1, 3 ], [ 13 ], [ 15 ], [ 17, 23 ], [ 25, 29 ], [ 31 ], [ 33, 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55, 59 ], [ 61 ], [ 63, 69 ], [ 71, 77 ], [ 79, 83 ], [ 85 ], [ 87, 91 ], [ 93 ], [ 95, 99 ], [ 101 ], [ 105 ], [ 109 ], [ 117 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137, 141 ], [ 143 ], [ 145, 149 ], [ 151 ], [ 153, 157 ], [ 159 ], [ 161, 165, 167 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 191, 193, 195 ], [ 197, 199 ], [ 201 ], [ 203, 205, 207 ], [ 211 ], [ 215 ], [ 217 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 241 ], [ 243 ], [ 245, 247 ] ]

[ "void FUNC_0(VirtIOBlockDataPlane *VAR_0)\n{", "if (!VAR_0) {", "return;", "}", "virtio_blk_data_plane_stop(VAR_0);", "blk_op_unblock_all(VAR_0->conf->conf.blk, VAR_0->blocker);", "error_free(VAR_0->blocker);", "object_unref(OBJECT(VAR_0->iothread));", "qemu_bh_delete(VAR_0->bh);", "g_free(VAR_0);", "}" ]

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

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "PCIDeviceClass *k = PCI_DEVICE_CLASS(VAR_0);", "UHCIPCIDeviceClass *u = container_of(k, UHCIPCIDeviceClass, parent_class);", "UHCIInfo *info = VAR_1;", "k->init = info->initfn ? info->initfn : usb_uhci_common_initfn;", "k->exit = info->unplug ? usb_uhci_exit : NULL;", "k->vendor_id = info->vendor_id;", "k->device_id = info->device_id;", "k->revision = info->revision;", "k->class_id = PCI_CLASS_SERIAL_USB;", "dc->vmsd = &vmstate_uhci;", "dc->props = uhci_properties;", "u->info = *info;", "}" ]

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

[ "static int FUNC_0(char *VAR_0, int VAR_1, bool VAR_2, bool VAR_3,\nQDict *VAR_4)\n{", "Error *local_err = NULL;", "BlockDriverState *bs;", "if (qemuio_blk) {", "error_report(\"file open already, try 'help close'\");", "QDECREF(VAR_4);", "return 1;", "}", "if (VAR_3) {", "if (!VAR_4) {", "VAR_4 = qdict_new();", "}", "if (qdict_haskey(VAR_4, BDRV_OPT_FORCE_SHARE)\n&& !qdict_get_bool(VAR_4, BDRV_OPT_FORCE_SHARE)) {", "error_report(\"-U conflicts with image options\");", "QDECREF(VAR_4);", "return 1;", "}", "qdict_put_bool(VAR_4, BDRV_OPT_FORCE_SHARE, true);", "}", "qemuio_blk = blk_new_open(VAR_0, NULL, VAR_4, VAR_1, &local_err);", "if (!qemuio_blk) {", "error_reportf_err(local_err, \"can't open%s%s: \",\nVAR_0 ? \" device \" : \"\", VAR_0 ?: \"\");", "return 1;", "}", "bs = blk_bs(qemuio_blk);", "if (bdrv_is_encrypted(bs) && bdrv_key_required(bs)) {", "char VAR_5[256];", "printf(\"Disk image '%s' is encrypted.\\n\", VAR_0);", "if (qemu_read_password(VAR_5, sizeof(VAR_5)) < 0) {", "error_report(\"No VAR_5 given\");", "goto error;", "}", "if (bdrv_set_key(bs, VAR_5) < 0) {", "error_report(\"invalid VAR_5\");", "goto error;", "}", "}", "blk_set_enable_write_cache(qemuio_blk, !VAR_2);", "return 0;", "error:\nblk_unref(qemuio_blk);", "qemuio_blk = NULL;", "return 1;", "}" ]

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

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

[ "static void FUNC_0(Object *VAR_0, Visitor *VAR_1, const char *VAR_2,\nvoid *VAR_3, Error **VAR_4)\n{", "char *VAR_5 = (char *)\"\";", "Property *prop = VAR_3;", "uint32_t *max_compat = qdev_get_prop_ptr(DEVICE(VAR_0), prop);", "switch (*max_compat) {", "case CPU_POWERPC_LOGICAL_2_05:\nVAR_5 = (char *)\"power6\";", "break;", "case CPU_POWERPC_LOGICAL_2_06:\nVAR_5 = (char *)\"power7\";", "break;", "case CPU_POWERPC_LOGICAL_2_07:\nVAR_5 = (char *)\"power8\";", "break;", "case 0:\nbreak;", "default:\nerror_report(\"Internal error: compat is set to %x\", *max_compat);", "abort();", "break;", "}", "visit_type_str(VAR_1, VAR_2, &VAR_5, VAR_4);", "}" ]

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

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

[ "int FUNC_0(PageCache *VAR_0, uint64_t VAR_1, uint8_t *VAR_2)\n{", "CacheItem *it = NULL;", "g_assert(VAR_0);", "g_assert(VAR_0->page_cache);", "it = cache_get_by_addr(VAR_0, VAR_1);", "if (!it->it_data) {", "it->it_data = g_try_malloc(VAR_0->page_size);", "if (!it->it_data) {", "DPRINTF(\"Error allocating page\\n\");", "return -1;", "}", "VAR_0->num_items++;", "}", "memcpy(it->it_data, VAR_2, VAR_0->page_size);", "it->it_age = ++VAR_0->max_item_age;", "it->it_addr = VAR_1;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 11 ], [ 13 ], [ 19 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ] ]

[ "int FUNC_0(MpegEncContext *VAR_0, Picture *VAR_1, int VAR_2){", "const int VAR_3= VAR_0->mb_stride*(VAR_0->mb_height+1) + 1;", "const int VAR_4= VAR_0->mb_stride*VAR_0->mb_height;", "const int VAR_5= VAR_0->b8_stride*VAR_0->mb_height*2;", "const int VAR_6= VAR_0->b4_stride*VAR_0->mb_height*4;", "int VAR_7;", "int VAR_8= -1;", "if(VAR_2){", "assert(VAR_1->data[0]);", "assert(VAR_1->type == 0 || VAR_1->type == FF_BUFFER_TYPE_SHARED);", "VAR_1->type= FF_BUFFER_TYPE_SHARED;", "}else{", "assert(!VAR_1->data[0]);", "if (alloc_frame_buffer(VAR_0, VAR_1) < 0)\nreturn -1;", "VAR_0->linesize = VAR_1->linesize[0];", "VAR_0->uvlinesize= VAR_1->linesize[1];", "}", "if(VAR_1->qscale_table==NULL){", "if (VAR_0->encoding) {", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->mb_var , VAR_4 * sizeof(int16_t) , fail)\nFF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->mc_mb_var, VAR_4 * sizeof(int16_t) , fail)\nFF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->mb_mean , VAR_4 * sizeof(int8_t ) , fail)\n}", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->mbskip_table , VAR_4 * sizeof(uint8_t)+2, fail)\nFF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->qscale_table , VAR_4 * sizeof(uint8_t) , fail)\nFF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->mb_type_base , (VAR_3 + VAR_0->mb_stride) * sizeof(uint32_t), fail)\nVAR_1->mb_type= VAR_1->mb_type_base + 2*VAR_0->mb_stride+1;", "if(VAR_0->out_format == FMT_H264){", "for(VAR_7=0; VAR_7<2; VAR_7++){", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->motion_val_base[VAR_7], 2 * (VAR_6+4) * sizeof(int16_t), fail)\nVAR_1->motion_val[VAR_7]= VAR_1->motion_val_base[VAR_7]+4;", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->ref_index[VAR_7], 4*VAR_4 * sizeof(uint8_t), fail)\n}", "VAR_1->motion_subsample_log2= 2;", "}else if(VAR_0->out_format == FMT_H263 || VAR_0->encoding || (VAR_0->avctx->debug&FF_DEBUG_MV) || (VAR_0->avctx->debug_mv)){", "for(VAR_7=0; VAR_7<2; VAR_7++){", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->motion_val_base[VAR_7], 2 * (VAR_5+4) * sizeof(int16_t), fail)\nVAR_1->motion_val[VAR_7]= VAR_1->motion_val_base[VAR_7]+4;", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->ref_index[VAR_7], 4*VAR_4 * sizeof(uint8_t), fail)\n}", "VAR_1->motion_subsample_log2= 3;", "}", "if(VAR_0->avctx->debug&FF_DEBUG_DCT_COEFF) {", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->dct_coeff, 64 * VAR_4 * sizeof(DCTELEM)*6, fail)\n}", "VAR_1->qstride= VAR_0->mb_stride;", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->pan_scan , 1 * sizeof(AVPanScan), fail)\n}", "memmove(VAR_0->prev_pict_types+1, VAR_0->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);", "VAR_0->prev_pict_types[0]= VAR_0->dropable ? AV_PICTURE_TYPE_B : VAR_0->pict_type;", "if(VAR_1->age < PREV_PICT_TYPES_BUFFER_SIZE && VAR_0->prev_pict_types[VAR_1->age] == AV_PICTURE_TYPE_B)\nVAR_1->age= INT_MAX;", "VAR_1->owner2 = NULL;", "return 0;", "fail:\nif(VAR_8>=0)\nfree_frame_buffer(VAR_0, VAR_1);", "return -1;", "}" ]

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

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49, 51, 53, 55 ], [ 59, 61, 63, 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 103 ], [ 105, 107 ], [ 115 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 127 ], [ 129, 131, 133 ], [ 135 ], [ 137 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1,\nint VAR_2, int VAR_3, Error **VAR_4)\n{", "BDRVRawState *s = VAR_0->opaque;", "QemuOpts *opts;", "Error *local_err = NULL;", "const char *VAR_5 = NULL;", "BlockdevAioOptions aio, aio_default;", "int VAR_6, VAR_7;", "struct stat VAR_8;", "OnOffAuto locking;", "opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);", "qemu_opts_absorb_qdict(opts, VAR_1, &local_err);", "if (local_err) {", "error_propagate(VAR_4, local_err);", "VAR_7 = -EINVAL;", "goto fail;", "}", "VAR_5 = qemu_opt_get(opts, \"VAR_5\");", "VAR_7 = raw_normalize_devicepath(&VAR_5);", "if (VAR_7 != 0) {", "error_setg_errno(VAR_4, -VAR_7, \"Could not normalize device path\");", "goto fail;", "}", "aio_default = (VAR_2 & BDRV_O_NATIVE_AIO)\n? BLOCKDEV_AIO_OPTIONS_NATIVE\n: BLOCKDEV_AIO_OPTIONS_THREADS;", "aio = qapi_enum_parse(BlockdevAioOptions_lookup, qemu_opt_get(opts, \"aio\"),\nBLOCKDEV_AIO_OPTIONS__MAX, aio_default, &local_err);", "if (local_err) {", "error_propagate(VAR_4, local_err);", "VAR_7 = -EINVAL;", "goto fail;", "}", "s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);", "locking = qapi_enum_parse(OnOffAuto_lookup, qemu_opt_get(opts, \"locking\"),\nON_OFF_AUTO__MAX, ON_OFF_AUTO_AUTO, &local_err);", "if (local_err) {", "error_propagate(VAR_4, local_err);", "VAR_7 = -EINVAL;", "goto fail;", "}", "switch (locking) {", "case ON_OFF_AUTO_ON:\ns->use_lock = true;", "#ifndef F_OFD_SETLK\nfprintf(stderr,\n\"File lock requested but OFD locking syscall is unavailable, \"\n\"falling back to POSIX file locks.\\n\"\n\"Due to the implementation, locks can be lost unexpectedly.\\n\");", "#endif\nbreak;", "case ON_OFF_AUTO_OFF:\ns->use_lock = false;", "break;", "case ON_OFF_AUTO_AUTO:\n#ifdef F_OFD_SETLK\ns->use_lock = true;", "#else\ns->use_lock = false;", "#endif\nbreak;", "default:\nabort();", "}", "s->VAR_3 = VAR_3;", "raw_parse_flags(VAR_2, &s->VAR_3);", "s->VAR_6 = -1;", "VAR_6 = qemu_open(VAR_5, s->VAR_3, 0644);", "if (VAR_6 < 0) {", "VAR_7 = -errno;", "error_setg_errno(VAR_4, errno, \"Could not open '%s'\", VAR_5);", "if (VAR_7 == -EROFS) {", "VAR_7 = -EACCES;", "}", "goto fail;", "}", "s->VAR_6 = VAR_6;", "s->lock_fd = -1;", "if (s->use_lock) {", "VAR_6 = qemu_open(VAR_5, s->VAR_3);", "if (VAR_6 < 0) {", "VAR_7 = -errno;", "error_setg_errno(VAR_4, errno, \"Could not open '%s' for locking\",\nVAR_5);", "qemu_close(s->VAR_6);", "goto fail;", "}", "s->lock_fd = VAR_6;", "}", "s->perm = 0;", "s->shared_perm = BLK_PERM_ALL;", "#ifdef CONFIG_LINUX_AIO\nif (s->use_linux_aio && !(s->VAR_3 & O_DIRECT)) {", "error_setg(VAR_4, \"aio=native was specified, but it requires \"\n\"cache.direct=on, which was not specified.\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "#else\nif (s->use_linux_aio) {", "error_setg(VAR_4, \"aio=native was specified, but is not supported \"\n\"in this build.\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "#endif\ns->has_discard = true;", "s->has_write_zeroes = true;", "VAR_0->supported_zero_flags = BDRV_REQ_MAY_UNMAP;", "if ((VAR_0->VAR_3 & BDRV_O_NOCACHE) != 0) {", "s->needs_alignment = true;", "}", "if (fstat(s->VAR_6, &VAR_8) < 0) {", "VAR_7 = -errno;", "error_setg_errno(VAR_4, errno, \"Could not stat file\");", "goto fail;", "}", "if (S_ISREG(VAR_8.st_mode)) {", "s->discard_zeroes = true;", "s->has_fallocate = true;", "}", "if (S_ISBLK(VAR_8.st_mode)) {", "#ifdef BLKDISCARDZEROES\nunsigned int arg;", "if (ioctl(s->VAR_6, BLKDISCARDZEROES, &arg) == 0 && arg) {", "s->discard_zeroes = true;", "}", "#endif\n#ifdef __linux__\nif (!(VAR_0->VAR_3 & BDRV_O_NOCACHE)) {", "s->discard_zeroes = false;", "s->has_write_zeroes = false;", "}", "#endif\n}", "#ifdef __FreeBSD__\nif (S_ISCHR(VAR_8.st_mode)) {", "s->needs_alignment = true;", "}", "#endif\n#ifdef CONFIG_XFS\nif (platform_test_xfs_fd(s->VAR_6)) {", "s->is_xfs = true;", "}", "#endif\nVAR_7 = 0;", "fail:\nif (VAR_5 && (VAR_2 & BDRV_O_TEMPORARY)) {", "unlink(VAR_5);", "}", "qemu_opts_del(opts);", "return VAR_7;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59, 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99 ], [ 101, 103, 105, 107, 109 ], [ 111, 113 ], [ 115, 117 ], [ 119 ], [ 121, 123, 125 ], [ 127, 129 ], [ 131, 133 ], [ 135, 137 ], [ 139 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183, 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203, 207 ], [ 209, 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219, 221 ], [ 223, 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271, 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281, 283, 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301, 303 ], [ 305, 307 ], [ 321 ], [ 323 ], [ 325, 329, 331 ], [ 333 ], [ 335 ], [ 337, 341 ], [ 343, 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ] ]

[ "int FUNC_0(MpegEncContext * VAR_0,\nint VAR_1, int VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "int VAR_7, VAR_8, VAR_9, VAR_10;", "int VAR_11, VAR_12, VAR_13, VAR_14;", "int VAR_15=0, VAR_16=0;", "int VAR_17[10][2];", "const int VAR_18= 1+VAR_0->quarter_sample;", "uint16_t * const mv_penalty= VAR_0->me.mv_penalty[VAR_0->f_code] + MAX_MV;", "const int VAR_19= VAR_0->mb_width + 2;", "const int VAR_20= VAR_1 + 1 + (VAR_2 + 1)*VAR_19;", "assert(VAR_0->quarter_sample==0 || VAR_0->quarter_sample==1);", "VAR_0->me.pre_penalty_factor = get_penalty_factor(VAR_0, VAR_0->avctx->me_pre_cmp);", "get_limits(VAR_0, &VAR_5, &VAR_7, &VAR_8, &VAR_9, &VAR_10, VAR_0->f_code);", "VAR_11= VAR_7 - VAR_1*16;", "VAR_13= VAR_9 - VAR_1*16;", "VAR_12= VAR_8 - VAR_2*16;", "VAR_14= VAR_10 - VAR_2*16;", "VAR_0->me.skip=0;", "P_LEFT[0] = VAR_0->p_mv_table[VAR_20 + 1][0];", "P_LEFT[1] = VAR_0->p_mv_table[VAR_20 + 1][1];", "if(P_LEFT[0] < (VAR_11<<VAR_18)) P_LEFT[0] = (VAR_11<<VAR_18);", "if (VAR_2 == VAR_0->mb_height-1) {", "VAR_15= P_LEFT[0];", "VAR_16= P_LEFT[1];", "P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]=\nP_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0;", "} else {", "P_TOP[0] = VAR_0->p_mv_table[VAR_20 + VAR_19 ][0];", "P_TOP[1] = VAR_0->p_mv_table[VAR_20 + VAR_19 ][1];", "P_TOPRIGHT[0] = VAR_0->p_mv_table[VAR_20 + VAR_19 - 1][0];", "P_TOPRIGHT[1] = VAR_0->p_mv_table[VAR_20 + VAR_19 - 1][1];", "if(P_TOP[1] < (VAR_12<<VAR_18)) P_TOP[1] = (VAR_12<<VAR_18);", "if(P_TOPRIGHT[0] > (VAR_13<<VAR_18)) P_TOPRIGHT[0]= (VAR_13<<VAR_18);", "if(P_TOPRIGHT[1] < (VAR_12<<VAR_18)) P_TOPRIGHT[1]= (VAR_12<<VAR_18);", "P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);", "P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);", "VAR_15 = P_MEDIAN[0];", "VAR_16 = P_MEDIAN[1];", "}", "VAR_6 = VAR_0->me.pre_motion_search(VAR_0, 0, &VAR_3, &VAR_4, VAR_17, VAR_15, VAR_16, VAR_11, VAR_12, VAR_13, VAR_14,\n&VAR_0->last_picture, VAR_0->p_mv_table, (1<<16)>>VAR_18, mv_penalty);", "VAR_0->p_mv_table[VAR_20][0] = VAR_3<<VAR_18;", "VAR_0->p_mv_table[VAR_20][1] = VAR_4<<VAR_18;", "return VAR_6;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 61 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101, 103 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ] ]

[ "static void FUNC_0(chrRangeFromJpeg)(int16_t *dst, int width)\n{", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < width; VAR_0++) {", "dst[VAR_0 ] = (dst[VAR_0 ]*1799 + 4081085)>>11;", "dst[VAR_0+VOFW] = (dst[VAR_0+VOFW]*1799 + 4081085)>>11;", "}", "}" ]

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

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

[ "int FUNC_0(FFDrawContext *VAR_0, enum AVPixelFormat VAR_1, unsigned VAR_2)\n{", "const AVPixFmtDescriptor *VAR_3 = av_pix_fmt_desc_get(VAR_1);", "const AVComponentDescriptor *VAR_4;", "unsigned VAR_5, VAR_6 = 0;", "int VAR_7[MAX_PLANES] = { 0 };", "if (!VAR_3->name)\nreturn AVERROR(EINVAL);", "if (VAR_3->VAR_2 & ~(AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_PSEUDOPAL | AV_PIX_FMT_FLAG_ALPHA))\nreturn AVERROR(ENOSYS);", "for (VAR_5 = 0; VAR_5 < VAR_3->nb_components; VAR_5++) {", "VAR_4 = &VAR_3->comp[VAR_5];", "if (VAR_4->depth_minus1 != 8 - 1)\nreturn AVERROR(ENOSYS);", "if (VAR_4->plane >= MAX_PLANES)\nreturn AVERROR(ENOSYS);", "if (VAR_7[VAR_4->plane] != 0 &&\nVAR_7[VAR_4->plane] != VAR_4->step_minus1 + 1)\nreturn AVERROR(ENOSYS);", "VAR_7[VAR_4->plane] = VAR_4->step_minus1 + 1;", "if (VAR_7[VAR_4->plane] >= 8)\nreturn AVERROR(ENOSYS);", "VAR_6 = FFMAX(VAR_6, VAR_4->plane + 1);", "}", "if ((VAR_3->log2_chroma_w || VAR_3->log2_chroma_h) && VAR_6 < 3)\nreturn AVERROR(ENOSYS);", "memset(VAR_0, 0, sizeof(*VAR_0));", "VAR_0->VAR_3 = VAR_3;", "VAR_0->VAR_1 = VAR_1;", "VAR_0->VAR_6 = VAR_6;", "memcpy(VAR_0->VAR_7, VAR_7, sizeof(VAR_0->VAR_7));", "VAR_0->hsub[1] = VAR_0->hsub[2] = VAR_0->hsub_max = VAR_3->log2_chroma_w;", "VAR_0->vsub[1] = VAR_0->vsub[2] = VAR_0->vsub_max = VAR_3->log2_chroma_h;", "for (VAR_5 = 0; VAR_5 < ((VAR_3->nb_components - 1) | 1); VAR_5++)", "VAR_0->comp_mask[VAR_3->comp[VAR_5].plane] |=\n1 << (VAR_3->comp[VAR_5].offset_plus1 - 1);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{", "sPAPRMachineState *spapr = VAR_1;", "int VAR_2;", "qemu_put_be32(VAR_0, 0);", "if (!spapr->htab) {", "int VAR_3;", "assert(kvm_enabled());", "VAR_2 = get_htab_fd(spapr);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_3 = kvmppc_save_htab(VAR_0, VAR_2, MAX_KVM_BUF_SIZE, -1);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "close_htab_fd(spapr);", "} else {", "if (spapr->htab_first_pass) {", "htab_save_first_pass(VAR_0, spapr, -1);", "}", "htab_save_later_pass(VAR_0, spapr, -1);", "}", "qemu_put_be32(VAR_0, 0);", "qemu_put_be16(VAR_0, 0);", "qemu_put_be16(VAR_0, 0);", "return 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 ], [ 13 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ] ]

[ "struct pxa2xx_gpio_info_s *FUNC_0(target_phys_addr_t VAR_0,\nCPUState *VAR_1, qemu_irq *VAR_2, int VAR_3)\n{", "int VAR_4;", "struct pxa2xx_gpio_info_s *VAR_5;", "VAR_5 = (struct pxa2xx_gpio_info_s *)\nqemu_mallocz(sizeof(struct pxa2xx_gpio_info_s));", "memset(VAR_5, 0, sizeof(struct pxa2xx_gpio_info_s));", "VAR_5->VAR_0 = VAR_0;", "VAR_5->VAR_2 = VAR_2;", "VAR_5->VAR_3 = VAR_3;", "VAR_5->cpu_env = VAR_1;", "VAR_4 = cpu_register_io_memory(0, pxa2xx_gpio_readfn,\npxa2xx_gpio_writefn, VAR_5);", "cpu_register_physical_memory(VAR_0, 0x00000fff, VAR_4);", "register_savevm(\"pxa2xx_gpio\", 0, 0,\npxa2xx_gpio_save, pxa2xx_gpio_load, VAR_5);", "return VAR_5;", "}" ]

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

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

[ "AVFilterFormats *FUNC_0(AVFilterFormats *a, AVFilterFormats *b)\n{", "AVFilterFormats *ret;", "unsigned VAR_0, VAR_1, VAR_2 = 0;", "ret = av_mallocz(sizeof(AVFilterFormats));", "ret->formats = av_malloc(sizeof(*ret->formats) * FFMIN(a->format_count,\nb->format_count));", "for(VAR_0 = 0; VAR_0 < a->format_count; VAR_0 ++)", "for(VAR_1 = 0; VAR_1 < b->format_count; VAR_1 ++)", "if(a->formats[VAR_0] == b->formats[VAR_1])\nret->formats[VAR_2++] = a->formats[VAR_0];", "ret->format_count = VAR_2;", "if(!ret->format_count) {", "av_free(ret->formats);", "av_free(ret);", "return NULL;", "}", "ret->refs = av_malloc(sizeof(AVFilterFormats**)*(a->refcount+b->refcount));", "merge_ref(ret, a);", "merge_ref(ret, b);", "return ret;", "}" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 7, 8 ], [ 9 ], [ 10 ], [ 11, 12 ], [ 13 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ] ]

[ "void FUNC_0(unsigned int VAR_0)\n{", "TextConsole *s;", "if (VAR_0 >= MAX_CONSOLES)\nreturn;", "if (active_console) {", "active_console->g_width = ds_get_width(active_console->ds);", "active_console->g_height = ds_get_height(active_console->ds);", "}", "s = consoles[VAR_0];", "if (s) {", "DisplayState *ds = s->ds;", "if (active_console->cursor_timer) {", "qemu_del_timer(active_console->cursor_timer);", "}", "active_console = s;", "if (ds_get_bits_per_pixel(s->ds)) {", "ds->surface = qemu_resize_displaysurface(ds, s->g_width, s->g_height);", "} else {", "s->ds->surface->width = s->width;", "s->ds->surface->height = s->height;", "}", "if (s->cursor_timer) {", "qemu_mod_timer(s->cursor_timer,\nqemu_get_clock_ms(rt_clock) + CONSOLE_CURSOR_PERIOD / 2);", "}", "dpy_resize(s->ds);", "vga_hw_invalidate();", "}", "}" ]

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

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

[ "static av_always_inline int FUNC_0(uint8_t *p, ptrdiff_t stride, int flim)\n{", "LOAD_PIXELS\nreturn 2*FFABS(p0-q0) + (FFABS(p1-q1) >> 1) <= flim;", "}" ]

[ 0, 0, 0 ]

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

[ "FUNC_0(AVFormatContext *VAR_0)\n{", "struct dshow_ctx *VAR_1 = VAR_0->priv_data;", "AVPacketList *pktl;", "if (VAR_1->control) {", "IMediaControl_Stop(VAR_1->control);", "IMediaControl_Release(VAR_1->control);", "}", "if (VAR_1->graph) {", "IEnumFilters *fenum;", "int VAR_2;", "VAR_2 = IGraphBuilder_EnumFilters(VAR_1->graph, &fenum);", "if (VAR_2 == S_OK) {", "IBaseFilter *f;", "IEnumFilters_Reset(fenum);", "while (IEnumFilters_Next(fenum, 1, &f, NULL) == S_OK) {", "if (IGraphBuilder_RemoveFilter(VAR_1->graph, f) == S_OK)\nIEnumFilters_Reset(fenum);", "IBaseFilter_Release(f);", "}", "IEnumFilters_Release(fenum);", "}", "IGraphBuilder_Release(VAR_1->graph);", "}", "if (VAR_1->capture_pin[VideoDevice])\nlibAVPin_Release(VAR_1->capture_pin[VideoDevice]);", "if (VAR_1->capture_pin[AudioDevice])\nlibAVPin_Release(VAR_1->capture_pin[AudioDevice]);", "if (VAR_1->capture_filter[VideoDevice])\nlibAVFilter_Release(VAR_1->capture_filter[VideoDevice]);", "if (VAR_1->capture_filter[AudioDevice])\nlibAVFilter_Release(VAR_1->capture_filter[AudioDevice]);", "if (VAR_1->device_pin[VideoDevice])\nIPin_Release(VAR_1->device_pin[VideoDevice]);", "if (VAR_1->device_pin[AudioDevice])\nIPin_Release(VAR_1->device_pin[AudioDevice]);", "if (VAR_1->device_filter[VideoDevice])\nIBaseFilter_Release(VAR_1->device_filter[VideoDevice]);", "if (VAR_1->device_filter[AudioDevice])\nIBaseFilter_Release(VAR_1->device_filter[AudioDevice]);", "if (VAR_1->device_name[0])\nav_free(VAR_1->device_name[0]);", "if (VAR_1->device_name[1])\nav_free(VAR_1->device_name[1]);", "if(VAR_1->mutex)\nCloseHandle(VAR_1->mutex);", "if(VAR_1->event)\nCloseHandle(VAR_1->event);", "pktl = VAR_1->pktl;", "while (pktl) {", "AVPacketList *next = pktl->next;", "av_destruct_packet(&pktl->pkt);", "av_free(pktl);", "pktl = next;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59 ], [ 61, 63 ], [ 65, 67 ], [ 69, 71 ], [ 75, 77 ], [ 79, 81 ], [ 83, 85 ], [ 87, 89 ], [ 93, 95 ], [ 97, 99 ], [ 103, 105 ], [ 107, 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ] ]

[ "static int FUNC_0(void *VAR_0)\n{", "FTPContext *s = VAR_0;", "return s->conn_control_block_flag;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(const char *VAR_0)\n{", "AVFormatContext *fmt_ctx;", "int VAR_1, VAR_2;", "if ((VAR_1 = open_input_file(&fmt_ctx, VAR_0)))\nreturn VAR_1;", "if (do_show_packets)\nshow_packets(fmt_ctx);", "if (do_show_streams)\nfor (VAR_2 = 0; VAR_2 < fmt_ctx->nb_streams; VAR_2++)", "show_stream(fmt_ctx, VAR_2);", "if (do_show_format)\nshow_format(fmt_ctx);", "close_input_file(&fmt_ctx);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11, 13 ], [ 17, 19 ], [ 23, 25 ], [ 27 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 41 ] ]

[ "av_cold int FUNC_0(AVCodecContext *avctx)\n{", "MJpegDecodeContext *s = avctx->priv_data;", "if (!s->picture_ptr) {", "s->picture = av_frame_alloc();", "if (!s->picture)\nreturn AVERROR(ENOMEM);", "s->picture_ptr = s->picture;", "}", "s->avctx = avctx;", "ff_blockdsp_init(&s->bdsp, avctx);", "ff_hpeldsp_init(&s->hdsp, avctx->flags);", "ff_idctdsp_init(&s->idsp, avctx);", "ff_init_scantable(s->idsp.idct_permutation, &s->scantable,\nff_zigzag_direct);", "s->buffer_size = 0;", "s->buffer = NULL;", "s->start_code = -1;", "s->first_picture = 1;", "s->org_height = avctx->coded_height;", "avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;", "avctx->colorspace = AVCOL_SPC_BT470BG;", "build_basic_mjpeg_vlc(s);", "if (s->extern_huff) {", "int VAR_0;", "av_log(avctx, AV_LOG_INFO, \"mjpeg: using external huffman table\\n\");", "init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);", "if ((VAR_0 = ff_mjpeg_decode_dht(s))) {", "av_log(avctx, AV_LOG_ERROR,\n\"mjpeg: error using external huffman table\\n\");", "return VAR_0;", "}", "}", "if (avctx->field_order == AV_FIELD_BB) {", "s->interlace_polarity = 1;", "av_log(avctx, AV_LOG_DEBUG, \"mjpeg bottom field first\\n\");", "}", "if (avctx->codec->id == AV_CODEC_ID_AMV)\ns->flipped = 1;", "return 0;", "}" ]

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

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

[ "int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1, int VAR_2,\nBlockDriver *VAR_3)\n{", "int VAR_4;", "int VAR_5 = 0;", "if (VAR_2 & BDRV_O_SNAPSHOT) {", "BlockDriverState *bs1;", "int64_t total_size;", "int VAR_6 = 0;", "BlockDriver *bdrv_qcow2;", "QEMUOptionParameter *options;", "char VAR_7[PATH_MAX];", "char VAR_9[PATH_MAX];", "bs1 = bdrv_new(\"\");", "VAR_4 = FUNC_0(bs1, VAR_1, 0, VAR_3);", "if (VAR_4 < 0) {", "bdrv_delete(bs1);", "return VAR_4;", "}", "total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;", "if (bs1->VAR_3 && bs1->VAR_3->protocol_name)\nVAR_6 = 1;", "bdrv_delete(bs1);", "get_tmp_filename(VAR_7, sizeof(VAR_7));", "if (VAR_6)\nsnprintf(VAR_9, sizeof(VAR_9),\n\"%s\", VAR_1);", "else if (!realpath(VAR_1, VAR_9))\nreturn -errno;", "bdrv_qcow2 = bdrv_find_format(\"qcow2\");", "options = parse_option_parameters(\"\", bdrv_qcow2->create_options, NULL);", "set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);", "set_option_parameter(options, BLOCK_OPT_BACKING_FILE, VAR_9);", "if (VAR_3) {", "set_option_parameter(options, BLOCK_OPT_BACKING_FMT,\nVAR_3->format_name);", "}", "VAR_4 = bdrv_create(bdrv_qcow2, VAR_7, options);", "free_option_parameters(options);", "if (VAR_4 < 0) {", "return VAR_4;", "}", "VAR_1 = VAR_7;", "VAR_3 = bdrv_qcow2;", "VAR_0->is_temporary = 1;", "}", "if (!VAR_3) {", "VAR_3 = find_image_format(VAR_1);", "VAR_5 = 1;", "}", "if (!VAR_3) {", "VAR_4 = -ENOENT;", "goto unlink_and_fail;", "}", "VAR_4 = bdrv_open_common(VAR_0, VAR_1, VAR_2, VAR_3);", "if (VAR_4 < 0) {", "goto unlink_and_fail;", "}", "if ((VAR_2 & BDRV_O_NO_BACKING) == 0 && VAR_0->backing_file[0] != '\\0') {", "char VAR_9[PATH_MAX];", "int VAR_9;", "BlockDriver *back_drv = NULL;", "VAR_0->backing_hd = bdrv_new(\"\");", "path_combine(VAR_9, sizeof(VAR_9),\nVAR_1, VAR_0->backing_file);", "if (VAR_0->backing_format[0] != '\\0')\nback_drv = bdrv_find_format(VAR_0->backing_format);", "VAR_9 =\nVAR_2 & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);", "VAR_4 = FUNC_0(VAR_0->backing_hd, VAR_9, VAR_9, back_drv);", "if (VAR_4 < 0) {", "bdrv_close(VAR_0);", "return VAR_4;", "}", "if (VAR_0->is_temporary) {", "VAR_0->backing_hd->keep_read_only = !(VAR_2 & BDRV_O_RDWR);", "} else {", "VAR_0->backing_hd->keep_read_only = VAR_0->keep_read_only;", "}", "}", "if (!bdrv_key_required(VAR_0)) {", "VAR_0->media_changed = 1;", "if (VAR_0->change_cb)\nVAR_0->change_cb(VAR_0->change_opaque);", "}", "return 0;", "unlink_and_fail:\nif (VAR_0->is_temporary) {", "unlink(VAR_1);", "}", "return VAR_4;", "}" ]

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

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24, 25 ], [ 26 ], [ 27 ], [ 29, 30, 31 ], [ 32, 33 ], [ 34 ], [ 35 ], [ 36 ], [ 37 ], [ 38 ], [ 39, 40 ], [ 41 ], [ 42 ], [ 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 52 ], [ 53 ], [ 54 ], [ 55 ], [ 56 ], [ 57 ], [ 58 ], [ 59 ], [ 61 ], [ 62 ], [ 63 ], [ 64 ], [ 66 ], [ 67 ], [ 68 ], [ 69 ], [ 70 ], [ 71, 72 ], [ 73, 74 ], [ 76, 77 ], [ 78 ], [ 79 ], [ 80 ], [ 81 ], [ 82 ], [ 83 ], [ 84 ], [ 85 ], [ 87 ], [ 88 ], [ 89 ], [ 90 ], [ 92 ], [ 93, 94 ], [ 95 ], [ 96 ], [ 97, 98 ], [ 99 ], [ 100 ], [ 101 ], [ 102 ] ]

[ "static int FUNC_0(const char **VAR_0, AVFilterInOut **VAR_1,\nAVFilterInOut **VAR_2,\nAVFilterInOut **VAR_3, AVClass *VAR_4)\n{", "int VAR_5, VAR_6 = 0;", "while (**VAR_0 == '[') {", "char *VAR_7 = parse_link_name(VAR_0, VAR_4);", "AVFilterInOut *match;", "AVFilterInOut *input = *VAR_1;", "*VAR_1 = (*VAR_1)->next;", "if (!VAR_7)\nmatch = extract_inout(VAR_7, VAR_2);", "if (match) {", "if ((VAR_5 = link_filter(input->filter_ctx, input->pad_idx,\nmatch->filter_ctx, match->pad_idx, VAR_4)) < 0)\nreturn VAR_5;", "av_free(match->VAR_7);", "av_free(VAR_7);", "av_free(match);", "av_free(input);", "} else {", "input->VAR_7 = VAR_7;", "insert_inout(VAR_3, input);", "*VAR_0 += strspn(*VAR_0, WHITESPACES);", "VAR_6++;", "return VAR_6;" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 29 ], [ 33, 40 ], [ 44 ], [ 46, 48, 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 64 ], [ 66 ], [ 69 ], [ 71 ], [ 76 ] ]

[ "static inline void FUNC_0(void)\n{", "rgb15to16 = rgb15to16_c;", "rgb15tobgr24 = rgb15tobgr24_c;", "rgb15to32 = rgb15to32_c;", "rgb16tobgr24 = rgb16tobgr24_c;", "rgb16to32 = rgb16to32_c;", "rgb16to15 = rgb16to15_c;", "rgb24tobgr16 = rgb24tobgr16_c;", "rgb24tobgr15 = rgb24tobgr15_c;", "rgb24tobgr32 = rgb24tobgr32_c;", "rgb32to16 = rgb32to16_c;", "rgb32to15 = rgb32to15_c;", "rgb32tobgr24 = rgb32tobgr24_c;", "rgb24to15 = rgb24to15_c;", "rgb24to16 = rgb24to16_c;", "rgb24tobgr24 = rgb24tobgr24_c;", "shuffle_bytes_2103 = shuffle_bytes_2103_c;", "rgb32tobgr16 = rgb32tobgr16_c;", "rgb32tobgr15 = rgb32tobgr15_c;", "yv12toyuy2 = yv12toyuy2_c;", "yv12touyvy = yv12touyvy_c;", "yuv422ptoyuy2 = yuv422ptoyuy2_c;", "yuv422ptouyvy = yuv422ptouyvy_c;", "yuy2toyv12 = yuy2toyv12_c;", "planar2x = planar2x_c;", "rgb24toyv12 = rgb24toyv12_c;", "interleaveBytes = interleaveBytes_c;", "vu9_to_vu12 = vu9_to_vu12_c;", "yvu9_to_yuy2 = yvu9_to_yuy2_c;", "uyvytoyuv420 = uyvytoyuv420_c;", "uyvytoyuv422 = uyvytoyuv422_c;", "yuyvtoyuv420 = yuyvtoyuv420_c;", "yuyvtoyuv422 = yuyvtoyuv422_c;", "}" ]

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

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

[ "static Visitor *FUNC_0(TestInputVisitorData *data,\nconst char *json_string,\nva_list *ap)\n{", "visitor_input_teardown(data, NULL);", "data->obj = qobject_from_jsonv(json_string, ap);", "g_assert(data->obj);", "data->qiv = qobject_input_visitor_new(data->obj);", "g_assert(data->qiv);", "return data->qiv;", "}" ]

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

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

[ "static int FUNC_0(VideoState *VAR_0)\n{", "int VAR_1, VAR_2;", "int64_t dec_channel_layout;", "int VAR_3 = 0;", "av_unused double audio_clock0;", "int VAR_4;", "AVRational tb;", "int VAR_5;", "int VAR_6;", "if (!VAR_0->frame)\nif (!(VAR_0->frame = av_frame_alloc()))\nreturn AVERROR(ENOMEM);", "for (;;) {", "if (VAR_0->audioq.serial != VAR_0->auddec.pkt_serial)\nVAR_0->audio_buf_frames_pending = VAR_3 = 0;", "if (!VAR_3)\nav_frame_unref(VAR_0->frame);", "if (VAR_0->paused)\nreturn -1;", "while (VAR_0->audio_buf_frames_pending || VAR_3) {", "if (!VAR_0->audio_buf_frames_pending) {", "VAR_3 = 0;", "tb = (AVRational){1, VAR_0->frame->sample_rate};", "#if CONFIG_AVFILTER\ndec_channel_layout = get_valid_channel_layout(VAR_0->frame->channel_layout, av_frame_get_channels(VAR_0->frame));", "VAR_6 =\ncmp_audio_fmts(VAR_0->audio_filter_src.fmt, VAR_0->audio_filter_src.channels,\nVAR_0->frame->format, av_frame_get_channels(VAR_0->frame)) ||\nVAR_0->audio_filter_src.channel_layout != dec_channel_layout ||\nVAR_0->audio_filter_src.freq != VAR_0->frame->sample_rate ||\nVAR_0->auddec.pkt_serial != VAR_0->audio_last_serial;", "if (VAR_6) {", "char buf1[1024], buf2[1024];", "av_get_channel_layout_string(buf1, sizeof(buf1), -1, VAR_0->audio_filter_src.channel_layout);", "av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);", "av_log(NULL, AV_LOG_DEBUG,\n\"Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\\n\",\nVAR_0->audio_filter_src.freq, VAR_0->audio_filter_src.channels, av_get_sample_fmt_name(VAR_0->audio_filter_src.fmt), buf1, VAR_0->audio_last_serial,\nVAR_0->frame->sample_rate, av_frame_get_channels(VAR_0->frame), av_get_sample_fmt_name(VAR_0->frame->format), buf2, VAR_0->auddec.pkt_serial);", "VAR_0->audio_filter_src.fmt = VAR_0->frame->format;", "VAR_0->audio_filter_src.channels = av_frame_get_channels(VAR_0->frame);", "VAR_0->audio_filter_src.channel_layout = dec_channel_layout;", "VAR_0->audio_filter_src.freq = VAR_0->frame->sample_rate;", "VAR_0->audio_last_serial = VAR_0->auddec.pkt_serial;", "if ((VAR_5 = configure_audio_filters(VAR_0, afilters, 1)) < 0)\nreturn VAR_5;", "}", "if ((VAR_5 = av_buffersrc_add_frame(VAR_0->in_audio_filter, VAR_0->frame)) < 0)\nreturn VAR_5;", "#endif\n}", "#if CONFIG_AVFILTER\nif ((VAR_5 = av_buffersink_get_frame_flags(VAR_0->out_audio_filter, VAR_0->frame, 0)) < 0) {", "if (VAR_5 == AVERROR(EAGAIN)) {", "VAR_0->audio_buf_frames_pending = 0;", "continue;", "}", "if (VAR_5 == AVERROR_EOF)\nVAR_0->auddec.finished = VAR_0->auddec.pkt_serial;", "return VAR_5;", "}", "VAR_0->audio_buf_frames_pending = 1;", "tb = VAR_0->out_audio_filter->inputs[0]->time_base;", "#endif\nVAR_1 = av_samples_get_buffer_size(NULL, av_frame_get_channels(VAR_0->frame),\nVAR_0->frame->nb_samples,\nVAR_0->frame->format, 1);", "dec_channel_layout =\n(VAR_0->frame->channel_layout && av_frame_get_channels(VAR_0->frame) == av_get_channel_layout_nb_channels(VAR_0->frame->channel_layout)) ?\nVAR_0->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(VAR_0->frame));", "VAR_4 = synchronize_audio(VAR_0, VAR_0->frame->nb_samples);", "if (VAR_0->frame->format != VAR_0->audio_src.fmt ||\ndec_channel_layout != VAR_0->audio_src.channel_layout ||\nVAR_0->frame->sample_rate != VAR_0->audio_src.freq ||\n(VAR_4 != VAR_0->frame->nb_samples && !VAR_0->swr_ctx)) {", "swr_free(&VAR_0->swr_ctx);", "VAR_0->swr_ctx = swr_alloc_set_opts(NULL,\nVAR_0->audio_tgt.channel_layout, VAR_0->audio_tgt.fmt, VAR_0->audio_tgt.freq,\ndec_channel_layout, VAR_0->frame->format, VAR_0->frame->sample_rate,\n0, NULL);", "if (!VAR_0->swr_ctx || swr_init(VAR_0->swr_ctx) < 0) {", "av_log(NULL, AV_LOG_ERROR,\n\"Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\\n\",\nVAR_0->frame->sample_rate, av_get_sample_fmt_name(VAR_0->frame->format), av_frame_get_channels(VAR_0->frame),\nVAR_0->audio_tgt.freq, av_get_sample_fmt_name(VAR_0->audio_tgt.fmt), VAR_0->audio_tgt.channels);", "break;", "}", "VAR_0->audio_src.channel_layout = dec_channel_layout;", "VAR_0->audio_src.channels = av_frame_get_channels(VAR_0->frame);", "VAR_0->audio_src.freq = VAR_0->frame->sample_rate;", "VAR_0->audio_src.fmt = VAR_0->frame->format;", "}", "if (VAR_0->swr_ctx) {", "const uint8_t **VAR_7 = (const uint8_t **)VAR_0->frame->extended_data;", "uint8_t **out = &VAR_0->audio_buf1;", "int VAR_8 = (int64_t)VAR_4 * VAR_0->audio_tgt.freq / VAR_0->frame->sample_rate + 256;", "int VAR_9 = av_samples_get_buffer_size(NULL, VAR_0->audio_tgt.channels, VAR_8, VAR_0->audio_tgt.fmt, 0);", "int VAR_10;", "if (VAR_9 < 0) {", "av_log(NULL, AV_LOG_ERROR, \"av_samples_get_buffer_size() failed\\n\");", "break;", "}", "if (VAR_4 != VAR_0->frame->nb_samples) {", "if (swr_set_compensation(VAR_0->swr_ctx, (VAR_4 - VAR_0->frame->nb_samples) * VAR_0->audio_tgt.freq / VAR_0->frame->sample_rate,\nVAR_4 * VAR_0->audio_tgt.freq / VAR_0->frame->sample_rate) < 0) {", "av_log(NULL, AV_LOG_ERROR, \"swr_set_compensation() failed\\n\");", "break;", "}", "}", "av_fast_malloc(&VAR_0->audio_buf1, &VAR_0->audio_buf1_size, VAR_9);", "if (!VAR_0->audio_buf1)\nreturn AVERROR(ENOMEM);", "VAR_10 = swr_convert(VAR_0->swr_ctx, out, VAR_8, VAR_7, VAR_0->frame->nb_samples);", "if (VAR_10 < 0) {", "av_log(NULL, AV_LOG_ERROR, \"swr_convert() failed\\n\");", "break;", "}", "if (VAR_10 == VAR_8) {", "av_log(NULL, AV_LOG_WARNING, \"audio buffer VAR_0 probably too small\\n\");", "swr_init(VAR_0->swr_ctx);", "}", "VAR_0->audio_buf = VAR_0->audio_buf1;", "VAR_2 = VAR_10 * VAR_0->audio_tgt.channels * av_get_bytes_per_sample(VAR_0->audio_tgt.fmt);", "} else {", "VAR_0->audio_buf = VAR_0->frame->data[0];", "VAR_2 = VAR_1;", "}", "audio_clock0 = VAR_0->audio_clock;", "if (VAR_0->frame->pts != AV_NOPTS_VALUE)\nVAR_0->audio_clock = VAR_0->frame->pts * av_q2d(tb) + (double) VAR_0->frame->nb_samples / VAR_0->frame->sample_rate;", "else\nVAR_0->audio_clock = NAN;", "VAR_0->audio_clock_serial = VAR_0->auddec.pkt_serial;", "#ifdef DEBUG\n{", "static double last_clock;", "printf(\"audio: delay=%0.3f clock=%0.3f clock0=%0.3f\\n\",\nVAR_0->audio_clock - last_clock,\nVAR_0->audio_clock, audio_clock0);", "last_clock = VAR_0->audio_clock;", "}", "#endif\nreturn VAR_2;", "}", "if ((VAR_3 = decoder_decode_frame(&VAR_0->auddec, VAR_0->frame, NULL)) < 0)\nreturn -1;", "if (VAR_0->auddec.flushed)\nVAR_0->audio_buf_frames_pending = 0;", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "SCSIDiskReq *r = VAR_0;", "SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);", "uint32_t n;", "if (r->req.aiocb != NULL) {", "r->req.aiocb = NULL;", "bdrv_acct_done(s->qdev.conf.bs, &r->acct);", "if (VAR_1 < 0) {", "if (scsi_handle_rw_error(r, -VAR_1)) {", "goto done;", "if (r->req.sg) {", "dma_acct_start(s->qdev.conf.bs, &r->acct, r->req.sg, BDRV_ACCT_READ);", "r->req.resid -= r->req.sg->size;", "r->req.aiocb = dma_bdrv_read(s->qdev.conf.bs, r->req.sg, r->sector,\nscsi_dma_complete, r);", "} else {", "n = scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);", "bdrv_acct_start(s->qdev.conf.bs, &r->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);", "r->req.aiocb = bdrv_aio_readv(s->qdev.conf.bs, r->sector, &r->qiov, n,\nscsi_read_complete, r);", "done:\nif (!r->req.io_canceled) {", "scsi_req_unref(&r->req);" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15, 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20, 21 ], [ 22, 23 ], [ 24 ] ]

[ "static void VAR_0 sd_write_done(SheepdogAIOCB *acb)\n{", "BDRVSheepdogState *s = acb->common.bs->opaque;", "struct iovec iov;", "AIOReq *aio_req;", "uint32_t offset, data_len, mn, mx;", "mn = s->min_dirty_data_idx;", "mx = s->max_dirty_data_idx;", "if (mn <= mx) {", "offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +\nmn * sizeof(s->inode.data_vdi_id[0]);", "data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);", "s->min_dirty_data_idx = UINT32_MAX;", "s->max_dirty_data_idx = 0;", "iov.iov_base = &s->inode;", "iov.iov_len = sizeof(s->inode);", "aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),\ndata_len, offset, 0, false, 0, offset);", "QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);", "add_aio_request(s, aio_req, &iov, 1, AIOCB_WRITE_UDATA);", "acb->aio_done_func = sd_finish_aiocb;", "acb->aiocb_type = AIOCB_WRITE_UDATA;", "return;", "}", "sd_finish_aiocb(acb);", "}" ]

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

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

[ "static int VAR_0 bdrv_aligned_pwritev(BlockDriverState *bs,\nBdrvTrackedRequest *req, int64_t offset, unsigned int bytes,\nint64_t align, QEMUIOVector *qiov, int flags)\n{", "BlockDriver *drv = bs->drv;", "bool waited;", "int ret;", "int64_t start_sector = offset >> BDRV_SECTOR_BITS;", "int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);", "uint64_t bytes_remaining = bytes;", "int max_transfer;", "assert(is_power_of_2(align));", "assert((offset & (align - 1)) == 0);", "assert((bytes & (align - 1)) == 0);", "assert(!qiov || bytes == qiov->size);", "assert((bs->open_flags & BDRV_O_NO_IO) == 0);", "assert(!(flags & ~BDRV_REQ_MASK));", "max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),\nalign);", "waited = wait_serialising_requests(req);", "assert(!waited || !req->serialising);", "assert(req->overlap_offset <= offset);", "assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);", "ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);", "if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&\n!(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_pwrite_zeroes &&\nqemu_iovec_is_zero(qiov)) {", "flags |= BDRV_REQ_ZERO_WRITE;", "if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {", "flags |= BDRV_REQ_MAY_UNMAP;", "}", "}", "if (ret < 0) {", "} else if (flags & BDRV_REQ_ZERO_WRITE) {", "bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);", "ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);", "} else if (flags & BDRV_REQ_WRITE_COMPRESSED) {", "ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov);", "} else if (bytes <= max_transfer) {", "bdrv_debug_event(bs, BLKDBG_PWRITEV);", "ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, flags);", "} else {", "bdrv_debug_event(bs, BLKDBG_PWRITEV);", "while (bytes_remaining) {", "int num = MIN(bytes_remaining, max_transfer);", "QEMUIOVector local_qiov;", "int local_flags = flags;", "assert(num);", "if (num < bytes_remaining && (flags & BDRV_REQ_FUA) &&\n!(bs->supported_write_flags & BDRV_REQ_FUA)) {", "local_flags &= ~BDRV_REQ_FUA;", "}", "qemu_iovec_init(&local_qiov, qiov->niov);", "qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);", "ret = bdrv_driver_pwritev(bs, offset + bytes - bytes_remaining,\nnum, &local_qiov, local_flags);", "qemu_iovec_destroy(&local_qiov);", "if (ret < 0) {", "break;", "}", "bytes_remaining -= num;", "}", "}", "bdrv_debug_event(bs, BLKDBG_PWRITEV_DONE);", "++bs->write_gen;", "bdrv_set_dirty(bs, start_sector, end_sector - start_sector);", "if (bs->wr_highest_offset < offset + bytes) {", "bs->wr_highest_offset = offset + bytes;", "}", "if (ret >= 0) {", "bs->total_sectors = MAX(bs->total_sectors, end_sector);", "ret = 0;", "}", "return ret;", "}" ]

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

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

[ "static target_ulong FUNC_0(struct target_sigaction *ka,\nCPUPPCState *env,\nint frame_size)\n{", "target_ulong oldsp, newsp;", "oldsp = env->gpr[1];", "if ((ka->sa_flags & TARGET_SA_ONSTACK) &&\n(sas_ss_flags(oldsp))) {", "oldsp = (target_sigaltstack_used.ss_sp\n+ target_sigaltstack_used.ss_size);", "}", "newsp = (oldsp - frame_size) & ~0xFUL;", "return newsp;", "}" ]

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

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

[ "vsprintf_len(string, format, args)\nchar *string;", "const char *format;", "va_list args;", "{", "vsprintf(string, format, args);", "return strlen(string);", "}" ]

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

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

[ "void FUNC_0(idte)(CPUS390XState *env, uint64_t r1, uint64_t r2, uint32_t m4)\n{", "CPUState *cs = CPU(s390_env_get_cpu(env));", "const uintptr_t VAR_0 = GETPC();", "uint64_t table, entry, raddr;", "uint16_t entries, i, index = 0;", "if (r2 & 0xff000) {", "cpu_restore_state(cs, VAR_0);", "program_interrupt(env, PGM_SPECIFICATION, 4);", "}", "if (!(r2 & 0x800)) {", "table = r1 & _ASCE_ORIGIN;", "entries = (r2 & 0x7ff) + 1;", "switch (r1 & _ASCE_TYPE_MASK) {", "case _ASCE_TYPE_REGION1:\nindex = (r2 >> 53) & 0x7ff;", "break;", "case _ASCE_TYPE_REGION2:\nindex = (r2 >> 42) & 0x7ff;", "break;", "case _ASCE_TYPE_REGION3:\nindex = (r2 >> 31) & 0x7ff;", "break;", "case _ASCE_TYPE_SEGMENT:\nindex = (r2 >> 20) & 0x7ff;", "break;", "}", "for (i = 0; i < entries; i++) {", "raddr = table + ((index + i) & 0x7ff) * sizeof(entry);", "entry = cpu_ldq_real_ra(env, raddr, VAR_0);", "if (!(entry & _REGION_ENTRY_INV)) {", "entry |= _REGION_ENTRY_INV;", "cpu_stq_real_ra(env, raddr, entry, VAR_0);", "}", "}", "}", "if (m4 & 1) {", "tlb_flush(cs);", "} else {", "tlb_flush_all_cpus_synced(cs);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ] ]

[ "CharDriverState *FUNC_0(QemuOpts *opts,\nvoid (*init)(struct CharDriverState *s))\n{", "CharDriverState *chr;", "int VAR_0;", "if (qemu_opts_id(opts) == NULL) {", "fprintf(stderr, \"chardev: no id specified\\n\");", "return NULL;", "}", "for (VAR_0 = 0; VAR_0 < ARRAY_SIZE(backend_table); VAR_0++) {", "if (strcmp(backend_table[VAR_0].name, qemu_opt_get(opts, \"backend\")) == 0)\nbreak;", "}", "if (VAR_0 == ARRAY_SIZE(backend_table)) {", "fprintf(stderr, \"chardev: backend \\\"%s\\\" not found\\n\",\nqemu_opt_get(opts, \"backend\"));", "return NULL;", "}", "chr = backend_table[VAR_0].open(opts);", "if (!chr) {", "fprintf(stderr, \"chardev: opening backend \\\"%s\\\" failed\\n\",\nqemu_opt_get(opts, \"backend\"));", "return NULL;", "}", "if (!chr->filename)\nchr->filename = qemu_strdup(qemu_opt_get(opts, \"backend\"));", "chr->init = init;", "TAILQ_INSERT_TAIL(&chardevs, chr, next);", "if (qemu_opt_get_bool(opts, \"mux\", 0)) {", "CharDriverState *base = chr;", "int VAR_1 = strlen(qemu_opts_id(opts)) + 6;", "base->label = qemu_malloc(VAR_1);", "snprintf(base->label, VAR_1, \"%s-base\", qemu_opts_id(opts));", "chr = qemu_chr_open_mux(base);", "chr->filename = base->filename;", "TAILQ_INSERT_TAIL(&chardevs, chr, next);", "}", "chr->label = qemu_strdup(qemu_opts_id(opts));", "return chr;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1, int *VAR_2, uint8_t *VAR_3, int VAR_4)\n{", "AC3DecodeContext *ctx = (AC3DecodeContext *)VAR_0->priv_data;", "ac3_audio_block *ab = &ctx->audio_block;", "int VAR_5;", "int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "float VAR_11[128], VAR_12[128];", "int16_t *out_samples = (int16_t *)VAR_1;", "int VAR_13;", "VAR_5 = ac3_synchronize(VAR_3, VAR_4);", "if (VAR_5 == -1) {", "av_log(VAR_0, AV_LOG_ERROR, \"frame is not synchronized\\n\");", "*VAR_2 = 0;", "return VAR_4;", "}", "init_get_bits(&(ctx->gb), VAR_3 + VAR_5, (VAR_4 - VAR_5) * 8);", "if (!ac3_parse_sync_info(ctx)) {", "av_log(VAR_0, AV_LOG_ERROR, \"\\n\");", "*VAR_2 = 0;", "return -1;", "}", "if (ac3_parse_bsi(ctx)) {", "av_log(VAR_0, AV_LOG_ERROR, \"bsid is not valid\\n\");", "*VAR_2 = 0;", "return -1;", "}", "for (VAR_6 = 0; VAR_6 < MAX_BLOCKS; VAR_6++)", "memset(ctx->delay[VAR_6], 0, sizeof(ctx->delay[VAR_6]));", "VAR_0->sample_rate = ctx->sync_info.sampling_rate;", "VAR_0->bit_rate = ctx->sync_info.bit_rate;", "if (VAR_0->channels == 0) {", "ctx->output = AC3_OUTPUT_UNMODIFIED;", "}", "else if ((ctx->bsi.VAR_13 + ((ctx->bsi.flags & AC3_BSI_LFEON) ? 1 : 0)) < VAR_0->channels) {", "av_log(VAR_0, AV_LOG_INFO, \"ac3_decoder: AC3 Source Channels Are Less Then Specified %d: Output to %d Channels\\n\",\nVAR_0->channels, (ctx->bsi.VAR_13 + ((ctx->bsi.flags & AC3_BSI_LFEON) ? 1 : 0)));", "ctx->output = AC3_OUTPUT_UNMODIFIED;", "}", "else if (VAR_0->channels == 1) {", "ctx->output = AC3_OUTPUT_MONO;", "} else if (VAR_0->channels == 2) {", "if (ctx->bsi.dsurmod == 0x02)\nctx->output = AC3_OUTPUT_DOLBY;", "else\nctx->output = AC3_OUTPUT_STEREO;", "}", "av_log(VAR_0, AV_LOG_INFO, \"channels = %d \\t bit rate = %d \\t sampling rate = %d \\n\", VAR_0->channels, VAR_0->sample_rate, VAR_0->bit_rate);", "*VAR_2 = 0;", "for (VAR_6 = 0; VAR_6 < 6; VAR_6++) {", "if (ac3_parse_audio_block(ctx, VAR_6)) {", "av_log(VAR_0, AV_LOG_ERROR, \"error parsing the audio block\\n\");", "*VAR_2 = 0;", "return -1;", "}", "av_log(NULL, AV_LOG_INFO, \"doing imdct\\n\");", "if (ctx->bsi.flags & AC3_BSI_LFEON) {", "ff_imdct_calc(&ctx->imdct_ctx_512, ctx->tmp_output, ab->transform_coeffs[0], ctx->tmp_imdct);", "for (VAR_9 = 0; VAR_9 < 256; VAR_9++)", "ab->block_output[0][VAR_9] = ctx->tmp_output[VAR_9] * window[VAR_9] + ctx->delay[0][VAR_9] * window[255 -VAR_9];", "memcpy(ctx->delay[0], ctx->tmp_output + 256, sizeof(ctx->delay[0]));", "}", "for (VAR_7 = 0; VAR_7 < ctx->bsi.VAR_13; VAR_7++) {", "if (ctx->audio_block.blksw & (1 << VAR_7)) {", "for (VAR_8 = 0; VAR_8 < 128; VAR_8++) {", "VAR_11[VAR_8] = ab->transform_coeffs[VAR_7 + 1][2 * VAR_8];", "VAR_12[VAR_8] = ab->transform_coeffs[VAR_7 + 1][2 * VAR_8 + 1];", "}", "ff_imdct_calc(&ctx->imdct_ctx_256, ctx->tmp_output, VAR_11, ctx->tmp_imdct);", "for (VAR_9 = 0; VAR_9 < 256; VAR_9++)", "ab->block_output[VAR_7 + 1][VAR_9] = ctx->tmp_output[VAR_9] * window[VAR_9] + ctx->delay[VAR_7 + 1][VAR_9] * window[255 - VAR_9];", "ff_imdct_calc(&ctx->imdct_ctx_256, ctx->delay[VAR_7 + 1], VAR_12, ctx->tmp_imdct);", "} else {", "ff_imdct_calc(&ctx->imdct_ctx_512, ctx->tmp_output, ab->transform_coeffs[VAR_7 + 1], ctx->tmp_imdct);", "for (VAR_9 = 0; VAR_9 < 256; VAR_9++)", "ab->block_output[VAR_7 + 1][VAR_9] = ctx->tmp_output[VAR_9] * window[VAR_9] + ctx->delay[VAR_7 + 1][VAR_9] * window[255 - VAR_9];", "memcpy(ctx->delay[VAR_7 + 1], ctx->tmp_output + 256, sizeof(ctx->delay[VAR_7 + 1]));", "}", "}", "if (ctx->bsi.flags & AC3_BSI_LFEON) {", "for (VAR_9 = 0; VAR_9 < 256; VAR_9++) {", "VAR_10 = lrint(ab->block_output[0][VAR_9]);", "if (VAR_10 < -32768)\nVAR_10 = -32768;", "else if (VAR_10 > 32767)\nVAR_10 = 32767;", "*(out_samples++) = VAR_10;", "}", "*VAR_2 += 256 * sizeof(int16_t);", "}", "do_downmix(ctx);", "if (ctx->output == AC3_OUTPUT_UNMODIFIED)\nVAR_13 = ctx->bsi.VAR_13;", "else\nVAR_13 = VAR_0->channels;", "for (VAR_8 = 0; VAR_8 < VAR_13; VAR_8++)", "for (VAR_9 = 0; VAR_9 < 256; VAR_9++) {", "VAR_10 = lrint(ab->block_output[VAR_8 + 1][VAR_9]);", "if (VAR_10 < -32768)\nVAR_10 = -32768;", "else if (VAR_10 > 32767)\nVAR_10 = 32767;", "*(out_samples++) = VAR_10;", "}", "*VAR_2 += VAR_13 * 256 * sizeof (int16_t);", "}", "return ctx->sync_info.framesize;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125, 127 ], [ 129 ], [ 135 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215, 217 ], [ 219, 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233, 235 ], [ 237, 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247, 249 ], [ 251, 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 265 ], [ 267 ] ]

[ "static void FUNC_0 (QEMUFile *VAR_0, void *VAR_1)\n{", "size_t i;", "uint8_t active[LAST_INDEX];", "AC97LinkState *s = VAR_1;", "pci_device_save (s->pci_dev, VAR_0);", "qemu_put_be32s (VAR_0, &s->glob_cnt);", "qemu_put_be32s (VAR_0, &s->glob_sta);", "qemu_put_be32s (VAR_0, &s->cas);", "for (i = 0; i < ARRAY_SIZE (s->bm_regs); ++i) {", "AC97BusMasterRegs *r = &s->bm_regs[i];", "qemu_put_be32s (VAR_0, &r->bdbar);", "qemu_put_8s (VAR_0, &r->civ);", "qemu_put_8s (VAR_0, &r->lvi);", "qemu_put_be16s (VAR_0, &r->sr);", "qemu_put_be16s (VAR_0, &r->picb);", "qemu_put_8s (VAR_0, &r->piv);", "qemu_put_8s (VAR_0, &r->cr);", "qemu_put_be32s (VAR_0, &r->bd_valid);", "qemu_put_be32s (VAR_0, &r->bd.addr);", "qemu_put_be32s (VAR_0, &r->bd.ctl_len);", "}", "qemu_put_buffer (VAR_0, s->mixer_data, sizeof (s->mixer_data));", "active[PI_INDEX] = AUD_is_active_in (s->voice_pi) ? 1 : 0;", "active[PO_INDEX] = AUD_is_active_out (s->voice_po) ? 1 : 0;", "active[MC_INDEX] = AUD_is_active_in (s->voice_mc) ? 1 : 0;", "qemu_put_buffer (VAR_0, active, sizeof (active));", "}" ]

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

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

[ "static void FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{", "if (cpu_ticks_enabled) {", "hw_error(\"cannot save state if virtual timers are running\");", "}", "qemu_put_be64(VAR_0, cpu_ticks_offset);", "qemu_put_be64(VAR_0, ticks_per_sec);", "qemu_put_be64(VAR_0, cpu_clock_offset);", "}" ]

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

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

[ "void FUNC_0(const uint8_t *VAR_0,\nuint32_t VAR_1,\nbool *VAR_2, bool *VAR_3,\nbool *VAR_4, bool *VAR_5)\n{", "int VAR_6;", "size_t l2hdr_len = eth_get_l2_hdr_length(VAR_0);", "assert(VAR_1 >= eth_get_l2_hdr_length(VAR_0));", "*VAR_2 = *VAR_3 = *VAR_4 = *VAR_5 = false;", "VAR_6 = eth_get_l3_proto(VAR_0, l2hdr_len);", "if (VAR_6 == ETH_P_IP) {", "*VAR_2 = true;", "struct ip_header *VAR_7;", "assert(VAR_1 >=\neth_get_l2_hdr_length(VAR_0) + sizeof(struct ip_header));", "VAR_7 = PKT_GET_IP_HDR(VAR_0);", "if (IP_HEADER_VERSION(VAR_7) == IP_HEADER_VERSION_4) {", "if (VAR_7->ip_p == IP_PROTO_TCP) {", "*VAR_5 = true;", "} else if (VAR_7->ip_p == IP_PROTO_UDP) {", "*VAR_4 = true;", "}", "}", "} else if (VAR_6 == ETH_P_IPV6) {", "uint8_t l4proto;", "size_t full_ip6hdr_len;", "struct iovec VAR_8;", "VAR_8.iov_base = (void *) VAR_0;", "VAR_8.iov_len = VAR_1;", "*VAR_3 = true;", "if (eth_parse_ipv6_hdr(&VAR_8, 1, l2hdr_len,\n&l4proto, &full_ip6hdr_len)) {", "if (l4proto == IP_PROTO_TCP) {", "*VAR_5 = true;", "} else if (l4proto == IP_PROTO_UDP) {", "*VAR_4 = true;", "}", "}", "}", "}" ]

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

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

[ "VncInfo *FUNC_0(Error **errp)\n{", "VncInfo *info = g_malloc0(sizeof(*info));", "VncDisplay *vd = vnc_display_find(NULL);", "SocketAddressLegacy *addr = NULL;", "if (vd == NULL || !vd->nlsock) {", "info->enabled = false;", "} else {", "info->enabled = true;", "info->has_clients = true;", "info->clients = qmp_query_client_list(vd);", "if (vd->lsock == NULL) {", "return info;", "}", "addr = qio_channel_socket_get_local_address(vd->lsock[0], errp);", "if (!addr) {", "goto out_error;", "}", "switch (addr->type) {", "case SOCKET_ADDRESS_LEGACY_KIND_INET:\ninfo->host = g_strdup(addr->u.inet.data->host);", "info->service = g_strdup(addr->u.inet.data->port);", "if (addr->u.inet.data->ipv6) {", "info->family = NETWORK_ADDRESS_FAMILY_IPV6;", "} else {", "info->family = NETWORK_ADDRESS_FAMILY_IPV4;", "}", "break;", "case SOCKET_ADDRESS_LEGACY_KIND_UNIX:\ninfo->host = g_strdup(\"\");", "info->service = g_strdup(addr->u.q_unix.data->path);", "info->family = NETWORK_ADDRESS_FAMILY_UNIX;", "break;", "case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:\ncase SOCKET_ADDRESS_LEGACY_KIND_FD:\nerror_setg(errp, \"Unsupported socket address type %s\",\nSocketAddressLegacyKind_lookup[addr->type]);", "goto out_error;", "default:\nabort();", "}", "info->has_host = true;", "info->has_service = true;", "info->has_family = true;", "info->has_auth = true;", "info->auth = g_strdup(vnc_auth_name(vd));", "}", "qapi_free_SocketAddressLegacy(addr);", "return info;", "out_error:\nqapi_free_SocketAddressLegacy(addr);", "qapi_free_VncInfo(info);", "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, 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 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83, 85, 87, 89 ], [ 91 ], [ 93, 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ] ]

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "#ifdef DEBUG_UNASSIGNED\nprintf(\"Unassigned mem write \" TARGET_FMT_plx \" = 0x%\"PRIx64\"\\n\", VAR_1, VAR_2);", "#endif\n#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)\ncpu_unassigned_access(cpu_single_env, VAR_1, 1, 0, 0, VAR_3);", "#endif\n}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(SysBusDevice *VAR_0)\n{", "MilkymistVgafbState *s = FROM_SYSBUS(typeof(*s), VAR_0);", "memory_region_init_io(&s->regs_region, &vgafb_mmio_ops, s,\n\"milkymist-vgafb\", R_MAX * 4);", "sysbus_init_mmio(VAR_0, &s->regs_region);", "s->con = graphic_console_init(vgafb_update_display,\nvgafb_invalidate_display,\nNULL, NULL, s);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "qemu_mutex_init(&flat_view_mutex);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(TCGContext *VAR_0, TCGRegSet VAR_1)\n{", "int VAR_2;", "for (VAR_2 = VAR_0->nb_globals; VAR_2 < VAR_0->nb_temps; VAR_2++) {", "TCGTemp *ts = &VAR_0->temps[VAR_2];", "if (ts->temp_local) {", "temp_save(VAR_0, ts, VAR_1);", "} else {", "#ifdef USE_LIVENESS_ANALYSIS\nif (!ts->indirect_base) {", "assert(ts->val_type == TEMP_VAL_DEAD);", "continue;", "}", "#endif\ntemp_dead(VAR_0, ts);", "}", "}", "save_globals(VAR_0, VAR_1);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19, 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ] ]

[ "static int FUNC_0(uint8_t* VAR_0, int VAR_1, int VAR_2, VC9Context *VAR_3)\n{", "int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;", "uint8_t invert, *planep = VAR_0;", "int VAR_12= VAR_1;", "invert = get_bits(&VAR_3->gb, 1);", "VAR_4 = get_vlc2(&VAR_3->gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);", "av_log(VAR_3->avctx, AV_LOG_DEBUG, \"Bitplane: VAR_4=%VAR_7, invert=%VAR_7\\n\",\nVAR_4, invert);", "switch (VAR_4)\n{", "case IMODE_RAW:\nfor (VAR_6=0; VAR_6<VAR_2; VAR_6++)", "{", "for (VAR_5=0; VAR_5<VAR_1; VAR_5++)", "planep[VAR_5] = (-get_bits(&VAR_3->gb, 1));", "planep += VAR_12;", "}", "invert=0;", "break;", "case IMODE_DIFF2:\ncase IMODE_NORM2:\nif ((VAR_2*VAR_1) & 1) *(++planep) = get_bits(&VAR_3->gb, 1);", "for(VAR_7=0; VAR_7<(VAR_2*VAR_1)>>1; VAR_7++){", "VAR_8 = get_vlc2(&VAR_3->gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);", "*(++planep) = VAR_8&1;", "*(++planep) = VAR_8&2;", "}", "break;", "case IMODE_DIFF6:\ncase IMODE_NORM6:\nVAR_9= VAR_2%3==0 && VAR_1%3!=0;", "VAR_10= VAR_9 ? 2 : 3;", "VAR_11= VAR_9 ? 3 : 2;", "for(VAR_6= VAR_2%VAR_11; VAR_6<VAR_2; VAR_6+=VAR_11){", "for(VAR_5= VAR_1%VAR_10; VAR_5<VAR_1; VAR_5+=VAR_10){", "VAR_8 = get_vlc2(&VAR_3->gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);", "planep[VAR_5 + 0*VAR_12]= (VAR_8>>0)&1;", "planep[VAR_5 + 1 + 0*VAR_12]= (VAR_8>>1)&1;", "if(VAR_9){", "planep[VAR_5 + 0 + 1*VAR_12]= (VAR_8>>2)&1;", "planep[VAR_5 + 1 + 1*VAR_12]= (VAR_8>>3)&1;", "planep[VAR_5 + 0 + 2*VAR_12]= (VAR_8>>4)&1;", "planep[VAR_5 + 1 + 2*VAR_12]= (VAR_8>>5)&1;", "}else{", "planep[VAR_5 + 2 + 0*VAR_12]= (VAR_8>>2)&1;", "planep[VAR_5 + 0 + 1*VAR_12]= (VAR_8>>3)&1;", "planep[VAR_5 + 1 + 1*VAR_12]= (VAR_8>>4)&1;", "planep[VAR_5 + 2 + 1*VAR_12]= (VAR_8>>5)&1;", "}", "}", "}", "VAR_5= VAR_1 % VAR_10;", "decode_colskip(VAR_0 , VAR_5, VAR_2 , VAR_12, VAR_3);", "decode_rowskip(VAR_0+VAR_5, VAR_1 - VAR_5, VAR_2 % VAR_11, VAR_12, VAR_3);", "break;", "case IMODE_ROWSKIP:\ndecode_rowskip(VAR_0, VAR_1, VAR_2, VAR_12, VAR_3);", "break;", "case IMODE_COLSKIP:\ndecode_colskip(VAR_0, VAR_1, VAR_2, VAR_12, VAR_3);", "break;", "default: break;", "}", "if (VAR_4 == IMODE_DIFF2 || VAR_4 == IMODE_DIFF6)\n{", "planep = VAR_0;", "planep[0] ^= invert;", "for (VAR_5=1; VAR_5<VAR_1; VAR_5++)", "planep[VAR_5] ^= planep[VAR_5-1];", "for (VAR_6=1; VAR_6<VAR_2; VAR_6++)", "{", "planep += VAR_12;", "planep[0] ^= planep[-VAR_12];", "for (VAR_5=1; VAR_5<VAR_1; VAR_5++)", "{", "if (planep[VAR_5-1] != planep[VAR_5-VAR_12]) planep[VAR_5] ^= invert;", "else planep[VAR_5] ^= planep[VAR_5-1];", "}", "}", "}", "else if (invert)\n{", "planep = VAR_0;", "for (VAR_5=0; VAR_5<VAR_1*VAR_2; VAR_5++) planep[VAR_5] = !planep[VAR_5];", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0 (HWVoiceOut *VAR_0, audsettings_t *VAR_1)\n{", "int VAR_2;", "static pa_sample_spec VAR_3;", "audsettings_t obt_as = *VAR_1;", "PAVoiceOut *pa = (PAVoiceOut *) VAR_0;", "VAR_3.format = audfmt_to_pa (VAR_1->fmt, VAR_1->endianness);", "VAR_3.channels = VAR_1->nchannels;", "VAR_3.rate = VAR_1->freq;", "obt_as.fmt = pa_to_audfmt (VAR_3.format, &obt_as.endianness);", "pa->s = pa_simple_new (\nconf.server,\n\"qemu\",\nPA_STREAM_PLAYBACK,\nconf.sink,\n\"pcm.playback\",\n&VAR_3,\nNULL,\nNULL,\n&VAR_2\n);", "if (!pa->s) {", "qpa_logerr (VAR_2, \"pa_simple_new for playback failed\\n\");", "goto fail1;", "}", "audio_pcm_init_info (&VAR_0->info, &obt_as);", "VAR_0->samples = conf.samples;", "pa->pcm_buf = audio_calloc (AUDIO_FUNC, VAR_0->samples, 1 << VAR_0->info.shift);", "if (!pa->pcm_buf) {", "dolog (\"Could not allocate buffer (%d bytes)\\n\",\nVAR_0->samples << VAR_0->info.shift);", "goto fail2;", "}", "if (audio_pt_init (&pa->pt, qpa_thread_out, VAR_0, AUDIO_CAP, AUDIO_FUNC)) {", "goto fail3;", "}", "return 0;", "fail3:\nfree (pa->pcm_buf);", "pa->pcm_buf = NULL;", "fail2:\npa_simple_free (pa->s);", "pa->s = NULL;", "fail1:\nreturn -1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 89, 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101, 103 ], [ 105 ] ]

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nconst char *VAR_2, V9fsPath *VAR_3)\n{", "if (VAR_1) {", "v9fs_string_sprintf((V9fsString *)VAR_3, \"%s/%s\",\nVAR_1->data, VAR_2);", "} else {", "v9fs_string_sprintf((V9fsString *)VAR_3, \"%s\", VAR_2);", "}", "VAR_3->size++;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nconst char *VAR_2, FsCred *VAR_3)\n{", "errno = EPERM;", "return -1;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "RoqContext *enc = VAR_0->priv_data;", "int VAR_4, VAR_5;", "enc->VAR_0 = VAR_0;", "enc->frame_to_enc = VAR_2;", "if (VAR_2->quality)\nenc->lambda = VAR_2->quality - 1;", "else\nenc->lambda = 2*ROQ_LAMBDA_SCALE;", "VAR_4 = ((enc->width * enc->height / 64) * 138 + 7) / 8 + 256 * (6 + 4) + 8;", "if ((VAR_5 = ff_alloc_packet(VAR_1, VAR_4)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Error getting output packet with VAR_4 %d.\\n\", VAR_4);", "return VAR_5;", "}", "enc->out_buf = VAR_1->data;", "if (enc->framesSinceKeyframe == VAR_0->gop_size)\nenc->framesSinceKeyframe = 0;", "if (enc->first_frame) {", "if (ff_get_buffer(VAR_0, enc->current_frame, 0) ||\nff_get_buffer(VAR_0, enc->last_frame, 0)) {", "av_log(VAR_0, AV_LOG_ERROR, \" RoQ: get_buffer() failed\\n\");", "return -1;", "}", "roq_write_video_info_chunk(enc);", "enc->first_frame = 0;", "}", "roq_encode_video(enc);", "VAR_1->VAR_4 = enc->out_buf - VAR_1->data;", "if (enc->framesSinceKeyframe == 1)\nVAR_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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 21, 23 ], [ 25, 27 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 51, 53 ], [ 57 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 77 ], [ 81 ], [ 83 ], [ 89 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 103 ], [ 105 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0,\nAVCodecContext *VAR_1, const uint8_t *VAR_2, int VAR_3)\n{", "SWFContext *swf = VAR_0->priv_data;", "ByteIOContext *pb = &VAR_0->pb;", "int VAR_4 = 0;", "int VAR_5 = 0;", "int VAR_6 = 0;", "if ( swf->swf_frame_number >= 16000 ) {", "return 0;", "}", "if ( VAR_1->codec_type == CODEC_TYPE_VIDEO ) {", "SWFFrame *new_frame = av_malloc(sizeof(SWFFrame));", "new_frame->prev = 0;", "new_frame->next = swf->frame_head;", "new_frame->data = av_malloc(VAR_3);", "new_frame->VAR_3 = VAR_3;", "memcpy(new_frame->data,VAR_2,VAR_3);", "swf->frame_head = new_frame;", "if ( swf->frame_tail == 0 ) {", "swf->frame_tail = new_frame;", "}", "}", "if ( swf->audio_type ) {", "retry_swf_audio_packet:\nif ( ( swf->audio_size-VAR_5 ) >= 4 ) {", "int VAR_7 = 0;", "int VAR_8 = 0;", "int VAR_9 = 0;", "int VAR_10 = 0;", "uint8_t header[4];", "for (VAR_4=0; VAR_4<4; VAR_4++) {", "header[VAR_4] = swf->audio_fifo[(swf->audio_in_pos+VAR_5+VAR_4) % AUDIO_FIFO_SIZE];", "}", "if ( swf_mp3_info(header,&VAR_7,&VAR_10,&VAR_8,&VAR_9) ) {", "if ( ( swf->audio_size-VAR_5 ) >= VAR_7 ) {", "VAR_5 += VAR_7;", "VAR_6 += VAR_10;", "if ( ( swf->sound_samples + VAR_6 + swf->samples_per_frame ) < swf->video_samples ) {", "goto retry_swf_audio_packet;", "}", "}", "} else {", "swf->audio_in_pos ++;", "swf->audio_size --;", "swf->audio_in_pos %= AUDIO_FIFO_SIZE;", "goto retry_swf_audio_packet;", "}", "}", "if ( ( swf->sound_samples + VAR_6 + swf->samples_per_frame ) < swf->video_samples ) {", "return 0;", "}", "if ( VAR_1->codec_type == CODEC_TYPE_VIDEO ) {", "swf->skip_samples = (int)( ( (double)(swf->swf_frame_number) * (double)VAR_1->frame_rate_base * 44100. ) / (double)(VAR_1->frame_rate) );", "swf->skip_samples -= swf->video_samples;", "}", "}", "if (swf->skip_samples <= ( swf->samples_per_frame / 2 ) ) {", "if ( swf->frame_tail ) {", "if ( swf->video_type == CODEC_ID_FLV1 ) {", "if ( swf->video_frame_number == 0 ) {", "put_swf_tag(VAR_0, TAG_VIDEOSTREAM);", "put_le16(pb, VIDEO_ID);", "put_le16(pb, 15000 );", "put_le16(pb, VAR_1->width);", "put_le16(pb, VAR_1->height);", "put_byte(pb, 0);", "put_byte(pb, SWF_VIDEO_CODEC_FLV1);", "put_swf_end_tag(VAR_0);", "put_swf_tag(VAR_0, TAG_PLACEOBJECT2);", "put_byte(pb, 0x36);", "put_le16(pb, 1);", "put_le16(pb, VIDEO_ID);", "put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);", "put_le16(pb, swf->video_frame_number );", "put_byte(pb, 'v');", "put_byte(pb, 'i');", "put_byte(pb, 'd');", "put_byte(pb, 'e');", "put_byte(pb, 'o');", "put_byte(pb, 0x00);", "put_swf_end_tag(VAR_0);", "} else {", "put_swf_tag(VAR_0, TAG_PLACEOBJECT2);", "put_byte(pb, 0x11);", "put_le16(pb, 1);", "put_le16(pb, swf->video_frame_number );", "put_swf_end_tag(VAR_0);", "}", "for (; ( VAR_1->frame_number - swf->video_frame_number ) > 0;) {", "put_swf_tag(VAR_0, TAG_VIDEOFRAME | TAG_LONG);", "put_le16(pb, VIDEO_ID);", "put_le16(pb, swf->video_frame_number++ );", "put_buffer(pb, swf->frame_tail->data, swf->frame_tail->VAR_3);", "put_swf_end_tag(VAR_0);", "}", "} else if ( swf->video_type == CODEC_ID_MJPEG ) {", "if (swf->swf_frame_number > 0) {", "put_swf_tag(VAR_0, TAG_REMOVEOBJECT);", "put_le16(pb, SHAPE_ID);", "put_le16(pb, 1);", "put_swf_end_tag(VAR_0);", "put_swf_tag(VAR_0, TAG_FREECHARACTER);", "put_le16(pb, BITMAP_ID);", "put_swf_end_tag(VAR_0);", "}", "put_swf_tag(VAR_0, TAG_JPEG2 | TAG_LONG);", "put_le16(pb, BITMAP_ID);", "put_byte(pb, 0xff);", "put_byte(pb, 0xd8);", "put_byte(pb, 0xff);", "put_byte(pb, 0xd9);", "put_buffer(pb, swf->frame_tail->data, swf->frame_tail->VAR_3);", "put_swf_end_tag(VAR_0);", "put_swf_tag(VAR_0, TAG_PLACEOBJECT);", "put_le16(pb, SHAPE_ID);", "put_le16(pb, 1);", "put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);", "put_swf_end_tag(VAR_0);", "} else {", "}", "av_free(swf->frame_tail->data);", "swf->frame_tail = swf->frame_tail->prev;", "if ( swf->frame_tail ) {", "if ( swf->frame_tail->next ) {", "av_free(swf->frame_tail->next);", "}", "swf->frame_tail->next = 0;", "} else {", "swf->frame_head = 0;", "}", "swf->swf_frame_number ++;", "}", "}", "swf->video_samples += swf->samples_per_frame;", "if ( VAR_5 > 0 ) {", "put_swf_tag(VAR_0, TAG_STREAMBLOCK | TAG_LONG);", "put_le16(pb, VAR_6);", "put_le16(pb, 0);", "for (VAR_4=0; VAR_4<VAR_5; VAR_4++) {", "put_byte(pb,swf->audio_fifo[(swf->audio_in_pos+VAR_4) % AUDIO_FIFO_SIZE]);", "}", "put_swf_end_tag(VAR_0);", "swf->sound_samples += VAR_6;", "swf->audio_in_pos += VAR_5;", "swf->audio_size -= VAR_5;", "swf->audio_in_pos %= AUDIO_FIFO_SIZE;", "}", "put_swf_tag(VAR_0, TAG_SHOWFRAME);", "put_swf_end_tag(VAR_0);", "put_flush_packet(&VAR_0->pb);", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 21 ], [ 23 ], [ 25 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 127 ], [ 129 ], [ 131 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 151 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 229 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247 ], [ 249 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 275 ], [ 279 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 295 ], [ 299 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 321 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 353 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 393 ], [ 395 ], [ 399 ], [ 403 ], [ 405 ] ]

[ "static int FUNC_0(AVCodecParserContext *VAR_0, const uint8_t *VAR_1,\nint VAR_2, AVCodecContext *VAR_3)\n{", "HEVCParserContext *ctx = VAR_0->priv_data;", "int VAR_4, VAR_5;", "VAR_4 = ff_h2645_packet_split(&ctx->pkt, VAR_1, VAR_2, VAR_3, 0, 0,\nAV_CODEC_ID_HEVC);", "if (VAR_4 < 0)\nreturn VAR_4;", "for (VAR_5 = 0; VAR_5 < ctx->pkt.nb_nals; VAR_5++) {", "H2645NAL *nal = &ctx->pkt.nals[VAR_5];", "switch (nal->type) {", "case NAL_VPS: ff_hevc_decode_nal_vps(&nal->gb, VAR_3, &ctx->ps); break;", "case NAL_SPS: ff_hevc_decode_nal_sps(&nal->gb, VAR_3, &ctx->ps, 1); break;", "case NAL_PPS: ff_hevc_decode_nal_pps(&nal->gb, VAR_3, &ctx->ps); break;", "case NAL_TRAIL_R:\ncase NAL_TRAIL_N:\ncase NAL_TSA_N:\ncase NAL_TSA_R:\ncase NAL_STSA_N:\ncase NAL_STSA_R:\ncase NAL_BLA_W_LP:\ncase NAL_BLA_W_RADL:\ncase NAL_BLA_N_LP:\ncase NAL_IDR_W_RADL:\ncase NAL_IDR_N_LP:\ncase NAL_CRA_NUT:\ncase NAL_RADL_N:\ncase NAL_RADL_R:\ncase NAL_RASL_N:\ncase NAL_RASL_R:\nif (VAR_1 == VAR_3->extradata) {", "av_log(VAR_3, AV_LOG_ERROR, \"Invalid NAL unit: %d\\n\", nal->type);", "return AVERROR_INVALIDDATA;", "}", "hevc_parse_slice_header(VAR_0, nal, VAR_3);", "break;", "}", "}", "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 ], [ 13, 15 ], [ 17, 19 ], [ 23 ], [ 25 ], [ 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 ], [ 89 ], [ 91 ] ]

[ "static int FUNC_0(char **VAR_0, int *VAR_1, char VAR_2, int VAR_3)\n{", "char *VAR_4 = split(*VAR_0, VAR_2);", "int VAR_5;", "int VAR_6 = 0;", "if (!VAR_4 && VAR_2 == '-')\nreturn AVERROR(EINVAL);", "if (!*VAR_0)\nreturn AVERROR(EINVAL);", "VAR_5 = strlen(*VAR_0);", "sscanf(*VAR_0, \"%d%VAR_6\", VAR_1, &VAR_6);", "if (VAR_6 != VAR_5)\nreturn AVERROR(EINVAL);", "if (*VAR_1 < 0 || *VAR_1 > VAR_3)\nreturn AVERROR(EINVAL);", "*VAR_0 = VAR_4;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVSContext *VAR_0, GetBitContext *VAR_1,\nconst struct dec_2dvlc *VAR_2, int VAR_3,\nint VAR_4, uint8_t *VAR_5, int VAR_6) {", "int VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;", "DCTELEM level_buf[65];", "uint8_t run_buf[65];", "DCTELEM *block = VAR_0->block;", "for(VAR_7=0;VAR_7<65;VAR_7++) {", "VAR_8 = get_ue_code(VAR_1,VAR_2->golomb_order);", "if(VAR_8 >= ESCAPE_CODE) {", "VAR_11 = ((VAR_8 - ESCAPE_CODE) >> 1) + 1;", "VAR_9 = get_ue_code(VAR_1,VAR_3);", "VAR_10 = VAR_9 + (VAR_11 > VAR_2->max_run ? 1 : VAR_2->level_add[VAR_11]);", "while(VAR_10 > VAR_2->inc_limit)\nVAR_2++;", "VAR_12 = -(VAR_8 & 1);", "VAR_10 = (VAR_10^VAR_12) - VAR_12;", "} else {", "VAR_10 = VAR_2->rltab[VAR_8][0];", "if(!VAR_10)\nbreak;", "VAR_11 = VAR_2->rltab[VAR_8][1];", "VAR_2 += VAR_2->rltab[VAR_8][2];", "}", "level_buf[VAR_7] = VAR_10;", "run_buf[VAR_7] = VAR_11;", "}", "if(dequant(VAR_0,level_buf, run_buf, block, ff_cavs_dequant_mul[VAR_4],\nff_cavs_dequant_shift[VAR_4], VAR_7))\nreturn -1;", "VAR_0->cdsp.cavs_idct8_add(VAR_5,block,VAR_6);", "VAR_0->s.dsp.clear_block(block);", "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 ], [ 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 ] ]

[ "static void FUNC_0(Object *VAR_0, bool VAR_1, Error **VAR_2)\n{", "DeviceState *dev = DEVICE(VAR_0);", "dev->hotplugged = VAR_1;", "}" ]

[ 1, 1, 1, 0 ]

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

[ "static void FUNC_0(MachineState *VAR_0)\n{", "ram_addr_t ram_size = VAR_0->ram_size;", "const char *VAR_1 = VAR_0->VAR_1;", "const char *VAR_2 = VAR_0->VAR_2;", "const char *VAR_3 = VAR_0->VAR_3;", "const char *VAR_4 = VAR_0->VAR_4;", "char *VAR_5;", "MemoryRegion *address_space_mem = get_system_memory();", "MemoryRegion *ram = g_new(MemoryRegion, 1);", "MemoryRegion *bios = g_new(MemoryRegion, 1);", "long VAR_6;", "int64_t kernel_entry;", "qemu_irq *i8259;", "qemu_irq *cpu_exit_irq;", "PCIBus *pci_bus;", "ISABus *isa_bus;", "I2CBus *smbus;", "int VAR_7;", "DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];", "MIPSCPU *cpu;", "CPUMIPSState *env;", "if (VAR_1 == NULL) {", "VAR_1 = \"Loongson-2E\";", "}", "cpu = cpu_mips_init(VAR_1);", "if (cpu == NULL) {", "fprintf(stderr, \"Unable to find CPU definition\\n\");", "exit(1);", "}", "env = &cpu->env;", "qemu_register_reset(main_cpu_reset, cpu);", "ram_size = 256 * 1024 * 1024;", "VAR_6 = 1024 * 1024;", "memory_region_init_ram(ram, NULL, \"fulong2e.ram\", ram_size, &error_abort);", "vmstate_register_ram_global(ram);", "memory_region_init_ram(bios, NULL, \"fulong2e.bios\", VAR_6,\n&error_abort);", "vmstate_register_ram_global(bios);", "memory_region_set_readonly(bios, true);", "memory_region_add_subregion(address_space_mem, 0, ram);", "memory_region_add_subregion(address_space_mem, 0x1fc00000LL, bios);", "if (VAR_2) {", "loaderparams.ram_size = ram_size;", "loaderparams.VAR_2 = VAR_2;", "loaderparams.VAR_3 = VAR_3;", "loaderparams.VAR_4 = VAR_4;", "kernel_entry = load_kernel (env);", "write_bootloader(env, memory_region_get_ram_ptr(bios), kernel_entry);", "} else {", "if (bios_name == NULL) {", "bios_name = FULONG_BIOSNAME;", "}", "VAR_5 = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);", "if (VAR_5) {", "VAR_6 = load_image_targphys(VAR_5, 0x1fc00000LL,\nBIOS_SIZE);", "g_free(VAR_5);", "} else {", "VAR_6 = -1;", "}", "if ((VAR_6 < 0 || VAR_6 > BIOS_SIZE) &&\n!VAR_2 && !qtest_enabled()) {", "error_report(\"Could not load MIPS bios '%s'\", bios_name);", "exit(1);", "}", "}", "cpu_mips_irq_init_cpu(env);", "cpu_mips_clock_init(env);", "pci_bus = bonito_init((qemu_irq *)&(env->irq[2]));", "ide_drive_get(hd, MAX_IDE_BUS);", "isa_bus = vt82c686b_init(pci_bus, PCI_DEVFN(FULONG2E_VIA_SLOT, 0));", "if (!isa_bus) {", "fprintf(stderr, \"vt82c686b_init error\\n\");", "exit(1);", "}", "i8259 = i8259_init(isa_bus, env->irq[5]);", "isa_bus_irqs(isa_bus, i8259);", "vt82c686b_ide_init(pci_bus, hd, PCI_DEVFN(FULONG2E_VIA_SLOT, 1));", "pci_create_simple(pci_bus, PCI_DEVFN(FULONG2E_VIA_SLOT, 2),\n\"vt82c686b-usb-uhci\");", "pci_create_simple(pci_bus, PCI_DEVFN(FULONG2E_VIA_SLOT, 3),\n\"vt82c686b-usb-uhci\");", "smbus = vt82c686b_pm_init(pci_bus, PCI_DEVFN(FULONG2E_VIA_SLOT, 4),\n0xeee1, NULL);", "smbus_eeprom_init(smbus, 1, eeprom_spd, sizeof(eeprom_spd));", "pit = pit_init(isa_bus, 0x40, 0, NULL);", "cpu_exit_irq = qemu_allocate_irqs(cpu_request_exit, NULL, 1);", "DMA_init(0, cpu_exit_irq);", "isa_create_simple(isa_bus, \"i8042\");", "rtc_init(isa_bus, 2000, NULL);", "for(VAR_7 = 0; VAR_7 < MAX_SERIAL_PORTS; VAR_7++) {", "if (serial_hds[VAR_7]) {", "serial_isa_init(isa_bus, VAR_7, serial_hds[VAR_7]);", "}", "}", "if (parallel_hds[0]) {", "parallel_init(isa_bus, 0, parallel_hds[0]);", "}", "audio_init(pci_bus);", "network_init(pci_bus);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 75 ], [ 81 ], [ 87 ], [ 89 ], [ 91, 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 169 ], [ 171 ], [ 177 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 203 ], [ 205 ], [ 209 ], [ 211, 213 ], [ 215, 217 ], [ 221, 223 ], [ 227 ], [ 233 ], [ 235 ], [ 237 ], [ 243 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ], [ 267 ], [ 273 ], [ 277 ], [ 279 ] ]