Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static S390PCIBusDevice *FUNC_0(uint16_t uid)\n{", "int VAR_0;", "S390PCIBusDevice *pbdev;", "S390pciState *s = s390_get_phb();", "for (VAR_0 = 0; VAR_0 < PCI_SLOT_MAX; VAR_0++) {", "pbdev = s->pbdev[VAR_0];", "if (!pbdev) {", "continue;", "}", "if (pbdev->uid == uid) {", "return pbdev;", "}", "}", "return NULL;", "}" ]

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

[ "static int FUNC_0(USBHostDevice *VAR_0, USBPacket *VAR_1)\n{", "static const int VAR_2[] = {", "[USB_ENDPOINT_XFER_CONTROL] = USBDEVFS_URB_TYPE_CONTROL,\n[USB_ENDPOINT_XFER_ISOC] = USBDEVFS_URB_TYPE_ISO,\n[USB_ENDPOINT_XFER_BULK] = USBDEVFS_URB_TYPE_BULK,\n[USB_ENDPOINT_XFER_INT] = USBDEVFS_URB_TYPE_INTERRUPT,\n};", "uint8_t type = usb_ep_get_type(&VAR_0->dev, VAR_1->pid, VAR_1->devep);", "assert(type < ARRAY_SIZE(VAR_2));", "return VAR_2[type];", "}" ]

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

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

[ "static void FUNC_0(SCSIRequest *VAR_0)\n{", "SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, VAR_0, VAR_0);", "DPRINTF(\"Cancel tag=0x%x\\n\", VAR_0->tag);", "if (r->VAR_0.aiocb) {", "bdrv_aio_cancel(r->VAR_0.aiocb);", "scsi_req_unref(&r->VAR_0);", "}", "r->VAR_0.aiocb = NULL;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ] ]

[ "static uint32_t FUNC_0(sPAPRDRConnector *drc)\n{", "if (!drc->dev ||\ndrc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {", "return RTAS_OUT_NO_SUCH_INDICATOR;", "}", "drc->isolation_state = SPAPR_DR_ISOLATION_STATE_UNISOLATED;", "return RTAS_OUT_SUCCESS;", "}" ]

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

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

[ "void FUNC_0(const char *VAR_0, const char *VAR_1,\nconst char *VAR_2, enum MirrorSyncMode VAR_3,\nbool VAR_4, int64_t VAR_5,\nbool VAR_6,\nBlockdevOnError VAR_7,\nbool VAR_8,\nBlockdevOnError VAR_9,\nBlockJobTxn *VAR_10, Error **VAR_11)\n{", "BlockBackend *blk;", "BlockDriverState *bs;", "BlockDriverState *target_bs;", "Error *local_err = NULL;", "AioContext *aio_context;", "if (!VAR_4) {", "VAR_5 = 0;", "}", "if (!VAR_6) {", "VAR_7 = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_8) {", "VAR_9 = BLOCKDEV_ON_ERROR_REPORT;", "}", "blk = blk_by_name(VAR_1);", "if (!blk) {", "error_setg(VAR_11, \"Device '%s' not found\", VAR_1);", "return;", "}", "aio_context = blk_get_aio_context(blk);", "aio_context_acquire(aio_context);", "if (!blk_is_available(blk)) {", "error_setg(VAR_11, \"Device '%s' has no medium\", VAR_1);", "goto out;", "}", "bs = blk_bs(blk);", "target_bs = bdrv_lookup_bs(VAR_2, VAR_2, VAR_11);", "if (!target_bs) {", "goto out;", "}", "if (bdrv_get_aio_context(target_bs) != aio_context) {", "if (!bdrv_has_blk(target_bs)) {", "bdrv_set_aio_context(target_bs, aio_context);", "} else {", "error_setg(VAR_11, \"Target is attached to a different thread from \"\n\"source.\");", "goto out;", "}", "}", "backup_start(VAR_0, bs, target_bs, VAR_5, VAR_3, NULL, VAR_7,\nVAR_9, block_job_cb, bs, VAR_10, &local_err);", "if (local_err != NULL) {", "error_propagate(VAR_11, local_err);", "}", "out:\naio_context_release(aio_context);", "}" ]

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

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

[ "BlockDeviceInfo *FUNC_0(BlockBackend *blk,\nBlockDriverState *bs, Error **errp)\n{", "ImageInfo **p_image_info;", "BlockDriverState *bs0;", "BlockDeviceInfo *info = g_malloc0(sizeof(*info));", "info->file = g_strdup(bs->filename);", "info->ro = bs->read_only;", "info->drv = g_strdup(bs->drv->format_name);", "info->encrypted = bs->encrypted;", "info->encryption_key_missing = false;", "info->cache = g_new(BlockdevCacheInfo, 1);", "*info->cache = (BlockdevCacheInfo) {", ".writeback = blk ? blk_enable_write_cache(blk) : true,\n.direct = !!(bs->open_flags & BDRV_O_NOCACHE),\n.no_flush = !!(bs->open_flags & BDRV_O_NO_FLUSH),\n};", "if (bs->node_name[0]) {", "info->has_node_name = true;", "info->node_name = g_strdup(bs->node_name);", "}", "if (bs->backing_file[0]) {", "info->has_backing_file = true;", "info->backing_file = g_strdup(bs->backing_file);", "}", "info->detect_zeroes = bs->detect_zeroes;", "if (blk && blk_get_public(blk)->throttle_state) {", "ThrottleConfig cfg;", "throttle_group_get_config(blk, &cfg);", "info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg;", "info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg;", "info->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE].avg;", "info->iops = cfg.buckets[THROTTLE_OPS_TOTAL].avg;", "info->iops_rd = cfg.buckets[THROTTLE_OPS_READ].avg;", "info->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE].avg;", "info->has_bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max;", "info->bps_max = cfg.buckets[THROTTLE_BPS_TOTAL].max;", "info->has_bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max;", "info->bps_rd_max = cfg.buckets[THROTTLE_BPS_READ].max;", "info->has_bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max;", "info->bps_wr_max = cfg.buckets[THROTTLE_BPS_WRITE].max;", "info->has_iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max;", "info->iops_max = cfg.buckets[THROTTLE_OPS_TOTAL].max;", "info->has_iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max;", "info->iops_rd_max = cfg.buckets[THROTTLE_OPS_READ].max;", "info->has_iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max;", "info->iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE].max;", "info->has_bps_max_length = info->has_bps_max;", "info->bps_max_length =\ncfg.buckets[THROTTLE_BPS_TOTAL].burst_length;", "info->has_bps_rd_max_length = info->has_bps_rd_max;", "info->bps_rd_max_length =\ncfg.buckets[THROTTLE_BPS_READ].burst_length;", "info->has_bps_wr_max_length = info->has_bps_wr_max;", "info->bps_wr_max_length =\ncfg.buckets[THROTTLE_BPS_WRITE].burst_length;", "info->has_iops_max_length = info->has_iops_max;", "info->iops_max_length =\ncfg.buckets[THROTTLE_OPS_TOTAL].burst_length;", "info->has_iops_rd_max_length = info->has_iops_rd_max;", "info->iops_rd_max_length =\ncfg.buckets[THROTTLE_OPS_READ].burst_length;", "info->has_iops_wr_max_length = info->has_iops_wr_max;", "info->iops_wr_max_length =\ncfg.buckets[THROTTLE_OPS_WRITE].burst_length;", "info->has_iops_size = cfg.op_size;", "info->iops_size = cfg.op_size;", "info->has_group = true;", "info->group = g_strdup(throttle_group_get_name(blk));", "}", "info->write_threshold = bdrv_write_threshold_get(bs);", "bs0 = bs;", "p_image_info = &info->image;", "info->backing_file_depth = 0;", "while (1) {", "Error *local_err = NULL;", "bdrv_query_image_info(bs0, p_image_info, &local_err);", "if (local_err) {", "error_propagate(errp, local_err);", "qapi_free_BlockDeviceInfo(info);", "return NULL;", "}", "if (bs0->drv && bs0->backing) {", "info->backing_file_depth++;", "bs0 = bs0->backing->bs;", "(*p_image_info)->has_backing_image = true;", "p_image_info = &((*p_image_info)->backing_image);", "} else {", "break;", "}", "while (blk && bs0 && bs0->drv && bs0->implicit) {", "bs0 = backing_bs(bs0);", "}", "}", "return info;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31, 33, 35, 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133, 135 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 147, 149 ], [ 151 ], [ 153, 155 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 233 ], [ 235 ] ]

[ "void FUNC_0(QEMUClockType VAR_0,\nNotifier *VAR_1)\n{", "notifier_remove(VAR_1);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0 (int VAR_0, int VAR_1,\nconst char *VAR_2, DisplayState *VAR_3,\nconst char **VAR_4, int VAR_5,\nconst char *VAR_6,\nconst char *VAR_7,\nconst char *VAR_8,\nconst char *VAR_9)\n{", "CPUState *env = NULL, *envs[MAX_CPUS];", "char VAR_10[1024];", "qemu_irq *pic, **openpic_irqs;", "int VAR_11;", "int VAR_12, VAR_13;", "unsigned long VAR_14, VAR_15;", "uint32_t kernel_base, kernel_size, initrd_base, initrd_size;", "PCIBus *pci_bus;", "nvram_t nvram;", "#if 0\nMacIONVRAMState *nvr;", "int nvram_mem_index;", "#endif\nm48t59_t *m48t59;", "int VAR_16, VAR_17;", "qemu_irq *dummy_irq;", "int VAR_18, VAR_19, VAR_20;", "int VAR_21[2];", "int VAR_22 = VAR_2[0];", "VAR_12 = (VAR_6 != NULL);", "if (VAR_9 == NULL)\nVAR_9 = \"default\";", "for (VAR_13 = 0; VAR_13 < smp_cpus; VAR_13++) {", "env = cpu_init(VAR_9);", "if (!env) {", "fprintf(stderr, \"Unable to find PowerPC CPU definition\\n\");", "exit(1);", "}", "cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);", "#if 0\nenv->osi_call = vga_osi_call;", "#endif\nqemu_register_reset(&cpu_ppc_reset, env);", "register_savevm(\"cpu\", 0, 3, cpu_save, cpu_load, env);", "envs[VAR_13] = env;", "}", "if (env->nip < 0xFFF80000) {", "cpu_abort(env, \"Mac99 hardware can not handle 1 MB BIOS\\n\");", "}", "cpu_register_physical_memory(0, VAR_0, IO_MEM_RAM);", "VAR_14 = VAR_0 + VAR_1;", "if (bios_name == NULL)\nbios_name = BIOS_FILENAME;", "snprintf(VAR_10, sizeof(VAR_10), \"%s/%s\", bios_dir, bios_name);", "VAR_17 = load_image(VAR_10, phys_ram_base + VAR_14);", "if (VAR_17 < 0 || VAR_17 > BIOS_SIZE) {", "cpu_abort(env, \"qemu: could not load PowerPC bios '%s'\\n\", VAR_10);", "exit(1);", "}", "VAR_17 = (VAR_17 + 0xfff) & ~0xfff;", "if (VAR_17 > 0x00080000) {", "cpu_abort(env, \"Mac99 hardware can not handle 1 MB BIOS\\n\");", "}", "cpu_register_physical_memory((uint32_t)(-VAR_17),\nVAR_17, VAR_14 | IO_MEM_ROM);", "VAR_15 = VAR_14 + VAR_17;", "snprintf(VAR_10, sizeof(VAR_10), \"%s/%s\", bios_dir, VGABIOS_FILENAME);", "VAR_16 = load_image(VAR_10, phys_ram_base + VAR_15 + 8);", "if (VAR_16 < 0) {", "fprintf(stderr, \"qemu: warning: could not load VGA bios '%s'\\n\", VAR_10);", "VAR_16 = 0;", "} else {", "phys_ram_base[VAR_15] = 'N';", "phys_ram_base[VAR_15 + 1] = 'D';", "phys_ram_base[VAR_15 + 2] = 'R';", "phys_ram_base[VAR_15 + 3] = 'V';", "cpu_to_be32w((uint32_t *)(phys_ram_base + VAR_15 + 4),\nVAR_16);", "VAR_16 += 8;", "}", "VAR_16 = (VAR_16 + 0xfff) & ~0xfff;", "if (VAR_12) {", "kernel_base = KERNEL_LOAD_ADDR;", "kernel_size = load_image(VAR_6, phys_ram_base + kernel_base);", "if (kernel_size < 0) {", "cpu_abort(env, \"qemu: could not load kernel '%s'\\n\",\nVAR_6);", "exit(1);", "}", "if (VAR_8) {", "initrd_base = INITRD_LOAD_ADDR;", "initrd_size = load_image(VAR_8,\nphys_ram_base + initrd_base);", "if (initrd_size < 0) {", "cpu_abort(env, \"qemu: could not load initial ram disk '%s'\\n\",\nVAR_8);", "exit(1);", "}", "} else {", "initrd_base = 0;", "initrd_size = 0;", "}", "VAR_22 = 'm';", "} else {", "kernel_base = 0;", "kernel_size = 0;", "initrd_base = 0;", "initrd_size = 0;", "}", "isa_mem_base = 0x80000000;", "isa_mmio_init(0xf2000000, 0x00800000);", "VAR_11 = cpu_register_io_memory(0, unin_read, unin_write, NULL);", "cpu_register_physical_memory(0xf8000000, 0x00001000, VAR_11);", "openpic_irqs = qemu_mallocz(smp_cpus * sizeof(qemu_irq *));", "openpic_irqs[0] =\nqemu_mallocz(smp_cpus * sizeof(qemu_irq) * OPENPIC_OUTPUT_NB);", "for (VAR_13 = 0; VAR_13 < smp_cpus; VAR_13++) {", "switch (PPC_INPUT(env)) {", "case PPC_FLAGS_INPUT_6xx:\nopenpic_irqs[VAR_13] = openpic_irqs[0] + (VAR_13 * OPENPIC_OUTPUT_NB);", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_INT] =\n((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT];", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_CINT] =\n((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT];", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_MCK] =\n((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_MCP];", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_DEBUG] = NULL;", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_RESET] =\n((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_HRESET];", "break;", "#if defined(TARGET_PPC64)\ncase PPC_FLAGS_INPUT_970:\nopenpic_irqs[VAR_13] = openpic_irqs[0] + (VAR_13 * OPENPIC_OUTPUT_NB);", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_INT] =\n((qemu_irq *)env->irq_inputs)[PPC970_INPUT_INT];", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_CINT] =\n((qemu_irq *)env->irq_inputs)[PPC970_INPUT_INT];", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_MCK] =\n((qemu_irq *)env->irq_inputs)[PPC970_INPUT_MCP];", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_DEBUG] = NULL;", "openpic_irqs[VAR_13][OPENPIC_OUTPUT_RESET] =\n((qemu_irq *)env->irq_inputs)[PPC970_INPUT_HRESET];", "break;", "#endif\ndefault:\ncpu_abort(env, \"Bus model not supported on mac99 machine\\n\");", "exit(1);", "}", "}", "pic = openpic_init(NULL, &VAR_18, smp_cpus, openpic_irqs, NULL);", "pci_bus = pci_pmac_init(pic);", "pci_vga_init(pci_bus, VAR_3, phys_ram_base + VAR_0,\nVAR_0, VAR_1,\nVAR_15, VAR_16);", "dummy_irq = i8259_init(NULL);", "serial_init(0x3f8, dummy_irq[4], serial_hds[0]);", "for(VAR_13 = 0; VAR_13 < nb_nics; VAR_13++) {", "if (!nd_table[VAR_13].model)\nnd_table[VAR_13].model = \"ne2k_pci\";", "pci_nic_init(pci_bus, &nd_table[VAR_13], -1);", "}", "#if 1\nVAR_21[0] = pmac_ide_init(&bs_table[0], pic[0x13]);", "VAR_21[1] = pmac_ide_init(&bs_table[2], pic[0x14]);", "#else\npci_cmd646_ide_init(pci_bus, &bs_table[0], 0);", "#endif\ncuda_init(&VAR_20, pic[0x19]);", "adb_kbd_init(&adb_bus);", "adb_mouse_init(&adb_bus);", "dbdma_init(&VAR_19);", "macio_init(pci_bus, 0x0022, 0, VAR_18, VAR_19,\nVAR_20, NULL, 2, VAR_21);", "if (usb_enabled) {", "usb_ohci_init_pci(pci_bus, 3, -1);", "}", "if (graphic_depth != 15 && graphic_depth != 32 && graphic_depth != 8)\ngraphic_depth = 15;", "#if 0\nnvr = macio_nvram_init(&nvram_mem_index, 0x2000);", "pmac_format_nvram_partition(nvr, 0x2000);", "macio_nvram_map(nvr, 0xFFF04000);", "nvram.opaque = nvr;", "nvram.read_fn = &macio_nvram_read;", "nvram.write_fn = &macio_nvram_write;", "#else\nm48t59 = m48t59_init(dummy_irq[8], 0xFFF04000, 0x0074, NVRAM_SIZE, 59);", "nvram.opaque = m48t59;", "nvram.read_fn = &m48t59_read;", "nvram.write_fn = &m48t59_write;", "#endif\nPPC_NVRAM_set_params(&nvram, NVRAM_SIZE, \"MAC99\", VAR_0,\nVAR_22, kernel_base, kernel_size,\nVAR_7,\ninitrd_base, initrd_size,\n0,\ngraphic_width, graphic_height, graphic_depth);", "register_ioport_write(0x0F00, 4, 1, &PPC_debug_write, NULL);", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13, 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83, 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 107 ], [ 109 ], [ 115 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 171 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227, 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 259 ], [ 265 ], [ 271 ], [ 273 ], [ 277 ], [ 279, 281 ], [ 283 ], [ 291 ], [ 293, 295 ], [ 297, 299 ], [ 301, 303 ], [ 305, 307 ], [ 311 ], [ 315, 317 ], [ 319 ], [ 321, 323, 325 ], [ 327, 329 ], [ 331, 333 ], [ 335, 337 ], [ 341 ], [ 345, 347 ], [ 349 ], [ 351, 353, 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 369, 371, 373 ], [ 379 ], [ 385 ], [ 387 ], [ 389, 391 ], [ 393 ], [ 395 ], [ 397, 399 ], [ 401 ], [ 403, 405 ], [ 407, 411 ], [ 415 ], [ 417 ], [ 421 ], [ 425, 427 ], [ 431 ], [ 433 ], [ 435 ], [ 439, 441 ], [ 443, 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 459, 461 ], [ 463 ], [ 465 ], [ 467 ], [ 469, 471, 473, 475, 477, 481, 483 ], [ 491 ], [ 493 ] ]

[ "FUNC_0(POWER5P)(ObjectClass *oc, void *data)\n{", "DeviceClass *dc = DEVICE_CLASS(oc);", "PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);", "dc->fw_name = \"PowerPC,POWER5\";", "dc->desc = \"POWER5+\";", "pcc->init_proc = init_proc_power5plus;", "pcc->check_pow = check_pow_970FX;", "pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |\nPPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |\nPPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |\nPPC_FLOAT_STFIWX |\nPPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |\nPPC_MEM_SYNC | PPC_MEM_EIEIO |\nPPC_MEM_TLBIE | PPC_MEM_TLBSYNC |\nPPC_64B |\nPPC_SEGMENT_64B | PPC_SLBI;", "pcc->msr_mask = (1ull << MSR_SF) |\n(1ull << MSR_VR) |\n(1ull << MSR_POW) |\n(1ull << MSR_EE) |\n(1ull << MSR_PR) |\n(1ull << MSR_FP) |\n(1ull << MSR_ME) |\n(1ull << MSR_FE0) |\n(1ull << MSR_SE) |\n(1ull << MSR_DE) |\n(1ull << MSR_FE1) |\n(1ull << MSR_IR) |\n(1ull << MSR_DR) |\n(1ull << MSR_PMM) |\n(1ull << MSR_RI);", "pcc->mmu_model = POWERPC_MMU_64B;", "#if defined(CONFIG_SOFTMMU)\npcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;", "#endif\npcc->excp_model = POWERPC_EXCP_970;", "pcc->bus_model = PPC_FLAGS_INPUT_970;", "pcc->bfd_mach = bfd_mach_ppc64;", "pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |\nPOWERPC_FLAG_BE | POWERPC_FLAG_PMM |\nPOWERPC_FLAG_BUS_CLK;", "pcc->l1_dcache_size = 0x8000;", "pcc->l1_icache_size = 0x10000;", "}" ]

[ 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, 31, 33, 35 ], [ 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65 ], [ 67 ], [ 69, 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81, 83, 85 ], [ 87 ], [ 89 ], [ 91 ] ]

[ "static unsigned int FUNC_0(DisasContext *VAR_0)\n{", "TCGv t0;", "DIS(fprintf (logfile, \"addi.%c $r%u, $r%u, $acr\\n\",\nmemsize_char(memsize_zz(VAR_0)), VAR_0->op2, VAR_0->op1));", "cris_cc_mask(VAR_0, 0);", "t0 = tcg_temp_new(TCG_TYPE_TL);", "tcg_gen_shl_tl(t0, cpu_R[VAR_0->op2], tcg_const_tl(VAR_0->zzsize));", "tcg_gen_add_tl(cpu_R[R_ACR], cpu_R[VAR_0->op1], t0);", "tcg_temp_free(t0);", "return 2;", "}" ]

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

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

[ "static void FUNC_0(TestOutputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "UserDefTwoList *p, *head = NULL;", "const char VAR_2[] = \"foo bar\";", "int VAR_3, VAR_4 = 1024;", "for (VAR_3 = 0; VAR_3 < VAR_4; VAR_3++) {", "p = g_malloc0(sizeof(*p));", "p->value = g_malloc0(sizeof(*p->value));", "p->value->string0 = g_strdup(VAR_2);", "p->value->dict1 = g_new0(UserDefTwoDict, 1);", "p->value->dict1->string1 = g_strdup(VAR_2);", "p->value->dict1->dict2 = g_new0(UserDefTwoDictDict, 1);", "p->value->dict1->dict2->userdef = g_new0(UserDefOne, 1);", "p->value->dict1->dict2->userdef->VAR_2 = g_strdup(VAR_2);", "p->value->dict1->dict2->userdef->integer = 42;", "p->value->dict1->dict2->VAR_2 = g_strdup(VAR_2);", "p->value->dict1->has_dict3 = false;", "p->next = head;", "head = p;", "}", "qapi_free_UserDefTwoList(head);", "}" ]

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

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

[ "void FUNC_0(BlockDriverState *VAR_0, const char *VAR_1)\n{", "assert(!VAR_0->throttle_state);", "throttle_group_register_bs(VAR_0, VAR_1);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static bool FUNC_0(const void *buf, size_t len)\n{", "uintptr_t ibuf = (uintptr_t)buf;", "#ifdef CONFIG_AVX2_OPT\nif (len % 128 == 0 && ibuf % 32 == 0 && (cpuid_cache & CACHE_AVX2)) {", "return buffer_zero_avx2(buf, len);", "}", "if (len % 64 == 0 && ibuf % 16 == 0 && (cpuid_cache & CACHE_SSE4)) {", "return buffer_zero_sse4(buf, len);", "}", "#endif\nif (len % 64 == 0 && ibuf % 16 == 0 && (cpuid_cache & CACHE_SSE2)) {", "return buffer_zero_sse2(buf, len);", "}", "return buffer_zero_int(buf, len);", "}" ]

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

[ "static void FUNC_0 (void *VAR_0, uint32_t VAR_1)\n{", "CPUState *env = VAR_0;", "ppc_tb_t *tb_env = env->tb_env;", "tb_env->tb_freq = VAR_1;", "tb_env->decr_freq = VAR_1;", "_cpu_ppc_store_decr(env, 0xFFFFFFFF, 0xFFFFFFFF, 0);", "#if defined(TARGET_PPC64H)\n_cpu_ppc_store_hdecr(env, 0xFFFFFFFF, 0xFFFFFFFF, 0);", "cpu_ppc_store_purr(env, 0x0000000000000000ULL);", "#endif\n}" ]

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

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

[ "static int FUNC_0(AVFilterContext *VAR_0, FilterParam *VAR_1, const char *VAR_2, int VAR_3)\n{", "int VAR_4;", "const char *VAR_5 = VAR_1->amount == 0 ? \"none\" : VAR_1->amount < 0 ? \"blur\" : \"sharpen\";", "if (!(VAR_1->msize_x & VAR_1->msize_y & 1)) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Invalid even size for %s matrix size %dx%d\\n\",\nVAR_2, VAR_1->msize_x, VAR_1->msize_y);", "return AVERROR(EINVAL);", "}", "av_log(VAR_0, AV_LOG_VERBOSE, \"VAR_5:%s type:%s msize_x:%d msize_y:%d amount:%0.2f\\n\",\nVAR_5, VAR_2, VAR_1->msize_x, VAR_1->msize_y, VAR_1->amount / 65535.0);", "for (VAR_4 = 0; VAR_4 < 2 * VAR_1->steps_y; VAR_4++)", "VAR_1->sc[VAR_4] = av_malloc(sizeof(*(VAR_1->sc[VAR_4])) * (VAR_3 + 2 * VAR_1->steps_x));", "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 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ] ]

[ "static void FUNC_0(AVFormatContext *VAR_0,\nAVOutputStream *VAR_1,\nAVInputStream *VAR_2,\nAVFrame *VAR_3,\nint *VAR_4)\n{", "int VAR_5, VAR_6, VAR_7;", "AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;", "AVFrame picture_crop_temp, picture_pad_temp;", "AVCodecContext *enc, *dec;", "avcodec_get_frame_defaults(&picture_crop_temp);", "avcodec_get_frame_defaults(&picture_pad_temp);", "enc = VAR_1->st->codec;", "dec = VAR_2->st->codec;", "VAR_5 = 1;", "*VAR_4 = 0;", "if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){", "double VAR_8;", "VAR_8 = get_sync_ipts(VAR_1) / av_q2d(enc->time_base) - VAR_1->sync_opts;", "if (VAR_8 < -1.1)\nVAR_5 = 0;", "else if (video_sync_method == 2)\nVAR_1->sync_opts= lrintf(get_sync_ipts(VAR_1) / av_q2d(enc->time_base));", "else if (VAR_8 > 1.1)\nVAR_5 = lrintf(VAR_8);", "if (VAR_5 == 0){", "++nb_frames_drop;", "if (verbose>2)\nfprintf(stderr, \"*** drop!\\n\");", "}else if (VAR_5 > 1) {", "nb_frames_dup += VAR_5;", "if (verbose>2)\nfprintf(stderr, \"*** %d dup!\\n\", VAR_5-1);", "}", "}else", "VAR_1->sync_opts= lrintf(get_sync_ipts(VAR_1) / av_q2d(enc->time_base));", "VAR_5= FFMIN(VAR_5, max_frames[CODEC_TYPE_VIDEO] - VAR_1->frame_number);", "if (VAR_5 <= 0)\nreturn;", "if (VAR_1->video_crop) {", "if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)VAR_3, dec->pix_fmt, VAR_1->topBand, VAR_1->leftBand) < 0) {", "av_log(NULL, AV_LOG_ERROR, \"error cropping picture\\n\");", "if (exit_on_error)\nav_exit(1);", "return;", "}", "formatted_picture = &picture_crop_temp;", "} else {", "formatted_picture = VAR_3;", "}", "final_picture = formatted_picture;", "padding_src = formatted_picture;", "resampling_dst = &VAR_1->pict_tmp;", "if (VAR_1->video_pad) {", "final_picture = &VAR_1->pict_tmp;", "if (VAR_1->video_resample) {", "if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, VAR_1->padtop, VAR_1->padleft) < 0) {", "av_log(NULL, AV_LOG_ERROR, \"error padding picture\\n\");", "if (exit_on_error)\nav_exit(1);", "return;", "}", "resampling_dst = &picture_pad_temp;", "}", "}", "if (VAR_1->video_resample) {", "padding_src = NULL;", "final_picture = &VAR_1->pict_tmp;", "sws_scale(VAR_1->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,\n0, VAR_1->resample_height, resampling_dst->data, resampling_dst->linesize);", "}", "if (VAR_1->video_pad) {", "av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,\nenc->height, enc->width, enc->pix_fmt,\nVAR_1->padtop, VAR_1->padbottom, VAR_1->padleft, VAR_1->padright, padcolor);", "}", "for(VAR_6=0;VAR_6<VAR_5;VAR_6++) {", "AVPacket pkt;", "av_init_packet(&pkt);", "pkt.stream_index= VAR_1->index;", "if (VAR_0->oformat->flags & AVFMT_RAWPICTURE) {", "AVFrame* old_frame = enc->coded_frame;", "enc->coded_frame = dec->coded_frame;", "pkt.data= (uint8_t *)final_picture;", "pkt.size= sizeof(AVPicture);", "pkt.pts= av_rescale_q(VAR_1->sync_opts, enc->time_base, VAR_1->st->time_base);", "pkt.flags |= PKT_FLAG_KEY;", "write_frame(VAR_0, &pkt, VAR_1->st->codec, bitstream_filters[VAR_1->file_index][pkt.stream_index]);", "enc->coded_frame = old_frame;", "} else {", "AVFrame big_picture;", "big_picture= *final_picture;", "big_picture.interlaced_frame = VAR_3->interlaced_frame;", "if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){", "if(top_field_first == -1)\nbig_picture.top_field_first = VAR_3->top_field_first;", "else\nbig_picture.top_field_first = top_field_first;", "}", "if (same_quality) {", "big_picture.quality = VAR_2->st->quality;", "}else", "big_picture.quality = VAR_1->st->quality;", "if(!me_threshold)\nbig_picture.pict_type = 0;", "big_picture.pts= VAR_1->sync_opts;", "VAR_7 = avcodec_encode_video(enc,\nbit_buffer, bit_buffer_size,\n&big_picture);", "if (VAR_7 == -1) {", "fprintf(stderr, \"Video encoding failed\\n\");", "av_exit(1);", "}", "if(VAR_7>0){", "pkt.data= bit_buffer;", "pkt.size= VAR_7;", "if(enc->coded_frame->pts != AV_NOPTS_VALUE)\npkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, VAR_1->st->time_base);", "if(enc->coded_frame->key_frame)\npkt.flags |= PKT_FLAG_KEY;", "write_frame(VAR_0, &pkt, VAR_1->st->codec, bitstream_filters[VAR_1->file_index][pkt.stream_index]);", "*VAR_4 = VAR_7;", "video_size += VAR_7;", "if (VAR_1->logfile && enc->stats_out) {", "fprintf(VAR_1->logfile, \"%VAR_0\", enc->stats_out);", "}", "}", "}", "VAR_1->sync_opts++;", "VAR_1->frame_number++;", "}", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 37 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 53, 55 ], [ 57, 59 ], [ 61, 63 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93, 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 169 ], [ 171, 173, 175 ], [ 177 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 225 ], [ 231 ], [ 233 ], [ 235, 237 ], [ 239, 241 ], [ 243 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259, 261 ], [ 265 ], [ 271, 273, 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 287 ], [ 289 ], [ 291 ], [ 293, 295 ], [ 305, 307 ], [ 309 ], [ 311 ], [ 313 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ] ]

[ "static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "cpu_outl(VAR_1 & IOPORTS_MASK, bswap32(VAR_2));", "}" ]

[ 0, 0, 0 ]

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

[ "FUNC_0(VncState *VAR_0, int VAR_1, int VAR_2)\n{", "int VAR_3;", "int VAR_4, VAR_5, VAR_6, VAR_7;", "uint c;", "uint stats[256];", "int VAR_8 = 0;", "int VAR_9, VAR_10[3];", "uint errors;", "unsigned char *VAR_11 = VAR_0->tight.buffer;", "VAR_3 = !!(VAR_0->clientds.flags & QEMU_BIG_ENDIAN_FLAG);", "memset(stats, 0, sizeof (stats));", "for (VAR_5 = 0, VAR_4 = 0; VAR_5 < VAR_2 && VAR_4 < VAR_1;) {", "for (VAR_6 = 0; VAR_6 < VAR_2 - VAR_5 && VAR_6 < VAR_1 - VAR_4 - VNC_TIGHT_DETECT_SUBROW_WIDTH;", "VAR_6++) {", "for (c = 0; c < 3; c++) {", "VAR_10[c] = VAR_11[((VAR_5+VAR_6)*VAR_1+VAR_4+VAR_6)*4+VAR_3+c] & 0xFF;", "}", "for (VAR_7 = 1; VAR_7 <= VNC_TIGHT_DETECT_SUBROW_WIDTH; VAR_7++) {", "for (c = 0; c < 3; c++) {", "VAR_9 = VAR_11[((VAR_5+VAR_6)*VAR_1+VAR_4+VAR_6+VAR_7)*4+VAR_3+c] & 0xFF;", "stats[abs(VAR_9 - VAR_10[c])]++;", "VAR_10[c] = VAR_9;", "}", "VAR_8++;", "}", "}", "if (VAR_1 > VAR_2) {", "VAR_4 += VAR_2;", "VAR_5 = 0;", "} else {", "VAR_4 = 0;", "VAR_5 += VAR_1;", "}", "}", "if (stats[0] * 33 / VAR_8 >= 95) {", "return 0;", "}", "errors = 0;", "for (c = 1; c < 8; c++) {", "errors += stats[c] * (c * c);", "if (stats[c] == 0 || stats[c] > stats[c-1] * 2) {", "return 0;", "}", "}", "for (; c < 256; c++) {", "errors += stats[c] * (c * c);", "}", "errors /= (VAR_8 * 3 - stats[0]);", "return errors;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ] ]

[ "static void FUNC_0(CPUARMState *VAR_0, const ARMCPRegInfo *VAR_1,\nuint64_t VAR_2)\n{", "VAR_0->cp15.c0_cssel = VAR_2 & 0xf;", "}" ]

[ 0, 0, 0 ]

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

[ "bool FUNC_0(struct NetTxPkt *pkt, NetClientState *nc)\n{", "assert(pkt);", "if (!pkt->has_virt_hdr &&\npkt->virt_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {", "net_tx_pkt_do_sw_csum(pkt);", "}", "if (VIRTIO_NET_HDR_GSO_NONE != pkt->virt_hdr.gso_type) {", "if (pkt->payload_len >\nETH_MAX_IP_DGRAM_LEN -\npkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len) {", "return false;", "}", "}", "if (pkt->has_virt_hdr ||\npkt->virt_hdr.gso_type == VIRTIO_NET_HDR_GSO_NONE) {", "qemu_sendv_packet(nc, pkt->vec,\npkt->payload_frags + NET_TX_PKT_PL_START_FRAG);", "return true;", "}", "return net_tx_pkt_do_sw_fragmentation(pkt, nc);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 27 ], [ 29, 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43, 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ] ]

[ "static int FUNC_0 (CPUState *VAR_0, mmu_ctx_t *VAR_1,\ntarget_ulong VAR_2, int VAR_3, int VAR_4)\n{", "ppcemb_tlb_t *tlb;", "target_phys_addr_t raddr;", "int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;", "VAR_6 = -1;", "raddr = (target_phys_addr_t)-1ULL;", "VAR_9 = msr_pr;", "for (VAR_5 = 0; VAR_5 < VAR_0->nb_tlb; VAR_5++) {", "tlb = &VAR_0->tlb[VAR_5].tlbe;", "if (ppcemb_tlb_check(VAR_0, tlb, &raddr, VAR_2,\nVAR_0->spr[SPR_40x_PID], 0, VAR_5) < 0)\ncontinue;", "VAR_7 = (tlb->attr >> 4) & 0xF;", "VAR_8 = (VAR_0->spr[SPR_40x_ZPR] >> (28 - (2 * VAR_7))) & 0x3;", "LOG_SWTLB(\"%s: TLB %d VAR_7 %d VAR_8 %d VAR_3 %d attr %08x\\n\",\n__func__, VAR_5, VAR_7, VAR_8, VAR_3, tlb->attr);", "switch (VAR_8) {", "case 0x2:\nif (VAR_9 != 0)\ngoto check_perms;", "case 0x3:\nVAR_1->prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;", "VAR_6 = 0;", "break;", "case 0x0:\nif (VAR_9 != 0) {", "VAR_1->prot = 0;", "VAR_6 = -2;", "break;", "}", "case 0x1:\ncheck_perms:\nVAR_1->prot = tlb->prot;", "VAR_1->prot |= PAGE_EXEC;", "VAR_6 = check_prot(VAR_1->prot, VAR_3, VAR_4);", "break;", "}", "if (VAR_6 >= 0) {", "VAR_1->raddr = raddr;", "LOG_SWTLB(\"%s: access granted \" TARGET_FMT_lx \" => \" TARGET_FMT_plx\n\" %d %d\\n\", __func__, VAR_2, VAR_1->raddr, VAR_1->prot,\nVAR_6);", "return 0;", "}", "}", "LOG_SWTLB(\"%s: access refused \" TARGET_FMT_lx \" => \" TARGET_FMT_plx\n\" %d %d\\n\", __func__, VAR_2, raddr, VAR_1->prot, VAR_6);", "return VAR_6;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 41 ], [ 43, 45, 47 ], [ 51, 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75, 77, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 115 ], [ 117 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nuint8_t *VAR_2, int VAR_3)\n{", "BlockDriver *drv = VAR_0->drv;", "if (!drv)\nreturn -ENOMEDIUM;", "if (VAR_1 == 0 && VAR_0->boot_sector_enabled && VAR_3 > 0) {", "memcpy(VAR_2, VAR_0->boot_sector_data, 512);", "VAR_1++;", "VAR_3--;", "VAR_2 += 512;", "if (VAR_3 == 0)\nreturn 0;", "}", "if (drv->bdrv_pread) {", "int VAR_4, VAR_5;", "VAR_5 = VAR_3 * 512;", "VAR_4 = drv->bdrv_pread(VAR_0, VAR_1 * 512, VAR_2, VAR_5);", "if (VAR_4 < 0)\nreturn VAR_4;", "else if (VAR_4 != VAR_5)\nreturn -EINVAL;", "else {", "VAR_0->rd_bytes += (unsigned) VAR_5;", "VAR_0->rd_ops ++;", "return 0;", "}", "} else {", "return drv->FUNC_0(VAR_0, VAR_1, VAR_2, 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 ]

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

[ "int FUNC_0(SocketAddress *VAR_0, Error **VAR_1,\nNonBlockingConnectHandler *VAR_2, void *VAR_3)\n{", "int VAR_4;", "switch (VAR_0->type) {", "case SOCKET_ADDRESS_KIND_INET:\nVAR_4 = inet_connect_saddr(VAR_0->u.inet, VAR_1, VAR_2, VAR_3);", "break;", "case SOCKET_ADDRESS_KIND_UNIX:\nVAR_4 = unix_connect_saddr(VAR_0->u.q_unix, VAR_1, VAR_2, VAR_3);", "break;", "case SOCKET_ADDRESS_KIND_FD:\nVAR_4 = monitor_get_fd(cur_mon, VAR_0->u.VAR_4->str, VAR_1);", "if (VAR_4 >= 0 && VAR_2) {", "qemu_set_nonblock(VAR_4);", "VAR_2(VAR_4, NULL, VAR_3);", "}", "break;", "default:\nabort();", "}", "return VAR_4;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0) {", "uint32_t blockid, size = 0;", "EaDemuxContext *ea = VAR_0->priv_data;", "ByteIOContext *pb = &VAR_0->pb;", "blockid = get_le32(pb);", "if (blockid == MVhd_TAG) {", "size = get_le32(pb);", "process_video_header_vp6(VAR_0);", "url_fskip(pb, size-32);", "blockid = get_le32(pb);", "}", "if (blockid != SCHl_TAG)\nreturn 0;", "size += get_le32(pb);", "blockid = get_le32(pb);", "if (blockid == GSTR_TAG) {", "url_fskip(pb, 4);", "} else if (blockid != PT00_TAG) {", "av_log (VAR_0, AV_LOG_ERROR, \"unknown SCHl headerid\\n\");", "return 0;", "}", "process_audio_header_elements(VAR_0);", "url_fseek(pb, size, SEEK_SET);", "return 1;", "}" ]

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

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

[ "static void FUNC_0(VideoState *VAR_0, double VAR_1) {", "if (fabs(get_external_clock(VAR_0) - VAR_1) > AV_NOSYNC_THRESHOLD) {", "update_external_clock_pts(VAR_0, VAR_1);", "}", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(CPUPhysMemoryClient *VAR_0,\ntarget_phys_addr_t VAR_1,\ntarget_phys_addr_t VAR_2)\n{", "struct vhost_dev *VAR_3 = container_of(VAR_0, struct vhost_dev, VAR_0);", "int VAR_4;", "if (!VAR_3->log_enabled || !VAR_3->started) {", "return 0;", "}", "for (VAR_4 = 0; VAR_4 < VAR_3->mem->nregions; ++VAR_4) {", "struct vhost_memory_region *VAR_5 = VAR_3->mem->regions + VAR_4;", "vhost_dev_sync_region(VAR_3, VAR_1, VAR_2,\nVAR_5->guest_phys_addr,\nrange_get_last(VAR_5->guest_phys_addr,\nVAR_5->memory_size));", "}", "for (VAR_4 = 0; VAR_4 < VAR_3->nvqs; ++VAR_4) {", "struct vhost_virtqueue *VAR_6 = VAR_3->vqs + VAR_4;", "vhost_dev_sync_region(VAR_3, VAR_1, VAR_2, VAR_6->used_phys,\nrange_get_last(VAR_6->used_phys, VAR_6->used_size));", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOV_atom_t VAR_2)\n{", "AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];", "MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;", "int VAR_3, VAR_4;", "uint32_t format;", "print_atom(\"stsd\", VAR_2);", "get_byte(VAR_1);", "get_byte(VAR_1); get_byte(VAR_1); get_byte(VAR_1);", "VAR_3 = get_be32(VAR_1);", "while(VAR_3--) {", "enum CodecID VAR_5;", "int VAR_6 = get_be32(VAR_1);", "format = get_le32(VAR_1);", "get_be32(VAR_1);", "get_be16(VAR_1);", "get_be16(VAR_1);", "VAR_5 = codec_get_id(mov_video_tags, format);", "if (VAR_5 >= 0) {", "AVCodec *codec;", "codec = avcodec_find_decoder(VAR_5);", "if (codec)\nst->codec.codec_type = codec->type;", "}", "#ifdef DEBUG\nprintf(\"VAR_6=%d 4CC= %VAR_0%VAR_0%VAR_0%VAR_0 codec_type=%d\\n\",\nVAR_6,\n(format >> 0) & 0xff,\n(format >> 8) & 0xff,\n(format >> 16) & 0xff,\n(format >> 24) & 0xff,\nst->codec.codec_type);", "#endif\nst->codec.codec_tag = format;", "if(st->codec.codec_type==CODEC_TYPE_VIDEO) {", "MOV_atom_t a = { 0, 0, 0 };", "st->codec.codec_id = VAR_5;", "get_be16(VAR_1);", "get_be16(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "st->codec.width = get_be16(VAR_1);", "st->codec.height = get_be16(VAR_1);", "#if 1\nif (st->codec.codec_id == CODEC_ID_MPEG4) {", "st->codec.width = 0;", "st->codec.height = 0;", "}", "#endif\nget_be32(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "VAR_4 = get_be16(VAR_1);", "#ifdef DEBUG\nprintf(\"frames/samples = %d\\n\", VAR_4);", "#endif\nget_buffer(VAR_1, (uint8_t *)st->codec.codec_name, 32);", "st->codec.bits_per_sample = get_be16(VAR_1);", "st->codec.color_table_id = get_be16(VAR_1);", "st->codec.frame_rate = 25;", "st->codec.frame_rate_base = 1;", "VAR_6 -= (16+8*4+2+32+2*2);", "#if 0\nwhile (VAR_6 >= 8) {", "MOV_atom_t a;", "int64_t start_pos;", "a.VAR_6 = get_be32(VAR_1);", "a.type = get_le32(VAR_1);", "VAR_6 -= 8;", "#ifdef DEBUG\nprintf(\"VIDEO: atom_type=%VAR_0%VAR_0%VAR_0%VAR_0 VAR_2.VAR_6=%Ld size_left=%d\\n\",\n(a.type >> 0) & 0xff,\n(a.type >> 8) & 0xff,\n(a.type >> 16) & 0xff,\n(a.type >> 24) & 0xff,\na.VAR_6, VAR_6);", "#endif\nstart_pos = url_ftell(VAR_1);", "switch(a.type) {", "case MKTAG('e', 's', 'd', 's'):\n{", "int tag, len;", "get_be32(VAR_1);", "len = mov_mp4_read_descr(VAR_1, &tag);", "if (tag == 0x03) {", "get_be16(VAR_1);", "get_byte(VAR_1);", "len = mov_mp4_read_descr(VAR_1, &tag);", "if (tag != 0x04)\ngoto fail;", "get_byte(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "len = mp4_read_descr(VAR_1, &tag);", "if (tag != 0x05)\ngoto fail;", "#ifdef DEBUG\nprintf(\"Specific MPEG4 header len=%d\\n\", len);", "#endif\nsc->header_data = av_mallocz(len);", "if (sc->header_data) {", "get_buffer(VAR_1, sc->header_data, len);", "sc->header_len = len;", "}", "}", "}", "break;", "default:\nbreak;", "}", "fail:\nprintf(\"ATOMENEWSIZE %Ld %d\\n\", VAR_2.VAR_6, url_ftell(VAR_1) - start_pos);", "if (VAR_2.VAR_6 > 8) {", "url_fskip(VAR_1, (VAR_2.VAR_6 - 8) -\n((url_ftell(VAR_1) - start_pos)));", "VAR_6 -= VAR_2.VAR_6 - 8;", "}", "}", "if (VAR_6 > 0) {", "url_fskip(VAR_1, VAR_6);", "}", "#else\na.VAR_6 = VAR_6;", "mov_read_default(VAR_0, VAR_1, a);", "#endif\n} else {", "get_be16(VAR_1);", "get_be16(VAR_1);", "get_be32(VAR_1);", "st->codec.channels = get_be16(VAR_1);", "st->codec.bits_per_sample = get_be16(VAR_1);", "st->codec.codec_id = codec_get_id(mov_audio_tags, format);", "get_be16(VAR_1);", "get_be16(VAR_1);", "st->codec.sample_rate = ((get_be32(VAR_1) >> 16));", "switch (st->codec.codec_id) {", "case CODEC_ID_PCM_S16BE:\nif (st->codec.bits_per_sample == 8)\nst->codec.codec_id = CODEC_ID_PCM_S8;", "case CODEC_ID_PCM_U8:\nst->codec.bit_rate = st->codec.sample_rate * 8;", "break;", "default:\n;", "}", "get_be32(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "{", "MOV_atom_t a = { format, url_ftell(VAR_1), VAR_6 - (16 + 20 + 16 + 8) };", "mov_read_default(VAR_0, VAR_1, a);", "}", "}", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 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 ], [ 111 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 131, 133 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169, 171, 173, 175, 177, 179 ], [ 181, 183 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ], [ 209 ], [ 211, 213 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227, 229 ], [ 233, 235 ], [ 237, 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 253 ], [ 255 ], [ 257, 259 ], [ 261 ], [ 263, 265 ], [ 267 ], [ 269, 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 283 ], [ 285 ], [ 287, 289 ], [ 291 ], [ 293, 295 ], [ 297 ], [ 299 ], [ 301 ], [ 305 ], [ 307 ], [ 311 ], [ 315 ], [ 317 ], [ 321 ], [ 327 ], [ 329, 331, 333 ], [ 337, 339 ], [ 341 ], [ 343, 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 373 ], [ 375 ] ]

[ "void FUNC_0(SCSIRequest *VAR_0)\n{", "scsi_req_dequeue(VAR_0);", "qemu_free(VAR_0);", "}" ]

[ 1, 1, 1, 0 ]

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

[ "void FUNC_0(QPCIDevice *VAR_0, void *VAR_1, const void *VAR_2, size_t VAR_3)\n{", "uintptr_t addr = (uintptr_t)VAR_1;", "g_assert(addr >= QPCI_PIO_LIMIT);", "VAR_0->bus->memwrite(VAR_0->bus, addr, VAR_2, VAR_3);", "}" ]

[ 1, 1, 1, 1, 0 ]

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

[ "FUNC_0(E1000EState *VAR_0)\n{", "int VAR_1;", "VAR_1 = msi_init(PCI_DEVICE(VAR_0),\n0xD0,\n1,\ntrue,\nfalse);", "if (VAR_1 > 0) {", "VAR_0->intr_state |= E1000E_USE_MSI;", "} else {", "trace_e1000e_msi_init_fail(VAR_1);", "}", "}" ]

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

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

[ "int FUNC_0(AVPacket *VAR_0, enum AVPacketSideDataType VAR_1,\nuint8_t *VAR_2, size_t VAR_3)\n{", "int VAR_4 = VAR_0->side_data_elems;", "if ((unsigned)VAR_4 + 1 > INT_MAX / sizeof(*VAR_0->side_data))\nreturn AVERROR(ERANGE);", "VAR_0->side_data = av_realloc(VAR_0->side_data,\n(VAR_4 + 1) * sizeof(*VAR_0->side_data));", "if (!VAR_0->side_data)\nreturn AVERROR(ENOMEM);", "VAR_0->side_data[VAR_4].VAR_2 = VAR_2;", "VAR_0->side_data[VAR_4].VAR_3 = VAR_3;", "VAR_0->side_data[VAR_4].VAR_1 = VAR_1;", "VAR_0->side_data_elems++;", "return 0;", "}" ]

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

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

[ "static coroutine_fn int FUNC_0(BlockDriverState *bs, int64_t sector_num,\nint nb_sectors, QEMUIOVector *qiov)\n{", "BDRVQcowState *s = bs->opaque;", "int VAR_0;", "int VAR_1 = 0, VAR_2;", "uint64_t cluster_offset;", "struct iovec VAR_3;", "QEMUIOVector hd_qiov;", "uint8_t *buf;", "void *VAR_4;", "if (qiov->niov > 1) {", "buf = VAR_4 = qemu_try_blockalign(bs, qiov->size);", "if (buf == NULL) {", "return -ENOMEM;", "}", "} else {", "VAR_4 = NULL;", "buf = (uint8_t *)qiov->iov->iov_base;", "}", "qemu_co_mutex_lock(&s->lock);", "while (nb_sectors != 0) {", "cluster_offset = get_cluster_offset(bs, sector_num << 9,\n0, 0, 0, 0);", "VAR_0 = sector_num & (s->cluster_sectors - 1);", "VAR_2 = s->cluster_sectors - VAR_0;", "if (VAR_2 > nb_sectors) {", "VAR_2 = nb_sectors;", "}", "if (!cluster_offset) {", "if (bs->backing) {", "VAR_3.iov_base = (void *)buf;", "VAR_3.iov_len = VAR_2 * 512;", "qemu_iovec_init_external(&hd_qiov, &VAR_3, 1);", "qemu_co_mutex_unlock(&s->lock);", "VAR_1 = bdrv_co_readv(bs->backing, sector_num, VAR_2, &hd_qiov);", "qemu_co_mutex_lock(&s->lock);", "if (VAR_1 < 0) {", "goto fail;", "}", "} else {", "memset(buf, 0, 512 * VAR_2);", "}", "} else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {", "if (decompress_cluster(bs, cluster_offset) < 0) {", "goto fail;", "}", "memcpy(buf,\ns->cluster_cache + VAR_0 * 512, 512 * VAR_2);", "} else {", "if ((cluster_offset & 511) != 0) {", "goto fail;", "}", "VAR_3.iov_base = (void *)buf;", "VAR_3.iov_len = VAR_2 * 512;", "qemu_iovec_init_external(&hd_qiov, &VAR_3, 1);", "qemu_co_mutex_unlock(&s->lock);", "VAR_1 = bdrv_co_readv(bs->file,\n(cluster_offset >> 9) + VAR_0,\nVAR_2, &hd_qiov);", "qemu_co_mutex_lock(&s->lock);", "if (VAR_1 < 0) {", "break;", "}", "if (bs->encrypted) {", "assert(s->crypto);", "if (qcrypto_block_decrypt(s->crypto, sector_num, buf,\nVAR_2 * BDRV_SECTOR_SIZE, NULL) < 0) {", "goto fail;", "}", "}", "}", "VAR_1 = 0;", "nb_sectors -= VAR_2;", "sector_num += VAR_2;", "buf += VAR_2 * 512;", "}", "done:\nqemu_co_mutex_unlock(&s->lock);", "if (qiov->niov > 1) {", "qemu_iovec_from_buf(qiov, 0, VAR_4, qiov->size);", "qemu_vfree(VAR_4);", "}", "return VAR_1;", "fail:\nVAR_1 = -EIO;", "goto done;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 49 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 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 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175, 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 195, 197 ], [ 199 ], [ 201 ] ]

[ "static inline I2CBus *FUNC_0(AUXTOI2CState *bridge)\n{", "return bridge->i2c_bus;", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(void *VAR_0, int VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int VAR_5,\nconst char *VAR_6, int VAR_7)\n{", "struct USBAutoFilter *VAR_8;", "struct USBDevice *VAR_9;", "if (VAR_3 == 9)\nreturn 0;", "for (VAR_8 = usb_auto_filter; VAR_8; VAR_8 = VAR_8->next) {", "if (VAR_8->VAR_1 >= 0 && VAR_8->VAR_1 != VAR_1)\ncontinue;", "if (VAR_8->VAR_2 >= 0 && VAR_8->VAR_2 != VAR_2)\ncontinue;", "if (VAR_8->VAR_4 >= 0 && VAR_8->VAR_4 != VAR_4)\ncontinue;", "if (VAR_8->VAR_5 >= 0 && VAR_8->VAR_5 != VAR_5)\ncontinue;", "if (hostdev_find(VAR_1, VAR_2))\nreturn 0;", "dprintf(\"husb: auto open: VAR_1 %d VAR_2 %d\\n\", VAR_1, VAR_2);", "VAR_9 = usb_host_device_open_addr(VAR_1, VAR_2, VAR_6);", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 17, 19 ], [ 23 ], [ 25, 27 ], [ 31, 33 ], [ 37, 39 ], [ 43, 45 ], [ 55, 57 ], [ 61 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ] ]

[ "static int FUNC_0(J2kDecoderContext *VAR_0)\n{", "int VAR_1, VAR_2;", "if (VAR_0->buf_end - VAR_0->buf < 36)\nbytestream_get_be16(&VAR_0->buf);", "VAR_0->width = bytestream_get_be32(&VAR_0->buf);", "VAR_0->height = bytestream_get_be32(&VAR_0->buf);", "VAR_0->image_offset_x = bytestream_get_be32(&VAR_0->buf);", "VAR_0->image_offset_y = bytestream_get_be32(&VAR_0->buf);", "VAR_0->tile_width = bytestream_get_be32(&VAR_0->buf);", "VAR_0->tile_height = bytestream_get_be32(&VAR_0->buf);", "VAR_0->tile_offset_x = bytestream_get_be32(&VAR_0->buf);", "VAR_0->tile_offset_y = bytestream_get_be32(&VAR_0->buf);", "VAR_0->ncomponents = bytestream_get_be16(&VAR_0->buf);", "if (VAR_0->buf_end - VAR_0->buf < 2 * VAR_0->ncomponents)\nfor (VAR_1 = 0; VAR_1 < VAR_0->ncomponents; VAR_1++){", "uint8_t x = bytestream_get_byte(&VAR_0->buf);", "VAR_0->cbps[VAR_1] = (x & 0x7f) + 1;", "VAR_0->precision = FFMAX(VAR_0->cbps[VAR_1], VAR_0->precision);", "VAR_0->sgnd[VAR_1] = !!(x & 0x80);", "VAR_0->cdx[VAR_1] = bytestream_get_byte(&VAR_0->buf);", "VAR_0->cdy[VAR_1] = bytestream_get_byte(&VAR_0->buf);", "}", "VAR_0->numXtiles = ff_j2k_ceildiv(VAR_0->width - VAR_0->tile_offset_x, VAR_0->tile_width);", "VAR_0->numYtiles = ff_j2k_ceildiv(VAR_0->height - VAR_0->tile_offset_y, VAR_0->tile_height);", "VAR_0->tile = av_mallocz(VAR_0->numXtiles * VAR_0->numYtiles * sizeof(J2kTile));", "if (!VAR_0->tile)\nreturn AVERROR(ENOMEM);", "for (VAR_1 = 0; VAR_1 < VAR_0->numXtiles * VAR_0->numYtiles; VAR_1++){", "J2kTile *tile = VAR_0->tile + VAR_1;", "tile->comp = av_mallocz(VAR_0->ncomponents * sizeof(J2kComponent));", "if (!tile->comp)\nreturn AVERROR(ENOMEM);", "}", "VAR_0->avctx->width = VAR_0->width - VAR_0->image_offset_x;", "VAR_0->avctx->height = VAR_0->height - VAR_0->image_offset_y;", "switch(VAR_0->ncomponents){", "case 1: if (VAR_0->precision > 8) {", "VAR_0->avctx->pix_fmt = PIX_FMT_GRAY16;", "} else VAR_0->avctx->pix_fmt = PIX_FMT_GRAY8;", "break;", "case 3: if (VAR_0->precision > 8) {", "VAR_0->avctx->pix_fmt = PIX_FMT_RGB48;", "} else VAR_0->avctx->pix_fmt = PIX_FMT_RGB24;", "break;", "case 4: VAR_0->avctx->pix_fmt = PIX_FMT_BGRA; break;", "}", "if (VAR_0->picture.data[0])\nVAR_0->avctx->release_buffer(VAR_0->avctx, &VAR_0->picture);", "if ((VAR_2 = VAR_0->avctx->get_buffer(VAR_0->avctx, &VAR_0->picture)) < 0)\nreturn VAR_2;", "VAR_0->picture.pict_type = FF_I_TYPE;", "VAR_0->picture.key_frame = 1;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(H264Context *VAR_0, GetBitContext *VAR_1){", "MpegEncContext * const s = &VAR_0->s;", "int VAR_2;", "if(VAR_0->nal_unit_type == NAL_IDR_SLICE){", "s->broken_link= get_bits1(VAR_1) -1;", "VAR_0->mmco[0].long_arg= get_bits1(VAR_1) - 1;", "if(VAR_0->mmco[0].long_arg == -1)\nelse{", "VAR_0->mmco[0].opcode= MMCO_LONG;", "VAR_0->mmco_index= 1;", "}", "}else{", "if(get_bits1(VAR_1)){", "for(VAR_2= 0; VAR_2<MAX_MMCO_COUNT; VAR_2++) {", "MMCOOpcode opcode= get_ue_golomb(VAR_1);", "VAR_0->mmco[VAR_2].opcode= opcode;", "if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){", "VAR_0->mmco[VAR_2].short_pic_num= (VAR_0->curr_pic_num - get_ue_golomb(VAR_1) - 1) & (VAR_0->max_pic_num - 1);", "}", "if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){", "unsigned int long_arg= get_ue_golomb(VAR_1);", "if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"illegal long ref in memory management control operation %d\\n\", opcode);", "return -1;", "}", "VAR_0->mmco[VAR_2].long_arg= long_arg;", "}", "if(opcode > (unsigned)MMCO_LONG){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"illegal memory management control operation %d\\n\", opcode);", "return -1;", "}", "if(opcode == MMCO_END)\nbreak;", "}", "VAR_0->mmco_index= VAR_2;", "}else{", "assert(VAR_0->long_ref_count + VAR_0->short_ref_count <= VAR_0->sps.ref_frame_count);", "if(VAR_0->short_ref_count && VAR_0->long_ref_count + VAR_0->short_ref_count == VAR_0->sps.ref_frame_count &&\n!(FIELD_PICTURE && !s->first_field && s->current_picture_ptr->reference)) {", "VAR_0->mmco[0].opcode= MMCO_SHORT2UNUSED;", "VAR_0->mmco[0].short_pic_num= VAR_0->short_ref[ VAR_0->short_ref_count - 1 ]->frame_num;", "VAR_0->mmco_index= 1;", "if (FIELD_PICTURE) {", "VAR_0->mmco[0].short_pic_num *= 2;", "VAR_0->mmco[1].opcode= MMCO_SHORT2UNUSED;", "VAR_0->mmco[1].short_pic_num= VAR_0->mmco[0].short_pic_num + 1;", "VAR_0->mmco_index= 2;", "}", "}else", "}", "}", "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 ], [ 10 ], [ 12 ], [ 14 ], [ 16, 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 118 ], [ 120 ], [ 124 ], [ 126 ] ]

[ "static int FUNC_0(NUTContext *VAR_0){", "AVFormatContext *s= VAR_0->avf;", "ByteIOContext *bc = &s->pb;", "uint64_t tmp, end;", "unsigned int VAR_1;", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;", "end= get_packetheader(VAR_0, bc, 1);", "end += url_ftell(bc) - 4;", "GET_V(tmp , tmp >=2 && tmp <= 3)\nGET_V(VAR_1 , tmp > 0 && tmp <=MAX_STREAMS)\nVAR_0->max_distance = get_v(bc);", "if(VAR_0->max_distance > 65536){", "av_log(s, AV_LOG_DEBUG, \"max_distance %d\\n\", VAR_0->max_distance);", "VAR_0->max_distance= 65536;", "}", "GET_V(VAR_0->time_base_count, tmp>0 && tmp<INT_MAX / sizeof(AVRational))\nVAR_0->time_base= av_malloc(VAR_0->time_base_count * sizeof(AVRational));", "for(VAR_2=0; VAR_2<VAR_0->time_base_count; VAR_2++){", "GET_V(VAR_0->time_base[VAR_2].num, tmp>0 && tmp<(1ULL<<31))\nGET_V(VAR_0->time_base[VAR_2].den, tmp>0 && tmp<(1ULL<<31))\nif(ff_gcd(VAR_0->time_base[VAR_2].num, VAR_0->time_base[VAR_2].den) != 1){", "av_log(s, AV_LOG_ERROR, \"time base invalid\\n\");", "return -1;", "}", "}", "VAR_6=0;", "VAR_5=1;", "VAR_4=0;", "for(VAR_2=0; VAR_2<256;){", "int VAR_10 = get_v(bc);", "int VAR_11= get_v(bc);", "if(VAR_11>0) VAR_6 = get_s(bc);", "if(VAR_11>1) VAR_5 = get_v(bc);", "if(VAR_11>2) VAR_4= get_v(bc);", "if(VAR_11>3) VAR_7 = get_v(bc);", "else VAR_7 = 0;", "if(VAR_11>4) VAR_9 = get_v(bc);", "else VAR_9 = 0;", "if(VAR_11>5) VAR_8 = get_v(bc);", "else VAR_8 = VAR_5 - VAR_7;", "while(VAR_11-- > 6)\nget_v(bc);", "if(VAR_8 == 0 || VAR_2+VAR_8 > 256){", "av_log(s, AV_LOG_ERROR, \"illegal VAR_8 %d at %d\\n\", VAR_8, VAR_2);", "return -1;", "}", "if(VAR_4 >= VAR_1){", "av_log(s, AV_LOG_ERROR, \"illegal stream number\\n\");", "return -1;", "}", "for(VAR_3=0; VAR_3<VAR_8; VAR_3++,VAR_2++){", "if (VAR_2 == 'N') {", "VAR_0->frame_code[VAR_2].flags= FLAG_INVALID;", "VAR_3--;", "continue;", "}", "VAR_0->frame_code[VAR_2].flags = VAR_10 ;", "VAR_0->frame_code[VAR_2].pts_delta = VAR_6 ;", "VAR_0->frame_code[VAR_2].stream_id = VAR_4;", "VAR_0->frame_code[VAR_2].size_mul = VAR_5 ;", "VAR_0->frame_code[VAR_2].size_lsb = VAR_7+VAR_3;", "VAR_0->frame_code[VAR_2].reserved_count = VAR_9 ;", "}", "}", "assert(VAR_0->frame_code['N'].flags == FLAG_INVALID);", "if(skip_reserved(bc, end) || check_checksum(bc)){", "av_log(s, AV_LOG_ERROR, \"Main header checksum mismatch\\n\");", "return -1;", "}", "VAR_0->stream = av_mallocz(sizeof(StreamContext)*VAR_1);", "for(VAR_2=0; VAR_2<VAR_1; VAR_2++){", "av_new_stream(s, VAR_2);", "}", "return 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, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21, 23, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41 ], [ 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 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ] ]

[ "void FUNC_0 (void)\n{", "if (((int32_t)T0 == INT32_MIN && (int32_t)T1 == -1) || (int32_t)T1 == 0) {", "T0 = (long)((-1) * (T0 >> 31));", "env->spr[SPR_MQ] = 0;", "xer_ov = 1;", "xer_so = 1;", "} else {", "T0 = (int32_t)T0 / (int32_t)T1;", "env->spr[SPR_MQ] = (int32_t)T0 % (int32_t)T1;", "xer_ov = 0;", "}", "}" ]

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

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

[ "void FUNC_0(Notifier *VAR_0)\n{", "notifier_list_add(&migration_state_notifiers, VAR_0);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(RTPDemuxContext *VAR_0, uint8_t *VAR_1, int VAR_2)\n{", "uint16_t seq = AV_RB16(VAR_1 + 2);", "RTPPacket **cur = &VAR_0->queue, *packet;", "while (*cur) {", "int16_t diff = seq - (*cur)->seq;", "if (diff < 0)\nbreak;", "cur = &(*cur)->next;", "}", "packet = av_mallocz(sizeof(*packet));", "if (!packet)\nreturn;", "packet->recvtime = av_gettime_relative();", "packet->seq = seq;", "packet->VAR_2 = VAR_2;", "packet->VAR_1 = VAR_1;", "packet->next = *cur;", "*cur = packet;", "VAR_0->queue_len++;", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{", "RV34DecContext *r = VAR_0->priv_data;", "MpegEncContext *s = &r->s;", "AVFrame *pict = VAR_1;", "SliceInfo si;", "int VAR_5;", "int VAR_6;", "const uint8_t *VAR_7 = NULL;", "int VAR_8 = 0;", "if (VAR_4 == 0) {", "if (s->low_delay==0 && s->next_picture_ptr) {", "*pict= *(AVFrame*)s->next_picture_ptr;", "s->next_picture_ptr= NULL;", "*VAR_2 = sizeof(AVFrame);", "}", "return 0;", "}", "if(!VAR_0->VAR_6){", "VAR_6 = (*VAR_3++) + 1;", "VAR_7 = VAR_3 + 4;", "VAR_3 += 8 * VAR_6;", "}else", "VAR_6 = VAR_0->VAR_6;", "for(VAR_5=0; VAR_5<VAR_6; VAR_5++){", "int VAR_9= get_slice_offset(VAR_0, VAR_7, VAR_5);", "int VAR_10;", "if(VAR_5+1 == VAR_6)\nVAR_10= VAR_4 - VAR_9;", "else\nVAR_10= get_slice_offset(VAR_0, VAR_7, VAR_5+1) - VAR_9;", "if(VAR_9 > VAR_4){", "av_log(VAR_0, AV_LOG_ERROR, \"Slice VAR_9 is greater than frame VAR_10\\n\");", "break;", "}", "r->si.end = s->mb_width * s->mb_height;", "if(VAR_5+1 < VAR_6){", "init_get_bits(&s->gb, VAR_3+get_slice_offset(VAR_0, VAR_7, VAR_5+1), (VAR_4-get_slice_offset(VAR_0, VAR_7, VAR_5+1))*8);", "if(r->parse_slice_header(r, &r->s.gb, &si) < 0){", "if(VAR_5+2 < VAR_6)\nVAR_10 = get_slice_offset(VAR_0, VAR_7, VAR_5+2) - VAR_9;", "else\nVAR_10 = VAR_4 - VAR_9;", "}else", "r->si.end = si.start;", "}", "if(!VAR_5 && si.type == FF_B_TYPE && (!s->last_picture_ptr || !s->last_picture_ptr->VAR_1[0]))\nreturn -1;", "VAR_8 = rv34_decode_slice(r, r->si.end, VAR_3 + VAR_9, VAR_10);", "s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start;", "if(VAR_8)\nbreak;", "}", "if(VAR_8){", "if(r->loop_filter)\nr->loop_filter(r, s->mb_height - 1);", "ff_er_frame_end(s);", "MPV_frame_end(s);", "if (s->pict_type == FF_B_TYPE || s->low_delay) {", "*pict= *(AVFrame*)s->current_picture_ptr;", "} else if (s->last_picture_ptr != NULL) {", "*pict= *(AVFrame*)s->last_picture_ptr;", "}", "if(s->last_picture_ptr || s->low_delay){", "*VAR_2 = sizeof(AVFrame);", "ff_print_debug_info(s, pict);", "}", "s->current_picture_ptr= NULL;", "}", "return VAR_4;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75, 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 129 ], [ 131, 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "MSS2Context * const ctx = avctx->priv_data;", "MSS12Context *c = &ctx->c;", "int VAR_0;", "c->avctx = avctx;", "avctx->coded_frame = &ctx->pic;", "if (VAR_0 = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))\nreturn VAR_0;", "c->pal_stride = c->mask_stride;", "c->pal_pic = av_malloc(c->pal_stride * avctx->height);", "c->last_pal_pic = av_malloc(c->pal_stride * avctx->height);", "if (!c->pal_pic || !c->last_pal_pic) {", "mss2_decode_end(avctx);", "return AVERROR(ENOMEM);", "}", "if (VAR_0 = wmv9_init(avctx)) {", "mss2_decode_end(avctx);", "return VAR_0;", "}", "ff_mss2dsp_init(&ctx->dsp);", "avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555\n: AV_PIX_FMT_RGB24;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "FFStream *stream, *stream_next;", "AVFormatContext *infile;", "int VAR_0;", "for(stream = first_stream; stream != NULL; stream = stream_next) {", "stream_next = stream->next;", "if (stream->stream_type == STREAM_TYPE_LIVE &&\n!stream->feed) {", "stream->ap_in = av_mallocz(sizeof(AVFormatParameters));", "if (!strcmp(stream->fmt->name, \"rtp\")) {", "stream->ap_in->mpeg2ts_raw = 1;", "stream->ap_in->mpeg2ts_compute_pcr = 1;", "}", "if (av_open_input_file(&infile, stream->feed_filename,\nstream->ifmt, 0, stream->ap_in) < 0) {", "http_log(\"%s not found\", stream->feed_filename);", "fail:\nremove_stream(stream);", "} else {", "if (av_find_stream_info(infile) < 0) {", "http_log(\"Could not find codec parameters from '%s'\",\nstream->feed_filename);", "av_close_input_file(infile);", "goto fail;", "}", "extract_mpeg4_header(infile);", "for(VAR_0=0;VAR_0<infile->nb_streams;VAR_0++)", "add_av_stream1(stream, infile->streams[VAR_0]->codec);", "av_close_input_file(infile);", "}", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 15 ], [ 17 ], [ 19, 21 ], [ 29 ], [ 31 ], [ 37 ], [ 39 ], [ 41 ], [ 45, 47 ], [ 49 ], [ 53, 55 ], [ 57 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ] ]

[ "void VAR_0 op_addco (void)\n{", "do_addco();", "RETURN();", "}" ]

[ 1, 1, 1, 0 ]

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

[ "static inline void FUNC_0(VirtQueue *VAR_0, int VAR_1)\n{", "VRingMemoryRegionCaches *caches = atomic_rcu_read(&VAR_0->vring.caches);", "VirtIODevice *vdev = VAR_0->vdev;", "hwaddr pa = offsetof(VRingUsed, flags);", "uint16_t flags = virtio_lduw_phys_cached(VAR_0->vdev, &caches->used, pa);", "virtio_stw_phys_cached(vdev, &caches->used, pa, flags | VAR_1);", "address_space_cache_invalidate(&caches->used, pa, sizeof(flags));", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1)\n{", "IscsiLun *iscsilun = VAR_0->opaque;", "Error *local_err = NULL;", "if (iscsilun->type != TYPE_DISK) {", "return -ENOTSUP;", "}", "iscsi_readcapacity_sync(iscsilun, &local_err);", "if (local_err != NULL) {", "error_free(local_err);", "return -EIO;", "}", "if (VAR_1 > iscsi_getlength(VAR_0)) {", "return -EINVAL;", "}", "if (iscsilun->allocationmap != NULL) {", "g_free(iscsilun->allocationmap);", "iscsilun->allocationmap =\nbitmap_new(DIV_ROUND_UP(VAR_0->total_sectors,\niscsilun->cluster_sectors));", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(unsigned char *VAR_0, unsigned char *VAR_1)\n{", "unsigned char VAR_2;", "int VAR_3;", "int VAR_4;", "int VAR_5, VAR_6, VAR_7;", "for (;;) {", "VAR_2 = *VAR_1++;", "if ( (VAR_2 & 0x80) == 0 ) {", "VAR_4 = *VAR_1++;", "VAR_3 = VAR_2 & 3;", "bytecopy(VAR_0, VAR_1, VAR_3); VAR_0 += VAR_3; VAR_1 += VAR_3;", "VAR_3 = ((VAR_2 & 0x1c) >> 2) + 3;", "bytecopy (VAR_0, VAR_0 - (((VAR_2 & 0x60) << 3) + VAR_4 + 1), VAR_3);", "VAR_0 += VAR_3;", "} else if ( (VAR_2 & 0x40) == 0 ) {", "VAR_5 = *VAR_1++;", "VAR_6 = *VAR_1++;", "VAR_3 = VAR_5 >> 6;", "bytecopy (VAR_0, VAR_1, VAR_3); VAR_0 += VAR_3; VAR_1 += VAR_3;", "VAR_3 = (VAR_2 & 0x3f) + 4;", "bytecopy (VAR_0, VAR_0 - (((VAR_5 & 0x3f) << 8) + VAR_6 + 1), VAR_3);", "VAR_0 += VAR_3;", "} else if ( (VAR_2 & 0x20) == 0 ) {", "VAR_5 = *VAR_1++;", "VAR_6 = *VAR_1++;", "VAR_7 = *VAR_1++;", "VAR_3 = VAR_2 & 3;", "bytecopy (VAR_0, VAR_1, VAR_3); VAR_0 += VAR_3; VAR_1 += VAR_3;", "VAR_3 = VAR_7 + 5 + ((VAR_2 & 0xc) << 6);", "bytecopy (VAR_0,\nVAR_0 - ((((VAR_2 & 0x10) >> 4) << 0x10) + 1 + (VAR_5 << 8) + VAR_6),\nVAR_3);", "VAR_0 += VAR_3;", "} else {", "VAR_3 = ((VAR_2 & 0x1f) << 2) + 4;", "if (VAR_3 > 0x70)\nbreak;", "bytecopy (VAR_0, VAR_1, VAR_3); VAR_0 += VAR_3; VAR_1 += VAR_3;", "}", "}", "VAR_3 = VAR_2 & 3;", "bytecopy(VAR_0, VAR_1, VAR_3); VAR_0 += VAR_3; VAR_1 += VAR_3;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 85 ], [ 87, 89, 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101, 103 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 119 ] ]

[ "FUNC_0(VAR_0)\n{", "const char *VAR_1 = \"VAR_1 test\";", "qdict_put(tests_dict, VAR_1, qstring_from_str(\"foo\"));", "fail_unless(qdict_size(tests_dict) == 1);", "qdict_del(tests_dict, VAR_1);", "fail_unless(qdict_size(tests_dict) == 0);", "fail_unless(qdict_haskey(tests_dict, VAR_1) == 0);", "}" ]

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

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

[ "static void FUNC_0(ThreadPool *VAR_0)\n{", "VAR_0->cur_threads++;", "VAR_0->new_threads++;", "if (!VAR_0->pending_threads) {", "qemu_bh_schedule(VAR_0->new_thread_bh);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ] ]

[ "static void FUNC_0(VncDisplay *VAR_0)\n{", "if (!VAR_0)\nreturn;", "g_free(VAR_0->display);", "VAR_0->display = NULL;", "if (VAR_0->lsock != -1) {", "qemu_set_fd_handler2(VAR_0->lsock, NULL, NULL, NULL, NULL);", "close(VAR_0->lsock);", "VAR_0->lsock = -1;", "}", "#ifdef CONFIG_VNC_WS\ng_free(VAR_0->ws_display);", "VAR_0->ws_display = NULL;", "if (VAR_0->lwebsock != -1) {", "qemu_set_fd_handler2(VAR_0->lwebsock, NULL, NULL, NULL, NULL);", "close(VAR_0->lwebsock);", "VAR_0->lwebsock = -1;", "}", "#endif\nVAR_0->auth = VNC_AUTH_INVALID;", "#ifdef CONFIG_VNC_TLS\nVAR_0->subauth = VNC_AUTH_INVALID;", "VAR_0->tls.x509verify = 0;", "#endif\n}" ]

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

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

[ "void FUNC_0(S390CPU *VAR_0)\n{", "kvm_s390_interrupt_internal(VAR_0, KVM_S390_MCHK, 1 << 28,\n0x00400f1d40330000, 1);", "}" ]

[ 0, 0, 0 ]

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

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

[ 0, 0, 0 ]

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

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint32_t VAR_2, int VAR_3)\n{", "openpic_t *opp = VAR_0;", "IRQ_src_t *src;", "IRQ_dst_t *dst;", "int VAR_4, VAR_5;", "DPRINTF(\"%s: cpu %d VAR_1 \" TARGET_FMT_plx \" <= %08x\\n\", __func__, VAR_3,\nVAR_1, VAR_2);", "if (VAR_1 & 0xF)\nreturn;", "dst = &opp->dst[VAR_3];", "VAR_1 &= 0xFF0;", "switch (VAR_1) {", "case 0x40:\ncase 0x50:\ncase 0x60:\ncase 0x70:\nVAR_3 = (VAR_1 - 0x40) >> 4;", "write_IRQreg_ide(opp, opp->irq_ipi0 + VAR_3,\nopp->src[opp->irq_ipi0 + VAR_3].ide | VAR_2);", "openpic_set_irq(opp, opp->irq_ipi0 + VAR_3, 1);", "openpic_set_irq(opp, opp->irq_ipi0 + VAR_3, 0);", "break;", "case 0x80:\ndst->pctp = VAR_2 & 0x0000000F;", "break;", "case 0x90:\nbreak;", "case 0xA0:\nbreak;", "case 0xB0:\nDPRINTF(\"PEOI\\n\");", "VAR_4 = IRQ_get_next(opp, &dst->servicing);", "IRQ_resetbit(&dst->servicing, VAR_4);", "dst->servicing.next = -1;", "VAR_4 = IRQ_get_next(opp, &dst->servicing);", "VAR_5 = IRQ_get_next(opp, &dst->raised);", "src = &opp->src[VAR_5];", "if (VAR_5 != -1 &&\n(VAR_4 == -1 ||\nIPVP_PRIORITY(src->ipvp) > dst->servicing.priority)) {", "DPRINTF(\"Raise OpenPIC INT output cpu %d irq %d\\n\",\nVAR_3, VAR_5);", "opp->irq_raise(opp, VAR_3, src);", "}", "break;", "default:\nbreak;", "}", "}" ]

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

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

[ "static inline int FUNC_0(BDRVDMGState *VAR_0,int VAR_1)\n{", "if(!is_sector_in_chunk(VAR_0,VAR_0->current_chunk,VAR_1)) {", "int VAR_2;", "uint32_t chunk = search_chunk(VAR_0,VAR_1);", "if(chunk>=VAR_0->n_chunks)\nreturn -1;", "VAR_0->current_chunk = VAR_0->n_chunks;", "switch(VAR_0->types[chunk]) {", "case 0x80000005: {", "int VAR_3;", "VAR_3=0;", "do {", "VAR_2 = pread(VAR_0->fd, VAR_0->compressed_chunk+VAR_3, VAR_0->lengths[chunk]-VAR_3,\nVAR_0->offsets[chunk] + VAR_3);", "if(VAR_2<0 && errno==EINTR)\nVAR_2=0;", "VAR_3+=VAR_2;", "} while(VAR_2>=0 && VAR_2+VAR_3<VAR_0->lengths[chunk]);", "if (VAR_2 != VAR_0->lengths[chunk])\nreturn -1;", "VAR_0->zstream.next_in = VAR_0->compressed_chunk;", "VAR_0->zstream.avail_in = VAR_0->lengths[chunk];", "VAR_0->zstream.next_out = VAR_0->uncompressed_chunk;", "VAR_0->zstream.avail_out = 512*VAR_0->sectorcounts[chunk];", "VAR_2 = inflateReset(&VAR_0->zstream);", "if(VAR_2 != Z_OK)\nreturn -1;", "VAR_2 = inflate(&VAR_0->zstream, Z_FINISH);", "if(VAR_2 != Z_STREAM_END || VAR_0->zstream.total_out != 512*VAR_0->sectorcounts[chunk])\nreturn -1;", "break; }", "case 1:\nVAR_2 = pread(VAR_0->fd, VAR_0->uncompressed_chunk, VAR_0->lengths[chunk],\nVAR_0->offsets[chunk]);", "if (VAR_2 != VAR_0->lengths[chunk])\nreturn -1;", "break;", "case 2:\nmemset(VAR_0->uncompressed_chunk, 0, 512*VAR_0->sectorcounts[chunk]);", "break;", "}", "VAR_0->current_chunk = chunk;", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13, 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 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 ] ]

[ "static QObject *FUNC_0(PCIDevice *dev, PCIBus *bus, int bus_num)\n{", "int VAR_0;", "QObject *obj;", "obj = qobject_from_jsonf(\"{ 'bus': %d, 'slot': %d, 'function': %d,\" \"'class_info': %p, 'id': %p, 'regions': %p,\"", "\" 'qdev_id': %s }\",", "bus_num,\nPCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),\npci_get_dev_class(dev), pci_get_dev_id(dev),\npci_get_regions_list(dev),\ndev->qdev.id ? dev->qdev.id : \"\");", "if (dev->config[PCI_INTERRUPT_PIN] != 0) {", "QDict *qdict = qobject_to_qdict(obj);", "qdict_put(qdict, \"irq\", qint_from_int(dev->config[PCI_INTERRUPT_LINE]));", "}", "VAR_0 = pci_get_word(dev->config + PCI_CLASS_DEVICE);", "if (VAR_0 == 0x0604) {", "QDict *qdict;", "QObject *pci_bridge;", "pci_bridge = qobject_from_jsonf(\"{ 'bus': \"", "\"{ 'number': %d, 'secondary': %d, 'subordinate': %d }, \"", "\"'io_range': { 'base': %\" PRId64 \", 'limit': %\" PRId64 \"}, \"", "\"'memory_range': { 'base': %\" PRId64 \", 'limit': %\" PRId64 \"}, \"", "\"'prefetchable_range': { 'base': %\" PRId64 \", 'limit': %\" PRId64 \"} }\",", "dev->config[0x19], dev->config[PCI_SECONDARY_BUS],\ndev->config[PCI_SUBORDINATE_BUS],\npci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO),\npci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO),\npci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY),\npci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY),\npci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY |\nPCI_BASE_ADDRESS_MEM_PREFETCH),\npci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY |\nPCI_BASE_ADDRESS_MEM_PREFETCH));", "if (dev->config[0x19] != 0) {", "qdict = qobject_to_qdict(pci_bridge);", "qdict_put_obj(qdict, \"devices\",\npci_get_devices_list(bus, dev->config[0x19]));", "}", "qdict = qobject_to_qdict(obj);", "qdict_put_obj(qdict, \"pci_bridge\", pci_bridge);", "}", "return obj;", "}" ]

[ 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57, 59, 61, 63, 65, 67, 69, 71, 73, 75 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ] ]

[ "static void FUNC_0(VGAState *VAR_0, int VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;", "int VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18, VAR_19;", "int VAR_20, VAR_21, VAR_22;", "uint8_t *d;", "uint32_t v, addr1, addr;", "vga_draw_line_func *vga_draw_line;", "VAR_1 |= update_basic_params(VAR_0);", "if (!VAR_1)\nvga_sync_dirty_bitmap(VAR_0);", "VAR_0->get_resolution(VAR_0, &VAR_12, &VAR_13);", "VAR_20 = VAR_12;", "VAR_14 = (VAR_0->gr[0x05] >> 5) & 3;", "VAR_9 = (VAR_0->cr[0x09] >> 7);", "if (VAR_14 != 1) {", "VAR_21 = (((VAR_0->cr[0x09] & 0x1f) + 1) << VAR_9) - 1;", "} else {", "VAR_21 = VAR_9;", "}", "VAR_22 = VAR_21;", "if (VAR_14 != VAR_0->VAR_14 ||\nVAR_9 != VAR_0->VAR_9) {", "VAR_1 = 1;", "VAR_0->VAR_14 = VAR_14;", "VAR_0->VAR_9 = VAR_9;", "}", "VAR_11 = VAR_0->get_bpp(VAR_0);", "if (VAR_0->VAR_15 != VAR_0->last_line_offset ||\nVAR_20 != VAR_0->last_width ||\nVAR_13 != VAR_0->last_height ||\nVAR_0->last_depth != VAR_11) {", "#if defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)\nif (VAR_11 == 16 || VAR_11 == 32) {", "#else\nif (VAR_11 == 32) {", "#endif\nif (is_graphic_console()) {", "qemu_free_displaysurface(VAR_0->ds);", "VAR_0->ds->surface = qemu_create_displaysurface_from(VAR_20, VAR_13, VAR_11,\nVAR_0->VAR_15,\nVAR_0->vram_ptr + (VAR_0->start_addr * 4));", "#if defined(WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)\nVAR_0->ds->surface->pf = qemu_different_endianness_pixelformat(VAR_11);", "#endif\ndpy_resize(VAR_0->ds);", "} else {", "qemu_console_resize(VAR_0->ds, VAR_20, VAR_13);", "}", "} else {", "qemu_console_resize(VAR_0->ds, VAR_20, VAR_13);", "}", "VAR_0->last_scr_width = VAR_20;", "VAR_0->last_scr_height = VAR_13;", "VAR_0->last_width = VAR_20;", "VAR_0->last_height = VAR_13;", "VAR_0->last_line_offset = VAR_0->VAR_15;", "VAR_0->last_depth = VAR_11;", "VAR_1 = 1;", "} else if (is_graphic_console() && is_buffer_shared(VAR_0->ds->surface) &&", "(VAR_1 || VAR_0->ds->surface->data != VAR_0->vram_ptr + (VAR_0->start_addr * 4))) {", "VAR_0->ds->surface->data = VAR_0->vram_ptr + (VAR_0->start_addr * 4);", "dpy_setdata(VAR_0->ds);", "}", "VAR_0->rgb_to_pixel =\nrgb_to_pixel_dup_table[get_depth_index(VAR_0->ds)];", "if (VAR_14 == 0) {", "VAR_1 |= update_palette16(VAR_0);", "if (VAR_0->sr[0x01] & 8) {", "v = VGA_DRAW_LINE4D2;", "VAR_20 <<= 1;", "} else {", "v = VGA_DRAW_LINE4;", "}", "VAR_19 = 4;", "} else if (VAR_14 == 1) {", "VAR_1 |= update_palette16(VAR_0);", "if (VAR_0->sr[0x01] & 8) {", "v = VGA_DRAW_LINE2D2;", "VAR_20 <<= 1;", "} else {", "v = VGA_DRAW_LINE2;", "}", "VAR_19 = 4;", "} else {", "switch(VAR_0->get_bpp(VAR_0)) {", "default:\ncase 0:\nVAR_1 |= update_palette256(VAR_0);", "v = VGA_DRAW_LINE8D2;", "VAR_19 = 4;", "break;", "case 8:\nVAR_1 |= update_palette256(VAR_0);", "v = VGA_DRAW_LINE8;", "VAR_19 = 8;", "break;", "case 15:\nv = VGA_DRAW_LINE15;", "VAR_19 = 16;", "break;", "case 16:\nv = VGA_DRAW_LINE16;", "VAR_19 = 16;", "break;", "case 24:\nv = VGA_DRAW_LINE24;", "VAR_19 = 24;", "break;", "case 32:\nv = VGA_DRAW_LINE32;", "VAR_19 = 32;", "break;", "}", "}", "vga_draw_line = vga_draw_line_table[v * NB_DEPTHS + get_depth_index(VAR_0->ds)];", "if (!is_buffer_shared(VAR_0->ds->surface) && VAR_0->cursor_invalidate)\nVAR_0->cursor_invalidate(VAR_0);", "VAR_15 = VAR_0->VAR_15;", "#if 0\nprintf(\"w=%d h=%d v=%d VAR_15=%d cr[0x09]=0x%02x cr[0x17]=0x%02x linecmp=%d sr[0x01]=0x%02x\\n\",\nVAR_12, VAR_13, v, VAR_15, VAR_0->cr[9], VAR_0->cr[0x17], VAR_0->line_compare, VAR_0->sr[0x01]);", "#endif\naddr1 = (VAR_0->start_addr * 4);", "VAR_18 = (VAR_12 * VAR_19 + 7) / 8;", "VAR_8 = -1;", "VAR_5 = 0x7fffffff;", "VAR_6 = -1;", "d = ds_get_data(VAR_0->ds);", "VAR_7 = ds_get_linesize(VAR_0->ds);", "VAR_2 = 0;", "for(VAR_3 = 0; VAR_3 < VAR_13; VAR_3++) {", "addr = addr1;", "if (!(VAR_0->cr[0x17] & 1)) {", "int VAR_23;", "VAR_23 = 14 + ((VAR_0->cr[0x17] >> 6) & 1);", "addr = (addr & ~(1 << VAR_23)) | ((VAR_2 & 1) << VAR_23);", "}", "if (!(VAR_0->cr[0x17] & 2)) {", "addr = (addr & ~0x8000) | ((VAR_2 & 2) << 14);", "}", "VAR_16 = VAR_0->vram_offset + (addr & TARGET_PAGE_MASK);", "VAR_17 = VAR_0->vram_offset + ((addr + VAR_18 - 1) & TARGET_PAGE_MASK);", "VAR_4 = VAR_1 |\ncpu_physical_memory_get_dirty(VAR_16, VGA_DIRTY_FLAG) |\ncpu_physical_memory_get_dirty(VAR_17, VGA_DIRTY_FLAG);", "if ((VAR_17 - VAR_16) > TARGET_PAGE_SIZE) {", "VAR_4 |= cpu_physical_memory_get_dirty(VAR_16 + TARGET_PAGE_SIZE,\nVGA_DIRTY_FLAG);", "}", "VAR_4 |= (VAR_0->invalidated_y_table[VAR_3 >> 5] >> (VAR_3 & 0x1f)) & 1;", "if (VAR_4) {", "if (VAR_8 < 0)\nVAR_8 = VAR_3;", "if (VAR_16 < VAR_5)\nVAR_5 = VAR_16;", "if (VAR_17 > VAR_6)\nVAR_6 = VAR_17;", "if (!(is_buffer_shared(VAR_0->ds->surface))) {", "vga_draw_line(VAR_0, d, VAR_0->vram_ptr + addr, VAR_12);", "if (VAR_0->cursor_draw_line)\nVAR_0->cursor_draw_line(VAR_0, d, VAR_3);", "}", "} else {", "if (VAR_8 >= 0) {", "dpy_update(VAR_0->ds, 0, VAR_8,\nVAR_20, VAR_3 - VAR_8);", "VAR_8 = -1;", "}", "}", "if (!VAR_22) {", "VAR_10 = (VAR_0->cr[0x17] & 3) ^ 3;", "if ((VAR_2 & VAR_10) == VAR_10)\naddr1 += VAR_15;", "VAR_2++;", "VAR_22 = VAR_21;", "} else {", "VAR_22--;", "}", "if (VAR_3 == VAR_0->line_compare)\naddr1 = 0;", "d += VAR_7;", "}", "if (VAR_8 >= 0) {", "dpy_update(VAR_0->ds, 0, VAR_8,\nVAR_20, VAR_3 - VAR_8);", "}", "if (VAR_6 != -1) {", "cpu_physical_memory_reset_dirty(VAR_5, VAR_6 + TARGET_PAGE_SIZE,\nVGA_DIRTY_FLAG);", "}", "memset(VAR_0->invalidated_y_table, 0, ((VAR_13 + 31) >> 5) * 4);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 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 ], [ 145, 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191, 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203, 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213, 215 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 237, 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 253, 255 ], [ 259 ], [ 261, 263, 265 ], [ 267, 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311, 313, 315 ], [ 317 ], [ 321, 323 ], [ 325 ], [ 329 ], [ 331 ], [ 333, 335 ], [ 337, 339 ], [ 341, 343 ], [ 345 ], [ 347 ], [ 349, 351 ], [ 353 ], [ 355 ], [ 357 ], [ 361, 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375, 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 391, 393 ], [ 395 ], [ 397 ], [ 399 ], [ 403, 405 ], [ 407 ], [ 411 ], [ 413, 415 ], [ 417 ], [ 419 ], [ 421 ] ]

[ "static void FUNC_0(CharDriverState *VAR_0, gchar **VAR_1)\n{", "const gchar *VAR_2;", "g_assert(VAR_1);", "VAR_2 = VAR_1[0];", "if (qtest_log_fp) {", "qemu_timeval tv;", "int VAR_3;", "qtest_get_time(&tv);", "fprintf(qtest_log_fp, \"[R +\" FMT_timeval \"]\",\n(long) tv.tv_sec, (long) tv.tv_usec);", "for (VAR_3 = 0; VAR_1[VAR_3]; VAR_3++) {", "fprintf(qtest_log_fp, \" %s\", VAR_1[VAR_3]);", "}", "fprintf(qtest_log_fp, \"\\n\");", "}", "g_assert(VAR_2);", "if (strcmp(VAR_1[0], \"irq_intercept_out\") == 0\n|| strcmp(VAR_1[0], \"irq_intercept_in\") == 0) {", "DeviceState *dev;", "NamedGPIOList *ngl;", "g_assert(VAR_1[1]);", "dev = DEVICE(object_resolve_path(VAR_1[1], NULL));", "if (!dev) {", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"FAIL Unknown device\\n\");", "return;", "}", "if (irq_intercept_dev) {", "qtest_send_prefix(VAR_0);", "if (irq_intercept_dev != dev) {", "qtest_send(VAR_0, \"FAIL IRQ intercept already enabled\\n\");", "} else {", "qtest_send(VAR_0, \"OK\\n\");", "}", "return;", "}", "QLIST_FOREACH(ngl, &dev->gpios, node) {", "if (ngl->name) {", "continue;", "}", "if (VAR_1[0][14] == 'o') {", "int VAR_3;", "for (VAR_3 = 0; VAR_3 < ngl->num_out; ++VAR_3) {", "qemu_irq *disconnected = g_new0(qemu_irq, 1);", "qemu_irq icpt = qemu_allocate_irq(qtest_irq_handler,\ndisconnected, VAR_3);", "*disconnected = qdev_intercept_gpio_out(dev, icpt,\nngl->name, VAR_3);", "}", "} else {", "qemu_irq_intercept_in(ngl->in, qtest_irq_handler,\nngl->num_in);", "}", "}", "irq_intercept_dev = dev;", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"OK\\n\");", "} else if (strcmp(VAR_1[0], \"outb\") == 0 ||", "strcmp(VAR_1[0], \"outw\") == 0 ||\nstrcmp(VAR_1[0], \"outl\") == 0) {", "uint16_t addr;", "uint32_t value;", "g_assert(VAR_1[1] && VAR_1[2]);", "addr = strtoul(VAR_1[1], NULL, 0);", "value = strtoul(VAR_1[2], NULL, 0);", "if (VAR_1[0][3] == 'b') {", "cpu_outb(addr, value);", "} else if (VAR_1[0][3] == 'w') {", "cpu_outw(addr, value);", "} else if (VAR_1[0][3] == 'l') {", "cpu_outl(addr, value);", "}", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"OK\\n\");", "} else if (strcmp(VAR_1[0], \"inb\") == 0 ||", "strcmp(VAR_1[0], \"inw\") == 0 ||\nstrcmp(VAR_1[0], \"inl\") == 0) {", "uint16_t addr;", "uint32_t value = -1U;", "g_assert(VAR_1[1]);", "addr = strtoul(VAR_1[1], NULL, 0);", "if (VAR_1[0][2] == 'b') {", "value = cpu_inb(addr);", "} else if (VAR_1[0][2] == 'w') {", "value = cpu_inw(addr);", "} else if (VAR_1[0][2] == 'l') {", "value = cpu_inl(addr);", "}", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"OK 0x%04x\\n\", value);", "} else if (strcmp(VAR_1[0], \"writeb\") == 0 ||", "strcmp(VAR_1[0], \"writew\") == 0 ||\nstrcmp(VAR_1[0], \"writel\") == 0 ||\nstrcmp(VAR_1[0], \"writeq\") == 0) {", "uint64_t addr;", "uint64_t value;", "g_assert(VAR_1[1] && VAR_1[2]);", "addr = strtoull(VAR_1[1], NULL, 0);", "value = strtoull(VAR_1[2], NULL, 0);", "if (VAR_1[0][5] == 'b') {", "uint8_t data = value;", "cpu_physical_memory_write(addr, &data, 1);", "} else if (VAR_1[0][5] == 'w') {", "uint16_t data = value;", "tswap16s(&data);", "cpu_physical_memory_write(addr, &data, 2);", "} else if (VAR_1[0][5] == 'l') {", "uint32_t data = value;", "tswap32s(&data);", "cpu_physical_memory_write(addr, &data, 4);", "} else if (VAR_1[0][5] == 'q') {", "uint64_t data = value;", "tswap64s(&data);", "cpu_physical_memory_write(addr, &data, 8);", "}", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"OK\\n\");", "} else if (strcmp(VAR_1[0], \"readb\") == 0 ||", "strcmp(VAR_1[0], \"readw\") == 0 ||\nstrcmp(VAR_1[0], \"readl\") == 0 ||\nstrcmp(VAR_1[0], \"readq\") == 0) {", "uint64_t addr;", "uint64_t value = UINT64_C(-1);", "g_assert(VAR_1[1]);", "addr = strtoull(VAR_1[1], NULL, 0);", "if (VAR_1[0][4] == 'b') {", "uint8_t data;", "cpu_physical_memory_read(addr, &data, 1);", "value = data;", "} else if (VAR_1[0][4] == 'w') {", "uint16_t data;", "cpu_physical_memory_read(addr, &data, 2);", "value = tswap16(data);", "} else if (VAR_1[0][4] == 'l') {", "uint32_t data;", "cpu_physical_memory_read(addr, &data, 4);", "value = tswap32(data);", "} else if (VAR_1[0][4] == 'q') {", "cpu_physical_memory_read(addr, &value, 8);", "tswap64s(&value);", "}", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"OK 0x%016\" PRIx64 \"\\n\", value);", "} else if (strcmp(VAR_1[0], \"read\") == 0) {", "uint64_t addr, len, VAR_3;", "uint8_t *data;", "char *VAR_4;", "g_assert(VAR_1[1] && VAR_1[2]);", "addr = strtoull(VAR_1[1], NULL, 0);", "len = strtoull(VAR_1[2], NULL, 0);", "data = g_malloc(len);", "cpu_physical_memory_read(addr, data, len);", "VAR_4 = g_malloc(2 * len + 1);", "for (VAR_3 = 0; VAR_3 < len; VAR_3++) {", "sprintf(&VAR_4[VAR_3 * 2], \"%02x\", data[VAR_3]);", "}", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"OK 0x%s\\n\", VAR_4);", "g_free(data);", "g_free(VAR_4);", "} else if (strcmp(VAR_1[0], \"b64read\") == 0) {", "uint64_t addr, len;", "uint8_t *data;", "gchar *b64_data;", "g_assert(VAR_1[1] && VAR_1[2]);", "addr = strtoull(VAR_1[1], NULL, 0);", "len = strtoull(VAR_1[2], NULL, 0);", "data = g_malloc(len);", "cpu_physical_memory_read(addr, data, len);", "b64_data = g_base64_encode(data, len);", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"OK %s\\n\", b64_data);", "g_free(data);", "g_free(b64_data);", "} else if (strcmp(VAR_1[0], \"write\") == 0) {", "uint64_t addr, len, VAR_3;", "uint8_t *data;", "size_t data_len;", "g_assert(VAR_1[1] && VAR_1[2] && VAR_1[3]);", "addr = strtoull(VAR_1[1], NULL, 0);", "len = strtoull(VAR_1[2], NULL, 0);", "data_len = strlen(VAR_1[3]);", "if (data_len < 3) {", "qtest_send(VAR_0, \"ERR invalid argument size\\n\");", "return;", "}", "data = g_malloc(len);", "for (VAR_3 = 0; VAR_3 < len; VAR_3++) {", "if ((VAR_3 * 2 + 4) <= data_len) {", "data[VAR_3] = hex2nib(VAR_1[3][VAR_3 * 2 + 2]) << 4;", "data[VAR_3] |= hex2nib(VAR_1[3][VAR_3 * 2 + 3]);", "} else {", "data[VAR_3] = 0;", "}", "}", "cpu_physical_memory_write(addr, data, len);", "g_free(data);", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"OK\\n\");", "} else if (strcmp(VAR_1[0], \"memset\") == 0) {", "uint64_t addr, len;", "uint8_t *data;", "uint8_t pattern;", "g_assert(VAR_1[1] && VAR_1[2] && VAR_1[3]);", "addr = strtoull(VAR_1[1], NULL, 0);", "len = strtoull(VAR_1[2], NULL, 0);", "pattern = strtoull(VAR_1[3], NULL, 0);", "if (len) {", "data = g_malloc(len);", "memset(data, pattern, len);", "cpu_physical_memory_write(addr, data, len);", "g_free(data);", "}", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"OK\\n\");", "} else if (strcmp(VAR_1[0], \"b64write\") == 0) {", "uint64_t addr, len;", "uint8_t *data;", "size_t data_len;", "gsize out_len;", "g_assert(VAR_1[1] && VAR_1[2] && VAR_1[3]);", "addr = strtoull(VAR_1[1], NULL, 0);", "len = strtoull(VAR_1[2], NULL, 0);", "data_len = strlen(VAR_1[3]);", "if (data_len < 3) {", "qtest_send(VAR_0, \"ERR invalid argument size\\n\");", "return;", "}", "data = g_base64_decode_inplace(VAR_1[3], &out_len);", "if (out_len != len) {", "qtest_log_send(\"b64write: data length mismatch (told %\"PRIu64\", \"\n\"found %zu)\\n\",\nlen, out_len);", "out_len = MIN(out_len, len);", "}", "cpu_physical_memory_write(addr, data, out_len);", "qtest_send_prefix(VAR_0);", "qtest_send(VAR_0, \"OK\\n\");", "} else if (qtest_enabled() && strcmp(VAR_1[0], \"clock_step\") == 0) {", "int64_t ns;", "if (VAR_1[1]) {", "ns = strtoll(VAR_1[1], NULL, 0);", "} else {", "ns = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);", "}", "qtest_clock_warp(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ns);", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"OK %\"PRIi64\"\\n\",\n(int64_t)qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL));", "} else if (qtest_enabled() && strcmp(VAR_1[0], \"clock_set\") == 0) {", "int64_t ns;", "g_assert(VAR_1[1]);", "ns = strtoll(VAR_1[1], NULL, 0);", "qtest_clock_warp(ns);", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"OK %\"PRIi64\"\\n\",\n(int64_t)qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL));", "} else {", "qtest_send_prefix(VAR_0);", "qtest_sendf(VAR_0, \"FAIL Unknown VAR_2 '%s'\\n\", 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215, 217, 219 ], [ 221 ], [ 223 ], [ 227 ], [ 229 ], [ 231 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273, 275, 277 ], [ 279 ], [ 281 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 337 ], [ 339 ], [ 341 ], [ 345 ], [ 347 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 361 ], [ 363 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 381 ], [ 383 ], [ 385 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 415 ], [ 417 ], [ 419 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 459 ], [ 461 ], [ 463 ], [ 465 ], [ 467 ], [ 469 ], [ 473 ], [ 475 ], [ 477 ], [ 479 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 513 ], [ 515 ], [ 517 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 533 ], [ 535 ], [ 537, 539, 541 ], [ 543 ], [ 545 ], [ 549 ], [ 553 ], [ 555 ], [ 557 ], [ 559 ], [ 563 ], [ 565 ], [ 567 ], [ 569 ], [ 571 ], [ 573 ], [ 575 ], [ 577, 579 ], [ 581 ], [ 583 ], [ 587 ], [ 589 ], [ 591 ], [ 593 ], [ 595, 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ] ]

[ "static RemoveResult FUNC_0(PowerPCCPU *cpu, target_ulong ptex,\ntarget_ulong avpn,\ntarget_ulong flags,\ntarget_ulong *vp, target_ulong *rp)\n{", "CPUPPCState *env = &cpu->env;", "uint64_t token;", "target_ulong v, r;", "if (!valid_pte_index(env, ptex)) {", "return REMOVE_PARM;", "}", "token = ppc_hash64_start_access(cpu, ptex);", "v = ppc_hash64_load_hpte0(cpu, token, 0);", "r = ppc_hash64_load_hpte1(cpu, token, 0);", "ppc_hash64_stop_access(token);", "if ((v & HPTE64_V_VALID) == 0 ||\n((flags & H_AVPN) && (v & ~0x7fULL) != avpn) ||\n((flags & H_ANDCOND) && (v & avpn) != 0)) {", "return REMOVE_NOT_FOUND;", "}", "*vp = v;", "*rp = r;", "ppc_hash64_store_hpte(cpu, ptex, HPTE64_V_HPTE_DIRTY, 0);", "ppc_hash64_tlb_flush_hpte(cpu, ptex, v, r);", "return REMOVE_SUCCESS;", "}" ]

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

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

[ "static void FUNC_0(BlockDriverAIOCB *VAR_0)\n{", "BlockDriverAIOCBCoroutine *acb =\ncontainer_of(VAR_0, BlockDriverAIOCBCoroutine, common);", "bool done = false;", "acb->done = &done;", "while (!done) {", "qemu_aio_wait();", "}", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque,\nhwaddr addr, unsigned size)\n{", "VFIOQuirk *quirk = opaque;", "VFIOPCIDevice *vdev = quirk->vdev;", "switch (addr) {", "case 4:\nif (quirk->data.flags) {", "trace_vfio_rtl8168_window_quirk_read_fake(\nmemory_region_name(&quirk->mem),\nvdev->vbasedev.name);", "return quirk->data.address_match ^ 0x10000000U;", "}", "break;", "case 0:\nif (quirk->data.flags) {", "uint64_t val;", "trace_vfio_rtl8168_window_quirk_read_table(\nmemory_region_name(&quirk->mem),\nvdev->vbasedev.name);", "if (!(vdev->pdev.cap_present & QEMU_PCI_CAP_MSIX)) {", "return 0;", "}", "memory_region_dispatch_read(&vdev->pdev.msix_table_mmio,\n(hwaddr)(quirk->data.address_match\n& 0xfff),\n&val,\nsize,\nMEMTXATTRS_UNSPECIFIED);", "return val;", "}", "}", "trace_vfio_rtl8168_window_quirk_read_direct(memory_region_name(&quirk->mem),\nvdev->vbasedev.name);", "return vfio_region_read(&vdev->bars[quirk->data.bar].region,\naddr + 0x70, size);", "}" ]

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

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

[ "static void FUNC_0(Object *VAR_0)\n{", "SCLPEventFacility *event_facility = EVENT_FACILITY(VAR_0);", "DeviceState *sdev = DEVICE(VAR_0);", "qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus),\nTYPE_SCLP_EVENTS_BUS, sdev, NULL);", "object_initialize(&event_facility->quiesce_event, sizeof(SCLPEvent),\nTYPE_SCLP_QUIESCE);", "qdev_set_parent_bus(DEVICE(&event_facility->quiesce_event),\n&event_facility->sbus.qbus);", "object_initialize(&event_facility->cpu_hotplug_event, sizeof(SCLPEvent),\nTYPE_SCLP_CPU_HOTPLUG);", "qdev_set_parent_bus(DEVICE(&event_facility->cpu_hotplug_event),\n&event_facility->sbus.qbus);", "}" ]

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

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

[ "static void FUNC_0(VC1Context *VAR_0)\n{", "MpegEncContext *s = &VAR_0->s;", "GetBitContext *gb = &s->gb;", "int VAR_1, VAR_2;", "int VAR_3 = s->mb_x + s->mb_y * s->mb_stride;", "int VAR_4 = 0;", "int VAR_5, VAR_6;", "int VAR_7 = VAR_0->ttfrm;", "int VAR_8 = 0;", "int VAR_9;", "int VAR_10 = 1;", "int VAR_11, VAR_12;", "int VAR_13;", "int VAR_14[2], VAR_15[2], VAR_16[2];", "int VAR_17 = BMV_TYPE_BACKWARD;", "int VAR_18, VAR_19;", "VAR_6 = VAR_0->pq;", "s->mb_intra = 0;", "VAR_18 = get_vlc2(gb, VAR_0->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);", "if (VAR_18 <= 1) {", "s->mb_intra = VAR_0->is_intra[s->mb_x] = 1;", "s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;", "s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;", "s->current_picture.f.mb_type[VAR_3 + VAR_0->mb_off] = MB_TYPE_INTRA;", "GET_MQUANT();", "s->current_picture.f.qscale_table[VAR_3] = VAR_6;", "s->y_dc_scale = s->y_dc_scale_table[VAR_6];", "s->c_dc_scale = s->c_dc_scale_table[VAR_6];", "VAR_0->s.ac_pred = VAR_0->acpred_plane[VAR_3] = get_bits1(gb);", "VAR_8 = VAR_18 & 1;", "if (VAR_8)\nVAR_4 = 1 + get_vlc2(&VAR_0->s.gb, VAR_0->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);", "VAR_11 = 0;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "s->dc_val[0][s->block_index[VAR_1]] = 0;", "VAR_11 += VAR_1 >> 2;", "VAR_9 = ((VAR_4 >> (5 - VAR_1)) & 1);", "VAR_0->mb_type[0][s->block_index[VAR_1]] = s->mb_intra;", "VAR_0->a_avail = VAR_0->c_avail = 0;", "if (VAR_1 == 2 || VAR_1 == 3 || !s->first_slice_line)\nVAR_0->a_avail = VAR_0->mb_type[0][s->block_index[VAR_1] - s->block_wrap[VAR_1]];", "if (VAR_1 == 1 || VAR_1 == 3 || s->mb_x)\nVAR_0->c_avail = VAR_0->mb_type[0][s->block_index[VAR_1] - 1];", "vc1_decode_intra_block(VAR_0, s->block[VAR_1], VAR_1, VAR_9, VAR_6,\n(VAR_1 & 4) ? VAR_0->codingset2 : VAR_0->codingset);", "if ((VAR_1>3) && (s->flags & CODEC_FLAG_GRAY))\ncontinue;", "VAR_0->vc1dsp.vc1_inv_trans_8x8(s->block[VAR_1]);", "if (VAR_0->rangeredfrm)\nfor (VAR_2 = 0; VAR_2 < 64; VAR_2++)", "s->block[VAR_1][VAR_2] <<= 1;", "VAR_12 = (VAR_1 & 4) ? 0 : ((VAR_1 & 1) * 8 + (VAR_1 & 2) * 4 * s->linesize);", "VAR_12 += VAR_0->second_field ? ((VAR_1 & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;", "s->dsp.put_signed_pixels_clamped(s->block[VAR_1], s->dest[VAR_11] + VAR_12, (VAR_1 & 4) ? s->uvlinesize : s->linesize);", "}", "} else {", "s->mb_intra = VAR_0->is_intra[s->mb_x] = 0;", "s->current_picture.f.mb_type[VAR_3 + VAR_0->mb_off] = MB_TYPE_16x16;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) VAR_0->mb_type[0][s->block_index[VAR_1]] = 0;", "if (VAR_0->fmb_is_raw)\nVAR_13 = VAR_0->forward_mb_plane[VAR_3] = get_bits1(gb);", "else\nVAR_13 = VAR_0->forward_mb_plane[VAR_3];", "if (VAR_18 <= 5) {", "VAR_14[0] = VAR_14[1] = VAR_15[0] = VAR_15[1] = 0;", "VAR_16[0] = VAR_16[1] = 0;", "if (VAR_13)\nVAR_17 = BMV_TYPE_FORWARD;", "else {", "VAR_17 = decode012(gb);", "switch (VAR_17) {", "case 0:\nVAR_17 = BMV_TYPE_BACKWARD;", "break;", "case 1:\nVAR_17 = BMV_TYPE_DIRECT;", "break;", "case 2:\nVAR_17 = BMV_TYPE_INTERPOLATED;", "VAR_19 = get_bits1(gb);", "}", "}", "VAR_0->VAR_17 = VAR_17;", "if (VAR_17 != BMV_TYPE_DIRECT && VAR_18 & 1) {", "get_mvdata_interlaced(VAR_0, &VAR_14[VAR_17 == BMV_TYPE_BACKWARD], &VAR_15[VAR_17 == BMV_TYPE_BACKWARD], &VAR_16[VAR_17 == BMV_TYPE_BACKWARD]);", "}", "if (VAR_17 == BMV_TYPE_INTERPOLATED && VAR_19) {", "get_mvdata_interlaced(VAR_0, &VAR_14[1], &VAR_15[1], &VAR_16[1]);", "}", "if (VAR_17 == BMV_TYPE_DIRECT) {", "VAR_14[0] = VAR_15[0] = VAR_16[0] = 0;", "VAR_14[1] = VAR_15[1] = VAR_16[0] = 0;", "}", "vc1_pred_b_mv_intfi(VAR_0, 0, VAR_14, VAR_15, 1, VAR_16);", "vc1_b_mc(VAR_0, VAR_14, VAR_15, (VAR_17 == BMV_TYPE_DIRECT), VAR_17);", "VAR_8 = !(VAR_18 & 2);", "} else {", "if (VAR_13)\nVAR_17 = BMV_TYPE_FORWARD;", "VAR_0->VAR_17 = VAR_17;", "VAR_0->fourmvbp = get_vlc2(gb, VAR_0->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "if (VAR_1 < 4) {", "VAR_14[0] = VAR_15[0] = VAR_16[0] = 0;", "VAR_14[1] = VAR_15[1] = VAR_16[1] = 0;", "VAR_9 = ((VAR_0->fourmvbp >> (3 - VAR_1)) & 1);", "if (VAR_9) {", "get_mvdata_interlaced(VAR_0, &VAR_14[VAR_17 == BMV_TYPE_BACKWARD],\n&VAR_15[VAR_17 == BMV_TYPE_BACKWARD],\n&VAR_16[VAR_17 == BMV_TYPE_BACKWARD]);", "}", "vc1_pred_b_mv_intfi(VAR_0, VAR_1, VAR_14, VAR_15, 0, VAR_16);", "vc1_mc_4mv_luma(VAR_0, VAR_1, VAR_17 == BMV_TYPE_BACKWARD);", "} else if (VAR_1 == 4)", "vc1_mc_4mv_chroma(VAR_0, VAR_17 == BMV_TYPE_BACKWARD);", "}", "VAR_8 = VAR_18 & 1;", "}", "if (VAR_8)\nVAR_4 = 1 + get_vlc2(&VAR_0->s.gb, VAR_0->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);", "if (VAR_4) {", "GET_MQUANT();", "}", "s->current_picture.f.qscale_table[VAR_3] = VAR_6;", "if (!VAR_0->ttmbf && VAR_4) {", "VAR_7 = get_vlc2(gb, ff_vc1_ttmb_vlc[VAR_0->tt_index].table, VC1_TTMB_VLC_BITS, 2);", "}", "VAR_11 = 0;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "s->dc_val[0][s->block_index[VAR_1]] = 0;", "VAR_11 += VAR_1 >> 2;", "VAR_9 = ((VAR_4 >> (5 - VAR_1)) & 1);", "VAR_12 = (VAR_1 & 4) ? 0 : (VAR_1 & 1) * 8 + (VAR_1 & 2) * 4 * s->linesize;", "if (VAR_0->second_field)\nVAR_12 += (VAR_1 & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];", "if (VAR_9) {", "vc1_decode_p_block(VAR_0, s->block[VAR_1], VAR_1, VAR_6, VAR_7,\nVAR_10, s->dest[VAR_11] + VAR_12,\n(VAR_1 & 4) ? s->uvlinesize : s->linesize,\n(VAR_1 & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);", "if (!VAR_0->ttmbf && VAR_7 < 8)\nVAR_7 = -1;", "VAR_10 = 0;", "}", "}", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 91, 93 ], [ 97, 99 ], [ 101, 103 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155, 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167, 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227, 229, 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249, 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281 ], [ 283 ], [ 285, 287, 289, 291 ], [ 293, 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{", "HLSContext *hls = VAR_0->priv_data;", "ListEntry *en;", "int64_t target_duration = 0;", "int VAR_2 = 0;", "AVIOContext *out = NULL;", "char VAR_3[1024];", "int64_t sequence = FFMAX(hls->start_sequence, hls->sequence - hls->size);", "snprintf(VAR_3, sizeof(VAR_3), \"%VAR_0.tmp\", VAR_0->filename);", "if ((VAR_2 = avio_open2(&out, VAR_3, AVIO_FLAG_WRITE,\n&VAR_0->interrupt_callback, NULL)) < 0)\ngoto fail;", "for (en = hls->list; en; en = en->next) {", "if (target_duration < en->duration)\ntarget_duration = en->duration;", "}", "avio_printf(out, \"#EXTM3U\\n\");", "avio_printf(out, \"#EXT-X-VERSION:%d\\n\", hls->version);", "if (hls->allowcache == 0 || hls->allowcache == 1) {", "avio_printf(out, \"#EXT-X-ALLOW-CACHE:%VAR_0\\n\", hls->allowcache == 0 ? \"NO\" : \"YES\");", "}", "avio_printf(out, \"#EXT-X-TARGETDURATION:%\"PRId64\"\\n\",\nav_rescale_rnd(target_duration, 1, AV_TIME_BASE,\nAV_ROUND_UP));", "avio_printf(out, \"#EXT-X-MEDIA-SEQUENCE:%\"PRId64\"\\n\", sequence);", "av_log(VAR_0, AV_LOG_VERBOSE, \"EXT-X-MEDIA-SEQUENCE:%\"PRId64\"\\n\",\nsequence);", "for (en = hls->list; en; en = en->next) {", "if (hls->version > 2)\navio_printf(out, \"#EXTINF:%f\\n\",\n(double)en->duration / AV_TIME_BASE);", "else\navio_printf(out, \"#EXTINF:%\"PRId64\",\\n\",\nav_rescale(en->duration, 1, AV_TIME_BASE));", "if (hls->baseurl)\navio_printf(out, \"%VAR_0\", hls->baseurl);", "avio_printf(out, \"%VAR_0\\n\", en->name);", "}", "if (VAR_1)\navio_printf(out, \"#EXT-X-ENDLIST\\n\");", "fail:\navio_closep(&out);", "if (VAR_2 >= 0)\nff_rename(VAR_3, VAR_0->filename);", "return VAR_2;", "}" ]

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

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

[ "FUNC_0(PVSCSICmdDescSetupRings *VAR_0)\n{", "int VAR_1;", "trace_pvscsi_tx_rings_ppn(\"Rings State\", VAR_0->ringsStatePPN);", "trace_pvscsi_tx_rings_num_pages(\"Request Ring\", VAR_0->reqRingNumPages);", "for (VAR_1 = 0; VAR_1 < VAR_0->reqRingNumPages; VAR_1++) {", "trace_pvscsi_tx_rings_ppn(\"Request Ring\", VAR_0->reqRingPPNs[VAR_1]);", "}", "trace_pvscsi_tx_rings_num_pages(\"Confirm Ring\", VAR_0->cmpRingNumPages);", "for (VAR_1 = 0; VAR_1 < VAR_0->cmpRingNumPages; VAR_1++) {", "trace_pvscsi_tx_rings_ppn(\"Confirm Ring\", VAR_0->reqRingPPNs[VAR_1]);", "}", "}" ]

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

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

[ "void FUNC_0(S390CPU *VAR_0, uint64_t VAR_1, uint32_t VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "SubchDev *sch;", "ORB orig_orb, orb;", "uint64_t addr;", "int VAR_7 = -ENODEV;", "int VAR_8;", "CPUS390XState *env = &VAR_0->env;", "uint8_t ar;", "addr = decode_basedisp_s(env, VAR_2, &ar);", "if (addr & 3) {", "program_interrupt(env, PGM_SPECIFICATION, 2);", "return;", "}", "if (s390_cpu_virt_mem_read(VAR_0, addr, ar, &orig_orb, sizeof(orb))) {", "return;", "}", "copy_orb_from_guest(&orb, &orig_orb);", "if (ioinst_disassemble_sch_ident(VAR_1, &VAR_6, &VAR_3, &VAR_4, &VAR_5) ||\n!ioinst_orb_valid(&orb)) {", "program_interrupt(env, PGM_OPERAND, 2);", "return;", "}", "trace_ioinst_sch_id(\"ssch\", VAR_3, VAR_4, VAR_5);", "sch = css_find_subch(VAR_6, VAR_3, VAR_4, VAR_5);", "if (sch && css_subch_visible(sch)) {", "VAR_7 = css_do_ssch(sch, &orb);", "}", "switch (VAR_7) {", "case -ENODEV:\nVAR_8 = 3;", "break;", "case -EBUSY:\nVAR_8 = 2;", "break;", "case -EFAULT:\nprogram_interrupt(env, PGM_ADDRESSING, 4);", "return;", "case 0:\nVAR_8 = 0;", "break;", "default:\nVAR_8 = 1;", "break;", "}", "setcc(VAR_0, VAR_8);", "}" ]

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

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "int VAR_0, VAR_1, VAR_2;", "IMCContext *q = avctx->priv_data;", "double VAR_3, VAR_4;", "if ((avctx->codec_id == AV_CODEC_ID_IMC && avctx->channels != 1)\n|| (avctx->codec_id == AV_CODEC_ID_IAC && avctx->channels > 2)) {", "av_log_ask_for_sample(avctx, \"Number of channels is not supported\\n\");", "return AVERROR_PATCHWELCOME;", "}", "for (VAR_1 = 0; VAR_1 < avctx->channels; VAR_1++) {", "q->chctx[VAR_1].decoder_reset = 1;", "for (VAR_0 = 0; VAR_0 < BANDS; VAR_0++)", "q->chctx[VAR_1].old_floor[VAR_0] = 1.0;", "for (VAR_0 = 0; VAR_0 < COEFFS / 2; VAR_0++)", "q->chctx[VAR_1].last_fft_im[VAR_0] = 0;", "}", "ff_sine_window_init(q->mdct_sine_window, COEFFS);", "for (VAR_0 = 0; VAR_0 < COEFFS; VAR_0++)", "q->mdct_sine_window[VAR_0] *= sqrt(2.0);", "for (VAR_0 = 0; VAR_0 < COEFFS / 2; VAR_0++) {", "q->post_cos[VAR_0] = (1.0f / 32768) * cos(VAR_0 / 256.0 * M_PI);", "q->post_sin[VAR_0] = (1.0f / 32768) * sin(VAR_0 / 256.0 * M_PI);", "VAR_3 = sin((VAR_0 * 4.0 + 1.0) / 1024.0 * M_PI);", "VAR_4 = cos((VAR_0 * 4.0 + 1.0) / 1024.0 * M_PI);", "if (VAR_0 & 0x1) {", "q->pre_coef1[VAR_0] = (VAR_3 + VAR_4) * sqrt(2.0);", "q->pre_coef2[VAR_0] = -(VAR_3 - VAR_4) * sqrt(2.0);", "} else {", "q->pre_coef1[VAR_0] = -(VAR_3 + VAR_4) * sqrt(2.0);", "q->pre_coef2[VAR_0] = (VAR_3 - VAR_4) * sqrt(2.0);", "}", "}", "for (VAR_0 = 0; VAR_0 < 30; VAR_0++)", "q->sqrt_tab[VAR_0] = sqrt(VAR_0);", "for (VAR_0 = 0; VAR_0 < 4 ; VAR_0++) {", "for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {", "huffman_vlc[VAR_0][VAR_1].table = &vlc_tables[vlc_offsets[VAR_0 * 4 + VAR_1]];", "huffman_vlc[VAR_0][VAR_1].table_allocated = vlc_offsets[VAR_0 * 4 + VAR_1 + 1] - vlc_offsets[VAR_0 * 4 + VAR_1];", "init_vlc(&huffman_vlc[VAR_0][VAR_1], 9, imc_huffman_sizes[VAR_0],\nimc_huffman_lens[VAR_0][VAR_1], 1, 1,\nimc_huffman_bits[VAR_0][VAR_1], 2, 2, INIT_VLC_USE_NEW_STATIC);", "}", "}", "if (avctx->codec_id == AV_CODEC_ID_IAC) {", "iac_generate_tabs(q, avctx->sample_rate);", "} else {", "memcpy(q->cyclTab, cyclTab, sizeof(cyclTab));", "memcpy(q->cyclTab2, cyclTab2, sizeof(cyclTab2));", "memcpy(q->weights1, imc_weights1, sizeof(imc_weights1));", "memcpy(q->weights2, imc_weights2, sizeof(imc_weights2));", "}", "if ((VAR_2 = ff_fft_init(&q->fft, 7, 1))) {", "av_log(avctx, AV_LOG_INFO, \"FFT init failed\\n\");", "return VAR_2;", "}", "ff_dsputil_init(&q->dsp, avctx);", "avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;", "avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO\n: AV_CH_LAYOUT_STEREO;", "avcodec_get_frame_defaults(&q->frame);", "avctx->coded_frame = &q->frame;", "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 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 89 ], [ 91 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107, 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147, 149 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ] ]

[ "static void FUNC_0(int VAR_0, struct target_sigaction *VAR_1,\ntarget_sigset_t *VAR_2, CPUPPCState *VAR_3)\n{", "struct target_sigframe *VAR_4;", "struct target_sigcontext *VAR_5;", "target_ulong frame_addr, newsp;", "int VAR_6 = 0;", "int VAR_7;", "frame_addr = get_sigframe(VAR_1, VAR_3, sizeof(*VAR_4));", "if (!lock_user_struct(VERIFY_WRITE, VAR_4, frame_addr, 1))\ngoto sigsegv;", "VAR_5 = &VAR_4->sctx;", "VAR_7 = current_exec_domain_sig(VAR_0);", "__put_user(VAR_1->_sa_handler, &VAR_5->handler);", "__put_user(VAR_2->VAR_0[0], &VAR_5->oldmask);", "#if defined(TARGET_PPC64)\n__put_user(VAR_2->VAR_0[0] >> 32, &VAR_5->_unused[3]);", "#else\n__put_user(VAR_2->VAR_0[1], &VAR_5->_unused[3]);", "#endif\n__put_user(h2g(&VAR_4->mctx), &VAR_5->regs);", "__put_user(VAR_0, &VAR_5->VAR_7);", "VAR_6 |= save_user_regs(VAR_3, &VAR_4->mctx, TARGET_NR_sigreturn);", "VAR_3->lr = (target_ulong) h2g(VAR_4->mctx.tramp);", "VAR_3->fpscr = 0;", "newsp = frame_addr - SIGNAL_FRAMESIZE;", "VAR_6 |= put_user(VAR_3->gpr[1], newsp, target_ulong);", "if (VAR_6)\ngoto sigsegv;", "VAR_3->gpr[1] = newsp;", "VAR_3->gpr[3] = VAR_7;", "VAR_3->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);", "VAR_3->nip = (target_ulong) VAR_1->_sa_handler;", "VAR_3->msr &= ~MSR_LE;", "unlock_user_struct(VAR_4, frame_addr, 1);", "return;", "sigsegv:\nunlock_user_struct(VAR_4, frame_addr, 1);", "qemu_log(\"segfaulting from FUNC_0\\n\");", "force_sig(TARGET_SIGSEGV);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41, 43 ], [ 45, 47 ], [ 49 ], [ 55 ], [ 63 ], [ 69 ], [ 75 ], [ 77 ], [ 81, 83 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ] ]

[ "void FUNC_0(AioContext *VAR_0)\n{", "g_source_ref(&VAR_0->source);", "}" ]

[ 0, 0, 0 ]

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t offset,\nunsigned size)\n{", "mv88w8618_audio_state *s = opaque;", "switch (offset) {", "case MP_AUDIO_PLAYBACK_MODE:\nreturn s->playback_mode;", "case MP_AUDIO_CLOCK_DIV:\nreturn s->clock_div;", "case MP_AUDIO_IRQ_STATUS:\nreturn s->status;", "case MP_AUDIO_IRQ_ENABLE:\nreturn s->irq_enable;", "case MP_AUDIO_TX_STATUS:\nreturn s->play_pos >> 2;", "default:\nreturn 0;", "}", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0, Property *VAR_1)\n{", "DriveInfo **ptr = qdev_get_prop_ptr(VAR_0, VAR_1);", "if (*ptr) {", "blockdev_auto_del((*ptr)->bdrv);", "}", "}" ]

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

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

[ "void FUNC_0(SCSIDevice *VAR_0, SCSISense VAR_1)\n{", "SCSIRequest *req;", "while (!QTAILQ_EMPTY(&VAR_0->requests)) {", "req = QTAILQ_FIRST(&VAR_0->requests);", "scsi_req_cancel(req);", "}", "VAR_0->unit_attention = VAR_1;", "}" ]

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

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

[ "uint64_t FUNC_0(DeviceState *d)\n{", "if (d) {", "APICCommonState *s = APIC_COMMON(d);", "trace_cpu_get_apic_base((uint64_t)s->apicbase);", "return s->apicbase;", "} else {", "trace_cpu_get_apic_base(0);", "return 0;", "}", "}" ]

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

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

[ "static int FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{", "rcu_read_lock();", "if (!migration_in_postcopy(migrate_get_current())) {", "migration_bitmap_sync();", "}", "ram_control_before_iterate(VAR_0, RAM_CONTROL_FINISH);", "while (true) {", "int VAR_2;", "VAR_2 = ram_find_and_save_block(VAR_0, true, &bytes_transferred);", "if (VAR_2 == 0) {", "break;", "}", "}", "flush_compressed_data(VAR_0);", "ram_control_after_iterate(VAR_0, RAM_CONTROL_FINISH);", "rcu_read_unlock();", "qemu_put_be64(VAR_0, RAM_SAVE_FLAG_EOS);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 57 ], [ 61 ], [ 63 ] ]

[ "uint32_t FUNC_0(lpxbr)(CPUS390XState *env, uint32_t f1, uint32_t f2)\n{", "CPU_QuadU v1;", "CPU_QuadU v2;", "v2.ll.upper = env->fregs[f2].ll;", "v2.ll.lower = env->fregs[f2 + 2].ll;", "v1.q = float128_abs(v2.q);", "env->fregs[f1].ll = v1.ll.upper;", "env->fregs[f1 + 2].ll = v1.ll.lower;", "return set_cc_nz_f128(v1.q);", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nstruct statfs *VAR_2)\n{", "VAR_2->f_type = 0xABCD;", "VAR_2->f_bsize = 512;", "VAR_2->f_blocks = 0;", "VAR_2->f_files = v9fs_synth_node_count;", "VAR_2->f_namelen = NAME_MAX;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "m5206_mbar_state *s = (m5206_mbar_state *)VAR_0;", "int VAR_3;", "VAR_1 &= 0x3ff;", "if (VAR_1 >= 0x200) {", "hw_error(\"Bad MBAR write VAR_1 0x%x\", (int)VAR_1);", "}", "VAR_3 = m5206_mbar_width[VAR_1 >> 2];", "if (VAR_3 > 2) {", "uint32_t tmp;", "tmp = m5206_mbar_readl(VAR_0, VAR_1 & ~3);", "if (VAR_1 & 3) {", "tmp = (tmp & 0xffff0000) | VAR_2;", "} else {", "tmp = (tmp & 0x0000ffff) | (VAR_2 << 16);", "}", "m5206_mbar_writel(VAR_0, VAR_1 & ~3, tmp);", "return;", "} else if (VAR_3 < 2) {", "m5206_mbar_writeb(VAR_0, VAR_1, VAR_2 >> 8);", "m5206_mbar_writeb(VAR_0, VAR_1 + 1, VAR_2 & 0xff);", "return;", "}", "m5206_mbar_write(s, VAR_1, VAR_2, 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 ]

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

[ "hwaddr FUNC_0(CPUArchState *env,\nMemoryRegionSection *section,\ntarget_ulong vaddr,\nhwaddr paddr,\nint prot,\ntarget_ulong *address)\n{", "hwaddr iotlb;", "CPUWatchpoint *wp;", "if (memory_region_is_ram(section->mr)) {", "iotlb = (memory_region_get_ram_addr(section->mr) & TARGET_PAGE_MASK)\n+ memory_region_section_addr(section, paddr);", "if (!section->readonly) {", "iotlb |= phys_section_notdirty;", "} else {", "iotlb |= phys_section_rom;", "}", "} else {", "iotlb = section - phys_sections;", "iotlb += memory_region_section_addr(section, paddr);", "}", "QTAILQ_FOREACH(wp, &env->watchpoints, entry) {", "if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {", "if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {", "iotlb = phys_section_watch + paddr;", "*address |= TLB_MMIO;", "break;", "}", "}", "}", "return iotlb;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "struct termios VAR_0;", "tcgetattr (0, &VAR_0);", "oldtty = VAR_0;", "VAR_0.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP\n|INLCR|IGNCR|ICRNL|IXON);", "VAR_0.c_oflag |= OPOST;", "VAR_0.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);", "VAR_0.c_cflag &= ~(CSIZE|PARENB);", "VAR_0.c_cflag |= CS8;", "VAR_0.c_cc[VMIN] = 1;", "VAR_0.c_cc[VTIME] = 0;", "tcsetattr (0, TCSANOW, &VAR_0);", "atexit(term_exit);", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{", "KVMXICSState *icpkvm = KVM_XICS(VAR_0);", "XICSState *icp = XICS_COMMON(VAR_0);", "int VAR_2, VAR_3;", "Error *error = NULL;", "struct kvm_create_device VAR_4 = {", ".type = KVM_DEV_TYPE_XICS,\n.flags = 0,\n};", "if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) {", "error_setg(VAR_1,\n\"KVM and IRQ_XICS capability must be present for in-kernel XICS\");", "goto fail;", "}", "spapr_rtas_register(RTAS_IBM_SET_XIVE, \"ibm,set-xive\", rtas_dummy);", "spapr_rtas_register(RTAS_IBM_GET_XIVE, \"ibm,get-xive\", rtas_dummy);", "spapr_rtas_register(RTAS_IBM_INT_OFF, \"ibm,int-off\", rtas_dummy);", "spapr_rtas_register(RTAS_IBM_INT_ON, \"ibm,int-on\", rtas_dummy);", "VAR_3 = kvmppc_define_rtas_kernel_token(RTAS_IBM_SET_XIVE, \"ibm,set-xive\");", "if (VAR_3 < 0) {", "error_setg(VAR_1, \"kvmppc_define_rtas_kernel_token: ibm,set-xive\");", "goto fail;", "}", "VAR_3 = kvmppc_define_rtas_kernel_token(RTAS_IBM_GET_XIVE, \"ibm,get-xive\");", "if (VAR_3 < 0) {", "error_setg(VAR_1, \"kvmppc_define_rtas_kernel_token: ibm,get-xive\");", "goto fail;", "}", "VAR_3 = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_ON, \"ibm,int-on\");", "if (VAR_3 < 0) {", "error_setg(VAR_1, \"kvmppc_define_rtas_kernel_token: ibm,int-on\");", "goto fail;", "}", "VAR_3 = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_OFF, \"ibm,int-off\");", "if (VAR_3 < 0) {", "error_setg(VAR_1, \"kvmppc_define_rtas_kernel_token: ibm,int-off\");", "goto fail;", "}", "VAR_3 = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &VAR_4);", "if (VAR_3 < 0) {", "error_setg_errno(VAR_1, -VAR_3, \"Error on KVM_CREATE_DEVICE for XICS\");", "goto fail;", "}", "icpkvm->kernel_xics_fd = VAR_4.fd;", "object_property_set_bool(OBJECT(icp->ics), true, \"realized\", &error);", "if (error) {", "error_propagate(VAR_1, error);", "goto fail;", "}", "assert(icp->nr_servers);", "for (VAR_2 = 0; VAR_2 < icp->nr_servers; VAR_2++) {", "object_property_set_bool(OBJECT(&icp->ss[VAR_2]), true, \"realized\", &error);", "if (error) {", "error_propagate(VAR_1, error);", "goto fail;", "}", "}", "kvm_kernel_irqchip = true;", "kvm_irqfds_allowed = true;", "kvm_msi_via_irqfd_allowed = true;", "kvm_gsi_direct_mapping = true;", "return;", "fail:\nkvmppc_define_rtas_kernel_token(0, \"ibm,set-xive\");", "kvmppc_define_rtas_kernel_token(0, \"ibm,get-xive\");", "kvmppc_define_rtas_kernel_token(0, \"ibm,int-on\");", "kvmppc_define_rtas_kernel_token(0, \"ibm,int-off\");", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17, 19 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ] ]

[ "static int FUNC_0(HTTPContext *VAR_0, long VAR_1)\n{", "int VAR_2;", "switch(VAR_0->state) {", "case HTTPSTATE_SEND_DATA_HEADER:\nmemset(&VAR_0->fmt_ctx, 0, sizeof(VAR_0->fmt_ctx));", "pstrcpy(VAR_0->fmt_ctx.author, sizeof(VAR_0->fmt_ctx.author), VAR_0->stream->author);", "pstrcpy(VAR_0->fmt_ctx.comment, sizeof(VAR_0->fmt_ctx.comment), VAR_0->stream->comment);", "pstrcpy(VAR_0->fmt_ctx.copyright, sizeof(VAR_0->fmt_ctx.copyright), VAR_0->stream->copyright);", "pstrcpy(VAR_0->fmt_ctx.title, sizeof(VAR_0->fmt_ctx.title), VAR_0->stream->title);", "if (VAR_0->stream->feed) {", "VAR_0->fmt_ctx.oformat = VAR_0->stream->fmt;", "VAR_0->fmt_ctx.nb_streams = VAR_0->stream->nb_streams;", "for(VAR_2=0;VAR_2<VAR_0->fmt_ctx.nb_streams;VAR_2++) {", "AVStream *st;", "st = av_mallocz(sizeof(AVStream));", "VAR_0->fmt_ctx.streams[VAR_2] = st;", "if (VAR_0->stream->feed == VAR_0->stream)\nmemcpy(st, VAR_0->stream->streams[VAR_2], sizeof(AVStream));", "else\nmemcpy(st, VAR_0->stream->feed->streams[VAR_0->stream->feed_streams[VAR_2]], sizeof(AVStream));", "st->codec.frame_number = 0;", "}", "VAR_0->got_key_frame = 0;", "} else {", "VAR_0->fmt_ctx.oformat = VAR_0->stream->fmt;", "VAR_0->fmt_ctx.nb_streams = VAR_0->fmt_in->nb_streams;", "for(VAR_2=0;VAR_2<VAR_0->fmt_ctx.nb_streams;VAR_2++) {", "AVStream *st;", "st = av_mallocz(sizeof(AVStream));", "VAR_0->fmt_ctx.streams[VAR_2] = st;", "memcpy(st, VAR_0->fmt_in->streams[VAR_2], sizeof(AVStream));", "st->codec.frame_number = 0;", "}", "VAR_0->got_key_frame = 0;", "}", "init_put_byte(&VAR_0->fmt_ctx.pb, VAR_0->pbuffer, VAR_0->pbuffer_size,\n1, VAR_0, NULL, http_write_packet, NULL);", "VAR_0->fmt_ctx.pb.is_streamed = 1;", "av_write_header(&VAR_0->fmt_ctx);", "VAR_0->state = HTTPSTATE_SEND_DATA;", "VAR_0->last_packet_sent = 0;", "break;", "case HTTPSTATE_SEND_DATA:\n#if 0\nfifo_total_size = http_fifo_write_count - VAR_0->last_http_fifo_write_count;", "if (fifo_total_size >= ((3 * FIFO_MAX_SIZE) / 4)) {", "VAR_0->rptr = http_fifo.wptr;", "VAR_0->got_key_frame = 0;", "}", "start_rptr = VAR_0->rptr;", "if (fifo_read(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &VAR_0->rptr) < 0)\nreturn 0;", "payload_size = ntohs(hdr.payload_size);", "payload = av_malloc(payload_size);", "if (fifo_read(&http_fifo, payload, payload_size, &VAR_0->rptr) < 0) {", "av_free(payload);", "VAR_0->rptr = start_rptr;", "return 0;", "}", "VAR_0->last_http_fifo_write_count = http_fifo_write_count -\nfifo_size(&http_fifo, VAR_0->rptr);", "if (VAR_0->stream->stream_type != STREAM_TYPE_MASTER) {", "ret = 0;", "for(VAR_2=0;VAR_2<VAR_0->fmt_ctx.nb_streams;VAR_2++) {", "AVStream *st = VAR_0->fmt_ctx.streams[VAR_2];", "if (test_header(&hdr, &st->codec)) {", "if (st->codec.key_frame)\nVAR_0->got_key_frame |= 1 << VAR_2;", "if (VAR_0->got_key_frame & (1 << VAR_2)) {", "ret = VAR_0->fmt_ctx.format->write_packet(&VAR_0->fmt_ctx, VAR_2,\npayload, payload_size);", "}", "break;", "}", "}", "if (ret) {", "VAR_0->state = HTTPSTATE_SEND_DATA_TRAILER;", "}", "} else {", "char *q;", "q = VAR_0->buffer;", "memcpy(q, &hdr, sizeof(hdr));", "q += sizeof(hdr);", "memcpy(q, payload, payload_size);", "q += payload_size;", "VAR_0->buffer_ptr = VAR_0->buffer;", "VAR_0->buffer_end = q;", "}", "av_free(payload);", "#endif\n{", "AVPacket pkt;", "if (VAR_0->stream->feed) {", "ffm_set_write_index(VAR_0->fmt_in,\nVAR_0->stream->feed->feed_write_index,\nVAR_0->stream->feed->feed_size);", "}", "if (VAR_0->stream->max_time &&\nVAR_0->stream->max_time + VAR_0->start_time - VAR_1 < 0) {", "VAR_0->state = HTTPSTATE_SEND_DATA_TRAILER;", "} else if (av_read_packet(VAR_0->fmt_in, &pkt) < 0) {", "if (VAR_0->stream->feed && VAR_0->stream->feed->feed_opened) {", "VAR_0->state = HTTPSTATE_WAIT_FEED;", "return 1;", "} else {", "VAR_0->state = HTTPSTATE_SEND_DATA_TRAILER;", "}", "} else {", "if (VAR_0->stream->feed) {", "if (VAR_0->switch_pending) {", "VAR_0->switch_pending = 0;", "for(VAR_2=0;VAR_2<VAR_0->stream->nb_streams;VAR_2++) {", "if (VAR_0->switch_feed_streams[VAR_2] == pkt.stream_index) {", "if (pkt.flags & PKT_FLAG_KEY) {", "do_switch_stream(VAR_0, VAR_2);", "}", "}", "if (VAR_0->switch_feed_streams[VAR_2] >= 0) {", "VAR_0->switch_pending = 1;", "}", "}", "}", "for(VAR_2=0;VAR_2<VAR_0->stream->nb_streams;VAR_2++) {", "if (VAR_0->feed_streams[VAR_2] == pkt.stream_index) {", "pkt.stream_index = VAR_2;", "if (pkt.flags & PKT_FLAG_KEY) {", "VAR_0->got_key_frame |= 1 << VAR_2;", "}", "if (!VAR_0->stream->send_on_key || ((VAR_0->got_key_frame + 1) >> VAR_0->stream->nb_streams)) {", "goto send_it;", "}", "}", "}", "} else {", "AVCodecContext *codec;", "send_it:\ncodec = &VAR_0->fmt_ctx.streams[pkt.stream_index]->codec;", "codec->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);", "#ifdef PJSG\nif (codec->codec_type == CODEC_TYPE_AUDIO) {", "codec->frame_size = (codec->sample_rate * pkt.duration + 500000) / 1000000;", "}", "#endif\nif (av_write_packet(&VAR_0->fmt_ctx, &pkt, 0))\nVAR_0->state = HTTPSTATE_SEND_DATA_TRAILER;", "codec->frame_number++;", "}", "av_free_packet(&pkt);", "}", "}", "break;", "default:\ncase HTTPSTATE_SEND_DATA_TRAILER:\nif (VAR_0->last_packet_sent)\nreturn -1;", "av_write_trailer(&VAR_0->fmt_ctx);", "VAR_0->last_packet_sent = 1;", "break;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 45, 47 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103, 107, 109 ], [ 111 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149, 151 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169, 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219, 221 ], [ 223 ], [ 229 ], [ 231, 233, 235 ], [ 237 ], [ 241, 243 ], [ 247 ], [ 249 ], [ 251 ], [ 257 ], [ 259 ], [ 261 ], [ 265 ], [ 267 ], [ 269 ], [ 273 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343, 347 ], [ 351 ], [ 355, 357 ], [ 359 ], [ 363 ], [ 365, 369, 371 ], [ 375 ], [ 377 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389, 391, 395, 397 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ] ]

[ "void FUNC_0(struct NetRxPkt *VAR_0)\n{", "#ifdef NET_RX_PKT_DEBUG\nassert(VAR_0);", "printf(\"RX PKT: tot_len: %d, vlan_stripped: %d, vlan_tag: %d\\n\",\nVAR_0->tot_len, VAR_0->vlan_stripped, VAR_0->tci);", "#endif\n}" ]

[ 0, 0, 1, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2, AVPacket *VAR_3)\n{", "BinkContext * const c = VAR_0->priv_data;", "GetBitContext gb;", "int VAR_4;", "int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "uint8_t *dst, *prev, *ref, *ref_start, *ref_end;", "int VAR_11, VAR_12[2];", "const uint8_t *VAR_13;", "int VAR_14, VAR_15;", "DECLARE_ALIGNED_16(DCTELEM, block[64]);", "DECLARE_ALIGNED_16(uint8_t, ublock[64]);", "int VAR_16[64];", "if(c->pic.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &c->pic);", "if(VAR_0->get_buffer(VAR_0, &c->pic) < 0){", "av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return -1;", "}", "init_get_bits(&gb, VAR_3->VAR_1, VAR_3->size*8);", "if (c->version >= 'VAR_5')\nskip_bits_long(&gb, 32);", "for (VAR_7 = 0; VAR_7 < 3; VAR_7++) {", "const int VAR_17 = c->pic.linesize[VAR_7];", "int VAR_18 = VAR_7 ? (VAR_0->VAR_20 + 15) >> 4 : (VAR_0->VAR_20 + 7) >> 3;", "int VAR_19 = VAR_7 ? (VAR_0->height + 15) >> 4 : (VAR_0->height + 7) >> 3;", "int VAR_20 = VAR_0->VAR_20 >> !!VAR_7;", "init_lengths(c, FFMAX(VAR_20, 8), VAR_18);", "for (VAR_5 = 0; VAR_5 < BINK_NB_SRC; VAR_5++)", "read_bundle(&gb, c, VAR_5);", "VAR_8 = (!VAR_7 || !c->swap_planes) ? VAR_7 : (VAR_7 ^ 3);", "ref_start = c->last.VAR_1[VAR_8];", "ref_end = c->last.VAR_1[VAR_8]\n+ (VAR_18 - 1 + c->last.linesize[VAR_8] * (VAR_19 - 1)) * 8;", "for (VAR_5 = 0; VAR_5 < 64; VAR_5++)", "VAR_16[VAR_5] = (VAR_5 & 7) + (VAR_5 >> 3) * VAR_17;", "for (VAR_10 = 0; VAR_10 < VAR_19; VAR_10++) {", "if (read_block_types(VAR_0, &gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)\nreturn -1;", "if (read_block_types(VAR_0, &gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES]) < 0)\nreturn -1;", "if (read_colors(&gb, &c->bundle[BINK_SRC_COLORS], c) < 0)\nreturn -1;", "if (read_patterns(VAR_0, &gb, &c->bundle[BINK_SRC_PATTERN]) < 0)\nreturn -1;", "if (read_motion_values(VAR_0, &gb, &c->bundle[BINK_SRC_X_OFF]) < 0)\nreturn -1;", "if (read_motion_values(VAR_0, &gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)\nreturn -1;", "if (read_dcs(VAR_0, &gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)\nreturn -1;", "if (read_dcs(VAR_0, &gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)\nreturn -1;", "if (read_runs(VAR_0, &gb, &c->bundle[BINK_SRC_RUN]) < 0)\nreturn -1;", "if (VAR_10 == VAR_19)\nbreak;", "dst = c->pic.VAR_1[VAR_8] + 8*VAR_10*VAR_17;", "prev = c->last.VAR_1[VAR_8] + 8*VAR_10*VAR_17;", "for (VAR_9 = 0; VAR_9 < VAR_18; VAR_9++, dst += 8, prev += 8) {", "VAR_4 = get_value(c, BINK_SRC_BLOCK_TYPES);", "if ((VAR_10 & 1) && VAR_4 == SCALED_BLOCK) {", "VAR_9++;", "dst += 8;", "prev += 8;", "continue;", "}", "switch (VAR_4) {", "case SKIP_BLOCK:\nc->dsp.put_pixels_tab[1][0](dst, prev, VAR_17, 8);", "break;", "case SCALED_BLOCK:\nVAR_4 = get_value(c, BINK_SRC_SUB_BLOCK_TYPES);", "switch (VAR_4) {", "case RUN_BLOCK:\nVAR_13 = bink_patterns[get_bits(&gb, 4)];", "VAR_5 = 0;", "do {", "int VAR_22 = get_value(c, BINK_SRC_RUN) + 1;", "VAR_5 += VAR_22;", "if (VAR_5 > 64) {", "av_log(VAR_0, AV_LOG_ERROR, \"Run went out of bounds\\n\");", "return -1;", "}", "if (get_bits1(&gb)) {", "VAR_11 = get_value(c, BINK_SRC_COLORS);", "for (VAR_6 = 0; VAR_6 < VAR_22; VAR_6++)", "ublock[*VAR_13++] = VAR_11;", "} else {", "for (VAR_6 = 0; VAR_6 < VAR_22; VAR_6++)", "ublock[*VAR_13++] = get_value(c, BINK_SRC_COLORS);", "}", "} while (VAR_5 < 63);", "if (VAR_5 == 63)\nublock[*VAR_13++] = get_value(c, BINK_SRC_COLORS);", "break;", "case INTRA_BLOCK:\nc->dsp.clear_block(block);", "block[0] = get_value(c, BINK_SRC_INTRA_DC);", "read_dct_coeffs(&gb, block, c->scantable.permutated, 1);", "c->dsp.idct(block);", "c->dsp.put_pixels_nonclamped(block, ublock, 8);", "break;", "case FILL_BLOCK:\nVAR_11 = get_value(c, BINK_SRC_COLORS);", "c->dsp.fill_block_tab[0](dst, VAR_11, VAR_17, 16);", "break;", "case PATTERN_BLOCK:\nfor (VAR_5 = 0; VAR_5 < 2; VAR_5++)", "VAR_12[VAR_5] = get_value(c, BINK_SRC_COLORS);", "for (VAR_6 = 0; VAR_6 < 8; VAR_6++) {", "VAR_11 = get_value(c, BINK_SRC_PATTERN);", "for (VAR_5 = 0; VAR_5 < 8; VAR_5++, VAR_11 >>= 1)", "ublock[VAR_5 + VAR_6*8] = VAR_12[VAR_11 & 1];", "}", "break;", "case RAW_BLOCK:\nfor (VAR_6 = 0; VAR_6 < 8; VAR_6++)", "for (VAR_5 = 0; VAR_5 < 8; VAR_5++)", "ublock[VAR_5 + VAR_6*8] = get_value(c, BINK_SRC_COLORS);", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Incorrect 16x16 block type %d\\n\", VAR_4);", "return -1;", "}", "if (VAR_4 != FILL_BLOCK)\nc->dsp.scale_block(ublock, dst, VAR_17);", "VAR_9++;", "dst += 8;", "prev += 8;", "break;", "case MOTION_BLOCK:\nVAR_14 = get_value(c, BINK_SRC_X_OFF);", "VAR_15 = get_value(c, BINK_SRC_Y_OFF);", "ref = prev + VAR_14 + VAR_15 * VAR_17;", "if (ref < ref_start || ref > ref_end) {", "av_log(VAR_0, AV_LOG_ERROR, \"Copy out of bounds @%d, %d\\n\",\nVAR_9*8 + VAR_14, VAR_10*8 + VAR_15);", "return -1;", "}", "c->dsp.put_pixels_tab[1][0](dst, ref, VAR_17, 8);", "break;", "case RUN_BLOCK:\nVAR_13 = bink_patterns[get_bits(&gb, 4)];", "VAR_5 = 0;", "do {", "int VAR_22 = get_value(c, BINK_SRC_RUN) + 1;", "VAR_5 += VAR_22;", "if (VAR_5 > 64) {", "av_log(VAR_0, AV_LOG_ERROR, \"Run went out of bounds\\n\");", "return -1;", "}", "if (get_bits1(&gb)) {", "VAR_11 = get_value(c, BINK_SRC_COLORS);", "for (VAR_6 = 0; VAR_6 < VAR_22; VAR_6++)", "dst[VAR_16[*VAR_13++]] = VAR_11;", "} else {", "for (VAR_6 = 0; VAR_6 < VAR_22; VAR_6++)", "dst[VAR_16[*VAR_13++]] = get_value(c, BINK_SRC_COLORS);", "}", "} while (VAR_5 < 63);", "if (VAR_5 == 63)\ndst[VAR_16[*VAR_13++]] = get_value(c, BINK_SRC_COLORS);", "break;", "case RESIDUE_BLOCK:\nVAR_14 = get_value(c, BINK_SRC_X_OFF);", "VAR_15 = get_value(c, BINK_SRC_Y_OFF);", "ref = prev + VAR_14 + VAR_15 * VAR_17;", "if (ref < ref_start || ref > ref_end) {", "av_log(VAR_0, AV_LOG_ERROR, \"Copy out of bounds @%d, %d\\n\",\nVAR_9*8 + VAR_14, VAR_10*8 + VAR_15);", "return -1;", "}", "c->dsp.put_pixels_tab[1][0](dst, ref, VAR_17, 8);", "c->dsp.clear_block(block);", "VAR_11 = get_bits(&gb, 7);", "read_residue(&gb, block, VAR_11);", "c->dsp.add_pixels8(dst, block, VAR_17);", "break;", "case INTRA_BLOCK:\nc->dsp.clear_block(block);", "block[0] = get_value(c, BINK_SRC_INTRA_DC);", "read_dct_coeffs(&gb, block, c->scantable.permutated, 1);", "c->dsp.idct_put(dst, VAR_17, block);", "break;", "case FILL_BLOCK:\nVAR_11 = get_value(c, BINK_SRC_COLORS);", "c->dsp.fill_block_tab[1](dst, VAR_11, VAR_17, 8);", "break;", "case INTER_BLOCK:\nVAR_14 = get_value(c, BINK_SRC_X_OFF);", "VAR_15 = get_value(c, BINK_SRC_Y_OFF);", "ref = prev + VAR_14 + VAR_15 * VAR_17;", "c->dsp.put_pixels_tab[1][0](dst, ref, VAR_17, 8);", "c->dsp.clear_block(block);", "block[0] = get_value(c, BINK_SRC_INTER_DC);", "read_dct_coeffs(&gb, block, c->scantable.permutated, 0);", "c->dsp.idct_add(dst, VAR_17, block);", "break;", "case PATTERN_BLOCK:\nfor (VAR_5 = 0; VAR_5 < 2; VAR_5++)", "VAR_12[VAR_5] = get_value(c, BINK_SRC_COLORS);", "for (VAR_5 = 0; VAR_5 < 8; VAR_5++) {", "VAR_11 = get_value(c, BINK_SRC_PATTERN);", "for (VAR_6 = 0; VAR_6 < 8; VAR_6++, VAR_11 >>= 1)", "dst[VAR_5*VAR_17 + VAR_6] = VAR_12[VAR_11 & 1];", "}", "break;", "case RAW_BLOCK:\nfor (VAR_5 = 0; VAR_5 < 8; VAR_5++)", "memcpy(dst + VAR_5*VAR_17, c->bundle[BINK_SRC_COLORS].cur_ptr + VAR_5*8, 8);", "c->bundle[BINK_SRC_COLORS].cur_ptr += 64;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unknown block type %d\\n\", VAR_4);", "return -1;", "}", "}", "}", "if (get_bits_count(&gb) & 0x1F)\nskip_bits_long(&gb, 32 - (get_bits_count(&gb) & 0x1F));", "}", "emms_c();", "*VAR_2 = sizeof(AVFrame);", "*(AVFrame*)VAR_1 = c->pic;", "FFSWAP(AVFrame, c->pic, c->last);", "return VAR_3->size;", "}" ]

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

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

[ "static void FUNC_0(CPUMIPSState *VAR_0, DisasContext *VAR_1, uint32_t VAR_2,\nuint32_t VAR_3)\n{", "#define MASK_MSA_ELM(op) (MASK_MSA_MINOR(op) | (op & (0xf << 22)))\nuint8_t ws = (VAR_1->opcode >> 11) & 0x1f;", "uint8_t wd = (VAR_1->opcode >> 6) & 0x1f;", "TCGv_i32 tws = tcg_const_i32(ws);", "TCGv_i32 twd = tcg_const_i32(wd);", "TCGv_i32 tn = tcg_const_i32(VAR_3);", "TCGv_i32 tdf = tcg_const_i32(VAR_2);", "switch (MASK_MSA_ELM(VAR_1->opcode)) {", "case OPC_SLDI_df:\ngen_helper_msa_sldi_df(cpu_env, tdf, twd, tws, tn);", "break;", "case OPC_SPLATI_df:\ngen_helper_msa_splati_df(cpu_env, tdf, twd, tws, tn);", "break;", "case OPC_INSVE_df:\ngen_helper_msa_insve_df(cpu_env, tdf, twd, tws, tn);", "break;", "case OPC_COPY_S_df:\ncase OPC_COPY_U_df:\ncase OPC_INSERT_df:\n#if !defined(TARGET_MIPS64)\nif (VAR_2 == DF_DOUBLE) {", "generate_exception_end(VAR_1, EXCP_RI);", "break;", "}", "#endif\nswitch (MASK_MSA_ELM(VAR_1->opcode)) {", "case OPC_COPY_S_df:\ngen_helper_msa_copy_s_df(cpu_env, tdf, twd, tws, tn);", "break;", "case OPC_COPY_U_df:\ngen_helper_msa_copy_u_df(cpu_env, tdf, twd, tws, tn);", "break;", "case OPC_INSERT_df:\ngen_helper_msa_insert_df(cpu_env, tdf, twd, tws, tn);", "break;", "}", "break;", "default:\nMIPS_INVAL(\"MSA instruction\");", "generate_exception_end(VAR_1, EXCP_RI);", "}", "tcg_temp_free_i32(twd);", "tcg_temp_free_i32(tws);", "tcg_temp_free_i32(tn);", "tcg_temp_free_i32(tdf);", "}" ]

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

[ [ 1, 3, 5 ], [ 7, 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45, 47, 49, 51, 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 ] ]

[ "static int FUNC_0(PNGContext *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "int VAR_3;", "VAR_0->zstream.avail_in = VAR_2;", "VAR_0->zstream.next_in = (uint8_t *)VAR_1;", "while (VAR_0->zstream.avail_in > 0) {", "VAR_3 = deflate(&VAR_0->zstream, Z_NO_FLUSH);", "if (VAR_3 != Z_OK)\nreturn -1;", "if (VAR_0->zstream.avail_out == 0) {", "png_write_chunk(&VAR_0->bytestream, MKTAG('I', 'D', 'A', 'T'), VAR_0->buf, IOBUF_SIZE);", "VAR_0->zstream.avail_out = IOBUF_SIZE;", "VAR_0->zstream.next_out = VAR_0->buf;", "}", "}", "return 0;", "}" ]

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

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

[ "static uint32_t FUNC_0(VirtIODevice *vdev, uint32_t features)\n{", "VirtIOSerial *vser;", "vser = DO_UPCAST(VirtIOSerial, vdev, vdev);", "if (vser->bus->max_nr_ports > 1) {", "features |= (1 << VIRTIO_CONSOLE_F_MULTIPORT);", "}", "return features;", "}" ]

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

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

[ "static void FUNC_0(pred4x4_127_dc)(uint8_t *_src, const uint8_t *topright, int _stride){", "pixel *src = (pixel*)_src;", "int VAR_0 = _stride/sizeof(pixel);", "((pixel4*)(src+0*VAR_0))[0]=\n((pixel4*)(src+1*VAR_0))[0]=\n((pixel4*)(src+2*VAR_0))[0]=\n((pixel4*)(src+3*VAR_0))[0]= PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))-1);", "}" ]

[ 0, 0, 0, 1, 0 ]

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

[ "av_cold int FUNC_0(AVCodecContext *avctx)\n{", "VAAPIEncodeContext *ctx = avctx->priv_data;", "VAAPIEncodePicture *pic, *next;", "for (pic = ctx->pic_start; pic; pic = next) {", "next = pic->next;", "vaapi_encode_free(avctx, pic);", "}", "if (ctx->va_context != VA_INVALID_ID)\nvaDestroyContext(ctx->hwctx->display, ctx->va_context);", "if (ctx->va_config != VA_INVALID_ID)\nvaDestroyConfig(ctx->hwctx->display, ctx->va_config);", "if (ctx->codec->close)\nctx->codec->close(avctx);", "av_freep(&ctx->codec_sequence_params);", "av_freep(&ctx->codec_picture_params);", "av_buffer_unref(&ctx->recon_frames_ref);", "av_buffer_unref(&ctx->input_frames_ref);", "av_buffer_unref(&ctx->device_ref);", "av_freep(&ctx->priv_data);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21, 23 ], [ 27, 29 ], [ 33, 35 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 57 ], [ 59 ] ]

[ "static int FUNC_0(AVFilterLink *VAR_0, AVFrame *VAR_1)\n{", "AVFilterContext *ctx = VAR_0->dst;", "TrimContext *s = ctx->priv;", "int VAR_2;", "if (s->eof) {", "av_frame_free(&VAR_1);", "return 0;", "}", "if (s->start_frame >= 0 || s->start_pts != AV_NOPTS_VALUE) {", "VAR_2 = 1;", "if (s->start_frame >= 0 && s->nb_frames >= s->start_frame)\nVAR_2 = 0;", "if (s->start_pts != AV_NOPTS_VALUE && VAR_1->pts != AV_NOPTS_VALUE &&\nVAR_1->pts >= s->start_pts)\nVAR_2 = 0;", "if (VAR_2)\ngoto VAR_2;", "}", "if (s->first_pts == AV_NOPTS_VALUE && VAR_1->pts != AV_NOPTS_VALUE)\ns->first_pts = VAR_1->pts;", "if (s->end_frame != INT64_MAX || s->end_pts != AV_NOPTS_VALUE || s->duration_tb) {", "VAR_2 = 1;", "if (s->end_frame != INT64_MAX && s->nb_frames < s->end_frame)\nVAR_2 = 0;", "if (s->end_pts != AV_NOPTS_VALUE && VAR_1->pts != AV_NOPTS_VALUE &&\nVAR_1->pts < s->end_pts)\nVAR_2 = 0;", "if (s->duration_tb && VAR_1->pts != AV_NOPTS_VALUE &&\nVAR_1->pts - s->first_pts < s->duration_tb)\nVAR_2 = 0;", "if (VAR_2) {", "s->eof = 1;", "goto VAR_2;", "}", "}", "s->nb_frames++;", "s->got_output = 1;", "return ff_filter_frame(ctx->outputs[0], VAR_1);", "VAR_2:\ns->nb_frames++;", "av_frame_free(&VAR_1);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(yuv2rgb32_2)(SwsContext *c, const uint16_t *buf0,\nconst uint16_t *buf1, const uint16_t *ubuf0,\nconst uint16_t *ubuf1, const uint16_t *vbuf0,\nconst uint16_t *vbuf1, const uint16_t *abuf0,\nconst uint16_t *abuf1, uint8_t *dest,\nint dstW, int yalpha, int uvalpha, int y)\n{", "if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {", "#if ARCH_X86_64\n__asm__ volatile(\nYSCALEYUV2RGB(%%r8, %5)\nYSCALEYUV2RGB_YA(%%r8, %5, %6, %7)\n\"psraw $3, %%mm1 \\n\\t\"\n\"psraw $3, %%mm7 \\n\\t\"\n\"packuswb %%mm7, %%mm1 \\n\\t\"\nWRITEBGR32(%4, 8280(%5), %%r8, %%mm2, %%mm4, %%mm5, %%mm1, %%mm0, %%mm7, %%mm3, %%mm6)\n:: \"c\" (buf0), \"d\" (buf1), \"S\" (ubuf0), \"D\" (ubuf1), \"r\" (dest),\n\"a\" (&c->redDither),\n\"r\" (abuf0), \"r\" (abuf1)\n: \"%r8\"\n);", "#else\n*(const uint16_t **)(&c->u_temp)=abuf0;", "*(const uint16_t **)(&c->v_temp)=abuf1;", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB(%%REGBP, %5)\n\"push %0 \\n\\t\"\n\"push %1 \\n\\t\"\n\"mov \"U_TEMP\"(%5), %0 \\n\\t\"\n\"mov \"V_TEMP\"(%5), %1 \\n\\t\"\nYSCALEYUV2RGB_YA(%%REGBP, %5, %0, %1)\n\"psraw $3, %%mm1 \\n\\t\"\n\"psraw $3, %%mm7 \\n\\t\"\n\"packuswb %%mm7, %%mm1 \\n\\t\"\n\"pop %1 \\n\\t\"\n\"pop %0 \\n\\t\"\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm1, %%mm0, %%mm7, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (buf1), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);", "#endif\n} else {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB(%%REGBP, %5)\n\"pcmpeqd %%mm7, %%mm7 \\n\\t\"\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (buf1), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);", "}", "}" ]

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

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

[ "static int FUNC_0(AVIOContext * VAR_0, char* VAR_1, int VAR_2)\n{", "int VAR_3;", "for (VAR_3 = 0; VAR_3 < VAR_2 - 1; VAR_3++) {", "int VAR_4 = avio_r8(VAR_0);", "if (VAR_4 == 0)\nbreak;", "if (VAR_4 == '\\n') {", "VAR_1[VAR_3] = '\\0';", "return 0;", "}", "VAR_1[VAR_3] = VAR_4;", "}", "VAR_1[VAR_3] = '\\0';", "return -1;", "}" ]

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

[ "static int FUNC_0(TiffContext *VAR_0)\n{", "unsigned VAR_1, VAR_2, VAR_3, VAR_4, VAR_5 = 0;", "int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "int VAR_11;", "uint32_t *pal;", "double *VAR_12;", "VAR_1 = tget_short(&VAR_0->gb, VAR_0->le);", "VAR_2 = tget_short(&VAR_0->gb, VAR_0->le);", "VAR_3 = tget_long(&VAR_0->gb, VAR_0->le);", "VAR_4 = tget_long(&VAR_0->gb, VAR_0->le);", "VAR_10 = bytestream2_tell(&VAR_0->gb);", "if (VAR_2 == 0 || VAR_2 >= FF_ARRAY_ELEMS(type_sizes)) {", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"Unknown tiff VAR_2 (%u) encountered\\n\",\nVAR_2);", "return 0;", "}", "if (VAR_3 == 1) {", "switch (VAR_2) {", "case TIFF_BYTE:\ncase TIFF_SHORT:\nbytestream2_seek(&VAR_0->gb, -4, SEEK_CUR);", "VAR_5 = tget(&VAR_0->gb, VAR_2, VAR_0->le);", "break;", "case TIFF_LONG:\nVAR_5 = VAR_4;", "break;", "case TIFF_STRING:\nif (VAR_3 <= 4) {", "bytestream2_seek(&VAR_0->gb, -4, SEEK_CUR);", "break;", "}", "default:\nVAR_5 = UINT_MAX;", "bytestream2_seek(&VAR_0->gb, VAR_4, SEEK_SET);", "}", "} else {", "if (VAR_3 <= 4 && type_sizes[VAR_2] * VAR_3 <= 4) {", "bytestream2_seek(&VAR_0->gb, -4, SEEK_CUR);", "} else {", "bytestream2_seek(&VAR_0->gb, VAR_4, SEEK_SET);", "}", "}", "switch (VAR_1) {", "case TIFF_WIDTH:\nVAR_0->width = VAR_5;", "break;", "case TIFF_HEIGHT:\nVAR_0->height = VAR_5;", "break;", "case TIFF_BPP:\nVAR_0->bppcount = VAR_3;", "if (VAR_3 > 4) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"This format is not supported (bpp=%d, %d components)\\n\",\nVAR_0->bpp, VAR_3);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_3 == 1)\nVAR_0->bpp = VAR_5;", "else {", "switch (VAR_2) {", "case TIFF_BYTE:\nVAR_0->bpp = (VAR_4 & 0xFF) + ((VAR_4 >> 8) & 0xFF) +\n((VAR_4 >> 16) & 0xFF) + ((VAR_4 >> 24) & 0xFF);", "break;", "case TIFF_SHORT:\ncase TIFF_LONG:\nVAR_0->bpp = 0;", "if (bytestream2_get_bytes_left(&VAR_0->gb) < type_sizes[VAR_2] * VAR_3)\nreturn AVERROR_INVALIDDATA;", "for (VAR_6 = 0; VAR_6 < VAR_3; VAR_6++)", "VAR_0->bpp += tget(&VAR_0->gb, VAR_2, VAR_0->le);", "break;", "default:\nVAR_0->bpp = -1;", "}", "}", "break;", "case TIFF_SAMPLES_PER_PIXEL:\nif (VAR_3 != 1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Samples per pixel requires a single VAR_5, many provided\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_0->bppcount == 1)\nVAR_0->bpp *= VAR_5;", "VAR_0->bppcount = VAR_5;", "break;", "case TIFF_COMPR:\nVAR_0->compr = VAR_5;", "VAR_0->predictor = 0;", "switch (VAR_0->compr) {", "case TIFF_RAW:\ncase TIFF_PACKBITS:\ncase TIFF_LZW:\ncase TIFF_CCITT_RLE:\nbreak;", "case TIFF_G3:\ncase TIFF_G4:\nVAR_0->fax_opts = 0;", "break;", "case TIFF_DEFLATE:\ncase TIFF_ADOBE_DEFLATE:\n#if CONFIG_ZLIB\nbreak;", "#else\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Deflate: ZLib not compiled in\\n\");", "return AVERROR(ENOSYS);", "#endif\ncase TIFF_JPEG:\ncase TIFF_NEWJPEG:\nav_log(VAR_0->avctx, AV_LOG_ERROR,\n\"JPEG compression is not supported\\n\");", "return AVERROR_PATCHWELCOME;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Unknown compression method %VAR_6\\n\",\nVAR_0->compr);", "return AVERROR_INVALIDDATA;", "}", "break;", "case TIFF_ROWSPERSTRIP:\nif (VAR_2 == TIFF_LONG && VAR_5 == UINT_MAX)\nVAR_5 = VAR_0->height;", "if (VAR_5 < 1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Incorrect VAR_5 of rows per strip\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->rps = VAR_5;", "break;", "case TIFF_STRIP_OFFS:\nif (VAR_3 == 1) {", "VAR_0->strippos = 0;", "VAR_0->stripoff = VAR_5;", "} else", "VAR_0->strippos = VAR_4;", "VAR_0->strips = VAR_3;", "if (VAR_0->strips == 1)\nVAR_0->rps = VAR_0->height;", "VAR_0->sot = VAR_2;", "if (VAR_0->strippos > bytestream2_size(&VAR_0->gb)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Tag referencing position outside the image\\n\");", "return AVERROR_INVALIDDATA;", "}", "break;", "case TIFF_STRIP_SIZE:\nif (VAR_3 == 1) {", "VAR_0->stripsizesoff = 0;", "VAR_0->stripsize = VAR_5;", "VAR_0->strips = 1;", "} else {", "VAR_0->stripsizesoff = VAR_4;", "}", "VAR_0->strips = VAR_3;", "VAR_0->sstype = VAR_2;", "if (VAR_0->stripsizesoff > bytestream2_size(&VAR_0->gb)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Tag referencing position outside the image\\n\");", "return AVERROR_INVALIDDATA;", "}", "break;", "case TIFF_TILE_BYTE_COUNTS:\ncase TIFF_TILE_LENGTH:\ncase TIFF_TILE_OFFSETS:\ncase TIFF_TILE_WIDTH:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Tiled images are not supported\\n\");", "return AVERROR_PATCHWELCOME;", "break;", "case TIFF_PREDICTOR:\nVAR_0->predictor = VAR_5;", "break;", "case TIFF_INVERT:\nswitch (VAR_5) {", "case 0:\nVAR_0->invert = 1;", "break;", "case 1:\nVAR_0->invert = 0;", "break;", "case 2:\ncase 3:\nbreak;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Color mode %d is not supported\\n\",\nVAR_5);", "return AVERROR_INVALIDDATA;", "}", "break;", "case TIFF_FILL_ORDER:\nif (VAR_5 < 1 || VAR_5 > 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Unknown FillOrder VAR_5 %d, trying default one\\n\", VAR_5);", "VAR_5 = 1;", "}", "VAR_0->fill_order = VAR_5 - 1;", "break;", "case TIFF_PAL:\npal = (uint32_t *) VAR_0->palette;", "VAR_4 = type_sizes[VAR_2];", "if (VAR_3 / 3 > 256 || bytestream2_get_bytes_left(&VAR_0->gb) < VAR_3 / 3 * VAR_4 * 3)\nreturn AVERROR_INVALIDDATA;", "VAR_4 = (type_sizes[VAR_2] - 1) << 3;", "for (VAR_8 = 2; VAR_8 >= 0; VAR_8--) {", "for (VAR_6 = 0; VAR_6 < VAR_3 / 3; VAR_6++) {", "if (VAR_8 == 2)\npal[VAR_6] = 0xFFU << 24;", "VAR_7 = (tget(&VAR_0->gb, VAR_2, VAR_0->le) >> VAR_4) << (VAR_8 * 8);", "pal[VAR_6] |= VAR_7;", "}", "}", "VAR_0->palette_is_set = 1;", "break;", "case TIFF_PLANAR:\nif (VAR_5 == 2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Planar format is not supported\\n\");", "return AVERROR_PATCHWELCOME;", "}", "break;", "case TIFF_T4OPTIONS:\nif (VAR_0->compr == TIFF_G3)\nVAR_0->fax_opts = VAR_5;", "break;", "case TIFF_T6OPTIONS:\nif (VAR_0->compr == TIFF_G4)\nVAR_0->fax_opts = VAR_5;", "break;", "#define ADD_METADATA(VAR_3, name, sep)\\\nif ((VAR_11 = add_metadata(VAR_3, VAR_2, name, sep, VAR_0)) < 0) {\\", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");\\", "return VAR_11;\\", "}", "case TIFF_MODEL_PIXEL_SCALE:\nADD_METADATA(VAR_3, \"ModelPixelScaleTag\", NULL);", "break;", "case TIFF_MODEL_TRANSFORMATION:\nADD_METADATA(VAR_3, \"ModelTransformationTag\", NULL);", "break;", "case TIFF_MODEL_TIEPOINT:\nADD_METADATA(VAR_3, \"ModelTiepointTag\", NULL);", "break;", "case TIFF_GEO_KEY_DIRECTORY:\nADD_METADATA(1, \"GeoTIFF_Version\", NULL);", "ADD_METADATA(2, \"GeoTIFF_Key_Revision\", \".\");", "VAR_0->geotag_count = tget_short(&VAR_0->gb, VAR_0->le);", "if (VAR_0->geotag_count > VAR_3 / 4 - 1) {", "VAR_0->geotag_count = VAR_3 / 4 - 1;", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"GeoTIFF key directory buffer shorter than specified\\n\");", "}", "if (bytestream2_get_bytes_left(&VAR_0->gb) < VAR_0->geotag_count * sizeof(int16_t) * 4)\nreturn -1;", "VAR_0->geotags = av_mallocz(sizeof(TiffGeoTag) * VAR_0->geotag_count);", "if (!VAR_0->geotags) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "return AVERROR(ENOMEM);", "}", "for (VAR_6 = 0; VAR_6 < VAR_0->geotag_count; VAR_6++) {", "VAR_0->geotags[VAR_6].key = tget_short(&VAR_0->gb, VAR_0->le);", "VAR_0->geotags[VAR_6].VAR_2 = tget_short(&VAR_0->gb, VAR_0->le);", "VAR_0->geotags[VAR_6].VAR_3 = tget_short(&VAR_0->gb, VAR_0->le);", "if (!VAR_0->geotags[VAR_6].VAR_2)\nVAR_0->geotags[VAR_6].val = get_geokey_val(VAR_0->geotags[VAR_6].key, tget_short(&VAR_0->gb, VAR_0->le));", "else\nVAR_0->geotags[VAR_6].offset = tget_short(&VAR_0->gb, VAR_0->le);", "}", "break;", "case TIFF_GEO_DOUBLE_PARAMS:\nif (VAR_3 >= INT_MAX / sizeof(int64_t))\nreturn AVERROR_INVALIDDATA;", "if (bytestream2_get_bytes_left(&VAR_0->gb) < VAR_3 * sizeof(int64_t))\nreturn AVERROR_INVALIDDATA;", "VAR_12 = av_malloc(VAR_3 * sizeof(double));", "if (!VAR_12) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "return AVERROR(ENOMEM);", "}", "for (VAR_6 = 0; VAR_6 < VAR_3; VAR_6++)", "VAR_12[VAR_6] = tget_double(&VAR_0->gb, VAR_0->le);", "for (VAR_6 = 0; VAR_6 < VAR_0->geotag_count; VAR_6++) {", "if (VAR_0->geotags[VAR_6].VAR_2 == TIFF_GEO_DOUBLE_PARAMS) {", "if (VAR_0->geotags[VAR_6].VAR_3 == 0\n|| VAR_0->geotags[VAR_6].offset + VAR_0->geotags[VAR_6].VAR_3 > VAR_3) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Invalid GeoTIFF key %d\\n\", VAR_0->geotags[VAR_6].key);", "} else {", "char *ap = doubles2str(&VAR_12[VAR_0->geotags[VAR_6].offset], VAR_0->geotags[VAR_6].VAR_3, \", \");", "if (!ap) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "av_freep(&VAR_12);", "return AVERROR(ENOMEM);", "}", "VAR_0->geotags[VAR_6].val = ap;", "}", "}", "}", "av_freep(&VAR_12);", "break;", "case TIFF_GEO_ASCII_PARAMS:\nVAR_9 = bytestream2_tell(&VAR_0->gb);", "for (VAR_6 = 0; VAR_6 < VAR_0->geotag_count; VAR_6++) {", "if (VAR_0->geotags[VAR_6].VAR_2 == TIFF_GEO_ASCII_PARAMS) {", "if (VAR_0->geotags[VAR_6].VAR_3 == 0\n|| VAR_0->geotags[VAR_6].offset + VAR_0->geotags[VAR_6].VAR_3 > VAR_3) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Invalid GeoTIFF key %d\\n\", VAR_0->geotags[VAR_6].key);", "} else {", "char *ap;", "bytestream2_seek(&VAR_0->gb, VAR_9 + VAR_0->geotags[VAR_6].offset, SEEK_SET);", "if (bytestream2_get_bytes_left(&VAR_0->gb) < VAR_0->geotags[VAR_6].VAR_3)\nreturn AVERROR_INVALIDDATA;", "ap = av_malloc(VAR_0->geotags[VAR_6].VAR_3);", "if (!ap) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Error allocating temporary buffer\\n\");", "return AVERROR(ENOMEM);", "}", "bytestream2_get_bufferu(&VAR_0->gb, ap, VAR_0->geotags[VAR_6].VAR_3);", "ap[VAR_0->geotags[VAR_6].VAR_3 - 1] = '\\0';", "VAR_0->geotags[VAR_6].val = ap;", "}", "}", "}", "break;", "case TIFF_ARTIST:\nADD_METADATA(VAR_3, \"artist\", NULL);", "break;", "case TIFF_COPYRIGHT:\nADD_METADATA(VAR_3, \"copyright\", NULL);", "break;", "case TIFF_DATE:\nADD_METADATA(VAR_3, \"date\", NULL);", "break;", "case TIFF_DOCUMENT_NAME:\nADD_METADATA(VAR_3, \"document_name\", NULL);", "break;", "case TIFF_HOST_COMPUTER:\nADD_METADATA(VAR_3, \"computer\", NULL);", "break;", "case TIFF_IMAGE_DESCRIPTION:\nADD_METADATA(VAR_3, \"description\", NULL);", "break;", "case TIFF_MAKE:\nADD_METADATA(VAR_3, \"make\", NULL);", "break;", "case TIFF_MODEL:\nADD_METADATA(VAR_3, \"model\", NULL);", "break;", "case TIFF_PAGE_NAME:\nADD_METADATA(VAR_3, \"page_name\", NULL);", "break;", "case TIFF_PAGE_NUMBER:\nADD_METADATA(VAR_3, \"page_number\", \" / \");", "break;", "case TIFF_SOFTWARE_NAME:\nADD_METADATA(VAR_3, \"software\", NULL);", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"Unknown or unsupported VAR_1 %d/0X%0X\\n\",\nVAR_1, VAR_1);", "}", "bytestream2_seek(&VAR_0->gb, VAR_10, SEEK_SET);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 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 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 103, 105 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115, 117, 119 ], [ 121 ], [ 123 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133, 135, 137 ], [ 139 ], [ 141, 143, 145 ], [ 147, 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169 ], [ 171, 173 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 187, 189 ], [ 191 ], [ 193 ], [ 195, 197, 199, 201, 203 ], [ 205, 207, 209 ], [ 211 ], [ 213, 215, 217, 219 ], [ 221, 223 ], [ 225 ], [ 227, 229, 231, 233, 235 ], [ 237 ], [ 239, 241, 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251, 253, 255 ], [ 257 ], [ 259, 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271, 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285, 287 ], [ 289 ], [ 291 ], [ 293, 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303, 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325, 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335, 337, 339, 341, 343 ], [ 345 ], [ 347 ], [ 349, 351 ], [ 353 ], [ 355, 357 ], [ 359, 361 ], [ 363 ], [ 365, 367 ], [ 369 ], [ 371, 373, 375 ], [ 377, 379, 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389, 391 ], [ 393, 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ], [ 411, 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421, 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437, 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449, 451, 453 ], [ 455 ], [ 457, 459, 461 ], [ 463 ], [ 465, 467 ], [ 469 ], [ 471 ], [ 473 ], [ 475, 477 ], [ 479 ], [ 481, 483 ], [ 485 ], [ 487, 489 ], [ 491 ], [ 493, 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509, 511 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 533, 535 ], [ 537, 539 ], [ 541 ], [ 543 ], [ 545, 547, 549 ], [ 551, 553 ], [ 555 ], [ 557 ], [ 559 ], [ 561 ], [ 563 ], [ 565 ], [ 567 ], [ 569 ], [ 571 ], [ 573, 575 ], [ 577 ], [ 579 ], [ 581 ], [ 583 ], [ 585 ], [ 587 ], [ 589 ], [ 591 ], [ 593 ], [ 595 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605, 607 ], [ 609 ], [ 611 ], [ 613, 615 ], [ 617 ], [ 619 ], [ 621 ], [ 625 ], [ 627, 629 ], [ 631 ], [ 633 ], [ 635 ], [ 637 ], [ 639 ], [ 641 ], [ 643 ], [ 645 ], [ 647 ], [ 649 ], [ 651 ], [ 653 ], [ 655, 657 ], [ 659 ], [ 661, 663 ], [ 665 ], [ 667, 669 ], [ 671 ], [ 673, 675 ], [ 677 ], [ 679, 681 ], [ 683 ], [ 685, 687 ], [ 689 ], [ 691, 693 ], [ 695 ], [ 697, 699 ], [ 701 ], [ 703, 705 ], [ 707 ], [ 709, 711 ], [ 713 ], [ 715, 717 ], [ 719 ], [ 721, 723, 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733 ] ]

[ "void FUNC_0(void *VAR_0, int VAR_1, const char *VAR_2, va_list VAR_3)\n{", "static int VAR_4 = 1;", "static int VAR_5;", "static char VAR_6[1024];", "char VAR_7[1024];", "static int VAR_8;", "AVClass* avc = VAR_0 ? *(AVClass **) VAR_0 : NULL;", "int VAR_9 = av_clip(VAR_1 >> 8, 0, 256);", "VAR_1 &= 0xff;", "if (VAR_1 > av_log_level)\nreturn;", "VAR_7[0] = 0;", "if (VAR_4 && avc) {", "if (avc->parent_log_context_offset) {", "AVClass** parent = *(AVClass ***) (((uint8_t *) VAR_0) +\navc->parent_log_context_offset);", "if (parent && *parent) {", "snprintf(VAR_7, sizeof(VAR_7), \"[%s @ %p] \",\n(*parent)->item_name(parent), parent);", "}", "}", "snprintf(VAR_7 + strlen(VAR_7), sizeof(VAR_7) - strlen(VAR_7), \"[%s @ %p] \",\navc->item_name(VAR_0), VAR_0);", "}", "vsnprintf(VAR_7 + strlen(VAR_7), sizeof(VAR_7) - strlen(VAR_7), VAR_2, VAR_3);", "VAR_4 = strlen(VAR_7) && VAR_7[strlen(VAR_7) - 1] == '\\n';", "#if HAVE_ISATTY\nif (!VAR_8)\nVAR_8 = isatty(2) ? 1 : -1;", "#endif\nif (VAR_4 && (flags & AV_LOG_SKIP_REPEATED) &&\n!strncmp(VAR_7, VAR_6, sizeof VAR_7)) {", "VAR_5++;", "if (VAR_8 == 1)\nfprintf(stderr, \" Last message repeated %d times\\r\", VAR_5);", "return;", "}", "if (VAR_5 > 0) {", "fprintf(stderr, \" Last message repeated %d times\\n\", VAR_5);", "VAR_5 = 0;", "}", "colored_fputs(av_clip(VAR_1 >> 3, 0, 6), VAR_9, VAR_7);", "av_strlcpy(VAR_6, VAR_7, sizeof VAR_7);", "}" ]

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

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

[ "void FUNC_0(BlockJob *VAR_0, int VAR_1)\n{", "BlockDriverState *bs = VAR_0->bs;", "assert(bs->VAR_0 == VAR_0);", "VAR_0->cb(VAR_0->opaque, VAR_1);", "bs->VAR_0 = NULL;", "bdrv_op_unblock_all(bs, VAR_0->blocker);", "error_free(VAR_0->blocker);", "g_free(VAR_0);", "}" ]

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

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

[ "static void FUNC_0(const TestData *VAR_0, uint16_t VAR_1)\n{", "qpci_io_writew(VAR_0->dev, VAR_0->tco_io_base + TCO_TMR, VAR_1);", "}" ]

[ 0, 1, 0 ]

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

[ "int FUNC_0(DisplayState *VAR_0, const char *VAR_1)\n{", "VncDisplay *vs = VAR_0 ? (VncDisplay *)VAR_0->opaque : vnc_display;", "if (!vs) {", "return -EINVAL;", "}", "if (!VAR_1) {", "return vnc_display_disable_login(VAR_0);", "}", "if (vs->VAR_1) {", "g_free(vs->VAR_1);", "vs->VAR_1 = NULL;", "}", "vs->VAR_1 = g_strdup(VAR_1);", "if (vs->auth == VNC_AUTH_NONE) {", "vs->auth = VNC_AUTH_VNC;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ] ]

[ "static void FUNC_0(VirtIOBlockDataPlane *VAR_0)\n{", "if (VAR_0->blocker) {", "blk_op_unblock_all(VAR_0->conf->conf.blk, VAR_0->blocker);", "error_free(VAR_0->blocker);", "VAR_0->blocker = NULL;", "}", "}" ]

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

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

[ "static int FUNC_0 (HWVoiceIn *VAR_0)\n{", "NoVoiceIn *no = (NoVoiceIn *) VAR_0;", "int VAR_1 = audio_pcm_hw_get_live_in (VAR_0);", "int VAR_2 = VAR_0->VAR_3 - VAR_1;", "int VAR_3 = 0;", "if (VAR_2) {", "int64_t now = qemu_get_clock (vm_clock);", "int64_t ticks = now - no->old_ticks;", "int64_t bytes =\nmuldiv64 (ticks, VAR_0->info.bytes_per_second, get_ticks_per_sec ());", "no->old_ticks = now;", "bytes = audio_MIN (bytes, INT_MAX);", "VAR_3 = bytes >> VAR_0->info.shift;", "VAR_3 = audio_MIN (VAR_3, VAR_2);", "}", "return VAR_3;", "}" ]

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

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

[ "int FUNC_0(Object *VAR_0, VFIODevice *VAR_1, VFIORegion *VAR_2,\nint VAR_3, const char *VAR_4)\n{", "struct vfio_region_info *VAR_5;", "int VAR_6;", "VAR_6 = vfio_get_region_info(VAR_1, VAR_3, &VAR_5);", "if (VAR_6) {", "return VAR_6;", "}", "VAR_2->VAR_1 = VAR_1;", "VAR_2->flags = VAR_5->flags;", "VAR_2->size = VAR_5->size;", "VAR_2->fd_offset = VAR_5->offset;", "VAR_2->nr = VAR_3;", "if (VAR_2->size) {", "VAR_2->mem = g_new0(MemoryRegion, 1);", "memory_region_init_io(VAR_2->mem, VAR_0, &vfio_region_ops,\nVAR_2, VAR_4, VAR_2->size);", "if (!VAR_1->no_mmap &&\nVAR_2->flags & VFIO_REGION_INFO_FLAG_MMAP &&\n!(VAR_2->size & ~qemu_real_host_page_mask)) {", "VAR_6 = vfio_setup_region_sparse_mmaps(VAR_2, VAR_5);", "if (VAR_6) {", "VAR_2->nr_mmaps = 1;", "VAR_2->mmaps = g_new0(VFIOMmap, VAR_2->nr_mmaps);", "VAR_2->mmaps[0].offset = 0;", "VAR_2->mmaps[0].size = VAR_2->size;", "}", "}", "}", "g_free(VAR_5);", "trace_vfio_region_setup(VAR_1->VAR_4, VAR_3, VAR_4,\nVAR_2->flags, VAR_2->fd_offset, VAR_2->size);", "return 0;", "}" ]

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

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

[ "static ssize_t FUNC_0(NBDRequestData *req, NBDReply *reply,\nint len)\n{", "NBDClient *client = req->client;", "ssize_t rc, ret;", "g_assert(qemu_in_coroutine());", "qemu_co_mutex_lock(&client->send_lock);", "client->send_coroutine = qemu_coroutine_self();", "if (!len) {", "rc = nbd_send_reply(client->ioc, reply);", "} else {", "qio_channel_set_cork(client->ioc, true);", "rc = nbd_send_reply(client->ioc, reply);", "if (rc >= 0) {", "ret = write_sync(client->ioc, req->data, len, NULL);", "if (ret < 0) {", "rc = -EIO;", "}", "}", "qio_channel_set_cork(client->ioc, false);", "}", "client->send_coroutine = NULL;", "qemu_co_mutex_unlock(&client->send_lock);", "return rc;", "}" ]

[ 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 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ] ]

[ "static void FUNC_0(MachineState *VAR_0)\n{", "IMX31KZM *s = g_new0(IMX31KZM, 1);", "unsigned int VAR_1;", "unsigned int VAR_2;", "unsigned int VAR_3;", "object_initialize(&s->soc, sizeof(s->soc), TYPE_FSL_IMX31);", "object_property_add_child(OBJECT(VAR_0), \"soc\", OBJECT(&s->soc),\n&error_abort);", "object_property_set_bool(OBJECT(&s->soc), true, \"realized\", &error_fatal);", "if (VAR_0->VAR_1 > (FSL_IMX31_SDRAM0_SIZE + FSL_IMX31_SDRAM1_SIZE)) {", "error_report(\"WARNING: RAM VAR_4 \" RAM_ADDR_FMT \" above max supported, \"\n\"reduced to %x\", VAR_0->VAR_1,\nFSL_IMX31_SDRAM0_SIZE + FSL_IMX31_SDRAM1_SIZE);", "VAR_0->VAR_1 = FSL_IMX31_SDRAM0_SIZE + FSL_IMX31_SDRAM1_SIZE;", "}", "memory_region_allocate_system_memory(&s->VAR_5, NULL, \"kzm.VAR_5\",\nVAR_0->VAR_1);", "memory_region_add_subregion(get_system_memory(), FSL_IMX31_SDRAM0_ADDR,\n&s->VAR_5);", "for (VAR_3 = 0, VAR_1 = VAR_0->VAR_1, VAR_2 = 0;", "(VAR_3 < 2) && VAR_1; VAR_3++) {", "unsigned int VAR_4;", "static const struct {", "hwaddr addr;", "unsigned int VAR_4;", "} VAR_5[2] = {", "{ FSL_IMX31_SDRAM0_ADDR, FSL_IMX31_SDRAM0_SIZE },", "{ FSL_IMX31_SDRAM1_ADDR, FSL_IMX31_SDRAM1_SIZE },", "};", "VAR_4 = MIN(VAR_1, VAR_5[VAR_3].VAR_4);", "VAR_1 -= VAR_4;", "if (VAR_4 < VAR_5[VAR_3].VAR_4) {", "memory_region_init_alias(&s->ram_alias, NULL, \"VAR_5.alias\",\n&s->VAR_5, VAR_2, VAR_5[VAR_3].VAR_4 - VAR_4);", "memory_region_add_subregion(get_system_memory(),\nVAR_5[VAR_3].addr + VAR_4, &s->ram_alias);", "}", "VAR_2 += VAR_5[VAR_3].VAR_4;", "}", "if (nd_table[0].used) {", "lan9118_init(&nd_table[0], KZM_LAN9118_ADDR,\nqdev_get_gpio_in(DEVICE(&s->soc.avic), 52));", "}", "if (serial_hds[2]) {", "serial_mm_init(get_system_memory(), KZM_FPGA_ADDR+0x10, 0,\nqdev_get_gpio_in(DEVICE(&s->soc.avic), 52),\n14745600, serial_hds[2], DEVICE_NATIVE_ENDIAN);", "}", "kzm_binfo.VAR_1 = VAR_0->VAR_1;", "kzm_binfo.kernel_filename = VAR_0->kernel_filename;", "kzm_binfo.kernel_cmdline = VAR_0->kernel_cmdline;", "kzm_binfo.initrd_filename = VAR_0->initrd_filename;", "kzm_binfo.nb_cpus = 1;", "if (!qtest_enabled()) {", "arm_load_kernel(&s->soc.cpu, &kzm_binfo);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17, 19 ], [ 23 ], [ 29 ], [ 31, 33, 35 ], [ 37 ], [ 39 ], [ 43, 45 ], [ 47, 49 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 81 ], [ 85 ], [ 87, 89 ], [ 91, 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 115 ], [ 117, 119, 121 ], [ 123 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ] ]