Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static void FUNC_0(AVCodecContext *VAR_0, int VAR_1)\n{", "const char *VAR_2 = VAR_1 ? \"VAR_1\" : \"decoder\";", "AVCodec *codec;", "if (VAR_0->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&\nVAR_0->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {", "av_log(NULL, AV_LOG_ERROR, \"%s '%s' is experimental and might produce bad \"\n\"results.\\nAdd '-strict experimental' if you want to use it.\\n\",\nVAR_2, VAR_0->codec->name);", "codec = VAR_1 ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);", "if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))\nav_log(NULL, AV_LOG_ERROR, \"Or use the non experimental %s '%s'.\\n\",\nVAR_2, codec->name);", "ffmpeg_exit(1);", "}", "}" ]

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

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

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

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

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

[ "static void FUNC_0(Object *VAR_0, bool VAR_1, Error **VAR_2)\n{", "DeviceState *dev = DEVICE(VAR_0);", "DeviceClass *dc = DEVICE_GET_CLASS(dev);", "HotplugHandler *hotplug_ctrl;", "BusState *bus;", "Error *local_err = NULL;", "bool unattached_parent = false;", "static int VAR_3;", "int VAR_4;", "if (dev->hotplugged && !dc->hotpluggable) {", "error_setg(VAR_2, QERR_DEVICE_NO_HOTPLUG, object_get_typename(VAR_0));", "return;", "if (VAR_1 && !dev->realized) {", "if (!VAR_0->parent) {", "gchar *name = g_strdup_printf(\"device[%d]\", VAR_3++);", "object_property_add_child(container_get(qdev_get_machine(),\n\"/unattached\"),\nname, VAR_0, &error_abort);", "unattached_parent = true;", "g_free(name);", "hotplug_ctrl = qdev_get_hotplug_handler(dev);", "if (hotplug_ctrl) {", "hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);", "if (local_err != NULL) {", "if (dc->realize) {", "dc->realize(dev, &local_err);", "if (local_err != NULL) {", "DEVICE_LISTENER_CALL(realize, Forward, dev);", "if (hotplug_ctrl) {", "hotplug_handler_plug(hotplug_ctrl, dev, &local_err);", "if (local_err != NULL) {", "goto post_realize_fail;", "if (qdev_get_vmsd(dev)) {", "if (vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,\ndev->instance_id_alias,\ndev->alias_required_for_version,\n&local_err) < 0) {", "goto post_realize_fail;", "QLIST_FOREACH(bus, &dev->child_bus, sibling) {", "object_property_set_bool(OBJECT(bus), true, \"realized\",\n&local_err);", "if (local_err != NULL) {", "goto child_realize_fail;", "if (dev->hotplugged) {", "device_reset(dev);", "dev->pending_deleted_event = false;", "} else if (!VAR_1 && dev->realized) {", "Error **local_errp = NULL;", "QLIST_FOREACH(bus, &dev->child_bus, sibling) {", "local_errp = local_err ? NULL : &local_err;", "object_property_set_bool(OBJECT(bus), false, \"realized\",\nlocal_errp);", "if (qdev_get_vmsd(dev)) {", "vmstate_unregister(dev, qdev_get_vmsd(dev), dev);", "if (dc->unrealize) {", "local_errp = local_err ? NULL : &local_err;", "dc->unrealize(dev, local_errp);", "dev->pending_deleted_event = true;", "DEVICE_LISTENER_CALL(unrealize, Reverse, dev);", "if (local_err != NULL) {", "dev->realized = VAR_1;", "return;", "child_realize_fail:\nQLIST_FOREACH(bus, &dev->child_bus, sibling) {", "object_property_set_bool(OBJECT(bus), false, \"realized\",\nNULL);", "if (qdev_get_vmsd(dev)) {", "vmstate_unregister(dev, qdev_get_vmsd(dev), dev);", "post_realize_fail:\nif (dc->unrealize) {", "dc->unrealize(dev, NULL);", "fail:\nerror_propagate(VAR_2, local_err);", "if (unattached_parent) {", "object_unparent(OBJECT(dev));", "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, 0, 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 ], [ 56 ], [ 57 ], [ 58 ], [ 59 ], [ 60 ], [ 61 ], [ 62 ], [ 63 ], [ 64, 65 ], [ 66, 67 ], [ 68 ], [ 69 ], [ 70, 71 ], [ 72 ], [ 73, 74 ], [ 75 ], [ 76 ], [ 77 ] ]

[ "void FUNC_0(Monitor *VAR_0, const QDict *VAR_1)\n{", "DriveInfo *dinfo;", "BlockDriverState *bs, *bs1;", "int VAR_2;", "const char *VAR_3 = qdict_get_str(VAR_1, \"VAR_3\");", "bs = get_bs_snapshots();", "if (!bs) {", "monitor_printf(VAR_0, \"No block device supports snapshots\\n\");", "return;", "}", "QTAILQ_FOREACH(dinfo, &drives, next) {", "bs1 = dinfo->bdrv;", "if (bdrv_has_snapshot(bs1)) {", "VAR_2 = bdrv_snapshot_delete(bs1, VAR_3);", "if (VAR_2 < 0) {", "if (VAR_2 == -ENOTSUP)\nmonitor_printf(VAR_0,\n\"Snapshots not supported on device '%s'\\n\",\nbdrv_get_device_name(bs1));", "else\nmonitor_printf(VAR_0, \"Error %d while deleting snapshot on \"\n\"'%s'\\n\", VAR_2, bdrv_get_device_name(bs1));", "}", "}", "}", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0, Property *VAR_1, bool VAR_2)\n{", "uint32_t *p = qdev_get_prop_ptr(VAR_0, VAR_1);", "uint32_t mask = qdev_get_prop_mask(VAR_1);", "if (VAR_2)\n*p |= ~mask;", "else\n*p &= ~mask;", "}" ]

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

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

[ "static void FUNC_0(VMXNET3State *VAR_0)\n{", "struct Vmxnet3_GOSInfo VAR_1;", "VMXNET3_READ_DRV_SHARED(VAR_0->drv_shmem, devRead.misc.driverInfo.VAR_1,\n&VAR_1, sizeof(VAR_1));", "VAR_0->rx_packets_compound =\n(VAR_1.gosType == VMXNET3_GOS_TYPE_WIN) ? false : true;", "VMW_CFPRN(\"Guest type specifics: RXCOMPOUND: %d\", VAR_0->rx_packets_compound);", "}" ]

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

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

[ "int FUNC_0(AVPacket *VAR_0, int VAR_1)\n{", "int VAR_2;", "av_assert0((unsigned)VAR_0->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);", "if ((unsigned)VAR_1 >\nINT_MAX - (VAR_0->size + AV_INPUT_BUFFER_PADDING_SIZE))\nreturn -1;", "VAR_2 = VAR_0->size + VAR_1 + AV_INPUT_BUFFER_PADDING_SIZE;", "if (VAR_0->buf) {", "size_t data_offset;", "uint8_t *old_data = VAR_0->data;", "if (VAR_0->data == NULL) {", "data_offset = 0;", "VAR_0->data = VAR_0->buf->data;", "} else {", "data_offset = VAR_0->data - VAR_0->buf->data;", "if (data_offset > INT_MAX - VAR_2)\nreturn -1;", "}", "if (VAR_2 + data_offset > VAR_0->buf->size) {", "int VAR_3 = av_buffer_realloc(&VAR_0->buf, VAR_2 + data_offset);", "if (VAR_3 < 0) {", "VAR_0->data = old_data;", "return VAR_3;", "}", "VAR_0->data = VAR_0->buf->data + data_offset;", "}", "} else {", "VAR_0->buf = av_buffer_alloc(VAR_2);", "if (!VAR_0->buf)\nreturn AVERROR(ENOMEM);", "memcpy(VAR_0->buf->data, VAR_0->data, VAR_0->size);", "VAR_0->data = VAR_0->buf->data;", "}", "VAR_0->size += VAR_1;", "memset(VAR_0->data + VAR_0->size, 0, AV_INPUT_BUFFER_PADDING_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, 1, 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 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ] ]

[ "static inline void FUNC_0(IRQ_queue_t *VAR_0, int VAR_1)\n{", "VAR_0->pending--;", "reset_bit(VAR_0->queue, VAR_1);", "}" ]

[ 1, 0, 0, 0 ]

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

[ "static void *FUNC_0(void *VAR_0)\n{", "char *VAR_1 = VAR_0;", "off_t size;", "size_t blocksize;", "uint32_t nbdflags;", "int VAR_2, VAR_3;", "int VAR_4;", "pthread_t show_parts_thread;", "VAR_3 = unix_socket_outgoing(sockpath);", "if (VAR_3 < 0) {", "goto out;", "}", "VAR_4 = nbd_receive_negotiate(VAR_3, NULL, &nbdflags,\n&size, &blocksize);", "if (VAR_4 < 0) {", "goto out;", "}", "VAR_2 = open(VAR_1, O_RDWR);", "if (VAR_2 < 0) {", "fprintf(stderr, \"Failed to open %s: %m\", VAR_1);", "goto out;", "}", "VAR_4 = nbd_init(VAR_2, VAR_3, nbdflags, size, blocksize);", "if (VAR_4 < 0) {", "goto out;", "}", "pthread_create(&show_parts_thread, NULL, show_parts, VAR_1);", "if (verbose) {", "fprintf(stderr, \"NBD VAR_1 %s is now connected to %s\\n\",\nVAR_1, srcpath);", "} else {", "dup2(STDOUT_FILENO, STDERR_FILENO);", "}", "VAR_4 = nbd_client(VAR_2);", "if (VAR_4) {", "goto out;", "}", "close(VAR_2);", "kill(getpid(), SIGTERM);", "return (void *) EXIT_SUCCESS;", "out:\nkill(getpid(), SIGTERM);", "return (void *) EXIT_FAILURE;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 69 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105, 107 ], [ 109 ], [ 111 ] ]

[ "bool FUNC_0(MigrationState *s)\n{", "return s->state == MIG_STATE_SETUP;", "}" ]

[ 0, 0, 0 ]

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

[ "static int64_t FUNC_0(HANDLE fh, Error **errp)\n{", "GuestFileHandle *gfh;", "int64_t handle;", "handle = ga_get_fd_handle(ga_state, errp);", "if (handle < 0) {", "return -1;", "}", "gfh = g_malloc0(sizeof(GuestFileHandle));", "gfh->id = handle;", "gfh->fh = fh;", "QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);", "return handle;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "ICH9LPCPMRegs *pm = VAR_0;", "ich9_pm_iospace_update(pm, 0);", "acpi_pm1_evt_reset(&pm->acpi_regs);", "acpi_pm1_cnt_reset(&pm->acpi_regs);", "acpi_pm_tmr_reset(&pm->acpi_regs);", "acpi_gpe_reset(&pm->acpi_regs);", "pm_update_sci(pm);" ]

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

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

[ "static void FUNC_0(int16_t *restrict VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{", "int VAR_3;", "vec_u8 perm = vec_lvsl(0, VAR_1);", "const vec_u8 VAR_4 = (const vec_u8)vec_splat_u8(0);", "for (VAR_3 = 0; VAR_3 < 8; VAR_3++) {", "vec_u8 pixl = vec_ld(0, VAR_1);", "vec_u8 pixr = vec_ld(7, VAR_1);", "vec_u8 bytes = vec_perm(pixl, pixr, perm);", "vec_s16 shorts = (vec_s16)vec_mergeh(VAR_4, bytes);", "vec_st(shorts, VAR_3 * 16, (vec_s16 *)VAR_0);", "VAR_1 += VAR_2;", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ] ]

[ "static int FUNC_0(SysBusDevice *VAR_0)\n{", "sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(VAR_0);", "PCIHostState *phb = PCI_HOST_BRIDGE(VAR_0);", "char *VAR_1;", "int VAR_2;", "PCIBus *bus;", "sphb->dtbusname = g_strdup_printf(\"pci@%\" PRIx64, sphb->buid);", "VAR_1 = alloca(strlen(sphb->dtbusname) + 32);", "sprintf(VAR_1, \"%VAR_0.mmio\", sphb->dtbusname);", "memory_region_init(&sphb->memspace, VAR_1, INT64_MAX);", "sprintf(VAR_1, \"%VAR_0.mmio-alias\", sphb->dtbusname);", "memory_region_init_alias(&sphb->memwindow, VAR_1, &sphb->memspace,\nSPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);", "memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,\n&sphb->memwindow);", "sprintf(VAR_1, \"%VAR_0.io\", sphb->dtbusname);", "memory_region_init(&sphb->iospace, VAR_1, SPAPR_PCI_IO_WIN_SIZE);", "memory_region_add_subregion(get_system_io(), 0, &sphb->iospace);", "sprintf(VAR_1, \"%VAR_0.io-alias\", sphb->dtbusname);", "memory_region_init_io(&sphb->iowindow, &spapr_io_ops, sphb,\nVAR_1, SPAPR_PCI_IO_WIN_SIZE);", "memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,\n&sphb->iowindow);", "if (msi_supported) {", "sprintf(VAR_1, \"%VAR_0.msi\", sphb->dtbusname);", "memory_region_init_io(&sphb->msiwindow, &spapr_msi_ops, sphb,\nVAR_1, SPAPR_MSIX_MAX_DEVS * 0x10000);", "memory_region_add_subregion(get_system_memory(), sphb->msi_win_addr,\n&sphb->msiwindow);", "}", "bus = pci_register_bus(DEVICE(VAR_0),\nsphb->busname ? sphb->busname : sphb->dtbusname,\npci_spapr_set_irq, pci_spapr_map_irq, sphb,\n&sphb->memspace, &sphb->iospace,\nPCI_DEVFN(0, 0), PCI_NUM_PINS);", "phb->bus = bus;", "sphb->dma_liobn = SPAPR_PCI_BASE_LIOBN | (pci_find_domain(bus) << 16);", "sphb->dma_window_start = 0;", "sphb->dma_window_size = 0x40000000;", "sphb->dma = spapr_tce_new_dma_context(sphb->dma_liobn, sphb->dma_window_size);", "pci_setup_iommu(bus, spapr_pci_dma_context_fn, sphb);", "QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);", "for (VAR_2 = 0; VAR_2 < PCI_NUM_PINS; VAR_2++) {", "uint32_t irq;", "irq = spapr_allocate_lsi(0);", "if (!irq) {", "return -1;", "}", "sphb->lsi_table[VAR_2].irq = irq;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 25 ], [ 27 ], [ 31 ], [ 33, 35 ], [ 37, 39 ], [ 59 ], [ 61 ], [ 65 ], [ 69 ], [ 71, 73 ], [ 75, 77 ], [ 87 ], [ 89 ], [ 91, 93 ], [ 95, 97 ], [ 99 ], [ 103, 105, 107, 109, 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ] ]

[ "static int FUNC_0(XenPCIPassthroughState *VAR_0,\nXenPTReg *VAR_1, uint16_t *VAR_2,\nuint16_t VAR_3, uint16_t VAR_4)\n{", "XenPTRegInfo *reg = VAR_1->reg;", "XenPTMSI *msi = VAR_0->msi;", "uint16_t writable_mask = 0;", "uint16_t throughable_mask = 0;", "uint16_t raw_val;", "if (*VAR_2 & PCI_MSI_FLAGS_QSIZE) {", "XEN_PT_WARN(&VAR_0->dev, \"Tries to set more than 1 vector ctrl %x\\n\", *VAR_2);", "}", "writable_mask = reg->emu_mask & ~reg->ro_mask & VAR_4;", "VAR_1->data = XEN_PT_MERGE_VALUE(*VAR_2, VAR_1->data, writable_mask);", "msi->flags |= VAR_1->data & ~PCI_MSI_FLAGS_ENABLE;", "raw_val = *VAR_2;", "throughable_mask = ~reg->emu_mask & VAR_4;", "*VAR_2 = XEN_PT_MERGE_VALUE(*VAR_2, VAR_3, throughable_mask);", "if (raw_val & PCI_MSI_FLAGS_ENABLE) {", "if (!msi->initialized) {", "XEN_PT_LOG(&VAR_0->dev, \"setup MSI\\n\");", "if (xen_pt_msi_setup(VAR_0)) {", "*VAR_2 &= ~PCI_MSI_FLAGS_ENABLE;", "XEN_PT_WARN(&VAR_0->dev, \"Can not map MSI.\\n\");", "return 0;", "}", "if (xen_pt_msi_update(VAR_0)) {", "*VAR_2 &= ~PCI_MSI_FLAGS_ENABLE;", "XEN_PT_WARN(&VAR_0->dev, \"Can not bind MSI\\n\");", "return 0;", "}", "msi->initialized = true;", "msi->mapped = true;", "}", "msi->flags |= PCI_MSI_FLAGS_ENABLE;", "} else {", "msi->flags &= ~PCI_MSI_FLAGS_ENABLE;", "}", "*VAR_2 &= ~PCI_MSI_FLAGS_ENABLE;", "*VAR_2 |= raw_val & PCI_MSI_FLAGS_ENABLE;", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 35 ], [ 37 ], [ 43 ], [ 45 ], [ 47 ], [ 53 ], [ 57 ], [ 61 ], [ 63 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, uint32_t VAR_2)\n{", "#ifdef DEBUG_UNASSIGNED\nprintf(\"Unassigned mem write \" TARGET_FMT_plx \" = 0x%x\\n\", VAR_1, VAR_2);", "#endif\n#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)\ndo_unassigned_access(VAR_1, 1, 0, 0, 2);", "#endif\n}" ]

[ 0, 0, 1, 0 ]

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

[ "static int FUNC_0(DisasContextBase *VAR_0, CPUState *VAR_1,\nint VAR_2)\n{", "DisasContext *dc = container_of(VAR_0, DisasContext, base);", "CPUX86State *env = VAR_1->env_ptr;", "uint32_t flags = dc->base.tb->flags;", "target_ulong cs_base = dc->base.tb->cs_base;", "dc->pe = (flags >> HF_PE_SHIFT) & 1;", "dc->code32 = (flags >> HF_CS32_SHIFT) & 1;", "dc->ss32 = (flags >> HF_SS32_SHIFT) & 1;", "dc->addseg = (flags >> HF_ADDSEG_SHIFT) & 1;", "dc->f_st = 0;", "dc->vm86 = (flags >> VM_SHIFT) & 1;", "dc->cpl = (flags >> HF_CPL_SHIFT) & 3;", "dc->iopl = (flags >> IOPL_SHIFT) & 3;", "dc->tf = (flags >> TF_SHIFT) & 1;", "dc->cc_op = CC_OP_DYNAMIC;", "dc->cc_op_dirty = false;", "dc->cs_base = cs_base;", "dc->popl_esp_hack = 0;", "dc->mem_index = 0;", "#ifdef CONFIG_SOFTMMU\ndc->mem_index = cpu_mmu_index(env, false);", "#endif\ndc->cpuid_features = env->features[FEAT_1_EDX];", "dc->cpuid_ext_features = env->features[FEAT_1_ECX];", "dc->cpuid_ext2_features = env->features[FEAT_8000_0001_EDX];", "dc->cpuid_ext3_features = env->features[FEAT_8000_0001_ECX];", "dc->cpuid_7_0_ebx_features = env->features[FEAT_7_0_EBX];", "dc->cpuid_xsave_features = env->features[FEAT_XSAVE];", "#ifdef TARGET_X86_64\ndc->lma = (flags >> HF_LMA_SHIFT) & 1;", "dc->code64 = (flags >> HF_CS64_SHIFT) & 1;", "#endif\ndc->flags = flags;", "dc->jmp_opt = !(dc->tf || dc->base.singlestep_enabled ||\n(flags & HF_INHIBIT_IRQ_MASK));", "dc->repz_opt = !dc->jmp_opt && !(dc->base.tb->cflags & CF_USE_ICOUNT);", "#if 0\nif (!dc->addseg && (dc->vm86 || !dc->pe || !dc->code32))\nprintf(\"ERROR addseg\\n\");", "#endif\ncpu_T0 = tcg_temp_new();", "cpu_T1 = tcg_temp_new();", "cpu_A0 = tcg_temp_new();", "cpu_tmp0 = tcg_temp_new();", "cpu_tmp1_i64 = tcg_temp_new_i64();", "cpu_tmp2_i32 = tcg_temp_new_i32();", "cpu_tmp3_i32 = tcg_temp_new_i32();", "cpu_tmp4 = tcg_temp_new();", "cpu_ptr0 = tcg_temp_new_ptr();", "cpu_ptr1 = tcg_temp_new_ptr();", "cpu_cc_srcT = tcg_temp_local_new();", "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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47, 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 71, 73 ], [ 75, 77 ], [ 99 ], [ 101, 105, 107 ], [ 109, 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ] ]

[ "void FUNC_0(interleaveBytes)(uint8_t *src1, uint8_t *src2, uint8_t *dest,\nunsigned width, unsigned height, int src1Stride,\nint src2Stride, int dstStride){", "unsigned VAR_0;", "for(VAR_0=0; VAR_0 < height; VAR_0++)", "{", "unsigned w;", "#ifdef HAVE_MMX\n#ifdef HAVE_SSE2\nasm(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 64(%1, %%\"REG_a\")\t\\n\\t\"\nPREFETCH\" 64(%2, %%\"REG_a\")\t\\n\\t\"\n\"movdqa (%1, %%\"REG_a\"), %%xmm0\t\\n\\t\"\n\"movdqa (%1, %%\"REG_a\"), %%xmm1\t\\n\\t\"\n\"movdqa (%2, %%\"REG_a\"), %%xmm2\t\\n\\t\"\n\"punpcklbw %%xmm2, %%xmm0\t\\n\\t\"\n\"punpckhbw %%xmm2, %%xmm1\t\\n\\t\"\n\"movntdq %%xmm0, (%0, %%\"REG_a\", 2)\\n\\t\"\n\"movntdq %%xmm1, 16(%0, %%\"REG_a\", 2)\\n\\t\"\n\"add $16, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %3, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n::\"r\"(dest), \"r\"(src1), \"r\"(src2), \"r\" ((long)width-15)\n: \"memory\", \"%\"REG_a\"\"\n);", "#else\nasm(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 64(%1, %%\"REG_a\")\t\\n\\t\"\nPREFETCH\" 64(%2, %%\"REG_a\")\t\\n\\t\"\n\"movq (%1, %%\"REG_a\"), %%mm0\t\\n\\t\"\n\"movq 8(%1, %%\"REG_a\"), %%mm2\t\\n\\t\"\n\"movq %%mm0, %%mm1\t\t\\n\\t\"\n\"movq %%mm2, %%mm3\t\t\\n\\t\"\n\"movq (%2, %%\"REG_a\"), %%mm4\t\\n\\t\"\n\"movq 8(%2, %%\"REG_a\"), %%mm5\t\\n\\t\"\n\"punpcklbw %%mm4, %%mm0\t\t\\n\\t\"\n\"punpckhbw %%mm4, %%mm1\t\t\\n\\t\"\n\"punpcklbw %%mm5, %%mm2\t\t\\n\\t\"\n\"punpckhbw %%mm5, %%mm3\t\t\\n\\t\"\nMOVNTQ\" %%mm0, (%0, %%\"REG_a\", 2)\\n\\t\"\nMOVNTQ\" %%mm1, 8(%0, %%\"REG_a\", 2)\\n\\t\"\nMOVNTQ\" %%mm2, 16(%0, %%\"REG_a\", 2)\\n\\t\"\nMOVNTQ\" %%mm3, 24(%0, %%\"REG_a\", 2)\\n\\t\"\n\"add $16, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %3, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n::\"r\"(dest), \"r\"(src1), \"r\"(src2), \"r\" ((long)width-15)\n: \"memory\", \"%\"REG_a\n);", "#endif\nfor(w= (width&(~15)); w < width; w++)", "{", "dest[2*w+0] = src1[w];", "dest[2*w+1] = src2[w];", "}", "#else\nfor(w=0; w < width; w++)", "{", "dest[2*w+0] = src1[w];", "dest[2*w+1] = src2[w];", "}", "#endif\ndest += dstStride;", "src1 += src1Stride;", "src2 += src2Stride;", "}", "#ifdef HAVE_MMX\nasm(\nEMMS\" \\n\\t\"\nSFENCE\" \\n\\t\"\n::: \"memory\"\n);", "#endif\n}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 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 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145, 147, 149, 151, 153, 155 ], [ 157, 159 ] ]

[ "void VAR_0 op_check_subfo (void)\n{", "if (likely(!(((uint32_t)(~T2) ^ (uint32_t)T1 ^ UINT32_MAX) &\n((uint32_t)(~T2) ^ (uint32_t)T0) & (1UL << 31)))) {", "xer_ov = 0;", "} else {", "xer_ov = 1;", "xer_so = 1;", "}", "RETURN();", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "ASFContext *asf = VAR_0->priv_data;", "ASFStream *stream;", "int64_t duration;", "AVCodecContext *codec;", "int64_t packet_st, pts;", "int VAR_2, VAR_3;", "int VAR_4 = VAR_1->VAR_4;", "codec = VAR_0->streams[VAR_1->stream_index]->codec;", "stream = &asf->streams[VAR_1->stream_index];", "if (codec->codec_type == AVMEDIA_TYPE_AUDIO)\nVAR_4 &= ~AV_PKT_FLAG_KEY;", "pts = (VAR_1->pts != AV_NOPTS_VALUE) ? VAR_1->pts : VAR_1->dts;", "if (pts < 0) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Negative dts not supported stream %d, dts %\"PRId64\"\\n\",\nVAR_1->stream_index, pts);", "return AVERROR(ENOSYS);", "}", "assert(pts != AV_NOPTS_VALUE);", "duration = pts * 10000;", "asf->duration = FFMAX(asf->duration, duration + VAR_1->duration * 10000);", "packet_st = asf->nb_packets;", "put_frame(VAR_0, stream, VAR_0->streams[VAR_1->stream_index],\nVAR_1->dts, VAR_1->data, VAR_1->size, VAR_4);", "if ((!asf->is_streamed) && (VAR_4 & AV_PKT_FLAG_KEY)) {", "VAR_2 = (int)(duration / INT64_C(10000000));", "if (VAR_2 != (int)(asf->last_indexed_pts / INT64_C(10000000))) {", "for (VAR_3 = asf->nb_index_count; VAR_3 < VAR_2; VAR_3++) {", "if (VAR_3 >= asf->nb_index_memory_alloc) {", "asf->nb_index_memory_alloc += ASF_INDEX_BLOCK;", "asf->index_ptr = (ASFIndex *)av_realloc(asf->index_ptr,\nsizeof(ASFIndex) *\nasf->nb_index_memory_alloc);", "}", "asf->index_ptr[VAR_3].packet_number = (uint32_t)packet_st;", "asf->index_ptr[VAR_3].packet_count = (uint16_t)(asf->nb_packets - packet_st);", "asf->maximum_packet = FFMAX(asf->maximum_packet,\n(uint16_t)(asf->nb_packets - packet_st));", "}", "asf->nb_index_count = VAR_2;", "asf->last_indexed_pts = duration;", "}", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 33 ], [ 37 ], [ 39, 41, 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61, 63 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81, 83, 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ] ]

[ "int FUNC_0(char *restrict VAR_0, size_t VAR_1, const char *restrict VAR_2, ...)\n{", "va_list ap;", "int VAR_3;", "va_start(ap, VAR_2);", "VAR_3 = avpriv_vsnprintf(VAR_0, VAR_1, VAR_2, ap);", "va_end(ap);", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{", "VirtIOPCIProxy *proxy = VIRTIO_PCI(VAR_0);", "VirtioBusState *bus = &proxy->bus;", "bool legacy = virtio_pci_legacy(proxy);", "bool modern;", "bool modern_pio = proxy->flags & VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY;", "uint8_t *config;", "uint32_t size;", "VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);", "if (!proxy->ignore_backend_features &&\n!virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) {", "virtio_pci_disable_modern(proxy);", "if (!legacy) {", "error_setg(VAR_1, \"Device doesn't support modern mode, and legacy\"\n\" mode is disabled\");", "error_append_hint(VAR_1, \"Set disable-legacy to off\\n\");", "return;", "}", "}", "modern = virtio_pci_modern(proxy);", "config = proxy->pci_dev.config;", "if (proxy->class_code) {", "pci_config_set_class(config, proxy->class_code);", "}", "if (legacy) {", "if (virtio_host_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM)) {", "error_setg(VAR_1, \"VIRTIO_F_IOMMU_PLATFORM was supported by\"\n\"neither legacy nor transitional device.\");", "return ;", "}", "pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID,\npci_get_word(config + PCI_VENDOR_ID));", "pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus));", "} else {", "pci_set_word(config + PCI_VENDOR_ID,\nPCI_VENDOR_ID_REDHAT_QUMRANET);", "pci_set_word(config + PCI_DEVICE_ID,\n0x1040 + virtio_bus_get_vdev_id(bus));", "pci_config_set_revision(config, 1);", "}", "config[PCI_INTERRUPT_PIN] = 1;", "if (modern) {", "struct virtio_pci_cap VAR_2 = {", ".cap_len = sizeof VAR_2,\n};", "struct virtio_pci_notify_cap VAR_3 = {", ".VAR_2.cap_len = sizeof VAR_3,\n.notify_off_multiplier =\ncpu_to_le32(virtio_pci_queue_mem_mult(proxy)),\n};", "struct virtio_pci_cfg_cap VAR_4 = {", ".VAR_2.cap_len = sizeof VAR_4,\n.VAR_2.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,\n};", "struct virtio_pci_notify_cap VAR_5 = {", ".VAR_2.cap_len = sizeof VAR_3,\n.notify_off_multiplier = cpu_to_le32(0x0),\n};", "struct virtio_pci_cfg_cap *VAR_6;", "virtio_pci_modern_regions_init(proxy);", "virtio_pci_modern_mem_region_map(proxy, &proxy->common, &VAR_2);", "virtio_pci_modern_mem_region_map(proxy, &proxy->isr, &VAR_2);", "virtio_pci_modern_mem_region_map(proxy, &proxy->device, &VAR_2);", "virtio_pci_modern_mem_region_map(proxy, &proxy->VAR_3, &VAR_3.VAR_2);", "if (modern_pio) {", "memory_region_init(&proxy->io_bar, OBJECT(proxy),\n\"virtio-pci-io\", 0x4);", "pci_register_bar(&proxy->pci_dev, proxy->modern_io_bar_idx,\nPCI_BASE_ADDRESS_SPACE_IO, &proxy->io_bar);", "virtio_pci_modern_io_region_map(proxy, &proxy->VAR_5,\n&VAR_5.VAR_2);", "}", "pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar_idx,\nPCI_BASE_ADDRESS_SPACE_MEMORY |\nPCI_BASE_ADDRESS_MEM_PREFETCH |\nPCI_BASE_ADDRESS_MEM_TYPE_64,\n&proxy->modern_bar);", "proxy->config_cap = virtio_pci_add_mem_cap(proxy, &VAR_4.VAR_2);", "VAR_6 = (void *)(proxy->pci_dev.wmask + proxy->config_cap);", "pci_set_byte(&VAR_6->VAR_2.bar, ~0x0);", "pci_set_long((uint8_t *)&VAR_6->VAR_2.offset, ~0x0);", "pci_set_long((uint8_t *)&VAR_6->VAR_2.length, ~0x0);", "pci_set_long(VAR_6->pci_cfg_data, ~0x0);", "}", "if (proxy->nvectors) {", "int VAR_7 = msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,\nproxy->msix_bar_idx, NULL);", "if (VAR_7) {", "if (VAR_7 != -ENOTSUP) {", "error_report(\"unable to init msix vectors to %\" PRIu32,\nproxy->nvectors);", "}", "proxy->nvectors = 0;", "}", "}", "proxy->pci_dev.config_write = virtio_write_config;", "proxy->pci_dev.config_read = virtio_read_config;", "if (legacy) {", "size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)\n+ virtio_bus_get_vdev_config_len(bus);", "size = pow2ceil(size);", "memory_region_init_io(&proxy->bar, OBJECT(proxy),\n&virtio_pci_config_ops,\nproxy, \"virtio-pci\", size);", "pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar_idx,\nPCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 33 ], [ 35 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 85, 87 ], [ 89 ], [ 91 ], [ 95, 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 123, 125, 127, 129 ], [ 131 ], [ 133, 135, 137 ], [ 139 ], [ 141, 143, 145 ], [ 149 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 169, 171 ], [ 175, 177 ], [ 181, 183 ], [ 185 ], [ 189, 191, 193, 195, 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 217 ], [ 219, 221 ], [ 223 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 243 ], [ 245 ], [ 249 ], [ 251, 253 ], [ 255 ], [ 259, 261, 263 ], [ 267, 269 ], [ 271 ], [ 273 ] ]

[ "static void FUNC_0(AddressSpaceDispatch *VAR_0, int VAR_1)\n{", "DECLARE_BITMAP(compacted, VAR_1);", "if (VAR_0->phys_map.skip) {", "phys_page_compact(&VAR_0->phys_map, VAR_0->nodes, compacted);", "}", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, const uint8_t *VAR_1,\nint VAR_2, int *VAR_3, int *VAR_4)\n{", "int VAR_5, VAR_6;", "if (VAR_2 < 24)\nreturn AVERROR_INVALIDDATA;", "if (AV_RB16(VAR_1) != 0x8000)\nreturn AVERROR_INVALIDDATA;", "VAR_5 = AV_RB16(VAR_1 + 2) + 4;", "if (VAR_2 >= VAR_5 && memcmp(VAR_1 + VAR_5 - 6, \"(c)CRI\", 6))\nreturn AVERROR_INVALIDDATA;", "if (VAR_1[4] != 3 || VAR_1[5] != 18 || VAR_1[6] != 4) {", "avpriv_request_sample(VAR_0, \"Support for this ADX format\");", "return AVERROR_PATCHWELCOME;", "}", "VAR_0->channels = VAR_1[7];", "if (VAR_0->channels <= 0 || VAR_0->channels > 2)\nreturn AVERROR_INVALIDDATA;", "VAR_0->sample_rate = AV_RB32(VAR_1 + 8);", "if (VAR_0->sample_rate < 1 ||\nVAR_0->sample_rate > INT_MAX / (VAR_0->channels * BLOCK_SIZE * 8))\nreturn AVERROR_INVALIDDATA;", "VAR_0->bit_rate = VAR_0->sample_rate * VAR_0->channels * BLOCK_SIZE * 8 / BLOCK_SAMPLES;", "if (VAR_4) {", "VAR_6 = AV_RB16(VAR_1 + 16);", "ff_adx_calculate_coeffs(VAR_6, VAR_0->sample_rate, COEFF_BITS, VAR_4);", "}", "*VAR_3 = VAR_5;", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11, 13 ], [ 17, 19 ], [ 21 ], [ 27, 29 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 47 ], [ 49, 51 ], [ 57 ], [ 59, 61, 63 ], [ 69 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ] ]

[ "int FUNC_0(void *VAR_0, walk_memory_regions_fn VAR_1)\n{", "struct walk_memory_regions_data VAR_2;", "uintptr_t i;", "VAR_2.VAR_1 = VAR_1;", "VAR_2.VAR_0 = VAR_0;", "VAR_2.start = -1ul;", "VAR_2.prot = 0;", "for (i = 0; i < V_L1_SIZE; i++) {", "int rc = walk_memory_regions_1(&VAR_2, (abi_ulong)i << V_L1_SHIFT,\nV_L1_SHIFT / L2_BITS - 1, l1_map + i);", "if (rc != 0) {", "return rc;", "}", "}", "return walk_memory_regions_end(&VAR_2, 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 ], [ 39 ], [ 41 ] ]

[ "static int FUNC_0 (PCIDevice *VAR_0)\n{", "ES1370State *s = DO_UPCAST (ES1370State, VAR_0, VAR_0);", "uint8_t *c = s->VAR_0.config;", "pci_config_set_vendor_id (c, PCI_VENDOR_ID_ENSONIQ);", "pci_config_set_device_id (c, PCI_DEVICE_ID_ENSONIQ_ES1370);", "c[PCI_STATUS + 1] = PCI_STATUS_DEVSEL_SLOW >> 8;", "pci_config_set_class (c, PCI_CLASS_MULTIMEDIA_AUDIO);", "#if 1\nc[PCI_SUBSYSTEM_VENDOR_ID] = 0x42;", "c[PCI_SUBSYSTEM_VENDOR_ID + 1] = 0x49;", "c[PCI_SUBSYSTEM_ID] = 0x4c;", "c[PCI_SUBSYSTEM_ID + 1] = 0x4c;", "#else\nc[PCI_SUBSYSTEM_VENDOR_ID] = 0x74;", "c[PCI_SUBSYSTEM_VENDOR_ID + 1] = 0x12;", "c[PCI_SUBSYSTEM_ID] = 0x71;", "c[PCI_SUBSYSTEM_ID + 1] = 0x13;", "c[PCI_CAPABILITY_LIST] = 0xdc;", "c[PCI_INTERRUPT_LINE] = 10;", "c[0xdc] = 0x00;", "#endif\nc[PCI_INTERRUPT_PIN] = 1;", "c[PCI_MIN_GNT] = 0x0c;", "c[PCI_MAX_LAT] = 0x80;", "pci_register_bar (&s->VAR_0, 0, 256, PCI_BASE_ADDRESS_SPACE_IO, es1370_map);", "qemu_register_reset (es1370_on_reset, s);", "AUD_register_card (\"es1370\", &s->card);", "es1370_reset (s);", "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 ]

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

[ "int FUNC_0(VLANClientState *VAR_0)\n{", "VLANState *vlan = VAR_0->vlan;", "VLANClientState *vc;", "for (vc = vlan->first_client; vc != NULL; vc = vc->next) {", "if (vc == VAR_0) {", "continue;", "}", "if (!vc->can_receive || vc->can_receive(vc->opaque)) {", "return 1;", "}", "}", "return 0;", "}" ]

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

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

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

[ 0, 0, 0 ]

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

[ "static int FUNC_0(int VAR_0, int VAR_1, bool VAR_2)\n{", "int VAR_3;", "VAR_3 = 0;", "if (VAR_0 == 0) {", "switch (VAR_1) {", "case 0x0:\ncase 0x1:\ncase 0x2:\nVAR_3 |= PAGE_WRITE;", "case 0x3:\ncase 0x6:\nVAR_3 |= PAGE_READ;", "break;", "}", "} else {", "switch (VAR_1) {", "case 0x0:\ncase 0x6:\nVAR_3 = 0;", "break;", "case 0x1:\ncase 0x3:\nVAR_3 = PAGE_READ;", "break;", "case 0x2:\nVAR_3 = PAGE_READ | PAGE_WRITE;", "break;", "}", "}", "if (!VAR_2) {", "VAR_3 |= PAGE_EXEC;", "}", "return VAR_3;", "}" ]

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

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

[ "long FUNC_0(CPUAlphaState *VAR_0)\n{", "abi_ulong frame_addr = VAR_0->ir[IR_A0];", "struct target_rt_sigframe *VAR_1;", "sigset_t set;", "if (!lock_user_struct(VERIFY_READ, VAR_1, frame_addr, 1)) {", "goto badframe;", "}", "target_to_host_sigset(&set, &VAR_1->uc.tuc_sigmask);", "sigprocmask(SIG_SETMASK, &set, NULL);", "if (restore_sigcontext(VAR_0, &VAR_1->uc.tuc_mcontext)) {", "goto badframe;", "}", "if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,\nuc.tuc_stack),\n0, VAR_0->ir[IR_SP]) == -EFAULT) {", "goto badframe;", "}", "unlock_user_struct(VAR_1, frame_addr, 0);", "return VAR_0->ir[IR_V0];", "badframe:\nunlock_user_struct(VAR_1, frame_addr, 0);", "force_sig(TARGET_SIGSEGV);", "}" ]

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

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

[ "static int FUNC_0(SysBusDevice *VAR_0)\n{", "TCXState *s = FROM_SYSBUS(TCXState, VAR_0);", "ram_addr_t vram_offset = 0;", "int VAR_1;", "uint8_t *vram_base;", "memory_region_init_ram(&s->vram_mem, \"tcx.vram\",\ns->vram_size * (1 + 4 + 4));", "vmstate_register_ram_global(&s->vram_mem);", "vram_base = memory_region_get_ram_ptr(&s->vram_mem);", "s->vram = vram_base;", "VAR_1 = s->vram_size;", "memory_region_init_alias(&s->vram_8bit, \"tcx.vram.8bit\",\n&s->vram_mem, vram_offset, VAR_1);", "sysbus_init_mmio(VAR_0, &s->vram_8bit);", "vram_offset += VAR_1;", "vram_base += VAR_1;", "memory_region_init_io(&s->dac, &tcx_dac_ops, s, \"tcx.dac\", TCX_DAC_NREGS);", "sysbus_init_mmio(VAR_0, &s->dac);", "memory_region_init_io(&s->tec, &dummy_ops, s, \"tcx.tec\", TCX_TEC_NREGS);", "sysbus_init_mmio(VAR_0, &s->tec);", "memory_region_init_io(&s->thc24, &dummy_ops, s, \"tcx.thc24\",\nTCX_THC_NREGS_24);", "sysbus_init_mmio(VAR_0, &s->thc24);", "if (s->depth == 24) {", "VAR_1 = s->vram_size * 4;", "s->vram24 = (uint32_t *)vram_base;", "s->vram24_offset = vram_offset;", "memory_region_init_alias(&s->vram_24bit, \"tcx.vram.24bit\",\n&s->vram_mem, vram_offset, VAR_1);", "sysbus_init_mmio(VAR_0, &s->vram_24bit);", "vram_offset += VAR_1;", "vram_base += VAR_1;", "VAR_1 = s->vram_size * 4;", "s->cplane = (uint32_t *)vram_base;", "s->cplane_offset = vram_offset;", "memory_region_init_alias(&s->vram_cplane, \"tcx.vram.cplane\",\n&s->vram_mem, vram_offset, VAR_1);", "sysbus_init_mmio(VAR_0, &s->vram_cplane);", "s->con = graphic_console_init(tcx24_update_display,\ntcx24_invalidate_display,\ntcx24_screen_dump, NULL, s);", "} else {", "memory_region_init_io(&s->thc8, &dummy_ops, s, \"tcx.thc8\",\nTCX_THC_NREGS_8);", "sysbus_init_mmio(VAR_0, &s->thc8);", "s->con = graphic_console_init(tcx_update_display,\ntcx_invalidate_display,\ntcx_screen_dump, NULL, s);", "}", "qemu_console_resize(s->con, s->width, s->height);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 19 ], [ 21 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 45 ], [ 47 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 105, 107, 109 ], [ 111 ], [ 115, 117 ], [ 119 ], [ 123, 125, 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ] ]

[ "static QObject *FUNC_0(QmpInputVisitor *qiv,\nconst char *name,\nbool consume)\n{", "StackObject *tos;", "QObject *qobj;", "QObject *ret;", "if (!qiv->nb_stack) {", "return qiv->root;", "}", "tos = &qiv->stack[qiv->nb_stack - 1];", "qobj = tos->obj;", "assert(qobj);", "if (qobject_type(qobj) == QTYPE_QDICT) {", "assert(name);", "ret = qdict_get(qobject_to_qdict(qobj), name);", "if (tos->h && consume && ret) {", "bool removed = g_hash_table_remove(tos->h, name);", "assert(removed);", "}", "} else {", "assert(qobject_type(qobj) == QTYPE_QLIST);", "assert(!name);", "ret = qlist_entry_obj(tos->entry);", "if (consume) {", "tos->entry = qlist_next(tos->entry);", "}", "}", "return ret;", "}" ]

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

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

[ "int FUNC_0(PollingFunc *VAR_0, void *VAR_1)\n{", "PollingEntry **ppe, *pe;", "pe = g_malloc0(sizeof(PollingEntry));", "pe->VAR_0 = VAR_0;", "pe->VAR_1 = VAR_1;", "for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);", "*ppe = pe;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(MachineState *VAR_0)\n{", "static const LxBoardDesc VAR_1 = {", ".flash_base = 0xf8000000,\n.flash_size = 0x01000000,\n.flash_sector_size = 0x20000,\n.sram_size = 0x2000000,\n};", "lx_init(&VAR_1, VAR_0);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "FUNC_0(VAR_0)\n{", "QString *qstring;", "const char *VAR_1 = \"QEMU\";", "qstring = qstring_from_str(VAR_1);", "fail_unless(qstring != NULL);", "fail_unless(qstring->base.refcnt == 1);", "fail_unless(strcmp(VAR_1, qstring->string) == 0);", "fail_unless(qobject_type(QOBJECT(qstring)) == QTYPE_QSTRING);", "g_free(qstring->string);", "g_free(qstring);", "}" ]

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

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

[ "static void FUNC_0(VirtIOPCIProxy *VAR_0, Error **VAR_1)\n{", "VirtIOVGA *vvga = VIRTIO_VGA(VAR_0);", "VirtIOGPU *g = &vvga->vdev;", "VGACommonState *vga = &vvga->vga;", "Error *err = NULL;", "uint32_t offset;", "int VAR_2;", "vga->vram_size_mb = 8;", "vga_common_init(vga, OBJECT(VAR_0), false);", "vga_init(vga, OBJECT(VAR_0), pci_address_space(&VAR_0->pci_dev),\npci_address_space_io(&VAR_0->pci_dev), true);", "pci_register_bar(&VAR_0->pci_dev, 0,\nPCI_BASE_ADDRESS_MEM_PREFETCH, &vga->vram);", "VAR_0->modern_mem_bar = 2;", "VAR_0->msix_bar = 4;", "offset = memory_region_size(&VAR_0->modern_bar);", "offset -= VAR_0->notify.size;", "VAR_0->notify.offset = offset;", "offset -= VAR_0->device.size;", "VAR_0->device.offset = offset;", "offset -= VAR_0->isr.size;", "VAR_0->isr.offset = offset;", "offset -= VAR_0->common.size;", "VAR_0->common.offset = offset;", "qdev_set_parent_bus(DEVICE(g), BUS(&VAR_0->bus));", "VAR_0->flags &= ~VIRTIO_PCI_FLAG_DISABLE_MODERN;", "VAR_0->flags |= VIRTIO_PCI_FLAG_DISABLE_LEGACY;", "object_property_set_bool(OBJECT(g), true, \"realized\", &err);", "if (err) {", "error_propagate(VAR_1, err);", "return;", "}", "pci_std_vga_mmio_region_init(vga, &VAR_0->modern_bar,\nvvga->vga_mrs, true);", "vga->con = g->scanout[0].con;", "graphic_console_set_hwops(vga->con, &virtio_vga_ops, vvga);", "for (VAR_2 = 0; VAR_2 < g->conf.max_outputs; VAR_2++) {", "object_property_set_link(OBJECT(g->scanout[VAR_2].con),\nOBJECT(VAR_0),\n\"device\", VAR_1);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 29, 31 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 97, 99 ], [ 103 ], [ 105 ], [ 109 ], [ 111, 113, 115 ], [ 117 ], [ 119 ] ]

[ "static int FUNC_0(ulong VAR_0, void *VAR_1, int VAR_2)\n{", "struct virtio_blk_outhdr VAR_3;", "u8 status;", "VAR_3.type = VIRTIO_BLK_T_IN;", "VAR_3.ioprio = 99;", "VAR_3.VAR_0 = VAR_0;", "vring_send_buf(&block, &VAR_3, sizeof(VAR_3), VRING_DESC_F_NEXT);", "vring_send_buf(&block, VAR_1, SECTOR_SIZE * VAR_2,\nVRING_DESC_F_WRITE | VRING_HIDDEN_IS_CHAIN |\nVRING_DESC_F_NEXT);", "vring_send_buf(&block, &status, sizeof(u8), VRING_DESC_F_WRITE |\nVRING_HIDDEN_IS_CHAIN);", "vring_wait_reply(&block, 0);", "drain_irqs(block.schid);", "return status;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 27, 29, 31 ], [ 37, 39 ], [ 45 ], [ 49 ], [ 53 ], [ 55 ] ]

[ "static int FUNC_0(AVFilterLink *VAR_0, AVFrame *VAR_1)\n{", "AVFilterContext *ctx = VAR_0->dst;", "AVFilterLink *outlink = ctx->outputs[0];", "ColorSpaceContext *s = ctx->priv;", "AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);", "int VAR_2;", "ptrdiff_t rgb_stride = FFALIGN(VAR_1->width * sizeof(int16_t), 32);", "unsigned VAR_3 = rgb_stride * VAR_1->height;", "struct ThreadData VAR_4;", "if (!out) {", "av_frame_free(&VAR_1);", "return AVERROR(ENOMEM);", "}", "av_frame_copy_props(out, VAR_1);", "out->color_primaries = s->user_prm == AVCOL_PRI_UNSPECIFIED ?\ndefault_prm[FFMIN(s->user_all, CS_NB)] : s->user_prm;", "if (s->user_trc == AVCOL_TRC_UNSPECIFIED) {", "const AVPixFmtDescriptor *VAR_6 = av_pix_fmt_desc_get(out->format);", "out->color_trc = default_trc[FFMIN(s->user_all, CS_NB)];", "if (out->color_trc == AVCOL_TRC_BT2020_10 && VAR_6 && VAR_6->comp[0].depth >= 12)\nout->color_trc = AVCOL_TRC_BT2020_12;", "} else {", "out->color_trc = s->user_trc;", "}", "out->colorspace = s->user_csp == AVCOL_SPC_UNSPECIFIED ?\ndefault_csp[FFMIN(s->user_all, CS_NB)] : s->user_csp;", "out->color_range = s->user_rng == AVCOL_RANGE_UNSPECIFIED ?\nVAR_1->color_range : s->user_rng;", "if (VAR_3 != s->VAR_3) {", "const AVPixFmtDescriptor *VAR_6 = av_pix_fmt_desc_get(out->format);", "int VAR_6 = VAR_1->width >> VAR_6->log2_chroma_w;", "av_freep(&s->rgb[0]);", "av_freep(&s->rgb[1]);", "av_freep(&s->rgb[2]);", "s->VAR_3 = 0;", "av_freep(&s->dither_scratch_base[0][0]);", "av_freep(&s->dither_scratch_base[0][1]);", "av_freep(&s->dither_scratch_base[1][0]);", "av_freep(&s->dither_scratch_base[1][1]);", "av_freep(&s->dither_scratch_base[2][0]);", "av_freep(&s->dither_scratch_base[2][1]);", "s->rgb[0] = av_malloc(VAR_3);", "s->rgb[1] = av_malloc(VAR_3);", "s->rgb[2] = av_malloc(VAR_3);", "s->dither_scratch_base[0][0] =\nav_malloc(sizeof(*s->dither_scratch_base[0][0]) * (VAR_1->width + 4));", "s->dither_scratch_base[0][1] =\nav_malloc(sizeof(*s->dither_scratch_base[0][1]) * (VAR_1->width + 4));", "s->dither_scratch_base[1][0] =\nav_malloc(sizeof(*s->dither_scratch_base[1][0]) * (VAR_6 + 4));", "s->dither_scratch_base[1][1] =\nav_malloc(sizeof(*s->dither_scratch_base[1][1]) * (VAR_6 + 4));", "s->dither_scratch_base[2][0] =\nav_malloc(sizeof(*s->dither_scratch_base[2][0]) * (VAR_6 + 4));", "s->dither_scratch_base[2][1] =\nav_malloc(sizeof(*s->dither_scratch_base[2][1]) * (VAR_6 + 4));", "s->dither_scratch[0][0] = &s->dither_scratch_base[0][0][1];", "s->dither_scratch[0][1] = &s->dither_scratch_base[0][1][1];", "s->dither_scratch[1][0] = &s->dither_scratch_base[1][0][1];", "s->dither_scratch[1][1] = &s->dither_scratch_base[1][1][1];", "s->dither_scratch[2][0] = &s->dither_scratch_base[2][0][1];", "s->dither_scratch[2][1] = &s->dither_scratch_base[2][1][1];", "if (!s->rgb[0] || !s->rgb[1] || !s->rgb[2] ||\n!s->dither_scratch_base[0][0] || !s->dither_scratch_base[0][1] ||\n!s->dither_scratch_base[1][0] || !s->dither_scratch_base[1][1] ||\n!s->dither_scratch_base[2][0] || !s->dither_scratch_base[2][1]) {", "uninit(ctx);", "return AVERROR(ENOMEM);", "}", "s->VAR_3 = VAR_3;", "}", "VAR_2 = create_filtergraph(ctx, VAR_1, out);", "if (VAR_2 < 0)\nreturn VAR_2;", "s->rgb_stride = rgb_stride / sizeof(int16_t);", "VAR_4.VAR_1 = VAR_1;", "VAR_4.out = out;", "VAR_4.in_linesize[0] = VAR_1->linesize[0];", "VAR_4.in_linesize[1] = VAR_1->linesize[1];", "VAR_4.in_linesize[2] = VAR_1->linesize[2];", "VAR_4.out_linesize[0] = out->linesize[0];", "VAR_4.out_linesize[1] = out->linesize[1];", "VAR_4.out_linesize[2] = out->linesize[2];", "VAR_4.in_ss_h = av_pix_fmt_desc_get(VAR_1->format)->log2_chroma_h;", "VAR_4.out_ss_h = av_pix_fmt_desc_get(out->format)->log2_chroma_h;", "if (s->yuv2yuv_passthrough) {", "VAR_2 = av_frame_copy(out, VAR_1);", "if (VAR_2 < 0)\nreturn VAR_2;", "} else {", "ctx->internal->execute(ctx, convert, &VAR_4, NULL,\nFFMIN((VAR_1->height + 1) >> 1, ctx->graph->nb_threads));", "}", "av_frame_free(&VAR_1);", "return ff_filter_frame(outlink, out);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 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 ], [ 209 ], [ 211 ] ]

[ "static void FUNC_0(AVFormatContext *VAR_0,\nOutputStream *VAR_1,\nInputStream *VAR_2,\nAVSubtitle *VAR_3,\nint64_t VAR_4)\n{", "static uint8_t *VAR_5 = NULL;", "int VAR_6 = 1024 * 1024;", "int VAR_7, VAR_8, VAR_9;", "AVCodecContext *enc;", "AVPacket pkt;", "if (VAR_4 == AV_NOPTS_VALUE) {", "av_log(NULL, AV_LOG_ERROR, \"Subtitle packets must have a VAR_4\\n\");", "if (exit_on_error)\nexit_program(1);", "return;", "}", "enc = VAR_1->enc_ctx;", "if (!VAR_5) {", "VAR_5 = av_malloc(VAR_6);", "}", "if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)\nVAR_8 = 2;", "else\nVAR_8 = 1;", "for (VAR_9 = 0; VAR_9 < VAR_8; VAR_9++) {", "VAR_1->sync_opts = av_rescale_q(VAR_4, VAR_2->st->time_base, enc->time_base);", "if (!check_recording_time(VAR_1))\nreturn;", "VAR_3->VAR_4 = av_rescale_q(VAR_4, VAR_2->st->time_base, AV_TIME_BASE_Q);", "VAR_3->VAR_4 += av_rescale_q(VAR_3->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);", "VAR_3->end_display_time -= VAR_3->start_display_time;", "VAR_3->start_display_time = 0;", "VAR_1->frames_encoded++;", "VAR_7 = avcodec_encode_subtitle(enc, VAR_5,\nVAR_6, VAR_3);", "if (VAR_7 < 0) {", "av_log(NULL, AV_LOG_FATAL, \"Subtitle encoding failed\\n\");", "exit_program(1);", "}", "av_init_packet(&pkt);", "pkt.data = VAR_5;", "pkt.size = VAR_7;", "pkt.VAR_4 = av_rescale_q(VAR_3->VAR_4, AV_TIME_BASE_Q, VAR_1->st->time_base);", "if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {", "if (VAR_9 == 0)\npkt.VAR_4 += 90 * VAR_3->start_display_time;", "else\npkt.VAR_4 += 90 * VAR_3->end_display_time;", "}", "output_packet(VAR_0, &pkt, 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 ]

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 57, 59 ], [ 61, 63 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 121, 123 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ] ]

[ "static inline void FUNC_0(yuy2toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,\nlong width, long height,\nlong lumStride, long chromStride, long srcStride)\n{", "long VAR_0;", "const long VAR_1= width>>1;", "for(VAR_0=0; VAR_0<height; VAR_0+=2)", "{", "#ifdef HAVE_MMX\nasm volatile(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\"pcmpeqw %%mm7, %%mm7\t\t\\n\\t\"\n\"psrlw $8, %%mm7\t\t\\n\\t\"\nASMALIGN(4)\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 64(%0, %%\"REG_a\", 4)\t\\n\\t\"\n\"movq (%0, %%\"REG_a\", 4), %%mm0\t\\n\\t\"\n\"movq 8(%0, %%\"REG_a\", 4), %%mm1\\n\\t\"\n\"movq %%mm0, %%mm2\t\t\\n\\t\"\n\"movq %%mm1, %%mm3\t\t\\n\\t\"\n\"psrlw $8, %%mm0\t\t\\n\\t\"\n\"psrlw $8, %%mm1\t\t\\n\\t\"\n\"pand %%mm7, %%mm2\t\t\\n\\t\"\n\"pand %%mm7, %%mm3\t\t\\n\\t\"\n\"packuswb %%mm1, %%mm0\t\t\\n\\t\"\n\"packuswb %%mm3, %%mm2\t\t\\n\\t\"\nMOVNTQ\" %%mm2, (%1, %%\"REG_a\", 2)\\n\\t\"\n\"movq 16(%0, %%\"REG_a\", 4), %%mm1\\n\\t\"\n\"movq 24(%0, %%\"REG_a\", 4), %%mm2\\n\\t\"\n\"movq %%mm1, %%mm3\t\t\\n\\t\"\n\"movq %%mm2, %%mm4\t\t\\n\\t\"\n\"psrlw $8, %%mm1\t\t\\n\\t\"\n\"psrlw $8, %%mm2\t\t\\n\\t\"\n\"pand %%mm7, %%mm3\t\t\\n\\t\"\n\"pand %%mm7, %%mm4\t\t\\n\\t\"\n\"packuswb %%mm2, %%mm1\t\t\\n\\t\"\n\"packuswb %%mm4, %%mm3\t\t\\n\\t\"\nMOVNTQ\" %%mm3, 8(%1, %%\"REG_a\", 2)\\n\\t\"\n\"movq %%mm0, %%mm2\t\t\\n\\t\"\n\"movq %%mm1, %%mm3\t\t\\n\\t\"\n\"psrlw $8, %%mm0\t\t\\n\\t\"\n\"psrlw $8, %%mm1\t\t\\n\\t\"\n\"pand %%mm7, %%mm2\t\t\\n\\t\"\n\"pand %%mm7, %%mm3\t\t\\n\\t\"\n\"packuswb %%mm1, %%mm0\t\t\\n\\t\"\n\"packuswb %%mm3, %%mm2\t\t\\n\\t\"\nMOVNTQ\" %%mm0, (%3, %%\"REG_a\")\t\\n\\t\"\nMOVNTQ\" %%mm2, (%2, %%\"REG_a\")\t\\n\\t\"\n\"add $8, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %4, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n::\"r\"(src), \"r\"(ydst), \"r\"(udst), \"r\"(vdst), \"g\" (VAR_1)\n: \"memory\", \"%\"REG_a\n);", "ydst += lumStride;", "src += srcStride;", "asm volatile(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\nASMALIGN(4)\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 64(%0, %%\"REG_a\", 4)\t\\n\\t\"\n\"movq (%0, %%\"REG_a\", 4), %%mm0\t\\n\\t\"\n\"movq 8(%0, %%\"REG_a\", 4), %%mm1\\n\\t\"\n\"movq 16(%0, %%\"REG_a\", 4), %%mm2\\n\\t\"\n\"movq 24(%0, %%\"REG_a\", 4), %%mm3\\n\\t\"\n\"pand %%mm7, %%mm0\t\t\\n\\t\"\n\"pand %%mm7, %%mm1\t\t\\n\\t\"\n\"pand %%mm7, %%mm2\t\t\\n\\t\"\n\"pand %%mm7, %%mm3\t\t\\n\\t\"\n\"packuswb %%mm1, %%mm0\t\t\\n\\t\"\n\"packuswb %%mm3, %%mm2\t\t\\n\\t\"\nMOVNTQ\" %%mm0, (%1, %%\"REG_a\", 2)\\n\\t\"\nMOVNTQ\" %%mm2, 8(%1, %%\"REG_a\", 2)\\n\\t\"\n\"add $8, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %4, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n::\"r\"(src), \"r\"(ydst), \"r\"(udst), \"r\"(vdst), \"g\" (VAR_1)\n: \"memory\", \"%\"REG_a\n);", "#else\nlong i;", "for(i=0; i<VAR_1; i++)", "{", "ydst[2*i+0] \t= src[4*i+0];", "udst[i] \t= src[4*i+1];", "ydst[2*i+1] \t= src[4*i+2];", "vdst[i] \t= src[4*i+3];", "}", "ydst += lumStride;", "src += srcStride;", "for(i=0; i<VAR_1; i++)", "{", "ydst[2*i+0] \t= src[4*i+0];", "ydst[2*i+1] \t= src[4*i+2];", "}", "#endif\nudst += chromStride;", "vdst += chromStride;", "ydst += lumStride;", "src += srcStride;", "}", "#ifdef HAVE_MMX\nasm volatile( EMMS\" \\n\\t\"\nSFENCE\" \\n\\t\"\n:::\"memory\");", "#endif\n}" ]

[ 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 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, 55, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 81, 85, 87, 89, 91, 93, 95, 97, 99, 103, 105, 109, 111, 113, 115, 117, 119 ], [ 123 ], [ 125 ], [ 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 161, 163, 167, 169, 171, 175, 177, 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215, 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227, 229, 231, 233 ], [ 235, 237 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "TCXState *ts = VAR_0;", "ram_addr_t page, page_min, page_max;", "int VAR_1, VAR_2, VAR_3, VAR_4;", "uint8_t *d, *s;", "void (*VAR_5)(TCXState *VAR_6, uint8_t *VAR_7, const uint8_t *VAR_8, int VAR_9);", "if (ts->VAR_4->depth == 0)\nreturn;", "page = ts->vram_offset;", "VAR_2 = -1;", "page_min = 0xffffffff;", "page_max = 0;", "d = ts->VAR_4->data;", "s = ts->vram;", "VAR_3 = ts->VAR_4->linesize;", "VAR_4 = 1024;", "switch (ts->VAR_4->depth) {", "case 32:\nVAR_5 = tcx_draw_line32;", "break;", "case 15:\ncase 16:\nVAR_5 = tcx_draw_line16;", "break;", "default:\ncase 8:\nVAR_5 = tcx_draw_line8;", "break;", "case 0:\nreturn;", "}", "for(VAR_1 = 0; VAR_1 < ts->height; VAR_1 += 4, page += TARGET_PAGE_SIZE) {", "if (cpu_physical_memory_get_dirty(page, VGA_DIRTY_FLAG)) {", "if (VAR_2 < 0)\nVAR_2 = VAR_1;", "if (page < page_min)\npage_min = page;", "if (page > page_max)\npage_max = page;", "VAR_5(ts, d, s, ts->VAR_9);", "d += VAR_3;", "s += VAR_4;", "VAR_5(ts, d, s, ts->VAR_9);", "d += VAR_3;", "s += VAR_4;", "VAR_5(ts, d, s, ts->VAR_9);", "d += VAR_3;", "s += VAR_4;", "VAR_5(ts, d, s, ts->VAR_9);", "d += VAR_3;", "s += VAR_4;", "} else {", "if (VAR_2 >= 0) {", "dpy_update(ts->VAR_4, 0, VAR_2,\nts->VAR_9, VAR_1 - VAR_2);", "VAR_2 = -1;", "}", "d += VAR_3 * 4;", "s += VAR_4 * 4;", "}", "}", "if (VAR_2 >= 0) {", "dpy_update(ts->VAR_4, 0, VAR_2,\nts->VAR_9, VAR_1 - VAR_2);", "}", "if (page_min <= page_max) {", "cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,\nVGA_DIRTY_FLAG);", "}", "}" ]

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

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

[ "static int FUNC_0(hwaddr VAR_0,\nuint32_t VAR_1,\nhwaddr VAR_2,\nhwaddr VAR_3,\nconst char *VAR_4)\n{", "int VAR_5 = -1;", "uint32_t mem_reg_property[] = { 0, 0, cpu_to_be32(VAR_1) };", "char *VAR_6;", "int VAR_7;", "void *VAR_8;", "uint32_t tb_freq = 400000000;", "uint32_t clock_freq = 400000000;", "VAR_6 = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);", "if (!VAR_6) {", "goto out;", "}", "VAR_8 = load_device_tree(VAR_6, &VAR_7);", "g_free(VAR_6);", "if (VAR_8 == NULL) {", "goto out;", "}", "VAR_5 = qemu_devtree_setprop(VAR_8, \"/memory\", \"reg\", mem_reg_property,\nsizeof(mem_reg_property));", "if (VAR_5 < 0)\nfprintf(stderr, \"couldn't set /memory/reg\\n\");", "VAR_5 = qemu_devtree_setprop_cell(VAR_8, \"/chosen\", \"linux,initrd-start\",\nVAR_2);", "if (VAR_5 < 0)\nfprintf(stderr, \"couldn't set /chosen/linux,initrd-start\\n\");", "VAR_5 = qemu_devtree_setprop_cell(VAR_8, \"/chosen\", \"linux,initrd-end\",\n(VAR_2 + VAR_3));", "if (VAR_5 < 0)\nfprintf(stderr, \"couldn't set /chosen/linux,initrd-end\\n\");", "VAR_5 = qemu_devtree_setprop_string(VAR_8, \"/chosen\", \"bootargs\",\nVAR_4);", "if (VAR_5 < 0)\nfprintf(stderr, \"couldn't set /chosen/bootargs\\n\");", "if (kvm_enabled()) {", "tb_freq = kvmppc_get_tbfreq();", "clock_freq = kvmppc_get_clockfreq();", "}", "qemu_devtree_setprop_cell(VAR_8, \"/cpus/cpu@0\", \"clock-frequency\",\nclock_freq);", "qemu_devtree_setprop_cell(VAR_8, \"/cpus/cpu@0\", \"timebase-frequency\",\ntb_freq);", "VAR_5 = rom_add_blob_fixed(BINARY_DEVICE_TREE_FILE, VAR_8, VAR_7, VAR_0);", "g_free(VAR_8);", "out:\nreturn VAR_5;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 53, 55 ], [ 57, 59 ], [ 63, 65 ], [ 67, 69 ], [ 73, 75 ], [ 77, 79 ], [ 83, 85 ], [ 87, 89 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 113, 115 ], [ 119 ], [ 121 ], [ 125, 129 ], [ 131 ] ]

[ "static int FUNC_0(VP8Context *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "VP56RangeCoder *c = &VAR_0->c;", "int VAR_3, VAR_4, VAR_5, VAR_13, VAR_13, VAR_8;", "int VAR_9 = VAR_0->avctx->VAR_9;", "int VAR_10 = VAR_0->avctx->VAR_10;", "VAR_0->profile = (VAR_1[0]>>1) & 7;", "if (VAR_0->profile > 1) {", "avpriv_request_sample(VAR_0->avctx, \"Unknown profile %d\", VAR_0->profile);", "VAR_0->keyframe = !(VAR_1[0] & 1);", "VAR_0->invisible = 0;", "VAR_3 = AV_RL24(VAR_1) >> 4;", "VAR_1 += 4 - VAR_0->profile;", "VAR_2 -= 4 - VAR_0->profile;", "memcpy(VAR_0->put_pixels_tab, VAR_0->vp8dsp.put_vp8_epel_pixels_tab, sizeof(VAR_0->put_pixels_tab));", "ff_vp56_init_range_decoder(c, VAR_1, VAR_3);", "VAR_1 += VAR_3;", "VAR_2 -= VAR_3;", "if (VAR_0->keyframe) {", "VAR_9 = vp8_rac_get_uint(c, 12);", "VAR_10 = vp8_rac_get_uint(c, 12);", "VAR_4 = vp8_rac_get_uint(c, 2);", "VAR_5 = vp8_rac_get_uint(c, 2);", "if (VAR_4 || VAR_5)\navpriv_request_sample(VAR_0->avctx, \"Upscaling\");", "VAR_0->update_golden = VAR_0->update_altref = VP56_FRAME_CURRENT;", "vp78_reset_probability_tables(VAR_0);", "memcpy(VAR_0->prob->pred16x16, vp8_pred16x16_prob_inter, sizeof(VAR_0->prob->pred16x16));", "memcpy(VAR_0->prob->pred8x8c , vp8_pred8x8c_prob_inter , sizeof(VAR_0->prob->pred8x8c));", "for (VAR_13 = 0; VAR_13 < 2; VAR_13++)", "memcpy(VAR_0->prob->mvc[VAR_13], vp7_mv_default_prob[VAR_13], sizeof(vp7_mv_default_prob[VAR_13]));", "memset(&VAR_0->segmentation, 0, sizeof(VAR_0->segmentation));", "memset(&VAR_0->lf_delta, 0, sizeof(VAR_0->lf_delta));", "memcpy(VAR_0->prob[0].scan, zigzag_scan, sizeof(VAR_0->prob[0].scan));", "if (VAR_0->keyframe || VAR_0->profile > 0)\nmemset(VAR_0->inter_dc_pred, 0 , sizeof(VAR_0->inter_dc_pred));", "for (VAR_13 = 0; VAR_13 < 4; VAR_13++) {", "VAR_0->feature_enabled[VAR_13] = vp8_rac_get(c);", "if (VAR_0->feature_enabled[VAR_13]) {", "VAR_0->feature_present_prob[VAR_13] = vp8_rac_get_uint(c, 8);", "for (VAR_13 = 0; VAR_13 < 3; VAR_13++)", "VAR_0->feature_index_prob[VAR_13][VAR_13] = vp8_rac_get(c) ? vp8_rac_get_uint(c, 8) : 255;", "if (vp7_feature_value_size[VAR_13])\nfor (VAR_13 = 0; VAR_13 < 4; VAR_13++)", "VAR_0->feature_value[VAR_13][VAR_13] = vp8_rac_get(c) ? vp8_rac_get_uint(c, vp7_feature_value_size[VAR_0->profile][VAR_13]) : 0;", "VAR_0->segmentation.enabled = 0;", "VAR_0->segmentation.update_map = 0;", "VAR_0->lf_delta.enabled = 0;", "VAR_0->num_coeff_partitions = 1;", "ff_vp56_init_range_decoder(&VAR_0->coeff_partition[0], VAR_1, VAR_2);", "if (!VAR_0->macroblocks_base ||\nVAR_9 != VAR_0->avctx->VAR_9 || VAR_10 != VAR_0->avctx->VAR_10 || (VAR_9+15)/16 != VAR_0->mb_width || (VAR_10+15)/16 != VAR_0->mb_height) {", "if ((VAR_8 = update_dimensions(VAR_0, VAR_9, VAR_10)) < 0)\nreturn VAR_8;", "vp7_get_quants(VAR_0);", "if (!VAR_0->keyframe) {", "VAR_0->update_golden = vp8_rac_get(c) ? VP56_FRAME_CURRENT : VP56_FRAME_NONE;", "VAR_0->sign_bias[VP56_FRAME_GOLDEN] = 0;", "VAR_0->update_last = 1;", "VAR_0->update_probabilities = 1;", "VAR_0->fade_present = 1;", "if (VAR_0->profile > 0) {", "VAR_0->update_probabilities = vp8_rac_get(c);", "if (!VAR_0->update_probabilities)\nVAR_0->prob[1] = VAR_0->prob[0];", "if (!VAR_0->keyframe)\nVAR_0->fade_present = vp8_rac_get(c);", "if (VAR_0->fade_present && vp8_rac_get(c)) {", "int VAR_11 = (int8_t)vp8_rac_get_uint(c, 8);", "int VAR_12 = (int8_t)vp8_rac_get_uint(c, 8);", "if (!VAR_0->keyframe && (VAR_11 || VAR_12)) {", "if (VAR_0->framep[VP56_FRAME_GOLDEN] == VAR_0->framep[VP56_FRAME_PREVIOUS]) {", "AVFrame *gold = VAR_0->framep[VP56_FRAME_GOLDEN]->tf.f;", "AVFrame *prev;", "int VAR_13, VAR_13;", "VAR_0->framep[VP56_FRAME_PREVIOUS] = vp8_find_free_buffer(VAR_0);", "if ((VAR_8 = vp8_alloc_frame(VAR_0, VAR_0->framep[VP56_FRAME_PREVIOUS], 1)) < 0)\nreturn VAR_8;", "prev = VAR_0->framep[VP56_FRAME_PREVIOUS]->tf.f;", "fade(prev->data[0], prev->linesize[0], gold->data[0], gold->linesize[0], VAR_0->mb_width * 16, VAR_0->mb_height * 16, VAR_11, VAR_12);", "for (VAR_13 = 1; VAR_13 < 3; VAR_13++)", "for (VAR_13 = 0; VAR_13 < VAR_0->mb_height * 8; VAR_13++)", "memcpy(prev->data[VAR_13] + VAR_13 * prev->linesize[VAR_13], gold->data[VAR_13] + VAR_13 * gold->linesize[VAR_13], VAR_0->mb_width * 8);", "} else {", "AVFrame *prev = VAR_0->framep[VP56_FRAME_PREVIOUS]->tf.f;", "fade(prev->data[0], prev->linesize[0], prev->data[0], prev->linesize[0], VAR_0->mb_width * 16, VAR_0->mb_height * 16, VAR_11, VAR_12);", "if (!VAR_0->profile)\nVAR_0->filter.simple = vp8_rac_get(c);", "if (vp8_rac_get(c))\nfor (VAR_13 = 1; VAR_13 < 16; VAR_13++)", "VAR_0->prob[0].scan[VAR_13] = zigzag_scan[vp8_rac_get_uint(c, 4)];", "if (VAR_0->profile > 0)\nVAR_0->filter.simple = vp8_rac_get(c);", "VAR_0->filter.level = vp8_rac_get_uint(c, 6);", "VAR_0->filter.sharpness = vp8_rac_get_uint(c, 3);", "vp78_update_probability_tables(VAR_0);", "VAR_0->mbskip_enabled = 0;", "if (!VAR_0->keyframe) {", "VAR_0->prob->intra = vp8_rac_get_uint(c, 8);", "VAR_0->prob->last = vp8_rac_get_uint(c, 8);", "vp78_update_pred16x16_pred8x8_mvc_probabilities(VAR_0);", "return 0;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25, 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36, 37 ], [ 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43 ], [ 44 ], [ 45, 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52 ], [ 53, 54 ], [ 55, 56 ], [ 58 ], [ 60 ], [ 61 ], [ 62 ], [ 63 ], [ 64 ], [ 65 ], [ 66 ], [ 67 ], [ 68, 69 ], [ 70, 71 ], [ 73 ], [ 74 ], [ 75 ], [ 76 ], [ 78 ], [ 79 ], [ 80 ], [ 81 ], [ 82 ], [ 83, 84 ], [ 85 ], [ 86 ], [ 87 ], [ 88 ], [ 89 ], [ 90 ], [ 91 ], [ 92 ], [ 94, 95 ], [ 97, 98 ], [ 99 ], [ 101, 102 ], [ 103 ], [ 104 ], [ 106 ], [ 107 ], [ 109 ], [ 110 ], [ 111 ], [ 112 ], [ 113 ] ]

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

[ 0, 0, 1, 0 ]

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "Vp3DecodeContext *s = avctx->priv_data;", "GetBitContext gb;", "int VAR_0;", "const uint8_t *VAR_1[3];", "int VAR_2[3];", "int VAR_3;", "avctx->pix_fmt = AV_PIX_FMT_YUV420P;", "s->theora = 1;", "if (!avctx->extradata_size) {", "av_log(avctx, AV_LOG_ERROR, \"Missing extradata!\\n\");", "return -1;", "}", "if (avpriv_split_xiph_headers(avctx->extradata, avctx->extradata_size,\n42, VAR_1, VAR_2) < 0) {", "av_log(avctx, AV_LOG_ERROR, \"Corrupt extradata\\n\");", "return -1;", "}", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "if (VAR_2[VAR_3] <= 0)\ncontinue;", "init_get_bits8(&gb, VAR_1[VAR_3], VAR_2[VAR_3]);", "VAR_0 = get_bits(&gb, 8);", "if (!(VAR_0 & 0x80)) {", "av_log(avctx, AV_LOG_ERROR, \"Invalid extradata!\\n\");", "}", "skip_bits_long(&gb, 6 * 8);", "switch (VAR_0) {", "case 0x80:\nif (theora_decode_header(avctx, &gb) < 0)\nreturn -1;", "break;", "case 0x81:\nbreak;", "case 0x82:\nif (theora_decode_tables(avctx, &gb))\nreturn -1;", "break;", "default:\nav_log(avctx, AV_LOG_ERROR,\n\"Unknown Theora config packet: %d\\n\", VAR_0 & ~0x80);", "break;", "}", "if (VAR_0 != 0x81 && 8 * VAR_2[VAR_3] != get_bits_count(&gb))\nav_log(avctx, AV_LOG_WARNING,\n\"%d bits left in packet %X\\n\",\n8 * VAR_2[VAR_3] - get_bits_count(&gb), VAR_0);", "if (s->theora < 0x030200)\nbreak;", "}", "return vp3_decode_init(avctx);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37, 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 59 ], [ 63 ], [ 65 ], [ 69 ], [ 75 ], [ 79 ], [ 81, 83, 85 ], [ 87 ], [ 89, 95 ], [ 97, 99, 101 ], [ 103 ], [ 105, 107, 109 ], [ 111 ], [ 113 ], [ 115, 117, 119, 121 ], [ 123, 125 ], [ 127 ], [ 131 ], [ 133 ] ]

[ "uint64_t FUNC_0(CPUAlphaState *env, uint64_t op1, uint64_t op2)\n{", "uint32_t res;", "res = op1 - op2;", "if (unlikely((op1 ^ op2) & (res ^ op1) & (1UL << 31))) {", "arith_excp(env, GETPC(), EXC_M_IOV, 0);", "}", "return res;", "}" ]

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

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

[ "static int FUNC_0(IVI45DecContext *VAR_0, IVIBandDesc *VAR_1,\nIVITile *VAR_2, AVCodecContext *VAR_3)\n{", "int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10,\nVAR_11, VAR_12;", "IVIMbInfo *mb, *ref_mb;", "int VAR_13 = VAR_1->mb_size * VAR_1->pitch;", "mb = VAR_2->mbs;", "ref_mb = VAR_2->ref_mbs;", "VAR_9 = VAR_2->ypos * VAR_1->pitch + VAR_2->xpos;", "if (!ref_mb &&\n((VAR_1->qdelta_present && VAR_1->inherit_qdelta) || VAR_1->inherit_mv))\nreturn AVERROR_INVALIDDATA;", "if (VAR_2->num_MBs != IVI_MBs_PER_TILE(VAR_2->width, VAR_2->height, VAR_1->mb_size)) {", "av_log(VAR_3, AV_LOG_ERROR, \"Allocated VAR_2 size %d mismatches parameters %d\\n\",\nVAR_2->num_MBs, IVI_MBs_PER_TILE(VAR_2->width, VAR_2->height, VAR_1->mb_size));", "return AVERROR_INVALIDDATA;", "}", "VAR_11 = (VAR_0->planes[0].bands[0].mb_size >> 3) - (VAR_1->mb_size >> 3);", "VAR_6 = VAR_7 = 0;", "for (VAR_5 = VAR_2->ypos; VAR_5 < (VAR_2->ypos + VAR_2->height); VAR_5 += VAR_1->mb_size) {", "VAR_10 = VAR_9;", "for (VAR_4 = VAR_2->xpos; VAR_4 < (VAR_2->xpos + VAR_2->width); VAR_4 += VAR_1->mb_size) {", "mb->xpos = VAR_4;", "mb->ypos = VAR_5;", "mb->buf_offs = VAR_10;", "if (get_bits1(&VAR_0->gb)) {", "if (VAR_0->frame_type == FRAMETYPE_INTRA) {", "av_log(VAR_3, AV_LOG_ERROR, \"Empty macroblock in an INTRA picture!\\n\");", "return -1;", "}", "mb->type = 1;", "mb->cbp = 0;", "mb->q_delta = 0;", "if (!VAR_1->plane && !VAR_1->band_num && (VAR_0->frame_flags & 8)) {", "mb->q_delta = get_vlc2(&VAR_0->gb, VAR_0->mb_vlc.tab->table,\nIVI_VLC_BITS, 1);", "mb->q_delta = IVI_TOSIGNED(mb->q_delta);", "}", "mb->VAR_6 = mb->VAR_7 = 0;", "if (VAR_1->inherit_mv){", "if (VAR_11) {", "mb->VAR_6 = ivi_scale_mv(ref_mb->VAR_6, VAR_11);", "mb->VAR_7 = ivi_scale_mv(ref_mb->VAR_7, VAR_11);", "} else {", "mb->VAR_6 = ref_mb->VAR_6;", "mb->VAR_7 = ref_mb->VAR_7;", "}", "}", "} else {", "if (VAR_1->inherit_mv) {", "mb->type = ref_mb->type;", "} else if (VAR_0->frame_type == FRAMETYPE_INTRA) {", "mb->type = 0;", "} else {", "mb->type = get_bits1(&VAR_0->gb);", "}", "VAR_12 = VAR_1->mb_size != VAR_1->blk_size ? 4 : 1;", "mb->cbp = get_bits(&VAR_0->gb, VAR_12);", "mb->q_delta = 0;", "if (VAR_1->qdelta_present) {", "if (VAR_1->inherit_qdelta) {", "if (ref_mb) mb->q_delta = ref_mb->q_delta;", "} else if (mb->cbp || (!VAR_1->plane && !VAR_1->band_num &&", "(VAR_0->frame_flags & 8))) {", "mb->q_delta = get_vlc2(&VAR_0->gb, VAR_0->mb_vlc.tab->table,\nIVI_VLC_BITS, 1);", "mb->q_delta = IVI_TOSIGNED(mb->q_delta);", "}", "}", "if (!mb->type) {", "mb->VAR_6 = mb->VAR_7 = 0;", "} else {", "if (VAR_1->inherit_mv){", "if (VAR_11) {", "mb->VAR_6 = ivi_scale_mv(ref_mb->VAR_6, VAR_11);", "mb->VAR_7 = ivi_scale_mv(ref_mb->VAR_7, VAR_11);", "} else {", "mb->VAR_6 = ref_mb->VAR_6;", "mb->VAR_7 = ref_mb->VAR_7;", "}", "} else {", "VAR_8 = get_vlc2(&VAR_0->gb, VAR_0->mb_vlc.tab->table,\nIVI_VLC_BITS, 1);", "VAR_7 += IVI_TOSIGNED(VAR_8);", "VAR_8 = get_vlc2(&VAR_0->gb, VAR_0->mb_vlc.tab->table,\nIVI_VLC_BITS, 1);", "VAR_6 += IVI_TOSIGNED(VAR_8);", "mb->VAR_6 = VAR_6;", "mb->VAR_7 = VAR_7;", "if (VAR_6 < 0 || VAR_7 < 0) {", "av_log(VAR_3, AV_LOG_ERROR, \"Invalid MV %d %d\\n\",\nVAR_6, VAR_7);", "mb->VAR_6 = mb->VAR_7 = 0;", "return AVERROR_INVALIDDATA;", "}", "}", "}", "}", "mb++;", "if (ref_mb)\nref_mb++;", "VAR_10 += VAR_1->mb_size;", "}", "VAR_9 += VAR_13;", "}", "align_get_bits(&VAR_0->gb);", "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 ]

[ [ 1, 3, 5 ], [ 7, 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25, 27, 29 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197, 199 ], [ 201 ], [ 203, 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215, 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 245 ], [ 247 ], [ 251 ], [ 255 ], [ 257 ] ]

[ "static int FUNC_0(MPADecodeContext *VAR_0, GranuleDef *VAR_1,\nint16_t *VAR_2, int VAR_3)\n{", "int VAR_4;", "int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_18;", "int VAR_15;", "VLC *vlc;", "VAR_4 = 0;", "for(VAR_11=0;VAR_11<3;VAR_11++) {", "VAR_12 = VAR_1->region_size[VAR_11];", "if (VAR_12 == 0)\ncontinue;", "VAR_13 = VAR_1->table_select[VAR_11];", "VAR_9 = mpa_huff_data[VAR_13][0];", "VAR_5 = mpa_huff_data[VAR_13][1];", "vlc = &huff_vlc[VAR_9];", "if(!VAR_9){", "memset(&VAR_1->sb_hybrid[VAR_4], 0, sizeof(*VAR_1->sb_hybrid)*VAR_12);", "VAR_4 += 2*VAR_12;", "continue;", "}", "for(;VAR_12>0;VAR_12--) {", "int VAR_16;", "if (get_bits_count(&VAR_0->gb) >= VAR_3)\nbreak;", "VAR_8 = get_vlc2(&VAR_0->gb, vlc->table, 7, 3);", "if(!VAR_8){", "VAR_1->sb_hybrid[VAR_4 ] =\nVAR_1->sb_hybrid[VAR_4+1] = 0;", "VAR_4 += 2;", "continue;", "}", "VAR_7 = VAR_8 >> 4;", "VAR_8 = VAR_8 & 0x0f;", "VAR_16= VAR_2[VAR_4];", "dprintf(\"region=%d n=%d VAR_7=%d VAR_8=%d exp=%d\\n\",\nVAR_11, VAR_1->region_size[VAR_11] - VAR_12, VAR_7, VAR_8, VAR_16);", "if (VAR_7) {", "#if 0\nif (VAR_7 == 15)\nVAR_7 += get_bitsz(&VAR_0->gb, VAR_5);", "VAR_10 = l3_unscale(VAR_7, VAR_16);", "#else\nif (VAR_7 < 15){", "VAR_10 = expval_table[ VAR_16 + 400 ][ VAR_7 ];", "}else{", "VAR_7 += get_bitsz(&VAR_0->gb, VAR_5);", "VAR_10 = l3_unscale(VAR_7, VAR_16);", "}", "#endif\nif (get_bits1(&VAR_0->gb))\nVAR_10 = -VAR_10;", "} else {", "VAR_10 = 0;", "}", "VAR_1->sb_hybrid[VAR_4++] = VAR_10;", "if (VAR_8) {", "#if 0\nif (VAR_8 == 15)\nVAR_8 += get_bitsz(&VAR_0->gb, VAR_5);", "VAR_10 = l3_unscale(VAR_8, VAR_16);", "#else\nif (VAR_8 < 15){", "VAR_10 = expval_table[ VAR_16 + 400 ][ VAR_8 ];", "}else{", "VAR_8 += get_bitsz(&VAR_0->gb, VAR_5);", "VAR_10 = l3_unscale(VAR_8, VAR_16);", "}", "#endif\nif (get_bits1(&VAR_0->gb))\nVAR_10 = -VAR_10;", "} else {", "VAR_10 = 0;", "}", "VAR_1->sb_hybrid[VAR_4++] = VAR_10;", "}", "}", "vlc = &huff_quad_vlc[VAR_1->count1table_select];", "VAR_15=0;", "while (VAR_4 <= 572) {", "VAR_18 = get_bits_count(&VAR_0->gb);", "if (VAR_18 >= VAR_3) {", "if (VAR_18 > VAR_3 && VAR_15){", "VAR_4 -= 4;", "init_get_bits(&VAR_0->gb, VAR_0->gb.buffer + 4*(VAR_15>>5), VAR_0->gb.size_in_bits - (VAR_15&(~31)));", "skip_bits(&VAR_0->gb, VAR_15&31);", "}", "break;", "}", "VAR_15= VAR_18;", "VAR_6 = get_vlc2(&VAR_0->gb, vlc->table, vlc->bits, 1);", "dprintf(\"t=%d VAR_6=%d\\n\", VAR_1->count1table_select, VAR_6);", "VAR_1->sb_hybrid[VAR_4+0]=\nVAR_1->sb_hybrid[VAR_4+1]=\nVAR_1->sb_hybrid[VAR_4+2]=\nVAR_1->sb_hybrid[VAR_4+3]= 0;", "while(VAR_6){", "const static int VAR_17[16]={3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0};", "int VAR_18= VAR_4+VAR_17[VAR_6];", "VAR_6 ^= 8>>VAR_17[VAR_6];", "VAR_10 = exp_table[ VAR_2[VAR_18] + 400];", "if(get_bits1(&VAR_0->gb))\nVAR_10 = -VAR_10;", "VAR_1->sb_hybrid[VAR_18] = VAR_10;", "}", "VAR_4+=4;", "}", "memset(&VAR_1->sb_hybrid[VAR_4], 0, sizeof(*VAR_1->sb_hybrid)*(576 - VAR_4));", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 55 ], [ 57 ], [ 61, 63 ], [ 65 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 91, 93 ], [ 95 ], [ 97, 99, 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 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 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 213 ], [ 215 ], [ 217, 219, 221, 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ] ]

[ "static int FUNC_0(struct mm_struct *VAR_0, abi_ulong VAR_1,\nabi_ulong VAR_2, abi_ulong VAR_3)\n{", "struct vm_area_struct *VAR_4;", "if ((VAR_4 = qemu_mallocz(sizeof (*VAR_4))) == NULL)\nreturn (-1);", "VAR_4->vma_start = VAR_1;", "VAR_4->vma_end = VAR_2;", "VAR_4->vma_flags = VAR_3;", "TAILQ_INSERT_TAIL(&VAR_0->mm_mmap, VAR_4, vma_link);", "VAR_0->mm_count++;", "return (0);", "}" ]

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

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

[ "static inline abi_long FUNC_0(int fd, struct sockaddr *addr,\nabi_ulong target_addr,\nsocklen_t len)\n{", "const socklen_t VAR_0 = sizeof (struct sockaddr_un);", "sa_family_t sa_family;", "struct target_sockaddr *VAR_1;", "if (fd_trans_target_to_host_addr(fd)) {", "return fd_trans_target_to_host_addr(fd)(addr, target_addr, len);", "}", "VAR_1 = lock_user(VERIFY_READ, target_addr, len, 1);", "if (!VAR_1)\nreturn -TARGET_EFAULT;", "sa_family = tswap16(VAR_1->sa_family);", "if (sa_family == AF_UNIX) {", "if (len < VAR_0 && len > 0) {", "char *VAR_2 = (char*)VAR_1;", "if ( VAR_2[len-1] && !VAR_2[len] )\nlen++;", "}", "if (len > VAR_0)\nlen = VAR_0;", "}", "memcpy(addr, VAR_1, len);", "addr->sa_family = sa_family;", "if (sa_family == AF_PACKET) {", "struct target_sockaddr_ll *VAR_3;", "VAR_3 = (struct target_sockaddr_ll *)addr;", "VAR_3->sll_ifindex = tswap32(VAR_3->sll_ifindex);", "VAR_3->sll_hatype = tswap16(VAR_3->sll_hatype);", "}", "unlock_user(VAR_1, target_addr, 0);", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27, 29 ], [ 33 ], [ 53 ], [ 55 ], [ 57 ], [ 61, 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ] ]

[ "int FUNC_0(CPUState *VAR_0, int VAR_1)\n{", "X86CPU *x86_cpu = X86_CPU(VAR_0);", "int VAR_2;", "assert(cpu_is_stopped(VAR_0) || qemu_cpu_is_self(VAR_0));", "if (VAR_1 >= KVM_PUT_RESET_STATE) {", "VAR_2 = kvm_put_msr_feature_control(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "}", "if (VAR_1 == KVM_PUT_FULL_STATE) {", "kvm_arch_set_tsc_khz(VAR_0);", "}", "VAR_2 = kvm_getput_regs(x86_cpu, 1);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_xsave(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_xcrs(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_sregs(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_inject_mce_oldstyle(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_msrs(x86_cpu, VAR_1);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "if (VAR_1 >= KVM_PUT_RESET_STATE) {", "VAR_2 = kvm_put_mp_state(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "}", "VAR_2 = kvm_put_tscdeadline_msr(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_vcpu_events(x86_cpu, VAR_1);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_put_debugregs(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "VAR_2 = kvm_guest_debug_workarounds(x86_cpu);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ] ]

[ "void FUNC_0(ProresDSPContext *VAR_0)\n{", "#if ARCH_X86_64 && HAVE_YASM\nint flags = av_get_cpu_flags();", "if (flags & AV_CPU_FLAG_SSE2) {", "VAR_0->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;", "VAR_0->idct_put = ff_prores_idct_put_10_sse2;", "}", "if (flags & AV_CPU_FLAG_SSE4) {", "VAR_0->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;", "VAR_0->idct_put = ff_prores_idct_put_10_sse4;", "}", "#if HAVE_AVX\nif (flags & AV_CPU_FLAG_AVX) {", "VAR_0->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;", "VAR_0->idct_put = ff_prores_idct_put_10_avx;", "}", "#endif\n#endif\n}" ]

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

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

[ "void FUNC_0(VirtIOSCSI *VAR_0, IOThread *VAR_1)\n{", "BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(VAR_0)));", "VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);", "VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(VAR_0);", "assert(!VAR_0->ctx);", "VAR_0->ctx = iothread_get_aio_context(vs->conf.VAR_1);", "if (!k->set_guest_notifiers || !k->ioeventfd_assign) {", "fprintf(stderr, \"virtio-scsi: Failed to set VAR_1 \"\n\"(transport does not support notifiers)\");", "exit(1);", "}", "}" ]

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

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

[ "void VAR_0 op_decl_ECX(void)\n{", "ECX = (uint32_t)(ECX - 1);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(Visitor *VAR_0, char **VAR_1, const char *VAR_2,\nError **VAR_3)\n{", "g_free(*VAR_1);", "}" ]

[ 0, 0, 0 ]

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

[ "static inline void FUNC_0(PXA2xxState *VAR_0)\n{", "qemu_set_irq(VAR_0->pic[PXA2XX_PIC_RTCALARM], !!(VAR_0->rtsr & 0x2553));", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(KVMState *VAR_0)\n{", "int VAR_1;", "struct kvm_device_attr VAR_2 = {", ".group = KVM_S390_VM_MEM_CTRL,\n.VAR_2 = KVM_S390_VM_MEM_ENABLE_CMMA,\n};", "if (kvm_s390_check_enable_cmma(VAR_0) || kvm_s390_check_clear_cmma(VAR_0)) {", "return;", "}", "VAR_1 = kvm_vm_ioctl(VAR_0, KVM_SET_DEVICE_ATTR, &VAR_2);", "if (!VAR_1) {", "qemu_register_reset(kvm_s390_clear_cmma_callback, VAR_0);", "}", "trace_kvm_enable_cmma(VAR_1);", "}" ]

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

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

[ "int FUNC_0(CPUX86State *VAR_0)\n{", "struct {", "struct kvm_cpuid2 cpuid;", "struct kvm_cpuid_entry2 entries[100];", "} QEMU_PACKED VAR_1;", "KVMState *s = VAR_0->kvm_state;", "uint32_t limit, i, j, cpuid_i;", "uint32_t unused;", "struct kvm_cpuid_entry2 *VAR_2;", "uint32_t signature[3];", "int VAR_3;", "VAR_0->cpuid_features &= kvm_arch_get_supported_cpuid(s, 1, 0, R_EDX);", "j = VAR_0->cpuid_ext_features & CPUID_EXT_TSC_DEADLINE_TIMER;", "VAR_0->cpuid_ext_features &= kvm_arch_get_supported_cpuid(s, 1, 0, R_ECX);", "if (j && kvm_irqchip_in_kernel() &&\nkvm_check_extension(s, KVM_CAP_TSC_DEADLINE_TIMER)) {", "VAR_0->cpuid_ext_features |= CPUID_EXT_TSC_DEADLINE_TIMER;", "}", "VAR_0->cpuid_ext2_features &= kvm_arch_get_supported_cpuid(s, 0x80000001,\n0, R_EDX);", "VAR_0->cpuid_ext3_features &= kvm_arch_get_supported_cpuid(s, 0x80000001,\n0, R_ECX);", "VAR_0->cpuid_svm_features &= kvm_arch_get_supported_cpuid(s, 0x8000000A,\n0, R_EDX);", "cpuid_i = 0;", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = KVM_CPUID_SIGNATURE;", "if (!hyperv_enabled()) {", "memcpy(signature, \"KVMKVMKVM\\0\\0\\0\", 12);", "VAR_2->eax = 0;", "} else {", "memcpy(signature, \"Microsoft Hv\", 12);", "VAR_2->eax = HYPERV_CPUID_MIN;", "}", "VAR_2->ebx = signature[0];", "VAR_2->ecx = signature[1];", "VAR_2->edx = signature[2];", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = KVM_CPUID_FEATURES;", "VAR_2->eax = VAR_0->cpuid_kvm_features &\nkvm_arch_get_supported_cpuid(s, KVM_CPUID_FEATURES, 0, R_EAX);", "if (hyperv_enabled()) {", "memcpy(signature, \"Hv#1\\0\\0\\0\\0\\0\\0\\0\\0\", 12);", "VAR_2->eax = signature[0];", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = HYPERV_CPUID_VERSION;", "VAR_2->eax = 0x00001bbc;", "VAR_2->ebx = 0x00060001;", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = HYPERV_CPUID_FEATURES;", "if (hyperv_relaxed_timing_enabled()) {", "VAR_2->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE;", "}", "if (hyperv_vapic_recommended()) {", "VAR_2->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE;", "VAR_2->eax |= HV_X64_MSR_APIC_ACCESS_AVAILABLE;", "}", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = HYPERV_CPUID_ENLIGHTMENT_INFO;", "if (hyperv_relaxed_timing_enabled()) {", "VAR_2->eax |= HV_X64_RELAXED_TIMING_RECOMMENDED;", "}", "if (hyperv_vapic_recommended()) {", "VAR_2->eax |= HV_X64_APIC_ACCESS_RECOMMENDED;", "}", "VAR_2->ebx = hyperv_get_spinlock_retries();", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = HYPERV_CPUID_IMPLEMENT_LIMITS;", "VAR_2->eax = 0x40;", "VAR_2->ebx = 0x40;", "VAR_2 = &VAR_1.entries[cpuid_i++];", "memset(VAR_2, 0, sizeof(*VAR_2));", "VAR_2->function = KVM_CPUID_SIGNATURE_NEXT;", "memcpy(signature, \"KVMKVMKVM\\0\\0\\0\", 12);", "VAR_2->eax = 0;", "VAR_2->ebx = signature[0];", "VAR_2->ecx = signature[1];", "VAR_2->edx = signature[2];", "}", "has_msr_async_pf_en = VAR_2->eax & (1 << KVM_FEATURE_ASYNC_PF);", "has_msr_pv_eoi_en = VAR_2->eax & (1 << KVM_FEATURE_PV_EOI);", "cpu_x86_cpuid(VAR_0, 0, 0, &limit, &unused, &unused, &unused);", "for (i = 0; i <= limit; i++) {", "VAR_2 = &VAR_1.entries[cpuid_i++];", "switch (i) {", "case 2: {", "int times;", "VAR_2->function = i;", "VAR_2->flags = KVM_CPUID_FLAG_STATEFUL_FUNC |\nKVM_CPUID_FLAG_STATE_READ_NEXT;", "cpu_x86_cpuid(VAR_0, i, 0, &VAR_2->eax, &VAR_2->ebx, &VAR_2->ecx, &VAR_2->edx);", "times = VAR_2->eax & 0xff;", "for (j = 1; j < times; ++j) {", "VAR_2 = &VAR_1.entries[cpuid_i++];", "VAR_2->function = i;", "VAR_2->flags = KVM_CPUID_FLAG_STATEFUL_FUNC;", "cpu_x86_cpuid(VAR_0, i, 0, &VAR_2->eax, &VAR_2->ebx, &VAR_2->ecx, &VAR_2->edx);", "}", "break;", "}", "case 4:\ncase 0xb:\ncase 0xd:\nfor (j = 0; ; j++) {", "if (i == 0xd && j == 64) {", "break;", "}", "VAR_2->function = i;", "VAR_2->flags = KVM_CPUID_FLAG_SIGNIFCANT_INDEX;", "VAR_2->index = j;", "cpu_x86_cpuid(VAR_0, i, j, &VAR_2->eax, &VAR_2->ebx, &VAR_2->ecx, &VAR_2->edx);", "if (i == 4 && VAR_2->eax == 0) {", "break;", "}", "if (i == 0xb && !(VAR_2->ecx & 0xff00)) {", "break;", "}", "if (i == 0xd && VAR_2->eax == 0) {", "continue;", "}", "VAR_2 = &VAR_1.entries[cpuid_i++];", "}", "break;", "default:\nVAR_2->function = i;", "VAR_2->flags = 0;", "cpu_x86_cpuid(VAR_0, i, 0, &VAR_2->eax, &VAR_2->ebx, &VAR_2->ecx, &VAR_2->edx);", "break;", "}", "}", "cpu_x86_cpuid(VAR_0, 0x80000000, 0, &limit, &unused, &unused, &unused);", "for (i = 0x80000000; i <= limit; i++) {", "VAR_2 = &VAR_1.entries[cpuid_i++];", "VAR_2->function = i;", "VAR_2->flags = 0;", "cpu_x86_cpuid(VAR_0, i, 0, &VAR_2->eax, &VAR_2->ebx, &VAR_2->ecx, &VAR_2->edx);", "}", "if (VAR_0->cpuid_xlevel2 > 0) {", "VAR_0->cpuid_ext4_features &=\nkvm_arch_get_supported_cpuid(s, 0xC0000001, 0, R_EDX);", "cpu_x86_cpuid(VAR_0, 0xC0000000, 0, &limit, &unused, &unused, &unused);", "for (i = 0xC0000000; i <= limit; i++) {", "VAR_2 = &VAR_1.entries[cpuid_i++];", "VAR_2->function = i;", "VAR_2->flags = 0;", "cpu_x86_cpuid(VAR_0, i, 0, &VAR_2->eax, &VAR_2->ebx, &VAR_2->ecx, &VAR_2->edx);", "}", "}", "VAR_1.cpuid.nent = cpuid_i;", "if (((VAR_0->cpuid_version >> 8)&0xF) >= 6\n&& (VAR_0->cpuid_features&(CPUID_MCE|CPUID_MCA)) == (CPUID_MCE|CPUID_MCA)\n&& kvm_check_extension(VAR_0->kvm_state, KVM_CAP_MCE) > 0) {", "uint64_t mcg_cap;", "int VAR_4;", "int VAR_5;", "VAR_5 = kvm_get_mce_cap_supported(VAR_0->kvm_state, &mcg_cap, &VAR_4);", "if (VAR_5 < 0) {", "fprintf(stderr, \"kvm_get_mce_cap_supported: %s\", strerror(-VAR_5));", "return VAR_5;", "}", "if (VAR_4 > MCE_BANKS_DEF) {", "VAR_4 = MCE_BANKS_DEF;", "}", "mcg_cap &= MCE_CAP_DEF;", "mcg_cap |= VAR_4;", "VAR_5 = kvm_vcpu_ioctl(VAR_0, KVM_X86_SETUP_MCE, &mcg_cap);", "if (VAR_5 < 0) {", "fprintf(stderr, \"KVM_X86_SETUP_MCE: %s\", strerror(-VAR_5));", "return VAR_5;", "}", "VAR_0->mcg_cap = mcg_cap;", "}", "qemu_add_vm_change_state_handler(cpu_update_state, VAR_0);", "VAR_1.cpuid.padding = 0;", "VAR_3 = kvm_vcpu_ioctl(VAR_0, KVM_SET_CPUID2, &VAR_1);", "if (VAR_3) {", "return VAR_3;", "}", "VAR_3 = kvm_check_extension(VAR_0->kvm_state, KVM_CAP_TSC_CONTROL);", "if (VAR_3 && VAR_0->tsc_khz) {", "VAR_3 = kvm_vcpu_ioctl(VAR_0, KVM_SET_TSC_KHZ, VAR_0->tsc_khz);", "if (VAR_3 < 0) {", "fprintf(stderr, \"KVM_SET_TSC_KHZ failed\\n\");", "return VAR_3;", "}", "}", "if (kvm_has_xsave()) {", "VAR_0->kvm_xsave_buf = qemu_memalign(4096, sizeof(struct kvm_xsave));", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 45, 47 ], [ 49, 51 ], [ 53, 55 ], [ 59 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 205 ], [ 209 ], [ 213 ], [ 215 ], [ 219 ], [ 221 ], [ 225 ], [ 229 ], [ 231, 233 ], [ 235 ], [ 237 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257, 259, 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305, 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 323 ], [ 325 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 341 ], [ 343, 345 ], [ 347 ], [ 351 ], [ 353 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 369 ], [ 373, 375, 377 ], [ 379 ], [ 381 ], [ 383 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 421 ], [ 423 ], [ 427 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 461 ], [ 463 ], [ 465 ], [ 469 ], [ 471 ] ]

[ "void FUNC_0(const char *VAR_0, const char *VAR_1,\nError **VAR_2)\n{", "BlockdevSnapshot snapshot_data = {", ".VAR_0 = (char *) VAR_0,\n.VAR_1 = (char *) VAR_1\n};", "TransactionAction action = {", ".type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT,\n.u.blockdev_snapshot = &snapshot_data,\n};", "blockdev_do_action(&action, VAR_2);", "}" ]

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

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

[ "CPUX86State *FUNC_0(const char *cpu_model)\n{", "Error *error = NULL;", "X86CPU *cpu;", "cpu = cpu_x86_create(cpu_model, NULL, &error);", "if (error) {", "goto out;", "}", "object_property_set_bool(OBJECT(cpu), true, \"realized\", &error);", "out:\nif (error) {", "error_report(\"%s\", error_get_pretty(error));", "error_free(error);", "if (cpu != NULL) {", "object_unref(OBJECT(cpu));", "}", "return NULL;", "}", "return &cpu->env;", "}" ]

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

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

[ "static int FUNC_0(NBDClient *VAR_0, uint16_t VAR_1,\nError **VAR_2)\n{", "uint32_t flags;", "bool fixedNewstyle = false;", "bool no_zeroes = false;", "if (nbd_read(VAR_0->ioc, &flags, sizeof(flags), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "return -EIO;", "}", "be32_to_cpus(&flags);", "trace_nbd_negotiate_options_flags(flags);", "if (flags & NBD_FLAG_C_FIXED_NEWSTYLE) {", "fixedNewstyle = true;", "flags &= ~NBD_FLAG_C_FIXED_NEWSTYLE;", "}", "if (flags & NBD_FLAG_C_NO_ZEROES) {", "no_zeroes = true;", "flags &= ~NBD_FLAG_C_NO_ZEROES;", "}", "if (flags != 0) {", "error_setg(VAR_2, \"Unknown VAR_0 flags 0x%\" PRIx32 \" received\", flags);", "return -EINVAL;", "}", "while (1) {", "int VAR_3;", "uint32_t option, length;", "uint64_t magic;", "if (nbd_read(VAR_0->ioc, &magic, sizeof(magic), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "return -EINVAL;", "}", "magic = be64_to_cpu(magic);", "trace_nbd_negotiate_options_check_magic(magic);", "if (magic != NBD_OPTS_MAGIC) {", "error_setg(VAR_2, \"Bad magic received\");", "return -EINVAL;", "}", "if (nbd_read(VAR_0->ioc, &option,\nsizeof(option), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "return -EINVAL;", "}", "option = be32_to_cpu(option);", "if (nbd_read(VAR_0->ioc, &length, sizeof(length), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "return -EINVAL;", "}", "length = be32_to_cpu(length);", "trace_nbd_negotiate_options_check_option(option,\nnbd_opt_lookup(option));", "if (VAR_0->tlscreds &&\nVAR_0->ioc == (QIOChannel *)VAR_0->sioc) {", "QIOChannel *tioc;", "if (!fixedNewstyle) {", "error_setg(VAR_2, \"Unsupported option 0x%\" PRIx32, option);", "return -EINVAL;", "}", "switch (option) {", "case NBD_OPT_STARTTLS:\ntioc = nbd_negotiate_handle_starttls(VAR_0, length, VAR_2);", "if (!tioc) {", "return -EIO;", "}", "object_unref(OBJECT(VAR_0->ioc));", "VAR_0->ioc = QIO_CHANNEL(tioc);", "break;", "case NBD_OPT_EXPORT_NAME:\nerror_setg(VAR_2, \"Option 0x%x not permitted before TLS\",\noption);", "return -EINVAL;", "default:\nif (nbd_drop(VAR_0->ioc, length, VAR_2) < 0) {", "return -EIO;", "}", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_TLS_REQD,\noption, VAR_2,\n\"Option 0x%\" PRIx32\n\"not permitted before TLS\",\noption);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "if (option == NBD_OPT_ABORT) {", "return 1;", "}", "break;", "}", "} else if (fixedNewstyle) {", "switch (option) {", "case NBD_OPT_LIST:\nVAR_3 = nbd_negotiate_handle_list(VAR_0, length, VAR_2);", "if (VAR_3 < 0) {", "return VAR_3;", "}", "break;", "case NBD_OPT_ABORT:\nnbd_negotiate_send_rep(VAR_0->ioc, NBD_REP_ACK, option, NULL);", "return 1;", "case NBD_OPT_EXPORT_NAME:\nreturn nbd_negotiate_handle_export_name(VAR_0, length,\nVAR_1, no_zeroes,\nVAR_2);", "case NBD_OPT_INFO:\ncase NBD_OPT_GO:\nVAR_3 = nbd_negotiate_handle_info(VAR_0, length, option,\nVAR_1, VAR_2);", "if (VAR_3 == 1) {", "assert(option == NBD_OPT_GO);", "return 0;", "}", "if (VAR_3) {", "return VAR_3;", "}", "break;", "case NBD_OPT_STARTTLS:\nif (nbd_drop(VAR_0->ioc, length, VAR_2) < 0) {", "return -EIO;", "}", "if (VAR_0->tlscreds) {", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_INVALID,\noption, VAR_2,\n\"TLS already enabled\");", "} else {", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_POLICY,\noption, VAR_2,\n\"TLS not configured\");", "}", "if (VAR_3 < 0) {", "return VAR_3;", "}", "break;", "default:\nif (nbd_drop(VAR_0->ioc, length, VAR_2) < 0) {", "return -EIO;", "}", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_UNSUP,\noption, VAR_2,\n\"Unsupported option 0x%\"\nPRIx32 \" (%s)\", option,\nnbd_opt_lookup(option));", "if (VAR_3 < 0) {", "return VAR_3;", "}", "break;", "}", "} else {", "switch (option) {", "case NBD_OPT_EXPORT_NAME:\nreturn nbd_negotiate_handle_export_name(VAR_0, length,\nVAR_1, no_zeroes,\nVAR_2);", "default:\nerror_setg(VAR_2, \"Unsupported option 0x%\" PRIx32 \" (%s)\",\noption, nbd_opt_lookup(option));", "return -EINVAL;", "}", "}", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141, 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 179, 183, 185 ], [ 187 ], [ 191, 193 ], [ 195 ], [ 197 ], [ 199, 201, 203, 205, 207, 209 ], [ 211 ], [ 213 ], [ 215 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237, 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 251, 259 ], [ 261 ], [ 265, 267, 269, 271 ], [ 275, 277, 279, 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 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 ], [ 379 ], [ 381, 383, 385, 387 ], [ 391, 393, 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ] ]

[ "static void FUNC_0(int VAR_0, int VAR_1)\n{", "PRINT_LIB_INFO(avutil, AVUTIL, VAR_0, VAR_1);", "PRINT_LIB_INFO(avcodec, AVCODEC, VAR_0, VAR_1);", "PRINT_LIB_INFO(avformat, AVFORMAT, VAR_0, VAR_1);", "PRINT_LIB_INFO(avdevice, AVDEVICE, VAR_0, VAR_1);", "PRINT_LIB_INFO(avfilter, AVFILTER, VAR_0, VAR_1);", "PRINT_LIB_INFO(avresample, AVRESAMPLE, VAR_0, VAR_1);", "PRINT_LIB_INFO(swscale, SWSCALE, VAR_0, VAR_1);", "PRINT_LIB_INFO(swresample,SWRESAMPLE, VAR_0, VAR_1);", "#if CONFIG_POSTPROC\nPRINT_LIB_INFO(postproc, POSTPROC, VAR_0, VAR_1);", "#endif\n}" ]

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

[ "static uint32_t FUNC_0(SDState *sd, uint64_t addr)\n{", "uint32_t i, wpnum;", "uint32_t ret = 0;", "wpnum = addr >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);", "for (i = 0; i < 32; i ++, wpnum ++, addr += WPGROUP_SIZE)", "if (addr < sd->size && sd->wp_groups[wpnum])\nret |= (1 << i);", "return ret;", "}" ]

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

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

[ "static TileExcp FUNC_0(DisasContext *dc, tilegx_bundle_bits bundle)\n{", "unsigned VAR_0 = get_Opcode_X0(bundle);", "unsigned VAR_1 = get_Dest_X0(bundle);", "unsigned VAR_2 = get_SrcA_X0(bundle);", "unsigned VAR_3, VAR_4, VAR_5, VAR_6;", "int VAR_7;", "switch (VAR_0) {", "case RRR_0_OPCODE_X0:\nVAR_3 = get_RRROpcodeExtension_X0(bundle);", "if (VAR_3 == UNARY_RRR_0_OPCODE_X0) {", "VAR_3 = get_UnaryOpcodeExtension_X0(bundle);", "return gen_rr_opcode(dc, OE(VAR_0, VAR_3, X0), VAR_1, VAR_2);", "}", "VAR_4 = get_SrcB_X0(bundle);", "return gen_rrr_opcode(dc, OE(VAR_0, VAR_3, X0), VAR_1, VAR_2, VAR_4);", "case SHIFT_OPCODE_X0:\nVAR_3 = get_ShiftOpcodeExtension_X0(bundle);", "VAR_7 = get_ShAmt_X0(bundle);", "return gen_rri_opcode(dc, OE(VAR_0, VAR_3, X0), VAR_1, VAR_2, VAR_7);", "case IMM8_OPCODE_X0:\nVAR_3 = get_Imm8OpcodeExtension_X0(bundle);", "VAR_7 = (int8_t)get_Imm8_X0(bundle);", "return gen_rri_opcode(dc, OE(VAR_0, VAR_3, X0), VAR_1, VAR_2, VAR_7);", "case BF_OPCODE_X0:\nVAR_3 = get_BFOpcodeExtension_X0(bundle);", "VAR_5 = get_BFStart_X0(bundle);", "VAR_6 = get_BFEnd_X0(bundle);", "return gen_bf_opcode_x0(dc, VAR_3, VAR_1, VAR_2, VAR_5, VAR_6);", "case ADDLI_OPCODE_X0:\ncase SHL16INSLI_OPCODE_X0:\ncase ADDXLI_OPCODE_X0:\nVAR_7 = (int16_t)get_Imm16_X0(bundle);", "return gen_rri_opcode(dc, OE(VAR_0, 0, X0), VAR_1, VAR_2, VAR_7);", "default:\nreturn TILEGX_EXCP_OPCODE_UNIMPLEMENTED;", "}", "}" ]

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

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

[ "static int FUNC_0(int VAR_0, char **VAR_1)\n{", "int64_t offset;", "int VAR_2, VAR_3;", "char VAR_4[64];", "int VAR_5, VAR_6;", "int VAR_7;", "offset = cvtnum(VAR_1[1]);", "if (offset & 0x1ff) {", "printf(\"offset %\" PRId64 \" is not sector aligned\\n\",\noffset);", "return 0;", "}", "if (VAR_0 == 3) {", "VAR_2 = cvtnum(VAR_1[2]);", "} else {", "VAR_2 = 1;", "}", "VAR_3 = VAR_2;", "VAR_6 = 0;", "while (VAR_3) {", "VAR_7 = bdrv_is_allocated(bs, offset >> 9, VAR_2, &VAR_5);", "VAR_3 -= VAR_5;", "if (VAR_7) {", "VAR_6 += VAR_5;", "}", "}", "cvtstr(offset, VAR_4, sizeof(VAR_4));", "printf(\"%d/%d sectors allocated at offset %s\\n\",\nVAR_6, VAR_2, VAR_4);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(SCSIDiskReq *VAR_0, int VAR_1)\n{", "assert(VAR_0->req.aiocb == NULL);", "if (VAR_0->req.io_canceled) {", "scsi_req_cancel_complete(&VAR_0->req);", "goto done;", "}", "if (VAR_1 < 0) {", "if (scsi_handle_rw_error(VAR_0, -VAR_1, false)) {", "goto done;", "}", "}", "VAR_0->sector += VAR_0->sector_count;", "VAR_0->sector_count = 0;", "if (VAR_0->req.cmd.mode == SCSI_XFER_TO_DEV) {", "scsi_write_do_fua(VAR_0);", "return;", "} else {", "scsi_req_complete(&VAR_0->req, GOOD);", "}", "done:\nscsi_req_unref(&VAR_0->req);", "}" ]

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

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "USBDeviceClass *uc = USB_DEVICE_CLASS(VAR_0);", "uc->init = usb_keyboard_initfn;", "uc->product_desc = \"QEMU USB Keyboard\";", "uc->usb_desc = &desc_keyboard;", "uc->handle_packet = usb_generic_handle_packet;", "uc->handle_reset = usb_hid_handle_reset;", "uc->handle_control = usb_hid_handle_control;", "uc->handle_data = usb_hid_handle_data;", "uc->handle_destroy = usb_hid_handle_destroy;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "struct omap_sti_s *VAR_3 = (struct omap_sti_s *) VAR_0;", "int VAR_4 = VAR_1 - VAR_3->channel_base;", "int VAR_5 = VAR_4 >> 6;", "uint8_t byte = VAR_2;", "if (VAR_5 == STI_TRACE_CONTROL_CHANNEL) {", "qemu_chr_write(VAR_3->chr, \"\\r\", 1);", "} else if (VAR_5 == STI_TRACE_CONSOLE_CHANNEL || 1) {", "if (VAR_2 == 0xc0 || VAR_2 == 0xc3) {", "} else if (VAR_2 == 0x00)", "qemu_chr_write(VAR_3->chr, \"\\n\", 1);", "else\nqemu_chr_write(VAR_3->chr, &byte, 1);", "}", "}" ]

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

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

[ "static void FUNC_0(TCGContext *VAR_0, TCGType VAR_1, TCGReg VAR_2, uint64_t VAR_3)\n{", "static const S390Opcode VAR_4[4] = {", "RI_NILL, RI_NILH, RI_NIHL, RI_NIHH\n};", "static const S390Opcode VAR_5[2] = {", "RIL_NILF, RIL_NIHF\n};", "uint64_t valid = (VAR_1 == TCG_TYPE_I32 ? 0xffffffffull : -1ull);", "int VAR_6;", "if ((VAR_3 & valid) == 0xffffffff) {", "tgen_ext32u(VAR_0, VAR_2, VAR_2);", "return;", "}", "if (facilities & FACILITY_EXT_IMM) {", "if ((VAR_3 & valid) == 0xff) {", "tgen_ext8u(VAR_0, TCG_TYPE_I64, VAR_2, VAR_2);", "return;", "}", "if ((VAR_3 & valid) == 0xffff) {", "tgen_ext16u(VAR_0, TCG_TYPE_I64, VAR_2, VAR_2);", "return;", "}", "}", "for (VAR_6 = 0; VAR_6 < 4; VAR_6++) {", "tcg_target_ulong mask = ~(0xffffull << VAR_6*16);", "if (((VAR_3 | ~valid) & mask) == mask) {", "tcg_out_insn_RI(VAR_0, VAR_4[VAR_6], VAR_2, VAR_3 >> VAR_6*16);", "return;", "}", "}", "if (facilities & FACILITY_EXT_IMM) {", "for (VAR_6 = 0; VAR_6 < 2; VAR_6++) {", "tcg_target_ulong mask = ~(0xffffffffull << VAR_6*32);", "if (((VAR_3 | ~valid) & mask) == mask) {", "tcg_out_insn_RIL(VAR_0, VAR_5[VAR_6], VAR_2, VAR_3 >> VAR_6*32);", "return;", "}", "}", "}", "if ((facilities & FACILITY_GEN_INST_EXT) && risbg_mask(VAR_3)) {", "tgen_andi_risbg(VAR_0, VAR_2, VAR_2, VAR_3);", "return;", "}", "tcg_out_movi(VAR_0, VAR_1, TCG_TMP0, VAR_3);", "if (VAR_1 == TCG_TYPE_I32) {", "tcg_out_insn(VAR_0, RR, NR, VAR_2, TCG_TMP0);", "} else {", "tcg_out_insn(VAR_0, RRE, NGR, VAR_2, TCG_TMP0);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ] ]

[ "static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{", "int VAR_2;", "NANDFlashState *s = NAND(VAR_0);", "s->buswidth = nand_flash_ids[s->chip_id].width >> 3;", "s->size = nand_flash_ids[s->chip_id].size << 20;", "if (nand_flash_ids[s->chip_id].options & NAND_SAMSUNG_LP) {", "s->page_shift = 11;", "s->erase_shift = 6;", "} else {", "s->page_shift = nand_flash_ids[s->chip_id].page_shift;", "s->erase_shift = nand_flash_ids[s->chip_id].erase_shift;", "}", "switch (1 << s->page_shift) {", "case 256:\nnand_init_256(s);", "break;", "case 512:\nnand_init_512(s);", "break;", "case 2048:\nnand_init_2048(s);", "break;", "default:\nerror_setg(VAR_1, \"Unsupported NAND block size %#x\\n\",\n1 << s->page_shift);", "return;", "}", "VAR_2 = 1 << s->oob_shift;", "s->mem_oob = 1;", "if (s->bdrv) {", "if (bdrv_is_read_only(s->bdrv)) {", "error_setg(VAR_1, \"Can't use a read-only drive\");", "return;", "}", "if (bdrv_getlength(s->bdrv) >=\n(s->pages << s->page_shift) + (s->pages << s->oob_shift)) {", "VAR_2 = 0;", "s->mem_oob = 0;", "}", "} else {", "VAR_2 += 1 << s->page_shift;", "}", "if (VAR_2) {", "s->storage = (uint8_t *) memset(g_malloc(s->pages * VAR_2),\n0xff, s->pages * VAR_2);", "}", "s->ioaddr = s->io;", "}" ]

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

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

[ "static inline void FUNC_0(ARMCPU *VAR_0,\nTranslationBlock *VAR_1,\nbool VAR_2)\n{", "CPUState *cs = CPU(VAR_0);", "CPUARMState *env = &VAR_0->env;", "DisasContext dc1, *dc = &dc1;", "CPUBreakpoint *bp;", "int VAR_3, VAR_4;", "target_ulong pc_start;", "target_ulong next_page_start;", "int VAR_5;", "int VAR_6;", "if (ARM_TBFLAG_AARCH64_STATE(VAR_1->flags)) {", "gen_intermediate_code_internal_a64(VAR_0, VAR_1, VAR_2);", "return;", "}", "pc_start = VAR_1->pc;", "dc->VAR_1 = VAR_1;", "dc->is_jmp = DISAS_NEXT;", "dc->pc = pc_start;", "dc->singlestep_enabled = cs->singlestep_enabled;", "dc->condjmp = 0;", "dc->aarch64 = 0;", "dc->el3_is_aa64 = arm_el_is_aa64(env, 3);", "dc->thumb = ARM_TBFLAG_THUMB(VAR_1->flags);", "dc->bswap_code = ARM_TBFLAG_BSWAP_CODE(VAR_1->flags);", "dc->condexec_mask = (ARM_TBFLAG_CONDEXEC(VAR_1->flags) & 0xf) << 1;", "dc->condexec_cond = ARM_TBFLAG_CONDEXEC(VAR_1->flags) >> 4;", "dc->mmu_idx = ARM_TBFLAG_MMUIDX(VAR_1->flags);", "dc->current_el = arm_mmu_idx_to_el(dc->mmu_idx);", "#if !defined(CONFIG_USER_ONLY)\ndc->user = (dc->current_el == 0);", "#endif\ndc->ns = ARM_TBFLAG_NS(VAR_1->flags);", "dc->cpacr_fpen = ARM_TBFLAG_CPACR_FPEN(VAR_1->flags);", "dc->vfp_enabled = ARM_TBFLAG_VFPEN(VAR_1->flags);", "dc->vec_len = ARM_TBFLAG_VECLEN(VAR_1->flags);", "dc->vec_stride = ARM_TBFLAG_VECSTRIDE(VAR_1->flags);", "dc->c15_cpar = ARM_TBFLAG_XSCALE_CPAR(VAR_1->flags);", "dc->cp_regs = VAR_0->cp_regs;", "dc->features = env->features;", "dc->ss_active = ARM_TBFLAG_SS_ACTIVE(VAR_1->flags);", "dc->pstate_ss = ARM_TBFLAG_PSTATE_SS(VAR_1->flags);", "dc->is_ldex = false;", "dc->ss_same_el = false;", "cpu_F0s = tcg_temp_new_i32();", "cpu_F1s = tcg_temp_new_i32();", "cpu_F0d = tcg_temp_new_i64();", "cpu_F1d = tcg_temp_new_i64();", "cpu_V0 = cpu_F0d;", "cpu_V1 = cpu_F1d;", "cpu_M0 = tcg_temp_new_i64();", "next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;", "VAR_4 = -1;", "VAR_5 = 0;", "VAR_6 = VAR_1->cflags & CF_COUNT_MASK;", "if (VAR_6 == 0)\nVAR_6 = CF_COUNT_MASK;", "gen_tb_start(VAR_1);", "tcg_clear_temp_count();", "if (dc->condexec_mask || dc->condexec_cond)\n{", "TCGv_i32 tmp = tcg_temp_new_i32();", "tcg_gen_movi_i32(tmp, 0);", "store_cpu_field(tmp, condexec_bits);", "}", "do {", "#ifdef CONFIG_USER_ONLY\nif (dc->pc >= 0xffff0000) {", "gen_exception_internal(EXCP_KERNEL_TRAP);", "dc->is_jmp = DISAS_UPDATE;", "break;", "}", "#else\nif (dc->pc >= 0xfffffff0 && arm_dc_feature(dc, ARM_FEATURE_M)) {", "gen_exception_internal(EXCP_EXCEPTION_EXIT);", "dc->is_jmp = DISAS_UPDATE;", "break;", "}", "#endif\nif (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) {", "QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {", "if (bp->pc == dc->pc) {", "gen_exception_internal_insn(dc, 0, EXCP_DEBUG);", "dc->pc += 2;", "goto done_generating;", "}", "}", "}", "if (VAR_2) {", "VAR_3 = tcg_op_buf_count();", "if (VAR_4 < VAR_3) {", "VAR_4++;", "while (VAR_4 < VAR_3)\ntcg_ctx.gen_opc_instr_start[VAR_4++] = 0;", "}", "tcg_ctx.gen_opc_pc[VAR_4] = dc->pc;", "gen_opc_condexec_bits[VAR_4] = (dc->condexec_cond << 4) | (dc->condexec_mask >> 1);", "tcg_ctx.gen_opc_instr_start[VAR_4] = 1;", "tcg_ctx.gen_opc_icount[VAR_4] = VAR_5;", "}", "if (VAR_5 + 1 == VAR_6 && (VAR_1->cflags & CF_LAST_IO))\ngen_io_start();", "if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {", "tcg_gen_debug_insn_start(dc->pc);", "}", "if (dc->ss_active && !dc->pstate_ss) {", "assert(VAR_5 == 0);", "gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0),\ndefault_exception_el(dc));", "goto done_generating;", "}", "if (dc->thumb) {", "disas_thumb_insn(env, dc);", "if (dc->condexec_mask) {", "dc->condexec_cond = (dc->condexec_cond & 0xe)\n| ((dc->condexec_mask >> 4) & 1);", "dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f;", "if (dc->condexec_mask == 0) {", "dc->condexec_cond = 0;", "}", "}", "} else {", "unsigned int VAR_7 = arm_ldl_code(env, dc->pc, dc->bswap_code);", "dc->pc += 4;", "disas_arm_insn(dc, VAR_7);", "}", "if (dc->condjmp && !dc->is_jmp) {", "gen_set_label(dc->condlabel);", "dc->condjmp = 0;", "}", "if (tcg_check_temp_count()) {", "fprintf(stderr, \"TCG temporary leak before \"TARGET_FMT_lx\"\\n\",\ndc->pc);", "}", "VAR_5 ++;", "} while (!dc->is_jmp && !tcg_op_buf_full() &&", "!cs->singlestep_enabled &&\n!singlestep &&\n!dc->ss_active &&\ndc->pc < next_page_start &&\nVAR_5 < VAR_6);", "if (VAR_1->cflags & CF_LAST_IO) {", "if (dc->condjmp) {", "cpu_abort(cs, \"IO on conditional branch instruction\");", "}", "gen_io_end();", "}", "if (unlikely(cs->singlestep_enabled || dc->ss_active)) {", "if (dc->condjmp) {", "gen_set_condexec(dc);", "if (dc->is_jmp == DISAS_SWI) {", "gen_ss_advance(dc);", "gen_exception(EXCP_SWI, syn_aa32_svc(dc->svc_imm, dc->thumb),\ndefault_exception_el(dc));", "} else if (dc->is_jmp == DISAS_HVC) {", "gen_ss_advance(dc);", "gen_exception(EXCP_HVC, syn_aa32_hvc(dc->svc_imm), 2);", "} else if (dc->is_jmp == DISAS_SMC) {", "gen_ss_advance(dc);", "gen_exception(EXCP_SMC, syn_aa32_smc(), 3);", "} else if (dc->ss_active) {", "gen_step_complete_exception(dc);", "} else {", "gen_exception_internal(EXCP_DEBUG);", "}", "gen_set_label(dc->condlabel);", "}", "if (dc->condjmp || !dc->is_jmp) {", "gen_set_pc_im(dc, dc->pc);", "dc->condjmp = 0;", "}", "gen_set_condexec(dc);", "if (dc->is_jmp == DISAS_SWI && !dc->condjmp) {", "gen_ss_advance(dc);", "gen_exception(EXCP_SWI, syn_aa32_svc(dc->svc_imm, dc->thumb),\ndefault_exception_el(dc));", "} else if (dc->is_jmp == DISAS_HVC && !dc->condjmp) {", "gen_ss_advance(dc);", "gen_exception(EXCP_HVC, syn_aa32_hvc(dc->svc_imm), 2);", "} else if (dc->is_jmp == DISAS_SMC && !dc->condjmp) {", "gen_ss_advance(dc);", "gen_exception(EXCP_SMC, syn_aa32_smc(), 3);", "} else if (dc->ss_active) {", "gen_step_complete_exception(dc);", "} else {", "gen_exception_internal(EXCP_DEBUG);", "}", "} else {", "gen_set_condexec(dc);", "switch(dc->is_jmp) {", "case DISAS_NEXT:\ngen_goto_tb(dc, 1, dc->pc);", "break;", "default:\ncase DISAS_JUMP:\ncase DISAS_UPDATE:\ntcg_gen_exit_tb(0);", "break;", "case DISAS_TB_JUMP:\nbreak;", "case DISAS_WFI:\ngen_helper_wfi(cpu_env);", "break;", "case DISAS_WFE:\ngen_helper_wfe(cpu_env);", "break;", "case DISAS_SWI:\ngen_exception(EXCP_SWI, syn_aa32_svc(dc->svc_imm, dc->thumb),\ndefault_exception_el(dc));", "break;", "case DISAS_HVC:\ngen_exception(EXCP_HVC, syn_aa32_hvc(dc->svc_imm), 2);", "break;", "case DISAS_SMC:\ngen_exception(EXCP_SMC, syn_aa32_smc(), 3);", "break;", "}", "if (dc->condjmp) {", "gen_set_label(dc->condlabel);", "gen_set_condexec(dc);", "gen_goto_tb(dc, 1, dc->pc);", "dc->condjmp = 0;", "}", "}", "done_generating:\ngen_tb_end(VAR_1, VAR_5);", "#ifdef DEBUG_DISAS\nif (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {", "qemu_log(\"----------------\\n\");", "qemu_log(\"IN: %s\\n\", lookup_symbol(pc_start));", "log_target_disas(env, pc_start, dc->pc - pc_start,\ndc->thumb | (dc->bswap_code << 1));", "qemu_log(\"\\n\");", "}", "#endif\nif (VAR_2) {", "VAR_3 = tcg_op_buf_count();", "VAR_4++;", "while (VAR_4 <= VAR_3)\ntcg_ctx.gen_opc_instr_start[VAR_4++] = 0;", "} else {", "VAR_1->size = dc->pc - pc_start;", "VAR_1->icount = VAR_5;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171, 173 ], [ 177 ], [ 181 ], [ 251, 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265, 269 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283, 285 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299, 303 ], [ 305 ], [ 307 ], [ 309 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333, 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 351, 353 ], [ 357 ], [ 359 ], [ 361 ], [ 365 ], [ 387 ], [ 389, 391 ], [ 393 ], [ 395 ], [ 399 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 441 ], [ 443, 445 ], [ 447 ], [ 459 ], [ 461 ], [ 463, 465, 467, 469, 471 ], [ 475 ], [ 477 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 499 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 511, 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539 ], [ 541 ], [ 543 ], [ 545 ], [ 547 ], [ 549 ], [ 551 ], [ 553 ], [ 555, 557 ], [ 559 ], [ 561 ], [ 563 ], [ 565 ], [ 567 ], [ 569 ], [ 571 ], [ 573 ], [ 575 ], [ 581 ], [ 583 ], [ 585 ], [ 603 ], [ 605 ], [ 607, 609 ], [ 611 ], [ 613, 615, 617, 621 ], [ 623 ], [ 625, 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 ], [ 681, 683 ], [ 687, 689 ], [ 691 ], [ 693 ], [ 695, 697 ], [ 699 ], [ 701 ], [ 703, 705 ], [ 707 ], [ 709 ], [ 711, 713 ], [ 715 ], [ 717 ], [ 719 ], [ 721 ], [ 723 ] ]

[ "av_cold int FUNC_0(AVCodecContext *avctx)\n{", "MpegEncContext *s = avctx->priv_data;", "static int VAR_0 = 0;", "int VAR_1;", "MVTable *mv;", "ff_h263_decode_init(avctx);", "common_init(s);", "if (!VAR_0) {", "VAR_0 = 1;", "for(VAR_1=0;VAR_1<NB_RL_TABLES;VAR_1++) {", "init_rl(&rl_table[VAR_1], static_rl_table_store[VAR_1]);", "}", "INIT_VLC_RL(rl_table[0], 642);", "INIT_VLC_RL(rl_table[1], 1104);", "INIT_VLC_RL(rl_table[2], 554);", "INIT_VLC_RL(rl_table[3], 940);", "INIT_VLC_RL(rl_table[4], 962);", "INIT_VLC_RL(rl_table[5], 554);", "mv = &mv_tables[0];", "INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,\nmv->table_mv_bits, 1, 1,\nmv->table_mv_code, 2, 2, 3714);", "mv = &mv_tables[1];", "INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,\nmv->table_mv_bits, 1, 1,\nmv->table_mv_code, 2, 2, 2694);", "INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,\n&ff_table0_dc_lum[0][1], 8, 4,\n&ff_table0_dc_lum[0][0], 8, 4, 1158);", "INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,\n&ff_table0_dc_chroma[0][1], 8, 4,\n&ff_table0_dc_chroma[0][0], 8, 4, 1118);", "INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,\n&ff_table1_dc_lum[0][1], 8, 4,\n&ff_table1_dc_lum[0][0], 8, 4, 1476);", "INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,\n&ff_table1_dc_chroma[0][1], 8, 4,\n&ff_table1_dc_chroma[0][0], 8, 4, 1216);", "INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,\n&v2_dc_lum_table[0][1], 8, 4,\n&v2_dc_lum_table[0][0], 8, 4, 1472);", "INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,\n&v2_dc_chroma_table[0][1], 8, 4,\n&v2_dc_chroma_table[0][0], 8, 4, 1506);", "INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,\n&v2_intra_cbpc[0][1], 2, 1,\n&v2_intra_cbpc[0][0], 2, 1, 8);", "INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,\n&v2_mb_type[0][1], 2, 1,\n&v2_mb_type[0][0], 2, 1, 128);", "INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,\n&mvtab[0][1], 2, 1,\n&mvtab[0][0], 2, 1, 538);", "INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,\n&wmv2_inter_table[0][0][1], 8, 4,\n&wmv2_inter_table[0][0][0], 8, 4, 1636);", "INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,\n&wmv2_inter_table[1][0][1], 8, 4,\n&wmv2_inter_table[1][0][0], 8, 4, 2648);", "INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,\n&wmv2_inter_table[2][0][1], 8, 4,\n&wmv2_inter_table[2][0][0], 8, 4, 1532);", "INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,\n&wmv2_inter_table[3][0][1], 8, 4,\n&wmv2_inter_table[3][0][0], 8, 4, 2488);", "INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,\n&ff_msmp4_mb_i_table[0][1], 4, 2,\n&ff_msmp4_mb_i_table[0][0], 4, 2, 536);", "INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,\n&table_inter_intra[0][1], 2, 1,\n&table_inter_intra[0][0], 2, 1, 8);", "}", "switch(s->msmpeg4_version){", "case 1:\ncase 2:\ns->decode_mb= msmpeg4v12_decode_mb;", "break;", "case 3:\ncase 4:\ns->decode_mb= msmpeg4v34_decode_mb;", "break;", "case 5:\nif (CONFIG_WMV2_DECODER)\ns->decode_mb= ff_wmv2_decode_mb;", "case 6:\nbreak;", "}", "s->slice_height= s->mb_height;", "return 0;", "}" ]

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

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

[ "PCIBus *FUNC_0(uint32_t base, qemu_irq *pic,\nMemoryRegion *address_space_mem,\nMemoryRegion *address_space_io)\n{", "DeviceState *dev;", "SysBusDevice *s;", "PCIHostState *phb;", "GrackleState *d;", "dev = qdev_create(NULL, TYPE_GRACKLE_PCI_HOST_BRIDGE);", "qdev_init_nofail(dev);", "s = SYS_BUS_DEVICE(dev);", "phb = PCI_HOST_BRIDGE(dev);", "d = GRACKLE_PCI_HOST_BRIDGE(dev);", "memory_region_init(&d->pci_mmio, OBJECT(s), \"pci-mmio\", 0x100000000ULL);", "memory_region_init_alias(&d->pci_hole, OBJECT(s), \"pci-hole\", &d->pci_mmio,\n0x80000000ULL, 0x7e000000ULL);", "memory_region_add_subregion(address_space_mem, 0x80000000ULL,\n&d->pci_hole);", "phb->bus = pci_register_bus(dev, \"pci\",\npci_grackle_set_irq,\npci_grackle_map_irq,\npic,\n&d->pci_mmio,\naddress_space_io,\n0, 4, TYPE_PCI_BUS);", "pci_create_simple(phb->bus, 0, \"grackle\");", "sysbus_mmio_map(s, 0, base);", "sysbus_mmio_map(s, 1, base + 0x00200000);", "return phb->bus;", "}" ]

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

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

[ "CPUAlphaState * FUNC_0 (const char *cpu_model)\n{", "CPUAlphaState *env;", "int VAR_0, VAR_1, VAR_2, VAR_3;", "env = qemu_mallocz(sizeof(CPUAlphaState));", "cpu_exec_init(env);", "alpha_translate_init();", "tlb_flush(env, 1);", "VAR_0 = IMPLVER_21264;", "VAR_1 = (AMASK_BWX | AMASK_FIX | AMASK_CIX | AMASK_MVI\n| AMASK_TRAP | AMASK_PREFETCH);", "VAR_3 = ARRAY_SIZE(cpu_defs);", "for (VAR_2 = 0; VAR_2 < VAR_3; VAR_2++) {", "if (strcmp (cpu_model, cpu_defs[VAR_2].name) == 0) {", "VAR_0 = cpu_defs[VAR_2].VAR_0;", "VAR_1 = cpu_defs[VAR_2].VAR_1;", "break;", "}", "}", "env->VAR_0 = VAR_0;", "env->VAR_1 = VAR_1;", "env->ps = 0x1F00;", "#if defined (CONFIG_USER_ONLY)\nenv->ps |= 1 << 3;", "cpu_alpha_store_fpcr(env, (FPCR_INVD | FPCR_DZED | FPCR_OVFD\n| FPCR_UNFD | FPCR_INED | FPCR_DNOD));", "#endif\npal_init(env);", "#if defined (CONFIG_USER_ONLY)\nenv->ipr[IPR_EXC_ADDR] = 0;", "env->ipr[IPR_EXC_SUM] = 0;", "env->ipr[IPR_EXC_MASK] = 0;", "#else\n{", "uint64_t hwpcb;", "hwpcb = env->ipr[IPR_PCBB];", "env->ipr[IPR_ASN] = 0;", "env->ipr[IPR_ASTEN] = 0;", "env->ipr[IPR_ASTSR] = 0;", "env->ipr[IPR_DATFX] = 0;", "env->ipr[IPR_FEN] = 0;", "env->ipr[IPR_IPL] = 31;", "env->ipr[IPR_MCES] = 0;", "env->ipr[IPR_PERFMON] = 0;", "env->ipr[IPR_SISR] = 0;", "env->ipr[IPR_VIRBND] = -1ULL;", "}", "#endif\nqemu_init_vcpu(env);", "return env;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55, 57 ], [ 59, 61 ], [ 63, 65 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 125 ], [ 127 ], [ 129 ] ]

[ "static int FUNC_0(const OptionGroupDef *VAR_0, const char *VAR_1)\n{", "const OptionGroupDef *VAR_2 = VAR_0;", "while (VAR_2->name) {", "if (VAR_2->sep && !strcmp(VAR_2->sep, VAR_1))\nreturn VAR_2 - VAR_0;", "VAR_2++;", "}", "return -1;", "}" ]

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

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

[ "static void FUNC_0(AVFilterContext *VAR_0)\n{", "LifeContext *life = VAR_0->priv;", "int VAR_1, VAR_2;", "uint8_t *oldbuf = life->buf[ life->buf_idx];", "uint8_t *newbuf = life->buf[!life->buf_idx];", "enum { NW, N, NE, W, E, SW, S, SE };", "for (VAR_1 = 0; VAR_1 < life->h; VAR_1++) {", "for (VAR_2 = 0; VAR_2 < life->w; VAR_2++) {", "int pos[8][2], n, alive, cell;", "if (life->stitch) {", "pos[NW][0] = (VAR_1-1) < 0 ? life->h-1 : VAR_1-1; pos[NW][1] = (VAR_2-1) < 0 ? life->w-1 : VAR_2-1;", "pos[N ][0] = (VAR_1-1) < 0 ? life->h-1 : VAR_1-1; pos[N ][1] = VAR_2 ;", "pos[NE][0] = (VAR_1-1) < 0 ? life->h-1 : VAR_1-1; pos[NE][1] = (VAR_2+1) == life->w ? 0 : VAR_2+1;", "pos[W ][0] = VAR_1 ; pos[W ][1] = (VAR_2-1) < 0 ? life->w-1 : VAR_2-1;", "pos[E ][0] = VAR_1 ; pos[E ][1] = (VAR_2+1) == life->w ? 0 : VAR_2+1;", "pos[SW][0] = (VAR_1+1) == life->h ? 0 : VAR_1+1; pos[SW][1] = (VAR_2-1) < 0 ? life->w-1 : VAR_2-1;", "pos[S ][0] = (VAR_1+1) == life->h ? 0 : VAR_1+1; pos[S ][1] = VAR_2 ;", "pos[SE][0] = (VAR_1+1) == life->h ? 0 : VAR_1+1; pos[SE][1] = (VAR_2+1) == life->w ? 0 : VAR_2+1;", "} else {", "pos[NW][0] = (VAR_1-1) < 0 ? -1 : VAR_1-1; pos[NW][1] = (VAR_2-1) < 0 ? -1 : VAR_2-1;", "pos[N ][0] = (VAR_1-1) < 0 ? -1 : VAR_1-1; pos[N ][1] = VAR_2 ;", "pos[NE][0] = (VAR_1-1) < 0 ? -1 : VAR_1-1; pos[NE][1] = (VAR_2+1) == life->w ? -1 : VAR_2+1;", "pos[W ][0] = VAR_1 ; pos[W ][1] = (VAR_2-1) < 0 ? -1 : VAR_2-1;", "pos[E ][0] = VAR_1 ; pos[E ][1] = (VAR_2+1) == life->w ? -1 : VAR_2+1;", "pos[SW][0] = (VAR_1+1) == life->h ? -1 : VAR_1+1; pos[SW][1] = (VAR_2-1) < 0 ? -1 : VAR_2-1;", "pos[S ][0] = (VAR_1+1) == life->h ? -1 : VAR_1+1; pos[S ][1] = VAR_2 ;", "pos[SE][0] = (VAR_1+1) == life->h ? -1 : VAR_1+1; pos[SE][1] = (VAR_2+1) == life->w ? -1 : VAR_2+1;", "}", "n = (pos[NW][0] == -1 || pos[NW][1] == -1 ? 0 : oldbuf[pos[NW][0]*life->w + pos[NW][1]] == ALIVE_CELL) +\n(pos[N ][0] == -1 || pos[N ][1] == -1 ? 0 : oldbuf[pos[N ][0]*life->w + pos[N ][1]] == ALIVE_CELL) +\n(pos[NE][0] == -1 || pos[NE][1] == -1 ? 0 : oldbuf[pos[NE][0]*life->w + pos[NE][1]] == ALIVE_CELL) +\n(pos[W ][0] == -1 || pos[W ][1] == -1 ? 0 : oldbuf[pos[W ][0]*life->w + pos[W ][1]] == ALIVE_CELL) +\n(pos[E ][0] == -1 || pos[E ][1] == -1 ? 0 : oldbuf[pos[E ][0]*life->w + pos[E ][1]] == ALIVE_CELL) +\n(pos[SW][0] == -1 || pos[SW][1] == -1 ? 0 : oldbuf[pos[SW][0]*life->w + pos[SW][1]] == ALIVE_CELL) +\n(pos[S ][0] == -1 || pos[S ][1] == -1 ? 0 : oldbuf[pos[S ][0]*life->w + pos[S ][1]] == ALIVE_CELL) +\n(pos[SE][0] == -1 || pos[SE][1] == -1 ? 0 : oldbuf[pos[SE][0]*life->w + pos[SE][1]] == ALIVE_CELL);", "cell = oldbuf[VAR_1*life->w + VAR_2];", "alive = 1<<n & (cell == ALIVE_CELL ? life->stay_rule : life->born_rule);", "if (alive) *newbuf = ALIVE_CELL;", "else if (cell) *newbuf = cell - 1;", "else *newbuf = 0;", "av_dlog(VAR_0, \"VAR_1:%d VAR_2:%d live_neighbors:%d cell:%d -> cell:%d\\n\", VAR_1, VAR_2, n, cell, *newbuf);", "newbuf++;", "}", "}", "life->buf_idx = !life->buf_idx;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 69, 71, 73, 75, 77, 79, 81, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ] ]

[ "void FUNC_0(const char *VAR_0, struct DisplaySurface *VAR_1, Error **VAR_2)\n{", "int VAR_3 = pixman_image_get_width(VAR_1->image);", "int VAR_4 = pixman_image_get_height(VAR_1->image);", "FILE *f;", "int VAR_5;", "int VAR_6;", "pixman_image_t *linebuf;", "trace_ppm_save(VAR_0, VAR_1);", "f = fopen(VAR_0, \"wb\");", "if (!f) {", "error_setg(VAR_2, \"failed to open file '%s': %s\", VAR_0,\nstrerror(errno));", "return;", "}", "VAR_6 = fprintf(f, \"P6\\n%d %d\\n%d\\n\", VAR_3, VAR_4, 255);", "if (VAR_6 < 0) {", "linebuf = NULL;", "goto write_err;", "}", "linebuf = qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, VAR_3);", "for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {", "qemu_pixman_linebuf_fill(linebuf, VAR_1->image, VAR_3, 0, VAR_5);", "clearerr(f);", "VAR_6 = fwrite(pixman_image_get_data(linebuf), 1,\npixman_image_get_stride(linebuf), f);", "(void)VAR_6;", "if (ferror(f)) {", "goto write_err;", "}", "}", "out:\nqemu_pixman_image_unref(linebuf);", "fclose(f);", "return;", "write_err:\nerror_setg(VAR_2, \"failed to write to file '%s': %s\", VAR_0,\nstrerror(errno));", "unlink(VAR_0);", "goto out;", "}" ]

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

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

[ "static TranslationBlock *FUNC_0(CPUState *cpu,\ntarget_ulong pc,\ntarget_ulong cs_base,\nuint32_t flags)\n{", "CPUArchState *env = (CPUArchState *)cpu->env_ptr;", "TranslationBlock *tb, **tb_hash_head, **ptb1;", "unsigned int VAR_0;", "tb_page_addr_t phys_pc, phys_page1;", "tcg_ctx.tb_ctx.tb_invalidated_flag = 0;", "phys_pc = get_page_addr_code(env, pc);", "phys_page1 = phys_pc & TARGET_PAGE_MASK;", "VAR_0 = tb_phys_hash_func(phys_pc);", "ptb1 = tb_hash_head = &tcg_ctx.tb_ctx.tb_phys_hash[VAR_0];", "tb = *ptb1;", "while (tb) {", "if (tb->pc == pc &&\ntb->page_addr[0] == phys_page1 &&\ntb->cs_base == cs_base &&\ntb->flags == flags) {", "if (tb->page_addr[1] == -1) {", "break;", "} else {", "target_ulong virt_page2 = (pc & TARGET_PAGE_MASK) +\nTARGET_PAGE_SIZE;", "tb_page_addr_t phys_page2 = get_page_addr_code(env, virt_page2);", "if (tb->page_addr[1] == phys_page2) {", "break;", "}", "}", "}", "ptb1 = &tb->phys_hash_next;", "tb = *ptb1;", "}", "if (tb) {", "*ptb1 = tb->phys_hash_next;", "tb->phys_hash_next = *tb_hash_head;", "*tb_hash_head = tb;", "}", "return tb;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 27 ], [ 29 ], [ 31 ], [ 37 ], [ 39 ], [ 43 ], [ 45, 47, 49, 51 ], [ 55 ], [ 59 ], [ 61 ], [ 65, 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ] ]

[ "static int FUNC_0(MXFContext *VAR_0, int *VAR_1, MXFIndexTableSegment ***VAR_2)\n{", "int VAR_3, VAR_4, VAR_5 = 0;", "MXFIndexTableSegment **unsorted_segments;", "int VAR_6 = -1, VAR_7 = -1, VAR_8 = -1;", "for (VAR_3 = 0; VAR_3 < VAR_0->metadata_sets_count; VAR_3++)", "if (VAR_0->metadata_sets[VAR_3]->type == IndexTableSegment)\nVAR_5++;", "if (!VAR_5)\nreturn AVERROR_INVALIDDATA;", "*VAR_2 = av_mallocz(VAR_5 * sizeof(**VAR_2));", "unsorted_segments = av_mallocz(VAR_5 * sizeof(*unsorted_segments));", "if (!VAR_2 || !unsorted_segments) {", "av_freep(VAR_2);", "av_free(unsorted_segments);", "return AVERROR(ENOMEM);", "}", "for (VAR_3 = VAR_4 = 0; VAR_3 < VAR_0->metadata_sets_count; VAR_3++)", "if (VAR_0->metadata_sets[VAR_3]->type == IndexTableSegment)\nunsorted_segments[VAR_4++] = (MXFIndexTableSegment*)VAR_0->metadata_sets[VAR_3];", "*VAR_1 = 0;", "for (VAR_3 = 0; VAR_3 < VAR_5; VAR_3++) {", "int VAR_9 = -1, VAR_10 = -1, VAR_11 = -1, VAR_12 = -1;", "for (VAR_4 = 0; VAR_4 < VAR_5; VAR_4++) {", "MXFIndexTableSegment *s = unsorted_segments[VAR_4];", "if ((VAR_3 == 0 || s->body_sid > VAR_6 || s->index_sid > VAR_7 || s->index_start_position > VAR_8) &&\n(VAR_9 == -1 || s->body_sid < VAR_10 || s->index_sid < VAR_11 || s->index_start_position < VAR_12)) {", "VAR_9 = VAR_4;", "VAR_10 = s->body_sid;", "VAR_11 = s->index_sid;", "VAR_12 = s->index_start_position;", "}", "}", "if (VAR_9 == -1)\nbreak;", "(*VAR_2)[(*VAR_1)++] = unsorted_segments[VAR_9];", "VAR_6 = VAR_10;", "VAR_7 = VAR_11;", "VAR_8 = VAR_12;", "}", "av_free(unsorted_segments);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 15 ], [ 17, 19 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47, 49 ], [ 53 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 97, 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ] ]

[ "static uint32_t FUNC_0(void *opaque, target_phys_addr_t addr)\n{", "MiscState *s = opaque;", "uint32_t ret = 0, saddr;", "saddr = addr & LED_MAXADDR;", "switch (saddr) {", "case 0:\nret = s->leds;", "break;", "default:\nbreak;", "}", "MISC_DPRINTF(\"Read diagnostic LED reg 0x\" TARGET_FMT_plx \" = %x\\n\", addr,\nret);", "return ret;", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0)\n{", "V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy));", "int VAR_1;", "if (VAR_0->export_flags & V9FS_PROXY_SOCK_NAME) {", "VAR_1 = connect_namedsocket(VAR_0->fs_root);", "} else {", "VAR_1 = atoi(VAR_0->fs_root);", "if (VAR_1 < 0) {", "fprintf(stderr, \"socket descriptor not initialized\\n\");", "}", "}", "if (VAR_1 < 0) {", "g_free(proxy);", "return -1;", "}", "g_free(VAR_0->fs_root);", "VAR_0->fs_root = NULL;", "proxy->in_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ);", "proxy->in_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ;", "proxy->out_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ);", "proxy->out_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ;", "VAR_0->private = proxy;", "proxy->sockfd = VAR_1;", "qemu_mutex_init(&proxy->mutex);", "VAR_0->export_flags |= V9FS_PATHNAME_FSCONTEXT;", "VAR_0->exops.get_st_gen = proxy_ioc_getversion;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(void * VAR_0, int VAR_1)\n{", "SCSIDiskReq *r = (SCSIDiskReq *)VAR_0;", "SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);", "if (r->req.aiocb != NULL) {", "r->req.aiocb = NULL;", "bdrv_acct_done(s->qdev.conf.bs, &r->acct);", "}", "if (VAR_1 < 0) {", "if (scsi_handle_rw_error(r, -VAR_1)) {", "goto done;", "}", "}", "scsi_req_complete(&r->req, GOOD);", "done:\nif (!r->req.io_canceled) {", "scsi_req_unref(&r->req);", "}", "}" ]

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

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

[ "void FUNC_0(int VAR_0)\n{", "mmap_fork_end(VAR_0);", "if (VAR_0) {", "CPUState *cpu, *next_cpu;", "CPU_FOREACH_SAFE(cpu, next_cpu) {", "if (cpu != thread_cpu) {", "QTAILQ_REMOVE(&cpus, thread_cpu, node);", "}", "}", "pending_cpus = 0;", "pthread_mutex_init(&exclusive_lock, NULL);", "pthread_mutex_init(&cpu_list_mutex, NULL);", "pthread_cond_init(&exclusive_cond, NULL);", "pthread_cond_init(&exclusive_resume, NULL);", "pthread_mutex_init(&tcg_ctx.tb_ctx.tb_lock, NULL);", "gdbserver_fork(thread_cpu);", "} else {", "pthread_mutex_unlock(&exclusive_lock);", "pthread_mutex_unlock(&tcg_ctx.tb_ctx.tb_lock);", "}", "}" ]

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

[ "static uint32_t FUNC_0(uint32_t idx, uint32_t state)\n{", "sPAPRDRConnector *drc = spapr_drc_by_index(idx);", "sPAPRDRConnectorClass *drck;", "if (!drc) {", "return RTAS_OUT_PARAM_ERROR;", "}", "drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);", "return drck->set_allocation_state(drc, state);", "}" ]

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

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

[ "static void FUNC_0(QEMUFile * VAR_0, void *VAR_1)\n{", "EEPRO100State *s = VAR_1;", "int VAR_2;", "pci_device_save(&s->dev, VAR_0);", "qemu_put_8s(VAR_0, &s->rxcr);", "qemu_put_8s(VAR_0, &s->cmd);", "qemu_put_be32s(VAR_0, &s->start);", "qemu_put_be32s(VAR_0, &s->stop);", "qemu_put_8s(VAR_0, &s->boundary);", "qemu_put_8s(VAR_0, &s->tsr);", "qemu_put_8s(VAR_0, &s->tpsr);", "qemu_put_be16s(VAR_0, &s->tcnt);", "qemu_put_be16s(VAR_0, &s->rcnt);", "qemu_put_be32s(VAR_0, &s->rsar);", "qemu_put_8s(VAR_0, &s->rsr);", "qemu_put_8s(VAR_0, &s->isr);", "qemu_put_8s(VAR_0, &s->dcfg);", "qemu_put_8s(VAR_0, &s->imr);", "qemu_put_buffer(VAR_0, s->phys, 6);", "qemu_put_8s(VAR_0, &s->curpag);", "qemu_put_buffer(VAR_0, s->mult, 8);", "qemu_put_buffer(VAR_0, s->mem, sizeof(s->mem));", "qemu_put_8s(VAR_0, &s->scb_stat);", "qemu_put_8s(VAR_0, &s->int_stat);", "for (VAR_2 = 0; VAR_2 < 3; VAR_2++) {", "qemu_put_be32s(VAR_0, &s->region[VAR_2]);", "}", "qemu_put_buffer(VAR_0, s->macaddr, 6);", "for (VAR_2 = 0; VAR_2 < 19; VAR_2++) {", "qemu_put_be32s(VAR_0, &s->statcounter[VAR_2]);", "}", "for (VAR_2 = 0; VAR_2 < 32; VAR_2++) {", "qemu_put_be16s(VAR_0, &s->mdimem[VAR_2]);", "}", "qemu_put_be32s(VAR_0, &s->device);", "qemu_put_be32s(VAR_0, &s->pointer);", "qemu_put_be32s(VAR_0, &s->cu_base);", "qemu_put_be32s(VAR_0, &s->cu_offset);", "qemu_put_be32s(VAR_0, &s->ru_base);", "qemu_put_be32s(VAR_0, &s->ru_offset);", "qemu_put_be32s(VAR_0, &s->statsaddr);", "qemu_put_be32s(VAR_0, &s->statistics.tx_good_frames);", "qemu_put_be32s(VAR_0, &s->statistics.tx_max_collisions);", "qemu_put_be32s(VAR_0, &s->statistics.tx_late_collisions);", "qemu_put_be32s(VAR_0, &s->statistics.tx_underruns);", "qemu_put_be32s(VAR_0, &s->statistics.tx_lost_crs);", "qemu_put_be32s(VAR_0, &s->statistics.tx_deferred);", "qemu_put_be32s(VAR_0, &s->statistics.tx_single_collisions);", "qemu_put_be32s(VAR_0, &s->statistics.tx_multiple_collisions);", "qemu_put_be32s(VAR_0, &s->statistics.tx_total_collisions);", "qemu_put_be32s(VAR_0, &s->statistics.rx_good_frames);", "qemu_put_be32s(VAR_0, &s->statistics.rx_crc_errors);", "qemu_put_be32s(VAR_0, &s->statistics.rx_alignment_errors);", "qemu_put_be32s(VAR_0, &s->statistics.rx_resource_errors);", "qemu_put_be32s(VAR_0, &s->statistics.rx_overrun_errors);", "qemu_put_be32s(VAR_0, &s->statistics.rx_cdt_errors);", "qemu_put_be32s(VAR_0, &s->statistics.rx_short_frame_errors);", "qemu_put_be32s(VAR_0, &s->statistics.fc_xmt_pause);", "qemu_put_be32s(VAR_0, &s->statistics.fc_rcv_pause);", "qemu_put_be32s(VAR_0, &s->statistics.fc_rcv_unsupported);", "qemu_put_be16s(VAR_0, &s->statistics.xmt_tco_frames);", "qemu_put_be16s(VAR_0, &s->statistics.rcv_tco_frames);", "qemu_put_be32s(VAR_0, &s->statistics.complete);", "#if 0\nqemu_put_be16s(VAR_0, &s->status);", "#endif\nqemu_put_buffer(VAR_0, s->configuration, sizeof(s->configuration));", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 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, 153 ], [ 155 ] ]

[ "static void FUNC_0(int VAR_0, int VAR_1, int VAR_2,\nDisplayState *VAR_3, const char **VAR_4, int VAR_5,\nconst char *VAR_6, const char *VAR_7,\nconst char *VAR_8, const char *VAR_9)\n{", "spitz_common_init(VAR_0, VAR_1, VAR_3, VAR_6,\nVAR_7, VAR_8, terrier, 0x33f);", "}" ]

[ 0, 0, 0 ]

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

[ "int FUNC_0(BDRVQEDState *VAR_0, QEDRequest *VAR_1,\nunsigned int VAR_2, unsigned int VAR_3, bool VAR_4)\n{", "int VAR_5 = -EINPROGRESS;", "qed_write_l2_table(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, qed_sync_cb, &VAR_5);", "while (VAR_5 == -EINPROGRESS) {", "aio_poll(bdrv_get_aio_context(VAR_0->bs), true);", "}", "return VAR_5;", "}" ]

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

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

[ "static void FUNC_0(MpegEncContext *VAR_0, int VAR_1)\n{", "int VAR_2, VAR_3, VAR_4 = 0;", "int VAR_5;", "int VAR_6;", "MpegEncContext best_s, backup_s;", "uint8_t bit_buf[2][3000];", "uint8_t bit_buf2[2][3000];", "uint8_t bit_buf_tex[2][3000];", "PutBitContext pb[2], pb2[2], tex_pb[2];", "for(VAR_5=0; VAR_5<2; VAR_5++){", "init_put_bits(&pb [VAR_5], bit_buf [VAR_5], 3000, NULL, NULL);", "init_put_bits(&pb2 [VAR_5], bit_buf2 [VAR_5], 3000, NULL, NULL);", "init_put_bits(&tex_pb[VAR_5], bit_buf_tex[VAR_5], 3000, NULL, NULL);", "}", "VAR_0->VAR_1 = VAR_1;", "VAR_0->block_wrap[0]=\nVAR_0->block_wrap[1]=\nVAR_0->block_wrap[2]=\nVAR_0->block_wrap[3]= VAR_0->mb_width*2 + 2;", "VAR_0->block_wrap[4]=\nVAR_0->block_wrap[5]= VAR_0->mb_width + 2;", "VAR_0->current_picture.mb_var_sum = 0;", "VAR_0->current_picture.mc_mb_var_sum = 0;", "#ifdef CONFIG_RISKY\nif (VAR_0->codec_id == CODEC_ID_MPEG1VIDEO || (VAR_0->h263_pred && !VAR_0->h263_msmpeg4))\nff_set_mpeg4_time(VAR_0, VAR_0->VAR_1);", "#endif\nVAR_0->scene_change_score=0;", "VAR_0->qscale= (int)(VAR_0->frame_qscale + 0.5);", "if(VAR_0->msmpeg4_version){", "if(VAR_0->pict_type==I_TYPE)\nVAR_0->no_rounding=1;", "else if(VAR_0->flipflop_rounding)\nVAR_0->no_rounding ^= 1;", "}else if(VAR_0->out_format == FMT_H263){", "if(VAR_0->pict_type==I_TYPE)\nVAR_0->no_rounding=0;", "else if(VAR_0->pict_type!=B_TYPE)\nVAR_0->no_rounding ^= 1;", "}", "VAR_0->mb_intra=0;", "if(VAR_0->pict_type != I_TYPE){", "if(VAR_0->pict_type != B_TYPE){", "if((VAR_0->avctx->pre_me && VAR_0->last_non_b_pict_type==I_TYPE) || VAR_0->avctx->pre_me==2){", "VAR_0->me.pre_pass=1;", "VAR_0->me.dia_size= VAR_0->avctx->pre_dia_size;", "for(VAR_3=VAR_0->mb_height-1; VAR_3 >=0 ; VAR_3--) {", "for(VAR_2=VAR_0->mb_width-1; VAR_2 >=0 ; VAR_2--) {", "VAR_0->VAR_2 = VAR_2;", "VAR_0->VAR_3 = VAR_3;", "ff_pre_estimate_p_frame_motion(VAR_0, VAR_2, VAR_3);", "}", "}", "VAR_0->me.pre_pass=0;", "}", "}", "VAR_0->me.dia_size= VAR_0->avctx->dia_size;", "for(VAR_3=0; VAR_3 < VAR_0->mb_height; VAR_3++) {", "VAR_0->block_index[0]= VAR_0->block_wrap[0]*(VAR_3*2 + 1) - 1;", "VAR_0->block_index[1]= VAR_0->block_wrap[0]*(VAR_3*2 + 1);", "VAR_0->block_index[2]= VAR_0->block_wrap[0]*(VAR_3*2 + 2) - 1;", "VAR_0->block_index[3]= VAR_0->block_wrap[0]*(VAR_3*2 + 2);", "for(VAR_2=0; VAR_2 < VAR_0->mb_width; VAR_2++) {", "VAR_0->VAR_2 = VAR_2;", "VAR_0->VAR_3 = VAR_3;", "VAR_0->block_index[0]+=2;", "VAR_0->block_index[1]+=2;", "VAR_0->block_index[2]+=2;", "VAR_0->block_index[3]+=2;", "if(VAR_0->pict_type==B_TYPE)\nff_estimate_b_frame_motion(VAR_0, VAR_2, VAR_3);", "else\nff_estimate_p_frame_motion(VAR_0, VAR_2, VAR_3);", "}", "}", "}else {", "memset(VAR_0->motion_val[0], 0, sizeof(int16_t)*(VAR_0->mb_width*2 + 2)*(VAR_0->mb_height*2 + 2)*2);", "memset(VAR_0->p_mv_table , 0, sizeof(int16_t)*(VAR_0->mb_width+2)*(VAR_0->mb_height+2)*2);", "memset(VAR_0->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*VAR_0->mb_width*VAR_0->mb_height);", "if(!VAR_0->fixed_qscale){", "for(VAR_3=0; VAR_3 < VAR_0->mb_height; VAR_3++) {", "for(VAR_2=0; VAR_2 < VAR_0->mb_width; VAR_2++) {", "int xx = VAR_2 * 16;", "int yy = VAR_3 * 16;", "uint8_t *pix = VAR_0->new_picture.data[0] + (yy * VAR_0->linesize) + xx;", "int varc;", "int sum = VAR_0->dsp.pix_sum(pix, VAR_0->linesize);", "varc = (VAR_0->dsp.pix_norm1(pix, VAR_0->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;", "VAR_0->current_picture.mb_var [VAR_0->mb_width * VAR_3 + VAR_2] = varc;", "VAR_0->current_picture.mb_mean[VAR_0->mb_width * VAR_3 + VAR_2] = (sum+128)>>8;", "VAR_0->current_picture.mb_var_sum += varc;", "}", "}", "}", "}", "emms_c();", "if(VAR_0->scene_change_score > 0 && VAR_0->pict_type == P_TYPE){", "VAR_0->pict_type= I_TYPE;", "memset(VAR_0->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*VAR_0->mb_width*VAR_0->mb_height);", "}", "if(VAR_0->pict_type==P_TYPE || VAR_0->pict_type==S_TYPE) {", "VAR_0->f_code= ff_get_best_fcode(VAR_0, VAR_0->p_mv_table, MB_TYPE_INTER);", "ff_fix_long_p_mvs(VAR_0);", "}", "if(VAR_0->pict_type==B_TYPE){", "int VAR_7, VAR_8;", "VAR_7 = ff_get_best_fcode(VAR_0, VAR_0->b_forw_mv_table, MB_TYPE_FORWARD);", "VAR_8 = ff_get_best_fcode(VAR_0, VAR_0->b_bidir_forw_mv_table, MB_TYPE_BIDIR);", "VAR_0->f_code = FFMAX(VAR_7, VAR_8);", "VAR_7 = ff_get_best_fcode(VAR_0, VAR_0->b_back_mv_table, MB_TYPE_BACKWARD);", "VAR_8 = ff_get_best_fcode(VAR_0, VAR_0->b_bidir_back_mv_table, MB_TYPE_BIDIR);", "VAR_0->b_code = FFMAX(VAR_7, VAR_8);", "ff_fix_long_b_mvs(VAR_0, VAR_0->b_forw_mv_table, VAR_0->f_code, MB_TYPE_FORWARD);", "ff_fix_long_b_mvs(VAR_0, VAR_0->b_back_mv_table, VAR_0->b_code, MB_TYPE_BACKWARD);", "ff_fix_long_b_mvs(VAR_0, VAR_0->b_bidir_forw_mv_table, VAR_0->f_code, MB_TYPE_BIDIR);", "ff_fix_long_b_mvs(VAR_0, VAR_0->b_bidir_back_mv_table, VAR_0->b_code, MB_TYPE_BIDIR);", "}", "if (VAR_0->fixed_qscale)\nVAR_0->frame_qscale = VAR_0->current_picture.quality;", "else\nVAR_0->frame_qscale = ff_rate_estimate_qscale(VAR_0);", "if(VAR_0->adaptive_quant){", "#ifdef CONFIG_RISKY\nswitch(VAR_0->codec_id){", "case CODEC_ID_MPEG4:\nff_clean_mpeg4_qscales(VAR_0);", "break;", "case CODEC_ID_H263:\ncase CODEC_ID_H263P:\nff_clean_h263_qscales(VAR_0);", "break;", "}", "#endif\nVAR_0->qscale= VAR_0->current_picture.qscale_table[0];", "}else", "VAR_0->qscale= (int)(VAR_0->frame_qscale + 0.5);", "if (VAR_0->out_format == FMT_MJPEG) {", "VAR_0->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];", "for(VAR_5=1;VAR_5<64;VAR_5++){", "int VAR_9= VAR_0->idct_permutation[VAR_5];", "VAR_0->intra_matrix[VAR_9] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[VAR_5] * VAR_0->qscale) >> 3);", "}", "convert_matrix(VAR_0, VAR_0->q_intra_matrix, VAR_0->q_intra_matrix16,\nVAR_0->q_intra_matrix16_bias, VAR_0->intra_matrix, VAR_0->intra_quant_bias, 8, 8);", "}", "VAR_0->current_picture.key_frame= VAR_0->pict_type == I_TYPE;", "VAR_0->current_picture.pict_type= VAR_0->pict_type;", "if(VAR_0->current_picture.key_frame)\nVAR_0->picture_in_gop_number=0;", "VAR_0->last_bits= get_bit_count(&VAR_0->pb);", "switch(VAR_0->out_format) {", "case FMT_MJPEG:\nmjpeg_picture_header(VAR_0);", "break;", "#ifdef CONFIG_RISKY\ncase FMT_H263:\nif (VAR_0->codec_id == CODEC_ID_WMV2)\nff_wmv2_encode_picture_header(VAR_0, VAR_1);", "else if (VAR_0->h263_msmpeg4)\nmsmpeg4_encode_picture_header(VAR_0, VAR_1);", "else if (VAR_0->h263_pred)\nmpeg4_encode_picture_header(VAR_0, VAR_1);", "else if (VAR_0->h263_rv10)\nrv10_encode_picture_header(VAR_0, VAR_1);", "else\nh263_encode_picture_header(VAR_0, VAR_1);", "break;", "#endif\ncase FMT_MPEG1:\nmpeg1_encode_picture_header(VAR_0, VAR_1);", "break;", "}", "VAR_6= get_bit_count(&VAR_0->pb);", "VAR_0->header_bits= VAR_6 - VAR_0->last_bits;", "VAR_0->last_bits= VAR_6;", "VAR_0->mv_bits=0;", "VAR_0->misc_bits=0;", "VAR_0->i_tex_bits=0;", "VAR_0->p_tex_bits=0;", "VAR_0->i_count=0;", "VAR_0->f_count=0;", "VAR_0->b_count=0;", "VAR_0->skip_count=0;", "for(VAR_5=0; VAR_5<3; VAR_5++){", "VAR_0->last_dc[VAR_5] = 128;", "VAR_0->current_picture.error[VAR_5] = 0;", "}", "VAR_0->mb_incr = 1;", "VAR_0->last_mv[0][0][0] = 0;", "VAR_0->last_mv[0][0][1] = 0;", "VAR_0->last_mv[1][0][0] = 0;", "VAR_0->last_mv[1][0][1] = 0;", "VAR_0->last_mv_dir = 0;", "#ifdef CONFIG_RISKY\nif (VAR_0->codec_id==CODEC_ID_H263 || VAR_0->codec_id==CODEC_ID_H263P)\nVAR_0->gob_index = ff_h263_get_gob_height(VAR_0);", "if(VAR_0->codec_id==CODEC_ID_MPEG4 && VAR_0->partitioned_frame)\nff_mpeg4_init_partitions(VAR_0);", "#endif\nVAR_0->resync_mb_x=0;", "VAR_0->resync_mb_y=0;", "VAR_0->first_slice_line = 1;", "VAR_0->ptr_lastgob = VAR_0->pb.buf;", "VAR_0->ptr_last_mb_line = VAR_0->pb.buf;", "for(VAR_3=0; VAR_3 < VAR_0->mb_height; VAR_3++) {", "VAR_0->y_dc_scale= VAR_0->y_dc_scale_table[ VAR_0->qscale ];", "VAR_0->c_dc_scale= VAR_0->c_dc_scale_table[ VAR_0->qscale ];", "VAR_0->block_index[0]= VAR_0->block_wrap[0]*(VAR_3*2 + 1) - 1;", "VAR_0->block_index[1]= VAR_0->block_wrap[0]*(VAR_3*2 + 1);", "VAR_0->block_index[2]= VAR_0->block_wrap[0]*(VAR_3*2 + 2) - 1;", "VAR_0->block_index[3]= VAR_0->block_wrap[0]*(VAR_3*2 + 2);", "VAR_0->block_index[4]= VAR_0->block_wrap[4]*(VAR_3 + 1) + VAR_0->block_wrap[0]*(VAR_0->mb_height*2 + 2);", "VAR_0->block_index[5]= VAR_0->block_wrap[4]*(VAR_3 + 1 + VAR_0->mb_height + 2) + VAR_0->block_wrap[0]*(VAR_0->mb_height*2 + 2);", "for(VAR_2=0; VAR_2 < VAR_0->mb_width; VAR_2++) {", "int mb_type= VAR_0->mb_type[VAR_3 * VAR_0->mb_width + VAR_2];", "const int xy= (VAR_3+1) * (VAR_0->mb_width+2) + VAR_2 + 1;", "int dmin=10000000;", "VAR_0->VAR_2 = VAR_2;", "VAR_0->VAR_3 = VAR_3;", "VAR_0->block_index[0]+=2;", "VAR_0->block_index[1]+=2;", "VAR_0->block_index[2]+=2;", "VAR_0->block_index[3]+=2;", "VAR_0->block_index[4]++;", "VAR_0->block_index[5]++;", "#ifdef CONFIG_RISKY\nif(VAR_0->rtp_mode){", "int current_packet_size, is_gob_start;", "current_packet_size= pbBufPtr(&VAR_0->pb) - VAR_0->ptr_lastgob;", "is_gob_start=0;", "if(VAR_0->codec_id==CODEC_ID_MPEG4){", "if(current_packet_size + VAR_0->mb_line_avgsize/VAR_0->mb_width >= VAR_0->rtp_payload_size\n&& VAR_0->VAR_3 + VAR_0->VAR_2>0){", "if(VAR_0->partitioned_frame){", "ff_mpeg4_merge_partitions(VAR_0);", "ff_mpeg4_init_partitions(VAR_0);", "}", "ff_mpeg4_encode_video_packet_header(VAR_0);", "if(VAR_0->flags&CODEC_FLAG_PASS1){", "int VAR_6= get_bit_count(&VAR_0->pb);", "VAR_0->misc_bits+= VAR_6 - VAR_0->last_bits;", "VAR_0->last_bits= VAR_6;", "}", "ff_mpeg4_clean_buffers(VAR_0);", "is_gob_start=1;", "}", "}else{", "if(current_packet_size + VAR_0->mb_line_avgsize*VAR_0->gob_index >= VAR_0->rtp_payload_size\n&& VAR_0->VAR_2==0 && VAR_0->VAR_3>0 && VAR_0->VAR_3%VAR_0->gob_index==0){", "h263_encode_gob_header(VAR_0, VAR_3);", "is_gob_start=1;", "}", "}", "if(is_gob_start){", "VAR_0->ptr_lastgob = pbBufPtr(&VAR_0->pb);", "VAR_0->first_slice_line=1;", "VAR_0->resync_mb_x=VAR_2;", "VAR_0->resync_mb_y=VAR_3;", "}", "}", "#endif\nif( (VAR_0->resync_mb_x == VAR_0->VAR_2)\n&& VAR_0->resync_mb_y+1 == VAR_0->VAR_3){", "VAR_0->first_slice_line=0;", "}", "if(mb_type & (mb_type-1)){", "int next_block=0;", "int pb_bits_count, pb2_bits_count, tex_pb_bits_count;", "copy_context_before_encode(&backup_s, VAR_0, -1);", "backup_s.pb= VAR_0->pb;", "best_s.data_partitioning= VAR_0->data_partitioning;", "best_s.partitioned_frame= VAR_0->partitioned_frame;", "if(VAR_0->data_partitioning){", "backup_s.pb2= VAR_0->pb2;", "backup_s.tex_pb= VAR_0->tex_pb;", "}", "if(mb_type&MB_TYPE_INTER){", "VAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mv_type = MV_TYPE_16X16;", "VAR_0->mb_intra= 0;", "VAR_0->mv[0][0][0] = VAR_0->p_mv_table[xy][0];", "VAR_0->mv[0][0][1] = VAR_0->p_mv_table[xy][1];", "encode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,\n&dmin, &next_block, VAR_0->mv[0][0][0], VAR_0->mv[0][0][1]);", "}", "if(mb_type&MB_TYPE_INTER4V){", "VAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mv_type = MV_TYPE_8X8;", "VAR_0->mb_intra= 0;", "for(VAR_5=0; VAR_5<4; VAR_5++){", "VAR_0->mv[0][VAR_5][0] = VAR_0->motion_val[VAR_0->block_index[VAR_5]][0];", "VAR_0->mv[0][VAR_5][1] = VAR_0->motion_val[VAR_0->block_index[VAR_5]][1];", "}", "encode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,\n&dmin, &next_block, 0, 0);", "}", "if(mb_type&MB_TYPE_FORWARD){", "VAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mv_type = MV_TYPE_16X16;", "VAR_0->mb_intra= 0;", "VAR_0->mv[0][0][0] = VAR_0->b_forw_mv_table[xy][0];", "VAR_0->mv[0][0][1] = VAR_0->b_forw_mv_table[xy][1];", "encode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,\n&dmin, &next_block, VAR_0->mv[0][0][0], VAR_0->mv[0][0][1]);", "}", "if(mb_type&MB_TYPE_BACKWARD){", "VAR_0->mv_dir = MV_DIR_BACKWARD;", "VAR_0->mv_type = MV_TYPE_16X16;", "VAR_0->mb_intra= 0;", "VAR_0->mv[1][0][0] = VAR_0->b_back_mv_table[xy][0];", "VAR_0->mv[1][0][1] = VAR_0->b_back_mv_table[xy][1];", "encode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,\n&dmin, &next_block, VAR_0->mv[1][0][0], VAR_0->mv[1][0][1]);", "}", "if(mb_type&MB_TYPE_BIDIR){", "VAR_0->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;", "VAR_0->mv_type = MV_TYPE_16X16;", "VAR_0->mb_intra= 0;", "VAR_0->mv[0][0][0] = VAR_0->b_bidir_forw_mv_table[xy][0];", "VAR_0->mv[0][0][1] = VAR_0->b_bidir_forw_mv_table[xy][1];", "VAR_0->mv[1][0][0] = VAR_0->b_bidir_back_mv_table[xy][0];", "VAR_0->mv[1][0][1] = VAR_0->b_bidir_back_mv_table[xy][1];", "encode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,\n&dmin, &next_block, 0, 0);", "}", "if(mb_type&MB_TYPE_DIRECT){", "int mx= VAR_0->b_direct_mv_table[xy][0];", "int my= VAR_0->b_direct_mv_table[xy][1];", "VAR_0->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;", "VAR_0->mb_intra= 0;", "#ifdef CONFIG_RISKY\nff_mpeg4_set_direct_mv(VAR_0, mx, my);", "#endif\nencode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,\n&dmin, &next_block, mx, my);", "}", "if(mb_type&MB_TYPE_INTRA){", "VAR_0->mv_dir = 0;", "VAR_0->mv_type = MV_TYPE_16X16;", "VAR_0->mb_intra= 1;", "VAR_0->mv[0][0][0] = 0;", "VAR_0->mv[0][0][1] = 0;", "encode_mb_hq(VAR_0, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,\n&dmin, &next_block, 0, 0);", "if(VAR_0->h263_pred || VAR_0->h263_aic)\nVAR_0->mbintra_table[VAR_2 + VAR_3*VAR_0->mb_width]=1;", "}", "copy_context_after_encode(VAR_0, &best_s, -1);", "pb_bits_count= get_bit_count(&VAR_0->pb);", "flush_put_bits(&VAR_0->pb);", "ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);", "VAR_0->pb= backup_s.pb;", "if(VAR_0->data_partitioning){", "pb2_bits_count= get_bit_count(&VAR_0->pb2);", "flush_put_bits(&VAR_0->pb2);", "ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);", "VAR_0->pb2= backup_s.pb2;", "tex_pb_bits_count= get_bit_count(&VAR_0->tex_pb);", "flush_put_bits(&VAR_0->tex_pb);", "ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);", "VAR_0->tex_pb= backup_s.tex_pb;", "}", "VAR_0->last_bits= get_bit_count(&VAR_0->pb);", "} else {", "int motion_x, motion_y;", "int intra_score;", "int inter_score= VAR_0->current_picture.mb_cmp_score[VAR_2 + VAR_3*VAR_0->mb_width];", "if(!(VAR_0->flags&CODEC_FLAG_HQ) && VAR_0->pict_type==P_TYPE){", "if((VAR_0->avctx->mb_cmp&0xFF)==FF_CMP_SSE){", "intra_score= (VAR_0->current_picture.mb_var[VAR_2 + VAR_3*VAR_0->mb_width]<<8) - 500;", "}else{", "uint8_t *dest_y;", "int mean= VAR_0->current_picture.mb_mean[VAR_2 + VAR_3*VAR_0->mb_width];", "mean*= 0x01010101;", "dest_y = VAR_0->new_picture.data[0] + (VAR_3 * 16 * VAR_0->linesize ) + VAR_2 * 16;", "for(VAR_5=0; VAR_5<16; VAR_5++){", "*(uint32_t*)(&VAR_0->me.scratchpad[VAR_5*VAR_0->linesize+ 0]) = mean;", "*(uint32_t*)(&VAR_0->me.scratchpad[VAR_5*VAR_0->linesize+ 4]) = mean;", "*(uint32_t*)(&VAR_0->me.scratchpad[VAR_5*VAR_0->linesize+ 8]) = mean;", "*(uint32_t*)(&VAR_0->me.scratchpad[VAR_5*VAR_0->linesize+12]) = mean;", "}", "VAR_0->mb_intra=1;", "intra_score= VAR_0->dsp.mb_cmp[0](VAR_0, VAR_0->me.scratchpad, dest_y, VAR_0->linesize);", "}", "if(VAR_0->avctx->mb_cmp&FF_CMP_CHROMA){", "int VAR_5;", "VAR_0->mb_intra=1;", "for(VAR_5=1; VAR_5<3; VAR_5++){", "uint8_t *dest_c;", "int mean;", "if(VAR_0->out_format == FMT_H263){", "mean= (VAR_0->dc_val[VAR_5][VAR_2 + (VAR_3+1)*(VAR_0->mb_width+2)] + 4)>>3; not exact but simple ;)", "}else{", "mean= (VAR_0->last_dc[VAR_5] + 4)>>3;", "}", "dest_c = VAR_0->new_picture.data[VAR_5] + (VAR_3 * 8 * (VAR_0->uvlinesize)) + VAR_2 * 8;", "mean*= 0x01010101;", "for(VAR_5=0; VAR_5<8; VAR_5++){", "*(uint32_t*)(&VAR_0->me.scratchpad[VAR_5*VAR_0->uvlinesize+ 0]) = mean;", "*(uint32_t*)(&VAR_0->me.scratchpad[VAR_5*VAR_0->uvlinesize+ 4]) = mean;", "}", "intra_score+= VAR_0->dsp.mb_cmp[1](VAR_0, VAR_0->me.scratchpad, dest_c, VAR_0->uvlinesize);", "}", "}", "switch(VAR_0->avctx->mb_cmp&0xFF){", "default:\ncase FF_CMP_SAD:\nintra_score+= 32*VAR_0->qscale;", "break;", "case FF_CMP_SSE:\nintra_score+= 24*VAR_0->qscale*VAR_0->qscale;", "break;", "case FF_CMP_SATD:\nintra_score+= 96*VAR_0->qscale;", "break;", "case FF_CMP_DCT:\nintra_score+= 48*VAR_0->qscale;", "break;", "case FF_CMP_BIT:\nintra_score+= 16;", "break;", "case FF_CMP_PSNR:\ncase FF_CMP_RD:\nintra_score+= (VAR_0->qscale*VAR_0->qscale*109*8 + 64)>>7;", "break;", "}", "if(intra_score < inter_score)\nmb_type= MB_TYPE_INTRA;", "}", "VAR_0->mv_type=MV_TYPE_16X16;", "switch(mb_type){", "case MB_TYPE_INTRA:\nVAR_0->mv_dir = 0;", "VAR_0->mb_intra= 1;", "motion_x= VAR_0->mv[0][0][0] = 0;", "motion_y= VAR_0->mv[0][0][1] = 0;", "break;", "case MB_TYPE_INTER:\nVAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mb_intra= 0;", "motion_x= VAR_0->mv[0][0][0] = VAR_0->p_mv_table[xy][0];", "motion_y= VAR_0->mv[0][0][1] = VAR_0->p_mv_table[xy][1];", "break;", "case MB_TYPE_INTER4V:\nVAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mv_type = MV_TYPE_8X8;", "VAR_0->mb_intra= 0;", "for(VAR_5=0; VAR_5<4; VAR_5++){", "VAR_0->mv[0][VAR_5][0] = VAR_0->motion_val[VAR_0->block_index[VAR_5]][0];", "VAR_0->mv[0][VAR_5][1] = VAR_0->motion_val[VAR_0->block_index[VAR_5]][1];", "}", "motion_x= motion_y= 0;", "break;", "case MB_TYPE_DIRECT:\nVAR_0->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;", "VAR_0->mb_intra= 0;", "motion_x=VAR_0->b_direct_mv_table[xy][0];", "motion_y=VAR_0->b_direct_mv_table[xy][1];", "#ifdef CONFIG_RISKY\nff_mpeg4_set_direct_mv(VAR_0, motion_x, motion_y);", "#endif\nbreak;", "case MB_TYPE_BIDIR:\nVAR_0->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;", "VAR_0->mb_intra= 0;", "motion_x=0;", "motion_y=0;", "VAR_0->mv[0][0][0] = VAR_0->b_bidir_forw_mv_table[xy][0];", "VAR_0->mv[0][0][1] = VAR_0->b_bidir_forw_mv_table[xy][1];", "VAR_0->mv[1][0][0] = VAR_0->b_bidir_back_mv_table[xy][0];", "VAR_0->mv[1][0][1] = VAR_0->b_bidir_back_mv_table[xy][1];", "break;", "case MB_TYPE_BACKWARD:\nVAR_0->mv_dir = MV_DIR_BACKWARD;", "VAR_0->mb_intra= 0;", "motion_x= VAR_0->mv[1][0][0] = VAR_0->b_back_mv_table[xy][0];", "motion_y= VAR_0->mv[1][0][1] = VAR_0->b_back_mv_table[xy][1];", "break;", "case MB_TYPE_FORWARD:\nVAR_0->mv_dir = MV_DIR_FORWARD;", "VAR_0->mb_intra= 0;", "motion_x= VAR_0->mv[0][0][0] = VAR_0->b_forw_mv_table[xy][0];", "motion_y= VAR_0->mv[0][0][1] = VAR_0->b_forw_mv_table[xy][1];", "break;", "default:\nmotion_x=motion_y=0;", "printf(\"illegal MB type\\n\");", "}", "encode_mb(VAR_0, motion_x, motion_y);", "VAR_0->last_mv_dir = VAR_0->mv_dir;", "}", "if(VAR_0->mb_intra ){", "VAR_0->p_mv_table[xy][0]=0;", "VAR_0->p_mv_table[xy][1]=0;", "}", "MPV_decode_mb(VAR_0, VAR_0->block);", "if(VAR_0->flags&CODEC_FLAG_PSNR){", "int w= 16;", "int h= 16;", "if(VAR_0->VAR_2*16 + 16 > VAR_0->width ) w= VAR_0->width - VAR_0->VAR_2*16;", "if(VAR_0->VAR_3*16 + 16 > VAR_0->height) h= VAR_0->height- VAR_0->VAR_3*16;", "VAR_0->current_picture.error[0] += sse(\nVAR_0,\nVAR_0->new_picture .data[0] + VAR_0->VAR_2*16 + VAR_0->VAR_3*VAR_0->linesize*16,\nVAR_0->current_picture.data[0] + VAR_0->VAR_2*16 + VAR_0->VAR_3*VAR_0->linesize*16,\nw, h, VAR_0->linesize);", "VAR_0->current_picture.error[1] += sse(\nVAR_0,\nVAR_0->new_picture .data[1] + VAR_0->VAR_2*8 + VAR_0->VAR_3*VAR_0->uvlinesize*8,\nVAR_0->current_picture.data[1] + VAR_0->VAR_2*8 + VAR_0->VAR_3*VAR_0->uvlinesize*8,\nw>>1, h>>1, VAR_0->uvlinesize);", "VAR_0->current_picture.error[2] += sse(\nVAR_0,\nVAR_0->new_picture .data[2] + VAR_0->VAR_2*8 + VAR_0->VAR_3*VAR_0->uvlinesize*8,\nVAR_0->current_picture.data[2] + VAR_0->VAR_2*8 + VAR_0->VAR_3*VAR_0->uvlinesize*8,\nw>>1, h>>1, VAR_0->uvlinesize);", "}", "}", "if (VAR_0->rtp_mode) {", "if (VAR_3==0)\nVAR_0->mb_line_avgsize = pbBufPtr(&VAR_0->pb) - VAR_0->ptr_last_mb_line;", "else {", "VAR_0->mb_line_avgsize = (VAR_0->mb_line_avgsize + pbBufPtr(&VAR_0->pb) - VAR_0->ptr_last_mb_line) >> 1;", "}", "VAR_0->ptr_last_mb_line = pbBufPtr(&VAR_0->pb);", "}", "}", "emms_c();", "#ifdef CONFIG_RISKY\nif(VAR_0->codec_id==CODEC_ID_MPEG4 && VAR_0->partitioned_frame)\nff_mpeg4_merge_partitions(VAR_0);", "if (VAR_0->msmpeg4_version && VAR_0->msmpeg4_version<4 && VAR_0->pict_type == I_TYPE)\nmsmpeg4_encode_ext_header(VAR_0);", "if(VAR_0->codec_id==CODEC_ID_MPEG4)\nff_mpeg4_stuffing(&VAR_0->pb);", "#endif\nif (VAR_0->rtp_mode) {", "flush_put_bits(&VAR_0->pb);", "VAR_4 = pbBufPtr(&VAR_0->pb) - VAR_0->ptr_lastgob;", "if (VAR_0->rtp_callback)\nVAR_0->rtp_callback(VAR_0->ptr_lastgob, VAR_4, VAR_0->gob_number);", "VAR_0->ptr_lastgob = pbBufPtr(&VAR_0->pb);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 39, 41, 43, 45 ], [ 47, 49 ], [ 55 ], [ 57 ], [ 61, 67, 69 ], [ 71, 75 ], [ 79 ], [ 83 ], [ 85, 87 ], [ 89, 91 ], [ 93 ], [ 95, 97 ], [ 99, 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 173, 175 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 185 ], [ 191 ], [ 193 ], [ 195 ], [ 199 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 241 ], [ 243 ], [ 245 ], [ 249 ], [ 253 ], [ 255 ], [ 261 ], [ 263 ], [ 269 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 283 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 303, 305 ], [ 307, 309 ], [ 313 ], [ 315, 317 ], [ 319, 321 ], [ 323 ], [ 325, 327, 329 ], [ 331 ], [ 333 ], [ 335, 339 ], [ 341 ], [ 343 ], [ 347 ], [ 351 ], [ 353 ], [ 355 ], [ 359 ], [ 361 ], [ 363, 365 ], [ 367 ], [ 373 ], [ 375 ], [ 379, 381 ], [ 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 ], [ 455 ], [ 461 ], [ 465 ], [ 467 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 481 ], [ 485, 487, 489 ], [ 493, 495 ], [ 497, 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 539 ], [ 543 ], [ 545 ], [ 547 ], [ 549 ], [ 551 ], [ 553 ], [ 555 ], [ 557 ], [ 563, 565 ], [ 567 ], [ 571 ], [ 573 ], [ 577 ], [ 579, 581 ], [ 585 ], [ 587 ], [ 589 ], [ 591 ], [ 593 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 613 ], [ 615, 617 ], [ 621 ], [ 623 ], [ 625 ], [ 627 ], [ 631 ], [ 633 ], [ 635 ], [ 637 ], [ 639 ], [ 641 ], [ 643 ], [ 645, 649, 651 ], [ 653 ], [ 655 ], [ 659 ], [ 661 ], [ 663 ], [ 667 ], [ 669 ], [ 671 ], [ 673 ], [ 675 ], [ 677 ], [ 679 ], [ 681 ], [ 685 ], [ 687 ], [ 689 ], [ 691 ], [ 693 ], [ 695 ], [ 697, 699 ], [ 701 ], [ 703 ], [ 705 ], [ 707 ], [ 709 ], [ 711 ], [ 713 ], [ 715 ], [ 717 ], [ 719, 721 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733 ], [ 735 ], [ 737, 739 ], [ 741 ], [ 743 ], [ 745 ], [ 747 ], [ 749 ], [ 751 ], [ 753 ], [ 755, 757 ], [ 759 ], [ 761 ], [ 763 ], [ 765 ], [ 767 ], [ 769 ], [ 771 ], [ 773 ], [ 775 ], [ 777, 779 ], [ 781 ], [ 783 ], [ 785 ], [ 787 ], [ 791 ], [ 793 ], [ 795, 797 ], [ 799, 801, 803 ], [ 805 ], [ 807 ], [ 809 ], [ 811 ], [ 813 ], [ 815 ], [ 817 ], [ 819, 821 ], [ 825, 827 ], [ 829 ], [ 831 ], [ 835 ], [ 837 ], [ 839 ], [ 841 ], [ 845 ], [ 847 ], [ 849 ], [ 851 ], [ 853 ], [ 857 ], [ 859 ], [ 861 ], [ 863 ], [ 865 ], [ 867 ], [ 869 ], [ 871 ], [ 873 ], [ 875 ], [ 879 ], [ 883 ], [ 885 ], [ 887 ], [ 889 ], [ 893 ], [ 895 ], [ 899 ], [ 903 ], [ 905 ], [ 907 ], [ 909 ], [ 911 ], [ 913 ], [ 917 ], [ 919 ], [ 929 ], [ 935 ], [ 937 ], [ 941 ], [ 943 ], [ 945 ], [ 947 ], [ 951 ], [ 953 ], [ 955 ], [ 957 ], [ 959 ], [ 961 ], [ 965 ], [ 967 ], [ 969 ], [ 971 ], [ 973 ], [ 977 ], [ 979 ], [ 981 ], [ 987 ], [ 989, 991, 993 ], [ 995 ], [ 997, 999 ], [ 1001 ], [ 1003, 1005 ], [ 1007 ], [ 1009, 1011 ], [ 1013 ], [ 1015, 1017 ], [ 1019 ], [ 1021, 1023, 1025 ], [ 1027 ], [ 1029 ], [ 1033, 1035 ], [ 1037 ], [ 1041 ], [ 1047 ], [ 1049, 1051 ], [ 1053 ], [ 1055 ], [ 1057 ], [ 1059 ], [ 1061, 1063 ], [ 1065 ], [ 1067 ], [ 1069 ], [ 1071 ], [ 1073, 1075 ], [ 1077 ], [ 1079 ], [ 1081 ], [ 1083 ], [ 1085 ], [ 1087 ], [ 1089 ], [ 1091 ], [ 1093, 1095 ], [ 1097 ], [ 1099 ], [ 1101 ], [ 1103, 1105 ], [ 1107, 1109 ], [ 1111, 1113 ], [ 1115 ], [ 1117 ], [ 1119 ], [ 1121 ], [ 1123 ], [ 1125 ], [ 1127 ], [ 1129 ], [ 1131, 1133 ], [ 1135 ], [ 1137 ], [ 1139 ], [ 1141 ], [ 1143, 1145 ], [ 1147 ], [ 1149 ], [ 1151 ], [ 1155 ], [ 1157, 1159 ], [ 1161 ], [ 1163 ], [ 1167 ], [ 1173 ], [ 1175 ], [ 1181 ], [ 1183 ], [ 1185 ], [ 1187 ], [ 1191 ], [ 1195 ], [ 1197 ], [ 1199 ], [ 1203 ], [ 1205 ], [ 1209, 1211, 1213, 1215, 1217 ], [ 1219, 1221, 1223, 1225, 1227 ], [ 1229, 1231, 1233, 1235, 1237 ], [ 1239 ], [ 1243 ], [ 1251 ], [ 1253, 1255 ], [ 1257 ], [ 1259 ], [ 1261 ], [ 1263 ], [ 1265 ], [ 1267 ], [ 1269 ], [ 1273, 1275, 1277 ], [ 1281, 1283 ], [ 1287, 1289 ], [ 1291, 1303 ], [ 1305 ], [ 1307 ], [ 1311, 1313 ], [ 1315 ], [ 1319 ], [ 1321 ] ]

[ "static void *FUNC_0(hwaddr VAR_0,\nhwaddr VAR_1,\nhwaddr VAR_2,\nbool VAR_3,\nconst char *VAR_4,\nuint32_t VAR_5)\n{", "void *VAR_6;", "uint32_t start_prop = cpu_to_be32(VAR_0);", "uint32_t end_prop = cpu_to_be32(VAR_0 + VAR_1);", "GString *hypertas = g_string_sized_new(256);", "GString *qemu_hypertas = g_string_sized_new(256);", "uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)};", "uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)};", "unsigned char VAR_7[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80};", "char *VAR_8;", "add_str(hypertas, \"hcall-pft\");", "add_str(hypertas, \"hcall-term\");", "add_str(hypertas, \"hcall-dabr\");", "add_str(hypertas, \"hcall-interrupt\");", "add_str(hypertas, \"hcall-tce\");", "add_str(hypertas, \"hcall-vio\");", "add_str(hypertas, \"hcall-splpar\");", "add_str(hypertas, \"hcall-bulk\");", "add_str(hypertas, \"hcall-set-mode\");", "add_str(hypertas, \"hcall-sprg0\");", "add_str(hypertas, \"hcall-copy\");", "add_str(hypertas, \"hcall-debug\");", "add_str(qemu_hypertas, \"hcall-memop1\");", "VAR_6 = g_malloc0(FDT_MAX_SIZE);", "_FDT((fdt_create(VAR_6, FDT_MAX_SIZE)));", "if (VAR_2) {", "_FDT((fdt_add_reservemap_entry(VAR_6, KERNEL_LOAD_ADDR, VAR_2)));", "}", "if (VAR_1) {", "_FDT((fdt_add_reservemap_entry(VAR_6, VAR_0, VAR_1)));", "}", "_FDT((fdt_finish_reservemap(VAR_6)));", "_FDT((fdt_begin_node(VAR_6, \"\")));", "_FDT((fdt_property_string(VAR_6, \"device_type\", \"chrp\")));", "_FDT((fdt_property_string(VAR_6, \"model\", \"IBM pSeries (emulated by qemu)\")));", "_FDT((fdt_property_string(VAR_6, \"compatible\", \"qemu,pseries\")));", "if (kvmppc_get_host_model(&VAR_8)) {", "_FDT((fdt_property_string(VAR_6, \"host-model\", VAR_8)));", "g_free(VAR_8);", "}", "if (kvmppc_get_host_serial(&VAR_8)) {", "_FDT((fdt_property_string(VAR_6, \"host-serial\", VAR_8)));", "g_free(VAR_8);", "}", "VAR_8 = g_strdup_printf(UUID_FMT, qemu_uuid[0], qemu_uuid[1],\nqemu_uuid[2], qemu_uuid[3], qemu_uuid[4],\nqemu_uuid[5], qemu_uuid[6], qemu_uuid[7],\nqemu_uuid[8], qemu_uuid[9], qemu_uuid[10],\nqemu_uuid[11], qemu_uuid[12], qemu_uuid[13],\nqemu_uuid[14], qemu_uuid[15]);", "_FDT((fdt_property_string(VAR_6, \"vm,uuid\", VAR_8)));", "if (qemu_uuid_set) {", "_FDT((fdt_property_string(VAR_6, \"system-id\", VAR_8)));", "}", "g_free(VAR_8);", "if (qemu_get_vm_name()) {", "_FDT((fdt_property_string(VAR_6, \"ibm,partition-name\",\nqemu_get_vm_name())));", "}", "_FDT((fdt_property_cell(VAR_6, \"#address-cells\", 0x2)));", "_FDT((fdt_property_cell(VAR_6, \"#size-cells\", 0x2)));", "_FDT((fdt_begin_node(VAR_6, \"chosen\")));", "_FDT((fdt_property(VAR_6, \"ibm,architecture-vec-5\", VAR_7, sizeof(VAR_7))));", "_FDT((fdt_property_string(VAR_6, \"bootargs\", VAR_4)));", "_FDT((fdt_property(VAR_6, \"linux,initrd-start\",\n&start_prop, sizeof(start_prop))));", "_FDT((fdt_property(VAR_6, \"linux,initrd-end\",\n&end_prop, sizeof(end_prop))));", "if (VAR_2) {", "uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),", "cpu_to_be64(VAR_2) };", "_FDT((fdt_property(VAR_6, \"qemu,boot-kernel\", &kprop, sizeof(kprop))));", "if (VAR_3) {", "_FDT((fdt_property(VAR_6, \"qemu,boot-kernel-le\", NULL, 0)));", "}", "}", "if (boot_menu) {", "_FDT((fdt_property_cell(VAR_6, \"qemu,boot-menu\", boot_menu)));", "}", "_FDT((fdt_property_cell(VAR_6, \"qemu,graphic-width\", graphic_width)));", "_FDT((fdt_property_cell(VAR_6, \"qemu,graphic-height\", graphic_height)));", "_FDT((fdt_property_cell(VAR_6, \"qemu,graphic-depth\", graphic_depth)));", "_FDT((fdt_end_node(VAR_6)));", "_FDT((fdt_begin_node(VAR_6, \"rtas\")));", "if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {", "add_str(hypertas, \"hcall-multi-tce\");", "}", "_FDT((fdt_property(VAR_6, \"ibm,hypertas-functions\", hypertas->str,\nhypertas->len)));", "g_string_free(hypertas, TRUE);", "_FDT((fdt_property(VAR_6, \"qemu,hypertas-functions\", qemu_hypertas->str,\nqemu_hypertas->len)));", "g_string_free(qemu_hypertas, TRUE);", "_FDT((fdt_property(VAR_6, \"ibm,associativity-reference-points\",\nrefpoints, sizeof(refpoints))));", "_FDT((fdt_property_cell(VAR_6, \"rtas-error-log-max\", RTAS_ERROR_LOG_MAX)));", "_FDT((fdt_property_cell(VAR_6, \"rtas-event-scan-rate\",\nRTAS_EVENT_SCAN_RATE)));", "if (msi_nonbroken) {", "_FDT((fdt_property(VAR_6, \"ibm,change-msix-capable\", NULL, 0)));", "}", "_FDT((fdt_property(VAR_6, \"ibm,extended-os-term\", NULL, 0)));", "_FDT((fdt_end_node(VAR_6)));", "_FDT((fdt_begin_node(VAR_6, \"interrupt-controller\")));", "_FDT((fdt_property_string(VAR_6, \"device_type\",\n\"PowerPC-External-Interrupt-Presentation\")));", "_FDT((fdt_property_string(VAR_6, \"compatible\", \"IBM,ppc-xicp\")));", "_FDT((fdt_property(VAR_6, \"interrupt-controller\", NULL, 0)));", "_FDT((fdt_property(VAR_6, \"ibm,interrupt-server-ranges\",\ninterrupt_server_ranges_prop,\nsizeof(interrupt_server_ranges_prop))));", "_FDT((fdt_property_cell(VAR_6, \"#interrupt-cells\", 2)));", "_FDT((fdt_property_cell(VAR_6, \"linux,phandle\", PHANDLE_XICP)));", "_FDT((fdt_property_cell(VAR_6, \"phandle\", PHANDLE_XICP)));", "_FDT((fdt_end_node(VAR_6)));", "_FDT((fdt_begin_node(VAR_6, \"vdevice\")));", "_FDT((fdt_property_string(VAR_6, \"device_type\", \"vdevice\")));", "_FDT((fdt_property_string(VAR_6, \"compatible\", \"IBM,vdevice\")));", "_FDT((fdt_property_cell(VAR_6, \"#address-cells\", 0x1)));", "_FDT((fdt_property_cell(VAR_6, \"#size-cells\", 0x0)));", "_FDT((fdt_property_cell(VAR_6, \"#interrupt-cells\", 0x2)));", "_FDT((fdt_property(VAR_6, \"interrupt-controller\", NULL, 0)));", "_FDT((fdt_end_node(VAR_6)));", "spapr_events_fdt_skel(VAR_6, VAR_5);", "if (kvm_enabled()) {", "uint8_t hypercall[16];", "_FDT((fdt_begin_node(VAR_6, \"hypervisor\")));", "_FDT((fdt_property_string(VAR_6, \"compatible\", \"linux,kvm\")));", "if (kvmppc_has_cap_fixup_hcalls()) {", "if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,\nsizeof(hypercall))) {", "_FDT((fdt_property(VAR_6, \"hcall-instructions\", hypercall,\nsizeof(hypercall))));", "}", "}", "_FDT((fdt_end_node(VAR_6)));", "}", "_FDT((fdt_end_node(VAR_6)));", "_FDT((fdt_finish(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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123, 125, 127, 129, 131, 133 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 159 ], [ 161 ], [ 167 ], [ 173 ], [ 177 ], [ 179, 181 ], [ 183, 185 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241, 243 ], [ 245 ], [ 249, 251 ], [ 255 ], [ 257, 259 ], [ 263 ], [ 265 ], [ 267 ], [ 285 ], [ 289 ], [ 295 ], [ 299, 301 ], [ 303 ], [ 305 ], [ 307, 309, 311 ], [ 313 ], [ 315 ], [ 317 ], [ 321 ], [ 327 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 345 ], [ 351 ], [ 357 ], [ 359 ], [ 365 ], [ 367 ], [ 369 ], [ 379, 381 ], [ 383, 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 397 ], [ 399 ], [ 403 ], [ 405 ] ]

[ "VAR_4staticVAR_4 VAR_4voidVAR_4 VAR_4__cpu_ppc_store_decrVAR_4(VAR_4PowerPCCPUVAR_4 *VAR_4VAR_0VAR_4, VAR_4uint64_tVAR_4 *VAR_4VAR_1VAR_4,\nVAR_4QEMUTimerVAR_4 *VAR_4VAR_2VAR_4,\nVAR_4voidVAR_4 (*VAR_4VAR_3VAR_4)(VAR_4PowerPCCPUVAR_4 *),\nVAR_4uint32_tVAR_4 VAR_4decrVAR_4, VAR_4uint32_tVAR_4 VAR_4valueVAR_4,\nVAR_4intVAR_4 VAR_4is_excpVAR_4)\n{", "VAR_4CPUPPCStateVAR_4 *VAR_4envVAR_4 = &VAR_4VAR_0VAR_4->VAR_4envVAR_4;", "VAR_4ppc_tb_tVAR_4 *VAR_4tb_envVAR_4 = VAR_4envVAR_4->VAR_4tb_envVAR_4;", "VAR_4uint64_tVAR_4 VAR_4nowVAR_4, VAR_4nextVAR_4;", "VAR_4LOG_TBVAR_4(\"%VAR_4sVAR_4: %VAR_408VAR_4\" VAR_4PRIx32VAR_4 \" => %VAR_408VAR_4\" VAR_4PRIx32VAR_4 \"\\VAR_4nVAR_4\", VAR_4__func__VAR_4,\nVAR_4decrVAR_4, VAR_4valueVAR_4);", "VAR_4ifVAR_4 (VAR_4kvm_enabledVAR_4()) {", "VAR_4returnVAR_4;", "}", "VAR_4nowVAR_4 = VAR_4qemu_clock_get_nsVAR_4(VAR_4QEMU_CLOCK_VIRTUALVAR_4);", "VAR_4nextVAR_4 = VAR_4nowVAR_4 + VAR_4muldiv64VAR_4(VAR_4valueVAR_4, VAR_4get_ticks_per_secVAR_4(), VAR_4tb_envVAR_4->VAR_4decr_freqVAR_4);", "VAR_4ifVAR_4 (VAR_4is_excpVAR_4) {", "VAR_4nextVAR_4 += *VAR_4VAR_1VAR_4 - VAR_4nowVAR_4;", "}", "VAR_4ifVAR_4 (VAR_4nextVAR_4 == VAR_4nowVAR_4) {", "VAR_4nextVAR_4++;", "}", "*VAR_4VAR_1VAR_4 = VAR_4nextVAR_4;", "VAR_4timer_modVAR_4(VAR_4VAR_2VAR_4, VAR_4nextVAR_4);", "VAR_4ifVAR_4 ((VAR_4tb_envVAR_4->VAR_4flagsVAR_4 & VAR_4PPC_DECR_UNDERFLOW_TRIGGEREDVAR_4)\n&& (VAR_4valueVAR_4 & VAR_40x80000000VAR_4)\n&& !(VAR_4decrVAR_4 & VAR_40x80000000VAR_4)) {", "(*VAR_4VAR_3VAR_4)(VAR_4VAR_0VAR_4);", "}", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21, 23 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 67, 69, 71 ], [ 73 ], [ 75 ], [ 77 ] ]

[ "static void FUNC_0(PCIQXLDevice *VAR_0, qxl_async_io VAR_1)\n{", "if (VAR_1) {", "#if SPICE_INTERFACE_QXL_MINOR < 1\nabort();", "#else\nspice_qxl_destroy_surfaces_async(&VAR_0->ssd.VAR_0, 0);", "#endif\n} else {", "VAR_0->ssd.worker->destroy_surfaces(VAR_0->ssd.worker);", "qxl_spice_destroy_surfaces_complete(VAR_0);", "}", "}" ]

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

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

[ "static inline void FUNC_0(TCGv VAR_0, TCGv VAR_1, TCGv VAR_2, int VAR_3, int VAR_4)\n{", "TCGv tmp;", "switch ((VAR_3 << 1) | VAR_4) {", "case 0: gen_helper_neon_mull_s8(VAR_0, VAR_1, VAR_2); break;", "case 1: gen_helper_neon_mull_u8(VAR_0, VAR_1, VAR_2); break;", "case 2: gen_helper_neon_mull_s16(VAR_0, VAR_1, VAR_2); break;", "case 3: gen_helper_neon_mull_u16(VAR_0, VAR_1, VAR_2); break;", "case 4:\ntmp = gen_muls_i64_i32(VAR_1, VAR_2);", "tcg_gen_mov_i64(VAR_0, tmp);", "break;", "case 5:\ntmp = gen_mulu_i64_i32(VAR_1, VAR_2);", "tcg_gen_mov_i64(VAR_0, tmp);", "break;", "default: abort();", "}", "if (VAR_3 < 2) {", "dead_tmp(VAR_2);", "dead_tmp(VAR_1);", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "IMXTimerPState *s = (IMXTimerPState *)VAR_0;", "DPRINTF(\"p-write(VAR_1=%x, VAR_2 = %x)\\n\", (unsigned int)VAR_1 >> 2,\n(unsigned int)VAR_2);", "switch (VAR_1 >> 2) {", "case 0:\nif (VAR_2 & CR_SWR) {", "imx_timerp_reset(&s->busdev.qdev);", "VAR_2 &= ~CR_SWR;", "}", "s->cr = VAR_2 & 0x03ffffff;", "set_timerp_freq(s);", "if (s->freq && (s->cr & CR_EN)) {", "if (!(s->cr & CR_ENMOD)) {", "ptimer_set_count(s->timer, s->lr);", "}", "ptimer_run(s->timer, 0);", "} else {", "ptimer_stop(s->timer);", "}", "break;", "case 1:\ns->int_level = 0;", "imx_timerp_update(s);", "break;", "case 2:\ns->lr = VAR_2;", "ptimer_set_limit(s->timer, VAR_2, !!(s->cr & CR_IOVW));", "break;", "case 3:\ns->cmp = VAR_2;", "if (VAR_2) {", "IPRINTF(\n\"Values for EPIT comparison other than zero not supported\\n\"\n);", "}", "break;", "default:\nIPRINTF(\"FUNC_0: Bad VAR_1 %x\\n\",\n(int)VAR_1 >> 2);", "}", "}" ]

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

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

[ "static int FUNC_0(NBDRequest *VAR_0, struct nbd_reply *VAR_1,\nint VAR_2)\n{", "NBDClient *client = VAR_0->client;", "int VAR_3 = client->sock;", "int VAR_4, VAR_5;", "qemu_co_mutex_lock(&client->send_lock);", "qemu_set_fd_handler2(VAR_3, NULL, nbd_read, nbd_restart_write, client);", "client->send_coroutine = qemu_coroutine_self();", "if (!VAR_2) {", "VAR_4 = nbd_send_reply(VAR_3, VAR_1);", "if (VAR_4 == -1) {", "VAR_4 = -errno;", "}", "} else {", "socket_set_cork(VAR_3, 1);", "VAR_4 = nbd_send_reply(VAR_3, VAR_1);", "if (VAR_4 != -1) {", "VAR_5 = qemu_co_send(VAR_3, VAR_0->data, VAR_2);", "if (VAR_5 != VAR_2) {", "errno = EIO;", "VAR_4 = -1;", "}", "}", "if (VAR_4 == -1) {", "VAR_4 = -errno;", "}", "socket_set_cork(VAR_3, 0);", "}", "client->send_coroutine = NULL;", "qemu_set_fd_handler2(VAR_3, NULL, nbd_read, NULL, client);", "qemu_co_mutex_unlock(&client->send_lock);", "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 ]

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

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

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

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

[ "static int FUNC_0(FsContext *VAR_0, int VAR_1,\nV9fsFidOpenState *VAR_2, int VAR_3)\n{", "int VAR_4;", "if (VAR_1 == P9_FID_DIR) {", "VAR_4 = dirfd(VAR_2->dir);", "} else {", "VAR_4 = VAR_2->VAR_4;", "}", "if (VAR_3) {", "return qemu_fdatasync(VAR_4);", "} else {", "return fsync(VAR_4);", "}", "}" ]

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

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

[ "static int FUNC_0(XenPCIPassthroughState *VAR_0, XenPTReg *VAR_1,\nuint32_t *VAR_2, uint32_t VAR_3)\n{", "XenPTRegInfo *reg = VAR_1->reg;", "uint32_t valid_emu_mask = 0;", "uint32_t bar_emu_mask = 0;", "int VAR_4;", "VAR_4 = xen_pt_bar_offset_to_index(reg->offset);", "if (VAR_4 < 0 || VAR_4 >= PCI_NUM_REGIONS - 1) {", "XEN_PT_ERR(&VAR_0->dev, \"Internal error: Invalid BAR VAR_4 [%d].\\n\", VAR_4);", "return -1;", "}", "*VAR_2 = base_address_with_flags(&VAR_0->real_device.io_regions[VAR_4]);", "switch (VAR_0->bases[VAR_4].bar_flag) {", "case XEN_PT_BAR_FLAG_MEM:\nbar_emu_mask = XEN_PT_BAR_MEM_EMU_MASK;", "break;", "case XEN_PT_BAR_FLAG_IO:\nbar_emu_mask = XEN_PT_BAR_IO_EMU_MASK;", "break;", "case XEN_PT_BAR_FLAG_UPPER:\nbar_emu_mask = XEN_PT_BAR_ALLF;", "break;", "default:\nbreak;", "}", "valid_emu_mask = bar_emu_mask & VAR_3;", "*VAR_2 = XEN_PT_MERGE_VALUE(*VAR_2, VAR_1->data, ~valid_emu_mask);", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ] ]

[ "uint32_t FUNC_0(SSIBus *bus, uint32_t val)\n{", "DeviceState *dev;", "SSISlave *slave;", "dev = LIST_FIRST(&bus->qbus.children);", "if (!dev) {", "return 0;", "}", "slave = SSI_SLAVE_FROM_QDEV(dev);", "return slave->info->transfer(slave, val);", "}" ]

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

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

[ "int FUNC_0(BlockDriverState *VAR_0,\nBlockDriverState *VAR_1,\nint64_t VAR_2,\nint VAR_3, int *VAR_4)\n{", "BlockDriverState *intermediate;", "int VAR_5, VAR_6 = VAR_3;", "intermediate = VAR_0;", "while (intermediate && intermediate != VAR_1) {", "int VAR_7;", "VAR_5 = bdrv_is_allocated(intermediate, VAR_2, VAR_3,\n&VAR_7);", "if (VAR_5 < 0) {", "return VAR_5;", "} else if (VAR_5) {", "*VAR_4 = VAR_7;", "return 1;", "}", "if (VAR_6 > VAR_7 &&\n(intermediate == VAR_0 ||\nVAR_2 + VAR_7 < intermediate->total_sectors)) {", "VAR_6 = VAR_7;", "}", "intermediate = intermediate->backing_hd;", "}", "*VAR_4 = VAR_6;", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 53, 55, 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ] ]

[ "static void FUNC_0(Monitor *VAR_0)\n{", "#ifdef CONFIG_KQEMU\nCPUState *env;", "int val;", "val = 0;", "env = mon_get_cpu();", "if (!env) {", "monitor_printf(VAR_0, \"No cpu initialized yet\");", "return;", "}", "val = env->kqemu_enabled;", "monitor_printf(VAR_0, \"kqemu support: \");", "switch(val) {", "default:\ncase 0:\nmonitor_printf(VAR_0, \"disabled\\n\");", "break;", "case 1:\nmonitor_printf(VAR_0, \"enabled for user code\\n\");", "break;", "case 2:\nmonitor_printf(VAR_0, \"enabled for user and kernel code\\n\");", "break;", "}", "#else\nmonitor_printf(VAR_0, \"kqemu support: not compiled\\n\");", "#endif\n}" ]

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

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