Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static BlockDriverAIOCB *FUNC_0(BlockDriverState *bs,\nint64_t sector_num, QEMUIOVector *qiov, int nb_sectors,\nBlockDriverCompletionFunc *cb, void *opaque)\n{", "QCowAIOCB *acb;", "acb = qemu_aio_get(bs, cb, opaque);", "if (!acb)\nreturn NULL;", "acb->hd_aiocb = NULL;", "acb->sector_num = sector_num;", "acb->qiov = qiov;", "if (qiov->niov > 1)\nacb->buf = acb->orig_buf = qemu_memalign(512, qiov->size);", "else\nacb->buf = (uint8_t *)qiov->iov->iov_base;", "acb->nb_sectors = nb_sectors;", "acb->n = 0;", "acb->cluster_offset = 0;", "qcow_aio_read_cb(acb, 0);", "return &acb->common;", "}" ]

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

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

[ "void FUNC_0(void *VAR_0, int VAR_1)\n{", "NVICState *s = (NVICState *)VAR_0;", "VecInfo *vec;", "assert(VAR_1 > ARMV7M_EXCP_RESET && VAR_1 < s->num_irq);", "vec = &s->vectors[VAR_1];", "trace_nvic_set_pending(VAR_1, vec->enabled, vec->prio);", "if (VAR_1 >= ARMV7M_EXCP_HARD && VAR_1 < ARMV7M_EXCP_PENDSV) {", "int VAR_2 = nvic_exec_prio(s);", "bool escalate = false;", "if (vec->prio >= VAR_2) {", "trace_nvic_escalate_prio(VAR_1, vec->prio, VAR_2);", "escalate = true;", "} else if (!vec->enabled) {", "trace_nvic_escalate_disabled(VAR_1);", "escalate = true;", "}", "if (escalate) {", "if (VAR_2 < 0) {", "cpu_abort(&s->cpu->parent_obj,\n\"Lockup: can't escalate %d to HardFault \"\n\"(current priority %d)\\n\", VAR_1, VAR_2);", "}", "VAR_1 = ARMV7M_EXCP_HARD;", "vec = &s->vectors[VAR_1];", "s->cpu->env.v7m.hfsr |= R_V7M_HFSR_FORCED_MASK;", "}", "}", "if (!vec->pending) {", "vec->pending = 1;", "nvic_irq_update(s);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 23 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 101, 103, 105 ], [ 107 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ] ]

[ "static void FUNC_0(target_phys_addr_t VAR_0,\nuint32_t VAR_1[8], uint16_t VAR_2[6], uint16_t VAR_3)\n{", "uint8_t rom[512], *p, *reloc;", "uint8_t sum;", "int VAR_4;", "memset(rom, 0, sizeof(rom));", "p = rom;", "*p++ = 0x55;", "*p++ = 0xaa;", "*p++ = 1;", "*p++ = 0x50;", "*p++ = 0x1e;", "*p++ = 0x31; *p++ = 0xc0;", "*p++ = 0x8e; *p++ = 0xd8;", "*p++ = 0xc7; *p++ = 0x06;", "*p++ = 0x64; *p++ = 0x00;", "reloc = p;", "*p++ = 0x00; *p++ = 0x00;", "*p++ = 0x8c; *p++ = 0x0e;", "*p++ = 0x66; *p++ = 0x00;", "*p++ = 0x1f;", "*p++ = 0x58;", "*p++ = 0xcb;", "*reloc = (p - rom);", "*p++ = 0xfa;", "*p++ = 0xfc;", "for (VAR_4 = 0; VAR_4 < 6; VAR_4++) {", "if (VAR_4 == 1)\ncontinue;", "*p++ = 0xb8;", "*p++ = VAR_2[VAR_4];", "*p++ = VAR_2[VAR_4] >> 8;", "*p++ = 0x8e;", "*p++ = 0xc0 + (VAR_4 << 3);", "}", "for (VAR_4 = 0; VAR_4 < 8; VAR_4++) {", "*p++ = 0x66;", "*p++ = 0xb8 + VAR_4;", "*p++ = VAR_1[VAR_4];", "*p++ = VAR_1[VAR_4] >> 8;", "*p++ = VAR_1[VAR_4] >> 16;", "*p++ = VAR_1[VAR_4] >> 24;", "}", "*p++ = 0xea;", "*p++ = VAR_3;", "*p++ = VAR_3 >> 8;", "*p++ = VAR_2[1];", "*p++ = VAR_2[1] >> 8;", "sum = 0;", "for (VAR_4 = 0; VAR_4 < (sizeof(rom) - 1); VAR_4++)", "sum += rom[VAR_4];", "rom[sizeof(rom) - 1] = -sum;", "cpu_physical_memory_write_rom(VAR_0, rom, sizeof(rom));", "option_rom_setup_reset(VAR_0, sizeof (rom));", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 31 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 75 ], [ 79 ], [ 81 ], [ 85 ], [ 87, 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1) {", "ByteIOContext *pb = VAR_0->pb;", "pkt_type_t pkt_type;", "int VAR_2;", "while (!url_feof(pb)) {", "int VAR_3, VAR_4, VAR_5;", "int VAR_6;", "int VAR_7;", "if (!parse_packet_header(pb, &pkt_type, &VAR_2)) {", "if (!url_feof(pb))\nav_log(VAR_0, AV_LOG_ERROR, \"GXF: sync lost\\n\");", "return -1;", "}", "if (pkt_type == PKT_FLT) {", "gxf_read_index(VAR_0, VAR_2);", "continue;", "}", "if (pkt_type != PKT_MEDIA) {", "url_fskip(pb, VAR_2);", "continue;", "}", "if (VAR_2 < 16) {", "av_log(VAR_0, AV_LOG_ERROR, \"GXF: invalid media packet length\\n\");", "continue;", "}", "VAR_2 -= 16;", "VAR_3 = get_byte(pb);", "VAR_4 = get_byte(pb);", "VAR_7 = get_sindex(VAR_0, VAR_4, VAR_3);", "if (VAR_7 < 0)\nreturn VAR_7;", "VAR_6 = get_be32(pb);", "get_be32(pb);", "get_be32(pb);", "get_byte(pb);", "get_byte(pb);", ", it might be better to take this into account\nVAR_5 = av_get_packet(pb, VAR_1, VAR_2);", "VAR_1->VAR_7 = VAR_7;", "VAR_1->dts = VAR_6;", "return VAR_5;", "}", "return AVERROR(EIO);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 75, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ] ]

[ "static int FUNC_0(USBDevice *VAR_0, USBPacket *VAR_1)\n{", "USBHIDState *us = DO_UPCAST(USBHIDState, VAR_0, VAR_0);", "HIDState *hs = &us->hid;", "uint8_t buf[VAR_1->iov.size];", "int VAR_2 = 0;", "switch (VAR_1->pid) {", "case USB_TOKEN_IN:\nif (VAR_1->devep == 1) {", "int64_t curtime = qemu_get_clock_ns(vm_clock);", "if (!us->changed &&\n(!us->idle || us->next_idle_clock - curtime > 0)) {", "return USB_RET_NAK;", "}", "usb_hid_set_next_idle(us, curtime);", "if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {", "VAR_2 = hid_pointer_poll(hs, buf, VAR_1->iov.size);", "} else if (hs->kind == HID_KEYBOARD) {", "VAR_2 = hid_keyboard_poll(hs, buf, VAR_1->iov.size);", "}", "usb_packet_copy(VAR_1, buf, VAR_2);", "us->changed = hs->n > 0;", "} else {", "goto fail;", "}", "break;", "case USB_TOKEN_OUT:\ndefault:\nfail:\nVAR_2 = USB_RET_STALL;", "break;", "}", "return VAR_2;", "}" ]

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

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

[ "tcg_target_ulong FUNC_0(CPUArchState *cpustate, uint8_t *tb_ptr)\n{", "tcg_target_ulong next_tb = 0;", "env = cpustate;", "tci_reg[TCG_AREG0] = (tcg_target_ulong)env;", "assert(tb_ptr);", "for (;;) {", "#if defined(GETPC)\ntci_tb_ptr = (uintptr_t)tb_ptr;", "#endif\nTCGOpcode opc = tb_ptr[0];", "#if !defined(NDEBUG)\nuint8_t op_size = tb_ptr[1];", "uint8_t *old_code_ptr = tb_ptr;", "#endif\ntcg_target_ulong t0;", "tcg_target_ulong t1;", "tcg_target_ulong t2;", "tcg_target_ulong label;", "TCGCond condition;", "target_ulong taddr;", "#ifndef CONFIG_SOFTMMU\ntcg_target_ulong host_addr;", "#endif\nuint8_t tmp8;", "uint16_t tmp16;", "uint32_t tmp32;", "uint64_t tmp64;", "#if TCG_TARGET_REG_BITS == 32\nuint64_t v64;", "#endif\ntb_ptr += 2;", "switch (opc) {", "case INDEX_op_end:\ncase INDEX_op_nop:\nbreak;", "case INDEX_op_nop1:\ncase INDEX_op_nop2:\ncase INDEX_op_nop3:\ncase INDEX_op_nopn:\ncase INDEX_op_discard:\nTODO();", "break;", "case INDEX_op_set_label:\nTODO();", "break;", "case INDEX_op_call:\nt0 = tci_read_ri(&tb_ptr);", "#if TCG_TARGET_REG_BITS == 32\ntmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),\ntci_read_reg(TCG_REG_R1),\ntci_read_reg(TCG_REG_R2),\ntci_read_reg(TCG_REG_R3),\ntci_read_reg(TCG_REG_R5),\ntci_read_reg(TCG_REG_R6),\ntci_read_reg(TCG_REG_R7),\ntci_read_reg(TCG_REG_R8),\ntci_read_reg(TCG_REG_R9),\ntci_read_reg(TCG_REG_R10));", "tci_write_reg(TCG_REG_R0, tmp64);", "tci_write_reg(TCG_REG_R1, tmp64 >> 32);", "#else\ntmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),\ntci_read_reg(TCG_REG_R1),\ntci_read_reg(TCG_REG_R2),\ntci_read_reg(TCG_REG_R3),\ntci_read_reg(TCG_REG_R5));", "tci_write_reg(TCG_REG_R0, tmp64);", "#endif\nbreak;", "case INDEX_op_br:\nlabel = tci_read_label(&tb_ptr);", "assert(tb_ptr == old_code_ptr + op_size);", "tb_ptr = (uint8_t *)label;", "continue;", "case INDEX_op_setcond_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "condition = *tb_ptr++;", "tci_write_reg32(t0, tci_compare32(t1, t2, condition));", "break;", "#if TCG_TARGET_REG_BITS == 32\ncase INDEX_op_setcond2_i32:\nt0 = *tb_ptr++;", "tmp64 = tci_read_r64(&tb_ptr);", "v64 = tci_read_ri64(&tb_ptr);", "condition = *tb_ptr++;", "tci_write_reg32(t0, tci_compare64(tmp64, v64, condition));", "break;", "#elif TCG_TARGET_REG_BITS == 64\ncase INDEX_op_setcond_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "condition = *tb_ptr++;", "tci_write_reg64(t0, tci_compare64(t1, t2, condition));", "break;", "#endif\ncase INDEX_op_mov_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "tci_write_reg32(t0, t1);", "break;", "case INDEX_op_movi_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_i32(&tb_ptr);", "tci_write_reg32(t0, t1);", "break;", "case INDEX_op_ld8u_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "tci_write_reg8(t0, *(uint8_t *)(t1 + t2));", "break;", "case INDEX_op_ld8s_i32:\ncase INDEX_op_ld16u_i32:\nTODO();", "break;", "case INDEX_op_ld16s_i32:\nTODO();", "break;", "case INDEX_op_ld_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "tci_write_reg32(t0, *(uint32_t *)(t1 + t2));", "break;", "case INDEX_op_st8_i32:\nt0 = tci_read_r8(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint8_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_st16_i32:\nt0 = tci_read_r16(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint16_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_st_i32:\nt0 = tci_read_r32(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint32_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_add_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 + t2);", "break;", "case INDEX_op_sub_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 - t2);", "break;", "case INDEX_op_mul_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 * t2);", "break;", "#if TCG_TARGET_HAS_div_i32\ncase INDEX_op_div_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, (int32_t)t1 / (int32_t)t2);", "break;", "case INDEX_op_divu_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 / t2);", "break;", "case INDEX_op_rem_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, (int32_t)t1 % (int32_t)t2);", "break;", "case INDEX_op_remu_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 % t2);", "break;", "#elif TCG_TARGET_HAS_div2_i32\ncase INDEX_op_div2_i32:\ncase INDEX_op_divu2_i32:\nTODO();", "break;", "#endif\ncase INDEX_op_and_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 & t2);", "break;", "case INDEX_op_or_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 | t2);", "break;", "case INDEX_op_xor_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 ^ t2);", "break;", "case INDEX_op_shl_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 << t2);", "break;", "case INDEX_op_shr_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, t1 >> t2);", "break;", "case INDEX_op_sar_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, ((int32_t)t1 >> t2));", "break;", "#if TCG_TARGET_HAS_rot_i32\ncase INDEX_op_rotl_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, (t1 << t2) | (t1 >> (32 - t2)));", "break;", "case INDEX_op_rotr_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_ri32(&tb_ptr);", "t2 = tci_read_ri32(&tb_ptr);", "tci_write_reg32(t0, (t1 >> t2) | (t1 << (32 - t2)));", "break;", "#endif\n#if TCG_TARGET_HAS_deposit_i32\ncase INDEX_op_deposit_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "t2 = tci_read_r32(&tb_ptr);", "tmp16 = *tb_ptr++;", "tmp8 = *tb_ptr++;", "tmp32 = (((1 << tmp8) - 1) << tmp16);", "tci_write_reg32(t0, (t1 & ~tmp32) | ((t2 << tmp16) & tmp32));", "break;", "#endif\ncase INDEX_op_brcond_i32:\nt0 = tci_read_r32(&tb_ptr);", "t1 = tci_read_ri32(&tb_ptr);", "condition = *tb_ptr++;", "label = tci_read_label(&tb_ptr);", "if (tci_compare32(t0, t1, condition)) {", "assert(tb_ptr == old_code_ptr + op_size);", "tb_ptr = (uint8_t *)label;", "continue;", "}", "break;", "#if TCG_TARGET_REG_BITS == 32\ncase INDEX_op_add2_i32:\nt0 = *tb_ptr++;", "t1 = *tb_ptr++;", "tmp64 = tci_read_r64(&tb_ptr);", "tmp64 += tci_read_r64(&tb_ptr);", "tci_write_reg64(t1, t0, tmp64);", "break;", "case INDEX_op_sub2_i32:\nt0 = *tb_ptr++;", "t1 = *tb_ptr++;", "tmp64 = tci_read_r64(&tb_ptr);", "tmp64 -= tci_read_r64(&tb_ptr);", "tci_write_reg64(t1, t0, tmp64);", "break;", "case INDEX_op_brcond2_i32:\ntmp64 = tci_read_r64(&tb_ptr);", "v64 = tci_read_ri64(&tb_ptr);", "condition = *tb_ptr++;", "label = tci_read_label(&tb_ptr);", "if (tci_compare64(tmp64, v64, condition)) {", "assert(tb_ptr == old_code_ptr + op_size);", "tb_ptr = (uint8_t *)label;", "continue;", "}", "break;", "case INDEX_op_mulu2_i32:\nt0 = *tb_ptr++;", "t1 = *tb_ptr++;", "t2 = tci_read_r32(&tb_ptr);", "tmp64 = tci_read_r32(&tb_ptr);", "tci_write_reg64(t1, t0, t2 * tmp64);", "break;", "#endif\n#if TCG_TARGET_HAS_ext8s_i32\ncase INDEX_op_ext8s_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r8s(&tb_ptr);", "tci_write_reg32(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext16s_i32\ncase INDEX_op_ext16s_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r16s(&tb_ptr);", "tci_write_reg32(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext8u_i32\ncase INDEX_op_ext8u_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r8(&tb_ptr);", "tci_write_reg32(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext16u_i32\ncase INDEX_op_ext16u_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r16(&tb_ptr);", "tci_write_reg32(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_bswap16_i32\ncase INDEX_op_bswap16_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r16(&tb_ptr);", "tci_write_reg32(t0, bswap16(t1));", "break;", "#endif\n#if TCG_TARGET_HAS_bswap32_i32\ncase INDEX_op_bswap32_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "tci_write_reg32(t0, bswap32(t1));", "break;", "#endif\n#if TCG_TARGET_HAS_not_i32\ncase INDEX_op_not_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "tci_write_reg32(t0, ~t1);", "break;", "#endif\n#if TCG_TARGET_HAS_neg_i32\ncase INDEX_op_neg_i32:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "tci_write_reg32(t0, -t1);", "break;", "#endif\n#if TCG_TARGET_REG_BITS == 64\ncase INDEX_op_mov_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r64(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "case INDEX_op_movi_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_i64(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "case INDEX_op_ld8u_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "tci_write_reg8(t0, *(uint8_t *)(t1 + t2));", "break;", "case INDEX_op_ld8s_i64:\ncase INDEX_op_ld16u_i64:\ncase INDEX_op_ld16s_i64:\nTODO();", "break;", "case INDEX_op_ld32u_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "tci_write_reg32(t0, *(uint32_t *)(t1 + t2));", "break;", "case INDEX_op_ld32s_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "tci_write_reg32s(t0, *(int32_t *)(t1 + t2));", "break;", "case INDEX_op_ld_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "tci_write_reg64(t0, *(uint64_t *)(t1 + t2));", "break;", "case INDEX_op_st8_i64:\nt0 = tci_read_r8(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint8_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_st16_i64:\nt0 = tci_read_r16(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint16_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_st32_i64:\nt0 = tci_read_r32(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint32_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_st_i64:\nt0 = tci_read_r64(&tb_ptr);", "t1 = tci_read_r(&tb_ptr);", "t2 = tci_read_i32(&tb_ptr);", "*(uint64_t *)(t1 + t2) = t0;", "break;", "case INDEX_op_add_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 + t2);", "break;", "case INDEX_op_sub_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 - t2);", "break;", "case INDEX_op_mul_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 * t2);", "break;", "#if TCG_TARGET_HAS_div_i64\ncase INDEX_op_div_i64:\ncase INDEX_op_divu_i64:\ncase INDEX_op_rem_i64:\ncase INDEX_op_remu_i64:\nTODO();", "break;", "#elif TCG_TARGET_HAS_div2_i64\ncase INDEX_op_div2_i64:\ncase INDEX_op_divu2_i64:\nTODO();", "break;", "#endif\ncase INDEX_op_and_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 & t2);", "break;", "case INDEX_op_or_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 | t2);", "break;", "case INDEX_op_xor_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 ^ t2);", "break;", "case INDEX_op_shl_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 << t2);", "break;", "case INDEX_op_shr_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, t1 >> t2);", "break;", "case INDEX_op_sar_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_ri64(&tb_ptr);", "t2 = tci_read_ri64(&tb_ptr);", "tci_write_reg64(t0, ((int64_t)t1 >> t2));", "break;", "#if TCG_TARGET_HAS_rot_i64\ncase INDEX_op_rotl_i64:\ncase INDEX_op_rotr_i64:\nTODO();", "break;", "#endif\n#if TCG_TARGET_HAS_deposit_i64\ncase INDEX_op_deposit_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r64(&tb_ptr);", "t2 = tci_read_r64(&tb_ptr);", "tmp16 = *tb_ptr++;", "tmp8 = *tb_ptr++;", "tmp64 = (((1ULL << tmp8) - 1) << tmp16);", "tci_write_reg64(t0, (t1 & ~tmp64) | ((t2 << tmp16) & tmp64));", "break;", "#endif\ncase INDEX_op_brcond_i64:\nt0 = tci_read_r64(&tb_ptr);", "t1 = tci_read_ri64(&tb_ptr);", "condition = *tb_ptr++;", "label = tci_read_label(&tb_ptr);", "if (tci_compare64(t0, t1, condition)) {", "assert(tb_ptr == old_code_ptr + op_size);", "tb_ptr = (uint8_t *)label;", "continue;", "}", "break;", "#if TCG_TARGET_HAS_ext8u_i64\ncase INDEX_op_ext8u_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r8(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext8s_i64\ncase INDEX_op_ext8s_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r8s(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext16s_i64\ncase INDEX_op_ext16s_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r16s(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext16u_i64\ncase INDEX_op_ext16u_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r16(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext32s_i64\ncase INDEX_op_ext32s_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r32s(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_ext32u_i64\ncase INDEX_op_ext32u_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "tci_write_reg64(t0, t1);", "break;", "#endif\n#if TCG_TARGET_HAS_bswap16_i64\ncase INDEX_op_bswap16_i64:\nTODO();", "t0 = *tb_ptr++;", "t1 = tci_read_r16(&tb_ptr);", "tci_write_reg64(t0, bswap16(t1));", "break;", "#endif\n#if TCG_TARGET_HAS_bswap32_i64\ncase INDEX_op_bswap32_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r32(&tb_ptr);", "tci_write_reg64(t0, bswap32(t1));", "break;", "#endif\n#if TCG_TARGET_HAS_bswap64_i64\ncase INDEX_op_bswap64_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r64(&tb_ptr);", "tci_write_reg64(t0, bswap64(t1));", "break;", "#endif\n#if TCG_TARGET_HAS_not_i64\ncase INDEX_op_not_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r64(&tb_ptr);", "tci_write_reg64(t0, ~t1);", "break;", "#endif\n#if TCG_TARGET_HAS_neg_i64\ncase INDEX_op_neg_i64:\nt0 = *tb_ptr++;", "t1 = tci_read_r64(&tb_ptr);", "tci_write_reg64(t0, -t1);", "break;", "#endif\n#endif\n#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS\ncase INDEX_op_debug_insn_start:\nTODO();", "break;", "#else\ncase INDEX_op_debug_insn_start:\nTODO();", "break;", "#endif\ncase INDEX_op_exit_tb:\nnext_tb = *(uint64_t *)tb_ptr;", "goto exit;", "break;", "case INDEX_op_goto_tb:\nt0 = tci_read_i32(&tb_ptr);", "assert(tb_ptr == old_code_ptr + op_size);", "tb_ptr += (int32_t)t0;", "continue;", "case INDEX_op_qemu_ld8u:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);", "#endif\ntci_write_reg8(t0, tmp8);", "break;", "case INDEX_op_qemu_ld8s:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);", "#endif\ntci_write_reg8s(t0, tmp8);", "break;", "case INDEX_op_qemu_ld16u:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));", "#endif\ntci_write_reg16(t0, tmp16);", "break;", "case INDEX_op_qemu_ld16s:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));", "#endif\ntci_write_reg16s(t0, tmp16);", "break;", "#if TCG_TARGET_REG_BITS == 64\ncase INDEX_op_qemu_ld32u:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));", "#endif\ntci_write_reg32(t0, tmp32);", "break;", "case INDEX_op_qemu_ld32s:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));", "#endif\ntci_write_reg32s(t0, tmp32);", "break;", "#endif\ncase INDEX_op_qemu_ld32:\nt0 = *tb_ptr++;", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));", "#endif\ntci_write_reg32(t0, tmp32);", "break;", "case INDEX_op_qemu_ld64:\nt0 = *tb_ptr++;", "#if TCG_TARGET_REG_BITS == 32\nt1 = *tb_ptr++;", "#endif\ntaddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\ntmp64 = helper_ldq_mmu(env, taddr, tci_read_i(&tb_ptr));", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "tmp64 = tswap64(*(uint64_t *)(host_addr + GUEST_BASE));", "#endif\ntci_write_reg(t0, tmp64);", "#if TCG_TARGET_REG_BITS == 32\ntci_write_reg(t1, tmp64 >> 32);", "#endif\nbreak;", "case INDEX_op_qemu_st8:\nt0 = tci_read_r8(&tb_ptr);", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\nt2 = tci_read_i(&tb_ptr);", "helper_stb_mmu(env, taddr, t0, t2);", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "*(uint8_t *)(host_addr + GUEST_BASE) = t0;", "#endif\nbreak;", "case INDEX_op_qemu_st16:\nt0 = tci_read_r16(&tb_ptr);", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\nt2 = tci_read_i(&tb_ptr);", "helper_stw_mmu(env, taddr, t0, t2);", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "*(uint16_t *)(host_addr + GUEST_BASE) = tswap16(t0);", "#endif\nbreak;", "case INDEX_op_qemu_st32:\nt0 = tci_read_r32(&tb_ptr);", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\nt2 = tci_read_i(&tb_ptr);", "helper_stl_mmu(env, taddr, t0, t2);", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "*(uint32_t *)(host_addr + GUEST_BASE) = tswap32(t0);", "#endif\nbreak;", "case INDEX_op_qemu_st64:\ntmp64 = tci_read_r64(&tb_ptr);", "taddr = tci_read_ulong(&tb_ptr);", "#ifdef CONFIG_SOFTMMU\nt2 = tci_read_i(&tb_ptr);", "helper_stq_mmu(env, taddr, tmp64, t2);", "#else\nhost_addr = (tcg_target_ulong)taddr;", "assert(taddr == host_addr);", "*(uint64_t *)(host_addr + GUEST_BASE) = tswap64(tmp64);", "#endif\nbreak;", "default:\nTODO();", "break;", "}", "assert(tb_ptr == old_code_ptr + op_size);", "}", "exit:\nreturn next_tb;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 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, 71 ], [ 75 ], [ 77, 79, 81 ], [ 83, 85, 87, 89, 91, 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 103, 105 ], [ 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127 ], [ 129 ], [ 131 ], [ 133, 135, 137, 139, 141, 143 ], [ 145 ], [ 147, 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177, 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191, 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207, 209, 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219, 221 ], [ 223 ], [ 225 ], [ 227 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247, 249, 251 ], [ 253 ], [ 255, 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273, 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285, 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297, 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 315, 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327, 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339, 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351, 353, 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365, 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377, 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389, 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401, 403, 405, 407 ], [ 409 ], [ 411, 413, 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425, 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437, 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 455, 457 ], [ 459 ], [ 461 ], [ 463 ], [ 465 ], [ 467, 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 479, 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491, 493, 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505, 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517, 519, 521, 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539, 541, 543 ], [ 545 ], [ 547 ], [ 549 ], [ 551 ], [ 553 ], [ 555 ], [ 557 ], [ 559 ], [ 561 ], [ 563, 565, 567 ], [ 569 ], [ 571 ], [ 573 ], [ 575 ], [ 577 ], [ 579, 581 ], [ 583 ], [ 585 ], [ 587 ], [ 589 ], [ 591 ], [ 593, 595 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 613 ], [ 615, 617 ], [ 619 ], [ 621 ], [ 623 ], [ 625 ], [ 627 ], [ 629, 631, 633, 635 ], [ 637 ], [ 639 ], [ 641 ], [ 643, 645, 647, 649 ], [ 651 ], [ 653 ], [ 655 ], [ 657, 659, 661, 663 ], [ 665 ], [ 667 ], [ 669 ], [ 671, 673, 675, 677 ], [ 679 ], [ 681 ], [ 683 ], [ 685, 687, 689, 691 ], [ 693 ], [ 695 ], [ 697 ], [ 699, 701, 703, 705 ], [ 707 ], [ 709 ], [ 711 ], [ 713, 715, 717, 719 ], [ 721 ], [ 723 ], [ 725 ], [ 727, 729, 731, 733 ], [ 735 ], [ 737 ], [ 739 ], [ 741, 743, 745, 747 ], [ 749 ], [ 751 ], [ 753 ], [ 755, 757 ], [ 759 ], [ 761 ], [ 763 ], [ 771, 773 ], [ 775 ], [ 777 ], [ 779 ], [ 781 ], [ 783, 785, 787, 789 ], [ 791 ], [ 793, 795 ], [ 797 ], [ 799 ], [ 801 ], [ 803 ], [ 805, 807 ], [ 809 ], [ 811 ], [ 813 ], [ 815 ], [ 817, 819 ], [ 821 ], [ 823 ], [ 825 ], [ 827 ], [ 829, 831 ], [ 833 ], [ 835 ], [ 837 ], [ 839 ], [ 841, 843 ], [ 845 ], [ 847 ], [ 849 ], [ 851 ], [ 853, 855 ], [ 857 ], [ 859 ], [ 861 ], [ 863 ], [ 865, 867 ], [ 869 ], [ 871 ], [ 873 ], [ 875 ], [ 883, 885 ], [ 887 ], [ 889 ], [ 891 ], [ 893 ], [ 895, 897 ], [ 899 ], [ 901 ], [ 903 ], [ 905 ], [ 907, 909 ], [ 911 ], [ 913 ], [ 915 ], [ 917 ], [ 919, 921, 923, 925, 927, 929 ], [ 931 ], [ 933, 935, 937, 939 ], [ 941 ], [ 943, 945, 947 ], [ 949 ], [ 951 ], [ 953 ], [ 955 ], [ 957, 959 ], [ 961 ], [ 963 ], [ 965 ], [ 967 ], [ 969, 971 ], [ 973 ], [ 975 ], [ 977 ], [ 979 ], [ 987, 989 ], [ 991 ], [ 993 ], [ 995 ], [ 997 ], [ 999, 1001 ], [ 1003 ], [ 1005 ], [ 1007 ], [ 1009 ], [ 1011, 1013 ], [ 1015 ], [ 1017 ], [ 1019 ], [ 1021 ], [ 1023, 1025, 1027, 1029 ], [ 1031 ], [ 1033, 1035, 1037, 1039 ], [ 1041 ], [ 1043 ], [ 1045 ], [ 1047 ], [ 1049 ], [ 1051 ], [ 1053 ], [ 1055, 1057, 1059 ], [ 1061 ], [ 1063 ], [ 1065 ], [ 1067 ], [ 1069 ], [ 1071 ], [ 1073 ], [ 1075 ], [ 1077 ], [ 1079, 1081, 1083 ], [ 1085 ], [ 1087 ], [ 1089 ], [ 1091, 1093, 1095, 1097 ], [ 1099 ], [ 1101 ], [ 1103 ], [ 1105, 1107, 1109, 1111 ], [ 1113 ], [ 1115 ], [ 1117 ], [ 1119, 1121, 1123, 1125 ], [ 1127 ], [ 1129 ], [ 1131 ], [ 1133, 1135, 1137, 1139 ], [ 1141 ], [ 1143 ], [ 1145 ], [ 1147, 1149, 1151, 1153 ], [ 1155 ], [ 1157 ], [ 1159 ], [ 1161, 1163, 1165, 1167 ], [ 1169 ], [ 1171 ], [ 1173 ], [ 1175 ], [ 1177, 1179, 1181, 1183 ], [ 1185 ], [ 1187 ], [ 1189 ], [ 1191, 1193, 1195, 1197 ], [ 1199 ], [ 1201 ], [ 1203 ], [ 1205, 1207, 1209, 1211 ], [ 1213 ], [ 1215 ], [ 1217 ], [ 1219, 1221, 1223, 1225 ], [ 1227 ], [ 1229 ], [ 1231 ], [ 1233, 1235, 1243, 1245, 1247 ], [ 1249 ], [ 1251, 1253, 1255 ], [ 1257 ], [ 1259, 1261, 1263 ], [ 1265 ], [ 1267 ], [ 1269, 1271 ], [ 1273 ], [ 1275 ], [ 1277 ], [ 1279, 1281 ], [ 1283 ], [ 1285, 1287 ], [ 1289, 1291 ], [ 1293 ], [ 1295 ], [ 1297, 1299 ], [ 1301 ], [ 1303, 1305 ], [ 1307 ], [ 1309, 1311 ], [ 1313, 1315 ], [ 1317 ], [ 1319 ], [ 1321, 1323 ], [ 1325 ], [ 1327, 1329 ], [ 1331 ], [ 1333, 1335 ], [ 1337, 1339 ], [ 1341 ], [ 1343 ], [ 1345, 1347 ], [ 1349 ], [ 1351, 1353 ], [ 1355 ], [ 1357, 1359 ], [ 1361, 1363 ], [ 1365 ], [ 1367 ], [ 1369, 1371 ], [ 1373 ], [ 1375, 1377, 1379 ], [ 1381 ], [ 1383, 1385 ], [ 1387, 1389 ], [ 1391 ], [ 1393 ], [ 1395, 1397 ], [ 1399 ], [ 1401, 1403 ], [ 1405 ], [ 1407, 1409 ], [ 1411, 1413 ], [ 1415 ], [ 1417 ], [ 1419, 1421 ], [ 1423 ], [ 1425, 1427, 1429 ], [ 1431 ], [ 1433, 1435 ], [ 1437, 1439 ], [ 1441 ], [ 1443 ], [ 1445, 1447 ], [ 1449 ], [ 1451, 1453 ], [ 1455, 1457 ], [ 1459, 1461 ], [ 1463, 1465 ], [ 1467, 1469 ], [ 1471 ], [ 1473 ], [ 1475, 1477 ], [ 1479, 1481 ], [ 1483, 1485 ], [ 1487, 1489 ], [ 1491 ], [ 1493, 1495 ], [ 1497 ], [ 1499, 1501 ], [ 1503 ], [ 1505 ], [ 1507, 1509 ], [ 1511, 1513 ], [ 1515 ], [ 1517, 1519 ], [ 1521 ], [ 1523, 1525 ], [ 1527 ], [ 1529 ], [ 1531, 1533 ], [ 1535, 1537 ], [ 1539 ], [ 1541, 1543 ], [ 1545 ], [ 1547, 1549 ], [ 1551 ], [ 1553 ], [ 1555, 1557 ], [ 1559, 1561 ], [ 1563 ], [ 1565, 1567 ], [ 1569 ], [ 1571, 1573 ], [ 1575 ], [ 1577 ], [ 1579, 1581 ], [ 1583, 1585 ], [ 1587 ], [ 1589 ], [ 1591 ], [ 1593 ], [ 1595, 1597 ], [ 1599 ] ]

[ "void *FUNC_0(void *VAR_0, size_t VAR_1, size_t VAR_2)\n{", "size_t sz;", "__coverity_negative_sink__(VAR_1);", "__coverity_negative_sink__(VAR_2);", "sz = VAR_1 * VAR_2;", "__coverity_escape__(VAR_0);", "VAR_0 = __coverity_alloc__(VAR_2);", "__coverity_writeall__(VAR_0);", "__coverity_mark_as_afm_allocated__(VAR_0, AFM_free);", "return VAR_0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "NetSocketState *s = VAR_0;", "int VAR_1;", "VAR_1 = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);", "if (VAR_1 < 0)\nreturn;", "if (VAR_1 == 0) {", "net_socket_read_poll(s, false);", "net_socket_write_poll(s, false);", "return;", "}", "qemu_send_packet(&s->nc, s->buf, VAR_1);", "}" ]

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

[ "static int FUNC_0(VncState *VAR_0, int VAR_1, int VAR_2,\nsize_t VAR_3, uint32_t *VAR_4, uint32_t *VAR_5,\nstruct QDict **VAR_6)\n{", "int VAR_7;", "VAR_7 = VAR_3 / tight_conf[VAR_0->tight_compression].idx_max_colors_divisor;", "if (VAR_7 < 2 &&\nVAR_3 >= tight_conf[VAR_0->tight_compression].mono_min_rect_size) {", "VAR_7 = 2;", "}", "if (VAR_7 >= 256) {", "VAR_7 = 256;", "}", "switch(VAR_0->clientds.pf.bytes_per_pixel) {", "case 4:\nreturn tight_fill_palette32(VAR_0, VAR_1, VAR_2, VAR_7, VAR_3, VAR_4, VAR_5, VAR_6);", "case 2:\nreturn tight_fill_palette16(VAR_0, VAR_1, VAR_2, VAR_7, VAR_3, VAR_4, VAR_5, VAR_6);", "default:\nVAR_7 = 2;", "return tight_fill_palette8(VAR_0, VAR_1, VAR_2, VAR_7, VAR_3, VAR_4, VAR_5, VAR_6);", "}", "return 0;", "}" ]

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

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

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

[ 0, 0, 0 ]

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

[ "void FUNC_0 (void)\n{", "mips_tlb_flush_extra (env, MIPS_TLB_NB);", "invalidate_tlb(env->CP0_index & (MIPS_TLB_NB - 1), 0);", "fill_tlb(env->CP0_index & (MIPS_TLB_NB - 1));", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 11 ], [ 19 ], [ 21 ], [ 23 ] ]

[ "static void FUNC_0(TCGContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,\nint VAR_4, int VAR_5, intptr_t VAR_6)\n{", "int VAR_7, VAR_8;", "if (VAR_4 < 0 && VAR_3 < 0) {", "if (TCG_TARGET_REG_BITS == 64) {", "intptr_t pc = (intptr_t)VAR_0->code_ptr + 5 + ~VAR_3;", "intptr_t disp = VAR_6 - pc;", "if (disp == (int32_t)disp) {", "tcg_out_opc(VAR_0, VAR_1, VAR_2, 0, 0);", "tcg_out8(VAR_0, (LOWREGMASK(VAR_2) << 3) | 5);", "tcg_out32(VAR_0, disp);", "return;", "}", "if (VAR_6 == (int32_t)VAR_6) {", "tcg_out_opc(VAR_0, VAR_1, VAR_2, 0, 0);", "tcg_out8(VAR_0, (LOWREGMASK(VAR_2) << 3) | 4);", "tcg_out8(VAR_0, (4 << 3) | 5);", "tcg_out32(VAR_0, VAR_6);", "return;", "}", "tcg_abort();", "} else {", "tcg_out_opc(VAR_0, VAR_1, VAR_2, 0, 0);", "tcg_out8(VAR_0, (VAR_2 << 3) | 5);", "tcg_out32(VAR_0, VAR_6);", "return;", "}", "}", "if (VAR_3 < 0) {", "VAR_7 = 0, VAR_8 = 4, VAR_3 = 5;", "} else if (VAR_6 == 0 && LOWREGMASK(VAR_3) != TCG_REG_EBP) {", "VAR_7 = 0, VAR_8 = 0;", "} else if (VAR_6 == (int8_t)VAR_6) {", "VAR_7 = 0x40, VAR_8 = 1;", "} else {", "VAR_7 = 0x80, VAR_8 = 4;", "}", "if (VAR_4 < 0 && LOWREGMASK(VAR_3) != TCG_REG_ESP) {", "tcg_out_opc(VAR_0, VAR_1, VAR_2, VAR_3, 0);", "tcg_out8(VAR_0, VAR_7 | (LOWREGMASK(VAR_2) << 3) | LOWREGMASK(VAR_3));", "} else {", "if (VAR_4 < 0) {", "VAR_4 = 4;", "} else {", "assert(VAR_4 != TCG_REG_ESP);", "}", "tcg_out_opc(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4);", "tcg_out8(VAR_0, VAR_7 | (LOWREGMASK(VAR_2) << 3) | 4);", "tcg_out8(VAR_0, (VAR_5 << 6) | (LOWREGMASK(VAR_4) << 3) | LOWREGMASK(VAR_3));", "}", "if (VAR_8 == 1) {", "tcg_out8(VAR_0, VAR_6);", "} else if (VAR_8 == 4) {", "tcg_out32(VAR_0, VAR_6);", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ] ]

[ "static int FUNC_0(struct common *VAR_0)\n{", "int VAR_1;", "if (xenstore_read_fe_int(&VAR_0->xendev, \"page-ref\", &VAR_1) == -1)\nreturn -1;", "if (xenstore_read_fe_int(&VAR_0->xendev, \"event-channel\", &VAR_0->xendev.remote_port) == -1)\nreturn -1;", "VAR_0->page = xc_map_foreign_range(xen_xc, VAR_0->xendev.dom,\nXC_PAGE_SIZE,\nPROT_READ | PROT_WRITE, VAR_1);", "if (VAR_0->page == NULL)\nreturn -1;", "xen_be_bind_evtchn(&VAR_0->xendev);", "xen_be_printf(&VAR_0->xendev, 1, \"ring VAR_1 %d, remote-port %d, local-port %d\\n\",\nVAR_1, VAR_0->xendev.remote_port, VAR_0->xendev.local_port);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1)\n{", "NVENCContext *ctx = VAR_0->priv_data;", "NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;", "NV_ENC_LOCK_BITSTREAM params = { 0 };", "NVENCOutputSurface *out = NULL;", "int VAR_2;", "VAR_2 = nvenc_dequeue_surface(ctx->pending, &out);", "if (VAR_2)\nreturn VAR_2;", "params.version = NV_ENC_LOCK_BITSTREAM_VER;", "params.outputBitstream = out->out;", "VAR_2 = nv->nvEncLockBitstream(ctx->nvenc_ctx, &params);", "if (VAR_2 < 0)\nreturn nvenc_print_error(VAR_0, VAR_2, \"Cannot lock the bitstream\");", "VAR_2 = ff_alloc_packet(VAR_1, params.bitstreamSizeInBytes);", "if (VAR_2 < 0)\nreturn VAR_2;", "memcpy(VAR_1->data, params.bitstreamBufferPtr, VAR_1->size);", "VAR_2 = nv->nvEncUnlockBitstream(ctx->nvenc_ctx, out->out);", "if (VAR_2 < 0)\nreturn nvenc_print_error(VAR_0, VAR_2, \"Cannot unlock the bitstream\");", "out->busy = out->in->locked = 0;", "VAR_2 = nvenc_set_timestamp(ctx, &params, VAR_1);", "if (VAR_2 < 0)\nreturn VAR_2;", "switch (params.pictureType) {", "case NV_ENC_PIC_TYPE_IDR:\nVAR_1->flags |= AV_PKT_FLAG_KEY;", "#if FF_API_CODED_FRAME\nFF_DISABLE_DEPRECATION_WARNINGS\ncase NV_ENC_PIC_TYPE_INTRA_REFRESH:\ncase NV_ENC_PIC_TYPE_I:\nVAR_0->coded_frame->pict_type = AV_PICTURE_TYPE_I;", "break;", "case NV_ENC_PIC_TYPE_P:\nVAR_0->coded_frame->pict_type = AV_PICTURE_TYPE_P;", "break;", "case NV_ENC_PIC_TYPE_B:\nVAR_0->coded_frame->pict_type = AV_PICTURE_TYPE_B;", "break;", "case NV_ENC_PIC_TYPE_BI:\nVAR_0->coded_frame->pict_type = AV_PICTURE_TYPE_BI;", "break;", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\n}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19, 21 ], [ 25 ], [ 27 ], [ 31 ], [ 33, 35 ], [ 39 ], [ 41, 43 ], [ 47 ], [ 51 ], [ 53, 55 ], [ 59 ], [ 63 ], [ 65, 67 ], [ 71 ], [ 73, 75 ], [ 77, 79, 81, 83, 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101, 103 ], [ 105 ], [ 107, 109, 111 ], [ 115 ], [ 117 ] ]

[ "static ssize_t FUNC_0(VLANClientState *nc, const uint8_t *buf, size_t size_, int do_interrupt)\n{", "RTL8139State *s = DO_UPCAST(NICState, nc, nc)->opaque;", "int VAR_0 = size_;", "uint32_t packet_header = 0;", "uint8_t buf1[60];", "static const uint8_t VAR_1[6] =\n{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };", "DEBUG_PRINT((\">>> RTL8139: received len=%d\\n\", VAR_0));", "if (!s->clock_enabled)\n{", "DEBUG_PRINT((\"RTL8139: stopped ==========================\\n\"));", "return -1;", "}", "if (!rtl8139_receiver_enabled(s))\n{", "DEBUG_PRINT((\"RTL8139: receiver disabled ================\\n\"));", "return -1;", "}", "if (s->RxConfig & AcceptAllPhys) {", "DEBUG_PRINT((\">>> RTL8139: packet received in promiscuous mode\\n\"));", "} else {", "if (!memcmp(buf, VAR_1, 6)) {", "if (!(s->RxConfig & AcceptBroadcast))\n{", "DEBUG_PRINT((\">>> RTL8139: broadcast packet rejected\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "packet_header |= RxBroadcast;", "DEBUG_PRINT((\">>> RTL8139: broadcast packet received\\n\"));", "++s->tally_counters.RxOkBrd;", "} else if (buf[0] & 0x01) {", "if (!(s->RxConfig & AcceptMulticast))\n{", "DEBUG_PRINT((\">>> RTL8139: multicast packet rejected\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "int VAR_2 = compute_mcast_idx(buf);", "if (!(s->mult[VAR_2 >> 3] & (1 << (VAR_2 & 7))))\n{", "DEBUG_PRINT((\">>> RTL8139: multicast address mismatch\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "packet_header |= RxMulticast;", "DEBUG_PRINT((\">>> RTL8139: multicast packet received\\n\"));", "++s->tally_counters.RxOkMul;", "} else if (s->phys[0] == buf[0] &&", "s->phys[1] == buf[1] &&\ns->phys[2] == buf[2] &&\ns->phys[3] == buf[3] &&\ns->phys[4] == buf[4] &&\ns->phys[5] == buf[5]) {", "if (!(s->RxConfig & AcceptMyPhys))\n{", "DEBUG_PRINT((\">>> RTL8139: rejecting physical address matching packet\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "packet_header |= RxPhysical;", "DEBUG_PRINT((\">>> RTL8139: physical address matching packet received\\n\"));", "++s->tally_counters.RxOkPhy;", "} else {", "DEBUG_PRINT((\">>> RTL8139: unknown packet\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "}", "if (VAR_0 < MIN_BUF_SIZE) {", "memcpy(buf1, buf, VAR_0);", "memset(buf1 + VAR_0, 0, MIN_BUF_SIZE - VAR_0);", "buf = buf1;", "VAR_0 = MIN_BUF_SIZE;", "}", "if (rtl8139_cp_receiver_enabled(s))\n{", "DEBUG_PRINT((\"RTL8139: in C+ Rx mode ================\\n\"));", "#define CP_RX_OWN (1<<31)\n#define CP_RX_EOR (1<<30)\n#define CP_RX_BUFFER_SIZE_MASK ((1<<13) - 1)\n#define CP_RX_TAVA (1<<16)\n#define CP_RX_VLAN_TAG_MASK ((1<<16) - 1)\nint VAR_3 = s->currCPlusRxDesc;", "target_phys_addr_t cplus_rx_ring_desc;", "cplus_rx_ring_desc = rtl8139_addr64(s->RxRingAddrLO, s->RxRingAddrHI);", "cplus_rx_ring_desc += 16 * VAR_3;", "DEBUG_PRINT((\"RTL8139: +++ C+ mode reading RX VAR_3 %d from host memory at %08x %08x = %016\" PRIx64 \"\\n\",\nVAR_3, s->RxRingAddrHI, s->RxRingAddrLO, (uint64_t)cplus_rx_ring_desc));", "uint32_t val, rxdw0,rxdw1,rxbufLO,rxbufHI;", "cpu_physical_memory_read(cplus_rx_ring_desc, (uint8_t *)&val, 4);", "rxdw0 = le32_to_cpu(val);", "cpu_physical_memory_read(cplus_rx_ring_desc+4, (uint8_t *)&val, 4);", "rxdw1 = le32_to_cpu(val);", "cpu_physical_memory_read(cplus_rx_ring_desc+8, (uint8_t *)&val, 4);", "rxbufLO = le32_to_cpu(val);", "cpu_physical_memory_read(cplus_rx_ring_desc+12, (uint8_t *)&val, 4);", "rxbufHI = le32_to_cpu(val);", "DEBUG_PRINT((\"RTL8139: +++ C+ mode RX VAR_3 %d %08x %08x %08x %08x\\n\",\nVAR_3,\nrxdw0, rxdw1, rxbufLO, rxbufHI));", "if (!(rxdw0 & CP_RX_OWN))\n{", "DEBUG_PRINT((\"RTL8139: C+ Rx mode : VAR_3 %d is owned by host\\n\", VAR_3));", "s->IntrStatus |= RxOverflow;", "++s->RxMissed;", "++s->tally_counters.RxERR;", "++s->tally_counters.MissPkt;", "rtl8139_update_irq(s);", "return size_;", "}", "uint32_t rx_space = rxdw0 & CP_RX_BUFFER_SIZE_MASK;", "if (VAR_0+4 > rx_space)\n{", "DEBUG_PRINT((\"RTL8139: C+ Rx mode : VAR_3 %d VAR_0 %d received %d + 4\\n\",\nVAR_3, rx_space, VAR_0));", "s->IntrStatus |= RxOverflow;", "++s->RxMissed;", "++s->tally_counters.RxERR;", "++s->tally_counters.MissPkt;", "rtl8139_update_irq(s);", "return size_;", "}", "target_phys_addr_t rx_addr = rtl8139_addr64(rxbufLO, rxbufHI);", "cpu_physical_memory_write( rx_addr, buf, VAR_0 );", "if (s->CpCmd & CPlusRxChkSum)\n{", "}", "#if defined (RTL8139_CALCULATE_RXCRC)\nval = cpu_to_le32(crc32(0, buf, VAR_0));", "#else\nval = 0;", "#endif\ncpu_physical_memory_write( rx_addr+VAR_0, (uint8_t *)&val, 4);", "#define CP_RX_STATUS_FS (1<<29)\n#define CP_RX_STATUS_LS (1<<28)\n#define CP_RX_STATUS_MAR (1<<26)\n#define CP_RX_STATUS_PAM (1<<25)\n#define CP_RX_STATUS_BAR (1<<24)\n#define CP_RX_STATUS_RUNT (1<<19)\n#define CP_RX_STATUS_CRC (1<<18)\n#define CP_RX_STATUS_IPF (1<<15)\n#define CP_RX_STATUS_UDPF (1<<14)\n#define CP_RX_STATUS_TCPF (1<<13)\nrxdw0 &= ~CP_RX_OWN;", "rxdw0 |= CP_RX_STATUS_FS;", "rxdw0 |= CP_RX_STATUS_LS;", "if (packet_header & RxBroadcast)\nrxdw0 |= CP_RX_STATUS_BAR;", "if (packet_header & RxMulticast)\nrxdw0 |= CP_RX_STATUS_MAR;", "if (packet_header & RxPhysical)\nrxdw0 |= CP_RX_STATUS_PAM;", "rxdw0 &= ~CP_RX_BUFFER_SIZE_MASK;", "rxdw0 |= (VAR_0+4);", "rxdw1 &= ~CP_RX_TAVA;", "val = cpu_to_le32(rxdw0);", "cpu_physical_memory_write(cplus_rx_ring_desc, (uint8_t *)&val, 4);", "val = cpu_to_le32(rxdw1);", "cpu_physical_memory_write(cplus_rx_ring_desc+4, (uint8_t *)&val, 4);", "++s->tally_counters.RxOk;", "if (rxdw0 & CP_RX_EOR)\n{", "s->currCPlusRxDesc = 0;", "}", "else\n{", "++s->currCPlusRxDesc;", "}", "DEBUG_PRINT((\"RTL8139: done C+ Rx mode ----------------\\n\"));", "}", "else\n{", "DEBUG_PRINT((\"RTL8139: in ring Rx mode ================\\n\"));", "int VAR_4 = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr, s->RxBufferSize);", "if (VAR_4 != 0 && VAR_0 + 8 >= VAR_4)\n{", "DEBUG_PRINT((\"rx overflow: rx buffer length %d head 0x%04x read 0x%04x === available 0x%04x need 0x%04x\\n\",\ns->RxBufferSize, s->RxBufAddr, s->RxBufPtr, VAR_4, VAR_0 + 8));", "s->IntrStatus |= RxOverflow;", "++s->RxMissed;", "rtl8139_update_irq(s);", "return size_;", "}", "packet_header |= RxStatusOK;", "packet_header |= (((VAR_0+4) << 16) & 0xffff0000);", "uint32_t val = cpu_to_le32(packet_header);", "rtl8139_write_buffer(s, (uint8_t *)&val, 4);", "rtl8139_write_buffer(s, buf, VAR_0);", "#if defined (RTL8139_CALCULATE_RXCRC)\nval = cpu_to_le32(crc32(0, buf, VAR_0));", "#else\nval = 0;", "#endif\nrtl8139_write_buffer(s, (uint8_t *)&val, 4);", "s->RxBufAddr = MOD2((s->RxBufAddr + 3) & ~0x3, s->RxBufferSize);", "DEBUG_PRINT((\" received: rx buffer length %d head 0x%04x read 0x%04x\\n\",\ns->RxBufferSize, s->RxBufAddr, s->RxBufPtr));", "}", "s->IntrStatus |= RxOK;", "if (do_interrupt)\n{", "rtl8139_update_irq(s);", "}", "return size_;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17, 19 ], [ 23 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 73, 75 ], [ 77 ], [ 83 ], [ 87 ], [ 89 ], [ 93 ], [ 97 ], [ 103 ], [ 107 ], [ 111, 113 ], [ 115 ], [ 121 ], [ 125 ], [ 127 ], [ 131 ], [ 135, 137 ], [ 139 ], [ 145 ], [ 149 ], [ 151 ], [ 155 ], [ 159 ], [ 165 ], [ 169 ], [ 171, 173, 175, 177, 179 ], [ 183, 185 ], [ 187 ], [ 193 ], [ 197 ], [ 199 ], [ 203 ], [ 207 ], [ 213 ], [ 217 ], [ 221 ], [ 227 ], [ 231 ], [ 233 ], [ 235 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 255, 257 ], [ 259 ], [ 269, 273, 277, 281, 285, 293 ], [ 295 ], [ 299 ], [ 301 ], [ 305, 307 ], [ 311 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 333, 335, 337 ], [ 341, 343 ], [ 345 ], [ 349 ], [ 351 ], [ 357 ], [ 359 ], [ 363 ], [ 365 ], [ 367 ], [ 371 ], [ 379, 381 ], [ 383, 385 ], [ 389 ], [ 391 ], [ 397 ], [ 399 ], [ 403 ], [ 405 ], [ 407 ], [ 411 ], [ 417 ], [ 421, 423 ], [ 427 ], [ 433, 435 ], [ 437, 439 ], [ 441, 443 ], [ 449, 453, 457, 461, 465, 469, 473, 477, 481, 485, 491 ], [ 497 ], [ 503 ], [ 509, 511 ], [ 513, 515 ], [ 517, 519 ], [ 525 ], [ 527 ], [ 533 ], [ 539 ], [ 541 ], [ 543 ], [ 545 ], [ 551 ], [ 557, 559 ], [ 561 ], [ 563 ], [ 565, 567 ], [ 569 ], [ 571 ], [ 575 ], [ 579 ], [ 581, 583 ], [ 585 ], [ 591 ], [ 599, 601 ], [ 603, 605 ], [ 609 ], [ 611 ], [ 613 ], [ 615 ], [ 617 ], [ 621 ], [ 625 ], [ 631 ], [ 635 ], [ 639 ], [ 645, 647 ], [ 649, 651 ], [ 653, 657 ], [ 663 ], [ 671, 673 ], [ 675 ], [ 679 ], [ 683, 685 ], [ 687 ], [ 689 ], [ 693 ], [ 695 ] ]

[ "static void FUNC_0(PCIBus *VAR_0, void *VAR_1)\n{", "AcpiBuildPciBusHotplugState *child = VAR_1;", "AcpiBuildPciBusHotplugState *parent = child->parent;", "GArray *bus_table = build_alloc_array();", "DECLARE_BITMAP(slot_hotplug_enable, PCI_SLOT_MAX);", "DECLARE_BITMAP(slot_device_present, PCI_SLOT_MAX);", "DECLARE_BITMAP(slot_device_system, PCI_SLOT_MAX);", "DECLARE_BITMAP(slot_device_vga, PCI_SLOT_MAX);", "DECLARE_BITMAP(slot_device_qxl, PCI_SLOT_MAX);", "uint8_t op;", "int VAR_2;", "QObject *bsel;", "GArray *method;", "bool bus_hotplug_support = false;", "if (VAR_0->parent_dev && (!child->pcihp_bridge_en ||\nDEVICE(VAR_0->parent_dev)->hotplugged)) {", "build_free_array(bus_table);", "build_pci_bus_state_cleanup(child);", "g_free(child);", "return;", "}", "if (VAR_0->parent_dev) {", "op = 0x82;", "build_append_namestring(bus_table, \"S%.02X\",\nVAR_0->parent_dev->devfn);", "build_append_byte(bus_table, 0x08);", "build_append_namestring(bus_table, \"_SUN\");", "build_append_int(bus_table, PCI_SLOT(VAR_0->parent_dev->devfn));", "build_append_byte(bus_table, 0x08);", "build_append_namestring(bus_table, \"_ADR\");", "build_append_int(bus_table, (PCI_SLOT(VAR_0->parent_dev->devfn) << 16) |\nPCI_FUNC(VAR_0->parent_dev->devfn));", "} else {", "op = 0x10; ;", "build_append_namestring(bus_table, \"PCI0\");", "}", "bsel = object_property_get_qobject(OBJECT(VAR_0), ACPI_PCIHP_PROP_BSEL, NULL);", "if (bsel) {", "build_append_byte(bus_table, 0x08);", "build_append_namestring(bus_table, \"BSEL\");", "build_append_int(bus_table, qint_get_int(qobject_to_qint(bsel)));", "memset(slot_hotplug_enable, 0xff, sizeof slot_hotplug_enable);", "} else {", "memset(slot_hotplug_enable, 0x00, sizeof slot_hotplug_enable);", "}", "memset(slot_device_present, 0x00, sizeof slot_device_present);", "memset(slot_device_system, 0x00, sizeof slot_device_present);", "memset(slot_device_vga, 0x00, sizeof slot_device_vga);", "memset(slot_device_qxl, 0x00, sizeof slot_device_qxl);", "for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(VAR_0->devices); VAR_2 += PCI_FUNC_MAX) {", "DeviceClass *dc;", "PCIDeviceClass *pc;", "PCIDevice *pdev = VAR_0->devices[VAR_2];", "int slot = PCI_SLOT(VAR_2);", "bool bridge_in_acpi;", "if (!pdev) {", "continue;", "}", "set_bit(slot, slot_device_present);", "pc = PCI_DEVICE_GET_CLASS(pdev);", "dc = DEVICE_GET_CLASS(pdev);", "bridge_in_acpi = pc->is_bridge && child->pcihp_bridge_en &&\n!DEVICE(pdev)->hotplugged;", "if (pc->class_id == PCI_CLASS_BRIDGE_ISA || bridge_in_acpi) {", "set_bit(slot, slot_device_system);", "}", "if (pc->class_id == PCI_CLASS_DISPLAY_VGA) {", "set_bit(slot, slot_device_vga);", "if (object_dynamic_cast(OBJECT(pdev), \"qxl-vga\")) {", "set_bit(slot, slot_device_qxl);", "}", "}", "if (!dc->hotpluggable || bridge_in_acpi) {", "clear_bit(slot, slot_hotplug_enable);", "}", "}", "for (VAR_2 = 0; VAR_2 < PCI_SLOT_MAX; VAR_2++) {", "bool can_eject = test_bit(VAR_2, slot_hotplug_enable);", "bool present = test_bit(VAR_2, slot_device_present);", "bool vga = test_bit(VAR_2, slot_device_vga);", "bool qxl = test_bit(VAR_2, slot_device_qxl);", "bool system = test_bit(VAR_2, slot_device_system);", "if (can_eject) {", "void *pcihp = acpi_data_push(bus_table,\nACPI_PCIHP_SIZEOF);", "memcpy(pcihp, ACPI_PCIHP_AML, ACPI_PCIHP_SIZEOF);", "patch_pcihp(VAR_2, pcihp);", "bus_hotplug_support = true;", "} else if (qxl) {", "void *pcihp = acpi_data_push(bus_table,\nACPI_PCIQXL_SIZEOF);", "memcpy(pcihp, ACPI_PCIQXL_AML, ACPI_PCIQXL_SIZEOF);", "patch_pciqxl(VAR_2, pcihp);", "} else if (vga) {", "void *pcihp = acpi_data_push(bus_table,\nACPI_PCIVGA_SIZEOF);", "memcpy(pcihp, ACPI_PCIVGA_AML, ACPI_PCIVGA_SIZEOF);", "patch_pcivga(VAR_2, pcihp);", "} else if (system) {", "} else if (present) {", "void *pcihp = acpi_data_push(bus_table,\nACPI_PCINOHP_SIZEOF);", "memcpy(pcihp, ACPI_PCINOHP_AML, ACPI_PCINOHP_SIZEOF);", "patch_pcinohp(VAR_2, pcihp);", "}", "}", "if (bsel) {", "method = build_alloc_method(\"DVNT\", 2);", "for (VAR_2 = 0; VAR_2 < PCI_SLOT_MAX; VAR_2++) {", "GArray *notify;", "uint8_t op;", "if (!test_bit(VAR_2, slot_hotplug_enable)) {", "continue;", "}", "notify = build_alloc_array();", "op = 0xA0;", "build_append_byte(notify, 0x7B);", "build_append_byte(notify, 0x68);", "build_append_int(notify, 0x1U << VAR_2);", "build_append_byte(notify, 0x00);", "build_append_byte(notify, 0x86);", "build_append_namestring(notify, \"S%.02X\", PCI_DEVFN(VAR_2, 0));", "build_append_byte(notify, 0x69);", "build_package(notify, op);", "build_append_array(method, notify);", "build_free_array(notify);", "}", "build_append_and_cleanup_method(bus_table, method);", "}", "if (bus_hotplug_support || child->notify_table->len || !VAR_0->parent_dev) {", "method = build_alloc_method(\"PCNT\", 0);", "if (bsel) {", "build_append_byte(method, 0x70);", "build_append_int(method, qint_get_int(qobject_to_qint(bsel)));", "build_append_namestring(method, \"BNUM\");", "build_append_namestring(method, \"DVNT\");", "build_append_namestring(method, \"PCIU\");", "build_append_int(method, 1);", "build_append_namestring(method, \"DVNT\");", "build_append_namestring(method, \"PCID\");", "build_append_int(method, 3);", "}", "build_append_array(method, child->notify_table);", "build_append_and_cleanup_method(bus_table, method);", "build_append_array(bus_table, child->device_table);", "if (VAR_0->parent_dev) {", "build_extop_package(bus_table, op);", "} else {", "build_package(bus_table, op);", "}", "build_append_array(parent->device_table, bus_table);", "if (VAR_0->parent_dev) {", "build_append_namestring(parent->notify_table, \"^PCNT.S%.02X\",\nVAR_0->parent_dev->devfn);", "}", "}", "qobject_decref(bsel);", "build_free_array(bus_table);", "build_pci_bus_state_cleanup(child);", "g_free(child);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149 ], [ 163, 165 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219, 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231, 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241, 243 ], [ 245 ], [ 247 ], [ 249 ], [ 253 ], [ 255, 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 269 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 283 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 315 ], [ 319 ], [ 323 ], [ 325 ], [ 329 ], [ 331 ], [ 341 ], [ 343 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 375 ], [ 379 ], [ 385 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 405 ], [ 415 ], [ 417, 419 ], [ 421 ], [ 423 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ] ]

[ "static void FUNC_0(CPUARMState *VAR_0, const ARMCPRegInfo *VAR_1)\n{", "ARMCPU *cpu;", "GICv3State *s;", "GICv3CPUState *c;", "c = (GICv3CPUState *)VAR_0->gicv3state;", "s = c->gic;", "cpu = ARM_CPU(c->cpu);", "kvm_device_access(s->dev_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,\nKVM_VGIC_ATTR(ICC_CTLR_EL1, cpu->mp_affinity),\n&c->icc_ctlr_el1[GICV3_NS], false);", "c->icc_ctlr_el1[GICV3_S] = c->icc_ctlr_el1[GICV3_NS];", "c->icc_pmr_el1 = 0;", "c->icc_bpr[GICV3_G0] = GIC_MIN_BPR;", "c->icc_bpr[GICV3_G1] = GIC_MIN_BPR;", "c->icc_bpr[GICV3_G1NS] = GIC_MIN_BPR;", "c->icc_sre_el1 = 0x7;", "memset(c->icc_apr, 0, sizeof(c->icc_apr));", "memset(c->icc_igrpen, 0, sizeof(c->icc_igrpen));", "}" ]

[ 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 ], [ 23, 25, 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ] ]

[ "static bool FUNC_0(const void *p, const void *d)\n{", "const TranslationBlock *VAR_0 = p;", "const struct tb_desc *VAR_1 = d;", "if (VAR_0->pc == VAR_1->pc &&\nVAR_0->page_addr[0] == VAR_1->phys_page1 &&\nVAR_0->cs_base == VAR_1->cs_base &&\nVAR_0->flags == VAR_1->flags &&\nVAR_0->trace_vcpu_dstate == VAR_1->trace_vcpu_dstate &&\n!atomic_read(&VAR_0->invalid)) {", "if (VAR_0->page_addr[1] == -1) {", "return true;", "} else {", "tb_page_addr_t phys_page2;", "target_ulong virt_page2;", "virt_page2 = (VAR_1->pc & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;", "phys_page2 = get_page_addr_code(VAR_1->env, virt_page2);", "if (VAR_0->page_addr[1] == phys_page2) {", "return true;", "}", "}", "}", "return false;", "}" ]

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

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

[ "static int FUNC_0(VncDisplay *VAR_0,\nSocketAddress *VAR_1,\nconst char *VAR_2,\nQIOChannelSocket ***VAR_3,\nguint **VAR_4,\nsize_t *VAR_5,\nError **VAR_6)\n{", "*VAR_5 = 1;", "*VAR_3 = g_new0(QIOChannelSocket *, 1);", "*VAR_4 = g_new0(guint, 1);", "(*VAR_3)[0] = qio_channel_socket_new();", "qio_channel_set_name(QIO_CHANNEL((*VAR_3)[0]), VAR_2);", "if (qio_channel_socket_listen_sync((*VAR_3)[0], VAR_1, VAR_6) < 0) {", "return -1;", "}", "(*VAR_4)[0] = qio_channel_add_watch(\nQIO_CHANNEL((*VAR_3)[0]),\nG_IO_IN, vnc_listen_io, VAR_0, NULL);", "return 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 ], [ 37, 39, 41 ], [ 45 ], [ 47 ] ]

[ "static SpiceChannelList *FUNC_0(void)\n{", "SpiceChannelList *cur_item = NULL, *head = NULL;", "ChannelList *item;", "QTAILQ_FOREACH(item, &channel_list, link) {", "SpiceChannelList *chan;", "char host[NI_MAXHOST], port[NI_MAXSERV];", "struct sockaddr *paddr;", "socklen_t plen;", "assert(item->info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT);", "chan = g_malloc0(sizeof(*chan));", "chan->value = g_malloc0(sizeof(*chan->value));", "chan->value->base = g_malloc0(sizeof(*chan->value->base));", "paddr = (struct sockaddr *)&item->info->paddr_ext;", "plen = item->info->plen_ext;", "getnameinfo(paddr, plen,\nhost, sizeof(host), port, sizeof(port),\nNI_NUMERICHOST | NI_NUMERICSERV);", "chan->value->base->host = g_strdup(host);", "chan->value->base->port = g_strdup(port);", "chan->value->base->family = inet_netfamily(paddr->sa_family);", "chan->value->connection_id = item->info->connection_id;", "chan->value->channel_type = item->info->type;", "chan->value->channel_id = item->info->id;", "chan->value->tls = item->info->flags & SPICE_CHANNEL_EVENT_FLAG_TLS;", "if (!cur_item) {", "head = cur_item = chan;", "} else {", "cur_item->next = chan;", "cur_item = chan;", "}", "}", "return head;", "}" ]

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

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

[ "static int FUNC_0(const char *VAR_0, QemuOpts *VAR_1, Error **VAR_2)\n{", "int VAR_3;", "int VAR_4 = 0;", "int64_t total_size = 0;", "bool nocow = false;", "PreallocMode prealloc;", "char *VAR_5 = NULL;", "Error *local_err = NULL;", "strstart(VAR_0, \"file:\", &VAR_0);", "total_size = ROUND_UP(qemu_opt_get_size_del(VAR_1, BLOCK_OPT_SIZE, 0),\nBDRV_SECTOR_SIZE);", "nocow = qemu_opt_get_bool(VAR_1, BLOCK_OPT_NOCOW, false);", "VAR_5 = qemu_opt_get_del(VAR_1, BLOCK_OPT_PREALLOC);", "prealloc = qapi_enum_parse(PreallocMode_lookup, VAR_5,\nPREALLOC_MODE_MAX, PREALLOC_MODE_OFF,\n&local_err);", "g_free(VAR_5);", "if (local_err) {", "error_propagate(VAR_2, local_err);", "VAR_4 = -EINVAL;", "goto out;", "}", "VAR_3 = qemu_open(VAR_0, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,\n0644);", "if (VAR_3 < 0) {", "VAR_4 = -errno;", "error_setg_errno(VAR_2, -VAR_4, \"Could not create file\");", "goto out;", "}", "if (nocow) {", "#ifdef __linux__\nint attr;", "if (ioctl(VAR_3, FS_IOC_GETFLAGS, &attr) == 0) {", "attr |= FS_NOCOW_FL;", "ioctl(VAR_3, FS_IOC_SETFLAGS, &attr);", "}", "#endif\n}", "if (ftruncate(VAR_3, total_size) != 0) {", "VAR_4 = -errno;", "error_setg_errno(VAR_2, -VAR_4, \"Could not resize file\");", "goto out_close;", "}", "switch (prealloc) {", "#ifdef CONFIG_POSIX_FALLOCATE\ncase PREALLOC_MODE_FALLOC:\nVAR_4 = -posix_fallocate(VAR_3, 0, total_size);", "if (VAR_4 != 0) {", "error_setg_errno(VAR_2, -VAR_4,\n\"Could not preallocate data for the new file\");", "}", "break;", "#endif\ncase PREALLOC_MODE_FULL:\n{", "int64_t num = 0, left = total_size;", "VAR_5 = g_malloc0(65536);", "while (left > 0) {", "num = MIN(left, 65536);", "VAR_4 = write(VAR_3, VAR_5, num);", "if (VAR_4 < 0) {", "VAR_4 = -errno;", "error_setg_errno(VAR_2, -VAR_4,\n\"Could not write to the new file\");", "break;", "}", "left -= VAR_4;", "}", "fsync(VAR_3);", "g_free(VAR_5);", "break;", "}", "case PREALLOC_MODE_OFF:\nbreak;", "default:\nVAR_4 = -EINVAL;", "error_setg(VAR_2, \"Unsupported preallocation mode: %s\",\nPreallocMode_lookup[prealloc]);", "break;", "}", "out_close:\nif (qemu_close(VAR_3) != 0 && VAR_4 == 0) {", "VAR_4 = -errno;", "error_setg_errno(VAR_2, -VAR_4, \"Could not close the new file\");", "}", "out:\nreturn VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 27, 29 ], [ 31 ], [ 33 ], [ 35, 37, 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115, 117, 121 ], [ 123 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133, 135, 137 ], [ 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 179, 181 ], [ 183, 185 ], [ 187 ], [ 189 ], [ 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203, 205 ], [ 207 ] ]

[ "FUNC_0 (void)\n{", "struct timeval VAR_0 = {0, 0};", "struct timezone VAR_1 = {0, 0};", "struct timeval VAR_2 = {0, 0};", "int VAR_3;", "if (gettimeofday (&VAR_0, &VAR_1) != 0)\nerr (\"gettimeofday\");", "for (VAR_3 = 1; VAR_3 < 10000; VAR_3++)", "if (gettimeofday (&VAR_2, NULL) != 0)\nerr (\"gettimeofday 1\");", "else\nif (VAR_2.tv_sec * 1000000 + VAR_2.tv_usec\n!= (VAR_0.tv_sec * 1000000 + VAR_0.tv_usec + VAR_3 * 1000))\n{", "fprintf (stderr, \"t0 (%ld, %ld), VAR_3 %d, t1 (%ld, %ld)\\n\",\nVAR_0.tv_sec, VAR_0.tv_usec, VAR_3, VAR_2.tv_sec, VAR_2.tv_usec);", "abort ();", "}", "if (time (NULL) != VAR_2.tv_sec)\n{", "fprintf (stderr, \"time != gettod\\n\");", "abort ();", "}", "printf (\"pass\\n\");", "exit (0);", "}" ]

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

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

[ "bool FUNC_0(BlockDriverState *top, BlockDriverState *base)\n{", "while (top && top != base) {", "top = top->backing_hd;", "}", "return top != NULL;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "PCIBonitoState *s = VAR_0;", "((uint32_t *)(&s->bonldma))[VAR_1/sizeof(uint32_t)] = VAR_2 & 0xffffffff;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static uint32_t FUNC_0(void)\n{", "unsigned VAR_0;", "uint32_t ret;", "ret = next_map.nodes_nb++;", "assert(ret != PHYS_MAP_NODE_NIL);", "assert(ret != next_map.nodes_nb_alloc);", "for (VAR_0 = 0; VAR_0 < P_L2_SIZE; ++VAR_0) {", "next_map.nodes[ret][VAR_0].skip = 1;", "next_map.nodes[ret][VAR_0].ptr = PHYS_MAP_NODE_NIL;", "}", "return ret;", "}" ]

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

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

[ "static bool FUNC_0(BDRVSheepdogState *s, SheepdogAIOCB *aiocb)\n{", "SheepdogAIOCB *cb;", "QLIST_FOREACH(cb, &s->inflight_aiocb_head, aiocb_siblings) {", "if (AIOCBOverwrapping(aiocb, cb)) {", "return true;", "}", "}", "QLIST_INSERT_HEAD(&s->inflight_aiocb_head, aiocb, aiocb_siblings);", "return false;", "}" ]

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

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

[ "static MemTxResult FUNC_0(GICState *s, int cpu, int offset,\nuint64_t *data, MemTxAttrs attrs)\n{", "switch (offset) {", "case 0x00:\n*data = s->cpu_enabled[cpu];", "break;", "case 0x04:\n*data = s->priority_mask[cpu];", "break;", "case 0x08:\nif (s->security_extn && !attrs.secure) {", "*data = s->abpr[cpu];", "} else {", "*data = s->bpr[cpu];", "}", "break;", "case 0x0c:\n*data = gic_acknowledge_irq(s, cpu);", "break;", "case 0x14:\n*data = s->running_priority[cpu];", "break;", "case 0x18:\n*data = s->current_pending[cpu];", "break;", "case 0x1c:\nif (!gic_has_groups(s) || (s->security_extn && !attrs.secure)) {", "*data = 0;", "} else {", "*data = s->abpr[cpu];", "}", "break;", "case 0xd0: case 0xd4: case 0xd8: case 0xdc:\n*data = s->apr[(offset - 0xd0) / 4][cpu];", "break;", "default:\nqemu_log_mask(LOG_GUEST_ERROR,\n\"FUNC_0: Bad offset %x\\n\", (int)offset);", "return MEMTX_ERROR;", "}", "return MEMTX_OK;", "}" ]

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

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

[ "static int64_t VAR_0 vpc_co_get_block_status(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors, int *pnum)\n{", "BDRVVPCState *s = bs->opaque;", "VHDFooter *footer = (VHDFooter*) s->footer_buf;", "int64_t start, offset;", "bool allocated;", "int n;", "if (be32_to_cpu(footer->type) == VHD_FIXED) {", "*pnum = nb_sectors;", "return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |\n(sector_num << BDRV_SECTOR_BITS);", "}", "offset = get_sector_offset(bs, sector_num, 0);", "start = offset;", "allocated = (offset != -1);", "*pnum = 0;", "do {", "n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)\n- sector_num;", "n = MIN(n, nb_sectors);", "*pnum += n;", "sector_num += n;", "nb_sectors -= n;", "if (allocated) {", "return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;", "}", "if (nb_sectors == 0) {", "break;", "}", "offset = get_sector_offset(bs, sector_num, 0);", "} while (offset == -1);", "return 0;", "}" ]

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

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

[ "static coroutine_fn int FUNC_0(BlockDriverState *bs, int64_t sector_num,\nint nb_sectors, QEMUIOVector *qiov)\n{", "SheepdogAIOCB acb;", "int VAR_0;", "int64_t offset = (sector_num + nb_sectors) * BDRV_SECTOR_SIZE;", "BDRVSheepdogState *s = bs->opaque;", "if (offset > s->inode.vdi_size) {", "VAR_0 = sd_truncate(bs, offset);", "if (VAR_0 < 0) {", "return VAR_0;", "}", "}", "sd_aio_setup(&acb, s, qiov, sector_num, nb_sectors, AIOCB_WRITE_UDATA);", "retry:\nif (check_overlapping_aiocb(s, &acb)) {", "qemu_co_queue_wait(&s->overlapping_queue);", "goto retry;", "}", "sd_co_rw_vector(&acb);", "sd_write_done(&acb);", "QLIST_REMOVE(&acb, aiocb_siblings);", "qemu_co_queue_restart_all(&s->overlapping_queue);", "return acb.VAR_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 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ] ]

[ "long FUNC_0(CPUS390XState *VAR_0)\n{", "rt_sigframe *frame;", "abi_ulong frame_addr = VAR_0->regs[15];", "qemu_log(\"%s: frame_addr 0x%llx\\n\", __FUNCTION__,\n(unsigned long long)frame_addr);", "sigset_t set;", "if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {", "goto badframe;", "}", "target_to_host_sigset(&set, &frame->uc.tuc_sigmask);", "sigprocmask(SIG_SETMASK, &set, NULL);", "if (restore_sigregs(VAR_0, &frame->uc.tuc_mcontext)) {", "goto badframe;", "}", "if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,\nget_sp_from_cpustate(VAR_0)) == -EFAULT) {", "goto badframe;", "}", "unlock_user_struct(frame, frame_addr, 0);", "return VAR_0->regs[2];", "badframe:\nunlock_user_struct(frame, frame_addr, 0);", "force_sig(TARGET_SIGSEGV);", "return 0;", "}" ]

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

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

[ "static bool FUNC_0(BdrvTrackedRequest *req,\nint64_t offset, unsigned int bytes)\n{", "if (offset >= req->overlap_offset + req->overlap_bytes) {", "return false;", "}", "if (req->overlap_offset >= offset + bytes) {", "return false;", "}", "return true;", "}" ]

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

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

[ "static av_cold void FUNC_0(MVTable *tab)\n{", "int VAR_0, VAR_1, VAR_2;", "tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);", "for(VAR_0=0;VAR_0<4096;VAR_0++)", "tab->table_mv_index[VAR_0] = tab->n;", "for(VAR_0=0;VAR_0<tab->n;VAR_0++) {", "VAR_1 = tab->table_mvx[VAR_0];", "VAR_2 = tab->table_mvy[VAR_0];", "tab->table_mv_index[(VAR_1 << 6) | VAR_2] = VAR_0;", "}", "}" ]

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

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

[ "static const QListEntry *FUNC_0(QmpInputVisitor *qiv, QObject *obj,\nvoid *qapi, Error **errp)\n{", "GHashTable *h;", "StackObject *tos = g_new0(StackObject, 1);", "assert(obj);", "tos->obj = obj;", "tos->qapi = qapi;", "if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {", "h = g_hash_table_new(g_str_hash, g_str_equal);", "qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);", "tos->h = h;", "} else if (qobject_type(obj) == QTYPE_QLIST) {", "tos->entry = qlist_first(qobject_to_qlist(obj));", "}", "QSLIST_INSERT_HEAD(&qiv->stack, tos, node);", "return tos->entry;", "}" ]

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

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

[ "int FUNC_0(AioContext *VAR_0)\n{", "QEMUBH *bh, **bhp, *next;", "int VAR_1;", "bool deleted = false;", "qemu_lockcnt_inc(&VAR_0->list_lock);", "VAR_1 = 0;", "for (bh = atomic_rcu_read(&VAR_0->first_bh); bh; bh = next) {", "next = atomic_rcu_read(&bh->next);", "if (atomic_xchg(&bh->scheduled, 0)) {", "if (!bh->idle) {", "VAR_1 = 1;", "}", "bh->idle = 0;", "aio_bh_call(bh);", "}", "if (bh->deleted) {", "deleted = true;", "}", "}", "if (!deleted) {", "qemu_lockcnt_dec(&VAR_0->list_lock);", "return VAR_1;", "}", "if (qemu_lockcnt_dec_and_lock(&VAR_0->list_lock)) {", "bhp = &VAR_0->first_bh;", "while (*bhp) {", "bh = *bhp;", "if (bh->deleted && !bh->scheduled) {", "*bhp = bh->next;", "g_free(bh);", "} else {", "bhp = &bh->next;", "}", "}", "qemu_lockcnt_unlock(&VAR_0->list_lock);", "}", "return VAR_1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ] ]

[ "static void FUNC_0(void)\n{", "QDict *req = qdict_new();", "QObject *resp;", "qdict_put_obj(req, \"execute\", QOBJECT(qstring_from_str(\"user_def_cmd2\")));", "resp = qmp_dispatch(QOBJECT(req));", "assert(resp != NULL);", "assert(qdict_haskey(qobject_to_qdict(resp), \"error\"));", "g_print(\"\\nresp: %s\\n\", qstring_get_str(qobject_to_json_pretty(resp)));", "qobject_decref(resp);", "QDECREF(req);", "}" ]

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

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

[ "int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1)\n{", "BlockDriver *drv = VAR_0->drv;", "int VAR_2;", "if (!drv)\nreturn -ENOMEDIUM;", "if (!drv->FUNC_0)\nreturn -ENOTSUP;", "if (VAR_0->read_only)\nreturn -EACCES;", "VAR_2 = drv->FUNC_0(VAR_0, VAR_1);", "if (VAR_2 == 0) {", "VAR_2 = refresh_total_sectors(VAR_0, VAR_1 >> BDRV_SECTOR_BITS);", "bdrv_dirty_bitmap_truncate(VAR_0);", "if (VAR_0->blk) {", "blk_dev_resize_cb(VAR_0->blk);", "}", "}", "return VAR_2;", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{", "uint32_t value;", "int VAR_0 = addr >> DBDMA_CHANNEL_SHIFT;", "DBDMAState *s = opaque;", "DBDMA_channel *ch = &s->channels[VAR_0];", "int VAR_1 = (addr - (VAR_0 << DBDMA_CHANNEL_SHIFT)) >> 2;", "value = ch->regs[VAR_1];", "DBDMA_DPRINTF(\"readl 0x\" TARGET_FMT_plx \" => 0x%08x\\n\", addr, value);", "DBDMA_DPRINTF(\"VAR_0 0x%x VAR_1 0x%x\\n\",\n(uint32_t)addr >> DBDMA_CHANNEL_SHIFT, VAR_1);", "switch(VAR_1) {", "case DBDMA_CONTROL:\nvalue = 0;", "break;", "case DBDMA_STATUS:\ncase DBDMA_CMDPTR_LO:\ncase DBDMA_INTR_SEL:\ncase DBDMA_BRANCH_SEL:\ncase DBDMA_WAIT_SEL:\nbreak;", "case DBDMA_XFER_MODE:\ncase DBDMA_CMDPTR_HI:\ncase DBDMA_DATA2PTR_HI:\ncase DBDMA_DATA2PTR_LO:\ncase DBDMA_ADDRESS_HI:\ncase DBDMA_BRANCH_ADDR_HI:\nvalue = 0;", "break;", "case DBDMA_RES1:\ncase DBDMA_RES2:\ncase DBDMA_RES3:\ncase DBDMA_RES4:\nbreak;", "}", "return value;", "}" ]

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

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

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "PXBDev *pxb = PXB_DEV(VAR_0);", "DeviceState *ds, *bds;", "PCIBus *bus;", "const char *VAR_1 = NULL;", "if (pxb->numa_node != NUMA_NODE_UNASSIGNED &&\npxb->numa_node >= nb_numa_nodes) {", "error_report(\"Illegal numa node %d.\", pxb->numa_node);", "return -EINVAL;", "}", "if (VAR_0->qdev.id && *VAR_0->qdev.id) {", "VAR_1 = VAR_0->qdev.id;", "}", "ds = qdev_create(NULL, TYPE_PXB_HOST);", "bus = pci_bus_new(ds, \"pxb-internal\", NULL, NULL, 0, TYPE_PXB_BUS);", "bus->parent_dev = VAR_0;", "bus->address_space_mem = VAR_0->bus->address_space_mem;", "bus->address_space_io = VAR_0->bus->address_space_io;", "bus->map_irq = pxb_map_irq_fn;", "bds = qdev_create(BUS(bus), \"pci-bridge\");", "bds->id = VAR_1;", "qdev_prop_set_uint8(bds, PCI_BRIDGE_DEV_PROP_CHASSIS_NR, pxb->bus_nr);", "qdev_prop_set_bit(bds, PCI_BRIDGE_DEV_PROP_SHPC, false);", "PCI_HOST_BRIDGE(ds)->bus = bus;", "if (pxb_register_bus(VAR_0, bus)) {", "return -EINVAL;", "}", "qdev_init_nofail(ds);", "qdev_init_nofail(bds);", "pci_word_test_and_set_mask(VAR_0->config + PCI_STATUS,\nPCI_STATUS_66MHZ | PCI_STATUS_FAST_BACK);", "pci_config_set_class(VAR_0->config, PCI_CLASS_BRIDGE_HOST);", "pxb_dev_list = g_list_insert_sorted(pxb_dev_list, pxb, pxb_compare);", "return 0;", "}" ]

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

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

[ "static bool FUNC_0(struct CirrusVGAState *s,\nint32_t pitch, int32_t addr)\n{", "if (!pitch) {", "return true;", "}", "if (pitch < 0) {", "int64_t min = addr\n+ ((int64_t)s->cirrus_blt_height-1) * pitch;", "int32_t max = addr\n+ s->cirrus_blt_width;", "if (min < 0 || max > s->vga.vram_size) {", "return true;", "}", "} else {", "int64_t max = addr\n+ ((int64_t)s->cirrus_blt_height-1) * pitch\n+ s->cirrus_blt_width;", "if (max > s->vga.vram_size) {", "return true;", "}", "}", "return false;", "}" ]

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

[ "int FUNC_0(QEMUFile *VAR_0, void *VAR_1, int VAR_2)\n{", "CPUCRISState *env = VAR_1;", "int VAR_3;", "int VAR_4;", "int VAR_5;", "for (VAR_3 = 0; VAR_3 < 16; VAR_3++)", "env->regs[VAR_3] = qemu_get_be32(VAR_0);", "for (VAR_3 = 0; VAR_3 < 16; VAR_3++)", "env->pregs[VAR_3] = qemu_get_be32(VAR_0);", "env->pc = qemu_get_be32(VAR_0);", "env->ksp = qemu_get_be32(VAR_0);", "env->dslot = qemu_get_be32(VAR_0);", "env->btaken = qemu_get_be32(VAR_0);", "env->btarget = qemu_get_be32(VAR_0);", "env->cc_op = qemu_get_be32(VAR_0);", "env->cc_mask = qemu_get_be32(VAR_0);", "env->cc_dest = qemu_get_be32(VAR_0);", "env->cc_src = qemu_get_be32(VAR_0);", "env->cc_result = qemu_get_be32(VAR_0);", "env->cc_size = qemu_get_be32(VAR_0);", "env->cc_x = qemu_get_be32(VAR_0);", "for (VAR_4 = 0; VAR_4 < 4; VAR_3++) {", "for (VAR_3 = 0; VAR_3 < 16; VAR_3++)", "env->sregs[VAR_4][VAR_3] = qemu_get_be32(VAR_0);", "}", "env->mmu_rand_lfsr = qemu_get_be32(VAR_0);", "for (VAR_5 = 0; VAR_5 < 2; VAR_5++) {", "for (VAR_4 = 0; VAR_4 < 4; VAR_3++) {", "for (VAR_3 = 0; VAR_3 < 16; VAR_3++) {", "env->tlbsets[VAR_5][VAR_4][VAR_3].lo = qemu_get_be32(VAR_0);", "env->tlbsets[VAR_5][VAR_4][VAR_3].hi = qemu_get_be32(VAR_0);", "}", "}", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nAVPacket *VAR_1,\nunsigned int VAR_2,\nunsigned int VAR_3) {", "int VAR_4 = 0, VAR_5;", "for( VAR_5 = 0; VAR_5 < VAR_2 - 3; VAR_5++ ) {", "if( VAR_1->data[VAR_5] == 0x00 &&\nVAR_1->data[VAR_5+1] == 0x00 &&\nVAR_1->data[VAR_5+2] == 0x01 &&\nVAR_1->data[VAR_5+3] == 0xB6 ) {", "VAR_4 = VAR_5;", "break;", "}", "}", "if( VAR_4 > 0 ) {", "if( VAR_0->extradata == NULL ) {", "VAR_0->extradata = av_malloc(VAR_4);", "memcpy(VAR_0->extradata, VAR_1->data, VAR_4);", "VAR_0->extradata_size = VAR_4;", "}", "memmove(VAR_1->data, &VAR_1->data[VAR_4], VAR_3 - VAR_4);", "VAR_1->size = VAR_3 - VAR_4;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(VFIOPCIDevice *VAR_0, int VAR_1, uint8_t VAR_2,\nError **VAR_3)\n{", "uint16_t flags;", "uint8_t type;", "flags = pci_get_word(VAR_0->pdev.config + VAR_1 + PCI_CAP_FLAGS);", "type = (flags & PCI_EXP_FLAGS_TYPE) >> 4;", "if (type != PCI_EXP_TYPE_ENDPOINT &&\ntype != PCI_EXP_TYPE_LEG_END &&\ntype != PCI_EXP_TYPE_RC_END) {", "error_setg(VAR_3, \"assignment of PCIe type 0x%x \"\n\"devices is not currently supported\", type);", "return -EINVAL;", "}", "if (!pci_bus_is_express(VAR_0->pdev.bus)) {", "PCIBus *bus = VAR_0->pdev.bus;", "PCIDevice *bridge;", "while (!pci_bus_is_root(bus)) {", "bridge = pci_bridge_get_device(bus);", "bus = bridge->bus;", "}", "if (pci_bus_is_express(bus)) {", "return 0;", "}", "} else if (pci_bus_is_root(VAR_0->pdev.bus)) {", "if (type == PCI_EXP_TYPE_ENDPOINT) {", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_CAP_FLAGS,\nPCI_EXP_TYPE_RC_END << 4,\nPCI_EXP_FLAGS_TYPE);", "if (VAR_2 > PCI_EXP_LNKCTL) {", "vfio_add_emulated_long(VAR_0, VAR_1 + PCI_EXP_LNKCAP, 0, ~0);", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_EXP_LNKCTL, 0, ~0);", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_EXP_LNKSTA, 0, ~0);", "#ifndef PCI_EXP_LNKCAP2\n#define PCI_EXP_LNKCAP2 44\n#endif\n#ifndef PCI_EXP_LNKSTA2\n#define PCI_EXP_LNKSTA2 50\n#endif\nif (VAR_2 > PCI_EXP_LNKCAP2) {", "vfio_add_emulated_long(VAR_0, VAR_1 + PCI_EXP_LNKCAP2, 0, ~0);", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_EXP_LNKCTL2, 0, ~0);", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_EXP_LNKSTA2, 0, ~0);", "}", "}", "} else if (type == PCI_EXP_TYPE_LEG_END) {", "return 0;", "}", "} else {", "if (type == PCI_EXP_TYPE_RC_END) {", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_CAP_FLAGS,\nPCI_EXP_TYPE_ENDPOINT << 4,\nPCI_EXP_FLAGS_TYPE);", "vfio_add_emulated_long(VAR_0, VAR_1 + PCI_EXP_LNKCAP,\nPCI_EXP_LNK_MLW_1 | PCI_EXP_LNK_LS_25, ~0);", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_EXP_LNKCTL, 0, ~0);", "}", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_EXP_LNKSTA,\npci_get_word(VAR_0->pdev.config + VAR_1 +\nPCI_EXP_LNKSTA),\nPCI_EXP_LNKCAP_MLW | PCI_EXP_LNKCAP_SLS);", "}", "if ((flags & PCI_EXP_FLAGS_VERS) == 0) {", "vfio_add_emulated_word(VAR_0, VAR_1 + PCI_CAP_FLAGS,\n1, PCI_EXP_FLAGS_VERS);", "}", "VAR_1 = pci_add_capability(&VAR_0->pdev, PCI_CAP_ID_EXP, VAR_1, VAR_2,\nVAR_3);", "if (VAR_1 < 0) {", "return VAR_1;", "}", "VAR_0->pdev.exp.exp_cap = VAR_1;", "return VAR_1;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 19, 21, 23 ], [ 27, 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 113 ], [ 115, 117, 119 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135, 137, 139, 141, 143, 145, 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 173 ], [ 175 ], [ 179 ], [ 189 ], [ 191, 193, 195 ], [ 197, 199 ], [ 201 ], [ 203 ], [ 209, 211, 213, 215 ], [ 217 ], [ 235 ], [ 237, 239 ], [ 241 ], [ 245, 247 ], [ 249 ], [ 251 ], [ 253 ], [ 257 ], [ 261 ], [ 263 ] ]

[ "static void FUNC_0 (openpic_t *VAR_0, int VAR_1, int VAR_2)\n{", "IRQ_dst_t *dst;", "IRQ_src_t *src;", "int VAR_3;", "dst = &VAR_0->dst[VAR_1];", "src = &VAR_0->src[VAR_2];", "VAR_3 = IPVP_PRIORITY(src->ipvp);", "if (VAR_3 <= dst->pctp) {", "DPRINTF(\"%s: IRQ %d has too low VAR_3 on CPU %d\\n\",\n__func__, VAR_2, VAR_1);", "return;", "}", "if (IRQ_testbit(&dst->raised, VAR_2)) {", "DPRINTF(\"%s: IRQ %d was missed on CPU %d\\n\",\n__func__, VAR_2, VAR_1);", "return;", "}", "set_bit(&src->ipvp, IPVP_ACTIVITY);", "IRQ_setbit(&dst->raised, VAR_2);", "if (VAR_3 < dst->raised.VAR_3) {", "DPRINTF(\"%s: IRQ %d is hidden by raised IRQ %d on CPU %d\\n\",\n__func__, VAR_2, dst->raised.next, VAR_1);", "return;", "}", "IRQ_get_next(VAR_0, &dst->raised);", "if (IRQ_get_next(VAR_0, &dst->servicing) != -1 &&\nVAR_3 <= dst->servicing.VAR_3) {", "DPRINTF(\"%s: IRQ %d is hidden by servicing IRQ %d on CPU %d\\n\",\n__func__, VAR_2, dst->servicing.next, VAR_1);", "return;", "}", "DPRINTF(\"Raise OpenPIC INT output cpu %d irq %d\\n\", VAR_1, VAR_2);", "VAR_0->irq_raise(VAR_0, VAR_1, src);", "}" ]

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

[ "void FUNC_0(void *VAR_0, int VAR_1)\n{", "nvic_state *s = (nvic_state *)VAR_0;", "if (VAR_1 >= 16)\nVAR_1 += 16;", "gic_complete_irq(&s->gic, 0, VAR_1);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(MemoryRegion *VAR_0,\nIOMMUNotifierFlag VAR_1,\nIOMMUNotifierFlag VAR_2)\n{", "AMDVIAddressSpace *as = container_of(VAR_0, AMDVIAddressSpace, VAR_0);", "hw_error(\"device %02x.%02x.%x requires VAR_0 notifier which is not \"\n\"currently supported\", as->bus_num, PCI_SLOT(as->devfn),\nPCI_FUNC(as->devfn));", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(X86CPU *VAR_0)\n{", "CPUX86State *env = &VAR_0->env;", "struct {", "struct kvm_msrs info;", "struct kvm_msr_entry entries[1];", "} VAR_1;", "struct kvm_msr_entry *VAR_2 = VAR_1.entries;", "if (!has_msr_tsc_deadline) {", "return 0;", "}", "kvm_msr_entry_set(&VAR_2[0], MSR_IA32_TSCDEADLINE, env->tsc_deadline);", "VAR_1.info.nmsrs = 1;", "return kvm_vcpu_ioctl(CPU(VAR_0), KVM_SET_MSRS, &VAR_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 ], [ 23 ], [ 27 ], [ 31 ], [ 35 ], [ 37 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "hw_error(\"FUNC_0: Bad offset 0x%x\\n\", (int)VAR_1);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(CPUState *VAR_0,\ntarget_phys_addr_t *VAR_1, int *VAR_2,\ntarget_ulong VAR_3, int VAR_4, int VAR_5)\n{", "unsigned int VAR_6;", "uint64_t context;", "int VAR_7;", "if ((VAR_0->lsu & DMMU_E) == 0) {", "*VAR_1 = ultrasparc_truncate_physical(VAR_3);", "*VAR_2 = PAGE_READ | PAGE_WRITE;", "return 0;", "}", "context = VAR_0->dmmu.mmu_primary_context & 0x1fff;", "VAR_7 = VAR_0->tl > 0;", "for (VAR_6 = 0; VAR_6 < 64; VAR_6++) {", "if (ultrasparc_tag_match(&VAR_0->dtlb[VAR_6],\nVAR_3, context, VAR_1,\nVAR_7)) {", "if (((VAR_0->dtlb[VAR_6].tte & 0x4) && VAR_5) ||\n(!(VAR_0->dtlb[VAR_6].tte & 0x2) && (VAR_4 == 1))) {", "uint8_t fault_type = 0;", "if ((VAR_0->dtlb[VAR_6].tte & 0x4) && VAR_5) {", "fault_type |= 1;", "}", "if (VAR_0->dmmu.sfsr & 1)\nVAR_0->dmmu.sfsr = 2;", "VAR_0->dmmu.sfsr |= (VAR_5 << 3) | ((VAR_4 == 1) << 2) | 1;", "VAR_0->dmmu.sfsr |= (fault_type << 7);", "VAR_0->dmmu.sfar = VAR_3;", "VAR_0->exception_index = TT_DFAULT;", "#ifdef DEBUG_MMU\nprintf(\"DFAULT at 0x%\" PRIx64 \"\\n\", VAR_3);", "#endif\nreturn 1;", "}", "*VAR_2 = PAGE_READ;", "if (VAR_0->dtlb[VAR_6].tte & 0x2)\n*VAR_2 |= PAGE_WRITE;", "TTE_SET_USED(VAR_0->dtlb[VAR_6].tte);", "return 0;", "}", "}", "#ifdef DEBUG_MMU\nprintf(\"DMISS at 0x%\" PRIx64 \"\\n\", VAR_3);", "#endif\nVAR_0->dmmu.tag_access = (VAR_3 & ~0x1fffULL) | context;", "VAR_0->exception_index = TT_DMISS;", "return 1;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 39, 41, 43 ], [ 47, 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63, 65 ], [ 71 ], [ 75 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ] ]

[ "static void FUNC_0(SDState *VAR_0, uint8_t *VAR_1)\n{", "uint32_t status = VAR_0->card_status;", "VAR_0->card_status &= ~CARD_STATUS_C | APP_CMD;", "VAR_1[0] = (status >> 24) & 0xff;", "VAR_1[1] = (status >> 16) & 0xff;", "VAR_1[2] = (status >> 8) & 0xff;", "VAR_1[3] = (status >> 0) & 0xff;", "}" ]

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

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

[ "void FUNC_0(ff_simple_idct_add)(uint8_t *dest_, int line_size, DCTELEM *block)\n{", "pixel *dest = (pixel *)dest_;", "int VAR_0;", "line_size /= sizeof(pixel);", "for (VAR_0 = 0; VAR_0 < 8; VAR_0++)", "FUNC_0(idctRowCondDC)(block + VAR_0*8);", "for (VAR_0 = 0; VAR_0 < 8; VAR_0++)", "FUNC_0(idctSparseColAdd)(dest + VAR_0, line_size, block + VAR_0);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, int VAR_1, int VAR_2)\n{", "PCIDevice *pci_dev = VAR_0;", "PCIBus *bus;", "int VAR_3;", "VAR_3 = VAR_2 - pci_dev->irq_state[VAR_1];", "if (!VAR_3)\nreturn;", "pci_dev->irq_state[VAR_1] = VAR_2;", "for (;;) {", "bus = pci_dev->bus;", "VAR_1 = bus->map_irq(pci_dev, VAR_1);", "if (bus->set_irq)\nbreak;", "pci_dev = bus->parent_dev;", "}", "bus->irq_count[VAR_1] += VAR_3;", "bus->set_irq(bus->irq_opaque, VAR_1, bus->irq_count[VAR_1] != 0);", "}" ]

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

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

[ "static int FUNC_0(VP8Context *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "const uint8_t *VAR_3 = VAR_1;", "int VAR_4;", "VAR_0->num_coeff_partitions = 1 << vp8_rac_get_uint(&VAR_0->c, 2);", "VAR_1 += 3 * (VAR_0->num_coeff_partitions - 1);", "VAR_2 -= 3 * (VAR_0->num_coeff_partitions - 1);", "if (VAR_2 < 0)\nreturn -1;", "for (VAR_4 = 0; VAR_4 < VAR_0->num_coeff_partitions - 1; VAR_4++) {", "int size = AV_RL24(VAR_3 + 3 * VAR_4);", "if (VAR_2 - size < 0)\nreturn -1;", "ff_vp56_init_range_decoder(&VAR_0->coeff_partition[VAR_4], VAR_1, size);", "VAR_1 += size;", "VAR_2 -= size;", "}", "ff_vp56_init_range_decoder(&VAR_0->coeff_partition[VAR_4], VAR_1, VAR_2);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVFilterContext *VAR_0, int VAR_1, int VAR_2, float VAR_3)\n{", "struct SOFAlizerContext *VAR_4 = VAR_0->priv;", "const int VAR_5 = VAR_4->sofa.VAR_5;", "int VAR_6 = VAR_4->VAR_6;", "int VAR_7 = VAR_4->VAR_7;", "int VAR_8[16];", "int VAR_9[16];", "int VAR_10 = VAR_0->inputs[0]->channels;", "float VAR_11 = expf((VAR_4->gain - 3 * VAR_10) / 20 * M_LN10);", "FFTComplex *data_hrtf_l = NULL;", "FFTComplex *data_hrtf_r = NULL;", "FFTComplex *fft_in_l = NULL;", "FFTComplex *fft_in_r = NULL;", "float *VAR_12 = NULL;", "float *VAR_13 = NULL;", "int VAR_14 = 0;", "int VAR_15[16];", "int VAR_16, VAR_17, VAR_18 = VAR_1, VAR_19 = VAR_2;", "if (!VAR_4->sofa.ncid) {", "av_log(VAR_0, AV_LOG_ERROR, \"Selected SOFA file is invalid. Please select valid SOFA file.\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_4->type == TIME_DOMAIN) {", "VAR_4->temp_src[0] = av_calloc(FFALIGN(VAR_5, 16), sizeof(float));", "VAR_4->temp_src[1] = av_calloc(FFALIGN(VAR_5, 16), sizeof(float));", "VAR_12 = av_malloc_array(VAR_6 * VAR_5, sizeof(*VAR_12));", "VAR_13 = av_malloc_array(VAR_6 * VAR_5, sizeof(*VAR_13));", "if (!VAR_13 || !VAR_12 || !VAR_4->temp_src[0] || !VAR_4->temp_src[1]) {", "av_free(VAR_12);", "av_free(VAR_13);", "return AVERROR(ENOMEM);", "}", "} else {", "data_hrtf_l = av_malloc_array(VAR_7, sizeof(*data_hrtf_l) * VAR_6);", "data_hrtf_r = av_malloc_array(VAR_7, sizeof(*data_hrtf_r) * VAR_6);", "if (!data_hrtf_r || !data_hrtf_l) {", "av_free(data_hrtf_l);", "av_free(data_hrtf_r);", "return AVERROR(ENOMEM);", "}", "}", "for (VAR_16 = 0; VAR_16 < VAR_4->VAR_6; VAR_16++) {", "VAR_1 = (int)(VAR_4->speaker_azim[VAR_16] + VAR_18) % 360;", "VAR_2 = (int)(VAR_4->speaker_elev[VAR_16] + VAR_19) % 90;", "VAR_15[VAR_16] = find_m(VAR_4, VAR_1, VAR_2, VAR_3);", "VAR_8[VAR_16] = *(VAR_4->sofa.data_delay + 2 * VAR_15[VAR_16]);", "VAR_9[VAR_16] = *(VAR_4->sofa.data_delay + 2 * VAR_15[VAR_16] + 1);", "if (VAR_4->type == TIME_DOMAIN) {", "VAR_14 = VAR_16 * VAR_5;", "for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) {", "*(VAR_12 + VAR_14 + VAR_17) =\n*(VAR_4->sofa.data_ir + 2 * VAR_15[VAR_16] * VAR_5 + VAR_5 - 1 - VAR_17) * VAR_11;", "*(VAR_13 + VAR_14 + VAR_17) =\n*(VAR_4->sofa.data_ir + 2 * VAR_15[VAR_16] * VAR_5 + VAR_5 - 1 - VAR_17 + VAR_5) * VAR_11;", "}", "} else {", "fft_in_l = av_calloc(VAR_7, sizeof(*fft_in_l));", "fft_in_r = av_calloc(VAR_7, sizeof(*fft_in_r));", "if (!fft_in_l || !fft_in_r) {", "av_free(data_hrtf_l);", "av_free(data_hrtf_r);", "av_free(fft_in_l);", "av_free(fft_in_r);", "return AVERROR(ENOMEM);", "}", "VAR_14 = VAR_16 * VAR_7;", "for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) {", "fft_in_l[VAR_8[VAR_16] + VAR_17].re =\n*(VAR_4->sofa.data_ir + 2 * VAR_15[VAR_16] * VAR_5 + VAR_17) * VAR_11;", "fft_in_r[VAR_9[VAR_16] + VAR_17].re =\n*(VAR_4->sofa.data_ir + (2 * VAR_15[VAR_16] + 1) * VAR_5 + VAR_17) * VAR_11;", "}", "av_fft_permute(VAR_4->fft[0], fft_in_l);", "av_fft_calc(VAR_4->fft[0], fft_in_l);", "memcpy(data_hrtf_l + VAR_14, fft_in_l, VAR_7 * sizeof(*fft_in_l));", "av_fft_permute(VAR_4->fft[0], fft_in_r);", "av_fft_calc(VAR_4->fft[0], fft_in_r);", "memcpy(data_hrtf_r + VAR_14, fft_in_r, VAR_7 * sizeof(*fft_in_r));", "}", "av_log(VAR_0, AV_LOG_DEBUG, \"Index: %d, Azimuth: %f, Elevation: %f, Radius: %f of SOFA file.\\n\",\nVAR_15[VAR_16], *(VAR_4->sofa.sp_a + VAR_15[VAR_16]), *(VAR_4->sofa.sp_e + VAR_15[VAR_16]), *(VAR_4->sofa.sp_r + VAR_15[VAR_16]));", "}", "if (VAR_4->type == TIME_DOMAIN) {", "memcpy(VAR_4->data_ir[0], VAR_12, sizeof(float) * VAR_6 * VAR_5);", "memcpy(VAR_4->data_ir[1], VAR_13, sizeof(float) * VAR_6 * VAR_5);", "av_freep(&VAR_12);", "av_freep(&VAR_13);", "} else {", "VAR_4->data_hrtf[0] = av_malloc_array(VAR_7 * VAR_4->VAR_6, sizeof(FFTComplex));", "VAR_4->data_hrtf[1] = av_malloc_array(VAR_7 * VAR_4->VAR_6, sizeof(FFTComplex));", "if (!VAR_4->data_hrtf[0] || !VAR_4->data_hrtf[1]) {", "av_freep(&data_hrtf_l);", "av_freep(&data_hrtf_r);", "av_freep(&fft_in_l);", "av_freep(&fft_in_r);", "return AVERROR(ENOMEM);", "}", "memcpy(VAR_4->data_hrtf[0], data_hrtf_l,\nsizeof(FFTComplex) * VAR_6 * VAR_7);", "memcpy(VAR_4->data_hrtf[1], data_hrtf_r,\nsizeof(FFTComplex) * VAR_6 * VAR_7);", "av_freep(&data_hrtf_l);", "av_freep(&data_hrtf_r);", "av_freep(&fft_in_l);", "av_freep(&fft_in_r);", "}", "memcpy(VAR_4->delay[0], &VAR_8[0], sizeof(int) * VAR_4->VAR_6);", "memcpy(VAR_4->delay[1], &VAR_9[0], sizeof(int) * VAR_4->VAR_6);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 101 ], [ 103 ], [ 107 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 129, 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 161 ], [ 163 ], [ 173, 175 ], [ 177, 179 ], [ 181 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203, 205 ], [ 207 ], [ 211 ], [ 215 ], [ 217 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247, 249 ], [ 251, 253 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ], [ 267 ], [ 271 ], [ 273 ], [ 277 ], [ 279 ] ]

[ "static int FUNC_0(GetByteContext *VAR_0, uint16_t *VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int VAR_5)\n{", "int VAR_6 = 0, VAR_7 = 0, VAR_8 = 0;", "if (!VAR_3) {", "int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13;", "#define READ_PAIR(a, VAR_14) \\\na = bytestream2_get_byte(VAR_0) << 4; \\", "VAR_13 = bytestream2_get_byte(VAR_0); \\", "a |= VAR_13 >> 4; \\", "VAR_14 = (VAR_13 & 0xF) << 8; \\", "VAR_14 |= bytestream2_get_byte(VAR_0); \\", "READ_PAIR(VAR_9, VAR_11)\nREAD_PAIR(VAR_10, VAR_12)\nif (VAR_11 >= VAR_4 || VAR_12 >= VAR_5 || VAR_9 > VAR_11 || VAR_10 > VAR_12)\nreturn AVERROR_INVALIDDATA;", "VAR_1 += VAR_9 + VAR_2 * VAR_10;", "VAR_4 = VAR_11 - VAR_9 + 1;", "VAR_5 = VAR_12 - VAR_10 + 1;", "if (VAR_10)\nVAR_8 = 1;", "}", "do {", "uint16_t *p = VAR_1;", "do {", "if (VAR_7-- < 1) {", "int VAR_14 = bytestream2_get_byte(VAR_0);", "if (VAR_14 < 128)\nVAR_6 = VAR_14 << 8 | bytestream2_get_byte(VAR_0);", "else if (VAR_14 > 129) {", "VAR_7 = 0;", "while (VAR_14-- > 130)\nVAR_7 = (VAR_7 << 8) + bytestream2_get_byte(VAR_0) + 1;", "if (VAR_6 == -2) {", "int VAR_15 = FFMIN((unsigned)VAR_7, VAR_1 + VAR_4 - p);", "VAR_7 -= VAR_15;", "p += VAR_15;", "}", "} else", "VAR_6 = 127 - VAR_14;", "}", "if (VAR_6 >= 0)\n*p = VAR_6;", "else if (VAR_6 == -1 && VAR_8)\n*p = *(p - VAR_2);", "} while (++p < VAR_1 + VAR_4);", "VAR_1 += VAR_2;", "VAR_8 = 1;", "} while (--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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(GetBitContext *VAR_0, int VAR_1)\n{", "unsigned int VAR_2 = get_unary(VAR_0, 1, 128);", "return (VAR_2 << VAR_1) | get_bits_long(VAR_0, VAR_1);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(DCAContext * VAR_0, int VAR_1,\nfloat VAR_2[32][8], float *VAR_3,\nfloat VAR_4)\n{", "const float *VAR_5;", "int VAR_6;", "int VAR_7 = VAR_0->subband_activity[VAR_1];", "int VAR_8;", "VAR_4 *= sqrt(1/8.0);", "if (!VAR_0->multirate_inter)\nVAR_5 = fir_32bands_nonperfect;", "else\nVAR_5 = fir_32bands_perfect;", "for (VAR_8 = 0; VAR_8 < 8; VAR_8++) {", "for (VAR_6 = 0; VAR_6 < VAR_7; VAR_6++){", "uint32_t v = AV_RN32A(&VAR_2[VAR_6][VAR_8]) ^ ((VAR_6-1)&2)<<30;", "AV_WN32A(&VAR_0->raXin[VAR_6], v);", "}", "for (; VAR_6 < 32; VAR_6++)", "VAR_0->raXin[VAR_6] = 0.0;", "VAR_0->synth.synth_filter_float(&VAR_0->imdct,\nVAR_0->subband_fir_hist[VAR_1], &VAR_0->hist_index[VAR_1],\nVAR_0->subband_fir_noidea[VAR_1], VAR_5,\nVAR_3, VAR_0->raXin, VAR_4);", "VAR_3+= 32;", "}", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 27, 29 ], [ 31, 33 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59, 61, 63 ], [ 65 ], [ 69 ], [ 71 ] ]

[ "static int FUNC_0(VncDisplay *VAR_0,\nSocketAddressLegacy **VAR_1,\nsize_t VAR_2,\nSocketAddressLegacy **VAR_3,\nsize_t VAR_4,\nError **VAR_5)\n{", "QIOChannelSocket *sioc = NULL;", "if (VAR_4 != 0) {", "error_setg(VAR_5, \"Cannot use websockets in reverse mode\");", "return -1;", "}", "if (VAR_2 != 1) {", "error_setg(VAR_5, \"Expected a single address in reverse mode\");", "return -1;", "}", "VAR_0->is_unix = VAR_1[0]->type == SOCKET_ADDRESS_LEGACY_KIND_UNIX;", "sioc = qio_channel_socket_new();", "qio_channel_set_name(QIO_CHANNEL(sioc), \"vnc-reverse\");", "if (qio_channel_socket_connect_sync(sioc, VAR_1[0], VAR_5) < 0) {", "return -1;", "}", "vnc_connect(VAR_0, sioc, false, false);", "object_unref(OBJECT(sioc));", "return 0;", "}" ]

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

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

[ "int64_t FUNC_0(const char *name)\n{", "int VAR_0 = 0;", "do {", "if (!strcmp(channel_layout_map[VAR_0].name, name))\nreturn channel_layout_map[VAR_0].layout;", "VAR_0++;", "} while (channel_layout_map[VAR_0].name);", "return 0;", "}" ]

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

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

[ "static DevicePropertyInfo *FUNC_0(ObjectClass *klass,\nconst char *name,\nconst char *default_type,\nconst char *description)\n{", "DevicePropertyInfo *info;", "Property *prop;", "do {", "for (prop = DEVICE_CLASS(klass)->props; prop && prop->name; prop++) {", "if (strcmp(name, prop->name) != 0) {", "continue;", "}", "if (!prop->info->set) {", "return NULL;", "}", "info = g_malloc0(sizeof(*info));", "info->name = g_strdup(prop->name);", "info->type = g_strdup(prop->info->name);", "info->has_description = !!prop->info->description;", "info->description = g_strdup(prop->info->description);", "return info;", "}", "klass = object_class_get_parent(klass);", "} while (klass != object_class_by_name(TYPE_DEVICE));", "info = g_malloc0(sizeof(*info));", "info->name = g_strdup(name);", "info->type = g_strdup(default_type);", "info->has_description = !!description;", "info->description = g_strdup(description);", "return info;", "}" ]

[ 0, 0, 0, 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 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ] ]

[ "static void FUNC_0(MemoryRegion *VAR_0,\nQEMUMachineInitArgs *VAR_1,\nconst struct VAR_2 *VAR_2)\n{", "SPARCCPU *cpu;", "M48t59State *nvram;", "unsigned int VAR_3;", "uint64_t initrd_addr, initrd_size, kernel_addr, kernel_size, kernel_entry;", "PCIBus *pci_bus, *pci_bus2, *pci_bus3;", "ISABus *isa_bus;", "qemu_irq *ivec_irqs, *pbm_irqs;", "DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];", "DriveInfo *fd[MAX_FD];", "FWCfgState *fw_cfg;", "cpu = cpu_devinit(VAR_1->cpu_model, VAR_2);", "ram_init(0, VAR_1->ram_size);", "prom_init(VAR_2->prom_addr, bios_name);", "ivec_irqs = qemu_allocate_irqs(cpu_set_ivec_irq, cpu, IVEC_MAX);", "pci_bus = pci_apb_init(APB_SPECIAL_BASE, APB_MEM_BASE, ivec_irqs, &pci_bus2,\n&pci_bus3, &pbm_irqs);", "pci_vga_init(pci_bus);", "isa_bus = pci_ebus_init(pci_bus, -1, pbm_irqs);", "VAR_3 = 0;", "if (VAR_2->console_serial_base) {", "serial_mm_init(VAR_0, VAR_2->console_serial_base, 0,\nNULL, 115200, serial_hds[VAR_3], DEVICE_BIG_ENDIAN);", "VAR_3++;", "}", "for(; VAR_3 < MAX_SERIAL_PORTS; VAR_3++) {", "if (serial_hds[VAR_3]) {", "serial_isa_init(isa_bus, VAR_3, serial_hds[VAR_3]);", "}", "}", "for(VAR_3 = 0; VAR_3 < MAX_PARALLEL_PORTS; VAR_3++) {", "if (parallel_hds[VAR_3]) {", "parallel_init(isa_bus, VAR_3, parallel_hds[VAR_3]);", "}", "}", "for(VAR_3 = 0; VAR_3 < nb_nics; VAR_3++)", "pci_nic_init_nofail(&nd_table[VAR_3], pci_bus, \"ne2k_pci\", NULL);", "ide_drive_get(hd, MAX_IDE_BUS);", "pci_cmd646_ide_init(pci_bus, hd, 1);", "isa_create_simple(isa_bus, \"i8042\");", "for(VAR_3 = 0; VAR_3 < MAX_FD; VAR_3++) {", "fd[VAR_3] = drive_get(IF_FLOPPY, 0, VAR_3);", "}", "fdctrl_init_isa(isa_bus, fd);", "nvram = m48t59_init_isa(isa_bus, 0x0074, NVRAM_SIZE, 59);", "initrd_size = 0;", "initrd_addr = 0;", "kernel_size = sun4u_load_kernel(VAR_1->kernel_filename,\nVAR_1->initrd_filename,\nram_size, &initrd_size, &initrd_addr,\n&kernel_addr, &kernel_entry);", "sun4u_NVRAM_set_params(nvram, NVRAM_SIZE, \"Sun4u\", VAR_1->ram_size,\nVAR_1->boot_device,\nkernel_addr, kernel_size,\nVAR_1->kernel_cmdline,\ninitrd_addr, initrd_size,\n0,\ngraphic_width, graphic_height, graphic_depth,\n(uint8_t *)&nd_table[0].macaddr);", "fw_cfg = fw_cfg_init(BIOS_CFG_IOPORT, BIOS_CFG_IOPORT + 1, 0, 0);", "fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);", "fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);", "fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);", "fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, VAR_2->machine_id);", "fw_cfg_add_i64(fw_cfg, FW_CFG_KERNEL_ADDR, kernel_entry);", "fw_cfg_add_i64(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);", "if (VAR_1->kernel_cmdline) {", "fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE,\nstrlen(VAR_1->kernel_cmdline) + 1);", "fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, VAR_1->kernel_cmdline);", "} else {", "fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 0);", "}", "fw_cfg_add_i64(fw_cfg, FW_CFG_INITRD_ADDR, initrd_addr);", "fw_cfg_add_i64(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size);", "fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, VAR_1->boot_device[0]);", "fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_WIDTH, graphic_width);", "fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_HEIGHT, graphic_height);", "fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_DEPTH, graphic_depth);", "qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 39 ], [ 43 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 59 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 131, 133, 135, 137 ], [ 141, 143, 145, 147, 149, 153, 155, 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "QEMUFileBuffered *s = VAR_0;", "if (s->has_error) {", "buffered_close(s);", "return;", "}", "qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100);", "if (s->freeze_output)\nreturn;", "s->bytes_xfer = 0;", "buffered_flush(s);", "s->put_ready(s->VAR_0);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23, 25 ], [ 29 ], [ 33 ], [ 39 ], [ 41 ] ]

[ "void FUNC_0(NbdClientSession *VAR_0)\n{", "struct nbd_request VAR_1 = {", ".type = NBD_CMD_DISC,\n.from = 0,\n.len = 0\n};", "if (!VAR_0->bs) {", "return;", "}", "if (VAR_0->sock == -1) {", "return;", "}", "nbd_send_request(VAR_0->sock, &VAR_1);", "nbd_teardown_connection(VAR_0);", "VAR_0->bs = NULL;", "}" ]

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

[ "void FUNC_0(BlockBackend *VAR_0, BlockDriverState *VAR_1)\n{", "bdrv_ref(VAR_1);", "VAR_0->root = bdrv_root_attach_child(VAR_1, \"root\", &child_root, VAR_0);", "notifier_list_notify(&VAR_0->insert_bs_notifiers, VAR_0);", "if (VAR_0->public.throttle_state) {", "throttle_timers_attach_aio_context(\n&VAR_0->public.throttle_timers, bdrv_get_aio_context(VAR_1));", "}", "}" ]

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

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

[ "static void FUNC_0(TestData *VAR_0)\n{", "QPCIBus *bus;", "QTestState *qs;", "char *VAR_1;", "VAR_1 = g_strdup_printf(\"-machine q35 %VAR_1\", !VAR_0->args ? \"\" : VAR_0->args);", "qs = qtest_start(VAR_1);", "qtest_irq_intercept_in(qs, \"ioapic\");", "g_free(VAR_1);", "bus = qpci_init_pc();", "VAR_0->dev = qpci_device_find(bus, QPCI_DEVFN(0x1f, 0x00));", "g_assert(VAR_0->dev != NULL);", "VAR_0->lpc_base = qpci_iomap(VAR_0->dev, 0, NULL);", "qpci_device_enable(VAR_0->dev);", "g_assert(VAR_0->lpc_base != NULL);", "qpci_config_writel(VAR_0->dev, (uintptr_t)VAR_0->lpc_base + ICH9_LPC_PMBASE,\nPM_IO_BASE_ADDR | 0x1);", "qpci_config_writeb(VAR_0->dev, (uintptr_t)VAR_0->lpc_base + ICH9_LPC_ACPI_CTRL,\n0x80);", "qpci_config_writel(VAR_0->dev, (uintptr_t)VAR_0->lpc_base + ICH9_LPC_RCBA,\nRCBA_BASE_ADDR | 0x1);", "VAR_0->tco_io_base = (void *)((uintptr_t)PM_IO_BASE_ADDR + 0x60);", "}" ]

[ 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 ], [ 33 ], [ 37 ], [ 41 ], [ 47, 49 ], [ 53, 55 ], [ 59, 61 ], [ 65 ], [ 67 ] ]

[ "FUNC_0(VAR_0)\n{", "size_t lines;", "char VAR_1[128];", "FILE *test_file;", "QDict *qdict;", "QString *value;", "const char *VAR_2 = \"qdict-test-data.txt\";", "test_file = fopen(VAR_2, \"r\");", "fail_unless(test_file != NULL);", "qdict = qdict_new();", "fail_unless(qdict != NULL);", "for (lines = 0;; lines++) {", "value = read_line(test_file, VAR_1);", "if (!value)\nbreak;", "qdict_put(qdict, VAR_1, value);", "}", "fail_unless(qdict_size(qdict) == lines);", "reset_file(test_file);", "for (;;) {", "const char *VAR_3, *VAR_4;", "value = read_line(test_file, VAR_1);", "if (!value)\nbreak;", "VAR_3 = qstring_get_str(value);", "VAR_4 = qdict_get_str(qdict, VAR_1);", "fail_unless(VAR_4 != NULL);", "fail_unless(strcmp(VAR_3, VAR_4) == 0);", "QDECREF(value);", "}", "reset_file(test_file);", "for (;;) {", "value = read_line(test_file, VAR_1);", "if (!value)\nbreak;", "qdict_del(qdict, VAR_1);", "QDECREF(value);", "fail_unless(qdict_haskey(qdict, VAR_1) == 0);", "}", "fclose(test_file);", "fail_unless(qdict_size(qdict) == 0);", "QDECREF(qdict);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 27 ], [ 29 ], [ 35 ], [ 37 ], [ 39, 41 ], [ 45 ], [ 47 ], [ 49 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65, 67 ], [ 71 ], [ 75 ], [ 77 ], [ 81 ], [ 85 ], [ 87 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ] ]

[ "static int FUNC_0(SysBusDevice *VAR_0)\n{", "SLNANDState *s = SL_NAND(VAR_0);", "DriveInfo *nand;", "s->ctl = 0;", "nand = drive_get(IF_MTD, 0, 0);", "s->nand = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL,\ns->manf_id, s->chip_id);", "memory_region_init_io(&s->iomem, OBJECT(s), &sl_ops, s, \"sl\", 0x40);", "sysbus_init_mmio(VAR_0, &s->iomem);", "return 0;", "}" ]

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

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

[ "void FUNC_0(int VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{", "QEMUPutMouseEntry *entry;", "QEMUPutMouseEvent *mouse_event;", "void *VAR_4;", "int VAR_5, VAR_6;", "if (!runstate_is_running()) {", "return;", "}", "if (QTAILQ_EMPTY(&mouse_handlers)) {", "return;", "}", "entry = QTAILQ_FIRST(&mouse_handlers);", "mouse_event = entry->qemu_put_mouse_event;", "VAR_4 = entry->qemu_put_mouse_event_opaque;", "if (mouse_event) {", "if (entry->qemu_put_mouse_event_absolute) {", "VAR_5 = 0x7fff;", "VAR_6 = 0x7fff;", "} else {", "VAR_5 = graphic_width - 1;", "VAR_6 = graphic_height - 1;", "}", "switch (graphic_rotate) {", "case 0:\nmouse_event(VAR_4,\nVAR_0, VAR_1, VAR_2, VAR_3);", "break;", "case 90:\nmouse_event(VAR_4,\nVAR_5 - VAR_1, VAR_0, VAR_2, VAR_3);", "break;", "case 180:\nmouse_event(VAR_4,\nVAR_5 - VAR_0, VAR_6 - VAR_1, VAR_2, VAR_3);", "break;", "case 270:\nmouse_event(VAR_4,\nVAR_1, VAR_6 - VAR_0, VAR_2, VAR_3);", "break;", "}", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "VmdVideoContext *s = VAR_0->priv_data;", "int VAR_1;", "unsigned int *VAR_2;", "int VAR_3 = 0;", "unsigned char VAR_4, VAR_5, VAR_6;", "unsigned char *VAR_7;", "unsigned char *VAR_8;", "s->VAR_0 = VAR_0;", "VAR_0->pix_fmt = PIX_FMT_PAL8;", "dsputil_init(&s->dsp, VAR_0);", "if (s->VAR_0->extradata_size != VMD_HEADER_SIZE) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"VMD video: expected extradata size of %d\\n\",\nVMD_HEADER_SIZE);", "return -1;", "}", "VAR_7 = (unsigned char *)VAR_0->extradata;", "s->unpack_buffer_size = AV_RL32(&VAR_7[800]);", "s->unpack_buffer = av_malloc(s->unpack_buffer_size);", "if (!s->unpack_buffer)\nreturn -1;", "VAR_8 = &VAR_7[28];", "VAR_2 = (unsigned int *)s->palette;", "for (VAR_1 = 0; VAR_1 < PALETTE_COUNT; VAR_1++) {", "VAR_4 = VAR_8[VAR_3++] * 4;", "VAR_5 = VAR_8[VAR_3++] * 4;", "VAR_6 = VAR_8[VAR_3++] * 4;", "VAR_2[VAR_1] = (VAR_4 << 16) | (VAR_5 << 8) | (VAR_6);", "}", "s->frame.data[0] = s->prev_frame.data[0] = NULL;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(abi_ulong VAR_0,\nabi_ulong VAR_1, abi_ulong VAR_2,\nint VAR_3, int VAR_4, int VAR_5, abi_ulong VAR_6)\n{", "abi_ulong real_end, addr;", "void *VAR_7;", "int VAR_8, VAR_9;", "real_end = VAR_0 + qemu_host_page_size;", "VAR_7 = g2h(VAR_0);", "VAR_8 = 0;", "for(addr = VAR_0; addr < real_end; addr++) {", "if (addr < VAR_1 || addr >= VAR_2)\nVAR_8 |= page_get_flags(addr);", "}", "if (VAR_8 == 0) {", "void *VAR_10 = mmap(VAR_7, qemu_host_page_size, VAR_3,\nVAR_4 | MAP_ANONYMOUS, -1, 0);", "if (VAR_10 == MAP_FAILED)\nreturn -1;", "VAR_8 = VAR_3;", "}", "VAR_8 &= PAGE_BITS;", "VAR_9 = VAR_3 | VAR_8;", "if (!(VAR_4 & MAP_ANONYMOUS)) {", "if ((VAR_4 & MAP_TYPE) == MAP_SHARED &&\n(VAR_3 & PROT_WRITE))\nreturn -EINVAL;", "if (!(VAR_8 & PROT_WRITE))\nmprotect(VAR_7, qemu_host_page_size, VAR_8 | PROT_WRITE);", "if (pread(VAR_5, g2h(VAR_1), VAR_2 - VAR_1, VAR_6) == -1)\nreturn -1;", "if (VAR_9 != (VAR_8 | PROT_WRITE))\nmprotect(VAR_7, qemu_host_page_size, VAR_9);", "} else {", "if (VAR_9 != VAR_8) {", "mprotect(VAR_7, qemu_host_page_size, VAR_9);", "}", "}", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 37 ], [ 41, 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 65, 67, 69 ], [ 75, 77 ], [ 83, 85 ], [ 91, 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, int VAR_1, int64_t VAR_2,\nint64_t VAR_3)\n{", "BDRVQcowState *s = VAR_0->opaque;", "int VAR_4 = QCOW2_OL_DEFAULT & ~VAR_1;", "int VAR_5, VAR_6;", "if (!VAR_3) {", "return 0;", "}", "if (VAR_4 & QCOW2_OL_MAIN_HEADER) {", "if (VAR_2 < s->cluster_size) {", "return QCOW2_OL_MAIN_HEADER;", "}", "}", "VAR_3 = align_offset(offset_into_cluster(s, VAR_2) + VAR_3, s->cluster_size);", "VAR_2 = start_of_cluster(s, VAR_2);", "if ((VAR_4 & QCOW2_OL_ACTIVE_L1) && s->l1_size) {", "if (overlaps_with(s->l1_table_offset, s->l1_size * sizeof(uint64_t))) {", "return QCOW2_OL_ACTIVE_L1;", "}", "}", "if ((VAR_4 & QCOW2_OL_REFCOUNT_TABLE) && s->refcount_table_size) {", "if (overlaps_with(s->refcount_table_offset,\ns->refcount_table_size * sizeof(uint64_t))) {", "return QCOW2_OL_REFCOUNT_TABLE;", "}", "}", "if ((VAR_4 & QCOW2_OL_SNAPSHOT_TABLE) && s->snapshots_size) {", "if (overlaps_with(s->snapshots_offset, s->snapshots_size)) {", "return QCOW2_OL_SNAPSHOT_TABLE;", "}", "}", "if ((VAR_4 & QCOW2_OL_INACTIVE_L1) && s->snapshots) {", "for (VAR_5 = 0; VAR_5 < s->nb_snapshots; VAR_5++) {", "if (s->snapshots[VAR_5].l1_size &&\noverlaps_with(s->snapshots[VAR_5].l1_table_offset,\ns->snapshots[VAR_5].l1_size * sizeof(uint64_t))) {", "return QCOW2_OL_INACTIVE_L1;", "}", "}", "}", "if ((VAR_4 & QCOW2_OL_ACTIVE_L2) && s->l1_table) {", "for (VAR_5 = 0; VAR_5 < s->l1_size; VAR_5++) {", "if ((s->l1_table[VAR_5] & L1E_OFFSET_MASK) &&\noverlaps_with(s->l1_table[VAR_5] & L1E_OFFSET_MASK,\ns->cluster_size)) {", "return QCOW2_OL_ACTIVE_L2;", "}", "}", "}", "if ((VAR_4 & QCOW2_OL_REFCOUNT_BLOCK) && s->refcount_table) {", "for (VAR_5 = 0; VAR_5 < s->refcount_table_size; VAR_5++) {", "if ((s->refcount_table[VAR_5] & REFT_OFFSET_MASK) &&\noverlaps_with(s->refcount_table[VAR_5] & REFT_OFFSET_MASK,\ns->cluster_size)) {", "return QCOW2_OL_REFCOUNT_BLOCK;", "}", "}", "}", "if ((VAR_4 & QCOW2_OL_INACTIVE_L2) && s->snapshots) {", "for (VAR_5 = 0; VAR_5 < s->nb_snapshots; VAR_5++) {", "uint64_t l1_ofs = s->snapshots[VAR_5].l1_table_offset;", "uint32_t l1_sz = s->snapshots[VAR_5].l1_size;", "uint64_t l1_sz2 = l1_sz * sizeof(uint64_t);", "uint64_t *l1 = g_malloc(l1_sz2);", "int ret;", "ret = bdrv_pread(VAR_0->file, l1_ofs, l1, l1_sz2);", "if (ret < 0) {", "g_free(l1);", "return ret;", "}", "for (VAR_6 = 0; VAR_6 < l1_sz; VAR_6++) {", "uint64_t l2_ofs = be64_to_cpu(l1[VAR_6]) & L1E_OFFSET_MASK;", "if (l2_ofs && overlaps_with(l2_ofs, s->cluster_size)) {", "g_free(l1);", "return QCOW2_OL_INACTIVE_L2;", "}", "}", "g_free(l1);", "}", "}", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85, 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105, 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125, 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ] ]

[ "void FUNC_0(TranslationBlock *VAR_0, tb_page_addr_t VAR_1)\n{", "CPUState *cpu;", "PageDesc *p;", "uint32_t h;", "tb_page_addr_t phys_pc;", "assert_tb_locked();", "atomic_set(&VAR_0->invalid, true);", "phys_pc = VAR_0->VAR_1[0] + (VAR_0->pc & ~TARGET_PAGE_MASK);", "h = tb_hash_func(phys_pc, VAR_0->pc, VAR_0->flags, VAR_0->trace_vcpu_dstate);", "qht_remove(&tcg_ctx.tb_ctx.htable, VAR_0, h);", "if (VAR_0->VAR_1[0] != VAR_1) {", "p = page_find(VAR_0->VAR_1[0] >> TARGET_PAGE_BITS);", "tb_page_remove(&p->first_tb, VAR_0);", "invalidate_page_bitmap(p);", "}", "if (VAR_0->VAR_1[1] != -1 && VAR_0->VAR_1[1] != VAR_1) {", "p = page_find(VAR_0->VAR_1[1] >> TARGET_PAGE_BITS);", "tb_page_remove(&p->first_tb, VAR_0);", "invalidate_page_bitmap(p);", "}", "h = tb_jmp_cache_hash_func(VAR_0->pc);", "CPU_FOREACH(cpu) {", "if (atomic_read(&cpu->tb_jmp_cache[h]) == VAR_0) {", "atomic_set(&cpu->tb_jmp_cache[h], NULL);", "}", "}", "tb_remove_from_jmp_list(VAR_0, 0);", "tb_remove_from_jmp_list(VAR_0, 1);", "tb_jmp_unlink(VAR_0);", "tcg_ctx.tb_ctx.tb_phys_invalidate_count++;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 25 ], [ 27 ], [ 29 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 75 ], [ 77 ], [ 83 ], [ 87 ], [ 89 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0)\n{", "NbdClientSession *client = nbd_get_client_session(VAR_0);", "struct nbd_request VAR_1 = { .type = NBD_CMD_FLUSH };", "struct nbd_reply VAR_2;", "ssize_t ret;", "if (!(client->nbdflags & NBD_FLAG_SEND_FLUSH)) {", "return 0;", "}", "if (client->nbdflags & NBD_FLAG_SEND_FUA) {", "VAR_1.type |= NBD_CMD_FLAG_FUA;", "}", "VAR_1.from = 0;", "VAR_1.len = 0;", "nbd_coroutine_start(client, &VAR_1);", "ret = nbd_co_send_request(VAR_0, &VAR_1, NULL, 0);", "if (ret < 0) {", "VAR_2.error = -ret;", "} else {", "nbd_co_receive_reply(client, &VAR_1, &VAR_2, NULL, 0);", "}", "nbd_coroutine_end(client, &VAR_1);", "return -VAR_2.error;", "}" ]

[ 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 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ] ]

[ "void *FUNC_0(void *VAR_0)\n{", "MigrationIncomingState *mis = VAR_0;", "migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,\nMIGRATION_STATUS_COLO);", "mis->to_src_file = qemu_file_get_return_path(mis->from_src_file);", "if (!mis->to_src_file) {", "error_report(\"COLO incoming thread: Open QEMUFile to_src_file failed\");", "goto out;", "}", "qemu_file_set_blocking(mis->from_src_file, true);", "out:\nif (mis->to_src_file) {", "qemu_fclose(mis->to_src_file);", "}", "migration_incoming_exit_colo();", "return NULL;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 37 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ] ]

[ "static int FUNC_0(V9fsProxy *VAR_0,\nstruct iovec *VAR_1, int *VAR_2)\n{", "int VAR_3;", "ProxyHeader header;", "*VAR_2 = 0;", "VAR_1->iov_len = 0;", "VAR_3 = socket_read(VAR_0->sockfd, VAR_1->iov_base, PROXY_HDR_SZ);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "VAR_1->iov_len = PROXY_HDR_SZ;", "proxy_unmarshal(VAR_1, 0, \"dd\", &header.type, &header.size);", "if (header.size != sizeof(int)) {", "*VAR_2 = -ENOBUFS;", "return 0;", "}", "VAR_3 = socket_read(VAR_0->sockfd,\nVAR_1->iov_base + PROXY_HDR_SZ, header.size);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "VAR_1->iov_len += header.size;", "proxy_unmarshal(VAR_1, PROXY_HDR_SZ, \"d\", VAR_2);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(QEMUFile *VAR_0)\n{", "if (VAR_0->is_write)\nabort();", "if (VAR_0->buf_index >= VAR_0->buf_size) {", "qemu_fill_buffer(VAR_0);", "if (VAR_0->buf_index >= VAR_0->buf_size)\nreturn 0;", "}", "return VAR_0->buf[VAR_0->buf_index];", "}" ]

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

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

[ "static void FUNC_0(PowerPCCPU *VAR_0)\n{", "static struct kvm_ppc_smmu_info VAR_1;", "static bool VAR_2;", "CPUPPCState *env = &VAR_0->env;", "long VAR_3;", "int VAR_4, VAR_5, VAR_6, VAR_7;", "if (!(env->mmu_model & POWERPC_MMU_64)) {", "return;", "}", "if (!VAR_2) {", "kvm_get_smmu_info(VAR_0, &VAR_1);", "VAR_2 = true;", "}", "VAR_3 = getrampagesize();", "memset(&env->sps, 0, sizeof(env->sps));", "for (VAR_5 = VAR_4 = 0; VAR_5 < KVM_PPC_PAGE_SIZES_MAX_SZ; VAR_5++) {", "struct ppc_one_seg_page_size *qsps = &env->sps.sps[VAR_4];", "struct kvm_ppc_one_seg_page_size *ksps = &VAR_1.sps[VAR_5];", "if (!kvm_valid_page_size(VAR_1.flags, VAR_3,\nksps->page_shift)) {", "continue;", "}", "qsps->page_shift = ksps->page_shift;", "qsps->slb_enc = ksps->slb_enc;", "for (VAR_7 = VAR_6 = 0; VAR_7 < KVM_PPC_PAGE_SIZES_MAX_SZ; VAR_7++) {", "if (!kvm_valid_page_size(VAR_1.flags, VAR_3,\nksps->enc[VAR_7].page_shift)) {", "continue;", "}", "qsps->enc[VAR_6].page_shift = ksps->enc[VAR_7].page_shift;", "qsps->enc[VAR_6].pte_enc = ksps->enc[VAR_7].pte_enc;", "if (++VAR_6 >= PPC_PAGE_SIZES_MAX_SZ) {", "break;", "}", "}", "if (++VAR_4 >= PPC_PAGE_SIZES_MAX_SZ) {", "break;", "}", "}", "env->slb_nr = VAR_1.slb_size;", "if (VAR_1.flags & KVM_PPC_1T_SEGMENTS) {", "env->mmu_model |= POWERPC_MMU_1TSEG;", "} else {", "env->mmu_model &= ~POWERPC_MMU_1TSEG;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ] ]

[ "static unsigned long *FUNC_0(IscsiLun *VAR_0)\n{", "return bitmap_try_new(DIV_ROUND_UP(sector_lun2qemu(VAR_0->num_blocks,\nVAR_0),\nVAR_0->cluster_sectors));", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0, BlockDriverInfo *VAR_1)\n{", "IscsiLun *iscsilun = VAR_0->opaque;", "VAR_1->unallocated_blocks_are_zero = !!iscsilun->lbprz;", "VAR_1->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws;", "if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 64 * 1024 &&\niscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) {", "VAR_1->cluster_size = iscsilun->bl.opt_unmap_gran * iscsilun->block_size;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(struct sockaddr_storage *VAR_0, int VAR_1)\n{", "sockaddr_union ssu = (sockaddr_union){.storage = *VAR_0};", "if (VAR_0->ss_family == AF_INET)\nssu.in.sin_port = htons(VAR_1);", "#if HAVE_STRUCT_SOCKADDR_IN6\nelse if (VAR_0->ss_family == AF_INET6)\nssu.in6.sin6_port = htons(VAR_1);", "#endif\n*VAR_0 = ssu.storage;", "}" ]

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

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

[ "void FUNC_0(const char *VAR_0, void *VAR_1)\n{", "SaveStateEntry *se, *new_se;", "TAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {", "if (strcmp(se->VAR_0, VAR_0) == 0 && se->VAR_1 == VAR_1) {", "TAILQ_REMOVE(&savevm_handlers, se, entry);", "qemu_free(se);", "}", "}", "}" ]

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

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

[ "static int FUNC_0(VirtIONet *VAR_0, uint8_t VAR_1,\nstruct iovec *VAR_2, unsigned int VAR_3)\n{", "VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);", "uint64_t offloads;", "size_t s;", "if (!((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features)) {", "return VIRTIO_NET_ERR;", "}", "s = iov_to_buf(VAR_2, VAR_3, 0, &offloads, sizeof(offloads));", "if (s != sizeof(offloads)) {", "return VIRTIO_NET_ERR;", "}", "if (VAR_1 == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {", "uint64_t supported_offloads;", "if (!VAR_0->has_vnet_hdr) {", "return VIRTIO_NET_ERR;", "}", "supported_offloads = virtio_net_supported_guest_offloads(VAR_0);", "if (offloads & ~supported_offloads) {", "return VIRTIO_NET_ERR;", "}", "VAR_0->curr_guest_offloads = offloads;", "virtio_net_apply_guest_offloads(VAR_0);", "return VIRTIO_NET_OK;", "} else {", "return VIRTIO_NET_ERR;", "}", "}" ]

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

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

[ "static int VAR_0 sd_co_flush_to_disk(BlockDriverState *bs)\n{", "BDRVSheepdogState *s = bs->opaque;", "SheepdogObjReq hdr = { 0 };", "SheepdogObjRsp *rsp = (SheepdogObjRsp *)&hdr;", "SheepdogInode *inode = &s->inode;", "int ret;", "unsigned int wlen = 0, rlen = 0;", "if (s->cache_flags != SD_FLAG_CMD_CACHE) {", "return 0;", "}", "hdr.opcode = SD_OP_FLUSH_VDI;", "hdr.oid = vid_to_vdi_oid(inode->vdi_id);", "ret = do_req(s->flush_fd, (SheepdogReq *)&hdr, NULL, &wlen, &rlen);", "if (ret) {", "error_report(\"failed to send a request to the sheep\");", "return ret;", "}", "if (rsp->result == SD_RES_INVALID_PARMS) {", "dprintf(\"disable write cache since the server doesn't support it\\n\");", "s->cache_flags = SD_FLAG_CMD_DIRECT;", "closesocket(s->flush_fd);", "return 0;", "}", "if (rsp->result != SD_RES_SUCCESS) {", "error_report(\"%s\", sd_strerror(rsp->result));", "return -EIO;", "}", "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 ]

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

[ "int FUNC_0(CPUState *VAR_0, target_ulong VAR_1,\ntarget_phys_addr_t VAR_2, int VAR_3,\nint VAR_4, int VAR_5)\n{", "PhysPageDesc *p;", "unsigned long VAR_6;", "unsigned int VAR_7;", "target_ulong address;", "target_ulong code_address;", "target_phys_addr_t addend;", "int VAR_8;", "CPUTLBEntry *te;", "CPUWatchpoint *wp;", "target_phys_addr_t iotlb;", "p = phys_page_find(VAR_2 >> TARGET_PAGE_BITS);", "if (!p) {", "VAR_6 = IO_MEM_UNASSIGNED;", "} else {", "VAR_6 = p->phys_offset;", "}", "#if defined(DEBUG_TLB)\nprintf(\"tlb_set_page: VAR_1=\" TARGET_FMT_lx \" VAR_2=0x%08x VAR_3=%x idx=%d smmu=%d VAR_6=0x%08lx\\n\",\nVAR_1, (int)VAR_2, VAR_3, VAR_4, VAR_5, VAR_6);", "#endif\nVAR_8 = 0;", "address = VAR_1;", "if ((VAR_6 & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(VAR_6 & IO_MEM_ROMD)) {", "address |= TLB_MMIO;", "}", "addend = (unsigned long)qemu_get_ram_ptr(VAR_6 & TARGET_PAGE_MASK);", "if ((VAR_6 & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {", "iotlb = VAR_6 & TARGET_PAGE_MASK;", "if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_RAM)\niotlb |= IO_MEM_NOTDIRTY;", "else\niotlb |= IO_MEM_ROM;", "} else {", "iotlb = (VAR_6 & ~TARGET_PAGE_MASK);", "if (p) {", "iotlb += p->region_offset;", "} else {", "iotlb += VAR_2;", "}", "}", "code_address = address;", "TAILQ_FOREACH(wp, &VAR_0->watchpoints, entry) {", "if (VAR_1 == (wp->VAR_1 & TARGET_PAGE_MASK)) {", "iotlb = io_mem_watch + VAR_2;", "address |= TLB_MMIO;", "}", "}", "VAR_7 = (VAR_1 >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);", "VAR_0->iotlb[VAR_4][VAR_7] = iotlb - VAR_1;", "te = &VAR_0->tlb_table[VAR_4][VAR_7];", "te->addend = addend - VAR_1;", "if (VAR_3 & PAGE_READ) {", "te->addr_read = address;", "} else {", "te->addr_read = -1;", "}", "if (VAR_3 & PAGE_EXEC) {", "te->addr_code = code_address;", "} else {", "te->addr_code = -1;", "}", "if (VAR_3 & PAGE_WRITE) {", "if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||\n(VAR_6 & IO_MEM_ROMD)) {", "te->addr_write = address | TLB_MMIO;", "} else if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&", "!cpu_physical_memory_is_dirty(VAR_6)) {", "te->addr_write = address | TLB_NOTDIRTY;", "} else {", "te->addr_write = address;", "}", "} else {", "te->addr_write = -1;", "}", "return VAR_8;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43, 45, 47 ], [ 49, 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73, 75 ], [ 77, 79 ], [ 81 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 117 ], [ 119 ], [ 121 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ] ]

[ "int FUNC_0(QemuOpts *VAR_0, Monitor *VAR_1, const char *VAR_2, VLANState *VAR_3)\n{", "TAPState *s;", "int VAR_4, VAR_5 = 0;", "if (qemu_opt_get(VAR_0, \"VAR_4\")) {", "if (qemu_opt_get(VAR_0, \"VAR_6\") ||\nqemu_opt_get(VAR_0, \"VAR_7\") ||\nqemu_opt_get(VAR_0, \"VAR_8\") ||\nqemu_opt_get(VAR_0, \"VAR_5\")) {", "qemu_error(\"VAR_6=, VAR_7=, VAR_8= and VAR_5= is invalid with VAR_4=\\n\");", "return -1;", "}", "VAR_4 = net_handle_fd_param(VAR_1, qemu_opt_get(VAR_0, \"VAR_4\"));", "if (VAR_4 == -1) {", "return -1;", "}", "fcntl(VAR_4, F_SETFL, O_NONBLOCK);", "VAR_5 = tap_probe_vnet_hdr(VAR_4);", "} else {", "if (!qemu_opt_get(VAR_0, \"VAR_7\")) {", "qemu_opt_set(VAR_0, \"VAR_7\", DEFAULT_NETWORK_SCRIPT);", "}", "if (!qemu_opt_get(VAR_0, \"VAR_8\")) {", "qemu_opt_set(VAR_0, \"VAR_8\", DEFAULT_NETWORK_DOWN_SCRIPT);", "}", "VAR_4 = net_tap_init(VAR_0, &VAR_5);", "if (VAR_4 == -1) {", "return -1;", "}", "}", "s = net_tap_fd_init(VAR_3, \"tap\", VAR_2, VAR_4, VAR_5);", "if (!s) {", "close(VAR_4);", "return -1;", "}", "if (tap_set_sndbuf(s->VAR_4, VAR_0) < 0) {", "return -1;", "}", "if (qemu_opt_get(VAR_0, \"VAR_4\")) {", "snprintf(s->nc.info_str, sizeof(s->nc.info_str), \"VAR_4=%d\", VAR_4);", "} else {", "const char *VAR_6, *VAR_7, *VAR_8;", "VAR_6 = qemu_opt_get(VAR_0, \"VAR_6\");", "VAR_7 = qemu_opt_get(VAR_0, \"VAR_7\");", "VAR_8 = qemu_opt_get(VAR_0, \"VAR_8\");", "snprintf(s->nc.info_str, sizeof(s->nc.info_str),\n\"VAR_6=%s,VAR_7=%s,VAR_8=%s\",\nVAR_6, VAR_7, VAR_8);", "if (strcmp(VAR_8, \"no\") != 0) {", "snprintf(s->down_script, sizeof(s->down_script), \"%s\", VAR_8);", "snprintf(s->down_script_arg, sizeof(s->down_script_arg), \"%s\", VAR_6);", "}", "}", "if (VAR_3) {", "VAR_3->nb_host_devs++;", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13, 15, 17, 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 113, 115, 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ] ]

[ "uint16_t FUNC_0(ACPIREGS *ar)\n{", "int64_t d = acpi_pm_tmr_get_clock();", "if (d >= ar->tmr.overflow_time) {", "ar->pm1.evt.sts |= ACPI_BITMASK_TIMER_STATUS;", "}", "return ar->pm1.evt.sts;", "}" ]

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

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

[ "static void FUNC_0(uint16_t *VAR_0, const uint16_t *VAR_1,\nint VAR_2, int VAR_3,\nint VAR_4, int VAR_5, int VAR_6,\nconst uint8_t VAR_7[8][8])\n{", "int VAR_8, VAR_9;", "#define STORE16(pos) do { \\", "temp = ((VAR_1[VAR_9 + VAR_8*VAR_3 + pos] << VAR_6) + (d[pos]>>1)) >> 5; \\", "if (temp & 0x400) \\\ntemp = ~(temp >> 31); \\", "VAR_0[VAR_9 + VAR_8*VAR_2 + pos] = temp; \\", "} while (0)", "for (VAR_8 = 0; VAR_8 < VAR_5; VAR_8++) {", "const uint8_t *d = VAR_7[VAR_8];", "for (VAR_9 = 0; VAR_9 < VAR_4; VAR_9 += 8) {", "int temp;", "STORE16(0);", "STORE16(1);", "STORE16(2);", "STORE16(3);", "STORE16(4);", "STORE16(5);", "STORE16(6);", "STORE16(7);", "}", "}", "}" ]

[ 1, 0, 0, 0, 1, 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 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "void FUNC_0(CPUState *VAR_0, hwaddr VAR_1,\nbool VAR_2, bool VAR_3, int VAR_4,\nunsigned VAR_5)\n{", "MIPSCPU *cpu = MIPS_CPU(VAR_0);", "CPUMIPSState *env = &cpu->env;", "if (VAR_3) {", "helper_raise_exception(env, EXCP_IBE);", "} else {", "helper_raise_exception(env, EXCP_DBE);" ]

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

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

[ "void FUNC_0(struct pxa2xx_keypad_s *VAR_0, struct keymap *VAR_1,\nint VAR_2)\n{", "VAR_0->VAR_1 = (struct keymap *) qemu_mallocz(sizeof(struct keymap) * VAR_2);", "if(!VAR_1 || VAR_2 < 0x80) {", "fprintf(stderr, \"%s - No PXA keypad VAR_1 defined\\n\", __FUNCTION__);", "exit(-1);", "}", "VAR_0->VAR_1 = VAR_1;", "qemu_add_kbd_event_handler((QEMUPutKBDEvent *) pxa27x_keyboard_event, VAR_0);", "}" ]

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

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

[ "static void FUNC_0(Object *VAR_0)\n{", "VirtIORNG *vrng = VIRTIO_RNG(VAR_0);", "object_property_add_link(VAR_0, \"rng\", TYPE_RNG_BACKEND,\n(Object **)&vrng->conf.rng, NULL);", "}" ]

[ 0, 0, 1, 0 ]

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

[ "FUNC_0(const struct syscallname *VAR_0,\nabi_long VAR_1, abi_long VAR_2, abi_long VAR_3,\nabi_long VAR_4, abi_long VAR_5, abi_long VAR_6)\n{", "abi_ulong arg_ptr_addr;", "char *VAR_7;", "if (!(VAR_7 = lock_user_string(VAR_1)))\nreturn;", "gemu_log(\"%VAR_7(\\\"%VAR_7\\\",{\", VAR_0->VAR_0, VAR_7);", "unlock_user(VAR_7, VAR_1, 0);", "for (arg_ptr_addr = VAR_2; ; arg_ptr_addr += sizeof(abi_ulong)) {", "abi_ulong *arg_ptr, arg_addr, s_addr;", "arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);", "if (!arg_ptr)\nreturn;", "arg_addr = tswapl(*arg_ptr);", "unlock_user(arg_ptr, arg_ptr_addr, 0);", "if (!arg_addr)\nbreak;", "if ((VAR_7 = lock_user_string(arg_addr))) {", "gemu_log(\"\\\"%VAR_7\\\",\", VAR_7);", "unlock_user(VAR_7, s_addr, 0);", "}", "}", "gemu_log(\"NULL})\");", "}" ]

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

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

[ "DECLARE_LOOP_FILTER(mmxext)\nDECLARE_LOOP_FILTER(sse2)\nDECLARE_LOOP_FILTER(ssse3)\n#endif\n#define VP8_LUMA_MC_FUNC(IDX, SIZE, OPT) \\\nc->put_vp8_epel_pixels_tab[IDX][0][2] = ff_put_vp8_epel ## SIZE ## _h6_ ## OPT; \\", "c->put_vp8_epel_pixels_tab[IDX][2][0] = ff_put_vp8_epel ## SIZE ## _v6_ ## OPT; \\", "c->put_vp8_epel_pixels_tab[IDX][2][2] = ff_put_vp8_epel ## SIZE ## _h6v6_ ## OPT\n#define VP8_MC_FUNC(IDX, SIZE, OPT) \\\nc->put_vp8_epel_pixels_tab[IDX][0][1] = ff_put_vp8_epel ## SIZE ## _h4_ ## OPT; \\", "c->put_vp8_epel_pixels_tab[IDX][1][0] = ff_put_vp8_epel ## SIZE ## _v4_ ## OPT; \\", "c->put_vp8_epel_pixels_tab[IDX][1][1] = ff_put_vp8_epel ## SIZE ## _h4v4_ ## OPT; \\", "c->put_vp8_epel_pixels_tab[IDX][1][2] = ff_put_vp8_epel ## SIZE ## _h6v4_ ## OPT; \\", "c->put_vp8_epel_pixels_tab[IDX][2][1] = ff_put_vp8_epel ## SIZE ## _h4v6_ ## OPT; \\", "VP8_LUMA_MC_FUNC(IDX, SIZE, OPT)\n#define VP8_BILINEAR_MC_FUNC(IDX, SIZE, OPT) \\\nc->put_vp8_bilinear_pixels_tab[IDX][0][1] = ff_put_vp8_bilinear ## SIZE ## _h_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][0][2] = ff_put_vp8_bilinear ## SIZE ## _h_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][1][0] = ff_put_vp8_bilinear ## SIZE ## _v_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][1][1] = ff_put_vp8_bilinear ## SIZE ## _hv_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][1][2] = ff_put_vp8_bilinear ## SIZE ## _hv_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][2][0] = ff_put_vp8_bilinear ## SIZE ## _v_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][2][1] = ff_put_vp8_bilinear ## SIZE ## _hv_ ## OPT; \\", "c->put_vp8_bilinear_pixels_tab[IDX][2][2] = ff_put_vp8_bilinear ## SIZE ## _hv_ ## OPT\nav_cold void ff_vp8dsp_init_x86(VP8DSPContext* c)\n{", "mm_flags = mm_support();", "#if HAVE_YASM\nif (mm_flags & FF_MM_MMX) {", "c->vp8_idct_dc_add = ff_vp8_idct_dc_add_mmx;", "c->vp8_idct_add = ff_vp8_idct_add_mmx;", "c->vp8_luma_dc_wht = ff_vp8_luma_dc_wht_mmx;", "c->put_vp8_epel_pixels_tab[0][0][0] =\nc->put_vp8_bilinear_pixels_tab[0][0][0] = ff_put_vp8_pixels16_mmx;", "c->put_vp8_epel_pixels_tab[1][0][0] =\nc->put_vp8_bilinear_pixels_tab[1][0][0] = ff_put_vp8_pixels8_mmx;", "c->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter_simple_mmx;", "c->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter_simple_mmx;", "c->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16y_inner_mmx;", "c->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16y_inner_mmx;", "c->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_mmx;", "c->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_mmx;", "c->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16y_mbedge_mmx;", "c->vp8_h_loop_filter16y = ff_vp8_h_loop_filter16y_mbedge_mmx;", "c->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_mbedge_mmx;", "c->vp8_h_loop_filter8uv = ff_vp8_h_loop_filter8uv_mbedge_mmx;", "}", "if (mm_flags & FF_MM_MMX2) {", "VP8_LUMA_MC_FUNC(0, 16, mmxext);", "VP8_MC_FUNC(1, 8, mmxext);", "VP8_MC_FUNC(2, 4, mmxext);", "VP8_BILINEAR_MC_FUNC(0, 16, mmxext);", "VP8_BILINEAR_MC_FUNC(1, 8, mmxext);", "VP8_BILINEAR_MC_FUNC(2, 4, mmxext);", "c->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter_simple_mmxext;", "c->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter_simple_mmxext;", "c->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16y_inner_mmxext;", "c->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16y_inner_mmxext;", "c->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_mmxext;", "c->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_mmxext;", "c->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16y_mbedge_mmxext;", "c->vp8_h_loop_filter16y = ff_vp8_h_loop_filter16y_mbedge_mmxext;", "c->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_mbedge_mmxext;", "c->vp8_h_loop_filter8uv = ff_vp8_h_loop_filter8uv_mbedge_mmxext;", "}", "if (mm_flags & FF_MM_SSE) {", "c->put_vp8_epel_pixels_tab[0][0][0] =\nc->put_vp8_bilinear_pixels_tab[0][0][0] = ff_put_vp8_pixels16_sse;", "}", "if (mm_flags & (FF_MM_SSE2|FF_MM_SSE2SLOW)) {", "VP8_LUMA_MC_FUNC(0, 16, sse2);", "VP8_MC_FUNC(1, 8, sse2);", "VP8_BILINEAR_MC_FUNC(0, 16, sse2);", "VP8_BILINEAR_MC_FUNC(1, 8, sse2);", "c->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter_simple_sse2;", "c->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter_simple_sse2;", "c->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16y_inner_sse2;", "c->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_sse2;", "c->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16y_mbedge_mmxext;", "c->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_mbedge_mmxext;", "}", "if (mm_flags & FF_MM_SSE2) {", "c->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16y_inner_sse2;", "c->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_sse2;", "}", "if (mm_flags & FF_MM_SSSE3) {", "VP8_LUMA_MC_FUNC(0, 16, ssse3);", "VP8_MC_FUNC(1, 8, ssse3);", "VP8_MC_FUNC(2, 4, ssse3);", "VP8_BILINEAR_MC_FUNC(0, 16, ssse3);", "VP8_BILINEAR_MC_FUNC(1, 8, ssse3);", "VP8_BILINEAR_MC_FUNC(2, 4, ssse3);", "c->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter_simple_ssse3;", "c->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter_simple_ssse3;", "c->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16y_inner_ssse3;", "c->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16y_inner_ssse3;", "c->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_ssse3;", "c->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_ssse3;", "c->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16y_mbedge_ssse3;", "c->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_mbedge_ssse3;", "}", "if (mm_flags & FF_MM_SSE4) {", "c->vp8_idct_dc_add = ff_vp8_idct_dc_add_sse4;", "}", "#endif\n}" ]

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

[ [ 1, 3, 5, 9, 13, 15 ], [ 17 ], [ 19, 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 61, 63 ], [ 65 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83, 85 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167, 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 239 ], [ 241 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 255 ], [ 259 ], [ 263 ], [ 267 ], [ 269 ], [ 271 ], [ 273, 275 ] ]

[ "void FUNC_0(PNGDSPContext *VAR_0)\n{", "#if HAVE_YASM\nint flags = av_get_cpu_flags();", "#if ARCH_X86_32\nif (flags & AV_CPU_FLAG_MMX)\nVAR_0->add_bytes_l2 = ff_add_bytes_l2_mmx;", "#endif\nif (flags & AV_CPU_FLAG_MMXEXT)\nVAR_0->add_paeth_prediction = ff_add_png_paeth_prediction_mmx2;", "if (flags & AV_CPU_FLAG_SSE2)\nVAR_0->add_bytes_l2 = ff_add_bytes_l2_sse2;", "if (flags & AV_CPU_FLAG_SSSE3)\nVAR_0->add_paeth_prediction = ff_add_png_paeth_prediction_ssse3;", "#endif\n}" ]

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

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

[ "static int FUNC_0(Indeo3DecodeContext *VAR_0, AVCodecContext *VAR_1,\nPlane *VAR_2, const uint8_t *VAR_3, int32_t VAR_4,\nint32_t VAR_5)\n{", "Cell curr_cell;", "int VAR_6;", "VAR_6 = bytestream_get_le32(&VAR_3);", "VAR_0->mc_vectors = VAR_6 ? VAR_3 : 0;", "init_get_bits(&VAR_0->gb, &VAR_3[VAR_6 * 2], VAR_4 << 3);", "VAR_0->skip_bits = 0;", "VAR_0->need_resync = 0;", "VAR_0->last_byte = VAR_3 + VAR_4 - 1;", "curr_cell.xpos = curr_cell.ypos = 0;", "curr_cell.width = VAR_2->width >> 2;", "curr_cell.height = VAR_2->height >> 2;", "curr_cell.tree = 0;", "curr_cell.mv_ptr = 0;", "return parse_bintree(VAR_0, VAR_1, VAR_2, INTRA_NULL, &curr_cell, CELL_STACK_MAX, VAR_5);", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 19 ], [ 21 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ] ]

[ "static void FUNC_0(QPCIBus *VAR_0, int VAR_1, uint8_t VAR_2, uint32_t VAR_3)\n{", "outl(0xcf8, (1 << 31) | (VAR_1 << 8) | VAR_2);", "outl(0xcfc, VAR_3);", "}" ]

[ 0, 1, 0, 0 ]

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

[ "static char *FUNC_0(int VAR_0, int VAR_1)\n{", "char *VAR_2;", "if (VAR_1 == TIFF_GEO_KEY_UNDEFINED)\nreturn av_strdup(\"undefined\");", "if (VAR_1 == TIFF_GEO_KEY_USER_DEFINED)\nreturn av_strdup(\"User-Defined\");", "#define RET_GEOKEY_VAL(TYPE, array)\\\nif (VAR_1 >= TIFF_##TYPE##_OFFSET &&\\\nVAR_1 - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\\\nreturn av_strdup(ff_tiff_##array##_codes[VAR_1 - TIFF_##TYPE##_OFFSET]);", "switch (VAR_0) {", "case TIFF_GT_MODEL_TYPE_GEOKEY:\nRET_GEOKEY_VAL(GT_MODEL_TYPE, gt_model_type);", "break;", "case TIFF_GT_RASTER_TYPE_GEOKEY:\nRET_GEOKEY_VAL(GT_RASTER_TYPE, gt_raster_type);", "break;", "case TIFF_GEOG_LINEAR_UNITS_GEOKEY:\ncase TIFF_PROJ_LINEAR_UNITS_GEOKEY:\ncase TIFF_VERTICAL_UNITS_GEOKEY:\nRET_GEOKEY_VAL(LINEAR_UNIT, linear_unit);", "break;", "case TIFF_GEOG_ANGULAR_UNITS_GEOKEY:\ncase TIFF_GEOG_AZIMUTH_UNITS_GEOKEY:\nRET_GEOKEY_VAL(ANGULAR_UNIT, angular_unit);", "break;", "case TIFF_GEOGRAPHIC_TYPE_GEOKEY:\nRET_GEOKEY_VAL(GCS_TYPE, gcs_type);", "RET_GEOKEY_VAL(GCSE_TYPE, gcse_type);", "break;", "case TIFF_GEOG_GEODETIC_DATUM_GEOKEY:\nRET_GEOKEY_VAL(GEODETIC_DATUM, geodetic_datum);", "RET_GEOKEY_VAL(GEODETIC_DATUM_E, geodetic_datum_e);", "break;", "case TIFF_GEOG_ELLIPSOID_GEOKEY:\nRET_GEOKEY_VAL(ELLIPSOID, ellipsoid);", "break;", "case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY:\nRET_GEOKEY_VAL(PRIME_MERIDIAN, prime_meridian);", "break;", "case TIFF_PROJECTED_CS_TYPE_GEOKEY:\nreturn av_strdup(search_keyval(ff_tiff_proj_cs_type_codes, FF_ARRAY_ELEMS(ff_tiff_proj_cs_type_codes), VAR_1));", "break;", "case TIFF_PROJECTION_GEOKEY:\nreturn av_strdup(search_keyval(ff_tiff_projection_codes, FF_ARRAY_ELEMS(ff_tiff_projection_codes), VAR_1));", "break;", "case TIFF_PROJ_COORD_TRANS_GEOKEY:\nRET_GEOKEY_VAL(COORD_TRANS, coord_trans);", "break;", "case TIFF_VERTICAL_CS_TYPE_GEOKEY:\nRET_GEOKEY_VAL(VERT_CS, vert_cs);", "RET_GEOKEY_VAL(ORTHO_VERT_CS, ortho_vert_cs);", "break;", "}", "VAR_2 = av_malloc(14);", "if (VAR_2)\nsnprintf(VAR_2, 14, \"Unknown-%d\", VAR_1);", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 13, 15 ], [ 19, 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 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101, 103 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 117 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129 ] ]

[ "void FUNC_0(DSPContext* VAR_0, AVCodecContext *VAR_1)\n{", "VAR_0->vector_fmul = vector_fmul_vfp;", "VAR_0->vector_fmul_reverse = vector_fmul_reverse_vfp;", "#ifdef HAVE_ARMV6\nVAR_0->float_to_int16 = float_to_int16_vfp;", "#endif\n}" ]

[ 1, 1, 1, 1, 1 ]

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

[ "static inline int64_t FUNC_0(BlockDriverState *bs,\nint64_t sector_num, int write)\n{", "BDRVVPCState *s = bs->opaque;", "uint64_t offset = sector_num * 512;", "uint64_t bitmap_offset, block_offset;", "uint32_t pagetable_index, pageentry_index;", "pagetable_index = offset / s->block_size;", "pageentry_index = (offset % s->block_size) / 512;", "if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)\nreturn -1;", "bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];", "block_offset = bitmap_offset + s->bitmap_size + (512 * pageentry_index);", "if (write && (s->last_bitmap_offset != bitmap_offset)) {", "uint8_t bitmap[s->bitmap_size];", "s->last_bitmap_offset = bitmap_offset;", "memset(bitmap, 0xff, s->bitmap_size);", "bdrv_pwrite(bs->file, bitmap_offset, bitmap, s->bitmap_size);", "}", "#if 0\n#ifdef CACHE\nif (bitmap_offset != s->last_bitmap)\n{", "lseek(s->fd, bitmap_offset, SEEK_SET);", "s->last_bitmap = bitmap_offset;", "read(s->fd, s->pageentry_u8, 512);", "for (i = 0; i < 128; i++)", "be32_to_cpus(&s->pageentry_u32[i]);", "}", "if ((s->pageentry_u8[pageentry_index / 8] >> (pageentry_index % 8)) & 1)\nreturn -1;", "#else\nlseek(s->fd, bitmap_offset + (pageentry_index / 8), SEEK_SET);", "read(s->fd, &bitmap_entry, 1);", "if ((bitmap_entry >> (pageentry_index % 8)) & 1)\nreturn -1;", "#endif\n#endif\nreturn block_offset;", "}" ]

[ 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 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 71, 73, 75, 77 ], [ 79 ], [ 83 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101, 103 ], [ 105, 107 ], [ 111 ], [ 115, 117 ], [ 119, 121, 125 ], [ 127 ] ]

[ "static void VAR_0 wait_for_overlapping_requests(BlockDriverState *bs,\nBdrvTrackedRequest *self, int64_t offset, unsigned int bytes)\n{", "BdrvTrackedRequest *req;", "int64_t cluster_offset;", "unsigned int cluster_bytes;", "bool retry;", "round_bytes_to_clusters(bs, offset, bytes, &cluster_offset, &cluster_bytes);", "do {", "retry = false;", "QLIST_FOREACH(req, &bs->tracked_requests, list) {", "if (req == self) {", "continue;", "}", "if (tracked_request_overlaps(req, cluster_offset, cluster_bytes)) {", "assert(qemu_coroutine_self() != req->co);", "qemu_co_queue_wait(&req->wait_queue);", "retry = true;", "break;", "}", "}", "} while (retry);", "}" ]

[ 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 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ] ]

[ "static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)\n{", "unsigned int VAR_2, VAR_3, VAR_4;", "uint64_t addr;", "int VAR_5;", "TCGv_i64 tcg_cmp;", "VAR_2 = extract32(VAR_1, 31, 1);", "VAR_3 = extract32(VAR_1, 24, 1);", "VAR_4 = extract32(VAR_1, 0, 5);", "addr = VAR_0->pc + sextract32(VAR_1, 5, 19) * 4 - 4;", "tcg_cmp = read_cpu_reg(VAR_0, VAR_4, VAR_2);", "VAR_5 = gen_new_label();", "tcg_gen_brcondi_i64(VAR_3 ? TCG_COND_NE : TCG_COND_EQ,\ntcg_cmp, 0, VAR_5);", "gen_goto_tb(VAR_0, 0, VAR_0->pc);", "gen_set_label(VAR_5);", "gen_goto_tb(VAR_0, 1, addr);", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t offset,\nunsigned size)\n{", "integratorcm_state *s = (integratorcm_state *)opaque;", "if (offset >= 0x100 && offset < 0x200) {", "if (offset >= 0x180)\nreturn 0;", "return integrator_spd[offset >> 2];", "}", "switch (offset >> 2) {", "case 0:\nreturn 0x411a3001;", "case 1:\nreturn 0;", "case 2:\nreturn s->cm_osc;", "case 3:\nreturn s->cm_ctrl;", "case 4:\nreturn 0x00100000;", "case 5:\nif (s->cm_lock == 0xa05f) {", "return 0x1a05f;", "} else {", "return s->cm_lock;", "}", "case 6:\nhw_error(\"FUNC_0: CM_LMBUSCNT\");", "case 7:\nreturn s->cm_auxosc;", "case 8:\nreturn s->cm_sdram;", "case 9:\nreturn s->cm_init;", "case 10:\nhw_error(\"FUNC_0: CM_REFCT\");", "case 12:\nreturn s->cm_flags;", "case 14:\nreturn s->cm_nvflags;", "case 16:\nreturn s->int_level & s->irq_enabled;", "case 17:\nreturn s->int_level;", "case 18:\nreturn s->irq_enabled;", "case 20:\nreturn s->int_level & 1;", "case 24:\nreturn s->int_level & s->fiq_enabled;", "case 25:\nreturn s->int_level;", "case 26:\nreturn s->fiq_enabled;", "case 32:\ncase 33:\ncase 34:\ncase 35:\nreturn 0;", "default:\nhw_error(\"FUNC_0: Unimplemented offset 0x%x\\n\",\n(int)offset);", "return 0;", "}", "}" ]

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

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