Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static int FUNC_0(QemuOpts *VAR_0, void *VAR_1)\n{", "GlobalProperty *g;", "ObjectClass *oc;", "g = g_malloc0(sizeof(*g));", "g->driver = qemu_opt_get(VAR_0, \"driver\");", "g->property = qemu_opt_get(VAR_0, \"property\");", "g->value = qemu_opt_get(VAR_0, \"value\");", "oc = object_class_by_name(g->driver);", "if (oc) {", "DeviceClass *dc = DEVICE_CLASS(oc);", "if (dc->hotpluggable) {", "g->not_used = false;", "} else {", "g->not_used = true;", "}", "} else {", "g->not_used = true;", "}", "qdev_prop_register_global(g);", "return 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 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ] ]

[ "void FUNC_0(const IVIPlaneDesc *VAR_0, uint8_t *VAR_1,\nconst ptrdiff_t VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "int32_t p0, p1, p2, p3, tmp0, tmp1, tmp2;", "int32_t b0_1, b0_2, b1_1, b1_2, b1_3, b2_1, b2_2, b2_3, b2_4, b2_5, b2_6;", "int32_t b3_1, b3_2, b3_3, b3_4, b3_5, b3_6, b3_7, b3_8, b3_9;", "ptrdiff_t pitch, back_pitch;", "const short *VAR_6, *VAR_7, *VAR_8, *VAR_9;", "const int VAR_10 = 4;", "pitch = VAR_0->bands[0].pitch;", "back_pitch = 0;", "VAR_6 = VAR_0->bands[0].buf;", "VAR_7 = VAR_0->bands[1].buf;", "VAR_8 = VAR_0->bands[2].buf;", "VAR_9 = VAR_0->bands[3].buf;", "for (VAR_4 = 0; VAR_4 < VAR_0->height; VAR_4 += 2) {", "if (VAR_4+2 >= VAR_0->height)\npitch= 0;", "if (VAR_10 > 0) {", "b0_1 = VAR_6[0];", "b0_2 = VAR_6[pitch];", "}", "if (VAR_10 > 1) {", "b1_1 = VAR_7[back_pitch];", "b1_2 = VAR_7[0];", "b1_3 = b1_1 - b1_2*6 + VAR_7[pitch];", "}", "if (VAR_10 > 2) {", "b2_2 = VAR_8[0];", "b2_3 = b2_2;", "b2_5 = VAR_8[pitch];", "b2_6 = b2_5;", "}", "if (VAR_10 > 3) {", "b3_2 = VAR_9[back_pitch];", "b3_3 = b3_2;", "b3_5 = VAR_9[0];", "b3_6 = b3_5;", "b3_8 = b3_2 - b3_5*6 + VAR_9[pitch];", "b3_9 = b3_8;", "}", "for (VAR_3 = 0, VAR_5 = 0; VAR_3 < VAR_0->width; VAR_3+=2, VAR_5++) {", "if (VAR_3+2 >= VAR_0->width) {", "VAR_6 --;", "VAR_7 --;", "VAR_8 --;", "VAR_9 --;", "}", "b2_1 = b2_2;", "b2_2 = b2_3;", "b2_4 = b2_5;", "b2_5 = b2_6; = b2[VAR_3+1,VAR_4+1]", "b3_1 = b3_2;", "b3_2 = b3_3; = b3[VAR_3+1,VAR_4-1]", "b3_4 = b3_5;", "b3_5 = b3_6; = b3[VAR_3+1,VAR_4 ]", "b3_7 = b3_8;", "b3_8 = b3_9;", "p0 = p1 = p2 = p3 = 0;", "if (VAR_10 > 0) {", "tmp0 = b0_1;", "tmp2 = b0_2;", "b0_1 = VAR_6[VAR_5+1];", "b0_2 = VAR_6[pitch+VAR_5+1];", "tmp1 = tmp0 + b0_1;", "p0 = tmp0 << 4;", "p1 = tmp1 << 3;", "p2 = (tmp0 + tmp2) << 3;", "p3 = (tmp1 + tmp2 + b0_2) << 2;", "}", "if (VAR_10 > 1) {", "tmp0 = b1_2;", "tmp1 = b1_1;", "b1_2 = VAR_7[VAR_5+1];", "b1_1 = VAR_7[back_pitch+VAR_5+1];", "tmp2 = tmp1 - tmp0*6 + b1_3;", "b1_3 = b1_1 - b1_2*6 + VAR_7[pitch+VAR_5+1];", "p0 += (tmp0 + tmp1) << 3;", "p1 += (tmp0 + tmp1 + b1_1 + b1_2) << 2;", "p2 += tmp2 << 2;", "p3 += (tmp2 + b1_3) << 1;", "}", "if (VAR_10 > 2) {", "b2_3 = VAR_8[VAR_5+1];", "b2_6 = VAR_8[pitch+VAR_5+1];", "tmp0 = b2_1 + b2_2;", "tmp1 = b2_1 - b2_2*6 + b2_3;", "p0 += tmp0 << 3;", "p1 += tmp1 << 2;", "p2 += (tmp0 + b2_4 + b2_5) << 2;", "p3 += (tmp1 + b2_4 - b2_5*6 + b2_6) << 1;", "}", "if (VAR_10 > 3) {", "b3_6 = VAR_9[VAR_5+1];", "b3_3 = VAR_9[back_pitch+VAR_5+1];", "tmp0 = b3_1 + b3_4;", "tmp1 = b3_2 + b3_5;", "tmp2 = b3_3 + b3_6;", "b3_9 = b3_3 - b3_6*6 + VAR_9[pitch+VAR_5+1];", "p0 += (tmp0 + tmp1) << 2;", "p1 += (tmp0 - tmp1*6 + tmp2) << 1;", "p2 += (b3_7 + b3_8) << 1;", "p3 += b3_7 - b3_8*6 + b3_9;", "}", "VAR_1[VAR_3] = av_clip_uint8((p0 >> 6) + 128);", "VAR_1[VAR_3+1] = av_clip_uint8((p1 >> 6) + 128);", "VAR_1[VAR_2+VAR_3] = av_clip_uint8((p2 >> 6) + 128);", "VAR_1[VAR_2+VAR_3+1] = av_clip_uint8((p3 >> 6) + 128);", "}", "VAR_1 += VAR_2 << 1;", "back_pitch = -pitch;", "VAR_6 += pitch + 1;", "VAR_7 += pitch + 1;", "VAR_8 += pitch + 1;", "VAR_9 += pitch + 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, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 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 ], [ 25 ], [ 31 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 51, 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 219 ], [ 221 ], [ 223 ], [ 227 ], [ 229 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 247 ], [ 249 ], [ 251 ], [ 255 ], [ 257 ], [ 259 ], [ 263 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 293 ], [ 297 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ] ]

[ "void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{", "VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);", "VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(VAR_0);", "int VAR_2;", "virtio_init(vdev, \"virtio-scsi\", VIRTIO_ID_SCSI,\nsizeof(VirtIOSCSIConfig));", "s->cmd_vqs = g_malloc0(s->conf.num_queues * sizeof(VirtQueue *));", "s->sense_size = VIRTIO_SCSI_SENSE_SIZE;", "s->cdb_size = VIRTIO_SCSI_CDB_SIZE;", "s->ctrl_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,\nvirtio_scsi_handle_ctrl);", "s->event_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,\nvirtio_scsi_handle_event);", "for (VAR_2 = 0; VAR_2 < s->conf.num_queues; VAR_2++) {", "s->cmd_vqs[VAR_2] = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,\nvirtio_scsi_handle_cmd);", "}", "}" ]

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

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

[ "static CharDriverState *FUNC_0(int fd)\n{", "CharDriverState *chr = NULL;", "NetCharDriver *s = NULL;", "chr = qemu_chr_alloc();", "s = g_malloc0(sizeof(NetCharDriver));", "s->fd = fd;", "s->chan = io_channel_from_socket(s->fd);", "s->bufcnt = 0;", "s->bufptr = 0;", "chr->opaque = s;", "chr->chr_write = udp_chr_write;", "chr->chr_update_read_handler = udp_chr_update_read_handler;", "chr->chr_close = udp_chr_close;", "chr->explicit_be_open = true;", "return chr;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "AVCodecContext *codec = VAR_0->streams[0]->codec;", "GENHDemuxContext *c = VAR_0->priv_data;", "int VAR_2;", "if (c->dsp_int_type == 1 && codec->codec_id == AV_CODEC_ID_ADPCM_THP &&\ncodec->channels > 1) {", "int VAR_3, VAR_4;", "if (avio_feof(VAR_0->pb))\nreturn AVERROR_EOF;", "av_new_packet(VAR_1, 8 * codec->channels);", "for (VAR_3 = 0; VAR_3 < 8 / c->interleave_size; VAR_3++) {", "for (VAR_4 = 0; VAR_4 < codec->channels; VAR_4++) {", "VAR_1->data[VAR_4 * 8 + VAR_3*c->interleave_size+0] = avio_r8(VAR_0->pb);", "VAR_1->data[VAR_4 * 8 + VAR_3*c->interleave_size+1] = avio_r8(VAR_0->pb);", "}", "}", "VAR_2 = 0;", "} else {", "VAR_2 = av_get_packet(VAR_0->pb, VAR_1, codec->block_align ? codec->block_align : 1024 * codec->channels);", "}", "VAR_1->stream_index = 0;", "return VAR_2;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "#if defined(__linux__)\nif (!kvm_enabled() || kvm_has_sync_mmu())\nmadvise(VAR_0, TARGET_PAGE_SIZE,\nVAR_1 ? MADV_WILLNEED : MADV_DONTNEED);", "#endif\n}" ]

[ 0, 1, 1 ]

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

[ "static void FUNC_0(void)\n{", "Coroutine *coroutine;", "coroutine = qemu_coroutine_create(verify_self);", "qemu_coroutine_enter(coroutine, &coroutine);", "}" ]

[ 0, 0, 1, 1, 0 ]

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "#else\nif (unlikely(VAR_0->pr)) {", "gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "return;", "}", "if (VAR_0->opcode & 0x00008000) {", "tcg_gen_ori_tl(cpu_msr, cpu_msr, (1 << MSR_EE));", "gen_stop_exception(VAR_0);", "} else {", "tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(1 << MSR_EE));", "}", "#endif\n}" ]

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

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

[ "void FUNC_0(QEMUFile *VAR_0, unsigned int VAR_1)\n{", "qemu_put_byte(VAR_0, VAR_1 >> 8);", "qemu_put_byte(VAR_0, VAR_1);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(void)\n{", "WorkerTestData data[100];", "int VAR_0;", "int VAR_1;", "test_submit_many();", "for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {", "data[VAR_1].n = 0;", "data[VAR_1].ret = -EINPROGRESS;", "data[VAR_1].aiocb = thread_pool_submit_aio(pool, long_cb, &data[VAR_1],\ndone_cb, &data[VAR_1]);", "}", "active = 100;", "aio_notify(ctx);", "aio_poll(ctx, false);", "g_assert_cmpint(active, ==, 100);", "g_usleep(1000000);", "g_assert_cmpint(active, >, 50);", "VAR_0 = 0;", "for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {", "if (atomic_cmpxchg(&data[VAR_1].n, 0, 3) == 0) {", "data[VAR_1].ret = -ECANCELED;", "bdrv_aio_cancel(data[VAR_1].aiocb);", "active--;", "VAR_0++;", "}", "}", "g_assert_cmpint(active, >, 0);", "g_assert_cmpint(VAR_0, <, 100);", "for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {", "if (data[VAR_1].n != 3) {", "bdrv_aio_cancel(data[VAR_1].aiocb);", "}", "}", "qemu_aio_wait_all();", "g_assert_cmpint(active, ==, 0);", "for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {", "if (data[VAR_1].n == 3) {", "g_assert_cmpint(data[VAR_1].ret, ==, -ECANCELED);", "g_assert(data[VAR_1].aiocb != NULL);", "} else {", "g_assert_cmpint(data[VAR_1].n, ==, 2);", "g_assert_cmpint(data[VAR_1].ret, ==, 0);", "g_assert(data[VAR_1].aiocb == NULL);", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 19 ], [ 25 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 45 ], [ 47 ], [ 49 ], [ 59 ], [ 61 ], [ 63 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ] ]

[ "static void FUNC_0(DisasContext *VAR_0, int VAR_1, int VAR_2)\n{", "if (VAR_0->tb->cflags & CF_USE_ICOUNT) {", "gen_io_start();", "}", "gen_helper_store_tbl(cpu_env, cpu_gpr[VAR_2]);", "if (VAR_0->tb->cflags & CF_USE_ICOUNT) {", "gen_io_end();", "gen_stop_exception(VAR_0);", "}", "}" ]

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

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

[ "static void VAR_0 commit_run(void *opaque)\n{", "CommitBlockJob *s = opaque;", "BlockDriverState *active = s->active;", "BlockDriverState *top = s->top;", "BlockDriverState *base = s->base;", "BlockDriverState *overlay_bs = NULL;", "int64_t sector_num, end;", "int ret = 0;", "int n = 0;", "void *buf;", "int bytes_written = 0;", "int64_t base_len;", "ret = s->common.len = bdrv_getlength(top);", "if (s->common.len < 0) {", "goto exit_restore_reopen;", "}", "ret = base_len = bdrv_getlength(base);", "if (base_len < 0) {", "goto exit_restore_reopen;", "}", "if (base_len < s->common.len) {", "ret = bdrv_truncate(base, s->common.len);", "if (ret) {", "goto exit_restore_reopen;", "}", "}", "overlay_bs = bdrv_find_overlay(active, top);", "end = s->common.len >> BDRV_SECTOR_BITS;", "buf = qemu_blockalign(top, COMMIT_BUFFER_SIZE);", "for (sector_num = 0; sector_num < end; sector_num += n) {", "uint64_t delay_ns = 0;", "bool copy;", "wait:\nblock_job_sleep_ns(&s->common, rt_clock, delay_ns);", "if (block_job_is_cancelled(&s->common)) {", "break;", "}", "ret = bdrv_co_is_allocated_above(top, base, sector_num,\nCOMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,\n&n);", "copy = (ret == 1);", "trace_commit_one_iteration(s, sector_num, n, ret);", "if (copy) {", "if (s->common.speed) {", "delay_ns = ratelimit_calculate_delay(&s->limit, n);", "if (delay_ns > 0) {", "goto wait;", "}", "}", "ret = commit_populate(top, base, sector_num, n, buf);", "bytes_written += n * BDRV_SECTOR_SIZE;", "}", "if (ret < 0) {", "if (s->on_error == BLOCKDEV_ON_ERROR_STOP ||\ns->on_error == BLOCKDEV_ON_ERROR_REPORT||\n(s->on_error == BLOCKDEV_ON_ERROR_ENOSPC && ret == -ENOSPC)) {", "goto exit_free_buf;", "} else {", "n = 0;", "continue;", "}", "}", "s->common.offset += n * BDRV_SECTOR_SIZE;", "}", "ret = 0;", "if (!block_job_is_cancelled(&s->common) && sector_num == end) {", "ret = bdrv_drop_intermediate(active, top, base);", "}", "exit_free_buf:\nqemu_vfree(buf);", "exit_restore_reopen:\nif (s->base_flags != bdrv_get_flags(base)) {", "bdrv_reopen(base, s->base_flags, NULL);", "}", "if (s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {", "bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);", "}", "block_job_completed(&s->common, ret);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 85, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 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 ], [ 155 ], [ 157 ], [ 161 ], [ 165 ], [ 169 ], [ 171 ], [ 175, 177 ], [ 181, 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ] ]

[ "static inline long double FUNC_0(void)\n{", "assert(block_mig_state.total_time != 0);", "return (block_mig_state.reads * BLOCK_SIZE)/ block_mig_state.total_time;", "}" ]

[ 0, 0, 1, 0 ]

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

[ "size_t FUNC_0(struct iovec *out_sg, int out_num, size_t offset,\nint bswap, const char *fmt, ...)\n{", "int VAR_0;", "va_list ap;", "size_t old_offset = offset;", "va_start(ap, fmt);", "for (VAR_0 = 0; fmt[VAR_0]; VAR_0++) {", "switch (fmt[VAR_0]) {", "case 'b': {", "uint8_t *valp = va_arg(ap, uint8_t *);", "offset += v9fs_unpack(valp, out_sg, out_num, offset, sizeof(*valp));", "break;", "}", "case 'w': {", "uint16_t val, *valp;", "valp = va_arg(ap, uint16_t *);", "offset += v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));", "if (bswap) {", "*valp = le16_to_cpu(val);", "} else {", "*valp = val;", "}", "break;", "}", "case 'd': {", "uint32_t val, *valp;", "valp = va_arg(ap, uint32_t *);", "offset += v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));", "if (bswap) {", "*valp = le32_to_cpu(val);", "} else {", "*valp = val;", "}", "break;", "}", "case 'q': {", "uint64_t val, *valp;", "valp = va_arg(ap, uint64_t *);", "offset += v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));", "if (bswap) {", "*valp = le64_to_cpu(val);", "} else {", "*valp = val;", "}", "break;", "}", "case 's': {", "V9fsString *str = va_arg(ap, V9fsString *);", "offset += FUNC_0(out_sg, out_num, offset, bswap,\n\"w\", &str->size);", "str->data = g_malloc(str->size + 1);", "offset += v9fs_unpack(str->data, out_sg, out_num, offset,\nstr->size);", "str->data[str->size] = 0;", "break;", "}", "case 'Q': {", "V9fsQID *qidp = va_arg(ap, V9fsQID *);", "offset += FUNC_0(out_sg, out_num, offset, bswap, \"bdq\",\n&qidp->type, &qidp->version, &qidp->path);", "break;", "}", "case 'S': {", "V9fsStat *statp = va_arg(ap, V9fsStat *);", "offset += FUNC_0(out_sg, out_num, offset, bswap,\n\"wwdQdddqsssssddd\",\n&statp->size, &statp->type, &statp->dev,\n&statp->qid, &statp->mode, &statp->atime,\n&statp->mtime, &statp->length,\n&statp->name, &statp->uid, &statp->gid,\n&statp->muid, &statp->extension,\n&statp->n_uid, &statp->n_gid,\n&statp->n_muid);", "break;", "}", "case 'I': {", "V9fsIattr *iattr = va_arg(ap, V9fsIattr *);", "offset += FUNC_0(out_sg, out_num, offset, bswap,\n\"ddddqqqqq\",\n&iattr->valid, &iattr->mode,\n&iattr->uid, &iattr->gid, &iattr->size,\n&iattr->atime_sec, &iattr->atime_nsec,\n&iattr->mtime_sec, &iattr->mtime_nsec);", "break;", "}", "default:\nbreak;", "}", "}", "va_end(ap);", "return offset - old_offset;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101, 103 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135, 137, 139, 141, 143, 145, 147, 149, 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161, 163, 165, 167, 169, 171 ], [ 173 ], [ 175 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 187 ], [ 191 ], [ 193 ] ]

[ "int VAR_0 thread_pool_submit_co(ThreadPool *pool, ThreadPoolFunc *func,\nvoid *arg)\n{", "ThreadPoolCo tpc = { .co = qemu_coroutine_self(), .ret = -EINPROGRESS };", "assert(qemu_in_coroutine());", "thread_pool_submit_aio(pool, func, arg, thread_pool_co_cb, &tpc);", "qemu_coroutine_yield();", "return tpc.ret;", "}" ]

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

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

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

[ 0, 0, 0 ]

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "MpegAudioContext *s = avctx->priv_data;", "int VAR_0 = avctx->sample_rate;", "int VAR_1 = avctx->bit_rate;", "int VAR_2 = avctx->VAR_2;", "int VAR_3, VAR_7, VAR_5;", "float VAR_6;", "if (VAR_2 <= 0 || VAR_2 > 2){", "av_log(avctx, AV_LOG_ERROR, \"encoding %d channel(s) is not allowed in mp2\\n\", VAR_2);", "return AVERROR(EINVAL);", "}", "VAR_1 = VAR_1 / 1000;", "s->nb_channels = VAR_2;", "avctx->frame_size = MPA_FRAME_SIZE;", "avctx->delay = 512 - 32 + 1;", "s->lsf = 0;", "for(VAR_3=0;VAR_3<3;VAR_3++) {", "if (avpriv_mpa_freq_tab[VAR_3] == VAR_0)\nbreak;", "if ((avpriv_mpa_freq_tab[VAR_3] / 2) == VAR_0) {", "s->lsf = 1;", "break;", "}", "}", "if (VAR_3 == 3){", "av_log(avctx, AV_LOG_ERROR, \"Sampling rate %d is not allowed in mp2\\n\", VAR_0);", "return AVERROR(EINVAL);", "}", "s->freq_index = VAR_3;", "for(VAR_3=0;VAR_3<15;VAR_3++) {", "if (avpriv_mpa_bitrate_tab[s->lsf][1][VAR_3] == VAR_1)\nbreak;", "}", "if (VAR_3 == 15){", "av_log(avctx, AV_LOG_ERROR, \"VAR_1 %d is not allowed in mp2\\n\", VAR_1);", "return AVERROR(EINVAL);", "}", "s->bitrate_index = VAR_3;", "VAR_6 = (float)(VAR_1 * 1000 * MPA_FRAME_SIZE) / (VAR_0 * 8.0);", "s->frame_size = ((int)VAR_6) * 8;", "s->frame_frac = 0;", "s->frame_frac_incr = (int)((VAR_6 - floor(VAR_6)) * 65536.0);", "VAR_5 = ff_mpa_l2_select_table(VAR_1, s->nb_channels, VAR_0, s->lsf);", "s->sblimit = ff_mpa_sblimit_table[VAR_5];", "s->alloc_table = ff_mpa_alloc_tables[VAR_5];", "av_dlog(avctx, \"%d kb/s, %d Hz, frame_size=%d bits, VAR_5=%d, padincr=%x\\n\",\nVAR_1, VAR_0, s->frame_size, VAR_5, s->frame_frac_incr);", "for(VAR_3=0;VAR_3<s->nb_channels;VAR_3++)", "s->samples_offset[VAR_3] = 0;", "for(VAR_3=0;VAR_3<257;VAR_3++) {", "int VAR_7;", "VAR_7 = ff_mpa_enwindow[VAR_3];", "#if WFRAC_BITS != 16\nVAR_7 = (VAR_7 + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);", "#endif\ns->filter_bank[VAR_3] = VAR_7;", "if ((VAR_3 & 63) != 0)\nVAR_7 = -VAR_7;", "if (VAR_3 != 0)\ns->filter_bank[512 - VAR_3] = VAR_7;", "}", "for(VAR_3=0;VAR_3<64;VAR_3++) {", "VAR_7 = (int)(pow(2.0, (3 - VAR_3) / 3.0) * (1 << 20));", "if (VAR_7 <= 0)\nVAR_7 = 1;", "s->scale_factor_table[VAR_3] = VAR_7;", "s->scale_factor_inv_table[VAR_3] = pow(2.0, -(3 - VAR_3) / 3.0) / (float)(1 << 20);", "}", "for(VAR_3=0;VAR_3<128;VAR_3++) {", "VAR_7 = VAR_3 - 64;", "if (VAR_7 <= -3)\nVAR_7 = 0;", "else if (VAR_7 < 0)\nVAR_7 = 1;", "else if (VAR_7 == 0)\nVAR_7 = 2;", "else if (VAR_7 < 3)\nVAR_7 = 3;", "else\nVAR_7 = 4;", "s->scale_diff_table[VAR_3] = VAR_7;", "}", "for(VAR_3=0;VAR_3<17;VAR_3++) {", "VAR_7 = ff_mpa_quant_bits[VAR_3];", "if (VAR_7 < 0)\nVAR_7 = -VAR_7;", "else\nVAR_7 = VAR_7 * 3;", "s->total_quant_bits[VAR_3] = 12 * 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 95 ], [ 97 ], [ 103 ], [ 105 ], [ 111 ], [ 117 ], [ 119 ], [ 123, 125 ], [ 129 ], [ 131 ], [ 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, 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ], [ 209, 211 ], [ 213, 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ] ]

[ "BlockDriverState *FUNC_0(const char *node_name, Error **errp)\n{", "BlockDriverState *to_replace_bs = bdrv_find_node(node_name);", "AioContext *aio_context;", "if (!to_replace_bs) {", "error_setg(errp, \"Node name '%s' not found\", node_name);", "return NULL;", "}", "aio_context = bdrv_get_aio_context(to_replace_bs);", "aio_context_acquire(aio_context);", "if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {", "to_replace_bs = NULL;", "goto out;", "}", "if (!bdrv_is_first_non_filter(to_replace_bs)) {", "error_setg(errp, \"Only top most non filter can be replaced\");", "to_replace_bs = NULL;", "goto out;", "}", "out:\naio_context_release(aio_context);", "return to_replace_bs;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 63 ], [ 65 ] ]

[ "static uint32_t FUNC_0(void *opaque, target_phys_addr_t addr)\n{", "printf(\"ECC: Unsupported read 0x\" TARGET_FMT_plx \" 00\\n\", addr);", "return 0;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static inline void FUNC_0(int VAR_0, int VAR_1, TCGv VAR_2)\n{", "switch(VAR_0) {", "case OT_BYTE:\nif (VAR_1 < 4 X86_64_DEF( || VAR_1 >= 8 || x86_64_hregs)) {", "tcg_gen_deposit_tl(cpu_regs[VAR_1], cpu_regs[VAR_1], VAR_2, 0, 8);", "} else {", "tcg_gen_deposit_tl(cpu_regs[VAR_1 - 4], cpu_regs[VAR_1 - 4], VAR_2, 8, 8);", "}", "break;", "case OT_WORD:\ntcg_gen_deposit_tl(cpu_regs[VAR_1], cpu_regs[VAR_1], VAR_2, 0, 16);", "break;", "default:\ncase OT_LONG:\ntcg_gen_ext32u_tl(cpu_regs[VAR_1], VAR_2);", "break;", "#ifdef TARGET_X86_64\ncase OT_QUAD:\ntcg_gen_mov_tl(cpu_regs[VAR_1], VAR_2);", "break;", "#endif\n}", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, const char *VAR_1,\nV9fsPath *VAR_2, const char *VAR_3, FsCred *VAR_4)\n{", "int VAR_5 = -1;", "int VAR_6 = 0;", "char *VAR_7;", "V9fsString fullname;", "char VAR_8[PATH_MAX];", "v9fs_string_init(&fullname);", "v9fs_string_sprintf(&fullname, \"%s/%s\", VAR_2->data, VAR_3);", "VAR_7 = fullname.data;", "if (VAR_0->fs_sm == SM_MAPPED) {", "int VAR_9;", "ssize_t oldpath_size, write_size;", "VAR_9 = open(rpath(VAR_0, VAR_7, VAR_8), O_CREAT|O_EXCL|O_RDWR,\nSM_LOCAL_MODE_BITS);", "if (VAR_9 == -1) {", "VAR_5 = VAR_9;", "goto out;", "}", "oldpath_size = strlen(VAR_1);", "do {", "write_size = write(VAR_9, (void *)VAR_1, oldpath_size);", "} while (write_size == -1 && errno == EINTR);", "if (write_size != oldpath_size) {", "VAR_6 = errno;", "close(VAR_9);", "VAR_5 = -1;", "goto err_end;", "}", "close(VAR_9);", "VAR_4->fc_mode = VAR_4->fc_mode|S_IFLNK;", "VAR_5 = local_set_xattr(rpath(VAR_0, VAR_7, VAR_8), VAR_4);", "if (VAR_5 == -1) {", "VAR_6 = errno;", "goto err_end;", "}", "} else if ((VAR_0->fs_sm == SM_PASSTHROUGH) ||", "(VAR_0->fs_sm == SM_NONE)) {", "VAR_5 = symlink(VAR_1, rpath(VAR_0, VAR_7, VAR_8));", "if (VAR_5) {", "goto out;", "}", "VAR_5 = lchown(rpath(VAR_0, VAR_7, VAR_8), VAR_4->fc_uid,\nVAR_4->fc_gid);", "if (VAR_5 == -1) {", "if (VAR_0->fs_sm != SM_NONE) {", "VAR_6 = errno;", "goto err_end;", "} else", "VAR_5 = 0;", "}", "}", "goto out;", "err_end:\nremove(rpath(VAR_0, VAR_7, VAR_8));", "errno = VAR_6;", "out:\nv9fs_string_free(&fullname);", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 103 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 131, 133 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 143 ] ]

[ "int FUNC_0(SocketAddress *VAR_0, Error **VAR_1)\n{", "QemuOpts *opts;", "int VAR_2;", "opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);", "switch (VAR_0->kind) {", "case SOCKET_ADDRESS_KIND_INET:\ninet_addr_to_opts(opts, VAR_0->inet);", "VAR_2 = inet_listen_opts(opts, 0, VAR_1);", "break;", "case SOCKET_ADDRESS_KIND_UNIX:\nqemu_opt_set(opts, \"path\", VAR_0->q_unix->path, &error_abort);", "VAR_2 = unix_listen_opts(opts, VAR_1);", "break;", "case SOCKET_ADDRESS_KIND_FD:\nVAR_2 = monitor_get_fd(cur_mon, VAR_0->VAR_2->str, VAR_1);", "break;", "default:\nabort();", "}", "qemu_opts_del(opts);", "return VAR_2;", "}" ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "BDRVQcowState *s = VAR_0->opaque;", "unsigned int VAR_4, VAR_5, VAR_6;", "int VAR_7;", "QCowHeader header;", "Error *local_err = NULL;", "VAR_0->file = bdrv_open_child(NULL, VAR_1, \"file\", VAR_0, &child_file,\nfalse, VAR_3);", "if (!VAR_0->file) {", "return -EINVAL;", "}", "VAR_7 = bdrv_pread(VAR_0->file, 0, &header, sizeof(header));", "if (VAR_7 < 0) {", "goto fail;", "}", "be32_to_cpus(&header.magic);", "be32_to_cpus(&header.version);", "be64_to_cpus(&header.backing_file_offset);", "be32_to_cpus(&header.backing_file_size);", "be32_to_cpus(&header.mtime);", "be64_to_cpus(&header.size);", "be32_to_cpus(&header.crypt_method);", "be64_to_cpus(&header.l1_table_offset);", "if (header.magic != QCOW_MAGIC) {", "error_setg(VAR_3, \"Image not in qcow format\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "if (header.version != QCOW_VERSION) {", "error_setg(VAR_3, \"Unsupported qcow version %\" PRIu32, header.version);", "VAR_7 = -ENOTSUP;", "goto fail;", "}", "if (header.size <= 1) {", "error_setg(VAR_3, \"Image size is too small (must be at least 2 bytes)\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "if (header.cluster_bits < 9 || header.cluster_bits > 16) {", "error_setg(VAR_3, \"Cluster size must be between 512 and 64k\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "if (header.l2_bits < 9 - 3 || header.l2_bits > 16 - 3) {", "error_setg(VAR_3, \"L2 table size must be between 512 and 64k\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "if (header.crypt_method > QCOW_CRYPT_AES) {", "error_setg(VAR_3, \"invalid encryption method in qcow header\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128,\nQCRYPTO_CIPHER_MODE_CBC)) {", "error_setg(VAR_3, \"AES cipher not available\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "s->crypt_method_header = header.crypt_method;", "if (s->crypt_method_header) {", "if (bdrv_uses_whitelist() &&\ns->crypt_method_header == QCOW_CRYPT_AES) {", "error_setg(VAR_3,\n\"Use of AES-CBC encrypted qcow images is no longer \"\n\"supported in system emulators\");", "error_append_hint(VAR_3,\n\"You can use 'qemu-img convert' to convert your \"\n\"image to an alternative supported format, such \"\n\"as unencrypted qcow, or raw with the LUKS \"\n\"format instead.\\n\");", "VAR_7 = -ENOSYS;", "goto fail;", "}", "VAR_0->encrypted = true;", "}", "s->cluster_bits = header.cluster_bits;", "s->cluster_size = 1 << s->cluster_bits;", "s->cluster_sectors = 1 << (s->cluster_bits - 9);", "s->l2_bits = header.l2_bits;", "s->l2_size = 1 << s->l2_bits;", "VAR_0->total_sectors = header.size / 512;", "s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;", "VAR_6 = s->cluster_bits + s->l2_bits;", "if (header.size > UINT64_MAX - (1LL << VAR_6)) {", "error_setg(VAR_3, \"Image too large\");", "VAR_7 = -EINVAL;", "goto fail;", "} else {", "uint64_t l1_size = (header.size + (1LL << VAR_6) - 1) >> VAR_6;", "if (l1_size > INT_MAX / sizeof(uint64_t)) {", "error_setg(VAR_3, \"Image too large\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "s->l1_size = l1_size;", "}", "s->l1_table_offset = header.l1_table_offset;", "s->l1_table = g_try_new(uint64_t, s->l1_size);", "if (s->l1_table == NULL) {", "error_setg(VAR_3, \"Could not allocate memory for L1 table\");", "VAR_7 = -ENOMEM;", "goto fail;", "}", "VAR_7 = bdrv_pread(VAR_0->file, s->l1_table_offset, s->l1_table,\ns->l1_size * sizeof(uint64_t));", "if (VAR_7 < 0) {", "goto fail;", "}", "for(VAR_5 = 0;VAR_5 < s->l1_size; VAR_5++) {", "be64_to_cpus(&s->l1_table[VAR_5]);", "}", "s->l2_cache =\nqemu_try_blockalign(VAR_0->file->VAR_0,\ns->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));", "if (s->l2_cache == NULL) {", "error_setg(VAR_3, \"Could not allocate L2 table cache\");", "VAR_7 = -ENOMEM;", "goto fail;", "}", "s->cluster_cache = g_malloc(s->cluster_size);", "s->cluster_data = g_malloc(s->cluster_size);", "s->cluster_cache_offset = -1;", "if (header.backing_file_offset != 0) {", "VAR_4 = header.backing_file_size;", "if (VAR_4 > 1023 || VAR_4 >= sizeof(VAR_0->backing_file)) {", "error_setg(VAR_3, \"Backing file name too long\");", "VAR_7 = -EINVAL;", "goto fail;", "}", "VAR_7 = bdrv_pread(VAR_0->file, header.backing_file_offset,\nVAR_0->backing_file, VAR_4);", "if (VAR_7 < 0) {", "goto fail;", "}", "VAR_0->backing_file[VAR_4] = '\\0';", "}", "error_setg(&s->migration_blocker, \"The qcow format used by node '%s' \"\n\"does not support live migration\",\nbdrv_get_device_or_node_name(VAR_0));", "VAR_7 = migrate_add_blocker(s->migration_blocker, &local_err);", "if (local_err) {", "error_propagate(VAR_3, local_err);", "error_free(s->migration_blocker);", "goto fail;", "}", "qemu_co_mutex_init(&s->lock);", "return 0;", "fail:\ng_free(s->l1_table);", "qemu_vfree(s->l2_cache);", "g_free(s->cluster_cache);", "g_free(s->cluster_data);", "return VAR_7;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19, 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 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 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 239, 241 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 261, 263, 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301, 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 319, 321, 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 339 ], [ 341 ], [ 345, 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ] ]

[ "static void FUNC_0(CPUState *VAR_0, run_on_cpu_data VAR_1)\n{", "S390CPU *cpu = S390_CPU(VAR_0);", "SigpInfo *si = VAR_1.host_ptr;", "struct kvm_s390_irq VAR_2 = {", ".type = KVM_S390_RESTART,\n};", "switch (s390_cpu_get_state(cpu)) {", "case CPU_STATE_STOPPED:\ncpu_synchronize_state(VAR_0);", "do_restart_interrupt(&cpu->env);", "s390_cpu_set_state(CPU_STATE_OPERATING, cpu);", "break;", "case CPU_STATE_OPERATING:\nkvm_s390_vcpu_interrupt(cpu, &VAR_2);", "break;", "}", "si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;", "}" ]

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

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

[ "void FUNC_0(VLANClientState *VAR_0)\n{", "VLANPacket *packet, *next;", "TAILQ_FOREACH_SAFE(packet, &VAR_0->vlan->send_queue, entry, next) {", "if (packet->sender == VAR_0) {", "TAILQ_REMOVE(&VAR_0->vlan->send_queue, packet, entry);", "qemu_free(packet);", "}", "}", "}" ]

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

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

[ "static void FUNC_0 (CPUState *VAR_0, int VAR_1)\n{", "while (VAR_0->tlb_in_use > VAR_1) {", "invalidate_tlb(--VAR_0->tlb_in_use, 0);", "}", "}" ]

[ 0, 0, 0, 0, 0 ]

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

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

[ 0, 0, 0 ]

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

[ "DeviceState *FUNC_0(target_phys_addr_t addr,\nint fifo_size,\nint channel,\nCharDriverState *chr,\nqemu_irq irq)\n{", "DeviceState *dev;", "SysBusDevice *bus;", "const char VAR_0[] = \"serial\";", "char VAR_1[ARRAY_SIZE(VAR_0) + 1];", "dev = qdev_create(NULL, \"exynos4210.uart\");", "if (!chr) {", "if (channel >= MAX_SERIAL_PORTS) {", "hw_error(\"Only %d serial ports are supported by QEMU.\\n\",\nMAX_SERIAL_PORTS);", "}", "chr = serial_hds[channel];", "if (!chr) {", "snprintf(VAR_1, ARRAY_SIZE(VAR_1), \"%s%d\", VAR_0, channel);", "chr = qemu_chr_new(VAR_1, \"null\", NULL);", "if (!(chr)) {", "hw_error(\"Can't assign serial port to UART%d.\\n\", channel);", "}", "}", "}", "qdev_prop_set_chr(dev, \"chardev\", chr);", "qdev_prop_set_uint32(dev, \"channel\", channel);", "qdev_prop_set_uint32(dev, \"rx-size\", fifo_size);", "qdev_prop_set_uint32(dev, \"tx-size\", fifo_size);", "bus = sysbus_from_qdev(dev);", "qdev_init_nofail(dev);", "if (addr != (target_phys_addr_t)-1) {", "sysbus_mmio_map(bus, 0, addr);", "}", "sysbus_connect_irq(bus, 0, irq);", "return dev;", "}" ]

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

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

[ "static VncClientInfo *FUNC_0(const VncState *client)\n{", "struct sockaddr_storage VAR_0;", "socklen_t salen = sizeof(VAR_0);", "char VAR_1[NI_MAXHOST];", "char VAR_2[NI_MAXSERV];", "VncClientInfo *info;", "if (getpeername(client->csock, (struct sockaddr *)&VAR_0, &salen) < 0) {", "return NULL;", "}", "if (getnameinfo((struct sockaddr *)&VAR_0, salen,\nVAR_1, sizeof(VAR_1),\nVAR_2, sizeof(VAR_2),\nNI_NUMERICHOST | NI_NUMERICSERV) < 0) {", "return NULL;", "}", "info = g_malloc0(sizeof(*info));", "info->base = g_malloc0(sizeof(*info->base));", "info->base->VAR_1 = g_strdup(VAR_1);", "info->base->service = g_strdup(VAR_2);", "info->base->family = inet_netfamily(VAR_0.ss_family);", "info->base->websocket = client->websocket;", "if (client->tls) {", "info->x509_dname = qcrypto_tls_session_get_peer_name(client->tls);", "info->has_x509_dname = info->x509_dname != NULL;", "}", "#ifdef CONFIG_VNC_SASL\nif (client->sasl.conn && client->sasl.username) {", "info->has_sasl_username = true;", "info->sasl_username = g_strdup(client->sasl.username);", "}", "#endif\nreturn info;", "}" ]

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

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

[ "static void FUNC_0(HEVCContext *VAR_0, int VAR_1, int VAR_2)\n{", "uint8_t *src;", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;", "int VAR_8[2], VAR_9[2], VAR_10[2];", "uint8_t no_p[2] = { 0 };", "uint8_t no_q[2] = { 0 };", "int VAR_11 = VAR_0->sps->VAR_11;", "int VAR_12 = 1 << VAR_11;", "int VAR_13 = (VAR_1 >> VAR_11) +\n(VAR_2 >> VAR_11) * VAR_0->sps->ctb_width;", "int VAR_14 = VAR_0->deblock[VAR_13].VAR_16;", "int VAR_15 = VAR_0->deblock[VAR_13].VAR_18;", "int VAR_16, VAR_17, VAR_18, VAR_19;", "int VAR_20 = (VAR_0->sps->pcm_enabled_flag &&\nVAR_0->sps->pcm.loop_filter_disable_flag) ||\nVAR_0->pps->transquant_bypass_enable_flag;", "if (VAR_1) {", "VAR_17 = VAR_0->deblock[VAR_13 - 1].VAR_16;", "VAR_19 = VAR_0->deblock[VAR_13 - 1].VAR_18;", "}", "VAR_5 = VAR_1 + VAR_12;", "if (VAR_5 > VAR_0->sps->width)\nVAR_5 = VAR_0->sps->width;", "VAR_6 = VAR_2 + VAR_12;", "if (VAR_6 > VAR_0->sps->height)\nVAR_6 = VAR_0->sps->height;", "VAR_16 = VAR_14;", "VAR_18 = VAR_15;", "for (VAR_4 = VAR_2; VAR_4 < VAR_6; VAR_4 += 8) {", "for (VAR_3 = VAR_1 ? VAR_1 : 8; VAR_3 < VAR_5; VAR_3 += 8) {", "const int VAR_25 = VAR_0->vertical_bs[(VAR_3 >> 3) + (VAR_4 >> 2) * VAR_0->bs_width];", "const int VAR_25 = VAR_0->vertical_bs[(VAR_3 >> 3) + ((VAR_4 + 4) >> 2) * VAR_0->bs_width];", "if (VAR_25 || VAR_25) {", "const int VAR_25 = (get_qPy(VAR_0, VAR_3 - 1, VAR_4) + get_qPy(VAR_0, VAR_3, VAR_4) + 1) >> 1;", "const int VAR_25 = (get_qPy(VAR_0, VAR_3 - 1, VAR_4 + 4) + get_qPy(VAR_0, VAR_3, VAR_4 + 4) + 1) >> 1;", "VAR_9[0] = betatable[av_clip(VAR_25 + VAR_18, 0, MAX_QP)];", "VAR_9[1] = betatable[av_clip(VAR_25 + VAR_18, 0, MAX_QP)];", "VAR_10[0] = VAR_25 ? TC_CALC(VAR_25, VAR_25) : 0;", "VAR_10[1] = VAR_25 ? TC_CALC(VAR_25, VAR_25) : 0;", "src = &VAR_0->frame->data[LUMA][VAR_4 * VAR_0->frame->linesize[LUMA] + (VAR_3 << VAR_0->sps->pixel_shift)];", "if (VAR_20) {", "no_p[0] = get_pcm(VAR_0, VAR_3 - 1, VAR_4);", "no_p[1] = get_pcm(VAR_0, VAR_3 - 1, VAR_4 + 4);", "no_q[0] = get_pcm(VAR_0, VAR_3, VAR_4);", "no_q[1] = get_pcm(VAR_0, VAR_3, VAR_4 + 4);", "VAR_0->hevcdsp.hevc_v_loop_filter_luma_c(src,\nVAR_0->frame->linesize[LUMA],\nVAR_9, VAR_10, no_p, no_q);", "} else", "VAR_0->hevcdsp.hevc_v_loop_filter_luma(src,\nVAR_0->frame->linesize[LUMA],\nVAR_9, VAR_10, no_p, no_q);", "}", "}", "}", "for (VAR_7 = 1; VAR_7 <= 2; VAR_7++) {", "for (VAR_4 = VAR_2; VAR_4 < VAR_6; VAR_4 += 16) {", "for (VAR_3 = VAR_1 ? VAR_1 : 16; VAR_3 < VAR_5; VAR_3 += 16) {", "const int VAR_25 = VAR_0->vertical_bs[(VAR_3 >> 3) + (VAR_4 >> 2) * VAR_0->bs_width];", "const int VAR_25 = VAR_0->vertical_bs[(VAR_3 >> 3) + ((VAR_4 + 8) >> 2) * VAR_0->bs_width];", "if ((VAR_25 == 2) || (VAR_25 == 2)) {", "const int VAR_25 = (get_qPy(VAR_0, VAR_3 - 1, VAR_4) + get_qPy(VAR_0, VAR_3, VAR_4) + 1) >> 1;", "const int VAR_25 = (get_qPy(VAR_0, VAR_3 - 1, VAR_4 + 8) + get_qPy(VAR_0, VAR_3, VAR_4 + 8) + 1) >> 1;", "VAR_8[0] = (VAR_25 == 2) ? chroma_tc(VAR_0, VAR_25, VAR_7, VAR_16) : 0;", "VAR_8[1] = (VAR_25 == 2) ? chroma_tc(VAR_0, VAR_25, VAR_7, VAR_16) : 0;", "src = &VAR_0->frame->data[VAR_7][VAR_4 / 2 * VAR_0->frame->linesize[VAR_7] + ((VAR_3 / 2) << VAR_0->sps->pixel_shift)];", "if (VAR_20) {", "no_p[0] = get_pcm(VAR_0, VAR_3 - 1, VAR_4);", "no_p[1] = get_pcm(VAR_0, VAR_3 - 1, VAR_4 + 8);", "no_q[0] = get_pcm(VAR_0, VAR_3, VAR_4);", "no_q[1] = get_pcm(VAR_0, VAR_3, VAR_4 + 8);", "VAR_0->hevcdsp.hevc_v_loop_filter_chroma_c(src,\nVAR_0->frame->linesize[VAR_7],\nVAR_8, no_p, no_q);", "} else", "VAR_0->hevcdsp.hevc_v_loop_filter_chroma(src,\nVAR_0->frame->linesize[VAR_7],\nVAR_8, no_p, no_q);", "}", "}", "}", "}", "if (VAR_5 != VAR_0->sps->width)\nVAR_5 -= 8;", "for (VAR_4 = VAR_2 ? VAR_2 : 8; VAR_4 < VAR_6; VAR_4 += 8) {", "for (VAR_3 = VAR_1 ? VAR_1 - 8 : 0; VAR_3 < VAR_5; VAR_3 += 8) {", "const int VAR_25 = VAR_0->horizontal_bs[(VAR_3 + VAR_4 * VAR_0->bs_width) >> 2];", "const int VAR_25 = VAR_0->horizontal_bs[(VAR_3 + 4 + VAR_4 * VAR_0->bs_width) >> 2];", "if (VAR_25 || VAR_25) {", "const int VAR_25 = (get_qPy(VAR_0, VAR_3, VAR_4 - 1) + get_qPy(VAR_0, VAR_3, VAR_4) + 1) >> 1;", "const int VAR_25 = (get_qPy(VAR_0, VAR_3 + 4, VAR_4 - 1) + get_qPy(VAR_0, VAR_3 + 4, VAR_4) + 1) >> 1;", "VAR_16 = VAR_3 >= VAR_1 ? VAR_14 : VAR_17;", "VAR_18 = VAR_3 >= VAR_1 ? VAR_15 : VAR_19;", "VAR_9[0] = betatable[av_clip(VAR_25 + VAR_18, 0, MAX_QP)];", "VAR_9[1] = betatable[av_clip(VAR_25 + VAR_18, 0, MAX_QP)];", "VAR_10[0] = VAR_25 ? TC_CALC(VAR_25, VAR_25) : 0;", "VAR_10[1] = VAR_25 ? TC_CALC(VAR_25, VAR_25) : 0;", "src = &VAR_0->frame->data[LUMA][VAR_4 * VAR_0->frame->linesize[LUMA] + (VAR_3 << VAR_0->sps->pixel_shift)];", "if (VAR_20) {", "no_p[0] = get_pcm(VAR_0, VAR_3, VAR_4 - 1);", "no_p[1] = get_pcm(VAR_0, VAR_3 + 4, VAR_4 - 1);", "no_q[0] = get_pcm(VAR_0, VAR_3, VAR_4);", "no_q[1] = get_pcm(VAR_0, VAR_3 + 4, VAR_4);", "VAR_0->hevcdsp.hevc_h_loop_filter_luma_c(src,\nVAR_0->frame->linesize[LUMA],\nVAR_9, VAR_10, no_p, no_q);", "} else", "VAR_0->hevcdsp.hevc_h_loop_filter_luma(src,\nVAR_0->frame->linesize[LUMA],\nVAR_9, VAR_10, no_p, no_q);", "}", "}", "}", "for (VAR_7 = 1; VAR_7 <= 2; VAR_7++) {", "for (VAR_4 = VAR_2 ? VAR_2 : 16; VAR_4 < VAR_6; VAR_4 += 16) {", "for (VAR_3 = VAR_1 - 8; VAR_3 < VAR_5; VAR_3 += 16) {", "int VAR_25, VAR_25;", "if (VAR_3 < 0) {", "VAR_25 = 0;", "VAR_25 = VAR_0->horizontal_bs[(VAR_3 + 8 + VAR_4 * VAR_0->bs_width) >> 2];", "} else if (VAR_3 >= VAR_5 - 8) {", "VAR_25 = VAR_0->horizontal_bs[(VAR_3 + VAR_4 * VAR_0->bs_width) >> 2];", "VAR_25 = 0;", "} else {", "VAR_25 = VAR_0->horizontal_bs[(VAR_3 + VAR_4 * VAR_0->bs_width) >> 2];", "VAR_25 = VAR_0->horizontal_bs[(VAR_3 + 8 + VAR_4 * VAR_0->bs_width) >> 2];", "}", "if ((VAR_25 == 2) || (VAR_25 == 2)) {", "const int VAR_25 = VAR_25 == 2 ? (get_qPy(VAR_0, VAR_3, VAR_4 - 1) + get_qPy(VAR_0, VAR_3, VAR_4) + 1) >> 1 : 0;", "const int VAR_25 = VAR_25 == 2 ? (get_qPy(VAR_0, VAR_3 + 8, VAR_4 - 1) + get_qPy(VAR_0, VAR_3 + 8, VAR_4) + 1) >> 1 : 0;", "VAR_16 = VAR_3 >= VAR_1 ? VAR_14 : VAR_17;", "VAR_8[0] = VAR_25 == 2 ? chroma_tc(VAR_0, VAR_25, VAR_7, VAR_16) : 0;", "VAR_8[1] = VAR_25 == 2 ? chroma_tc(VAR_0, VAR_25, VAR_7, VAR_14) : 0;", "src = &VAR_0->frame->data[VAR_7][VAR_4 / 2 * VAR_0->frame->linesize[VAR_7] + ((VAR_3 / 2) << VAR_0->sps->pixel_shift)];", "if (VAR_20) {", "no_p[0] = get_pcm(VAR_0, VAR_3, VAR_4 - 1);", "no_p[1] = get_pcm(VAR_0, VAR_3 + 8, VAR_4 - 1);", "no_q[0] = get_pcm(VAR_0, VAR_3, VAR_4);", "no_q[1] = get_pcm(VAR_0, VAR_3 + 8, VAR_4);", "VAR_0->hevcdsp.hevc_h_loop_filter_chroma_c(src,\nVAR_0->frame->linesize[VAR_7],\nVAR_8, no_p, no_q);", "} else", "VAR_0->hevcdsp.hevc_h_loop_filter_chroma(src,\nVAR_0->frame->linesize[VAR_7],\nVAR_8, no_p, no_q);", "}", "}", "}", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57, 59 ], [ 63 ], [ 65 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107, 109, 111 ], [ 113 ], [ 115, 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165, 167, 169 ], [ 171 ], [ 173, 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 191, 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 211 ], [ 213 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237, 239, 241 ], [ 243 ], [ 245, 247, 249 ], [ 251 ], [ 253 ], [ 255 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 295 ], [ 297 ], [ 299 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321, 323, 325 ], [ 327 ], [ 329, 331, 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ] ]

[ "static inline void FUNC_0(AC3DecodeContext *VAR_0)\n{", "int VAR_1;", "float (*VAR_2)[256] = VAR_0->audio_block.block_output;", "for (VAR_1 = 0; VAR_1 < 256; VAR_1++) {", "VAR_2[1][VAR_1] -= VAR_2[3][VAR_1];", "VAR_2[2][VAR_1] += VAR_2[4][VAR_1];", "}", "memset(VAR_2[3], 0, sizeof(VAR_2[3]));", "memset(VAR_2[4], 0, sizeof(VAR_2[4]));", "}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, QSVEncContext *VAR_1)\n{", "QSVFrame *cur;", "MFXVideoENCODE_Close(VAR_1->session);", "if (VAR_1->internal_session)\nMFXClose(VAR_1->internal_session);", "VAR_1->session = NULL;", "VAR_1->internal_session = NULL;", "cur = VAR_1->work_frames;", "while (cur) {", "VAR_1->work_frames = cur->next;", "av_frame_free(&cur->frame);", "av_freep(&cur);", "cur = VAR_1->work_frames;", "}", "while (VAR_1->async_fifo && av_fifo_size(VAR_1->async_fifo)) {", "AVPacket pkt;", "mfxSyncPoint sync;", "mfxBitstream *bs;", "av_fifo_generic_read(VAR_1->async_fifo, &pkt, sizeof(pkt), NULL);", "av_fifo_generic_read(VAR_1->async_fifo, &sync, sizeof(sync), NULL);", "av_fifo_generic_read(VAR_1->async_fifo, &bs, sizeof(bs), NULL);", "av_freep(&bs);", "av_packet_unref(&pkt);", "}", "av_fifo_free(VAR_1->async_fifo);", "VAR_1->async_fifo = NULL;", "av_frame_free(&VAR_0->coded_frame);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "const AVPixFmtDescriptor *VAR_0 = av_pix_fmt_desc_get(avctx->pix_fmt);", "avctx->coded_frame = av_frame_alloc();", "if (!avctx->coded_frame)\nreturn AVERROR(ENOMEM);", "avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;", "avctx->coded_frame->key_frame = 1;", "avctx->bits_per_coded_sample = av_get_bits_per_pixel(VAR_0);", "if(!avctx->codec_tag)\navctx->codec_tag = avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);", "return 0;", "}" ]

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

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

[ "int FUNC_0(AudioMix *VAR_0, AudioData *VAR_1)\n{", "int VAR_2 = 1;", "int VAR_3 = VAR_1->nb_samples;", "int VAR_4, VAR_5;", "if (VAR_0->has_optimized_func) {", "int VAR_6 = FFALIGN(VAR_3, VAR_0->samples_align);", "if (!(VAR_1->ptr_align % VAR_0->ptr_align) &&\nVAR_1->samples_align >= VAR_6) {", "VAR_3 = VAR_6;", "VAR_2 = 0;", "}", "}", "av_dlog(VAR_0->avr, \"audio_mix: %d samples - %d to %d channels (%s)\\n\",\nVAR_1->nb_samples, VAR_0->in_channels, VAR_0->out_channels,\nVAR_2 ? VAR_0->func_descr_generic : VAR_0->func_descr);", "if (VAR_0->in_matrix_channels && VAR_0->out_matrix_channels) {", "uint8_t **data;", "uint8_t *data0[AVRESAMPLE_MAX_CHANNELS];", "if (VAR_0->out_matrix_channels < VAR_0->out_channels ||\nVAR_0->in_matrix_channels < VAR_0->in_channels) {", "for (VAR_4 = 0, VAR_5 = 0; VAR_4 < FFMAX(VAR_0->in_channels, VAR_0->out_channels); VAR_4++) {", "if (VAR_0->input_skip[VAR_4] || VAR_0->output_skip[VAR_4] || VAR_0->output_zero[VAR_4])\ncontinue;", "data0[VAR_5++] = VAR_1->data[VAR_4];", "}", "data = data0;", "} else {", "data = VAR_1->data;", "}", "if (VAR_2)\nVAR_0->mix_generic(data, VAR_0->matrix, VAR_3, VAR_0->out_matrix_channels,\nVAR_0->in_matrix_channels);", "else\nVAR_0->mix(data, VAR_0->matrix, VAR_3, VAR_0->out_matrix_channels,\nVAR_0->in_matrix_channels);", "}", "if (VAR_0->out_matrix_channels < VAR_0->out_channels) {", "for (VAR_4 = 0; VAR_4 < VAR_0->out_channels; VAR_4++)", "if (VAR_0->output_zero[VAR_4])\nav_samples_set_silence(&VAR_1->data[VAR_4], 0, VAR_3, 1, VAR_0->fmt);", "}", "ff_audio_data_set_channels(VAR_1, VAR_0->out_channels);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(IDEDMA *VAR_0)\n{", "AHCIDevice *ad = DO_UPCAST(AHCIDevice, VAR_0, VAR_0);", "DPRINTF(ad->port_no, \"VAR_0 done\\n\");", "ahci_write_fis_d2h(ad, NULL);", "ad->dma_cb = NULL;", "ad->check_bh = qemu_bh_new(ahci_check_cmd_bh, ad);", "qemu_bh_schedule(ad->check_bh);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 15 ], [ 19 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ] ]

[ "DriveInfo *FUNC_0(QemuOpts *opts, void *opaque,\nint *fatal_error)\n{", "const char *VAR_0;", "const char *VAR_1 = NULL;", "char VAR_2[128];", "const char *VAR_3;", "const char *VAR_4 = \"\";", "BlockInterfaceType type;", "enum { MEDIA_DISK, MEDIA_CDROM } VAR_5;", "int VAR_6, VAR_7;", "int VAR_8, VAR_9, VAR_10, VAR_11;", "BlockDriver *drv = NULL;", "QEMUMachine *machine = opaque;", "int VAR_12;", "int VAR_13;", "int VAR_14 = 0;", "int VAR_15 = 0;", "int VAR_16, VAR_17;", "const char *VAR_18;", "DriveInfo *dinfo;", "int VAR_19 = 0;", "*fatal_error = 1;", "VAR_11 = BIOS_ATA_TRANSLATION_AUTO;", "if (machine && machine->use_scsi) {", "type = IF_SCSI;", "VAR_12 = MAX_SCSI_DEVS;", "pstrcpy(VAR_2, sizeof(VAR_2), \"scsi\");", "} else {", "type = IF_IDE;", "VAR_12 = MAX_IDE_DEVS;", "pstrcpy(VAR_2, sizeof(VAR_2), \"ide\");", "}", "VAR_5 = MEDIA_DISK;", "VAR_6 = qemu_opt_get_number(opts, \"bus\", 0);", "VAR_7 = qemu_opt_get_number(opts, \"unit\", -1);", "VAR_13 = qemu_opt_get_number(opts, \"VAR_13\", -1);", "VAR_8 = qemu_opt_get_number(opts, \"VAR_8\", 0);", "VAR_9 = qemu_opt_get_number(opts, \"VAR_9\", 0);", "VAR_10 = qemu_opt_get_number(opts, \"VAR_10\", 0);", "VAR_19 = qemu_opt_get_bool(opts, \"VAR_19\", 0);", "VAR_14 = qemu_opt_get_bool(opts, \"readonly\", 0);", "VAR_1 = qemu_opt_get(opts, \"VAR_1\");", "VAR_3 = qemu_opt_get(opts, \"VAR_3\");", "if ((VAR_0 = qemu_opt_get(opts, \"if\")) != NULL) {", "pstrcpy(VAR_2, sizeof(VAR_2), VAR_0);", "if (!strcmp(VAR_0, \"ide\")) {", "type = IF_IDE;", "VAR_12 = MAX_IDE_DEVS;", "} else if (!strcmp(VAR_0, \"scsi\")) {", "type = IF_SCSI;", "VAR_12 = MAX_SCSI_DEVS;", "} else if (!strcmp(VAR_0, \"floppy\")) {", "type = IF_FLOPPY;", "VAR_12 = 0;", "} else if (!strcmp(VAR_0, \"pflash\")) {", "type = IF_PFLASH;", "VAR_12 = 0;", "} else if (!strcmp(VAR_0, \"mtd\")) {", "type = IF_MTD;", "VAR_12 = 0;", "} else if (!strcmp(VAR_0, \"sd\")) {", "type = IF_SD;", "VAR_12 = 0;", "} else if (!strcmp(VAR_0, \"virtio\")) {", "type = IF_VIRTIO;", "VAR_12 = 0;", "} else if (!strcmp(VAR_0, \"xen\")) {", "type = IF_XEN;", "VAR_12 = 0;", "} else if (!strcmp(VAR_0, \"none\")) {", "type = IF_NONE;", "VAR_12 = 0;", "} else {", "fprintf(stderr, \"qemu: unsupported bus type '%s'\\n\", VAR_0);", "return NULL;", "}", "}", "if (VAR_8 || VAR_9 || VAR_10) {", "if (VAR_8 < 1 || (type == IF_IDE && VAR_8 > 16383)) {", "fprintf(stderr, \"qemu: '%s' invalid physical VAR_8 number\\n\", VAR_0);", "return NULL;", "}", "if (VAR_9 < 1 || (type == IF_IDE && VAR_9 > 16)) {", "fprintf(stderr, \"qemu: '%s' invalid physical VAR_9 number\\n\", VAR_0);", "return NULL;", "}", "if (VAR_10 < 1 || (type == IF_IDE && VAR_10 > 63)) {", "fprintf(stderr, \"qemu: '%s' invalid physical VAR_10 number\\n\", VAR_0);", "return NULL;", "}", "}", "if ((VAR_0 = qemu_opt_get(opts, \"trans\")) != NULL) {", "if (!VAR_8) {", "fprintf(stderr,\n\"qemu: '%s' trans must be used with VAR_8,VAR_9 and VAR_10\\n\",\nVAR_0);", "return NULL;", "}", "if (!strcmp(VAR_0, \"none\"))\nVAR_11 = BIOS_ATA_TRANSLATION_NONE;", "else if (!strcmp(VAR_0, \"lba\"))\nVAR_11 = BIOS_ATA_TRANSLATION_LBA;", "else if (!strcmp(VAR_0, \"auto\"))\nVAR_11 = BIOS_ATA_TRANSLATION_AUTO;", "else {", "fprintf(stderr, \"qemu: '%s' invalid VAR_11 type\\n\", VAR_0);", "return NULL;", "}", "}", "if ((VAR_0 = qemu_opt_get(opts, \"VAR_5\")) != NULL) {", "if (!strcmp(VAR_0, \"disk\")) {", "VAR_5 = MEDIA_DISK;", "} else if (!strcmp(VAR_0, \"cdrom\")) {", "if (VAR_8 || VAR_10 || VAR_9) {", "fprintf(stderr,\n\"qemu: '%s' invalid physical CHS format\\n\", VAR_0);", "return NULL;", "}", "VAR_5 = MEDIA_CDROM;", "} else {", "fprintf(stderr, \"qemu: '%s' invalid VAR_5\\n\", VAR_0);", "return NULL;", "}", "}", "if ((VAR_0 = qemu_opt_get(opts, \"cache\")) != NULL) {", "if (!strcmp(VAR_0, \"off\") || !strcmp(VAR_0, \"none\")) {", "VAR_15 |= BDRV_O_NOCACHE;", "} else if (!strcmp(VAR_0, \"writeback\")) {", "} else if (!strcmp(VAR_0, \"writethrough\")) {", "} else {", "fprintf(stderr, \"qemu: invalid cache option\\n\");", "return NULL;", "}", "}", "#ifdef CONFIG_LINUX_AIO\nif ((VAR_0 = qemu_opt_get(opts, \"aio\")) != NULL) {", "if (!strcmp(VAR_0, \"native\")) {", "VAR_15 |= BDRV_O_NATIVE_AIO;", "} else if (!strcmp(VAR_0, \"threads\")) {", "} else {", "fprintf(stderr, \"qemu: invalid aio option\\n\");", "return NULL;", "}", "}", "#endif\nif ((VAR_0 = qemu_opt_get(opts, \"format\")) != NULL) {", "if (strcmp(VAR_0, \"?\") == 0) {", "fprintf(stderr, \"qemu: Supported formats:\");", "bdrv_iterate_format(bdrv_format_print, NULL);", "fprintf(stderr, \"\\n\");", "return NULL;", "}", "drv = bdrv_find_whitelisted_format(VAR_0);", "if (!drv) {", "fprintf(stderr, \"qemu: '%s' invalid format\\n\", VAR_0);", "return NULL;", "}", "}", "VAR_17 = BLOCK_ERR_STOP_ENOSPC;", "if ((VAR_0 = qemu_opt_get(opts, \"werror\")) != NULL) {", "if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {", "fprintf(stderr, \"werror is no supported by this format\\n\");", "return NULL;", "}", "VAR_17 = parse_block_error_action(VAR_0, 0);", "if (VAR_17 < 0) {", "return NULL;", "}", "}", "VAR_16 = BLOCK_ERR_REPORT;", "if ((VAR_0 = qemu_opt_get(opts, \"rerror\")) != NULL) {", "if (type != IF_IDE && type != IF_VIRTIO) {", "fprintf(stderr, \"rerror is no supported by this format\\n\");", "return NULL;", "}", "VAR_16 = parse_block_error_action(VAR_0, 1);", "if (VAR_16 < 0) {", "return NULL;", "}", "}", "if ((VAR_18 = qemu_opt_get(opts, \"addr\")) != NULL) {", "if (type != IF_VIRTIO) {", "fprintf(stderr, \"addr is not supported\\n\");", "return NULL;", "}", "}", "if (VAR_13 != -1) {", "if (VAR_6 != 0 || VAR_7 != -1) {", "fprintf(stderr,\n\"qemu: VAR_13 cannot be used with bus and unit\\n\");", "return NULL;", "}", "if (VAR_12 == 0)\n{", "VAR_7 = VAR_13;", "VAR_6 = 0;", "} else {", "VAR_7 = VAR_13 % VAR_12;", "VAR_6 = VAR_13 / VAR_12;", "}", "}", "if (VAR_7 == -1) {", "VAR_7 = 0;", "while (drive_get(type, VAR_6, VAR_7) != NULL) {", "VAR_7++;", "if (VAR_12 && VAR_7 >= VAR_12) {", "VAR_7 -= VAR_12;", "VAR_6++;", "}", "}", "}", "if (VAR_12 && VAR_7 >= VAR_12) {", "fprintf(stderr, \"qemu: unit %d too big (max is %d)\\n\",\nVAR_7, VAR_12 - 1);", "return NULL;", "}", "if (drive_get(type, VAR_6, VAR_7) != NULL) {", "*fatal_error = 0;", "return NULL;", "}", "dinfo = qemu_mallocz(sizeof(*dinfo));", "if ((VAR_0 = qemu_opts_id(opts)) != NULL) {", "dinfo->id = qemu_strdup(VAR_0);", "} else {", "dinfo->id = qemu_mallocz(32);", "if (type == IF_IDE || type == IF_SCSI)\nVAR_4 = (VAR_5 == MEDIA_CDROM) ? \"-cd\" : \"-hd\";", "if (VAR_12)\nsnprintf(dinfo->id, 32, \"%s%i%s%i\",\nVAR_2, VAR_6, VAR_4, VAR_7);", "else\nsnprintf(dinfo->id, 32, \"%s%s%i\",\nVAR_2, VAR_4, VAR_7);", "}", "dinfo->bdrv = bdrv_new(dinfo->id);", "dinfo->VAR_18 = VAR_18;", "dinfo->type = type;", "dinfo->bus = VAR_6;", "dinfo->unit = VAR_7;", "dinfo->VAR_16 = VAR_16;", "dinfo->VAR_17 = VAR_17;", "dinfo->opts = opts;", "if (VAR_3)\nstrncpy(dinfo->VAR_3, VAR_3, sizeof(VAR_3));", "QTAILQ_INSERT_TAIL(&drives, dinfo, next);", "switch(type) {", "case IF_IDE:\ncase IF_SCSI:\ncase IF_XEN:\ncase IF_NONE:\nswitch(VAR_5) {", "case MEDIA_DISK:\nif (VAR_8 != 0) {", "bdrv_set_geometry_hint(dinfo->bdrv, VAR_8, VAR_9, VAR_10);", "bdrv_set_translation_hint(dinfo->bdrv, VAR_11);", "}", "break;", "case MEDIA_CDROM:\nbdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);", "break;", "}", "break;", "case IF_SD:\ncase IF_FLOPPY:\nbdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);", "break;", "case IF_PFLASH:\ncase IF_MTD:\nbreak;", "case IF_VIRTIO:\nopts = qemu_opts_create(&qemu_device_opts, NULL, 0);", "qemu_opt_set(opts, \"driver\", \"virtio-blk-pci\");", "qemu_opt_set(opts, \"drive\", dinfo->id);", "if (VAR_18)\nqemu_opt_set(opts, \"addr\", VAR_18);", "break;", "case IF_COUNT:\nabort();", "}", "if (!VAR_1) {", "*fatal_error = 0;", "return NULL;", "}", "if (VAR_19) {", "VAR_15 &= ~BDRV_O_CACHE_MASK;", "VAR_15 |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB);", "}", "if (VAR_5 == MEDIA_CDROM) {", "VAR_14 = 1;", "} else if (VAR_14 == 1) {", "if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY) {", "fprintf(stderr, \"qemu: readonly flag not supported for drive with this interface\\n\");", "return NULL;", "}", "}", "VAR_15 |= VAR_14 ? 0 : BDRV_O_RDWR;", "if (bdrv_open(dinfo->bdrv, VAR_1, VAR_15, drv) < 0) {", "fprintf(stderr, \"qemu: could not open disk image %s: %s\\n\",\nVAR_1, strerror(errno));", "return NULL;", "}", "if (bdrv_key_required(dinfo->bdrv))\nautostart = 0;", "*fatal_error = 0;", "return dinfo;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 47 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 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 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211, 213, 215 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225, 227 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255, 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 289 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 305, 307 ], [ 309 ], [ 311 ], [ 313 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327, 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 429 ], [ 431 ], [ 433, 435 ], [ 437 ], [ 439 ], [ 441, 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 495 ], [ 497, 499 ], [ 501 ], [ 503 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 539 ], [ 541, 543 ], [ 545, 547, 549 ], [ 551, 553, 555 ], [ 557 ], [ 559 ], [ 561 ], [ 563 ], [ 565 ], [ 567 ], [ 569 ], [ 571 ], [ 573 ], [ 575, 577 ], [ 579 ], [ 583 ], [ 585, 587, 589, 591, 593 ], [ 595, 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607, 609 ], [ 611 ], [ 613 ], [ 615 ], [ 617, 623, 625 ], [ 627 ], [ 629, 631, 633 ], [ 635, 639 ], [ 641 ], [ 643 ], [ 645, 647 ], [ 649 ], [ 651, 653 ], [ 655 ], [ 657 ], [ 659 ], [ 661 ], [ 663 ], [ 665 ], [ 669 ], [ 671 ], [ 673 ], [ 677 ], [ 681 ], [ 683 ], [ 685 ], [ 687 ], [ 689 ], [ 691 ], [ 693 ], [ 697 ], [ 701 ], [ 703, 705 ], [ 707 ], [ 709 ], [ 713, 715 ], [ 717 ], [ 719 ], [ 721 ] ]

[ "static void FUNC_0(MmContext * VAR_0, int VAR_1, int VAR_2, const uint8_t *VAR_3, int VAR_4)\n{", "int VAR_5, VAR_6, VAR_7;", "VAR_5=0; VAR_6=0; VAR_7=0;", "while(VAR_5<VAR_4) {", "int VAR_8, VAR_9;", "if (VAR_3[VAR_5] & 0x80) {", "VAR_8 = 1;", "VAR_9 = VAR_3[VAR_5];", "VAR_5++;", "}else{", "VAR_8 = (VAR_3[VAR_5] & 0x7f) + 2;", "VAR_9 = VAR_3[VAR_5+1];", "VAR_5+=2;", "}", "if (VAR_1)\nVAR_8 *=2;", "if (VAR_9) {", "memset(VAR_0->frame.data[0] + VAR_7*VAR_0->frame.linesize[0] + VAR_6, VAR_9, VAR_8);", "if (VAR_2)\nmemset(VAR_0->frame.data[0] + (VAR_7+1)*VAR_0->frame.linesize[0] + VAR_6, VAR_9, VAR_8);", "}", "VAR_6+= VAR_8;", "if (VAR_6 >= VAR_0->avctx->width) {", "VAR_6=0;", "VAR_7 += VAR_2 ? 2 : 1;", "}", "}", "}" ]

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

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

[ "FUNC_0(QEMUMachineInitArgs *VAR_0)\n{", "const char *VAR_1 = VAR_0->VAR_1;", "const char *VAR_2 = VAR_0->VAR_2;", "const char *VAR_3 = VAR_0->VAR_3;", "const char *VAR_4 = VAR_0->VAR_4;", "LM32CPU *cpu;", "CPULM32State *env;", "int VAR_5;", "DriveInfo *dinfo;", "MemoryRegion *address_space_mem = get_system_memory();", "MemoryRegion *phys_sdram = g_new(MemoryRegion, 1);", "qemu_irq irq[32], *cpu_irq;", "int VAR_6;", "char *VAR_7;", "ResetInfo *reset_info;", "hwaddr flash_base = 0x00000000;", "size_t flash_sector_size = 128 * 1024;", "size_t flash_size = 32 * 1024 * 1024;", "hwaddr sdram_base = 0x40000000;", "size_t sdram_size = 128 * 1024 * 1024;", "hwaddr initrd_base = sdram_base + 0x1002000;", "hwaddr cmdline_base = sdram_base + 0x1000000;", "size_t initrd_max = sdram_size - 0x1002000;", "reset_info = g_malloc0(sizeof(ResetInfo));", "if (VAR_1 == NULL) {", "VAR_1 = \"lm32-full\";", "cpu = cpu_lm32_init(VAR_1);", "env = &cpu->env;", "reset_info->cpu = cpu;", "cpu_lm32_set_phys_msb_ignore(env, 1);", "memory_region_init_ram(phys_sdram, NULL, \"milkymist.sdram\", sdram_size);", "vmstate_register_ram_global(phys_sdram);", "memory_region_add_subregion(address_space_mem, sdram_base, phys_sdram);", "dinfo = drive_get(IF_PFLASH, 0, 0);", "pflash_cfi01_register(flash_base, NULL, \"milkymist.flash\", flash_size,\ndinfo ? dinfo->bdrv : NULL, flash_sector_size,\nflash_size / flash_sector_size, 2,\n0x00, 0x89, 0x00, 0x1d, 1);", "cpu_irq = qemu_allocate_irqs(cpu_irq_handler, cpu, 1);", "env->pic_state = lm32_pic_init(*cpu_irq);", "for (VAR_6 = 0; VAR_6 < 32; VAR_6++) {", "irq[VAR_6] = qdev_get_gpio_in(env->pic_state, VAR_6);", "if (bios_name == NULL) {", "bios_name = BIOS_FILENAME;", "VAR_7 = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);", "if (VAR_7) {", "load_image_targphys(VAR_7, BIOS_OFFSET, BIOS_SIZE);", "reset_info->bootstrap_pc = BIOS_OFFSET;", "if (!VAR_2 && !dinfo && !VAR_7 && !qtest_enabled()) {", "fprintf(stderr, \"qemu: could not load Milkymist One bios '%s'\\n\",\nbios_name);", "milkymist_uart_create(0x60000000, irq[0]);", "milkymist_sysctl_create(0x60001000, irq[1], irq[2], irq[3],\n80000000, 0x10014d31, 0x0000041f, 0x00000001);", "milkymist_hpdmc_create(0x60002000);", "milkymist_vgafb_create(0x60003000, 0x40000000, 0x0fffffff);", "milkymist_memcard_create(0x60004000);", "milkymist_ac97_create(0x60005000, irq[4], irq[5], irq[6], irq[7]);", "milkymist_pfpu_create(0x60006000, irq[8]);", "milkymist_tmu2_create(0x60007000, irq[9]);", "milkymist_minimac2_create(0x60008000, 0x30000000, irq[10], irq[11]);", "milkymist_softusb_create(0x6000f000, irq[15],\n0x20000000, 0x1000, 0x20020000, 0x2000);", "env->juart_state = lm32_juart_init();", "if (VAR_2) {", "uint64_t entry;", "VAR_5 = load_elf(VAR_2, NULL, NULL, &entry, NULL, NULL,\n1, ELF_MACHINE, 0);", "reset_info->bootstrap_pc = entry;", "if (VAR_5 < 0) {", "VAR_5 = load_image_targphys(VAR_2, sdram_base,\nsdram_size);", "reset_info->bootstrap_pc = sdram_base;", "if (VAR_5 < 0) {", "fprintf(stderr, \"qemu: could not load kernel '%s'\\n\",\nVAR_2);", "if (VAR_3 && strlen(VAR_3)) {", "pstrcpy_targphys(\"cmdline\", cmdline_base, TARGET_PAGE_SIZE,\nVAR_3);", "reset_info->cmdline_base = (uint32_t)cmdline_base;", "if (VAR_4) {", "size_t initrd_size;", "initrd_size = load_image_targphys(VAR_4, initrd_base,\ninitrd_max);", "reset_info->initrd_base = (uint32_t)initrd_base;", "reset_info->initrd_size = (uint32_t)initrd_size;", "qemu_register_reset(main_cpu_reset, reset_info);" ]

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

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

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

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

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

[ "static int FUNC_0(struct bt_hci_s *VAR_0, bdaddr_t *VAR_1)\n{", "struct bt_device_s *VAR_2;", "evt_remote_name_req_complete params;", "int VAR_3;", "for (VAR_2 = VAR_0->device.net->VAR_2; VAR_2; VAR_2 = VAR_2->next)", "if (VAR_2->page_scan && !bacmp(&VAR_2->bd_addr, VAR_1))\nbreak;", "if (!VAR_2)\nreturn -ENODEV;", "bt_hci_event_status(VAR_0, HCI_SUCCESS);", "params.status = HCI_SUCCESS;", "bacpy(&params.VAR_1, &VAR_2->bd_addr);", "VAR_3 = snprintf(params.name, sizeof(params.name),\n\"%s\", VAR_2->lmp_name ?: \"\");", "memset(params.name + VAR_3, 0, sizeof(params.name) - VAR_3);", "bt_hci_event(VAR_0, EVT_REMOTE_NAME_REQ_COMPLETE,\n&params, EVT_REMOTE_NAME_REQ_COMPLETE_SIZE);", "return 0;", "}" ]

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

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

[ "int FUNC_0(void *VAR_0, const AVOption *VAR_1)\n{", "int64_t i64;", "double VAR_2, VAR_3;", "float VAR_4;", "AVRational q;", "int VAR_5, VAR_6, VAR_7;", "char *VAR_8;", "void *VAR_9;", "if (!VAR_1 || !VAR_0)\nreturn AVERROR(EINVAL);", "VAR_9 = ((uint8_t*)VAR_0) + VAR_1->offset;", "switch (VAR_1->type) {", "case AV_OPT_TYPE_CONST:\nreturn 1;", "case AV_OPT_TYPE_FLAGS:\ncase AV_OPT_TYPE_PIXEL_FMT:\ncase AV_OPT_TYPE_SAMPLE_FMT:\ncase AV_OPT_TYPE_INT:\ncase AV_OPT_TYPE_CHANNEL_LAYOUT:\ncase AV_OPT_TYPE_DURATION:\ncase AV_OPT_TYPE_INT64:\nread_number(VAR_1, VAR_9, NULL, NULL, &i64);", "return VAR_1->default_val.i64 == i64;", "case AV_OPT_TYPE_STRING:\nVAR_8 = *(char **)VAR_9;", "if (VAR_8 == VAR_1->default_val.VAR_8)\nreturn 1;", "if (!VAR_8 || !VAR_1->default_val.VAR_8)\nreturn 0;", "return !strcmp(VAR_8, VAR_1->default_val.VAR_8);", "case AV_OPT_TYPE_DOUBLE:\nread_number(VAR_1, VAR_9, &VAR_2, NULL, NULL);", "return VAR_1->default_val.dbl == VAR_2;", "case AV_OPT_TYPE_FLOAT:\nread_number(VAR_1, VAR_9, &VAR_2, NULL, NULL);", "VAR_4 = VAR_1->default_val.dbl;", "VAR_3 = VAR_4;", "return VAR_3 == VAR_2;", "case AV_OPT_TYPE_RATIONAL:\nq = av_d2q(VAR_1->default_val.dbl, INT_MAX);", "return !av_cmp_q(*(AVRational*)VAR_9, q);", "case AV_OPT_TYPE_BINARY: {", "struct {", "uint8_t *data;", "int size;", "} VAR_10 = {0};", "int VAR_11 = *(int *)((void **)VAR_9 + 1);", "void *VAR_12 = *(void **)VAR_9;", "if (!VAR_12 && (!VAR_1->default_val.VAR_8 || !strlen(VAR_1->default_val.VAR_8)))\nreturn 1;", "if (VAR_12 && VAR_1->default_val.VAR_8 && !strlen(VAR_1->default_val.VAR_8))\nreturn 0;", "if (VAR_11 != strlen(VAR_1->default_val.VAR_8) / 2)\nreturn 0;", "VAR_5 = set_string_binary(NULL, NULL, VAR_1->default_val.VAR_8, &VAR_10.data);", "if (!VAR_5)\nVAR_5 = !memcmp(VAR_12, VAR_10.data, VAR_10.size);", "av_free(VAR_10.data);", "return VAR_5;", "}", "case AV_OPT_TYPE_DICT:\nreturn !!(*(void **)VAR_9);", "case AV_OPT_TYPE_IMAGE_SIZE:\nif (!VAR_1->default_val.VAR_8 || !strcmp(VAR_1->default_val.VAR_8, \"none\"))\nVAR_6 = VAR_7 = 0;", "else if ((VAR_5 = av_parse_video_size(&VAR_6, &VAR_7, VAR_1->default_val.VAR_8)) < 0)\nreturn VAR_5;", "return (VAR_6 == *(int *)VAR_9) && (VAR_7 == *((int *)VAR_9+1));", "case AV_OPT_TYPE_VIDEO_RATE:\nq = (AVRational){0, 0};", "if (VAR_1->default_val.VAR_8)\nav_parse_video_rate(&q, VAR_1->default_val.VAR_8);", "return !av_cmp_q(*(AVRational*)VAR_9, q);", "case AV_OPT_TYPE_COLOR: {", "uint8_t color[4] = {0, 0, 0, 0};", "if (VAR_1->default_val.VAR_8)\nav_parse_color(color, VAR_1->default_val.VAR_8, -1, NULL);", "return !memcmp(color, VAR_9, sizeof(color));", "}", "default:\nav_log(VAR_0, AV_LOG_WARNING, \"Not supported option type: %VAR_2, option name: %s\\n\", VAR_1->type, VAR_1->name);", "break;", "}", "return AVERROR_PATCHWELCOME;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21, 23 ], [ 27 ], [ 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, 133 ], [ 135, 137, 139 ], [ 141, 143 ], [ 145 ], [ 147, 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nunsigned char *VAR_3, int VAR_4)\n{", "Indeo3DecodeContext *s=VAR_0->priv_data;", "unsigned char *VAR_5, *VAR_6;", "int VAR_7;", "if (VAR_4 == 0) {", "return 0;", "}", "iv_decode_frame(s, VAR_3, VAR_4);", "if(s->frame.VAR_1[0])\nVAR_0->release_buffer(VAR_0, &s->frame);", "s->frame.reference = 0;", "if(VAR_0->get_buffer(VAR_0, &s->frame) < 0) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return -1;", "}", "VAR_5 = s->cur_frame->Ybuf;", "VAR_6 = s->frame.VAR_1[0];", "for (VAR_7 = 0; VAR_7 < s->height; VAR_7++) {", "memcpy(VAR_6, VAR_5, s->cur_frame->y_w);", "VAR_5 += s->cur_frame->y_w;", "VAR_6 += s->frame.linesize[0];", "}", "if (!(s->VAR_0->flags & CODEC_FLAG_GRAY))\n{", "VAR_5 = s->cur_frame->Ubuf;", "VAR_6 = s->frame.VAR_1[1];", "for (VAR_7 = 0; VAR_7 < s->height / 4; VAR_7++) {", "memcpy(VAR_6, VAR_5, s->cur_frame->uv_w);", "VAR_5 += s->cur_frame->uv_w;", "VAR_6 += s->frame.linesize[1];", "}", "VAR_5 = s->cur_frame->Vbuf;", "VAR_6 = s->frame.VAR_1[2];", "for (VAR_7 = 0; VAR_7 < s->height / 4; VAR_7++) {", "memcpy(VAR_6, VAR_5, s->cur_frame->uv_w);", "VAR_5 += s->cur_frame->uv_w;", "VAR_6 += s->frame.linesize[2];", "}", "}", "*VAR_2=sizeof(AVFrame);", "*(AVFrame*)VAR_1= s->frame;", "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 ]

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

[ "void FUNC_0(MpegEncContext *VAR_0){", "H261Context * h= (H261Context*)VAR_0;", "const int VAR_1 = VAR_0->VAR_1;", "const int VAR_2= VAR_0->VAR_2;", "uint8_t *dest_y = VAR_0->dest[0];", "uint8_t *dest_cb= VAR_0->dest[1];", "uint8_t *dest_cr= VAR_0->dest[2];", "if(!(IS_FIL (h->mtype)))\nreturn;", "VAR_0->dsp.h261_loop_filter(dest_y , VAR_1);", "VAR_0->dsp.h261_loop_filter(dest_y + 8, VAR_1);", "VAR_0->dsp.h261_loop_filter(dest_y + 8 * VAR_1 , VAR_1);", "VAR_0->dsp.h261_loop_filter(dest_y + 8 * VAR_1 + 8, VAR_1);", "VAR_0->dsp.h261_loop_filter(dest_cb, VAR_2);", "VAR_0->dsp.h261_loop_filter(dest_cr, VAR_2);", "}" ]

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

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

[ "static gboolean FUNC_0(void *opaque)\n{", "CompareState *s = opaque;", "colo_old_packet_check(s);", "return TRUE;", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "float64 FUNC_0(CPUSPARCState *env, float64 src)\n{", "float64 ret;", "clear_float_exceptions(env);", "ret = float64_sqrt(src, &env->fp_status);", "check_ieee_exceptions(env);", "return ret;", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, const char *VAR_1, mode_t VAR_2, dev_t VAR_3)\n{", "return mknod(rpath(VAR_0, VAR_1), VAR_2, VAR_3);", "}" ]

[ 0, 0, 0 ]

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

[ "int FUNC_0(CPUS390XState *VAR_0, uint64_t VAR_1, uint32_t VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "SubchDev *sch;", "SCHIB *schib;", "uint64_t addr;", "int VAR_7 = -ENODEV;", "int VAR_8;", "hwaddr len = sizeof(*schib);", "if (ioinst_disassemble_sch_ident(VAR_1, &VAR_6, &VAR_3, &VAR_4, &VAR_5)) {", "program_interrupt(VAR_0, PGM_OPERAND, 2);", "return -EIO;", "}", "trace_ioinst_sch_id(\"msch\", VAR_3, VAR_4, VAR_5);", "addr = decode_basedisp_s(VAR_0, VAR_2);", "if (addr & 3) {", "program_interrupt(VAR_0, PGM_SPECIFICATION, 2);", "return -EIO;", "}", "schib = s390_cpu_physical_memory_map(VAR_0, addr, &len, 0);", "if (!schib || len != sizeof(*schib)) {", "program_interrupt(VAR_0, PGM_ADDRESSING, 2);", "VAR_8 = -EIO;", "goto out;", "}", "if (!ioinst_schib_valid(schib)) {", "program_interrupt(VAR_0, PGM_OPERAND, 2);", "VAR_8 = -EIO;", "goto out;", "}", "sch = css_find_subch(VAR_6, VAR_3, VAR_4, VAR_5);", "if (sch && css_subch_visible(sch)) {", "VAR_7 = css_do_msch(sch, schib);", "}", "switch (VAR_7) {", "case -ENODEV:\nVAR_8 = 3;", "break;", "case -EBUSY:\nVAR_8 = 2;", "break;", "case 0:\nVAR_8 = 0;", "break;", "default:\nVAR_8 = 1;", "break;", "}", "out:\ns390_cpu_physical_memory_unmap(VAR_0, schib, len, 0);", "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 ]

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

[ "static void FUNC_0(void *VAR_0)\n{", "V9fsPDU *pdu = VAR_0;", "size_t offset = 7;", "V9fsString target;", "int32_t fid;", "int VAR_1 = 0;", "V9fsFidState *fidp;", "pdu_unmarshal(pdu, offset, \"d\", &fid);", "trace_v9fs_readlink(pdu->tag, pdu->id, fid);", "fidp = get_fid(pdu, fid);", "if (fidp == NULL) {", "VAR_1 = -ENOENT;", "goto out_nofid;", "}", "v9fs_string_init(&target);", "VAR_1 = v9fs_co_readlink(pdu, &fidp->path, &target);", "if (VAR_1 < 0) {", "goto out;", "}", "offset += pdu_marshal(pdu, offset, \"s\", &target);", "VAR_1 = offset;", "trace_v9fs_readlink_return(pdu->tag, pdu->id, target.data);", "v9fs_string_free(&target);", "out:\nput_fid(pdu, fidp);", "out_nofid:\ncomplete_pdu(pdu->s, pdu, 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 ]

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

[ "static void FUNC_0(PCIDevice *VAR_0, uint32_t VAR_1, uint32_t VAR_2,\nint VAR_3)\n{", "#ifdef TARGET_WORDS_BIGENDIAN\nVAR_2 = bswap32(VAR_2);", "#endif\npci_default_write_config(VAR_0, VAR_1, VAR_2, VAR_3);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "arm_mptimer_state *s = (arm_mptimer_state *)VAR_0;", "int VAR_4 = get_current_cpu(s);", "timerblock_write(&s->timerblock[VAR_4 * 2 + 1], VAR_1, VAR_2, VAR_3);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{", "RTCState *s = VAR_1;", "qemu_put_be32(VAR_0, s->irq_coalesced);", "qemu_put_be32(VAR_0, s->period);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(SCSIDevice *VAR_0, Error **VAR_1)\n{", "SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0);", "Error *err = NULL;", "if (!s->qdev.conf.bs) {", "error_setg(VAR_1, \"drive property not set\");", "return;", "}", "if (!(s->features & (1 << SCSI_DISK_F_REMOVABLE)) &&\n!bdrv_is_inserted(s->qdev.conf.bs)) {", "error_setg(VAR_1, \"Device needs media, but drive is empty\");", "return;", "}", "blkconf_serial(&s->qdev.conf, &s->serial);", "if (VAR_0->type == TYPE_DISK) {", "blkconf_geometry(&VAR_0->conf, NULL, 65535, 255, 255, &err);", "if (err) {", "error_propagate(VAR_1, err);", "return;", "}", "}", "if (s->qdev.conf.discard_granularity == -1) {", "s->qdev.conf.discard_granularity =\nMAX(s->qdev.conf.logical_block_size, DEFAULT_DISCARD_GRANULARITY);", "}", "if (!s->version) {", "s->version = g_strdup(qemu_get_version());", "}", "if (!s->vendor) {", "s->vendor = g_strdup(\"QEMU\");", "}", "if (bdrv_is_sg(s->qdev.conf.bs)) {", "error_setg(VAR_1, \"unwanted /VAR_0/sg*\");", "return;", "}", "if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) &&\n!(s->features & (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS))) {", "bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_disk_removable_block_ops, s);", "} else {", "bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_disk_block_ops, s);", "}", "bdrv_set_guest_block_size(s->qdev.conf.bs, s->qdev.blocksize);", "bdrv_iostatus_enable(s->qdev.conf.bs);", "}" ]

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

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

[ "static void FUNC_0(AHCIQState *VAR_0)\n{", "QOSState *qs = VAR_0->parent;", "ahci_clean_mem(VAR_0);", "free_ahci_device(VAR_0->dev);", "g_free(VAR_0);", "qtest_shutdown(qs);", "}" ]

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

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

[ "int FUNC_0(URLContext *VAR_0, const char *VAR_1)\n{", "UDPContext *s = VAR_0->priv_data;", "char VAR_2[256];", "int VAR_3;", "url_split(NULL, 0, VAR_2, sizeof(VAR_2), &VAR_3, NULL, 0, VAR_1);", "if (resolve_host(&s->dest_addr.sin_addr, VAR_2) < 0)\nreturn AVERROR_IO;", "s->dest_addr.sin_family = AF_INET;", "s->dest_addr.sin_port = htons(VAR_3);", "return 0;", "}" ]

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

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

[ "int FUNC_0(int VAR_0, void *VAR_1,\nvoid *VAR_2)\n{", "siginfo_t *info = VAR_1;", "#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\nucontext_t *uc = VAR_2;", "#else\nucontext_t *uc = VAR_2;", "#endif\nunsigned long VAR_3;", "int VAR_4;", "VAR_3 = IAR_sig(uc);", "VAR_4 = 0;", "#if 0\nif (DSISR_sig(uc) & 0x00800000) {", "VAR_4 = 1;", "}", "#else\nif (TRAP_sig(uc) != 0x400 && (DSISR_sig(uc) & 0x02000000)) {", "VAR_4 = 1;", "}", "#endif\nreturn handle_cpu_signal(VAR_3, (unsigned long)info->si_addr,\nVAR_4, &uc->uc_sigmask);", "}" ]

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

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

[ "static void FUNC_0(int VAR_0, Error *VAR_1, void *VAR_2)\n{", "socket_connect_data *c = VAR_2;", "NetSocketState *s;", "char *VAR_3 = NULL;", "Error *local_error = NULL;", "VAR_3 = socket_address_to_string(c->saddr, &local_error);", "if (VAR_3 == NULL) {", "error_report_err(local_error);", "closesocket(VAR_0);", "goto end;", "}", "s = net_socket_fd_init(c->peer, c->model, c->name, VAR_0, true);", "if (!s) {", "closesocket(VAR_0);", "goto end;", "}", "snprintf(s->nc.info_str, sizeof(s->nc.info_str),\n\"socket: connect to %s\", VAR_3);", "end:\ng_free(VAR_3);", "socket_connect_data_free(c);", "}" ]

[ 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 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41, 43 ], [ 47, 49 ], [ 51 ], [ 53 ] ]

[ "void VAR_0 op_decw_ECX(void)\n{", "ECX = (ECX & ~0xffff) | ((ECX - 1) & 0xffff);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(VncState *VAR_0)\n{", "const void *VAR_1;", "int VAR_2;", "VAR_2 = sasl_getprop(VAR_0->sasl.conn, SASL_USERNAME, &VAR_1);", "if (VAR_2 != SASL_OK) {", "VNC_DEBUG(\"cannot query SASL username on connection %d (%s)\\n\",\nVAR_2, sasl_errstring(VAR_2, NULL, NULL));", "return -1;", "}", "if (VAR_1 == NULL) {", "VNC_DEBUG(\"no client username was found\\n\");", "return -1;", "}", "VNC_DEBUG(\"SASL client username %s\\n\", (const char *)VAR_1);", "VAR_0->sasl.username = qemu_strdup((const char*)VAR_1);", "return 0;", "}" ]

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

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

[ "ssize_t FUNC_0(QIOChannel *ioc, struct nbd_request *request)\n{", "uint8_t buf[NBD_REQUEST_SIZE];", "ssize_t ret;", "TRACE(\"Sending request to server: \"\n\"{ .from = %\" PRIu64\", .len = %\" PRIu32 \", .handle = %\" PRIu64", "\", .type=%\" PRIu32 \" }\",", "request->from, request->len, request->handle, request->type);", "stl_be_p(buf, NBD_REQUEST_MAGIC);", "stl_be_p(buf + 4, request->type);", "stq_be_p(buf + 8, request->handle);", "stq_be_p(buf + 16, request->from);", "stl_be_p(buf + 24, request->len);", "ret = write_sync(ioc, buf, sizeof(buf));", "if (ret < 0) {", "return ret;", "}", "if (ret != sizeof(buf)) {", "LOG(\"writing to socket failed\");", "return -EINVAL;", "}", "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 ], [ 11, 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ] ]

[ "static void FUNC_0(JSONLexer *VAR_0, QString *VAR_1, JSONTokenType VAR_2, int VAR_3, int VAR_4)\n{", "JSONMessageParser *parser = container_of(VAR_0, JSONMessageParser, VAR_0);", "QDict *dict;", "if (VAR_2 == JSON_OPERATOR) {", "switch (qstring_get_str(VAR_1)[0]) {", "case '{':", "parser->brace_count++;", "break;", "case '}':", "parser->brace_count--;", "break;", "case '[':\nparser->bracket_count++;", "break;", "case ']':\nparser->bracket_count--;", "break;", "default:\nbreak;", "}", "}", "dict = qdict_new();", "qdict_put(dict, \"VAR_2\", qint_from_int(VAR_2));", "QINCREF(VAR_1);", "qdict_put(dict, \"VAR_1\", VAR_1);", "qdict_put(dict, \"VAR_3\", qint_from_int(VAR_3));", "qdict_put(dict, \"VAR_4\", qint_from_int(VAR_4));", "parser->token_size += VAR_1->length;", "qlist_append(parser->tokens, dict);", "if (VAR_2 == JSON_ERROR) {", "goto out_emit_bad;", "} else if (parser->brace_count < 0 ||", "parser->bracket_count < 0 ||\n(parser->brace_count == 0 &&\nparser->bracket_count == 0)) {", "goto out_emit;", "} else if (parser->token_size > MAX_TOKEN_SIZE ||", "parser->bracket_count > MAX_NESTING ||\nparser->brace_count > MAX_NESTING) {", "goto out_emit;", "}", "return;", "out_emit_bad:\nQDECREF(parser->tokens);", "parser->tokens = NULL;", "out_emit:\nparser->brace_count = 0;", "parser->bracket_count = 0;", "parser->emit(parser, parser->tokens);", "if (parser->tokens) {", "QDECREF(parser->tokens);", "}", "parser->tokens = qlist_new();", "parser->token_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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 97 ], [ 99 ], [ 103 ], [ 107, 115 ], [ 117 ], [ 119, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ] ]

[ "static bool FUNC_0(DisasContext *dc, uint32_t sr, TCGv_i32 v)\n{", "uint32_t id = sr - CCOMPARE;", "bool ret = false;", "if (id < dc->config->nccompare) {", "uint32_t int_bit = 1 << dc->config->timerint[id];", "TCGv_i32 tmp = tcg_const_i32(id);", "tcg_gen_mov_i32(cpu_SR[sr], v);", "tcg_gen_andi_i32(cpu_SR[INTSET], cpu_SR[INTSET], ~int_bit);", "if (dc->tb->cflags & CF_USE_ICOUNT) {", "gen_io_start();", "}", "gen_helper_update_ccompare(cpu_env, tmp);", "if (dc->tb->cflags & CF_USE_ICOUNT) {", "gen_io_end();", "gen_jumpi_check_loop_end(dc, 0);", "ret = true;", "}", "tcg_temp_free(tmp);", "}", "return ret;", "}" ]

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

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

[ "static void FUNC_0(VncState *VAR_0, void *VAR_1, int VAR_2)\n{", "uint8_t buf[4];", "if (VAR_0->depth == 4) {", "uint32_t *pixels = VAR_1;", "int VAR_5, VAR_5;", "VAR_5 = VAR_2 >> 2;", "for(VAR_5 = 0; VAR_5 < VAR_5; VAR_5++) {", "vnc_convert_pixel(VAR_0, buf, pixels[VAR_5]);", "vnc_write(VAR_0, buf, VAR_0->pix_bpp);", "}", "} else if (VAR_0->depth == 2) {", "uint16_t *pixels = VAR_1;", "int VAR_5, VAR_5;", "VAR_5 = VAR_2 >> 1;", "for(VAR_5 = 0; VAR_5 < VAR_5; VAR_5++) {", "vnc_convert_pixel(VAR_0, buf, pixels[VAR_5]);", "vnc_write(VAR_0, buf, VAR_0->pix_bpp);", "}", "} else if (VAR_0->depth == 1) {", "uint8_t *pixels = VAR_1;", "int VAR_5, VAR_5;", "VAR_5 = VAR_2;", "for(VAR_5 = 0; VAR_5 < VAR_5; VAR_5++) {", "vnc_convert_pixel(VAR_0, buf, pixels[VAR_5]);", "vnc_write(VAR_0, buf, VAR_0->pix_bpp);", "}", "} else {", "fprintf(stderr, \"FUNC_0: VncState color depth not supported\\VAR_5\");", "}", "}" ]

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

[ "static int FUNC_0(DCALbrDecoder *VAR_0, int VAR_1)\n{", "unsigned int VAR_2[DCA_LBR_CHANNELS_TOTAL];", "unsigned int VAR_3[DCA_LBR_CHANNELS_TOTAL];", "unsigned int VAR_4, VAR_5, VAR_6;", "int VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;", "int VAR_12 = av_ceil_log2(VAR_0->nchannels_total);", "for (VAR_7 = 0; VAR_7 < 1 << VAR_1; VAR_7 += VAR_4 ? 8 : 1) {", "VAR_8 = ((VAR_0->framenum << VAR_1) + VAR_7) & 31;", "VAR_0->tonal_bounds[VAR_1][VAR_8][0] = VAR_0->ntones;", "for (VAR_11 = 1;; VAR_11++) {", "if (get_bits_left(&VAR_0->gb) < 1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Tonal VAR_1 chunk too short\\n\");", "return -1;", "}", "VAR_4 = parse_vlc(&VAR_0->gb, &ff_dca_vlc_tnl_grp[VAR_1], 2);", "if (VAR_4 >= FF_ARRAY_ELEMS(ff_dca_fst_amp)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid tonal frequency VAR_4\\n\");", "return -1;", "}", "VAR_4 = get_bitsz(&VAR_0->gb, VAR_4 >> 2) + ff_dca_fst_amp[VAR_4];", "if (VAR_4 <= 1)\nbreak;", "VAR_11 += VAR_4 - 2;", "if (VAR_11 >> (5 - VAR_1) > VAR_0->nsubbands * 4 - 5) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid spectral line offset\\n\");", "return -1;", "}", "VAR_10 = get_bitsz(&VAR_0->gb, VAR_12);", "VAR_5 = parse_vlc(&VAR_0->gb, &ff_dca_vlc_tnl_scf, 2)\n+ VAR_0->tonal_scf[ff_dca_freq_to_sb[VAR_11 >> (7 - VAR_1)]]\n+ VAR_0->limited_range - 2;", "VAR_2[VAR_10] = VAR_5 < AMP_MAX ? VAR_5 : 0;", "VAR_3[VAR_10] = get_bits(&VAR_0->gb, 3);", "for (VAR_9 = 0; VAR_9 < VAR_0->nchannels_total; VAR_9++) {", "if (VAR_9 == VAR_10)\ncontinue;", "if (get_bits1(&VAR_0->gb)) {", "VAR_2[VAR_9] = VAR_2[VAR_10] - parse_vlc(&VAR_0->gb, &ff_dca_vlc_damp, 1);", "VAR_3[VAR_9] = VAR_3[VAR_10] - parse_vlc(&VAR_0->gb, &ff_dca_vlc_dph, 1);", "} else {", "VAR_2[VAR_9] = 0;", "VAR_3[VAR_9] = 0;", "}", "}", "if (VAR_2[VAR_10]) {", "DCALbrTone *t = &VAR_0->tones[VAR_0->ntones];", "VAR_0->ntones = (VAR_0->ntones + 1) & (DCA_LBR_TONES - 1);", "t->x_freq = VAR_11 >> (5 - VAR_1);", "t->f_delt = (VAR_11 & ((1 << (5 - VAR_1)) - 1)) << VAR_1;", "t->ph_rot = 256 - (t->x_freq & 1) * 128 - t->f_delt * 4;", "VAR_6 = ff_dca_ph0_shift[(t->x_freq & 3) * 2 + (VAR_11 & 1)]\n- ((t->ph_rot << (5 - VAR_1)) - t->ph_rot);", "for (VAR_9 = 0; VAR_9 < VAR_0->nchannels; VAR_9++) {", "t->VAR_2[VAR_9] = VAR_2[VAR_9] < AMP_MAX ? VAR_2[VAR_9] : 0;", "t->VAR_3[VAR_9] = 128 - VAR_3[VAR_9] * 32 + VAR_6;", "}", "}", "}", "VAR_0->tonal_bounds[VAR_1][VAR_8][1] = VAR_0->ntones;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 91 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 133, 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ] ]

[ "static uint64_t FUNC_0(void *opaque, hwaddr offset,\nunsigned size)\n{", "mv88w8618_eth_state *s = opaque;", "switch (offset) {", "case MP_ETH_SMIR:\nif (s->smir & MP_ETH_SMIR_OPCODE) {", "switch (s->smir & MP_ETH_SMIR_ADDR) {", "case MP_ETH_PHY1_BMSR:\nreturn MP_PHY_BMSR_LINK | MP_PHY_BMSR_AUTONEG |\nMP_ETH_SMIR_RDVALID;", "case MP_ETH_PHY1_PHYSID1:\nreturn (MP_PHY_88E3015 >> 16) | MP_ETH_SMIR_RDVALID;", "case MP_ETH_PHY1_PHYSID2:\nreturn (MP_PHY_88E3015 & 0xFFFF) | MP_ETH_SMIR_RDVALID;", "default:\nreturn MP_ETH_SMIR_RDVALID;", "}", "}", "return 0;", "case MP_ETH_ICR:\nreturn s->icr;", "case MP_ETH_IMR:\nreturn s->imr;", "case MP_ETH_FRDP0 ... MP_ETH_FRDP3:\nreturn s->frx_queue[(offset - MP_ETH_FRDP0)/4];", "case MP_ETH_CRDP0 ... MP_ETH_CRDP3:\nreturn s->rx_queue[(offset - MP_ETH_CRDP0)/4];", "case MP_ETH_CTDP0 ... MP_ETH_CTDP3:\nreturn s->tx_queue[(offset - MP_ETH_CTDP0)/4];", "default:\nreturn 0;", "}", "}" ]

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

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

[ "static int FUNC_0(int VAR_0, int VAR_1, int16_t *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "VAR_4 = VAR_2[VAR_1];", "VAR_3 = VAR_2[VAR_0] << 11;", "VAR_5 = VAR_4 + VAR_3;", "return (VAR_5 + (VAR_5 << 16)) << 1;", "}" ]

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

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

[ "static void FUNC_0(Monitor *VAR_0, const mon_cmd_t *VAR_1,\nconst QDict *VAR_2)\n{", "QObject *data = NULL;", "VAR_1->mhandler.cmd_new(VAR_0, VAR_2, &data);", "if (is_async_return(data)) {", "if (monitor_ctrl_mode(VAR_0) && monitor_has_error(VAR_0)) {", "monitor_protocol_emitter(VAR_0, NULL);", "}", "} else if (monitor_ctrl_mode(VAR_0)) {", "monitor_protocol_emitter(VAR_0, data);", "} else {", "if (data)\nVAR_1->user_print(VAR_0, data);", "}", "qobject_decref(data);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 15 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 41, 43 ], [ 45 ], [ 49 ], [ 51 ] ]

[ "static inline int64_t FUNC_0(BlockDriverState *bs, uint64_t offset,\nbool write)\n{", "BDRVVPCState *s = bs->opaque;", "uint64_t bitmap_offset, block_offset;", "uint32_t pagetable_index, offset_in_block;", "pagetable_index = offset / s->block_size;", "offset_in_block = offset % s->block_size;", "if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)\nreturn -1;", "bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];", "block_offset = bitmap_offset + s->bitmap_size + offset_in_block;", "if (write && (s->last_bitmap_offset != bitmap_offset)) {", "uint8_t bitmap[s->bitmap_size];", "s->last_bitmap_offset = bitmap_offset;", "memset(bitmap, 0xff, s->bitmap_size);", "bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);", "}", "return block_offset;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21, 23 ], [ 27 ], [ 29 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ] ]

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{", "OpenPICState *opp = VAR_0;", "int VAR_4;", "DPRINTF(\"%s: VAR_1 %08x <= %08x\\n\", __func__, VAR_1, VAR_2);", "if (VAR_1 & 0xF)\nreturn;", "VAR_4 = (VAR_1 >> 6) & 0x3;", "VAR_1 = VAR_1 & 0x30;", "if (VAR_1 == 0x0) {", "opp->tifr = VAR_2;", "return;", "}", "switch (VAR_1 & 0x30) {", "case 0x00:\nbreak;", "case 0x10:\nif ((opp->timers[VAR_4].ticc & TICC_TOG) != 0 &&\n(VAR_2 & TIBC_CI) == 0 &&\n(opp->timers[VAR_4].tibc & TIBC_CI) != 0) {", "opp->timers[VAR_4].ticc &= ~TICC_TOG;", "}", "opp->timers[VAR_4].tibc = VAR_2;", "break;", "case 0x20:\nwrite_IRQreg_ipvp(opp, opp->irq_tim0 + VAR_4, VAR_2);", "break;", "case 0x30:\nwrite_IRQreg_ide(opp, opp->irq_tim0 + VAR_4, VAR_2);", "break;", "}", "}" ]

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

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

[ "int FUNC_0(const char *VAR_0, Error **VAR_1)\n{", "BlockDriverState *bs, *bs_vm_state;", "QEMUSnapshotInfo sn;", "QEMUFile *f;", "int VAR_2;", "AioContext *aio_context;", "MigrationIncomingState *mis = migration_incoming_get_current();", "if (!bdrv_all_can_snapshot(&bs)) {", "error_setg(VAR_1,\n\"Device '%s' is writable but does not support snapshots\",\nbdrv_get_device_name(bs));", "return -ENOTSUP;", "}", "VAR_2 = bdrv_all_find_snapshot(VAR_0, &bs);", "if (VAR_2 < 0) {", "error_setg(VAR_1,\n\"Device '%s' does not have the requested snapshot '%s'\",\nbdrv_get_device_name(bs), VAR_0);", "return VAR_2;", "}", "bs_vm_state = bdrv_all_find_vmstate_bs();", "if (!bs_vm_state) {", "error_setg(VAR_1, \"No block device supports snapshots\");", "return -ENOTSUP;", "}", "aio_context = bdrv_get_aio_context(bs_vm_state);", "aio_context_acquire(aio_context);", "VAR_2 = bdrv_snapshot_find(bs_vm_state, &sn, VAR_0);", "aio_context_release(aio_context);", "if (VAR_2 < 0) {", "return VAR_2;", "} else if (sn.vm_state_size == 0) {", "error_setg(VAR_1, \"This is a disk-only snapshot. Revert to it \"\n\" offline using qemu-img\");", "return -EINVAL;", "}", "bdrv_drain_all();", "VAR_2 = bdrv_all_goto_snapshot(VAR_0, &bs);", "if (VAR_2 < 0) {", "error_setg(VAR_1, \"Error %d while activating snapshot '%s' on '%s'\",\nVAR_2, VAR_0, bdrv_get_device_name(bs));", "return VAR_2;", "}", "f = qemu_fopen_bdrv(bs_vm_state, 0);", "if (!f) {", "error_setg(VAR_1, \"Could not open VM state file\");", "return -EINVAL;", "}", "qemu_system_reset(VMRESET_SILENT);", "mis->from_src_file = f;", "aio_context_acquire(aio_context);", "VAR_2 = qemu_loadvm_state(f);", "qemu_fclose(f);", "aio_context_release(aio_context);", "migration_incoming_state_destroy();", "if (VAR_2 < 0) {", "error_setg(VAR_1, \"Error %d while loading VM state\", VAR_2);", "return VAR_2;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37, 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 87 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ] ]

[ "CharDriverState *FUNC_0(QemuOpts *opts,\nvoid (*init)(struct CharDriverState *s),\nError **errp)\n{", "CharDriver *cd;", "CharDriverState *chr;", "GSList *i;", "if (qemu_opts_id(opts) == NULL) {", "error_setg(errp, \"chardev: no VAR_0 specified\");", "goto err;", "}", "if (qemu_opt_get(opts, \"backend\") == NULL) {", "error_setg(errp, \"chardev: \\\"%s\\\" missing backend\",\nqemu_opts_id(opts));", "goto err;", "}", "for (i = backends; i; i = i->next) {", "cd = i->data;", "if (strcmp(cd->name, qemu_opt_get(opts, \"backend\")) == 0) {", "break;", "}", "}", "if (i == NULL) {", "error_setg(errp, \"chardev: backend \\\"%s\\\" not found\",\nqemu_opt_get(opts, \"backend\"));", "goto err;", "}", "if (!cd->open) {", "ChardevBackend *backend = g_new0(ChardevBackend, 1);", "ChardevReturn *ret = NULL;", "const char *VAR_0 = qemu_opts_id(opts);", "const char *VAR_1 = NULL;", "if (qemu_opt_get_bool(opts, \"mux\", 0)) {", "VAR_1 = g_strdup_printf(\"%s-base\", VAR_0);", "}", "chr = NULL;", "backend->kind = cd->kind;", "if (cd->parse) {", "cd->parse(opts, backend, errp);", "if (error_is_set(errp)) {", "goto qapi_out;", "}", "}", "ret = qmp_chardev_add(VAR_1 ? VAR_1 : VAR_0, backend, errp);", "if (error_is_set(errp)) {", "goto qapi_out;", "}", "if (VAR_1) {", "qapi_free_ChardevBackend(backend);", "qapi_free_ChardevReturn(ret);", "backend = g_new0(ChardevBackend, 1);", "backend->mux = g_new0(ChardevMux, 1);", "backend->kind = CHARDEV_BACKEND_KIND_MUX;", "backend->mux->chardev = g_strdup(VAR_1);", "ret = qmp_chardev_add(VAR_0, backend, errp);", "if (error_is_set(errp)) {", "goto qapi_out;", "}", "}", "chr = qemu_chr_find(VAR_0);", "qapi_out:\nqapi_free_ChardevBackend(backend);", "qapi_free_ChardevReturn(ret);", "return chr;", "}", "chr = cd->open(opts);", "if (!chr) {", "error_setg(errp, \"chardev: opening backend \\\"%s\\\" failed\",\nqemu_opt_get(opts, \"backend\"));", "goto err;", "}", "if (!chr->filename)\nchr->filename = g_strdup(qemu_opt_get(opts, \"backend\"));", "chr->init = init;", "if (!chr->explicit_be_open) {", "qemu_chr_be_event(chr, CHR_EVENT_OPENED);", "}", "QTAILQ_INSERT_TAIL(&chardevs, chr, next);", "if (qemu_opt_get_bool(opts, \"mux\", 0)) {", "CharDriverState *base = chr;", "int VAR_2 = strlen(qemu_opts_id(opts)) + 6;", "base->label = g_malloc(VAR_2);", "snprintf(base->label, VAR_2, \"%s-base\", qemu_opts_id(opts));", "chr = qemu_chr_open_mux(base);", "chr->filename = base->filename;", "chr->avail_connections = MAX_MUX;", "QTAILQ_INSERT_TAIL(&chardevs, chr, next);", "} else {", "chr->avail_connections = 1;", "}", "chr->label = g_strdup(qemu_opts_id(opts));", "chr->opts = opts;", "return chr;", "err:\nqemu_opts_del(opts);", "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, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157, 159 ], [ 161 ], [ 163 ], [ 167, 169 ], [ 171 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 221, 223 ], [ 225 ], [ 227 ] ]

[ "void FUNC_0(MpegEncContext * VAR_0,\nint VAR_1, int VAR_2)\n{", "MotionEstContext * const c= &VAR_0->me;", "uint8_t *pix, *ppix;", "int VAR_3, VAR_4, VAR_5, VAR_6;", "int VAR_7;", "int VAR_8;", "int VAR_9[10][2];", "const int VAR_10= 1+VAR_0->quarter_sample;", "int VAR_11=0;", "Picture * const pic= &VAR_0->current_picture;", "init_ref(c, VAR_0->new_picture.f.data, VAR_0->last_picture.f.data, NULL, 16*VAR_1, 16*VAR_2, 0);", "assert(VAR_0->quarter_sample==0 || VAR_0->quarter_sample==1);", "assert(VAR_0->linesize == c->stride);", "assert(VAR_0->uvlinesize == c->uvstride);", "c->penalty_factor = get_penalty_factor(VAR_0->lambda, VAR_0->lambda2, c->avctx->me_cmp);", "c->sub_penalty_factor= get_penalty_factor(VAR_0->lambda, VAR_0->lambda2, c->avctx->me_sub_cmp);", "c->mb_penalty_factor = get_penalty_factor(VAR_0->lambda, VAR_0->lambda2, c->avctx->mb_cmp);", "c->current_mv_penalty= c->mv_penalty[VAR_0->f_code] + MAX_MV;", "get_limits(VAR_0, 16*VAR_1, 16*VAR_2);", "c->skip=0;", "pix = c->src[0][0];", "VAR_3 = VAR_0->dsp.pix_sum(pix, VAR_0->linesize);", "VAR_7 = VAR_0->dsp.pix_norm1(pix, VAR_0->linesize) - (((unsigned)(VAR_3*VAR_3))>>8) + 500;", "pic->mb_mean[VAR_0->mb_stride * VAR_2 + VAR_1] = (VAR_3+128)>>8;", "pic->mb_var [VAR_0->mb_stride * VAR_2 + VAR_1] = (VAR_7+128)>>8;", "c->mb_var_sum_temp += (VAR_7+128)>>8;", "if(c->avctx->me_threshold){", "VAR_8= check_input_motion(VAR_0, VAR_1, VAR_2, 1);", "if((VAR_8+128)>>8 < c->avctx->me_threshold){", "int VAR_21= FFMIN(VAR_8, VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*100);", "int VAR_21= VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*20;", "pic->mc_mb_var[VAR_0->mb_stride * VAR_2 + VAR_1] = (VAR_8+128)>>8;", "c->mc_mb_var_sum_temp += (VAR_8+128)>>8;", "c->scene_change_score+= ff_sqrt(VAR_21) - ff_sqrt(VAR_21);", "return;", "}", "if((VAR_8+128)>>8 < c->avctx->mb_threshold)\nVAR_11= VAR_0->VAR_11[VAR_1 + VAR_2*VAR_0->mb_stride];", "}", "switch(VAR_0->me_method) {", "case ME_ZERO:\ndefault:\nno_motion_search(VAR_0, &VAR_4, &VAR_5);", "VAR_4-= VAR_1*16;", "VAR_5-= VAR_2*16;", "VAR_6 = 0;", "break;", "case ME_X1:\ncase ME_EPZS:\n{", "const int VAR_14 = VAR_0->b8_stride;", "const int VAR_15 = VAR_0->block_index[0];", "P_LEFT[0] = VAR_0->current_picture.f.motion_val[0][VAR_15 - 1][0];", "P_LEFT[1] = VAR_0->current_picture.f.motion_val[0][VAR_15 - 1][1];", "if(P_LEFT[0] > (c->xmax<<VAR_10)) P_LEFT[0] = (c->xmax<<VAR_10);", "if(!VAR_0->first_slice_line) {", "P_TOP[0] = VAR_0->current_picture.f.motion_val[0][VAR_15 - VAR_14 ][0];", "P_TOP[1] = VAR_0->current_picture.f.motion_val[0][VAR_15 - VAR_14 ][1];", "P_TOPRIGHT[0] = VAR_0->current_picture.f.motion_val[0][VAR_15 - VAR_14 + 2][0];", "P_TOPRIGHT[1] = VAR_0->current_picture.f.motion_val[0][VAR_15 - VAR_14 + 2][1];", "if(P_TOP[1] > (c->ymax<<VAR_10)) P_TOP[1] = (c->ymax<<VAR_10);", "if(P_TOPRIGHT[0] < (c->xmin<<VAR_10)) P_TOPRIGHT[0]= (c->xmin<<VAR_10);", "if(P_TOPRIGHT[1] > (c->ymax<<VAR_10)) P_TOPRIGHT[1]= (c->ymax<<VAR_10);", "P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);", "P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);", "if(VAR_0->out_format == FMT_H263){", "c->pred_x = P_MEDIAN[0];", "c->pred_y = P_MEDIAN[1];", "}else {", "c->pred_x= P_LEFT[0];", "c->pred_y= P_LEFT[1];", "}", "}else{", "c->pred_x= P_LEFT[0];", "c->pred_y= P_LEFT[1];", "}", "}", "VAR_6 = ff_epzs_motion_search(VAR_0, &VAR_4, &VAR_5, VAR_9, 0, 0, VAR_0->p_mv_table, (1<<16)>>VAR_10, 0, 16);", "break;", "}", "ppix = c->ref[0][0] + (VAR_5 * VAR_0->linesize) + VAR_4;", "VAR_8 = VAR_0->dsp.sse[0](NULL, pix, ppix, VAR_0->linesize, 16);", "pic->mc_mb_var[VAR_0->mb_stride * VAR_2 + VAR_1] = (VAR_8+128)>>8;", "c->mc_mb_var_sum_temp += (VAR_8+128)>>8;", "if(VAR_11){", "int VAR_21= FFMIN(VAR_8, VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*100);", "int VAR_21= VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*20;", "c->scene_change_score+= ff_sqrt(VAR_21) - ff_sqrt(VAR_21);", "if(VAR_11 == CANDIDATE_MB_TYPE_INTER){", "c->sub_motion_search(VAR_0, &VAR_4, &VAR_5, VAR_6, 0, 0, 0, 16);", "set_p_mv_tables(VAR_0, VAR_4, VAR_5, 1);", "}else{", "VAR_4 <<=VAR_10;", "VAR_5 <<=VAR_10;", "}", "if(VAR_11 == CANDIDATE_MB_TYPE_INTER4V){", "h263_mv4_search(VAR_0, VAR_4, VAR_5, VAR_10);", "set_p_mv_tables(VAR_0, VAR_4, VAR_5, 0);", "}", "if(VAR_11 == CANDIDATE_MB_TYPE_INTER_I){", "interlaced_search(VAR_0, 0, VAR_0->p_field_mv_table, VAR_0->p_field_select_table, VAR_4, VAR_5, 1);", "}", "}else if(c->avctx->mb_decision > FF_MB_DECISION_SIMPLE){", "int VAR_21= FFMIN(VAR_8, VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*100);", "int VAR_21= VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*20;", "c->scene_change_score+= ff_sqrt(VAR_21) - ff_sqrt(VAR_21);", "if (VAR_8*2 + 200*256 > VAR_7)\nVAR_11|= CANDIDATE_MB_TYPE_INTRA;", "if (VAR_7*2 + 200*256 > VAR_8 || VAR_0->qscale > 24){", "VAR_11|= CANDIDATE_MB_TYPE_INTER;", "c->sub_motion_search(VAR_0, &VAR_4, &VAR_5, VAR_6, 0, 0, 0, 16);", "if(VAR_0->flags&CODEC_FLAG_MV0)\nif(VAR_4 || VAR_5)\nVAR_11 |= CANDIDATE_MB_TYPE_SKIPPED;", "}else{", "VAR_4 <<=VAR_10;", "VAR_5 <<=VAR_10;", "}", "if((VAR_0->flags&CODEC_FLAG_4MV)\n&& !c->skip && VAR_7>50<<8 && VAR_8>10<<8){", "if(h263_mv4_search(VAR_0, VAR_4, VAR_5, VAR_10) < INT_MAX)\nVAR_11|=CANDIDATE_MB_TYPE_INTER4V;", "set_p_mv_tables(VAR_0, VAR_4, VAR_5, 0);", "}else", "set_p_mv_tables(VAR_0, VAR_4, VAR_5, 1);", "if((VAR_0->flags&CODEC_FLAG_INTERLACED_ME)\n&& !c->skip){", "if(interlaced_search(VAR_0, 0, VAR_0->p_field_mv_table, VAR_0->p_field_select_table, VAR_4, VAR_5, 0) < INT_MAX)\nVAR_11 |= CANDIDATE_MB_TYPE_INTER_I;", "}", "}else{", "int VAR_16, VAR_17;", "VAR_11= CANDIDATE_MB_TYPE_INTER;", "VAR_6= c->sub_motion_search(VAR_0, &VAR_4, &VAR_5, VAR_6, 0, 0, 0, 16);", "if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip)\nVAR_6= ff_get_mb_score(VAR_0, VAR_4, VAR_5, 0, 0, 0, 16, 1);", "if((VAR_0->flags&CODEC_FLAG_4MV)\n&& !c->skip && VAR_7>50<<8 && VAR_8>10<<8){", "int VAR_18= h263_mv4_search(VAR_0, VAR_4, VAR_5, VAR_10);", "if(VAR_18 < VAR_6){", "VAR_11= CANDIDATE_MB_TYPE_INTER4V;", "VAR_6=VAR_18;", "}", "}", "if((VAR_0->flags&CODEC_FLAG_INTERLACED_ME)\n&& !c->skip){", "int VAR_19= interlaced_search(VAR_0, 0, VAR_0->p_field_mv_table, VAR_0->p_field_select_table, VAR_4, VAR_5, 0);", "if(VAR_19 < VAR_6){", "VAR_11 = CANDIDATE_MB_TYPE_INTER_I;", "VAR_6= VAR_19;", "}", "}", "set_p_mv_tables(VAR_0, VAR_4, VAR_5, VAR_11!=CANDIDATE_MB_TYPE_INTER4V);", "if((c->avctx->mb_cmp&0xFF)==FF_CMP_SSE){", "VAR_16= VAR_7 - 500;", "}else{", "int VAR_20= (VAR_3+128)>>8;", "VAR_20*= 0x01010101;", "for(VAR_17=0; VAR_17<16; VAR_17++){", "*(uint32_t*)(&c->scratchpad[VAR_17*VAR_0->linesize+ 0]) = VAR_20;", "*(uint32_t*)(&c->scratchpad[VAR_17*VAR_0->linesize+ 4]) = VAR_20;", "*(uint32_t*)(&c->scratchpad[VAR_17*VAR_0->linesize+ 8]) = VAR_20;", "*(uint32_t*)(&c->scratchpad[VAR_17*VAR_0->linesize+12]) = VAR_20;", "}", "VAR_16= VAR_0->dsp.mb_cmp[0](VAR_0, c->scratchpad, pix, VAR_0->linesize, 16);", "}", "VAR_16 += c->mb_penalty_factor*16;", "if(VAR_16 < VAR_6){", "VAR_11= CANDIDATE_MB_TYPE_INTRA;", "VAR_0->current_picture.f.VAR_11[VAR_2*VAR_0->mb_stride + VAR_1] = CANDIDATE_MB_TYPE_INTRA;", "}else", "VAR_0->current_picture.f.VAR_11[VAR_2*VAR_0->mb_stride + VAR_1] = 0;", "{", "int VAR_21= FFMIN(VAR_8, VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*100);", "int VAR_21= VAR_7-500+(VAR_0->lambda2>>FF_LAMBDA_SHIFT)*20;", "c->scene_change_score+= ff_sqrt(VAR_21) - ff_sqrt(VAR_21);", "}", "}", "VAR_0->VAR_11[VAR_2*VAR_0->mb_stride + VAR_1]= VAR_11;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 103 ], [ 105, 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119, 121, 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 203 ], [ 207 ], [ 211 ], [ 215 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 269, 271 ], [ 273 ], [ 277 ], [ 279 ], [ 281, 283, 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295, 297 ], [ 299, 301 ], [ 305 ], [ 307 ], [ 309 ], [ 311, 313 ], [ 315, 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 329 ], [ 331, 333 ], [ 337, 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353, 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 373 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 405 ], [ 407 ], [ 409 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 439 ], [ 441 ] ]

[ "static int FUNC_0(BDRVVVFATState* VAR_0,const char* VAR_1)\n{", "bootsector_t* bootsector=(bootsector_t*)&(VAR_0->first_sectors[(VAR_0->first_sectors_number-1)*0x200]);", "unsigned int VAR_2;", "unsigned int VAR_3;", "memset(&(VAR_0->first_sectors[0]),0,0x40*0x200);", "VAR_0->sectors_per_fat=0xfc;", "VAR_0->sectors_per_cluster=0x10;", "VAR_0->cluster_size=VAR_0->sectors_per_cluster*0x200;", "VAR_0->VAR_3=malloc(VAR_0->cluster_size);", "array_init(&(VAR_0->mapping),sizeof(mapping_t));", "array_init(&(VAR_0->directory),sizeof(direntry_t));", "array_init(&(VAR_0->commit),sizeof(commit_t));", "{", "direntry_t* entry=array_get_next(&(VAR_0->directory));", "entry->attributes=0x28;", "snprintf(entry->name,11,\"QEMU VVFAT\");", "}", "if(read_directory(VAR_0,VAR_1,0))\nreturn -1;", "VAR_0->sectors_for_directory=VAR_0->directory.next/0x10;", "VAR_0->faked_sectors=VAR_0->first_sectors_number+VAR_0->sectors_per_fat*2+VAR_0->sectors_for_directory;", "VAR_0->cluster_count=(VAR_0->sector_count-VAR_0->faked_sectors)/VAR_0->sectors_per_cluster;", "init_fat(VAR_0);", "VAR_3=VAR_0->sectors_for_directory/VAR_0->sectors_per_cluster;", "assert(VAR_0->sectors_for_directory%VAR_0->sectors_per_cluster==0);", "if(VAR_0->first_file_mapping>0) {", "mapping_t* mapping=array_get(&(VAR_0->mapping),VAR_0->first_file_mapping-1);", "mapping->end=VAR_3;", "}", "for(VAR_2=1;VAR_2<VAR_0->mapping.next;VAR_2++) {", "mapping_t* mapping=array_get(&(VAR_0->mapping),VAR_2);", "direntry_t* direntry=array_get(&(VAR_0->directory),mapping->dir_index);", "if(mapping->mode==MODE_DIRECTORY) {", "int VAR_2;", "#ifdef DEBUG\nfprintf(stderr,\"assert: %VAR_0 %d < %d\\n\",mapping->filename,(int)mapping->begin,(int)mapping->end);", "#endif\nassert(mapping->begin<mapping->end);", "for(VAR_2=mapping->begin;VAR_2<mapping->end-1;VAR_2++)", "fat_set(VAR_0,VAR_2,VAR_2+1);", "fat_set(VAR_0,VAR_2,0x7fffffff);", "} else {", "unsigned int end_cluster=VAR_3+mapping->end/VAR_0->cluster_size;", "if(end_cluster>=VAR_0->cluster_count) {", "fprintf(stderr,\"Directory does not fit in FAT%d\\n\",VAR_0->fat_type);", "return -1;", "}", "mapping->begin=VAR_3;", "mapping->mode=MODE_NORMAL;", "mapping->offset=0;", "direntry->size=cpu_to_le32(mapping->end);", "if(direntry->size==0) {", "direntry->begin=0;", "mapping->end=VAR_3;", "continue;", "}", "direntry->begin=cpu_to_le16(VAR_3);", "mapping->end=end_cluster+1;", "for(;VAR_3<end_cluster;VAR_3++)", "fat_set(VAR_0,VAR_3,VAR_3+1);", "fat_set(VAR_0,VAR_3,0x7fffffff);", "VAR_3++;", "}", "}", "VAR_0->current_mapping=0;", "bootsector->jump[0]=0xeb;", "bootsector->jump[1]=0x3e;", "bootsector->jump[2]=0x90;", "memcpy(bootsector->name,\"QEMU \",8);", "bootsector->sector_size=cpu_to_le16(0x200);", "bootsector->sectors_per_cluster=VAR_0->sectors_per_cluster;", "bootsector->reserved_sectors=cpu_to_le16(1);", "bootsector->number_of_fats=0x2;", "bootsector->root_entries=cpu_to_le16(VAR_0->sectors_of_root_directory*0x10);", "bootsector->zero=0;", "bootsector->media_type=(VAR_0->first_sectors_number==1?0xf0:0xf8);", "bootsector->sectors_per_fat=cpu_to_le16(VAR_0->sectors_per_fat);", "bootsector->sectors_per_track=cpu_to_le16(0x3f);", "bootsector->number_of_heads=cpu_to_le16(0x10);", "bootsector->hidden_sectors=cpu_to_le32(VAR_0->first_sectors_number==1?0:0x3f);", "bootsector->total_sectors=cpu_to_le32(VAR_0->sector_count);", "bootsector->u.fat16.drive_number=0x80;", "bootsector->u.fat16.current_head=0;", "bootsector->u.fat16.signature=0x29;", "bootsector->u.fat16.id=cpu_to_le32(0xfabe1afd);", "memcpy(bootsector->u.fat16.volume_label,\"QEMU VVFAT \",11);", "memcpy(bootsector->fat_type,(VAR_0->fat_type==12?\"FAT12 \":VAR_0->fat_type==16?\"FAT16 \":\"FAT32 \"),8);", "bootsector->magic[0]=0x55; bootsector->magic[1]=0xaa;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51, 53 ], [ 59 ], [ 63 ], [ 65 ], [ 71 ], [ 75 ], [ 77 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105, 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 209 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 225 ], [ 227 ], [ 229 ], [ 233 ], [ 235 ] ]

[ "static void FUNC_0( H264Context *VAR_0, uint8_t *VAR_1, int VAR_2, int16_t VAR_3[8], int VAR_4[2] ) {", "int VAR_5;", "for( VAR_5 = 0; VAR_5 < 8; VAR_5++, VAR_1 += VAR_2) {", "int VAR_6;", "int VAR_7;", "int VAR_8;", "int VAR_9;", "int VAR_10 = VAR_5;", "if( VAR_3[VAR_10] == 0 ) {", "continue;", "}", "VAR_9 = MB_FIELD ? (VAR_5 >> 2) : (VAR_5 & 1);", "VAR_6 = VAR_4[VAR_9] + VAR_0->slice_alpha_c0_offset;", "VAR_7 = (alpha_table+52)[VAR_6];", "VAR_8 = (beta_table+52)[VAR_4[VAR_9] + VAR_0->slice_beta_offset];", "if( VAR_3[VAR_10] < 4 ) {", "const int VAR_11 = (tc0_table+52)[VAR_6][VAR_3[VAR_10]] + 1;", "const int VAR_17 = VAR_1[-1];", "const int VAR_17 = VAR_1[-2];", "const int VAR_17 = VAR_1[0];", "const int VAR_17 = VAR_1[1];", "if( FFABS( VAR_17 - VAR_17 ) < VAR_7 &&\nFFABS( VAR_17 - VAR_17 ) < VAR_8 &&\nFFABS( VAR_17 - VAR_17 ) < VAR_8 ) {", "const int VAR_16 = av_clip( (((VAR_17 - VAR_17 ) << 2) + (VAR_17 - VAR_17) + 4) >> 3, -VAR_11, VAR_11 );", "VAR_1[-1] = av_clip_uint8( VAR_17 + VAR_16 );", "VAR_1[0] = av_clip_uint8( VAR_17 - VAR_16 );", "tprintf(VAR_0->s.avctx, \"FUNC_0 VAR_5:%d, VAR_4:%d, indexA:%d, VAR_7:%d, VAR_8:%d, VAR_11:%d\\n# VAR_3:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\\n\", VAR_5, VAR_4[VAR_9], VAR_6, VAR_7, VAR_8, VAR_11, VAR_3[VAR_10], VAR_1[-3], VAR_17, VAR_17, VAR_17, VAR_17, VAR_1[2], VAR_17, VAR_1[-1], VAR_1[0], VAR_17);", "}", "}else{", "const int VAR_17 = VAR_1[-1];", "const int VAR_17 = VAR_1[-2];", "const int VAR_17 = VAR_1[0];", "const int VAR_17 = VAR_1[1];", "if( FFABS( VAR_17 - VAR_17 ) < VAR_7 &&\nFFABS( VAR_17 - VAR_17 ) < VAR_8 &&\nFFABS( VAR_17 - VAR_17 ) < VAR_8 ) {", "VAR_1[-1] = ( 2*VAR_17 + VAR_17 + VAR_17 + 2 ) >> 2;", "VAR_1[0] = ( 2*VAR_17 + VAR_17 + VAR_17 + 2 ) >> 2;", "tprintf(VAR_0->s.avctx, \"FUNC_0 VAR_5:%d\\n# VAR_3:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\\n\", VAR_5, VAR_1[-3], VAR_17, VAR_17, VAR_17, VAR_17, VAR_1[2], VAR_1[-3], VAR_1[-2], VAR_1[-1], VAR_1[0], VAR_1[1], VAR_1[2]);", "}", "}", "}", "}" ]

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

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

[ "int FUNC_0(AVFormatContext *VAR_0, int VAR_1, int64_t VAR_2, int VAR_3)\n{", "int VAR_4;", "AVStream *st;", "ff_read_frame_flush(VAR_0);", "if(VAR_3 & AVSEEK_FLAG_BYTE)\nreturn seek_frame_byte(VAR_0, VAR_1, VAR_2, VAR_3);", "if(VAR_1 < 0){", "VAR_1= av_find_default_stream_index(VAR_0);", "if(VAR_1 < 0)\nreturn -1;", "st= VAR_0->streams[VAR_1];", "VAR_2 = av_rescale(VAR_2, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);", "}", "if (VAR_0->iformat->read_seek)\nVAR_4 = VAR_0->iformat->read_seek(VAR_0, VAR_1, VAR_2, VAR_3);", "else\nVAR_4 = -1;", "if (VAR_4 >= 0) {", "return 0;", "}", "if(VAR_0->iformat->read_timestamp && !(VAR_0->iformat->VAR_3 & AVFMT_NOBINSEARCH))\nreturn av_seek_frame_binary(VAR_0, VAR_1, VAR_2, VAR_3);", "else if (!(VAR_0->iformat->VAR_3 & AVFMT_NOGENSEARCH))\nreturn seek_frame_generic(VAR_0, VAR_1, VAR_2, VAR_3);", "else\nreturn -1;", "}" ]

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

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

[ "static const char *FUNC_0(AVCodecContext *VAR_0, char *VAR_1, char *VAR_2,\nconst char *VAR_3, int VAR_4, int VAR_5, int VAR_6, int VAR_7)\n{", "char VAR_8, *VAR_9, VAR_10[128], VAR_11[128];", "int VAR_12, VAR_13, VAR_14 = 1, VAR_15 = 1, VAR_16 = 0, VAR_17 = 0;", "SrtStack stack[16];", "stack[0].tag[0] = 0;", "strcpy(stack[0].VAR_9[PARAM_SIZE], \"{\\\\fs}\");", "strcpy(stack[0].VAR_9[PARAM_COLOR], \"{\\\\VAR_8}\");", "strcpy(stack[0].VAR_9[PARAM_FACE], \"{\\\\fn}\");", "if (VAR_4 >= 0 && VAR_5 >= 0) {", "if (VAR_6 >= 0 && VAR_7 >= 0 && (VAR_6 != VAR_4 || VAR_7 != VAR_5))\nVAR_1 += snprintf(VAR_1, VAR_2-VAR_1,\n\"{\\\\an1}{\\\\move(%d,%d,%d,%d)}\", VAR_4, VAR_5, VAR_6, VAR_7);", "else\nVAR_1 += snprintf(VAR_1, VAR_2-VAR_1, \"{\\\\an1}{\\\\pos(%d,%d)}\", VAR_4, VAR_5);", "}", "for (; VAR_1 < VAR_2 && !VAR_17 && *VAR_3; VAR_3++) {", "switch (*VAR_3) {", "case '\\r':\nbreak;", "case '\\n':\nif (VAR_15) {", "VAR_17 = 1;", "break;", "}", "while (VAR_1[-1] == ' ')\nVAR_1--;", "VAR_1 += snprintf(VAR_1, VAR_2-VAR_1, \"\\\\N\");", "VAR_15 = 1;", "break;", "case ' ':\nif (!VAR_15)\n*VAR_1++ = *VAR_3;", "break;", "case '{':", "VAR_16 += sscanf(VAR_3, \"{\\\\VAR_16%*1u}%VAR_8\", &VAR_8) == 1;", "if ((VAR_16 != 1 && sscanf(VAR_3, \"{\\\\%*[^}]}%n%VAR_8\", &VAR_12, &VAR_8) > 0) ||", "sscanf(VAR_3, \"{%*1[CcFfoPSsYy]:%*[^}]}%n%VAR_8\", &VAR_12, &VAR_8) > 0) {", "VAR_3 += VAR_12 - 1;", "} else", "*VAR_1++ = *VAR_3;", "break;", "case '<':\nVAR_13 = VAR_3[1] == '/';", "if (sscanf(VAR_3+VAR_13+1, \"%127[^>]>%n%VAR_8\", VAR_10, &VAR_12,&VAR_8) >= 2) {", "if ((VAR_9 = strchr(VAR_10, ' ')))\n*VAR_9++ = 0;", "if ((!VAR_13 && VAR_14 < FF_ARRAY_ELEMS(stack)) ||\n( VAR_13 && VAR_14 > 0 && !strcmp(stack[VAR_14-1].tag, VAR_10))) {", "int VAR_18, VAR_19, VAR_20 = 0;", "VAR_3 += VAR_12 + VAR_13;", "if (!VAR_13)\nmemset(stack+VAR_14, 0, sizeof(*stack));", "if (!strcmp(VAR_10, \"font\")) {", "if (VAR_13) {", "for (VAR_18=PARAM_NUMBER-1; VAR_18>=0; VAR_18--)", "if (stack[VAR_14-1].VAR_9[VAR_18][0])\nfor (VAR_19=VAR_14-2; VAR_19>=0; VAR_19--)", "if (stack[VAR_19].VAR_9[VAR_18][0]) {", "VAR_1 += snprintf(VAR_1, VAR_2-VAR_1,\n\"%s\", stack[VAR_19].VAR_9[VAR_18]);", "break;", "}", "} else {", "while (VAR_9) {", "if (!strncmp(VAR_9, \"size=\", 5)) {", "unsigned VAR_21;", "VAR_9 += 5 + (VAR_9[5] == '\"');", "if (sscanf(VAR_9, \"%u\", &VAR_21) == 1) {", "snprintf(stack[VAR_14].VAR_9[PARAM_SIZE],\nsizeof(stack[0].VAR_9[PARAM_SIZE]),\n\"{\\\\fs%u}\", VAR_21);", "}", "} else if (!strncmp(VAR_9, \"color=\", 6)) {", "VAR_9 += 6 + (VAR_9[6] == '\"');", "snprintf(stack[VAR_14].VAR_9[PARAM_COLOR],\nsizeof(stack[0].VAR_9[PARAM_COLOR]),\n\"{\\\\VAR_8&H%X&}\",", "html_color_parse(VAR_0, VAR_9));", "} else if (!strncmp(VAR_9, \"face=\", 5)) {", "VAR_9 += 5 + (VAR_9[5] == '\"');", "VAR_12 = strcspn(VAR_9,\nVAR_9[-1] == '\"' ? \"\\\"\" :\" \");", "av_strlcpy(VAR_11, VAR_9,\nFFMIN(sizeof(VAR_11), VAR_12+1));", "VAR_9 += VAR_12;", "snprintf(stack[VAR_14].VAR_9[PARAM_FACE],\nsizeof(stack[0].VAR_9[PARAM_FACE]),\n\"{\\\\fn%s}\", VAR_11);", "}", "if ((VAR_9 = strchr(VAR_9, ' ')))\nVAR_9++;", "}", "for (VAR_18=0; VAR_18<PARAM_NUMBER; VAR_18++)", "if (stack[VAR_14].VAR_9[VAR_18][0])\nVAR_1 += snprintf(VAR_1, VAR_2-VAR_1,\n\"%s\", stack[VAR_14].VAR_9[VAR_18]);", "}", "} else if (!VAR_10[1] && strspn(VAR_10, \"bisu\") == 1) {", "VAR_1 += snprintf(VAR_1, VAR_2-VAR_1,\n\"{\\\\%VAR_8%d}\", VAR_10[0], !VAR_13);", "} else {", "VAR_20 = 1;", "snprintf(VAR_11, sizeof(VAR_11), \"</%s>\", VAR_10);", "}", "if (VAR_13) {", "VAR_14--;", "} else if (VAR_20 && !strstr(VAR_3, VAR_11)) {", "VAR_3 -= VAR_12 + VAR_13;", "*VAR_1++ = *VAR_3;", "} else", "av_strlcpy(stack[VAR_14++].tag, VAR_10,\nsizeof(stack[0].tag));", "break;", "}", "}", "default:\n*VAR_1++ = *VAR_3;", "break;", "}", "if (*VAR_3 != ' ' && *VAR_3 != '\\r' && *VAR_3 != '\\n')\nVAR_15 = 0;", "}", "VAR_1 = FFMIN(VAR_1, VAR_2-3);", "while (!strncmp(VAR_1-2, \"\\\\N\", 2))\nVAR_1 -= 2;", "while (VAR_1[-1] == ' ')\nVAR_1--;", "VAR_1 += snprintf(VAR_1, VAR_2-VAR_1, \"\\r\\n\");", "return VAR_3;", "}" ]

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

[ "int FUNC_0(AVMetadata **VAR_0, const char *VAR_1, const char *VAR_2)\n{", "AVMetadata *m= *VAR_0;", "AVMetadataTag *tag= av_metadata_get(m, VAR_1, NULL, AV_METADATA_MATCH_CASE);", "if(!m)\nm=*VAR_0= av_mallocz(sizeof(*m));", "if(tag){", "av_free(tag->VAR_2);", "av_free(tag->VAR_1);", "*tag= m->elems[--m->count];", "}else{", "AVMetadataTag *tmp= av_realloc(m->elems, (m->count+1) * sizeof(*m->elems));", "if(tmp){", "m->elems= tmp;", "}else", "return AVERROR(ENOMEM);", "}", "if(VAR_2){", "m->elems[m->count].VAR_1 = av_strdup(VAR_1 );", "m->elems[m->count].VAR_2= av_strdup(VAR_2);", "m->count++;", "}", "if(!m->count) {", "av_free(m->elems);", "av_freep(VAR_0);", "}", "return 0;", "}" ]

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

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

[ "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;", "const char *VAR_4 = VAR_0->VAR_4;", "ObjectClass *cpu_oc;", "ARMCPU *cpu;", "MemoryRegion *address_space_mem = get_system_memory();", "MemoryRegion *ext_ram = g_new(MemoryRegion, 1);", "MemoryRegion *ocm_ram = g_new(MemoryRegion, 1);", "DeviceState *dev;", "SysBusDevice *busdev;", "qemu_irq pic[64];", "Error *err = NULL;", "int VAR_5;", "if (!VAR_1) {", "VAR_1 = \"cortex-a9\";", "}", "cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, VAR_1);", "cpu = ARM_CPU(object_new(object_class_get_name(cpu_oc)));", "object_property_set_int(OBJECT(cpu), ZYNQ_BOARD_MIDR, \"midr\", &err);", "if (err) {", "error_report(\"%s\", error_get_pretty(err));", "exit(1);", "}", "object_property_set_int(OBJECT(cpu), MPCORE_PERIPHBASE, \"reset-cbar\", &err);", "if (err) {", "error_report(\"%s\", error_get_pretty(err));", "exit(1);", "}", "object_property_set_bool(OBJECT(cpu), true, \"realized\", &err);", "if (err) {", "error_report(\"%s\", error_get_pretty(err));", "exit(1);", "}", "if (ram_size > 0x80000000) {", "ram_size = 0x80000000;", "}", "memory_region_init_ram(ext_ram, NULL, \"zynq.ext_ram\", ram_size,\n&error_abort);", "vmstate_register_ram_global(ext_ram);", "memory_region_add_subregion(address_space_mem, 0, ext_ram);", "memory_region_init_ram(ocm_ram, NULL, \"zynq.ocm_ram\", 256 << 10,\n&error_abort);", "vmstate_register_ram_global(ocm_ram);", "memory_region_add_subregion(address_space_mem, 0xFFFC0000, ocm_ram);", "DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0);", "pflash_cfi02_register(0xe2000000, NULL, \"zynq.pflash\", FLASH_SIZE,\ndinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL,\nFLASH_SECTOR_SIZE,\nFLASH_SIZE/FLASH_SECTOR_SIZE, 1,\n1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa,\n0);", "dev = qdev_create(NULL, \"xilinx,zynq_slcr\");", "qdev_init_nofail(dev);", "sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xF8000000);", "dev = qdev_create(NULL, \"a9mpcore_priv\");", "qdev_prop_set_uint32(dev, \"num-cpu\", 1);", "qdev_init_nofail(dev);", "busdev = SYS_BUS_DEVICE(dev);", "sysbus_mmio_map(busdev, 0, MPCORE_PERIPHBASE);", "sysbus_connect_irq(busdev, 0,\nqdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ));", "for (VAR_5 = 0; VAR_5 < 64; VAR_5++) {", "pic[VAR_5] = qdev_get_gpio_in(dev, VAR_5);", "}", "zynq_init_spi_flashes(0xE0006000, pic[58-IRQ_OFFSET], false);", "zynq_init_spi_flashes(0xE0007000, pic[81-IRQ_OFFSET], false);", "zynq_init_spi_flashes(0xE000D000, pic[51-IRQ_OFFSET], true);", "sysbus_create_simple(\"xlnx,ps7-usb\", 0xE0002000, pic[53-IRQ_OFFSET]);", "sysbus_create_simple(\"xlnx,ps7-usb\", 0xE0003000, pic[76-IRQ_OFFSET]);", "sysbus_create_simple(\"cadence_uart\", 0xE0000000, pic[59-IRQ_OFFSET]);", "sysbus_create_simple(\"cadence_uart\", 0xE0001000, pic[82-IRQ_OFFSET]);", "sysbus_create_varargs(\"cadence_ttc\", 0xF8001000,\npic[42-IRQ_OFFSET], pic[43-IRQ_OFFSET], pic[44-IRQ_OFFSET], NULL);", "sysbus_create_varargs(\"cadence_ttc\", 0xF8002000,\npic[69-IRQ_OFFSET], pic[70-IRQ_OFFSET], pic[71-IRQ_OFFSET], NULL);", "gem_init(&nd_table[0], 0xE000B000, pic[54-IRQ_OFFSET]);", "gem_init(&nd_table[1], 0xE000C000, pic[77-IRQ_OFFSET]);", "dev = qdev_create(NULL, \"generic-sdhci\");", "qdev_init_nofail(dev);", "sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0100000);", "sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[56-IRQ_OFFSET]);", "dev = qdev_create(NULL, \"generic-sdhci\");", "qdev_init_nofail(dev);", "sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, 0xE0101000);", "sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[79-IRQ_OFFSET]);", "dev = qdev_create(NULL, \"pl330\");", "qdev_prop_set_uint8(dev, \"num_chnls\", 8);", "qdev_prop_set_uint8(dev, \"num_periph_req\", 4);", "qdev_prop_set_uint8(dev, \"num_events\", 16);", "qdev_prop_set_uint8(dev, \"data_width\", 64);", "qdev_prop_set_uint8(dev, \"wr_cap\", 8);", "qdev_prop_set_uint8(dev, \"wr_q_dep\", 16);", "qdev_prop_set_uint8(dev, \"rd_cap\", 8);", "qdev_prop_set_uint8(dev, \"rd_q_dep\", 16);", "qdev_prop_set_uint16(dev, \"data_buffer_dep\", 256);", "qdev_init_nofail(dev);", "busdev = SYS_BUS_DEVICE(dev);", "sysbus_mmio_map(busdev, 0, 0xF8003000);", "sysbus_connect_irq(busdev, 0, pic[45-IRQ_OFFSET]);", "for (VAR_5 = 0; VAR_5 < 8; ++VAR_5) {", "sysbus_connect_irq(busdev, VAR_5 + 1, pic[dma_irqs[VAR_5] - IRQ_OFFSET]);", "}", "zynq_binfo.ram_size = ram_size;", "zynq_binfo.VAR_2 = VAR_2;", "zynq_binfo.VAR_3 = VAR_3;", "zynq_binfo.VAR_4 = VAR_4;", "zynq_binfo.nb_cpus = 1;", "zynq_binfo.board_id = 0xd32;", "zynq_binfo.loader_start = 0;", "arm_load_kernel(ARM_CPU(first_cpu), &zynq_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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 87 ], [ 89 ], [ 91 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 119 ], [ 125, 127, 129, 131, 133, 135 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 185 ], [ 187 ], [ 191, 193 ], [ 195, 197 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ] ]

[ "static void FUNC_0(TCGContext *VAR_0, TCGMemOp VAR_1, TCGCond VAR_2, TCGArg VAR_3,\nTCGArg VAR_4, bool VAR_5, int VAR_6)\n{", "TCGLabel *l = &VAR_0->labels[VAR_6];", "intptr_t offset;", "bool need_cmp;", "if (VAR_5 && VAR_4 == 0 && (VAR_2 == TCG_COND_EQ || VAR_2 == TCG_COND_NE)) {", "need_cmp = false;", "} else {", "need_cmp = true;", "tcg_out_cmp(VAR_0, VAR_1, VAR_3, VAR_4, VAR_5);", "}", "if (!l->has_value) {", "tcg_out_reloc(VAR_0, VAR_0->code_ptr, R_AARCH64_CONDBR19, VAR_6, 0);", "offset = tcg_in32(VAR_0) >> 5;", "} else {", "offset = l->u.value_ptr - VAR_0->code_ptr;", "assert(offset == sextract64(offset, 0, 19));", "}", "if (need_cmp) {", "tcg_out_insn(VAR_0, 3202, B_C, VAR_2, offset);", "} else if (VAR_2 == TCG_COND_EQ) {", "tcg_out_insn(VAR_0, 3201, CBZ, VAR_1, VAR_3, offset);", "} else {", "tcg_out_insn(VAR_0, 3201, CBNZ, VAR_1, VAR_3, offset);", "}", "}" ]

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

[ "static target_ulong FUNC_0(CPUState *env, sPAPREnvironment *spapr,\ntarget_ulong opcode,\ntarget_ulong *args)\n{", "target_ulong reg = args[0];", "target_ulong mode = args[1];", "VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);", "VIOsPAPRDeviceInfo *info;", "if (!dev) {", "return H_PARAMETER;", "}", "info = (VIOsPAPRDeviceInfo *)qdev_get_info(&dev->qdev);", "if (mode & ~info->signal_mask) {", "return H_PARAMETER;", "}", "dev->signal_state = mode;", "return H_SUCCESS;", "}" ]

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

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

[ "static TCGArg FUNC_0(int op, TCGArg x, TCGArg y)\n{", "TCGArg res = do_constant_folding_2(op, x, y);", "#if TCG_TARGET_REG_BITS == 64\nif (op_bits(op) == 32) {", "res &= 0xffffffff;", "}", "#endif\nreturn res;", "}" ]

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

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

[ "static int64_t FUNC_0(BDRVParallelsState *s, int64_t sector_num)\n{", "uint32_t index, offset;", "index = sector_num / s->tracks;", "offset = sector_num % s->tracks;", "if ((index >= s->catalog_size) || (s->catalog_bitmap[index] == 0))\nreturn -1;", "return (uint64_t)s->catalog_bitmap[index] * s->off_multiplier + offset;", "}" ]

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

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

[ "int FUNC_0(const char *VAR_0,\ntarget_phys_addr_t VAR_1, uint64_t VAR_2)\n{", "int VAR_3;", "VAR_3 = get_image_size(VAR_0);", "if (VAR_3 > VAR_2) {", "return -1;", "}", "if (VAR_3 > 0) {", "rom_add_file_fixed(VAR_0, VAR_1, -1);", "}", "return VAR_3;", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque,\nhwaddr addr, unsigned size)\n{", "VFIOBAR *bar = opaque;", "union {", "uint8_t byte;", "uint16_t word;", "uint32_t dword;", "uint64_t qword;", "} VAR_0;", "uint64_t data = 0;", "if (pread(bar->fd, &VAR_0, size, bar->fd_offset + addr) != size) {", "error_report(\"%s(,0x%\"HWADDR_PRIx\", %d) failed: %m\",\n__func__, addr, size);", "return (uint64_t)-1;", "}", "switch (size) {", "case 1:\ndata = VAR_0.byte;", "break;", "case 2:\ndata = le16_to_cpu(VAR_0.word);", "break;", "case 4:\ndata = le32_to_cpu(VAR_0.dword);", "break;", "default:\nhw_error(\"vfio: unsupported read size, %d bytes\\n\", size);", "break;", "}", "DPRINTF(\"%s(BAR%d+0x%\"HWADDR_PRIx\", %d) = 0x%\"PRIx64\"\\n\",\n__func__, bar->nr, addr, size, data);", "vfio_eoi(container_of(bar, VFIODevice, bars[bar->nr]));", "return data;", "}" ]

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

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

[ "static int FUNC_0(void *VAR_0)\n{", "NetL2TPV3State *s = VAR_0;", "return qemu_can_send_packet(&s->nc);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(QemuOpts *VAR_0, int *VAR_1,\nconst char **VAR_2, ThrottleConfig *VAR_3,\nBlockdevDetectZeroesOptions *VAR_4, Error **VAR_5)\n{", "const char *VAR_6;", "Error *local_error = NULL;", "const char *VAR_7;", "if (VAR_1) {", "if (!qemu_opt_get_bool(VAR_0, \"read-only\", false)) {", "*VAR_1 |= BDRV_O_RDWR;", "}", "if (qemu_opt_get_bool(VAR_0, \"copy-on-read\", false)) {", "*VAR_1 |= BDRV_O_COPY_ON_READ;", "}", "if ((VAR_6 = qemu_opt_get(VAR_0, \"VAR_6\")) != NULL) {", "if (bdrv_parse_discard_flags(VAR_6, VAR_1) != 0) {", "error_setg(VAR_5, \"Invalid VAR_6 option\");", "return;", "}", "}", "if ((VAR_7 = qemu_opt_get(VAR_0, \"VAR_7\")) != NULL) {", "if (!strcmp(VAR_7, \"native\")) {", "*VAR_1 |= BDRV_O_NATIVE_AIO;", "} else if (!strcmp(VAR_7, \"threads\")) {", "} else {", "error_setg(VAR_5, \"invalid VAR_7 option\");", "return;", "}", "}", "}", "if (VAR_2) {", "*VAR_2 = qemu_opt_get(VAR_0, \"throttling.group\");", "}", "if (VAR_3) {", "memset(VAR_3, 0, sizeof(*VAR_3));", "VAR_3->buckets[THROTTLE_BPS_TOTAL].avg =\nqemu_opt_get_number(VAR_0, \"throttling.bps-total\", 0);", "VAR_3->buckets[THROTTLE_BPS_READ].avg =\nqemu_opt_get_number(VAR_0, \"throttling.bps-read\", 0);", "VAR_3->buckets[THROTTLE_BPS_WRITE].avg =\nqemu_opt_get_number(VAR_0, \"throttling.bps-write\", 0);", "VAR_3->buckets[THROTTLE_OPS_TOTAL].avg =\nqemu_opt_get_number(VAR_0, \"throttling.iops-total\", 0);", "VAR_3->buckets[THROTTLE_OPS_READ].avg =\nqemu_opt_get_number(VAR_0, \"throttling.iops-read\", 0);", "VAR_3->buckets[THROTTLE_OPS_WRITE].avg =\nqemu_opt_get_number(VAR_0, \"throttling.iops-write\", 0);", "VAR_3->buckets[THROTTLE_BPS_TOTAL].max =\nqemu_opt_get_number(VAR_0, \"throttling.bps-total-max\", 0);", "VAR_3->buckets[THROTTLE_BPS_READ].max =\nqemu_opt_get_number(VAR_0, \"throttling.bps-read-max\", 0);", "VAR_3->buckets[THROTTLE_BPS_WRITE].max =\nqemu_opt_get_number(VAR_0, \"throttling.bps-write-max\", 0);", "VAR_3->buckets[THROTTLE_OPS_TOTAL].max =\nqemu_opt_get_number(VAR_0, \"throttling.iops-total-max\", 0);", "VAR_3->buckets[THROTTLE_OPS_READ].max =\nqemu_opt_get_number(VAR_0, \"throttling.iops-read-max\", 0);", "VAR_3->buckets[THROTTLE_OPS_WRITE].max =\nqemu_opt_get_number(VAR_0, \"throttling.iops-write-max\", 0);", "VAR_3->op_size =\nqemu_opt_get_number(VAR_0, \"throttling.iops-size\", 0);", "if (!check_throttle_config(VAR_3, VAR_5)) {", "return;", "}", "}", "if (VAR_4) {", "*VAR_4 =\nqapi_enum_parse(BlockdevDetectZeroesOptions_lookup,\nqemu_opt_get(VAR_0, \"detect-zeroes\"),\nBLOCKDEV_DETECT_ZEROES_OPTIONS__MAX,\nBLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,\n&local_error);", "if (local_error) {", "error_propagate(VAR_5, local_error);", "return;", "}", "if (VAR_1 &&\n*VAR_4 == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&\n!(*VAR_1 & BDRV_O_UNMAP))\n{", "error_setg(VAR_5, \"setting detect-zeroes to unmap is not allowed \"\n\"without setting VAR_6 operation to unmap\");", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89, 91 ], [ 93, 95 ], [ 97, 99 ], [ 101, 103 ], [ 105, 107 ], [ 111, 113 ], [ 115, 117 ], [ 119, 121 ], [ 123, 125 ], [ 127, 129 ], [ 131, 133 ], [ 137, 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155, 157, 159, 161, 163, 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177, 179, 181, 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ] ]

[ "static inline void FUNC_0(TCGContext *VAR_0, int VAR_1, int VAR_2, TCGArg VAR_3,\nTCGArg VAR_4, TCGArg VAR_5, int VAR_6)\n{", "if (VAR_6) {", "int VAR_7 = encode_imm(VAR_5);", "assert(VAR_7 >= 0);", "tcg_out_dat_imm(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, rotl(VAR_5, VAR_7) | (VAR_7 << 7));", "} else {", "tcg_out_dat_reg(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, SHIFT_IMM_LSL(0));", "}", "}" ]

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

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

[ "static always_inline void FUNC_0 (DisasContext *ctx,\nTCGCond cond,\nint ra, int32_t disp16, int mask)\n{", "int VAR_0, VAR_1;", "VAR_0 = gen_new_label();", "VAR_1 = gen_new_label();", "if (likely(ra != 31)) {", "if (mask) {", "TCGv tmp = tcg_temp_new(TCG_TYPE_I64);", "tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);", "tcg_gen_brcondi_i64(cond, tmp, 0, VAR_0);", "tcg_temp_free(tmp);", "} else", "tcg_gen_brcondi_i64(cond, cpu_ir[ra], 0, VAR_0);", "} else {", "TCGv tmp = tcg_const_i64(0);", "tcg_gen_brcondi_i64(cond, tmp, 0, VAR_0);", "tcg_temp_free(tmp);", "}", "tcg_gen_movi_i64(cpu_pc, ctx->pc);", "tcg_gen_br(VAR_1);", "gen_set_label(VAR_0);", "tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp16 << 2));", "gen_set_label(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 ]

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

[ "void FUNC_0(EventNotifier *VAR_0,\nEventNotifierHandler *VAR_1,\nAioFlushEventNotifierHandler *VAR_2)\n{", "qemu_aio_set_fd_handler(event_notifier_get_fd(VAR_0),\n(IOHandler *)VAR_1, NULL,\n(AioFlushHandler *)VAR_2, VAR_0);", "}" ]

[ 0, 0, 0 ]

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

[ "uint32_t FUNC_0(lpebr)(CPUS390XState *env, uint32_t f1, uint32_t f2)\n{", "float32 v1;", "float32 v2 = env->fregs[f2].d;", "v1 = float32_abs(v2);", "env->fregs[f1].d = v1;", "return set_cc_nz_f32(v1);", "}" ]

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

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

[ "uint64_t FUNC_0 (uint64_t arg1, uint64_t arg2, uint64_t arg3)\n{", "CPU_DoubleU farg1;", "farg1.ll = arg1;", "if ((!float64_is_neg(farg1.d) || float64_is_zero(farg1.d)) && !float64_is_nan(farg1.d))\nreturn arg2;", "else\nreturn arg3;", "}" ]

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

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

[ "static int FUNC_0(OHCIState *VAR_0, struct ohci_ed *VAR_1)\n{", "int VAR_2;", "size_t len = 0, pktlen = 0;", "#ifdef DEBUG_PACKET\nconst char *str = NULL;", "#endif\nint VAR_3;", "int VAR_4;", "int VAR_5;", "USBDevice *dev;", "struct ohci_td VAR_6;", "uint32_t addr;", "int VAR_7;", "int VAR_8;", "addr = VAR_1->head & OHCI_DPTR_MASK;", "VAR_8 = (addr == VAR_0->async_td);", "if (VAR_8 && !VAR_0->async_complete) {", "#ifdef DEBUG_PACKET\nDPRINTF(\"Skipping async TD\\n\");", "#endif\nreturn 1;", "}", "if (!ohci_read_td(VAR_0, addr, &VAR_6)) {", "fprintf(stderr, \"usb-VAR_0: TD read error at %x\\n\", addr);", "return 0;", "}", "VAR_2 = OHCI_BM(VAR_1->flags, ED_D);", "switch (VAR_2) {", "case OHCI_TD_DIR_OUT:\ncase OHCI_TD_DIR_IN:\nbreak;", "default:\nVAR_2 = OHCI_BM(VAR_6.flags, TD_DP);", "break;", "}", "switch (VAR_2) {", "case OHCI_TD_DIR_IN:\n#ifdef DEBUG_PACKET\nstr = \"in\";", "#endif\nVAR_3 = USB_TOKEN_IN;", "break;", "case OHCI_TD_DIR_OUT:\n#ifdef DEBUG_PACKET\nstr = \"out\";", "#endif\nVAR_3 = USB_TOKEN_OUT;", "break;", "case OHCI_TD_DIR_SETUP:\n#ifdef DEBUG_PACKET\nstr = \"setup\";", "#endif\nVAR_3 = USB_TOKEN_SETUP;", "break;", "default:\nfprintf(stderr, \"usb-VAR_0: Bad direction\\n\");", "return 1;", "}", "if (VAR_6.cbp && VAR_6.be) {", "if ((VAR_6.cbp & 0xfffff000) != (VAR_6.be & 0xfffff000)) {", "len = (VAR_6.be & 0xfff) + 0x1001 - (VAR_6.cbp & 0xfff);", "} else {", "len = (VAR_6.be - VAR_6.cbp) + 1;", "}", "pktlen = len;", "if (len && VAR_2 != OHCI_TD_DIR_IN) {", "pktlen = (VAR_1->flags & OHCI_ED_MPS_MASK) >> OHCI_ED_MPS_SHIFT;", "if (pktlen > len) {", "pktlen = len;", "}", "if (!VAR_8) {", "ohci_copy_td(VAR_0, &VAR_6, VAR_0->usb_buf, pktlen, 0);", "}", "}", "}", "VAR_7 = (VAR_6.flags & OHCI_TD_R) != 0;", "#ifdef DEBUG_PACKET\nDPRINTF(\" TD @ 0x%.8x %\" PRId64 \" of %\" PRId64\n\" bytes %s r=%d cbp=0x%.8x be=0x%.8x\\n\",\naddr, (int64_t)pktlen, (int64_t)len, str, VAR_7, VAR_6.cbp, VAR_6.be);", "if (pktlen > 0 && VAR_2 != OHCI_TD_DIR_IN) {", "DPRINTF(\" data:\");", "for (VAR_5 = 0; VAR_5 < pktlen; VAR_5++) {", "printf(\" %.2x\", VAR_0->usb_buf[VAR_5]);", "}", "DPRINTF(\"\\n\");", "}", "#endif\nif (VAR_8) {", "VAR_4 = VAR_0->usb_packet.result;", "VAR_0->async_td = 0;", "VAR_0->async_complete = 0;", "} else {", "if (VAR_0->async_td) {", "#ifdef DEBUG_PACKET\nDPRINTF(\"Too many pending packets\\n\");", "#endif\nreturn 1;", "}", "usb_packet_setup(&VAR_0->usb_packet, VAR_3,\nOHCI_BM(VAR_1->flags, ED_FA),\nOHCI_BM(VAR_1->flags, ED_EN));", "usb_packet_addbuf(&VAR_0->usb_packet, VAR_0->usb_buf, pktlen);", "dev = ohci_find_device(VAR_0, VAR_0->usb_packet.devaddr);", "VAR_4 = usb_handle_packet(dev, &VAR_0->usb_packet);", "#ifdef DEBUG_PACKET\nDPRINTF(\"VAR_4=%d\\n\", VAR_4);", "#endif\nif (VAR_4 == USB_RET_ASYNC) {", "VAR_0->async_td = addr;", "return 1;", "}", "}", "if (VAR_4 >= 0) {", "if (VAR_2 == OHCI_TD_DIR_IN) {", "ohci_copy_td(VAR_0, &VAR_6, VAR_0->usb_buf, VAR_4, 1);", "#ifdef DEBUG_PACKET\nDPRINTF(\" data:\");", "for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++)", "printf(\" %.2x\", VAR_0->usb_buf[VAR_5]);", "DPRINTF(\"\\n\");", "#endif\n} else {", "VAR_4 = pktlen;", "}", "}", "if (VAR_4 == pktlen || (VAR_2 == OHCI_TD_DIR_IN && VAR_4 >= 0 && VAR_7)) {", "if (VAR_4 == len) {", "VAR_6.cbp = 0;", "} else {", "if ((VAR_6.cbp & 0xfff) + VAR_4 > 0xfff) {", "VAR_6.cbp = (VAR_6.be & ~0xfff) + ((VAR_6.cbp + VAR_4) & 0xfff);", "} else {", "VAR_6.cbp += VAR_4;", "}", "}", "VAR_6.flags |= OHCI_TD_T1;", "VAR_6.flags ^= OHCI_TD_T0;", "OHCI_SET_BM(VAR_6.flags, TD_CC, OHCI_CC_NOERROR);", "OHCI_SET_BM(VAR_6.flags, TD_EC, 0);", "if ((VAR_2 != OHCI_TD_DIR_IN) && (VAR_4 != len)) {", "goto exit_no_retire;", "}", "VAR_1->head &= ~OHCI_ED_C;", "if (VAR_6.flags & OHCI_TD_T0)\nVAR_1->head |= OHCI_ED_C;", "} else {", "if (VAR_4 >= 0) {", "DPRINTF(\"usb-VAR_0: Underrun\\n\");", "OHCI_SET_BM(VAR_6.flags, TD_CC, OHCI_CC_DATAUNDERRUN);", "} else {", "switch (VAR_4) {", "case USB_RET_NODEV:\nOHCI_SET_BM(VAR_6.flags, TD_CC, OHCI_CC_DEVICENOTRESPONDING);", "case USB_RET_NAK:\nDPRINTF(\"usb-VAR_0: got NAK\\n\");", "return 1;", "case USB_RET_STALL:\nDPRINTF(\"usb-VAR_0: got STALL\\n\");", "OHCI_SET_BM(VAR_6.flags, TD_CC, OHCI_CC_STALL);", "break;", "case USB_RET_BABBLE:\nDPRINTF(\"usb-VAR_0: got BABBLE\\n\");", "OHCI_SET_BM(VAR_6.flags, TD_CC, OHCI_CC_DATAOVERRUN);", "break;", "default:\nfprintf(stderr, \"usb-VAR_0: Bad device response %d\\n\", VAR_4);", "OHCI_SET_BM(VAR_6.flags, TD_CC, OHCI_CC_UNDEXPETEDPID);", "OHCI_SET_BM(VAR_6.flags, TD_EC, 3);", "break;", "}", "}", "VAR_1->head |= OHCI_ED_H;", "}", "VAR_1->head &= ~OHCI_DPTR_MASK;", "VAR_1->head |= VAR_6.next & OHCI_DPTR_MASK;", "VAR_6.next = VAR_0->done;", "VAR_0->done = addr;", "VAR_5 = OHCI_BM(VAR_6.flags, TD_DI);", "if (VAR_5 < VAR_0->done_count)\nVAR_0->done_count = VAR_5;", "exit_no_retire:\nohci_put_td(VAR_0, addr, &VAR_6);", "return OHCI_BM(VAR_6.flags, TD_CC) != OHCI_CC_NOERROR;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 45, 47 ], [ 49 ], [ 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 ], [ 109, 111, 113 ], [ 115, 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171, 173, 175, 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 219, 221 ], [ 223, 225 ], [ 227 ], [ 229, 231, 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241, 243 ], [ 245, 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263, 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273, 275 ], [ 277 ], [ 279 ], [ 281 ], [ 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 319 ], [ 323 ], [ 325 ], [ 331 ], [ 333, 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349, 351 ], [ 353, 355 ], [ 357 ], [ 359, 361 ], [ 363 ], [ 365 ], [ 367, 369 ], [ 371 ], [ 373 ], [ 375, 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407, 409 ], [ 411, 413 ], [ 415 ], [ 417 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3) {", "GetByteContext gb;", "AVFrame * const p = VAR_1;", "unsigned int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "unsigned int VAR_11, VAR_12;", "uint8_t *ptr;", "uint32_t *pal;", "int VAR_13;", "bytestream2_init(&gb, VAR_3->VAR_1, VAR_3->size);", "VAR_4 = bytestream2_get_le32(&gb);", "bytestream2_skip(&gb, 72);", "VAR_7 = bytestream2_get_le32(&gb);", "VAR_5 = bytestream2_get_le16(&gb);", "VAR_6 = bytestream2_get_le16(&gb);", "VAR_8 = bytestream2_get_byte(&gb);", "bytestream2_skip(&gb, 2);", "VAR_10 = bytestream2_get_byte(&gb);", "if (VAR_4 < 8 || VAR_4 > 9) {", "av_log(VAR_0, AV_LOG_ERROR, \"texture VAR_1 VAR_4 %i is unsupported\\n\",\nVAR_4);", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_8 == 8) {", "VAR_0->pix_fmt = AV_PIX_FMT_PAL8;", "} else if (VAR_8 == 16 || VAR_8 == 32) {", "VAR_0->pix_fmt = AV_PIX_FMT_RGB32;", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_8 of %i is unsupported\\n\", VAR_8);", "return AVERROR_PATCHWELCOME;", "}", "if ((VAR_13 = ff_set_dimensions(VAR_0, VAR_5, VAR_6)) < 0)\nreturn VAR_13;", "if ((VAR_13 = ff_get_buffer(VAR_0, p, 0)) < 0)\nreturn VAR_13;", "p->pict_type = AV_PICTURE_TYPE_I;", "ptr = p->VAR_1[0];", "VAR_9 = p->linesize[0];", "if (VAR_8 == 8) {", "pal = (uint32_t *) p->VAR_1[1];", "for (VAR_11 = 0; VAR_11 < 256; VAR_11++) {", "VAR_12 = bytestream2_get_be32(&gb);", "pal[VAR_11] = (VAR_12 >> 8) + (VAR_12 << 24);", "}", "if (bytestream2_get_bytes_left(&gb) < VAR_5 * VAR_6)\nreturn AVERROR_INVALIDDATA;", "bytestream2_skip(&gb, 4);", "for (VAR_11=0; VAR_11<VAR_6; VAR_11++) {", "bytestream2_get_buffer(&gb, ptr, VAR_5);", "ptr += VAR_9;", "}", "} else if (VAR_8 == 16) {", "bytestream2_skip(&gb, 4);", "switch (VAR_7) {", "case 0:\nif (!(VAR_10 & 1))\ngoto unsupported;", "case FF_S3TC_DXT1:\nif (bytestream2_get_bytes_left(&gb) < (VAR_5/4) * (VAR_6/4) * 8)\nreturn AVERROR_INVALIDDATA;", "ff_decode_dxt1(&gb, ptr, VAR_5, VAR_6, VAR_9);", "break;", "case FF_S3TC_DXT3:\nif (bytestream2_get_bytes_left(&gb) < (VAR_5/4) * (VAR_6/4) * 16)\nreturn AVERROR_INVALIDDATA;", "ff_decode_dxt3(&gb, ptr, VAR_5, VAR_6, VAR_9);", "break;", "default:\ngoto unsupported;", "}", "} else if (VAR_8 == 32) {", "switch (VAR_7) {", "case 0x15:\ncase 0x16:\nif (bytestream2_get_bytes_left(&gb) < VAR_6 * VAR_5 * 4)\nreturn AVERROR_INVALIDDATA;", "for (VAR_11=0; VAR_11<VAR_6; VAR_11++) {", "bytestream2_get_buffer(&gb, ptr, VAR_5 * 4);", "ptr += VAR_9;", "}", "break;", "default:\ngoto unsupported;", "}", "}", "*VAR_2 = 1;", "return VAR_3->size;", "unsupported:\nav_log(VAR_0, AV_LOG_ERROR, \"unsupported d3d format (%08x)\\n\", VAR_7);", "return AVERROR_PATCHWELCOME;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71, 73 ], [ 77, 79 ], [ 83 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125, 127, 129 ], [ 131, 133, 135 ], [ 137 ], [ 139 ], [ 141, 143, 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161, 163, 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 189 ], [ 193 ], [ 197, 199 ], [ 201 ], [ 203 ] ]

[ "static int FUNC_0(AVFormatContext* VAR_0, AVPacket *VAR_1)\n{", "al_data *ad = VAR_0->priv_data;", "int VAR_2=0;", "const char *VAR_3;", "ALCint nb_samples;", "alcGetIntegerv(ad->device, ALC_CAPTURE_SAMPLES, (ALCsizei) sizeof(ALCint), &nb_samples);", "if (VAR_2 = al_get_error(ad->device, &VAR_3)) goto fail;", "av_new_packet(VAR_1, nb_samples*ad->sample_step);", "VAR_1->pts = av_gettime();", "alcCaptureSamples(ad->device, VAR_1->data, nb_samples);", "if (VAR_2 = al_get_error(ad->device, &VAR_3)) goto fail;", "return VAR_1->size;", "fail:\nif (VAR_1->data)\nav_destruct_packet(VAR_1);", "if (VAR_3)\nav_log(VAR_0, AV_LOG_ERROR, \"Error: %s\\n\", VAR_3);", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 17 ], [ 19 ], [ 25 ], [ 27 ], [ 33 ], [ 35 ], [ 39 ], [ 41, 45, 47 ], [ 49, 51 ], [ 53 ], [ 55 ] ]

[ "static int FUNC_0(FFV1Context *VAR_0){", "uint8_t state[CONTEXT_SIZE];", "int VAR_1, VAR_2, VAR_3;", "RangeCoder * const c= &VAR_0->slice_context[0]->c;", "memset(state, 128, sizeof(state));", "if(VAR_0->version < 2){", "VAR_0->version= get_symbol(c, state, 0);", "VAR_0->ac= VAR_0->avctx->coder_type= get_symbol(c, state, 0);", "if(VAR_0->ac>1){", "for(VAR_1=1; VAR_1<256; VAR_1++){", "VAR_0->state_transition[VAR_1]= get_symbol(c, state, 1) + c->one_state[VAR_1];", "}", "}", "VAR_0->colorspace= get_symbol(c, state, 0);", "if(VAR_0->version>0)\nVAR_0->avctx->bits_per_raw_sample= get_symbol(c, state, 0);", "VAR_0->chroma_planes= get_rac(c, state);", "VAR_0->chroma_h_shift= get_symbol(c, state, 0);", "VAR_0->chroma_v_shift= get_symbol(c, state, 0);", "VAR_0->transparency= get_rac(c, state);", "VAR_0->plane_count= 2 + VAR_0->transparency;", "}", "if(VAR_0->colorspace==0){", "if(!VAR_0->transparency && !VAR_0->chroma_planes){", "if (VAR_0->avctx->bits_per_raw_sample<=8)\nVAR_0->avctx->pix_fmt= PIX_FMT_GRAY8;", "else\nVAR_0->avctx->pix_fmt= PIX_FMT_GRAY16;", "}else if(VAR_0->avctx->bits_per_raw_sample<=8 && !VAR_0->transparency){", "switch(16*VAR_0->chroma_h_shift + VAR_0->chroma_v_shift){", "case 0x00: VAR_0->avctx->pix_fmt= PIX_FMT_YUV444P; break;", "case 0x01: VAR_0->avctx->pix_fmt= PIX_FMT_YUV440P; break;", "case 0x10: VAR_0->avctx->pix_fmt= PIX_FMT_YUV422P; break;", "case 0x11: VAR_0->avctx->pix_fmt= PIX_FMT_YUV420P; break;", "case 0x20: VAR_0->avctx->pix_fmt= PIX_FMT_YUV411P; break;", "case 0x22: VAR_0->avctx->pix_fmt= PIX_FMT_YUV410P; break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"format not supported\\n\");", "return -1;", "}", "}else if(VAR_0->avctx->bits_per_raw_sample<=8 && VAR_0->transparency){", "switch(16*VAR_0->chroma_h_shift + VAR_0->chroma_v_shift){", "case 0x00: VAR_0->avctx->pix_fmt= PIX_FMT_YUVA444P; break;", "case 0x11: VAR_0->avctx->pix_fmt= PIX_FMT_YUVA420P; break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"format not supported\\n\");", "return -1;", "}", "}else if(VAR_0->avctx->bits_per_raw_sample==9) {", "VAR_0->packed_at_lsb=1;", "switch(16*VAR_0->chroma_h_shift + VAR_0->chroma_v_shift){", "case 0x00: VAR_0->avctx->pix_fmt= PIX_FMT_YUV444P9; break;", "case 0x10: VAR_0->avctx->pix_fmt= PIX_FMT_YUV422P9; break;", "case 0x11: VAR_0->avctx->pix_fmt= PIX_FMT_YUV420P9; break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"format not supported\\n\");", "return -1;", "}", "}else if(VAR_0->avctx->bits_per_raw_sample==10) {", "VAR_0->packed_at_lsb=1;", "switch(16*VAR_0->chroma_h_shift + VAR_0->chroma_v_shift){", "case 0x00: VAR_0->avctx->pix_fmt= PIX_FMT_YUV444P10; break;", "case 0x10: VAR_0->avctx->pix_fmt= PIX_FMT_YUV422P10; break;", "case 0x11: VAR_0->avctx->pix_fmt= PIX_FMT_YUV420P10; break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"format not supported\\n\");", "return -1;", "}", "}else {", "switch(16*VAR_0->chroma_h_shift + VAR_0->chroma_v_shift){", "case 0x00: VAR_0->avctx->pix_fmt= PIX_FMT_YUV444P16; break;", "case 0x10: VAR_0->avctx->pix_fmt= PIX_FMT_YUV422P16; break;", "case 0x11: VAR_0->avctx->pix_fmt= PIX_FMT_YUV420P16; break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"format not supported\\n\");", "return -1;", "}", "}", "}else if(VAR_0->colorspace==1){", "if(VAR_0->chroma_h_shift || VAR_0->chroma_v_shift){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"chroma subsampling not supported in this colorspace\\n\");", "return -1;", "}", "if(VAR_0->transparency) VAR_0->avctx->pix_fmt= PIX_FMT_RGB32;", "else VAR_0->avctx->pix_fmt= PIX_FMT_0RGB32;", "}else{", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"colorspace not supported\\n\");", "return -1;", "}", "if(VAR_0->version < 2){", "VAR_3= read_quant_tables(c, VAR_0->quant_table);", "if(VAR_3 < 0){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"read_quant_table error\\n\");", "return -1;", "}", "}else{", "VAR_0->slice_count= get_symbol(c, state, 0);", "if(VAR_0->slice_count > (unsigned)MAX_SLICES)\nreturn -1;", "}", "for(VAR_2=0; VAR_2<VAR_0->slice_count; VAR_2++){", "FFV1Context *fs= VAR_0->slice_context[VAR_2];", "fs->ac= VAR_0->ac;", "fs->packed_at_lsb= VAR_0->packed_at_lsb;", "if(VAR_0->version >= 2){", "fs->slice_x = get_symbol(c, state, 0) *VAR_0->width ;", "fs->slice_y = get_symbol(c, state, 0) *VAR_0->height;", "fs->slice_width =(get_symbol(c, state, 0)+1)*VAR_0->width + fs->slice_x;", "fs->slice_height=(get_symbol(c, state, 0)+1)*VAR_0->height + fs->slice_y;", "fs->slice_x /= VAR_0->num_h_slices;", "fs->slice_y /= VAR_0->num_v_slices;", "fs->slice_width = fs->slice_width /VAR_0->num_h_slices - fs->slice_x;", "fs->slice_height = fs->slice_height/VAR_0->num_v_slices - fs->slice_y;", "if((unsigned)fs->slice_width > VAR_0->width || (unsigned)fs->slice_height > VAR_0->height)\nreturn -1;", "if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > VAR_0->width\n|| (unsigned)fs->slice_y + (uint64_t)fs->slice_height > VAR_0->height)\nreturn -1;", "}", "for(VAR_1=0; VAR_1<VAR_0->plane_count; VAR_1++){", "PlaneContext * const p= &fs->plane[VAR_1];", "if(VAR_0->version >= 2){", "int idx=get_symbol(c, state, 0);", "if(idx > (unsigned)VAR_0->quant_table_count){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"quant_table_index out of range\\n\");", "return -1;", "}", "p->quant_table_index= idx;", "memcpy(p->quant_table, VAR_0->quant_tables[idx], sizeof(p->quant_table));", "VAR_3= VAR_0->VAR_3[idx];", "}else{", "memcpy(p->quant_table, VAR_0->quant_table, sizeof(p->quant_table));", "}", "if(p->VAR_3 < VAR_3){", "av_freep(&p->state);", "av_freep(&p->vlc_state);", "}", "p->VAR_3= VAR_3;", "}", "}", "return 0;", "}" ]

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

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205, 207 ], [ 209 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243, 245 ], [ 247, 249, 251 ], [ 253 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 305 ], [ 307 ] ]

[ "static void FUNC_0(uint8_t *VAR_0,\nuint8_t VAR_1,\nuint8_t VAR_2,\nuint32_t VAR_3)\n{", "v16u8 alpha, beta;", "v16u8 is_less_than;", "v8i16 p0_or_q0, q0_or_p0;", "v16u8 p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org;", "v16i8 zero = { 0 };", "v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;", "v16u8 is_less_than_alpha, is_less_than_beta;", "v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;", "alpha = (v16u8) __msa_fill_b(VAR_1);", "beta = (v16u8) __msa_fill_b(VAR_2);", "p1_or_q1_org = LOAD_UB(VAR_0 - (VAR_3 << 1));", "p0_or_q0_org = LOAD_UB(VAR_0 - VAR_3);", "q0_or_p0_org = LOAD_UB(VAR_0);", "q1_or_p1_org = LOAD_UB(VAR_0 + VAR_3);", "p0_asub_q0 = __msa_asub_u_b(p0_or_q0_org, q0_or_p0_org);", "p1_asub_p0 = __msa_asub_u_b(p1_or_q1_org, p0_or_q0_org);", "q1_asub_q0 = __msa_asub_u_b(q1_or_p1_org, q0_or_p0_org);", "is_less_than_alpha = (p0_asub_q0 < alpha);", "is_less_than_beta = (p1_asub_p0 < beta);", "is_less_than = is_less_than_beta & is_less_than_alpha;", "is_less_than_beta = (q1_asub_q0 < beta);", "is_less_than = is_less_than_beta & is_less_than;", "is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);", "if (!__msa_test_bz_v(is_less_than)) {", "p1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p1_or_q1_org);", "p0_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p0_or_q0_org);", "q0_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q0_or_p0_org);", "q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_or_p1_org);", "AVC_LOOP_FILTER_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_or_q0);", "AVC_LOOP_FILTER_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_or_p0);", "p0_or_q0 = (v8i16) __msa_pckev_b(zero, (v16i8) p0_or_q0);", "q0_or_p0 = (v8i16) __msa_pckev_b(zero, (v16i8) q0_or_p0);", "p0_or_q0_org =\n__msa_bmnz_v(p0_or_q0_org, (v16u8) p0_or_q0, is_less_than);", "q0_or_p0_org =\n__msa_bmnz_v(q0_or_p0_org, (v16u8) q0_or_p0, is_less_than);", "STORE_UB(q0_or_p0_org, VAR_0);", "STORE_UB(p0_or_q0_org, VAR_0 - VAR_3);", "}", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "#else\nif (unlikely(VAR_0->pr)) {", "gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "return;", "}", "#endif\n}" ]

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

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

[ "void FUNC_0(const uint8_t *VAR_0, uint8_t *VAR_1, unsigned VAR_2, const uint8_t *VAR_3)\n{", "unsigned VAR_4;", "for(VAR_4=0; VAR_4<VAR_2; VAR_4++)", "((uint16_t *)VAR_1)[VAR_4] = bswap_16(((uint16_t *)VAR_3)[ VAR_0[VAR_4] ]);", "}" ]

[ 1, 1, 0, 0, 0 ]

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

[ "static int FUNC_0(void *VAR_0)\n{", "return received_nb_signals > transcode_init_done;", "}" ]

[ 0, 1, 0 ]

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

[ "static int FUNC_0(void *VAR_0, AVIOContext *VAR_1, int VAR_2, int VAR_3, UID VAR_4, int64_t VAR_5)\n{", "MXFContext *mxf = VAR_0;", "switch (VAR_2) {", "case 0x1901:\nmxf->packages_count = avio_rb32(VAR_1);", "mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));", "if (!mxf->packages_refs)\nreturn AVERROR(ENOMEM);", "avio_skip(VAR_1, 4);", "avio_read(VAR_1, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));", "break;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9, 14 ], [ 16 ], [ 18, 20 ], [ 22 ], [ 24 ], [ 26 ], [ 28 ], [ 30 ], [ 32 ] ]

[ "void FUNC_0(Error **VAR_0)\n{", "Error *local_err = NULL;", "if (runstate_check(RUN_STATE_INMIGRATE)) {", "error_set(VAR_0, QERR_MIGRATION_EXPECTED);", "return;", "} else if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||", "runstate_check(RUN_STATE_SHUTDOWN)) {", "error_set(VAR_0, QERR_RESET_REQUIRED);", "return;", "} else if (runstate_check(RUN_STATE_SUSPENDED)) {", "return;", "}", "bdrv_iterate(iostatus_bdrv_it, NULL);", "bdrv_iterate(encrypted_bdrv_it, &local_err);", "if (local_err) {", "error_propagate(VAR_0, local_err);", "return;", "}", "vm_start();", "}" ]

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

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