Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "enum AVCodecID FUNC_0(AVOutputFormat *VAR_0, const char *VAR_1,\nconst char *VAR_2, const char *VAR_3,\nenum AVMediaType VAR_4)\n{", "if (av_match_name(\"segment\", VAR_0->name) || av_match_name(\"ssegment\", VAR_0->name)) {", "VAR_0 = av_guess_format(NULL, VAR_2, NULL);", "}", "if (VAR_4 == AVMEDIA_TYPE_VIDEO) {", "enum AVCodecID VAR_5 = AV_CODEC_ID_NONE;", "#if CONFIG_IMAGE2_MUXER\nif (!strcmp(VAR_0->name, \"image2\") || !strcmp(VAR_0->name, \"image2pipe\")) {", "VAR_5 = ff_guess_image2_codec(VAR_2);", "}", "#endif\nif (VAR_5 == AV_CODEC_ID_NONE)\nVAR_5 = VAR_0->video_codec;", "return VAR_5;", "} else if (VAR_4 == AVMEDIA_TYPE_AUDIO)", "return VAR_0->audio_codec;", "else if (VAR_4 == AVMEDIA_TYPE_SUBTITLE)\nreturn VAR_0->subtitle_codec;", "else\nreturn AV_CODEC_ID_NONE;", "}" ]

[ 0, 0, 1, 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 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47, 49 ], [ 51 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, int64_t VAR_1, AVStream **VAR_2)\n{", "AVIOContext *pb = VAR_0->pb;", "int VAR_3;", "*VAR_2 = av_new_stream(VAR_0, 0);", "if (!*VAR_2)\nreturn AVERROR(ENOMEM);", "ff_get_wav_header(pb, (*VAR_2)->codec, VAR_1);", "if (VAR_3 < 0)\nreturn VAR_3;", "(*VAR_2)->need_parsing = AVSTREAM_PARSE_FULL;", "av_set_pts_info(*VAR_2, 64, 1, (*VAR_2)->codec->sample_rate);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13 ], [ 15, 17 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 31 ], [ 35 ], [ 37 ] ]

[ "static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)\n{", "float64 *v = VAR_1;", "*v = make_float64(qemu_get_be64(VAR_0));", "return 0;", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "WebMChunkContext *wc = VAR_0->priv_data;", "AVFormatContext *oc;", "int VAR_1;", "VAR_1 = avformat_alloc_output_context2(&wc->avf, wc->oformat, NULL, NULL);", "if (VAR_1 < 0)\nreturn VAR_1;", "oc = wc->avf;", "oc->interrupt_callback = VAR_0->interrupt_callback;", "oc->max_delay = VAR_0->max_delay;", "av_dict_copy(&oc->metadata, VAR_0->metadata, 0);", "oc->priv_data = av_mallocz(oc->oformat->priv_data_size);", "if (!oc->priv_data) {", "avio_close(oc->pb);", "return AVERROR(ENOMEM);", "}", "*(const AVClass**)oc->priv_data = oc->oformat->priv_class;", "av_opt_set_defaults(oc->priv_data);", "av_opt_set_int(oc->priv_data, \"dash\", 1, 0);", "av_opt_set_int(oc->priv_data, \"cluster_time_limit\", wc->chunk_duration, 0);", "av_opt_set_int(oc->priv_data, \"live\", 1, 0);", "oc->streams = VAR_0->streams;", "oc->nb_streams = VAR_0->nb_streams;", "return 0;", "}" ]

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

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

[ "void FUNC_0(const char *VAR_0, BlockDriverState *VAR_1,\nBlockDriverState *VAR_2, int64_t VAR_3,\nBlockdevOnError VAR_4,\nBlockCompletionFunc *VAR_5,\nvoid *VAR_6, Error **VAR_7)\n{", "int64_t length, base_length;", "int VAR_8;", "int VAR_9;", "Error *local_err = NULL;", "VAR_8 = bdrv_get_flags(VAR_2);", "if (bdrv_reopen(VAR_2, VAR_1->open_flags, VAR_7)) {", "return;", "}", "length = bdrv_getlength(VAR_1);", "if (length < 0) {", "error_setg_errno(VAR_7, -length,\n\"Unable to determine length of %s\", VAR_1->filename);", "goto error_restore_flags;", "}", "base_length = bdrv_getlength(VAR_2);", "if (base_length < 0) {", "error_setg_errno(VAR_7, -base_length,\n\"Unable to determine length of %s\", VAR_2->filename);", "goto error_restore_flags;", "}", "if (length > base_length) {", "VAR_9 = bdrv_truncate(VAR_2, length);", "if (VAR_9 < 0) {", "error_setg_errno(VAR_7, -VAR_9,\n\"Top image %s is larger than VAR_2 image %s, and \"\n\"resize of VAR_2 image failed\",\nVAR_1->filename, VAR_2->filename);", "goto error_restore_flags;", "}", "}", "mirror_start_job(VAR_0, VAR_1, VAR_2, NULL, VAR_3, 0, 0,\nMIRROR_LEAVE_BACKING_CHAIN,\nVAR_4, VAR_4, false, VAR_5, VAR_6, &local_err,\n&commit_active_job_driver, false, VAR_2);", "if (local_err) {", "error_propagate(VAR_7, local_err);", "goto error_restore_flags;", "}", "return;", "error_restore_flags:\nbdrv_reopen(VAR_2, VAR_8, NULL);", "return;", "}" ]

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

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

[ "static void FUNC_0(VirtIOBlockReq *VAR_0, MultiReqBuffer *VAR_1)\n{", "block_acct_start(bdrv_get_stats(VAR_0->dev->bs), &VAR_0->acct, 0,\nBLOCK_ACCT_FLUSH);", "virtio_submit_multiwrite(VAR_0->dev->bs, VAR_1);", "bdrv_aio_flush(VAR_0->dev->bs, virtio_blk_flush_complete, VAR_0);", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5, 7 ], [ 17 ], [ 19 ], [ 21 ] ]

[ "static void FUNC_0(DisasContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,\nTCGv_i64 VAR_4, int VAR_5, int VAR_6)\n{", "TCGLabel *fail_label = gen_new_label();", "TCGLabel *done_label = gen_new_label();", "TCGv_i64 tmp;", "tcg_gen_brcond_i64(TCG_COND_NE, VAR_4, cpu_exclusive_addr, fail_label);", "tmp = tcg_temp_new_i64();", "if (VAR_6) {", "if (VAR_5 == 2) {", "if (VAR_0->be_data == MO_LE) {", "tcg_gen_concat32_i64(tmp, cpu_reg(VAR_0, VAR_2), cpu_reg(VAR_0, VAR_3));", "} else {", "tcg_gen_concat32_i64(tmp, cpu_reg(VAR_0, VAR_3), cpu_reg(VAR_0, VAR_2));", "}", "tcg_gen_atomic_cmpxchg_i64(tmp, cpu_exclusive_addr,\ncpu_exclusive_val, tmp,\nget_mem_index(VAR_0),\nMO_64 | MO_ALIGN | VAR_0->be_data);", "tcg_gen_setcond_i64(TCG_COND_NE, tmp, tmp, cpu_exclusive_val);", "} else if (VAR_0->be_data == MO_LE) {", "gen_helper_paired_cmpxchg64_le(tmp, cpu_env, cpu_exclusive_addr,\ncpu_reg(VAR_0, VAR_2), cpu_reg(VAR_0, VAR_3));", "} else {", "gen_helper_paired_cmpxchg64_be(tmp, cpu_env, cpu_exclusive_addr,\ncpu_reg(VAR_0, VAR_2), cpu_reg(VAR_0, VAR_3));", "}", "} else {", "tcg_gen_atomic_cmpxchg_i64(tmp, cpu_exclusive_addr, cpu_exclusive_val,\ncpu_reg(VAR_0, VAR_2), get_mem_index(VAR_0),\nVAR_5 | MO_ALIGN | VAR_0->be_data);", "tcg_gen_setcond_i64(TCG_COND_NE, tmp, tmp, cpu_exclusive_val);", "}", "tcg_gen_mov_i64(cpu_reg(VAR_0, VAR_1), tmp);", "tcg_temp_free_i64(tmp);", "tcg_gen_br(done_label);", "gen_set_label(fail_label);", "tcg_gen_movi_i64(cpu_reg(VAR_0, VAR_1), 1);", "gen_set_label(done_label);", "tcg_gen_movi_i64(cpu_exclusive_addr, -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 ]

[ [ 1, 3, 5 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 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 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ] ]

[ "void FUNC_0(VirtMachineState *VAR_0, AcpiBuildTables *VAR_1)\n{", "VirtMachineClass *vmc = VIRT_MACHINE_GET_CLASS(VAR_0);", "GArray *table_offsets;", "unsigned VAR_2, VAR_3;", "GArray *tables_blob = VAR_1->table_data;", "table_offsets = g_array_new(false, true ,\nsizeof(uint32_t));", "bios_linker_loader_alloc(VAR_1->linker,\nACPI_BUILD_TABLE_FILE, tables_blob,\n64, false );", "VAR_2 = tables_blob->len;", "build_dsdt(tables_blob, VAR_1->linker, VAR_0);", "acpi_add_table(table_offsets, tables_blob);", "build_fadt(tables_blob, VAR_1->linker, VAR_0, VAR_2);", "acpi_add_table(table_offsets, tables_blob);", "build_madt(tables_blob, VAR_1->linker, VAR_0);", "acpi_add_table(table_offsets, tables_blob);", "build_gtdt(tables_blob, VAR_1->linker, VAR_0);", "acpi_add_table(table_offsets, tables_blob);", "build_mcfg(tables_blob, VAR_1->linker, VAR_0);", "acpi_add_table(table_offsets, tables_blob);", "build_spcr(tables_blob, VAR_1->linker, VAR_0);", "if (nb_numa_nodes > 0) {", "acpi_add_table(table_offsets, tables_blob);", "build_srat(tables_blob, VAR_1->linker, VAR_0);", "}", "if (its_class_name() && !vmc->no_its) {", "acpi_add_table(table_offsets, tables_blob);", "build_iort(tables_blob, VAR_1->linker);", "}", "VAR_3 = tables_blob->len;", "build_rsdt(tables_blob, VAR_1->linker, table_offsets, NULL, NULL);", "build_rsdp(VAR_1->rsdp, VAR_1->linker, VAR_3);", "g_array_free(table_offsets, true);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 21, 23, 25 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 91 ], [ 93 ], [ 99 ], [ 105 ], [ 107 ] ]

[ "static void FUNC_0(QEMUMachineInitArgs *VAR_0, int VAR_1)\n{", "ARMCPU *cpu;", "MemoryRegion *sysmem = get_system_memory();", "MemoryRegion *ram = g_new(MemoryRegion, 1);", "qemu_irq *cpu_pic;", "qemu_irq pic[32];", "qemu_irq sic[32];", "DeviceState *dev, *sysctl;", "SysBusDevice *busdev;", "DeviceState *pl041;", "PCIBus *pci_bus;", "NICInfo *nd;", "i2c_bus *i2c;", "int VAR_2;", "int VAR_3 = 0;", "DriveInfo *dinfo;", "if (!VAR_0->cpu_model) {", "VAR_0->cpu_model = \"arm926\";", "}", "cpu = cpu_arm_init(VAR_0->cpu_model);", "if (!cpu) {", "fprintf(stderr, \"Unable to find CPU definition\\VAR_2\");", "exit(1);", "}", "memory_region_init_ram(ram, \"versatile.ram\", VAR_0->ram_size);", "vmstate_register_ram_global(ram);", "memory_region_add_subregion(sysmem, 0, ram);", "sysctl = qdev_create(NULL, \"realview_sysctl\");", "qdev_prop_set_uint32(sysctl, \"sys_id\", 0x41007004);", "qdev_prop_set_uint32(sysctl, \"proc_id\", 0x02000000);", "qdev_init_nofail(sysctl);", "sysbus_mmio_map(SYS_BUS_DEVICE(sysctl), 0, 0x10000000);", "cpu_pic = arm_pic_init_cpu(cpu);", "dev = sysbus_create_varargs(\"pl190\", 0x10140000,\ncpu_pic[ARM_PIC_CPU_IRQ],\ncpu_pic[ARM_PIC_CPU_FIQ], NULL);", "for (VAR_2 = 0; VAR_2 < 32; VAR_2++) {", "pic[VAR_2] = qdev_get_gpio_in(dev, VAR_2);", "}", "dev = sysbus_create_simple(\"versatilepb_sic\", 0x10003000, NULL);", "for (VAR_2 = 0; VAR_2 < 32; VAR_2++) {", "sysbus_connect_irq(SYS_BUS_DEVICE(dev), VAR_2, pic[VAR_2]);", "sic[VAR_2] = qdev_get_gpio_in(dev, VAR_2);", "}", "sysbus_create_simple(\"pl050_keyboard\", 0x10006000, sic[3]);", "sysbus_create_simple(\"pl050_mouse\", 0x10007000, sic[4]);", "dev = qdev_create(NULL, \"versatile_pci\");", "busdev = SYS_BUS_DEVICE(dev);", "qdev_init_nofail(dev);", "sysbus_mmio_map(busdev, 0, 0x41000000);", "sysbus_mmio_map(busdev, 1, 0x42000000);", "sysbus_connect_irq(busdev, 0, sic[27]);", "sysbus_connect_irq(busdev, 1, sic[28]);", "sysbus_connect_irq(busdev, 2, sic[29]);", "sysbus_connect_irq(busdev, 3, sic[30]);", "pci_bus = (PCIBus *)qdev_get_child_bus(dev, \"pci\");", "for(VAR_2 = 0; VAR_2 < nb_nics; VAR_2++) {", "nd = &nd_table[VAR_2];", "if (!VAR_3 && (!nd->model || strcmp(nd->model, \"smc91c111\") == 0)) {", "smc91c111_init(nd, 0x10010000, sic[25]);", "VAR_3 = 1;", "} else {", "pci_nic_init_nofail(nd, \"rtl8139\", NULL);", "}", "}", "if (usb_enabled(false)) {", "pci_create_simple(pci_bus, -1, \"pci-ohci\");", "}", "VAR_2 = drive_get_max_bus(IF_SCSI);", "while (VAR_2 >= 0) {", "pci_create_simple(pci_bus, -1, \"lsi53c895a\");", "VAR_2--;", "}", "sysbus_create_simple(\"pl011\", 0x101f1000, pic[12]);", "sysbus_create_simple(\"pl011\", 0x101f2000, pic[13]);", "sysbus_create_simple(\"pl011\", 0x101f3000, pic[14]);", "sysbus_create_simple(\"pl011\", 0x10009000, sic[6]);", "sysbus_create_simple(\"pl080\", 0x10130000, pic[17]);", "sysbus_create_simple(\"sp804\", 0x101e2000, pic[4]);", "sysbus_create_simple(\"sp804\", 0x101e3000, pic[5]);", "sysbus_create_simple(\"pl061\", 0x101e4000, pic[6]);", "sysbus_create_simple(\"pl061\", 0x101e5000, pic[7]);", "sysbus_create_simple(\"pl061\", 0x101e6000, pic[8]);", "sysbus_create_simple(\"pl061\", 0x101e7000, pic[9]);", "dev = sysbus_create_simple(\"pl110_versatile\", 0x10120000, pic[16]);", "qdev_connect_gpio_out(sysctl, 0, qdev_get_gpio_in(dev, 0));", "sysbus_create_varargs(\"pl181\", 0x10005000, sic[22], sic[1], NULL);", "sysbus_create_varargs(\"pl181\", 0x1000b000, sic[23], sic[2], NULL);", "sysbus_create_simple(\"pl031\", 0x101e8000, pic[10]);", "dev = sysbus_create_simple(\"versatile_i2c\", 0x10002000, NULL);", "i2c = (i2c_bus *)qdev_get_child_bus(dev, \"i2c\");", "i2c_create_slave(i2c, \"ds1338\", 0x68);", "pl041 = qdev_create(NULL, \"pl041\");", "qdev_prop_set_uint32(pl041, \"nc_fifo_depth\", 512);", "qdev_init_nofail(pl041);", "sysbus_mmio_map(SYS_BUS_DEVICE(pl041), 0, 0x10004000);", "sysbus_connect_irq(SYS_BUS_DEVICE(pl041), 0, sic[24]);", "dinfo = drive_get(IF_PFLASH, 0, 0);", "if (!pflash_cfi01_register(VERSATILE_FLASH_ADDR, NULL, \"versatile.flash\",\nVERSATILE_FLASH_SIZE, dinfo ? dinfo->bdrv : NULL,\nVERSATILE_FLASH_SECT_SIZE,\nVERSATILE_FLASH_SIZE / VERSATILE_FLASH_SECT_SIZE,\n4, 0x0089, 0x0018, 0x0000, 0x0, 0)) {", "fprintf(stderr, \"qemu: Error registering flash memory.\\VAR_2\");", "}", "versatile_binfo.ram_size = VAR_0->ram_size;", "versatile_binfo.kernel_filename = VAR_0->kernel_filename;", "versatile_binfo.kernel_cmdline = VAR_0->kernel_cmdline;", "versatile_binfo.initrd_filename = VAR_0->initrd_filename;", "versatile_binfo.VAR_1 = VAR_1;", "arm_load_kernel(cpu, &versatile_binfo);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79, 81, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 205 ], [ 209 ], [ 213 ], [ 215 ], [ 221 ], [ 225 ], [ 227 ], [ 229 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 321 ], [ 323, 325, 327, 329, 331 ], [ 333 ], [ 335 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ] ]

[ "static int FUNC_0(RA144Context *VAR_0, int16_t *VAR_1, int VAR_2,\nint VAR_3, int VAR_4)\n{", "int VAR_5[10];", "int VAR_6 = VAR_2 + 1;", "int VAR_7 = NBLOCKS - VAR_6;", "int VAR_8;", "for (VAR_8=0; VAR_8<30; VAR_8++)", "VAR_1[VAR_8] = (VAR_6 * VAR_0->lpc_coef[0][VAR_8] + VAR_7 * VAR_0->lpc_coef[1][VAR_8])>> 2;", "if (eval_refl(VAR_5, VAR_1, VAR_0)) {", "int_to_int16(VAR_1, VAR_0->lpc_coef[VAR_3]);", "return rescale_rms(VAR_0->lpc_refl_rms[VAR_3], VAR_4);", "} else {", "return rescale_rms(rms(VAR_5), VAR_4);", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 21 ], [ 23 ], [ 27 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ] ]

[ "FUNC_0(VAR_0)\nstruct socket *VAR_0;", "{", "struct sockaddr_in VAR_1;", "int VAR_2 = sizeof(struct sockaddr_in);", "DEBUG_CALL(\"FUNC_0\");", "DEBUG_ARG(\"VAR_0 = %lx\", (long)VAR_0);", "if (VAR_0->so_type == IPPROTO_ICMP) {", "char VAR_3[256];", "int VAR_6;", "VAR_6 = recvfrom(VAR_0->s, VAR_3, 256, 0,\n(struct sockaddr *)&VAR_1, &VAR_2);", "if(VAR_6 == -1 || VAR_6 == 0) {", "u_char code=ICMP_UNREACH_PORT;", "if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;", "else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;", "DEBUG_MISC((dfd,\" udp icmp rx errno = %d-%s\\VAR_6\",\nerrno,strerror(errno)));", "icmp_error(VAR_0->so_m, ICMP_UNREACH,code, 0,strerror(errno));", "} else {", "icmp_reflect(VAR_0->so_m);", "VAR_0->so_m = 0;", "}", "udp_detach(VAR_0);", "} else {", "struct mbuf *VAR_5;", "int VAR_6, VAR_6;", "if (!(VAR_5 = m_get())) return;", "VAR_5->m_data += IF_MAXLINKHDR;", "VAR_6 = M_FREEROOM(VAR_5);", "ioctlsocket(VAR_0->s, FIONREAD, &VAR_6);", "if (VAR_6 > VAR_6) {", "VAR_6 = (VAR_5->m_data - VAR_5->m_dat) + VAR_5->m_len + VAR_6 + 1;", "m_inc(VAR_5, VAR_6);", "VAR_6 = M_FREEROOM(VAR_5);", "}", "VAR_5->m_len = recvfrom(VAR_0->s, VAR_5->m_data, VAR_6, 0,\n(struct sockaddr *)&VAR_1, &VAR_2);", "DEBUG_MISC((dfd, \" did recvfrom %d, errno = %d-%s\\VAR_6\",\nVAR_5->m_len, errno,strerror(errno)));", "if(VAR_5->m_len<0) {", "u_char code=ICMP_UNREACH_PORT;", "if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;", "else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;", "DEBUG_MISC((dfd,\" rx error, tx icmp ICMP_UNREACH:%i\\VAR_6\", code));", "icmp_error(VAR_0->so_m, ICMP_UNREACH,code, 0,strerror(errno));", "m_free(VAR_5);", "} else {", "if (VAR_0->so_expire) {", "if (VAR_0->so_fport == htons(53))\nVAR_0->so_expire = curtime + SO_EXPIREFAST;", "else\nVAR_0->so_expire = curtime + SO_EXPIRE;", "}", "udp_output(VAR_0, VAR_5, &VAR_1);", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 87 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 109, 111 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 149 ], [ 151, 153 ], [ 155, 157 ], [ 159 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ] ]

[ "char *FUNC_0(const char *VAR_0, bool VAR_1,\nint64_t VAR_2, Error **VAR_3)\n{", "char *VAR_4 = NULL;", "Monitor *old_mon, hmp;", "memset(&hmp, 0, sizeof(hmp));", "hmp.outbuf = qstring_new();", "hmp.skip_flush = true;", "old_mon = cur_mon;", "cur_mon = &hmp;", "if (VAR_1) {", "int VAR_5 = monitor_set_cpu(VAR_2);", "if (VAR_5 < 0) {", "cur_mon = old_mon;", "error_set(VAR_3, QERR_INVALID_PARAMETER_VALUE, \"cpu-index\",\n\"a CPU number\");", "goto out;", "}", "}", "handle_user_command(&hmp, VAR_0);", "cur_mon = old_mon;", "if (qstring_get_length(hmp.outbuf) > 0) {", "VAR_4 = g_strdup(qstring_get_str(hmp.outbuf));", "} else {", "VAR_4 = g_strdup(\"\");", "}", "out:\nQDECREF(hmp.outbuf);", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65, 67 ], [ 69 ], [ 71 ] ]

[ "static void FUNC_0(int VAR_0, const char **VAR_1)\n{", "if (VAR_0 != 2) {", "help_cmd(VAR_1[0]);", "return;", "}", "vga_screen_dump(VAR_1[1]);", "}" ]

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

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

[ "static int FUNC_0(USBNetState *VAR_0, uint8_t *VAR_1)\n{", "int VAR_2 = 0;", "struct rndis_response *VAR_3 = VAR_0->rndis_resp.tqh_first;", "if (!VAR_3)\nreturn VAR_2;", "TAILQ_REMOVE(&VAR_0->rndis_resp, VAR_3, entries);", "VAR_2 = VAR_3->length;", "memcpy(VAR_1, VAR_3->VAR_1, VAR_3->length);", "qemu_free(VAR_3);", "return VAR_2;", "}" ]

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

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

[ "FUNC_0(VAR_0)\n{", "int VAR_1;", "struct {", "const char *encoded;", "const char *decoded;", "} VAR_2[] = {", "{ \"'hello world'\", \"hello world\" },", "{ \"'the quick brown fox \\\\' jumped over the fence'\",", "\"the quick brown fox ' jumped over the fence\" },", "{}", "};", "for (VAR_1 = 0; VAR_2[VAR_1].encoded; VAR_1++) {", "QObject *obj;", "QString *str;", "obj = qobject_from_json(VAR_2[VAR_1].encoded);", "fail_unless(obj != NULL);", "fail_unless(qobject_type(obj) == QTYPE_QSTRING);", "str = qobject_to_qstring(obj);", "fail_unless(strcmp(qstring_get_str(str), VAR_2[VAR_1].decoded) == 0);", "QDECREF(str);", "}", "}" ]

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

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

[ "static inline void FUNC_0(CPUMIPSState *VAR_0)\n{", "VAR_0->hflags &= ~(MIPS_HFLAG_COP1X | MIPS_HFLAG_64 | MIPS_HFLAG_CP0 |\nMIPS_HFLAG_F64 | MIPS_HFLAG_FPU | MIPS_HFLAG_KSU |\nMIPS_HFLAG_UX);", "if (!(VAR_0->CP0_Status & (1 << CP0St_EXL)) &&\n!(VAR_0->CP0_Status & (1 << CP0St_ERL)) &&\n!(VAR_0->hflags & MIPS_HFLAG_DM)) {", "VAR_0->hflags |= (VAR_0->CP0_Status >> CP0St_KSU) & MIPS_HFLAG_KSU;", "}", "#if defined(TARGET_MIPS64)\nif (((VAR_0->hflags & MIPS_HFLAG_KSU) != MIPS_HFLAG_UM) ||\n(VAR_0->CP0_Status & (1 << CP0St_PX)) ||\n(VAR_0->CP0_Status & (1 << CP0St_UX))) {", "VAR_0->hflags |= MIPS_HFLAG_64;", "}", "if (VAR_0->CP0_Status & (1 << CP0St_UX)) {", "VAR_0->hflags |= MIPS_HFLAG_UX;", "}", "#endif\nif ((VAR_0->CP0_Status & (1 << CP0St_CU0)) ||\n!(VAR_0->hflags & MIPS_HFLAG_KSU)) {", "VAR_0->hflags |= MIPS_HFLAG_CP0;", "}", "if (VAR_0->CP0_Status & (1 << CP0St_CU1)) {", "VAR_0->hflags |= MIPS_HFLAG_FPU;", "}", "if (VAR_0->CP0_Status & (1 << CP0St_FR)) {", "VAR_0->hflags |= MIPS_HFLAG_F64;", "}", "if (VAR_0->insn_flags & ISA_MIPS32R2) {", "if (VAR_0->active_fpu.fcr0 & (1 << FCR0_F64)) {", "VAR_0->hflags |= MIPS_HFLAG_COP1X;", "}", "} else if (VAR_0->insn_flags & ISA_MIPS32) {", "if (VAR_0->hflags & MIPS_HFLAG_64) {", "VAR_0->hflags |= MIPS_HFLAG_COP1X;", "}", "} else if (VAR_0->insn_flags & ISA_MIPS4) {", "if (VAR_0->CP0_Status & (1 << CP0St_CU3)) {", "VAR_0->hflags |= MIPS_HFLAG_COP1X;", "}", "}", "}" ]

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

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

[ "static void FUNC_0(VirtIODevice *VAR_0, VirtQueue *VAR_1)\n{", "V9fsVirtioState *v = (V9fsVirtioState *)VAR_0;", "V9fsState *s = &v->state;", "V9fsPDU *pdu;", "ssize_t len;", "while ((pdu = pdu_alloc(s))) {", "struct {", "uint32_t size_le;", "uint8_t id;", "uint16_t tag_le;", "} QEMU_PACKED VAR_2;", "VirtQueueElement *elem = &v->elems[pdu->idx];", "len = virtqueue_pop(VAR_1, elem);", "if (!len) {", "pdu_free(pdu);", "break;", "}", "BUG_ON(elem->out_num == 0 || elem->in_num == 0);", "QEMU_BUILD_BUG_ON(sizeof VAR_2 != 7);", "len = iov_to_buf(elem->out_sg, elem->out_num, 0,\n&VAR_2, sizeof VAR_2);", "BUG_ON(len != sizeof VAR_2);", "pdu->size = le32_to_cpu(VAR_2.size_le);", "pdu->id = VAR_2.id;", "pdu->tag = le16_to_cpu(VAR_2.tag_le);", "qemu_co_queue_init(&pdu->complete);", "pdu_submit(pdu);", "}", "}" ]

[ 0, 0, 0, 0, 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 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 49, 51 ], [ 53 ], [ 57 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ] ]

[ "hwaddr FUNC_0(CPUPPCState *env, target_ulong addr)\n{", "struct mmu_ctx_hash64 VAR_0;", "if (unlikely(ppc_hash64_get_physical_address(env, &VAR_0, addr, 0, ACCESS_INT)\n!= 0)) {", "return -1;", "}", "return VAR_0.raddr & TARGET_PAGE_MASK;", "}" ]

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

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

[ "int FUNC_0(FFFrameSync *VAR_0, AVFilterLink *VAR_1)\n{", "AVFilterContext *ctx = VAR_1->src;", "int VAR_2, VAR_3;", "if ((VAR_3 = ff_framesync_process_frame(VAR_0, 0)) < 0)\nreturn VAR_3;", "if (VAR_3 > 0)\nreturn 0;", "if (VAR_0->eof)\nreturn AVERROR_EOF;", "VAR_2 = VAR_0->in_request;", "VAR_3 = ff_request_frame(ctx->inputs[VAR_2]);", "if (VAR_3 == AVERROR_EOF) {", "if ((VAR_3 = ff_framesync_add_frame(VAR_0, VAR_2, NULL)) < 0)\nreturn VAR_3;", "if ((VAR_3 = ff_framesync_process_frame(VAR_0, 0)) < 0)\nreturn VAR_3;", "VAR_3 = 0;", "}", "return VAR_3;", "}" ]

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

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

[ "int FUNC_0(S390CPU *VAR_0, uint8_t VAR_1, uint8_t VAR_2)\n{", "CPUS390XState *env = &VAR_0->env;", "S390PCIBusDevice *pbdev;", "uint64_t offset;", "uint64_t data;", "uint8_t len;", "uint32_t fh;", "uint8_t pcias;", "cpu_synchronize_state(CPU(VAR_0));", "if (env->psw.mask & PSW_MASK_PSTATE) {", "program_interrupt(env, PGM_PRIVILEGED, 4);", "return 0;", "}", "if (VAR_2 & 0x1) {", "program_interrupt(env, PGM_SPECIFICATION, 4);", "return 0;", "}", "fh = env->regs[VAR_2] >> 32;", "pcias = (env->regs[VAR_2] >> 16) & 0xf;", "len = env->regs[VAR_2] & 0xf;", "offset = env->regs[VAR_2 + 1];", "pbdev = s390_pci_find_dev_by_fh(fh);", "if (!pbdev || !(pbdev->fh & FH_MASK_ENABLE)) {", "DPRINTF(\"pcilg no pci dev\\n\");", "setcc(VAR_0, ZPCI_PCI_LS_INVAL_HANDLE);", "return 0;", "}", "if (pbdev->lgstg_blocked) {", "setcc(VAR_0, ZPCI_PCI_LS_ERR);", "s390_set_status_code(env, VAR_2, ZPCI_PCI_ST_BLOCKED);", "return 0;", "}", "if (pcias < 6) {", "if ((8 - (offset & 0x7)) < len) {", "program_interrupt(env, PGM_OPERAND, 4);", "return 0;", "}", "MemoryRegion *mr = pbdev->pdev->io_regions[pcias].memory;", "memory_region_dispatch_read(mr, offset, &data, len,\nMEMTXATTRS_UNSPECIFIED);", "} else if (pcias == 15) {", "if ((4 - (offset & 0x3)) < len) {", "program_interrupt(env, PGM_OPERAND, 4);", "return 0;", "}", "data = pci_host_config_read_common(\npbdev->pdev, offset, pci_config_size(pbdev->pdev), len);", "switch (len) {", "case 1:\nbreak;", "case 2:\ndata = bswap16(data);", "break;", "case 4:\ndata = bswap32(data);", "break;", "case 8:\ndata = bswap64(data);", "break;", "default:\nprogram_interrupt(env, PGM_OPERAND, 4);", "return 0;", "}", "} else {", "DPRINTF(\"invalid space\\n\");", "setcc(VAR_0, ZPCI_PCI_LS_ERR);", "s390_set_status_code(env, VAR_2, ZPCI_PCI_ST_INVAL_AS);", "return 0;", "}", "env->regs[VAR_1] = data;", "setcc(VAR_0, ZPCI_PCI_LS_OK);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 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 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ] ]

[ "static Jpeg2000TgtNode *FUNC_0(int w, int h)\n{", "int VAR_0 = w, VAR_1 = h;", "Jpeg2000TgtNode *res, *t, *t2;", "int32_t tt_size;", "tt_size = tag_tree_size(w, h);", "if (tt_size == -1)\nreturn NULL;", "t = res = av_mallocz_array(tt_size, sizeof(*t));", "if (!res)\nreturn NULL;", "while (w > 1 || h > 1) {", "int VAR_2, VAR_3;", "VAR_0 = w;", "VAR_1 = h;", "w = (w + 1) >> 1;", "h = (h + 1) >> 1;", "t2 = t + VAR_0 * VAR_1;", "for (VAR_2 = 0; VAR_2 < VAR_1; VAR_2++)", "for (VAR_3 = 0; VAR_3 < VAR_0; VAR_3++)", "t[VAR_2 * VAR_0 + VAR_3].parent = &t2[(VAR_2 >> 1) * w + (VAR_3 >> 1)];", "t = t2;", "}", "t[0].parent = NULL;", "return res;", "}" ]

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

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

[ "int FUNC_0(CPUState *VAR_0, int VAR_1)\n{", "struct kvm_one_reg VAR_2;", "uint32_t fpr;", "uint64_t val;", "int VAR_3;", "int VAR_4;", "ARMCPU *cpu = ARM_CPU(VAR_0);", "CPUARMState *env = &cpu->env;", "if (!is_a64(env)) {", "aarch64_sync_32_to_64(env);", "}", "for (VAR_3 = 0; VAR_3 < 31; VAR_3++) {", "VAR_2.id = AARCH64_CORE_REG(regs.regs[VAR_3]);", "VAR_2.addr = (uintptr_t) &env->xregs[VAR_3];", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "}", "aarch64_save_sp(env, 1);", "VAR_2.id = AARCH64_CORE_REG(regs.sp);", "VAR_2.addr = (uintptr_t) &env->sp_el[0];", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "VAR_2.id = AARCH64_CORE_REG(sp_el1);", "VAR_2.addr = (uintptr_t) &env->sp_el[1];", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "if (is_a64(env)) {", "val = pstate_read(env);", "} else {", "val = cpsr_read(env);", "}", "VAR_2.id = AARCH64_CORE_REG(regs.pstate);", "VAR_2.addr = (uintptr_t) &val;", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "VAR_2.id = AARCH64_CORE_REG(regs.pc);", "VAR_2.addr = (uintptr_t) &env->pc;", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "VAR_2.id = AARCH64_CORE_REG(elr_el1);", "VAR_2.addr = (uintptr_t) &env->elr_el[1];", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "for (VAR_3 = 0; VAR_3 < KVM_NR_SPSR; VAR_3++) {", "VAR_2.id = AARCH64_CORE_REG(spsr[VAR_3]);", "VAR_2.addr = (uintptr_t) &env->banked_spsr[VAR_3 - 1];", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "}", "for (VAR_3 = 0; VAR_3 < 32; VAR_3++) {", "int VAR_5 = VAR_3 << 1;", "uint64_t fp_val[2];", "#ifdef HOST_WORDS_BIGENDIAN\nfp_val[0] = env->vfp.regs[VAR_5 + 1];", "fp_val[1] = env->vfp.regs[VAR_5];", "#else\nfp_val[1] = env->vfp.regs[VAR_5 + 1];", "fp_val[0] = env->vfp.regs[VAR_5];", "#endif\nVAR_2.id = AARCH64_SIMD_CORE_REG(fp_regs.vregs[VAR_3]);", "VAR_2.addr = (uintptr_t)(&fp_val);", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "}", "VAR_2.addr = (uintptr_t)(&fpr);", "fpr = vfp_get_fpsr(env);", "VAR_2.id = AARCH64_SIMD_CTRL_REG(fp_regs.fpsr);", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "fpr = vfp_get_fpcr(env);", "VAR_2.id = AARCH64_SIMD_CTRL_REG(fp_regs.fpcr);", "VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);", "if (VAR_4) {", "return VAR_4;", "}", "if (!write_list_to_kvmstate(cpu)) {", "return EINVAL;", "}", "kvm_arm_sync_mpstate_to_kvm(cpu);", "return VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 171 ], [ 173 ], [ 175 ], [ 177, 179 ], [ 181 ], [ 183, 185 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 237 ], [ 239 ], [ 241 ], [ 245 ], [ 249 ], [ 251 ] ]

[ "static void FUNC_0(DisplayState *VAR_0)\n{", "SDL_Event ev1, *ev = &ev1;", "int VAR_1;", "int VAR_2 = SDL_GetMouseState(NULL, NULL);", "if (last_vm_running != vm_running) {", "last_vm_running = vm_running;", "sdl_update_caption();", "}", "vga_hw_update();", "SDL_EnableUNICODE(!is_graphic_console());", "while (SDL_PollEvent(ev)) {", "switch (ev->type) {", "case SDL_VIDEOEXPOSE:\nsdl_update(VAR_0, 0, 0, screen->w, screen->h);", "break;", "case SDL_KEYDOWN:\ncase SDL_KEYUP:\nif (ev->type == SDL_KEYDOWN) {", "if (!alt_grab) {", "VAR_1 = (SDL_GetModState() & gui_grab_code) ==\ngui_grab_code;", "} else {", "VAR_1 = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==\n(gui_grab_code | KMOD_LSHIFT);", "}", "gui_key_modifier_pressed = VAR_1;", "if (gui_key_modifier_pressed) {", "int VAR_3;", "VAR_3 = sdl_keyevent_to_keycode(&ev->key);", "switch(VAR_3) {", "case 0x21:\ntoggle_full_screen(VAR_0);", "gui_keysym = 1;", "break;", "case 0x02 ... 0x0a:\nreset_keys();", "console_select(VAR_3 - 0x02);", "if (!is_graphic_console()) {", "if (gui_grab)\nsdl_grab_end();", "}", "gui_keysym = 1;", "break;", "default:\nbreak;", "}", "} else if (!is_graphic_console()) {", "int VAR_4;", "VAR_4 = 0;", "if (ev->key.VAR_4.mod & (KMOD_LCTRL | KMOD_RCTRL)) {", "switch(ev->key.VAR_4.sym) {", "case SDLK_UP: VAR_4 = QEMU_KEY_CTRL_UP; break;", "case SDLK_DOWN: VAR_4 = QEMU_KEY_CTRL_DOWN; break;", "case SDLK_LEFT: VAR_4 = QEMU_KEY_CTRL_LEFT; break;", "case SDLK_RIGHT: VAR_4 = QEMU_KEY_CTRL_RIGHT; break;", "case SDLK_HOME: VAR_4 = QEMU_KEY_CTRL_HOME; break;", "case SDLK_END: VAR_4 = QEMU_KEY_CTRL_END; break;", "case SDLK_PAGEUP: VAR_4 = QEMU_KEY_CTRL_PAGEUP; break;", "case SDLK_PAGEDOWN: VAR_4 = QEMU_KEY_CTRL_PAGEDOWN; break;", "default: break;", "}", "} else {", "switch(ev->key.VAR_4.sym) {", "case SDLK_UP: VAR_4 = QEMU_KEY_UP; break;", "case SDLK_DOWN: VAR_4 = QEMU_KEY_DOWN; break;", "case SDLK_LEFT: VAR_4 = QEMU_KEY_LEFT; break;", "case SDLK_RIGHT: VAR_4 = QEMU_KEY_RIGHT; break;", "case SDLK_HOME: VAR_4 = QEMU_KEY_HOME; break;", "case SDLK_END: VAR_4 = QEMU_KEY_END; break;", "case SDLK_PAGEUP: VAR_4 = QEMU_KEY_PAGEUP; break;", "case SDLK_PAGEDOWN: VAR_4 = QEMU_KEY_PAGEDOWN; break;", "case SDLK_BACKSPACE: VAR_4 = QEMU_KEY_BACKSPACE; break;", "case SDLK_DELETE: VAR_4 = QEMU_KEY_DELETE; break;", "default: break;", "}", "}", "if (VAR_4) {", "kbd_put_keysym(VAR_4);", "} else if (ev->key.VAR_4.unicode != 0) {", "kbd_put_keysym(ev->key.VAR_4.unicode);", "}", "}", "} else if (ev->type == SDL_KEYUP) {", "if (!alt_grab) {", "VAR_1 = (ev->key.VAR_4.mod & gui_grab_code);", "} else {", "VAR_1 = (ev->key.VAR_4.mod &\n(gui_grab_code | KMOD_LSHIFT));", "}", "if (!VAR_1) {", "if (gui_key_modifier_pressed) {", "gui_key_modifier_pressed = 0;", "if (gui_keysym == 0) {", "if (!gui_grab) {", "if (SDL_GetAppState() & SDL_APPACTIVE)\nsdl_grab_start();", "} else {", "sdl_grab_end();", "}", "reset_keys();", "break;", "}", "gui_keysym = 0;", "}", "}", "}", "if (is_graphic_console() && !gui_keysym)\nsdl_process_key(&ev->key);", "break;", "case SDL_QUIT:\nif (!no_quit) {", "qemu_system_shutdown_request();", "vm_start();", "}", "break;", "case SDL_MOUSEMOTION:\nif (gui_grab || kbd_mouse_is_absolute() ||\nabsolute_enabled) {", "sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,\nev->motion.x, ev->motion.y, ev->motion.state);", "}", "break;", "case SDL_MOUSEBUTTONDOWN:\ncase SDL_MOUSEBUTTONUP:\n{", "SDL_MouseButtonEvent *bev = &ev->button;", "if (!gui_grab && !kbd_mouse_is_absolute()) {", "if (ev->type == SDL_MOUSEBUTTONDOWN &&\n(bev->button == SDL_BUTTON_LEFT)) {", "sdl_grab_start();", "}", "} else {", "int VAR_5;", "VAR_5 = 0;", "if (ev->type == SDL_MOUSEBUTTONDOWN) {", "VAR_2 |= SDL_BUTTON(bev->button);", "} else {", "VAR_2 &= ~SDL_BUTTON(bev->button);", "}", "#ifdef SDL_BUTTON_WHEELUP\nif (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {", "VAR_5 = -1;", "} else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {", "VAR_5 = 1;", "}", "#endif\nsdl_send_mouse_event(0, 0, VAR_5, bev->x, bev->y, VAR_2);", "}", "}", "break;", "case SDL_ACTIVEEVENT:\nif (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&\n!ev->active.gain && !gui_fullscreen_initial_grab) {", "sdl_grab_end();", "}", "if (ev->active.state & SDL_APPACTIVE) {", "if (ev->active.gain) {", "VAR_0->gui_timer_interval = 0;", "} else {", "VAR_0->gui_timer_interval = 500;", "}", "}", "break;", "default:\nbreak;", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39, 41, 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77, 81 ], [ 83 ], [ 85 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 215, 217 ], [ 219 ], [ 221 ], [ 223 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243, 245 ], [ 247 ], [ 249, 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261, 263, 265 ], [ 267, 269 ], [ 271 ], [ 273 ], [ 275, 277, 279 ], [ 281 ], [ 283 ], [ 285, 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311, 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323, 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333, 335, 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 349 ], [ 351 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363, 365 ], [ 367 ], [ 369 ], [ 371 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nsize_t VAR_2)\n{", "int64_t len;", "if (VAR_2 > INT_MAX) {", "return -EIO;", "}", "if (!bdrv_is_inserted(VAR_0))\nreturn -ENOMEDIUM;", "if (VAR_0->growable)\nreturn 0;", "len = bdrv_getlength(VAR_0);", "if (VAR_1 < 0)\nreturn -EIO;", "if ((VAR_1 > len) || (len - VAR_1 < VAR_2))\nreturn -EIO;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(SwsContext *VAR_0, const uint8_t *VAR_1[],\nint VAR_2[], int VAR_3, int VAR_4,\nuint8_t *VAR_5[], int VAR_6[])\n{", "const uint16_t *VAR_7[] = { (uint16_t *)VAR_1[1], (uint16_t *)VAR_1[0], (uint16_t *)VAR_1[2] };", "const uint16_t *VAR_8[] = { (uint16_t *)VAR_1[2], (uint16_t *)VAR_1[0], (uint16_t *)VAR_1[1] };", "int VAR_9[] = { VAR_2[1], VAR_2[0], VAR_2[2] };", "int VAR_10[] = { VAR_2[2], VAR_2[0], VAR_2[1] };", "const AVPixFmtDescriptor *VAR_11 = av_pix_fmt_desc_get(VAR_0->srcFormat);", "const AVPixFmtDescriptor *VAR_12 = av_pix_fmt_desc_get(VAR_0->dstFormat);", "int VAR_13 = VAR_11->comp[0].depth_minus1 + 1;", "int VAR_14 = 0;", "if ( HAVE_BIGENDIAN && !(VAR_11->flags & AV_PIX_FMT_FLAG_BE) ||\n!HAVE_BIGENDIAN && VAR_11->flags & AV_PIX_FMT_FLAG_BE)\nVAR_14++;", "if ( HAVE_BIGENDIAN && !(VAR_12->flags & AV_PIX_FMT_FLAG_BE) ||\n!HAVE_BIGENDIAN && VAR_12->flags & AV_PIX_FMT_FLAG_BE)\nVAR_14 += 2;", "if ((VAR_11->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) !=\n(AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) {", "av_log(VAR_0, AV_LOG_ERROR, \"unsupported planar RGB conversion %s -> %s\\n\",\nVAR_11->name, VAR_12->name);", "return VAR_4;", "}", "switch (VAR_0->dstFormat) {", "case AV_PIX_FMT_BGR48LE:\ncase AV_PIX_FMT_BGR48BE:\ngbr16ptopacked16(VAR_7, VAR_9,\nVAR_5[0] + VAR_3 * VAR_6[0], VAR_6[0],\nVAR_4, 0, VAR_14, VAR_13, VAR_0->srcW);", "break;", "case AV_PIX_FMT_RGB48LE:\ncase AV_PIX_FMT_RGB48BE:\ngbr16ptopacked16(VAR_8, VAR_10,\nVAR_5[0] + VAR_3 * VAR_6[0], VAR_6[0],\nVAR_4, 0, VAR_14, VAR_13, VAR_0->srcW);", "break;", "case AV_PIX_FMT_RGBA64LE:\ncase AV_PIX_FMT_RGBA64BE:\ngbr16ptopacked16(VAR_8, VAR_10,\nVAR_5[0] + VAR_3 * VAR_6[0], VAR_6[0],\nVAR_4, 1, VAR_14, VAR_13, VAR_0->srcW);", "break;", "case AV_PIX_FMT_BGRA64LE:\ncase AV_PIX_FMT_BGRA64BE:\ngbr16ptopacked16(VAR_7, VAR_9,\nVAR_5[0] + VAR_3 * VAR_6[0], VAR_6[0],\nVAR_4, 1, VAR_14, VAR_13, VAR_0->srcW);", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR,\n\"unsupported planar RGB conversion %s -> %s\\n\",\nVAR_11->name, VAR_12->name);", "}", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27, 29 ], [ 31, 33, 35 ], [ 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 ], [ 113 ], [ 115 ] ]

[ "void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1, int VAR_2, int VAR_3)\n{", "POWERPC_TBL_DECLARE(altivec_put_pixels16_num, 1);", "#ifdef ALTIVEC_USE_REFERENCE_C_CODE\nint VAR_6;", "POWERPC_TBL_START_COUNT(altivec_put_pixels16_num, 1);", "for(VAR_6=0; VAR_6<VAR_3; VAR_6++) {", "*((uint32_t*)(VAR_0 )) = (((const struct unaligned_32 *) (VAR_1))->l);", "*((uint32_t*)(VAR_0+4)) = (((const struct unaligned_32 *) (VAR_1+4))->l);", "*((uint32_t*)(VAR_0+8)) = (((const struct unaligned_32 *) (VAR_1+8))->l);", "*((uint32_t*)(VAR_0+12)) = (((const struct unaligned_32 *) (VAR_1+12))->l);", "VAR_1+=VAR_2;", "VAR_0 +=VAR_2;", "}", "POWERPC_TBL_STOP_COUNT(altivec_put_pixels16_num, 1);", "#else\nregister vector unsigned char VAR_4, pixelsv2;", "register vector unsigned char VAR_5 = vec_lvsl(0, VAR_1);", "int VAR_6;", "POWERPC_TBL_START_COUNT(altivec_put_pixels16_num, 1);", "for(VAR_6=0; VAR_6<VAR_3; VAR_6++) {", "VAR_4 = vec_ld(0, (unsigned char*)VAR_1);", "pixelsv2 = vec_ld(16, (unsigned char*)VAR_1);", "vec_st(vec_perm(VAR_4, pixelsv2, VAR_5),\n0, (unsigned char*)VAR_0);", "VAR_1+=VAR_2;", "VAR_0 +=VAR_2;", "}", "POWERPC_TBL_STOP_COUNT(altivec_put_pixels16_num, 1);", "#endif\n}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7, 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 75, 77 ] ]

[ "static ssize_t FUNC_0(gnutls_transport_ptr_t transport,\nvoid *data,\nsize_t len) {", "struct VncState *VAR_0 = (struct VncState *)transport;", "int VAR_1;", "retry:\nVAR_1 = recv(VAR_0->csock, data, len, 0);", "if (VAR_1 < 0) {", "if (errno == EINTR)\ngoto retry;", "return -1;", "}", "return VAR_1;", "}" ]

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

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

[ "static bool FUNC_0(PCIDevice *dev, const PCIEAERMsg *msg)\n{", "bool msg_sent;", "uint16_t cmd;", "uint8_t *aer_cap;", "uint32_t root_cmd;", "uint32_t root_status;", "bool msi_trigger;", "msg_sent = false;", "cmd = pci_get_word(dev->config + PCI_COMMAND);", "aer_cap = dev->config + dev->exp.aer_cap;", "root_cmd = pci_get_long(aer_cap + PCI_ERR_ROOT_COMMAND);", "root_status = pci_get_long(aer_cap + PCI_ERR_ROOT_STATUS);", "msi_trigger = false;", "if (cmd & PCI_COMMAND_SERR) {", "}", "switch (msg->severity) {", "case PCI_ERR_ROOT_CMD_COR_EN:\nif (root_status & PCI_ERR_ROOT_COR_RCV) {", "root_status |= PCI_ERR_ROOT_MULTI_COR_RCV;", "} else {", "if (root_cmd & PCI_ERR_ROOT_CMD_COR_EN) {", "msi_trigger = true;", "}", "pci_set_word(aer_cap + PCI_ERR_ROOT_COR_SRC, msg->source_id);", "}", "root_status |= PCI_ERR_ROOT_COR_RCV;", "break;", "case PCI_ERR_ROOT_CMD_NONFATAL_EN:\nif (!(root_status & PCI_ERR_ROOT_NONFATAL_RCV) &&\nroot_cmd & PCI_ERR_ROOT_CMD_NONFATAL_EN) {", "msi_trigger = true;", "}", "root_status |= PCI_ERR_ROOT_NONFATAL_RCV;", "break;", "case PCI_ERR_ROOT_CMD_FATAL_EN:\nif (!(root_status & PCI_ERR_ROOT_FATAL_RCV) &&\nroot_cmd & PCI_ERR_ROOT_CMD_FATAL_EN) {", "msi_trigger = true;", "}", "if (!(root_status & PCI_ERR_ROOT_UNCOR_RCV)) {", "root_status |= PCI_ERR_ROOT_FIRST_FATAL;", "}", "root_status |= PCI_ERR_ROOT_FATAL_RCV;", "break;", "default:\nabort();", "break;", "}", "if (pcie_aer_msg_is_uncor(msg)) {", "if (root_status & PCI_ERR_ROOT_UNCOR_RCV) {", "root_status |= PCI_ERR_ROOT_MULTI_UNCOR_RCV;", "} else {", "pci_set_word(aer_cap + PCI_ERR_ROOT_SRC, msg->source_id);", "}", "root_status |= PCI_ERR_ROOT_UNCOR_RCV;", "}", "pci_set_long(aer_cap + PCI_ERR_ROOT_STATUS, root_status);", "if (root_cmd & msg->severity) {", "if (msix_enabled(dev)) {", "if (msi_trigger) {", "msix_notify(dev, pcie_aer_root_get_vector(dev));", "}", "} else if (msi_enabled(dev)) {", "if (msi_trigger) {", "msi_notify(dev, pcie_aer_root_get_vector(dev));", "}", "} else {", "qemu_set_irq(dev->irq[dev->exp.aer_intx], 1);", "}", "msg_sent = true;", "}", "return msg_sent;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 33 ], [ 51 ], [ 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 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ] ]

[ "static void FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)\n{", "int VAR_3;", "PCIDevice *s = container_of(VAR_1, PCIDevice, config);", "for (VAR_3 = 0; VAR_3 < PCI_NUM_PINS; ++VAR_3) {", "qemu_put_be32(VAR_0, pci_irq_state(s, VAR_3));", "}", "}" ]

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

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

[ "static void FUNC_0(Notifier *VAR_0, void *VAR_1)\n{", "VirtIOBlockDataPlane *s = container_of(VAR_0, VirtIOBlockDataPlane,\nremove_notifier);", "assert(s->conf->conf.blk == VAR_1);", "data_plane_remove_op_blockers(s);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(NbdClientSession *VAR_0,\nstruct nbd_request *VAR_1,\nQEMUIOVector *VAR_2, int VAR_3)\n{", "AioContext *aio_context;", "int VAR_4, VAR_5;", "qemu_co_mutex_lock(&VAR_0->send_mutex);", "VAR_0->send_coroutine = qemu_coroutine_self();", "aio_context = bdrv_get_aio_context(VAR_0->bs);", "aio_set_fd_handler(aio_context, VAR_0->sock,\nnbd_reply_ready, nbd_restart_write, VAR_0);", "if (VAR_2) {", "if (!VAR_0->is_unix) {", "socket_set_cork(VAR_0->sock, 1);", "}", "VAR_4 = nbd_send_request(VAR_0->sock, VAR_1);", "if (VAR_4 >= 0) {", "VAR_5 = qemu_co_sendv(VAR_0->sock, VAR_2->iov, VAR_2->niov,\nVAR_3, VAR_1->len);", "if (VAR_5 != VAR_1->len) {", "VAR_4 = -EIO;", "}", "}", "if (!VAR_0->is_unix) {", "socket_set_cork(VAR_0->sock, 0);", "}", "} else {", "VAR_4 = nbd_send_request(VAR_0->sock, VAR_1);", "}", "aio_set_fd_handler(aio_context, VAR_0->sock, nbd_reply_ready, NULL, VAR_0);", "VAR_0->send_coroutine = NULL;", "qemu_co_mutex_unlock(&VAR_0->send_mutex);", "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 ]

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{", "MilkymistAC97State *s = opaque;", "uint32_t r = 0;", "addr >>= 2;", "switch (addr) {", "case R_AC97_CTRL:\ncase R_AC97_ADDR:\ncase R_AC97_DATAOUT:\ncase R_AC97_DATAIN:\ncase R_D_CTRL:\ncase R_D_ADDR:\ncase R_D_REMAINING:\ncase R_U_CTRL:\ncase R_U_ADDR:\ncase R_U_REMAINING:\nr = s->regs[addr];", "break;", "default:\nerror_report(\"milkymist_ac97: read access to unknown register 0x\"\nTARGET_FMT_plx, addr << 2);", "break;", "}", "trace_milkymist_ac97_memory_read(addr << 2, r);", "return r;", "}" ]

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

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

[ "static void FUNC_0 (void *VAR_0, int VAR_1)\n{", "DisasContext *ctx = VAR_0;", "gen_op_store_ibatu((VAR_1 - SPR_IBAT4U) / 2);", "RET_STOP(ctx);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static int FUNC_0(BlockBackend *VAR_0, int VAR_1,\noff_t *VAR_2, off_t *VAR_3)\n{", "struct partition_record VAR_4[4];", "uint8_t data[512];", "int VAR_5;", "int VAR_6 = 4;", "int VAR_7;", "if ((VAR_7 = blk_read(VAR_0, 0, data, 1)) < 0) {", "error_report(\"error while reading: %s\", strerror(-VAR_7));", "exit(EXIT_FAILURE);", "}", "if (data[510] != 0x55 || data[511] != 0xaa) {", "return -EINVAL;", "}", "for (VAR_5 = 0; VAR_5 < 4; VAR_5++) {", "read_partition(&data[446 + 16 * VAR_5], &VAR_4[VAR_5]);", "if (!VAR_4[VAR_5].system || !VAR_4[VAR_5].nb_sectors_abs) {", "continue;", "}", "if (VAR_4[VAR_5].system == 0xF || VAR_4[VAR_5].system == 0x5) {", "struct partition_record VAR_8[4];", "uint8_t data1[512];", "int VAR_9;", "if ((VAR_7 = blk_read(VAR_0, VAR_4[VAR_5].start_sector_abs, data1, 1)) < 0) {", "error_report(\"error while reading: %s\", strerror(-VAR_7));", "exit(EXIT_FAILURE);", "}", "for (VAR_9 = 0; VAR_9 < 4; VAR_9++) {", "read_partition(&data1[446 + 16 * VAR_9], &VAR_8[VAR_9]);", "if (!VAR_8[VAR_9].system || !VAR_8[VAR_9].nb_sectors_abs) {", "continue;", "}", "if ((VAR_6 + VAR_9 + 1) == VAR_1) {", "*VAR_2 = (uint64_t)VAR_8[VAR_9].start_sector_abs << 9;", "*VAR_3 = (uint64_t)VAR_8[VAR_9].nb_sectors_abs << 9;", "return 0;", "}", "}", "VAR_6 += 4;", "} else if ((VAR_5 + 1) == VAR_1) {", "*VAR_2 = (uint64_t)VAR_4[VAR_5].start_sector_abs << 9;", "*VAR_3 = (uint64_t)VAR_4[VAR_5].nb_sectors_abs << 9;", "return 0;", "}", "}", "return -ENOENT;", "}" ]

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

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

[ "static void FUNC_0(int VAR_0, int VAR_1, DisplayState *VAR_2,\nconst char *VAR_3, const char *VAR_4,\nconst char *VAR_5, const char *VAR_6,\nunsigned int VAR_7, int VAR_8)\n{", "if ((unsigned int)VAR_0 > (unsigned int)VAR_8) {", "fprintf(stderr, \"qemu: Too much memory for this VAR_7: %d, maximum %d\\n\",\n(unsigned int)VAR_0 / (1024 * 1024),\n(unsigned int)VAR_8 / (1024 * 1024));", "exit(1);", "}", "sun4m_hw_init(&hwdefs[VAR_7], VAR_0, VAR_2, VAR_6);", "sun4m_load_kernel(hwdefs[VAR_7].vram_size, VAR_0, VAR_1,\nVAR_3, VAR_4, VAR_5,\nhwdefs[VAR_7].machine_id);", "}" ]

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

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

[ "static always_inline void FUNC_0 (CPUState *env, uint32_t hdecr,\nuint32_t value, int is_excp)\n{", "ppc_tb_t *tb_env = env->tb_env;", "__cpu_ppc_store_decr(env, &tb_env->hdecr_next, tb_env->hdecr_timer,\n&cpu_ppc_hdecr_excp, hdecr, value, is_excp);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0, const uint8_t *VAR_1, uint32_t VAR_2)\n{", "VP9SharedContext *h = VAR_0->priv_data;", "const AVPixFmtDescriptor *VAR_3 = av_pix_fmt_desc_get(VAR_0->sw_pix_fmt);", "NVDECContext *ctx = VAR_0->internal->hwaccel_priv_data;", "CUVIDPICPARAMS *pp = &ctx->pic_params;", "CUVIDVP9PICPARAMS *ppc = &pp->CodecSpecific.vp9;", "FrameDecodeData *fdd;", "NVDECFrame *cf;", "AVFrame *cur_frame = h->frames[CUR_FRAME].tf.f;", "int VAR_4, VAR_5;", "VAR_4 = ff_nvdec_start_frame(VAR_0, cur_frame);", "if (VAR_4 < 0)\nreturn VAR_4;", "fdd = (FrameDecodeData*)cur_frame->private_ref->data;", "cf = (NVDECFrame*)fdd->hwaccel_priv;", "*pp = (CUVIDPICPARAMS) {", ".PicWidthInMbs = (cur_frame->width + 15) / 16,\n.FrameHeightInMbs = (cur_frame->height + 15) / 16,\n.CurrPicIdx = cf->idx,\n.CodecSpecific.vp9 = {", ".width = cur_frame->width,\n.height = cur_frame->height,\n.LastRefIdx = get_ref_idx(h->refs[h->h.refidx[0]].f),\n.GoldenRefIdx = get_ref_idx(h->refs[h->h.refidx[1]].f),\n.AltRefIdx = get_ref_idx(h->refs[h->h.refidx[2]].f),\n.profile = h->h.profile,\n.frameContextIdx = h->h.framectxid,\n.frameType = !h->h.keyframe,\n.showFrame = !h->h.invisible,\n.errorResilient = h->h.errorres,\n.frameParallelDecoding = h->h.parallelmode,\n.subSamplingX = VAR_3->log2_chroma_w,\n.subSamplingY = VAR_3->log2_chroma_h,\n.intraOnly = h->h.intraonly,\n.allow_high_precision_mv = h->h.keyframe ? 0 : h->h.highprecisionmvs,\n.refreshEntropyProbs = h->h.refreshctx,\n.bitDepthMinus8Luma = VAR_3->comp[0].depth - 8,\n.bitDepthMinus8Chroma = VAR_3->comp[1].depth - 8,\n.loopFilterLevel = h->h.filter.level,\n.loopFilterSharpness = h->h.filter.sharpness,\n.modeRefLfEnabled = h->h.lf_delta.enabled,\n.log2_tile_columns = h->h.tiling.log2_tile_cols,\n.log2_tile_rows = h->h.tiling.log2_tile_rows,\n.segmentEnabled = h->h.segmentation.enabled,\n.segmentMapUpdate = h->h.segmentation.update_map,\n.segmentMapTemporalUpdate = h->h.segmentation.temporal,\n.segmentFeatureMode = h->h.segmentation.absolute_vals,\n.qpYAc = h->h.yac_qi,\n.qpYDc = h->h.ydc_qdelta,\n.qpChDc = h->h.uvdc_qdelta,\n.qpChAc = h->h.uvac_qdelta,\n.resetFrameContext = h->h.resetctx,\n.mcomp_filter_type = h->h.filtermode ^ (h->h.filtermode <= 1),\n.frameTagSize = h->h.uncompressed_header_size,\n.offsetToDctParts = h->h.compressed_header_size,\n.refFrameSignBias[0] = 0,\n}", "};", "for (VAR_5 = 0; VAR_5 < 2; VAR_5++)", "ppc->mbModeLfDelta[VAR_5] = h->h.lf_delta.mode[VAR_5];", "for (VAR_5 = 0; VAR_5 < 4; VAR_5++)", "ppc->mbRefLfDelta[VAR_5] = h->h.lf_delta.ref[VAR_5];", "for (VAR_5 = 0; VAR_5 < 7; VAR_5++)", "ppc->mb_segment_tree_probs[VAR_5] = h->h.segmentation.prob[VAR_5];", "for (VAR_5 = 0; VAR_5 < 3; VAR_5++) {", "ppc->activeRefIdx[VAR_5] = h->h.refidx[VAR_5];", "ppc->segment_pred_probs[VAR_5] = h->h.segmentation.pred_prob[VAR_5];", "ppc->refFrameSignBias[VAR_5 + 1] = h->h.signbias[VAR_5];", "}", "for (VAR_5 = 0; VAR_5 < 8; VAR_5++) {", "ppc->segmentFeatureEnable[VAR_5][0] = h->h.segmentation.feat[VAR_5].q_enabled;", "ppc->segmentFeatureEnable[VAR_5][1] = h->h.segmentation.feat[VAR_5].lf_enabled;", "ppc->segmentFeatureEnable[VAR_5][2] = h->h.segmentation.feat[VAR_5].ref_enabled;", "ppc->segmentFeatureEnable[VAR_5][3] = h->h.segmentation.feat[VAR_5].skip_enabled;", "ppc->segmentFeatureData[VAR_5][0] = h->h.segmentation.feat[VAR_5].q_val;", "ppc->segmentFeatureData[VAR_5][1] = h->h.segmentation.feat[VAR_5].lf_val;", "ppc->segmentFeatureData[VAR_5][2] = h->h.segmentation.feat[VAR_5].ref_val;", "ppc->segmentFeatureData[VAR_5][3] = 0;", "}", "switch (VAR_0->colorspace) {", "default:\ncase AVCOL_SPC_UNSPECIFIED:\nppc->colorSpace = 0;", "break;", "case AVCOL_SPC_BT470BG:\nppc->colorSpace = 1;", "break;", "case AVCOL_SPC_BT709:\nppc->colorSpace = 2;", "break;", "case AVCOL_SPC_SMPTE170M:\nppc->colorSpace = 3;", "break;", "case AVCOL_SPC_SMPTE240M:\nppc->colorSpace = 4;", "break;", "case AVCOL_SPC_BT2020_NCL:\nppc->colorSpace = 5;", "break;", "case AVCOL_SPC_RESERVED:\nppc->colorSpace = 6;", "break;", "case AVCOL_SPC_RGB:\nppc->colorSpace = 7;", "break;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 43 ], [ 45, 47, 49, 53 ], [ 55, 57, 61, 63, 65, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 93, 95, 99, 101, 103, 107, 109, 113, 115, 117, 119, 123, 125, 127, 129, 133, 135, 139, 141, 145, 147 ], [ 149 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209, 211, 213 ], [ 215 ], [ 217, 219 ], [ 221 ], [ 223, 225 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241, 243 ], [ 245 ], [ 247, 249 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ] ]

[ "void FUNC_0(const char *VAR_0)\n{", "QmpCommand *cmd;", "QTAILQ_FOREACH(cmd, &qmp_commands, node) {", "if (strcmp(cmd->VAR_0, VAR_0) == 0) {", "cmd->enabled = false;", "return;", "}", "}", "}" ]

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

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

[ "static void FUNC_0(MachineState *VAR_0)\n{", "ram_addr_t ram_size = VAR_0->ram_size;", "const char *VAR_1 = VAR_0->VAR_1;", "const char *VAR_2 = VAR_0->VAR_2;", "const char *VAR_3 = VAR_0->VAR_3;", "char *VAR_4;", "ppc4xx_bd_info_t bd;", "CPUPPCState *env;", "qemu_irq *pic;", "MemoryRegion *bios;", "MemoryRegion *sram = g_new(MemoryRegion, 1);", "ram_addr_t bdloc;", "MemoryRegion *ram_memories = g_malloc(2 * sizeof(*ram_memories));", "hwaddr ram_bases[2], ram_sizes[2];", "target_ulong sram_size;", "long VAR_5;", "target_ulong kernel_base, initrd_base;", "long VAR_6, VAR_7;", "int VAR_8;", "int VAR_9, VAR_10, VAR_11;", "DriveInfo *dinfo;", "MemoryRegion *sysmem = get_system_memory();", "memory_region_allocate_system_memory(&ram_memories[0], NULL, \"ef405ep.ram\",\n0x08000000);", "ram_bases[0] = 0;", "ram_sizes[0] = 0x08000000;", "memory_region_init(&ram_memories[1], NULL, \"ef405ep.ram1\", 0);", "ram_bases[1] = 0x00000000;", "ram_sizes[1] = 0x00000000;", "ram_size = 128 * 1024 * 1024;", "#ifdef DEBUG_BOARD_INIT\nprintf(\"%s: register cpu\\n\", __func__);", "#endif\nenv = ppc405ep_init(sysmem, ram_memories, ram_bases, ram_sizes,\n33333333, &pic, VAR_1 == NULL ? 0 : 1);", "sram_size = 512 * 1024;", "memory_region_init_ram(sram, NULL, \"ef405ep.sram\", sram_size, &error_abort);", "vmstate_register_ram_global(sram);", "memory_region_add_subregion(sysmem, 0xFFF00000, sram);", "#ifdef DEBUG_BOARD_INIT\nprintf(\"%s: register BIOS\\n\", __func__);", "#endif\nVAR_9 = 0;", "#ifdef USE_FLASH_BIOS\ndinfo = drive_get(IF_PFLASH, 0, VAR_9);", "if (dinfo) {", "BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo));", "VAR_5 = bdrv_getlength(bs);", "VAR_10 = (VAR_5 + 65535) >> 16;", "#ifdef DEBUG_BOARD_INIT\nprintf(\"Register parallel flash %d size %lx\"\n\" at addr %lx '%s' %d\\n\",\nVAR_9, VAR_5, -VAR_5,\nbdrv_get_device_name(bs), VAR_10);", "#endif\npflash_cfi02_register((uint32_t)(-VAR_5),\nNULL, \"ef405ep.bios\", VAR_5,\nbs, 65536, VAR_10, 1,\n2, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA,\n1);", "VAR_9++;", "} else", "#endif\n{", "#ifdef DEBUG_BOARD_INIT\nprintf(\"Load BIOS from file\\n\");", "#endif\nbios = g_new(MemoryRegion, 1);", "memory_region_init_ram(bios, NULL, \"ef405ep.bios\", BIOS_SIZE,\n&error_abort);", "vmstate_register_ram_global(bios);", "if (bios_name == NULL)\nbios_name = BIOS_FILENAME;", "VAR_4 = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);", "if (VAR_4) {", "VAR_5 = load_image(VAR_4, memory_region_get_ram_ptr(bios));", "g_free(VAR_4);", "if (VAR_5 < 0 || VAR_5 > BIOS_SIZE) {", "error_report(\"Could not load PowerPC BIOS '%s'\", bios_name);", "exit(1);", "}", "VAR_5 = (VAR_5 + 0xfff) & ~0xfff;", "memory_region_add_subregion(sysmem, (uint32_t)(-VAR_5), bios);", "} else if (!qtest_enabled() || VAR_1 != NULL) {", "error_report(\"Could not load PowerPC BIOS '%s'\", bios_name);", "exit(1);", "} else {", "VAR_5 = -1;", "}", "memory_region_set_readonly(bios, true);", "}", "#ifdef DEBUG_BOARD_INIT\nprintf(\"%s: register FPGA\\n\", __func__);", "#endif\nref405ep_fpga_init(sysmem, 0xF0300000);", "#ifdef DEBUG_BOARD_INIT\nprintf(\"%s: register NVRAM\\n\", __func__);", "#endif\nm48t59_init(NULL, 0xF0000000, 0, 8192, 8);", "VAR_8 = (VAR_1 != NULL);", "if (VAR_8) {", "#ifdef DEBUG_BOARD_INIT\nprintf(\"%s: load kernel\\n\", __func__);", "#endif\nmemset(&bd, 0, sizeof(bd));", "bd.bi_memstart = 0x00000000;", "bd.bi_memsize = ram_size;", "bd.bi_flashstart = -VAR_5;", "bd.bi_flashsize = -VAR_5;", "bd.bi_flashoffset = 0;", "bd.bi_sramstart = 0xFFF00000;", "bd.bi_sramsize = sram_size;", "bd.bi_bootflags = 0;", "bd.bi_intfreq = 133333333;", "bd.bi_busfreq = 33333333;", "bd.bi_baudrate = 115200;", "bd.bi_s_version[0] = 'Q';", "bd.bi_s_version[1] = 'M';", "bd.bi_s_version[2] = 'U';", "bd.bi_s_version[3] = '\\0';", "bd.bi_r_version[0] = 'Q';", "bd.bi_r_version[1] = 'E';", "bd.bi_r_version[2] = 'M';", "bd.bi_r_version[3] = 'U';", "bd.bi_r_version[4] = '\\0';", "bd.bi_procfreq = 133333333;", "bd.bi_plb_busfreq = 33333333;", "bd.bi_pci_busfreq = 33333333;", "bd.bi_opbfreq = 33333333;", "bdloc = ppc405_set_bootinfo(env, &bd, 0x00000001);", "env->gpr[3] = bdloc;", "kernel_base = KERNEL_LOAD_ADDR;", "VAR_6 = load_image_targphys(VAR_1, kernel_base,\nram_size - kernel_base);", "if (VAR_6 < 0) {", "fprintf(stderr, \"qemu: could not load kernel '%s'\\n\",\nVAR_1);", "exit(1);", "}", "printf(\"Load kernel size %ld at \" TARGET_FMT_lx,\nVAR_6, kernel_base);", "if (VAR_3) {", "initrd_base = INITRD_LOAD_ADDR;", "VAR_7 = load_image_targphys(VAR_3, initrd_base,\nram_size - initrd_base);", "if (VAR_7 < 0) {", "fprintf(stderr, \"qemu: could not load initial ram disk '%s'\\n\",\nVAR_3);", "exit(1);", "}", "} else {", "initrd_base = 0;", "VAR_7 = 0;", "}", "env->gpr[4] = initrd_base;", "env->gpr[5] = VAR_7;", "if (VAR_2 != NULL) {", "VAR_11 = strlen(VAR_2);", "bdloc -= ((VAR_11 + 255) & ~255);", "cpu_physical_memory_write(bdloc, VAR_2, VAR_11 + 1);", "env->gpr[6] = bdloc;", "env->gpr[7] = bdloc + VAR_11;", "} else {", "env->gpr[6] = 0;", "env->gpr[7] = 0;", "}", "env->nip = KERNEL_LOAD_ADDR;", "} else {", "kernel_base = 0;", "VAR_6 = 0;", "initrd_base = 0;", "VAR_7 = 0;", "bdloc = 0;", "}", "#ifdef DEBUG_BOARD_INIT\nprintf(\"bdloc \" RAM_ADDR_FMT \"\\n\", bdloc);", "printf(\"%s: Done\\n\", __func__);", "#endif\n}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 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 ], [ 111 ], [ 113 ], [ 115, 117, 119, 121, 123 ], [ 125, 127, 129, 131, 133, 135 ], [ 137 ], [ 139 ], [ 141, 143 ], [ 145, 147 ], [ 149, 151 ], [ 153, 155 ], [ 157 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 205, 207 ], [ 209, 211 ], [ 215, 217 ], [ 219, 221 ], [ 225 ], [ 227 ], [ 229, 231 ], [ 233, 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 293, 295 ], [ 297 ], [ 299, 301 ], [ 303 ], [ 305 ], [ 307, 309 ], [ 313 ], [ 315 ], [ 317, 319 ], [ 321 ], [ 323, 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379, 381 ], [ 383 ], [ 385, 387 ] ]

[ "static int FUNC_0(FsContext *VAR_0,\nV9fsPath *VAR_1, V9fsFidOpenState *VAR_2)\n{", "V9fsSynthOpenState *synth_open;", "V9fsSynthNode *node = *(V9fsSynthNode **)VAR_1->data;", "synth_open = g_malloc(sizeof(*synth_open));", "synth_open->node = node;", "node->open_count++;", "VAR_2->private = synth_open;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(BDRVReopenState *VAR_0)\n{", "BDRVRawState *new_s = VAR_0->opaque;", "BDRVRawState *s = VAR_0->bs->opaque;", "memcpy(s, new_s, sizeof(BDRVRawState));", "g_free(VAR_0->opaque);", "VAR_0->opaque = NULL;", "}" ]

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

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

[ "static int FUNC_0(AVFilterContext *VAR_0, AVFilterBufferRef *VAR_1,\nint VAR_2, int VAR_3)\n{", "DrawTextContext *dtext = VAR_0->priv;", "uint32_t code = 0, prev_code = 0;", "int VAR_4 = 0, VAR_5 = 0, VAR_6 = 0, VAR_7;", "int VAR_8 = 0, VAR_9;", "int VAR_10, VAR_11;", "char *VAR_12 = dtext->VAR_12;", "uint8_t *p;", "int VAR_13 = 32000, VAR_14 = -32000;", "int VAR_15 = 32000, VAR_16 = -32000;", "FT_Vector delta;", "Glyph *glyph = NULL, *prev_glyph = NULL;", "Glyph dummy = { 0 };", "time_t now = time(0);", "struct tm VAR_17;", "uint8_t *buf = dtext->expanded_text;", "int VAR_18 = dtext->expanded_text_size;", "if(dtext->basetime != AV_NOPTS_VALUE)\nnow= VAR_1->pts*av_q2d(VAR_0->inputs[0]->time_base) + dtext->basetime/1000000;", "if (!buf) {", "VAR_18 = 2*strlen(dtext->VAR_12)+1;", "buf = av_malloc(VAR_18);", "}", "#if HAVE_LOCALTIME_R\nlocaltime_r(&now, &VAR_17);", "#else\nif(strchr(dtext->VAR_12, '%'))\nVAR_17= *localtime(&now);", "#endif\ndo {", "*buf = 1;", "if (strftime(buf, VAR_18, dtext->VAR_12, &VAR_17) != 0 || *buf == 0)\nbreak;", "VAR_18 *= 2;", "} while ((buf = av_realloc(buf, VAR_18)));", "if (dtext->tc_opt_string) {", "char VAR_19[AV_TIMECODE_STR_SIZE];", "av_timecode_make_string(&dtext->tc, VAR_19, dtext->frame_id++);", "buf = av_asprintf(\"%s%s\", dtext->VAR_12, VAR_19);", "}", "if (!buf)\nreturn AVERROR(ENOMEM);", "VAR_12 = dtext->expanded_text = buf;", "dtext->expanded_text_size = VAR_18;", "if ((VAR_9 = strlen(VAR_12)) > dtext->nb_positions) {", "if (!(dtext->positions =\nav_realloc(dtext->positions, VAR_9*sizeof(*dtext->positions))))\nreturn AVERROR(ENOMEM);", "dtext->nb_positions = VAR_9;", "}", "VAR_4 = 0;", "VAR_5 = 0;", "for (VAR_6 = 0, p = VAR_12; *p; VAR_6++) {", "GET_UTF8(code, *p++, continue;);", "dummy.code = code;", "glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);", "if (!glyph) {", "load_glyph(VAR_0, &glyph, code);", "}", "VAR_13 = FFMIN(glyph->bbox.yMin, VAR_13);", "VAR_14 = FFMAX(glyph->bbox.yMax, VAR_14);", "VAR_15 = FFMIN(glyph->bbox.xMin, VAR_15);", "VAR_16 = FFMAX(glyph->bbox.xMax, VAR_16);", "}", "dtext->max_glyph_h = VAR_14 - VAR_13;", "dtext->max_glyph_w = VAR_16 - VAR_15;", "glyph = NULL;", "for (VAR_6 = 0, p = VAR_12; *p; VAR_6++) {", "GET_UTF8(code, *p++, continue;);", "if (prev_code == '\\r' && code == '\\n')\ncontinue;", "prev_code = code;", "if (is_newline(code)) {", "VAR_8 = FFMAX(VAR_8, VAR_4);", "VAR_5 += dtext->max_glyph_h;", "VAR_4 = 0;", "continue;", "}", "prev_glyph = glyph;", "dummy.code = code;", "glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);", "if (dtext->use_kerning && prev_glyph && glyph->code) {", "FT_Get_Kerning(dtext->face, prev_glyph->code, glyph->code,\nft_kerning_default, &delta);", "VAR_4 += delta.VAR_4 >> 6;", "}", "dtext->positions[VAR_6].VAR_4 = VAR_4 + glyph->bitmap_left;", "dtext->positions[VAR_6].VAR_5 = VAR_5 - glyph->bitmap_top + VAR_14;", "if (code == '\\t') VAR_4 = (VAR_4 / dtext->tabsize + 1)*dtext->tabsize;", "else VAR_4 += glyph->advance;", "}", "VAR_8 = FFMAX(VAR_4, VAR_8);", "dtext->var_values[VAR_TW] = dtext->var_values[VAR_TEXT_W] = VAR_8;", "dtext->var_values[VAR_TH] = dtext->var_values[VAR_TEXT_H] = VAR_5 + dtext->max_glyph_h;", "dtext->var_values[VAR_MAX_GLYPH_W] = dtext->max_glyph_w;", "dtext->var_values[VAR_MAX_GLYPH_H] = dtext->max_glyph_h;", "dtext->var_values[VAR_MAX_GLYPH_A] = dtext->var_values[VAR_ASCENT ] = VAR_14;", "dtext->var_values[VAR_MAX_GLYPH_D] = dtext->var_values[VAR_DESCENT] = VAR_13;", "dtext->var_values[VAR_LINE_H] = dtext->var_values[VAR_LH] = dtext->max_glyph_h;", "dtext->VAR_4 = dtext->var_values[VAR_X] = av_expr_eval(dtext->x_pexpr, dtext->var_values, &dtext->prng);", "dtext->VAR_5 = dtext->var_values[VAR_Y] = av_expr_eval(dtext->y_pexpr, dtext->var_values, &dtext->prng);", "dtext->VAR_4 = dtext->var_values[VAR_X] = av_expr_eval(dtext->x_pexpr, dtext->var_values, &dtext->prng);", "dtext->draw = av_expr_eval(dtext->draw_pexpr, dtext->var_values, &dtext->prng);", "if(!dtext->draw)\nreturn 0;", "VAR_10 = FFMIN(VAR_2 - 1 , VAR_8);", "VAR_11 = FFMIN(VAR_3 - 1, VAR_5 + dtext->max_glyph_h);", "if (dtext->draw_box)\nff_blend_rectangle(&dtext->dc, &dtext->boxcolor,\nVAR_1->data, VAR_1->linesize, VAR_2, VAR_3,\ndtext->VAR_4, dtext->VAR_5, VAR_10, VAR_11);", "if (dtext->shadowx || dtext->shadowy) {", "if ((VAR_7 = draw_glyphs(dtext, VAR_1, VAR_2, VAR_3, dtext->shadowcolor.rgba,\n&dtext->shadowcolor, dtext->shadowx, dtext->shadowy)) < 0)\nreturn VAR_7;", "}", "if ((VAR_7 = draw_glyphs(dtext, VAR_1, VAR_2, VAR_3, dtext->fontcolor.rgba,\n&dtext->fontcolor, 0, 0)) < 0)\nreturn VAR_7;", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43, 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 63, 65, 67 ], [ 69, 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 94 ], [ 96 ], [ 100, 102 ], [ 104 ], [ 106 ], [ 108 ], [ 110, 112, 114 ], [ 116 ], [ 118 ], [ 122 ], [ 124 ], [ 130 ], [ 132 ], [ 138 ], [ 140 ], [ 142 ], [ 144 ], [ 146 ], [ 150 ], [ 152 ], [ 154 ], [ 156 ], [ 158 ], [ 160 ], [ 162 ], [ 168 ], [ 170 ], [ 172 ], [ 178, 180 ], [ 184 ], [ 186 ], [ 188 ], [ 190 ], [ 192 ], [ 194 ], [ 196 ], [ 202 ], [ 204 ], [ 206 ], [ 212 ], [ 214, 216 ], [ 218 ], [ 220 ], [ 226 ], [ 228 ], [ 230 ], [ 232 ], [ 234 ], [ 238 ], [ 242 ], [ 244 ], [ 248 ], [ 250 ], [ 252 ], [ 254 ], [ 258 ], [ 262 ], [ 264 ], [ 266 ], [ 268 ], [ 272, 274 ], [ 278 ], [ 280 ], [ 286, 288, 290, 292 ], [ 296 ], [ 298, 300, 302 ], [ 304 ], [ 308, 310, 312 ], [ 316 ], [ 318 ] ]

[ "static int FUNC_0(AVThreadMessageQueue *VAR_0,\nvoid *VAR_1,\nunsigned VAR_2)\n{", "while (!VAR_0->err_recv && av_fifo_size(VAR_0->fifo) < VAR_0->elsize) {", "if ((VAR_2 & AV_THREAD_MESSAGE_NONBLOCK))\nreturn AVERROR(EAGAIN);", "pthread_cond_wait(&VAR_0->cond, &VAR_0->lock);", "}", "if (av_fifo_size(VAR_0->fifo) < VAR_0->elsize)\nreturn VAR_0->err_recv;", "av_fifo_generic_read(VAR_0->fifo, VAR_1, VAR_0->elsize, NULL);", "pthread_cond_signal(&VAR_0->cond);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1)\n{", "BDRVBlkdebugState *s = VAR_0->opaque;", "BlkdebugSuspendedReq *r;", "QLIST_FOREACH(r, &s->suspended_reqs, next) {", "if (!strcmp(r->VAR_1, VAR_1)) {", "qemu_coroutine_enter(r->co, NULL);", "return 0;", "}", "}", "return -ENOENT;", "}" ]

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

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

[ "static void FUNC_0(VirtIOBlockReq *VAR_0, MultiReqBuffer *VAR_1)\n{", "BlockRequest *blkreq;", "uint64_t sector;", "sector = virtio_ldq_p(VIRTIO_DEVICE(VAR_0->dev), &VAR_0->out.sector);", "bdrv_acct_start(VAR_0->dev->bs, &VAR_0->acct, VAR_0->qiov.size, BDRV_ACCT_WRITE);", "trace_virtio_blk_handle_write(VAR_0, sector, VAR_0->qiov.size / 512);", "if (!virtio_blk_sect_range_ok(VAR_0->dev, sector, VAR_0->qiov.size)) {", "virtio_blk_rw_complete(VAR_0, -EIO);", "return;", "}", "if (VAR_1->num_writes == 32) {", "virtio_submit_multiwrite(VAR_0->dev->bs, VAR_1);", "}", "blkreq = &VAR_1->blkreq[VAR_1->num_writes];", "blkreq->sector = sector;", "blkreq->nb_sectors = VAR_0->qiov.size / BDRV_SECTOR_SIZE;", "blkreq->qiov = &VAR_0->qiov;", "blkreq->cb = virtio_blk_rw_complete;", "blkreq->opaque = VAR_0;", "blkreq->error = 0;", "VAR_1->num_writes++;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ] ]

[ "static int FUNC_0(MachineState *VAR_0,\nPPCE500Params *VAR_1,\nhwaddr VAR_2,\nhwaddr VAR_3,\nhwaddr VAR_4,\nhwaddr VAR_5,\nhwaddr VAR_6,\nbool VAR_7)\n{", "CPUPPCState *env = first_cpu->env_ptr;", "int VAR_8 = -1;", "uint64_t mem_reg_property[] = { 0, cpu_to_be64(VAR_0->ram_size) };", "int VAR_9;", "void *VAR_10;", "uint8_t hypercall[16];", "uint32_t clock_freq = 400000000;", "uint32_t tb_freq = 400000000;", "int VAR_11;", "char VAR_12[] = \"fsl,mpc8544-immr\\0simple-bus\";", "char VAR_13[128];", "char VAR_14[128];", "uint32_t mpic_ph;", "uint32_t msi_ph;", "char VAR_15[128];", "char VAR_16[128];", "char VAR_17[128];", "uint32_t *pci_map = NULL;", "int VAR_18;", "uint32_t pci_ranges[14] =\n{", "0x2000000, 0x0, VAR_1->pci_mmio_bus_base,\nVAR_1->pci_mmio_base >> 32, VAR_1->pci_mmio_base,\n0x0, 0x20000000,\n0x1000000, 0x0, 0x0,\nVAR_1->pci_pio_base >> 32, VAR_1->pci_pio_base,\n0x0, 0x10000,\n};", "QemuOpts *machine_opts = qemu_get_machine_opts();", "const char *VAR_19 = qemu_opt_get(machine_opts, \"dtb\");", "const char *VAR_20 = qemu_opt_get(machine_opts, \"dt_compatible\");", "if (VAR_19) {", "char *VAR_21;", "VAR_21 = qemu_find_file(QEMU_FILE_TYPE_BIOS, VAR_19);", "if (!VAR_21) {", "goto out;", "}", "VAR_10 = load_device_tree(VAR_21, &VAR_9);", "if (!VAR_10) {", "goto out;", "}", "goto done;", "}", "VAR_10 = create_device_tree(&VAR_9);", "if (VAR_10 == NULL) {", "goto out;", "}", "qemu_fdt_setprop_cell(VAR_10, \"/\", \"#address-cells\", 2);", "qemu_fdt_setprop_cell(VAR_10, \"/\", \"#size-cells\", 2);", "qemu_fdt_add_subnode(VAR_10, \"/memory\");", "qemu_fdt_setprop_string(VAR_10, \"/memory\", \"device_type\", \"memory\");", "qemu_fdt_setprop(VAR_10, \"/memory\", \"reg\", mem_reg_property,\nsizeof(mem_reg_property));", "qemu_fdt_add_subnode(VAR_10, \"/chosen\");", "if (VAR_4) {", "VAR_8 = qemu_fdt_setprop_cell(VAR_10, \"/chosen\", \"linux,initrd-start\",\nVAR_3);", "if (VAR_8 < 0) {", "fprintf(stderr, \"couldn't set /chosen/linux,initrd-start\\n\");", "}", "VAR_8 = qemu_fdt_setprop_cell(VAR_10, \"/chosen\", \"linux,initrd-end\",\n(VAR_3 + VAR_4));", "if (VAR_8 < 0) {", "fprintf(stderr, \"couldn't set /chosen/linux,initrd-end\\n\");", "}", "}", "if (VAR_5 != -1ULL) {", "qemu_fdt_setprop_cells(VAR_10, \"/chosen\", \"qemu,boot-kernel\",\nVAR_5 >> 32, VAR_5,\nVAR_6 >> 32, VAR_6);", "}", "VAR_8 = qemu_fdt_setprop_string(VAR_10, \"/chosen\", \"bootargs\",\nVAR_0->kernel_cmdline);", "if (VAR_8 < 0)\nfprintf(stderr, \"couldn't set /chosen/bootargs\\n\");", "if (kvm_enabled()) {", "clock_freq = kvmppc_get_clockfreq();", "tb_freq = kvmppc_get_tbfreq();", "qemu_fdt_add_subnode(VAR_10, \"/hypervisor\");", "qemu_fdt_setprop_string(VAR_10, \"/hypervisor\", \"compatible\",\n\"linux,kvm\");", "kvmppc_get_hypercall(env, hypercall, sizeof(hypercall));", "qemu_fdt_setprop(VAR_10, \"/hypervisor\", \"hcall-instructions\",\nhypercall, sizeof(hypercall));", "if (kvmppc_get_hasidle(env)) {", "qemu_fdt_setprop(VAR_10, \"/hypervisor\", \"has-idle\", NULL, 0);", "}", "}", "qemu_fdt_add_subnode(VAR_10, \"/cpus\");", "qemu_fdt_setprop_cell(VAR_10, \"/cpus\", \"#address-cells\", 1);", "qemu_fdt_setprop_cell(VAR_10, \"/cpus\", \"#size-cells\", 0);", "for (VAR_11 = smp_cpus - 1; VAR_11 >= 0; VAR_11--) {", "CPUState *cpu;", "PowerPCCPU *pcpu;", "char VAR_22[128];", "uint64_t cpu_release_addr = VAR_1->spin_base + (VAR_11 * 0x20);", "cpu = qemu_get_cpu(VAR_11);", "if (cpu == NULL) {", "continue;", "}", "env = cpu->env_ptr;", "pcpu = POWERPC_CPU(cpu);", "snprintf(VAR_22, sizeof(VAR_22), \"/cpus/PowerPC,8544@%x\",\nppc_get_vcpu_dt_id(pcpu));", "qemu_fdt_add_subnode(VAR_10, VAR_22);", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"clock-frequency\", clock_freq);", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"timebase-frequency\", tb_freq);", "qemu_fdt_setprop_string(VAR_10, VAR_22, \"device_type\", \"cpu\");", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"reg\",\nppc_get_vcpu_dt_id(pcpu));", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"d-cache-line-size\",\nenv->dcache_line_size);", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"VAR_11-cache-line-size\",\nenv->icache_line_size);", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"d-cache-size\", 0x8000);", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"VAR_11-cache-size\", 0x8000);", "qemu_fdt_setprop_cell(VAR_10, VAR_22, \"bus-frequency\", 0);", "if (cpu->cpu_index) {", "qemu_fdt_setprop_string(VAR_10, VAR_22, \"status\", \"disabled\");", "qemu_fdt_setprop_string(VAR_10, VAR_22, \"enable-method\",\n\"spin-table\");", "qemu_fdt_setprop_u64(VAR_10, VAR_22, \"cpu-release-VAR_2\",\ncpu_release_addr);", "} else {", "qemu_fdt_setprop_string(VAR_10, VAR_22, \"status\", \"okay\");", "}", "}", "qemu_fdt_add_subnode(VAR_10, \"/aliases\");", "snprintf(VAR_13, sizeof(VAR_13), \"/VAR_13@%\"PRIx64, VAR_1->ccsrbar_base);", "qemu_fdt_add_subnode(VAR_10, VAR_13);", "qemu_fdt_setprop_string(VAR_10, VAR_13, \"device_type\", \"VAR_13\");", "qemu_fdt_setprop(VAR_10, VAR_13, \"compatible\", VAR_12,\nsizeof(VAR_12));", "qemu_fdt_setprop_cell(VAR_10, VAR_13, \"#address-cells\", 1);", "qemu_fdt_setprop_cell(VAR_10, VAR_13, \"#size-cells\", 1);", "qemu_fdt_setprop_cells(VAR_10, VAR_13, \"ranges\", 0x0,\nVAR_1->ccsrbar_base >> 32, VAR_1->ccsrbar_base,\nMPC8544_CCSRBAR_SIZE);", "qemu_fdt_setprop_cell(VAR_10, VAR_13, \"bus-frequency\", 0);", "snprintf(VAR_14, sizeof(VAR_14), \"%s/pic@%llx\", VAR_13, MPC8544_MPIC_REGS_OFFSET);", "qemu_fdt_add_subnode(VAR_10, VAR_14);", "qemu_fdt_setprop_string(VAR_10, VAR_14, \"device_type\", \"open-pic\");", "qemu_fdt_setprop_string(VAR_10, VAR_14, \"compatible\", \"fsl,VAR_14\");", "qemu_fdt_setprop_cells(VAR_10, VAR_14, \"reg\", MPC8544_MPIC_REGS_OFFSET,\n0x40000);", "qemu_fdt_setprop_cell(VAR_10, VAR_14, \"#address-cells\", 0);", "qemu_fdt_setprop_cell(VAR_10, VAR_14, \"#interrupt-cells\", 2);", "mpic_ph = qemu_fdt_alloc_phandle(VAR_10);", "qemu_fdt_setprop_cell(VAR_10, VAR_14, \"phandle\", mpic_ph);", "qemu_fdt_setprop_cell(VAR_10, VAR_14, \"linux,phandle\", mpic_ph);", "qemu_fdt_setprop(VAR_10, VAR_14, \"interrupt-controller\", NULL, 0);", "if (serial_hds[1]) {", "dt_serial_create(VAR_10, MPC8544_SERIAL1_REGS_OFFSET,\nVAR_13, VAR_14, \"serial1\", 1, false);", "}", "if (serial_hds[0]) {", "dt_serial_create(VAR_10, MPC8544_SERIAL0_REGS_OFFSET,\nVAR_13, VAR_14, \"serial0\", 0, true);", "}", "snprintf(VAR_15, sizeof(VAR_15), \"%s/global-utilities@%llx\", VAR_13,\nMPC8544_UTIL_OFFSET);", "qemu_fdt_add_subnode(VAR_10, VAR_15);", "qemu_fdt_setprop_string(VAR_10, VAR_15, \"compatible\", \"fsl,mpc8544-guts\");", "qemu_fdt_setprop_cells(VAR_10, VAR_15, \"reg\", MPC8544_UTIL_OFFSET, 0x1000);", "qemu_fdt_setprop(VAR_10, VAR_15, \"fsl,has-rstcr\", NULL, 0);", "snprintf(VAR_17, sizeof(VAR_17), \"/%s/VAR_17@%llx\", VAR_13, MPC8544_MSI_REGS_OFFSET);", "qemu_fdt_add_subnode(VAR_10, VAR_17);", "qemu_fdt_setprop_string(VAR_10, VAR_17, \"compatible\", \"fsl,VAR_14-VAR_17\");", "qemu_fdt_setprop_cells(VAR_10, VAR_17, \"reg\", MPC8544_MSI_REGS_OFFSET, 0x200);", "msi_ph = qemu_fdt_alloc_phandle(VAR_10);", "qemu_fdt_setprop_cells(VAR_10, VAR_17, \"VAR_17-available-ranges\", 0x0, 0x100);", "qemu_fdt_setprop_phandle(VAR_10, VAR_17, \"interrupt-parent\", VAR_14);", "qemu_fdt_setprop_cells(VAR_10, VAR_17, \"interrupts\",\n0xe0, 0x0,\n0xe1, 0x0,\n0xe2, 0x0,\n0xe3, 0x0,\n0xe4, 0x0,\n0xe5, 0x0,\n0xe6, 0x0,\n0xe7, 0x0);", "qemu_fdt_setprop_cell(VAR_10, VAR_17, \"phandle\", msi_ph);", "qemu_fdt_setprop_cell(VAR_10, VAR_17, \"linux,phandle\", msi_ph);", "snprintf(VAR_16, sizeof(VAR_16), \"/VAR_16@%llx\",\nVAR_1->ccsrbar_base + MPC8544_PCI_REGS_OFFSET);", "qemu_fdt_add_subnode(VAR_10, VAR_16);", "qemu_fdt_setprop_cell(VAR_10, VAR_16, \"cell-index\", 0);", "qemu_fdt_setprop_string(VAR_10, VAR_16, \"compatible\", \"fsl,mpc8540-VAR_16\");", "qemu_fdt_setprop_string(VAR_10, VAR_16, \"device_type\", \"VAR_16\");", "qemu_fdt_setprop_cells(VAR_10, VAR_16, \"interrupt-map-mask\", 0xf800, 0x0,\n0x0, 0x7);", "pci_map = pci_map_create(VAR_10, qemu_fdt_get_phandle(VAR_10, VAR_14),\nVAR_1->pci_first_slot, VAR_1->pci_nr_slots,\n&VAR_18);", "qemu_fdt_setprop(VAR_10, VAR_16, \"interrupt-map\", pci_map, VAR_18);", "qemu_fdt_setprop_phandle(VAR_10, VAR_16, \"interrupt-parent\", VAR_14);", "qemu_fdt_setprop_cells(VAR_10, VAR_16, \"interrupts\", 24, 2);", "qemu_fdt_setprop_cells(VAR_10, VAR_16, \"bus-range\", 0, 255);", "for (VAR_11 = 0; VAR_11 < 14; VAR_11++) {", "pci_ranges[VAR_11] = cpu_to_be32(pci_ranges[VAR_11]);", "}", "qemu_fdt_setprop_cell(VAR_10, VAR_16, \"fsl,VAR_17\", msi_ph);", "qemu_fdt_setprop(VAR_10, VAR_16, \"ranges\", pci_ranges, sizeof(pci_ranges));", "qemu_fdt_setprop_cells(VAR_10, VAR_16, \"reg\",\n(VAR_1->ccsrbar_base + MPC8544_PCI_REGS_OFFSET) >> 32,\n(VAR_1->ccsrbar_base + MPC8544_PCI_REGS_OFFSET),\n0, 0x1000);", "qemu_fdt_setprop_cell(VAR_10, VAR_16, \"clock-frequency\", 66666666);", "qemu_fdt_setprop_cell(VAR_10, VAR_16, \"#interrupt-cells\", 1);", "qemu_fdt_setprop_cell(VAR_10, VAR_16, \"#size-cells\", 2);", "qemu_fdt_setprop_cell(VAR_10, VAR_16, \"#address-cells\", 3);", "qemu_fdt_setprop_string(VAR_10, \"/aliases\", \"pci0\", VAR_16);", "if (VAR_1->has_mpc8xxx_gpio) {", "create_dt_mpc8xxx_gpio(VAR_10, VAR_13, VAR_14);", "}", "if (VAR_1->has_platform_bus) {", "platform_bus_create_devtree(VAR_1, VAR_10, VAR_14);", "}", "VAR_1->fixup_devtree(VAR_1, VAR_10);", "if (VAR_20) {", "qemu_fdt_setprop(VAR_10, \"/\", \"compatible\", VAR_20,\nstrlen(VAR_20) + 1);", "}", "done:\nif (!VAR_7) {", "qemu_fdt_dumpdtb(VAR_10, VAR_9);", "cpu_physical_memory_write(VAR_2, VAR_10, VAR_9);", "}", "VAR_8 = VAR_9;", "out:\ng_free(pci_map);", "return VAR_8;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13, 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61, 63, 65, 69, 71, 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 102 ], [ 104 ], [ 106 ], [ 108 ], [ 110 ], [ 114 ], [ 116 ], [ 118 ], [ 120 ], [ 126 ], [ 128 ], [ 132 ], [ 134 ], [ 136, 138 ], [ 142 ], [ 144 ], [ 146, 148 ], [ 150 ], [ 152 ], [ 154 ], [ 158, 160 ], [ 162 ], [ 164 ], [ 166 ], [ 170 ], [ 174 ], [ 176, 178, 180 ], [ 182 ], [ 186, 188 ], [ 190, 192 ], [ 196 ], [ 200 ], [ 202 ], [ 208 ], [ 210, 212 ], [ 214 ], [ 216, 218 ], [ 222 ], [ 224 ], [ 226 ], [ 228 ], [ 234 ], [ 236 ], [ 238 ], [ 246 ], [ 248 ], [ 250 ], [ 252 ], [ 254 ], [ 258 ], [ 260 ], [ 262 ], [ 264 ], [ 266 ], [ 268 ], [ 272, 274 ], [ 276 ], [ 278 ], [ 280 ], [ 282 ], [ 284, 286 ], [ 288, 290 ], [ 292, 294 ], [ 296 ], [ 298 ], [ 300 ], [ 302 ], [ 304 ], [ 306, 308 ], [ 310, 312 ], [ 314 ], [ 316 ], [ 318 ], [ 320 ], [ 324 ], [ 328 ], [ 330 ], [ 332 ], [ 334, 336 ], [ 338 ], [ 340 ], [ 342, 344, 346 ], [ 350 ], [ 354 ], [ 356 ], [ 358 ], [ 360 ], [ 362, 364 ], [ 366 ], [ 368 ], [ 370 ], [ 372 ], [ 374 ], [ 376 ], [ 390 ], [ 392, 394 ], [ 396 ], [ 400 ], [ 402, 404 ], [ 406 ], [ 410, 412 ], [ 414 ], [ 416 ], [ 418 ], [ 420 ], [ 424 ], [ 426 ], [ 428 ], [ 430 ], [ 432 ], [ 434 ], [ 436 ], [ 438, 440, 442, 444, 446, 448, 450, 452, 454 ], [ 456 ], [ 458 ], [ 462, 464 ], [ 466 ], [ 468 ], [ 470 ], [ 472 ], [ 474, 476 ], [ 478, 480, 482 ], [ 484 ], [ 486 ], [ 488 ], [ 490 ], [ 492 ], [ 494 ], [ 496 ], [ 498 ], [ 500 ], [ 502, 504, 506, 508 ], [ 510 ], [ 512 ], [ 514 ], [ 516 ], [ 518 ], [ 522 ], [ 524 ], [ 526 ], [ 530 ], [ 532 ], [ 534 ], [ 538 ], [ 542 ], [ 544, 546 ], [ 548 ], [ 552, 554 ], [ 556 ], [ 558 ], [ 560 ], [ 562 ], [ 566, 568 ], [ 572 ], [ 574 ] ]

[ "FUNC_0(PVSCSIState *VAR_0)\n{", "PVSCSICmdDescSetupRings *rc =\n(PVSCSICmdDescSetupRings *) VAR_0->curr_cmd_data;", "trace_pvscsi_on_cmd_arrived(\"PVSCSI_CMD_SETUP_RINGS\");", "pvscsi_dbg_dump_tx_rings_config(rc);", "pvscsi_ring_init_data(&VAR_0->rings, rc);", "VAR_0->rings_info_valid = TRUE;", "return PVSCSI_COMMAND_PROCESSING_SUCCEEDED;", "}" ]

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

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

[ "void FUNC_0(IDWTELEM *VAR_0, IDWTELEM *VAR_1, IDWTELEM *VAR_2, IDWTELEM *VAR_3, IDWTELEM *VAR_4, IDWTELEM *VAR_5, int VAR_6){", "long VAR_7 = VAR_6;", "while(VAR_7 & 15)\n{", "VAR_7--;", "VAR_4[VAR_7] -= (W_DM*(VAR_3[VAR_7] + VAR_5[VAR_7])+W_DO)>>W_DS;", "VAR_3[VAR_7] -= (W_CM*(VAR_2[VAR_7] + VAR_4[VAR_7])+W_CO)>>W_CS;", "VAR_2[VAR_7] += (W_BM*(VAR_1[VAR_7] + VAR_3[VAR_7])+4*VAR_2[VAR_7]+W_BO)>>W_BS;", "VAR_1[VAR_7] += (W_AM*(VAR_0[VAR_7] + VAR_2[VAR_7])+W_AO)>>W_AS;", "}", "VAR_7+=VAR_7;", "asm volatile(\n\"jmp 2f \\n\\t\"\n\"1: \\n\\t\"\nsnow_vertical_compose_mmx_load(\"%4\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_add(\"%6\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_move(\"mm0\",\"mm2\",\"mm4\",\"mm6\",\"mm1\",\"mm3\",\"mm5\",\"mm7\")\nsnow_vertical_compose_sra(\"1\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_r2r_add(\"mm1\",\"mm3\",\"mm5\",\"mm7\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\n\"pcmpeqw %%mm1, %%mm1 \\n\\t\"\n\"psllw $15, %%mm1 \\n\\t\"\n\"psrlw $14, %%mm1 \\n\\t\"\nsnow_vertical_compose_r2r_add(\"mm1\",\"mm1\",\"mm1\",\"mm1\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_sra(\"2\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_load(\"%5\",\"mm1\",\"mm3\",\"mm5\",\"mm7\")\nsnow_vertical_compose_r2r_sub(\"mm0\",\"mm2\",\"mm4\",\"mm6\",\"mm1\",\"mm3\",\"mm5\",\"mm7\")\nsnow_vertical_compose_mmx_store(\"%5\",\"mm1\",\"mm3\",\"mm5\",\"mm7\")\nsnow_vertical_compose_mmx_load(\"%4\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_add(\"%3\",\"mm1\",\"mm3\",\"mm5\",\"mm7\")\nsnow_vertical_compose_r2r_sub(\"mm1\",\"mm3\",\"mm5\",\"mm7\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_store(\"%4\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\n\"pcmpeqw %%mm7, %%mm7 \\n\\t\"\n\"pcmpeqw %%mm5, %%mm5 \\n\\t\"\n\"psllw $15, %%mm7 \\n\\t\"\n\"psrlw $13, %%mm5 \\n\\t\"\n\"paddw %%mm7, %%mm5 \\n\\t\"\nsnow_vertical_compose_r2r_add(\"mm5\",\"mm5\",\"mm5\",\"mm5\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\n\"movq (%2,%%\"REG_d\"), %%mm1 \\n\\t\"\n\"movq 8(%2,%%\"REG_d\"), %%mm3 \\n\\t\"\n\"paddw %%mm7, %%mm1 \\n\\t\"\n\"paddw %%mm7, %%mm3 \\n\\t\"\n\"pavgw %%mm1, %%mm0 \\n\\t\"\n\"pavgw %%mm3, %%mm2 \\n\\t\"\n\"movq 16(%2,%%\"REG_d\"), %%mm1 \\n\\t\"\n\"movq 24(%2,%%\"REG_d\"), %%mm3 \\n\\t\"\n\"paddw %%mm7, %%mm1 \\n\\t\"\n\"paddw %%mm7, %%mm3 \\n\\t\"\n\"pavgw %%mm1, %%mm4 \\n\\t\"\n\"pavgw %%mm3, %%mm6 \\n\\t\"\nsnow_vertical_compose_r2r_sub(\"mm7\",\"mm7\",\"mm7\",\"mm7\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_sra(\"1\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_add(\"%3\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_sra(\"2\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_add(\"%3\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_store(\"%3\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_add(\"%1\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_move(\"mm0\",\"mm2\",\"mm4\",\"mm6\",\"mm1\",\"mm3\",\"mm5\",\"mm7\")\nsnow_vertical_compose_sra(\"1\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_r2r_add(\"mm1\",\"mm3\",\"mm5\",\"mm7\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_add(\"%2\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\nsnow_vertical_compose_mmx_store(\"%2\",\"mm0\",\"mm2\",\"mm4\",\"mm6\")\n\"2: \\n\\t\"\n\"sub $32, %%\"REG_d\" \\n\\t\"\n\"jge 1b \\n\\t\"\n:\"+d\"(VAR_7)\n:\"r\"(VAR_0),\"r\"(VAR_1),\"r\"(VAR_2),\"r\"(VAR_3),\"r\"(VAR_4),\"r\"(VAR_5));", "}" ]

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

[ [ 1 ], [ 3 ], [ 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23, 25, 27, 31, 33, 35, 37, 39, 43, 45, 47, 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, 113, 115, 117, 119, 121, 123, 125, 127, 129, 133, 135, 137, 139, 141 ], [ 143 ] ]

[ "static int FUNC_0(QemuOpts *VAR_0, void *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "int64_t fdset_id;", "const char *VAR_5 = NULL;", "VAR_2 = qemu_opt_get_number(VAR_0, \"VAR_2\", -1);", "fdset_id = qemu_opt_get_number(VAR_0, \"set\", -1);", "VAR_5 = qemu_opt_get(VAR_0, \"VAR_1\");", "if (VAR_2 < 0) {", "qerror_report(ERROR_CLASS_GENERIC_ERROR,\n\"VAR_2 option is required and must be non-negative\");", "return -1;", "}", "if (VAR_2 <= STDERR_FILENO) {", "qerror_report(ERROR_CLASS_GENERIC_ERROR,\n\"VAR_2 cannot be a standard I/O stream\");", "return -1;", "}", "VAR_4 = fcntl(VAR_2, F_GETFD);", "if (VAR_4 == -1 || (VAR_4 & FD_CLOEXEC)) {", "qerror_report(ERROR_CLASS_GENERIC_ERROR,\n\"VAR_2 is not valid or already in use\");", "return -1;", "}", "if (fdset_id < 0) {", "qerror_report(ERROR_CLASS_GENERIC_ERROR,\n\"set option is required and must be non-negative\");", "return -1;", "}", "#ifdef F_DUPFD_CLOEXEC\nVAR_3 = fcntl(VAR_2, F_DUPFD_CLOEXEC, 0);", "#else\nVAR_3 = dup(VAR_2);", "if (VAR_3 != -1) {", "qemu_set_cloexec(VAR_3);", "}", "#endif\nif (VAR_3 == -1) {", "qerror_report(ERROR_CLASS_GENERIC_ERROR,\n\"Error duplicating VAR_2: %s\", strerror(errno));", "return -1;", "}", "monitor_fdset_add_fd(VAR_3, true, fdset_id, VAR_5 ? true : false,\nVAR_5, NULL);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 79, 81 ], [ 83, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 109, 111 ], [ 115 ], [ 117 ] ]

[ "void FUNC_0(AVThreadMessageQueue *VAR_0)\n{", "#if HAVE_THREADS\nint used, off;", "void *free_func = VAR_0->free_func;", "pthread_mutex_lock(&VAR_0->lock);", "used = av_fifo_size(VAR_0->fifo);", "if (free_func)\nfor (off = 0; off < used; off += VAR_0->elsize)", "av_fifo_generic_peek_at(VAR_0->fifo, VAR_0, off, VAR_0->elsize, free_func_wrap);", "av_fifo_drain(VAR_0->fifo, used);", "pthread_cond_broadcast(&VAR_0->cond);", "pthread_mutex_unlock(&VAR_0->lock);", "#endif\n}" ]

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

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

[ "int FUNC_0(AVFormatContext **VAR_0,\nAVIOContext *VAR_1, const char *VAR_2,\nAVInputFormat *VAR_3, AVFormatParameters *VAR_4)\n{", "int VAR_5;", "AVDictionary *opts;", "AVFormatContext *ic;", "AVFormatParameters default_ap;", "if(!VAR_4){", "VAR_4=&default_ap;", "memset(VAR_4, 0, sizeof(default_ap));", "}", "opts = convert_format_parameters(VAR_4);", "if(!VAR_4->prealloced_context)\nic = avformat_alloc_context();", "else\nic = *VAR_0;", "if (!ic) {", "VAR_5 = AVERROR(ENOMEM);", "goto fail;", "}", "if (VAR_1 && VAR_3 && VAR_3->flags & AVFMT_NOFILE)\nav_log(ic, AV_LOG_WARNING, \"Custom AVIOContext makes no sense and \"\n\"will be ignored with AVFMT_NOFILE format.\\n\");", "else\nic->VAR_1 = VAR_1;", "VAR_5 = avformat_open_input(&ic, VAR_2, VAR_3, &opts);", "ic->VAR_1 = ic->VAR_1 ? ic->VAR_1 : VAR_1;", "*VAR_0 = ic;", "fail:\nav_dict_free(&opts);", "return VAR_5;", "}" ]

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

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

[ "void FUNC_0(Monitor *VAR_0, const QDict *VAR_1)\n{", "x86_cpu_dump_local_apic_state(mon_get_cpu(), (FILE *)VAR_0, monitor_fprintf,\nCPU_DUMP_FPU);", "}" ]

[ 0, 1, 0 ]

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

[ "void FUNC_0(Monitor *VAR_0, const char *VAR_1, va_list VAR_2)\n{", "if (!VAR_0)\nreturn;", "if (VAR_0->mc && !VAR_0->mc->print_enabled) {", "qemu_error_new(QERR_UNDEFINED_ERROR);", "} else {", "char VAR_3[4096];", "vsnprintf(VAR_3, sizeof(VAR_3), VAR_1, VAR_2);", "monitor_puts(VAR_0, VAR_3);", "}", "}" ]

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

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

[ "static void FUNC_0(MemoryRegion *VAR_0,\nPCIBus *VAR_1, PIIX4PMState *VAR_2)\n{", "memory_region_init_io(&VAR_2->io_gpe, OBJECT(VAR_2), &piix4_gpe_ops, VAR_2,\n\"acpi-gpe0\", GPE_LEN);", "memory_region_add_subregion(VAR_0, GPE_BASE, &VAR_2->io_gpe);", "acpi_pcihp_init(OBJECT(VAR_2), &VAR_2->acpi_pci_hotplug, VAR_1, VAR_0,\nVAR_2->use_acpi_pci_hotplug);", "VAR_2->cpu_hotplug_legacy = true;", "object_property_add_bool(OBJECT(VAR_2), \"cpu-hotplug-legacy\",\npiix4_get_cpu_hotplug_legacy,\npiix4_set_cpu_hotplug_legacy,\nNULL);", "legacy_acpi_cpu_hotplug_init(VAR_0, OBJECT(VAR_2), &VAR_2->gpe_cpu,\nPIIX4_CPU_HOTPLUG_IO_BASE);", "if (VAR_2->acpi_memory_hotplug.is_enabled) {", "acpi_memory_hotplug_init(VAR_0, OBJECT(VAR_2), &VAR_2->acpi_memory_hotplug);", "}", "}" ]

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

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

[ "long FUNC_0(CPUX86State *VAR_0)\n{", "struct sigframe *VAR_1;", "abi_ulong frame_addr = VAR_0->regs[R_ESP] - 8;", "target_sigset_t target_set;", "sigset_t set;", "int VAR_2, VAR_3;", "#if defined(DEBUG_SIGNAL)\nfprintf(stderr, \"FUNC_0\\n\");", "#endif\nif (!lock_user_struct(VERIFY_READ, VAR_1, frame_addr, 1))\ngoto badframe;", "if (__get_user(target_set.sig[0], &VAR_1->sc.oldmask))\ngoto badframe;", "for(VAR_3 = 1; VAR_3 < TARGET_NSIG_WORDS; VAR_3++) {", "if (__get_user(target_set.sig[VAR_3], &VAR_1->extramask[VAR_3 - 1]))\ngoto badframe;", "}", "target_to_host_sigset_internal(&set, &target_set);", "sigprocmask(SIG_SETMASK, &set, NULL);", "if (restore_sigcontext(VAR_0, &VAR_1->sc, &VAR_2))\ngoto badframe;", "unlock_user_struct(VAR_1, frame_addr, 0);", "return VAR_2;", "badframe:\nunlock_user_struct(VAR_1, frame_addr, 0);", "force_sig(TARGET_SIGSEGV);", "return 0;", "}" ]

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

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

[ "static ssize_t FUNC_0(VLANClientState *vc, const struct iovec *iov,\nint iovcnt)\n{", "uint8_t buffer[4096];", "size_t offset = 0;", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < iovcnt; VAR_0++) {", "size_t len;", "len = MIN(sizeof(buffer) - offset, iov[VAR_0].iov_len);", "memcpy(buffer + offset, iov[VAR_0].iov_base, len);", "offset += len;", "}", "vc->receive(vc->opaque, buffer, offset);", "return offset;", "}" ]

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

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

[ "void FUNC_0(BlockdevBackup *VAR_0, BlockJobTxn *VAR_1, Error **VAR_2)\n{", "BlockDriverState *bs;", "BlockDriverState *target_bs;", "Error *local_err = NULL;", "AioContext *aio_context;", "if (!VAR_0->has_speed) {", "VAR_0->speed = 0;", "}", "if (!VAR_0->has_on_source_error) {", "VAR_0->on_source_error = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_0->has_on_target_error) {", "VAR_0->on_target_error = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_0->has_job_id) {", "VAR_0->job_id = NULL;", "}", "bs = qmp_get_root_bs(VAR_0->device, VAR_2);", "if (!bs) {", "return;", "}", "aio_context = bdrv_get_aio_context(bs);", "aio_context_acquire(aio_context);", "target_bs = bdrv_lookup_bs(VAR_0->target, VAR_0->target, VAR_2);", "if (!target_bs) {", "goto out;", "}", "if (bdrv_get_aio_context(target_bs) != aio_context) {", "if (!bdrv_has_blk(target_bs)) {", "bdrv_set_aio_context(target_bs, aio_context);", "} else {", "error_setg(VAR_2, \"Target is attached to a different thread from \"\n\"source.\");", "goto out;", "}", "}", "backup_start(VAR_0->job_id, bs, target_bs, VAR_0->speed, VAR_0->sync,\nNULL, VAR_0->on_source_error, VAR_0->on_target_error,\nblock_job_cb, bs, VAR_1, &local_err);", "if (local_err != NULL) {", "error_propagate(VAR_2, local_err);", "}", "out:\naio_context_release(aio_context);", "}" ]

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

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

[ "static void FUNC_0(const char *VAR_0,\nTestInputVisitorData *VAR_3,\nvoid (*VAR_2)(TestInputVisitorData *VAR_3, const void *VAR_3))\n{", "g_test_add(VAR_0, TestInputVisitorData, VAR_3, NULL, VAR_2,\nvisitor_input_teardown);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(PowerPCCPU *VAR_0, void *VAR_1, int VAR_2,\nbool VAR_3)\n{", "CPUPPCState *env = &VAR_0->env;", "uint8_t pa_features_206[] = { 6, 0,", "0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 };", "uint8_t pa_features_207[] = { 24, 0,", "0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0,\n0x80, 0x00, 0x00, 0x00, 0x00, 0x00,\n0x00, 0x00, 0x00, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x00, 0x00 };", "uint8_t pa_features_300[] = { 66, 0,", "0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0,\n0x80, 0x00, 0x00, 0x00, 0x00, 0x00,\n0x00, 0x00, 0x00, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x00, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0xC0, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x80, 0x00,\n0x80, 0x00, 0x80, 0x00, 0x00, 0x00,\n};", "uint8_t *pa_features = NULL;", "size_t pa_size;", "if (ppc_check_compat(VAR_0, CPU_POWERPC_LOGICAL_2_06, 0, VAR_0->compat_pvr)) {", "pa_features = pa_features_206;", "pa_size = sizeof(pa_features_206);", "}", "if (ppc_check_compat(VAR_0, CPU_POWERPC_LOGICAL_2_07, 0, VAR_0->compat_pvr)) {", "pa_features = pa_features_207;", "pa_size = sizeof(pa_features_207);", "}", "if (ppc_check_compat(VAR_0, CPU_POWERPC_LOGICAL_3_00, 0, VAR_0->compat_pvr)) {", "pa_features = pa_features_300;", "pa_size = sizeof(pa_features_300);", "}", "if (!pa_features) {", "return;", "}", "if (env->ci_large_pages) {", "pa_features[3] |= 0x20;", "}", "if (kvmppc_has_cap_htm() && pa_size > 24) {", "pa_features[24] |= 0x80;", "}", "if (VAR_3 && pa_size > 40) {", "pa_features[40 + 2] &= ~0x80;", "}", "_FDT((fdt_setprop(VAR_1, VAR_2, \"ibm,pa-features\", pa_features, pa_size)));", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17, 19, 21 ], [ 23 ], [ 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ] ]

[ "void *FUNC_0(const BlockJobType *VAR_0, BlockDriverState *VAR_1,\nBlockDriverCompletionFunc *VAR_2, void *VAR_3,\nError **VAR_4)\n{", "BlockJob *job;", "if (VAR_1->job || bdrv_in_use(VAR_1)) {", "error_set(VAR_4, QERR_DEVICE_IN_USE, bdrv_get_device_name(VAR_1));", "return NULL;", "}", "bdrv_set_in_use(VAR_1, 1);", "job = g_malloc0(VAR_0->instance_size);", "job->VAR_0 = VAR_0;", "job->VAR_1 = VAR_1;", "job->VAR_2 = VAR_2;", "job->VAR_3 = VAR_3;", "VAR_1->job = job;", "return job;", "}" ]

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

[ "int FUNC_0(BlockDriverState *VAR_0)\n{", "return !!(VAR_0->open_flags & BDRV_O_SNAPSHOT);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(NvdimmFitBuffer *VAR_0)\n{", "qemu_mutex_init(&VAR_0->lock);", "VAR_0->fit = g_array_new(false, true , 1);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(const void *VAR_0)\n{", "const QCryptoCipherTestData *VAR_1 = VAR_0;", "QCryptoCipher *cipher;", "Error *err = NULL;", "uint8_t *key, *iv, *ciphertext, *plaintext, *outtext;", "size_t nkey, niv, nciphertext, nplaintext;", "char *VAR_2;", "g_test_message(\"foo\");", "nkey = unhex_string(VAR_1->key, &key);", "niv = unhex_string(VAR_1->iv, &iv);", "nciphertext = unhex_string(VAR_1->ciphertext, &ciphertext);", "nplaintext = unhex_string(VAR_1->plaintext, &plaintext);", "g_assert(nciphertext == nplaintext);", "outtext = g_new0(uint8_t, nciphertext);", "cipher = qcrypto_cipher_new(\nVAR_1->alg, VAR_1->mode,\nkey, nkey,\n&err);", "g_assert(cipher != NULL);", "g_assert(err == NULL);", "if (iv) {", "g_assert(qcrypto_cipher_setiv(cipher,\niv, niv,\n&err) == 0);", "g_assert(err == NULL);", "}", "g_assert(qcrypto_cipher_encrypt(cipher,\nplaintext,\nouttext,\nnplaintext,\n&err) == 0);", "g_assert(err == NULL);", "VAR_2 = hex_string(outtext, nciphertext);", "g_assert_cmpstr(VAR_2, ==, VAR_1->ciphertext);", "g_free(outtext);", "g_free(VAR_2);", "g_free(key);", "g_free(iv);", "g_free(ciphertext);", "g_free(plaintext);", "qcrypto_cipher_free(cipher);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 41, 43, 45, 47 ], [ 49 ], [ 51 ], [ 57 ], [ 59, 61, 63 ], [ 65 ], [ 67 ], [ 69, 71, 73, 75, 77 ], [ 79 ], [ 83 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ] ]

[ "static uint64_t FUNC_0(CPUARMState *env, const ARMCPRegInfo *ri)\n{", "return simple_mpu_ap_bits(env->cp15.c5_insn);", "}" ]

[ 0, 1, 0 ]

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx) {", "if (avctx->channels > 1) {", "av_log(avctx, AV_LOG_ERROR, \"Mono required for GSM, got %d channels\\n\",\navctx->channels);", "return -1;", "if (avctx->sample_rate != 8000) {", "av_log(avctx, AV_LOG_ERROR, \"Sample rate 8000Hz required for GSM, got %dHz\\n\",\navctx->sample_rate);", "if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)\nreturn -1;", "if (avctx->bit_rate != 13000 &&\navctx->bit_rate != 13200 &&\navctx->bit_rate != 0 ) {", "av_log(avctx, AV_LOG_ERROR, \"Bitrate 13000bps required for GSM, got %dbps\\n\",\navctx->bit_rate);", "if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)\nreturn -1;", "avctx->priv_data = gsm_create();", "switch(avctx->codec_id) {", "case CODEC_ID_GSM:\navctx->frame_size = GSM_FRAME_SIZE;", "avctx->block_align = GSM_BLOCK_SIZE;", "break;", "case CODEC_ID_GSM_MS: {", "int VAR_0 = 1;", "gsm_option(avctx->priv_data, GSM_OPT_WAV49, &VAR_0);", "avctx->frame_size = 2*GSM_FRAME_SIZE;", "avctx->block_align = GSM_MS_BLOCK_SIZE;", "avctx->coded_frame= avcodec_alloc_frame();", "return 0;" ]

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

[ [ 1 ], [ 3 ], [ 5, 7 ], [ 9 ], [ 14 ], [ 16, 18 ], [ 20, 22 ], [ 25, 27, 29 ], [ 31, 33 ], [ 35, 37 ], [ 42 ], [ 46 ], [ 48, 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 70 ], [ 78 ] ]

[ "static void FUNC_0(uint8_t *VAR_0,\nint32_t VAR_1,\nint32_t VAR_2,\nint32_t VAR_3,\nint32_t VAR_4)\n{", "uint32_t data0, data1;", "v16u8 zero = { 0 };", "v16u8 src0, src1;", "v4i32 res0, res1;", "v8i16 temp0, temp1;", "v16u8 vec0, vec1;", "v8i16 wgt, denom, offset;", "VAR_4 <<= (VAR_2);", "if (VAR_2) {", "VAR_4 += (1 << (VAR_2 - 1));", "}", "wgt = __msa_fill_h(VAR_3);", "offset = __msa_fill_h(VAR_4);", "denom = __msa_fill_h(VAR_2);", "data0 = LOAD_WORD(VAR_0);", "data1 = LOAD_WORD(VAR_0 + VAR_1);", "src0 = (v16u8) __msa_fill_w(data0);", "src1 = (v16u8) __msa_fill_w(data1);", "ILVR_B_2VECS_UB(src0, src1, zero, zero, vec0, vec1);", "temp0 = wgt * (v8i16) vec0;", "temp1 = wgt * (v8i16) vec1;", "temp0 = __msa_adds_s_h(temp0, offset);", "temp1 = __msa_adds_s_h(temp1, offset);", "temp0 = __msa_maxi_s_h(temp0, 0);", "temp1 = __msa_maxi_s_h(temp1, 0);", "temp0 = __msa_srl_h(temp0, denom);", "temp1 = __msa_srl_h(temp1, denom);", "temp0 = (v8i16) __msa_sat_u_h((v8u16) temp0, 7);", "temp1 = (v8i16) __msa_sat_u_h((v8u16) temp1, 7);", "res0 = (v4i32) __msa_pckev_b((v16i8) temp0, (v16i8) temp0);", "res1 = (v4i32) __msa_pckev_b((v16i8) temp1, (v16i8) temp1);", "data0 = __msa_copy_u_w(res0, 0);", "data1 = __msa_copy_u_w(res1, 0);", "STORE_WORD(VAR_0, data0);", "VAR_0 += VAR_1;", "STORE_WORD(VAR_0, data1);", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "BDRVQuorumState *s = VAR_0->opaque;", "Error *local_err = NULL;", "QemuOpts *opts;", "bool *opened;", "QDict *sub = NULL;", "QList *list = NULL;", "const QListEntry *VAR_4;", "int VAR_5;", "int VAR_6 = 0;", "qdict_flatten(VAR_1);", "qdict_extract_subqdict(VAR_1, &sub, \"children.\");", "qdict_array_split(sub, &list);", "if (qdict_size(sub)) {", "error_setg(&local_err, \"Invalid option children.%s\",\nqdict_first(sub)->key);", "VAR_6 = -EINVAL;", "goto exit;", "}", "s->num_children = qlist_size(list);", "if (s->num_children < 2) {", "error_setg(&local_err,\n\"Number of provided children must be greater than 1\");", "VAR_6 = -EINVAL;", "goto exit;", "}", "opts = qemu_opts_create(&quorum_runtime_opts, NULL, 0, &error_abort);", "qemu_opts_absorb_qdict(opts, VAR_1, &local_err);", "if (local_err) {", "VAR_6 = -EINVAL;", "goto exit;", "}", "s->threshold = qemu_opt_get_number(opts, QUORUM_OPT_VOTE_THRESHOLD, 0);", "VAR_6 = quorum_valid_threshold(s->threshold, s->num_children, &local_err);", "if (VAR_6 < 0) {", "goto exit;", "}", "if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false) &&\ns->num_children == 2 && s->threshold == 2) {", "s->is_blkverify = true;", "} else if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false)) {", "fprintf(stderr, \"blkverify mode is set by setting blkverify=on \"\n\"and using two files with vote_threshold=2\\n\");", "}", "s->rewrite_corrupted = qemu_opt_get_bool(opts, QUORUM_OPT_REWRITE, false);", "if (s->rewrite_corrupted && s->is_blkverify) {", "error_setg(&local_err,\n\"rewrite-corrupted=on cannot be used with blkverify=on\");", "VAR_6 = -EINVAL;", "goto exit;", "}", "s->VAR_0 = g_new0(BlockDriverState *, s->num_children);", "opened = g_new0(bool, s->num_children);", "for (VAR_5 = 0, VAR_4 = qlist_first(list); VAR_4;", "VAR_4 = qlist_next(VAR_4), VAR_5++) {", "QDict *d;", "QString *string;", "switch (qobject_type(VAR_4->value))\n{", "case QTYPE_QDICT:\nd = qobject_to_qdict(VAR_4->value);", "QINCREF(d);", "VAR_6 = bdrv_open(&s->VAR_0[VAR_5], NULL, NULL, d, VAR_2, NULL,\n&local_err);", "break;", "case QTYPE_QSTRING:\nstring = qobject_to_qstring(VAR_4->value);", "VAR_6 = bdrv_open(&s->VAR_0[VAR_5], NULL, qstring_get_str(string), NULL,\nVAR_2, NULL, &local_err);", "break;", "default:\nerror_setg(&local_err, \"Specification of child block device %VAR_5 \"\n\"is invalid\", VAR_5);", "VAR_6 = -EINVAL;", "}", "if (VAR_6 < 0) {", "goto close_exit;", "}", "opened[VAR_5] = true;", "}", "g_free(opened);", "goto exit;", "close_exit:\nfor (VAR_5 = 0; VAR_5 < s->num_children; VAR_5++) {", "if (!opened[VAR_5]) {", "continue;", "}", "bdrv_unref(s->VAR_0[VAR_5]);", "}", "g_free(s->VAR_0);", "g_free(opened);", "exit:\nif (local_err) {", "error_propagate(VAR_3, local_err);", "}", "QDECREF(list);", "QDECREF(sub);", "return VAR_6;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 43 ], [ 45 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 115 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149, 151 ], [ 155, 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 171, 173 ], [ 175, 177 ], [ 179 ], [ 183, 185, 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 213, 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ] ]

[ "void FUNC_0(MDCTContext *VAR_0, FFTSample *VAR_1,\nconst FFTSample *VAR_2, FFTSample *VAR_3)\n{", "long VAR_4, VAR_5, VAR_6, VAR_7;", "x86_reg k;", "const uint16_t *VAR_8 = VAR_0->fft.VAR_8;", "const FFTSample *VAR_9 = VAR_0->VAR_9;", "const FFTSample *VAR_10 = VAR_0->VAR_10;", "const FFTSample *VAR_11, *in2;", "FFTComplex *z = (FFTComplex *)VAR_3;", "VAR_7 = 1 << VAR_0->nbits;", "VAR_6 = VAR_7 >> 1;", "VAR_5 = VAR_7 >> 2;", "VAR_4 = VAR_7 >> 3;", "VAR_11 = VAR_2;", "in2 = VAR_2 + VAR_6 - 1;", "for(k = 0; k < VAR_5; k++) {", "asm volatile(\n\"movd %0, %%mm0 \\VAR_7\\t\"\n\"movd %2, %%mm1 \\VAR_7\\t\"\n\"punpckldq %1, %%mm0 \\VAR_7\\t\"\n\"punpckldq %3, %%mm1 \\VAR_7\\t\"\n\"movq %%mm0, %%mm2 \\VAR_7\\t\"\n\"pfmul %%mm1, %%mm0 \\VAR_7\\t\"\n\"pswapd %%mm1, %%mm1 \\VAR_7\\t\"\n\"pfmul %%mm1, %%mm2 \\VAR_7\\t\"\n\"pfpnacc %%mm2, %%mm0 \\VAR_7\\t\"\n::\"m\"(in2[-2*k]), \"m\"(VAR_11[2*k]),\n\"m\"(VAR_9[k]), \"m\"(VAR_10[k])\n);", "asm volatile(\n\"movq %%mm0, %0 \\VAR_7\\t\"\n:\"=m\"(z[VAR_8[k]])\n);", "}", "ff_fft_calc(&VAR_0->fft, z);", "for(k = 0; k < VAR_5; k++) {", "asm volatile(\n\"movq %0, %%mm0 \\VAR_7\\t\"\n\"movd %1, %%mm1 \\VAR_7\\t\"\n\"punpckldq %2, %%mm1 \\VAR_7\\t\"\n\"movq %%mm0, %%mm2 \\VAR_7\\t\"\n\"pfmul %%mm1, %%mm0 \\VAR_7\\t\"\n\"pswapd %%mm1, %%mm1 \\VAR_7\\t\"\n\"pfmul %%mm1, %%mm2 \\VAR_7\\t\"\n\"pfpnacc %%mm2, %%mm0 \\VAR_7\\t\"\n\"movq %%mm0, %0 \\VAR_7\\t\"\n:\"+m\"(z[k])\n:\"m\"(VAR_9[k]), \"m\"(VAR_10[k])\n);", "}", "k = VAR_7-8;", "asm volatile(\"movd %0, %%mm7\" ::\"r\"(1<<31));", "asm volatile(\n\"1: \\VAR_7\\t\"\n\"movq (%4,%0), %%mm0 \\VAR_7\\t\"\n\"neg %0 \\VAR_7\\t\"\n\"pswapd -8(%4,%0), %%mm1 \\VAR_7\\t\"\n\"movq %%mm0, %%mm2 \\VAR_7\\t\"\n\"pxor %%mm7, %%mm2 \\VAR_7\\t\"\n\"punpckldq %%mm1, %%mm2 \\VAR_7\\t\"\n\"pswapd %%mm2, %%mm3 \\VAR_7\\t\"\n\"punpckhdq %%mm1, %%mm0 \\VAR_7\\t\"\n\"pswapd %%mm0, %%mm4 \\VAR_7\\t\"\n\"pxor %%mm7, %%mm0 \\VAR_7\\t\"\n\"pxor %%mm7, %%mm4 \\VAR_7\\t\"\n\"movq %%mm3, -8(%3,%0) \\VAR_7\\t\"\n\"movq %%mm4, -8(%2,%0) \\VAR_7\\t\"\n\"neg %0 \\VAR_7\\t\"\n\"movq %%mm0, (%1,%0) \\VAR_7\\t\"\n\"movq %%mm2, (%2,%0) \\VAR_7\\t\"\n\"sub $8, %0 \\VAR_7\\t\"\n\"jge 1b \\VAR_7\\t\"\n:\"+r\"(k)\n:\"r\"(VAR_1), \"r\"(VAR_1+VAR_6), \"r\"(VAR_1+VAR_7), \"r\"(z+VAR_4)\n:\"memory\"\n);", "asm volatile(\"femms\");", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 35 ], [ 37 ], [ 39 ], [ 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67 ], [ 69, 71, 73, 75 ], [ 77 ], [ 81 ], [ 87 ], [ 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113 ], [ 115 ], [ 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 ] ]

[ "void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{", "avc_luma_vt_qrt_8w_msa(VAR_1 - (VAR_2 * 2), VAR_2, VAR_0, VAR_2, 8, 0);", "}" ]

[ 0, 0, 0 ]

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

[ "int VAR_0 avcodec_open(AVCodecContext *avctx, AVCodec *codec)\n{", "int ret = 0;", "if (ff_lockmgr_cb) {", "if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))\nreturn -1;", "}", "entangled_thread_counter++;", "if(entangled_thread_counter != 1){", "av_log(avctx, AV_LOG_ERROR, \"insufficient thread locking around avcodec_open/close()\\n\");", "ret = -1;", "goto end;", "}", "if(avctx->codec || !codec) {", "ret = AVERROR(EINVAL);", "goto end;", "}", "if (codec->priv_data_size > 0) {", "if(!avctx->priv_data){", "avctx->priv_data = av_mallocz(codec->priv_data_size);", "if (!avctx->priv_data) {", "ret = AVERROR(ENOMEM);", "goto end;", "}", "if(codec->priv_class){", "*(AVClass**)avctx->priv_data= codec->priv_class;", "av_opt_set_defaults(avctx->priv_data);", "}", "}", "} else {", "avctx->priv_data = NULL;", "}", "if(avctx->coded_width && avctx->coded_height)\navcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);", "else if(avctx->width && avctx->height)\navcodec_set_dimensions(avctx, avctx->width, avctx->height);", "if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)\n&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0\n|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {", "av_log(avctx, AV_LOG_WARNING, \"ignoring invalid width/height values\\n\");", "avcodec_set_dimensions(avctx, 0, 0);", "}", "if (codec->decode)\nav_freep(&avctx->subtitle_header);", "#define SANE_NB_CHANNELS 128U\nif (avctx->channels > SANE_NB_CHANNELS) {", "ret = AVERROR(EINVAL);", "goto free_and_end;", "}", "avctx->codec = codec;", "if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&\navctx->codec_id == CODEC_ID_NONE) {", "avctx->codec_type = codec->type;", "avctx->codec_id = codec->id;", "}", "if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type\n&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {", "av_log(avctx, AV_LOG_ERROR, \"codec type or id mismatches\\n\");", "ret = AVERROR(EINVAL);", "goto free_and_end;", "}", "avctx->frame_number = 0;", "if (HAVE_THREADS && !avctx->thread_opaque) {", "ret = ff_thread_init(avctx);", "if (ret < 0) {", "goto free_and_end;", "}", "}", "if (avctx->codec->max_lowres < avctx->lowres) {", "av_log(avctx, AV_LOG_ERROR, \"The maximum value for lowres supported by the decoder is %d\\n\",\navctx->codec->max_lowres);", "ret = AVERROR(EINVAL);", "goto free_and_end;", "}", "if (avctx->codec->sample_fmts && avctx->codec->encode) {", "int i;", "for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)", "if (avctx->sample_fmt == avctx->codec->sample_fmts[i])\nbreak;", "if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {", "av_log(avctx, AV_LOG_ERROR, \"Specified sample_fmt is not supported.\\n\");", "ret = AVERROR(EINVAL);", "goto free_and_end;", "}", "}", "if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){", "ret = avctx->codec->init(avctx);", "if (ret < 0) {", "goto free_and_end;", "}", "}", "end:\nentangled_thread_counter--;", "if (ff_lockmgr_cb) {", "(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);", "}", "return ret;", "free_and_end:\nav_freep(&avctx->priv_data);", "avctx->codec= NULL;", "goto end;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77, 79 ], [ 81, 83 ], [ 87, 89, 91 ], [ 93 ], [ 95 ], [ 97 ], [ 105, 107 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167, 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183, 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213, 215 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 237 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1,\nint *VAR_2)\n{", "WMAVoiceContext *s = VAR_0->priv_data;", "GetBitContext *gb = &s->gb, s_gb;", "int VAR_3, VAR_4, VAR_5 = 480;", "double VAR_6[MAX_FRAMES][MAX_LSPS];", "const double *VAR_7 = s->VAR_6 == 16 ?\nwmavoice_mean_lsf16[s->lsp_def_mode] : wmavoice_mean_lsf10[s->lsp_def_mode];", "float VAR_8[MAX_SIGNAL_HISTORY + MAX_SFRAMESIZE + 12];", "float VAR_9[MAX_LSPS + MAX_SFRAMESIZE];", "float *VAR_10;", "memcpy(VAR_9, s->synth_history,\ns->VAR_6 * sizeof(*VAR_9));", "memcpy(VAR_8, s->excitation_history,\ns->history_nsamples * sizeof(*VAR_8));", "if (s->sframe_cache_size > 0) {", "gb = &s_gb;", "init_get_bits(gb, s->sframe_cache, s->sframe_cache_size);", "s->sframe_cache_size = 0;", "}", "if ((VAR_4 = check_bits_for_superframe(gb, s)) == 1) {", "*VAR_2 = 0;", "return 1;", "} else if (VAR_4 < 0)", "return VAR_4;", "if (!get_bits1(gb)) {", "avpriv_request_sample(VAR_0, \"WMAPro-in-WMAVoice\");", "return AVERROR_PATCHWELCOME;", "}", "if (get_bits1(gb)) {", "if ((VAR_5 = get_bits(gb, 12)) > 480) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Superframe encodes >480 VAR_10 (%d), not allowed\\VAR_3\",\nVAR_5);", "return AVERROR_INVALIDDATA;", "}", "}", "if (s->has_residual_lsps) {", "double VAR_11[MAX_LSPS], a1[MAX_LSPS * 2], a2[MAX_LSPS * 2];", "for (VAR_3 = 0; VAR_3 < s->VAR_6; VAR_3++)", "VAR_11[VAR_3] = s->VAR_11[VAR_3] - VAR_7[VAR_3];", "if (s->VAR_6 == 10) {", "dequant_lsp10r(gb, VAR_6[2], VAR_11, a1, a2, s->lsp_q_mode);", "} else", "dequant_lsp16r(gb, VAR_6[2], VAR_11, a1, a2, s->lsp_q_mode);", "for (VAR_3 = 0; VAR_3 < s->VAR_6; VAR_3++) {", "VAR_6[0][VAR_3] = VAR_7[VAR_3] + (a1[VAR_3] - a2[VAR_3 * 2]);", "VAR_6[1][VAR_3] = VAR_7[VAR_3] + (a1[s->VAR_6 + VAR_3] - a2[VAR_3 * 2 + 1]);", "VAR_6[2][VAR_3] += VAR_7[VAR_3];", "}", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++)", "stabilize_lsps(VAR_6[VAR_3], s->VAR_6);", "}", "VAR_1->nb_samples = 480;", "if ((VAR_4 = ff_get_buffer(VAR_0, VAR_1, 0)) < 0)\nreturn VAR_4;", "VAR_1->nb_samples = VAR_5;", "VAR_10 = (float *)VAR_1->data[0];", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "if (!s->has_residual_lsps) {", "int VAR_12;", "if (s->VAR_6 == 10) {", "dequant_lsp10i(gb, VAR_6[VAR_3]);", "} else", "dequant_lsp16i(gb, VAR_6[VAR_3]);", "for (VAR_12 = 0; VAR_12 < s->VAR_6; VAR_12++)", "VAR_6[VAR_3][VAR_12] += VAR_7[VAR_12];", "stabilize_lsps(VAR_6[VAR_3], s->VAR_6);", "}", "if ((VAR_4 = synth_frame(VAR_0, gb, VAR_3,\n&VAR_10[VAR_3 * MAX_FRAMESIZE],\nVAR_6[VAR_3], VAR_3 == 0 ? s->VAR_11 : VAR_6[VAR_3 - 1],\n&VAR_8[s->history_nsamples + VAR_3 * MAX_FRAMESIZE],\n&VAR_9[s->VAR_6 + VAR_3 * MAX_FRAMESIZE]))) {", "*VAR_2 = 0;", "return VAR_4;", "}", "}", "if (get_bits1(gb)) {", "VAR_4 = get_bits(gb, 4);", "skip_bits(gb, 10 * (VAR_4 + 1));", "}", "*VAR_2 = 1;", "memcpy(s->VAR_11, VAR_6[2],\ns->VAR_6 * sizeof(*s->VAR_11));", "memcpy(s->synth_history, &VAR_9[MAX_SFRAMESIZE],\ns->VAR_6 * sizeof(*VAR_9));", "memcpy(s->excitation_history, &VAR_8[MAX_SFRAMESIZE],\ns->history_nsamples * sizeof(*VAR_8));", "if (s->do_apf)\nmemmove(s->zero_exc_pf, &s->zero_exc_pf[MAX_SFRAMESIZE],\ns->history_nsamples * sizeof(*s->zero_exc_pf));", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85, 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183, 185, 187, 189, 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 225, 227 ], [ 229, 231 ], [ 233, 235 ], [ 237, 239, 241 ], [ 245 ], [ 247 ] ]

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(VAR_0);", "k->init = virtual_css_bridge_init;", "dc->no_user = 1;", "}" ]

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

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

[ "static void FUNC_0(MpegEncContext *VAR_0, Picture *VAR_1){", "int VAR_2;", "if(VAR_1->data[0] && VAR_1->type!=FF_BUFFER_TYPE_SHARED){", "free_frame_buffer(VAR_0, VAR_1);", "}", "av_freep(&VAR_1->mb_var);", "av_freep(&VAR_1->mc_mb_var);", "av_freep(&VAR_1->mb_mean);", "av_freep(&VAR_1->mbskip_table);", "av_freep(&VAR_1->qscale_table);", "av_freep(&VAR_1->mb_type_base);", "av_freep(&VAR_1->dct_coeff);", "av_freep(&VAR_1->pan_scan);", "VAR_1->mb_type= NULL;", "for(VAR_2=0; VAR_2<2; VAR_2++){", "av_freep(&VAR_1->motion_val_base[VAR_2]);", "av_freep(&VAR_1->ref_index[VAR_2]);", "}", "if(VAR_1->type == FF_BUFFER_TYPE_SHARED){", "for(VAR_2=0; VAR_2<4; VAR_2++){", "VAR_1->base[VAR_2]=\nVAR_1->data[VAR_2]= NULL;", "}", "VAR_1->type= 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 ]

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

[ "static void FUNC_0(BdrvTrackedRequest *VAR_0,\nBlockDriverState *VAR_1,\nint64_t VAR_2,\nint VAR_3, bool VAR_4)\n{", "*VAR_0 = (BdrvTrackedRequest){", ".VAR_1 = VAR_1,\n.VAR_2 = VAR_2,\n.VAR_3 = VAR_3,\n.VAR_4 = VAR_4,\n};", "qemu_co_queue_init(&VAR_0->wait_queue);", "QLIST_INSERT_HEAD(&VAR_1->tracked_requests, VAR_0, list);", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13, 15, 17, 19, 22 ], [ 26 ], [ 30 ], [ 32 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "int VAR_1;", "MOVContext *mov = VAR_0->priv_data;", "for(VAR_1=0; VAR_1<mov->total_streams; VAR_1++)", "mov_free_stream_context(mov->streams[VAR_1]);", "for(VAR_1=0; VAR_1<VAR_0->nb_streams; VAR_1++)", "av_free(VAR_0->streams[VAR_1]);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "AACContext *ac = VAR_0->priv_data;", "ChannelElement *che = NULL, *che_prev = NULL;", "GetBitContext gb;", "enum RawDataBlockType VAR_6, VAR_7 = TYPE_END;", "int VAR_8, VAR_9, VAR_10;", "int VAR_11;", "int VAR_12 = 1024, VAR_13;", "int VAR_14;", "init_get_bits(&gb, VAR_4, VAR_5 * 8);", "if (show_bits(&gb, 12) == 0xfff) {", "if (parse_adts_frame_header(ac, &gb) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Error decoding AAC frame header.\\n\");", "return -1;", "}", "if (ac->m4ac.sampling_index > 12) {", "av_log(ac->VAR_0, AV_LOG_ERROR, \"invalid sampling rate index %d\\n\", ac->m4ac.sampling_index);", "return -1;", "}", "}", "while ((VAR_6 = get_bits(&gb, 3)) != TYPE_END) {", "VAR_9 = get_bits(&gb, 4);", "if (VAR_6 < TYPE_DSE && !(che=get_che(ac, VAR_6, VAR_9))) {", "av_log(ac->VAR_0, AV_LOG_ERROR, \"channel element %d.%d is not allocated\\n\", VAR_6, VAR_9);", "return -1;", "}", "switch (VAR_6) {", "case TYPE_SCE:\nVAR_8 = decode_ics(ac, &che->ch[0], &gb, 0, 0);", "break;", "case TYPE_CPE:\nVAR_8 = decode_cpe(ac, &gb, che);", "break;", "case TYPE_CCE:\nVAR_8 = decode_cce(ac, &gb, che);", "break;", "case TYPE_LFE:\nVAR_8 = decode_ics(ac, &che->ch[0], &gb, 0, 0);", "break;", "case TYPE_DSE:\nVAR_8 = skip_data_stream_element(ac, &gb);", "break;", "case TYPE_PCE: {", "enum ChannelPosition VAR_15[4][MAX_ELEM_ID];", "memset(VAR_15, 0, 4 * MAX_ELEM_ID * sizeof(VAR_15[0][0]));", "if ((VAR_8 = decode_pce(ac, VAR_15, &gb)))\nbreak;", "if (ac->output_configured > OC_TRIAL_PCE)\nav_log(VAR_0, AV_LOG_ERROR,\n\"Not evaluating a further program_config_element as this construct is dubious at best.\\n\");", "else\nVAR_8 = output_configure(ac, ac->che_pos, VAR_15, 0, OC_TRIAL_PCE);", "break;", "}", "case TYPE_FIL:\nif (VAR_9 == 15)\nVAR_9 += get_bits(&gb, 8) - 1;", "if (get_bits_left(&gb) < 8 * VAR_9) {", "av_log(VAR_0, AV_LOG_ERROR, overread_err);", "return -1;", "}", "while (VAR_9 > 0)\nVAR_9 -= decode_extension_payload(ac, &gb, VAR_9, che_prev, VAR_7);", "VAR_8 = 0;", "break;", "default:\nVAR_8 = -1;", "break;", "}", "che_prev = che;", "VAR_7 = VAR_6;", "if (VAR_8)\nreturn VAR_8;", "if (get_bits_left(&gb) < 3) {", "av_log(VAR_0, AV_LOG_ERROR, overread_err);", "return -1;", "}", "}", "spectral_to_sample(ac);", "VAR_13 = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0;", "VAR_12 <<= VAR_13;", "if (ac->output_configured < OC_LOCKED) {", "VAR_0->sample_rate = ac->m4ac.sample_rate << VAR_13;", "VAR_0->frame_size = VAR_12;", "}", "VAR_10 = VAR_12 * VAR_0->channels * sizeof(int16_t);", "if (*VAR_2 < VAR_10) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Output buffer too small (%d) or trying to output too many VAR_12 (%d) for this frame.\\n\",\n*VAR_2, VAR_10);", "return -1;", "}", "*VAR_2 = VAR_10;", "ac->dsp.float_to_int16_interleave(VAR_1, (const float **)ac->output_data, VAR_12, VAR_0->channels);", "if (ac->output_configured)\nac->output_configured = OC_LOCKED;", "VAR_11 = (get_bits_count(&gb) + 7) >> 3;", "for (VAR_14 = VAR_11; VAR_14 < VAR_5; VAR_14++)", "if (VAR_4[VAR_14])\nbreak;", "return VAR_5 > VAR_14 ? VAR_11 : 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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 58 ], [ 60 ], [ 64 ], [ 66 ], [ 68 ], [ 70 ], [ 74 ], [ 78, 80 ], [ 82 ], [ 86, 88 ], [ 90 ], [ 94, 96 ], [ 98 ], [ 102, 104 ], [ 106 ], [ 110, 112 ], [ 114 ], [ 118 ], [ 120 ], [ 122 ], [ 124, 126 ], [ 128, 130, 132 ], [ 134, 136 ], [ 138 ], [ 140 ], [ 144, 146, 148 ], [ 150 ], [ 152 ], [ 154 ], [ 156 ], [ 158, 160 ], [ 162 ], [ 164 ], [ 168, 170 ], [ 172 ], [ 174 ], [ 178 ], [ 180 ], [ 184, 186 ], [ 190 ], [ 192 ], [ 194 ], [ 196 ], [ 198 ], [ 202 ], [ 206 ], [ 208 ], [ 210 ], [ 212 ], [ 214 ], [ 216 ], [ 220 ], [ 222 ], [ 224, 226, 228 ], [ 230 ], [ 232 ], [ 234 ], [ 238 ], [ 242, 244 ], [ 248 ], [ 250 ], [ 252, 254 ], [ 258 ], [ 260 ] ]

[ "static inline void FUNC_0(EncBlockInfo* VAR_0, int* VAR_1)\n{", "int VAR_2[5];", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;", "EncBlockInfo* b;", "VAR_2[4]= 1<<24;", "do {", "b = VAR_0;", "for (VAR_3=0; VAR_3<5; VAR_3++) {", "if (!VAR_1[VAR_3])\ncontinue;", "VAR_1[VAR_3]--;", "VAR_2[VAR_3] = 0;", "for (VAR_4=0; VAR_4<6; VAR_4++, b++) {", "for (VAR_6=0; VAR_6<4; VAR_6++) {", "if (b->area_q[VAR_6] != dv_quant_shifts[VAR_1[VAR_3] + dv_quant_offset[b->cno]][VAR_6]) {", "b->bit_size[VAR_6] = 1;", "b->area_q[VAR_6]++;", "VAR_7= b->VAR_7[VAR_6];", "for (VAR_5= b->next[VAR_7] ; VAR_5<mb_area_start[VAR_6+1]; VAR_5= b->next[VAR_5]) {", "b->mb[VAR_5] >>= 1;", "if (b->mb[VAR_5]) {", "b->bit_size[VAR_6] += dv_rl2vlc_size(VAR_5 - VAR_7 - 1, b->mb[VAR_5]);", "VAR_7= VAR_5;", "} else {", "if(b->next[VAR_5] >= mb_area_start[VAR_6+1] && b->next[VAR_5]<64){", "for(VAR_8=VAR_6+1; b->next[VAR_5] >= mb_area_start[VAR_8+1]; VAR_8++);", "assert(VAR_8<4);", "assert(b->mb[b->next[VAR_5]]);", "b->bit_size[VAR_8] += dv_rl2vlc_size(b->next[VAR_5] - VAR_7 - 1, b->mb[b->next[VAR_5]])\n-dv_rl2vlc_size(b->next[VAR_5] - VAR_5 - 1, b->mb[b->next[VAR_5]]);", "}", "b->next[VAR_7] = b->next[VAR_5];", "}", "}", "b->VAR_7[VAR_6+1]= VAR_7;", "}", "VAR_2[VAR_3] += b->bit_size[VAR_6];", "}", "}", "if(vs_total_ac_bits >= VAR_2[0] + VAR_2[1] + VAR_2[2] + VAR_2[3] + VAR_2[4])\nreturn;", "}", "} while (VAR_1[0]|VAR_1[1]|VAR_1[2]|VAR_1[3]|VAR_1[4]);", "for(VAR_6=2; VAR_6==2 || vs_total_ac_bits < VAR_2[0]; VAR_6+=VAR_6){", "b = VAR_0;", "VAR_2[0] = 5*6*4;", "for (VAR_4=0; VAR_4<6*5; VAR_4++, b++) {", "VAR_7= b->VAR_7[0];", "for (VAR_5= b->next[VAR_7]; VAR_5<64; VAR_5= b->next[VAR_5]) {", "if(b->mb[VAR_5] < VAR_6 && b->mb[VAR_5] > -VAR_6){", "b->next[VAR_7] = b->next[VAR_5];", "}else{", "VAR_2[0] += dv_rl2vlc_size(VAR_5 - VAR_7 - 1, b->mb[VAR_5]);", "VAR_7= VAR_5;", "}", "}", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21, 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 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 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "Hnm4VideoContext *hnm = avctx->priv_data;", "if (avctx->extradata_size < 1) {", "av_log(avctx, AV_LOG_ERROR,\n\"Extradata missing, decoder requires version number\\n\");", "return AVERROR_INVALIDDATA;", "}", "hnm->version = avctx->extradata[0];", "avctx->pix_fmt = AV_PIX_FMT_PAL8;", "hnm->width = avctx->width;", "hnm->height = avctx->height;", "hnm->buffer1 = av_mallocz(avctx->width * avctx->height);", "hnm->buffer2 = av_mallocz(avctx->width * avctx->height);", "hnm->processed = av_mallocz(avctx->width * avctx->height);", "if (!hnm->buffer1 || !hnm->buffer2 || !hnm->processed) {", "av_log(avctx, AV_LOG_ERROR, \"av_mallocz() failed\\n\");", "av_freep(&hnm->buffer1);", "av_freep(&hnm->buffer2);", "av_freep(&hnm->processed);", "return AVERROR(ENOMEM);", "}", "hnm->current = hnm->buffer1;", "hnm->previous = hnm->buffer2;", "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 ], [ 9 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ] ]

[ "static int VAR_0 bdrv_aligned_preadv(BlockDriverState *bs,\nBdrvTrackedRequest *req, int64_t offset, unsigned int bytes,\nint64_t align, QEMUIOVector *qiov, int flags)\n{", "BlockDriver *drv = bs->drv;", "int ret;", "int64_t sector_num = offset >> BDRV_SECTOR_BITS;", "unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;", "assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);", "assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);", "if (flags & BDRV_REQ_COPY_ON_READ) {", "mark_request_serialising(req, bdrv_get_cluster_size(bs));", "}", "wait_serialising_requests(req);", "if (flags & BDRV_REQ_COPY_ON_READ) {", "int pnum;", "ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);", "if (ret < 0) {", "goto out;", "}", "if (!ret || pnum != nb_sectors) {", "ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);", "goto out;", "}", "}", "if (!(bs->zero_beyond_eof && bs->growable)) {", "ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);", "} else {", "int64_t len, total_sectors, max_nb_sectors;", "len = bdrv_getlength(bs);", "if (len < 0) {", "ret = len;", "goto out;", "}", "total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);", "max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),\nalign >> BDRV_SECTOR_BITS);", "if (max_nb_sectors > 0) {", "ret = drv->bdrv_co_readv(bs, sector_num,\nMIN(nb_sectors, max_nb_sectors), qiov);", "} else {", "ret = 0;", "}", "if (ret == 0 && total_sectors < sector_num + nb_sectors) {", "uint64_t offset = MAX(0, total_sectors - sector_num);", "uint64_t bytes = (sector_num + nb_sectors - offset) *\nBDRV_SECTOR_SIZE;", "qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);", "}", "}", "out:\nreturn ret;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 29 ], [ 41 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 121 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143, 145 ], [ 147 ] ]

[ "static uint16_t FUNC_0(NvmeCtrl *n, NvmeIdentify *c)\n{", "NvmeNamespace *ns;", "uint32_t nsid = le32_to_cpu(c->nsid);", "uint64_t prp1 = le64_to_cpu(c->prp1);", "uint64_t prp2 = le64_to_cpu(c->prp2);", "if (nsid == 0 || nsid > n->num_namespaces) {", "return NVME_INVALID_NSID | NVME_DNR;", "}", "ns = &n->namespaces[nsid - 1];", "return nvme_dma_read_prp(n, (uint8_t *)&ns->id_ns, sizeof(ns->id_ns),\nprp1, prp2);", "}" ]

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

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

[ "void FUNC_0(QemuConsole *VAR_0,\nDisplaySurface *VAR_1)\n{", "DisplayState *s = VAR_0->ds;", "DisplaySurface *old_surface = VAR_0->VAR_1;", "DisplayChangeListener *dcl;", "VAR_0->VAR_1 = VAR_1;", "QLIST_FOREACH(dcl, &s->listeners, next) {", "if (VAR_0 != (dcl->VAR_0 ? dcl->VAR_0 : active_console)) {", "continue;", "}", "if (dcl->ops->dpy_gfx_switch) {", "dcl->ops->dpy_gfx_switch(dcl, VAR_1);", "}", "}", "qemu_free_displaysurface(old_surface);", "}" ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "const uint8_t *VAR_6 = VAR_4+VAR_5;", "TqiContext *t = VAR_0->priv_data;", "MpegEncContext *s = &t->s;", "s->width = AV_RL16(&VAR_4[0]);", "s->height = AV_RL16(&VAR_4[2]);", "tqi_calculate_qtable(s, VAR_4[4]);", "VAR_4 += 8;", "if (t->frame.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &t->frame);", "if (s->VAR_0->width!=s->width || s->VAR_0->height!=s->height)\navcodec_set_dimensions(s->VAR_0, s->width, s->height);", "if(VAR_0->get_buffer(VAR_0, &t->frame) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return -1;", "}", "av_fast_malloc(&t->bitstream_buf, &t->bitstream_buf_size, (VAR_6-VAR_4) + FF_INPUT_BUFFER_PADDING_SIZE);", "if (!t->bitstream_buf)\nreturn AVERROR(ENOMEM);", "s->dsp.bswap_buf(t->bitstream_buf, (const uint32_t*)VAR_4, (VAR_6-VAR_4)/4);", "init_get_bits(&s->gb, t->bitstream_buf, 8*(VAR_6-VAR_4));", "s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 0;", "for (s->mb_y=0; s->mb_y<(VAR_0->height+15)/16; s->mb_y++)", "for (s->mb_x=0; s->mb_x<(VAR_0->width+15)/16; s->mb_x++)", "{", "if(tqi_decode_mb(s, t->block) < 0)\nbreak;", "tqi_idct_put(t, t->block);", "}", "*VAR_2 = sizeof(AVFrame);", "*(AVFrame*)VAR_1 = t->frame;", "return VAR_5;", "}" ]

[ 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 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31, 33 ], [ 37, 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ] ]

[ "static void FUNC_0(VAPICROMState *VAR_0, X86CPU *VAR_1, target_ulong VAR_2,\nuint32_t VAR_3)\n{", "uint32_t offset;", "offset = cpu_to_le32(VAR_3 - VAR_2 - 5);", "patch_byte(VAR_1, VAR_2, 0xe8);", "cpu_memory_rw_debug(CPU(VAR_1), VAR_2 + 1, (void *)&offset, sizeof(offset), 1);", "}" ]

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

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

[ "static void FUNC_0(SpectralBandReplication *VAR_0, int VAR_1)\n{", "int VAR_2, VAR_3;", "int VAR_4;", "if (VAR_1 == TYPE_CPE && VAR_0->bs_coupling) {", "float VAR_5 = VAR_0->data[0].bs_amp_res ? 1.0f : 0.5f;", "float VAR_6 = VAR_0->data[0].bs_amp_res ? 12.0f : 24.0f;", "for (VAR_3 = 1; VAR_3 <= VAR_0->data[0].bs_num_env; VAR_3++) {", "for (VAR_2 = 0; VAR_2 < VAR_0->n[VAR_0->data[0].bs_freq_res[VAR_3]]; VAR_2++) {", "float temp1 = exp2f(VAR_0->data[0].env_facs[VAR_3][VAR_2] * VAR_5 + 7.0f);", "float temp2 = exp2f((VAR_6 - VAR_0->data[1].env_facs[VAR_3][VAR_2]) * VAR_5);", "float fac = temp1 / (1.0f + temp2);", "VAR_0->data[0].env_facs[VAR_3][VAR_2] = fac;", "VAR_0->data[1].env_facs[VAR_3][VAR_2] = fac * temp2;", "}", "}", "for (VAR_3 = 1; VAR_3 <= VAR_0->data[0].bs_num_noise; VAR_3++) {", "for (VAR_2 = 0; VAR_2 < VAR_0->n_q; VAR_2++) {", "float temp1 = exp2f(NOISE_FLOOR_OFFSET - VAR_0->data[0].noise_facs[VAR_3][VAR_2] + 1);", "float temp2 = exp2f(12 - VAR_0->data[1].noise_facs[VAR_3][VAR_2]);", "float fac = temp1 / (1.0f + temp2);", "VAR_0->data[0].noise_facs[VAR_3][VAR_2] = fac;", "VAR_0->data[1].noise_facs[VAR_3][VAR_2] = fac * temp2;", "}", "}", "} else {", "for (VAR_4 = 0; VAR_4 < (VAR_1 == TYPE_CPE) + 1; VAR_4++) {", "float VAR_5 = VAR_0->data[VAR_4].bs_amp_res ? 1.0f : 0.5f;", "for (VAR_3 = 1; VAR_3 <= VAR_0->data[VAR_4].bs_num_env; VAR_3++)", "for (VAR_2 = 0; VAR_2 < VAR_0->n[VAR_0->data[VAR_4].bs_freq_res[VAR_3]]; VAR_2++)", "VAR_0->data[VAR_4].env_facs[VAR_3][VAR_2] =\nexp2f(VAR_5 * VAR_0->data[VAR_4].env_facs[VAR_3][VAR_2] + 6.0f);", "for (VAR_3 = 1; VAR_3 <= VAR_0->data[VAR_4].bs_num_noise; VAR_3++)", "for (VAR_2 = 0; VAR_2 < VAR_0->n_q; VAR_2++)", "VAR_0->data[VAR_4].noise_facs[VAR_3][VAR_2] =\nexp2f(NOISE_FLOOR_OFFSET - VAR_0->data[VAR_4].noise_facs[VAR_3][VAR_2]);", "}", "}", "}" ]

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

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

[ "static inline int16_t FUNC_0(int16_t a, int16_t b)\n{", "int16_t c = a - b;", "uint8_t address = FFMIN((ABS(c) >> 1), 255);", "return ((c >= 0) ? (a + latab[address]) : (b + latab[address]));", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(Range *VAR_0, Range *VAR_1)\n{", "if (VAR_0->end < VAR_1->end) {", "VAR_0->end = VAR_1->end;", "}", "if (VAR_0->begin > VAR_1->begin) {", "VAR_0->begin = VAR_1->begin;", "}", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{", "DASHContext *c = VAR_0->priv_data;", "AVIOContext *out;", "char VAR_2[1024];", "int VAR_3, VAR_4;", "AVDictionaryEntry *title = av_dict_get(VAR_0->metadata, \"title\", NULL, 0);", "snprintf(VAR_2, sizeof(VAR_2), \"%VAR_0.tmp\", VAR_0->filename);", "VAR_3 = avio_open2(&out, VAR_2, AVIO_FLAG_WRITE, &VAR_0->interrupt_callback, NULL);", "if (VAR_3 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Unable to open %VAR_0 for writing\\n\", VAR_2);", "return VAR_3;", "}", "avio_printf(out, \"<?xml version=\\\"1.0\\\" encoding=\\\"utf-8\\\"?>\\n\");", "avio_printf(out, \"<MPD xmlns:xsi=\\\"http:\n\"\\txmlns=\\\"urn:mpeg:dash:schema:mpd:2011\\\"\\n\"\n\"\\txmlns:xlink=\\\"http:\n\"\\txsi:schemaLocation=\\\"urn:mpeg:DASH:schema:MPD:2011 http:\n\"\\tprofiles=\\\"urn:mpeg:dash:profile:isoff-live:2011\\\"\\n\"\n\"\\ttype=\\\"%VAR_0\\\"\\n\", VAR_1 ? \"static\" : \"dynamic\");", "if (VAR_1) {", "avio_printf(out, \"\\tmediaPresentationDuration=\\\"\");", "write_time(out, c->total_duration);", "avio_printf(out, \"\\\"\\n\");", "} else {", "int VAR_5 = c->last_duration / AV_TIME_BASE;", "if (c->use_template && !c->use_timeline)\nVAR_5 = 500;", "avio_printf(out, \"\\tminimumUpdatePeriod=\\\"PT%dS\\\"\\n\", VAR_5);", "avio_printf(out, \"\\tsuggestedPresentationDelay=\\\"PT%dS\\\"\\n\", c->last_duration / AV_TIME_BASE);", "if (!c->availability_start_time[0] && VAR_0->nb_streams > 0 && c->streams[0].nb_segments > 0) {", "time_t t = time(NULL);", "struct tm *VAR_6, VAR_7;", "VAR_6 = gmtime_r(&t, &VAR_7);", "if (VAR_6) {", "if (!strftime(c->availability_start_time, sizeof(c->availability_start_time),\n\"%Y-%m-%dT%H:%M:%S\", VAR_6))\nc->availability_start_time[0] = '\\0';", "}", "}", "if (c->availability_start_time[0])\navio_printf(out, \"\\tavailabilityStartTime=\\\"%VAR_0\\\"\\n\", c->availability_start_time);", "if (c->window_size && c->use_template) {", "avio_printf(out, \"\\ttimeShiftBufferDepth=\\\"\");", "write_time(out, c->last_duration * c->window_size);", "avio_printf(out, \"\\\"\\n\");", "}", "}", "avio_printf(out, \"\\tminBufferTime=\\\"\");", "write_time(out, c->last_duration);", "avio_printf(out, \"\\\">\\n\");", "avio_printf(out, \"\\t<ProgramInformation>\\n\");", "if (title) {", "char *VAR_8 = xmlescape(title->value);", "avio_printf(out, \"\\t\\t<Title>%VAR_0</Title>\\n\", VAR_8);", "av_free(VAR_8);", "}", "avio_printf(out, \"\\t</ProgramInformation>\\n\");", "if (c->window_size && VAR_0->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) {", "OutputStream *os = &c->streams[0];", "int VAR_9 = FFMAX(os->nb_segments - c->window_size, 0);", "int64_t start_time = av_rescale_q(os->segments[VAR_9]->time, VAR_0->streams[0]->time_base, AV_TIME_BASE_Q);", "avio_printf(out, \"\\t<Period start=\\\"\");", "write_time(out, start_time);", "avio_printf(out, \"\\\">\\n\");", "} else {", "avio_printf(out, \"\\t<Period start=\\\"PT0.0S\\\">\\n\");", "}", "if (c->has_video) {", "avio_printf(out, \"\\t\\t<AdaptationSet id=\\\"video\\\" segmentAlignment=\\\"true\\\" bitstreamSwitching=\\\"true\\\">\\n\");", "for (VAR_4 = 0; VAR_4 < VAR_0->nb_streams; VAR_4++) {", "AVStream *st = VAR_0->streams[VAR_4];", "OutputStream *os = &c->streams[VAR_4];", "if (VAR_0->streams[VAR_4]->codec->codec_type != AVMEDIA_TYPE_VIDEO)\ncontinue;", "avio_printf(out, \"\\t\\t\\t<Representation id=\\\"%d\\\" mimeType=\\\"video/mp4\\\" codecs=\\\"%VAR_0\\\"%VAR_0 width=\\\"%d\\\" height=\\\"%d\\\">\\n\", VAR_4, os->codec_str, os->bandwidth_str, st->codec->width, st->codec->height);", "output_segment_list(&c->streams[VAR_4], out, c);", "avio_printf(out, \"\\t\\t\\t</Representation>\\n\");", "}", "avio_printf(out, \"\\t\\t</AdaptationSet>\\n\");", "}", "if (c->has_audio) {", "avio_printf(out, \"\\t\\t<AdaptationSet id=\\\"audio\\\" segmentAlignment=\\\"true\\\" bitstreamSwitching=\\\"true\\\">\\n\");", "for (VAR_4 = 0; VAR_4 < VAR_0->nb_streams; VAR_4++) {", "AVStream *st = VAR_0->streams[VAR_4];", "OutputStream *os = &c->streams[VAR_4];", "if (VAR_0->streams[VAR_4]->codec->codec_type != AVMEDIA_TYPE_AUDIO)\ncontinue;", "avio_printf(out, \"\\t\\t\\t<Representation id=\\\"%d\\\" mimeType=\\\"audio/mp4\\\" codecs=\\\"%VAR_0\\\"%VAR_0 audioSamplingRate=\\\"%d\\\">\\n\", VAR_4, os->codec_str, os->bandwidth_str, st->codec->sample_rate);", "avio_printf(out, \"\\t\\t\\t\\t<AudioChannelConfiguration schemeIdUri=\\\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\\\" value=\\\"%d\\\" />\\n\", st->codec->channels);", "output_segment_list(&c->streams[VAR_4], out, c);", "avio_printf(out, \"\\t\\t\\t</Representation>\\n\");", "}", "avio_printf(out, \"\\t\\t</AdaptationSet>\\n\");", "}", "avio_printf(out, \"\\t</Period>\\n\");", "avio_printf(out, \"</MPD>\\n\");", "avio_flush(out);", "avio_close(out);", "return ff_rename(VAR_2, VAR_0->filename, VAR_0);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31, 33, 35, 37, 39, 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 ], [ 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 ] ]

[ "static int FUNC_0(H264SliceContext *VAR_0,\nint VAR_1, int VAR_2, int VAR_3)\n{", "int VAR_4 = VAR_0->ref_list[0][VAR_3].VAR_1;", "int VAR_5 = av_clip_int8(VAR_2 - VAR_4);", "if (VAR_5 == 0 || VAR_0->ref_list[0][VAR_3].parent->long_ref) {", "return 256;", "} else {", "int VAR_6 = av_clip_int8(VAR_1 - VAR_4);", "int VAR_7 = (16384 + (FFABS(VAR_5) >> 1)) / VAR_5;", "return av_clip_intp2((VAR_6 * VAR_7 + 32) >> 6, 10);", "}", "}" ]

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

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

[ "static int FUNC_0(CPUPPCState *VAR_0,\nppc_slb_t *VAR_1, ppc_hash_pte64_t VAR_2)\n{", "unsigned VAR_3, VAR_4;", "int VAR_5 = 0;", "VAR_4 = !!(msr_pr ? (VAR_1->vsid & SLB_VSID_KP)\n: (VAR_1->vsid & SLB_VSID_KS));", "VAR_3 = (VAR_2.pte1 & HPTE64_R_PP) | ((VAR_2.pte1 & HPTE64_R_PP0) >> 61);", "if (VAR_4 == 0) {", "switch (VAR_3) {", "case 0x0:\ncase 0x1:\ncase 0x2:\nVAR_5 = PAGE_READ | PAGE_WRITE;", "break;", "case 0x3:\ncase 0x6:\nVAR_5 = PAGE_READ;", "break;", "}", "} else {", "switch (VAR_3) {", "case 0x0:\ncase 0x6:\nVAR_5 = 0;", "break;", "case 0x1:\ncase 0x3:\nVAR_5 = PAGE_READ;", "break;", "case 0x2:\nVAR_5 = PAGE_READ | PAGE_WRITE;", "break;", "}", "}", "if (!(VAR_2.pte1 & HPTE64_R_N) || (VAR_2.pte1 & HPTE64_R_G)) {", "VAR_5 |= PAGE_EXEC;", "}", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 13 ], [ 17, 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29, 31, 33, 35 ], [ 37 ], [ 41, 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57, 59 ], [ 61 ], [ 65, 67, 69 ], [ 71 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ] ]

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

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{", "struct omap_sysctl_s *VAR_3 = (struct omap_sysctl_s *) VAR_0;", "int VAR_4, VAR_5;", "int VAR_6;", "switch (VAR_1) {", "case 0x030 ... 0x140:\nVAR_4 = (VAR_1 - 0x30) >> 2;", "VAR_5 = (VAR_1 - 0x30) & (4 - 1);", "VAR_6 = VAR_3->padconf[VAR_4];", "VAR_6 &= ~(0xff << (VAR_5 * 8));", "VAR_6 |= ((VAR_2 & 0x1f1f1f1f) << (VAR_5 * 8)) & 0x1f1f1f1f;", "VAR_3->padconf[VAR_4] = VAR_6;", "break;", "default:\nOMAP_BAD_REG(VAR_1);", "break;", "}", "}" ]

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

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

[ "static void FUNC_0(NetL2TPV3State *VAR_0)\n{", "qemu_set_fd_handler2(VAR_0->fd,\nVAR_0->read_poll ? l2tpv3_can_send : NULL,\nVAR_0->read_poll ? net_l2tpv3_send : NULL,\nVAR_0->write_poll ? l2tpv3_writable : NULL,\nVAR_0);", "}" ]

[ 0, 0, 0 ]

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

[ "void FUNC_0(BlockDriverState *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "VAR_0->boot_sector_enabled = 1;", "if (VAR_2 > 512)\nVAR_2 = 512;", "memcpy(VAR_0->boot_sector_data, VAR_1, VAR_2);", "memset(VAR_0->boot_sector_data + VAR_2, 0, 512 - VAR_2);", "}" ]

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

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

[ "void FUNC_0(CPUX86State *VAR_0, int VAR_1)\n{", "int VAR_2;", "VAR_2 = VAR_0->hflags & HF_CPL_MASK;", "if (VAR_0->sysenter_cs == 0 || VAR_2 != 0) {", "raise_exception_err(VAR_0, EXCP0D_GPF, 0);", "}", "cpu_x86_set_cpl(VAR_0, 3);", "#ifdef TARGET_X86_64\nif (VAR_1 == 2) {", "cpu_x86_load_seg_cache(VAR_0, R_CS, ((VAR_0->sysenter_cs + 32) & 0xfffc) |\n3, 0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK | (3 << DESC_DPL_SHIFT) |\nDESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |\nDESC_L_MASK);", "cpu_x86_load_seg_cache(VAR_0, R_SS, ((VAR_0->sysenter_cs + 40) & 0xfffc) |\n3, 0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK | (3 << DESC_DPL_SHIFT) |\nDESC_W_MASK | DESC_A_MASK);", "} else", "#endif\n{", "cpu_x86_load_seg_cache(VAR_0, R_CS, ((VAR_0->sysenter_cs + 16) & 0xfffc) |\n3, 0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK | (3 << DESC_DPL_SHIFT) |\nDESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);", "cpu_x86_load_seg_cache(VAR_0, R_SS, ((VAR_0->sysenter_cs + 24) & 0xfffc) |\n3, 0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK | (3 << DESC_DPL_SHIFT) |\nDESC_W_MASK | DESC_A_MASK);", "}", "VAR_0->regs[R_ESP] = VAR_0->regs[R_ECX];", "VAR_0->eip = VAR_0->regs[R_EDX];", "}" ]

[ 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 ], [ 61, 63, 65, 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ] ]

[ "static int FUNC_0(SlirpState *VAR_0, const char *VAR_1,\nint VAR_2)\n{", "struct in_addr VAR_3 = { .s_addr = 0 };", "struct GuestFwd *VAR_4;", "const char *VAR_5;", "char VAR_6[128];", "char *VAR_7;", "int VAR_8;", "VAR_5 = VAR_1;", "if (VAR_2) {", "if (get_str_sep(VAR_6, sizeof(VAR_6), &VAR_5, ':') < 0) {", "goto fail_syntax;", "}", "} else {", "if (get_str_sep(VAR_6, sizeof(VAR_6), &VAR_5, ':') < 0) {", "goto fail_syntax;", "}", "if (strcmp(VAR_6, \"tcp\") && VAR_6[0] != '\\0') {", "goto fail_syntax;", "}", "if (get_str_sep(VAR_6, sizeof(VAR_6), &VAR_5, ':') < 0) {", "goto fail_syntax;", "}", "if (VAR_6[0] != '\\0' && !inet_aton(VAR_6, &VAR_3)) {", "goto fail_syntax;", "}", "if (get_str_sep(VAR_6, sizeof(VAR_6), &VAR_5, '-') < 0) {", "goto fail_syntax;", "}", "}", "VAR_8 = strtol(VAR_6, &VAR_7, 10);", "if (*VAR_7 != '\\0' || VAR_8 < 1 || VAR_8 > 65535) {", "goto fail_syntax;", "}", "VAR_4 = qemu_malloc(sizeof(struct GuestFwd));", "snprintf(VAR_6, sizeof(VAR_6), \"guestfwd.tcp:%d\", VAR_8);", "VAR_4->hd = qemu_chr_open(VAR_6, VAR_5, NULL);", "if (!VAR_4->hd) {", "error_report(\"could not open guest forwarding device '%VAR_0'\", VAR_6);", "qemu_free(VAR_4);", "return -1;", "}", "if (slirp_add_exec(VAR_0->slirp, 3, VAR_4->hd, &VAR_3, VAR_8) < 0) {", "error_report(\"conflicting/invalid host:VAR_8 in guest forwarding \"\n\"rule '%VAR_0'\", VAR_1);", "qemu_free(VAR_4);", "return -1;", "}", "VAR_4->VAR_3 = VAR_3;", "VAR_4->VAR_8 = VAR_8;", "VAR_4->slirp = VAR_0->slirp;", "qemu_chr_add_handlers(VAR_4->hd, guestfwd_can_read, guestfwd_read,\nNULL, VAR_4);", "return 0;", "fail_syntax:\nerror_report(\"invalid guest forwarding rule '%VAR_0'\", VAR_1);", "return -1;", "}" ]

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

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

[ "BlockAIOCB *FUNC_0(BlockDriverState *bs, LinuxAioState *s, int fd,\nint64_t sector_num, QEMUIOVector *qiov, int nb_sectors,\nBlockCompletionFunc *cb, void *opaque, int type)\n{", "struct qemu_laiocb *VAR_0;", "struct iocb *VAR_1;", "off_t offset = sector_num * 512;", "VAR_0 = qemu_aio_get(&laio_aiocb_info, bs, cb, opaque);", "VAR_0->nbytes = nb_sectors * 512;", "VAR_0->ctx = s;", "VAR_0->ret = -EINPROGRESS;", "VAR_0->is_read = (type == QEMU_AIO_READ);", "VAR_0->qiov = qiov;", "VAR_1 = &VAR_0->iocb;", "switch (type) {", "case QEMU_AIO_WRITE:\nio_prep_pwritev(VAR_1, fd, qiov->iov, qiov->niov, offset);", "break;", "case QEMU_AIO_READ:\nio_prep_preadv(VAR_1, fd, qiov->iov, qiov->niov, offset);", "break;", "default:\nfprintf(stderr, \"%s: invalid AIO request type 0x%x.\\n\",\n__func__, type);", "goto out_free_aiocb;", "}", "io_set_eventfd(&VAR_0->iocb, event_notifier_get_fd(&s->e));", "QSIMPLEQ_INSERT_TAIL(&s->io_q.pending, VAR_0, next);", "s->io_q.n++;", "if (!s->io_q.blocked &&\n(!s->io_q.plugged || s->io_q.n >= MAX_QUEUED_IO)) {", "ioq_submit(s);", "}", "return &VAR_0->common;", "out_free_aiocb:\nqemu_aio_unref(VAR_0);", "return NULL;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, uint8_t *VAR_1,\nint VAR_2, void *VAR_3)\n{", "X264Context *x4 = VAR_0->priv_data;", "AVFrame *frame = VAR_3;", "x264_nal_t *nal;", "int VAR_4, VAR_5;", "x264_picture_t pic_out;", "x4->pic.img.i_csp = X264_CSP_I420;", "x4->pic.img.i_plane = 3;", "if (frame) {", "for (VAR_5 = 0; VAR_5 < 3; VAR_5++) {", "x4->pic.img.plane[VAR_5] = frame->VAR_3[VAR_5];", "x4->pic.img.i_stride[VAR_5] = frame->linesize[VAR_5];", "}", "x4->pic.i_pts = frame->pts;", "x4->pic.i_type = X264_TYPE_AUTO;", "}", "if (x264_encoder_encode(x4->enc, &nal, &VAR_4, frame? &x4->pic: NULL, &pic_out) < 0)\nreturn -1;", "VAR_2 = encode_nals(VAR_0, VAR_1, VAR_2, nal, VAR_4, 0);", "if (VAR_2 < 0)\nreturn -1;", "x4->out_pic.pts = pic_out.i_pts;", "switch (pic_out.i_type) {", "case X264_TYPE_IDR:\ncase X264_TYPE_I:\nx4->out_pic.pict_type = FF_I_TYPE;", "break;", "case X264_TYPE_P:\nx4->out_pic.pict_type = FF_P_TYPE;", "break;", "case X264_TYPE_B:\ncase X264_TYPE_BREF:\nx4->out_pic.pict_type = FF_B_TYPE;", "break;", "}", "x4->out_pic.key_frame = pic_out.i_type == X264_TYPE_IDR;", "x4->out_pic.quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;", "return VAR_2;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "int32_t fid;", "ssize_t err = 0;", "size_t offset = 7;", "V9fsString name;", "int32_t newdirfid;", "V9fsFidState *fidp;", "V9fsPDU *pdu = VAR_0;", "V9fsState *s = pdu->s;", "pdu_unmarshal(pdu, offset, \"dds\", &fid, &newdirfid, &name);", "fidp = get_fid(pdu, fid);", "if (fidp == NULL) {", "err = -ENOENT;", "goto out_nofid;", "}", "BUG_ON(fidp->fid_type != P9_FID_NONE);", "if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {", "err = -EOPNOTSUPP;", "goto out;", "}", "v9fs_path_write_lock(s);", "err = v9fs_complete_rename(pdu, fidp, newdirfid, &name);", "v9fs_path_unlock(s);", "if (!err) {", "err = offset;", "}", "out:\nput_fid(pdu, fidp);", "out_nofid:\ncomplete_pdu(s, pdu, err);", "v9fs_string_free(&name);", "}" ]

[ 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65, 67 ], [ 69 ], [ 71 ] ]

[ "static int VAR_0 cow_co_is_allocated(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors, int *num_same)\n{", "int64_t bitnum = sector_num + sizeof(struct cow_header_v2) * 8;", "uint64_t offset = (bitnum / 8) & -BDRV_SECTOR_SIZE;", "bool first = true;", "int changed = 0, same = 0;", "do {", "int ret;", "uint8_t bitmap[BDRV_SECTOR_SIZE];", "bitnum &= BITS_PER_BITMAP_SECTOR - 1;", "int sector_bits = MIN(nb_sectors, BITS_PER_BITMAP_SECTOR - bitnum);", "ret = bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap));", "if (ret < 0) {", "return ret;", "}", "if (first) {", "changed = cow_test_bit(bitnum, bitmap);", "first = false;", "}", "same += cow_find_streak(bitmap, changed, bitnum, nb_sectors);", "bitnum += sector_bits;", "nb_sectors -= sector_bits;", "offset += BDRV_SECTOR_SIZE;", "} while (nb_sectors);", "*num_same = same;", "return changed;", "}" ]

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

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

[ "void FUNC_0(void)\n{", "int VAR_0 = 0;", "if (daemonize) {", "uint8_t status = 0;", "ssize_t len;", "again1:\nlen = write(daemon_pipe, &status, 1);", "if (len == -1 && (errno == EINTR)) {", "goto again1;", "}", "if (len != 1) {", "exit(1);", "}", "if (chdir(\"/\")) {", "perror(\"not able to chdir to /\");", "exit(1);", "}", "TFR(VAR_0 = qemu_open(\"/dev/null\", O_RDWR));", "if (VAR_0 == -1) {", "exit(1);", "}", "}", "change_root();", "change_process_uid();", "if (daemonize) {", "dup2(VAR_0, 0);", "dup2(VAR_0, 1);", "dup2(VAR_0, 2);", "close(VAR_0);", "}", "}" ]

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

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