Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "long FUNC_0(CPUAlphaState *VAR_0)\n{", "struct target_sigcontext *VAR_1;", "abi_ulong sc_addr = VAR_0->ir[IR_A0];", "target_sigset_t target_set;", "sigset_t set;", "if (!lock_user_struct(VERIFY_READ, VAR_1, sc_addr, 1)) {", "goto badframe;", "}", "target_sigemptyset(&target_set);", "__get_user(target_set.sig[0], &VAR_1->sc_mask);", "target_to_host_sigset_internal(&set, &target_set);", "do_sigprocmask(SIG_SETMASK, &set, NULL);", "restore_sigcontext(VAR_0, VAR_1);", "unlock_user_struct(VAR_1, sc_addr, 0);", "return VAR_0->ir[IR_V0];", "badframe:\nforce_sig(TARGET_SIGSEGV);", "}" ]

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

[ "static bool FUNC_0(IDEState *s,\nuint64_t sector, uint64_t nb_sectors)\n{", "uint64_t total_sectors;", "bdrv_get_geometry(s->bs, &total_sectors);", "if (sector > total_sectors || nb_sectors > total_sectors - sector) {", "return false;", "}", "return true;", "}" ]

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

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

[ "int FUNC_0(BDRVQEDState *VAR_0, unsigned int VAR_1,\nunsigned int VAR_2)\n{", "int VAR_3 = -EINPROGRESS;", "async_context_push();", "qed_write_l1_table(VAR_0, VAR_1, VAR_2, qed_sync_cb, &VAR_3);", "while (VAR_3 == -EINPROGRESS) {", "qemu_aio_wait();", "}", "async_context_pop();", "return VAR_3;", "}" ]

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

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

[ "bool FUNC_0(MemoryRegion *mr, hwaddr addr,\nhwaddr size, unsigned client)\n{", "assert(mr->terminates);", "return cpu_physical_memory_get_dirty(mr->ram_addr + addr, size, client);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(NetFilterState *VAR_0, Error **VAR_1)\n{", "MirrorState *s = FILTER_MIRROR(VAR_0);", "if (!s->outdev) {", "error_setg(VAR_1, \"filter filter mirror needs 'outdev' \"\n\"property set\");", "return;", "}", "s->chr_out = qemu_chr_find(s->outdev);", "if (s->chr_out == NULL) {", "error_set(VAR_1, ERROR_CLASS_DEVICE_NOT_FOUND,\n\"Device '%s' not found\", s->outdev);", "return;", "}", "if (qemu_chr_fe_claim(s->chr_out) != 0) {", "error_setg(VAR_1, QERR_DEVICE_IN_USE, s->outdev);", "return;", "}", "}" ]

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

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

[ "static void FUNC_0(uint8_t *VAR_0, ram_addr_t VAR_1)\n{", "enum { SDR = 0x4, DDR2 = 0x8 } VAR_2;", "uint8_t *spd = spd_eeprom.contents;", "uint8_t nbanks = 0;", "uint16_t density = 0;", "int VAR_3;", "VAR_1 >>= 20;", "while ((VAR_1 >= 4) && (nbanks <= 2)) {", "int VAR_4 = MIN(31 - clz32(VAR_1), 14);", "nbanks++;", "density |= 1 << (VAR_4 - 2);", "VAR_1 -= 1 << VAR_4;", "}", "if ((nbanks == 1) && (density > 1)) {", "nbanks++;", "density >>= 1;", "}", "if (density & 0xff00) {", "density = (density & 0xe0) | ((density >> 8) & 0x1f);", "VAR_2 = DDR2;", "} else if (!(density & 0x1f)) {", "VAR_2 = DDR2;", "} else {", "VAR_2 = SDR;", "}", "if (VAR_1) {", "fprintf(stderr, \"Warning: SPD cannot represent final %dMB\"\n\" of SDRAM\\n\", (int)VAR_1);", "}", "spd[2] = VAR_2;", "spd[5] = nbanks;", "spd[31] = density;", "spd[63] = 0;", "for (VAR_3 = 0; VAR_3 < 63; VAR_3++) {", "spd[63] += spd[VAR_3];", "}", "memcpy(VAR_0, spd, sizeof(spd_eeprom.contents));", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 101 ], [ 103 ] ]

[ "static GenericList *FUNC_0(Visitor *v, GenericList *tail, size_t size)\n{", "StringInputVisitor *siv = to_siv(v);", "Range *r;", "if (!siv->ranges || !siv->cur_range) {", "return NULL;", "}", "r = siv->cur_range->data;", "if (!r) {", "return NULL;", "}", "if (siv->cur < r->begin || siv->cur >= r->end) {", "siv->cur_range = g_list_next(siv->cur_range);", "if (!siv->cur_range) {", "return NULL;", "}", "r = siv->cur_range->data;", "if (!r) {", "return NULL;", "}", "siv->cur = r->begin;", "}", "tail->next = g_malloc0(size);", "return tail->next;", "}" ]

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

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

[ "static int FUNC_0(AVFilterContext *VAR_0,\nAVFilterInOut **VAR_1,\nAVFilterInOut **VAR_2, void *VAR_3)\n{", "int VAR_4, VAR_5;", "for (VAR_4 = 0; VAR_4 < VAR_0->input_count; VAR_4++) {", "AVFilterInOut *p = *VAR_1;", "if (p)\n*VAR_1 = (*VAR_1)->next;", "else if (!(p = av_mallocz(sizeof(*p))))\nreturn AVERROR(ENOMEM);", "if (p->filter_ctx) {", "if ((VAR_5 = link_filter(p->filter_ctx, p->pad_idx, VAR_0, VAR_4, VAR_3)) < 0)\nreturn VAR_5;", "av_free(p->name);", "av_free(p);", "} else {", "p->filter_ctx = VAR_0;", "p->pad_idx = VAR_4;", "append_inout(VAR_2, &p);", "}", "}", "if (*VAR_1) {", "av_log(VAR_3, AV_LOG_ERROR,\n\"Too many inputs specified for the \\\"%s\\\" filter.\\n\",\nVAR_0->filter->name);", "return AVERROR(EINVAL);", "}", "VAR_4 = VAR_0->output_count;", "while (VAR_4--) {", "AVFilterInOut *currlinkn = av_mallocz(sizeof(AVFilterInOut));", "if (!currlinkn)\nreturn AVERROR(ENOMEM);", "currlinkn->filter_ctx = VAR_0;", "currlinkn->pad_idx = VAR_4;", "insert_inout(VAR_1, currlinkn);", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(hwaddr VAR_0,\nhwaddr VAR_1)\n{", "if (cpu_physical_memory_range_includes_clean(VAR_0, VAR_1)) {", "tb_invalidate_phys_range(VAR_0, VAR_0 + VAR_1, 0);", "cpu_physical_memory_set_dirty_range_nocode(VAR_0, VAR_1);", "}", "xen_modified_memory(VAR_0, VAR_1);", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nconst char *VAR_2, int VAR_3)\n{", "int VAR_4;", "V9fsString fullname;", "v9fs_string_init(&fullname);", "v9fs_string_sprintf(&fullname, \"%s/%s\", VAR_1->data, VAR_2);", "VAR_4 = proxy_remove(VAR_0, fullname.data);", "v9fs_string_free(&fullname);", "return VAR_4;", "}" ]

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

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

[ "void FUNC_0(DeviceState *VAR_0, Error **VAR_1,\nVirtIOHandleOutput VAR_2,\nVirtIOHandleOutput VAR_3,\nVirtIOHandleOutput VAR_4)\n{", "VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);", "VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(VAR_0);", "int VAR_5;", "virtio_init(vdev, \"virtio-scsi\", VIRTIO_ID_SCSI,\nsizeof(VirtIOSCSIConfig));", "if (s->conf.num_queues == 0 ||\ns->conf.num_queues > VIRTIO_QUEUE_MAX - 2) {", "error_setg(VAR_1, \"Invalid number of queues (= %\" PRIu32 \"), \"\n\"must be a positive integer less than %d.\",\ns->conf.num_queues, VIRTIO_QUEUE_MAX - 2);", "virtio_cleanup(vdev);", "return;", "}", "s->cmd_vqs = g_new0(VirtQueue *, s->conf.num_queues);", "s->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;", "s->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;", "s->ctrl_vq = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, VAR_2);", "s->event_vq = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, VAR_3);", "for (VAR_5 = 0; VAR_5 < s->conf.num_queues; VAR_5++) {", "s->cmd_vqs[VAR_5] = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, VAR_4);", "}", "if (s->conf.iothread) {", "virtio_scsi_set_iothread(VIRTIO_SCSI(s), s->conf.iothread);", "}", "}" ]

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

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

[ "static inline void FUNC_0(SPARCCPU *VAR_0,\nTranslationBlock *VAR_1,\nbool VAR_2)\n{", "CPUState *cs = CPU(VAR_0);", "CPUSPARCState *env = &VAR_0->env;", "target_ulong pc_start, last_pc;", "uint16_t *gen_opc_end;", "DisasContext dc1, *dc = &dc1;", "CPUBreakpoint *bp;", "int VAR_3, VAR_4 = -1;", "int VAR_5;", "int VAR_6;", "unsigned int VAR_7;", "memset(dc, 0, sizeof(DisasContext));", "dc->VAR_1 = VAR_1;", "pc_start = VAR_1->pc;", "dc->pc = pc_start;", "last_pc = dc->pc;", "dc->npc = (target_ulong) VAR_1->cs_base;", "dc->cc_op = CC_OP_DYNAMIC;", "dc->mem_idx = cpu_mmu_index(env);", "dc->def = env->def;", "dc->fpu_enabled = tb_fpu_enabled(VAR_1->flags);", "dc->address_mask_32bit = tb_am_enabled(VAR_1->flags);", "dc->singlestep = (cs->singlestep_enabled || singlestep);", "gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;", "VAR_5 = 0;", "VAR_6 = VAR_1->cflags & CF_COUNT_MASK;", "if (VAR_6 == 0)\nVAR_6 = CF_COUNT_MASK;", "gen_tb_start();", "do {", "if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) {", "QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {", "if (bp->pc == dc->pc) {", "if (dc->pc != pc_start)\nsave_state(dc);", "gen_helper_debug(cpu_env);", "tcg_gen_exit_tb(0);", "dc->is_br = 1;", "goto exit_gen_loop;", "}", "}", "}", "if (VAR_2) {", "qemu_log(\"Search PC...\\n\");", "VAR_3 = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;", "if (VAR_4 < VAR_3) {", "VAR_4++;", "while (VAR_4 < VAR_3)\ntcg_ctx.gen_opc_instr_start[VAR_4++] = 0;", "tcg_ctx.gen_opc_pc[VAR_4] = dc->pc;", "gen_opc_npc[VAR_4] = dc->npc;", "tcg_ctx.gen_opc_instr_start[VAR_4] = 1;", "tcg_ctx.gen_opc_icount[VAR_4] = VAR_5;", "}", "}", "if (VAR_5 + 1 == VAR_6 && (VAR_1->cflags & CF_LAST_IO))\ngen_io_start();", "last_pc = dc->pc;", "VAR_7 = cpu_ldl_code(env, dc->pc);", "disas_sparc_insn(dc, VAR_7);", "VAR_5++;", "if (dc->is_br)\nbreak;", "if (dc->pc != (last_pc + 4))\nbreak;", "if ((dc->pc & (TARGET_PAGE_SIZE - 1)) == 0)\nbreak;", "if (dc->singlestep) {", "break;", "}", "} while ((tcg_ctx.gen_opc_ptr < gen_opc_end) &&", "(dc->pc - pc_start) < (TARGET_PAGE_SIZE - 32) &&\nVAR_5 < VAR_6);", "exit_gen_loop:\nif (VAR_1->cflags & CF_LAST_IO) {", "gen_io_end();", "}", "if (!dc->is_br) {", "if (dc->pc != DYNAMIC_PC &&\n(dc->npc != DYNAMIC_PC && dc->npc != JUMP_PC)) {", "gen_goto_tb(dc, 0, dc->pc, dc->npc);", "} else {", "if (dc->pc != DYNAMIC_PC) {", "tcg_gen_movi_tl(cpu_pc, dc->pc);", "}", "save_npc(dc);", "tcg_gen_exit_tb(0);", "}", "}", "gen_tb_end(VAR_1, VAR_5);", "*tcg_ctx.gen_opc_ptr = INDEX_op_end;", "if (VAR_2) {", "VAR_3 = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;", "VAR_4++;", "while (VAR_4 <= VAR_3)\ntcg_ctx.gen_opc_instr_start[VAR_4++] = 0;", "#if 0\nlog_page_dump();", "#endif\ngen_opc_jump_pc[0] = dc->jump_pc[0];", "gen_opc_jump_pc[1] = dc->jump_pc[1];", "} else {", "VAR_1->size = last_pc + 4 - pc_start;", "VAR_1->icount = VAR_5;", "}", "#ifdef DEBUG_DISAS\nif (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {", "qemu_log(\"--------------\\n\");", "qemu_log(\"IN: %s\\n\", lookup_symbol(pc_start));", "log_target_disas(env, pc_start, last_pc + 4 - pc_start, 0);", "qemu_log(\"\\n\");", "}", "#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, 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 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 137, 139 ], [ 143, 145 ], [ 151, 153 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183, 185 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217, 219 ], [ 221, 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239, 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253, 255 ] ]

[ "static int FUNC_0(const char *VAR_0, hwaddr *VAR_1, hwaddr *VAR_2,\nint *VAR_3, uint8_t VAR_4,\nVAR_5 (*translate_fn)(void *, VAR_5),\nvoid *VAR_6)\n{", "int VAR_7;", "int VAR_8;", "hwaddr address;", "uboot_image_header_t h;", "uboot_image_header_t *hdr = &h;", "uint8_t *data = NULL;", "int VAR_9 = -1;", "int VAR_10 = 0;", "VAR_7 = open(VAR_0, O_RDONLY | O_BINARY);", "if (VAR_7 < 0)\nreturn -1;", "VAR_8 = read(VAR_7, hdr, sizeof(uboot_image_header_t));", "if (VAR_8 < 0)\ngoto out;", "bswap_uboot_header(hdr);", "if (hdr->ih_magic != IH_MAGIC)\ngoto out;", "if (hdr->ih_type != VAR_4) {", "fprintf(stderr, \"Wrong image type %d, expected %d\\n\", hdr->ih_type,\nVAR_4);", "goto out;", "}", "switch (hdr->ih_type) {", "case IH_TYPE_KERNEL:\naddress = hdr->ih_load;", "if (translate_fn) {", "address = translate_fn(VAR_6, address);", "}", "if (VAR_2) {", "*VAR_2 = hdr->ih_load;", "}", "switch (hdr->ih_comp) {", "case IH_COMP_NONE:\nbreak;", "case IH_COMP_GZIP:\nVAR_10 = 1;", "break;", "default:\nfprintf(stderr,\n\"Unable to load u-boot images with compression type %d\\n\",\nhdr->ih_comp);", "goto out;", "}", "if (VAR_1) {", "*VAR_1 = hdr->ih_ep;", "}", "if (VAR_3) {", "if (hdr->ih_os == IH_OS_LINUX) {", "*VAR_3 = 1;", "} else {", "*VAR_3 = 0;", "}", "}", "break;", "case IH_TYPE_RAMDISK:\naddress = *VAR_2;", "break;", "default:\nfprintf(stderr, \"Unsupported u-boot image type %d\\n\", hdr->ih_type);", "goto out;", "}", "data = g_malloc(hdr->ih_size);", "if (read(VAR_7, data, hdr->ih_size) != hdr->ih_size) {", "fprintf(stderr, \"Error reading file\\n\");", "goto out;", "}", "if (VAR_10) {", "uint8_t *compressed_data;", "size_t max_bytes;", "ssize_t bytes;", "compressed_data = data;", "max_bytes = UBOOT_MAX_GUNZIP_BYTES;", "data = g_malloc(max_bytes);", "bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);", "g_free(compressed_data);", "if (bytes < 0) {", "fprintf(stderr, \"Unable to decompress gzipped image!\\n\");", "goto out;", "}", "hdr->ih_size = bytes;", "}", "rom_add_blob_fixed(VAR_0, data, hdr->ih_size, address);", "VAR_9 = hdr->ih_size;", "out:\nif (data)\ng_free(data);", "close(VAR_7);", "return VAR_9;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 37 ], [ 39, 41 ], [ 45 ], [ 49, 51 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91, 93 ], [ 95, 97 ], [ 99 ], [ 101, 103, 105, 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 119 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 209 ], [ 213 ], [ 217, 219, 221 ], [ 223 ], [ 225 ], [ 227 ] ]

[ "static void FUNC_0(const char *VAR_0, const char *VAR_1,\nDisplayState *VAR_2, stellaris_board_info *VAR_3)\n{", "static const int VAR_4[] = {5, 6, 33, 34};", "static const int VAR_5[] = {19, 21, 23, 35};", "static const uint32_t VAR_6[7] =\n{ 0x40004000, 0x40005000, 0x40006000, 0x40007000,", "0x40024000, 0x40025000, 0x40026000};", "static const int VAR_7[7] = {0, 1, 2, 3, 4, 30, 31};", "qemu_irq *pic;", "qemu_irq *gpio_in[7];", "qemu_irq *gpio_out[7];", "qemu_irq adc;", "int VAR_8;", "int VAR_9;", "i2c_bus *i2c;", "int VAR_10;", "VAR_9 = ((VAR_3->dc0 & 0xffff) + 1) << 1;", "VAR_8 = (VAR_3->dc0 >> 18) + 1;", "pic = armv7m_init(VAR_9, VAR_8, VAR_0, VAR_1);", "if (VAR_3->dc1 & (1 << 16)) {", "adc = stellaris_adc_init(0x40038000, pic[14]);", "} else {", "adc = NULL;", "}", "for (VAR_10 = 0; VAR_10 < 4; VAR_10++) {", "if (VAR_3->dc2 & (0x10000 << VAR_10)) {", "stellaris_gptm_init(0x40030000 + VAR_10 * 0x1000,\npic[VAR_5[VAR_10]], adc);", "}", "}", "stellaris_sys_init(0x400fe000, pic[28], VAR_3, nd_table[0].macaddr);", "for (VAR_10 = 0; VAR_10 < 7; VAR_10++) {", "if (VAR_3->dc4 & (1 << VAR_10)) {", "gpio_in[VAR_10] = pl061_init(VAR_6[VAR_10], pic[VAR_7[VAR_10]],\n&gpio_out[VAR_10]);", "}", "}", "if (VAR_3->dc2 & (1 << 12)) {", "i2c = i2c_init_bus();", "stellaris_i2c_init(0x40020000, pic[8], i2c);", "if (VAR_3->peripherals & BP_OLED_I2C) {", "ssd0303_init(VAR_2, i2c, 0x3d);", "}", "}", "for (VAR_10 = 0; VAR_10 < 4; VAR_10++) {", "if (VAR_3->dc2 & (1 << VAR_10)) {", "pl011_init(0x4000c000 + VAR_10 * 0x1000, pic[VAR_4[VAR_10]],\nserial_hds[VAR_10], PL011_LUMINARY);", "}", "}", "if (VAR_3->dc2 & (1 << 4)) {", "if (VAR_3->peripherals & BP_OLED_SSI) {", "void * VAR_11;", "void * VAR_12;", "void *VAR_13;", "int VAR_14;", "VAR_11 = ssd0323_init(VAR_2, &gpio_out[GPIO_C][7]);", "VAR_14 = drive_get_index(IF_SD, 0, 0);", "VAR_12 = ssi_sd_init(drives_table[VAR_14].bdrv);", "VAR_13 = stellaris_ssi_bus_init(&gpio_out[GPIO_D][0],\nssi_sd_xfer, VAR_12,\nssd0323_xfer_ssi, VAR_11);", "pl022_init(0x40008000, pic[7], stellaris_ssi_bus_xfer, VAR_13);", "qemu_irq_raise(gpio_out[GPIO_D][0]);", "} else {", "pl022_init(0x40008000, pic[7], NULL, NULL);", "}", "}", "if (VAR_3->dc4 & (1 << 28)) {", "stellaris_enet_init(&nd_table[0], 0x40048000, pic[42]);", "}", "if (VAR_3->peripherals & BP_GAMEPAD) {", "qemu_irq gpad_irq[5];", "static const int VAR_15[5] = { 0xc8, 0xd0, 0xcb, 0xcd, 0x1d };", "gpad_irq[0] = qemu_irq_invert(gpio_in[GPIO_E][0]);", "gpad_irq[1] = qemu_irq_invert(gpio_in[GPIO_E][1]);", "gpad_irq[2] = qemu_irq_invert(gpio_in[GPIO_E][2]);", "gpad_irq[3] = qemu_irq_invert(gpio_in[GPIO_E][3]);", "gpad_irq[4] = qemu_irq_invert(gpio_in[GPIO_F][1]);", "stellaris_gamepad_init(5, gpad_irq, VAR_15);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 71 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141, 143 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191 ], [ 193 ] ]

[ "static int FUNC_0(void *VAR_0)\n{", "PCNetState *s = VAR_0;", "if (CSR_STOP(s) || CSR_SPND(s))\nreturn 0;", "if (s->recv_pos > 0)\nreturn 0;", "return sizeof(s->buffer)-16;", "}" ]

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

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

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

[ 0, 0, 0 ]

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

[ "static uint32_t FUNC_0 (void *opaque, target_phys_addr_t addr)\n{", "return 0;", "}" ]

[ 0, 0, 0 ]

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

[ "void FUNC_0(int VAR_0, int VAR_1)\n{", "int VAR_2, VAR_3;", "uint32_t e1, e2;", "if (env->eflags & NT_MASK) {", "#ifdef TARGET_X86_64\nif (env->hflags & HF_LMA_MASK)\nraise_exception_err(EXCP0D_GPF, 0);", "#endif\nVAR_2 = lduw_kernel(env->tr.base + 0);", "if (VAR_2 & 4)\nraise_exception_err(EXCP0A_TSS, VAR_2 & 0xfffc);", "if (load_segment(&e1, &e2, VAR_2) != 0)\nraise_exception_err(EXCP0A_TSS, VAR_2 & 0xfffc);", "VAR_3 = (e2 >> DESC_TYPE_SHIFT) & 0x17;", "if (VAR_3 != 3)\nraise_exception_err(EXCP0A_TSS, VAR_2 & 0xfffc);", "switch_tss(VAR_2, e1, e2, SWITCH_TSS_IRET, VAR_1);", "} else {", "helper_ret_protected(VAR_0, 1, 0);", "}", "env->hflags2 &= ~HF2_NMI_MASK;", "#ifdef CONFIG_KQEMU\nif (kqemu_is_ok(env)) {", "CC_OP = CC_OP_EFLAGS;", "env->exception_index = -1;", "cpu_loop_exit();", "}", "#endif\n}" ]

[ 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 ], [ 13 ], [ 15, 17, 19 ], [ 21, 23 ], [ 25, 27 ], [ 29, 31 ], [ 33 ], [ 37, 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63, 65 ] ]

[ "static void FUNC_0(AVFilterContext *VAR_0, AVFrame *VAR_1, const AVFrame *VAR_2, int VAR_3, int VAR_4)\n{", "blend_image_packed_rgb(VAR_0, VAR_1, VAR_2, 1, VAR_3, VAR_4, 0);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "PCIBonitoState *s = VAR_0;", "PCIDevice *d = PCI_DEVICE(s);", "PCIHostState *phb = PCI_HOST_BRIDGE(s->pcihost);", "uint32_t pciaddr;", "uint16_t status;", "DPRINTF(\"FUNC_0 \"TARGET_FMT_plx\" VAR_2 %x\\n\", VAR_1, VAR_2);", "pciaddr = bonito_sbridge_pciaddr(s, VAR_1);", "if (pciaddr == 0xffffffff) {", "return;", "}", "phb->config_reg = (pciaddr) | (1u << 31);", "pci_data_write(phb->bus, phb->config_reg, VAR_2 & 0xff, 1);", "status = pci_get_word(d->config + PCI_STATUS);", "status &= ~(PCI_STATUS_REC_MASTER_ABORT | PCI_STATUS_REC_TARGET_ABORT);", "pci_set_word(d->config + PCI_STATUS, status);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 35 ], [ 37 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ] ]

[ "FUNC_0(SCSIRequest *VAR_0, uint32_t VAR_1, size_t VAR_2)\n{", "PVSCSIRequest *pvscsi_req = VAR_0->hba_private;", "PVSCSIState *s = pvscsi_req->dev;", "if (!pvscsi_req) {", "trace_pvscsi_command_complete_not_found(VAR_0->tag);", "return;", "}", "if (VAR_2) {", "trace_pvscsi_command_complete_data_run();", "pvscsi_req->cmp.hostStatus = BTSTAT_DATARUN;", "}", "pvscsi_req->cmp.scsiStatus = VAR_1;", "if (pvscsi_req->cmp.scsiStatus == CHECK_CONDITION) {", "uint8_t sense[SCSI_SENSE_BUF_SIZE];", "int VAR_3 =\nscsi_req_get_sense(pvscsi_req->sreq, sense, sizeof(sense));", "trace_pvscsi_command_complete_sense_len(VAR_3);", "pvscsi_write_sense(pvscsi_req, sense, VAR_3);", "}", "qemu_sglist_destroy(&pvscsi_req->sgl);", "pvscsi_complete_request(s, pvscsi_req);", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nint VAR_2, V9fsFidOpenState *VAR_3)\n{", "VAR_3->fd = v9fs_request(VAR_0->private, T_OPEN, NULL, \"sd\", VAR_1, VAR_2);", "if (VAR_3->fd < 0) {", "errno = -VAR_3->fd;", "VAR_3->fd = -1;", "}", "return VAR_3->fd;", "}" ]

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

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

[ "void FUNC_0 (ram_addr_t VAR_0, int VAR_1,\nconst char *VAR_2, DisplayState *VAR_3,\nconst char *VAR_4, const char *VAR_5,\nconst char *VAR_6, const char *VAR_7)\n{", "char VAR_8[1024];", "unsigned long VAR_9;", "int VAR_10;", "CPUState *env;", "RTCState *rtc_state;", "int VAR_11;", "qemu_irq *i8259;", "int VAR_12;", "BlockDriverState *hd[MAX_IDE_BUS * MAX_IDE_DEVS];", "if (VAR_7 == NULL) {", "#ifdef TARGET_MIPS64\nVAR_7 = \"R4000\";", "#else\nVAR_7 = \"24Kf\";", "#endif\n}", "env = cpu_init(VAR_7);", "if (!env) {", "fprintf(stderr, \"Unable to find CPU definition\\n\");", "exit(1);", "}", "qemu_register_reset(main_cpu_reset, env);", "cpu_register_physical_memory(0, VAR_0, IO_MEM_RAM);", "if (!mips_qemu_iomemtype) {", "mips_qemu_iomemtype = cpu_register_io_memory(0, mips_qemu_read,\nmips_qemu_write, NULL);", "}", "cpu_register_physical_memory(0x1fbf0000, 0x10000, mips_qemu_iomemtype);", "VAR_9 = VAR_0 + VAR_1;", "if (bios_name == NULL)\nbios_name = BIOS_FILENAME;", "snprintf(VAR_8, sizeof(VAR_8), \"%s/%s\", bios_dir, bios_name);", "VAR_10 = load_image(VAR_8, phys_ram_base + VAR_9);", "if ((VAR_10 > 0) && (VAR_10 <= BIOS_SIZE)) {", "cpu_register_physical_memory(0x1fc00000,\nBIOS_SIZE, VAR_9 | IO_MEM_ROM);", "} else if ((VAR_12 = drive_get_index(IF_PFLASH, 0, 0)) > -1) {", "uint32_t mips_rom = 0x00400000;", "cpu_register_physical_memory(0x1fc00000, mips_rom,\nqemu_ram_alloc(mips_rom) | IO_MEM_ROM);", "if (!pflash_cfi01_register(0x1fc00000, qemu_ram_alloc(mips_rom),\ndrives_table[VAR_12].bdrv, sector_len, mips_rom / sector_len,\n4, 0, 0, 0, 0)) {", "fprintf(stderr, \"qemu: Error registering flash memory.\\n\");", "}", "}", "else {", "fprintf(stderr, \"qemu: Warning, could not load MIPS bios '%s'\\n\",\nVAR_8);", "}", "if (VAR_4) {", "loaderparams.VAR_0 = VAR_0;", "loaderparams.VAR_4 = VAR_4;", "loaderparams.VAR_5 = VAR_5;", "loaderparams.VAR_6 = VAR_6;", "load_kernel (env);", "}", "cpu_mips_irq_init_cpu(env);", "cpu_mips_clock_init(env);", "i8259 = i8259_init(env->irq[2]);", "rtc_state = rtc_init(0x70, i8259[8]);", "isa_mmio_init(0x14000000, 0x00010000);", "isa_mem_base = 0x10000000;", "pit = pit_init(0x40, i8259[0]);", "for(VAR_11 = 0; VAR_11 < MAX_SERIAL_PORTS; VAR_11++) {", "if (serial_hds[VAR_11]) {", "serial_init(serial_io[VAR_11], i8259[serial_irq[VAR_11]], 115200,\nserial_hds[VAR_11]);", "}", "}", "isa_vga_init(VAR_3, phys_ram_base + VAR_0, VAR_0,\nVAR_1);", "if (nd_table[0].vlan) {", "if (nd_table[VAR_11].model == NULL) {", "nd_table[VAR_11].model = \"ne2k_isa\";", "}", "if (strcmp(nd_table[0].model, \"ne2k_isa\") == 0) {", "isa_ne2000_init(0x300, i8259[9], &nd_table[0]);", "} else if (strcmp(nd_table[0].model, \"?\") == 0) {", "fprintf(stderr, \"qemu: Supported NICs: ne2k_isa\\n\");", "exit (1);", "} else {", "fprintf(stderr, \"qemu: Unsupported NIC: %s\\n\", nd_table[0].model);", "exit (1);", "}", "}", "if (drive_get_max_bus(IF_IDE) >= MAX_IDE_BUS) {", "fprintf(stderr, \"qemu: too many IDE bus\\n\");", "exit(1);", "}", "for(VAR_11 = 0; VAR_11 < MAX_IDE_BUS * MAX_IDE_DEVS; VAR_11++) {", "VAR_12 = drive_get_index(IF_IDE, VAR_11 / MAX_IDE_DEVS, VAR_11 % MAX_IDE_DEVS);", "if (VAR_12 != -1)\nhd[VAR_11] = drives_table[VAR_12].bdrv;", "else\nhd[VAR_11] = NULL;", "}", "for(VAR_11 = 0; VAR_11 < MAX_IDE_BUS; VAR_11++)", "isa_ide_init(ide_iobase[VAR_11], ide_iobase2[VAR_11], i8259[ide_irq[VAR_11]],\nhd[MAX_IDE_DEVS * VAR_11],\nhd[MAX_IDE_DEVS * VAR_11 + 1]);", "i8042_init(i8259[1], i8259[12], 0x60);", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 35, 37 ], [ 39, 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 111, 113, 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127, 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 153 ], [ 155 ], [ 161 ], [ 165 ], [ 171 ], [ 173 ], [ 177 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 195, 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 241 ], [ 243 ], [ 245, 247 ], [ 249, 251 ], [ 253 ], [ 257 ], [ 259, 261, 263 ], [ 267 ], [ 269 ] ]

[ "static bool FUNC_0(void *opaque)\n{", "sPAPRDRConnector *drc = (sPAPRDRConnector *)opaque;", "sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);", "bool rc = false;", "sPAPRDREntitySense value = drck->dr_entity_sense(drc);", "if (value != SPAPR_DR_ENTITY_SENSE_PRESENT) {", "return false;", "}", "switch (spapr_drc_type(drc)) {", "case SPAPR_DR_CONNECTOR_TYPE_PCI:\ncase SPAPR_DR_CONNECTOR_TYPE_CPU:\ncase SPAPR_DR_CONNECTOR_TYPE_LMB:\nrc = !((drc->isolation_state == SPAPR_DR_ISOLATION_STATE_UNISOLATED) &&\n(drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_USABLE) &&\ndrc->configured && !drc->awaiting_release);", "break;", "case SPAPR_DR_CONNECTOR_TYPE_PHB:\ncase SPAPR_DR_CONNECTOR_TYPE_VIO:\ndefault:\ng_assert_not_reached();", "}", "return rc;", "}" ]

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

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

[ "static inline void FUNC_0(yuv2yuv1)(SwsContext *c, const int16_t *lumSrc,\nconst int16_t *chrUSrc, const int16_t *chrVSrc,\nconst int16_t *alpSrc,\nuint8_t *dest, uint8_t *uDest, uint8_t *vDest,\nuint8_t *aDest, int dstW, int chrDstW)\n{", "int VAR_0= 4;", "const uint8_t *VAR_1[4]= { alpSrc + dstW, lumSrc + dstW, chrUSrc + chrDstW, chrVSrc + chrDstW };", "uint8_t *dst[4]= { aDest, dest, uDest, vDest };", "x86_reg counter[4]= { dstW, dstW, chrDstW, chrDstW };", "while (VAR_0--) {", "if (dst[VAR_0]) {", "__asm__ volatile(\n\"mov %2, %%\"REG_a\" \\n\\t\"\n\".p2align 4 \\n\\t\"\n\"1: \\n\\t\"\n\"movq (%0, %%\"REG_a\", 2), %%mm0 \\n\\t\"\n\"movq 8(%0, %%\"REG_a\", 2), %%mm1 \\n\\t\"\n\"psraw $7, %%mm0 \\n\\t\"\n\"psraw $7, %%mm1 \\n\\t\"\n\"packuswb %%mm1, %%mm0 \\n\\t\"\nMOVNTQ(%%mm0, (%1, %%REGa))\n\"add $8, %%\"REG_a\" \\n\\t\"\n\"jnc 1b \\n\\t\"\n:: \"r\" (VAR_1[VAR_0]), \"r\" (dst[VAR_0] + counter[VAR_0]),\n\"g\" (-counter[VAR_0])\n: \"%\"REG_a\n);", "}", "}", "}" ]

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

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

[ "static inline void FUNC_0(rgb15to16)(const uint8_t *src, uint8_t *dst, long src_size)\n{", "register const uint8_t* VAR_0=src;", "register uint8_t* VAR_1=dst;", "register const uint8_t *VAR_2;", "const uint8_t *VAR_3;", "VAR_2 = VAR_0 + src_size;", "#if COMPILE_TEMPLATE_MMX\n__asm__ volatile(PREFETCH\" %0\"::\"m\"(*VAR_0));", "__asm__ volatile(\"movq %0, %%mm4\"::\"m\"(mask15s));", "VAR_3 = VAR_2 - 15;", "while (VAR_0<VAR_3) {", "__asm__ volatile(\nPREFETCH\" 32%1 \\n\\t\"\n\"movq %1, %%mm0 \\n\\t\"\n\"movq 8%1, %%mm2 \\n\\t\"\n\"movq %%mm0, %%mm1 \\n\\t\"\n\"movq %%mm2, %%mm3 \\n\\t\"\n\"pand %%mm4, %%mm0 \\n\\t\"\n\"pand %%mm4, %%mm2 \\n\\t\"\n\"paddw %%mm1, %%mm0 \\n\\t\"\n\"paddw %%mm3, %%mm2 \\n\\t\"\nMOVNTQ\" %%mm0, %0 \\n\\t\"\nMOVNTQ\" %%mm2, 8%0\"\n:\"=m\"(*VAR_1)\n:\"m\"(*VAR_0)\n);", "VAR_1+=16;", "VAR_0+=16;", "}", "__asm__ volatile(SFENCE:::\"memory\");", "__asm__ volatile(EMMS:::\"memory\");", "#endif\nVAR_3 = VAR_2 - 3;", "while (VAR_0 < VAR_3) {", "register unsigned VAR_5= *((const uint32_t *)VAR_0);", "*((uint32_t *)VAR_1) = (VAR_5&0x7FFF7FFF) + (VAR_5&0x7FE07FE0);", "VAR_1+=4;", "VAR_0+=4;", "}", "if (VAR_0 < VAR_2) {", "register unsigned short VAR_5= *((const uint16_t *)VAR_0);", "*((uint16_t *)VAR_1) = (VAR_5&0x7FFF) + (VAR_5&0x7FE0);", "}", "}" ]

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

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

[ "PowerPCCPU *FUNC_0(const char *cpu_model,\nclk_setup_t *cpu_clk, clk_setup_t *tb_clk,\nuint32_t sysclk)\n{", "PowerPCCPU *cpu;", "CPUPPCState *env;", "cpu = POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU, cpu_model));", "if (cpu == NULL) {", "fprintf(stderr, \"Unable to find PowerPC %s CPU definition\\n\",\ncpu_model);", "exit(1);", "}", "env = &cpu->env;", "cpu_clk->cb = NULL;", "cpu_clk->opaque = env;", "tb_clk->cb = ppc_40x_timers_init(env, sysclk, PPC_INTERRUPT_PIT);", "tb_clk->opaque = env;", "ppc_dcr_init(env, NULL, NULL);", "qemu_register_reset(ppc4xx_reset, cpu);", "return cpu;", "}" ]

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

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

[ "void FUNC_0(MpegEncContext *VAR_0, const uint8_t *VAR_1,\nint VAR_2, int VAR_3)\n{", "struct vdpau_render_state *VAR_4, *VAR_5, *VAR_6;", "int VAR_7;", "VAR_4 = (struct vdpau_render_state *)VAR_0->current_picture_ptr->data[0];", "assert(VAR_4);", "VAR_4->info.mpeg.picture_structure = VAR_0->picture_structure;", "VAR_4->info.mpeg.picture_coding_type = VAR_0->pict_type;", "VAR_4->info.mpeg.intra_dc_precision = VAR_0->intra_dc_precision;", "VAR_4->info.mpeg.frame_pred_frame_dct = VAR_0->frame_pred_frame_dct;", "VAR_4->info.mpeg.concealment_motion_vectors = VAR_0->concealment_motion_vectors;", "VAR_4->info.mpeg.intra_vlc_format = VAR_0->intra_vlc_format;", "VAR_4->info.mpeg.alternate_scan = VAR_0->alternate_scan;", "VAR_4->info.mpeg.q_scale_type = VAR_0->q_scale_type;", "VAR_4->info.mpeg.top_field_first = VAR_0->top_field_first;", "VAR_4->info.mpeg.full_pel_forward_vector = VAR_0->full_pel[0];", "VAR_4->info.mpeg.full_pel_backward_vector = VAR_0->full_pel[1];", "VAR_4->info.mpeg.f_code[0][0] = VAR_0->mpeg_f_code[0][0];", "VAR_4->info.mpeg.f_code[0][1] = VAR_0->mpeg_f_code[0][1];", "VAR_4->info.mpeg.f_code[1][0] = VAR_0->mpeg_f_code[1][0];", "VAR_4->info.mpeg.f_code[1][1] = VAR_0->mpeg_f_code[1][1];", "for (VAR_7 = 0; VAR_7 < 64; ++VAR_7) {", "VAR_4->info.mpeg.intra_quantizer_matrix[VAR_7] = VAR_0->intra_matrix[VAR_7];", "VAR_4->info.mpeg.non_intra_quantizer_matrix[VAR_7] = VAR_0->inter_matrix[VAR_7];", "}", "VAR_4->info.mpeg.forward_reference = VDP_INVALID_HANDLE;", "VAR_4->info.mpeg.backward_reference = VDP_INVALID_HANDLE;", "switch(VAR_0->pict_type){", "case FF_B_TYPE:\nVAR_6 = (struct vdpau_render_state *)VAR_0->next_picture.data[0];", "assert(VAR_6);", "VAR_4->info.mpeg.backward_reference = VAR_6->surface;", "case FF_P_TYPE:\nVAR_5 = (struct vdpau_render_state *)VAR_0->last_picture.data[0];", "if (!VAR_5)\nVAR_5 = VAR_4;", "VAR_4->info.mpeg.forward_reference = VAR_5->surface;", "}", "ff_vdpau_add_data_chunk(VAR_0, VAR_1, VAR_2);", "VAR_4->info.mpeg.VAR_3 = VAR_3;", "if (VAR_3)\nff_draw_horiz_band(VAR_0, 0, VAR_0->avctx->height);", "VAR_4->bitstream_buffers_used = 0;", "}" ]

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

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30 ], [ 31, 32 ], [ 33 ], [ 34 ], [ 36, 37 ], [ 38, 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43 ], [ 44, 45 ], [ 46 ], [ 47 ] ]

[ "static int FUNC_0(HTTPContext *VAR_0, const char *VAR_1)\n{", "char VAR_2[128];", "char VAR_3[1024];", "AVFormatContext *s = NULL;", "int VAR_4, VAR_5, VAR_6;", "int64_t stream_pos;", "if (VAR_0->stream->feed) {", "strcpy(VAR_3, VAR_0->stream->feed->feed_filename);", "VAR_4 = FFM_PACKET_SIZE;", "if (av_find_info_tag(VAR_2, sizeof(VAR_2), \"date\", VAR_1)) {", "if ((VAR_6 = av_parse_time(&stream_pos, VAR_2, 0)) < 0) {", "http_log(\"Invalid date specification '%s' for stream\\n\", VAR_2);", "return VAR_6;", "}", "} else if (av_find_info_tag(VAR_2, sizeof(VAR_2), \"buffer\", VAR_1)) {", "int VAR_7 = strtol(VAR_2, 0, 10);", "stream_pos = av_gettime() - VAR_7 * (int64_t)1000000;", "} else", "stream_pos = av_gettime() - VAR_0->stream->VAR_7 * (int64_t)1000;", "} else {", "strcpy(VAR_3, VAR_0->stream->feed_filename);", "VAR_4 = 0;", "if (av_find_info_tag(VAR_2, sizeof(VAR_2), \"date\", VAR_1)) {", "if ((VAR_6 = av_parse_time(&stream_pos, VAR_2, 1)) < 0) {", "http_log(\"Invalid date specification '%s' for stream\\n\", VAR_2);", "return VAR_6;", "}", "} else", "stream_pos = 0;", "}", "if (!VAR_3[0]) {", "http_log(\"No filename was specified for stream\\n\");", "return AVERROR(EINVAL);", "}", "VAR_6 = avformat_open_input(&s, VAR_3, VAR_0->stream->ifmt,\n&VAR_0->stream->in_opts);", "if (VAR_6 < 0) {", "http_log(\"Could not open input '%s': %s\\n\",\nVAR_3, av_err2str(VAR_6));", "return VAR_6;", "}", "if (VAR_4 > 0) {", "VAR_6 = ffio_set_buf_size(s->pb, VAR_4);", "if (VAR_6 < 0) {", "http_log(\"Failed to set buffer size\\n\");", "return VAR_6;", "}", "}", "s->flags |= AVFMT_FLAG_GENPTS;", "VAR_0->fmt_in = s;", "if (strcmp(s->iformat->name, \"ffm\") &&\n(VAR_6 = avformat_find_stream_info(VAR_0->fmt_in, NULL)) < 0) {", "http_log(\"Could not find stream VAR_1 for input '%s'\\n\", VAR_3);", "avformat_close_input(&s);", "return VAR_6;", "}", "VAR_0->pts_stream_index = 0;", "for(VAR_5=0;VAR_5<VAR_0->stream->nb_streams;VAR_5++) {", "if (VAR_0->pts_stream_index == 0 &&\nVAR_0->stream->streams[VAR_5]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {", "VAR_0->pts_stream_index = VAR_5;", "}", "}", "if (VAR_0->fmt_in->iformat->read_seek)\nav_seek_frame(VAR_0->fmt_in, -1, stream_pos, 0);", "VAR_0->start_time = cur_time;", "VAR_0->first_pts = AV_NOPTS_VALUE;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 83, 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 139 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155, 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ] ]

[ "static int FUNC_0(int VAR_0, char **VAR_1)\n{", "bdrv_close(bs);", "bs = NULL;", "return 0;", "}" ]

[ 0, 1, 0, 0, 0 ]

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

[ "static void FUNC_0(CharDriverState *VAR_0, int VAR_1)\n{", "PtyCharDriver *s = VAR_0->opaque;", "if (!VAR_1) {", "if (s->fd_tag) {", "io_remove_watch_poll(s->fd_tag);", "s->fd_tag = 0;", "}", "s->VAR_1 = 0;", "pty_chr_rearm_timer(VAR_0, 1000);", "} else {", "if (s->timer_tag) {", "g_source_remove(s->timer_tag);", "s->timer_tag = 0;", "}", "if (!s->VAR_1) {", "qemu_chr_be_generic_open(VAR_0);", "s->VAR_1 = 1;", "s->fd_tag = io_add_watch_poll(s->fd, pty_chr_read_poll, pty_chr_read, VAR_0);", "}", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{", "ZynqXADCState *s = (ZynqXADCState *)VAR_0;", "int VAR_4 = VAR_1 / 4;", "int VAR_5;", "int VAR_6;", "int VAR_7;", "if (!zynq_xadc_check_offset(VAR_4, false)) {", "qemu_log_mask(LOG_GUEST_ERROR, \"zynq_xadc: Invalid write access \"\n\"to addr %\" HWADDR_PRIx \"\\n\", VAR_1);", "return;", "}", "switch (VAR_4) {", "case CFG:\ns->regs[CFG] = VAR_2;", "break;", "case INT_STS:\ns->regs[INT_STS] &= ~VAR_2;", "break;", "case INT_MASK:\ns->regs[INT_MASK] = VAR_2 & INT_ALL;", "break;", "case CMDFIFO:\nVAR_6 = extract32(VAR_2, 26, 4);", "VAR_5 = extract32(VAR_2, 16, 10);", "VAR_7 = extract32(VAR_2, 0, 16);", "if (s->regs[MCTL] & MCTL_RESET) {", "qemu_log_mask(LOG_GUEST_ERROR, \"zynq_xadc: Sending command \"\n\"while comm channel held in reset: %\" PRIx32 \"\\n\",\n(uint32_t) VAR_2);", "break;", "}", "if (VAR_5 > ZYNQ_XADC_NUM_ADC_REGS && VAR_6 != CMD_NOP) {", "qemu_log_mask(LOG_GUEST_ERROR, \"read/write op to invalid xadc \"\n\"VAR_4 0x%x\\n\", VAR_5);", "break;", "}", "switch (VAR_6) {", "case CMD_READ:\nxadc_push_dfifo(s, s->xadc_regs[VAR_5]);", "break;", "case CMD_WRITE:\ns->xadc_regs[VAR_5] = VAR_7;", "case CMD_NOP:\nxadc_push_dfifo(s, 0);", "break;", "}", "break;", "case MCTL:\ns->regs[MCTL] = VAR_2 & 0x00fffeff;", "break;", "}", "zynq_xadc_update_ints(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, 1, 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 ], [ 39, 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63, 65, 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95, 97 ], [ 101, 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ] ]

[ "static inline void FUNC_0 (DisasContext *VAR_0)\n{", "gen_op_cmpi(0);", "gen_op_set_Rc0();", "}" ]

[ 0, 1, 0, 0 ]

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

[ "static int FUNC_0(CPUPhysMemoryClient *VAR_0,\ntarget_phys_addr_t VAR_1, ram_addr_t VAR_2)\n{", "return kvm_dirty_pages_log_change(VAR_1, VAR_2, true);", "}" ]

[ 1, 1, 0 ]

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

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "DeviceState *d = DEVICE(VAR_0);", "MegasasState *s = MEGASAS(VAR_0);", "MegasasBaseClass *b = MEGASAS_DEVICE_GET_CLASS(s);", "uint8_t *pci_conf;", "int VAR_1, VAR_2;", "Error *err = NULL;", "pci_conf = VAR_0->config;", "pci_conf[PCI_LATENCY_TIMER] = 0;", "pci_conf[PCI_INTERRUPT_PIN] = 0x01;", "memory_region_init_io(&s->mmio_io, OBJECT(s), &megasas_mmio_ops, s,\n\"megasas-mmio\", 0x4000);", "memory_region_init_io(&s->port_io, OBJECT(s), &megasas_port_ops, s,\n\"megasas-io\", 256);", "memory_region_init_io(&s->queue_io, OBJECT(s), &megasas_queue_ops, s,\n\"megasas-queue\", 0x40000);", "if (megasas_use_msi(s) &&\nmsi_init(VAR_0, 0x50, 1, true, false)) {", "s->flags &= ~MEGASAS_MASK_USE_MSI;", "}", "if (megasas_use_msix(s) &&\nmsix_init(VAR_0, 15, &s->mmio_io, b->mmio_bar, 0x2000,\n&s->mmio_io, b->mmio_bar, 0x3800, 0x68)) {", "s->flags &= ~MEGASAS_MASK_USE_MSIX;", "}", "if (pci_is_express(VAR_0)) {", "pcie_endpoint_cap_init(VAR_0, 0xa0);", "}", "VAR_2 = PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64;", "pci_register_bar(VAR_0, b->ioport_bar,\nPCI_BASE_ADDRESS_SPACE_IO, &s->port_io);", "pci_register_bar(VAR_0, b->mmio_bar, VAR_2, &s->mmio_io);", "pci_register_bar(VAR_0, 3, VAR_2, &s->queue_io);", "if (megasas_use_msix(s)) {", "msix_vector_use(VAR_0, 0);", "}", "s->fw_state = MFI_FWSTATE_READY;", "if (!s->sas_addr) {", "s->sas_addr = ((NAA_LOCALLY_ASSIGNED_ID << 24) |\nIEEE_COMPANY_LOCALLY_ASSIGNED) << 36;", "s->sas_addr |= (pci_bus_num(VAR_0->bus) << 16);", "s->sas_addr |= (PCI_SLOT(VAR_0->devfn) << 8);", "s->sas_addr |= PCI_FUNC(VAR_0->devfn);", "}", "if (!s->hba_serial) {", "s->hba_serial = g_strdup(MEGASAS_HBA_SERIAL);", "}", "if (s->fw_sge >= MEGASAS_MAX_SGE - MFI_PASS_FRAME_SIZE) {", "s->fw_sge = MEGASAS_MAX_SGE - MFI_PASS_FRAME_SIZE;", "} else if (s->fw_sge >= 128 - MFI_PASS_FRAME_SIZE) {", "s->fw_sge = 128 - MFI_PASS_FRAME_SIZE;", "} else {", "s->fw_sge = 64 - MFI_PASS_FRAME_SIZE;", "}", "if (s->fw_cmds > MEGASAS_MAX_FRAMES) {", "s->fw_cmds = MEGASAS_MAX_FRAMES;", "}", "trace_megasas_init(s->fw_sge, s->fw_cmds,\nmegasas_is_jbod(s) ? \"jbod\" : \"raid\");", "if (megasas_is_jbod(s)) {", "s->fw_luns = MFI_MAX_SYS_PDS;", "} else {", "s->fw_luns = MFI_MAX_LD;", "}", "s->producer_pa = 0;", "s->consumer_pa = 0;", "for (VAR_1 = 0; VAR_1 < s->fw_cmds; VAR_1++) {", "s->frames[VAR_1].index = VAR_1;", "s->frames[VAR_1].context = -1;", "s->frames[VAR_1].pa = 0;", "s->frames[VAR_1].state = s;", "}", "scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(VAR_0),\n&megasas_scsi_info, NULL);", "if (!d->hotplugged) {", "scsi_bus_legacy_handle_cmdline(&s->bus, &err);", "if (err != NULL) {", "error_free(err);", "return -1;", "}", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 25 ], [ 29 ], [ 33, 35 ], [ 37, 39 ], [ 41, 43 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55, 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 180 ], [ 182 ], [ 184 ], [ 186 ], [ 188 ], [ 190 ] ]

[ "VirtIODevice *FUNC_0(DeviceState *dev, BlockConf *conf)\n{", "VirtIOBlock *s;", "int VAR_0, VAR_1, VAR_2;", "static int VAR_3;", "DriveInfo *dinfo;", "if (!conf->bs) {", "error_report(\"virtio-blk-pci: drive property not set\");", "s = (VirtIOBlock *)virtio_common_init(\"virtio-blk\", VIRTIO_ID_BLOCK,\nsizeof(struct virtio_blk_config),\nsizeof(VirtIOBlock));", "s->vdev.get_config = virtio_blk_update_config;", "s->vdev.get_features = virtio_blk_get_features;", "s->vdev.reset = virtio_blk_reset;", "s->bs = conf->bs;", "s->conf = conf;", "s->rq = NULL;", "s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1;", "bdrv_guess_geometry(s->bs, &VAR_0, &VAR_1, &VAR_2);", "dinfo = drive_get_by_blockdev(s->bs);", "strncpy(s->sn, dinfo->serial, sizeof (s->sn));", "s->vq = virtio_add_queue(&s->vdev, 128, virtio_blk_handle_output);", "qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);", "register_savevm(dev, \"virtio-blk\", VAR_3++, 2,\nvirtio_blk_save, virtio_blk_load, s);", "bdrv_set_removable(s->bs, 0);", "return &s->vdev;" ]

[ 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 ], [ 27, 29, 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 59 ], [ 61 ], [ 65 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 79 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, QEMUSnapshotInfo **VAR_1)\n{", "BDRVQcowState *s = VAR_0->opaque;", "QEMUSnapshotInfo *sn_tab, *sn_info;", "QCowSnapshot *sn;", "int VAR_2;", "if (!s->nb_snapshots) {", "*VAR_1 = NULL;", "return s->nb_snapshots;", "}", "sn_tab = g_malloc0(s->nb_snapshots * sizeof(QEMUSnapshotInfo));", "for(VAR_2 = 0; VAR_2 < s->nb_snapshots; VAR_2++) {", "sn_info = sn_tab + VAR_2;", "sn = s->snapshots + VAR_2;", "pstrcpy(sn_info->id_str, sizeof(sn_info->id_str),\nsn->id_str);", "pstrcpy(sn_info->name, sizeof(sn_info->name),\nsn->name);", "sn_info->vm_state_size = sn->vm_state_size;", "sn_info->date_sec = sn->date_sec;", "sn_info->date_nsec = sn->date_nsec;", "sn_info->vm_clock_nsec = sn->vm_clock_nsec;", "}", "*VAR_1 = sn_tab;", "return s->nb_snapshots;", "}" ]

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

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

[ "static void FUNC_0(uint8_t *VAR_0, int VAR_1, DCTELEM *VAR_2)\n{", "int VAR_3;", "register int VAR_4,VAR_5,VAR_6,VAR_7,VAR_8,VAR_9,VAR_10,VAR_11;", "DCTELEM *src, *dst;", "const uint8_t *VAR_12 = ff_cropTbl + MAX_NEG_CROP;", "src = VAR_2;", "dst = VAR_2;", "for(VAR_3 = 0; VAR_3 < 8; VAR_3++){", "VAR_4 = 17 * (src[0] + src[2]) + 4;", "VAR_5 = 17 * (src[0] - src[2]) + 4;", "VAR_6 = 22 * src[1] + 10 * src[3];", "VAR_7 = 22 * src[3] - 10 * src[1];", "dst[0] = (VAR_4 + VAR_6) >> 3;", "dst[1] = (VAR_5 - VAR_7) >> 3;", "dst[2] = (VAR_5 + VAR_7) >> 3;", "dst[3] = (VAR_4 - VAR_6) >> 3;", "src += 8;", "dst += 8;", "}", "src = VAR_2;", "for(VAR_3 = 0; VAR_3 < 4; VAR_3++){", "VAR_4 = 12 * (src[ 0] + src[32]) + 64;", "VAR_5 = 12 * (src[ 0] - src[32]) + 64;", "VAR_6 = 16 * src[16] + 6 * src[48];", "VAR_7 = 6 * src[16] - 16 * src[48];", "VAR_8 = VAR_4 + VAR_6;", "VAR_9 = VAR_5 + VAR_7;", "VAR_10 = VAR_5 - VAR_7;", "VAR_11 = VAR_4 - VAR_6;", "VAR_4 = 16 * src[ 8] + 15 * src[24] + 9 * src[40] + 4 * src[56];", "VAR_5 = 15 * src[ 8] - 4 * src[24] - 16 * src[40] - 9 * src[56];", "VAR_6 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56];", "VAR_7 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56];", "VAR_0[0*VAR_1] = VAR_12[VAR_0[0*VAR_1] + ((VAR_8 + VAR_4) >> 7)];", "VAR_0[1*VAR_1] = VAR_12[VAR_0[1*VAR_1] + ((VAR_9 + VAR_5) >> 7)];", "VAR_0[2*VAR_1] = VAR_12[VAR_0[2*VAR_1] + ((VAR_10 + VAR_6) >> 7)];", "VAR_0[3*VAR_1] = VAR_12[VAR_0[3*VAR_1] + ((VAR_11 + VAR_7) >> 7)];", "VAR_0[4*VAR_1] = VAR_12[VAR_0[4*VAR_1] + ((VAR_11 - VAR_7 + 1) >> 7)];", "VAR_0[5*VAR_1] = VAR_12[VAR_0[5*VAR_1] + ((VAR_10 - VAR_6 + 1) >> 7)];", "VAR_0[6*VAR_1] = VAR_12[VAR_0[6*VAR_1] + ((VAR_9 - VAR_5 + 1) >> 7)];", "VAR_0[7*VAR_1] = VAR_12[VAR_0[7*VAR_1] + ((VAR_8 - VAR_4 + 1) >> 7)];", "src ++;", "VAR_0++;", "}", "}" ]

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

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

[ "FUNC_0(VAR_0)\n{", "TCGv reg;", "TCGv shift;", "reg = DREG(insn, 0);", "shift = DREG(insn, 9);", "if (insn & 0x100) {", "gen_helper_shl_cc(reg, cpu_env, reg, shift);", "} else {", "if (insn & 8) {", "gen_helper_shr_cc(reg, cpu_env, reg, shift);", "} else {", "gen_helper_sar_cc(reg, cpu_env, reg, shift);", "}", "}", "set_cc_op(s, CC_OP_FLAGS);", "}" ]

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

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

[ "static av_cold int FUNC_0(WMAProDecodeCtx *s, AVCodecContext *avctx)\n{", "uint8_t *edata_ptr = avctx->extradata;", "unsigned int VAR_0;", "int VAR_1, VAR_2;", "int VAR_3;", "int VAR_4;", "if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)\navctx->block_align = 2048;", "if (!avctx->block_align) {", "av_log(avctx, AV_LOG_ERROR, \"block_align is not set\\n\");", "return AVERROR(EINVAL);", "}", "s->avctx = avctx;", "s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);", "if (!s->fdsp)\nreturn AVERROR(ENOMEM);", "init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);", "avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;", "av_log(avctx, AV_LOG_DEBUG, \"extradata:\\n\");", "for (VAR_1 = 0; VAR_1 < avctx->extradata_size; VAR_1++)", "av_log(avctx, AV_LOG_DEBUG, \"[%VAR_7] \", avctx->extradata[VAR_1]);", "av_log(avctx, AV_LOG_DEBUG, \"\\n\");", "if (avctx->codec_id == AV_CODEC_ID_XMA2 && (!avctx->extradata || avctx->extradata_size >= 6)) {", "s->decode_flags = 0x10d6;", "VAR_0 = avctx->extradata ? AV_RL32(edata_ptr+2) : 0;", "s->bits_per_sample = 16;", "} else if (avctx->codec_id == AV_CODEC_ID_XMA1) {", "s->decode_flags = 0x10d6;", "s->bits_per_sample = 16;", "VAR_0 = 0;", "} else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {", "s->decode_flags = AV_RL16(edata_ptr+14);", "VAR_0 = AV_RL32(edata_ptr+2);", "s->bits_per_sample = AV_RL16(edata_ptr);", "if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {", "avpriv_request_sample(avctx, \"VAR_2 per sample is %d\", s->bits_per_sample);", "return AVERROR_PATCHWELCOME;", "}", "} else {", "avpriv_request_sample(avctx, \"Unknown extradata size\");", "return AVERROR_PATCHWELCOME;", "}", "if (avctx->codec_id != AV_CODEC_ID_WMAPRO && avctx->channels > 2) {", "s->nb_channels = 2;", "} else {", "s->nb_channels = avctx->channels;", "}", "s->log2_frame_size = av_log2(avctx->block_align) + 4;", "if (s->log2_frame_size > 25) {", "avpriv_request_sample(avctx, \"Large block align\");", "return AVERROR_PATCHWELCOME;", "}", "if (avctx->codec_id != AV_CODEC_ID_WMAPRO)\ns->skip_frame = 0;", "else\ns->skip_frame = 1;", "s->packet_loss = 1;", "s->len_prefix = (s->decode_flags & 0x40);", "if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {", "VAR_2 = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);", "if (VAR_2 > WMAPRO_BLOCK_MAX_BITS) {", "avpriv_request_sample(avctx, \"14-bit block sizes\");", "return AVERROR_PATCHWELCOME;", "}", "s->samples_per_frame = 1 << VAR_2;", "} else {", "s->samples_per_frame = 512;", "}", "VAR_3 = ((s->decode_flags & 0x38) >> 3);", "s->max_num_subframes = 1 << VAR_3;", "if (s->max_num_subframes == 16 || s->max_num_subframes == 4)\ns->max_subframe_len_bit = 1;", "s->subframe_len_bits = av_log2(VAR_3) + 1;", "VAR_4 = VAR_3 + 1;", "s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;", "s->dynamic_range_compression = (s->decode_flags & 0x80);", "if (s->max_num_subframes > MAX_SUBFRAMES) {", "av_log(avctx, AV_LOG_ERROR, \"invalid number of subframes %\"PRId8\"\\n\",\ns->max_num_subframes);", "return AVERROR_INVALIDDATA;", "}", "if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {", "av_log(avctx, AV_LOG_ERROR, \"min_samples_per_subframe of %d too small\\n\",\ns->min_samples_per_subframe);", "return AVERROR_INVALIDDATA;", "}", "if (s->avctx->sample_rate <= 0) {", "av_log(avctx, AV_LOG_ERROR, \"invalid sample VAR_9\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (s->nb_channels <= 0) {", "av_log(avctx, AV_LOG_ERROR, \"invalid number of channels %d\\n\",\ns->nb_channels);", "return AVERROR_INVALIDDATA;", "} else if (s->nb_channels > WMAPRO_MAX_CHANNELS) {", "avpriv_request_sample(avctx,\n\"More than %d channels\", WMAPRO_MAX_CHANNELS);", "return AVERROR_PATCHWELCOME;", "}", "for (VAR_1 = 0; VAR_1 < s->nb_channels; VAR_1++)", "s->channel[VAR_1].prev_block_len = s->samples_per_frame;", "s->lfe_channel = -1;", "if (VAR_0 & 8) {", "unsigned int VAR_5;", "for (VAR_5 = 1; VAR_5 < 16; VAR_5 <<= 1) {", "if (VAR_0 & VAR_5)\n++s->lfe_channel;", "}", "}", "INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,\nscale_huffbits, 1, 1,\nscale_huffcodes, 2, 2, 616);", "INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,\nscale_rl_huffbits, 1, 1,\nscale_rl_huffcodes, 4, 4, 1406);", "INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,\ncoef0_huffbits, 1, 1,\ncoef0_huffcodes, 4, 4, 2108);", "INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,\ncoef1_huffbits, 1, 1,\ncoef1_huffcodes, 4, 4, 3912);", "INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,\nvec4_huffbits, 1, 1,\nvec4_huffcodes, 2, 2, 604);", "INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,\nvec2_huffbits, 1, 1,\nvec2_huffcodes, 2, 2, 562);", "INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,\nvec1_huffbits, 1, 1,\nvec1_huffcodes, 2, 2, 562);", "for (VAR_1 = 0; VAR_1 < VAR_4; VAR_1++) {", "int VAR_6 = s->samples_per_frame >> VAR_1;", "int VAR_7;", "int VAR_8 = 1;", "int VAR_9 = get_rate(avctx);", "s->sfb_offsets[VAR_1][0] = 0;", "for (VAR_7 = 0; VAR_7 < MAX_BANDS-1 && s->sfb_offsets[VAR_1][VAR_8 - 1] < VAR_6; VAR_7++) {", "int offset = (VAR_6 * 2 * critical_freq[VAR_7]) / VAR_9 + 2;", "offset &= ~3;", "if (offset > s->sfb_offsets[VAR_1][VAR_8 - 1])\ns->sfb_offsets[VAR_1][VAR_8++] = offset;", "if (offset >= VAR_6)\nbreak;", "}", "s->sfb_offsets[VAR_1][VAR_8 - 1] = VAR_6;", "s->num_sfb[VAR_1] = VAR_8 - 1;", "if (s->num_sfb[VAR_1] <= 0) {", "av_log(avctx, AV_LOG_ERROR, \"num_sfb invalid\\n\");", "return AVERROR_INVALIDDATA;", "}", "}", "for (VAR_1 = 0; VAR_1 < VAR_4; VAR_1++) {", "int VAR_10;", "for (VAR_10 = 0; VAR_10 < s->num_sfb[VAR_1]; VAR_10++) {", "int VAR_7;", "int offset = ((s->sfb_offsets[VAR_1][VAR_10]\n+ s->sfb_offsets[VAR_1][VAR_10 + 1] - 1) << VAR_1) >> 1;", "for (VAR_7 = 0; VAR_7 < VAR_4; VAR_7++) {", "int v = 0;", "while (s->sfb_offsets[VAR_7][v + 1] << VAR_7 < offset) {", "v++;", "av_assert0(v < MAX_BANDS);", "}", "s->sf_offsets[VAR_1][VAR_7][VAR_10] = v;", "}", "}", "}", "for (VAR_1 = 0; VAR_1 < WMAPRO_BLOCK_SIZES; VAR_1++)", "ff_mdct_init(&s->mdct_ctx[VAR_1], WMAPRO_BLOCK_MIN_BITS+1+VAR_1, 1,\n1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + VAR_1 - 1))\n/ (1 << (s->bits_per_sample - 1)));", "for (VAR_1 = 0; VAR_1 < WMAPRO_BLOCK_SIZES; VAR_1++) {", "const int win_idx = WMAPRO_BLOCK_MAX_BITS - VAR_1;", "ff_init_ff_sine_windows(win_idx);", "s->windows[WMAPRO_BLOCK_SIZES - VAR_1 - 1] = ff_sine_windows[win_idx];", "}", "for (VAR_1 = 0; VAR_1 < VAR_4; VAR_1++) {", "int VAR_11 = s->samples_per_frame >> VAR_1;", "int VAR_12 = (440*VAR_11 + 3LL * (s->avctx->sample_rate >> 1) - 1)\n/ s->avctx->sample_rate;", "s->subwoofer_cutoffs[VAR_1] = av_clip(VAR_12, 4, VAR_11);", "}", "for (VAR_1 = 0; VAR_1 < 33; VAR_1++)", "sin64[VAR_1] = sin(VAR_1*M_PI / 64.0);", "if (avctx->debug & FF_DEBUG_BITSTREAM)\ndump_context(s);", "avctx->channel_layout = VAR_0;", "return 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17, 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 43 ], [ 47 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 133, 135 ], [ 137, 139 ], [ 143 ], [ 145 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197, 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209, 211 ], [ 213 ], [ 215 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231, 233 ], [ 235 ], [ 237 ], [ 239, 241 ], [ 243 ], [ 245 ], [ 251 ], [ 253 ], [ 259 ], [ 263 ], [ 265 ], [ 267 ], [ 269, 271 ], [ 273 ], [ 275 ], [ 279, 281, 283 ], [ 287, 289, 291 ], [ 295, 297, 299 ], [ 303, 305, 307 ], [ 311, 313, 315 ], [ 319, 321, 323 ], [ 327, 329, 331 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 351 ], [ 355 ], [ 357 ], [ 359 ], [ 361, 363 ], [ 367, 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409, 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 437 ], [ 439, 441, 443 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 463 ], [ 465 ], [ 467, 469 ], [ 471 ], [ 473 ], [ 479 ], [ 481 ], [ 485, 487 ], [ 491 ], [ 495 ], [ 497 ] ]

[ "static uint16_t FUNC_0(QVirtioDevice *d)\n{", "QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;", "return qpci_io_readw(dev->pdev, dev->addr + VIRTIO_PCI_QUEUE_NUM);", "}" ]

[ 0, 0, 1, 0 ]

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

[ "int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nconst void *VAR_2, int VAR_3)\n{", "int VAR_4;", "VAR_4 = bdrv_pwrite(VAR_0, VAR_1, VAR_2, VAR_3);", "if (VAR_4 < 0) {", "return VAR_4;", "}", "if ((VAR_0->open_flags & BDRV_O_CACHE_MASK) != 0) {", "bdrv_flush(VAR_0);", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(const DNXHDContext *VAR_0,\nRowContext *VAR_1, int VAR_2)\n{", "dnxhd_decode_dct_block(VAR_0, VAR_1, VAR_2, 4, 32, 6);", "}" ]

[ 1, 1, 0 ]

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

[ "int FUNC_0(H264Context *VAR_0, H264SliceContext *VAR_1)\n{", "unsigned int VAR_2;", "unsigned int VAR_3;", "int VAR_4;", "unsigned int VAR_5, VAR_6, VAR_7, VAR_8;", "int VAR_9, VAR_10;", "int VAR_11;", "int VAR_12 = 0;", "int VAR_13, VAR_14;", "int VAR_15 = VAR_1 == VAR_0->slice_ctx && !VAR_0->current_slice;", "int VAR_16, VAR_17, VAR_18;", "PPS *pps;", "VAR_0->qpel_put = VAR_0->h264qpel.put_h264_qpel_pixels_tab;", "VAR_0->qpel_avg = VAR_0->h264qpel.avg_h264_qpel_pixels_tab;", "VAR_2 = get_ue_golomb_long(&VAR_1->gb);", "if (VAR_2 == 0) {", "if (VAR_0->current_slice) {", "if (VAR_0->cur_pic_ptr && FIELD_PICTURE(VAR_0) && VAR_0->first_field) {", "ff_h264_field_end(VAR_0, VAR_1, 1);", "VAR_0->current_slice = 0;", "} else if (VAR_0->cur_pic_ptr && !FIELD_PICTURE(VAR_0) && !VAR_0->first_field && VAR_0->nal_unit_type == NAL_IDR_SLICE) {", "av_log(VAR_0, AV_LOG_WARNING, \"Broken frame packetizing\\n\");", "ff_h264_field_end(VAR_0, VAR_1, 1);", "VAR_0->current_slice = 0;", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 0);", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 1);", "VAR_0->cur_pic_ptr = NULL;", "} else", "return AVERROR_INVALIDDATA;", "}", "if (!VAR_0->first_field) {", "if (VAR_0->cur_pic_ptr && !VAR_0->VAR_18) {", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,\nVAR_0->VAR_17 == PICT_BOTTOM_FIELD);", "}", "VAR_0->cur_pic_ptr = NULL;", "}", "}", "VAR_5 = get_ue_golomb_31(&VAR_1->gb);", "if (VAR_5 > 9) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"slice type %d too large at %d\\n\",\nVAR_5, VAR_2);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_5 > 4) {", "VAR_5 -= 5;", "VAR_1->slice_type_fixed = 1;", "} else", "VAR_1->slice_type_fixed = 0;", "VAR_5 = golomb_to_pict_type[VAR_5];", "VAR_1->VAR_5 = VAR_5;", "VAR_1->slice_type_nos = VAR_5 & 3;", "if (VAR_0->nal_unit_type == NAL_IDR_SLICE &&\nVAR_1->slice_type_nos != AV_PICTURE_TYPE_I) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"A non-intra slice in an IDR NAL unit.\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (\n(VAR_0->avctx->skip_frame >= AVDISCARD_NONREF && !VAR_0->nal_ref_idc) ||\n(VAR_0->avctx->skip_frame >= AVDISCARD_BIDIR && VAR_1->slice_type_nos == AV_PICTURE_TYPE_B) ||\n(VAR_0->avctx->skip_frame >= AVDISCARD_NONINTRA && VAR_1->slice_type_nos != AV_PICTURE_TYPE_I) ||\n(VAR_0->avctx->skip_frame >= AVDISCARD_NONKEY && VAR_0->nal_unit_type != NAL_IDR_SLICE) ||\nVAR_0->avctx->skip_frame >= AVDISCARD_ALL) {", "return SLICE_SKIPED;", "}", "VAR_0->pict_type = VAR_1->VAR_5;", "VAR_3 = get_ue_golomb(&VAR_1->gb);", "if (VAR_3 >= MAX_PPS_COUNT) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_3 %u out of range\\n\", VAR_3);", "return AVERROR_INVALIDDATA;", "}", "if (!VAR_0->pps_buffers[VAR_3]) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"non-existing PPS %u referenced\\n\",\nVAR_3);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_0->au_pps_id >= 0 && VAR_3 != VAR_0->au_pps_id) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"PPS change from %d to %d forbidden\\n\",\nVAR_0->au_pps_id, VAR_3);", "return AVERROR_INVALIDDATA;", "}", "pps = VAR_0->pps_buffers[VAR_3];", "if (!VAR_0->sps_buffers[pps->sps_id]) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"non-existing SPS %u referenced\\n\",\nVAR_0->pps.sps_id);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_15)\nVAR_0->pps = *VAR_0->pps_buffers[VAR_3];", "if (pps->sps_id != VAR_0->sps.sps_id ||\npps->sps_id != VAR_0->current_sps_id ||\nVAR_0->sps_buffers[pps->sps_id]->new) {", "if (!VAR_15) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"SPS changed in the middle of the frame\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->sps = *VAR_0->sps_buffers[VAR_0->pps.sps_id];", "if (VAR_0->mb_width != VAR_0->sps.mb_width ||\nVAR_0->mb_height != VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag) ||\nVAR_0->cur_bit_depth_luma != VAR_0->sps.bit_depth_luma ||\nVAR_0->cur_chroma_format_idc != VAR_0->sps.chroma_format_idc\n)\nVAR_12 = 1;", "if (VAR_0->bit_depth_luma != VAR_0->sps.bit_depth_luma ||\nVAR_0->chroma_format_idc != VAR_0->sps.chroma_format_idc) {", "VAR_0->bit_depth_luma = VAR_0->sps.bit_depth_luma;", "VAR_0->chroma_format_idc = VAR_0->sps.chroma_format_idc;", "VAR_12 = 1;", "}", "if ((VAR_4 = ff_h264_set_parameter_from_sps(VAR_0)) < 0)\nreturn VAR_4;", "}", "VAR_0->avctx->profile = ff_h264_get_profile(&VAR_0->sps);", "VAR_0->avctx->level = VAR_0->sps.level_idc;", "VAR_0->avctx->refs = VAR_0->sps.ref_frame_count;", "VAR_11 = (VAR_0->context_initialized &&\n( 16*VAR_0->sps.mb_width != VAR_0->avctx->coded_width\n|| 16*VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag) != VAR_0->avctx->coded_height\n|| VAR_0->cur_bit_depth_luma != VAR_0->sps.bit_depth_luma\n|| VAR_0->cur_chroma_format_idc != VAR_0->sps.chroma_format_idc\n|| VAR_0->mb_width != VAR_0->sps.mb_width\n|| VAR_0->mb_height != VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag)\n));", "if (VAR_0->avctx->pix_fmt == AV_PIX_FMT_NONE\n|| (non_j_pixfmt(VAR_0->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(VAR_0, 0))))\nVAR_11 = 1;", "if (VAR_15 && av_cmp_q(VAR_0->sps.sar, VAR_0->avctx->sample_aspect_ratio))\nVAR_11 = 1;", "VAR_0->mb_width = VAR_0->sps.mb_width;", "VAR_0->mb_height = VAR_0->sps.mb_height * (2 - VAR_0->sps.frame_mbs_only_flag);", "VAR_0->mb_num = VAR_0->mb_width * VAR_0->mb_height;", "VAR_0->mb_stride = VAR_0->mb_width + 1;", "VAR_0->b_stride = VAR_0->mb_width * 4;", "VAR_0->chroma_y_shift = VAR_0->sps.chroma_format_idc <= 1;", "VAR_0->width = 16 * VAR_0->mb_width;", "VAR_0->height = 16 * VAR_0->mb_height;", "VAR_4 = init_dimensions(VAR_0);", "if (VAR_4 < 0)\nreturn VAR_4;", "if (VAR_0->sps.video_signal_type_present_flag) {", "VAR_0->avctx->color_range = VAR_0->sps.full_range>0 ? AVCOL_RANGE_JPEG\n: AVCOL_RANGE_MPEG;", "if (VAR_0->sps.colour_description_present_flag) {", "if (VAR_0->avctx->colorspace != VAR_0->sps.colorspace)\nVAR_12 = 1;", "VAR_0->avctx->color_primaries = VAR_0->sps.color_primaries;", "VAR_0->avctx->color_trc = VAR_0->sps.color_trc;", "VAR_0->avctx->colorspace = VAR_0->sps.colorspace;", "}", "}", "if (VAR_0->context_initialized &&\n(VAR_11 || VAR_12)) {", "if (VAR_1 != VAR_0->slice_ctx) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"changing width %d -> %d / height %d -> %d on \"\n\"slice %d\\n\",\nVAR_0->width, VAR_0->avctx->coded_width,\nVAR_0->height, VAR_0->avctx->coded_height,\nVAR_0->current_slice + 1);", "return AVERROR_INVALIDDATA;", "}", "av_assert1(VAR_15);", "ff_h264_flush_change(VAR_0);", "if ((VAR_4 = get_pixel_format(VAR_0, 1)) < 0)\nreturn VAR_4;", "VAR_0->avctx->pix_fmt = VAR_4;", "av_log(VAR_0->avctx, AV_LOG_INFO, \"Reinit context to %dx%d, \"\n\"pix_fmt: %s\\n\", VAR_0->width, VAR_0->height, av_get_pix_fmt_name(VAR_0->avctx->pix_fmt));", "if ((VAR_4 = h264_slice_header_init(VAR_0, 1)) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"h264_slice_header_init() failed\\n\");", "return VAR_4;", "}", "}", "if (!VAR_0->context_initialized) {", "if (VAR_1 != VAR_0->slice_ctx) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Cannot (re-)initialize context during parallel decoding.\\n\");", "return AVERROR_PATCHWELCOME;", "}", "if ((VAR_4 = get_pixel_format(VAR_0, 1)) < 0)\nreturn VAR_4;", "VAR_0->avctx->pix_fmt = VAR_4;", "if ((VAR_4 = h264_slice_header_init(VAR_0, 0)) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"h264_slice_header_init() failed\\n\");", "return VAR_4;", "}", "}", "if (VAR_15 && VAR_0->dequant_coeff_pps != VAR_3) {", "VAR_0->dequant_coeff_pps = VAR_3;", "ff_h264_init_dequant_tables(VAR_0);", "}", "VAR_16 = get_bits(&VAR_1->gb, VAR_0->sps.log2_max_frame_num);", "if (!VAR_15) {", "if (VAR_0->VAR_16 != VAR_16) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Frame num change from %d to %d\\n\",\nVAR_0->VAR_16, VAR_16);", "return AVERROR_INVALIDDATA;", "}", "}", "VAR_1->mb_mbaff = 0;", "VAR_0->mb_aff_frame = 0;", "VAR_9 = VAR_0->VAR_17;", "VAR_10 = VAR_0->VAR_18;", "VAR_18 = VAR_0->nal_ref_idc == 0;", "if (VAR_0->sps.frame_mbs_only_flag) {", "VAR_17 = PICT_FRAME;", "} else {", "if (!VAR_0->sps.direct_8x8_inference_flag && VAR_5 == AV_PICTURE_TYPE_B) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"This stream was generated by a broken encoder, invalid 8x8 inference\\n\");", "return -1;", "}", "VAR_13 = get_bits1(&VAR_1->gb);", "if (VAR_13) {", "VAR_14 = get_bits1(&VAR_1->gb);", "VAR_17 = PICT_TOP_FIELD + VAR_14;", "} else {", "VAR_17 = PICT_FRAME;", "VAR_0->mb_aff_frame = VAR_0->sps.mb_aff;", "}", "}", "if (VAR_0->current_slice) {", "if (VAR_9 != VAR_17 ||\nVAR_10 != VAR_18) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Changing field mode (%d -> %d) between slices is not allowed\\n\",\nVAR_9, VAR_0->VAR_17);", "return AVERROR_INVALIDDATA;", "} else if (!VAR_0->cur_pic_ptr) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"unset cur_pic_ptr on slice %d\\n\",\nVAR_0->current_slice + 1);", "return AVERROR_INVALIDDATA;", "}", "}", "VAR_0->VAR_17 = VAR_17;", "VAR_0->VAR_18 = VAR_18;", "VAR_0->VAR_16 = VAR_16;", "VAR_1->mb_field_decoding_flag = VAR_17 != PICT_FRAME;", "if (VAR_0->current_slice == 0) {", "if (VAR_0->VAR_16 != VAR_0->prev_frame_num) {", "int VAR_19 = VAR_0->prev_frame_num;", "int VAR_20 = 1 << VAR_0->sps.log2_max_frame_num;", "if (VAR_19 > VAR_0->VAR_16)\nVAR_19 -= VAR_20;", "if ((VAR_0->VAR_16 - VAR_19) > VAR_0->sps.ref_frame_count) {", "VAR_19 = (VAR_0->VAR_16 - VAR_0->sps.ref_frame_count) - 1;", "if (VAR_19 < 0)\nVAR_19 += VAR_20;", "VAR_0->prev_frame_num = VAR_19;", "}", "}", "if (VAR_0->first_field) {", "assert(VAR_0->cur_pic_ptr);", "assert(VAR_0->cur_pic_ptr->f.buf[0]);", "assert(VAR_0->cur_pic_ptr->reference != DELAYED_PIC_REF);", "if (VAR_0->cur_pic_ptr->tf.owner == VAR_0->avctx) {", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,\nVAR_9 == PICT_BOTTOM_FIELD);", "}", "if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_9) {", "if (VAR_9 != PICT_FRAME) {", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,\nVAR_9 == PICT_TOP_FIELD);", "}", "} else {", "if (VAR_0->cur_pic_ptr->VAR_16 != VAR_0->VAR_16) {", "if (VAR_9 != PICT_FRAME) {", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,\nVAR_9 == PICT_TOP_FIELD);", "}", "} else {", "if (!((VAR_9 == PICT_TOP_FIELD &&\nVAR_0->VAR_17 == PICT_BOTTOM_FIELD) ||\n(VAR_9 == PICT_BOTTOM_FIELD &&\nVAR_0->VAR_17 == PICT_TOP_FIELD))) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Invalid field mode combination %d/%d\\n\",\nVAR_9, VAR_0->VAR_17);", "VAR_0->VAR_17 = VAR_9;", "VAR_0->VAR_18 = VAR_10;", "return AVERROR_INVALIDDATA;", "} else if (VAR_10 != VAR_0->VAR_18) {", "avpriv_request_sample(VAR_0->avctx,\n\"Found reference and non-reference fields in the same frame, which\");", "VAR_0->VAR_17 = VAR_9;", "VAR_0->VAR_18 = VAR_10;", "return AVERROR_PATCHWELCOME;", "}", "}", "}", "}", "while (VAR_0->VAR_16 != VAR_0->prev_frame_num && !VAR_0->first_field &&\nVAR_0->VAR_16 != (VAR_0->prev_frame_num + 1) % (1 << VAR_0->sps.log2_max_frame_num)) {", "H264Picture *prev = VAR_0->short_ref_count ? VAR_0->short_ref[0] : NULL;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"Frame num gap %d %d\\n\",\nVAR_0->VAR_16, VAR_0->prev_frame_num);", "if (!VAR_0->sps.gaps_in_frame_num_allowed_flag)\nfor(VAR_7=0; VAR_7<FF_ARRAY_ELEMS(VAR_0->last_pocs); VAR_7++)", "VAR_0->last_pocs[VAR_7] = INT_MIN;", "VAR_4 = h264_frame_start(VAR_0);", "if (VAR_4 < 0) {", "VAR_0->first_field = 0;", "return VAR_4;", "}", "VAR_0->prev_frame_num++;", "VAR_0->prev_frame_num %= 1 << VAR_0->sps.log2_max_frame_num;", "VAR_0->cur_pic_ptr->VAR_16 = VAR_0->prev_frame_num;", "VAR_0->cur_pic_ptr->invalid_gap = !VAR_0->sps.gaps_in_frame_num_allowed_flag;", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 0);", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 1);", "VAR_4 = ff_generate_sliding_window_mmcos(VAR_0, 1);", "if (VAR_4 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))\nreturn VAR_4;", "VAR_4 = ff_h264_execute_ref_pic_marking(VAR_0, VAR_0->mmco, VAR_0->mmco_index);", "if (VAR_4 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))\nreturn VAR_4;", "if (VAR_0->short_ref_count) {", "if (prev) {", "av_image_copy(VAR_0->short_ref[0]->f.data,\nVAR_0->short_ref[0]->f.linesize,\n(const uint8_t **)prev->f.data,\nprev->f.linesize,\nVAR_0->avctx->pix_fmt,\nVAR_0->mb_width * 16,\nVAR_0->mb_height * 16);", "VAR_0->short_ref[0]->poc = prev->poc + 2;", "}", "VAR_0->short_ref[0]->VAR_16 = VAR_0->prev_frame_num;", "}", "}", "if (VAR_0->first_field) {", "assert(VAR_0->cur_pic_ptr);", "assert(VAR_0->cur_pic_ptr->f.buf[0]);", "assert(VAR_0->cur_pic_ptr->reference != DELAYED_PIC_REF);", "if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_9) {", "VAR_0->missing_fields ++;", "VAR_0->cur_pic_ptr = NULL;", "VAR_0->first_field = FIELD_PICTURE(VAR_0);", "} else {", "VAR_0->missing_fields = 0;", "if (VAR_0->cur_pic_ptr->VAR_16 != VAR_0->VAR_16) {", "ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,\nVAR_0->VAR_17==PICT_BOTTOM_FIELD);", "VAR_0->first_field = 1;", "VAR_0->cur_pic_ptr = NULL;", "} else {", "VAR_0->first_field = 0;", "}", "}", "} else {", "VAR_0->first_field = FIELD_PICTURE(VAR_0);", "}", "if (!FIELD_PICTURE(VAR_0) || VAR_0->first_field) {", "if (h264_frame_start(VAR_0) < 0) {", "VAR_0->first_field = 0;", "return AVERROR_INVALIDDATA;", "}", "} else {", "release_unused_pictures(VAR_0, 0);", "}", "if (FIELD_PICTURE(VAR_0)) {", "for(VAR_7 = (VAR_0->VAR_17 == PICT_BOTTOM_FIELD); VAR_7<VAR_0->mb_height; VAR_7++)", "memset(VAR_0->slice_table + VAR_7*VAR_0->mb_stride, -1, (VAR_0->mb_stride - (VAR_7+1==VAR_0->mb_height)) * sizeof(*VAR_0->slice_table));", "} else {", "memset(VAR_0->slice_table, -1,\n(VAR_0->mb_height * VAR_0->mb_stride - 1) * sizeof(*VAR_0->slice_table));", "}", "VAR_0->last_slice_type = -1;", "}", "VAR_0->cur_pic_ptr->VAR_16 = VAR_0->VAR_16;", "av_assert1(VAR_0->mb_num == VAR_0->mb_width * VAR_0->mb_height);", "if (VAR_2 << FIELD_OR_MBAFF_PICTURE(VAR_0) >= VAR_0->mb_num ||\nVAR_2 >= VAR_0->mb_num) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_2 overflow\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_1->resync_mb_x = VAR_1->mb_x = VAR_2 % VAR_0->mb_width;", "VAR_1->resync_mb_y = VAR_1->mb_y = (VAR_2 / VAR_0->mb_width) <<\nFIELD_OR_MBAFF_PICTURE(VAR_0);", "if (VAR_0->VAR_17 == PICT_BOTTOM_FIELD)\nVAR_1->resync_mb_y = VAR_1->mb_y = VAR_1->mb_y + 1;", "av_assert1(VAR_1->mb_y < VAR_0->mb_height);", "if (VAR_0->VAR_17 == PICT_FRAME) {", "VAR_0->curr_pic_num = VAR_0->VAR_16;", "VAR_0->max_pic_num = 1 << VAR_0->sps.log2_max_frame_num;", "} else {", "VAR_0->curr_pic_num = 2 * VAR_0->VAR_16 + 1;", "VAR_0->max_pic_num = 1 << (VAR_0->sps.log2_max_frame_num + 1);", "}", "if (VAR_0->nal_unit_type == NAL_IDR_SLICE)\nget_ue_golomb(&VAR_1->gb);", "if (VAR_0->sps.poc_type == 0) {", "VAR_0->poc_lsb = get_bits(&VAR_1->gb, VAR_0->sps.log2_max_poc_lsb);", "if (VAR_0->pps.pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME)\nVAR_0->delta_poc_bottom = get_se_golomb(&VAR_1->gb);", "}", "if (VAR_0->sps.poc_type == 1 && !VAR_0->sps.delta_pic_order_always_zero_flag) {", "VAR_0->delta_poc[0] = get_se_golomb(&VAR_1->gb);", "if (VAR_0->pps.pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME)\nVAR_0->delta_poc[1] = get_se_golomb(&VAR_1->gb);", "}", "ff_init_poc(VAR_0, VAR_0->cur_pic_ptr->field_poc, &VAR_0->cur_pic_ptr->poc);", "if (VAR_0->pps.redundant_pic_cnt_present)\nVAR_1->redundant_pic_count = get_ue_golomb(&VAR_1->gb);", "VAR_4 = ff_set_ref_count(VAR_0, VAR_1);", "if (VAR_4 < 0)\nreturn VAR_4;", "if (VAR_5 != AV_PICTURE_TYPE_I &&\n(VAR_0->current_slice == 0 ||\nVAR_5 != VAR_0->last_slice_type ||\nmemcmp(VAR_0->last_ref_count, VAR_1->ref_count, sizeof(VAR_1->ref_count)))) {", "ff_h264_fill_default_ref_list(VAR_0, VAR_1);", "}", "if (VAR_1->slice_type_nos != AV_PICTURE_TYPE_I) {", "VAR_4 = ff_h264_decode_ref_pic_list_reordering(VAR_0, VAR_1);", "if (VAR_4 < 0) {", "VAR_1->ref_count[1] = VAR_1->ref_count[0] = 0;", "return VAR_4;", "}", "}", "if ((VAR_0->pps.weighted_pred && VAR_1->slice_type_nos == AV_PICTURE_TYPE_P) ||\n(VAR_0->pps.weighted_bipred_idc == 1 &&\nVAR_1->slice_type_nos == AV_PICTURE_TYPE_B))\nff_pred_weight_table(VAR_0, VAR_1);", "else if (VAR_0->pps.weighted_bipred_idc == 2 &&\nVAR_1->slice_type_nos == AV_PICTURE_TYPE_B) {", "implicit_weight_table(VAR_0, VAR_1, -1);", "} else {", "VAR_1->use_weight = 0;", "for (VAR_7 = 0; VAR_7 < 2; VAR_7++) {", "VAR_1->luma_weight_flag[VAR_7] = 0;", "VAR_1->chroma_weight_flag[VAR_7] = 0;", "}", "}", "if (VAR_0->nal_ref_idc) {", "VAR_4 = ff_h264_decode_ref_pic_marking(VAR_0, &VAR_1->gb,\n!(VAR_0->avctx->active_thread_type & FF_THREAD_FRAME) ||\nVAR_0->current_slice == 0);", "if (VAR_4 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))\nreturn AVERROR_INVALIDDATA;", "}", "if (FRAME_MBAFF(VAR_0)) {", "ff_h264_fill_mbaff_ref_list(VAR_0, VAR_1);", "if (VAR_0->pps.weighted_bipred_idc == 2 && VAR_1->slice_type_nos == AV_PICTURE_TYPE_B) {", "implicit_weight_table(VAR_0, VAR_1, 0);", "implicit_weight_table(VAR_0, VAR_1, 1);", "}", "}", "if (VAR_1->slice_type_nos == AV_PICTURE_TYPE_B && !VAR_1->direct_spatial_mv_pred)\nff_h264_direct_dist_scale_factor(VAR_0, VAR_1);", "ff_h264_direct_ref_list_init(VAR_0, VAR_1);", "if (VAR_1->slice_type_nos != AV_PICTURE_TYPE_I && VAR_0->pps.cabac) {", "VAR_6 = get_ue_golomb_31(&VAR_1->gb);", "if (VAR_6 > 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"cabac_init_idc %u overflow\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "VAR_1->cabac_init_idc = VAR_6;", "}", "VAR_1->last_qscale_diff = 0;", "VAR_6 = VAR_0->pps.init_qp + get_se_golomb(&VAR_1->gb);", "if (VAR_6 > 51 + 6 * (VAR_0->sps.bit_depth_luma - 8)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"QP %u out of range\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "VAR_1->qscale = VAR_6;", "VAR_1->chroma_qp[0] = get_chroma_qp(VAR_0, 0, VAR_1->qscale);", "VAR_1->chroma_qp[1] = get_chroma_qp(VAR_0, 1, VAR_1->qscale);", "if (VAR_1->VAR_5 == AV_PICTURE_TYPE_SP)\nget_bits1(&VAR_1->gb);", "if (VAR_1->VAR_5 == AV_PICTURE_TYPE_SP ||\nVAR_1->VAR_5 == AV_PICTURE_TYPE_SI)\nget_se_golomb(&VAR_1->gb);", "VAR_1->deblocking_filter = 1;", "VAR_1->slice_alpha_c0_offset = 0;", "VAR_1->slice_beta_offset = 0;", "if (VAR_0->pps.deblocking_filter_parameters_present) {", "VAR_6 = get_ue_golomb_31(&VAR_1->gb);", "if (VAR_6 > 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"deblocking_filter_idc %u out of range\\n\", VAR_6);", "return AVERROR_INVALIDDATA;", "}", "VAR_1->deblocking_filter = VAR_6;", "if (VAR_1->deblocking_filter < 2)\nVAR_1->deblocking_filter ^= 1;", "if (VAR_1->deblocking_filter) {", "VAR_1->slice_alpha_c0_offset = get_se_golomb(&VAR_1->gb) * 2;", "VAR_1->slice_beta_offset = get_se_golomb(&VAR_1->gb) * 2;", "if (VAR_1->slice_alpha_c0_offset > 12 ||\nVAR_1->slice_alpha_c0_offset < -12 ||\nVAR_1->slice_beta_offset > 12 ||\nVAR_1->slice_beta_offset < -12) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"deblocking filter parameters %d %d out of range\\n\",\nVAR_1->slice_alpha_c0_offset, VAR_1->slice_beta_offset);", "return AVERROR_INVALIDDATA;", "}", "}", "}", "if (VAR_0->avctx->skip_loop_filter >= AVDISCARD_ALL ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&\nVAR_0->nal_unit_type != NAL_IDR_SLICE) ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&\nVAR_1->slice_type_nos != AV_PICTURE_TYPE_I) ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_BIDIR &&\nVAR_1->slice_type_nos == AV_PICTURE_TYPE_B) ||\n(VAR_0->avctx->skip_loop_filter >= AVDISCARD_NONREF &&\nVAR_0->nal_ref_idc == 0))\nVAR_1->deblocking_filter = 0;", "if (VAR_1->deblocking_filter == 1 && VAR_0->max_contexts > 1) {", "if (VAR_0->avctx->flags2 & CODEC_FLAG2_FAST) {", "VAR_1->deblocking_filter = 2;", "} else {", "VAR_0->max_contexts = 1;", "if (!VAR_0->single_decode_warning) {", "av_log(VAR_0->avctx, AV_LOG_INFO,\n\"Cannot parallelize slice decoding with deblocking filter type 1, decoding such frames in sequential order\\n\"\n\"To parallelize slice decoding you need video encoded with disable_deblocking_filter_idc set to 2 (deblock only edges that do not cross slices).\\n\"\n\"Setting the flags2 libavcodec option to +fast (-flags2 +fast) will disable deblocking across slices and enable parallel slice decoding \"\n\"but will generate non-standard-compliant output.\\n\");", "VAR_0->single_decode_warning = 1;", "}", "if (VAR_1 != VAR_0->slice_ctx) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Deblocking switched inside frame.\\n\");", "return SLICE_SINGLETHREAD;", "}", "}", "}", "VAR_1->qp_thresh = 15 -\nFFMIN(VAR_1->slice_alpha_c0_offset, VAR_1->slice_beta_offset) -\nFFMAX3(0,\nVAR_0->pps.chroma_qp_index_offset[0],\nVAR_0->pps.chroma_qp_index_offset[1]) +\n6 * (VAR_0->sps.bit_depth_luma - 8);", "VAR_0->last_slice_type = VAR_5;", "memcpy(VAR_0->last_ref_count, VAR_1->ref_count, sizeof(VAR_0->last_ref_count));", "VAR_1->slice_num = ++VAR_0->current_slice;", "if (VAR_1->slice_num)\nVAR_0->slice_row[(VAR_1->slice_num-1)&(MAX_SLICES-1)]= VAR_1->resync_mb_y;", "if ( VAR_0->slice_row[VAR_1->slice_num&(MAX_SLICES-1)] + 3 >= VAR_1->resync_mb_y\n&& VAR_0->slice_row[VAR_1->slice_num&(MAX_SLICES-1)] <= VAR_1->resync_mb_y\n&& VAR_1->slice_num >= MAX_SLICES) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\\n\", VAR_1->slice_num, MAX_SLICES);", "}", "for (VAR_8 = 0; VAR_8 < 2; VAR_8++) {", "int VAR_21[16];", "int *VAR_22 = VAR_1->VAR_22[VAR_1->slice_num & (MAX_SLICES - 1)][VAR_8];", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++) {", "VAR_21[VAR_7] = 60;", "if (VAR_8 < VAR_1->list_count && VAR_7 < VAR_1->ref_count[VAR_8] &&\nVAR_1->ref_list[VAR_8][VAR_7].parent->f.buf[0]) {", "int VAR_23;", "AVBuffer *buf = VAR_1->ref_list[VAR_8][VAR_7].parent->f.buf[0]->buffer;", "for (VAR_23 = 0; VAR_23 < VAR_0->short_ref_count; VAR_23++)", "if (VAR_0->short_ref[VAR_23]->f.buf[0]->buffer == buf) {", "VAR_21[VAR_7] = VAR_23;", "break;", "}", "for (VAR_23 = 0; VAR_23 < VAR_0->long_ref_count; VAR_23++)", "if (VAR_0->long_ref[VAR_23] && VAR_0->long_ref[VAR_23]->f.buf[0]->buffer == buf) {", "VAR_21[VAR_7] = VAR_0->short_ref_count + VAR_23;", "break;", "}", "}", "}", "VAR_22[0] =\nVAR_22[1] = -1;", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++)", "VAR_22[VAR_7 + 2] = 4 * VAR_21[VAR_7] + (VAR_1->ref_list[VAR_8][VAR_7].reference & 3);", "VAR_22[18 + 0] =\nVAR_22[18 + 1] = -1;", "for (VAR_7 = 16; VAR_7 < 48; VAR_7++)", "VAR_22[VAR_7 + 4] = 4 * VAR_21[(VAR_7 - 16) >> 1] +\n(VAR_1->ref_list[VAR_8][VAR_7].reference & 3);", "}", "VAR_0->au_pps_id = VAR_3;", "VAR_0->sps.new =\nVAR_0->sps_buffers[VAR_0->pps.sps_id]->new = 0;", "VAR_0->current_sps_id = VAR_0->pps.sps_id;", "if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO) {", "av_log(VAR_0->avctx, AV_LOG_DEBUG,\n\"slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\\n\",\nVAR_1->slice_num,\n(VAR_0->VAR_17 == PICT_FRAME ? \"F\" : VAR_0->VAR_17 == PICT_TOP_FIELD ? \"T\" : \"B\"),\nVAR_2,\nav_get_picture_type_char(VAR_1->VAR_5),\nVAR_1->slice_type_fixed ? \" fix\" : \"\",\nVAR_0->nal_unit_type == NAL_IDR_SLICE ? \" IDR\" : \"\",\nVAR_3, VAR_0->VAR_16,\nVAR_0->cur_pic_ptr->field_poc[0],\nVAR_0->cur_pic_ptr->field_poc[1],\nVAR_1->ref_count[0], VAR_1->ref_count[1],\nVAR_1->qscale,\nVAR_1->deblocking_filter,\nVAR_1->slice_alpha_c0_offset, VAR_1->slice_beta_offset,\nVAR_1->use_weight,\nVAR_1->use_weight == 1 && VAR_1->use_weight_chroma ? \"c\" : \"\",\nVAR_1->VAR_5 == AV_PICTURE_TYPE_B ? (VAR_1->direct_spatial_mv_pred ? \"SPAT\" : \"TEMP\") : \"\");", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93, 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137, 139, 141, 143, 145, 147 ], [ 149 ], [ 151 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173, 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185, 187, 189 ], [ 191 ], [ 193 ], [ 197 ], [ 201 ], [ 203, 205, 207 ], [ 209 ], [ 211 ], [ 213, 215 ], [ 219, 221, 223 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 239 ], [ 243, 245, 247, 249, 251, 253 ], [ 257, 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269, 271 ], [ 273 ], [ 277 ], [ 279 ], [ 281 ], [ 285, 287, 289, 291, 293, 295, 297, 299 ], [ 301, 303, 305 ], [ 309, 311 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 325 ], [ 329 ], [ 333 ], [ 335 ], [ 339 ], [ 341, 343 ], [ 347 ], [ 349, 351 ], [ 353 ], [ 355, 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 371, 373 ], [ 375 ], [ 377, 379, 381, 383, 385, 387 ], [ 389 ], [ 391 ], [ 395 ], [ 399 ], [ 403, 405 ], [ 407 ], [ 411, 413 ], [ 417 ], [ 419, 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433, 435 ], [ 437 ], [ 439 ], [ 443, 445 ], [ 447 ], [ 451 ], [ 453, 455 ], [ 457 ], [ 459 ], [ 461 ], [ 465 ], [ 467 ], [ 469 ], [ 471 ], [ 475 ], [ 477 ], [ 479 ], [ 481, 483 ], [ 485 ], [ 487 ], [ 489 ], [ 493 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539, 541 ], [ 543, 545, 547 ], [ 549 ], [ 551 ], [ 553, 555, 557 ], [ 559 ], [ 561 ], [ 563 ], [ 567 ], [ 569 ], [ 571 ], [ 573 ], [ 577 ], [ 583 ], [ 585 ], [ 587 ], [ 591, 593 ], [ 597 ], [ 599 ], [ 601, 603 ], [ 607 ], [ 609 ], [ 611 ], [ 625 ], [ 627 ], [ 629 ], [ 631 ], [ 637 ], [ 639, 641 ], [ 643 ], [ 649 ], [ 655 ], [ 657, 659 ], [ 661 ], [ 663 ], [ 665 ], [ 675 ], [ 677, 679 ], [ 681 ], [ 683 ], [ 687, 689, 691, 693 ], [ 695, 697, 699 ], [ 701 ], [ 703 ], [ 705 ], [ 707 ], [ 709, 711 ], [ 713 ], [ 715 ], [ 717 ], [ 719 ], [ 721 ], [ 723 ], [ 725 ], [ 729, 731 ], [ 733 ], [ 735, 737 ], [ 739, 741 ], [ 743 ], [ 745 ], [ 747 ], [ 749 ], [ 751 ], [ 753 ], [ 757 ], [ 759 ], [ 761 ], [ 763 ], [ 765 ], [ 767 ], [ 769 ], [ 771, 773 ], [ 775 ], [ 777, 779 ], [ 795 ], [ 797 ], [ 799, 801, 803, 805, 807, 809, 811 ], [ 813 ], [ 815 ], [ 817 ], [ 819 ], [ 821 ], [ 831 ], [ 833 ], [ 835 ], [ 837 ], [ 843 ], [ 849 ], [ 851 ], [ 853 ], [ 855 ], [ 857 ], [ 859 ], [ 861, 863 ], [ 871 ], [ 873 ], [ 875 ], [ 879 ], [ 881 ], [ 883 ], [ 885 ], [ 889 ], [ 891 ], [ 895 ], [ 897 ], [ 899 ], [ 901 ], [ 903 ], [ 905 ], [ 907 ], [ 909 ], [ 915 ], [ 917 ], [ 919 ], [ 921 ], [ 923, 925 ], [ 927 ], [ 929 ], [ 931 ], [ 937 ], [ 941 ], [ 943, 945 ], [ 947 ], [ 949 ], [ 951 ], [ 953 ], [ 955, 957 ], [ 959, 961 ], [ 963 ], [ 967 ], [ 969 ], [ 971 ], [ 973 ], [ 975 ], [ 977 ], [ 979 ], [ 983, 985 ], [ 989 ], [ 991 ], [ 995, 997 ], [ 999 ], [ 1003 ], [ 1005 ], [ 1009, 1011 ], [ 1013 ], [ 1017 ], [ 1021, 1023 ], [ 1027 ], [ 1029, 1031 ], [ 1035, 1037, 1039, 1041 ], [ 1045 ], [ 1047 ], [ 1051 ], [ 1053 ], [ 1055 ], [ 1057 ], [ 1059 ], [ 1061 ], [ 1063 ], [ 1067, 1069, 1071, 1073 ], [ 1075, 1077 ], [ 1079 ], [ 1081 ], [ 1083 ], [ 1085 ], [ 1087 ], [ 1089 ], [ 1091 ], [ 1093 ], [ 1107 ], [ 1109, 1111, 1113 ], [ 1115, 1117 ], [ 1119 ], [ 1123 ], [ 1125 ], [ 1129 ], [ 1131 ], [ 1133 ], [ 1135 ], [ 1137 ], [ 1141, 1143 ], [ 1145 ], [ 1149 ], [ 1151 ], [ 1153 ], [ 1155 ], [ 1157 ], [ 1159 ], [ 1161 ], [ 1163 ], [ 1167 ], [ 1169 ], [ 1171 ], [ 1173 ], [ 1175 ], [ 1177 ], [ 1179 ], [ 1181 ], [ 1183 ], [ 1187, 1189 ], [ 1191, 1193, 1195 ], [ 1199 ], [ 1201 ], [ 1203 ], [ 1205 ], [ 1207 ], [ 1209 ], [ 1211, 1213 ], [ 1215 ], [ 1217 ], [ 1219 ], [ 1221, 1223 ], [ 1227 ], [ 1229 ], [ 1231 ], [ 1233, 1235, 1237, 1239 ], [ 1241, 1243, 1245 ], [ 1247 ], [ 1249 ], [ 1251 ], [ 1253 ], [ 1257, 1259, 1261, 1263, 1265, 1267, 1269, 1271, 1273, 1275 ], [ 1279 ], [ 1281 ], [ 1287 ], [ 1289 ], [ 1291 ], [ 1293 ], [ 1295, 1297, 1299, 1301, 1303 ], [ 1305 ], [ 1307 ], [ 1309 ], [ 1311, 1313 ], [ 1315 ], [ 1317 ], [ 1319 ], [ 1321 ], [ 1323, 1325, 1327, 1329, 1331, 1333 ], [ 1337 ], [ 1339 ], [ 1341 ], [ 1345, 1347 ], [ 1349, 1351, 1353 ], [ 1357 ], [ 1359 ], [ 1363 ], [ 1365 ], [ 1367 ], [ 1369 ], [ 1371 ], [ 1373, 1375 ], [ 1377 ], [ 1379 ], [ 1381 ], [ 1383 ], [ 1385 ], [ 1387 ], [ 1389 ], [ 1391 ], [ 1393 ], [ 1395 ], [ 1397 ], [ 1399 ], [ 1401 ], [ 1403 ], [ 1407, 1409 ], [ 1411 ], [ 1413 ], [ 1415, 1417 ], [ 1419 ], [ 1421, 1423 ], [ 1425 ], [ 1429 ], [ 1431, 1433 ], [ 1435 ], [ 1439 ], [ 1441, 1443, 1445, 1447, 1449, 1451, 1453, 1455, 1457, 1459, 1461, 1463, 1465, 1467, 1469, 1471, 1473, 1475 ], [ 1477 ], [ 1481 ], [ 1483 ] ]

[ "static int FUNC_0(WavpackFrameContext *VAR_0, GetBitContext *VAR_1,\nint VAR_2, int *VAR_3)\n{", "int VAR_4, VAR_5;", "int VAR_6, VAR_7, VAR_8, VAR_9;", "WvChannel *c = &VAR_0->ch[VAR_2];", "*VAR_3 = 0;", "if ((VAR_0->ch[0].median[0] < 2U) && (VAR_0->ch[1].median[0] < 2U) &&\n!VAR_0->zero && !VAR_0->one) {", "if (VAR_0->zeroes) {", "VAR_0->zeroes--;", "if (VAR_0->zeroes) {", "c->slow_level -= LEVEL_DECAY(c->slow_level);", "return 0;", "} else {", "VAR_4 = get_unary_0_33(VAR_1);", "if (VAR_4 >= 2) {", "if (get_bits_left(VAR_1) < VAR_4 - 1)\nVAR_4 = get_bits(VAR_1, VAR_4 - 1) | (1 << (VAR_4-1));", "} else {", "if (get_bits_left(VAR_1) < 0)\nVAR_0->zeroes = VAR_4;", "if (VAR_0->zeroes) {", "memset(VAR_0->ch[0].median, 0, sizeof(VAR_0->ch[0].median));", "memset(VAR_0->ch[1].median, 0, sizeof(VAR_0->ch[1].median));", "c->slow_level -= LEVEL_DECAY(c->slow_level);", "return 0;", "if (VAR_0->zero) {", "VAR_4 = 0;", "VAR_0->zero = 0;", "} else {", "VAR_4 = get_unary_0_33(VAR_1);", "if (get_bits_left(VAR_1) < 0)\nif (VAR_4 == 16) {", "VAR_5 = get_unary_0_33(VAR_1);", "if (VAR_5 < 2) {", "if (get_bits_left(VAR_1) < 0)\nVAR_4 += VAR_5;", "} else {", "if (get_bits_left(VAR_1) < VAR_5 - 1)\nVAR_4 += get_bits(VAR_1, VAR_5 - 1) | (1 << (VAR_5 - 1));", "if (VAR_0->one) {", "VAR_0->one = VAR_4 & 1;", "VAR_4 = (VAR_4 >> 1) + 1;", "} else {", "VAR_0->one = VAR_4 & 1;", "VAR_4 >>= 1;", "VAR_0->zero = !VAR_0->one;", "if (VAR_0->hybrid && !VAR_2)\nupdate_error_limit(VAR_0);", "if (!VAR_4) {", "VAR_7 = 0;", "VAR_8 = GET_MED(0) - 1;", "DEC_MED(0);", "} else if (VAR_4 == 1) {", "VAR_7 = GET_MED(0);", "VAR_8 = GET_MED(1) - 1;", "INC_MED(0);", "DEC_MED(1);", "} else if (VAR_4 == 2) {", "VAR_7 = GET_MED(0) + GET_MED(1);", "VAR_8 = GET_MED(2) - 1;", "INC_MED(0);", "INC_MED(1);", "DEC_MED(2);", "} else {", "VAR_7 = GET_MED(0) + GET_MED(1) + GET_MED(2) * (VAR_4 - 2);", "VAR_8 = GET_MED(2) - 1;", "INC_MED(0);", "INC_MED(1);", "INC_MED(2);", "if (!c->error_limit) {", "VAR_9 = VAR_7 + get_tail(VAR_1, VAR_8);", "if (get_bits_left(VAR_1) <= 0)\n} else {", "int VAR_10 = (VAR_7 * 2 + VAR_8 + 1) >> 1;", "while (VAR_8 > c->error_limit) {", "if (get_bits_left(VAR_1) <= 0)\nif (get_bits1(VAR_1)) {", "VAR_8 -= (VAR_10 - VAR_7);", "VAR_7 = VAR_10;", "} else", "VAR_8 = VAR_10 - VAR_7 - 1;", "VAR_10 = (VAR_7 * 2 + VAR_8 + 1) >> 1;", "VAR_9 = VAR_10;", "VAR_6 = get_bits1(VAR_1);", "if (VAR_0->hybrid_bitrate)\nc->slow_level += wp_log2(VAR_9) - LEVEL_DECAY(c->slow_level);", "return VAR_6 ? ~VAR_9 : VAR_9;", "error:\n*VAR_3 = 1;", "return 0;" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 34 ], [ 36 ], [ 38 ], [ 40, 43 ], [ 45 ], [ 47, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 68 ], [ 70 ], [ 72 ], [ 74 ], [ 76 ], [ 78, 81 ], [ 83 ], [ 85 ], [ 87, 90 ], [ 92 ], [ 94, 97 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 116 ], [ 121, 123 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 170 ], [ 176 ], [ 178, 181 ], [ 183 ], [ 185 ], [ 187, 190 ], [ 192 ], [ 194 ], [ 196 ], [ 198 ], [ 200 ], [ 203 ], [ 206 ], [ 208, 210 ], [ 212 ], [ 216, 218 ], [ 220 ] ]

[ "static pxa2xx_timer_info *FUNC_0(target_phys_addr_t base,\nqemu_irq *irqs)\n{", "int VAR_0;", "int VAR_1;", "pxa2xx_timer_info *s;", "s = (pxa2xx_timer_info *) qemu_mallocz(sizeof(pxa2xx_timer_info));", "s->base = base;", "s->irq_enabled = 0;", "s->oldclock = 0;", "s->clock = 0;", "s->lastload = qemu_get_clock(vm_clock);", "s->reset3 = 0;", "for (VAR_0 = 0; VAR_0 < 4; VAR_0 ++) {", "s->timer[VAR_0].value = 0;", "s->timer[VAR_0].irq = irqs[VAR_0];", "s->timer[VAR_0].info = s;", "s->timer[VAR_0].num = VAR_0;", "s->timer[VAR_0].level = 0;", "s->timer[VAR_0].qtimer = qemu_new_timer(vm_clock,\npxa2xx_timer_tick, &s->timer[VAR_0]);", "}", "VAR_1 = cpu_register_io_memory(0, pxa2xx_timer_readfn,\npxa2xx_timer_writefn, s);", "cpu_register_physical_memory(base, 0x00000fff, VAR_1);", "register_savevm(\"pxa2xx_timer\", 0, 0,\npxa2xx_timer_save, pxa2xx_timer_load, s);", "return s;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0,\nunsigned char *VAR_1, int VAR_2)\n{", "HTTPContext *c = VAR_0;", "if (c->buffer_ptr == c->buffer_end || !c->buffer_ptr)\nc->buffer_ptr = c->buffer_end = c->buffer;", "if (c->buffer_end - c->buffer + VAR_2 > IOBUFFER_MAX_SIZE)\nabort();", "memcpy(c->buffer_end, VAR_1, VAR_2);", "c->buffer_end += VAR_2;", "}" ]

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

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

[ "void FUNC_0(struct NetRxPkt *VAR_0,\nconst struct iovec *VAR_1, int VAR_2,\nsize_t VAR_3, bool VAR_4,\nuint16_t VAR_5)\n{", "uint16_t tci = 0;", "uint16_t ploff = VAR_3;", "assert(VAR_0);", "VAR_0->vlan_stripped = false;", "if (VAR_4) {", "VAR_0->vlan_stripped = eth_strip_vlan_ex(VAR_1, VAR_2, VAR_3, VAR_5,\nVAR_0->ehdr_buf,\n&ploff, &tci);", "}", "VAR_0->tci = tci;", "net_rx_pkt_pull_data(VAR_0, VAR_1, VAR_2, ploff);", "}" ]

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

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

[ "static int FUNC_0(URLContext *VAR_0, uint8_t *VAR_1, int VAR_2)\n{", "HTTPContext *s = VAR_0->priv_data;", "int VAR_3, VAR_4;", "if (!s->hd)\nreturn AVERROR_EOF;", "if (s->end_chunked_post && !s->end_header) {", "VAR_3 = http_read_header(VAR_0, &VAR_4);", "if (VAR_3 < 0)\nreturn VAR_3;", "}", "if (s->chunksize >= 0) {", "if (!s->chunksize) {", "char VAR_5[32];", "for (;;) {", "do {", "if ((VAR_3 = http_get_line(s, VAR_5, sizeof(VAR_5))) < 0)\nreturn VAR_3;", "} while (!*VAR_5);", "s->chunksize = strtoll(VAR_5, NULL, 16);", "av_log(NULL, AV_LOG_TRACE, \"Chunked encoding data VAR_2: %\"PRId64\"'\\n\",\ns->chunksize);", "if (!s->chunksize)\nreturn 0;", "break;", "}", "}", "VAR_2 = FFMIN(VAR_2, s->chunksize);", "}", "#if CONFIG_ZLIB\nif (s->compressed)\nreturn http_buf_read_compressed(VAR_0, VAR_1, VAR_2);", "#endif\nreturn http_buf_read(VAR_0, VAR_1, VAR_2);", "}" ]

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

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

[ "static int FUNC_0(lag_rac *VAR_0, GetBitContext *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "unsigned VAR_5, VAR_6;", "unsigned VAR_7 = 0;", "unsigned VAR_8 = 0;", "VAR_0->VAR_5[0] = 0;", "VAR_0->VAR_5[257] = UINT_MAX;", "for (VAR_2 = 1; VAR_2 < 257; VAR_2++) {", "if (lag_decode_prob(VAR_1, &VAR_0->VAR_5[VAR_2]) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid probability encountered.\\n\");", "return -1;", "}", "if ((uint64_t)VAR_7 + VAR_0->VAR_5[VAR_2] > UINT_MAX) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Integer overflow encountered in cumulative probability calculation.\\n\");", "return -1;", "}", "VAR_7 += VAR_0->VAR_5[VAR_2];", "if (!VAR_0->VAR_5[VAR_2]) {", "if (lag_decode_prob(VAR_1, &VAR_5)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid probability run encountered.\\n\");", "return -1;", "}", "if (VAR_5 > 256 - VAR_2)\nVAR_5 = 256 - VAR_2;", "for (VAR_3 = 0; VAR_3 < VAR_5; VAR_3++)", "VAR_0->VAR_5[++VAR_2] = 0;", "}", "}", "if (!VAR_7) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"All probabilities are 0!\\n\");", "return -1;", "}", "VAR_4 = av_log2(VAR_7);", "if (VAR_7 & (VAR_7 - 1)) {", "uint64_t mul = softfloat_reciprocal(VAR_7);", "for (VAR_2 = 1; VAR_2 <= 128; VAR_2++) {", "VAR_0->VAR_5[VAR_2] = softfloat_mul(VAR_0->VAR_5[VAR_2], mul);", "VAR_8 += VAR_0->VAR_5[VAR_2];", "}", "if (VAR_8 <= 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Scaled probabilities invalid\\n\");", "return AVERROR_INVALIDDATA;", "}", "for (; VAR_2 < 257; VAR_2++) {", "VAR_0->VAR_5[VAR_2] = softfloat_mul(VAR_0->VAR_5[VAR_2], mul);", "VAR_8 += VAR_0->VAR_5[VAR_2];", "}", "VAR_4++;", "VAR_6 = 1 << VAR_4;", "if (VAR_8 > VAR_6) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Scaled probabilities are larger than target!\\n\");", "return -1;", "}", "VAR_8 = VAR_6 - VAR_8;", "for (VAR_2 = 1; VAR_8; VAR_2 = (VAR_2 & 0x7f) + 1) {", "if (VAR_0->VAR_5[VAR_2]) {", "VAR_0->VAR_5[VAR_2]++;", "VAR_8--;", "}", "}", "}", "VAR_0->scale = VAR_4;", "for (VAR_2 = 1; VAR_2 < 257; VAR_2++)", "VAR_0->VAR_5[VAR_2] += VAR_0->VAR_5[VAR_2 - 1];", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 165 ], [ 167 ], [ 171 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ] ]

[ "static int FUNC_0(SCSIDevice *VAR_0, uint8_t *VAR_1)\n{", "int VAR_2 = VAR_1[2] & 0x3;", "int VAR_3;", "int VAR_4 = ata_passthrough_xfer_unit(VAR_0, VAR_1);", "switch (VAR_2) {", "case 0:\ncase 3:\nVAR_3 = 0;", "break;", "case 1:\nVAR_3 = VAR_1[3];", "break;", "case 2:\nVAR_3 = VAR_1[4];", "break;", "}", "return VAR_3 * VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15, 17, 20 ], [ 22 ], [ 24, 26 ], [ 28 ], [ 30, 32 ], [ 34 ], [ 36 ], [ 40 ], [ 42 ] ]

[ "static inline void FUNC_0(float *VAR_0)\n{", "int VAR_1;", "for (VAR_1 = 0; VAR_1 < 256; VAR_1++) {", "VAR_0[VAR_1] += VAR_0[VAR_1 + 512];", "VAR_0[VAR_1 + 256] = VAR_0[VAR_1 + 768];", "VAR_0[VAR_1 + 512] = VAR_0[VAR_1 + 768] = 0;", "}", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0,\nAVFormatParameters *VAR_1)\n{", "AVStream *st;", "st = av_new_stream(VAR_0, 0);", "if (!st)\nreturn AVERROR_NOMEM;", "st->codec->codec_type = CODEC_TYPE_VIDEO;", "st->codec->codec_id = VAR_0->iformat->value;", "st->need_parsing = 1;", "if (VAR_1 && VAR_1->time_base.num) {", "av_set_pts_info(st, 64, VAR_1->time_base.num, VAR_1->time_base.den);", "} else if ( st->codec->codec_id == CODEC_ID_MJPEG ||", "st->codec->codec_id == CODEC_ID_MPEG4 ||\nst->codec->codec_id == CODEC_ID_H264) {", "av_set_pts_info(st, 64, 1, 25);", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{", "Vp3DecodeContext *s = VAR_0->priv_data;", "GetBitContext gb;", "static int VAR_5 = 0;", "int VAR_6;", "init_get_bits(&gb, VAR_3, VAR_4 * 8);", "if (s->theora && get_bits1(&gb))\n{", "#if 1\nav_log(VAR_0, AV_LOG_ERROR, \"Header packet passed to frame decoder, skipping\\n\");", "return -1;", "#else\nint ptype = get_bits(&gb, 7);", "skip_bits(&gb, 6*8);", "switch(ptype)\n{", "case 1:\ntheora_decode_comments(VAR_0, gb);", "break;", "case 2:\ntheora_decode_tables(VAR_0, gb);", "init_dequantizer(s);", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unknown Theora config packet: %d\\n\", ptype);", "}", "return VAR_4;", "#endif\n}", "s->keyframe = !get_bits1(&gb);", "if (!s->theora)\nskip_bits(&gb, 1);", "s->last_quality_index = s->quality_index;", "s->quality_index = get_bits(&gb, 6);", "if (s->theora >= 0x030200)\nskip_bits1(&gb);", "if (s->VAR_0->debug & FF_DEBUG_PICT_INFO)\nav_log(s->VAR_0, AV_LOG_INFO, \" VP3 %sframe #%d: Q index = %d\\n\",\ns->keyframe?\"key\":\"\", VAR_5, s->quality_index);", "VAR_5++;", "if (s->quality_index != s->last_quality_index) {", "init_dequantizer(s);", "init_loop_filter(s);", "}", "if (s->keyframe) {", "if (!s->theora)\n{", "skip_bits(&gb, 4);", "skip_bits(&gb, 4);", "if (s->version)\n{", "s->version = get_bits(&gb, 5);", "if (VAR_5 == 1)\nav_log(s->VAR_0, AV_LOG_DEBUG, \"VP version: %d\\n\", s->version);", "}", "}", "if (s->version || s->theora)\n{", "if (get_bits1(&gb))\nav_log(s->VAR_0, AV_LOG_ERROR, \"Warning, unsupported keyframe coding type?!\\n\");", "skip_bits(&gb, 2);", "}", "if (s->last_frame.VAR_1[0] == s->golden_frame.VAR_1[0]) {", "if (s->golden_frame.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &s->golden_frame);", "s->last_frame= s->golden_frame;", "} else {", "if (s->golden_frame.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &s->golden_frame);", "if (s->last_frame.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &s->last_frame);", "}", "s->golden_frame.reference = 3;", "if(VAR_0->get_buffer(VAR_0, &s->golden_frame) < 0) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"vp3: get_buffer() failed\\n\");", "return -1;", "}", "memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));", "if (!s->pixel_addresses_inited)\n{", "if (!s->flipped_image)\nvp3_calculate_pixel_addresses(s);", "else\ntheora_calculate_pixel_addresses(s);", "}", "} else {", "s->current_frame.reference = 3;", "if(VAR_0->get_buffer(VAR_0, &s->current_frame) < 0) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"vp3: get_buffer() failed\\n\");", "return -1;", "}", "}", "s->current_frame.qscale_table= s->qscale_table;", "s->current_frame.qstride= 0;", "{START_TIMER", "init_frame(s, &gb);", "STOP_TIMER(\"init_frame\")}", "#if KEYFRAMES_ONLY\nif (!s->keyframe) {", "memcpy(s->current_frame.VAR_1[0], s->golden_frame.VAR_1[0],\ns->current_frame.linesize[0] * s->height);", "memcpy(s->current_frame.VAR_1[1], s->golden_frame.VAR_1[1],\ns->current_frame.linesize[1] * s->height / 2);", "memcpy(s->current_frame.VAR_1[2], s->golden_frame.VAR_1[2],\ns->current_frame.linesize[2] * s->height / 2);", "} else {", "#endif\n{START_TIMER", "if (unpack_superblocks(s, &gb)){", "av_log(s->VAR_0, AV_LOG_ERROR, \"error in unpack_superblocks\\n\");", "return -1;", "}", "STOP_TIMER(\"unpack_superblocks\")}", "{START_TIMER", "if (unpack_modes(s, &gb)){", "av_log(s->VAR_0, AV_LOG_ERROR, \"error in unpack_modes\\n\");", "return -1;", "}", "STOP_TIMER(\"unpack_modes\")}", "{START_TIMER", "if (unpack_vectors(s, &gb)){", "av_log(s->VAR_0, AV_LOG_ERROR, \"error in unpack_vectors\\n\");", "return -1;", "}", "STOP_TIMER(\"unpack_vectors\")}", "{START_TIMER", "if (unpack_dct_coeffs(s, &gb)){", "av_log(s->VAR_0, AV_LOG_ERROR, \"error in unpack_dct_coeffs\\n\");", "return -1;", "}", "STOP_TIMER(\"unpack_dct_coeffs\")}", "{START_TIMER", "reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);", "if ((VAR_0->flags & CODEC_FLAG_GRAY) == 0) {", "reverse_dc_prediction(s, s->u_fragment_start,\ns->fragment_width / 2, s->fragment_height / 2);", "reverse_dc_prediction(s, s->v_fragment_start,\ns->fragment_width / 2, s->fragment_height / 2);", "}", "STOP_TIMER(\"reverse_dc_prediction\")}", "{START_TIMER", "for (VAR_6 = 0; VAR_6 < s->macroblock_height; VAR_6++)", "render_slice(s, VAR_6);", "STOP_TIMER(\"render_fragments\")}", "{START_TIMER", "apply_loop_filter(s);", "STOP_TIMER(\"apply_loop_filter\")}", "#if KEYFRAMES_ONLY\n}", "#endif\n*VAR_2=sizeof(AVFrame);", "*(AVFrame*)VAR_1= s->current_frame;", "if ((s->last_frame.VAR_1[0]) &&\n(s->last_frame.VAR_1[0] != s->golden_frame.VAR_1[0]))\nVAR_0->release_buffer(VAR_0, &s->last_frame);", "memcpy(&s->last_frame, &s->current_frame, sizeof(AVFrame));", "s->current_frame.VAR_1[0]= NULL;", "return VAR_4;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23, 25 ], [ 27, 29 ], [ 31 ], [ 33, 35 ], [ 39 ], [ 43, 45 ], [ 47, 49 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 91, 93, 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159, 161 ], [ 163, 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 185 ], [ 191, 193 ], [ 195, 197 ], [ 199, 201 ], [ 203 ], [ 205 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 237, 239 ], [ 243, 245 ], [ 247, 249 ], [ 251, 253 ], [ 257 ], [ 259, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 315 ], [ 317 ], [ 319, 321 ], [ 323, 325 ], [ 327 ], [ 329 ], [ 331 ], [ 335 ], [ 337 ], [ 339 ], [ 343 ], [ 345 ], [ 347 ], [ 349, 351 ], [ 353, 357 ], [ 359 ], [ 367, 369, 371 ], [ 377 ], [ 379 ], [ 383 ], [ 385 ] ]

[ "static inline int FUNC_0(int VAR_0)\n{", "if(host_to_target_errno_table[VAR_0])\nreturn host_to_target_errno_table[VAR_0];", "return VAR_0;", "}" ]

[ 0, 1, 0, 0 ]

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

[ "void FUNC_0(const char *VAR_0, BlockDriverState *VAR_1,\nBlockDriverState *VAR_2, int64_t VAR_3,\nMirrorSyncMode VAR_4, BdrvDirtyBitmap *VAR_5,\nbool VAR_6,\nBlockdevOnError VAR_7,\nBlockdevOnError VAR_8,\nint VAR_9,\nBlockCompletionFunc *VAR_10, void *VAR_11,\nBlockJobTxn *VAR_12, Error **VAR_13)\n{", "int64_t len;", "BlockDriverInfo bdi;", "BackupBlockJob *job = NULL;", "int VAR_14;", "assert(VAR_1);", "assert(VAR_2);", "if (VAR_1 == VAR_2) {", "error_setg(VAR_13, \"Source and VAR_2 cannot be the same\");", "return;", "}", "if (!bdrv_is_inserted(VAR_1)) {", "error_setg(VAR_13, \"Device is not inserted: %s\",\nbdrv_get_device_name(VAR_1));", "return;", "}", "if (!bdrv_is_inserted(VAR_2)) {", "error_setg(VAR_13, \"Device is not inserted: %s\",\nbdrv_get_device_name(VAR_2));", "return;", "}", "if (VAR_6 && VAR_2->drv->bdrv_co_pwritev_compressed == NULL) {", "error_setg(VAR_13, \"Compression is not supported for this drive %s\",\nbdrv_get_device_name(VAR_2));", "return;", "}", "if (bdrv_op_is_blocked(VAR_1, BLOCK_OP_TYPE_BACKUP_SOURCE, VAR_13)) {", "return;", "}", "if (bdrv_op_is_blocked(VAR_2, BLOCK_OP_TYPE_BACKUP_TARGET, VAR_13)) {", "return;", "}", "if (VAR_4 == MIRROR_SYNC_MODE_INCREMENTAL) {", "if (!VAR_5) {", "error_setg(VAR_13, \"must provide a valid bitmap name for \"\n\"\\\"incremental\\\" sync mode\");", "return;", "}", "if (bdrv_dirty_bitmap_create_successor(VAR_1, VAR_5, VAR_13) < 0) {", "return;", "}", "} else if (VAR_5) {", "error_setg(VAR_13,\n\"a VAR_5 was provided to backup_run, \"\n\"but received an incompatible VAR_4 (%s)\",\nMirrorSyncMode_lookup[VAR_4]);", "return;", "}", "len = bdrv_getlength(VAR_1);", "if (len < 0) {", "error_setg_errno(VAR_13, -len, \"unable to get length for '%s'\",\nbdrv_get_device_name(VAR_1));", "goto error;", "}", "job = block_job_create(VAR_0, &backup_job_driver, VAR_1, VAR_3,\nVAR_9, VAR_10, VAR_11, VAR_13);", "if (!job) {", "goto error;", "}", "job->VAR_2 = blk_new();", "blk_insert_bs(job->VAR_2, VAR_2);", "job->VAR_7 = VAR_7;", "job->VAR_8 = VAR_8;", "job->VAR_4 = VAR_4;", "job->VAR_5 = VAR_4 == MIRROR_SYNC_MODE_INCREMENTAL ?\nVAR_5 : NULL;", "job->VAR_6 = VAR_6;", "VAR_14 = bdrv_get_info(VAR_2, &bdi);", "if (VAR_14 < 0 && !VAR_2->backing) {", "error_setg_errno(VAR_13, -VAR_14,\n\"Couldn't determine the cluster size of the VAR_2 image, \"\n\"which has no backing file\");", "error_append_hint(VAR_13,\n\"Aborting, since this may create an unusable destination image\\n\");", "goto error;", "} else if (VAR_14 < 0 && VAR_2->backing) {", "job->cluster_size = BACKUP_CLUSTER_SIZE_DEFAULT;", "} else {", "job->cluster_size = MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);", "}", "block_job_add_bdrv(&job->common, VAR_2);", "job->common.len = len;", "job->common.co = qemu_coroutine_create(backup_run, job);", "block_job_txn_add_job(VAR_12, &job->common);", "qemu_coroutine_enter(job->common.co);", "return;", "error:\nif (VAR_5) {", "bdrv_reclaim_dirty_bitmap(VAR_1, VAR_5, NULL);", "}", "if (job) {", "blk_unref(job->VAR_2);", "block_job_unref(&job->common);", "}", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 125, 127, 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 189 ], [ 191 ], [ 193, 195, 197 ], [ 199, 201 ], [ 203 ], [ 205 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 233, 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "Coroutine *co = VAR_0;", "qemu_coroutine_enter(co, NULL);", "}" ]

[ 0, 0, 1, 0 ]

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

[ "static void FUNC_0(NBDClientSession *VAR_0,\nNBDRequest *VAR_1)\n{", "if (VAR_0->in_flight == MAX_NBD_REQUESTS) {", "qemu_co_queue_wait(&VAR_0->free_sema, NULL);", "assert(VAR_0->in_flight < MAX_NBD_REQUESTS);", "}", "VAR_0->in_flight++;", "}" ]

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

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

[ "void FUNC_0(H264Context *const VAR_0)\n{", "const int VAR_5 = VAR_0->cur_pic_ptr->field_poc[VAR_0->picture_structure == PICT_BOTTOM_FIELD];", "const int VAR_5 = VAR_0->ref_list[1][0].VAR_5;", "int VAR_3, VAR_4;", "if (FRAME_MBAFF(VAR_0))\nfor (VAR_4 = 0; VAR_4 < 2; VAR_4++) {", "const int VAR_5 = VAR_0->cur_pic_ptr->field_poc[VAR_4];", "const int VAR_5 = VAR_0->ref_list[1][0].field_poc[VAR_4];", "for (VAR_3 = 0; VAR_3 < 2 * VAR_0->ref_count[0]; VAR_3++)", "VAR_0->dist_scale_factor_field[VAR_4][VAR_3 ^ VAR_4] =\nget_scale_factor(VAR_0, VAR_5, VAR_5, VAR_3 + 16);", "}", "for (VAR_3 = 0; VAR_3 < VAR_0->ref_count[0]; VAR_3++)", "VAR_0->dist_scale_factor[VAR_3] = get_scale_factor(VAR_0, VAR_5, VAR_5, VAR_3);", "}" ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0, BlockDriverState *VAR_1,\nQDict *VAR_2, int VAR_3, BlockDriver *VAR_4)\n{", "int VAR_5, VAR_6;", "const char *VAR_7;", "assert(VAR_4 != NULL);", "assert(VAR_0->VAR_1 == NULL);", "assert(VAR_2 != NULL && VAR_0->VAR_2 != VAR_2);", "trace_bdrv_open_common(VAR_0, VAR_7, VAR_3, VAR_4->format_name);", "if (use_bdrv_whitelist && !bdrv_is_whitelisted(VAR_4)) {", "return -ENOTSUP;", "}", "if (VAR_1 != NULL && VAR_4->bdrv_file_open) {", "bdrv_swap(VAR_1, VAR_0);", "return 0;", "}", "VAR_0->VAR_6 = VAR_3;", "VAR_0->buffer_alignment = 512;", "assert(VAR_0->copy_on_read == 0);", "if ((VAR_3 & BDRV_O_RDWR) && (VAR_3 & BDRV_O_COPY_ON_READ)) {", "bdrv_enable_copy_on_read(VAR_0);", "}", "if (VAR_1 != NULL) {", "VAR_7 = VAR_1->VAR_7;", "} else {", "VAR_7 = qdict_get_try_str(VAR_2, \"VAR_7\");", "}", "if (VAR_7 != NULL) {", "pstrcpy(VAR_0->VAR_7, sizeof(VAR_0->VAR_7), VAR_7);", "} else {", "VAR_0->VAR_7[0] = '\\0';", "}", "VAR_0->VAR_4 = VAR_4;", "VAR_0->opaque = g_malloc0(VAR_4->instance_size);", "VAR_0->enable_write_cache = !!(VAR_3 & BDRV_O_CACHE_WB);", "VAR_6 = bdrv_open_flags(VAR_0, VAR_3);", "VAR_0->read_only = !(VAR_6 & BDRV_O_RDWR);", "if (VAR_4->bdrv_file_open) {", "assert(VAR_1 == NULL);", "assert(VAR_4->bdrv_parse_filename || VAR_7 != NULL);", "VAR_5 = VAR_4->bdrv_file_open(VAR_0, VAR_2, VAR_6);", "} else {", "if (VAR_1 == NULL) {", "qerror_report(ERROR_CLASS_GENERIC_ERROR, \"Can't use '%s' as a \"\n\"block driver for the protocol level\",\nVAR_4->format_name);", "VAR_5 = -EINVAL;", "goto free_and_fail;", "}", "assert(VAR_1 != NULL);", "VAR_0->VAR_1 = VAR_1;", "VAR_5 = VAR_4->bdrv_open(VAR_0, VAR_2, VAR_6);", "}", "if (VAR_5 < 0) {", "goto free_and_fail;", "}", "VAR_5 = refresh_total_sectors(VAR_0, VAR_0->total_sectors);", "if (VAR_5 < 0) {", "goto free_and_fail;", "}", "#ifndef _WIN32\nif (VAR_0->is_temporary) {", "assert(VAR_7 != NULL);", "unlink(VAR_7);", "}", "#endif\nreturn 0;", "free_and_fail:\nVAR_0->VAR_1 = NULL;", "g_free(VAR_0->opaque);", "VAR_0->opaque = NULL;", "VAR_0->VAR_4 = NULL;", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 101 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119, 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159, 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169, 171 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, int VAR_1)\n{", "BDRVQcowState *s = VAR_0->opaque;", "int VAR_2, VAR_3, VAR_4 = 0;", "QCowHeader header;", "uint64_t ext_end;", "VAR_4 = bdrv_pread(VAR_0->file, 0, &header, sizeof(header));", "if (VAR_4 < 0) {", "goto fail;", "}", "be32_to_cpus(&header.magic);", "be32_to_cpus(&header.version);", "be64_to_cpus(&header.backing_file_offset);", "be32_to_cpus(&header.backing_file_size);", "be64_to_cpus(&header.size);", "be32_to_cpus(&header.cluster_bits);", "be32_to_cpus(&header.crypt_method);", "be64_to_cpus(&header.l1_table_offset);", "be32_to_cpus(&header.l1_size);", "be64_to_cpus(&header.refcount_table_offset);", "be32_to_cpus(&header.refcount_table_clusters);", "be64_to_cpus(&header.snapshots_offset);", "be32_to_cpus(&header.nb_snapshots);", "if (header.magic != QCOW_MAGIC) {", "VAR_4 = -EINVAL;", "goto fail;", "}", "if (header.version < 2 || header.version > 3) {", "report_unsupported(VAR_0, \"QCOW version %d\", header.version);", "VAR_4 = -ENOTSUP;", "goto fail;", "}", "s->qcow_version = header.version;", "if (header.version == 2) {", "header.incompatible_features = 0;", "header.compatible_features = 0;", "header.autoclear_features = 0;", "header.refcount_order = 4;", "header.header_length = 72;", "} else {", "be64_to_cpus(&header.incompatible_features);", "be64_to_cpus(&header.compatible_features);", "be64_to_cpus(&header.autoclear_features);", "be32_to_cpus(&header.refcount_order);", "be32_to_cpus(&header.header_length);", "}", "if (header.header_length > sizeof(header)) {", "s->unknown_header_fields_size = header.header_length - sizeof(header);", "s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);", "VAR_4 = bdrv_pread(VAR_0->file, sizeof(header), s->unknown_header_fields,\ns->unknown_header_fields_size);", "if (VAR_4 < 0) {", "goto fail;", "}", "}", "if (header.backing_file_offset) {", "ext_end = header.backing_file_offset;", "} else {", "ext_end = 1 << header.cluster_bits;", "}", "s->incompatible_features = header.incompatible_features;", "s->compatible_features = header.compatible_features;", "s->autoclear_features = header.autoclear_features;", "if (s->incompatible_features != 0) {", "void *VAR_5 = NULL;", "qcow2_read_extensions(VAR_0, header.header_length, ext_end,\n&VAR_5);", "report_unsupported_feature(VAR_0, VAR_5,\ns->incompatible_features);", "VAR_4 = -ENOTSUP;", "goto fail;", "}", "if (header.refcount_order != 4) {", "report_unsupported(VAR_0, \"%d bit reference counts\",\n1 << header.refcount_order);", "VAR_4 = -ENOTSUP;", "goto fail;", "}", "if (header.cluster_bits < MIN_CLUSTER_BITS ||\nheader.cluster_bits > MAX_CLUSTER_BITS) {", "VAR_4 = -EINVAL;", "goto fail;", "}", "if (header.crypt_method > QCOW_CRYPT_AES) {", "VAR_4 = -EINVAL;", "goto fail;", "}", "s->crypt_method_header = header.crypt_method;", "if (s->crypt_method_header) {", "VAR_0->encrypted = 1;", "}", "s->cluster_bits = header.cluster_bits;", "s->cluster_size = 1 << s->cluster_bits;", "s->cluster_sectors = 1 << (s->cluster_bits - 9);", "s->l2_bits = s->cluster_bits - 3;", "s->l2_size = 1 << s->l2_bits;", "VAR_0->total_sectors = header.size / 512;", "s->csize_shift = (62 - (s->cluster_bits - 8));", "s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;", "s->cluster_offset_mask = (1LL << s->csize_shift) - 1;", "s->refcount_table_offset = header.refcount_table_offset;", "s->refcount_table_size =\nheader.refcount_table_clusters << (s->cluster_bits - 3);", "s->snapshots_offset = header.snapshots_offset;", "s->nb_snapshots = header.nb_snapshots;", "s->l1_size = header.l1_size;", "s->l1_vm_state_index = size_to_l1(s, header.size);", "if (s->l1_size < s->l1_vm_state_index) {", "VAR_4 = -EINVAL;", "goto fail;", "}", "s->l1_table_offset = header.l1_table_offset;", "if (s->l1_size > 0) {", "s->l1_table = g_malloc0(\nalign_offset(s->l1_size * sizeof(uint64_t), 512));", "VAR_4 = bdrv_pread(VAR_0->file, s->l1_table_offset, s->l1_table,\ns->l1_size * sizeof(uint64_t));", "if (VAR_4 < 0) {", "goto fail;", "}", "for(VAR_3 = 0;VAR_3 < s->l1_size; VAR_3++) {", "be64_to_cpus(&s->l1_table[VAR_3]);", "}", "}", "s->l2_table_cache = qcow2_cache_create(VAR_0, L2_CACHE_SIZE);", "s->refcount_block_cache = qcow2_cache_create(VAR_0, REFCOUNT_CACHE_SIZE);", "s->cluster_cache = g_malloc(s->cluster_size);", "s->cluster_data = qemu_blockalign(VAR_0, QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size\n+ 512);", "s->cluster_cache_offset = -1;", "s->VAR_1 = VAR_1;", "VAR_4 = qcow2_refcount_init(VAR_0);", "if (VAR_4 != 0) {", "goto fail;", "}", "QLIST_INIT(&s->cluster_allocs);", "if (qcow2_read_extensions(VAR_0, header.header_length, ext_end, NULL)) {", "VAR_4 = -EINVAL;", "goto fail;", "}", "if (header.backing_file_offset != 0) {", "VAR_2 = header.backing_file_size;", "if (VAR_2 > 1023) {", "VAR_2 = 1023;", "}", "VAR_4 = bdrv_pread(VAR_0->file, header.backing_file_offset,\nVAR_0->backing_file, VAR_2);", "if (VAR_4 < 0) {", "goto fail;", "}", "VAR_0->backing_file[VAR_2] = '\\0';", "}", "VAR_4 = qcow2_read_snapshots(VAR_0);", "if (VAR_4 < 0) {", "goto fail;", "}", "if (!VAR_0->read_only && s->autoclear_features != 0) {", "s->autoclear_features = 0;", "VAR_4 = qcow2_update_header(VAR_0);", "if (VAR_4 < 0) {", "goto fail;", "}", "}", "qemu_co_mutex_init(&s->lock);", "#ifdef DEBUG_ALLOC\n{", "BdrvCheckResult result = {0};", "qcow2_check_refcounts(VAR_0, &result);", "}", "#endif\nreturn VAR_4;", "fail:\ng_free(s->unknown_header_fields);", "cleanup_unknown_header_ext(VAR_0);", "qcow2_free_snapshots(VAR_0);", "qcow2_refcount_close(VAR_0);", "g_free(s->l1_table);", "if (s->l2_table_cache) {", "qcow2_cache_destroy(VAR_0, s->l2_table_cache);", "}", "g_free(s->cluster_cache);", "qemu_vfree(s->cluster_data);", "return VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 169 ], [ 171, 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183, 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 231 ], [ 235 ], [ 237 ], [ 243 ], [ 245 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263, 265 ], [ 267, 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 289 ], [ 291 ], [ 295 ], [ 299, 301 ], [ 303 ], [ 305 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 319 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347, 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 393 ], [ 397, 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407, 409 ], [ 413, 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "PAFDemuxContext *p = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "uint32_t count, offset;", "int VAR_2, VAR_3;", "if (p->current_frame >= p->nb_frames)\nreturn AVERROR_EOF;", "if (url_feof(pb))\nreturn AVERROR_EOF;", "if (p->got_audio) {", "if (av_new_packet(VAR_1, p->audio_size) < 0)\nreturn AVERROR(ENOMEM);", "memcpy(VAR_1->data, p->temp_audio_frame, p->audio_size);", "VAR_1->duration = PAF_SOUND_SAMPLES * (p->audio_size / PAF_SOUND_FRAME_SIZE);", "VAR_1->flags |= AV_PKT_FLAG_KEY;", "VAR_1->stream_index = 1;", "p->got_audio = 0;", "return VAR_1->VAR_2;", "}", "count = (p->current_frame == 0) ? p->preload_count : p->blocks_count_table[p->current_frame - 1];", "for (VAR_3 = 0; VAR_3 < count; VAR_3++) {", "if (p->current_frame_block >= p->frame_blks)\nreturn AVERROR_INVALIDDATA;", "offset = p->blocks_offset_table[p->current_frame_block] & ~(1U << 31);", "if (p->blocks_offset_table[p->current_frame_block] & (1U << 31)) {", "if (offset > p->audio_size - p->buffer_size)\nreturn AVERROR_INVALIDDATA;", "avio_read(pb, p->audio_frame + offset, p->buffer_size);", "if (offset == (p->max_audio_blks - 2) * p->buffer_size) {", "memcpy(p->temp_audio_frame, p->audio_frame, p->audio_size);", "p->got_audio = 1;", "}", "} else {", "if (offset > p->video_size - p->buffer_size)\nreturn AVERROR_INVALIDDATA;", "avio_read(pb, p->video_frame + offset, p->buffer_size);", "}", "p->current_frame_block++;", "}", "VAR_2 = p->video_size - p->frames_offset_table[p->current_frame];", "if (VAR_2 < 1)\nreturn AVERROR_INVALIDDATA;", "if (av_new_packet(VAR_1, VAR_2) < 0)\nreturn AVERROR(ENOMEM);", "VAR_1->stream_index = 0;", "VAR_1->duration = 1;", "memcpy(VAR_1->data, p->video_frame + p->frames_offset_table[p->current_frame], VAR_2);", "if (VAR_1->data[0] & 0x20)\nVAR_1->flags |= AV_PKT_FLAG_KEY;", "p->current_frame++;", "return VAR_1->VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 21, 23 ], [ 27 ], [ 29, 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101, 103 ], [ 107, 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 127 ], [ 129 ] ]

[ "char *FUNC_0(int VAR_0)\n{", "return strerror(target_to_host_errno(VAR_0));" ]

[ 0, 0 ]

[ [ 1, 3 ], [ 8 ] ]

[ "AVFormatContext *FUNC_0(AVFormatContext *s, AVStream *st,\nURLContext *handle, int packet_size)\n{", "AVFormatContext *rtpctx;", "int VAR_0;", "AVOutputFormat *rtp_format = av_guess_format(\"rtp\", NULL, NULL);", "if (!rtp_format)\nreturn NULL;", "rtpctx = avformat_alloc_context();", "if (!rtpctx)\nreturn NULL;", "rtpctx->oformat = rtp_format;", "if (!av_new_stream(rtpctx, 0)) {", "av_free(rtpctx);", "return NULL;", "}", "rtpctx->max_delay = s->max_delay;", "rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;", "rtpctx->start_time_realtime = s->start_time_realtime;", "av_free(rtpctx->streams[0]->codec);", "rtpctx->streams[0]->codec = st->codec;", "if (handle) {", "url_fdopen(&rtpctx->pb, handle);", "} else", "url_open_dyn_packet_buf(&rtpctx->pb, packet_size);", "VAR_0 = av_write_header(rtpctx);", "if (VAR_0) {", "if (handle) {", "url_fclose(rtpctx->pb);", "} else {", "uint8_t *ptr;", "url_close_dyn_buf(rtpctx->pb, &ptr);", "av_free(ptr);", "}", "av_free(rtpctx->streams[0]);", "av_free(rtpctx);", "return NULL;", "}", "st->time_base = rtpctx->streams[0]->time_base;", "return rtpctx;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 53 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 98 ], [ 100 ], [ 102 ], [ 104 ], [ 110 ], [ 112 ], [ 114 ] ]

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "PCICirrusVGAState *d = DO_UPCAST(PCICirrusVGAState, VAR_0, VAR_0);", "CirrusVGAState *s = &d->cirrus_vga;", "PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(VAR_0);", "int16_t device_id = pc->device_id;", "vga_common_init(&s->vga, OBJECT(VAR_0), true);", "cirrus_init_common(s, OBJECT(VAR_0), device_id, 1, pci_address_space(VAR_0),\npci_address_space_io(VAR_0));", "s->vga.con = graphic_console_init(DEVICE(VAR_0), 0, s->vga.hw_ops, &s->vga);", "memory_region_init(&s->pci_bar, OBJECT(VAR_0), \"cirrus-pci-bar0\", 0x2000000);", "memory_region_add_subregion(&s->pci_bar, 0, &s->cirrus_linear_io);", "memory_region_add_subregion(&s->pci_bar, 0x1000000,\n&s->cirrus_linear_bitblt_io);", "pci_register_bar(&d->VAR_0, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->pci_bar);", "if (device_id == CIRRUS_ID_CLGD5446) {", "pci_register_bar(&d->VAR_0, 1, 0, &s->cirrus_mmio_io);", "return 0;" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 39 ], [ 45 ], [ 47, 49 ], [ 61 ], [ 63 ], [ 65 ], [ 68 ] ]

[ "static void FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1,\nint VAR_2)\n{", "RMContext *rm = VAR_0->priv_data;", "ByteIOContext *pb = &VAR_0->pb;", "char VAR_3[256];", "uint32_t version;", "int VAR_10;", "version = get_be32(pb);", "if (((version >> 16) & 0xff) == 3) {", "int64_t startpos = url_ftell(pb);", "for(VAR_10 = 0; VAR_10 < 14; VAR_10++)", "get_byte(pb);", "get_str8(pb, VAR_0->title, sizeof(VAR_0->title));", "get_str8(pb, VAR_0->author, sizeof(VAR_0->author));", "get_str8(pb, VAR_0->copyright, sizeof(VAR_0->copyright));", "get_str8(pb, VAR_0->comment, sizeof(VAR_0->comment));", "if ((startpos + (version & 0xffff)) >= url_ftell(pb) + 2) {", "get_byte(pb);", "get_str8(pb, VAR_3, sizeof(VAR_3));", "if ((startpos + (version & 0xffff)) > url_ftell(pb))\nurl_fskip(pb, (version & 0xffff) + startpos - url_ftell(pb));", "VAR_1->codec->sample_rate = 8000;", "VAR_1->codec->channels = 1;", "VAR_1->codec->codec_type = CODEC_TYPE_AUDIO;", "VAR_1->codec->codec_id = CODEC_ID_RA_144;", "} else {", "int VAR_5, VAR_6, VAR_7, VAR_8;", "get_be32(pb);", "get_be32(pb);", "get_be16(pb);", "get_be32(pb);", "VAR_5= get_be16(pb);", "rm->VAR_7 = VAR_7 = get_be32(pb);", "get_be32(pb);", "get_be32(pb);", "get_be32(pb);", "rm->VAR_6 = VAR_6 = get_be16(pb);", "VAR_1->codec->block_align= get_be16(pb);", "rm->VAR_8 = VAR_8 = get_be16(pb);", "get_be16(pb);", "if (((version >> 16) & 0xff) == 5) {", "get_be16(pb); get_be16(pb); get_be16(pb); }", "VAR_1->codec->sample_rate = get_be16(pb);", "get_be32(pb);", "VAR_1->codec->channels = get_be16(pb);", "if (((version >> 16) & 0xff) == 5) {", "get_be32(pb);", "VAR_3[0] = get_byte(pb);", "VAR_3[1] = get_byte(pb);", "VAR_3[2] = get_byte(pb);", "VAR_3[3] = get_byte(pb);", "VAR_3[4] = 0;", "} else {", "get_str8(pb, VAR_3, sizeof(VAR_3));", "get_str8(pb, VAR_3, sizeof(VAR_3));", "VAR_1->codec->codec_type = CODEC_TYPE_AUDIO;", "if (!strcmp(VAR_3, \"dnet\")) {", "VAR_1->codec->codec_id = CODEC_ID_AC3;", "} else if (!strcmp(VAR_3, \"28_8\")) {", "VAR_1->codec->codec_id = CODEC_ID_RA_288;", "VAR_1->codec->extradata_size= 0;", "rm->audio_framesize = VAR_1->codec->block_align;", "VAR_1->codec->block_align = VAR_7;", "rm->audiobuf = av_malloc(rm->audio_framesize * VAR_6);", "} else if (!strcmp(VAR_3, \"cook\")) {", "int VAR_9, VAR_10;", "get_be16(pb); get_byte(pb);", "if (((version >> 16) & 0xff) == 5)\nget_byte(pb);", "VAR_9 = get_be32(pb);", "if(VAR_9 + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)VAR_9){", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_9 too large\\n\");", "VAR_1->codec->codec_id = CODEC_ID_COOK;", "VAR_1->codec->extradata_size= VAR_9;", "VAR_1->codec->extradata= av_mallocz(VAR_1->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);", "for(VAR_10 = 0; VAR_10 < VAR_9; VAR_10++)", "((uint8_t*)VAR_1->codec->extradata)[VAR_10] = get_byte(pb);", "rm->audio_framesize = VAR_1->codec->block_align;", "VAR_1->codec->block_align = rm->VAR_8;", "rm->audiobuf = av_malloc(rm->audio_framesize * VAR_6);", "} else {", "VAR_1->codec->codec_id = CODEC_ID_NONE;", "pstrcpy(VAR_1->codec->codec_name, sizeof(VAR_1->codec->codec_name),\nVAR_3);", "if (VAR_2) {", "get_byte(pb);", "get_byte(pb);", "get_byte(pb);", "get_str8(pb, VAR_0->title, sizeof(VAR_0->title));", "get_str8(pb, VAR_0->author, sizeof(VAR_0->author));", "get_str8(pb, VAR_0->copyright, sizeof(VAR_0->copyright));", "get_str8(pb, VAR_0->comment, sizeof(VAR_0->comment));" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "AVCodecContext *avc = VAR_0->streams[0]->codec;", "AVIOContext *pb = VAR_0->pb;", "if (avc->codec_id != CODEC_ID_WMV3) {", "av_log(VAR_0, AV_LOG_ERROR, \"Only WMV3 is accepted!\\n\");", "return -1;", "}", "avio_wl24(pb, 0);", "avio_w8(pb, 0xC5);", "avio_wl32(pb, 4);", "avio_write(pb, avc->extradata, 4);", "avio_wl32(pb, avc->height);", "avio_wl32(pb, avc->width);", "avio_wl32(pb, 0xC);", "avio_wl24(pb, 0);", "avio_w8(pb, 0x80);", "avio_wl32(pb, 0);", "if (VAR_0->streams[0]->r_frame_rate.den && VAR_0->streams[0]->r_frame_rate.num == 1)\navio_wl32(pb, VAR_0->streams[0]->r_frame_rate.den);", "else\navio_wl32(pb, 0xFFFFFFFF);", "avpriv_set_pts_info(VAR_0->streams[0], 32, 1, 1000);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "CACAContext *c = VAR_0->priv_data;", "av_freep(&c->window_title);", "caca_free_dither(c->dither);", "caca_free_display(c->display);", "caca_free_canvas(c->canvas);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "qemu_log (\"unknown insn pc=%x opc=%x\\n\", VAR_0->pc, VAR_0->opcode);", "VAR_0->abort_at_next_insn = 1;" ]

[ 0, 0, 0 ]

[ [ 1, 3 ], [ 11 ], [ 13 ] ]

[ "int FUNC_0(const char *VAR_0)\n{", "#define CPUFLAG_MMXEXT (AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT | AV_CPU_FLAG_CMOV)\n#define CPUFLAG_3DNOW (AV_CPU_FLAG_3DNOW | AV_CPU_FLAG_MMX)\n#define CPUFLAG_3DNOWEXT (AV_CPU_FLAG_3DNOWEXT | CPUFLAG_3DNOW)\n#define CPUFLAG_SSE (AV_CPU_FLAG_SSE | CPUFLAG_MMXEXT)\n#define CPUFLAG_SSE2 (AV_CPU_FLAG_SSE2 | CPUFLAG_SSE)\n#define CPUFLAG_SSE2SLOW (AV_CPU_FLAG_SSE2SLOW | CPUFLAG_SSE2)\n#define CPUFLAG_SSE3 (AV_CPU_FLAG_SSE3 | CPUFLAG_SSE2)\n#define CPUFLAG_SSE3SLOW (AV_CPU_FLAG_SSE3SLOW | CPUFLAG_SSE3)\n#define CPUFLAG_SSSE3 (AV_CPU_FLAG_SSSE3 | CPUFLAG_SSE3)\n#define CPUFLAG_SSE4 (AV_CPU_FLAG_SSE4 | CPUFLAG_SSSE3)\n#define CPUFLAG_SSE42 (AV_CPU_FLAG_SSE42 | CPUFLAG_SSE4)\n#define CPUFLAG_AVX (AV_CPU_FLAG_AVX | CPUFLAG_SSE42)\n#define CPUFLAG_AVXSLOW (AV_CPU_FLAG_AVXSLOW | CPUFLAG_AVX)\n#define CPUFLAG_XOP (AV_CPU_FLAG_XOP | CPUFLAG_AVX)\n#define CPUFLAG_FMA3 (AV_CPU_FLAG_FMA3 | CPUFLAG_AVX)\n#define CPUFLAG_FMA4 (AV_CPU_FLAG_FMA4 | CPUFLAG_AVX)\n#define CPUFLAG_AVX2 (AV_CPU_FLAG_AVX2 | CPUFLAG_AVX)\n#define CPUFLAG_BMI2 (AV_CPU_FLAG_BMI2 | AV_CPU_FLAG_BMI1)\nstatic const AVOption VAR_1[] = {", "{ \"VAR_3\" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = \"VAR_3\" },", "#if ARCH_PPC\n{ \"altivec\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ALTIVEC }, .unit = \"VAR_3\" },", "#elif ARCH_X86\n{ \"mmx\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX }, .unit = \"VAR_3\" },", "{ \"mmxext\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_MMXEXT }, .unit = \"VAR_3\" },", "{ \"sse\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE }, .unit = \"VAR_3\" },", "{ \"sse2\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE2 }, .unit = \"VAR_3\" },", "{ \"sse2slow\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE2SLOW }, .unit = \"VAR_3\" },", "{ \"sse3\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE3 }, .unit = \"VAR_3\" },", "{ \"sse3slow\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE3SLOW }, .unit = \"VAR_3\" },", "{ \"ssse3\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSSE3 }, .unit = \"VAR_3\" },", "{ \"atom\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ATOM }, .unit = \"VAR_3\" },", "{ \"sse4.1\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE4 }, .unit = \"VAR_3\" },", "{ \"sse4.2\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE42 }, .unit = \"VAR_3\" },", "{ \"avx\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_AVX }, .unit = \"VAR_3\" },", "{ \"avxslow\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_AVXSLOW }, .unit = \"VAR_3\" },", "{ \"xop\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_XOP }, .unit = \"VAR_3\" },", "{ \"fma3\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_FMA3 }, .unit = \"VAR_3\" },", "{ \"fma4\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_FMA4 }, .unit = \"VAR_3\" },", "{ \"avx2\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_AVX2 }, .unit = \"VAR_3\" },", "{ \"bmi1\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_BMI1 }, .unit = \"VAR_3\" },", "{ \"bmi2\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_BMI2 }, .unit = \"VAR_3\" },", "{ \"3dnow\" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_3DNOW }, .unit = \"VAR_3\" },", "{ \"3dnowext\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_3DNOWEXT }, .unit = \"VAR_3\" },", "{ \"cmov\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_CMOV }, .unit = \"VAR_3\" },", "#elif ARCH_ARM\n{ \"armv5te\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV5TE }, .unit = \"VAR_3\" },", "{ \"armv6\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6 }, .unit = \"VAR_3\" },", "{ \"armv6t2\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6T2 }, .unit = \"VAR_3\" },", "{ \"vfp\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = \"VAR_3\" },", "{ \"vfpv3\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFPV3 }, .unit = \"VAR_3\" },", "{ \"neon\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = \"VAR_3\" },", "#elif ARCH_AARCH64\n{ \"armv8\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV8 }, .unit = \"VAR_3\" },", "{ \"neon\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = \"VAR_3\" },", "{ \"vfp\", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = \"VAR_3\" },", "#endif\n{ NULL },", "};", "static const AVClass VAR_2 = {", ".class_name = \"cpuflags\",\n.item_name = av_default_item_name,\n.option = VAR_1,\n.version = LIBAVUTIL_VERSION_INT,\n};", "int VAR_3 = 0, VAR_4;", "const AVClass *VAR_5 = &VAR_2;", "if ((VAR_4 = av_opt_eval_flags(&VAR_5, &VAR_1[0], VAR_0, &VAR_3)) < 0)\nreturn VAR_4;", "return VAR_3 & INT_MAX;", "}" ]

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

[ [ 1, 3 ], [ 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41 ], [ 43 ], [ 45, 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 106 ], [ 108 ], [ 110, 112 ], [ 114 ], [ 116 ], [ 118, 120 ], [ 122 ], [ 124 ], [ 126, 128, 130, 132, 134 ], [ 138 ], [ 140 ], [ 144, 146 ], [ 150 ], [ 152 ] ]

[ "void FUNC_0(MpegEncContext *VAR_0)\n{", "static int VAR_1 = 0;", "if (!VAR_1) {", "init_vlc(&dc_lum_vlc, 9, 12,\nvlc_dc_lum_bits, 1, 1,\nvlc_dc_lum_code, 2, 2);", "init_vlc(&dc_chroma_vlc, 9, 12,\nvlc_dc_chroma_bits, 1, 1,\nvlc_dc_chroma_code, 2, 2);", "init_vlc(&mv_vlc, 9, 17,\n&mbMotionVectorTable[0][1], 2, 1,\n&mbMotionVectorTable[0][0], 2, 1);", "init_vlc(&mbincr_vlc, 9, 35,\n&mbAddrIncrTable[0][1], 2, 1,\n&mbAddrIncrTable[0][0], 2, 1);", "init_vlc(&mb_pat_vlc, 9, 63,\n&mbPatTable[0][1], 2, 1,\n&mbPatTable[0][0], 2, 1);", "init_vlc(&mb_ptype_vlc, 6, 32,\n&table_mb_ptype[0][1], 2, 1,\n&table_mb_ptype[0][0], 2, 1);", "init_vlc(&mb_btype_vlc, 6, 32,\n&table_mb_btype[0][1], 2, 1,\n&table_mb_btype[0][0], 2, 1);", "init_rl(&rl_mpeg1);", "init_rl(&rl_mpeg2);", "init_vlc(&rl_mpeg1.vlc, 9, rl_mpeg1.n + 2,\n&rl_mpeg1.table_vlc[0][1], 4, 2,\n&rl_mpeg1.table_vlc[0][0], 4, 2);", "init_vlc(&rl_mpeg2.vlc, 9, rl_mpeg2.n + 2,\n&rl_mpeg2.table_vlc[0][1], 4, 2,\n&rl_mpeg2.table_vlc[0][0], 4, 2);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 14, 16, 18 ], [ 20, 22, 24 ], [ 26, 28, 30 ], [ 32, 34, 36 ], [ 38, 40, 42 ], [ 46, 48, 50 ], [ 52, 54, 56 ], [ 58 ], [ 60 ], [ 64, 66, 68 ], [ 70, 72, 74 ], [ 76 ], [ 78 ] ]

[ "static int FUNC_0(FlashSVContext *VAR_0, const AVFrame *VAR_1, uint8_t *VAR_2,\nint VAR_3, int VAR_4, int VAR_5,\nuint8_t *VAR_6, int *VAR_7)\n{", "PutBitContext pb;", "int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13;", "int VAR_14, VAR_15;", "int VAR_16 = 0;", "init_put_bits(&pb, VAR_2, VAR_3 * 8);", "put_bits(&pb, 4, VAR_4 / 16 - 1);", "put_bits(&pb, 12, VAR_0->image_width);", "put_bits(&pb, 4, VAR_5 / 16 - 1);", "put_bits(&pb, 12, VAR_0->image_height);", "flush_put_bits(&pb);", "VAR_14 = 4;", "VAR_8 = VAR_0->image_width / VAR_4;", "VAR_10 = VAR_0->image_width % VAR_4;", "VAR_9 = VAR_0->image_height / VAR_5;", "VAR_11 = VAR_0->image_height % VAR_5;", "for (VAR_13 = 0; VAR_13 < VAR_9 + (VAR_11 ? 1 : 0); VAR_13++) {", "int VAR_17 = VAR_13 * VAR_5;", "int VAR_18 = (VAR_13 < VAR_9) ? VAR_5 : VAR_11;", "for (VAR_12 = 0; VAR_12 < VAR_8 + (VAR_10 ? 1 : 0); VAR_12++) {", "int VAR_19 = VAR_12 * VAR_4;", "int VAR_20 = (VAR_12 < VAR_8) ? VAR_4 : VAR_10;", "int VAR_21 = Z_OK;", "uint8_t *ptr = VAR_2 + VAR_14;", "VAR_15 = copy_region_enc(VAR_1->data[0], VAR_0->tmpblock,\nVAR_0->image_height - (VAR_17 + VAR_18 + 1),\nVAR_19, VAR_18, VAR_20,\nVAR_1->linesize[0], VAR_6);", "if (VAR_15 || *VAR_7) {", "unsigned long VAR_22 = 3 * VAR_4 * VAR_5;", "VAR_21 = compress2(ptr + 2, &VAR_22, VAR_0->tmpblock,\n3 * VAR_20 * VAR_18, 9);", "if (VAR_21 != Z_OK)\nav_log(VAR_0->avctx, AV_LOG_ERROR,\n\"error while compressing block %dx%d\\n\", VAR_12, VAR_13);", "bytestream_put_be16(&ptr, VAR_22);", "VAR_14 += VAR_22 + 2;", "av_dlog(VAR_0->avctx, \"VAR_14 = %d\\n\", VAR_14);", "} else {", "VAR_16++;", "bytestream_put_be16(&ptr, 0);", "VAR_14 += 2;", "}", "}", "}", "if (VAR_16)\n*VAR_7 = 0;", "else\n*VAR_7 = 1;", "return VAR_14;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 51 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 79, 81, 83, 85 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 101, 103, 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 131, 133 ], [ 135, 137 ], [ 141 ], [ 143 ] ]

[ "static void FUNC_0(UASDevice *VAR_0, uas_ui *VAR_1)\n{", "uint16_t tag = be16_to_cpu(VAR_1->hdr.tag);", "uint64_t lun64 = be64_to_cpu(VAR_1->task.VAR_2);", "SCSIDevice *dev = usb_uas_get_dev(VAR_0, lun64);", "int VAR_2 = usb_uas_get_lun(lun64);", "UASRequest *req;", "uint16_t task_tag;", "req = usb_uas_find_request(VAR_0, be16_to_cpu(VAR_1->hdr.tag));", "if (req) {", "goto overlapped_tag;", "if (dev == NULL) {", "goto incorrect_lun;", "switch (VAR_1->task.function) {", "case UAS_TMF_ABORT_TASK:\ntask_tag = be16_to_cpu(VAR_1->task.task_tag);", "trace_usb_uas_tmf_abort_task(VAR_0->dev.addr, tag, task_tag);", "req = usb_uas_find_request(VAR_0, task_tag);", "if (req && req->dev == dev) {", "scsi_req_cancel(req->req);", "usb_uas_queue_response(VAR_0, tag, UAS_RC_TMF_COMPLETE, 0);", "break;", "case UAS_TMF_LOGICAL_UNIT_RESET:\ntrace_usb_uas_tmf_logical_unit_reset(VAR_0->dev.addr, tag, VAR_2);", "qdev_reset_all(&dev->qdev);", "usb_uas_queue_response(VAR_0, tag, UAS_RC_TMF_COMPLETE, 0);", "break;", "default:\ntrace_usb_uas_tmf_unsupported(VAR_0->dev.addr, tag, VAR_1->task.function);", "usb_uas_queue_response(VAR_0, tag, UAS_RC_TMF_NOT_SUPPORTED, 0);", "break;", "return;", "invalid_tag:\nusb_uas_queue_response(VAR_0, tag, UAS_RC_INVALID_INFO_UNIT, 0);", "return;", "overlapped_tag:\nusb_uas_queue_response(VAR_0, req->tag, UAS_RC_OVERLAPPED_TAG, 0);", "return;", "incorrect_lun:\nusb_uas_queue_response(VAR_0, tag, UAS_RC_INCORRECT_LUN, 0);" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 22 ], [ 24 ], [ 26 ], [ 29 ], [ 31 ], [ 36 ], [ 38, 40 ], [ 42 ], [ 44 ], [ 46 ], [ 48 ], [ 51 ], [ 53 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 78 ], [ 82, 84 ], [ 86 ], [ 90, 92 ], [ 94 ], [ 98, 100 ] ]

[ "static int FUNC_0(SubchDev *VAR_0)\n{", "PMCW *p = &VAR_0->curr_status.pmcw;", "SCSW *s = &VAR_0->curr_status.scsw;", "int VAR_1;", "ORB *orb = &VAR_0->orb;", "if (!(s->ctrl & SCSW_ACTL_SUSP)) {", "assert(orb != NULL);", "p->intparm = orb->intparm;", "}", "if (!(orb->ctrl0 & ORB_CTRL0_MASK_PFCH) ||\n!(orb->ctrl0 & ORB_CTRL0_MASK_C64)) {", "return -EINVAL;", "}", "VAR_1 = s390_ccw_cmd_request(orb, s, VAR_0->driver_data);", "switch (VAR_1) {", "case 0:\nbreak;", "case -EBUSY:\nbreak;", "case -ENODEV:\nbreak;", "case -EACCES:\nVAR_1 = -ENODEV;", "break;", "default:\nbreak;", "};", "return VAR_1;", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 51, 53 ], [ 55, 57 ], [ 59, 61 ], [ 63, 67 ], [ 69 ], [ 71, 81 ], [ 83 ], [ 87 ], [ 89 ] ]

[ "static int FUNC_0(SDState *VAR_0, SDRequest *VAR_1)\n{", "if (VAR_0->card_status & APP_CMD) {", "return VAR_1->cmd == 41 || VAR_1->cmd == 42;", "}", "if (VAR_1->cmd == 16 || VAR_1->cmd == 55) {", "return 1;", "}", "return sd_cmd_class[VAR_1->cmd] == 0 || sd_cmd_class[VAR_1->cmd] == 7;", "}" ]

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

[ [ 1, 3 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "SmcContext *s = VAR_0->priv_data;", "s->VAR_0 = VAR_0;", "VAR_0->pix_fmt = PIX_FMT_PAL8;", "dsputil_init(&s->dsp, VAR_0);", "s->frame.data[0] = NULL;", "return 0;", "}" ]

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

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

[ "int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1,\nint VAR_2, int VAR_3)\n{", "MOVMuxContext *mov = VAR_0->priv_data;", "MOVTrack *trk = &mov->tracks[VAR_2];", "AVFormatContext *rtp_ctx = trk->rtp_ctx;", "uint8_t *buf = NULL;", "int VAR_4;", "AVIOContext *hintbuf = NULL;", "AVPacket hint_pkt;", "int VAR_5 = 0, VAR_6;", "if (!rtp_ctx)\nreturn AVERROR(ENOENT);", "if (!rtp_ctx->pb)\nreturn AVERROR(ENOMEM);", "sample_queue_push(&trk->sample_queue, VAR_1, VAR_3);", "ff_write_chained(rtp_ctx, 0, VAR_1, VAR_0);", "VAR_4 = avio_close_dyn_buf(rtp_ctx->pb, &buf);", "if ((VAR_5 = url_open_dyn_packet_buf(&rtp_ctx->pb,\nRTP_MAX_PACKET_SIZE)) < 0)\ngoto done;", "if (VAR_4 <= 0)\ngoto done;", "if ((VAR_5 = avio_open_dyn_buf(&hintbuf)) < 0)\ngoto done;", "av_init_packet(&hint_pkt);", "VAR_6 = write_hint_packets(hintbuf, buf, VAR_4, trk, &hint_pkt.dts);", "av_freep(&buf);", "hint_pkt.VAR_4 = VAR_4 = avio_close_dyn_buf(hintbuf, &buf);", "hint_pkt.data = buf;", "hint_pkt.pts = hint_pkt.dts;", "hint_pkt.stream_index = VAR_2;", "if (VAR_1->flags & AV_PKT_FLAG_KEY)\nhint_pkt.flags |= AV_PKT_FLAG_KEY;", "if (VAR_6 > 0)\nff_mov_write_packet(VAR_0, &hint_pkt);", "done:\nav_free(buf);", "sample_queue_retain(&trk->sample_queue);", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25, 27 ], [ 29, 31 ], [ 35 ], [ 41 ], [ 49 ], [ 51, 53, 55 ], [ 59, 61 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 93, 95 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 105 ] ]

[ "static void FUNC_0(DiracContext *VAR_0)\n{", "AVCodecContext *avctx = VAR_0->avctx;", "int VAR_1, VAR_2, VAR_3, VAR_4;", "const uint8_t *VAR_5;", "struct lowdelay_slice *VAR_6;", "int VAR_7 = 0;", "VAR_6 = av_mallocz_array(VAR_0->lowdelay.num_x, VAR_0->lowdelay.num_y * sizeof(struct lowdelay_slice));", "align_get_bits(&VAR_0->gb);", "VAR_5 = VAR_0->gb.buffer + get_bits_count(&VAR_0->gb)/8;", "VAR_4 = get_bits_left(&VAR_0->gb);", "for (VAR_2 = 0; VAR_4 > 0 && VAR_2 < VAR_0->lowdelay.num_y; VAR_2++)", "for (VAR_1 = 0; VAR_4 > 0 && VAR_1 < VAR_0->lowdelay.num_x; VAR_1++) {", "VAR_3 = (VAR_7+1) * VAR_0->lowdelay.VAR_3.num / VAR_0->lowdelay.VAR_3.den\n- VAR_7 * VAR_0->lowdelay.VAR_3.num / VAR_0->lowdelay.VAR_3.den;", "VAR_6[VAR_7].VAR_3 = VAR_3;", "VAR_6[VAR_7].VAR_1 = VAR_1;", "VAR_6[VAR_7].VAR_2 = VAR_2;", "init_get_bits(&VAR_6[VAR_7].gb, VAR_5, VAR_4);", "VAR_7++;", "VAR_5 += VAR_3;", "VAR_4 -= VAR_3*8;", "}", "avctx->execute(avctx, decode_lowdelay_slice, VAR_6, NULL, VAR_7,\nsizeof(struct lowdelay_slice));", "intra_dc_prediction(&VAR_0->plane[0].band[0][0]);", "intra_dc_prediction(&VAR_0->plane[1].band[0][0]);", "intra_dc_prediction(&VAR_0->plane[2].band[0][0]);", "av_free(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 ]

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

[ "static void FUNC_0(AVFilterBufferRefVideoProps *VAR_0, AVFilterBufferRefVideoProps *VAR_1) {", "*VAR_0 = *VAR_1;", "if (VAR_1->qp_table) {", "int VAR_2 = VAR_1->qp_table_size;", "VAR_0->qp_table = av_malloc(VAR_2);", "memcpy(VAR_0->qp_table, VAR_1->qp_table, VAR_2);", "}", "}" ]

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

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

[ "void FUNC_0(BlockdevBackup *VAR_0, Error **VAR_1)\n{", "do_blockdev_backup(VAR_0, NULL, VAR_1);", "}" ]

[ 0, 1, 0 ]

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

[ "int VAR_0 avcodec_encode_audio2(AVCodecContext *avctx,\nAVPacket *avpkt,\nconst AVFrame *frame,\nint *got_packet_ptr)\n{", "int ret;", "int user_packet = !!avpkt->data;", "int nb_samples;", "*got_packet_ptr = 0;", "if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {", "av_free_packet(avpkt);", "av_init_packet(avpkt);", "avpkt->size = 0;", "return 0;", "}", "if (frame) {", "nb_samples = frame->nb_samples;", "if (avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {", "if (nb_samples > avctx->frame_size)\nreturn AVERROR(EINVAL);", "} else if (!(avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {", "if (nb_samples != avctx->frame_size)\nreturn AVERROR(EINVAL);", "}", "} else {", "nb_samples = avctx->frame_size;", "}", "if (avctx->codec->encode2) {", "ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);", "if (!ret && *got_packet_ptr) {", "if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {", "if (avpkt->pts == AV_NOPTS_VALUE)\navpkt->pts = frame->pts;", "if (!avpkt->duration)\navpkt->duration = ff_samples_to_time_base(avctx,\nframe->nb_samples);", "}", "avpkt->dts = avpkt->pts;", "} else {", "avpkt->size = 0;", "}", "} else {", "int fs_tmp = 0;", "int buf_size = avpkt->size;", "if (!user_packet) {", "if (avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE) {", "av_assert0(av_get_bits_per_sample(avctx->codec_id) != 0);", "buf_size = nb_samples * avctx->channels *\nav_get_bits_per_sample(avctx->codec_id) / 8;", "} else {", "buf_size = 2 * avctx->frame_size * avctx->channels *\nav_get_bytes_per_sample(avctx->sample_fmt);", "buf_size += FF_MIN_BUFFER_SIZE;", "}", "}", "if ((ret = ff_alloc_packet(avpkt, buf_size)))\nreturn ret;", "if ((avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) &&\nnb_samples < avctx->frame_size) {", "fs_tmp = avctx->frame_size;", "avctx->frame_size = nb_samples;", "}", "ret = avctx->codec->encode(avctx, avpkt->data, avpkt->size,\nframe ? frame->data[0] : NULL);", "if (ret >= 0) {", "if (!ret) {", "if (!user_packet)\nav_freep(&avpkt->data);", "} else {", "if (avctx->coded_frame)\navpkt->pts = avpkt->dts = avctx->coded_frame->pts;", "if (fs_tmp) {", "avpkt->duration = ff_samples_to_time_base(avctx,\navctx->frame_size);", "}", "}", "avpkt->size = ret;", "*got_packet_ptr = (ret > 0);", "ret = 0;", "}", "if (fs_tmp)\navctx->frame_size = fs_tmp;", "}", "if (!ret) {", "if (!user_packet && avpkt->data) {", "uint8_t *new_data = av_realloc(avpkt->data, avpkt->size);", "if (new_data)\navpkt->data = new_data;", "}", "avctx->frame_number++;", "}", "if (ret < 0 || !*got_packet_ptr)\nav_free_packet(avpkt);", "avpkt->flags |= AV_PKT_FLAG_KEY;", "return ret;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133, 135 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 157 ], [ 163, 165 ], [ 167 ], [ 169 ], [ 175, 177 ], [ 179 ], [ 181, 183 ], [ 191 ], [ 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223, 225 ], [ 227 ], [ 231 ], [ 233 ], [ 237, 239 ], [ 249 ], [ 253 ], [ 255 ] ]

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "dc->realize = fsl_imx6_realize;", "dc->desc = \"i.MX6 SOC\";", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(gconstpointer VAR_0)\n{", "const TestCase *VAR_1 = VAR_0;", "char *VAR_2;", "VAR_2 = g_strdup_printf(\"-display none -M %s%s%s -device pc-testdev\",\nVAR_1->machine,\nVAR_1->superio ? \" -device \" : \"\",\nVAR_1->superio ?: \"\");", "qtest_start(VAR_2);", "isa_outl(VAR_1, 0xe8, 0x87654321);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x87654321);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8765);", "g_assert_cmphex(isa_inw(VAR_1, 0xe0), ==, 0x4321);", "isa_outw(VAR_1, 0xea, 0x8866);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x88664321);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8866);", "g_assert_cmphex(isa_inw(VAR_1, 0xe0), ==, 0x4321);", "isa_outw(VAR_1, 0xe8, 0x4422);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x88664422);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8866);", "g_assert_cmphex(isa_inw(VAR_1, 0xe0), ==, 0x4422);", "isa_outb(VAR_1, 0xeb, 0x87);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x87664422);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8766);", "isa_outb(VAR_1, 0xea, 0x65);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x87654422);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8765);", "g_assert_cmphex(isa_inw(VAR_1, 0xe0), ==, 0x4422);", "isa_outb(VAR_1, 0xe9, 0x43);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x87654322);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8765);", "g_assert_cmphex(isa_inw(VAR_1, 0xe0), ==, 0x4322);", "isa_outb(VAR_1, 0xe8, 0x21);", "g_assert_cmphex(isa_inl(VAR_1, 0xe0), ==, 0x87654321);", "g_assert_cmphex(isa_inw(VAR_1, 0xe2), ==, 0x8765);", "g_assert_cmphex(isa_inw(VAR_1, 0xe0), ==, 0x4321);", "qtest_quit(global_qtest);", "g_free(VAR_2);", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "const char *VAR_0 = \" \\t \";", "char VAR_1 = 'X';", "const char *VAR_2 = &VAR_1;", "uint64_t res = 999;", "int VAR_3;", "VAR_3 = qemu_strtoull(VAR_0, &VAR_2, 0, &res);", "g_assert_cmpint(VAR_3, ==, 0);", "g_assert_cmpint(res, ==, 0);", "g_assert(VAR_2 == VAR_0);", "}" ]

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

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

[ "static int FUNC_0(MatroskaDemuxContext *VAR_0,\nMatroskaTrack *VAR_1, AVStream *VAR_2,\nuint8_t *VAR_3, int VAR_4,\nuint64_t VAR_5, uint64_t VAR_6,\nint64_t VAR_7, int VAR_8)\n{", "MatroskaTrackEncoding *encodings = VAR_1->encodings.elem;", "uint8_t *pkt_data = VAR_3;", "int VAR_9 = 0, VAR_10;", "AVPacket *pkt;", "if (encodings && encodings->scope & 1) {", "VAR_10 = matroska_decode_buffer(&pkt_data, &VAR_4, VAR_1);", "if (VAR_10 < 0)\nreturn VAR_10;", "}", "if (VAR_2->codec->codec_id == AV_CODEC_ID_WAVPACK) {", "uint8_t *wv_data;", "VAR_10 = matroska_parse_wavpack(VAR_1, pkt_data, &wv_data, &VAR_4);", "if (VAR_10 < 0) {", "av_log(VAR_0->ctx, AV_LOG_ERROR,\n\"Error parsing a wavpack block.\\n\");", "goto fail;", "}", "if (pkt_data != VAR_3)\npkt_data = wv_data;", "}", "if (VAR_2->codec->codec_id == AV_CODEC_ID_PRORES)\nVAR_9 = 8;", "pkt = av_mallocz(sizeof(AVPacket));", "if (av_new_packet(pkt, VAR_4 + VAR_9) < 0) {", "av_free(pkt);", "return AVERROR(ENOMEM);", "}", "if (VAR_2->codec->codec_id == AV_CODEC_ID_PRORES) {", "uint8_t *buf = pkt->VAR_3;", "bytestream_put_be32(&buf, VAR_4);", "bytestream_put_be32(&buf, MKBETAG('i', 'c', 'p', 'f'));", "}", "memcpy(pkt->VAR_3 + VAR_9, pkt_data, VAR_4);", "if (pkt_data != VAR_3)\nav_free(pkt_data);", "pkt->flags = VAR_8;", "pkt->stream_index = VAR_2->index;", "if (VAR_1->ms_compat)\npkt->dts = VAR_5;", "else\npkt->pts = VAR_5;", "pkt->VAR_7 = VAR_7;", "if (VAR_2->codec->codec_id == AV_CODEC_ID_TEXT)\npkt->convergence_duration = VAR_6;", "else if (VAR_1->type != MATROSKA_TRACK_TYPE_SUBTITLE)\npkt->VAR_6 = VAR_6;", "if (VAR_2->codec->codec_id == AV_CODEC_ID_SSA)\nmatroska_fix_ass_packet(VAR_0, pkt, VAR_6);", "if (VAR_0->prev_pkt &&\nVAR_5 != AV_NOPTS_VALUE &&\nVAR_0->prev_pkt->pts == VAR_5 &&\nVAR_0->prev_pkt->stream_index == VAR_2->index &&\nVAR_2->codec->codec_id == AV_CODEC_ID_SSA)\nmatroska_merge_packets(VAR_0->prev_pkt, pkt);", "else {", "dynarray_add(&VAR_0->packets, &VAR_0->num_packets, pkt);", "VAR_0->prev_pkt = pkt;", "}", "return 0;", "fail:\nif (pkt_data != VAR_3)\nreturn VAR_10;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51, 54 ], [ 56 ], [ 60, 62 ], [ 66 ], [ 70 ], [ 72 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 97, 99 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 113, 115 ], [ 117 ], [ 119, 121 ], [ 123, 125 ], [ 129, 131 ], [ 135, 137, 139, 141, 143, 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 161, 163, 166 ], [ 168 ] ]

[ "void *FUNC_0(void *VAR_0, unsigned int *VAR_1, unsigned int VAR_2)\n{", "if(VAR_2 < *VAR_1)\nreturn VAR_0;", "*VAR_1= 17*VAR_2/16 + 32;", "return av_realloc(VAR_0, *VAR_1);", "}" ]

[ 0, 0, 1, 0, 0 ]

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

[ "static int FUNC_0(VideoState *VAR_0, AVFrame *VAR_1, int64_t *VAR_2, AVPacket *VAR_3, int *VAR_4)\n{", "int VAR_5;", "if (packet_queue_get(&VAR_0->videoq, VAR_3, 1, VAR_4) < 0)\nreturn -1;", "if (VAR_3->data == flush_pkt.data) {", "avcodec_flush_buffers(VAR_0->video_st->codec);", "SDL_LockMutex(VAR_0->pictq_mutex);", "while (VAR_0->pictq_size && !VAR_0->videoq.abort_request) {", "SDL_CondWait(VAR_0->pictq_cond, VAR_0->pictq_mutex);", "}", "VAR_0->video_current_pos = -1;", "VAR_0->frame_last_pts = AV_NOPTS_VALUE;", "VAR_0->frame_last_duration = 0;", "VAR_0->frame_timer = (double)av_gettime() / 1000000.0;", "VAR_0->frame_last_dropped_pts = AV_NOPTS_VALUE;", "SDL_UnlockMutex(VAR_0->pictq_mutex);", "return 0;", "}", "if(avcodec_decode_video2(VAR_0->video_st->codec, VAR_1, &VAR_5, VAR_3) < 0)\nreturn 0;", "if (VAR_5) {", "int VAR_6 = 1;", "if (decoder_reorder_pts == -1) {", "*VAR_2 = av_frame_get_best_effort_timestamp(VAR_1);", "} else if (decoder_reorder_pts) {", "*VAR_2 = VAR_1->pkt_pts;", "} else {", "*VAR_2 = VAR_1->pkt_dts;", "}", "if (*VAR_2 == AV_NOPTS_VALUE) {", "*VAR_2 = 0;", "}", "if (framedrop>0 || (framedrop && get_master_sync_type(VAR_0) != AV_SYNC_VIDEO_MASTER)) {", "SDL_LockMutex(VAR_0->pictq_mutex);", "if (VAR_0->frame_last_pts != AV_NOPTS_VALUE && *VAR_2) {", "double VAR_7 = get_video_clock(VAR_0) - get_master_clock(VAR_0);", "double VAR_8 = av_q2d(VAR_0->video_st->time_base) * *VAR_2;", "double VAR_9 = VAR_8 - VAR_0->frame_last_pts;", "if (fabs(VAR_7) < AV_NOSYNC_THRESHOLD &&\nVAR_9 > 0 && VAR_9 < AV_NOSYNC_THRESHOLD &&\nVAR_7 + VAR_9 - VAR_0->frame_last_filter_delay < 0) {", "VAR_0->frame_last_dropped_pos = VAR_3->pos;", "VAR_0->frame_last_dropped_pts = VAR_8;", "VAR_0->frame_drops_early++;", "VAR_6 = 0;", "}", "}", "SDL_UnlockMutex(VAR_0->pictq_mutex);", "}", "return 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 51, 53 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101, 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "PCIDevice *dev = VAR_0;", "unsigned int VAR_4 = VAR_1 & (MSIX_PAGE_SIZE - 1) & ~0x3;", "int VAR_5 = VAR_4 / PCI_MSIX_ENTRY_SIZE;", "pci_set_long(dev->msix_table_page + VAR_4, VAR_2);", "msix_handle_mask_update(dev, VAR_5);" ]

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

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

[ "static void FUNC_0(VFIOPCIDevice *VAR_0)\n{", "vfio_disable_interrupts(VAR_0);", "VAR_0->msi_vectors = g_malloc0(VAR_0->msix->entries * sizeof(VFIOMSIVector));", "VAR_0->interrupt = VFIO_INT_MSIX;", "vfio_msix_vector_do_use(&VAR_0->pdev, 0, NULL, NULL);", "vfio_msix_vector_release(&VAR_0->pdev, 0);", "if (msix_set_vector_notifiers(&VAR_0->pdev, vfio_msix_vector_use,\nvfio_msix_vector_release, NULL)) {", "error_report(\"vfio: msix_set_vector_notifiers failed\");", "}", "trace_vfio_msix_enable(VAR_0->vbasedev.name);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 13 ], [ 43 ], [ 45 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ] ]

[ "static int FUNC_0(struct sockaddr *VAR_0, socklen_t VAR_1, bool *VAR_2)\n{", "int VAR_3;", "VAR_3 = socket(VAR_0->sa_family, SOCK_STREAM, 0);", "if (VAR_3 < 0) {", "return -1;", "}", "if (bind(VAR_3, VAR_0, VAR_1) < 0) {", "close(VAR_3);", "if (errno == EADDRNOTAVAIL) {", "*VAR_2 = false;", "return 0;", "}", "return -1;", "}", "close(VAR_3);", "*VAR_2 = true;", "return 0;", "}" ]

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

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

[ "int FUNC_0(FFTContext *VAR_0, int VAR_1, int VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "float VAR_7, VAR_8, VAR_9, VAR_10;", "int VAR_11 = 0;", "int VAR_12 has_vectors;", "VAR_0->VAR_1 = VAR_1;", "VAR_6 = 1 << VAR_1;", "VAR_0->exptab = av_malloc((VAR_6 / 2) * sizeof(FFTComplex));", "if (!VAR_0->exptab)\ngoto fail;", "VAR_0->revtab = av_malloc(VAR_6 * sizeof(uint16_t));", "if (!VAR_0->revtab)\ngoto fail;", "VAR_0->VAR_2 = VAR_2;", "VAR_10 = VAR_2 ? 1.0 : -1.0;", "for(VAR_3=0;VAR_3<(VAR_6/2);VAR_3++) {", "VAR_7 = 2 * M_PI * (float)VAR_3 / (float)VAR_6;", "VAR_8 = cos(VAR_7);", "VAR_9 = sin(VAR_7) * VAR_10;", "VAR_0->exptab[VAR_3].re = VAR_8;", "VAR_0->exptab[VAR_3].im = VAR_9;", "}", "VAR_0->fft_calc = ff_fft_calc_c;", "VAR_0->imdct_calc = ff_imdct_calc;", "VAR_0->imdct_half = ff_imdct_half;", "VAR_0->exptab1 = NULL;", "#ifdef HAVE_MMX\nhas_vectors = mm_support();", "VAR_11 = 1;", "if (has_vectors & MM_3DNOWEXT) {", "VAR_0->imdct_calc = ff_imdct_calc_3dn2;", "VAR_0->fft_calc = ff_fft_calc_3dn2;", "} else if (has_vectors & MM_3DNOW) {", "VAR_0->fft_calc = ff_fft_calc_3dn;", "} else if (has_vectors & MM_SSE) {", "VAR_0->imdct_calc = ff_imdct_calc_sse;", "VAR_0->imdct_half = ff_imdct_half_sse;", "VAR_0->fft_calc = ff_fft_calc_sse;", "} else {", "VAR_11 = 0;", "}", "#elif defined HAVE_ALTIVEC && !defined ALTIVEC_USE_REFERENCE_C_CODE\nhas_vectors = mm_support();", "if (has_vectors & MM_ALTIVEC) {", "VAR_0->fft_calc = ff_fft_calc_altivec;", "VAR_11 = 1;", "}", "#endif\nif (VAR_11) {", "int VAR_13, VAR_14, VAR_15, VAR_16;", "FFTComplex *q;", "VAR_13 = 1 << VAR_1;", "VAR_14 = VAR_13 >> 3;", "VAR_15 = VAR_13 >> 1;", "VAR_0->exptab1 = av_malloc(VAR_13 * 2 * sizeof(FFTComplex));", "if (!VAR_0->exptab1)\ngoto fail;", "q = VAR_0->exptab1;", "do {", "for(VAR_16 = 0; VAR_16 < VAR_15; VAR_16 += 2 * VAR_14) {", "*q++ = VAR_0->exptab[VAR_16];", "*q++ = VAR_0->exptab[VAR_16 + VAR_14];", "q->re = -VAR_0->exptab[VAR_16].im;", "q->im = VAR_0->exptab[VAR_16].re;", "q++;", "q->re = -VAR_0->exptab[VAR_16 + VAR_14].im;", "q->im = VAR_0->exptab[VAR_16 + VAR_14].re;", "q++;", "}", "VAR_14 = VAR_14 >> 1;", "} while (VAR_14 != 0);", "av_freep(&VAR_0->exptab);", "}", "for(VAR_3=0;VAR_3<VAR_6;VAR_3++) {", "VAR_5=0;", "for(VAR_4=0;VAR_4<VAR_1;VAR_4++) {", "VAR_5 |= ((VAR_3 >> VAR_4) & 1) << (VAR_1-VAR_4-1);", "}", "VAR_0->revtab[VAR_3]=VAR_5;", "}", "return 0;", "fail:\nav_freep(&VAR_0->revtab);", "av_freep(&VAR_0->exptab);", "av_freep(&VAR_0->exptab1);", "return -1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 75 ], [ 78 ], [ 80 ], [ 84 ], [ 86 ], [ 90 ], [ 92 ], [ 94 ], [ 96 ], [ 98 ], [ 100 ], [ 102, 104 ], [ 106 ], [ 108 ], [ 110 ], [ 112 ], [ 114, 120 ], [ 122 ], [ 124 ], [ 128 ], [ 130 ], [ 132 ], [ 134 ], [ 136, 138 ], [ 140 ], [ 142 ], [ 144 ], [ 146 ], [ 148 ], [ 152 ], [ 154 ], [ 156 ], [ 158 ], [ 160 ], [ 162 ], [ 164 ], [ 166 ], [ 168 ], [ 170 ], [ 172 ], [ 180 ], [ 182 ], [ 184 ], [ 186 ], [ 188 ], [ 190 ], [ 192 ], [ 194 ], [ 196, 198 ], [ 200 ], [ 202 ], [ 204 ], [ 206 ] ]

[ "static void FUNC_0(NUTContext *VAR_0, AVIOContext *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9,\nVAR_10;", "int64_t tmp_match;", "ff_put_v(VAR_1, VAR_0->version);", "if (VAR_0->version > 3)\nff_put_v(VAR_1, VAR_0->minor_version);", "ff_put_v(VAR_1, VAR_0->avf->nb_streams);", "ff_put_v(VAR_1, VAR_0->max_distance);", "ff_put_v(VAR_1, VAR_0->time_base_count);", "for (VAR_2 = 0; VAR_2 < VAR_0->time_base_count; VAR_2++) {", "ff_put_v(VAR_1, VAR_0->time_base[VAR_2].num);", "ff_put_v(VAR_1, VAR_0->time_base[VAR_2].den);", "}", "VAR_4 = 0;", "VAR_7 = 1;", "VAR_6 = 0;", "tmp_match = 1 - (1LL << 62);", "VAR_10 = 0;", "for (VAR_2 = 0; VAR_2 < 256; ) {", "VAR_9 = 0;", "VAR_8 = 0;", "if (VAR_4 != VAR_0->frame_code[VAR_2].pts_delta ) VAR_9 = 1;", "if (VAR_7 != VAR_0->frame_code[VAR_2].size_mul ) VAR_9 = 2;", "if (VAR_6 != VAR_0->frame_code[VAR_2].stream_id ) VAR_9 = 3;", "if (VAR_8 != VAR_0->frame_code[VAR_2].size_lsb ) VAR_9 = 4;", "if (VAR_10 != VAR_0->frame_code[VAR_2].header_idx) VAR_9 = 8;", "VAR_4 = VAR_0->frame_code[VAR_2].pts_delta;", "VAR_5 = VAR_0->frame_code[VAR_2].flags;", "VAR_6 = VAR_0->frame_code[VAR_2].stream_id;", "VAR_7 = VAR_0->frame_code[VAR_2].size_mul;", "VAR_8 = VAR_0->frame_code[VAR_2].size_lsb;", "VAR_10 = VAR_0->frame_code[VAR_2].header_idx;", "for (VAR_3 = 0; VAR_2 < 256; VAR_3++, VAR_2++) {", "if (VAR_2 == 'N') {", "VAR_3--;", "continue;", "}", "if (VAR_0->frame_code[VAR_2].pts_delta != VAR_4 ||\nVAR_0->frame_code[VAR_2].flags != VAR_5 ||\nVAR_0->frame_code[VAR_2].stream_id != VAR_6 ||\nVAR_0->frame_code[VAR_2].size_mul != VAR_7 ||\nVAR_0->frame_code[VAR_2].size_lsb != VAR_8 + VAR_3 ||\nVAR_0->frame_code[VAR_2].header_idx != VAR_10)\nbreak;", "}", "if (VAR_3 != VAR_7 - VAR_8)\nVAR_9 = 6;", "ff_put_v(VAR_1, VAR_5);", "ff_put_v(VAR_1, VAR_9);", "if (VAR_9 > 0) put_s(VAR_1, VAR_4);", "if (VAR_9 > 1) ff_put_v(VAR_1, VAR_7);", "if (VAR_9 > 2) ff_put_v(VAR_1, VAR_6);", "if (VAR_9 > 3) ff_put_v(VAR_1, VAR_8);", "if (VAR_9 > 4) ff_put_v(VAR_1, 0 );", "if (VAR_9 > 5) ff_put_v(VAR_1, VAR_3);", "if (VAR_9 > 6) ff_put_v(VAR_1, tmp_match);", "if (VAR_9 > 7) ff_put_v(VAR_1, VAR_10);", "}", "ff_put_v(VAR_1, VAR_0->header_count - 1);", "for (VAR_2 = 1; VAR_2 < VAR_0->header_count; VAR_2++) {", "ff_put_v(VAR_1, VAR_0->header_len[VAR_2]);", "avio_write(VAR_1, VAR_0->header[VAR_2], VAR_0->header_len[VAR_2]);", "}", "if (VAR_0->version > NUT_STABLE_VERSION)\nff_put_v(VAR_1, VAR_0->flags);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97, 99, 101, 103, 107, 109 ], [ 111 ], [ 113, 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153, 155 ], [ 157 ] ]

[ "static void FUNC_0(CPUPPCState *VAR_0,\ntarget_ulong VAR_1,\nhwaddr VAR_2)\n{", "ppcemb_tlb_t *tlb = &VAR_0->tlb.tlbe[0];", "tlb->attr = 0;", "tlb->prot = PAGE_VALID | ((PAGE_READ | PAGE_WRITE | PAGE_EXEC) << 4);", "tlb->size = 1 << 31;", "tlb->EPN = VAR_1 & TARGET_PAGE_MASK;", "tlb->RPN = VAR_2 & TARGET_PAGE_MASK;", "tlb->PID = 0;", "tlb = &VAR_0->tlb.tlbe[1];", "tlb->attr = 0;", "tlb->prot = PAGE_VALID | ((PAGE_READ | PAGE_WRITE | PAGE_EXEC) << 4);", "tlb->size = 1 << 31;", "tlb->EPN = 0x80000000 & TARGET_PAGE_MASK;", "tlb->RPN = 0x80000000 & TARGET_PAGE_MASK;", "tlb->PID = 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ] ]

[ "struct pxa2xx_pcmcia_s *FUNC_0(target_phys_addr_t VAR_0)\n{", "int VAR_1;", "struct pxa2xx_pcmcia_s *VAR_2;", "VAR_2 = (struct pxa2xx_pcmcia_s *)\nqemu_mallocz(sizeof(struct pxa2xx_pcmcia_s));", "VAR_2->io_base = VAR_0 | 0x00000000;", "VAR_1 = cpu_register_io_memory(0, pxa2xx_pcmcia_io_readfn,\npxa2xx_pcmcia_io_writefn, VAR_2);", "cpu_register_physical_memory(VAR_2->io_base, 0x03ffffff, VAR_1);", "VAR_2->attr_base = VAR_0 | 0x08000000;", "VAR_1 = cpu_register_io_memory(0, pxa2xx_pcmcia_attr_readfn,\npxa2xx_pcmcia_attr_writefn, VAR_2);", "cpu_register_physical_memory(VAR_2->attr_base, 0x03ffffff, VAR_1);", "VAR_2->common_base = VAR_0 | 0x0c000000;", "VAR_1 = cpu_register_io_memory(0, pxa2xx_pcmcia_common_readfn,\npxa2xx_pcmcia_common_writefn, VAR_2);", "cpu_register_physical_memory(VAR_2->common_base, 0x03ffffff, VAR_1);", "if (VAR_0 == 0x30000000)\nVAR_2->slot.slot_string = \"PXA PC Card Socket 1\";", "else\nVAR_2->slot.slot_string = \"PXA PC Card Socket 0\";", "VAR_2->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, VAR_2, 1)[0];", "pcmcia_socket_register(&VAR_2->slot);", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11, 13 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 57, 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2, AVPacket *VAR_3)\n{", "AVSubtitle *sub = VAR_1;", "MovTextContext *m = VAR_0->priv_data;", "int VAR_4;", "AVBPrint buf;", "char *VAR_5 = VAR_3->VAR_1;", "char *VAR_6;", "int VAR_7, VAR_8, VAR_9;", "uint64_t tsmb_size;", "const uint8_t *VAR_10;", "if (!VAR_5 || VAR_3->size < 2)\nreturn AVERROR_INVALIDDATA;", "if (VAR_3->size == 2)\nreturn AV_RB16(VAR_5) == 0 ? 0 : AVERROR_INVALIDDATA;", "VAR_7 = AV_RB16(VAR_5);", "VAR_6 = VAR_5 + FFMIN(2 + VAR_7, VAR_3->size);", "VAR_5 += 2;", "tsmb_size = 0;", "m->tracksize = 2 + VAR_7;", "m->style_entries = 0;", "m->box_flags = 0;", "m->count_s = 0;", "av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);", "if (VAR_7 + 2 != VAR_3->size) {", "while (m->tracksize + 8 <= VAR_3->size) {", "VAR_10 = VAR_5 + m->tracksize - 2;", "tsmb_size = AV_RB32(VAR_10);", "VAR_10 += 4;", "VAR_8 = AV_RB32(VAR_10);", "VAR_10 += 4;", "if (tsmb_size == 1) {", "if (m->tracksize + 16 > VAR_3->size)\nbreak;", "tsmb_size = AV_RB64(VAR_10);", "VAR_10 += 8;", "m->size_var = 16;", "} else", "m->size_var = 8;", "if (tsmb_size == 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"tsmb_size is 0\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (tsmb_size > VAR_3->size - m->tracksize)\nbreak;", "for (size_t i = 0; i < box_count; i++) {", "if (VAR_8 == box_types[i].type) {", "if (m->tracksize + m->size_var + box_types[i].base_size > VAR_3->size)\nbreak;", "VAR_9 = box_types[i].decode(VAR_10, m, VAR_3);", "if (VAR_9 == -1)\nbreak;", "}", "}", "m->tracksize = m->tracksize + tsmb_size;", "}", "text_to_ass(&buf, VAR_5, VAR_6, m);", "} else", "text_to_ass(&buf, VAR_5, VAR_6, m);", "VAR_4 = ff_ass_add_rect(sub, buf.str, m->readorder++, 0, NULL, NULL);", "av_bprint_finalize(&buf, NULL);", "if (VAR_4 < 0)\nreturn VAR_4;", "*VAR_2 = sub->num_rects > 0;", "return VAR_3->size;", "}" ]

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

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13, 14 ], [ 22, 23 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36 ], [ 38 ], [ 39 ], [ 40 ], [ 42 ], [ 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48, 49 ], [ 50 ], [ 51 ], [ 52 ], [ 53 ], [ 54 ], [ 56 ], [ 57 ], [ 58 ], [ 59 ], [ 60, 61 ], [ 62 ], [ 63 ], [ 64, 65 ], [ 66 ], [ 67, 68 ], [ 69 ], [ 70 ], [ 71 ], [ 72 ], [ 73 ], [ 74 ], [ 75 ], [ 76 ], [ 77 ], [ 78, 79 ], [ 80 ], [ 81 ], [ 82 ] ]

[ "static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "AVFrame *frame = VAR_1;", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "static const uint8_t VAR_6[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};", "unsigned int VAR_7[NBLOCKS];", "int16_t block_coefs[NBLOCKS][LPC_ORDER];", "unsigned int VAR_8[LPC_ORDER];", "int VAR_9, VAR_10;", "int VAR_11;", "int16_t *samples;", "unsigned int VAR_12;", "RA144Context *ractx = VAR_0->priv_data;", "GetBitContext gb;", "if (VAR_5 < FRAME_SIZE) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Frame too small (%d bytes). Truncated file?\\n\", VAR_5);", "*VAR_2 = 0;", "return AVERROR_INVALIDDATA;", "}", "frame->nb_samples = NBLOCKS * BLOCKSIZE;", "if ((VAR_11 = ff_get_buffer(VAR_0, frame, 0)) < 0)\nreturn VAR_11;", "samples = (int16_t *)frame->VAR_1[0];", "init_get_bits8(&gb, VAR_4, FRAME_SIZE);", "for (VAR_9 = 0; VAR_9 < LPC_ORDER; VAR_9++)", "VAR_8[VAR_9] = ff_lpc_refl_cb[VAR_9][get_bits(&gb, VAR_6[VAR_9])];", "ff_eval_coefs(ractx->lpc_coef[0], VAR_8);", "ractx->lpc_refl_rms[0] = ff_rms(VAR_8);", "VAR_12 = ff_energy_tab[get_bits(&gb, 5)];", "VAR_7[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy);", "VAR_7[1] = ff_interp(ractx, block_coefs[1], 2,\nVAR_12 <= ractx->old_energy,\nff_t_sqrt(VAR_12*ractx->old_energy) >> 12);", "VAR_7[2] = ff_interp(ractx, block_coefs[2], 3, 0, VAR_12);", "VAR_7[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], VAR_12);", "ff_int_to_int16(block_coefs[3], ractx->lpc_coef[0]);", "for (VAR_9=0; VAR_9 < NBLOCKS; VAR_9++) {", "do_output_subblock(ractx, block_coefs[VAR_9], VAR_7[VAR_9], &gb);", "for (VAR_10=0; VAR_10 < BLOCKSIZE; VAR_10++)", "*samples++ = av_clip_int16(ractx->curr_sblock[VAR_10 + 10] << 2);", "}", "ractx->old_energy = VAR_12;", "ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0];", "FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);", "*VAR_2 = 1;", "return FRAME_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, 1, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 79 ], [ 83 ], [ 85, 87, 89 ], [ 91 ], [ 93 ], [ 97 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 121 ], [ 125 ], [ 129 ], [ 131 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "IscsiLun *iscsilun = VAR_0;", "iscsi_set_events(iscsilun);", "}" ]

[ 1, 0, 0, 0 ]

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

[ "void FUNC_0(CPUState *VAR_0, FILE *VAR_1, fprintf_function VAR_2,\nint VAR_3)\n{", "MIPSCPU *cpu = MIPS_CPU(VAR_0);", "CPUMIPSState *env = &cpu->env;", "int VAR_4;", "VAR_2(VAR_1, \"pc=0x\" TARGET_FMT_lx \" HI=0x\" TARGET_FMT_lx\n\" LO=0x\" TARGET_FMT_lx \" ds %04x \"\nTARGET_FMT_lx \" \" TARGET_FMT_ld \"\\n\",\nenv->active_tc.PC, env->active_tc.HI[0], env->active_tc.LO[0],\nenv->hflags, env->btarget, env->bcond);", "for (VAR_4 = 0; VAR_4 < 32; VAR_4++) {", "if ((VAR_4 & 3) == 0)\nVAR_2(VAR_1, \"GPR%02d:\", VAR_4);", "VAR_2(VAR_1, \" %s \" TARGET_FMT_lx, regnames[VAR_4], env->active_tc.gpr[VAR_4]);", "if ((VAR_4 & 3) == 3)\nVAR_2(VAR_1, \"\\n\");", "}", "VAR_2(VAR_1, \"CP0 Status 0x%08x Cause 0x%08x EPC 0x\" TARGET_FMT_lx \"\\n\",\nenv->CP0_Status, env->CP0_Cause, env->CP0_EPC);", "VAR_2(VAR_1, \" Config0 0x%08x Config1 0x%08x LLAddr 0x%016\"\nPRIx64 \"\\n\",\nenv->CP0_Config0, env->CP0_Config1, env->lladdr);", "VAR_2(VAR_1, \" Config2 0x%08x Config3 0x%08x\\n\",\nenv->CP0_Config2, env->CP0_Config3);", "VAR_2(VAR_1, \" Config4 0x%08x Config5 0x%08x\\n\",\nenv->CP0_Config4, env->CP0_Config5);", "if (env->hflags & MIPS_HFLAG_FPU)\nfpu_dump_state(env, VAR_1, VAR_2, VAR_3);", "#if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)\ncpu_mips_check_sign_extensions(env, VAR_1, VAR_2, VAR_3);", "#endif\n}" ]

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

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

[ "static gboolean FUNC_0(GIOChannel *chan, GIOCondition cond, void *opaque)\n{", "SerialState *s = opaque;", "do {", "if (s->tsr_retry <= 0) {", "if (s->fcr & UART_FCR_FE) {", "if (fifo8_is_empty(&s->xmit_fifo)) {", "return FALSE;", "}", "s->tsr = fifo8_pop(&s->xmit_fifo);", "if (!s->xmit_fifo.num) {", "s->lsr |= UART_LSR_THRE;", "}", "} else if ((s->lsr & UART_LSR_THRE)) {", "return FALSE;", "} else {", "s->tsr = s->thr;", "s->lsr |= UART_LSR_THRE;", "s->lsr &= ~UART_LSR_TEMT;", "}", "}", "if (s->mcr & UART_MCR_LOOP) {", "serial_receive1(s, &s->tsr, 1);", "} else if (qemu_chr_fe_write(s->chr, &s->tsr, 1) != 1) {", "if (s->tsr_retry >= 0 && s->tsr_retry < MAX_XMIT_RETRY &&\nqemu_chr_fe_add_watch(s->chr, G_IO_OUT|G_IO_HUP,\nFUNC_0, s) > 0) {", "s->tsr_retry++;", "return FALSE;", "}", "s->tsr_retry = 0;", "} else {", "s->tsr_retry = 0;", "}", "} while ((s->fcr & UART_FCR_FE) && !fifo8_is_empty(&s->xmit_fifo));", "s->last_xmit_ts = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);", "if (s->lsr & UART_LSR_THRE) {", "s->lsr |= UART_LSR_TEMT;", "s->thr_ipending = 1;", "serial_update_irq(s);", "}", "return FALSE;", "}" ]

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

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

[ "static int FUNC_0(VC1Context *VAR_0, GetBitContext *VAR_1)\n{", "VAR_0->res_rtm_flag = 1;", "VAR_0->level = get_bits(VAR_1, 3);", "if (VAR_0->level >= 5) {", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"Reserved LEVEL %VAR_7\\n\",VAR_0->level);", "}", "VAR_0->chromaformat = get_bits(VAR_1, 2);", "if (VAR_0->chromaformat != 1) {", "av_log(VAR_0->s.avctx, AV_LOG_ERROR,\n\"Only 4:2:0 chroma format supported\\n\");", "return -1;", "}", "VAR_0->frmrtq_postproc = get_bits(VAR_1, 3);", "VAR_0->bitrtq_postproc = get_bits(VAR_1, 5);", "VAR_0->postprocflag = get_bits1(VAR_1);", "VAR_0->s.avctx->coded_width = (get_bits(VAR_1, 12) + 1) << 1;", "VAR_0->s.avctx->coded_height = (get_bits(VAR_1, 12) + 1) << 1;", "VAR_0->s.avctx->width = VAR_0->s.avctx->coded_width;", "VAR_0->s.avctx->height = VAR_0->s.avctx->coded_height;", "VAR_0->broadcast = get_bits1(VAR_1);", "VAR_0->interlace = get_bits1(VAR_1);", "VAR_0->tfcntrflag = get_bits1(VAR_1);", "VAR_0->finterpflag = get_bits1(VAR_1);", "skip_bits1(VAR_1);", "av_log(VAR_0->s.avctx, AV_LOG_DEBUG,\n\"Advanced Profile level %VAR_7:\\nfrmrtq_postproc=%VAR_7, bitrtq_postproc=%VAR_7\\n\"\n\"LoopFilter=%VAR_7, ChromaFormat=%VAR_7, Pulldown=%VAR_7, Interlace: %VAR_7\\n\"\n\"TFCTRflag=%VAR_7, FINTERPflag=%VAR_7\\n\",\nVAR_0->level, VAR_0->frmrtq_postproc, VAR_0->bitrtq_postproc,\nVAR_0->s.loop_filter, VAR_0->chromaformat, VAR_0->broadcast, VAR_0->interlace,\nVAR_0->tfcntrflag, VAR_0->finterpflag);", "VAR_0->psf = get_bits1(VAR_1);", "if (VAR_0->psf) {", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"Progressive Segmented Frame mode: not supported (yet)\\n\");", "return -1;", "}", "VAR_0->s.max_b_frames = VAR_0->s.avctx->max_b_frames = 7;", "if (get_bits1(VAR_1)) {", "int VAR_2, VAR_3, VAR_4 = 0;", "av_log(VAR_0->s.avctx, AV_LOG_DEBUG, \"Display extended info:\\n\");", "VAR_2 = get_bits(VAR_1, 14) + 1;", "VAR_3 = get_bits(VAR_1, 14) + 1;", "av_log(VAR_0->s.avctx, AV_LOG_DEBUG, \"Display dimensions: %ix%VAR_7\\n\", VAR_2, VAR_3);", "if (get_bits1(VAR_1))\nVAR_4 = get_bits(VAR_1, 4);", "if (VAR_4 && VAR_4 < 14) {", "VAR_0->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[VAR_4];", "} else if (VAR_4 == 15) {", "VAR_2 = get_bits(VAR_1, 8) + 1;", "VAR_3 = get_bits(VAR_1, 8) + 1;", "VAR_0->s.avctx->sample_aspect_ratio = (AVRational){VAR_2, VAR_3};", "} else {", "av_reduce(&VAR_0->s.avctx->sample_aspect_ratio.num,\n&VAR_0->s.avctx->sample_aspect_ratio.den,\nVAR_0->s.avctx->height * VAR_2,\nVAR_0->s.avctx->width * VAR_3,\n1 << 30);", "}", "av_log(VAR_0->s.avctx, AV_LOG_DEBUG, \"Aspect: %VAR_7:%VAR_7\\n\",\nVAR_0->s.avctx->sample_aspect_ratio.num,\nVAR_0->s.avctx->sample_aspect_ratio.den);", "if (get_bits1(VAR_1)) {", "if (get_bits1(VAR_1)) {", "VAR_0->s.avctx->time_base.num = 32;", "VAR_0->s.avctx->time_base.den = get_bits(VAR_1, 16) + 1;", "} else {", "int VAR_5, VAR_6;", "VAR_5 = get_bits(VAR_1, 8);", "VAR_6 = get_bits(VAR_1, 4);", "if (VAR_5 && VAR_5 < 8 && VAR_6 && VAR_6 < 3) {", "VAR_0->s.avctx->time_base.num = ff_vc1_fps_dr[VAR_6 - 1];", "VAR_0->s.avctx->time_base.den = ff_vc1_fps_nr[VAR_5 - 1] * 1000;", "}", "}", "if (VAR_0->broadcast) {", "VAR_0->s.avctx->time_base.den *= 2;", "VAR_0->s.avctx->ticks_per_frame = 2;", "}", "}", "if (get_bits1(VAR_1)) {", "VAR_0->color_prim = get_bits(VAR_1, 8);", "VAR_0->transfer_char = get_bits(VAR_1, 8);", "VAR_0->matrix_coef = get_bits(VAR_1, 8);", "}", "}", "VAR_0->hrd_param_flag = get_bits1(VAR_1);", "if (VAR_0->hrd_param_flag) {", "int VAR_7;", "VAR_0->hrd_num_leaky_buckets = get_bits(VAR_1, 5);", "skip_bits(VAR_1, 4);", "skip_bits(VAR_1, 4);", "for (VAR_7 = 0; VAR_7 < VAR_0->hrd_num_leaky_buckets; VAR_7++) {", "skip_bits(VAR_1, 16);", "skip_bits(VAR_1, 16);", "}", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 31 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 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, 123, 125, 127 ], [ 129 ], [ 131, 133, 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ] ]