Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "int FUNC_0(const char *VAR_0)\n{", "if (!rom_enable_driver_roms)\nreturn 0;", "return rom_add_file(VAR_0, \"genroms\", VAR_0, 0);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static target_ulong FUNC_0(PowerPCCPU *cpu_,\nsPAPRMachineState *spapr,\ntarget_ulong opcode,\ntarget_ulong *args)\n{", "target_ulong list = ppc64_phys_to_real(args[0]);", "target_ulong ov_table;", "PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu_);", "CPUState *cs;", "bool cpu_match = false, cpu_update = true;", "unsigned VAR_0 = cpu_->VAR_2;", "unsigned VAR_1 = 0, VAR_2 = 0;", "unsigned VAR_3 = get_compat_level(cpu_->max_compat);", "int VAR_4;", "sPAPROptionVector *ov5_guest, *ov5_cas_old, *ov5_updates;", "for (VAR_4 = 0; VAR_4 < 512; ++VAR_4) {", "uint32_t pvr, pvr_mask;", "pvr_mask = ldl_be_phys(&address_space_memory, list);", "list += 4;", "pvr = ldl_be_phys(&address_space_memory, list);", "list += 4;", "trace_spapr_cas_pvr_try(pvr);", "if (!VAR_3 &&\n((cpu_->env.spr[SPR_PVR] & pvr_mask) == (pvr & pvr_mask))) {", "cpu_match = true;", "VAR_2 = 0;", "} else if (pvr == cpu_->VAR_2) {", "cpu_match = true;", "VAR_2 = cpu_->VAR_2;", "} else if (!cpu_match) {", "cas_handle_compat_cpu(pcc, pvr, VAR_3, &VAR_1, &VAR_2);", "}", "if (~pvr_mask & pvr) {", "break;", "}", "}", "trace_spapr_cas_pvr(cpu_->VAR_2, cpu_match,\nVAR_2, pcc->pcr_mask);", "if (VAR_0 != VAR_2) {", "CPU_FOREACH(cs) {", "SetCompatState s = {", ".VAR_2 = VAR_2,\n.err = NULL,\n};", "run_on_cpu(cs, do_set_compat, RUN_ON_CPU_HOST_PTR(&s));", "if (s.err) {", "error_report_err(s.err);", "return H_HARDWARE;", "}", "}", "}", "if (!VAR_2) {", "cpu_update = false;", "}", "ov_table = list;", "ov5_guest = spapr_ovec_parse_vector(ov_table, 5);", "ov5_cas_old = spapr_ovec_clone(spapr->ov5_cas);", "spapr_ovec_intersect(spapr->ov5_cas, spapr->ov5, ov5_guest);", "spapr_ovec_cleanup(ov5_guest);", "ov5_updates = spapr_ovec_new();", "spapr->cas_reboot = spapr_ovec_diff(ov5_updates,\nov5_cas_old, spapr->ov5_cas);", "if (!spapr->cas_reboot) {", "spapr->cas_reboot =\n(spapr_h_cas_compose_response(spapr, args[1], args[2], cpu_update,\nov5_updates) != 0);", "}", "spapr_ovec_cleanup(ov5_updates);", "if (spapr->cas_reboot) {", "qemu_system_reset_request();", "}", "return H_SUCCESS;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 87, 89 ], [ 95 ], [ 97 ], [ 99 ], [ 101, 103, 105 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 131 ], [ 137 ], [ 141 ], [ 159 ], [ 163 ], [ 165 ], [ 173 ], [ 175, 177 ], [ 181 ], [ 183, 185, 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ] ]

[ "static void FUNC_0(PowerPCCPU *VAR_0,\nsPAPRMachineState *VAR_1,\nuint32_t VAR_2, uint32_t VAR_3,\ntarget_ulong VAR_4, uint32_t VAR_5,\ntarget_ulong VAR_6)\n{", "uint64_t wa_addr;", "uint64_t wa_offset;", "uint32_t drc_index;", "sPAPRDRConnector *drc;", "sPAPRDRConnectorClass *drck;", "sPAPRConfigureConnectorState *ccs;", "sPAPRDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE;", "int VAR_7;", "if (VAR_3 != 2 || VAR_5 != 1) {", "rtas_st(VAR_6, 0, RTAS_OUT_PARAM_ERROR);", "return;", "}", "wa_addr = ((uint64_t)rtas_ld(VAR_4, 1) << 32) | rtas_ld(VAR_4, 0);", "drc_index = rtas_ld(wa_addr, 0);", "drc = spapr_drc_by_index(drc_index);", "if (!drc) {", "trace_spapr_rtas_ibm_configure_connector_invalid(drc_index);", "VAR_7 = RTAS_OUT_PARAM_ERROR;", "goto out;", "}", "if ((drc->state != SPAPR_DRC_STATE_LOGICAL_UNISOLATE)\n&& (drc->state != SPAPR_DRC_STATE_PHYSICAL_UNISOLATE)) {", "VAR_7 = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE;", "goto out;", "}", "g_assert(drc->fdt);", "drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);", "ccs = drc->ccs;", "if (!ccs) {", "ccs = g_new0(sPAPRConfigureConnectorState, 1);", "ccs->fdt_offset = drc->fdt_start_offset;", "drc->ccs = ccs;", "}", "do {", "uint32_t tag;", "const char *VAR_8;", "const struct fdt_property *VAR_9;", "int VAR_10, VAR_11;", "tag = fdt_next_tag(drc->fdt, ccs->fdt_offset, &VAR_10);", "switch (tag) {", "case FDT_BEGIN_NODE:\nccs->fdt_depth++;", "VAR_8 = fdt_get_name(drc->fdt, ccs->fdt_offset, NULL);", "wa_offset = CC_VAL_DATA_OFFSET;", "rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset);", "configure_connector_st(wa_addr, wa_offset, VAR_8, strlen(VAR_8) + 1);", "resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD;", "break;", "case FDT_END_NODE:\nccs->fdt_depth--;", "if (ccs->fdt_depth == 0) {", "uint32_t drc_index = spapr_drc_index(drc);", "trace_spapr_drc_set_configured(drc_index);", "drc->state = drck->ready_state;", "g_free(ccs);", "drc->ccs = NULL;", "ccs = NULL;", "resp = SPAPR_DR_CC_RESPONSE_SUCCESS;", "} else {", "resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT;", "}", "break;", "case FDT_PROP:\nVAR_9 = fdt_get_property_by_offset(drc->fdt, ccs->fdt_offset,\n&VAR_11);", "VAR_8 = fdt_string(drc->fdt, fdt32_to_cpu(VAR_9->nameoff));", "wa_offset = CC_VAL_DATA_OFFSET;", "rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset);", "configure_connector_st(wa_addr, wa_offset, VAR_8, strlen(VAR_8) + 1);", "wa_offset += strlen(VAR_8) + 1,\nrtas_st(wa_addr, CC_IDX_PROP_LEN, VAR_11);", "rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset);", "configure_connector_st(wa_addr, wa_offset, VAR_9->data, VAR_11);", "resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY;", "break;", "case FDT_END:\nresp = SPAPR_DR_CC_RESPONSE_ERROR;", "default:\nbreak;", "}", "if (ccs) {", "ccs->fdt_offset = VAR_10;", "}", "} while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE);", "VAR_7 = resp;", "out:\nrtas_st(VAR_6, 0, VAR_7);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61, 63 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169, 171 ], [ 173 ], [ 179 ], [ 181 ], [ 183 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207, 209 ], [ 211, 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231, 233 ], [ 235 ] ]

[ "static void FUNC_0(void)\n{", "term_printf(\"(qemu) \");", "fflush(stdout);", "term_last_cmd_buf_index = 0;", "term_last_cmd_buf_size = 0;", "term_esc_state = IS_NORM;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "PXA2xxLCDState *s = (PXA2xxLCDState *) VAR_0;", "int VAR_4;", "switch (VAR_1) {", "case LCCR0:\nif ((s->control[0] & LCCR0_ENB) && !(VAR_2 & LCCR0_ENB))\ns->status[0] |= LCSR0_QD;", "if (!(s->control[0] & LCCR0_LCDT) && (VAR_2 & LCCR0_LCDT))\nprintf(\"%s: internal frame buffer unsupported\\n\", __FUNCTION__);", "if ((s->control[3] & LCCR3_API) &&\n(VAR_2 & LCCR0_ENB) && !(VAR_2 & LCCR0_LCDT))\ns->status[0] |= LCSR0_ABC;", "s->control[0] = VAR_2 & 0x07ffffff;", "pxa2xx_lcdc_int_update(s);", "s->dma_ch[0].up = !!(VAR_2 & LCCR0_ENB);", "s->dma_ch[1].up = (s->ovl1c[0] & OVLC1_EN) || (VAR_2 & LCCR0_SDS);", "break;", "case LCCR1:\ns->control[1] = VAR_2;", "break;", "case LCCR2:\ns->control[2] = VAR_2;", "break;", "case LCCR3:\ns->control[3] = VAR_2 & 0xefffffff;", "s->bpp = LCCR3_BPP(VAR_2);", "break;", "case LCCR4:\ns->control[4] = VAR_2 & 0x83ff81ff;", "break;", "case LCCR5:\ns->control[5] = VAR_2 & 0x3f3f3f3f;", "break;", "case OVL1C1:\nif (!(s->ovl1c[0] & OVLC1_EN) && (VAR_2 & OVLC1_EN))\nprintf(\"%s: Overlay 1 not supported\\n\", __FUNCTION__);", "s->ovl1c[0] = VAR_2 & 0x80ffffff;", "s->dma_ch[1].up = (VAR_2 & OVLC1_EN) || (s->control[0] & LCCR0_SDS);", "break;", "case OVL1C2:\ns->ovl1c[1] = VAR_2 & 0x000fffff;", "break;", "case OVL2C1:\nif (!(s->ovl2c[0] & OVLC1_EN) && (VAR_2 & OVLC1_EN))\nprintf(\"%s: Overlay 2 not supported\\n\", __FUNCTION__);", "s->ovl2c[0] = VAR_2 & 0x80ffffff;", "s->dma_ch[2].up = !!(VAR_2 & OVLC1_EN);", "s->dma_ch[3].up = !!(VAR_2 & OVLC1_EN);", "s->dma_ch[4].up = !!(VAR_2 & OVLC1_EN);", "break;", "case OVL2C2:\ns->ovl2c[1] = VAR_2 & 0x007fffff;", "break;", "case CCR:\nif (!(s->ccr & CCR_CEN) && (VAR_2 & CCR_CEN))\nprintf(\"%s: Hardware cursor unimplemented\\n\", __FUNCTION__);", "s->ccr = VAR_2 & 0x81ffffe7;", "s->dma_ch[5].up = !!(VAR_2 & CCR_CEN);", "break;", "case CMDCR:\ns->cmdcr = VAR_2 & 0xff;", "break;", "case TRGBR:\ns->trgbr = VAR_2 & 0x00ffffff;", "break;", "case TCR:\ns->tcr = VAR_2 & 0x7fff;", "break;", "case 0x200 ... 0x1000:\nVAR_4 = (VAR_1 - 0x200) >> 4;", "if (!(VAR_4 >= 0 && VAR_4 < PXA_LCDDMA_CHANS))\ngoto fail;", "switch (VAR_1 & 0xf) {", "case DMA_FDADR:\ns->dma_ch[VAR_4].descriptor = VAR_2 & 0xfffffff0;", "break;", "default:\ngoto fail;", "}", "break;", "case FBR0:\ns->dma_ch[0].branch = VAR_2 & 0xfffffff3;", "break;", "case FBR1:\ns->dma_ch[1].branch = VAR_2 & 0xfffffff3;", "break;", "case FBR2:\ns->dma_ch[2].branch = VAR_2 & 0xfffffff3;", "break;", "case FBR3:\ns->dma_ch[3].branch = VAR_2 & 0xfffffff3;", "break;", "case FBR4:\ns->dma_ch[4].branch = VAR_2 & 0xfffffff3;", "break;", "case FBR5:\ns->dma_ch[5].branch = VAR_2 & 0xfffffff3;", "break;", "case FBR6:\ns->dma_ch[6].branch = VAR_2 & 0xfffffff3;", "break;", "case BSCNTR:\ns->bscntr = VAR_2 & 0xf;", "break;", "case PRSR:\nbreak;", "case LCSR0:\ns->status[0] &= ~(VAR_2 & 0xfff);", "if (VAR_2 & LCSR0_BER)\ns->status[0] &= ~LCSR0_BERCH(7);", "break;", "case LCSR1:\ns->status[1] &= ~(VAR_2 & 0x3e3f3f);", "break;", "default:\nfail:\nhw_error(\"%s: Bad VAR_1 \" REG_FMT \"\\n\", __FUNCTION__, VAR_1);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 25, 27 ], [ 31, 33, 35 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 53, 55 ], [ 57 ], [ 61, 63 ], [ 65 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 79, 81 ], [ 83 ], [ 87, 89 ], [ 91 ], [ 95, 97, 99 ], [ 103 ], [ 105 ], [ 107 ], [ 111, 113 ], [ 115 ], [ 119, 121, 123 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 143 ], [ 147, 149, 151 ], [ 155 ], [ 157 ], [ 159 ], [ 163, 165 ], [ 167 ], [ 171, 173 ], [ 175 ], [ 179, 181 ], [ 183 ], [ 187, 189 ], [ 191, 193 ], [ 197 ], [ 199, 201 ], [ 203 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 217, 219 ], [ 221 ], [ 223, 225 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241, 243 ], [ 245 ], [ 247, 249 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 261, 263 ], [ 265 ], [ 269, 271 ], [ 275, 277 ], [ 279, 281 ], [ 283 ], [ 287, 289 ], [ 291 ], [ 295, 297, 299 ], [ 301 ], [ 303 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "int VAR_1;", "int32_t fid;", "size_t offset = 7;", "V9fsFidState *fidp;", "V9fsPDU *pdu = VAR_0;", "V9fsState *s = pdu->s;", "pdu_unmarshal(pdu, offset, \"d\", &fid);", "trace_v9fs_clunk(pdu->tag, pdu->id, fid);", "fidp = clunk_fid(s, fid);", "if (fidp == NULL) {", "VAR_1 = -ENOENT;", "goto out_nofid;", "}", "fidp->ref++;", "VAR_1 = offset;", "put_fid(pdu, fidp);", "out_nofid:\ncomplete_pdu(s, pdu, VAR_1);", "}" ]

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

[ "static void FUNC_0(PCIDevice *VAR_0, const PCIEAERErr *VAR_1)\n{", "uint8_t *aer_cap = VAR_0->config + VAR_0->exp.aer_cap;", "uint8_t first_bit = ffs(VAR_1->status) - 1;", "uint32_t errcap = pci_get_long(aer_cap + PCI_ERR_CAP);", "int VAR_2;", "assert(VAR_1->status);", "assert(!(VAR_1->status & (VAR_1->status - 1)));", "errcap &= ~(PCI_ERR_CAP_FEP_MASK | PCI_ERR_CAP_TLP);", "errcap |= PCI_ERR_CAP_FEP(first_bit);", "if (VAR_1->flags & PCIE_AER_ERR_HEADER_VALID) {", "for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(VAR_1->header); ++VAR_2) {", "uint8_t *header_log =\naer_cap + PCI_ERR_HEADER_LOG + VAR_2 * sizeof VAR_1->header[0];", "stl_be_p(header_log, VAR_1->header[VAR_2]);", "}", "} else {", "assert(!(VAR_1->flags & PCIE_AER_ERR_TLP_PREFIX_PRESENT));", "memset(aer_cap + PCI_ERR_HEADER_LOG, 0, PCI_ERR_HEADER_LOG_SIZE);", "}", "if ((VAR_1->flags & PCIE_AER_ERR_TLP_PREFIX_PRESENT) &&\n(pci_get_long(VAR_0->config + VAR_0->exp.exp_cap + PCI_EXP_DEVCAP2) &\nPCI_EXP_DEVCAP2_EETLPP)) {", "for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(VAR_1->prefix); ++VAR_2) {", "uint8_t *prefix_log =\naer_cap + PCI_ERR_TLP_PREFIX_LOG + VAR_2 * sizeof VAR_1->prefix[0];", "stl_be_p(prefix_log, VAR_1->prefix[VAR_2]);", "}", "errcap |= PCI_ERR_CAP_TLP;", "} else {", "memset(aer_cap + PCI_ERR_TLP_PREFIX_LOG, 0,\nPCI_ERR_TLP_PREFIX_LOG_SIZE);", "}", "pci_set_long(aer_cap + PCI_ERR_CAP, errcap);", "}" ]

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

[ "static int FUNC_0(const char *VAR_0, QEMUOptionParameter *VAR_1)\n{", "int VAR_2;", "int VAR_3 = 0;", "struct stat VAR_4;", "int64_t total_size = 0;", "while (VAR_1 && VAR_1->name) {", "if (!strcmp(VAR_1->name, \"size\")) {", "total_size = VAR_1->value.n / 512;", "}", "VAR_1++;", "}", "VAR_2 = open(VAR_0, O_WRONLY | O_BINARY);", "if (VAR_2 < 0)\nreturn -EIO;", "if (fstat(VAR_2, &VAR_4) < 0)\nVAR_3 = -EIO;", "else if (!S_ISBLK(VAR_4.st_mode))\nVAR_3 = -EIO;", "else if (lseek(VAR_2, 0, SEEK_END) < total_size * 512)\nVAR_3 = -ENOSPC;", "close(VAR_2);", "return VAR_3;", "}" ]

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

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

[ "void FUNC_0(struct NetRxPkt *VAR_0, const void *VAR_1,\nsize_t VAR_2)\n{", "assert(VAR_0);", "eth_get_protocols(VAR_1, VAR_2, &VAR_0->isip4, &VAR_0->isip6,\n&VAR_0->isudp, &VAR_0->istcp);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1,\nint *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "const uint8_t *VAR_5 = VAR_3->VAR_1 + VAR_3->size;", "int VAR_6 = VAR_3->size;", "DPXContext *const s = VAR_0->priv_data;", "AVFrame *picture = VAR_1;", "AVFrame *const p = &s->picture;", "uint8_t *ptr;", "int VAR_7, VAR_8, VAR_9;", "int VAR_10, VAR_11;", "int VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18, VAR_19;", "unsigned int VAR_20;", "if (VAR_3->size <= 1634) {", "av_log(VAR_0, AV_LOG_ERROR, \"Packet too small for DPX header\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_7 = AV_RB32(VAR_4);", "VAR_4 += 4;", "if (VAR_7 == AV_RL32(\"SDPX\")) {", "VAR_9 = 0;", "} else if (VAR_7 == AV_RB32(\"SDPX\")) {", "VAR_9 = 1;", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"DPX marker not found\\n\");", "return -1;", "}", "VAR_8 = read32(&VAR_4, VAR_9);", "if (VAR_3->size <= VAR_8) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid VAR_1 start VAR_8\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_4 = VAR_3->VAR_1 + 0x304;", "VAR_12 = read32(&VAR_4, VAR_9);", "VAR_13 = read32(&VAR_4, VAR_9);", "VAR_4 += 20;", "VAR_16 = VAR_4[0];", "VAR_4 += 3;", "VAR_0->bits_per_raw_sample =\nVAR_15 = VAR_4[0];", "VAR_4 += 825;", "VAR_0->sample_aspect_ratio.num = read32(&VAR_4, VAR_9);", "VAR_0->sample_aspect_ratio.den = read32(&VAR_4, VAR_9);", "if (VAR_0->sample_aspect_ratio.num > 0 && VAR_0->sample_aspect_ratio.den > 0)\nav_reduce(&VAR_0->sample_aspect_ratio.num, &VAR_0->sample_aspect_ratio.den,\nVAR_0->sample_aspect_ratio.num, VAR_0->sample_aspect_ratio.den,\n0x10000);", "else\nVAR_0->sample_aspect_ratio = (AVRational){ 0, 0 };", "switch (VAR_16) {", "case 51:\nVAR_17 = 4;", "break;", "case 50:\nVAR_17 = 3;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unsupported VAR_16 %d\\n\", VAR_16);", "return -1;", "}", "switch (VAR_15) {", "case 8:\nif (VAR_17 == 4) {", "VAR_0->pix_fmt = PIX_FMT_RGBA;", "} else {", "VAR_0->pix_fmt = PIX_FMT_RGB24;", "}", "VAR_19 = VAR_17;", "VAR_18 = VAR_17;", "break;", "case 10:\nVAR_0->pix_fmt = PIX_FMT_RGB48;", "VAR_18 = 6;", "VAR_19 = 4;", "break;", "case 12:\ncase 16:\nif (VAR_9) {", "VAR_0->pix_fmt = VAR_17 == 4 ? PIX_FMT_RGBA64BE : PIX_FMT_RGB48BE;", "} else {", "VAR_0->pix_fmt = VAR_17 == 4 ? PIX_FMT_RGBA64LE : PIX_FMT_RGB48LE;", "}", "VAR_18 =\nVAR_19 = VAR_17 * 2;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unsupported color depth : %d\\n\", VAR_15);", "return -1;", "}", "if (s->picture.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &s->picture);", "if (av_image_check_size(VAR_12, VAR_13, 0, VAR_0))\nreturn -1;", "if (VAR_12 != VAR_0->width || VAR_13 != VAR_0->height)\navcodec_set_dimensions(VAR_0, VAR_12, VAR_13);", "if (VAR_0->get_buffer(VAR_0, p) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return -1;", "}", "VAR_4 = VAR_3->VAR_1 + VAR_8;", "ptr = p->VAR_1[0];", "VAR_14 = p->linesize[0];", "if (VAR_19*VAR_0->width*VAR_0->height > VAR_5 - VAR_4) {", "av_log(VAR_0, AV_LOG_ERROR, \"Overread buffer. Invalid header?\\n\");", "return -1;", "}", "switch (VAR_15) {", "case 10:\nfor (VAR_10 = 0; VAR_10 < VAR_0->height; VAR_10++) {", "uint16_t *dst = (uint16_t*)ptr;", "for (VAR_11 = 0; VAR_11 < VAR_0->width; VAR_11++) {", "VAR_20 = read32(&VAR_4, VAR_9);", "*dst++ = make_16bit(VAR_20 >> 16);", "*dst++ = make_16bit(VAR_20 >> 6);", "*dst++ = make_16bit(VAR_20 << 4);", "}", "ptr += VAR_14;", "}", "break;", "case 8:\ncase 12:\ncase 16:\nif (VAR_19 == VAR_18) {", "for (VAR_10 = 0; VAR_10 < VAR_0->height; VAR_10++) {", "memcpy(ptr, VAR_4, VAR_18*VAR_0->width);", "ptr += VAR_14;", "VAR_4 += VAR_19*VAR_0->width;", "}", "} else {", "for (VAR_10 = 0; VAR_10 < VAR_0->height; VAR_10++) {", "uint8_t *dst = ptr;", "for (VAR_11 = 0; VAR_11 < VAR_0->width; VAR_11++) {", "memcpy(dst, VAR_4, VAR_18);", "dst += VAR_18;", "VAR_4 += VAR_19;", "}", "ptr += VAR_14;", "}", "}", "break;", "}", "*picture = s->picture;", "*VAR_2 = sizeof(AVPicture);", "return VAR_6;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 99 ], [ 101 ], [ 107 ], [ 109, 111 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 123, 125, 127 ], [ 129, 131 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189, 191, 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203, 205 ], [ 207 ], [ 209, 211 ], [ 213 ], [ 215 ], [ 219, 221 ], [ 223, 225 ], [ 227, 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 243 ], [ 247 ], [ 249 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263, 265 ], [ 267 ], [ 269 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289, 291, 293, 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 335 ], [ 337 ], [ 341 ], [ 343 ] ]

[ "static int FUNC_0(struct AVFormatContext *VAR_0)\n{", "HLSContext *hls = VAR_0->priv_data;", "AVFormatContext *VAR_1 = hls->avf;", "av_write_trailer(VAR_1);", "avio_closep(&VAR_1->pb);", "avformat_free_context(VAR_1);", "av_free(hls->basename);", "append_entry(hls, hls->duration);", "hls_window(VAR_0, 1);", "free_entries(hls);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "G726Context *c = VAR_0->priv_data;", "int16_t *samples = VAR_1;", "GetBitContext gb;", "init_get_bits(&gb, VAR_4, VAR_5 * 8);", "while (get_bits_count(&gb) + c->code_size <= VAR_5*8)\n*samples++ = g726_decode(c, get_bits(&gb, c->code_size));", "if(VAR_5*8 != get_bits_count(&gb))\nav_log(VAR_0, AV_LOG_ERROR, \"Frame invalidly split, missing parser?\\n\");", "*VAR_2 = (uint8_t*)samples - (uint8_t*)VAR_1;", "return VAR_5;", "}" ]

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

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

[ "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 + 256] = VAR_0[VAR_1];", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "FUNC_0(AVFormatContext *VAR_0, ICreateDevEnum *VAR_1,\nenum dshowDeviceType VAR_2, enum dshowSourceFilterType VAR_3, IBaseFilter **VAR_4)\n{", "struct dshow_ctx *VAR_5 = VAR_0->priv_data;", "IBaseFilter *device_filter = NULL;", "IEnumMoniker *classenum = NULL;", "IMoniker *m = NULL;", "const char *VAR_6 = VAR_5->VAR_6[VAR_2];", "int VAR_7 = (VAR_2 == VideoDevice) ? VAR_5->video_device_number\n: VAR_5->audio_device_number;", "int VAR_8;", "const GUID *VAR_9[2] = { &CLSID_VideoInputDeviceCategory,", "&CLSID_AudioInputDeviceCategory };", "const char *VAR_10 = (VAR_2 == VideoDevice) ? \"video\" : \"audio only\";", "const char *VAR_11 = (VAR_3 == VideoSourceDevice) ? \"video\" : \"audio\";", "VAR_8 = ICreateDevEnum_CreateClassEnumerator(VAR_1, VAR_9[VAR_3],\n(IEnumMoniker **) &classenum, 0);", "if (VAR_8 != S_OK) {", "av_log(VAR_0, AV_LOG_ERROR, \"Could not enumerate %s devices (or none found).\\n\",\nVAR_10);", "return AVERROR(EIO);", "}", "while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) {", "IPropertyBag *bag = NULL;", "char *VAR_12 = NULL;", "char *VAR_13 = NULL;", "VARIANT var;", "IBindCtx *bind_ctx = NULL;", "LPOLESTR olestr = NULL;", "LPMALLOC co_malloc = NULL;", "int VAR_14;", "VAR_8 = CoGetMalloc(1, &co_malloc);", "if (VAR_8 = S_OK)\ngoto fail1;", "VAR_8 = CreateBindCtx(0, &bind_ctx);", "if (VAR_8 != S_OK)\ngoto fail1;", "VAR_8 = IMoniker_GetDisplayName(m, bind_ctx, NULL, &olestr);", "if (VAR_8 != S_OK)\ngoto fail1;", "VAR_13 = dup_wchar_to_utf8(olestr);", "for (VAR_14 = 0; VAR_14 < strlen(VAR_13); VAR_14++) {", "if (VAR_13[VAR_14] == ':')\nVAR_13[VAR_14] = '_';", "}", "VAR_8 = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);", "if (VAR_8 != S_OK)\ngoto fail1;", "var.vt = VT_BSTR;", "VAR_8 = IPropertyBag_Read(bag, L\"FriendlyName\", &var, NULL);", "if (VAR_8 != S_OK)\ngoto fail1;", "VAR_12 = dup_wchar_to_utf8(var.bstrVal);", "if (VAR_4) {", "if (strcmp(VAR_6, VAR_12) && strcmp(VAR_6, VAR_13))\ngoto fail1;", "if (!VAR_7--) {", "VAR_8 = IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);", "if (VAR_8 != S_OK) {", "av_log(VAR_0, AV_LOG_ERROR, \"Unable to BindToObject for %s\\n\", VAR_6);", "goto fail1;", "}", "}", "} else {", "av_log(VAR_0, AV_LOG_INFO, \" \\\"%s\\\"\\n\", VAR_12);", "av_log(VAR_0, AV_LOG_INFO, \" Alternative name \\\"%s\\\"\\n\", VAR_13);", "}", "fail1:\nif (olestr && co_malloc)\nIMalloc_Free(co_malloc, olestr);", "if (bind_ctx)\nIBindCtx_Release(bind_ctx);", "av_free(VAR_12);", "av_free(VAR_13);", "if (bag)\nIPropertyBag_Release(bag);", "IMoniker_Release(m);", "}", "IEnumMoniker_Release(classenum);", "if (VAR_4) {", "if (!device_filter) {", "av_log(VAR_0, AV_LOG_ERROR, \"Could not find %s device with name [%s] among source devices of type %s.\\n\",\nVAR_10, VAR_6, VAR_11);", "return AVERROR(EIO);", "}", "*VAR_4 = device_filter;", "}", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17, 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35, 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79, 81 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 105 ], [ 107, 109 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 125 ], [ 127, 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157, 159, 161 ], [ 163, 165 ], [ 167 ], [ 169 ], [ 171, 173 ], [ 175 ], [ 177 ], [ 181 ], [ 185 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ] ]

[ "static void FUNC_0(AVPicture *VAR_0, AVPicture *VAR_1,\nint VAR_2, int VAR_3)\n{", "int VAR_4, VAR_5, VAR_6;", "int VAR_7, VAR_8, VAR_9;", "uint8_t *lum, *cb, *cr;", "const uint8_t *VAR_10;", "lum = VAR_0->data[0];", "cb = VAR_0->data[1];", "cr = VAR_0->data[2];", "VAR_4 = VAR_1->linesize[0] - VAR_2 * BPP;", "VAR_10 = VAR_1->data[0];", "for(VAR_6=0;VAR_6<VAR_3;VAR_6++) {", "for(VAR_5=0;VAR_5<VAR_2;VAR_5++) {", "RGB_IN(VAR_7, VAR_8, VAR_9, VAR_10);", "lum[0] = RGB_TO_Y(VAR_7, VAR_8, VAR_9);", "cb[0] = RGB_TO_U(VAR_7, VAR_8, VAR_9, 0);", "cr[0] = RGB_TO_V(VAR_7, VAR_8, VAR_9, 0);", "cb++;", "cr++;", "lum++;", "}", "VAR_10 += VAR_4;", "lum += VAR_0->linesize[0] - VAR_2;", "cb += VAR_0->linesize[1] - VAR_2;", "cr += VAR_0->linesize[2] - 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 ]

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

[ "static int FUNC_0(vf_instance_t *VAR_0, char *VAR_1){", "VAR_0->config=config;", "VAR_0->put_image=put_image;", "VAR_0->get_image=get_image;", "VAR_0->query_format=query_format;", "VAR_0->uninit=uninit;", "VAR_0->control= control;", "VAR_0->priv=malloc(sizeof(struct vf_priv_s));", "memset(VAR_0->priv, 0, sizeof(struct vf_priv_s));", "if (VAR_1) sscanf(VAR_1, \"%d:%d\", &VAR_0->priv->qp, &VAR_0->priv->mode);", "if(VAR_0->priv->qp < 0)\nVAR_0->priv->qp = 0;", "init_thres2();", "switch(VAR_0->priv->mode){", "case 0: requantize= hardthresh_c; break;", "case 1: requantize= softthresh_c; break;", "default:\ncase 2: requantize= mediumthresh_c; break;", "}", "#if HAVE_MMX\nif(ff_gCpuCaps.hasMMX){", "dctB= dctB_mmx;", "}", "#endif\n#if 0\nif(ff_gCpuCaps.hasMMX){", "switch(VAR_0->priv->mode){", "case 0: requantize= hardthresh_mmx; break;", "case 1: requantize= softthresh_mmx; break;", "}", "}", "#endif\nreturn 1;", "}" ]

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

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

[ "VAR_15staticVAR_15 VAR_15voidVAR_15 VAR_15ff_id3v2_parseVAR_15(VAR_15AVFormatContextVAR_15 *VAR_15VAR_0VAR_15, VAR_15intVAR_15 VAR_15VAR_1VAR_15, VAR_15uint8_tVAR_15 VAR_15VAR_2VAR_15, VAR_15uint8_tVAR_15 VAR_15VAR_3VAR_15, VAR_15ID3v2ExtraMetaVAR_15 **VAR_15VAR_4VAR_15)\n{", "VAR_15intVAR_15 VAR_15VAR_5VAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_7VAR_15;", "VAR_15charVAR_15 VAR_15VAR_8VAR_15[VAR_155VAR_15];", "VAR_15int64_tVAR_15 VAR_15nextVAR_15, VAR_15endVAR_15 = VAR_15avio_tellVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15) + VAR_15VAR_1VAR_15;", "VAR_15intVAR_15 VAR_15VAR_9VAR_15;", "VAR_15constVAR_15 VAR_15charVAR_15 *VAR_15VAR_10VAR_15 = VAR_15NULLVAR_15;", "VAR_15AVIOContextVAR_15 VAR_15pbVAR_15;", "VAR_15AVIOContextVAR_15 *VAR_15pbxVAR_15;", "VAR_15unsignedVAR_15 VAR_15charVAR_15 *VAR_15VAR_11VAR_15 = VAR_15NULLVAR_15;", "VAR_15intVAR_15 VAR_15VAR_12VAR_15 = VAR_150VAR_15;", "VAR_15voidVAR_15 (*VAR_15VAR_13VAR_15)(VAR_15AVFormatContextVAR_15*, VAR_15AVIOContextVAR_15*, VAR_15intVAR_15, VAR_15charVAR_15*, VAR_15ID3v2ExtraMetaVAR_15**) = VAR_15NULLVAR_15;", "VAR_15switchVAR_15 (VAR_15VAR_2VAR_15) {", "VAR_15caseVAR_15 VAR_152VAR_15:\nVAR_15ifVAR_15 (VAR_15VAR_3VAR_15 & VAR_150x40VAR_15) {", "VAR_15VAR_10VAR_15 = \"VAR_15compressionVAR_15\";", "VAR_15gotoVAR_15 VAR_15errorVAR_15;", "}", "VAR_15VAR_5VAR_15 = VAR_150VAR_15;", "VAR_15VAR_9VAR_15 = VAR_156VAR_15;", "VAR_15breakVAR_15;", "VAR_15caseVAR_15 VAR_153VAR_15:\nVAR_15caseVAR_15 VAR_154VAR_15:\nVAR_15VAR_5VAR_15 = VAR_151VAR_15;", "VAR_15VAR_9VAR_15 = VAR_1510VAR_15;", "VAR_15breakVAR_15;", "VAR_15defaultVAR_15:\nVAR_15VAR_10VAR_15 = \"VAR_15VAR_2VAR_15\";", "VAR_15gotoVAR_15 VAR_15errorVAR_15;", "}", "VAR_15VAR_7VAR_15 = VAR_15VAR_3VAR_15 & VAR_150x80VAR_15;", "VAR_15ifVAR_15 (VAR_15VAR_5VAR_15 && VAR_15VAR_3VAR_15 & VAR_150x40VAR_15)\nVAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15get_sizeVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_154VAR_15));", "VAR_15whileVAR_15 (VAR_15VAR_1VAR_15 >= VAR_15VAR_9VAR_15) {", "VAR_15unsignedVAR_15 VAR_15intVAR_15 VAR_15tflagsVAR_15 = VAR_150VAR_15;", "VAR_15intVAR_15 VAR_15tunsyncVAR_15 = VAR_150VAR_15;", "VAR_15ifVAR_15 (VAR_15VAR_5VAR_15) {", "VAR_15avio_readVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_8VAR_15, VAR_154VAR_15);", "VAR_15VAR_8VAR_15[VAR_154VAR_15] = VAR_150VAR_15;", "VAR_15ifVAR_15(VAR_15VAR_2VAR_15==VAR_153VAR_15){", "VAR_15VAR_6VAR_15 = VAR_15avio_rb32VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);", "}VAR_15elseVAR_15", "VAR_15VAR_6VAR_15 = VAR_15get_sizeVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_154VAR_15);", "VAR_15tflagsVAR_15 = VAR_15avio_rb16VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);", "VAR_15tunsyncVAR_15 = VAR_15tflagsVAR_15 & VAR_15ID3v2_FLAG_UNSYNCHVAR_15;", "} VAR_15elseVAR_15 {", "VAR_15avio_readVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_8VAR_15, VAR_153VAR_15);", "VAR_15VAR_8VAR_15[VAR_153VAR_15] = VAR_150VAR_15;", "VAR_15VAR_6VAR_15 = VAR_15avio_rb24VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);", "}", "VAR_15ifVAR_15 (VAR_15VAR_6VAR_15 <= VAR_150VAR_15 || VAR_15VAR_6VAR_15 > VAR_15VAR_1VAR_15 - VAR_15VAR_9VAR_15) {", "VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, \"VAR_15InvalidVAR_15 VAR_15sizeVAR_15 VAR_15inVAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15, VAR_15skippingVAR_15 VAR_15theVAR_15 VAR_15restVAR_15 VAR_15ofVAR_15 VAR_15VAR_8VAR_15.\\VAR_15nVAR_15\", VAR_15VAR_8VAR_15);", "VAR_15breakVAR_15;", "}", "VAR_15VAR_1VAR_15 -= VAR_15VAR_9VAR_15 + VAR_15VAR_6VAR_15;", "VAR_15nextVAR_15 = VAR_15avio_tellVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15) + VAR_15VAR_6VAR_15;", "VAR_15ifVAR_15 (VAR_15tflagsVAR_15 & VAR_15ID3v2_FLAG_DATALENVAR_15) {", "VAR_15avio_rb32VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);", "VAR_15VAR_6VAR_15 -= VAR_154VAR_15;", "}", "VAR_15ifVAR_15 (VAR_15tflagsVAR_15 & (VAR_15ID3v2_FLAG_ENCRYPTIONVAR_15 | VAR_15ID3v2_FLAG_COMPRESSIONVAR_15)) {", "VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, \"VAR_15SkippingVAR_15 VAR_15encryptedVAR_15/VAR_15compressedVAR_15 VAR_15ID3v2VAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15.\\VAR_15nVAR_15\", VAR_15VAR_8VAR_15);", "VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_6VAR_15);", "} VAR_15elseVAR_15 VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15] == 'VAR_15TVAR_15' || (VAR_15VAR_4VAR_15 && (VAR_15VAR_13VAR_15 = VAR_15get_extra_meta_funcVAR_15(VAR_15VAR_8VAR_15, VAR_15VAR_5VAR_15)->VAR_15readVAR_15))) {", "VAR_15ifVAR_15 (VAR_15VAR_7VAR_15 || VAR_15tunsyncVAR_15) {", "VAR_15intVAR_15 VAR_15iVAR_15, VAR_15jVAR_15;", "VAR_15av_fast_mallocVAR_15(&VAR_15VAR_11VAR_15, &VAR_15VAR_12VAR_15, VAR_15VAR_6VAR_15);", "VAR_15ifVAR_15 (!VAR_15VAR_11VAR_15) {", "VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_ERRORVAR_15, \"VAR_15FailedVAR_15 VAR_15toVAR_15 VAR_15allocVAR_15 %VAR_15dVAR_15 VAR_15bytesVAR_15\\VAR_15nVAR_15\", VAR_15VAR_6VAR_15);", "VAR_15gotoVAR_15 VAR_15seekVAR_15;", "}", "VAR_15forVAR_15 (VAR_15iVAR_15 = VAR_150VAR_15, VAR_15jVAR_15 = VAR_150VAR_15; VAR_15iVAR_15 < VAR_15VAR_6VAR_15; VAR_15iVAR_15++, VAR_15jVAR_15++) {", "VAR_15VAR_11VAR_15[VAR_15jVAR_15] = VAR_15avio_r8VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);", "VAR_15ifVAR_15 (VAR_15jVAR_15 > VAR_150VAR_15 && !VAR_15VAR_11VAR_15[VAR_15jVAR_15] && VAR_15VAR_11VAR_15[VAR_15jVAR_15 - VAR_151VAR_15] == VAR_150xffVAR_15) {", "VAR_15jVAR_15--;", "}", "}", "VAR_15ffio_init_contextVAR_15(&VAR_15pbVAR_15, VAR_15VAR_11VAR_15, VAR_15jVAR_15, VAR_150VAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15);", "VAR_15VAR_6VAR_15 = VAR_15jVAR_15;", "VAR_15pbxVAR_15 = &VAR_15pbVAR_15;", "} VAR_15elseVAR_15 {", "VAR_15pbxVAR_15 = VAR_15VAR_0VAR_15->VAR_15pbVAR_15;", "}", "VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15] == 'VAR_15TVAR_15')\nVAR_15read_ttagVAR_15(VAR_15VAR_0VAR_15, VAR_15pbxVAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_8VAR_15);", "VAR_15elseVAR_15\nVAR_15VAR_13VAR_15(VAR_15VAR_0VAR_15, VAR_15pbxVAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_8VAR_15, VAR_15VAR_4VAR_15);", "}", "VAR_15elseVAR_15 VAR_15ifVAR_15 (!VAR_15VAR_8VAR_15[VAR_150VAR_15]) {", "VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_151VAR_15])\nVAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, \"VAR_15invalidVAR_15 VAR_15frameVAR_15 VAR_15idVAR_15, VAR_15assumingVAR_15 VAR_15paddingVAR_15\");", "VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_6VAR_15);", "VAR_15breakVAR_15;", "}", "VAR_15seekVAR_15:\nVAR_15avio_seekVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15nextVAR_15, VAR_15SEEK_SETVAR_15);", "}", "VAR_15ifVAR_15 (VAR_15VAR_2VAR_15 == VAR_154VAR_15 && VAR_15VAR_3VAR_15 & VAR_150x10VAR_15)\nVAR_15endVAR_15 += VAR_1510VAR_15;", "VAR_15errorVAR_15:\nVAR_15ifVAR_15 (VAR_15VAR_10VAR_15)\nVAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_INFOVAR_15, \"VAR_15ID3v2VAR_15.%VAR_15dVAR_15 VAR_15VAR_8VAR_15 VAR_15skippedVAR_15, VAR_15cannotVAR_15 VAR_15handleVAR_15 %VAR_15VAR_0VAR_15\\VAR_15nVAR_15\", VAR_15VAR_2VAR_15, VAR_15VAR_10VAR_15);", "VAR_15avio_seekVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15endVAR_15, VAR_15SEEK_SETVAR_15);", "VAR_15av_freeVAR_15(VAR_15VAR_11VAR_15);", "VAR_15returnVAR_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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47, 49, 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 69 ], [ 73, 75 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189, 193 ], [ 195, 199 ], [ 201 ], [ 203 ], [ 205, 207 ], [ 209 ], [ 211 ], [ 213 ], [ 217, 219 ], [ 221 ], [ 225, 227 ], [ 231, 233, 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ] ]

[ "static int FUNC_0(int *VAR_0, const int16_t *VAR_1, RA144Context *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "unsigned int VAR_6;", "int VAR_7[10];", "int VAR_8[10];", "int *VAR_9 = VAR_7;", "int *VAR_10 = VAR_8;", "for (VAR_5=0; VAR_5 < 10; VAR_5++)", "VAR_8[VAR_5] = VAR_1[VAR_5];", "VAR_0[9] = VAR_10[9];", "if ((unsigned) VAR_10[9] + 0x1000 > 0x1fff) {", "av_log(VAR_2, AV_LOG_ERROR, \"Overflow. Broken sample?\\n\");", "return 1;", "}", "for (VAR_4=8; VAR_4 >= 0; VAR_4--) {", "VAR_3 = 0x1000-((VAR_10[VAR_4+1] * VAR_10[VAR_4+1]) >> 12);", "if (!VAR_3)\nVAR_3 = -2;", "for (VAR_6=0; VAR_6<=VAR_4; VAR_6++)", "VAR_9[VAR_6] = ((VAR_10[VAR_6] - ((VAR_0[VAR_4+1] * VAR_10[VAR_4-VAR_6]) >> 12)) * (0x1000000 / VAR_3)) >> 12;", "VAR_0[VAR_4] = VAR_9[VAR_4];", "if ((unsigned) VAR_9[VAR_4] + 0x1000 > 0x1fff)\nreturn 1;", "FFSWAP(int *, VAR_9, VAR_10);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 45, 47 ], [ 51 ], [ 53 ], [ 57 ], [ 61, 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ] ]

[ "static char *FUNC_0(char *VAR_0, int VAR_1, AVCodecContext *VAR_2, int VAR_3)\n{", "char *VAR_4 = NULL;", "switch (VAR_2->codec_id) {", "case CODEC_ID_MPEG4:\nif (VAR_2->flags & CODEC_FLAG_GLOBAL_HEADER) {", "VAR_4 = extradata2config(VAR_2->extradata, VAR_2->extradata_size);", "}", "av_strlcatf(VAR_0, VAR_1, \"a=rtpmap:%d MP4V-ES/90000\\r\\n\"\n\"a=fmtp:%d profile-level-id=1%s\\r\\n\",\nVAR_3,\nVAR_3, VAR_4 ? VAR_4 : \"\");", "break;", "case CODEC_ID_AAC:\nif (VAR_2->flags & CODEC_FLAG_GLOBAL_HEADER) {", "VAR_4 = extradata2config(VAR_2->extradata, VAR_2->extradata_size);", "} else {", "av_log(NULL, AV_LOG_ERROR, \"AAC with no global headers is currently not supported\\n\");", "return NULL;", "}", "if (VAR_4 == NULL) {", "return NULL;", "}", "av_strlcatf(VAR_0, VAR_1, \"a=rtpmap:%d MPEG4-GENERIC/%d/%d\\r\\n\"\n\"a=fmtp:%d profile-level-id=1;\"", "\"mode=AAC-hbr;sizelength=13;indexlength=3;\"", "\"indexdeltalength=3%s\\r\\n\",\nVAR_3, VAR_2->sample_rate, VAR_2->channels,\nVAR_3, VAR_4);", "break;", "default:\nbreak;", "}", "av_free(VAR_4);", "return VAR_0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecParserContext *VAR_0,\nAVCodecContext *VAR_1,\nconst uint8_t **VAR_2, int *VAR_3,\nconst uint8_t *VAR_4, int VAR_5)\n{", "ParseContext1 *pc1 = VAR_0->priv_data;", "ParseContext *pc= &pc1->pc;", "int VAR_6;", "if(VAR_0->flags & PARSER_FLAG_COMPLETE_FRAMES){", "VAR_6= VAR_5;", "}else{", "VAR_6= ff_mpeg1_find_frame_end(pc, VAR_4, VAR_5);", "if (ff_combine_frame(pc, VAR_6, &VAR_4, &VAR_5) < 0) {", "*VAR_2 = NULL;", "*VAR_3 = 0;", "return VAR_5;", "}", "}", "mpegvideo_extract_headers(VAR_0, VAR_1, VAR_4, VAR_5);", "#if 0\nprintf(\"pict_type=%d frame_rate=%0.3f repeat_pict=%d\\n\",\nVAR_0->pict_type, (double)VAR_1->time_base.den / VAR_1->time_base.num, VAR_0->repeat_pict);", "#endif\n*VAR_2 = VAR_4;", "*VAR_3 = VAR_5;", "return VAR_6;", "}" ]

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

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

[ "int FUNC_0(H264Context *VAR_0, MMCO *VAR_1, int VAR_2)\n{", "int VAR_3, FUNC_2(j);", "int VAR_4 = 0, VAR_5 = 0;", "H264Picture *FUNC_2(pic);", "if ((VAR_0->avctx->debug & FF_DEBUG_MMCO) && VAR_2 == 0)\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"no VAR_1 here\\n\");", "for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {", "int FUNC_2(structure), FUNC_2(frame_num);", "if (VAR_0->avctx->debug & FF_DEBUG_MMCO)\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"VAR_1:%d %d %d\\n\", VAR_0->VAR_1[VAR_3].opcode,\nVAR_0->VAR_1[VAR_3].short_pic_num, VAR_0->VAR_1[VAR_3].long_arg);", "if (VAR_1[VAR_3].opcode == MMCO_SHORT2UNUSED ||\nVAR_1[VAR_3].opcode == MMCO_SHORT2LONG) {", "frame_num = pic_num_extract(VAR_0, VAR_1[VAR_3].short_pic_num, &structure);", "pic = find_short(VAR_0, frame_num, &j);", "if (!pic) {", "if (VAR_1[VAR_3].opcode != MMCO_SHORT2LONG ||\n!VAR_0->long_ref[VAR_1[VAR_3].long_arg] ||\nVAR_0->long_ref[VAR_1[VAR_3].long_arg]->frame_num != frame_num) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_1: unref short failure\\n\");", "VAR_5 = AVERROR_INVALIDDATA;", "}", "continue;", "}", "}", "switch (VAR_1[VAR_3].opcode) {", "case MMCO_SHORT2UNUSED:\nif (VAR_0->avctx->debug & FF_DEBUG_MMCO)\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"VAR_1: unref short %d count %d\\n\",\nVAR_0->VAR_1[VAR_3].short_pic_num, VAR_0->short_ref_count);", "remove_short(VAR_0, frame_num, structure ^ PICT_FRAME);", "break;", "case MMCO_SHORT2LONG:\nif (VAR_0->long_ref[VAR_1[VAR_3].long_arg] != pic)\nremove_long(VAR_0, VAR_1[VAR_3].long_arg, 0);", "remove_short_at_index(VAR_0, j);", "VAR_0->long_ref[ VAR_1[VAR_3].long_arg ] = pic;", "if (VAR_0->long_ref[VAR_1[VAR_3].long_arg]) {", "VAR_0->long_ref[VAR_1[VAR_3].long_arg]->long_ref = 1;", "VAR_0->long_ref_count++;", "}", "break;", "case MMCO_LONG2UNUSED:\nj = pic_num_extract(VAR_0, VAR_1[VAR_3].long_arg, &structure);", "pic = VAR_0->long_ref[j];", "if (pic) {", "remove_long(VAR_0, j, structure ^ PICT_FRAME);", "} else if (VAR_0->avctx->debug & FF_DEBUG_MMCO)", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"VAR_1: unref long failure\\n\");", "break;", "case MMCO_LONG:\nif (VAR_0->short_ref[0] == VAR_0->cur_pic_ptr)\nremove_short_at_index(VAR_0, 0);", "if (VAR_0->cur_pic_ptr->long_ref) {", "for (j = 0; j < FF_ARRAY_ELEMS(VAR_0->long_ref); j++) {", "if (VAR_0->long_ref[j] == VAR_0->cur_pic_ptr)\nremove_long(VAR_0, j, 0);", "}", "}", "if (VAR_0->long_ref[VAR_1[VAR_3].long_arg] != VAR_0->cur_pic_ptr) {", "remove_long(VAR_0, VAR_1[VAR_3].long_arg, 0);", "VAR_0->long_ref[VAR_1[VAR_3].long_arg] = VAR_0->cur_pic_ptr;", "VAR_0->long_ref[VAR_1[VAR_3].long_arg]->long_ref = 1;", "VAR_0->long_ref_count++;", "}", "VAR_0->cur_pic_ptr->reference |= VAR_0->picture_structure;", "VAR_4 = 1;", "break;", "case MMCO_SET_MAX_LONG:\nassert(VAR_1[VAR_3].long_arg <= 16);", "for (j = VAR_1[VAR_3].long_arg; j < 16; j++) {", "remove_long(VAR_0, j, 0);", "}", "break;", "case MMCO_RESET:\nwhile (VAR_0->short_ref_count) {", "remove_short(VAR_0, VAR_0->short_ref[0]->frame_num, 0);", "}", "for (j = 0; j < 16; j++) {", "remove_long(VAR_0, j, 0);", "}", "VAR_0->frame_num = VAR_0->cur_pic_ptr->frame_num = 0;", "VAR_0->mmco_reset = 1;", "VAR_0->cur_pic_ptr->mmco_reset = 1;", "break;", "default: assert(0);", "}", "}", "if (!VAR_4) {", "if (VAR_0->short_ref_count && VAR_0->short_ref[0] == VAR_0->cur_pic_ptr) {", "VAR_0->cur_pic_ptr->reference = PICT_FRAME;", "} else if (VAR_0->cur_pic_ptr->long_ref) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal short term reference \"\n\"assignment for second field \"\n\"in complementary field pair \"\n\"(first field is long term)\\n\");", "VAR_5 = AVERROR_INVALIDDATA;", "} else {", "pic = remove_short(VAR_0, VAR_0->cur_pic_ptr->frame_num, 0);", "if (pic) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal short term buffer state detected\\n\");", "VAR_5 = AVERROR_INVALIDDATA;", "}", "if (VAR_0->short_ref_count)\nmemmove(&VAR_0->short_ref[1], &VAR_0->short_ref[0],\nVAR_0->short_ref_count * sizeof(H264Picture*));", "VAR_0->short_ref[0] = VAR_0->cur_pic_ptr;", "VAR_0->short_ref_count++;", "VAR_0->cur_pic_ptr->reference |= VAR_0->picture_structure;", "}", "}", "if (VAR_0->long_ref_count + VAR_0->short_ref_count -\n(VAR_0->short_ref[0] == VAR_0->cur_pic_ptr) > VAR_0->sps.ref_frame_count) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"number of reference frames (%d+%d) exceeds max (%d; probably \"", "\"corrupt input), discarding one\\n\",\nVAR_0->long_ref_count, VAR_0->short_ref_count, VAR_0->sps.ref_frame_count);", "VAR_5 = AVERROR_INVALIDDATA;", "if (VAR_0->long_ref_count && !VAR_0->short_ref_count) {", "for (VAR_3 = 0; VAR_3 < 16; ++VAR_3)", "if (VAR_0->long_ref[VAR_3])\nbreak;", "assert(VAR_3 < 16);", "remove_long(VAR_0, VAR_3, 0);", "} else {", "pic = VAR_0->short_ref[VAR_0->short_ref_count - 1];", "remove_short(VAR_0, pic->frame_num, 0);", "}", "}", "print_short_term(VAR_0);", "print_long_term(VAR_0);", "return (VAR_0->avctx->err_recognition & AV_EF_EXPLODE) ? VAR_5 : 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 27 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63, 65, 67, 69 ], [ 71 ], [ 73 ], [ 75, 77, 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113, 129, 131 ], [ 137 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 233 ], [ 237 ], [ 239 ], [ 241, 243, 245, 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 265, 267, 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 285, 287 ], [ 299, 301 ], [ 303, 305 ], [ 307 ], [ 311 ], [ 313 ], [ 315, 317 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "SchroEncoderParams *p_schro_params = VAR_0->priv_data;", "schro_encoder_free(p_schro_params->encoder);", "ff_schro_queue_free(&p_schro_params->enc_frame_queue,\nlibschroedinger_free_frame);", "if (p_schro_params->enc_buf_size)\nav_freep(&p_schro_params->enc_buf);", "av_freep(&p_schro_params->format);", "av_frame_free(&VAR_0->coded_frame);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 11 ], [ 17, 19 ], [ 27, 29 ], [ 35 ], [ 39 ], [ 43 ], [ 45 ] ]

[ "static void FUNC_0(float *VAR_0, float *VAR_1, int *VAR_2, float *VAR_3,\nint VAR_4)\n{", "LOCAL_ALIGNED_16(float, suma, [17]);", "LOCAL_ALIGNED_16(float, sumb, [17]);", "LOCAL_ALIGNED_16(float, sumc, [17]);", "LOCAL_ALIGNED_16(float, sumd, [17]);", "float VAR_5;", "memcpy(VAR_0 + 512, VAR_0, 32 * sizeof(*VAR_0));", "apply_window(VAR_0 + 16, VAR_1 , VAR_1 + 512, suma, sumc, 16);", "apply_window(VAR_0 + 32, VAR_1 + 48, VAR_1 + 640, sumb, sumd, 16);", "SUM8(MACS, suma[0], VAR_1 + 32, VAR_0 + 48);", "sumc[ 0] = 0;", "sumb[16] = 0;", "sumd[16] = 0;", "#define SUMS(suma, sumb, sumc, sumd, out1, out2) \\\n\"movups \" #sumd \"(%4), %%xmm0 \\n\\t\" \\\n\"shufps $0x1b, %%xmm0, %%xmm0 \\n\\t\" \\\n\"subps \" #suma \"(%1), %%xmm0 \\n\\t\" \\\n\"movaps %%xmm0,\" #out1 \"(%0) \\n\\t\" \\\n\\\n\"movups \" #sumc \"(%3), %%xmm0 \\n\\t\" \\\n\"shufps $0x1b, %%xmm0, %%xmm0 \\n\\t\" \\\n\"addps \" #sumb \"(%2), %%xmm0 \\n\\t\" \\\n\"movaps %%xmm0,\" #out2 \"(%0) \\n\\t\"\nif (VAR_4 == 1) {", "__asm__ volatile(\nSUMS( 0, 48, 4, 52, 0, 112)\nSUMS(16, 32, 20, 36, 16, 96)\nSUMS(32, 16, 36, 20, 32, 80)\nSUMS(48, 0, 52, 4, 48, 64)\n:\"+&r\"(VAR_3)\n:\"r\"(&suma[0]), \"r\"(&sumb[0]), \"r\"(&sumc[0]), \"r\"(&sumd[0])\n:\"memory\"\n);", "VAR_3 += 16*VAR_4;", "} else {", "int j;", "float *out2 = VAR_3 + 32 * VAR_4;", "VAR_3[0 ] = -suma[ 0];", "VAR_3 += VAR_4;", "out2 -= VAR_4;", "for(j=1;j<16;j++) {", "*VAR_3 = -suma[ j] + sumd[16-j];", "*out2 = sumb[16-j] + sumc[ j];", "VAR_3 += VAR_4;", "out2 -= VAR_4;", "}", "}", "VAR_5 = 0;", "SUM8(MLSS, VAR_5, VAR_1 + 16 + 32, VAR_0 + 32);", "*VAR_3 = VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 67 ], [ 69, 71, 73, 75, 77, 81, 83, 85, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ] ]

[ "static int FUNC_0(FsContext *VAR_0,\nconst char *VAR_1, const char *VAR_2)\n{", "char VAR_3[PATH_MAX];", "if (strncmp(VAR_2, \"user.virtfs.\", 12) == 0) {", "errno = EACCES;", "return -1;", "}", "return lremovexattr(rpath(VAR_0, VAR_1, VAR_3), VAR_2);", "}" ]

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

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

[ "static void FUNC_0(SDHCIState *VAR_0)\n{", "SDHCIClass *k = SDHCI_GET_CLASS(VAR_0);", "if (VAR_0->trnmod & SDHC_TRNS_DMA) {", "switch (SDHC_DMA_TYPE(VAR_0->hostctl)) {", "case SDHC_CTRL_SDMA:\nif ((VAR_0->trnmod & SDHC_TRNS_MULTI) &&\n(!(VAR_0->trnmod & SDHC_TRNS_BLK_CNT_EN) || VAR_0->blkcnt == 0)) {", "break;", "}", "if ((VAR_0->blkcnt == 1) || !(VAR_0->trnmod & SDHC_TRNS_MULTI)) {", "k->do_sdma_single(VAR_0);", "} else {", "k->do_sdma_multi(VAR_0);", "}", "break;", "case SDHC_CTRL_ADMA1_32:\nif (!(VAR_0->capareg & SDHC_CAN_DO_ADMA1)) {", "ERRPRINT(\"ADMA1 not supported\\n\");", "break;", "}", "k->do_adma(VAR_0);", "break;", "case SDHC_CTRL_ADMA2_32:\nif (!(VAR_0->capareg & SDHC_CAN_DO_ADMA2)) {", "ERRPRINT(\"ADMA2 not supported\\n\");", "break;", "}", "k->do_adma(VAR_0);", "break;", "case SDHC_CTRL_ADMA2_64:\nif (!(VAR_0->capareg & SDHC_CAN_DO_ADMA2) ||\n!(VAR_0->capareg & SDHC_64_BIT_BUS_SUPPORT)) {", "ERRPRINT(\"64 bit ADMA not supported\\n\");", "break;", "}", "k->do_adma(VAR_0);", "break;", "default:\nERRPRINT(\"Unsupported DMA type\\n\");", "break;", "}", "} else {", "if ((VAR_0->trnmod & SDHC_TRNS_READ) && sd_data_ready(VAR_0->card)) {", "VAR_0->prnsts |= SDHC_DOING_READ | SDHC_DATA_INHIBIT |\nSDHC_DAT_LINE_ACTIVE;", "SDHCI_GET_CLASS(VAR_0)->read_block_from_card(VAR_0);", "} else {", "VAR_0->prnsts |= SDHC_DOING_WRITE | SDHC_DAT_LINE_ACTIVE |\nSDHC_SPACE_AVAILABLE | SDHC_DATA_INHIBIT;", "SDHCI_GET_CLASS(VAR_0)->write_block_to_card(VAR_0);", "}", "}", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)\n{", "unsigned int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;", "int VAR_9 = -1;", "TCGv_i64 tcg_tmp, tcg_y, tcg_rn;", "if (!extract32(VAR_1, 29, 1)) {", "unallocated_encoding(VAR_0);", "return;", "}", "if (VAR_1 & (1 << 10 | 1 << 4)) {", "unallocated_encoding(VAR_0);", "return;", "}", "VAR_2 = extract32(VAR_1, 31, 1);", "VAR_3 = extract32(VAR_1, 30, 1);", "VAR_8 = extract32(VAR_1, 11, 1);", "VAR_4 = extract32(VAR_1, 16, 5);", "VAR_5 = extract32(VAR_1, 12, 4);", "VAR_6 = extract32(VAR_1, 5, 5);", "VAR_7 = extract32(VAR_1, 0, 4);", "if (VAR_5 < 0x0e) {", "int VAR_10 = gen_new_label();", "VAR_9 = gen_new_label();", "arm_gen_test_cc(VAR_5, VAR_10);", "tcg_tmp = tcg_temp_new_i64();", "tcg_gen_movi_i64(tcg_tmp, VAR_7 << 28);", "gen_set_nzcv(tcg_tmp);", "tcg_temp_free_i64(tcg_tmp);", "tcg_gen_br(VAR_9);", "gen_set_label(VAR_10);", "}", "if (VAR_8) {", "tcg_y = new_tmp_a64(VAR_0);", "tcg_gen_movi_i64(tcg_y, VAR_4);", "} else {", "tcg_y = cpu_reg(VAR_0, VAR_4);", "}", "tcg_rn = cpu_reg(VAR_0, VAR_6);", "tcg_tmp = tcg_temp_new_i64();", "if (VAR_3) {", "gen_sub_CC(VAR_2, tcg_tmp, tcg_rn, tcg_y);", "} else {", "gen_add_CC(VAR_2, tcg_tmp, tcg_rn, tcg_y);", "}", "tcg_temp_free_i64(tcg_tmp);", "if (VAR_5 < 0x0e) {", "gen_set_label(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 ]

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

[ "static void FUNC_0(struct XenFB *VAR_0)\n{", "uint32_t prod, cons, out_cons;", "struct xenfb_page *VAR_1 = VAR_0->c.VAR_1;", "prod = VAR_1->out_prod;", "out_cons = VAR_1->out_cons;", "if (prod - out_cons >= XENFB_OUT_RING_LEN) {", "return;", "}", "xen_rmb();", "for (cons = out_cons; cons != prod; cons++) {", "union xenfb_out_event *event = &XENFB_OUT_RING_REF(VAR_1, cons);", "uint8_t type = event->type;", "int x, y, w, h;", "switch (type) {", "case XENFB_TYPE_UPDATE:\nif (VAR_0->up_count == UP_QUEUE)\nVAR_0->up_fullscreen = 1;", "if (VAR_0->up_fullscreen)\nbreak;", "x = MAX(event->update.x, 0);", "y = MAX(event->update.y, 0);", "w = MIN(event->update.width, VAR_0->width - x);", "h = MIN(event->update.height, VAR_0->height - y);", "if (w < 0 || h < 0) {", "xen_be_printf(&VAR_0->c.xendev, 1, \"bogus update ignored\\n\");", "break;", "}", "if (x != event->update.x ||\ny != event->update.y ||\nw != event->update.width ||\nh != event->update.height) {", "xen_be_printf(&VAR_0->c.xendev, 1, \"bogus update clipped\\n\");", "}", "if (w == VAR_0->width && h > VAR_0->height / 2) {", "VAR_0->up_fullscreen = 1;", "} else {", "VAR_0->up_rects[VAR_0->up_count].x = x;", "VAR_0->up_rects[VAR_0->up_count].y = y;", "VAR_0->up_rects[VAR_0->up_count].w = w;", "VAR_0->up_rects[VAR_0->up_count].h = h;", "VAR_0->up_count++;", "}", "break;", "#ifdef XENFB_TYPE_RESIZE\ncase XENFB_TYPE_RESIZE:\nif (xenfb_configure_fb(VAR_0, VAR_0->fb_len,\nevent->resize.width,\nevent->resize.height,\nevent->resize.depth,\nVAR_0->fb_len,\nevent->resize.offset,\nevent->resize.stride) < 0)\nbreak;", "xenfb_invalidate(VAR_0);", "break;", "#endif\n}", "}", "xen_mb();", "VAR_1->out_cons = cons;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35, 37, 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63, 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 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 ] ]

[ "static always_inline void FUNC_0(void (*tcg_gen_ext_i64)(TCGv t0, TCGv t1),\nint ra, int rb, int rc,\nint islit, uint8_t lit)\n{", "if (unlikely(rc == 31))\nreturn;", "if (ra != 31) {", "if (islit) {", "tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], (lit & 7) * 8);", "} else {", "TCGv tmp = tcg_temp_new(TCG_TYPE_I64);", "tcg_gen_andi_i64(tmp, cpu_ir[rb], 7);", "tcg_gen_shli_i64(tmp, tmp, 3);", "tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], tmp);", "tcg_temp_free(tmp);", "}", "if (tcg_gen_ext_i64)\ntcg_gen_ext_i64(cpu_ir[rc], cpu_ir[rc]);", "} else", "tcg_gen_movi_i64(cpu_ir[rc], 0);", "}" ]

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

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

[ "FUNC_0(struct ip_header *VAR_0, uint16_t VAR_1)\n{", "struct ip_pseudo_header VAR_2;", "VAR_2.ip_src = VAR_0->ip_src;", "VAR_2.ip_dst = VAR_0->ip_dst;", "VAR_2.ip_payload = cpu_to_be16(VAR_1);", "VAR_2.ip_proto = VAR_0->ip_p;", "VAR_2.zeros = 0;", "return net_checksum_add(sizeof(VAR_2), (uint8_t *) &VAR_2);", "}" ]

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

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

[ "static int FUNC_0(FTPContext *VAR_0, char *VAR_1)\n{", "const char *VAR_2 = NULL, *VAR_3 = NULL;", "char *VAR_4 = NULL, buf[CONTROL_BUFFER_SIZE];", "int VAR_5;", "av_assert2(VAR_1);", "VAR_2 = av_strtok(VAR_1, \":\", &VAR_4);", "VAR_3 = av_strtok(VAR_4, \":\", &VAR_4);", "if (VAR_2) {", "snprintf(buf, sizeof(buf), \"USER %VAR_0\\r\\n\", VAR_2);", "if ((VAR_5 = ffurl_write(VAR_0->conn_control, buf, strlen(buf))) < 0)\nreturn VAR_5;", "ftp_status(VAR_0, &VAR_5, NULL, NULL, NULL, -1);", "if (VAR_5 == 3) {", "if (VAR_3) {", "snprintf(buf, sizeof(buf), \"PASS %VAR_0\\r\\n\", VAR_3);", "if ((VAR_5 = ffurl_write(VAR_0->conn_control, buf, strlen(buf))) < 0)\nreturn VAR_5;", "ftp_status(VAR_0, &VAR_5, NULL, NULL, NULL, -1);", "} else", "return AVERROR(EACCES);", "}", "if (VAR_5 != 2) {", "return AVERROR(EACCES);", "}", "} else {", "const char* VAR_6 = \"USER anonymous\\r\\n\";", "if ((VAR_5 = ffurl_write(VAR_0->conn_control, VAR_6, strlen(VAR_6))) < 0)\nreturn VAR_5;", "ftp_status(VAR_0, &VAR_5, NULL, NULL, NULL, -1);", "if (VAR_5 == 3) {", "if (VAR_0->anonymous_password) {", "snprintf(buf, sizeof(buf), \"PASS %VAR_0\\r\\n\", VAR_0->anonymous_password);", "} else", "snprintf(buf, sizeof(buf), \"PASS nopassword\\r\\n\");", "if ((VAR_5 = ffurl_write(VAR_0->conn_control, buf, strlen(buf))) < 0)\nreturn VAR_5;", "ftp_status(VAR_0, &VAR_5, NULL, NULL, NULL, -1);", "}", "if (VAR_5 != 2) {", "return AVERROR(EACCES);", "}", "}", "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 ]

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "unsigned int VAR_3 = (VAR_1 - OMAP2_L4_BASE) >> TARGET_PAGE_BITS;", "return omap_l4_io_writew_fn[VAR_3](omap_l4_io_opaque[VAR_3], VAR_1, VAR_2);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "pl050_state *s = (pl050_state *)VAR_0;", "switch (VAR_1 >> 2) {", "case 0:\ns->cr = VAR_2;", "pl050_update(s, s->pending);", "break;", "case 2:\nif (s->is_mouse) {", "ps2_write_mouse(s->dev, VAR_2);", "} else {", "ps2_write_keyboard(s->dev, VAR_2);", "}", "break;", "case 3:\ns->clk = VAR_2;", "return;", "default:\nhw_error(\"FUNC_0: Bad VAR_1 %x\\n\", (int)VAR_1);", "}", "}" ]

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

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

[ "static int FUNC_0(Monitor *VAR_0, BlockDriverState *VAR_1, int VAR_2)\n{", "if (!bdrv_is_removable(VAR_1)) {", "qerror_report(QERR_DEVICE_NOT_REMOVABLE, bdrv_get_device_name(VAR_1));", "return -1;", "}", "if (!VAR_2 && bdrv_dev_is_medium_locked(VAR_1)) {", "qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(VAR_1));", "return -1;", "}", "bdrv_close(VAR_1);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(target_phys_addr_t VAR_0, const struct arm_boot_info *VAR_1)\n{", "#ifdef CONFIG_FDT\nuint32_t *mem_reg_property;", "uint32_t mem_reg_propsize;", "void *fdt = NULL;", "char *filename;", "int size, rc;", "uint32_t acells, scells, hival;", "filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, VAR_1->dtb_filename);", "if (!filename) {", "fprintf(stderr, \"Couldn't open dtb file %s\\n\", VAR_1->dtb_filename);", "return -1;", "}", "fdt = load_device_tree(filename, &size);", "if (!fdt) {", "fprintf(stderr, \"Couldn't open dtb file %s\\n\", filename);", "g_free(filename);", "return -1;", "}", "g_free(filename);", "acells = qemu_devtree_getprop_cell(fdt, \"/\", \"#address-cells\");", "scells = qemu_devtree_getprop_cell(fdt, \"/\", \"#size-cells\");", "if (acells == 0 || scells == 0) {", "fprintf(stderr, \"dtb file invalid (#address-cells or #size-cells 0)\\n\");", "return -1;", "}", "mem_reg_propsize = acells + scells;", "mem_reg_property = g_new0(uint32_t, mem_reg_propsize);", "mem_reg_property[acells - 1] = cpu_to_be32(VAR_1->loader_start);", "hival = cpu_to_be32(VAR_1->loader_start >> 32);", "if (acells > 1) {", "mem_reg_property[acells - 2] = hival;", "} else if (hival != 0) {", "fprintf(stderr, \"qemu: dtb file not compatible with \"\n\"RAM start address > 4GB\\n\");", "exit(1);", "}", "mem_reg_property[acells + scells - 1] = cpu_to_be32(VAR_1->ram_size);", "hival = cpu_to_be32(VAR_1->ram_size >> 32);", "if (scells > 1) {", "mem_reg_property[acells + scells - 2] = hival;", "} else if (hival != 0) {", "fprintf(stderr, \"qemu: dtb file not compatible with \"\n\"RAM size > 4GB\\n\");", "exit(1);", "}", "rc = qemu_devtree_setprop(fdt, \"/memory\", \"reg\", mem_reg_property,\nmem_reg_propsize * sizeof(uint32_t));", "if (rc < 0) {", "fprintf(stderr, \"couldn't set /memory/reg\\n\");", "}", "if (VAR_1->kernel_cmdline && *VAR_1->kernel_cmdline) {", "rc = qemu_devtree_setprop_string(fdt, \"/chosen\", \"bootargs\",\nVAR_1->kernel_cmdline);", "if (rc < 0) {", "fprintf(stderr, \"couldn't set /chosen/bootargs\\n\");", "}", "}", "if (VAR_1->initrd_size) {", "rc = qemu_devtree_setprop_cell(fdt, \"/chosen\", \"linux,initrd-start\",\nVAR_1->loader_start + INITRD_LOAD_ADDR);", "if (rc < 0) {", "fprintf(stderr, \"couldn't set /chosen/linux,initrd-start\\n\");", "}", "rc = qemu_devtree_setprop_cell(fdt, \"/chosen\", \"linux,initrd-end\",\nVAR_1->loader_start + INITRD_LOAD_ADDR +\nVAR_1->initrd_size);", "if (rc < 0) {", "fprintf(stderr, \"couldn't set /chosen/linux,initrd-end\\n\");", "}", "}", "cpu_physical_memory_write(VAR_0, fdt, size);", "return 0;", "#else\nfprintf(stderr, \"Device tree requested, \"\n\"but qemu was compiled without fdt support\\n\");", "return -1;", "#endif\n}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147, 149, 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 167 ], [ 171, 173, 175 ], [ 177 ], [ 179, 181 ] ]

[ "static void FUNC_0(QEMUFile *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3;", "if (!migrate_use_compression()) {", "return;", "}", "VAR_3 = migrate_compress_threads();", "for (VAR_1 = 0; VAR_1 < VAR_3; VAR_1++) {", "if (!comp_param[VAR_1].done) {", "qemu_mutex_lock(comp_done_lock);", "while (!comp_param[VAR_1].done && !quit_comp_thread) {", "qemu_cond_wait(comp_done_cond, comp_done_lock);", "}", "qemu_mutex_unlock(comp_done_lock);", "}", "if (!quit_comp_thread) {", "VAR_2 = qemu_put_qemu_file(VAR_0, comp_param[VAR_1].file);", "bytes_transferred += VAR_2;", "}", "}", "}" ]

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

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

[ "sPAPRDRConnector *FUNC_0(Object *owner,\nsPAPRDRConnectorType type,\nuint32_t id)\n{", "sPAPRDRConnector *drc =\nSPAPR_DR_CONNECTOR(object_new(TYPE_SPAPR_DR_CONNECTOR));", "g_assert(type);", "drc->type = type;", "drc->id = id;", "drc->owner = owner;", "object_property_add_child(owner, \"dr-connector[*]\", OBJECT(drc), NULL);", "object_property_set_bool(OBJECT(drc), true, \"realized\", NULL);", "switch (drc->type) {", "case SPAPR_DR_CONNECTOR_TYPE_CPU:\ndrc->name = g_strdup_printf(\"CPU %d\", id);", "break;", "case SPAPR_DR_CONNECTOR_TYPE_PHB:\ndrc->name = g_strdup_printf(\"PHB %d\", id);", "break;", "case SPAPR_DR_CONNECTOR_TYPE_VIO:\ncase SPAPR_DR_CONNECTOR_TYPE_PCI:\ndrc->name = g_strdup_printf(\"C%d\", id);", "break;", "case SPAPR_DR_CONNECTOR_TYPE_LMB:\ndrc->name = g_strdup_printf(\"LMB %d\", id);", "break;", "default:\ng_assert(false);", "}", "if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) {", "drc->allocation_state = SPAPR_DR_ALLOCATION_STATE_USABLE;", "}", "return drc;", "}" ]

[ 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 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87, 89, 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101, 103 ], [ 105 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ] ]

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

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

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

[ "static char *FUNC_0(TCGContext *VAR_0, char *VAR_1,\nint VAR_2, int VAR_3)\n{", "assert(VAR_3 >= 0 && VAR_3 < VAR_0->nb_temps);", "return tcg_get_arg_str_ptr(VAR_0, VAR_1, VAR_2, &VAR_0->temps[VAR_3]);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static inline int FUNC_0(MpegEncContext *VAR_0){", "const int VAR_1= get_bits_count(&VAR_0->gb);", "if(VAR_0->workaround_bugs&FF_BUG_NO_PADDING){", "return 0;", "}", "if(VAR_1 + 8 >= VAR_0->gb.size*8){", "int VAR_2= show_bits(&VAR_0->gb, 8);", "VAR_2|= 0x7F >> (7-(VAR_1&7));", "if(VAR_2==0x7F)\nreturn 1;", "}else{", "if(show_bits(&VAR_0->gb, 16) == ff_mpeg4_resync_prefix[VAR_1&7]){", "int VAR_3;", "GetBitContext gb= VAR_0->gb;", "skip_bits(&VAR_0->gb, 1);", "align_get_bits(&VAR_0->gb);", "for(VAR_3=0; VAR_3<32; VAR_3++){", "if(get_bits1(&VAR_0->gb)) break;", "}", "VAR_0->gb= gb;", "if(VAR_3>=ff_mpeg4_get_video_packet_prefix_length(VAR_0))\nreturn 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 ]

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

[ "ssize_t FUNC_0(FsContext *ctx, const char *path,\nvoid *value, size_t vsize)\n{", "ssize_t size = 0;", "char *VAR_0;", "void *VAR_1 = value;", "XattrOperations *xops;", "char *VAR_2, *VAR_3;", "ssize_t xattr_len, parsed_len = 0, attr_len;", "VAR_0 = rpath(ctx, path);", "xattr_len = llistxattr(VAR_0, value, 0);", "if (xattr_len <= 0) {", "g_free(VAR_0);", "return xattr_len;", "}", "VAR_2 = g_malloc(xattr_len);", "xattr_len = llistxattr(VAR_0, VAR_2, xattr_len);", "g_free(VAR_0);", "VAR_3 = VAR_2;", "while (xattr_len > parsed_len) {", "xops = get_xattr_operations(ctx->xops, VAR_2);", "if (!xops) {", "goto next_entry;", "}", "if (!value) {", "size += xops->listxattr(ctx, path, VAR_2, value, vsize);", "} else {", "size = xops->listxattr(ctx, path, VAR_2, value, vsize);", "if (size < 0) {", "goto err_out;", "}", "value += size;", "vsize -= size;", "}", "next_entry:\nattr_len = strlen(VAR_2) + 1;", "parsed_len += attr_len;", "VAR_2 += attr_len;", "}", "if (value) {", "size = value - VAR_1;", "}", "err_out:\ng_free(VAR_3);", "return size;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103, 105 ], [ 107 ], [ 109 ] ]

[ "static int FUNC_0(ByteIOContext *VAR_0, MOVContext* VAR_1,\nAVFormatContext *VAR_2)\n{", "int VAR_5 = url_ftell(VAR_0);", "int VAR_4;", "put_be32(VAR_0, 0);", "put_tag(VAR_0, \"udta\");", "mov_write_meta_tag(VAR_0, VAR_1, VAR_2);", "for (VAR_4=0; VAR_4<MAX_STREAMS; VAR_4++) {", "if(VAR_1->tracks[VAR_4].entry <= 0) continue;", "if (VAR_1->tracks[VAR_4].enc->codec_id == CODEC_ID_AAC ||\nVAR_1->tracks[VAR_4].enc->codec_id == CODEC_ID_MPEG4) {", "int VAR_5 = url_ftell(VAR_0);", "put_be32(VAR_0, 0);", "put_tag(VAR_0, \"\\251req\");", "put_be16(VAR_0, sizeof(\"QuickTime 6.0 or greater\") - 1);", "put_be16(VAR_0, 0);", "put_buffer(VAR_0, \"QuickTime 6.0 or greater\",\nsizeof(\"QuickTime 6.0 or greater\") - 1);", "updateSize(VAR_0, VAR_5);", "break;", "}", "}", "if(!(VAR_1->tracks[0].enc->flags & CODEC_FLAG_BITEXACT))\n{", "int VAR_5 = url_ftell(VAR_0);", "put_be32(VAR_0, 0);", "put_tag(VAR_0, \"\\251enc\");", "put_be16(VAR_0, sizeof(LIBAVFORMAT_IDENT) - 1);", "put_be16(VAR_0, 0);", "put_buffer(VAR_0, LIBAVFORMAT_IDENT, sizeof(LIBAVFORMAT_IDENT) - 1);", "updateSize(VAR_0, VAR_5);", "}", "if( VAR_2->title[0] )\n{", "int VAR_5 = url_ftell(VAR_0);", "put_be32(VAR_0, 0);", "put_tag(VAR_0, \"\\251nam\");", "put_be16(VAR_0, strlen(VAR_2->title));", "put_be16(VAR_0, 0);", "put_buffer(VAR_0, VAR_2->title, strlen(VAR_2->title));", "updateSize(VAR_0, VAR_5);", "}", "if( VAR_2->author[0] )\n{", "int VAR_5 = url_ftell(VAR_0);", "put_be32(VAR_0, 0);", "put_tag(VAR_0, \"\\251day\" );", "put_be16(VAR_0, strlen(VAR_2->author));", "put_be16(VAR_0, 0);", "put_buffer(VAR_0, VAR_2->author, strlen(VAR_2->author));", "updateSize(VAR_0, VAR_5);", "}", "if( VAR_2->comment[0] )\n{", "int VAR_5 = url_ftell(VAR_0);", "put_be32(VAR_0, 0);", "put_tag(VAR_0, \"\\251des\");", "put_be16(VAR_0, strlen(VAR_2->comment));", "put_be16(VAR_0, 0);", "put_buffer(VAR_0, VAR_2->comment, strlen(VAR_2->comment));", "updateSize(VAR_0, VAR_5);", "}", "return updateSize(VAR_0, VAR_5);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{", "static const char VAR_3[8] = \"Shutdown\";", "static int VAR_4 = 0;", "switch(VAR_1) {", "case 0x400:\ncase 0x401:\nbreak;", "case 0x402:\ncase 0x403:\n#ifdef DEBUG_BIOS\nfprintf(stderr, \"%c\", VAR_2);", "#endif\nbreak;", "case 0x8900:\nif (VAR_2 == VAR_3[VAR_4]) {", "VAR_4++;", "if (VAR_4 == 8) {", "VAR_4 = 0;", "qemu_system_shutdown_request();", "}", "} else {", "VAR_4 = 0;", "}", "break;", "case 0x501:\ncase 0x502:\nfprintf(stderr, \"VGA BIOS panic, line %d\\n\", VAR_2);", "exit(1);", "case 0x500:\ncase 0x503:\n#ifdef DEBUG_BIOS\nfprintf(stderr, \"%c\", VAR_2);", "#endif\nbreak;", "}", "}" ]

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

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

[ "void FUNC_0(Error **VAR_0, Error *VAR_1)\n{", "if (VAR_0) {", "*VAR_0 = VAR_1;", "} else if (VAR_1) {", "error_free(VAR_1);", "}", "}" ]

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

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

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "MacIOState *s = MACIO(VAR_0);", "NewWorldMacIOState *ns = NEWWORLD_MACIO(VAR_0);", "SysBusDevice *sysbus_dev;", "MemoryRegion *timer_memory = g_new(MemoryRegion, 1);", "int VAR_1;", "int VAR_2 = 0;", "int VAR_3 = macio_common_initfn(VAR_0);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "sysbus_dev = SYS_BUS_DEVICE(&s->cuda);", "sysbus_connect_irq(sysbus_dev, 0, ns->irqs[VAR_2++]);", "if (s->pic_mem) {", "memory_region_add_subregion(&s->bar, 0x40000, s->pic_mem);", "}", "for (VAR_1 = 0; VAR_1 < ARRAY_SIZE(ns->ide); VAR_1++) {", "qemu_irq irq0 = ns->irqs[VAR_2++];", "qemu_irq irq1 = ns->irqs[VAR_2++];", "VAR_3 = macio_initfn_ide(s, &ns->ide[VAR_1], irq0, irq1, 0x16 + (VAR_1 * 4));", "if (VAR_3 < 0) {", "return VAR_3;", "}", "}", "memory_region_init_io(timer_memory, OBJECT(s), &timer_ops, NULL, \"timer\",\n0x1000);", "memory_region_add_subregion(&s->bar, 0x15000, timer_memory);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 67, 69 ], [ 71 ], [ 75 ], [ 77 ] ]

[ "static void FUNC_0(ram_addr_t VAR_0,\nconst char *VAR_1,\nOpenRISCCPU *VAR_2)\n{", "long VAR_3;", "uint64_t elf_entry;", "hwaddr entry;", "if (VAR_1 && !qtest_enabled()) {", "VAR_3 = load_elf(VAR_1, NULL, NULL,\n&elf_entry, NULL, NULL, 1, ELF_MACHINE, 1);", "entry = elf_entry;", "if (VAR_3 < 0) {", "VAR_3 = load_uimage(VAR_1,\n&entry, NULL, NULL);", "}", "if (VAR_3 < 0) {", "VAR_3 = load_image_targphys(VAR_1,\nKERNEL_LOAD_ADDR,\nVAR_0 - KERNEL_LOAD_ADDR);", "entry = KERNEL_LOAD_ADDR;", "}", "if (VAR_3 < 0) {", "fprintf(stderr, \"QEMU: couldn't load the kernel '%s'\\n\",\nVAR_1);", "exit(1);", "}", "}", "VAR_2->env.pc = entry;", "}" ]

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

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

[ "void FUNC_0(const char *VAR_0, bool VAR_1, bool VAR_2,\nbool VAR_3, bool VAR_4, bool VAR_5, bool VAR_6,\nError **VAR_7)\n{", "Error *local_err = NULL;", "MigrationState *s = migrate_get_current();", "MigrationParams params;", "const char *VAR_8;", "params.VAR_2 = VAR_1 && VAR_2;", "params.shared = VAR_3 && VAR_4;", "if (migration_is_setup_or_active(s->state) ||\ns->state == MIGRATION_STATUS_CANCELLING) {", "error_setg(VAR_7, QERR_MIGRATION_ACTIVE);", "return;", "}", "if (runstate_check(RUN_STATE_INMIGRATE)) {", "error_setg(VAR_7, \"Guest is waiting for an incoming migration\");", "return;", "}", "if (qemu_savevm_state_blocked(VAR_7)) {", "return;", "}", "if (migration_blockers) {", "*VAR_7 = error_copy(migration_blockers->data);", "return;", "}", "s = migrate_init(&params);", "if (strstart(VAR_0, \"tcp:\", &VAR_8)) {", "tcp_start_outgoing_migration(s, VAR_8, &local_err);", "#ifdef CONFIG_RDMA\n} else if (strstart(VAR_0, \"rdma:\", &VAR_8)) {", "rdma_start_outgoing_migration(s, VAR_8, &local_err);", "#endif\n#if !defined(WIN32)\n} else if (strstart(VAR_0, \"exec:\", &VAR_8)) {", "exec_start_outgoing_migration(s, VAR_8, &local_err);", "} else if (strstart(VAR_0, \"unix:\", &VAR_8)) {", "unix_start_outgoing_migration(s, VAR_8, &local_err);", "} else if (strstart(VAR_0, \"fd:\", &VAR_8)) {", "fd_start_outgoing_migration(s, VAR_8, &local_err);", "#endif\n} else {", "error_setg(VAR_7, QERR_INVALID_PARAMETER_VALUE, \"VAR_0\",\n\"a valid migration protocol\");", "migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,\nMIGRATION_STATUS_FAILED);", "return;", "}", "if (local_err) {", "migrate_fd_error(s);", "error_propagate(VAR_7, local_err);", "return;", "}", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 97, 99 ], [ 101, 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ] ]

[ "static void FUNC_0(const uint8_t *VAR_0,\nconst uint8_t *VAR_1,\nint32_t VAR_2,\nuint8_t *VAR_3,\nint32_t VAR_4)\n{", "uint32_t multiple8_cnt;", "for (multiple8_cnt = 2; multiple8_cnt--;) {", "avc_luma_hv_qrt_and_aver_dst_8x8_msa(VAR_0, VAR_1, VAR_2,\nVAR_3, VAR_4);", "VAR_0 += 8;", "VAR_1 += 8;", "VAR_3 += 8;", "}", "VAR_0 += (8 * VAR_2) - 16;", "VAR_1 += (8 * VAR_2) - 16;", "VAR_3 += (8 * VAR_4) - 16;", "for (multiple8_cnt = 2; multiple8_cnt--;) {", "avc_luma_hv_qrt_and_aver_dst_8x8_msa(VAR_0, VAR_1, VAR_2,\nVAR_3, VAR_4);", "VAR_0 += 8;", "VAR_1 += 8;", "VAR_3 += 8;", "}", "}" ]

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

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

[ "uint32_t FUNC_0(int len, uint8_t *buf)\n{", "uint32_t sum = 0;", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < len; VAR_0++) {", "if (VAR_0 & 1)\nsum += (uint32_t)buf[VAR_0];", "else\nsum += (uint32_t)buf[VAR_0] << 8;", "}", "return sum;", "}" ]

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

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

[ "static uint32_t FUNC_0(void *opaque, target_phys_addr_t addr)\n{", "HPETState *s = opaque;", "uint64_t cur_tick, index;", "DPRINTF(\"qemu: Enter FUNC_0 at %\" PRIx64 \"\\n\", addr);", "index = addr;", "if (index >= 0x100 && index <= 0x3ff) {", "uint8_t timer_id = (addr - 0x100) / 0x20;", "HPETTimer *timer = &s->timer[timer_id];", "if (timer_id > s->num_timers) {", "DPRINTF(\"qemu: timer id out of range\\n\");", "return 0;", "}", "switch ((addr - 0x100) % 0x20) {", "case HPET_TN_CFG:\nreturn timer->config;", "case HPET_TN_CFG + 4:\nreturn timer->config >> 32;", "case HPET_TN_CMP:\nreturn timer->cmp;", "case HPET_TN_CMP + 4:\nreturn timer->cmp >> 32;", "case HPET_TN_ROUTE:\nreturn timer->fsb;", "case HPET_TN_ROUTE + 4:\nreturn timer->fsb >> 32;", "default:\nDPRINTF(\"qemu: invalid FUNC_0\\n\");", "break;", "}", "} else {", "switch (index) {", "case HPET_ID:\nreturn s->capability;", "case HPET_PERIOD:\nreturn s->capability >> 32;", "case HPET_CFG:\nreturn s->config;", "case HPET_CFG + 4:\nDPRINTF(\"qemu: invalid HPET_CFG + 4 FUNC_0 \\n\");", "return 0;", "case HPET_COUNTER:\nif (hpet_enabled(s)) {", "cur_tick = hpet_get_ticks(s);", "} else {", "cur_tick = s->hpet_counter;", "}", "DPRINTF(\"qemu: reading counter = %\" PRIx64 \"\\n\", cur_tick);", "return cur_tick;", "case HPET_COUNTER + 4:\nif (hpet_enabled(s)) {", "cur_tick = hpet_get_ticks(s);", "} else {", "cur_tick = s->hpet_counter;", "}", "DPRINTF(\"qemu: reading counter + 4 = %\" PRIx64 \"\\n\", cur_tick);", "return cur_tick >> 32;", "case HPET_STATUS:\nreturn s->isr;", "default:\nDPRINTF(\"qemu: invalid FUNC_0\\n\");", "break;", "}", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, uint32_t VAR_2, uint32_t VAR_3)\n{", "target_ulong tmp_pc;", "tmp_pc = sign_extend((VAR_1<<2), 26) + VAR_0->pc;", "switch (VAR_3) {", "case 0x00:\ntcg_gen_movi_tl(jmp_pc, tmp_pc);", "break;", "case 0x01:\ntcg_gen_movi_tl(cpu_R[9], (VAR_0->pc + 8));", "tcg_gen_movi_tl(jmp_pc, tmp_pc);", "break;", "case 0x03:\ncase 0x04:\n{", "int VAR_4 = gen_new_label();", "TCGv sr_f = tcg_temp_new();", "tcg_gen_movi_tl(jmp_pc, VAR_0->pc+8);", "tcg_gen_andi_tl(sr_f, cpu_sr, SR_F);", "tcg_gen_brcondi_i32(VAR_3 == 0x03 ? TCG_COND_EQ : TCG_COND_NE,\nsr_f, SR_F, VAR_4);", "tcg_gen_movi_tl(jmp_pc, tmp_pc);", "gen_set_label(VAR_4);", "tcg_temp_free(sr_f);", "}", "break;", "case 0x11:\ntcg_gen_mov_tl(jmp_pc, cpu_R[VAR_2]);", "break;", "case 0x12:\ntcg_gen_movi_tl(cpu_R[9], (VAR_0->pc + 8));", "tcg_gen_mov_tl(jmp_pc, cpu_R[VAR_2]);", "break;", "default:\ngen_illegal_exception(VAR_0);", "break;", "}", "VAR_0->delayed_branch = 2;", "VAR_0->tb_flags |= D_FLAG;", "gen_sync_flags(VAR_0);", "}" ]

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

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

[ "static int FUNC_0(const NetClientOptions *VAR_0, const char *VAR_1,\nNetClientState *VAR_2, Error **VAR_3)\n{", "int VAR_4;", "NICInfo *nd;", "const NetLegacyNicOptions *VAR_5;", "assert(VAR_0->type == NET_CLIENT_OPTIONS_KIND_NIC);", "VAR_5 = VAR_0->u.VAR_5;", "VAR_4 = nic_get_free_idx();", "if (VAR_4 == -1 || nb_nics >= MAX_NICS) {", "error_setg(VAR_3, \"too many NICs\");", "return -1;", "}", "nd = &nd_table[VAR_4];", "memset(nd, 0, sizeof(*nd));", "if (VAR_5->has_netdev) {", "nd->netdev = qemu_find_netdev(VAR_5->netdev);", "if (!nd->netdev) {", "error_setg(VAR_3, \"netdev '%s' not found\", VAR_5->netdev);", "return -1;", "}", "} else {", "assert(VAR_2);", "nd->netdev = VAR_2;", "}", "nd->VAR_1 = g_strdup(VAR_1);", "if (VAR_5->has_model) {", "nd->model = g_strdup(VAR_5->model);", "}", "if (VAR_5->has_addr) {", "nd->devaddr = g_strdup(VAR_5->addr);", "}", "if (VAR_5->has_macaddr &&\nnet_parse_macaddr(nd->macaddr.a, VAR_5->macaddr) < 0) {", "error_setg(VAR_3, \"invalid syntax for ethernet address\");", "return -1;", "}", "if (VAR_5->has_macaddr &&\nis_multicast_ether_addr(nd->macaddr.a)) {", "error_setg(VAR_3,\n\"NIC cannot have multicast MAC address (odd 1st byte)\");", "return -1;", "}", "qemu_macaddr_default_if_unset(&nd->macaddr);", "if (VAR_5->has_vectors) {", "if (VAR_5->vectors > 0x7ffffff) {", "error_setg(VAR_3, \"invalid # of vectors: %\"PRIu32, VAR_5->vectors);", "return -1;", "}", "nd->nvectors = VAR_5->vectors;", "} else {", "nd->nvectors = DEV_NVECTORS_UNSPECIFIED;", "}", "nd->used = 1;", "nb_nics++;", "return VAR_4;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1,\nconst uint8_t *VAR_2, int VAR_3)\n{", "GetByteContext gb;", "GetBitContext gb2;", "int VAR_4, VAR_5, VAR_6, VAR_7;", "int VAR_8, VAR_9;", "uint32_t off, slice_size;", "uint8_t *Y, *U, *V;", "int VAR_10;", "bytestream2_init(&gb, VAR_2, VAR_3);", "VAR_4 = bytestream2_get_le16(&gb);", "off = FFALIGN(VAR_4 * 4 + 2, 16);", "if (VAR_3 < off) {", "av_log(VAR_0, AV_LOG_ERROR, \"no VAR_5 data\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (!VAR_4 || VAR_0->height % VAR_4) {", "avpriv_request_sample(VAR_0, \"%d slices for %dx%d\", VAR_4,\nVAR_0->width, VAR_0->height);", "return AVERROR_PATCHWELCOME;", "}", "VAR_7 = VAR_0->height / VAR_4;", "if ((VAR_0->width & 3) || (VAR_0->height & 3)) {", "avpriv_request_sample(VAR_0, \"Frame dimensions %dx%d\",\nVAR_0->width, VAR_0->height);", "}", "VAR_0->pix_fmt = AV_PIX_FMT_YUV410P;", "if ((VAR_10 = ff_get_buffer(VAR_0, VAR_1, 0)) < 0)\nreturn VAR_10;", "Y = VAR_1->data[0];", "U = VAR_1->data[1];", "V = VAR_1->data[2];", "VAR_8 = 0;", "VAR_9 = VAR_7;", "for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {", "slice_size = bytestream2_get_le32(&gb);", "VAR_6 = (VAR_9 & ~3) - (VAR_8 & ~3);", "if (slice_size > VAR_3 - off) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"invalid VAR_5 size %\"PRIu32\" (only %\"PRIu32\" bytes left)\\n\",\nslice_size, VAR_3 - off);", "return AVERROR_INVALIDDATA;", "}", "if (slice_size <= 16) {", "av_log(VAR_0, AV_LOG_ERROR, \"invalid VAR_5 size %\"PRIu32\"\\n\", slice_size);", "return AVERROR_INVALIDDATA;", "}", "if (AV_RL32(VAR_2 + off) != slice_size - 16) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Slice sizes mismatch: got %\"PRIu32\" instead of %\"PRIu32\"\\n\",\nAV_RL32(VAR_2 + off), slice_size - 16);", "}", "init_get_bits(&gb2, VAR_2 + off + 16, (slice_size - 16) * 8);", "dx2_decode_slice_410(&gb2, VAR_0->width, VAR_6, Y, U, V,\nVAR_1->linesize[0], VAR_1->linesize[1],\nVAR_1->linesize[2]);", "Y += VAR_1->linesize[0] * VAR_6;", "U += VAR_1->linesize[1] * (VAR_6 >> 2);", "V += VAR_1->linesize[2] * (VAR_6 >> 2);", "off += slice_size;", "VAR_8 = VAR_9;", "VAR_9 += VAR_7;", "}", "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, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 63 ], [ 65, 67 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91, 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113, 115, 117 ], [ 119 ], [ 121 ], [ 123, 125, 127 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ] ]

[ "int FUNC_0(KVMState *VAR_0, int VAR_1, MSIMessage VAR_2)\n{", "struct kvm_irq_routing_entry VAR_3;", "if (!kvm_irqchip_in_kernel()) {", "return -ENOSYS;", "}", "VAR_3.gsi = VAR_1;", "VAR_3.type = KVM_IRQ_ROUTING_MSI;", "VAR_3.flags = 0;", "VAR_3.u.msi.address_lo = (uint32_t)VAR_2.address;", "VAR_3.u.msi.address_hi = VAR_2.address >> 32;", "VAR_3.u.msi.data = VAR_2.data;", "return kvm_update_routing_entry(VAR_0, &VAR_3);", "}" ]

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

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

[ "type_init(pflash_cfi01_register_types)\npflash_t *pflash_cfi01_register(hwaddr base,\nDeviceState *qdev, const char *name,\nhwaddr size,\nBlockDriverState *bs,\nuint32_t sector_len, int nb_blocs,\nint bank_width, uint16_t id0, uint16_t id1,\nuint16_t id2, uint16_t id3, int be)\n{", "DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH01);", "if (bs && qdev_prop_set_drive(dev, \"drive\", bs)) {", "abort();", "}", "qdev_prop_set_uint32(dev, \"num-blocks\", nb_blocs);", "qdev_prop_set_uint64(dev, \"sector-length\", sector_len);", "qdev_prop_set_uint8(dev, \"width\", bank_width);", "qdev_prop_set_uint8(dev, \"big-endian\", !!be);", "qdev_prop_set_uint16(dev, \"id0\", id0);", "qdev_prop_set_uint16(dev, \"id1\", id1);", "qdev_prop_set_uint16(dev, \"id2\", id2);", "qdev_prop_set_uint16(dev, \"id3\", id3);", "qdev_prop_set_string(dev, \"name\", name);", "qdev_init_nofail(dev);", "sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);", "return CFI_PFLASH01(dev);", "}" ]

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

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

[ "static void FUNC_0(VncState *VAR_0, uint16_t VAR_1)\n{", "uint8_t buf[2];", "buf[0] = (VAR_1 >> 8) & 0xFF;", "buf[1] = VAR_1 & 0xFF;", "vnc_write(VAR_0, buf, 2);", "}" ]

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

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

[ "FUNC_0(VAR_0)\nstatic void assigned_dev_load_option_rom(AssignedDevice *dev)\n{", "int VAR_1 = 0;", "pci_assign_dev_load_option_rom(&dev->dev, OBJECT(dev), &VAR_1,\ndev->host.domain, dev->host.bus,\ndev->host.slot, dev->host.function);", "if (!VAR_1) {", "error_report(\"pci-assign: Invalid ROM.\");", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "TrimAIOCB *iocb = VAR_0;", "if (VAR_1 >= 0) {", "while (iocb->VAR_2 < iocb->qiov->niov) {", "int VAR_2 = iocb->VAR_2;", "while (++iocb->VAR_3 < iocb->qiov->iov[VAR_2].iov_len / 8) {", "int VAR_3 = iocb->VAR_3;", "uint64_t *buffer = iocb->qiov->iov[VAR_2].iov_base;", "uint64_t entry = le64_to_cpu(buffer[VAR_3]);", "uint64_t sector = entry & 0x0000ffffffffffffULL;", "uint16_t count = entry >> 48;", "if (count == 0) {", "continue;", "}", "iocb->aiocb = blk_aio_pdiscard(iocb->blk,\nsector << BDRV_SECTOR_BITS,\ncount << BDRV_SECTOR_BITS,\nFUNC_0, VAR_0);", "return;", "}", "iocb->VAR_2++;", "iocb->VAR_3 = -1;", "}", "} else {", "iocb->VAR_1 = VAR_1;", "}", "iocb->aiocb = NULL;", "if (iocb->bh) {", "qemu_bh_schedule(iocb->bh);", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "USBRedirDevice *dev = VAR_0;", "int VAR_1;", "qemu_del_timer(dev->attach_timer);", "if (dev->dev.attached) {", "usb_device_detach(&dev->dev);", "dev->next_attach_time = qemu_get_clock_ms(vm_clock) + 200;", "}", "usbredir_cleanup_device_queues(dev);", "memset(dev->endpoint, 0, sizeof(dev->endpoint));", "for (VAR_1 = 0; VAR_1 < MAX_ENDPOINTS; VAR_1++) {", "QTAILQ_INIT(&dev->endpoint[VAR_1].bufpq);", "}", "usb_ep_init(&dev->dev);", "dev->interface_info.interface_count = 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13 ], [ 17 ], [ 19 ], [ 29 ], [ 31 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ] ]

[ "static void FUNC_0(PCIDevice *VAR_0,\nuint32_t VAR_1, uint32_t VAR_2, int VAR_3)\n{", "DPRINTF(\"FUNC_0 VAR_1 0x%x VAR_2 0x%x VAR_3 0x%x \\n\",\nVAR_1, VAR_2, VAR_3);", "pci_default_write_config(VAR_0, VAR_1, VAR_2, VAR_3);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(MpegEncContext *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3;", "VAR_3= get_bits(&VAR_0->gb, 2);", "switch(VAR_3){", "case 0: VAR_0->pict_type= I_TYPE; break;", "case 1: VAR_0->pict_type= I_TYPE; break;", "case 2: VAR_0->pict_type= P_TYPE; break;", "case 3: VAR_0->pict_type= B_TYPE; break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"unknown frame type\\n\");", "return -1;", "}", "if (get_bits(&VAR_0->gb, 1)){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"unknown bit set\\n\");", "return -1;", "}", "VAR_0->qscale = get_bits(&VAR_0->gb, 5);", "if(VAR_0->qscale==0){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"error, qscale:0\\n\");", "return -1;", "}", "if(VAR_0->avctx->sub_id == 0x20200002)\nVAR_1= get_bits(&VAR_0->gb, 16);", "else\nVAR_1= get_bits(&VAR_0->gb, 8);", "for(VAR_3=0; VAR_3<6; VAR_3++){", "if(VAR_0->mb_width*VAR_0->mb_height < ff_mba_max[VAR_3]) break;", "}", "VAR_2= get_bits(&VAR_0->gb, ff_mba_length[VAR_3]);", "VAR_0->mb_x= VAR_2 % VAR_0->mb_width;", "VAR_0->mb_y= VAR_2 / VAR_0->mb_width;", "VAR_0->no_rounding= get_bits1(&VAR_0->gb);", "VAR_0->f_code = 1;", "VAR_0->unrestricted_mv = 1;", "VAR_0->h263_aic= VAR_0->pict_type == I_TYPE;", "if(VAR_0->avctx->debug & FF_DEBUG_PICT_INFO){", "av_log(VAR_0->avctx, AV_LOG_INFO, \"num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\\n\",\nVAR_1, VAR_0->mb_x, VAR_0->mb_y, VAR_0->pict_type, VAR_0->qscale, VAR_0->no_rounding);", "}", "if (VAR_0->pict_type == B_TYPE){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"b frame not supported\\n\");", "return -1;", "}", "return VAR_0->mb_width*VAR_0->mb_height - VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53, 55 ], [ 57, 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ] ]

[ "static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "Visitor *v;", "Error *err = NULL;", "UserDefFlatUnion *tmp;", "UserDefUnionBase *base;", "v = visitor_input_test_init(VAR_0,\n\"{ 'enum1': 'value1', \"", "\"'integer': 41, \"\n\"'string': 'str', \"\n\"'boolean': true }\");", "visit_type_UserDefFlatUnion(v, &tmp, NULL, &err);", "g_assert(err == NULL);", "g_assert_cmpint(tmp->enum1, ==, ENUM_ONE_VALUE1);", "g_assert_cmpstr(tmp->string, ==, \"str\");", "g_assert_cmpint(tmp->integer, ==, 41);", "g_assert_cmpint(tmp->u.value1->boolean, ==, true);", "base = qapi_UserDefFlatUnion_base(tmp);", "g_assert(&base->enum1 == &tmp->enum1);", "qapi_free_UserDefFlatUnion(tmp);", "}" ]

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

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

[ "static void FUNC_0(HotplugHandler *VAR_0,\nDeviceState *VAR_1, Error **VAR_2)\n{", "PCIDevice *pci_dev = NULL;", "PCIBus *bus;", "int32_t devfn;", "S390PCIBusDevice *pbdev = NULL;", "S390pciState *s = s390_get_phb();", "if (object_dynamic_cast(OBJECT(VAR_1), TYPE_PCI_BRIDGE)) {", "error_setg(VAR_2, \"PCI bridge hot unplug currently not supported\");", "return;", "} else if (object_dynamic_cast(OBJECT(VAR_1), TYPE_PCI_DEVICE)) {", "pci_dev = PCI_DEVICE(VAR_1);", "QTAILQ_FOREACH(pbdev, &s->zpci_devs, link) {", "if (pbdev->pdev == pci_dev) {", "break;", "}", "}", "assert(pbdev != NULL);", "} else if (object_dynamic_cast(OBJECT(VAR_1), TYPE_S390_PCI_DEVICE)) {", "pbdev = S390_PCI_DEVICE(VAR_1);", "pci_dev = pbdev->pdev;", "}", "switch (pbdev->state) {", "case ZPCI_FS_RESERVED:\ngoto out;", "case ZPCI_FS_STANDBY:\nbreak;", "default:\ns390_pci_generate_plug_event(HP_EVENT_DECONFIGURE_REQUEST,\npbdev->fh, pbdev->fid);", "pbdev->release_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,\ns390_pcihost_timer_cb,\npbdev);", "timer_mod(pbdev->release_timer,\nqemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + HOT_UNPLUG_TIMEOUT);", "return;", "}", "if (pbdev->release_timer && timer_pending(pbdev->release_timer)) {", "timer_del(pbdev->release_timer);", "timer_free(pbdev->release_timer);", "pbdev->release_timer = NULL;", "}", "s390_pci_generate_plug_event(HP_EVENT_STANDBY_TO_RESERVED,\npbdev->fh, pbdev->fid);", "bus = pci_dev->bus;", "devfn = pci_dev->devfn;", "object_unparent(OBJECT(pci_dev));", "s390_pci_msix_free(pbdev);", "s390_pci_iommu_free(s, bus, devfn);", "pbdev->pdev = NULL;", "pbdev->state = ZPCI_FS_RESERVED;", "out:\npbdev->fid = 0;", "QTAILQ_REMOVE(&s->zpci_devs, pbdev, link);", "g_hash_table_remove(s->zpci_table, &pbdev->idx);", "object_unparent(OBJECT(pbdev));", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nconst uint8_t *VAR_1, int VAR_2,\nint64_t VAR_3)\n{", "PGSSubContext *ctx = VAR_0->priv_data;", "int VAR_4, VAR_5, VAR_6;", "int VAR_7 = bytestream_get_be16(&VAR_1);", "int VAR_8 = bytestream_get_be16(&VAR_1);", "uint16_t object_index;", "ctx->presentation.VAR_3 = VAR_3;", "av_dlog(VAR_0, \"Video Dimensions %dx%d\\n\",\nVAR_7, VAR_8);", "VAR_6 = ff_set_dimensions(VAR_0, VAR_7, VAR_8);", "if (VAR_6 < 0)\nreturn VAR_6;", "VAR_1++;", "ctx->presentation.id_number = bytestream_get_be16(&VAR_1);", "VAR_5 = bytestream_get_byte(&VAR_1) >> 6;", "if (VAR_5 != 0) {", "flush_cache(VAR_0);", "}", "VAR_1 += 1;", "ctx->presentation.palette_id = bytestream_get_byte(&VAR_1);", "ctx->presentation.object_count = bytestream_get_byte(&VAR_1);", "if (ctx->presentation.object_count > MAX_OBJECT_REFS) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Invalid number of presentation objects %d\\n\",\nctx->presentation.object_count);", "ctx->presentation.object_count = 2;", "if (VAR_0->err_recognition & AV_EF_EXPLODE) {", "return AVERROR_INVALIDDATA;", "}", "}", "for (VAR_4 = 0; VAR_4 < ctx->presentation.object_count; VAR_4++)", "{", "if (buf_end - VAR_1 < 8) {", "av_log(VAR_0, AV_LOG_ERROR, \"Insufficent space for object\\n\");", "ctx->presentation.object_count = VAR_4;", "return AVERROR_INVALIDDATA;", "}", "ctx->presentation.objects[VAR_4].id = bytestream_get_be16(&VAR_1);", "ctx->presentation.objects[VAR_4].window_id = bytestream_get_byte(&VAR_1);", "ctx->presentation.objects[VAR_4].composition_flag = bytestream_get_byte(&VAR_1);", "ctx->presentation.objects[VAR_4].x = bytestream_get_be16(&VAR_1);", "ctx->presentation.objects[VAR_4].y = bytestream_get_be16(&VAR_1);", "if (ctx->presentation.objects[VAR_4].composition_flag & 0x80) {", "ctx->presentation.objects[VAR_4].crop_x = bytestream_get_be16(&VAR_1);", "ctx->presentation.objects[VAR_4].crop_y = bytestream_get_be16(&VAR_1);", "ctx->presentation.objects[VAR_4].crop_w = bytestream_get_be16(&VAR_1);", "ctx->presentation.objects[VAR_4].crop_h = bytestream_get_be16(&VAR_1);", "}", "av_dlog(VAR_0, \"Subtitle Placement x=%d, y=%d\\n\",\nctx->presentation.objects[VAR_4].x, ctx->presentation.objects[VAR_4].y);", "if (ctx->presentation.objects[VAR_4].x > VAR_0->width ||\nctx->presentation.objects[VAR_4].y > VAR_0->height) {", "av_log(VAR_0, AV_LOG_ERROR, \"Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\\n\",\nctx->presentation.objects[VAR_4].x,\nctx->presentation.objects[VAR_4].y,\nVAR_0->width, VAR_0->height);", "ctx->presentation.objects[VAR_4].x = 0;", "ctx->presentation.objects[VAR_4].y = 0;", "if (VAR_0->err_recognition & AV_EF_EXPLODE) {", "return AVERROR_INVALIDDATA;", "}", "}", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 18 ], [ 20 ], [ 24 ], [ 28 ], [ 32, 34 ], [ 36 ], [ 38, 40 ], [ 46 ], [ 52 ], [ 72 ], [ 74 ], [ 76 ], [ 78 ], [ 88 ], [ 90 ], [ 92 ], [ 94 ], [ 96, 98, 100 ], [ 102 ], [ 104 ], [ 106 ], [ 108 ], [ 110 ], [ 116 ], [ 118 ], [ 122 ], [ 124 ], [ 126 ], [ 128 ], [ 130 ], [ 134 ], [ 136 ], [ 138 ], [ 142 ], [ 144 ], [ 150 ], [ 152 ], [ 154 ], [ 156 ], [ 158 ], [ 160 ], [ 164, 166 ], [ 170, 172 ], [ 174, 176, 178, 180 ], [ 182 ], [ 184 ], [ 186 ], [ 188 ], [ 190 ], [ 192 ], [ 194 ], [ 198 ], [ 200 ] ]

[ "static int FUNC_0(URLContext *VAR_0)\n{", "CryptoContext *c = VAR_0->priv_data;", "if (c->hd)\nffurl_close(c->hd);", "av_freep(&c->aes);", "av_freep(&c->key);", "av_freep(&c->iv);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "int VAR_6 = VAR_5 - MIMIC_HEADER_SIZE;", "MimicContext *ctx = VAR_0->priv_data;", "GetByteContext gb;", "int VAR_7;", "int VAR_8, VAR_9;", "int VAR_10, VAR_11;", "int VAR_12;", "if (VAR_5 <= MIMIC_HEADER_SIZE) {", "av_log(VAR_0, AV_LOG_ERROR, \"insufficient VAR_1\\n\");", "return AVERROR_INVALIDDATA;", "}", "bytestream2_init(&gb, VAR_4, MIMIC_HEADER_SIZE);", "bytestream2_skip(&gb, 2);", "VAR_10 = bytestream2_get_le16u(&gb);", "VAR_8 = bytestream2_get_le16u(&gb);", "VAR_9 = bytestream2_get_le16u(&gb);", "bytestream2_skip(&gb, 4);", "VAR_7 = bytestream2_get_le32u(&gb);", "VAR_11 = bytestream2_get_byteu(&gb);", "bytestream2_skip(&gb, 3);", "if (!ctx->VAR_0) {", "int VAR_13;", "if (!(VAR_8 == 160 && VAR_9 == 120) &&\n!(VAR_8 == 320 && VAR_9 == 240)) {", "av_log(VAR_0, AV_LOG_ERROR, \"invalid VAR_8/VAR_9!\\n\");", "return AVERROR_INVALIDDATA;", "}", "ctx->VAR_0 = VAR_0;", "VAR_0->VAR_8 = VAR_8;", "VAR_0->VAR_9 = VAR_9;", "VAR_0->pix_fmt = AV_PIX_FMT_YUV420P;", "for (VAR_13 = 0; VAR_13 < 3; VAR_13++) {", "ctx->num_vblocks[VAR_13] = AV_CEIL_RSHIFT(VAR_9, 3 + !!VAR_13);", "ctx->num_hblocks[VAR_13] = VAR_8 >> (3 + !!VAR_13);", "}", "} else if (VAR_8 != ctx->VAR_0->VAR_8 || VAR_9 != ctx->VAR_0->VAR_9) {", "avpriv_request_sample(VAR_0, \"Resolution changing\");", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_7 && !ctx->frames[ctx->prev_index].f->VAR_1[0]) {", "av_log(VAR_0, AV_LOG_ERROR, \"decoding must start with keyframe\\n\");", "return AVERROR_INVALIDDATA;", "}", "ff_thread_release_buffer(VAR_0, &ctx->frames[ctx->cur_index]);", "ctx->frames[ctx->cur_index].f->pict_type = VAR_7 ? AV_PICTURE_TYPE_P :\nAV_PICTURE_TYPE_I;", "if ((VAR_12 = ff_thread_get_buffer(VAR_0, &ctx->frames[ctx->cur_index],\nAV_GET_BUFFER_FLAG_REF)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return VAR_12;", "}", "ctx->next_prev_index = ctx->cur_index;", "ctx->next_cur_index = (ctx->cur_index - 1) & 15;", "ff_thread_finish_setup(VAR_0);", "av_fast_padded_malloc(&ctx->swap_buf, &ctx->VAR_6, VAR_6);", "if (!ctx->swap_buf)\nreturn AVERROR(ENOMEM);", "ctx->bbdsp.bswap_buf(ctx->swap_buf,\n(const uint32_t *) (VAR_4 + MIMIC_HEADER_SIZE),\nVAR_6 >> 2);", "init_get_bits(&ctx->gb, ctx->swap_buf, VAR_6 << 3);", "VAR_12 = decode(ctx, VAR_10, VAR_11, !VAR_7);", "ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);", "if (VAR_12 < 0) {", "if (!(VAR_0->active_thread_type & FF_THREAD_FRAME))\nff_thread_release_buffer(VAR_0, &ctx->frames[ctx->cur_index]);", "return VAR_12;", "}", "if ((VAR_12 = av_frame_ref(VAR_1, ctx->frames[ctx->cur_index].f)) < 0)\nreturn VAR_12;", "*VAR_2 = 1;", "flip_swap_frame(VAR_1);", "ctx->prev_index = ctx->next_prev_index;", "ctx->cur_index = ctx->next_cur_index;", "ff_thread_release_buffer(VAR_0, &ctx->frames[ctx->cur_index]);", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113, 115 ], [ 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 135 ], [ 139 ], [ 141, 143 ], [ 147, 149, 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163, 165 ], [ 167 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 181 ], [ 185 ], [ 187 ], [ 193 ], [ 197 ], [ 199 ] ]

[ "static void FUNC_0(void)\n{", "const char *VAR_0;", "QemuUUID measured;", "VAR_0 = \"-machine accel=tcg -device vmgenid,id=testvgid,\" \"guid=auto\";", "qtest_start(VAR_0);", "read_guid_from_memory(&measured);", "g_assert(!qemu_uuid_is_null(&measured));", "qtest_quit(global_qtest);", "}" ]

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

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

[ "static TCGv FUNC_0(CPUM68KState *env, DisasContext *s, TCGv base)\n{", "uint32_t offset;", "uint16_t ext;", "TCGv add;", "TCGv tmp;", "uint32_t bd, od;", "offset = s->pc;", "ext = cpu_lduw_code(env, s->pc);", "s->pc += 2;", "if ((ext & 0x800) == 0 && !m68k_feature(s->env, M68K_FEATURE_WORD_INDEX))\nreturn NULL_QREG;", "if (ext & 0x100) {", "if (!m68k_feature(s->env, M68K_FEATURE_EXT_FULL))\nreturn NULL_QREG;", "if ((ext & 0x30) > 0x10) {", "if ((ext & 0x30) == 0x20) {", "bd = (int16_t)cpu_lduw_code(env, s->pc);", "s->pc += 2;", "} else {", "bd = read_im32(env, s);", "} else {", "bd = 0;", "tmp = tcg_temp_new();", "if ((ext & 0x44) == 0) {", "add = gen_addr_index(ext, tmp);", "} else {", "add = NULL_QREG;", "if ((ext & 0x80) == 0) {", "if (IS_NULL_QREG(base)) {", "base = tcg_const_i32(offset + bd);", "bd = 0;", "if (!IS_NULL_QREG(add)) {", "tcg_gen_add_i32(tmp, add, base);", "add = tmp;", "} else {", "add = base;", "if (!IS_NULL_QREG(add)) {", "if (bd != 0) {", "tcg_gen_addi_i32(tmp, add, bd);", "add = tmp;", "} else {", "add = tcg_const_i32(bd);", "if ((ext & 3) != 0) {", "base = gen_load(s, OS_LONG, add, 0);", "if ((ext & 0x44) == 4) {", "add = gen_addr_index(ext, tmp);", "tcg_gen_add_i32(tmp, add, base);", "add = tmp;", "} else {", "add = base;", "if ((ext & 3) > 1) {", "if ((ext & 3) == 2) {", "od = (int16_t)cpu_lduw_code(env, s->pc);", "s->pc += 2;", "} else {", "od = read_im32(env, s);", "} else {", "od = 0;", "if (od != 0) {", "tcg_gen_addi_i32(tmp, add, od);", "add = tmp;", "} else {", "tmp = tcg_temp_new();", "add = gen_addr_index(ext, tmp);", "if (!IS_NULL_QREG(base)) {", "tcg_gen_add_i32(tmp, add, base);", "if ((int8_t)ext)\ntcg_gen_addi_i32(tmp, tmp, (int8_t)ext);", "} else {", "tcg_gen_addi_i32(tmp, add, offset + (int8_t)ext);", "add = tmp;", "return add;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 15, 16 ], [ 17 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 34 ], [ 35 ], [ 36 ], [ 37 ], [ 38 ], [ 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 50 ], [ 51 ], [ 52 ], [ 53 ], [ 54 ], [ 55 ], [ 56 ], [ 57 ], [ 59 ], [ 60 ], [ 61 ], [ 62 ], [ 63 ], [ 64 ], [ 65 ], [ 66 ], [ 67 ], [ 68 ], [ 69 ], [ 71 ], [ 72 ], [ 73 ], [ 74 ], [ 75, 76 ], [ 77 ], [ 78 ], [ 79 ], [ 80 ] ]

[ "int FUNC_0(SwrContext *VAR_0,\nAVFrame *VAR_1, const AVFrame *VAR_2)\n{", "int VAR_3, VAR_4 = 0;", "if (!swr_is_initialized(VAR_0)) {", "if ((VAR_3 = swr_config_frame(VAR_0, VAR_1, VAR_2)) < 0)\nreturn VAR_3;", "if ((VAR_3 = swr_init(VAR_0)) < 0)\nreturn VAR_3;", "VAR_4 = 1;", "} else {", "if ((VAR_3 = config_changed(VAR_0, VAR_1, VAR_2)))\nreturn VAR_3;", "}", "if (VAR_1) {", "if (!VAR_1->linesize[0]) {", "VAR_1->nb_samples = swr_get_delay(VAR_0, VAR_0->out_sample_rate)\n+ VAR_2->nb_samples*(int64_t)VAR_0->out_sample_rate / VAR_0->in_sample_rate\n+ 3;", "if ((VAR_3 = av_frame_get_buffer(VAR_1, 0)) < 0) {", "if (VAR_4)\nswr_close(VAR_0);", "return VAR_3;", "}", "} else {", "if (!VAR_1->nb_samples)\nVAR_1->nb_samples = available_samples(VAR_1);", "}", "}", "return convert_frame(VAR_0, VAR_1, VAR_2);", "}" ]

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

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

[ "av_cold static int FUNC_0(AVFormatContext *avctx,\nAVFormatParameters *ap)\n{", "FBDevContext *fbdev = avctx->priv_data;", "AVStream *st = NULL;", "enum PixelFormat VAR_0;", "int VAR_1, VAR_2 = O_RDONLY;", "VAR_1 = av_parse_video_rate(&fbdev->framerate_q, fbdev->framerate);", "if (VAR_1 < 0) {", "av_log(avctx, AV_LOG_ERROR, \"Couldn't parse framerate.\\n\");", "return VAR_1;", "}", "#if FF_API_FORMAT_PARAMETERS\nif (ap->time_base.num)\nfbdev->framerate_q = (AVRational){ap->time_base.den, ap->time_base.num};", "#endif\nif (!(st = av_new_stream(avctx, 0)))\nreturn AVERROR(ENOMEM);", "av_set_pts_info(st, 64, 1, 1000000);", "if (avctx->VAR_2 & AVFMT_FLAG_NONBLOCK)\nVAR_2 |= O_NONBLOCK;", "if ((fbdev->fd = open(avctx->filename, VAR_2)) == -1) {", "VAR_1 = AVERROR(errno);", "av_log(avctx, AV_LOG_ERROR,\n\"Could not open framebuffer device '%s': %s\\n\",\navctx->filename, strerror(VAR_1));", "return VAR_1;", "}", "if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {", "VAR_1 = AVERROR(errno);", "av_log(avctx, AV_LOG_ERROR,\n\"FBIOGET_VSCREENINFO: %s\\n\", strerror(errno));", "goto fail;", "}", "if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {", "VAR_1 = AVERROR(errno);", "av_log(avctx, AV_LOG_ERROR,\n\"FBIOGET_FSCREENINFO: %s\\n\", strerror(errno));", "goto fail;", "}", "VAR_0 = get_pixfmt_from_fb_varinfo(&fbdev->varinfo);", "if (VAR_0 == PIX_FMT_NONE) {", "VAR_1 = AVERROR(EINVAL);", "av_log(avctx, AV_LOG_ERROR,\n\"Framebuffer pixel format not supported.\\n\");", "goto fail;", "}", "fbdev->width = fbdev->varinfo.xres;", "fbdev->heigth = fbdev->varinfo.yres;", "fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;", "fbdev->frame_linesize = fbdev->width * fbdev->bytes_per_pixel;", "fbdev->frame_size = fbdev->frame_linesize * fbdev->heigth;", "fbdev->time_frame = AV_NOPTS_VALUE;", "fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);", "if (fbdev->data == MAP_FAILED) {", "VAR_1 = AVERROR(errno);", "av_log(avctx, AV_LOG_ERROR, \"Error in mmap(): %s\\n\", strerror(errno));", "goto fail;", "}", "st->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "st->codec->codec_id = CODEC_ID_RAWVIDEO;", "st->codec->width = fbdev->width;", "st->codec->height = fbdev->heigth;", "st->codec->VAR_0 = VAR_0;", "st->codec->time_base = (AVRational){fbdev->framerate_q.den, fbdev->framerate_q.num};", "st->codec->bit_rate =\nfbdev->width * fbdev->heigth * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;", "av_log(avctx, AV_LOG_INFO,\n\"w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\\n\",\nfbdev->width, fbdev->heigth, fbdev->varinfo.bits_per_pixel,\nav_pix_fmt_descriptors[VAR_0].name,\nfbdev->framerate_q.num, fbdev->framerate_q.den,\nst->codec->bit_rate);", "return 0;", "fail:\nclose(fbdev->fd);", "return VAR_1;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27, 29, 31 ], [ 33, 37, 39 ], [ 41 ], [ 47, 49 ], [ 53 ], [ 55 ], [ 57, 59, 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 157, 159, 161, 163, 165, 167 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 179 ] ]

[ "static abi_long FUNC_0(struct nlmsghdr *nlh)\n{", "struct ifinfomsg *VAR_0;", "struct ifaddrmsg *VAR_1;", "struct rtmsg *VAR_2;", "switch (nlh->nlmsg_type) {", "case RTM_GETLINK:\nbreak;", "case RTM_NEWLINK:\ncase RTM_DELLINK:\nVAR_0 = NLMSG_DATA(nlh);", "VAR_0->ifi_type = tswap16(VAR_0->ifi_type);", "VAR_0->ifi_index = tswap32(VAR_0->ifi_index);", "VAR_0->ifi_flags = tswap32(VAR_0->ifi_flags);", "VAR_0->ifi_change = tswap32(VAR_0->ifi_change);", "target_to_host_link_rtattr(IFLA_RTA(VAR_0), nlh->nlmsg_len -\nNLMSG_LENGTH(sizeof(*VAR_0)));", "break;", "case RTM_GETADDR:\ncase RTM_NEWADDR:\ncase RTM_DELADDR:\nVAR_1 = NLMSG_DATA(nlh);", "VAR_1->ifa_index = tswap32(VAR_1->ifa_index);", "target_to_host_addr_rtattr(IFA_RTA(VAR_1), nlh->nlmsg_len -\nNLMSG_LENGTH(sizeof(*VAR_1)));", "break;", "case RTM_GETROUTE:\nbreak;", "case RTM_NEWROUTE:\ncase RTM_DELROUTE:\nVAR_2 = NLMSG_DATA(nlh);", "VAR_2->rtm_flags = tswap32(VAR_2->rtm_flags);", "target_to_host_route_rtattr(RTM_RTA(VAR_2), nlh->nlmsg_len -\nNLMSG_LENGTH(sizeof(*VAR_2)));", "break;", "default:\nreturn -TARGET_EOPNOTSUPP;", "}", "return 0;", "}" ]

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

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

[ "FUNC_0(VAR_0)\n{", "if (Ts0 < Ts1) {", "T0 = 0x08;", "} else if (Ts0 > Ts1) {", "T0 = 0x04;", "} else {", "T0 = 0x02;", "}", "RETURN();", "}" ]

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

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

[ "VAR_8staticVAR_8 VAR_8intVAR_8 VAR_8parse_channel_expressionsVAR_8(VAR_8AVFilterContextVAR_8 *VAR_8VAR_0VAR_8,\nVAR_8intVAR_8 VAR_8VAR_1VAR_8)\n{", "VAR_8EvalContextVAR_8 *VAR_8evalVAR_8 = VAR_8VAR_0VAR_8->VAR_8privVAR_8;", "VAR_8charVAR_8 *VAR_8VAR_2VAR_8 = VAR_8av_strdupVAR_8(VAR_8evalVAR_8->VAR_8exprsVAR_8);", "VAR_8charVAR_8 *VAR_8VAR_3VAR_8, *VAR_8VAR_4VAR_8, *VAR_8VAR_11VAR_8;", "VAR_8doubleVAR_8 (* VAR_8constVAR_8 *VAR_8VAR_6VAR_8)(VAR_8voidVAR_8 *, VAR_8doubleVAR_8) = VAR_8NULLVAR_8;", "VAR_8constVAR_8 VAR_8charVAR_8 * VAR_8constVAR_8 *VAR_8func1_namesVAR_8 = VAR_8NULLVAR_8;", "VAR_8intVAR_8 VAR_8iVAR_8, VAR_8retVAR_8 = VAR_80VAR_8;", "VAR_8ifVAR_8 (!VAR_8VAR_2VAR_8)\nVAR_8returnVAR_8 VAR_8AVERRORVAR_8(VAR_8ENOMEMVAR_8);", "VAR_8ifVAR_8 (!VAR_8evalVAR_8->VAR_8exprsVAR_8) {", "VAR_8av_logVAR_8(VAR_8VAR_0VAR_8, VAR_8AV_LOG_ERRORVAR_8, \"VAR_8ChannelsVAR_8 VAR_8expressionsVAR_8 VAR_8listVAR_8 VAR_8isVAR_8 VAR_8emptyVAR_8\\VAR_8nVAR_8\");", "VAR_8returnVAR_8 VAR_8AVERRORVAR_8(VAR_8EINVALVAR_8);", "}", "VAR_8ifVAR_8 (!VAR_8strcmpVAR_8(VAR_8VAR_0VAR_8->VAR_8filterVAR_8->VAR_8nameVAR_8, \"VAR_8aevalVAR_8\")) {", "VAR_8VAR_6VAR_8 = VAR_8aeval_func1VAR_8;", "VAR_8func1_namesVAR_8 = VAR_8aeval_func1_namesVAR_8;", "}", "#VAR_8defineVAR_8 VAR_8ADD_EXPRESSIONVAR_8(VAR_8expr_VAR_8) VAR_8doVAR_8 { \\", "VAR_8ifVAR_8 (!VAR_8av_dynarray2_addVAR_8((VAR_8voidVAR_8 **)&VAR_8evalVAR_8->VAR_8VAR_3VAR_8, &VAR_8evalVAR_8->VAR_8nb_channelsVAR_8, \\\nVAR_8sizeofVAR_8(*VAR_8evalVAR_8->VAR_8VAR_3VAR_8), VAR_8NULLVAR_8)) { \\", "VAR_8retVAR_8 = VAR_8AVERRORVAR_8(VAR_8ENOMEMVAR_8); \\", "VAR_8gotoVAR_8 VAR_8endVAR_8; \\", "} \\", "VAR_8evalVAR_8->VAR_8VAR_3VAR_8[VAR_8evalVAR_8->VAR_8nb_channelsVAR_8-VAR_81VAR_8] = VAR_8NULLVAR_8; \\", "VAR_8retVAR_8 = VAR_8av_expr_parseVAR_8(&VAR_8evalVAR_8->VAR_8VAR_3VAR_8[VAR_8evalVAR_8->VAR_8nb_channelsVAR_8 - VAR_81VAR_8], VAR_8expr_VAR_8, \\\nVAR_8var_namesVAR_8, VAR_8func1_namesVAR_8, VAR_8VAR_6VAR_8, \\\nVAR_8NULLVAR_8, VAR_8NULLVAR_8, VAR_80VAR_8, VAR_8VAR_0VAR_8); \\", "VAR_8ifVAR_8 (VAR_8retVAR_8 < VAR_80VAR_8) \\\nVAR_8gotoVAR_8 VAR_8endVAR_8; \\", "} VAR_8whileVAR_8 (VAR_80VAR_8)", "VAR_8forVAR_8 (VAR_8iVAR_8 = VAR_80VAR_8; VAR_8iVAR_8 < VAR_8evalVAR_8->VAR_8nb_channelsVAR_8; VAR_8iVAR_8++) {", "VAR_8av_expr_freeVAR_8(VAR_8evalVAR_8->VAR_8VAR_3VAR_8[VAR_8iVAR_8]);", "VAR_8evalVAR_8->VAR_8VAR_3VAR_8[VAR_8iVAR_8] = VAR_8NULLVAR_8;", "}", "VAR_8av_freepVAR_8(&VAR_8evalVAR_8->VAR_8VAR_3VAR_8);", "VAR_8evalVAR_8->VAR_8nb_channelsVAR_8 = VAR_80VAR_8;", "VAR_8VAR_11VAR_8 = VAR_8VAR_2VAR_8;", "VAR_8whileVAR_8 (VAR_8VAR_3VAR_8 = VAR_8av_strtokVAR_8(VAR_8VAR_11VAR_8, \"|\", &VAR_8VAR_11VAR_8)) {", "VAR_8ADD_EXPRESSIONVAR_8(VAR_8VAR_3VAR_8);", "VAR_8VAR_4VAR_8 = VAR_8VAR_3VAR_8;", "}", "VAR_8ifVAR_8 (VAR_8VAR_1VAR_8 > VAR_8evalVAR_8->VAR_8nb_channelsVAR_8)\nVAR_8forVAR_8 (VAR_8iVAR_8 = VAR_8evalVAR_8->VAR_8nb_channelsVAR_8; VAR_8iVAR_8 < VAR_8VAR_1VAR_8; VAR_8iVAR_8++)", "VAR_8ADD_EXPRESSIONVAR_8(VAR_8VAR_4VAR_8);", "VAR_8ifVAR_8 (VAR_8VAR_1VAR_8 > VAR_80VAR_8 && VAR_8evalVAR_8->VAR_8nb_channelsVAR_8 != VAR_8VAR_1VAR_8) {", "VAR_8av_logVAR_8(VAR_8VAR_0VAR_8, VAR_8AV_LOG_ERRORVAR_8,\n\"VAR_8MismatchVAR_8 VAR_8betweenVAR_8 VAR_8theVAR_8 VAR_8specifiedVAR_8 VAR_8numberVAR_8 VAR_8ofVAR_8 VAR_8channelVAR_8 VAR_8expressionsVAR_8 '%VAR_8dVAR_8' \"\n\"VAR_8andVAR_8 VAR_8theVAR_8 VAR_8numberVAR_8 VAR_8ofVAR_8 VAR_8expectedVAR_8 VAR_8outputVAR_8 VAR_8channelsVAR_8 '%VAR_8dVAR_8' VAR_8forVAR_8 VAR_8theVAR_8 VAR_8specifiedVAR_8 VAR_8channelVAR_8 VAR_8layoutVAR_8\\VAR_8nVAR_8\",\nVAR_8evalVAR_8->VAR_8nb_channelsVAR_8, VAR_8VAR_1VAR_8);", "VAR_8retVAR_8 = VAR_8AVERRORVAR_8(VAR_8EINVALVAR_8);", "VAR_8gotoVAR_8 VAR_8endVAR_8;", "}", "VAR_8endVAR_8:\nVAR_8av_freeVAR_8(VAR_8VAR_2VAR_8);", "VAR_8returnVAR_8 VAR_8retVAR_8;", "}" ]

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

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

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "const char *VAR_1 = VAR_0->buf, *VAR_2 = VAR_0->buf + VAR_0->buf_size;", "while (VAR_1 < VAR_2 && *VAR_1 != '\\0') {", "if (VAR_1 + sizeof(\"c=IN IP\") - 1 < VAR_2 &&\nav_strstart(VAR_1, \"c=IN IP\", NULL))\nreturn AVPROBE_SCORE_EXTENSION;", "while (VAR_1 < VAR_2 - 1 && *VAR_1 != '\\n') VAR_1++;", "if (++VAR_1 >= VAR_2)\nbreak;", "if (*VAR_1 == '\\r')\nVAR_1++;", "}", "return 0;", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, int16_t *VAR_1,\nint *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{", "int VAR_5;", "*VAR_2= 0;", "VAR_5 = VAR_0->codec->decode(VAR_0, VAR_1, VAR_2,\nVAR_3, VAR_4);", "VAR_0->frame_number++;", "return VAR_5;", "}" ]

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

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

[ "static int FUNC_0(AVBSFContext *VAR_0, AVPacket *VAR_1)\n{", "UnpackBFramesBSFContext *s = VAR_0->priv_data;", "int VAR_2 = -1, VAR_3 = 0, VAR_4 = -1, VAR_5 = 0;", "AVPacket *in;", "VAR_5 = ff_bsf_get_packet(VAR_0, &in);", "if (VAR_5 < 0)\nreturn VAR_5;", "scan_buffer(in->data, in->size, &VAR_2, &VAR_3, &VAR_4);", "av_log(VAR_0, AV_LOG_DEBUG, \"Found %d VOP startcode(s) in this packet.\\n\", VAR_3);", "if (VAR_4 >= 0) {", "if (s->b_frame_buf) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"Missing one N-VOP packet, discarding one B-frame.\\n\");", "av_freep(&s->b_frame_buf);", "s->b_frame_buf_size = 0;", "}", "s->b_frame_buf_size = in->size - VAR_4;", "s->b_frame_buf = create_new_buffer(in->data + VAR_4, s->b_frame_buf_size);", "if (!s->b_frame_buf) {", "s->b_frame_buf_size = 0;", "av_packet_free(&in);", "return AVERROR(ENOMEM);", "}", "}", "if (VAR_3 > 2) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"Found %d VOP headers in one packet, only unpacking one.\\n\", VAR_3);", "}", "if (VAR_3 == 1 && s->b_frame_buf) {", "VAR_5 = av_packet_copy_props(VAR_1, in);", "if (VAR_5 < 0) {", "av_packet_free(&in);", "return VAR_5;", "}", "av_packet_from_data(VAR_1, s->b_frame_buf, s->b_frame_buf_size);", "if (in->size <= MAX_NVOP_SIZE) {", "av_log(VAR_0, AV_LOG_DEBUG, \"Skipping N-VOP.\\n\");", "s->b_frame_buf = NULL;", "s->b_frame_buf_size = 0;", "} else {", "s->b_frame_buf_size = in->size;", "s->b_frame_buf = create_new_buffer(in->data, in->size);", "if (!s->b_frame_buf) {", "s->b_frame_buf_size = 0;", "av_packet_unref(VAR_1);", "av_packet_free(&in);", "return AVERROR(ENOMEM);", "}", "}", "} else if (VAR_3 >= 2) {", "av_packet_move_ref(VAR_1, in);", "VAR_1->size = VAR_4;", "} else if (VAR_2 >= 0) {", "av_log(VAR_0, AV_LOG_DEBUG, \"Updating DivX userdata (remove trailing 'p').\\n\");", "av_packet_move_ref(VAR_1, in);", "VAR_1->data[VAR_2] = '\\0';", "} else {", "av_packet_move_ref(VAR_1, in);", "}", "av_packet_free(&in);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15, 17 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 149 ], [ 153 ], [ 155 ] ]

[ "static int FUNC_0(void *VAR_0, void *VAR_1, const AVOption *VAR_2, const char *VAR_3, void *VAR_4)\n{", "int VAR_5 = 0;", "int VAR_6, VAR_7;", "char VAR_8;", "if (sscanf(VAR_3, \"%VAR_12%*1[:/]%VAR_12%VAR_8\", &VAR_6, &VAR_7, &VAR_8) == 2) {", "if ((VAR_5 = write_number(VAR_0, VAR_2, VAR_4, 1, VAR_7, VAR_6)) >= 0)\nreturn VAR_5;", "VAR_5 = 0;", "}", "for (;;) {", "int VAR_9 = 0;", "char VAR_10[256];", "int VAR_11 = 0;", "double VAR_12;", "int64_t intnum = 1;", "if (VAR_2->type == AV_OPT_TYPE_FLAGS) {", "if (*VAR_3 == '+' || *VAR_3 == '-')\nVAR_11 = *(VAR_3++);", "for (; VAR_9 < sizeof(VAR_10) - 1 && VAR_3[VAR_9] && VAR_3[VAR_9] != '+' && VAR_3[VAR_9] != '-'; VAR_9++)", "VAR_10[VAR_9] = VAR_3[VAR_9];", "VAR_10[VAR_9] = 0;", "}", "{", "const AVOption *VAR_13 = av_opt_find(VAR_1, VAR_10, VAR_2->unit, 0, 0);", "int VAR_14;", "int VAR_15 = 0;", "double VAR_16[64];", "const char * VAR_17[64];", "if (VAR_13 && VAR_13->type == AV_OPT_TYPE_CONST)\nVAR_12 = DEFAULT_NUMVAL(VAR_13);", "else {", "if (VAR_2->unit) {", "for (VAR_13 = NULL; VAR_13 = av_opt_next(VAR_1, VAR_13); ) {", "if (VAR_13->type == AV_OPT_TYPE_CONST &&\nVAR_13->unit &&\n!strcmp(VAR_13->unit, VAR_2->unit)) {", "if (VAR_15 + 6 >= FF_ARRAY_ELEMS(VAR_16)) {", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_16 array too small for %s\\n\", VAR_2->unit);", "return AVERROR_PATCHWELCOME;", "}", "VAR_17 [VAR_15 ] = VAR_13->name;", "VAR_16[VAR_15++] = DEFAULT_NUMVAL(VAR_13);", "}", "}", "}", "VAR_17 [VAR_15 ] = \"default\";", "VAR_16[VAR_15++] = DEFAULT_NUMVAL(VAR_2);", "VAR_17 [VAR_15 ] = \"max\";", "VAR_16[VAR_15++] = VAR_2->max;", "VAR_17 [VAR_15 ] = \"min\";", "VAR_16[VAR_15++] = VAR_2->min;", "VAR_17 [VAR_15 ] = \"none\";", "VAR_16[VAR_15++] = 0;", "VAR_17 [VAR_15 ] = \"all\";", "VAR_16[VAR_15++] = ~0;", "VAR_17 [VAR_15] = NULL;", "VAR_16[VAR_15] = 0;", "VAR_14 = av_expr_parse_and_eval(&VAR_12, VAR_9 ? VAR_10 : VAR_3, VAR_17,\nVAR_16, NULL, NULL, NULL, NULL, NULL, 0, VAR_0);", "if (VAR_14 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Unable to parse option value \\\"%s\\\"\\n\", VAR_3);", "return VAR_14;", "}", "}", "}", "if (VAR_2->type == AV_OPT_TYPE_FLAGS) {", "read_number(VAR_2, VAR_4, NULL, NULL, &intnum);", "if (VAR_11 == '+') VAR_12 = intnum | (int64_t)VAR_12;", "else if (VAR_11 == '-') VAR_12 = intnum &~(int64_t)VAR_12;", "}", "if ((VAR_5 = write_number(VAR_0, VAR_2, VAR_4, VAR_12, 1, 1)) < 0)\nreturn VAR_5;", "VAR_3 += VAR_9;", "if (!VAR_9 || !*VAR_3)\nreturn 0;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(QmpInputVisitor *VAR_0, Error **VAR_1)\n{", "StackObject *tos = &VAR_0->stack[VAR_0->nb_stack - 1];", "assert(VAR_0->nb_stack > 0);", "if (VAR_0->strict) {", "GHashTable *const top_ht = tos->h;", "if (top_ht) {", "GHashTableIter iter;", "const char *VAR_2;", "g_hash_table_iter_init(&iter, top_ht);", "if (g_hash_table_iter_next(&iter, (void **)&VAR_2, NULL)) {", "error_setg(VAR_1, QERR_QMP_EXTRA_MEMBER, VAR_2);", "}", "g_hash_table_unref(top_ht);", "}", "tos->h = NULL;", "}", "VAR_0->nb_stack--;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "GString *gstr = g_string_new(\"\");", "QObject *obj;", "gen_test_json(gstr, 10, 100);", "obj = qobject_from_json(gstr->str, NULL);", "g_assert(obj != NULL);", "qobject_decref(obj);", "g_string_free(gstr, true);", "}" ]

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

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

[ "static uint32_t FUNC_0(SSISlave *ss, uint32_t tx)\n{", "Flash *s = M25P80(ss);", "uint32_t r = 0;", "switch (s->state) {", "case STATE_PAGE_PROGRAM:\nDB_PRINT_L(1, \"page program cur_addr=%#\" PRIx64 \" data=%\" PRIx8 \"\\n\",\ns->cur_addr, (uint8_t)tx);", "flash_write8(s, s->cur_addr, (uint8_t)tx);", "s->cur_addr++;", "break;", "case STATE_READ:\nr = s->storage[s->cur_addr];", "DB_PRINT_L(1, \"READ 0x%\" PRIx64 \"=%\" PRIx8 \"\\n\", s->cur_addr,\n(uint8_t)r);", "s->cur_addr = (s->cur_addr + 1) % s->size;", "break;", "case STATE_COLLECTING_DATA:\ncase STATE_COLLECTING_VAR_LEN_DATA:\ns->data[s->len] = (uint8_t)tx;", "s->len++;", "if (s->len == s->needed_bytes) {", "complete_collecting_data(s);", "}", "break;", "case STATE_READING_DATA:\nr = s->data[s->pos];", "s->pos++;", "if (s->pos == s->len) {", "s->pos = 0;", "s->state = STATE_IDLE;", "}", "break;", "default:\ncase STATE_IDLE:\ndecode_new_cmd(s, (uint8_t)tx);", "break;", "}", "return r;", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "if (VAR_0->imm5 == 7) {", "LOG_DIS(\"scall\\n\");", "} else if (VAR_0->imm5 == 2) {", "LOG_DIS(\"break\\n\");", "} else {", "cpu_abort(VAR_0->env, \"invalid opcode\\n\");", "}", "if (VAR_0->imm5 == 7) {", "tcg_gen_movi_tl(cpu_pc, VAR_0->pc);", "t_gen_raise_exception(VAR_0, EXCP_SYSTEMCALL);", "} else {", "tcg_gen_movi_tl(cpu_pc, VAR_0->pc);", "t_gen_raise_exception(VAR_0, EXCP_BREAKPOINT);", "}", "}" ]

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

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

[ "static int FUNC_0(OHCIState *VAR_0, struct ohci_ed *VAR_1,\nint VAR_2)\n{", "int VAR_3;", "size_t len = 0;", "#ifdef DEBUG_ISOCH\nconst char *str = NULL;", "#endif\nint VAR_4;", "int VAR_5;", "int VAR_6;", "USBDevice *dev;", "struct ohci_iso_td VAR_7;", "uint32_t addr;", "uint16_t starting_frame;", "int16_t relative_frame_number;", "int VAR_8;", "uint32_t start_offset, next_offset, end_offset = 0;", "uint32_t start_addr, end_addr;", "addr = VAR_1->head & OHCI_DPTR_MASK;", "if (!ohci_read_iso_td(VAR_0, addr, &VAR_7)) {", "printf(\"usb-VAR_0: ISO_TD read error at %x\\n\", addr);", "return 0;", "}", "starting_frame = OHCI_BM(VAR_7.flags, TD_SF);", "VAR_8 = OHCI_BM(VAR_7.flags, TD_FC);", "relative_frame_number = USUB(VAR_0->frame_number, starting_frame);", "#ifdef DEBUG_ISOCH\nprintf(\"--- ISO_TD ED head 0x%.8x tailp 0x%.8x\\n\"\n\"0x%.8x 0x%.8x 0x%.8x 0x%.8x\\n\"\n\"0x%.8x 0x%.8x 0x%.8x 0x%.8x\\n\"\n\"0x%.8x 0x%.8x 0x%.8x 0x%.8x\\n\"\n\"frame_number 0x%.8x starting_frame 0x%.8x\\n\"\n\"VAR_8 0x%.8x relative %d\\n\"\n\"di 0x%.8x cc 0x%.8x\\n\",\nVAR_1->head & OHCI_DPTR_MASK, VAR_1->tail & OHCI_DPTR_MASK,\nVAR_7.flags, VAR_7.bp, VAR_7.next, VAR_7.be,\nVAR_7.offset[0], VAR_7.offset[1], VAR_7.offset[2], VAR_7.offset[3],\nVAR_7.offset[4], VAR_7.offset[5], VAR_7.offset[6], VAR_7.offset[7],\nVAR_0->frame_number, starting_frame,\nVAR_8, relative_frame_number,\nOHCI_BM(VAR_7.flags, TD_DI), OHCI_BM(VAR_7.flags, TD_CC));", "#endif\nif (relative_frame_number < 0) {", "DPRINTF(\"usb-VAR_0: ISO_TD R=%d < 0\\n\", relative_frame_number);", "return 1;", "} else if (relative_frame_number > VAR_8) {", "DPRINTF(\"usb-VAR_0: ISO_TD R=%d > FC=%d\\n\", relative_frame_number,\nVAR_8);", "OHCI_SET_BM(VAR_7.flags, TD_CC, OHCI_CC_DATAOVERRUN);", "VAR_1->head &= ~OHCI_DPTR_MASK;", "VAR_1->head |= (VAR_7.next & OHCI_DPTR_MASK);", "VAR_7.next = VAR_0->done;", "VAR_0->done = addr;", "VAR_6 = OHCI_BM(VAR_7.flags, TD_DI);", "if (VAR_6 < VAR_0->done_count)\nVAR_0->done_count = VAR_6;", "ohci_put_iso_td(VAR_0, addr, &VAR_7);", "return 0;", "}", "VAR_3 = OHCI_BM(VAR_1->flags, ED_D);", "switch (VAR_3) {", "case OHCI_TD_DIR_IN:\n#ifdef DEBUG_ISOCH\nstr = \"in\";", "#endif\nVAR_4 = USB_TOKEN_IN;", "break;", "case OHCI_TD_DIR_OUT:\n#ifdef DEBUG_ISOCH\nstr = \"out\";", "#endif\nVAR_4 = USB_TOKEN_OUT;", "break;", "case OHCI_TD_DIR_SETUP:\n#ifdef DEBUG_ISOCH\nstr = \"setup\";", "#endif\nVAR_4 = USB_TOKEN_SETUP;", "break;", "default:\nprintf(\"usb-VAR_0: Bad direction %d\\n\", VAR_3);", "return 1;", "}", "if (!VAR_7.bp || !VAR_7.be) {", "printf(\"usb-VAR_0: ISO_TD bp 0x%.8x be 0x%.8x\\n\", VAR_7.bp, VAR_7.be);", "return 1;", "}", "start_offset = VAR_7.offset[relative_frame_number];", "next_offset = VAR_7.offset[relative_frame_number + 1];", "if (!(OHCI_BM(start_offset, TD_PSW_CC) & 0xe) ||\n((relative_frame_number < VAR_8) &&\n!(OHCI_BM(next_offset, TD_PSW_CC) & 0xe))) {", "printf(\"usb-VAR_0: ISO_TD cc != not accessed 0x%.8x 0x%.8x\\n\",\nstart_offset, next_offset);", "return 1;", "}", "if ((relative_frame_number < VAR_8) && (start_offset > next_offset)) {", "printf(\"usb-VAR_0: ISO_TD start_offset=0x%.8x > next_offset=0x%.8x\\n\",\nstart_offset, next_offset);", "return 1;", "}", "if ((start_offset & 0x1000) == 0) {", "start_addr = (VAR_7.bp & OHCI_PAGE_MASK) |\n(start_offset & OHCI_OFFSET_MASK);", "} else {", "start_addr = (VAR_7.be & OHCI_PAGE_MASK) |\n(start_offset & OHCI_OFFSET_MASK);", "}", "if (relative_frame_number < VAR_8) {", "end_offset = next_offset - 1;", "if ((end_offset & 0x1000) == 0) {", "end_addr = (VAR_7.bp & OHCI_PAGE_MASK) |\n(end_offset & OHCI_OFFSET_MASK);", "} else {", "end_addr = (VAR_7.be & OHCI_PAGE_MASK) |\n(end_offset & OHCI_OFFSET_MASK);", "}", "} else {", "end_addr = VAR_7.be;", "}", "if ((start_addr & OHCI_PAGE_MASK) != (end_addr & OHCI_PAGE_MASK)) {", "len = (end_addr & OHCI_OFFSET_MASK) + 0x1001\n- (start_addr & OHCI_OFFSET_MASK);", "} else {", "len = end_addr - start_addr + 1;", "}", "if (len && VAR_3 != OHCI_TD_DIR_IN) {", "ohci_copy_iso_td(VAR_0, start_addr, end_addr, VAR_0->usb_buf, len, 0);", "}", "if (VAR_2) {", "VAR_5 = VAR_0->usb_packet.len;", "} else {", "VAR_5 = USB_RET_NODEV;", "for (VAR_6 = 0; VAR_6 < VAR_0->num_ports; VAR_6++) {", "dev = VAR_0->rhport[VAR_6].port.dev;", "if ((VAR_0->rhport[VAR_6].ctrl & OHCI_PORT_PES) == 0)\ncontinue;", "VAR_0->usb_packet.VAR_4 = VAR_4;", "VAR_0->usb_packet.devaddr = OHCI_BM(VAR_1->flags, ED_FA);", "VAR_0->usb_packet.devep = OHCI_BM(VAR_1->flags, ED_EN);", "VAR_0->usb_packet.data = VAR_0->usb_buf;", "VAR_0->usb_packet.len = len;", "VAR_5 = usb_handle_packet(dev, &VAR_0->usb_packet);", "if (VAR_5 != USB_RET_NODEV)\nbreak;", "}", "if (VAR_5 == USB_RET_ASYNC) {", "return 1;", "}", "}", "#ifdef DEBUG_ISOCH\nprintf(\"so 0x%.8x eo 0x%.8x\\nsa 0x%.8x ea 0x%.8x\\ndir %s len %zu VAR_5 %d\\n\",\nstart_offset, end_offset, start_addr, end_addr, str, len, VAR_5);", "#endif\nif (VAR_3 == OHCI_TD_DIR_IN && VAR_5 >= 0 && VAR_5 <= len) {", "ohci_copy_iso_td(VAR_0, start_addr, end_addr, VAR_0->usb_buf, VAR_5, 1);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_NOERROR);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_SIZE, VAR_5);", "} else if (VAR_3 == OHCI_TD_DIR_OUT && VAR_5 == len) {", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_NOERROR);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_SIZE, 0);", "} else {", "if (VAR_5 > (ssize_t) len) {", "printf(\"usb-VAR_0: DataOverrun %d > %zu\\n\", VAR_5, len);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_DATAOVERRUN);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_SIZE,\nlen);", "} else if (VAR_5 >= 0) {", "printf(\"usb-VAR_0: DataUnderrun %d\\n\", VAR_5);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_DATAUNDERRUN);", "} else {", "switch (VAR_5) {", "case USB_RET_NODEV:\nOHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_DEVICENOTRESPONDING);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_SIZE,\n0);", "break;", "case USB_RET_NAK:\ncase USB_RET_STALL:\nprintf(\"usb-VAR_0: got NAK/STALL %d\\n\", VAR_5);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_STALL);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_SIZE,\n0);", "break;", "default:\nprintf(\"usb-VAR_0: Bad device response %d\\n\", VAR_5);", "OHCI_SET_BM(VAR_7.offset[relative_frame_number], TD_PSW_CC,\nOHCI_CC_UNDEXPETEDPID);", "break;", "}", "}", "}", "if (relative_frame_number == VAR_8) {", "OHCI_SET_BM(VAR_7.flags, TD_CC, OHCI_CC_NOERROR);", "VAR_1->head &= ~OHCI_DPTR_MASK;", "VAR_1->head |= (VAR_7.next & OHCI_DPTR_MASK);", "VAR_7.next = VAR_0->done;", "VAR_0->done = addr;", "VAR_6 = OHCI_BM(VAR_7.flags, TD_DI);", "if (VAR_6 < VAR_0->done_count)\nVAR_0->done_count = VAR_6;", "}", "ohci_put_iso_td(VAR_0, addr, &VAR_7);", "return 1;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11, 13 ], [ 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91 ], [ 93, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141, 143, 145 ], [ 147, 149 ], [ 151 ], [ 153, 155, 157 ], [ 159, 161 ], [ 163 ], [ 165, 167, 169 ], [ 171, 173 ], [ 175 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 203, 205, 207 ], [ 209, 211 ], [ 213 ], [ 215 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 231 ], [ 233, 235 ], [ 237 ], [ 239, 241 ], [ 243 ], [ 247 ], [ 249 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 259, 261 ], [ 263 ], [ 265 ], [ 269 ], [ 271 ], [ 275 ], [ 277, 279 ], [ 281 ], [ 283 ], [ 285 ], [ 289 ], [ 291 ], [ 293 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309, 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325, 327 ], [ 329 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 343, 345, 347 ], [ 349, 355 ], [ 359 ], [ 361, 363 ], [ 365 ], [ 367 ], [ 371, 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383, 385 ], [ 387, 389 ], [ 391 ], [ 393 ], [ 395, 397 ], [ 399 ], [ 401 ], [ 403, 405, 407 ], [ 409, 411 ], [ 413 ], [ 415, 417, 419 ], [ 421, 423 ], [ 425, 427 ], [ 429 ], [ 431, 433 ], [ 435, 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 449 ], [ 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 463 ], [ 465, 467 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ] ]

[ "int FUNC_0(VIOsPAPRDevice *VAR_0, uint8_t *VAR_1)\n{", "int VAR_2;", "uint8_t byte;", "if (!VAR_0->VAR_1.qsize) {", "fprintf(stderr, \"spapr_vio_send_creq on uninitialized queue\\n\");", "return -1;", "}", "VAR_2 = spapr_tce_dma_read(VAR_0, VAR_0->VAR_1.qladdr + VAR_0->VAR_1.qnext, &byte, 1);", "if (VAR_2) {", "return VAR_2;", "}", "if (byte != 0) {", "return 1;", "}", "VAR_2 = spapr_tce_dma_write(VAR_0, VAR_0->VAR_1.qladdr + VAR_0->VAR_1.qnext + 8,\n&VAR_1[8], 8);", "if (VAR_2) {", "return VAR_2;", "}", "kvmppc_eieio();", "VAR_2 = spapr_tce_dma_write(VAR_0, VAR_0->VAR_1.qladdr + VAR_0->VAR_1.qnext, VAR_1, 8);", "if (VAR_2) {", "return VAR_2;", "}", "VAR_0->VAR_1.qnext = (VAR_0->VAR_1.qnext + 16) % VAR_0->VAR_1.qsize;", "if (VAR_0->signal_state & 1) {", "qemu_irq_pulse(VAR_0->qirq);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ] ]

[ "static void FUNC_0(struct vhost_dev *VAR_0, bool VAR_1)\n{", "struct vhost_log *VAR_2 = VAR_0->VAR_2;", "if (!VAR_2) {", "return;", "}", "VAR_0->VAR_2 = NULL;", "VAR_0->log_size = 0;", "--VAR_2->refcnt;", "if (VAR_2->refcnt == 0) {", "if (VAR_0->log_size && VAR_1) {", "vhost_log_sync_range(VAR_0, 0, VAR_0->log_size * VHOST_LOG_CHUNK - 1);", "}", "if (vhost_log == VAR_2) {", "g_free(VAR_2->VAR_2);", "vhost_log = NULL;", "} else if (vhost_log_shm == VAR_2) {", "qemu_memfd_free(VAR_2->VAR_2, VAR_2->size * sizeof(*(VAR_2->VAR_2)),\nVAR_2->fd);", "vhost_log_shm = NULL;", "}", "g_free(VAR_2);", "}", "}" ]

[ 0, 0, 0, 0, 0, 1, 1, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "static void FUNC_0(BlockJob *VAR_0, int64_t VAR_1, Error **VAR_2)\n{", "MirrorBlockJob *s = container_of(VAR_0, MirrorBlockJob, common);", "if (VAR_1 < 0) {", "error_setg(VAR_2, QERR_INVALID_PARAMETER, \"VAR_1\");", "return;", "}", "ratelimit_set_speed(&s->limit, VAR_1 / BDRV_SECTOR_SIZE, SLICE_TIME);", "}" ]

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

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

[ "static uint16_t FUNC_0(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,\nuint64_t prp2, uint32_t len, NvmeCtrl *n)\n{", "hwaddr trans_len = n->page_size - (prp1 % n->page_size);", "trans_len = MIN(len, trans_len);", "int VAR_0 = (len >> n->page_bits) + 1;", "if (!prp1) {", "return NVME_INVALID_FIELD | NVME_DNR;", "} else if (n->cmbsz && prp1 >= n->ctrl_mem.addr &&", "prp1 < n->ctrl_mem.addr + int128_get64(n->ctrl_mem.size)) {", "qsg->nsg = 0;", "qemu_iovec_init(iov, VAR_0);", "qemu_iovec_add(iov, (void *)&n->cmbuf[prp1 - n->ctrl_mem.addr], trans_len);", "} else {", "pci_dma_sglist_init(qsg, &n->parent_obj, VAR_0);", "qemu_sglist_add(qsg, prp1, trans_len);", "}", "len -= trans_len;", "if (len) {", "if (!prp2) {", "goto unmap;", "}", "if (len > n->page_size) {", "uint64_t prp_list[n->max_prp_ents];", "uint32_t nents, prp_trans;", "int VAR_1 = 0;", "nents = (len + n->page_size - 1) >> n->page_bits;", "prp_trans = MIN(n->max_prp_ents, nents) * sizeof(uint64_t);", "nvme_addr_read(n, prp2, (void *)prp_list, prp_trans);", "while (len != 0) {", "uint64_t prp_ent = le64_to_cpu(prp_list[VAR_1]);", "if (VAR_1 == n->max_prp_ents - 1 && len > n->page_size) {", "if (!prp_ent || prp_ent & (n->page_size - 1)) {", "goto unmap;", "}", "VAR_1 = 0;", "nents = (len + n->page_size - 1) >> n->page_bits;", "prp_trans = MIN(n->max_prp_ents, nents) * sizeof(uint64_t);", "nvme_addr_read(n, prp_ent, (void *)prp_list,\nprp_trans);", "prp_ent = le64_to_cpu(prp_list[VAR_1]);", "}", "if (!prp_ent || prp_ent & (n->page_size - 1)) {", "goto unmap;", "}", "trans_len = MIN(len, n->page_size);", "if (qsg->nsg){", "qemu_sglist_add(qsg, prp_ent, trans_len);", "} else {", "qemu_iovec_add(iov, (void *)&n->cmbuf[prp_ent - n->ctrl_mem.addr], trans_len);", "}", "len -= trans_len;", "VAR_1++;", "}", "} else {", "if (prp2 & (n->page_size - 1)) {", "goto unmap;", "}", "if (qsg->nsg) {", "qemu_sglist_add(qsg, prp2, len);", "} else {", "qemu_iovec_add(iov, (void *)&n->cmbuf[prp2 - n->ctrl_mem.addr], trans_len);", "}", "}", "}", "return NVME_SUCCESS;", "unmap:\nqemu_sglist_destroy(qsg);", "return NVME_INVALID_FIELD | NVME_DNR;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, const char *VAR_1, AVDictionary **VAR_2)\n{", "int VAR_3;", "AVProbeData pd = {VAR_1, NULL, 0};", "if(VAR_0->iformat && !strlen(VAR_1))\nreturn 0;", "if (VAR_0->pb) {", "VAR_0->flags |= AVFMT_FLAG_CUSTOM_IO;", "if (!VAR_0->iformat)\nreturn av_probe_input_buffer(VAR_0->pb, &VAR_0->iformat, VAR_1, VAR_0, 0, 0);", "else if (VAR_0->iformat->flags & AVFMT_NOFILE)\nav_log(VAR_0, AV_LOG_WARNING, \"Custom AVIOContext makes no sense and \"\n\"will be ignored with AVFMT_NOFILE format.\\n\");", "return 0;", "}", "if ( (VAR_0->iformat && VAR_0->iformat->flags & AVFMT_NOFILE) ||\n(!VAR_0->iformat && (VAR_0->iformat = av_probe_input_format(&pd, 0))))\nreturn 0;", "if ((VAR_3 = avio_open2(&VAR_0->pb, VAR_1, AVIO_FLAG_READ,\n&VAR_0->interrupt_callback, VAR_2)) < 0)\nreturn VAR_3;", "if (VAR_0->iformat)\nreturn 0;", "return av_probe_input_buffer(VAR_0->pb, &VAR_0->iformat, VAR_1, VAR_0, 0, 0);", "}" ]

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

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

[ "static GuestPCIAddress *FUNC_0(char *guid, Error **errp)\n{", "HDEVINFO dev_info;", "SP_DEVINFO_DATA dev_info_data;", "DWORD size = 0;", "int VAR_0;", "char VAR_1[MAX_PATH];", "char *VAR_2 = NULL;", "GuestPCIAddress *pci = NULL;", "char *VAR_3 = g_strdup(&guid[4]);", "if (!QueryDosDevice(VAR_3, VAR_1, ARRAY_SIZE(VAR_1))) {", "error_setg_win32(errp, GetLastError(), \"failed to get dos device VAR_3\");", "goto out;", "}", "dev_info = SetupDiGetClassDevs(&GUID_DEVINTERFACE_VOLUME, 0, 0,\nDIGCF_PRESENT | DIGCF_DEVICEINTERFACE);", "if (dev_info == INVALID_HANDLE_VALUE) {", "error_setg_win32(errp, GetLastError(), \"failed to get devices tree\");", "goto out;", "}", "dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);", "for (VAR_0 = 0; SetupDiEnumDeviceInfo(dev_info, VAR_0, &dev_info_data); VAR_0++) {", "DWORD addr, bus, slot, func, dev, data, size2;", "while (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,\nSPDRP_PHYSICAL_DEVICE_OBJECT_NAME,\n&data, (PBYTE)VAR_2, size,\n&size2)) {", "size = MAX(size, size2);", "if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {", "g_free(VAR_2);", "VAR_2 = g_malloc(size * 2);", "} else {", "error_setg_win32(errp, GetLastError(),\n\"failed to get device VAR_3\");", "goto out;", "}", "}", "if (g_strcmp0(VAR_2, VAR_1)) {", "continue;", "}", "if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,\nSPDRP_BUSNUMBER, &data, (PBYTE)&bus, size, NULL)) {", "break;", "}", "if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,\nSPDRP_ADDRESS, &data, (PBYTE)&addr, size, NULL)) {", "break;", "}", "if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data,\nSPDRP_UI_NUMBER, &data, (PBYTE)&slot, size, NULL)) {", "break;", "}", "func = addr & 0x0000FFFF;", "dev = (addr >> 16) & 0x0000FFFF;", "pci = g_malloc0(sizeof(*pci));", "pci->domain = dev;", "pci->slot = slot;", "pci->function = func;", "pci->bus = bus;", "break;", "}", "out:\ng_free(VAR_2);", "g_free(VAR_3);", "return pci;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53, 55, 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 185 ] ]

[ "int FUNC_0(CPUState *VAR_0, const char *VAR_1, uint64_t *VAR_2)\n{", "int VAR_3, VAR_4;", "PowerPCCPU *cpu = POWERPC_CPU(VAR_0);", "CPUPPCState *env = &cpu->env;", "if ((tolower(VAR_1[0]) == 'r') &&\nppc_cpu_get_reg_num(VAR_1 + 1, ARRAY_SIZE(env->gpr), &VAR_4)) {", "*VAR_2 = env->gpr[VAR_4];", "return 0;", "}", "if ((tolower(VAR_1[0]) == 'f') &&\nppc_cpu_get_reg_num(VAR_1 + 1, ARRAY_SIZE(env->fpr), &VAR_4)) {", "*VAR_2 = env->fpr[VAR_4];", "return 0;", "}", "for (VAR_3 = 0; VAR_3 < ARRAY_SIZE(env->spr_cb); ++VAR_3) {", "ppc_spr_t *spr = &env->spr_cb[VAR_3];", "if (spr->VAR_1 && (strcasecmp(VAR_1, spr->VAR_1) == 0)) {", "*VAR_2 = env->spr[VAR_3];", "return 0;", "}", "}", "#if !defined(CONFIG_USER_ONLY)\nif ((strncasecmp(VAR_1, \"sr\", 2) == 0) &&\nppc_cpu_get_reg_num(VAR_1 + 2, ARRAY_SIZE(env->sr), &VAR_4)) {", "*VAR_2 = env->sr[VAR_4];", "return 0;", "}", "#endif\nreturn -EINVAL;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63, 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75, 79 ], [ 81 ] ]

[ "FUNC_0(VAR_0)\n{", "env->nip = PARAM(1);", "RETURN();", "}" ]

[ 0, 1, 1, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nconst uint8_t *VAR_1, int VAR_2)\n{", "Mpeg1Context *s1 = VAR_0->priv_data;", "MpegEncContext *s = &s1->mpeg_enc_ctx;", "int VAR_3, VAR_4;", "int VAR_5, VAR_6, VAR_8;", "init_get_bits(&s->gb, VAR_1, VAR_2 * 8);", "VAR_3 = get_bits(&s->gb, 12);", "VAR_4 = get_bits(&s->gb, 12);", "if (VAR_3 == 0 || VAR_4 == 0) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"Invalid horizontal or vertical size value.\\n\");", "if (VAR_0->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))\nreturn AVERROR_INVALIDDATA;", "}", "s->aspect_ratio_info = get_bits(&s->gb, 4);", "if (s->aspect_ratio_info == 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"aspect ratio has forbidden 0 value\\n\");", "if (VAR_0->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))\nreturn AVERROR_INVALIDDATA;", "}", "s->frame_rate_index = get_bits(&s->gb, 4);", "if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"frame_rate_index %d is invalid\\n\", s->frame_rate_index);", "s->frame_rate_index = 1;", "}", "s->bit_rate = get_bits(&s->gb, 18) * 400;", "if (check_marker(&s->gb, \"in sequence header\") == 0) {", "return AVERROR_INVALIDDATA;", "}", "s->VAR_0->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;", "skip_bits(&s->gb, 1);", "if (get_bits1(&s->gb)) {", "load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);", "} else {", "for (VAR_5 = 0; VAR_5 < 64; VAR_5++) {", "VAR_8 = s->idsp.idct_permutation[VAR_5];", "VAR_6 = ff_mpeg1_default_intra_matrix[VAR_5];", "s->intra_matrix[VAR_8] = VAR_6;", "s->chroma_intra_matrix[VAR_8] = VAR_6;", "}", "}", "if (get_bits1(&s->gb)) {", "load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);", "} else {", "for (VAR_5 = 0; VAR_5 < 64; VAR_5++) {", "int VAR_8 = s->idsp.idct_permutation[VAR_5];", "VAR_6 = ff_mpeg1_default_non_intra_matrix[VAR_5];", "s->inter_matrix[VAR_8] = VAR_6;", "s->chroma_inter_matrix[VAR_8] = VAR_6;", "}", "}", "if (show_bits(&s->gb, 23) != 0) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"sequence header damaged\\n\");", "return AVERROR_INVALIDDATA;", "}", "s->VAR_3 = VAR_3;", "s->VAR_4 = VAR_4;", "s->progressive_sequence = 1;", "s->progressive_frame = 1;", "s->picture_structure = PICT_FRAME;", "s->first_field = 0;", "s->frame_pred_frame_dct = 1;", "s->chroma_format = 1;", "s->codec_id =\ns->VAR_0->codec_id = AV_CODEC_ID_MPEG1VIDEO;", "s->out_format = FMT_MPEG1;", "s->swap_uv = 0;", "if (s->VAR_0->flags & AV_CODEC_FLAG_LOW_DELAY)\ns->low_delay = 1;", "if (s->VAR_0->debug & FF_DEBUG_PICT_INFO)\nav_log(s->VAR_0, AV_LOG_DEBUG, \"vbv buffer: %d, bitrate:%\"PRId64\", aspect_ratio_info: %d \\n\",\ns->VAR_0->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(VncState *VAR_0, VncState *VAR_1)\n{", "VAR_0->tight = VAR_1->tight;", "VAR_0->zlib = VAR_1->zlib;", "VAR_0->hextile = VAR_1->hextile;", "VAR_0->zrle = VAR_1->zrle;", "VAR_0->lossy_rect = VAR_1->lossy_rect;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "S302Context *s = VAR_0->priv_data;", "AVFrame *frame = VAR_1;", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "int VAR_6, VAR_7;", "int VAR_8;", "int VAR_9 = -1;", "int VAR_10 = s302m_parse_frame_header(VAR_0, VAR_4, VAR_5);", "if (VAR_10 < 0)\nreturn VAR_10;", "VAR_5 -= AES3_HEADER_LEN;", "VAR_4 += AES3_HEADER_LEN;", "VAR_6 = (VAR_0->bits_per_raw_sample + 4) / 4;", "frame->nb_samples = 2 * (VAR_5 / VAR_6) / VAR_0->channels;", "if ((VAR_7 = ff_get_buffer(VAR_0, frame, 0)) < 0)\nreturn VAR_7;", "VAR_0->bit_rate = 48000 * VAR_0->channels * (VAR_0->bits_per_raw_sample + 4) +\n32 * 48000 / frame->nb_samples;", "VAR_5 = (frame->nb_samples * VAR_0->channels / 2) * VAR_6;", "if (VAR_0->bits_per_raw_sample == 24) {", "uint32_t *o = (uint32_t *)frame->VAR_1[0];", "for (; VAR_5 > 6; VAR_5 -= 7) {", "*o++ = (ff_reverse[VAR_4[2]] << 24) |\n(ff_reverse[VAR_4[1]] << 16) |\n(ff_reverse[VAR_4[0]] << 8);", "*o++ = (ff_reverse[VAR_4[6] & 0xf0] << 28) |\n(ff_reverse[VAR_4[5]] << 20) |\n(ff_reverse[VAR_4[4]] << 12) |\n(ff_reverse[VAR_4[3] & 0x0f] << 4);", "VAR_4 += 7;", "}", "o = (uint32_t *)frame->VAR_1[0];", "if (VAR_0->channels == 2)\nfor (VAR_8=0; VAR_8<frame->nb_samples * 2 - 6; VAR_8+=2) {", "if (o[VAR_8] || o[VAR_8+1] || o[VAR_8+2] || o[VAR_8+3])\nbreak;", "if (o[VAR_8+4] == 0x96F87200U && o[VAR_8+5] == 0xA54E1F00) {", "VAR_9 = (o[VAR_8+6] >> 16) & 0x1F;", "break;", "}", "}", "} else if (VAR_0->bits_per_raw_sample == 20) {", "uint32_t *o = (uint32_t *)frame->VAR_1[0];", "for (; VAR_5 > 5; VAR_5 -= 6) {", "*o++ = (ff_reverse[VAR_4[2] & 0xf0] << 28) |\n(ff_reverse[VAR_4[1]] << 20) |\n(ff_reverse[VAR_4[0]] << 12);", "*o++ = (ff_reverse[VAR_4[5] & 0xf0] << 28) |\n(ff_reverse[VAR_4[4]] << 20) |\n(ff_reverse[VAR_4[3]] << 12);", "VAR_4 += 6;", "}", "o = (uint32_t *)frame->VAR_1[0];", "if (VAR_0->channels == 2)\nfor (VAR_8=0; VAR_8<frame->nb_samples * 2 - 6; VAR_8+=2) {", "if (o[VAR_8] || o[VAR_8+1] || o[VAR_8+2] || o[VAR_8+3])\nbreak;", "if (o[VAR_8+4] == 0x6F872000U && o[VAR_8+5] == 0x54E1F000) {", "VAR_9 = (o[VAR_8+6] >> 16) & 0x1F;", "break;", "}", "}", "} else {", "uint16_t *o = (uint16_t *)frame->VAR_1[0];", "for (; VAR_5 > 4; VAR_5 -= 5) {", "*o++ = (ff_reverse[VAR_4[1]] << 8) |\nff_reverse[VAR_4[0]];", "*o++ = (ff_reverse[VAR_4[4] & 0xf0] << 12) |\n(ff_reverse[VAR_4[3]] << 4) |\n(ff_reverse[VAR_4[2]] >> 4);", "VAR_4 += 5;", "}", "o = (uint16_t *)frame->VAR_1[0];", "if (VAR_0->channels == 2)\nfor (VAR_8=0; VAR_8<frame->nb_samples * 2 - 6; VAR_8+=2) {", "if (o[VAR_8] || o[VAR_8+1] || o[VAR_8+2] || o[VAR_8+3])\nbreak;", "if (o[VAR_8+4] == 0xF872U && o[VAR_8+5] == 0x4E1F) {", "VAR_9 = (o[VAR_8+6] & 0x1F);", "break;", "}", "}", "}", "if (VAR_9 != -1) {", "if (s->non_pcm_mode == 3) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"S302 non PCM mode with VAR_1 type %d not supported\\n\",\nVAR_9);", "return AVERROR_PATCHWELCOME;", "}", "if (s->non_pcm_mode & 1) {", "return VAR_3->size;", "}", "}", "VAR_0->sample_rate = 48000;", "*VAR_2 = 1;", "return VAR_3->size;", "}" ]

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

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

[ "static gboolean FUNC_0(GIOChannel *chan, GIOCondition cond, void *opaque)\n{", "CharDriverState *chr = opaque;", "TCPCharDriver *s = chr->opaque;", "uint8_t buf[READ_BUF_LEN];", "int VAR_0, VAR_1;", "if (!s->connected || s->max_size <= 0) {", "return FALSE;", "}", "VAR_0 = sizeof(buf);", "if (VAR_0 > s->max_size)\nVAR_0 = s->max_size;", "VAR_1 = tcp_chr_recv(chr, (void *)buf, VAR_0);", "if (VAR_1 == 0) {", "s->connected = 0;", "if (s->listen_chan) {", "s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr);", "}", "if (s->tag) {", "g_source_remove(s->tag);", "s->tag = 0;", "}", "g_io_channel_unref(s->chan);", "s->chan = NULL;", "closesocket(s->fd);", "s->fd = -1;", "qemu_chr_be_event(chr, CHR_EVENT_CLOSED);", "} else if (VAR_1 > 0) {", "if (s->do_telnetopt)\ntcp_chr_process_IAC_bytes(chr, s, buf, &VAR_1);", "if (VAR_1 > 0)\nqemu_chr_be_write(chr, buf, VAR_1);", "}", "return TRUE;", "}" ]

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

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

[ "static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)\n{", "IVShmemState *s = IVSHMEM_COMMON(VAR_0);", "if (!qtest_enabled()) {", "error_report(\"ivshmem is deprecated, please use ivshmem-plain\"\n\" or ivshmem-doorbell instead\");", "}", "if (!!qemu_chr_fe_get_driver(&s->server_chr) + !!s->shmobj != 1) {", "error_setg(VAR_1, \"You must specify either 'shm' or 'chardev'\");", "return;", "}", "if (s->sizearg == NULL) {", "s->legacy_size = 4 << 20;", "} else {", "int64_t size = qemu_strtosz_MiB(s->sizearg, NULL);", "if (size < 0 || (size_t)size != size || !is_power_of_2(size)) {", "error_setg(VAR_1, \"Invalid size %s\", s->sizearg);", "return;", "}", "s->legacy_size = size;", "}", "if (s->role) {", "if (strncmp(s->role, \"peer\", 5) == 0) {", "s->master = ON_OFF_AUTO_OFF;", "} else if (strncmp(s->role, \"master\", 7) == 0) {", "s->master = ON_OFF_AUTO_ON;", "} else {", "error_setg(VAR_1, \"'role' must be 'peer' or 'master'\");", "return;", "}", "} else {", "s->master = ON_OFF_AUTO_AUTO;", "}", "if (s->shmobj) {", "desugar_shm(s);", "}", "pci_config_set_interrupt_pin(VAR_0->config, 1);", "ivshmem_common_realize(VAR_0, VAR_1);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11, 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 95 ], [ 99 ], [ 101 ] ]

[ "void FUNC_0(SubchDev *VAR_0)\n{", "if (!(VAR_0->curr_status.scsw.ctrl & SCSW_STCTL_STATUS_PEND)) {", "S390CPU *cpu = s390_cpu_addr2state(0);", "uint8_t isc = (VAR_0->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ISC) >> 11;", "trace_css_io_interrupt(VAR_0->cssid, VAR_0->ssid, VAR_0->schid,\nVAR_0->curr_status.pmcw.intparm, isc,\n\"(unsolicited)\");", "VAR_0->curr_status.scsw.ctrl &= ~SCSW_CTRL_MASK_STCTL;", "VAR_0->curr_status.scsw.ctrl |=\nSCSW_STCTL_ALERT | SCSW_STCTL_STATUS_PEND;", "s390_io_interrupt(cpu,\ncss_build_subchannel_id(VAR_0),\nVAR_0->schid,\nVAR_0->curr_status.pmcw.intparm,\n(0x80 >> isc) << 24);", "}", "}" ]

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

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

[ "int FUNC_0(const char *VAR_0, hwaddr VAR_1, uint64_t VAR_2)\n{", "uint8_t *compressed_data = NULL;", "uint8_t *data = NULL;", "gsize len;", "ssize_t bytes;", "int VAR_3 = -1;", "if (!g_file_get_contents(VAR_0, (char **) &compressed_data, &len,\nNULL)) {", "goto out;", "}", "if (len < 2 ||\ncompressed_data[0] != 0x1f ||\ncompressed_data[1] != 0x8b) {", "goto out;", "}", "if (VAR_2 > LOAD_IMAGE_MAX_GUNZIP_BYTES) {", "VAR_2 = LOAD_IMAGE_MAX_GUNZIP_BYTES;", "}", "data = g_malloc(VAR_2);", "bytes = gunzip(data, VAR_2, compressed_data, len);", "if (bytes < 0) {", "fprintf(stderr, \"%s: unable to decompress gzipped kernel file\\n\",\nVAR_0);", "goto out;", "}", "rom_add_blob_fixed(VAR_0, data, bytes, VAR_1);", "VAR_3 = bytes;", "out:\ng_free(compressed_data);", "g_free(data);", "return VAR_3;", "}" ]

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

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

[ "static ioreq_t *FUNC_0(XenIOState *state, int vcpu)\n{", "ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu);", "if (req->state != STATE_IOREQ_READY) {", "DPRINTF(\"I/O request not ready: \"\n\"%x, ptr: %x, port: %\"PRIx64\", \"\n\"data: %\"PRIx64\", count: %\" FMT_ioreq_size \", size: %\" FMT_ioreq_size \"\\n\",\nreq->state, req->data_is_ptr, req->addr,\nreq->data, req->count, req->size);", "return NULL;", "}", "xen_rmb();", "req->state = STATE_IOREQ_INPROCESS;", "return req;", "}" ]

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

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

[ "static void FUNC_0(PCIDevice *VAR_0, uint32_t VAR_1,\nuint32_t VAR_2, int VAR_3)\n{", "VFIODevice *vdev = DO_UPCAST(VFIODevice, VAR_0, VAR_0);", "uint32_t val_le = cpu_to_le32(VAR_2);", "DPRINTF(\"%s(%04x:%02x:%02x.%x, @0x%x, 0x%x, VAR_3=0x%x)\\n\", __func__,\nvdev->host.domain, vdev->host.bus, vdev->host.slot,\nvdev->host.function, VAR_1, VAR_2, VAR_3);", "if (pwrite(vdev->fd, &val_le, VAR_3, vdev->config_offset + VAR_1) != VAR_3) {", "error_report(\"%s(%04x:%02x:%02x.%x, 0x%x, 0x%x, 0x%x) failed: %m\",\n__func__, vdev->host.domain, vdev->host.bus,\nvdev->host.slot, vdev->host.function, VAR_1, VAR_2, VAR_3);", "}", "if (VAR_1 < PCI_CONFIG_HEADER_SIZE) {", "pci_default_write_config(VAR_0, VAR_1, VAR_2, VAR_3);", "return;", "}", "if (VAR_0->cap_present & QEMU_PCI_CAP_MSI &&\nranges_overlap(VAR_1, VAR_3, VAR_0->msi_cap, vdev->msi_cap_size)) {", "int VAR_6, VAR_6 = msi_enabled(VAR_0);", "pci_default_write_config(VAR_0, VAR_1, VAR_2, VAR_3);", "VAR_6 = msi_enabled(VAR_0);", "if (!VAR_6 && VAR_6) {", "vfio_enable_msi(vdev);", "} else if (VAR_6 && !VAR_6) {", "vfio_disable_msi(vdev);", "}", "}", "if (VAR_0->cap_present & QEMU_PCI_CAP_MSIX &&\nranges_overlap(VAR_1, VAR_3, VAR_0->msix_cap, MSIX_CAP_LENGTH)) {", "int VAR_6, VAR_6 = msix_enabled(VAR_0);", "pci_default_write_config(VAR_0, VAR_1, VAR_2, VAR_3);", "VAR_6 = msix_enabled(VAR_0);", "if (!VAR_6 && VAR_6) {", "vfio_enable_msix(vdev);", "} else if (VAR_6 && !VAR_6) {", "vfio_disable_msix(vdev);", "}", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25, 27, 29 ], [ 31 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 49, 51 ], [ 53 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79, 81 ], [ 83 ], [ 87 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, BdrvCheckResult *VAR_1,\nBdrvCheckMode VAR_2, uint16_t **VAR_3,\nint64_t *VAR_4)\n{", "BDRVQcowState *s = VAR_0->opaque;", "int64_t i;", "for(i = 0; i < s->refcount_table_size; i++) {", "uint64_t offset, cluster;", "offset = s->VAR_3[i];", "cluster = offset >> s->cluster_bits;", "if (offset_into_cluster(s, offset)) {", "fprintf(stderr, \"ERROR refcount block %\" PRId64 \" is not \"\n\"cluster aligned; refcount table entry corrupted\\n\", i);", "VAR_1->corruptions++;", "continue;", "}", "if (cluster >= *VAR_4) {", "fprintf(stderr, \"ERROR refcount block %\" PRId64\n\" is outside image\\n\", i);", "VAR_1->corruptions++;", "continue;", "}", "if (offset != 0) {", "inc_refcounts(VAR_0, VAR_1, *VAR_3, *VAR_4,\noffset, s->cluster_size);", "if ((*VAR_3)[cluster] != 1) {", "fprintf(stderr, \"%s refcount block %\" PRId64\n\" refcount=%d\\n\",\nVAR_2 & BDRV_FIX_ERRORS ? \"Repairing\" :\n\"ERROR\",\ni, (*VAR_3)[cluster]);", "if (VAR_2 & BDRV_FIX_ERRORS) {", "int64_t new_offset;", "new_offset = realloc_refcount_block(VAR_0, i, offset);", "if (new_offset < 0) {", "VAR_1->corruptions++;", "continue;", "}", "if ((new_offset >> s->cluster_bits) >= *VAR_4) {", "int old_nb_clusters = *VAR_4;", "*VAR_4 = (new_offset >> s->cluster_bits) + 1;", "*VAR_3 = g_renew(uint16_t, *VAR_3,\n*VAR_4);", "memset(&(*VAR_3)[old_nb_clusters], 0,\n(*VAR_4 - old_nb_clusters) *\nsizeof(uint16_t));", "}", "(*VAR_3)[cluster]--;", "inc_refcounts(VAR_0, VAR_1, *VAR_3, *VAR_4,\nnew_offset, s->cluster_size);", "VAR_1->corruptions_fixed++;", "} else {", "VAR_1->corruptions++;", "}", "}", "}", "}", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63, 65, 67, 69, 71 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 95 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107, 109, 111 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ] ]

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "TCGv t0;", "gen_set_access_type(VAR_0, ACCESS_RES);", "t0 = tcg_temp_local_new();", "gen_addr_reg_index(VAR_0, t0);", "gen_check_align(VAR_0, t0, 0x03);", "gen_qemu_ld32u(VAR_0, cpu_gpr[rD(VAR_0->opcode)], t0);", "tcg_gen_mov_tl(cpu_reserve, t0);", "tcg_temp_free(t0);", "}" ]

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

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